From 9b6afcfeadc21d2283a1a8f5eb9bfdab646c9f88 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 07:28:32 +0800
Subject: [PATCH 0001/1059] Fix indent for convert_closure_to_fn

Example
---
```rust
fn foo() {
    {
        let closure = |$0| match () {
            () => {},
        };
        closure();
    }
}
```

**Before this PR**:

```rust
fn foo() {
    {
        fn closure() {
            match () {
                    () => {},
                }
        }
        closure();
    }
}
```

**After this PR**:

```rust
fn foo() {
    {
        fn closure() {
            match () {
                () => {},
            }
        }
        closure();
    }
}
```
---
 .../src/handlers/convert_closure_to_fn.rs     | 28 ++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
index 5f526ec89940..03f4e4749dbd 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
@@ -220,7 +220,7 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
             }
 
             let body = if wrap_body_in_block {
-                make::block_expr([], Some(body))
+                make::block_expr([], Some(body.reset_indent().indent(1.into())))
             } else {
                 ast::BlockExpr::cast(body.syntax().clone()).unwrap()
             };
@@ -969,6 +969,32 @@ fn closure() {
     }
     closure();
 }
+"#,
+        );
+        check_assist(
+            convert_closure_to_fn,
+            r#"
+//- minicore: copy
+fn foo() {
+    {
+        let closure = |$0| match () {
+            () => {},
+        };
+        closure();
+    }
+}
+"#,
+            r#"
+fn foo() {
+    {
+        fn closure() {
+            match () {
+                () => {},
+            }
+        }
+        closure();
+    }
+}
 "#,
         );
     }

From 9bc8e4eb09aab27c024b52fb461bcf3d8fa143a8 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 22:18:01 +0800
Subject: [PATCH 0002/1059] Add applicable on LetExpr for unwrap_tuple

Example
---
```rust
fn main() {
    if $0let (foo, bar) = ("Foo", "Bar") {
        code();
    }
}
```
->
```rust
fn main() {
    if let foo = "Foo"
        && let bar = "Bar" {
        code();
    }
}
```
---
 .../ide-assists/src/handlers/unwrap_tuple.rs  | 64 +++++++++++++------
 1 file changed, 44 insertions(+), 20 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
index 46f3e85e1234..2345075a52be 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
@@ -1,3 +1,6 @@
+use std::iter;
+
+use either::Either;
 use syntax::{
     AstNode, T,
     ast::{self, edit::AstNodeEdit},
@@ -24,11 +27,16 @@
 // ```
 pub(crate) fn unwrap_tuple(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let let_kw = ctx.find_token_syntax_at_offset(T![let])?;
-    let let_stmt = let_kw.parent().and_then(ast::LetStmt::cast)?;
-    let indent_level = let_stmt.indent_level().0 as usize;
-    let pat = let_stmt.pat()?;
-    let ty = let_stmt.ty();
-    let init = let_stmt.initializer()?;
+    let let_stmt = let_kw.parent().and_then(Either::<ast::LetStmt, ast::LetExpr>::cast)?;
+    let mut indent_level = let_stmt.indent_level();
+    let pat = either::for_both!(&let_stmt, it => it.pat())?;
+    let (ty, init, prefix, suffix) = match &let_stmt {
+        Either::Left(let_stmt) => (let_stmt.ty(), let_stmt.initializer()?, "", ";"),
+        Either::Right(let_expr) => {
+            indent_level = indent_level + 1;
+            (None, let_expr.expr()?, "&& ", "")
+        }
+    };
 
     // This only applies for tuple patterns, types, and initializers.
     let tuple_pat = match pat {
@@ -60,25 +68,19 @@ pub(crate) fn unwrap_tuple(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
         "Unwrap tuple",
         let_kw.text_range(),
         |edit| {
-            let indents = "    ".repeat(indent_level);
+            let mut decls = String::new();
 
             // If there is an ascribed type, insert that type for each declaration,
             // otherwise, omit that type.
-            if let Some(tys) = tuple_ty {
-                let mut zipped_decls = String::new();
-                for (pat, ty, expr) in
-                    itertools::izip!(tuple_pat.fields(), tys.fields(), tuple_init.fields())
-                {
-                    zipped_decls.push_str(&format!("{indents}let {pat}: {ty} = {expr};\n"))
-                }
-                edit.replace(parent.text_range(), zipped_decls.trim());
-            } else {
-                let mut zipped_decls = String::new();
-                for (pat, expr) in itertools::izip!(tuple_pat.fields(), tuple_init.fields()) {
-                    zipped_decls.push_str(&format!("{indents}let {pat} = {expr};\n"));
-                }
-                edit.replace(parent.text_range(), zipped_decls.trim());
+            let tys =
+                tuple_ty.into_iter().flat_map(|it| it.fields().map(Some)).chain(iter::repeat(None));
+            for (pat, ty, expr) in itertools::izip!(tuple_pat.fields(), tys, tuple_init.fields()) {
+                let ty = ty.map_or_else(String::new, |ty| format!(": {ty}"));
+                decls.push_str(&format!("{prefix}let {pat}{ty} = {expr}{suffix}\n{indent_level}"))
             }
+
+            let s = decls.trim();
+            edit.replace(parent.text_range(), s.strip_prefix(prefix).unwrap_or(s));
         },
     )
 }
@@ -123,6 +125,28 @@ fn main() {
         );
     }
 
+    #[test]
+    fn unwrap_tuples_in_let_expr() {
+        check_assist(
+            unwrap_tuple,
+            r#"
+fn main() {
+    if $0let (foo, bar) = ("Foo", "Bar") {
+        code();
+    }
+}
+"#,
+            r#"
+fn main() {
+    if let foo = "Foo"
+        && let bar = "Bar" {
+        code();
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn unwrap_tuple_with_types() {
         check_assist(

From 293e8d33a2b6279d1a82fad44a4321a77705fd9f Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 5 Sep 2025 15:56:48 +0800
Subject: [PATCH 0003/1059] Fix not applicable on empty struct for
 no_such_field

Example
---
```rust
fn main() {
    Foo { bar$0: false };
}
struct Foo {}
```
->
```rust
fn main() {
    Foo { bar: false };
}
struct Foo {
    bar: bool,
}
```
---
 .../src/handlers/no_such_field.rs             | 62 +++++++++++++++++--
 1 file changed, 56 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
index 0edab5e0b3b1..9ae99faa00a4 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
@@ -97,24 +97,36 @@ fn missing_record_expr_field_fixes(
         make::ty(&new_field_type.display_source_code(sema.db, module.into(), true).ok()?),
     );
 
-    let last_field = record_fields.fields().last()?;
-    let last_field_syntax = last_field.syntax();
-    let indent = IndentLevel::from_node(last_field_syntax);
+    let (indent, offset, postfix, needs_comma) =
+        if let Some(last_field) = record_fields.fields().last() {
+            let indent = IndentLevel::from_node(last_field.syntax());
+            let offset = last_field.syntax().text_range().end();
+            let needs_comma = !last_field.to_string().ends_with(',');
+            (indent, offset, String::new(), needs_comma)
+        } else {
+            let indent = IndentLevel::from_node(record_fields.syntax());
+            let offset = record_fields.l_curly_token()?.text_range().end();
+            let postfix = if record_fields.syntax().text().contains_char('\n') {
+                ",".into()
+            } else {
+                format!(",\n{indent}")
+            };
+            (indent + 1, offset, postfix, false)
+        };
 
     let mut new_field = new_field.to_string();
     if usage_file_id != def_file_id {
         new_field = format!("pub(crate) {new_field}");
     }
-    new_field = format!("\n{indent}{new_field}");
+    new_field = format!("\n{indent}{new_field}{postfix}");
 
-    let needs_comma = !last_field_syntax.to_string().ends_with(',');
     if needs_comma {
         new_field = format!(",{new_field}");
     }
 
     let source_change = SourceChange::from_text_edit(
         def_file_id.file_id(sema.db),
-        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
+        TextEdit::insert(offset, new_field),
     );
 
     return Some(vec![fix(
@@ -333,6 +345,44 @@ struct Foo {
         )
     }
 
+    #[test]
+    fn test_add_field_from_usage_with_empty_struct() {
+        check_fix(
+            r"
+fn main() {
+    Foo { bar$0: false };
+}
+struct Foo {}
+",
+            r"
+fn main() {
+    Foo { bar: false };
+}
+struct Foo {
+    bar: bool,
+}
+",
+        );
+
+        check_fix(
+            r"
+fn main() {
+    Foo { bar$0: false };
+}
+struct Foo {
+}
+",
+            r"
+fn main() {
+    Foo { bar: false };
+}
+struct Foo {
+    bar: bool,
+}
+",
+        );
+    }
+
     #[test]
     fn test_add_field_in_other_file_from_usage() {
         check_fix(

From 04b232a2576eaebd233815a6a670f3ae800d9827 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 7 Sep 2025 16:13:49 +0800
Subject: [PATCH 0004/1059] Add wrap multiple attr for wrap_unwrap_cfg_attr

Example
---
```rust
pub struct Test {
    $0#[foo]
    #[bar]$0
    test: u32,
}
```
->
```rust
pub struct Test {
    #[cfg_attr($0, foo, bar)]
    test: u32,
}
```
---
 .../src/handlers/wrap_unwrap_cfg_attr.rs      | 138 +++++++++++++-----
 1 file changed, 101 insertions(+), 37 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/wrap_unwrap_cfg_attr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/wrap_unwrap_cfg_attr.rs
index 7d5740b748be..36df4af31d5e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/wrap_unwrap_cfg_attr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/wrap_unwrap_cfg_attr.rs
@@ -2,7 +2,7 @@
 use itertools::Itertools;
 use syntax::{
     NodeOrToken, SyntaxToken, T, TextRange, algo,
-    ast::{self, AstNode, make, syntax_factory::SyntaxFactory},
+    ast::{self, AstNode, edit::AstNodeEdit, make, syntax_factory::SyntaxFactory},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -27,7 +27,7 @@
 
 enum WrapUnwrapOption {
     WrapDerive { derive: TextRange, attr: ast::Attr },
-    WrapAttr(ast::Attr),
+    WrapAttr(Vec<ast::Attr>),
 }
 
 /// Attempts to get the derive attribute from a derive attribute list
@@ -102,9 +102,9 @@ fn attempt_get_derive(attr: ast::Attr, ident: SyntaxToken) -> WrapUnwrapOption {
     if ident.parent().and_then(ast::TokenTree::cast).is_none()
         || !attr.simple_name().map(|v| v.eq("derive")).unwrap_or_default()
     {
-        WrapUnwrapOption::WrapAttr(attr)
+        WrapUnwrapOption::WrapAttr(vec![attr])
     } else {
-        attempt_attr().unwrap_or(WrapUnwrapOption::WrapAttr(attr))
+        attempt_attr().unwrap_or_else(|| WrapUnwrapOption::WrapAttr(vec![attr]))
     }
 }
 pub(crate) fn wrap_unwrap_cfg_attr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
@@ -118,13 +118,27 @@ pub(crate) fn wrap_unwrap_cfg_attr(acc: &mut Assists, ctx: &AssistContext<'_>) -
                 Some(attempt_get_derive(attr, ident))
             }
 
-            (Some(attr), _) => Some(WrapUnwrapOption::WrapAttr(attr)),
+            (Some(attr), _) => Some(WrapUnwrapOption::WrapAttr(vec![attr])),
             _ => None,
         }
     } else {
         let covering_element = ctx.covering_element();
         match covering_element {
-            NodeOrToken::Node(node) => ast::Attr::cast(node).map(WrapUnwrapOption::WrapAttr),
+            NodeOrToken::Node(node) => {
+                if let Some(attr) = ast::Attr::cast(node.clone()) {
+                    Some(WrapUnwrapOption::WrapAttr(vec![attr]))
+                } else {
+                    let attrs = node
+                        .children()
+                        .filter(|it| it.text_range().intersect(ctx.selection_trimmed()).is_some())
+                        .map(ast::Attr::cast)
+                        .collect::<Option<Vec<_>>>()?;
+                    if attrs.is_empty() {
+                        return None;
+                    }
+                    Some(WrapUnwrapOption::WrapAttr(attrs))
+                }
+            }
             NodeOrToken::Token(ident) if ident.kind() == syntax::T![ident] => {
                 let attr = ident.parent_ancestors().find_map(ast::Attr::cast)?;
                 Some(attempt_get_derive(attr, ident))
@@ -133,10 +147,12 @@ pub(crate) fn wrap_unwrap_cfg_attr(acc: &mut Assists, ctx: &AssistContext<'_>) -
         }
     }?;
     match option {
-        WrapUnwrapOption::WrapAttr(attr) if attr.simple_name().as_deref() == Some("cfg_attr") => {
-            unwrap_cfg_attr(acc, attr)
-        }
-        WrapUnwrapOption::WrapAttr(attr) => wrap_cfg_attr(acc, ctx, attr),
+        WrapUnwrapOption::WrapAttr(attrs) => match &attrs[..] {
+            [attr] if attr.simple_name().as_deref() == Some("cfg_attr") => {
+                unwrap_cfg_attr(acc, attrs.into_iter().next().unwrap())
+            }
+            _ => wrap_cfg_attrs(acc, ctx, attrs),
+        },
         WrapUnwrapOption::WrapDerive { derive, attr } => wrap_derive(acc, ctx, attr, derive),
     }
 }
@@ -220,40 +236,51 @@ fn wrap_derive(
     );
     Some(())
 }
-fn wrap_cfg_attr(acc: &mut Assists, ctx: &AssistContext<'_>, attr: ast::Attr) -> Option<()> {
-    let range = attr.syntax().text_range();
-    let path = attr.path()?;
+fn wrap_cfg_attrs(acc: &mut Assists, ctx: &AssistContext<'_>, attrs: Vec<ast::Attr>) -> Option<()> {
+    let (first_attr, last_attr) = (attrs.first()?, attrs.last()?);
+    let range = first_attr.syntax().text_range().cover(last_attr.syntax().text_range());
+    let path_attrs =
+        attrs.iter().map(|attr| Some((attr.path()?, attr.clone()))).collect::<Option<Vec<_>>>()?;
     let handle_source_change = |edit: &mut SourceChangeBuilder| {
         let make = SyntaxFactory::with_mappings();
-        let mut editor = edit.make_editor(attr.syntax());
-        let mut raw_tokens =
-            vec![NodeOrToken::Token(make.token(T![,])), NodeOrToken::Token(make.whitespace(" "))];
-        path.syntax().descendants_with_tokens().for_each(|it| {
-            if let NodeOrToken::Token(token) = it {
-                raw_tokens.push(NodeOrToken::Token(token));
-            }
-        });
-        if let Some(meta) = attr.meta() {
-            if let (Some(eq), Some(expr)) = (meta.eq_token(), meta.expr()) {
-                raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));
-                raw_tokens.push(NodeOrToken::Token(eq));
-                raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));
+        let mut editor = edit.make_editor(first_attr.syntax());
+        let mut raw_tokens = vec![];
+        for (path, attr) in path_attrs {
+            raw_tokens.extend([
+                NodeOrToken::Token(make.token(T![,])),
+                NodeOrToken::Token(make.whitespace(" ")),
+            ]);
+            path.syntax().descendants_with_tokens().for_each(|it| {
+                if let NodeOrToken::Token(token) = it {
+                    raw_tokens.push(NodeOrToken::Token(token));
+                }
+            });
+            if let Some(meta) = attr.meta() {
+                if let (Some(eq), Some(expr)) = (meta.eq_token(), meta.expr()) {
+                    raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));
+                    raw_tokens.push(NodeOrToken::Token(eq));
+                    raw_tokens.push(NodeOrToken::Token(make.whitespace(" ")));
 
-                expr.syntax().descendants_with_tokens().for_each(|it| {
-                    if let NodeOrToken::Token(token) = it {
-                        raw_tokens.push(NodeOrToken::Token(token));
-                    }
-                });
-            } else if let Some(tt) = meta.token_tree() {
-                raw_tokens.extend(tt.token_trees_and_tokens());
+                    expr.syntax().descendants_with_tokens().for_each(|it| {
+                        if let NodeOrToken::Token(token) = it {
+                            raw_tokens.push(NodeOrToken::Token(token));
+                        }
+                    });
+                } else if let Some(tt) = meta.token_tree() {
+                    raw_tokens.extend(tt.token_trees_and_tokens());
+                }
             }
         }
         let meta =
             make.meta_token_tree(make.ident_path("cfg_attr"), make.token_tree(T!['('], raw_tokens));
-        let cfg_attr =
-            if attr.excl_token().is_some() { make.attr_inner(meta) } else { make.attr_outer(meta) };
+        let cfg_attr = if first_attr.excl_token().is_some() {
+            make.attr_inner(meta)
+        } else {
+            make.attr_outer(meta)
+        };
 
-        editor.replace(attr.syntax(), cfg_attr.syntax());
+        let syntax_range = first_attr.syntax().clone().into()..=last_attr.syntax().clone().into();
+        editor.replace_all(syntax_range, vec![cfg_attr.syntax().clone().into()]);
 
         if let Some(snippet_cap) = ctx.config.snippet_cap
             && let Some(first_meta) =
@@ -332,7 +359,8 @@ fn unwrap_cfg_attr(acc: &mut Assists, attr: ast::Attr) -> Option<()> {
         return None;
     }
     let handle_source_change = |f: &mut SourceChangeBuilder| {
-        let inner_attrs = inner_attrs.iter().map(|it| it.to_string()).join("\n");
+        let inner_attrs =
+            inner_attrs.iter().map(|it| it.to_string()).join(&format!("\n{}", attr.indent_level()));
         f.replace(range, inner_attrs);
     };
     acc.add(
@@ -414,6 +442,42 @@ pub struct Test {
             }
             "#,
         );
+        check_assist(
+            wrap_unwrap_cfg_attr,
+            r#"
+            pub struct Test {
+                #[other_attr]
+                $0#[foo]
+                #[bar]$0
+                #[other_attr]
+                test: u32,
+            }
+            "#,
+            r#"
+            pub struct Test {
+                #[other_attr]
+                #[cfg_attr($0, foo, bar)]
+                #[other_attr]
+                test: u32,
+            }
+            "#,
+        );
+        check_assist(
+            wrap_unwrap_cfg_attr,
+            r#"
+            pub struct Test {
+                #[cfg_attr(debug_assertions$0, foo, bar)]
+                test: u32,
+            }
+            "#,
+            r#"
+            pub struct Test {
+                #[foo]
+                #[bar]
+                test: u32,
+            }
+            "#,
+        );
     }
     #[test]
     fn to_from_eq_attr() {

From 2b3e3190a22650fe0874e482afb3de1ab36d678b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 8 Sep 2025 14:09:48 +0800
Subject: [PATCH 0005/1059] Add nested lifetime support for
 add_lifetime_to_type

Changes:

- Add nested lifetime support
- Add explicit infer lifetime support
- Change assist type to `quickfix`

Example
---
```rust
struct Foo {
    a: &$0i32,
    b: &'_ i32,
    c: (&i32, Bar<'_>),
}
```

**Before this PR**:

```rust
struct Foo<'a> {
    a: &'a i32,
    b: &'_ i32,
    c: (&i32, Bar<'_>),
}
```

**After this PR**:

```rust
struct Foo<'a> {
    a: &'a i32,
    b: &'a i32,
    c: (&'a i32, Bar<'a>),
}
```
---
 .../src/handlers/add_lifetime_to_type.rs      | 115 +++++++++++-------
 1 file changed, 68 insertions(+), 47 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_lifetime_to_type.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_lifetime_to_type.rs
index 27dbdcf2c4d5..265ee3d2d4e7 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_lifetime_to_type.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_lifetime_to_type.rs
@@ -1,4 +1,7 @@
-use syntax::ast::{self, AstNode, HasGenericParams, HasName};
+use syntax::{
+    SyntaxKind, SyntaxNode, SyntaxToken,
+    ast::{self, AstNode, HasGenericParams, HasName},
+};
 
 use crate::{AssistContext, AssistId, Assists};
 
@@ -21,7 +24,7 @@
 // ```
 pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let ref_type_focused = ctx.find_node_at_offset::<ast::RefType>()?;
-    if ref_type_focused.lifetime().is_some() {
+    if ref_type_focused.lifetime().is_some_and(|lifetime| lifetime.text() != "'_") {
         return None;
     }
 
@@ -34,10 +37,10 @@ pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext<'_>) -
         return None;
     }
 
-    let ref_types = fetch_borrowed_types(&node)?;
+    let changes = fetch_borrowed_types(&node)?;
     let target = node.syntax().text_range();
 
-    acc.add(AssistId::generate("add_lifetime_to_type"), "Add lifetime", target, |builder| {
+    acc.add(AssistId::quick_fix("add_lifetime_to_type"), "Add lifetime", target, |builder| {
         match node.generic_param_list() {
             Some(gen_param) => {
                 if let Some(left_angle) = gen_param.l_angle_token() {
@@ -51,16 +54,21 @@ pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext<'_>) -
             }
         }
 
-        for ref_type in ref_types {
-            if let Some(amp_token) = ref_type.amp_token() {
-                builder.insert(amp_token.text_range().end(), "'a ");
+        for change in changes {
+            match change {
+                Change::Replace(it) => {
+                    builder.replace(it.text_range(), "'a");
+                }
+                Change::Insert(it) => {
+                    builder.insert(it.text_range().end(), "'a ");
+                }
             }
         }
     })
 }
 
-fn fetch_borrowed_types(node: &ast::Adt) -> Option<Vec<ast::RefType>> {
-    let ref_types: Vec<ast::RefType> = match node {
+fn fetch_borrowed_types(node: &ast::Adt) -> Option<Vec<Change>> {
+    let ref_types: Vec<_> = match node {
         ast::Adt::Enum(enum_) => {
             let variant_list = enum_.variant_list()?;
             variant_list
@@ -79,55 +87,50 @@ fn fetch_borrowed_types(node: &ast::Adt) -> Option<Vec<ast::RefType>> {
         }
         ast::Adt::Union(un) => {
             let record_field_list = un.record_field_list()?;
-            record_field_list
-                .fields()
-                .filter_map(|r_field| {
-                    if let ast::Type::RefType(ref_type) = r_field.ty()?
-                        && ref_type.lifetime().is_none()
-                    {
-                        return Some(ref_type);
-                    }
-
-                    None
-                })
-                .collect()
+            find_ref_types_from_field_list(&record_field_list.into())?
         }
     };
 
     if ref_types.is_empty() { None } else { Some(ref_types) }
 }
 
-fn find_ref_types_from_field_list(field_list: &ast::FieldList) -> Option<Vec<ast::RefType>> {
-    let ref_types: Vec<ast::RefType> = match field_list {
-        ast::FieldList::RecordFieldList(record_list) => record_list
-            .fields()
-            .filter_map(|f| {
-                if let ast::Type::RefType(ref_type) = f.ty()?
-                    && ref_type.lifetime().is_none()
-                {
-                    return Some(ref_type);
-                }
-
-                None
-            })
-            .collect(),
-        ast::FieldList::TupleFieldList(tuple_field_list) => tuple_field_list
-            .fields()
-            .filter_map(|f| {
-                if let ast::Type::RefType(ref_type) = f.ty()?
-                    && ref_type.lifetime().is_none()
-                {
-                    return Some(ref_type);
-                }
-
-                None
-            })
-            .collect(),
+fn find_ref_types_from_field_list(field_list: &ast::FieldList) -> Option<Vec<Change>> {
+    let ref_types: Vec<_> = match field_list {
+        ast::FieldList::RecordFieldList(record_list) => {
+            record_list.fields().flat_map(|f| infer_lifetimes(f.syntax())).collect()
+        }
+        ast::FieldList::TupleFieldList(tuple_field_list) => {
+            tuple_field_list.fields().flat_map(|f| infer_lifetimes(f.syntax())).collect()
+        }
     };
 
     if ref_types.is_empty() { None } else { Some(ref_types) }
 }
 
+enum Change {
+    Replace(SyntaxToken),
+    Insert(SyntaxToken),
+}
+
+fn infer_lifetimes(node: &SyntaxNode) -> Vec<Change> {
+    node.children()
+        .filter(|it| !matches!(it.kind(), SyntaxKind::FN_PTR_TYPE | SyntaxKind::TYPE_BOUND_LIST))
+        .flat_map(|it| {
+            infer_lifetimes(&it)
+                .into_iter()
+                .chain(ast::Lifetime::cast(it.clone()).and_then(|lt| {
+                    lt.lifetime_ident_token().filter(|lt| lt.text() == "'_").map(Change::Replace)
+                }))
+                .chain(
+                    ast::RefType::cast(it)
+                        .filter(|ty| ty.lifetime().is_none())
+                        .and_then(|ty| ty.amp_token())
+                        .map(Change::Insert),
+                )
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -164,6 +167,24 @@ fn add_lifetime_to_struct() {
         check_assist_not_applicable(add_lifetime_to_type, r#"struct Foo { a: &'a$0 i32 }"#);
     }
 
+    #[test]
+    fn add_lifetime_to_nested_types() {
+        check_assist(
+            add_lifetime_to_type,
+            r#"struct Foo { a: &$0i32, b: &(&i32, fn(&str) -> &str) }"#,
+            r#"struct Foo<'a> { a: &'a i32, b: &'a (&'a i32, fn(&str) -> &str) }"#,
+        );
+    }
+
+    #[test]
+    fn add_lifetime_to_explicit_infer_lifetime() {
+        check_assist(
+            add_lifetime_to_type,
+            r#"struct Foo { a: &'_ $0i32, b: &'_ (&'_ i32, fn(&str) -> &str) }"#,
+            r#"struct Foo<'a> { a: &'a i32, b: &'a (&'a i32, fn(&str) -> &str) }"#,
+        );
+    }
+
     #[test]
     fn add_lifetime_to_enum() {
         check_assist(

From 5cd99fb215e58a881900e1c25af15e0bd7707023 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 29 Sep 2025 18:12:38 +0800
Subject: [PATCH 0006/1059] Add fixes for non_exhaustive_let diagnostic

Example
---
```rust
fn foo() {
    let None$0 = Some(5);
}
```

->

```rust
fn foo() {
    let None = Some(5) else { return };
}
```
---
 .../src/handlers/non_exhaustive_let.rs        | 185 +++++++++++++++++-
 1 file changed, 178 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
index c86ecd2f03b9..346a59ed528d 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
@@ -1,4 +1,11 @@
-use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
+use either::Either;
+use hir::Semantics;
+use ide_db::text_edit::TextEdit;
+use ide_db::ty_filter::TryEnum;
+use ide_db::{RootDatabase, source_change::SourceChange};
+use syntax::{AstNode, ast};
+
+use crate::{Assist, Diagnostic, DiagnosticCode, DiagnosticsContext, fix};
 
 // Diagnostic: non-exhaustive-let
 //
@@ -15,11 +22,68 @@ pub(crate) fn non_exhaustive_let(
         d.pat.map(Into::into),
     )
     .stable()
+    .with_fixes(fixes(&ctx.sema, d))
+}
+fn fixes(sema: &Semantics<'_, RootDatabase>, d: &hir::NonExhaustiveLet) -> Option<Vec<Assist>> {
+    let root = sema.parse_or_expand(d.pat.file_id);
+    let pat = d.pat.value.to_node(&root);
+    let let_stmt = ast::LetStmt::cast(pat.syntax().parent()?)?;
+    let early_node = let_stmt.syntax().ancestors().find_map(AstNode::cast)?;
+    let early_text = early_text(sema, &early_node);
+
+    if let_stmt.let_else().is_some() {
+        return None;
+    }
+
+    let file_id = d.pat.file_id.file_id()?.file_id(sema.db);
+    let semicolon = if let_stmt.semicolon_token().is_none() { ";" } else { "" };
+    let else_block = format!(" else {{ {early_text} }}{semicolon}");
+    let insert_offset = let_stmt
+        .semicolon_token()
+        .map(|it| it.text_range().start())
+        .unwrap_or_else(|| let_stmt.syntax().text_range().end());
+
+    let source_change =
+        SourceChange::from_text_edit(file_id, TextEdit::insert(insert_offset, else_block));
+    let target = sema.original_range(let_stmt.syntax()).range;
+    Some(vec![fix("add_let_else_block", "Add let-else block", source_change, target)])
+}
+
+fn early_text(
+    sema: &Semantics<'_, RootDatabase>,
+    early_node: &Either<ast::AnyHasLoopBody, Either<ast::Fn, ast::ClosureExpr>>,
+) -> &'static str {
+    match early_node {
+        Either::Left(_any_loop) => "continue",
+        Either::Right(Either::Left(fn_)) => sema
+            .to_def(fn_)
+            .map(|fn_def| fn_def.ret_type(sema.db))
+            .map(|ty| return_text(&ty, sema))
+            .unwrap_or("return"),
+        Either::Right(Either::Right(closure)) => closure
+            .body()
+            .and_then(|expr| sema.type_of_expr(&expr))
+            .map(|ty| return_text(&ty.adjusted(), sema))
+            .unwrap_or("return"),
+    }
+}
+
+fn return_text(ty: &hir::Type<'_>, sema: &Semantics<'_, RootDatabase>) -> &'static str {
+    if ty.is_unit() {
+        "return"
+    } else if let Some(try_enum) = TryEnum::from_ty(sema, ty) {
+        match try_enum {
+            TryEnum::Option => "return None",
+            TryEnum::Result => "return Err($0)",
+        }
+    } else {
+        "return $0"
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::check_diagnostics;
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn option_nonexhaustive() {
@@ -28,7 +92,7 @@ fn option_nonexhaustive() {
 //- minicore: option
 fn main() {
     let None = Some(5);
-      //^^^^ error: non-exhaustive pattern: `Some(_)` not covered
+      //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered
 }
 "#,
         );
@@ -54,7 +118,7 @@ fn option_nonexhaustive_inside_blocks() {
 fn main() {
     '_a: {
         let None = Some(5);
-          //^^^^ error: non-exhaustive pattern: `Some(_)` not covered
+          //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered
     }
 }
 "#,
@@ -66,7 +130,7 @@ fn main() {
 fn main() {
     let _ = async {
         let None = Some(5);
-          //^^^^ error: non-exhaustive pattern: `Some(_)` not covered
+          //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered
     };
 }
 "#,
@@ -78,7 +142,7 @@ fn main() {
 fn main() {
     unsafe {
         let None = Some(5);
-          //^^^^ error: non-exhaustive pattern: `Some(_)` not covered
+          //^^^^ 💡 error: non-exhaustive pattern: `Some(_)` not covered
     }
 }
 "#,
@@ -101,7 +165,7 @@ fn test(x: Result<i32, !>) {
 //- minicore: result
 fn test(x: Result<i32, &'static !>) {
     let Ok(_y) = x;
-      //^^^^^^ error: non-exhaustive pattern: `Err(_)` not covered
+      //^^^^^^ 💡 error: non-exhaustive pattern: `Err(_)` not covered
 }
 "#,
         );
@@ -132,6 +196,113 @@ fn foo(v: Enum<()>) {
         );
     }
 
+    #[test]
+    fn fix_return_in_loop() {
+        check_fix(
+            r#"
+//- minicore: option
+fn foo() {
+    while cond {
+        let None$0 = Some(5);
+    }
+}
+"#,
+            r#"
+fn foo() {
+    while cond {
+        let None = Some(5) else { continue };
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fix_return_in_fn() {
+        check_fix(
+            r#"
+//- minicore: option
+fn foo() {
+    let None$0 = Some(5);
+}
+"#,
+            r#"
+fn foo() {
+    let None = Some(5) else { return };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fix_return_in_incomplete_let() {
+        check_fix(
+            r#"
+//- minicore: option
+fn foo() {
+    let None$0 = Some(5)
+}
+"#,
+            r#"
+fn foo() {
+    let None = Some(5) else { return };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fix_return_in_closure() {
+        check_fix(
+            r#"
+//- minicore: option
+fn foo() -> Option<()> {
+    let _f = || {
+        let None$0 = Some(5);
+    };
+}
+"#,
+            r#"
+fn foo() -> Option<()> {
+    let _f = || {
+        let None = Some(5) else { return };
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fix_return_try_in_fn() {
+        check_fix(
+            r#"
+//- minicore: option
+fn foo() -> Option<()> {
+    let None$0 = Some(5);
+}
+"#,
+            r#"
+fn foo() -> Option<()> {
+    let None = Some(5) else { return None };
+}
+"#,
+        );
+
+        check_fix(
+            r#"
+//- minicore: option, result
+fn foo() -> Result<(), i32> {
+    let None$0 = Some(5);
+}
+"#,
+            r#"
+fn foo() -> Result<(), i32> {
+    let None = Some(5) else { return Err($0) };
+}
+"#,
+        );
+    }
+
     #[test]
     fn regression_20259() {
         check_diagnostics(

From c55a2249cd3014c3f14a782c292adf3bee32f7f9 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 26 Oct 2025 17:16:47 +0800
Subject: [PATCH 0007/1059] Support unmap macro expansion

---
 .../src/handlers/non_exhaustive_let.rs        | 43 ++++++++++++++++---
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
index 346a59ed528d..bc10e82854f5 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/non_exhaustive_let.rs
@@ -24,24 +24,30 @@ pub(crate) fn non_exhaustive_let(
     .stable()
     .with_fixes(fixes(&ctx.sema, d))
 }
+
 fn fixes(sema: &Semantics<'_, RootDatabase>, d: &hir::NonExhaustiveLet) -> Option<Vec<Assist>> {
     let root = sema.parse_or_expand(d.pat.file_id);
     let pat = d.pat.value.to_node(&root);
     let let_stmt = ast::LetStmt::cast(pat.syntax().parent()?)?;
-    let early_node = let_stmt.syntax().ancestors().find_map(AstNode::cast)?;
+    let early_node =
+        sema.ancestors_with_macros(let_stmt.syntax().clone()).find_map(AstNode::cast)?;
     let early_text = early_text(sema, &early_node);
 
     if let_stmt.let_else().is_some() {
         return None;
     }
-
-    let file_id = d.pat.file_id.file_id()?.file_id(sema.db);
+    let hir::FileRangeWrapper { file_id, range } = sema.original_range_opt(let_stmt.syntax())?;
+    let insert_offset = if let Some(semicolon) = let_stmt.semicolon_token()
+        && let Some(token) = sema.parse(file_id).syntax().token_at_offset(range.end()).left_biased()
+        && token.kind() == semicolon.kind()
+    {
+        token.text_range().start()
+    } else {
+        range.end()
+    };
     let semicolon = if let_stmt.semicolon_token().is_none() { ";" } else { "" };
     let else_block = format!(" else {{ {early_text} }}{semicolon}");
-    let insert_offset = let_stmt
-        .semicolon_token()
-        .map(|it| it.text_range().start())
-        .unwrap_or_else(|| let_stmt.syntax().text_range().end());
+    let file_id = file_id.file_id(sema.db);
 
     let source_change =
         SourceChange::from_text_edit(file_id, TextEdit::insert(insert_offset, else_block));
@@ -234,6 +240,29 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn fix_return_in_macro_expanded() {
+        check_fix(
+            r#"
+//- minicore: option
+macro_rules! identity { ($($t:tt)*) => { $($t)* }; }
+fn foo() {
+    identity! {
+        let None$0 = Some(5);
+    }
+}
+"#,
+            r#"
+macro_rules! identity { ($($t:tt)*) => { $($t)* }; }
+fn foo() {
+    identity! {
+        let None = Some(5) else { return };
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn fix_return_in_incomplete_let() {
         check_fix(

From c1b51dd002ee13514355987ce77fa600584eb3a5 Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Wed, 5 Nov 2025 18:49:44 -0800
Subject: [PATCH 0008/1059] In `Option::get_or_insert_with()`, forget the
 `None` instead of dropping it.

This allows eliminating the `T: [const] Destruct` bounds and avoids
generating an implicit `drop_in_place::<Option<T>>()` that will never do
anything.

Ideally, the compiler would prove that that drop is not necessary
itself, but it currently doesn't, even with `const_precise_live_drops`
enabled.
---
 library/core/src/option.rs        | 21 ++++++++++++++++++---
 library/coretests/tests/option.rs | 24 ++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index e3c4758bc6af..df92fb3955a9 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -1776,7 +1776,7 @@ pub fn get_or_insert(&mut self, value: T) -> &mut T {
     #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
     pub const fn get_or_insert_default(&mut self) -> &mut T
     where
-        T: [const] Default + [const] Destruct,
+        T: [const] Default,
     {
         self.get_or_insert_with(T::default)
     }
@@ -1804,10 +1804,25 @@ pub const fn get_or_insert_default(&mut self) -> &mut T
     pub const fn get_or_insert_with<F>(&mut self, f: F) -> &mut T
     where
         F: [const] FnOnce() -> T + [const] Destruct,
-        T: [const] Destruct,
     {
         if let None = self {
-            *self = Some(f());
+            // The effect of the following statement is identical to
+            //     *self = Some(f());
+            // except that it does not drop the old value of `*self`. This is not a leak, because
+            // we just checked that the old value is `None`, which contains no fields to drop.
+            // This implementation strategy
+            //
+            // * avoids needing a `T: [const] Destruct` bound, to the benefit of `const` callers,
+            // * and avoids possibly compiling needless drop code (as would sometimes happen in the
+            //   previous implementation), to the benefit of non-`const` callers.
+            //
+            // FIXME(const-hack): It would be nice if this weird trick were made obsolete
+            // (though that is likely to be hard/wontfix).
+            //
+            // It could also be expressed as `unsafe { core::ptr::write(self, Some(f())) }`, but
+            // no reason is currently known to use additional unsafe code here.
+
+            mem::forget(mem::replace(self, Some(f())));
         }
 
         // SAFETY: a `None` variant for `self` would have been replaced by a `Some`
diff --git a/library/coretests/tests/option.rs b/library/coretests/tests/option.rs
index fc0f82ad6bb3..3df7afb4f3be 100644
--- a/library/coretests/tests/option.rs
+++ b/library/coretests/tests/option.rs
@@ -495,6 +495,30 @@ const fn option_const_mut() {
     */
 }
 
+/// Test that `Option::get_or_insert_default` is usable in const contexts, including with types that
+/// do not satisfy `T: const Destruct`.
+#[test]
+fn const_get_or_insert_default() {
+    const OPT_DEFAULT: Option<Vec<bool>> = {
+        let mut x = None;
+        x.get_or_insert_default();
+        x
+    };
+    assert!(OPT_DEFAULT.is_some());
+}
+
+/// Test that `Option::get_or_insert_with` is usable in const contexts, including with types that
+/// do not satisfy `T: const Destruct`.
+#[test]
+fn const_get_or_insert_with() {
+    const OPT_WITH: Option<Vec<bool>> = {
+        let mut x = None;
+        x.get_or_insert_with(Vec::new);
+        x
+    };
+    assert!(OPT_WITH.is_some());
+}
+
 #[test]
 fn test_unwrap_drop() {
     struct Dtor<'a> {

From 440cb96934cbc71daee8b6c0cde9271090ed3bde Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 7 Nov 2025 21:55:50 +0800
Subject: [PATCH 0009/1059] Support WhileExpr and ForExpr for add_label_to_loop

Example
---
```rust
fn main() {
    for$0 _ in 0..5 {
        break;
        continue;
    }
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
fn main() {
    'l: for _ in 0..5 {
        break 'l;
        continue 'l;
    }
}
```
---
 .../src/handlers/add_label_to_loop.rs         | 81 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
index b84ad24cfcef..ece927fce2cd 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
@@ -35,9 +35,9 @@
 // }
 // ```
 pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
-    let loop_kw = ctx.find_token_syntax_at_offset(T![loop])?;
-    let loop_expr = loop_kw.parent().and_then(ast::LoopExpr::cast)?;
-    if loop_expr.label().is_some() {
+    let loop_expr = ctx.find_node_at_offset::<ast::AnyHasLoopBody>()?;
+    let loop_kw = loop_token(&loop_expr)?;
+    if loop_expr.label().is_some() || !loop_kw.text_range().contains_inclusive(ctx.offset()) {
         return None;
     }
 
@@ -80,6 +80,14 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
     )
 }
 
+fn loop_token(loop_expr: &ast::AnyHasLoopBody) -> Option<syntax::SyntaxToken> {
+    loop_expr
+        .syntax()
+        .children_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|it| matches!(it.kind(), T![for] | T![loop] | T![while]))
+}
+
 fn insert_label_after_token(
     editor: &mut SyntaxEditor,
     make: &SyntaxFactory,
@@ -123,6 +131,48 @@ fn main() {
         );
     }
 
+    #[test]
+    fn add_label_to_while_expr() {
+        check_assist(
+            add_label_to_loop,
+            r#"
+fn main() {
+    while$0 true {
+        break;
+        continue;
+    }
+}"#,
+            r#"
+fn main() {
+    ${1:'l}: while true {
+        break ${2:'l};
+        continue ${0:'l};
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn add_label_to_for_expr() {
+        check_assist(
+            add_label_to_loop,
+            r#"
+fn main() {
+    for$0 _ in 0..5 {
+        break;
+        continue;
+    }
+}"#,
+            r#"
+fn main() {
+    ${1:'l}: for _ in 0..5 {
+        break ${2:'l};
+        continue ${0:'l};
+    }
+}"#,
+        );
+    }
+
     #[test]
     fn add_label_to_outer_loop() {
         check_assist(
@@ -191,6 +241,31 @@ fn main() {
         break 'l;
         continue 'l;
     }
+}"#,
+        );
+    }
+
+    #[test]
+    fn do_not_add_label_if_outside_keyword() {
+        check_assist_not_applicable(
+            add_label_to_loop,
+            r#"
+fn main() {
+    'l: loop {$0
+        break 'l;
+        continue 'l;
+    }
+}"#,
+        );
+
+        check_assist_not_applicable(
+            add_label_to_loop,
+            r#"
+fn main() {
+    'l: while true {$0
+        break 'l;
+        continue 'l;
+    }
 }"#,
         );
     }

From f4334bb19c847eb9e37d42a20c153ea81e74ee80 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 23 Dec 2025 16:49:57 +0800
Subject: [PATCH 0010/1059] stdx indent and dedent utils

---
 .../rust-analyzer/crates/stdx/src/lib.rs      | 57 +++++++++++++++++--
 1 file changed, 51 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/stdx/src/lib.rs b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
index 5fa007416371..bda933bb4032 100644
--- a/src/tools/rust-analyzer/crates/stdx/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
@@ -207,12 +207,7 @@ pub fn trim_indent(mut text: &str) -> String {
     if text.starts_with('\n') {
         text = &text[1..];
     }
-    let indent = text
-        .lines()
-        .filter(|it| !it.trim().is_empty())
-        .map(|it| it.len() - it.trim_start().len())
-        .min()
-        .unwrap_or(0);
+    let indent = indent_of(text);
     text.split_inclusive('\n')
         .map(
             |line| {
@@ -222,6 +217,25 @@ pub fn trim_indent(mut text: &str) -> String {
         .collect()
 }
 
+#[must_use]
+fn indent_of(text: &str) -> usize {
+    text.lines()
+        .filter(|it| !it.trim().is_empty())
+        .map(|it| it.len() - it.trim_start().len())
+        .min()
+        .unwrap_or(0)
+}
+
+#[must_use]
+pub fn dedent_by(spaces: usize, text: &str) -> String {
+    text.split_inclusive('\n')
+        .map(|line| {
+            let trimmed = line.trim_start_matches(' ');
+            if line.len() - trimmed.len() <= spaces { trimmed } else { &line[spaces..] }
+        })
+        .collect()
+}
+
 pub fn equal_range_by<T, F>(slice: &[T], mut key: F) -> ops::Range<usize>
 where
     F: FnMut(&T) -> Ordering,
@@ -352,6 +366,37 @@ fn main() {
         );
     }
 
+    #[test]
+    fn test_dedent() {
+        assert_eq!(dedent_by(0, ""), "");
+        assert_eq!(dedent_by(1, ""), "");
+        assert_eq!(dedent_by(2, ""), "");
+        assert_eq!(dedent_by(0, "foo"), "foo");
+        assert_eq!(dedent_by(2, "foo"), "foo");
+        assert_eq!(dedent_by(2, "  foo"), "foo");
+        assert_eq!(dedent_by(2, "    foo"), "  foo");
+        assert_eq!(dedent_by(2, "    foo\nbar"), "  foo\nbar");
+        assert_eq!(dedent_by(2, "foo\n    bar"), "foo\n  bar");
+        assert_eq!(dedent_by(2, "foo\n\n    bar"), "foo\n\n  bar");
+        assert_eq!(dedent_by(2, "foo\n.\n    bar"), "foo\n.\n  bar");
+        assert_eq!(dedent_by(2, "foo\n .\n    bar"), "foo\n.\n  bar");
+        assert_eq!(dedent_by(2, "foo\n   .\n    bar"), "foo\n .\n  bar");
+    }
+
+    #[test]
+    fn test_indent_of() {
+        assert_eq!(indent_of(""), 0);
+        assert_eq!(indent_of(" "), 0);
+        assert_eq!(indent_of(" x"), 1);
+        assert_eq!(indent_of(" x\n"), 1);
+        assert_eq!(indent_of(" x\ny"), 0);
+        assert_eq!(indent_of(" x\n y"), 1);
+        assert_eq!(indent_of(" x\n  y"), 1);
+        assert_eq!(indent_of("  x\n  y"), 2);
+        assert_eq!(indent_of("  x\n  y\n"), 2);
+        assert_eq!(indent_of("  x\n\n  y\n"), 2);
+    }
+
     #[test]
     fn test_replace() {
         #[track_caller]

From ad4e1c2fb27802f54806286d4fc486c5d11392fa Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 23 Dec 2025 16:50:25 +0800
Subject: [PATCH 0011/1059] Fix postfix completion indentation compensation

Editor adds the current indentation to the content of the code snippet

This PR dedentation is used to offset the editor snippet indentation

Example
---
```rust
fn foo(x: Option<i32>, y: Option<i32>) {
    let _f = || {
        x
            .and(y)
            .map(|it| it+2)
            .$0
    };
}
```

**Before this PR**

```rust
fn foo(x: Option<i32>, y: Option<i32>) {
    let _f = || {
        let $0 = x
                        .and(y)
                        .map(|it| it+2);
    };
}
```

**After this PR**

```rust
fn foo(x: Option<i32>, y: Option<i32>) {
    let _f = || {
        let $0 = x
            .and(y)
            .map(|it| it+2);
    };
}
```
---
 .../ide-completion/src/completions/postfix.rs | 45 ++++++++++++++++---
 1 file changed, 40 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
index 7f67ef848ece..250e1472e9a3 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
@@ -355,12 +355,20 @@ fn get_receiver_text(
         range.range = TextRange::at(range.range.start(), range.range.len() - TextSize::of('.'))
     }
     let file_text = sema.db.file_text(range.file_id.file_id(sema.db));
-    let mut text = file_text.text(sema.db)[range.range].to_owned();
+    let text = file_text.text(sema.db);
+    let indent_spaces = indent_of_tail_line(&text[TextRange::up_to(range.range.start())]);
+    let mut text = stdx::dedent_by(indent_spaces, &text[range.range]);
 
     // The receiver texts should be interpreted as-is, as they are expected to be
     // normal Rust expressions.
     escape_snippet_bits(&mut text);
-    text
+    return text;
+
+    fn indent_of_tail_line(text: &str) -> usize {
+        let tail_line = text.rsplit_once('\n').map_or(text, |(_, s)| s);
+        let trimmed = tail_line.trim_start_matches(' ');
+        tail_line.len() - trimmed.len()
+    }
 }
 
 /// Escapes `\` and `$` so that they don't get interpreted as snippet-specific constructs.
@@ -977,9 +985,9 @@ fn main() {
 
 fn main() {
     ControlFlow::Break(match true {
-        true => "\${1:placeholder}",
-        false => "\\\$",
-    })
+    true => "\${1:placeholder}",
+    false => "\\\$",
+})
 }
 "#,
         );
@@ -1219,4 +1227,31 @@ fn foo() {
         "#,
         );
     }
+
+    #[test]
+    fn snippet_dedent() {
+        check_edit(
+            "let",
+            r#"
+//- minicore: option
+fn foo(x: Option<i32>, y: Option<i32>) {
+    let _f = || {
+        x
+            .and(y)
+            .map(|it| it+2)
+            .$0
+    };
+}
+"#,
+            r#"
+fn foo(x: Option<i32>, y: Option<i32>) {
+    let _f = || {
+        let $0 = x
+    .and(y)
+    .map(|it| it+2);
+    };
+}
+"#,
+        );
+    }
 }

From 430468fdbfb5d3972aafe9bcd196b5a7fc484159 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 25 Dec 2025 15:06:45 +0800
Subject: [PATCH 0012/1059] Fix tuple struct pat expected type

Example
---
```rust
struct Foo(Option<i32>);
fn foo(x: Foo) -> Foo {
   match x { Foo($0) => () }
}
```

**Before this PR**

```rust
ty: Foo, name: ?
```

**After this PR**

```rust
ty: Option<i32>, name: ?
```
---
 .../ide-completion/src/context/analysis.rs    | 10 +++++
 .../ide-completion/src/context/tests.rs       | 44 +++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index ce26d3806cc4..0528a94dac65 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -761,6 +761,16 @@ fn expected_type_and_name<'db>(
                     let ty = sema.type_of_pat(&ast::Pat::from(it)).map(TypeInfo::original);
                     (ty, None)
                 },
+                ast::TupleStructPat(it) => {
+                    let fields = it.path().and_then(|path| match sema.resolve_path(&path)? {
+                        hir::PathResolution::Def(hir::ModuleDef::Adt(adt)) => Some(adt.as_struct()?.fields(sema.db)),
+                        hir::PathResolution::Def(hir::ModuleDef::Variant(variant)) => Some(variant.fields(sema.db)),
+                        _ => None,
+                    });
+                    let nr = it.fields().take_while(|it| it.syntax().text_range().end() <= token.text_range().start()).count();
+                    let ty = fields.and_then(|fields| Some(fields.get(nr)?.ty(sema.db).to_type(sema.db)));
+                    (ty, None)
+                },
                 ast::Fn(it) => {
                     cov_mark::hit!(expected_type_fn_ret_with_leading_char);
                     cov_mark::hit!(expected_type_fn_ret_without_leading_char);
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 09a9b6f112f0..3169a16e2e74 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -287,6 +287,50 @@ fn foo() -> Foo {
     );
 }
 
+#[test]
+fn expected_type_tuple_struct_pat() {
+    check_expected_type_and_name(
+        r#"
+//- minicore: option
+struct Foo(Option<i32>);
+fn foo(x: Foo) -> Foo {
+   match x { Foo($0) => () }
+}
+"#,
+        expect![[r#"ty: Option<i32>, name: ?"#]],
+    );
+
+    check_expected_type_and_name(
+        r#"
+struct Foo(i32, u32, f32);
+fn foo(x: Foo) -> Foo {
+   match x { Foo($0) => () }
+}
+"#,
+        expect![[r#"ty: i32, name: ?"#]],
+    );
+
+    check_expected_type_and_name(
+        r#"
+struct Foo(i32, u32, f32);
+fn foo(x: Foo) -> Foo {
+   match x { Foo(num,$0) => () }
+}
+"#,
+        expect![[r#"ty: u32, name: ?"#]],
+    );
+
+    check_expected_type_and_name(
+        r#"
+struct Foo(i32, u32, f32);
+fn foo(x: Foo) -> Foo {
+   match x { Foo(num,$0,float) => () }
+}
+"#,
+        expect![[r#"ty: u32, name: ?"#]],
+    );
+}
+
 #[test]
 fn expected_type_if_let_without_leading_char() {
     cov_mark::check!(expected_type_if_let_without_leading_char);

From e04b950e1231b33d7dc951494b66f4315192bc81 Mon Sep 17 00:00:00 2001
From: dfireBird <me@dfirebird.dev>
Date: Sat, 3 Jan 2026 10:37:57 +0530
Subject: [PATCH 0013/1059] change test_name placeholder to executable_arg fix
 replacing target on lib target kind

---
 .../crates/rust-analyzer/src/config.rs        | 12 +--
 .../crates/rust-analyzer/src/target_spec.rs   | 85 +++++++++++++------
 .../docs/book/src/configuration_generated.md  | 12 +--
 .../rust-analyzer/editors/code/package.json   |  6 +-
 4 files changed, 76 insertions(+), 39 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index e39569e108de..444bbd1b2683 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -909,18 +909,18 @@ pub enum MaxSubstitutionLength {
         /// Override the command used for bench runnables.
         /// The first element of the array should be the program to execute (for example, `cargo`).
         ///
-        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
         /// replace the package name, target option (such as `--bin` or `--example`), the target name and
-        /// the test name (name of test function or test mod path).
+        /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
         runnables_bench_overrideCommand: Option<Vec<String>> = None,
         /// Command to be executed instead of 'cargo' for runnables.
         runnables_command: Option<String> = None,
         /// Override the command used for bench runnables.
         /// The first element of the array should be the program to execute (for example, `cargo`).
         ///
-        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
         /// replace the package name, target option (such as `--bin` or `--example`), the target name and
-        /// the test name (name of test function or test mod path).
+        /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
         runnables_doctest_overrideCommand: Option<Vec<String>> = None,
         /// Additional arguments to be passed to cargo for runnables such as
         /// tests or binaries. For example, it may be `--release`.
@@ -938,9 +938,9 @@ pub enum MaxSubstitutionLength {
         /// Override the command used for test runnables.
         /// The first element of the array should be the program to execute (for example, `cargo`).
         ///
-        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+        /// Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
         /// replace the package name, target option (such as `--bin` or `--example`), the target name and
-        /// the test name (name of test function or test mod path).
+        /// the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
         runnables_test_overrideCommand: Option<Vec<String>> = None,
 
         /// Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
index e0f95a7830ea..6d9adc2d8d8a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
@@ -119,38 +119,21 @@ pub(crate) fn runnable_args(
         let extra_test_binary_args = config.extra_test_binary_args;
 
         let mut cargo_args = Vec::new();
-        let mut executable_args = Vec::new();
+        let executable_args = Self::executable_args_for(kind, extra_test_binary_args);
 
         match kind {
-            RunnableKind::Test { test_id, attr } => {
+            RunnableKind::Test { .. } => {
                 cargo_args.push(config.test_command);
-                executable_args.push(test_id.to_string());
-                if let TestId::Path(_) = test_id {
-                    executable_args.push("--exact".to_owned());
-                }
-                executable_args.extend(extra_test_binary_args);
-                if attr.ignore {
-                    executable_args.push("--ignored".to_owned());
-                }
             }
-            RunnableKind::TestMod { path } => {
+            RunnableKind::TestMod { .. } => {
                 cargo_args.push(config.test_command);
-                executable_args.push(path.clone());
-                executable_args.extend(extra_test_binary_args);
             }
-            RunnableKind::Bench { test_id } => {
+            RunnableKind::Bench { .. } => {
                 cargo_args.push(config.bench_command);
-                executable_args.push(test_id.to_string());
-                if let TestId::Path(_) = test_id {
-                    executable_args.push("--exact".to_owned());
-                }
-                executable_args.extend(extra_test_binary_args);
             }
-            RunnableKind::DocTest { test_id } => {
+            RunnableKind::DocTest { .. } => {
                 cargo_args.push("test".to_owned());
                 cargo_args.push("--doc".to_owned());
-                executable_args.push(test_id.to_string());
-                executable_args.extend(extra_test_binary_args);
             }
             RunnableKind::Bin => {
                 let subcommand = match spec {
@@ -243,16 +226,70 @@ pub(crate) fn override_command(
             TargetKind::BuildScript | TargetKind::Other => "",
         };
 
+        let target = |kind, target| match kind {
+            TargetKind::Bin | TargetKind::Test | TargetKind::Bench | TargetKind::Example => target,
+            _ => "",
+        };
+
         let replace_placeholders = |arg: String| match &spec {
             Some(spec) => arg
                 .replace("${package}", &spec.package)
                 .replace("${target_arg}", target_arg(spec.target_kind))
-                .replace("${target}", &spec.target)
+                .replace("${target}", target(spec.target_kind, &spec.target))
                 .replace("${test_name}", &test_name),
             _ => arg,
         };
 
-        args.map(|args| args.into_iter().map(replace_placeholders).collect())
+        let extra_test_binary_args = config.extra_test_binary_args;
+        let executable_args = Self::executable_args_for(kind, extra_test_binary_args);
+
+        args.map(|mut args| {
+            let exec_args_idx = args.iter().position(|a| a == "${executable_args}");
+
+            if let Some(idx) = exec_args_idx {
+                args.splice(idx..idx + 1, executable_args);
+            }
+
+            args.into_iter().map(replace_placeholders).filter(|a| !a.trim().is_empty()).collect()
+        })
+    }
+
+    fn executable_args_for(
+        kind: &RunnableKind,
+        extra_test_binary_args: impl IntoIterator<Item = String>,
+    ) -> Vec<String> {
+        let mut executable_args = Vec::new();
+
+        match kind {
+            RunnableKind::Test { test_id, attr } => {
+                executable_args.push(test_id.to_string());
+                if let TestId::Path(_) = test_id {
+                    executable_args.push("--exact".to_owned());
+                }
+                executable_args.extend(extra_test_binary_args);
+                if attr.ignore {
+                    executable_args.push("--ignored".to_owned());
+                }
+            }
+            RunnableKind::TestMod { path } => {
+                executable_args.push(path.clone());
+                executable_args.extend(extra_test_binary_args);
+            }
+            RunnableKind::Bench { test_id } => {
+                executable_args.push(test_id.to_string());
+                if let TestId::Path(_) = test_id {
+                    executable_args.push("--exact".to_owned());
+                }
+                executable_args.extend(extra_test_binary_args);
+            }
+            RunnableKind::DocTest { test_id } => {
+                executable_args.push(test_id.to_string());
+                executable_args.extend(extra_test_binary_args);
+            }
+            RunnableKind::Bin => {}
+        }
+
+        executable_args
     }
 
     pub(crate) fn push_to(self, buf: &mut Vec<String>, kind: &RunnableKind) {
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 58b636334527..811f995493a6 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -1362,9 +1362,9 @@ Default: `null`
 Override the command used for bench runnables.
 The first element of the array should be the program to execute (for example, `cargo`).
 
-Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
 replace the package name, target option (such as `--bin` or `--example`), the target name and
-the test name (name of test function or test mod path).
+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
 
 
 ## rust-analyzer.runnables.command {#runnables.command}
@@ -1381,9 +1381,9 @@ Default: `null`
 Override the command used for bench runnables.
 The first element of the array should be the program to execute (for example, `cargo`).
 
-Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
 replace the package name, target option (such as `--bin` or `--example`), the target name and
-the test name (name of test function or test mod path).
+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
 
 
 ## rust-analyzer.runnables.extraArgs {#runnables.extraArgs}
@@ -1426,9 +1426,9 @@ Default: `null`
 Override the command used for test runnables.
 The first element of the array should be the program to execute (for example, `cargo`).
 
-Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically
+Use the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically
 replace the package name, target option (such as `--bin` or `--example`), the target name and
-the test name (name of test function or test mod path).
+the arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).
 
 
 ## rust-analyzer.rustc.source {#rustc.source}
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 2157cbd48653..498077ddb51a 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -2840,7 +2840,7 @@
                 "title": "Runnables",
                 "properties": {
                     "rust-analyzer.runnables.bench.overrideCommand": {
-                        "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe test name (name of test function or test mod path).",
+                        "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",
                         "default": null,
                         "type": [
                             "null",
@@ -2869,7 +2869,7 @@
                 "title": "Runnables",
                 "properties": {
                     "rust-analyzer.runnables.doctest.overrideCommand": {
-                        "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe test name (name of test function or test mod path).",
+                        "markdownDescription": "Override the command used for bench runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",
                         "default": null,
                         "type": [
                             "null",
@@ -2923,7 +2923,7 @@
                 "title": "Runnables",
                 "properties": {
                     "rust-analyzer.runnables.test.overrideCommand": {
-                        "markdownDescription": "Override the command used for test runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${test_name}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe test name (name of test function or test mod path).",
+                        "markdownDescription": "Override the command used for test runnables.\nThe first element of the array should be the program to execute (for example, `cargo`).\n\nUse the placeholders `${package}`, `${target_arg}`, `${target}`, `${executable_args}` to dynamically\nreplace the package name, target option (such as `--bin` or `--example`), the target name and\nthe arguments passed to test binary args (includes `rust-analyzer.runnables.extraTestBinaryArgs`).",
                         "default": null,
                         "type": [
                             "null",

From b21e115e2cc6193838cdc499e127debcffe4d62a Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 14:04:32 +1100
Subject: [PATCH 0014/1059] Add a test for parsing BuildData and RunnableData
 json

---
 .../crates/project-model/src/tests.rs         |  6 ++++
 .../test_data/labeled-project.json            | 31 +++++++++++++++++++
 2 files changed, 37 insertions(+)
 create mode 100644 src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json

diff --git a/src/tools/rust-analyzer/crates/project-model/src/tests.rs b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
index a03ed562e1be..395cea6f76e6 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
@@ -192,6 +192,12 @@ fn rust_project_hello_world_project_model() {
     );
 }
 
+#[test]
+fn rust_project_labeled_project_model() {
+    // This just needs to parse.
+    _ = load_rust_project("labeled-project.json");
+}
+
 #[test]
 fn rust_project_cfg_groups() {
     let (crate_graph, _proc_macros) = load_rust_project("cfg-groups.json");
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json b/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json
new file mode 100644
index 000000000000..50f66739cfdf
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json
@@ -0,0 +1,31 @@
+{
+    "sysroot_src": null,
+    "crates": [
+        {
+            "display_name": "hello_world",
+            "root_module": "$ROOT$src/lib.rs",
+            "edition": "2018",
+            "deps": [],
+            "is_workspace_member": true,
+            "build": {
+                "label": "//:hello_world",
+                "build_file": "$ROOT$BUILD",
+                "target_kind": "bin"
+            }
+        }
+    ],
+    "runnables": [
+        {
+            "kind": "run",
+            "program": "bazel",
+            "args": ["run", "{label}"],
+            "cwd": "$ROOT$"
+        },
+        {
+            "kind": "flycheck",
+            "program": "$ROOT$custom-flychecker.sh",
+            "args": ["{label}"],
+            "cwd": "$ROOT$"
+        }
+    ]
+}

From 557df27ade4759f3e7d0c5c8ea8aed6cdf75a597 Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 10:07:36 +1100
Subject: [PATCH 0015/1059] Privatise some fields and structs in project_json

These are not used outside of the project-model crate, ie. instantly converted to other structures.
---
 .../crates/project-model/src/project_json.rs     | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
index cbbb95cc468f..cd13a208a4a4 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
@@ -460,23 +460,23 @@ enum EditionData {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub struct BuildData {
+struct BuildData {
     label: String,
     build_file: Utf8PathBuf,
     target_kind: TargetKindData,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RunnableData {
-    pub program: String,
-    pub args: Vec<String>,
-    pub cwd: Utf8PathBuf,
-    pub kind: RunnableKindData,
+struct RunnableData {
+    program: String,
+    args: Vec<String>,
+    cwd: Utf8PathBuf,
+    kind: RunnableKindData,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub enum RunnableKindData {
+enum RunnableKindData {
     Flycheck,
     Check,
     Run,
@@ -490,7 +490,7 @@ pub enum RunnableKindData {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub enum TargetKindData {
+enum TargetKindData {
     Bin,
     /// Any kind of Cargo lib crate-type (dylib, rlib, proc-macro, ...).
     Lib,

From b801b88405cf5911ad8196fc2ed67233d4bb2b51 Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 10:06:47 +1100
Subject: [PATCH 0016/1059] Add unknown runnable kind for forwards
 compatibility

---
 .../crates/project-model/src/project_json.rs             | 9 +++++++++
 .../crates/project-model/test_data/labeled-project.json  | 6 ++++++
 2 files changed, 15 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
index 6938010cbd70..cbbb95cc468f 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
@@ -368,6 +368,9 @@ pub enum RunnableKind {
     /// Template for checking a target, emitting rustc JSON diagnostics.
     /// May include {label} which will get the label from the `build` section of a crate.
     Flycheck,
+
+    /// For forwards-compatibility, i.e. old rust-analyzer binary with newer workspace discovery tools
+    Unknown,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -478,6 +481,11 @@ pub enum RunnableKindData {
     Check,
     Run,
     TestOne,
+
+    /// For forwards-compatibility, i.e. old rust-analyzer binary with newer workspace discovery tools
+    #[allow(unused)]
+    #[serde(other)]
+    Unknown,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
@@ -546,6 +554,7 @@ fn from(data: RunnableKindData) -> Self {
             RunnableKindData::Run => RunnableKind::Run,
             RunnableKindData::TestOne => RunnableKind::TestOne,
             RunnableKindData::Flycheck => RunnableKind::Flycheck,
+            RunnableKindData::Unknown => RunnableKind::Unknown,
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json b/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json
index 50f66739cfdf..5c0e1f33979e 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/labeled-project.json
@@ -26,6 +26,12 @@
             "program": "$ROOT$custom-flychecker.sh",
             "args": ["{label}"],
             "cwd": "$ROOT$"
+        },
+        {
+            "kind": "we-ignore-unknown-runnable-kinds-for-forwards-compatibility",
+            "program": "abc",
+            "args": ["{label}"],
+            "cwd": "$ROOT$"
         }
     ]
 }

From f8455e26bdbd27dd4f970e39d87aaa1d84b3ae87 Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 10:07:36 +1100
Subject: [PATCH 0017/1059] A comment to help ProjectJsonData stay
 backwards-compatible

Makes clear to future editors of this code that they should add #[serde(default)]
to new fields.
---
 .../rust-analyzer/crates/project-model/src/project_json.rs      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
index cd13a208a4a4..e3a4feec8d92 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
@@ -383,6 +383,8 @@ pub struct ProjectJsonData {
     crates: Vec<CrateData>,
     #[serde(default)]
     runnables: Vec<RunnableData>,
+    //
+    // New fields should be Option or #[serde(default)]. This applies to most of this datastructure.
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Default)]

From ff365fd4a4eb9b7c7a59c514b240912ed710d3dd Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 11:07:21 +1100
Subject: [PATCH 0018/1059] Refactor the runnable_args implementation to be
 more compact

I'm about to complete the match statement here with more of the same.
Once you write the exact same code 5 times, it's time for a helper function.
---
 .../crates/rust-analyzer/src/target_spec.rs   | 64 ++++++++-----------
 1 file changed, 28 insertions(+), 36 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
index b8d9acc02a32..c87eefc6955a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
@@ -6,7 +6,7 @@
 use cfg::{CfgAtom, CfgExpr};
 use hir::sym;
 use ide::{Cancellable, Crate, FileId, RunnableKind, TestId};
-use project_model::project_json::Runnable;
+use project_model::project_json::{self, Runnable};
 use project_model::{CargoFeatures, ManifestPath, TargetKind};
 use rustc_hash::FxHashSet;
 use triomphe::Arc;
@@ -72,44 +72,36 @@ pub(crate) struct ProjectJsonTargetSpec {
 }
 
 impl ProjectJsonTargetSpec {
+    fn find_replace_runnable(
+        &self,
+        kind: project_json::RunnableKind,
+        replacer: &dyn Fn(&Self, &str) -> String,
+    ) -> Option<Runnable> {
+        for runnable in &self.shell_runnables {
+            if runnable.kind == kind {
+                let mut runnable = runnable.clone();
+
+                let replaced_args: Vec<_> =
+                    runnable.args.iter().map(|arg| replacer(self, arg)).collect();
+                runnable.args = replaced_args;
+
+                return Some(runnable);
+            }
+        }
+
+        None
+    }
+
     pub(crate) fn runnable_args(&self, kind: &RunnableKind) -> Option<Runnable> {
         match kind {
-            RunnableKind::Bin => {
-                for runnable in &self.shell_runnables {
-                    if matches!(runnable.kind, project_model::project_json::RunnableKind::Run) {
-                        let mut runnable = runnable.clone();
-
-                        let replaced_args: Vec<_> = runnable
-                            .args
-                            .iter()
-                            .map(|arg| arg.replace("{label}", &self.label))
-                            .collect();
-                        runnable.args = replaced_args;
-
-                        return Some(runnable);
-                    }
-                }
-
-                None
-            }
+            RunnableKind::Bin => self
+                .find_replace_runnable(project_json::RunnableKind::Run, &|this, arg| {
+                    arg.replace("{label}", &this.label)
+                }),
             RunnableKind::Test { test_id, .. } => {
-                for runnable in &self.shell_runnables {
-                    if matches!(runnable.kind, project_model::project_json::RunnableKind::TestOne) {
-                        let mut runnable = runnable.clone();
-
-                        let replaced_args: Vec<_> = runnable
-                            .args
-                            .iter()
-                            .map(|arg| arg.replace("{test_id}", &test_id.to_string()))
-                            .map(|arg| arg.replace("{label}", &self.label))
-                            .collect();
-                        runnable.args = replaced_args;
-
-                        return Some(runnable);
-                    }
-                }
-
-                None
+                self.find_replace_runnable(project_json::RunnableKind::Run, &|this, arg| {
+                    arg.replace("{label}", &this.label).replace("{test_id}", &test_id.to_string())
+                })
             }
             RunnableKind::TestMod { .. } => None,
             RunnableKind::Bench { .. } => None,

From 91819d05f63488c0db7df48fa8212b6eccb4e843 Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 10:34:16 +1100
Subject: [PATCH 0019/1059] Restore a deleted comment that was quite
 informative

Was deleted when this code was moved in PR 18043.
---
 src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index 62a3b3a17bdf..ba817609d3ff 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -1180,6 +1180,8 @@ fn handle_flycheck_msg(&mut self, message: FlycheckMessage, cargo_finished: &mut
             } => self.diagnostics.clear_check_older_than_for_package(id, package_id, generation),
             FlycheckMessage::Progress { id, progress } => {
                 let format_with_id = |user_facing_command: String| {
+                    // When we're running multiple flychecks, we have to include a disambiguator in
+                    // the title, or the editor complains. Note that this is a user-facing string.
                     if self.flycheck.len() == 1 {
                         user_facing_command
                     } else {

From f8d046d87deb9fd77fc35e42506091aee34cb8da Mon Sep 17 00:00:00 2001
From: Cormac Relf <web@cormacrelf.net>
Date: Fri, 9 Jan 2026 11:12:20 +1100
Subject: [PATCH 0020/1059] Support more runnable kinds for project json

Allows project JSON users  to run a whole module of tests, benchmarks, doctests.
---
 .../crates/project-model/src/project_json.rs  | 21 +++++++++++++++++++
 .../crates/rust-analyzer/src/target_spec.rs   | 17 ++++++++++++---
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
index cbbb95cc468f..201c59039bef 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs
@@ -365,6 +365,21 @@ pub enum RunnableKind {
     /// May include {test_id} which will get the test clicked on by the user.
     TestOne,
 
+    /// Run tests matching a pattern (in RA, usually a path::to::module::of::tests)
+    /// May include {label} which will get the label from the `build` section of a crate.
+    /// May include {test_pattern} which will get the test module clicked on by the user.
+    TestMod,
+
+    /// Run a single doctest
+    /// May include {label} which will get the label from the `build` section of a crate.
+    /// May include {test_id} which will get the doctest clicked on by the user.
+    DocTestOne,
+
+    /// Run a single benchmark
+    /// May include {label} which will get the label from the `build` section of a crate.
+    /// May include {bench_id} which will get the benchmark clicked on by the user.
+    BenchOne,
+
     /// Template for checking a target, emitting rustc JSON diagnostics.
     /// May include {label} which will get the label from the `build` section of a crate.
     Flycheck,
@@ -481,6 +496,9 @@ pub enum RunnableKindData {
     Check,
     Run,
     TestOne,
+    TestMod,
+    DocTestOne,
+    BenchOne,
 
     /// For forwards-compatibility, i.e. old rust-analyzer binary with newer workspace discovery tools
     #[allow(unused)]
@@ -553,6 +571,9 @@ fn from(data: RunnableKindData) -> Self {
             RunnableKindData::Check => RunnableKind::Check,
             RunnableKindData::Run => RunnableKind::Run,
             RunnableKindData::TestOne => RunnableKind::TestOne,
+            RunnableKindData::TestMod => RunnableKind::TestMod,
+            RunnableKindData::DocTestOne => RunnableKind::DocTestOne,
+            RunnableKindData::BenchOne => RunnableKind::BenchOne,
             RunnableKindData::Flycheck => RunnableKind::Flycheck,
             RunnableKindData::Unknown => RunnableKind::Unknown,
         }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
index c87eefc6955a..b96786cae935 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
@@ -103,9 +103,20 @@ pub(crate) fn runnable_args(&self, kind: &RunnableKind) -> Option<Runnable> {
                     arg.replace("{label}", &this.label).replace("{test_id}", &test_id.to_string())
                 })
             }
-            RunnableKind::TestMod { .. } => None,
-            RunnableKind::Bench { .. } => None,
-            RunnableKind::DocTest { .. } => None,
+            RunnableKind::TestMod { path } => self
+                .find_replace_runnable(project_json::RunnableKind::TestMod, &|this, arg| {
+                    arg.replace("{label}", &this.label).replace("{test_pattern}", path)
+                }),
+            RunnableKind::Bench { test_id } => {
+                self.find_replace_runnable(project_json::RunnableKind::BenchOne, &|this, arg| {
+                    arg.replace("{label}", &this.label).replace("{bench_id}", &test_id.to_string())
+                })
+            }
+            RunnableKind::DocTest { test_id } => {
+                self.find_replace_runnable(project_json::RunnableKind::DocTestOne, &|this, arg| {
+                    arg.replace("{label}", &this.label).replace("{test_id}", &test_id.to_string())
+                })
+            }
         }
     }
 }

From 8ec0c96d8c8cc83552a65413cb8d8ea647dcd25b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 29 Aug 2025 18:20:41 +0800
Subject: [PATCH 0021/1059] Add partial selection for merge_imports

Example
---
**Input**:

```rust
use std::fmt::Error;
$0use std::fmt::Display;
use std::fmt::Debug;
use std::fmt::Write;
use$0 std::fmt::Result;
```

**Before this PR**:

```rust
use std::fmt::Error;
use std::fmt::{Debug, Display, Write};
use std::fmt::Result;
```

**After this PR**:

```rust
use std::fmt::Error;
use std::fmt::{Debug, Display, Result, Write};
```
---
 .../ide-assists/src/handlers/merge_imports.rs | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
index 9ba73d23dd24..42bc05811fd1 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
@@ -49,8 +49,9 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext<'_>) -> Optio
             SyntaxElement::Node(n) => n,
             SyntaxElement::Token(t) => t.parent()?,
         };
-        let mut selected_nodes =
-            parent_node.children().filter(|it| selection_range.contains_range(it.text_range()));
+        let mut selected_nodes = parent_node.children().filter(|it| {
+            selection_range.intersect(it.text_range()).is_some_and(|it| !it.is_empty())
+        });
 
         let first_selected = selected_nodes.next()?;
         let edits = match_ast! {
@@ -677,6 +678,25 @@ fn merge_selection_uses() {
         );
     }
 
+    #[test]
+    fn merge_partial_selection_uses() {
+        cov_mark::check!(merge_with_selected_use_item_neighbors);
+        check_assist(
+            merge_imports,
+            r"
+use std::fmt::Error;
+$0use std::fmt::Display;
+use std::fmt::Debug;
+use std::fmt::Write;
+use$0 std::fmt::Result;
+",
+            r"
+use std::fmt::Error;
+use std::fmt::{Debug, Display, Result, Write};
+",
+        );
+    }
+
     #[test]
     fn merge_selection_use_trees() {
         cov_mark::check!(merge_with_selected_use_tree_neighbors);

From 529c83d0cd4fa4ee2f002b322257cd5e16959a0d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 15 Jan 2026 16:55:20 +0800
Subject: [PATCH 0022/1059] Add applicable on let-else branch for unwrap_block

Example
---
```rust
fn main() {
    let Some(2) = None else {$0
        return;
    };
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
fn main() {
    return;
}
```
---
 .../ide-assists/src/handlers/unwrap_block.rs  | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_block.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_block.rs
index e4f5e3523bd2..e029d7884fd5 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_block.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_block.rs
@@ -45,6 +45,7 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                 ast::LoopExpr(it) => it.syntax().clone(),
                 ast::WhileExpr(it) => it.syntax().clone(),
                 ast::MatchArm(it) => it.parent_match().syntax().clone(),
+                ast::LetElse(it) => it.syntax().parent()?,
                 ast::LetStmt(it) => {
                     replacement = wrap_let(&it, replacement);
                     prefer_container = Some(it.syntax().clone());
@@ -556,6 +557,40 @@ fn main() {
         );
     }
 
+    #[test]
+    fn simple_let_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    let Some(2) = None else {$0
+        return;
+    };
+}
+"#,
+            r#"
+fn main() {
+    return;
+}
+"#,
+        );
+        check_assist(
+            unwrap_block,
+            r#"
+fn main() {
+    let Some(2) = None else {$0
+        return
+    };
+}
+"#,
+            r#"
+fn main() {
+    return
+}
+"#,
+        );
+    }
+
     #[test]
     fn unwrap_match_arm() {
         check_assist(

From 438b12617774fa989673968aad51e5eae03d0333 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 12 Dec 2025 14:38:01 -0600
Subject: [PATCH 0023/1059] rustdoc: don't give depreciation notes special
 handling

---
 src/librustdoc/html/markdown.rs            | 12 +++++++-----
 src/librustdoc/html/markdown/tests.rs      |  2 +-
 src/librustdoc/html/static/css/rustdoc.css |  1 -
 tests/rustdoc-html/deprecated.rs           |  5 +++++
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index c472c20a7dc7..7b3198a194c4 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -109,13 +109,15 @@ pub(crate) struct MarkdownWithToc<'a> {
     pub(crate) edition: Edition,
     pub(crate) playground: &'a Option<Playground>,
 }
-/// A tuple struct like `Markdown` that renders the markdown escaping HTML tags
+
+/// A struct like `Markdown` that renders the markdown escaping HTML tags
 /// and includes no paragraph tags.
 pub(crate) struct MarkdownItemInfo<'a> {
     pub(crate) content: &'a str,
     pub(crate) links: &'a [RenderedLink],
     pub(crate) ids: &'a mut IdMap,
 }
+
 /// A tuple struct like `Markdown` that renders only the first paragraph.
 pub(crate) struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
 
@@ -1497,10 +1499,10 @@ pub(crate) fn write_into(self, mut f: impl fmt::Write) -> fmt::Result {
             let p = SpannedLinkReplacer::new(p, links);
             let p = footnotes::Footnotes::new(p, existing_footnotes);
             let p = TableWrapper::new(p.map(|(ev, _)| ev));
-            let p = p.filter(|event| {
-                !matches!(event, Event::Start(Tag::Paragraph) | Event::End(TagEnd::Paragraph))
-            });
-            html::write_html_fmt(&mut f, p)
+            // in legacy wrap mode, strip <p> elements to avoid them inserting newlines
+            html::write_html_fmt(&mut f, p)?;
+
+            Ok(())
         })
     }
 }
diff --git a/src/librustdoc/html/markdown/tests.rs b/src/librustdoc/html/markdown/tests.rs
index 1c99ccc5228b..3655a52deee6 100644
--- a/src/librustdoc/html/markdown/tests.rs
+++ b/src/librustdoc/html/markdown/tests.rs
@@ -472,7 +472,7 @@ fn t(input: &str, expect: &str) {
         let mut idmap = IdMap::new();
         let mut output = String::new();
         MarkdownItemInfo::new(input, &[], &mut idmap).write_into(&mut output).unwrap();
-        assert_eq!(output, expect, "original: {}", input);
+        assert_eq!(output, format!("<p>{}</p>\n", expect), "original: {}", input);
     }
 
     t("`Struct<'a, T>`", "<code>Struct&lt;'a, T&gt;</code>");
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index b770a0e2a0e4..8410e8c793e1 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1585,7 +1585,6 @@ so that we can apply CSS-filters to change the arrow color in themes */
 	color: var(--main-color);
 	background-color: var(--stab-background-color);
 	width: fit-content;
-	white-space: pre-wrap;
 	border-radius: 3px;
 	display: inline;
 	vertical-align: baseline;
diff --git a/tests/rustdoc-html/deprecated.rs b/tests/rustdoc-html/deprecated.rs
index a84657a3df5a..c7db816cffcf 100644
--- a/tests/rustdoc-html/deprecated.rs
+++ b/tests/rustdoc-html/deprecated.rs
@@ -30,3 +30,8 @@
 //      'Deprecated: shorthand reason: code$'
 #[deprecated = "shorthand reason: `code`"]
 pub struct X;
+
+//@ matches deprecated/struct.Y.html '//*[@class="stab deprecated"]//p[1]' 'multiple'
+//@ matches deprecated/struct.Y.html '//*[@class="stab deprecated"]//p[2]' 'paragraphs'
+#[deprecated = "multiple\n\nparagraphs"]
+pub struct Y;

From e7d56c6d01a11cddc94d2f12edeb381bf4f0f579 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 14 Jan 2026 19:03:30 -0500
Subject: [PATCH 0024/1059] Add functions to `GrowableBitSet`.

---
 compiler/rustc_index/src/bit_set.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index a9bdf597e128..2a850898b2d6 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -1336,6 +1336,12 @@ pub fn insert(&mut self, elem: T) -> bool {
         self.bit_set.insert(elem)
     }
 
+    #[inline]
+    pub fn insert_range(&mut self, elems: Range<T>) {
+        self.ensure(elems.end.index());
+        self.bit_set.insert_range(elems);
+    }
+
     /// Returns `true` if the set has changed.
     #[inline]
     pub fn remove(&mut self, elem: T) -> bool {
@@ -1343,6 +1349,16 @@ pub fn remove(&mut self, elem: T) -> bool {
         self.bit_set.remove(elem)
     }
 
+    #[inline]
+    pub fn clear(&mut self) {
+        self.bit_set.clear();
+    }
+
+    #[inline]
+    pub fn count(&self) -> usize {
+        self.bit_set.count()
+    }
+
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.bit_set.is_empty()
@@ -1354,6 +1370,14 @@ pub fn contains(&self, elem: T) -> bool {
         self.bit_set.words.get(word_index).is_some_and(|word| (word & mask) != 0)
     }
 
+    #[inline]
+    pub fn contains_any(&self, elems: Range<T>) -> bool {
+        elems.start.index() < self.bit_set.domain_size
+            && self
+                .bit_set
+                .contains_any(elems.start..T::new(elems.end.index().min(self.bit_set.domain_size)))
+    }
+
     #[inline]
     pub fn iter(&self) -> BitIter<'_, T> {
         self.bit_set.iter()

From f1d5fdefa8e8d7a2bacb640888bc6f4e4d1b6b6d Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain@oss.qualcomm.com>
Date: Fri, 23 Jan 2026 23:18:36 -0600
Subject: [PATCH 0025/1059] Fix Hexagon ABI calling convention for small
 aggregates

Small structs (<= 64 bits) were being passed with their fields split
into separate arguments instead of being packed into register-sized
chunks. This caused ABI mismatches.

The fix properly casts small aggregates to consecutive register-sized
chunks using Uniform::consecutive(), matching the Hexagon C ABI where
small structs are packed into R1:0 register pair.

This fixes tests like extern-pass-TwoU16s.rs and extern-pass-TwoU8s.rs.
---
 compiler/rustc_target/src/callconv/hexagon.rs | 60 +++++++++++++++----
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_target/src/callconv/hexagon.rs b/compiler/rustc_target/src/callconv/hexagon.rs
index e08e6daa7405..e07aa32251aa 100644
--- a/compiler/rustc_target/src/callconv/hexagon.rs
+++ b/compiler/rustc_target/src/callconv/hexagon.rs
@@ -1,36 +1,74 @@
-use rustc_abi::TyAbiInterface;
+use rustc_abi::{HasDataLayout, TyAbiInterface};
 
-use crate::callconv::{ArgAbi, FnAbi};
+use crate::callconv::{ArgAbi, FnAbi, Reg, Uniform};
 
-fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
-    if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 {
-        ret.make_indirect();
-    } else {
-        ret.extend_integer_width_to(32);
+fn classify_ret<'a, Ty, C>(_cx: &C, ret: &mut ArgAbi<'a, Ty>)
+where
+    Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
+{
+    if !ret.layout.is_sized() {
+        return;
     }
+    if !ret.layout.is_aggregate() {
+        ret.extend_integer_width_to(32);
+        return;
+    }
+
+    let size = ret.layout.size;
+    let bits = size.bits();
+
+    // Aggregates larger than 64 bits are returned indirectly
+    if bits > 64 {
+        ret.make_indirect();
+        return;
+    }
+
+    // Small aggregates are returned in registers
+    // Cast to appropriate register type to ensure proper ABI
+    let align = ret.layout.align.bytes();
+    ret.cast_to(Uniform::consecutive(if align <= 4 { Reg::i32() } else { Reg::i64() }, size));
 }
 
 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
 {
+    if !arg.layout.is_sized() {
+        return;
+    }
     if arg.layout.pass_indirectly_in_non_rustic_abis(cx) {
         arg.make_indirect();
         return;
     }
-    if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 {
-        arg.make_indirect();
-    } else {
+    if !arg.layout.is_aggregate() {
         arg.extend_integer_width_to(32);
+        return;
     }
+
+    let size = arg.layout.size;
+    let bits = size.bits();
+
+    // Aggregates larger than 64 bits are passed indirectly
+    if bits > 64 {
+        arg.make_indirect();
+        return;
+    }
+
+    // Small aggregates are passed in registers
+    // Cast to consecutive register-sized chunks to match the C ABI
+    let align = arg.layout.align.bytes();
+    arg.cast_to(Uniform::consecutive(if align <= 4 { Reg::i32() } else { Reg::i64() }, size));
 }
 
 pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
 {
     if !fn_abi.ret.is_ignore() {
-        classify_ret(&mut fn_abi.ret);
+        classify_ret(cx, &mut fn_abi.ret);
     }
 
     for arg in fn_abi.args.iter_mut() {

From b1925a9791a3097065af228f9b109430b92d75de Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain@oss.qualcomm.com>
Date: Sat, 24 Jan 2026 13:46:00 -0600
Subject: [PATCH 0026/1059] Fix Hexagon ABI calling convention for aggregates

Correct the handling of aggregate types in extern "C" functions to match
the Hexagon ABI specification:

- Aggregates up to 32 bits: passed/returned in a single register (R0)
- Aggregates 33-64 bits: passed/returned in a register pair (R1:R0)
- Aggregates > 64 bits: passed on stack via byval, returned via sret

This fixes all tests/ui/abi/extern/ tests for Hexagon, including:
- extern-pass-TwoU8s, extern-pass-TwoU16s, extern-pass-TwoU32s
- extern-pass-TwoU64s, extern-pass-FiveU16s
- extern-return-TwoU8s, extern-return-TwoU16s, extern-return-TwoU32s
- extern-return-TwoU64s, extern-return-FiveU16s
---
 compiler/rustc_target/src/callconv/hexagon.rs | 40 ++++++++++---------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_target/src/callconv/hexagon.rs b/compiler/rustc_target/src/callconv/hexagon.rs
index e07aa32251aa..1e0f1f769c3b 100644
--- a/compiler/rustc_target/src/callconv/hexagon.rs
+++ b/compiler/rustc_target/src/callconv/hexagon.rs
@@ -10,24 +10,25 @@ fn classify_ret<'a, Ty, C>(_cx: &C, ret: &mut ArgAbi<'a, Ty>)
     if !ret.layout.is_sized() {
         return;
     }
+
     if !ret.layout.is_aggregate() {
         ret.extend_integer_width_to(32);
         return;
     }
 
+    // Per the Hexagon ABI:
+    // - Aggregates up to 32 bits are returned in R0
+    // - Aggregates 33-64 bits are returned in R1:R0
+    // - Aggregates > 64 bits are returned indirectly via hidden first argument
     let size = ret.layout.size;
     let bits = size.bits();
-
-    // Aggregates larger than 64 bits are returned indirectly
-    if bits > 64 {
+    if bits <= 32 {
+        ret.cast_to(Uniform::new(Reg::i32(), size));
+    } else if bits <= 64 {
+        ret.cast_to(Uniform::new(Reg::i64(), size));
+    } else {
         ret.make_indirect();
-        return;
     }
-
-    // Small aggregates are returned in registers
-    // Cast to appropriate register type to ensure proper ABI
-    let align = ret.layout.align.bytes();
-    ret.cast_to(Uniform::consecutive(if align <= 4 { Reg::i32() } else { Reg::i64() }, size));
 }
 
 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
@@ -42,24 +43,25 @@ fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
         arg.make_indirect();
         return;
     }
+
     if !arg.layout.is_aggregate() {
         arg.extend_integer_width_to(32);
         return;
     }
 
+    // Per the Hexagon ABI:
+    // - Aggregates up to 32 bits are passed in a single register
+    // - Aggregates 33-64 bits are passed in a register pair
+    // - Aggregates > 64 bits are passed on the stack
     let size = arg.layout.size;
     let bits = size.bits();
-
-    // Aggregates larger than 64 bits are passed indirectly
-    if bits > 64 {
-        arg.make_indirect();
-        return;
+    if bits <= 32 {
+        arg.cast_to(Uniform::new(Reg::i32(), size));
+    } else if bits <= 64 {
+        arg.cast_to(Uniform::new(Reg::i64(), size));
+    } else {
+        arg.pass_by_stack_offset(None);
     }
-
-    // Small aggregates are passed in registers
-    // Cast to consecutive register-sized chunks to match the C ABI
-    let align = arg.layout.align.bytes();
-    arg.cast_to(Uniform::consecutive(if align <= 4 { Reg::i32() } else { Reg::i64() }, size));
 }
 
 pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)

From 57650eeb9dd4d4af3cf265c360864716b2badc4f Mon Sep 17 00:00:00 2001
From: Lieselotte <52315535+she3py@users.noreply.github.com>
Date: Sat, 7 Feb 2026 17:24:16 +0100
Subject: [PATCH 0027/1059] fix: don't suggest replacing
 `env!("CARGO_BIN_NAME")` with itself

---
 compiler/rustc_builtin_macros/src/env.rs      | 46 ++++++++++++-------
 compiler/rustc_builtin_macros/src/errors.rs   |  1 +
 .../env-cargo-var-typo-issue-148439.rs        | 10 +++-
 .../env-cargo-var-typo-issue-148439.stderr    | 26 +++++++----
 .../env-macro/env-not-defined-default.stderr  |  1 +
 5 files changed, 58 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/env.rs b/compiler/rustc_builtin_macros/src/env.rs
index af78db156a22..12f59467ffd1 100644
--- a/compiler/rustc_builtin_macros/src/env.rs
+++ b/compiler/rustc_builtin_macros/src/env.rs
@@ -140,18 +140,21 @@ pub(crate) fn expand_env<'cx>(
                 unreachable!("`expr_to_string` ensures this is a string lit")
             };
 
+            let var = var.as_str();
             let guar = match err {
                 VarError::NotPresent => {
                     if let Some(msg_from_user) = custom_msg {
                         cx.dcx()
                             .emit_err(errors::EnvNotDefinedWithUserMessage { span, msg_from_user })
-                    } else if let Some(suggested_var) = find_similar_cargo_var(var.as_str()) {
+                    } else if let Some(suggested_var) = find_similar_cargo_var(var)
+                        && suggested_var != var
+                    {
                         cx.dcx().emit_err(errors::EnvNotDefined::CargoEnvVarTypo {
                             span,
                             var: *symbol,
                             suggested_var: Symbol::intern(suggested_var),
                         })
-                    } else if is_cargo_env_var(var.as_str()) {
+                    } else if is_cargo_env_var(var) {
                         cx.dcx().emit_err(errors::EnvNotDefined::CargoEnvVar {
                             span,
                             var: *symbol,
@@ -177,7 +180,7 @@ pub(crate) fn expand_env<'cx>(
     ExpandResult::Ready(MacEager::expr(e))
 }
 
-/// Returns `true` if an environment variable from `env!` is one used by Cargo.
+/// Returns `true` if an environment variable from `env!` could be one used by Cargo.
 fn is_cargo_env_var(var: &str) -> bool {
     var.starts_with("CARGO_")
         || var.starts_with("DEP_")
@@ -187,25 +190,28 @@ fn is_cargo_env_var(var: &str) -> bool {
 const KNOWN_CARGO_VARS: &[&str] = &[
     // List of known Cargo environment variables that are set for crates (not build scripts, OUT_DIR etc).
     // See: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates
+    // tidy-alphabetical-start
+    "CARGO_BIN_NAME",
+    "CARGO_CRATE_NAME",
+    "CARGO_MANIFEST_DIR",
+    "CARGO_MANIFEST_PATH",
+    "CARGO_PKG_AUTHORS",
+    "CARGO_PKG_DESCRIPTION",
+    "CARGO_PKG_HOMEPAGE",
+    "CARGO_PKG_LICENSE",
+    "CARGO_PKG_LICENSE_FILE",
+    "CARGO_PKG_NAME",
+    "CARGO_PKG_README",
+    "CARGO_PKG_REPOSITORY",
+    "CARGO_PKG_RUST_VERSION",
     "CARGO_PKG_VERSION",
     "CARGO_PKG_VERSION_MAJOR",
     "CARGO_PKG_VERSION_MINOR",
     "CARGO_PKG_VERSION_PATCH",
     "CARGO_PKG_VERSION_PRE",
-    "CARGO_PKG_AUTHORS",
-    "CARGO_PKG_NAME",
-    "CARGO_PKG_DESCRIPTION",
-    "CARGO_PKG_HOMEPAGE",
-    "CARGO_PKG_REPOSITORY",
-    "CARGO_PKG_LICENSE",
-    "CARGO_PKG_LICENSE_FILE",
-    "CARGO_PKG_RUST_VERSION",
-    "CARGO_PKG_README",
-    "CARGO_MANIFEST_DIR",
-    "CARGO_MANIFEST_PATH",
-    "CARGO_CRATE_NAME",
-    "CARGO_BIN_NAME",
     "CARGO_PRIMARY_PACKAGE",
+    "CARGO_TARGET_TMPDIR",
+    // tidy-alphabetical-end
 ];
 
 fn find_similar_cargo_var(var: &str) -> Option<&'static str> {
@@ -219,7 +225,13 @@ fn find_similar_cargo_var(var: &str) -> Option<&'static str> {
     let mut best_distance = usize::MAX;
 
     for &known_var in KNOWN_CARGO_VARS {
-        if let Some(distance) = edit_distance(var, known_var, max_dist) {
+        if let Some(mut distance) = edit_distance(var, known_var, max_dist) {
+            // assume `PACKAGE` to equals `PKG`
+            // (otherwise, `d("CARGO_PACKAGE_NAME", "CARGO_PKG_NAME") == d("CARGO_PACKAGE_NAME", "CARGO_CRATE_NAME") == 4`)
+            if var.contains("PACKAGE") && known_var.contains("PKG") {
+                distance = distance.saturating_sub(const { "PACKAGE".len() - "PKG".len() }) // == d("PACKAGE", "PKG")
+            }
+
             if distance < best_distance {
                 best_distance = distance;
                 best_match = Some(known_var);
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index d3f7e1c5d8e3..e57d3f621f69 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -544,6 +544,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
 #[derive(Diagnostic)]
 pub(crate) enum EnvNotDefined<'a> {
     #[diag("environment variable `{$var}` not defined at compile time")]
+    #[help("`{$var}` may not be available for the current Cargo target")]
     #[help(
         "Cargo sets build script variables at run time. Use `std::env::var({$var_expr})` instead"
     )]
diff --git a/tests/ui/env-macro/env-cargo-var-typo-issue-148439.rs b/tests/ui/env-macro/env-cargo-var-typo-issue-148439.rs
index f859decd09ec..f72b43bb2543 100644
--- a/tests/ui/env-macro/env-cargo-var-typo-issue-148439.rs
+++ b/tests/ui/env-macro/env-cargo-var-typo-issue-148439.rs
@@ -1,4 +1,5 @@
 //@ edition: 2021
+//@ compile-flags: --crate-type=lib
 
 // Regression test for issue #148439
 // Ensure that when using misspelled Cargo environment variables in env!(),
@@ -44,7 +45,14 @@ fn test_cargo_unknown_var() {
     // Cargo-prefixed but not similar to any known variable
     let _ = env!("CARGO_SOMETHING_TOTALLY_UNKNOWN");
     //~^ ERROR environment variable `CARGO_SOMETHING_TOTALLY_UNKNOWN` not defined at compile time
+    //~| HELP `CARGO_SOMETHING_TOTALLY_UNKNOWN` may not be available for the current Cargo target
     //~| HELP Cargo sets build script variables at run time. Use `std::env::var("CARGO_SOMETHING_TOTALLY_UNKNOWN")` instead
 }
 
-fn main() {}
+fn test_cargo_conditional_var() {
+    // Only set for binairies
+    let _ = env!("CARGO_BIN_NAME");
+    //~^ ERROR environment variable `CARGO_BIN_NAME` not defined at compile time
+    //~| HELP `CARGO_BIN_NAME` may not be available for the current Cargo target
+    //~| HELP Cargo sets build script variables at run time. Use `std::env::var("CARGO_BIN_NAME")` instead
+}
diff --git a/tests/ui/env-macro/env-cargo-var-typo-issue-148439.stderr b/tests/ui/env-macro/env-cargo-var-typo-issue-148439.stderr
index e16c4d9a1f4c..50a4cf1a616b 100644
--- a/tests/ui/env-macro/env-cargo-var-typo-issue-148439.stderr
+++ b/tests/ui/env-macro/env-cargo-var-typo-issue-148439.stderr
@@ -1,5 +1,5 @@
 error: environment variable `CARGO_PACKAGE_VERSION` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:7:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:8:13
    |
 LL |     let _ = env!("CARGO_PACKAGE_VERSION");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let _ = env!("CARGO_PACKAGE_VERSION");
    = help: there is a similar Cargo environment variable: `CARGO_PKG_VERSION`
 
 error: environment variable `CARGO_PACKAGE_NAME` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:13:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:14:13
    |
 LL |     let _ = env!("CARGO_PACKAGE_NAME");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |     let _ = env!("CARGO_PACKAGE_NAME");
    = help: there is a similar Cargo environment variable: `CARGO_PKG_NAME`
 
 error: environment variable `CARGO_PACKAGE_AUTHORS` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:19:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:20:13
    |
 LL |     let _ = env!("CARGO_PACKAGE_AUTHORS");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |     let _ = env!("CARGO_PACKAGE_AUTHORS");
    = help: there is a similar Cargo environment variable: `CARGO_PKG_AUTHORS`
 
 error: environment variable `CARGO_MANIFEST_DIRECTORY` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:25:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:26:13
    |
 LL |     let _ = env!("CARGO_MANIFEST_DIRECTORY");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL |     let _ = env!("CARGO_MANIFEST_DIRECTORY");
    = help: there is a similar Cargo environment variable: `CARGO_MANIFEST_DIR`
 
 error: environment variable `CARGO_PKG_VERSIO` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:31:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:32:13
    |
 LL |     let _ = env!("CARGO_PKG_VERSIO");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     let _ = env!("CARGO_PKG_VERSIO");
    = help: there is a similar Cargo environment variable: `CARGO_PKG_VERSION`
 
 error: environment variable `MY_CUSTOM_VAR` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:38:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:39:13
    |
 LL |     let _ = env!("MY_CUSTOM_VAR");
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -47,12 +47,22 @@ LL |     let _ = env!("MY_CUSTOM_VAR");
    = help: use `std::env::var("MY_CUSTOM_VAR")` to read the variable at run time
 
 error: environment variable `CARGO_SOMETHING_TOTALLY_UNKNOWN` not defined at compile time
-  --> $DIR/env-cargo-var-typo-issue-148439.rs:45:13
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:46:13
    |
 LL |     let _ = env!("CARGO_SOMETHING_TOTALLY_UNKNOWN");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = help: `CARGO_SOMETHING_TOTALLY_UNKNOWN` may not be available for the current Cargo target
    = help: Cargo sets build script variables at run time. Use `std::env::var("CARGO_SOMETHING_TOTALLY_UNKNOWN")` instead
 
-error: aborting due to 7 previous errors
+error: environment variable `CARGO_BIN_NAME` not defined at compile time
+  --> $DIR/env-cargo-var-typo-issue-148439.rs:54:13
+   |
+LL |     let _ = env!("CARGO_BIN_NAME");
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `CARGO_BIN_NAME` may not be available for the current Cargo target
+   = help: Cargo sets build script variables at run time. Use `std::env::var("CARGO_BIN_NAME")` instead
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/env-macro/env-not-defined-default.stderr b/tests/ui/env-macro/env-not-defined-default.stderr
index 77ba00e45c1c..8340bb0e8fba 100644
--- a/tests/ui/env-macro/env-not-defined-default.stderr
+++ b/tests/ui/env-macro/env-not-defined-default.stderr
@@ -4,6 +4,7 @@ error: environment variable `CARGO__HOPEFULLY_NOT_DEFINED__` not defined at comp
 LL |     env!("CARGO__HOPEFULLY_NOT_DEFINED__");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = help: `CARGO__HOPEFULLY_NOT_DEFINED__` may not be available for the current Cargo target
    = help: Cargo sets build script variables at run time. Use `std::env::var("CARGO__HOPEFULLY_NOT_DEFINED__")` instead
 
 error: aborting due to 1 previous error

From 0d2a5d24d3ca2416eebb7000608a1ce176025302 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 7 Feb 2026 05:24:36 -0600
Subject: [PATCH 0028/1059] symcheck: Switch to getopts for argument parsing

It would be nice to support a few more flags here, but the current
implementation is a bit limited. Switch to `getopts` which should make
things a bit easier in the future.
---
 library/compiler-builtins/Cargo.toml          |  1 +
 library/compiler-builtins/ci/run.sh           | 16 ++--
 .../crates/symbol-check/Cargo.toml            |  1 +
 .../crates/symbol-check/src/main.rs           | 80 ++++++++++++-------
 .../crates/symbol-check/tests/all.rs          |  6 +-
 5 files changed, 64 insertions(+), 40 deletions(-)

diff --git a/library/compiler-builtins/Cargo.toml b/library/compiler-builtins/Cargo.toml
index 26f67e02fc52..3dff23d28577 100644
--- a/library/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/Cargo.toml
@@ -37,6 +37,7 @@ assert_cmd = "2.1.2"
 cc = "1.2.55"
 compiler_builtins = { path = "builtins-shim", default-features = false }
 criterion = { version = "0.6.0", default-features = false, features = ["cargo_bench_support"] }
+getopts = "0.2.24"
 getrandom = "0.3.4"
 gmp-mpfr-sys = { version = "1.6.8", default-features = false }
 gungraun = "0.17.0"
diff --git a/library/compiler-builtins/ci/run.sh b/library/compiler-builtins/ci/run.sh
index 12b3f37889c9..04e44e1cb859 100755
--- a/library/compiler-builtins/ci/run.sh
+++ b/library/compiler-builtins/ci/run.sh
@@ -48,21 +48,21 @@ fi
 # build with the arguments we provide it, then validates the built artifacts.
 SYMCHECK_TEST_TARGET="$target" cargo test -p symbol-check --release
 symcheck=(cargo run -p symbol-check --release)
-symcheck+=(-- build-and-check)
+symcheck+=(-- --build-and-check --target "$target")
 
-"${symcheck[@]}" "$target" -- -p compiler_builtins
-"${symcheck[@]}" "$target" -- -p compiler_builtins --release
-"${symcheck[@]}" "$target" -- -p compiler_builtins --features c
-"${symcheck[@]}" "$target" -- -p compiler_builtins --features c --release
-"${symcheck[@]}" "$target" -- -p compiler_builtins --features no-asm
-"${symcheck[@]}" "$target" -- -p compiler_builtins --features no-asm --release
+"${symcheck[@]}" -- -p compiler_builtins
+"${symcheck[@]}" -- -p compiler_builtins --release
+"${symcheck[@]}" -- -p compiler_builtins --features c
+"${symcheck[@]}" -- -p compiler_builtins --features c --release
+"${symcheck[@]}" -- -p compiler_builtins --features no-asm
+"${symcheck[@]}" -- -p compiler_builtins --features no-asm --release
 
 run_intrinsics_test() {
     build_args=(--verbose --manifest-path builtins-test-intrinsics/Cargo.toml)
     build_args+=("$@")
 
     # symcheck also checks the results of builtins-test-intrinsics
-    "${symcheck[@]}" "$target" -- "${build_args[@]}"
+    "${symcheck[@]}" -- "${build_args[@]}"
 
     # FIXME: we get access violations on Windows, our entrypoint may need to
     # be tweaked.
diff --git a/library/compiler-builtins/crates/symbol-check/Cargo.toml b/library/compiler-builtins/crates/symbol-check/Cargo.toml
index 5bc13d337c27..6d13f9488800 100644
--- a/library/compiler-builtins/crates/symbol-check/Cargo.toml
+++ b/library/compiler-builtins/crates/symbol-check/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
 publish = false
 
 [dependencies]
+getopts.workspace = true
 object.workspace = true
 regex.workspace = true
 serde_json.workspace = true
diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index 733d9f4e8bef..85aa7118aac2 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -8,7 +8,7 @@
 use std::fs;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::{Command, Stdio, exit};
 use std::sync::LazyLock;
 
 use object::read::archive::ArchiveFile;
@@ -24,38 +24,60 @@
 
 const USAGE: &str = "Usage:
 
-    symbol-check build-and-check [TARGET] -- CARGO_BUILD_ARGS ...
-
-Cargo will get invoked with `CARGO_ARGS` and the specified target. All output
-`compiler_builtins*.rlib` files will be checked.
-
-If TARGET is not specified, the host target is used.
-
-    check PATHS ...
-
-Run the same checks on the given set of paths, without invoking Cargo. Paths
-may be either archives or object files.
+    symbol-check --build-and-check [--target TARGET] -- CARGO_BUILD_ARGS ...
+    symbol-check --check PATHS ...\
 ";
 
 fn main() {
-    // Create a `&str` vec so we can match on it.
-    let args = std::env::args().collect::<Vec<_>>();
-    let args_ref = args.iter().map(String::as_str).collect::<Vec<_>>();
+    let mut opts = getopts::Options::new();
 
-    match &args_ref[1..] {
-        ["build-and-check", target, "--", args @ ..] if !args.is_empty() => {
-            run_build_and_check(target, args);
-        }
-        ["build-and-check", "--", args @ ..] if !args.is_empty() => {
-            run_build_and_check(env!("HOST"), args);
-        }
-        ["check", paths @ ..] if !paths.is_empty() => {
-            check_paths(paths);
-        }
-        _ => {
-            println!("{USAGE}");
-            std::process::exit(1);
+    // Ideally these would be subcommands but that isn't supported.
+    opts.optflag("h", "help", "Print this help message");
+    opts.optflag(
+        "",
+        "build-and-check",
+        "Cargo will get invoked with `CARGO_BUILD_ARGS` and the specified target. All output \
+        `compiler_builtins*.rlib` files will be checked.",
+    );
+    opts.optopt(
+        "",
+        "target",
+        "Set the target for build-and-check. Falls back to the host target otherwise.",
+        "TARGET",
+    );
+    opts.optflag(
+        "",
+        "check",
+        "Run checks on the given set of paths, without invoking Cargo. Paths \
+        may be either archives or object files.",
+    );
+
+    let print_usage_and_exit = |code: i32| -> ! {
+        eprintln!("{}", opts.usage(USAGE));
+        exit(code);
+    };
+
+    let m = opts.parse(std::env::args().skip(1)).unwrap_or_else(|e| {
+        eprintln!("{e}");
+        print_usage_and_exit(1);
+    });
+
+    if m.opt_present("help") {
+        print_usage_and_exit(0);
+    }
+
+    let free_args = m.free.iter().map(String::as_str).collect::<Vec<_>>();
+
+    if m.opt_present("build-and-check") {
+        let target = m.opt_str("target").unwrap_or(env!("HOST").to_string());
+        run_build_and_check(&target, &free_args);
+    } else if m.opt_present("check") {
+        if free_args.is_empty() {
+            print_usage_and_exit(1);
         }
+        check_paths(&free_args);
+    } else {
+        print_usage_and_exit(1);
     }
 }
 
@@ -65,7 +87,7 @@ fn run_build_and_check(target: &str, args: &[&str]) {
     for arg in args {
         assert!(
             !arg.contains("--target"),
-            "target must be passed positionally. {USAGE}"
+            "target must be passed to symbol-check"
         );
     }
 
diff --git a/library/compiler-builtins/crates/symbol-check/tests/all.rs b/library/compiler-builtins/crates/symbol-check/tests/all.rs
index 400469a49e2a..34a2dd3c399e 100644
--- a/library/compiler-builtins/crates/symbol-check/tests/all.rs
+++ b/library/compiler-builtins/crates/symbol-check/tests/all.rs
@@ -51,7 +51,7 @@ fn test_duplicates() {
     let status = ar.arg(&dup_out).status().unwrap();
     assert!(status.success());
 
-    let assert = cargo_bin_cmd!().arg("check").arg(&lib_out).assert();
+    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
     assert
         .failure()
         .stderr_contains("duplicate symbols")
@@ -65,7 +65,7 @@ fn test_core_symbols() {
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
     rustc_build(&input_dir().join("core_symbols.rs"), &lib_out, |cmd| cmd);
-    let assert = cargo_bin_cmd!().arg("check").arg(&lib_out).assert();
+    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
     assert
         .failure()
         .stderr_contains("found 1 undefined symbols from core")
@@ -77,7 +77,7 @@ fn test_good() {
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
     rustc_build(&input_dir().join("good.rs"), &lib_out, |cmd| cmd);
-    let assert = cargo_bin_cmd!().arg("check").arg(&lib_out).assert();
+    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
     assert.success();
 }
 

From 1da633ca4bcc0bb5ffb2a758ff6b9cb6bc78454f Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 13:16:50 -0600
Subject: [PATCH 0029/1059] symcheck: Always check args, simplify running
 functions

---
 .../crates/symbol-check/src/main.rs           | 23 +++++++------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index 85aa7118aac2..2520073de099 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -67,10 +67,17 @@ fn main() {
     }
 
     let free_args = m.free.iter().map(String::as_str).collect::<Vec<_>>();
+    for arg in &free_args {
+        assert!(
+            !arg.contains("--target"),
+            "target must be passed to symbol-check"
+        );
+    }
 
     if m.opt_present("build-and-check") {
         let target = m.opt_str("target").unwrap_or(env!("HOST").to_string());
-        run_build_and_check(&target, &free_args);
+        let paths = exec_cargo_with_args(&target, &free_args);
+        check_paths(&paths);
     } else if m.opt_present("check") {
         if free_args.is_empty() {
             print_usage_and_exit(1);
@@ -81,20 +88,6 @@ fn main() {
     }
 }
 
-fn run_build_and_check(target: &str, args: &[&str]) {
-    // Make sure `--target` isn't passed to avoid confusion (since it should be
-    // proivded only once, positionally).
-    for arg in args {
-        assert!(
-            !arg.contains("--target"),
-            "target must be passed to symbol-check"
-        );
-    }
-
-    let paths = exec_cargo_with_args(target, args);
-    check_paths(&paths);
-}
-
 fn check_paths<P: AsRef<Path>>(paths: &[P]) {
     for path in paths {
         let path = path.as_ref();

From 7d5135c25b4be6355de910dbe352b18fb435d713 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 13:16:50 -0600
Subject: [PATCH 0030/1059] symcheck: Clean up test setup that requires
 environment

---
 .../crates/symbol-check/tests/all.rs          | 103 +++++++++++-------
 1 file changed, 63 insertions(+), 40 deletions(-)

diff --git a/library/compiler-builtins/crates/symbol-check/tests/all.rs b/library/compiler-builtins/crates/symbol-check/tests/all.rs
index 34a2dd3c399e..f65038c62da6 100644
--- a/library/compiler-builtins/crates/symbol-check/tests/all.rs
+++ b/library/compiler-builtins/crates/symbol-check/tests/all.rs
@@ -2,7 +2,6 @@
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
-use std::sync::LazyLock;
 
 use assert_cmd::assert::Assert;
 use assert_cmd::cargo::cargo_bin_cmd;
@@ -13,6 +12,7 @@ trait AssertExt {
 }
 
 impl AssertExt for Assert {
+    #[track_caller]
     fn stderr_contains(self, s: &str) -> Self {
         let out = String::from_utf8_lossy(&self.get_output().stderr);
         assert!(out.contains(s), "looking for: `{s}`\nout:\n```\n{out}\n```");
@@ -22,18 +22,19 @@ fn stderr_contains(self, s: &str) -> Self {
 
 #[test]
 fn test_duplicates() {
+    let t = TestTarget::from_env();
     let dir = tempdir().unwrap();
     let dup_out = dir.path().join("dup.o");
     let lib_out = dir.path().join("libfoo.rlib");
 
     // For the "bad" file, we need duplicate symbols from different object files in the archive. Do
     // this reliably by building an archive and a separate object file then merging them.
-    rustc_build(&input_dir().join("duplicates.rs"), &lib_out, |cmd| cmd);
-    rustc_build(&input_dir().join("duplicates.rs"), &dup_out, |cmd| {
+    t.rustc_build(&input_dir().join("duplicates.rs"), &lib_out, |cmd| cmd);
+    t.rustc_build(&input_dir().join("duplicates.rs"), &dup_out, |cmd| {
         cmd.arg("--emit=obj")
     });
 
-    let mut ar = cc_build().get_archiver();
+    let mut ar = t.cc_build().get_archiver();
 
     if ar.get_program().to_string_lossy().contains("lib.exe") {
         let mut out_arg = OsString::from("-out:");
@@ -48,10 +49,10 @@ fn test_duplicates() {
             .stderr(Stdio::null())
             .arg(&lib_out);
     }
-    let status = ar.arg(&dup_out).status().unwrap();
-    assert!(status.success());
 
-    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
+    run(ar.arg(&dup_out));
+
+    let assert = t.symcheck_exe().arg(&lib_out).assert();
     assert
         .failure()
         .stderr_contains("duplicate symbols")
@@ -62,10 +63,11 @@ fn test_duplicates() {
 
 #[test]
 fn test_core_symbols() {
+    let t = TestTarget::from_env();
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
-    rustc_build(&input_dir().join("core_symbols.rs"), &lib_out, |cmd| cmd);
-    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
+    t.rustc_build(&input_dir().join("core_symbols.rs"), &lib_out, |cmd| cmd);
+    let assert = t.symcheck_exe().arg(&lib_out).assert();
     assert
         .failure()
         .stderr_contains("found 1 undefined symbols from core")
@@ -73,40 +75,24 @@ fn test_core_symbols() {
 }
 
 #[test]
-fn test_good() {
+fn test_good_lib() {
+    let t = TestTarget::from_env();
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
-    rustc_build(&input_dir().join("good.rs"), &lib_out, |cmd| cmd);
-    let assert = cargo_bin_cmd!().arg("--check").arg(&lib_out).assert();
+    t.rustc_build(&input_dir().join("good.rs"), &lib_out, |cmd| cmd);
+    let assert = t.symcheck_exe().arg(&lib_out).assert();
     assert.success();
 }
 
-/// Build i -> o with optional additional configuration.
-fn rustc_build(i: &Path, o: &Path, mut f: impl FnMut(&mut Command) -> &mut Command) {
-    let mut cmd = Command::new("rustc");
-    cmd.arg(i)
-        .arg("--target")
-        .arg(target())
-        .arg("--crate-type=lib")
-        .arg("-o")
-        .arg(o);
-    f(&mut cmd);
-    let status = cmd.status().unwrap();
-    assert!(status.success());
+/// Since symcheck is a hostprog, the target we want to build and test symcheck for may not be the
+/// same as the host target.
+struct TestTarget {
+    triple: String,
 }
 
-/// Configure `cc` with the host and target.
-fn cc_build() -> cc::Build {
-    let mut b = cc::Build::new();
-    b.host(env!("HOST")).target(&target());
-    b
-}
-
-/// Symcheck runs on the host but we want to verify that we find issues on all targets, so
-/// the cross target may be specified.
-fn target() -> String {
-    static TARGET: LazyLock<String> = LazyLock::new(|| {
-        let target = match env::var("SYMCHECK_TEST_TARGET") {
+impl TestTarget {
+    fn from_env() -> Self {
+        let triple = match env::var("SYMCHECK_TEST_TARGET") {
             Ok(t) => t,
             // Require on CI so we don't accidentally always test the native target
             _ if env::var("CI").is_ok() => panic!("SYMCHECK_TEST_TARGET must be set in CI"),
@@ -114,13 +100,50 @@ fn target() -> String {
             Err(_) => env!("HOST").to_string(),
         };
 
-        println!("using target {target}");
-        target
-    });
+        println!("using target {triple}");
+        Self { triple }
+    }
 
-    TARGET.clone()
+    /// Build i -> o with optional additional configuration.
+    fn rustc_build(&self, i: &Path, o: &Path, mut f: impl FnMut(&mut Command) -> &mut Command) {
+        let mut cmd = Command::new("rustc");
+        cmd.arg(i)
+            .arg("--target")
+            .arg(&self.triple)
+            .arg("--crate-type=lib")
+            .arg("-o")
+            .arg(o);
+        f(&mut cmd);
+        run(&mut cmd);
+    }
+
+    /// Configure `cc` with the host and target.
+    fn cc_build(&self) -> cc::Build {
+        let mut b = cc::Build::new();
+        b.host(env!("HOST"))
+            .target(&self.triple)
+            .opt_level(0)
+            .cargo_debug(true)
+            .cargo_metadata(false);
+        b
+    }
+
+    fn symcheck_exe(&self) -> assert_cmd::Command {
+        let mut cmd = cargo_bin_cmd!();
+        cmd.arg("--check");
+        cmd
+    }
 }
 
 fn input_dir() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/input")
 }
+
+#[track_caller]
+fn run(cmd: &mut Command) {
+    eprintln!("+ {cmd:?}");
+    let out = cmd.output().unwrap();
+    println!("{}", String::from_utf8_lossy(&out.stdout));
+    eprintln!("{}", String::from_utf8_lossy(&out.stderr));
+    assert!(out.status.success(), "{:?}", out.status);
+}

From 44b0bd98fd0be6bd0dd5dcea63620c0a41dda8ba Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 13:16:50 -0600
Subject: [PATCH 0031/1059] symcheck: Don't check for empty symbol tables with
 PE binaries

PE executables don't seem to have anything in the symbol table. Don't
assert that we find any symbols in this case, which allows using
symcheck for executable binaries.
---
 .../crates/symbol-check/src/main.rs           | 31 ++++++++++++++++---
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index 2520073de099..683bba285cde 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -13,8 +13,8 @@
 
 use object::read::archive::ArchiveFile;
 use object::{
-    File as ObjFile, Object, ObjectSection, ObjectSymbol, Result as ObjResult, Symbol, SymbolKind,
-    SymbolScope,
+    BinaryFormat, File as ObjFile, Object, ObjectSection, ObjectSymbol, Result as ObjResult,
+    Symbol, SymbolKind, SymbolScope,
 };
 use regex::Regex;
 use serde_json::Value;
@@ -259,7 +259,9 @@ fn verify_no_duplicates(archive: &BinFile) {
         found_any = true;
     });
 
-    assert!(found_any, "no symbols found");
+    if archive.has_symbol_tables() {
+        assert!(found_any, "no symbols found");
+    }
 
     if !dups.is_empty() {
         let count = dups.iter().map(|x| &x.name).collect::<HashSet<_>>().len();
@@ -300,7 +302,9 @@ fn verify_core_symbols(archive: &BinFile) {
         }
     });
 
-    assert!(has_symbols, "no symbols found");
+    if archive.has_symbol_tables() {
+        assert!(has_symbols, "no symbols found");
+    }
 
     // Discard any symbols that are defined somewhere in the archive
     undefined.retain(|sym| !defined.contains(&sym.name));
@@ -376,4 +380,23 @@ fn for_each_symbol(&self, mut f: impl FnMut(Symbol, &ObjFile, &str)) {
             obj.symbols().for_each(|sym| f(sym, &obj, obj_path));
         });
     }
+
+    /// PE executable files don't have the same kind of symbol tables. This isn't a perfectly
+    /// accurate check, but at least tells us whether we can skip erroring if we don't find any
+    /// symbols.
+    fn has_symbol_tables(&self) -> bool {
+        let mut empty = true;
+        let mut ret = false;
+
+        self.for_each_object(|obj, _obj_path| {
+            if !matches!(obj.format(), BinaryFormat::Pe) {
+                // Any non-PE objects should have symbol tables.
+                ret = true;
+            }
+            empty = false;
+        });
+
+        // If empty, assume there should be tables.
+        empty || ret
+    }
 }

From 15d02fc0d71f86fe09a882ed16a541b3f4de4ca0 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 13:16:50 -0600
Subject: [PATCH 0032/1059] symcheck: Check for binaries requiring a writeable
 + executable stack

Implement the following logic:

* For elf executable binaries, check for PT_GNU_STACK with PF_X. This
  combination tells the kernel to make the stack executable.
* For elf intermediate objects, check for `.note.GNU-stack` with
  SHF_EXECINSTR. This combination in an object file tells the linker to
  give the final binary PT_GNU_STACK PF_X.
* For elf intermediate objects with no `.note.GNU-stack`, assume the
  legacy behavior that assumes an executable stack is required.
* For non-elf binaries, don't check anything. In a follow up it may be
  possible to check for `MH_ALLOW_STACK_EXECUTION` on Mach-O binaries,
  but it doesn't seem possible to get the latest compiler to emit this.

This appears to match what is done by `scanelf` to emit `!WX` [1], which
seems to be the tool used to create the output in the issue. The ld
manpage [2] also has some useful notes about these flags, as does the
presentation at [3].

Closes: https://github.com/rust-lang/compiler-builtins/issues/183

[1]: https://github.com/gentoo/pax-utils/blob/9ef54b472e42ba2c5479fbd86b8be2275724b064/scanelf.c
[2]: https://man7.org/linux/man-pages/man1/ld.1.html
[3]: https://www.ndss-symposium.org/wp-content/uploads/6D-s0924-ye.pdf
---
 library/compiler-builtins/ci/run.sh           |   3 +
 .../crates/symbol-check/src/main.rs           | 194 +++++++++++++++++-
 .../crates/symbol-check/tests/all.rs          | 179 +++++++++++++++-
 .../symbol-check/tests/input/good_bin.c       |   3 +
 .../tests/input/{good.rs => good_lib.rs}      |   0
 .../tests/input/has_exe_gnu_stack_section.c   |  16 ++
 .../tests/input/missing_gnu_stack_section.S   |  19 ++
 7 files changed, 406 insertions(+), 8 deletions(-)
 create mode 100644 library/compiler-builtins/crates/symbol-check/tests/input/good_bin.c
 rename library/compiler-builtins/crates/symbol-check/tests/input/{good.rs => good_lib.rs} (100%)
 create mode 100644 library/compiler-builtins/crates/symbol-check/tests/input/has_exe_gnu_stack_section.c
 create mode 100644 library/compiler-builtins/crates/symbol-check/tests/input/missing_gnu_stack_section.S

diff --git a/library/compiler-builtins/ci/run.sh b/library/compiler-builtins/ci/run.sh
index 04e44e1cb859..b9a21d555c9e 100755
--- a/library/compiler-builtins/ci/run.sh
+++ b/library/compiler-builtins/ci/run.sh
@@ -50,6 +50,9 @@ SYMCHECK_TEST_TARGET="$target" cargo test -p symbol-check --release
 symcheck=(cargo run -p symbol-check --release)
 symcheck+=(-- --build-and-check --target "$target")
 
+# Executable section checks are meaningless on no-std targets
+[[ "$target" == *"-none"* ]] && symcheck+=(--no-os)
+
 "${symcheck[@]}" -- -p compiler_builtins
 "${symcheck[@]}" -- -p compiler_builtins --release
 "${symcheck[@]}" -- -p compiler_builtins --features c
diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index 683bba285cde..e15522d223d8 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -5,26 +5,27 @@
 //! actual target is cross compiled.
 
 use std::collections::{BTreeMap, BTreeSet, HashSet};
-use std::fs;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio, exit};
 use std::sync::LazyLock;
+use std::{env, fs};
 
 use object::read::archive::ArchiveFile;
 use object::{
-    BinaryFormat, File as ObjFile, Object, ObjectSection, ObjectSymbol, Result as ObjResult,
-    Symbol, SymbolKind, SymbolScope,
+    Architecture, BinaryFormat, Endianness, File as ObjFile, Object, ObjectSection, ObjectSymbol,
+    Result as ObjResult, SectionFlags, Symbol, SymbolKind, SymbolScope, U32, elf,
 };
 use regex::Regex;
 use serde_json::Value;
 
 const CHECK_LIBRARIES: &[&str] = &["compiler_builtins", "builtins_test_intrinsics"];
 const CHECK_EXTENSIONS: &[Option<&str>] = &[Some("rlib"), Some("a"), Some("exe"), None];
+const GNU_STACK: &str = ".note.GNU-stack";
 
 const USAGE: &str = "Usage:
 
-    symbol-check --build-and-check [--target TARGET] -- CARGO_BUILD_ARGS ...
+    symbol-check --build-and-check [--target TARGET] [--no-os] -- CARGO_BUILD_ARGS ...
     symbol-check --check PATHS ...\
 ";
 
@@ -51,6 +52,12 @@ fn main() {
         "Run checks on the given set of paths, without invoking Cargo. Paths \
         may be either archives or object files.",
     );
+    opts.optflag(
+        "",
+        "no-os",
+        "The binaries will not be checked for executable stacks. Used for embedded targets which \
+        don't set `.note.GNU-stack` since there is no protection.",
+    );
 
     let print_usage_and_exit = |code: i32| -> ! {
         eprintln!("{}", opts.usage(USAGE));
@@ -66,6 +73,7 @@ fn main() {
         print_usage_and_exit(0);
     }
 
+    let no_os_target = m.opt_present("no-os");
     let free_args = m.free.iter().map(String::as_str).collect::<Vec<_>>();
     for arg in &free_args {
         assert!(
@@ -77,18 +85,18 @@ fn main() {
     if m.opt_present("build-and-check") {
         let target = m.opt_str("target").unwrap_or(env!("HOST").to_string());
         let paths = exec_cargo_with_args(&target, &free_args);
-        check_paths(&paths);
+        check_paths(&paths, no_os_target);
     } else if m.opt_present("check") {
         if free_args.is_empty() {
             print_usage_and_exit(1);
         }
-        check_paths(&free_args);
+        check_paths(&free_args, no_os_target);
     } else {
         print_usage_and_exit(1);
     }
 }
 
-fn check_paths<P: AsRef<Path>>(paths: &[P]) {
+fn check_paths<P: AsRef<Path>>(paths: &[P], no_os_target: bool) {
     for path in paths {
         let path = path.as_ref();
         println!("Checking {}", path.display());
@@ -96,6 +104,7 @@ fn check_paths<P: AsRef<Path>>(paths: &[P]) {
 
         verify_no_duplicates(&archive);
         verify_core_symbols(&archive);
+        verify_no_exec_stack(&archive, no_os_target);
     }
 }
 
@@ -320,6 +329,177 @@ fn verify_core_symbols(archive: &BinFile) {
     println!("    success: no undefined references to core found");
 }
 
+/// Reasons a binary is considered to have an executable stack.
+enum ExeStack {
+    MissingGnuStackSec,
+    ExeGnuStackSec,
+    ExePtGnuStack,
+}
+
+/// Ensure that the object/archive will not require an executable stack.
+fn verify_no_exec_stack(archive: &BinFile, no_os_target: bool) {
+    if no_os_target {
+        // We don't really have a good way of knowing whether or not an elf file is for a
+        // no-os environment so we rely on a CLI arg (note.GNU-stack doesn't get emitted if
+        // there is no OS to protect the stack).
+        println!("    skipping check for writeable+executable stack on no-os target");
+        return;
+    }
+
+    let mut problem_objfiles = Vec::new();
+
+    archive.for_each_object(|obj, obj_path| match check_obj_exe_stack(&obj) {
+        Ok(()) => (),
+        Err(exe) => problem_objfiles.push((obj_path.to_owned(), exe)),
+    });
+
+    if problem_objfiles.is_empty() {
+        println!("    success: no writeable+executable stack indicators found");
+        return;
+    }
+
+    eprintln!("the following object files require an executable stack:");
+
+    for (obj, exe) in problem_objfiles {
+        let reason = match exe {
+            ExeStack::MissingGnuStackSec => "no .note.GNU-stack section",
+            ExeStack::ExeGnuStackSec => ".note.GNU-stack section marked SHF_EXECINSTR",
+            ExeStack::ExePtGnuStack => "PT_GNU_STACK program header marked PF_X",
+        };
+        eprintln!("    {obj} ({reason})");
+    }
+
+    exit(1);
+}
+
+/// `Err` if the section/flag combination indicates that the object file should be linked with an
+/// executable stack.
+fn check_obj_exe_stack(obj: &ObjFile) -> Result<(), ExeStack> {
+    match obj.format() {
+        BinaryFormat::Elf => check_elf_exe_stack(obj),
+        // Technically has the `MH_ALLOW_STACK_EXECUTION` flag but I can't get the compiler to
+        // emit it (`-allow_stack_execute` doesn't seem to work in recent versions).
+        BinaryFormat::MachO => Ok(()),
+        // Can't find much information about Windows stack executability.
+        BinaryFormat::Coff | BinaryFormat::Pe => Ok(()),
+        // Also not sure about wasm.
+        BinaryFormat::Wasm => Ok(()),
+        BinaryFormat::Xcoff | _ => {
+            unimplemented!("binary format {:?} is not supported", obj.format())
+        }
+    }
+}
+
+/// Check for an executable stack in elf binaries.
+///
+/// If the `PT_GNU_STACK` header on a binary is present and marked executable, the binary will
+/// have an executable stack (RWE rather than the desired RW). If any object file has the right
+/// `.note.GNU-stack` logic, the final binary will get `PT_GNU_STACK`.
+///
+/// Individual object file logic is as follows, paraphrased from [1]:
+///
+/// - A `.note.GNU-stack` section with the exe flag means this needs an executable stack
+/// - A `.note.GNU-stack` section without the exe flag means there is no executable stack needed
+/// - Without the section, behavior is target-specific. Historically it usually means an executable
+///   stack is required.
+///
+/// Per [2], it is now deprecated behavior for a missing `.note.GNU-stack` section to imply an
+/// executable stack. However, we shouldn't assume that tooling has caught up to this.
+///
+/// [1]: https://www.man7.org/linux/man-pages/man1/ld.1.html
+/// [2]: https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=0d38576a34ec64a1b4500c9277a8e9d0f07e6774>
+fn check_elf_exe_stack(obj: &ObjFile) -> Result<(), ExeStack> {
+    let end = obj.endianness();
+
+    // Check for PT_GNU_STACK marked executable
+    let mut is_obj_exe = false;
+    let mut found_gnu_stack = false;
+    let mut check_ph = |p_type: U32<Endianness>, p_flags: U32<Endianness>| {
+        let ty = p_type.get(end);
+        let flags = p_flags.get(end);
+
+        // Presence of PT_INTERP indicates that this is an executable rather than a standalone
+        // object file.
+        if ty == elf::PT_INTERP {
+            is_obj_exe = true;
+        }
+
+        if ty == elf::PT_GNU_STACK {
+            assert!(!found_gnu_stack, "multiple PT_GNU_STACK sections");
+            found_gnu_stack = true;
+            if flags & elf::PF_X != 0 {
+                return Err(ExeStack::ExePtGnuStack);
+            }
+        }
+
+        Ok(())
+    };
+
+    match obj {
+        ObjFile::Elf32(f) => {
+            for ph in f.elf_program_headers() {
+                check_ph(ph.p_type, ph.p_flags)?;
+            }
+        }
+        ObjFile::Elf64(f) => {
+            for ph in f.elf_program_headers() {
+                check_ph(ph.p_type, ph.p_flags)?;
+            }
+        }
+        _ => panic!("should only be called with elf objects"),
+    }
+
+    if is_obj_exe {
+        return Ok(());
+    }
+
+    // The remaining are checks for individual object files, which wind up controlling PT_GNU_STACK
+    // in the final binary.
+    let mut gnu_stack_exe = None;
+    let mut has_exe_sections = false;
+    for sec in obj.sections() {
+        let SectionFlags::Elf { sh_flags } = sec.flags() else {
+            unreachable!("only elf files are being checked");
+        };
+
+        let is_sec_exe = sh_flags & u64::from(elf::SHF_EXECINSTR) != 0;
+
+        // If the magic section is present, its exe bit tells us whether or not the object
+        // file requires an executable stack.
+        if sec.name().unwrap_or_default() == GNU_STACK {
+            assert!(gnu_stack_exe.is_none(), "multiple {GNU_STACK} sections");
+            if is_sec_exe {
+                gnu_stack_exe = Some(Err(ExeStack::ExeGnuStackSec));
+            } else {
+                gnu_stack_exe = Some(Ok(()));
+            }
+        }
+
+        // Otherwise, just keep track of whether or not we have exeuctable sections
+        has_exe_sections |= is_sec_exe;
+    }
+
+    // GNU_STACK sets the executability if specified.
+    if let Some(exe) = gnu_stack_exe {
+        return exe;
+    }
+
+    // Ignore object files that have no executable sections, like rmeta.
+    if !has_exe_sections {
+        return Ok(());
+    }
+
+    // If there is no `.note.GNU-stack` and no executable sections, behavior differs by platform.
+    match obj.architecture() {
+        // PPC64 doesn't set `.note.GNU-stack` since GNU nested functions don't need a trampoline,
+        // <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=21098>. From experimentation, it seems
+        // like this only applies to big endian.
+        Architecture::PowerPc64 if obj.endianness() == Endianness::Big => Ok(()),
+
+        _ => Err(ExeStack::MissingGnuStackSec),
+    }
+}
+
 /// Thin wrapper for owning data used by `object`.
 struct BinFile {
     path: PathBuf,
diff --git a/library/compiler-builtins/crates/symbol-check/tests/all.rs b/library/compiler-builtins/crates/symbol-check/tests/all.rs
index f65038c62da6..6dc34c3e3dba 100644
--- a/library/compiler-builtins/crates/symbol-check/tests/all.rs
+++ b/library/compiler-builtins/crates/symbol-check/tests/all.rs
@@ -5,6 +5,7 @@
 
 use assert_cmd::assert::Assert;
 use assert_cmd::cargo::cargo_bin_cmd;
+use object::BinaryFormat;
 use tempfile::tempdir;
 
 trait AssertExt {
@@ -74,16 +75,134 @@ fn test_core_symbols() {
         .stderr_contains("from_utf8");
 }
 
+mod exe_stack {
+    use super::*;
+
+    /// Check with an object that has no `.note.GNU-stack` section, indicating platform-default stack
+    /// writeability (usually enabled).
+    #[test]
+    fn test_missing_gnu_stack_section() {
+        let t = TestTarget::from_env();
+        if t.is_msvc() {
+            // Can't easily build asm via cc with cl.exe / masm.exe
+            eprintln!("assembly on windows, skipping");
+            return;
+        }
+
+        let dir = tempdir().unwrap();
+        let src = input_dir().join("missing_gnu_stack_section.S");
+
+        let objs = t.cc_build().file(src).out_dir(&dir).compile_intermediates();
+        let [obj] = objs.as_slice() else { panic!() };
+
+        let assert = t.symcheck_exe().arg(obj).assert();
+
+        if t.is_ppc64be() || t.no_os() || t.binary_obj_format() != BinaryFormat::Elf {
+            // Ppc64be doesn't emit `.note.GNU-stack`, not relevant without an OS, and non-elf
+            // targets don't use `.note.GNU-stack`.
+            assert.success();
+            return;
+        }
+
+        assert
+            .failure()
+            .stderr_contains("the following object files require an executable stack")
+            .stderr_contains("missing_gnu_stack_section.o (no .note.GNU-stack section)");
+    }
+
+    /// Check with an object that has a `.note.GNU-stack` section with the executable flag set.
+    #[test]
+    fn test_exe_gnu_stack_section() {
+        let t = TestTarget::from_env();
+        let mut build = t.cc_build();
+        if !build.get_compiler().is_like_gnu() || t.is_windows() {
+            eprintln!("unsupported compiler for nested functions, skipping");
+            return;
+        }
+
+        let dir = tempdir().unwrap();
+        let objs = build
+            .file(input_dir().join("has_exe_gnu_stack_section.c"))
+            .out_dir(&dir)
+            .compile_intermediates();
+        let [obj] = objs.as_slice() else { panic!() };
+
+        let assert = t.symcheck_exe().arg(obj).assert();
+
+        if t.is_ppc64be() || t.no_os() {
+            // Ppc64be doesn't emit `.note.GNU-stack`, not relevant without an OS.
+            assert.success();
+            return;
+        }
+
+        assert
+            .failure()
+            .stderr_contains("the following object files require an executable stack")
+            .stderr_contains(
+                "has_exe_gnu_stack_section.o (.note.GNU-stack section marked SHF_EXECINSTR)",
+            );
+    }
+
+    /// Check a final binary with `PT_GNU_STACK`.
+    #[test]
+    fn test_execstack_bin() {
+        let t = TestTarget::from_env();
+        if t.binary_obj_format() != BinaryFormat::Elf || !t.supports_executables() {
+            // Mac's Clang rejects `-z execstack`. `-allow_stack_execute` should work per the ld
+            // manpage, at least on x86, but it doesn't seem to., not relevant without an OS.
+            eprintln!("non-elf or no-executable target, skipping");
+            return;
+        }
+
+        let dir = tempdir().unwrap();
+        let out = dir.path().join("execstack.out");
+
+        let mut cmd = t.cc_build().get_compiler().to_command();
+        t.set_bin_out_path(&mut cmd, &out);
+
+        run(cmd
+            .arg("-z")
+            .arg("execstack")
+            .arg(input_dir().join("good_bin.c")));
+
+        let assert = t.symcheck_exe().arg(&out).assert();
+        assert
+            .failure()
+            .stderr_contains("the following object files require an executable stack")
+            .stderr_contains("execstack.out (PT_GNU_STACK program header marked PF_X)");
+    }
+}
+
 #[test]
 fn test_good_lib() {
     let t = TestTarget::from_env();
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
-    t.rustc_build(&input_dir().join("good.rs"), &lib_out, |cmd| cmd);
+    t.rustc_build(&input_dir().join("good_lib.rs"), &lib_out, |cmd| cmd);
     let assert = t.symcheck_exe().arg(&lib_out).assert();
     assert.success();
 }
 
+#[test]
+fn test_good_bin() {
+    let t = TestTarget::from_env();
+    // Nothing to test if we can't build a binary.
+    if !t.supports_executables() {
+        eprintln!("no-exe target, skipping");
+        return;
+    }
+
+    let dir = tempdir().unwrap();
+    let out = dir.path().join("good_bin.out");
+
+    let mut cmd = t.cc_build().get_compiler().to_command();
+    t.set_bin_out_path(&mut cmd, &out);
+    run(cmd.arg(input_dir().join("good_bin.c")));
+
+    let assert = t.symcheck_exe().arg(&out).assert();
+    assert.success();
+}
+
 /// Since symcheck is a hostprog, the target we want to build and test symcheck for may not be the
 /// same as the host target.
 struct TestTarget {
@@ -131,8 +250,66 @@ fn cc_build(&self) -> cc::Build {
     fn symcheck_exe(&self) -> assert_cmd::Command {
         let mut cmd = cargo_bin_cmd!();
         cmd.arg("--check");
+        if self.no_os() {
+            cmd.arg("--no-os");
+        }
         cmd
     }
+
+    /// MSVC requires different flags for setting output path, account for that here.
+    fn set_bin_out_path<'a>(&self, cmd: &'a mut Command, out: &Path) -> &'a mut Command {
+        if self.cc_build().get_compiler().is_like_msvc() {
+            let mut exe_arg = OsString::from("/Fe");
+            let mut obj_arg = OsString::from("/Fo");
+            exe_arg.push(out);
+            obj_arg.push(out.with_extension("o"));
+            cmd.arg(exe_arg).arg(obj_arg)
+        } else {
+            cmd.arg("-o").arg(out)
+        }
+    }
+
+    /// Based on `rustc_target`.
+    fn binary_obj_format(&self) -> BinaryFormat {
+        let t = &self.triple;
+        if t.contains("-windows-") || t.contains("-cygwin") {
+            // Coff for libraries, PE for executables.
+            BinaryFormat::Coff
+        } else if t.starts_with("wasm") {
+            BinaryFormat::Wasm
+        } else if t.contains("-aix") {
+            BinaryFormat::Xcoff
+        } else if t.contains("-apple-") {
+            BinaryFormat::MachO
+        } else {
+            BinaryFormat::Elf
+        }
+    }
+
+    fn is_windows(&self) -> bool {
+        self.triple.contains("-windows-")
+    }
+
+    fn is_msvc(&self) -> bool {
+        self.triple.contains("-windows-msvc")
+    }
+
+    fn is_ppc64be(&self) -> bool {
+        self.triple.starts_with("powerpc64-")
+    }
+
+    /// True if the target needs `--no-os` passed to symcheck.
+    fn no_os(&self) -> bool {
+        self.triple.contains("-none")
+    }
+
+    /// True if the target supports (easily) building to a final executable.
+    fn supports_executables(&self) -> bool {
+        // Technically i686-pc-windows-gnu should work but it has nontrivial setup in CI.
+        !(self.no_os()
+            || self.triple == "wasm32-unknown-unknown"
+            || self.triple == "i686-pc-windows-gnu")
+    }
 }
 
 fn input_dir() -> PathBuf {
diff --git a/library/compiler-builtins/crates/symbol-check/tests/input/good_bin.c b/library/compiler-builtins/crates/symbol-check/tests/input/good_bin.c
new file mode 100644
index 000000000000..dba75b58af1a
--- /dev/null
+++ b/library/compiler-builtins/crates/symbol-check/tests/input/good_bin.c
@@ -0,0 +1,3 @@
+/* empty main used to test binaries with compiler options */
+
+int main() {}
diff --git a/library/compiler-builtins/crates/symbol-check/tests/input/good.rs b/library/compiler-builtins/crates/symbol-check/tests/input/good_lib.rs
similarity index 100%
rename from library/compiler-builtins/crates/symbol-check/tests/input/good.rs
rename to library/compiler-builtins/crates/symbol-check/tests/input/good_lib.rs
diff --git a/library/compiler-builtins/crates/symbol-check/tests/input/has_exe_gnu_stack_section.c b/library/compiler-builtins/crates/symbol-check/tests/input/has_exe_gnu_stack_section.c
new file mode 100644
index 000000000000..d4be217b5a06
--- /dev/null
+++ b/library/compiler-builtins/crates/symbol-check/tests/input/has_exe_gnu_stack_section.c
@@ -0,0 +1,16 @@
+/* A file that requires an executable stack and thus will have a
+ * `.note.GNU-stack` section with the executable bit set.
+ *
+ * GNU nested functions are the only way I could find to force an explicitly
+ * executable stack. Supported by GCC only, not Clang.
+ */
+
+void intermediate(void (*)(int, int), int);
+
+void hack(int *array, int size) {
+    void store (int index, int value) {
+        array[index] = value;
+    }
+
+    intermediate(store, size);
+}
diff --git a/library/compiler-builtins/crates/symbol-check/tests/input/missing_gnu_stack_section.S b/library/compiler-builtins/crates/symbol-check/tests/input/missing_gnu_stack_section.S
new file mode 100644
index 000000000000..09bb761c40ba
--- /dev/null
+++ b/library/compiler-builtins/crates/symbol-check/tests/input/missing_gnu_stack_section.S
@@ -0,0 +1,19 @@
+/* Create an object file with no `.note.GNU-stack` section.
+ *
+ * Assembly files do not get that section, meaning platform-default stack
+ * executability is implied (usually yes on Linux).
+ */
+
+.global func
+
+#ifdef __wasm__
+.functype func () -> ()
+.type     func, @function
+#endif
+
+func:
+    nop
+
+#ifdef __wasm__
+    end_function
+#endif

From 200968c81db4920f6d2f1546c476a00ab6ea98af Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 20:55:17 -0600
Subject: [PATCH 0033/1059] ci: Pin Miri to the 2026-02-11 nightly

CI is failing with:

    error: failed to run custom build command for `quote v1.0.44`

    Caused by:
      process didn't exit successfully: `/home/runner/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/cargo-miri runner /home/runner/work/compiler-builtins/compiler-builtins/target/miri/debug/build/quote-32cc00414fa6f72d/build-script-build` (exit status: 1)
      --- stderr
      fatal error: file "/home/runner/work/compiler-builtins/compiler-builtins/target/miri/debug/build/quote-32cc00414fa6f72d/build-script-build" contains outdated or invalid JSON; try `cargo clean`

Link: https://rust-lang.zulipchat.com/#narrow/channel/269128-miri/topic/build-script-build.20contains.20outdated.20or.20invalid.20JSON/with/573426109
---
 library/compiler-builtins/.github/workflows/main.yaml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 3fed58f2a207..a62f847082ae 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -303,7 +303,9 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust (rustup)
-      run: rustup update nightly --no-self-update && rustup default nightly
+      # FIXME(ci): not working in the 2026-02-11 nightly
+      # https://rust-lang.zulipchat.com/#narrow/channel/269128-miri/topic/build-script-build.20contains.20outdated.20or.20invalid.20JSON/with/573426109
+      run: rustup update nightly-2026-02-10 --no-self-update && rustup default nightly-2026-02-10
       shell: bash
     - run: rustup component add miri
     - run: cargo miri setup

From 8f0208ecb2365135ae3f8a8f67544c43002ae8f4 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 02:58:18 +0000
Subject: [PATCH 0034/1059] Revert "ci: Temporarily disable native PPC and
 s390x jobs"

These were disabled due to permission issues, which should now be
resolved.

This reverts commit 28e0556a7bca6ca828186d9de74d30c7cb45db5e.
---
 .../compiler-builtins/.github/workflows/main.yaml    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index a62f847082ae..163b64616b0b 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -70,14 +70,14 @@ jobs:
           os: ubuntu-24.04
         - target: powerpc64le-unknown-linux-gnu
           os: ubuntu-24.04
-        # - target: powerpc64le-unknown-linux-gnu
-        #   os: ubuntu-24.04-ppc64le
-        #   # FIXME(rust#151807): remove once PPC builds work again.
-        #   channel: nightly-2026-01-23
+        - target: powerpc64le-unknown-linux-gnu
+          os: ubuntu-24.04-ppc64le
+          # FIXME(rust#151807): remove once PPC builds work again.
+          channel: nightly-2026-01-23
         - target: riscv64gc-unknown-linux-gnu
           os: ubuntu-24.04
-        # - target: s390x-unknown-linux-gnu
-        #   os: ubuntu-24.04-s390x
+        - target: s390x-unknown-linux-gnu
+          os: ubuntu-24.04-s390x
         - target: thumbv6m-none-eabi
           os: ubuntu-24.04
         - target: thumbv7em-none-eabi

From 804a1f87cfcce416cdfd10830e500ce5f50b4997 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 03:59:46 +0000
Subject: [PATCH 0035/1059] Revert "ci: Pin rustc on the native PowerPC job"

The nightly has the LLVM bump that resolves the relevant issue.

This reverts commit 99d1fc7752b0e09cff5729cd4f3783d23c23cb66.

Link: https://github.com/rust-lang/rust/pull/152428
---
 library/compiler-builtins/.github/workflows/main.yaml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 163b64616b0b..0375d1eb29de 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -72,8 +72,6 @@ jobs:
           os: ubuntu-24.04
         - target: powerpc64le-unknown-linux-gnu
           os: ubuntu-24.04-ppc64le
-          # FIXME(rust#151807): remove once PPC builds work again.
-          channel: nightly-2026-01-23
         - target: riscv64gc-unknown-linux-gnu
           os: ubuntu-24.04
         - target: s390x-unknown-linux-gnu

From f2bec36b92b9e3ba64d8b5b6ad390e534af64f24 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 20 Apr 2025 04:21:18 +0000
Subject: [PATCH 0036/1059] libm: Convert `frexp` and `ilogb` to a generic
 implementations

---
 .../etc/function-definitions.json             | 10 ++++--
 .../compiler-builtins/libm/src/math/frexp.rs  | 30 +++++++---------
 .../compiler-builtins/libm/src/math/frexpf.rs | 22 ------------
 .../libm/src/math/generic/frexp.rs            | 24 +++++++++++++
 .../libm/src/math/generic/ilogb.rs            | 35 +++++++++++++++++++
 .../libm/src/math/generic/mod.rs              |  4 +++
 .../compiler-builtins/libm/src/math/ilogb.rs  | 35 ++++---------------
 .../compiler-builtins/libm/src/math/ilogbf.rs | 28 ---------------
 .../compiler-builtins/libm/src/math/mod.rs    |  8 ++---
 9 files changed, 91 insertions(+), 105 deletions(-)
 delete mode 100644 library/compiler-builtins/libm/src/math/frexpf.rs
 create mode 100644 library/compiler-builtins/libm/src/math/generic/frexp.rs
 create mode 100644 library/compiler-builtins/libm/src/math/generic/ilogb.rs
 delete mode 100644 library/compiler-builtins/libm/src/math/ilogbf.rs

diff --git a/library/compiler-builtins/etc/function-definitions.json b/library/compiler-builtins/etc/function-definitions.json
index 4f796905b754..105d0266fc60 100644
--- a/library/compiler-builtins/etc/function-definitions.json
+++ b/library/compiler-builtins/etc/function-definitions.json
@@ -560,13 +560,15 @@
     },
     "frexp": {
         "sources": [
-            "libm/src/math/frexp.rs"
+            "libm/src/math/frexp.rs",
+            "libm/src/math/generic/frexp.rs"
         ],
         "type": "f64"
     },
     "frexpf": {
         "sources": [
-            "libm/src/math/frexpf.rs"
+            "libm/src/math/frexp.rs",
+            "libm/src/math/generic/frexp.rs"
         ],
         "type": "f32"
     },
@@ -584,13 +586,15 @@
     },
     "ilogb": {
         "sources": [
+            "libm/src/math/generic/ilogb.rs",
             "libm/src/math/ilogb.rs"
         ],
         "type": "f64"
     },
     "ilogbf": {
         "sources": [
-            "libm/src/math/ilogbf.rs"
+            "libm/src/math/generic/ilogb.rs",
+            "libm/src/math/ilogb.rs"
         ],
         "type": "f32"
     },
diff --git a/library/compiler-builtins/libm/src/math/frexp.rs b/library/compiler-builtins/libm/src/math/frexp.rs
index 932111eebc95..8281ed27bd5d 100644
--- a/library/compiler-builtins/libm/src/math/frexp.rs
+++ b/library/compiler-builtins/libm/src/math/frexp.rs
@@ -1,21 +1,15 @@
+/// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
+///
+/// That is, `x * 2^p` will represent the input value.
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub fn frexpf(x: f32) -> (f32, i32) {
+    super::generic::frexp(x)
+}
+
+/// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
+///
+/// That is, `x * 2^p` will represent the input value.
 #[cfg_attr(assert_no_panic, no_panic::no_panic)]
 pub fn frexp(x: f64) -> (f64, i32) {
-    let mut y = x.to_bits();
-    let ee = ((y >> 52) & 0x7ff) as i32;
-
-    if ee == 0 {
-        if x != 0.0 {
-            let x1p64 = f64::from_bits(0x43f0000000000000);
-            let (x, e) = frexp(x * x1p64);
-            return (x, e - 64);
-        }
-        return (x, 0);
-    } else if ee == 0x7ff {
-        return (x, 0);
-    }
-
-    let e = ee - 0x3fe;
-    y &= 0x800fffffffffffff;
-    y |= 0x3fe0000000000000;
-    return (f64::from_bits(y), e);
+    super::generic::frexp(x)
 }
diff --git a/library/compiler-builtins/libm/src/math/frexpf.rs b/library/compiler-builtins/libm/src/math/frexpf.rs
deleted file mode 100644
index 904bf14f7b8e..000000000000
--- a/library/compiler-builtins/libm/src/math/frexpf.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#[cfg_attr(assert_no_panic, no_panic::no_panic)]
-pub fn frexpf(x: f32) -> (f32, i32) {
-    let mut y = x.to_bits();
-    let ee: i32 = ((y >> 23) & 0xff) as i32;
-
-    if ee == 0 {
-        if x != 0.0 {
-            let x1p64 = f32::from_bits(0x5f800000);
-            let (x, e) = frexpf(x * x1p64);
-            return (x, e - 64);
-        } else {
-            return (x, 0);
-        }
-    } else if ee == 0xff {
-        return (x, 0);
-    }
-
-    let e = ee - 0x7e;
-    y &= 0x807fffff;
-    y |= 0x3f000000;
-    (f32::from_bits(y), e)
-}
diff --git a/library/compiler-builtins/libm/src/math/generic/frexp.rs b/library/compiler-builtins/libm/src/math/generic/frexp.rs
new file mode 100644
index 000000000000..d5c2758a4b04
--- /dev/null
+++ b/library/compiler-builtins/libm/src/math/generic/frexp.rs
@@ -0,0 +1,24 @@
+use super::super::{CastFrom, Float, MinInt};
+
+#[inline]
+pub fn frexp<F: Float>(x: F) -> (F, i32) {
+    let mut ix = x.to_bits();
+    let ee = x.ex() as i32;
+
+    if ee == 0 {
+        if x != F::ZERO {
+            // normalize via multiplication; 1p64 for `f64`
+            let magic = F::from_parts(false, F::EXP_BIAS + F::BITS, F::Int::ZERO);
+            let (x, e) = frexp(x * magic);
+            return (x, e - F::BITS as i32);
+        }
+        return (x, 0);
+    } else if ee == F::EXP_SAT as i32 {
+        return (x, 0);
+    }
+
+    let e = ee - (F::EXP_BIAS as i32 - 1);
+    ix &= F::SIGN_MASK | F::SIG_MASK;
+    ix |= F::Int::cast_from(F::EXP_BIAS - 1) << F::SIG_BITS;
+    (F::from_bits(ix), e)
+}
diff --git a/library/compiler-builtins/libm/src/math/generic/ilogb.rs b/library/compiler-builtins/libm/src/math/generic/ilogb.rs
new file mode 100644
index 000000000000..02a7d6b30b10
--- /dev/null
+++ b/library/compiler-builtins/libm/src/math/generic/ilogb.rs
@@ -0,0 +1,35 @@
+use super::super::{Float, MinInt};
+
+const FP_ILOGBNAN: i32 = i32::MIN;
+const FP_ILOGB0: i32 = FP_ILOGBNAN;
+
+#[inline]
+pub fn ilogb<F: Float>(x: F) -> i32 {
+    let zero = F::Int::ZERO;
+    let mut i = x.to_bits();
+    let e = x.ex() as i32;
+
+    if e == 0 {
+        i <<= F::EXP_BITS + 1;
+        if i == F::Int::ZERO {
+            force_eval!(0.0 / 0.0);
+            return FP_ILOGB0;
+        }
+        /* subnormal x */
+        let mut e = -(F::EXP_BIAS as i32);
+        while i >> (F::BITS - 1) == zero {
+            e -= 1;
+            i <<= 1;
+        }
+        e
+    } else if e == F::EXP_SAT as i32 {
+        force_eval!(0.0 / 0.0);
+        if i << (F::EXP_BITS + 1) != zero {
+            FP_ILOGBNAN
+        } else {
+            i32::MAX
+        }
+    } else {
+        e - F::EXP_BIAS as i32
+    }
+}
diff --git a/library/compiler-builtins/libm/src/math/generic/mod.rs b/library/compiler-builtins/libm/src/math/generic/mod.rs
index 9d497a03f544..114fcddf516e 100644
--- a/library/compiler-builtins/libm/src/math/generic/mod.rs
+++ b/library/compiler-builtins/libm/src/math/generic/mod.rs
@@ -15,6 +15,8 @@
 mod fminimum;
 mod fminimum_num;
 mod fmod;
+mod frexp;
+mod ilogb;
 mod rint;
 mod round;
 mod scalbn;
@@ -35,6 +37,8 @@
 pub use fminimum::fminimum;
 pub use fminimum_num::fminimum_num;
 pub use fmod::fmod;
+pub use frexp::frexp;
+pub use ilogb::ilogb;
 pub use rint::rint_round;
 pub use round::round;
 pub use scalbn::scalbn;
diff --git a/library/compiler-builtins/libm/src/math/ilogb.rs b/library/compiler-builtins/libm/src/math/ilogb.rs
index ef774f6ad3a6..13bef5f8c617 100644
--- a/library/compiler-builtins/libm/src/math/ilogb.rs
+++ b/library/compiler-builtins/libm/src/math/ilogb.rs
@@ -1,32 +1,11 @@
-const FP_ILOGBNAN: i32 = -1 - 0x7fffffff;
-const FP_ILOGB0: i32 = FP_ILOGBNAN;
+/// Extract the binary exponent of `x`.
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub fn ilogbf(x: f32) -> i32 {
+    super::generic::ilogb(x)
+}
 
+/// Extract the binary exponent of `x`.
 #[cfg_attr(assert_no_panic, no_panic::no_panic)]
 pub fn ilogb(x: f64) -> i32 {
-    let mut i: u64 = x.to_bits();
-    let e = ((i >> 52) & 0x7ff) as i32;
-
-    if e == 0 {
-        i <<= 12;
-        if i == 0 {
-            force_eval!(0.0 / 0.0);
-            return FP_ILOGB0;
-        }
-        /* subnormal x */
-        let mut e = -0x3ff;
-        while (i >> 63) == 0 {
-            e -= 1;
-            i <<= 1;
-        }
-        e
-    } else if e == 0x7ff {
-        force_eval!(0.0 / 0.0);
-        if (i << 12) != 0 {
-            FP_ILOGBNAN
-        } else {
-            i32::MAX
-        }
-    } else {
-        e - 0x3ff
-    }
+    super::generic::ilogb(x)
 }
diff --git a/library/compiler-builtins/libm/src/math/ilogbf.rs b/library/compiler-builtins/libm/src/math/ilogbf.rs
deleted file mode 100644
index 5b0cb46ec558..000000000000
--- a/library/compiler-builtins/libm/src/math/ilogbf.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-const FP_ILOGBNAN: i32 = -1 - 0x7fffffff;
-const FP_ILOGB0: i32 = FP_ILOGBNAN;
-
-#[cfg_attr(assert_no_panic, no_panic::no_panic)]
-pub fn ilogbf(x: f32) -> i32 {
-    let mut i = x.to_bits();
-    let e = ((i >> 23) & 0xff) as i32;
-
-    if e == 0 {
-        i <<= 9;
-        if i == 0 {
-            force_eval!(0.0 / 0.0);
-            return FP_ILOGB0;
-        }
-        /* subnormal x */
-        let mut e = -0x7f;
-        while (i >> 31) == 0 {
-            e -= 1;
-            i <<= 1;
-        }
-        e
-    } else if e == 0xff {
-        force_eval!(0.0 / 0.0);
-        if (i << 9) != 0 { FP_ILOGBNAN } else { i32::MAX }
-    } else {
-        e - 0x7f
-    }
-}
diff --git a/library/compiler-builtins/libm/src/math/mod.rs b/library/compiler-builtins/libm/src/math/mod.rs
index 8eecfe5667d1..c1ea60e368d9 100644
--- a/library/compiler-builtins/libm/src/math/mod.rs
+++ b/library/compiler-builtins/libm/src/math/mod.rs
@@ -166,11 +166,9 @@ macro_rules! div {
 mod fminimum_fmaximum_num;
 mod fmod;
 mod frexp;
-mod frexpf;
 mod hypot;
 mod hypotf;
 mod ilogb;
-mod ilogbf;
 mod j0;
 mod j0f;
 mod j1;
@@ -260,12 +258,10 @@ macro_rules! div {
 pub use self::fminimum_fmaximum::{fmaximum, fmaximumf, fminimum, fminimumf};
 pub use self::fminimum_fmaximum_num::{fmaximum_num, fmaximum_numf, fminimum_num, fminimum_numf};
 pub use self::fmod::{fmod, fmodf};
-pub use self::frexp::frexp;
-pub use self::frexpf::frexpf;
+pub use self::frexp::{frexp, frexpf};
 pub use self::hypot::hypot;
 pub use self::hypotf::hypotf;
-pub use self::ilogb::ilogb;
-pub use self::ilogbf::ilogbf;
+pub use self::ilogb::{ilogb, ilogbf};
 pub use self::j0::{j0, y0};
 pub use self::j0f::{j0f, y0f};
 pub use self::j1::{j1, y1};

From 212652c5d4abf5c92c4a654ed9bad1e4dbff809b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 20 Apr 2025 04:21:18 +0000
Subject: [PATCH 0037/1059] libm: Add `frexpf128`, `ilogbf16`, and `ilogbf128`

The `frexpf16` signature is added (to make traits easier) but left
unimplemented, since it will need a slightly different algorithm.
---
 .../crates/libm-macros/src/shared.rs          | 36 +++++++++++
 .../etc/function-definitions.json             | 21 ++++++
 .../compiler-builtins/etc/function-list.txt   |  3 +
 .../libm-test/benches/icount.rs               |  3 +
 .../libm-test/src/generate/case_list.rs       | 19 +++++-
 .../libm-test/src/mpfloat.rs                  | 64 ++++++++++++-------
 .../libm-test/src/test_traits.rs              | 12 ++++
 .../compiler-builtins/libm/src/libm_helper.rs |  4 ++
 .../compiler-builtins/libm/src/math/frexp.rs  | 20 ++++++
 .../compiler-builtins/libm/src/math/ilogb.rs  | 14 ++++
 .../compiler-builtins/libm/src/math/mod.rs    |  6 ++
 11 files changed, 177 insertions(+), 25 deletions(-)

diff --git a/library/compiler-builtins/crates/libm-macros/src/shared.rs b/library/compiler-builtins/crates/libm-macros/src/shared.rs
index 1cefe4e8c7ed..5a5eca6f685d 100644
--- a/library/compiler-builtins/crates/libm-macros/src/shared.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/shared.rs
@@ -279,6 +279,17 @@ struct NestedOp {
         fn_list: &["fmaf128"],
         public: true,
     },
+    NestedOp {
+        // `(f16) -> i32`
+        float_ty: FloatTy::F16,
+        rust_sig: Signature {
+            args: &[Ty::F16],
+            returns: &[Ty::I32],
+        },
+        c_sig: None,
+        fn_list: &["ilogbf16"],
+        public: true,
+    },
     NestedOp {
         // `(f32) -> i32`
         float_ty: FloatTy::F32,
@@ -301,6 +312,17 @@ struct NestedOp {
         fn_list: &["ilogb"],
         public: true,
     },
+    NestedOp {
+        // `(f128) -> i32`
+        float_ty: FloatTy::F128,
+        rust_sig: Signature {
+            args: &[Ty::F128],
+            returns: &[Ty::I32],
+        },
+        c_sig: None,
+        fn_list: &["ilogbf128"],
+        public: true,
+    },
     NestedOp {
         // `(i32, f32) -> f32`
         float_ty: FloatTy::F32,
@@ -423,6 +445,20 @@ struct NestedOp {
         fn_list: &["frexp", "lgamma_r"],
         public: true,
     },
+    NestedOp {
+        // `(f128, &mut c_int) -> f128` as `(f128) -> (f128, i32)`
+        float_ty: FloatTy::F128,
+        rust_sig: Signature {
+            args: &[Ty::F128],
+            returns: &[Ty::F128, Ty::I32],
+        },
+        c_sig: Some(Signature {
+            args: &[Ty::F128, Ty::MutCInt],
+            returns: &[Ty::F128],
+        }),
+        fn_list: &["frexpf128"],
+        public: true,
+    },
     NestedOp {
         // `(f32, f32, &mut c_int) -> f32` as `(f32, f32) -> (f32, i32)`
         float_ty: FloatTy::F32,
diff --git a/library/compiler-builtins/etc/function-definitions.json b/library/compiler-builtins/etc/function-definitions.json
index 105d0266fc60..06eb1ad5e2e7 100644
--- a/library/compiler-builtins/etc/function-definitions.json
+++ b/library/compiler-builtins/etc/function-definitions.json
@@ -572,6 +572,13 @@
         ],
         "type": "f32"
     },
+    "frexpf128": {
+        "sources": [
+            "libm/src/math/frexp.rs",
+            "libm/src/math/generic/frexp.rs"
+        ],
+        "type": "f128"
+    },
     "hypot": {
         "sources": [
             "libm/src/math/hypot.rs"
@@ -598,6 +605,20 @@
         ],
         "type": "f32"
     },
+    "ilogbf128": {
+        "sources": [
+            "libm/src/math/generic/ilogb.rs",
+            "libm/src/math/ilogb.rs"
+        ],
+        "type": "f128"
+    },
+    "ilogbf16": {
+        "sources": [
+            "libm/src/math/generic/ilogb.rs",
+            "libm/src/math/ilogb.rs"
+        ],
+        "type": "f16"
+    },
     "j0": {
         "sources": [
             "libm/src/math/j0.rs"
diff --git a/library/compiler-builtins/etc/function-list.txt b/library/compiler-builtins/etc/function-list.txt
index 1f226c8c0ff3..45a39e3eee8d 100644
--- a/library/compiler-builtins/etc/function-list.txt
+++ b/library/compiler-builtins/etc/function-list.txt
@@ -84,10 +84,13 @@ fmodf128
 fmodf16
 frexp
 frexpf
+frexpf128
 hypot
 hypotf
 ilogb
 ilogbf
+ilogbf128
+ilogbf16
 j0
 j0f
 j1
diff --git a/library/compiler-builtins/libm-test/benches/icount.rs b/library/compiler-builtins/libm-test/benches/icount.rs
index fb856d9be451..be5178e205a2 100644
--- a/library/compiler-builtins/libm-test/benches/icount.rs
+++ b/library/compiler-builtins/libm-test/benches/icount.rs
@@ -331,10 +331,13 @@ fn icount_bench_print_hf128(x: f128) -> String {
     icount_bench_fmodf16_group,
     icount_bench_fmodf_group,
     icount_bench_frexp_group,
+    icount_bench_frexpf128_group,
     icount_bench_frexpf_group,
     icount_bench_hypot_group,
     icount_bench_hypotf_group,
     icount_bench_ilogb_group,
+    icount_bench_ilogbf128_group,
+    icount_bench_ilogbf16_group,
     icount_bench_ilogbf_group,
     icount_bench_j0_group,
     icount_bench_j0f_group,
diff --git a/library/compiler-builtins/libm-test/src/generate/case_list.rs b/library/compiler-builtins/libm-test/src/generate/case_list.rs
index 43b28722f2dd..958e03ab67f0 100644
--- a/library/compiler-builtins/libm-test/src/generate/case_list.rs
+++ b/library/compiler-builtins/libm-test/src/generate/case_list.rs
@@ -460,11 +460,16 @@ fn fmodf16_cases() -> Vec<TestCase<op::fmodf16::Routine>> {
     vec![]
 }
 
+fn frexpf_cases() -> Vec<TestCase<op::frexpf::Routine>> {
+    vec![]
+}
+
 fn frexp_cases() -> Vec<TestCase<op::frexp::Routine>> {
     vec![]
 }
 
-fn frexpf_cases() -> Vec<TestCase<op::frexpf::Routine>> {
+#[cfg(f128_enabled)]
+fn frexpf128_cases() -> Vec<TestCase<op::frexpf128::Routine>> {
     vec![]
 }
 
@@ -476,7 +481,8 @@ fn hypotf_cases() -> Vec<TestCase<op::hypotf::Routine>> {
     vec![]
 }
 
-fn ilogb_cases() -> Vec<TestCase<op::ilogb::Routine>> {
+#[cfg(f16_enabled)]
+fn ilogbf16_cases() -> Vec<TestCase<op::ilogbf16::Routine>> {
     vec![]
 }
 
@@ -484,6 +490,15 @@ fn ilogbf_cases() -> Vec<TestCase<op::ilogbf::Routine>> {
     vec![]
 }
 
+fn ilogb_cases() -> Vec<TestCase<op::ilogb::Routine>> {
+    vec![]
+}
+
+#[cfg(f128_enabled)]
+fn ilogbf128_cases() -> Vec<TestCase<op::ilogbf128::Routine>> {
+    vec![]
+}
+
 fn j0_cases() -> Vec<TestCase<op::j0::Routine>> {
     vec![]
 }
diff --git a/library/compiler-builtins/libm-test/src/mpfloat.rs b/library/compiler-builtins/libm-test/src/mpfloat.rs
index 85f0a4da4a6e..3237a232f7dc 100644
--- a/library/compiler-builtins/libm-test/src/mpfloat.rs
+++ b/library/compiler-builtins/libm-test/src/mpfloat.rs
@@ -162,8 +162,11 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
         fmodf16,
         frexp,
         frexpf,
+        frexpf128,
         ilogb,
         ilogbf,
+        ilogbf128,
+        ilogbf16,
         jn,
         jnf,
         ldexp,
@@ -338,29 +341,6 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
                 }
             }
 
-            impl MpOp for crate::op::[<ilogb $suffix>]::Routine {
-                type MpTy = MpFloat;
-
-                fn new_mp() -> Self::MpTy {
-                    new_mpfloat::<Self::FTy>()
-                }
-
-                fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
-                    this.assign(input.0);
-
-                    // `get_exp` follows `frexp` for `0.5 <= |m| < 1.0`. Adjust the exponent by
-                    // one to scale the significand to `1.0 <= |m| < 2.0`.
-                    this.get_exp().map(|v| v - 1).unwrap_or_else(|| {
-                        if this.is_infinite() {
-                            i32::MAX
-                        } else {
-                            // Zero or NaN
-                            i32::MIN
-                        }
-                    })
-                }
-            }
-
             impl MpOp for crate::op::[<jn $suffix>]::Routine {
                 type MpTy = MpFloat;
 
@@ -505,6 +485,29 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
                 }
             }
 
+            impl MpOp for crate::op::[<ilogb $suffix>]::Routine {
+                type MpTy = MpFloat;
+
+                fn new_mp() -> Self::MpTy {
+                    new_mpfloat::<Self::FTy>()
+                }
+
+                fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
+                    this.assign(input.0);
+
+                    // `get_exp` follows `frexp` for `0.5 <= |m| < 1.0`. Adjust the exponent by
+                    // one to scale the significand to `1.0 <= |m| < 2.0`.
+                    this.get_exp().map(|v| v - 1).unwrap_or_else(|| {
+                        if this.is_infinite() {
+                            i32::MAX
+                        } else {
+                            // Zero or NaN
+                            i32::MIN
+                        }
+                    })
+                }
+            }
+
             // `ldexp` and `scalbn` are the same for binary floating point, so just forward all
             // methods.
             impl MpOp for crate::op::[<ldexp $suffix>]::Routine {
@@ -546,6 +549,21 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
 #[cfg(f128_enabled)]
 impl_op_for_ty_all!(f128, "f128");
 
+#[cfg(f128_enabled)]
+impl MpOp for crate::op::frexpf128::Routine {
+    type MpTy = MpFloat;
+
+    fn new_mp() -> Self::MpTy {
+        new_mpfloat::<Self::FTy>()
+    }
+
+    fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
+        this.assign(input.0);
+        let exp = this.frexp_mut();
+        (prep_retval::<Self::FTy>(this, Ordering::Equal), exp)
+    }
+}
+
 // `lgamma_r` is not a simple suffix so we can't use the above macro.
 impl MpOp for crate::op::lgamma_r::Routine {
     type MpTy = MpFloat;
diff --git a/library/compiler-builtins/libm-test/src/test_traits.rs b/library/compiler-builtins/libm-test/src/test_traits.rs
index 278274d917b3..8b21e2af9a04 100644
--- a/library/compiler-builtins/libm-test/src/test_traits.rs
+++ b/library/compiler-builtins/libm-test/src/test_traits.rs
@@ -456,3 +456,15 @@ fn validate<'a>(
     (f32, f32);
     (f64, f64);
 );
+
+#[cfg(f16_enabled)]
+impl_tuples!(
+    (f16, i32);
+    (f16, f16);
+);
+
+#[cfg(f128_enabled)]
+impl_tuples!(
+    (f128, i32);
+    (f128, f128);
+);
diff --git a/library/compiler-builtins/libm/src/libm_helper.rs b/library/compiler-builtins/libm/src/libm_helper.rs
index 0bb669398657..1e6e0beb3e3e 100644
--- a/library/compiler-builtins/libm/src/libm_helper.rs
+++ b/library/compiler-builtins/libm/src/libm_helper.rs
@@ -202,6 +202,8 @@ pub fn $func($($arg: $arg_typ),*) -> ($($ret_typ),*) {
         (fn fminimum(x: f16, y: f16) -> (f16);      => fminimumf16);
         (fn fminimum_num(x: f16, y: f16) -> (f16);  => fminimum_numf16);
         (fn fmod(x: f16, y: f16) -> (f16);          => fmodf16);
+        (fn frexp(x: f16) -> (f16, i32);            => frexpf16);
+        (fn ilogb(x: f16) -> (i32);                 => ilogbf16);
         (fn ldexp(x: f16, n: i32) -> (f16);         => ldexpf16);
         (fn rint(x: f16) -> (f16);                  => rintf16);
         (fn round(x: f16) -> (f16);                 => roundf16);
@@ -231,6 +233,8 @@ pub fn $func($($arg: $arg_typ),*) -> ($($ret_typ),*) {
         (fn fminimum(x: f128, y: f128) -> (f128);      => fminimumf128);
         (fn fminimum_num(x: f128, y: f128) -> (f128);  => fminimum_numf128);
         (fn fmod(x: f128, y: f128) -> (f128);       => fmodf128);
+        (fn frexp(x: f128) -> (f128, i32);            => frexpf128);
+        (fn ilogb(x: f128) -> (i32);                 => ilogbf128);
         (fn ldexp(x: f128, n: i32) -> (f128);       => ldexpf128);
         (fn rint(x: f128) -> (f128);                => rintf128);
         (fn round(x: f128) -> (f128);               => roundf128);
diff --git a/library/compiler-builtins/libm/src/math/frexp.rs b/library/compiler-builtins/libm/src/math/frexp.rs
index 8281ed27bd5d..f2f545fb65e4 100644
--- a/library/compiler-builtins/libm/src/math/frexp.rs
+++ b/library/compiler-builtins/libm/src/math/frexp.rs
@@ -1,3 +1,14 @@
+/// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
+///
+/// That is, `x * 2^p` will represent the input value.
+// Placeholder so we can have `frexpf16` in the `Float` trait.
+#[allow(unused)]
+#[cfg(f16_enabled)]
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub(crate) fn frexpf16(x: f16) -> (f16, i32) {
+    unimplemented!()
+}
+
 /// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
 ///
 /// That is, `x * 2^p` will represent the input value.
@@ -13,3 +24,12 @@ pub fn frexpf(x: f32) -> (f32, i32) {
 pub fn frexp(x: f64) -> (f64, i32) {
     super::generic::frexp(x)
 }
+
+/// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
+///
+/// That is, `x * 2^p` will represent the input value.
+#[cfg(f128_enabled)]
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub fn frexpf128(x: f128) -> (f128, i32) {
+    super::generic::frexp(x)
+}
diff --git a/library/compiler-builtins/libm/src/math/ilogb.rs b/library/compiler-builtins/libm/src/math/ilogb.rs
index 13bef5f8c617..4c3f0a6aa045 100644
--- a/library/compiler-builtins/libm/src/math/ilogb.rs
+++ b/library/compiler-builtins/libm/src/math/ilogb.rs
@@ -1,3 +1,10 @@
+/// Extract the binary exponent of `x`.
+#[cfg(f16_enabled)]
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub fn ilogbf16(x: f16) -> i32 {
+    super::generic::ilogb(x)
+}
+
 /// Extract the binary exponent of `x`.
 #[cfg_attr(assert_no_panic, no_panic::no_panic)]
 pub fn ilogbf(x: f32) -> i32 {
@@ -9,3 +16,10 @@ pub fn ilogbf(x: f32) -> i32 {
 pub fn ilogb(x: f64) -> i32 {
     super::generic::ilogb(x)
 }
+
+/// Extract the binary exponent of `x`.
+#[cfg(f128_enabled)]
+#[cfg_attr(assert_no_panic, no_panic::no_panic)]
+pub fn ilogbf128(x: f128) -> i32 {
+    super::generic::ilogb(x)
+}
diff --git a/library/compiler-builtins/libm/src/math/mod.rs b/library/compiler-builtins/libm/src/math/mod.rs
index c1ea60e368d9..0484fe6a3765 100644
--- a/library/compiler-builtins/libm/src/math/mod.rs
+++ b/library/compiler-builtins/libm/src/math/mod.rs
@@ -322,6 +322,7 @@ macro_rules! div {
         pub use self::fminimum_fmaximum::{fmaximumf16, fminimumf16};
         pub use self::fminimum_fmaximum_num::{fmaximum_numf16, fminimum_numf16};
         pub use self::fmod::fmodf16;
+        pub use self::ilogb::ilogbf16;
         pub use self::ldexp::ldexpf16;
         pub use self::rint::rintf16;
         pub use self::round::roundf16;
@@ -333,6 +334,9 @@ macro_rules! div {
 
         #[allow(unused_imports)]
         pub(crate) use self::fma::fmaf16;
+
+        #[allow(unused_imports)]
+        pub(crate) use self::frexp::frexpf16;
     }
 }
 
@@ -349,6 +353,8 @@ macro_rules! div {
         pub use self::fminimum_fmaximum::{fmaximumf128, fminimumf128};
         pub use self::fminimum_fmaximum_num::{fmaximum_numf128, fminimum_numf128};
         pub use self::fmod::fmodf128;
+        pub use self::frexp::frexpf128;
+        pub use self::ilogb::ilogbf128;
         pub use self::ldexp::ldexpf128;
         pub use self::rint::rintf128;
         pub use self::round::roundf128;

From 0a4613c2978d428ac2ef99d6937a3414cc3c8864 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 22:05:07 -0600
Subject: [PATCH 0038/1059] util: `f16` now has parsing in the standard
 library, use it

---
 library/compiler-builtins/crates/util/src/main.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/compiler-builtins/crates/util/src/main.rs b/library/compiler-builtins/crates/util/src/main.rs
index 5972181531b2..34e28d7b9759 100644
--- a/library/compiler-builtins/crates/util/src/main.rs
+++ b/library/compiler-builtins/crates/util/src/main.rs
@@ -232,11 +232,11 @@ fn parse(_input: &[&str]) -> Self {
     };
 }
 
+#[cfg(f16_enabled)]
+impl_parse_tuple!(f16);
 impl_parse_tuple!(f32);
 impl_parse_tuple!(f64);
 
-#[cfg(f16_enabled)]
-impl_parse_tuple_via_rug!(f16);
 #[cfg(f128_enabled)]
 impl_parse_tuple_via_rug!(f128);
 

From 6aa1e6932d15709a1fe67df045c7ff6115f6dc9c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 19:56:08 -0600
Subject: [PATCH 0039/1059] util: Add support for decomposing floats

---
 library/compiler-builtins/Cargo.toml          |  1 +
 .../compiler-builtins/crates/util/Cargo.toml  |  1 +
 .../compiler-builtins/crates/util/src/main.rs | 70 ++++++++++++++++++-
 .../libm-test/src/test_traits.rs              |  2 +-
 4 files changed, 71 insertions(+), 3 deletions(-)

diff --git a/library/compiler-builtins/Cargo.toml b/library/compiler-builtins/Cargo.toml
index 3dff23d28577..785df6a20015 100644
--- a/library/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/Cargo.toml
@@ -35,6 +35,7 @@ exclude = [
 anyhow = "1.0.101"
 assert_cmd = "2.1.2"
 cc = "1.2.55"
+cfg-if = "1.0.4"
 compiler_builtins = { path = "builtins-shim", default-features = false }
 criterion = { version = "0.6.0", default-features = false, features = ["cargo_bench_support"] }
 getopts = "0.2.24"
diff --git a/library/compiler-builtins/crates/util/Cargo.toml b/library/compiler-builtins/crates/util/Cargo.toml
index c56e2cc12ea5..b0a365e4735b 100644
--- a/library/compiler-builtins/crates/util/Cargo.toml
+++ b/library/compiler-builtins/crates/util/Cargo.toml
@@ -6,6 +6,7 @@ publish = false
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+cfg-if.workspace = true
 libm.workspace = true
 libm-macros.workspace = true
 libm-test.workspace = true
diff --git a/library/compiler-builtins/crates/util/src/main.rs b/library/compiler-builtins/crates/util/src/main.rs
index 34e28d7b9759..498162158426 100644
--- a/library/compiler-builtins/crates/util/src/main.rs
+++ b/library/compiler-builtins/crates/util/src/main.rs
@@ -8,10 +8,11 @@
 use std::num::ParseIntError;
 use std::str::FromStr;
 
-use libm::support::{Hexf, hf32, hf64};
+use cfg_if::cfg_if;
+use libm::support::{Float, Hexf, hf32, hf64};
 #[cfg(feature = "build-mpfr")]
 use libm_test::mpfloat::MpOp;
-use libm_test::{MathOp, TupleCall};
+use libm_test::{Hex, MathOp, TupleCall};
 #[cfg(feature = "build-mpfr")]
 use rug::az::{self, Az};
 
@@ -26,6 +27,10 @@
         running routines with a debugger, or quickly checking input. Examples:
         * eval musl sinf 1.234 # print the results of musl sinf(1.234f32)
         * eval mpfr pow 1.234 2.432 # print the results of mpfr pow(1.234, 2.432)
+
+    print inputs...
+        For each input, print it in different formats with various floating
+        point properties (normal, infinite, etc).
 ";
 
 fn main() {
@@ -34,6 +39,7 @@ fn main() {
 
     match &str_args.as_slice()[1..] {
         ["eval", basis, op, inputs @ ..] => do_eval(basis, op, inputs),
+        ["print" | "p", inputs @ ..] => do_classify(inputs),
         _ => {
             println!("{USAGE}\nunrecognized input `{str_args:?}`");
             std::process::exit(1);
@@ -106,6 +112,66 @@ fn do_eval(basis: &str, op: &str, inputs: &[&str]) {
     panic!("no operation matching {op}");
 }
 
+/// Print basic float information to stdout.
+fn do_classify(inputs: &[&str]) {
+    for s in inputs {
+        if let Some(s) = s.strip_suffix("f16") {
+            cfg_if! {
+                if #[cfg(f16_enabled)] {
+                    let s = s.trim_end_matches("_");
+                    let x: f16 = parse(&[s], 0);
+                    classify_print(x);
+                    continue;
+                } else {
+                    panic!("parsing this type requires f16 support: `{s}`");
+                }
+            }
+        };
+        if let Some(s) = s.strip_suffix("f32") {
+            let s = s.trim_end_matches("_");
+            let x: f32 = parse(&[s], 0);
+            classify_print(x);
+            continue;
+        } else if let Some(s) = s.strip_suffix("f64") {
+            let s = s.trim_end_matches("_");
+            let x: f64 = parse(&[s], 0);
+            classify_print(x);
+            continue;
+        }
+        if let Some(s) = s.strip_suffix("f128") {
+            cfg_if! {
+                if #[cfg(all(f128_enabled, feature = "build-mpfr"))] {
+                    let s = s.trim_end_matches("_");
+                    let x: f128 = parse_rug(&[s], 0);
+                    classify_print(x);
+                    continue;
+                } else {
+                    panic!("parsing this type requires f128 support and \
+                            the `build-mpfr` feature: `{s}`");
+                }
+            }
+        };
+        panic!("float type must be specified with a `f*` suffix: `{s}`");
+    }
+}
+
+fn classify_print<F>(x: F)
+where
+    F: Float,
+    F::Int: Hex,
+{
+    println!("{x:?}");
+    println!("    hex:  {}", Hexf(x));
+    println!("    bits: {}", x.to_bits().hex());
+    println!("    nan:  {}", x.is_nan());
+    println!("    inf:  {}", x.is_infinite());
+    println!("    normal: {}", !x.is_subnormal());
+    println!("    pos:  {}", x.is_sign_positive());
+    println!("    exp:  {} {}", x.ex(), x.ex().hex());
+    println!("    exp unbiased: {}", x.exp_unbiased());
+    println!("    frac: {} {}", x.frac(), x.frac().hex());
+}
+
 /// Parse a tuple from a space-delimited string.
 trait ParseTuple {
     fn parse(input: &[&str]) -> Self;
diff --git a/library/compiler-builtins/libm-test/src/test_traits.rs b/library/compiler-builtins/libm-test/src/test_traits.rs
index 8b21e2af9a04..f8621a3734a4 100644
--- a/library/compiler-builtins/libm-test/src/test_traits.rs
+++ b/library/compiler-builtins/libm-test/src/test_traits.rs
@@ -260,7 +260,7 @@ fn validate_int<I, Input>(actual: I, expected: I, input: Input, ctx: &CheckCtx)
     Ok(())
 }
 
-impl_int!(u32, i32, u64, i64);
+impl_int!(u16, i16, u32, i32, u64, i64, u128, i128);
 
 /* trait implementations for floats */
 

From c1653840a62f6a03ec01db3763cbe3a30c0e2548 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Wed, 11 Feb 2026 22:06:49 -0600
Subject: [PATCH 0040/1059] util: Add an alias for the eval subcommand

---
 library/compiler-builtins/crates/util/src/main.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/compiler-builtins/crates/util/src/main.rs b/library/compiler-builtins/crates/util/src/main.rs
index 498162158426..70aa613f18d0 100644
--- a/library/compiler-builtins/crates/util/src/main.rs
+++ b/library/compiler-builtins/crates/util/src/main.rs
@@ -23,12 +23,14 @@
 
 SUBCOMMAND:
     eval <BASIS> <OP> inputs...
+    x <BASIS> <OP> inputs...
         Evaulate the expression with a given basis. This can be useful for
         running routines with a debugger, or quickly checking input. Examples:
         * eval musl sinf 1.234 # print the results of musl sinf(1.234f32)
         * eval mpfr pow 1.234 2.432 # print the results of mpfr pow(1.234, 2.432)
 
     print inputs...
+    p inputs...
         For each input, print it in different formats with various floating
         point properties (normal, infinite, etc).
 ";
@@ -38,7 +40,7 @@ fn main() {
     let str_args = args.iter().map(|s| s.as_str()).collect::<Vec<_>>();
 
     match &str_args.as_slice()[1..] {
-        ["eval", basis, op, inputs @ ..] => do_eval(basis, op, inputs),
+        ["eval" | "x", basis, op, inputs @ ..] => do_eval(basis, op, inputs),
         ["print" | "p", inputs @ ..] => do_classify(inputs),
         _ => {
             println!("{USAGE}\nunrecognized input `{str_args:?}`");

From e7e9546ef6c746055d7b62ccb4b667bab19e925f Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 00:41:46 -0600
Subject: [PATCH 0041/1059] libm: Print `Hexf<i32>` with `0x` and zero padding

---
 library/compiler-builtins/libm/src/math/support/hex_float.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/libm/src/math/support/hex_float.rs b/library/compiler-builtins/libm/src/math/support/hex_float.rs
index 2f9369e50441..4495e3c18801 100644
--- a/library/compiler-builtins/libm/src/math/support/hex_float.rs
+++ b/library/compiler-builtins/libm/src/math/support/hex_float.rs
@@ -419,7 +419,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                     let _ = f;
                     unimplemented!()
                 } else {
-                    fmt::LowerHex::fmt(&self.0, f)
+                    write!(f, "{:#010x}", self.0)
                 }
             }
         }

From 4401daa4ff79b1665a95b5546b96356ed8be9a9f Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 00:41:46 -0600
Subject: [PATCH 0042/1059] libm: Switch to a non-recursive algorithm for
 subnormals

This will support `frexpf16` and should allow `generic::frexp` to be
inlined into the non-generic `frexp*` functions.

Additionally remove an unneeded `as` cast.
---
 .../libm/src/math/generic/frexp.rs             | 18 ++++++++++--------
 .../libm/src/math/support/float_traits.rs      |  6 +-----
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/generic/frexp.rs b/library/compiler-builtins/libm/src/math/generic/frexp.rs
index d5c2758a4b04..cbf5b100ba0f 100644
--- a/library/compiler-builtins/libm/src/math/generic/frexp.rs
+++ b/library/compiler-builtins/libm/src/math/generic/frexp.rs
@@ -1,19 +1,21 @@
-use super::super::{CastFrom, Float, MinInt};
+use super::super::{CastFrom, Float};
 
 #[inline]
 pub fn frexp<F: Float>(x: F) -> (F, i32) {
     let mut ix = x.to_bits();
-    let ee = x.ex() as i32;
+    let mut ee = x.ex() as i32;
 
     if ee == 0 {
-        if x != F::ZERO {
-            // normalize via multiplication; 1p64 for `f64`
-            let magic = F::from_parts(false, F::EXP_BIAS + F::BITS, F::Int::ZERO);
-            let (x, e) = frexp(x * magic);
-            return (x, e - F::BITS as i32);
+        if x == F::ZERO {
+            return (x, 0);
         }
-        return (x, 0);
+
+        // Subnormals, needs to be normalized first
+        ix &= F::SIG_MASK;
+        (ee, ix) = F::normalize(ix);
+        ix |= x.to_bits() & F::SIGN_MASK;
     } else if ee == F::EXP_SAT as i32 {
+        // inf or  NaN
         return (x, 0);
     }
 
diff --git a/library/compiler-builtins/libm/src/math/support/float_traits.rs b/library/compiler-builtins/libm/src/math/support/float_traits.rs
index 60c8bfca5165..9f2ce532ed17 100644
--- a/library/compiler-builtins/libm/src/math/support/float_traits.rs
+++ b/library/compiler-builtins/libm/src/math/support/float_traits.rs
@@ -176,7 +176,6 @@ fn from_parts(negative: bool, exponent: u32, significand: Self::Int) -> Self {
     fn fma(self, y: Self, z: Self) -> Self;
 
     /// Returns (normalized exponent, normalized significand)
-    #[allow(dead_code)]
     fn normalize(significand: Self::Int) -> (i32, Self::Int);
 
     /// Returns a number that represents the sign of self.
@@ -295,10 +294,7 @@ fn fma(self, y: Self, z: Self) -> Self {
             }
             fn normalize(significand: Self::Int) -> (i32, Self::Int) {
                 let shift = significand.leading_zeros().wrapping_sub(Self::EXP_BITS);
-                (
-                    1i32.wrapping_sub(shift as i32),
-                    significand << shift as Self::Int,
-                )
+                (1i32.wrapping_sub(shift as i32), significand << shift)
             }
         }
     };

From 67ab9a5568209e381b166edd34fbff5c1a26f000 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 00:41:46 -0600
Subject: [PATCH 0043/1059] libm: Add `frexpf16`

The new algorithm now correctly supports the type.
---
 .../crates/libm-macros/src/shared.rs          | 14 ++++++
 .../etc/function-definitions.json             |  7 +++
 .../compiler-builtins/etc/function-list.txt   |  1 +
 .../libm-test/benches/icount.rs               |  1 +
 .../libm-test/src/generate/case_list.rs       |  5 +++
 .../libm-test/src/mpfloat.rs                  | 44 +++++++------------
 .../compiler-builtins/libm/src/math/frexp.rs  |  5 +--
 .../compiler-builtins/libm/src/math/mod.rs    |  4 +-
 8 files changed, 46 insertions(+), 35 deletions(-)

diff --git a/library/compiler-builtins/crates/libm-macros/src/shared.rs b/library/compiler-builtins/crates/libm-macros/src/shared.rs
index 5a5eca6f685d..ee1feed7c35e 100644
--- a/library/compiler-builtins/crates/libm-macros/src/shared.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/shared.rs
@@ -417,6 +417,20 @@ struct NestedOp {
         fn_list: &["modf"],
         public: true,
     },
+    NestedOp {
+        // `(f16, &mut c_int) -> f16` as `(f16) -> (f16, i32)`
+        float_ty: FloatTy::F16,
+        rust_sig: Signature {
+            args: &[Ty::F16],
+            returns: &[Ty::F16, Ty::I32],
+        },
+        c_sig: Some(Signature {
+            args: &[Ty::F16, Ty::MutCInt],
+            returns: &[Ty::F16],
+        }),
+        fn_list: &["frexpf16"],
+        public: true,
+    },
     NestedOp {
         // `(f32, &mut c_int) -> f32` as `(f32) -> (f32, i32)`
         float_ty: FloatTy::F32,
diff --git a/library/compiler-builtins/etc/function-definitions.json b/library/compiler-builtins/etc/function-definitions.json
index 06eb1ad5e2e7..6bd395a84b66 100644
--- a/library/compiler-builtins/etc/function-definitions.json
+++ b/library/compiler-builtins/etc/function-definitions.json
@@ -579,6 +579,13 @@
         ],
         "type": "f128"
     },
+    "frexpf16": {
+        "sources": [
+            "libm/src/math/frexp.rs",
+            "libm/src/math/generic/frexp.rs"
+        ],
+        "type": "f16"
+    },
     "hypot": {
         "sources": [
             "libm/src/math/hypot.rs"
diff --git a/library/compiler-builtins/etc/function-list.txt b/library/compiler-builtins/etc/function-list.txt
index 45a39e3eee8d..f7a694d10f95 100644
--- a/library/compiler-builtins/etc/function-list.txt
+++ b/library/compiler-builtins/etc/function-list.txt
@@ -85,6 +85,7 @@ fmodf16
 frexp
 frexpf
 frexpf128
+frexpf16
 hypot
 hypotf
 ilogb
diff --git a/library/compiler-builtins/libm-test/benches/icount.rs b/library/compiler-builtins/libm-test/benches/icount.rs
index be5178e205a2..617e9fb7ad21 100644
--- a/library/compiler-builtins/libm-test/benches/icount.rs
+++ b/library/compiler-builtins/libm-test/benches/icount.rs
@@ -332,6 +332,7 @@ fn icount_bench_print_hf128(x: f128) -> String {
     icount_bench_fmodf_group,
     icount_bench_frexp_group,
     icount_bench_frexpf128_group,
+    icount_bench_frexpf16_group,
     icount_bench_frexpf_group,
     icount_bench_hypot_group,
     icount_bench_hypotf_group,
diff --git a/library/compiler-builtins/libm-test/src/generate/case_list.rs b/library/compiler-builtins/libm-test/src/generate/case_list.rs
index 958e03ab67f0..66d7f6a282f6 100644
--- a/library/compiler-builtins/libm-test/src/generate/case_list.rs
+++ b/library/compiler-builtins/libm-test/src/generate/case_list.rs
@@ -460,6 +460,11 @@ fn fmodf16_cases() -> Vec<TestCase<op::fmodf16::Routine>> {
     vec![]
 }
 
+#[cfg(f16_enabled)]
+fn frexpf16_cases() -> Vec<TestCase<op::frexpf16::Routine>> {
+    vec![]
+}
+
 fn frexpf_cases() -> Vec<TestCase<op::frexpf::Routine>> {
     vec![]
 }
diff --git a/library/compiler-builtins/libm-test/src/mpfloat.rs b/library/compiler-builtins/libm-test/src/mpfloat.rs
index 3237a232f7dc..91130f892b8a 100644
--- a/library/compiler-builtins/libm-test/src/mpfloat.rs
+++ b/library/compiler-builtins/libm-test/src/mpfloat.rs
@@ -163,6 +163,7 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
         frexp,
         frexpf,
         frexpf128,
+        frexpf16,
         ilogb,
         ilogbf,
         ilogbf128,
@@ -327,20 +328,6 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
                 }
             }
 
-            impl MpOp for crate::op::[<frexp $suffix>]::Routine {
-                type MpTy = MpFloat;
-
-                fn new_mp() -> Self::MpTy {
-                    new_mpfloat::<Self::FTy>()
-                }
-
-                fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
-                    this.assign(input.0);
-                    let exp = this.frexp_mut();
-                    (prep_retval::<Self::FTy>(this, Ordering::Equal), exp)
-                }
-            }
-
             impl MpOp for crate::op::[<jn $suffix>]::Routine {
                 type MpTy = MpFloat;
 
@@ -485,6 +472,20 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
                 }
             }
 
+            impl MpOp for crate::op::[<frexp $suffix>]::Routine {
+                type MpTy = MpFloat;
+
+                fn new_mp() -> Self::MpTy {
+                    new_mpfloat::<Self::FTy>()
+                }
+
+                fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
+                    this.assign(input.0);
+                    let exp = this.frexp_mut();
+                    (prep_retval::<Self::FTy>(this, Ordering::Equal), exp)
+                }
+            }
+
             impl MpOp for crate::op::[<ilogb $suffix>]::Routine {
                 type MpTy = MpFloat;
 
@@ -549,21 +550,6 @@ fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
 #[cfg(f128_enabled)]
 impl_op_for_ty_all!(f128, "f128");
 
-#[cfg(f128_enabled)]
-impl MpOp for crate::op::frexpf128::Routine {
-    type MpTy = MpFloat;
-
-    fn new_mp() -> Self::MpTy {
-        new_mpfloat::<Self::FTy>()
-    }
-
-    fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
-        this.assign(input.0);
-        let exp = this.frexp_mut();
-        (prep_retval::<Self::FTy>(this, Ordering::Equal), exp)
-    }
-}
-
 // `lgamma_r` is not a simple suffix so we can't use the above macro.
 impl MpOp for crate::op::lgamma_r::Routine {
     type MpTy = MpFloat;
diff --git a/library/compiler-builtins/libm/src/math/frexp.rs b/library/compiler-builtins/libm/src/math/frexp.rs
index f2f545fb65e4..af38915a3ac6 100644
--- a/library/compiler-builtins/libm/src/math/frexp.rs
+++ b/library/compiler-builtins/libm/src/math/frexp.rs
@@ -2,11 +2,10 @@
 ///
 /// That is, `x * 2^p` will represent the input value.
 // Placeholder so we can have `frexpf16` in the `Float` trait.
-#[allow(unused)]
 #[cfg(f16_enabled)]
 #[cfg_attr(assert_no_panic, no_panic::no_panic)]
-pub(crate) fn frexpf16(x: f16) -> (f16, i32) {
-    unimplemented!()
+pub fn frexpf16(x: f16) -> (f16, i32) {
+    super::generic::frexp(x)
 }
 
 /// Decompose a float into a normalized value within the range `[0.5, 1)`, and a power of 2.
diff --git a/library/compiler-builtins/libm/src/math/mod.rs b/library/compiler-builtins/libm/src/math/mod.rs
index 0484fe6a3765..b34ab8465349 100644
--- a/library/compiler-builtins/libm/src/math/mod.rs
+++ b/library/compiler-builtins/libm/src/math/mod.rs
@@ -322,6 +322,7 @@ macro_rules! div {
         pub use self::fminimum_fmaximum::{fmaximumf16, fminimumf16};
         pub use self::fminimum_fmaximum_num::{fmaximum_numf16, fminimum_numf16};
         pub use self::fmod::fmodf16;
+        pub use self::frexp::frexpf16;
         pub use self::ilogb::ilogbf16;
         pub use self::ldexp::ldexpf16;
         pub use self::rint::rintf16;
@@ -334,9 +335,6 @@ macro_rules! div {
 
         #[allow(unused_imports)]
         pub(crate) use self::fma::fmaf16;
-
-        #[allow(unused_imports)]
-        pub(crate) use self::frexp::frexpf16;
     }
 }
 

From ef8c95cde1a83a12b7e34a71138729e624da86e0 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Thu, 12 Feb 2026 17:35:57 +0300
Subject: [PATCH 0044/1059] privacy: Fix type privacy holes when it doesn't
 cause too much breakage

---
 compiler/rustc_privacy/src/lib.rs             |  5 +-
 tests/ui/privacy/private-in-public-warn.rs    | 12 +--
 .../ui/privacy/private-in-public-warn.stderr  | 78 +++++++------------
 3 files changed, 39 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 9a952bb72195..a34fcc4f68c9 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -1590,13 +1590,14 @@ fn check_assoc_item(
         let mut check = self.check(item.def_id.expect_local(), vis, effective_vis);
 
         let is_assoc_ty = item.is_type();
-        check.hard_error = is_assoc_ty && !item.is_impl_trait_in_trait();
+        check.hard_error = is_assoc_ty;
         check.generics().predicates();
         if assoc_has_type_of(self.tcx, item) {
-            check.hard_error = check.hard_error && item.defaultness(self.tcx).has_value();
             check.ty();
         }
         if is_assoc_ty && item.container == AssocContainer::Trait {
+            // FIXME: too much breakage from reporting hard errors here, better wait for a fix
+            // from proper associated type normalization.
             check.hard_error = false;
             check.bounds();
         }
diff --git a/tests/ui/privacy/private-in-public-warn.rs b/tests/ui/privacy/private-in-public-warn.rs
index 6a0ac2b9ade7..299fe9a75d4c 100644
--- a/tests/ui/privacy/private-in-public-warn.rs
+++ b/tests/ui/privacy/private-in-public-warn.rs
@@ -49,10 +49,10 @@ pub trait Tr3 {
         fn f<T: PrivTr>(arg: T) {}
         //~^ ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::f`
         fn g() -> impl PrivTr;
-        //~^ ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::g::{anon_assoc#0}`
+        //~^ ERROR private trait `traits::PrivTr` in public interface
         //~| ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::g::{anon_assoc#0}`
         fn h() -> impl PrivTr {}
-        //~^ ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::h::{anon_assoc#0}`
+        //~^ ERROR private trait `traits::PrivTr` in public interface
         //~| ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::h::{anon_assoc#0}`
     }
     impl<T: PrivTr> Pub<T> {} //~ ERROR trait `traits::PrivTr` is more private than the item `traits::Pub<T>`
@@ -93,13 +93,13 @@ pub trait Tr4: PubTr<Pub<Priv>> {} //~ ERROR type `generics::Priv` is more priva
 
     pub trait Tr5 {
         fn required() -> impl PrivTr<Priv<()>>;
-        //~^ ERROR trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
-        //~| ERROR type `generics::Priv<()>` is more private than the item `Tr5::required::{anon_assoc#0}`
+        //~^ ERROR private trait `generics::PrivTr<generics::Priv<()>>` in public interface
+        //~| ERROR private type `generics::Priv<()>` in public interface
         //~| ERROR trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
         //~| ERROR type `generics::Priv<()>` is more private than the item `Tr5::required::{anon_assoc#0}`
         fn provided() -> impl PrivTr<Priv<()>> {}
-        //~^ ERROR trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::provided::{anon_assoc#0}`
-        //~| ERROR type `generics::Priv<()>` is more private than the item `Tr5::provided::{anon_assoc#0}`
+        //~^ ERROR private trait `generics::PrivTr<generics::Priv<()>>` in public interface
+        //~| ERROR private type `generics::Priv<()>` in public interface
         //~| ERROR trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::provided::{anon_assoc#0}`
         //~| ERROR type `generics::Priv<()>` is more private than the item `Tr5::provided::{anon_assoc#0}`
     }
diff --git a/tests/ui/privacy/private-in-public-warn.stderr b/tests/ui/privacy/private-in-public-warn.stderr
index 1fa415e27c16..64be22b4cdf9 100644
--- a/tests/ui/privacy/private-in-public-warn.stderr
+++ b/tests/ui/privacy/private-in-public-warn.stderr
@@ -194,17 +194,14 @@ note: but trait `traits::PrivTr` is only usable at visibility `pub(self)`
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
-error: trait `traits::PrivTr` is more private than the item `traits::Tr3::g::{anon_assoc#0}`
+error[E0446]: private trait `traits::PrivTr` in public interface
   --> $DIR/private-in-public-warn.rs:51:19
    |
-LL |         fn g() -> impl PrivTr;
-   |                   ^^^^^^^^^^^ opaque type `traits::Tr3::g::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but trait `traits::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:37:5
-   |
 LL |     trait PrivTr {}
-   |     ^^^^^^^^^^^^
+   |     ------------ `traits::PrivTr` declared as private
+...
+LL |         fn g() -> impl PrivTr;
+   |                   ^^^^^^^^^^^ can't leak private trait
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr3::g::{anon_assoc#0}`
   --> $DIR/private-in-public-warn.rs:51:19
@@ -218,17 +215,14 @@ note: but trait `traits::PrivTr` is only usable at visibility `pub(self)`
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
-error: trait `traits::PrivTr` is more private than the item `traits::Tr3::h::{anon_assoc#0}`
+error[E0446]: private trait `traits::PrivTr` in public interface
   --> $DIR/private-in-public-warn.rs:54:19
    |
-LL |         fn h() -> impl PrivTr {}
-   |                   ^^^^^^^^^^^ opaque type `traits::Tr3::h::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but trait `traits::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:37:5
-   |
 LL |     trait PrivTr {}
-   |     ^^^^^^^^^^^^
+   |     ------------ `traits::PrivTr` declared as private
+...
+LL |         fn h() -> impl PrivTr {}
+   |                   ^^^^^^^^^^^ can't leak private trait
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr3::h::{anon_assoc#0}`
   --> $DIR/private-in-public-warn.rs:54:19
@@ -350,29 +344,23 @@ note: but type `generics::Priv` is only usable at visibility `pub(self)`
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
+error[E0446]: private trait `generics::PrivTr<generics::Priv<()>>` in public interface
   --> $DIR/private-in-public-warn.rs:95:26
    |
-LL |         fn required() -> impl PrivTr<Priv<()>>;
-   |                          ^^^^^^^^^^^^^^^^^^^^^ opaque type `Tr5::required::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but trait `generics::PrivTr<generics::Priv<()>>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:84:5
-   |
 LL |     trait PrivTr<T> {}
-   |     ^^^^^^^^^^^^^^^
+   |     --------------- `generics::PrivTr<generics::Priv<()>>` declared as private
+...
+LL |         fn required() -> impl PrivTr<Priv<()>>;
+   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
 
-error: type `generics::Priv<()>` is more private than the item `Tr5::required::{anon_assoc#0}`
+error[E0446]: private type `generics::Priv<()>` in public interface
   --> $DIR/private-in-public-warn.rs:95:26
    |
-LL |         fn required() -> impl PrivTr<Priv<()>>;
-   |                          ^^^^^^^^^^^^^^^^^^^^^ opaque type `Tr5::required::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but type `generics::Priv<()>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:82:5
-   |
 LL |     struct Priv<T = u8>(T);
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ------------------- `generics::Priv<()>` declared as private
+...
+LL |         fn required() -> impl PrivTr<Priv<()>>;
+   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private type
 
 error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
   --> $DIR/private-in-public-warn.rs:95:26
@@ -398,29 +386,23 @@ note: but type `generics::Priv<()>` is only usable at visibility `pub(self)`
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::provided::{anon_assoc#0}`
+error[E0446]: private trait `generics::PrivTr<generics::Priv<()>>` in public interface
   --> $DIR/private-in-public-warn.rs:100:26
    |
-LL |         fn provided() -> impl PrivTr<Priv<()>> {}
-   |                          ^^^^^^^^^^^^^^^^^^^^^ opaque type `Tr5::provided::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but trait `generics::PrivTr<generics::Priv<()>>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:84:5
-   |
 LL |     trait PrivTr<T> {}
-   |     ^^^^^^^^^^^^^^^
+   |     --------------- `generics::PrivTr<generics::Priv<()>>` declared as private
+...
+LL |         fn provided() -> impl PrivTr<Priv<()>> {}
+   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
 
-error: type `generics::Priv<()>` is more private than the item `Tr5::provided::{anon_assoc#0}`
+error[E0446]: private type `generics::Priv<()>` in public interface
   --> $DIR/private-in-public-warn.rs:100:26
    |
-LL |         fn provided() -> impl PrivTr<Priv<()>> {}
-   |                          ^^^^^^^^^^^^^^^^^^^^^ opaque type `Tr5::provided::{anon_assoc#0}` is reachable at visibility `pub(crate)`
-   |
-note: but type `generics::Priv<()>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:82:5
-   |
 LL |     struct Priv<T = u8>(T);
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ------------------- `generics::Priv<()>` declared as private
+...
+LL |         fn provided() -> impl PrivTr<Priv<()>> {}
+   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private type
 
 error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::provided::{anon_assoc#0}`
   --> $DIR/private-in-public-warn.rs:100:26

From e68fc280c21da48381fa99f1dc0962625841a60c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 06:17:04 -0600
Subject: [PATCH 0045/1059] ci: Increase the benchmark rustc version to
 2026-02-10

This includes the most recent LLVM bump.
---
 library/compiler-builtins/.github/workflows/main.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 0375d1eb29de..1a69f7484d88 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -13,7 +13,7 @@ env:
   RUSTDOCFLAGS: -Dwarnings
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: full
-  BENCHMARK_RUSTC: nightly-2025-12-01 # Pin the toolchain for reproducable results
+  BENCHMARK_RUSTC: nightly-2026-02-10 # Pin the toolchain for reproducable results
 
 jobs:
   # Determine which tests should be run based on changed files.

From 0b0d40d5f3ab401604d138fdf2cc4785a3ecc6bc Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 7 Feb 2026 07:06:05 -0600
Subject: [PATCH 0046/1059] libm: Improve debug output for `Status`

---
 .../libm/src/math/support/env.rs              | 49 +++++++++++++++++--
 1 file changed, 44 insertions(+), 5 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/support/env.rs b/library/compiler-builtins/libm/src/math/support/env.rs
index 53ae32f658db..0f89799ed918 100644
--- a/library/compiler-builtins/libm/src/math/support/env.rs
+++ b/library/compiler-builtins/libm/src/math/support/env.rs
@@ -49,10 +49,14 @@ pub enum Round {
 }
 
 /// IEEE 754 exception status flags.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Status(u8);
 
 impl Status {
+    /* Note that if we ever store/load this to/from floating point control status registers, it
+     * may be worth making these values platform-dependent to line up with register layout
+     * to avoid bit swapping. For the time being, this isn't a concern. */
+
     /// Default status indicating no errors.
     pub const OK: Self = Self(0);
 
@@ -74,7 +78,7 @@ impl Status {
     /// result is -inf.
     /// `x / y` when `x != 0.0` and `y == 0.0`,
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
-    pub const DIVIDE_BY_ZERO: Self = Self(1 << 2);
+    pub const DIVIDE_BY_ZERO: Self = Self(1 << 1);
 
     /// The result exceeds the maximum finite value.
     ///
@@ -82,14 +86,14 @@ impl Status {
     /// on the intermediate result. `Zero` rounds to the signed maximum finite. `Positive` and
     /// `Negative` round to signed maximum finite in one direction, signed infinity in the other.
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
-    pub const OVERFLOW: Self = Self(1 << 3);
+    pub const OVERFLOW: Self = Self(1 << 2);
 
     /// The result is subnormal and lost precision.
-    pub const UNDERFLOW: Self = Self(1 << 4);
+    pub const UNDERFLOW: Self = Self(1 << 3);
 
     /// The finite-precision result does not match that of infinite precision, and the reason
     /// is not represented by one of the other flags.
-    pub const INEXACT: Self = Self(1 << 5);
+    pub const INEXACT: Self = Self(1 << 4);
 
     /// True if `UNDERFLOW` is set.
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
@@ -128,3 +132,38 @@ pub(crate) const fn with(self, rhs: Self) -> Self {
         Self(self.0 | rhs.0)
     }
 }
+
+#[cfg(any(test, feature = "unstable-public-internals"))]
+impl core::fmt::Debug for Status {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        // shift -> flag map
+        let names = &[
+            "INVALID",
+            "DIVIDE_BY_ZERO",
+            "OVERFLOW",
+            "UNDERFLOW",
+            "INEXACT",
+        ];
+
+        write!(f, "Status(")?;
+        let mut any = false;
+        for shift in 0..u8::BITS {
+            if self.0 & (1 << shift) != 0 {
+                if any {
+                    write!(f, " | ")?;
+                }
+                match names.get(shift as usize) {
+                    Some(name) => write!(f, "{name}")?,
+                    None => write!(f, "UNKNOWN(1 << {shift})")?,
+                }
+                any = true;
+            }
+        }
+
+        if !any {
+            write!(f, "OK")?;
+        }
+        write!(f, ")")?;
+        Ok(())
+    }
+}

From 70c6d5a4476db95a94e417694f3535388ef613ed Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 7 Feb 2026 07:06:05 -0600
Subject: [PATCH 0047/1059] libm: Fix `_status` status outputs on null-mantissa
 inputs

Values like 0.5 that have an exponent but not a mantissa are currently
being reported as OK rather than INEXACT for ceil, floor, and trunc. Fix
this and clean up the test cases.

This tries to keep the algorithm diff as simple as possible, which
introduces some small performance regressions. This is improved in a
future commit.
---
 .../libm/src/math/generic/ceil.rs             | 146 +++++++---------
 .../libm/src/math/generic/floor.rs            | 129 +++++++-------
 .../libm/src/math/generic/trunc.rs            | 159 ++++++++----------
 3 files changed, 194 insertions(+), 240 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/generic/ceil.rs b/library/compiler-builtins/libm/src/math/generic/ceil.rs
index 1072ba7c29b6..5584f6503ef5 100644
--- a/library/compiler-builtins/libm/src/math/generic/ceil.rs
+++ b/library/compiler-builtins/libm/src/math/generic/ceil.rs
@@ -46,7 +46,7 @@ pub fn ceil_status<F: Float>(x: F) -> FpResult<F> {
         F::from_bits(ix)
     } else {
         // |x| < 1.0, raise an inexact exception since truncation will happen (unless x == 0).
-        if ix & F::SIG_MASK == F::Int::ZERO {
+        if ix & !F::SIGN_MASK == F::Int::ZERO {
             status = Status::OK;
         } else {
             status = Status::INEXACT;
@@ -72,103 +72,83 @@ mod tests {
     use super::*;
     use crate::support::Hexf;
 
-    /// Test against https://en.cppreference.com/w/cpp/numeric/math/ceil
-    fn spec_test<F: Float>(cases: &[(F, F, Status)]) {
-        let roundtrip = [
-            F::ZERO,
-            F::ONE,
-            F::NEG_ONE,
-            F::NEG_ZERO,
-            F::INFINITY,
-            F::NEG_INFINITY,
-        ];
-
-        for x in roundtrip {
-            let FpResult { val, status } = ceil_status(x);
-            assert_biteq!(val, x, "{}", Hexf(x));
-            assert_eq!(status, Status::OK, "{}", Hexf(x));
-        }
-
-        for &(x, res, res_stat) in cases {
-            let FpResult { val, status } = ceil_status(x);
-            assert_biteq!(val, res, "{}", Hexf(x));
-            assert_eq!(status, res_stat, "{}", Hexf(x));
-        }
+    macro_rules! cases {
+        ($f:ty) => {
+            [
+                // roundtrip
+                (0.0, 0.0, Status::OK),
+                (-0.0, -0.0, Status::OK),
+                (1.0, 1.0, Status::OK),
+                (-1.0, -1.0, Status::OK),
+                (<$f>::INFINITY, <$f>::INFINITY, Status::OK),
+                (<$f>::NEG_INFINITY, <$f>::NEG_INFINITY, Status::OK),
+                // with rounding
+                (0.1, 1.0, Status::INEXACT),
+                (-0.1, -0.0, Status::INEXACT),
+                (0.5, 1.0, Status::INEXACT),
+                (-0.5, -0.0, Status::INEXACT),
+                (0.9, 1.0, Status::INEXACT),
+                (-0.9, -0.0, Status::INEXACT),
+                (1.1, 2.0, Status::INEXACT),
+                (-1.1, -1.0, Status::INEXACT),
+                (1.5, 2.0, Status::INEXACT),
+                (-1.5, -1.0, Status::INEXACT),
+                (1.9, 2.0, Status::INEXACT),
+                (-1.9, -1.0, Status::INEXACT),
+            ]
+        };
     }
 
-    /* Skipping f16 / f128 "sanity_check"s due to rejected literal lexing at MSRV */
+    #[track_caller]
+    fn check<F: Float>(cases: &[(F, F, Status)]) {
+        for &(x, exp_res, exp_stat) in cases {
+            let FpResult { val, status } = ceil_status(x);
+            assert_biteq!(val, exp_res, "{x:?} {}", Hexf(x));
+            assert_eq!(
+                status,
+                exp_stat,
+                "{x:?} {} -> {exp_res:?} {}",
+                Hexf(x),
+                Hexf(exp_res)
+            );
+        }
+    }
 
     #[test]
     #[cfg(f16_enabled)]
-    fn spec_tests_f16() {
-        let cases = [
-            (0.1, 1.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 1.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 2.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 2.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f16>(&cases);
+    fn check_f16() {
+        check::<f16>(&cases!(f16));
+        check::<f16>(&[
+            (hf16!("0x1p10"), hf16!("0x1p10"), Status::OK),
+            (hf16!("-0x1p10"), hf16!("-0x1p10"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn sanity_check_f32() {
-        assert_eq!(ceil(1.1f32), 2.0);
-        assert_eq!(ceil(2.9f32), 3.0);
+    fn check_f32() {
+        check::<f32>(&cases!(f32));
+        check::<f32>(&[
+            (hf32!("0x1p23"), hf32!("0x1p23"), Status::OK),
+            (hf32!("-0x1p23"), hf32!("-0x1p23"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn spec_tests_f32() {
-        let cases = [
-            (0.1, 1.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 1.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 2.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 2.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f32>(&cases);
-    }
-
-    #[test]
-    fn sanity_check_f64() {
-        assert_eq!(ceil(1.1f64), 2.0);
-        assert_eq!(ceil(2.9f64), 3.0);
-    }
-
-    #[test]
-    fn spec_tests_f64() {
-        let cases = [
-            (0.1, 1.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 1.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 2.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 2.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f64>(&cases);
+    fn check_f64() {
+        check::<f64>(&cases!(f64));
+        check::<f64>(&[
+            (hf64!("0x1p52"), hf64!("0x1p52"), Status::OK),
+            (hf64!("-0x1p52"), hf64!("-0x1p52"), Status::OK),
+        ]);
     }
 
     #[test]
     #[cfg(f128_enabled)]
     fn spec_tests_f128() {
-        let cases = [
-            (0.1, 1.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 1.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 2.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 2.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f128>(&cases);
+        check::<f128>(&cases!(f128));
+        check::<f128>(&[
+            (hf128!("0x1p112"), hf128!("0x1p112"), Status::OK),
+            (hf128!("-0x1p112"), hf128!("-0x1p112"), Status::OK),
+        ]);
     }
 }
diff --git a/library/compiler-builtins/libm/src/math/generic/floor.rs b/library/compiler-builtins/libm/src/math/generic/floor.rs
index e6dfd8866a42..c763a3cc265e 100644
--- a/library/compiler-builtins/libm/src/math/generic/floor.rs
+++ b/library/compiler-builtins/libm/src/math/generic/floor.rs
@@ -46,7 +46,7 @@ pub fn floor_status<F: Float>(x: F) -> FpResult<F> {
         F::from_bits(ix)
     } else {
         // |x| < 1.0, raise an inexact exception since truncation will happen.
-        if ix & F::SIG_MASK == F::Int::ZERO {
+        if ix & !F::SIGN_MASK == F::Int::ZERO {
             status = Status::OK;
         } else {
             status = Status::INEXACT;
@@ -72,86 +72,83 @@ mod tests {
     use super::*;
     use crate::support::Hexf;
 
-    /// Test against https://en.cppreference.com/w/cpp/numeric/math/floor
-    fn spec_test<F: Float>(cases: &[(F, F, Status)]) {
-        let roundtrip = [
-            F::ZERO,
-            F::ONE,
-            F::NEG_ONE,
-            F::NEG_ZERO,
-            F::INFINITY,
-            F::NEG_INFINITY,
-        ];
-
-        for x in roundtrip {
-            let FpResult { val, status } = floor_status(x);
-            assert_biteq!(val, x, "{}", Hexf(x));
-            assert_eq!(status, Status::OK, "{}", Hexf(x));
-        }
-
-        for &(x, res, res_stat) in cases {
-            let FpResult { val, status } = floor_status(x);
-            assert_biteq!(val, res, "{}", Hexf(x));
-            assert_eq!(status, res_stat, "{}", Hexf(x));
-        }
+    macro_rules! cases {
+        ($f:ty) => {
+            [
+                // roundtrip
+                (0.0, 0.0, Status::OK),
+                (-0.0, -0.0, Status::OK),
+                (1.0, 1.0, Status::OK),
+                (-1.0, -1.0, Status::OK),
+                (<$f>::INFINITY, <$f>::INFINITY, Status::OK),
+                (<$f>::NEG_INFINITY, <$f>::NEG_INFINITY, Status::OK),
+                // with rounding
+                (0.1, 0.0, Status::INEXACT),
+                (-0.1, -1.0, Status::INEXACT),
+                (0.5, 0.0, Status::INEXACT),
+                (-0.5, -1.0, Status::INEXACT),
+                (0.9, 0.0, Status::INEXACT),
+                (-0.9, -1.0, Status::INEXACT),
+                (1.1, 1.0, Status::INEXACT),
+                (-1.1, -2.0, Status::INEXACT),
+                (1.5, 1.0, Status::INEXACT),
+                (-1.5, -2.0, Status::INEXACT),
+                (1.9, 1.0, Status::INEXACT),
+                (-1.9, -2.0, Status::INEXACT),
+            ]
+        };
     }
 
-    /* Skipping f16 / f128 "sanity_check"s and spec cases due to rejected literal lexing at MSRV */
+    #[track_caller]
+    fn check<F: Float>(cases: &[(F, F, Status)]) {
+        for &(x, exp_res, exp_stat) in cases {
+            let FpResult { val, status } = floor_status(x);
+            assert_biteq!(val, exp_res, "{x:?} {}", Hexf(x));
+            assert_eq!(
+                status,
+                exp_stat,
+                "{x:?} {} -> {exp_res:?} {}",
+                Hexf(x),
+                Hexf(exp_res)
+            );
+        }
+    }
 
     #[test]
     #[cfg(f16_enabled)]
-    fn spec_tests_f16() {
-        let cases = [];
-        spec_test::<f16>(&cases);
+    fn check_f16() {
+        check::<f16>(&cases!(f16));
+        check::<f16>(&[
+            (hf16!("0x1p10"), hf16!("0x1p10"), Status::OK),
+            (hf16!("-0x1p10"), hf16!("-0x1p10"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn sanity_check_f32() {
-        assert_eq!(floor(0.5f32), 0.0);
-        assert_eq!(floor(1.1f32), 1.0);
-        assert_eq!(floor(2.9f32), 2.0);
+    fn check_f32() {
+        check::<f32>(&cases!(f32));
+        check::<f32>(&[
+            (hf32!("0x1p23"), hf32!("0x1p23"), Status::OK),
+            (hf32!("-0x1p23"), hf32!("-0x1p23"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn spec_tests_f32() {
-        let cases = [
-            (0.1, 0.0, Status::INEXACT),
-            (-0.1, -1.0, Status::INEXACT),
-            (0.9, 0.0, Status::INEXACT),
-            (-0.9, -1.0, Status::INEXACT),
-            (1.1, 1.0, Status::INEXACT),
-            (-1.1, -2.0, Status::INEXACT),
-            (1.9, 1.0, Status::INEXACT),
-            (-1.9, -2.0, Status::INEXACT),
-        ];
-        spec_test::<f32>(&cases);
-    }
-
-    #[test]
-    fn sanity_check_f64() {
-        assert_eq!(floor(1.1f64), 1.0);
-        assert_eq!(floor(2.9f64), 2.0);
-    }
-
-    #[test]
-    fn spec_tests_f64() {
-        let cases = [
-            (0.1, 0.0, Status::INEXACT),
-            (-0.1, -1.0, Status::INEXACT),
-            (0.9, 0.0, Status::INEXACT),
-            (-0.9, -1.0, Status::INEXACT),
-            (1.1, 1.0, Status::INEXACT),
-            (-1.1, -2.0, Status::INEXACT),
-            (1.9, 1.0, Status::INEXACT),
-            (-1.9, -2.0, Status::INEXACT),
-        ];
-        spec_test::<f64>(&cases);
+    fn check_f64() {
+        check::<f64>(&cases!(f64));
+        check::<f64>(&[
+            (hf64!("0x1p52"), hf64!("0x1p52"), Status::OK),
+            (hf64!("-0x1p52"), hf64!("-0x1p52"), Status::OK),
+        ]);
     }
 
     #[test]
     #[cfg(f128_enabled)]
     fn spec_tests_f128() {
-        let cases = [];
-        spec_test::<f128>(&cases);
+        check::<f128>(&cases!(f128));
+        check::<f128>(&[
+            (hf128!("0x1p112"), hf128!("0x1p112"), Status::OK),
+            (hf128!("-0x1p112"), hf128!("-0x1p112"), Status::OK),
+        ]);
     }
 }
diff --git a/library/compiler-builtins/libm/src/math/generic/trunc.rs b/library/compiler-builtins/libm/src/math/generic/trunc.rs
index d5b444d15dfc..686436c43b95 100644
--- a/library/compiler-builtins/libm/src/math/generic/trunc.rs
+++ b/library/compiler-builtins/libm/src/math/generic/trunc.rs
@@ -13,35 +13,29 @@ pub fn trunc_status<F: Float>(x: F) -> FpResult<F> {
     let mut xi: F::Int = x.to_bits();
     let e: i32 = x.exp_unbiased();
 
-    // C1: The represented value has no fractional part, so no truncation is needed
+    // The represented value has no fractional part, so no truncation is needed
     if e >= F::SIG_BITS as i32 {
         return FpResult::ok(x);
     }
 
     let mask = if e < 0 {
-        // C2: If the exponent is negative, the result will be zero so we mask out everything
+        // If the exponent is negative, the result will be zero so we mask out everything
         // except the sign.
         F::SIGN_MASK
     } else {
-        // C3: Otherwise, we mask out the last `e` bits of the significand.
+        // Otherwise, we mask out the last `e` bits of the significand.
         !(F::SIG_MASK >> e.unsigned())
     };
 
-    // C4: If the to-be-masked-out portion is already zero, we have an exact result
+    // If the to-be-masked-out portion is already zero, we have an exact result
     if (xi & !mask) == IntTy::<F>::ZERO {
         return FpResult::ok(x);
     }
 
-    // C5: Otherwise the result is inexact and we will truncate. Raise `FE_INEXACT`, mask the
+    // Otherwise the result is inexact and we will truncate. Raise `FE_INEXACT`, mask the
     // result, and return.
-
-    let status = if xi & F::SIG_MASK == F::Int::ZERO {
-        Status::OK
-    } else {
-        Status::INEXACT
-    };
     xi &= mask;
-    FpResult::new(F::from_bits(xi), status)
+    FpResult::new(F::from_bits(xi), Status::INEXACT)
 }
 
 #[cfg(test)]
@@ -49,100 +43,83 @@ mod tests {
     use super::*;
     use crate::support::Hexf;
 
-    fn spec_test<F: Float>(cases: &[(F, F, Status)]) {
-        let roundtrip = [
-            F::ZERO,
-            F::ONE,
-            F::NEG_ONE,
-            F::NEG_ZERO,
-            F::INFINITY,
-            F::NEG_INFINITY,
-        ];
-
-        for x in roundtrip {
-            let FpResult { val, status } = trunc_status(x);
-            assert_biteq!(val, x, "{}", Hexf(x));
-            assert_eq!(status, Status::OK, "{}", Hexf(x));
-        }
-
-        for &(x, res, res_stat) in cases {
-            let FpResult { val, status } = trunc_status(x);
-            assert_biteq!(val, res, "{}", Hexf(x));
-            assert_eq!(status, res_stat, "{}", Hexf(x));
-        }
+    macro_rules! cases {
+        ($f:ty) => {
+            [
+                // roundtrip
+                (0.0, 0.0, Status::OK),
+                (-0.0, -0.0, Status::OK),
+                (1.0, 1.0, Status::OK),
+                (-1.0, -1.0, Status::OK),
+                (<$f>::INFINITY, <$f>::INFINITY, Status::OK),
+                (<$f>::NEG_INFINITY, <$f>::NEG_INFINITY, Status::OK),
+                // with rounding
+                (0.1, 0.0, Status::INEXACT),
+                (-0.1, -0.0, Status::INEXACT),
+                (0.5, 0.0, Status::INEXACT),
+                (-0.5, -0.0, Status::INEXACT),
+                (0.9, 0.0, Status::INEXACT),
+                (-0.9, -0.0, Status::INEXACT),
+                (1.1, 1.0, Status::INEXACT),
+                (-1.1, -1.0, Status::INEXACT),
+                (1.5, 1.0, Status::INEXACT),
+                (-1.5, -1.0, Status::INEXACT),
+                (1.9, 1.0, Status::INEXACT),
+                (-1.9, -1.0, Status::INEXACT),
+            ]
+        };
     }
 
-    /* Skipping f16 / f128 "sanity_check"s and spec cases due to rejected literal lexing at MSRV */
+    #[track_caller]
+    fn check<F: Float>(cases: &[(F, F, Status)]) {
+        for &(x, exp_res, exp_stat) in cases {
+            let FpResult { val, status } = trunc_status(x);
+            assert_biteq!(val, exp_res, "{x:?} {}", Hexf(x));
+            assert_eq!(
+                status,
+                exp_stat,
+                "{x:?} {} -> {exp_res:?} {}",
+                Hexf(x),
+                Hexf(exp_res)
+            );
+        }
+    }
 
     #[test]
     #[cfg(f16_enabled)]
-    fn spec_tests_f16() {
-        let cases = [];
-        spec_test::<f16>(&cases);
+    fn check_f16() {
+        check::<f16>(&cases!(f16));
+        check::<f16>(&[
+            (hf16!("0x1p10"), hf16!("0x1p10"), Status::OK),
+            (hf16!("-0x1p10"), hf16!("-0x1p10"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn sanity_check_f32() {
-        assert_eq!(trunc(0.5f32), 0.0);
-        assert_eq!(trunc(1.1f32), 1.0);
-        assert_eq!(trunc(2.9f32), 2.0);
+    fn check_f32() {
+        check::<f32>(&cases!(f32));
+        check::<f32>(&[
+            (hf32!("0x1p23"), hf32!("0x1p23"), Status::OK),
+            (hf32!("-0x1p23"), hf32!("-0x1p23"), Status::OK),
+        ]);
     }
 
     #[test]
-    fn spec_tests_f32() {
-        let cases = [
-            (0.1, 0.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 0.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 1.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 1.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f32>(&cases);
-
-        assert_biteq!(trunc(1.1f32), 1.0);
-        assert_biteq!(trunc(1.1f64), 1.0);
-
-        // C1
-        assert_biteq!(trunc(hf32!("0x1p23")), hf32!("0x1p23"));
-        assert_biteq!(trunc(hf64!("0x1p52")), hf64!("0x1p52"));
-        assert_biteq!(trunc(hf32!("-0x1p23")), hf32!("-0x1p23"));
-        assert_biteq!(trunc(hf64!("-0x1p52")), hf64!("-0x1p52"));
-
-        // C2
-        assert_biteq!(trunc(hf32!("0x1p-1")), 0.0);
-        assert_biteq!(trunc(hf64!("0x1p-1")), 0.0);
-        assert_biteq!(trunc(hf32!("-0x1p-1")), -0.0);
-        assert_biteq!(trunc(hf64!("-0x1p-1")), -0.0);
-    }
-
-    #[test]
-    fn sanity_check_f64() {
-        assert_eq!(trunc(1.1f64), 1.0);
-        assert_eq!(trunc(2.9f64), 2.0);
-    }
-
-    #[test]
-    fn spec_tests_f64() {
-        let cases = [
-            (0.1, 0.0, Status::INEXACT),
-            (-0.1, -0.0, Status::INEXACT),
-            (0.9, 0.0, Status::INEXACT),
-            (-0.9, -0.0, Status::INEXACT),
-            (1.1, 1.0, Status::INEXACT),
-            (-1.1, -1.0, Status::INEXACT),
-            (1.9, 1.0, Status::INEXACT),
-            (-1.9, -1.0, Status::INEXACT),
-        ];
-        spec_test::<f64>(&cases);
+    fn check_f64() {
+        check::<f64>(&cases!(f64));
+        check::<f64>(&[
+            (hf64!("0x1p52"), hf64!("0x1p52"), Status::OK),
+            (hf64!("-0x1p52"), hf64!("-0x1p52"), Status::OK),
+        ]);
     }
 
     #[test]
     #[cfg(f128_enabled)]
     fn spec_tests_f128() {
-        let cases = [];
-        spec_test::<f128>(&cases);
+        check::<f128>(&cases!(f128));
+        check::<f128>(&[
+            (hf128!("0x1p112"), hf128!("0x1p112"), Status::OK),
+            (hf128!("-0x1p112"), hf128!("-0x1p112"), Status::OK),
+        ]);
     }
 }

From 8c26adcab0d57791c2af752fd1c0973860bc38f5 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 7 Feb 2026 09:26:48 -0600
Subject: [PATCH 0048/1059] libm: Add an optimization for `floor`

ceil seems to optimize better, but this gets closer to the pre-fix
codegen.
---
 .../libm/src/math/generic/floor.rs            | 20 ++++++-------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/generic/floor.rs b/library/compiler-builtins/libm/src/math/generic/floor.rs
index c763a3cc265e..7045229c0c75 100644
--- a/library/compiler-builtins/libm/src/math/generic/floor.rs
+++ b/library/compiler-builtins/libm/src/math/generic/floor.rs
@@ -26,7 +26,6 @@ pub fn floor_status<F: Float>(x: F) -> FpResult<F> {
         return FpResult::ok(x);
     }
 
-    let status;
     let res = if e >= 0 {
         // |x| >= 1.0
         let m = F::SIG_MASK >> e.unsigned();
@@ -35,9 +34,6 @@ pub fn floor_status<F: Float>(x: F) -> FpResult<F> {
             return FpResult::ok(x);
         }
 
-        // Otherwise, raise an inexact exception.
-        status = Status::INEXACT;
-
         if x.is_sign_negative() {
             ix += m;
         }
@@ -45,26 +41,22 @@ pub fn floor_status<F: Float>(x: F) -> FpResult<F> {
         ix &= !m;
         F::from_bits(ix)
     } else {
-        // |x| < 1.0, raise an inexact exception since truncation will happen.
-        if ix & !F::SIGN_MASK == F::Int::ZERO {
-            status = Status::OK;
-        } else {
-            status = Status::INEXACT;
+        // |x| < 1.0, zero or inexact with truncation
+
+        if (ix & !F::SIGN_MASK) == F::Int::ZERO {
+            return FpResult::ok(x);
         }
 
         if x.is_sign_positive() {
             // 0.0 <= x < 1.0; rounding down goes toward +0.0.
             F::ZERO
-        } else if ix << 1 != zero {
+        } else {
             // -1.0 < x < 0.0; rounding down goes toward -1.0.
             F::NEG_ONE
-        } else {
-            // -0.0 remains unchanged
-            x
         }
     };
 
-    FpResult::new(res, status)
+    FpResult::new(res, Status::INEXACT)
 }
 
 #[cfg(test)]

From dffcc200c07f756612b2ab20ac0acf96f7ca3d19 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 02:23:56 -0600
Subject: [PATCH 0049/1059] libm: Add an optimization for `trunc`

Suggested-by: Juho Kahala <57393910+quaternic@users.noreply.github.com>
---
 .../libm/src/math/generic/trunc.rs            | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/generic/trunc.rs b/library/compiler-builtins/libm/src/math/generic/trunc.rs
index 686436c43b95..7f18eb42e884 100644
--- a/library/compiler-builtins/libm/src/math/generic/trunc.rs
+++ b/library/compiler-builtins/libm/src/math/generic/trunc.rs
@@ -10,7 +10,7 @@ pub fn trunc<F: Float>(x: F) -> F {
 
 #[inline]
 pub fn trunc_status<F: Float>(x: F) -> FpResult<F> {
-    let mut xi: F::Int = x.to_bits();
+    let xi: F::Int = x.to_bits();
     let e: i32 = x.exp_unbiased();
 
     // The represented value has no fractional part, so no truncation is needed
@@ -18,24 +18,26 @@ pub fn trunc_status<F: Float>(x: F) -> FpResult<F> {
         return FpResult::ok(x);
     }
 
-    let mask = if e < 0 {
-        // If the exponent is negative, the result will be zero so we mask out everything
+    let clear_mask = if e < 0 {
+        // If the exponent is negative, the result will be zero so we clear everything
         // except the sign.
-        F::SIGN_MASK
+        !F::SIGN_MASK
     } else {
-        // Otherwise, we mask out the last `e` bits of the significand.
-        !(F::SIG_MASK >> e.unsigned())
+        // Otherwise, we keep `e` fractional bits and clear the rest.
+        F::SIG_MASK >> e.unsigned()
     };
 
-    // If the to-be-masked-out portion is already zero, we have an exact result
-    if (xi & !mask) == IntTy::<F>::ZERO {
-        return FpResult::ok(x);
-    }
+    let cleared = xi & clear_mask;
+    let status = if cleared == IntTy::<F>::ZERO {
+        // If the to-be-zeroed portion is already zero, we have an exact result.
+        Status::OK
+    } else {
+        // Otherwise the result is inexact and we will truncate, so indicate `FE_INEXACT`.
+        Status::INEXACT
+    };
 
-    // Otherwise the result is inexact and we will truncate. Raise `FE_INEXACT`, mask the
-    // result, and return.
-    xi &= mask;
-    FpResult::new(F::from_bits(xi), Status::INEXACT)
+    // Now zero the bits we need to truncate and return.
+    FpResult::new(F::from_bits(xi ^ cleared), status)
 }
 
 #[cfg(test)]

From 8fd2474e2deb9ec1e44c7f8166c20cb3f129e1f5 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 7 Feb 2026 04:11:18 -0600
Subject: [PATCH 0050/1059] meta: Upgrade all dependencies to the latest
 incompatible versions

Most of the semver-breaking changes here relate to the 0.10 release of
`rand`.

Changelogs:

* https://github.com/criterion-rs/criterion.rs/releases/tag/criterion-v0.8.0
* https://github.com/gimli-rs/object/blob/master/CHANGELOG.md#0380
* https://github.com/rust-random/rand/blob/master/CHANGELOG.md#0100---2026-02-08
---
 library/compiler-builtins/Cargo.toml          | 22 +++++++++----------
 .../builtins-test/src/lib.rs                  |  2 +-
 .../libm-test/src/generate/random.rs          |  2 +-
 .../compiler-builtins/libm-test/tests/u256.rs |  2 +-
 library/compiler-builtins/libm/Cargo.toml     |  2 +-
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/library/compiler-builtins/Cargo.toml b/library/compiler-builtins/Cargo.toml
index 785df6a20015..26a056f43496 100644
--- a/library/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/Cargo.toml
@@ -34,14 +34,14 @@ exclude = [
 [workspace.dependencies]
 anyhow = "1.0.101"
 assert_cmd = "2.1.2"
-cc = "1.2.55"
+cc = "1.2.56"
 cfg-if = "1.0.4"
 compiler_builtins = { path = "builtins-shim", default-features = false }
-criterion = { version = "0.6.0", default-features = false, features = ["cargo_bench_support"] }
+criterion = { version = "0.8.2", default-features = false, features = ["cargo_bench_support"] }
 getopts = "0.2.24"
-getrandom = "0.3.4"
+getrandom = "0.4.1"
 gmp-mpfr-sys = { version = "1.6.8", default-features = false }
-gungraun = "0.17.0"
+gungraun = "0.17.2"
 heck = "0.5.0"
 indicatif = { version = "0.18.3", default-features = false }
 libm = { path = "libm", default-features = false }
@@ -49,22 +49,22 @@ libm-macros = { path = "crates/libm-macros" }
 libm-test = { path = "libm-test", default-features = false }
 libtest-mimic = "0.8.1"
 musl-math-sys = { path = "crates/musl-math-sys" }
-no-panic = "0.1.35"
-object = { version = "0.37.3", features = ["wasm"] }
+no-panic = "0.1.36"
+object = { version = "0.38.1", features = ["wasm"] }
 panic-handler = { path = "crates/panic-handler" }
 paste = "1.0.15"
 proc-macro2 = "1.0.106"
 quote = "1.0.44"
-rand = "0.9.2"
-rand_chacha = "0.9.0"
-rand_xoshiro = "0.7"
+rand = "0.10.0"
+rand_chacha = "0.10.0"
+rand_xoshiro = "0.8"
 rayon = "1.11.0"
 regex = "1.12.3"
 rug = { version = "1.28.1", default-features = false, features = ["float", "integer", "std"] }
 rustc_apfloat = "0.2.3"
 serde_json = "1.0.149"
-syn = "2.0.114"
-tempfile = "3.24.0"
+syn = "2.0.115"
+tempfile = "3.25.0"
 
 [profile.release]
 panic = "abort"
diff --git a/library/compiler-builtins/builtins-test/src/lib.rs b/library/compiler-builtins/builtins-test/src/lib.rs
index f1673133be27..b9ad649f88dd 100644
--- a/library/compiler-builtins/builtins-test/src/lib.rs
+++ b/library/compiler-builtins/builtins-test/src/lib.rs
@@ -22,7 +22,7 @@
 use compiler_builtins::float::Float;
 use compiler_builtins::int::{Int, MinInt};
 use rand_xoshiro::Xoshiro128StarStar;
-use rand_xoshiro::rand_core::{RngCore, SeedableRng};
+use rand_xoshiro::rand_core::{Rng, SeedableRng};
 
 /// Sets the number of fuzz iterations run for most tests. In practice, the vast majority of bugs
 /// are caught by the edge case testers. Most of the remaining bugs triggered by more complex
diff --git a/library/compiler-builtins/libm-test/src/generate/random.rs b/library/compiler-builtins/libm-test/src/generate/random.rs
index 4ee88946d8ea..09a3766c6678 100644
--- a/library/compiler-builtins/libm-test/src/generate/random.rs
+++ b/library/compiler-builtins/libm-test/src/generate/random.rs
@@ -5,7 +5,7 @@
 use libm::support::Float;
 use rand::distr::{Alphanumeric, StandardUniform};
 use rand::prelude::Distribution;
-use rand::{Rng, SeedableRng};
+use rand::{RngExt, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 
 use super::KnownSize;
diff --git a/library/compiler-builtins/libm-test/tests/u256.rs b/library/compiler-builtins/libm-test/tests/u256.rs
index d1c5cfbcc586..e697945f4797 100644
--- a/library/compiler-builtins/libm-test/tests/u256.rs
+++ b/library/compiler-builtins/libm-test/tests/u256.rs
@@ -10,7 +10,7 @@
 
 use libm_test::bigint_fuzz_iteration_count;
 use libm_test::generate::random::SEED;
-use rand::{Rng, SeedableRng};
+use rand::{RngExt, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use rug::Assign;
 use rug::integer::Order;
diff --git a/library/compiler-builtins/libm/Cargo.toml b/library/compiler-builtins/libm/Cargo.toml
index 98202d1977dc..28e594dca1f9 100644
--- a/library/compiler-builtins/libm/Cargo.toml
+++ b/library/compiler-builtins/libm/Cargo.toml
@@ -17,7 +17,7 @@ rust-version = "1.67"
 
 [dev-dependencies]
 # FIXME(msrv): switch to `no-panic.workspace` when possible
-no-panic = "0.1.35"
+no-panic = "0.1.36"
 
 [features]
 default = ["arch"]

From 706a3ab68e65c007ba236a6f39189dd9b218834b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 13 Feb 2026 07:46:29 -0600
Subject: [PATCH 0051/1059] meta: Move the Criterion dependency behind a
 `walltime` feature

Currently Criterion is always built with the test crates, but it doesn't
really need to be. It wasn't a problem before but did start showing up
with the latest version bump since it added a C dependency, and for the
Miri CI runs we don't have the C toolchains. To resolve this and speed
up compilation time, move criterion behind a new feature `walltime`.

I'd rather have named this `runtime` but don't want to confuse my future
self with "what runtime?".
---
 .../.github/workflows/main.yaml               |  2 +-
 .../builtins-test/Cargo.toml                  | 19 +++++++++++++++----
 .../{bench-runtime.sh => bench-walltime.sh}   |  2 +-
 .../compiler-builtins/libm-test/Cargo.toml    | 13 +++++++++----
 4 files changed, 26 insertions(+), 10 deletions(-)
 rename library/compiler-builtins/ci/{bench-runtime.sh => bench-walltime.sh} (77%)

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 1a69f7484d88..261b1619f1c5 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -287,7 +287,7 @@ jobs:
         path: ${{ env.BASELINE_NAME }}.tar.xz
 
     - name: Run wall time benchmarks
-      run: ./ci/bench-runtime.sh
+      run: ./ci/bench-walltime.sh
 
     - name: Print test logs if available
       if: always()
diff --git a/library/compiler-builtins/builtins-test/Cargo.toml b/library/compiler-builtins/builtins-test/Cargo.toml
index 9395ab1a985e..b2313bb9d140 100644
--- a/library/compiler-builtins/builtins-test/Cargo.toml
+++ b/library/compiler-builtins/builtins-test/Cargo.toml
@@ -16,11 +16,11 @@ rand_xoshiro.workspace = true
 # To compare float builtins against
 rustc_apfloat.workspace = true
 
-# Really a dev dependency, but dev dependencies can't be optional
+# Really dev dependencies, but those can't be optional
+criterion = { workspace = true, optional = true }
 gungraun = { workspace = true, optional = true }
 
 [dev-dependencies]
-criterion.workspace = true
 paste.workspace = true
 
 [target.'cfg(all(target_arch = "arm", not(any(target_env = "gnu", target_env = "musl")), target_os = "linux"))'.dev-dependencies]
@@ -46,8 +46,10 @@ no-sys-f16 = ["no-sys-f16-f64-convert"]
 # Enable icount benchmarks (requires gungraun-runner and valgrind locally)
 icount = ["dep:gungraun"]
 
-# Enable report generation without bringing in more dependencies by default
-benchmarking-reports = ["criterion/plotters", "criterion/html_reports"]
+# Config for wall time benchmarks. Plotters and html_reports bring in extra
+# deps so are off by default for CI.
+benchmarking-reports = ["walltime", "criterion/plotters", "criterion/html_reports"]
+walltime = ["dep:criterion"]
 
 # NOTE: benchmarks must be run with `--no-default-features` or with
 # `-p builtins-test`, otherwise the default `compiler-builtins` feature
@@ -57,38 +59,47 @@ benchmarking-reports = ["criterion/plotters", "criterion/html_reports"]
 [[bench]]
 name = "float_add"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_sub"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_mul"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_div"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_cmp"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_conv"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_extend"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_trunc"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "float_pow"
 harness = false
+required-features = ["walltime"]
 
 [[bench]]
 name = "mem_icount"
diff --git a/library/compiler-builtins/ci/bench-runtime.sh b/library/compiler-builtins/ci/bench-walltime.sh
similarity index 77%
rename from library/compiler-builtins/ci/bench-runtime.sh
rename to library/compiler-builtins/ci/bench-walltime.sh
index d272cf33463e..0393d02dfc45 100755
--- a/library/compiler-builtins/ci/bench-runtime.sh
+++ b/library/compiler-builtins/ci/bench-walltime.sh
@@ -6,4 +6,4 @@
 export LIBM_SEED=benchesbenchesbenchesbencheswoo!
 cargo bench --package libm-test \
     --no-default-features \
-    --features short-benchmarks,build-musl,libm/force-soft-floats
+    --features walltime,short-benchmarks,build-musl,libm/force-soft-floats
diff --git a/library/compiler-builtins/libm-test/Cargo.toml b/library/compiler-builtins/libm-test/Cargo.toml
index 4f65504bd584..eb382ad87f5f 100644
--- a/library/compiler-builtins/libm-test/Cargo.toml
+++ b/library/compiler-builtins/libm-test/Cargo.toml
@@ -9,7 +9,6 @@ license = "MIT OR Apache-2.0"
 anyhow.workspace = true
 # This is not directly used but is required so we can enable `gmp-mpfr-sys/force-cross`.
 gmp-mpfr-sys = { workspace = true, optional = true }
-gungraun = { workspace = true, optional = true }
 indicatif.workspace = true
 libm = { workspace = true, default-features = true, features = ["unstable-public-internals"] }
 libm-macros.workspace = true
@@ -20,6 +19,10 @@ rand_chacha.workspace = true
 rayon.workspace = true
 rug = { workspace = true, optional = true }
 
+# Really dev dependencies, but those can't be optional
+criterion = { workspace = true, optional = true }
+gungraun = { workspace = true, optional = true }
+
 [target.'cfg(target_family = "wasm")'.dependencies]
 getrandom = { workspace = true, features = ["wasm_js"] }
 
@@ -27,7 +30,6 @@ getrandom = { workspace = true, features = ["wasm_js"] }
 rand = { workspace = true, optional = true }
 
 [dev-dependencies]
-criterion.workspace = true
 libtest-mimic.workspace = true
 
 [features]
@@ -43,8 +45,10 @@ build-mpfr = ["dep:rug", "dep:gmp-mpfr-sys"]
 # Build our own musl for testing and benchmarks
 build-musl = ["dep:musl-math-sys"]
 
-# Enable report generation without bringing in more dependencies by default
-benchmarking-reports = ["criterion/plotters", "criterion/html_reports"]
+# Config for wall time benchmarks. Plotters and html_reports bring in extra
+# deps so are off by default for CI.
+benchmarking-reports = ["walltime", "criterion/plotters", "criterion/html_reports"]
+walltime = ["dep:criterion"]
 
 # Enable icount benchmarks (requires gungraun-runner and valgrind locally)
 icount = ["dep:gungraun"]
@@ -60,6 +64,7 @@ required-features = ["icount"]
 [[bench]]
 name = "random"
 harness = false
+required-features = ["walltime"]
 
 [[test]]
 # No harness so that we can skip tests at runtime based on env. Prefixed with

From 873e96b6752a323f149495abc2479d3d70df611a Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 13 Feb 2026 08:34:31 -0600
Subject: [PATCH 0052/1059] ci: Rewrap the command in miri.sh

---
 library/compiler-builtins/ci/miri.sh | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/library/compiler-builtins/ci/miri.sh b/library/compiler-builtins/ci/miri.sh
index 7b0ea44c690f..aae474d88463 100755
--- a/library/compiler-builtins/ci/miri.sh
+++ b/library/compiler-builtins/ci/miri.sh
@@ -14,5 +14,9 @@ targets=(
 )
 for target in "${targets[@]}"; do
     # Only run the `mem` tests to avoid this taking too long.
-    cargo miri test --manifest-path builtins-test/Cargo.toml --features no-asm --target "$target" -- mem
+    cargo miri test \
+        --manifest-path builtins-test/Cargo.toml \
+        --features no-asm \
+        --target "$target" \
+        -- mem
 done

From 87166b545e435a1bffac968a023260d3795e532c Mon Sep 17 00:00:00 2001
From: Aelin Reidel <aelin@travitia.xyz>
Date: Fri, 13 Feb 2026 22:59:28 -0500
Subject: [PATCH 0053/1059] libm: Reenable should_panic tests on ppc64le

The tests pass successfully for me on powerpc64le-unknown-linux-gnu
with nightly 1.95.
---
 library/compiler-builtins/libm/src/math/support/big/tests.rs | 2 --
 library/compiler-builtins/libm/src/math/support/hex_float.rs | 2 --
 2 files changed, 4 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/support/big/tests.rs b/library/compiler-builtins/libm/src/math/support/big/tests.rs
index 0c32f445c136..2eafed50a275 100644
--- a/library/compiler-builtins/libm/src/math/support/big/tests.rs
+++ b/library/compiler-builtins/libm/src/math/support/big/tests.rs
@@ -261,8 +261,6 @@ fn shr_u256() {
 #[test]
 #[should_panic]
 #[cfg(debug_assertions)]
-// FIXME(ppc): ppc64le seems to have issues with `should_panic` tests.
-#[cfg(not(all(target_arch = "powerpc64", target_endian = "little")))]
 fn shr_u256_overflow() {
     // Like regular shr, panic on overflow with debug assertions
     let _ = u256::MAX >> 256;
diff --git a/library/compiler-builtins/libm/src/math/support/hex_float.rs b/library/compiler-builtins/libm/src/math/support/hex_float.rs
index 4495e3c18801..81f6b86686c4 100644
--- a/library/compiler-builtins/libm/src/math/support/hex_float.rs
+++ b/library/compiler-builtins/libm/src/math/support/hex_float.rs
@@ -846,8 +846,6 @@ fn test_macros() {
 }
 
 #[cfg(test)]
-// FIXME(ppc): something with `should_panic` tests cause a SIGILL with ppc64le
-#[cfg(not(all(target_arch = "powerpc64", target_endian = "little")))]
 mod tests_panicking {
     extern crate std;
     use super::*;

From 7d9b4120739fa80e1fa04b2448b631148d37810d Mon Sep 17 00:00:00 2001
From: Aelin <aelin@travitia.xyz>
Date: Sat, 14 Feb 2026 21:57:28 +0100
Subject: [PATCH 0054/1059] libm: Reenable sincosf tests on ppc64
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This was missed in 6e91b0346c3d (“Revert "Disable broken powerpc64 test
due to
 https://github.com/rust-lang/rust/issues/88520"”).
---
 library/compiler-builtins/libm/src/math/sincosf.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/sincosf.rs b/library/compiler-builtins/libm/src/math/sincosf.rs
index c4beb5267f28..1d15abe54306 100644
--- a/library/compiler-builtins/libm/src/math/sincosf.rs
+++ b/library/compiler-builtins/libm/src/math/sincosf.rs
@@ -122,8 +122,6 @@ pub fn sincosf(x: f32) -> (f32, f32) {
     }
 }
 
-// PowerPC tests are failing on LLVM 13: https://github.com/rust-lang/rust/issues/88520
-#[cfg(not(target_arch = "powerpc64"))]
 #[cfg(test)]
 mod tests {
     use super::sincosf;

From 49e594e11af4ada0d3b44f7414c5f8b515de7474 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Mon, 16 Feb 2026 01:18:47 -0600
Subject: [PATCH 0055/1059] ci: Allow specifying extra extensive tests to run

For cases where we would like to run tests that aren't automatically
detected, allow the following syntax in PR descriptions:

    ci: extra-extensive=copysignf,sqrtf16
---
 library/compiler-builtins/ci/ci-util.py | 64 +++++++++++++++++++++----
 1 file changed, 55 insertions(+), 9 deletions(-)

diff --git a/library/compiler-builtins/ci/ci-util.py b/library/compiler-builtins/ci/ci-util.py
index ef9ce455178e..1fd8e72077ff 100755
--- a/library/compiler-builtins/ci/ci-util.py
+++ b/library/compiler-builtins/ci/ci-util.py
@@ -11,7 +11,7 @@ import pprint
 import re
 import subprocess as sp
 import sys
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import cache
 from glob import glob
 from inspect import cleandoc
@@ -19,8 +19,7 @@ from os import getenv
 from pathlib import Path
 from typing import TypedDict, Self
 
-USAGE = cleandoc(
-    """
+USAGE = cleandoc("""
     usage:
 
     ./ci/ci-util.py <COMMAND> [flags]
@@ -44,8 +43,7 @@ USAGE = cleandoc(
             Exit with success if the pull request contains a line starting with
             `ci: allow-regressions`, indicating that regressions in benchmarks should
             be accepted. Otherwise, exit 1.
-    """
-)
+    """)
 
 REPO_ROOT = Path(__file__).parent.parent
 GIT = ["git", "-C", REPO_ROOT]
@@ -84,6 +82,8 @@ class PrCfg:
     allow_regressions: bool = False
     # Don't run extensive tests
     skip_extensive: bool = False
+    # Add these extensive tests to the list
+    extra_extensive: list[str] = field(default_factory=list)
 
     # Allow running a large number of extensive tests. If not set, this script
     # will error out if a threshold is exceeded in order to avoid accidentally
@@ -101,11 +101,17 @@ class PrCfg:
     DIR_SKIP_EXTENSIVE: str = "skip-extensive"
     DIR_ALLOW_MANY_EXTENSIVE: str = "allow-many-extensive"
     DIR_TEST_LIBM: str = "test-libm"
+    DIR_EXTRA_EXTENSIVE: str = "extra-extensive"
 
     def __init__(self, body: str):
-        directives = re.finditer(r"^\s*ci:\s*(?P<dir_name>\S*)", body, re.MULTILINE)
+        directives = re.finditer(
+            r"^\s*ci:\s*(?P<dir_name>[^\s=]*)(?:\s*=\s*(?P<args>.*))?",
+            body,
+            re.MULTILINE,
+        )
         for dir in directives:
             name = dir.group("dir_name")
+            args = dir.group("args")
             if name == self.DIR_ALLOW_REGRESSIONS:
                 self.allow_regressions = True
             elif name == self.DIR_SKIP_EXTENSIVE:
@@ -114,10 +120,17 @@ class PrCfg:
                 self.allow_many_extensive = True
             elif name == self.DIR_TEST_LIBM:
                 self.always_test_libm = True
+            elif name == self.DIR_EXTRA_EXTENSIVE:
+                self.extra_extensive = [x.strip() for x in args.split(",")]
+                args = None
             else:
                 eprint(f"Found unexpected directive `{name}`")
                 exit(1)
 
+            if args is not None:
+                eprint("Found arguments where not expected")
+                exit(1)
+
         pprint.pp(self)
 
 
@@ -276,29 +289,35 @@ class Context:
 
         skip_tests = False
         error_on_many_tests = False
+        extra_tests = {}
 
         pr = PrInfo.from_env()
         if pr is not None:
             skip_tests = pr.cfg.skip_extensive
             error_on_many_tests = not pr.cfg.allow_many_extensive
+            for fn_name in pr.cfg.extra_extensive:
+                extra_tests.setdefault(base_name(fn_name)[1], []).append(fn_name)
 
             if skip_tests:
                 eprint("Skipping all extensive tests")
 
         changed = self.changed_routines()
+        eprint(f"Changed: {changed}")
+
         matrix = []
         total_to_test = 0
 
         # Figure out which extensive tests need to run
         for ty in TYPES:
             ty_changed = changed.get(ty, [])
-            ty_to_test = [] if skip_tests else ty_changed
+            ty_to_test = [] if skip_tests else ty_changed.copy()
+            ty_to_test.extend(extra_tests.get(ty, []))
             total_to_test += len(ty_to_test)
 
             item = {
                 "ty": ty,
-                "changed": ",".join(ty_changed),
-                "to_test": ",".join(ty_to_test),
+                "changed": ",".join(sorted(set(ty_changed))),
+                "to_test": ",".join(sorted(set(ty_to_test))),
             }
 
             matrix.append(item)
@@ -319,6 +338,33 @@ class Context:
             exit(1)
 
 
+def base_name(name: str) -> tuple[str, str]:
+    """Return the basename and type from a full function name. Keep in sync with Rust's
+    `fn base_name`.
+    """
+    known_mappings = [
+        ("erff", ("erf", "f32")),
+        ("erf", ("erf", "f64")),
+        ("modff", ("modf", "f32")),
+        ("modf", ("modf", "f64")),
+        ("lgammaf_r", ("lgamma_r", "f32")),
+        ("lgamma_r", ("lgamma_r", "f64")),
+    ]
+
+    found = next((base for (full, base) in known_mappings if full == name), None)
+    if found is not None:
+        return found
+
+    if name.endswith("f"):
+        return (name.rstrip("f"), "f32")
+    elif name.endswith("f16"):
+        return (name.rstrip("f16"), "f16")
+    elif name.endswith("f128"):
+        return (name.rstrip("f128"), "f128")
+
+    return (name, "f64")
+
+
 def locate_baseline(flags: list[str]) -> None:
     """Find the most recent baseline from CI, download it if specified.
 

From 9be3b21559a5de22ee3920dc91811d4f1c5ac65c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Mon, 16 Feb 2026 02:35:29 -0600
Subject: [PATCH 0056/1059] meta: Add a root Cargo.lock file

In order to improve upon some inconsistencies seen across CI runs and
locally, add a Cargo.lock file for the main workspace.
---
 library/compiler-builtins/.gitignore |    6 +-
 library/compiler-builtins/Cargo.lock | 1644 ++++++++++++++++++++++++++
 2 files changed, 1649 insertions(+), 1 deletion(-)
 create mode 100644 library/compiler-builtins/Cargo.lock

diff --git a/library/compiler-builtins/.gitignore b/library/compiler-builtins/.gitignore
index abe346659d4c..1137a19cf093 100644
--- a/library/compiler-builtins/.gitignore
+++ b/library/compiler-builtins/.gitignore
@@ -1,7 +1,11 @@
 # Rust files
-Cargo.lock
 target
 
+# We have a couple of potential Cargo.lock files, but we only the root
+# workspace should have dependencies other than (optional) `cc`.
+Cargo.lock
+!/Cargo.lock
+
 # Sources for external files
 compiler-rt
 *.tar.gz
diff --git a/library/compiler-builtins/Cargo.lock b/library/compiler-builtins/Cargo.lock
new file mode 100644
index 000000000000..4bbdf5f4ae20
--- /dev/null
+++ b/library/compiler-builtins/Cargo.lock
@@ -0,0 +1,1644 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloca"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
+
+[[package]]
+name = "assert_cmd"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c5bcfa8749ac45dd12cb11055aeeb6b27a3895560d60d71e3c23bf979e60514"
+dependencies = [
+ "anstyle",
+ "bstr",
+ "libc",
+ "predicates",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "az"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be5eb007b7cacc6c660343e96f650fedf4b5a77512399eb952ca6642cf8d13f7"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "builtins-test"
+version = "0.1.0"
+dependencies = [
+ "compiler_builtins",
+ "criterion",
+ "gungraun",
+ "paste",
+ "rand_xoshiro",
+ "rustc_apfloat",
+ "test",
+ "utest-cortex-m-qemu",
+ "utest-macros",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "rand_core",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63be97961acde393029492ce0be7a1af7e323e6bae9511ebfac33751be5e6806"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f13174bda5dfd69d7e947827e5af4b0f2f94a4a3ee92912fba07a66150f21e2"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "compiler_builtins"
+version = "0.1.160"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "console"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e45a4a8926227e4197636ba97a9fc9b00477e9f4bd711395687c5f0734bec4"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "criterion"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
+dependencies = [
+ "alloca",
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "itertools",
+ "num-traits",
+ "oorandom",
+ "page_size",
+ "plotters",
+ "regex",
+ "serde",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+]
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "escape8259"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5692dd7b5a1978a5aeb0ce83b7655c58ca8efdcb79d21036ea249da95afec2c6"
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "getopts"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "rand_core",
+ "wasip2",
+ "wasip3",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "gmp-mpfr-sys"
+version = "1.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60f8970a75c006bb2f8ae79c6768a116dd215fa8346a87aed99bf9d82ca43394"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "gungraun"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c1bbe46f51c63bc08a1fac0ee0c530a77c961613a86ecf828ab1b0ffc6687a"
+dependencies = [
+ "bincode",
+ "derive_more",
+ "gungraun-macros",
+ "gungraun-runner",
+]
+
+[[package]]
+name = "gungraun-macros"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdccd089c36fb2ee66ef0eb7b1baa3ce7e7878a8eae682d9c8c368869ff6eca1"
+dependencies = [
+ "derive_more",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "serde",
+ "serde_json",
+ "syn",
+]
+
+[[package]]
+name = "gungraun-runner"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6da6487203fa53ae6b1c8fead642fe79a3199464b0dd1337635594d675a9ac05"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "indicatif"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25470f23803092da7d239834776d653104d551bc4d7eacaf31e6837854b8e9eb"
+dependencies = [
+ "console",
+ "portable-atomic",
+ "unit-prefix",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+dependencies = [
+ "no-panic",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libm-macros"
+version = "0.1.0"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "libm-test"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "criterion",
+ "getrandom",
+ "gmp-mpfr-sys",
+ "gungraun",
+ "indicatif",
+ "libm 0.2.16",
+ "libm-macros",
+ "libtest-mimic",
+ "musl-math-sys",
+ "paste",
+ "rand",
+ "rand_chacha",
+ "rayon",
+ "rug",
+]
+
+[[package]]
+name = "libtest-mimic"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5297962ef19edda4ce33aaa484386e0a5b3d7f2f4e037cbeee00503ef6b29d33"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap",
+ "escape8259",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "musl-math-sys"
+version = "0.1.0"
+dependencies = [
+ "cc",
+ "libm 0.2.16",
+]
+
+[[package]]
+name = "no-panic"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f967505aabc8af5752d098c34146544a43684817cdba8f9725b292530cabbf53"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "object"
+version = "0.38.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271638cd5fa9cca89c4c304675ca658efc4e64a66c716b7cfe1afb4b9611dbbc"
+dependencies = [
+ "flate2",
+ "memchr",
+ "ruzstd",
+ "wasmparser 0.243.0",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "panic-handler"
+version = "0.1.0"
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "predicates"
+version = "3.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
+dependencies = [
+ "chacha20",
+ "getrandom",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
+
+[[package]]
+name = "rand_xoshiro"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f0b2cc7bfeef8f0320ca45f88b00157a03c67137022d59393614352d6bf4312"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+
+[[package]]
+name = "rug"
+version = "1.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de190ec858987c79cad4da30e19e546139b3339331282832af004d0ea7829639"
+dependencies = [
+ "az",
+ "gmp-mpfr-sys",
+ "libc",
+ "libm 0.2.16 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rustc_apfloat"
+version = "0.2.3+llvm-462a31f5a5ab"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "486c2179b4796f65bfe2ee33679acf0927ac83ecf583ad6c91c3b4570911b9ad"
+dependencies = [
+ "bitflags",
+ "smallvec",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ruzstd"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5ff0cc5e135c8870a775d3320910cd9b564ec036b4dc0b8741629020be63f01"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "sc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "010e18bd3bfd1d45a7e666b236c78720df0d9a7698ebaa9c1c559961eb60a38b"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "symbol-check"
+version = "0.1.0"
+dependencies = [
+ "assert_cmd",
+ "cc",
+ "getopts",
+ "object",
+ "regex",
+ "serde_json",
+ "tempfile",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3df424c70518695237746f84cede799c9c58fcb37450d7b23716568cc8bc69cb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termtree"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
+
+[[package]]
+name = "test"
+version = "0.1.0"
+source = "git+https://github.com/japaric/utest#e32073e2b078e3bee46001c13ae4c1acf368d762"
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "unit-prefix"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3"
+
+[[package]]
+name = "utest-cortex-m-qemu"
+version = "0.1.0"
+source = "git+https://github.com/japaric/utest#e32073e2b078e3bee46001c13ae4c1acf368d762"
+dependencies = [
+ "sc",
+]
+
+[[package]]
+name = "utest-macros"
+version = "0.1.0"
+source = "git+https://github.com/japaric/utest#e32073e2b078e3bee46001c13ae4c1acf368d762"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "util"
+version = "0.1.0"
+dependencies = [
+ "cfg-if",
+ "libm 0.2.16",
+ "libm-macros",
+ "libm-test",
+ "musl-math-sys",
+ "rug",
+]
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.243.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6d8db401b0528ec316dfbe579e6ab4152d61739cfe076706d2009127970159d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser 0.244.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

From e12d83967e0537f4066f18a485d61e044f0314b6 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Mon, 16 Feb 2026 03:02:14 -0600
Subject: [PATCH 0057/1059] ci: Resolve an issue calculating workflow variables

PRs are now getting the following:

    Traceback (most recent call last):
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 510, in <module>
        main()
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 496, in main
        ctx.emit_workflow_output()
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 294, in emit_workflow_output
        pr = PrInfo.from_env()
             ^^^^^^^^^^^^^^^^^
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 152, in from_env
        return cls.from_pr(pr_env)
               ^^^^^^^^^^^^^^^^^^^
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 174, in from_pr
        return cls(**json.loads(pr_info), cfg=PrCfg(pr_json["body"]))
                                              ^^^^^^^^^^^^^^^^^^^^^^
      File "/home/runner/work/compiler-builtins/compiler-builtins/ci/ci-util.py", line 134, in __init__
        pprint.pp(self)
      File "/usr/lib/python3.12/pprint.py", line 66, in pp
        pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
    ...
    AttributeError: 'PrCfg' object has no attribute 'extra_extensive'. Did you mean: 'skip_extensive'?

Resolve this by using `__post_init__` rather than `__init__`.

Fixes: bba024d20464 ("ci: Allow specifying extra extensive tests to run")
---
 library/compiler-builtins/ci/ci-util.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/library/compiler-builtins/ci/ci-util.py b/library/compiler-builtins/ci/ci-util.py
index 1fd8e72077ff..392f83c219e7 100755
--- a/library/compiler-builtins/ci/ci-util.py
+++ b/library/compiler-builtins/ci/ci-util.py
@@ -71,19 +71,21 @@ def eprint(*args, **kwargs):
     print(*args, file=sys.stderr, **kwargs)
 
 
-@dataclass(init=False)
+@dataclass(kw_only=True)
 class PrCfg:
     """Directives that we allow in the commit body to control test behavior.
 
     These are of the form `ci: foo`, at the start of a line.
     """
 
+    # The PR body
+    body: str
     # Skip regression checks (must be at the start of a line).
     allow_regressions: bool = False
     # Don't run extensive tests
     skip_extensive: bool = False
     # Add these extensive tests to the list
-    extra_extensive: list[str] = field(default_factory=list)
+    extra_extensive: list[str] = field(default_factory=list, init=False)
 
     # Allow running a large number of extensive tests. If not set, this script
     # will error out if a threshold is exceeded in order to avoid accidentally
@@ -103,10 +105,10 @@ class PrCfg:
     DIR_TEST_LIBM: str = "test-libm"
     DIR_EXTRA_EXTENSIVE: str = "extra-extensive"
 
-    def __init__(self, body: str):
+    def __post_init__(self):
         directives = re.finditer(
             r"^\s*ci:\s*(?P<dir_name>[^\s=]*)(?:\s*=\s*(?P<args>.*))?",
-            body,
+            self.body,
             re.MULTILINE,
         )
         for dir in directives:
@@ -131,7 +133,7 @@ class PrCfg:
                 eprint("Found arguments where not expected")
                 exit(1)
 
-        pprint.pp(self)
+        eprint(pprint.pformat(self))
 
 
 @dataclass
@@ -171,7 +173,7 @@ class PrInfo:
         )
         pr_json = json.loads(pr_info)
         eprint("PR info:", json.dumps(pr_json, indent=4))
-        return cls(**json.loads(pr_info), cfg=PrCfg(pr_json["body"]))
+        return cls(**pr_json, cfg=PrCfg(body=pr_json["body"]))
 
 
 class FunctionDef(TypedDict):

From 1542d6405c144697cd9d5f50c5db55c0931651af Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Mon, 16 Feb 2026 03:40:01 -0600
Subject: [PATCH 0058/1059] test: Enable the `wasmbind` feature on indicatif
 for wasm

As of indicatif 0.18.4, this option must be enabled in able to build.
---
 library/compiler-builtins/Cargo.lock           | 11 +++++++++++
 library/compiler-builtins/libm-test/Cargo.toml |  1 +
 2 files changed, 12 insertions(+)

diff --git a/library/compiler-builtins/Cargo.lock b/library/compiler-builtins/Cargo.lock
index 4bbdf5f4ae20..7a3e9a38430b 100644
--- a/library/compiler-builtins/Cargo.lock
+++ b/library/compiler-builtins/Cargo.lock
@@ -590,6 +590,7 @@ dependencies = [
  "console",
  "portable-atomic",
  "unit-prefix",
+ "web-time",
 ]
 
 [[package]]
@@ -1409,6 +1410,16 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
diff --git a/library/compiler-builtins/libm-test/Cargo.toml b/library/compiler-builtins/libm-test/Cargo.toml
index eb382ad87f5f..8a8c2b0a2ce0 100644
--- a/library/compiler-builtins/libm-test/Cargo.toml
+++ b/library/compiler-builtins/libm-test/Cargo.toml
@@ -25,6 +25,7 @@ gungraun = { workspace = true, optional = true }
 
 [target.'cfg(target_family = "wasm")'.dependencies]
 getrandom = { workspace = true, features = ["wasm_js"] }
+indicatif = { workspace = true, features = ["wasmbind"] }
 
 [build-dependencies]
 rand = { workspace = true, optional = true }

From 65443dc7074c66e53ea16a02665eee00aeb9acb3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 16 Feb 2026 22:10:26 +1100
Subject: [PATCH 0059/1059] Unalign `PackedFingerprint` on all hosts, not just
 x86 and x86-64

---
 .../rustc_data_structures/src/fingerprint.rs  | 34 ++++++++++---------
 .../rustc_middle/src/dep_graph/dep_node.rs    |  3 --
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_data_structures/src/fingerprint.rs b/compiler/rustc_data_structures/src/fingerprint.rs
index c7c0d0ab0725..06ab95d65b6a 100644
--- a/compiler/rustc_data_structures/src/fingerprint.rs
+++ b/compiler/rustc_data_structures/src/fingerprint.rs
@@ -181,22 +181,24 @@ fn decode(d: &mut D) -> Self {
     }
 }
 
-// `PackedFingerprint` wraps a `Fingerprint`. Its purpose is to, on certain
-// architectures, behave like a `Fingerprint` without alignment requirements.
-// This behavior is only enabled on x86 and x86_64, where the impact of
-// unaligned accesses is tolerable in small doses.
-//
-// This may be preferable to use in large collections of structs containing
-// fingerprints, as it can reduce memory consumption by preventing the padding
-// that the more strictly-aligned `Fingerprint` can introduce. An application of
-// this is in the query dependency graph, which contains a large collection of
-// `DepNode`s. As of this writing, the size of a `DepNode` decreases by ~30%
-// (from 24 bytes to 17) by using the packed representation here, which
-// noticeably decreases total memory usage when compiling large crates.
-//
-// The wrapped `Fingerprint` is private to reduce the chance of a client
-// invoking undefined behavior by taking a reference to the packed field.
-#[cfg_attr(any(target_arch = "x86", target_arch = "x86_64"), repr(packed))]
+/// `PackedFingerprint` wraps a `Fingerprint`.
+/// Its purpose is to behave like a `Fingerprint` without alignment requirements.
+///
+/// This may be preferable to use in large collections of structs containing
+/// fingerprints, as it can reduce memory consumption by preventing the padding
+/// that the more strictly-aligned `Fingerprint` can introduce. An application of
+/// this is in the query dependency graph, which contains a large collection of
+/// `DepNode`s. As of this writing, the size of a `DepNode` decreases by 25%
+/// (from 24 bytes to 18) by using the packed representation here, which
+/// noticeably decreases total memory usage when compiling large crates.
+///
+/// (Unalignment was previously restricted to `x86` and `x86_64` hosts, but is
+/// now enabled by default for all host architectures, in the hope that the
+/// memory and cache savings should outweigh any unaligned access penalty.)
+///
+/// The wrapped `Fingerprint` is private to reduce the chance of a client
+/// invoking undefined behavior by taking a reference to the packed field.
+#[repr(packed)]
 #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)]
 pub struct PackedFingerprint(Fingerprint);
 
diff --git a/compiler/rustc_middle/src/dep_graph/dep_node.rs b/compiler/rustc_middle/src/dep_graph/dep_node.rs
index 909638b85906..78ab157487a6 100644
--- a/compiler/rustc_middle/src/dep_graph/dep_node.rs
+++ b/compiler/rustc_middle/src/dep_graph/dep_node.rs
@@ -506,9 +506,6 @@ mod size_asserts {
     use super::*;
     // tidy-alphabetical-start
     static_assert_size!(DepKind, 2);
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     static_assert_size!(DepNode, 18);
-    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-    static_assert_size!(DepNode, 24);
     // tidy-alphabetical-end
 }

From 04334f05157ce6f0d7898de357d9ddd37769f6ef Mon Sep 17 00:00:00 2001
From: Juho Kahala <57393910+quaternic@users.noreply.github.com>
Date: Mon, 16 Feb 2026 04:36:15 +0200
Subject: [PATCH 0060/1059] fix testing at lgammaf overflow threshold

The current implementation of lgammaf evaluates to f32::MAX at the first
input that would overflow if correctly rounded. This is still well within
allowed error, so special case it.
---
 library/compiler-builtins/libm-test/src/precision.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/library/compiler-builtins/libm-test/src/precision.rs b/library/compiler-builtins/libm-test/src/precision.rs
index 5d52da168fe7..8c01c9e3d491 100644
--- a/library/compiler-builtins/libm-test/src/precision.rs
+++ b/library/compiler-builtins/libm-test/src/precision.rs
@@ -222,6 +222,15 @@ fn check_float<F: Float>(input: (f32,), actual: F, expected: F, ctx: &CheckCtx)
             return XFAIL_NOCHECK;
         }
 
+        // the testing infrastructure doesn't account for allowed ulp in the case of overflow
+        if matches!(ctx.base_name, BaseName::Lgamma | BaseName::LgammaR)
+            && input.0 == 4.0850034e36
+            && expected.is_infinite()
+            && actual == F::MAX
+        {
+            return XFAIL_NOCHECK;
+        }
+
         // FIXME(correctness): lgammaf has high relative inaccuracy near its zeroes
         if matches!(ctx.base_name, BaseName::Lgamma | BaseName::LgammaR)
             && input.0 > -13.0625

From 84cfd9a557167fe453f7f6474dbea02b76f46b1b Mon Sep 17 00:00:00 2001
From: Hans Wennborg <hans@chromium.org>
Date: Tue, 3 Feb 2026 17:02:22 +0100
Subject: [PATCH 0061/1059] Check for symbols with default visibility in
 symbol-check

to ensure that compiler-builtins doesn't expose any symbols with default
visibility.
---
 .../crates/symbol-check/src/main.rs           | 43 +++++++++++++++++--
 .../crates/symbol-check/tests/all.rs          | 26 +++++++++--
 2 files changed, 62 insertions(+), 7 deletions(-)

diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index e15522d223d8..135019e5f729 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -58,6 +58,7 @@ fn main() {
         "The binaries will not be checked for executable stacks. Used for embedded targets which \
         don't set `.note.GNU-stack` since there is no protection.",
     );
+    opts.optflag("", "no-visibility", "Don't check visibility.");
 
     let print_usage_and_exit = |code: i32| -> ! {
         eprintln!("{}", opts.usage(USAGE));
@@ -74,6 +75,7 @@ fn main() {
     }
 
     let no_os_target = m.opt_present("no-os");
+    let check_visibility = !m.opt_present("no-visibility");
     let free_args = m.free.iter().map(String::as_str).collect::<Vec<_>>();
     for arg in &free_args {
         assert!(
@@ -85,18 +87,18 @@ fn main() {
     if m.opt_present("build-and-check") {
         let target = m.opt_str("target").unwrap_or(env!("HOST").to_string());
         let paths = exec_cargo_with_args(&target, &free_args);
-        check_paths(&paths, no_os_target);
+        check_paths(&paths, no_os_target, check_visibility);
     } else if m.opt_present("check") {
         if free_args.is_empty() {
             print_usage_and_exit(1);
         }
-        check_paths(&free_args, no_os_target);
+        check_paths(&free_args, no_os_target, check_visibility);
     } else {
         print_usage_and_exit(1);
     }
 }
 
-fn check_paths<P: AsRef<Path>>(paths: &[P], no_os_target: bool) {
+fn check_paths<P: AsRef<Path>>(paths: &[P], no_os_target: bool, check_visibility: bool) {
     for path in paths {
         let path = path.as_ref();
         println!("Checking {}", path.display());
@@ -105,6 +107,9 @@ fn check_paths<P: AsRef<Path>>(paths: &[P], no_os_target: bool) {
         verify_no_duplicates(&archive);
         verify_core_symbols(&archive);
         verify_no_exec_stack(&archive, no_os_target);
+        if check_visibility {
+            verify_hidden_visibility(&archive);
+        }
     }
 }
 
@@ -329,6 +334,38 @@ fn verify_core_symbols(archive: &BinFile) {
     println!("    success: no undefined references to core found");
 }
 
+/// Check for symbols with default visibility.
+fn verify_hidden_visibility(archive: &BinFile) {
+    let mut visible = Vec::new();
+    let mut found_any = false;
+
+    archive.for_each_symbol(|symbol, obj, member| {
+        // Only check defined globals.
+        if !symbol.is_global() || symbol.is_undefined() {
+            return;
+        }
+
+        let sym = SymInfo::new(&symbol, obj, member);
+        if sym.scope == SymbolScope::Dynamic {
+            visible.push(sym);
+        }
+
+        found_any = true
+    });
+
+    if archive.has_symbol_tables() {
+        assert!(found_any, "no symbols found");
+    }
+
+    if !visible.is_empty() {
+        visible.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+        let num = visible.len();
+        panic!("found {num:#?} visible symbols: {visible:#?}");
+    }
+
+    println!("    success: no visible symbols found");
+}
+
 /// Reasons a binary is considered to have an executable stack.
 enum ExeStack {
     MissingGnuStackSec,
diff --git a/library/compiler-builtins/crates/symbol-check/tests/all.rs b/library/compiler-builtins/crates/symbol-check/tests/all.rs
index 6dc34c3e3dba..cfc8641aca82 100644
--- a/library/compiler-builtins/crates/symbol-check/tests/all.rs
+++ b/library/compiler-builtins/crates/symbol-check/tests/all.rs
@@ -75,6 +75,20 @@ fn test_core_symbols() {
         .stderr_contains("from_utf8");
 }
 
+#[test]
+fn test_visible_symbols() {
+    let t = TestTarget::from_env();
+    if t.is_windows() {
+        eprintln!("windows does not have visibility, skipping");
+        return;
+    }
+    let dir = tempdir().unwrap();
+    let lib_out = dir.path().join("libfoo.rlib");
+    t.rustc_build(&input_dir().join("good_lib.rs"), &lib_out, |cmd| cmd);
+    let assert = t.symcheck_exe().arg(&lib_out).assert();
+    assert.failure().stderr_contains("found 1 visible symbols"); // good is visible.
+}
+
 mod exe_stack {
     use super::*;
 
@@ -95,7 +109,7 @@ fn test_missing_gnu_stack_section() {
         let objs = t.cc_build().file(src).out_dir(&dir).compile_intermediates();
         let [obj] = objs.as_slice() else { panic!() };
 
-        let assert = t.symcheck_exe().arg(obj).assert();
+        let assert = t.symcheck_exe().arg(obj).arg("--no-visibility").assert();
 
         if t.is_ppc64be() || t.no_os() || t.binary_obj_format() != BinaryFormat::Elf {
             // Ppc64be doesn't emit `.note.GNU-stack`, not relevant without an OS, and non-elf
@@ -127,7 +141,7 @@ fn test_exe_gnu_stack_section() {
             .compile_intermediates();
         let [obj] = objs.as_slice() else { panic!() };
 
-        let assert = t.symcheck_exe().arg(obj).assert();
+        let assert = t.symcheck_exe().arg(obj).arg("--no-visibility").assert();
 
         if t.is_ppc64be() || t.no_os() {
             // Ppc64be doesn't emit `.note.GNU-stack`, not relevant without an OS.
@@ -179,7 +193,11 @@ fn test_good_lib() {
     let dir = tempdir().unwrap();
     let lib_out = dir.path().join("libfoo.rlib");
     t.rustc_build(&input_dir().join("good_lib.rs"), &lib_out, |cmd| cmd);
-    let assert = t.symcheck_exe().arg(&lib_out).assert();
+    let assert = t
+        .symcheck_exe()
+        .arg(&lib_out)
+        .arg("--no-visibility")
+        .assert();
     assert.success();
 }
 
@@ -199,7 +217,7 @@ fn test_good_bin() {
     t.set_bin_out_path(&mut cmd, &out);
     run(cmd.arg(input_dir().join("good_bin.c")));
 
-    let assert = t.symcheck_exe().arg(&out).assert();
+    let assert = t.symcheck_exe().arg(&out).arg("--no-visibility").assert();
     assert.success();
 }
 

From 980b31646f38b123ba3667607508bf52b0845e85 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Wed, 15 Oct 2025 23:08:15 +0000
Subject: [PATCH 0062/1059] Remove ShallowInitBox.

---
 src/base.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/base.rs b/src/base.rs
index 1a916c876824..e4865ece63b6 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -902,7 +902,6 @@ fn is_wide_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
                     lval.write_cvalue_transmute(fx, operand);
                 }
                 Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in codegen"),
-                Rvalue::ShallowInitBox(..) => bug!("`ShallowInitBox` in codegen"),
             }
         }
         StatementKind::StorageLive(_)

From 9ddb7fc60a596492db05b3ed846c0dc5f1ebbf23 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 18 Feb 2026 15:02:27 +0000
Subject: [PATCH 0063/1059] Merge commit
 'abdb98ad4b47117ee3be17b1e43fab34f18f5805' into sync_cg_clif-2026-02-18

---
 .github/scripts/free-disk-space.sh            | 259 ++++++++++++++++++
 .github/workflows/abi-cafe.yml                |   6 +
 .github/workflows/audit.yml                   |   2 +-
 Cargo.lock                                    | 108 ++++----
 Cargo.toml                                    |  24 +-
 build_system/build_backend.rs                 |   2 +
 build_system/build_sysroot.rs                 |   9 +-
 config.txt                                    |   2 +-
 ...esn-t-get-emitted-unless-VaList-is-a.patch |  25 ++
 rust-toolchain.toml                           |   2 +-
 scripts/jit-helpers.py                        |  52 ++++
 scripts/setup_rust_fork.sh                    |  44 ++-
 scripts/test_rustc_tests.sh                   |  38 +--
 src/abi/mod.rs                                |   6 +-
 14 files changed, 472 insertions(+), 107 deletions(-)
 create mode 100755 .github/scripts/free-disk-space.sh
 create mode 100644 patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
 create mode 100644 scripts/jit-helpers.py

diff --git a/.github/scripts/free-disk-space.sh b/.github/scripts/free-disk-space.sh
new file mode 100755
index 000000000000..06afdaad619f
--- /dev/null
+++ b/.github/scripts/free-disk-space.sh
@@ -0,0 +1,259 @@
+#!/bin/bash
+# Ported from rust-lang/rust commit d29e4783dff30f9526eeba3929ebfe86c00c9dad in src/ci/scripts/free-disk-space-linux.sh
+set -euo pipefail
+
+# Script inspired by https://github.com/jlumbroso/free-disk-space
+isX86() {
+    local arch
+    arch=$(uname -m)
+    if [ "$arch" = "x86_64" ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# In aws codebuild, the variable RUNNER_ENVIRONMENT is "self-hosted".
+isGitHubRunner() {
+    # `:-` means "use the value of RUNNER_ENVIRONMENT if it exists, otherwise use an empty string".
+    if [[ "${RUNNER_ENVIRONMENT:-}" == "github-hosted" ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# print a line of the specified character
+printSeparationLine() {
+    for ((i = 0; i < 80; i++)); do
+        printf "%s" "$1"
+    done
+    printf "\n"
+}
+
+# REF: https://stackoverflow.com/a/450821/408734
+getAvailableSpace() {
+    df -a | awk 'NR > 1 {avail+=$4} END {print avail}'
+}
+
+# REF: https://unix.stackexchange.com/a/44087/60849
+formatByteCount() {
+    numfmt --to=iec-i --suffix=B --padding=7 "${1}000"
+}
+
+# macro to output saved space
+printSavedSpace() {
+    # Disk space before the operation
+    local before=${1}
+    local title=${2:-}
+
+    local after
+    after=$(getAvailableSpace)
+    local saved=$((after - before))
+
+    if [ "$saved" -lt 0 ]; then
+        echo "::warning::Saved space is negative: $saved. Using '0' as saved space."
+        saved=0
+    fi
+
+    echo ""
+    printSeparationLine "*"
+    if [ -n "${title}" ]; then
+        echo "=> ${title}: Saved $(formatByteCount "$saved")"
+    else
+        echo "=> Saved $(formatByteCount "$saved")"
+    fi
+    printSeparationLine "*"
+    echo ""
+}
+
+# macro to print output of df with caption
+printDF() {
+    local caption=${1}
+
+    printSeparationLine "="
+    echo "${caption}"
+    echo ""
+    echo "$ df -h"
+    echo ""
+    df -h
+    printSeparationLine "="
+}
+
+removeUnusedFilesAndDirs() {
+    local to_remove=(
+        "/usr/share/java"
+    )
+
+    if isGitHubRunner; then
+        to_remove+=(
+            "/usr/local/aws-sam-cli"
+            "/usr/local/doc/cmake"
+            "/usr/local/julia"*
+            "/usr/local/lib/android"
+            "/usr/local/share/chromedriver-"*
+            "/usr/local/share/chromium"
+            "/usr/local/share/cmake-"*
+            "/usr/local/share/edge_driver"
+            "/usr/local/share/emacs"
+            "/usr/local/share/gecko_driver"
+            "/usr/local/share/icons"
+            "/usr/local/share/powershell"
+            "/usr/local/share/vcpkg"
+            "/usr/local/share/vim"
+            "/usr/share/apache-maven-"*
+            "/usr/share/gradle-"*
+            "/usr/share/kotlinc"
+            "/usr/share/miniconda"
+            "/usr/share/php"
+            "/usr/share/ri"
+            "/usr/share/swift"
+
+            # binaries
+            "/usr/local/bin/azcopy"
+            "/usr/local/bin/bicep"
+            "/usr/local/bin/ccmake"
+            "/usr/local/bin/cmake-"*
+            "/usr/local/bin/cmake"
+            "/usr/local/bin/cpack"
+            "/usr/local/bin/ctest"
+            "/usr/local/bin/helm"
+            "/usr/local/bin/kind"
+            "/usr/local/bin/kustomize"
+            "/usr/local/bin/minikube"
+            "/usr/local/bin/packer"
+            "/usr/local/bin/phpunit"
+            "/usr/local/bin/pulumi-"*
+            "/usr/local/bin/pulumi"
+            "/usr/local/bin/stack"
+
+            # Haskell runtime
+            "/usr/local/.ghcup"
+
+            # Azure
+            "/opt/az"
+            "/usr/share/az_"*
+        )
+
+        if [ -n "${AGENT_TOOLSDIRECTORY:-}" ]; then
+            # Environment variable set by GitHub Actions
+            to_remove+=(
+                "${AGENT_TOOLSDIRECTORY}"
+            )
+        else
+            echo "::warning::AGENT_TOOLSDIRECTORY is not set. Skipping removal."
+        fi
+    else
+        # Remove folders and files present in AWS CodeBuild
+        to_remove+=(
+            # binaries
+            "/usr/local/bin/ecs-cli"
+            "/usr/local/bin/eksctl"
+            "/usr/local/bin/kubectl"
+
+            "${HOME}/.gradle"
+            "${HOME}/.dotnet"
+            "${HOME}/.goenv"
+            "${HOME}/.phpenv"
+
+        )
+    fi
+
+    for element in "${to_remove[@]}"; do
+        if [ ! -e "$element" ]; then
+            # The file or directory doesn't exist.
+            # Maybe it was removed in a newer version of the runner or it's not present in a
+            # specific architecture (e.g. ARM).
+            echo "::warning::Directory or file $element does not exist, skipping."
+        fi
+    done
+
+    # Remove all files and directories at once to save time.
+    sudo rm -rf "${to_remove[@]}"
+}
+
+execAndMeasureSpaceChange() {
+    local operation=${1} # Function to execute
+    local title=${2}
+
+    local before
+    before=$(getAvailableSpace)
+    $operation
+
+    printSavedSpace "$before" "$title"
+}
+
+# REF: https://github.com/apache/flink/blob/master/tools/azure-pipelines/free_disk_space.sh
+cleanPackages() {
+    local packages=(
+        '^aspnetcore-.*'
+        '^dotnet-.*'
+        '^llvm-.*'
+        '^mongodb-.*'
+        'firefox'
+        'libgl1-mesa-dri'
+        'mono-devel'
+        'php.*'
+    )
+
+    if isGitHubRunner; then
+        packages+=(
+            azure-cli
+        )
+
+        if isX86; then
+            packages+=(
+                'google-chrome-stable'
+                'google-cloud-cli'
+                'google-cloud-sdk'
+                'powershell'
+            )
+        fi
+    else
+        packages+=(
+            'google-chrome-stable'
+        )
+    fi
+
+    WAIT_DPKG_LOCK="-o DPkg::Lock::Timeout=60"
+    sudo apt-get ${WAIT_DPKG_LOCK} -qq remove -y --fix-missing "${packages[@]}"
+
+    sudo apt-get ${WAIT_DPKG_LOCK} autoremove -y \
+        || echo "::warning::The command [sudo apt-get autoremove -y] failed"
+    sudo apt-get ${WAIT_DPKG_LOCK} clean \
+        || echo "::warning::The command [sudo apt-get clean] failed"
+}
+
+# They aren't present in ubuntu 24 runners.
+cleanDocker() {
+    echo "=> Removing the following docker images:"
+    sudo docker image ls
+    echo "=> Removing docker images..."
+    sudo docker image prune --all --force || true
+}
+
+# Remove Swap storage
+cleanSwap() {
+    sudo swapoff -a || true
+    sudo rm -rf /mnt/swapfile || true
+    free -h
+}
+
+# Display initial disk space stats
+AVAILABLE_INITIAL=$(getAvailableSpace)
+
+printDF "BEFORE CLEAN-UP:"
+echo ""
+execAndMeasureSpaceChange cleanPackages "Unused packages"
+execAndMeasureSpaceChange cleanDocker "Docker images"
+execAndMeasureSpaceChange cleanSwap "Swap storage"
+execAndMeasureSpaceChange removeUnusedFilesAndDirs "Unused files and directories"
+
+# Output saved space statistic
+echo ""
+printDF "AFTER CLEAN-UP:"
+
+echo ""
+echo ""
+
+printSavedSpace "$AVAILABLE_INITIAL" "Total saved"
diff --git a/.github/workflows/abi-cafe.yml b/.github/workflows/abi-cafe.yml
index 170c7126c296..3367562f2683 100644
--- a/.github/workflows/abi-cafe.yml
+++ b/.github/workflows/abi-cafe.yml
@@ -49,6 +49,12 @@ jobs:
       if: matrix.os == 'ubuntu-latest'
       run: cat /proc/cpuinfo
 
+    - name: Free disk space
+      if: runner.os == 'Linux'
+      env:
+        RUNNER_ENVIRONMENT: github-hosted
+      run: .github/scripts/free-disk-space.sh
+
     - name: Cache cargo target dir
       uses: actions/cache@v4
       with:
diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
index 274b9504beb0..95a4dcd3266d 100644
--- a/.github/workflows/audit.yml
+++ b/.github/workflows/audit.yml
@@ -13,6 +13,6 @@ jobs:
       - uses: actions/checkout@v4
       - run: |
           sed -i 's/components.*/components = []/' rust-toolchain.toml
-      - uses: rustsec/audit-check@v1.4.1
+      - uses: rustsec/audit-check@v2.0.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/Cargo.lock b/Cargo.lock
index 3d13b5540e19..afc1d0d0ab95 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -28,9 +28,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 dependencies = [
  "allocator-api2",
 ]
@@ -43,42 +43,42 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bd963a645179fa33834ba61fa63353998543b07f877e208da9eb47d4a70d1e7"
+checksum = "0377b13bf002a0774fcccac4f1102a10f04893d24060cf4b7350c87e4cbb647c"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6d5739c9dc6b5553ca758d78d87d127dd19f397f776efecf817b8ba8d0bb01"
+checksum = "cfa027979140d023b25bf7509fb7ede3a54c3d3871fb5ead4673c4b633f671a2"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff402c11bb1c9652b67a3e885e84b1b8d00c13472c8fd85211e06a41a63c3e03"
+checksum = "618e4da87d9179a70b3c2f664451ca8898987aa6eb9f487d16988588b5d8cc40"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "769a0d88c2f5539e9c5536a93a7bf164b0dc68d91e3d00723e5b4ffc1440afdc"
+checksum = "db53764b5dad233b37b8f5dc54d3caa9900c54579195e00f17ea21f03f71aaa7"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4351f721fb3b26add1c180f0a75c7474bab2f903c8b777c6ca65238ded59a78"
+checksum = "4ae927f1d8c0abddaa863acd201471d56e7fc6c3925104f4861ed4dc3e28b421"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -102,9 +102,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61f86c0ba5b96713643f4dd0de0df12844de9c7bb137d6829b174b706939aa74"
+checksum = "d3fcf1e3e6757834bd2584f4cbff023fcc198e9279dcb5d684b4bb27a9b19f54"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -114,33 +114,33 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f08605eee8d51fd976a970bd5b16c9529b51b624f8af68f80649ffb172eb85a4"
+checksum = "205dcb9e6ccf9d368b7466be675ff6ee54a63e36da6fe20e72d45169cf6fd254"
 
 [[package]]
 name = "cranelift-control"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "623aab0a09e40f0cf0b5d35eb7832bae4c4f13e3768228e051a6c1a60e88ef5f"
+checksum = "108eca9fcfe86026054f931eceaf57b722c1b97464bf8265323a9b5877238817"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea0f066e07e3bcbe38884cc5c94c32c7a90267d69df80f187d9dfe421adaa7c4"
+checksum = "a0d96496910065d3165f84ff8e1e393916f4c086f88ac8e1b407678bc78735aa"
 dependencies = [
  "cranelift-bitset",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40865b02a0e52ca8e580ad64feef530cb1d05f6bb4972b4eef05e3eaeae81701"
+checksum = "e303983ad7e23c850f24d9c41fc3cb346e1b930f066d3966545e4c98dac5c9fb"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -150,15 +150,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "104b3c117ae513e9af1d90679842101193a5ccb96ac9f997966d85ea25be2852"
+checksum = "24b0cf8d867d891245836cac7abafb0a5b0ea040a019d720702b3b8bcba40bfa"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3aa5f855cfb8e4253ed2d0dfc1a0b6ebe4912e67aa8b7ee14026ff55ca17f1fe"
+checksum = "dcf1e35da6eca2448395f483eb172ce71dd7842f7dc96f44bb8923beafe43c6d"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -176,9 +176,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d01806b191b59f4fc4680293dd5f554caf2de5b62f95eff5beef7acb46c29c"
+checksum = "792ba2a54100e34f8a36e3e329a5207cafd1f0918a031d34695db73c163fdcc7"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -187,9 +187,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5c54e0a358bc05b48f2032e1c320e7f468da068604f2869b77052eab68eb0fe"
+checksum = "e24b641e315443e27807b69c440fe766737d7e718c68beb665a2d69259c77bf3"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -198,9 +198,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-object"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d17e0216be5daabab616647c1918e06dae0708474ba5f7b7762ac24ea5eb126"
+checksum = "ecba1f219a201cf946150538e631defd620c5051b62c52ecb89a0004bab263d4"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -213,9 +213,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.127.0"
+version = "0.128.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc6f4b039f453b66c75e9f7886e5a2af96276e151f44dc19b24b58f9a0c98009"
+checksum = "a4e378a54e7168a689486d67ee1f818b7e5356e54ae51a1d7a53f4f13f7f8b7a"
 
 [[package]]
 name = "crc32fast"
@@ -257,9 +257,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.15.4"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
  "foldhash",
 ]
@@ -282,9 +282,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.178"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[package]]
 name = "libloading"
@@ -298,9 +298,9 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
 [[package]]
 name = "log"
@@ -337,27 +337,27 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.103"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.42"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "regalloc2"
-version = "0.13.3"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e249c660440317032a71ddac302f25f1d5dff387667bcc3978d1f77aa31ac34"
+checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa"
 dependencies = [
  "allocator-api2",
  "bumpalo",
@@ -446,9 +446,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "syn"
-version = "2.0.111"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -457,9 +457,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.3"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
+checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
 
 [[package]]
 name = "unicode-ident"
@@ -469,9 +469,9 @@ checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "40.0.0"
+version = "41.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0858b470463f3e7c73acd6049046049e64be17b98901c2db5047450cf83df1fe"
+checksum = "bada5ca1cc47df7d14100e2254e187c2486b426df813cea2dd2553a7469f7674"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-math"
-version = "40.0.0"
+version = "41.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222e1a590ece4e898f20af1e541b61d2cb803f2557e7eaff23e6c1db5434454a"
+checksum = "cf6f615d528eda9adc6eefb062135f831b5215c348f4c3ec3e143690c730605b"
 dependencies = [
  "libm",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index ee4bde477c47..a7b4664282ed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,12 +8,12 @@ crate-type = ["dylib"]
 
 [dependencies]
 # These have to be in sync with each other
-cranelift-codegen = { version = "0.127.0", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
-cranelift-frontend = { version = "0.127.0" }
-cranelift-module = { version = "0.127.0" }
-cranelift-native = { version = "0.127.0" }
-cranelift-jit = { version = "0.127.0", optional = true }
-cranelift-object = { version = "0.127.0" }
+cranelift-codegen = { version = "0.128.3", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
+cranelift-frontend = { version = "0.128.3" }
+cranelift-module = { version = "0.128.3" }
+cranelift-native = { version = "0.128.3" }
+cranelift-jit = { version = "0.128.3", optional = true }
+cranelift-object = { version = "0.128.3" }
 target-lexicon = "0.13"
 gimli = { version = "0.32", default-features = false, features = ["write"] }
 object = { version = "0.37.3", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
@@ -24,12 +24,12 @@ smallvec = "1.8.1"
 
 [patch.crates-io]
 # Uncomment to use an unreleased version of cranelift
-#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
-#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
-#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
-#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
-#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
-#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-40.0.0" }
+#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
 
 # Uncomment to use local checkout of cranelift
 #cranelift-codegen = { path = "../wasmtime/cranelift/codegen" }
diff --git a/build_system/build_backend.rs b/build_system/build_backend.rs
index c0a8cc95614f..6b14727cd153 100644
--- a/build_system/build_backend.rs
+++ b/build_system/build_backend.rs
@@ -43,6 +43,8 @@ pub(crate) fn build_backend(
 
     cmd.arg("--release");
 
+    cmd.arg("-Zno-embed-metadata");
+
     eprintln!("[BUILD] rustc_codegen_cranelift");
     crate::utils::spawn_and_wait(cmd);
 
diff --git a/build_system/build_sysroot.rs b/build_system/build_sysroot.rs
index 7b4c604580c1..5205ec1e8aaa 100644
--- a/build_system/build_sysroot.rs
+++ b/build_system/build_sysroot.rs
@@ -235,17 +235,14 @@ fn build_clif_sysroot_for_triple(
 
     if let Some(prefix) = env::var_os("CG_CLIF_STDLIB_REMAP_PATH_PREFIX") {
         rustflags.push("--remap-path-prefix".to_owned());
-        rustflags.push(format!(
-            "{}={}",
-            STDLIB_SRC.to_path(dirs).to_str().unwrap(),
-            prefix.to_str().unwrap()
-        ));
+        rustflags.push(format!("library/={}/library", prefix.to_str().unwrap()));
     }
     compiler.rustflags.extend(rustflags);
     let mut build_cmd = STANDARD_LIBRARY.build(&compiler, dirs);
     build_cmd.arg("--release");
     build_cmd.arg("--features").arg("backtrace panic-unwind");
     build_cmd.arg(format!("-Zroot-dir={}", STDLIB_SRC.to_path(dirs).display()));
+    build_cmd.arg("-Zno-embed-metadata");
     build_cmd.env("CARGO_PROFILE_RELEASE_DEBUG", "true");
     build_cmd.env("__CARGO_DEFAULT_LIB_METADATA", "cg_clif");
     if compiler.triple.contains("apple") {
@@ -260,7 +257,7 @@ fn build_clif_sysroot_for_triple(
     for entry in fs::read_dir(build_dir.join("deps")).unwrap() {
         let entry = entry.unwrap();
         if let Some(ext) = entry.path().extension() {
-            if ext == "rmeta" || ext == "d" || ext == "dSYM" || ext == "clif" {
+            if ext == "d" || ext == "dSYM" || ext == "clif" {
                 continue;
             }
         } else {
diff --git a/config.txt b/config.txt
index 85748a4f8a78..72631355733c 100644
--- a/config.txt
+++ b/config.txt
@@ -20,7 +20,7 @@ aot.mini_core_hello_world
 
 testsuite.base_sysroot
 aot.arbitrary_self_types_pointers_and_wrappers
-jit.std_example
+#jit.std_example # FIXME(#1619) broken for some reason
 aot.std_example
 aot.dst_field_align
 aot.subslice-patterns-const-eval
diff --git a/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch b/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
new file mode 100644
index 000000000000..2aa93164674f
--- /dev/null
+++ b/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
@@ -0,0 +1,25 @@
+From 116abc64add4d617104993a7a3011f20bcf31ef2 Mon Sep 17 00:00:00 2001
+From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
+Date: Mon, 26 Jan 2026 16:20:58 +0000
+Subject: [PATCH] Ensure va_end doesn't get emitted unless VaList is actually
+ used
+
+---
+ library/core/src/ffi/va_list.rs | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
+index d0f1553..75129af 100644
+--- a/library/core/src/ffi/va_list.rs
++++ b/library/core/src/ffi/va_list.rs
+@@ -217,6 +217,7 @@ impl Clone for VaList<'_> {
+
+ #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
+ impl<'f> const Drop for VaList<'f> {
++    #[inline]
+     fn drop(&mut self) {
+         // SAFETY: this variable argument list is being dropped, so won't be read from again.
+         unsafe { va_end(self) }
+-- 
+2.43.0
+
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index b157c5879ba7..fe967c84352c 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2025-12-23"
+channel = "nightly-2026-02-18"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"
diff --git a/scripts/jit-helpers.py b/scripts/jit-helpers.py
new file mode 100644
index 000000000000..1128521c0dfb
--- /dev/null
+++ b/scripts/jit-helpers.py
@@ -0,0 +1,52 @@
+import gdb
+
+def jitmap_raw():
+    pid = gdb.selected_inferior().pid
+    jitmap_file = open("/tmp/perf-%d.map" % (pid,), "r")
+    jitmap = jitmap_file.read()
+    jitmap_file.close()
+    return jitmap
+
+def jit_functions():
+    jitmap = jitmap_raw()
+
+    functions = []
+    for line in jitmap.strip().split("\n"):
+        [addr, size, name] = line.split(" ")
+        functions.append((int(addr, 16), int(size, 16), name))
+
+    return functions
+
+class JitDecorator(gdb.FrameDecorator.FrameDecorator):
+    def __init__(self, fobj, name):
+        super(JitDecorator, self).__init__(fobj)
+        self.name = name
+
+    def function(self):
+        return self.name
+
+class JitFilter:
+    """
+    A backtrace filter which reads perf map files produced by cranelift-jit.
+    """
+
+    def __init__(self):
+        self.name = 'JitFilter'
+        self.enabled = True
+        self.priority = 0
+
+        gdb.current_progspace().frame_filters[self.name] = self
+
+    # FIXME add an actual unwinder or somehow register JITed .eh_frame with gdb to avoid relying on
+    # gdb unwinder heuristics.
+    def filter(self, frame_iter):
+        for frame in frame_iter:
+            frame_addr = frame.inferior_frame().pc()
+            for (addr, size, name) in jit_functions():
+                if frame_addr >= addr and frame_addr < addr + size:
+                    yield JitDecorator(frame, name)
+                    break
+            else:
+                yield frame
+
+JitFilter()
diff --git a/scripts/setup_rust_fork.sh b/scripts/setup_rust_fork.sh
index c16cb4e538fe..bb9f69b5c974 100644
--- a/scripts/setup_rust_fork.sh
+++ b/scripts/setup_rust_fork.sh
@@ -49,25 +49,45 @@ std-features = ["panic-unwind"]
 EOF
 
 cat <<EOF | git apply -
+diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
+index 2e16f2cf27..3ac3df99a8 100644
+--- a/src/bootstrap/bootstrap.py
++++ b/src/bootstrap/bootstrap.py
+@@ -1147,6 +1147,8 @@ class RustBuild(object):
+             args += ["-Zwarnings"]
+             env["CARGO_BUILD_WARNINGS"] = "deny"
+
++        env["RUSTFLAGS"] += " -Zbinary-dep-depinfo"
++
+         # Add RUSTFLAGS_BOOTSTRAP to RUSTFLAGS for bootstrap compilation.
+         # Note that RUSTFLAGS_BOOTSTRAP should always be added to the end of
+         # RUSTFLAGS, since that causes RUSTFLAGS_BOOTSTRAP to override RUSTFLAGS.
 diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
 index a656927b1f6..44fc5546fac 100644
 --- a/src/bootstrap/src/core/config/config.rs
 +++ b/src/bootstrap/src/core/config/config.rs
-@@ -2249,14 +2249,6 @@ pub fn parse_download_ci_llvm<'a>(
-                 );
+@@ -2249,7 +2249,7 @@ pub fn parse_download_ci_llvm<'a>(
              }
 
--            #[cfg(not(test))]
+             #[cfg(not(test))]
 -            if b && dwn_ctx.is_running_on_ci && CiEnv::is_rust_lang_managed_ci_job() {
--                // On rust-lang CI, we must always rebuild LLVM if there were any modifications to it
--                panic!(
--                    "\`llvm.download-ci-llvm\` cannot be set to \`true\` on CI. Use \`if-unchanged\` instead."
--                );
--            }
--
-             // If download-ci-llvm=true we also want to check that CI llvm is available
-             b && llvm::is_ci_llvm_available_for_target(&dwn_ctx.host_target, asserts)
-         }
++            if false && dwn_ctx.is_running_on_ci && CiEnv::is_rust_lang_managed_ci_job() {
+                 // On rust-lang CI, we must always rebuild LLVM if there were any modifications to it
+                 panic!(
+                     "\`llvm.download-ci-llvm\` cannot be set to \`true\` on CI. Use \`if-unchanged\` instead."
+diff --git a/src/build_helper/src/git.rs b/src/build_helper/src/git.rs
+index 330fb465de..a4593ed96f 100644
+--- a/src/build_helper/src/git.rs
++++ b/src/build_helper/src/git.rs
+@@ -218,7 +218,7 @@ pub fn get_closest_upstream_commit(
+     config: &GitConfig<'_>,
+     env: CiEnv,
+ ) -> Result<Option<String>, String> {
+-    let base = match env {
++    let base = match CiEnv::None {
+         CiEnv::None => "HEAD",
+         CiEnv::GitHubActions => {
+             // On CI, we should always have a non-upstream merge commit at the tip,
 EOF
 
 popd
diff --git a/scripts/test_rustc_tests.sh b/scripts/test_rustc_tests.sh
index b25269d1430a..4cad18f2a94f 100755
--- a/scripts/test_rustc_tests.sh
+++ b/scripts/test_rustc_tests.sh
@@ -10,11 +10,6 @@ pushd rust
 
 command -v rg >/dev/null 2>&1 || cargo install ripgrep
 
-rm -r tests/ui/{lto/,linkage*} || true
-for test in $(rg --files-with-matches "lto" tests/{codegen-units,ui,incremental}); do
-  rm $test
-done
-
 # should-fail tests don't work when compiletest is compiled with panic=abort
 for test in $(rg --files-with-matches "//@ should-fail" tests/{codegen-units,ui,incremental}); do
   rm $test
@@ -38,6 +33,7 @@ rm tests/ui/simd/intrinsic/generic-arithmetic-pass.rs # unimplemented simd_funne
 rm -r tests/ui/scalable-vectors # scalable vectors are unsupported
 
 # exotic linkages
+rm -r tests/ui/linkage*
 rm tests/incremental/hashes/function_interfaces.rs
 rm tests/incremental/hashes/statics.rs
 rm -r tests/run-make/naked-symbol-visibility
@@ -45,11 +41,13 @@ rm -r tests/run-make/naked-symbol-visibility
 # variadic arguments
 rm tests/ui/abi/mir/mir_codegen_calls_variadic.rs # requires float varargs
 rm tests/ui/c-variadic/naked.rs # same
+rm tests/ui/consts/const-eval/c-variadic.rs # same
 rm tests/ui/abi/variadic-ffi.rs # requires callee side vararg support
 rm -r tests/run-make/c-link-to-rust-va-list-fn # requires callee side vararg support
 rm tests/ui/c-variadic/valid.rs # same
 rm tests/ui/c-variadic/trait-method.rs # same
 rm tests/ui/c-variadic/inherent-method.rs # same
+rm tests/ui/c-variadic/copy.rs # same
 rm tests/ui/sanitizer/kcfi-c-variadic.rs # same
 rm tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs # variadics for calling conventions other than C unsupported
 rm tests/ui/delegation/fn-header.rs
@@ -79,6 +77,10 @@ rm -r tests/ui/eii # EII not yet implemented
 rm -r tests/run-make/forced-unwind-terminate-pof # forced unwinding doesn't take precedence
 
 # requires LTO
+rm -r tests/ui/lto
+for test in $(rg --files-with-matches "lto" tests/{codegen-units,ui,incremental}); do
+  rm $test
+done
 rm -r tests/run-make/cdylib
 rm -r tests/run-make/codegen-options-parsing
 rm -r tests/run-make/lto-*
@@ -126,6 +128,14 @@ rm -r tests/run-make/notify-all-emit-artifacts
 rm -r tests/run-make/reset-codegen-1
 rm -r tests/run-make/inline-always-many-cgu
 rm -r tests/run-make/intrinsic-unreachable
+rm -r tests/run-make/artifact-incr-cache
+rm -r tests/run-make/artifact-incr-cache-no-obj
+rm -r tests/run-make/emit
+rm -r tests/run-make/llvm-outputs
+rm -r tests/run-make/panic-impl-transitive
+rm -r tests/ui/debuginfo/debuginfo-emit-llvm-ir-and-split-debuginfo.rs
+rm -r tests/ui/statics/issue-91050-1.rs
+rm -r tests/ui/statics/issue-91050-2.rs
 
 # giving different but possibly correct results
 # =============================================
@@ -134,6 +144,7 @@ rm tests/ui/mir/mir_raw_fat_ptr.rs # same
 rm tests/ui/consts/issue-33537.rs # same
 rm tests/ui/consts/const-mut-refs-crate.rs # same
 rm tests/ui/abi/large-byval-align.rs # exceeds implementation limit of Cranelift
+rm -r tests/run-make/short-ice # ICE backtrace begin/end marker mismatch
 
 # doesn't work due to the way the rustc test suite is invoked.
 # should work when using ./x.py test the way it is intended
@@ -147,20 +158,15 @@ rm -r tests/run-make-cargo/panic-immediate-abort-codegen # same
 rm -r tests/run-make/missing-unstable-trait-bound # This disables support for unstable features, but running cg_clif needs some unstable features
 rm -r tests/run-make/const-trait-stable-toolchain # same
 rm -r tests/run-make/print-request-help-stable-unstable # same
+rm -r tests/run-make/issue-149402-suggest-unresolve # same
 rm -r tests/run-make/incr-add-rust-src-component
 rm tests/ui/errors/remap-path-prefix-sysroot.rs # different sysroot source path
 rm -r tests/run-make/export/extern-opt # something about rustc version mismatches
 rm -r tests/run-make/export # same
 rm -r tests/ui/compiletest-self-test/compile-flags-incremental.rs # needs compiletest compiled with panic=unwind
-rm tests/ui/async-await/in-trait/dont-project-to-specializable-projection.rs # something going wrong with stdlib source remapping
-rm tests/ui/consts/miri_unleashed/drop.rs # same
-rm tests/ui/error-emitter/multiline-removal-suggestion.rs # same
-rm tests/ui/lint/lint-const-item-mutation.rs # same
-rm tests/ui/lint/use-redundant/use-redundant-issue-71450.rs # same
-rm tests/ui/lint/use-redundant/use-redundant-prelude-rust-2021.rs # same
-rm tests/ui/specialization/const_trait_impl.rs # same
-rm tests/ui/thir-print/offset_of.rs # same
-rm tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs # same
+rm -r tests/ui/extern/extern-types-field-offset.rs # expects /rustc/<hash> rather than /rustc/FAKE_PREFIX
+rm -r tests/ui/process/println-with-broken-pipe.rs # same
+rm tests/codegen-units/item-collection/opaque-return-impls.rs # extra mono item. possibly due to other configuration
 
 # genuine bugs
 # ============
@@ -170,11 +176,7 @@ rm -r tests/run-make/panic-abort-eh_frame # .eh_frame emitted with panic=abort
 # bugs in the test suite
 # ======================
 rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
-rm tests/ui/backtrace/synchronized-panic-handler.rs # missing needs-unwind annotation
-rm tests/ui/lint/non-snake-case/lint-non-snake-case-crate.rs # same
-rm tests/ui/async-await/async-drop/async-drop-initial.rs # same (rust-lang/rust#140493)
 rm -r tests/ui/codegen/equal-pointers-unequal # make incorrect assumptions about the location of stack variables
-rm -r tests/run-make-cargo/rustdoc-scrape-examples-paths # FIXME(rust-lang/rust#145580) incr comp bug
 rm -r tests/incremental/extern_static/issue-49153.rs # assumes reference to undefined static gets optimized away
 
 rm tests/ui/intrinsics/panic-uninitialized-zeroed.rs # really slow with unoptimized libstd
diff --git a/src/abi/mod.rs b/src/abi/mod.rs
index 5a46f79e2ba0..133e7e26c0de 100644
--- a/src/abi/mod.rs
+++ b/src/abi/mod.rs
@@ -53,8 +53,10 @@ pub(crate) fn conv_to_call_conv(
     default_call_conv: CallConv,
 ) -> CallConv {
     match c {
-        CanonAbi::Rust | CanonAbi::C => default_call_conv,
-        CanonAbi::RustCold => CallConv::Cold,
+        CanonAbi::Rust | CanonAbi::RustCold | CanonAbi::C => default_call_conv,
+
+        // Cranelift doesn't currently have anything for this.
+        CanonAbi::RustPreserveNone => default_call_conv,
 
         // Cranelift doesn't currently have anything for this.
         CanonAbi::RustPreserveNone => default_call_conv,

From 6a1537830e393dfb937caf2e97d1c2f80049620f Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 18 Feb 2026 15:10:37 +0000
Subject: [PATCH 0064/1059] Fix broken merge

---
 src/abi/mod.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/abi/mod.rs b/src/abi/mod.rs
index 133e7e26c0de..97a19b8976d3 100644
--- a/src/abi/mod.rs
+++ b/src/abi/mod.rs
@@ -58,9 +58,6 @@ pub(crate) fn conv_to_call_conv(
         // Cranelift doesn't currently have anything for this.
         CanonAbi::RustPreserveNone => default_call_conv,
 
-        // Cranelift doesn't currently have anything for this.
-        CanonAbi::RustPreserveNone => default_call_conv,
-
         // Functions with this calling convention can only be called from assembly, but it is
         // possible to declare an `extern "custom"` block, so the backend still needs a calling
         // convention for declaring foreign functions.

From ee75e9b59896b2cf098935b31da4fda011503af3 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 18 Feb 2026 15:22:36 +0000
Subject: [PATCH 0065/1059] Format jit-helper.py

---
 scripts/jit-helpers.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/scripts/jit-helpers.py b/scripts/jit-helpers.py
index 1128521c0dfb..4542aef7cb52 100644
--- a/scripts/jit-helpers.py
+++ b/scripts/jit-helpers.py
@@ -1,5 +1,6 @@
 import gdb
 
+
 def jitmap_raw():
     pid = gdb.selected_inferior().pid
     jitmap_file = open("/tmp/perf-%d.map" % (pid,), "r")
@@ -7,6 +8,7 @@ def jitmap_raw():
     jitmap_file.close()
     return jitmap
 
+
 def jit_functions():
     jitmap = jitmap_raw()
 
@@ -17,6 +19,7 @@ def jit_functions():
 
     return functions
 
+
 class JitDecorator(gdb.FrameDecorator.FrameDecorator):
     def __init__(self, fobj, name):
         super(JitDecorator, self).__init__(fobj)
@@ -25,13 +28,14 @@ class JitDecorator(gdb.FrameDecorator.FrameDecorator):
     def function(self):
         return self.name
 
+
 class JitFilter:
     """
     A backtrace filter which reads perf map files produced by cranelift-jit.
     """
 
     def __init__(self):
-        self.name = 'JitFilter'
+        self.name = "JitFilter"
         self.enabled = True
         self.priority = 0
 
@@ -42,11 +46,12 @@ class JitFilter:
     def filter(self, frame_iter):
         for frame in frame_iter:
             frame_addr = frame.inferior_frame().pc()
-            for (addr, size, name) in jit_functions():
+            for addr, size, name in jit_functions():
                 if frame_addr >= addr and frame_addr < addr + size:
                     yield JitDecorator(frame, name)
                     break
             else:
                 yield frame
 
+
 JitFilter()

From 8b83d4b4a6fe563fdf4b89c7b4dfe2c1fb0048ce Mon Sep 17 00:00:00 2001
From: Ada Bohm <ada@kreatrix.org>
Date: Wed, 18 Feb 2026 16:44:18 +0100
Subject: [PATCH 0066/1059] Adds recursion limit into FindParamInClause

---
 .../src/solve/assembly/mod.rs                   | 10 +++++++++-
 .../find-param-recursion-issue-152716.rs        | 17 +++++++++++++++++
 .../find-param-recursion-issue-152716.stderr    |  7 +++++++
 3 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
 create mode 100644 tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr

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 63f246db8a5f..bf59f7cab8e4 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -1233,6 +1233,7 @@ fn characterize_param_env_assumption(
             ecx: self,
             param_env,
             universes: vec![],
+            recursion_depth: 0,
         }) {
             ControlFlow::Break(Err(NoSolution)) => Err(NoSolution),
             ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)),
@@ -1245,6 +1246,7 @@ struct FindParamInClause<'a, 'b, D: SolverDelegate<Interner = I>, I: Interner> {
     ecx: &'a mut EvalCtxt<'b, D>,
     param_env: I::ParamEnv,
     universes: Vec<Option<ty::UniverseIndex>>,
+    recursion_depth: usize,
 }
 
 impl<D, I> TypeVisitor<I> for FindParamInClause<'_, '_, D, I>
@@ -1274,7 +1276,13 @@ fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
                 ControlFlow::Continue(())
             }
         } else if ty.has_type_flags(TypeFlags::HAS_PLACEHOLDER | TypeFlags::HAS_RE_INFER) {
-            ty.super_visit_with(self)
+            self.recursion_depth += 1;
+            if self.recursion_depth > self.ecx.cx().recursion_limit() {
+                return ControlFlow::Break(Err(NoSolution));
+            }
+            let result = ty.super_visit_with(self);
+            self.recursion_depth -= 1;
+            result
         } else {
             ControlFlow::Continue(())
         }
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
new file mode 100644
index 000000000000..410781e955d7
--- /dev/null
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Znext-solver
+//~^ ERROR overflow normalizing the associated type `<T as Proj<'b>>::Assoc` [E0275]
+
+// Regression test for <https://github.com/rust-lang/rust/issues/152716>.
+
+trait Trait<T> {}
+trait Proj<'a> {
+    type Assoc;
+}
+fn foo<T>()
+where
+    T: for<'a> Proj<'a, Assoc = for<'b> fn(<T as Proj<'b>>::Assoc)>,
+    (): Trait<<T as Proj<'static>>::Assoc>
+{
+}
+
+fn main() {}
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
new file mode 100644
index 000000000000..9886e303eaf7
--- /dev/null
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
@@ -0,0 +1,7 @@
+error[E0275]: overflow normalizing the associated type `<T as Proj<'b>>::Assoc`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`find_param_recursion_issue_152716`)
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.

From 4da823ba4be74cdd840c6db854ee57cc0c864d31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Thu, 19 Feb 2026 22:11:58 +0100
Subject: [PATCH 0067/1059] Do not enable split debuginfo for windows-gnu

Because rustc doesn't handle split debuginfo for these targets,
enabling that option causes them to be missing some of the debuginfo.
---
 bootstrap.example.toml                            | 7 ++++---
 src/bootstrap/src/core/config/target_selection.rs | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index e0cbb0c0e747..432a68140361 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -1008,9 +1008,10 @@
 # its historical default, but when compiling the compiler itself, we skip it by
 # default since we know it's safe to do so in that case.
 #
-# On Windows platforms, packed debuginfo is the only supported option,
-# producing a `.pdb` file.
-#split-debuginfo = if linux { off } else if windows { packed } else if apple { unpacked }
+# On Windows MSVC platforms, packed debuginfo is the only supported option,
+# producing a `.pdb` file. On Windows GNU rustc doesn't support splitting debuginfo,
+# and enabling it causes issues.
+#split-debuginfo = if linux || windows-gnu { off } else if windows-msvc { packed } else if apple { unpacked }
 
 # Path to the `llvm-config` binary of the installation of a custom LLVM to link
 # against. Note that if this is specified we don't compile LLVM at all for this
diff --git a/src/bootstrap/src/core/config/target_selection.rs b/src/bootstrap/src/core/config/target_selection.rs
index 47f6d6f386df..8457607b897d 100644
--- a/src/bootstrap/src/core/config/target_selection.rs
+++ b/src/bootstrap/src/core/config/target_selection.rs
@@ -142,7 +142,7 @@ impl SplitDebuginfo {
     pub fn default_for_platform(target: TargetSelection) -> Self {
         if target.contains("apple") {
             SplitDebuginfo::Unpacked
-        } else if target.is_windows() {
+        } else if target.is_msvc() {
             SplitDebuginfo::Packed
         } else {
             SplitDebuginfo::Off

From 11953d71f5e18701e6a9f7c10f3bb612422e726b Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Feb 2026 10:48:58 +0000
Subject: [PATCH 0068/1059] Rustup to rustc 1.95.0-nightly (7f99507f5
 2026-02-19)

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index fe967c84352c..62e07412a7f8 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-02-18"
+channel = "nightly-2026-02-20"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 96e7213d310861698667e36b5568147c9217c84e Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Feb 2026 11:01:07 +0000
Subject: [PATCH 0069/1059] Fix rustc test suite

---
 scripts/setup_rust_fork.sh  | 18 +++++++++---------
 scripts/test_rustc_tests.sh |  1 -
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/scripts/setup_rust_fork.sh b/scripts/setup_rust_fork.sh
index bb9f69b5c974..2ca0c3cab910 100644
--- a/scripts/setup_rust_fork.sh
+++ b/scripts/setup_rust_fork.sh
@@ -63,18 +63,18 @@ index 2e16f2cf27..3ac3df99a8 100644
          # Note that RUSTFLAGS_BOOTSTRAP should always be added to the end of
          # RUSTFLAGS, since that causes RUSTFLAGS_BOOTSTRAP to override RUSTFLAGS.
 diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
-index a656927b1f6..44fc5546fac 100644
+index bc68bfe396..00143ef3ed 100644
 --- a/src/bootstrap/src/core/config/config.rs
 +++ b/src/bootstrap/src/core/config/config.rs
-@@ -2249,7 +2249,7 @@ pub fn parse_download_ci_llvm<'a>(
-             }
+@@ -2230,7 +2230,7 @@ pub fn download_ci_rustc_commit<'a>(
+                     return None;
+                 }
 
-             #[cfg(not(test))]
--            if b && dwn_ctx.is_running_on_ci && CiEnv::is_rust_lang_managed_ci_job() {
-+            if false && dwn_ctx.is_running_on_ci && CiEnv::is_rust_lang_managed_ci_job() {
-                 // On rust-lang CI, we must always rebuild LLVM if there were any modifications to it
-                 panic!(
-                     "\`llvm.download-ci-llvm\` cannot be set to \`true\` on CI. Use \`if-unchanged\` instead."
+-                if dwn_ctx.is_running_on_ci() {
++                if false && dwn_ctx.is_running_on_ci() {
+                     eprintln!("CI rustc commit matches with HEAD and we are in CI.");
+                     eprintln!(
+                         "\`rustc.download-ci\` functionality will be skipped as artifacts are not available."
 diff --git a/src/build_helper/src/git.rs b/src/build_helper/src/git.rs
 index 330fb465de..a4593ed96f 100644
 --- a/src/build_helper/src/git.rs
diff --git a/scripts/test_rustc_tests.sh b/scripts/test_rustc_tests.sh
index 4cad18f2a94f..798bef7ba3e3 100755
--- a/scripts/test_rustc_tests.sh
+++ b/scripts/test_rustc_tests.sh
@@ -20,7 +20,6 @@ for test in $(rg -i --files-with-matches "//(\[\w+\])?~[^\|]*\s*ERR|//@ error-pa
 done
 
 git checkout -- tests/ui/issues/auxiliary/issue-3136-a.rs # contains //~ERROR, but shouldn't be removed
-git checkout -- tests/ui/proc-macro/pretty-print-hack/
 git checkout -- tests/ui/entry-point/auxiliary/bad_main_functions.rs
 
 # missing features

From d31b87f20b28d3cc2e4f26bc3de465aa209de670 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vin=C3=ADcius=20Freitas?= <vinifreitas.d.a@gmail.com>
Date: Mon, 12 Jan 2026 01:30:00 -0300
Subject: [PATCH 0070/1059] Add Apple AArch64 support for outline atomics

Add support for ELF and Mach-O AArch64 relocation specifiers for symbol
access, enabling outline-atomics to work on Apple targets. Remove the
Linux-only OS gate in tests.

Co-authored-by: Trevor Gross <tmgross@umich.edu>
---
 .../builtins-test/tests/lse.rs                |  2 +-
 .../src/aarch64_outline_atomics.rs            | 69 +++++++++++++++++--
 2 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/library/compiler-builtins/builtins-test/tests/lse.rs b/library/compiler-builtins/builtins-test/tests/lse.rs
index 56891be8a8ac..854ea021b4b1 100644
--- a/library/compiler-builtins/builtins-test/tests/lse.rs
+++ b/library/compiler-builtins/builtins-test/tests/lse.rs
@@ -1,6 +1,6 @@
 #![feature(decl_macro)] // so we can use pub(super)
 #![feature(macro_metavar_expr_concat)]
-#![cfg(all(target_arch = "aarch64", target_os = "linux"))]
+#![cfg(target_arch = "aarch64")]
 
 /// Translate a byte size to a Rust type.
 macro int_ty {
diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
index df0cf7650222..3245523280d7 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
@@ -135,18 +135,73 @@ macro_rules! stxp {
     };
 }
 
+// The AArch64 assembly syntax for relocation specifiers
+// when accessing symbols changes depending on the target executable format.
+// In ELF (used in Linux), we have a prefix notation surrounded by colons (:specifier:sym),
+// while in Mach-O object files (used in MacOS), a postfix notation is used (sym@specifier).
+
+/// AArch64 ELF position-independent addressing:
+///
+///   adrp xN, symbol
+///   add  xN, xN, :lo12:symbol
+///
+/// The :lo12: modifier selects the low 12 bits of the symbol address
+/// and emits an ELF relocation such as R_AARCH64_ADD_ABS_LO12_NC.
+///
+/// Defined by the AArch64 ELF psABI.
+/// See: <https://github.com/ARM-software/abi-aa/blob/main/aaelf64/aaelf64.rst#static-miscellaneous-relocations>.
+#[cfg(not(target_vendor = "apple"))]
+macro_rules! sym {
+    ($sym:literal) => {
+        $sym
+    };
+}
+
+#[cfg(not(target_vendor = "apple"))]
+macro_rules! sym_off {
+    ($sym:literal) => {
+        concat!(":lo12:", $sym)
+    };
+}
+
+/// Mach-O ARM64 relocation types:
+///   ARM64_RELOC_PAGE21
+///   ARM64_RELOC_PAGEOFF12
+///
+/// These relocations implement the @PAGE / @PAGEOFF split used by
+/// adrp + add sequences on Apple platforms.
+///
+///   adrp xN, symbol@PAGE      -> ARM64_RELOC_PAGE21
+///   add  xN, xN, symbol@PAGEOFF -> ARM64_RELOC_PAGEOFF12
+///
+/// Relocation types defined by Apple in XNU: <mach-o/arm64/reloc.h>.
+/// See: <https://github.com/apple-oss-distributions/xnu/blob/f6217f891ac0bb64f3d375211650a4c1ff8ca1ea/EXTERNAL_HEADERS/mach-o/arm64/reloc.h>.
+#[cfg(target_vendor = "apple")]
+macro_rules! sym {
+    ($sym:literal) => {
+        concat!($sym, "@PAGE")
+    };
+}
+
+#[cfg(target_vendor = "apple")]
+macro_rules! sym_off {
+    ($sym:literal) => {
+        concat!($sym, "@PAGEOFF")
+    };
+}
+
 // If supported, perform the requested LSE op and return, or fallthrough.
 macro_rules! try_lse_op {
     ($op: literal, $ordering:ident, $bytes:tt, $($reg:literal,)* [ $mem:ident ] ) => {
         concat!(
-            ".arch_extension lse; ",
-            "adrp    x16, {have_lse}; ",
-            "ldrb    w16, [x16, :lo12:{have_lse}]; ",
-            "cbz     w16, 8f; ",
+            ".arch_extension lse\n",
+            concat!("adrp    x16, ", sym!("{have_lse}"), "\n"),
+            concat!("ldrb    w16, [x16, ", sym_off!("{have_lse}"), "]\n"),
+            "cbz     w16, 8f\n",
             // LSE_OP  s(reg),* [$mem]
-            concat!(lse!($op, $ordering, $bytes), $( " ", reg!($bytes, $reg), ", " ,)* "[", stringify!($mem), "]; ",),
-            "ret; ",
-            "8:"
+            concat!(lse!($op, $ordering, $bytes), $( " ", reg!($bytes, $reg), ", " ,)* "[", stringify!($mem), "]\n",),
+            "ret
+            8:"
         )
     };
 }

From 010e20923b4b660d567b6d260fcb408a337e7cc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vin=C3=ADcius=20Freitas?= <vinifreitas.d.a@gmail.com>
Date: Thu, 22 Jan 2026 00:39:03 -0300
Subject: [PATCH 0071/1059] Change atomic function signatures to use unsigned
 integer types

Replace signed integer types (i8, i16, i32, i64, i128) with their
unsigned equivalents (u8, u16, u32, u64, u128) in function declarations
and the int_ty! macro, avoiding the need for sign extension in emitted
assembly.
---
 .../builtins-test/tests/lse.rs                | 10 +++++-----
 .../src/aarch64_outline_atomics.rs            | 20 +++++++++----------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/library/compiler-builtins/builtins-test/tests/lse.rs b/library/compiler-builtins/builtins-test/tests/lse.rs
index 854ea021b4b1..b727a223e5c9 100644
--- a/library/compiler-builtins/builtins-test/tests/lse.rs
+++ b/library/compiler-builtins/builtins-test/tests/lse.rs
@@ -4,11 +4,11 @@
 
 /// Translate a byte size to a Rust type.
 macro int_ty {
-    (1) => { i8 },
-    (2) => { i16 },
-    (4) => { i32 },
-    (8) => { i64 },
-    (16) => { i128 }
+    (1) => { u8 },
+    (2) => { u16 },
+    (4) => { u32 },
+    (8) => { u64 },
+    (16) => { u128 }
 }
 
 mod cas {
diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
index 3245523280d7..54232fe5c62e 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
@@ -37,11 +37,11 @@ pub extern "C" fn __rust_enable_lse() {
 /// Translate a byte size to a Rust type.
 #[rustfmt::skip]
 macro_rules! int_ty {
-    (1) => { i8 };
-    (2) => { i16 };
-    (4) => { i32 };
-    (8) => { i64 };
-    (16) => { i128 };
+    (1) => { u8 };
+    (2) => { u16 };
+    (4) => { u32 };
+    (8) => { u64 };
+    (16) => { u128 };
 }
 
 /// Given a byte size and a register number, return a register of the appropriate size.
@@ -258,15 +258,15 @@ macro_rules! compare_and_swap {
     };
 }
 
-// i128 uses a completely different impl, so it has its own macro.
-macro_rules! compare_and_swap_i128 {
+// u128 uses a completely different impl, so it has its own macro.
+macro_rules! compare_and_swap_u128 {
     ($ordering:ident, $name:ident) => {
         intrinsics! {
             #[maybe_use_optimized_c_shim]
             #[unsafe(naked)]
             pub unsafe extern "C" fn $name (
-                expected: i128, desired: i128, ptr: *mut i128
-            ) -> i128 {
+                expected: u128, desired: u128, ptr: *mut u128
+            ) -> u128 {
                 core::arch::naked_asm! {
                     // CASP   x0, x1, x2, x3, [x4]; if LSE supported.
                     try_lse_op!("cas", $ordering, 16, 0, 1, 2, 3, [x4]),
@@ -446,7 +446,7 @@ macro_rules! foreach_ldset {
 }
 
 foreach_cas!(compare_and_swap);
-foreach_cas16!(compare_and_swap_i128);
+foreach_cas16!(compare_and_swap_u128);
 foreach_swp!(swap);
 foreach_ldadd!(add);
 foreach_ldclr!(and);

From 008f3134668f667a2430008131452d7cbacf2354 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vin=C3=ADcius=20Freitas?= <vinifreitas.d.a@gmail.com>
Date: Mon, 12 Jan 2026 02:30:22 -0300
Subject: [PATCH 0072/1059] Add comprehensive tests for AArch64 atomics with
 and without LSE

Enable aarch64 outline-atomics in tests via the mangled-names feature
gate, and add comprehensive compare-and-swap tests that run both with
LSE enabled and disabled. Improve assertion messages to better describe
expected behavior.

Co-authored-by: Trevor Gross <tmgross@umich.edu>
---
 .../builtins-test/tests/lse.rs                | 102 +++++++++++++-----
 .../src/aarch64_outline_atomics.rs            |  13 +++
 .../compiler-builtins/src/lib.rs              |   7 +-
 3 files changed, 93 insertions(+), 29 deletions(-)

diff --git a/library/compiler-builtins/builtins-test/tests/lse.rs b/library/compiler-builtins/builtins-test/tests/lse.rs
index b727a223e5c9..03fe9467a2fe 100644
--- a/library/compiler-builtins/builtins-test/tests/lse.rs
+++ b/library/compiler-builtins/builtins-test/tests/lse.rs
@@ -2,6 +2,45 @@
 #![feature(macro_metavar_expr_concat)]
 #![cfg(target_arch = "aarch64")]
 
+use std::sync::Mutex;
+
+use compiler_builtins::aarch64_outline_atomics::{get_have_lse_atomics, set_have_lse_atomics};
+use compiler_builtins::int::{Int, MinInt};
+use compiler_builtins::{foreach_bytes, foreach_ordering};
+
+#[track_caller]
+fn with_maybe_lse_atomics(use_lse: bool, f: impl FnOnce()) {
+    // Ensure tests run in parallel don't interleave global settings
+    static LOCK: Mutex<()> = Mutex::new(());
+    let _g = LOCK.lock().unwrap();
+    let old = get_have_lse_atomics();
+    // safety: as the caller of the unsafe fn `set_have_lse_atomics`, we
+    // have to ensure the CPU supports LSE. This is why we make this assertion.
+    if use_lse || old {
+        assert!(std::arch::is_aarch64_feature_detected!("lse"));
+    }
+    unsafe { set_have_lse_atomics(use_lse) };
+    f();
+    unsafe { set_have_lse_atomics(old) };
+}
+
+pub fn run_fuzz_tests_with_lse_variants<I: Int, F: Fn(I, I) + Copy>(n: u32, f: F)
+where
+    <I as MinInt>::Unsigned: Int,
+{
+    // We use `fuzz_2` because our subject function `f` requires two inputs
+    let test_fn = || {
+        builtins_test::fuzz_2(n, f);
+    };
+    // Always run without LSE
+    with_maybe_lse_atomics(false, test_fn);
+
+    // Conditionally run with LSE
+    if std::arch::is_aarch64_feature_detected!("lse") {
+        with_maybe_lse_atomics(true, test_fn);
+    }
+}
+
 /// Translate a byte size to a Rust type.
 macro int_ty {
     (1) => { u8 },
@@ -15,16 +54,17 @@ mod cas {
     pub(super) macro test($_ordering:ident, $bytes:tt, $name:ident) {
         #[test]
         fn $name() {
-            builtins_test::fuzz_2(10000, |expected: super::int_ty!($bytes), new| {
+            crate::run_fuzz_tests_with_lse_variants(10000, |expected: super::int_ty!($bytes), new| {
                 let mut target = expected.wrapping_add(10);
+                let ret: super::int_ty!($bytes) = unsafe {
+                    compiler_builtins::aarch64_outline_atomics::$name::$name(
+                        expected,
+                        new,
+                        &mut target,
+                    )
+                };
                 assert_eq!(
-                    unsafe {
-                        compiler_builtins::aarch64_outline_atomics::$name::$name(
-                            expected,
-                            new,
-                            &mut target,
-                        )
-                    },
+                    ret,
                     expected.wrapping_add(10),
                     "return value should always be the previous value",
                 );
@@ -35,15 +75,17 @@ fn $name() {
                 );
 
                 target = expected;
+                let ret: super::int_ty!($bytes) = unsafe {
+                    compiler_builtins::aarch64_outline_atomics::$name::$name(
+                        expected,
+                        new,
+                        &mut target,
+                    )
+                };
                 assert_eq!(
-                    unsafe {
-                        compiler_builtins::aarch64_outline_atomics::$name::$name(
-                            expected,
-                            new,
-                            &mut target,
-                        )
-                    },
-                    expected
+                    ret,
+                    expected,
+                    "the new return value should always be the previous value (i.e. the first parameter passed to the function)",
                 );
                 assert_eq!(target, new, "should have updated target");
             });
@@ -59,16 +101,21 @@ mod swap {
     pub(super) macro test($_ordering:ident, $bytes:tt, $name:ident) {
         #[test]
         fn $name() {
-            builtins_test::fuzz_2(10000, |left: super::int_ty!($bytes), mut right| {
-                let orig_right = right;
-                assert_eq!(
-                    unsafe {
-                        compiler_builtins::aarch64_outline_atomics::$name::$name(left, &mut right)
-                    },
-                    orig_right
-                );
-                assert_eq!(left, right);
-            });
+            crate::run_fuzz_tests_with_lse_variants(
+                10000,
+                |left: super::int_ty!($bytes), mut right| {
+                    let orig_right = right;
+                    assert_eq!(
+                        unsafe {
+                            compiler_builtins::aarch64_outline_atomics::$name::$name(
+                                left, &mut right,
+                            )
+                        },
+                        orig_right
+                    );
+                    assert_eq!(left, right);
+                },
+            );
         }
     }
 }
@@ -80,7 +127,7 @@ mod $mod {
                 ($_ordering:ident, $bytes:tt, $name:ident) => {
                     #[test]
                     fn $name() {
-                        builtins_test::fuzz_2(10000, |old, val| {
+                        crate::run_fuzz_tests_with_lse_variants(10000, |old, val| {
                             let mut target = old;
                             let op: fn(super::int_ty!($bytes), super::int_ty!($bytes)) -> _ = $($op)*;
                             let expected = op(old, val);
@@ -98,7 +145,6 @@ fn $name() {
 test_op!(clr, |left, right| left & !right);
 test_op!(xor, std::ops::BitXor::bitxor);
 test_op!(or, std::ops::BitOr::bitor);
-use compiler_builtins::{foreach_bytes, foreach_ordering};
 compiler_builtins::foreach_cas!(cas::test);
 compiler_builtins::foreach_cas16!(test_cas16);
 compiler_builtins::foreach_swp!(swap::test);
diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
index 54232fe5c62e..100b67150772 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64_outline_atomics.rs
@@ -34,6 +34,19 @@ pub extern "C" fn __rust_enable_lse() {
     }
 }
 
+/// Function to enable/disable LSE. To be used only for testing purposes.
+#[cfg(feature = "mangled-names")]
+pub unsafe fn set_have_lse_atomics(has_lse: bool) {
+    let lse_flag = if has_lse { 1 } else { 0 };
+    HAVE_LSE_ATOMICS.store(lse_flag, Ordering::Relaxed);
+}
+
+/// Function to obtain whether LSE is enabled or not. To be used only for testing purposes.
+#[cfg(feature = "mangled-names")]
+pub fn get_have_lse_atomics() -> bool {
+    HAVE_LSE_ATOMICS.load(Ordering::Relaxed) != 0
+}
+
 /// Translate a byte size to a Rust type.
 #[rustfmt::skip]
 macro_rules! int_ty {
diff --git a/library/compiler-builtins/compiler-builtins/src/lib.rs b/library/compiler-builtins/compiler-builtins/src/lib.rs
index 80395a4738eb..a027cd978af2 100644
--- a/library/compiler-builtins/compiler-builtins/src/lib.rs
+++ b/library/compiler-builtins/compiler-builtins/src/lib.rs
@@ -57,7 +57,12 @@
 #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
 pub mod aarch64;
 
-#[cfg(all(target_arch = "aarch64", target_feature = "outline-atomics"))]
+// Note that we enable the module on "mangled-names" because that is the default feature
+// in the builtins-test tests. So this is a way of enabling the module during testing.
+#[cfg(all(
+    target_arch = "aarch64",
+    any(target_feature = "outline-atomics", feature = "mangled-names")
+))]
 pub mod aarch64_outline_atomics;
 
 #[cfg(target_arch = "avr")]

From 00ea98816d1ccd5c7c5d4e6aee287e656e2d1d60 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 20 Feb 2026 16:43:15 -0500
Subject: [PATCH 0073/1059] test: Gate LSE tests by mangled-names

Resolve a CI issue when running tests with `--no-default-features`.
---
 library/compiler-builtins/builtins-test/tests/lse.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/builtins-test/tests/lse.rs b/library/compiler-builtins/builtins-test/tests/lse.rs
index 03fe9467a2fe..c45fc161b6c4 100644
--- a/library/compiler-builtins/builtins-test/tests/lse.rs
+++ b/library/compiler-builtins/builtins-test/tests/lse.rs
@@ -1,6 +1,6 @@
 #![feature(decl_macro)] // so we can use pub(super)
 #![feature(macro_metavar_expr_concat)]
-#![cfg(target_arch = "aarch64")]
+#![cfg(all(target_arch = "aarch64", feature = "mangled-names"))]
 
 use std::sync::Mutex;
 

From 7ba44756aa8ef5bfca675e8424e6043ce6d609b9 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 05:10:16 -0600
Subject: [PATCH 0074/1059] c-b: Clean up unused imports

These are remnants of historical chkstk implementations that are no
longer relevant, so clean up the imports here.
---
 library/compiler-builtins/compiler-builtins/src/aarch64.rs | 4 ----
 library/compiler-builtins/compiler-builtins/src/x86.rs     | 4 ----
 library/compiler-builtins/compiler-builtins/src/x86_64.rs  | 4 ----
 3 files changed, 12 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64.rs b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
index 1b230a214eef..2c12cb7f3095 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
@@ -1,7 +1,3 @@
-#![allow(unused_imports)]
-
-use core::intrinsics;
-
 intrinsics! {
     #[unsafe(naked)]
     #[cfg(any(all(windows, target_env = "gnu"), target_os = "uefi"))]
diff --git a/library/compiler-builtins/compiler-builtins/src/x86.rs b/library/compiler-builtins/compiler-builtins/src/x86.rs
index 1a3c41860945..45f4ba207e6e 100644
--- a/library/compiler-builtins/compiler-builtins/src/x86.rs
+++ b/library/compiler-builtins/compiler-builtins/src/x86.rs
@@ -1,7 +1,3 @@
-#![allow(unused_imports)]
-
-use core::intrinsics;
-
 // NOTE These functions are implemented using assembly because they use a custom
 // calling convention which can't be implemented using a normal Rust function
 
diff --git a/library/compiler-builtins/compiler-builtins/src/x86_64.rs b/library/compiler-builtins/compiler-builtins/src/x86_64.rs
index 99a527ee9ac5..a3a5c8f7e10f 100644
--- a/library/compiler-builtins/compiler-builtins/src/x86_64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/x86_64.rs
@@ -1,7 +1,3 @@
-#![allow(unused_imports)]
-
-use core::intrinsics;
-
 // NOTE These functions are implemented using assembly because they use a custom
 // calling convention which can't be implemented using a normal Rust function
 

From c5e7c934061869ecc494bc8a3557a0f3e34558c2 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 05:53:06 -0600
Subject: [PATCH 0075/1059] c-b: Remove `#![feature(naked_functions)]`

This feature has been stable for a while.
---
 library/compiler-builtins/compiler-builtins/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/lib.rs b/library/compiler-builtins/compiler-builtins/src/lib.rs
index a027cd978af2..07960222f20f 100644
--- a/library/compiler-builtins/compiler-builtins/src/lib.rs
+++ b/library/compiler-builtins/compiler-builtins/src/lib.rs
@@ -7,7 +7,6 @@
 #![feature(compiler_builtins)]
 #![feature(core_intrinsics)]
 #![feature(linkage)]
-#![feature(naked_functions)]
 #![feature(repr_simd)]
 #![feature(macro_metavar_expr_concat)]
 #![feature(rustc_attrs)]

From 2b76199bfb822e356d9faff67e43f5769ef31beb Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 05:57:14 -0600
Subject: [PATCH 0076/1059] c-b: Remove unused features in tests

---
 library/compiler-builtins/builtins-test-intrinsics/src/main.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/compiler-builtins/builtins-test-intrinsics/src/main.rs b/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
index b9d19ea77256..848f00de44d1 100644
--- a/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
+++ b/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
@@ -3,10 +3,8 @@
 // compiling a C implementation and forget to implement that intrinsic in Rust, this file will fail
 // to link due to the missing intrinsic (symbol).
 
-#![allow(unused_features)]
 #![allow(internal_features)]
 #![deny(dead_code)]
-#![feature(allocator_api)]
 #![feature(f128)]
 #![feature(f16)]
 #![feature(lang_items)]

From 8b9bbbccef2da23cb195a3d2d783f886002611ac Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 04:37:49 -0600
Subject: [PATCH 0077/1059] c-b: Replace `core::intrinsics::{cold_path,
 likely}`

Replace the use of intrinsics with `core::hint::cold_path` which has
been unstably available for a while, and is on track to become stable in
the next release.
---
 .../compiler-builtins/src/mem/impls.rs              | 13 +++++++++----
 .../compiler-builtins/libm/src/math/support/mod.rs  |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/mem/impls.rs b/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
index da16dee25ce5..9681f5d6dac6 100644
--- a/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
+++ b/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
@@ -16,7 +16,8 @@
 // crate doing wrapping pointer arithmetic with a method that must not wrap won't be the problem if
 // something does go wrong at runtime.
 use core::ffi::c_int;
-use core::intrinsics::likely;
+
+use crate::support::cold_path;
 
 const WORD_SIZE: usize = core::mem::size_of::<usize>();
 const WORD_MASK: usize = WORD_SIZE - 1;
@@ -209,9 +210,10 @@ unsafe fn copy_forward_misaligned_words(dest: *mut u8, src: *const u8, n: usize)
 
         let n_words = n & !WORD_MASK;
         let src_misalignment = src as usize & WORD_MASK;
-        if likely(src_misalignment == 0) {
+        if src_misalignment == 0 {
             copy_forward_aligned_words(dest, src, n_words);
         } else {
+            cold_path();
             copy_forward_misaligned_words(dest, src, n_words);
         }
         dest = dest.wrapping_add(n_words);
@@ -327,9 +329,10 @@ unsafe fn copy_backward_misaligned_words(dest: *mut u8, src: *const u8, n: usize
 
         let n_words = n & !WORD_MASK;
         let src_misalignment = src as usize & WORD_MASK;
-        if likely(src_misalignment == 0) {
+        if src_misalignment == 0 {
             copy_backward_aligned_words(dest, src, n_words);
         } else {
+            cold_path();
             copy_backward_misaligned_words(dest, src, n_words);
         }
         dest = dest.wrapping_sub(n_words);
@@ -368,7 +371,7 @@ pub unsafe fn set_bytes_words(s: *mut u8, c: u8, n: usize) {
         }
     }
 
-    if likely(n >= WORD_COPY_THRESHOLD) {
+    if n >= WORD_COPY_THRESHOLD {
         // Align s
         // Because of n >= 2 * WORD_SIZE, dst_misalignment < n
         let misalignment = (s as usize).wrapping_neg() & WORD_MASK;
@@ -380,6 +383,8 @@ pub unsafe fn set_bytes_words(s: *mut u8, c: u8, n: usize) {
         set_bytes_words(s, c, n_words);
         s = s.wrapping_add(n_words);
         n -= n_words;
+    } else {
+        cold_path();
     }
     set_bytes_bytes(s, c, n);
 }
diff --git a/library/compiler-builtins/libm/src/math/support/mod.rs b/library/compiler-builtins/libm/src/math/support/mod.rs
index 15ab010dc8d5..128ba36e7f01 100644
--- a/library/compiler-builtins/libm/src/math/support/mod.rs
+++ b/library/compiler-builtins/libm/src/math/support/mod.rs
@@ -35,5 +35,5 @@
 /// Hint to the compiler that the current path is cold.
 pub fn cold_path() {
     #[cfg(intrinsics_enabled)]
-    core::intrinsics::cold_path();
+    core::hint::cold_path();
 }

From b4ec29c9939909ae4ed0157ab8bfa2eb9f099b7a Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 12 Feb 2026 05:10:16 -0600
Subject: [PATCH 0078/1059] libm: Replace `div!` with `unchecked_div_*`

`div!` looks innocuous but is actually unsafe. Replace it with function
calls that require us to actually use `unsafe`, and add the precondition
notes. These can likely be removed completely in the near future.

There is one case in `rem_pio2_large` and one in `exp2` where
preconditions aren't as easy to define, but fortunately it seems like we
are able to just use regular division there without affecting codegen.
---
 .../compiler-builtins/libm/src/math/exp2.rs   |  2 +-
 .../libm/src/math/lgamma_r.rs                 |  4 ++-
 .../libm/src/math/lgammaf_r.rs                |  4 ++-
 .../compiler-builtins/libm/src/math/mod.rs    | 18 ----------
 .../libm/src/math/rem_pio2_large.rs           |  2 +-
 .../libm/src/math/support/mod.rs              | 33 +++++++++++++++++++
 .../compiler-builtins/libm/src/math/tgamma.rs |  4 ++-
 7 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/exp2.rs b/library/compiler-builtins/libm/src/math/exp2.rs
index 08b71587f6de..d4c9e9665200 100644
--- a/library/compiler-builtins/libm/src/math/exp2.rs
+++ b/library/compiler-builtins/libm/src/math/exp2.rs
@@ -380,7 +380,7 @@ pub fn exp2(mut x: f64) -> f64 {
     let mut i0 = ui as u32;
     i0 = i0.wrapping_add(TBLSIZE as u32 / 2);
     let ku = i0 / TBLSIZE as u32 * TBLSIZE as u32;
-    let ki = div!(ku as i32, TBLSIZE as i32);
+    let ki = (ku as i32) / TBLSIZE as i32;
     i0 %= TBLSIZE as u32;
     let uf = f64::from_bits(ui) - redux;
     let mut z = x - uf;
diff --git a/library/compiler-builtins/libm/src/math/lgamma_r.rs b/library/compiler-builtins/libm/src/math/lgamma_r.rs
index 38eb270f6839..f3c6fef1464d 100644
--- a/library/compiler-builtins/libm/src/math/lgamma_r.rs
+++ b/library/compiler-builtins/libm/src/math/lgamma_r.rs
@@ -79,6 +79,7 @@
  */
 
 use super::{floor, k_cos, k_sin, log};
+use crate::support::unchecked_div_i32;
 
 const PI: f64 = 3.14159265358979311600e+00; /* 0x400921FB, 0x54442D18 */
 const A0: f64 = 7.72156649015328655494e-02; /* 0x3FB3C467, 0xE37DB0C8 */
@@ -152,7 +153,8 @@ fn sin_pi(mut x: f64) -> f64 {
     x = 2.0 * (x * 0.5 - floor(x * 0.5)); /* x mod 2.0 */
 
     n = (x * 4.0) as i32;
-    n = div!(n + 1, 2);
+    // SAFETY: nonzero divisor, nonnegative dividend (`n < 8`).
+    n = unsafe { unchecked_div_i32(n + 1, 2) };
     x -= (n as f64) * 0.5;
     x *= PI;
 
diff --git a/library/compiler-builtins/libm/src/math/lgammaf_r.rs b/library/compiler-builtins/libm/src/math/lgammaf_r.rs
index a0b6a678a670..5c087f14d7df 100644
--- a/library/compiler-builtins/libm/src/math/lgammaf_r.rs
+++ b/library/compiler-builtins/libm/src/math/lgammaf_r.rs
@@ -14,6 +14,7 @@
  */
 
 use super::{floorf, k_cosf, k_sinf, logf};
+use crate::support::unchecked_div_isize;
 
 const PI: f32 = 3.1415927410e+00; /* 0x40490fdb */
 const A0: f32 = 7.7215664089e-02; /* 0x3d9e233f */
@@ -88,7 +89,8 @@ fn sin_pi(mut x: f32) -> f32 {
     x = 2.0 * (x * 0.5 - floorf(x * 0.5)); /* x mod 2.0 */
 
     n = (x * 4.0) as isize;
-    n = div!(n + 1, 2);
+    // SAFETY: nonzero divisor, nonnegative dividend (`n < 8`).
+    n = unsafe { unchecked_div_isize(n + 1, 2) };
     y = (x as f64) - (n as f64) * 0.5;
     y *= 3.14159265358979323846;
     match n {
diff --git a/library/compiler-builtins/libm/src/math/mod.rs b/library/compiler-builtins/libm/src/math/mod.rs
index b34ab8465349..4bee4478164a 100644
--- a/library/compiler-builtins/libm/src/math/mod.rs
+++ b/library/compiler-builtins/libm/src/math/mod.rs
@@ -58,24 +58,6 @@ macro_rules! i {
     };
 }
 
-// Temporary macro to avoid panic codegen for division (in debug mode too). At
-// the time of this writing this is only used in a few places, and once
-// rust-lang/rust#72751 is fixed then this macro will no longer be necessary and
-// the native `/` operator can be used and panics won't be codegen'd.
-#[cfg(any(debug_assertions, not(intrinsics_enabled)))]
-macro_rules! div {
-    ($a:expr, $b:expr) => {
-        $a / $b
-    };
-}
-
-#[cfg(all(not(debug_assertions), intrinsics_enabled))]
-macro_rules! div {
-    ($a:expr, $b:expr) => {
-        unsafe { core::intrinsics::unchecked_div($a, $b) }
-    };
-}
-
 // `support` may be public for testing
 #[macro_use]
 #[cfg(feature = "unstable-public-internals")]
diff --git a/library/compiler-builtins/libm/src/math/rem_pio2_large.rs b/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
index bb2c532916b2..5065ca496b22 100644
--- a/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
+++ b/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
@@ -255,7 +255,7 @@ extern "C" fn floor(x: f64) -> f64 {
 
     /* determine jx,jv,q0, note that 3>q0 */
     let jx = nx - 1;
-    let mut jv = div!(e0 - 3, 24);
+    let mut jv = (e0 - 3) / 24;
     if jv < 0 {
         jv = 0;
     }
diff --git a/library/compiler-builtins/libm/src/math/support/mod.rs b/library/compiler-builtins/libm/src/math/support/mod.rs
index 128ba36e7f01..9dc872cdc150 100644
--- a/library/compiler-builtins/libm/src/math/support/mod.rs
+++ b/library/compiler-builtins/libm/src/math/support/mod.rs
@@ -37,3 +37,36 @@ pub fn cold_path() {
     #[cfg(intrinsics_enabled)]
     core::hint::cold_path();
 }
+
+/// # Safety
+///
+/// `y` must not be zero and the result must not overflow (`x > i32::MIN`).
+pub unsafe fn unchecked_div_i32(x: i32, y: i32) -> i32 {
+    cfg_if! {
+        if #[cfg(all(not(debug_assertions), intrinsics_enabled))] {
+            // Temporary macro to avoid panic codegen for division (in debug mode too). At
+            // the time of this writing this is only used in a few places, and once
+            // rust-lang/rust#72751 is fixed then this macro will no longer be necessary and
+            // the native `/` operator can be used and panics won't be codegen'd.
+            //
+            // Note: I am not sure whether the above comment is still up to date, we need
+            // to double check whether panics are elided where we use this.
+            unsafe { core::intrinsics::unchecked_div(x, y) }
+        } else {
+            x / y
+        }
+    }
+}
+
+/// # Safety
+///
+/// `y` must not be zero and the result must not overflow (`x > isize::MIN`).
+pub unsafe fn unchecked_div_isize(x: isize, y: isize) -> isize {
+    cfg_if! {
+        if #[cfg(all(not(debug_assertions), intrinsics_enabled))] {
+            unsafe { core::intrinsics::unchecked_div(x, y) }
+        } else {
+            x / y
+        }
+    }
+}
diff --git a/library/compiler-builtins/libm/src/math/tgamma.rs b/library/compiler-builtins/libm/src/math/tgamma.rs
index 41415d9d1258..c526842470c8 100644
--- a/library/compiler-builtins/libm/src/math/tgamma.rs
+++ b/library/compiler-builtins/libm/src/math/tgamma.rs
@@ -23,6 +23,7 @@
 most ideas and constants are from boost and python
 */
 use super::{exp, floor, k_cos, k_sin, pow};
+use crate::support::unchecked_div_isize;
 
 const PI: f64 = 3.141592653589793238462643383279502884;
 
@@ -37,7 +38,8 @@ fn sinpi(mut x: f64) -> f64 {
 
     /* reduce x into [-.25,.25] */
     n = (4.0 * x) as isize;
-    n = div!(n + 1, 2);
+    // SAFETY: nonzero divisor, nonnegative dividend (`n < 8`).
+    n = unsafe { unchecked_div_isize(n + 1, 2) };
     x -= (n as f64) * 0.5;
 
     x *= PI;

From 71d656edde5b2e588a129951beef1c5c7dbe35e7 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 14 Feb 2026 17:41:51 +0300
Subject: [PATCH 0079/1059] LinkedGraph: Use IndexVec instead of Vec in
 LinkedGraph nodes

---
 .../src/graph/linked_graph/mod.rs             | 35 ++++++++++++-------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
index ecb0095626b4..6d53b155e9a2 100644
--- a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
@@ -23,6 +23,7 @@
 use std::fmt::Debug;
 
 use rustc_index::bit_set::DenseBitSet;
+use rustc_index::{Idx, IndexSlice, IndexVec};
 use tracing::debug;
 
 #[cfg(test)]
@@ -45,7 +46,7 @@
 /// and does not implement those traits, so it has its own implementations of a
 /// few basic graph algorithms.
 pub struct LinkedGraph<N, E> {
-    nodes: Vec<Node<N>>,
+    nodes: IndexVec<NodeIndex, Node<N>>,
     edges: Vec<Edge<E>>,
 }
 
@@ -62,7 +63,7 @@ pub struct Edge<E> {
     pub data: E,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct NodeIndex(pub usize);
 
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -87,19 +88,29 @@ pub fn node_id(self) -> usize {
     }
 }
 
+impl Idx for NodeIndex {
+    fn new(idx: usize) -> NodeIndex {
+        NodeIndex(idx)
+    }
+
+    fn index(self) -> usize {
+        self.0
+    }
+}
+
 impl<N: Debug, E: Debug> LinkedGraph<N, E> {
     pub fn new() -> Self {
-        Self { nodes: Vec::new(), edges: Vec::new() }
+        Self { nodes: IndexVec::new(), edges: Vec::new() }
     }
 
     pub fn with_capacity(nodes: usize, edges: usize) -> Self {
-        Self { nodes: Vec::with_capacity(nodes), edges: Vec::with_capacity(edges) }
+        Self { nodes: IndexVec::with_capacity(nodes), edges: Vec::with_capacity(edges) }
     }
 
     // # Simple accessors
 
     #[inline]
-    pub fn all_nodes(&self) -> &[Node<N>] {
+    pub fn all_nodes(&self) -> &IndexSlice<NodeIndex, Node<N>> {
         &self.nodes
     }
 
@@ -131,15 +142,15 @@ pub fn add_node(&mut self, data: N) -> NodeIndex {
     }
 
     pub fn mut_node_data(&mut self, idx: NodeIndex) -> &mut N {
-        &mut self.nodes[idx.0].data
+        &mut self.nodes[idx].data
     }
 
     pub fn node_data(&self, idx: NodeIndex) -> &N {
-        &self.nodes[idx.0].data
+        &self.nodes[idx].data
     }
 
     pub fn node(&self, idx: NodeIndex) -> &Node<N> {
-        &self.nodes[idx.0]
+        &self.nodes[idx]
     }
 
     // # Edge construction and queries
@@ -154,16 +165,16 @@ pub fn add_edge(&mut self, source: NodeIndex, target: NodeIndex, data: E) -> Edg
         let idx = self.next_edge_index();
 
         // read current first of the list of edges from each node
-        let source_first = self.nodes[source.0].first_edge[OUTGOING.repr];
-        let target_first = self.nodes[target.0].first_edge[INCOMING.repr];
+        let source_first = self.nodes[source].first_edge[OUTGOING.repr];
+        let target_first = self.nodes[target].first_edge[INCOMING.repr];
 
         // create the new edge, with the previous firsts from each node
         // as the next pointers
         self.edges.push(Edge { next_edge: [source_first, target_first], source, target, data });
 
         // adjust the firsts for each node target be the next object.
-        self.nodes[source.0].first_edge[OUTGOING.repr] = idx;
-        self.nodes[target.0].first_edge[INCOMING.repr] = idx;
+        self.nodes[source].first_edge[OUTGOING.repr] = idx;
+        self.nodes[target].first_edge[INCOMING.repr] = idx;
 
         idx
     }

From 96697d41ed0c2d70dc4bb64cb4e660da1b82150d Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 14 Feb 2026 17:53:00 +0300
Subject: [PATCH 0080/1059] LinkedGraph: support adding nodes and edges in
 arbitrary order

If an edge uses some not-yet-known node, we just leave the node's data empty, that data can be added later.

Use this support to avoid skipping edges in DepGraphQuery
---
 .../src/graph/linked_graph/mod.rs             | 24 ++++++++++++++-----
 .../src/graph/linked_graph/tests.rs           |  2 +-
 .../rustc_middle/src/dep_graph/retained.rs    | 17 ++++---------
 3 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
index 6d53b155e9a2..2223e85a2495 100644
--- a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
@@ -52,7 +52,7 @@ pub struct LinkedGraph<N, E> {
 
 pub struct Node<N> {
     first_edge: [EdgeIndex; 2], // see module comment
-    pub data: N,
+    pub data: Option<N>,
 }
 
 #[derive(Debug)]
@@ -135,18 +135,30 @@ pub fn next_node_index(&self) -> NodeIndex {
         NodeIndex(self.nodes.len())
     }
 
+    fn ensure_node(&mut self, idx: NodeIndex) -> &mut Node<N> {
+        self.nodes.ensure_contains_elem(idx, || Node {
+            first_edge: [INVALID_EDGE_INDEX, INVALID_EDGE_INDEX],
+            data: None,
+        })
+    }
+
+    pub fn add_node_with_idx(&mut self, idx: NodeIndex, data: N) {
+        let old_data = self.ensure_node(idx).data.replace(data);
+        debug_assert!(old_data.is_none());
+    }
+
     pub fn add_node(&mut self, data: N) -> NodeIndex {
         let idx = self.next_node_index();
-        self.nodes.push(Node { first_edge: [INVALID_EDGE_INDEX, INVALID_EDGE_INDEX], data });
+        self.add_node_with_idx(idx, data);
         idx
     }
 
     pub fn mut_node_data(&mut self, idx: NodeIndex) -> &mut N {
-        &mut self.nodes[idx].data
+        self.nodes[idx].data.as_mut().unwrap()
     }
 
     pub fn node_data(&self, idx: NodeIndex) -> &N {
-        &self.nodes[idx].data
+        self.nodes[idx].data.as_ref().unwrap()
     }
 
     pub fn node(&self, idx: NodeIndex) -> &Node<N> {
@@ -165,8 +177,8 @@ pub fn add_edge(&mut self, source: NodeIndex, target: NodeIndex, data: E) -> Edg
         let idx = self.next_edge_index();
 
         // read current first of the list of edges from each node
-        let source_first = self.nodes[source].first_edge[OUTGOING.repr];
-        let target_first = self.nodes[target].first_edge[INCOMING.repr];
+        let source_first = self.ensure_node(source).first_edge[OUTGOING.repr];
+        let target_first = self.ensure_node(target).first_edge[INCOMING.repr];
 
         // create the new edge, with the previous firsts from each node
         // as the next pointers
diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs b/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs
index 357aa81a57ca..da416cd638d4 100644
--- a/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs
+++ b/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs
@@ -40,7 +40,7 @@ fn each_node() {
     let expected = ["A", "B", "C", "D", "E", "F"];
     graph.each_node(|idx, node| {
         assert_eq!(&expected[idx.0], graph.node_data(idx));
-        assert_eq!(expected[idx.0], node.data);
+        assert_eq!(expected[idx.0], node.data.unwrap());
         true
     });
 }
diff --git a/compiler/rustc_middle/src/dep_graph/retained.rs b/compiler/rustc_middle/src/dep_graph/retained.rs
index 4427982e3708..626b3b782179 100644
--- a/compiler/rustc_middle/src/dep_graph/retained.rs
+++ b/compiler/rustc_middle/src/dep_graph/retained.rs
@@ -1,6 +1,5 @@
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::graph::linked_graph::{Direction, INCOMING, LinkedGraph, NodeIndex};
-use rustc_index::IndexVec;
 
 use super::{DepNode, DepNodeIndex};
 
@@ -13,7 +12,6 @@
 pub struct RetainedDepGraph {
     pub inner: LinkedGraph<DepNode, ()>,
     pub indices: FxHashMap<DepNode, NodeIndex>,
-    pub dep_index_to_index: IndexVec<DepNodeIndex, Option<NodeIndex>>,
 }
 
 impl RetainedDepGraph {
@@ -23,27 +21,22 @@ pub fn new(prev_node_count: usize) -> Self {
 
         let inner = LinkedGraph::with_capacity(node_count, edge_count);
         let indices = FxHashMap::default();
-        let dep_index_to_index = IndexVec::new();
 
-        Self { inner, indices, dep_index_to_index }
+        Self { inner, indices }
     }
 
     pub fn push(&mut self, index: DepNodeIndex, node: DepNode, edges: &[DepNodeIndex]) {
-        let source = self.inner.add_node(node);
-        self.dep_index_to_index.insert(index, source);
+        let source = NodeIndex(index.as_usize());
+        self.inner.add_node_with_idx(source, node);
         self.indices.insert(node, source);
 
         for &target in edges.iter() {
-            // We may miss the edges that are pushed while the `DepGraphQuery` is being accessed.
-            // Skip them to issues.
-            if let Some(&Some(target)) = self.dep_index_to_index.get(target) {
-                self.inner.add_edge(source, target, ());
-            }
+            self.inner.add_edge(source, NodeIndex(target.as_usize()), ());
         }
     }
 
     pub fn nodes(&self) -> Vec<&DepNode> {
-        self.inner.all_nodes().iter().map(|n| &n.data).collect()
+        self.inner.all_nodes().iter().map(|n| n.data.as_ref().unwrap()).collect()
     }
 
     pub fn edges(&self) -> Vec<(&DepNode, &DepNode)> {

From 6b1ee2c7018e97189c06a1734937da0bf1dd32a8 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 7 Feb 2026 20:42:31 +0100
Subject: [PATCH 0081/1059] Stabilize `cfg_select`

---
 patches/0027-sysroot_tests-128bit-atomic-operations.patch | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/patches/0027-sysroot_tests-128bit-atomic-operations.patch b/patches/0027-sysroot_tests-128bit-atomic-operations.patch
index 6ed0b17f679c..7ba4475e3145 100644
--- a/patches/0027-sysroot_tests-128bit-atomic-operations.patch
+++ b/patches/0027-sysroot_tests-128bit-atomic-operations.patch
@@ -17,8 +17,8 @@ index 1e336bf..35e6f54 100644
 @@ -2,4 +2,3 @@
  // tidy-alphabetical-start
 -#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
- #![cfg_attr(test, feature(cfg_select))]
  #![feature(array_ptr_get)]
+ #![feature(array_try_from_fn)]
 diff --git a/coretests/tests/atomic.rs b/coretests/tests/atomic.rs
 index b735957..ea728b6 100644
 --- a/coretests/tests/atomic.rs

From 9b2b57085d8e2c2707028ef8a82c2c51b235d2c0 Mon Sep 17 00:00:00 2001
From: linshuy2 <linshuy2@illinois.edu>
Date: Thu, 12 Feb 2026 23:10:44 +0000
Subject: [PATCH 0082/1059] fix: `unnecessary_safety_comment` FP on code blocks
 inside inner docs

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  4 +++-
 tests/ui/unnecessary_safety_comment.rs         | 10 ++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1b26b1b32b80..c56a1fc8c510 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -822,7 +822,9 @@ fn text_has_safety_comment(
             // Don't lint if the safety comment is part of a codeblock in a doc comment.
             // It may or may not be required, and we can't very easily check it (and we shouldn't, since
             // the safety comment isn't referring to the node we're currently checking)
-            if line.trim_start_matches("///").trim_start().starts_with("```") {
+            if let Some(doc) = line.strip_prefix("///").or_else(|| line.strip_prefix("//!"))
+                && doc.trim_start().starts_with("```")
+            {
                 in_codeblock = !in_codeblock;
             }
 
diff --git a/tests/ui/unnecessary_safety_comment.rs b/tests/ui/unnecessary_safety_comment.rs
index d82a7b969080..75e8315343d3 100644
--- a/tests/ui/unnecessary_safety_comment.rs
+++ b/tests/ui/unnecessary_safety_comment.rs
@@ -100,3 +100,13 @@ pub fn point_to_five() -> *const u8 {
 }
 
 fn main() {}
+
+mod issue16553 {
+    //! ```
+    //! // SAFETY: All is well.
+    //! unsafe {
+    //!    foo()
+    //! }
+    //! ```
+    mod blah {}
+}

From fa99d5b72b7d45fc6875141f85d2b1db5d28423b Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 23 Feb 2026 18:49:55 +0100
Subject: [PATCH 0083/1059] core: respect precision in `ByteStr` `Display`

---
 library/core/src/bstr/mod.rs    | 110 ++++++++++++++++++++++----------
 library/coretests/tests/bstr.rs |  15 +++++
 2 files changed, 91 insertions(+), 34 deletions(-)

diff --git a/library/core/src/bstr/mod.rs b/library/core/src/bstr/mod.rs
index 2be7dfc9bfdd..9d623d3af8b5 100644
--- a/library/core/src/bstr/mod.rs
+++ b/library/core/src/bstr/mod.rs
@@ -6,7 +6,7 @@
 pub use traits::{impl_partial_eq, impl_partial_eq_n, impl_partial_eq_ord};
 
 use crate::borrow::{Borrow, BorrowMut};
-use crate::fmt;
+use crate::fmt::{self, Alignment};
 use crate::ops::{Deref, DerefMut, DerefPure};
 
 /// A wrapper for `&[u8]` representing a human-readable string that's conventionally, but not
@@ -174,43 +174,85 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 #[unstable(feature = "bstr", issue = "134915")]
 impl fmt::Display for ByteStr {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let nchars: usize = self
-            .utf8_chunks()
-            .map(|chunk| {
-                chunk.valid().chars().count() + if chunk.invalid().is_empty() { 0 } else { 1 }
-            })
-            .sum();
-
-        let padding = f.width().unwrap_or(0).saturating_sub(nchars);
-        let fill = f.fill();
-
-        let (lpad, rpad) = match f.align() {
-            Some(fmt::Alignment::Right) => (padding, 0),
-            Some(fmt::Alignment::Center) => {
-                let half = padding / 2;
-                (half, half + padding % 2)
+        fn emit(byte_str: &ByteStr, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            for chunk in byte_str.utf8_chunks() {
+                f.write_str(chunk.valid())?;
+                if !chunk.invalid().is_empty() {
+                    f.write_str("\u{FFFD}")?;
+                }
+            }
+
+            Ok(())
+        }
+
+        let requested_width = f.width().unwrap_or(0);
+        if requested_width == 0 && f.precision().is_none() {
+            // Avoid counting the characters if no truncation or padding was
+            // requested.
+            return emit(self, f);
+        }
+
+        let (truncated, actual_width) = match f.precision() {
+            // The entire string is truncated away. Weird, but ok.
+            Some(0) => (ByteStr::new(&[]), 0),
+            // Advance through string until we run out of space.
+            Some(precision) => {
+                let mut remaining_width = precision;
+                let mut chunks = self.utf8_chunks();
+                let mut current_width = 0;
+                let mut offset = 0;
+                loop {
+                    let Some(chunk) = chunks.next() else {
+                        // We reached the end of the string without running out
+                        // of space, so print the entire string.
+                        break (self, current_width);
+                    };
+
+                    let mut chars = chunk.valid().char_indices();
+                    let Err(remaining) = chars.advance_by(remaining_width) else {
+                        // We've counted off `precision` characters, so truncate
+                        // the string at the current offset.
+                        break (&self[..offset + chars.offset()], precision);
+                    };
+
+                    offset += chunk.valid().len();
+                    current_width += remaining_width - remaining.get();
+                    remaining_width = remaining.get();
+
+                    // `remaining_width` cannot be zero, there is still space
+                    // remaining. So next, count the � character emitted for
+                    // the invalid chunk (if it exists).
+                    if !chunk.invalid().is_empty() {
+                        offset += chunk.invalid().len();
+                        current_width += 1;
+                        remaining_width -= 1;
+
+                        if remaining_width == 0 {
+                            break (&self[..offset], precision);
+                        }
+                    }
+                }
+            }
+            // The string shouldn't be truncated at all, so just count the number
+            // of characters to calculate the padding.
+            None => {
+                let actual_width = self
+                    .utf8_chunks()
+                    .map(|chunk| {
+                        chunk.valid().chars().count()
+                            + if chunk.invalid().is_empty() { 0 } else { 1 }
+                    })
+                    .sum();
+                (self, actual_width)
             }
-            // Either alignment is not specified or it's left aligned
-            // which behaves the same with padding
-            _ => (0, padding),
         };
 
-        for _ in 0..lpad {
-            write!(f, "{fill}")?;
-        }
+        // The width is originally stored as a 16-bit number, so this cannot fail.
+        let padding = u16::try_from(requested_width.saturating_sub(actual_width)).unwrap();
 
-        for chunk in self.utf8_chunks() {
-            f.write_str(chunk.valid())?;
-            if !chunk.invalid().is_empty() {
-                f.write_str("\u{FFFD}")?;
-            }
-        }
-
-        for _ in 0..rpad {
-            write!(f, "{fill}")?;
-        }
-
-        Ok(())
+        let post_padding = f.padding(padding, Alignment::Left)?;
+        emit(truncated, f)?;
+        post_padding.write(f)
     }
 }
 
diff --git a/library/coretests/tests/bstr.rs b/library/coretests/tests/bstr.rs
index cd4d69d6b337..dffc7e3f0349 100644
--- a/library/coretests/tests/bstr.rs
+++ b/library/coretests/tests/bstr.rs
@@ -49,4 +49,19 @@ fn test_display() {
     assert_eq!(&format!("{b2:->3}!"), "�(��!");
     assert_eq!(&format!("{b2:-^3}!"), "�(��!");
     assert_eq!(&format!("{b2:-^2}!"), "�(��!");
+
+    assert_eq!(&format!("{b1:.1}!"), &format!("{:.1}!", "abc"));
+    assert_eq!(&format!("{b1:.2}!"), &format!("{:.2}!", "abc"));
+    assert_eq!(&format!("{b1:.3}!"), &format!("{:.3}!", "abc"));
+    assert_eq!(&format!("{b1:-<5.2}!"), &format!("{:-<5.2}!", "abc"));
+    assert_eq!(&format!("{b1:-^5.2}!"), &format!("{:-^5.2}!", "abc"));
+    assert_eq!(&format!("{b1:->5.2}!"), &format!("{:->5.2}!", "abc"));
+
+    assert_eq!(&format!("{b2:.1}!"), "�!");
+    assert_eq!(&format!("{b2:.2}!"), "�(!");
+    assert_eq!(&format!("{b2:.3}!"), "�(�!");
+    assert_eq!(&format!("{b2:.4}!"), "�(��!");
+    assert_eq!(&format!("{b2:-<6.3}!"), "�(�---!");
+    assert_eq!(&format!("{b2:-^6.3}!"), "-�(�--!");
+    assert_eq!(&format!("{b2:->6.3}!"), "---�(�!");
 }

From 3282e2cb9c8c16f6d22d90a6af2515b592b2c692 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 24 Feb 2026 16:08:32 +0000
Subject: [PATCH 0084/1059] Rustup to rustc 1.95.0-nightly (b3869b94c
 2026-02-23)

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 62e07412a7f8..85b1cf4d6117 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-02-20"
+channel = "nightly-2026-02-24"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 890434af218987d48f092524490c9a25ff910eeb Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 24 Feb 2026 16:13:56 +0000
Subject: [PATCH 0085/1059] Fix rustc test suite

---
 scripts/test_rustc_tests.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/scripts/test_rustc_tests.sh b/scripts/test_rustc_tests.sh
index 798bef7ba3e3..6dc981531be3 100755
--- a/scripts/test_rustc_tests.sh
+++ b/scripts/test_rustc_tests.sh
@@ -151,7 +151,6 @@ rm -r tests/run-make/short-ice # ICE backtrace begin/end marker mismatch
 rm -r tests/run-make/remap-path-prefix-dwarf # requires llvm-dwarfdump
 rm -r tests/run-make/strip # same
 rm -r tests/run-make-cargo/compiler-builtins # Expects lib/rustlib/src/rust to contains the standard library source
-rm -r tests/run-make/translation # same
 rm -r tests/run-make-cargo/panic-immediate-abort-works # same
 rm -r tests/run-make-cargo/panic-immediate-abort-codegen # same
 rm -r tests/run-make/missing-unstable-trait-bound # This disables support for unstable features, but running cg_clif needs some unstable features

From 06b0bd21d74db05eaffd33aacdb7f67bedef5f45 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 24 Feb 2026 17:43:06 +0000
Subject: [PATCH 0086/1059] stop marking `deref_patterns` as an incomplete
 feature

---
 compiler/rustc_feature/src/unstable.rs         |  2 +-
 .../src/language-features/deref-patterns.md    |  6 +-----
 .../building/match/deref-patterns/string.rs    |  1 -
 tests/ui/pattern/deref-patterns/basic.rs       |  1 -
 tests/ui/pattern/deref-patterns/bindings.rs    |  1 -
 tests/ui/pattern/deref-patterns/branch.rs      |  1 -
 .../deref-patterns/byte-string-type-errors.rs  |  1 -
 .../byte-string-type-errors.stderr             | 18 +++++++++---------
 .../deref-patterns/cant_move_out_of_pattern.rs |  1 -
 .../cant_move_out_of_pattern.stderr            |  8 ++++----
 .../pattern/deref-patterns/closure_capture.rs  |  1 -
 .../const-pats-do-not-mislead-inference.rs     |  1 -
 ...pats-do-not-mislead-inference.stable.stderr |  8 ++++----
 .../ui/pattern/deref-patterns/default-infer.rs |  1 -
 tests/ui/pattern/deref-patterns/deref-box.rs   |  1 -
 ...ont-ice-on-slice-in-deref-pat-in-closure.rs |  1 -
 .../ui/pattern/deref-patterns/fake_borrows.rs  |  1 -
 .../pattern/deref-patterns/fake_borrows.stderr |  8 ++++----
 ...adjust-mode-unimplemented-for-constblock.rs |  1 -
 ...st-mode-unimplemented-for-constblock.stderr |  8 ++++----
 .../deref-patterns/implicit-const-deref.rs     |  1 -
 .../deref-patterns/implicit-const-deref.stderr |  2 +-
 .../deref-patterns/implicit-cow-deref.rs       |  1 -
 .../pattern/deref-patterns/recursion-limit.rs  |  1 -
 .../deref-patterns/recursion-limit.stderr      |  6 +++---
 tests/ui/pattern/deref-patterns/ref-mut.rs     |  1 -
 tests/ui/pattern/deref-patterns/ref-mut.stderr | 15 +++------------
 tests/ui/pattern/deref-patterns/refs.rs        |  1 -
 tests/ui/pattern/deref-patterns/strings.rs     |  1 -
 tests/ui/pattern/deref-patterns/typeck.rs      |  1 -
 tests/ui/pattern/deref-patterns/typeck_fail.rs |  1 -
 .../pattern/deref-patterns/typeck_fail.stderr  |  2 +-
 .../deref-patterns/unsatisfied-bounds.rs       |  1 -
 .../deref-patterns/unsatisfied-bounds.stderr   |  4 ++--
 .../deref-patterns/usefulness/empty-types.rs   |  1 -
 .../usefulness/empty-types.stderr              |  4 ++--
 .../usefulness/mixed-constructors.rs           |  1 -
 .../usefulness/mixed-constructors.stderr       | 10 +++++-----
 .../usefulness/non-exhaustive.rs               |  1 -
 .../usefulness/non-exhaustive.stderr           |  8 ++++----
 .../usefulness/unreachable-patterns.rs         |  1 -
 .../usefulness/unreachable-patterns.stderr     | 14 +++++++-------
 42 files changed, 55 insertions(+), 94 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 1d123385961a..d8afc8c794b6 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -451,7 +451,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows having using `suggestion` in the `#[deprecated]` attribute.
     (unstable, deprecated_suggestion, "1.61.0", Some(94785)),
     /// Allows deref patterns.
-    (incomplete, deref_patterns, "1.79.0", Some(87121)),
+    (unstable, deref_patterns, "1.79.0", Some(87121)),
     /// Allows deriving the From trait on single-field structs.
     (unstable, derive_from, "1.91.0", Some(144889)),
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
diff --git a/src/doc/unstable-book/src/language-features/deref-patterns.md b/src/doc/unstable-book/src/language-features/deref-patterns.md
index 23c2dc688400..a0c9a7e30277 100644
--- a/src/doc/unstable-book/src/language-features/deref-patterns.md
+++ b/src/doc/unstable-book/src/language-features/deref-patterns.md
@@ -6,8 +6,7 @@ The tracking issue for this feature is: [#87121]
 
 ------------------------
 
-> **Note**: This feature is incomplete. In the future, it is meant to supersede
-> [`box_patterns`].
+> **Note**: This feature supersedes [`box_patterns`].
 
 This feature permits pattern matching on [smart pointers in the standard library] through their
 `Deref` target types, either implicitly or with explicit `deref!(_)` patterns (the syntax of which
@@ -15,7 +14,6 @@ is currently a placeholder).
 
 ```rust
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 let mut v = vec![Box::new(Some(0))];
 
@@ -58,7 +56,6 @@ Like [`box_patterns`], deref patterns may move out of boxes:
 
 ```rust
 # #![feature(deref_patterns)]
-# #![allow(incomplete_features)]
 struct NoCopy;
 let deref!(x) = Box::new(NoCopy);
 drop::<NoCopy>(x);
@@ -69,7 +66,6 @@ allowing then to be used in deref patterns:
 
 ```rust
 # #![feature(deref_patterns)]
-# #![allow(incomplete_features)]
 match ("test".to_string(), Box::from("test"), b"test".to_vec()) {
     ("test", "test", b"test") => {}
     _ => panic!(),
diff --git a/tests/mir-opt/building/match/deref-patterns/string.rs b/tests/mir-opt/building/match/deref-patterns/string.rs
index 1f8d6fbb0bd2..92232c7df79d 100644
--- a/tests/mir-opt/building/match/deref-patterns/string.rs
+++ b/tests/mir-opt/building/match/deref-patterns/string.rs
@@ -2,7 +2,6 @@
 //@ compile-flags: -Z mir-opt-level=0 -C panic=abort
 
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 #![crate_type = "lib"]
 
 // EMIT_MIR string.foo.PreCodegen.after.mir
diff --git a/tests/ui/pattern/deref-patterns/basic.rs b/tests/ui/pattern/deref-patterns/basic.rs
index dee4521e1f95..0cb80b43944d 100644
--- a/tests/ui/pattern/deref-patterns/basic.rs
+++ b/tests/ui/pattern/deref-patterns/basic.rs
@@ -1,7 +1,6 @@
 //@ run-pass
 //@ check-run-results
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn main() {
     test(Some(String::from("42")));
diff --git a/tests/ui/pattern/deref-patterns/bindings.rs b/tests/ui/pattern/deref-patterns/bindings.rs
index 92c01d737bac..c3165ebf6cef 100644
--- a/tests/ui/pattern/deref-patterns/bindings.rs
+++ b/tests/ui/pattern/deref-patterns/bindings.rs
@@ -1,7 +1,6 @@
 //@ revisions: explicit implicit
 //@ run-pass
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/pattern/deref-patterns/branch.rs b/tests/ui/pattern/deref-patterns/branch.rs
index 9d72b35fd2f1..5b87742eb319 100644
--- a/tests/ui/pattern/deref-patterns/branch.rs
+++ b/tests/ui/pattern/deref-patterns/branch.rs
@@ -2,7 +2,6 @@
 //@ run-pass
 // Test the execution of deref patterns.
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 #[cfg(explicit)]
 fn branch(vec: Vec<u32>) -> u32 {
diff --git a/tests/ui/pattern/deref-patterns/byte-string-type-errors.rs b/tests/ui/pattern/deref-patterns/byte-string-type-errors.rs
index fdcc6cb46111..633044a59772 100644
--- a/tests/ui/pattern/deref-patterns/byte-string-type-errors.rs
+++ b/tests/ui/pattern/deref-patterns/byte-string-type-errors.rs
@@ -5,7 +5,6 @@
 //@ dont-require-annotations: NOTE
 
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn main() {
     // Baseline 1: under normal circumstances, byte string literal patterns have type `&[u8; N]`,
diff --git a/tests/ui/pattern/deref-patterns/byte-string-type-errors.stderr b/tests/ui/pattern/deref-patterns/byte-string-type-errors.stderr
index 046682004be7..531d5ba292c4 100644
--- a/tests/ui/pattern/deref-patterns/byte-string-type-errors.stderr
+++ b/tests/ui/pattern/deref-patterns/byte-string-type-errors.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:13:12
+  --> $DIR/byte-string-type-errors.rs:12:12
    |
 LL |     if let b"test" = () {}
    |            ^^^^^^^   -- this expression has type `()`
@@ -7,7 +7,7 @@ LL |     if let b"test" = () {}
    |            expected `()`, found `&[u8; 4]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:20:12
+  --> $DIR/byte-string-type-errors.rs:19:12
    |
 LL |     if let b"test" = &[] as &[i8] {}
    |            ^^^^^^^   ------------ this expression has type `&[i8]`
@@ -18,7 +18,7 @@ LL |     if let b"test" = &[] as &[i8] {}
               found reference `&'static [u8]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:25:12
+  --> $DIR/byte-string-type-errors.rs:24:12
    |
 LL |     if let b"test" = *(&[] as &[i8]) {}
    |            ^^^^^^^   --------------- this expression has type `[i8]`
@@ -29,7 +29,7 @@ LL |     if let b"test" = *(&[] as &[i8]) {}
               found slice `[u8]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:30:12
+  --> $DIR/byte-string-type-errors.rs:29:12
    |
 LL |     if let b"test" = [()] {}
    |            ^^^^^^^   ---- this expression has type `[(); 1]`
@@ -40,7 +40,7 @@ LL |     if let b"test" = [()] {}
               found array `[u8; 4]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:33:12
+  --> $DIR/byte-string-type-errors.rs:32:12
    |
 LL |     if let b"test" = *b"this array is too long" {}
    |            ^^^^^^^   -------------------------- this expression has type `[u8; 22]`
@@ -48,7 +48,7 @@ LL |     if let b"test" = *b"this array is too long" {}
    |            expected an array with a size of 22, found one with a size of 4
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:39:12
+  --> $DIR/byte-string-type-errors.rs:38:12
    |
 LL |     if let b"test" = &mut () {}
    |            ^^^^^^^   ------- this expression has type `&mut ()`
@@ -56,7 +56,7 @@ LL |     if let b"test" = &mut () {}
    |            expected `()`, found `&[u8; 4]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:44:12
+  --> $DIR/byte-string-type-errors.rs:43:12
    |
 LL |     if let b"test" = &mut [] as &mut [i8] {}
    |            ^^^^^^^   -------------------- this expression has type `&mut [i8]`
@@ -67,7 +67,7 @@ LL |     if let b"test" = &mut [] as &mut [i8] {}
               found slice `[u8]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:48:12
+  --> $DIR/byte-string-type-errors.rs:47:12
    |
 LL |     if let b"test" = &mut [()] {}
    |            ^^^^^^^   --------- this expression has type `&mut [(); 1]`
@@ -78,7 +78,7 @@ LL |     if let b"test" = &mut [()] {}
               found array `[u8; 4]`
 
 error[E0308]: mismatched types
-  --> $DIR/byte-string-type-errors.rs:52:12
+  --> $DIR/byte-string-type-errors.rs:51:12
    |
 LL |     if let b"test" = &mut *b"this array is too long" {}
    |            ^^^^^^^   ------------------------------- this expression has type `&mut [u8; 22]`
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
index 2b4746e33e67..36d9ae70efdd 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
index a548ac5909a8..532dd496b235 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
@@ -1,5 +1,5 @@
 error[E0508]: cannot move out of type `[Struct]`, a non-copy slice
-  --> $DIR/cant_move_out_of_pattern.rs:9:11
+  --> $DIR/cant_move_out_of_pattern.rs:8:11
    |
 LL |     match b {
    |           ^ cannot move out of here
@@ -16,7 +16,7 @@ LL |         deref!([ref x]) => x,
    |                 +++
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/cant_move_out_of_pattern.rs:17:11
+  --> $DIR/cant_move_out_of_pattern.rs:16:11
    |
 LL |     match rc {
    |           ^^
@@ -33,7 +33,7 @@ LL |         deref!(ref x) => x,
    |                +++
 
 error[E0508]: cannot move out of type `[Struct]`, a non-copy slice
-  --> $DIR/cant_move_out_of_pattern.rs:25:11
+  --> $DIR/cant_move_out_of_pattern.rs:24:11
    |
 LL |     match b {
    |           ^ cannot move out of here
@@ -50,7 +50,7 @@ LL |         [ref x] => x,
    |          +++
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/cant_move_out_of_pattern.rs:35:11
+  --> $DIR/cant_move_out_of_pattern.rs:34:11
    |
 LL |     match rc {
    |           ^^
diff --git a/tests/ui/pattern/deref-patterns/closure_capture.rs b/tests/ui/pattern/deref-patterns/closure_capture.rs
index 497ec622b0cf..c02c82e9ea0c 100644
--- a/tests/ui/pattern/deref-patterns/closure_capture.rs
+++ b/tests/ui/pattern/deref-patterns/closure_capture.rs
@@ -1,6 +1,5 @@
 //@ run-pass
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.rs b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.rs
index 3a2531f4b95e..08dec4885846 100644
--- a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.rs
+++ b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.rs
@@ -8,7 +8,6 @@
 //! we'd get without `deref_patterns` enabled.
 
 #![cfg_attr(deref_patterns, feature(deref_patterns))]
-#![cfg_attr(deref_patterns, expect(incomplete_features))]
 
 fn uninferred<T>() -> T { unimplemented!() }
 
diff --git a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
index 61079718c5d5..0770569e0406 100644
--- a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
+++ b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/const-pats-do-not-mislead-inference.rs:33:12
+  --> $DIR/const-pats-do-not-mislead-inference.rs:32:12
    |
 LL |     if let b"..." = &&x {}
    |            ^^^^^^   --- this expression has type `&&_`
@@ -10,7 +10,7 @@ LL |     if let b"..." = &&x {}
               found reference `&'static [u8; 3]`
 
 error[E0308]: mismatched types
-  --> $DIR/const-pats-do-not-mislead-inference.rs:39:12
+  --> $DIR/const-pats-do-not-mislead-inference.rs:38:12
    |
 LL |     if let "..." = &Box::new(x) {}
    |            ^^^^^   ------------ this expression has type `&Box<_>`
@@ -25,7 +25,7 @@ LL |     if let "..." = &*Box::new(x) {}
    |                     +
 
 error[E0308]: mismatched types
-  --> $DIR/const-pats-do-not-mislead-inference.rs:45:12
+  --> $DIR/const-pats-do-not-mislead-inference.rs:44:12
    |
 LL |     if let b"..." = Box::new(&x) {}
    |            ^^^^^^   ------------ this expression has type `Box<&_>`
@@ -40,7 +40,7 @@ LL |     if let b"..." = *Box::new(&x) {}
    |                     +
 
 error[E0308]: mismatched types
-  --> $DIR/const-pats-do-not-mislead-inference.rs:51:12
+  --> $DIR/const-pats-do-not-mislead-inference.rs:50:12
    |
 LL |     if let "..." = &mut x {}
    |            ^^^^^   ------ this expression has type `&mut _`
diff --git a/tests/ui/pattern/deref-patterns/default-infer.rs b/tests/ui/pattern/deref-patterns/default-infer.rs
index fb0b2add132a..38c8793a9b44 100644
--- a/tests/ui/pattern/deref-patterns/default-infer.rs
+++ b/tests/ui/pattern/deref-patterns/default-infer.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn main() {
     match <_ as Default>::default() {
diff --git a/tests/ui/pattern/deref-patterns/deref-box.rs b/tests/ui/pattern/deref-patterns/deref-box.rs
index 39b23dcab51e..1af13f82f3f9 100644
--- a/tests/ui/pattern/deref-patterns/deref-box.rs
+++ b/tests/ui/pattern/deref-patterns/deref-box.rs
@@ -3,7 +3,6 @@
 //! and `DerefMut::deref_mut`. Test that they work as expected.
 
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn unbox_1<T>(b: Box<T>) -> T {
     let deref!(x) = b;
diff --git a/tests/ui/pattern/deref-patterns/dont-ice-on-slice-in-deref-pat-in-closure.rs b/tests/ui/pattern/deref-patterns/dont-ice-on-slice-in-deref-pat-in-closure.rs
index e1a37b9c65f4..e656ef9a4380 100644
--- a/tests/ui/pattern/deref-patterns/dont-ice-on-slice-in-deref-pat-in-closure.rs
+++ b/tests/ui/pattern/deref-patterns/dont-ice-on-slice-in-deref-pat-in-closure.rs
@@ -3,7 +3,6 @@
 //! inside a deref pattern inside a closure: rust-lang/rust#125059
 
 #![feature(deref_patterns)]
-#![allow(incomplete_features, unused)]
 
 fn simple_vec(vec: Vec<u32>) -> u32 {
    (|| match Vec::<u32>::new() {
diff --git a/tests/ui/pattern/deref-patterns/fake_borrows.rs b/tests/ui/pattern/deref-patterns/fake_borrows.rs
index fba2873fd02a..74292fe25d8c 100644
--- a/tests/ui/pattern/deref-patterns/fake_borrows.rs
+++ b/tests/ui/pattern/deref-patterns/fake_borrows.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 #[rustfmt::skip]
 fn main() {
diff --git a/tests/ui/pattern/deref-patterns/fake_borrows.stderr b/tests/ui/pattern/deref-patterns/fake_borrows.stderr
index 7dc3001739e6..312de4760a45 100644
--- a/tests/ui/pattern/deref-patterns/fake_borrows.stderr
+++ b/tests/ui/pattern/deref-patterns/fake_borrows.stderr
@@ -1,5 +1,5 @@
 error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
-  --> $DIR/fake_borrows.rs:9:16
+  --> $DIR/fake_borrows.rs:8:16
    |
 LL |     match v {
    |           - immutable borrow occurs here
@@ -10,7 +10,7 @@ LL |         _ if { v[0] = true; false } => {}
    |                mutable borrow occurs here
 
 error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
-  --> $DIR/fake_borrows.rs:16:16
+  --> $DIR/fake_borrows.rs:15:16
    |
 LL |     match v {
    |           - immutable borrow occurs here
@@ -21,7 +21,7 @@ LL |         _ if { v[0] = true; false } => {}
    |                mutable borrow occurs here
 
 error[E0510]: cannot assign `*b` in match guard
-  --> $DIR/fake_borrows.rs:26:16
+  --> $DIR/fake_borrows.rs:25:16
    |
 LL |     match b {
    |           - value is immutable in match guard
@@ -30,7 +30,7 @@ LL |         _ if { *b = true; false } => {}
    |                ^^^^^^^^^ cannot assign
 
 error[E0510]: cannot assign `*b` in match guard
-  --> $DIR/fake_borrows.rs:33:16
+  --> $DIR/fake_borrows.rs:32:16
    |
 LL |     match b {
    |           - value is immutable in match guard
diff --git a/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.rs b/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.rs
index fbc742aa8477..b775cb3ac756 100644
--- a/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.rs
+++ b/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn main() {
     let vec![const { vec![] }]: Vec<usize> = vec![];
diff --git a/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.stderr b/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.stderr
index 48728acbc291..d18ca2589bbc 100644
--- a/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.stderr
+++ b/tests/ui/pattern/deref-patterns/ice-adjust-mode-unimplemented-for-constblock.stderr
@@ -1,5 +1,5 @@
 error[E0532]: expected a pattern, found a function call
-  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:5:9
+  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:4:9
    |
 LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    |         ^^^^^^^^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
@@ -7,7 +7,7 @@ LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    = note: function calls are not allowed in patterns: <https://doc.rust-lang.org/book/ch19-00-patterns.html>
 
 error[E0532]: expected a pattern, found a function call
-  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:5:9
+  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:4:9
    |
 LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    |         ^^^^^^^^^^^^^^^^^^^^^^ not a tuple struct or tuple variant
@@ -15,7 +15,7 @@ LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    = note: function calls are not allowed in patterns: <https://doc.rust-lang.org/book/ch19-00-patterns.html>
 
 error: arbitrary expressions aren't allowed in patterns
-  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:5:14
+  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:4:14
    |
 LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    |              ^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    = help: use a named `const`-item or an `if`-guard (`x if x == const { ... }`) instead
 
 error[E0164]: expected tuple struct or tuple variant, found associated function `::alloc::boxed::Box::new_uninit`
-  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:5:9
+  --> $DIR/ice-adjust-mode-unimplemented-for-constblock.rs:4:9
    |
 LL |     let vec![const { vec![] }]: Vec<usize> = vec![];
    |         ^^^^^^^^^^^^^^^^^^^^^^ `fn` calls are not allowed in patterns
diff --git a/tests/ui/pattern/deref-patterns/implicit-const-deref.rs b/tests/ui/pattern/deref-patterns/implicit-const-deref.rs
index 70f89629bc22..4aa5695c7399 100644
--- a/tests/ui/pattern/deref-patterns/implicit-const-deref.rs
+++ b/tests/ui/pattern/deref-patterns/implicit-const-deref.rs
@@ -4,7 +4,6 @@
 //! scrutinee and end up with a type error; this would prevent us from reporting that only constants
 //! supporting structural equality can be used as patterns.
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 const EMPTY: Vec<()> = Vec::new();
 
diff --git a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
index 6d4301846287..a75542ffd4ad 100644
--- a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
+++ b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
@@ -1,5 +1,5 @@
 error: constant of non-structural type `Vec<()>` in a pattern
-  --> $DIR/implicit-const-deref.rs:15:9
+  --> $DIR/implicit-const-deref.rs:14:9
    |
 LL | const EMPTY: Vec<()> = Vec::new();
    | -------------------- constant defined here
diff --git a/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs b/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
index 24770261edc5..107ae12f3b74 100644
--- a/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
+++ b/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
@@ -1,7 +1,6 @@
 //@ run-pass
 //! Test that implicit deref patterns interact as expected with `Cow` constructor patterns.
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 use std::borrow::Cow;
 use std::rc::Rc;
diff --git a/tests/ui/pattern/deref-patterns/recursion-limit.rs b/tests/ui/pattern/deref-patterns/recursion-limit.rs
index c5fe520f6f1a..75c64cb1f539 100644
--- a/tests/ui/pattern/deref-patterns/recursion-limit.rs
+++ b/tests/ui/pattern/deref-patterns/recursion-limit.rs
@@ -1,6 +1,5 @@
 //! Test that implicit deref patterns respect the recursion limit
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 #![recursion_limit = "8"]
 
 use std::ops::Deref;
diff --git a/tests/ui/pattern/deref-patterns/recursion-limit.stderr b/tests/ui/pattern/deref-patterns/recursion-limit.stderr
index 7c140e4493e7..e7f6a272432e 100644
--- a/tests/ui/pattern/deref-patterns/recursion-limit.stderr
+++ b/tests/ui/pattern/deref-patterns/recursion-limit.stderr
@@ -1,5 +1,5 @@
 error[E0055]: reached the recursion limit while auto-dereferencing `Cyclic`
-  --> $DIR/recursion-limit.rs:18:9
+  --> $DIR/recursion-limit.rs:17:9
    |
 LL |         () => {}
    |         ^^ deref recursion limit reached
@@ -7,13 +7,13 @@ LL |         () => {}
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "16"]` attribute to your crate (`recursion_limit`)
 
 error[E0277]: the trait bound `Cyclic: DerefPure` is not satisfied
-  --> $DIR/recursion-limit.rs:18:9
+  --> $DIR/recursion-limit.rs:17:9
    |
 LL |         () => {}
    |         ^^ unsatisfied trait bound
    |
 help: the nightly-only, unstable trait `DerefPure` is not implemented for `Cyclic`
-  --> $DIR/recursion-limit.rs:8:1
+  --> $DIR/recursion-limit.rs:7:1
    |
 LL | struct Cyclic;
    | ^^^^^^^^^^^^^
diff --git a/tests/ui/pattern/deref-patterns/ref-mut.rs b/tests/ui/pattern/deref-patterns/ref-mut.rs
index 43738671346d..7751a13565e8 100644
--- a/tests/ui/pattern/deref-patterns/ref-mut.rs
+++ b/tests/ui/pattern/deref-patterns/ref-mut.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-//~^ WARN the feature `deref_patterns` is incomplete
 
 use std::rc::Rc;
 
diff --git a/tests/ui/pattern/deref-patterns/ref-mut.stderr b/tests/ui/pattern/deref-patterns/ref-mut.stderr
index 24a35b418e95..1359410de827 100644
--- a/tests/ui/pattern/deref-patterns/ref-mut.stderr
+++ b/tests/ui/pattern/deref-patterns/ref-mut.stderr
@@ -1,14 +1,5 @@
-warning: the feature `deref_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/ref-mut.rs:1:12
-   |
-LL | #![feature(deref_patterns)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #87121 <https://github.com/rust-lang/rust/issues/87121> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `Rc<{integer}>: DerefMut` is not satisfied
-  --> $DIR/ref-mut.rs:17:9
+  --> $DIR/ref-mut.rs:16:9
    |
 LL |         deref!(x) => {}
    |         ^^^^^^^^^ the trait `DerefMut` is not implemented for `Rc<{integer}>`
@@ -16,11 +7,11 @@ LL |         deref!(x) => {}
    = note: this error originates in the macro `deref` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: the trait bound `Rc<({integer},)>: DerefMut` is not satisfied
-  --> $DIR/ref-mut.rs:22:9
+  --> $DIR/ref-mut.rs:21:9
    |
 LL |         (x,) => {}
    |         ^^^^ the trait `DerefMut` is not implemented for `Rc<({integer},)>`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/pattern/deref-patterns/refs.rs b/tests/ui/pattern/deref-patterns/refs.rs
index 51826225856b..13566510e7a5 100644
--- a/tests/ui/pattern/deref-patterns/refs.rs
+++ b/tests/ui/pattern/deref-patterns/refs.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 
 fn foo(s: &String) -> i32 {
     match *s {
diff --git a/tests/ui/pattern/deref-patterns/strings.rs b/tests/ui/pattern/deref-patterns/strings.rs
index fac15a9aee3d..5b6cfb9425d6 100644
--- a/tests/ui/pattern/deref-patterns/strings.rs
+++ b/tests/ui/pattern/deref-patterns/strings.rs
@@ -2,7 +2,6 @@
 //! Test deref patterns using string and bytestring literals.
 
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 fn main() {
     for (test_in, test_expect) in [("zero", 0), ("one", 1), ("two", 2)] {
diff --git a/tests/ui/pattern/deref-patterns/typeck.rs b/tests/ui/pattern/deref-patterns/typeck.rs
index 3a7ce9d1deb3..a1a055d5f0e7 100644
--- a/tests/ui/pattern/deref-patterns/typeck.rs
+++ b/tests/ui/pattern/deref-patterns/typeck.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/pattern/deref-patterns/typeck_fail.rs b/tests/ui/pattern/deref-patterns/typeck_fail.rs
index 6ae87bb7bc36..14ddb670e57f 100644
--- a/tests/ui/pattern/deref-patterns/typeck_fail.rs
+++ b/tests/ui/pattern/deref-patterns/typeck_fail.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 fn main() {
     // Make sure we don't try implicitly dereferncing any ADT.
diff --git a/tests/ui/pattern/deref-patterns/typeck_fail.stderr b/tests/ui/pattern/deref-patterns/typeck_fail.stderr
index fc29caac5630..6e81e9f6a064 100644
--- a/tests/ui/pattern/deref-patterns/typeck_fail.stderr
+++ b/tests/ui/pattern/deref-patterns/typeck_fail.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:7:9
+  --> $DIR/typeck_fail.rs:6:9
    |
 LL |     match Some(0) {
    |           ------- this expression has type `Option<{integer}>`
diff --git a/tests/ui/pattern/deref-patterns/unsatisfied-bounds.rs b/tests/ui/pattern/deref-patterns/unsatisfied-bounds.rs
index 9e95f4ec4096..db76e6fb7f94 100644
--- a/tests/ui/pattern/deref-patterns/unsatisfied-bounds.rs
+++ b/tests/ui/pattern/deref-patterns/unsatisfied-bounds.rs
@@ -1,5 +1,4 @@
 #![feature(deref_patterns)]
-#![allow(incomplete_features)]
 
 struct MyPointer;
 
diff --git a/tests/ui/pattern/deref-patterns/unsatisfied-bounds.stderr b/tests/ui/pattern/deref-patterns/unsatisfied-bounds.stderr
index 3ee6efefe697..3b680b4238a0 100644
--- a/tests/ui/pattern/deref-patterns/unsatisfied-bounds.stderr
+++ b/tests/ui/pattern/deref-patterns/unsatisfied-bounds.stderr
@@ -1,11 +1,11 @@
 error[E0277]: the trait bound `MyPointer: DerefPure` is not satisfied
-  --> $DIR/unsatisfied-bounds.rs:17:9
+  --> $DIR/unsatisfied-bounds.rs:16:9
    |
 LL |         () => {}
    |         ^^ unsatisfied trait bound
    |
 help: the nightly-only, unstable trait `DerefPure` is not implemented for `MyPointer`
-  --> $DIR/unsatisfied-bounds.rs:4:1
+  --> $DIR/unsatisfied-bounds.rs:3:1
    |
 LL | struct MyPointer;
    | ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/pattern/deref-patterns/usefulness/empty-types.rs b/tests/ui/pattern/deref-patterns/usefulness/empty-types.rs
index 03419030e72f..17de65380169 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/empty-types.rs
+++ b/tests/ui/pattern/deref-patterns/usefulness/empty-types.rs
@@ -4,7 +4,6 @@
 // FIXME(deref_patterns): On stabilization, cases for deref patterns could be worked into that file
 // to keep the tests for empty types in one place and test more thoroughly.
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 #![deny(unreachable_patterns)]
 
 enum Void {}
diff --git a/tests/ui/pattern/deref-patterns/usefulness/empty-types.stderr b/tests/ui/pattern/deref-patterns/usefulness/empty-types.stderr
index e32477085661..4eb49b54b83b 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/empty-types.stderr
+++ b/tests/ui/pattern/deref-patterns/usefulness/empty-types.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: `deref!(Some(_))` not covered
-  --> $DIR/empty-types.rs:21:11
+  --> $DIR/empty-types.rs:20:11
    |
 LL |     match box_opt_void {
    |           ^^^^^^^^^^^^ pattern `deref!(Some(_))` not covered
@@ -15,7 +15,7 @@ LL +         deref!(Some(_)) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:35:11
+  --> $DIR/empty-types.rs:34:11
    |
 LL |     match *box_opt_void {
    |           ^^^^^^^^^^^^^ pattern `Some(_)` not covered
diff --git a/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.rs b/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.rs
index f567dc07bb59..8858f628217c 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.rs
+++ b/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.rs
@@ -2,7 +2,6 @@
 //! doesn't support this, so make sure we catch it beforehand. As a consequence, it takes priority
 //! over non-exhaustive match and unreachable pattern errors.
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 #![deny(unreachable_patterns)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.stderr b/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.stderr
index 5ad24164b985..3d036afc9e90 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.stderr
+++ b/tests/ui/pattern/deref-patterns/usefulness/mixed-constructors.stderr
@@ -1,5 +1,5 @@
 error: mix of deref patterns and normal constructors
-  --> $DIR/mixed-constructors.rs:16:9
+  --> $DIR/mixed-constructors.rs:15:9
    |
 LL |         false => {}
    |         ^^^^^ matches on the result of dereferencing `Cow<'_, bool>`
@@ -7,7 +7,7 @@ LL |         Cow::Borrowed(_) => {}
    |         ^^^^^^^^^^^^^^^^ matches directly on `Cow<'_, bool>`
 
 error: mix of deref patterns and normal constructors
-  --> $DIR/mixed-constructors.rs:22:9
+  --> $DIR/mixed-constructors.rs:21:9
    |
 LL |         Cow::Borrowed(_) => {}
    |         ^^^^^^^^^^^^^^^^ matches directly on `Cow<'_, bool>`
@@ -15,7 +15,7 @@ LL |         true => {}
    |         ^^^^ matches on the result of dereferencing `Cow<'_, bool>`
 
 error: mix of deref patterns and normal constructors
-  --> $DIR/mixed-constructors.rs:29:9
+  --> $DIR/mixed-constructors.rs:28:9
    |
 LL |         Cow::Owned(_) => {}
    |         ^^^^^^^^^^^^^ matches directly on `Cow<'_, bool>`
@@ -23,7 +23,7 @@ LL |         false => {}
    |         ^^^^^ matches on the result of dereferencing `Cow<'_, bool>`
 
 error: mix of deref patterns and normal constructors
-  --> $DIR/mixed-constructors.rs:36:10
+  --> $DIR/mixed-constructors.rs:35:10
    |
 LL |         (Cow::Borrowed(_), 0) => {}
    |          ^^^^^^^^^^^^^^^^ matches directly on `Cow<'_, bool>`
@@ -31,7 +31,7 @@ LL |         (true, 0) => {}
    |          ^^^^ matches on the result of dereferencing `Cow<'_, bool>`
 
 error: mix of deref patterns and normal constructors
-  --> $DIR/mixed-constructors.rs:43:13
+  --> $DIR/mixed-constructors.rs:42:13
    |
 LL |         (0, Cow::Borrowed(_)) => {}
    |             ^^^^^^^^^^^^^^^^ matches directly on `Cow<'_, bool>`
diff --git a/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.rs b/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.rs
index bab6308223e5..64f5f14f199a 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.rs
+++ b/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.rs
@@ -1,6 +1,5 @@
 //! Test non-exhaustive matches involving deref patterns.
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 #![deny(unreachable_patterns)]
 
 fn main() {
diff --git a/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.stderr b/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.stderr
index a1abd5f0e3f4..75c8b1864c78 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.stderr
+++ b/tests/ui/pattern/deref-patterns/usefulness/non-exhaustive.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: `deref!(true)` not covered
-  --> $DIR/non-exhaustive.rs:7:11
+  --> $DIR/non-exhaustive.rs:6:11
    |
 LL |     match Box::new(false) {
    |           ^^^^^^^^^^^^^^^ pattern `deref!(true)` not covered
@@ -14,7 +14,7 @@ LL +         deref!(true) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `deref!(deref!(false))` not covered
-  --> $DIR/non-exhaustive.rs:12:11
+  --> $DIR/non-exhaustive.rs:11:11
    |
 LL |     match Box::new(Box::new(false)) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `deref!(deref!(false))` not covered
@@ -29,7 +29,7 @@ LL +         deref!(deref!(false)) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `deref!((true, deref!(true)))` and `deref!((false, deref!(false)))` not covered
-  --> $DIR/non-exhaustive.rs:17:11
+  --> $DIR/non-exhaustive.rs:16:11
    |
 LL |     match Box::new((true, Box::new(false))) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ patterns `deref!((true, deref!(true)))` and `deref!((false, deref!(false)))` not covered
@@ -44,7 +44,7 @@ LL +         deref!((true, deref!(true))) | deref!((false, deref!(false))) => to
    |
 
 error[E0004]: non-exhaustive patterns: `deref!((deref!(T::C), _))` not covered
-  --> $DIR/non-exhaustive.rs:24:11
+  --> $DIR/non-exhaustive.rs:23:11
    |
 LL |     match Box::new((Box::new(T::A), Box::new(T::A))) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pattern `deref!((deref!(T::C), _))` not covered
diff --git a/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.rs b/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.rs
index 2677fc54dedc..5559ee8f5566 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.rs
+++ b/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.rs
@@ -1,6 +1,5 @@
 //! Test unreachable patterns involving deref patterns.
 #![feature(deref_patterns)]
-#![expect(incomplete_features)]
 #![deny(unreachable_patterns)]
 
 fn main() {
diff --git a/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.stderr b/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.stderr
index 045e11be3196..88ac7b2351a7 100644
--- a/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.stderr
+++ b/tests/ui/pattern/deref-patterns/usefulness/unreachable-patterns.stderr
@@ -1,5 +1,5 @@
 error: unreachable pattern
-  --> $DIR/unreachable-patterns.rs:10:9
+  --> $DIR/unreachable-patterns.rs:9:9
    |
 LL |         false => {}
    |         ----- matches all the relevant values
@@ -7,13 +7,13 @@ LL |         false => {}
    |         ^^^^^ no value can reach this
    |
 note: the lint level is defined here
-  --> $DIR/unreachable-patterns.rs:4:9
+  --> $DIR/unreachable-patterns.rs:3:9
    |
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/unreachable-patterns.rs:16:9
+  --> $DIR/unreachable-patterns.rs:15:9
    |
 LL |         true => {}
    |         ---- matches all the relevant values
@@ -22,13 +22,13 @@ LL |         true => {}
    |         ^^^^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/unreachable-patterns.rs:23:9
+  --> $DIR/unreachable-patterns.rs:22:9
    |
 LL |         _ => {}
    |         ^ no value can reach this
    |
 note: multiple earlier patterns match some of the same values
-  --> $DIR/unreachable-patterns.rs:23:9
+  --> $DIR/unreachable-patterns.rs:22:9
    |
 LL |         (true, _) => {}
    |         --------- matches some of the same values
@@ -40,7 +40,7 @@ LL |         _ => {}
    |         ^ collectively making this unreachable
 
 error: unreachable pattern
-  --> $DIR/unreachable-patterns.rs:29:9
+  --> $DIR/unreachable-patterns.rs:28:9
    |
 LL |         (T::A | T::B, T::A | T::C) => {}
    |         -------------------------- matches all the relevant values
@@ -48,7 +48,7 @@ LL |         (T::A, T::C) => {}
    |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/unreachable-patterns.rs:30:9
+  --> $DIR/unreachable-patterns.rs:29:9
    |
 LL |         (T::A | T::B, T::A | T::C) => {}
    |         -------------------------- matches all the relevant values

From 29df68bb1243a0d90217b4cd9cfb84673f34046a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 24 Feb 2026 20:41:24 +0100
Subject: [PATCH 0087/1059] Remove one DOM level for lint additional info

---
 util/gh-pages/index_template.html | 8 ++------
 util/gh-pages/style.css           | 6 +++---
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/util/gh-pages/index_template.html b/util/gh-pages/index_template.html
index 91a5c1263195..dd9e9b837640 100644
--- a/util/gh-pages/index_template.html
+++ b/util/gh-pages/index_template.html
@@ -203,15 +203,11 @@ Otherwise, have a great day =^.^=
                             <span class="label label-default label-version">{{lint.version}}</span> {# #}
                         </div>
                         {# Open related issues #}
-                        <div> {# #}
-                            <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a> {# #}
-                        </div>
+                        <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
 
                         {# Jump to source #}
                         {% if let Some(id_location) = lint.id_location %}
-                            <div> {# #}
-                                <a href="https://github.com/rust-lang/rust-clippy/blob/master/{{id_location}}">View Source</a> {# #}
-                            </div>
+                            <a href="https://github.com/rust-lang/rust-clippy/blob/master/{{id_location}}">View Source</a>
                         {% endif %}
                     </div> {# #}
                 </div> {# #}
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index ce478a3e18d0..59868ddce847 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -459,7 +459,7 @@ article:hover .panel-title-name .anchor { display: inline;}
         display: flex;
         flex-flow: column;
     }
-    .lint-additional-info > div + div {
+    .lint-additional-info > * + * {
         border-top: 1px solid var(--theme-popup-border);
     }
 }
@@ -468,12 +468,12 @@ article:hover .panel-title-name .anchor { display: inline;}
         display: flex;
         flex-flow: row;
     }
-    .lint-additional-info > div + div {
+    .lint-additional-info > * + * {
         border-left: 1px solid var(--theme-popup-border);
     }
 }
 
-.lint-additional-info > div {
+.lint-additional-info > * {
     display: inline-flex;
     min-width: 200px;
     flex-grow: 1;

From 0a22189ba132980e36dda24eee99d3bae064e919 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 24 Feb 2026 20:46:05 +0100
Subject: [PATCH 0088/1059] Remove unused `label-default` CSS class

---
 util/gh-pages/index_template.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/util/gh-pages/index_template.html b/util/gh-pages/index_template.html
index dd9e9b837640..35254fcfab79 100644
--- a/util/gh-pages/index_template.html
+++ b/util/gh-pages/index_template.html
@@ -194,13 +194,13 @@ Otherwise, have a great day =^.^=
                         {# Applicability #}
                         <div> {# #}
                             Applicability: {#+ #}
-                            <span class="label label-default applicability">{{ lint.applicability_str() }}</span> {# #}
+                            <span class="label applicability">{{ lint.applicability_str() }}</span> {# #}
                             <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/enum.Applicability.html#variants">(?)</a> {# #}
                         </div>
                         {# Clippy version #}
                         <div> {# #}
                             {% if lint.group == "deprecated" %}Deprecated{% else %} Added{% endif +%} in: {#+ #}
-                            <span class="label label-default label-version">{{lint.version}}</span> {# #}
+                            <span class="label label-version">{{lint.version}}</span> {# #}
                         </div>
                         {# Open related issues #}
                         <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>

From db18ecf2637f9994ad2508144bcf4f018ac46315 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Wed, 25 Feb 2026 06:17:53 +0530
Subject: [PATCH 0089/1059] Require avxvnni for avx10.2

---
 compiler/rustc_target/src/target_features.rs |  6 +-
 library/std_detect/src/detect/os/x86.rs      | 68 +++++++++++---------
 2 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index c3de7e257662..aa272ebd4b77 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -392,7 +392,11 @@ pub fn toggle_allowed(&self) -> Result<(), &'static str> {
             "avx512vpopcntdq",
         ],
     ),
-    ("avx10.2", Unstable(sym::avx10_target_feature), &["avx10.1"]),
+    (
+        "avx10.2",
+        Unstable(sym::avx10_target_feature),
+        &["avx10.1", "avxvnni", "avxvnniint8", "avxvnniint16"],
+    ),
     ("avx512bf16", Stable, &["avx512bw"]),
     ("avx512bitalg", Stable, &["avx512bw"]),
     ("avx512bw", Stable, &["avx512f"]),
diff --git a/library/std_detect/src/detect/os/x86.rs b/library/std_detect/src/detect/os/x86.rs
index f2205ba07dd4..b24ef6a37ef5 100644
--- a/library/std_detect/src/detect/os/x86.rs
+++ b/library/std_detect/src/detect/os/x86.rs
@@ -202,6 +202,28 @@ pub(crate) fn detect_features() -> cache::Initializer {
                 // Test `XCR0.APX[19]` with the mask `0b1000_0000_0000_0000_0000 == 0x80000`
                 let os_apx_support = xcr0 & 0x80000 == 0x80000;
 
+                if os_amx_support {
+                    enable(extended_features_edx, 24, Feature::amx_tile);
+                    enable(extended_features_edx, 25, Feature::amx_int8);
+                    enable(extended_features_edx, 22, Feature::amx_bf16);
+                    enable(extended_features_eax_leaf_1, 21, Feature::amx_fp16);
+                    enable(extended_features_edx_leaf_1, 8, Feature::amx_complex);
+
+                    if max_basic_leaf >= 0x1e {
+                        let CpuidResult { eax: amx_feature_flags_eax, .. } =
+                            __cpuid_count(0x1e_u32, 1);
+
+                        enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
+                        enable(amx_feature_flags_eax, 6, Feature::amx_tf32);
+                        enable(amx_feature_flags_eax, 7, Feature::amx_avx512);
+                        enable(amx_feature_flags_eax, 8, Feature::amx_movrs);
+                    }
+                }
+
+                if os_apx_support {
+                    enable(extended_features_edx_leaf_1, 21, Feature::apxf);
+                }
+
                 // Only if the OS and the CPU support saving/restoring the AVX
                 // registers we enable `xsave` support:
                 if os_avx_support {
@@ -236,9 +258,10 @@ pub(crate) fn detect_features() -> cache::Initializer {
                     enable(extended_features_ebx, 5, Feature::avx2);
 
                     // "Short" versions of AVX512 instructions
-                    enable(extended_features_eax_leaf_1, 4, Feature::avxvnni);
-                    enable(extended_features_eax_leaf_1, 23, Feature::avxifma);
-                    enable(extended_features_edx_leaf_1, 4, Feature::avxvnniint8);
+                    let avxvnni = enable(extended_features_eax_leaf_1, 4, Feature::avxvnni);
+                    let avxvnniint8 = enable(extended_features_eax_leaf_1, 23, Feature::avxifma);
+                    let avxvnniint16 =
+                        enable(extended_features_edx_leaf_1, 4, Feature::avxvnniint8);
                     enable(extended_features_edx_leaf_1, 5, Feature::avxneconvert);
                     enable(extended_features_edx_leaf_1, 10, Feature::avxvnniint16);
 
@@ -269,37 +292,18 @@ pub(crate) fn detect_features() -> cache::Initializer {
                         enable(extended_features_edx, 8, Feature::avx512vp2intersect);
                         enable(extended_features_edx, 23, Feature::avx512fp16);
                         enable(extended_features_eax_leaf_1, 5, Feature::avx512bf16);
-                    }
-                }
 
-                if os_amx_support {
-                    enable(extended_features_edx, 24, Feature::amx_tile);
-                    enable(extended_features_edx, 25, Feature::amx_int8);
-                    enable(extended_features_edx, 22, Feature::amx_bf16);
-                    enable(extended_features_eax_leaf_1, 21, Feature::amx_fp16);
-                    enable(extended_features_edx_leaf_1, 8, Feature::amx_complex);
+                        let avx10_1 = enable(extended_features_edx_leaf_1, 19, Feature::avx10_1);
+                        if avx10_1 {
+                            let CpuidResult { ebx, .. } = __cpuid(0x24);
+                            let avx10_version = ebx & 0xff;
 
-                    if max_basic_leaf >= 0x1e {
-                        let CpuidResult { eax: amx_feature_flags_eax, .. } =
-                            __cpuid_count(0x1e_u32, 1);
-
-                        enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
-                        enable(amx_feature_flags_eax, 6, Feature::amx_tf32);
-                        enable(amx_feature_flags_eax, 7, Feature::amx_avx512);
-                        enable(amx_feature_flags_eax, 8, Feature::amx_movrs);
-                    }
-                }
-
-                if os_apx_support {
-                    enable(extended_features_edx_leaf_1, 21, Feature::apxf);
-                }
-
-                let avx10_1 = enable(extended_features_edx_leaf_1, 19, Feature::avx10_1);
-                if avx10_1 {
-                    let CpuidResult { ebx, .. } = __cpuid(0x24);
-                    let avx10_version = ebx & 0xff;
-                    if avx10_version >= 2 {
-                        value.set(Feature::avx10_2 as u32);
+                            // AVX10.2 supports masked versions of dot-product instructions available in avxvnni etc,
+                            // so it doesn't make sense to have it without the unmasked versions
+                            if avx10_version >= 2 && avxvnni && avxvnniint8 && avxvnniint16 {
+                                value.set(Feature::avx10_2 as u32);
+                            }
+                        }
                     }
                 }
             }

From f62b2f3b4dc85bac50b4b6f517587f479e79f9e1 Mon Sep 17 00:00:00 2001
From: Claire Fan <fanyungching@gmail.com>
Date: Mon, 23 Feb 2026 18:47:11 +0800
Subject: [PATCH 0090/1059] [BPF] add target feature
 allows-misaligned-mem-access

---
 compiler/rustc_codegen_llvm/src/llvm_util.rs  |  5 +++-
 compiler/rustc_target/src/target_features.rs  |  6 +++--
 .../crates/hir-ty/src/target_feature.rs       |  1 +
 tests/assembly-llvm/bpf_unaligned.rs          | 27 +++++++++++++++++++
 tests/auxiliary/minicore.rs                   |  4 +++
 tests/codegen-llvm/bpf-allows-unaligned.rs    | 11 ++++++++
 tests/ui/check-cfg/target_feature.stderr      |  1 +
 7 files changed, 52 insertions(+), 3 deletions(-)
 create mode 100644 tests/assembly-llvm/bpf_unaligned.rs
 create mode 100644 tests/codegen-llvm/bpf-allows-unaligned.rs

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index fbb582fe8601..66bd6dfffec1 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -252,7 +252,10 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
             "fp16" => Some(LLVMFeature::new("fullfp16")),
             s => Some(LLVMFeature::new(s)),
         },
-
+        Arch::Bpf => match s {
+            "allows-misaligned-mem-access" if major < 22 => None,
+            s => Some(LLVMFeature::new(s)),
+        },
         // Filter out features that are not supported by the current LLVM version
         Arch::LoongArch32 | Arch::LoongArch64 => match s {
             "32s" if major < 21 => None,
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index c3de7e257662..8a87cee91117 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -756,8 +756,10 @@ pub fn toggle_allowed(&self) -> Result<(), &'static str> {
     // tidy-alphabetical-end
 ];
 
-const BPF_FEATURES: &[(&str, Stability, ImpliedFeatures)] =
-    &[("alu32", Unstable(sym::bpf_target_feature), &[])];
+const BPF_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
+    ("alu32", Unstable(sym::bpf_target_feature), &[]),
+    ("allows-misaligned-mem-access", Unstable(sym::bpf_target_feature), &[]),
+];
 
 static CSKY_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     // tidy-alphabetical-start
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs b/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
index 2bd675ba124e..29a933f92263 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
@@ -217,6 +217,7 @@ pub(crate) fn from_fn_no_implications(db: &'db dyn HirDatabase, owner: FunctionI
     ("relaxed-simd", &["simd128"]),
     // BPF
     ("alu32", &[]),
+    ("allows-misaligned-mem-access", &[]),
     // CSKY
     ("10e60", &["7e10"]),
     ("2e3", &["e2"]),
diff --git a/tests/assembly-llvm/bpf_unaligned.rs b/tests/assembly-llvm/bpf_unaligned.rs
new file mode 100644
index 000000000000..466c3e411ec2
--- /dev/null
+++ b/tests/assembly-llvm/bpf_unaligned.rs
@@ -0,0 +1,27 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//@ compile-flags: --target bpfel-unknown-none -C target_feature=+allows-misaligned-mem-access
+//@ min-llvm-version: 22
+//@ needs-llvm-components: bpf
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: test_load_i64:
+// CHECK:       r0 = *(u64 *)(r1 + 0)
+#[no_mangle]
+pub unsafe fn test_load_i64(p: *const u64) -> u64 {
+    let mut tmp: u64 = 0;
+    copy_nonoverlapping(p as *const u8, &mut tmp as *mut u64 as *mut u8, 8);
+    tmp
+}
+
+// CHECK-LABEL: test_store_i64:
+// CHECK:       *(u64 *)(r1 + 0) = r2
+#[no_mangle]
+pub unsafe fn test_store_i64(p: *mut u64, v: u64) {
+    copy_nonoverlapping(&v as *const u64 as *const u8, p as *mut u8, 8);
+}
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 3b3472340e73..11f0c9927cdb 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -275,6 +275,10 @@ trait Drop {
     fn drop(&mut self);
 }
 
+#[rustc_nounwind]
+#[rustc_intrinsic]
+pub const unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
+
 pub mod mem {
     #[rustc_nounwind]
     #[rustc_intrinsic]
diff --git a/tests/codegen-llvm/bpf-allows-unaligned.rs b/tests/codegen-llvm/bpf-allows-unaligned.rs
new file mode 100644
index 000000000000..c7a70d5b2e50
--- /dev/null
+++ b/tests/codegen-llvm/bpf-allows-unaligned.rs
@@ -0,0 +1,11 @@
+//@ only-bpf
+#![crate_type = "lib"]
+#![feature(bpf_target_feature)]
+#![no_std]
+
+#[no_mangle]
+#[target_feature(enable = "allows-misaligned-mem-access")]
+// CHECK: define noundef zeroext i8 @foo(i8 noundef returned %arg) unnamed_addr #0 {
+pub unsafe fn foo(arg: u8) -> u8 {
+    arg
+}
diff --git a/tests/ui/check-cfg/target_feature.stderr b/tests/ui/check-cfg/target_feature.stderr
index 06a7f477a7fd..06384c2202f1 100644
--- a/tests/ui/check-cfg/target_feature.stderr
+++ b/tests/ui/check-cfg/target_feature.stderr
@@ -17,6 +17,7 @@ LL |     cfg!(target_feature = "_UNEXPECTED_VALUE");
 `addsubiw`
 `adx`
 `aes`
+`allows-misaligned-mem-access`
 `altivec`
 `alu32`
 `amx-avx512`

From f0336511fa7bc27e05fbab5c851b8cf592844132 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 16:09:52 +0100
Subject: [PATCH 0091/1059] remove debug requirement from hooks

---
 compiler/rustc_middle/src/hooks/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 0ddcdac817b8..1a7a8f5cae60 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -35,8 +35,10 @@ pub struct Providers {
 
         impl Default for Providers {
             fn default() -> Self {
+                #[allow(unused)]
                 Providers {
-                    $($name: |_, $($arg,)*| default_hook(stringify!($name), &($($arg,)*))),*
+                    $($name:
+                        |_, $($arg,)*| default_hook(stringify!($name))),*
                 }
             }
         }
@@ -118,8 +120,6 @@ fn clone(&self) -> Self { *self }
 }
 
 #[cold]
-fn default_hook(name: &str, args: &dyn std::fmt::Debug) -> ! {
-    bug!(
-        "`tcx.{name}{args:?}` cannot be called as `{name}` was never assigned to a provider function"
-    )
+fn default_hook(name: &str) -> ! {
+    bug!("`tcx.{name}` cannot be called as `{name}` was never assigned to a provider function")
 }

From 244b6d5ca8fd6257df414c8b8d48c9c8d26269de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 15:00:36 +0100
Subject: [PATCH 0092/1059] Regression test for trait-system-refactor#262

---
 .../generalize/eagely-normalizing-aliases.rs  | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs

diff --git a/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs b/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs
new file mode 100644
index 000000000000..463fe49e5531
--- /dev/null
+++ b/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs
@@ -0,0 +1,26 @@
+//@ revisions: old next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+// Regression test for trait-system-refactor-initiative#262
+
+trait View {}
+trait HasAssoc {
+    type Assoc;
+}
+
+struct StableVec<T>(T);
+impl<T> View for StableVec<T> {}
+
+fn assert_view<F: View>(f: F) -> F { f }
+
+
+fn store<T>(x: StableVec<T::Assoc>)
+where
+    T: HasAssoc,
+    StableVec<T>: View,
+{
+    let _: StableVec<T::Assoc> = assert_view(x);
+}
+
+fn main() {}

From 5d0863b147c0a0084dfb15e6435004909363865f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 15:00:36 +0100
Subject: [PATCH 0093/1059] eagerly normalize during generalization

---
 .../src/type_check/relate_tys.rs              |   5 +
 compiler/rustc_infer/src/infer/at.rs          |   6 +
 .../src/infer/relate/generalize.rs            | 103 ++++++++++++++----
 .../rustc_infer/src/infer/relate/lattice.rs   |   5 +
 .../src/infer/relate/type_relating.rs         |   9 ++
 .../src/solve/assembly/structural_traits.rs   |   7 +-
 .../src/solve/eval_ctxt/mod.rs                |  35 +++++-
 compiler/rustc_type_ir/src/relate/combine.rs  |   2 +
 .../src/relate/solver_relating.rs             |  49 ++++++---
 9 files changed, 179 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
index e2d684e12a81..152a7674490c 100644
--- a/compiler/rustc_borrowck/src/type_check/relate_tys.rs
+++ b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -616,4 +616,9 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             }
         })]);
     }
+
+    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        // Past hir typeck, so we don't have to worry about type inference anymore.
+        self.type_checker.infcx.next_ty_var(self.span())
+    }
 }
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
index 70e3d7dc9fef..84ad05fa8ea2 100644
--- a/compiler/rustc_infer/src/infer/at.rs
+++ b/compiler/rustc_infer/src/infer/at.rs
@@ -140,6 +140,8 @@ pub fn sup<T>(
                 ty::Contravariant,
                 actual,
                 self.cause.span,
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -173,6 +175,8 @@ pub fn sub<T>(
                 ty::Covariant,
                 actual,
                 self.cause.span,
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -225,6 +229,8 @@ pub fn eq_trace<T>(
                 ty::Invariant,
                 actual,
                 self.cause.span,
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 69c090b662e5..34fd32c45bd2 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -76,6 +76,7 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
             target_vid,
             instantiation_variance,
             source_ty,
+            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         // Constrain `b_vid` to the generalized type `generalized_ty`.
@@ -210,6 +211,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
             target_vid,
             ty::Invariant,
             source_ct,
+            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         debug_assert!(!generalized_ct.is_ct_infer());
@@ -249,6 +251,7 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         target_vid: impl Into<TermVid>,
         ambient_variance: ty::Variance,
         source_term: T,
+        normalize: &mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
     ) -> RelateResult<'tcx, Generalization<T>> {
         assert!(!source_term.has_escaping_bound_vars());
         let (for_universe, root_vid) = match target_vid.into() {
@@ -269,8 +272,9 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            in_alias: false,
+            state: GeneralizationState::Default,
             cache: Default::default(),
+            normalize,
         };
 
         let value_may_be_infer = generalizer.relate(source_term, source_term)?;
@@ -317,6 +321,13 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum GeneralizationState {
+    Default,
+    InAlias,
+    InNormalizedAlias,
+}
+
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to
@@ -361,9 +372,14 @@ struct Generalizer<'me, 'tcx> {
     /// This is necessary to correctly handle
     /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
     /// hold by either normalizing the outer or the inner associated type.
-    in_alias: bool,
+    // TODO: update doc comment
+    state: GeneralizationState,
 
-    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, bool), Ty<'tcx>>,
+    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizationState), Ty<'tcx>>,
+
+    /// Normalize an alias in the trait solver.
+    /// If normalization fails, a fresh infer var is returned.
+    normalize: &'me mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
 }
 
 impl<'tcx> Generalizer<'_, 'tcx> {
@@ -409,17 +425,34 @@ fn generalize_alias_ty(
         // with inference variables can cause incorrect ambiguity.
         //
         // cc trait-system-refactor-initiative#110
-        if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
-            return Ok(self.next_ty_var_for_alias());
+        if self.infcx.next_trait_solver()
+            && !alias.has_escaping_bound_vars()
+            && match self.state {
+                GeneralizationState::Default => true,
+                GeneralizationState::InAlias => false,
+                // When generalizing an alias after normalizing,
+                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
+                // If we recursively find more aliases, the state should have been set back to InAlias.
+                GeneralizationState::InNormalizedAlias => unreachable!(),
+            }
+        {
+            let normalized_alias = (self.normalize)(alias);
+
+            self.state = GeneralizationState::InNormalizedAlias;
+            // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
+            let res = self.relate(normalized_alias, normalized_alias);
+
+            // only one way to get here
+            self.state = GeneralizationState::Default;
+
+            return res;
         }
 
-        let is_nested_alias = mem::replace(&mut self.in_alias, true);
+        let previous_state = mem::replace(&mut self.state, GeneralizationState::InAlias);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
-            Err(e) => {
-                if is_nested_alias {
-                    return Err(e);
-                } else {
+            Err(e) => match previous_state {
+                GeneralizationState::Default => {
                     let mut visitor = MaxUniverse::new();
                     alias.visit_with(&mut visitor);
                     let infer_replacement_is_complete =
@@ -432,9 +465,14 @@ fn generalize_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-            }
+                GeneralizationState::InAlias => return Err(e),
+                // When generalizing an alias after normalizing,
+                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
+                // If we recursively find more aliases, the state should have been set back to InAlias.
+                GeneralizationState::InNormalizedAlias => unreachable!(),
+            },
         };
-        self.in_alias = is_nested_alias;
+        self.state = previous_state;
         result
     }
 }
@@ -488,7 +526,7 @@ fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
     fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
         assert_eq!(t, t2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
 
-        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.in_alias)) {
+        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.state)) {
             return Ok(result);
         }
 
@@ -553,9 +591,17 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                             // cc trait-system-refactor-initiative#108
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                                && self.in_alias
                             {
-                                inner.type_variables().equate(vid, new_var_id);
+                                match self.state {
+                                    GeneralizationState::InAlias => {
+                                        inner.type_variables().equate(vid, new_var_id);
+                                    }
+                                    GeneralizationState::Default
+                                    | GeneralizationState::InNormalizedAlias => {}
+                                }
+                                GeneralizerState::Default
+                                | GeneralizerState::ShallowStructurallyRelateAliases
+                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
 
                             debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
@@ -585,14 +631,25 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
             }
 
             ty::Alias(_, data) => match self.structurally_relate_aliases {
-                StructurallyRelateAliases::No => self.generalize_alias_ty(data),
+                StructurallyRelateAliases::No => match self.state {
+                    GeneralizationState::Default | GeneralizationState::InAlias => {
+                        self.generalize_alias_ty(data)
+                    }
+                    GeneralizationState::InNormalizedAlias => {
+                        // We can switch back to default, we've treated one layer as rigid by doing this operation.
+                        self.state = GeneralizationState::Default;
+                        let res = relate::structurally_relate_tys(self, t, t);
+                        self.state = GeneralizationState::InNormalizedAlias;
+                        res
+                    }
+                },
                 StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
             },
 
             _ => relate::structurally_relate_tys(self, t, t),
         }?;
 
-        self.cache.insert((t, self.ambient_variance, self.in_alias), g);
+        self.cache.insert((t, self.ambient_variance, self.state), g);
         Ok(g)
     }
 
@@ -683,9 +740,17 @@ fn consts(
                             // for more details.
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                                && self.in_alias
                             {
-                                variable_table.union(vid, new_var_id);
+                                match self.state {
+                                    GeneralizationState::InAlias => {
+                                        variable_table.union(vid, new_var_id);
+                                    }
+                                    GeneralizationState::Default
+                                    | GeneralizationState::InNormalizedAlias => {}
+                                }
+                                GeneralizerState::Default
+                                | GeneralizerState::ShallowStructurallyRelateAliases
+                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
                             Ok(ty::Const::new_var(self.cx(), new_var_id))
                         }
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index a05e2d40e829..2cb256b1c63c 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -299,4 +299,9 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             ty::AliasRelationDirection::Equate,
         ))]);
     }
+
+    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        // TODO: this should actually normalize
+        self.infcx.next_ty_var(self.span())
+    }
 }
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs
index 96a0375f5fba..67f9dc69a4a6 100644
--- a/compiler/rustc_infer/src/infer/relate/type_relating.rs
+++ b/compiler/rustc_infer/src/infer/relate/type_relating.rs
@@ -396,4 +396,13 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             }
         })]);
     }
+
+    fn try_eagerly_normalize_alias(
+        &mut self,
+        _alias: rustc_type_ir::AliasTy<<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner>,
+    ) -> <<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner as rustc_type_ir::Interner>::Ty
+    {
+        // We only try to eagerly normalize aliases if we're using the new solver.
+        unreachable!()
+    }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 05ea217c1de0..f94b0f0c30ed 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -976,7 +976,12 @@ fn try_eagerly_replace_alias(
         let replacement = self.ecx.instantiate_binder_with_infer(*replacement);
         self.nested.extend(
             self.ecx
-                .eq_and_get_goals(self.param_env, alias_term, replacement.projection_term)
+                .relate_and_get_goals(
+                    self.param_env,
+                    alias_term,
+                    ty::Invariant,
+                    replacement.projection_term,
+                )
                 .expect("expected to be able to unify goal projection with dyn's projection"),
         );
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 6841fe1c5124..fedb6390d958 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -408,7 +408,7 @@ pub(super) fn ignore_candidate_head_usages(&mut self, usages: CandidateHeadUsage
 
     /// Recursively evaluates `goal`, returning whether any inference vars have
     /// been constrained and the certainty of the result.
-    fn evaluate_goal(
+    pub(super) fn evaluate_goal(
         &mut self,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
@@ -1018,7 +1018,8 @@ pub(super) fn relate<T: Relate<I>>(
         variance: ty::Variance,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        let goals = self.delegate.relate(param_env, lhs, variance, rhs, self.origin_span)?;
+        let goals = self.relate_and_get_goals(param_env, lhs, variance, rhs)?;
+
         for &goal in goals.iter() {
             let source = match goal.predicate.kind().skip_binder() {
                 ty::PredicateKind::Subtype { .. } | ty::PredicateKind::AliasRelate(..) => {
@@ -1039,13 +1040,37 @@ pub(super) fn relate<T: Relate<I>>(
     /// If possible, try using `eq` instead which automatically handles nested
     /// goals correctly.
     #[instrument(level = "trace", skip(self, param_env), ret)]
-    pub(super) fn eq_and_get_goals<T: Relate<I>>(
-        &self,
+    pub(super) fn relate_and_get_goals<T: Relate<I>>(
+        &mut self,
         param_env: I::ParamEnv,
         lhs: T,
+        variance: ty::Variance,
         rhs: T,
     ) -> Result<Vec<Goal<I, I::Predicate>>, NoSolution> {
-        Ok(self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs, self.origin_span)?)
+        let cx = self.cx();
+        let delegate = self.delegate;
+        let origin_span = self.origin_span;
+
+        let mut normalize = |alias: ty::AliasTy<I>| {
+            let inference_var = self.next_ty_infer();
+
+            let goal = Goal::new(
+                cx,
+                param_env,
+                ty::PredicateKind::AliasRelate(
+                    alias.to_ty(cx).into(),
+                    inference_var.into(),
+                    ty::AliasRelationDirection::Equate,
+                ),
+            );
+
+            // Ignore the result. If we can't eagerly normalize, returning the inference variable is enough.
+            let _ = self.evaluate_goal(GoalSource::TypeRelating, goal, None);
+
+            self.resolve_vars_if_possible(inference_var)
+        };
+
+        Ok(delegate.relate(param_env, lhs, variance, rhs, origin_span, &mut normalize)?)
     }
 
     pub(super) fn instantiate_binder_with_infer<T: TypeFoldable<I> + Copy>(
diff --git a/compiler/rustc_type_ir/src/relate/combine.rs b/compiler/rustc_type_ir/src/relate/combine.rs
index 64b87fac77f9..72d54c23733e 100644
--- a/compiler/rustc_type_ir/src/relate/combine.rs
+++ b/compiler/rustc_type_ir/src/relate/combine.rs
@@ -40,6 +40,8 @@ fn register_predicates(
 
     /// Register `AliasRelate` obligation(s) that both types must be related to each other.
     fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty);
+
+    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<I>) -> I::Ty;
 }
 
 pub fn super_combine_tys<Infcx, I, R>(
diff --git a/compiler/rustc_type_ir/src/relate/solver_relating.rs b/compiler/rustc_type_ir/src/relate/solver_relating.rs
index 82ee4f75fcb0..541b2531fe74 100644
--- a/compiler/rustc_type_ir/src/relate/solver_relating.rs
+++ b/compiler/rustc_type_ir/src/relate/solver_relating.rs
@@ -15,6 +15,7 @@ fn relate<T: Relate<Self::Interner>>(
         variance: ty::Variance,
         rhs: T,
         span: <Self::Interner as Interner>::Span,
+        normalize: &mut dyn FnMut(ty::AliasTy<Self::Interner>) -> <Self::Interner as Interner>::Ty,
     ) -> Result<
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
@@ -32,40 +33,46 @@ fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
     >;
 }
 
-impl<Infcx: InferCtxtLike> RelateExt for Infcx {
-    fn relate<T: Relate<Self::Interner>>(
+impl<I: Interner, Infcx: InferCtxtLike<Interner = I>> RelateExt for Infcx {
+    fn relate<T: Relate<I>>(
         &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
+        param_env: I::ParamEnv,
         lhs: T,
         variance: ty::Variance,
         rhs: T,
-        span: <Self::Interner as Interner>::Span,
-    ) -> Result<
-        Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
-        TypeError<Self::Interner>,
-    > {
-        let mut relate =
-            SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env, span);
+        span: I::Span,
+        normalize: &mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
+    ) -> Result<Vec<Goal<I, I::Predicate>>, TypeError<I>> {
+        let mut relate = SolverRelating::new(
+            self,
+            StructurallyRelateAliases::No,
+            variance,
+            param_env,
+            span,
+            normalize,
+        );
         relate.relate(lhs, rhs)?;
         Ok(relate.goals)
     }
 
-    fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
+    fn eq_structurally_relating_aliases<T: Relate<I>>(
         &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
+        param_env: I::ParamEnv,
         lhs: T,
         rhs: T,
-        span: <Self::Interner as Interner>::Span,
-    ) -> Result<
-        Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
-        TypeError<Self::Interner>,
-    > {
+        span: I::Span,
+    ) -> Result<Vec<Goal<I, I::Predicate>>, TypeError<I>> {
+        // Structurally relating, we treat aliases as rigid,
+        // so we shouldn't ever try to normalize them.
+        let mut normalize_unreachable = |_alias| unreachable!();
+
         let mut relate = SolverRelating::new(
             self,
             StructurallyRelateAliases::Yes,
             ty::Invariant,
             param_env,
             span,
+            &mut normalize_unreachable,
         );
         relate.relate(lhs, rhs)?;
         Ok(relate.goals)
@@ -75,12 +82,14 @@ fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
 /// Enforce that `a` is equal to or a subtype of `b`.
 pub struct SolverRelating<'infcx, Infcx, I: Interner> {
     infcx: &'infcx Infcx,
+
     // Immutable fields.
     structurally_relate_aliases: StructurallyRelateAliases,
     param_env: I::ParamEnv,
     span: I::Span,
     // Mutable fields.
     ambient_variance: ty::Variance,
+    normalize: &'infcx mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
     goals: Vec<Goal<I, I::Predicate>>,
     /// The cache only tracks the `ambient_variance` as it's the
     /// only field which is mutable and which meaningfully changes
@@ -118,12 +127,14 @@ pub fn new(
         ambient_variance: ty::Variance,
         param_env: I::ParamEnv,
         span: I::Span,
+        normalize: &'infcx mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
     ) -> Self {
         SolverRelating {
             infcx,
             structurally_relate_aliases,
             span,
             ambient_variance,
+            normalize,
             param_env,
             goals: vec![],
             cache: Default::default(),
@@ -406,4 +417,8 @@ fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty) {
             }
         })]);
     }
+
+    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<I>) -> I::Ty {
+        (self.normalize)(alias)
+    }
 }

From 04f2c0191ebe7a1018e00cf6db5f8394352c2da6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 15:46:09 +0100
Subject: [PATCH 0094/1059] implement eager normalization in a fresh context
 during typeck

---
 compiler/rustc_infer/src/infer/at.rs          | 15 +++--
 compiler/rustc_infer/src/infer/mod.rs         | 13 ++++-
 .../rustc_infer/src/infer/relate/lattice.rs   |  5 +-
 compiler/rustc_interface/src/passes.rs        |  2 +-
 compiler/rustc_middle/src/hooks/mod.rs        | 24 +++++++-
 compiler/rustc_trait_selection/src/solve.rs   | 56 +++++++++++++++++--
 6 files changed, 98 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
index 84ad05fa8ea2..3487286d5883 100644
--- a/compiler/rustc_infer/src/infer/at.rs
+++ b/compiler/rustc_infer/src/infer/at.rs
@@ -140,8 +140,9 @@ pub fn sup<T>(
                 ty::Contravariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -175,8 +176,9 @@ pub fn sub<T>(
                 ty::Covariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -229,8 +231,9 @@ pub fn eq_trace<T>(
                 ty::Invariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index b57306536260..2a2ac7c15924 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1,5 +1,5 @@
 use std::cell::{Cell, RefCell};
-use std::fmt;
+use std::{fmt, mem};
 
 pub use at::DefineOpaqueTypes;
 use free_regions::RegionRelations;
@@ -21,6 +21,7 @@
 use rustc_macros::extension;
 pub use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::bug;
+use rustc_middle::hooks::TypeErasedInfcx;
 use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::select;
@@ -1498,6 +1499,16 @@ pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> boo
         }
     }
 
+    pub fn try_eagerly_normalize_alias<'a>(
+        &'a self,
+        param_env: ty::ParamEnv<'tcx>,
+        span: Span,
+        alias: ty::AliasTy<'tcx>,
+    ) -> Ty<'tcx> {
+        let erased = unsafe { mem::transmute::<_, TypeErasedInfcx<'a, 'tcx>>(self) };
+        self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
+    }
+
     /// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
     pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
         debug_assert!(
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index 2cb256b1c63c..7e480df7dda6 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -300,8 +300,7 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
         ))]);
     }
 
-    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        // TODO: this should actually normalize
-        self.infcx.next_ty_var(self.span())
+    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        self.infcx.try_eagerly_normalize_alias(self.param_env(), self.span(), alias)
     }
 }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 15addd240785..225fff380ef5 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -900,7 +900,7 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
     rustc_hir_typeck::provide(&mut providers.queries);
     ty::provide(&mut providers.queries);
     traits::provide(&mut providers.queries);
-    solve::provide(&mut providers.queries);
+    solve::provide(providers);
     rustc_passes::provide(&mut providers.queries);
     rustc_traits::provide(&mut providers.queries);
     rustc_ty_utils::provide(&mut providers.queries);
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 1a7a8f5cae60..c09d9fc2d468 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -3,14 +3,16 @@
 //! similar to queries, but queries come with a lot of machinery for caching and incremental
 //! compilation, whereas hooks are just plain function pointers without any of the query magic.
 
+use std::marker::PhantomData;
+
 use rustc_hir::def_id::{DefId, DefPathHash};
 use rustc_session::StableCrateId;
 use rustc_span::def_id::{CrateNum, LocalDefId};
-use rustc_span::{ExpnHash, ExpnId};
+use rustc_span::{ExpnHash, ExpnId, Span};
 
-use crate::mir;
 use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex};
 use crate::ty::{Ty, TyCtxt};
+use crate::{mir, ty};
 
 macro_rules! declare_hooks {
     ($($(#[$attr:meta])*hook $name:ident($($arg:ident: $K:ty),*) -> $V:ty;)*) => {
@@ -117,6 +119,24 @@ fn clone(&self) -> Self { *self }
         encoder: &mut CacheEncoder<'_, 'tcx>,
         query_result_index: &mut EncodedDepNodeIndex
     ) -> ();
+
+    /// Tries to normalize an alias, ignoring any errors.
+    ///
+    /// Generalization with the new trait solver calls into this,
+    /// when generalizing outside of the trait solver in `hir_typeck`.
+    hook try_eagerly_normalize_alias(
+        type_erased_infcx: TypeErasedInfcx<'_, 'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+        span: Span,
+        alias: ty::AliasTy<'tcx>
+    ) -> Ty<'tcx>;
+}
+
+// `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
+#[repr(transparent)]
+pub struct TypeErasedInfcx<'a, 'tcx> {
+    _infcx: *const (),
+    phantom: PhantomData<&'a mut &'tcx ()>,
 }
 
 #[cold]
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index 5d200c4d340b..cb0288513903 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -1,3 +1,8 @@
+use std::mem;
+
+use rustc_infer::infer::InferCtxt;
+use rustc_infer::traits::{Obligation, ObligationCause};
+use rustc_middle::hooks::TypeErasedInfcx;
 pub use rustc_next_trait_solver::solve::*;
 
 mod delegate;
@@ -13,10 +18,13 @@
     deeply_normalize, deeply_normalize_with_skipped_universes,
     deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,
 };
-use rustc_middle::query::Providers;
-use rustc_middle::ty::TyCtxt;
+use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::util::Providers;
+use rustc_span::Span;
 pub use select::InferCtxtSelectExt;
 
+use crate::traits::ObligationCtxt;
+
 fn evaluate_root_goal_for_proof_tree_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     canonical_input: CanonicalInput<TyCtxt<'tcx>>,
@@ -27,6 +35,46 @@ fn evaluate_root_goal_for_proof_tree_raw<'tcx>(
     )
 }
 
-pub fn provide(providers: &mut Providers) {
-    *providers = Providers { evaluate_root_goal_for_proof_tree_raw, ..*providers };
+fn try_eagerly_normalize_alias<'a, 'tcx>(
+    tcx: TyCtxt<'tcx>,
+    type_erased_infcx: TypeErasedInfcx<'a, 'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    span: Span,
+    alias: ty::AliasTy<'tcx>,
+) -> Ty<'tcx> {
+    let infcx = unsafe {
+        mem::transmute::<TypeErasedInfcx<'a, 'tcx>, &'a InferCtxt<'tcx>>(type_erased_infcx)
+    };
+
+    let ocx = ObligationCtxt::new(infcx);
+
+    let infer_term = infcx.next_ty_var(span);
+
+    // Dummy because we ignore the error anyway.
+    // We do provide a span, because this span is used when registering opaque types.
+    // For example, if we don't provide a span here, some diagnostics talking about TAIT will refer to a dummy span.
+    let cause = ObligationCause::dummy_with_span(span);
+    let obligation = Obligation::new(
+        tcx,
+        // we ignore the error anyway
+        ObligationCause::dummy(),
+        param_env,
+        ty::PredicateKind::AliasRelate(
+            alias.to_ty(tcx).into(),
+            infer_term.into(),
+            ty::AliasRelationDirection::Equate,
+        ),
+    );
+
+    ocx.register_obligation(obligation);
+
+    // This only tries to eagerly resolve, if it errors we don't care.
+    let _ = ocx.try_evaluate_obligations();
+
+    infcx.resolve_vars_if_possible(infer_term)
+}
+
+pub fn provide(providers: &mut Providers) {
+    providers.hooks.try_eagerly_normalize_alias = try_eagerly_normalize_alias;
+    providers.queries.evaluate_root_goal_for_proof_tree_raw = evaluate_root_goal_for_proof_tree_raw;
 }

From 917713b4db3c627f2a35174c09d3ca715dd814b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 16:03:10 +0100
Subject: [PATCH 0095/1059] merge generalizer state and structurally relate
 aliases

---
 .../src/infer/relate/generalize.rs            | 117 ++++++++----------
 1 file changed, 53 insertions(+), 64 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 34fd32c45bd2..d5c0726ed9a8 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -267,12 +267,14 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         let mut generalizer = Generalizer {
             infcx: self,
             span,
-            structurally_relate_aliases,
             root_vid,
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            state: GeneralizationState::Default,
+            state: match structurally_relate_aliases {
+                StructurallyRelateAliases::No => GeneralizerState::Default,
+                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+            },
             cache: Default::default(),
             normalize,
         };
@@ -322,10 +324,13 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-enum GeneralizationState {
+enum GeneralizerState {
+    /// Treat aliases as potentially normalizable.
     Default,
-    InAlias,
-    InNormalizedAlias,
+    IncompletelyRelateHigherRankedAlias,
+    /// Only one layer
+    ShallowStructurallyRelateAliases,
+    StructurallyRelateAliases,
 }
 
 /// The "generalizer" is used when handling inference variables.
@@ -346,10 +351,6 @@ struct Generalizer<'me, 'tcx> {
 
     span: Span,
 
-    /// Whether aliases should be related structurally. If not, we have to
-    /// be careful when generalizing aliases.
-    structurally_relate_aliases: StructurallyRelateAliases,
-
     /// The vid of the type variable that is in the process of being
     /// instantiated. If we find this within the value we are folding,
     /// that means we would have created a cyclic value.
@@ -372,10 +373,9 @@ struct Generalizer<'me, 'tcx> {
     /// This is necessary to correctly handle
     /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
     /// hold by either normalizing the outer or the inner associated type.
-    // TODO: update doc comment
-    state: GeneralizationState,
+    state: GeneralizerState,
 
-    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizationState), Ty<'tcx>>,
+    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizerState), Ty<'tcx>>,
 
     /// Normalize an alias in the trait solver.
     /// If normalization fails, a fresh infer var is returned.
@@ -415,44 +415,51 @@ fn next_ty_var_for_alias(&self) -> Ty<'tcx> {
     ///   continue generalizing the alias. This ends up pulling down the universe of the
     ///   inference variable and is incomplete in case the alias would normalize to a type
     ///   which does not mention that inference variable.
-    fn generalize_alias_ty(
+    fn handle_alias_ty(
         &mut self,
+        alias_ty: Ty<'tcx>,
         alias: ty::AliasTy<'tcx>,
     ) -> Result<Ty<'tcx>, TypeError<'tcx>> {
-        // We do not eagerly replace aliases with inference variables if they have
-        // escaping bound vars, see the method comment for details. However, when we
-        // are inside of an alias with escaping bound vars replacing nested aliases
-        // with inference variables can cause incorrect ambiguity.
-        //
-        // cc trait-system-refactor-initiative#110
-        if self.infcx.next_trait_solver()
-            && !alias.has_escaping_bound_vars()
-            && match self.state {
-                GeneralizationState::Default => true,
-                GeneralizationState::InAlias => false,
-                // When generalizing an alias after normalizing,
-                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
-                // If we recursively find more aliases, the state should have been set back to InAlias.
-                GeneralizationState::InNormalizedAlias => unreachable!(),
+        match self.state {
+            GeneralizerState::ShallowStructurallyRelateAliases => {
+                // We can switch back to default, we've treated one layer as rigid by doing this operation.
+                self.state = GeneralizerState::Default;
+                let res = relate::structurally_relate_tys(self, alias_ty, alias_ty);
+                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
+                return res;
             }
-        {
-            let normalized_alias = (self.normalize)(alias);
+            GeneralizerState::StructurallyRelateAliases => {
+                return relate::structurally_relate_tys(self, alias_ty, alias_ty);
+            }
+            GeneralizerState::Default
+                if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() =>
+            {
+                // We do not eagerly replace aliases with inference variables if they have
+                // escaping bound vars, see the method comment for details. However, when we
+                // are inside of an alias with escaping bound vars replacing nested aliases
+                // with inference variables can cause incorrect ambiguity.
+                //
+                // cc trait-system-refactor-initiative#110
+                let normalized_alias = (self.normalize)(alias);
 
-            self.state = GeneralizationState::InNormalizedAlias;
-            // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
-            let res = self.relate(normalized_alias, normalized_alias);
+                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
+                // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
+                let res = self.relate(normalized_alias, normalized_alias);
 
-            // only one way to get here
-            self.state = GeneralizationState::Default;
+                // only one way to get here
+                self.state = GeneralizerState::Default;
 
-            return res;
+                return res;
+            }
+            GeneralizerState::Default | GeneralizerState::IncompletelyRelateHigherRankedAlias => {}
         }
 
-        let previous_state = mem::replace(&mut self.state, GeneralizationState::InAlias);
+        let previous_state =
+            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateHigherRankedAlias);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
             Err(e) => match previous_state {
-                GeneralizationState::Default => {
+                GeneralizerState::Default => {
                     let mut visitor = MaxUniverse::new();
                     alias.visit_with(&mut visitor);
                     let infer_replacement_is_complete =
@@ -465,11 +472,11 @@ fn generalize_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-                GeneralizationState::InAlias => return Err(e),
-                // When generalizing an alias after normalizing,
-                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
-                // If we recursively find more aliases, the state should have been set back to InAlias.
-                GeneralizationState::InNormalizedAlias => unreachable!(),
+                GeneralizerState::IncompletelyRelateHigherRankedAlias => return Err(e),
+
+                // Early return.
+                GeneralizerState::ShallowStructurallyRelateAliases
+                | GeneralizerState::StructurallyRelateAliases => unreachable!(),
             },
         };
         self.state = previous_state;
@@ -593,11 +600,9 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizationState::InAlias => {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
                                         inner.type_variables().equate(vid, new_var_id);
                                     }
-                                    GeneralizationState::Default
-                                    | GeneralizationState::InNormalizedAlias => {}
                                 }
                                 GeneralizerState::Default
                                 | GeneralizerState::ShallowStructurallyRelateAliases
@@ -630,21 +635,7 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                 }
             }
 
-            ty::Alias(_, data) => match self.structurally_relate_aliases {
-                StructurallyRelateAliases::No => match self.state {
-                    GeneralizationState::Default | GeneralizationState::InAlias => {
-                        self.generalize_alias_ty(data)
-                    }
-                    GeneralizationState::InNormalizedAlias => {
-                        // We can switch back to default, we've treated one layer as rigid by doing this operation.
-                        self.state = GeneralizationState::Default;
-                        let res = relate::structurally_relate_tys(self, t, t);
-                        self.state = GeneralizationState::InNormalizedAlias;
-                        res
-                    }
-                },
-                StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
-            },
+            ty::Alias(_, data) => self.handle_alias_ty(t, data),
 
             _ => relate::structurally_relate_tys(self, t, t),
         }?;
@@ -742,11 +733,9 @@ fn consts(
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizationState::InAlias => {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
                                         variable_table.union(vid, new_var_id);
                                     }
-                                    GeneralizationState::Default
-                                    | GeneralizationState::InNormalizedAlias => {}
                                 }
                                 GeneralizerState::Default
                                 | GeneralizerState::ShallowStructurallyRelateAliases

From 7a123e87b21cd95fef62b80571ee6c644ac3a1c3 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 29 Jan 2026 18:49:58 +0100
Subject: [PATCH 0096/1059] explicitly provide type in transmute

---
 compiler/rustc_infer/src/infer/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 2a2ac7c15924..351d0001c677 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1505,7 +1505,8 @@ pub fn try_eagerly_normalize_alias<'a>(
         span: Span,
         alias: ty::AliasTy<'tcx>,
     ) -> Ty<'tcx> {
-        let erased = unsafe { mem::transmute::<_, TypeErasedInfcx<'a, 'tcx>>(self) };
+        let erased =
+            unsafe { mem::transmute::<&'a InferCtxt<'tcx>, TypeErasedInfcx<'a, 'tcx>>(self) };
         self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
     }
 

From f50591fc1059d98ba57c79094f6e2d46db4b25b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Fri, 30 Jan 2026 19:00:20 +0100
Subject: [PATCH 0097/1059] normalize at the start of generalize if we can

---
 .../src/infer/relate/generalize.rs            | 82 +++++++++++++------
 .../src/canonical/canonicalizer.rs            |  6 +-
 2 files changed, 62 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index d5c0726ed9a8..1d4dab001616 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -38,6 +38,31 @@ fn from(value: ty::ConstVid) -> Self {
 }
 
 impl<'tcx> InferCtxt<'tcx> {
+    fn check_generalized_alias_normalizes_to_tyvar<R: PredicateEmittingRelation<Self>>(
+        &self,
+        relation: &mut R,
+        source_ty: Ty<'tcx>,
+    ) -> Option<Ty<'tcx>> {
+        if !self.next_trait_solver()
+            || matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::Yes)
+        {
+            return None;
+        }
+
+        // If we get an alias
+        let ty::Alias(_, alias) = source_ty.kind() else {
+            return None;
+        };
+
+        if alias.has_escaping_bound_vars() {
+            return None;
+        }
+
+        let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
+
+        normalized_alias.is_ty_var().then_some(normalized_alias)
+    }
+
     /// The idea is that we should ensure that the type variable `target_vid`
     /// is equal to, a subtype of, or a supertype of `source_ty`.
     ///
@@ -51,7 +76,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// `TypeRelation`. Do not use this, and instead please use `At::eq`, for all
     /// other usecases (i.e. setting the value of a type var).
     #[instrument(level = "debug", skip(self, relation))]
-    pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
+    pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
         &self,
         relation: &mut R,
         target_is_expected: bool,
@@ -61,30 +86,31 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
     ) -> RelateResult<'tcx, ()> {
         debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
 
-        // Generalize `source_ty` depending on the current variance. As an example, assume
-        // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
-        // variable.
-        //
-        // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
-        // region/type inference variables.
-        //
-        // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
-        // `?1 <: ?3`.
-        let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
-            relation.span(),
-            relation.structurally_relate_aliases(),
-            target_vid,
-            instantiation_variance,
-            source_ty,
-            &mut |alias| relation.try_eagerly_normalize_alias(alias),
-        )?;
+        let generalized_ty =
+            match self.check_generalized_alias_normalizes_to_tyvar(relation, source_ty) {
+                Some(tyvar) => tyvar,
+                None => {
+                    // Generalize `source_ty` depending on the current variance. As an example, assume
+                    // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+                    // variable.
+                    //
+                    // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+                    // region/type inference variables.
+                    //
+                    // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+                    // `?1 <: ?3`.
+                    let generalizer = self.generalize(
+                        relation.span(),
+                        relation.structurally_relate_aliases(),
+                        target_vid,
+                        instantiation_variance,
+                        source_ty,
+                        &mut |alias| relation.try_eagerly_normalize_alias(alias),
+                    )?;
 
-        // Constrain `b_vid` to the generalized type `generalized_ty`.
-        if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
-            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
-        } else {
-            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
-        }
+                    generalizer.value_may_be_infer
+                }
+            };
 
         // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
         //
@@ -92,7 +118,10 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
         // relations wind up attributed to the same spans. We need
         // to associate causes/spans with each of the relations in
         // the stack to get this right.
-        if generalized_ty.is_ty_var() {
+        if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
+            // Constrain `b_vid` to the generalized type variable.
+            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
+
             // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
             // We can't instantiate `?0` here as that would result in a
             // cyclic type. We instead delay the unification in case
@@ -133,6 +162,9 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
                 }
             }
         } else {
+            // Constrain `b_vid` to the generalized type `generalized_ty`.
+            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
+
             // NOTE: The `instantiation_variance` is not the same variance as
             // used by the relation. When instantiating `b`, `target_is_expected`
             // is flipped and the `instantiation_variance` is also flipped. To
diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
index ce2be24adc58..e469451da993 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
@@ -177,7 +177,11 @@ fn canonicalize_param_env(
                 cache: Default::default(),
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
-            debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
+            debug_assert!(
+                env_canonicalizer.sub_root_lookup_table.is_empty(),
+                "{:?}",
+                env_canonicalizer.sub_root_lookup_table
+            );
             (
                 param_env,
                 env_canonicalizer.variables,

From e8e3544a71f23606c85e8586e37bd98389bc1ebe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 3 Feb 2026 15:14:44 +0100
Subject: [PATCH 0098/1059] try generalizing if normalization isn't a tyvar

---
 .../src/infer/relate/generalize.rs            | 113 +++++++++---------
 1 file changed, 58 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 1d4dab001616..e1d3f4e6bd48 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -38,31 +38,6 @@ fn from(value: ty::ConstVid) -> Self {
 }
 
 impl<'tcx> InferCtxt<'tcx> {
-    fn check_generalized_alias_normalizes_to_tyvar<R: PredicateEmittingRelation<Self>>(
-        &self,
-        relation: &mut R,
-        source_ty: Ty<'tcx>,
-    ) -> Option<Ty<'tcx>> {
-        if !self.next_trait_solver()
-            || matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::Yes)
-        {
-            return None;
-        }
-
-        // If we get an alias
-        let ty::Alias(_, alias) = source_ty.kind() else {
-            return None;
-        };
-
-        if alias.has_escaping_bound_vars() {
-            return None;
-        }
-
-        let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
-
-        normalized_alias.is_ty_var().then_some(normalized_alias)
-    }
-
     /// The idea is that we should ensure that the type variable `target_vid`
     /// is equal to, a subtype of, or a supertype of `source_ty`.
     ///
@@ -86,31 +61,53 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
     ) -> RelateResult<'tcx, ()> {
         debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
 
-        let generalized_ty =
-            match self.check_generalized_alias_normalizes_to_tyvar(relation, source_ty) {
-                Some(tyvar) => tyvar,
-                None => {
-                    // Generalize `source_ty` depending on the current variance. As an example, assume
-                    // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
-                    // variable.
-                    //
-                    // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
-                    // region/type inference variables.
-                    //
-                    // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
-                    // `?1 <: ?3`.
-                    let generalizer = self.generalize(
-                        relation.span(),
-                        relation.structurally_relate_aliases(),
-                        target_vid,
-                        instantiation_variance,
-                        source_ty,
-                        &mut |alias| relation.try_eagerly_normalize_alias(alias),
-                    )?;
+        let generalized_ty = if self.next_trait_solver()
+            && matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::No)
+            && let ty::Alias(_, alias) = source_ty.kind()
+        {
+            let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
 
-                    generalizer.value_may_be_infer
-                }
-            };
+            if normalized_alias.is_ty_var() {
+                normalized_alias
+            } else {
+                let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
+                    relation.span(),
+                    GeneralizerState::ShallowStructurallyRelateAliases,
+                    target_vid,
+                    instantiation_variance,
+                    normalized_alias,
+                    &mut |alias| relation.try_eagerly_normalize_alias(alias),
+                )?;
+
+                // The only way to get a tyvar back is if the outermost type is an alias.
+                // However, here, though we know it *is* an alias, we initialize the generalizer
+                // with `ShallowStructurallyRelateAliases` so we treat the outermost alias as rigid,
+                // ensuring this is never a tyvar.
+                assert!(!generalized_ty.is_ty_var());
+
+                generalized_ty
+            }
+        } else {
+            // Generalize `source_ty` depending on the current variance. As an example, assume
+            // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+            // variable.
+            //
+            // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+            // region/type inference variables.
+            //
+            // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+            // `?1 <: ?3`.
+            let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
+                relation.span(),
+                relation.structurally_relate_aliases().into(),
+                target_vid,
+                instantiation_variance,
+                source_ty,
+                &mut |alias| relation.try_eagerly_normalize_alias(alias),
+            )?;
+
+            generalized_ty
+        };
 
         // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
         //
@@ -239,7 +236,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
         // constants and generic expressions are not yet handled correctly.
         let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
             relation.span(),
-            relation.structurally_relate_aliases(),
+            relation.structurally_relate_aliases().into(),
             target_vid,
             ty::Invariant,
             source_ct,
@@ -279,7 +276,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
     fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         &self,
         span: Span,
-        structurally_relate_aliases: StructurallyRelateAliases,
+        initial_state: GeneralizerState,
         target_vid: impl Into<TermVid>,
         ambient_variance: ty::Variance,
         source_term: T,
@@ -303,10 +300,7 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            state: match structurally_relate_aliases {
-                StructurallyRelateAliases::No => GeneralizerState::Default,
-                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-            },
+            state: initial_state,
             cache: Default::default(),
             normalize,
         };
@@ -365,6 +359,15 @@ enum GeneralizerState {
     StructurallyRelateAliases,
 }
 
+impl From<StructurallyRelateAliases> for GeneralizerState {
+    fn from(structurally_relate_aliases: StructurallyRelateAliases) -> Self {
+        match structurally_relate_aliases {
+            StructurallyRelateAliases::No => GeneralizerState::Default,
+            StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+        }
+    }
+}
+
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to

From 2d411a0faad447b5bfc968b954fd3e9c10596325 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Thu, 5 Feb 2026 11:35:47 +0100
Subject: [PATCH 0099/1059] fixup span in obligation cause

---
 compiler/rustc_trait_selection/src/solve.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index cb0288513903..118bd8c81b1e 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -57,7 +57,7 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     let obligation = Obligation::new(
         tcx,
         // we ignore the error anyway
-        ObligationCause::dummy(),
+        ObligationCause::dummy_with_span(span),
         param_env,
         ty::PredicateKind::AliasRelate(
             alias.to_ty(tcx).into(),

From 6edf58fab80d713b5e017d98a57c4075c12b833e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 2 Feb 2026 19:31:10 +0100
Subject: [PATCH 0100/1059] bless some tests

---
 .../impl-trait/unsized_coercion.next.stderr   | 11 ------
 tests/ui/impl-trait/unsized_coercion.rs       |  2 +-
 .../impl-trait/unsized_coercion3.next.stderr  | 36 +++++++++++++++++--
 .../impl-trait/unsized_coercion3.old.stderr   |  2 +-
 tests/ui/impl-trait/unsized_coercion3.rs      |  2 ++
 ...id-alias-bound-is-not-inherent.next.stderr |  2 +-
 ...rg-type-mismatch-issue-45727.current.fixed |  3 +-
 ...-arg-type-mismatch-issue-45727.next.stderr | 11 ++----
 .../closure-arg-type-mismatch-issue-45727.rs  |  3 +-
 9 files changed, 42 insertions(+), 30 deletions(-)
 delete mode 100644 tests/ui/impl-trait/unsized_coercion.next.stderr

diff --git a/tests/ui/impl-trait/unsized_coercion.next.stderr b/tests/ui/impl-trait/unsized_coercion.next.stderr
deleted file mode 100644
index bea5ddb0aefc..000000000000
--- a/tests/ui/impl-trait/unsized_coercion.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
-  --> $DIR/unsized_coercion.rs:14:17
-   |
-LL |         let x = hello();
-   |                 ^^^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `dyn Trait`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/unsized_coercion.rs b/tests/ui/impl-trait/unsized_coercion.rs
index 2cbf0d25d7ec..6a9a53903fed 100644
--- a/tests/ui/impl-trait/unsized_coercion.rs
+++ b/tests/ui/impl-trait/unsized_coercion.rs
@@ -4,6 +4,7 @@
 //@ revisions: next old
 //@[next] compile-flags: -Znext-solver
 //@[old] check-pass
+//@[next] check-pass
 
 trait Trait {}
 
@@ -12,7 +13,6 @@ impl Trait for u32 {}
 fn hello() -> Box<impl Trait> {
     if true {
         let x = hello();
-        //[next]~^ ERROR: the size for values of type `dyn Trait` cannot be known at compilation time
         let y: Box<dyn Trait> = x;
     }
     Box::new(1u32)
diff --git a/tests/ui/impl-trait/unsized_coercion3.next.stderr b/tests/ui/impl-trait/unsized_coercion3.next.stderr
index a480a69a3864..db758761d795 100644
--- a/tests/ui/impl-trait/unsized_coercion3.next.stderr
+++ b/tests/ui/impl-trait/unsized_coercion3.next.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `dyn Send: Trait` is not satisfied
-  --> $DIR/unsized_coercion3.rs:13:17
+  --> $DIR/unsized_coercion3.rs:14:17
    |
 LL |         let x = hello();
    |                 ^^^^^^^ the trait `Trait` is not implemented for `dyn Send`
@@ -9,7 +9,37 @@ help: the trait `Trait` is implemented for `u32`
    |
 LL | impl Trait for u32 {}
    | ^^^^^^^^^^^^^^^^^^
+note: required by a bound in `Box`
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/unsized_coercion3.rs:19:5
+   |
+LL | fn hello() -> Box<impl Trait + ?Sized> {
+   |               ------------------------
+   |               |   |
+   |               |   the expected opaque type
+   |               expected `Box<impl Trait + ?Sized>` because of return type
+...
+LL |     Box::new(1u32)
+   |     ^^^^^^^^^^^^^^ types differ
+   |
+   = note: expected struct `Box<impl Trait + ?Sized>`
+              found struct `Box<u32>`
 
-For more information about this error, try `rustc --explain E0277`.
+error[E0277]: the trait bound `dyn Send: Trait` is not satisfied
+  --> $DIR/unsized_coercion3.rs:11:1
+   |
+LL | fn hello() -> Box<impl Trait + ?Sized> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `dyn Send`
+   |
+help: the trait `Trait` is implemented for `u32`
+  --> $DIR/unsized_coercion3.rs:9:1
+   |
+LL | impl Trait for u32 {}
+   | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/unsized_coercion3.old.stderr b/tests/ui/impl-trait/unsized_coercion3.old.stderr
index 52a72b84a8dd..3bb9f9c20951 100644
--- a/tests/ui/impl-trait/unsized_coercion3.old.stderr
+++ b/tests/ui/impl-trait/unsized_coercion3.old.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the size for values of type `impl Trait + ?Sized` cannot be known at compilation time
-  --> $DIR/unsized_coercion3.rs:15:32
+  --> $DIR/unsized_coercion3.rs:16:32
    |
 LL |         let y: Box<dyn Send> = x;
    |                                ^ doesn't have a size known at compile-time
diff --git a/tests/ui/impl-trait/unsized_coercion3.rs b/tests/ui/impl-trait/unsized_coercion3.rs
index ebfbb2955de5..c1dd5350e229 100644
--- a/tests/ui/impl-trait/unsized_coercion3.rs
+++ b/tests/ui/impl-trait/unsized_coercion3.rs
@@ -9,6 +9,7 @@ trait Trait {}
 impl Trait for u32 {}
 
 fn hello() -> Box<impl Trait + ?Sized> {
+    //[next]~^ ERROR: the trait bound `dyn Send: Trait` is not satisfied
     if true {
         let x = hello();
         //[next]~^ ERROR: the trait bound `dyn Send: Trait` is not satisfied
@@ -16,6 +17,7 @@ fn hello() -> Box<impl Trait + ?Sized> {
         //[old]~^ ERROR: the size for values of type `impl Trait + ?Sized` cannot be know
     }
     Box::new(1u32)
+    //[next]~^ ERROR: mismatched types
 }
 
 fn main() {}
diff --git a/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr b/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
index afacb3a7d521..4652bf5e3c58 100644
--- a/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
+++ b/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
@@ -9,7 +9,7 @@ note: candidate #1 is defined in the trait `Trait1`
    |
 LL |     fn method(&self) {
    |     ^^^^^^^^^^^^^^^^
-note: candidate #2 is defined in the trait `Trait2`
+note: candidate #2 is defined in an impl of the trait `Trait2` for the type `T`
   --> $DIR/rigid-alias-bound-is-not-inherent.rs:27:5
    |
 LL |     fn method(&self) {
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
index ba46a447802c..1c45a2c0adb3 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
@@ -8,6 +8,5 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
index 7912ed4d7071..36e49c20c433 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
@@ -12,12 +12,6 @@ LL |     let _ = (-10..=10).find(|x: i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error[E0271]: expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-  --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:24
-   |
-LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
-   |                        ^^^^ expected `&&i32`, found integer
-
 error[E0277]: expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found `{closure@$DIR/closure-arg-type-mismatch-issue-45727.rs:9:29: 9:40}`
   --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:29
    |
@@ -32,7 +26,6 @@ LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0271, E0277.
-For more information about an error, try `rustc --explain E0271`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
index 0fd56707763e..20d6fed3b35b 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
@@ -8,6 +8,5 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }

From 9aa065bc49e5c9a0e07dbfc4bb0823821e5f130d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 9 Feb 2026 12:31:37 +0100
Subject: [PATCH 0101/1059] inline into

---
 .../src/infer/relate/generalize.rs            | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index e1d3f4e6bd48..f3843c371e2c 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -99,7 +99,10 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
             // `?1 <: ?3`.
             let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
                 relation.span(),
-                relation.structurally_relate_aliases().into(),
+                match relation.structurally_relate_aliases() {
+                    StructurallyRelateAliases::No => GeneralizerState::Default,
+                    StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+                },
                 target_vid,
                 instantiation_variance,
                 source_ty,
@@ -236,7 +239,10 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
         // constants and generic expressions are not yet handled correctly.
         let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
             relation.span(),
-            relation.structurally_relate_aliases().into(),
+            match relation.structurally_relate_aliases() {
+                StructurallyRelateAliases::No => GeneralizerState::Default,
+                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+            },
             target_vid,
             ty::Invariant,
             source_ct,
@@ -359,15 +365,6 @@ enum GeneralizerState {
     StructurallyRelateAliases,
 }
 
-impl From<StructurallyRelateAliases> for GeneralizerState {
-    fn from(structurally_relate_aliases: StructurallyRelateAliases) -> Self {
-        match structurally_relate_aliases {
-            StructurallyRelateAliases::No => GeneralizerState::Default,
-            StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-        }
-    }
-}
-
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to

From 7adb9bac0c7d2bf469e6b76c6cc47099afb02123 Mon Sep 17 00:00:00 2001
From: "LevitatingBusinessMan (Rein Fernhout)" <me@levitati.ng>
Date: Fri, 27 Feb 2026 09:30:27 +0100
Subject: [PATCH 0102/1059] Add is_disconnected functions to mpsc and mpmc
 channels

---
 library/std/src/sync/mpmc/mod.rs  | 46 +++++++++++++++++++++++++++++++
 library/std/src/sync/mpmc/zero.rs |  6 ++++
 library/std/src/sync/mpsc.rs      | 38 +++++++++++++++++++++++++
 3 files changed, 90 insertions(+)

diff --git a/library/std/src/sync/mpmc/mod.rs b/library/std/src/sync/mpmc/mod.rs
index 8df81a580f7b..6249e8a033e8 100644
--- a/library/std/src/sync/mpmc/mod.rs
+++ b/library/std/src/sync/mpmc/mod.rs
@@ -623,6 +623,29 @@ pub fn same_channel(&self, other: &Sender<T>) -> bool {
             _ => false,
         }
     }
+
+    /// Returns `true` if the channel is disconnected.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(mpmc_channel)]
+    ///
+    /// use std::sync::mpmc::channel;
+    ///
+    /// let (tx, rx) = channel::<i32>();
+    /// assert!(!tx.is_disconnected());
+    /// drop(rx);
+    /// assert!(tx.is_disconnected());
+    /// ```
+    #[unstable(feature = "mpmc_channel", issue = "126840")]
+    pub fn is_disconnected(&self) -> bool {
+        match &self.flavor {
+            SenderFlavor::Array(chan) => chan.is_disconnected(),
+            SenderFlavor::List(chan) => chan.is_disconnected(),
+            SenderFlavor::Zero(chan) => chan.is_disconnected(),
+        }
+    }
 }
 
 #[unstable(feature = "mpmc_channel", issue = "126840")]
@@ -1349,6 +1372,29 @@ pub fn same_channel(&self, other: &Receiver<T>) -> bool {
     pub fn iter(&self) -> Iter<'_, T> {
         Iter { rx: self }
     }
+
+    /// Returns `true` if the channel is disconnected.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(mpmc_channel)]
+    ///
+    /// use std::sync::mpmc::channel;
+    ///
+    /// let (tx, rx) = channel::<i32>();
+    /// assert!(!rx.is_disconnected());
+    /// drop(tx);
+    /// assert!(rx.is_disconnected());
+    /// ```
+    #[unstable(feature = "mpmc_channel", issue = "126840")]
+    pub fn is_disconnected(&self) -> bool {
+        match &self.flavor {
+            ReceiverFlavor::Array(chan) => chan.is_disconnected(),
+            ReceiverFlavor::List(chan) => chan.is_disconnected(),
+            ReceiverFlavor::Zero(chan) => chan.is_disconnected(),
+        }
+    }
 }
 
 #[unstable(feature = "mpmc_channel", issue = "126840")]
diff --git a/library/std/src/sync/mpmc/zero.rs b/library/std/src/sync/mpmc/zero.rs
index f1ecf80fcb9f..c74346250192 100644
--- a/library/std/src/sync/mpmc/zero.rs
+++ b/library/std/src/sync/mpmc/zero.rs
@@ -316,4 +316,10 @@ pub(crate) fn is_empty(&self) -> bool {
     pub(crate) fn is_full(&self) -> bool {
         true
     }
+
+    /// Returns `true` if the channel is disconnected.
+    pub(crate) fn is_disconnected(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.is_disconnected
+    }
 }
diff --git a/library/std/src/sync/mpsc.rs b/library/std/src/sync/mpsc.rs
index 0ae23f6e13bf..81bb5849fb77 100644
--- a/library/std/src/sync/mpsc.rs
+++ b/library/std/src/sync/mpsc.rs
@@ -607,6 +607,25 @@ impl<T> Sender<T> {
     pub fn send(&self, t: T) -> Result<(), SendError<T>> {
         self.inner.send(t)
     }
+
+    /// Returns `true` if the channel is disconnected.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(mpsc_is_disconnected)]
+    ///
+    /// use std::sync::mpsc::channel;
+    ///
+    /// let (tx, rx) = channel::<i32>();
+    /// assert!(!tx.is_disconnected());
+    /// drop(rx);
+    /// assert!(tx.is_disconnected());
+    /// ```
+    #[unstable(feature = "mpsc_is_disconnected", issue = "none")]
+    pub fn is_disconnected(&self) -> bool {
+        self.inner.is_disconnected()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1038,6 +1057,25 @@ pub fn iter(&self) -> Iter<'_, T> {
     pub fn try_iter(&self) -> TryIter<'_, T> {
         TryIter { rx: self }
     }
+
+    /// Returns `true` if the channel is disconnected.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(mpsc_is_disconnected)]
+    ///
+    /// use std::sync::mpsc::channel;
+    ///
+    /// let (tx, rx) = channel::<i32>();
+    /// assert!(!rx.is_disconnected());
+    /// drop(tx);
+    /// assert!(rx.is_disconnected());
+    /// ```
+    #[unstable(feature = "mpsc_is_disconnected", issue = "none")]
+    pub fn is_disconnected(&self) -> bool {
+        self.inner.is_disconnected()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

From 3ecd18ca376b59e96db9b1daa8d14a4fe6856adc Mon Sep 17 00:00:00 2001
From: xtqqczze <45661989+xtqqczze@users.noreply.github.com>
Date: Mon, 23 Feb 2026 01:45:28 +0000
Subject: [PATCH 0103/1059] std: make `OsString::truncate` a no-op when `len >
 current_len`

Align `OsString::truncate` (and the underlying WTF-8 implementation) with `String::truncate` by making it a no-op when `len > self.len()`.

Previously, `OsString::truncate` would panic if `len > self.len()`, while `String::truncate` treats such cases as a no-op.
---
 library/alloc/src/wtf8/mod.rs   | 12 ++++++++----
 library/alloc/src/wtf8/tests.rs |  4 ++--
 library/std/src/ffi/os_str.rs   | 12 +++++++++---
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/library/alloc/src/wtf8/mod.rs b/library/alloc/src/wtf8/mod.rs
index e4834a24bf43..394c41bf3672 100644
--- a/library/alloc/src/wtf8/mod.rs
+++ b/library/alloc/src/wtf8/mod.rs
@@ -342,14 +342,18 @@ pub fn push(&mut self, code_point: CodePoint) {
 
     /// Shortens a string to the specified length.
     ///
+    /// If `new_len` is greater than the string's current length, this has no
+    /// effect.
+    ///
     /// # Panics
     ///
-    /// Panics if `new_len` > current length,
-    /// or if `new_len` is not a code point boundary.
+    /// Panics if `new_len` does not lie on a code point boundary.
     #[inline]
     pub fn truncate(&mut self, new_len: usize) {
-        assert!(self.is_code_point_boundary(new_len));
-        self.bytes.truncate(new_len)
+        if new_len <= self.len() {
+            assert!(self.is_code_point_boundary(new_len));
+            self.bytes.truncate(new_len)
+        }
     }
 
     /// Consumes the WTF-8 string and tries to convert it to a vec of bytes.
diff --git a/library/alloc/src/wtf8/tests.rs b/library/alloc/src/wtf8/tests.rs
index a72ad0837d11..79e0bbdef50f 100644
--- a/library/alloc/src/wtf8/tests.rs
+++ b/library/alloc/src/wtf8/tests.rs
@@ -308,10 +308,10 @@ fn wtf8buf_truncate_fail_code_point_boundary() {
 }
 
 #[test]
-#[should_panic]
-fn wtf8buf_truncate_fail_longer() {
+fn wtf8buf_truncate_invalid_len() {
     let mut string = Wtf8Buf::from_str("aé");
     string.truncate(4);
+    assert_eq!(string, Wtf8Buf::from_str("aé"));
 }
 
 #[test]
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index 6b4cf3cea831..3d1acc24918c 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -576,15 +576,21 @@ pub fn leak<'a>(self) -> &'a mut OsStr {
 
     /// Truncate the `OsString` to the specified length.
     ///
+    /// If `new_len` is greater than the string's current length, this has no
+    /// effect.
+    ///
     /// # Panics
+    ///
     /// Panics if `len` does not lie on a valid `OsStr` boundary
     /// (as described in [`OsStr::slice_encoded_bytes`]).
     #[inline]
     #[unstable(feature = "os_string_truncate", issue = "133262")]
     pub fn truncate(&mut self, len: usize) {
-        self.as_os_str().inner.check_public_boundary(len);
-        // SAFETY: The length was just checked to be at a valid boundary.
-        unsafe { self.inner.truncate_unchecked(len) };
+        if len <= self.len() {
+            self.as_os_str().inner.check_public_boundary(len);
+            // SAFETY: The length was just checked to be at a valid boundary.
+            unsafe { self.inner.truncate_unchecked(len) };
+        }
     }
 
     /// Provides plumbing to `Vec::extend_from_slice` without giving full

From feef7b4eafedfae6c8fd40caf711343b6cc3fe43 Mon Sep 17 00:00:00 2001
From: "LevitatingBusinessMan (Rein Fernhout)" <me@levitati.ng>
Date: Sat, 28 Feb 2026 19:52:50 +0100
Subject: [PATCH 0104/1059] warn of possible race condition in channel
 is_disconnected doc

---
 library/std/src/sync/mpmc/mod.rs | 8 ++++++++
 library/std/src/sync/mpsc.rs     | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/library/std/src/sync/mpmc/mod.rs b/library/std/src/sync/mpmc/mod.rs
index 6249e8a033e8..16ae8a88370b 100644
--- a/library/std/src/sync/mpmc/mod.rs
+++ b/library/std/src/sync/mpmc/mod.rs
@@ -626,6 +626,10 @@ pub fn same_channel(&self, other: &Sender<T>) -> bool {
 
     /// Returns `true` if the channel is disconnected.
     ///
+    /// Note that a return value of `false` does not guarantee the channel will
+    /// remain connected. The channel may be disconnected immediately after this method
+    /// returns, so a subsequent [`Sender::send`] may still fail with [`SendError`].
+    ///
     /// # Examples
     ///
     /// ```
@@ -1375,6 +1379,10 @@ pub fn iter(&self) -> Iter<'_, T> {
 
     /// Returns `true` if the channel is disconnected.
     ///
+    /// Note that a return value of `false` does not guarantee the channel will
+    /// remain connected. The channel may be disconnected immediately after this method
+    /// returns, so a subsequent [`Receiver::recv`] may still fail with [`RecvError`].
+    ///
     /// # Examples
     ///
     /// ```
diff --git a/library/std/src/sync/mpsc.rs b/library/std/src/sync/mpsc.rs
index 81bb5849fb77..2abf7bfe341d 100644
--- a/library/std/src/sync/mpsc.rs
+++ b/library/std/src/sync/mpsc.rs
@@ -610,6 +610,10 @@ pub fn send(&self, t: T) -> Result<(), SendError<T>> {
 
     /// Returns `true` if the channel is disconnected.
     ///
+    /// Note that a return value of `false` does not guarantee the channel will
+    /// remain connected. The channel may be disconnected immediately after this method
+    /// returns, so a subsequent [`Sender::send`] may still fail with [`SendError`].
+    ///
     /// # Examples
     ///
     /// ```
@@ -1060,6 +1064,10 @@ pub fn try_iter(&self) -> TryIter<'_, T> {
 
     /// Returns `true` if the channel is disconnected.
     ///
+    /// Note that a return value of `false` does not guarantee the channel will
+    /// remain connected. The channel may be disconnected immediately after this method
+    /// returns, so a subsequent [`Receiver::recv`] may still fail with [`RecvError`].
+    ///
     /// # Examples
     ///
     /// ```

From 8c93b88076d7f7c1957c75ba5916da98dce98078 Mon Sep 17 00:00:00 2001
From: Cathal Mullan <contact@cathal.dev>
Date: Sat, 28 Feb 2026 00:52:20 +0000
Subject: [PATCH 0105/1059] Extend x86 inline asm to support `ymm` and `zmm`
 vector registers

---
 example/std_example.rs | 72 ++++++++++++++++++++++++++++++++++++++++++
 src/inline_asm.rs      | 63 +++++++++++++++++++-----------------
 2 files changed, 106 insertions(+), 29 deletions(-)

diff --git a/example/std_example.rs b/example/std_example.rs
index 33db75f0943a..408c9b3dad0f 100644
--- a/example/std_example.rs
+++ b/example/std_example.rs
@@ -9,6 +9,8 @@
 )]
 #![allow(internal_features)]
 
+#[cfg(target_arch = "x86_64")]
+use std::arch::asm;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 use std::hint::black_box;
@@ -279,6 +281,17 @@ unsafe fn test_simd() {
 
         #[cfg(not(jit))]
         test_crc32();
+
+        #[cfg(not(jit))]
+        test_xmm_roundtrip();
+        #[cfg(not(jit))]
+        if is_x86_feature_detected!("avx") {
+            test_ymm_roundtrip();
+        }
+        #[cfg(not(jit))]
+        if is_x86_feature_detected!("avx512f") {
+            test_zmm_roundtrip();
+        }
     }
 }
 
@@ -576,6 +589,65 @@ unsafe fn test_mm_cvtps_ph() {
     assert_eq_m128i(r, e);
 }
 
+#[cfg(target_arch = "x86_64")]
+#[cfg(not(jit))]
+unsafe fn test_xmm_roundtrip() {
+    unsafe {
+        let input = [1u8; 16];
+        let mut output = [0u8; 16];
+
+        asm!(
+            "movups {xmm}, [{input}]",
+            "movups [{output}], {xmm}",
+            input = in(reg) input.as_ptr(),
+            output = in(reg) output.as_mut_ptr(),
+            xmm = out(xmm_reg) _,
+        );
+
+        assert_eq!(input, output);
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx")]
+#[cfg(not(jit))]
+unsafe fn test_ymm_roundtrip() {
+    unsafe {
+        let input = [1u8; 32];
+        let mut output = [0u8; 32];
+
+        asm!(
+            "vmovups {ymm}, [{input}]",
+            "vmovups [{output}], {ymm}",
+            input = in(reg) input.as_ptr(),
+            output = in(reg) output.as_mut_ptr(),
+            ymm = out(ymm_reg) _,
+        );
+
+        assert_eq!(input, output);
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx512f")]
+#[cfg(not(jit))]
+unsafe fn test_zmm_roundtrip() {
+    unsafe {
+        let input = [1u8; 64];
+        let mut output = [0u8; 64];
+
+        asm!(
+            "vmovups {zmm}, [{input}]",
+            "vmovups [{output}], {zmm}",
+            input = in(reg) input.as_ptr(),
+            output = in(reg) output.as_mut_ptr(),
+            zmm = out(zmm_reg) _,
+        );
+
+        assert_eq!(input, output);
+    }
+}
+
 fn test_checked_mul() {
     let u: Option<u8> = u8::from_str_radix("1000", 10).ok();
     assert_eq!(u, None);
diff --git a/src/inline_asm.rs b/src/inline_asm.rs
index ac0da06cbb8e..8f1bb0b471e6 100644
--- a/src/inline_asm.rs
+++ b/src/inline_asm.rs
@@ -548,22 +548,21 @@ fn generate_asm_wrapper(&self, asm_name: &str) -> String {
                             match self.arch {
                                 InlineAsmArch::X86_64 => match reg {
                                     InlineAsmReg::X86(reg)
-                                        if reg as u32 >= X86InlineAsmReg::xmm0 as u32
-                                            && reg as u32 <= X86InlineAsmReg::xmm15 as u32 =>
+                                        if matches!(
+                                            reg.reg_class(),
+                                            X86InlineAsmRegClass::xmm_reg
+                                                | X86InlineAsmRegClass::ymm_reg
+                                                | X86InlineAsmRegClass::zmm_reg
+                                        ) =>
                                     {
-                                        // rustc emits x0 rather than xmm0
-                                        let class = match *modifier {
-                                            None | Some('x') => "xmm",
-                                            Some('y') => "ymm",
-                                            Some('z') => "zmm",
-                                            _ => unreachable!(),
-                                        };
-                                        write!(
-                                            generated_asm,
-                                            "{class}{}",
-                                            reg as u32 - X86InlineAsmReg::xmm0 as u32
-                                        )
-                                        .unwrap();
+                                        // rustc emits x0/y0/z0 rather than xmm0/ymm0/zmm0
+                                        let name = reg.name();
+                                        if let Some(prefix) = modifier {
+                                            let index = &name[3..];
+                                            write!(generated_asm, "{prefix}mm{index}").unwrap();
+                                        } else {
+                                            write!(generated_asm, "{name}").unwrap();
+                                        }
                                     }
                                     _ => reg
                                         .emit(&mut generated_asm, InlineAsmArch::X86_64, *modifier)
@@ -716,12 +715,17 @@ fn save_register(
             InlineAsmArch::X86_64 => {
                 match reg {
                     InlineAsmReg::X86(reg)
-                        if reg as u32 >= X86InlineAsmReg::xmm0 as u32
-                            && reg as u32 <= X86InlineAsmReg::xmm15 as u32 =>
+                        if matches!(
+                            reg.reg_class(),
+                            X86InlineAsmRegClass::xmm_reg
+                                | X86InlineAsmRegClass::ymm_reg
+                                | X86InlineAsmRegClass::zmm_reg
+                        ) =>
                     {
-                        // rustc emits x0 rather than xmm0
-                        write!(generated_asm, "    movups [rbx+0x{:x}], ", offset.bytes()).unwrap();
-                        write!(generated_asm, "xmm{}", reg as u32 - X86InlineAsmReg::xmm0 as u32)
+                        // rustc emits x0/y0/z0 rather than xmm0/ymm0/zmm0
+                        let name = reg.name();
+                        let mov = if name.starts_with("xmm") { "movups" } else { "vmovups" };
+                        write!(generated_asm, "    {mov} [rbx+0x{:x}], {name}", offset.bytes())
                             .unwrap();
                     }
                     _ => {
@@ -761,16 +765,17 @@ fn restore_register(
             InlineAsmArch::X86_64 => {
                 match reg {
                     InlineAsmReg::X86(reg)
-                        if reg as u32 >= X86InlineAsmReg::xmm0 as u32
-                            && reg as u32 <= X86InlineAsmReg::xmm15 as u32 =>
+                        if matches!(
+                            reg.reg_class(),
+                            X86InlineAsmRegClass::xmm_reg
+                                | X86InlineAsmRegClass::ymm_reg
+                                | X86InlineAsmRegClass::zmm_reg
+                        ) =>
                     {
-                        // rustc emits x0 rather than xmm0
-                        write!(
-                            generated_asm,
-                            "    movups xmm{}",
-                            reg as u32 - X86InlineAsmReg::xmm0 as u32
-                        )
-                        .unwrap();
+                        // rustc emits x0/y0/z0 rather than xmm0/ymm0/zmm0
+                        let name = reg.name();
+                        let mov = if name.starts_with("xmm") { "movups" } else { "vmovups" };
+                        write!(generated_asm, "    {mov} {name}").unwrap();
                     }
                     _ => {
                         generated_asm.push_str("    mov ");

From d0a33abd4d65f59e7affdc85ef19f33a05e08304 Mon Sep 17 00:00:00 2001
From: Mahdi Ali-Raihan <asder8215@gmail.com>
Date: Fri, 6 Feb 2026 16:55:17 -0500
Subject: [PATCH 0106/1059] fixed VecDeque::splice() not filling the buffer
 correctly when resizing the buffer on start = end range

---
 .../alloc/src/collections/vec_deque/splice.rs | 47 ++++++++++++++++++-
 library/alloctests/tests/vec_deque.rs         | 13 +++++
 2 files changed, 58 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/collections/vec_deque/splice.rs b/library/alloc/src/collections/vec_deque/splice.rs
index d7b9a96291c3..b82f9fba7ceb 100644
--- a/library/alloc/src/collections/vec_deque/splice.rs
+++ b/library/alloc/src/collections/vec_deque/splice.rs
@@ -138,8 +138,48 @@ unsafe fn fill<I: Iterator<Item = T>>(&mut self, replace_with: &mut I) -> bool {
     /// self.deque must be valid.
     unsafe fn move_tail(&mut self, additional: usize) {
         let deque = unsafe { self.deque.as_mut() };
-        let tail_start = deque.len + self.drain_len;
-        deque.buf.reserve(tail_start + self.tail_len, additional);
+
+        // `Drain::new` modifies the deque's len (so does `Drain::fill` here)
+        // directly with the start bound of the range passed into
+        // `VecDeque::splice`. This causes a few different issue:
+        //     - Most notably, there will be a hole at the end of the
+        //       buffer when our buffer resizes in the case that our
+        //       data wraps around.
+        //     - We cannot use `VecDeque::reserve` directly because
+        //       how it reserves more space and updates the `VecDeque`'s
+        //       `head` field accordingly depends on the `VecDeque`'s
+        //       actual `len`.
+        //     - We cannot just directly modify `VecDeque`'s `len` and
+        //       and call `VecDeque::reserve` afterward because if
+        //       `VecDeque::reserve` panics on capacity overflow,
+        //       well now our `VecDeque`'s head does not get updated
+        //       and we still have a potential hole at the end of the
+        //       buffer.
+        // Therefore, we manually reserve additional space (if necessary)
+        // based on calculating the actual `len` of the `VecDeque` and adjust
+        // `VecDeque`'s len right *after* the panicking region of `VecDeque::reserve`
+        // (that is `RawVec` `reserve()` call)
+
+        let drain_start = deque.len;
+        let tail_start = drain_start + self.drain_len;
+
+        // Actual VecDeque's len = drain_start + tail_len + drain_len
+        let actual_len = drain_start + self.tail_len + self.drain_len;
+        let new_cap = actual_len.checked_add(additional).expect("capacity overflow");
+        let old_cap = deque.capacity();
+
+        if new_cap > old_cap {
+            deque.buf.reserve(actual_len, additional);
+            // If new_cap doesn't panic, we can safely set the `VecDeque` len to its
+            // actual len; this needs to be done in order to set deque.head correctly
+            // on `VecDeque::handle_capacity_increase`
+            deque.len = actual_len;
+            // SAFETY: this cannot panic since our internal buffer's new_cap should
+            // be bigger than the passed in old_cap
+            unsafe {
+                deque.handle_capacity_increase(old_cap);
+            }
+        }
 
         let new_tail_start = tail_start + additional;
         unsafe {
@@ -149,6 +189,9 @@ unsafe fn move_tail(&mut self, additional: usize) {
                 self.tail_len,
             );
         }
+
+        // revert the `VecDeque` len to what it was before
+        deque.len = drain_start;
         self.drain_len += additional;
     }
 }
diff --git a/library/alloctests/tests/vec_deque.rs b/library/alloctests/tests/vec_deque.rs
index 92853fe00fd6..91843dfd0058 100644
--- a/library/alloctests/tests/vec_deque.rs
+++ b/library/alloctests/tests/vec_deque.rs
@@ -2347,3 +2347,16 @@ fn test_splice_wrapping() {
 
     assert_eq!(Vec::from(vec), [7, 8, 9]);
 }
+
+#[test]
+fn test_splice_wrapping_and_resize() {
+    let mut vec = VecDeque::new();
+
+    for i in [1; 6] {
+        vec.push_front(i);
+    }
+
+    vec.splice(1..1, [2, 3, 4]);
+
+    assert_eq!(Vec::from(vec), [1, 2, 3, 4, 1, 1, 1, 1, 1])
+}

From e5250ec5eef76d00f3e708c108da24593fcc6a52 Mon Sep 17 00:00:00 2001
From: Ayush Singh <ayush@beagleboard.org>
Date: Sun, 1 Mar 2026 10:42:29 +0530
Subject: [PATCH 0107/1059] tools: remote-test-server: Add UEFI run support

Tested with OVMF on QEMU with Linux as the host running
remote-test-client. The instructions for running tests are provided
below:

1. Use rust-lld linker: `bootstrap.toml`

```toml
[rust]
lld = true

[target.x86_64-unknown-uefi]
linker = "rust-lld"
```

2. Use a custom startup.nsh script to auto-launch remote-test-server.
   This is optional.

```shell
fs1:
run.efi --sequential --bind "10.0.2.15:12345" --batch
```

3. Launch remote-test-server in QEMU. I am using uefi-run script [0].

```shell
uefi-run build/x86_64-unknown-linux-gnu/stage2-tools/x86_64-unknown-uefi/release/remote-test-server.efi  -n --startup startup.nsh --tcp-port 12345
```

4. Run tests:

```shell
RUST_TEST_THREADS=1 TEST_DEVICE_ADDR="localhost:12345" ./x.py test tests/ui/abi --target x86_64-unknown-uefi --stage 1
```

[0]: https://github.com/Ayush1325/dotfiles/blob/2d13056bf8ca1931a234b72967d9e857c4afbf1a/uefi/.local/bin/uefi-run

Signed-off-by: Ayush Singh <ayush@beagleboard.org>
---
 src/tools/remote-test-server/src/main.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tools/remote-test-server/src/main.rs b/src/tools/remote-test-server/src/main.rs
index c0820e4a6854..b4d30289cabb 100644
--- a/src/tools/remote-test-server/src/main.rs
+++ b/src/tools/remote-test-server/src/main.rs
@@ -123,6 +123,8 @@ fn main() {
     let listener = bind_socket(config.bind);
     let (work, tmp): (PathBuf, PathBuf) = if cfg!(target_os = "android") {
         ("/data/local/tmp/work".into(), "/data/local/tmp/work/tmp".into())
+    } else if cfg!(target_os = "uefi") {
+        ("tmp\\work".into(), "tmp\\work\\tmp".into())
     } else {
         let mut work_dir = env::temp_dir();
         work_dir.push("work");
@@ -274,6 +276,8 @@ fn handle_run(socket: TcpStream, work: &Path, tmp: &Path, lock: &Mutex<()>, conf
     } else if cfg!(target_vendor = "apple") {
         // On Apple platforms, the environment variable is named differently.
         "DYLD_LIBRARY_PATH"
+    } else if cfg!(target_os = "uefi") {
+        "path"
     } else {
         "LD_LIBRARY_PATH"
     };

From 5a9807742b1cf626ef730df1f9ca53097aa14b3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Sat, 28 Feb 2026 20:50:05 +0100
Subject: [PATCH 0108/1059] Mention `@bors squash` in squashing documentation

---
 src/doc/rustc-dev-guide/src/git.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/git.md b/src/doc/rustc-dev-guide/src/git.md
index bf31e79a9a15..34e419fa5225 100644
--- a/src/doc/rustc-dev-guide/src/git.md
+++ b/src/doc/rustc-dev-guide/src/git.md
@@ -383,6 +383,11 @@ Both the upside and downside of this is that it simplifies the history.
 On the one hand, you lose track of the steps in which changes were made, but
 the history becomes easier to work with.
 
+The easiest way to squash your commits in a PR on the `rust-lang/rust` repository is to use the `@bors squash` command in a comment on the PR. By default, [bors] combines all commit messages of the PR into the squashed commit message. To customize the commit message, use `@bors squash msg=<commit message>`.
+
+
+If you want to squash commits using local git operations, read on below.
+
 If there are no conflicts and you are just squashing to clean up the history,
 use `git rebase --interactive --keep-base main`.
 This keeps the fork point of your PR the same, making it easier to review the diff of what happened
@@ -410,11 +415,6 @@ because they only represent "fixups" and not real changes.
 For example,
 `git rebase --interactive HEAD~2` will allow you to edit the two commits only.
 
-For pull requests in `rust-lang/rust`, you can ask [bors] to squash by commenting
-`@bors squash` on the PR.
-By default, [bors] combines all commit messages in the PR.
-To customize the commit message, use `@bors squash [msg|message=<commit-message>]`.
-
 [bors]: https://github.com/rust-lang/bors
 
 ### `git range-diff`

From fd8bb2167640600d59ac9199a4ddeb1a2edf7f4f Mon Sep 17 00:00:00 2001
From: irelaxcn <irelaxcn@outlook.com>
Date: Mon, 2 Mar 2026 00:34:09 +0800
Subject: [PATCH 0109/1059] fix: `question_mark` suggestion caused error

---
 clippy_lints/src/question_mark.rs |  5 +++--
 tests/ui/question_mark.fixed      | 13 +++++++++++++
 tests/ui/question_mark.rs         | 19 +++++++++++++++++++
 tests/ui/question_mark.stderr     | 21 ++++++++++++++++++++-
 4 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 719f364357d3..e4bb3f13aea0 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -501,7 +501,8 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
 
         let mut applicability = Applicability::MachineApplicable;
         let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
-        let requires_semi = matches!(cx.tcx.parent_hir_node(expr.hir_id), Node::Stmt(_));
+        let parent = cx.tcx.parent_hir_node(expr.hir_id);
+        let requires_semi = matches!(parent, Node::Stmt(_)) || cx.typeck_results().expr_ty(expr).is_unit();
         let method_call_str = match by_ref {
             ByRef::Yes(_, Mutability::Mut) => ".as_mut()",
             ByRef::Yes(_, Mutability::Not) => ".as_ref()",
@@ -512,7 +513,7 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
             "{receiver_str}{method_call_str}?{}",
             if requires_semi { ";" } else { "" }
         );
-        if is_else_clause(cx.tcx, expr) {
+        if is_else_clause(cx.tcx, expr) || (requires_semi && !matches!(parent, Node::Stmt(_) | Node::Block(_))) {
             sugg = format!("{{ {sugg} }}");
         }
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 102517d34c61..e209da5c8258 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -524,3 +524,16 @@ fn issue16429(b: i32) -> Option<i32> {
 
     Some(0)
 }
+
+fn issue16654() -> Result<(), i32> {
+    let result = func_returning_result();
+
+    #[allow(clippy::collapsible_if)]
+    if true {
+        result?;
+    }
+
+    _ = [{ result?; }];
+
+    Ok(())
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index cfea1277fe76..579b51461d13 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -649,3 +649,22 @@ fn issue16429(b: i32) -> Option<i32> {
 
     Some(0)
 }
+
+fn issue16654() -> Result<(), i32> {
+    let result = func_returning_result();
+
+    #[allow(clippy::collapsible_if)]
+    if true {
+        if let Err(err) = result {
+            //~^ question_mark
+            return Err(err);
+        }
+    }
+
+    _ = [if let Err(err) = result {
+        //~^ question_mark
+        return Err(err);
+    }];
+
+    Ok(())
+}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index c243f12de040..1d7f665a2662 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -362,5 +362,24 @@ LL | |         return None;
 LL | |     };
    | |_____^ help: replace it with: `{ a? }`
 
-error: aborting due to 38 previous errors
+error: this block may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:658:9
+   |
+LL | /         if let Err(err) = result {
+LL | |
+LL | |             return Err(err);
+LL | |         }
+   | |_________^ help: replace it with: `result?;`
+
+error: this block may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:664:10
+   |
+LL |       _ = [if let Err(err) = result {
+   |  __________^
+LL | |
+LL | |         return Err(err);
+LL | |     }];
+   | |_____^ help: replace it with: `{ result?; }`
+
+error: aborting due to 40 previous errors
 

From 0b9fb671d8cef497beff74766ce1d14acedd6968 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 2 Mar 2026 04:40:37 +0000
Subject: [PATCH 0110/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to e7d90c695a39426baf5ae705de2f9570a72229de.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index b6e1b2bc55df..4dedd81b0066 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-c78a29473a68f07012904af11c92ecffa68fcc75
+e7d90c695a39426baf5ae705de2f9570a72229de

From affe60917ce26bb2dfc0d100bdbe29d5804fe17f Mon Sep 17 00:00:00 2001
From: Aelin Reidel <aelin@travitia.xyz>
Date: Mon, 2 Mar 2026 15:18:53 +0100
Subject: [PATCH 0111/1059] tests: codegen-llvm: iter-repeat-n-trivial-drop:
 Allow non-zero lower bound to __rust_alloc size

LLVM emits a lower bound of 8 for the size parameter to __rust_alloc
when targeting x86_64-unknown-hermit. Since that is also completely
valid, relax the lower bound check.
---
 tests/codegen-llvm/iter-repeat-n-trivial-drop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs b/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
index a4e5c885a139..98e906d852f7 100644
--- a/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
+++ b/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
@@ -47,7 +47,7 @@ pub fn iter_repeat_n_next(it: &mut std::iter::RepeatN<NotCopy>) -> Option<NotCop
 #[no_mangle]
 // CHECK-LABEL: @vec_extend_via_iter_repeat_n
 pub fn vec_extend_via_iter_repeat_n() -> Vec<u8> {
-    // CHECK: %[[ADDR:.+]] = tail call {{(noalias )?}}noundef dereferenceable_or_null(1234) ptr @{{.*}}__rust_alloc(i64 noundef {{(range\(i64 0, -9223372036854775808\) )?}}1234, i64 noundef {{(range\(i64 1, -9223372036854775807\) )?}}1)
+    // CHECK: %[[ADDR:.+]] = tail call {{(noalias )?}}noundef dereferenceable_or_null(1234) ptr @{{.*}}__rust_alloc(i64 noundef {{(range\(i64 [0-9]+, -9223372036854775808\) )?}}1234, i64 noundef {{(range\(i64 1, -9223372036854775807\) )?}}1)
     // CHECK: tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(1234) %[[ADDR]], i8 42, i64 1234,
 
     let n = 1234_usize;

From 022d6959d361a2cc6d5243307802d4f98ebf5780 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 27 Feb 2026 14:33:23 +0000
Subject: [PATCH 0112/1059] Use CompiledModules inside CodegenResults

In preparation for fully replacing CodegenResults with CompiledModules.
---
 src/driver/aot.rs | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/src/driver/aot.rs b/src/driver/aot.rs
index fc5c634d9570..7a736de967d2 100644
--- a/src/driver/aot.rs
+++ b/src/driver/aot.rs
@@ -10,9 +10,9 @@
 
 use cranelift_object::{ObjectBuilder, ObjectModule};
 use rustc_codegen_ssa::assert_module_sources::CguReuse;
-use rustc_codegen_ssa::back::write::{CompiledModules, produce_final_output_artifacts};
+use rustc_codegen_ssa::back::write::produce_final_output_artifacts;
 use rustc_codegen_ssa::base::determine_cgu_reuse;
-use rustc_codegen_ssa::{CodegenResults, CompiledModule, CrateInfo, ModuleKind};
+use rustc_codegen_ssa::{CodegenResults, CompiledModule, CompiledModules, CrateInfo, ModuleKind};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
@@ -126,15 +126,7 @@ pub(crate) fn join(
 
         produce_final_output_artifacts(sess, &compiled_modules, outputs);
 
-        (
-            CodegenResults {
-                crate_info: self.crate_info,
-
-                modules: compiled_modules.modules,
-                allocator_module: compiled_modules.allocator_module,
-            },
-            work_products,
-        )
+        (CodegenResults { compiled_modules, crate_info: self.crate_info }, work_products)
     }
 }
 

From 3047cffe9228d880b3720dd692d14730ff839d72 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 23 Oct 2025 15:33:06 +0000
Subject: [PATCH 0113/1059] Replace CodegenResults with CompiledModules

This is already CodegenResults without CrateInfo. The driver can
calculate the CrateInfo and pass it by-ref to the backend. Using
CompiledModules makes it a bit easier to move some other things out of
the backend as will be necessary for moving LTO to the link phase.
---
 src/driver/aot.rs | 15 +++------------
 src/driver/jit.rs | 13 +++++++------
 src/lib.rs        | 17 +++++++++++++----
 3 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/src/driver/aot.rs b/src/driver/aot.rs
index 7a736de967d2..79a321456808 100644
--- a/src/driver/aot.rs
+++ b/src/driver/aot.rs
@@ -12,7 +12,7 @@
 use rustc_codegen_ssa::assert_module_sources::CguReuse;
 use rustc_codegen_ssa::back::write::produce_final_output_artifacts;
 use rustc_codegen_ssa::base::determine_cgu_reuse;
-use rustc_codegen_ssa::{CodegenResults, CompiledModule, CompiledModules, CrateInfo, ModuleKind};
+use rustc_codegen_ssa::{CompiledModule, CompiledModules, ModuleKind};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
@@ -54,7 +54,6 @@ fn hash_stable(&self, _: &mut HCX, _: &mut StableHasher) {
 pub(crate) struct OngoingCodegen {
     modules: Vec<OngoingModuleCodegen>,
     allocator_module: Option<CompiledModule>,
-    crate_info: CrateInfo,
     concurrency_limiter: ConcurrencyLimiter,
 }
 
@@ -63,7 +62,7 @@ pub(crate) fn join(
         self,
         sess: &Session,
         outputs: &OutputFilenames,
-    ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
         let mut work_products = FxIndexMap::default();
         let mut modules = vec![];
         let disable_incr_cache = disable_incr_cache();
@@ -126,7 +125,7 @@ pub(crate) fn join(
 
         produce_final_output_artifacts(sess, &compiled_modules, outputs);
 
-        (CodegenResults { compiled_modules, crate_info: self.crate_info }, work_products)
+        (compiled_modules, work_products)
     }
 }
 
@@ -475,13 +474,6 @@ fn emit_allocator_module(tcx: TyCtxt<'_>) -> Option<CompiledModule> {
 }
 
 pub(crate) fn run_aot(tcx: TyCtxt<'_>) -> Box<OngoingCodegen> {
-    // FIXME handle `-Ctarget-cpu=native`
-    let target_cpu = match tcx.sess.opts.cg.target_cpu {
-        Some(ref name) => name,
-        None => tcx.sess.target.cpu.as_ref(),
-    }
-    .to_owned();
-
     let cgus = tcx.collect_and_partition_mono_items(()).codegen_units;
 
     if tcx.dep_graph.is_fully_enabled() {
@@ -541,7 +533,6 @@ pub(crate) fn run_aot(tcx: TyCtxt<'_>) -> Box<OngoingCodegen> {
     Box::new(OngoingCodegen {
         modules,
         allocator_module,
-        crate_info: CrateInfo::new(tcx, target_cpu),
         concurrency_limiter: concurrency_limiter.0,
     })
 }
diff --git a/src/driver/jit.rs b/src/driver/jit.rs
index 3a8ca25a5fc0..9bbc338a8e07 100644
--- a/src/driver/jit.rs
+++ b/src/driver/jit.rs
@@ -16,13 +16,14 @@
 use crate::prelude::*;
 use crate::unwind_module::UnwindModule;
 
-fn create_jit_module(tcx: TyCtxt<'_>) -> (UnwindModule<JITModule>, Option<DebugContext>) {
-    let crate_info = CrateInfo::new(tcx, "dummy_target_cpu".to_string());
-
+fn create_jit_module(
+    tcx: TyCtxt<'_>,
+    crate_info: &CrateInfo,
+) -> (UnwindModule<JITModule>, Option<DebugContext>) {
     let isa = crate::build_isa(tcx.sess, true);
     let mut jit_builder = JITBuilder::with_isa(isa, cranelift_module::default_libcall_names());
     crate::compiler_builtins::register_functions_for_jit(&mut jit_builder);
-    jit_builder.symbol_lookup_fn(dep_symbol_lookup_fn(tcx.sess, crate_info));
+    jit_builder.symbol_lookup_fn(dep_symbol_lookup_fn(tcx.sess, crate_info.clone()));
     let mut jit_module = UnwindModule::new(JITModule::new(jit_builder), false);
 
     let cx = DebugContext::new(tcx, jit_module.isa(), false, "dummy_cgu_name");
@@ -32,14 +33,14 @@ fn create_jit_module(tcx: TyCtxt<'_>) -> (UnwindModule<JITModule>, Option<DebugC
     (jit_module, cx)
 }
 
-pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
+pub(crate) fn run_jit(tcx: TyCtxt<'_>, crate_info: &CrateInfo, jit_args: Vec<String>) -> ! {
     if !tcx.crate_types().contains(&rustc_session::config::CrateType::Executable) {
         tcx.dcx().fatal("can't jit non-executable crate");
     }
 
     let output_filenames = tcx.output_filenames(());
     let should_write_ir = crate::pretty_clif::should_write_ir(tcx.sess);
-    let (mut jit_module, mut debug_context) = create_jit_module(tcx);
+    let (mut jit_module, mut debug_context) = create_jit_module(tcx, crate_info);
     let mut cached_context = Context::new();
 
     let cgus = tcx.collect_and_partition_mono_items(()).codegen_units;
diff --git a/src/lib.rs b/src/lib.rs
index 7bab07def63d..82c2e91b4b0f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -40,7 +40,7 @@
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_codegen::settings::{self, Configurable};
 use rustc_codegen_ssa::traits::CodegenBackend;
-use rustc_codegen_ssa::{CodegenResults, TargetConfig};
+use rustc_codegen_ssa::{CompiledModules, CrateInfo, TargetConfig};
 use rustc_log::tracing::info;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_session::Session;
@@ -200,12 +200,21 @@ fn print_version(&self) {
         println!("Cranelift version: {}", cranelift_codegen::VERSION);
     }
 
-    fn codegen_crate(&self, tcx: TyCtxt<'_>) -> Box<dyn Any> {
+    fn target_cpu(&self, sess: &Session) -> String {
+        // FIXME handle `-Ctarget-cpu=native`
+        match sess.opts.cg.target_cpu {
+            Some(ref name) => name,
+            None => sess.target.cpu.as_ref(),
+        }
+        .to_owned()
+    }
+
+    fn codegen_crate(&self, tcx: TyCtxt<'_>, _crate_info: &CrateInfo) -> Box<dyn Any> {
         info!("codegen crate {}", tcx.crate_name(LOCAL_CRATE));
         let config = self.config.get().unwrap();
         if config.jit_mode {
             #[cfg(feature = "jit")]
-            driver::jit::run_jit(tcx, config.jit_args.clone());
+            driver::jit::run_jit(tcx, _crate_info, config.jit_args.clone());
 
             #[cfg(not(feature = "jit"))]
             tcx.dcx().fatal("jit support was disabled when compiling rustc_codegen_cranelift");
@@ -219,7 +228,7 @@ fn join_codegen(
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
         outputs: &OutputFilenames,
-    ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
         ongoing_codegen.downcast::<driver::aot::OngoingCodegen>().unwrap().join(sess, outputs)
     }
 }

From 13ddff53be423b17615837846dc959592c32d93d Mon Sep 17 00:00:00 2001
From: Tim Neumann <timnn@google.com>
Date: Mon, 2 Mar 2026 21:06:11 +0100
Subject: [PATCH 0114/1059] Adapt codegen test to accept operand bundles

---
 tests/codegen-llvm/issues/issue-37945.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/tests/codegen-llvm/issues/issue-37945.rs b/tests/codegen-llvm/issues/issue-37945.rs
index 23d0eab8ae46..3167a045575a 100644
--- a/tests/codegen-llvm/issues/issue-37945.rs
+++ b/tests/codegen-llvm/issues/issue-37945.rs
@@ -1,5 +1,8 @@
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
 //@ ignore-32bit LLVM has a bug with them
+//@ revisions: new old
+//@ [old] max-llvm-major-version: 22
+//@ [new] min-llvm-version: 23
 
 // Check that LLVM understands that `Iter` pointer is not null. Issue #37945.
 
@@ -11,8 +14,9 @@
 pub fn is_empty_1(xs: Iter<f32>) -> bool {
     // CHECK-LABEL: @is_empty_1(
     // CHECK-NEXT:  start:
-    // CHECK-NEXT:    [[A:%.*]] = icmp ne ptr {{%xs.0|%xs.1}}, null
-    // CHECK-NEXT:    tail call void @llvm.assume(i1 [[A]])
+    // old-NEXT:    [[A:%.*]] = icmp ne ptr {{%xs.0|%xs.1}}, null
+    // old-NEXT:    tail call void @llvm.assume(i1 [[A]])
+    // new-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr {{%xs.0|%xs.1}}) ]
     // The order between %xs.0 and %xs.1 on the next line doesn't matter
     // and different LLVM versions produce different order.
     // CHECK-NEXT:    [[B:%.*]] = icmp eq ptr {{%xs.0, %xs.1|%xs.1, %xs.0}}
@@ -24,8 +28,9 @@ pub fn is_empty_1(xs: Iter<f32>) -> bool {
 pub fn is_empty_2(xs: Iter<f32>) -> bool {
     // CHECK-LABEL: @is_empty_2
     // CHECK-NEXT:  start:
-    // CHECK-NEXT:    [[C:%.*]] = icmp ne ptr {{%xs.0|%xs.1}}, null
-    // CHECK-NEXT:    tail call void @llvm.assume(i1 [[C]])
+    // old-NEXT:    [[C:%.*]] = icmp ne ptr {{%xs.0|%xs.1}}, null
+    // old-NEXT:    tail call void @llvm.assume(i1 [[C]])
+    // new-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr {{%xs.0|%xs.1}}) ]
     // The order between %xs.0 and %xs.1 on the next line doesn't matter
     // and different LLVM versions produce different order.
     // CHECK-NEXT:    [[D:%.*]] = icmp eq ptr {{%xs.0, %xs.1|%xs.1, %xs.0}}

From f5a2bb6263ad332ceb2d9b3b82afe935259a7723 Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Mon, 2 Mar 2026 20:28:16 +0000
Subject: [PATCH 0115/1059] Add hygiene annotations for tokens in macro_rules!
 bodies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`-Zunpretty=expanded,hygiene` was not printing syntax context annotations
for identifiers and lifetimes inside `macro_rules!` bodies. These tokens
are printed via `print_tt()` → `token_to_string_ext()`, which converts
tokens to strings without calling `ann_post()`. This meant that
macro-generated `macro_rules!` definitions with hygienic metavar
parameters (e.g. multiple `$marg` distinguished only by hygiene) were
printed with no way to tell them apart.

This was fixed by adding a match on `token.kind` in `print_tt()` to call
`ann_post()` for `Ident`, `NtIdent`, `Lifetime`, and `NtLifetime`
tokens, matching how `print_ident()` and `print_lifetime()` already
handle AST-level identifiers and lifetimes.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 17 ++++++
 .../hygiene/unpretty-debug-lifetimes.stdout   |  8 +--
 tests/ui/hygiene/unpretty-debug-metavars.rs   | 25 +++++++++
 .../ui/hygiene/unpretty-debug-metavars.stdout | 52 +++++++++++++++++++
 tests/ui/hygiene/unpretty-debug.stdout        | 10 +++-
 tests/ui/proc-macro/meta-macro-hygiene.stdout |  5 +-
 .../nonterminal-token-hygiene.stdout          | 17 ++++--
 7 files changed, 122 insertions(+), 12 deletions(-)
 create mode 100644 tests/ui/hygiene/unpretty-debug-metavars.rs
 create mode 100644 tests/ui/hygiene/unpretty-debug-metavars.stdout

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index f4168301bc5d..7d963dd2037c 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -735,6 +735,23 @@ fn print_tt(&mut self, tt: &TokenTree, convert_dollar_crate: bool) -> Spacing {
             TokenTree::Token(token, spacing) => {
                 let token_str = self.token_to_string_ext(token, convert_dollar_crate);
                 self.word(token_str);
+                // Emit hygiene annotations for identity-bearing tokens,
+                // matching how print_ident() and print_lifetime() call ann_post().
+                match token.kind {
+                    token::Ident(name, _) => {
+                        self.ann_post(Ident::new(name, token.span));
+                    }
+                    token::NtIdent(ident, _) => {
+                        self.ann_post(ident);
+                    }
+                    token::Lifetime(name, _) => {
+                        self.ann_post(Ident::new(name, token.span));
+                    }
+                    token::NtLifetime(ident, _) => {
+                        self.ann_post(ident);
+                    }
+                    _ => {}
+                }
                 if let token::DocComment(..) = token.kind {
                     self.hardbreak()
                 }
diff --git a/tests/ui/hygiene/unpretty-debug-lifetimes.stdout b/tests/ui/hygiene/unpretty-debug-lifetimes.stdout
index 28a5c70a02d7..689453326c0b 100644
--- a/tests/ui/hygiene/unpretty-debug-lifetimes.stdout
+++ b/tests/ui/hygiene/unpretty-debug-lifetimes.stdout
@@ -7,15 +7,17 @@
 // Don't break whenever Symbol numbering changes
 //@ normalize-stdout: "\d+#" -> "0#"
 
-#![feature /* 0#0 */(decl_macro)]
-#![feature /* 0#0 */(no_core)]
+#![feature /* 0#0 */(decl_macro /* 0#0 */)]
+#![feature /* 0#0 */(no_core /* 0#0 */)]
 #![no_core /* 0#0 */]
 
 macro lifetime_hygiene
     /*
     0#0
     */ {
-    ($f:ident<$a:lifetime>) => { fn $f<$a, 'a>() {} }
+    ($f /* 0#0 */:ident /* 0#0 */<$a /* 0#0 */:lifetime /* 0#0 */>)
+    =>
+    { fn /* 0#0 */ $f /* 0#0 */<$a /* 0#0 */, 'a /* 0#0 */>() {} }
 }
 fn f /* 0#0 */<'a /* 0#0 */, 'a /* 0#1 */>() {}
 
diff --git a/tests/ui/hygiene/unpretty-debug-metavars.rs b/tests/ui/hygiene/unpretty-debug-metavars.rs
new file mode 100644
index 000000000000..a0c47bec3ccf
--- /dev/null
+++ b/tests/ui/hygiene/unpretty-debug-metavars.rs
@@ -0,0 +1,25 @@
+//@ check-pass
+//@ compile-flags: -Zunpretty=expanded,hygiene
+
+// Regression test: metavar parameters in macro-generated macro_rules!
+// definitions should have hygiene annotations so that textually identical
+// `$marg` bindings are distinguishable by their syntax contexts.
+
+// Don't break whenever Symbol numbering changes
+//@ normalize-stdout: "\d+#" -> "0#"
+
+#![feature(no_core)]
+#![no_core]
+
+macro_rules! make_macro {
+    (@inner $name:ident ($dol:tt) $a:ident) => {
+        macro_rules! $name {
+            ($dol $a : expr, $dol marg : expr) => {}
+        }
+    };
+    ($name:ident) => {
+        make_macro!{@inner $name ($) marg}
+    };
+}
+
+make_macro!(add2);
diff --git a/tests/ui/hygiene/unpretty-debug-metavars.stdout b/tests/ui/hygiene/unpretty-debug-metavars.stdout
new file mode 100644
index 000000000000..307c5e1b8de9
--- /dev/null
+++ b/tests/ui/hygiene/unpretty-debug-metavars.stdout
@@ -0,0 +1,52 @@
+//@ check-pass
+//@ compile-flags: -Zunpretty=expanded,hygiene
+
+// Regression test: metavar parameters in macro-generated macro_rules!
+// definitions should have hygiene annotations so that textually identical
+// `$marg` bindings are distinguishable by their syntax contexts.
+
+// Don't break whenever Symbol numbering changes
+//@ normalize-stdout: "\d+#" -> "0#"
+
+#![feature /* 0#0 */(no_core /* 0#0 */)]
+#![no_core /* 0#0 */]
+
+macro_rules! make_macro
+    /*
+    0#0
+    */ {
+    (@inner /* 0#0 */ $name /* 0#0 */:ident /* 0#0
+    */($dol /* 0#0 */:tt /* 0#0 */) $a /* 0#0 */:ident /* 0#0 */)
+    =>
+    {
+        macro_rules /* 0#0 */! $name /* 0#0 */
+        {
+            ($dol /* 0#0 */ $a /* 0#0 */ : expr /* 0#0 */, $dol /*
+            0#0 */ marg /* 0#0 */ : expr /* 0#0 */) => {}
+        }
+    }; ($name /* 0#0 */:ident /* 0#0 */) =>
+    {
+        make_macro /* 0#0
+        */!{@inner /* 0#0 */ $name /* 0#0 */($) marg /* 0#0 */}
+    };
+}
+macro_rules! add2
+    /*
+    0#0
+    */ {
+    ($ marg /* 0#1 */ : expr /* 0#2 */, $marg /* 0#2 */ : expr /*
+    0#2 */) => {}
+}
+
+
+/*
+Expansions:
+crate0::{{expn0}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Root
+crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "make_macro")
+crate0::{{expn2}}: parent: crate0::{{expn1}}, call_site_ctxt: #1, def_site_ctxt: #0, kind: Macro(Bang, "make_macro")
+
+SyntaxContexts:
+#0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
+#1: parent: #0, outer_mark: (crate0::{{expn1}}, SemiOpaque)
+#2: parent: #0, outer_mark: (crate0::{{expn2}}, SemiOpaque)
+*/
diff --git a/tests/ui/hygiene/unpretty-debug.stdout b/tests/ui/hygiene/unpretty-debug.stdout
index f35bd7a7cb2c..ac6051e2d542 100644
--- a/tests/ui/hygiene/unpretty-debug.stdout
+++ b/tests/ui/hygiene/unpretty-debug.stdout
@@ -5,10 +5,16 @@
 //@ normalize-stdout: "\d+#" -> "0#"
 
 // minimal junk
-#![feature /* 0#0 */(no_core)]
+#![feature /* 0#0 */(no_core /* 0#0 */)]
 #![no_core /* 0#0 */]
 
-macro_rules! foo /* 0#0 */ { ($x: ident) => { y + $x } }
+macro_rules! foo
+    /*
+    0#0
+    */ {
+    ($x /* 0#0 */: ident /* 0#0 */) =>
+    { y /* 0#0 */ + $x /* 0#0 */ }
+}
 
 fn bar /* 0#0 */() {
     let x /* 0#0 */ = 1;
diff --git a/tests/ui/proc-macro/meta-macro-hygiene.stdout b/tests/ui/proc-macro/meta-macro-hygiene.stdout
index b5db9922b31a..a03e567bd48a 100644
--- a/tests/ui/proc-macro/meta-macro-hygiene.stdout
+++ b/tests/ui/proc-macro/meta-macro-hygiene.stdout
@@ -1,7 +1,7 @@
 Def site: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4)
 Input: TokenStream [Ident { ident: "$crate", span: $DIR/meta-macro-hygiene.rs:26:37: 26:43 (#3) }, Punct { ch: ':', spacing: Joint, span: $DIR/meta-macro-hygiene.rs:26:43: 26:44 (#3) }, Punct { ch: ':', spacing: Alone, span: $DIR/meta-macro-hygiene.rs:26:44: 26:45 (#3) }, Ident { ident: "dummy", span: $DIR/meta-macro-hygiene.rs:26:45: 26:50 (#3) }, Punct { ch: '!', spacing: Alone, span: $DIR/meta-macro-hygiene.rs:26:50: 26:51 (#3) }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/meta-macro-hygiene.rs:26:51: 26:53 (#3) }]
 Respanned: TokenStream [Ident { ident: "$crate", span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }, Punct { ch: ':', spacing: Joint, span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }, Punct { ch: ':', spacing: Alone, span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }, Ident { ident: "dummy", span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }, Punct { ch: '!', spacing: Alone, span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/auxiliary/make-macro.rs:7:9: 7:56 (#4) }]
-#![feature /* 0#0 */(prelude_import)]
+#![feature /* 0#0 */(prelude_import /* 0#0 */)]
 //@ aux-build:make-macro.rs
 //@ proc-macro: meta-macro.rs
 //@ edition:2018
@@ -30,7 +30,8 @@ macro_rules! produce_it
     */ {
     () =>
     {
-        meta_macro::print_def_site!($crate::dummy!());
+        meta_macro /* 0#0 */::print_def_site /* 0#0
+        */!($crate /* 0#0 */::dummy /* 0#0 */!());
         // `print_def_site!` will respan the `$crate` identifier
         // with `Span::def_site()`. This should cause it to resolve
         // relative to `meta_macro`, *not* `make_macro` (despite
diff --git a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
index e45abab03b4c..61b55782e6e9 100644
--- a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
+++ b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
@@ -20,7 +20,7 @@ PRINT-BANG INPUT (DEBUG): TokenStream [
         span: $DIR/nonterminal-token-hygiene.rs:23:27: 23:32 (#4),
     },
 ]
-#![feature /* 0#0 */(prelude_import)]
+#![feature /* 0#0 */(prelude_import /* 0#0 */)]
 #![no_std /* 0#0 */]
 // Make sure that marks from declarative macros are applied to tokens in nonterminal.
 
@@ -34,7 +34,7 @@ PRINT-BANG INPUT (DEBUG): TokenStream [
 //@ proc-macro: test-macros.rs
 //@ edition: 2015
 
-#![feature /* 0#0 */(decl_macro)]
+#![feature /* 0#0 */(decl_macro /* 0#0 */)]
 #![no_std /* 0#0 */]
 extern crate core /* 0#2 */;
 #[prelude_import /* 0#1 */]
@@ -49,15 +49,22 @@ macro_rules! outer
     /*
     0#0
     */ {
-    ($item:item) =>
+    ($item /* 0#0 */:item /* 0#0 */) =>
     {
-        macro inner() { print_bang! { $item } } inner!();
+        macro /* 0#0 */ inner /* 0#0 */()
+        { print_bang /* 0#0 */! { $item /* 0#0 */ } } inner /* 0#0
+        */!();
 
     };
 }
 
 struct S /* 0#0 */;
-macro inner /* 0#3 */ { () => { print_bang! { struct S; } } }
+macro inner
+    /*
+    0#3
+    */ {
+    () => { print_bang /* 0#3 */! { struct /* 0#0 */ S /* 0#0 */; } }
+}
 
 struct S /* 0#5 */;
 // OK, not a duplicate definition of `S`

From cf6e7bcf5946bdae784a47aebed56083c97caa6a Mon Sep 17 00:00:00 2001
From: Cathal Mullan <contact@cathal.dev>
Date: Mon, 2 Mar 2026 20:32:29 +0000
Subject: [PATCH 0116/1059] Add leading underscore to asm symbols on Mach-O

---
 src/global_asm.rs | 16 ++++++++++++++--
 src/inline_asm.rs |  8 +++++++-
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/global_asm.rs b/src/global_asm.rs
index 1daf428acf76..b14988577845 100644
--- a/src/global_asm.rs
+++ b/src/global_asm.rs
@@ -120,9 +120,15 @@ fn codegen_global_asm_inner<'tcx>(
                         }
 
                         let symbol = tcx.symbol_name(instance);
+                        let symbol_name = if tcx.sess.target.is_like_darwin {
+                            format!("_{}", symbol.name)
+                        } else {
+                            symbol.name.to_owned()
+                        };
+
                         // FIXME handle the case where the function was made private to the
                         // current codegen unit
-                        global_asm.push_str(&escape_symbol_name(tcx, symbol.name, span));
+                        global_asm.push_str(&escape_symbol_name(tcx, &symbol_name, span));
                     }
                     GlobalAsmOperandRef::SymStatic { def_id } => {
                         if cfg!(not(feature = "inline_asm_sym")) {
@@ -134,7 +140,13 @@ fn codegen_global_asm_inner<'tcx>(
 
                         let instance = Instance::mono(tcx, def_id);
                         let symbol = tcx.symbol_name(instance);
-                        global_asm.push_str(&escape_symbol_name(tcx, symbol.name, span));
+                        let symbol_name = if tcx.sess.target.is_like_darwin {
+                            format!("_{}", symbol.name)
+                        } else {
+                            symbol.name.to_owned()
+                        };
+
+                        global_asm.push_str(&escape_symbol_name(tcx, &symbol_name, span));
                     }
                 }
             }
diff --git a/src/inline_asm.rs b/src/inline_asm.rs
index 8f1bb0b471e6..044243f2c716 100644
--- a/src/inline_asm.rs
+++ b/src/inline_asm.rs
@@ -574,7 +574,13 @@ fn generate_asm_wrapper(&self, asm_name: &str) -> String {
                         CInlineAsmOperand::Const { ref value } => {
                             generated_asm.push_str(value);
                         }
-                        CInlineAsmOperand::Symbol { ref symbol } => generated_asm.push_str(symbol),
+                        CInlineAsmOperand::Symbol { ref symbol } => {
+                            if binary_format == BinaryFormat::Macho {
+                                generated_asm.push('_');
+                            }
+
+                            generated_asm.push_str(symbol);
+                        }
                     }
                 }
             }

From 6d6493a7986e66e3a99b41b3f563f83faa4fd2b0 Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Mon, 3 Nov 2025 17:24:53 +0100
Subject: [PATCH 0117/1059] tweak r-a default settings

1. Explain that you need to make paths absolute in helix settings
2. Use the correct compiler (set `RUSTC` and `CARGO` to stage0, instead
   of `RUSTUP_TOOLCHAIN=nightly`)
3. Add comments to vscode and zed settings
---
 src/bootstrap/src/core/build_steps/setup.rs |  3 +++
 src/etc/rust_analyzer_helix.toml            |  8 ++++++--
 src/etc/rust_analyzer_settings.json         | 14 +++++++++++++-
 src/etc/rust_analyzer_zed.json              | 14 +++++++++++++-
 4 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 7dfd566a58cc..f4e6a20ec849 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -607,6 +607,7 @@ fn hashes(&self) -> &'static [&'static str] {
                 "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
                 "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
                 "cb653043852d9d5ff4a5be56407b859ff9928be055ad3f307eb309aad04765e6",
+                "e28b1930d16d3d8bbdeed7bd4a995613e648b49e08c9b6f5271880f520637fed",
             ],
             EditorKind::Vim | EditorKind::VsCode => &[
                 "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
@@ -626,6 +627,7 @@ fn hashes(&self) -> &'static [&'static str] {
                 "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
                 "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
                 "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
+                "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd",
             ],
             EditorKind::Zed => &[
                 "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
@@ -636,6 +638,7 @@ fn hashes(&self) -> &'static [&'static str] {
                 "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
                 "74420c13094b530a986b37c4f1d23cb58c0e8e2295f5858ded129fb1574e66f9",
                 "2d3b592c089b2ad2c528686a1e371af49922edad1c59accd5d5f31612a441568",
+                "0767a2398ccc253274b184adbb9e018ce931bd0ef45baad06dad19b652c52951",
             ],
         }
     }
diff --git a/src/etc/rust_analyzer_helix.toml b/src/etc/rust_analyzer_helix.toml
index c9ee1ca181d5..ae2c2d906488 100644
--- a/src/etc/rust_analyzer_helix.toml
+++ b/src/etc/rust_analyzer_helix.toml
@@ -9,6 +9,9 @@
 # x fmt --check
 # ```
 # (if that doesn't work -- do `x clean` first)
+#
+# NOTE: helix doesn't support getting workspace root in configs, for this config
+# to work replace WORKSPACE_ROOT with the path to your rustc checkout
 
 [language-server.rust-analyzer.config]
 linkedProjects = [
@@ -33,7 +36,7 @@ overrideCommand = [
 
 [language-server.rust-analyzer.config.rustfmt]
 overrideCommand = [
-    "build/host/rustfmt/bin/rustfmt",
+    "WORKSPACE_ROOT/build/host/rustfmt/bin/rustfmt",
     "--edition=2024"
 ]
 
@@ -64,7 +67,8 @@ overrideCommand = [
 ]
 
 [language-server.rust-analyzer.environment]
-RUSTUP_TOOLCHAIN = "nightly"
+RUSTC = "WORKSPACE_ROOT/build/host/stage0/bin/rustc"
+CARGO = "WORKSPACE_ROOT/build/host/stage0/bin/cargo"
 
 [[language]]
 name = "rust"
diff --git a/src/etc/rust_analyzer_settings.json b/src/etc/rust_analyzer_settings.json
index 8e94fbaa163e..ea5bb544c700 100644
--- a/src/etc/rust_analyzer_settings.json
+++ b/src/etc/rust_analyzer_settings.json
@@ -1,3 +1,14 @@
+// This config uses a separate build directory for rust-analyzer,
+// so that r-a's checks don't block user `x` commands and vice-verse.
+// R-a's build directory is located in `build-rust-analyzer`.
+//
+// To download rustfmt and proc macro server for r-a run the following command
+// (proc macro server is downloaded automatically with pretty much any command,
+// this specific one also downloads rustfmt):
+// ```
+// x fmt --check
+// ```
+// (if that doesn't work -- do `x clean` first)
 {
     "git.detectSubmodulesLimit": 20,
     "rust-analyzer.linkedProjects": [
@@ -40,7 +51,8 @@
         "build-rust-analyzer"
     ],
     "rust-analyzer.server.extraEnv": {
-        "RUSTUP_TOOLCHAIN": "nightly"
+        "RUSTC": "${workspaceFolder}/build/host/stage0/bin/rustc",
+        "CARGO": "${workspaceFolder}/build/host/stage0/bin/cargo"
     },
     "files.associations": {
         "*.fixed": "rust",
diff --git a/src/etc/rust_analyzer_zed.json b/src/etc/rust_analyzer_zed.json
index df1f7334556c..e69800c0624d 100644
--- a/src/etc/rust_analyzer_zed.json
+++ b/src/etc/rust_analyzer_zed.json
@@ -1,3 +1,14 @@
+// This config uses a separate build directory for rust-analyzer,
+// so that r-a's checks don't block user `x` commands and vice-verse.
+// R-a's build directory is located in `build-rust-analyzer`.
+//
+// To download rustfmt and proc macro server for r-a run the following command
+// (proc macro server is downloaded automatically with pretty much any command,
+// this specific one also downloads rustfmt):
+// ```
+// x fmt --check
+// ```
+// (if that doesn't work -- do `x clean` first)
 {
   "lsp": {
     "rust-analyzer": {
@@ -55,7 +66,8 @@
         },
         "server": {
           "extraEnv": {
-            "RUSTUP_TOOLCHAIN": "nightly"
+            "RUSTC": "build/host/stage0/bin/rustc",
+            "CARGO": "build/host/stage0/bin/cargo"
           }
         }
       }

From bf6db4f345799e1f922b3109a7278d8be11f3058 Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Tue, 3 Mar 2026 13:06:55 +0000
Subject: [PATCH 0118/1059] Add regression tests for token hygiene annotations
 in macro bodies

Add `unpretty-debug-shadow` test covering macro body tokens that
reference a shadowed variable, and simplify the `unpretty-debug-metavars`
test macro.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 tests/ui/hygiene/unpretty-debug-metavars.rs   |  7 +++--
 .../ui/hygiene/unpretty-debug-metavars.stdout |  7 +++--
 tests/ui/hygiene/unpretty-debug-shadow.rs     | 20 +++++++++++++
 tests/ui/hygiene/unpretty-debug-shadow.stdout | 30 +++++++++++++++++++
 4 files changed, 58 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/hygiene/unpretty-debug-shadow.rs
 create mode 100644 tests/ui/hygiene/unpretty-debug-shadow.stdout

diff --git a/tests/ui/hygiene/unpretty-debug-metavars.rs b/tests/ui/hygiene/unpretty-debug-metavars.rs
index a0c47bec3ccf..41bf75cd0d98 100644
--- a/tests/ui/hygiene/unpretty-debug-metavars.rs
+++ b/tests/ui/hygiene/unpretty-debug-metavars.rs
@@ -1,9 +1,10 @@
 //@ check-pass
 //@ compile-flags: -Zunpretty=expanded,hygiene
 
-// Regression test: metavar parameters in macro-generated macro_rules!
-// definitions should have hygiene annotations so that textually identical
-// `$marg` bindings are distinguishable by their syntax contexts.
+// Regression test for token hygiene annotations in -Zunpretty=expanded,hygiene
+// Previously, metavar parameters in macro-generated macro_rules! definitions
+// were missing hygiene annotations, making identical `$marg` bindings
+// indistinguishable.
 
 // Don't break whenever Symbol numbering changes
 //@ normalize-stdout: "\d+#" -> "0#"
diff --git a/tests/ui/hygiene/unpretty-debug-metavars.stdout b/tests/ui/hygiene/unpretty-debug-metavars.stdout
index 307c5e1b8de9..89658bc909a1 100644
--- a/tests/ui/hygiene/unpretty-debug-metavars.stdout
+++ b/tests/ui/hygiene/unpretty-debug-metavars.stdout
@@ -1,9 +1,10 @@
 //@ check-pass
 //@ compile-flags: -Zunpretty=expanded,hygiene
 
-// Regression test: metavar parameters in macro-generated macro_rules!
-// definitions should have hygiene annotations so that textually identical
-// `$marg` bindings are distinguishable by their syntax contexts.
+// Regression test for token hygiene annotations in -Zunpretty=expanded,hygiene
+// Previously, metavar parameters in macro-generated macro_rules! definitions
+// were missing hygiene annotations, making identical `$marg` bindings
+// indistinguishable.
 
 // Don't break whenever Symbol numbering changes
 //@ normalize-stdout: "\d+#" -> "0#"
diff --git a/tests/ui/hygiene/unpretty-debug-shadow.rs b/tests/ui/hygiene/unpretty-debug-shadow.rs
new file mode 100644
index 000000000000..2aa68c8aec11
--- /dev/null
+++ b/tests/ui/hygiene/unpretty-debug-shadow.rs
@@ -0,0 +1,20 @@
+//@ check-pass
+//@ compile-flags: -Zunpretty=expanded,hygiene
+
+// Regression test for token hygiene annotations in -Zunpretty=expanded,hygiene
+// Previously, tokens in macro_rules! bodies were missing hygiene annotations,
+// making it impossible to see how a macro's reference to a shadowed variable
+// is distinguished from the shadowing binding.
+
+// Don't break whenever Symbol numbering changes
+//@ normalize-stdout: "\d+#" -> "0#"
+
+#![feature(no_core)]
+#![no_core]
+
+fn f() {
+    let x = 0;
+    macro_rules! use_x { () => { x }; }
+    let x = 1;
+    use_x!();
+}
diff --git a/tests/ui/hygiene/unpretty-debug-shadow.stdout b/tests/ui/hygiene/unpretty-debug-shadow.stdout
new file mode 100644
index 000000000000..36076b6a968f
--- /dev/null
+++ b/tests/ui/hygiene/unpretty-debug-shadow.stdout
@@ -0,0 +1,30 @@
+//@ check-pass
+//@ compile-flags: -Zunpretty=expanded,hygiene
+
+// Regression test for token hygiene annotations in -Zunpretty=expanded,hygiene
+// Previously, tokens in macro_rules! bodies were missing hygiene annotations,
+// making it impossible to see how a macro's reference to a shadowed variable
+// is distinguished from the shadowing binding.
+
+// Don't break whenever Symbol numbering changes
+//@ normalize-stdout: "\d+#" -> "0#"
+
+#![feature /* 0#0 */(no_core /* 0#0 */)]
+#![no_core /* 0#0 */]
+
+fn f /* 0#0 */() {
+    let x /* 0#0 */ = 0;
+    macro_rules! use_x /* 0#0 */ { () => { x /* 0#0 */ }; }
+    let x /* 0#0 */ = 1;
+    x /* 0#1 */;
+}
+
+/*
+Expansions:
+crate0::{{expn0}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Root
+crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "use_x")
+
+SyntaxContexts:
+#0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
+#1: parent: #0, outer_mark: (crate0::{{expn1}}, SemiOpaque)
+*/

From e0637766029752d6d9a2aaf088edbc469b4f66a0 Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Wed, 4 Mar 2026 01:00:11 +0100
Subject: [PATCH 0119/1059] Fix LegacyKeyValueFormat report from docker build:
 powerpc

---
 src/ci/docker/host-x86_64/dist-powerpc-linux/Dockerfile    | 4 ++--
 .../docker/host-x86_64/dist-powerpc64-linux-gnu/Dockerfile | 4 ++--
 .../host-x86_64/dist-powerpc64-linux-musl/Dockerfile       | 7 +++----
 .../host-x86_64/dist-powerpc64le-linux-gnu/Dockerfile      | 7 +++----
 .../host-x86_64/dist-powerpc64le-linux-musl/Dockerfile     | 7 +++----
 5 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-powerpc-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-powerpc-linux/Dockerfile
index 7081d9527f06..825392414671 100644
--- a/src/ci/docker/host-x86_64/dist-powerpc-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-powerpc-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=powerpc-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --enable-profiler --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --enable-profiler --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-powerpc64-linux-gnu/Dockerfile b/src/ci/docker/host-x86_64/dist-powerpc64-linux-gnu/Dockerfile
index 046406224c34..ad0e21019017 100644
--- a/src/ci/docker/host-x86_64/dist-powerpc64-linux-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-powerpc64-linux-gnu/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=powerpc64-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --enable-profiler --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --enable-profiler --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-powerpc64-linux-musl/Dockerfile b/src/ci/docker/host-x86_64/dist-powerpc64-linux-musl/Dockerfile
index 7c8a1e657ac2..17783b9c7358 100644
--- a/src/ci/docker/host-x86_64/dist-powerpc64-linux-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-powerpc64-linux-musl/Dockerfile
@@ -27,13 +27,12 @@ ENV \
 
 ENV HOSTS=powerpc64-unknown-linux-musl
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
     --enable-full-tools \
     --enable-profiler \
     --enable-sanitizers \
     --disable-docs \
     --set target.powerpc64-unknown-linux-musl.crt-static=false \
-    --musl-root-powerpc64=/x-tools/powerpc64-unknown-linux-musl/powerpc64-unknown-linux-musl/sysroot/usr
+    --musl-root-powerpc64=/x-tools/powerpc64-unknown-linux-musl/powerpc64-unknown-linux-musl/sysroot/usr"
 
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-powerpc64le-linux-gnu/Dockerfile b/src/ci/docker/host-x86_64/dist-powerpc64le-linux-gnu/Dockerfile
index e3ba51e8ffce..6a9573cb4231 100644
--- a/src/ci/docker/host-x86_64/dist-powerpc64le-linux-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-powerpc64le-linux-gnu/Dockerfile
@@ -27,11 +27,10 @@ ENV \
 
 ENV HOSTS=powerpc64le-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
     --enable-full-tools \
     --enable-profiler \
     --enable-sanitizers \
-    --disable-docs
+    --disable-docs"
 
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-powerpc64le-linux-musl/Dockerfile b/src/ci/docker/host-x86_64/dist-powerpc64le-linux-musl/Dockerfile
index 601c8e905858..be16966fbe1b 100644
--- a/src/ci/docker/host-x86_64/dist-powerpc64le-linux-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-powerpc64le-linux-musl/Dockerfile
@@ -27,13 +27,12 @@ ENV \
 
 ENV HOSTS=powerpc64le-unknown-linux-musl
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
     --enable-full-tools \
     --enable-profiler \
     --enable-sanitizers \
     --disable-docs \
     --set target.powerpc64le-unknown-linux-musl.crt-static=false \
-    --musl-root-powerpc64le=/x-tools/powerpc64le-unknown-linux-musl/powerpc64le-unknown-linux-musl/sysroot/usr
+    --musl-root-powerpc64le=/x-tools/powerpc64le-unknown-linux-musl/powerpc64le-unknown-linux-musl/sysroot/usr"
 
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"

From 1b86d31ae236d7e7e1fd2ed46be491fd38af2b17 Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Wed, 4 Mar 2026 01:25:25 +0100
Subject: [PATCH 0120/1059] Fix LegacyKeyValueFormat report from docker build:
 dist-x86_64

---
 .../host-x86_64/dist-x86_64-freebsd/Dockerfile      |  7 +++----
 .../host-x86_64/dist-x86_64-illumos/Dockerfile      |  4 ++--
 .../docker/host-x86_64/dist-x86_64-linux/Dockerfile | 13 ++++++-------
 .../docker/host-x86_64/dist-x86_64-musl/Dockerfile  |  7 +++----
 .../host-x86_64/dist-x86_64-netbsd/Dockerfile       |  4 ++--
 .../host-x86_64/dist-x86_64-solaris/Dockerfile      |  4 ++--
 6 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile
index f42e6f770ebe..e62aa74662be 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile
@@ -35,10 +35,9 @@ ENV \
 
 ENV HOSTS=x86_64-unknown-freebsd
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-full-tools \
+ENV RUST_CONFIGURE_ARGS="--enable-full-tools \
     --enable-extended \
     --enable-profiler \
     --enable-sanitizers \
-    --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+    --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-illumos/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-illumos/Dockerfile
index 37a8dc56a5fa..0675c3cafd9e 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-illumos/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-illumos/Dockerfile
@@ -36,5 +36,5 @@ ENV \
 
 ENV HOSTS=x86_64-unknown-illumos
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python2.7 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python2.7 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
index cb5747876199..b168c739c979 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
@@ -80,8 +80,7 @@ ENV PGO_HOST=x86_64-unknown-linux-gnu
 
 ENV HOSTS=x86_64-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS \
-      --enable-full-tools \
+ENV RUST_CONFIGURE_ARGS="--enable-full-tools \
       --enable-sanitizers \
       --enable-profiler \
       --enable-compiler-docs \
@@ -94,23 +93,23 @@ ENV RUST_CONFIGURE_ARGS \
       --set rust.jemalloc \
       --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
-      --set rust.codegen-units=1
+      --set rust.codegen-units=1"
 
 COPY host-x86_64/dist-x86_64-linux/dist.sh /scripts/
 COPY host-x86_64/dist-x86_64-linux/dist-alt.sh /scripts/
 
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
+ENV SCRIPT="Must specify DOCKER_SCRIPT for this image"
 
 ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER=clang
 
 # This is the only builder which will create source tarballs
-ENV DIST_SRC 1
+ENV DIST_SRC="1"
 
 # When we build cargo in this container, we don't want it to use the system
 # libcurl, instead it should compile its own.
-ENV LIBCURL_NO_PKG_CONFIG 1
+ENV LIBCURL_NO_PKG_CONFIG="1"
 
-ENV DIST_REQUIRE_ALL_TOOLS 1
+ENV DIST_REQUIRE_ALL_TOOLS="1"
 
 # FIXME: Without this, LLVMgold.so incorrectly resolves to the system
 # libstdc++, instead of the one we build.
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile
index 32b5058bce70..68f914a81552 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile
@@ -35,14 +35,13 @@ RUN sh /scripts/sccache.sh
 
 ENV HOSTS=x86_64-unknown-linux-musl
 
-ENV RUST_CONFIGURE_ARGS \
-      --musl-root-x86_64=/usr/local/x86_64-linux-musl \
+ENV RUST_CONFIGURE_ARGS="--musl-root-x86_64=/usr/local/x86_64-linux-musl \
       --enable-extended \
       --enable-sanitizers \
       --enable-profiler \
       --enable-lld \
       --set target.x86_64-unknown-linux-musl.crt-static=false \
-      --build $HOSTS
+      --build $HOSTS"
 
 # Newer binutils broke things on some vms/distros (i.e., linking against
 # unknown relocs disabled by the following flag), so we need to go out of our
@@ -54,4 +53,4 @@ ENV CFLAGS_x86_64_unknown_linux_musl="-Wa,-mrelax-relocations=no -Wa,--compress-
     -Wl,--compress-debug-sections=none"
 
 # To run native tests replace `dist` below with `test`
-ENV SCRIPT python3 ../x.py dist --build $HOSTS
+ENV SCRIPT="python3 ../x.py dist --build $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-netbsd/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-netbsd/Dockerfile
index effdc99d9a65..3bb2c7433e03 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-netbsd/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-netbsd/Dockerfile
@@ -22,5 +22,5 @@ ENV \
 
 ENV HOSTS=x86_64-unknown-netbsd
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-solaris/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-solaris/Dockerfile
index 4d77f0aad26b..b11e8cdeaa73 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-solaris/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-solaris/Dockerfile
@@ -32,5 +32,5 @@ ENV \
 
 ENV HOSTS=x86_64-pc-solaris
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"

From bf69dfa024c670e0f8f6d38dd1cde385959117c9 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 4 Mar 2026 10:51:22 +0000
Subject: [PATCH 0121/1059] Rustup to rustc 1.96.0-nightly (d9563937f
 2026-03-03)

---
 patches/0027-stdlib-128bit-atomic-operations.patch | 13 +------------
 rust-toolchain.toml                                |  2 +-
 2 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/patches/0027-stdlib-128bit-atomic-operations.patch b/patches/0027-stdlib-128bit-atomic-operations.patch
index 38bb43f8204b..b7276e43153b 100644
--- a/patches/0027-stdlib-128bit-atomic-operations.patch
+++ b/patches/0027-stdlib-128bit-atomic-operations.patch
@@ -37,16 +37,7 @@ diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
 index bf2b6d59f88..d5ccce03bbf 100644
 --- a/library/core/src/sync/atomic.rs
 +++ b/library/core/src/sync/atomic.rs
-@@ -300,8 +300,6 @@ impl_atomic_primitive!(AtomicI32(i32), size("32"), align(4));
- impl_atomic_primitive!(AtomicU32(u32), size("32"), align(4));
- impl_atomic_primitive!(AtomicI64(i64), size("64"), align(8));
- impl_atomic_primitive!(AtomicU64(u64), size("64"), align(8));
--impl_atomic_primitive!(AtomicI128(i128), size("128"), align(16));
--impl_atomic_primitive!(AtomicU128(u128), size("128"), align(16));
- 
- #[cfg(target_pointer_width = "16")]
- impl_atomic_primitive!(AtomicIsize(isize), size("ptr"), align(2));
-@@ -3585,44 +3585,6 @@ pub const fn as_ptr(&self) -> *mut $int_type {
+@@ -3585,42 +3585,6 @@ pub const fn as_ptr(&self) -> *mut $int_type {
      8,
      u64 AtomicU64
  }
@@ -62,7 +53,6 @@ index bf2b6d59f88..d5ccce03bbf 100644
 -    unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
--    rustc_diagnostic_item = "AtomicI128",
 -    "i128",
 -    "#![feature(integer_atomics)]\n\n",
 -    atomic_min, atomic_max,
@@ -81,7 +71,6 @@ index bf2b6d59f88..d5ccce03bbf 100644
 -    unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
--    rustc_diagnostic_item = "AtomicU128",
 -    "u128",
 -    "#![feature(integer_atomics)]\n\n",
 -    atomic_umin, atomic_umax,
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 85b1cf4d6117..44ae84d9ac69 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-02-24"
+channel = "nightly-2026-03-04"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From dd9922151fc6546580c0b5d7316d6b097d87c63a Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Tue, 3 Mar 2026 18:12:21 -0800
Subject: [PATCH 0122/1059] refactor(autodiff): Simplify rlib dep handling; use
 fn_ptr_ty in `adjust_activity_to_abi`, drop mono-collection &
 cross-crate-inline workarounds

---
 .../src/builder/autodiff.rs                   | 18 +++----
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  4 +-
 .../src/cross_crate_inline.rs                 |  5 --
 compiler/rustc_monomorphize/src/collector.rs  |  5 --
 .../src/collector/autodiff.rs                 | 50 -------------------
 5 files changed, 11 insertions(+), 71 deletions(-)
 delete mode 100644 compiler/rustc_monomorphize/src/collector/autodiff.rs

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index f8f6439a7b0e..1cefdaae5ebd 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -6,7 +6,7 @@
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir::attrs::RustcAutodiff;
-use rustc_middle::ty::{Instance, PseudoCanonicalInput, TyCtxt, TypingEnv};
+use rustc_middle::ty::{PseudoCanonicalInput, Ty, TyCtxt, TypingEnv};
 use rustc_middle::{bug, ty};
 use rustc_target::callconv::PassMode;
 use tracing::debug;
@@ -18,25 +18,23 @@
 
 pub(crate) fn adjust_activity_to_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
-    instance: Instance<'tcx>,
+    fn_ptr_ty: Ty<'tcx>,
     typing_env: TypingEnv<'tcx>,
     da: &mut ThinVec<DiffActivity>,
 ) {
-    let fn_ty = instance.ty(tcx, typing_env);
-
-    if !matches!(fn_ty.kind(), ty::FnDef(..)) {
-        bug!("expected fn def for autodiff, got {:?}", fn_ty);
+    if !matches!(fn_ptr_ty.kind(), ty::FnPtr(..)) {
+        bug!("expected fn ptr for autodiff, got {:?}", fn_ptr_ty);
     }
 
     // We don't actually pass the types back into the type system.
     // All we do is decide how to handle the arguments.
-    let sig = fn_ty.fn_sig(tcx).skip_binder();
+    let fn_sig = fn_ptr_ty.fn_sig(tcx);
+    let sig = fn_sig.skip_binder();
 
     // FIXME(Sa4dUs): pass proper varargs once we have support for differentiating variadic functions
-    let Ok(fn_abi) =
-        tcx.fn_abi_of_instance(typing_env.as_query_input((instance, ty::List::empty())))
+    let Ok(fn_abi) = tcx.fn_abi_of_fn_ptr(typing_env.as_query_input((fn_sig, ty::List::empty())))
     else {
-        bug!("failed to get fn_abi of instance with empty varargs");
+        bug!("failed to get fn_abi of fn_ptr with empty varargs");
     };
 
     let mut new_activities = vec![];
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index cf088ed50909..47ba227735a4 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1374,9 +1374,11 @@ fn codegen_autodiff<'ll, 'tcx>(
         bug!("could not find autodiff attrs")
     };
 
+    let fn_ptr_ty =
+        Ty::new_fn_ptr(tcx, fn_source.ty(tcx, TypingEnv::fully_monomorphized()).fn_sig(tcx));
     adjust_activity_to_abi(
         tcx,
-        fn_source,
+        fn_ptr_ty,
         TypingEnv::fully_monomorphized(),
         &mut diff_attrs.input_activity,
     );
diff --git a/compiler/rustc_mir_transform/src/cross_crate_inline.rs b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
index 19ffffdd1eca..53aa5f450dbb 100644
--- a/compiler/rustc_mir_transform/src/cross_crate_inline.rs
+++ b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
@@ -35,11 +35,6 @@ fn cross_crate_inlinable(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
         return true;
     }
 
-    // FIXME(autodiff): replace this as per discussion in https://github.com/rust-lang/rust/pull/149033#discussion_r2535465880
-    if find_attr!(tcx, def_id, RustcAutodiff(..)) {
-        return true;
-    }
-
     if find_attr!(tcx, def_id, RustcIntrinsic) {
         // Intrinsic fallback bodies are always cross-crate inlineable.
         // To ensure that the MIR inliner doesn't cluelessly try to inline fallback
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 3aa55cc8eb9f..3b1b5ba9673a 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -205,8 +205,6 @@
 //! this is not implemented however: a mono item will be produced
 //! regardless of whether it is actually needed or not.
 
-mod autodiff;
-
 use std::cell::OnceCell;
 use std::ops::ControlFlow;
 
@@ -240,7 +238,6 @@
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument, trace};
 
-use crate::collector::autodiff::collect_autodiff_fn;
 use crate::errors::{
     self, EncounteredErrorWhileInstantiating, EncounteredErrorWhileInstantiatingGlobalAsm,
     NoOptimizedMir, RecursionLimit,
@@ -990,8 +987,6 @@ fn visit_instance_use<'tcx>(
         return;
     }
     if let Some(intrinsic) = tcx.intrinsic(instance.def_id()) {
-        collect_autodiff_fn(tcx, instance, intrinsic, output);
-
         if let Some(_requirement) = ValidityRequirement::from_intrinsic(intrinsic.name) {
             // The intrinsics assert_inhabited, assert_zero_valid, and assert_mem_uninitialized_valid will
             // be lowered in codegen to nothing or a call to panic_nounwind. So if we encounter any
diff --git a/compiler/rustc_monomorphize/src/collector/autodiff.rs b/compiler/rustc_monomorphize/src/collector/autodiff.rs
deleted file mode 100644
index 67d4b8c8afff..000000000000
--- a/compiler/rustc_monomorphize/src/collector/autodiff.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use rustc_middle::bug;
-use rustc_middle::ty::{self, GenericArg, IntrinsicDef, TyCtxt};
-
-use crate::collector::{MonoItems, create_fn_mono_item};
-
-// Here, we force both primal and diff function to be collected in
-// mono so this does not interfere in `autodiff` intrinsics
-// codegen process. If they are unused, LLVM will remove them when
-// compiling with O3.
-// FIXME(autodiff): Remove this whole file, as per discussion in
-// https://github.com/rust-lang/rust/pull/149033#discussion_r2535465880
-pub(crate) fn collect_autodiff_fn<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    instance: ty::Instance<'tcx>,
-    intrinsic: IntrinsicDef,
-    output: &mut MonoItems<'tcx>,
-) {
-    if intrinsic.name != rustc_span::sym::autodiff {
-        return;
-    };
-
-    collect_autodiff_fn_from_arg(instance.args[0], tcx, output);
-}
-
-fn collect_autodiff_fn_from_arg<'tcx>(
-    arg: GenericArg<'tcx>,
-    tcx: TyCtxt<'tcx>,
-    output: &mut MonoItems<'tcx>,
-) {
-    let (instance, span) = match arg.kind() {
-        ty::GenericArgKind::Type(ty) => match *ty.kind() {
-            ty::FnDef(def_id, substs) => {
-                let span = tcx.def_span(def_id);
-                let instance = ty::Instance::expect_resolve(
-                    tcx,
-                    ty::TypingEnv::non_body_analysis(tcx, def_id),
-                    def_id,
-                    substs,
-                    span,
-                );
-
-                (instance, span)
-            }
-            _ => bug!("expected autodiff function"),
-        },
-        _ => bug!("expected type when matching autodiff arg"),
-    };
-
-    output.push(create_fn_mono_item(tcx, instance, span));
-}

From 8a3d0f48677f111d85450e0634d8ecaacc16269b Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Wed, 4 Mar 2026 03:20:03 -0800
Subject: [PATCH 0123/1059] refactor(autodiff): Cast primal to fn ptr, drop
 Instance::try_resolve for source

---
 compiler/rustc_builtin_macros/src/autodiff.rs | 53 +++++++++++++++++--
 compiler/rustc_codegen_llvm/src/intrinsic.rs  | 32 ++---------
 tests/pretty/autodiff/autodiff_forward.pp     | 43 +++++++++------
 tests/pretty/autodiff/autodiff_reverse.pp     | 15 ++++--
 tests/pretty/autodiff/inherent_impl.pp        |  4 +-
 5 files changed, 93 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 2a0175043b6f..f18326328f41 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -20,7 +20,7 @@ mod llvm_enzyme {
     };
     use rustc_expand::base::{Annotatable, ExtCtxt};
     use rustc_hir::attrs::RustcAutodiff;
-    use rustc_span::{Ident, Span, Symbol, sym};
+    use rustc_span::{Ident, Span, Symbol, kw, sym};
     use thin_vec::{ThinVec, thin_vec};
     use tracing::{debug, trace};
 
@@ -197,7 +197,7 @@ pub(crate) fn expand_reverse(
     /// }
     /// #[rustc_autodiff(Reverse, Duplicated, Active)]
     /// fn cos_box(x: &Box<f32>, dx: &mut Box<f32>, dret: f32) -> f32 {
-    ///     std::intrinsics::autodiff(sin::<>, cos_box::<>, (x, dx, dret))
+    ///     std::intrinsics::autodiff(sin::<> as fn(..) -> .., cos_box::<>, (x, dx, dret))
     /// }
     /// ```
     /// FIXME(ZuseZ4): Once autodiff is enabled by default, make this a doc comment which is checked
@@ -326,6 +326,7 @@ pub(crate) fn expand_with_mode(
                 primal,
                 first_ident(&meta_item_vec[0]),
                 span,
+                &sig,
                 &d_sig,
                 &generics,
                 impl_of_trait,
@@ -496,18 +497,62 @@ fn assure_mut_ref(ty: &ast::Ty) -> ast::Ty {
 
     // Generate `autodiff` intrinsic call
     // ```
-    // std::intrinsics::autodiff(source, diff, (args))
+    // std::intrinsics::autodiff(source as fn(..) -> .., diff, (args))
     // ```
     fn call_autodiff(
         ecx: &ExtCtxt<'_>,
         primal: Ident,
         diff: Ident,
         span: Span,
+        p_sig: &FnSig,
         d_sig: &FnSig,
         generics: &Generics,
         is_impl: bool,
     ) -> rustc_ast::Stmt {
         let primal_path_expr = gen_turbofish_expr(ecx, primal, generics, span, is_impl);
+
+        let self_ty = || ecx.ty_path(ast::Path::from_ident(Ident::with_dummy_span(kw::SelfUpper)));
+        let fn_ptr_params: ThinVec<ast::Param> = p_sig
+            .decl
+            .inputs
+            .iter()
+            .map(|param| {
+                let ty = match &param.ty.kind {
+                    TyKind::ImplicitSelf => self_ty(),
+                    TyKind::Ref(lt, mt) if matches!(mt.ty.kind, TyKind::ImplicitSelf) => ecx.ty(
+                        span,
+                        TyKind::Ref(lt.clone(), ast::MutTy { ty: self_ty(), mutbl: mt.mutbl }),
+                    ),
+                    TyKind::Ptr(mt) if matches!(mt.ty.kind, TyKind::ImplicitSelf) => {
+                        ecx.ty(span, TyKind::Ptr(ast::MutTy { ty: self_ty(), mutbl: mt.mutbl }))
+                    }
+                    _ => param.ty.clone(),
+                };
+                ast::Param {
+                    attrs: ast::AttrVec::new(),
+                    ty,
+                    pat: Box::new(ecx.pat_wild(span)),
+                    id: ast::DUMMY_NODE_ID,
+                    span,
+                    is_placeholder: false,
+                }
+            })
+            .collect();
+        let fn_ptr_ty = ecx.ty(
+            span,
+            TyKind::FnPtr(Box::new(ast::FnPtrTy {
+                safety: p_sig.header.safety,
+                ext: p_sig.header.ext,
+                generic_params: ThinVec::new(),
+                decl: Box::new(ast::FnDecl {
+                    inputs: fn_ptr_params,
+                    output: p_sig.decl.output.clone(),
+                }),
+                decl_span: span,
+            })),
+        );
+        let primal_fn_ptr = ecx.expr(span, ast::ExprKind::Cast(primal_path_expr, fn_ptr_ty));
+
         let diff_path_expr = gen_turbofish_expr(ecx, diff, generics, span, is_impl);
 
         let tuple_expr = ecx.expr_tuple(
@@ -529,7 +574,7 @@ fn call_autodiff(
         let call_expr = ecx.expr_call(
             span,
             ecx.expr_path(enzyme_path),
-            vec![primal_path_expr, diff_path_expr, tuple_expr].into(),
+            vec![primal_fn_ptr, diff_path_expr, tuple_expr].into(),
         );
 
         ecx.stmt_expr(call_expr)
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 47ba227735a4..8c7d6997bf83 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1323,29 +1323,8 @@ fn codegen_autodiff<'ll, 'tcx>(
     let ret_ty = sig.output();
     let llret_ty = bx.layout_of(ret_ty).llvm_type(bx);
 
-    // Get source, diff, and attrs
-    let (source_id, source_args) = match fn_args.into_type_list(tcx)[0].kind() {
-        ty::FnDef(def_id, source_params) => (def_id, source_params),
-        _ => bug!("invalid autodiff intrinsic args"),
-    };
-
-    let fn_source = match Instance::try_resolve(tcx, bx.cx.typing_env(), *source_id, source_args) {
-        Ok(Some(instance)) => instance,
-        Ok(None) => bug!(
-            "could not resolve ({:?}, {:?}) to a specific autodiff instance",
-            source_id,
-            source_args
-        ),
-        Err(_) => {
-            // An error has already been emitted
-            return;
-        }
-    };
-
-    let source_symbol = symbol_name_for_instance_in_crate(tcx, fn_source.clone(), LOCAL_CRATE);
-    let Some(fn_to_diff) = bx.cx.get_function(&source_symbol) else {
-        bug!("could not find source function")
-    };
+    let source_fn_ptr_ty = fn_args.into_type_list(tcx)[0];
+    let fn_to_diff = args[0].immediate();
 
     let (diff_id, diff_args) = match fn_args.into_type_list(tcx)[1].kind() {
         ty::FnDef(def_id, diff_args) => (def_id, diff_args),
@@ -1374,17 +1353,14 @@ fn codegen_autodiff<'ll, 'tcx>(
         bug!("could not find autodiff attrs")
     };
 
-    let fn_ptr_ty =
-        Ty::new_fn_ptr(tcx, fn_source.ty(tcx, TypingEnv::fully_monomorphized()).fn_sig(tcx));
     adjust_activity_to_abi(
         tcx,
-        fn_ptr_ty,
+        source_fn_ptr_ty,
         TypingEnv::fully_monomorphized(),
         &mut diff_attrs.input_activity,
     );
 
-    let fnc_tree =
-        rustc_middle::ty::fnc_typetrees(tcx, fn_source.ty(tcx, TypingEnv::fully_monomorphized()));
+    let fnc_tree = rustc_middle::ty::fnc_typetrees(tcx, source_fn_ptr_ty);
 
     // Build body
     generate_enzyme_call(
diff --git a/tests/pretty/autodiff/autodiff_forward.pp b/tests/pretty/autodiff/autodiff_forward.pp
index c64da3f60884..746754637f5c 100644
--- a/tests/pretty/autodiff/autodiff_forward.pp
+++ b/tests/pretty/autodiff/autodiff_forward.pp
@@ -35,7 +35,8 @@ pub fn f1(x: &[f64], y: f64) -> f64 {
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Dual)]
 pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {
-    ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f1::<> as fn(_: &[f64], _: f64) -> f64,
+        df1::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f2(x: &[f64], y: f64) -> f64 {
@@ -43,7 +44,8 @@ pub fn f2(x: &[f64], y: f64) -> f64 {
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df2(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::autodiff(f2::<>, df2::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f2::<> as fn(_: &[f64], _: f64) -> f64,
+        df2::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f3(x: &[f64], y: f64) -> f64 {
@@ -51,27 +53,33 @@ pub fn f3(x: &[f64], y: f64) -> f64 {
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df3(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::autodiff(f3::<>, df3::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f3::<> as fn(_: &[f64], _: f64) -> f64,
+        df3::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f4() {}
 #[rustc_autodiff(Forward, 1, None)]
-pub fn df4() -> () { ::core::intrinsics::autodiff(f4::<>, df4::<>, ()) }
+pub fn df4() -> () {
+    ::core::intrinsics::autodiff(f4::<> as fn(), df4::<>, ())
+}
 #[rustc_autodiff]
 pub fn f5(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Const, Dual, Const)]
 pub fn df5_y(x: &[f64], y: f64, by_0: f64) -> f64 {
-    ::core::intrinsics::autodiff(f5::<>, df5_y::<>, (x, y, by_0))
+    ::core::intrinsics::autodiff(f5::<> as fn(_: &[f64], _: f64) -> f64,
+        df5_y::<>, (x, y, by_0))
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df5_x(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::autodiff(f5::<>, df5_x::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f5::<> as fn(_: &[f64], _: f64) -> f64,
+        df5_x::<>, (x, bx_0, y))
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df5_rev(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::autodiff(f5::<>, df5_rev::<>, (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f5::<> as fn(_: &[f64], _: f64) -> f64,
+        df5_rev::<>, (x, dx_0, y, dret))
 }
 struct DoesNotImplDefault;
 #[rustc_autodiff]
@@ -80,13 +88,14 @@ pub fn f6() -> DoesNotImplDefault {
 }
 #[rustc_autodiff(Forward, 1, Const)]
 pub fn df6() -> DoesNotImplDefault {
-    ::core::intrinsics::autodiff(f6::<>, df6::<>, ())
+    ::core::intrinsics::autodiff(f6::<> as fn() -> DoesNotImplDefault,
+        df6::<>, ())
 }
 #[rustc_autodiff]
 pub fn f7(x: f32) -> () {}
 #[rustc_autodiff(Forward, 1, Const, None)]
 pub fn df7(x: f32) -> () {
-    ::core::intrinsics::autodiff(f7::<>, df7::<>, (x,))
+    ::core::intrinsics::autodiff(f7::<> as fn(_: f32) -> (), df7::<>, (x,))
 }
 #[no_mangle]
 #[rustc_autodiff]
@@ -94,29 +103,32 @@ fn f8(x: &f32) -> f32 { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Forward, 4, Dual, Dual)]
 fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
     -> [f32; 5usize] {
-    ::core::intrinsics::autodiff(f8::<>, f8_3::<>,
+    ::core::intrinsics::autodiff(f8::<> as fn(_: &f32) -> f32, f8_3::<>,
         (x, bx_0, bx_1, bx_2, bx_3))
 }
 #[rustc_autodiff(Forward, 4, Dual, DualOnly)]
 fn f8_2(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
     -> [f32; 4usize] {
-    ::core::intrinsics::autodiff(f8::<>, f8_2::<>,
+    ::core::intrinsics::autodiff(f8::<> as fn(_: &f32) -> f32, f8_2::<>,
         (x, bx_0, bx_1, bx_2, bx_3))
 }
 #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
 fn f8_1(x: &f32, bx_0: &f32) -> f32 {
-    ::core::intrinsics::autodiff(f8::<>, f8_1::<>, (x, bx_0))
+    ::core::intrinsics::autodiff(f8::<> as fn(_: &f32) -> f32, f8_1::<>,
+        (x, bx_0))
 }
 pub fn f9() {
     #[rustc_autodiff]
     fn inner(x: f32) -> f32 { x * x }
     #[rustc_autodiff(Forward, 1, Dual, Dual)]
     fn d_inner_2(x: f32, bx_0: f32) -> (f32, f32) {
-        ::core::intrinsics::autodiff(inner::<>, d_inner_2::<>, (x, bx_0))
+        ::core::intrinsics::autodiff(inner::<> as fn(_: f32) -> f32,
+            d_inner_2::<>, (x, bx_0))
     }
     #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
     fn d_inner_1(x: f32, bx_0: f32) -> f32 {
-        ::core::intrinsics::autodiff(inner::<>, d_inner_1::<>, (x, bx_0))
+        ::core::intrinsics::autodiff(inner::<> as fn(_: f32) -> f32,
+            d_inner_1::<>, (x, bx_0))
     }
 }
 #[rustc_autodiff]
@@ -124,6 +136,7 @@ pub fn f10<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T { *x * *x }
 #[rustc_autodiff(Reverse, 1, Duplicated, Active)]
 pub fn d_square<T: std::ops::Mul<Output = T> +
     Copy>(x: &T, dx_0: &mut T, dret: T) -> T {
-    ::core::intrinsics::autodiff(f10::<T>, d_square::<T>, (x, dx_0, dret))
+    ::core::intrinsics::autodiff(f10::<T> as fn(_: &T) -> T, d_square::<T>,
+        (x, dx_0, dret))
 }
 fn main() {}
diff --git a/tests/pretty/autodiff/autodiff_reverse.pp b/tests/pretty/autodiff/autodiff_reverse.pp
index 61ab121b31bc..e2088e0ac13d 100644
--- a/tests/pretty/autodiff/autodiff_reverse.pp
+++ b/tests/pretty/autodiff/autodiff_reverse.pp
@@ -28,32 +28,37 @@ pub fn f1(x: &[f64], y: f64) -> f64 {
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df1(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f1::<> as fn(_: &[f64], _: f64) -> f64,
+        df1::<>, (x, dx_0, y, dret))
 }
 #[rustc_autodiff]
 pub fn f2() {}
 #[rustc_autodiff(Reverse, 1, None)]
-pub fn df2() { ::core::intrinsics::autodiff(f2::<>, df2::<>, ()) }
+pub fn df2() { ::core::intrinsics::autodiff(f2::<> as fn(), df2::<>, ()) }
 #[rustc_autodiff]
 pub fn f3(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df3(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::autodiff(f3::<>, df3::<>, (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f3::<> as fn(_: &[f64], _: f64) -> f64,
+        df3::<>, (x, dx_0, y, dret))
 }
 enum Foo { Reverse, }
 use Foo::Reverse;
 #[rustc_autodiff]
 pub fn f4(x: f32) { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Reverse, 1, Const, None)]
-pub fn df4(x: f32) { ::core::intrinsics::autodiff(f4::<>, df4::<>, (x,)) }
+pub fn df4(x: f32) {
+    ::core::intrinsics::autodiff(f4::<> as fn(_: f32), df4::<>, (x,))
+}
 #[rustc_autodiff]
 pub fn f5(x: *const f32, y: &f32) {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, DuplicatedOnly, Duplicated, None)]
 pub unsafe fn df5(x: *const f32, dx_0: *mut f32, y: &f32, dy_0: &mut f32) {
-    ::core::intrinsics::autodiff(f5::<>, df5::<>, (x, dx_0, y, dy_0))
+    ::core::intrinsics::autodiff(f5::<> as fn(_: *const f32, _: &f32),
+        df5::<>, (x, dx_0, y, dy_0))
 }
 fn main() {}
diff --git a/tests/pretty/autodiff/inherent_impl.pp b/tests/pretty/autodiff/inherent_impl.pp
index 1c83c66c8edf..d3a5a71b8bcb 100644
--- a/tests/pretty/autodiff/inherent_impl.pp
+++ b/tests/pretty/autodiff/inherent_impl.pp
@@ -30,7 +30,7 @@ impl MyTrait for Foo {
     }
     #[rustc_autodiff(Reverse, 1, Const, Active, Active)]
     fn df(&self, x: f64, dret: f64) -> (f64, f64) {
-        ::core::intrinsics::autodiff(Self::f::<>, Self::df::<>,
-            (self, x, dret))
+        ::core::intrinsics::autodiff(Self::f::<> as
+                fn(_: &Self, _: f64) -> f64, Self::df::<>, (self, x, dret))
     }
 }

From aaa4523d4bd6786a04b3291073321798a95fe38a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 4 Mar 2026 15:21:10 +0100
Subject: [PATCH 0124/1059] explain how to control target features with Miri

---
 src/tools/miri/README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index f254eb357a45..d9a2ee10ef6f 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -154,6 +154,16 @@ platform. For example `cargo miri test --target s390x-unknown-linux-gnu`
 will run your test suite on a big-endian target, which is useful for testing
 endian-sensitive code.
 
+### Controlling target features
+
+Controlling target features works similar to regular rustc invocations:
+`RUSTFLAGS="-Ctarget-features=+avx512f" cargo miri test` runs the tests with AVX512 enabled. (Miri
+only supports very few AVX512 intrinsics at the moment.) `-Ctarget-cpu` also works. Unlike regular
+rustc, this command has *two* effects: it builds the code with that target feature available (which
+affects `cfg(target_feature)`), and it tells Miri to consider the "virtual CPU" that the interpreted
+program runs on as having the feature available (meaning the code is allowed to invoke the
+corresponding intrinsics).
+
 ### Testing multiple different executions
 
 Certain parts of the execution are picked randomly by Miri, such as the exact base address

From a2fbeffe2ef625bea85efb970ba2975f22e1feca Mon Sep 17 00:00:00 2001
From: N1ark <opale.sjostedt@gmail.com>
Date: Tue, 3 Mar 2026 16:22:07 +0000
Subject: [PATCH 0125/1059] Clarify `-Zmiri-disable-validation` in the README

Co-Authored-By: Ralf Jung <post@ralfj.de>
---
 src/tools/miri/README.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index f254eb357a45..2473832e3cad 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -421,10 +421,11 @@ to Miri failing to detect cases of undefined behavior in a program.
   are experimental). Later flags take precedence: borrow tracking can be reactivated
   by `-Zmiri-tree-borrows`.
 * `-Zmiri-disable-validation` disables enforcing validity invariants, which are
-  enforced by default.  This is mostly useful to focus on other failures (such
-  as out-of-bounds accesses) first.  Setting this flag means Miri can miss bugs
-  in your program.  However, this can also help to make Miri run faster.  Using
-  this flag is **unsound**.
+  enforced by default. This only disables these checks for typed copies; using
+  invalid values in any other operation will still cause an error. This is mostly useful 
+  to focus on other failures (such as out-of-bounds accesses) first. Setting this 
+  flag means Miri can miss bugs in your program. However, this can also help to 
+  make Miri run faster. Using this flag is **unsound**.
 * `-Zmiri-disable-weak-memory-emulation` disables the emulation of some C++11 weak
   memory effects.
 * `-Zmiri-fixed-schedule` disables preemption (like `-Zmiri-preemption-rate=0.0`) and furthermore

From 390f683cfca9e3c39d73e9df776a65ec0f141290 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 2 Mar 2026 12:52:30 +0100
Subject: [PATCH 0126/1059] std: move non-path functions into dedicated module
 in PAL

---
 .../std/src/sys/net/connection/socket/unix.rs |   2 +-
 library/std/src/sys/pal/teeos/conf.rs         |   5 +
 library/std/src/sys/pal/teeos/mod.rs          |   1 +
 library/std/src/sys/pal/teeos/os.rs           |   6 --
 library/std/src/sys/pal/unix/conf.rs          |  97 +++++++++++++++++
 .../src/sys/pal/unix/{os => conf}/tests.rs    |   0
 library/std/src/sys/pal/unix/mod.rs           |   1 +
 library/std/src/sys/pal/unix/os.rs            | 101 ++----------------
 .../std/src/sys/pal/unix/stack_overflow.rs    |   4 +-
 library/std/src/sys/pal/wasi/conf.rs          |   4 +
 library/std/src/sys/pal/wasi/mod.rs           |   2 +
 library/std/src/sys/pal/wasi/os.rs            |   5 -
 library/std/src/sys/process/unix/unix.rs      |   2 +-
 library/std/src/sys/thread/teeos.rs           |   4 +-
 library/std/src/sys/thread/unix.rs            |   2 +-
 15 files changed, 124 insertions(+), 112 deletions(-)
 create mode 100644 library/std/src/sys/pal/teeos/conf.rs
 create mode 100644 library/std/src/sys/pal/unix/conf.rs
 rename library/std/src/sys/pal/unix/{os => conf}/tests.rs (100%)
 create mode 100644 library/std/src/sys/pal/wasi/conf.rs

diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index 5e20c0ffdfa6..f3c860804de0 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -684,7 +684,7 @@ fn on_resolver_failure() {
     use crate::sys;
 
     // If the version fails to parse, we treat it the same as "not glibc".
-    if let Some(version) = sys::os::glibc_version() {
+    if let Some(version) = sys::pal::conf::glibc_version() {
         if version < (2, 26) {
             unsafe { libc::res_init() };
         }
diff --git a/library/std/src/sys/pal/teeos/conf.rs b/library/std/src/sys/pal/teeos/conf.rs
new file mode 100644
index 000000000000..1d13a283c458
--- /dev/null
+++ b/library/std/src/sys/pal/teeos/conf.rs
@@ -0,0 +1,5 @@
+// Hardcoded to return 4096, since `sysconf` is only implemented as a stub.
+pub fn page_size() -> usize {
+    // unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize };
+    4096
+}
diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index f76c26d3c966..7d2ecdbf7ec4 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -6,6 +6,7 @@
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
+pub mod conf;
 pub mod os;
 #[path = "../unix/time.rs"]
 pub mod time;
diff --git a/library/std/src/sys/pal/teeos/os.rs b/library/std/src/sys/pal/teeos/os.rs
index c09b84f42bab..c86fa555e411 100644
--- a/library/std/src/sys/pal/teeos/os.rs
+++ b/library/std/src/sys/pal/teeos/os.rs
@@ -7,12 +7,6 @@
 use crate::path::PathBuf;
 use crate::{fmt, io, path};
 
-// Hardcoded to return 4096, since `sysconf` is only implemented as a stub.
-pub fn page_size() -> usize {
-    // unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize };
-    4096
-}
-
 // Everything below are stubs and copied from unsupported.rs
 
 pub fn getcwd() -> io::Result<PathBuf> {
diff --git a/library/std/src/sys/pal/unix/conf.rs b/library/std/src/sys/pal/unix/conf.rs
new file mode 100644
index 000000000000..a97173a1a35a
--- /dev/null
+++ b/library/std/src/sys/pal/unix/conf.rs
@@ -0,0 +1,97 @@
+#[cfg(test)]
+mod tests;
+
+#[cfg(not(target_os = "espidf"))]
+pub fn page_size() -> usize {
+    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
+}
+
+/// Returns the value for [`confstr(key, ...)`][posix_confstr]. Currently only
+/// used on Darwin, but should work on any unix (in case we need to get
+/// `_CS_PATH` or `_CS_V[67]_ENV` in the future).
+///
+/// [posix_confstr]:
+///     https://pubs.opengroup.org/onlinepubs/9699919799/functions/confstr.html
+//
+// FIXME: Support `confstr` in Miri.
+#[cfg(all(target_vendor = "apple", not(miri)))]
+pub fn confstr(
+    key: crate::ffi::c_int,
+    size_hint: Option<usize>,
+) -> crate::io::Result<crate::ffi::OsString> {
+    use crate::ffi::OsString;
+    use crate::io;
+    use crate::os::unix::ffi::OsStringExt;
+
+    let mut buf: Vec<u8> = Vec::with_capacity(0);
+    let mut bytes_needed_including_nul = size_hint
+        .unwrap_or_else(|| {
+            // Treat "None" as "do an extra call to get the length". In theory
+            // we could move this into the loop below, but it's hard to do given
+            // that it isn't 100% clear if it's legal to pass 0 for `len` when
+            // the buffer isn't null.
+            unsafe { libc::confstr(key, core::ptr::null_mut(), 0) }
+        })
+        .max(1);
+    // If the value returned by `confstr` is greater than the len passed into
+    // it, then the value was truncated, meaning we need to retry. Note that
+    // while `confstr` results don't seem to change for a process, it's unclear
+    // if this is guaranteed anywhere, so looping does seem required.
+    while bytes_needed_including_nul > buf.capacity() {
+        // We write into the spare capacity of `buf`. This lets us avoid
+        // changing buf's `len`, which both simplifies `reserve` computation,
+        // allows working with `Vec<u8>` instead of `Vec<MaybeUninit<u8>>`, and
+        // may avoid a copy, since the Vec knows that none of the bytes are needed
+        // when reallocating (well, in theory anyway).
+        buf.reserve(bytes_needed_including_nul);
+        // `confstr` returns
+        // - 0 in the case of errors: we break and return an error.
+        // - The number of bytes written, iff the provided buffer is enough to
+        //   hold the entire value: we break and return the data in `buf`.
+        // - Otherwise, the number of bytes needed (including nul): we go
+        //   through the loop again.
+        bytes_needed_including_nul =
+            unsafe { libc::confstr(key, buf.as_mut_ptr().cast(), buf.capacity()) };
+    }
+    // `confstr` returns 0 in the case of an error.
+    if bytes_needed_including_nul == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    // Safety: `confstr(..., buf.as_mut_ptr(), buf.capacity())` returned a
+    // non-zero value, meaning `bytes_needed_including_nul` bytes were
+    // initialized.
+    unsafe {
+        buf.set_len(bytes_needed_including_nul);
+        // Remove the NUL-terminator.
+        let last_byte = buf.pop();
+        // ... and smoke-check that it *was* a NUL-terminator.
+        assert_eq!(last_byte, Some(0), "`confstr` provided a string which wasn't nul-terminated");
+    };
+    Ok(OsString::from_vec(buf))
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+pub fn glibc_version() -> Option<(usize, usize)> {
+    use crate::ffi::CStr;
+
+    unsafe extern "C" {
+        fn gnu_get_libc_version() -> *const libc::c_char;
+    }
+    let version_cstr = unsafe { CStr::from_ptr(gnu_get_libc_version()) };
+    if let Ok(version_str) = version_cstr.to_str() {
+        parse_glibc_version(version_str)
+    } else {
+        None
+    }
+}
+
+/// Returns Some((major, minor)) if the string is a valid "x.y" version,
+/// ignoring any extra dot-separated parts. Otherwise return None.
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+fn parse_glibc_version(version: &str) -> Option<(usize, usize)> {
+    let mut parsed_ints = version.split('.').map(str::parse::<usize>).fuse();
+    match (parsed_ints.next(), parsed_ints.next()) {
+        (Some(Ok(major)), Some(Ok(minor))) => Some((major, minor)),
+        _ => None,
+    }
+}
diff --git a/library/std/src/sys/pal/unix/os/tests.rs b/library/std/src/sys/pal/unix/conf/tests.rs
similarity index 100%
rename from library/std/src/sys/pal/unix/os/tests.rs
rename to library/std/src/sys/pal/unix/conf/tests.rs
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index 0fbf37fda7fb..9931b4de0b9b 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -2,6 +2,7 @@
 
 use crate::io;
 
+pub mod conf;
 #[cfg(target_os = "fuchsia")]
 pub mod fuchsia;
 pub mod futex;
diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/pal/unix/os.rs
index d11282682d08..f69614c2077c 100644
--- a/library/std/src/sys/pal/unix/os.rs
+++ b/library/std/src/sys/pal/unix/os.rs
@@ -2,9 +2,6 @@
 
 #![allow(unused_imports)] // lots of cfg code here
 
-#[cfg(test)]
-mod tests;
-
 use libc::{c_char, c_int, c_void};
 
 use crate::ffi::{CStr, OsStr, OsString};
@@ -396,75 +393,15 @@ pub fn current_exe() -> io::Result<PathBuf> {
     if !path.is_absolute() { getcwd().map(|cwd| cwd.join(path)) } else { Ok(path) }
 }
 
-#[cfg(not(target_os = "espidf"))]
-pub fn page_size() -> usize {
-    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
-}
-
-// Returns the value for [`confstr(key, ...)`][posix_confstr]. Currently only
-// used on Darwin, but should work on any unix (in case we need to get
-// `_CS_PATH` or `_CS_V[67]_ENV` in the future).
-//
-// [posix_confstr]:
-//     https://pubs.opengroup.org/onlinepubs/9699919799/functions/confstr.html
-//
-// FIXME: Support `confstr` in Miri.
-#[cfg(all(target_vendor = "apple", not(miri)))]
-fn confstr(key: c_int, size_hint: Option<usize>) -> io::Result<OsString> {
-    let mut buf: Vec<u8> = Vec::with_capacity(0);
-    let mut bytes_needed_including_nul = size_hint
-        .unwrap_or_else(|| {
-            // Treat "None" as "do an extra call to get the length". In theory
-            // we could move this into the loop below, but it's hard to do given
-            // that it isn't 100% clear if it's legal to pass 0 for `len` when
-            // the buffer isn't null.
-            unsafe { libc::confstr(key, core::ptr::null_mut(), 0) }
-        })
-        .max(1);
-    // If the value returned by `confstr` is greater than the len passed into
-    // it, then the value was truncated, meaning we need to retry. Note that
-    // while `confstr` results don't seem to change for a process, it's unclear
-    // if this is guaranteed anywhere, so looping does seem required.
-    while bytes_needed_including_nul > buf.capacity() {
-        // We write into the spare capacity of `buf`. This lets us avoid
-        // changing buf's `len`, which both simplifies `reserve` computation,
-        // allows working with `Vec<u8>` instead of `Vec<MaybeUninit<u8>>`, and
-        // may avoid a copy, since the Vec knows that none of the bytes are needed
-        // when reallocating (well, in theory anyway).
-        buf.reserve(bytes_needed_including_nul);
-        // `confstr` returns
-        // - 0 in the case of errors: we break and return an error.
-        // - The number of bytes written, iff the provided buffer is enough to
-        //   hold the entire value: we break and return the data in `buf`.
-        // - Otherwise, the number of bytes needed (including nul): we go
-        //   through the loop again.
-        bytes_needed_including_nul =
-            unsafe { libc::confstr(key, buf.as_mut_ptr().cast::<c_char>(), buf.capacity()) };
-    }
-    // `confstr` returns 0 in the case of an error.
-    if bytes_needed_including_nul == 0 {
-        return Err(io::Error::last_os_error());
-    }
-    // Safety: `confstr(..., buf.as_mut_ptr(), buf.capacity())` returned a
-    // non-zero value, meaning `bytes_needed_including_nul` bytes were
-    // initialized.
-    unsafe {
-        buf.set_len(bytes_needed_including_nul);
-        // Remove the NUL-terminator.
-        let last_byte = buf.pop();
-        // ... and smoke-check that it *was* a NUL-terminator.
-        assert_eq!(last_byte, Some(0), "`confstr` provided a string which wasn't nul-terminated");
-    };
-    Ok(OsString::from_vec(buf))
-}
-
 #[cfg(all(target_vendor = "apple", not(miri)))]
 fn darwin_temp_dir() -> PathBuf {
-    confstr(libc::_CS_DARWIN_USER_TEMP_DIR, Some(64)).map(PathBuf::from).unwrap_or_else(|_| {
-        // It failed for whatever reason (there are several possible reasons),
-        // so return the global one.
-        PathBuf::from("/tmp")
-    })
+    crate::sys::pal::conf::confstr(libc::_CS_DARWIN_USER_TEMP_DIR, Some(64))
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            // It failed for whatever reason (there are several possible reasons),
+            // so return the global one.
+            PathBuf::from("/tmp")
+        })
 }
 
 pub fn temp_dir() -> PathBuf {
@@ -532,27 +469,3 @@ unsafe fn fallback() -> Option<OsString> {
         }
     }
 }
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub fn glibc_version() -> Option<(usize, usize)> {
-    unsafe extern "C" {
-        fn gnu_get_libc_version() -> *const libc::c_char;
-    }
-    let version_cstr = unsafe { CStr::from_ptr(gnu_get_libc_version()) };
-    if let Ok(version_str) = version_cstr.to_str() {
-        parse_glibc_version(version_str)
-    } else {
-        None
-    }
-}
-
-// Returns Some((major, minor)) if the string is a valid "x.y" version,
-// ignoring any extra dot-separated parts. Otherwise return None.
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-fn parse_glibc_version(version: &str) -> Option<(usize, usize)> {
-    let mut parsed_ints = version.split('.').map(str::parse::<usize>).fuse();
-    match (parsed_ints.next(), parsed_ints.next()) {
-        (Some(Ok(major)), Some(Ok(minor))) => Some((major, minor)),
-        _ => None,
-    }
-}
diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 040fda75a508..632f619655b3 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -70,7 +70,7 @@ mod imp {
     use super::thread_info::{delete_current_info, set_current_info, with_current_info};
     use crate::ops::Range;
     use crate::sync::atomic::{Atomic, AtomicBool, AtomicPtr, AtomicUsize, Ordering};
-    use crate::sys::pal::unix::os;
+    use crate::sys::pal::unix::conf;
     use crate::{io, mem, ptr};
 
     // Signal handler for the SIGSEGV and SIGBUS handlers. We've got guard pages
@@ -150,7 +150,7 @@ mod imp {
     /// Must be called only once
     #[forbid(unsafe_op_in_unsafe_fn)]
     pub unsafe fn init() {
-        PAGE_SIZE.store(os::page_size(), Ordering::Relaxed);
+        PAGE_SIZE.store(conf::page_size(), Ordering::Relaxed);
 
         let mut guard_page_range = unsafe { install_main_guard() };
 
diff --git a/library/std/src/sys/pal/wasi/conf.rs b/library/std/src/sys/pal/wasi/conf.rs
new file mode 100644
index 000000000000..cf76ae733358
--- /dev/null
+++ b/library/std/src/sys/pal/wasi/conf.rs
@@ -0,0 +1,4 @@
+#[allow(dead_code)]
+pub fn page_size() -> usize {
+    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
+}
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasi/mod.rs
index 9b49db9af6b0..efe4af6a0c62 100644
--- a/library/std/src/sys/pal/wasi/mod.rs
+++ b/library/std/src/sys/pal/wasi/mod.rs
@@ -4,6 +4,8 @@
 //! OS level functionality for WASI. Currently this includes both WASIp1 and
 //! WASIp2.
 
+pub mod conf;
+
 #[allow(unused)]
 #[path = "../wasm/atomics/futex.rs"]
 pub mod futex;
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasi/os.rs
index c8f3ddf692bc..b0148b265e32 100644
--- a/library/std/src/sys/pal/wasi/os.rs
+++ b/library/std/src/sys/pal/wasi/os.rs
@@ -89,11 +89,6 @@ pub fn current_exe() -> io::Result<PathBuf> {
     unsupported()
 }
 
-#[allow(dead_code)]
-pub fn page_size() -> usize {
-    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
-}
-
 pub fn temp_dir() -> PathBuf {
     panic!("no filesystem on wasm")
 }
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 82ff94fb1e03..a68be2543bc2 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -537,7 +537,7 @@ fn pidfd_spawnp(
         // Only glibc 2.24+ posix_spawn() supports returning ENOENT directly.
         #[cfg(all(target_os = "linux", target_env = "gnu"))]
         {
-            if let Some(version) = sys::os::glibc_version() {
+            if let Some(version) = sys::pal::conf::glibc_version() {
                 if version < (2, 24) {
                     return Ok(None);
                 }
diff --git a/library/std/src/sys/thread/teeos.rs b/library/std/src/sys/thread/teeos.rs
index 5e71f757eaa4..aa679e780c18 100644
--- a/library/std/src/sys/thread/teeos.rs
+++ b/library/std/src/sys/thread/teeos.rs
@@ -1,5 +1,5 @@
 use crate::mem::{self, ManuallyDrop};
-use crate::sys::os;
+use crate::sys::pal::conf;
 use crate::thread::ThreadInit;
 use crate::time::Duration;
 use crate::{cmp, io, ptr};
@@ -52,7 +52,7 @@ pub unsafe fn new(stack: usize, init: Box<ThreadInit>) -> io::Result<Thread> {
                 // multiple of the system page size.  Because it's definitely
                 // >= PTHREAD_STACK_MIN, it must be an alignment issue.
                 // Round up to the nearest page and try again.
-                let page_size = os::page_size();
+                let page_size = conf::page_size();
                 let stack_size =
                     (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
                 assert_eq!(unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) }, 0);
diff --git a/library/std/src/sys/thread/unix.rs b/library/std/src/sys/thread/unix.rs
index 22f9bfef5a38..5d4eabc226ed 100644
--- a/library/std/src/sys/thread/unix.rs
+++ b/library/std/src/sys/thread/unix.rs
@@ -76,7 +76,7 @@ pub unsafe fn new(stack: usize, init: Box<ThreadInit>) -> io::Result<Thread> {
                     // multiple of the system page size. Because it's definitely
                     // >= PTHREAD_STACK_MIN, it must be an alignment issue.
                     // Round up to the nearest page and try again.
-                    let page_size = sys::os::page_size();
+                    let page_size = sys::pal::conf::page_size();
                     let stack_size =
                         (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
 

From 866975f8a88eea5e8d6d92541e65dcd33dd9c684 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 2 Mar 2026 12:58:59 +0100
Subject: [PATCH 0127/1059] std: move SOLID error converting out of `pal::os`

---
 library/std/src/sys/pal/solid/error.rs |  8 ++++++++
 library/std/src/sys/pal/solid/os.rs    | 10 +---------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/library/std/src/sys/pal/solid/error.rs b/library/std/src/sys/pal/solid/error.rs
index 3e85cdb3c1d9..a737abcc04ed 100644
--- a/library/std/src/sys/pal/solid/error.rs
+++ b/library/std/src/sys/pal/solid/error.rs
@@ -3,6 +3,14 @@
 use crate::io;
 use crate::sys::net;
 
+// SOLID directly maps `errno`s to μITRON error codes.
+impl SolidError {
+    #[inline]
+    pub(crate) fn as_io_error(self) -> crate::io::Error {
+        crate::io::Error::from_raw_os_error(self.as_raw())
+    }
+}
+
 /// Describe the specified SOLID error code. Returns `None` if it's an
 /// undefined error code.
 ///
diff --git a/library/std/src/sys/pal/solid/os.rs b/library/std/src/sys/pal/solid/os.rs
index 4a07d240d2e6..79bb91b17996 100644
--- a/library/std/src/sys/pal/solid/os.rs
+++ b/library/std/src/sys/pal/solid/os.rs
@@ -1,16 +1,8 @@
-use super::{itron, unsupported};
+use super::unsupported;
 use crate::ffi::{OsStr, OsString};
 use crate::path::{self, PathBuf};
 use crate::{fmt, io};
 
-// `solid` directly maps `errno`s to μITRON error codes.
-impl itron::error::ItronError {
-    #[inline]
-    pub(crate) fn as_io_error(self) -> crate::io::Error {
-        crate::io::Error::from_raw_os_error(self.as_raw())
-    }
-}
-
 pub fn getcwd() -> io::Result<PathBuf> {
     unsupported()
 }

From d31aecff6a3a7a5272e8b07a72f8cebc8ec1f517 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Wed, 4 Mar 2026 16:56:29 +0100
Subject: [PATCH 0128/1059] std: reorganize some WASI helpers

---
 library/std/src/sys/env/wasi.rs         | 11 ++--
 library/std/src/sys/pal/wasi/helpers.rs | 11 ----
 library/std/src/sys/pal/wasi/mod.rs     | 72 +++++++++++++++++--------
 library/std/src/sys/pal/wasi/os.rs      | 43 ---------------
 4 files changed, 58 insertions(+), 79 deletions(-)
 delete mode 100644 library/std/src/sys/pal/wasi/helpers.rs

diff --git a/library/std/src/sys/env/wasi.rs b/library/std/src/sys/env/wasi.rs
index c970aac18260..6b892376fd0c 100644
--- a/library/std/src/sys/env/wasi.rs
+++ b/library/std/src/sys/env/wasi.rs
@@ -1,11 +1,16 @@
 use core::slice::memchr;
 
 pub use super::common::Env;
-use crate::ffi::{CStr, OsStr, OsString};
+use crate::ffi::{CStr, OsStr, OsString, c_char};
 use crate::io;
 use crate::os::wasi::prelude::*;
 use crate::sys::helpers::run_with_cstr;
-use crate::sys::pal::os::{cvt, libc};
+use crate::sys::pal::cvt;
+
+// This is not available yet in libc.
+unsafe extern "C" {
+    fn __wasilibc_get_environ() -> *mut *mut c_char;
+}
 
 cfg_select! {
     target_feature = "atomics" => {
@@ -37,7 +42,7 @@ pub fn env() -> Env {
         // Use `__wasilibc_get_environ` instead of `environ` here so that we
         // don't require wasi-libc to eagerly initialize the environment
         // variables.
-        let mut environ = libc::__wasilibc_get_environ();
+        let mut environ = __wasilibc_get_environ();
 
         let mut result = Vec::new();
         if !environ.is_null() {
diff --git a/library/std/src/sys/pal/wasi/helpers.rs b/library/std/src/sys/pal/wasi/helpers.rs
deleted file mode 100644
index 4f2eb1148f0b..000000000000
--- a/library/std/src/sys/pal/wasi/helpers.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![forbid(unsafe_op_in_unsafe_fn)]
-
-pub fn abort_internal() -> ! {
-    unsafe { libc::abort() }
-}
-
-#[inline]
-#[cfg(target_env = "p1")]
-pub(crate) fn err2io(err: wasi::Errno) -> crate::io::Error {
-    crate::io::Error::from_raw_os_error(err.raw().into())
-}
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasi/mod.rs
index efe4af6a0c62..66d91078a5d5 100644
--- a/library/std/src/sys/pal/wasi/mod.rs
+++ b/library/std/src/sys/pal/wasi/mod.rs
@@ -4,36 +4,64 @@
 //! OS level functionality for WASI. Currently this includes both WASIp1 and
 //! WASIp2.
 
-pub mod conf;
+use crate::io;
 
+pub mod conf;
 #[allow(unused)]
 #[path = "../wasm/atomics/futex.rs"]
 pub mod futex;
-
 pub mod os;
 pub mod stack_overflow;
 #[path = "../unix/time.rs"]
 pub mod time;
 
-#[path = "../unsupported/common.rs"]
-#[deny(unsafe_op_in_unsafe_fn)]
-#[allow(unused)]
-mod common;
-
-pub use common::*;
-
-mod helpers;
-
-// The following exports are listed individually to work around Rust's glob
-// import conflict rules. If we glob export `helpers` and `common` together,
-// then the compiler complains about conflicts.
-
-pub(crate) use helpers::abort_internal;
-#[cfg(target_env = "p1")]
-pub(crate) use helpers::err2io;
-#[cfg(not(target_env = "p1"))]
-pub use os::IsMinusOne;
-pub use os::{cvt, cvt_r};
-
 #[cfg(not(target_env = "p1"))]
 mod cabi_realloc;
+
+#[path = "../unsupported/common.rs"]
+#[deny(unsafe_op_in_unsafe_fn)]
+#[expect(dead_code)]
+mod common;
+pub use common::{cleanup, init, unsupported};
+
+pub fn abort_internal() -> ! {
+    unsafe { libc::abort() }
+}
+
+#[inline]
+#[cfg(target_env = "p1")]
+pub(crate) fn err2io(err: wasi::Errno) -> crate::io::Error {
+    crate::io::Error::from_raw_os_error(err.raw().into())
+}
+
+#[doc(hidden)]
+pub trait IsMinusOne {
+    fn is_minus_one(&self) -> bool;
+}
+
+macro_rules! impl_is_minus_one {
+    ($($t:ident)*) => ($(impl IsMinusOne for $t {
+        fn is_minus_one(&self) -> bool {
+            *self == -1
+        }
+    })*)
+}
+
+impl_is_minus_one! { i8 i16 i32 i64 isize }
+
+pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
+    if t.is_minus_one() { Err(io::Error::last_os_error()) } else { Ok(t) }
+}
+
+pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
+where
+    T: IsMinusOne,
+    F: FnMut() -> T,
+{
+    loop {
+        match cvt(f()) {
+            Err(ref e) if e.is_interrupted() => {}
+            other => return other,
+        }
+    }
+}
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasi/os.rs
index b0148b265e32..b1c26acc68cb 100644
--- a/library/std/src/sys/pal/wasi/os.rs
+++ b/library/std/src/sys/pal/wasi/os.rs
@@ -8,17 +8,6 @@
 use crate::sys::unsupported;
 use crate::{fmt, io};
 
-// Add a few symbols not in upstream `libc` just yet.
-pub mod libc {
-    pub use libc::*;
-
-    unsafe extern "C" {
-        pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char;
-        pub fn chdir(dir: *const c_char) -> c_int;
-        pub fn __wasilibc_get_environ() -> *mut *mut c_char;
-    }
-}
-
 pub fn getcwd() -> io::Result<PathBuf> {
     let mut buf = Vec::with_capacity(512);
     loop {
@@ -96,35 +85,3 @@ pub fn temp_dir() -> PathBuf {
 pub fn home_dir() -> Option<PathBuf> {
     None
 }
-
-#[doc(hidden)]
-pub trait IsMinusOne {
-    fn is_minus_one(&self) -> bool;
-}
-
-macro_rules! impl_is_minus_one {
-    ($($t:ident)*) => ($(impl IsMinusOne for $t {
-        fn is_minus_one(&self) -> bool {
-            *self == -1
-        }
-    })*)
-}
-
-impl_is_minus_one! { i8 i16 i32 i64 isize }
-
-pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
-    if t.is_minus_one() { Err(io::Error::last_os_error()) } else { Ok(t) }
-}
-
-pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
-where
-    T: IsMinusOne,
-    F: FnMut() -> T,
-{
-    loop {
-        match cvt(f()) {
-            Err(ref e) if e.is_interrupted() => {}
-            other => return other,
-        }
-    }
-}

From 1f94e979fb9b09f4df5483ce549fb96574be1e6e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 22 Oct 2025 14:28:05 +1100
Subject: [PATCH 0129/1059] Fix some comments about dataflow analysis.

Mostly in the examples in `initialized.rs`. In particular, the
`EverInitializedPlaces` example currently doesn't cover how it's
initialization sites that are tracked, rather than local variables
(that's the `b_0`/`b_1` distinction in the example.)
---
 compiler/rustc_middle/src/mir/basic_blocks.rs |  2 +-
 .../src/impls/initialized.rs                  | 54 ++++++++++---------
 2 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/basic_blocks.rs b/compiler/rustc_middle/src/mir/basic_blocks.rs
index aae815c0be04..bd8c022ef42a 100644
--- a/compiler/rustc_middle/src/mir/basic_blocks.rs
+++ b/compiler/rustc_middle/src/mir/basic_blocks.rs
@@ -65,7 +65,7 @@ pub fn predecessors(&self) -> &Predecessors {
 
     /// Returns basic blocks in a reverse postorder.
     ///
-    /// See [`traversal::reverse_postorder`]'s docs to learn what is preorder traversal.
+    /// See [`traversal::reverse_postorder`]'s docs to learn what is postorder traversal.
     ///
     /// [`traversal::reverse_postorder`]: crate::mir::traversal::reverse_postorder
     #[inline]
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
index 6a0881ec2bcb..f83ea0c8be61 100644
--- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -108,21 +108,21 @@ fn new(
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // maybe-init:
-///                                             // {}
-///     let a = S; let mut b = S; let c; let d; // {a, b}
+/// fn foo(p: bool) {                           // maybe-init:
+///                                             // {p}
+///     let a = S; let mut b = S; let c; let d; // {p, a, b}
 ///
-///     if pred {
-///         drop(a);                            // {   b}
-///         b = S;                              // {   b}
+///     if p {
+///         drop(a);                            // {p,    b}
+///         b = S;                              // {p,    b}
 ///
 ///     } else {
-///         drop(b);                            // {a}
-///         d = S;                              // {a,       d}
+///         drop(b);                            // {p, a}
+///         d = S;                              // {p, a,       d}
 ///
-///     }                                       // {a, b,    d}
+///     }                                       // {p, a, b,    d}
 ///
-///     c = S;                                  // {a, b, c, d}
+///     c = S;                                  // {p, a, b, c, d}
 /// }
 /// ```
 ///
@@ -198,11 +198,11 @@ fn move_data(&self) -> &MoveData<'tcx> {
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // maybe-uninit:
+/// fn foo(p: bool) {                           // maybe-uninit:
 ///                                             // {a, b, c, d}
 ///     let a = S; let mut b = S; let c; let d; // {      c, d}
 ///
-///     if pred {
+///     if p {
 ///         drop(a);                            // {a,    c, d}
 ///         b = S;                              // {a,    c, d}
 ///
@@ -278,34 +278,36 @@ fn move_data(&self) -> &MoveData<'tcx> {
     }
 }
 
-/// `EverInitializedPlaces` tracks all places that might have ever been
-/// initialized upon reaching a particular point in the control flow
-/// for a function, without an intervening `StorageDead`.
+/// `EverInitializedPlaces` tracks all initializations that may have occurred
+/// upon reaching a particular point in the control flow for a function,
+/// without an intervening `StorageDead`.
 ///
 /// This dataflow is used to determine if an immutable local variable may
 /// be assigned to.
 ///
 /// For example, in code like the following, we have corresponding
-/// dataflow information shown in the right-hand comments.
+/// dataflow information shown in the right-hand comments. Underscored indices
+/// are used to distinguish between multiple initializations of the same local
+/// variable, e.g. `b_0` and `b_1`.
 ///
 /// ```rust
 /// struct S;
 /// #[rustfmt::skip]
-/// fn foo(pred: bool) {                        // ever-init:
-///                                             // {          }
-///     let a = S; let mut b = S; let c; let d; // {a, b      }
+/// fn foo(p: bool) {                           // ever-init:
+///                                             // {p,                  }
+///     let a = S; let mut b = S; let c; let d; // {p, a, b_0,          }
 ///
-///     if pred {
-///         drop(a);                            // {a, b,     }
-///         b = S;                              // {a, b,     }
+///     if p {
+///         drop(a);                            // {p, a, b_0,          }
+///         b = S;                              // {p, a, b_0, b_1,     }
 ///
 ///     } else {
-///         drop(b);                            // {a, b,      }
-///         d = S;                              // {a, b,    d }
+///         drop(b);                            // {p, a, b_0, b_1,     }
+///         d = S;                              // {p, a, b_0, b_1,    d}
 ///
-///     }                                       // {a, b,    d }
+///     }                                       // {p, a, b_0, b_1,    d}
 ///
-///     c = S;                                  // {a, b, c, d }
+///     c = S;                                  // {p, a, b_0, b_1, c, d}
 /// }
 /// ```
 pub struct EverInitializedPlaces<'a, 'tcx> {

From c9bfe10af5e0eed3d10be76782ed94dd6c35b6f7 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 5 Mar 2026 05:15:12 +0000
Subject: [PATCH 0130/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to f8704be04fe1150527fc2cf21dd44327f0fe87fb.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 90a48de0fcb0..7c89bcb9ab04 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-d933cf483edf1605142ac6899ff32536c0ad8b22
+f8704be04fe1150527fc2cf21dd44327f0fe87fb

From fcddf7fa3cd4c9cfa8afa9f1aba830cea87971b0 Mon Sep 17 00:00:00 2001
From: Ada Bohm <ada@kreatrix.org>
Date: Thu, 5 Mar 2026 10:08:57 +0100
Subject: [PATCH 0131/1059] Propagate certainty

---
 .../src/solve/assembly/mod.rs                 | 37 +++++++++++++------
 .../find-param-recursion-issue-152716.rs      |  2 +-
 .../find-param-recursion-issue-152716.stderr  |  6 ++-
 3 files changed, 31 insertions(+), 14 deletions(-)

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 bf59f7cab8e4..bb0f16e153da 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -9,6 +9,7 @@
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::search_graph::CandidateHeadUsages;
+use rustc_type_ir::solve::Certainty::Maybe;
 use rustc_type_ir::solve::{AliasBoundKind, SizedTraitKind};
 use rustc_type_ir::{
     self as ty, Interner, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable,
@@ -138,8 +139,10 @@ fn probe_and_consider_param_env_candidate(
             .enter_single_candidate(|ecx| {
                 Self::match_assumption(ecx, goal, assumption, |ecx| {
                     ecx.try_evaluate_added_goals()?;
-                    source.set(ecx.characterize_param_env_assumption(goal.param_env, assumption)?);
-                    ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                    let (src, certainty) =
+                        ecx.characterize_param_env_assumption(goal.param_env, assumption)?;
+                    source.set(src);
+                    ecx.evaluate_added_goals_and_make_canonical_response(certainty)
                 })
             });
 
@@ -1222,11 +1225,11 @@ fn characterize_param_env_assumption(
         &mut self,
         param_env: I::ParamEnv,
         assumption: I::Clause,
-    ) -> Result<CandidateSource<I>, NoSolution> {
+    ) -> Result<(CandidateSource<I>, Certainty), NoSolution> {
         // FIXME: This should be fixed, but it also requires changing the behavior
         // in the old solver which is currently relied on.
         if assumption.has_bound_vars() {
-            return Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal));
+            return Ok((CandidateSource::ParamEnv(ParamEnvSource::NonGlobal), Certainty::Yes));
         }
 
         match assumption.visit_with(&mut FindParamInClause {
@@ -1236,8 +1239,12 @@ fn characterize_param_env_assumption(
             recursion_depth: 0,
         }) {
             ControlFlow::Break(Err(NoSolution)) => Err(NoSolution),
-            ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)),
-            ControlFlow::Continue(()) => Ok(CandidateSource::ParamEnv(ParamEnvSource::Global)),
+            ControlFlow::Break(Ok(certainty)) => {
+                Ok((CandidateSource::ParamEnv(ParamEnvSource::NonGlobal), certainty))
+            }
+            ControlFlow::Continue(()) => {
+                Ok((CandidateSource::ParamEnv(ParamEnvSource::Global), Certainty::Yes))
+            }
         }
     }
 }
@@ -1254,7 +1261,7 @@ impl<D, I> TypeVisitor<I> for FindParamInClause<'_, '_, D, I>
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    type Result = ControlFlow<Result<(), NoSolution>>;
+    type Result = ControlFlow<Result<Certainty, NoSolution>>;
 
     fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
         self.universes.push(None);
@@ -1271,14 +1278,20 @@ fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
 
         if let ty::Placeholder(p) = ty.kind() {
             if p.universe() == ty::UniverseIndex::ROOT {
-                ControlFlow::Break(Ok(()))
+                ControlFlow::Break(Ok(Certainty::Yes))
             } else {
                 ControlFlow::Continue(())
             }
         } else if ty.has_type_flags(TypeFlags::HAS_PLACEHOLDER | TypeFlags::HAS_RE_INFER) {
             self.recursion_depth += 1;
             if self.recursion_depth > self.ecx.cx().recursion_limit() {
-                return ControlFlow::Break(Err(NoSolution));
+                return ControlFlow::Break(Ok(Maybe {
+                    cause: MaybeCause::Overflow {
+                        suggest_increasing_limit: true,
+                        keep_constraints: false,
+                    },
+                    opaque_types_jank: OpaqueTypesJank::AllGood,
+                }));
             }
             let result = ty.super_visit_with(self);
             self.recursion_depth -= 1;
@@ -1296,7 +1309,7 @@ fn visit_const(&mut self, ct: I::Const) -> Self::Result {
 
         if let ty::ConstKind::Placeholder(p) = ct.kind() {
             if p.universe() == ty::UniverseIndex::ROOT {
-                ControlFlow::Break(Ok(()))
+                ControlFlow::Break(Ok(Certainty::Yes))
             } else {
                 ControlFlow::Continue(())
             }
@@ -1312,12 +1325,12 @@ fn visit_region(&mut self, r: I::Region) -> Self::Result {
             ty::ReStatic | ty::ReError(_) | ty::ReBound(..) => ControlFlow::Continue(()),
             ty::RePlaceholder(p) => {
                 if p.universe() == ty::UniverseIndex::ROOT {
-                    ControlFlow::Break(Ok(()))
+                    ControlFlow::Break(Ok(Certainty::Yes))
                 } else {
                     ControlFlow::Continue(())
                 }
             }
-            ty::ReVar(_) => ControlFlow::Break(Ok(())),
+            ty::ReVar(_) => ControlFlow::Break(Ok(Certainty::Yes)),
             ty::ReErased | ty::ReEarlyParam(_) | ty::ReLateParam(_) => {
                 unreachable!("unexpected region in param-env clause")
             }
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
index 410781e955d7..e9635f709a99 100644
--- a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Znext-solver
-//~^ ERROR overflow normalizing the associated type `<T as Proj<'b>>::Assoc` [E0275]
 
 // Regression test for <https://github.com/rust-lang/rust/issues/152716>.
 
@@ -11,6 +10,7 @@ fn foo<T>()
 where
     T: for<'a> Proj<'a, Assoc = for<'b> fn(<T as Proj<'b>>::Assoc)>,
     (): Trait<<T as Proj<'static>>::Assoc>
+    //~^ ERROR overflow evaluating the requirement `(): Trait<<T as Proj<'static>>::Assoc>` [E0275]
 {
 }
 
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
index 9886e303eaf7..3aca6cfc9c5a 100644
--- a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
@@ -1,4 +1,8 @@
-error[E0275]: overflow normalizing the associated type `<T as Proj<'b>>::Assoc`
+error[E0275]: overflow evaluating the requirement `(): Trait<<T as Proj<'static>>::Assoc>`
+  --> $DIR/find-param-recursion-issue-152716.rs:12:9
+   |
+LL |     (): Trait<<T as Proj<'static>>::Assoc>
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`find_param_recursion_issue_152716`)
 

From 61304807aaa73ea9de1e920e7c3571f5ea58cb2c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 5 Mar 2026 08:33:24 +0100
Subject: [PATCH 0132/1059] remove unused features

---
 src/tools/miri/src/alloc/mod.rs           |  4 ++--
 src/tools/miri/src/alloc_addresses/mod.rs |  4 ++--
 src/tools/miri/src/bin/miri.rs            |  4 ++--
 src/tools/miri/src/lib.rs                 | 18 +++++++++++-------
 src/tools/miri/src/machine.rs             | 14 +++++++-------
 src/tools/miri/src/shims/foreign_items.rs |  2 +-
 src/tools/miri/src/shims/mod.rs           |  4 ++--
 7 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/src/tools/miri/src/alloc/mod.rs b/src/tools/miri/src/alloc/mod.rs
index 35158f50a8ff..bc306b5e8738 100644
--- a/src/tools/miri/src/alloc/mod.rs
+++ b/src/tools/miri/src/alloc/mod.rs
@@ -1,7 +1,7 @@
 mod alloc_bytes;
-#[cfg(all(unix, feature = "native-lib"))]
+#[cfg(all(feature = "native-lib", unix))]
 pub mod isolated_alloc;
-#[cfg(not(all(unix, feature = "native-lib")))]
+#[cfg(not(all(feature = "native-lib", unix)))]
 pub mod isolated_alloc {
     use std::alloc::Layout;
 
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 91559e76e68c..15ad967657de 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -163,7 +163,7 @@ fn addr_from_alloc_id_uncached(
                         this.get_alloc_bytes_unchecked_raw(alloc_id)?
                     }
                 }
-                #[cfg(all(unix, feature = "native-lib"))]
+                #[cfg(all(feature = "native-lib", unix))]
                 AllocKind::Function => {
                     if let Some(GlobalAlloc::Function { instance, .. }) =
                         this.tcx.try_get_global_alloc(alloc_id)
@@ -186,7 +186,7 @@ fn addr_from_alloc_id_uncached(
                         dummy_alloc(params)
                     }
                 }
-                #[cfg(not(all(unix, feature = "native-lib")))]
+                #[cfg(not(all(feature = "native-lib", unix)))]
                 AllocKind::Function => dummy_alloc(params),
                 AllocKind::VTable | AllocKind::VaList => dummy_alloc(params),
                 AllocKind::TypeId | AllocKind::Dead => unreachable!(),
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 3766debb159d..0ec1464f9a43 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -382,7 +382,7 @@ fn exit(exit_code: i32) -> ! {
     // Drop the tracing guard before exiting, so tracing calls are flushed correctly.
     deinit_loggers();
     // Make sure the supervisor knows about the exit code.
-    #[cfg(all(unix, feature = "native-lib"))]
+    #[cfg(all(feature = "native-lib", unix))]
     miri::native_lib::register_retcode_sv(exit_code);
     // Actually exit.
     std::process::exit(exit_code);
@@ -756,7 +756,7 @@ fn main() -> ExitCode {
     debug!("crate arguments: {:?}", miri_config.args);
     if !miri_config.native_lib.is_empty() && miri_config.native_lib_enable_tracing {
         // SAFETY: No other threads are running
-        #[cfg(all(unix, feature = "native-lib"))]
+        #[cfg(all(feature = "native-lib", unix))]
         if unsafe { miri::native_lib::init_sv() }.is_err() {
             eprintln!(
                 "warning: The native-lib tracer could not be started. Is this an x86 Linux system, and does Miri have permissions to ptrace?\n\
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 155140165458..497c937e0b18 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -1,6 +1,15 @@
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![cfg_attr(bootstrap, feature(cfg_select))]
-#![feature(abort_unwind)]
+#![cfg_attr(
+    all(
+        feature = "native-lib",
+        target_os = "linux",
+        target_env = "gnu",
+        any(target_arch = "x86", target_arch = "x86_64")
+    ),
+    feature(abort_unwind)
+)]
+#![cfg_attr(all(feature = "native-lib", unix), feature(iter_advance_by))]
 #![feature(rustc_private)]
 #![feature(float_gamma)]
 #![feature(float_erf)]
@@ -10,13 +19,10 @@
 #![feature(io_error_more)]
 #![feature(variant_count)]
 #![feature(yeet_expr)]
-#![feature(nonzero_ops)]
 #![feature(pointer_is_aligned_to)]
-#![feature(ptr_metadata)]
 #![feature(unqualified_local_imports)]
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
-#![feature(iter_advance_by)]
 #![feature(macro_metavar_expr)]
 // Configure clippy and other lints
 #![allow(
@@ -43,8 +49,6 @@
     clippy::collapsible_match,
     // We are not implementing queries here so it's fine
     rustc::potential_query_instability,
-    // FIXME: Unused features should be removed in the future
-    unused_features,
 )]
 #![warn(
     rust_2018_idioms,
@@ -103,7 +107,7 @@
 use rustc_log::tracing::{self, info, trace};
 use rustc_middle::{bug, span_bug};
 
-#[cfg(all(unix, feature = "native-lib"))]
+#[cfg(all(feature = "native-lib", unix))]
 pub mod native_lib {
     pub use crate::shims::{init_sv, register_retcode_sv};
 }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 000f4ac4ceca..ab38828c2108 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -596,12 +596,12 @@ pub struct MiriMachine<'tcx> {
     pub(crate) basic_block_count: u64,
 
     /// Handle of the optional shared object file for native functions.
-    #[cfg(all(unix, feature = "native-lib"))]
+    #[cfg(all(feature = "native-lib", unix))]
     pub native_lib: Vec<(libloading::Library, std::path::PathBuf)>,
-    #[cfg(not(all(unix, feature = "native-lib")))]
+    #[cfg(not(all(feature = "native-lib", unix)))]
     pub native_lib: Vec<!>,
     /// A memory location for exchanging the current `ecx` pointer with native code.
-    #[cfg(all(unix, feature = "native-lib"))]
+    #[cfg(all(feature = "native-lib", unix))]
     pub native_lib_ecx_interchange: &'static Cell<usize>,
 
     /// Run a garbage collector for BorTags every N basic blocks.
@@ -772,7 +772,7 @@ pub(crate) fn new(
             report_progress: config.report_progress,
             basic_block_count: 0,
             monotonic_clock: MonotonicClock::new(config.isolated_op == IsolatedOp::Allow),
-            #[cfg(all(unix, feature = "native-lib"))]
+            #[cfg(all(feature = "native-lib", unix))]
             native_lib: config.native_lib.iter().map(|lib_file_path| {
                 let host_triple = rustc_session::config::host_tuple();
                 let target_triple = tcx.sess.opts.target_triple.tuple();
@@ -794,9 +794,9 @@ pub(crate) fn new(
                     lib_file_path.clone(),
                 )
             }).collect(),
-            #[cfg(all(unix, feature = "native-lib"))]
+            #[cfg(all(feature = "native-lib", unix))]
             native_lib_ecx_interchange: Box::leak(Box::new(Cell::new(0))),
-            #[cfg(not(all(unix, feature = "native-lib")))]
+            #[cfg(not(all(feature = "native-lib", unix)))]
             native_lib: config.native_lib.iter().map(|_| {
                 panic!("calling functions from native libraries via FFI is not supported in this build of Miri")
             }).collect(),
@@ -1032,7 +1032,7 @@ fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
             report_progress: _,
             basic_block_count: _,
             native_lib: _,
-            #[cfg(all(unix, feature = "native-lib"))]
+            #[cfg(all(feature = "native-lib", unix))]
             native_lib_ecx_interchange: _,
             gc_interval: _,
             since_gc: _,
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 12a170e6a849..9669fe0e44e3 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -255,7 +255,7 @@ fn emulate_foreign_item_inner(
         let this = self.eval_context_mut();
 
         // First deal with any external C functions in linked .so file.
-        #[cfg(all(unix, feature = "native-lib"))]
+        #[cfg(all(feature = "native-lib", unix))]
         if !this.machine.native_lib.is_empty() {
             use crate::shims::native_lib::EvalContextExt as _;
             // An Ok(false) here means that the function being called was not exported
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 345e16b8da71..281dfc758f4e 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -5,7 +5,7 @@
 mod backtrace;
 mod files;
 mod math;
-#[cfg(all(unix, feature = "native-lib"))]
+#[cfg(all(feature = "native-lib", unix))]
 pub mod native_lib;
 mod unix;
 mod windows;
@@ -24,7 +24,7 @@
 pub mod unwind;
 
 pub use self::files::FdTable;
-#[cfg(all(unix, feature = "native-lib"))]
+#[cfg(all(feature = "native-lib", unix))]
 pub use self::native_lib::trace::{init_sv, register_retcode_sv};
 pub use self::unix::{DirTable, EpollInterestTable};
 

From 87880340985aac06989f3acc94365ddd83127f5c Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 5 Mar 2026 18:16:07 +0800
Subject: [PATCH 0133/1059] feat: complete block .let in closure expression

Example
---
```rust
fn main() {
    let bar = 2;
    let f = || bar.$0;
}
```

**Before this PR**

Cannot complete `.let`

**After this PR**

```rust
fn main() {
    let bar = 2;
    let f = || {
        let $1 = bar;
        $0
    };
}
```
---
 .../ide-completion/src/completions/postfix.rs | 26 +++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
index ea53aef40c2e..4cf5c85d6fa3 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
@@ -16,7 +16,7 @@
 use stdx::never;
 use syntax::{
     SmolStr,
-    SyntaxKind::{EXPR_STMT, STMT_LIST},
+    SyntaxKind::{CLOSURE_EXPR, EXPR_STMT, MATCH_ARM, STMT_LIST},
     T, TextRange, TextSize, ToSmolStr,
     ast::{self, AstNode, AstToken},
     format_smolstr, match_ast,
@@ -156,7 +156,7 @@ pub(crate) fn complete_postfix(
                 postfix_snippet("letm", "let mut", &format!("let mut $0 = {receiver_text};"))
                     .add_to(acc, ctx.db);
             }
-            _ if ast::MatchArm::can_cast(parent.kind()) => {
+            _ if matches!(parent.kind(), MATCH_ARM | CLOSURE_EXPR) => {
                 postfix_snippet(
                     "let",
                     "let",
@@ -965,6 +965,28 @@ fn main() {
         );
     }
 
+    #[test]
+    fn closure_let_block() {
+        check_edit(
+            "let",
+            r#"
+fn main() {
+    let bar = 2;
+    let f = || bar.$0;
+}
+"#,
+            r#"
+fn main() {
+    let bar = 2;
+    let f = || {
+    let $1 = bar;
+    $0
+};
+}
+"#,
+        );
+    }
+
     #[test]
     fn option_letelse() {
         check_edit(

From 5701d13840031ed3061281e43794f631f41a44a6 Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Thu, 19 Feb 2026 18:42:24 +0100
Subject: [PATCH 0134/1059] refactor `PointeeInfo`

Make `size`/`align` always correct rather than conditionally on the
`safe` field. This makes it less error prone and easier to work with for
`MaybeDangling` / potential future pointer kinds like `Aligned<_>`.
---
 src/base.rs | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/base.rs b/src/base.rs
index e4865ece63b6..4f483cdc5d6c 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -10,7 +10,7 @@
 use rustc_index::IndexVec;
 use rustc_middle::ty::TypeVisitableExt;
 use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::layout::FnAbiOf;
+use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv as _};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::config::OutputFilenames;
 use rustc_span::Symbol;
@@ -924,19 +924,26 @@ fn is_wide_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
                 count,
             }) => {
                 let dst = codegen_operand(fx, dst);
-                let pointee = dst
-                    .layout()
-                    .pointee_info_at(fx, rustc_abi::Size::ZERO)
-                    .expect("Expected pointer");
+
+                let &ty::RawPtr(pointee, _) = dst.layout().ty.kind() else {
+                    bug!("expected pointer")
+                };
+                let pointee_layout = fx
+                    .tcx
+                    .layout_of(fx.typing_env().as_query_input(pointee))
+                    .expect("expected pointee to have a layout");
+                let elem_size: u64 = pointee_layout.layout.size().bytes();
+
                 let dst = dst.load_scalar(fx);
                 let src = codegen_operand(fx, src).load_scalar(fx);
                 let count = codegen_operand(fx, count).load_scalar(fx);
-                let elem_size: u64 = pointee.size.bytes();
+
                 let bytes = if elem_size != 1 {
                     fx.bcx.ins().imul_imm(count, elem_size as i64)
                 } else {
                     count
                 };
+
                 fx.bcx.call_memcpy(fx.target_config, dst, src, bytes);
             }
         },

From b8403383ff2d9a544a04d981482cb89c138db0b7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 4 Mar 2026 16:14:57 +0100
Subject: [PATCH 0135/1059] miri: make read_discriminant UB when the tag is not
 in the validity range of the tag field

---
 .../src/interpret/discriminant.rs             | 28 +++++++++++++++----
 .../enum-untagged-variant-invalid-encoding.rs |  4 +--
 ...m-untagged-variant-invalid-encoding.stderr |  4 +--
 .../invalid_enum_op_discr_uninhabited.rs      | 27 ++++++++++++++++++
 .../invalid_enum_op_discr_uninhabited.stderr  | 13 +++++++++
 .../invalid_enum_op_niche_out_of_range.rs     | 14 ++++++++++
 .../invalid_enum_op_niche_out_of_range.stderr | 13 +++++++++
 .../consts/const-eval/raw-bytes.32bit.stderr  |  2 +-
 .../consts/const-eval/raw-bytes.64bit.stderr  |  2 +-
 tests/ui/consts/const-eval/ub-enum.rs         |  2 +-
 tests/ui/consts/const-eval/ub-enum.stderr     |  2 +-
 11 files changed, 97 insertions(+), 14 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.rs
 create mode 100644 src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.stderr
 create mode 100644 src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.rs
 create mode 100644 src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.stderr

diff --git a/compiler/rustc_const_eval/src/interpret/discriminant.rs b/compiler/rustc_const_eval/src/interpret/discriminant.rs
index b7e7f65c95c7..3a7c1ea65f3d 100644
--- a/compiler/rustc_const_eval/src/interpret/discriminant.rs
+++ b/compiler/rustc_const_eval/src/interpret/discriminant.rs
@@ -111,23 +111,30 @@ pub fn read_discriminant(
                     .try_to_scalar_int()
                     .map_err(|dbg_val| err_ub!(InvalidTag(dbg_val)))?
                     .to_bits(tag_layout.size);
+                // Ensure the tag is in its layout range. Codegen adds range metadata on the
+                // discriminant load so we really have to make this UB.
+                if !tag_scalar_layout.valid_range(self).contains(tag_bits) {
+                    throw_ub!(InvalidTag(Scalar::from_uint(tag_bits, tag_layout.size)))
+                }
                 // Cast bits from tag layout to discriminant layout.
                 // After the checks we did above, this cannot fail, as
                 // discriminants are int-like.
                 let discr_val = self.int_to_int_or_float(&tag_val, discr_layout).unwrap();
                 let discr_bits = discr_val.to_scalar().to_bits(discr_layout.size)?;
-                // Convert discriminant to variant index, and catch invalid discriminants.
+                // Convert discriminant to variant index. Since we validated the tag against the
+                // layout range above, this cannot fail.
                 let index = match *ty.kind() {
                     ty::Adt(adt, _) => {
-                        adt.discriminants(*self.tcx).find(|(_, var)| var.val == discr_bits)
+                        adt.discriminants(*self.tcx).find(|(_, var)| var.val == discr_bits).unwrap()
                     }
                     ty::Coroutine(def_id, args) => {
                         let args = args.as_coroutine();
-                        args.discriminants(def_id, *self.tcx).find(|(_, var)| var.val == discr_bits)
+                        args.discriminants(def_id, *self.tcx)
+                            .find(|(_, var)| var.val == discr_bits)
+                            .unwrap()
                     }
                     _ => span_bug!(self.cur_span(), "tagged layout for non-adt non-coroutine"),
-                }
-                .ok_or_else(|| err_ub!(InvalidTag(Scalar::from_uint(tag_bits, tag_layout.size))))?;
+                };
                 // Return the cast value, and the index.
                 index.0
             }
@@ -174,13 +181,22 @@ pub fn read_discriminant(
                             let variants =
                                 ty.ty_adt_def().expect("tagged layout for non adt").variants();
                             assert!(variant_index < variants.next_index());
+                            // This should imply that the tag is in its layout range.
+                            assert!(tag_scalar_layout.valid_range(self).contains(tag_bits));
+
                             if variant_index == untagged_variant {
                                 // The untagged variant can be in the niche range, but even then it
-                                // is not a valid encoding.
+                                // is not a valid encoding. Codegen inserts an `assume` here
+                                // so we really have to make this UB.
                                 throw_ub!(InvalidTag(Scalar::from_uint(tag_bits, tag_layout.size)))
                             }
                             variant_index
                         } else {
+                            // Ensure the tag is in its layout range. Codegen adds range metadata on
+                            // the discriminant load so we really have to make this UB.
+                            if !tag_scalar_layout.valid_range(self).contains(tag_bits) {
+                                throw_ub!(InvalidTag(Scalar::from_uint(tag_bits, tag_layout.size)))
+                            }
                             untagged_variant
                         }
                     }
diff --git a/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.rs b/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.rs
index bd02e7f5fb44..2bea47e32dd9 100644
--- a/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.rs
+++ b/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.rs
@@ -20,8 +20,8 @@ fn main() {
         assert!(Foo::Var1 == mem::transmute(2u8));
         assert!(Foo::Var3 == mem::transmute(4u8));
 
-        let invalid: Foo = mem::transmute(3u8);
-        assert!(matches!(invalid, Foo::Var2(_)));
+        let invalid: *const Foo = mem::transmute(&3u8);
+        assert!(matches!(*invalid, Foo::Var2(_)));
         //~^ ERROR: invalid tag
     }
 }
diff --git a/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.stderr b/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.stderr
index e019a350ba17..b0862cf94b9a 100644
--- a/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.stderr
+++ b/src/tools/miri/tests/fail/enum-untagged-variant-invalid-encoding.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: enum value has invalid tag: 0x03
   --> tests/fail/enum-untagged-variant-invalid-encoding.rs:LL:CC
    |
-LL |         assert!(matches!(invalid, Foo::Var2(_)));
-   |                          ^^^^^^^ Undefined Behavior occurred here
+LL |         assert!(matches!(*invalid, Foo::Var2(_)));
+   |                          ^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.rs b/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.rs
new file mode 100644
index 000000000000..3d1ae64b5782
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.rs
@@ -0,0 +1,27 @@
+// Make sure we find these even with many checks disabled.
+//@compile-flags: -Zmiri-disable-alignment-check -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
+#![feature(never_type)]
+
+enum Never {}
+
+// An enum with 4 variants of which only some are uninhabited -- so the uninhabited variants *do*
+// have a discriminant.
+#[allow(unused)]
+enum UninhDiscriminant {
+    A,
+    B(!),
+    C,
+    D(Never),
+}
+
+fn main() {
+    unsafe {
+        let x = 3u8;
+        let x_ptr: *const u8 = &x;
+        let cast_ptr = x_ptr as *const UninhDiscriminant;
+        // Reading the discriminant should fail since the tag value is not in the valid
+        // range for the tag field.
+        let _val = matches!(*cast_ptr, UninhDiscriminant::A);
+        //~^ ERROR: invalid tag
+    }
+}
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.stderr b/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.stderr
new file mode 100644
index 000000000000..2e2ad81a0451
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_op_discr_uninhabited.stderr
@@ -0,0 +1,13 @@
+error: Undefined Behavior: enum value has invalid tag: 0x03
+  --> tests/fail/validity/invalid_enum_op_discr_uninhabited.rs:LL:CC
+   |
+LL |         let _val = matches!(*cast_ptr, UninhDiscriminant::A);
+   |                             ^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.rs b/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.rs
new file mode 100644
index 000000000000..51237c360f1c
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.rs
@@ -0,0 +1,14 @@
+// Make sure we find these even with many checks disabled.
+//@compile-flags: -Zmiri-disable-alignment-check -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
+
+fn main() {
+    unsafe {
+        let x = 12u8;
+        let x_ptr: *const u8 = &x;
+        let cast_ptr = x_ptr as *const Option<bool>;
+        // Reading the discriminant should fail since the tag value is not in the valid
+        // range for the tag field.
+        let _val = matches!(*cast_ptr, None);
+        //~^ ERROR: invalid tag
+    }
+}
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.stderr b/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.stderr
new file mode 100644
index 000000000000..65fcddbb43da
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_op_niche_out_of_range.stderr
@@ -0,0 +1,13 @@
+error: Undefined Behavior: enum value has invalid tag: 0x0c
+  --> tests/fail/validity/invalid_enum_op_niche_out_of_range.rs:LL:CC
+   |
+LL |         let _val = matches!(*cast_ptr, None);
+   |                             ^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
index be3b539b269a..acbf19d6ad77 100644
--- a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
@@ -31,7 +31,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                01                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:47:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
diff --git a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
index 9950ac726ca7..52d32fd3f875 100644
--- a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
@@ -31,7 +31,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                01                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:47:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
diff --git a/tests/ui/consts/const-eval/ub-enum.rs b/tests/ui/consts/const-eval/ub-enum.rs
index 9c78bb6efed7..63029e17da22 100644
--- a/tests/ui/consts/const-eval/ub-enum.rs
+++ b/tests/ui/consts/const-eval/ub-enum.rs
@@ -83,7 +83,7 @@ enum UninhDiscriminant {
 const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
 //~^ ERROR uninhabited enum variant
 const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
-//~^ ERROR uninhabited enum variant
+//~^ ERROR expected a valid enum tag
 
 // # other
 
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index 1efd93832291..da63af30480e 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -86,7 +86,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
   --> $DIR/ub-enum.rs:85:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };

From 9a224202e434c2e16f92f9803c65e07dc8e06875 Mon Sep 17 00:00:00 2001
From: Aliaksei Semianiuk <alexsemenyuk88@gmail.com>
Date: Sat, 21 Feb 2026 15:40:37 +0500
Subject: [PATCH 0136/1059] Changelog for Clippy 1.94

---
 CHANGELOG.md                                 | 98 +++++++++++++++++++-
 clippy_lints/src/casts/mod.rs                |  2 +-
 clippy_lints/src/manual_ilog2.rs             |  2 +-
 clippy_lints/src/methods/mod.rs              |  2 +-
 clippy_lints/src/operators/mod.rs            |  2 +-
 clippy_lints/src/same_length_and_capacity.rs |  2 +-
 6 files changed, 102 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c798a3c2e5a..531c8794a572 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,103 @@ document.
 
 ## Unreleased / Beta / In Rust Nightly
 
-[92b4b68...master](https://github.com/rust-lang/rust-clippy/compare/92b4b68...master)
+[500e0ff...master](https://github.com/rust-lang/rust-clippy/compare/500e0ff...master)
+
+## Rust 1.94
+
+Current stable, released 2026-03-05
+
+[View all 94 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2025-11-29T21%3A01%3A29Z..2026-01-08T20%3A33%3A22Z+base%3Amaster)
+
+### New Lints
+
+* Added [`same_length_and_capacity`] to `pedantic`
+  [#15656](https://github.com/rust-lang/rust-clippy/pull/15656)
+* Added [`manual_ilog2`] to `pedantic`
+  [#15865](https://github.com/rust-lang/rust-clippy/pull/15865)
+* Added [`needless_type_cast`] to `nursery`
+  [#16139](https://github.com/rust-lang/rust-clippy/pull/16139)
+* Added [`ptr_offset_by_literal`] to `pedantic`
+  [#15606](https://github.com/rust-lang/rust-clippy/pull/15606)
+* Added [`decimal_bitwise_operands`] to `pedantic`
+  [#15215](https://github.com/rust-lang/rust-clippy/pull/15215)
+
+### Moves and Deprecations
+
+* Moved [`multiple_bound_locations`] from `suspicious` to `style`
+  [#16302](https://github.com/rust-lang/rust-clippy/pull/16302)
+* Moved [`collapsible_else_if`] from `style` to `pedantic`
+  [#16211](https://github.com/rust-lang/rust-clippy/pull/16211)
+* Moved [`needless_type_cast`] from `pedantic` to `nursery`
+  [#16246](https://github.com/rust-lang/rust-clippy/pull/16246)
+
+### Enhancements
+
+* [`never_loop`] do not consider `return` as preventing the iterator from looping; lint diverging
+  iterator reduction closures like `for_each` and `fold`
+  [#16364](https://github.com/rust-lang/rust-clippy/pull/16364)
+* [`single_range_in_vec_init`] don't apply the suggestion automatically
+  [#16365](https://github.com/rust-lang/rust-clippy/pull/16365)
+* [`useless_conversion`] refine `.into_iter()` suggestions to stop at final target type
+  [#16238](https://github.com/rust-lang/rust-clippy/pull/16238)
+* Multiple lints fix wrongly unmangled macros
+  [#16337](https://github.com/rust-lang/rust-clippy/pull/16337)
+* [`large_stack_arrays`] do not warn for libtest harness
+  [#16347](https://github.com/rust-lang/rust-clippy/pull/16347)
+* [`derive_ord_xor_partial_ord`] allow `expect` on `impl` block
+  [#16303](https://github.com/rust-lang/rust-clippy/pull/16303)
+* [`match_bool`] restrict to 2 arms
+  [#16333](https://github.com/rust-lang/rust-clippy/pull/16333)
+* [`multiple_inherent_impl`] fix false negatives for generic impl blocks
+  [#16284](https://github.com/rust-lang/rust-clippy/pull/16284)
+* [`unnecessary_fold`] warn about semantics change and lint `Add::add`/`Mul::mul` folds
+  [#16324](https://github.com/rust-lang/rust-clippy/pull/16324)
+* [`transmuting_null`] check const blocks and const integer casts
+  [#16260](https://github.com/rust-lang/rust-clippy/pull/16260)
+* [`needless_pass_by_ref_mut`] preserve user-provided lifetime information
+  [#16273](https://github.com/rust-lang/rust-clippy/pull/16273)
+* [`while_let_on_iterator`] use reborrow for non-`Sized` trait references
+  [#16100](https://github.com/rust-lang/rust-clippy/pull/16100)
+* [`collapsible_else_if`] prevent emitting when arms only `if {..} else {..}`
+  [#16286](https://github.com/rust-lang/rust-clippy/pull/16286)
+* [`multiple_unsafe_ops_per_block`] count only towards innermost unsafe block
+  [#16117](https://github.com/rust-lang/rust-clippy/pull/16117)
+* [`manual_saturating_arithmetic`] lint `x.checked_sub(y).unwrap_or_default()`
+  [#15845](https://github.com/rust-lang/rust-clippy/pull/15845)
+* [`transmute_ptr_to_ref`] handle pointer in struct
+  [#15948](https://github.com/rust-lang/rust-clippy/pull/15948)
+* [`disallowed_methods`] skip compiler-generated code
+  [#16186](https://github.com/rust-lang/rust-clippy/pull/16186)
+* [`missing_enforced_import_renames`] do not enforce for "as _"
+  [#16352](https://github.com/rust-lang/rust-clippy/pull/16352)
+
+### False Positive Fixes
+
+* [`double_parens`] fix FP on macro repetition patterns
+  [#16301](https://github.com/rust-lang/rust-clippy/pull/16301)
+* [`assertions_on_constants`] fix false positive when there is non-constant value in condition expr
+  [#16297](https://github.com/rust-lang/rust-clippy/pull/16297)
+* [`use_self`] fix FP on type in const generics
+  [#16172](https://github.com/rust-lang/rust-clippy/pull/16172)
+* [`set_contains_or_insert`] fix FP when set is mutated before `insert`
+  [#16009](https://github.com/rust-lang/rust-clippy/pull/16009)
+* [`if_then_some_else_none`] fix FP when then block contains `await`
+  [#16178](https://github.com/rust-lang/rust-clippy/pull/16178)
+* [`match_like_matches_macro`] fix FP with guards containing `if let`
+  [#15876](https://github.com/rust-lang/rust-clippy/pull/15876)
+* [`tuple_array_conversions`] fix FP when binded vars are used before conversion
+  [#16197](https://github.com/rust-lang/rust-clippy/pull/16197)
+* [`map_entry`] fix FP when it would cause `MutexGuard` to be held across await
+  [#16199](https://github.com/rust-lang/rust-clippy/pull/16199)
+* [`panicking_unwrap`] fix FP on field access with implicit deref
+  [#16196](https://github.com/rust-lang/rust-clippy/pull/16196)
+* [`large_stack_frames`] fix FP on compiler generated targets
+  [#15101](https://github.com/rust-lang/rust-clippy/pull/15101)
+
+### ICE Fixes
+
+* [`needless_type_cast`] do not ICE on struct constructor
+  [#16245](https://github.com/rust-lang/rust-clippy/pull/16245)
 
 ### New Lints
 
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 75761de4ae73..151f9c956c6d 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -691,7 +691,7 @@
     /// const SIZE: usize = 15;
     /// let arr: [u8; SIZE] = [0; SIZE];
     /// ```
-    #[clippy::version = "1.93.0"]
+    #[clippy::version = "1.94.0"]
     pub NEEDLESS_TYPE_CAST,
     nursery,
     "binding defined with one type but always cast to another"
diff --git a/clippy_lints/src/manual_ilog2.rs b/clippy_lints/src/manual_ilog2.rs
index 7c397bd3f5e8..2c368f15d670 100644
--- a/clippy_lints/src/manual_ilog2.rs
+++ b/clippy_lints/src/manual_ilog2.rs
@@ -31,7 +31,7 @@
     /// let log = x.ilog2();
     /// let log = x.ilog2();
     /// ```
-    #[clippy::version = "1.93.0"]
+    #[clippy::version = "1.94.0"]
     pub MANUAL_ILOG2,
     pedantic,
     "manually reimplementing `ilog2`"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0ed166f8dd5b..48ab42d587c8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3030,7 +3030,7 @@
     ///     ptr.sub(8);
     /// }
     /// ```
-    #[clippy::version = "1.92.0"]
+    #[clippy::version = "1.94.0"]
     pub PTR_OFFSET_BY_LITERAL,
     pedantic,
     "unneeded pointer offset"
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 567443b8e86d..b4519d654722 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -221,7 +221,7 @@
     /// ```rust,no_run
     /// let a = 0b1110 & 0b0110;
     /// ```
-    #[clippy::version = "1.93.0"]
+    #[clippy::version = "1.94.0"]
     pub DECIMAL_BITWISE_OPERANDS,
     pedantic,
     "use binary, hex, or octal literals for bitwise operations"
diff --git a/clippy_lints/src/same_length_and_capacity.rs b/clippy_lints/src/same_length_and_capacity.rs
index b200fd1fe25f..ebf649c24307 100644
--- a/clippy_lints/src/same_length_and_capacity.rs
+++ b/clippy_lints/src/same_length_and_capacity.rs
@@ -65,7 +65,7 @@
     /// // This time, leverage the previously saved capacity:
     /// let reconstructed = unsafe { Vec::from_raw_parts(ptr, len, cap) };
     /// ```
-    #[clippy::version = "1.93.0"]
+    #[clippy::version = "1.94.0"]
     pub SAME_LENGTH_AND_CAPACITY,
     pedantic,
     "`from_raw_parts` with same length and capacity"

From b4d244543239d6be118a3640f1691ab9fbc19cb7 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 5 Mar 2026 17:18:20 +0100
Subject: [PATCH 0137/1059] Merge commit
 'e645f93552c3926a0bb481a777df120b7bce986f'

---
 .github/workflows/clippy_changelog.yml        |    3 +-
 Cargo.toml                                    |    2 +-
 book/src/development/the_team.md              |    2 +-
 clippy_config/Cargo.toml                      |    2 +-
 clippy_dev/src/edit_lints.rs                  |   11 +-
 clippy_dev/src/fmt.rs                         |   30 +-
 clippy_dev/src/generate.rs                    |  316 +
 clippy_dev/src/lib.rs                         |    3 +-
 clippy_dev/src/main.rs                        |    7 +-
 clippy_dev/src/parse.rs                       |  187 +-
 clippy_dev/src/parse/cursor.rs                |   86 +-
 clippy_dev/src/update_lints.rs                |  204 -
 clippy_dev/src/utils.rs                       |   27 +
 clippy_lints/Cargo.toml                       |    2 +-
 clippy_lints/src/absolute_paths.rs            |    1 +
 clippy_lints/src/almost_complete_range.rs     |    1 +
 clippy_lints/src/approx_const.rs              |    4 +-
 clippy_lints/src/arc_with_non_send_sync.rs    |    1 +
 clippy_lints/src/asm_syntax.rs                |   96 +-
 clippy_lints/src/assertions_on_constants.rs   |    1 +
 clippy_lints/src/assigning_clones.rs          |    4 +-
 clippy_lints/src/attrs/mod.rs                 |  623 +-
 clippy_lints/src/await_holding_invalid.rs     |   80 +-
 clippy_lints/src/bool_to_int_with_if.rs       |    1 +
 clippy_lints/src/booleans.rs                  |    4 +-
 clippy_lints/src/box_default.rs               |    2 +-
 clippy_lints/src/byte_char_slices.rs          |    1 +
 clippy_lints/src/cargo/mod.rs                 |  254 +-
 clippy_lints/src/casts/mod.rs                 | 1010 +--
 clippy_lints/src/checked_conversions.rs       |    4 +-
 clippy_lints/src/cloned_ref_to_slice_refs.rs  |    4 +-
 clippy_lints/src/coerce_container_to_any.rs   |    1 +
 clippy_lints/src/cognitive_complexity.rs      |    4 +-
 clippy_lints/src/collapsible_if.rs            |   68 +-
 clippy_lints/src/collection_is_never_read.rs  |    3 +-
 clippy_lints/src/crate_in_macro_def.rs        |    1 +
 clippy_lints/src/dbg_macro.rs                 |    6 +-
 clippy_lints/src/default.rs                   |    4 +-
 .../src/default_constructed_unit_structs.rs   |    5 +-
 .../src/default_instead_of_iter_empty.rs      |    1 +
 .../src/default_union_representation.rs       |    1 +
 clippy_lints/src/dereference.rs               |   52 +-
 clippy_lints/src/derivable_impls.rs           |    4 +-
 clippy_lints/src/derive/mod.rs                |  128 +-
 clippy_lints/src/disallowed_fields.rs         |    4 +-
 clippy_lints/src/disallowed_macros.rs         |    4 +-
 clippy_lints/src/disallowed_methods.rs        |    4 +-
 clippy_lints/src/disallowed_names.rs          |    4 +-
 clippy_lints/src/disallowed_script_idents.rs  |    4 +-
 clippy_lints/src/disallowed_types.rs          |    4 +-
 .../doc/doc_paragraphs_missing_punctuation.rs |   22 +-
 clippy_lints/src/doc/mod.rs                   |  832 +-
 clippy_lints/src/drop_forget_ref.rs           |    8 +-
 clippy_lints/src/duplicate_mod.rs             |    4 +-
 clippy_lints/src/empty_drop.rs                |    1 +
 clippy_lints/src/empty_line_after.rs          |   80 +-
 clippy_lints/src/empty_with_brackets.rs       |   63 +-
 clippy_lints/src/endian_bytes.rs              |   42 +-
 clippy_lints/src/entry.rs                     |    5 +-
 clippy_lints/src/error_impl_error.rs          |    1 +
 clippy_lints/src/escape.rs                    |    4 +-
 clippy_lints/src/eta_reduction.rs             |   29 +-
 clippy_lints/src/excessive_bools.rs           |   81 +-
 clippy_lints/src/excessive_nesting.rs         |    1 +
 clippy_lints/src/explicit_write.rs            |    4 +-
 .../src/extra_unused_type_parameters.rs       |    4 +-
 .../src/field_scoped_visibility_modifiers.rs  |    4 +-
 clippy_lints/src/float_literal.rs             |    6 +-
 .../src/floating_point_arithmetic/mod.rs      |    5 +-
 .../src/floating_point_arithmetic/mul_add.rs  |  159 +-
 clippy_lints/src/format.rs                    |    4 +-
 clippy_lints/src/format_args.rs               |  136 +-
 clippy_lints/src/format_impl.rs               |   82 +-
 clippy_lints/src/format_push_string.rs        |    1 +
 clippy_lints/src/formatting.rs                |  138 +-
 clippy_lints/src/four_forward_slashes.rs      |    1 +
 clippy_lints/src/from_over_into.rs            |    4 +-
 clippy_lints/src/from_raw_with_void_ptr.rs    |    1 +
 clippy_lints/src/functions/mod.rs             |  552 +-
 clippy_lints/src/functions/must_use.rs        |    2 +-
 clippy_lints/src/if_then_some_else_none.rs    |    4 +-
 clippy_lints/src/ifs/mod.rs                   |  124 +-
 clippy_lints/src/ignored_unit_patterns.rs     |    1 +
 .../impl_hash_with_borrow_str_and_bytes.rs    |    4 +-
 clippy_lints/src/implicit_saturating_add.rs   |    1 +
 clippy_lints/src/implicit_saturating_sub.rs   |    7 +-
 clippy_lints/src/implied_bounds_in_impls.rs   |    1 +
 clippy_lints/src/incompatible_msrv.rs         |    4 +-
 .../src/inconsistent_struct_constructor.rs    |    6 +-
 clippy_lints/src/index_refutable_slice.rs     |    4 +-
 clippy_lints/src/indexing_slicing.rs          |   60 +-
 clippy_lints/src/infallible_try_from.rs       |    1 +
 clippy_lints/src/inherent_to_string.rs        |    5 +-
 clippy_lints/src/item_name_repetitions.rs     |   75 +-
 clippy_lints/src/iter_without_into_iter.rs    |   93 +-
 clippy_lints/src/large_const_arrays.rs        |    4 +-
 clippy_lints/src/large_enum_variant.rs        |    4 +-
 clippy_lints/src/large_futures.rs             |    4 +-
 clippy_lints/src/large_include_file.rs        |    4 +-
 clippy_lints/src/large_stack_arrays.rs        |    6 +-
 clippy_lints/src/large_stack_frames.rs        |    4 +-
 clippy_lints/src/legacy_numeric_constants.rs  |    9 +-
 clippy_lints/src/len_zero.rs                  |   74 +-
 clippy_lints/src/let_underscore.rs            |   73 +-
 clippy_lints/src/let_with_type_underscore.rs  |    1 +
 clippy_lints/src/lifetimes.rs                 |   82 +-
 clippy_lints/src/literal_representation.rs    |  160 +-
 .../literal_string_with_formatting_args.rs    |    4 +-
 .../src/loops/explicit_counter_loop.rs        |  133 +-
 clippy_lints/src/loops/infinite_loop.rs       |   12 +-
 .../src/loops/manual_while_let_some.rs        |    2 +-
 clippy_lints/src/loops/mod.rs                 | 1004 +--
 clippy_lints/src/macro_metavars_in_unsafe.rs  |    1 +
 clippy_lints/src/macro_use.rs                 |    4 +-
 clippy_lints/src/main_recursion.rs            |    4 +-
 clippy_lints/src/manual_bits.rs               |    6 +-
 clippy_lints/src/manual_checked_ops.rs        |    1 +
 clippy_lints/src/manual_clamp.rs              |    1 +
 clippy_lints/src/manual_float_methods.rs      |   50 +-
 clippy_lints/src/manual_hash_one.rs           |    4 +-
 clippy_lints/src/manual_ilog2.rs              |    4 +-
 clippy_lints/src/manual_is_ascii_check.rs     |    1 +
 clippy_lints/src/manual_is_power_of_two.rs    |    4 +-
 clippy_lints/src/manual_main_separator_str.rs |    4 +-
 clippy_lints/src/manual_non_exhaustive.rs     |    4 +-
 clippy_lints/src/manual_option_as_slice.rs    |    4 +-
 clippy_lints/src/manual_range_patterns.rs     |    1 +
 clippy_lints/src/manual_rem_euclid.rs         |    4 +-
 clippy_lints/src/manual_retain.rs             |    6 +-
 .../src/manual_slice_size_calculation.rs      |    1 +
 clippy_lints/src/manual_string_new.rs         |    1 +
 clippy_lints/src/manual_strip.rs              |    4 +-
 clippy_lints/src/manual_take.rs               |    5 +-
 clippy_lints/src/matches/mod.rs               | 1682 ++--
 clippy_lints/src/mem_replace.rs               |   62 +-
 clippy_lints/src/methods/clear_with_drain.rs  |    2 +-
 clippy_lints/src/methods/filetype_is_file.rs  |    2 +-
 clippy_lints/src/methods/filter_next.rs       |    2 +-
 .../methods/from_iter_instead_of_collect.rs   |    2 +-
 clippy_lints/src/methods/get_unwrap.rs        |    2 +-
 .../src/methods/iter_out_of_bounds.rs         |    2 +-
 .../src/methods/join_absolute_paths.rs        |    2 +-
 clippy_lints/src/methods/mod.rs               | 7192 +++++++++--------
 .../src/methods/option_as_ref_deref.rs        |    2 +-
 clippy_lints/src/methods/or_fun_call.rs       |    3 +-
 .../src/methods/readonly_write_lock.rs        |    5 +-
 .../methods/suspicious_command_arg_space.rs   |    3 +-
 .../src/methods/unwrap_expect_used.rs         |   80 +-
 clippy_lints/src/min_ident_chars.rs           |    1 +
 clippy_lints/src/misc.rs                      |   44 +-
 clippy_lints/src/misc_early/mod.rs            |  340 +-
 .../src/mismatching_type_param_order.rs       |    1 +
 .../src/missing_asserts_for_indexing.rs       |    1 +
 .../src/missing_const_for_thread_local.rs     |    4 +-
 clippy_lints/src/missing_doc.rs               |    4 +-
 .../src/missing_enforced_import_rename.rs     |    4 +-
 clippy_lints/src/missing_fields_in_debug.rs   |    1 +
 clippy_lints/src/missing_inline.rs            |    4 +-
 clippy_lints/src/missing_trait_methods.rs     |    1 +
 .../src/mixed_read_write_in_expression.rs     |   61 +-
 .../src/multiple_unsafe_ops_per_block.rs      |    1 +
 clippy_lints/src/mut_key.rs                   |    6 +-
 clippy_lints/src/needless_bool.rs             |    1 +
 .../src/needless_borrows_for_generic_args.rs  |    6 +-
 clippy_lints/src/needless_else.rs             |    1 +
 clippy_lints/src/needless_ifs.rs              |    1 +
 clippy_lints/src/needless_late_init.rs        |    1 +
 clippy_lints/src/needless_maybe_sized.rs      |    1 +
 .../src/needless_parens_on_range_literals.rs  |    4 +-
 clippy_lints/src/needless_pass_by_ref_mut.rs  |    4 +-
 clippy_lints/src/new_without_default.rs       |    4 +-
 clippy_lints/src/no_effect.rs                 |    8 +-
 clippy_lints/src/no_mangle_with_rust_abi.rs   |    1 +
 clippy_lints/src/non_canonical_impls.rs       |    7 +-
 clippy_lints/src/non_copy_const.rs            |  117 +-
 clippy_lints/src/non_expressive_names.rs      |   86 +-
 .../src/non_send_fields_in_send_ty.rs         |    4 +-
 clippy_lints/src/non_std_lazy_statics.rs      |    4 +-
 clippy_lints/src/nonstandard_macro_braces.rs  |    4 +-
 clippy_lints/src/only_used_in_recursion.rs    |    6 +-
 .../src/operators/arithmetic_side_effects.rs  |    3 +-
 clippy_lints/src/operators/cmp_owned.rs       |    6 +-
 clippy_lints/src/operators/mod.rs             |  840 +-
 clippy_lints/src/panic_in_result_fn.rs        |    2 +-
 clippy_lints/src/panic_unimplemented.rs       |   36 +-
 clippy_lints/src/partial_pub_fields.rs        |    1 +
 clippy_lints/src/partialeq_to_none.rs         |    1 +
 clippy_lints/src/pass_by_ref_or_value.rs      |   71 +-
 .../src/permissions_set_readonly_false.rs     |    5 +-
 clippy_lints/src/ptr/mod.rs                   |   74 +-
 clippy_lints/src/pub_underscore_fields.rs     |    4 +-
 clippy_lints/src/pub_use.rs                   |    1 +
 clippy_lints/src/question_mark.rs             |    4 +-
 clippy_lints/src/ranges.rs                    |  142 +-
 clippy_lints/src/raw_strings.rs               |   44 +-
 clippy_lints/src/rc_clone_in_vec_init.rs      |    1 +
 clippy_lints/src/read_zero_byte_vec.rs        |    1 +
 clippy_lints/src/redundant_async_block.rs     |    1 +
 clippy_lints/src/redundant_clone.rs           |   30 +-
 clippy_lints/src/redundant_field_names.rs     |    4 +-
 clippy_lints/src/redundant_locals.rs          |    1 +
 clippy_lints/src/redundant_pub_crate.rs       |    4 +-
 clippy_lints/src/redundant_slicing.rs         |   50 +-
 .../src/redundant_static_lifetimes.rs         |    4 +-
 .../src/redundant_type_annotations.rs         |    1 +
 clippy_lints/src/ref_patterns.rs              |    1 +
 clippy_lints/src/regex.rs                     |   64 +-
 clippy_lints/src/replace_box.rs               |    4 +-
 .../src/reserve_after_initialization.rs       |    1 +
 clippy_lints/src/returns/mod.rs               |    6 +-
 clippy_lints/src/same_length_and_capacity.rs  |    1 +
 clippy_lints/src/semicolon_block.rs           |    2 +
 clippy_lints/src/shadow.rs                    |   58 +-
 clippy_lints/src/single_call_fn.rs            |    1 +
 .../src/single_component_path_imports.rs      |    4 +-
 clippy_lints/src/single_range_in_vec_init.rs  |    1 +
 clippy_lints/src/size_of_ref.rs               |    1 +
 clippy_lints/src/std_instead_of_core.rs       |  102 +-
 clippy_lints/src/string_patterns.rs           |    7 +-
 clippy_lints/src/strings.rs                   |  174 +-
 clippy_lints/src/strlen_on_c_strings.rs       |    4 +-
 .../src/suspicious_operation_groupings.rs     |    4 +-
 clippy_lints/src/suspicious_trait_impl.rs     |    5 +-
 .../src/suspicious_xor_used_as_pow.rs         |    1 +
 clippy_lints/src/swap.rs                      |   54 +-
 clippy_lints/src/swap_ptr_to_ref.rs           |    1 +
 clippy_lints/src/temporary_assignment.rs      |    4 +-
 clippy_lints/src/time_subtraction.rs          |    7 +-
 clippy_lints/src/trailing_empty_array.rs      |    1 +
 clippy_lints/src/trait_bounds.rs              |   53 +-
 clippy_lints/src/transmute/mod.rs             |  656 +-
 .../src/transmute/transmuting_null.rs         |    2 +-
 clippy_lints/src/tuple_array_conversions.rs   |    1 +
 clippy_lints/src/types/box_collection.rs      |    2 +-
 clippy_lints/src/types/linked_list.rs         |    2 +-
 clippy_lints/src/types/mod.rs                 |  330 +-
 clippy_lints/src/types/owned_cow.rs           |    2 +-
 clippy_lints/src/types/rc_buffer.rs           |    2 +-
 clippy_lints/src/unconditional_recursion.rs   |    6 +-
 .../src/undocumented_unsafe_blocks.rs         |    8 +-
 clippy_lints/src/unicode.rs                   |    6 +-
 clippy_lints/src/unit_types/mod.rs            |   44 +-
 clippy_lints/src/unnecessary_box_returns.rs   |    4 +-
 .../src/unnecessary_map_on_constructor.rs     |    5 +-
 .../src/unnecessary_owned_empty_strings.rs    |    5 +-
 clippy_lints/src/unnecessary_semicolon.rs     |    4 +-
 .../src/unnecessary_struct_initialization.rs  |    1 +
 clippy_lints/src/unnecessary_wraps.rs         |    4 +-
 clippy_lints/src/unnested_or_patterns.rs      |    4 +-
 clippy_lints/src/unused_async.rs              |    4 +-
 clippy_lints/src/unused_result_ok.rs          |    1 +
 clippy_lints/src/unused_rounding.rs           |    1 +
 clippy_lints/src/unused_self.rs               |    4 +-
 clippy_lints/src/unused_trait_names.rs        |    4 +-
 clippy_lints/src/unwrap.rs                    |   56 +-
 clippy_lints/src/unwrap_in_result.rs          |    2 +-
 clippy_lints/src/upper_case_acronyms.rs       |    4 +-
 clippy_lints/src/use_self.rs                  |    4 +-
 clippy_lints/src/useless_conversion.rs        |    4 +-
 clippy_lints/src/visibility.rs                |    9 +-
 clippy_lints/src/volatile_composites.rs       |    1 +
 clippy_lints/src/wildcard_imports.rs          |    4 +-
 clippy_lints/src/write/mod.rs                 |  182 +-
 clippy_lints/src/zombie_processes.rs          |    1 +
 .../derive_deserialize_allowing_unknown.rs    |    6 +-
 .../src/repeated_is_diagnostic_item.rs        |    6 +-
 clippy_lints_internal/src/symbols.rs          |    2 +-
 clippy_utils/Cargo.toml                       |    2 +-
 clippy_utils/README.md                        |    2 +-
 clippy_utils/src/hir_utils.rs                 |   69 +-
 clippy_utils/src/macros.rs                    |    1 +
 clippy_utils/src/mir/mod.rs                   |   63 +-
 clippy_utils/src/sym.rs                       |    2 -
 declare_clippy_lint/Cargo.toml                |    2 +-
 rust-toolchain.toml                           |    2 +-
 tests/compile-test.rs                         |    9 +-
 tests/test_utils/mod.rs                       |    7 +-
 tests/ui/cmp_owned/with_suggestion.fixed      |    8 +
 tests/ui/cmp_owned/with_suggestion.rs         |    8 +
 tests/ui/cmp_owned/with_suggestion.stderr     |    8 +-
 ...oc_paragraphs_missing_punctuation_emoji.rs |   12 +
 ...aragraphs_missing_punctuation_emoji.stderr |   11 +
 tests/ui/eta.fixed                            |    9 +
 tests/ui/eta.rs                               |    9 +
 tests/ui/eta.stderr                           |    8 +-
 tests/ui/explicit_counter_loop.rs             |   15 +
 tests/ui/floating_point_mul_add.fixed         |   12 +
 tests/ui/floating_point_mul_add.rs            |   12 +
 tests/ui/floating_point_mul_add.stderr        |   14 +-
 tests/ui/if_same_then_else.rs                 |   17 +
 tests/ui/infinite_loops.rs                    |   53 +
 tests/ui/infinite_loops.stderr                |  131 +-
 tests/ui/must_use_candidates.fixed            |   14 +-
 tests/ui/must_use_candidates.stderr           |   14 +-
 ...gle_component_path_imports_nested_first.rs |    1 +
 ...component_path_imports_nested_first.stderr |    4 +-
 tests/ui/uninlined_format_args.fixed          |   21 +
 tests/ui/uninlined_format_args.rs             |   21 +
 ...nlined_format_args_panic.edition2018.fixed |   34 +-
 ...lined_format_args_panic.edition2018.stderr |    2 +-
 ...nlined_format_args_panic.edition2021.fixed |   34 +-
 ...lined_format_args_panic.edition2021.stderr |   50 +-
 ...nlined_format_args_panic.edition2024.fixed |   70 +
 ...lined_format_args_panic.edition2024.stderr |  112 +
 tests/ui/uninlined_format_args_panic.rs       |   34 +-
 triagebot.toml                                |   25 +
 306 files changed, 11449 insertions(+), 10159 deletions(-)
 create mode 100644 clippy_dev/src/generate.rs
 delete mode 100644 clippy_dev/src/update_lints.rs
 create mode 100644 tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.rs
 create mode 100644 tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.stderr
 create mode 100644 tests/ui/uninlined_format_args_panic.edition2024.fixed
 create mode 100644 tests/ui/uninlined_format_args_panic.edition2024.stderr

diff --git a/.github/workflows/clippy_changelog.yml b/.github/workflows/clippy_changelog.yml
index 4d84d6b6dae4..121e1b84543f 100644
--- a/.github/workflows/clippy_changelog.yml
+++ b/.github/workflows/clippy_changelog.yml
@@ -20,7 +20,8 @@ jobs:
     - name: Check Changelog
       if: ${{ github.event_name == 'pull_request' }}
       run: |
-        if [[ -z $(grep -oP 'changelog: *\K\S+' <<< "$PR_BODY") ]]; then
+        # Checks that the PR body contains a changelog entry, ignoring the placeholder from the PR template.
+        if [[ -z $(grep -oP 'changelog: *\K(?!\[`lint_name`\])\S+' <<< "$PR_BODY") ]]; then
           echo "::error::Pull request message must contain 'changelog: ...' with your changelog. Please add it."
           exit 1
         fi
diff --git a/Cargo.toml b/Cargo.toml
index 8f5ef9ca2f8f..bcd800930c51 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.1.95"
+version = "0.1.96"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/book/src/development/the_team.md b/book/src/development/the_team.md
index d22123231868..a663158c949b 100644
--- a/book/src/development/the_team.md
+++ b/book/src/development/the_team.md
@@ -51,7 +51,7 @@ this group to help with triaging, which can include:
     busy or wants to abandon it. If the reviewer is busy, the PR can be
     reassigned to someone else.
 
-    Checkout: https://triage.rust-lang.org/triage/rust-lang/rust-clippy to
+    Checkout: <https://triage.rust-lang.org/triage/rust-lang/rust-clippy> to
     monitor PRs.
 
 While not part of their duties, contributors are encouraged to review PRs
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index da5166392b4e..366c776b8f1a 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_config"
-version = "0.1.95"
+version = "0.1.96"
 edition = "2024"
 publish = false
 
diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
index 411bf530b22b..70c096783af8 100644
--- a/clippy_dev/src/edit_lints.rs
+++ b/clippy_dev/src/edit_lints.rs
@@ -1,6 +1,5 @@
 use crate::parse::cursor::{self, Capture, Cursor};
 use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, RenamedLint};
-use crate::update_lints::generate_lint_files;
 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,
@@ -40,7 +39,7 @@ pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name
     };
 
     remove_lint_declaration(name, &prev_lint, &data, &mut FileUpdater::default());
-    generate_lint_files(UpdateMode::Change, &data);
+    data.gen_decls(UpdateMode::Change);
     println!("info: `{name}` has successfully been deprecated");
     println!("note: you must run `cargo uitest` to update the test results");
 }
@@ -74,7 +73,7 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
             updater.update_file(e.path(), &mut update_fn);
         }
     }
-    generate_lint_files(UpdateMode::Change, &data);
+    data.gen_decls(UpdateMode::Change);
     println!("info: `{old_name}` has successfully been uplifted as `{new_name}`");
     println!("note: you must run `cargo uitest` to update the test results");
 }
@@ -151,7 +150,7 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
             updater.update_file(e.path(), &mut update_fn);
         }
     }
-    generate_lint_files(UpdateMode::Change, &data);
+    data.gen_decls(UpdateMode::Change);
 
     println!("Renamed `{old_name}` to `{new_name}`");
     println!("All code referencing the old name has been updated");
@@ -172,11 +171,11 @@ fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &LintData<'_
         delete_file_if_exists(lint.path.as_ref())
     } else {
         updater.update_file(&lint.path, &mut |_, src, dst| -> UpdateStatus {
-            let mut start = &src[..lint.declaration_range.start];
+            let mut start = &src[..lint.declaration_range.start as usize];
             if start.ends_with("\n\n") {
                 start = &start[..start.len() - 1];
             }
-            let mut end = &src[lint.declaration_range.end..];
+            let mut end = &src[lint.declaration_range.end as usize..];
             if end.starts_with("\n\n") {
                 end = &end[1..];
             }
diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index 781e37e6144e..d13f966b19c3 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -1,3 +1,6 @@
+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,
     walk_dir_no_dot_or_target,
@@ -326,10 +329,35 @@ fn run_rustfmt(update_mode: UpdateMode) {
 
 // the "main" function of cargo dev fmt
 pub fn run(update_mode: UpdateMode) {
-    run_rustfmt(update_mode);
     fmt_syms(update_mode);
     if let Err(e) = fmt_conf(update_mode.is_check()) {
         e.display();
         process::exit(1);
     }
+
+    new_parse_cx(|cx| {
+        let mut data = cx.parse_lint_decls();
+        let (mut lints, passes) = data.split_by_lint_file();
+        let mut updater = FileUpdater::default();
+        let mut ranges = VecBuf::with_capacity(256);
+
+        for passes in passes {
+            let path = passes[0].path.clone();
+            let mut lints = lints.remove(&*path);
+            let lints = lints.as_deref_mut().unwrap_or_default();
+            updater.update_file_checked("cargo dev fmt", update_mode, &path, &mut |_, src, dst| {
+                gen_sorted_lints_file(src, dst, lints, passes, &mut ranges);
+                UpdateStatus::from_changed(src != dst)
+            });
+        }
+
+        for (&path, lints) in &mut lints {
+            updater.update_file_checked("cargo dev fmt", update_mode, path, &mut |_, src, dst| {
+                gen_sorted_lints_file(src, dst, lints, &mut [], &mut ranges);
+                UpdateStatus::from_changed(src != dst)
+            });
+        }
+    });
+
+    run_rustfmt(update_mode);
 }
diff --git a/clippy_dev/src/generate.rs b/clippy_dev/src/generate.rs
new file mode 100644
index 000000000000..24e4218716ab
--- /dev/null
+++ b/clippy_dev/src/generate.rs
@@ -0,0 +1,316 @@
+use crate::parse::cursor::Cursor;
+use crate::parse::{Lint, LintData, LintPass, VecBuf};
+use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, update_text_region_fn};
+use core::range::Range;
+use itertools::Itertools;
+use std::collections::HashSet;
+use std::fmt::Write;
+use std::path::{self, Path};
+
+const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
+     // Use that command to update this file and do not edit by hand.\n\
+     // Manual edits will be overwritten.\n\n";
+
+const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.html";
+
+impl LintData<'_> {
+    #[expect(clippy::too_many_lines)]
+    pub fn gen_decls(&self, update_mode: UpdateMode) {
+        let mut updater = FileUpdater::default();
+
+        let mut lints: Vec<_> = self.lints.iter().map(|(&x, y)| (x, y)).collect();
+        lints.sort_by_key(|&(x, _)| x);
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "CHANGELOG.md",
+            &mut update_text_region_fn(
+                "<!-- begin autogenerated links to lint list -->\n",
+                "<!-- end autogenerated links to lint list -->",
+                |dst| {
+                    for &(lint, _) in &lints {
+                        writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
+                    }
+                },
+            ),
+        );
+
+        let mut active = Vec::with_capacity(lints.len());
+        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)),
+                Lint::Deprecated(lint) => deprecated.push((name, lint)),
+                Lint::Renamed(lint) => renamed.push((name, lint)),
+            }
+        }
+        active.sort_by_key(|&(_, lint)| lint.module);
+
+        // Round to avoid updating the readme every time a lint is added/deprecated.
+        let lint_count = active.len() / 50 * 50;
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "README.md",
+            &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
+                write!(dst, "{lint_count}").unwrap();
+            }),
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "book/src/README.md",
+            &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
+                write!(dst, "{lint_count}").unwrap();
+            }),
+        );
+
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "clippy_lints/src/deprecated_lints.rs",
+            &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(),
+                    "error reading deprecated lints"
+                );
+                dst.push_str(&src[..cursor.pos() as usize]);
+                dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
+                for &(name, data) in &deprecated {
+                    write!(
+                        dst,
+                        "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
+                        data.version, data.reason,
+                    )
+                    .unwrap();
+                }
+                dst.push_str(
+                    "]}\n\n\
+                        #[rustfmt::skip]\n\
+                        declare_with_version! { RENAMED(RENAMED_VERSION) = [\n\
+                    ",
+                );
+                for &(name, data) in &renamed {
+                    write!(
+                        dst,
+                        "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
+                        data.version, data.new_name,
+                    )
+                    .unwrap();
+                }
+                dst.push_str("]}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "tests/ui/deprecated.rs",
+            &mut |_, src, dst| {
+                dst.push_str(GENERATED_FILE_COMMENT);
+                for &(lint, _) in &deprecated {
+                    writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
+                }
+                dst.push_str("\nfn main() {}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "tests/ui/rename.rs",
+            &mut move |_, src, dst| {
+                let mut seen_lints = HashSet::new();
+                dst.push_str(GENERATED_FILE_COMMENT);
+                dst.push_str("#![allow(clippy::duplicated_attributes)]\n");
+                for &(_, lint) in &renamed {
+                    if seen_lints.insert(lint.new_name) {
+                        writeln!(dst, "#![allow({})]", lint.new_name).unwrap();
+                    }
+                }
+                for &(lint, _) in &renamed {
+                    writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
+                }
+                dst.push_str("\nfn main() {}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+        for (crate_name, lints) in active.iter().copied().into_group_map_by(|&(_, lint)| {
+            let Some(path::Component::Normal(name)) = lint.path.components().next() else {
+                // All paths should start with `{crate_name}/src` when parsed from `find_lint_decls`
+                panic!(
+                    "internal error: can't read crate name from path `{}`",
+                    lint.path.display()
+                );
+            };
+            name
+        }) {
+            updater.update_file_checked(
+                "cargo dev update_lints",
+                update_mode,
+                Path::new(crate_name).join("src/lib.rs"),
+                &mut update_text_region_fn(
+                    "// begin lints modules, do not remove this comment, it's used in `update_lints`\n",
+                    "// end lints modules, do not remove this comment, it's used in `update_lints`",
+                    |dst| {
+                        let mut prev = "";
+                        for &(_, lint) in &lints {
+                            if lint.module != prev {
+                                writeln!(dst, "mod {};", lint.module).unwrap();
+                                prev = lint.module;
+                            }
+                        }
+                    },
+                ),
+            );
+            updater.update_file_checked(
+                "cargo dev update_lints",
+                update_mode,
+                Path::new(crate_name).join("src/declared_lints.rs"),
+                &mut |_, src, dst| {
+                    dst.push_str(GENERATED_FILE_COMMENT);
+                    dst.push_str("pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[\n");
+                    let mut buf = String::new();
+                    for &(name, lint) in &lints {
+                        buf.clear();
+                        buf.push_str(name);
+                        buf.make_ascii_uppercase();
+                        if lint.module.is_empty() {
+                            writeln!(dst, "    crate::{buf}_INFO,").unwrap();
+                        } else {
+                            writeln!(dst, "    crate::{}::{buf}_INFO,", lint.module).unwrap();
+                        }
+                    }
+                    dst.push_str("];\n");
+                    UpdateStatus::from_changed(src != dst)
+                },
+            );
+        }
+    }
+}
+
+impl LintPass<'_> {
+    pub fn gen_mac(&self, dst: &mut String) {
+        let mut line_start = dst.len();
+        dst.extend([self.mac.name(), "!("]);
+        let has_docs = write_comment_lines(self.docs, "\n    ", dst);
+        let (list_indent, list_multi_end, end) = if has_docs {
+            dst.push_str("\n    ");
+            line_start = dst.len() - 4;
+            ("        ", "\n    ", "]\n);")
+        } else {
+            ("    ", "\n", "]);")
+        };
+        dst.push_str(self.name);
+        if let Some(lt) = self.lt {
+            dst.extend(["<", lt, ">"]);
+        }
+        dst.push_str(" => [");
+        let fmt = write_list(
+            self.lints.iter().copied(),
+            80usize.saturating_sub(dst.len() - line_start),
+            list_indent,
+            dst,
+        );
+        if matches!(fmt, ListFmt::MultiLine) {
+            dst.push_str(list_multi_end);
+        }
+        dst.push_str(end);
+    }
+}
+
+fn write_comment_lines(s: &str, prefix: &str, dst: &mut String) -> bool {
+    let mut has_doc = false;
+    for line in s.split('\n') {
+        let line = line.trim_start();
+        if !line.is_empty() {
+            has_doc = true;
+            dst.extend([prefix, line]);
+        }
+    }
+    has_doc
+}
+
+#[derive(Clone, Copy)]
+enum ListFmt {
+    SingleLine,
+    MultiLine,
+}
+
+fn write_list<'a>(
+    items: impl Iterator<Item = &'a str> + Clone,
+    single_line_limit: usize,
+    indent: &str,
+    dst: &mut String,
+) -> ListFmt {
+    let len = items.clone().map(str::len).sum::<usize>();
+    if len > single_line_limit {
+        for item in items {
+            dst.extend(["\n", indent, item, ","]);
+        }
+        ListFmt::MultiLine
+    } else {
+        let _ = write!(dst, "{}", items.format(", "));
+        ListFmt::SingleLine
+    }
+}
+
+/// Generates the contents of a lint's source file with all the lint and lint pass
+/// declarations sorted.
+pub fn gen_sorted_lints_file(
+    src: &str,
+    dst: &mut String,
+    lints: &mut [(&str, Range<u32>)],
+    passes: &mut [LintPass<'_>],
+    ranges: &mut VecBuf<Range<u32>>,
+) {
+    ranges.with(|ranges| {
+        ranges.extend(lints.iter().map(|&(_, x)| x));
+        ranges.extend(passes.iter().map(|x| x.decl_range));
+        ranges.sort_unstable_by_key(|x| x.start);
+
+        lints.sort_unstable_by_key(|&(x, _)| x);
+        passes.sort_by_key(|x| x.name);
+
+        let mut ranges = ranges.iter();
+        let pos = if let Some(range) = ranges.next() {
+            dst.push_str(&src[..range.start as usize]);
+            for &(_, range) in &*lints {
+                dst.push_str(&src[range.start as usize..range.end as usize]);
+                dst.push_str("\n\n");
+            }
+            for pass in passes {
+                pass.gen_mac(dst);
+                dst.push_str("\n\n");
+            }
+            range.end
+        } else {
+            dst.push_str(src);
+            return;
+        };
+
+        let pos = ranges.fold(pos, |start, range| {
+            let s = &src[start as usize..range.start as usize];
+            dst.push_str(if s.trim_start().is_empty() {
+                // Only whitespace between this and the previous item. No need to keep that.
+                ""
+            } else if src[..pos as usize].ends_with("\n\n")
+                && let Some(s) = s.strip_prefix("\n\n")
+            {
+                // Empty line before and after. Remove one of them.
+                s
+            } else {
+                // Remove only full lines unless something is in the way.
+                s.strip_prefix('\n').unwrap_or(s)
+            });
+            range.end
+        });
+
+        // Since we always generate an empty line at the end, make sure to always skip it.
+        let s = &src[pos as usize..];
+        dst.push_str(s.strip_prefix('\n').map_or(s, |s| s.strip_prefix('\n').unwrap_or(s)));
+    });
+}
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index cff51d34c30e..359bf17c68c5 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(
     exit_status_error,
-    if_let_guard,
     new_range,
     new_range_api,
     os_str_slice,
@@ -33,8 +32,8 @@
 pub mod serve;
 pub mod setup;
 pub mod sync;
-pub mod update_lints;
 
+mod generate;
 mod parse;
 mod utils;
 
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 8dc2290df8e4..5fe2295a1e21 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -5,7 +5,6 @@
 use clap::{Args, Parser, Subcommand};
 use clippy_dev::{
     ClippyInfo, UpdateMode, dogfood, edit_lints, fmt, lint, new_lint, new_parse_cx, release, serve, setup, sync,
-    update_lints,
 };
 use std::env;
 
@@ -27,7 +26,9 @@ 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| update_lints::update(cx, UpdateMode::from_check(check))),
+        DevCommand::UpdateLints { check } => {
+            new_parse_cx(|cx| cx.parse_lint_decls().gen_decls(UpdateMode::from_check(check)));
+        },
         DevCommand::NewLint {
             pass,
             name,
@@ -35,7 +36,7 @@ fn main() {
             r#type,
             msrv,
         } => match new_lint::create(clippy.version, pass, &name, &category, r#type.as_deref(), msrv) {
-            Ok(()) => new_parse_cx(|cx| update_lints::update(cx, UpdateMode::Change)),
+            Ok(()) => new_parse_cx(|cx| cx.parse_lint_decls().gen_decls(UpdateMode::Change)),
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
index ffb50784a9a7..d51fb25552f9 100644
--- a/clippy_dev/src/parse.rs
+++ b/clippy_dev/src/parse.rs
@@ -1,7 +1,7 @@
 pub mod cursor;
 
 use self::cursor::{Capture, Cursor};
-use crate::utils::{ErrAction, File, Scoped, expect_action, walk_dir_no_dot_or_target};
+use crate::utils::{ErrAction, File, Scoped, expect_action, slice_groups_mut, walk_dir_no_dot_or_target};
 use core::fmt::{self, Display, Write as _};
 use core::range::Range;
 use rustc_arena::DroplessArena;
@@ -13,6 +13,7 @@
 pub struct ParseCxImpl<'cx> {
     pub arena: &'cx DroplessArena,
     pub str_buf: StrBuf,
+    pub str_list_buf: VecBuf<&'cx str>,
 }
 pub type ParseCx<'cx> = &'cx mut ParseCxImpl<'cx>;
 
@@ -22,6 +23,7 @@ pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx, 'env,
     f(&mut Scoped::new(ParseCxImpl {
         arena: &arena,
         str_buf: StrBuf::with_capacity(128),
+        str_list_buf: VecBuf::with_capacity(128),
     }))
 }
 
@@ -82,6 +84,20 @@ pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
     }
 }
 
+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,
@@ -128,7 +144,7 @@ pub struct ActiveLint<'cx> {
     pub group: &'cx str,
     pub module: &'cx str,
     pub path: PathBuf,
-    pub declaration_range: Range<usize>,
+    pub declaration_range: Range<u32>,
 }
 
 pub struct DeprecatedLint<'cx> {
@@ -147,8 +163,59 @@ pub enum Lint<'cx> {
     Renamed(RenamedLint<'cx>),
 }
 
+#[derive(Clone, Copy)]
+pub enum LintPassMac {
+    Declare,
+    Impl,
+}
+impl LintPassMac {
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Declare => "declare_lint_pass",
+            Self::Impl => "impl_lint_pass",
+        }
+    }
+}
+
+pub struct LintPass<'cx> {
+    /// The raw text of the documentation comments. May include leading/trailing
+    /// whitespace and empty lines.
+    pub docs: &'cx str,
+    pub name: &'cx str,
+    pub lt: Option<&'cx str>,
+    pub mac: LintPassMac,
+    pub decl_range: Range<u32>,
+    pub lints: &'cx [&'cx str],
+    pub path: PathBuf,
+}
+
 pub struct LintData<'cx> {
     pub lints: FxHashMap<&'cx str, Lint<'cx>>,
+    pub lint_passes: Vec<LintPass<'cx>>,
+}
+impl<'cx> LintData<'cx> {
+    #[expect(clippy::type_complexity)]
+    pub fn split_by_lint_file<'s>(
+        &'s mut self,
+    ) -> (
+        FxHashMap<&'s Path, Vec<(&'s str, Range<u32>)>>,
+        impl Iterator<Item = &'s mut [LintPass<'cx>]>,
+    ) {
+        #[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 {
+                lints
+                    .entry(&*lint.path)
+                    .or_insert_with(|| Vec::with_capacity(8))
+                    .push((name, lint.declaration_range));
+            }
+        }
+        let passes = slice_groups_mut(&mut self.lint_passes, |head, tail| {
+            tail.iter().take_while(|&x| x.path == head.path).count()
+        });
+        (lints, passes)
+    }
 }
 
 impl<'cx> ParseCxImpl<'cx> {
@@ -158,6 +225,7 @@ pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
         let mut data = LintData {
             #[expect(clippy::default_trait_access)]
             lints: FxHashMap::with_capacity_and_hasher(1000, Default::default()),
+            lint_passes: Vec::with_capacity(400),
         };
 
         let mut contents = String::new();
@@ -193,7 +261,7 @@ pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
                         self.str_buf
                             .alloc_replaced(self.arena, path, path::MAIN_SEPARATOR, "::")
                     };
-                    self.parse_clippy_lint_decls(
+                    self.parse_lint_src_file(
                         e.path(),
                         File::open_read_to_cleared_string(e.path(), &mut contents),
                         module,
@@ -208,11 +276,11 @@ pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
     }
 
     /// Parse a source file looking for `declare_clippy_lint` macro invocations.
-    fn parse_clippy_lint_decls(&mut self, path: &Path, contents: &str, module: &'cx str, data: &mut LintData<'cx>) {
+    fn parse_lint_src_file(&mut self, path: &Path, contents: &str, module: &'cx str, data: &mut LintData<'cx>) {
         #[allow(clippy::enum_glob_use)]
         use cursor::Pat::*;
         #[rustfmt::skip]
-        static DECL_TOKENS: &[cursor::Pat<'_>] = &[
+        static LINT_DECL_TOKENS: &[cursor::Pat<'_>] = &[
             // !{ /// docs
             Bang, OpenBrace, AnyComment,
             // #[clippy::version = "version"]
@@ -220,24 +288,101 @@ fn parse_clippy_lint_decls(&mut self, path: &Path, contents: &str, module: &'cx
             // pub NAME, GROUP,
             Ident("pub"), CaptureIdent, Comma, AnyComment, CaptureIdent, Comma,
         ];
+        #[rustfmt::skip]
+        static PASS_DECL_TOKENS: &[cursor::Pat<'_>] = &[
+            // !( NAME <'lt> => [
+            Bang, OpenParen, CaptureDocLines, CaptureIdent, CaptureOptLifetimeArg, FatArrow, OpenBracket,
+        ];
 
         let mut cursor = Cursor::new(contents);
-        let mut captures = [Capture::EMPTY; 2];
-        while let Some(start) = cursor.find_ident("declare_clippy_lint") {
-            if cursor.match_all(DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) {
-                assert!(
-                    data.lints
-                        .insert(
-                            self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[0])),
-                            Lint::Active(ActiveLint {
-                                group: self.arena.alloc_str(cursor.get_text(captures[1])),
-                                module,
-                                path: path.into(),
-                                declaration_range: start as usize..cursor.pos() as usize,
-                            }),
-                        )
-                        .is_none()
-                );
+        let mut captures = [Capture::EMPTY; 3];
+        while let Some(mac_name) = cursor.find_any_ident() {
+            match cursor.get_text(mac_name) {
+                "declare_clippy_lint"
+                    if cursor.match_all(LINT_DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) =>
+                {
+                    assert!(
+                        data.lints
+                            .insert(
+                                self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[0])),
+                                Lint::Active(ActiveLint {
+                                    group: self.arena.alloc_str(cursor.get_text(captures[1])),
+                                    module,
+                                    path: path.into(),
+                                    declaration_range: mac_name.pos..cursor.pos(),
+                                }),
+                            )
+                            .is_none()
+                    );
+                },
+                mac @ ("declare_lint_pass" | "impl_lint_pass") if cursor.match_all(PASS_DECL_TOKENS, &mut captures) => {
+                    let mac = if matches!(mac, "declare_lint_pass") {
+                        LintPassMac::Declare
+                    } else {
+                        LintPassMac::Impl
+                    };
+                    let docs = match cursor.get_text(captures[0]) {
+                        "" => "",
+                        x => self.arena.alloc_str(x),
+                    };
+                    let name = self.arena.alloc_str(cursor.get_text(captures[1]));
+                    let lt = cursor.get_text(captures[2]);
+                    let lt = if lt.is_empty() {
+                        None
+                    } else {
+                        Some(self.arena.alloc_str(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.match_pat(CloseBracket) {
+                            buf.push(self.str_buf.with(|buf| {
+                                if cursor.match_pat(DoubleColon) {
+                                    buf.push_str("::");
+                                }
+                                let capture = cursor.capture_ident()?;
+                                buf.push_str(cursor.get_text(capture));
+                                while cursor.match_pat(DoubleColon) {
+                                    buf.push_str("::");
+                                    let capture = cursor.capture_ident()?;
+                                    buf.push_str(cursor.get_text(capture));
+                                }
+                                Some(self.arena.alloc_str(buf))
+                            })?);
+
+                            if !cursor.match_pat(Comma) {
+                                if !cursor.match_pat(CloseBracket) {
+                                    return None;
+                                }
+                                break;
+                            }
+                        }
+
+                        // The arena panics when allocating a size of zero.
+                        Some(if buf.is_empty() {
+                            &[]
+                        } else {
+                            buf.sort_unstable();
+                            &*self.arena.alloc_slice(buf)
+                        })
+                    });
+
+                    if let Some(lints) = lints
+                        && cursor.match_all(&[CloseParen, Semi], &mut [])
+                    {
+                        data.lint_passes.push(LintPass {
+                            docs,
+                            name,
+                            lt,
+                            mac,
+                            decl_range: mac_name.pos..cursor.pos(),
+                            lints,
+                            path: path.into(),
+                        });
+                    }
+                },
+                _ => {},
             }
         }
     }
diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
index 2c142af4883a..af840532c27b 100644
--- a/clippy_dev/src/parse/cursor.rs
+++ b/clippy_dev/src/parse/cursor.rs
@@ -12,6 +12,7 @@ pub enum Pat<'a> {
     /// Matches any number of comments and doc comments.
     AnyComment,
     Ident(&'a str),
+    CaptureDocLines,
     CaptureIdent,
     LitStr,
     CaptureLitStr,
@@ -22,12 +23,14 @@ pub enum Pat<'a> {
     Comma,
     DoubleColon,
     Eq,
+    FatArrow,
     Lifetime,
     Lt,
     Gt,
     OpenBrace,
     OpenBracket,
     OpenParen,
+    CaptureOptLifetimeArg,
     Pound,
     Semi,
 }
@@ -112,6 +115,7 @@ pub fn step(&mut self) {
     ///
     /// 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) {
@@ -121,7 +125,6 @@ fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_, Capture
                     Pat::AnyComment,
                     TokenKind::BlockComment { terminated: true, .. } | TokenKind::LineComment { .. },
                 ) => self.step(),
-                (Pat::AnyComment, _) => return true,
                 (Pat::Bang, TokenKind::Bang)
                 | (Pat::CloseBrace, TokenKind::CloseBrace)
                 | (Pat::CloseBracket, TokenKind::CloseBracket)
@@ -152,12 +155,48 @@ fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_, Capture
                 },
                 (Pat::DoubleColon, TokenKind::Colon) => {
                     self.step();
-                    if !self.at_end() && matches!(self.next_token.kind, TokenKind::Colon) {
+                    if matches!(self.next_token.kind, TokenKind::Colon) {
                         self.step();
                         return true;
                     }
                     return false;
                 },
+                (Pat::FatArrow, TokenKind::Eq) => {
+                    self.step();
+                    if matches!(self.next_token.kind, TokenKind::Gt) {
+                        self.step();
+                        return true;
+                    }
+                    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,
@@ -173,6 +212,28 @@ fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_, Capture
                     self.step();
                     return true;
                 },
+                (Pat::CaptureDocLines, TokenKind::LineComment { doc_style: Some(_) }) => {
+                    let pos = self.pos;
+                    loop {
+                        self.step();
+                        if !matches!(
+                            self.next_token.kind,
+                            TokenKind::Whitespace | TokenKind::LineComment { doc_style: Some(_) }
+                        ) {
+                            break;
+                        }
+                    }
+                    *captures.next().unwrap() = Capture {
+                        pos,
+                        len: self.pos - pos,
+                    };
+                    return true;
+                },
+                (Pat::CaptureDocLines, _) => {
+                    *captures.next().unwrap() = Capture::EMPTY;
+                    return true;
+                },
+                (Pat::AnyComment, _) => return true,
                 _ => return false,
             }
         }
@@ -219,8 +280,8 @@ pub fn find_any_ident(&mut self) -> Option<Capture> {
         }
     }
 
-    /// Consume the returns the position of the next non-whitespace token if it's an
-    /// identifier. Returns `None` otherwise.
+    /// 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 {
@@ -235,6 +296,23 @@ pub fn match_ident(&mut self, s: &str) -> Option<u32> {
         }
     }
 
+    /// Consumes and captures the next non-whitespace token if it's an identifier. Returns
+    /// `None` otherwise.
+    pub fn capture_ident(&mut self) -> Option<Capture> {
+        loop {
+            match self.next_token.kind {
+                TokenKind::Ident => {
+                    let pos = self.pos;
+                    let len = self.next_token.len;
+                    self.step();
+                    return Some(Capture { pos, len });
+                },
+                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.
     ///
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
deleted file mode 100644
index a4cf15058986..000000000000
--- a/clippy_dev/src/update_lints.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use crate::parse::cursor::Cursor;
-use crate::parse::{Lint, LintData, ParseCx};
-use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, update_text_region_fn};
-use itertools::Itertools;
-use std::collections::HashSet;
-use std::fmt::Write;
-use std::path::{self, Path};
-
-const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
-     // Use that command to update this file and do not edit by hand.\n\
-     // Manual edits will be overwritten.\n\n";
-
-const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.html";
-
-/// Runs the `update_lints` command.
-///
-/// This updates various generated values from the lint source code.
-///
-/// `update_mode` indicates if the files should be updated or if updates should be checked for.
-///
-/// # Panics
-///
-/// Panics if a file path could not read from or then written to
-pub fn update(cx: ParseCx<'_>, update_mode: UpdateMode) {
-    let data = cx.parse_lint_decls();
-    generate_lint_files(update_mode, &data);
-}
-
-#[expect(clippy::too_many_lines)]
-pub fn generate_lint_files(update_mode: UpdateMode, data: &LintData<'_>) {
-    let mut updater = FileUpdater::default();
-
-    let mut lints: Vec<_> = data.lints.iter().map(|(&x, y)| (x, y)).collect();
-    lints.sort_by_key(|&(x, _)| x);
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "CHANGELOG.md",
-        &mut update_text_region_fn(
-            "<!-- begin autogenerated links to lint list -->\n",
-            "<!-- end autogenerated links to lint list -->",
-            |dst| {
-                for &(lint, _) in &lints {
-                    writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
-                }
-            },
-        ),
-    );
-
-    let mut active = Vec::with_capacity(lints.len());
-    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)),
-            Lint::Deprecated(lint) => deprecated.push((name, lint)),
-            Lint::Renamed(lint) => renamed.push((name, lint)),
-        }
-    }
-    active.sort_by_key(|&(_, lint)| lint.module);
-
-    // Round to avoid updating the readme every time a lint is added/deprecated.
-    let lint_count = active.len() / 50 * 50;
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "README.md",
-        &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-            write!(dst, "{lint_count}").unwrap();
-        }),
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "book/src/README.md",
-        &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-            write!(dst, "{lint_count}").unwrap();
-        }),
-    );
-
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "clippy_lints/src/deprecated_lints.rs",
-        &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(),
-                "error reading deprecated lints"
-            );
-            dst.push_str(&src[..cursor.pos() as usize]);
-            dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
-            for &(name, data) in &deprecated {
-                write!(
-                    dst,
-                    "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
-                    data.version, data.reason,
-                )
-                .unwrap();
-            }
-            dst.push_str(
-                "]}\n\n\
-                    #[rustfmt::skip]\n\
-                    declare_with_version! { RENAMED(RENAMED_VERSION) = [\n\
-                ",
-            );
-            for &(name, data) in &renamed {
-                write!(
-                    dst,
-                    "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
-                    data.version, data.new_name,
-                )
-                .unwrap();
-            }
-            dst.push_str("]}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "tests/ui/deprecated.rs",
-        &mut |_, src, dst| {
-            dst.push_str(GENERATED_FILE_COMMENT);
-            for &(lint, _) in &deprecated {
-                writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
-            }
-            dst.push_str("\nfn main() {}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "tests/ui/rename.rs",
-        &mut move |_, src, dst| {
-            let mut seen_lints = HashSet::new();
-            dst.push_str(GENERATED_FILE_COMMENT);
-            dst.push_str("#![allow(clippy::duplicated_attributes)]\n");
-            for &(_, lint) in &renamed {
-                if seen_lints.insert(lint.new_name) {
-                    writeln!(dst, "#![allow({})]", lint.new_name).unwrap();
-                }
-            }
-            for &(lint, _) in &renamed {
-                writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
-            }
-            dst.push_str("\nfn main() {}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    for (crate_name, lints) in active.iter().copied().into_group_map_by(|&(_, lint)| {
-        let Some(path::Component::Normal(name)) = lint.path.components().next() else {
-            // All paths should start with `{crate_name}/src` when parsed from `find_lint_decls`
-            panic!(
-                "internal error: can't read crate name from path `{}`",
-                lint.path.display()
-            );
-        };
-        name
-    }) {
-        updater.update_file_checked(
-            "cargo dev update_lints",
-            update_mode,
-            Path::new(crate_name).join("src/lib.rs"),
-            &mut update_text_region_fn(
-                "// begin lints modules, do not remove this comment, it's used in `update_lints`\n",
-                "// end lints modules, do not remove this comment, it's used in `update_lints`",
-                |dst| {
-                    let mut prev = "";
-                    for &(_, lint) in &lints {
-                        if lint.module != prev {
-                            writeln!(dst, "mod {};", lint.module).unwrap();
-                            prev = lint.module;
-                        }
-                    }
-                },
-            ),
-        );
-        updater.update_file_checked(
-            "cargo dev update_lints",
-            update_mode,
-            Path::new(crate_name).join("src/declared_lints.rs"),
-            &mut |_, src, dst| {
-                dst.push_str(GENERATED_FILE_COMMENT);
-                dst.push_str("pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[\n");
-                let mut buf = String::new();
-                for &(name, lint) in &lints {
-                    buf.clear();
-                    buf.push_str(name);
-                    buf.make_ascii_uppercase();
-                    if lint.module.is_empty() {
-                        writeln!(dst, "    crate::{buf}_INFO,").unwrap();
-                    } else {
-                        writeln!(dst, "    crate::{}::{buf}_INFO,", lint.module).unwrap();
-                    }
-                }
-                dst.push_str("];\n");
-                UpdateStatus::from_changed(src != dst)
-            },
-        );
-    }
-}
diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
index 52452dd86b49..1f931140467e 100644
--- a/clippy_dev/src/utils.rs
+++ b/clippy_dev/src/utils.rs
@@ -1,5 +1,6 @@
 use core::fmt::{self, Display};
 use core::marker::PhantomData;
+use core::mem;
 use core::num::NonZero;
 use core::ops::{Deref, DerefMut};
 use core::range::Range;
@@ -600,3 +601,29 @@ pub fn walk_dir_no_dot_or_target(p: impl AsRef<Path>) -> impl Iterator<Item = ::
             .is_none_or(|x| x != "target" && x.as_encoded_bytes().first().copied() != Some(b'.'))
     })
 }
+
+pub fn slice_groups_mut<T>(
+    slice: &mut [T],
+    split_idx: impl FnMut(&T, &[T]) -> usize,
+) -> impl Iterator<Item = &mut [T]> {
+    struct I<'a, T, F> {
+        slice: &'a mut [T],
+        split_idx: F,
+    }
+    impl<'a, T, F: FnMut(&T, &[T]) -> usize> Iterator for I<'a, T, F> {
+        type Item = &'a mut [T];
+        fn next(&mut self) -> Option<Self::Item> {
+            let (head, tail) = self.slice.split_first()?;
+            let idx = (self.split_idx)(head, tail) + 1;
+            // `mem::take` makes it so `self.slice` isn't reborrowed.
+            if let Some((head, tail)) = mem::take(&mut self.slice).split_at_mut_checked(idx) {
+                self.slice = tail;
+                Some(head)
+            } else {
+                self.slice = &mut [];
+                None
+            }
+        }
+    }
+    I { slice, split_idx }
+}
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index c0804dbb0492..51e753efb52e 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_lints"
-version = "0.1.95"
+version = "0.1.96"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
index 1af6d448a93c..fd515939dfb8 100644
--- a/clippy_lints/src/absolute_paths.rs
+++ b/clippy_lints/src/absolute_paths.rs
@@ -52,6 +52,7 @@
     restriction,
     "checks for usage of an item without a `use` statement"
 }
+
 impl_lint_pass!(AbsolutePaths => [ABSOLUTE_PATHS]);
 
 pub struct AbsolutePaths {
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 4f55968d5625..258970393023 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -28,6 +28,7 @@
     suspicious,
     "almost complete range"
 }
+
 impl_lint_pass!(AlmostCompleteRange => [ALMOST_COMPLETE_RANGE]);
 
 pub struct AlmostCompleteRange {
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index a3710ca51655..2ea921e5d461 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -39,6 +39,8 @@
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 
+impl_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
+
 // Tuples are of the form (constant, name, min_digits, msrv)
 const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 19] = [
     (f64::E, "E", 4, None),
@@ -111,8 +113,6 @@ fn check_known_consts(&self, cx: &LateContext<'_>, span: Span, s: symbol::Symbol
     }
 }
 
-impl_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
-
 fn count_digits_after_dot(input: &str) -> usize {
     input
         .char_indices()
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index acfdfa65baed..e449b06199d3 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -39,6 +39,7 @@
     suspicious,
     "using `Arc` with a type that does not implement `Send` and `Sync`"
 }
+
 declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
 
 impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync {
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index 69a8eb7d94e7..3c5cf74d5a17 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -57,54 +57,6 @@ fn check_asm_syntax(
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of Intel x86 assembly syntax.
-    ///
-    /// ### Why restrict this?
-    /// To enforce consistent use of AT&T x86 assembly syntax.
-    ///
-    /// ### Example
-    ///
-    /// ```rust,no_run
-    /// # #![feature(asm)]
-    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    /// # unsafe { let ptr = "".as_ptr();
-    /// # use std::arch::asm;
-    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
-    /// # }
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    /// # #![feature(asm)]
-    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    /// # unsafe { let ptr = "".as_ptr();
-    /// # use std::arch::asm;
-    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
-    /// # }
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub INLINE_ASM_X86_INTEL_SYNTAX,
-    restriction,
-    "prefer AT&T x86 assembly syntax"
-}
-
-declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
-
-impl EarlyLintPass for InlineAsmX86IntelSyntax {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
-            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
-        }
-    }
-
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
-            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
-        }
-    }
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of AT&T x86 assembly syntax.
@@ -137,8 +89,56 @@ fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
     "prefer Intel x86 assembly syntax"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of Intel x86 assembly syntax.
+    ///
+    /// ### Why restrict this?
+    /// To enforce consistent use of AT&T x86 assembly syntax.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// # use std::arch::asm;
+    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// # use std::arch::asm;
+    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
+    /// # }
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub INLINE_ASM_X86_INTEL_SYNTAX,
+    restriction,
+    "prefer AT&T x86 assembly syntax"
+}
+
 declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 
+declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
+
+impl EarlyLintPass for InlineAsmX86IntelSyntax {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
+        }
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
+        }
+    }
+}
+
 impl EarlyLintPass for InlineAsmX86AttSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 4aa55e53445c..6e57d0608bed 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -33,6 +33,7 @@
 }
 
 impl_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
+
 pub struct AssertionsOnConstants {
     msrv: Msrv,
 }
diff --git a/clippy_lints/src/assigning_clones.rs b/clippy_lints/src/assigning_clones.rs
index efce23d13a38..60bc9b2b5b85 100644
--- a/clippy_lints/src/assigning_clones.rs
+++ b/clippy_lints/src/assigning_clones.rs
@@ -53,6 +53,8 @@
     "assigning the result of cloning may be inefficient"
 }
 
+impl_lint_pass!(AssigningClones => [ASSIGNING_CLONES]);
+
 pub struct AssigningClones {
     msrv: Msrv,
 }
@@ -63,8 +65,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(AssigningClones => [ASSIGNING_CLONES]);
-
 impl<'tcx> LateLintPass<'tcx> for AssigningClones {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Assign(lhs, rhs, _) = e.kind
diff --git a/clippy_lints/src/attrs/mod.rs b/clippy_lints/src/attrs/mod.rs
index fa2951d91934..c15a378053e3 100644
--- a/clippy_lints/src/attrs/mod.rs
+++ b/clippy_lints/src/attrs/mod.rs
@@ -25,106 +25,60 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for items annotated with `#[inline(always)]`,
-    /// unless the annotated function is empty or simply panics.
+    /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
+    /// the `#[expect]` attribute (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    ///
+    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
+    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
     ///
     /// ### Why is this bad?
-    /// While there are valid uses of this annotation (and once
-    /// you know when to use it, by all means `allow` this lint), it's a common
-    /// newbie-mistake to pepper one's code with it.
-    ///
-    /// As a rule of thumb, before slapping `#[inline(always)]` on a function,
-    /// measure if that additional function call really affects your runtime profile
-    /// sufficiently to make up for the increase in compile time.
-    ///
-    /// ### Known problems
-    /// False positives, big time. This lint is meant to be
-    /// deactivated by everyone doing serious performance work. This means having
-    /// done the measurement.
+    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
+    /// the expectation is unfulfilled. This can be useful to be notified when the
+    /// lint is no longer triggered.
     ///
     /// ### Example
-    /// ```ignore
-    /// #[inline(always)]
-    /// fn not_quite_hot_code(..) { ... }
+    /// ```rust,ignore
+    /// #[allow(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INLINE_ALWAYS,
-    pedantic,
-    "use of `#[inline(always)]`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `extern crate` and `use` items annotated with
-    /// lint attributes.
-    ///
-    /// This lint permits lint attributes for lints emitted on the items themself.
-    /// For `use` items these lints are:
-    /// * ambiguous_glob_reexports
-    /// * dead_code
-    /// * deprecated
-    /// * hidden_glob_reexports
-    /// * unreachable_pub
-    /// * unused
-    /// * unused_braces
-    /// * unused_import_braces
-    /// * clippy::disallowed_types
-    /// * clippy::enum_glob_use
-    /// * clippy::macro_use_imports
-    /// * clippy::module_name_repetitions
-    /// * clippy::redundant_pub_crate
-    /// * clippy::single_component_path_imports
-    /// * clippy::unsafe_removed_from_name
-    /// * clippy::wildcard_imports
-    ///
-    /// For `extern crate` items these lints are:
-    /// * `unused_imports` on items with `#[macro_use]`
-    ///
-    /// ### Why is this bad?
-    /// Lint attributes have no effect on crate imports. Most
-    /// likely a `!` was forgotten.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #[deny(dead_code)]
-    /// extern crate foo;
-    /// #[forbid(dead_code)]
-    /// use foo::bar;
-    /// ```
-    ///
     /// Use instead:
     /// ```rust,ignore
-    /// #[allow(unused_imports)]
-    /// use foo::baz;
-    /// #[allow(unused_imports)]
-    /// #[macro_use]
-    /// extern crate baz;
+    /// #[expect(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub USELESS_ATTRIBUTE,
-    correctness,
-    "use of lint attributes on `extern crate` items"
+    #[clippy::version = "1.70.0"]
+    pub ALLOW_ATTRIBUTES,
+    restriction,
+    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `#[deprecated]` annotations with a `since`
-    /// field that is not a valid semantic version. Also allows "TBD" to signal
-    /// future deprecation.
+    /// Checks for attributes that allow lints without a reason.
     ///
-    /// ### Why is this bad?
-    /// For checking the version of the deprecation, it must be
-    /// a valid semver. Failing that, the contained information is useless.
+    /// ### Why restrict this?
+    /// Justifying each `allow` helps readers understand the reasoning,
+    /// and may allow removing `allow` attributes if their purpose is obsolete.
     ///
     /// ### Example
     /// ```no_run
-    /// #[deprecated(since = "forever")]
-    /// fn something_else() { /* ... */ }
+    /// #![allow(clippy::some_lint)]
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DEPRECATED_SEMVER,
-    correctness,
-    "use of `#[deprecated(since = \"x\")]` where x is not semver"
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    restriction,
+    "ensures that all `allow` and `expect` attributes have a reason"
 }
 
 declare_clippy_lint! {
@@ -181,161 +135,6 @@
     "usage of `cfg_attr(rustfmt)` instead of tool attributes"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for attributes that allow lints without a reason.
-    ///
-    /// ### Why restrict this?
-    /// Justifying each `allow` helps readers understand the reasoning,
-    /// and may allow removing `allow` attributes if their purpose is obsolete.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #![allow(clippy::some_lint)]
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    restriction,
-    "ensures that all `allow` and `expect` attributes have a reason"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
-    /// the `#[expect]` attribute (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
-    ///
-    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
-    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
-    ///
-    /// ### Why is this bad?
-    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
-    /// the expectation is unfulfilled. This can be useful to be notified when the
-    /// lint is no longer triggered.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[allow(unused_mut)]
-    /// fn foo() -> usize {
-    ///     let mut a = Vec::new();
-    ///     a.len()
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// #[expect(unused_mut)]
-    /// fn foo() -> usize {
-    ///     let mut a = Vec::new();
-    ///     a.len()
-    /// }
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub ALLOW_ATTRIBUTES,
-    restriction,
-    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `#[should_panic]` attributes without specifying the expected panic message.
-    ///
-    /// ### Why is this bad?
-    /// The expected panic message should be specified to ensure that the test is actually
-    /// panicking with the expected message, and not another unrelated panic.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn random() -> i32 { 0 }
-    ///
-    /// #[should_panic]
-    /// #[test]
-    /// fn my_test() {
-    ///     let _ = 1 / random();
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn random() -> i32 { 0 }
-    ///
-    /// #[should_panic = "attempt to divide by zero"]
-    /// #[test]
-    /// fn my_test() {
-    ///     let _ = 1 / random();
-    /// }
-    /// ```
-    #[clippy::version = "1.74.0"]
-    pub SHOULD_PANIC_WITHOUT_EXPECT,
-    pedantic,
-    "ensures that all `should_panic` attributes specify its expected panic message"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for items with `#[repr(packed)]`-attribute without ABI qualification
-    ///
-    /// ### Why is this bad?
-    /// Without qualification, `repr(packed)` implies `repr(Rust)`. The Rust-ABI is inherently unstable.
-    /// While this is fine as long as the type is accessed correctly within Rust-code, most uses
-    /// of `#[repr(packed)]` involve FFI and/or data structures specified by network-protocols or
-    /// other external specifications. In such situations, the unstable Rust-ABI implied in
-    /// `#[repr(packed)]` may lead to future bugs should the Rust-ABI change.
-    ///
-    /// In case you are relying on a well defined and stable memory layout, qualify the type's
-    /// representation using the `C`-ABI. Otherwise, if the type in question is only ever
-    /// accessed from Rust-code according to Rust's rules, use the `Rust`-ABI explicitly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[repr(packed)]
-    /// struct NetworkPacketHeader {
-    ///     header_length: u8,
-    ///     header_version: u16
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// #[repr(C, packed)]
-    /// struct NetworkPacketHeader {
-    ///     header_length: u8,
-    ///     header_version: u16
-    /// }
-    /// ```
-    #[clippy::version = "1.85.0"]
-    pub REPR_PACKED_WITHOUT_ABI,
-    suspicious,
-    "ensures that `repr(packed)` always comes with a qualified ABI"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `any` and `all` combinators in `cfg` with only one condition.
-    ///
-    /// ### Why is this bad?
-    /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[cfg(any(unix))]
-    /// pub struct Bar;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// #[cfg(unix)]
-    /// pub struct Bar;
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub NON_MINIMAL_CFG,
-    style,
-    "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `#[cfg_attr(feature = "cargo-clippy", ...)]` and for
@@ -364,63 +163,23 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `#[cfg_attr(clippy, allow(clippy::lint))]`
-    /// and suggests to replace it with `#[allow(clippy::lint)]`.
+    /// Checks for `#[deprecated]` annotations with a `since`
+    /// field that is not a valid semantic version. Also allows "TBD" to signal
+    /// future deprecation.
     ///
     /// ### Why is this bad?
-    /// There is no reason to put clippy attributes behind a clippy `cfg` as they are not
-    /// run by anything else than clippy.
+    /// For checking the version of the deprecation, it must be
+    /// a valid semver. Failing that, the contained information is useless.
     ///
     /// ### Example
     /// ```no_run
-    /// #![cfg_attr(clippy, allow(clippy::deprecated_cfg_attr))]
+    /// #[deprecated(since = "forever")]
+    /// fn something_else() { /* ... */ }
     /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// #![allow(clippy::deprecated_cfg_attr)]
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub UNNECESSARY_CLIPPY_CFG,
-    suspicious,
-    "usage of `cfg_attr(clippy, allow(clippy::lint))` instead of `allow(clippy::lint)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for items that have the same kind of attributes with mixed styles (inner/outer).
-    ///
-    /// ### Why is this bad?
-    /// Having both style of said attributes makes it more complicated to read code.
-    ///
-    /// ### Known problems
-    /// This lint currently has false-negatives when mixing same attributes
-    /// but they have different path symbols, for example:
-    /// ```ignore
-    /// #[custom_attribute]
-    /// pub fn foo() {
-    ///     #![my_crate::custom_attribute]
-    /// }
-    /// ```
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[cfg(linux)]
-    /// pub fn foo() {
-    ///     #![cfg(windows)]
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[cfg(linux)]
-    /// #[cfg(windows)]
-    /// pub fn foo() {
-    /// }
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub MIXED_ATTRIBUTES_STYLE,
-    style,
-    "item has both inner and outer attributes"
+    #[clippy::version = "pre 1.29.0"]
+    pub DEPRECATED_SEMVER,
+    correctness,
+    "use of `#[deprecated(since = \"x\")]` where x is not semver"
 }
 
 declare_clippy_lint! {
@@ -478,15 +237,272 @@
     "ignored tests without messages"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for items annotated with `#[inline(always)]`,
+    /// unless the annotated function is empty or simply panics.
+    ///
+    /// ### Why is this bad?
+    /// While there are valid uses of this annotation (and once
+    /// you know when to use it, by all means `allow` this lint), it's a common
+    /// newbie-mistake to pepper one's code with it.
+    ///
+    /// As a rule of thumb, before slapping `#[inline(always)]` on a function,
+    /// measure if that additional function call really affects your runtime profile
+    /// sufficiently to make up for the increase in compile time.
+    ///
+    /// ### Known problems
+    /// False positives, big time. This lint is meant to be
+    /// deactivated by everyone doing serious performance work. This means having
+    /// done the measurement.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[inline(always)]
+    /// fn not_quite_hot_code(..) { ... }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INLINE_ALWAYS,
+    pedantic,
+    "use of `#[inline(always)]`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for items that have the same kind of attributes with mixed styles (inner/outer).
+    ///
+    /// ### Why is this bad?
+    /// Having both style of said attributes makes it more complicated to read code.
+    ///
+    /// ### Known problems
+    /// This lint currently has false-negatives when mixing same attributes
+    /// but they have different path symbols, for example:
+    /// ```ignore
+    /// #[custom_attribute]
+    /// pub fn foo() {
+    ///     #![my_crate::custom_attribute]
+    /// }
+    /// ```
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[cfg(linux)]
+    /// pub fn foo() {
+    ///     #![cfg(windows)]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[cfg(linux)]
+    /// #[cfg(windows)]
+    /// pub fn foo() {
+    /// }
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub MIXED_ATTRIBUTES_STYLE,
+    style,
+    "item has both inner and outer attributes"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `any` and `all` combinators in `cfg` with only one condition.
+    ///
+    /// ### Why is this bad?
+    /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[cfg(any(unix))]
+    /// pub struct Bar;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #[cfg(unix)]
+    /// pub struct Bar;
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub NON_MINIMAL_CFG,
+    style,
+    "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for items with `#[repr(packed)]`-attribute without ABI qualification
+    ///
+    /// ### Why is this bad?
+    /// Without qualification, `repr(packed)` implies `repr(Rust)`. The Rust-ABI is inherently unstable.
+    /// While this is fine as long as the type is accessed correctly within Rust-code, most uses
+    /// of `#[repr(packed)]` involve FFI and/or data structures specified by network-protocols or
+    /// other external specifications. In such situations, the unstable Rust-ABI implied in
+    /// `#[repr(packed)]` may lead to future bugs should the Rust-ABI change.
+    ///
+    /// In case you are relying on a well defined and stable memory layout, qualify the type's
+    /// representation using the `C`-ABI. Otherwise, if the type in question is only ever
+    /// accessed from Rust-code according to Rust's rules, use the `Rust`-ABI explicitly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[repr(packed)]
+    /// struct NetworkPacketHeader {
+    ///     header_length: u8,
+    ///     header_version: u16
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #[repr(C, packed)]
+    /// struct NetworkPacketHeader {
+    ///     header_length: u8,
+    ///     header_version: u16
+    /// }
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub REPR_PACKED_WITHOUT_ABI,
+    suspicious,
+    "ensures that `repr(packed)` always comes with a qualified ABI"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[should_panic]` attributes without specifying the expected panic message.
+    ///
+    /// ### Why is this bad?
+    /// The expected panic message should be specified to ensure that the test is actually
+    /// panicking with the expected message, and not another unrelated panic.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn random() -> i32 { 0 }
+    ///
+    /// #[should_panic]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn random() -> i32 { 0 }
+    ///
+    /// #[should_panic = "attempt to divide by zero"]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub SHOULD_PANIC_WITHOUT_EXPECT,
+    pedantic,
+    "ensures that all `should_panic` attributes specify its expected panic message"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[cfg_attr(clippy, allow(clippy::lint))]`
+    /// and suggests to replace it with `#[allow(clippy::lint)]`.
+    ///
+    /// ### Why is this bad?
+    /// There is no reason to put clippy attributes behind a clippy `cfg` as they are not
+    /// run by anything else than clippy.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #![cfg_attr(clippy, allow(clippy::deprecated_cfg_attr))]
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #![allow(clippy::deprecated_cfg_attr)]
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub UNNECESSARY_CLIPPY_CFG,
+    suspicious,
+    "usage of `cfg_attr(clippy, allow(clippy::lint))` instead of `allow(clippy::lint)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `extern crate` and `use` items annotated with
+    /// lint attributes.
+    ///
+    /// This lint permits lint attributes for lints emitted on the items themself.
+    /// For `use` items these lints are:
+    /// * ambiguous_glob_reexports
+    /// * dead_code
+    /// * deprecated
+    /// * hidden_glob_reexports
+    /// * unreachable_pub
+    /// * unused
+    /// * unused_braces
+    /// * unused_import_braces
+    /// * clippy::disallowed_types
+    /// * clippy::enum_glob_use
+    /// * clippy::macro_use_imports
+    /// * clippy::module_name_repetitions
+    /// * clippy::redundant_pub_crate
+    /// * clippy::single_component_path_imports
+    /// * clippy::unsafe_removed_from_name
+    /// * clippy::wildcard_imports
+    ///
+    /// For `extern crate` items these lints are:
+    /// * `unused_imports` on items with `#[macro_use]`
+    ///
+    /// ### Why is this bad?
+    /// Lint attributes have no effect on crate imports. Most
+    /// likely a `!` was forgotten.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[deny(dead_code)]
+    /// extern crate foo;
+    /// #[forbid(dead_code)]
+    /// use foo::bar;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[allow(unused_imports)]
+    /// use foo::baz;
+    /// #[allow(unused_imports)]
+    /// #[macro_use]
+    /// extern crate baz;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_ATTRIBUTE,
+    correctness,
+    "use of lint attributes on `extern crate` items"
+}
+
+impl_lint_pass!(Attributes => [INLINE_ALWAYS, REPR_PACKED_WITHOUT_ABI]);
+
+impl_lint_pass!(EarlyAttributes => [
+    DEPRECATED_CFG_ATTR,
+    DEPRECATED_CLIPPY_CFG_ATTR,
+    NON_MINIMAL_CFG,
+    UNNECESSARY_CLIPPY_CFG,
+]);
+
+impl_lint_pass!(PostExpansionEarlyAttributes => [
+    ALLOW_ATTRIBUTES,
+    ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    BLANKET_CLIPPY_RESTRICTION_LINTS,
+    DEPRECATED_SEMVER,
+    DUPLICATED_ATTRIBUTES,
+    IGNORE_WITHOUT_REASON,
+    MIXED_ATTRIBUTES_STYLE,
+    SHOULD_PANIC_WITHOUT_EXPECT,
+    USELESS_ATTRIBUTE,
+]);
+
 pub struct Attributes {
     msrv: Msrv,
 }
 
-impl_lint_pass!(Attributes => [
-    INLINE_ALWAYS,
-    REPR_PACKED_WITHOUT_ABI,
-]);
-
 impl Attributes {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
@@ -529,13 +545,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(EarlyAttributes => [
-    DEPRECATED_CFG_ATTR,
-    NON_MINIMAL_CFG,
-    DEPRECATED_CLIPPY_CFG_ATTR,
-    UNNECESSARY_CLIPPY_CFG,
-]);
-
 impl EarlyLintPass for EarlyAttributes {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         deprecated_cfg_attr::check(cx, attr, &self.msrv);
@@ -558,18 +567,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(PostExpansionEarlyAttributes => [
-    ALLOW_ATTRIBUTES,
-    ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    DEPRECATED_SEMVER,
-    IGNORE_WITHOUT_REASON,
-    USELESS_ATTRIBUTE,
-    BLANKET_CLIPPY_RESTRICTION_LINTS,
-    SHOULD_PANIC_WITHOUT_EXPECT,
-    MIXED_ATTRIBUTES_STYLE,
-    DUPLICATED_ATTRIBUTES,
-]);
-
 impl EarlyLintPass for PostExpansionEarlyAttributes {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &ast::Crate) {
         blanket_clippy_restriction_lints::check_command_line(cx);
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 4ee955c035da..9e5b57a05580 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -11,6 +11,43 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Allows users to configure types which should not be held across await
+    /// suspension points.
+    ///
+    /// ### Why is this bad?
+    /// There are some types which are perfectly safe to use concurrently from
+    /// a memory access perspective, but that will cause bugs at runtime if
+    /// they are held in such a way.
+    ///
+    /// ### Example
+    ///
+    /// ```toml
+    /// await-holding-invalid-types = [
+    ///   # You can specify a type name
+    ///   "CustomLockType",
+    ///   # You can (optionally) specify a reason
+    ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
+    /// ]
+    /// ```
+    ///
+    /// ```no_run
+    /// # async fn baz() {}
+    /// struct CustomLockType;
+    /// struct OtherCustomLockType;
+    /// async fn foo() {
+    ///   let _x = CustomLockType;
+    ///   let _y = OtherCustomLockType;
+    ///   baz().await; // Lint violation
+    /// }
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub AWAIT_HOLDING_INVALID_TYPE,
+    suspicious,
+    "holding a type across an await point which is not allowed to be held as per the configuration"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `await` while holding a non-async-aware
@@ -135,44 +172,11 @@
     "inside an async function, holding a `RefCell` ref while calling `await`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Allows users to configure types which should not be held across await
-    /// suspension points.
-    ///
-    /// ### Why is this bad?
-    /// There are some types which are perfectly safe to use concurrently from
-    /// a memory access perspective, but that will cause bugs at runtime if
-    /// they are held in such a way.
-    ///
-    /// ### Example
-    ///
-    /// ```toml
-    /// await-holding-invalid-types = [
-    ///   # You can specify a type name
-    ///   "CustomLockType",
-    ///   # You can (optionally) specify a reason
-    ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
-    /// ]
-    /// ```
-    ///
-    /// ```no_run
-    /// # async fn baz() {}
-    /// struct CustomLockType;
-    /// struct OtherCustomLockType;
-    /// async fn foo() {
-    ///   let _x = CustomLockType;
-    ///   let _y = OtherCustomLockType;
-    ///   baz().await; // Lint violation
-    /// }
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub AWAIT_HOLDING_INVALID_TYPE,
-    suspicious,
-    "holding a type across an await point which is not allowed to be held as per the configuration"
-}
-
-impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
+impl_lint_pass!(AwaitHolding => [
+    AWAIT_HOLDING_INVALID_TYPE,
+    AWAIT_HOLDING_LOCK,
+    AWAIT_HOLDING_REFCELL_REF,
+]);
 
 pub struct AwaitHolding {
     def_ids: DefIdMap<(&'static str, &'static DisallowedPathWithoutReplacement)>,
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 129e77478406..b98a20a90ccb 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -43,6 +43,7 @@
     pedantic,
     "using if to convert bool to int"
 }
+
 declare_lint_pass!(BoolToIntWithIf => [BOOL_TO_INT_WITH_IF]);
 
 impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 0bd459d8b021..8b7619d11a83 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -74,6 +74,8 @@
     "boolean expressions that contain terminals which can be eliminated"
 }
 
+impl_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, OVERLY_COMPLEX_BOOL_EXPR]);
+
 // For each pairs, both orders are considered.
 const METHODS_WITH_NEGATION: [(Option<RustcVersion>, Symbol, Symbol); 3] = [
     (None, sym::is_some, sym::is_none),
@@ -91,8 +93,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, OVERLY_COMPLEX_BOOL_EXPR]);
-
 impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index b78aa1f1b63d..34b96b1d9d7a 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_default_equivalent, sym};
 use clippy_utils::macros::macro_backtrace;
 use clippy_utils::res::{MaybeDef, MaybeResPath};
 use clippy_utils::ty::expr_sig;
+use clippy_utils::{is_default_equivalent, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{InferKind, Visitor, VisitorExt, walk_ty};
diff --git a/clippy_lints/src/byte_char_slices.rs b/clippy_lints/src/byte_char_slices.rs
index fc9931439e93..6c023189f69e 100644
--- a/clippy_lints/src/byte_char_slices.rs
+++ b/clippy_lints/src/byte_char_slices.rs
@@ -27,6 +27,7 @@
     style,
     "hard to read byte char slice"
 }
+
 declare_lint_pass!(ByteCharSlice => [BYTE_CHAR_SLICES]);
 
 impl EarlyLintPass for ByteCharSlice {
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index 08d92adbacef..0aa6e4c3e8e2 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -56,126 +56,6 @@
     "common metadata is defined in `Cargo.toml`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
-    ///
-    /// ### Why is this bad?
-    /// These prefixes and suffixes have no significant meaning.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # The `Cargo.toml` with feature name redundancy
-    /// [features]
-    /// default = ["use-abc", "with-def", "ghi-support"]
-    /// use-abc = []  // redundant
-    /// with-def = []   // redundant
-    /// ghi-support = []   // redundant
-    /// ```
-    ///
-    /// Use instead:
-    /// ```toml
-    /// [features]
-    /// default = ["abc", "def", "ghi"]
-    /// abc = []
-    /// def = []
-    /// ghi = []
-    /// ```
-    ///
-    #[clippy::version = "1.57.0"]
-    pub REDUNDANT_FEATURE_NAMES,
-    cargo,
-    "usage of a redundant feature name"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for negative feature names with prefix `no-` or `not-`
-    ///
-    /// ### Why is this bad?
-    /// Features are supposed to be additive, and negatively-named features violate it.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # The `Cargo.toml` with negative feature names
-    /// [features]
-    /// default = []
-    /// no-abc = []
-    /// not-def = []
-    ///
-    /// ```
-    /// Use instead:
-    /// ```toml
-    /// [features]
-    /// default = ["abc", "def"]
-    /// abc = []
-    /// def = []
-    ///
-    /// ```
-    #[clippy::version = "1.57.0"]
-    pub NEGATIVE_FEATURE_NAMES,
-    cargo,
-    "usage of a negative feature name"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks to see if multiple versions of a crate are being
-    /// used.
-    ///
-    /// ### Why is this bad?
-    /// This bloats the size of targets, and can lead to
-    /// confusing error messages when structs or traits are used interchangeably
-    /// between different versions of a crate.
-    ///
-    /// ### Known problems
-    /// Because this can be caused purely by the dependencies
-    /// themselves, it's not always possible to fix this issue.
-    /// In those cases, you can allow that specific crate using
-    /// the `allowed-duplicate-crates` configuration option.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
-    /// [dependencies]
-    /// ctrlc = "=3.1.0"
-    /// ansi_term = "=0.11.0"
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MULTIPLE_CRATE_VERSIONS,
-    cargo,
-    "multiple versions of the same crate being used"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard dependencies in the `Cargo.toml`.
-    ///
-    /// ### Why is this bad?
-    /// [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
-    /// it is highly unlikely that you work with any possible version of your dependency,
-    /// and wildcard dependencies would cause unnecessary breakage in the ecosystem.
-    ///
-    /// ### Example
-    /// ```toml
-    /// [dependencies]
-    /// regex = "*"
-    /// ```
-    /// Use instead:
-    /// ```toml
-    /// [dependencies]
-    /// # allow patch updates, but not minor or major version changes
-    /// some_crate_1 = "~1.2.3"
-    ///
-    /// # pin the version to a specific version
-    /// some_crate_2 = "=1.2.3"
-    /// ```
-    #[clippy::version = "1.32.0"]
-    pub WILDCARD_DEPENDENCIES,
-    cargo,
-    "wildcard dependencies being used"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for lint groups with the same priority as lints in the `Cargo.toml`
@@ -213,20 +93,140 @@
     "a lint group in `Cargo.toml` at the same priority as a lint"
 }
 
-pub struct Cargo {
-    allowed_duplicate_crates: FxHashSet<String>,
-    ignore_publish: bool,
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks to see if multiple versions of a crate are being
+    /// used.
+    ///
+    /// ### Why is this bad?
+    /// This bloats the size of targets, and can lead to
+    /// confusing error messages when structs or traits are used interchangeably
+    /// between different versions of a crate.
+    ///
+    /// ### Known problems
+    /// Because this can be caused purely by the dependencies
+    /// themselves, it's not always possible to fix this issue.
+    /// In those cases, you can allow that specific crate using
+    /// the `allowed-duplicate-crates` configuration option.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
+    /// [dependencies]
+    /// ctrlc = "=3.1.0"
+    /// ansi_term = "=0.11.0"
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MULTIPLE_CRATE_VERSIONS,
+    cargo,
+    "multiple versions of the same crate being used"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for negative feature names with prefix `no-` or `not-`
+    ///
+    /// ### Why is this bad?
+    /// Features are supposed to be additive, and negatively-named features violate it.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with negative feature names
+    /// [features]
+    /// default = []
+    /// no-abc = []
+    /// not-def = []
+    ///
+    /// ```
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def"]
+    /// abc = []
+    /// def = []
+    ///
+    /// ```
+    #[clippy::version = "1.57.0"]
+    pub NEGATIVE_FEATURE_NAMES,
+    cargo,
+    "usage of a negative feature name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
+    ///
+    /// ### Why is this bad?
+    /// These prefixes and suffixes have no significant meaning.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with feature name redundancy
+    /// [features]
+    /// default = ["use-abc", "with-def", "ghi-support"]
+    /// use-abc = []  // redundant
+    /// with-def = []   // redundant
+    /// ghi-support = []   // redundant
+    /// ```
+    ///
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def", "ghi"]
+    /// abc = []
+    /// def = []
+    /// ghi = []
+    /// ```
+    ///
+    #[clippy::version = "1.57.0"]
+    pub REDUNDANT_FEATURE_NAMES,
+    cargo,
+    "usage of a redundant feature name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard dependencies in the `Cargo.toml`.
+    ///
+    /// ### Why is this bad?
+    /// [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
+    /// it is highly unlikely that you work with any possible version of your dependency,
+    /// and wildcard dependencies would cause unnecessary breakage in the ecosystem.
+    ///
+    /// ### Example
+    /// ```toml
+    /// [dependencies]
+    /// regex = "*"
+    /// ```
+    /// Use instead:
+    /// ```toml
+    /// [dependencies]
+    /// # allow patch updates, but not minor or major version changes
+    /// some_crate_1 = "~1.2.3"
+    ///
+    /// # pin the version to a specific version
+    /// some_crate_2 = "=1.2.3"
+    /// ```
+    #[clippy::version = "1.32.0"]
+    pub WILDCARD_DEPENDENCIES,
+    cargo,
+    "wildcard dependencies being used"
 }
 
 impl_lint_pass!(Cargo => [
     CARGO_COMMON_METADATA,
-    REDUNDANT_FEATURE_NAMES,
-    NEGATIVE_FEATURE_NAMES,
-    MULTIPLE_CRATE_VERSIONS,
-    WILDCARD_DEPENDENCIES,
     LINT_GROUPS_PRIORITY,
+    MULTIPLE_CRATE_VERSIONS,
+    NEGATIVE_FEATURE_NAMES,
+    REDUNDANT_FEATURE_NAMES,
+    WILDCARD_DEPENDENCIES,
 ]);
 
+pub struct Cargo {
+    allowed_duplicate_crates: FxHashSet<String>,
+    ignore_publish: bool,
+}
+
 impl Cargo {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 3c9ebef73f0d..75761de4ae73 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -36,50 +36,231 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from any numeric type to a float type where
-    /// the receiving type cannot store all values from the original type without
-    /// rounding errors. This possible rounding is to be expected, so this lint is
-    /// `Allow` by default.
+    /// Checks for the usage of `as *const _` or `as *mut _` conversion using inferred type.
     ///
-    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
-    /// or any 64-bit integer to `f64`.
-    ///
-    /// ### Why is this bad?
-    /// It's not bad at all. But in some applications it can be
-    /// helpful to know where precision loss can take place. This lint can help find
-    /// those places in the code.
+    /// ### Why restrict this?
+    /// The conversion might include a dangerous cast that might go undetected due to the type being inferred.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = u64::MAX;
-    /// x as f64;
+    /// fn as_usize<T>(t: &T) -> usize {
+    ///     // BUG: `t` is already a reference, so we will here
+    ///     // return a dangling pointer to a temporary value instead
+    ///     &t as *const _ as usize
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CAST_PRECISION_LOSS,
-    pedantic,
-    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
+    /// Use instead:
+    /// ```no_run
+    /// fn as_usize<T>(t: &T) -> usize {
+    ///     t as *const T as usize
+    /// }
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub AS_POINTER_UNDERSCORE,
+    restriction,
+    "detects `as *mut _` and `as *const _` conversion"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from a signed to an unsigned numeric
-    /// type. In this case, negative values wrap around to large positive values,
-    /// which can be quite surprising in practice. However, since the cast works as
-    /// defined, this lint is `Allow` by default.
+    /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer.
     ///
     /// ### Why is this bad?
-    /// Possibly surprising results. You can activate this lint
-    /// as a one-time check to see where numeric wrapping can arise.
+    /// Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
+    /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
     ///
     /// ### Example
     /// ```no_run
-    /// let y: i8 = -1;
-    /// y as u64; // will return 18446744073709551615
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_ptr() as *mut u8;
+    /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_mut_ptr();
+    /// unsafe { ptr.write(4) };
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub AS_PTR_CAST_MUT,
+    nursery,
+    "casting the result of the `&self`-taking `as_ptr` to a mutable pointer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `as _` conversion using inferred type.
+    ///
+    /// ### Why restrict this?
+    /// The conversion might include lossy conversion or a dangerous cast that might go
+    /// undetected due to the type being inferred.
+    ///
+    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as _);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as usize);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub AS_UNDERSCORE,
+    restriction,
+    "detects `as _` conversion"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `&expr as *const T` or
+    /// `&mut expr as *mut T`, and suggest using `&raw const` or
+    /// `&raw mut` instead.
+    ///
+    /// ### Why is this bad?
+    /// This would improve readability and avoid creating a reference
+    /// that points to an uninitialized value or unaligned place.
+    /// Read the `&raw` explanation in the Reference for more information.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let val = 1;
+    /// let p = &val as *const i32;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &mut val_mut as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let val = 1;
+    /// let p = &raw const val;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &raw mut val_mut;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub BORROW_AS_PTR,
+    pedantic,
+    "borrowing just to cast to a raw pointer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `abs()` method that cast the result to unsigned.
+    ///
+    /// ### Why is this bad?
+    /// The `unsigned_abs()` method avoids panic when called on the MIN value.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: i32 = -42;
+    /// let y: u32 = x.abs() as u32;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x: i32 = -42;
+    /// let y: u32 = x.unsigned_abs();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub CAST_ABS_TO_UNSIGNED,
+    suspicious,
+    "casting the result of `abs()` to an unsigned integer can panic"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum tuple constructor to an integer.
+    ///
+    /// ### Why is this bad?
+    /// The cast is easily confused with casting a c-like enum value to an integer.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum E { X(i32) };
+    /// let _ = E::X as usize;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ENUM_CONSTRUCTOR,
+    suspicious,
+    "casts from an enum tuple constructor to an integer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum type to an integral type that will definitely truncate the
+    /// value.
+    ///
+    /// ### Why is this bad?
+    /// The resulting integral value will not match the value of the variant it came from.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum E { X = 256 };
+    /// let _ = E::X as u8;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ENUM_TRUNCATION,
+    suspicious,
+    "casts from an enum type to an integral type that will truncate the value"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts between numeric types that can be replaced by safe
+    /// conversion functions.
+    ///
+    /// ### Why is this bad?
+    /// Rust's `as` keyword will perform many kinds of conversions, including
+    /// silently lossy conversions. Conversion functions such as `i32::from`
+    /// will only perform lossless conversions. Using the conversion functions
+    /// prevents conversions from becoming silently lossy if the input types
+    /// ever change, and makes it clear for people reading the code that the
+    /// conversion is lossless.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn as_u64(x: u8) -> u64 {
+    ///     x as u64
+    /// }
+    /// ```
+    ///
+    /// Using `::from` would look like this:
+    ///
+    /// ```no_run
+    /// fn as_u64(x: u8) -> u64 {
+    ///     u64::from(x)
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CAST_SIGN_LOSS,
+    pub CAST_LOSSLESS,
     pedantic,
-    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
+    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a known NaN float being cast to an integer
+    ///
+    /// ### Why is this bad?
+    /// NaNs are cast into zero, so one could simply use this and make the
+    /// code more readable. The lint could also hint at a programmer error.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _ = (0.0_f32 / 0.0) as u64;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _ = 0_u64;
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub CAST_NAN_TO_INT,
+    suspicious,
+    "casting a known floating-point NaN into an integer"
 }
 
 declare_clippy_lint! {
@@ -159,71 +340,28 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts between numeric types that can be replaced by safe
-    /// conversion functions.
+    /// Checks for casts from any numeric type to a float type where
+    /// the receiving type cannot store all values from the original type without
+    /// rounding errors. This possible rounding is to be expected, so this lint is
+    /// `Allow` by default.
+    ///
+    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
+    /// or any 64-bit integer to `f64`.
     ///
     /// ### Why is this bad?
-    /// Rust's `as` keyword will perform many kinds of conversions, including
-    /// silently lossy conversions. Conversion functions such as `i32::from`
-    /// will only perform lossless conversions. Using the conversion functions
-    /// prevents conversions from becoming silently lossy if the input types
-    /// ever change, and makes it clear for people reading the code that the
-    /// conversion is lossless.
+    /// It's not bad at all. But in some applications it can be
+    /// helpful to know where precision loss can take place. This lint can help find
+    /// those places in the code.
     ///
     /// ### Example
     /// ```no_run
-    /// fn as_u64(x: u8) -> u64 {
-    ///     x as u64
-    /// }
-    /// ```
-    ///
-    /// Using `::from` would look like this:
-    ///
-    /// ```no_run
-    /// fn as_u64(x: u8) -> u64 {
-    ///     u64::from(x)
-    /// }
+    /// let x = u64::MAX;
+    /// x as f64;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CAST_LOSSLESS,
+    pub CAST_PRECISION_LOSS,
     pedantic,
-    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts to the same type, casts of int literals to integer
-    /// types, casts of float literals to float types, and casts between raw
-    /// pointers that don't change type or constness.
-    ///
-    /// ### Why is this bad?
-    /// It's just unnecessary.
-    ///
-    /// ### Known problems
-    /// When the expression on the left is a function call, the lint considers
-    /// the return type to be a type alias if it's aliased through a `use`
-    /// statement (like `use std::io::Result as IoResult`). It will not lint
-    /// such cases.
-    ///
-    /// This check will only work on primitive types without any intermediate
-    /// references: raw pointers and trait objects may or may not work.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = 2i32 as i32;
-    /// let _ = 0.5 as f32;
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```no_run
-    /// let _ = 2_i32;
-    /// let _ = 0.5_f32;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNNECESSARY_CAST,
-    complexity,
-    "cast to the same type, e.g., `x as i32` where `x: i32`"
+    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
 }
 
 declare_clippy_lint! {
@@ -254,6 +392,154 @@
     "cast from a pointer to a more strictly aligned pointer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from a signed to an unsigned numeric
+    /// type. In this case, negative values wrap around to large positive values,
+    /// which can be quite surprising in practice. However, since the cast works as
+    /// defined, this lint is `Allow` by default.
+    ///
+    /// ### Why is this bad?
+    /// Possibly surprising results. You can activate this lint
+    /// as a one-time check to see where numeric wrapping can arise.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let y: i8 = -1;
+    /// y as u64; // will return 18446744073709551615
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CAST_SIGN_LOSS,
+    pedantic,
+    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `as` casts between raw pointers to slices with differently sized elements.
+    ///
+    /// ### Why is this bad?
+    /// The produced raw pointer to a slice does not update its length metadata. The produced
+    /// pointer will point to a different number of bytes than the original pointer because the
+    /// length metadata of a raw slice pointer is in elements rather than bytes.
+    /// Producing a slice reference from the raw pointer will either create a slice with
+    /// less data (which can be surprising) or create a slice with more data and cause Undefined Behavior.
+    ///
+    /// ### Example
+    /// // Missing data
+    /// ```no_run
+    /// let a = [1_i32, 2, 3, 4];
+    /// let p = &a as *const [i32] as *const [u8];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
+    /// ```
+    /// // Undefined Behavior (note: also potential alignment issues)
+    /// ```no_run
+    /// let a = [1_u8, 2, 3, 4];
+    /// let p = &a as *const [u8] as *const [u32];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
+    /// ```
+    /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
+    /// ```no_run
+    /// let a = [1_i32, 2, 3, 4];
+    /// let old_ptr = &a as *const [i32];
+    /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
+    /// // The length comes from the known length of 4 i32s times the 4 bytes per i32
+    /// let new_ptr = core::ptr::slice_from_raw_parts(old_ptr as *const u8, 16);
+    /// unsafe {
+    ///     println!("{:?}", &*new_ptr);
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_SLICE_DIFFERENT_SIZES,
+    correctness,
+    "casting using `as` between raw pointers to slices of types with different sizes"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a raw slice being cast to a slice pointer
+    ///
+    /// ### Why is this bad?
+    /// This can result in multiple `&mut` references to the same location when only a pointer is
+    /// required.
+    /// `ptr::slice_from_raw_parts` is a safe alternative that doesn't require
+    /// the same [safety requirements] to be upheld.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::slice::from_raw_parts(ptr, len) as *const _;
+    /// let _: *mut [u8] = std::slice::from_raw_parts_mut(ptr, len) as *mut _;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, len);
+    /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
+    /// ```
+    /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
+    #[clippy::version = "1.65.0"]
+    pub CAST_SLICE_FROM_RAW_PARTS,
+    suspicious,
+    "casting a slice created from a pointer and length to a slice pointer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions where a character literal is cast
+    /// to `u8` and suggests using a byte literal instead.
+    ///
+    /// ### Why is this bad?
+    /// In general, casting values to smaller types is
+    /// error-prone and should be avoided where possible. In the particular case of
+    /// converting a character literal to `u8`, it is easy to avoid by just using a
+    /// byte literal instead. As an added bonus, `b'a'` is also slightly shorter
+    /// than `'a' as u8`.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// 'x' as u8
+    /// ```
+    ///
+    /// A better version, using the byte literal:
+    ///
+    /// ```rust,ignore
+    /// b'x'
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CHAR_LIT_AS_U8,
+    complexity,
+    "casting a character literal to `u8` truncates"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts of a primitive method pointer like `max`/`min` to any integer type.
+    ///
+    /// ### Why restrict this?
+    /// Casting a function pointer to an integer can have surprising results and can occur
+    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
+    /// low-level with function pointers then you can opt out of casting functions to integers in
+    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
+    /// pointer casts in your code.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = u16::max as usize;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let _ = u16::MAX as usize;
+    /// ```
+    #[clippy::version = "1.89.0"]
+    pub CONFUSING_METHOD_TO_NUMERIC_CAST,
+    suspicious,
+    "casting a primitive method pointer to any integer type"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts of function pointers to something other than `usize`.
@@ -284,39 +570,6 @@
     "casting a function pointer to a numeric type other than `usize`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of a function pointer to a numeric type not wide enough to
-    /// store an address.
-    ///
-    /// ### Why is this bad?
-    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
-    /// clearly expressed by casting to `usize` first, then casting the `usize` to the intended type (with
-    /// a comment) to perform the truncation.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let _ = fn1 as i32;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// // Cast to usize first, then comment with the reason for the truncation
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let fn_ptr = fn1 as usize;
-    /// let fn_ptr_truncated = fn_ptr as i32;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    style,
-    "casting a function pointer to a numeric type not wide enough to store the address"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts of a function pointer to any integer type.
@@ -361,30 +614,87 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for expressions where a character literal is cast
-    /// to `u8` and suggests using a byte literal instead.
+    /// Checks for casts of a function pointer to a numeric type not wide enough to
+    /// store an address.
     ///
     /// ### Why is this bad?
-    /// In general, casting values to smaller types is
-    /// error-prone and should be avoided where possible. In the particular case of
-    /// converting a character literal to `u8`, it is easy to avoid by just using a
-    /// byte literal instead. As an added bonus, `b'a'` is also slightly shorter
-    /// than `'a' as u8`.
+    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
+    /// clearly expressed by casting to `usize` first, then casting the `usize` to the intended type (with
+    /// a comment) to perform the truncation.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// 'x' as u8
+    /// ```no_run
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as i32;
     /// ```
     ///
-    /// A better version, using the byte literal:
-    ///
-    /// ```rust,ignore
-    /// b'x'
+    /// Use instead:
+    /// ```no_run
+    /// // Cast to usize first, then comment with the reason for the truncation
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let fn_ptr = fn1 as usize;
+    /// let fn_ptr_truncated = fn_ptr as i32;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CHAR_LIT_AS_U8,
-    complexity,
-    "casting a character literal to `u8` truncates"
+    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    style,
+    "casting a function pointer to a numeric type not wide enough to store the address"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts of small constant literals or `mem::align_of` results to raw pointers.
+    ///
+    /// ### Why is this bad?
+    /// This creates a dangling pointer and is better expressed as
+    /// {`std`, `core`}`::ptr::`{`dangling`, `dangling_mut`}.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let ptr = 4 as *const u32;
+    /// let aligned = std::mem::align_of::<u32>() as *const u32;
+    /// let mut_ptr: *mut i64 = 8 as *mut _;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let ptr = std::ptr::dangling::<u32>();
+    /// let aligned = std::ptr::dangling::<u32>();
+    /// let mut_ptr: *mut i64 = std::ptr::dangling_mut();
+    /// ```
+    #[clippy::version = "1.88.0"]
+    pub MANUAL_DANGLING_PTR,
+    style,
+    "casting small constant literals to pointers to create dangling pointers"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bindings (constants, statics, or let bindings) that are defined
+    /// with one numeric type but are consistently cast to a different type in all usages.
+    ///
+    /// ### Why is this bad?
+    /// If a binding is always cast to a different type when used, it would be clearer
+    /// and more efficient to define it with the target type from the start.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// const SIZE: u16 = 15;
+    /// let arr: [u8; SIZE as usize] = [0; SIZE as usize];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// const SIZE: usize = 15;
+    /// let arr: [u8; SIZE] = [0; SIZE];
+    /// ```
+    #[clippy::version = "1.93.0"]
+    pub NEEDLESS_TYPE_CAST,
+    nursery,
+    "binding defined with one type but always cast to another"
 }
 
 declare_clippy_lint! {
@@ -455,243 +765,62 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from an enum type to an integral type that will definitely truncate the
-    /// value.
+    /// Checks for casts of references to pointer using `as`
+    /// and suggests `std::ptr::from_ref` and `std::ptr::from_mut` instead.
     ///
     /// ### Why is this bad?
-    /// The resulting integral value will not match the value of the variant it came from.
+    /// Using `as` casts may result in silently changing mutability or type.
     ///
     /// ### Example
     /// ```no_run
-    /// enum E { X = 256 };
-    /// let _ = E::X as u8;
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_ENUM_TRUNCATION,
-    suspicious,
-    "casts from an enum type to an integral type that will truncate the value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `as` casts between raw pointers to slices with differently sized elements.
-    ///
-    /// ### Why is this bad?
-    /// The produced raw pointer to a slice does not update its length metadata. The produced
-    /// pointer will point to a different number of bytes than the original pointer because the
-    /// length metadata of a raw slice pointer is in elements rather than bytes.
-    /// Producing a slice reference from the raw pointer will either create a slice with
-    /// less data (which can be surprising) or create a slice with more data and cause Undefined Behavior.
-    ///
-    /// ### Example
-    /// // Missing data
-    /// ```no_run
-    /// let a = [1_i32, 2, 3, 4];
-    /// let p = &a as *const [i32] as *const [u8];
-    /// unsafe {
-    ///     println!("{:?}", &*p);
-    /// }
-    /// ```
-    /// // Undefined Behavior (note: also potential alignment issues)
-    /// ```no_run
-    /// let a = [1_u8, 2, 3, 4];
-    /// let p = &a as *const [u8] as *const [u32];
-    /// unsafe {
-    ///     println!("{:?}", &*p);
-    /// }
-    /// ```
-    /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
-    /// ```no_run
-    /// let a = [1_i32, 2, 3, 4];
-    /// let old_ptr = &a as *const [i32];
-    /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
-    /// // The length comes from the known length of 4 i32s times the 4 bytes per i32
-    /// let new_ptr = core::ptr::slice_from_raw_parts(old_ptr as *const u8, 16);
-    /// unsafe {
-    ///     println!("{:?}", &*new_ptr);
-    /// }
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_SLICE_DIFFERENT_SIZES,
-    correctness,
-    "casting using `as` between raw pointers to slices of types with different sizes"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts from an enum tuple constructor to an integer.
-    ///
-    /// ### Why is this bad?
-    /// The cast is easily confused with casting a c-like enum value to an integer.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// enum E { X(i32) };
-    /// let _ = E::X as usize;
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_ENUM_CONSTRUCTOR,
-    suspicious,
-    "casts from an enum tuple constructor to an integer"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `abs()` method that cast the result to unsigned.
-    ///
-    /// ### Why is this bad?
-    /// The `unsigned_abs()` method avoids panic when called on the MIN value.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: i32 = -42;
-    /// let y: u32 = x.abs() as u32;
+    /// let a_ref = &1;
+    /// let a_ptr = a_ref as *const _;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let x: i32 = -42;
-    /// let y: u32 = x.unsigned_abs();
+    /// let a_ref = &1;
+    /// let a_ptr = std::ptr::from_ref(a_ref);
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub CAST_ABS_TO_UNSIGNED,
-    suspicious,
-    "casting the result of `abs()` to an unsigned integer can panic"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of `as _` conversion using inferred type.
-    ///
-    /// ### Why restrict this?
-    /// The conversion might include lossy conversion or a dangerous cast that might go
-    /// undetected due to the type being inferred.
-    ///
-    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as _);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as usize);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub AS_UNDERSCORE,
-    restriction,
-    "detects `as _` conversion"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of `&expr as *const T` or
-    /// `&mut expr as *mut T`, and suggest using `&raw const` or
-    /// `&raw mut` instead.
-    ///
-    /// ### Why is this bad?
-    /// This would improve readability and avoid creating a reference
-    /// that points to an uninitialized value or unaligned place.
-    /// Read the `&raw` explanation in the Reference for more information.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let val = 1;
-    /// let p = &val as *const i32;
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = &mut val_mut as *mut i32;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let val = 1;
-    /// let p = &raw const val;
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = &raw mut val_mut;
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub BORROW_AS_PTR,
+    #[clippy::version = "1.78.0"]
+    pub REF_AS_PTR,
     pedantic,
-    "borrowing just to cast to a raw pointer"
+    "using `as` to cast a reference to pointer"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a raw slice being cast to a slice pointer
+    /// Checks for casts to the same type, casts of int literals to integer
+    /// types, casts of float literals to float types, and casts between raw
+    /// pointers that don't change type or constness.
     ///
     /// ### Why is this bad?
-    /// This can result in multiple `&mut` references to the same location when only a pointer is
-    /// required.
-    /// `ptr::slice_from_raw_parts` is a safe alternative that doesn't require
-    /// the same [safety requirements] to be upheld.
+    /// It's just unnecessary.
     ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let _: *const [u8] = std::slice::from_raw_parts(ptr, len) as *const _;
-    /// let _: *mut [u8] = std::slice::from_raw_parts_mut(ptr, len) as *mut _;
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, len);
-    /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
-    /// ```
-    /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
-    #[clippy::version = "1.65.0"]
-    pub CAST_SLICE_FROM_RAW_PARTS,
-    suspicious,
-    "casting a slice created from a pointer and length to a slice pointer"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer.
+    /// ### Known problems
+    /// When the expression on the left is a function call, the lint considers
+    /// the return type to be a type alias if it's aliased through a `use`
+    /// statement (like `use std::io::Result as IoResult`). It will not lint
+    /// such cases.
     ///
-    /// ### Why is this bad?
-    /// Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
-    /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
+    /// This check will only work on primitive types without any intermediate
+    /// references: raw pointers and trait objects may or may not work.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut vec = Vec::<u8>::with_capacity(1);
-    /// let ptr = vec.as_ptr() as *mut u8;
-    /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
+    /// let _ = 2i32 as i32;
+    /// let _ = 0.5 as f32;
     /// ```
-    /// Use instead:
+    ///
+    /// Better:
+    ///
     /// ```no_run
-    /// let mut vec = Vec::<u8>::with_capacity(1);
-    /// let ptr = vec.as_mut_ptr();
-    /// unsafe { ptr.write(4) };
+    /// let _ = 2_i32;
+    /// let _ = 0.5_f32;
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub AS_PTR_CAST_MUT,
-    nursery,
-    "casting the result of the `&self`-taking `as_ptr` to a mutable pointer"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for a known NaN float being cast to an integer
-    ///
-    /// ### Why is this bad?
-    /// NaNs are cast into zero, so one could simply use this and make the
-    /// code more readable. The lint could also hint at a programmer error.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let _ = (0.0_f32 / 0.0) as u64;
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// let _ = 0_u64;
-    /// ```
-    #[clippy::version = "1.66.0"]
-    pub CAST_NAN_TO_INT,
-    suspicious,
-    "casting a known floating-point NaN into an integer"
+    #[clippy::version = "pre 1.29.0"]
+    pub UNNECESSARY_CAST,
+    complexity,
+    "cast to the same type, e.g., `x as i32` where `x: i32`"
 }
 
 declare_clippy_lint! {
@@ -717,134 +846,36 @@
     "using `0 as *{const, mut} T`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of references to pointer using `as`
-    /// and suggests `std::ptr::from_ref` and `std::ptr::from_mut` instead.
-    ///
-    /// ### Why is this bad?
-    /// Using `as` casts may result in silently changing mutability or type.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let a_ref = &1;
-    /// let a_ptr = a_ref as *const _;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let a_ref = &1;
-    /// let a_ptr = std::ptr::from_ref(a_ref);
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub REF_AS_PTR,
-    pedantic,
-    "using `as` to cast a reference to pointer"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of `as *const _` or `as *mut _` conversion using inferred type.
-    ///
-    /// ### Why restrict this?
-    /// The conversion might include a dangerous cast that might go undetected due to the type being inferred.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn as_usize<T>(t: &T) -> usize {
-    ///     // BUG: `t` is already a reference, so we will here
-    ///     // return a dangling pointer to a temporary value instead
-    ///     &t as *const _ as usize
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn as_usize<T>(t: &T) -> usize {
-    ///     t as *const T as usize
-    /// }
-    /// ```
-    #[clippy::version = "1.85.0"]
-    pub AS_POINTER_UNDERSCORE,
-    restriction,
-    "detects `as *mut _` and `as *const _` conversion"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of small constant literals or `mem::align_of` results to raw pointers.
-    ///
-    /// ### Why is this bad?
-    /// This creates a dangling pointer and is better expressed as
-    /// {`std`, `core`}`::ptr::`{`dangling`, `dangling_mut`}.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let ptr = 4 as *const u32;
-    /// let aligned = std::mem::align_of::<u32>() as *const u32;
-    /// let mut_ptr: *mut i64 = 8 as *mut _;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let ptr = std::ptr::dangling::<u32>();
-    /// let aligned = std::ptr::dangling::<u32>();
-    /// let mut_ptr: *mut i64 = std::ptr::dangling_mut();
-    /// ```
-    #[clippy::version = "1.88.0"]
-    pub MANUAL_DANGLING_PTR,
-    style,
-    "casting small constant literals to pointers to create dangling pointers"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of a primitive method pointer like `max`/`min` to any integer type.
-    ///
-    /// ### Why restrict this?
-    /// Casting a function pointer to an integer can have surprising results and can occur
-    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
-    /// low-level with function pointers then you can opt out of casting functions to integers in
-    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
-    /// pointer casts in your code.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = u16::max as usize;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let _ = u16::MAX as usize;
-    /// ```
-    #[clippy::version = "1.89.0"]
-    pub CONFUSING_METHOD_TO_NUMERIC_CAST,
-    suspicious,
-    "casting a primitive method pointer to any integer type"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for bindings (constants, statics, or let bindings) that are defined
-    /// with one numeric type but are consistently cast to a different type in all usages.
-    ///
-    /// ### Why is this bad?
-    /// If a binding is always cast to a different type when used, it would be clearer
-    /// and more efficient to define it with the target type from the start.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// const SIZE: u16 = 15;
-    /// let arr: [u8; SIZE as usize] = [0; SIZE as usize];
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// const SIZE: usize = 15;
-    /// let arr: [u8; SIZE] = [0; SIZE];
-    /// ```
-    #[clippy::version = "1.93.0"]
-    pub NEEDLESS_TYPE_CAST,
-    nursery,
-    "binding defined with one type but always cast to another"
-}
+impl_lint_pass!(Casts => [
+    AS_POINTER_UNDERSCORE,
+    AS_PTR_CAST_MUT,
+    AS_UNDERSCORE,
+    BORROW_AS_PTR,
+    CAST_ABS_TO_UNSIGNED,
+    CAST_ENUM_CONSTRUCTOR,
+    CAST_ENUM_TRUNCATION,
+    CAST_LOSSLESS,
+    CAST_NAN_TO_INT,
+    CAST_POSSIBLE_TRUNCATION,
+    CAST_POSSIBLE_WRAP,
+    CAST_PRECISION_LOSS,
+    CAST_PTR_ALIGNMENT,
+    CAST_SIGN_LOSS,
+    CAST_SLICE_DIFFERENT_SIZES,
+    CAST_SLICE_FROM_RAW_PARTS,
+    CHAR_LIT_AS_U8,
+    CONFUSING_METHOD_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST_ANY,
+    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    MANUAL_DANGLING_PTR,
+    NEEDLESS_TYPE_CAST,
+    PTR_AS_PTR,
+    PTR_CAST_CONSTNESS,
+    REF_AS_PTR,
+    UNNECESSARY_CAST,
+    ZERO_PTR,
+]);
 
 pub struct Casts {
     msrv: Msrv,
@@ -856,37 +887,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Casts => [
-    CAST_PRECISION_LOSS,
-    CAST_SIGN_LOSS,
-    CAST_POSSIBLE_TRUNCATION,
-    CAST_POSSIBLE_WRAP,
-    CAST_LOSSLESS,
-    CAST_PTR_ALIGNMENT,
-    CAST_SLICE_DIFFERENT_SIZES,
-    UNNECESSARY_CAST,
-    FN_TO_NUMERIC_CAST_ANY,
-    FN_TO_NUMERIC_CAST,
-    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    CHAR_LIT_AS_U8,
-    PTR_AS_PTR,
-    PTR_CAST_CONSTNESS,
-    CAST_ENUM_TRUNCATION,
-    CAST_ENUM_CONSTRUCTOR,
-    CAST_ABS_TO_UNSIGNED,
-    AS_UNDERSCORE,
-    BORROW_AS_PTR,
-    CAST_SLICE_FROM_RAW_PARTS,
-    AS_PTR_CAST_MUT,
-    CAST_NAN_TO_INT,
-    ZERO_PTR,
-    REF_AS_PTR,
-    AS_POINTER_UNDERSCORE,
-    MANUAL_DANGLING_PTR,
-    CONFUSING_METHOD_TO_NUMERIC_CAST,
-    NEEDLESS_TYPE_CAST,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 8303897d1294..5e9009c67197 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -34,6 +34,8 @@
     "`try_from` could replace manual bounds checking when casting"
 }
 
+impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
+
 pub struct CheckedConversions {
     msrv: Msrv,
 }
@@ -44,8 +46,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
-
 impl LateLintPass<'_> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
         if let ExprKind::Binary(op, lhs, rhs) = item.kind
diff --git a/clippy_lints/src/cloned_ref_to_slice_refs.rs b/clippy_lints/src/cloned_ref_to_slice_refs.rs
index 35b799aefb04..c5eabe4c2b88 100644
--- a/clippy_lints/src/cloned_ref_to_slice_refs.rs
+++ b/clippy_lints/src/cloned_ref_to_slice_refs.rs
@@ -44,6 +44,8 @@
     "cloning a reference for slice references"
 }
 
+impl_lint_pass!(ClonedRefToSliceRefs<'_> => [CLONED_REF_TO_SLICE_REFS]);
+
 pub struct ClonedRefToSliceRefs<'a> {
     msrv: &'a Msrv,
 }
@@ -53,8 +55,6 @@ pub fn new(conf: &'a Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ClonedRefToSliceRefs<'_> => [CLONED_REF_TO_SLICE_REFS]);
-
 impl<'tcx> LateLintPass<'tcx> for ClonedRefToSliceRefs<'_> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if self.msrv.meets(cx, {
diff --git a/clippy_lints/src/coerce_container_to_any.rs b/clippy_lints/src/coerce_container_to_any.rs
index 2e3acb7748e2..1a7e20b98271 100644
--- a/clippy_lints/src/coerce_container_to_any.rs
+++ b/clippy_lints/src/coerce_container_to_any.rs
@@ -46,6 +46,7 @@
     nursery,
     "coercing to `&dyn Any` when dereferencing could produce a `dyn Any` without coercion is usually not intended"
 }
+
 declare_lint_pass!(CoerceContainerToAny => [COERCE_CONTAINER_TO_ANY]);
 
 impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index c256ad9b06a4..911ca306aca4 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -40,6 +40,8 @@
     @eval_always = true
 }
 
+impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
+
 pub struct CognitiveComplexity {
     limit: LimitStack,
 }
@@ -52,8 +54,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
-
 impl CognitiveComplexity {
     fn check<'tcx>(
         &self,
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 17e11b8b281d..a76027caebc8 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -12,38 +12,6 @@
 use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Span, Symbol};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for nested `if` statements which can be collapsed
-    /// by `&&`-combining their conditions.
-    ///
-    /// ### Why is this bad?
-    /// Each `if`-statement adds one level of nesting, which
-    /// makes code look more complex than it really is.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let (x, y) = (true, true);
-    /// if x {
-    ///     if y {
-    ///         // …
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let (x, y) = (true, true);
-    /// if x && y {
-    ///     // …
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub COLLAPSIBLE_IF,
-    style,
-    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for collapsible `else { if ... }` expressions
@@ -80,6 +48,40 @@
     "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for nested `if` statements which can be collapsed
+    /// by `&&`-combining their conditions.
+    ///
+    /// ### Why is this bad?
+    /// Each `if`-statement adds one level of nesting, which
+    /// makes code look more complex than it really is.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let (x, y) = (true, true);
+    /// if x {
+    ///     if y {
+    ///         // …
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let (x, y) = (true, true);
+    /// if x && y {
+    ///     // …
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub COLLAPSIBLE_IF,
+    style,
+    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
+}
+
+impl_lint_pass!(CollapsibleIf => [COLLAPSIBLE_ELSE_IF, COLLAPSIBLE_IF]);
+
 pub struct CollapsibleIf {
     msrv: Msrv,
     lint_commented_code: bool,
@@ -259,8 +261,6 @@ fn check_significant_tokens_and_expect_attrs(
     }
 }
 
-impl_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
-
 impl LateLintPass<'_> for CollapsibleIf {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::If(cond, then, else_) = &expr.kind
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index 5bf582f4da65..ddd3e8b805d1 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{get_enclosing_block, sym};
 use clippy_utils::res::{MaybeDef, MaybeResPath};
 use clippy_utils::visitors::{Visitable, for_each_expr};
+use clippy_utils::{get_enclosing_block, sym};
 use core::ops::ControlFlow;
 use rustc_hir::{Body, ExprKind, HirId, LangItem, LetStmt, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -40,6 +40,7 @@
     nursery,
     "a collection is never queried"
 }
+
 declare_lint_pass!(CollectionIsNeverRead => [COLLECTION_IS_NEVER_READ]);
 
 impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 19f62e8bf79c..509b345048c1 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -49,6 +49,7 @@
     suspicious,
     "using `crate` in a macro definition"
 }
+
 declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
 
 impl EarlyLintPass for CrateInMacroDef {
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index f47d0d4835a9..eb14ef18c03d 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,8 +1,8 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_in_test, sym};
 use clippy_utils::macros::{MacroCall, macro_backtrace};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_in_test, sym};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
@@ -33,6 +33,8 @@
     "`dbg!` macro is intended as a debugging tool"
 }
 
+impl_lint_pass!(DbgMacro => [DBG_MACRO]);
+
 pub struct DbgMacro {
     allow_dbg_in_tests: bool,
     /// Tracks the `dbg!` macro callsites that are already checked.
@@ -41,8 +43,6 @@ pub struct DbgMacro {
     prev_ctxt: SyntaxContext,
 }
 
-impl_lint_pass!(DbgMacro => [DBG_MACRO]);
-
 impl DbgMacro {
     pub fn new(conf: &'static Conf) -> Self {
         DbgMacro {
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index a48e4d2fbd57..2064d896861b 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -69,14 +69,14 @@
     "binding initialized with Default should have its fields set in the initializer"
 }
 
+impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
+
 #[derive(Default)]
 pub struct Default {
     // Spans linted by `field_reassign_with_default`.
     reassigned_linted: FxHashSet<Span>,
 }
 
-impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
-
 impl<'tcx> LateLintPass<'tcx> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion()
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index 641f8ae03b72..c831f96443c6 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -45,7 +45,10 @@
     complexity,
     "unit structs can be constructed without calling `default`"
 }
-declare_lint_pass!(DefaultConstructedUnitStructs => [DEFAULT_CONSTRUCTED_UNIT_STRUCTS]);
+
+declare_lint_pass!(DefaultConstructedUnitStructs => [
+    DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
+]);
 
 fn is_alias(ty: hir::Ty<'_>) -> bool {
     if let hir::TyKind::Path(ref qpath) = ty.kind {
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index c7807f7b122a..fffdea863f51 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -28,6 +28,7 @@
     style,
     "check `std::iter::Empty::default()` and replace with `std::iter::empty()`"
 }
+
 declare_lint_pass!(DefaultIterEmpty => [DEFAULT_INSTEAD_OF_ITER_EMPTY]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index c1005688a921..61656d6cede5 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -48,6 +48,7 @@
     restriction,
     "unions without a `#[repr(C)]` attribute"
 }
+
 declare_lint_pass!(DefaultUnionRepresentation => [DEFAULT_UNION_REPRESENTATION]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 3433ab511b07..26dfa7593f22 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -3,7 +3,9 @@
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{adjust_derefs_manually_drop, implements_trait, is_manually_drop, peel_and_count_ty_refs};
-use clippy_utils::{DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_from_proc_macro, is_lint_allowed, sym};
+use clippy_utils::{
+    DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_from_proc_macro, is_lint_allowed, sym,
+};
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
@@ -20,6 +22,29 @@
 use rustc_span::{Span, Symbol};
 use std::borrow::Cow;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for dereferencing expressions which would be covered by auto-deref.
+    ///
+    /// ### Why is this bad?
+    /// This unnecessarily complicates the code.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = String::new();
+    /// let y: &str = &*x;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = String::new();
+    /// let y: &str = &x;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub EXPLICIT_AUTO_DEREF,
+    complexity,
+    "dereferencing when the compiler would automatically dereference"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for explicit `deref()` or `deref_mut()` method calls.
@@ -117,34 +142,11 @@
     "`ref` binding to a reference"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for dereferencing expressions which would be covered by auto-deref.
-    ///
-    /// ### Why is this bad?
-    /// This unnecessarily complicates the code.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = String::new();
-    /// let y: &str = &*x;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = String::new();
-    /// let y: &str = &x;
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub EXPLICIT_AUTO_DEREF,
-    complexity,
-    "dereferencing when the compiler would automatically dereference"
-}
-
 impl_lint_pass!(Dereferencing<'_> => [
+    EXPLICIT_AUTO_DEREF,
     EXPLICIT_DEREF_METHODS,
     NEEDLESS_BORROW,
     REF_BINDING_TO_REFERENCE,
-    EXPLICIT_AUTO_DEREF,
 ]);
 
 #[derive(Default)]
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 992ed320ce68..c04163b1c7a0 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -56,6 +56,8 @@
     "manual implementation of the `Default` trait which is equal to a derive"
 }
 
+impl_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
+
 pub struct DerivableImpls {
     msrv: Msrv,
 }
@@ -66,8 +68,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
-
 fn is_path_self(e: &Expr<'_>) -> bool {
     if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
         matches!(p.res, Res::SelfCtor(..) | Res::Def(DefKind::Ctor(..), _))
diff --git a/clippy_lints/src/derive/mod.rs b/clippy_lints/src/derive/mod.rs
index 86614201c406..fa1a7037154e 100644
--- a/clippy_lints/src/derive/mod.rs
+++ b/clippy_lints/src/derive/mod.rs
@@ -10,36 +10,6 @@
 mod expl_impl_clone_on_copy;
 mod unsafe_derive_deserialize;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
-    /// implementation.
-    ///
-    /// ### Why is this bad?
-    /// The implementation of these traits must agree (for
-    /// example for use with `HashMap`) so it’s probably a bad idea to use a
-    /// default-generated `Hash` implementation with an explicitly defined
-    /// `PartialEq`. In particular, the following must hold for any type:
-    ///
-    /// ```text
-    /// k1 == k2 ⇒ hash(k1) == hash(k2)
-    /// ```
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #[derive(Hash)]
-    /// struct Foo;
-    ///
-    /// impl PartialEq for Foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DERIVED_HASH_WITH_MANUAL_EQ,
-    correctness,
-    "deriving `Hash` but implementing `PartialEq` explicitly"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Lints against manual `PartialOrd` and `Ord` implementations for types with a derived `Ord`
@@ -91,6 +61,68 @@
     "deriving `Ord` but implementing `PartialOrd` explicitly"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for types that derive `PartialEq` and could implement `Eq`.
+    ///
+    /// ### Why is this bad?
+    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
+    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
+    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
+    /// `Eq` themselves.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[derive(PartialEq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    nursery,
+    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
+    /// implementation.
+    ///
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
+    /// example for use with `HashMap`) so it’s probably a bad idea to use a
+    /// default-generated `Hash` implementation with an explicitly defined
+    /// `PartialEq`. In particular, the following must hold for any type:
+    ///
+    /// ```text
+    /// k1 == k2 ⇒ hash(k1) == hash(k2)
+    /// ```
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[derive(Hash)]
+    /// struct Foo;
+    ///
+    /// impl PartialEq for Foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DERIVED_HASH_WITH_MANUAL_EQ,
+    correctness,
+    "deriving `Hash` but implementing `PartialEq` explicitly"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for explicit `Clone` implementations for `Copy`
@@ -152,44 +184,12 @@
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for types that derive `PartialEq` and could implement `Eq`.
-    ///
-    /// ### Why is this bad?
-    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
-    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
-    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
-    /// `Eq` themselves.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[derive(PartialEq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[derive(PartialEq, Eq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    nursery,
-    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
-}
-
 declare_lint_pass!(Derive => [
-    EXPL_IMPL_CLONE_ON_COPY,
     DERIVED_HASH_WITH_MANUAL_EQ,
     DERIVE_ORD_XOR_PARTIAL_ORD,
+    DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    EXPL_IMPL_CLONE_ON_COPY,
     UNSAFE_DERIVE_DESERIALIZE,
-    DERIVE_PARTIAL_EQ_WITHOUT_EQ
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Derive {
diff --git a/clippy_lints/src/disallowed_fields.rs b/clippy_lints/src/disallowed_fields.rs
index f1136556e2ed..9873c32f427f 100644
--- a/clippy_lints/src/disallowed_fields.rs
+++ b/clippy_lints/src/disallowed_fields.rs
@@ -56,6 +56,8 @@
     "declaration of a disallowed field use"
 }
 
+impl_lint_pass!(DisallowedFields => [DISALLOWED_FIELDS]);
+
 pub struct DisallowedFields {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
 }
@@ -74,8 +76,6 @@ pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(DisallowedFields => [DISALLOWED_FIELDS]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedFields {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let (id, span) = match &expr.kind {
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 1c9c971730f6..7253b65e4337 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -63,6 +63,8 @@
     "use of a disallowed macro"
 }
 
+impl_lint_pass!(DisallowedMacros => [DISALLOWED_MACROS]);
+
 pub struct DisallowedMacros {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
     seen: FxHashSet<ExpnId>,
@@ -125,8 +127,6 @@ fn check(&mut self, cx: &LateContext<'_>, span: Span, derive_src: Option<OwnerId
     }
 }
 
-impl_lint_pass!(DisallowedMacros => [DISALLOWED_MACROS]);
-
 impl LateLintPass<'_> for DisallowedMacros {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         // once we check a crate in the late pass we can emit the early pass lints
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 58403ad19235..e2fd71b7d990 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -61,6 +61,8 @@
     "use of a disallowed method call"
 }
 
+impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
+
 pub struct DisallowedMethods {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
 }
@@ -84,8 +86,6 @@ pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.desugaring_kind().is_some() {
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index 566aa12b08f5..1f658b2aa068 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -26,6 +26,8 @@
     "usage of a disallowed/placeholder name"
 }
 
+impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
+
 pub struct DisallowedNames {
     disallow: FxHashSet<Symbol>,
 }
@@ -38,8 +40,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedNames {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         if let PatKind::Binding(.., ident, _) = pat.kind
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 5b4fe2a6b803..4596d9457c0b 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -45,6 +45,8 @@
     "usage of non-allowed Unicode scripts"
 }
 
+impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
+
 pub struct DisallowedScriptIdents {
     whitelist: FxHashSet<Script>,
 }
@@ -62,8 +64,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
-
 impl EarlyLintPass for DisallowedScriptIdents {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
         // Implementation is heavily inspired by the implementation of [`non_ascii_idents`] lint:
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 9a82327a0d7b..2c520d053f43 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -57,6 +57,8 @@
     "use of disallowed types"
 }
 
+impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
+
 pub struct DisallowedTypes {
     def_ids: DefIdMap<(&'static str, &'static DisallowedPath)>,
     prim_tys: FxHashMap<PrimTy, (&'static str, &'static DisallowedPath)>,
@@ -104,8 +106,6 @@ pub fn def_kind_predicate(def_kind: DefKind) -> bool {
     )
 }
 
-impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Use(path, UseKind::Single(_)) = &item.kind
diff --git a/clippy_lints/src/doc/doc_paragraphs_missing_punctuation.rs b/clippy_lints/src/doc/doc_paragraphs_missing_punctuation.rs
index 605d35f48baf..cafb33aaa881 100644
--- a/clippy_lints/src/doc/doc_paragraphs_missing_punctuation.rs
+++ b/clippy_lints/src/doc/doc_paragraphs_missing_punctuation.rs
@@ -94,17 +94,14 @@ fn is_missing_punctuation(doc_string: &str) -> Vec<MissingPunctuation> {
             Event::Code(..) | Event::Start(Tag::Link { .. }) | Event::End(TagEnd::Link)
                 if no_report_depth == 0 && !offset.is_empty() =>
             {
-                if doc_string[..offset.end]
-                    .trim_end()
-                    .ends_with(TERMINAL_PUNCTUATION_MARKS)
-                {
+                if trim_trailing_symbols(&doc_string[..offset.end]).ends_with(TERMINAL_PUNCTUATION_MARKS) {
                     current_paragraph = None;
                 } else {
                     current_paragraph = Some(MissingPunctuation::Fixable(offset.end));
                 }
             },
             Event::Text(..) if no_report_depth == 0 && !offset.is_empty() => {
-                let trimmed = doc_string[..offset.end].trim_end();
+                let trimmed = trim_trailing_symbols(&doc_string[..offset.end]);
                 if trimmed.ends_with(TERMINAL_PUNCTUATION_MARKS) {
                     current_paragraph = None;
                 } else if let Some(t) = trimmed.strip_suffix(|c| c == ')' || c == '"') {
@@ -125,6 +122,21 @@ fn is_missing_punctuation(doc_string: &str) -> Vec<MissingPunctuation> {
     missing_punctuation
 }
 
+fn trim_trailing_symbols(s: &str) -> &str {
+    s.trim_end_matches(|c: char|
+        // Source: https://unicodeplus.com
+        matches!(c as u32,
+            0x1F300..=0x1F5FF | // Miscellaneous Symbols and Pictographs
+            0x1F600..=0x1F64F | // Emoticons
+            0x1F900..=0x1F9FF | // Supplemental Symbols and Pictographs
+            0x2700..=0x27BF   | // Dingbats
+            0x1FA70..=0x1FAFF | // Symbols and Pictographs Extended-A
+            0x1F680..=0x1F6FF | // Transport and Map Symbols
+            0x2600..=0x26FF | // Miscellaneous Symbols
+            0xFE00..=0xFE0F // Variation selectors
+        ) || c.is_whitespace())
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum MissingPunctuation {
     Fixable(usize),
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 0a2871f23964..a94133376cbf 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -39,6 +39,198 @@
 mod test_attr_in_doctest;
 mod too_long_first_doc_paragraph;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the doc comments have unbroken links, mostly caused
+    /// by bad formatted links such as broken across multiple lines.
+    ///
+    /// ### Why is this bad?
+    /// Because documentation generated by rustdoc will be broken
+    /// since expected links won't be links and just text.
+    ///
+    /// ### Examples
+    /// This link is broken:
+    /// ```no_run
+    /// /// [example of a bad link](https://
+    /// /// github.com/rust-lang/rust-clippy/)
+    /// pub fn do_something() {}
+    /// ```
+    ///
+    /// It shouldn't be broken across multiple lines to work:
+    /// ```no_run
+    /// /// [example of a good link](https://github.com/rust-lang/rust-clippy/)
+    /// pub fn do_something() {}
+    /// ```
+    #[clippy::version = "1.90.0"]
+    pub DOC_BROKEN_LINK,
+    pedantic,
+    "broken document link"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects doc comment linebreaks that use double spaces to separate lines, instead of back-slash (`\`).
+    ///
+    /// ### Why is this bad?
+    /// Double spaces, when used as doc comment linebreaks, can be difficult to see, and may
+    /// accidentally be removed during automatic formatting or manual refactoring. The use of a back-slash (`\`)
+    /// is clearer in this regard.
+    ///
+    /// ### Example
+    /// The two replacement dots in this example represent a double space.
+    /// ```no_run
+    /// /// This command takes two numbers as inputs and··
+    /// /// adds them together, and then returns the result.
+    /// fn add(l: i32, r: i32) -> i32 {
+    ///     l + r
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// /// This command takes two numbers as inputs and\
+    /// /// adds them together, and then returns the result.
+    /// fn add(l: i32, r: i32) -> i32 {
+    ///     l + r
+    /// }
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
+    pedantic,
+    "double-space used for doc comment linebreak instead of `\\`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if included files in doc comments are included only for `cfg(doc)`.
+    ///
+    /// ### Why restrict this?
+    /// These files are not useful for compilation but will still be included.
+    /// Also, if any of these non-source code file is updated, it will trigger a
+    /// recompilation.
+    ///
+    /// ### Known problems
+    ///
+    /// Excluding this will currently result in the file being left out if
+    /// the item's docs are inlined from another crate. This may be fixed in a
+    /// future version of rustdoc.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #![doc = include_str!("some_file.md")]
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #![cfg_attr(doc, doc = include_str!("some_file.md"))]
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub DOC_INCLUDE_WITHOUT_CFG,
+    restriction,
+    "check if files included in documentation are behind `cfg(doc)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// In CommonMark Markdown, the language used to write doc comments, a
+    /// paragraph nested within a list or block quote does not need any line
+    /// after the first one to be indented or marked. The specification calls
+    /// this a "lazy paragraph continuation."
+    ///
+    /// ### Why is this bad?
+    ///
+    /// This is easy to write but hard to read. Lazy continuations makes
+    /// unintended markers hard to see, and make it harder to deduce the
+    /// document's intended structure.
+    ///
+    /// ### Example
+    ///
+    /// This table is probably intended to have two rows,
+    /// but it does not. It has zero rows, and is followed by
+    /// a block quote.
+    /// ```no_run
+    /// /// Range | Description
+    /// /// ----- | -----------
+    /// /// >= 1  | fully opaque
+    /// /// < 1   | partially see-through
+    /// fn set_opacity(opacity: f32) {}
+    /// ```
+    ///
+    /// Fix it by escaping the marker:
+    /// ```no_run
+    /// /// Range | Description
+    /// /// ----- | -----------
+    /// /// \>= 1 | fully opaque
+    /// /// < 1   | partially see-through
+    /// fn set_opacity(opacity: f32) {}
+    /// ```
+    ///
+    /// This example is actually intended to be a list:
+    /// ```no_run
+    /// /// * Do nothing.
+    /// /// * Then do something. Whatever it is needs done,
+    /// /// it should be done right now.
+    /// # fn do_stuff() {}
+    /// ```
+    ///
+    /// Fix it by indenting the list contents:
+    /// ```no_run
+    /// /// * Do nothing.
+    /// /// * Then do something. Whatever it is needs done,
+    /// ///   it should be done right now.
+    /// # fn do_stuff() {}
+    /// ```
+    #[clippy::version = "1.80.0"]
+    pub DOC_LAZY_CONTINUATION,
+    style,
+    "require every line of a paragraph to be indented and marked"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for links with code directly adjacent to code text:
+    /// `` [`MyItem`]`<`[`u32`]`>` ``.
+    ///
+    /// ### Why is this bad?
+    /// It can be written more simply using HTML-style `<code>` tags.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// //! [`first`](x)`second`
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// //! <code>[first](x)second</code>
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub DOC_LINK_CODE,
+    nursery,
+    "link with code back-to-back with other code"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
+    /// outside of code blocks
+    /// ### Why is this bad?
+    /// It is likely a typo when defining an intra-doc link
+    ///
+    /// ### Example
+    /// ```no_run
+    /// /// See also: ['foo']
+    /// fn bar() {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// /// See also: [`foo`]
+    /// fn bar() {}
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DOC_LINK_WITH_QUOTES,
+    pedantic,
+    "possible typo for an intra-doc link"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the presence of `_`, `::` or camel-case words
@@ -83,59 +275,149 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for links with code directly adjacent to code text:
-    /// `` [`MyItem`]`<`[`u32`]`>` ``.
+    /// Warns if a link reference definition appears at the start of a
+    /// list item or quote.
     ///
     /// ### Why is this bad?
-    /// It can be written more simply using HTML-style `<code>` tags.
+    /// This is probably intended as an intra-doc link. If it is really
+    /// supposed to be a reference definition, it can be written outside
+    /// of the list item or quote.
     ///
     /// ### Example
     /// ```no_run
-    /// //! [`first`](x)`second`
+    /// //! - [link]: description
     /// ```
     /// Use instead:
     /// ```no_run
-    /// //! <code>[first](x)second</code>
+    /// //! - [link][]: description (for intra-doc link)
+    /// //!
+    /// //! [link]: destination (for link reference definition)
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub DOC_LINK_CODE,
-    nursery,
-    "link with code back-to-back with other code"
+    #[clippy::version = "1.85.0"]
+    pub DOC_NESTED_REFDEFS,
+    suspicious,
+    "link reference defined in list item or quote"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// unsafe functions and warns if there is no `# Safety` section.
+    ///
+    /// Detects overindented list items in doc comments where the continuation
+    /// lines are indented more than necessary.
     ///
     /// ### Why is this bad?
-    /// Unsafe functions should document their safety
-    /// preconditions, so that users can be sure they are using them safely.
     ///
-    /// ### Examples
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
+    /// Overindented list items in doc comments can lead to inconsistent and
+    /// poorly formatted documentation when rendered. Excessive indentation may
+    /// cause the text to be misinterpreted as a nested list item or code block,
+    /// affecting readability and the overall structure of the documentation.
     ///
-    /// At least write a line about safety:
+    /// ### Example
     ///
     /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
-    /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
+    /// /// - This is the first item in a list
+    /// ///      and this line is overindented.
+    /// # fn foo() {}
     /// ```
-    #[clippy::version = "1.39.0"]
-    pub MISSING_SAFETY_DOC,
+    ///
+    /// Fixes this into:
+    /// ```no_run
+    /// /// - This is the first item in a list
+    /// ///   and this line is overindented.
+    /// # fn foo() {}
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub DOC_OVERINDENTED_LIST_ITEMS,
     style,
-    "`pub unsafe fn` without `# Safety` docs"
+    "ensure list items are not overindented"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for doc comments whose paragraphs do not end with a period or another punctuation mark.
+    /// Various Markdowns constructs are taken into account to avoid false positives.
+    ///
+    /// ### Why is this bad?
+    /// A project may wish to enforce consistent doc comments by making sure paragraphs end with a
+    /// punctuation mark.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// /// Returns a random number
+    /// ///
+    /// /// It was chosen by a fair dice roll
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// /// Returns a random number.
+    /// ///
+    /// /// It was chosen by a fair dice roll.
+    /// ```
+    ///
+    /// ### Terminal punctuation marks
+    /// This lint treats these characters as end markers: '.', '?', '!', '…' and ':'.
+    ///
+    /// The colon is not exactly a terminal punctuation mark, but this is required for paragraphs that
+    /// introduce a table or a list for example.
+    #[clippy::version = "1.93.0"]
+    pub DOC_PARAGRAPHS_MISSING_PUNCTUATION,
+    restriction,
+    "missing terminal punctuation in doc comments"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects syntax that looks like a footnote reference.
+    ///
+    /// Rustdoc footnotes are compatible with GitHub-Flavored Markdown (GFM).
+    /// GFM does not parse a footnote reference unless its definition also
+    /// exists. This lint checks for footnote references with missing
+    /// definitions, unless it thinks you're writing a regex.
+    ///
+    /// ### Why is this bad?
+    /// This probably means that a footnote was meant to exist,
+    /// but was not written.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// /// This is not a footnote[^1], because no definition exists.
+    /// fn my_fn() {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// /// This is a footnote[^1].
+    /// ///
+    /// /// [^1]: defined here
+    /// fn my_fn() {}
+    /// ```
+    #[clippy::version = "1.89.0"]
+    pub DOC_SUSPICIOUS_FOOTNOTES,
+    suspicious,
+    "looks like a link or footnote ref, but with no definition"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects documentation that is empty.
+    /// ### Why is this bad?
+    /// Empty docs clutter code without adding value, reducing readability and maintainability.
+    /// ### Example
+    /// ```no_run
+    /// ///
+    /// fn returns_true() -> bool {
+    ///     true
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn returns_true() -> bool {
+    ///     true
+    /// }
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub EMPTY_DOCS,
+    suspicious,
+    "docstrings exist but documentation is empty"
 }
 
 declare_clippy_lint! {
@@ -211,6 +493,41 @@
     "`pub fn` may panic without `# Panics` in doc comment"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
+    /// unsafe functions and warns if there is no `# Safety` section.
+    ///
+    /// ### Why is this bad?
+    /// Unsafe functions should document their safety
+    /// preconditions, so that users can be sure they are using them safely.
+    ///
+    /// ### Examples
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    ///
+    /// At least write a line about safety:
+    ///
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub MISSING_SAFETY_DOC,
+    style,
+    "`pub unsafe fn` without `# Safety` docs"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `fn main() { .. }` in doctests
@@ -240,126 +557,6 @@
     "presence of `fn main() {` in code examples"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `#[test]` in doctests unless they are marked with
-    /// either `ignore`, `no_run` or `compile_fail`.
-    ///
-    /// ### Why is this bad?
-    /// Code in examples marked as `#[test]` will somewhat
-    /// surprisingly not be run by `cargo test`. If you really want
-    /// to show how to test stuff in an example, mark it `no_run` to
-    /// make the intent clear.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// /// An example of a doctest with a `main()` function
-    /// ///
-    /// /// # Examples
-    /// ///
-    /// /// ```
-    /// /// #[test]
-    /// /// fn equality_works() {
-    /// ///     assert_eq!(1_u8, 1);
-    /// /// }
-    /// /// ```
-    /// fn test_attr_in_doctest() {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.76.0"]
-    pub TEST_ATTR_IN_DOCTEST,
-    suspicious,
-    "presence of `#[test]` in code examples"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
-    /// outside of code blocks
-    /// ### Why is this bad?
-    /// It is likely a typo when defining an intra-doc link
-    ///
-    /// ### Example
-    /// ```no_run
-    /// /// See also: ['foo']
-    /// fn bar() {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// /// See also: [`foo`]
-    /// fn bar() {}
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DOC_LINK_WITH_QUOTES,
-    pedantic,
-    "possible typo for an intra-doc link"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the doc comments have unbroken links, mostly caused
-    /// by bad formatted links such as broken across multiple lines.
-    ///
-    /// ### Why is this bad?
-    /// Because documentation generated by rustdoc will be broken
-    /// since expected links won't be links and just text.
-    ///
-    /// ### Examples
-    /// This link is broken:
-    /// ```no_run
-    /// /// [example of a bad link](https://
-    /// /// github.com/rust-lang/rust-clippy/)
-    /// pub fn do_something() {}
-    /// ```
-    ///
-    /// It shouldn't be broken across multiple lines to work:
-    /// ```no_run
-    /// /// [example of a good link](https://github.com/rust-lang/rust-clippy/)
-    /// pub fn do_something() {}
-    /// ```
-    #[clippy::version = "1.90.0"]
-    pub DOC_BROKEN_LINK,
-    pedantic,
-    "broken document link"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// safe functions and traits and warns if there is a `# Safety` section.
-    ///
-    /// ### Why restrict this?
-    /// Safe functions and traits are safe to implement and therefore do not
-    /// need to describe safety preconditions that users are required to uphold.
-    ///
-    /// ### Examples
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
-    /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    ///
-    /// The function is safe, so there shouldn't be any preconditions
-    /// that have to be explained for safety reasons.
-    ///
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.67.0"]
-    pub UNNECESSARY_SAFETY_DOC,
-    restriction,
-    "`pub fn` or `pub trait` with `# Safety` docs"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
@@ -409,116 +606,35 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects documentation that is empty.
+    /// Checks for `#[test]` in doctests unless they are marked with
+    /// either `ignore`, `no_run` or `compile_fail`.
+    ///
     /// ### Why is this bad?
-    /// Empty docs clutter code without adding value, reducing readability and maintainability.
-    /// ### Example
+    /// Code in examples marked as `#[test]` will somewhat
+    /// surprisingly not be run by `cargo test`. If you really want
+    /// to show how to test stuff in an example, mark it `no_run` to
+    /// make the intent clear.
+    ///
+    /// ### Examples
     /// ```no_run
+    /// /// An example of a doctest with a `main()` function
     /// ///
-    /// fn returns_true() -> bool {
-    ///     true
+    /// /// # Examples
+    /// ///
+    /// /// ```
+    /// /// #[test]
+    /// /// fn equality_works() {
+    /// ///     assert_eq!(1_u8, 1);
+    /// /// }
+    /// /// ```
+    /// fn test_attr_in_doctest() {
+    ///     unimplemented!();
     /// }
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn returns_true() -> bool {
-    ///     true
-    /// }
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub EMPTY_DOCS,
+    #[clippy::version = "1.76.0"]
+    pub TEST_ATTR_IN_DOCTEST,
     suspicious,
-    "docstrings exist but documentation is empty"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// In CommonMark Markdown, the language used to write doc comments, a
-    /// paragraph nested within a list or block quote does not need any line
-    /// after the first one to be indented or marked. The specification calls
-    /// this a "lazy paragraph continuation."
-    ///
-    /// ### Why is this bad?
-    ///
-    /// This is easy to write but hard to read. Lazy continuations makes
-    /// unintended markers hard to see, and make it harder to deduce the
-    /// document's intended structure.
-    ///
-    /// ### Example
-    ///
-    /// This table is probably intended to have two rows,
-    /// but it does not. It has zero rows, and is followed by
-    /// a block quote.
-    /// ```no_run
-    /// /// Range | Description
-    /// /// ----- | -----------
-    /// /// >= 1  | fully opaque
-    /// /// < 1   | partially see-through
-    /// fn set_opacity(opacity: f32) {}
-    /// ```
-    ///
-    /// Fix it by escaping the marker:
-    /// ```no_run
-    /// /// Range | Description
-    /// /// ----- | -----------
-    /// /// \>= 1 | fully opaque
-    /// /// < 1   | partially see-through
-    /// fn set_opacity(opacity: f32) {}
-    /// ```
-    ///
-    /// This example is actually intended to be a list:
-    /// ```no_run
-    /// /// * Do nothing.
-    /// /// * Then do something. Whatever it is needs done,
-    /// /// it should be done right now.
-    /// # fn do_stuff() {}
-    /// ```
-    ///
-    /// Fix it by indenting the list contents:
-    /// ```no_run
-    /// /// * Do nothing.
-    /// /// * Then do something. Whatever it is needs done,
-    /// ///   it should be done right now.
-    /// # fn do_stuff() {}
-    /// ```
-    #[clippy::version = "1.80.0"]
-    pub DOC_LAZY_CONTINUATION,
-    style,
-    "require every line of a paragraph to be indented and marked"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Detects overindented list items in doc comments where the continuation
-    /// lines are indented more than necessary.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Overindented list items in doc comments can lead to inconsistent and
-    /// poorly formatted documentation when rendered. Excessive indentation may
-    /// cause the text to be misinterpreted as a nested list item or code block,
-    /// affecting readability and the overall structure of the documentation.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// /// - This is the first item in a list
-    /// ///      and this line is overindented.
-    /// # fn foo() {}
-    /// ```
-    ///
-    /// Fixes this into:
-    /// ```no_run
-    /// /// - This is the first item in a list
-    /// ///   and this line is overindented.
-    /// # fn foo() {}
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub DOC_OVERINDENTED_LIST_ITEMS,
-    style,
-    "ensure list items are not overindented"
+    "presence of `#[test]` in code examples"
 }
 
 declare_clippy_lint! {
@@ -554,156 +670,63 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if included files in doc comments are included only for `cfg(doc)`.
+    /// Checks for the doc comments of publicly visible
+    /// safe functions and traits and warns if there is a `# Safety` section.
     ///
     /// ### Why restrict this?
-    /// These files are not useful for compilation but will still be included.
-    /// Also, if any of these non-source code file is updated, it will trigger a
-    /// recompilation.
+    /// Safe functions and traits are safe to implement and therefore do not
+    /// need to describe safety preconditions that users are required to uphold.
     ///
-    /// ### Known problems
-    ///
-    /// Excluding this will currently result in the file being left out if
-    /// the item's docs are inlined from another crate. This may be fixed in a
-    /// future version of rustdoc.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #![doc = include_str!("some_file.md")]
-    /// ```
-    /// Use instead:
+    /// ### Examples
     /// ```no_run
-    /// #![cfg_attr(doc, doc = include_str!("some_file.md"))]
-    /// ```
-    #[clippy::version = "1.85.0"]
-    pub DOC_INCLUDE_WITHOUT_CFG,
-    restriction,
-    "check if files included in documentation are behind `cfg(doc)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if a link reference definition appears at the start of a
-    /// list item or quote.
-    ///
-    /// ### Why is this bad?
-    /// This is probably intended as an intra-doc link. If it is really
-    /// supposed to be a reference definition, it can be written outside
-    /// of the list item or quote.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// //! - [link]: description
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// //! - [link][]: description (for intra-doc link)
-    /// //!
-    /// //! [link]: destination (for link reference definition)
-    /// ```
-    #[clippy::version = "1.85.0"]
-    pub DOC_NESTED_REFDEFS,
-    suspicious,
-    "link reference defined in list item or quote"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects doc comment linebreaks that use double spaces to separate lines, instead of back-slash (`\`).
-    ///
-    /// ### Why is this bad?
-    /// Double spaces, when used as doc comment linebreaks, can be difficult to see, and may
-    /// accidentally be removed during automatic formatting or manual refactoring. The use of a back-slash (`\`)
-    /// is clearer in this regard.
-    ///
-    /// ### Example
-    /// The two replacement dots in this example represent a double space.
-    /// ```no_run
-    /// /// This command takes two numbers as inputs and··
-    /// /// adds them together, and then returns the result.
-    /// fn add(l: i32, r: i32) -> i32 {
-    ///     l + r
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
+    ///     unimplemented!();
     /// }
     /// ```
     ///
-    /// Use instead:
+    /// The function is safe, so there shouldn't be any preconditions
+    /// that have to be explained for safety reasons.
+    ///
     /// ```no_run
-    /// /// This command takes two numbers as inputs and\
-    /// /// adds them together, and then returns the result.
-    /// fn add(l: i32, r: i32) -> i32 {
-    ///     l + r
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
     /// }
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
-    pedantic,
-    "double-space used for doc comment linebreak instead of `\\`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects syntax that looks like a footnote reference.
-    ///
-    /// Rustdoc footnotes are compatible with GitHub-Flavored Markdown (GFM).
-    /// GFM does not parse a footnote reference unless its definition also
-    /// exists. This lint checks for footnote references with missing
-    /// definitions, unless it thinks you're writing a regex.
-    ///
-    /// ### Why is this bad?
-    /// This probably means that a footnote was meant to exist,
-    /// but was not written.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// /// This is not a footnote[^1], because no definition exists.
-    /// fn my_fn() {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// /// This is a footnote[^1].
-    /// ///
-    /// /// [^1]: defined here
-    /// fn my_fn() {}
-    /// ```
-    #[clippy::version = "1.89.0"]
-    pub DOC_SUSPICIOUS_FOOTNOTES,
-    suspicious,
-    "looks like a link or footnote ref, but with no definition"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for doc comments whose paragraphs do not end with a period or another punctuation mark.
-    /// Various Markdowns constructs are taken into account to avoid false positives.
-    ///
-    /// ### Why is this bad?
-    /// A project may wish to enforce consistent doc comments by making sure paragraphs end with a
-    /// punctuation mark.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// /// Returns a random number
-    /// ///
-    /// /// It was chosen by a fair dice roll
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// /// Returns a random number.
-    /// ///
-    /// /// It was chosen by a fair dice roll.
-    /// ```
-    ///
-    /// ### Terminal punctuation marks
-    /// This lint treats these characters as end markers: '.', '?', '!', '…' and ':'.
-    ///
-    /// The colon is not exactly a terminal punctuation mark, but this is required for paragraphs that
-    /// introduce a table or a list for example.
-    #[clippy::version = "1.93.0"]
-    pub DOC_PARAGRAPHS_MISSING_PUNCTUATION,
+    #[clippy::version = "1.67.0"]
+    pub UNNECESSARY_SAFETY_DOC,
     restriction,
-    "missing terminal punctuation in doc comments"
+    "`pub fn` or `pub trait` with `# Safety` docs"
 }
 
+impl_lint_pass!(Documentation => [
+    DOC_BROKEN_LINK,
+    DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
+    DOC_INCLUDE_WITHOUT_CFG,
+    DOC_LAZY_CONTINUATION,
+    DOC_LINK_CODE,
+    DOC_LINK_WITH_QUOTES,
+    DOC_MARKDOWN,
+    DOC_NESTED_REFDEFS,
+    DOC_OVERINDENTED_LIST_ITEMS,
+    DOC_PARAGRAPHS_MISSING_PUNCTUATION,
+    DOC_SUSPICIOUS_FOOTNOTES,
+    EMPTY_DOCS,
+    MISSING_ERRORS_DOC,
+    MISSING_PANICS_DOC,
+    MISSING_SAFETY_DOC,
+    NEEDLESS_DOCTEST_MAIN,
+    SUSPICIOUS_DOC_COMMENTS,
+    TEST_ATTR_IN_DOCTEST,
+    TOO_LONG_FIRST_DOC_PARAGRAPH,
+    UNNECESSARY_SAFETY_DOC,
+]);
+
 pub struct Documentation {
     valid_idents: FxHashSet<String>,
     check_private_items: bool,
@@ -718,29 +741,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Documentation => [
-    DOC_LINK_CODE,
-    DOC_LINK_WITH_QUOTES,
-    DOC_BROKEN_LINK,
-    DOC_MARKDOWN,
-    DOC_NESTED_REFDEFS,
-    MISSING_SAFETY_DOC,
-    MISSING_ERRORS_DOC,
-    MISSING_PANICS_DOC,
-    NEEDLESS_DOCTEST_MAIN,
-    TEST_ATTR_IN_DOCTEST,
-    UNNECESSARY_SAFETY_DOC,
-    SUSPICIOUS_DOC_COMMENTS,
-    EMPTY_DOCS,
-    DOC_LAZY_CONTINUATION,
-    DOC_OVERINDENTED_LIST_ITEMS,
-    TOO_LONG_FIRST_DOC_PARAGRAPH,
-    DOC_INCLUDE_WITHOUT_CFG,
-    DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
-    DOC_SUSPICIOUS_FOOTNOTES,
-    DOC_PARAGRAPHS_MISSING_PUNCTUATION,
-]);
-
 impl EarlyLintPass for Documentation {
     fn check_attributes(&mut self, cx: &EarlyContext<'_>, attrs: &[rustc_ast::Attribute]) {
         include_in_doc_without_cfg::check(cx, attrs);
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 3bb8c484ceec..5da76bc3095f 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -70,17 +70,13 @@
     "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
 }
 
+declare_lint_pass!(DropForgetRef => [DROP_NON_DROP, FORGET_NON_DROP, MEM_FORGET]);
+
 const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
                                  Dropping such a type only extends its contained lifetimes";
 const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
                                    Forgetting such a type is the same as dropping it";
 
-declare_lint_pass!(DropForgetRef => [
-    DROP_NON_DROP,
-    FORGET_NON_DROP,
-    MEM_FORGET,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Call(path, [arg]) = expr.kind
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index 759b7b6837bd..f3facac32107 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -46,6 +46,8 @@
     "file loaded as module multiple times"
 }
 
+impl_lint_pass!(DuplicateMod => [DUPLICATE_MOD]);
+
 struct Modules {
     local_path: PathBuf,
     spans: Vec<Span>,
@@ -59,8 +61,6 @@ pub struct DuplicateMod {
     modules: BTreeMap<PathBuf, Modules>,
 }
 
-impl_lint_pass!(DuplicateMod => [DUPLICATE_MOD]);
-
 impl EarlyLintPass for DuplicateMod {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if let ItemKind::Mod(_, _, ModKind::Loaded(_, Inline::No { .. }, mod_spans)) = &item.kind
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 2b8221884344..1a10e962e875 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -31,6 +31,7 @@
     restriction,
     "empty `Drop` implementations"
 }
+
 declare_lint_pass!(EmptyDrop => [EMPTY_DROP]);
 
 impl LateLintPass<'_> for EmptyDrop {
diff --git a/clippy_lints/src/empty_line_after.rs b/clippy_lints/src/empty_line_after.rs
index 12dcf9252f73..b7b84c173f41 100644
--- a/clippy_lints/src/empty_line_after.rs
+++ b/clippy_lints/src/empty_line_after.rs
@@ -12,41 +12,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, ExpnKind, Ident, InnerSpan, Span, SpanData, Symbol, kw, sym};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for empty lines after outer attributes
-    ///
-    /// ### Why is this bad?
-    /// The attribute may have meant to be an inner attribute (`#![attr]`). If
-    /// it was meant to be an outer attribute (`#[attr]`) then the empty line
-    /// should be removed
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[allow(dead_code)]
-    ///
-    /// fn not_quite_good_code() {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// // Good (as inner attribute)
-    /// #![allow(dead_code)]
-    ///
-    /// fn this_is_fine() {}
-    ///
-    /// // or
-    ///
-    /// // Good (as outer attribute)
-    /// #[allow(dead_code)]
-    /// fn this_is_fine_too() {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EMPTY_LINE_AFTER_OUTER_ATTR,
-    suspicious,
-    "empty line after outer attribute"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for empty lines after doc comments.
@@ -88,6 +53,46 @@
     "empty line after doc comments"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty lines after outer attributes
+    ///
+    /// ### Why is this bad?
+    /// The attribute may have meant to be an inner attribute (`#![attr]`). If
+    /// it was meant to be an outer attribute (`#[attr]`) then the empty line
+    /// should be removed
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[allow(dead_code)]
+    ///
+    /// fn not_quite_good_code() {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// // Good (as inner attribute)
+    /// #![allow(dead_code)]
+    ///
+    /// fn this_is_fine() {}
+    ///
+    /// // or
+    ///
+    /// // Good (as outer attribute)
+    /// #[allow(dead_code)]
+    /// fn this_is_fine_too() {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EMPTY_LINE_AFTER_OUTER_ATTR,
+    suspicious,
+    "empty line after outer attribute"
+}
+
+impl_lint_pass!(EmptyLineAfter => [
+    EMPTY_LINE_AFTER_DOC_COMMENTS,
+    EMPTY_LINE_AFTER_OUTER_ATTR,
+]);
+
 #[derive(Debug)]
 struct ItemInfo {
     kind: &'static str,
@@ -100,11 +105,6 @@ pub struct EmptyLineAfter {
     items: Vec<ItemInfo>,
 }
 
-impl_lint_pass!(EmptyLineAfter => [
-    EMPTY_LINE_AFTER_OUTER_ATTR,
-    EMPTY_LINE_AFTER_DOC_COMMENTS,
-]);
-
 impl EmptyLineAfter {
     pub fn new() -> Self {
         Self { items: Vec::new() }
diff --git a/clippy_lints/src/empty_with_brackets.rs b/clippy_lints/src/empty_with_brackets.rs
index 7e335d5c9809..53e6b7f95ae3 100644
--- a/clippy_lints/src/empty_with_brackets.rs
+++ b/clippy_lints/src/empty_with_brackets.rs
@@ -14,34 +14,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Span};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
-    ///
-    /// ### Why restrict this?
-    /// Empty brackets after a struct declaration can be omitted,
-    /// and it may be desirable to do so consistently for style.
-    ///
-    /// However, removing the brackets also introduces a public constant named after the struct,
-    /// so this is not just a syntactic simplification but an API change, and adding them back
-    /// is a *breaking* API change.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct Cookie {}
-    /// struct Biscuit();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// struct Cookie;
-    /// struct Biscuit;
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub EMPTY_STRUCTS_WITH_BRACKETS,
-    restriction,
-    "finds struct declarations with empty brackets"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Finds enum variants without fields that are declared with empty brackets.
@@ -77,6 +49,39 @@
     "finds enum variants with empty brackets"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
+    ///
+    /// ### Why restrict this?
+    /// Empty brackets after a struct declaration can be omitted,
+    /// and it may be desirable to do so consistently for style.
+    ///
+    /// However, removing the brackets also introduces a public constant named after the struct,
+    /// so this is not just a syntactic simplification but an API change, and adding them back
+    /// is a *breaking* API change.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct Cookie {}
+    /// struct Biscuit();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct Cookie;
+    /// struct Biscuit;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub EMPTY_STRUCTS_WITH_BRACKETS,
+    restriction,
+    "finds struct declarations with empty brackets"
+}
+
+impl_lint_pass!(EmptyWithBrackets => [
+    EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
+    EMPTY_STRUCTS_WITH_BRACKETS,
+]);
+
 #[derive(Debug)]
 enum Usage {
     Unused { redundant_use_sites: Vec<Span> },
@@ -90,8 +95,6 @@ pub struct EmptyWithBrackets {
     empty_tuple_enum_variants: FxIndexMap<LocalDefId, Usage>,
 }
 
-impl_lint_pass!(EmptyWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS, EMPTY_ENUM_VARIANTS_WITH_BRACKETS]);
-
 impl LateLintPass<'_> for EmptyWithBrackets {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         // FIXME: handle `struct $name {}`
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 75db923b1c37..d76729047cdc 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -8,6 +8,24 @@
 use rustc_span::Symbol;
 use std::fmt::Write;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of the `to_be_bytes` method and/or the function `from_be_bytes`.
+    ///
+    /// ### Why restrict this?
+    /// To ensure use of little-endian or the target’s endianness rather than big-endian.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _x = 2i32.to_be_bytes();
+    /// let _y = 2i64.to_be_bytes();
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub BIG_ENDIAN_BYTES,
+    restriction,
+    "disallows usage of the `to_be_bytes` method"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the usage of the `to_ne_bytes` method and/or the function `from_ne_bytes`.
@@ -45,25 +63,11 @@
     "disallows usage of the `to_le_bytes` method"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of the `to_be_bytes` method and/or the function `from_be_bytes`.
-    ///
-    /// ### Why restrict this?
-    /// To ensure use of little-endian or the target’s endianness rather than big-endian.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let _x = 2i32.to_be_bytes();
-    /// let _y = 2i64.to_be_bytes();
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub BIG_ENDIAN_BYTES,
-    restriction,
-    "disallows usage of the `to_be_bytes` method"
-}
-
-declare_lint_pass!(EndianBytes => [HOST_ENDIAN_BYTES, LITTLE_ENDIAN_BYTES, BIG_ENDIAN_BYTES]);
+declare_lint_pass!(EndianBytes => [
+    BIG_ENDIAN_BYTES,
+    HOST_ENDIAN_BYTES,
+    LITTLE_ENDIAN_BYTES,
+]);
 
 const HOST_NAMES: [Symbol; 2] = [sym::from_ne_bytes, sym::to_ne_bytes];
 const LITTLE_NAMES: [Symbol; 2] = [sym::from_le_bytes, sym::to_le_bytes];
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index bb9c9ec3614b..f700cb677343 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -2,7 +2,10 @@
 use clippy_utils::source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{SpanlessEq, can_move_expr_to_closure_no_visit, desugar_await, higher, is_expr_final_block_expr, is_expr_used_or_unified, paths, peel_hir_expr_while, span_contains_non_whitespace, sym};
+use clippy_utils::{
+    SpanlessEq, can_move_expr_to_closure_no_visit, desugar_await, higher, is_expr_final_block_expr,
+    is_expr_used_or_unified, paths, peel_hir_expr_while, span_contains_non_whitespace, sym,
+};
 use core::fmt::{self, Write};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 6604c9a4050b..32be1ad1e644 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -32,6 +32,7 @@
     restriction,
     "exported types named `Error` that implement `Error`"
 }
+
 declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
 
 impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index fc224fa5f924..2e88d78ce909 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -50,6 +50,8 @@ pub fn new(conf: &'static Conf) -> Self {
     "using `Box<T>` where unnecessary"
 }
 
+impl_lint_pass!(BoxedLocal => [BOXED_LOCAL]);
+
 fn is_non_trait_box(ty: Ty<'_>) -> bool {
     ty.boxed_ty().is_some_and(|boxed| !boxed.is_trait())
 }
@@ -61,8 +63,6 @@ struct EscapeDelegate<'a, 'tcx> {
     too_large_for_stack: u64,
 }
 
-impl_lint_pass!(BoxedLocal => [BOXED_LOCAL]);
-
 impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 20cf3796c8be..3562200cbd92 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -65,7 +65,10 @@
     "redundant closures for method calls"
 }
 
-declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
+declare_lint_pass!(EtaReduction => [
+    REDUNDANT_CLOSURE,
+    REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for EtaReduction {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
@@ -215,6 +218,18 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                     "redundant closure",
                     |diag| {
                         if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+                            let n_refs = callee_ty_adjustments
+                                .iter()
+                                .rev()
+                                .fold(0, |acc, adjustment| match adjustment.kind {
+                                    Adjust::Deref(DerefAdjustKind::Overloaded(_)) => acc + 1,
+                                    Adjust::Deref(_) if acc > 0 => acc + 1,
+                                    _ => acc,
+                                });
+                            if n_refs > 0 {
+                                snippet = format!("{}{snippet}", "*".repeat(n_refs));
+                            }
+
                             if callee.res_local_id().is_some_and(|l| {
                                 // FIXME: Do we really need this `local_used_in` check?
                                 // Isn't it checking something like... `callee(callee)`?
@@ -230,18 +245,6 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                     },
                                     _ => (),
                                 }
-                            } else if let n_refs =
-                                callee_ty_adjustments
-                                    .iter()
-                                    .rev()
-                                    .fold(0, |acc, adjustment| match adjustment.kind {
-                                        Adjust::Deref(DerefAdjustKind::Overloaded(_)) => acc + 1,
-                                        Adjust::Deref(_) if acc > 0 => acc + 1,
-                                        _ => acc,
-                                    })
-                                && n_refs > 0
-                            {
-                                snippet = format!("{}{snippet}", "*".repeat(n_refs));
                             }
 
                             let replace_with = match callee_ty_adjusted.kind() {
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 686dc5c3c4fc..65d0ff9b543f 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -9,6 +9,44 @@
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for excessive use of
+    /// bools in function definitions.
+    ///
+    /// ### Why is this bad?
+    /// Calls to such functions
+    /// are confusing and error prone, because it's
+    /// hard to remember argument order and you have
+    /// no type system support to back you up. Using
+    /// two-variant enums instead of bools often makes
+    /// API easier to use.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn f(is_round: bool, is_hot: bool) { ... }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// enum Shape {
+    ///     Round,
+    ///     Spiky,
+    /// }
+    ///
+    /// enum Temperature {
+    ///     Hot,
+    ///     IceCold,
+    /// }
+    ///
+    /// fn f(shape: Shape, temperature: Temperature) { ... }
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub FN_PARAMS_EXCESSIVE_BOOLS,
+    pedantic,
+    "using too many bools in function parameters"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for excessive
@@ -50,43 +88,10 @@
     "using too many bools in a struct"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for excessive use of
-    /// bools in function definitions.
-    ///
-    /// ### Why is this bad?
-    /// Calls to such functions
-    /// are confusing and error prone, because it's
-    /// hard to remember argument order and you have
-    /// no type system support to back you up. Using
-    /// two-variant enums instead of bools often makes
-    /// API easier to use.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// fn f(is_round: bool, is_hot: bool) { ... }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// enum Shape {
-    ///     Round,
-    ///     Spiky,
-    /// }
-    ///
-    /// enum Temperature {
-    ///     Hot,
-    ///     IceCold,
-    /// }
-    ///
-    /// fn f(shape: Shape, temperature: Temperature) { ... }
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub FN_PARAMS_EXCESSIVE_BOOLS,
-    pedantic,
-    "using too many bools in function parameters"
-}
+impl_lint_pass!(ExcessiveBools => [
+    FN_PARAMS_EXCESSIVE_BOOLS,
+    STRUCT_EXCESSIVE_BOOLS,
+]);
 
 pub struct ExcessiveBools {
     max_struct_bools: u64,
@@ -102,8 +107,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ExcessiveBools => [STRUCT_EXCESSIVE_BOOLS, FN_PARAMS_EXCESSIVE_BOOLS]);
-
 fn has_n_bools<'tcx>(iter: impl Iterator<Item = &'tcx Ty<'tcx>>, mut count: u64) -> bool {
     iter.filter(|ty| is_bool(ty)).any(|_| {
         let (x, overflow) = count.overflowing_sub(1);
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 5368701c3041..58d00933a785 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -61,6 +61,7 @@
     complexity,
     "checks for blocks nested beyond a certain threshold"
 }
+
 impl_lint_pass!(ExcessiveNesting => [EXCESSIVE_NESTING]);
 
 pub struct ExcessiveNesting {
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index c59ffa14a5fe..a85025a48e5a 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -39,6 +39,8 @@
     "using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work"
 }
 
+impl_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
+
 pub struct ExplicitWrite {
     format_args: FormatArgsStorage,
 }
@@ -49,8 +51,6 @@ pub fn new(format_args: FormatArgsStorage) -> Self {
     }
 }
 
-impl_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
-
 impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // match call to unwrap
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index fb98cb30ae90..93a6dc59993a 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -40,6 +40,8 @@
     "unused type parameters in function definitions"
 }
 
+impl_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
+
 pub struct ExtraUnusedTypeParameters {
     avoid_breaking_exported_api: bool,
 }
@@ -52,8 +54,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
-
 /// A visitor struct that walks a given function and gathers generic type parameters, plus any
 /// trait bounds those parameters have.
 struct TypeWalker<'cx, 'tcx> {
diff --git a/clippy_lints/src/field_scoped_visibility_modifiers.rs b/clippy_lints/src/field_scoped_visibility_modifiers.rs
index dfb0b4f103c5..4b736c68cb86 100644
--- a/clippy_lints/src/field_scoped_visibility_modifiers.rs
+++ b/clippy_lints/src/field_scoped_visibility_modifiers.rs
@@ -47,7 +47,9 @@
     "checks for usage of a scoped visibility modifier, like `pub(crate)`, on fields"
 }
 
-declare_lint_pass!(FieldScopedVisibilityModifiers => [FIELD_SCOPED_VISIBILITY_MODIFIERS]);
+declare_lint_pass!(FieldScopedVisibilityModifiers => [
+    FIELD_SCOPED_VISIBILITY_MODIFIERS,
+]);
 
 impl EarlyLintPass for FieldScopedVisibilityModifiers {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 6178addfff12..c6ae2cfc2545 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -61,14 +61,12 @@
     "lossy whole number float literals"
 }
 
+impl_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
+
 pub struct FloatLiteral {
     const_literal_digits_threshold: usize,
 }
 
-impl_lint_pass!(FloatLiteral => [
-    EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL
-]);
-
 impl FloatLiteral {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/floating_point_arithmetic/mod.rs b/clippy_lints/src/floating_point_arithmetic/mod.rs
index edc638c96bbf..0833761b32dc 100644
--- a/clippy_lints/src/floating_point_arithmetic/mod.rs
+++ b/clippy_lints/src/floating_point_arithmetic/mod.rs
@@ -103,10 +103,7 @@
     "usage of sub-optimal floating point operations"
 }
 
-declare_lint_pass!(FloatingPointArithmetic => [
-    IMPRECISE_FLOPS,
-    SUBOPTIMAL_FLOPS
-]);
+declare_lint_pass!(FloatingPointArithmetic => [IMPRECISE_FLOPS, SUBOPTIMAL_FLOPS]);
 
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/floating_point_arithmetic/mul_add.rs b/clippy_lints/src/floating_point_arithmetic/mul_add.rs
index 03a9d3b05f88..e0a6498f62fd 100644
--- a/clippy_lints/src/floating_point_arithmetic/mul_add.rs
+++ b/clippy_lints/src/floating_point_arithmetic/mul_add.rs
@@ -1,6 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, has_ambiguous_literal_in_expr, sym};
+use rustc_ast::AssignOpKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
@@ -26,69 +27,99 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
 }
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Binary(
-        Spanned {
-            node: op @ (BinOpKind::Add | BinOpKind::Sub),
-            ..
-        },
-        lhs,
-        rhs,
-    ) = &expr.kind
+    let (is_assign, op, lhs, rhs) = match &expr.kind {
+        ExprKind::AssignOp(
+            Spanned {
+                node: AssignOpKind::AddAssign,
+                ..
+            },
+            lhs,
+            rhs,
+        ) => (true, BinOpKind::Add, lhs, rhs),
+        ExprKind::AssignOp(
+            Spanned {
+                node: AssignOpKind::SubAssign,
+                ..
+            },
+            lhs,
+            rhs,
+        ) => (true, BinOpKind::Sub, lhs, rhs),
+        ExprKind::Binary(
+            Spanned {
+                node: op @ (BinOpKind::Add | BinOpKind::Sub),
+                ..
+            },
+            lhs,
+            rhs,
+        ) => (false, *op, lhs, rhs),
+        _ => return,
+    };
+
+    if !is_assign
+        && let Some(parent) = get_parent_expr(cx, expr)
+        && let ExprKind::MethodCall(PathSegment { ident: method, .. }, receiver, ..) = parent.kind
+        && method.name == sym::sqrt
+        // we don't care about the applicability as this is an early-return condition
+        && super::hypot::detect(cx, receiver, &mut Applicability::Unspecified).is_some()
     {
-        if let Some(parent) = get_parent_expr(cx, expr)
-            && let ExprKind::MethodCall(PathSegment { ident: method, .. }, receiver, ..) = parent.kind
-            && method.name == sym::sqrt
-            // we don't care about the applicability as this is an early-return condition
-            && super::hypot::detect(cx, receiver, &mut Applicability::Unspecified).is_some()
-        {
-            return;
-        }
-
-        let maybe_neg_sugg = |expr, app: &mut _| {
-            let sugg = Sugg::hir_with_applicability(cx, expr, "_", app);
-            if let BinOpKind::Sub = op { -sugg } else { sugg }
-        };
-
-        let mut app = Applicability::MachineApplicable;
-        let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs)
-            && cx.typeck_results().expr_ty(rhs).is_floating_point()
-        {
-            (
-                inner_lhs,
-                Sugg::hir_with_applicability(cx, inner_rhs, "_", &mut app),
-                maybe_neg_sugg(rhs, &mut app),
-            )
-        } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs)
-            && cx.typeck_results().expr_ty(lhs).is_floating_point()
-        {
-            (
-                inner_lhs,
-                maybe_neg_sugg(inner_rhs, &mut app),
-                Sugg::hir_with_applicability(cx, lhs, "_", &mut app),
-            )
-        } else {
-            return;
-        };
-
-        // Check if any variable in the expression has an ambiguous type (could be f32 or f64)
-        // see: https://github.com/rust-lang/rust-clippy/issues/14897
-        if (matches!(recv.kind, ExprKind::Path(_)) || matches!(recv.kind, ExprKind::Call(_, _)))
-            && has_ambiguous_literal_in_expr(cx, recv)
-        {
-            return;
-        }
-
-        span_lint_and_sugg(
-            cx,
-            SUBOPTIMAL_FLOPS,
-            expr.span,
-            "multiply and add expressions can be calculated more efficiently and accurately",
-            "consider using",
-            format!(
-                "{}.mul_add({arg1}, {arg2})",
-                super::lib::prepare_receiver_sugg(cx, recv, &mut app)
-            ),
-            app,
-        );
+        return;
     }
+
+    // Check if any variable in the expression has an ambiguous type (could be f32 or f64)
+    // see: https://github.com/rust-lang/rust-clippy/issues/14897
+    let has_ambiguous_type = |expr: &Expr<'_>| {
+        (matches!(expr.kind, ExprKind::Path(_)) || matches!(expr.kind, ExprKind::Call(_, _)))
+            && has_ambiguous_literal_in_expr(cx, expr)
+    };
+
+    let (recv, arg1, arg2, is_from_rhs) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs)
+        && cx.typeck_results().expr_ty(lhs).is_floating_point()
+        && !has_ambiguous_type(inner_lhs)
+    {
+        (inner_lhs, inner_rhs, lhs, true)
+    } else if !is_assign
+        && let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs)
+        && cx.typeck_results().expr_ty(rhs).is_floating_point()
+        && !has_ambiguous_type(inner_lhs)
+    {
+        (inner_lhs, inner_rhs, rhs, false)
+    } else {
+        return;
+    };
+
+    span_lint_and_then(
+        cx,
+        SUBOPTIMAL_FLOPS,
+        expr.span,
+        "multiply and add expressions can be calculated more efficiently and accurately",
+        |diag| {
+            let maybe_neg_sugg = |expr, app: &mut _| {
+                let sugg = Sugg::hir_with_applicability(cx, expr, "_", app);
+                if let BinOpKind::Sub = op { -sugg } else { sugg }
+            };
+            let mut app = Applicability::MachineApplicable;
+            let recv_sugg = super::lib::prepare_receiver_sugg(cx, recv, &mut app);
+            let (arg1, arg2) = if is_from_rhs {
+                (
+                    maybe_neg_sugg(arg1, &mut app),
+                    Sugg::hir_with_applicability(cx, arg2, "_", &mut app),
+                )
+            } else {
+                (
+                    Sugg::hir_with_applicability(cx, arg1, "_", &mut app),
+                    maybe_neg_sugg(arg2, &mut app),
+                )
+            };
+            diag.span_suggestion(
+                expr.span,
+                "consider using",
+                if is_assign {
+                    format!("{arg2} = {recv_sugg}.mul_add({arg1}, {arg2})")
+                } else {
+                    format!("{recv_sugg}.mul_add({arg1}, {arg2})")
+                },
+                app,
+            );
+        },
+    );
 }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 098bf4ba42f9..486fdb8a2bb8 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -39,6 +39,8 @@
     "useless use of `format!`"
 }
 
+impl_lint_pass!(UselessFormat => [USELESS_FORMAT]);
+
 pub struct UselessFormat {
     format_args: FormatArgsStorage,
 }
@@ -49,8 +51,6 @@ pub fn new(format_args: FormatArgsStorage) -> Self {
     }
 }
 
-impl_lint_pass!(UselessFormat => [USELESS_FORMAT]);
-
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr)
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index d987a76f5394..12cf82916739 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -58,32 +58,30 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Debug` formatting (`{:?}`) applied to an `OsStr` or `Path`.
+    /// Detects [pointer format] as well as `Debug` formatting of raw pointers or function pointers
+    /// or any types that have a derived `Debug` impl that recursively contains them.
     ///
-    /// ### Why is this bad?
-    /// Rust doesn't guarantee what `Debug` formatting looks like, and it could
-    /// change in the future. `OsStr`s and `Path`s can be `Display` formatted
-    /// using their `display` methods.
+    /// ### Why restrict this?
+    /// The addresses are only useful in very specific contexts, and certain projects may want to keep addresses of
+    /// certain data structures or functions from prying hacker eyes as an additional line of security.
     ///
-    /// Furthermore, with `Debug` formatting, certain characters are escaped.
-    /// Thus, a `Debug` formatted `Path` is less likely to be clickable.
+    /// ### Known problems
+    /// The lint currently only looks through derived `Debug` implementations. Checking whether a manual
+    /// implementation prints an address is left as an exercise to the next lint implementer.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::path::Path;
-    /// let path = Path::new("...");
-    /// println!("The path is {:?}", path);
+    /// let foo = &0_u32;
+    /// fn bar() {}
+    /// println!("{:p}", foo);
+    /// let _ = format!("{:?}", &(bar as fn()));
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::path::Path;
-    /// let path = Path::new("…");
-    /// println!("The path is {}", path.display());
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub UNNECESSARY_DEBUG_FORMATTING,
-    pedantic,
-    "`Debug` formatting applied to an `OsStr` or `Path` when `.display()` is available"
+    ///
+    /// [pointer format]: https://doc.rust-lang.org/std/fmt/index.html#formatting-traits
+    #[clippy::version = "1.89.0"]
+    pub POINTER_FORMAT,
+    restriction,
+    "formatting a pointer"
 }
 
 declare_clippy_lint! {
@@ -171,61 +169,32 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects [formatting parameters] that have no effect on the output of
-    /// `format!()`, `println!()` or similar macros.
+    /// Checks for `Debug` formatting (`{:?}`) applied to an `OsStr` or `Path`.
     ///
     /// ### Why is this bad?
-    /// Shorter format specifiers are easier to read, it may also indicate that
-    /// an expected formatting operation such as adding padding isn't happening.
+    /// Rust doesn't guarantee what `Debug` formatting looks like, and it could
+    /// change in the future. `OsStr`s and `Path`s can be `Display` formatted
+    /// using their `display` methods.
+    ///
+    /// Furthermore, with `Debug` formatting, certain characters are escaped.
+    /// Thus, a `Debug` formatted `Path` is less likely to be clickable.
     ///
     /// ### Example
     /// ```no_run
-    /// println!("{:.}", 1.0);
-    ///
-    /// println!("not padded: {:5}", format_args!("..."));
+    /// # use std::path::Path;
+    /// let path = Path::new("...");
+    /// println!("The path is {:?}", path);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// println!("{}", 1.0);
-    ///
-    /// println!("not padded: {}", format_args!("..."));
-    /// // OR
-    /// println!("padded: {:5}", format!("..."));
+    /// # use std::path::Path;
+    /// let path = Path::new("…");
+    /// println!("The path is {}", path.display());
     /// ```
-    ///
-    /// [formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
-    #[clippy::version = "1.66.0"]
-    pub UNUSED_FORMAT_SPECS,
-    complexity,
-    "use of a format specifier that has no effect"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects [pointer format] as well as `Debug` formatting of raw pointers or function pointers
-    /// or any types that have a derived `Debug` impl that recursively contains them.
-    ///
-    /// ### Why restrict this?
-    /// The addresses are only useful in very specific contexts, and certain projects may want to keep addresses of
-    /// certain data structures or functions from prying hacker eyes as an additional line of security.
-    ///
-    /// ### Known problems
-    /// The lint currently only looks through derived `Debug` implementations. Checking whether a manual
-    /// implementation prints an address is left as an exercise to the next lint implementer.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let foo = &0_u32;
-    /// fn bar() {}
-    /// println!("{:p}", foo);
-    /// let _ = format!("{:?}", &(bar as fn()));
-    /// ```
-    ///
-    /// [pointer format]: https://doc.rust-lang.org/std/fmt/index.html#formatting-traits
-    #[clippy::version = "1.89.0"]
-    pub POINTER_FORMAT,
-    restriction,
-    "formatting a pointer"
+    #[clippy::version = "1.87.0"]
+    pub UNNECESSARY_DEBUG_FORMATTING,
+    pedantic,
+    "`Debug` formatting applied to an `OsStr` or `Path` when `.display()` is available"
 }
 
 declare_clippy_lint! {
@@ -257,14 +226,45 @@
     "unnecessary trailing comma before closing parenthesis"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects [formatting parameters] that have no effect on the output of
+    /// `format!()`, `println!()` or similar macros.
+    ///
+    /// ### Why is this bad?
+    /// Shorter format specifiers are easier to read, it may also indicate that
+    /// an expected formatting operation such as adding padding isn't happening.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// println!("{:.}", 1.0);
+    ///
+    /// println!("not padded: {:5}", format_args!("..."));
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// println!("{}", 1.0);
+    ///
+    /// println!("not padded: {}", format_args!("..."));
+    /// // OR
+    /// println!("padded: {:5}", format!("..."));
+    /// ```
+    ///
+    /// [formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
+    #[clippy::version = "1.66.0"]
+    pub UNUSED_FORMAT_SPECS,
+    complexity,
+    "use of a format specifier that has no effect"
+}
+
 impl_lint_pass!(FormatArgs<'_> => [
     FORMAT_IN_FORMAT_ARGS,
+    POINTER_FORMAT,
     TO_STRING_IN_FORMAT_ARGS,
     UNINLINED_FORMAT_ARGS,
     UNNECESSARY_DEBUG_FORMATTING,
-    UNUSED_FORMAT_SPECS,
-    POINTER_FORMAT,
     UNNECESSARY_TRAILING_COMMA,
+    UNUSED_FORMAT_SPECS,
 ]);
 
 #[expect(clippy::struct_field_names)]
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 903d43e56c4b..4d0a324a2a39 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -10,45 +10,6 @@
 use rustc_span::Symbol;
 use rustc_span::symbol::kw;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
-    /// which uses `self` as a parameter.
-    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
-    ///
-    /// ### Why is this bad?
-    /// This will lead to infinite recursion and a stack overflow.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.to_string())
-    ///     }
-    /// }
-    ///
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.0)
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub RECURSIVE_FORMAT_IMPL,
-    correctness,
-    "Format trait method called while implementing the same Format trait"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `println`, `print`, `eprintln` or `eprint` in an
@@ -90,6 +51,47 @@
     "use of a print macro in a formatting trait impl"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
+    /// which uses `self` as a parameter.
+    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
+    ///
+    /// ### Why is this bad?
+    /// This will lead to infinite recursion and a stack overflow.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.to_string())
+    ///     }
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.0)
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub RECURSIVE_FORMAT_IMPL,
+    correctness,
+    "Format trait method called while implementing the same Format trait"
+}
+
+impl_lint_pass!(FormatImpl => [PRINT_IN_FORMAT_IMPL, RECURSIVE_FORMAT_IMPL]);
+
 #[derive(Clone, Copy)]
 struct FormatTraitNames {
     /// e.g. `sym::Display`
@@ -113,8 +115,6 @@ pub fn new(format_args: FormatArgsStorage) -> Self {
     }
 }
 
-impl_lint_pass!(FormatImpl => [RECURSIVE_FORMAT_IMPL, PRINT_IN_FORMAT_IMPL]);
-
 impl<'tcx> LateLintPass<'tcx> for FormatImpl {
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
         self.format_trait_impl = is_format_trait_impl(cx, impl_item);
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 3e3cd0a77899..d5a7cffe9e6c 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -41,6 +41,7 @@
     pedantic,
     "`format!(..)` appended to existing `String`"
 }
+
 impl_lint_pass!(FormatPushString => [FORMAT_PUSH_STRING]);
 
 pub(crate) struct FormatPushString {
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 7a64d3135fa5..87e290cf0357 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -6,6 +6,52 @@
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for possible missing comma in an array. It lints if
+    /// an array element is a binary operator expression and it lies on two lines.
+    ///
+    /// ### Why is this bad?
+    /// This could lead to unexpected results.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let a = &[
+    ///     -1, -2, -3 // <= no comma here
+    ///     -4, -5, -6
+    /// ];
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub POSSIBLE_MISSING_COMMA,
+    correctness,
+    "possible missing comma in array"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an `if` expression followed by either a block or another `if` that
+    /// looks like it should have an `else` between them.
+    ///
+    /// ### Why is this bad?
+    /// This is probably some refactoring remnant, even if the code is correct, it
+    /// might look confusing.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if foo {
+    /// } { // looks like an `else` is missing here
+    /// }
+    ///
+    /// if foo {
+    /// } if bar { // looks like an `else` is missing here
+    /// }
+    /// ```
+    #[clippy::version = "1.91.0"]
+    pub POSSIBLE_MISSING_ELSE,
+    suspicious,
+    "possibly missing `else`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of the non-existent `=*`, `=!` and `=-`
@@ -25,35 +71,6 @@
     "suspicious formatting of `*=`, `-=` or `!=`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the formatting of a unary operator on the right hand side
-    /// of a binary operator. It lints if there is no space between the binary and unary operators,
-    /// but there is a space between the unary and its operand.
-    ///
-    /// ### Why is this bad?
-    /// This is either a typo in the binary operator or confusing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let foo = true;
-    /// # let bar = false;
-    /// // &&! looks like a different operator
-    /// if foo &&! bar {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let foo = true;
-    /// # let bar = false;
-    /// if foo && !bar {}
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub SUSPICIOUS_UNARY_OP_FORMATTING,
-    suspicious,
-    "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for formatting of `else`. It lints if the `else`
@@ -93,56 +110,39 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for an `if` expression followed by either a block or another `if` that
-    /// looks like it should have an `else` between them.
+    /// Checks the formatting of a unary operator on the right hand side
+    /// of a binary operator. It lints if there is no space between the binary and unary operators,
+    /// but there is a space between the unary and its operand.
     ///
     /// ### Why is this bad?
-    /// This is probably some refactoring remnant, even if the code is correct, it
-    /// might look confusing.
+    /// This is either a typo in the binary operator or confusing.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// if foo {
-    /// } { // looks like an `else` is missing here
-    /// }
-    ///
-    /// if foo {
-    /// } if bar { // looks like an `else` is missing here
-    /// }
+    /// ```no_run
+    /// # let foo = true;
+    /// # let bar = false;
+    /// // &&! looks like a different operator
+    /// if foo &&! bar {}
     /// ```
-    #[clippy::version = "1.91.0"]
-    pub POSSIBLE_MISSING_ELSE,
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let foo = true;
+    /// # let bar = false;
+    /// if foo && !bar {}
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub SUSPICIOUS_UNARY_OP_FORMATTING,
     suspicious,
-    "possibly missing `else`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for possible missing comma in an array. It lints if
-    /// an array element is a binary operator expression and it lies on two lines.
-    ///
-    /// ### Why is this bad?
-    /// This could lead to unexpected results.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let a = &[
-    ///     -1, -2, -3 // <= no comma here
-    ///     -4, -5, -6
-    /// ];
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub POSSIBLE_MISSING_COMMA,
-    correctness,
-    "possible missing comma in array"
+    "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
 }
 
 declare_lint_pass!(Formatting => [
-    SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    SUSPICIOUS_UNARY_OP_FORMATTING,
-    SUSPICIOUS_ELSE_FORMATTING,
+    POSSIBLE_MISSING_COMMA,
     POSSIBLE_MISSING_ELSE,
-    POSSIBLE_MISSING_COMMA
+    SUSPICIOUS_ASSIGNMENT_FORMATTING,
+    SUSPICIOUS_ELSE_FORMATTING,
+    SUSPICIOUS_UNARY_OP_FORMATTING,
 ]);
 
 impl EarlyLintPass for Formatting {
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 5a0cee40a155..57c1dd2eb72b 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -35,6 +35,7 @@
     suspicious,
     "comments with 4 forward slashes (`////`) likely intended to be doc comments (`///`)"
 }
+
 declare_lint_pass!(FourForwardSlashes => [FOUR_FORWARD_SLASHES]);
 
 impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index ed55f90848f8..841d561b371c 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -52,6 +52,8 @@
     "Warns on implementations of `Into<..>` to use `From<..>`"
 }
 
+impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
+
 pub struct FromOverInto {
     msrv: Msrv,
 }
@@ -62,8 +64,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
-
 impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 0e6eeb75ec57..5c6d6607a0aa 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -35,6 +35,7 @@
     suspicious,
     "creating a `Box` from a void raw pointer"
 }
+
 declare_lint_pass!(FromRawWithVoidPtr => [FROM_RAW_WITH_VOID_PTR]);
 
 impl LateLintPass<'_> for FromRawWithVoidPtr {
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 9a7427ea1447..7c5fd760a7da 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -21,6 +21,30 @@
 use rustc_span::Span;
 use rustc_span::def_id::{DefIdSet, LocalDefId};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a `#[must_use]` attribute without
+    /// further information on functions and methods that return a type already
+    /// marked as `#[must_use]`.
+    ///
+    /// ### Why is this bad?
+    /// The attribute isn't needed. Not using the result
+    /// will already be reported. Alternatively, one can add some text to the
+    /// attribute to improve the lint message.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// #[must_use]
+    /// fn double_must_use() -> Result<(), ()> {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub DOUBLE_MUST_USE,
+    style,
+    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for function arguments having the similar names
@@ -46,48 +70,122 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions with too many parameters.
+    /// Lints when `impl Trait` is being used in a function's parameters.
     ///
-    /// ### Why is this bad?
-    /// Functions with lots of parameters are considered bad
-    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
-    /// grouping some parameters into a new type.
+    /// ### Why restrict this?
+    /// Turbofish syntax (`::<>`) cannot be used to specify the type of an `impl Trait` parameter,
+    /// making `impl Trait` less powerful. Readability may also be a factor.
     ///
     /// ### Example
     /// ```no_run
-    /// # struct Color;
-    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
-    ///     // ..
+    /// trait MyTrait {}
+    /// fn foo(a: impl MyTrait) {
+    /// 	// [...]
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TOO_MANY_ARGUMENTS,
-    complexity,
-    "functions with too many arguments"
+    /// Use instead:
+    /// ```no_run
+    /// trait MyTrait {}
+    /// fn foo<T: MyTrait>(a: T) {
+    /// 	// [...]
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub IMPL_TRAIT_IN_PARAMS,
+    restriction,
+    "`impl Trait` is used in the function's parameters"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions with a large amount of lines.
+    /// Checks for getter methods that return a field that doesn't correspond
+    /// to the name of the method, when there is a field's whose name matches that of the method.
     ///
     /// ### Why is this bad?
-    /// Functions with a lot of lines are harder to understand
-    /// due to having to look at a larger amount of code to understand what the
-    /// function is doing. Consider splitting the body of the function into
-    /// multiple functions.
+    /// It is most likely that such a method is a bug caused by a typo or by copy-pasting.
     ///
     /// ### Example
+
     /// ```no_run
-    /// fn im_too_long() {
-    ///     println!("");
-    ///     // ... 100 more LoC
-    ///     println!("");
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         &self.b
+    ///     }
+    /// }
+
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         &self.a
+    ///     }
     /// }
     /// ```
-    #[clippy::version = "1.34.0"]
-    pub TOO_MANY_LINES,
+    #[clippy::version = "1.67.0"]
+    pub MISNAMED_GETTERS,
+    suspicious,
+    "getter method returning the wrong field"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for public functions that have no
+    /// `#[must_use]` attribute, but return something not already marked
+    /// must-use, have no mutable arg and mutate no statics.
+    ///
+    /// ### Why is this bad?
+    /// Not bad at all, this lint just shows places where
+    /// you could add the attribute.
+    ///
+    /// ### Known problems
+    /// The lint only checks the arguments for mutable
+    /// types without looking if they are actually changed. On the other hand,
+    /// it also ignores a broad range of potentially interesting side effects,
+    /// because we cannot decide whether the programmer intends the function to
+    /// be called for the side effect or the result. Expect many false
+    /// positives. At least we don't lint if the result type is unit or already
+    /// `#[must_use]`.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// // this could be annotated with `#[must_use]`.
+    /// pub fn id<T>(t: T) -> T { t }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub MUST_USE_CANDIDATE,
     pedantic,
-    "functions with too many lines"
+    "function or method that could take a `#[must_use]` attribute"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a `#[must_use]` attribute on
+    /// unit-returning functions and methods.
+    ///
+    /// ### Why is this bad?
+    /// Unit values are useless. The attribute is likely
+    /// a remnant of a refactoring that removed the return type.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// #[must_use]
+    /// fn useless() { }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub MUST_USE_UNIT,
+    style,
+    "`#[must_use]` attribute on a unit-returning function / method"
 }
 
 declare_clippy_lint! {
@@ -152,76 +250,131 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a `#[must_use]` attribute on
-    /// unit-returning functions and methods.
+    /// Warns when a function signature uses `&Option<T>` instead of `Option<&T>`.
     ///
     /// ### Why is this bad?
-    /// Unit values are useless. The attribute is likely
-    /// a remnant of a refactoring that removed the return type.
+    /// More flexibility, better memory optimization, and more idiomatic Rust code.
     ///
-    /// ### Examples
-    /// ```no_run
-    /// #[must_use]
-    /// fn useless() { }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub MUST_USE_UNIT,
-    style,
-    "`#[must_use]` attribute on a unit-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for a `#[must_use]` attribute without
-    /// further information on functions and methods that return a type already
-    /// marked as `#[must_use]`.
+    /// `&Option<T>` in a function signature breaks encapsulation because the caller must own T
+    /// and move it into an Option to call with it. When returned, the owner must internally store
+    /// it as `Option<T>` in order to return it.
+    /// At a lower level, `&Option<T>` points to memory with the `presence` bit flag plus the `T` value,
+    /// whereas `Option<&T>` is usually [optimized](https://doc.rust-lang.org/1.81.0/std/option/index.html#representation)
+    /// to a single pointer, so it may be more optimal.
     ///
-    /// ### Why is this bad?
-    /// The attribute isn't needed. Not using the result
-    /// will already be reported. Alternatively, one can add some text to the
-    /// attribute to improve the lint message.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// #[must_use]
-    /// fn double_must_use() -> Result<(), ()> {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub DOUBLE_MUST_USE,
-    style,
-    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for public functions that have no
-    /// `#[must_use]` attribute, but return something not already marked
-    /// must-use, have no mutable arg and mutate no statics.
-    ///
-    /// ### Why is this bad?
-    /// Not bad at all, this lint just shows places where
-    /// you could add the attribute.
+    /// See this [YouTube video](https://www.youtube.com/watch?v=6c7pZYP_iIE) by
+    /// Logan Smith for an in-depth explanation of why this is important.
     ///
     /// ### Known problems
-    /// The lint only checks the arguments for mutable
-    /// types without looking if they are actually changed. On the other hand,
-    /// it also ignores a broad range of potentially interesting side effects,
-    /// because we cannot decide whether the programmer intends the function to
-    /// be called for the side effect or the result. Expect many false
-    /// positives. At least we don't lint if the result type is unit or already
-    /// `#[must_use]`.
+    /// This lint recommends changing the function signatures, but it cannot
+    /// automatically change the function calls or the function implementations.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // caller uses  foo(&opt)
+    /// fn foo(a: &Option<String>) {}
+    /// # struct Unit {}
+    /// # impl Unit {
+    /// fn bar(&self) -> &Option<String> { &None }
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // caller should use  `foo1(opt.as_ref())`
+    /// fn foo1(a: Option<&String>) {}
+    /// // better yet, use string slice  `foo2(opt.as_deref())`
+    /// fn foo2(a: Option<&str>) {}
+    /// # struct Unit {}
+    /// # impl Unit {
+    /// fn bar(&self) -> Option<&String> { None }
+    /// # }
+    /// ```
+    #[clippy::version = "1.83.0"]
+    pub REF_OPTION,
+    pedantic,
+    "function signature uses `&Option<T>` instead of `Option<&T>`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints when the name of function parameters from trait impl is
+    /// different than its default implementation.
+    ///
+    /// ### Why restrict this?
+    /// Using the default name for parameters of a trait method is more consistent.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct A(u32);
+    ///
+    /// impl PartialEq for A {
+    ///     fn eq(&self, b: &Self) -> bool {
+    ///         self.0 == b.0
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct A(u32);
+    ///
+    /// impl PartialEq for A {
+    ///     fn eq(&self, other: &Self) -> bool {
+    ///         self.0 == other.0
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.80.0"]
+    pub RENAMED_FUNCTION_PARAMS,
+    restriction,
+    "renamed function parameters in trait implementation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions that return `Result` with an unusually large
+    /// `Err`-variant.
+    ///
+    /// ### Why is this bad?
+    /// A `Result` is at least as large as the `Err`-variant. While we
+    /// expect that variant to be seldom used, the compiler needs to reserve
+    /// and move that much memory every single time.
+    /// Furthermore, errors are often simply passed up the call-stack, making
+    /// use of the `?`-operator and its type-conversion mechanics. If the
+    /// `Err`-variant further up the call-stack stores the `Err`-variant in
+    /// question (as library code often does), it itself needs to be at least
+    /// as large, propagating the problem.
+    ///
+    /// ### Known problems
+    /// The size determined by Clippy is platform-dependent.
     ///
     /// ### Examples
     /// ```no_run
-    /// // this could be annotated with `#[must_use]`.
-    /// pub fn id<T>(t: T) -> T { t }
+    /// pub enum ParseError {
+    ///     UnparsedBytes([u8; 512]),
+    ///     UnexpectedEof,
+    /// }
+    ///
+    /// // The `Result` has at least 512 bytes, even in the `Ok`-case
+    /// pub fn parse() -> Result<(), ParseError> {
+    ///     Ok(())
+    /// }
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub MUST_USE_CANDIDATE,
-    pedantic,
-    "function or method that could take a `#[must_use]` attribute"
+    /// should be
+    /// ```no_run
+    /// pub enum ParseError {
+    ///     UnparsedBytes(Box<[u8; 512]>),
+    ///     UnexpectedEof,
+    /// }
+    ///
+    /// // The `Result` is slightly larger than a pointer
+    /// pub fn parse() -> Result<(), ParseError> {
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub RESULT_LARGE_ERR,
+    perf,
+    "function returning `Result` with large `Err` type"
 }
 
 declare_clippy_lint! {
@@ -276,205 +429,67 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions that return `Result` with an unusually large
-    /// `Err`-variant.
+    /// Checks for functions with too many parameters.
     ///
     /// ### Why is this bad?
-    /// A `Result` is at least as large as the `Err`-variant. While we
-    /// expect that variant to be seldom used, the compiler needs to reserve
-    /// and move that much memory every single time.
-    /// Furthermore, errors are often simply passed up the call-stack, making
-    /// use of the `?`-operator and its type-conversion mechanics. If the
-    /// `Err`-variant further up the call-stack stores the `Err`-variant in
-    /// question (as library code often does), it itself needs to be at least
-    /// as large, propagating the problem.
+    /// Functions with lots of parameters are considered bad
+    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
+    /// grouping some parameters into a new type.
     ///
-    /// ### Known problems
-    /// The size determined by Clippy is platform-dependent.
-    ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// pub enum ParseError {
-    ///     UnparsedBytes([u8; 512]),
-    ///     UnexpectedEof,
-    /// }
-    ///
-    /// // The `Result` has at least 512 bytes, even in the `Ok`-case
-    /// pub fn parse() -> Result<(), ParseError> {
-    ///     Ok(())
+    /// # struct Color;
+    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
+    ///     // ..
     /// }
     /// ```
-    /// should be
-    /// ```no_run
-    /// pub enum ParseError {
-    ///     UnparsedBytes(Box<[u8; 512]>),
-    ///     UnexpectedEof,
-    /// }
-    ///
-    /// // The `Result` is slightly larger than a pointer
-    /// pub fn parse() -> Result<(), ParseError> {
-    ///     Ok(())
-    /// }
-    /// ```
-    #[clippy::version = "1.65.0"]
-    pub RESULT_LARGE_ERR,
-    perf,
-    "function returning `Result` with large `Err` type"
+    #[clippy::version = "pre 1.29.0"]
+    pub TOO_MANY_ARGUMENTS,
+    complexity,
+    "functions with too many arguments"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for getter methods that return a field that doesn't correspond
-    /// to the name of the method, when there is a field's whose name matches that of the method.
+    /// Checks for functions with a large amount of lines.
     ///
     /// ### Why is this bad?
-    /// It is most likely that such a method is a bug caused by a typo or by copy-pasting.
-    ///
-    /// ### Example
-
-    /// ```no_run
-    /// struct A {
-    ///     a: String,
-    ///     b: String,
-    /// }
-    ///
-    /// impl A {
-    ///     fn a(&self) -> &str{
-    ///         &self.b
-    ///     }
-    /// }
-
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// struct A {
-    ///     a: String,
-    ///     b: String,
-    /// }
-    ///
-    /// impl A {
-    ///     fn a(&self) -> &str{
-    ///         &self.a
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.67.0"]
-    pub MISNAMED_GETTERS,
-    suspicious,
-    "getter method returning the wrong field"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints when `impl Trait` is being used in a function's parameters.
-    ///
-    /// ### Why restrict this?
-    /// Turbofish syntax (`::<>`) cannot be used to specify the type of an `impl Trait` parameter,
-    /// making `impl Trait` less powerful. Readability may also be a factor.
+    /// Functions with a lot of lines are harder to understand
+    /// due to having to look at a larger amount of code to understand what the
+    /// function is doing. Consider splitting the body of the function into
+    /// multiple functions.
     ///
     /// ### Example
     /// ```no_run
-    /// trait MyTrait {}
-    /// fn foo(a: impl MyTrait) {
-    /// 	// [...]
+    /// fn im_too_long() {
+    ///     println!("");
+    ///     // ... 100 more LoC
+    ///     println!("");
     /// }
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// trait MyTrait {}
-    /// fn foo<T: MyTrait>(a: T) {
-    /// 	// [...]
-    /// }
-    /// ```
-    #[clippy::version = "1.69.0"]
-    pub IMPL_TRAIT_IN_PARAMS,
-    restriction,
-    "`impl Trait` is used in the function's parameters"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints when the name of function parameters from trait impl is
-    /// different than its default implementation.
-    ///
-    /// ### Why restrict this?
-    /// Using the default name for parameters of a trait method is more consistent.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct A(u32);
-    ///
-    /// impl PartialEq for A {
-    ///     fn eq(&self, b: &Self) -> bool {
-    ///         self.0 == b.0
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// struct A(u32);
-    ///
-    /// impl PartialEq for A {
-    ///     fn eq(&self, other: &Self) -> bool {
-    ///         self.0 == other.0
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.80.0"]
-    pub RENAMED_FUNCTION_PARAMS,
-    restriction,
-    "renamed function parameters in trait implementation"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns when a function signature uses `&Option<T>` instead of `Option<&T>`.
-    ///
-    /// ### Why is this bad?
-    /// More flexibility, better memory optimization, and more idiomatic Rust code.
-    ///
-    /// `&Option<T>` in a function signature breaks encapsulation because the caller must own T
-    /// and move it into an Option to call with it. When returned, the owner must internally store
-    /// it as `Option<T>` in order to return it.
-    /// At a lower level, `&Option<T>` points to memory with the `presence` bit flag plus the `T` value,
-    /// whereas `Option<&T>` is usually [optimized](https://doc.rust-lang.org/1.81.0/std/option/index.html#representation)
-    /// to a single pointer, so it may be more optimal.
-    ///
-    /// See this [YouTube video](https://www.youtube.com/watch?v=6c7pZYP_iIE) by
-    /// Logan Smith for an in-depth explanation of why this is important.
-    ///
-    /// ### Known problems
-    /// This lint recommends changing the function signatures, but it cannot
-    /// automatically change the function calls or the function implementations.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // caller uses  foo(&opt)
-    /// fn foo(a: &Option<String>) {}
-    /// # struct Unit {}
-    /// # impl Unit {
-    /// fn bar(&self) -> &Option<String> { &None }
-    /// # }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// // caller should use  `foo1(opt.as_ref())`
-    /// fn foo1(a: Option<&String>) {}
-    /// // better yet, use string slice  `foo2(opt.as_deref())`
-    /// fn foo2(a: Option<&str>) {}
-    /// # struct Unit {}
-    /// # impl Unit {
-    /// fn bar(&self) -> Option<&String> { None }
-    /// # }
-    /// ```
-    #[clippy::version = "1.83.0"]
-    pub REF_OPTION,
+    #[clippy::version = "1.34.0"]
+    pub TOO_MANY_LINES,
     pedantic,
-    "function signature uses `&Option<T>` instead of `Option<&T>`"
+    "functions with too many lines"
 }
 
 declare_lint_pass!(EarlyFunctions => [DUPLICATE_UNDERSCORE_ARGUMENT]);
 
+impl_lint_pass!(Functions => [
+    DOUBLE_MUST_USE,
+    IMPL_TRAIT_IN_PARAMS,
+    MISNAMED_GETTERS,
+    MUST_USE_CANDIDATE,
+    MUST_USE_UNIT,
+    NOT_UNSAFE_PTR_ARG_DEREF,
+    REF_OPTION,
+    RENAMED_FUNCTION_PARAMS,
+    RESULT_LARGE_ERR,
+    RESULT_UNIT_ERR,
+    TOO_MANY_ARGUMENTS,
+    TOO_MANY_LINES,
+]);
+
 impl EarlyLintPass for EarlyFunctions {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: visit::FnKind<'_>, _: Span, _: ast::NodeId) {
         duplicate_underscore_argument::check(cx, fn_kind);
@@ -515,21 +530,6 @@ pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Functions => [
-    TOO_MANY_ARGUMENTS,
-    TOO_MANY_LINES,
-    NOT_UNSAFE_PTR_ARG_DEREF,
-    MUST_USE_UNIT,
-    DOUBLE_MUST_USE,
-    MUST_USE_CANDIDATE,
-    RESULT_UNIT_ERR,
-    RESULT_LARGE_ERR,
-    MISNAMED_GETTERS,
-    IMPL_TRAIT_IN_PARAMS,
-    RENAMED_FUNCTION_PARAMS,
-    REF_OPTION,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Functions {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 15f34169b0d8..04c657104fe1 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -217,7 +217,7 @@ fn check_must_use_candidate<'tcx>(
         diag.span_suggestion(
             item_span.shrink_to_lo(),
             "add the attribute",
-            format!("#[must_use] \n{indent}"),
+            format!("#[must_use]\n{indent}"),
             Applicability::MachineApplicable,
         );
         if let Some(msg) = match return_ty(cx, item_id).opt_diag_name(cx) {
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 9e5e4fa58d2f..2d5ccc0b82b7 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -50,6 +50,8 @@
     "Finds if-else that could be written using either `bool::then` or `bool::then_some`"
 }
 
+impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
+
 pub struct IfThenSomeElseNone {
     msrv: Msrv,
 }
@@ -60,8 +62,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
-
 impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let Some(higher::If {
diff --git a/clippy_lints/src/ifs/mod.rs b/clippy_lints/src/ifs/mod.rs
index 739f2fc91729..8a22d8935368 100644
--- a/clippy_lints/src/ifs/mod.rs
+++ b/clippy_lints/src/ifs/mod.rs
@@ -11,6 +11,62 @@
 mod ifs_same_cond;
 mod same_functions_in_if_cond;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if the `if` and `else` block contain shared code that can be
+    /// moved out of the blocks.
+    ///
+    /// ### Why is this bad?
+    /// Duplicate code is less maintainable.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let foo = if … {
+    ///     println!("Hello World");
+    ///     13
+    /// } else {
+    ///     println!("Hello World");
+    ///     42
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// println!("Hello World");
+    /// let foo = if … {
+    ///     13
+    /// } else {
+    ///     42
+    /// };
+    /// ```
+    #[clippy::version = "1.53.0"]
+    pub BRANCHES_SHARING_CODE,
+    nursery,
+    "`if` statement with shared code in all blocks"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `if/else` with the same body as the *then* part
+    /// and the *else* part.
+    ///
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let foo = if … {
+    ///     42
+    /// } else {
+    ///     42
+    /// };
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub IF_SAME_THEN_ELSE,
+    style,
+    "`if` with the same `then` and `else` blocks"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for consecutive `if`s with the same condition.
@@ -91,61 +147,12 @@
     "consecutive `if`s with the same function call"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `if/else` with the same body as the *then* part
-    /// and the *else* part.
-    ///
-    /// ### Why is this bad?
-    /// This is probably a copy & paste error.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let foo = if … {
-    ///     42
-    /// } else {
-    ///     42
-    /// };
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub IF_SAME_THEN_ELSE,
-    style,
-    "`if` with the same `then` and `else` blocks"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if the `if` and `else` block contain shared code that can be
-    /// moved out of the blocks.
-    ///
-    /// ### Why is this bad?
-    /// Duplicate code is less maintainable.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let foo = if … {
-    ///     println!("Hello World");
-    ///     13
-    /// } else {
-    ///     println!("Hello World");
-    ///     42
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// println!("Hello World");
-    /// let foo = if … {
-    ///     13
-    /// } else {
-    ///     42
-    /// };
-    /// ```
-    #[clippy::version = "1.53.0"]
-    pub BRANCHES_SHARING_CODE,
-    nursery,
-    "`if` statement with shared code in all blocks"
-}
+impl_lint_pass!(CopyAndPaste<'_> => [
+    BRANCHES_SHARING_CODE,
+    IFS_SAME_COND,
+    IF_SAME_THEN_ELSE,
+    SAME_FUNCTIONS_IN_IF_CONDITION,
+]);
 
 pub struct CopyAndPaste<'tcx> {
     interior_mut: InteriorMut<'tcx>,
@@ -159,13 +166,6 @@ pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(CopyAndPaste<'_> => [
-    IFS_SAME_COND,
-    SAME_FUNCTIONS_IN_IF_CONDITION,
-    IF_SAME_THEN_ELSE,
-    BRANCHES_SHARING_CODE
-]);
-
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index e4ace3bdabf0..cf7b444f6754 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -33,6 +33,7 @@
     pedantic,
     "suggest replacing `_` by `()` in patterns where appropriate"
 }
+
 declare_lint_pass!(IgnoredUnitPatterns => [IGNORED_UNIT_PATTERNS]);
 
 impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
diff --git a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
index f73182d3af0d..dec08d94e89d 100644
--- a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
+++ b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
@@ -69,7 +69,9 @@
     "ensures that the semantics of `Borrow` for `Hash` are satisfied when `Borrow<str>` and `Borrow<[u8]>` are implemented"
 }
 
-declare_lint_pass!(ImplHashWithBorrowStrBytes => [IMPL_HASH_BORROW_WITH_STR_AND_BYTES]);
+declare_lint_pass!(ImplHashWithBorrowStrBytes => [
+    IMPL_HASH_BORROW_WITH_STR_AND_BYTES,
+]);
 
 impl LateLintPass<'_> for ImplHashWithBorrowStrBytes {
     /// We are emitting this lint at the Hash impl of a type that implements all
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 4bf3a390b050..f0a2ad59cd28 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -36,6 +36,7 @@
     style,
     "Perform saturating addition instead of implicitly checking max bound of data type"
 }
+
 declare_lint_pass!(ImplicitSaturatingAdd => [IMPLICIT_SATURATING_ADD]);
 
 impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 516f9e3aa60c..ee3619ea6746 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -79,12 +79,15 @@
     "Check if a variable is smaller than another one and still subtract from it even if smaller"
 }
 
+impl_lint_pass!(ImplicitSaturatingSub => [
+    IMPLICIT_SATURATING_SUB,
+    INVERTED_SATURATING_SUB,
+]);
+
 pub struct ImplicitSaturatingSub {
     msrv: Msrv,
 }
 
-impl_lint_pass!(ImplicitSaturatingSub => [IMPLICIT_SATURATING_SUB, INVERTED_SATURATING_SUB]);
-
 impl ImplicitSaturatingSub {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 6b89abdb0367..780c789d4fe3 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -47,6 +47,7 @@
     complexity,
     "specifying bounds that are implied by other bounds in `impl Trait` type"
 }
+
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
 
 fn emit_lint(
diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index 6ef3459f222c..ad81810b58cb 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -71,6 +71,8 @@
     "ensures that all items used in the crate are available for the current MSRV"
 }
 
+impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
+
 #[derive(Clone, Copy)]
 enum Availability {
     FeatureEnabled,
@@ -113,8 +115,6 @@ pub struct IncompatibleMsrv {
     called_path: Option<HirId>,
 }
 
-impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
-
 impl IncompatibleMsrv {
     pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index e6129757e560..4555af85c2d2 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -64,6 +64,10 @@
     "the order of the field init is inconsistent with the order in the struct definition"
 }
 
+impl_lint_pass!(InconsistentStructConstructor => [
+    INCONSISTENT_STRUCT_CONSTRUCTOR,
+]);
+
 pub struct InconsistentStructConstructor {
     check_inconsistent_struct_field_initializers: bool,
 }
@@ -76,8 +80,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRUCTOR]);
-
 impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         let ExprKind::Struct(_, fields, _) = expr.kind else {
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index e95816353df6..b1f03babb9fa 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -53,6 +53,8 @@
     "avoid indexing on slices which could be destructed"
 }
 
+impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
+
 pub struct IndexRefutableSlice {
     max_suggested_slice: u64,
     msrv: Msrv,
@@ -67,8 +69,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
-
 impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if let Some(IfLet { let_pat, if_then, .. }) = IfLet::hir(cx, expr)
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index e9ddd3ca8ede..e19e02901cae 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -9,36 +9,6 @@
 use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for out of bounds array indexing with a constant
-    /// index.
-    ///
-    /// ### Why is this bad?
-    /// This will always panic at runtime.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// let x = [1, 2, 3, 4];
-    ///
-    /// x[9];
-    /// &x[2..9];
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = [1, 2, 3, 4];
-    /// // Index within bounds
-    ///
-    /// x[0];
-    /// x[3];
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OUT_OF_BOUNDS_INDEXING,
-    correctness,
-    "out of bounds constant indexing"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of indexing or slicing that may panic at runtime.
@@ -92,6 +62,36 @@
     "indexing/slicing usage"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for out of bounds array indexing with a constant
+    /// index.
+    ///
+    /// ### Why is this bad?
+    /// This will always panic at runtime.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// let x = [1, 2, 3, 4];
+    ///
+    /// x[9];
+    /// &x[2..9];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = [1, 2, 3, 4];
+    /// // Index within bounds
+    ///
+    /// x[0];
+    /// x[3];
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OUT_OF_BOUNDS_INDEXING,
+    correctness,
+    "out of bounds constant indexing"
+}
+
 impl_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
 
 pub struct IndexingSlicing {
diff --git a/clippy_lints/src/infallible_try_from.rs b/clippy_lints/src/infallible_try_from.rs
index 36df07a43705..511df733ed91 100644
--- a/clippy_lints/src/infallible_try_from.rs
+++ b/clippy_lints/src/infallible_try_from.rs
@@ -40,6 +40,7 @@
     suspicious,
     "TryFrom with infallible Error type"
 }
+
 declare_lint_pass!(InfallibleTryFrom => [INFALLIBLE_TRY_FROM]);
 
 impl<'tcx> LateLintPass<'tcx> for InfallibleTryFrom {
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index e569a5c7b612..22082646eb31 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -88,7 +88,10 @@
     "type implements inherent method `to_string()`, which gets shadowed by the implementation of the `Display` trait"
 }
 
-declare_lint_pass!(InherentToString => [INHERENT_TO_STRING, INHERENT_TO_STRING_SHADOW_DISPLAY]);
+declare_lint_pass!(InherentToString => [
+    INHERENT_TO_STRING,
+    INHERENT_TO_STRING_SHADOW_DISPLAY,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for InherentToString {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 22767901614e..70df856570b2 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -45,6 +45,37 @@
     "enums where all variants share a prefix/postfix"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for modules that have the same name as their
+    /// parent module
+    ///
+    /// ### Why is this bad?
+    /// A typical beginner mistake is to have `mod foo;` and
+    /// again `mod foo { ..
+    /// }` in `foo.rs`.
+    /// The expectation is that items inside the inner `mod foo { .. }` are then
+    /// available
+    /// through `foo::x`, but they are only available through
+    /// `foo::foo::x`.
+    /// If this is done on purpose, it would be better to choose a more
+    /// representative module name.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// // lib.rs
+    /// mod foo;
+    /// // foo.rs
+    /// mod foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULE_INCEPTION,
+    style,
+    "modules that have the same name as their parent module"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Detects public item names that are prefixed or suffixed by the
@@ -89,36 +120,6 @@
     "type names prefixed/postfixed with their containing module's name"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for modules that have the same name as their
-    /// parent module
-    ///
-    /// ### Why is this bad?
-    /// A typical beginner mistake is to have `mod foo;` and
-    /// again `mod foo { ..
-    /// }` in `foo.rs`.
-    /// The expectation is that items inside the inner `mod foo { .. }` are then
-    /// available
-    /// through `foo::x`, but they are only available through
-    /// `foo::foo::x`.
-    /// If this is done on purpose, it would be better to choose a more
-    /// representative module name.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// // lib.rs
-    /// mod foo;
-    /// // foo.rs
-    /// mod foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MODULE_INCEPTION,
-    style,
-    "modules that have the same name as their parent module"
-}
 declare_clippy_lint! {
     /// ### What it does
     /// Detects struct fields that are prefixed or suffixed
@@ -155,6 +156,13 @@
     "structs where all fields share a prefix/postfix or contain the name of the struct"
 }
 
+impl_lint_pass!(ItemNameRepetitions => [
+    ENUM_VARIANT_NAMES,
+    MODULE_INCEPTION,
+    MODULE_NAME_REPETITIONS,
+    STRUCT_FIELD_NAMES,
+]);
+
 pub struct ItemNameRepetitions {
     /// The module path the lint pass is in.
     modules: Vec<ModInfo>,
@@ -195,13 +203,6 @@ fn is_allowed_prefix(&self, prefix: &str) -> bool {
     }
 }
 
-impl_lint_pass!(ItemNameRepetitions => [
-    ENUM_VARIANT_NAMES,
-    STRUCT_FIELD_NAMES,
-    MODULE_NAME_REPETITIONS,
-    MODULE_INCEPTION
-]);
-
 #[must_use]
 fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
     prefixes.iter().all(|p| p == &"" || p == &"_")
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 645e0f981f27..4e56f9c8472d 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -9,50 +9,6 @@
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.
-    ///
-    /// ### Why is this bad?
-    /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
-    /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
-    ///
-    /// ### Limitations
-    /// This lint focuses on providing an idiomatic API. Therefore, it will only
-    /// lint on types which are accessible outside of the crate. For internal types,
-    /// the `IntoIterator` trait can be implemented on demand if it is actually needed.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct MySlice<'a>(&'a [u8]);
-    /// impl<'a> MySlice<'a> {
-    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
-    ///         self.0.iter()
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// struct MySlice<'a>(&'a [u8]);
-    /// impl<'a> MySlice<'a> {
-    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
-    ///         self.0.iter()
-    ///     }
-    /// }
-    /// impl<'a> IntoIterator for &MySlice<'a> {
-    ///     type Item = &'a u8;
-    ///     type IntoIter = std::slice::Iter<'a, u8>;
-    ///     fn into_iter(self) -> Self::IntoIter {
-    ///         self.iter()
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.75.0"]
-    pub ITER_WITHOUT_INTO_ITER,
-    pedantic,
-    "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// This is the opposite of the `iter_without_into_iter` lint.
@@ -105,7 +61,54 @@
     "implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"
 }
 
-declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER, INTO_ITER_WITHOUT_ITER]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.
+    ///
+    /// ### Why is this bad?
+    /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
+    /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
+    ///
+    /// ### Limitations
+    /// This lint focuses on providing an idiomatic API. Therefore, it will only
+    /// lint on types which are accessible outside of the crate. For internal types,
+    /// the `IntoIterator` trait can be implemented on demand if it is actually needed.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// impl<'a> IntoIterator for &MySlice<'a> {
+    ///     type Item = &'a u8;
+    ///     type IntoIter = std::slice::Iter<'a, u8>;
+    ///     fn into_iter(self) -> Self::IntoIter {
+    ///         self.iter()
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub ITER_WITHOUT_INTO_ITER,
+    pedantic,
+    "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
+}
+
+declare_lint_pass!(IterWithoutIntoIter => [
+    INTO_ITER_WITHOUT_ITER,
+    ITER_WITHOUT_INTO_ITER,
+]);
 
 /// Checks if a given type is nameable in a trait (impl).
 /// RPIT is stable, but impl Trait in traits is not (yet), so when we have
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index cee8ca1261e5..383f2721fad2 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -32,6 +32,8 @@
     "large non-scalar const array may cause performance overhead"
 }
 
+impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
+
 pub struct LargeConstArrays {
     maximum_allowed_size: u64,
 }
@@ -44,8 +46,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Const(ident, generics, _, _) = &item.kind
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index c2b739431060..50767b32bb71 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -58,6 +58,8 @@
     "large size difference between variants on an enum"
 }
 
+impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
+
 pub struct LargeEnumVariant {
     maximum_size_difference_allowed: u64,
 }
@@ -70,8 +72,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
         if let ItemKind::Enum(ident, _, ref def) = item.kind
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index b11e89a9b566..382d1c1ae3ef 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -40,6 +40,8 @@
     "large future may lead to unexpected stack overflows"
 }
 
+impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
+
 pub struct LargeFuture {
     future_size_threshold: u64,
 }
@@ -52,8 +54,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeFuture {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Match(scrutinee, _, MatchSource::AwaitDesugar) = expr.kind
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 8ea756fa4b59..39d252f4f3b6 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -38,6 +38,8 @@
     "including a large file"
 }
 
+impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
+
 pub struct LargeIncludeFile {
     max_file_size: u64,
 }
@@ -50,8 +52,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
-
 impl LateLintPass<'_> for LargeIncludeFile {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(lit) = &expr.kind
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index fa85bef12a82..9b0b65cd02c7 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -2,9 +2,9 @@
 
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_from_proc_macro, sym};
 use clippy_utils::macros::macro_backtrace;
 use clippy_utils::source::snippet;
+use clippy_utils::{is_from_proc_macro, sym};
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -29,6 +29,8 @@
     "allocating large arrays on stack may cause stack overflow"
 }
 
+impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
+
 pub struct LargeStackArrays {
     maximum_allowed_size: u64,
     prev_vec_macro_callsite: Option<Span>,
@@ -61,8 +63,6 @@ fn is_from_vec_macro(&mut self, cx: &LateContext<'_>, span: Span) -> bool {
     }
 }
 
-impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
     fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if matches!(item.kind, ItemKind::Static(..) | ItemKind::Const(..)) {
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 6b0080d04c44..7cf594384b5a 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -82,6 +82,8 @@
     "checks for functions that allocate a lot of stack space"
 }
 
+impl_lint_pass!(LargeStackFrames => [LARGE_STACK_FRAMES]);
+
 pub struct LargeStackFrames {
     maximum_allowed_size: u64,
     allow_large_stack_frames_in_tests: bool,
@@ -96,8 +98,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LargeStackFrames => [LARGE_STACK_FRAMES]);
-
 #[derive(Copy, Clone)]
 enum Space {
     Used(u64),
diff --git a/clippy_lints/src/legacy_numeric_constants.rs b/clippy_lints/src/legacy_numeric_constants.rs
index d9920acb0f9f..838abc81ce44 100644
--- a/clippy_lints/src/legacy_numeric_constants.rs
+++ b/clippy_lints/src/legacy_numeric_constants.rs
@@ -1,16 +1,16 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_from_proc_macro, sym};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
+use clippy_utils::{is_from_proc_macro, sym};
 use hir::def_id::DefId;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{ExprKind, Item, ItemKind, QPath, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
-use rustc_span::symbol::kw;
 use rustc_span::Symbol;
+use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -34,6 +34,9 @@
     style,
     "checks for usage of legacy std numeric constants and methods"
 }
+
+impl_lint_pass!(LegacyNumericConstants => [LEGACY_NUMERIC_CONSTANTS]);
+
 pub struct LegacyNumericConstants {
     msrv: Msrv,
 }
@@ -44,8 +47,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(LegacyNumericConstants => [LEGACY_NUMERIC_CONSTANTS]);
-
 impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         // Integer modules are "TBD" deprecated, and the contents are too,
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 2e576da38b89..d683abd3d33b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -16,41 +16,6 @@
 use rustc_span::source_map::Spanned;
 use rustc_span::{Span, Symbol};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for getting the length of something via `.len()`
-    /// just to compare to zero, and suggests using `.is_empty()` where applicable.
-    ///
-    /// ### Why is this bad?
-    /// Some structures can answer `.is_empty()` much faster
-    /// than calculating their length. So it is good to get into the habit of using
-    /// `.is_empty()`, and having it is cheap.
-    /// Besides, it makes the intent clearer than a manual comparison in some contexts.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// if x.len() == 0 {
-    ///     ..
-    /// }
-    /// if y.len() != 0 {
-    ///     ..
-    /// }
-    /// ```
-    /// instead use
-    /// ```ignore
-    /// if x.is_empty() {
-    ///     ..
-    /// }
-    /// if !y.is_empty() {
-    ///     ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub LEN_ZERO,
-    style,
-    "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for comparing to an empty slice such as `""` or `[]`,
@@ -89,12 +54,47 @@
     "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for getting the length of something via `.len()`
+    /// just to compare to zero, and suggests using `.is_empty()` where applicable.
+    ///
+    /// ### Why is this bad?
+    /// Some structures can answer `.is_empty()` much faster
+    /// than calculating their length. So it is good to get into the habit of using
+    /// `.is_empty()`, and having it is cheap.
+    /// Besides, it makes the intent clearer than a manual comparison in some contexts.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// if x.len() == 0 {
+    ///     ..
+    /// }
+    /// if y.len() != 0 {
+    ///     ..
+    /// }
+    /// ```
+    /// instead use
+    /// ```ignore
+    /// if x.is_empty() {
+    ///     ..
+    /// }
+    /// if !y.is_empty() {
+    ///     ..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub LEN_ZERO,
+    style,
+    "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead"
+}
+
+impl_lint_pass!(LenZero => [COMPARISON_TO_EMPTY, LEN_ZERO]);
+
 pub struct LenZero {
     msrv: Msrv,
 }
 
-impl_lint_pass!(LenZero => [LEN_ZERO, COMPARISON_TO_EMPTY]);
-
 impl LenZero {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index b72e14246db7..984574c221fb 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -9,25 +9,33 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = <expr>` where expr is `#[must_use]`
+    /// Checks for `let _ = <expr>` where the resulting type of expr implements `Future`
     ///
-    /// ### Why restrict this?
-    /// To ensure that all `#[must_use]` types are used rather than ignored.
+    /// ### Why is this bad?
+    /// Futures must be polled for work to be done. The original intention was most likely to await the future
+    /// and ignore the resulting value.
     ///
     /// ### Example
     /// ```no_run
-    /// fn f() -> Result<u32, u32> {
-    ///     Ok(0)
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
     /// }
-    ///
-    /// let _ = f();
-    /// // is_ok() is marked #[must_use]
-    /// let _ = f().is_ok();
+    /// let _ = foo();
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub LET_UNDERSCORE_MUST_USE,
-    restriction,
-    "non-binding `let` on a `#[must_use]` expression"
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # async fn context() {
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
+    /// }
+    /// let _ = foo().await;
+    /// # }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub LET_UNDERSCORE_FUTURE,
+    suspicious,
+    "non-binding `let` on a future"
 }
 
 declare_clippy_lint! {
@@ -60,33 +68,25 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = <expr>` where the resulting type of expr implements `Future`
+    /// Checks for `let _ = <expr>` where expr is `#[must_use]`
     ///
-    /// ### Why is this bad?
-    /// Futures must be polled for work to be done. The original intention was most likely to await the future
-    /// and ignore the resulting value.
+    /// ### Why restrict this?
+    /// To ensure that all `#[must_use]` types are used rather than ignored.
     ///
     /// ### Example
     /// ```no_run
-    /// async fn foo() -> Result<(), ()> {
-    ///     Ok(())
+    /// fn f() -> Result<u32, u32> {
+    ///     Ok(0)
     /// }
-    /// let _ = foo();
-    /// ```
     ///
-    /// Use instead:
-    /// ```no_run
-    /// # async fn context() {
-    /// async fn foo() -> Result<(), ()> {
-    ///     Ok(())
-    /// }
-    /// let _ = foo().await;
-    /// # }
+    /// let _ = f();
+    /// // is_ok() is marked #[must_use]
+    /// let _ = f().is_ok();
     /// ```
-    #[clippy::version = "1.67.0"]
-    pub LET_UNDERSCORE_FUTURE,
-    suspicious,
-    "non-binding `let` on a future"
+    #[clippy::version = "1.42.0"]
+    pub LET_UNDERSCORE_MUST_USE,
+    restriction,
+    "non-binding `let` on a `#[must_use]` expression"
 }
 
 declare_clippy_lint! {
@@ -127,7 +127,12 @@
     "non-binding `let` without a type annotation"
 }
 
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE, LET_UNDERSCORE_UNTYPED]);
+declare_lint_pass!(LetUnderscore => [
+    LET_UNDERSCORE_FUTURE,
+    LET_UNDERSCORE_LOCK,
+    LET_UNDERSCORE_MUST_USE,
+    LET_UNDERSCORE_UNTYPED,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &LetStmt<'tcx>) {
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 24a4c321bdab..7f2687664c68 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -24,6 +24,7 @@
     complexity,
     "unneeded underscore type (`_`) in a variable declaration"
 }
+
 declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
 impl EarlyLintPass for UnderscoreTyped {
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 679fb983d532..0bb4992cf6bb 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -27,41 +27,6 @@
 use rustc_span::symbol::{Ident, kw};
 use std::ops::ControlFlow;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for lifetime annotations which can be removed by
-    /// relying on lifetime elision.
-    ///
-    /// ### Why is this bad?
-    /// The additional lifetimes make the code look more
-    /// complicated, while there is nothing out of the ordinary going on. Removing
-    /// them leads to more readable code.
-    ///
-    /// ### Known problems
-    /// This lint ignores functions with `where` clauses that reference
-    /// lifetimes to prevent false positives.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // Unnecessary lifetime annotations
-    /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
-    ///     x
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn elided(x: &u8, y: u8) -> &u8 {
-    ///     x
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_LIFETIMES,
-    complexity,
-    "using explicit lifetimes for references in function arguments when elision rules \
-     would allow omitting them"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for lifetime annotations which can be replaced with anonymous lifetimes (`'_`).
@@ -124,6 +89,47 @@
     "unused lifetimes in function definitions"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for lifetime annotations which can be removed by
+    /// relying on lifetime elision.
+    ///
+    /// ### Why is this bad?
+    /// The additional lifetimes make the code look more
+    /// complicated, while there is nothing out of the ordinary going on. Removing
+    /// them leads to more readable code.
+    ///
+    /// ### Known problems
+    /// This lint ignores functions with `where` clauses that reference
+    /// lifetimes to prevent false positives.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // Unnecessary lifetime annotations
+    /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
+    ///     x
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn elided(x: &u8, y: u8) -> &u8 {
+    ///     x
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_LIFETIMES,
+    complexity,
+    "using explicit lifetimes for references in function arguments when elision rules \
+     would allow omitting them"
+}
+
+impl_lint_pass!(Lifetimes => [
+    ELIDABLE_LIFETIME_NAMES,
+    EXTRA_UNUSED_LIFETIMES,
+    NEEDLESS_LIFETIMES,
+]);
+
 pub struct Lifetimes {
     msrv: Msrv,
 }
@@ -134,12 +140,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Lifetimes => [
-    NEEDLESS_LIFETIMES,
-    ELIDABLE_LIFETIME_NAMES,
-    EXTRA_UNUSED_LIFETIMES,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7cbfa2d097ae..2ec046c8d6ba 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -12,51 +12,22 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if a long integral or floating-point constant does
-    /// not contain underscores.
+    /// Warns if there is a better representation for a numeric literal.
     ///
-    /// ### Why is this bad?
-    /// Reading long numbers is difficult without separators.
+    /// ### Why restrict this?
+    /// Especially for big powers of 2, a hexadecimal representation is usually more
+    /// readable than a decimal representation.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let _: u64 =
-    /// 61864918973511
-    /// # ;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let _: u64 =
-    /// 61_864_918_973_511
-    /// # ;
+    /// ```text
+    /// `255` => `0xFF`
+    /// `65_535` => `0xFFFF`
+    /// `4_042_322_160` => `0xF0F0_F0F0`
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub UNREADABLE_LITERAL,
-    pedantic,
-    "long literal without underscores"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns for mistyped suffix in literals
-    ///
-    /// ### Why is this bad?
-    /// This is most probably a typo
-    ///
-    /// ### Known problems
-    /// - Does not match on integers too large to fit in the corresponding unsigned type
-    /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
-    ///
-    /// ### Example
-    /// ```ignore
-    /// `2_32` => `2_i32`
-    /// `250_8 => `250_u8`
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub MISTYPED_LITERAL_SUFFIXES,
-    correctness,
-    "mistyped literal suffix"
+    pub DECIMAL_LITERAL_REPRESENTATION,
+    restriction,
+    "using decimal representation when hexadecimal would be better"
 }
 
 declare_clippy_lint! {
@@ -87,25 +58,6 @@
     "integer literals with digits grouped inconsistently"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if hexadecimal or binary literals are not grouped
-    /// by nibble or byte.
-    ///
-    /// ### Why is this bad?
-    /// Negatively impacts readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: u32 = 0xFFF_FFF;
-    /// let y: u8 = 0b01_011_101;
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub UNUSUAL_BYTE_GROUPINGS,
-    style,
-    "binary or hex literals that aren't grouped by four"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Warns if the digits of an integral or floating-point
@@ -127,24 +79,82 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if there is a better representation for a numeric literal.
+    /// Warns for mistyped suffix in literals
     ///
-    /// ### Why restrict this?
-    /// Especially for big powers of 2, a hexadecimal representation is usually more
-    /// readable than a decimal representation.
+    /// ### Why is this bad?
+    /// This is most probably a typo
+    ///
+    /// ### Known problems
+    /// - Does not match on integers too large to fit in the corresponding unsigned type
+    /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
     ///
     /// ### Example
-    /// ```text
-    /// `255` => `0xFF`
-    /// `65_535` => `0xFFFF`
-    /// `4_042_322_160` => `0xF0F0_F0F0`
+    /// ```ignore
+    /// `2_32` => `2_i32`
+    /// `250_8 => `250_u8`
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub MISTYPED_LITERAL_SUFFIXES,
+    correctness,
+    "mistyped literal suffix"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if a long integral or floating-point constant does
+    /// not contain underscores.
+    ///
+    /// ### Why is this bad?
+    /// Reading long numbers is difficult without separators.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let _: u64 =
+    /// 61864918973511
+    /// # ;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let _: u64 =
+    /// 61_864_918_973_511
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub DECIMAL_LITERAL_REPRESENTATION,
-    restriction,
-    "using decimal representation when hexadecimal would be better"
+    pub UNREADABLE_LITERAL,
+    pedantic,
+    "long literal without underscores"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if hexadecimal or binary literals are not grouped
+    /// by nibble or byte.
+    ///
+    /// ### Why is this bad?
+    /// Negatively impacts readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: u32 = 0xFFF_FFF;
+    /// let y: u8 = 0b01_011_101;
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub UNUSUAL_BYTE_GROUPINGS,
+    style,
+    "binary or hex literals that aren't grouped by four"
+}
+
+impl_lint_pass!(DecimalLiteralRepresentation => [DECIMAL_LITERAL_REPRESENTATION]);
+
+impl_lint_pass!(LiteralDigitGrouping => [
+    INCONSISTENT_DIGIT_GROUPING,
+    LARGE_DIGIT_GROUPS,
+    MISTYPED_LITERAL_SUFFIXES,
+    UNREADABLE_LITERAL,
+    UNUSUAL_BYTE_GROUPINGS,
+]);
+
 enum WarningType {
     UnreadableLiteral,
     InconsistentDigitGrouping,
@@ -195,14 +205,6 @@ pub struct LiteralDigitGrouping {
     lint_fraction_readability: bool,
 }
 
-impl_lint_pass!(LiteralDigitGrouping => [
-    UNREADABLE_LITERAL,
-    INCONSISTENT_DIGIT_GROUPING,
-    LARGE_DIGIT_GROUPS,
-    MISTYPED_LITERAL_SUFFIXES,
-    UNUSUAL_BYTE_GROUPINGS,
-]);
-
 impl EarlyLintPass for LiteralDigitGrouping {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::Lit(lit) = expr.kind
@@ -414,8 +416,6 @@ pub struct DecimalLiteralRepresentation {
     threshold: u64,
 }
 
-impl_lint_pass!(DecimalLiteralRepresentation => [DECIMAL_LITERAL_REPRESENTATION]);
-
 impl EarlyLintPass for DecimalLiteralRepresentation {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::Lit(lit) = expr.kind
diff --git a/clippy_lints/src/literal_string_with_formatting_args.rs b/clippy_lints/src/literal_string_with_formatting_args.rs
index 244e7c95122e..2751a7edc1ae 100644
--- a/clippy_lints/src/literal_string_with_formatting_args.rs
+++ b/clippy_lints/src/literal_string_with_formatting_args.rs
@@ -36,7 +36,9 @@
     "Checks if string literals have formatting arguments"
 }
 
-declare_lint_pass!(LiteralStringWithFormattingArg => [LITERAL_STRING_WITH_FORMATTING_ARGS]);
+declare_lint_pass!(LiteralStringWithFormattingArg => [
+    LITERAL_STRING_WITH_FORMATTING_ARGS,
+]);
 
 fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, spans: &[(Span, Option<String>)]) {
     if !spans.is_empty()
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index bfd4d4bcd564..9bfc3aa56648 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -28,72 +28,77 @@ pub(super) fn check<'tcx>(
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(cx, expr.hir_id) {
-        for id in increment_visitor.into_results() {
-            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
-            walk_block(&mut initialize_visitor, block);
+    let Some(block) = get_enclosing_block(cx, expr.hir_id) else {
+        return;
+    };
 
-            if let Some((name, ty, initializer)) = initialize_visitor.get_result() {
-                let is_zero = is_integer_const(cx, initializer, 0);
-                let mut applicability = Applicability::MaybeIncorrect;
-                let span = expr.span.with_hi(arg.span.hi());
-                let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
+    for id in increment_visitor.into_results() {
+        let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
+        walk_block(&mut initialize_visitor, block);
 
-                span_lint_and_then(
-                    cx,
-                    EXPLICIT_COUNTER_LOOP,
-                    span,
-                    format!("the variable `{name}` is used as a loop counter"),
-                    |diag| {
-                        let pat_snippet = snippet_with_applicability(cx, pat.span, "item", &mut applicability);
-                        let iter_snippet = make_iterator_snippet(cx, arg, &mut applicability);
-                        let int_name = match ty.map(Ty::kind) {
-                            Some(ty::Uint(UintTy::Usize)) | None => {
-                                if is_zero {
-                                    diag.span_suggestion(
-                                        span,
-                                        "consider using",
-                                        format!(
-                                            "{loop_label}for ({name}, {pat_snippet}) in {iter_snippet}.enumerate()",
-                                        ),
-                                        applicability,
-                                    );
-                                    return;
-                                }
-                                None
-                            },
-                            Some(ty::Int(int_ty)) => Some(int_ty.name_str()),
-                            Some(ty::Uint(uint_ty)) => Some(uint_ty.name_str()),
-                            _ => None,
-                        }
-                        .filter(|_| is_integer_literal_untyped(initializer));
-
-                        let initializer = Sugg::hir_from_snippet(cx, initializer, |span| {
-                            let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
-                            if let Some(int_name) = int_name {
-                                return Cow::Owned(format!("{snippet}_{int_name}"));
-                            }
-                            snippet
-                        });
-
-                        diag.span_suggestion(
-                            span,
-                            "consider using",
-                            format!(
-                                "{loop_label}for ({name}, {pat_snippet}) in ({}).zip({iter_snippet})",
-                                initializer.range(&EMPTY, RangeLimits::HalfOpen)
-                            ),
-                            applicability,
-                        );
-
-                        if is_zero && let Some(int_name) = int_name {
-                            diag.note(format!(
-                                "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
-                            ));
-                        }
-                    },
-                );
-            }
+        let Some((name, ty, initializer)) = initialize_visitor.get_result() else {
+            continue;
+        };
+        if !cx.typeck_results().expr_ty(initializer).is_integral() {
+            continue;
         }
+
+        let is_zero = is_integer_const(cx, initializer, 0);
+        let mut applicability = Applicability::MaybeIncorrect;
+        let span = expr.span.with_hi(arg.span.hi());
+        let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
+
+        span_lint_and_then(
+            cx,
+            EXPLICIT_COUNTER_LOOP,
+            span,
+            format!("the variable `{name}` is used as a loop counter"),
+            |diag| {
+                let pat_snippet = snippet_with_applicability(cx, pat.span, "item", &mut applicability);
+                let iter_snippet = make_iterator_snippet(cx, arg, &mut applicability);
+                let int_name = match ty.map(Ty::kind) {
+                    Some(ty::Uint(UintTy::Usize)) | None => {
+                        if is_zero {
+                            diag.span_suggestion(
+                                span,
+                                "consider using",
+                                format!("{loop_label}for ({name}, {pat_snippet}) in {iter_snippet}.enumerate()"),
+                                applicability,
+                            );
+                            return;
+                        }
+                        None
+                    },
+                    Some(ty::Int(int_ty)) => Some(int_ty.name_str()),
+                    Some(ty::Uint(uint_ty)) => Some(uint_ty.name_str()),
+                    _ => None,
+                }
+                .filter(|_| is_integer_literal_untyped(initializer));
+
+                let initializer = Sugg::hir_from_snippet(cx, initializer, |span| {
+                    let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+                    if let Some(int_name) = int_name {
+                        return Cow::Owned(format!("{snippet}_{int_name}"));
+                    }
+                    snippet
+                });
+
+                diag.span_suggestion(
+                    span,
+                    "consider using",
+                    format!(
+                        "{loop_label}for ({name}, {pat_snippet}) in ({}).zip({iter_snippet})",
+                        initializer.range(&EMPTY, RangeLimits::HalfOpen)
+                    ),
+                    applicability,
+                );
+
+                if is_zero && let Some(int_name) = int_name {
+                    diag.note(format!(
+                        "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
+                    ));
+                }
+            },
+        );
     }
 }
diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index 74c0b1780189..f3d5611b0479 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{fn_def_id, is_from_proc_macro, is_lint_allowed};
+use clippy_utils::{RequiresSemi, fn_def_id, is_from_proc_macro, is_lint_allowed, is_never_expr};
 use hir::intravisit::{Visitor, walk_expr};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
@@ -52,16 +52,20 @@ pub(super) fn check<'tcx>(
 
     if !is_finite_loop {
         span_lint_and_then(cx, INFINITE_LOOP, expr.span, "infinite loop detected", |diag| {
-            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret {
+            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret
+                && cx
+                    .enclosing_body
+                    .is_some_and(|id| matches!(is_never_expr(cx, cx.tcx.hir_body(id).value), Some(RequiresSemi::No)))
+            {
                 diag.span_suggestion(
                     ret_span,
                     "if this is intentional, consider specifying `!` as function return",
                     " -> !",
                     Applicability::MaybeIncorrect,
                 );
-            } else {
-                diag.help("if this is not intended, try adding a `break` or `return` condition in the loop");
             }
+
+            diag.help("if this is not intended, try adding a `break` or `return` to the loop");
         });
     }
 }
diff --git a/clippy_lints/src/loops/manual_while_let_some.rs b/clippy_lints/src/loops/manual_while_let_some.rs
index caaf173bf90c..df5e9ffa9863 100644
--- a/clippy_lints/src/loops/manual_while_let_some.rs
+++ b/clippy_lints/src/loops/manual_while_let_some.rs
@@ -1,6 +1,6 @@
-use clippy_utils::{sym, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
+use clippy_utils::{SpanlessEq, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Pat, Stmt, StmtKind, UnOp};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 83574cab6b67..f89ea531d583 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -37,214 +37,45 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for for-loops that manually copy items between
-    /// slices that could be optimized by having a memcpy.
+    /// Checks for usage of a character position yielded by `.chars().enumerate()` in a context where a **byte index** is expected,
+    /// such as an argument to a specific `str` method or indexing into a `str` or `String`.
     ///
     /// ### Why is this bad?
-    /// It is not as fast as a memcpy.
+    /// A character (more specifically, a Unicode scalar value) that is yielded by `str::chars` can take up multiple bytes,
+    /// so a character position does not necessarily have the same byte index at which the character is stored.
+    /// Thus, using the character position where a byte index is expected can unexpectedly return wrong values
+    /// or panic when the string consists of multibyte characters.
+    ///
+    /// For example, the character `a` in `äa` is stored at byte index 2 but has the character position 1.
+    /// Using the character position 1 to index into the string will lead to a panic as it is in the middle of the first character.
+    ///
+    /// Instead of `.chars().enumerate()`, the correct iterator to use is `.char_indices()`, which yields byte indices.
+    ///
+    /// This pattern is technically fine if the strings are known to only use the ASCII subset,
+    /// though in those cases it would be better to use `bytes()` directly to make the intent clearer,
+    /// but there is also no downside to just using `.char_indices()` directly and supporting non-ASCII strings.
+    ///
+    /// You may also want to read the [chapter on strings in the Rust Book](https://doc.rust-lang.org/book/ch08-02-strings.html)
+    /// which goes into this in more detail.
     ///
     /// ### Example
     /// ```no_run
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// for i in 0..src.len() {
-    ///     dst[i + 64] = src[i];
+    /// # let s = "...";
+    /// for (idx, c) in s.chars().enumerate() {
+    ///     let _ = s[idx..]; // ⚠️ Panics for strings consisting of multibyte characters
     /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MANUAL_MEMCPY,
-    perf,
-    "manually copying items between slices"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for looping over the range of `0..len` of some
-    /// collection just to get the values by index.
-    ///
-    /// ### Why is this bad?
-    /// Just iterating the collection itself makes the intent
-    /// more clear and is probably faster because it eliminates
-    /// the bounds check that is done when indexing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in 0..vec.len() {
-    ///     println!("{}", vec[i]);
+    /// # let s = "...";
+    /// for (idx, c) in s.char_indices() {
+    ///     let _ = s[idx..];
     /// }
     /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in vec {
-    ///     println!("{}", i);
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_RANGE_LOOP,
-    style,
-    "for-looping over a range of indices where an iterator over items would do"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for loops on `x.iter()` where `&x` will do, and
-    /// suggests the latter.
-    ///
-    /// ### Why is this bad?
-    /// Readability.
-    ///
-    /// ### Known problems
-    /// False negatives. We currently only warn on some known
-    /// types.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // with `y` a `Vec` or slice:
-    /// # let y = vec![1];
-    /// for x in y.iter() {
-    ///     // ..
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let y = vec![1];
-    /// for x in &y {
-    ///     // ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPLICIT_ITER_LOOP,
-    pedantic,
-    "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for loops on `y.into_iter()` where `y` will do, and
-    /// suggests the latter.
-    ///
-    /// ### Why is this bad?
-    /// Readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let y = vec![1];
-    /// // with `y` a `Vec` or slice:
-    /// for x in y.into_iter() {
-    ///     // ..
-    /// }
-    /// ```
-    /// can be rewritten to
-    /// ```no_run
-    /// # let y = vec![1];
-    /// for x in y {
-    ///     // ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPLICIT_INTO_ITER_LOOP,
-    pedantic,
-    "for-looping over `_.into_iter()` when `_` would do"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for loops on `x.next()`.
-    ///
-    /// ### Why is this bad?
-    /// `next()` returns either `Some(value)` if there was a
-    /// value, or `None` otherwise. The insidious thing is that `Option<_>`
-    /// implements `IntoIterator`, so that possibly one value will be iterated,
-    /// leading to some hard to find bugs. No one will want to write such code
-    /// [except to win an Underhanded Rust
-    /// Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).
-    ///
-    /// ### Example
-    /// ```ignore
-    /// for x in y.next() {
-    ///     ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITER_NEXT_LOOP,
+    #[clippy::version = "1.88.0"]
+    pub CHAR_INDICES_AS_BYTE_INDICES,
     correctness,
-    "for-looping over `_.next()` which is probably not intended"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects `loop + match` combinations that are easier
-    /// written as a `while let` loop.
-    ///
-    /// ### Why is this bad?
-    /// The `while let` loop is usually shorter and more
-    /// readable.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// let y = Some(1);
-    /// loop {
-    ///     let x = match y {
-    ///         Some(x) => x,
-    ///         None => break,
-    ///     };
-    ///     // ..
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    /// let y = Some(1);
-    /// while let Some(x) = y {
-    ///     // ..
-    /// };
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WHILE_LET_LOOP,
-    complexity,
-    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks `for` loops over slices with an explicit counter
-    /// and suggests the use of `.enumerate()`.
-    ///
-    /// ### Why is this bad?
-    /// Using `.enumerate()` makes the intent more clear,
-    /// declutters the code and may be faster in some instances.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// let mut i = 0;
-    /// for item in &v {
-    ///     bar(i, *item);
-    ///     i += 1;
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPLICIT_COUNTER_LOOP,
-    complexity,
-    "for-looping with an explicit counter when `_.enumerate()` would do"
+    "using the character position yielded by `.chars().enumerate()` in a context where a byte index is expected"
 }
 
 declare_clippy_lint! {
@@ -283,29 +114,97 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `while let` expressions on iterators.
+    /// Checks `for` loops over slices with an explicit counter
+    /// and suggests the use of `.enumerate()`.
     ///
     /// ### Why is this bad?
-    /// Readability. A simple `for` loop is shorter and conveys
-    /// the intent better.
+    /// Using `.enumerate()` makes the intent more clear,
+    /// declutters the code and may be faster in some instances.
     ///
     /// ### Example
-    /// ```ignore
-    /// while let Some(val) = iter.next() {
-    ///     ..
+    /// ```no_run
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// let mut i = 0;
+    /// for item in &v {
+    ///     bar(i, *item);
+    ///     i += 1;
     /// }
     /// ```
     ///
     /// Use instead:
-    /// ```ignore
-    /// for val in &mut iter {
-    ///     ..
+    /// ```no_run
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPLICIT_COUNTER_LOOP,
+    complexity,
+    "for-looping with an explicit counter when `_.enumerate()` would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for loops on `y.into_iter()` where `y` will do, and
+    /// suggests the latter.
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let y = vec![1];
+    /// // with `y` a `Vec` or slice:
+    /// for x in y.into_iter() {
+    ///     // ..
+    /// }
+    /// ```
+    /// can be rewritten to
+    /// ```no_run
+    /// # let y = vec![1];
+    /// for x in y {
+    ///     // ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WHILE_LET_ON_ITERATOR,
-    style,
-    "using a `while let` loop instead of a for loop on an iterator"
+    pub EXPLICIT_INTO_ITER_LOOP,
+    pedantic,
+    "for-looping over `_.into_iter()` when `_` would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for loops on `x.iter()` where `&x` will do, and
+    /// suggests the latter.
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Known problems
+    /// False negatives. We currently only warn on some known
+    /// types.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // with `y` a `Vec` or slice:
+    /// # let y = vec![1];
+    /// for x in y.iter() {
+    ///     // ..
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let y = vec![1];
+    /// for x in &y {
+    ///     // ..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPLICIT_ITER_LOOP,
+    pedantic,
+    "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
 }
 
 declare_clippy_lint! {
@@ -339,24 +238,251 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for loops that will always `break`, `return` or
-    /// `continue` an outer loop.
+    /// Checks for infinite loops in a function where the return type is not `!`
+    /// and lint accordingly.
     ///
-    /// ### Why is this bad?
-    /// This loop never loops, all it does is obfuscating the
-    /// code.
+    /// ### Why restrict this?
+    /// Making the return type `!` serves as documentation that the function does not return.
+    /// If the function is not intended to loop infinitely, then this lint may detect a bug.
     ///
     /// ### Example
-    /// ```no_run
-    /// loop {
-    ///     ..;
-    ///     break;
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// If infinite loops are as intended:
+    /// ```no_run,ignore
+    /// fn run_forever() -> ! {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// Otherwise add a `break` or `return` condition:
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///         if condition {
+    ///             break;
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub INFINITE_LOOP,
+    restriction,
+    "possibly unintended infinite loop"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for loops on `x.next()`.
+    ///
+    /// ### Why is this bad?
+    /// `next()` returns either `Some(value)` if there was a
+    /// value, or `None` otherwise. The insidious thing is that `Option<_>`
+    /// implements `IntoIterator`, so that possibly one value will be iterated,
+    /// leading to some hard to find bugs. No one will want to write such code
+    /// [except to win an Underhanded Rust
+    /// Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).
+    ///
+    /// ### Example
+    /// ```ignore
+    /// for x in y.next() {
+    ///     ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub NEVER_LOOP,
+    pub ITER_NEXT_LOOP,
     correctness,
-    "any loop that will always `break` or `return`"
+    "for-looping over `_.next()` which is probably not intended"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of Iterator::find
+    ///
+    /// ### Why is this bad?
+    /// It doesn't affect performance, but using `find` is shorter and easier to read.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     for el in arr {
+    ///         if el == 1 {
+    ///             return Some(el);
+    ///         }
+    ///     }
+    ///     None
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     arr.into_iter().find(|&el| el == 1)
+    /// }
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub MANUAL_FIND,
+    complexity,
+    "manual implementation of `Iterator::find`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary `if let` usage in a for loop
+    /// where only the `Some` or `Ok` variant of the iterator element is used.
+    ///
+    /// ### Why is this bad?
+    /// It is verbose and can be simplified
+    /// by first calling the `flatten` method on the `Iterator`.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x {
+    ///     if let Some(n) = n {
+    ///         println!("{}", n);
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x.into_iter().flatten() {
+    ///     println!("{}", n);
+    /// }
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub MANUAL_FLATTEN,
+    complexity,
+    "for loops over `Option`s or `Result`s with a single expression can be simplified"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for for-loops that manually copy items between
+    /// slices that could be optimized by having a memcpy.
+    ///
+    /// ### Why is this bad?
+    /// It is not as fast as a memcpy.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// for i in 0..src.len() {
+    ///     dst[i + 64] = src[i];
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MANUAL_MEMCPY,
+    perf,
+    "manually copying items between slices"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manually filling a slice with a value.
+    ///
+    /// ### Why is this bad?
+    /// Using the `fill` method is more idiomatic and concise.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut some_slice = [1, 2, 3, 4, 5];
+    /// for i in 0..some_slice.len() {
+    ///     some_slice[i] = 0;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let mut some_slice = [1, 2, 3, 4, 5];
+    /// some_slice.fill(0);
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_SLICE_FILL,
+    style,
+    "manually filling a slice with a value"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
+    /// in the body as a separate operation.
+    ///
+    /// ### Why is this bad?
+    /// Such loops can be written in a more idiomatic way by using a while-let loop and directly
+    /// pattern matching on the return value of `Vec::pop()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while !numbers.is_empty() {
+    ///     let number = numbers.pop().unwrap();
+    ///     // use `number`
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while let Some(number) = numbers.pop() {
+    ///     // use `number`
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_WHILE_LET_SOME,
+    style,
+    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty spin loops
+    ///
+    /// ### Why is this bad?
+    /// The loop body should have something like `thread::park()` or at least
+    /// `std::hint::spin_loop()` to avoid needlessly burning cycles and conserve
+    /// energy. Perhaps even better use an actual lock, if possible.
+    ///
+    /// ### Known problems
+    /// This lint doesn't currently trigger on `while let` or
+    /// `loop { match .. { .. } }` loops, which would be considered idiomatic in
+    /// combination with e.g. `AtomicBool::compare_exchange_weak`.
+    ///
+    /// ### Example
+    ///
+    /// ```ignore
+    /// use core::sync::atomic::{AtomicBool, Ordering};
+    /// let b = AtomicBool::new(true);
+    /// // give a ref to `b` to another thread,wait for it to become false
+    /// while b.load(Ordering::Acquire) {};
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    ///# use core::sync::atomic::{AtomicBool, Ordering};
+    ///# let b = AtomicBool::new(true);
+    /// while b.load(Ordering::Acquire) {
+    ///     std::hint::spin_loop()
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub MISSING_SPIN_LOOP,
+    perf,
+    "An empty busy waiting loop"
 }
 
 declare_clippy_lint! {
@@ -397,62 +523,55 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks whether variables used within while loop condition
-    /// can be (and are) mutated in the body.
+    /// Checks for looping over the range of `0..len` of some
+    /// collection just to get the values by index.
     ///
     /// ### Why is this bad?
-    /// If the condition is unchanged, entering the body of the loop
-    /// will lead to an infinite loop.
-    ///
-    /// ### Known problems
-    /// If the `while`-loop is in a closure, the check for mutation of the
-    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
-    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
+    /// Just iterating the collection itself makes the intent
+    /// more clear and is probably faster because it eliminates
+    /// the bounds check that is done when indexing.
     ///
     /// ### Example
     /// ```no_run
-    /// let i = 0;
-    /// while i > 10 {
-    ///     println!("let me loop forever!");
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WHILE_IMMUTABLE_CONDITION,
-    correctness,
-    "variables used within while expression are not mutated in the body"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for while loops comparing floating point values.
-    ///
-    /// ### Why is this bad?
-    /// If you increment floating point values, errors can compound,
-    /// so, use integers instead if possible.
-    ///
-    /// ### Known problems
-    /// The lint will catch all while loops comparing floating point
-    /// values without regarding the increment.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut x = 0.0;
-    /// while x < 42.0 {
-    ///     x += 1.0;
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in 0..vec.len() {
+    ///     println!("{}", vec[i]);
     /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let mut x = 0;
-    /// while x < 42 {
-    ///     x += 1;
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in vec {
+    ///     println!("{}", i);
     /// }
     /// ```
-    #[clippy::version = "1.80.0"]
-    pub WHILE_FLOAT,
-    nursery,
-    "while loops comparing floating point values"
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_RANGE_LOOP,
+    style,
+    "for-looping over a range of indices where an iterator over items would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for loops that will always `break`, `return` or
+    /// `continue` an outer loop.
+    ///
+    /// ### Why is this bad?
+    /// This loop never loops, all it does is obfuscating the
+    /// code.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// loop {
+    ///     ..;
+    ///     break;
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEVER_LOOP,
+    correctness,
+    "any loop that will always `break` or `return`"
 }
 
 declare_clippy_lint! {
@@ -519,105 +638,6 @@
     "there is no reason to have a single element loop"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary `if let` usage in a for loop
-    /// where only the `Some` or `Ok` variant of the iterator element is used.
-    ///
-    /// ### Why is this bad?
-    /// It is verbose and can be simplified
-    /// by first calling the `flatten` method on the `Iterator`.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x {
-    ///     if let Some(n) = n {
-    ///         println!("{}", n);
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x.into_iter().flatten() {
-    ///     println!("{}", n);
-    /// }
-    /// ```
-    #[clippy::version = "1.52.0"]
-    pub MANUAL_FLATTEN,
-    complexity,
-    "for loops over `Option`s or `Result`s with a single expression can be simplified"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for empty spin loops
-    ///
-    /// ### Why is this bad?
-    /// The loop body should have something like `thread::park()` or at least
-    /// `std::hint::spin_loop()` to avoid needlessly burning cycles and conserve
-    /// energy. Perhaps even better use an actual lock, if possible.
-    ///
-    /// ### Known problems
-    /// This lint doesn't currently trigger on `while let` or
-    /// `loop { match .. { .. } }` loops, which would be considered idiomatic in
-    /// combination with e.g. `AtomicBool::compare_exchange_weak`.
-    ///
-    /// ### Example
-    ///
-    /// ```ignore
-    /// use core::sync::atomic::{AtomicBool, Ordering};
-    /// let b = AtomicBool::new(true);
-    /// // give a ref to `b` to another thread,wait for it to become false
-    /// while b.load(Ordering::Acquire) {};
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    ///# use core::sync::atomic::{AtomicBool, Ordering};
-    ///# let b = AtomicBool::new(true);
-    /// while b.load(Ordering::Acquire) {
-    ///     std::hint::spin_loop()
-    /// }
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub MISSING_SPIN_LOOP,
-    perf,
-    "An empty busy waiting loop"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of Iterator::find
-    ///
-    /// ### Why is this bad?
-    /// It doesn't affect performance, but using `find` is shorter and easier to read.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// fn example(arr: Vec<i32>) -> Option<i32> {
-    ///     for el in arr {
-    ///         if el == 1 {
-    ///             return Some(el);
-    ///         }
-    ///     }
-    ///     None
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn example(arr: Vec<i32>) -> Option<i32> {
-    ///     arr.into_iter().find(|&el| el == 1)
-    /// }
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub MANUAL_FIND,
-    complexity,
-    "manual implementation of `Iterator::find`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for uses of the `enumerate` method where the index is unused (`_`)
@@ -647,144 +667,151 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
-    /// in the body as a separate operation.
+    /// Checks for while loops comparing floating point values.
     ///
     /// ### Why is this bad?
-    /// Such loops can be written in a more idiomatic way by using a while-let loop and directly
-    /// pattern matching on the return value of `Vec::pop()`.
+    /// If you increment floating point values, errors can compound,
+    /// so, use integers instead if possible.
+    ///
+    /// ### Known problems
+    /// The lint will catch all while loops comparing floating point
+    /// values without regarding the increment.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while !numbers.is_empty() {
-    ///     let number = numbers.pop().unwrap();
-    ///     // use `number`
+    /// let mut x = 0.0;
+    /// while x < 42.0 {
+    ///     x += 1.0;
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while let Some(number) = numbers.pop() {
-    ///     // use `number`
+    /// let mut x = 0;
+    /// while x < 42 {
+    ///     x += 1;
     /// }
     /// ```
-    #[clippy::version = "1.71.0"]
-    pub MANUAL_WHILE_LET_SOME,
-    style,
-    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
+    #[clippy::version = "1.80.0"]
+    pub WHILE_FLOAT,
+    nursery,
+    "while loops comparing floating point values"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for infinite loops in a function where the return type is not `!`
-    /// and lint accordingly.
-    ///
-    /// ### Why restrict this?
-    /// Making the return type `!` serves as documentation that the function does not return.
-    /// If the function is not intended to loop infinitely, then this lint may detect a bug.
-    ///
-    /// ### Example
-    /// ```no_run,ignore
-    /// fn run_forever() {
-    ///     loop {
-    ///         // do something
-    ///     }
-    /// }
-    /// ```
-    /// If infinite loops are as intended:
-    /// ```no_run,ignore
-    /// fn run_forever() -> ! {
-    ///     loop {
-    ///         // do something
-    ///     }
-    /// }
-    /// ```
-    /// Otherwise add a `break` or `return` condition:
-    /// ```no_run,ignore
-    /// fn run_forever() {
-    ///     loop {
-    ///         // do something
-    ///         if condition {
-    ///             break;
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.76.0"]
-    pub INFINITE_LOOP,
-    restriction,
-    "possibly unintended infinite loop"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manually filling a slice with a value.
+    /// Checks whether variables used within while loop condition
+    /// can be (and are) mutated in the body.
     ///
     /// ### Why is this bad?
-    /// Using the `fill` method is more idiomatic and concise.
+    /// If the condition is unchanged, entering the body of the loop
+    /// will lead to an infinite loop.
+    ///
+    /// ### Known problems
+    /// If the `while`-loop is in a closure, the check for mutation of the
+    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
+    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut some_slice = [1, 2, 3, 4, 5];
-    /// for i in 0..some_slice.len() {
-    ///     some_slice[i] = 0;
+    /// let i = 0;
+    /// while i > 10 {
+    ///     println!("let me loop forever!");
     /// }
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let mut some_slice = [1, 2, 3, 4, 5];
-    /// some_slice.fill(0);
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_SLICE_FILL,
-    style,
-    "manually filling a slice with a value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of a character position yielded by `.chars().enumerate()` in a context where a **byte index** is expected,
-    /// such as an argument to a specific `str` method or indexing into a `str` or `String`.
-    ///
-    /// ### Why is this bad?
-    /// A character (more specifically, a Unicode scalar value) that is yielded by `str::chars` can take up multiple bytes,
-    /// so a character position does not necessarily have the same byte index at which the character is stored.
-    /// Thus, using the character position where a byte index is expected can unexpectedly return wrong values
-    /// or panic when the string consists of multibyte characters.
-    ///
-    /// For example, the character `a` in `äa` is stored at byte index 2 but has the character position 1.
-    /// Using the character position 1 to index into the string will lead to a panic as it is in the middle of the first character.
-    ///
-    /// Instead of `.chars().enumerate()`, the correct iterator to use is `.char_indices()`, which yields byte indices.
-    ///
-    /// This pattern is technically fine if the strings are known to only use the ASCII subset,
-    /// though in those cases it would be better to use `bytes()` directly to make the intent clearer,
-    /// but there is also no downside to just using `.char_indices()` directly and supporting non-ASCII strings.
-    ///
-    /// You may also want to read the [chapter on strings in the Rust Book](https://doc.rust-lang.org/book/ch08-02-strings.html)
-    /// which goes into this in more detail.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let s = "...";
-    /// for (idx, c) in s.chars().enumerate() {
-    ///     let _ = s[idx..]; // ⚠️ Panics for strings consisting of multibyte characters
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let s = "...";
-    /// for (idx, c) in s.char_indices() {
-    ///     let _ = s[idx..];
-    /// }
-    /// ```
-    #[clippy::version = "1.88.0"]
-    pub CHAR_INDICES_AS_BYTE_INDICES,
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_IMMUTABLE_CONDITION,
     correctness,
-    "using the character position yielded by `.chars().enumerate()` in a context where a byte index is expected"
+    "variables used within while expression are not mutated in the body"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `loop + match` combinations that are easier
+    /// written as a `while let` loop.
+    ///
+    /// ### Why is this bad?
+    /// The `while let` loop is usually shorter and more
+    /// readable.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// let y = Some(1);
+    /// loop {
+    ///     let x = match y {
+    ///         Some(x) => x,
+    ///         None => break,
+    ///     };
+    ///     // ..
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// let y = Some(1);
+    /// while let Some(x) = y {
+    ///     // ..
+    /// };
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_LET_LOOP,
+    complexity,
+    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `while let` expressions on iterators.
+    ///
+    /// ### Why is this bad?
+    /// Readability. A simple `for` loop is shorter and conveys
+    /// the intent better.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// while let Some(val) = iter.next() {
+    ///     ..
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// for val in &mut iter {
+    ///     ..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_LET_ON_ITERATOR,
+    style,
+    "using a `while let` loop instead of a for loop on an iterator"
+}
+
+impl_lint_pass!(Loops => [
+    CHAR_INDICES_AS_BYTE_INDICES,
+    EMPTY_LOOP,
+    EXPLICIT_COUNTER_LOOP,
+    EXPLICIT_INTO_ITER_LOOP,
+    EXPLICIT_ITER_LOOP,
+    FOR_KV_MAP,
+    INFINITE_LOOP,
+    ITER_NEXT_LOOP,
+    MANUAL_FIND,
+    MANUAL_FLATTEN,
+    MANUAL_MEMCPY,
+    MANUAL_SLICE_FILL,
+    MANUAL_WHILE_LET_SOME,
+    MISSING_SPIN_LOOP,
+    MUT_RANGE_BOUND,
+    NEEDLESS_RANGE_LOOP,
+    NEVER_LOOP,
+    SAME_ITEM_PUSH,
+    SINGLE_ELEMENT_LOOP,
+    UNUSED_ENUMERATE_INDEX,
+    WHILE_FLOAT,
+    WHILE_IMMUTABLE_CONDITION,
+    WHILE_LET_LOOP,
+    WHILE_LET_ON_ITERATOR,
+]);
+
 pub struct Loops {
     msrv: Msrv,
     enforce_iter_loop_reborrow: bool,
@@ -798,33 +825,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Loops => [
-    MANUAL_MEMCPY,
-    MANUAL_FLATTEN,
-    NEEDLESS_RANGE_LOOP,
-    EXPLICIT_ITER_LOOP,
-    EXPLICIT_INTO_ITER_LOOP,
-    ITER_NEXT_LOOP,
-    WHILE_LET_LOOP,
-    EXPLICIT_COUNTER_LOOP,
-    EMPTY_LOOP,
-    WHILE_LET_ON_ITERATOR,
-    FOR_KV_MAP,
-    NEVER_LOOP,
-    MUT_RANGE_BOUND,
-    WHILE_IMMUTABLE_CONDITION,
-    WHILE_FLOAT,
-    SAME_ITEM_PUSH,
-    SINGLE_ELEMENT_LOOP,
-    MISSING_SPIN_LOOP,
-    MANUAL_FIND,
-    MANUAL_WHILE_LET_SOME,
-    UNUSED_ENUMERATE_INDEX,
-    INFINITE_LOOP,
-    MANUAL_SLICE_FILL,
-    CHAR_INDICES_AS_BYTE_INDICES,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Loops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let for_loop = higher::ForLoop::hir(expr);
diff --git a/clippy_lints/src/macro_metavars_in_unsafe.rs b/clippy_lints/src/macro_metavars_in_unsafe.rs
index 4d8f10506b59..a7eda8e2932a 100644
--- a/clippy_lints/src/macro_metavars_in_unsafe.rs
+++ b/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -83,6 +83,7 @@
     suspicious,
     "expanding macro metavariables in an unsafe block"
 }
+
 impl_lint_pass!(ExprMetavarsInUnsafe => [MACRO_METAVARS_IN_UNSAFE]);
 
 #[derive(Clone, Debug)]
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 005a04002cf3..6eda0fa257a9 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -43,6 +43,8 @@
     "#[macro_use] is no longer needed"
 }
 
+impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
+
 /// `MacroRefData` includes the name of the macro.
 #[derive(Debug, Clone)]
 pub struct MacroRefData {
@@ -65,8 +67,6 @@ pub struct MacroUseImports {
     mac_refs: Vec<MacroRefData>,
 }
 
-impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
-
 impl MacroUseImports {
     fn push_unique_macro(&mut self, cx: &LateContext<'_>, span: Span) {
         let call_site = span.source_callsite();
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 01ea2f5debea..ecdeedc955a9 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -25,13 +25,13 @@
     "recursion using the entrypoint"
 }
 
+impl_lint_pass!(MainRecursion => [MAIN_RECURSION]);
+
 #[derive(Default)]
 pub struct MainRecursion {
     has_no_std_attr: bool,
 }
 
-impl_lint_pass!(MainRecursion => [MAIN_RECURSION]);
-
 impl LateLintPass<'_> for MainRecursion {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         self.has_no_std_attr = is_no_std_crate(cx);
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 28790e5597fe..dd64381033d4 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,8 +1,8 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{get_parent_expr, sym};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::{get_parent_expr, sym};
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
@@ -34,6 +34,8 @@
     "manual implementation of `size_of::<T>() * 8` can be simplified with `T::BITS`"
 }
 
+impl_lint_pass!(ManualBits => [MANUAL_BITS]);
+
 pub struct ManualBits {
     msrv: Msrv,
 }
@@ -44,8 +46,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualBits => [MANUAL_BITS]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualBits {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind
diff --git a/clippy_lints/src/manual_checked_ops.rs b/clippy_lints/src/manual_checked_ops.rs
index 6327567df336..5fd1e27d5b99 100644
--- a/clippy_lints/src/manual_checked_ops.rs
+++ b/clippy_lints/src/manual_checked_ops.rs
@@ -35,6 +35,7 @@
     complexity,
     "manual zero checks before dividing integers"
 }
+
 declare_lint_pass!(ManualCheckedOps => [MANUAL_CHECKED_OPS]);
 
 #[derive(Copy, Clone)]
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 54387e36d6c8..c8fba3e5a7bc 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -88,6 +88,7 @@
     complexity,
     "using a clamp pattern instead of the clamp function"
 }
+
 impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
 
 pub struct ManualClamp {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 8a3acde166c5..4a2784caf4c7 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -13,29 +13,6 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_session::impl_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual `is_infinite` reimplementations
-    /// (i.e., `x == <float>::INFINITY || x == <float>::NEG_INFINITY`).
-    ///
-    /// ### Why is this bad?
-    /// The method `is_infinite` is shorter and more readable.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = 1.0f32;
-    /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let x = 1.0f32;
-    /// if x.is_infinite() {}
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub MANUAL_IS_INFINITE,
-    style,
-    "use dedicated method to check if a float is infinite"
-}
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for manual `is_finite` reimplementations
@@ -61,7 +38,32 @@
     style,
     "use dedicated method to check if a float is finite"
 }
-impl_lint_pass!(ManualFloatMethods => [MANUAL_IS_INFINITE, MANUAL_IS_FINITE]);
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual `is_infinite` reimplementations
+    /// (i.e., `x == <float>::INFINITY || x == <float>::NEG_INFINITY`).
+    ///
+    /// ### Why is this bad?
+    /// The method `is_infinite` is shorter and more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 1.0f32;
+    /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let x = 1.0f32;
+    /// if x.is_infinite() {}
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub MANUAL_IS_INFINITE,
+    style,
+    "use dedicated method to check if a float is infinite"
+}
+
+impl_lint_pass!(ManualFloatMethods => [MANUAL_IS_FINITE, MANUAL_IS_INFINITE]);
 
 #[derive(Clone, Copy)]
 enum Variant {
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index ccb8d4272bfa..96d69003934f 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -47,6 +47,8 @@
     "manual implementations of `BuildHasher::hash_one`"
 }
 
+impl_lint_pass!(ManualHashOne => [MANUAL_HASH_ONE]);
+
 pub struct ManualHashOne {
     msrv: Msrv,
 }
@@ -57,8 +59,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualHashOne => [MANUAL_HASH_ONE]);
-
 impl LateLintPass<'_> for ManualHashOne {
     fn check_local(&mut self, cx: &LateContext<'_>, local: &LetStmt<'_>) {
         // `let mut hasher = seg.build_hasher();`
diff --git a/clippy_lints/src/manual_ilog2.rs b/clippy_lints/src/manual_ilog2.rs
index 4b411a60f3bf..7c397bd3f5e8 100644
--- a/clippy_lints/src/manual_ilog2.rs
+++ b/clippy_lints/src/manual_ilog2.rs
@@ -37,6 +37,8 @@
     "manually reimplementing `ilog2`"
 }
 
+impl_lint_pass!(ManualIlog2 => [MANUAL_ILOG2]);
+
 pub struct ManualIlog2 {
     msrv: Msrv,
 }
@@ -47,8 +49,6 @@ pub fn new(conf: &Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualIlog2 => [MANUAL_ILOG2]);
-
 impl LateLintPass<'_> for ManualIlog2 {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if expr.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index a0f946d22fa6..b55b3995f732 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -57,6 +57,7 @@
     style,
     "use dedicated method to check ascii range"
 }
+
 impl_lint_pass!(ManualIsAsciiCheck => [MANUAL_IS_ASCII_CHECK]);
 
 pub struct ManualIsAsciiCheck {
diff --git a/clippy_lints/src/manual_is_power_of_two.rs b/clippy_lints/src/manual_is_power_of_two.rs
index 25db719c8214..2ba79113e7bc 100644
--- a/clippy_lints/src/manual_is_power_of_two.rs
+++ b/clippy_lints/src/manual_is_power_of_two.rs
@@ -34,12 +34,12 @@
     "manually reimplementing `is_power_of_two`"
 }
 
+impl_lint_pass!(ManualIsPowerOfTwo => [MANUAL_IS_POWER_OF_TWO]);
+
 pub struct ManualIsPowerOfTwo {
     msrv: Msrv,
 }
 
-impl_lint_pass!(ManualIsPowerOfTwo => [MANUAL_IS_POWER_OF_TWO]);
-
 impl ManualIsPowerOfTwo {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index d4a7c190feca..47e98d68bc83 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -33,6 +33,8 @@
     "`&std::path::MAIN_SEPARATOR.to_string()` can be replaced by `std::path::MAIN_SEPARATOR_STR`"
 }
 
+impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
+
 pub struct ManualMainSeparatorStr {
     msrv: Msrv,
 }
@@ -43,8 +45,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
-
 impl LateLintPass<'_> for ManualMainSeparatorStr {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let (target, _) = peel_hir_expr_refs(expr);
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 8e09d88232f6..9ababe87f9de 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -61,6 +61,8 @@
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
 }
 
+impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
+
 pub struct ManualNonExhaustive {
     msrv: Msrv,
     constructed_enum_variants: FxHashSet<LocalDefId>,
@@ -77,8 +79,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if !cx.effective_visibilities.is_exported(item.owner_id.def_id) || !self.msrv.meets(cx, msrvs::NON_EXHAUSTIVE) {
diff --git a/clippy_lints/src/manual_option_as_slice.rs b/clippy_lints/src/manual_option_as_slice.rs
index cb451d8c0da3..2488873fb789 100644
--- a/clippy_lints/src/manual_option_as_slice.rs
+++ b/clippy_lints/src/manual_option_as_slice.rs
@@ -40,6 +40,8 @@
     "manual `Option::as_slice`"
 }
 
+impl_lint_pass!(ManualOptionAsSlice => [MANUAL_OPTION_AS_SLICE]);
+
 pub struct ManualOptionAsSlice {
     msrv: Msrv,
 }
@@ -50,8 +52,6 @@ pub fn new(conf: &Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualOptionAsSlice => [MANUAL_OPTION_AS_SLICE]);
-
 impl LateLintPass<'_> for ManualOptionAsSlice {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let span = expr.span;
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index bf4f2bff3195..f60b2a1a6729 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -35,6 +35,7 @@
     complexity,
     "manually writing range patterns using a combined OR pattern (`|`)"
 }
+
 declare_lint_pass!(ManualRangePatterns => [MANUAL_RANGE_PATTERNS]);
 
 fn expr_as_i128(expr: &PatExpr<'_>) -> Option<i128> {
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index d993ed48eac4..3ee92dca5303 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -35,6 +35,8 @@
     "manually reimplementing `rem_euclid`"
 }
 
+impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
+
 pub struct ManualRemEuclid {
     msrv: Msrv,
 }
@@ -45,8 +47,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // (x % c + c) % c
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 5eeda32c7ceb..564d5b53fa70 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -1,9 +1,9 @@
 use clippy_config::Conf;
-use clippy_utils::{sym, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
 use clippy_utils::source::snippet;
+use clippy_utils::{SpanlessEq, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::ExprKind::Assign;
@@ -44,6 +44,8 @@
     "`retain()` is simpler and the same functionalities"
 }
 
+impl_lint_pass!(ManualRetain => [MANUAL_RETAIN]);
+
 pub struct ManualRetain {
     msrv: Msrv,
 }
@@ -54,8 +56,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualRetain => [MANUAL_RETAIN]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualRetain {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if let Assign(left_expr, collect_expr, _) = &expr.kind
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 2c4998204f1f..f99a4bd18690 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -38,6 +38,7 @@
     complexity,
     "manual slice size calculation"
 }
+
 impl_lint_pass!(ManualSliceSizeCalculation => [MANUAL_SLICE_SIZE_CALCULATION]);
 
 pub struct ManualSliceSizeCalculation {
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index 9b590e092d05..a3ff19d34316 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -34,6 +34,7 @@
     pedantic,
     "empty String is being created manually"
 }
+
 declare_lint_pass!(ManualStringNew => [MANUAL_STRING_NEW]);
 
 impl LateLintPass<'_> for ManualStringNew {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index a3f6ea2d8886..526163244596 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -50,6 +50,8 @@
     "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
 }
 
+impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);
+
 pub struct ManualStrip {
     msrv: Msrv,
 }
@@ -60,8 +62,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);
-
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum StripKind {
     Prefix,
diff --git a/clippy_lints/src/manual_take.rs b/clippy_lints/src/manual_take.rs
index 8e74d04c4556..a0c701b6c24a 100644
--- a/clippy_lints/src/manual_take.rs
+++ b/clippy_lints/src/manual_take.rs
@@ -38,6 +38,9 @@
     complexity,
     "manual `mem::take` implementation"
 }
+
+impl_lint_pass!(ManualTake => [MANUAL_TAKE]);
+
 pub struct ManualTake {
     msrv: Msrv,
 }
@@ -48,8 +51,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ManualTake => [MANUAL_TAKE]);
-
 impl LateLintPass<'_> for ManualTake {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::If(cond, then, Some(otherwise)) = expr.kind
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 6f49c5524118..dc8c06ffd79e 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -35,6 +35,796 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::{SpanData, SyntaxContext};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
+    /// without adding any branches.
+    ///
+    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
+    /// cases where merging would most likely make the code more readable.
+    ///
+    /// ### Why is this bad?
+    /// It is unnecessarily verbose and complex.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(n) => match n {
+    ///             Ok(n) => n,
+    ///             _ => return,
+    ///         }
+    ///         None => return,
+    ///     };
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(Ok(n)) => n,
+    ///         _ => return,
+    ///     };
+    /// }
+    /// ```
+    #[clippy::version = "1.50.0"]
+    pub COLLAPSIBLE_MATCH,
+    style,
+    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches being used to destructure a single-variant enum
+    /// or tuple struct where a `let` will suffice.
+    ///
+    /// ### Why is this bad?
+    /// Just readability – `let` doesn't nest, whereas a `match` does.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum Wrapper {
+    ///     Data(i32),
+    /// }
+    ///
+    /// let wrapper = Wrapper::Data(42);
+    ///
+    /// let data = match wrapper {
+    ///     Wrapper::Data(i) => i,
+    /// };
+    /// ```
+    ///
+    /// The correct use would be:
+    /// ```no_run
+    /// enum Wrapper {
+    ///     Data(i32),
+    /// }
+    ///
+    /// let wrapper = Wrapper::Data(42);
+    /// let Wrapper::Data(data) = wrapper;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INFALLIBLE_DESTRUCTURING_MATCH,
+    style,
+    "a `match` statement with a single infallible arm instead of a `let`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `match` which could be implemented using `filter`
+    ///
+    /// ### Why is this bad?
+    /// Using the `filter` method is clearer and more concise.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// match Some(0) {
+    ///     Some(x) => if x % 2 == 0 {
+    ///                     Some(x)
+    ///                } else {
+    ///                     None
+    ///                 },
+    ///     None => None,
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// Some(0).filter(|&x| x % 2 == 0);
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub MANUAL_FILTER,
+    complexity,
+    "reimplementation of `filter`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `match` which could be implemented using `map`
+    ///
+    /// ### Why is this bad?
+    /// Using the `map` method is clearer and more concise.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// match Some(0) {
+    ///     Some(x) => Some(x + 1),
+    ///     None => None,
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// Some(0).map(|x| x + 1);
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub MANUAL_MAP,
+    style,
+    "reimplementation of `map`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementation of `.ok()` or `.err()`
+    /// on `Result` values.
+    ///
+    /// ### Why is this bad?
+    /// Using `.ok()` or `.err()` rather than a `match` or
+    /// `if let` is less complex and more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
+    /// let a = match func() {
+    ///     Ok(v) => Some(v),
+    ///     Err(_) => None,
+    /// };
+    /// let b = if let Err(v) = func() {
+    ///     Some(v)
+    /// } else {
+    ///     None
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
+    /// let a = func().ok();
+    /// let b = func().err();
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_OK_ERR,
+    complexity,
+    "find manual implementations of `.ok()` or `.err()` on `Result`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
+    ///
+    /// ### Why is this bad?
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let foo: Option<i32> = None;
+    /// match foo {
+    ///     Some(v) => v,
+    ///     None => 1,
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let foo: Option<i32> = None;
+    /// foo.unwrap_or(1);
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_UNWRAP_OR,
+    complexity,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if a `match` or `if let` expression can be simplified using
+    /// `.unwrap_or_default()`.
+    ///
+    /// ### Why is this bad?
+    /// It can be done in one call with `.unwrap_or_default()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: Option<String> = Some(String::new());
+    /// let y: String = match x {
+    ///     Some(v) => v,
+    ///     None => String::new(),
+    /// };
+    ///
+    /// let x: Option<Vec<String>> = Some(Vec::new());
+    /// let y: Vec<String> = if let Some(v) = x {
+    ///     v
+    /// } else {
+    ///     Vec::new()
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x: Option<String> = Some(String::new());
+    /// let y: String = x.unwrap_or_default();
+    ///
+    /// let x: Option<Vec<String>> = Some(Vec::new());
+    /// let y: Vec<String> = x.unwrap_or_default();
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub MANUAL_UNWRAP_OR_DEFAULT,
+    suspicious,
+    "check if a `match` or `if let` can be simplified with `unwrap_or_default`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for match which is used to add a reference to an
+    /// `Option` value.
+    ///
+    /// ### Why is this bad?
+    /// Using `as_ref()` or `as_mut()` instead is shorter.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: Option<()> = None;
+    ///
+    /// let r: Option<&()> = match x {
+    ///     None => None,
+    ///     Some(ref v) => Some(v),
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let x: Option<()> = None;
+    ///
+    /// let r: Option<&()> = x.as_ref();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_AS_REF,
+    complexity,
+    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches where match expression is a `bool`. It
+    /// suggests to replace the expression with an `if...else` block.
+    ///
+    /// ### Why is this bad?
+    /// It makes the code less readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// match condition {
+    ///     true => foo(),
+    ///     false => bar(),
+    /// }
+    /// ```
+    /// Use if/else instead:
+    /// ```no_run
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// if condition {
+    ///     foo();
+    /// } else {
+    ///     bar();
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_BOOL,
+    pedantic,
+    "a `match` on a boolean expression instead of an `if..else` block"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match`  or `if let` expressions producing a
+    /// `bool` that could be written using `matches!`
+    ///
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
+    ///
+    /// ### Known problems
+    /// This lint falsely triggers, if there are arms with
+    /// `cfg` attributes that remove an arm evaluating to `false`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = Some(5);
+    ///
+    /// let a = match x {
+    ///     Some(0) => true,
+    ///     _ => false,
+    /// };
+    ///
+    /// let a = if let Some(0) = x {
+    ///     true
+    /// } else {
+    ///     false
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let x = Some(5);
+    /// let a = matches!(x, Some(0));
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub MATCH_LIKE_MATCHES_MACRO,
+    style,
+    "a match that could be written with the matches! macro"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for overlapping match arms.
+    ///
+    /// ### Why is this bad?
+    /// It is likely to be an error and if not, makes the code
+    /// less obvious.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = 5;
+    /// match x {
+    ///     1..=10 => println!("1 ... 10"),
+    ///     5..=15 => println!("5 ... 15"),
+    ///     _ => (),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_OVERLAPPING_ARM,
+    style,
+    "a `match` with overlapping arms"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches where all arms match a reference,
+    /// suggesting to remove the reference and deref the matched expression
+    /// instead. It also checks for `if let &foo = bar` blocks.
+    ///
+    /// ### Why is this bad?
+    /// It just makes the code less readable. That reference
+    /// destructuring adds nothing to the code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// match x {
+    ///     &A(ref y) => foo(y),
+    ///     &B => bar(),
+    ///     _ => frob(&x),
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// match *x {
+    ///     A(ref y) => foo(y),
+    ///     B => bar(),
+    ///     _ => frob(x),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_REF_PATS,
+    style,
+    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match` with identical arm bodies.
+    ///
+    /// Note: Does not lint on wildcards if the `non_exhaustive_omitted_patterns_lint` feature is
+    /// enabled and disallowed.
+    ///
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error. If arm bodies
+    /// are the same on purpose, you can factor them
+    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => bar(), // <= oops
+    /// }
+    /// ```
+    ///
+    /// This should probably be
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => baz(), // <= fixed
+    /// }
+    /// ```
+    ///
+    /// or if the original code was not a typo:
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar | Baz => bar(), // <= shows the intent better
+    ///     Quz => quz(),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_SAME_ARMS,
+    pedantic,
+    "`match` with identical arm bodies"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for useless match that binds to only one value.
+    ///
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
+    ///
+    /// ### Known problems
+    ///  Suggested replacements may be incorrect when `match`
+    /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let a = 1;
+    /// # let b = 2;
+    /// match (a, b) {
+    ///     (c, d) => {
+    ///         // useless match
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let a = 1;
+    /// # let b = 2;
+    /// let (c, d) = (a, b);
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub MATCH_SINGLE_BINDING,
+    complexity,
+    "a match with a single binding instead of using `let` statement"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
+    ///
+    /// ### Why is this bad?
+    /// The arm is unreachable, which is likely a mistake
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "Bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub MATCH_STR_CASE_MISMATCH,
+    correctness,
+    "creation of a case altering match expression with non-compliant arms"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arm which matches all errors with `Err(_)`
+    /// and take drastic actions like `panic!`.
+    ///
+    /// ### Why is this bad?
+    /// It is generally a bad practice, similar to
+    /// catching all exceptions in java with `catch(Exception)`
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: Result<i32, &str> = Ok(3);
+    /// match x {
+    ///     Ok(_) => println!("ok"),
+    ///     Err(_) => panic!("err"),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_WILD_ERR_ARM,
+    pedantic,
+    "a `match` with `Err(_)` arm and take drastic actions"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard enum matches for a single variant.
+    ///
+    /// ### Why is this bad?
+    /// New enum variants added by library updates can be missed.
+    ///
+    /// ### Known problems
+    /// Suggested replacements may not use correct path to enum
+    /// if it's not present in the current scope.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     Foo::C => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    pedantic,
+    "a wildcard enum match for a single variant"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary `match` or match-like `if let` returns for `Option` and `Result`
+    /// when function signatures are the same.
+    ///
+    /// ### Why is this bad?
+    /// This `match` block does nothing and might not be what the coder intended.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo() -> Result<(), i32> {
+    ///     match result {
+    ///         Ok(val) => Ok(val),
+    ///         Err(err) => Err(err),
+    ///     }
+    /// }
+    ///
+    /// fn bar() -> Option<i32> {
+    ///     if let Some(val) = option {
+    ///         Some(val)
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Could be replaced as
+    ///
+    /// ```rust,ignore
+    /// fn foo() -> Result<(), i32> {
+    ///     result
+    /// }
+    ///
+    /// fn bar() -> Option<i32> {
+    ///     option
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub NEEDLESS_MATCH,
+    complexity,
+    "`match` or match-like `if let` that are unnecessary"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary guards in match expressions.
+    ///
+    /// ### Why is this bad?
+    /// It's more complex and much less readable. Making it part of the pattern can improve
+    /// exhaustiveness checking as well.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(x) if matches!(x, Some(1)) => ..,
+    ///     Some(x) if x == Some(2) => ..,
+    ///     _ => todo!(),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(Some(1)) => ..,
+    ///     Some(Some(2)) => ..,
+    ///     _ => todo!(),
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub REDUNDANT_GUARDS,
+    complexity,
+    "checks for unnecessary guards in match expressions"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lint for redundant pattern matching over `Result`, `Option`,
+    /// `std::task::Poll`, `std::net::IpAddr` or `bool`s
+    ///
+    /// ### Why is this bad?
+    /// It's more concise and clear to just use the proper
+    /// utility function or using the condition directly
+    ///
+    /// ### Known problems
+    /// For suggestions involving bindings in patterns, this will change the drop order for the matched type.
+    /// Both `if let` and `while let` will drop the value at the end of the block, both `if` and `while` will drop the
+    /// value before entering the block. For most types this change will not matter, but for a few
+    /// types this will not be an acceptable change (e.g. locks). See the
+    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
+    /// drop order.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if let Ok(_) = Ok::<i32, i32>(42) {}
+    /// if let Err(_) = Err::<i32, i32>(42) {}
+    /// if let None = None::<()> {}
+    /// if let Some(_) = Some(42) {}
+    /// if let Poll::Pending = Poll::Pending::<()> {}
+    /// if let Poll::Ready(_) = Poll::Ready(42) {}
+    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
+    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
+    /// match Ok::<i32, i32>(42) {
+    ///     Ok(_) => true,
+    ///     Err(_) => false,
+    /// };
+    ///
+    /// let cond = true;
+    /// if let true = cond {}
+    /// matches!(cond, true);
+    /// ```
+    ///
+    /// The more idiomatic use would be:
+    ///
+    /// ```no_run
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if Ok::<i32, i32>(42).is_ok() {}
+    /// if Err::<i32, i32>(42).is_err() {}
+    /// if None::<()>.is_none() {}
+    /// if Some(42).is_some() {}
+    /// if Poll::Pending::<()>.is_pending() {}
+    /// if Poll::Ready(42).is_ready() {}
+    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    /// Ok::<i32, i32>(42).is_ok();
+    ///
+    /// let cond = true;
+    /// if cond {}
+    /// cond;
+    /// ```
+    #[clippy::version = "1.31.0"]
+    pub REDUNDANT_PATTERN_MATCHING,
+    style,
+    "use the proper utility function avoiding an `if let`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
+    ///
+    /// ### Why restrict this?
+    /// Correctness and readability. It's like having a wildcard pattern after
+    /// matching all enum variants explicitly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # struct A { a: i32 }
+    /// let a = A { a: 5 };
+    ///
+    /// match a {
+    ///     A { a: 5, .. } => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # struct A { a: i32 }
+    /// # let a = A { a: 5 };
+    /// match a {
+    ///     A { a: 5 } => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    restriction,
+    "a match on a struct that binds all fields but still uses the wildcard pattern"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for temporaries returned from function calls in a match scrutinee that have the
+    /// `clippy::has_significant_drop` attribute.
+    ///
+    /// ### Why is this bad?
+    /// The `clippy::has_significant_drop` attribute can be added to types whose Drop impls have
+    /// an important side-effect, such as unlocking a mutex, making it important for users to be
+    /// able to accurately understand their lifetimes. When a temporary is returned in a function
+    /// call in a match scrutinee, its lifetime lasts until the end of the match block, which may
+    /// be surprising.
+    ///
+    /// For `Mutex`es this can lead to a deadlock. This happens when the match scrutinee uses a
+    /// function call that returns a `MutexGuard` and then tries to lock again in one of the match
+    /// arms. In that case the `MutexGuard` in the scrutinee will not be dropped until the end of
+    /// the match block and thus will not unlock.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// # use std::sync::Mutex;
+    /// # struct State {}
+    /// # impl State {
+    /// #     fn foo(&self) -> bool {
+    /// #         true
+    /// #     }
+    /// #     fn bar(&self) {}
+    /// # }
+    /// let mutex = Mutex::new(State {});
+    ///
+    /// match mutex.lock().unwrap().foo() {
+    ///     true => {
+    ///         mutex.lock().unwrap().bar(); // Deadlock!
+    ///     }
+    ///     false => {}
+    /// };
+    ///
+    /// println!("All done!");
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::sync::Mutex;
+    /// # struct State {}
+    /// # impl State {
+    /// #     fn foo(&self) -> bool {
+    /// #         true
+    /// #     }
+    /// #     fn bar(&self) {}
+    /// # }
+    /// let mutex = Mutex::new(State {});
+    ///
+    /// let is_foo = mutex.lock().unwrap().foo();
+    /// match is_foo {
+    ///     true => {
+    ///         mutex.lock().unwrap().bar();
+    ///     }
+    ///     false => {}
+    /// };
+    ///
+    /// println!("All done!");
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub SIGNIFICANT_DROP_IN_SCRUTINEE,
+    nursery,
+    "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for matches with a single arm where an `if let`
@@ -116,146 +906,37 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for matches where all arms match a reference,
-    /// suggesting to remove the reference and deref the matched expression
-    /// instead. It also checks for `if let &foo = bar` blocks.
+    /// Checks for usage of `Err(x)?`.
     ///
-    /// ### Why is this bad?
-    /// It just makes the code less readable. That reference
-    /// destructuring adds nothing to the code.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match x {
-    ///     &A(ref y) => foo(y),
-    ///     &B => bar(),
-    ///     _ => frob(&x),
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// match *x {
-    ///     A(ref y) => foo(y),
-    ///     B => bar(),
-    ///     _ => frob(x),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_REF_PATS,
-    style,
-    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches where match expression is a `bool`. It
-    /// suggests to replace the expression with an `if...else` block.
-    ///
-    /// ### Why is this bad?
-    /// It makes the code less readable.
+    /// ### Why restrict this?
+    /// The `?` operator is designed to allow calls that
+    /// can fail to be easily chained. For example, `foo()?.bar()` or
+    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
+    /// always return), it is more clear to write `return Err(x)`.
     ///
     /// ### Example
     /// ```no_run
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// match condition {
-    ///     true => foo(),
-    ///     false => bar(),
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       Err("failed")?;
+    ///     }
+    ///     Ok(0)
     /// }
     /// ```
-    /// Use if/else instead:
+    /// Could be written:
+    ///
     /// ```no_run
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// if condition {
-    ///     foo();
-    /// } else {
-    ///     bar();
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       return Err("failed".into());
+    ///     }
+    ///     Ok(0)
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_BOOL,
-    pedantic,
-    "a `match` on a boolean expression instead of an `if..else` block"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for overlapping match arms.
-    ///
-    /// ### Why is this bad?
-    /// It is likely to be an error and if not, makes the code
-    /// less obvious.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = 5;
-    /// match x {
-    ///     1..=10 => println!("1 ... 10"),
-    ///     5..=15 => println!("5 ... 15"),
-    ///     _ => (),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_OVERLAPPING_ARM,
-    style,
-    "a `match` with overlapping arms"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for arm which matches all errors with `Err(_)`
-    /// and take drastic actions like `panic!`.
-    ///
-    /// ### Why is this bad?
-    /// It is generally a bad practice, similar to
-    /// catching all exceptions in java with `catch(Exception)`
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: Result<i32, &str> = Ok(3);
-    /// match x {
-    ///     Ok(_) => println!("ok"),
-    ///     Err(_) => panic!("err"),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_WILD_ERR_ARM,
-    pedantic,
-    "a `match` with `Err(_)` arm and take drastic actions"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for match which is used to add a reference to an
-    /// `Option` value.
-    ///
-    /// ### Why is this bad?
-    /// Using `as_ref()` or `as_mut()` instead is shorter.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: Option<()> = None;
-    ///
-    /// let r: Option<&()> = match x {
-    ///     None => None,
-    ///     Some(ref v) => Some(v),
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x: Option<()> = None;
-    ///
-    /// let r: Option<&()> = x.as_ref();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_AS_REF,
-    complexity,
-    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
+    #[clippy::version = "1.38.0"]
+    pub TRY_ERR,
+    restriction,
+    "return errors explicitly rather than hiding them behind a `?`"
 }
 
 declare_clippy_lint! {
@@ -294,44 +975,6 @@
     "a wildcard enum match arm using `_`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard enum matches for a single variant.
-    ///
-    /// ### Why is this bad?
-    /// New enum variants added by library updates can be missed.
-    ///
-    /// ### Known problems
-    /// Suggested replacements may not use correct path to enum
-    /// if it's not present in the current scope.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
-    /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
-    /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     Foo::C => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    pedantic,
-    "a wildcard enum match for a single variant"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for wildcard pattern used with others patterns in same match arm.
@@ -363,648 +1006,35 @@
     "a wildcard pattern used with others patterns in same match arm"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches being used to destructure a single-variant enum
-    /// or tuple struct where a `let` will suffice.
-    ///
-    /// ### Why is this bad?
-    /// Just readability – `let` doesn't nest, whereas a `match` does.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// enum Wrapper {
-    ///     Data(i32),
-    /// }
-    ///
-    /// let wrapper = Wrapper::Data(42);
-    ///
-    /// let data = match wrapper {
-    ///     Wrapper::Data(i) => i,
-    /// };
-    /// ```
-    ///
-    /// The correct use would be:
-    /// ```no_run
-    /// enum Wrapper {
-    ///     Data(i32),
-    /// }
-    ///
-    /// let wrapper = Wrapper::Data(42);
-    /// let Wrapper::Data(data) = wrapper;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INFALLIBLE_DESTRUCTURING_MATCH,
-    style,
-    "a `match` statement with a single infallible arm instead of a `let`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for useless match that binds to only one value.
-    ///
-    /// ### Why is this bad?
-    /// Readability and needless complexity.
-    ///
-    /// ### Known problems
-    ///  Suggested replacements may be incorrect when `match`
-    /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let a = 1;
-    /// # let b = 2;
-    /// match (a, b) {
-    ///     (c, d) => {
-    ///         // useless match
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let a = 1;
-    /// # let b = 2;
-    /// let (c, d) = (a, b);
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub MATCH_SINGLE_BINDING,
-    complexity,
-    "a match with a single binding instead of using `let` statement"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
-    ///
-    /// ### Why restrict this?
-    /// Correctness and readability. It's like having a wildcard pattern after
-    /// matching all enum variants explicitly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # struct A { a: i32 }
-    /// let a = A { a: 5 };
-    ///
-    /// match a {
-    ///     A { a: 5, .. } => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # struct A { a: i32 }
-    /// # let a = A { a: 5 };
-    /// match a {
-    ///     A { a: 5 } => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    restriction,
-    "a match on a struct that binds all fields but still uses the wildcard pattern"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lint for redundant pattern matching over `Result`, `Option`,
-    /// `std::task::Poll`, `std::net::IpAddr` or `bool`s
-    ///
-    /// ### Why is this bad?
-    /// It's more concise and clear to just use the proper
-    /// utility function or using the condition directly
-    ///
-    /// ### Known problems
-    /// For suggestions involving bindings in patterns, this will change the drop order for the matched type.
-    /// Both `if let` and `while let` will drop the value at the end of the block, both `if` and `while` will drop the
-    /// value before entering the block. For most types this change will not matter, but for a few
-    /// types this will not be an acceptable change (e.g. locks). See the
-    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
-    /// drop order.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if let Ok(_) = Ok::<i32, i32>(42) {}
-    /// if let Err(_) = Err::<i32, i32>(42) {}
-    /// if let None = None::<()> {}
-    /// if let Some(_) = Some(42) {}
-    /// if let Poll::Pending = Poll::Pending::<()> {}
-    /// if let Poll::Ready(_) = Poll::Ready(42) {}
-    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
-    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
-    /// match Ok::<i32, i32>(42) {
-    ///     Ok(_) => true,
-    ///     Err(_) => false,
-    /// };
-    ///
-    /// let cond = true;
-    /// if let true = cond {}
-    /// matches!(cond, true);
-    /// ```
-    ///
-    /// The more idiomatic use would be:
-    ///
-    /// ```no_run
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if Ok::<i32, i32>(42).is_ok() {}
-    /// if Err::<i32, i32>(42).is_err() {}
-    /// if None::<()>.is_none() {}
-    /// if Some(42).is_some() {}
-    /// if Poll::Pending::<()>.is_pending() {}
-    /// if Poll::Ready(42).is_ready() {}
-    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
-    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
-    /// Ok::<i32, i32>(42).is_ok();
-    ///
-    /// let cond = true;
-    /// if cond {}
-    /// cond;
-    /// ```
-    #[clippy::version = "1.31.0"]
-    pub REDUNDANT_PATTERN_MATCHING,
-    style,
-    "use the proper utility function avoiding an `if let`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match`  or `if let` expressions producing a
-    /// `bool` that could be written using `matches!`
-    ///
-    /// ### Why is this bad?
-    /// Readability and needless complexity.
-    ///
-    /// ### Known problems
-    /// This lint falsely triggers, if there are arms with
-    /// `cfg` attributes that remove an arm evaluating to `false`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = Some(5);
-    ///
-    /// let a = match x {
-    ///     Some(0) => true,
-    ///     _ => false,
-    /// };
-    ///
-    /// let a = if let Some(0) = x {
-    ///     true
-    /// } else {
-    ///     false
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x = Some(5);
-    /// let a = matches!(x, Some(0));
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub MATCH_LIKE_MATCHES_MACRO,
-    style,
-    "a match that could be written with the matches! macro"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match` with identical arm bodies.
-    ///
-    /// Note: Does not lint on wildcards if the `non_exhaustive_omitted_patterns_lint` feature is
-    /// enabled and disallowed.
-    ///
-    /// ### Why is this bad?
-    /// This is probably a copy & paste error. If arm bodies
-    /// are the same on purpose, you can factor them
-    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => bar(), // <= oops
-    /// }
-    /// ```
-    ///
-    /// This should probably be
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => baz(), // <= fixed
-    /// }
-    /// ```
-    ///
-    /// or if the original code was not a typo:
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar | Baz => bar(), // <= shows the intent better
-    ///     Quz => quz(),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_SAME_ARMS,
-    pedantic,
-    "`match` with identical arm bodies"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary `match` or match-like `if let` returns for `Option` and `Result`
-    /// when function signatures are the same.
-    ///
-    /// ### Why is this bad?
-    /// This `match` block does nothing and might not be what the coder intended.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// fn foo() -> Result<(), i32> {
-    ///     match result {
-    ///         Ok(val) => Ok(val),
-    ///         Err(err) => Err(err),
-    ///     }
-    /// }
-    ///
-    /// fn bar() -> Option<i32> {
-    ///     if let Some(val) = option {
-    ///         Some(val)
-    ///     } else {
-    ///         None
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Could be replaced as
-    ///
-    /// ```rust,ignore
-    /// fn foo() -> Result<(), i32> {
-    ///     result
-    /// }
-    ///
-    /// fn bar() -> Option<i32> {
-    ///     option
-    /// }
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub NEEDLESS_MATCH,
-    complexity,
-    "`match` or match-like `if let` that are unnecessary"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
-    /// without adding any branches.
-    ///
-    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
-    /// cases where merging would most likely make the code more readable.
-    ///
-    /// ### Why is this bad?
-    /// It is unnecessarily verbose and complex.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(n) => match n {
-    ///             Ok(n) => n,
-    ///             _ => return,
-    ///         }
-    ///         None => return,
-    ///     };
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(Ok(n)) => n,
-    ///         _ => return,
-    ///     };
-    /// }
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub COLLAPSIBLE_MATCH,
-    style,
-    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
-    ///
-    /// ### Why is this bad?
-    /// Concise code helps focusing on behavior instead of boilerplate.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// match foo {
-    ///     Some(v) => v,
-    ///     None => 1,
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.unwrap_or(1);
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_UNWRAP_OR,
-    complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if a `match` or `if let` expression can be simplified using
-    /// `.unwrap_or_default()`.
-    ///
-    /// ### Why is this bad?
-    /// It can be done in one call with `.unwrap_or_default()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: Option<String> = Some(String::new());
-    /// let y: String = match x {
-    ///     Some(v) => v,
-    ///     None => String::new(),
-    /// };
-    ///
-    /// let x: Option<Vec<String>> = Some(Vec::new());
-    /// let y: Vec<String> = if let Some(v) = x {
-    ///     v
-    /// } else {
-    ///     Vec::new()
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x: Option<String> = Some(String::new());
-    /// let y: String = x.unwrap_or_default();
-    ///
-    /// let x: Option<Vec<String>> = Some(Vec::new());
-    /// let y: Vec<String> = x.unwrap_or_default();
-    /// ```
-    #[clippy::version = "1.79.0"]
-    pub MANUAL_UNWRAP_OR_DEFAULT,
-    suspicious,
-    "check if a `match` or `if let` can be simplified with `unwrap_or_default`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
-    ///
-    /// ### Why is this bad?
-    /// The arm is unreachable, which is likely a mistake
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "Bar" => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "bar" => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.58.0"]
-    pub MATCH_STR_CASE_MISMATCH,
-    correctness,
-    "creation of a case altering match expression with non-compliant arms"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for temporaries returned from function calls in a match scrutinee that have the
-    /// `clippy::has_significant_drop` attribute.
-    ///
-    /// ### Why is this bad?
-    /// The `clippy::has_significant_drop` attribute can be added to types whose Drop impls have
-    /// an important side-effect, such as unlocking a mutex, making it important for users to be
-    /// able to accurately understand their lifetimes. When a temporary is returned in a function
-    /// call in a match scrutinee, its lifetime lasts until the end of the match block, which may
-    /// be surprising.
-    ///
-    /// For `Mutex`es this can lead to a deadlock. This happens when the match scrutinee uses a
-    /// function call that returns a `MutexGuard` and then tries to lock again in one of the match
-    /// arms. In that case the `MutexGuard` in the scrutinee will not be dropped until the end of
-    /// the match block and thus will not unlock.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// # use std::sync::Mutex;
-    /// # struct State {}
-    /// # impl State {
-    /// #     fn foo(&self) -> bool {
-    /// #         true
-    /// #     }
-    /// #     fn bar(&self) {}
-    /// # }
-    /// let mutex = Mutex::new(State {});
-    ///
-    /// match mutex.lock().unwrap().foo() {
-    ///     true => {
-    ///         mutex.lock().unwrap().bar(); // Deadlock!
-    ///     }
-    ///     false => {}
-    /// };
-    ///
-    /// println!("All done!");
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::sync::Mutex;
-    /// # struct State {}
-    /// # impl State {
-    /// #     fn foo(&self) -> bool {
-    /// #         true
-    /// #     }
-    /// #     fn bar(&self) {}
-    /// # }
-    /// let mutex = Mutex::new(State {});
-    ///
-    /// let is_foo = mutex.lock().unwrap().foo();
-    /// match is_foo {
-    ///     true => {
-    ///         mutex.lock().unwrap().bar();
-    ///     }
-    ///     false => {}
-    /// };
-    ///
-    /// println!("All done!");
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub SIGNIFICANT_DROP_IN_SCRUTINEE,
-    nursery,
-    "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Err(x)?`.
-    ///
-    /// ### Why restrict this?
-    /// The `?` operator is designed to allow calls that
-    /// can fail to be easily chained. For example, `foo()?.bar()` or
-    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
-    /// always return), it is more clear to write `return Err(x)`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       Err("failed")?;
-    ///     }
-    ///     Ok(0)
-    /// }
-    /// ```
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       return Err("failed".into());
-    ///     }
-    ///     Ok(0)
-    /// }
-    /// ```
-    #[clippy::version = "1.38.0"]
-    pub TRY_ERR,
-    restriction,
-    "return errors explicitly rather than hiding them behind a `?`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `match` which could be implemented using `map`
-    ///
-    /// ### Why is this bad?
-    /// Using the `map` method is clearer and more concise.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// match Some(0) {
-    ///     Some(x) => Some(x + 1),
-    ///     None => None,
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// Some(0).map(|x| x + 1);
-    /// ```
-    #[clippy::version = "1.52.0"]
-    pub MANUAL_MAP,
-    style,
-    "reimplementation of `map`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `match` which could be implemented using `filter`
-    ///
-    /// ### Why is this bad?
-    /// Using the `filter` method is clearer and more concise.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// match Some(0) {
-    ///     Some(x) => if x % 2 == 0 {
-    ///                     Some(x)
-    ///                } else {
-    ///                     None
-    ///                 },
-    ///     None => None,
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// Some(0).filter(|&x| x % 2 == 0);
-    /// ```
-    #[clippy::version = "1.66.0"]
-    pub MANUAL_FILTER,
-    complexity,
-    "reimplementation of `filter`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary guards in match expressions.
-    ///
-    /// ### Why is this bad?
-    /// It's more complex and much less readable. Making it part of the pattern can improve
-    /// exhaustiveness checking as well.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match x {
-    ///     Some(x) if matches!(x, Some(1)) => ..,
-    ///     Some(x) if x == Some(2) => ..,
-    ///     _ => todo!(),
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// match x {
-    ///     Some(Some(1)) => ..,
-    ///     Some(Some(2)) => ..,
-    ///     _ => todo!(),
-    /// }
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub REDUNDANT_GUARDS,
-    complexity,
-    "checks for unnecessary guards in match expressions"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementation of `.ok()` or `.err()`
-    /// on `Result` values.
-    ///
-    /// ### Why is this bad?
-    /// Using `.ok()` or `.err()` rather than a `match` or
-    /// `if let` is less complex and more readable.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
-    /// let a = match func() {
-    ///     Ok(v) => Some(v),
-    ///     Err(_) => None,
-    /// };
-    /// let b = if let Err(v) = func() {
-    ///     Some(v)
-    /// } else {
-    ///     None
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
-    /// let a = func().ok();
-    /// let b = func().err();
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_OK_ERR,
-    complexity,
-    "find manual implementations of `.ok()` or `.err()` on `Result`"
-}
+impl_lint_pass!(Matches => [
+    COLLAPSIBLE_MATCH,
+    INFALLIBLE_DESTRUCTURING_MATCH,
+    MANUAL_FILTER,
+    MANUAL_MAP,
+    MANUAL_OK_ERR,
+    MANUAL_UNWRAP_OR,
+    MANUAL_UNWRAP_OR_DEFAULT,
+    MATCH_AS_REF,
+    MATCH_BOOL,
+    MATCH_LIKE_MATCHES_MACRO,
+    MATCH_OVERLAPPING_ARM,
+    MATCH_REF_PATS,
+    MATCH_SAME_ARMS,
+    MATCH_SINGLE_BINDING,
+    MATCH_STR_CASE_MISMATCH,
+    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    MATCH_WILD_ERR_ARM,
+    NEEDLESS_MATCH,
+    REDUNDANT_GUARDS,
+    REDUNDANT_PATTERN_MATCHING,
+    REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    SIGNIFICANT_DROP_IN_SCRUTINEE,
+    SINGLE_MATCH,
+    SINGLE_MATCH_ELSE,
+    TRY_ERR,
+    WILDCARD_ENUM_MATCH_ARM,
+    WILDCARD_IN_OR_PATTERNS,
+]);
 
 pub struct Matches {
     msrv: Msrv,
@@ -1020,36 +1050,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Matches => [
-    SINGLE_MATCH,
-    MATCH_REF_PATS,
-    MATCH_BOOL,
-    SINGLE_MATCH_ELSE,
-    MATCH_OVERLAPPING_ARM,
-    MATCH_WILD_ERR_ARM,
-    MATCH_AS_REF,
-    WILDCARD_ENUM_MATCH_ARM,
-    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    WILDCARD_IN_OR_PATTERNS,
-    MATCH_SINGLE_BINDING,
-    INFALLIBLE_DESTRUCTURING_MATCH,
-    REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    REDUNDANT_PATTERN_MATCHING,
-    MATCH_LIKE_MATCHES_MACRO,
-    MATCH_SAME_ARMS,
-    NEEDLESS_MATCH,
-    COLLAPSIBLE_MATCH,
-    MANUAL_UNWRAP_OR,
-    MANUAL_UNWRAP_OR_DEFAULT,
-    MATCH_STR_CASE_MISMATCH,
-    SIGNIFICANT_DROP_IN_SCRUTINEE,
-    TRY_ERR,
-    MANUAL_MAP,
-    MANUAL_FILTER,
-    REDUNDANT_GUARDS,
-    MANUAL_OK_ERR,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Matches {
     #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index d8f4ee9b3189..43f0e5f8b639 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -5,7 +5,9 @@
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{as_some_expr, is_default_equivalent, is_expr_used_or_unified, is_none_expr, peel_ref_operators, std_or_core, sym};
+use clippy_utils::{
+    as_some_expr, is_default_equivalent, is_expr_used_or_unified, is_none_expr, peel_ref_operators, std_or_core, sym,
+};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -65,6 +67,31 @@
     "replacing an `Option` with `Some` instead of `replace()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `std::mem::replace` on a value of type
+    /// `T` with `T::default()`.
+    ///
+    /// ### Why is this bad?
+    /// `std::mem` module already has the method `take` to
+    /// take the current value and replace it with the default value of that type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut text = String::from("foo");
+    /// let replaced = std::mem::replace(&mut text, String::default());
+    /// ```
+    /// Is better expressed with:
+    /// ```no_run
+    /// let mut text = String::from("foo");
+    /// let taken = std::mem::take(&mut text);
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub MEM_REPLACE_WITH_DEFAULT,
+    style,
+    "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `mem::replace(&mut _, mem::uninitialized())`
@@ -97,33 +124,12 @@
     "`mem::replace(&mut _, mem::uninitialized())` or `mem::replace(&mut _, mem::zeroed())`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `std::mem::replace` on a value of type
-    /// `T` with `T::default()`.
-    ///
-    /// ### Why is this bad?
-    /// `std::mem` module already has the method `take` to
-    /// take the current value and replace it with the default value of that type.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut text = String::from("foo");
-    /// let replaced = std::mem::replace(&mut text, String::default());
-    /// ```
-    /// Is better expressed with:
-    /// ```no_run
-    /// let mut text = String::from("foo");
-    /// let taken = std::mem::take(&mut text);
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub MEM_REPLACE_WITH_DEFAULT,
-    style,
-    "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
-}
-
-impl_lint_pass!(MemReplace =>
-    [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_OPTION_WITH_SOME, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
+impl_lint_pass!(MemReplace => [
+    MEM_REPLACE_OPTION_WITH_NONE,
+    MEM_REPLACE_OPTION_WITH_SOME,
+    MEM_REPLACE_WITH_DEFAULT,
+    MEM_REPLACE_WITH_UNINIT,
+]);
 
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) -> bool {
     if is_none_expr(cx, src) {
diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index e6a8acb9c72e..cd6b39b15a1b 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_range_full, sym};
 use clippy_utils::res::MaybeDef;
+use clippy_utils::{is_range_full, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index a2ed55796887..15f3adf3405e 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_parent_expr, sym};
 use clippy_utils::res::MaybeDef;
+use clippy_utils::{get_parent_expr, sym};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::Span;
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 66ab3075f715..9c6b16b88bfd 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::{path_to_local_with_projections, sym};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{path_to_local_with_projections, sym};
 use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 7b0ac90ced6c..996668edac6a 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -3,8 +3,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{sugg, sym};
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{sugg, sym};
 use rustc_ast::join_path_idents;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 76499c5bd9e6..676f1b13b16e 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,7 +1,7 @@
 use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_parent_expr, sym};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_parent_expr, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index a8ea43cf73e3..6e998ccf896d 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{expr_or_init, sym};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
+use clippy_utils::{expr_or_init, sym};
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/join_absolute_paths.rs b/clippy_lints/src/methods/join_absolute_paths.rs
index 248c76181250..fe3ca632d6e3 100644
--- a/clippy_lints/src/methods/join_absolute_paths.rs
+++ b/clippy_lints/src/methods/join_absolute_paths.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{expr_or_init, sym};
 use clippy_utils::res::MaybeDef;
 use clippy_utils::source::snippet;
+use clippy_utils::{expr_or_init, sym};
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 74db7ae03ba0..0ed166f8dd5b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -163,495 +163,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, Symbol};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `cloned()` on an `Iterator` or `Option` where
-    /// `copied()` could be used instead.
-    ///
-    /// ### Why is this bad?
-    /// `copied()` is better because it guarantees that the type being cloned
-    /// implements `Copy`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// [1, 2, 3].iter().cloned();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// [1, 2, 3].iter().copied();
-    /// ```
-    #[clippy::version = "1.53.0"]
-    pub CLONED_INSTEAD_OF_COPIED,
-    pedantic,
-    "used `cloned` where `copied` could be used instead"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for consecutive calls to `str::replace` (2 or more)
-    /// that can be collapsed into a single call.
-    ///
-    /// ### Why is this bad?
-    /// Consecutive `str::replace` calls scan the string multiple times
-    /// with repetitive code.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let hello = "hesuo worpd"
-    ///     .replace('s', "l")
-    ///     .replace("u", "l")
-    ///     .replace('p', "l");
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
-    /// ```
-    #[clippy::version = "1.65.0"]
-    pub COLLAPSIBLE_STR_REPLACE,
-    perf,
-    "collapse consecutive calls to str::replace (2 or more) into a single call"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
-    ///
-    /// ### Why is this bad?
-    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
-    /// of them will be consumed.
-    ///
-    /// ### Known Problems
-    /// This `lint` removes the side of effect of cloning items in the iterator.
-    /// A code that relies on that side-effect could fail.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// # let vec = vec!["string".to_string()];
-    /// vec.iter().cloned().take(10);
-    /// vec.iter().cloned().last();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let vec = vec!["string".to_string()];
-    /// vec.iter().take(10).cloned();
-    /// vec.iter().last().cloned();
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub ITER_OVEREAGER_CLONED,
-    perf,
-    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be
-    /// used instead.
-    ///
-    /// ### Why is this bad?
-    /// `filter_map()` is known to always produce 0 or 1 output items per input item,
-    /// rather than however many the inner iterator type produces.
-    /// Therefore, it maintains the upper bound in `Iterator::size_hint()`,
-    /// and communicates to the reader that the input items are not being expanded into
-    /// multiple output items without their having to notice that the mapping function
-    /// returns an `Option`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
-    /// ```
-    #[clippy::version = "1.53.0"]
-    pub FLAT_MAP_OPTION,
-    pedantic,
-    "used `flat_map` where `filter_map` could be used instead"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
-    ///
-    /// ### Why restrict this?
-    /// It is better to handle the `None` or `Err` case,
-    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
-    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
-    /// `Allow` by default.
-    ///
-    /// `result.unwrap()` will let the thread panic on `Err` values.
-    /// Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
-    ///
-    /// Even if you want to panic on errors, not all `Error`s implement good
-    /// messages on display. Therefore, it may be beneficial to look at the places
-    /// where they may get displayed. Activate this lint to do just that.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.unwrap();
-    /// result.unwrap();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.expect("more helpful message");
-    /// result.expect("more helpful message");
-    /// ```
-    ///
-    /// If [expect_used](#expect_used) is enabled, instead:
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option?;
-    ///
-    /// // or
-    ///
-    /// result?;
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub UNWRAP_USED,
-    restriction,
-    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.unwrap()` related calls on `Result`s and `Option`s that are constructed.
-    ///
-    /// ### Why is this bad?
-    /// It is better to write the value directly without the indirection.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// let val1 = Some(1).unwrap();
-    /// let val2 = Ok::<_, ()>(1).unwrap();
-    /// let val3 = Err::<(), _>(1).unwrap_err();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let val1 = 1;
-    /// let val2 = 1;
-    /// let val3 = 1;
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub UNNECESSARY_LITERAL_UNWRAP,
-    complexity,
-    "using `unwrap()` related calls on `Result` and `Option` constructors"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
-    ///
-    /// ### Why restrict this?
-    /// Usually it is better to handle the `None` or `Err` case.
-    /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
-    /// this lint is `Allow` by default.
-    ///
-    /// `result.expect()` will let the thread panic on `Err`
-    /// values. Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
-    ///
-    /// ### Examples
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.expect("one");
-    /// result.expect("one");
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option?;
-    ///
-    /// // or
-    ///
-    /// result?;
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub EXPECT_USED,
-    restriction,
-    "using `.expect()` on `Result` or `Option`, which might be better handled"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for methods that should live in a trait
-    /// implementation of a `std` trait (see [llogiq's blog
-    /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
-    /// information) instead of an inherent implementation.
-    ///
-    /// ### Why is this bad?
-    /// Implementing the traits improve ergonomics for users of
-    /// the code, often with very little cost. Also people seeing a `mul(...)`
-    /// method
-    /// may expect `*` to work equally, so you should have good reason to disappoint
-    /// them.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct X;
-    /// impl X {
-    ///     fn add(&self, other: &X) -> X {
-    ///         // ..
-    /// # X
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SHOULD_IMPLEMENT_TRAIT,
-    style,
-    "defining a method that should be implementing a std trait"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for methods with certain name prefixes or suffixes, and which
-    /// do not adhere to standard conventions regarding how `self` is taken.
-    /// The actual rules are:
-    ///
-    /// |Prefix |Postfix     |`self` taken                   | `self` type  |
-    /// |-------|------------|-------------------------------|--------------|
-    /// |`as_`  | none       |`&self` or `&mut self`         | any          |
-    /// |`from_`| none       | none                          | any          |
-    /// |`into_`| none       |`self`                         | any          |
-    /// |`is_`  | none       |`&mut self` or `&self` or none | any          |
-    /// |`to_`  | `_mut`     |`&mut self`                    | any          |
-    /// |`to_`  | not `_mut` |`self`                         | `Copy`       |
-    /// |`to_`  | not `_mut` |`&self`                        | not `Copy`   |
-    ///
-    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
-    /// - Traits definition.
-    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
-    /// - Traits implementation, when `&self` is taken.
-    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
-    /// (see e.g. the `std::string::ToString` trait).
-    ///
-    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
-    ///
-    /// Please find more info here:
-    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
-    ///
-    /// ### Why is this bad?
-    /// Consistency breeds readability. If you follow the
-    /// conventions, your users won't be surprised that they, e.g., need to supply a
-    /// mutable reference to a `as_..` function.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # struct X;
-    /// impl X {
-    ///     fn as_str(self) -> &'static str {
-    ///         // ..
-    /// # ""
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # struct X;
-    /// impl X {
-    ///     fn as_str(&self) -> &'static str {
-    ///         // ..
-    /// # ""
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WRONG_SELF_CONVENTION,
-    style,
-    "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `ok().expect(..)`.
-    ///
-    /// Note: This lint only triggers for code marked compatible
-    /// with versions of the compiler older than Rust 1.82.0.
-    ///
-    /// ### Why is this bad?
-    /// Because you usually call `expect()` on the `Result`
-    /// directly to get a better error message.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = Ok::<_, ()>(());
-    /// x.ok().expect("why did I do this again?");
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = Ok::<_, ()>(());
-    /// x.expect("why did I do this again?");
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OK_EXPECT,
-    style,
-    "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.err().expect()` calls on the `Result` type.
-    ///
-    /// ### Why is this bad?
-    /// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.
-    ///
-    /// ### Example
-    /// ```should_panic
-    /// let x: Result<u32, &str> = Ok(10);
-    /// x.err().expect("Testing err().expect()");
-    /// ```
-    /// Use instead:
-    /// ```should_panic
-    /// let x: Result<u32, &str> = Ok(10);
-    /// x.expect_err("Testing expect_err");
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub ERR_EXPECT,
-    style,
-    r#"using `.err().expect("")` when `.expect_err("")` can be used"#
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usages of the following functions with an argument that constructs a default value
-    /// (e.g., `Default::default` or `String::new`):
-    /// - `unwrap_or`
-    /// - `unwrap_or_else`
-    /// - `or_insert`
-    /// - `or_insert_with`
-    ///
-    /// ### Why is this bad?
-    /// Readability. Using `unwrap_or_default` in place of `unwrap_or`/`unwrap_or_else`, or `or_default`
-    /// in place of `or_insert`/`or_insert_with`, is simpler and more concise.
-    ///
-    /// ### Known problems
-    /// In some cases, the argument of `unwrap_or`, etc. is needed for type inference. The lint uses a
-    /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// # let x = Some(1);
-    /// # let mut map = std::collections::HashMap::<u64, String>::new();
-    /// x.unwrap_or(Default::default());
-    /// map.entry(42).or_insert_with(String::new);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = Some(1);
-    /// # let mut map = std::collections::HashMap::<u64, String>::new();
-    /// x.unwrap_or_default();
-    /// map.entry(42).or_default();
-    /// ```
-    #[clippy::version = "1.56.0"]
-    pub UNWRAP_OR_DEFAULT,
-    style,
-    "using `.unwrap_or`, etc. with an argument that constructs a default value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
-    /// `result.map(_).unwrap_or_else(_)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, these can be written more concisely (resp.) as
-    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
-    ///
-    /// ### Known problems
-    /// The order of the arguments is not in execution order
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// # fn some_function(foo: ()) -> usize { 1 }
-    /// option.map(|a| a + 1).unwrap_or(0);
-    /// option.map(|a| a > 10).unwrap_or(false);
-    /// result.map(|a| a + 1).unwrap_or_else(some_function);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// # fn some_function(foo: ()) -> usize { 1 }
-    /// option.map_or(0, |a| a + 1);
-    /// option.is_some_and(|a| a > 10);
-    /// result.map_or_else(some_function, |a| a + 1);
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub MAP_UNWRAP_OR,
-    pedantic,
-    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.map_or(None, _)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.and_then(_)`.
-    ///
-    /// ### Known problems
-    /// The order of the arguments is not in execution order.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.map_or(None, |a| Some(a + 1));
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.and_then(|a| Some(a + 1));
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OPTION_MAP_OR_NONE,
-    style,
-    "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.map_or(None, Some)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.ok()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let r: Result<u32, &str> = Ok(1);
-    /// assert_eq!(Some(1), r.map_or(None, Some));
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let r: Result<u32, &str> = Ok(1);
-    /// assert_eq!(Some(1), r.ok());
-    /// ```
-    #[clippy::version = "1.44.0"]
-    pub RESULT_MAP_OR_INTO_OPTION,
-    style,
-    "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))`
@@ -686,211 +197,104 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.filter(_).next()`.
+    /// It checks for `str::bytes().count()` and suggests replacing it with
+    /// `str::len()`.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.find(_)`.
+    /// `str::bytes().count()` is longer and may not be as performant as using
+    /// `str::len()`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().filter(|x| **x == 0).next();
+    /// "hello".bytes().count();
+    /// String::from("hello").bytes().count();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().find(|x| **x == 0);
+    /// "hello".len();
+    /// String::from("hello").len();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FILTER_NEXT,
+    #[clippy::version = "1.62.0"]
+    pub BYTES_COUNT_TO_LEN,
     complexity,
-    "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
+    "Using `bytes().count()` when `len()` performs the same functionality"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.skip_while(condition).next()`.
+    /// Checks for the use of `.bytes().nth()`.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.find(!condition)`.
+    /// `.as_bytes().get()` is more efficient and more
+    /// readable.
     ///
     /// ### Example
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().skip_while(|x| **x == 0).next();
+    /// "Hello".bytes().nth(3);
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().find(|x| **x != 0);
+    /// "Hello".as_bytes().get(3);
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub SKIP_WHILE_NEXT,
-    complexity,
-    "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
+    #[clippy::version = "1.52.0"]
+    pub BYTES_NTH,
+    style,
+    "replace `.bytes().nth()` with `.as_bytes().get()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![vec![1]];
-    /// let opt = Some(5);
-    ///
-    /// vec.iter().map(|x| x.iter()).flatten();
-    /// opt.map(|x| Some(x * 2)).flatten();
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let vec = vec![vec![1]];
-    /// # let opt = Some(5);
-    /// vec.iter().flat_map(|x| x.iter());
-    /// opt.and_then(|x| Some(x * 2));
-    /// ```
-    #[clippy::version = "1.31.0"]
-    pub MAP_FLATTEN,
-    complexity,
-    "using combinations of `flatten` and `map` which can usually be written as a single method call"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
-    /// as `filter_map(_)`.
-    ///
-    /// ### Why is this bad?
-    /// Redundant code in the `filter` and `map` operations is poor style and
-    /// less performant.
-    ///
-     /// ### Example
-    /// ```no_run
-    /// (0_i32..10)
-    ///     .filter(|n| n.checked_add(1).is_some())
-    ///     .map(|n| n.checked_add(1).unwrap());
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     let filename = std::path::Path::new(filename);
+    ///     filename.extension()
+    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    /// }
     /// ```
     #[clippy::version = "1.51.0"]
-    pub MANUAL_FILTER_MAP,
-    complexity,
-    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
-    /// as `find_map(_)`.
-    ///
-    /// ### Why is this bad?
-    /// Redundant code in the `find` and `map` operations is poor style and
-    /// less performant.
-    ///
-     /// ### Example
-    /// ```no_run
-    /// (0_i32..10)
-    ///     .find(|n| n.checked_add(1).is_some())
-    ///     .map(|n| n.checked_add(1).unwrap());
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// (0_i32..10).find_map(|n| n.checked_add(1));
-    /// ```
-    #[clippy::version = "1.51.0"]
-    pub MANUAL_FIND_MAP,
-    complexity,
-    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.filter_map(_).next()`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.find_map(_)`.
-    ///
-    /// ### Example
-    /// ```no_run
-    ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
-    /// ```
-    /// Can be written as
-    ///
-    /// ```no_run
-    ///  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });
-    /// ```
-    #[clippy::version = "1.36.0"]
-    pub FILTER_MAP_NEXT,
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     pedantic,
-    "using combination of `filter_map` and `next` which can usually be written as a single method call"
+    "Checks for calls to ends_with with case-sensitive file extensions"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `flat_map(|x| x)`.
+    /// Checks for usage of `_.chars().last()` or
+    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely by using `flatten`.
+    /// Readability, this can be written more concisely as
+    /// `_.ends_with(_)`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let iter = vec![vec![0]].into_iter();
-    /// iter.flat_map(|x| x);
-    /// ```
-    /// Can be written as
-    /// ```no_run
-    /// # let iter = vec![vec![0]].into_iter();
-    /// iter.flatten();
-    /// ```
-    #[clippy::version = "1.39.0"]
-    pub FLAT_MAP_IDENTITY,
-    complexity,
-    "call to `flat_map` where `flatten` is sufficient"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for an iterator or string search (such as `find()`,
-    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as:
-    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
-    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![1];
-    /// vec.iter().find(|x| **x == 0).is_some();
-    ///
-    /// "hello world".find("world").is_none();
+    /// # let name = "_";
+    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let vec = vec![1];
-    /// vec.iter().any(|x| *x == 0);
-    ///
-    /// !"hello world".contains("world");
+    /// # let name = "_";
+    /// name.ends_with('_') || name.ends_with('-');
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SEARCH_IS_SOME,
-    nursery,
-    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
+    pub CHARS_LAST_CMP,
+    style,
+    "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
 }
 
 declare_clippy_lint! {
@@ -921,111 +325,27 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
-    /// `.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
-    /// `.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
-    /// etc. instead.
+    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a container.
     ///
     /// ### Why is this bad?
-    /// The function will always be called. This is only bad if it allocates or
-    /// does some non-trivial amount of work.
+    /// This creates an unnecessary iterator that is dropped immediately.
     ///
-    /// ### Known problems
-    /// If the function has side-effects, not calling it will change the
-    /// semantic of the program, but you shouldn't rely on that.
-    ///
-    /// The lint also cannot figure out whether the function you call is
-    /// actually expensive to call or not.
+    /// Calling `.clear()` also makes the intent clearer.
     ///
     /// ### Example
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// foo.unwrap_or(String::from("empty"));
+    /// let mut v = vec![1, 2, 3];
+    /// v.drain(..);
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// foo.unwrap_or_else(|| String::from("empty"));
+    /// let mut v = vec![1, 2, 3];
+    /// v.clear();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OR_FUN_CALL,
+    #[clippy::version = "1.70.0"]
+    pub CLEAR_WITH_DRAIN,
     nursery,
-    "using any `*or` method with a function call, which suggests `*or_else`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.or(…).unwrap()` calls to Options and Results.
-    ///
-    /// ### Why is this bad?
-    /// You should use `.unwrap_or(…)` instead for clarity.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # type Error = &'static str;
-    /// # let result: Result<&str, Error> = Err("error");
-    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.or(Some(fallback)).unwrap();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # let result: Result<&str, &str> = Err("error");
-    /// let value = result.unwrap_or(fallback);
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.unwrap_or(fallback);
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub OR_THEN_UNWRAP,
-    complexity,
-    "checks for `.or(…).unwrap()` calls to Options and Results."
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
-    /// etc., and suggests to use `unwrap_or_else` instead
-    ///
-    /// ### Why is this bad?
-    /// The function will always be called.
-    ///
-    /// ### Known problems
-    /// If the function has side-effects, not calling it will
-    /// change the semantics of the program, but you shouldn't rely on that anyway.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let foo = Some(String::new());
-    /// # let err_code = "418";
-    /// # let err_msg = "I'm a teapot";
-    /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
-    ///
-    /// // or
-    ///
-    /// # let foo = Some(String::new());
-    /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let foo = Some(String::new());
-    /// # let err_code = "418";
-    /// # let err_msg = "I'm a teapot";
-    /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPECT_FUN_CALL,
-    perf,
-    "using any `expect` method with a function call"
+    "calling `drain` in order to `clear` a container"
 }
 
 declare_clippy_lint! {
@@ -1079,237 +399,561 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.to_string()` on an `&&T` where
-    /// `T` implements `ToString` directly (like `&&str` or `&&String`).
+    /// Checks for usage of `cloned()` on an `Iterator` or `Option` where
+    /// `copied()` could be used instead.
     ///
     /// ### Why is this bad?
-    /// In versions of the compiler before Rust 1.82.0, this bypasses the specialized
-    /// implementation of `ToString` and instead goes through the more expensive string
-    /// formatting facilities.
+    /// `copied()` is better because it guarantees that the type being cloned
+    /// implements `Copy`.
     ///
     /// ### Example
     /// ```no_run
-    /// // Generic implementation for `T: Display` is used (slow)
-    /// ["foo", "bar"].iter().map(|s| s.to_string());
-    ///
-    /// // OK, the specialized impl is used
-    /// ["foo", "bar"].iter().map(|&s| s.to_string());
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub INEFFICIENT_TO_STRING,
-    pedantic,
-    "using `to_string` on `&&T` where `T: ToString`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `new` not returning a type that contains `Self`.
-    ///
-    /// ### Why is this bad?
-    /// As a convention, `new` methods are used to make a new
-    /// instance of a type.
-    ///
-    /// ### Example
-    /// In an impl block:
-    /// ```no_run
-    /// # struct Foo;
-    /// # struct NotAFoo;
-    /// impl Foo {
-    ///     fn new() -> NotAFoo {
-    /// # NotAFoo
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// ```no_run
-    /// # struct Foo;
-    /// struct Bar(Foo);
-    /// impl Foo {
-    ///     // Bad. The type name must contain `Self`
-    ///     fn new() -> Bar {
-    /// # Bar(Foo)
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// ```no_run
-    /// # struct Foo;
-    /// # struct FooError;
-    /// impl Foo {
-    ///     // Good. Return type contains `Self`
-    ///     fn new() -> Result<Foo, FooError> {
-    /// # Ok(Foo)
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Or in a trait definition:
-    /// ```no_run
-    /// pub trait Trait {
-    ///     // Bad. The type name must contain `Self`
-    ///     fn new();
-    /// }
-    /// ```
-    ///
-    /// ```no_run
-    /// pub trait Trait {
-    ///     // Good. Return type contains `Self`
-    ///     fn new() -> Self;
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEW_RET_NO_SELF,
-    style,
-    "not returning type containing `Self` in a `new` method"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calling `.step_by(0)` on iterators which panics.
-    ///
-    /// ### Why is this bad?
-    /// This very much looks like an oversight. Use `panic!()` instead if you
-    /// actually intend to panic.
-    ///
-    /// ### Example
-    /// ```rust,should_panic
-    /// for x in (0..100).step_by(0) {
-    ///     //..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITERATOR_STEP_BY_ZERO,
-    correctness,
-    "using `Iterator::step_by(0)`, which will panic at runtime"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for iterators of `Option`s using `.filter(Option::is_some).map(Option::unwrap)` that may
-    /// be replaced with a `.flatten()` call.
-    ///
-    /// ### Why is this bad?
-    /// `Option` is like a collection of 0-1 things, so `flatten`
-    /// automatically does this without suspicious-looking `unwrap` calls.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
+    /// [1, 2, 3].iter().cloned();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+    /// [1, 2, 3].iter().copied();
     /// ```
     #[clippy::version = "1.53.0"]
-    pub OPTION_FILTER_MAP,
-    complexity,
-    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+    pub CLONED_INSTEAD_OF_COPIED,
+    pedantic,
+    "used `cloned` where `copied` could be used instead"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `iter.nth(0)`.
+    /// Checks for consecutive calls to `str::replace` (2 or more)
+    /// that can be collapsed into a single call.
     ///
     /// ### Why is this bad?
-    /// `iter.next()` is equivalent to
-    /// `iter.nth(0)`, as they both consume the next element,
-    ///  but is more readable.
+    /// Consecutive `str::replace` calls scan the string multiple times
+    /// with repetitive code.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// # let mut s = HashSet::new();
-    /// # s.insert(1);
-    /// let x = s.iter().nth(0);
+    /// let hello = "hesuo worpd"
+    ///     .replace('s', "l")
+    ///     .replace("u", "l")
+    ///     .replace('p', "l");
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub COLLAPSIBLE_STR_REPLACE,
+    perf,
+    "collapse consecutive calls to str::replace (2 or more) into a single call"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It identifies calls to `.is_empty()` on constant values.
+    ///
+    /// ### Why is this bad?
+    /// String literals and constant values are known at compile time. Checking if they
+    /// are empty will always return the same value. This might not be the intention of
+    /// the expression.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let value = "";
+    /// if value.is_empty() {
+    ///     println!("the string is empty");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// println!("the string is empty");
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub CONST_IS_EMPTY,
+    suspicious,
+    "is_empty() called on strings known at compile time"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `Iterator::last` being called on a  `DoubleEndedIterator`, which can be replaced
+    /// with `DoubleEndedIterator::next_back`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `Iterator::last` is implemented by consuming the iterator, which is unnecessary if
+    /// the iterator is a `DoubleEndedIterator`. Since Rust traits do not allow specialization,
+    /// `Iterator::last` cannot be optimized for `DoubleEndedIterator`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let last_arg = "echo hello world".split(' ').last();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let last_arg = "echo hello world".split(' ').next_back();
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub DOUBLE_ENDED_ITERATOR_LAST,
+    perf,
+    "using `Iterator::last` on a `DoubleEndedIterator`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.
+    ///
+    /// > "Collection" in this context refers to any type with a `drain` method:
+    /// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`
+    ///
+    /// ### Why is this bad?
+    /// Using `mem::take` is faster as it avoids the allocation.
+    /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
+    /// the old collection is returned.
+    ///
+    /// ### Known issues
+    /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
+    /// it also moves the **capacity**. The user might have explicitly written it this way
+    /// to keep the capacity on the original `Vec`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     v.drain(..).collect()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::mem;
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     mem::take(v)
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub DRAIN_COLLECT,
+    perf,
+    "calling `.drain(..).collect()` to move all elements into a new collection"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.err().expect()` calls on the `Result` type.
+    ///
+    /// ### Why is this bad?
+    /// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.
+    ///
+    /// ### Example
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.err().expect("Testing err().expect()");
+    /// ```
+    /// Use instead:
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.expect_err("Testing expect_err");
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub ERR_EXPECT,
+    style,
+    r#"using `.err().expect("")` when `.expect_err("")` can be used"#
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
+    /// etc., and suggests to use `unwrap_or_else` instead
+    ///
+    /// ### Why is this bad?
+    /// The function will always be called.
+    ///
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will
+    /// change the semantics of the program, but you shouldn't rely on that anyway.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let foo = Some(String::new());
+    /// # let err_code = "418";
+    /// # let err_msg = "I'm a teapot";
+    /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
+    ///
+    /// // or
+    ///
+    /// # let foo = Some(String::new());
+    /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// # let mut s = HashSet::new();
-    /// # s.insert(1);
-    /// let x = s.iter().next();
+    /// # let foo = Some(String::new());
+    /// # let err_code = "418";
+    /// # let err_msg = "I'm a teapot";
+    /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPECT_FUN_CALL,
+    perf,
+    "using any `expect` method with a function call"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
+    ///
+    /// ### Why restrict this?
+    /// Usually it is better to handle the `None` or `Err` case.
+    /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
+    /// this lint is `Allow` by default.
+    ///
+    /// `result.expect()` will let the thread panic on `Err`
+    /// values. Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
+    ///
+    /// ### Examples
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("one");
+    /// result.expect("one");
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub EXPECT_USED,
+    restriction,
+    "using `.expect()` on `Result` or `Option`, which might be better handled"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for occurrences where one vector gets extended instead of append
+    ///
+    /// ### Why is this bad?
+    /// Using `append` instead of `extend` is more concise and faster
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
+    ///
+    /// a.extend(b.drain(..));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
+    ///
+    /// a.append(&mut b);
+    /// ```
+    #[clippy::version = "1.55.0"]
+    pub EXTEND_WITH_DRAIN,
+    perf,
+    "using vec.append(&mut vec) to move the full range of a vector to another"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `FileType::is_file()`.
+    ///
+    /// ### Why restrict this?
+    /// When people testing a file type with `FileType::is_file`
+    /// they are testing whether a path is something they can get bytes from. But
+    /// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover
+    /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # || {
+    /// let metadata = std::fs::metadata("foo.txt")?;
+    /// let filetype = metadata.file_type();
+    ///
+    /// if filetype.is_file() {
+    ///     // read file
+    /// }
+    /// # Ok::<_, std::io::Error>(())
+    /// # };
+    /// ```
+    ///
+    /// should be written as:
+    ///
+    /// ```no_run
+    /// # || {
+    /// let metadata = std::fs::metadata("foo.txt")?;
+    /// let filetype = metadata.file_type();
+    ///
+    /// if !filetype.is_dir() {
+    ///     // read file
+    /// }
+    /// # Ok::<_, std::io::Error>(())
+    /// # };
     /// ```
     #[clippy::version = "1.42.0"]
-    pub ITER_NTH_ZERO,
-    style,
-    "replace `iter.nth(0)` with `iter.next()`"
+    pub FILETYPE_IS_FILE,
+    restriction,
+    "`FileType::is_file` is not recommended to test for readable file type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.iter().nth()`/`.iter_mut().nth()` on standard library types that have
-    /// equivalent `.get()`/`.get_mut()` methods.
+    /// Checks for usage of `bool::then` in `Iterator::filter_map`.
     ///
     /// ### Why is this bad?
-    /// `.get()` and `.get_mut()` are equivalent but more concise.
+    /// This can be written with `filter` then `map` instead, which would reduce nesting and
+    /// separates the filtering from the transformation phase. This comes with no cost to
+    /// performance and is just cleaner.
+    ///
+    /// ### Limitations
+    /// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.
+    /// This can create differing behavior, so better safe than sorry.
     ///
     /// ### Example
     /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().nth(3);
-    /// let bad_slice = &some_vec[..].iter().nth(3);
-    /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.get(3);
-    /// let bad_slice = &some_vec[..].get(3);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITER_NTH,
-    style,
-    "using `.iter().nth()` on a standard library type with O(1) element access"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.skip(x).next()` on iterators.
-    ///
-    /// ### Why is this bad?
-    /// `.nth(x)` is cleaner
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().skip(3).next();
-    /// let bad_slice = &some_vec[..].iter().skip(3).next();
-    /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().nth(3);
-    /// let bad_slice = &some_vec[..].iter().nth(3);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITER_SKIP_NEXT,
-    style,
-    "using `.skip(x).next()` on an iterator"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.drain(..)` on `Vec` and `VecDeque` for iteration.
-    ///
-    /// ### Why is this bad?
-    /// `.into_iter()` is simpler with better performance.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let mut foo = vec![0, 1, 2, 3];
-    /// let bar: HashSet<usize> = foo.drain(..).collect();
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let foo = vec![0, 1, 2, 3];
-    /// let bar: HashSet<usize> = foo.into_iter().collect();
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub ITER_WITH_DRAIN,
-    nursery,
-    "replace `.drain(..)` with `.into_iter()`"
+    #[clippy::version = "1.73.0"]
+    pub FILTER_MAP_BOOL_THEN,
+    style,
+    "checks for usage of `bool::then` in `Iterator::filter_map`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `filter_map(|x| x)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely by using `flatten`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.filter_map(|x| x);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.flatten();
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub FILTER_MAP_IDENTITY,
+    complexity,
+    "call to `filter_map` where `flatten` is sufficient"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.filter_map(_).next()`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.find_map(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
+    /// ```
+    /// Can be written as
+    ///
+    /// ```no_run
+    ///  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });
+    /// ```
+    #[clippy::version = "1.36.0"]
+    pub FILTER_MAP_NEXT,
+    pedantic,
+    "using combination of `filter_map` and `next` which can usually be written as a single method call"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.filter(_).next()`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.find(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let vec = vec![1];
+    /// vec.iter().filter(|x| **x == 0).next();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let vec = vec![1];
+    /// vec.iter().find(|x| **x == 0);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FILTER_NEXT,
+    complexity,
+    "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `flat_map(|x| x)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely by using `flatten`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let iter = vec![vec![0]].into_iter();
+    /// iter.flat_map(|x| x);
+    /// ```
+    /// Can be written as
+    /// ```no_run
+    /// # let iter = vec![vec![0]].into_iter();
+    /// iter.flatten();
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub FLAT_MAP_IDENTITY,
+    complexity,
+    "call to `flat_map` where `flatten` is sufficient"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be
+    /// used instead.
+    ///
+    /// ### Why is this bad?
+    /// `filter_map()` is known to always produce 0 or 1 output items per input item,
+    /// rather than however many the inner iterator type produces.
+    /// Therefore, it maintains the upper bound in `Iterator::size_hint()`,
+    /// and communicates to the reader that the input items are not being expanded into
+    /// multiple output items without their having to notice that the mapping function
+    /// returns an `Option`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
+    /// ```
+    #[clippy::version = "1.53.0"]
+    pub FLAT_MAP_OPTION,
+    pedantic,
+    "used `flat_map` where `filter_map` could be used instead"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
+    ///
+    /// ### Why is this bad?
+    /// This allocates a new string for every element in the iterator.
+    /// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,
+    /// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,
+    /// or concatenating with `+` in case the iterator yields `&str`/`String`.
+    ///
+    /// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,
+    /// so it can be safely ignored or unwrapped.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::fmt::Write;
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().fold(String::new(), |mut output, b| {
+    ///         let _ = write!(output, "{b:02X}");
+    ///         output
+    ///     })
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub FORMAT_COLLECT,
+    pedantic,
+    "`format!`ing every element in a collection, then collecting the strings into a new `String`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
+    /// trait.
+    ///
+    /// ### Why is this bad?
+    /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
+    /// method is preferred. However, when it's needed to specify the container type,
+    /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
+    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v = Vec::from_iter(five_fives);
+    ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v: Vec<i32> = five_fives.collect();
+    ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// ```
+    /// but prefer to use
+    /// ```no_run
+    /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
+    /// ```
+    /// instead of
+    /// ```no_run
+    /// let numbers = (1..=5).collect::<Vec<_>>();
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub FROM_ITER_INSTEAD_OF_COLLECT,
+    pedantic,
+    "use `.collect()` instead of `::from_iter()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `x.get(0)` instead of
+    /// `x.first()` or `x.front()`.
+    ///
+    /// ### Why is this bad?
+    /// Using `x.first()` for `Vec`s and slices or `x.front()`
+    /// for `VecDeque`s is easier to read and has the same result.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.get(0);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.first();
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub GET_FIRST,
+    style,
+    "Using `x.get(0)` when `x.first()` or `x.front()` is simpler"
 }
 
 declare_clippy_lint! {
@@ -1384,643 +1028,52 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for occurrences where one vector gets extended instead of append
+    /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
     ///
     /// ### Why is this bad?
-    /// Using `append` instead of `extend` is more concise and faster
+    /// These methods do the same thing as `_.clone()` but may be confusing as
+    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut a = vec![1, 2, 3];
-    /// let mut b = vec![4, 5, 6];
-    ///
-    /// a.extend(b.drain(..));
+    /// let a = vec![1, 2, 3];
+    /// let b = a.to_vec();
+    /// let c = a.to_owned();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let mut a = vec![1, 2, 3];
-    /// let mut b = vec![4, 5, 6];
-    ///
-    /// a.append(&mut b);
+    /// let a = vec![1, 2, 3];
+    /// let b = a.clone();
+    /// let c = a.clone();
     /// ```
-    #[clippy::version = "1.55.0"]
-    pub EXTEND_WITH_DRAIN,
-    perf,
-    "using vec.append(&mut vec) to move the full range of a vector to another"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the use of `.extend(s.chars())` where s is a
-    /// `&str` or `String`.
-    ///
-    /// ### Why is this bad?
-    /// `.push_str(s)` is clearer
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let abc = "abc";
-    /// let def = String::from("def");
-    /// let mut s = String::new();
-    /// s.extend(abc.chars());
-    /// s.extend(def.chars());
-    /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// let abc = "abc";
-    /// let def = String::from("def");
-    /// let mut s = String::new();
-    /// s.push_str(abc);
-    /// s.push_str(&def);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub STRING_EXTEND_CHARS,
-    style,
-    "using `x.extend(s.chars())` where s is a `&str` or `String`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the use of `.cloned().collect()` on slice to
-    /// create a `Vec`.
-    ///
-    /// ### Why is this bad?
-    /// `.to_vec()` is clearer
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let s = [1, 2, 3, 4, 5];
-    /// let s2: Vec<isize> = s[..].iter().cloned().collect();
-    /// ```
-    /// The better use would be:
-    /// ```no_run
-    /// let s = [1, 2, 3, 4, 5];
-    /// let s2: Vec<isize> = s.to_vec();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITER_CLONED_COLLECT,
-    style,
-    "using `.cloned().collect()` on slice to create a `Vec`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.chars().last()` or
-    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.ends_with(_)`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let name = "_";
-    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let name = "_";
-    /// name.ends_with('_') || name.ends_with('-');
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CHARS_LAST_CMP,
-    style,
-    "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.as_ref()` or `.as_mut()` where the
-    /// types before and after the call are the same.
-    ///
-    /// ### Why is this bad?
-    /// The call is unnecessary.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # fn do_stuff(x: &[i32]) {}
-    /// let x: &[i32] = &[1, 2, 3, 4, 5];
-    /// do_stuff(x.as_ref());
-    /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// # fn do_stuff(x: &[i32]) {}
-    /// let x: &[i32] = &[1, 2, 3, 4, 5];
-    /// do_stuff(x);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub USELESS_ASREF,
-    complexity,
-    "using `as_ref` where the types before and after the call are the same"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `fold` when a more succinct alternative exists.
-    /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
-    /// `sum` or `product`.
-    ///
-    /// ### Why is this bad?
-    /// Readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// (0..3).fold(false, |acc, x| acc || x > 2);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// (0..3).any(|x| x > 2);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNNECESSARY_FOLD,
-    style,
-    "using `fold` when a more succinct alternative exists"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `filter_map` calls that could be replaced by `filter` or `map`.
-    /// More specifically it checks if the closure provided is only performing one of the
-    /// filter or map operations and suggests the appropriate option.
-    ///
-    /// ### Why is this bad?
-    /// Complexity. The intent is also clearer if only a single
-    /// operation is being performed.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
-    ///
-    /// // As there is no transformation of the argument this could be written as:
-    /// let _ = (0..3).filter(|&x| x > 2);
-    /// ```
-    ///
-    /// ```no_run
-    /// let _ = (0..4).filter_map(|x| Some(x + 1));
-    ///
-    /// // As there is no conditional check on the argument this could be written as:
-    /// let _ = (0..4).map(|x| x + 1);
-    /// ```
-    #[clippy::version = "1.31.0"]
-    pub UNNECESSARY_FILTER_MAP,
-    complexity,
-    "using `filter_map` when a more succinct alternative exists"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `find_map` calls that could be replaced by `find` or `map`. More
-    /// specifically it checks if the closure provided is only performing one of the
-    /// find or map operations and suggests the appropriate option.
-    ///
-    /// ### Why is this bad?
-    /// Complexity. The intent is also clearer if only a single
-    /// operation is being performed.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
-    ///
-    /// // As there is no transformation of the argument this could be written as:
-    /// let _ = (0..3).find(|&x| x > 2);
-    /// ```
-    ///
-    /// ```no_run
-    /// let _ = (0..4).find_map(|x| Some(x + 1));
-    ///
-    /// // As there is no conditional check on the argument this could be written as:
-    /// let _ = (0..4).map(|x| x + 1).next();
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub UNNECESSARY_FIND_MAP,
-    complexity,
-    "using `find_map` when a more succinct alternative exists"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `into_iter` calls on references which should be replaced by `iter`
-    /// or `iter_mut`.
-    ///
-    /// ### Why is this bad?
-    /// Readability. Calling `into_iter` on a reference will not move out its
-    /// content into the resulting iterator, which is confusing. It is better just call `iter` or
-    /// `iter_mut` directly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let vec = vec![3, 4, 5];
-    /// (&vec).into_iter();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let vec = vec![3, 4, 5];
-    /// (&vec).iter();
-    /// ```
-    #[clippy::version = "1.32.0"]
-    pub INTO_ITER_ON_REF,
-    style,
-    "using `.into_iter()` on a reference"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `map` followed by a `count`.
-    ///
-    /// ### Why is this bad?
-    /// It looks suspicious. Maybe `map` was confused with `filter`.
-    /// If the `map` call is intentional, this should be rewritten
-    /// using `inspect`. Or, if you intend to drive the iterator to
-    /// completion, you can just use `for_each` instead.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = (0..3).map(|x| x + 2).count();
-    /// ```
-    #[clippy::version = "1.39.0"]
-    pub SUSPICIOUS_MAP,
-    suspicious,
-    "suspicious usage of map"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `MaybeUninit::uninit().assume_init()`.
-    ///
-    /// ### Why is this bad?
-    /// For most types, this is undefined behavior.
-    ///
-    /// ### Known problems
-    /// For now, we accept empty tuples and tuples / arrays
-    /// of `MaybeUninit`. There may be other types that allow uninitialized
-    /// data, but those are not yet rigorously defined.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // Beware the UB
-    /// use std::mem::MaybeUninit;
-    ///
-    /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
-    /// ```
-    ///
-    /// Note that the following is OK:
-    ///
-    /// ```no_run
-    /// use std::mem::MaybeUninit;
-    ///
-    /// let _: [MaybeUninit<bool>; 5] = unsafe {
-    ///     MaybeUninit::uninit().assume_init()
-    /// };
-    /// ```
-    #[clippy::version = "1.39.0"]
-    pub UNINIT_ASSUMED_INIT,
-    correctness,
-    "`MaybeUninit::uninit().assume_init()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
-    ///
-    /// ### Why is this bad?
-    /// These can be written simply with `saturating_add/sub` methods.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let y: u32 = 0;
-    /// # let x: u32 = 100;
-    /// let add = x.checked_add(y).unwrap_or(u32::MAX);
-    /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
-    /// ```
-    ///
-    /// can be written using dedicated methods for saturating addition/subtraction as:
-    ///
-    /// ```no_run
-    /// # let y: u32 = 0;
-    /// # let x: u32 = 100;
-    /// let add = x.saturating_add(y);
-    /// let sub = x.saturating_sub(y);
-    /// ```
-    #[clippy::version = "1.39.0"]
-    pub MANUAL_SATURATING_ARITHMETIC,
-    style,
-    "`.checked_add/sub(x).unwrap_or(MAX/MIN)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
-    /// zero-sized types
-    ///
-    /// ### Why is this bad?
-    /// This is a no-op, and likely unintended
-    ///
-    /// ### Example
-    /// ```no_run
-    /// unsafe { (&() as *const ()).offset(1) };
-    /// ```
-    #[clippy::version = "1.41.0"]
-    pub ZST_OFFSET,
-    correctness,
-    "Check for offset calculations on raw pointers to zero-sized types"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `offset` pointer method with an integer
-    /// literal.
-    ///
-    /// ### Why is this bad?
-    /// The `add` and `sub` methods more accurately express the intent.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    ///
-    /// unsafe {
-    ///     ptr.offset(-8);
-    /// }
-    /// ```
-    ///
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    ///
-    /// unsafe {
-    ///     ptr.sub(8);
-    /// }
-    /// ```
-    #[clippy::version = "1.92.0"]
-    pub PTR_OFFSET_BY_LITERAL,
+    #[clippy::version = "1.52.0"]
+    pub IMPLICIT_CLONE,
     pedantic,
-    "unneeded pointer offset"
+    "implicitly cloning a value by invoking a function on its dereferenced type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
-    /// `isize`.
+    /// Checks for usage of `.to_string()` on an `&&T` where
+    /// `T` implements `ToString` directly (like `&&str` or `&&String`).
     ///
     /// ### Why is this bad?
-    /// If we’re always increasing the pointer address, we can avoid the numeric
-    /// cast by using the `add` method instead.
+    /// In versions of the compiler before Rust 1.82.0, this bypasses the specialized
+    /// implementation of `ToString` and instead goes through the more expensive string
+    /// formatting facilities.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
+    /// // Generic implementation for `T: Display` is used (slow)
+    /// ["foo", "bar"].iter().map(|s| s.to_string());
     ///
-    /// unsafe {
-    ///     ptr.offset(offset as isize);
-    /// }
+    /// // OK, the specialized impl is used
+    /// ["foo", "bar"].iter().map(|&s| s.to_string());
     /// ```
-    ///
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.add(offset);
-    /// }
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub PTR_OFFSET_WITH_CAST,
-    complexity,
-    "unneeded pointer offset cast"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `FileType::is_file()`.
-    ///
-    /// ### Why restrict this?
-    /// When people testing a file type with `FileType::is_file`
-    /// they are testing whether a path is something they can get bytes from. But
-    /// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover
-    /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # || {
-    /// let metadata = std::fs::metadata("foo.txt")?;
-    /// let filetype = metadata.file_type();
-    ///
-    /// if filetype.is_file() {
-    ///     // read file
-    /// }
-    /// # Ok::<_, std::io::Error>(())
-    /// # };
-    /// ```
-    ///
-    /// should be written as:
-    ///
-    /// ```no_run
-    /// # || {
-    /// let metadata = std::fs::metadata("foo.txt")?;
-    /// let filetype = metadata.file_type();
-    ///
-    /// if !filetype.is_dir() {
-    ///     // read file
-    /// }
-    /// # Ok::<_, std::io::Error>(())
-    /// # };
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub FILETYPE_IS_FILE,
-    restriction,
-    "`FileType::is_file` is not recommended to test for readable file type"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.as_deref()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let opt = Some("".to_string());
-    /// opt.as_ref().map(String::as_str)
-    /// # ;
-    /// ```
-    /// Can be written as
-    /// ```no_run
-    /// # let opt = Some("".to_string());
-    /// opt.as_deref()
-    /// # ;
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub OPTION_AS_REF_DEREF,
-    complexity,
-    "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `iter().next()` on a Slice or an Array
-    ///
-    /// ### Why is this bad?
-    /// These can be shortened into `.get()`
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let a = [1, 2, 3];
-    /// # let b = vec![1, 2, 3];
-    /// a[2..].iter().next();
-    /// b.iter().next();
-    /// ```
-    /// should be written as:
-    /// ```no_run
-    /// # let a = [1, 2, 3];
-    /// # let b = vec![1, 2, 3];
-    /// a.get(2);
-    /// b.get(0);
-    /// ```
-    #[clippy::version = "1.46.0"]
-    pub ITER_NEXT_SLICE,
-    style,
-    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns when using `push_str`/`insert_str` with a single-character string literal
-    /// where `push`/`insert` with a `char` would work fine.
-    ///
-    /// ### Why is this bad?
-    /// It's less clear that we are pushing a single character.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let mut string = String::new();
-    /// string.insert_str(0, "R");
-    /// string.push_str("R");
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let mut string = String::new();
-    /// string.insert(0, 'R');
-    /// string.push('R');
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub SINGLE_CHAR_ADD_STR,
-    style,
-    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
-    /// lazily evaluated closures on `Option` and `Result`.
-    ///
-    /// This lint suggests changing the following functions, when eager evaluation results in
-    /// simpler code:
-    ///  - `unwrap_or_else` to `unwrap_or`
-    ///  - `and_then` to `and`
-    ///  - `or_else` to `or`
-    ///  - `get_or_insert_with` to `get_or_insert`
-    ///  - `ok_or_else` to `ok_or`
-    ///  - `then` to `then_some` (for msrv >= 1.62.0)
-    ///
-    /// ### Why is this bad?
-    /// Using eager evaluation is shorter and simpler in some cases.
-    ///
-    /// ### Known problems
-    /// It is possible, but not recommended for `Deref` and `Index` to have
-    /// side effects. Eagerly evaluating them can change the semantics of the program.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let opt: Option<u32> = None;
-    ///
-    /// opt.unwrap_or_else(|| 42);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let opt: Option<u32> = None;
-    ///
-    /// opt.unwrap_or(42);
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub UNNECESSARY_LAZY_EVALUATIONS,
-    style,
-    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
-    ///
-    /// ### Why is this bad?
-    /// Using `try_for_each` instead is more readable and idiomatic.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// (0..3).try_for_each(|t| Err(t));
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MAP_COLLECT_RESULT_UNIT,
-    style,
-    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
-    /// trait.
-    ///
-    /// ### Why is this bad?
-    /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
-    /// method is preferred. However, when it's needed to specify the container type,
-    /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
-    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let five_fives = std::iter::repeat(5).take(5);
-    ///
-    /// let v = Vec::from_iter(five_fives);
-    ///
-    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let five_fives = std::iter::repeat(5).take(5);
-    ///
-    /// let v: Vec<i32> = five_fives.collect();
-    ///
-    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
-    /// ```
-    /// but prefer to use
-    /// ```no_run
-    /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
-    /// ```
-    /// instead of
-    /// ```no_run
-    /// let numbers = (1..=5).collect::<Vec<_>>();
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub FROM_ITER_INSTEAD_OF_COLLECT,
+    #[clippy::version = "1.40.0"]
+    pub INEFFICIENT_TO_STRING,
     pedantic,
-    "use `.collect()` instead of `::from_iter()`"
+    "using `to_string` on `&&T` where `T: ToString`"
 }
 
 declare_clippy_lint! {
@@ -2055,97 +1108,138 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `filter_map(|x| x)`.
+    /// Checks for `into_iter` calls on references which should be replaced by `iter`
+    /// or `iter_mut`.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely by using `flatten`.
+    /// Readability. Calling `into_iter` on a reference will not move out its
+    /// content into the resulting iterator, which is confusing. It is better just call `iter` or
+    /// `iter_mut` directly.
     ///
     /// ### Example
     /// ```no_run
-    /// # let iter = vec![Some(1)].into_iter();
-    /// iter.filter_map(|x| x);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let iter = vec![Some(1)].into_iter();
-    /// iter.flatten();
-    /// ```
-    #[clippy::version = "1.52.0"]
-    pub FILTER_MAP_IDENTITY,
-    complexity,
-    "call to `filter_map` where `flatten` is sufficient"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for instances of `map(f)` where `f` is the identity function.
-    ///
-    /// ### Why is this bad?
-    /// It can be written more concisely without the call to `map`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub MAP_IDENTITY,
-    complexity,
-    "using iterator.map(|x| x)"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the use of `.bytes().nth()`.
-    ///
-    /// ### Why is this bad?
-    /// `.as_bytes().get()` is more efficient and more
-    /// readable.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// "Hello".bytes().nth(3);
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).into_iter();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// "Hello".as_bytes().get(3);
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).iter();
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub BYTES_NTH,
+    #[clippy::version = "1.32.0"]
+    pub INTO_ITER_ON_REF,
     style,
-    "replace `.bytes().nth()` with `.as_bytes().get()`"
+    "using `.into_iter()` on a reference"
+}
+
+declare_clippy_lint! {
+    /// This lint warns on calling `io::Error::new(..)` with a kind of
+    /// `io::ErrorKind::Other`.
+    ///
+    /// ### Why is this bad?
+    /// Since Rust 1.74, there's the `io::Error::other(_)` shortcut.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::io;
+    /// let _ = io::Error::new(io::ErrorKind::Other, "bad".to_string());
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = std::io::Error::other("bad".to_string());
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub IO_OTHER_ERROR,
+    style,
+    "calling `std::io::Error::new(std::io::ErrorKind::Other, _)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
+    /// Checks for IP addresses that could be replaced with predefined constants such as
+    /// `Ipv4Addr::new(127, 0, 0, 1)` instead of using the appropriate constants.
     ///
     /// ### Why is this bad?
-    /// These methods do the same thing as `_.clone()` but may be confusing as
-    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
+    /// Using specific IP addresses like `127.0.0.1` or `::1` is less clear and less maintainable than using the
+    /// predefined constants `Ipv4Addr::LOCALHOST` or `Ipv6Addr::LOCALHOST`. These constants improve code
+    /// readability, make the intent explicit, and are less error-prone.
     ///
     /// ### Example
     /// ```no_run
-    /// let a = vec![1, 2, 3];
-    /// let b = a.to_vec();
-    /// let c = a.to_owned();
+    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    ///
+    /// // IPv4 loopback
+    /// let addr_v4 = Ipv4Addr::new(127, 0, 0, 1);
+    ///
+    /// // IPv6 loopback
+    /// let addr_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let a = vec![1, 2, 3];
-    /// let b = a.clone();
-    /// let c = a.clone();
+    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    ///
+    /// // IPv4 loopback
+    /// let addr_v4 = Ipv4Addr::LOCALHOST;
+    ///
+    /// // IPv6 loopback
+    /// let addr_v6 = Ipv6Addr::LOCALHOST;
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub IMPLICIT_CLONE,
+    #[clippy::version = "1.89.0"]
+    pub IP_CONSTANT,
     pedantic,
-    "implicitly cloning a value by invoking a function on its dereferenced type"
+    "hardcoded localhost IP address"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds usages of [`char::is_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
+    /// can be replaced with [`is_ascii_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
+    /// [`is_ascii_hexdigit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
+    ///
+    /// ### Why is this bad?
+    /// `is_digit(..)` is slower and requires specifying the radix.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let c: char = '6';
+    /// c.is_digit(10);
+    /// c.is_digit(16);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let c: char = '6';
+    /// c.is_ascii_digit();
+    /// c.is_ascii_hexdigit();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub IS_DIGIT_ASCII_RADIX,
+    style,
+    "use of `char::is_digit(..)` with literal radix of 10 or 16"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the use of `.cloned().collect()` on slice to
+    /// create a `Vec`.
+    ///
+    /// ### Why is this bad?
+    /// `.to_vec()` is clearer
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let s = [1, 2, 3, 4, 5];
+    /// let s2: Vec<isize> = s[..].iter().cloned().collect();
+    /// ```
+    /// The better use would be:
+    /// ```no_run
+    /// let s = [1, 2, 3, 4, 5];
+    /// let s2: Vec<isize> = s.to_vec();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ITER_CLONED_COLLECT,
+    style,
+    "using `.cloned().collect()` on slice to create a `Vec`"
 }
 
 declare_clippy_lint! {
@@ -2179,103 +1273,734 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `_.to_owned()`, on a `Cow<'_, _>`.
+    /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
+    /// This lint will require additional changes to the follow-up calls as it affects the type.
     ///
     /// ### Why is this bad?
-    /// Calling `to_owned()` on a `Cow` creates a clone of the `Cow`
-    /// itself, without taking ownership of the `Cow` contents (i.e.
-    /// it's equivalent to calling `Cow::clone`).
-    /// The similarly named `into_owned` method, on the other hand,
-    /// clones the `Cow` contents, effectively turning any `Cow::Borrowed`
-    /// into a `Cow::Owned`.
-    ///
-    /// Given the potential ambiguity, consider replacing `to_owned`
-    /// with `clone` for better readability or, if getting a `Cow::Owned`
-    /// was the original intent, using `into_owned` instead.
+    /// This pattern is often followed by manual unwrapping of `Result`. The simplification
+    /// results in more readable and succinct code without the need for manual unwrapping.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
+    /// vec![Ok::<i32, String>(1)].into_iter().filter(Result::is_ok);
     ///
-    /// let data = cow.to_owned();
-    /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
-    ///
-    /// let data = cow.clone();
-    /// assert!(matches!(data, Cow::Borrowed(_)))
+    /// vec![Ok::<i32, String>(1)].into_iter().flatten();
     /// ```
-    /// or
+    #[clippy::version = "1.77.0"]
+    pub ITER_FILTER_IS_OK,
+    pedantic,
+    "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.filter(Option::is_some)` that may be replaced with a `.flatten()` call.
+    /// This lint will require additional changes to the follow-up calls as it affects the type.
+    ///
+    /// ### Why is this bad?
+    /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
+    /// results in more readable and succinct code without the need for manual unwrapping.
+    ///
+    /// ### Example
     /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
+    /// vec![Some(1)].into_iter().filter(Option::is_some);
     ///
-    /// let _data: String = cow.into_owned();
     /// ```
+    /// Use instead:
+    /// ```no_run
+    /// vec![Some(1)].into_iter().flatten();
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub ITER_FILTER_IS_SOME,
+    pedantic,
+    "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ignoring either the keys or values.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Readability. There are `keys` and `values` methods that
+    /// can be used to express that we only need the keys or the values.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.values().collect::<Vec<_>>();
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub ITER_KV_MAP,
+    complexity,
+    "iterating on map using `iter` when `keys` or `values` would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `iter().next()` on a Slice or an Array
+    ///
+    /// ### Why is this bad?
+    /// These can be shortened into `.get()`
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a[2..].iter().next();
+    /// b.iter().next();
+    /// ```
+    /// should be written as:
+    /// ```no_run
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a.get(2);
+    /// b.get(0);
+    /// ```
+    #[clippy::version = "1.46.0"]
+    pub ITER_NEXT_SLICE,
+    style,
+    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.iter().nth()`/`.iter_mut().nth()` on standard library types that have
+    /// equivalent `.get()`/`.get_mut()` methods.
+    ///
+    /// ### Why is this bad?
+    /// `.get()` and `.get_mut()` are equivalent but more concise.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().nth(3);
+    /// let bad_slice = &some_vec[..].iter().nth(3);
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.get(3);
+    /// let bad_slice = &some_vec[..].get(3);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ITER_NTH,
+    style,
+    "using `.iter().nth()` on a standard library type with O(1) element access"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the use of `iter.nth(0)`.
+    ///
+    /// ### Why is this bad?
+    /// `iter.next()` is equivalent to
+    /// `iter.nth(0)`, as they both consume the next element,
+    ///  but is more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// # let mut s = HashSet::new();
+    /// # s.insert(1);
+    /// let x = s.iter().nth(0);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// # let mut s = HashSet::new();
+    /// # s.insert(1);
+    /// let x = s.iter().next();
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub ITER_NTH_ZERO,
+    style,
+    "replace `iter.nth(0)` with `iter.next()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the empty function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// use std::{slice, option};
+    /// let a: slice::Iter<i32> = [].iter();
+    /// let f: option::IntoIter<i32> = None.into_iter();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::iter;
+    /// let a: iter::Empty<i32> = iter::empty();
+    /// let b: iter::Empty<i32> = iter::empty();
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
     #[clippy::version = "1.65.0"]
-    pub SUSPICIOUS_TO_OWNED,
+    pub ITER_ON_EMPTY_COLLECTIONS,
+    nursery,
+    "Iterator for empty array"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the once function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// let a = [123].iter();
+    /// let b = Some(123).into_iter();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::iter;
+    /// let a = iter::once(&123);
+    /// let b = iter::once(123);
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.65.0"]
+    pub ITER_ON_SINGLE_ITEMS,
+    nursery,
+    "Iterator for array of length 1"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for iterator combinator calls such as `.take(x)` or `.skip(x)`
+    /// where `x` is greater than the amount of items that an iterator will produce.
+    ///
+    /// ### Why is this bad?
+    /// Taking or skipping more items than there are in an iterator either creates an iterator
+    /// with all items from the original iterator or an iterator with no items at all.
+    /// This is most likely not what the user intended to do.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// for _ in [1, 2, 3].iter().take(4) {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// for _ in [1, 2, 3].iter() {}
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub ITER_OUT_OF_BOUNDS,
     suspicious,
-    "calls to `to_owned` on a `Cow<'_, _>` might not do what they are expected"
+    "calls to `.take()` or `.skip()` that are out of bounds"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to [`splitn`]
-    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
-    /// related functions with either zero or one splits.
+    /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
     ///
     /// ### Why is this bad?
-    /// These calls don't actually split the value and are
-    /// likely to be intended as a different number.
+    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
+    /// of them will be consumed.
     ///
-    /// ### Example
+    /// ### Known Problems
+    /// This `lint` removes the side of effect of cloning items in the iterator.
+    /// A code that relies on that side-effect could fail.
+    ///
+    /// ### Examples
     /// ```no_run
-    /// # let s = "";
-    /// for x in s.splitn(1, ":") {
-    ///     // ..
-    /// }
+    /// # let vec = vec!["string".to_string()];
+    /// vec.iter().cloned().take(10);
+    /// vec.iter().cloned().last();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let s = "";
-    /// for x in s.splitn(2, ":") {
-    ///     // ..
-    /// }
+    /// # let vec = vec!["string".to_string()];
+    /// vec.iter().take(10).cloned();
+    /// vec.iter().last().cloned();
     /// ```
-    #[clippy::version = "1.54.0"]
-    pub SUSPICIOUS_SPLITN,
-    correctness,
-    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of `str::repeat`
-    ///
-    /// ### Why is this bad?
-    /// These are both harder to read, as well as less performant.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: String = std::iter::repeat('x').take(10).collect();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x: String = "x".repeat(10);
-    /// ```
-    #[clippy::version = "1.54.0"]
-    pub MANUAL_STR_REPEAT,
+    #[clippy::version = "1.60.0"]
+    pub ITER_OVEREAGER_CLONED,
     perf,
-    "manual implementation of `str::repeat`"
+    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.skip(x).next()` on iterators.
+    ///
+    /// ### Why is this bad?
+    /// `.nth(x)` is cleaner
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().skip(3).next();
+    /// let bad_slice = &some_vec[..].iter().skip(3).next();
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().nth(3);
+    /// let bad_slice = &some_vec[..].iter().nth(3);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ITER_SKIP_NEXT,
+    style,
+    "using `.skip(x).next()` on an iterator"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.skip(0)` on iterators.
+    ///
+    /// ### Why is this bad?
+    /// This was likely intended to be `.skip(1)` to skip the first element, as `.skip(0)` does
+    /// nothing. If not, the call should be removed.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let v = vec![1, 2, 3];
+    /// let x = v.iter().skip(0).collect::<Vec<_>>();
+    /// let y = v.iter().collect::<Vec<_>>();
+    /// assert_eq!(x, y);
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub ITER_SKIP_ZERO,
+    correctness,
+    "disallows `.skip(0)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.drain(..)` on `Vec` and `VecDeque` for iteration.
+    ///
+    /// ### Why is this bad?
+    /// `.into_iter()` is simpler with better performance.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// let mut foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.drain(..).collect();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// let foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.into_iter().collect();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ITER_WITH_DRAIN,
+    nursery,
+    "replace `.drain(..)` with `.into_iter()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calling `.step_by(0)` on iterators which panics.
+    ///
+    /// ### Why is this bad?
+    /// This very much looks like an oversight. Use `panic!()` instead if you
+    /// actually intend to panic.
+    ///
+    /// ### Example
+    /// ```rust,should_panic
+    /// for x in (0..100).step_by(0) {
+    ///     //..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ITERATOR_STEP_BY_ZERO,
+    correctness,
+    "using `Iterator::step_by(0)`, which will panic at runtime"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Path::join` that start with a path separator (`\\` or `/`).
+    ///
+    /// ### Why is this bad?
+    /// If the argument to `Path::join` starts with a separator, it will overwrite
+    /// the original path. If this is intentional, prefer using `Path::new` instead.
+    ///
+    /// Note the behavior is platform dependent. A leading `\\` will be accepted
+    /// on unix systems as part of the file name
+    ///
+    /// See [`Path::join`](https://doc.rust-lang.org/std/path/struct.Path.html#method.join)
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
+    /// let joined_path = path.join("/sh");
+    /// assert_eq!(joined_path, PathBuf::from("/sh"));
+    /// ```
+    ///
+    /// Use instead;
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
+    ///
+    /// // If this was unintentional, remove the leading separator
+    /// let joined_path = path.join("sh");
+    /// assert_eq!(joined_path, PathBuf::from("/bin/sh"));
+    ///
+    /// // If this was intentional, create a new path instead
+    /// let new = Path::new("/sh");
+    /// assert_eq!(new, PathBuf::from("/sh"));
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub JOIN_ABSOLUTE_PATHS,
+    suspicious,
+    "calls to `Path::join` which will overwrite the original path"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
+    /// when `lines` has type `std::io::Lines`.
+    ///
+    /// ### Why is this bad?
+    /// `Lines` instances might produce a never-ending stream of `Err`, in which case
+    /// `filter_map(Result::ok)` will enter an infinite loop while waiting for an
+    /// `Ok` variant. Calling `next()` once is sufficient to enter the infinite loop,
+    /// even in the absence of explicit loops in the user code.
+    ///
+    /// This situation can arise when working with user-provided paths. On some platforms,
+    /// `std::fs::File::open(path)` might return `Ok(fs)` even when `path` is a directory,
+    /// but any later attempt to read from `fs` will return an error.
+    ///
+    /// ### Known problems
+    /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
+    /// instance in all cases. There are two cases where the suggestion might not be
+    /// appropriate or necessary:
+    ///
+    /// - If the `Lines` instance can never produce any error, or if an error is produced
+    ///   only once just before terminating the iterator, using `map_while()` is not
+    ///   necessary but will not do any harm.
+    /// - If the `Lines` instance can produce intermittent errors then recover and produce
+    ///   successful results, using `map_while()` would stop at the first error.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
+    /// // If "some-path" points to a directory, the next statement never terminates:
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub LINES_FILTER_MAP_OK,
+    suspicious,
+    "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the manual creation of C strings (a string with a `NUL` byte at the end), either
+    /// through one of the `CStr` constructor functions, or more plainly by calling `.as_ptr()`
+    /// on a (byte) string literal with a hardcoded `\0` byte at the end.
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely using `c"str"` literals and is also less error-prone,
+    /// because the compiler checks for interior `NUL` bytes and the terminating `NUL` byte is inserted automatically.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
+    ///
+    /// needs_cstr(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
+    /// unsafe { libc::puts("World\0".as_ptr().cast()) }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
+    ///
+    /// needs_cstr(c"Hello");
+    /// unsafe { libc::puts(c"World".as_ptr()) }
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub MANUAL_C_STR_LITERALS,
+    complexity,
+    r#"creating a `CStr` through functions when `c""` literals can be used"#
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `iter().any()` on slices when it can be replaced with `contains()` and suggests doing so.
+    ///
+    /// ### Why is this bad?
+    /// `contains()` is more concise and idiomatic, while also being faster in some cases.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(values: &[u8]) -> bool {
+    ///     values.iter().any(|&v| v == 10)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(values: &[u8]) -> bool {
+    ///     values.contains(&10)
+    /// }
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub MANUAL_CONTAINS,
+    perf,
+    "unnecessary `iter().any()` on slices that can be replaced with `contains()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
+    /// as `filter_map(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code in the `filter` and `map` operations is poor style and
+    /// less performant.
+    ///
+     /// ### Example
+    /// ```no_run
+    /// (0_i32..10)
+    ///     .filter(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+    /// ```
+    #[clippy::version = "1.51.0"]
+    pub MANUAL_FILTER_MAP,
+    complexity,
+    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
+    /// as `find_map(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code in the `find` and `map` operations is poor style and
+    /// less performant.
+    ///
+     /// ### Example
+    /// ```no_run
+    /// (0_i32..10)
+    ///     .find(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// (0_i32..10).find_map(|n| n.checked_add(1));
+    /// ```
+    #[clippy::version = "1.51.0"]
+    pub MANUAL_FIND_MAP,
+    complexity,
+    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for uses of `map` which return the original item.
+    ///
+    /// ### Why is this bad?
+    /// `inspect` is both clearer in intent and shorter.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = Some(0).map(|x| { println!("{x}"); x });
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = Some(0).inspect(|x| println!("{x}"));
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub MANUAL_INSPECT,
+    complexity,
+    "use of `map` returning the original item"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `option.map(f).unwrap_or_default()` and `result.map(f).unwrap_or_default()` where `f` is a function or closure that returns the `bool` type.
+    ///
+    /// Also checks for equality comparisons like `option.map(f) == Some(true)` and `result.map(f) == Ok(true)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability. These can be written more concisely as `option.is_some_and(f)` and `result.is_ok_and(f)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.map(|a| a > 10).unwrap_or_default();
+    /// result.map(|a| a > 10).unwrap_or_default();
+    ///
+    /// option.map(|a| a > 10) == Some(true);
+    /// result.map(|a| a > 10) == Ok(true);
+    /// option.map(|a| a > 10) != Some(true);
+    /// result.map(|a| a > 10) != Ok(true);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.is_some_and(|a| a > 10);
+    /// result.is_ok_and(|a| a > 10);
+    ///
+    /// option.is_some_and(|a| a > 10);
+    /// result.is_ok_and(|a| a > 10);
+    /// option.is_none_or(|a| a > 10);
+    /// !result.is_ok_and(|a| a > 10);
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub MANUAL_IS_VARIANT_AND,
+    pedantic,
+    "using `.map(f).unwrap_or_default()` or `.map(f) == Some/Ok(true)`, which are more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.rev().next()` on a `DoubleEndedIterator`
+    ///
+    /// ### Why is this bad?
+    /// `.next_back()` is cleaner.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let foo = [0; 10];
+    /// foo.iter().rev().next();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let foo = [0; 10];
+    /// foo.iter().next_back();
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_NEXT_BACK,
+    style,
+    "manual reverse iteration of `DoubleEndedIterator`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Finds patterns that reimplement `Option::ok_or`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// let foo: Option<i32> = None;
+    /// foo.map_or(Err("error"), |v| Ok(v));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let foo: Option<i32> = None;
+    /// foo.ok_or("error");
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_OK_OR,
+    style,
+    "finds patterns that can be encoded more concisely with `Option::ok_or`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `repeat().take()` that can be replaced with `repeat_n()`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Using `repeat_n()` is more concise and clearer. Also, `repeat_n()` is sometimes faster than `repeat().take()` when the type of the element is non-trivial to clone because the original value can be reused for the last `.next()` call rather than always cloning.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = std::iter::repeat(10).take(3);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = std::iter::repeat_n(10, 3);
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_REPEAT_N,
+    style,
+    "detect `repeat().take()` that can be replaced with `repeat_n()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
+    ///
+    /// ### Why is this bad?
+    /// These can be written simply with `saturating_add/sub` methods.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let y: u32 = 0;
+    /// # let x: u32 = 100;
+    /// let add = x.checked_add(y).unwrap_or(u32::MAX);
+    /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
+    /// ```
+    ///
+    /// can be written using dedicated methods for saturating addition/subtraction as:
+    ///
+    /// ```no_run
+    /// # let y: u32 = 0;
+    /// # let x: u32 = 100;
+    /// let add = x.saturating_add(y);
+    /// let sub = x.saturating_sub(y);
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub MANUAL_SATURATING_ARITHMETIC,
+    style,
+    "`.checked_add/sub(x).unwrap_or(MAX/MIN)`"
 }
 
 declare_clippy_lint! {
@@ -2316,410 +2041,78 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+    /// Checks for manual implementations of `str::repeat`
+    ///
     /// ### Why is this bad?
-    /// The function `split` is simpler and there is no performance difference in these cases, considering
-    /// that both functions return a lazy iterator.
+    /// These are both harder to read, as well as less performant.
+    ///
     /// ### Example
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.splitn(3, '=').next().unwrap();
+    /// let x: String = std::iter::repeat('x').take(10).collect();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.split('=').next().unwrap();
+    /// let x: String = "x".repeat(10);
     /// ```
-    #[clippy::version = "1.59.0"]
-    pub NEEDLESS_SPLITN,
-    complexity,
-    "usages of `str::splitn` that can be replaced with `str::split`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
-    /// and other `to_owned`-like functions.
-    ///
-    /// ### Why is this bad?
-    /// The unnecessary calls result in useless allocations.
-    ///
-    /// ### Known problems
-    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
-    /// owned copy of a resource and the resource is later used mutably. See
-    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let path = std::path::Path::new("x");
-    /// foo(&path.to_string_lossy().to_string());
-    /// fn foo(s: &str) {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let path = std::path::Path::new("x");
-    /// foo(&path.to_string_lossy());
-    /// fn foo(s: &str) {}
-    /// ```
-    #[clippy::version = "1.59.0"]
-    pub UNNECESSARY_TO_OWNED,
+    #[clippy::version = "1.54.0"]
+    pub MANUAL_STR_REPEAT,
     perf,
-    "unnecessary calls to `to_owned`-like functions"
+    "manual implementation of `str::repeat`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.collect::<Vec<String>>().join("")` on iterators.
+    /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
     ///
     /// ### Why is this bad?
-    /// `.collect::<String>()` is more concise and might be more performant
+    /// The code should use `try_fold` instead, which short-circuits on failure, thus opening the
+    /// door for additional optimizations not possible with `fold` as rustc can guarantee the
+    /// function is never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's
+    /// also slightly more idiomatic.
+    ///
+    /// ### Known issues
+    /// This lint doesn't take into account whether a function does something on the failure case,
+    /// i.e., whether short-circuiting will affect behavior. Refactoring to `try_fold` is not
+    /// desirable in those cases.
     ///
     /// ### Example
     /// ```no_run
-    /// let vector = vec!["hello",  "world"];
-    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
-    /// println!("{}", output);
+    /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
     /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// let vector = vec!["hello",  "world"];
-    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
-    /// println!("{}", output);
-    /// ```
-    /// ### Known problems
-    /// While `.collect::<String>()` is sometimes more performant, there are cases where
-    /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
-    /// will prevent loop unrolling and will result in a negative performance impact.
-    ///
-    /// Additionally, differences have been observed between aarch64 and x86_64 assembly output,
-    /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
-    #[clippy::version = "1.61.0"]
-    pub UNNECESSARY_JOIN,
-    pedantic,
-    "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for no-op uses of `Option::{as_deref, as_deref_mut}`,
-    /// for example, `Option<&T>::as_deref()` returns the same type.
-    ///
-    /// ### Why is this bad?
-    /// Redundant code and improving readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let a = Some(&1);
-    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
-    /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let a = Some(&1);
-    /// let b = a;
+    /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
     /// ```
-    #[clippy::version = "1.57.0"]
-    pub NEEDLESS_OPTION_AS_DEREF,
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_TRY_FOLD,
+    perf,
+    "checks for usage of `Iterator::fold` with a type that implements `Try`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.map(…)`, followed by `.all(identity)` or `.any(identity)`.
+    ///
+    /// ### Why is this bad?
+    /// The `.all(…)` or `.any(…)` methods can be called directly in place of `.map(…)`.
+    ///
+    /// ### Example
+    /// ```
+    /// # let mut v = [""];
+    /// let e1 = v.iter().map(|s| s.is_empty()).all(|a| a);
+    /// let e2 = v.iter().map(|s| s.is_empty()).any(std::convert::identity);
+    /// ```
+    /// Use instead:
+    /// ```
+    /// # let mut v = [""];
+    /// let e1 = v.iter().all(|s| s.is_empty());
+    /// let e2 = v.iter().any(|s| s.is_empty());
+    /// ```
+    #[clippy::version = "1.84.0"]
+    pub MAP_ALL_ANY_IDENTITY,
     complexity,
-    "no-op use of `deref` or `deref_mut` method to `Option`."
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds usages of [`char::is_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
-    /// can be replaced with [`is_ascii_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
-    /// [`is_ascii_hexdigit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
-    ///
-    /// ### Why is this bad?
-    /// `is_digit(..)` is slower and requires specifying the radix.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let c: char = '6';
-    /// c.is_digit(10);
-    /// c.is_digit(16);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let c: char = '6';
-    /// c.is_ascii_digit();
-    /// c.is_ascii_hexdigit();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub IS_DIGIT_ASCII_RADIX,
-    style,
-    "use of `char::is_digit(..)` with literal radix of 10 or 16"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calling `take` function after `as_ref`.
-    ///
-    /// ### Why is this bad?
-    /// Redundant code. `take` writes `None` to its argument.
-    /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = Some(3);
-    /// x.as_ref().take();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = Some(3);
-    /// x.as_ref();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub NEEDLESS_OPTION_TAKE,
-    complexity,
-    "using `.as_ref().take()` on a temporary value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `replace` statements which have no effect.
-    ///
-    /// ### Why is this bad?
-    /// It's either a mistake or confusing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// "1234".replace("12", "12");
-    /// "1234".replacen("12", "12", 1);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub NO_EFFECT_REPLACE,
-    suspicious,
-    "replace with no effect"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary method chains that can be simplified into `if .. else ..`.
-    ///
-    /// ### Why is this bad?
-    /// This can be written more clearly with `if .. else ..`
-    ///
-    /// ### Limitations
-    /// This lint currently only looks for usages of
-    /// `.{then, then_some}(..).{unwrap_or, unwrap_or_else, unwrap_or_default}(..)`, but will be expanded
-    /// to account for similar patterns.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = true;
-    /// x.then_some("a").unwrap_or("b");
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = true;
-    /// if x { "a" } else { "b" };
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub OBFUSCATED_IF_ELSE,
-    style,
-    "use of `.then_some(..).unwrap_or(..)` can be written \
-    more clearly with `if .. else ..`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It is simpler to use the once function from the standard library:
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// let a = [123].iter();
-    /// let b = Some(123).into_iter();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::iter;
-    /// let a = iter::once(&123);
-    /// let b = iter::once(123);
-    /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.65.0"]
-    pub ITER_ON_SINGLE_ITEMS,
-    nursery,
-    "Iterator for array of length 1"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It is simpler to use the empty function from the standard library:
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// use std::{slice, option};
-    /// let a: slice::Iter<i32> = [].iter();
-    /// let f: option::IntoIter<i32> = None.into_iter();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::iter;
-    /// let a: iter::Empty<i32> = iter::empty();
-    /// let b: iter::Empty<i32> = iter::empty();
-    /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.65.0"]
-    pub ITER_ON_EMPTY_COLLECTIONS,
-    nursery,
-    "Iterator for empty array"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for naive byte counts
-    ///
-    /// ### Why is this bad?
-    /// The [`bytecount`](https://crates.io/crates/bytecount)
-    /// crate has methods to count your bytes faster, especially for large slices.
-    ///
-    /// ### Known problems
-    /// If you have predominantly small slices, the
-    /// `bytecount::count(..)` method may actually be slower. However, if you can
-    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
-    /// faster in those cases.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let vec = vec![1_u8];
-    /// let count = vec.iter().filter(|x| **x == 0u8).count();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// # let vec = vec![1_u8];
-    /// let count = bytecount::count(&vec, 0u8);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NAIVE_BYTECOUNT,
-    pedantic,
-    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// It checks for `str::bytes().count()` and suggests replacing it with
-    /// `str::len()`.
-    ///
-    /// ### Why is this bad?
-    /// `str::bytes().count()` is longer and may not be as performant as using
-    /// `str::len()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// "hello".bytes().count();
-    /// String::from("hello").bytes().count();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// "hello".len();
-    /// String::from("hello").len();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub BYTES_COUNT_TO_LEN,
-    complexity,
-    "Using `bytes().count()` when `len()` performs the same functionality"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `ends_with` with possible file extensions
-    /// and suggests to use a case-insensitive approach instead.
-    ///
-    /// ### Why is this bad?
-    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     filename.ends_with(".rs")
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     let filename = std::path::Path::new(filename);
-    ///     filename.extension()
-    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
-    /// }
-    /// ```
-    #[clippy::version = "1.51.0"]
-    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    pedantic,
-    "Checks for calls to ends_with with case-sensitive file extensions"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `x.get(0)` instead of
-    /// `x.first()` or `x.front()`.
-    ///
-    /// ### Why is this bad?
-    /// Using `x.first()` for `Vec`s and slices or `x.front()`
-    /// for `VecDeque`s is easier to read and has the same result.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.get(0);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.first();
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub GET_FIRST,
-    style,
-    "Using `x.get(0)` when `x.first()` or `x.front()` is simpler"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Finds patterns that reimplement `Option::ok_or`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Concise code helps focusing on behavior instead of boilerplate.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.map_or(Err("error"), |v| Ok(v));
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.ok_or("error");
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_OK_OR,
-    style,
-    "finds patterns that can be encoded more concisely with `Option::ok_or`"
+    "combine `.map(_)` followed by `.all(identity)`/`.any(identity)` into a single call"
 }
 
 declare_clippy_lint! {
@@ -2751,6 +2144,27 @@
     "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
+    ///
+    /// ### Why is this bad?
+    /// Using `try_for_each` instead is more readable and idiomatic.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// (0..3).try_for_each(|t| Err(t));
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MAP_COLLECT_RESULT_UNIT,
+    style,
+    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for instances of `map_err(|_| Some::Enum)`
@@ -2852,6 +2266,130 @@
     "`map_err` should not ignore the original error"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![vec![1]];
+    /// let opt = Some(5);
+    ///
+    /// vec.iter().map(|x| x.iter()).flatten();
+    /// opt.map(|x| Some(x * 2)).flatten();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let vec = vec![vec![1]];
+    /// # let opt = Some(5);
+    /// vec.iter().flat_map(|x| x.iter());
+    /// opt.and_then(|x| Some(x * 2));
+    /// ```
+    #[clippy::version = "1.31.0"]
+    pub MAP_FLATTEN,
+    complexity,
+    "using combinations of `flatten` and `map` which can usually be written as a single method call"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for instances of `map(f)` where `f` is the identity function.
+    ///
+    /// ### Why is this bad?
+    /// It can be written more concisely without the call to `map`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub MAP_IDENTITY,
+    complexity,
+    "using iterator.map(|x| x)"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+    /// `result.map(_).unwrap_or_else(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, these can be written more concisely (resp.) as
+    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
+    ///
+    /// ### Known problems
+    /// The order of the arguments is not in execution order
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// option.map(|a| a + 1).unwrap_or(0);
+    /// option.map(|a| a > 10).unwrap_or(false);
+    /// result.map(|a| a + 1).unwrap_or_else(some_function);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// option.map_or(0, |a| a + 1);
+    /// option.is_some_and(|a| a > 10);
+    /// result.map_or_else(some_function, |a| a + 1);
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub MAP_UNWRAP_OR,
+    pedantic,
+    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `Iterator::map` over ranges without using the parameter which
+    /// could be more clearly expressed using `std::iter::repeat(...).take(...)`
+    /// or `std::iter::repeat_n`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It expresses the intent more clearly to `take` the correct number of times
+    /// from a generating function than to apply a closure to each number in a
+    /// range only to discard them.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// let random_numbers : Vec<_> = (0..10).map(|_| { 3 + 1 }).collect();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let f : Vec<_> = std::iter::repeat( 3 + 1 ).take(10).collect();
+    /// ```
+    ///
+    /// ### Known Issues
+    ///
+    /// This lint may suggest replacing a `Map<Range>` with a `Take<RepeatWith>`.
+    /// The former implements some traits that the latter does not, such as
+    /// `DoubleEndedIterator`.
+    #[clippy::version = "1.84.0"]
+    pub MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    restriction,
+    "map of a trivial closure (not dependent on parameter) over a range"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `&mut Mutex::lock` calls
@@ -2888,6 +2426,260 @@
     "`&mut Mutex::lock` does unnecessary locking"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for naive byte counts
+    ///
+    /// ### Why is this bad?
+    /// The [`bytecount`](https://crates.io/crates/bytecount)
+    /// crate has methods to count your bytes faster, especially for large slices.
+    ///
+    /// ### Known problems
+    /// If you have predominantly small slices, the
+    /// `bytecount::count(..)` method may actually be slower. However, if you can
+    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
+    /// faster in those cases.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let vec = vec![1_u8];
+    /// let count = vec.iter().filter(|x| **x == 0u8).count();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let vec = vec![1_u8];
+    /// let count = bytecount::count(&vec, 0u8);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NAIVE_BYTECOUNT,
+    pedantic,
+    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
+}
+
+declare_clippy_lint! {
+   /// ### What it does
+   /// It detects useless calls to `str::as_bytes()` before calling `len()` or `is_empty()`.
+   ///
+   /// ### Why is this bad?
+   /// The `len()` and `is_empty()` methods are also directly available on strings, and they
+   /// return identical results. In particular, `len()` on a string returns the number of
+   /// bytes.
+   ///
+   /// ### Example
+   /// ```
+   /// let len = "some string".as_bytes().len();
+   /// let b = "some string".as_bytes().is_empty();
+   /// ```
+   /// Use instead:
+   /// ```
+   /// let len = "some string".len();
+   /// let b = "some string".is_empty();
+   /// ```
+   #[clippy::version = "1.84.0"]
+   pub NEEDLESS_AS_BYTES,
+   complexity,
+   "detect useless calls to `as_bytes()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if an iterator is used to check if a string is ascii.
+    ///
+    /// ### Why is this bad?
+    /// The `str` type already implements the `is_ascii` method.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// "foo".chars().all(|c| c.is_ascii());
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// "foo".is_ascii();
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub NEEDLESS_CHARACTER_ITERATION,
+    suspicious,
+    "is_ascii() called on a char iterator"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions collecting an iterator when collect
+    /// is not needed.
+    ///
+    /// ### Why is this bad?
+    /// `collect` causes the allocation of a new data structure,
+    /// when this allocation may not be needed.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.collect::<Vec<_>>().len();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.count();
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub NEEDLESS_COLLECT,
+    nursery,
+    "collecting an iterator when collect is not needed"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for no-op uses of `Option::{as_deref, as_deref_mut}`,
+    /// for example, `Option<&T>::as_deref()` returns the same type.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code and improving readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let a = Some(&1);
+    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let a = Some(&1);
+    /// let b = a;
+    /// ```
+    #[clippy::version = "1.57.0"]
+    pub NEEDLESS_OPTION_AS_DEREF,
+    complexity,
+    "no-op use of `deref` or `deref_mut` method to `Option`."
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calling `take` function after `as_ref`.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code. `take` writes `None` to its argument.
+    /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = Some(3);
+    /// x.as_ref().take();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = Some(3);
+    /// x.as_ref();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub NEEDLESS_OPTION_TAKE,
+    complexity,
+    "using `.as_ref().take()` on a temporary value"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+    /// ### Why is this bad?
+    /// The function `split` is simpler and there is no performance difference in these cases, considering
+    /// that both functions return a lazy iterator.
+    /// ### Example
+    /// ```no_run
+    /// let str = "key=value=add";
+    /// let _ = str.splitn(3, '=').next().unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let str = "key=value=add";
+    /// let _ = str.split('=').next().unwrap();
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub NEEDLESS_SPLITN,
+    complexity,
+    "usages of `str::splitn` that can be replaced with `str::split`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `new` not returning a type that contains `Self`.
+    ///
+    /// ### Why is this bad?
+    /// As a convention, `new` methods are used to make a new
+    /// instance of a type.
+    ///
+    /// ### Example
+    /// In an impl block:
+    /// ```no_run
+    /// # struct Foo;
+    /// # struct NotAFoo;
+    /// impl Foo {
+    ///     fn new() -> NotAFoo {
+    /// # NotAFoo
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ```no_run
+    /// # struct Foo;
+    /// struct Bar(Foo);
+    /// impl Foo {
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new() -> Bar {
+    /// # Bar(Foo)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ```no_run
+    /// # struct Foo;
+    /// # struct FooError;
+    /// impl Foo {
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Result<Foo, FooError> {
+    /// # Ok(Foo)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Or in a trait definition:
+    /// ```no_run
+    /// pub trait Trait {
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new();
+    /// }
+    /// ```
+    ///
+    /// ```no_run
+    /// pub trait Trait {
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Self;
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEW_RET_NO_SELF,
+    style,
+    "not returning type containing `Self` in a `new` method"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `replace` statements which have no effect.
+    ///
+    /// ### Why is this bad?
+    /// It's either a mistake or confusing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// "1234".replace("12", "12");
+    /// "1234".replacen("12", "12", 1);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub NO_EFFECT_REPLACE,
+    suspicious,
+    "replace with no effect"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for duplicate open options as well as combinations
@@ -2911,40 +2703,232 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the suspicious use of `OpenOptions::create()`
-    /// without an explicit `OpenOptions::truncate()`.
+    /// Checks for unnecessary method chains that can be simplified into `if .. else ..`.
     ///
     /// ### Why is this bad?
-    /// `create()` alone will either create a new file or open an
-    /// existing file. If the file already exists, it will be
-    /// overwritten when written to, but the file will not be
-    /// truncated by default.
-    /// If less data is written to the file
-    /// than it already contains, the remainder of the file will
-    /// remain unchanged, and the end of the file will contain old
-    /// data.
-    /// In most cases, one should either use `create_new` to ensure
-    /// the file is created from scratch, or ensure `truncate` is
-    /// called so that the truncation behaviour is explicit. `truncate(true)`
-    /// will ensure the file is entirely overwritten with new data, whereas
-    /// `truncate(false)` will explicitly keep the default behavior.
+    /// This can be written more clearly with `if .. else ..`
+    ///
+    /// ### Limitations
+    /// This lint currently only looks for usages of
+    /// `.{then, then_some}(..).{unwrap_or, unwrap_or_else, unwrap_or_default}(..)`, but will be expanded
+    /// to account for similar patterns.
     ///
     /// ### Example
-    /// ```rust,no_run
-    /// use std::fs::OpenOptions;
-    ///
-    /// OpenOptions::new().create(true);
+    /// ```no_run
+    /// let x = true;
+    /// x.then_some("a").unwrap_or("b");
     /// ```
     /// Use instead:
-    /// ```rust,no_run
-    /// use std::fs::OpenOptions;
+    /// ```no_run
+    /// let x = true;
+    /// if x { "a" } else { "b" };
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub OBFUSCATED_IF_ELSE,
+    style,
+    "use of `.then_some(..).unwrap_or(..)` can be written \
+    more clearly with `if .. else ..`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `ok().expect(..)`.
     ///
-    /// OpenOptions::new().create(true).truncate(true);
+    /// Note: This lint only triggers for code marked compatible
+    /// with versions of the compiler older than Rust 1.82.0.
+    ///
+    /// ### Why is this bad?
+    /// Because you usually call `expect()` on the `Result`
+    /// directly to get a better error message.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = Ok::<_, ()>(());
+    /// x.ok().expect("why did I do this again?");
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = Ok::<_, ()>(());
+    /// x.expect("why did I do this again?");
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OK_EXPECT,
+    style,
+    "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.as_ref().cloned()` and `.as_mut().cloned()` on `Option`s
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely by cloning the `Option` directly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.as_ref().cloned()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.clone()
+    /// }
     /// ```
     #[clippy::version = "1.77.0"]
-    pub SUSPICIOUS_OPEN_OPTIONS,
-    suspicious,
-    "suspicious combination of options for opening a file"
+    pub OPTION_AS_REF_CLONED,
+    pedantic,
+    "cloning an `Option` via `as_ref().cloned()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.as_deref()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let opt = Some("".to_string());
+    /// opt.as_ref().map(String::as_str)
+    /// # ;
+    /// ```
+    /// Can be written as
+    /// ```no_run
+    /// # let opt = Some("".to_string());
+    /// opt.as_deref()
+    /// # ;
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub OPTION_AS_REF_DEREF,
+    complexity,
+    "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for iterators of `Option`s using `.filter(Option::is_some).map(Option::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
+    ///
+    /// ### Why is this bad?
+    /// `Option` is like a collection of 0-1 things, so `flatten`
+    /// automatically does this without suspicious-looking `unwrap` calls.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+    /// ```
+    #[clippy::version = "1.53.0"]
+    pub OPTION_FILTER_MAP,
+    complexity,
+    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.map_or(None, _)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.and_then(_)`.
+    ///
+    /// ### Known problems
+    /// The order of the arguments is not in execution order.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.map_or(None, |a| Some(a + 1));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.and_then(|a| Some(a + 1));
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OPTION_MAP_OR_NONE,
+    style,
+    "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
+    /// `.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
+    /// `.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
+    /// etc. instead.
+    ///
+    /// ### Why is this bad?
+    /// The function will always be called. This is only bad if it allocates or
+    /// does some non-trivial amount of work.
+    ///
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will change the
+    /// semantic of the program, but you shouldn't rely on that.
+    ///
+    /// The lint also cannot figure out whether the function you call is
+    /// actually expensive to call or not.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let foo = Some(String::new());
+    /// foo.unwrap_or(String::from("empty"));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let foo = Some(String::new());
+    /// foo.unwrap_or_else(|| String::from("empty"));
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OR_FUN_CALL,
+    nursery,
+    "using any `*or` method with a function call, which suggests `*or_else`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.or(…).unwrap()` calls to Options and Results.
+    ///
+    /// ### Why is this bad?
+    /// You should use `.unwrap_or(…)` instead for clarity.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # type Error = &'static str;
+    /// # let result: Result<&str, Error> = Err("error");
+    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.or(Some(fallback)).unwrap();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # let result: Result<&str, &str> = Err("error");
+    /// let value = result.unwrap_or(fallback);
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.unwrap_or(fallback);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub OR_THEN_UNWRAP,
+    complexity,
+    "checks for `.or(…).unwrap()` calls to Options and Results."
 }
 
 declare_clippy_lint! {
@@ -2979,6 +2963,116 @@
     "calling `push` with file system root on `PathBuf` can overwrite it"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to `Path::ends_with` calls where the argument looks like a file extension.
+    ///
+    /// By default, Clippy has a short list of known filenames that start with a dot
+    /// but aren't necessarily file extensions (e.g. the `.git` folder), which are allowed by default.
+    /// The `allowed-dotfiles` configuration can be used to allow additional
+    /// file extensions that Clippy should not lint.
+    ///
+    /// ### Why is this bad?
+    /// This doesn't actually compare file extensions. Rather, `ends_with` compares the given argument
+    /// to the last **component** of the path and checks if it matches exactly.
+    ///
+    /// ### Known issues
+    /// File extensions are often at most three characters long, so this only lints in those cases
+    /// in an attempt to avoid false positives.
+    /// Any extension names longer than that are assumed to likely be real path components and are
+    /// therefore ignored.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.ends_with(".md")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.extension().is_some_and(|ext| ext == "md")
+    /// }
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub PATH_ENDS_WITH_EXT,
+    suspicious,
+    "attempting to compare file extensions using `Path::ends_with`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `offset` pointer method with an integer
+    /// literal.
+    ///
+    /// ### Why is this bad?
+    /// The `add` and `sub` methods more accurately express the intent.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    ///
+    /// unsafe {
+    ///     ptr.offset(-8);
+    /// }
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    ///
+    /// unsafe {
+    ///     ptr.sub(8);
+    /// }
+    /// ```
+    #[clippy::version = "1.92.0"]
+    pub PTR_OFFSET_BY_LITERAL,
+    pedantic,
+    "unneeded pointer offset"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
+    /// `isize`.
+    ///
+    /// ### Why is this bad?
+    /// If we’re always increasing the pointer address, we can avoid the numeric
+    /// cast by using the `add` method instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.offset(offset as isize);
+    /// }
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.add(offset);
+    /// }
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub PTR_OFFSET_WITH_CAST,
+    complexity,
+    "unneeded pointer offset cast"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for zipping a collection with the range of
@@ -3004,6 +3098,119 @@
     "zipping iterator with a range when `enumerate()` would do"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
+    /// into a string, then later attempting to use that string for an operation that will never
+    /// work for strings with a trailing newline character in it (e.g. parsing into a `i32`).
+    ///
+    /// ### Why is this bad?
+    /// The operation will always fail at runtime no matter what the user enters, thus
+    /// making it a useless operation.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.parse().expect("Not a number!");
+    /// assert_eq!(num, 42); // we never even get here!
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.trim_end().parse().expect("Not a number!");
+    /// //                  ^^^^^^^^^^^ remove the trailing newline
+    /// assert_eq!(num, 42);
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub READ_LINE_WITHOUT_TRIM,
+    correctness,
+    "calling `Stdin::read_line`, then trying to parse it without first trimming"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to `RwLock::write` where the lock is only used for reading.
+    ///
+    /// ### Why is this bad?
+    /// The write portion of `RwLock` is exclusive, meaning that no other thread
+    /// can access the lock while this writer is active.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.write().unwrap();
+    ///     assert_eq!(*num, 0);
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.read().unwrap();
+    ///     assert_eq!(*num, 0);
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub READONLY_WRITE_LOCK,
+    perf,
+    "acquiring a write lock when a read lock would work"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `as_str()` on a `String` chained with a method available on the `String` itself.
+    ///
+    /// ### Why is this bad?
+    /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_str().as_bytes()
+    /// # ;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_bytes()
+    /// # ;
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub REDUNDANT_AS_STR,
+    complexity,
+    "`as_str` used to call a method on `str` that is also available on `String`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Iterator::cloned` where the original value could be used
+    /// instead.
+    ///
+    /// ### Why is this bad?
+    /// It is not always possible for the compiler to eliminate useless allocations and
+    /// deallocations generated by redundant `clone()`s.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().cloned().map(|x| x.len());
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().map(|x| x.len());
+    /// ```
+    #[clippy::version = "1.92.0"]
+    pub REDUNDANT_ITER_CLONED,
+    perf,
+    "detects redundant calls to `Iterator::cloned`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
@@ -3038,233 +3245,120 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// When sorting primitive values (integers, bools, chars, as well
-    /// as arrays, slices, and tuples of such items), it is typically better to
-    /// use an unstable sort than a stable sort.
+    /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
     ///
     /// ### Why is this bad?
-    /// Typically, using a stable sort consumes more memory and cpu cycles.
-    /// Because values which compare equal are identical, preserving their
-    /// relative order (the guarantee that a stable sort provides) means
-    /// nothing, while the extra costs still apply.
-    ///
-    /// ### Known problems
-    ///
-    /// As pointed out in
-    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
-    /// a stable sort can instead be significantly faster for certain scenarios
-    /// (eg. when a sorted vector is extended with new data and resorted).
-    ///
-    /// For more information and benchmarking results, please refer to the
-    /// issue linked above.
+    /// `Result` implements `IntoIterator<Item = T>`. This means that `Result` can be flattened
+    /// automatically without suspicious-looking `unwrap` calls.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort();
+    /// let _ = std::iter::empty::<Result<i32, ()>>().filter(Result::is_ok).map(Result::unwrap);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort_unstable();
+    /// let _ = std::iter::empty::<Result<i32, ()>>().flatten();
     /// ```
-    #[clippy::version = "1.47.0"]
-    pub STABLE_SORT_PRIMITIVE,
-    pedantic,
-    "use of sort() when sort_unstable() is equivalent"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for calls to `.type_id()` on a `Box<dyn _>`.
-    ///
-    /// ### Why is this bad?
-    /// This almost certainly does not do what the user expects and can lead to subtle bugs.
-    /// Calling `.type_id()` on a `Box<dyn Trait>` returns a fixed `TypeId` of the `Box` itself,
-    /// rather than returning the `TypeId` of the underlying type behind the trait object.
-    ///
-    /// For `Box<dyn Any>` specifically (and trait objects that have `Any` as its supertrait),
-    /// this lint will provide a suggestion, which is to dereference the receiver explicitly
-    /// to go from `Box<dyn Any>` to `dyn Any`.
-    /// This makes sure that `.type_id()` resolves to a dynamic call on the trait object
-    /// and not on the box.
-    ///
-    /// If the fixed `TypeId` of the `Box` is the intended behavior, it's better to be explicit about it
-    /// and write `TypeId::of::<Box<dyn Trait>>()`:
-    /// this makes it clear that a fixed `TypeId` is returned and not the `TypeId` of the implementor.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// use std::any::{Any, TypeId};
-    ///
-    /// let any_box: Box<dyn Any> = Box::new(42_i32);
-    /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::any::{Any, TypeId};
-    ///
-    /// let any_box: Box<dyn Any> = Box::new(42_i32);
-    /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
-    /// //          ^ dereference first, to call `type_id` on `dyn Any`
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub TYPE_ID_ON_BOX,
-    suspicious,
-    "calling `.type_id()` on a boxed trait object"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects `().hash(_)`.
-    ///
-    /// ### Why is this bad?
-    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => ().hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => 0_u8.hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
-    /// }
-    /// ```
-    #[clippy::version = "1.58.0"]
-    pub UNIT_HASH,
-    correctness,
-    "hashing a unit value, which does nothing"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Vec::sort_by` passing in a closure
-    /// which compares the two arguments, either directly or indirectly.
-    ///
-    /// ### Why is this bad?
-    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
-    /// possible) than to use `Vec::sort_by` and a more complicated
-    /// closure.
-    ///
-    /// ### Known problems
-    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
-    /// imported by a use statement, then it will need to be added manually.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by_key(|a| a.foo());
-    /// ```
-    #[clippy::version = "1.46.0"]
-    pub UNNECESSARY_SORT_BY,
+    #[clippy::version = "1.77.0"]
+    pub RESULT_FILTER_MAP,
     complexity,
-    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
+    "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds occurrences of `Vec::resize(0, an_int)`
+    /// Checks for usage of `_.map_or(None, Some)`.
     ///
     /// ### Why is this bad?
-    /// This is probably an argument inversion mistake.
+    /// Readability, this can be written more concisely as
+    /// `_.ok()`.
     ///
     /// ### Example
     /// ```no_run
-    /// vec![1, 2, 3, 4, 5].resize(0, 5)
+    /// # let r: Result<u32, &str> = Ok(1);
+    /// assert_eq!(Some(1), r.map_or(None, Some));
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// vec![1, 2, 3, 4, 5].clear()
-    /// ```
-    #[clippy::version = "1.46.0"]
-    pub VEC_RESIZE_TO_ZERO,
-    correctness,
-    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of File::read_to_end and File::read_to_string.
-    ///
-    /// ### Why restrict this?
-    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
-    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # use std::io::Read;
-    /// # use std::fs::File;
-    /// let mut f = File::open("foo.txt").unwrap();
-    /// let mut bytes = Vec::new();
-    /// f.read_to_end(&mut bytes).unwrap();
-    /// ```
-    /// Can be written more concisely as
-    /// ```rust,no_run
-    /// # use std::fs;
-    /// let mut bytes = fs::read("foo.txt").unwrap();
+    /// # let r: Result<u32, &str> = Ok(1);
+    /// assert_eq!(Some(1), r.ok());
     /// ```
     #[clippy::version = "1.44.0"]
-    pub VERBOSE_FILE_READS,
-    restriction,
-    "use of `File::read_to_end` or `File::read_to_string`"
+    pub RESULT_MAP_OR_INTO_OPTION,
+    style,
+    "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
-    /// ignoring either the keys or values.
+    /// Detect functions that end with `Option::and_then` or `Result::and_then`, and suggest using
+    /// the `?` operator instead.
     ///
     /// ### Why is this bad?
-    ///
-    /// Readability. There are `keys` and `values` methods that
-    /// can be used to express that we only need the keys or the values.
+    /// The `and_then` method is used to chain a computation that returns an `Option` or a `Result`.
+    /// This can be replaced with the `?` operator, which is more concise and idiomatic.
     ///
     /// ### Example
     ///
     /// ```no_run
-    /// # use std::collections::HashMap;
-    /// let map: HashMap<u32, u32> = HashMap::new();
-    /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    /// fn test(opt: Option<i32>) -> Option<i32> {
+    ///     opt.and_then(|n| {
+    ///         if n > 1 {
+    ///             Some(n + 1)
+    ///         } else {
+    ///             None
+    ///        }
+    ///     })
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn test(opt: Option<i32>) -> Option<i32> {
+    ///     let n = opt?;
+    ///     if n > 1 {
+    ///         Some(n + 1)
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub RETURN_AND_THEN,
+    restriction,
+    "using `Option::and_then` or `Result::and_then` to chain a computation that returns an `Option` or a `Result`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an iterator or string search (such as `find()`,
+    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as:
+    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
+    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![1];
+    /// vec.iter().find(|x| **x == 0).is_some();
+    ///
+    /// "hello world".find("world").is_none();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashMap;
-    /// let map: HashMap<u32, u32> = HashMap::new();
-    /// let values = map.values().collect::<Vec<_>>();
+    /// let vec = vec![1];
+    /// vec.iter().any(|x| *x == 0);
+    ///
+    /// !"hello world".contains("world");
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub ITER_KV_MAP,
-    complexity,
-    "iterating on map using `iter` when `keys` or `values` would do"
+    #[clippy::version = "pre 1.29.0"]
+    pub SEARCH_IS_SOME,
+    nursery,
+    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
 }
 
 declare_clippy_lint! {
@@ -3343,631 +3437,150 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions collecting an iterator when collect
-    /// is not needed.
+    /// Checks for methods that should live in a trait
+    /// implementation of a `std` trait (see [llogiq's blog
+    /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
+    /// information) instead of an inherent implementation.
     ///
     /// ### Why is this bad?
-    /// `collect` causes the allocation of a new data structure,
-    /// when this allocation may not be needed.
+    /// Implementing the traits improve ergonomics for users of
+    /// the code, often with very little cost. Also people seeing a `mul(...)`
+    /// method
+    /// may expect `*` to work equally, so you should have good reason to disappoint
+    /// them.
     ///
     /// ### Example
     /// ```no_run
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.collect::<Vec<_>>().len();
+    /// struct X;
+    /// impl X {
+    ///     fn add(&self, other: &X) -> X {
+    ///         // ..
+    /// # X
+    ///     }
+    /// }
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.count();
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub NEEDLESS_COLLECT,
-    nursery,
-    "collecting an iterator when collect is not needed"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `Command::arg()` invocations that look like they
-    /// should be multiple arguments instead, such as `arg("-t ext2")`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// `Command::arg()` does not split arguments by space. An argument like `arg("-t ext2")`
-    /// will be passed as a single argument to the command,
-    /// which is likely not what was intended.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
-    /// ```
-    #[clippy::version = "1.69.0"]
-    pub SUSPICIOUS_COMMAND_ARG_SPACE,
-    suspicious,
-    "single command line argument that looks like it should be multiple arguments"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a container.
-    ///
-    /// ### Why is this bad?
-    /// This creates an unnecessary iterator that is dropped immediately.
-    ///
-    /// Calling `.clear()` also makes the intent clearer.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut v = vec![1, 2, 3];
-    /// v.drain(..);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let mut v = vec![1, 2, 3];
-    /// v.clear();
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub CLEAR_WITH_DRAIN,
-    nursery,
-    "calling `drain` in order to `clear` a container"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.rev().next()` on a `DoubleEndedIterator`
-    ///
-    /// ### Why is this bad?
-    /// `.next_back()` is cleaner.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let foo = [0; 10];
-    /// foo.iter().rev().next();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let foo = [0; 10];
-    /// foo.iter().next_back();
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub MANUAL_NEXT_BACK,
+    #[clippy::version = "pre 1.29.0"]
+    pub SHOULD_IMPLEMENT_TRAIT,
     style,
-    "manual reverse iteration of `DoubleEndedIterator`"
+    "defining a method that should be implementing a std trait"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.
-    ///
-    /// > "Collection" in this context refers to any type with a `drain` method:
-    /// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`
+    /// Warns when using `push_str`/`insert_str` with a single-character string literal
+    /// where `push`/`insert` with a `char` would work fine.
     ///
     /// ### Why is this bad?
-    /// Using `mem::take` is faster as it avoids the allocation.
-    /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
-    /// the old collection is returned.
-    ///
-    /// ### Known issues
-    /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
-    /// it also moves the **capacity**. The user might have explicitly written it this way
-    /// to keep the capacity on the original `Vec`.
+    /// It's less clear that we are pushing a single character.
     ///
     /// ### Example
     /// ```no_run
-    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
-    ///     v.drain(..).collect()
-    /// }
+    /// # let mut string = String::new();
+    /// string.insert_str(0, "R");
+    /// string.push_str("R");
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// use std::mem;
-    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
-    ///     mem::take(v)
-    /// }
+    /// # let mut string = String::new();
+    /// string.insert(0, 'R');
+    /// string.push('R');
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub DRAIN_COLLECT,
-    perf,
-    "calling `.drain(..).collect()` to move all elements into a new collection"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
-    ///
-    /// ### Why is this bad?
-    /// The code should use `try_fold` instead, which short-circuits on failure, thus opening the
-    /// door for additional optimizations not possible with `fold` as rustc can guarantee the
-    /// function is never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's
-    /// also slightly more idiomatic.
-    ///
-    /// ### Known issues
-    /// This lint doesn't take into account whether a function does something on the failure case,
-    /// i.e., whether short-circuiting will affect behavior. Refactoring to `try_fold` is not
-    /// desirable in those cases.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub MANUAL_TRY_FOLD,
-    perf,
-    "checks for usage of `Iterator::fold` with a type that implements `Try`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
-    /// into a string, then later attempting to use that string for an operation that will never
-    /// work for strings with a trailing newline character in it (e.g. parsing into a `i32`).
-    ///
-    /// ### Why is this bad?
-    /// The operation will always fail at runtime no matter what the user enters, thus
-    /// making it a useless operation.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let mut input = String::new();
-    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
-    /// let num: i32 = input.parse().expect("Not a number!");
-    /// assert_eq!(num, 42); // we never even get here!
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// let mut input = String::new();
-    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
-    /// let num: i32 = input.trim_end().parse().expect("Not a number!");
-    /// //                  ^^^^^^^^^^^ remove the trailing newline
-    /// assert_eq!(num, 42);
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub READ_LINE_WITHOUT_TRIM,
-    correctness,
-    "calling `Stdin::read_line`, then trying to parse it without first trimming"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `<string_lit>.chars().any(|i| i == c)`.
-    ///
-    /// ### Why is this bad?
-    /// It's significantly slower than using a pattern instead, like
-    /// `matches!(c, '\\' | '.' | '+')`.
-    ///
-    /// Despite this being faster, this is not `perf` as this is pretty common, and is a rather nice
-    /// way to check if a `char` is any in a set. In any case, this `restriction` lint is available
-    /// for situations where that additional performance is absolutely necessary.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let c = 'c';
-    /// "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let c = 'c';
-    /// matches!(c, '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub STRING_LIT_CHARS_ANY,
-    restriction,
-    "checks for `<string_lit>.chars().any(|i| i == c)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
-    ///
-    /// ### Why is this bad?
-    /// This allocates a new string for every element in the iterator.
-    /// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,
-    /// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,
-    /// or concatenating with `+` in case the iterator yields `&str`/`String`.
-    ///
-    /// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,
-    /// so it can be safely ignored or unwrapped.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn hex_encode(bytes: &[u8]) -> String {
-    ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::fmt::Write;
-    /// fn hex_encode(bytes: &[u8]) -> String {
-    ///     bytes.iter().fold(String::new(), |mut output, b| {
-    ///         let _ = write!(output, "{b:02X}");
-    ///         output
-    ///     })
-    /// }
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub FORMAT_COLLECT,
-    pedantic,
-    "`format!`ing every element in a collection, then collecting the strings into a new `String`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.skip(0)` on iterators.
-    ///
-    /// ### Why is this bad?
-    /// This was likely intended to be `.skip(1)` to skip the first element, as `.skip(0)` does
-    /// nothing. If not, the call should be removed.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// let x = v.iter().skip(0).collect::<Vec<_>>();
-    /// let y = v.iter().collect::<Vec<_>>();
-    /// assert_eq!(x, y);
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub ITER_SKIP_ZERO,
-    correctness,
-    "disallows `.skip(0)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `bool::then` in `Iterator::filter_map`.
-    ///
-    /// ### Why is this bad?
-    /// This can be written with `filter` then `map` instead, which would reduce nesting and
-    /// separates the filtering from the transformation phase. This comes with no cost to
-    /// performance and is just cleaner.
-    ///
-    /// ### Limitations
-    /// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.
-    /// This can create differing behavior, so better safe than sorry.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # fn really_expensive_fn(i: i32) -> i32 { i }
-    /// # let v = vec![];
-    /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # fn really_expensive_fn(i: i32) -> i32 { i }
-    /// # let v = vec![];
-    /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub FILTER_MAP_BOOL_THEN,
+    #[clippy::version = "1.49.0"]
+    pub SINGLE_CHAR_ADD_STR,
     style,
-    "checks for usage of `bool::then` in `Iterator::filter_map`"
+    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for calls to `RwLock::write` where the lock is only used for reading.
+    /// Checks for usage of `_.skip_while(condition).next()`.
     ///
     /// ### Why is this bad?
-    /// The write portion of `RwLock` is exclusive, meaning that no other thread
-    /// can access the lock while this writer is active.
+    /// Readability, this can be written more concisely as
+    /// `_.find(!condition)`.
     ///
     /// ### Example
     /// ```no_run
-    /// use std::sync::RwLock;
-    /// fn assert_is_zero(lock: &RwLock<i32>) {
-    ///     let num = lock.write().unwrap();
-    ///     assert_eq!(*num, 0);
-    /// }
+    /// # let vec = vec![1];
+    /// vec.iter().skip_while(|x| **x == 0).next();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// use std::sync::RwLock;
-    /// fn assert_is_zero(lock: &RwLock<i32>) {
-    ///     let num = lock.read().unwrap();
-    ///     assert_eq!(*num, 0);
-    /// }
+    /// # let vec = vec![1];
+    /// vec.iter().find(|x| **x != 0);
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub READONLY_WRITE_LOCK,
-    perf,
-    "acquiring a write lock when a read lock would work"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for iterator combinator calls such as `.take(x)` or `.skip(x)`
-    /// where `x` is greater than the amount of items that an iterator will produce.
-    ///
-    /// ### Why is this bad?
-    /// Taking or skipping more items than there are in an iterator either creates an iterator
-    /// with all items from the original iterator or an iterator with no items at all.
-    /// This is most likely not what the user intended to do.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// for _ in [1, 2, 3].iter().take(4) {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// for _ in [1, 2, 3].iter() {}
-    /// ```
-    #[clippy::version = "1.74.0"]
-    pub ITER_OUT_OF_BOUNDS,
-    suspicious,
-    "calls to `.take()` or `.skip()` that are out of bounds"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for calls to `Path::ends_with` calls where the argument looks like a file extension.
-    ///
-    /// By default, Clippy has a short list of known filenames that start with a dot
-    /// but aren't necessarily file extensions (e.g. the `.git` folder), which are allowed by default.
-    /// The `allowed-dotfiles` configuration can be used to allow additional
-    /// file extensions that Clippy should not lint.
-    ///
-    /// ### Why is this bad?
-    /// This doesn't actually compare file extensions. Rather, `ends_with` compares the given argument
-    /// to the last **component** of the path and checks if it matches exactly.
-    ///
-    /// ### Known issues
-    /// File extensions are often at most three characters long, so this only lints in those cases
-    /// in an attempt to avoid false positives.
-    /// Any extension names longer than that are assumed to likely be real path components and are
-    /// therefore ignored.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::path::Path;
-    /// fn is_markdown(path: &Path) -> bool {
-    ///     path.ends_with(".md")
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::path::Path;
-    /// fn is_markdown(path: &Path) -> bool {
-    ///     path.extension().is_some_and(|ext| ext == "md")
-    /// }
-    /// ```
-    #[clippy::version = "1.74.0"]
-    pub PATH_ENDS_WITH_EXT,
-    suspicious,
-    "attempting to compare file extensions using `Path::ends_with`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `as_str()` on a `String` chained with a method available on the `String` itself.
-    ///
-    /// ### Why is this bad?
-    /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_str().as_bytes()
-    /// # ;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_bytes()
-    /// # ;
-    /// ```
-    #[clippy::version = "1.74.0"]
-    pub REDUNDANT_AS_STR,
+    #[clippy::version = "1.42.0"]
+    pub SKIP_WHILE_NEXT,
     complexity,
-    "`as_str` used to call a method on `str` that is also available on `String`"
+    "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `waker.clone().wake()`
+    /// Checks for string slices immediately followed by `as_bytes`.
     ///
     /// ### Why is this bad?
-    /// Cloning the waker is not necessary, `wake_by_ref()` enables the same operation
-    /// without extra cloning/dropping.
+    /// It involves doing an unnecessary UTF-8 alignment check which is less efficient, and can cause a panic.
     ///
-    /// ### Example
-    /// ```rust,ignore
-    /// waker.clone().wake();
-    /// ```
-    /// Should be written
-    /// ```rust,ignore
-    /// waker.wake_by_ref();
-    /// ```
-    #[clippy::version = "1.75.0"]
-    pub WAKER_CLONE_WAKE,
-    perf,
-    "cloning a `Waker` only to wake it"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `TryInto::try_into` and `TryFrom::try_from` when their infallible counterparts
-    /// could be used.
-    ///
-    /// ### Why is this bad?
-    /// In those cases, the `TryInto` and `TryFrom` trait implementation is a blanket impl that forwards
-    /// to `Into` or `From`, which always succeeds.
-    /// The returned `Result<_, Infallible>` requires error handling to get the contained value
-    /// even though the conversion can never fail.
+    /// ### Known problems
+    /// In some cases, the UTF-8 validation and potential panic from string slicing may be required for
+    /// the code's correctness. If you need to ensure the slice boundaries fall on valid UTF-8 character
+    /// boundaries, the original form (`s[1..5].as_bytes()`) should be preferred.
     ///
     /// ### Example
     /// ```rust
-    /// let _: Result<i64, _> = 1i32.try_into();
-    /// let _: Result<i64, _> = <_>::try_from(1i32);
+    /// let s = "Lorem ipsum";
+    /// s[1..5].as_bytes();
     /// ```
-    /// Use `from`/`into` instead:
+    /// Use instead:
     /// ```rust
-    /// let _: i64 = 1i32.into();
-    /// let _: i64 = <_>::from(1i32);
+    /// let s = "Lorem ipsum";
+    /// &s.as_bytes()[1..5];
     /// ```
-    #[clippy::version = "1.75.0"]
-    pub UNNECESSARY_FALLIBLE_CONVERSIONS,
-    style,
-    "calling the `try_from` and `try_into` trait methods when `From`/`Into` is implemented"
+     #[clippy::version = "1.86.0"]
+     pub SLICED_STRING_AS_BYTES,
+     perf,
+     "slicing a string and immediately calling as_bytes is less efficient and can lead to panics"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `Path::join` that start with a path separator (`\\` or `/`).
+    /// When sorting primitive values (integers, bools, chars, as well
+    /// as arrays, slices, and tuples of such items), it is typically better to
+    /// use an unstable sort than a stable sort.
     ///
     /// ### Why is this bad?
-    /// If the argument to `Path::join` starts with a separator, it will overwrite
-    /// the original path. If this is intentional, prefer using `Path::new` instead.
+    /// Typically, using a stable sort consumes more memory and cpu cycles.
+    /// Because values which compare equal are identical, preserving their
+    /// relative order (the guarantee that a stable sort provides) means
+    /// nothing, while the extra costs still apply.
     ///
-    /// Note the behavior is platform dependent. A leading `\\` will be accepted
-    /// on unix systems as part of the file name
+    /// ### Known problems
     ///
-    /// See [`Path::join`](https://doc.rust-lang.org/std/path/struct.Path.html#method.join)
+    /// As pointed out in
+    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
+    /// a stable sort can instead be significantly faster for certain scenarios
+    /// (eg. when a sorted vector is extended with new data and resorted).
     ///
-    /// ### Example
-    /// ```rust
-    /// # use std::path::{Path, PathBuf};
-    /// let path = Path::new("/bin");
-    /// let joined_path = path.join("/sh");
-    /// assert_eq!(joined_path, PathBuf::from("/sh"));
-    /// ```
-    ///
-    /// Use instead;
-    /// ```rust
-    /// # use std::path::{Path, PathBuf};
-    /// let path = Path::new("/bin");
-    ///
-    /// // If this was unintentional, remove the leading separator
-    /// let joined_path = path.join("sh");
-    /// assert_eq!(joined_path, PathBuf::from("/bin/sh"));
-    ///
-    /// // If this was intentional, create a new path instead
-    /// let new = Path::new("/sh");
-    /// assert_eq!(new, PathBuf::from("/sh"));
-    /// ```
-    #[clippy::version = "1.76.0"]
-    pub JOIN_ABSOLUTE_PATHS,
-    suspicious,
-    "calls to `Path::join` which will overwrite the original path"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
-    /// be replaced with a `.flatten()` call.
-    ///
-    /// ### Why is this bad?
-    /// `Result` implements `IntoIterator<Item = T>`. This means that `Result` can be flattened
-    /// automatically without suspicious-looking `unwrap` calls.
+    /// For more information and benchmarking results, please refer to the
+    /// issue linked above.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = std::iter::empty::<Result<i32, ()>>().filter(Result::is_ok).map(Result::unwrap);
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let _ = std::iter::empty::<Result<i32, ()>>().flatten();
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort_unstable();
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub RESULT_FILTER_MAP,
-    complexity,
-    "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.filter(Option::is_some)` that may be replaced with a `.flatten()` call.
-    /// This lint will require additional changes to the follow-up calls as it affects the type.
-    ///
-    /// ### Why is this bad?
-    /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
-    /// results in more readable and succinct code without the need for manual unwrapping.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// vec![Some(1)].into_iter().filter(Option::is_some);
-    ///
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// vec![Some(1)].into_iter().flatten();
-    /// ```
-    #[clippy::version = "1.77.0"]
-    pub ITER_FILTER_IS_SOME,
+    #[clippy::version = "1.47.0"]
+    pub STABLE_SORT_PRIMITIVE,
     pedantic,
-    "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
-    /// This lint will require additional changes to the follow-up calls as it affects the type.
-    ///
-    /// ### Why is this bad?
-    /// This pattern is often followed by manual unwrapping of `Result`. The simplification
-    /// results in more readable and succinct code without the need for manual unwrapping.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// vec![Ok::<i32, String>(1)].into_iter().filter(Result::is_ok);
-    ///
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// vec![Ok::<i32, String>(1)].into_iter().flatten();
-    /// ```
-    #[clippy::version = "1.77.0"]
-    pub ITER_FILTER_IS_OK,
-    pedantic,
-    "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `option.map(f).unwrap_or_default()` and `result.map(f).unwrap_or_default()` where `f` is a function or closure that returns the `bool` type.
-    ///
-    /// Also checks for equality comparisons like `option.map(f) == Some(true)` and `result.map(f) == Ok(true)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability. These can be written more concisely as `option.is_some_and(f)` and `result.is_ok_and(f)`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.map(|a| a > 10).unwrap_or_default();
-    /// result.map(|a| a > 10).unwrap_or_default();
-    ///
-    /// option.map(|a| a > 10) == Some(true);
-    /// result.map(|a| a > 10) == Ok(true);
-    /// option.map(|a| a > 10) != Some(true);
-    /// result.map(|a| a > 10) != Ok(true);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.is_some_and(|a| a > 10);
-    /// result.is_ok_and(|a| a > 10);
-    ///
-    /// option.is_some_and(|a| a > 10);
-    /// result.is_ok_and(|a| a > 10);
-    /// option.is_none_or(|a| a > 10);
-    /// !result.is_ok_and(|a| a > 10);
-    /// ```
-    #[clippy::version = "1.77.0"]
-    pub MANUAL_IS_VARIANT_AND,
-    pedantic,
-    "using `.map(f).unwrap_or_default()` or `.map(f) == Some/Ok(true)`, which are more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
+    "use of sort() when sort_unstable() is equivalent"
 }
 
 declare_clippy_lint! {
@@ -4001,572 +3614,223 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.as_ref().cloned()` and `.as_mut().cloned()` on `Option`s
+    /// Checks for the use of `.extend(s.chars())` where s is a
+    /// `&str` or `String`.
     ///
     /// ### Why is this bad?
-    /// This can be written more concisely by cloning the `Option` directly.
+    /// `.push_str(s)` is clearer
     ///
     /// ### Example
     /// ```no_run
-    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
-    ///     bar.as_ref().cloned()
-    /// }
+    /// let abc = "abc";
+    /// let def = String::from("def");
+    /// let mut s = String::new();
+    /// s.extend(abc.chars());
+    /// s.extend(def.chars());
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// let abc = "abc";
+    /// let def = String::from("def");
+    /// let mut s = String::new();
+    /// s.push_str(abc);
+    /// s.push_str(&def);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub STRING_EXTEND_CHARS,
+    style,
+    "using `x.extend(s.chars())` where s is a `&str` or `String`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `<string_lit>.chars().any(|i| i == c)`.
+    ///
+    /// ### Why is this bad?
+    /// It's significantly slower than using a pattern instead, like
+    /// `matches!(c, '\\' | '.' | '+')`.
+    ///
+    /// Despite this being faster, this is not `perf` as this is pretty common, and is a rather nice
+    /// way to check if a `char` is any in a set. In any case, this `restriction` lint is available
+    /// for situations where that additional performance is absolutely necessary.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let c = 'c';
+    /// "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
-    ///     bar.clone()
-    /// }
+    /// # let c = 'c';
+    /// matches!(c, '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub STRING_LIT_CHARS_ANY,
+    restriction,
+    "checks for `<string_lit>.chars().any(|i| i == c)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `Command::arg()` invocations that look like they
+    /// should be multiple arguments instead, such as `arg("-t ext2")`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `Command::arg()` does not split arguments by space. An argument like `arg("-t ext2")`
+    /// will be passed as a single argument to the command,
+    /// which is likely not what was intended.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub SUSPICIOUS_COMMAND_ARG_SPACE,
+    suspicious,
+    "single command line argument that looks like it should be multiple arguments"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `map` followed by a `count`.
+    ///
+    /// ### Why is this bad?
+    /// It looks suspicious. Maybe `map` was confused with `filter`.
+    /// If the `map` call is intentional, this should be rewritten
+    /// using `inspect`. Or, if you intend to drive the iterator to
+    /// completion, you can just use `for_each` instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = (0..3).map(|x| x + 2).count();
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub SUSPICIOUS_MAP,
+    suspicious,
+    "suspicious usage of map"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the suspicious use of `OpenOptions::create()`
+    /// without an explicit `OpenOptions::truncate()`.
+    ///
+    /// ### Why is this bad?
+    /// `create()` alone will either create a new file or open an
+    /// existing file. If the file already exists, it will be
+    /// overwritten when written to, but the file will not be
+    /// truncated by default.
+    /// If less data is written to the file
+    /// than it already contains, the remainder of the file will
+    /// remain unchanged, and the end of the file will contain old
+    /// data.
+    /// In most cases, one should either use `create_new` to ensure
+    /// the file is created from scratch, or ensure `truncate` is
+    /// called so that the truncation behaviour is explicit. `truncate(true)`
+    /// will ensure the file is entirely overwritten with new data, whereas
+    /// `truncate(false)` will explicitly keep the default behavior.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().create(true);
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().create(true).truncate(true);
     /// ```
     #[clippy::version = "1.77.0"]
-    pub OPTION_AS_REF_CLONED,
-    pedantic,
-    "cloning an `Option` via `as_ref().cloned()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary calls to `min()` or `max()` in the following cases
-    /// - Either both side is constant
-    /// - One side is clearly larger than the other, like i32::MIN and an i32 variable
-    ///
-    /// ### Why is this bad?
-    ///
-    /// In the aforementioned cases it is not necessary to call `min()` or `max()`
-    /// to compare values, it may even cause confusion.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = 0.min(7_u32);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = 0;
-    /// ```
-    #[clippy::version = "1.81.0"]
-    pub UNNECESSARY_MIN_OR_MAX,
-    complexity,
-    "using 'min()/max()' when there is no need for it"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.map_or_else()` "map closure" for `Result` type.
-    ///
-    /// ### Why is this bad?
-    /// This can be written more concisely by using `unwrap_or_else()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # fn handle_error(_: ()) -> u32 { 0 }
-    /// let x: Result<u32, ()> = Ok(0);
-    /// let y = x.map_or_else(|err| handle_error(err), |n| n);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # fn handle_error(_: ()) -> u32 { 0 }
-    /// let x: Result<u32, ()> = Ok(0);
-    /// let y = x.unwrap_or_else(|err| handle_error(err));
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub UNNECESSARY_RESULT_MAP_OR_ELSE,
+    pub SUSPICIOUS_OPEN_OPTIONS,
     suspicious,
-    "making no use of the \"map closure\" when calling `.map_or_else(|err| handle_error(err), |n| n)`"
+    "suspicious combination of options for opening a file"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the manual creation of C strings (a string with a `NUL` byte at the end), either
-    /// through one of the `CStr` constructor functions, or more plainly by calling `.as_ptr()`
-    /// on a (byte) string literal with a hardcoded `\0` byte at the end.
+    /// Checks for calls to [`splitn`]
+    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
+    /// related functions with either zero or one splits.
     ///
     /// ### Why is this bad?
-    /// This can be written more concisely using `c"str"` literals and is also less error-prone,
-    /// because the compiler checks for interior `NUL` bytes and the terminating `NUL` byte is inserted automatically.
+    /// These calls don't actually split the value and are
+    /// likely to be intended as a different number.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::ffi::CStr;
-    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
-    /// fn needs_cstr(_: &CStr) {}
-    ///
-    /// needs_cstr(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
-    /// unsafe { libc::puts("World\0".as_ptr().cast()) }
+    /// # let s = "";
+    /// for x in s.splitn(1, ":") {
+    ///     // ..
+    /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # use std::ffi::CStr;
-    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
-    /// fn needs_cstr(_: &CStr) {}
-    ///
-    /// needs_cstr(c"Hello");
-    /// unsafe { libc::puts(c"World".as_ptr()) }
+    /// # let s = "";
+    /// for x in s.splitn(2, ":") {
+    ///     // ..
+    /// }
     /// ```
-    #[clippy::version = "1.78.0"]
-    pub MANUAL_C_STR_LITERALS,
-    complexity,
-    r#"creating a `CStr` through functions when `c""` literals can be used"#
+    #[clippy::version = "1.54.0"]
+    pub SUSPICIOUS_SPLITN,
+    correctness,
+    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the usage of `.get().is_some()` or `.get().is_none()` on std map types.
+    /// Checks for the usage of `_.to_owned()`, on a `Cow<'_, _>`.
     ///
     /// ### Why is this bad?
-    /// It can be done in one call with `.contains()`/`.contains_key()`.
+    /// Calling `to_owned()` on a `Cow` creates a clone of the `Cow`
+    /// itself, without taking ownership of the `Cow` contents (i.e.
+    /// it's equivalent to calling `Cow::clone`).
+    /// The similarly named `into_owned` method, on the other hand,
+    /// clones the `Cow` contents, effectively turning any `Cow::Borrowed`
+    /// into a `Cow::Owned`.
+    ///
+    /// Given the potential ambiguity, consider replacing `to_owned`
+    /// with `clone` for better readability or, if getting a `Cow::Owned`
+    /// was the original intent, using `into_owned` instead.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let s: HashSet<String> = HashSet::new();
-    /// if s.get("a").is_some() {
-    ///     // code
-    /// }
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.to_owned();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let s: HashSet<String> = HashSet::new();
-    /// if s.contains("a") {
-    ///     // code
-    /// }
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.clone();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
-    #[clippy::version = "1.78.0"]
-    pub UNNECESSARY_GET_THEN_CHECK,
+    /// or
+    /// ```no_run
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let _data: String = cow.into_owned();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub SUSPICIOUS_TO_OWNED,
     suspicious,
-    "calling `.get().is_some()` or `.get().is_none()` instead of `.contains()` or `.contains_key()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// It identifies calls to `.is_empty()` on constant values.
-    ///
-    /// ### Why is this bad?
-    /// String literals and constant values are known at compile time. Checking if they
-    /// are empty will always return the same value. This might not be the intention of
-    /// the expression.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let value = "";
-    /// if value.is_empty() {
-    ///     println!("the string is empty");
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// println!("the string is empty");
-    /// ```
-    #[clippy::version = "1.79.0"]
-    pub CONST_IS_EMPTY,
-    suspicious,
-    "is_empty() called on strings known at compile time"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Converts some constructs mapping an Enum value for equality comparison.
-    ///
-    /// ### Why is this bad?
-    /// Calls such as `opt.map_or(false, |val| val == 5)` are needlessly long and cumbersome,
-    /// and can be reduced to, for example, `opt == Some(5)` assuming `opt` implements `PartialEq`.
-    /// Also, calls such as `opt.map_or(true, |val| val == 5)` can be reduced to
-    /// `opt.is_none_or(|val| val == 5)`.
-    /// This lint offers readability and conciseness improvements.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// pub fn a(x: Option<i32>) -> (bool, bool) {
-    ///     (
-    ///         x.map_or(false, |n| n == 5),
-    ///         x.map_or(true, |n| n > 5),
-    ///     )
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// pub fn a(x: Option<i32>) -> (bool, bool) {
-    ///     (
-    ///         x == Some(5),
-    ///         x.is_none_or(|n| n > 5),
-    ///     )
-    /// }
-    /// ```
-    #[clippy::version = "1.84.0"]
-    pub UNNECESSARY_MAP_OR,
-    style,
-    "reduce unnecessary calls to `.map_or(bool, …)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if an iterator is used to check if a string is ascii.
-    ///
-    /// ### Why is this bad?
-    /// The `str` type already implements the `is_ascii` method.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// "foo".chars().all(|c| c.is_ascii());
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// "foo".is_ascii();
-    /// ```
-    #[clippy::version = "1.81.0"]
-    pub NEEDLESS_CHARACTER_ITERATION,
-    suspicious,
-    "is_ascii() called on a char iterator"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for uses of `map` which return the original item.
-    ///
-    /// ### Why is this bad?
-    /// `inspect` is both clearer in intent and shorter.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = Some(0).map(|x| { println!("{x}"); x });
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = Some(0).inspect(|x| println!("{x}"));
-    /// ```
-    #[clippy::version = "1.81.0"]
-    pub MANUAL_INSPECT,
-    complexity,
-    "use of `map` returning the original item"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the usage of `.first().is_some()` or `.first().is_none()` to check if a slice is
-    /// empty.
-    ///
-    /// ### Why is this bad?
-    /// Using `.is_empty()` is shorter and better communicates the intention.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// if v.first().is_none() {
-    ///     // The vector is empty...
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// if v.is_empty() {
-    ///     // The vector is empty...
-    /// }
-    /// ```
-    #[clippy::version = "1.83.0"]
-    pub UNNECESSARY_FIRST_THEN_CHECK,
-    complexity,
-    "calling `.first().is_some()` or `.first().is_none()` instead of `.is_empty()`"
-}
-
-declare_clippy_lint! {
-   /// ### What it does
-   /// It detects useless calls to `str::as_bytes()` before calling `len()` or `is_empty()`.
-   ///
-   /// ### Why is this bad?
-   /// The `len()` and `is_empty()` methods are also directly available on strings, and they
-   /// return identical results. In particular, `len()` on a string returns the number of
-   /// bytes.
-   ///
-   /// ### Example
-   /// ```
-   /// let len = "some string".as_bytes().len();
-   /// let b = "some string".as_bytes().is_empty();
-   /// ```
-   /// Use instead:
-   /// ```
-   /// let len = "some string".len();
-   /// let b = "some string".is_empty();
-   /// ```
-   #[clippy::version = "1.84.0"]
-   pub NEEDLESS_AS_BYTES,
-   complexity,
-   "detect useless calls to `as_bytes()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.map(…)`, followed by `.all(identity)` or `.any(identity)`.
-    ///
-    /// ### Why is this bad?
-    /// The `.all(…)` or `.any(…)` methods can be called directly in place of `.map(…)`.
-    ///
-    /// ### Example
-    /// ```
-    /// # let mut v = [""];
-    /// let e1 = v.iter().map(|s| s.is_empty()).all(|a| a);
-    /// let e2 = v.iter().map(|s| s.is_empty()).any(std::convert::identity);
-    /// ```
-    /// Use instead:
-    /// ```
-    /// # let mut v = [""];
-    /// let e1 = v.iter().all(|s| s.is_empty());
-    /// let e2 = v.iter().any(|s| s.is_empty());
-    /// ```
-    #[clippy::version = "1.84.0"]
-    pub MAP_ALL_ANY_IDENTITY,
-    complexity,
-    "combine `.map(_)` followed by `.all(identity)`/`.any(identity)` into a single call"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `Iterator::map` over ranges without using the parameter which
-    /// could be more clearly expressed using `std::iter::repeat(...).take(...)`
-    /// or `std::iter::repeat_n`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It expresses the intent more clearly to `take` the correct number of times
-    /// from a generating function than to apply a closure to each number in a
-    /// range only to discard them.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// let random_numbers : Vec<_> = (0..10).map(|_| { 3 + 1 }).collect();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let f : Vec<_> = std::iter::repeat( 3 + 1 ).take(10).collect();
-    /// ```
-    ///
-    /// ### Known Issues
-    ///
-    /// This lint may suggest replacing a `Map<Range>` with a `Take<RepeatWith>`.
-    /// The former implements some traits that the latter does not, such as
-    /// `DoubleEndedIterator`.
-    #[clippy::version = "1.84.0"]
-    pub MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
-    restriction,
-    "map of a trivial closure (not dependent on parameter) over a range"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `Iterator::last` being called on a  `DoubleEndedIterator`, which can be replaced
-    /// with `DoubleEndedIterator::next_back`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// `Iterator::last` is implemented by consuming the iterator, which is unnecessary if
-    /// the iterator is a `DoubleEndedIterator`. Since Rust traits do not allow specialization,
-    /// `Iterator::last` cannot be optimized for `DoubleEndedIterator`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let last_arg = "echo hello world".split(' ').last();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let last_arg = "echo hello world".split(' ').next_back();
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub DOUBLE_ENDED_ITERATOR_LAST,
-    perf,
-    "using `Iterator::last` on a `DoubleEndedIterator`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `NonZero*::new_unchecked()` being used in a `const` context.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Using `NonZero*::new_unchecked()` is an `unsafe` function and requires an `unsafe` context. When used in a
-    /// context evaluated at compilation time, `NonZero*::new().unwrap()` will provide the same result with identical
-    /// runtime performances while not requiring `unsafe`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::num::NonZeroUsize;
-    /// const PLAYERS: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::num::NonZeroUsize;
-    /// const PLAYERS: NonZeroUsize = NonZeroUsize::new(3).unwrap();
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub USELESS_NONZERO_NEW_UNCHECKED,
-    complexity,
-    "using `NonZero::new_unchecked()` in a `const` context"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `repeat().take()` that can be replaced with `repeat_n()`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Using `repeat_n()` is more concise and clearer. Also, `repeat_n()` is sometimes faster than `repeat().take()` when the type of the element is non-trivial to clone because the original value can be reused for the last `.next()` call rather than always cloning.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = std::iter::repeat(10).take(3);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = std::iter::repeat_n(10, 3);
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_REPEAT_N,
-    style,
-    "detect `repeat().take()` that can be replaced with `repeat_n()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for string slices immediately followed by `as_bytes`.
-    ///
-    /// ### Why is this bad?
-    /// It involves doing an unnecessary UTF-8 alignment check which is less efficient, and can cause a panic.
-    ///
-    /// ### Known problems
-    /// In some cases, the UTF-8 validation and potential panic from string slicing may be required for
-    /// the code's correctness. If you need to ensure the slice boundaries fall on valid UTF-8 character
-    /// boundaries, the original form (`s[1..5].as_bytes()`) should be preferred.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let s = "Lorem ipsum";
-    /// s[1..5].as_bytes();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let s = "Lorem ipsum";
-    /// &s.as_bytes()[1..5];
-    /// ```
-     #[clippy::version = "1.86.0"]
-     pub SLICED_STRING_AS_BYTES,
-     perf,
-     "slicing a string and immediately calling as_bytes is less efficient and can lead to panics"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detect functions that end with `Option::and_then` or `Result::and_then`, and suggest using
-    /// the `?` operator instead.
-    ///
-    /// ### Why is this bad?
-    /// The `and_then` method is used to chain a computation that returns an `Option` or a `Result`.
-    /// This can be replaced with the `?` operator, which is more concise and idiomatic.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// fn test(opt: Option<i32>) -> Option<i32> {
-    ///     opt.and_then(|n| {
-    ///         if n > 1 {
-    ///             Some(n + 1)
-    ///         } else {
-    ///             None
-    ///        }
-    ///     })
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn test(opt: Option<i32>) -> Option<i32> {
-    ///     let n = opt?;
-    ///     if n > 1 {
-    ///         Some(n + 1)
-    ///     } else {
-    ///         None
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub RETURN_AND_THEN,
-    restriction,
-    "using `Option::and_then` or `Result::and_then` to chain a computation that returns an `Option` or a `Result`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
-    ///
-    /// ### Why is this bad?
-    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::io::Read;
-    /// use std::fs::File;
-    /// let file = File::open("./bytes.txt").unwrap();
-    /// file.bytes();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::io::{BufReader, Read};
-    /// use std::fs::File;
-    /// let file = BufReader::new(File::open("./bytes.txt").unwrap());
-    /// file.bytes();
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub UNBUFFERED_BYTES,
-    perf,
-    "calling .bytes() is very inefficient when data is not in memory"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `iter().any()` on slices when it can be replaced with `contains()` and suggests doing so.
-    ///
-    /// ### Why is this bad?
-    /// `contains()` is more concise and idiomatic, while also being faster in some cases.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(values: &[u8]) -> bool {
-    ///     values.iter().any(|&v| v == 10)
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(values: &[u8]) -> bool {
-    ///     values.contains(&10)
-    /// }
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub MANUAL_CONTAINS,
-    perf,
-    "unnecessary `iter().any()` on slices that can be replaced with `contains()`"
-}
-
-declare_clippy_lint! {
-    /// This lint warns on calling `io::Error::new(..)` with a kind of
-    /// `io::ErrorKind::Other`.
-    ///
-    /// ### Why is this bad?
-    /// Since Rust 1.74, there's the `io::Error::other(_)` shortcut.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::io;
-    /// let _ = io::Error::new(io::ErrorKind::Other, "bad".to_string());
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = std::io::Error::other("bad".to_string());
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub IO_OTHER_ERROR,
-    style,
-    "calling `std::io::Error::new(std::io::ErrorKind::Other, _)`"
+    "calls to `to_owned` on a `Cow<'_, _>` might not do what they are expected"
 }
 
 declare_clippy_lint! {
@@ -4618,63 +3882,468 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for IP addresses that could be replaced with predefined constants such as
-    /// `Ipv4Addr::new(127, 0, 0, 1)` instead of using the appropriate constants.
+    /// Looks for calls to `.type_id()` on a `Box<dyn _>`.
     ///
     /// ### Why is this bad?
-    /// Using specific IP addresses like `127.0.0.1` or `::1` is less clear and less maintainable than using the
-    /// predefined constants `Ipv4Addr::LOCALHOST` or `Ipv6Addr::LOCALHOST`. These constants improve code
-    /// readability, make the intent explicit, and are less error-prone.
+    /// This almost certainly does not do what the user expects and can lead to subtle bugs.
+    /// Calling `.type_id()` on a `Box<dyn Trait>` returns a fixed `TypeId` of the `Box` itself,
+    /// rather than returning the `TypeId` of the underlying type behind the trait object.
+    ///
+    /// For `Box<dyn Any>` specifically (and trait objects that have `Any` as its supertrait),
+    /// this lint will provide a suggestion, which is to dereference the receiver explicitly
+    /// to go from `Box<dyn Any>` to `dyn Any`.
+    /// This makes sure that `.type_id()` resolves to a dynamic call on the trait object
+    /// and not on the box.
+    ///
+    /// If the fixed `TypeId` of the `Box` is the intended behavior, it's better to be explicit about it
+    /// and write `TypeId::of::<Box<dyn Trait>>()`:
+    /// this makes it clear that a fixed `TypeId` is returned and not the `TypeId` of the implementor.
     ///
     /// ### Example
-    /// ```no_run
-    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    /// ```rust,ignore
+    /// use std::any::{Any, TypeId};
     ///
-    /// // IPv4 loopback
-    /// let addr_v4 = Ipv4Addr::new(127, 0, 0, 1);
-    ///
-    /// // IPv6 loopback
-    /// let addr_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    /// use std::any::{Any, TypeId};
     ///
-    /// // IPv4 loopback
-    /// let addr_v4 = Ipv4Addr::LOCALHOST;
-    ///
-    /// // IPv6 loopback
-    /// let addr_v6 = Ipv6Addr::LOCALHOST;
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
+    /// //          ^ dereference first, to call `type_id` on `dyn Any`
     /// ```
-    #[clippy::version = "1.89.0"]
-    pub IP_CONSTANT,
-    pedantic,
-    "hardcoded localhost IP address"
+    #[clippy::version = "1.73.0"]
+    pub TYPE_ID_ON_BOX,
+    suspicious,
+    "calling `.type_id()` on a boxed trait object"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `Iterator::cloned` where the original value could be used
-    /// instead.
+    /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
     ///
     /// ### Why is this bad?
-    /// It is not always possible for the compiler to eliminate useless allocations and
-    /// deallocations generated by redundant `clone()`s.
+    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = vec![String::new()];
-    /// let _ = x.iter().cloned().map(|x| x.len());
+    /// use std::io::Read;
+    /// use std::fs::File;
+    /// let file = File::open("./bytes.txt").unwrap();
+    /// file.bytes();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let x = vec![String::new()];
-    /// let _ = x.iter().map(|x| x.len());
+    /// use std::io::{BufReader, Read};
+    /// use std::fs::File;
+    /// let file = BufReader::new(File::open("./bytes.txt").unwrap());
+    /// file.bytes();
     /// ```
-    #[clippy::version = "1.92.0"]
-    pub REDUNDANT_ITER_CLONED,
+    #[clippy::version = "1.87.0"]
+    pub UNBUFFERED_BYTES,
     perf,
-    "detects redundant calls to `Iterator::cloned`"
+    "calling .bytes() is very inefficient when data is not in memory"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `MaybeUninit::uninit().assume_init()`.
+    ///
+    /// ### Why is this bad?
+    /// For most types, this is undefined behavior.
+    ///
+    /// ### Known problems
+    /// For now, we accept empty tuples and tuples / arrays
+    /// of `MaybeUninit`. There may be other types that allow uninitialized
+    /// data, but those are not yet rigorously defined.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // Beware the UB
+    /// use std::mem::MaybeUninit;
+    ///
+    /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
+    /// ```
+    ///
+    /// Note that the following is OK:
+    ///
+    /// ```no_run
+    /// use std::mem::MaybeUninit;
+    ///
+    /// let _: [MaybeUninit<bool>; 5] = unsafe {
+    ///     MaybeUninit::uninit().assume_init()
+    /// };
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub UNINIT_ASSUMED_INIT,
+    correctness,
+    "`MaybeUninit::uninit().assume_init()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `().hash(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => ().hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => 0_u8.hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub UNIT_HASH,
+    correctness,
+    "hashing a unit value, which does nothing"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `TryInto::try_into` and `TryFrom::try_from` when their infallible counterparts
+    /// could be used.
+    ///
+    /// ### Why is this bad?
+    /// In those cases, the `TryInto` and `TryFrom` trait implementation is a blanket impl that forwards
+    /// to `Into` or `From`, which always succeeds.
+    /// The returned `Result<_, Infallible>` requires error handling to get the contained value
+    /// even though the conversion can never fail.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _: Result<i64, _> = 1i32.try_into();
+    /// let _: Result<i64, _> = <_>::try_from(1i32);
+    /// ```
+    /// Use `from`/`into` instead:
+    /// ```rust
+    /// let _: i64 = 1i32.into();
+    /// let _: i64 = <_>::from(1i32);
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub UNNECESSARY_FALLIBLE_CONVERSIONS,
+    style,
+    "calling the `try_from` and `try_into` trait methods when `From`/`Into` is implemented"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `filter_map` calls that could be replaced by `filter` or `map`.
+    /// More specifically it checks if the closure provided is only performing one of the
+    /// filter or map operations and suggests the appropriate option.
+    ///
+    /// ### Why is this bad?
+    /// Complexity. The intent is also clearer if only a single
+    /// operation is being performed.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
+    ///
+    /// // As there is no transformation of the argument this could be written as:
+    /// let _ = (0..3).filter(|&x| x > 2);
+    /// ```
+    ///
+    /// ```no_run
+    /// let _ = (0..4).filter_map(|x| Some(x + 1));
+    ///
+    /// // As there is no conditional check on the argument this could be written as:
+    /// let _ = (0..4).map(|x| x + 1);
+    /// ```
+    #[clippy::version = "1.31.0"]
+    pub UNNECESSARY_FILTER_MAP,
+    complexity,
+    "using `filter_map` when a more succinct alternative exists"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `find_map` calls that could be replaced by `find` or `map`. More
+    /// specifically it checks if the closure provided is only performing one of the
+    /// find or map operations and suggests the appropriate option.
+    ///
+    /// ### Why is this bad?
+    /// Complexity. The intent is also clearer if only a single
+    /// operation is being performed.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
+    ///
+    /// // As there is no transformation of the argument this could be written as:
+    /// let _ = (0..3).find(|&x| x > 2);
+    /// ```
+    ///
+    /// ```no_run
+    /// let _ = (0..4).find_map(|x| Some(x + 1));
+    ///
+    /// // As there is no conditional check on the argument this could be written as:
+    /// let _ = (0..4).map(|x| x + 1).next();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_FIND_MAP,
+    complexity,
+    "using `find_map` when a more succinct alternative exists"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the usage of `.first().is_some()` or `.first().is_none()` to check if a slice is
+    /// empty.
+    ///
+    /// ### Why is this bad?
+    /// Using `.is_empty()` is shorter and better communicates the intention.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let v = vec![1, 2, 3];
+    /// if v.first().is_none() {
+    ///     // The vector is empty...
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let v = vec![1, 2, 3];
+    /// if v.is_empty() {
+    ///     // The vector is empty...
+    /// }
+    /// ```
+    #[clippy::version = "1.83.0"]
+    pub UNNECESSARY_FIRST_THEN_CHECK,
+    complexity,
+    "calling `.first().is_some()` or `.first().is_none()` instead of `.is_empty()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `fold` when a more succinct alternative exists.
+    /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
+    /// `sum` or `product`.
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// (0..3).fold(false, |acc, x| acc || x > 2);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// (0..3).any(|x| x > 2);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub UNNECESSARY_FOLD,
+    style,
+    "using `fold` when a more succinct alternative exists"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the usage of `.get().is_some()` or `.get().is_none()` on std map types.
+    ///
+    /// ### Why is this bad?
+    /// It can be done in one call with `.contains()`/`.contains_key()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// let s: HashSet<String> = HashSet::new();
+    /// if s.get("a").is_some() {
+    ///     // code
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::collections::HashSet;
+    /// let s: HashSet<String> = HashSet::new();
+    /// if s.contains("a") {
+    ///     // code
+    /// }
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub UNNECESSARY_GET_THEN_CHECK,
+    suspicious,
+    "calling `.get().is_some()` or `.get().is_none()` instead of `.contains()` or `.contains_key()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.collect::<Vec<String>>().join("")` on iterators.
+    ///
+    /// ### Why is this bad?
+    /// `.collect::<String>()` is more concise and might be more performant
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
+    /// println!("{}", output);
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
+    /// println!("{}", output);
+    /// ```
+    /// ### Known problems
+    /// While `.collect::<String>()` is sometimes more performant, there are cases where
+    /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
+    /// will prevent loop unrolling and will result in a negative performance impact.
+    ///
+    /// Additionally, differences have been observed between aarch64 and x86_64 assembly output,
+    /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_JOIN,
+    pedantic,
+    "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
+    /// lazily evaluated closures on `Option` and `Result`.
+    ///
+    /// This lint suggests changing the following functions, when eager evaluation results in
+    /// simpler code:
+    ///  - `unwrap_or_else` to `unwrap_or`
+    ///  - `and_then` to `and`
+    ///  - `or_else` to `or`
+    ///  - `get_or_insert_with` to `get_or_insert`
+    ///  - `ok_or_else` to `ok_or`
+    ///  - `then` to `then_some` (for msrv >= 1.62.0)
+    ///
+    /// ### Why is this bad?
+    /// Using eager evaluation is shorter and simpler in some cases.
+    ///
+    /// ### Known problems
+    /// It is possible, but not recommended for `Deref` and `Index` to have
+    /// side effects. Eagerly evaluating them can change the semantics of the program.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or_else(|| 42);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or(42);
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub UNNECESSARY_LAZY_EVALUATIONS,
+    style,
+    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.unwrap()` related calls on `Result`s and `Option`s that are constructed.
+    ///
+    /// ### Why is this bad?
+    /// It is better to write the value directly without the indirection.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// let val1 = Some(1).unwrap();
+    /// let val2 = Ok::<_, ()>(1).unwrap();
+    /// let val3 = Err::<(), _>(1).unwrap_err();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let val1 = 1;
+    /// let val2 = 1;
+    /// let val3 = 1;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub UNNECESSARY_LITERAL_UNWRAP,
+    complexity,
+    "using `unwrap()` related calls on `Result` and `Option` constructors"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Converts some constructs mapping an Enum value for equality comparison.
+    ///
+    /// ### Why is this bad?
+    /// Calls such as `opt.map_or(false, |val| val == 5)` are needlessly long and cumbersome,
+    /// and can be reduced to, for example, `opt == Some(5)` assuming `opt` implements `PartialEq`.
+    /// Also, calls such as `opt.map_or(true, |val| val == 5)` can be reduced to
+    /// `opt.is_none_or(|val| val == 5)`.
+    /// This lint offers readability and conciseness improvements.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// pub fn a(x: Option<i32>) -> (bool, bool) {
+    ///     (
+    ///         x.map_or(false, |n| n == 5),
+    ///         x.map_or(true, |n| n > 5),
+    ///     )
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// pub fn a(x: Option<i32>) -> (bool, bool) {
+    ///     (
+    ///         x == Some(5),
+    ///         x.is_none_or(|n| n > 5),
+    ///     )
+    /// }
+    /// ```
+    #[clippy::version = "1.84.0"]
+    pub UNNECESSARY_MAP_OR,
+    style,
+    "reduce unnecessary calls to `.map_or(bool, …)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary calls to `min()` or `max()` in the following cases
+    /// - Either both side is constant
+    /// - One side is clearly larger than the other, like i32::MIN and an i32 variable
+    ///
+    /// ### Why is this bad?
+    ///
+    /// In the aforementioned cases it is not necessary to call `min()` or `max()`
+    /// to compare values, it may even cause confusion.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = 0.min(7_u32);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = 0;
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub UNNECESSARY_MIN_OR_MAX,
+    complexity,
+    "using 'min()/max()' when there is no need for it"
 }
 
 declare_clippy_lint! {
@@ -4703,53 +4372,540 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
-    /// when `lines` has type `std::io::Lines`.
+    /// Checks for usage of `.map_or_else()` "map closure" for `Result` type.
     ///
     /// ### Why is this bad?
-    /// `Lines` instances might produce a never-ending stream of `Err`, in which case
-    /// `filter_map(Result::ok)` will enter an infinite loop while waiting for an
-    /// `Ok` variant. Calling `next()` once is sufficient to enter the infinite loop,
-    /// even in the absence of explicit loops in the user code.
-    ///
-    /// This situation can arise when working with user-provided paths. On some platforms,
-    /// `std::fs::File::open(path)` might return `Ok(fs)` even when `path` is a directory,
-    /// but any later attempt to read from `fs` will return an error.
-    ///
-    /// ### Known problems
-    /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
-    /// instance in all cases. There are two cases where the suggestion might not be
-    /// appropriate or necessary:
-    ///
-    /// - If the `Lines` instance can never produce any error, or if an error is produced
-    ///   only once just before terminating the iterator, using `map_while()` is not
-    ///   necessary but will not do any harm.
-    /// - If the `Lines` instance can produce intermittent errors then recover and produce
-    ///   successful results, using `map_while()` would stop at the first error.
+    /// This can be written more concisely by using `unwrap_or_else()`.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
-    /// # let _ = || -> io::Result<()> {
-    /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
-    /// // If "some-path" points to a directory, the next statement never terminates:
-    /// let first_line: Option<String> = lines.next();
-    /// # Ok(()) };
+    /// # fn handle_error(_: ()) -> u32 { 0 }
+    /// let x: Result<u32, ()> = Ok(0);
+    /// let y = x.map_or_else(|err| handle_error(err), |n| n);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
-    /// # let _ = || -> io::Result<()> {
-    /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
-    /// let first_line: Option<String> = lines.next();
-    /// # Ok(()) };
+    /// # fn handle_error(_: ()) -> u32 { 0 }
+    /// let x: Result<u32, ()> = Ok(0);
+    /// let y = x.unwrap_or_else(|err| handle_error(err));
     /// ```
-    #[clippy::version = "1.70.0"]
-    pub LINES_FILTER_MAP_OK,
+    #[clippy::version = "1.78.0"]
+    pub UNNECESSARY_RESULT_MAP_OR_ELSE,
     suspicious,
-    "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
+    "making no use of the \"map closure\" when calling `.map_or_else(|err| handle_error(err), |n| n)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `Vec::sort_by` passing in a closure
+    /// which compares the two arguments, either directly or indirectly.
+    ///
+    /// ### Why is this bad?
+    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
+    /// possible) than to use `Vec::sort_by` and a more complicated
+    /// closure.
+    ///
+    /// ### Known problems
+    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
+    /// imported by a use statement, then it will need to be added manually.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by_key(|a| a.foo());
+    /// ```
+    #[clippy::version = "1.46.0"]
+    pub UNNECESSARY_SORT_BY,
+    complexity,
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
+    /// and other `to_owned`-like functions.
+    ///
+    /// ### Why is this bad?
+    /// The unnecessary calls result in useless allocations.
+    ///
+    /// ### Known problems
+    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
+    /// owned copy of a resource and the resource is later used mutably. See
+    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy().to_string());
+    /// fn foo(s: &str) {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy());
+    /// fn foo(s: &str) {}
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub UNNECESSARY_TO_OWNED,
+    perf,
+    "unnecessary calls to `to_owned`-like functions"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of the following functions with an argument that constructs a default value
+    /// (e.g., `Default::default` or `String::new`):
+    /// - `unwrap_or`
+    /// - `unwrap_or_else`
+    /// - `or_insert`
+    /// - `or_insert_with`
+    ///
+    /// ### Why is this bad?
+    /// Readability. Using `unwrap_or_default` in place of `unwrap_or`/`unwrap_or_else`, or `or_default`
+    /// in place of `or_insert`/`or_insert_with`, is simpler and more concise.
+    ///
+    /// ### Known problems
+    /// In some cases, the argument of `unwrap_or`, etc. is needed for type inference. The lint uses a
+    /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # let x = Some(1);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
+    /// x.unwrap_or(Default::default());
+    /// map.entry(42).or_insert_with(String::new);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = Some(1);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
+    /// x.unwrap_or_default();
+    /// map.entry(42).or_default();
+    /// ```
+    #[clippy::version = "1.56.0"]
+    pub UNWRAP_OR_DEFAULT,
+    style,
+    "using `.unwrap_or`, etc. with an argument that constructs a default value"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
+    ///
+    /// ### Why restrict this?
+    /// It is better to handle the `None` or `Err` case,
+    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
+    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
+    /// `Allow` by default.
+    ///
+    /// `result.unwrap()` will let the thread panic on `Err` values.
+    /// Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
+    ///
+    /// Even if you want to panic on errors, not all `Error`s implement good
+    /// messages on display. Therefore, it may be beneficial to look at the places
+    /// where they may get displayed. Activate this lint to do just that.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.unwrap();
+    /// result.unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("more helpful message");
+    /// result.expect("more helpful message");
+    /// ```
+    ///
+    /// If [expect_used](#expect_used) is enabled, instead:
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub UNWRAP_USED,
+    restriction,
+    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.as_ref()` or `.as_mut()` where the
+    /// types before and after the call are the same.
+    ///
+    /// ### Why is this bad?
+    /// The call is unnecessary.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn do_stuff(x: &[i32]) {}
+    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+    /// do_stuff(x.as_ref());
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// # fn do_stuff(x: &[i32]) {}
+    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+    /// do_stuff(x);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_ASREF,
+    complexity,
+    "using `as_ref` where the types before and after the call are the same"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `NonZero*::new_unchecked()` being used in a `const` context.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Using `NonZero*::new_unchecked()` is an `unsafe` function and requires an `unsafe` context. When used in a
+    /// context evaluated at compilation time, `NonZero*::new().unwrap()` will provide the same result with identical
+    /// runtime performances while not requiring `unsafe`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::num::NonZeroUsize;
+    /// const PLAYERS: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::num::NonZeroUsize;
+    /// const PLAYERS: NonZeroUsize = NonZeroUsize::new(3).unwrap();
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub USELESS_NONZERO_NEW_UNCHECKED,
+    complexity,
+    "using `NonZero::new_unchecked()` in a `const` context"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds occurrences of `Vec::resize(0, an_int)`
+    ///
+    /// ### Why is this bad?
+    /// This is probably an argument inversion mistake.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// vec![1, 2, 3, 4, 5].resize(0, 5)
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// vec![1, 2, 3, 4, 5].clear()
+    /// ```
+    #[clippy::version = "1.46.0"]
+    pub VEC_RESIZE_TO_ZERO,
+    correctness,
+    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of File::read_to_end and File::read_to_string.
+    ///
+    /// ### Why restrict this?
+    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
+    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// # use std::io::Read;
+    /// # use std::fs::File;
+    /// let mut f = File::open("foo.txt").unwrap();
+    /// let mut bytes = Vec::new();
+    /// f.read_to_end(&mut bytes).unwrap();
+    /// ```
+    /// Can be written more concisely as
+    /// ```rust,no_run
+    /// # use std::fs;
+    /// let mut bytes = fs::read("foo.txt").unwrap();
+    /// ```
+    #[clippy::version = "1.44.0"]
+    pub VERBOSE_FILE_READS,
+    restriction,
+    "use of `File::read_to_end` or `File::read_to_string`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `waker.clone().wake()`
+    ///
+    /// ### Why is this bad?
+    /// Cloning the waker is not necessary, `wake_by_ref()` enables the same operation
+    /// without extra cloning/dropping.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// waker.clone().wake();
+    /// ```
+    /// Should be written
+    /// ```rust,ignore
+    /// waker.wake_by_ref();
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub WAKER_CLONE_WAKE,
+    perf,
+    "cloning a `Waker` only to wake it"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for methods with certain name prefixes or suffixes, and which
+    /// do not adhere to standard conventions regarding how `self` is taken.
+    /// The actual rules are:
+    ///
+    /// |Prefix |Postfix     |`self` taken                   | `self` type  |
+    /// |-------|------------|-------------------------------|--------------|
+    /// |`as_`  | none       |`&self` or `&mut self`         | any          |
+    /// |`from_`| none       | none                          | any          |
+    /// |`into_`| none       |`self`                         | any          |
+    /// |`is_`  | none       |`&mut self` or `&self` or none | any          |
+    /// |`to_`  | `_mut`     |`&mut self`                    | any          |
+    /// |`to_`  | not `_mut` |`self`                         | `Copy`       |
+    /// |`to_`  | not `_mut` |`&self`                        | not `Copy`   |
+    ///
+    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
+    /// - Traits definition.
+    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
+    /// - Traits implementation, when `&self` is taken.
+    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
+    /// (see e.g. the `std::string::ToString` trait).
+    ///
+    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
+    ///
+    /// Please find more info here:
+    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
+    ///
+    /// ### Why is this bad?
+    /// Consistency breeds readability. If you follow the
+    /// conventions, your users won't be surprised that they, e.g., need to supply a
+    /// mutable reference to a `as_..` function.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # struct X;
+    /// impl X {
+    ///     fn as_str(self) -> &'static str {
+    ///         // ..
+    /// # ""
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # struct X;
+    /// impl X {
+    ///     fn as_str(&self) -> &'static str {
+    ///         // ..
+    /// # ""
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub WRONG_SELF_CONVENTION,
+    style,
+    "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
+    /// zero-sized types
+    ///
+    /// ### Why is this bad?
+    /// This is a no-op, and likely unintended
+    ///
+    /// ### Example
+    /// ```no_run
+    /// unsafe { (&() as *const ()).offset(1) };
+    /// ```
+    #[clippy::version = "1.41.0"]
+    pub ZST_OFFSET,
+    correctness,
+    "Check for offset calculations on raw pointers to zero-sized types"
+}
+
+impl_lint_pass!(Methods => [
+    BIND_INSTEAD_OF_MAP,
+    BYTES_COUNT_TO_LEN,
+    BYTES_NTH,
+    CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    CHARS_LAST_CMP,
+    CHARS_NEXT_CMP,
+    CLEAR_WITH_DRAIN,
+    CLONED_INSTEAD_OF_COPIED,
+    CLONE_ON_COPY,
+    CLONE_ON_REF_PTR,
+    COLLAPSIBLE_STR_REPLACE,
+    CONST_IS_EMPTY,
+    DOUBLE_ENDED_ITERATOR_LAST,
+    DRAIN_COLLECT,
+    ERR_EXPECT,
+    EXPECT_FUN_CALL,
+    EXPECT_USED,
+    EXTEND_WITH_DRAIN,
+    FILETYPE_IS_FILE,
+    FILTER_MAP_BOOL_THEN,
+    FILTER_MAP_IDENTITY,
+    FILTER_MAP_NEXT,
+    FILTER_NEXT,
+    FLAT_MAP_IDENTITY,
+    FLAT_MAP_OPTION,
+    FORMAT_COLLECT,
+    FROM_ITER_INSTEAD_OF_COLLECT,
+    GET_FIRST,
+    GET_LAST_WITH_LEN,
+    GET_UNWRAP,
+    IMPLICIT_CLONE,
+    INEFFICIENT_TO_STRING,
+    INSPECT_FOR_EACH,
+    INTO_ITER_ON_REF,
+    IO_OTHER_ERROR,
+    IP_CONSTANT,
+    IS_DIGIT_ASCII_RADIX,
+    ITERATOR_STEP_BY_ZERO,
+    ITER_CLONED_COLLECT,
+    ITER_COUNT,
+    ITER_FILTER_IS_OK,
+    ITER_FILTER_IS_SOME,
+    ITER_KV_MAP,
+    ITER_NEXT_SLICE,
+    ITER_NTH,
+    ITER_NTH_ZERO,
+    ITER_ON_EMPTY_COLLECTIONS,
+    ITER_ON_SINGLE_ITEMS,
+    ITER_OUT_OF_BOUNDS,
+    ITER_OVEREAGER_CLONED,
+    ITER_SKIP_NEXT,
+    ITER_SKIP_ZERO,
+    ITER_WITH_DRAIN,
+    JOIN_ABSOLUTE_PATHS,
+    LINES_FILTER_MAP_OK,
+    MANUAL_CONTAINS,
+    MANUAL_C_STR_LITERALS,
+    MANUAL_FILTER_MAP,
+    MANUAL_FIND_MAP,
+    MANUAL_INSPECT,
+    MANUAL_IS_VARIANT_AND,
+    MANUAL_NEXT_BACK,
+    MANUAL_OK_OR,
+    MANUAL_REPEAT_N,
+    MANUAL_SATURATING_ARITHMETIC,
+    MANUAL_SPLIT_ONCE,
+    MANUAL_STR_REPEAT,
+    MANUAL_TRY_FOLD,
+    MAP_ALL_ANY_IDENTITY,
+    MAP_CLONE,
+    MAP_COLLECT_RESULT_UNIT,
+    MAP_ERR_IGNORE,
+    MAP_FLATTEN,
+    MAP_IDENTITY,
+    MAP_UNWRAP_OR,
+    MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    MUT_MUTEX_LOCK,
+    NAIVE_BYTECOUNT,
+    NEEDLESS_AS_BYTES,
+    NEEDLESS_CHARACTER_ITERATION,
+    NEEDLESS_COLLECT,
+    NEEDLESS_OPTION_AS_DEREF,
+    NEEDLESS_OPTION_TAKE,
+    NEEDLESS_SPLITN,
+    NEW_RET_NO_SELF,
+    NONSENSICAL_OPEN_OPTIONS,
+    NO_EFFECT_REPLACE,
+    OBFUSCATED_IF_ELSE,
+    OK_EXPECT,
+    OPTION_AS_REF_CLONED,
+    OPTION_AS_REF_DEREF,
+    OPTION_FILTER_MAP,
+    OPTION_MAP_OR_NONE,
+    OR_FUN_CALL,
+    OR_THEN_UNWRAP,
+    PATH_BUF_PUSH_OVERWRITE,
+    PATH_ENDS_WITH_EXT,
+    PTR_OFFSET_BY_LITERAL,
+    PTR_OFFSET_WITH_CAST,
+    RANGE_ZIP_WITH_LEN,
+    READONLY_WRITE_LOCK,
+    READ_LINE_WITHOUT_TRIM,
+    REDUNDANT_AS_STR,
+    REDUNDANT_ITER_CLONED,
+    REPEAT_ONCE,
+    RESULT_FILTER_MAP,
+    RESULT_MAP_OR_INTO_OPTION,
+    RETURN_AND_THEN,
+    SEARCH_IS_SOME,
+    SEEK_FROM_CURRENT,
+    SEEK_TO_START_INSTEAD_OF_REWIND,
+    SHOULD_IMPLEMENT_TRAIT,
+    SINGLE_CHAR_ADD_STR,
+    SKIP_WHILE_NEXT,
+    SLICED_STRING_AS_BYTES,
+    STABLE_SORT_PRIMITIVE,
+    STRING_EXTEND_CHARS,
+    STRING_LIT_CHARS_ANY,
+    STR_SPLIT_AT_NEWLINE,
+    SUSPICIOUS_COMMAND_ARG_SPACE,
+    SUSPICIOUS_MAP,
+    SUSPICIOUS_OPEN_OPTIONS,
+    SUSPICIOUS_SPLITN,
+    SUSPICIOUS_TO_OWNED,
+    SWAP_WITH_TEMPORARY,
+    TYPE_ID_ON_BOX,
+    UNBUFFERED_BYTES,
+    UNINIT_ASSUMED_INIT,
+    UNIT_HASH,
+    UNNECESSARY_FALLIBLE_CONVERSIONS,
+    UNNECESSARY_FILTER_MAP,
+    UNNECESSARY_FIND_MAP,
+    UNNECESSARY_FIRST_THEN_CHECK,
+    UNNECESSARY_FOLD,
+    UNNECESSARY_GET_THEN_CHECK,
+    UNNECESSARY_JOIN,
+    UNNECESSARY_LAZY_EVALUATIONS,
+    UNNECESSARY_LITERAL_UNWRAP,
+    UNNECESSARY_MAP_OR,
+    UNNECESSARY_MIN_OR_MAX,
+    UNNECESSARY_OPTION_MAP_OR_ELSE,
+    UNNECESSARY_RESULT_MAP_OR_ELSE,
+    UNNECESSARY_SORT_BY,
+    UNNECESSARY_TO_OWNED,
+    UNWRAP_OR_DEFAULT,
+    UNWRAP_USED,
+    USELESS_ASREF,
+    USELESS_NONZERO_NEW_UNCHECKED,
+    VEC_RESIZE_TO_ZERO,
+    VERBOSE_FILE_READS,
+    WAKER_CLONE_WAKE,
+    WRONG_SELF_CONVENTION,
+    ZST_OFFSET,
+]);
+
 #[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
     avoid_breaking_exported_api: bool,
@@ -4761,6 +4917,8 @@ pub struct Methods {
     allowed_dotfiles: FxHashSet<&'static str>,
     format_args: FormatArgsStorage,
     allow_unwrap_types: Vec<String>,
+    unwrap_allowed_ids: FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: Vec<rustc_hir::def_id::DefId>,
 }
 
 impl Methods {
@@ -4778,166 +4936,12 @@ pub fn new(conf: &'static Conf, format_args: FormatArgsStorage) -> Self {
             allowed_dotfiles,
             format_args,
             allow_unwrap_types: conf.allow_unwrap_types.clone(),
+            unwrap_allowed_ids: FxHashSet::default(),
+            unwrap_allowed_aliases: Vec::new(),
         }
     }
 }
 
-impl_lint_pass!(Methods => [
-    UNWRAP_USED,
-    EXPECT_USED,
-    SHOULD_IMPLEMENT_TRAIT,
-    WRONG_SELF_CONVENTION,
-    OK_EXPECT,
-    UNWRAP_OR_DEFAULT,
-    MAP_UNWRAP_OR,
-    RESULT_MAP_OR_INTO_OPTION,
-    OPTION_MAP_OR_NONE,
-    BIND_INSTEAD_OF_MAP,
-    OR_FUN_CALL,
-    OR_THEN_UNWRAP,
-    EXPECT_FUN_CALL,
-    CHARS_NEXT_CMP,
-    CHARS_LAST_CMP,
-    CLONE_ON_COPY,
-    CLONE_ON_REF_PTR,
-    COLLAPSIBLE_STR_REPLACE,
-    CONST_IS_EMPTY,
-    ITER_OVEREAGER_CLONED,
-    CLONED_INSTEAD_OF_COPIED,
-    FLAT_MAP_OPTION,
-    INEFFICIENT_TO_STRING,
-    NEW_RET_NO_SELF,
-    SINGLE_CHAR_ADD_STR,
-    SEARCH_IS_SOME,
-    FILTER_NEXT,
-    SKIP_WHILE_NEXT,
-    FILTER_MAP_IDENTITY,
-    MAP_IDENTITY,
-    MANUAL_FILTER_MAP,
-    MANUAL_FIND_MAP,
-    OPTION_FILTER_MAP,
-    FILTER_MAP_NEXT,
-    FLAT_MAP_IDENTITY,
-    MAP_FLATTEN,
-    ITERATOR_STEP_BY_ZERO,
-    ITER_NEXT_SLICE,
-    ITER_COUNT,
-    ITER_NTH,
-    ITER_NTH_ZERO,
-    BYTES_NTH,
-    ITER_SKIP_NEXT,
-    GET_UNWRAP,
-    GET_LAST_WITH_LEN,
-    STRING_EXTEND_CHARS,
-    ITER_CLONED_COLLECT,
-    ITER_WITH_DRAIN,
-    TYPE_ID_ON_BOX,
-    USELESS_ASREF,
-    UNNECESSARY_FOLD,
-    UNNECESSARY_FILTER_MAP,
-    UNNECESSARY_FIND_MAP,
-    INTO_ITER_ON_REF,
-    SUSPICIOUS_MAP,
-    UNINIT_ASSUMED_INIT,
-    MANUAL_SATURATING_ARITHMETIC,
-    ZST_OFFSET,
-    PTR_OFFSET_BY_LITERAL,
-    PTR_OFFSET_WITH_CAST,
-    FILETYPE_IS_FILE,
-    OPTION_AS_REF_DEREF,
-    UNNECESSARY_LAZY_EVALUATIONS,
-    MAP_COLLECT_RESULT_UNIT,
-    FROM_ITER_INSTEAD_OF_COLLECT,
-    INSPECT_FOR_EACH,
-    IMPLICIT_CLONE,
-    SUSPICIOUS_TO_OWNED,
-    SUSPICIOUS_SPLITN,
-    MANUAL_STR_REPEAT,
-    EXTEND_WITH_DRAIN,
-    MANUAL_SPLIT_ONCE,
-    NEEDLESS_SPLITN,
-    UNNECESSARY_TO_OWNED,
-    UNNECESSARY_JOIN,
-    ERR_EXPECT,
-    NEEDLESS_OPTION_AS_DEREF,
-    IS_DIGIT_ASCII_RADIX,
-    NEEDLESS_OPTION_TAKE,
-    NO_EFFECT_REPLACE,
-    OBFUSCATED_IF_ELSE,
-    ITER_ON_SINGLE_ITEMS,
-    ITER_ON_EMPTY_COLLECTIONS,
-    NAIVE_BYTECOUNT,
-    BYTES_COUNT_TO_LEN,
-    CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    GET_FIRST,
-    MANUAL_OK_OR,
-    MAP_CLONE,
-    MAP_ERR_IGNORE,
-    MUT_MUTEX_LOCK,
-    NONSENSICAL_OPEN_OPTIONS,
-    SUSPICIOUS_OPEN_OPTIONS,
-    PATH_BUF_PUSH_OVERWRITE,
-    RANGE_ZIP_WITH_LEN,
-    REPEAT_ONCE,
-    STABLE_SORT_PRIMITIVE,
-    UNIT_HASH,
-    READ_LINE_WITHOUT_TRIM,
-    UNNECESSARY_SORT_BY,
-    VEC_RESIZE_TO_ZERO,
-    VERBOSE_FILE_READS,
-    ITER_KV_MAP,
-    SEEK_FROM_CURRENT,
-    SEEK_TO_START_INSTEAD_OF_REWIND,
-    NEEDLESS_COLLECT,
-    SUSPICIOUS_COMMAND_ARG_SPACE,
-    CLEAR_WITH_DRAIN,
-    MANUAL_NEXT_BACK,
-    UNNECESSARY_LITERAL_UNWRAP,
-    DRAIN_COLLECT,
-    MANUAL_TRY_FOLD,
-    FORMAT_COLLECT,
-    STRING_LIT_CHARS_ANY,
-    ITER_SKIP_ZERO,
-    FILTER_MAP_BOOL_THEN,
-    READONLY_WRITE_LOCK,
-    ITER_OUT_OF_BOUNDS,
-    PATH_ENDS_WITH_EXT,
-    REDUNDANT_AS_STR,
-    WAKER_CLONE_WAKE,
-    UNNECESSARY_FALLIBLE_CONVERSIONS,
-    JOIN_ABSOLUTE_PATHS,
-    RESULT_FILTER_MAP,
-    ITER_FILTER_IS_SOME,
-    ITER_FILTER_IS_OK,
-    MANUAL_IS_VARIANT_AND,
-    STR_SPLIT_AT_NEWLINE,
-    OPTION_AS_REF_CLONED,
-    UNNECESSARY_RESULT_MAP_OR_ELSE,
-    MANUAL_C_STR_LITERALS,
-    UNNECESSARY_GET_THEN_CHECK,
-    UNNECESSARY_FIRST_THEN_CHECK,
-    NEEDLESS_CHARACTER_ITERATION,
-    MANUAL_INSPECT,
-    UNNECESSARY_MIN_OR_MAX,
-    NEEDLESS_AS_BYTES,
-    MAP_ALL_ANY_IDENTITY,
-    MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
-    UNNECESSARY_MAP_OR,
-    DOUBLE_ENDED_ITERATOR_LAST,
-    USELESS_NONZERO_NEW_UNCHECKED,
-    MANUAL_REPEAT_N,
-    SLICED_STRING_AS_BYTES,
-    RETURN_AND_THEN,
-    UNBUFFERED_BYTES,
-    MANUAL_CONTAINS,
-    IO_OTHER_ERROR,
-    SWAP_WITH_TEMPORARY,
-    IP_CONSTANT,
-    REDUNDANT_ITER_CLONED,
-    UNNECESSARY_OPTION_MAP_OR_ELSE,
-    LINES_FILTER_MAP_OK,
-]);
-
 /// Extracts a method call name, args, and `Span` of the method name.
 /// This ensures that neither the receiver nor any of the arguments
 /// come from expansion.
@@ -4953,6 +4957,19 @@ pub fn method_call<'tcx>(recv: &'tcx Expr<'tcx>) -> Option<(Symbol, &'tcx Expr<'
 }
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        for s in &self.allow_unwrap_types {
+            let def_ids = clippy_utils::paths::lookup_path_str(cx.tcx, clippy_utils::paths::PathNS::Type, s);
+            for def_id in def_ids {
+                if cx.tcx.def_kind(def_id) == rustc_hir::def::DefKind::TyAlias {
+                    self.unwrap_allowed_aliases.push(def_id);
+                } else {
+                    self.unwrap_allowed_ids.insert(def_id);
+                }
+            }
+        }
+    }
+
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
             return;
@@ -4976,7 +4993,8 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                     self.allow_expect_in_tests,
                     self.allow_unwrap_in_consts,
                     self.allow_expect_in_consts,
-                    &self.allow_unwrap_types,
+                    &self.unwrap_allowed_ids,
+                    &self.unwrap_allowed_aliases,
                 );
             },
             ExprKind::MethodCall(..) => {
@@ -5730,7 +5748,8 @@ fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                         false,
                         self.allow_expect_in_consts,
                         self.allow_expect_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                         unwrap_expect_used::Variant::Expect,
                     );
                     expect_fun_call::check(cx, &self.format_args, expr, method_span, recv, arg);
@@ -5743,7 +5762,8 @@ fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                         true,
                         self.allow_expect_in_consts,
                         self.allow_expect_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                         unwrap_expect_used::Variant::Expect,
                     );
                 },
@@ -5764,7 +5784,8 @@ fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                         false,
                         self.allow_unwrap_in_consts,
                         self.allow_unwrap_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                         unwrap_expect_used::Variant::Unwrap,
                     );
                 },
@@ -5776,7 +5797,8 @@ fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                         true,
                         self.allow_unwrap_in_consts,
                         self.allow_unwrap_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                         unwrap_expect_used::Variant::Unwrap,
                     );
                 },
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index d80feff11f34..a52f3c1be26e 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{peel_blocks, sym};
 use clippy_utils::res::{MaybeDef, MaybeResPath};
 use clippy_utils::source::snippet;
+use clippy_utils::{peel_blocks, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 94c61a74dac6..e12cce93c2a4 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -11,11 +11,12 @@
 use clippy_utils::{
     contains_return, is_default_equivalent, is_default_equivalent_call, last_path_segment, peel_blocks, sym,
 };
+use rustc_ast as ast;
 use rustc_errors::Applicability;
+use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::{Span, Symbol};
-use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{OR_FUN_CALL, UNWRAP_OR_DEFAULT};
 
diff --git a/clippy_lints/src/methods/readonly_write_lock.rs b/clippy_lints/src/methods/readonly_write_lock.rs
index a98a807d1a3c..b89aa8dfb4db 100644
--- a/clippy_lints/src/methods/readonly_write_lock.rs
+++ b/clippy_lints/src/methods/readonly_write_lock.rs
@@ -38,15 +38,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver
             .local_decls
             .iter_enumerated()
             .find(|(_, decl)| local.span.contains(decl.source_info.span))
-        && let Some(usages) = visit_local_usage(
-            &[local],
+        && let Some([usage]) = visit_local_usage(
+            [local],
             mir,
             Location {
                 block: START_BLOCK,
                 statement_index: 0,
             },
         )
-        && let [usage] = usages.as_slice()
     {
         let writer_never_mutated = usage.local_consume_or_mutate_locs.is_empty();
 
diff --git a/clippy_lints/src/methods/suspicious_command_arg_space.rs b/clippy_lints/src/methods/suspicious_command_arg_space.rs
index ca226dca8852..b4ea2e62b3c1 100644
--- a/clippy_lints/src/methods/suspicious_command_arg_space.rs
+++ b/clippy_lints/src/methods/suspicious_command_arg_space.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeDef;
 use clippy_utils::sym;
+use rustc_ast as ast;
 use rustc_errors::{Applicability, Diag};
+use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::Span;
-use {rustc_ast as ast, rustc_hir as hir};
 
 use super::SUSPICIOUS_COMMAND_ARG_SPACE;
 
diff --git a/clippy_lints/src/methods/unwrap_expect_used.rs b/clippy_lints/src/methods/unwrap_expect_used.rs
index 6d8777cbc23f..c07c93217646 100644
--- a/clippy_lints/src/methods/unwrap_expect_used.rs
+++ b/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -44,7 +44,8 @@ pub(super) fn check(
     is_err: bool,
     allow_unwrap_in_consts: bool,
     allow_unwrap_in_tests: bool,
-    allow_unwrap_types: &[String],
+    unwrap_allowed_ids: &rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: &[rustc_hir::def_id::DefId],
     variant: Variant,
 ) {
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();
@@ -66,51 +67,39 @@ pub(super) fn check(
 
     let method_suffix = if is_err { "_err" } else { "" };
 
-    let ty_name = ty.to_string();
-    if allow_unwrap_types
-        .iter()
-        .any(|allowed_type| ty_name.starts_with(allowed_type) || ty_name == *allowed_type)
+    if let ty::Adt(adt, _) = ty.kind()
+        && unwrap_allowed_ids.contains(&adt.did())
     {
         return;
     }
 
-    for s in allow_unwrap_types {
-        let def_ids = clippy_utils::paths::lookup_path_str(cx.tcx, clippy_utils::paths::PathNS::Type, s);
-        for def_id in def_ids {
-            if let ty::Adt(adt, _) = ty.kind()
-                && adt.did() == def_id
-            {
-                return;
-            }
-            if cx.tcx.def_kind(def_id) == DefKind::TyAlias {
-                let alias_ty = cx.tcx.type_of(def_id).instantiate_identity();
-                if let (ty::Adt(adt, substs), ty::Adt(alias_adt, alias_substs)) = (ty.kind(), alias_ty.kind())
-                    && adt.did() == alias_adt.did()
-                {
-                    let mut all_match = true;
-                    for (arg, alias_arg) in substs.iter().zip(alias_substs.iter()) {
-                        if let (Some(arg_ty), Some(alias_arg_ty)) = (arg.as_type(), alias_arg.as_type()) {
-                            if matches!(alias_arg_ty.kind(), ty::Param(_)) {
-                                continue;
-                            }
-                            if let (ty::Adt(arg_adt, _), ty::Adt(alias_arg_adt, _)) =
-                                (arg_ty.peel_refs().kind(), alias_arg_ty.peel_refs().kind())
-                            {
-                                if arg_adt.did() != alias_arg_adt.did() {
-                                    all_match = false;
-                                    break;
-                                }
-                            } else if arg_ty != alias_arg_ty {
-                                all_match = false;
-                                break;
-                            }
-                        }
+    for &def_id in unwrap_allowed_aliases {
+        let alias_ty = cx.tcx.type_of(def_id).instantiate_identity();
+        if let (ty::Adt(adt, substs), ty::Adt(alias_adt, alias_substs)) = (ty.kind(), alias_ty.kind())
+            && adt.did() == alias_adt.did()
+        {
+            let mut all_match = true;
+            for (arg, alias_arg) in substs.iter().zip(alias_substs.iter()) {
+                if let (Some(arg_ty), Some(alias_arg_ty)) = (arg.as_type(), alias_arg.as_type()) {
+                    if matches!(alias_arg_ty.kind(), ty::Param(_)) {
+                        continue;
                     }
-                    if all_match {
-                        return;
+                    if let (ty::Adt(arg_adt, _), ty::Adt(alias_arg_adt, _)) =
+                        (arg_ty.peel_refs().kind(), alias_arg_ty.peel_refs().kind())
+                    {
+                        if arg_adt.did() != alias_arg_adt.did() {
+                            all_match = false;
+                            break;
+                        }
+                    } else if arg_ty != alias_arg_ty {
+                        all_match = false;
+                        break;
                     }
                 }
             }
+            if all_match {
+                return;
+            }
         }
     }
 
@@ -149,7 +138,8 @@ pub(super) fn check_call(
     allow_unwrap_in_tests: bool,
     allow_expect_in_consts: bool,
     allow_expect_in_tests: bool,
-    allow_unwrap_types: &[String],
+    unwrap_allowed_ids: &rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: &[rustc_hir::def_id::DefId],
 ) {
     let Some(recv) = args.first() else {
         return;
@@ -167,7 +157,8 @@ pub(super) fn check_call(
                 false,
                 allow_unwrap_in_consts,
                 allow_unwrap_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                 Variant::Unwrap,
             );
         },
@@ -179,7 +170,8 @@ pub(super) fn check_call(
                 false,
                 allow_expect_in_consts,
                 allow_expect_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                 Variant::Expect,
             );
         },
@@ -191,7 +183,8 @@ pub(super) fn check_call(
                 true,
                 allow_unwrap_in_consts,
                 allow_unwrap_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                 Variant::Unwrap,
             );
         },
@@ -203,7 +196,8 @@ pub(super) fn check_call(
                 true,
                 allow_expect_in_consts,
                 allow_expect_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                 Variant::Expect,
             );
         },
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 1ceee836732a..2bb574ac113c 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -45,6 +45,7 @@
     restriction,
     "disallows idents that are too short"
 }
+
 impl_lint_pass!(MinIdentChars => [MIN_IDENT_CHARS]);
 
 pub struct MinIdentChars {
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 19e9910dfe9d..c77b87268910 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -7,6 +7,27 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the use of short circuit boolean conditions as
+    /// a
+    /// statement.
+    ///
+    /// ### Why is this bad?
+    /// Using a short circuit boolean condition as a statement
+    /// may hide the fact that the second part is executed or not depending on the
+    /// outcome of the first part.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// f() && g(); // We should write `if f() { g(); }`.
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SHORT_CIRCUIT_STATEMENT,
+    complexity,
+    "using a short circuit boolean condition as a statement"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the use of bindings with a single leading
@@ -72,31 +93,10 @@
     "using a item which is prefixed with an underscore"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the use of short circuit boolean conditions as
-    /// a
-    /// statement.
-    ///
-    /// ### Why is this bad?
-    /// Using a short circuit boolean condition as a statement
-    /// may hide the fact that the second part is executed or not depending on the
-    /// outcome of the first part.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// f() && g(); // We should write `if f() { g(); }`.
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SHORT_CIRCUIT_STATEMENT,
-    complexity,
-    "using a short circuit boolean condition as a statement"
-}
-
 declare_lint_pass!(LintPass => [
+    SHORT_CIRCUIT_STATEMENT,
     USED_UNDERSCORE_BINDING,
     USED_UNDERSCORE_ITEMS,
-    SHORT_CIRCUIT_STATEMENT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LintPass {
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index f988323a8c13..604b946d91a7 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -14,6 +14,144 @@
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if a generic shadows a built-in type.
+    ///
+    /// ### Why is this bad?
+    /// This gives surprising type errors.
+    ///
+    /// ### Example
+    ///
+    /// ```ignore
+    /// impl<u32> Foo<u32> {
+    ///     fn impl_func(&self) -> u32 {
+    ///         42
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub BUILTIN_TYPE_SHADOW,
+    style,
+    "shadowing a builtin type"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns on hexadecimal literals with mixed-case letter
+    /// digits.
+    ///
+    /// ### Why is this bad?
+    /// It looks confusing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let _ =
+    /// 0x1a9BAcD
+    /// # ;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let _ =
+    /// 0x1A9BACD
+    /// # ;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MIXED_CASE_HEX_LITERALS,
+    style,
+    "hex literals whose letter digits are not consistently upper- or lowercased"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `[all @ ..]` patterns.
+    ///
+    /// ### Why is this bad?
+    /// In all cases, `all` works fine and can often make code simpler, as you possibly won't need
+    /// to convert from say a `Vec` to a slice by dereferencing.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if let [all @ ..] = &*v {
+    ///     // NOTE: Type is a slice here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// if let all = v {
+    ///     // NOTE: Type is a `Vec` here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// // or
+    /// println!("all elements: {v:#?}");
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub REDUNDANT_AT_REST_PATTERN,
+    complexity,
+    "checks for `[all @ ..]` where `all` would suffice"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for patterns in the form `name @ _`.
+    ///
+    /// ### Why is this bad?
+    /// It's almost always more readable to just use direct
+    /// bindings.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let v = Some("abc");
+    /// match v {
+    ///     Some(x) => (),
+    ///     y @ _ => (),
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let v = Some("abc");
+    /// match v {
+    ///     Some(x) => (),
+    ///     y => (),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub REDUNDANT_PATTERN,
+    style,
+    "using `name @ _` in a pattern"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if literal suffixes are separated by an underscore.
+    /// To enforce separated literal suffix style,
+    /// see the `unseparated_literal_suffix` lint.
+    ///
+    /// ### Why restrict this?
+    /// Suffix style should be consistent.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let _ =
+    /// 123832_i32
+    /// # ;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let _ =
+    /// 123832i32
+    /// # ;
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub SEPARATED_LITERAL_SUFFIX,
+    restriction,
+    "literals whose suffix is separated by an underscore"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for structure field patterns bound to wildcards.
@@ -59,29 +197,41 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns on hexadecimal literals with mixed-case letter
-    /// digits.
+    /// Checks for tuple patterns with a wildcard
+    /// pattern (`_`) is next to a rest pattern (`..`).
+    ///
+    /// _NOTE_: While `_, ..` means there is at least one element left, `..`
+    /// means there are 0 or more elements left. This can make a difference
+    /// when refactoring, but shouldn't result in errors in the refactored code,
+    /// since the wildcard pattern isn't used anyway.
     ///
     /// ### Why is this bad?
-    /// It looks confusing.
+    /// The wildcard pattern is unneeded as the rest pattern
+    /// can match that element as well.
     ///
     /// ### Example
     /// ```no_run
-    /// # let _ =
-    /// 0x1a9BAcD
-    /// # ;
+    /// # struct TupleStruct(u32, u32, u32);
+    /// # let t = TupleStruct(1, 2, 3);
+    /// match t {
+    ///     TupleStruct(0, .., _) => (),
+    ///     _ => (),
+    /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let _ =
-    /// 0x1A9BACD
-    /// # ;
+    /// # struct TupleStruct(u32, u32, u32);
+    /// # let t = TupleStruct(1, 2, 3);
+    /// match t {
+    ///     TupleStruct(0, ..) => (),
+    ///     _ => (),
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MIXED_CASE_HEX_LITERALS,
-    style,
-    "hex literals whose letter digits are not consistently upper- or lowercased"
+    #[clippy::version = "1.40.0"]
+    pub UNNEEDED_WILDCARD_PATTERN,
+    complexity,
+    "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
 }
 
 declare_clippy_lint! {
@@ -113,34 +263,6 @@
     "literals whose suffix is not separated by an underscore"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if literal suffixes are separated by an underscore.
-    /// To enforce separated literal suffix style,
-    /// see the `unseparated_literal_suffix` lint.
-    ///
-    /// ### Why restrict this?
-    /// Suffix style should be consistent.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let _ =
-    /// 123832_i32
-    /// # ;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let _ =
-    /// 123832i32
-    /// # ;
-    /// ```
-    #[clippy::version = "1.58.0"]
-    pub SEPARATED_LITERAL_SUFFIX,
-    restriction,
-    "literals whose suffix is separated by an underscore"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Warns if an integral constant literal starts with `0`.
@@ -180,138 +302,16 @@
     "integer literals starting with `0`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if a generic shadows a built-in type.
-    ///
-    /// ### Why is this bad?
-    /// This gives surprising type errors.
-    ///
-    /// ### Example
-    ///
-    /// ```ignore
-    /// impl<u32> Foo<u32> {
-    ///     fn impl_func(&self) -> u32 {
-    ///         42
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BUILTIN_TYPE_SHADOW,
-    style,
-    "shadowing a builtin type"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for patterns in the form `name @ _`.
-    ///
-    /// ### Why is this bad?
-    /// It's almost always more readable to just use direct
-    /// bindings.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let v = Some("abc");
-    /// match v {
-    ///     Some(x) => (),
-    ///     y @ _ => (),
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let v = Some("abc");
-    /// match v {
-    ///     Some(x) => (),
-    ///     y => (),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub REDUNDANT_PATTERN,
-    style,
-    "using `name @ _` in a pattern"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for tuple patterns with a wildcard
-    /// pattern (`_`) is next to a rest pattern (`..`).
-    ///
-    /// _NOTE_: While `_, ..` means there is at least one element left, `..`
-    /// means there are 0 or more elements left. This can make a difference
-    /// when refactoring, but shouldn't result in errors in the refactored code,
-    /// since the wildcard pattern isn't used anyway.
-    ///
-    /// ### Why is this bad?
-    /// The wildcard pattern is unneeded as the rest pattern
-    /// can match that element as well.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # struct TupleStruct(u32, u32, u32);
-    /// # let t = TupleStruct(1, 2, 3);
-    /// match t {
-    ///     TupleStruct(0, .., _) => (),
-    ///     _ => (),
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # struct TupleStruct(u32, u32, u32);
-    /// # let t = TupleStruct(1, 2, 3);
-    /// match t {
-    ///     TupleStruct(0, ..) => (),
-    ///     _ => (),
-    /// }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub UNNEEDED_WILDCARD_PATTERN,
-    complexity,
-    "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `[all @ ..]` patterns.
-    ///
-    /// ### Why is this bad?
-    /// In all cases, `all` works fine and can often make code simpler, as you possibly won't need
-    /// to convert from say a `Vec` to a slice by dereferencing.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// if let [all @ ..] = &*v {
-    ///     // NOTE: Type is a slice here
-    ///     println!("all elements: {all:#?}");
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// if let all = v {
-    ///     // NOTE: Type is a `Vec` here
-    ///     println!("all elements: {all:#?}");
-    /// }
-    /// // or
-    /// println!("all elements: {v:#?}");
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub REDUNDANT_AT_REST_PATTERN,
-    complexity,
-    "checks for `[all @ ..]` where `all` would suffice"
-}
-
 declare_lint_pass!(MiscEarlyLints => [
-    UNNEEDED_FIELD_PATTERN,
-    MIXED_CASE_HEX_LITERALS,
-    UNSEPARATED_LITERAL_SUFFIX,
-    SEPARATED_LITERAL_SUFFIX,
-    ZERO_PREFIXED_LITERAL,
     BUILTIN_TYPE_SHADOW,
-    REDUNDANT_PATTERN,
-    UNNEEDED_WILDCARD_PATTERN,
+    MIXED_CASE_HEX_LITERALS,
     REDUNDANT_AT_REST_PATTERN,
+    REDUNDANT_PATTERN,
+    SEPARATED_LITERAL_SUFFIX,
+    UNNEEDED_FIELD_PATTERN,
+    UNNEEDED_WILDCARD_PATTERN,
+    UNSEPARATED_LITERAL_SUFFIX,
+    ZERO_PREFIXED_LITERAL,
 ]);
 
 impl EarlyLintPass for MiscEarlyLints {
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 394bc4aef1cc..70eab98bd067 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -45,6 +45,7 @@
     pedantic,
     "type parameter positioned inconsistently between type def and impl block"
 }
+
 declare_lint_pass!(TypeParamMismatch => [MISMATCHING_TYPE_PARAM_ORDER]);
 
 impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 651382fb4bfe..2773f537efc6 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -65,6 +65,7 @@
     restriction,
     "indexing into a slice multiple times without an `assert`"
 }
+
 declare_lint_pass!(MissingAssertsForIndexing => [MISSING_ASSERTS_FOR_INDEXING]);
 
 fn report_lint<F>(cx: &LateContext<'_>, index_spans: Vec<Span>, msg: &'static str, f: F)
diff --git a/clippy_lints/src/missing_const_for_thread_local.rs b/clippy_lints/src/missing_const_for_thread_local.rs
index 4b4bc6a6e05d..bb5396c7cac9 100644
--- a/clippy_lints/src/missing_const_for_thread_local.rs
+++ b/clippy_lints/src/missing_const_for_thread_local.rs
@@ -42,6 +42,8 @@
     "suggest using `const` in `thread_local!` macro"
 }
 
+impl_lint_pass!(MissingConstForThreadLocal => [MISSING_CONST_FOR_THREAD_LOCAL]);
+
 pub struct MissingConstForThreadLocal {
     msrv: Msrv,
 }
@@ -52,8 +54,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(MissingConstForThreadLocal => [MISSING_CONST_FOR_THREAD_LOCAL]);
-
 #[inline]
 fn is_thread_local_initializer(
     cx: &LateContext<'_>,
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 375b275cd113..89a61298bf19 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -29,6 +29,8 @@
     "detects missing documentation for private members"
 }
 
+impl_lint_pass!(MissingDoc => [MISSING_DOCS_IN_PRIVATE_ITEMS]);
+
 pub struct MissingDoc {
     /// Whether to **only** check for missing documentation in items visible within the current
     /// crate. For example, `pub(crate)` items.
@@ -99,8 +101,6 @@ fn is_missing_docs(&self, cx: &LateContext<'_>, def_id: LocalDefId, hir_id: HirI
     }
 }
 
-impl_lint_pass!(MissingDoc => [MISSING_DOCS_IN_PRIVATE_ITEMS]);
-
 impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     fn check_attributes(&mut self, _: &LateContext<'tcx>, attrs: &'tcx [Attribute]) {
         self.attr_depth += 1;
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 1f9652a2bd38..7dbe39bb099d 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -46,6 +46,8 @@
     "enforce import renames"
 }
 
+impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
+
 pub struct ImportRename {
     renames: DefIdMap<Symbol>,
 }
@@ -67,8 +69,6 @@ pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
-
 impl LateLintPass<'_> for ImportRename {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if let ItemKind::Use(path, UseKind::Single(_)) = &item.kind {
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index a26f24d15247..332c19e140b3 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -76,6 +76,7 @@
     pedantic,
     "missing fields in manual `Debug` implementation"
 }
+
 declare_lint_pass!(MissingFieldsInDebug => [MISSING_FIELDS_IN_DEBUG]);
 
 fn report_lints(cx: &LateContext<'_>, span: Span, span_notes: Vec<(Span, &'static str)>) {
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 0dd531d36742..16dae67c2986 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -64,6 +64,8 @@
     "detects missing `#[inline]` attribute for public callables (functions, trait methods, methods...)"
 }
 
+declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
+
 fn check_missing_inline_attrs(
     cx: &LateContext<'_>,
     attrs: &[Attribute],
@@ -81,8 +83,6 @@ fn check_missing_inline_attrs(
     }
 }
 
-declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
-
 impl<'tcx> LateLintPass<'tcx> for MissingInline {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
         if it.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index 7a791f949943..332d31feeecf 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -55,6 +55,7 @@
     restriction,
     "trait implementation uses default provided method"
 }
+
 declare_lint_pass!(MissingTraitMethods => [MISSING_TRAIT_METHODS]);
 
 impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 53f97abe0b44..99561e60f725 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -8,6 +8,34 @@
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for diverging calls that are not match arms or
+    /// statements.
+    ///
+    /// ### Why is this bad?
+    /// It is often confusing to read. In addition, the
+    /// sub-expression evaluation order for Rust is not well documented.
+    ///
+    /// ### Known problems
+    /// Someone might want to use `some_bool || panic!()` as a
+    /// shorthand.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// # fn b() -> bool { true }
+    /// # fn c() -> bool { true }
+    /// let a = b() || panic!() || c();
+    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
+    /// let x = (a, b, c, panic!());
+    /// // can simply be replaced by `panic!()`
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DIVERGING_SUB_EXPRESSION,
+    complexity,
+    "whether an expression contains a diverging sub expression"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for a read and a write to the same variable where
@@ -51,35 +79,10 @@
     "whether a variable read occurs before a write depends on sub-expression evaluation order"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for diverging calls that are not match arms or
-    /// statements.
-    ///
-    /// ### Why is this bad?
-    /// It is often confusing to read. In addition, the
-    /// sub-expression evaluation order for Rust is not well documented.
-    ///
-    /// ### Known problems
-    /// Someone might want to use `some_bool || panic!()` as a
-    /// shorthand.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # fn b() -> bool { true }
-    /// # fn c() -> bool { true }
-    /// let a = b() || panic!() || c();
-    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
-    /// let x = (a, b, c, panic!());
-    /// // can simply be replaced by `panic!()`
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DIVERGING_SUB_EXPRESSION,
-    complexity,
-    "whether an expression contains a diverging sub expression"
-}
-
-declare_lint_pass!(EvalOrderDependence => [MIXED_READ_WRITE_IN_EXPRESSION, DIVERGING_SUB_EXPRESSION]);
+declare_lint_pass!(EvalOrderDependence => [
+    DIVERGING_SUB_EXPRESSION,
+    MIXED_READ_WRITE_IN_EXPRESSION,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index ebf7ccfd5ba7..7e96507a27b1 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -72,6 +72,7 @@
     restriction,
     "more than one unsafe operation per `unsafe` block"
 }
+
 declare_lint_pass!(MultipleUnsafeOpsPerBlock => [MULTIPLE_UNSAFE_OPS_PER_BLOCK]);
 
 impl<'tcx> LateLintPass<'tcx> for MultipleUnsafeOpsPerBlock {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 7669ad047c46..86438a1753bd 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{sym, trait_ref_of_method};
 use clippy_utils::ty::InteriorMut;
+use clippy_utils::{sym, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::print::with_forced_trimmed_paths;
@@ -67,12 +67,12 @@
     "Check for mutable `Map`/`Set` key type"
 }
 
+impl_lint_pass!(MutableKeyType<'_> => [MUTABLE_KEY_TYPE]);
+
 pub struct MutableKeyType<'tcx> {
     interior_mut: InteriorMut<'tcx>,
 }
 
-impl_lint_pass!(MutableKeyType<'_> => [ MUTABLE_KEY_TYPE ]);
-
 impl<'tcx> LateLintPass<'tcx> for MutableKeyType<'tcx> {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         if let hir::ItemKind::Fn { ref sig, .. } = item.kind {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 6b5db9dcf3e2..387b6f8bf223 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -80,6 +80,7 @@
     complexity,
     "setting the same boolean variable in both branches of an if-statement"
 }
+
 declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL, NEEDLESS_BOOL_ASSIGN]);
 
 fn condition_needs_parentheses(e: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 8da9a6dfcad4..c77398cbc836 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -56,6 +56,10 @@
     "taking a reference that is going to be automatically dereferenced"
 }
 
+impl_lint_pass!(NeedlessBorrowsForGenericArgs<'_> => [
+    NEEDLESS_BORROWS_FOR_GENERIC_ARGS,
+]);
+
 pub struct NeedlessBorrowsForGenericArgs<'tcx> {
     /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
     /// [`needless_borrow_count`] to determine when a borrowed expression can instead
@@ -65,8 +69,6 @@ pub struct NeedlessBorrowsForGenericArgs<'tcx> {
     // `IntoIterator` for arrays requires Rust 1.53.
     msrv: Msrv,
 }
-impl_lint_pass!(NeedlessBorrowsForGenericArgs<'_> => [NEEDLESS_BORROWS_FOR_GENERIC_ARGS]);
-
 impl NeedlessBorrowsForGenericArgs<'_> {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index f8bb72a16db2..807c4cf5da8e 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -32,6 +32,7 @@
     style,
     "empty else branch"
 }
+
 declare_lint_pass!(NeedlessElse => [NEEDLESS_ELSE]);
 
 impl EarlyLintPass for NeedlessElse {
diff --git a/clippy_lints/src/needless_ifs.rs b/clippy_lints/src/needless_ifs.rs
index 8ec7e47ccc5b..ad1da9441dac 100644
--- a/clippy_lints/src/needless_ifs.rs
+++ b/clippy_lints/src/needless_ifs.rs
@@ -33,6 +33,7 @@
     complexity,
     "checks for empty if branches"
 }
+
 declare_lint_pass!(NeedlessIfs => [NEEDLESS_IFS]);
 
 impl LateLintPass<'_> for NeedlessIfs {
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 464a91959a8e..bc4f6ca40171 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -60,6 +60,7 @@
     style,
     "late initializations that can be replaced by a `let` statement with an initializer"
 }
+
 declare_lint_pass!(NeedlessLateInit => [NEEDLESS_LATE_INIT]);
 
 fn contains_assign_expr<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> bool {
diff --git a/clippy_lints/src/needless_maybe_sized.rs b/clippy_lints/src/needless_maybe_sized.rs
index e7ae54e0d0e1..d718751e3428 100644
--- a/clippy_lints/src/needless_maybe_sized.rs
+++ b/clippy_lints/src/needless_maybe_sized.rs
@@ -32,6 +32,7 @@
     suspicious,
     "a `?Sized` bound that is unusable due to a `Sized` requirement"
 }
+
 declare_lint_pass!(NeedlessMaybeSized => [NEEDLESS_MAYBE_SIZED]);
 
 #[expect(clippy::struct_field_names)]
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index f270ba7277cb..0c23bd6b1f96 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -38,7 +38,9 @@
   "needless parenthesis on range literals can be removed"
 }
 
-declare_lint_pass!(NeedlessParensOnRangeLiterals => [NEEDLESS_PARENS_ON_RANGE_LITERALS]);
+declare_lint_pass!(NeedlessParensOnRangeLiterals => [
+    NEEDLESS_PARENS_ON_RANGE_LITERALS,
+]);
 
 fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
     snippet.starts_with('(') && snippet.ends_with(')')
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index f3e42b1c58f8..2b1f7574a83a 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -51,6 +51,8 @@
     "using a `&mut` argument when it's not mutated"
 }
 
+impl_lint_pass!(NeedlessPassByRefMut<'_> => [NEEDLESS_PASS_BY_REF_MUT]);
+
 pub struct NeedlessPassByRefMut<'tcx> {
     avoid_breaking_exported_api: bool,
     used_fn_def_ids: FxHashSet<LocalDefId>,
@@ -67,8 +69,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(NeedlessPassByRefMut<'_> => [NEEDLESS_PASS_BY_REF_MUT]);
-
 fn should_skip<'tcx>(
     cx: &LateContext<'tcx>,
     input: rustc_hir::Ty<'tcx>,
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index e151c06c6c20..ce8ce2aa900a 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -50,13 +50,13 @@
     "`pub fn new() -> Self` method without `Default` implementation"
 }
 
+impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
+
 #[derive(Clone, Default)]
 pub struct NewWithoutDefault {
     impling_types: Option<HirIdSet>,
 }
 
-impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
-
 impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     #[expect(clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 3620e5425a94..7163daa5b0f3 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -73,14 +73,18 @@
     "outer expressions with no effect"
 }
 
+impl_lint_pass!(NoEffect => [
+    NO_EFFECT,
+    NO_EFFECT_UNDERSCORE_BINDING,
+    UNNECESSARY_OPERATION,
+]);
+
 #[derive(Default)]
 pub struct NoEffect {
     underscore_bindings: HirIdMap<Span>,
     local_bindings: Vec<Vec<HirId>>,
 }
 
-impl_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION, NO_EFFECT_UNDERSCORE_BINDING]);
-
 impl<'tcx> LateLintPass<'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if self.check_no_effect(cx, stmt) {
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index daa2c2877944..760a5a920542 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -34,6 +34,7 @@
     pedantic,
     "convert Rust ABI functions to C ABI"
 }
+
 declare_lint_pass!(NoMangleWithRustAbi => [NO_MANGLE_WITH_RUST_ABI]);
 
 impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index e66c088617cb..46d1be80b50a 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -51,6 +51,7 @@
     suspicious,
     "non-canonical implementation of `Clone` on a `Copy` type"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for non-canonical implementations of `PartialOrd` when `Ord` is already implemented.
@@ -108,7 +109,11 @@
     suspicious,
     "non-canonical implementation of `PartialOrd` on an `Ord` type"
 }
-impl_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL_PARTIAL_ORD_IMPL]);
+
+impl_lint_pass!(NonCanonicalImpls => [
+    NON_CANONICAL_CLONE_IMPL,
+    NON_CANONICAL_PARTIAL_ORD_IMPL,
+]);
 
 #[expect(
     clippy::struct_field_names,
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index f591a1be1f80..015cd06b23e3 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -42,61 +42,6 @@
 use rustc_span::DUMMY_SP;
 use std::collections::hash_map::Entry;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the declaration of named constant which contain interior mutability.
-    ///
-    /// ### Why is this bad?
-    /// Named constants are copied at every use site which means any change to their value
-    /// will be lost after the newly created value is dropped. e.g.
-    ///
-    /// ```rust
-    /// use core::sync::atomic::{AtomicUsize, Ordering};
-    /// const ATOMIC: AtomicUsize = AtomicUsize::new(0);
-    /// fn add_one() -> usize {
-    ///     // This will always return `0` since `ATOMIC` is copied before it's used.
-    ///     ATOMIC.fetch_add(1, Ordering::AcqRel)
-    /// }
-    /// ```
-    ///
-    /// If shared modification of the value is desired, a `static` item is needed instead.
-    /// If that is not desired, a `const fn` constructor should be used to make it obvious
-    /// at the use site that a new value is created.
-    ///
-    /// ### Known problems
-    /// Prior to `const fn` stabilization this was the only way to provide a value which
-    /// could initialize a `static` item (e.g. the `std::sync::ONCE_INIT` constant). In
-    /// this case the use of `const` is required and this lint should be suppressed.
-    ///
-    /// There also exists types which contain private fields with interior mutability, but
-    /// no way to both create a value as a constant and modify any mutable field using the
-    /// type's public interface (e.g. `bytes::Bytes`). As there is no reasonable way to
-    /// scan a crate's interface to see if this is the case, all such types will be linted.
-    /// If this happens use the `ignore-interior-mutability` configuration option to allow
-    /// the type.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    ///
-    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
-    /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
-    /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
-    /// STATIC_ATOM.store(9, SeqCst);
-    /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DECLARE_INTERIOR_MUTABLE_CONST,
-    suspicious,
-    "declaring `const` with interior mutability"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for a borrow of a named constant with interior mutability.
@@ -160,6 +105,66 @@
     "referencing `const` with interior mutability"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the declaration of named constant which contain interior mutability.
+    ///
+    /// ### Why is this bad?
+    /// Named constants are copied at every use site which means any change to their value
+    /// will be lost after the newly created value is dropped. e.g.
+    ///
+    /// ```rust
+    /// use core::sync::atomic::{AtomicUsize, Ordering};
+    /// const ATOMIC: AtomicUsize = AtomicUsize::new(0);
+    /// fn add_one() -> usize {
+    ///     // This will always return `0` since `ATOMIC` is copied before it's used.
+    ///     ATOMIC.fetch_add(1, Ordering::AcqRel)
+    /// }
+    /// ```
+    ///
+    /// If shared modification of the value is desired, a `static` item is needed instead.
+    /// If that is not desired, a `const fn` constructor should be used to make it obvious
+    /// at the use site that a new value is created.
+    ///
+    /// ### Known problems
+    /// Prior to `const fn` stabilization this was the only way to provide a value which
+    /// could initialize a `static` item (e.g. the `std::sync::ONCE_INIT` constant). In
+    /// this case the use of `const` is required and this lint should be suppressed.
+    ///
+    /// There also exists types which contain private fields with interior mutability, but
+    /// no way to both create a value as a constant and modify any mutable field using the
+    /// type's public interface (e.g. `bytes::Bytes`). As there is no reasonable way to
+    /// scan a crate's interface to see if this is the case, all such types will be linted.
+    /// If this happens use the `ignore-interior-mutability` configuration option to allow
+    /// the type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    ///
+    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
+    /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
+    /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
+    /// STATIC_ATOM.store(9, SeqCst);
+    /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DECLARE_INTERIOR_MUTABLE_CONST,
+    suspicious,
+    "declaring `const` with interior mutability"
+}
+
+impl_lint_pass!(NonCopyConst<'_> => [
+    BORROW_INTERIOR_MUTABLE_CONST,
+    DECLARE_INTERIOR_MUTABLE_CONST,
+]);
+
 #[derive(Clone, Copy)]
 enum IsFreeze {
     /// The type and all possible values are `Freeze`
@@ -257,8 +262,6 @@ pub struct NonCopyConst<'tcx> {
     freeze_tys: FxHashMap<Ty<'tcx>, IsFreeze>,
 }
 
-impl_lint_pass!(NonCopyConst<'_> => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTERIOR_MUTABLE_CONST]);
-
 impl<'tcx> NonCopyConst<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 1961ac1516da..72542d4845b3 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -10,6 +10,46 @@
 use rustc_span::{Span, sym};
 use std::cmp::Ordering;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if you have variables whose name consists of just
+    /// underscores and digits.
+    ///
+    /// ### Why is this bad?
+    /// It's hard to memorize what a variable means without a
+    /// descriptive name.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _1 = 1;
+    /// let ___1 = 1;
+    /// let __1___2 = 11;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub JUST_UNDERSCORES_AND_DIGITS,
+    style,
+    "unclear name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for too many variables whose name consists of a
+    /// single character.
+    ///
+    /// ### Why is this bad?
+    /// It's hard to memorize what a variable means without a
+    /// descriptive name.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let (a, b, c, d, e, f, g) = (...);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MANY_SINGLE_CHAR_NAMES,
+    pedantic,
+    "too many single character bindings"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for names that are very similar and thus confusing.
@@ -33,52 +73,16 @@
     "similarly named items and bindings"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for too many variables whose name consists of a
-    /// single character.
-    ///
-    /// ### Why is this bad?
-    /// It's hard to memorize what a variable means without a
-    /// descriptive name.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let (a, b, c, d, e, f, g) = (...);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MANY_SINGLE_CHAR_NAMES,
-    pedantic,
-    "too many single character bindings"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if you have variables whose name consists of just
-    /// underscores and digits.
-    ///
-    /// ### Why is this bad?
-    /// It's hard to memorize what a variable means without a
-    /// descriptive name.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _1 = 1;
-    /// let ___1 = 1;
-    /// let __1___2 = 11;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub JUST_UNDERSCORES_AND_DIGITS,
-    style,
-    "unclear name"
-}
+impl_lint_pass!(NonExpressiveNames => [
+    JUST_UNDERSCORES_AND_DIGITS,
+    MANY_SINGLE_CHAR_NAMES,
+    SIMILAR_NAMES,
+]);
 
 pub struct NonExpressiveNames {
     pub single_char_binding_names_threshold: u64,
 }
 
-impl_lint_pass!(NonExpressiveNames => [SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS]);
-
 impl NonExpressiveNames {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 3c4dfade3439..c6ed0082016f 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -54,6 +54,8 @@
     "there is a field that is not safe to be sent to another thread in a `Send` struct"
 }
 
+impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELDS_IN_SEND_TY]);
+
 pub struct NonSendFieldInSendTy {
     enable_raw_pointer_heuristic: bool,
 }
@@ -66,8 +68,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELDS_IN_SEND_TY]);
-
 impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
diff --git a/clippy_lints/src/non_std_lazy_statics.rs b/clippy_lints/src/non_std_lazy_statics.rs
index 61e4d419fdf0..487eaecf1889 100644
--- a/clippy_lints/src/non_std_lazy_statics.rs
+++ b/clippy_lints/src/non_std_lazy_statics.rs
@@ -45,6 +45,8 @@
     "lazy static that could be replaced by `std::sync::LazyLock`"
 }
 
+impl_lint_pass!(NonStdLazyStatic => [NON_STD_LAZY_STATICS]);
+
 /// A list containing functions with corresponding replacements in `LazyLock`.
 ///
 /// Some functions could be replaced as well if we have replaced `Lazy` to `LazyLock`,
@@ -83,8 +85,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(NonStdLazyStatic => [NON_STD_LAZY_STATICS]);
-
 fn can_use_lazy_cell(cx: &LateContext<'_>, msrv: Msrv) -> bool {
     msrv.meets(cx, msrvs::LAZY_CELL) && !is_no_std_crate(cx)
 }
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 8970970f4b47..b449681ae2e1 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -33,6 +33,8 @@
     "check consistent use of braces in macro"
 }
 
+impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
+
 struct MacroInfo {
     callsite_span: Span,
     callsite_snippet: SourceText,
@@ -54,8 +56,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
-
 impl EarlyLintPass for MacroBraces {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         if let Some(MacroInfo {
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index f756f94d97b3..8b0743c8d9d5 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -164,7 +164,11 @@
     pedantic,
     "self receiver only used to recursively call method can be removed"
 }
-impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION, SELF_ONLY_USED_IN_RECURSION]);
+
+impl_lint_pass!(OnlyUsedInRecursion => [
+    ONLY_USED_IN_RECURSION,
+    SELF_ONLY_USED_IN_RECURSION,
+]);
 
 #[derive(Clone, Copy)]
 enum FnKind {
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 106286d16d18..96e7f7785357 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -5,12 +5,13 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::res::MaybeDef;
 use clippy_utils::{expr_or_init, is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary, sym};
+use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, UintTy};
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, Symbol};
-use {rustc_ast as ast, rustc_hir as hir};
 
 pub struct ArithmeticSideEffects {
     allowed_binary: FxHashMap<&'static str, FxHashSet<&'static str>>,
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 08ef5958b3bb..fa1ce43d53b4 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -100,10 +100,10 @@ fn check_op(cx: &LateContext<'_>, outer: &Expr<'_>, expr: &Expr<'_>, other: &Exp
 
             let mut applicability = Applicability::MachineApplicable;
             let (arg_snip, _) = snippet_with_context(cx, arg_span, expr.span.ctxt(), "..", &mut applicability);
-            let (expr_snip, eq_impl) = if with_deref.is_implemented() && !arg_ty.peel_refs().is_str() {
-                (format!("*{arg_snip}"), with_deref)
-            } else {
+            let (expr_snip, eq_impl) = if without_deref.is_implemented() {
                 (arg_snip.to_string(), without_deref)
+            } else {
+                (format!("*{arg_snip}"), with_deref)
             };
 
             let (span, hint) = if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 5b00f1b0bd13..567443b8e86d 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -103,25 +103,6 @@
     "any arithmetic expression that can cause side effects like overflows or panics"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for float arithmetic.
-    ///
-    /// ### Why restrict this?
-    /// For some embedded systems or kernel development, it
-    /// can be useful to rule out floating-point numbers.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let a = 0.0;
-    /// a + 1.0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_ARITHMETIC,
-    restriction,
-    "any floating-point arithmetic statement"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `a = a op b` or `a = b commutative_op a`
@@ -157,33 +138,6 @@
     "assigning the result of an operation on a variable to that same variable"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `a op= a op b` or `a op= b op a` patterns.
-    ///
-    /// ### Why is this bad?
-    /// Most likely these are bugs where one meant to write `a
-    /// op= b`.
-    ///
-    /// ### Known problems
-    /// Clippy cannot know for sure if `a op= a op b` should have
-    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
-    /// If `a op= a op b` is really the correct behavior it should be
-    /// written as `a = a op a op b` as it's less confusing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut a = 5;
-    /// let b = 2;
-    /// // ...
-    /// a += a + b;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MISREFACTORED_ASSIGN_OP,
-    suspicious,
-    "having a variable on both sides of an assign op"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for incompatible bit masks in comparisons.
@@ -224,69 +178,53 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bit masks in comparisons which can be removed
-    /// without changing the outcome. The basic structure can be seen in the
-    /// following table:
-    ///
-    /// |Comparison| Bit Op   |Example     |equals |
-    /// |----------|----------|------------|-------|
-    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
-    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
+    /// Checks for conversions to owned values just for the sake
+    /// of a comparison.
     ///
     /// ### Why is this bad?
-    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
-    /// but still a bit misleading, because the bit mask is ineffective.
-    ///
-    /// ### Known problems
-    /// False negatives: This lint will only match instances
-    /// where we have figured out the math (which is for a power-of-two compared
-    /// value). This means things like `x | 1 >= 7` (which would be better written
-    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
-    /// uncommon).
+    /// The comparison can operate on a reference, so creating
+    /// an owned value effectively throws it away directly afterwards, which is
+    /// needlessly consuming code and heap space.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = 1;
-    /// if (x | 1 > 3) {  }
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x.to_owned() == y {}
     /// ```
     ///
     /// Use instead:
-    ///
     /// ```no_run
-    /// # let x = 1;
-    /// if (x >= 2) {  }
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x == y {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub INEFFECTIVE_BIT_MASK,
-    correctness,
-    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
+    pub CMP_OWNED,
+    perf,
+    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bit masks that can be replaced by a call
-    /// to `trailing_zeros`
+    /// Checks for decimal literals used as bit masks in bitwise operations.
     ///
     /// ### Why is this bad?
-    /// `x.trailing_zeros() >= 4` is much clearer than `x & 15
-    /// == 0`
+    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
+    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let x = 1;
-    /// if x & 0b1111 == 0 { }
+    /// ```rust,no_run
+    /// let a = 14 & 6; // Bit pattern is not immediately clear
     /// ```
-    ///
     /// Use instead:
-    ///
-    /// ```no_run
-    /// # let x: i32 = 1;
-    /// if x.trailing_zeros() >= 4 { }
+    /// ```rust,no_run
+    /// let a = 0b1110 & 0b0110;
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub VERBOSE_BIT_MASK,
+    #[clippy::version = "1.93.0"]
+    pub DECIMAL_BITWISE_OPERANDS,
     pedantic,
-    "expressions where a bit mask is less readable than the corresponding method call"
+    "use binary, hex, or octal literals for bitwise operations"
 }
 
 declare_clippy_lint! {
@@ -317,45 +255,6 @@
     "unnecessary double comparisons that can be simplified"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for double comparisons that can never succeed
-    ///
-    /// ### Why is this bad?
-    /// The whole expression can be replaced by `false`,
-    /// which is probably not the programmer's intention
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let status_code = 200;
-    /// if status_code <= 400 && status_code > 500 {}
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub IMPOSSIBLE_COMPARISONS,
-    correctness,
-    "double comparisons that will never evaluate to `true`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for ineffective double comparisons against constants.
-    ///
-    /// ### Why is this bad?
-    /// Only one of the comparisons has any effect on the result, the programmer
-    /// probably intended to flip one of the comparison operators, or compare a
-    /// different value entirely.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let status_code = 200;
-    /// if status_code <= 400 && status_code < 500 {}
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub REDUNDANT_COMPARISONS,
-    correctness,
-    "double comparisons where one of them can be removed"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calculation of subsecond microseconds or milliseconds
@@ -418,30 +317,6 @@
     "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for arguments to `==` which have their address
-    /// taken to satisfy a bound
-    /// and suggests to dereference the other argument instead
-    ///
-    /// ### Why is this bad?
-    /// It is more idiomatic to dereference the other argument.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// &x == y
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// x == *y
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OP_REF,
-    style,
-    "taking a reference to satisfy the type constraints on `==`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for erasing operations, e.g., `x * 0`.
@@ -466,109 +341,21 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
-    /// `(a - b) < f64::EPSILON`. Note the missing `.abs()`.
-    ///
-    /// ### Why is this bad?
-    /// The code without `.abs()` is more likely to have a bug.
-    ///
-    /// ### Known problems
-    /// If the user can ensure that b is larger than a, the `.abs()` is
-    /// technically unnecessary. However, it will make the code more robust and doesn't have any
-    /// large performance implications. If the abs call was deliberately left out for performance
-    /// reasons, it is probably better to state this explicitly in the code, which then can be done
-    /// with an allow.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b) < f32::EPSILON
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b).abs() < f32::EPSILON
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub FLOAT_EQUALITY_WITHOUT_ABS,
-    suspicious,
-    "float equality check without `.abs()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for identity operations, e.g., `x + 0`.
-    ///
-    /// ### Why is this bad?
-    /// This code can be removed without changing the
-    /// meaning. So it just obscures what's going on. Delete it mercilessly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = 1;
-    /// x / 1 + 0 * 1 - 0 | 0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub IDENTITY_OP,
-    complexity,
-    "using identity operations, e.g., `x + 0` or `y / 1`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for division of integers
+    /// Checks for float arithmetic.
     ///
     /// ### Why restrict this?
-    /// When outside of some very specific algorithms,
-    /// integer division is very often a mistake because it discards the
-    /// remainder.
+    /// For some embedded systems or kernel development, it
+    /// can be useful to rule out floating-point numbers.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = 3 / 2;
-    /// println!("{}", x);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x = 3f32 / 2f32;
-    /// println!("{}", x);
-    /// ```
-    #[clippy::version = "1.37.0"]
-    pub INTEGER_DIVISION,
-    restriction,
-    "integer division may cause loss of precision"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for conversions to owned values just for the sake
-    /// of a comparison.
-    ///
-    /// ### Why is this bad?
-    /// The comparison can operate on a reference, so creating
-    /// an owned value effectively throws it away directly afterwards, which is
-    /// needlessly consuming code and heap space.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x.to_owned() == y {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x == y {}
+    /// # let a = 0.0;
+    /// a + 1.0;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CMP_OWNED,
-    perf,
-    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
+    pub FLOAT_ARITHMETIC,
+    restriction,
+    "any floating-point arithmetic statement"
 }
 
 declare_clippy_lint! {
@@ -699,26 +486,291 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for getting the remainder of integer division by one or minus
-    /// one.
+    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
+    /// `(a - b) < f64::EPSILON`. Note the missing `.abs()`.
     ///
     /// ### Why is this bad?
-    /// The result for a divisor of one can only ever be zero; for
-    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
-    /// the respective integer type) or results in zero. No one will write such code
-    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
-    /// contest, it's probably a bad idea. Use something more underhanded.
+    /// The code without `.abs()` is more likely to have a bug.
+    ///
+    /// ### Known problems
+    /// If the user can ensure that b is larger than a, the `.abs()` is
+    /// technically unnecessary. However, it will make the code more robust and doesn't have any
+    /// large performance implications. If the abs call was deliberately left out for performance
+    /// reasons, it is probably better to state this explicitly in the code, which then can be done
+    /// with an allow.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b) < f32::EPSILON
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b).abs() < f32::EPSILON
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub FLOAT_EQUALITY_WITHOUT_ABS,
+    suspicious,
+    "float equality check without `.abs()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for identity operations, e.g., `x + 0`.
+    ///
+    /// ### Why is this bad?
+    /// This code can be removed without changing the
+    /// meaning. So it just obscures what's going on. Delete it mercilessly.
     ///
     /// ### Example
     /// ```no_run
     /// # let x = 1;
-    /// let a = x % 1;
-    /// let a = x % -1;
+    /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub MODULO_ONE,
+    pub IDENTITY_OP,
+    complexity,
+    "using identity operations, e.g., `x + 0` or `y / 1`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for double comparisons that can never succeed
+    ///
+    /// ### Why is this bad?
+    /// The whole expression can be replaced by `false`,
+    /// which is probably not the programmer's intention
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code > 500 {}
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub IMPOSSIBLE_COMPARISONS,
     correctness,
-    "taking an integer modulo +/-1, which can either panic/overflow or always returns 0"
+    "double comparisons that will never evaluate to `true`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bit masks in comparisons which can be removed
+    /// without changing the outcome. The basic structure can be seen in the
+    /// following table:
+    ///
+    /// |Comparison| Bit Op   |Example     |equals |
+    /// |----------|----------|------------|-------|
+    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
+    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
+    ///
+    /// ### Why is this bad?
+    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
+    /// but still a bit misleading, because the bit mask is ineffective.
+    ///
+    /// ### Known problems
+    /// False negatives: This lint will only match instances
+    /// where we have figured out the math (which is for a power-of-two compared
+    /// value). This means things like `x | 1 >= 7` (which would be better written
+    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
+    /// uncommon).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 1;
+    /// if (x | 1 > 3) {  }
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```no_run
+    /// # let x = 1;
+    /// if (x >= 2) {  }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INEFFECTIVE_BIT_MASK,
+    correctness,
+    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for division of integers
+    ///
+    /// ### Why restrict this?
+    /// When outside of some very specific algorithms,
+    /// integer division is very often a mistake because it discards the
+    /// remainder.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = 3 / 2;
+    /// println!("{}", x);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let x = 3f32 / 2f32;
+    /// println!("{}", x);
+    /// ```
+    #[clippy::version = "1.37.0"]
+    pub INTEGER_DIVISION,
+    restriction,
+    "integer division may cause loss of precision"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of division (`/`) and remainder (`%`) operations
+    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
+    ///
+    /// ### Why restrict this?
+    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
+    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let my_div = 10 / 2;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let my_div = 10 >> 1;
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub INTEGER_DIVISION_REMAINDER_USED,
+    restriction,
+    "use of disallowed default division and remainder operations"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for comparisons where the relation is always either
+    /// true or false, but where one side has been upcast so that the comparison is
+    /// necessary. Only integer types are checked.
+    ///
+    /// ### Why is this bad?
+    /// An expression like `let x : u8 = ...; (x as u32) > 300`
+    /// will mistakenly imply that it is possible for `x` to be outside the range of
+    /// `u8`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: u8 = 1;
+    /// (x as u32) > 300;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INVALID_UPCAST_COMPARISONS,
+    pedantic,
+    "a comparison involving an upcast which is always true or false"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an expression like `(x + (y - 1)) / y` which is a common manual reimplementation
+    /// of `x.div_ceil(y)`.
+    ///
+    /// ### Why is this bad?
+    /// It's simpler, clearer and more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: i32 = 7;
+    /// let y: i32 = 4;
+    /// let div = (x + (y - 1)) / y;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #![feature(int_roundings)]
+    /// let x: i32 = 7;
+    /// let y: i32 = 4;
+    /// let div = x.div_ceil(y);
+    /// ```
+    #[clippy::version = "1.83.0"]
+    pub MANUAL_DIV_CEIL,
+    complexity,
+    "manually reimplementing `div_ceil`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementation of `.is_multiple_of()` on
+    /// unsigned integer types.
+    ///
+    /// ### Why is this bad?
+    /// `a.is_multiple_of(b)` is a clearer way to check for divisibility
+    /// of `a` by `b`. This expression can never panic.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let (a, b) = (3u64, 4u64);
+    /// if a % b == 0 {
+    ///     println!("{a} is divisible by {b}");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let (a, b) = (3u64, 4u64);
+    /// if a.is_multiple_of(b) {
+    ///     println!("{a} is divisible by {b}");
+    /// }
+    /// ```
+    #[clippy::version = "1.90.0"]
+    pub MANUAL_IS_MULTIPLE_OF,
+    complexity,
+    "manual implementation of `.is_multiple_of()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementation of `midpoint`.
+    ///
+    /// ### Why is this bad?
+    /// Using `(x + y) / 2` might cause an overflow on the intermediate
+    /// addition result.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let a: u32 = 0;
+    /// let c = (a + 10) / 2;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let a: u32 = 0;
+    /// let c = u32::midpoint(a, 10);
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub MANUAL_MIDPOINT,
+    pedantic,
+    "manual implementation of `midpoint` which can overflow"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `a op= a op b` or `a op= b op a` patterns.
+    ///
+    /// ### Why is this bad?
+    /// Most likely these are bugs where one meant to write `a
+    /// op= b`.
+    ///
+    /// ### Known problems
+    /// Clippy cannot know for sure if `a op= a op b` should have
+    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
+    /// If `a op= a op b` is really the correct behavior it should be
+    /// written as `a = a op a op b` as it's less confusing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut a = 5;
+    /// let b = 2;
+    /// // ...
+    /// a += a + b;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MISREFACTORED_ASSIGN_OP,
+    suspicious,
+    "having a variable on both sides of an assign op"
 }
 
 declare_clippy_lint! {
@@ -743,6 +795,30 @@
     "any modulo arithmetic statement"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for getting the remainder of integer division by one or minus
+    /// one.
+    ///
+    /// ### Why is this bad?
+    /// The result for a divisor of one can only ever be zero; for
+    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
+    /// the respective integer type) or results in zero. No one will write such code
+    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
+    /// contest, it's probably a bad idea. Use something more underhanded.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 1;
+    /// let a = x % 1;
+    /// let a = x % -1;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULO_ONE,
+    correctness,
+    "taking an integer modulo +/-1, which can either panic/overflow or always returns 0"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of bitwise and/or operators between booleans, where performance may be improved by using
@@ -772,6 +848,50 @@
     "Boolean expressions that use bitwise rather than lazy operators"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arguments to `==` which have their address
+    /// taken to satisfy a bound
+    /// and suggests to dereference the other argument instead
+    ///
+    /// ### Why is this bad?
+    /// It is more idiomatic to dereference the other argument.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// &x == y
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// x == *y
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OP_REF,
+    style,
+    "taking a reference to satisfy the type constraints on `==`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ineffective double comparisons against constants.
+    ///
+    /// ### Why is this bad?
+    /// Only one of the comparisons has any effect on the result, the programmer
+    /// probably intended to flip one of the comparison operators, or compare a
+    /// different value entirely.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code < 500 {}
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub REDUNDANT_COMPARISONS,
+    correctness,
+    "double comparisons where one of them can be removed"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for explicit self-assignments.
@@ -813,150 +933,64 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual implementation of `midpoint`.
+    /// Checks for bit masks that can be replaced by a call
+    /// to `trailing_zeros`
     ///
     /// ### Why is this bad?
-    /// Using `(x + y) / 2` might cause an overflow on the intermediate
-    /// addition result.
+    /// `x.trailing_zeros() >= 4` is much clearer than `x & 15
+    /// == 0`
     ///
     /// ### Example
     /// ```no_run
-    /// # let a: u32 = 0;
-    /// let c = (a + 10) / 2;
+    /// # let x = 1;
+    /// if x & 0b1111 == 0 { }
     /// ```
+    ///
     /// Use instead:
-    /// ```no_run
-    /// # let a: u32 = 0;
-    /// let c = u32::midpoint(a, 10);
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub MANUAL_MIDPOINT,
-    pedantic,
-    "manual implementation of `midpoint` which can overflow"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementation of `.is_multiple_of()` on
-    /// unsigned integer types.
     ///
-    /// ### Why is this bad?
-    /// `a.is_multiple_of(b)` is a clearer way to check for divisibility
-    /// of `a` by `b`. This expression can never panic.
-    ///
-    /// ### Example
     /// ```no_run
-    /// # let (a, b) = (3u64, 4u64);
-    /// if a % b == 0 {
-    ///     println!("{a} is divisible by {b}");
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let (a, b) = (3u64, 4u64);
-    /// if a.is_multiple_of(b) {
-    ///     println!("{a} is divisible by {b}");
-    /// }
-    /// ```
-    #[clippy::version = "1.90.0"]
-    pub MANUAL_IS_MULTIPLE_OF,
-    complexity,
-    "manual implementation of `.is_multiple_of()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for an expression like `(x + (y - 1)) / y` which is a common manual reimplementation
-    /// of `x.div_ceil(y)`.
-    ///
-    /// ### Why is this bad?
-    /// It's simpler, clearer and more readable.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: i32 = 7;
-    /// let y: i32 = 4;
-    /// let div = (x + (y - 1)) / y;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #![feature(int_roundings)]
-    /// let x: i32 = 7;
-    /// let y: i32 = 4;
-    /// let div = x.div_ceil(y);
-    /// ```
-    #[clippy::version = "1.83.0"]
-    pub MANUAL_DIV_CEIL,
-    complexity,
-    "manually reimplementing `div_ceil`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for comparisons where the relation is always either
-    /// true or false, but where one side has been upcast so that the comparison is
-    /// necessary. Only integer types are checked.
-    ///
-    /// ### Why is this bad?
-    /// An expression like `let x : u8 = ...; (x as u32) > 300`
-    /// will mistakenly imply that it is possible for `x` to be outside the range of
-    /// `u8`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: u8 = 1;
-    /// (x as u32) > 300;
+    /// # let x: i32 = 1;
+    /// if x.trailing_zeros() >= 4 { }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub INVALID_UPCAST_COMPARISONS,
+    pub VERBOSE_BIT_MASK,
     pedantic,
-    "a comparison involving an upcast which is always true or false"
+    "expressions where a bit mask is less readable than the corresponding method call"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of division (`/`) and remainder (`%`) operations
-    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
-    ///
-    /// ### Why restrict this?
-    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
-    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let my_div = 10 / 2;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let my_div = 10 >> 1;
-    /// ```
-    #[clippy::version = "1.79.0"]
-    pub INTEGER_DIVISION_REMAINDER_USED,
-    restriction,
-    "use of disallowed default division and remainder operations"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for decimal literals used as bit masks in bitwise operations.
-    ///
-    /// ### Why is this bad?
-    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
-    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// let a = 14 & 6; // Bit pattern is not immediately clear
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    /// let a = 0b1110 & 0b0110;
-    /// ```
-    #[clippy::version = "1.93.0"]
-    pub DECIMAL_BITWISE_OPERANDS,
-    pedantic,
-    "use binary, hex, or octal literals for bitwise operations"
-}
+impl_lint_pass!(Operators => [
+    ABSURD_EXTREME_COMPARISONS,
+    ARITHMETIC_SIDE_EFFECTS,
+    ASSIGN_OP_PATTERN,
+    BAD_BIT_MASK,
+    CMP_OWNED,
+    DECIMAL_BITWISE_OPERANDS,
+    DOUBLE_COMPARISONS,
+    DURATION_SUBSEC,
+    EQ_OP,
+    ERASING_OP,
+    FLOAT_ARITHMETIC,
+    FLOAT_CMP,
+    FLOAT_CMP_CONST,
+    FLOAT_EQUALITY_WITHOUT_ABS,
+    IDENTITY_OP,
+    IMPOSSIBLE_COMPARISONS,
+    INEFFECTIVE_BIT_MASK,
+    INTEGER_DIVISION,
+    INTEGER_DIVISION_REMAINDER_USED,
+    INVALID_UPCAST_COMPARISONS,
+    MANUAL_DIV_CEIL,
+    MANUAL_IS_MULTIPLE_OF,
+    MANUAL_MIDPOINT,
+    MISREFACTORED_ASSIGN_OP,
+    MODULO_ARITHMETIC,
+    MODULO_ONE,
+    NEEDLESS_BITWISE_BOOL,
+    OP_REF,
+    REDUNDANT_COMPARISONS,
+    SELF_ASSIGNMENT,
+    VERBOSE_BIT_MASK,
+]);
 
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
@@ -976,40 +1010,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Operators => [
-    ABSURD_EXTREME_COMPARISONS,
-    ARITHMETIC_SIDE_EFFECTS,
-    FLOAT_ARITHMETIC,
-    ASSIGN_OP_PATTERN,
-    MISREFACTORED_ASSIGN_OP,
-    BAD_BIT_MASK,
-    INEFFECTIVE_BIT_MASK,
-    VERBOSE_BIT_MASK,
-    DOUBLE_COMPARISONS,
-    IMPOSSIBLE_COMPARISONS,
-    REDUNDANT_COMPARISONS,
-    DURATION_SUBSEC,
-    EQ_OP,
-    OP_REF,
-    ERASING_OP,
-    FLOAT_EQUALITY_WITHOUT_ABS,
-    IDENTITY_OP,
-    INTEGER_DIVISION,
-    INTEGER_DIVISION_REMAINDER_USED,
-    CMP_OWNED,
-    FLOAT_CMP,
-    FLOAT_CMP_CONST,
-    MODULO_ONE,
-    MODULO_ARITHMETIC,
-    NEEDLESS_BITWISE_BOOL,
-    SELF_ASSIGNMENT,
-    MANUAL_MIDPOINT,
-    MANUAL_IS_MULTIPLE_OF,
-    MANUAL_DIV_CEIL,
-    INVALID_UPCAST_COMPARISONS,
-    DECIMAL_BITWISE_OPERANDS
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         eq_op::check_assert(cx, e);
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 57127e9d2298..cc147a4a84bd 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -40,7 +40,7 @@
     "functions of type `Result<..>` that contain `panic!()` or assertion"
 }
 
-declare_lint_pass!(PanicInResultFn  => [PANIC_IN_RESULT_FN]);
+declare_lint_pass!(PanicInResultFn => [PANIC_IN_RESULT_FN]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
     fn check_fn(
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index cfe2513521eb..a5cb5cf3f5e3 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -36,23 +36,6 @@ pub fn new(conf: &'static Conf) -> Self {
     "usage of the `panic!` macro"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `unimplemented!`.
-    ///
-    /// ### Why restrict this?
-    /// This macro, or panics in general, may be unwanted in production code.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// unimplemented!();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNIMPLEMENTED,
-    restriction,
-    "`unimplemented!` should not be present in production code"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `todo!`.
@@ -75,6 +58,23 @@ pub fn new(conf: &'static Conf) -> Self {
     "`todo!` should not be present in production code"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `unimplemented!`.
+    ///
+    /// ### Why restrict this?
+    /// This macro, or panics in general, may be unwanted in production code.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// unimplemented!();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub UNIMPLEMENTED,
+    restriction,
+    "`unimplemented!` should not be present in production code"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `unreachable!`.
@@ -92,7 +92,7 @@ pub fn new(conf: &'static Conf) -> Self {
     "usage of the `unreachable!` macro"
 }
 
-impl_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANIC]);
+impl_lint_pass!(PanicUnimplemented => [PANIC, TODO, UNIMPLEMENTED, UNREACHABLE]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 65e93af9420d..4428e07f7995 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -37,6 +37,7 @@
     restriction,
     "partial fields of a struct are public"
 }
+
 declare_lint_pass!(PartialPubFields => [PARTIAL_PUB_FIELDS]);
 
 impl EarlyLintPass for PartialPubFields {
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 44217ac2c4fc..72d2fdeda21c 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -37,6 +37,7 @@
     style,
     "Binary comparison to `Option<T>::None` relies on `T: PartialEq`, which is unneeded"
 }
+
 declare_lint_pass!(PartialeqToNone => [PARTIALEQ_TO_NONE]);
 
 impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 666476cb4bac..6cb57b1d3b36 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -20,6 +20,39 @@
 use rustc_span::{Span, sym};
 use std::iter;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions taking arguments by value, where
+    /// the argument type is `Copy` and large enough to be worth considering
+    /// passing by reference. Does not trigger if the function is being exported,
+    /// because that might induce API breakage, if the parameter is declared as mutable,
+    /// or if the argument is a `self`.
+    ///
+    /// ### Why is this bad?
+    /// Arguments passed by value might result in an unnecessary
+    /// shallow copy, taking up more space in the stack and requiring a call to
+    /// `memcpy`, which can be expensive.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[derive(Clone, Copy)]
+    /// struct TooLarge([u8; 2048]);
+    ///
+    /// fn foo(v: TooLarge) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # #[derive(Clone, Copy)]
+    /// # struct TooLarge([u8; 2048]);
+    /// fn foo(v: &TooLarge) {}
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub LARGE_TYPES_PASSED_BY_VALUE,
+    pedantic,
+    "functions taking large arguments by value"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for functions taking arguments by reference, where
@@ -68,38 +101,10 @@
     "functions taking small copyable arguments by reference"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for functions taking arguments by value, where
-    /// the argument type is `Copy` and large enough to be worth considering
-    /// passing by reference. Does not trigger if the function is being exported,
-    /// because that might induce API breakage, if the parameter is declared as mutable,
-    /// or if the argument is a `self`.
-    ///
-    /// ### Why is this bad?
-    /// Arguments passed by value might result in an unnecessary
-    /// shallow copy, taking up more space in the stack and requiring a call to
-    /// `memcpy`, which can be expensive.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[derive(Clone, Copy)]
-    /// struct TooLarge([u8; 2048]);
-    ///
-    /// fn foo(v: TooLarge) {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # #[derive(Clone, Copy)]
-    /// # struct TooLarge([u8; 2048]);
-    /// fn foo(v: &TooLarge) {}
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub LARGE_TYPES_PASSED_BY_VALUE,
-    pedantic,
-    "functions taking large arguments by value"
-}
+impl_lint_pass!(PassByRefOrValue => [
+    LARGE_TYPES_PASSED_BY_VALUE,
+    TRIVIALLY_COPY_PASS_BY_REF,
+]);
 
 pub struct PassByRefOrValue {
     ref_min_size: u64,
@@ -237,8 +242,6 @@ fn check_poly_fn(&self, cx: &LateContext<'_>, def_id: LocalDefId, decl: &FnDecl<
     }
 }
 
-impl_lint_pass!(PassByRefOrValue => [TRIVIALLY_COPY_PASS_BY_REF, LARGE_TYPES_PASSED_BY_VALUE]);
-
 impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         if item.span.from_expansion() {
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index 68a34d459e0d..a888ee546294 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -26,7 +26,10 @@
     suspicious,
     "Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`"
 }
-declare_lint_pass!(PermissionsSetReadonlyFalse => [PERMISSIONS_SET_READONLY_FALSE]);
+
+declare_lint_pass!(PermissionsSetReadonlyFalse => [
+    PERMISSIONS_SET_READONLY_FALSE,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
diff --git a/clippy_lints/src/ptr/mod.rs b/clippy_lints/src/ptr/mod.rs
index c4f40a7ffcaa..f1e422d436bd 100644
--- a/clippy_lints/src/ptr/mod.rs
+++ b/clippy_lints/src/ptr/mod.rs
@@ -7,42 +7,6 @@
 mod ptr_arg;
 mod ptr_eq;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint checks for function arguments of type `&String`, `&Vec`,
-    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
-    /// with the appropriate `.to_owned()`/`to_string()` calls.
-    ///
-    /// ### Why is this bad?
-    /// Requiring the argument to be of the specific type
-    /// makes the function less useful for no benefit; slices in the form of `&[T]`
-    /// or `&str` usually suffice and can be obtained from other types, too.
-    ///
-    /// ### Known problems
-    /// There may be `fn(&Vec)`-typed references pointing to your function.
-    /// If you have them, you will get a compiler error after applying this lint's
-    /// suggestions. You then have the choice to undo your changes or change the
-    /// type of the reference.
-    ///
-    /// Note that if the function is part of your public interface, there may be
-    /// other crates referencing it, of which you may not be aware. Carefully
-    /// deprecate the function before applying the lint suggestions in this case.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// fn foo(&Vec<u32>) { .. }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// fn foo(&[u32]) { .. }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub PTR_ARG,
-    style,
-    "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// This lint checks for equality comparisons with `ptr::null` or `ptr::null_mut`
@@ -106,6 +70,42 @@
     "fns that create mutable refs from immutable ref args"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint checks for function arguments of type `&String`, `&Vec`,
+    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
+    /// with the appropriate `.to_owned()`/`to_string()` calls.
+    ///
+    /// ### Why is this bad?
+    /// Requiring the argument to be of the specific type
+    /// makes the function less useful for no benefit; slices in the form of `&[T]`
+    /// or `&str` usually suffice and can be obtained from other types, too.
+    ///
+    /// ### Known problems
+    /// There may be `fn(&Vec)`-typed references pointing to your function.
+    /// If you have them, you will get a compiler error after applying this lint's
+    /// suggestions. You then have the choice to undo your changes or change the
+    /// type of the reference.
+    ///
+    /// Note that if the function is part of your public interface, there may be
+    /// other crates referencing it, of which you may not be aware. Carefully
+    /// deprecate the function before applying the lint suggestions in this case.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// fn foo(&Vec<u32>) { .. }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// fn foo(&[u32]) { .. }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub PTR_ARG,
+    style,
+    "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Use `std::ptr::eq` when applicable
@@ -135,7 +135,7 @@
     "use `std::ptr::eq` when comparing raw pointers"
 }
 
-declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, PTR_EQ]);
+declare_lint_pass!(Ptr => [CMP_NULL, MUT_FROM_REF, PTR_ARG, PTR_EQ]);
 
 impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
index 694d44d70856..64724f7d01d0 100644
--- a/clippy_lints/src/pub_underscore_fields.rs
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -42,11 +42,11 @@
     "struct field prefixed with underscore and marked public"
 }
 
+impl_lint_pass!(PubUnderscoreFields => [PUB_UNDERSCORE_FIELDS]);
+
 pub struct PubUnderscoreFields {
     behavior: PubUnderscoreFieldsBehaviour,
 }
-impl_lint_pass!(PubUnderscoreFields => [PUB_UNDERSCORE_FIELDS]);
-
 impl PubUnderscoreFields {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index 5b973a79eae3..f3d6ed268bda 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -35,6 +35,7 @@
     restriction,
     "restricts the usage of `pub use`"
 }
+
 declare_lint_pass!(PubUse => [PUB_USE]);
 
 impl EarlyLintPass for PubUse {
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 719f364357d3..e79ce91d8b32 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -51,6 +51,8 @@
     "checks for expressions that could be replaced by the `?` operator"
 }
 
+impl_lint_pass!(QuestionMark => [MANUAL_LET_ELSE, QUESTION_MARK]);
+
 pub struct QuestionMark {
     pub(crate) msrv: Msrv,
     pub(crate) matches_behaviour: MatchLintBehaviour,
@@ -65,8 +67,6 @@ pub struct QuestionMark {
     inferred_ret_closure_stack: u16,
 }
 
-impl_lint_pass!(QuestionMark => [QUESTION_MARK, MANUAL_LET_ELSE]);
-
 impl QuestionMark {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index bed50918192e..61087ad88457 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -18,6 +18,71 @@
 use rustc_span::{DesugaringKind, Span};
 use std::cmp::Ordering;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions like `x >= 3 && x < 8` that could
+    /// be more readably expressed as `(3..8).contains(x)`.
+    ///
+    /// ### Why is this bad?
+    /// `contains` expresses the intent better and has less
+    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // given
+    /// let x = 6;
+    ///
+    /// assert!(x >= 3 && x < 8);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    ///# let x = 6;
+    /// assert!((3..8).contains(&x));
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_RANGE_CONTAINS,
+    style,
+    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for inclusive ranges where 1 is subtracted from
+    /// the upper bound, e.g., `x..=(y-1)`.
+    ///
+    /// ### Why is this bad?
+    /// The code is more readable with an exclusive range
+    /// like `x..y`.
+    ///
+    /// ### Limitations
+    /// The lint is conservative and will trigger only when switching
+    /// from an inclusive to an exclusive range is provably safe from
+    /// a typing point of view. This corresponds to situations where
+    /// the range is used as an iterator, or for indexing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..=(y-1) {
+    ///     // ..
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..y {
+    ///     // ..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub RANGE_MINUS_ONE,
+    pedantic,
+    "`x..=(y-1)` reads better as `x..y`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for exclusive ranges where 1 is added to the
@@ -66,44 +131,6 @@
     "`x..(y+1)` reads better as `x..=y`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for inclusive ranges where 1 is subtracted from
-    /// the upper bound, e.g., `x..=(y-1)`.
-    ///
-    /// ### Why is this bad?
-    /// The code is more readable with an exclusive range
-    /// like `x..y`.
-    ///
-    /// ### Limitations
-    /// The lint is conservative and will trigger only when switching
-    /// from an inclusive to an exclusive range is provably safe from
-    /// a typing point of view. This corresponds to situations where
-    /// the range is used as an iterator, or for indexing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = 0;
-    /// # let y = 1;
-    /// for i in x..=(y-1) {
-    ///     // ..
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = 0;
-    /// # let y = 1;
-    /// for i in x..y {
-    ///     // ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub RANGE_MINUS_ONE,
-    pedantic,
-    "`x..=(y-1)` reads better as `x..y`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for range expressions `x..y` where both `x` and `y`
@@ -137,32 +164,12 @@
     "reversing the limits of range expressions, resulting in empty ranges"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for expressions like `x >= 3 && x < 8` that could
-    /// be more readably expressed as `(3..8).contains(x)`.
-    ///
-    /// ### Why is this bad?
-    /// `contains` expresses the intent better and has less
-    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // given
-    /// let x = 6;
-    ///
-    /// assert!(x >= 3 && x < 8);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    ///# let x = 6;
-    /// assert!((3..8).contains(&x));
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_RANGE_CONTAINS,
-    style,
-    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
-}
+impl_lint_pass!(Ranges => [
+    MANUAL_RANGE_CONTAINS,
+    RANGE_MINUS_ONE,
+    RANGE_PLUS_ONE,
+    REVERSED_EMPTY_RANGES,
+]);
 
 pub struct Ranges {
     msrv: Msrv,
@@ -174,13 +181,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(Ranges => [
-    RANGE_PLUS_ONE,
-    RANGE_MINUS_ONE,
-    REVERSED_EMPTY_RANGES,
-    MANUAL_RANGE_CONTAINS,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, l, r) = expr.kind
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 63b9a38eef1e..7f08fe0daca4 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -10,6 +10,28 @@
 use std::iter::once;
 use std::ops::ControlFlow;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals with an unnecessary amount of hashes around them.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
+    /// necessary.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let r = r###"Hello, "world"!"###;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let r = r#"Hello, "world"!"#;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING_HASHES,
+    pedantic,
+    "suggests reducing the number of hashes around a raw string literal"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for raw string literals where a string literal can be used instead.
@@ -33,27 +55,7 @@
     restriction,
     "suggests using a string literal when a raw string literal is unnecessary"
 }
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for raw string literals with an unnecessary amount of hashes around them.
-    ///
-    /// ### Why is this bad?
-    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
-    /// necessary.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let r = r###"Hello, "world"!"###;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let r = r#"Hello, "world"!"#;
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRING_HASHES,
-    pedantic,
-    "suggests reducing the number of hashes around a raw string literal"
-}
+
 impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRINGS, NEEDLESS_RAW_STRING_HASHES]);
 
 pub struct RawStrings {
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 689a2ac4c6ae..e3f718cb2d7d 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -45,6 +45,7 @@
     suspicious,
     "initializing reference-counted pointer in `vec![elem; len]`"
 }
+
 declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);
 
 impl LateLintPass<'_> for RcCloneInVecInit {
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index b8d4e7c4651d..6d8b26d93f83 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -46,6 +46,7 @@
     nursery,
     "checks for reads into a zero-length `Vec`"
 }
+
 declare_lint_pass!(ReadZeroByteVec => [READ_ZERO_BYTE_VEC]);
 
 impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index d2442ad0f373..386bf3cf90fd 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -36,6 +36,7 @@
     complexity,
     "`async { future.await }` can be replaced by `future`"
 }
+
 declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 7a2772f1d5e7..d2d9e1642d44 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::{fn_has_unsatisfiable_preds, sym};
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 use clippy_utils::res::MaybeDef;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::{has_drop, is_copy, peel_and_count_ty_refs};
+use clippy_utils::{fn_has_unsatisfiable_preds, sym};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -368,25 +368,25 @@ struct CloneUsage {
 }
 
 fn visit_clone_usage(cloned: mir::Local, clone: mir::Local, mir: &mir::Body<'_>, bb: mir::BasicBlock) -> CloneUsage {
-    if let Some((
-        LocalUsage {
-            local_use_locs: cloned_use_locs,
-            local_consume_or_mutate_locs: cloned_consume_or_mutate_locs,
-        },
-        LocalUsage {
-            local_use_locs: _,
-            local_consume_or_mutate_locs: clone_consume_or_mutate_locs,
-        },
-    )) = visit_local_usage(
-        &[cloned, clone],
+    if let Some(
+        [
+            LocalUsage {
+                local_use_locs: cloned_use_locs,
+                local_consume_or_mutate_locs: cloned_consume_or_mutate_locs,
+            },
+            LocalUsage {
+                local_use_locs: _,
+                local_consume_or_mutate_locs: clone_consume_or_mutate_locs,
+            },
+        ],
+    ) = visit_local_usage(
+        [cloned, clone],
         mir,
         mir::Location {
             block: bb,
             statement_index: mir.basic_blocks[bb].statements.len(),
         },
-    )
-    .map(|mut vec| (vec.remove(0), vec.remove(0)))
-    {
+    ) {
         CloneUsage {
             cloned_use_loc: cloned_use_locs.first().copied().into(),
             cloned_consume_or_mutate_loc: cloned_consume_or_mutate_locs.first().copied(),
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index feefe10f57d7..10793ccca97f 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -35,6 +35,8 @@
     "checks for fields in struct literals where shorthands could be used"
 }
 
+impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
+
 pub struct RedundantFieldNames {
     msrv: MsrvStack,
 }
@@ -47,8 +49,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
-
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if !self.msrv.meets(msrvs::FIELD_INIT_SHORTHAND) {
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 8f33a47e2908..13bd05511ec3 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -43,6 +43,7 @@
     suspicious,
     "redundant redefinition of a local binding"
 }
+
 declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 0c1c664f1117..7ebf7ccb7571 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -36,13 +36,13 @@
     "Using `pub(crate)` visibility on items that are not crate visible due to the visibility of the module that contains them."
 }
 
+impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
+
 #[derive(Default)]
 pub struct RedundantPubCrate {
     is_exported: Vec<bool>,
 }
 
-impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
-
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if cx.tcx.visibility(item.owner_id.def_id) == ty::Visibility::Restricted(CRATE_DEF_ID.to_def_id())
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index f2cf809d6012..1637156d7c37 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -11,6 +11,30 @@
 use rustc_middle::ty::{GenericArg, Ty};
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for slicing expressions which are equivalent to dereferencing the
+    /// value.
+    ///
+    /// ### Why restrict this?
+    /// Some people may prefer to dereference rather than slice.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &vec[..];
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &*vec;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub DEREF_BY_SLICING,
+    restriction,
+    "slicing instead of dereferencing"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for redundant slicing expressions which use the full range, and
@@ -42,31 +66,7 @@
     "redundant slicing of the whole range of a type"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for slicing expressions which are equivalent to dereferencing the
-    /// value.
-    ///
-    /// ### Why restrict this?
-    /// Some people may prefer to dereference rather than slice.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![1, 2, 3];
-    /// let slice = &vec[..];
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let vec = vec![1, 2, 3];
-    /// let slice = &*vec;
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub DEREF_BY_SLICING,
-    restriction,
-    "slicing instead of dereferencing"
-}
-
-declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING, DEREF_BY_SLICING]);
+declare_lint_pass!(RedundantSlicing => [DEREF_BY_SLICING, REDUNDANT_SLICING]);
 
 static REDUNDANT_SLICING_LINT: (&Lint, &str) = (REDUNDANT_SLICING, "redundant slicing of the whole range");
 static DEREF_BY_SLICING_LINT: (&Lint, &str) = (DEREF_BY_SLICING, "slicing when dereferencing would work");
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index da85125730a8..35cfc37b133b 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -34,6 +34,8 @@
     "Using explicit `'static` lifetime for constants or statics when elision rules would allow omitting them."
 }
 
+impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
+
 pub struct RedundantStaticLifetimes {
     msrv: MsrvStack,
 }
@@ -46,8 +48,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
-
 impl RedundantStaticLifetimes {
     // Recursively visit types
     fn visit_type(ty: &Ty, cx: &EarlyContext<'_>, reason: &'static str) {
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index e298fa55a2b6..3ffb00e2ee9d 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -36,6 +36,7 @@
     restriction,
     "warns about needless / redundant type annotations."
 }
+
 declare_lint_pass!(RedundantTypeAnnotations => [REDUNDANT_TYPE_ANNOTATIONS]);
 
 fn is_same_type<'tcx>(cx: &LateContext<'tcx>, ty_resolved_path: hir::def::Res, func_return_type: Ty<'tcx>) -> bool {
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index 002c6c41d52b..b6a28571230a 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -26,6 +26,7 @@
     restriction,
     "use of a ref pattern, e.g. Some(ref value)"
 }
+
 declare_lint_pass!(RefPatterns => [REF_PATTERNS]);
 
 impl EarlyLintPass for RefPatterns {
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index d1fc228f4b35..80696f0a81b1 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -37,36 +37,6 @@
     "invalid regular expressions"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for trivial [regex](https://crates.io/crates/regex)
-    /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
-    ///
-    /// ### Why is this bad?
-    /// Matching the regex can likely be replaced by `==` or
-    /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
-    /// methods.
-    ///
-    /// ### Known problems
-    /// If the same regex is going to be applied to multiple
-    /// inputs, the precomputations done by `Regex` construction can give
-    /// significantly better performance than any of the `str`-based methods.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// Regex::new("^foobar")
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// str::starts_with("foobar")
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRIVIAL_REGEX,
-    nursery,
-    "trivial regular expressions"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     ///
@@ -105,6 +75,38 @@
     "regular expression compilation performed in a loop"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for trivial [regex](https://crates.io/crates/regex)
+    /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
+    ///
+    /// ### Why is this bad?
+    /// Matching the regex can likely be replaced by `==` or
+    /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
+    /// methods.
+    ///
+    /// ### Known problems
+    /// If the same regex is going to be applied to multiple
+    /// inputs, the precomputations done by `Regex` construction can give
+    /// significantly better performance than any of the `str`-based methods.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// Regex::new("^foobar")
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// str::starts_with("foobar")
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRIVIAL_REGEX,
+    nursery,
+    "trivial regular expressions"
+}
+
+impl_lint_pass!(Regex => [INVALID_REGEX, REGEX_CREATION_IN_LOOPS, TRIVIAL_REGEX]);
+
 #[derive(Copy, Clone)]
 enum RegexKind {
     Unicode,
@@ -119,8 +121,6 @@ pub struct Regex {
     loop_stack: Vec<(OwnerId, Span)>,
 }
 
-impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX, REGEX_CREATION_IN_LOOPS]);
-
 impl<'tcx> LateLintPass<'tcx> for Regex {
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
         let mut resolve = |path: &PathLookup, kind: RegexKind| {
diff --git a/clippy_lints/src/replace_box.rs b/clippy_lints/src/replace_box.rs
index 638f6dc1532b..7b743746df2c 100644
--- a/clippy_lints/src/replace_box.rs
+++ b/clippy_lints/src/replace_box.rs
@@ -40,6 +40,8 @@
     "assigning a newly created box to `Box<T>` is inefficient"
 }
 
+impl_lint_pass!(ReplaceBox => [REPLACE_BOX]);
+
 #[derive(Default)]
 pub struct ReplaceBox {
     consumed_locals: FxHashSet<HirId>,
@@ -67,8 +69,6 @@ fn get_consumed_locals(&mut self, cx: &LateContext<'_>) -> &FxHashSet<HirId> {
     }
 }
 
-impl_lint_pass!(ReplaceBox => [REPLACE_BOX]);
-
 impl LateLintPass<'_> for ReplaceBox {
     fn check_body_post(&mut self, _: &LateContext<'_>, body: &Body<'_>) {
         if self.loaded_bodies.first().is_some_and(|&x| x == body.id()) {
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index ce86a9caac75..b5503f6cdfb0 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -31,6 +31,7 @@
     complexity,
     "`reserve` called immediately after `Vec` creation"
 }
+
 impl_lint_pass!(ReserveAfterInitialization => [RESERVE_AFTER_INITIALIZATION]);
 
 #[derive(Default)]
diff --git a/clippy_lints/src/returns/mod.rs b/clippy_lints/src/returns/mod.rs
index 47c6332b9b81..eb84582593a4 100644
--- a/clippy_lints/src/returns/mod.rs
+++ b/clippy_lints/src/returns/mod.rs
@@ -115,7 +115,11 @@
     "using a return statement like `return Err(expr)?;` where removing it would suffice"
 }
 
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
+declare_lint_pass!(Return => [
+    LET_AND_RETURN,
+    NEEDLESS_RETURN,
+    NEEDLESS_RETURN_WITH_QUESTION_MARK,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
diff --git a/clippy_lints/src/same_length_and_capacity.rs b/clippy_lints/src/same_length_and_capacity.rs
index 042dec35f7c9..b200fd1fe25f 100644
--- a/clippy_lints/src/same_length_and_capacity.rs
+++ b/clippy_lints/src/same_length_and_capacity.rs
@@ -70,6 +70,7 @@
     pedantic,
     "`from_raw_parts` with same length and capacity"
 }
+
 declare_lint_pass!(SameLengthAndCapacity => [SAME_LENGTH_AND_CAPACITY]);
 
 impl<'tcx> LateLintPass<'tcx> for SameLengthAndCapacity {
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 371d62a06849..7c68762b22c0 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -36,6 +36,7 @@
     restriction,
     "add a semicolon inside the block"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     ///
@@ -64,6 +65,7 @@
     restriction,
     "add a semicolon outside the block"
 }
+
 impl_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
 
 pub struct SemicolonBlock {
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f6083394fea5..4fa22ff0cdb5 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -15,33 +15,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, Symbol};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for bindings that shadow other bindings already in
-    /// scope, while just changing reference level or mutability.
-    ///
-    /// ### Why restrict this?
-    /// To require that what are formally distinct variables be given distinct names.
-    ///
-    /// See also `shadow_reuse` and `shadow_unrelated` for other restrictions on shadowing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = 1;
-    /// let x = &x;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = 1;
-    /// let y = &x; // use different variable name
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SHADOW_SAME,
-    restriction,
-    "rebinding a name to itself, e.g., `let mut x = &mut x`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for bindings that shadow other bindings already in
@@ -70,6 +43,33 @@
     "rebinding a name to an expression that reuses the original value, e.g., `let x = x + 1`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bindings that shadow other bindings already in
+    /// scope, while just changing reference level or mutability.
+    ///
+    /// ### Why restrict this?
+    /// To require that what are formally distinct variables be given distinct names.
+    ///
+    /// See also `shadow_reuse` and `shadow_unrelated` for other restrictions on shadowing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 1;
+    /// let x = &x;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = 1;
+    /// let y = &x; // use different variable name
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SHADOW_SAME,
+    restriction,
+    "rebinding a name to itself, e.g., `let mut x = &mut x`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for bindings that shadow other bindings already in
@@ -106,13 +106,13 @@
     "rebinding a name without even using the original value"
 }
 
+impl_lint_pass!(Shadow => [SHADOW_REUSE, SHADOW_SAME, SHADOW_UNRELATED]);
+
 #[derive(Default)]
 pub(crate) struct Shadow {
     bindings: Vec<(FxHashMap<Symbol, Vec<ItemLocalId>>, LocalDefId)>,
 }
 
-impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
-
 impl<'tcx> LateLintPass<'tcx> for Shadow {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         let PatKind::Binding(_, id, ident, _) = pat.kind else {
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 64891743dc63..4adcc1cac123 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -58,6 +58,7 @@
     restriction,
     "checks for functions that are only used once"
 }
+
 impl_lint_pass!(SingleCallFn => [SINGLE_CALL_FN]);
 
 #[derive(Debug, Clone)]
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 07a8eb5d886c..36ea341a87bc 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -37,6 +37,8 @@
     "imports with single component path are redundant"
 }
 
+impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
+
 #[derive(Default)]
 pub struct SingleComponentPathImports {
     /// Buffer found usages to emit when visiting that item so that `#[allow]` works as expected
@@ -50,8 +52,6 @@ struct SingleUse {
     can_suggest: bool,
 }
 
-impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
-
 impl EarlyLintPass for SingleComponentPathImports {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
         if cx.sess().opts.edition < Edition::Edition2018 {
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index e4906eb0c777..a9e90dec5dc9 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -37,6 +37,7 @@
     suspicious,
     "checks for initialization of `Vec` or arrays which consist of a single range"
 }
+
 declare_lint_pass!(SingleRangeInVecInit => [SINGLE_RANGE_IN_VEC_INIT]);
 
 enum SuggestedType {
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 3e48f0bc5037..0e78cf277c64 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -52,6 +52,7 @@
     suspicious,
     "Argument to `size_of_val()` is a double-reference, which is almost certainly unintended"
 }
+
 declare_lint_pass!(SizeOfRef => [SIZE_OF_REF]);
 
 impl LateLintPass<'_> for SizeOfRef {
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 143be5137038..d519afba61b5 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -11,53 +11,6 @@
 use rustc_span::symbol::kw;
 use rustc_span::{Span, sym};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds items imported through `std` when available through `core`.
-    ///
-    /// ### Why restrict this?
-    /// Crates which have `no_std` compatibility may wish to ensure types are imported from core to ensure
-    /// disabling `std` does not cause the crate to fail to compile. This lint is also useful for crates
-    /// migrating to become `no_std` compatible.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::hash::Hasher;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use core::hash::Hasher;
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub STD_INSTEAD_OF_CORE,
-    restriction,
-    "type is imported from std when available in core"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds items imported through `std` when available through `alloc`.
-    ///
-    /// ### Why restrict this?
-    /// Crates which have `no_std` compatibility and require alloc may wish to ensure types are imported from
-    /// alloc to ensure disabling `std` does not cause the crate to fail to compile. This lint is also useful
-    /// for crates migrating to become `no_std` compatible.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::vec::Vec;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # extern crate alloc;
-    /// use alloc::vec::Vec;
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub STD_INSTEAD_OF_ALLOC,
-    restriction,
-    "type is imported from std when available in alloc"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Finds items imported through `alloc` when available through `core`.
@@ -86,6 +39,59 @@
     "type is imported from alloc when available in core"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds items imported through `std` when available through `alloc`.
+    ///
+    /// ### Why restrict this?
+    /// Crates which have `no_std` compatibility and require alloc may wish to ensure types are imported from
+    /// alloc to ensure disabling `std` does not cause the crate to fail to compile. This lint is also useful
+    /// for crates migrating to become `no_std` compatible.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::vec::Vec;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # extern crate alloc;
+    /// use alloc::vec::Vec;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub STD_INSTEAD_OF_ALLOC,
+    restriction,
+    "type is imported from std when available in alloc"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds items imported through `std` when available through `core`.
+    ///
+    /// ### Why restrict this?
+    /// Crates which have `no_std` compatibility may wish to ensure types are imported from core to ensure
+    /// disabling `std` does not cause the crate to fail to compile. This lint is also useful for crates
+    /// migrating to become `no_std` compatible.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::hash::Hasher;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use core::hash::Hasher;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub STD_INSTEAD_OF_CORE,
+    restriction,
+    "type is imported from std when available in core"
+}
+
+impl_lint_pass!(StdReexports => [
+    ALLOC_INSTEAD_OF_CORE,
+    STD_INSTEAD_OF_ALLOC,
+    STD_INSTEAD_OF_CORE,
+]);
+
 pub struct StdReexports {
     lint_points: Option<(Span, Vec<LintPoint>)>,
     msrv: Msrv,
@@ -109,8 +115,6 @@ fn lint_if_finish(&mut self, cx: &LateContext<'_>, krate: Span, lint_point: Lint
     }
 }
 
-impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
-
 #[derive(Debug)]
 enum LintPoint {
     Available(Span, &'static Lint, &'static str, &'static str),
diff --git a/clippy_lints/src/string_patterns.rs b/clippy_lints/src/string_patterns.rs
index e5347bf3e8f0..3528fa36e2d1 100644
--- a/clippy_lints/src/string_patterns.rs
+++ b/clippy_lints/src/string_patterns.rs
@@ -72,6 +72,11 @@
     "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
 }
 
+impl_lint_pass!(StringPatterns => [
+    MANUAL_PATTERN_CHAR_COMPARISON,
+    SINGLE_CHAR_PATTERN,
+]);
+
 pub struct StringPatterns {
     msrv: Msrv,
 }
@@ -82,8 +87,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(StringPatterns => [MANUAL_PATTERN_CHAR_COMPARISON, SINGLE_CHAR_PATTERN]);
-
 const PATTERN_METHODS: [(Symbol, usize); 22] = [
     (sym::contains, 0),
     (sym::starts_with, 0),
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 9d3e4a6b1d92..ab11c37b5041 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -15,26 +15,25 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for string appends of the form `x = x + y` (without
-    /// `let`!).
+    /// This lint checks for `.to_string()` method calls on values of type `&str`.
     ///
-    /// ### Why is this bad?
-    /// It's not really bad, but some people think that the
-    /// `.push_str(_)` method is more readable.
+    /// ### Why restrict this?
+    /// The `to_string` method is also used on other types to convert them to a string.
+    /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be
+    /// more specifically expressed with `.to_owned()`.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut x = "Hello".to_owned();
-    /// x = x + ", World";
-    ///
-    /// // More readable
-    /// x += ", World";
-    /// x.push_str(", World");
+    /// let _ = "str".to_string();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = "str".to_owned();
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub STRING_ADD_ASSIGN,
-    pedantic,
-    "using `x = x + ..` where x is a `String` instead of `push_str()`"
+    pub STR_TO_STRING,
+    restriction,
+    "using `to_string()` on a `&str`, which should be `to_owned()`"
 }
 
 declare_clippy_lint! {
@@ -71,6 +70,52 @@
     "using `x + ..` where x is a `String` instead of `push_str()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for string appends of the form `x = x + y` (without
+    /// `let`!).
+    ///
+    /// ### Why is this bad?
+    /// It's not really bad, but some people think that the
+    /// `.push_str(_)` method is more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut x = "Hello".to_owned();
+    /// x = x + ", World";
+    ///
+    /// // More readable
+    /// x += ", World";
+    /// x.push_str(", World");
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub STRING_ADD_ASSIGN,
+    pedantic,
+    "using `x = x + ..` where x is a `String` instead of `push_str()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check if the string is transformed to byte array and casted back to string.
+    ///
+    /// ### Why is this bad?
+    /// It's unnecessary, the string can be used directly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// &"Hello World!"[6..11];
+    /// ```
+    #[clippy::version = "1.50.0"]
+    pub STRING_FROM_UTF8_AS_BYTES,
+    complexity,
+    "casting string slices to byte slices and back"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the `as_bytes` method called on string literals
@@ -141,8 +186,38 @@
     "slicing a string"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
+    ///
+    /// ### Why is this bad?
+    /// `split_whitespace` already ignores leading and trailing whitespace.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// " A B C ".trim().split_whitespace();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// " A B C ".split_whitespace();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub TRIM_SPLIT_WHITESPACE,
+    style,
+    "using `str::trim()` or alike before `str::split_whitespace`"
+}
+
+declare_lint_pass!(StrToString => [STR_TO_STRING]);
+
 declare_lint_pass!(StringAdd => [STRING_ADD, STRING_ADD_ASSIGN, STRING_SLICE]);
 
+declare_lint_pass!(StringLitAsBytes => [
+    STRING_FROM_UTF8_AS_BYTES,
+    STRING_LIT_AS_BYTES,
+]);
+
+declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
+
 impl<'tcx> LateLintPass<'tcx> for StringAdd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if e.span.in_external_macro(cx.sess().source_map()) {
@@ -218,33 +293,9 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check if the string is transformed to byte array and casted back to string.
-    ///
-    /// ### Why is this bad?
-    /// It's unnecessary, the string can be used directly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// &"Hello World!"[6..11];
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub STRING_FROM_UTF8_AS_BYTES,
-    complexity,
-    "casting string slices to byte slices and back"
-}
-
 // Max length a b"foo" string can take
 const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 
-declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
-
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
@@ -358,31 +409,6 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint checks for `.to_string()` method calls on values of type `&str`.
-    ///
-    /// ### Why restrict this?
-    /// The `to_string` method is also used on other types to convert them to a string.
-    /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be
-    /// more specifically expressed with `.to_owned()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = "str".to_string();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = "str".to_owned();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub STR_TO_STRING,
-    restriction,
-    "using `to_string()` on a `&str`, which should be `to_owned()`"
-}
-
-declare_lint_pass!(StrToString => [STR_TO_STRING]);
-
 impl<'tcx> LateLintPass<'tcx> for StrToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if expr.span.from_expansion() {
@@ -430,28 +456,6 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
-    ///
-    /// ### Why is this bad?
-    /// `split_whitespace` already ignores leading and trailing whitespace.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// " A B C ".trim().split_whitespace();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// " A B C ".split_whitespace();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub TRIM_SPLIT_WHITESPACE,
-    style,
-    "using `str::trim()` or alike before `str::split_whitespace`"
-}
-declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
-
 impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         let tyckres = cx.typeck_results();
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 962ab9cce14c..53038672d1ec 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -37,6 +37,8 @@
     "using `libc::strlen` on a `CString` or `CStr` value, while `count_bytes()` can be used instead"
 }
 
+impl_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
+
 pub struct StrlenOnCStrings {
     msrv: Msrv,
 }
@@ -47,8 +49,6 @@ pub fn new(conf: &Conf) -> Self {
     }
 }
 
-impl_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
-
 impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion()
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index af5e3ccb674a..9fa4d2c142b5 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -64,7 +64,9 @@
     "groupings of binary operations that look suspiciously like typos"
 }
 
-declare_lint_pass!(SuspiciousOperationGroupings => [SUSPICIOUS_OPERATION_GROUPINGS]);
+declare_lint_pass!(SuspiciousOperationGroupings => [
+    SUSPICIOUS_OPERATION_GROUPINGS,
+]);
 
 impl EarlyLintPass for SuspiciousOperationGroupings {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index edb7600b7c06..694f1896a4d2 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -53,7 +53,10 @@
     "suspicious use of operators in impl of OpAssign trait"
 }
 
-declare_lint_pass!(SuspiciousImpl => [SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_ASSIGN_IMPL]);
+declare_lint_pass!(SuspiciousImpl => [
+    SUSPICIOUS_ARITHMETIC_IMPL,
+    SUSPICIOUS_OP_ASSIGN_IMPL,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index e55d17818e4f..37fdba91cc02 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -27,6 +27,7 @@
     restriction,
     "XOR (`^`) operator possibly used as exponentiation operator"
 }
+
 declare_lint_pass!(ConfusingXorAndPow => [SUSPICIOUS_XOR_USED_AS_POW]);
 
 impl LateLintPass<'_> for ConfusingXorAndPow {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 694be160e79a..0c78ed84adc4 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -18,6 +18,32 @@
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, SyntaxContext};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `foo = bar; bar = foo` sequences.
+    ///
+    /// ### Why is this bad?
+    /// This looks like a failed attempt to swap.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let mut a = 1;
+    /// # let mut b = 2;
+    /// a = b;
+    /// b = a;
+    /// ```
+    /// If swapping is intended, use `swap()` instead:
+    /// ```no_run
+    /// # let mut a = 1;
+    /// # let mut b = 2;
+    /// std::mem::swap(&mut a, &mut b);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ALMOST_SWAPPED,
+    correctness,
+    "`foo = bar; bar = foo` sequence"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for manual swapping.
@@ -49,33 +75,7 @@
     "manual swap of two variables"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `foo = bar; bar = foo` sequences.
-    ///
-    /// ### Why is this bad?
-    /// This looks like a failed attempt to swap.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let mut a = 1;
-    /// # let mut b = 2;
-    /// a = b;
-    /// b = a;
-    /// ```
-    /// If swapping is intended, use `swap()` instead:
-    /// ```no_run
-    /// # let mut a = 1;
-    /// # let mut b = 2;
-    /// std::mem::swap(&mut a, &mut b);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ALMOST_SWAPPED,
-    correctness,
-    "`foo = bar; bar = foo` sequence"
-}
-
-declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
+declare_lint_pass!(Swap => [ALMOST_SWAPPED, MANUAL_SWAP]);
 
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 339c97d575ae..4d7bb2cc1f98 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -36,6 +36,7 @@
     suspicious,
     "call to `mem::swap` using pointer derived references"
 }
+
 declare_lint_pass!(SwapPtrToRef => [SWAP_PTR_TO_REF]);
 
 impl LateLintPass<'_> for SwapPtrToRef {
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 8151dd8f2cfe..bc242ba73a63 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -23,12 +23,12 @@
     "assignments to temporaries"
 }
 
+declare_lint_pass!(TemporaryAssignment => [TEMPORARY_ASSIGNMENT]);
+
 fn is_temporary(expr: &Expr<'_>) -> bool {
     matches!(&expr.kind, ExprKind::Struct(..) | ExprKind::Tup(..))
 }
 
-declare_lint_pass!(TemporaryAssignment => [TEMPORARY_ASSIGNMENT]);
-
 impl<'tcx> LateLintPass<'tcx> for TemporaryAssignment {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Assign(target, ..) = &expr.kind {
diff --git a/clippy_lints/src/time_subtraction.rs b/clippy_lints/src/time_subtraction.rs
index 457a8f48f7e2..e906ee081346 100644
--- a/clippy_lints/src/time_subtraction.rs
+++ b/clippy_lints/src/time_subtraction.rs
@@ -73,6 +73,11 @@
     "finds unchecked subtraction involving 'Duration' or 'Instant'"
 }
 
+impl_lint_pass!(UncheckedTimeSubtraction => [
+    MANUAL_INSTANT_ELAPSED,
+    UNCHECKED_TIME_SUBTRACTION,
+]);
+
 pub struct UncheckedTimeSubtraction {
     msrv: Msrv,
 }
@@ -83,8 +88,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(UncheckedTimeSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_TIME_SUBTRACTION]);
-
 impl LateLintPass<'_> for UncheckedTimeSubtraction {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         let (lhs, rhs) = match expr.kind {
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 75a82770af04..8bac517682db 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -33,6 +33,7 @@
     nursery,
     "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
 }
+
 declare_lint_pass!(TrailingEmptyArray => [TRAILING_EMPTY_ARRAY]);
 
 impl<'tcx> LateLintPass<'tcx> for TrailingEmptyArray {
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 819185775505..e7a785289f39 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -17,29 +17,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint warns about unnecessary type repetitions in trait bounds
-    ///
-    /// ### Why is this bad?
-    /// Repeating the type for every bound makes the code
-    /// less readable than combining the bounds
-    ///
-    /// ### Example
-    /// ```no_run
-    /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// pub fn foo<T>(t: T) where T: Copy + Clone {}
-    /// ```
-    #[clippy::version = "1.38.0"]
-    pub TYPE_REPETITION_IN_BOUNDS,
-    nursery,
-    "types are repeated unnecessarily in trait bounds, use `+` instead of using `T: _, T: _`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for cases where generics or trait objects are being used and multiple
@@ -86,6 +63,34 @@
     "check if the same trait bounds are specified more than once during a generic declaration"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint warns about unnecessary type repetitions in trait bounds
+    ///
+    /// ### Why is this bad?
+    /// Repeating the type for every bound makes the code
+    /// less readable than combining the bounds
+    ///
+    /// ### Example
+    /// ```no_run
+    /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// pub fn foo<T>(t: T) where T: Copy + Clone {}
+    /// ```
+    #[clippy::version = "1.38.0"]
+    pub TYPE_REPETITION_IN_BOUNDS,
+    nursery,
+    "types are repeated unnecessarily in trait bounds, use `+` instead of using `T: _, T: _`"
+}
+
+impl_lint_pass!(TraitBounds => [
+    TRAIT_DUPLICATION_IN_BOUNDS,
+    TYPE_REPETITION_IN_BOUNDS,
+]);
+
 pub struct TraitBounds {
     max_trait_bounds: u64,
     msrv: Msrv,
@@ -100,8 +105,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS, TRAIT_DUPLICATION_IN_BOUNDS]);
-
 impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, generics: &'tcx Generics<'_>) {
         self.check_type_repetition(cx, generics);
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 435cd7bcba4e..625388782e8d 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -26,73 +26,6 @@
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes that can't ever be correct on any
-    /// architecture.
-    ///
-    /// ### Why is this bad?
-    /// It's basically guaranteed to be undefined behavior.
-    ///
-    /// ### Known problems
-    /// When accessing C, users might want to store pointer
-    /// sized objects in `extradata` arguments to save an allocation.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let ptr: *const T = core::intrinsics::transmute('x')
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WRONG_TRANSMUTE,
-    correctness,
-    "transmutes that are confusing at best, undefined behavior at worst and always useless"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes to the original type of the object
-    /// and transmutes that could be a cast.
-    ///
-    /// ### Why is this bad?
-    /// Readability. The code tricks people into thinking that
-    /// something complex is going on.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub USELESS_TRANSMUTE,
-    complexity,
-    "transmutes that have the same to and from types or could be a cast/coercion"
-}
-
-// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
-declare_clippy_lint! {
-    /// ### What it does
-    ///Checks for transmutes that could be a pointer cast.
-    ///
-    /// ### Why is this bad?
-    /// Readability. The code tricks people into thinking that
-    /// something complex is going on.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// # let p: *const [i32] = &[];
-    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let p: *const [i32] = &[];
-    /// p as *const [u16];
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-    complexity,
-    "transmutes that could be a pointer cast"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmutes between a type `T` and `*T`.
@@ -112,255 +45,6 @@
     "transmutes that have to or from types that are a pointer to the other"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes from a pointer to a reference.
-    ///
-    /// ### Why is this bad?
-    /// This can always be rewritten with `&` and `*`.
-    ///
-    /// ### Known problems
-    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
-    /// while dereferencing raw pointer is not stable yet.
-    /// If you need to do this in those places,
-    /// you would have to use `transmute` instead.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// unsafe {
-    ///     let _: &T = std::mem::transmute(p); // where p: *const T
-    /// }
-    ///
-    /// // can be written:
-    /// let _: &T = &*p;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRANSMUTE_PTR_TO_REF,
-    complexity,
-    "transmutes from a pointer to a reference type"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes from a `&[u8]` to a `&str`.
-    ///
-    /// ### Why is this bad?
-    /// Not every byte slice is a valid UTF-8 string.
-    ///
-    /// ### Known problems
-    /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
-    /// as it needs to validate the input.
-    /// If you are certain that the input is always a valid UTF-8,
-    /// use [`from_utf8_unchecked`] which is as fast as `transmute`
-    /// but has a semantically meaningful name.
-    /// - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.
-    ///
-    /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
-    /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let b: &[u8] = &[1_u8, 2_u8];
-    /// unsafe {
-    ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
-    /// }
-    ///
-    /// // should be:
-    /// let _ = std::str::from_utf8(b).unwrap();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRANSMUTE_BYTES_TO_STR,
-    complexity,
-    "transmutes from a `&[u8]` to a `&str`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes from an integer to a `bool`.
-    ///
-    /// ### Why is this bad?
-    /// This might result in an invalid in-memory representation of a `bool`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = 1_u8;
-    /// unsafe {
-    ///     let _: bool = std::mem::transmute(x); // where x: u8
-    /// }
-    ///
-    /// // should be:
-    /// let _: bool = x != 0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRANSMUTE_INT_TO_BOOL,
-    complexity,
-    "transmutes from an integer to a `bool`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes from `T` to `NonZero<T>`, and suggests the `new_unchecked`
-    /// method instead.
-    ///
-    /// ### Why is this bad?
-    /// Transmutes work on any types and thus might cause unsoundness when those types change
-    /// elsewhere. `new_unchecked` only works for the appropriate types instead.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use core::num::NonZero;
-    /// let _: NonZero<u32> = unsafe { std::mem::transmute(123) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use core::num::NonZero;
-    /// let _: NonZero<u32> = unsafe { NonZero::new_unchecked(123) };
-    /// ```
-    #[clippy::version = "1.69.0"]
-    pub TRANSMUTE_INT_TO_NON_ZERO,
-    complexity,
-    "transmutes from an integer to a non-zero wrapper"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes from a pointer to a pointer, or
-    /// from a reference to a reference.
-    ///
-    /// ### Why is this bad?
-    /// Transmutes are dangerous, and these can instead be
-    /// written as casts.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let ptr = &1u32 as *const u32;
-    /// unsafe {
-    ///     // pointer-to-pointer transmute
-    ///     let _: *const f32 = std::mem::transmute(ptr);
-    ///     // ref-ref transmute
-    ///     let _: &f32 = std::mem::transmute(&1u32);
-    /// }
-    /// // These can be respectively written:
-    /// let _ = ptr as *const f32;
-    /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRANSMUTE_PTR_TO_PTR,
-    pedantic,
-    "transmutes from a pointer to a pointer / a reference to a reference"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes between collections whose
-    /// types have different ABI, size or alignment.
-    ///
-    /// ### Why is this bad?
-    /// This is undefined behavior.
-    ///
-    /// ### Known problems
-    /// Currently, we cannot know whether a type is a
-    /// collection, so we just lint the ones that come with `std`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // different size, therefore likely out-of-bounds memory access
-    /// // You absolutely do not want this in your code!
-    /// unsafe {
-    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
-    /// };
-    /// ```
-    ///
-    /// You must always iterate, map and collect the values:
-    ///
-    /// ```no_run
-    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub UNSOUND_COLLECTION_TRANSMUTE,
-    correctness,
-    "transmute between collections of layout-incompatible types"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes between types which do not have a representation defined relative to
-    /// each other.
-    ///
-    /// ### Why is this bad?
-    /// The results of such a transmute are not defined.
-    ///
-    /// ### Known problems
-    /// This lint has had multiple problems in the past and was moved to `nursery`. See issue
-    /// [#8496](https://github.com/rust-lang/rust-clippy/issues/8496) for more details.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct Foo<T>(u32, T);
-    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[repr(C)]
-    /// struct Foo<T>(u32, T);
-    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub TRANSMUTE_UNDEFINED_REPR,
-    nursery,
-    "transmute to or from a type with an undefined representation"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmute calls which would receive a null pointer.
-    ///
-    /// ### Why is this bad?
-    /// Transmuting a null pointer is undefined behavior.
-    ///
-    /// ### Known problems
-    /// Not all cases can be detected at the moment of this writing.
-    /// For example, variables which hold a null pointer and are then fed to a `transmute`
-    /// call, aren't detectable yet.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
-    /// ```
-    #[clippy::version = "1.35.0"]
-    pub TRANSMUTING_NULL,
-    correctness,
-    "transmutes from a null pointer to a reference, which is undefined behavior"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for null function pointer creation through transmute.
-    ///
-    /// ### Why is this bad?
-    /// Creating a null function pointer is undefined behavior.
-    ///
-    /// More info: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
-    ///
-    /// ### Known problems
-    /// Not all cases can be detected at the moment of this writing.
-    /// For example, variables which hold a null pointer and are then fed to a `transmute`
-    /// call, aren't detectable yet.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let null_fn: Option<fn()> = None;
-    /// ```
-    #[clippy::version = "1.68.0"]
-    pub TRANSMUTE_NULL_TO_FN,
-    correctness,
-    "transmute results in a null function pointer, which is undefined behavior"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for integer validity checks, followed by a transmute that is (incorrectly) evaluated
@@ -469,26 +153,344 @@
     "warns if a transmute call doesn't have all generics specified"
 }
 
-pub struct Transmute {
-    msrv: Msrv,
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from a `&[u8]` to a `&str`.
+    ///
+    /// ### Why is this bad?
+    /// Not every byte slice is a valid UTF-8 string.
+    ///
+    /// ### Known problems
+    /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
+    /// as it needs to validate the input.
+    /// If you are certain that the input is always a valid UTF-8,
+    /// use [`from_utf8_unchecked`] which is as fast as `transmute`
+    /// but has a semantically meaningful name.
+    /// - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.
+    ///
+    /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
+    /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let b: &[u8] = &[1_u8, 2_u8];
+    /// unsafe {
+    ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
+    /// }
+    ///
+    /// // should be:
+    /// let _ = std::str::from_utf8(b).unwrap();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRANSMUTE_BYTES_TO_STR,
+    complexity,
+    "transmutes from a `&[u8]` to a `&str`"
 }
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from an integer to a `bool`.
+    ///
+    /// ### Why is this bad?
+    /// This might result in an invalid in-memory representation of a `bool`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = 1_u8;
+    /// unsafe {
+    ///     let _: bool = std::mem::transmute(x); // where x: u8
+    /// }
+    ///
+    /// // should be:
+    /// let _: bool = x != 0;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRANSMUTE_INT_TO_BOOL,
+    complexity,
+    "transmutes from an integer to a `bool`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from `T` to `NonZero<T>`, and suggests the `new_unchecked`
+    /// method instead.
+    ///
+    /// ### Why is this bad?
+    /// Transmutes work on any types and thus might cause unsoundness when those types change
+    /// elsewhere. `new_unchecked` only works for the appropriate types instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use core::num::NonZero;
+    /// let _: NonZero<u32> = unsafe { std::mem::transmute(123) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use core::num::NonZero;
+    /// let _: NonZero<u32> = unsafe { NonZero::new_unchecked(123) };
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub TRANSMUTE_INT_TO_NON_ZERO,
+    complexity,
+    "transmutes from an integer to a non-zero wrapper"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for null function pointer creation through transmute.
+    ///
+    /// ### Why is this bad?
+    /// Creating a null function pointer is undefined behavior.
+    ///
+    /// More info: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
+    ///
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
+    /// For example, variables which hold a null pointer and are then fed to a `transmute`
+    /// call, aren't detectable yet.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let null_fn: Option<fn()> = None;
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub TRANSMUTE_NULL_TO_FN,
+    correctness,
+    "transmute results in a null function pointer, which is undefined behavior"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from a pointer to a pointer, or
+    /// from a reference to a reference.
+    ///
+    /// ### Why is this bad?
+    /// Transmutes are dangerous, and these can instead be
+    /// written as casts.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let ptr = &1u32 as *const u32;
+    /// unsafe {
+    ///     // pointer-to-pointer transmute
+    ///     let _: *const f32 = std::mem::transmute(ptr);
+    ///     // ref-ref transmute
+    ///     let _: &f32 = std::mem::transmute(&1u32);
+    /// }
+    /// // These can be respectively written:
+    /// let _ = ptr as *const f32;
+    /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRANSMUTE_PTR_TO_PTR,
+    pedantic,
+    "transmutes from a pointer to a pointer / a reference to a reference"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from a pointer to a reference.
+    ///
+    /// ### Why is this bad?
+    /// This can always be rewritten with `&` and `*`.
+    ///
+    /// ### Known problems
+    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
+    /// while dereferencing raw pointer is not stable yet.
+    /// If you need to do this in those places,
+    /// you would have to use `transmute` instead.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// unsafe {
+    ///     let _: &T = std::mem::transmute(p); // where p: *const T
+    /// }
+    ///
+    /// // can be written:
+    /// let _: &T = &*p;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRANSMUTE_PTR_TO_REF,
+    complexity,
+    "transmutes from a pointer to a reference type"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes between types which do not have a representation defined relative to
+    /// each other.
+    ///
+    /// ### Why is this bad?
+    /// The results of such a transmute are not defined.
+    ///
+    /// ### Known problems
+    /// This lint has had multiple problems in the past and was moved to `nursery`. See issue
+    /// [#8496](https://github.com/rust-lang/rust-clippy/issues/8496) for more details.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct Foo<T>(u32, T);
+    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[repr(C)]
+    /// struct Foo<T>(u32, T);
+    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub TRANSMUTE_UNDEFINED_REPR,
+    nursery,
+    "transmute to or from a type with an undefined representation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///Checks for transmutes that could be a pointer cast.
+    ///
+    /// ### Why is this bad?
+    /// Readability. The code tricks people into thinking that
+    /// something complex is going on.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// # let p: *const [i32] = &[];
+    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let p: *const [i32] = &[];
+    /// p as *const [u16];
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    complexity,
+    "transmutes that could be a pointer cast"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmute calls which would receive a null pointer.
+    ///
+    /// ### Why is this bad?
+    /// Transmuting a null pointer is undefined behavior.
+    ///
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
+    /// For example, variables which hold a null pointer and are then fed to a `transmute`
+    /// call, aren't detectable yet.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
+    /// ```
+    #[clippy::version = "1.35.0"]
+    pub TRANSMUTING_NULL,
+    correctness,
+    "transmutes from a null pointer to a reference, which is undefined behavior"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes between collections whose
+    /// types have different ABI, size or alignment.
+    ///
+    /// ### Why is this bad?
+    /// This is undefined behavior.
+    ///
+    /// ### Known problems
+    /// Currently, we cannot know whether a type is a
+    /// collection, so we just lint the ones that come with `std`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // different size, therefore likely out-of-bounds memory access
+    /// // You absolutely do not want this in your code!
+    /// unsafe {
+    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
+    /// };
+    /// ```
+    ///
+    /// You must always iterate, map and collect the values:
+    ///
+    /// ```no_run
+    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub UNSOUND_COLLECTION_TRANSMUTE,
+    correctness,
+    "transmute between collections of layout-incompatible types"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes to the original type of the object
+    /// and transmutes that could be a cast.
+    ///
+    /// ### Why is this bad?
+    /// Readability. The code tricks people into thinking that
+    /// something complex is going on.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_TRANSMUTE,
+    complexity,
+    "transmutes that have the same to and from types or could be a cast/coercion"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes that can't ever be correct on any
+    /// architecture.
+    ///
+    /// ### Why is this bad?
+    /// It's basically guaranteed to be undefined behavior.
+    ///
+    /// ### Known problems
+    /// When accessing C, users might want to store pointer
+    /// sized objects in `extradata` arguments to save an allocation.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let ptr: *const T = core::intrinsics::transmute('x')
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub WRONG_TRANSMUTE,
+    correctness,
+    "transmutes that are confusing at best, undefined behavior at worst and always useless"
+}
+
 impl_lint_pass!(Transmute => [
     CROSSPOINTER_TRANSMUTE,
-    TRANSMUTE_PTR_TO_REF,
-    TRANSMUTE_PTR_TO_PTR,
-    USELESS_TRANSMUTE,
-    WRONG_TRANSMUTE,
+    EAGER_TRANSMUTE,
+    MISSING_TRANSMUTE_ANNOTATIONS,
+    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     TRANSMUTE_BYTES_TO_STR,
     TRANSMUTE_INT_TO_BOOL,
     TRANSMUTE_INT_TO_NON_ZERO,
-    UNSOUND_COLLECTION_TRANSMUTE,
-    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    TRANSMUTE_NULL_TO_FN,
+    TRANSMUTE_PTR_TO_PTR,
+    TRANSMUTE_PTR_TO_REF,
     TRANSMUTE_UNDEFINED_REPR,
     TRANSMUTING_NULL,
-    TRANSMUTE_NULL_TO_FN,
-    EAGER_TRANSMUTE,
-    MISSING_TRANSMUTE_ANNOTATIONS,
+    UNSOUND_COLLECTION_TRANSMUTE,
+    USELESS_TRANSMUTE,
+    WRONG_TRANSMUTE,
 ]);
+
+// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
+
+pub struct Transmute {
+    msrv: Msrv,
+}
 impl Transmute {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 7d6a667eb8e5..ed8a099eced0 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_integer_const, sym};
 use clippy_utils::res::{MaybeDef, MaybeResPath};
+use clippy_utils::{is_integer_const, sym};
 use rustc_hir::{ConstBlock, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 98bf9f9fea58..8bbecb5c1954 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -40,6 +40,7 @@
     nursery,
     "checks for tuple<=>array conversions that are not done with `.into()`"
 }
+
 impl_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
 
 pub struct TupleArrayConversions {
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index cca04d39ca31..b3fea7b5a32a 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{qpath_generic_tys, sym};
 use clippy_utils::res::MaybeResPath;
+use clippy_utils::{qpath_generic_tys, sym};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index abd6138655d7..9f043b78f789 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::sym;
-use rustc_hir::def_id::DefId;
 use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_lint::LateContext;
 
 use super::LINKEDLIST;
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 7d97ce97f487..17f1adf6960f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -22,6 +22,32 @@
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `&Box<T>` anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    ///
+    /// ### Why is this bad?
+    /// A `&Box<T>` parameter requires the function caller to box `T` first before passing it to a function.
+    /// Using `&T` defines a concrete type for the parameter and generalizes the function, this would also
+    /// auto-deref to `&T` at the function call site if passed a `&Box<T>`.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo(bar: &Box<T>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// fn foo(bar: &T) { ... }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub BORROWED_BOX,
+    complexity,
+    "a borrow of a boxed type"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `Box<T>` where T is a collection such as Vec anywhere in the code.
@@ -52,74 +78,6 @@
     "usage of `Box<Vec<T>>`, vector elements are already on the heap"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Vec<Box<T>>` where T: Sized anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
-    ///
-    /// ### Why is this bad?
-    /// `Vec` already keeps its contents in a separate area on
-    /// the heap. So if you `Box` its contents, you just add another level of indirection.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct X {
-    ///     values: Vec<Box<i32>>,
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```no_run
-    /// struct X {
-    ///     values: Vec<i32>,
-    /// }
-    /// ```
-    #[clippy::version = "1.33.0"]
-    pub VEC_BOX,
-    complexity,
-    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Option<Option<_>>` in function signatures and type
-    /// definitions
-    ///
-    /// ### Why is this bad?
-    /// `Option<_>` represents an optional value. `Option<Option<_>>`
-    /// represents an optional value which itself wraps an optional. This is logically the
-    /// same thing as an optional value but has an unneeded extra level of wrapping.
-    ///
-    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
-    /// consider a custom `enum` instead, with clear names for each case.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn get_data() -> Option<Option<u32>> {
-    ///     None
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```no_run
-    /// pub enum Contents {
-    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
-    ///     NotYetFetched, // Was Some(None)
-    ///     None,          // Was None
-    /// }
-    ///
-    /// fn get_data() -> Contents {
-    ///     Contents::None
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OPTION_OPTION,
-    pedantic,
-    "usage of `Option<Option<T>>`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of any `LinkedList`, suggesting to use a
@@ -162,53 +120,80 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `&Box<T>` anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    /// Checks for usage of `Option<Option<_>>` in function signatures and type
+    /// definitions
     ///
     /// ### Why is this bad?
-    /// A `&Box<T>` parameter requires the function caller to box `T` first before passing it to a function.
-    /// Using `&T` defines a concrete type for the parameter and generalizes the function, this would also
-    /// auto-deref to `&T` at the function call site if passed a `&Box<T>`.
+    /// `Option<_>` represents an optional value. `Option<Option<_>>`
+    /// represents an optional value which itself wraps an optional. This is logically the
+    /// same thing as an optional value but has an unneeded extra level of wrapping.
+    ///
+    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
+    /// consider a custom `enum` instead, with clear names for each case.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// fn foo(bar: &Box<T>) { ... }
+    /// ```no_run
+    /// fn get_data() -> Option<Option<u32>> {
+    ///     None
+    /// }
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust,ignore
-    /// fn foo(bar: &T) { ... }
+    /// ```no_run
+    /// pub enum Contents {
+    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
+    ///     NotYetFetched, // Was Some(None)
+    ///     None,          // Was None
+    /// }
+    ///
+    /// fn get_data() -> Contents {
+    ///     Contents::None
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub BORROWED_BOX,
-    complexity,
-    "a borrow of a boxed type"
+    pub OPTION_OPTION,
+    pedantic,
+    "usage of `Option<Option<T>>`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of redundant allocations anywhere in the code.
+    /// Detects needlessly owned `Cow` types.
     ///
     /// ### Why is this bad?
-    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
-    /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
+    /// The borrowed types are usually more flexible, in that e.g. a
+    /// `Cow<'_, str>` can accept both `&str` and `String` while
+    /// `Cow<'_, String>` can only accept `&String` and `String`. In
+    /// particular, `&str` is more general, because it allows for string
+    /// literals while `&String` can only be borrowed from a heap-owned
+    /// `String`).
+    ///
+    /// ### Known Problems
+    /// The lint does not check for usage of the type. There may be external
+    /// interfaces that require the use of an owned type.
+    ///
+    /// At least the `CString` type also has a different API than `CStr`: The
+    /// former has an `as_bytes` method which the latter calls `to_bytes`.
+    /// There is no guarantee that other types won't gain additional methods
+    /// leading to a similar mismatch.
+    ///
+    /// In addition, the lint only checks for the known problematic types
+    /// `String`, `Vec<_>`, `CString`, `OsString` and `PathBuf`. Custom types
+    /// that implement `ToOwned` will not be detected.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::rc::Rc;
-    /// fn foo(bar: Rc<&usize>) {}
+    /// let wrogn: std::borrow::Cow<'_, Vec<u8>>;
     /// ```
-    ///
-    /// Better:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// fn foo(bar: &usize) {}
+    /// let right: std::borrow::Cow<'_, [u8]>;
     /// ```
-    #[clippy::version = "1.44.0"]
-    pub REDUNDANT_ALLOCATION,
-    perf,
-    "redundant allocation"
+    #[clippy::version = "1.87.0"]
+    pub OWNED_COW,
+    style,
+    "needlessly owned Cow type"
 }
 
 declare_clippy_lint! {
@@ -246,6 +231,64 @@
     "shared ownership of a buffer type"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Rc<Mutex<T>>`.
+    ///
+    /// ### Why restrict this?
+    /// `Rc` is used in single thread and `Mutex` is used in multi thread.
+    /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
+    ///
+    /// ### Known problems
+    /// Sometimes combining generic types can lead to the requirement that a
+    /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
+    /// alas they are quite hard to rule out. Luckily they are also rare.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::sync::Mutex;
+    /// fn foo(interned: Rc<Mutex<i32>>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::cell::RefCell
+    /// fn foo(interned: Rc<RefCell<i32>>) { ... }
+    /// ```
+    #[clippy::version = "1.55.0"]
+    pub RC_MUTEX,
+    restriction,
+    "usage of `Rc<Mutex<T>>`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of redundant allocations anywhere in the code.
+    ///
+    /// ### Why is this bad?
+    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
+    /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::rc::Rc;
+    /// fn foo(bar: Rc<&usize>) {}
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```no_run
+    /// fn foo(bar: &usize) {}
+    /// ```
+    #[clippy::version = "1.44.0"]
+    pub REDUNDANT_ALLOCATION,
+    perf,
+    "redundant allocation"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for types used in structs, parameters and `let`
@@ -321,75 +364,45 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Rc<Mutex<T>>`.
+    /// Checks for usage of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
-    /// ### Why restrict this?
-    /// `Rc` is used in single thread and `Mutex` is used in multi thread.
-    /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
-    ///
-    /// ### Known problems
-    /// Sometimes combining generic types can lead to the requirement that a
-    /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
-    /// alas they are quite hard to rule out. Luckily they are also rare.
+    /// ### Why is this bad?
+    /// `Vec` already keeps its contents in a separate area on
+    /// the heap. So if you `Box` its contents, you just add another level of indirection.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// use std::rc::Rc;
-    /// use std::sync::Mutex;
-    /// fn foo(interned: Rc<Mutex<i32>>) { ... }
+    /// ```no_run
+    /// struct X {
+    ///     values: Vec<Box<i32>>,
+    /// }
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust,ignore
-    /// use std::rc::Rc;
-    /// use std::cell::RefCell
-    /// fn foo(interned: Rc<RefCell<i32>>) { ... }
+    /// ```no_run
+    /// struct X {
+    ///     values: Vec<i32>,
+    /// }
     /// ```
-    #[clippy::version = "1.55.0"]
-    pub RC_MUTEX,
-    restriction,
-    "usage of `Rc<Mutex<T>>`"
+    #[clippy::version = "1.33.0"]
+    pub VEC_BOX,
+    complexity,
+    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects needlessly owned `Cow` types.
-    ///
-    /// ### Why is this bad?
-    /// The borrowed types are usually more flexible, in that e.g. a
-    /// `Cow<'_, str>` can accept both `&str` and `String` while
-    /// `Cow<'_, String>` can only accept `&String` and `String`. In
-    /// particular, `&str` is more general, because it allows for string
-    /// literals while `&String` can only be borrowed from a heap-owned
-    /// `String`).
-    ///
-    /// ### Known Problems
-    /// The lint does not check for usage of the type. There may be external
-    /// interfaces that require the use of an owned type.
-    ///
-    /// At least the `CString` type also has a different API than `CStr`: The
-    /// former has an `as_bytes` method which the latter calls `to_bytes`.
-    /// There is no guarantee that other types won't gain additional methods
-    /// leading to a similar mismatch.
-    ///
-    /// In addition, the lint only checks for the known problematic types
-    /// `String`, `Vec<_>`, `CString`, `OsString` and `PathBuf`. Custom types
-    /// that implement `ToOwned` will not be detected.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let wrogn: std::borrow::Cow<'_, Vec<u8>>;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let right: std::borrow::Cow<'_, [u8]>;
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub OWNED_COW,
-    style,
-    "needlessly owned Cow type"
-}
+impl_lint_pass!(Types => [
+    BORROWED_BOX,
+    BOX_COLLECTION,
+    LINKEDLIST,
+    OPTION_OPTION,
+    OWNED_COW,
+    RC_BUFFER,
+    RC_MUTEX,
+    REDUNDANT_ALLOCATION,
+    TYPE_COMPLEXITY,
+    VEC_BOX,
+]);
 
 pub struct Types {
     vec_box_size_threshold: u64,
@@ -397,19 +410,6 @@ pub struct Types {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(Types => [
-    BOX_COLLECTION,
-    VEC_BOX,
-    OPTION_OPTION,
-    LINKEDLIST,
-    BORROWED_BOX,
-    REDUNDANT_ALLOCATION,
-    RC_BUFFER,
-    RC_MUTEX,
-    TYPE_COMPLEXITY,
-    OWNED_COW
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/types/owned_cow.rs b/clippy_lints/src/types/owned_cow.rs
index 3a806cfef691..0b8389b72c35 100644
--- a/clippy_lints/src/types/owned_cow.rs
+++ b/clippy_lints/src/types/owned_cow.rs
@@ -3,8 +3,8 @@
 use clippy_utils::source::snippet_opt;
 use clippy_utils::sym;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
 use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 8c864dab66d8..81061ce1178b 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{qpath_generic_tys, sym};
 use clippy_utils::res::MaybeResPath;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{qpath_generic_tys, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{QPath, Ty, TyKind};
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 1b7d7fd6c68c..84e6825419d1 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -13,8 +13,8 @@
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::impl_lint_pass;
-use rustc_span::symbol::{Ident, kw};
 use rustc_span::Span;
+use rustc_span::symbol::{Ident, kw};
 use rustc_trait_selection::error_reporting::traits::suggestions::ReturnsVisitor;
 use std::ops::ControlFlow;
 
@@ -71,6 +71,8 @@
     "detect unconditional recursion in some traits implementation"
 }
 
+impl_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
+
 #[derive(Default)]
 pub struct UnconditionalRecursion {
     /// The key is the `DefId` of the type implementing the `Default` trait and the value is the
@@ -78,8 +80,6 @@ pub struct UnconditionalRecursion {
     default_impl_for_type: FxHashMap<DefId, DefId>,
 }
 
-impl_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
-
 fn span_error(cx: &LateContext<'_>, method_span: Span, expr: &Expr<'_>) {
     span_lint_and_then(
         cx,
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1b26b1b32b80..60775d1856eb 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -63,6 +63,7 @@
     restriction,
     "creating an unsafe block without explaining why it is safe"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `// SAFETY: ` comments on safe code.
@@ -92,6 +93,11 @@
     "annotating safe code with a safety comment"
 }
 
+impl_lint_pass!(UndocumentedUnsafeBlocks => [
+    UNDOCUMENTED_UNSAFE_BLOCKS,
+    UNNECESSARY_SAFETY_COMMENT,
+]);
+
 pub struct UndocumentedUnsafeBlocks {
     accept_comment_above_statement: bool,
     accept_comment_above_attributes: bool,
@@ -106,8 +112,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
-
 impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 79571b0409d2..bef8b8fb4ee0 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -72,7 +72,11 @@
     "using a Unicode literal not in NFC normal form (see [Unicode tr15](http://www.unicode.org/reports/tr15/) for further information)"
 }
 
-declare_lint_pass!(Unicode => [INVISIBLE_CHARACTERS, NON_ASCII_LITERAL, UNICODE_NOT_NFC]);
+declare_lint_pass!(Unicode => [
+    INVISIBLE_CHARACTERS,
+    NON_ASCII_LITERAL,
+    UNICODE_NOT_NFC,
+]);
 
 impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 4ffcc247acf6..ca29975392de 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -28,6 +28,27 @@
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for passing a unit value as an argument to a function without using a
+    /// unit literal (`()`).
+    ///
+    /// ### Why is this bad?
+    /// This is likely the result of an accidental semicolon.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// foo({
+    ///     let a = bar();
+    ///     baz(a);
+    /// })
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub UNIT_ARG,
+    complexity,
+    "passing unit to a function"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for comparisons to unit. This includes all binary
@@ -76,33 +97,12 @@
     "comparing unit values"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for passing a unit value as an argument to a function without using a
-    /// unit literal (`()`).
-    ///
-    /// ### Why is this bad?
-    /// This is likely the result of an accidental semicolon.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// foo({
-    ///     let a = bar();
-    ///     baz(a);
-    /// })
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNIT_ARG,
-    complexity,
-    "passing unit to a function"
-}
+impl_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_ARG, UNIT_CMP]);
 
 pub struct UnitTypes {
     format_args: FormatArgsStorage,
 }
 
-impl_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP, UNIT_ARG]);
-
 impl UnitTypes {
     pub fn new(format_args: FormatArgsStorage) -> Self {
         Self { format_args }
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 6e3e41f08ee5..8d4f1a153def 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -40,13 +40,13 @@
     "Needlessly returning a Box"
 }
 
+impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
+
 pub struct UnnecessaryBoxReturns {
     avoid_breaking_exported_api: bool,
     maximum_size: u64,
 }
 
-impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
-
 impl UnnecessaryBoxReturns {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index fba530d0dfca..6754c224e7e4 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -31,7 +31,10 @@
     complexity,
     "using `map`/`map_err` on `Option` or `Result` constructors"
 }
-declare_lint_pass!(UnnecessaryMapOnConstructor => [UNNECESSARY_MAP_ON_CONSTRUCTOR]);
+
+declare_lint_pass!(UnnecessaryMapOnConstructor => [
+    UNNECESSARY_MAP_ON_CONSTRUCTOR,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 229974b499ad..6960c006ab94 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -30,7 +30,10 @@
     style,
     "detects cases of references to owned empty strings being passed as an argument to a function expecting `&str`"
 }
-declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [UNNECESSARY_OWNED_EMPTY_STRINGS]);
+
+declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [
+    UNNECESSARY_OWNED_EMPTY_STRINGS,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
diff --git a/clippy_lints/src/unnecessary_semicolon.rs b/clippy_lints/src/unnecessary_semicolon.rs
index e1e450a52fdf..8a76fdecc0a6 100644
--- a/clippy_lints/src/unnecessary_semicolon.rs
+++ b/clippy_lints/src/unnecessary_semicolon.rs
@@ -35,13 +35,13 @@
     "unnecessary semicolon after expression returning `()`"
 }
 
+impl_lint_pass!(UnnecessarySemicolon => [UNNECESSARY_SEMICOLON]);
+
 #[derive(Default)]
 pub struct UnnecessarySemicolon {
     last_statements: Vec<(HirId, bool)>,
 }
 
-impl_lint_pass!(UnnecessarySemicolon => [UNNECESSARY_SEMICOLON]);
-
 impl UnnecessarySemicolon {
     /// Enter or leave a block, remembering the last statement of the block.
     fn handle_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>, enter: bool) {
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index 51397accefea..65a3c2f304af 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -45,6 +45,7 @@
     nursery,
     "struct built from a base that can be written mode concisely"
 }
+
 declare_lint_pass!(UnnecessaryStruct => [UNNECESSARY_STRUCT_INITIALIZATION]);
 
 impl LateLintPass<'_> for UnnecessaryStruct {
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 29747cf0e447..17e05db644b0 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -60,12 +60,12 @@
     "functions that only return `Ok` or `Some`"
 }
 
+impl_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
+
 pub struct UnnecessaryWraps {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
-
 impl UnnecessaryWraps {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 12f8bd50e144..712dcf60e695 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -49,6 +49,8 @@
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
+impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
+
 pub struct UnnestedOrPatterns {
     msrv: MsrvStack,
 }
@@ -61,8 +63,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
-
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 5a3e4b7adf64..a4ebd8860dc0 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -43,6 +43,8 @@
     "finds async functions with no await statements"
 }
 
+impl_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
+
 #[derive(Default)]
 pub struct UnusedAsync {
     /// Keeps track of async functions used as values (i.e. path expressions to async functions that
@@ -60,8 +62,6 @@ struct UnusedAsyncFn {
     await_in_async_block: Option<Span>,
 }
 
-impl_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
-
 struct AsyncFnVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     found_await: bool,
diff --git a/clippy_lints/src/unused_result_ok.rs b/clippy_lints/src/unused_result_ok.rs
index fe323a0b7b0c..c1dc64e0bbe8 100644
--- a/clippy_lints/src/unused_result_ok.rs
+++ b/clippy_lints/src/unused_result_ok.rs
@@ -30,6 +30,7 @@
     restriction,
     "Use of `.ok()` to silence `Result`'s `#[must_use]` is misleading. Use `let _ =` instead."
 }
+
 declare_lint_pass!(UnusedResultOk => [UNUSED_RESULT_OK]);
 
 impl LateLintPass<'_> for UnusedResultOk {
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index c21004b5362d..a8af8eafe8dc 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -30,6 +30,7 @@
     nursery,
     "Uselessly rounding a whole number floating-point literal"
 }
+
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
 fn is_useless_rounding(cx: &EarlyContext<'_>, expr: &Expr) -> Option<(Symbol, String)> {
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index dff39974a373..587cc8631d02 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -36,12 +36,12 @@
     "methods that contain a `self` argument but don't use it"
 }
 
+impl_lint_pass!(UnusedSelf => [UNUSED_SELF]);
+
 pub struct UnusedSelf {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(UnusedSelf => [UNUSED_SELF]);
-
 impl UnusedSelf {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unused_trait_names.rs b/clippy_lints/src/unused_trait_names.rs
index 12f2804dbaa1..be41bdd38020 100644
--- a/clippy_lints/src/unused_trait_names.rs
+++ b/clippy_lints/src/unused_trait_names.rs
@@ -45,6 +45,8 @@
     "use items that import a trait but only use it anonymously"
 }
 
+impl_lint_pass!(UnusedTraitNames => [UNUSED_TRAIT_NAMES]);
+
 pub struct UnusedTraitNames {
     msrv: Msrv,
 }
@@ -55,8 +57,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(UnusedTraitNames => [UNUSED_TRAIT_NAMES]);
-
 impl<'tcx> LateLintPass<'tcx> for UnusedTraitNames {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if !item.span.from_expansion()
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index a95f2b681add..cfd3f420db5a 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -22,6 +22,33 @@
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, Symbol};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls of `unwrap[_err]()` that will always fail.
+    ///
+    /// ### Why is this bad?
+    /// If panicking is desired, an explicit `panic!()` should be used.
+    ///
+    /// ### Known problems
+    /// This lint only checks `if` conditions not assignments.
+    /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let option = Some(0);
+    /// # fn do_something_with(_x: usize) {}
+    /// if option.is_none() {
+    ///     do_something_with(option.unwrap())
+    /// }
+    /// ```
+    ///
+    /// This code will always panic. The if condition should probably be inverted.
+    #[clippy::version = "pre 1.29.0"]
+    pub PANICKING_UNWRAP,
+    correctness,
+    "checks for calls of `unwrap[_err]()` that will always fail"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls of `unwrap[_err]()` that cannot fail.
@@ -53,32 +80,7 @@
     "checks for calls of `unwrap[_err]()` that cannot fail"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls of `unwrap[_err]()` that will always fail.
-    ///
-    /// ### Why is this bad?
-    /// If panicking is desired, an explicit `panic!()` should be used.
-    ///
-    /// ### Known problems
-    /// This lint only checks `if` conditions not assignments.
-    /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let option = Some(0);
-    /// # fn do_something_with(_x: usize) {}
-    /// if option.is_none() {
-    ///     do_something_with(option.unwrap())
-    /// }
-    /// ```
-    ///
-    /// This code will always panic. The if condition should probably be inverted.
-    #[clippy::version = "pre 1.29.0"]
-    pub PANICKING_UNWRAP,
-    correctness,
-    "checks for calls of `unwrap[_err]()` that will always fail"
-}
+impl_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
 
 pub(crate) struct Unwrap {
     msrv: Msrv,
@@ -524,8 +526,6 @@ fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
     }
 }
 
-impl_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
-
 impl<'tcx> LateLintPass<'tcx> for Unwrap {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index f26647fa3485..aafd1153f933 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -56,7 +56,7 @@
     "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
 }
 
-impl_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
+impl_lint_pass!(UnwrapInResult => [UNWRAP_IN_RESULT]);
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 enum OptionOrResult {
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 944cd91a7fda..6ea6a0ad85aa 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -39,6 +39,8 @@
     "capitalized acronyms are against the naming convention"
 }
 
+impl_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
+
 pub struct UpperCaseAcronyms {
     avoid_breaking_exported_api: bool,
     upper_case_acronyms_aggressive: bool,
@@ -53,8 +55,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
-
 fn contains_acronym(s: &str) -> bool {
     let mut count = 0;
     for c in s.chars() {
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 38ce9dc3f916..620874e2aebf 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -56,6 +56,8 @@
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
+impl_lint_pass!(UseSelf => [USE_SELF]);
+
 pub struct UseSelf {
     msrv: Msrv,
     stack: Vec<StackItem>,
@@ -81,8 +83,6 @@ enum StackItem {
     NoCheck,
 }
 
-impl_lint_pass!(UseSelf => [USE_SELF]);
-
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e287a3de86bd..662da5929adb 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -41,14 +41,14 @@
     "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type"
 }
 
+impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
+
 #[derive(Default)]
 pub struct UselessConversion {
     try_desugar_arm: Vec<HirId>,
     expn_depth: u32,
 }
 
-impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
-
 enum MethodOrFunction {
     Method,
     Function,
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index d17b3df99216..74ffeb629d2b 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -27,6 +27,7 @@
     style,
     "checks for usage of `pub(self)` and `pub(in self)`."
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `pub(<loc>)` with `in`.
@@ -49,6 +50,7 @@
     restriction,
     "disallows usage of `pub(<loc>)`, without `in`"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `pub(<loc>)` without `in`.
@@ -74,7 +76,12 @@
     restriction,
     "disallows usage of `pub(in <loc>)` with `in`"
 }
-declare_lint_pass!(Visibility => [NEEDLESS_PUB_SELF, PUB_WITH_SHORTHAND, PUB_WITHOUT_SHORTHAND]);
+
+declare_lint_pass!(Visibility => [
+    NEEDLESS_PUB_SELF,
+    PUB_WITHOUT_SHORTHAND,
+    PUB_WITH_SHORTHAND,
+]);
 
 impl EarlyLintPass for Visibility {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
diff --git a/clippy_lints/src/volatile_composites.rs b/clippy_lints/src/volatile_composites.rs
index 6402c3ef72c4..c7659056c937 100644
--- a/clippy_lints/src/volatile_composites.rs
+++ b/clippy_lints/src/volatile_composites.rs
@@ -57,6 +57,7 @@
     nursery,
     "warn about volatile read/write applied to composite types"
 }
+
 declare_lint_pass!(VolatileComposites => [VOLATILE_COMPOSITES]);
 
 /// Zero-sized types are intrinsically safe to use volatile on since they won't
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index a2523b5fb07c..22c46527b5c6 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -100,6 +100,8 @@
     "lint `use _::*` statements"
 }
 
+impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
+
 pub struct WildcardImports {
     warn_on_all: bool,
     allowed_segments: FxHashSet<String>,
@@ -114,8 +116,6 @@ pub fn new(conf: &'static Conf) -> Self {
     }
 }
 
-impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
-
 impl LateLintPass<'_> for WildcardImports {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if cx.sess().is_test_crate() || item.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/write/mod.rs b/clippy_lints/src/write/mod.rs
index c42c047745bb..8d896046200b 100644
--- a/clippy_lints/src/write/mod.rs
+++ b/clippy_lints/src/write/mod.rs
@@ -13,25 +13,69 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns when you use `println!("")` to
-    /// print a newline.
+    /// This lint warns about the use of literals as `print!`/`println!` args.
     ///
     /// ### Why is this bad?
-    /// You should use `println!()`, which is simpler.
+    /// Using literals as `println!` args is inefficient
+    /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
+    /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
     /// ```no_run
-    /// println!("");
+    /// println!("{}", "foo");
     /// ```
-    ///
-    /// Use instead:
+    /// use the literal without formatting:
     /// ```no_run
-    /// println!();
+    /// println!("foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub PRINTLN_EMPTY_STRING,
+    pub PRINT_LITERAL,
     style,
-    "using `println!(\"\")` with an empty string"
+    "printing a literal with a format string"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for printing on *stderr*. The purpose of this lint
+    /// is to catch debugging remnants.
+    ///
+    /// ### Why restrict this?
+    /// People often print on *stderr* while debugging an
+    /// application and might forget to remove those prints afterward.
+    ///
+    /// ### Known problems
+    /// Only catches `eprint!` and `eprintln!` calls.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// eprintln!("Hello world!");
+    /// ```
+    #[clippy::version = "1.50.0"]
+    pub PRINT_STDERR,
+    restriction,
+    "printing on stderr"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for printing on *stdout*. The purpose of this lint
+    /// is to catch debugging remnants.
+    ///
+    /// ### Why restrict this?
+    /// People often print on *stdout* while debugging an
+    /// application and might forget to remove those prints afterward.
+    ///
+    /// ### Known problems
+    /// Only catches `print!` and `println!` calls.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// println!("Hello world!");
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub PRINT_STDOUT,
+    restriction,
+    "printing on stdout"
 }
 
 declare_clippy_lint! {
@@ -61,46 +105,25 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for printing on *stdout*. The purpose of this lint
-    /// is to catch debugging remnants.
+    /// This lint warns when you use `println!("")` to
+    /// print a newline.
     ///
-    /// ### Why restrict this?
-    /// People often print on *stdout* while debugging an
-    /// application and might forget to remove those prints afterward.
-    ///
-    /// ### Known problems
-    /// Only catches `print!` and `println!` calls.
+    /// ### Why is this bad?
+    /// You should use `println!()`, which is simpler.
     ///
     /// ### Example
     /// ```no_run
-    /// println!("Hello world!");
+    /// println!("");
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// println!();
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub PRINT_STDOUT,
-    restriction,
-    "printing on stdout"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for printing on *stderr*. The purpose of this lint
-    /// is to catch debugging remnants.
-    ///
-    /// ### Why restrict this?
-    /// People often print on *stderr* while debugging an
-    /// application and might forget to remove those prints afterward.
-    ///
-    /// ### Known problems
-    /// Only catches `eprint!` and `eprintln!` calls.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// eprintln!("Hello world!");
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub PRINT_STDERR,
-    restriction,
-    "printing on stderr"
+    pub PRINTLN_EMPTY_STRING,
+    style,
+    "using `println!(\"\")` with an empty string"
 }
 
 declare_clippy_lint! {
@@ -128,52 +151,30 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns about the use of literals as `print!`/`println!` args.
+    /// This lint warns about the use of literals as `write!`/`writeln!` args.
     ///
     /// ### Why is this bad?
-    /// Using literals as `println!` args is inefficient
+    /// Using literals as `writeln!` args is inefficient
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
     /// ```no_run
-    /// println!("{}", "foo");
-    /// ```
-    /// use the literal without formatting:
-    /// ```no_run
-    /// println!("foo");
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub PRINT_LITERAL,
-    style,
-    "printing a literal with a format string"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint warns when you use `writeln!(buf, "")` to
-    /// print a newline.
-    ///
-    /// ### Why is this bad?
-    /// You should use `writeln!(buf)`, which is simpler.
-    ///
-    /// ### Example
-    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "");
+    /// writeln!(buf, "{}", "foo");
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf);
+    /// writeln!(buf, "foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WRITELN_EMPTY_STRING,
+    pub WRITE_LITERAL,
     style,
-    "using `writeln!(buf, \"\")` with an empty string"
+    "writing a literal with a format string"
 }
 
 declare_clippy_lint! {
@@ -209,32 +210,43 @@
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns about the use of literals as `write!`/`writeln!` args.
+    /// This lint warns when you use `writeln!(buf, "")` to
+    /// print a newline.
     ///
     /// ### Why is this bad?
-    /// Using literals as `writeln!` args is inefficient
-    /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
-    /// (i.e., just put the literal in the format string)
+    /// You should use `writeln!(buf)`, which is simpler.
     ///
     /// ### Example
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "{}", "foo");
+    /// writeln!(buf, "");
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "foo");
+    /// writeln!(buf);
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WRITE_LITERAL,
+    pub WRITELN_EMPTY_STRING,
     style,
-    "writing a literal with a format string"
+    "using `writeln!(buf, \"\")` with an empty string"
 }
 
+impl_lint_pass!(Write => [
+    PRINTLN_EMPTY_STRING,
+    PRINT_LITERAL,
+    PRINT_STDERR,
+    PRINT_STDOUT,
+    PRINT_WITH_NEWLINE,
+    USE_DEBUG,
+    WRITELN_EMPTY_STRING,
+    WRITE_LITERAL,
+    WRITE_WITH_NEWLINE,
+]);
+
 pub struct Write {
     format_args: FormatArgsStorage,
     // The outermost `impl Debug` we're currently in. While we're in one, `USE_DEBUG` is deactivated
@@ -256,18 +268,6 @@ fn in_debug_impl(&self) -> bool {
     }
 }
 
-impl_lint_pass!(Write => [
-    PRINT_WITH_NEWLINE,
-    PRINTLN_EMPTY_STRING,
-    PRINT_STDOUT,
-    PRINT_STDERR,
-    USE_DEBUG,
-    PRINT_LITERAL,
-    WRITE_WITH_NEWLINE,
-    WRITELN_EMPTY_STRING,
-    WRITE_LITERAL,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Write {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         // Only check for `impl Debug`s if we're not already in one
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 92a5752cc2df..df2dcdbb9d06 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -54,6 +54,7 @@
     suspicious,
     "not waiting on a spawned child process"
 }
+
 declare_lint_pass!(ZombieProcesses => [ZOMBIE_PROCESSES]);
 
 impl<'tcx> LateLintPass<'tcx> for ZombieProcesses {
diff --git a/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs b/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
index 0fd1e11b0333..7190b8bf39b8 100644
--- a/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
+++ b/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
@@ -2,7 +2,6 @@
 use clippy_utils::paths;
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::{AttrStyle, DelimArgs};
-use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{
@@ -93,10 +92,7 @@ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         }
 
         // Is it derived?
-        if !find_attr!(
-            cx.tcx.get_all_attrs(item.owner_id),
-            AttributeKind::AutomaticallyDerived(..)
-        ) {
+        if !find_attr!(cx.tcx.hir_attrs(item.hir_id()), AutomaticallyDerived(..)) {
             return;
         }
 
diff --git a/clippy_lints_internal/src/repeated_is_diagnostic_item.rs b/clippy_lints_internal/src/repeated_is_diagnostic_item.rs
index 8644ea1fc907..4492e3539ffb 100644
--- a/clippy_lints_internal/src/repeated_is_diagnostic_item.rs
+++ b/clippy_lints_internal/src/repeated_is_diagnostic_item.rs
@@ -489,11 +489,7 @@ fn check_if_chains<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, conds: Vec<&'t
                 }))
                 .collect();
 
-                diag.multipart_suggestion(
-                    "call `TyCtxt::get_diagnostic_name`, and reuse the results",
-                    sugg,
-                    app,
-                );
+                diag.multipart_suggestion("call `TyCtxt::get_diagnostic_name`, and reuse the results", sugg, app);
             },
         );
     }
diff --git a/clippy_lints_internal/src/symbols.rs b/clippy_lints_internal/src/symbols.rs
index 38c95666e211..779485e49b39 100644
--- a/clippy_lints_internal/src/symbols.rs
+++ b/clippy_lints_internal/src/symbols.rs
@@ -112,7 +112,7 @@ fn check_crate(&mut self, cx: &LateContext<'_>) {
                     continue;
                 }
 
-                for item in cx.tcx.module_children(def_id) {
+                for item in cx.tcx.module_children(*def_id) {
                     if let Res::Def(DefKind::Const { .. }, item_def_id) = item.res
                         && let ty = cx.tcx.type_of(item_def_id).instantiate_identity()
                         && internal_paths::SYMBOL.matches_ty(cx, ty)
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index b61b663d1026..9800a75035fa 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_utils"
-version = "0.1.95"
+version = "0.1.96"
 edition = "2024"
 description = "Helpful tools for writing lints, provided as they are used in Clippy"
 repository = "https://github.com/rust-lang/rust-clippy"
diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index 87048ceff891..d7e40130380d 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2026-02-19
+nightly-2026-03-05
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index e1e72950393d..4e9c64dd63c7 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -505,7 +505,7 @@ pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
             (ExprKind::Block(l, _), ExprKind::Block(r, _)) => self.eq_block(l, r),
             (ExprKind::Binary(l_op, ll, lr), ExprKind::Binary(r_op, rl, rr)) => {
                 l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    || swap_binop(self.inner.cx, l_op.node, ll, lr).is_some_and(|(l_op, ll, lr)| {
+                    || self.swap_binop(l_op.node, ll, lr).is_some_and(|(l_op, ll, lr)| {
                         l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
                     })
             },
@@ -921,6 +921,40 @@ fn check_ctxt(&mut self, left: SyntaxContext, right: SyntaxContext) -> bool {
         self.right_ctxt = right;
         true
     }
+
+    fn swap_binop<'a>(
+        &self,
+        binop: BinOpKind,
+        lhs: &'a Expr<'a>,
+        rhs: &'a Expr<'a>,
+    ) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
+        match binop {
+            // `==` and `!=`, are commutative
+            BinOpKind::Eq | BinOpKind::Ne => Some((binop, rhs, lhs)),
+            // Comparisons can be reversed
+            BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
+            BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
+            BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
+            BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
+            // Non-commutative operators
+            BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Rem | BinOpKind::Sub | BinOpKind::Div => None,
+            // We know that those operators are commutative for primitive types,
+            // and we don't assume anything for other types
+            BinOpKind::Mul
+            | BinOpKind::Add
+            | BinOpKind::And
+            | BinOpKind::Or
+            | BinOpKind::BitAnd
+            | BinOpKind::BitXor
+            | BinOpKind::BitOr => self.inner.maybe_typeck_results.and_then(|(typeck_lhs, _)| {
+                typeck_lhs
+                    .expr_ty_adjusted(lhs)
+                    .peel_refs()
+                    .is_primitive()
+                    .then_some((binop, rhs, lhs))
+            }),
+        }
+    }
 }
 
 /// Some simple reductions like `{ return }` => `return`
@@ -966,39 +1000,6 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
     }
 }
 
-fn swap_binop<'a>(
-    cx: &LateContext<'_>,
-    binop: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
-    match binop {
-        // `==` and `!=`, are commutative
-        BinOpKind::Eq | BinOpKind::Ne => Some((binop, rhs, lhs)),
-        // Comparisons can be reversed
-        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
-        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
-        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
-        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        // Non-commutative operators
-        BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Rem | BinOpKind::Sub | BinOpKind::Div => None,
-        // We know that those operators are commutative for primitive types,
-        // and we don't assume anything for other types
-        BinOpKind::Mul
-        | BinOpKind::Add
-        | BinOpKind::And
-        | BinOpKind::Or
-        | BinOpKind::BitAnd
-        | BinOpKind::BitXor
-        | BinOpKind::BitOr => cx
-            .typeck_results()
-            .expr_ty_adjusted(lhs)
-            .peel_refs()
-            .is_primitive()
-            .then_some((binop, rhs, lhs)),
-    }
-}
-
 /// Checks if the two `Option`s are both `None` or some equal values as per
 /// `eq_fn`.
 pub fn both<X>(l: Option<&X>, r: Option<&X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index ed5db32d1117..4162595ffe81 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -19,6 +19,7 @@
     sym::assert_eq_macro,
     sym::assert_macro,
     sym::assert_ne_macro,
+    sym::core_panic_macro,
     sym::debug_assert_eq_macro,
     sym::debug_assert_macro,
     sym::debug_assert_ne_macro,
diff --git a/clippy_utils/src/mir/mod.rs b/clippy_utils/src/mir/mod.rs
index a066427d6bc1..40c553d1c9e6 100644
--- a/clippy_utils/src/mir/mod.rs
+++ b/clippy_utils/src/mir/mod.rs
@@ -1,3 +1,6 @@
+use std::iter;
+
+use rustc_data_structures::either::Either;
 use rustc_hir::{Expr, HirId};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
@@ -21,14 +24,17 @@ pub struct LocalUsage {
     pub local_consume_or_mutate_locs: Vec<Location>,
 }
 
-pub fn visit_local_usage(locals: &[Local], mir: &Body<'_>, location: Location) -> Option<Vec<LocalUsage>> {
-    let init = vec![
+pub fn visit_local_usage<const N: usize>(
+    locals: [Local; N],
+    mir: &Body<'_>,
+    location: Location,
+) -> Option<[LocalUsage; N]> {
+    let init = [const {
         LocalUsage {
             local_use_locs: Vec::new(),
             local_consume_or_mutate_locs: Vec::new(),
-        };
-        locals.len()
-    ];
+        }
+    }; N];
 
     traversal::Postorder::new(&mir.basic_blocks, location.block, None)
         .collect::<Vec<_>>()
@@ -43,7 +49,7 @@ pub fn visit_local_usage(locals: &[Local], mir: &Body<'_>, location: Location) -
             }
 
             let mut v = V {
-                locals,
+                locals: &locals,
                 location,
                 results: usage,
             };
@@ -52,13 +58,13 @@ pub fn visit_local_usage(locals: &[Local], mir: &Body<'_>, location: Location) -
         })
 }
 
-struct V<'a> {
-    locals: &'a [Local],
+struct V<'a, const N: usize> {
+    locals: &'a [Local; N],
     location: Location,
-    results: Vec<LocalUsage>,
+    results: [LocalUsage; N],
 }
 
-impl<'tcx> Visitor<'tcx> for V<'_> {
+impl<'tcx, const N: usize> Visitor<'tcx> for V<'_, N> {
     fn visit_place(&mut self, place: &Place<'tcx>, ctx: PlaceContext, loc: Location) {
         if loc.block == self.location.block && loc.statement_index <= self.location.statement_index {
             return;
@@ -66,20 +72,20 @@ fn visit_place(&mut self, place: &Place<'tcx>, ctx: PlaceContext, loc: Location)
 
         let local = place.local;
 
-        for (i, self_local) in self.locals.iter().enumerate() {
+        for (self_local, result) in iter::zip(self.locals, &mut self.results) {
             if local == *self_local {
                 if !matches!(
                     ctx,
                     PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
                 ) {
-                    self.results[i].local_use_locs.push(loc);
+                    result.local_use_locs.push(loc);
                 }
                 if matches!(
                     ctx,
                     PlaceContext::NonMutatingUse(NonMutatingUseContext::Move | NonMutatingUseContext::Inspect)
                         | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
                 ) {
-                    self.results[i].local_consume_or_mutate_locs.push(loc);
+                    result.local_consume_or_mutate_locs.push(loc);
                 }
             }
         }
@@ -113,16 +119,16 @@ pub fn block_in_cycle(body: &Body<'_>, block: BasicBlock) -> bool {
 /// Convenience wrapper around `visit_local_usage`.
 pub fn used_exactly_once(mir: &Body<'_>, local: Local) -> Option<bool> {
     visit_local_usage(
-        &[local],
+        [local],
         mir,
         Location {
             block: START_BLOCK,
             statement_index: 0,
         },
     )
-    .map(|mut vec| {
-        let LocalUsage { local_use_locs, .. } = vec.remove(0);
-        let mut locations = local_use_locs
+    .map(|[local_usage]| {
+        let mut locations = local_usage
+            .local_use_locs
             .into_iter()
             .filter(|&location| !is_local_assignment(mir, local, location));
         if let Some(location) = locations.next() {
@@ -175,18 +181,15 @@ pub fn local_assignments(mir: &Body<'_>, local: Local) -> Vec<Location> {
 // `is_local_assignment` is based on `is_place_assignment`:
 // https://github.com/rust-lang/rust/blob/b7413511dc85ec01ef4b91785f86614589ac6103/compiler/rustc_middle/src/mir/visit.rs#L1350
 fn is_local_assignment(mir: &Body<'_>, local: Local, location: Location) -> bool {
-    let Location { block, statement_index } = location;
-    let basic_block = &mir.basic_blocks[block];
-    if statement_index < basic_block.statements.len() {
-        let statement = &basic_block.statements[statement_index];
-        if let StatementKind::Assign(box (place, _)) = statement.kind {
-            place.as_local() == Some(local)
-        } else {
-            false
-        }
-    } else {
-        let terminator = basic_block.terminator();
-        match &terminator.kind {
+    match mir.stmt_at(location) {
+        Either::Left(statement) => {
+            if let StatementKind::Assign(box (place, _)) = statement.kind {
+                place.as_local() == Some(local)
+            } else {
+                false
+            }
+        },
+        Either::Right(terminator) => match &terminator.kind {
             TerminatorKind::Call { destination, .. } => destination.as_local() == Some(local),
             TerminatorKind::InlineAsm { operands, .. } => operands.iter().any(|operand| {
                 if let InlineAsmOperand::Out { place: Some(place), .. } = operand {
@@ -196,6 +199,6 @@ fn is_local_assignment(mir: &Body<'_>, local: Local, location: Location) -> bool
                 }
             }),
             _ => false,
-        }
+        },
     }
 }
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index f8a0b3f161df..d6ba678434bc 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -453,7 +453,6 @@ macro_rules! generate {
     os_string_as_os_str,
     outer_expn,
     panic_any,
-    panic_str,
     parse,
     partition,
     path_main_separator,
@@ -536,7 +535,6 @@ macro_rules! generate {
     skip,
     skip_while,
     slice_from_ref,
-    slice_into_vec,
     slice_iter,
     slice_mut_unchecked,
     slice_unchecked,
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
index 39831e2b52d6..c55e084ad52f 100644
--- a/declare_clippy_lint/Cargo.toml
+++ b/declare_clippy_lint/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "declare_clippy_lint"
-version = "0.1.95"
+version = "0.1.96"
 edition = "2024"
 repository = "https://github.com/rust-lang/rust-clippy"
 license = "MIT OR Apache-2.0"
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index e9b06bcbdaef..c9bb94cededb 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2026-02-19"
+channel = "nightly-2026-03-05"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index a92bb8f5ca73..c5af6d2d27c4 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -197,9 +197,6 @@ fn base_config(&self, test_dir: &str, mandatory_annotations: bool) -> Config {
             defaults.set_custom("diagnostic-collector", collector);
         }
         config.with_args(&self.args);
-        let current_exe_path = env::current_exe().unwrap();
-        let deps_path = current_exe_path.parent().unwrap();
-        let profile_path = deps_path.parent().unwrap();
 
         config.program.args.extend(
             [
@@ -224,11 +221,7 @@ fn base_config(&self, test_dir: &str, mandatory_annotations: bool) -> Config {
             config.program.args.push(format!("--sysroot={sysroot}").into());
         }
 
-        config.program.program = profile_path.join(if cfg!(windows) {
-            "clippy-driver.exe"
-        } else {
-            "clippy-driver"
-        });
+        config.program.program = PathBuf::from(env!("CARGO_BIN_EXE_clippy-driver"));
 
         config
     }
diff --git a/tests/test_utils/mod.rs b/tests/test_utils/mod.rs
index ea8c54e08b33..9099f91693a7 100644
--- a/tests/test_utils/mod.rs
+++ b/tests/test_utils/mod.rs
@@ -3,11 +3,6 @@
 use std::path::PathBuf;
 use std::sync::LazyLock;
 
-pub static CARGO_CLIPPY_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
-    let mut path = std::env::current_exe().unwrap();
-    assert!(path.pop()); // deps
-    path.set_file_name("cargo-clippy");
-    path
-});
+pub static CARGO_CLIPPY_PATH: LazyLock<PathBuf> = LazyLock::new(|| PathBuf::from(env!("CARGO_BIN_EXE_cargo-clippy")));
 
 pub const IS_RUSTC_TEST_SUITE: bool = option_env!("RUSTC_TEST_SUITE").is_some();
diff --git a/tests/ui/cmp_owned/with_suggestion.fixed b/tests/ui/cmp_owned/with_suggestion.fixed
index 471905b47df7..1a1f3ff1194b 100644
--- a/tests/ui/cmp_owned/with_suggestion.fixed
+++ b/tests/ui/cmp_owned/with_suggestion.fixed
@@ -150,3 +150,11 @@ fn issue16458() {
         required_version: String, m!().to_string();
     }
 }
+
+fn issue16564(path: std::path::PathBuf) {
+    const ROOT: &str = "root";
+    if path != *ROOT {
+        //~^ cmp_owned
+        todo!()
+    }
+}
diff --git a/tests/ui/cmp_owned/with_suggestion.rs b/tests/ui/cmp_owned/with_suggestion.rs
index 3323176d34e3..185c56893787 100644
--- a/tests/ui/cmp_owned/with_suggestion.rs
+++ b/tests/ui/cmp_owned/with_suggestion.rs
@@ -150,3 +150,11 @@ macro_rules! all_comes_from_macro {
         required_version: String, m!().to_string();
     }
 }
+
+fn issue16564(path: std::path::PathBuf) {
+    const ROOT: &str = "root";
+    if path != std::path::PathBuf::from(ROOT) {
+        //~^ cmp_owned
+        todo!()
+    }
+}
diff --git a/tests/ui/cmp_owned/with_suggestion.stderr b/tests/ui/cmp_owned/with_suggestion.stderr
index 3797810e3b98..7d9a12b1ddd3 100644
--- a/tests/ui/cmp_owned/with_suggestion.stderr
+++ b/tests/ui/cmp_owned/with_suggestion.stderr
@@ -68,5 +68,11 @@ LL | |     }
    |
    = note: this error originates in the macro `all_comes_from_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 10 previous errors
+error: this creates an owned instance just for comparison
+  --> tests/ui/cmp_owned/with_suggestion.rs:156:16
+   |
+LL |     if path != std::path::PathBuf::from(ROOT) {
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `*ROOT`
+
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.rs b/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.rs
new file mode 100644
index 000000000000..361e09b554a5
--- /dev/null
+++ b/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.rs
@@ -0,0 +1,12 @@
+#![feature(custom_inner_attributes)]
+#![rustfmt::skip]
+#![warn(clippy::doc_paragraphs_missing_punctuation)]
+//@no-rustfix
+
+enum EmojiTrailers {
+    /// Sometimes the doc comment ends with an emoji! 😅
+    ExistingPunctuationBeforeEmoji,
+    /// But it may still be missing punctuation 😢
+    //~^ doc_paragraphs_missing_punctuation
+    MissingPunctuationBeforeEmoji,
+}
diff --git a/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.stderr b/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.stderr
new file mode 100644
index 000000000000..1eb1a77e4017
--- /dev/null
+++ b/tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.stderr
@@ -0,0 +1,11 @@
+error: doc paragraphs should end with a terminal punctuation mark
+  --> tests/ui/doc/doc_paragraphs_missing_punctuation_emoji.rs:9:50
+   |
+LL |     /// But it may still be missing punctuation 😢
+   |                                                   ^ help: end the paragraph with some punctuation: `.`
+   |
+   = note: `-D clippy::doc-paragraphs-missing-punctuation` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::doc_paragraphs_missing_punctuation)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index fdaf1c37b201..41e5bbe3cbed 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -652,3 +652,12 @@ trait Issue16360: Sized {
         //~^ redundant_closure_for_method_calls
     }
 }
+
+fn issue16641() {
+    use std::cell::LazyCell;
+
+    let closure = LazyCell::new(|| |x: usize| println!("{x}"));
+
+    (0..10).flat_map(|x| (0..10).map(&*closure)).count();
+    //~^ redundant_closure
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 1054060db449..de0d3fb63c51 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -652,3 +652,12 @@ trait Issue16360: Sized {
         //~^ redundant_closure_for_method_calls
     }
 }
+
+fn issue16641() {
+    use std::cell::LazyCell;
+
+    let closure = LazyCell::new(|| |x: usize| println!("{x}"));
+
+    (0..10).flat_map(|x| (0..10).map(|y| closure(y))).count();
+    //~^ redundant_closure
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 2e0ccc557915..c19947cddafa 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -262,5 +262,11 @@ error: redundant closure
 LL |         array.iter().for_each(|item| item.method());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Self::method`
 
-error: aborting due to 43 previous errors
+error: redundant closure
+  --> tests/ui/eta.rs:661:38
+   |
+LL |     (0..10).flat_map(|x| (0..10).map(|y| closure(y))).count();
+   |                                      ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&*closure`
+
+error: aborting due to 44 previous errors
 
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index ebb261a0d97a..79968700f8e4 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -317,3 +317,18 @@ fn issue16612(v: Vec<u8>, s: i64) {
         j += 1;
     }
 }
+
+fn issue16640(x: &[u8]) {
+    struct Priority(u8);
+
+    impl core::ops::AddAssign<u8> for Priority {
+        fn add_assign(&mut self, rhs: u8) {
+            self.0 += rhs
+        }
+    }
+
+    let mut priority = Priority(1);
+    for _val in x {
+        priority += 1;
+    }
+}
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index 884bae004320..a4841d309d56 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -113,3 +113,15 @@ fn _issue14897() {
     let _ = 1.0f64.mul_add(2.0, 0.5);
     //~^ suboptimal_flops
 }
+
+fn issue16573() {
+    let mut a = 3.0_f32;
+    let b = 4.0_f32;
+    let c = 7.0_f32;
+
+    a = b.mul_add(c, a);
+    //~^ suboptimal_flops
+
+    a = b.mul_add(-c, a);
+    //~^ suboptimal_flops
+}
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 9ceb2ec96062..c048653a4123 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -113,3 +113,15 @@ fn _issue14897() {
     let _ = 1.0 * 2.0 + 0.5;
     //~^ suboptimal_flops
 }
+
+fn issue16573() {
+    let mut a = 3.0_f32;
+    let b = 4.0_f32;
+    let c = 7.0_f32;
+
+    a += b * c;
+    //~^ suboptimal_flops
+
+    a -= b * c;
+    //~^ suboptimal_flops
+}
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index dad65ddf2ec3..3f2ca76826f4 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -109,5 +109,17 @@ error: multiply and add expressions can be calculated more efficiently and accur
 LL |     let _ = 1.0 * 2.0 + 0.5;
    |             ^^^^^^^^^^^^^^^ help: consider using: `1.0f64.mul_add(2.0, 0.5)`
 
-error: aborting due to 18 previous errors
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:122:5
+   |
+LL |     a += b * c;
+   |     ^^^^^^^^^^ help: consider using: `a = b.mul_add(c, a)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:125:5
+   |
+LL |     a -= b * c;
+   |     ^^^^^^^^^^ help: consider using: `a = b.mul_add(-c, a)`
+
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index 6e0e2c5ea720..6982a9d143e4 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -305,3 +305,20 @@ fn issue16416_prim(x: bool, a: u32, b: u32) {
     //~v if_same_then_else
     _ = if x { a >= b } else { b <= a };
 }
+
+mod issue16505 {
+    macro_rules! foo {
+        (< $hi:literal : $lo:literal > | $N:tt bits) => {{
+            const NEW_N_: usize = $hi - $lo + 1;
+            NEW_N_
+        }};
+    }
+
+    fn bar(x: bool) {
+        _ = if x {
+            foo!(<2:0> | 3 bits) == foo!(<3:1> | 3 bits)
+        } else {
+            foo!(<3:1> | 3 bits) == foo!(<2:0> | 3 bits)
+        };
+    }
+}
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 0bde31aca030..88e3328d662e 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -536,4 +536,57 @@ async fn bad() {
     }
 }
 
+mod issue16155 {
+    #![allow(clippy::empty_loop)]
+
+    use super::do_something;
+
+    fn let_then_else(cond: bool) {
+        let true = cond else { loop {} };
+        //~^ infinite_loop
+    }
+
+    fn loop_in_one_if_branch(cond: bool) {
+        if cond {
+            loop {}
+            //~^ infinite_loop
+        }
+    }
+
+    fn loop_in_one_match_arm(x: Option<i32>) {
+        match x {
+            Some(_) => {},
+            None => loop {},
+            //~^ infinite_loop
+        }
+    }
+
+    fn loop_in_if_let_else(x: Option<i32>) {
+        if let Some(_val) = x {
+            do_something();
+        } else {
+            loop {}
+            //~^ infinite_loop
+        }
+    }
+
+    #[expect(clippy::if_same_then_else)]
+    fn all_branches_diverge_if(cond: bool) {
+        if cond {
+            loop {}
+            //~^ infinite_loop
+        } else {
+            loop {}
+            //~^ infinite_loop
+        }
+    }
+
+    fn all_branches_diverge_match(x: Option<i32>) {
+        match x {
+            Some(_) => loop {}, //~ infinite_loop
+            None => loop {},    //~ infinite_loop
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index 319f1e5012b6..9c2b4667b979 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -7,6 +7,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
    = note: `-D clippy::infinite-loop` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::infinite_loop)]`
 help: if this is intentional, consider specifying `!` as function return
@@ -25,6 +26,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
@@ -40,6 +42,7 @@ LL | |             loop {
 LL | |         }
    | |_________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
@@ -54,6 +57,7 @@ LL | |                 do_something();
 LL | |             }
    | |_____________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
@@ -68,7 +72,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
-   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:51:5
@@ -82,6 +86,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn no_break_never_ret_noise() -> ! {
@@ -98,6 +103,7 @@ LL | |             if cond {
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
@@ -114,6 +120,7 @@ LL | |             loop {
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
@@ -128,10 +135,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifying `!` as function return
-   |
-LL | fn break_outer_but_not_inner() -> ! {
-   |                                ++++
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:143:9
@@ -144,10 +148,7 @@ LL | |                 loop {
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifying `!` as function return
-   |
-LL | fn break_wrong_loop(cond: bool) -> ! {
-   |                                 ++++
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:183:5
@@ -160,10 +161,7 @@ LL | |             Some(v) => {
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifying `!` as function return
-   |
-LL | fn match_like() -> ! {
-   |                 ++++
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:224:5
@@ -174,10 +172,7 @@ LL | |         let _x = matches!(result, Ok(v) if v != 0).then_some(0);
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifying `!` as function return
-   |
-LL | fn match_like() -> ! {
-   |                 ++++
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:229:5
@@ -191,10 +186,7 @@ LL | |         });
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifying `!` as function return
-   |
-LL | fn match_like() -> ! {
-   |                 ++++
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:334:9
@@ -205,6 +197,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL |     fn problematic_trait_method() -> ! {
@@ -219,6 +212,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL |     fn could_be_problematic() -> ! {
@@ -233,6 +227,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL |     let _loop_forever = || -> ! {
@@ -248,7 +243,7 @@ LL | |         do_something()
 LL | |     })
    | |_____^
    |
-   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:410:5
@@ -261,6 +256,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn continue_outer() -> ! {
@@ -276,6 +272,7 @@ LL | |         'inner: loop {
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn continue_outer() -> ! {
@@ -292,6 +289,7 @@ LL | |             }
 LL | |         }
    | |_________^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn continue_outer() -> ! {
@@ -306,6 +304,7 @@ LL | |         continue;
 LL | |     }
    | |_____^
    |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn continue_outer() -> ! {
@@ -320,7 +319,7 @@ LL | |                 do_something();
 LL | |             }
    | |_____________^
    |
-   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:466:13
@@ -331,7 +330,7 @@ LL | |                 continue;
 LL | |             }
    | |_____________^
    |
-   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
 error: infinite loop detected
   --> tests/ui/infinite_loops.rs:533:9
@@ -341,7 +340,87 @@ LL | |             std::future::pending().await
 LL | |         }
    | |_________^
    |
-   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+   = help: if this is not intended, try adding a `break` or `return` to the loop
 
-error: aborting due to 24 previous errors
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:545:32
+   |
+LL |         let true = cond else { loop {} };
+   |                                ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:551:13
+   |
+LL |             loop {}
+   |             ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:559:21
+   |
+LL |             None => loop {},
+   |                     ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:568:13
+   |
+LL |             loop {}
+   |             ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:576:13
+   |
+LL |             loop {}
+   |             ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+help: if this is intentional, consider specifying `!` as function return
+   |
+LL |     fn all_branches_diverge_if(cond: bool) -> ! {
+   |                                            ++++
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:579:13
+   |
+LL |             loop {}
+   |             ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+help: if this is intentional, consider specifying `!` as function return
+   |
+LL |     fn all_branches_diverge_if(cond: bool) -> ! {
+   |                                            ++++
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:586:24
+   |
+LL |             Some(_) => loop {},
+   |                        ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+help: if this is intentional, consider specifying `!` as function return
+   |
+LL |     fn all_branches_diverge_match(x: Option<i32>) -> ! {
+   |                                                   ++++
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:587:21
+   |
+LL |             None => loop {},
+   |                     ^^^^^^^
+   |
+   = help: if this is not intended, try adding a `break` or `return` to the loop
+help: if this is intentional, consider specifying `!` as function return
+   |
+LL |     fn all_branches_diverge_match(x: Option<i32>) -> ! {
+   |                                                   ++++
+
+error: aborting due to 32 previous errors
 
diff --git a/tests/ui/must_use_candidates.fixed b/tests/ui/must_use_candidates.fixed
index 10dc5f9157b7..17569884658b 100644
--- a/tests/ui/must_use_candidates.fixed
+++ b/tests/ui/must_use_candidates.fixed
@@ -13,14 +13,14 @@ use std::sync::atomic::{AtomicBool, Ordering};
 pub struct MyAtomic(AtomicBool);
 pub struct MyPure;
 
-#[must_use] 
+#[must_use]
 pub fn pure(i: u8) -> u8 {
     //~^ must_use_candidate
     i
 }
 
 impl MyPure {
-    #[must_use] 
+    #[must_use]
     pub fn inherent_pure(&self) -> u8 {
         //~^ must_use_candidate
         0
@@ -53,7 +53,7 @@ pub fn with_callback<F: Fn(u32) -> bool>(f: &F) -> bool {
     f(0)
 }
 
-#[must_use] 
+#[must_use]
 pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
     //~^ must_use_candidate
     true
@@ -67,7 +67,7 @@ pub fn atomics(b: &AtomicBool) -> bool {
     b.load(Ordering::SeqCst)
 }
 
-#[must_use] 
+#[must_use]
 pub fn rcd(_x: Rc<u32>) -> bool {
     //~^ must_use_candidate
     true
@@ -77,7 +77,7 @@ pub fn rcmut(_x: Rc<&mut u32>) -> bool {
     true
 }
 
-#[must_use] 
+#[must_use]
 pub fn arcd(_x: Arc<u32>) -> bool {
     //~^ must_use_candidate
     false
@@ -110,13 +110,13 @@ pub fn main() -> std::process::ExitCode {
 }
 
 //~v must_use_candidate
-#[must_use] 
+#[must_use]
 pub fn result_uninhabited() -> Result<i32, std::convert::Infallible> {
     todo!()
 }
 
 //~v must_use_candidate
-#[must_use] 
+#[must_use]
 pub fn controlflow_uninhabited() -> std::ops::ControlFlow<std::convert::Infallible, i32> {
     todo!()
 }
diff --git a/tests/ui/must_use_candidates.stderr b/tests/ui/must_use_candidates.stderr
index f2ec9b265c45..38c733432250 100644
--- a/tests/ui/must_use_candidates.stderr
+++ b/tests/ui/must_use_candidates.stderr
@@ -8,7 +8,7 @@ LL | pub fn pure(i: u8) -> u8 {
    = help: to override `-D warnings` add `#[allow(clippy::must_use_candidate)]`
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn pure(i: u8) -> u8 {
    |
 
@@ -20,7 +20,7 @@ LL |     pub fn inherent_pure(&self) -> u8 {
    |
 help: add the attribute
    |
-LL ~     #[must_use] 
+LL ~     #[must_use]
 LL ~     pub fn inherent_pure(&self) -> u8 {
    |
 
@@ -32,7 +32,7 @@ LL | pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
    |
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
    |
 
@@ -44,7 +44,7 @@ LL | pub fn rcd(_x: Rc<u32>) -> bool {
    |
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn rcd(_x: Rc<u32>) -> bool {
    |
 
@@ -56,7 +56,7 @@ LL | pub fn arcd(_x: Arc<u32>) -> bool {
    |
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn arcd(_x: Arc<u32>) -> bool {
    |
 
@@ -69,7 +69,7 @@ LL | pub fn result_uninhabited() -> Result<i32, std::convert::Infallible> {
    = note: a future version of Rust will treat `Result<T, E>` as `T` when `E` is uninhabited wrt `#[must_use]`
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn result_uninhabited() -> Result<i32, std::convert::Infallible> {
    |
 
@@ -82,7 +82,7 @@ LL | pub fn controlflow_uninhabited() -> std::ops::ControlFlow<std::convert::Inf
    = note: a future version of Rust will treat `ControlFlow<B, C>` as `C` when `B` is uninhabited wrt `#[must_use]`
 help: add the attribute
    |
-LL + #[must_use] 
+LL + #[must_use]
 LL | pub fn controlflow_uninhabited() -> std::ops::ControlFlow<std::convert::Infallible, i32> {
    |
 
diff --git a/tests/ui/single_component_path_imports_nested_first.rs b/tests/ui/single_component_path_imports_nested_first.rs
index acfda8b3a9c8..77213bc482c3 100644
--- a/tests/ui/single_component_path_imports_nested_first.rs
+++ b/tests/ui/single_component_path_imports_nested_first.rs
@@ -13,6 +13,7 @@ fn main() {
 }
 
 mod root_nested_use_mod {
+    #[rustfmt::skip]
     use {regex, serde};
     //~^ single_component_path_imports
     //~| single_component_path_imports
diff --git a/tests/ui/single_component_path_imports_nested_first.stderr b/tests/ui/single_component_path_imports_nested_first.stderr
index 6dbfd2711b4a..8eec877860e7 100644
--- a/tests/ui/single_component_path_imports_nested_first.stderr
+++ b/tests/ui/single_component_path_imports_nested_first.stderr
@@ -8,7 +8,7 @@ LL | use regex;
    = help: to override `-D warnings` add `#[allow(clippy::single_component_path_imports)]`
 
 error: this import is redundant
-  --> tests/ui/single_component_path_imports_nested_first.rs:16:10
+  --> tests/ui/single_component_path_imports_nested_first.rs:17:10
    |
 LL |     use {regex, serde};
    |          ^^^^^
@@ -16,7 +16,7 @@ LL |     use {regex, serde};
    = help: remove this import
 
 error: this import is redundant
-  --> tests/ui/single_component_path_imports_nested_first.rs:16:17
+  --> tests/ui/single_component_path_imports_nested_first.rs:17:17
    |
 LL |     use {regex, serde};
    |                 ^^^^^
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 6e999a48595c..2e84bbc106ac 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -361,3 +361,24 @@ fn user_format() {
     usr_println!(true, "{local_f64:.1}");
     //~^ uninlined_format_args
 }
+
+// issue #16411: false negative when #[clippy::format_args] macro uses nested format_args
+// without binding the inner args first
+#[clippy::format_args]
+macro_rules! nested_format_args {
+    ($($arg:tt)*) => {{
+        // Wraps the user args in another format_args call
+        ::core::format_args!("{}\n", ::core::format_args!($($arg)*))
+    }};
+}
+
+fn nested_format_args_user() {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+
+    // false negative: should warn but currently doesn't because the inner format_args
+    // is not processed when it's used as an argument to another format_args
+    nested_format_args!("{}", local_i32);
+    nested_format_args!("val='{}'", local_i32);
+    nested_format_args!("{:.1}", local_f64);
+}
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
index 58bbe41b97bf..4368ce864474 100644
--- a/tests/ui/uninlined_format_args.rs
+++ b/tests/ui/uninlined_format_args.rs
@@ -366,3 +366,24 @@ fn user_format() {
     usr_println!(true, "{:.1}", local_f64);
     //~^ uninlined_format_args
 }
+
+// issue #16411: false negative when #[clippy::format_args] macro uses nested format_args
+// without binding the inner args first
+#[clippy::format_args]
+macro_rules! nested_format_args {
+    ($($arg:tt)*) => {{
+        // Wraps the user args in another format_args call
+        ::core::format_args!("{}\n", ::core::format_args!($($arg)*))
+    }};
+}
+
+fn nested_format_args_user() {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+
+    // false negative: should warn but currently doesn't because the inner format_args
+    // is not processed when it's used as an argument to another format_args
+    nested_format_args!("{}", local_i32);
+    nested_format_args!("val='{}'", local_i32);
+    nested_format_args!("{:.1}", local_f64);
+}
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.fixed b/tests/ui/uninlined_format_args_panic.edition2018.fixed
index 3710036c0589..6d0f76eaf252 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2018.fixed
@@ -1,6 +1,7 @@
-//@revisions: edition2018 edition2021
+//@revisions: edition2018 edition2021 edition2024
 //@[edition2018] edition:2018
 //@[edition2021] edition:2021
+//@[edition2024] edition:2024
 
 #![warn(clippy::uninlined_format_args)]
 #![allow(clippy::literal_string_with_formatting_args)]
@@ -14,14 +15,17 @@ fn main() {
     if var > 0 {
         panic!("p1 {}", var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {0}", var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}", var = var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -33,6 +37,34 @@ fn main() {
 
     assert!(var == 1, "p5 {}", var);
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
     debug_assert!(var == 1, "p6 {}", var);
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
+
+    // core::panic! with format string containing text: should warn on 2021+ (issue #16411)
+    if var > 0 {
+        core::panic!("p7 {}", var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p8 {0}", var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p9 {var}", var = var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+
+    // std::panic! and core::panic! with only "{}" format string: false negative due to
+    // panic_display special case in panic_2021 macro - no format_args node is created
+    if var > 0 {
+        std::panic!("{}", var);
+    }
+    if var > 0 {
+        core::panic!("{}", var);
+    }
 }
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.stderr b/tests/ui/uninlined_format_args_panic.edition2018.stderr
index 4b154abac5bc..24afb3d35abe 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2018.stderr
@@ -1,5 +1,5 @@
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:11:5
+  --> tests/ui/uninlined_format_args_panic.rs:12:5
    |
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.fixed b/tests/ui/uninlined_format_args_panic.edition2021.fixed
index 8a754d313806..ba741bfcd09d 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2021.fixed
@@ -1,6 +1,7 @@
-//@revisions: edition2018 edition2021
+//@revisions: edition2018 edition2021 edition2024
 //@[edition2018] edition:2018
 //@[edition2021] edition:2021
+//@[edition2024] edition:2024
 
 #![warn(clippy::uninlined_format_args)]
 #![allow(clippy::literal_string_with_formatting_args)]
@@ -14,14 +15,17 @@ fn main() {
     if var > 0 {
         panic!("p1 {var}");
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {var}");
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}");
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -33,6 +37,34 @@ fn main() {
 
     assert!(var == 1, "p5 {var}");
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
     debug_assert!(var == 1, "p6 {var}");
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
+
+    // core::panic! with format string containing text: should warn on 2021+ (issue #16411)
+    if var > 0 {
+        core::panic!("p7 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p8 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p9 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+
+    // std::panic! and core::panic! with only "{}" format string: false negative due to
+    // panic_display special case in panic_2021 macro - no format_args node is created
+    if var > 0 {
+        std::panic!("{}", var);
+    }
+    if var > 0 {
+        core::panic!("{}", var);
+    }
 }
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.stderr b/tests/ui/uninlined_format_args_panic.edition2021.stderr
index 4db6e6a99312..dcf6747e2d64 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2021.stderr
@@ -1,5 +1,5 @@
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:11:5
+  --> tests/ui/uninlined_format_args_panic.rs:12:5
    |
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     println!("val='{var}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:15:9
+  --> tests/ui/uninlined_format_args_panic.rs:16:9
    |
 LL |         panic!("p1 {}", var);
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         panic!("p1 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:19:9
+  --> tests/ui/uninlined_format_args_panic.rs:21:9
    |
 LL |         panic!("p2 {0}", var);
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +         panic!("p2 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:23:9
+  --> tests/ui/uninlined_format_args_panic.rs:26:9
    |
 LL |         panic!("p3 {var}", var = var);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         panic!("p3 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:34:5
+  --> tests/ui/uninlined_format_args_panic.rs:38:5
    |
 LL |     assert!(var == 1, "p5 {}", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     assert!(var == 1, "p5 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:36:5
+  --> tests/ui/uninlined_format_args_panic.rs:41:5
    |
 LL |     debug_assert!(var == 1, "p6 {}", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,5 +72,41 @@ LL -     debug_assert!(var == 1, "p6 {}", var);
 LL +     debug_assert!(var == 1, "p6 {var}");
    |
 
-error: aborting due to 6 previous errors
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:47:9
+   |
+LL |         core::panic!("p7 {}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p7 {}", var);
+LL +         core::panic!("p7 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:52:9
+   |
+LL |         core::panic!("p8 {0}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p8 {0}", var);
+LL +         core::panic!("p8 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:57:9
+   |
+LL |         core::panic!("p9 {var}", var = var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p9 {var}", var = var);
+LL +         core::panic!("p9 {var}");
+   |
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/uninlined_format_args_panic.edition2024.fixed b/tests/ui/uninlined_format_args_panic.edition2024.fixed
new file mode 100644
index 000000000000..ba741bfcd09d
--- /dev/null
+++ b/tests/ui/uninlined_format_args_panic.edition2024.fixed
@@ -0,0 +1,70 @@
+//@revisions: edition2018 edition2021 edition2024
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@[edition2024] edition:2024
+
+#![warn(clippy::uninlined_format_args)]
+#![allow(clippy::literal_string_with_formatting_args)]
+
+fn main() {
+    let var = 1;
+
+    println!("val='{var}'");
+    //~^ uninlined_format_args
+
+    if var > 0 {
+        panic!("p1 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        panic!("p2 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        panic!("p3 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+
+    #[allow(non_fmt_panics)]
+    {
+        if var > 0 {
+            panic!("p4 {var}");
+        }
+    }
+
+    assert!(var == 1, "p5 {var}");
+    //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
+    debug_assert!(var == 1, "p6 {var}");
+    //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
+
+    // core::panic! with format string containing text: should warn on 2021+ (issue #16411)
+    if var > 0 {
+        core::panic!("p7 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p8 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p9 {var}");
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+
+    // std::panic! and core::panic! with only "{}" format string: false negative due to
+    // panic_display special case in panic_2021 macro - no format_args node is created
+    if var > 0 {
+        std::panic!("{}", var);
+    }
+    if var > 0 {
+        core::panic!("{}", var);
+    }
+}
diff --git a/tests/ui/uninlined_format_args_panic.edition2024.stderr b/tests/ui/uninlined_format_args_panic.edition2024.stderr
new file mode 100644
index 000000000000..dcf6747e2d64
--- /dev/null
+++ b/tests/ui/uninlined_format_args_panic.edition2024.stderr
@@ -0,0 +1,112 @@
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:12:5
+   |
+LL |     println!("val='{}'", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::uninlined_format_args)]`
+help: change this to
+   |
+LL -     println!("val='{}'", var);
+LL +     println!("val='{var}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:16:9
+   |
+LL |         panic!("p1 {}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p1 {}", var);
+LL +         panic!("p1 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:21:9
+   |
+LL |         panic!("p2 {0}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p2 {0}", var);
+LL +         panic!("p2 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:26:9
+   |
+LL |         panic!("p3 {var}", var = var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p3 {var}", var = var);
+LL +         panic!("p3 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:38:5
+   |
+LL |     assert!(var == 1, "p5 {}", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     assert!(var == 1, "p5 {}", var);
+LL +     assert!(var == 1, "p5 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:41:5
+   |
+LL |     debug_assert!(var == 1, "p6 {}", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     debug_assert!(var == 1, "p6 {}", var);
+LL +     debug_assert!(var == 1, "p6 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:47:9
+   |
+LL |         core::panic!("p7 {}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p7 {}", var);
+LL +         core::panic!("p7 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:52:9
+   |
+LL |         core::panic!("p8 {0}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p8 {0}", var);
+LL +         core::panic!("p8 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> tests/ui/uninlined_format_args_panic.rs:57:9
+   |
+LL |         core::panic!("p9 {var}", var = var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         core::panic!("p9 {var}", var = var);
+LL +         core::panic!("p9 {var}");
+   |
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/uninlined_format_args_panic.rs b/tests/ui/uninlined_format_args_panic.rs
index 94de4f057e99..7ee17d8fb16e 100644
--- a/tests/ui/uninlined_format_args_panic.rs
+++ b/tests/ui/uninlined_format_args_panic.rs
@@ -1,6 +1,7 @@
-//@revisions: edition2018 edition2021
+//@revisions: edition2018 edition2021 edition2024
 //@[edition2018] edition:2018
 //@[edition2021] edition:2021
+//@[edition2024] edition:2024
 
 #![warn(clippy::uninlined_format_args)]
 #![allow(clippy::literal_string_with_formatting_args)]
@@ -14,14 +15,17 @@ fn main() {
     if var > 0 {
         panic!("p1 {}", var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {0}", var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}", var = var);
         //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -33,6 +37,34 @@ fn main() {
 
     assert!(var == 1, "p5 {}", var);
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
     debug_assert!(var == 1, "p6 {}", var);
     //~[edition2021]^ uninlined_format_args
+    //~[edition2024]^^ uninlined_format_args
+
+    // core::panic! with format string containing text: should warn on 2021+ (issue #16411)
+    if var > 0 {
+        core::panic!("p7 {}", var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p8 {0}", var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+    if var > 0 {
+        core::panic!("p9 {var}", var = var);
+        //~[edition2021]^ uninlined_format_args
+        //~[edition2024]^^ uninlined_format_args
+    }
+
+    // std::panic! and core::panic! with only "{}" format string: false negative due to
+    // panic_display special case in panic_2021 macro - no format_args node is created
+    if var > 0 {
+        std::panic!("{}", var);
+    }
+    if var > 0 {
+        core::panic!("{}", var);
+    }
 }
diff --git a/triagebot.toml b/triagebot.toml
index eb8442ab21e2..8e7c36dac841 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -60,6 +60,31 @@ labels = ["S-waiting-on-concerns"]
 [view-all-comments-link]
 threshold = 20
 
+[notify-zulip."lint-nominated"]
+zulip_stream = 577190 # #clippy/fcp
+topic = "FCP rust-clippy#{number}: {title}"
+github_comment = """\
+This lint has been nominated for inclusion.
+
+[A FCP topic has been created on Zulip]({zulip_topic_url}).
+"""
+# Zulip polls may not be preceded by any other text and pings & short links inside
+# the title of a poll don't get recognized. Therefore we need to send two messages.
+message_on_add = [
+    """\
+PR rust-clippy#{number} "{title}" has been nominated for lint inclusion.
+""",
+    """\
+/poll Approve lint inclusion of rust-clippy#{number}?
+approve
+decline
+don't know
+""",
+]
+message_on_remove = "PR rust-clippy#{number} lint nomination has been removed."
+message_on_close = "PR rust-clippy#{number} has been closed. Thanks for participating!"
+message_on_reopen = "PR rust-clippy#{number} has been reopened."
+
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [

From 25171f23aeec81bf7a6fcad429fcbd1c91d1bfc0 Mon Sep 17 00:00:00 2001
From: Paolo Borelli <pborelli@gnome.org>
Date: Fri, 13 Feb 2026 14:55:18 +0100
Subject: [PATCH 0138/1059] add `manual_pop_if` lint

Add a lint to detect when the recently added Vec::pop_if,
VecDeque::pop_front_if, and VecDeque::pop_back_if are manually
implemented.

changelog: add [`manual_pop_if`] lint
---
 CHANGELOG.md                       |   1 +
 clippy_lints/src/declared_lints.rs |   1 +
 clippy_lints/src/lib.rs            |   2 +
 clippy_lints/src/manual_pop_if.rs  | 434 +++++++++++++++++++++++++++++
 clippy_utils/src/msrvs.rs          |   2 +
 clippy_utils/src/sym.rs            |   8 +
 tests/ui/manual_pop_if.fixed       | 247 ++++++++++++++++
 tests/ui/manual_pop_if.rs          | 319 +++++++++++++++++++++
 tests/ui/manual_pop_if.stderr      | 197 +++++++++++++
 9 files changed, 1211 insertions(+)
 create mode 100644 clippy_lints/src/manual_pop_if.rs
 create mode 100644 tests/ui/manual_pop_if.fixed
 create mode 100644 tests/ui/manual_pop_if.rs
 create mode 100644 tests/ui/manual_pop_if.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c798a3c2e5a..2e7312227f91 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6705,6 +6705,7 @@ Released 2018-09-13
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_option_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_option_as_slice
 [`manual_pattern_char_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_pattern_char_comparison
+[`manual_pop_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_pop_if
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_range_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_patterns
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e16b194c0cad..441b907eaf2f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -312,6 +312,7 @@
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
     crate::manual_option_as_slice::MANUAL_OPTION_AS_SLICE_INFO,
+    crate::manual_pop_if::MANUAL_POP_IF_INFO,
     crate::manual_range_patterns::MANUAL_RANGE_PATTERNS_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4dca8dfe94d0..950fcf0db0a4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -211,6 +211,7 @@
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
 mod manual_option_as_slice;
+mod manual_pop_if;
 mod manual_range_patterns;
 mod manual_rem_euclid;
 mod manual_retain;
@@ -864,6 +865,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
         Box::new(move |tcx| Box::new(duration_suboptimal_units::DurationSuboptimalUnits::new(tcx, conf))),
         Box::new(move |_| Box::new(manual_take::ManualTake::new(conf))),
         Box::new(|_| Box::new(manual_checked_ops::ManualCheckedOps)),
+        Box::new(move |_| Box::new(manual_pop_if::ManualPopIf::new(conf))),
         // add late passes here, used by `cargo dev new_lint`
     ];
     store.late_passes.extend(late_lints);
diff --git a/clippy_lints/src/manual_pop_if.rs b/clippy_lints/src/manual_pop_if.rs
new file mode 100644
index 000000000000..6662a34bc332
--- /dev/null
+++ b/clippy_lints/src/manual_pop_if.rs
@@ -0,0 +1,434 @@
+use clippy_config::Conf;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::MaybeDef;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{eq_expr_value, is_else_clause, is_lang_item_or_ctor, peel_blocks_with_stmt, sym};
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem, PatKind, RustcVersion, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+use rustc_span::{Span, Symbol};
+use std::fmt;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for code to be replaced by `pop_if` methods.
+    ///
+    /// ### Why is this bad?
+    /// Using `pop_if` is more concise and idiomatic.
+    ///
+    /// ### Known issues
+    /// Currently, the lint does not handle the case where the
+    /// `if` condition is part of an `else if` branch.
+    ///
+    /// The lint also does not handle the case where
+    /// the popped value is assigned and used.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # use std::collections::VecDeque;
+    /// # let mut vec = vec![1, 2, 3, 4, 5];
+    /// # let mut deque: VecDeque<i32> = VecDeque::from([1, 2, 3, 4, 5]);
+    /// if vec.last().is_some_and(|x| *x > 5) {
+    ///     vec.pop().unwrap();
+    /// }
+    /// if deque.back().is_some_and(|x| *x > 5) {
+    ///     deque.pop_back().unwrap();
+    /// }
+    /// if deque.front().is_some_and(|x| *x > 5) {
+    ///     deque.pop_front().unwrap();
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::collections::VecDeque;
+    /// # let mut vec = vec![1, 2, 3, 4, 5];
+    /// # let mut deque: VecDeque<i32> = VecDeque::from([1, 2, 3, 4, 5]);
+    /// vec.pop_if(|x| *x > 5);
+    /// deque.pop_back_if(|x| *x > 5);
+    /// deque.pop_front_if(|x| *x > 5);
+    /// ```
+    #[clippy::version = "1.95.0"]
+    pub MANUAL_POP_IF,
+    complexity,
+    "manual implementation of `pop_if` methods"
+}
+
+impl_lint_pass!(ManualPopIf => [MANUAL_POP_IF]);
+
+pub struct ManualPopIf {
+    msrv: Msrv,
+}
+
+impl ManualPopIf {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
+#[allow(clippy::enum_variant_names)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ManualPopIfKind {
+    Vec,
+    VecDequeBack,
+    VecDequeFront,
+}
+
+impl ManualPopIfKind {
+    fn check_method(self) -> Symbol {
+        match self {
+            ManualPopIfKind::Vec => sym::last,
+            ManualPopIfKind::VecDequeBack => sym::back,
+            ManualPopIfKind::VecDequeFront => sym::front,
+        }
+    }
+
+    fn pop_method(self) -> Symbol {
+        match self {
+            ManualPopIfKind::Vec => sym::pop,
+            ManualPopIfKind::VecDequeBack => sym::pop_back,
+            ManualPopIfKind::VecDequeFront => sym::pop_front,
+        }
+    }
+
+    fn pop_if_method(self) -> Symbol {
+        match self {
+            ManualPopIfKind::Vec => sym::pop_if,
+            ManualPopIfKind::VecDequeBack => sym::pop_back_if,
+            ManualPopIfKind::VecDequeFront => sym::pop_front_if,
+        }
+    }
+
+    fn is_diag_item(self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+        let ty = cx.typeck_results().expr_ty(expr).peel_refs();
+        match self {
+            ManualPopIfKind::Vec => ty.is_diag_item(cx, sym::Vec),
+            ManualPopIfKind::VecDequeBack | ManualPopIfKind::VecDequeFront => ty.is_diag_item(cx, sym::VecDeque),
+        }
+    }
+
+    fn msrv(self) -> RustcVersion {
+        match self {
+            ManualPopIfKind::Vec => msrvs::VEC_POP_IF,
+            ManualPopIfKind::VecDequeBack => msrvs::VEC_DEQUE_POP_BACK_IF,
+            ManualPopIfKind::VecDequeFront => msrvs::VEC_DEQUE_POP_FRONT_IF,
+        }
+    }
+}
+
+impl fmt::Display for ManualPopIfKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ManualPopIfKind::Vec => write!(f, "`Vec::pop_if`"),
+            ManualPopIfKind::VecDequeBack => write!(f, "`VecDeque::pop_back_if`"),
+            ManualPopIfKind::VecDequeFront => write!(f, "`VecDeque::pop_front_if`"),
+        }
+    }
+}
+
+struct ManualPopIfPattern<'tcx> {
+    kind: ManualPopIfKind,
+
+    /// The collection (`vec` in `vec.last()`)
+    collection_expr: &'tcx Expr<'tcx>,
+
+    /// The closure (`*x > 5` in `|x| *x > 5`)
+    predicate: &'tcx Expr<'tcx>,
+
+    /// Parameter name for the closure (`x` in `|x| *x > 5`)
+    param_name: Symbol,
+
+    /// Span of the if expression (including the `if` keyword)
+    if_span: Span,
+}
+
+impl ManualPopIfPattern<'_> {
+    fn emit_lint(&self, cx: &LateContext<'_>) {
+        let mut app = Applicability::MachineApplicable;
+        let ctxt = self.if_span.ctxt();
+        let collection_snippet = snippet_with_context(cx, self.collection_expr.span, ctxt, "..", &mut app).0;
+        let predicate_snippet = snippet_with_context(cx, self.predicate.span, ctxt, "..", &mut app).0;
+        let param_name = self.param_name;
+        let pop_if_method = self.kind.pop_if_method();
+
+        let suggestion = format!("{collection_snippet}.{pop_if_method}(|{param_name}| {predicate_snippet});");
+
+        span_lint_and_sugg(
+            cx,
+            MANUAL_POP_IF,
+            self.if_span,
+            format!("manual implementation of {}", self.kind),
+            "try",
+            suggestion,
+            app,
+        );
+    }
+}
+
+fn pop_value_is_used(then_block: &Expr<'_>) -> bool {
+    let ExprKind::Block(block, _) = then_block.kind else {
+        return true;
+    };
+
+    if block.expr.is_some() {
+        return true;
+    }
+
+    match block.stmts {
+        [stmt] => !matches!(stmt.kind, StmtKind::Semi(_) | StmtKind::Item(_)),
+        [.., last] => matches!(last.kind, StmtKind::Expr(_)),
+        [] => false,
+    }
+}
+
+/// Checks for the pattern:
+/// ```ignore
+/// if vec.last().is_some_and(|x| *x > 5) {
+///     vec.pop().unwrap();
+/// }
+/// ```
+fn check_is_some_and_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    cond: &'tcx Expr<'_>,
+    then_block: &'tcx Expr<'_>,
+    if_expr_span: Span,
+    kind: ManualPopIfKind,
+) -> Option<ManualPopIfPattern<'tcx>> {
+    if pop_value_is_used(then_block) {
+        return None;
+    }
+
+    let check_method = kind.check_method();
+    let pop_method = kind.pop_method();
+
+    if let ExprKind::MethodCall(path, receiver, [closure_arg], _) = cond.kind
+        && path.ident.name == sym::is_some_and
+        && let ExprKind::MethodCall(check_path, collection_expr, [], _) = receiver.kind
+        && check_path.ident.name == check_method
+        && kind.is_diag_item(cx, collection_expr)
+        && let ExprKind::Closure(closure) = closure_arg.kind
+        && let body = cx.tcx.hir_body(closure.body)
+        && let Some((pop_collection, _pop_span)) = check_pop_unwrap(then_block, pop_method)
+        && eq_expr_value(cx, collection_expr, pop_collection)
+        && let Some(param) = body.params.first()
+        && let Some(ident) = param.pat.simple_ident()
+    {
+        return Some(ManualPopIfPattern {
+            kind,
+            collection_expr,
+            predicate: body.value,
+            param_name: ident.name,
+            if_span: if_expr_span,
+        });
+    }
+
+    None
+}
+
+/// Checks for the pattern:
+/// ```ignore
+/// if let Some(x) = vec.last() {
+///     if *x > 5 {
+///         vec.pop().unwrap();
+///     }
+/// }
+/// ```
+fn check_if_let_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    cond: &'tcx Expr<'_>,
+    then_block: &'tcx Expr<'_>,
+    if_expr_span: Span,
+    kind: ManualPopIfKind,
+) -> Option<ManualPopIfPattern<'tcx>> {
+    let check_method = kind.check_method();
+    let pop_method = kind.pop_method();
+
+    if let ExprKind::Let(let_expr) = cond.kind
+        && let PatKind::TupleStruct(qpath, [binding_pat], _) = let_expr.pat.kind
+    {
+        let res = cx.qpath_res(&qpath, let_expr.pat.hir_id);
+
+        if let Some(def_id) = res.opt_def_id()
+            && is_lang_item_or_ctor(cx, def_id, LangItem::OptionSome)
+            && let PatKind::Binding(_, binding_id, binding_name, _) = binding_pat.kind
+            && let ExprKind::MethodCall(path, collection_expr, [], _) = let_expr.init.kind
+            && path.ident.name == check_method
+            && kind.is_diag_item(cx, collection_expr)
+            && let ExprKind::Block(block, _) = then_block.kind
+        {
+            // The inner if can be either a statement or a block expression
+            let inner_if = match (block.stmts, block.expr) {
+                ([stmt], _) => match stmt.kind {
+                    StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
+                    _ => return None,
+                },
+                ([], Some(expr)) => expr,
+                _ => return None,
+            };
+
+            if let ExprKind::If(inner_cond, inner_then, None) = inner_if.kind
+                && is_local_used(cx, inner_cond, binding_id)
+                && !pop_value_is_used(inner_then)
+                && let Some((pop_collection, _pop_span)) = check_pop_unwrap(inner_then, pop_method)
+                && eq_expr_value(cx, collection_expr, pop_collection)
+            {
+                return Some(ManualPopIfPattern {
+                    kind,
+                    collection_expr,
+                    predicate: inner_cond,
+                    param_name: binding_name.name,
+                    if_span: if_expr_span,
+                });
+            }
+        }
+    }
+
+    None
+}
+
+/// Checks for the pattern:
+/// ```ignore
+/// if let Some(x) = vec.last() && *x > 5 {
+///     vec.pop().unwrap();
+/// }
+/// ```
+fn check_let_chain_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    cond: &'tcx Expr<'_>,
+    then_block: &'tcx Expr<'_>,
+    if_expr_span: Span,
+    kind: ManualPopIfKind,
+) -> Option<ManualPopIfPattern<'tcx>> {
+    if pop_value_is_used(then_block) {
+        return None;
+    }
+
+    let check_method = kind.check_method();
+    let pop_method = kind.pop_method();
+
+    if let ExprKind::Binary(op, left, right) = cond.kind
+        && op.node == rustc_ast::BinOpKind::And
+        && let ExprKind::Let(let_expr) = left.kind
+        && let PatKind::TupleStruct(qpath, [binding_pat], _) = let_expr.pat.kind
+    {
+        let res = cx.qpath_res(&qpath, let_expr.pat.hir_id);
+
+        if let Some(def_id) = res.opt_def_id()
+            && is_lang_item_or_ctor(cx, def_id, LangItem::OptionSome)
+            && let PatKind::Binding(_, binding_id, binding_name, _) = binding_pat.kind
+            && let ExprKind::MethodCall(path, collection_expr, [], _) = let_expr.init.kind
+            && path.ident.name == check_method
+            && kind.is_diag_item(cx, collection_expr)
+            && is_local_used(cx, right, binding_id)
+            && !pop_value_is_used(then_block)
+            && let Some((pop_collection, _pop_span)) = check_pop_unwrap(then_block, pop_method)
+            && eq_expr_value(cx, collection_expr, pop_collection)
+        {
+            return Some(ManualPopIfPattern {
+                kind,
+                collection_expr,
+                predicate: right,
+                param_name: binding_name.name,
+                if_span: if_expr_span,
+            });
+        }
+    }
+
+    None
+}
+
+/// Checks for the pattern:
+/// ```ignore
+/// if vec.last().map(|x| *x > 5).unwrap_or(false) {
+///     vec.pop().unwrap();
+/// }
+/// ```
+fn check_map_unwrap_or_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    cond: &'tcx Expr<'_>,
+    then_block: &'tcx Expr<'_>,
+    if_expr_span: Span,
+    kind: ManualPopIfKind,
+) -> Option<ManualPopIfPattern<'tcx>> {
+    if pop_value_is_used(then_block) {
+        return None;
+    }
+
+    let check_method = kind.check_method();
+    let pop_method = kind.pop_method();
+
+    if let ExprKind::MethodCall(unwrap_path, receiver, [default_arg], _) = cond.kind
+        && unwrap_path.ident.name == sym::unwrap_or
+        && matches!(default_arg.kind, ExprKind::Lit(lit) if matches!(lit.node, LitKind::Bool(false)))
+        && let ExprKind::MethodCall(map_path, map_receiver, [closure_arg], _) = receiver.kind
+        && map_path.ident.name == sym::map
+        && let ExprKind::MethodCall(check_path, collection_expr, [], _) = map_receiver.kind
+        && check_path.ident.name == check_method
+        && kind.is_diag_item(cx, collection_expr)
+        && let ExprKind::Closure(closure) = closure_arg.kind
+        && let body = cx.tcx.hir_body(closure.body)
+        && cx.typeck_results().expr_ty(body.value).is_bool()
+        && let Some((pop_collection, _pop_span)) = check_pop_unwrap(then_block, pop_method)
+        && eq_expr_value(cx, collection_expr, pop_collection)
+        && let Some(param) = body.params.first()
+        && let Some(ident) = param.pat.simple_ident()
+    {
+        return Some(ManualPopIfPattern {
+            kind,
+            collection_expr,
+            predicate: body.value,
+            param_name: ident.name,
+            if_span: if_expr_span,
+        });
+    }
+
+    None
+}
+
+/// Checks for `collection.<pop_method>().unwrap()` or `collection.<pop_method>().expect(..)`
+/// and returns the collection and the span of the peeled expr
+fn check_pop_unwrap<'tcx>(expr: &'tcx Expr<'_>, pop_method: Symbol) -> Option<(&'tcx Expr<'tcx>, Span)> {
+    let inner_expr = peel_blocks_with_stmt(expr);
+
+    if let ExprKind::MethodCall(unwrap_path, receiver, _, _) = inner_expr.kind
+        && matches!(unwrap_path.ident.name, sym::unwrap | sym::expect)
+        && let ExprKind::MethodCall(pop_path, collection_expr, [], _) = receiver.kind
+        && pop_path.ident.name == pop_method
+    {
+        return Some((collection_expr, inner_expr.span));
+    }
+
+    None
+}
+
+impl<'tcx> LateLintPass<'tcx> for ManualPopIf {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let ExprKind::If(cond, then_block, None) = expr.kind else {
+            return;
+        };
+
+        // Do not lint if we are in an else-if branch.
+        if is_else_clause(cx.tcx, expr) {
+            return;
+        }
+
+        for kind in [
+            ManualPopIfKind::Vec,
+            ManualPopIfKind::VecDequeBack,
+            ManualPopIfKind::VecDequeFront,
+        ] {
+            if let Some(pattern) = check_is_some_and_pattern(cx, cond, then_block, expr.span, kind)
+                .or_else(|| check_if_let_pattern(cx, cond, then_block, expr.span, kind))
+                .or_else(|| check_let_chain_pattern(cx, cond, then_block, expr.span, kind))
+                .or_else(|| check_map_unwrap_or_pattern(cx, cond, then_block, expr.span, kind))
+                && self.msrv.meets(cx, kind.msrv())
+            {
+                pattern.emit_lint(cx);
+                return;
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 5aa457b9d19c..ecadc3322e14 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -23,9 +23,11 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,93,0 { VEC_DEQUE_POP_BACK_IF, VEC_DEQUE_POP_FRONT_IF }
     1,91,0 { DURATION_FROM_MINUTES_HOURS }
     1,88,0 { LET_CHAINS }
     1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
+    1,86,0 { VEC_POP_IF }
     1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL }
     1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
     1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index d6ba678434bc..bb67e4350d2b 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -140,6 +140,7 @@ macro_rules! generate {
     as_str,
     assert_failed,
     author,
+    back,
     binaryheap_iter,
     bool_then,
     borrow,
@@ -295,6 +296,7 @@ macro_rules! generate {
     from_str_method,
     from_str_radix,
     from_weeks,
+    front,
     fs,
     fs_create_dir,
     fuse,
@@ -464,6 +466,12 @@ macro_rules! generate {
     peekable,
     permissions_from_mode,
     pin_macro,
+    pop,
+    pop_back,
+    pop_back_if,
+    pop_front,
+    pop_front_if,
+    pop_if,
     position,
     pow,
     powf,
diff --git a/tests/ui/manual_pop_if.fixed b/tests/ui/manual_pop_if.fixed
new file mode 100644
index 000000000000..6e30786c8097
--- /dev/null
+++ b/tests/ui/manual_pop_if.fixed
@@ -0,0 +1,247 @@
+#![warn(clippy::manual_pop_if)]
+#![allow(clippy::collapsible_if, clippy::redundant_closure)]
+
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+
+// FakeVec has the same methods as Vec but isn't actually a Vec
+struct FakeVec<T>(PhantomData<T>);
+
+impl<T> FakeVec<T> {
+    fn last(&self) -> Option<&T> {
+        None
+    }
+
+    fn pop(&mut self) -> Option<T> {
+        None
+    }
+}
+
+fn is_some_and_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    vec.pop_if(|x| *x > 2);
+
+    vec.pop_if(|x| *x > 2);
+
+    deque.pop_back_if(|x| *x > 2);
+
+    deque.pop_front_if(|x| *x > 2);
+}
+
+fn is_some_and_pattern_negative(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if vec.last().is_some_and(|x| *x > 2) {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, non-Vec type
+    let mut fake_vec: FakeVec<i32> = FakeVec(PhantomData);
+    if fake_vec.last().is_some_and(|x| *x > 2) {
+        fake_vec.pop().unwrap();
+    }
+
+    // Do not lint, else-if branch
+    if false {
+        // something
+    } else if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if vec.last().is_some_and(|x| *x > 2) {
+        let _value = vec.pop().unwrap();
+        println!("Popped: {}", _value);
+    }
+
+    // Do not lint, value used in expression
+    if vec.last().is_some_and(|x| *x > 2) {
+        println!("Popped: {}", vec.pop().unwrap());
+    }
+
+    // Do not lint, else block
+    let _result = if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+fn if_let_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    vec.pop_if(|x| *x > 2);
+
+    vec.pop_if(|x| *x > 2);
+
+    deque.pop_back_if(|x| *x > 2);
+
+    deque.pop_front_if(|x| *x > 2);
+}
+
+fn if_let_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if let Some(x) = vec.last() {
+        if *x > 2 {
+            vec2.pop().unwrap();
+        }
+    }
+
+    // Do not lint, intervening statements
+    if let Some(x) = vec.last() {
+        println!("Checking {}", x);
+        if *x > 2 {
+            vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, bound variable not used in condition
+    if let Some(_x) = vec.last() {
+        if vec.len() > 2 {
+            vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, value used in let binding
+    if let Some(x) = vec.last() {
+        if *x > 2 {
+            let _val = vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, else block
+    let _result = if let Some(x) = vec.last() {
+        if *x > 2 { vec.pop().unwrap() } else { 0 }
+    } else {
+        0
+    };
+}
+
+fn let_chain_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    vec.pop_if(|x| *x > 2);
+
+    vec.pop_if(|x| *x > 2);
+
+    deque.pop_back_if(|x| *x > 2);
+
+    deque.pop_front_if(|x| *x > 2);
+}
+
+fn let_chain_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, bound variable not used in condition
+    if let Some(_x) = vec.last()
+        && vec.len() > 2
+    {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        let _val = vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in expression
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        println!("Popped: {}", vec.pop().unwrap());
+    }
+
+    // Do not lint, else block
+    let _result = if let Some(x) = vec.last()
+        && *x > 2
+    {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+fn map_unwrap_or_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    vec.pop_if(|x| *x > 2);
+
+    vec.pop_if(|x| *x > 2);
+
+    deque.pop_back_if(|x| *x > 2);
+
+    deque.pop_front_if(|x| *x > 2);
+}
+
+fn map_unwrap_or_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, unwrap_or(true) instead of false
+    if vec.last().map(|x| *x > 2).unwrap_or(true) {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, non-Vec type
+    let mut fake_vec: FakeVec<i32> = FakeVec(PhantomData);
+    if fake_vec.last().map(|x| *x > 2).unwrap_or(false) {
+        fake_vec.pop().unwrap();
+    }
+
+    // Do not lint, map returns non-boolean
+    if vec.last().map(|x| x + 1).unwrap_or(0) > 2 {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        let _val = vec.pop().unwrap();
+    }
+
+    // Do not lint, else block
+    let _result = if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+// this makes sure we do not expand vec![] in the suggestion
+fn handle_macro_in_closure(mut vec: Vec<Vec<i32>>) {
+    vec.pop_if(|e| *e == vec![1]);
+}
+
+#[clippy::msrv = "1.85.0"]
+fn msrv_too_low_vec(mut vec: Vec<i32>) {
+    if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.92.0"]
+fn msrv_too_low_vecdeque(mut deque: VecDeque<i32>) {
+    if deque.back().is_some_and(|x| *x > 2) {
+        deque.pop_back().unwrap();
+    }
+
+    if deque.front().is_some_and(|x| *x > 2) {
+        deque.pop_front().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.86.0"]
+fn msrv_high_enough_vec(mut vec: Vec<i32>) {
+    vec.pop_if(|x| *x > 2);
+}
+
+#[clippy::msrv = "1.93.0"]
+fn msrv_high_enough_vecdeque(mut deque: VecDeque<i32>) {
+    deque.pop_back_if(|x| *x > 2);
+
+    deque.pop_front_if(|x| *x > 2);
+}
diff --git a/tests/ui/manual_pop_if.rs b/tests/ui/manual_pop_if.rs
new file mode 100644
index 000000000000..a2f679dfc6b3
--- /dev/null
+++ b/tests/ui/manual_pop_if.rs
@@ -0,0 +1,319 @@
+#![warn(clippy::manual_pop_if)]
+#![allow(clippy::collapsible_if, clippy::redundant_closure)]
+
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+
+// FakeVec has the same methods as Vec but isn't actually a Vec
+struct FakeVec<T>(PhantomData<T>);
+
+impl<T> FakeVec<T> {
+    fn last(&self) -> Option<&T> {
+        None
+    }
+
+    fn pop(&mut self) -> Option<T> {
+        None
+    }
+}
+
+fn is_some_and_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    if vec.last().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        vec.pop().unwrap();
+    }
+
+    if vec.last().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        vec.pop().expect("element");
+    }
+
+    if deque.back().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        deque.pop_back().unwrap();
+    }
+
+    if deque.front().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        deque.pop_front().unwrap();
+    }
+}
+
+fn is_some_and_pattern_negative(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if vec.last().is_some_and(|x| *x > 2) {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, non-Vec type
+    let mut fake_vec: FakeVec<i32> = FakeVec(PhantomData);
+    if fake_vec.last().is_some_and(|x| *x > 2) {
+        fake_vec.pop().unwrap();
+    }
+
+    // Do not lint, else-if branch
+    if false {
+        // something
+    } else if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if vec.last().is_some_and(|x| *x > 2) {
+        let _value = vec.pop().unwrap();
+        println!("Popped: {}", _value);
+    }
+
+    // Do not lint, value used in expression
+    if vec.last().is_some_and(|x| *x > 2) {
+        println!("Popped: {}", vec.pop().unwrap());
+    }
+
+    // Do not lint, else block
+    let _result = if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+fn if_let_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    if let Some(x) = vec.last() {
+        //~^ manual_pop_if
+        if *x > 2 {
+            vec.pop().unwrap();
+        }
+    }
+
+    if let Some(x) = vec.last() {
+        //~^ manual_pop_if
+        if *x > 2 {
+            vec.pop().expect("element");
+        }
+    }
+
+    if let Some(x) = deque.back() {
+        //~^ manual_pop_if
+        if *x > 2 {
+            deque.pop_back().unwrap();
+        }
+    }
+
+    if let Some(x) = deque.front() {
+        //~^ manual_pop_if
+        if *x > 2 {
+            deque.pop_front().unwrap();
+        }
+    }
+}
+
+fn if_let_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if let Some(x) = vec.last() {
+        if *x > 2 {
+            vec2.pop().unwrap();
+        }
+    }
+
+    // Do not lint, intervening statements
+    if let Some(x) = vec.last() {
+        println!("Checking {}", x);
+        if *x > 2 {
+            vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, bound variable not used in condition
+    if let Some(_x) = vec.last() {
+        if vec.len() > 2 {
+            vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, value used in let binding
+    if let Some(x) = vec.last() {
+        if *x > 2 {
+            let _val = vec.pop().unwrap();
+        }
+    }
+
+    // Do not lint, else block
+    let _result = if let Some(x) = vec.last() {
+        if *x > 2 { vec.pop().unwrap() } else { 0 }
+    } else {
+        0
+    };
+}
+
+fn let_chain_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    if let Some(x) = vec.last() //~ manual_pop_if
+        && *x > 2
+    {
+        vec.pop().unwrap();
+    }
+
+    if let Some(x) = vec.last() //~ manual_pop_if
+        && *x > 2
+    {
+        vec.pop().expect("element");
+    }
+
+    if let Some(x) = deque.back() //~ manual_pop_if
+        && *x > 2
+    {
+        deque.pop_back().unwrap();
+    }
+
+    if let Some(x) = deque.front() //~ manual_pop_if
+        && *x > 2
+    {
+        deque.pop_front().unwrap();
+    }
+}
+
+fn let_chain_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, bound variable not used in condition
+    if let Some(_x) = vec.last()
+        && vec.len() > 2
+    {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        let _val = vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in expression
+    if let Some(x) = vec.last()
+        && *x > 2
+    {
+        println!("Popped: {}", vec.pop().unwrap());
+    }
+
+    // Do not lint, else block
+    let _result = if let Some(x) = vec.last()
+        && *x > 2
+    {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+fn map_unwrap_or_pattern_positive(mut vec: Vec<i32>, mut deque: VecDeque<i32>) {
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        //~^ manual_pop_if
+        vec.pop().unwrap();
+    }
+
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        //~^ manual_pop_if
+        vec.pop().expect("element");
+    }
+
+    if deque.back().map(|x| *x > 2).unwrap_or(false) {
+        //~^ manual_pop_if
+        deque.pop_back().unwrap();
+    }
+
+    if deque.front().map(|x| *x > 2).unwrap_or(false) {
+        //~^ manual_pop_if
+        deque.pop_front().unwrap();
+    }
+}
+
+fn map_unwrap_or_pattern_negative(mut vec: Vec<i32>) {
+    // Do not lint, unwrap_or(true) instead of false
+    if vec.last().map(|x| *x > 2).unwrap_or(true) {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, different vectors
+    let mut vec2 = vec![0];
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        vec2.pop().unwrap();
+    }
+
+    // Do not lint, non-Vec type
+    let mut fake_vec: FakeVec<i32> = FakeVec(PhantomData);
+    if fake_vec.last().map(|x| *x > 2).unwrap_or(false) {
+        fake_vec.pop().unwrap();
+    }
+
+    // Do not lint, map returns non-boolean
+    if vec.last().map(|x| x + 1).unwrap_or(0) > 2 {
+        vec.pop().unwrap();
+    }
+
+    // Do not lint, value used in let binding
+    if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        let _val = vec.pop().unwrap();
+    }
+
+    // Do not lint, else block
+    let _result = if vec.last().map(|x| *x > 2).unwrap_or(false) {
+        vec.pop().unwrap()
+    } else {
+        0
+    };
+}
+
+// this makes sure we do not expand vec![] in the suggestion
+fn handle_macro_in_closure(mut vec: Vec<Vec<i32>>) {
+    if vec.last().is_some_and(|e| *e == vec![1]) {
+        //~^ manual_pop_if
+        vec.pop().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.85.0"]
+fn msrv_too_low_vec(mut vec: Vec<i32>) {
+    if vec.last().is_some_and(|x| *x > 2) {
+        vec.pop().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.92.0"]
+fn msrv_too_low_vecdeque(mut deque: VecDeque<i32>) {
+    if deque.back().is_some_and(|x| *x > 2) {
+        deque.pop_back().unwrap();
+    }
+
+    if deque.front().is_some_and(|x| *x > 2) {
+        deque.pop_front().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.86.0"]
+fn msrv_high_enough_vec(mut vec: Vec<i32>) {
+    if vec.last().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        vec.pop().unwrap();
+    }
+}
+
+#[clippy::msrv = "1.93.0"]
+fn msrv_high_enough_vecdeque(mut deque: VecDeque<i32>) {
+    if deque.back().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        deque.pop_back().unwrap();
+    }
+
+    if deque.front().is_some_and(|x| *x > 2) {
+        //~^ manual_pop_if
+        deque.pop_front().unwrap();
+    }
+}
diff --git a/tests/ui/manual_pop_if.stderr b/tests/ui/manual_pop_if.stderr
new file mode 100644
index 000000000000..d57e20dc6205
--- /dev/null
+++ b/tests/ui/manual_pop_if.stderr
@@ -0,0 +1,197 @@
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:21:5
+   |
+LL | /     if vec.last().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         vec.pop().unwrap();
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+   |
+   = note: `-D clippy::manual-pop-if` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_pop_if)]`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:26:5
+   |
+LL | /     if vec.last().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         vec.pop().expect("element");
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_back_if`
+  --> tests/ui/manual_pop_if.rs:31:5
+   |
+LL | /     if deque.back().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         deque.pop_back().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_back_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_front_if`
+  --> tests/ui/manual_pop_if.rs:36:5
+   |
+LL | /     if deque.front().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         deque.pop_front().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_front_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:82:5
+   |
+LL | /     if let Some(x) = vec.last() {
+LL | |
+LL | |         if *x > 2 {
+LL | |             vec.pop().unwrap();
+LL | |         }
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:89:5
+   |
+LL | /     if let Some(x) = vec.last() {
+LL | |
+LL | |         if *x > 2 {
+LL | |             vec.pop().expect("element");
+LL | |         }
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_back_if`
+  --> tests/ui/manual_pop_if.rs:96:5
+   |
+LL | /     if let Some(x) = deque.back() {
+LL | |
+LL | |         if *x > 2 {
+LL | |             deque.pop_back().unwrap();
+LL | |         }
+LL | |     }
+   | |_____^ help: try: `deque.pop_back_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_front_if`
+  --> tests/ui/manual_pop_if.rs:103:5
+   |
+LL | /     if let Some(x) = deque.front() {
+LL | |
+LL | |         if *x > 2 {
+LL | |             deque.pop_front().unwrap();
+LL | |         }
+LL | |     }
+   | |_____^ help: try: `deque.pop_front_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:151:5
+   |
+LL | /     if let Some(x) = vec.last()
+LL | |         && *x > 2
+LL | |     {
+LL | |         vec.pop().unwrap();
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:157:5
+   |
+LL | /     if let Some(x) = vec.last()
+LL | |         && *x > 2
+LL | |     {
+LL | |         vec.pop().expect("element");
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_back_if`
+  --> tests/ui/manual_pop_if.rs:163:5
+   |
+LL | /     if let Some(x) = deque.back()
+LL | |         && *x > 2
+LL | |     {
+LL | |         deque.pop_back().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_back_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_front_if`
+  --> tests/ui/manual_pop_if.rs:169:5
+   |
+LL | /     if let Some(x) = deque.front()
+LL | |         && *x > 2
+LL | |     {
+LL | |         deque.pop_front().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_front_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:217:5
+   |
+LL | /     if vec.last().map(|x| *x > 2).unwrap_or(false) {
+LL | |
+LL | |         vec.pop().unwrap();
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:222:5
+   |
+LL | /     if vec.last().map(|x| *x > 2).unwrap_or(false) {
+LL | |
+LL | |         vec.pop().expect("element");
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_back_if`
+  --> tests/ui/manual_pop_if.rs:227:5
+   |
+LL | /     if deque.back().map(|x| *x > 2).unwrap_or(false) {
+LL | |
+LL | |         deque.pop_back().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_back_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_front_if`
+  --> tests/ui/manual_pop_if.rs:232:5
+   |
+LL | /     if deque.front().map(|x| *x > 2).unwrap_or(false) {
+LL | |
+LL | |         deque.pop_front().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_front_if(|x| *x > 2);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:276:5
+   |
+LL | /     if vec.last().is_some_and(|e| *e == vec![1]) {
+LL | |
+LL | |         vec.pop().unwrap();
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|e| *e == vec![1]);`
+
+error: manual implementation of `Vec::pop_if`
+  --> tests/ui/manual_pop_if.rs:302:5
+   |
+LL | /     if vec.last().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         vec.pop().unwrap();
+LL | |     }
+   | |_____^ help: try: `vec.pop_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_back_if`
+  --> tests/ui/manual_pop_if.rs:310:5
+   |
+LL | /     if deque.back().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         deque.pop_back().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_back_if(|x| *x > 2);`
+
+error: manual implementation of `VecDeque::pop_front_if`
+  --> tests/ui/manual_pop_if.rs:315:5
+   |
+LL | /     if deque.front().is_some_and(|x| *x > 2) {
+LL | |
+LL | |         deque.pop_front().unwrap();
+LL | |     }
+   | |_____^ help: try: `deque.pop_front_if(|x| *x > 2);`
+
+error: aborting due to 20 previous errors
+

From b5f63104b26781131c6eb252c5f2ef2c4e1df956 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 5 Mar 2026 14:22:13 +0100
Subject: [PATCH 0139/1059] Do not materialize snippets when it is not needed
 to

It is not necessary to materialize snippets into `String` objects just
to check if they contain comments for example.
---
 clippy_lints/src/bool_to_int_with_if.rs       |  3 +-
 clippy_lints/src/collapsible_if.rs            | 54 +++++++++----------
 clippy_lints/src/loops/manual_flatten.rs      |  4 +-
 clippy_lints/src/loops/manual_slice_fill.rs   |  4 +-
 clippy_lints/src/manual_abs_diff.rs           |  6 +--
 clippy_lints/src/manual_assert.rs             |  2 +-
 clippy_lints/src/matches/collapsible_match.rs |  2 +-
 clippy_lints/src/matches/manual_ok_err.rs     |  4 +-
 clippy_lints/src/matches/manual_unwrap_or.rs  |  4 +-
 .../src/matches/match_like_matches.rs         |  6 +--
 clippy_lints/src/matches/mod.rs               |  5 +-
 clippy_lints/src/methods/iter_filter.rs       |  4 +-
 clippy_lints/src/methods/map_flatten.rs       |  2 +-
 clippy_lints/src/needless_bool.rs             |  2 +-
 clippy_lints/src/question_mark.rs             |  2 +-
 .../src/slow_vector_initialization.rs         |  2 +-
 clippy_lints/src/useless_vec.rs               |  2 +-
 clippy_lints/src/write/empty_string.rs        |  2 +-
 clippy_utils/src/lib.rs                       | 45 ++++++++--------
 19 files changed, 75 insertions(+), 80 deletions(-)

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index b98a20a90ccb..8b45473687e6 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::HasSession;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{higher, is_else_clause, is_in_const_context, span_contains_comment};
 use rustc_ast::LitKind;
@@ -60,7 +59,7 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             && !is_in_const_context(cx)
         {
             let ty = cx.typeck_results().expr_ty(then);
-            let mut applicability = if span_contains_comment(cx.sess().source_map(), expr.span) {
+            let mut applicability = if span_contains_comment(cx, expr.span) {
                 Applicability::MaybeIncorrect
             } else {
                 Applicability::MachineApplicable
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index a76027caebc8..3850c55c49f8 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
+use clippy_utils::source::{HasSession, IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
 use clippy_utils::{can_use_if_let_chains, span_contains_non_whitespace, sym, tokenize_with_text};
 use rustc_ast::{BinOpKind, MetaItemInner};
 use rustc_errors::Applicability;
@@ -9,7 +9,6 @@
 use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass, Level};
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Span, Symbol};
 
 declare_clippy_lint! {
@@ -111,10 +110,8 @@ fn check_collapsible_else_if(&self, cx: &LateContext<'_>, then_span: Span, else_
                     let up_to_else = then_span.between(else_block.span);
                     let else_before_if = else_.span.shrink_to_lo().with_hi(else_if_cond.span.lo() - BytePos(1));
                     if self.lint_commented_code
-                        && let Some(else_keyword_span) =
-                            span_extract_keyword(cx.tcx.sess.source_map(), up_to_else, "else")
-                        && let Some(else_if_keyword_span) =
-                            span_extract_keyword(cx.tcx.sess.source_map(), else_before_if, "if")
+                        && let Some(else_keyword_span) = span_extract_keyword(cx, up_to_else, "else")
+                        && let Some(else_if_keyword_span) = span_extract_keyword(cx, else_before_if, "if")
                     {
                         let else_keyword_span = else_keyword_span.with_leading_whitespace(cx).into_span();
                         let else_open_bracket = else_block.span.split_at(1).0.with_leading_whitespace(cx).into_span();
@@ -139,7 +136,7 @@ fn check_collapsible_else_if(&self, cx: &LateContext<'_>, then_span: Span, else_
                     }
 
                     // Peel off any parentheses.
-                    let (_, else_block_span, _) = peel_parens(cx.tcx.sess.source_map(), else_.span);
+                    let (_, else_block_span, _) = peel_parens(cx, else_.span);
 
                     // Prevent "elseif"
                     // Check that the "else" is followed by whitespace
@@ -187,7 +184,7 @@ fn check_collapsible_if_if(&self, cx: &LateContext<'_>, expr: &Expr<'_>, check:
                             .with_leading_whitespace(cx)
                             .into_span()
                     };
-                    let (paren_start, inner_if_span, paren_end) = peel_parens(cx.tcx.sess.source_map(), inner.span);
+                    let (paren_start, inner_if_span, paren_end) = peel_parens(cx, inner.span);
                     let inner_if = inner_if_span.split_at(2).0;
                     let mut sugg = vec![
                         // Remove the outer then block `{`
@@ -320,33 +317,36 @@ pub(super) fn parens_around(expr: &Expr<'_>) -> Vec<(Span, String)> {
     }
 }
 
-fn span_extract_keyword(sm: &SourceMap, span: Span, keyword: &str) -> Option<Span> {
-    let snippet = sm.span_to_snippet(span).ok()?;
-    tokenize_with_text(&snippet)
-        .filter(|(t, s, _)| matches!(t, TokenKind::Ident if *s == keyword))
-        .map(|(_, _, inner)| {
-            span.split_at(u32::try_from(inner.start).unwrap())
-                .1
-                .split_at(u32::try_from(inner.end - inner.start).unwrap())
-                .0
-        })
-        .next()
+fn span_extract_keyword(cx: &impl HasSession, span: Span, keyword: &str) -> Option<Span> {
+    span.with_source_text(cx, |snippet| {
+        tokenize_with_text(snippet)
+            .filter(|(t, s, _)| matches!(t, TokenKind::Ident if *s == keyword))
+            .map(|(_, _, inner)| {
+                span.split_at(u32::try_from(inner.start).unwrap())
+                    .1
+                    .split_at(u32::try_from(inner.end - inner.start).unwrap())
+                    .0
+            })
+            .next()
+    })
+    .flatten()
 }
 
 /// Peel the parentheses from an `if` expression, e.g. `((if true {} else {}))`.
-pub(super) fn peel_parens(sm: &SourceMap, mut span: Span) -> (Span, Span, Span) {
+pub(super) fn peel_parens(cx: &impl HasSession, mut span: Span) -> (Span, Span, Span) {
     use crate::rustc_span::Pos;
 
     let start = span.shrink_to_lo();
     let end = span.shrink_to_hi();
 
-    let snippet = sm.span_to_snippet(span).unwrap();
-    if let Some((trim_start, _, trim_end)) = peel_parens_str(&snippet) {
-        let mut data = span.data();
-        data.lo = data.lo + BytePos::from_usize(trim_start);
-        data.hi = data.hi - BytePos::from_usize(trim_end);
-        span = data.span();
-    }
+    span.with_source_text(cx, |snippet| {
+        if let Some((trim_start, _, trim_end)) = peel_parens_str(snippet) {
+            let mut data = span.data();
+            data.lo = data.lo + BytePos::from_usize(trim_start);
+            data.hi = data.hi - BytePos::from_usize(trim_end);
+            span = data.span();
+        }
+    });
 
     (start.with_hi(span.lo()), span, end.with_lo(span.hi()))
 }
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 96de118b5233..2c89afc73974 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -3,7 +3,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeResPath;
-use clippy_utils::source::{HasSession, indent_of, reindent_multiline, snippet_with_applicability};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_with_applicability};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{higher, is_refutable, peel_blocks_with_stmt, span_contains_comment};
 use rustc_errors::Applicability;
@@ -50,7 +50,7 @@ pub(super) fn check<'tcx>(
             format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
 
         // Prepare the help message
-        let mut applicability = if span_contains_comment(cx.sess().source_map(), body.span) {
+        let mut applicability = if span_contains_comment(cx, body.span) {
             Applicability::MaybeIncorrect
         } else {
             Applicability::MachineApplicable
diff --git a/clippy_lints/src/loops/manual_slice_fill.rs b/clippy_lints/src/loops/manual_slice_fill.rs
index a2ff60a3d8ac..f91e3e6d597f 100644
--- a/clippy_lints/src/loops/manual_slice_fill.rs
+++ b/clippy_lints/src/loops/manual_slice_fill.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{HasSession, snippet_with_applicability};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{implements_trait, is_slice_like};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{higher, peel_blocks_with_stmt, span_contains_comment};
@@ -94,7 +94,7 @@ fn sugg<'tcx>(
     slice_span: rustc_span::Span,
     assignval_span: rustc_span::Span,
 ) {
-    let mut app = if span_contains_comment(cx.sess().source_map(), body.span) {
+    let mut app = if span_contains_comment(cx, body.span) {
         Applicability::MaybeIncorrect // Comments may be informational.
     } else {
         Applicability::MachineApplicable
diff --git a/clippy_lints/src/manual_abs_diff.rs b/clippy_lints/src/manual_abs_diff.rs
index e3886517fdd3..400cfcd18f2c 100644
--- a/clippy_lints/src/manual_abs_diff.rs
+++ b/clippy_lints/src/manual_abs_diff.rs
@@ -3,7 +3,6 @@
 use clippy_utils::higher::If;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::HasSession as _;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::peel_and_count_ty_refs;
 use clippy_utils::{eq_expr_value, peel_blocks, span_contains_comment, sym};
@@ -76,10 +75,7 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
                         (a, b) = (b, a);
                     }
                     let applicability = {
-                        let source_map = cx.sess().source_map();
-                        if span_contains_comment(source_map, if_expr.then.span)
-                            || span_contains_comment(source_map, r#else.span)
-                        {
+                        if span_contains_comment(cx, if_expr.then.span) || span_contains_comment(cx, r#else.span) {
                             Applicability::MaybeIncorrect
                         } else {
                             Applicability::MachineApplicable
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index c34e0d33e713..c77133130ba4 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -58,7 +58,7 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
                 "only a `panic!` in `if`-then statement",
                 |diag| {
                     let mut applicability = Applicability::MachineApplicable;
-                    let mut comments = span_extract_comment(cx.sess().source_map(), expr.span);
+                    let mut comments = span_extract_comment(cx, expr.span);
                     if !comments.is_empty() {
                         comments += "\n";
                     }
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index c95a72da6e29..de5f83b4745f 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -154,7 +154,7 @@ fn check_arm<'tcx>(
                 } else {
                     outer_pat.span.shrink_to_hi()
                 };
-                let (paren_start, inner_if_span, paren_end) = peel_parens(cx.tcx.sess.source_map(), inner_expr.span);
+                let (paren_start, inner_if_span, paren_end) = peel_parens(cx, inner_expr.span);
                 let inner_if = inner_if_span.split_at(2).0;
                 let mut sugg = vec![
                     (inner.then.span.shrink_to_lo(), "=> ".to_string()),
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index 1fc8bb9acce2..abbf60019c5c 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -9,7 +9,7 @@
 use rustc_hir::LangItem::ResultErr;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath};
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::symbol::Ident;
 
@@ -130,7 +130,7 @@ fn is_none(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 /// `err`, depending on `is_ok`.
 fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok: bool) {
     let method = if is_ok { "ok" } else { "err" };
-    let mut app = if span_contains_comment(cx.sess().source_map(), expr.span) {
+    let mut app = if span_contains_comment(cx, expr.span) {
         Applicability::MaybeIncorrect
     } else {
         Applicability::MachineApplicable
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 421c6064284d..e3a112d1f780 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -5,7 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Arm, Expr, ExprKind, HirId, LangItem, Pat, PatExpr, PatExprKind, PatKind, QPath};
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 use rustc_middle::ty::{GenericArgKind, Ty};
 use rustc_span::sym;
 
@@ -101,7 +101,7 @@ fn handle(
         && local_id == binding_id
     {
         // Machine applicable only if there are no comments present
-        let mut applicability = if span_contains_comment(cx.sess().source_map(), expr.span) {
+        let mut applicability = if span_contains_comment(cx, expr.span) {
             Applicability::MaybeIncorrect
         } else {
             Applicability::MachineApplicable
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 347560b14eea..95036f092478 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -8,7 +8,7 @@
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Pat, PatKind, QPath};
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
 
@@ -22,7 +22,7 @@ pub(crate) fn check_if_let<'tcx>(
     then_expr: &'tcx Expr<'_>,
     else_expr: &'tcx Expr<'_>,
 ) {
-    if !span_contains_comment(cx.sess().source_map(), expr.span)
+    if !span_contains_comment(cx, expr.span)
         && cx.typeck_results().expr_ty(expr).is_bool()
         && let Some(b0) = find_bool_lit(then_expr)
         && let Some(b1) = find_bool_lit(else_expr)
@@ -71,7 +71,7 @@ pub(super) fn check_match<'tcx>(
 ) -> bool {
     if let Some((last_arm, arms_without_last)) = arms.split_last()
         && let Some((first_arm, middle_arms)) = arms_without_last.split_first()
-        && !span_contains_comment(cx.sess().source_map(), e.span)
+        && !span_contains_comment(cx, e.span)
         && cx.typeck_results().expr_ty(e).is_bool()
         && let Some(b0) = find_bool_lit(first_arm.body)
         && let Some(b1) = find_bool_lit(last_arm.body)
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index dc8c06ffd79e..717c47b8aed3 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1093,12 +1093,11 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                     }
 
                     redundant_pattern_match::check_match(cx, expr, ex, arms);
-                    let source_map = cx.tcx.sess.source_map();
-                    let mut match_comments = span_extract_comments(source_map, expr.span);
+                    let mut match_comments = span_extract_comments(cx, expr.span);
                     // We remove comments from inside arms block.
                     if !match_comments.is_empty() {
                         for arm in arms {
-                            for comment in span_extract_comments(source_map, arm.body.span) {
+                            for comment in span_extract_comments(cx, arm.body.span) {
                                 if let Some(index) = match_comments
                                     .iter()
                                     .enumerate()
diff --git a/clippy_lints/src/methods/iter_filter.rs b/clippy_lints/src/methods/iter_filter.rs
index aaface3aa971..3aa666145b86 100644
--- a/clippy_lints/src/methods/iter_filter.rs
+++ b/clippy_lints/src/methods/iter_filter.rs
@@ -1,7 +1,7 @@
 use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
 use clippy_utils::ty::get_iterator_item_ty;
 use hir::ExprKind;
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 
 use super::{ITER_FILTER_IS_OK, ITER_FILTER_IS_SOME};
 
@@ -144,7 +144,7 @@ fn expression_type(
 ) -> Option<FilterType> {
     if !cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator)
         || parent_is_map(cx, expr)
-        || span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
+        || span_contains_comment(cx, filter_span.with_hi(expr.span.hi()))
     {
         return None;
     }
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index e4ae14b6cf59..09733953255e 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -19,7 +19,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, map_
         let closure_snippet = snippet_with_applicability(cx, map_arg.span, "..", &mut applicability);
         let span = expr.span.with_lo(map_span.lo());
         // If the methods are separated with comments, we don't apply suggestion automatically.
-        if span_contains_comment(cx.tcx.sess.source_map(), span) {
+        if span_contains_comment(cx, span) {
             applicability = Applicability::Unspecified;
         }
         span_lint_and_sugg(
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 387b6f8bf223..a0ad1fe00c62 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -108,7 +108,7 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
                 then,
                 r#else: Some(else_expr),
             }) = higher::If::hir(e)
-            && !span_contains_comment(cx.tcx.sess.source_map(), e.span)
+            && !span_contains_comment(cx, e.span)
         {
             let reduce = |ret, not| {
                 let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index e79ce91d8b32..58cd1e23398f 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -143,7 +143,7 @@ fn init_expr_can_use_question_mark(cx: &LateContext<'_>, init_expr: &Expr<'_>) -
         && init_expr_can_use_question_mark(cx, init_expr)
         && let Some(ret) = find_let_else_ret_expression(els)
         && let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, ret)
-        && !span_contains_comment(cx.tcx.sess.source_map(), els.span)
+        && !span_contains_comment(cx, els.span)
         && !span_contains_cfg(cx, els.span)
     {
         let mut applicability = Applicability::MaybeIncorrect;
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 8524497c387c..c99f2e2fb942 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -208,7 +208,7 @@ fn emit_lint(cx: &LateContext<'_>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocati
             .with_lo(vec_alloc.allocation_expr.span.source_callsite().lo());
 
         // If there is no comment in `span_to_replace`, Clippy can automatically fix the code.
-        let app = if span_contains_comment(cx.tcx.sess.source_map(), span_to_replace) {
+        let app = if span_contains_comment(cx, span_to_replace) {
             Applicability::Unspecified
         } else {
             Applicability::MachineApplicable
diff --git a/clippy_lints/src/useless_vec.rs b/clippy_lints/src/useless_vec.rs
index 28c339ce2b7d..7b6122213d60 100644
--- a/clippy_lints/src/useless_vec.rs
+++ b/clippy_lints/src/useless_vec.rs
@@ -251,7 +251,7 @@ fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
                     let help_msg = format!("you can use {} directly", suggest_ty.desc());
                     // If the `vec!` macro contains comment, better not make the suggestion machine applicable as it
                     // would remove them.
-                    let applicability = if span_contains_comment(cx.tcx.sess.source_map(), span) {
+                    let applicability = if span_contains_comment(cx, span) {
                         Applicability::Unspecified
                     } else {
                         Applicability::MachineApplicable
diff --git a/clippy_lints/src/write/empty_string.rs b/clippy_lints/src/write/empty_string.rs
index 1291f2489a21..fa2ad4ba94a2 100644
--- a/clippy_lints/src/write/empty_string.rs
+++ b/clippy_lints/src/write/empty_string.rs
@@ -22,7 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, format_args: &FormatArgs, macro_call:
             macro_call.span,
             format!("empty string literal in `{name}!`"),
             |diag| {
-                if span_extract_comments(cx.sess().source_map(), macro_call.span).is_empty() {
+                if span_extract_comments(cx, macro_call.span).is_empty() {
                     let closing_paren = cx.sess().source_map().span_extend_to_prev_char_before(
                         macro_call.span.shrink_to_hi(),
                         ')',
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 13c687a82b13..f502dfd6d388 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2764,16 +2764,15 @@ pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str, Inn
 
 /// Checks whether a given span has any comment token
 /// This checks for all types of comment: line "//", block "/**", doc "///" "//!"
-pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
-    let Ok(snippet) = sm.span_to_snippet(span) else {
-        return false;
-    };
-    return tokenize(&snippet, FrontmatterAllowed::No).any(|token| {
-        matches!(
-            token.kind,
-            TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }
-        )
-    });
+pub fn span_contains_comment(cx: &impl source::HasSession, span: Span) -> bool {
+    span.check_source_text(cx, |snippet| {
+        tokenize(snippet, FrontmatterAllowed::No).any(|token| {
+            matches!(
+                token.kind,
+                TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }
+            )
+        })
+    })
 }
 
 /// Checks whether a given span has any significant token. A significant token is a non-whitespace
@@ -2781,30 +2780,32 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
 /// This is useful to determine if there are any actual code tokens in the span that are omitted in
 /// the late pass, such as platform-specific code.
 pub fn span_contains_non_whitespace(cx: &impl source::HasSession, span: Span, skip_comments: bool) -> bool {
-    matches!(span.get_source_text(cx), Some(snippet) if tokenize_with_text(&snippet).any(|(token, _, _)|
-        match token {
+    span.check_source_text(cx, |snippet| {
+        tokenize_with_text(snippet).any(|(token, _, _)| match token {
             TokenKind::Whitespace => false,
             TokenKind::BlockComment { .. } | TokenKind::LineComment { .. } => !skip_comments,
             _ => true,
-        }
-    ))
+        })
+    })
 }
 /// Returns all the comments a given span contains
 ///
 /// Comments are returned wrapped with their relevant delimiters
-pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
-    span_extract_comments(sm, span).join("\n")
+pub fn span_extract_comment(cx: &impl source::HasSession, span: Span) -> String {
+    span_extract_comments(cx, span).join("\n")
 }
 
 /// Returns all the comments a given span contains.
 ///
 /// Comments are returned wrapped with their relevant delimiters.
-pub fn span_extract_comments(sm: &SourceMap, span: Span) -> Vec<String> {
-    let snippet = sm.span_to_snippet(span).unwrap_or_default();
-    tokenize_with_text(&snippet)
-        .filter(|(t, ..)| matches!(t, TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }))
-        .map(|(_, s, _)| s.to_string())
-        .collect::<Vec<_>>()
+pub fn span_extract_comments(cx: &impl source::HasSession, span: Span) -> Vec<String> {
+    span.with_source_text(cx, |snippet| {
+        tokenize_with_text(snippet)
+            .filter(|(t, ..)| matches!(t, TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }))
+            .map(|(_, s, _)| s.to_string())
+            .collect::<Vec<_>>()
+    })
+    .unwrap_or_default()
 }
 
 pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {

From 858353ce6c6d4718f76c3d88b8c075248f461516 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 5 Mar 2026 15:40:19 +0100
Subject: [PATCH 0140/1059] Update `bytes` dependency in `clippy_test_deps` to
 avoid CVE warning

Pull-requests get a warning because of
[RUSTSEC-2026-0007](https://rustsec.org/advisories/RUSTSEC-2026-0007.html).
Bumping `bytes` will silence the warning.
---
 clippy_test_deps/Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_test_deps/Cargo.lock b/clippy_test_deps/Cargo.lock
index b22cf9d107d7..63e41e8abd10 100644
--- a/clippy_test_deps/Cargo.lock
+++ b/clippy_test_deps/Cargo.lock
@@ -55,9 +55,9 @@ checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cfg-if"

From dbb159a432940d3788b83f5fbbbe9274d0be25d7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 5 Mar 2026 19:55:51 +0100
Subject: [PATCH 0141/1059] Remove usage of `LintContext::span_lint` in clippy

---
 clippy_utils/src/diagnostics.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 81b06ea0c539..65c962826900 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -8,7 +8,7 @@
 //! Thank you!
 //! ~The `INTERNAL_METADATA_COLLECTOR` lint
 
-use rustc_errors::{Applicability, Diag, DiagMessage, MultiSpan};
+use rustc_errors::{Applicability, Diag, Diagnostic, DiagCtxtHandle, DiagMessage, Level, MultiSpan};
 #[cfg(debug_assertions)]
 use rustc_errors::{EmissionGuarantee, SubstitutionPart, Suggestions};
 use rustc_hir::HirId;
@@ -240,15 +240,25 @@ pub fn span_lint_and_then<C, S, M, F>(cx: &C, lint: &'static Lint, sp: S, msg: M
     M: Into<DiagMessage>,
     F: FnOnce(&mut Diag<'_, ()>),
 {
+    struct ClippyDiag<F: FnOnce(&mut Diag<'_, ()>)>(F);
+
+    impl<'a, F: FnOnce(&mut Diag<'_, ()>)> Diagnostic<'a, ()> for ClippyDiag<F> {
+        fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+            let mut lint = Diag::new(dcx, level, "");
+            (self.0)(&mut lint);
+            lint
+        }
+    }
+
     #[expect(clippy::disallowed_methods)]
-    cx.span_lint(lint, sp, |diag| {
+    cx.emit_span_lint(lint, sp, ClippyDiag(|diag: &mut Diag<'_, ()>| {
         diag.primary_message(msg);
         f(diag);
         docs_link(diag, lint);
 
         #[cfg(debug_assertions)]
         validate_diag(diag);
-    });
+    }));
 }
 
 /// Like [`span_lint`], but emits the lint at the node identified by the given `HirId`.

From 2891905c7d1ae5a40fc3798ab25fab2348734daf Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:15:05 -0500
Subject: [PATCH 0142/1059] meta: Commit changes applied by recent versions of
 `rustfmt`

---
 library/compiler-builtins/libm-test/src/precision.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/compiler-builtins/libm-test/src/precision.rs b/library/compiler-builtins/libm-test/src/precision.rs
index 8c01c9e3d491..e99424414274 100644
--- a/library/compiler-builtins/libm-test/src/precision.rs
+++ b/library/compiler-builtins/libm-test/src/precision.rs
@@ -1,9 +1,10 @@
 //! Configuration for skipping or changing the result for individual test cases (inputs) rather
 //! than ignoring entire tests.
 
+use BaseName as Bn;
 use CheckBasis::{Mpfr, Musl};
+use Identifier as Id;
 use libm::support::CastFrom;
-use {BaseName as Bn, Identifier as Id};
 
 use crate::{BaseName, CheckBasis, CheckCtx, Float, Identifier, Int, TestResult};
 

From 44ee391300a7cc4623410145e4aca511cd2bd00e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:17:32 -0500
Subject: [PATCH 0143/1059] meta: Allow a clippy lint that appears in recent
 versions

We are now getting this warning:

    warning: the variable `j` is used as a loop counter
       --> libm/src/math/rem_pio2_large.rs:268:5
        |
    268 |     for i in 0..=m {
        |     ^^^^^^^^^^^^^^ help: consider using: `for (j, i) in ((jv as i32) - (jx as i32)..).zip((0..=m))`
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
        = note: `#[warn(clippy::explicit_counter_loop)]` on by default

    warning: `libm` (lib) generated 1 warning

Where the suggestion is definitely not an improvement.
---
 library/compiler-builtins/libm/src/math/rem_pio2_large.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/compiler-builtins/libm/src/math/rem_pio2_large.rs b/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
index 5065ca496b22..841a51b84c27 100644
--- a/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
+++ b/library/compiler-builtins/libm/src/math/rem_pio2_large.rs
@@ -1,4 +1,6 @@
 #![allow(unused_unsafe)]
+// FIXME(clippy): the suggested fix is bad but the code as-written could be better
+#![allow(clippy::explicit_counter_loop)]
 /* origin: FreeBSD /usr/src/lib/msun/src/k_rem_pio2.c */
 /*
  * ====================================================

From ba06eb8e7ac23f1dc97e247c72225ead74f12710 Mon Sep 17 00:00:00 2001
From: zedddie <zedddie@protonmail.com>
Date: Tue, 3 Mar 2026 04:02:36 +0100
Subject: [PATCH 0144/1059] gate `ConstParamTy_` trait behind
 `const_param_ty_trait` feature

---
 library/core/src/marker.rs                    |  6 ++---
 .../const_param_ty_bad_empty_array.rs         |  2 +-
 .../const_param_ty_dyn_compatibility.rs       |  2 +-
 ...nst_param_ty_generic_bounds_do_not_hold.rs |  2 +-
 .../const_param_ty_impl_bad_field.rs          |  2 +-
 .../const_param_ty_impl_no_structural_eq.rs   |  2 +-
 .../const_param_ty_impl_union.rs              |  2 +-
 .../const_param_ty_trait_gate.rs              |  8 +++++++
 .../const_param_ty_trait_implied.rs           |  9 ++++++++
 .../const_param_ty_trait_no_gate.rs           |  7 ++++++
 .../const_param_ty_trait_no_gate.stderr       | 23 +++++++++++++++++++
 .../bound-var-in-ty-not-wf.rs                 |  2 +-
 .../bound-var-in-ty.rs                        |  2 +-
 ...dyn-compat-assoc-const-ty-mentions-self.rs |  2 +-
 ...elf-const-projections-in-assoc-const-ty.rs |  2 +-
 .../associated-const-bindings/supertraits.rs  |  2 +-
 ...const-param-with-additional-obligations.rs |  2 +-
 .../bad_inference.rs                          |  2 +-
 .../evaluate_const_parameter_in_mir.rs        |  2 +-
 .../mismatched_args_with_value.rs             |  2 +-
 .../no_const_param_ty_bound.rs                |  2 +-
 .../unrelated_inferred_arg.rs                 |  2 +-
 .../mgca/adt_expr_infers_from_value.rs        |  2 +-
 tests/ui/const-generics/mgca/const-ctor.rs    |  2 +-
 .../mgca/generic_const_type_mismatch.rs       |  2 +-
 .../assoc-const-bindings.rs                   |  2 +-
 26 files changed, 71 insertions(+), 24 deletions(-)
 create mode 100644 tests/ui/const-generics/adt_const_params/const_param_ty_trait_gate.rs
 create mode 100644 tests/ui/const-generics/adt_const_params/const_param_ty_trait_implied.rs
 create mode 100644 tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.rs
 create mode 100644 tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.stderr

diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 7187c71799b9..a2c9c705d364 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -54,7 +54,7 @@
 /// ```
 #[unstable(feature = "internal_impls_macro", issue = "none")]
 // Allow implementations of `UnsizedConstParamTy` even though std cannot use that feature.
-#[allow_internal_unstable(unsized_const_params)]
+#[allow_internal_unstable(const_param_ty_trait)]
 macro marker_impls {
     ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(, $($rest:tt)*)? ) => {
         $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for $T {}
@@ -1080,7 +1080,7 @@ pub trait Tuple {}
 /// that all fields are also `ConstParamTy`, which implies that recursively, all fields
 /// are `StructuralPartialEq`.
 #[lang = "const_param_ty"]
-#[unstable(feature = "unsized_const_params", issue = "95174")]
+#[unstable(feature = "const_param_ty_trait", issue = "95174", implied_by = "unsized_const_params")]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 #[allow(multiple_supertrait_upcastable)]
 // We name this differently than the derive macro so that the `adt_const_params` can
@@ -1090,7 +1090,7 @@ pub trait ConstParamTy_: StructuralPartialEq + Eq {}
 
 /// Derive macro generating an impl of the trait `ConstParamTy`.
 #[rustc_builtin_macro]
-#[allow_internal_unstable(unsized_const_params)]
+#[allow_internal_unstable(const_param_ty_trait)]
 #[unstable(feature = "adt_const_params", issue = "95174")]
 pub macro ConstParamTy($item:item) {
     /* compiler built-in */
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs
index 2008a96310a8..a7c051cd4c39 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs
@@ -1,5 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 
 #[derive(PartialEq, Eq)]
 struct NotParam;
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
index 2fcf872c99aa..535447cf2b94 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
@@ -1,4 +1,4 @@
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
index a86d74275de8..0d67854ecfc8 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
@@ -1,5 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 
 #[derive(PartialEq, Eq)]
 struct NotParam;
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
index 1900931b3f35..dd425a28e972 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
@@ -1,5 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 
 #[derive(PartialEq, Eq)]
 struct NotParam;
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
index a8f190609c04..7f4dee418fe9 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
@@ -1,5 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 
 #[derive(PartialEq, Eq)]
 struct ImplementsConstParamTy;
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
index 0c9b12805f75..a7e0fa2ef212 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
@@ -1,5 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 
 union Union {
     a: u8,
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_trait_gate.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_gate.rs
new file mode 100644
index 000000000000..591e550d7b99
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_gate.rs
@@ -0,0 +1,8 @@
+//@check-pass
+#![feature(const_param_ty_trait)]
+
+use std::marker::ConstParamTy_;
+
+fn meow<T: ConstParamTy_>() {}
+
+fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_trait_implied.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_implied.rs
new file mode 100644
index 000000000000..9b66daaf9aea
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_implied.rs
@@ -0,0 +1,9 @@
+//@check-pass
+#![feature(unsized_const_params, adt_const_params)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+fn miow<T: ConstParamTy_>() {}
+
+fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.rs
new file mode 100644
index 000000000000..85283a0cbac4
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.rs
@@ -0,0 +1,7 @@
+use std::marker::ConstParamTy_;
+ //~^ ERROR use of unstable library feature `const_param_ty_trait` [E0658]
+
+fn miaw<T: ConstParamTy_>() {}
+         //~^ ERROR use of unstable library feature `const_param_ty_trait` [E0658]
+
+fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.stderr
new file mode 100644
index 000000000000..87dedcdab908
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_trait_no_gate.stderr
@@ -0,0 +1,23 @@
+error[E0658]: use of unstable library feature `const_param_ty_trait`
+  --> $DIR/const_param_ty_trait_no_gate.rs:1:5
+   |
+LL | use std::marker::ConstParamTy_;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
+   = help: add `#![feature(const_param_ty_trait)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: use of unstable library feature `const_param_ty_trait`
+  --> $DIR/const_param_ty_trait_no_gate.rs:4:12
+   |
+LL | fn miaw<T: ConstParamTy_>() {}
+   |            ^^^^^^^^^^^^^
+   |
+   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
+   = help: add `#![feature(const_param_ty_trait)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty-not-wf.rs b/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty-not-wf.rs
index 53f65319db9d..b66dff43a3d1 100644
--- a/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty-not-wf.rs
+++ b/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty-not-wf.rs
@@ -3,7 +3,7 @@
 #![feature(
     min_generic_const_args,
     adt_const_params,
-    unsized_const_params,
+    const_param_ty_trait,
     generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
diff --git a/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty.rs b/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty.rs
index a509fe0d52e3..e5757c8ef447 100644
--- a/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty.rs
+++ b/tests/ui/const-generics/associated-const-bindings/bound-var-in-ty.rs
@@ -6,7 +6,7 @@
 #![feature(
     min_generic_const_args,
     adt_const_params,
-    unsized_const_params,
+    const_param_ty_trait,
     generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
diff --git a/tests/ui/const-generics/associated-const-bindings/dyn-compat-assoc-const-ty-mentions-self.rs b/tests/ui/const-generics/associated-const-bindings/dyn-compat-assoc-const-ty-mentions-self.rs
index 771f48cba068..454ce7b3875f 100644
--- a/tests/ui/const-generics/associated-const-bindings/dyn-compat-assoc-const-ty-mentions-self.rs
+++ b/tests/ui/const-generics/associated-const-bindings/dyn-compat-assoc-const-ty-mentions-self.rs
@@ -7,7 +7,7 @@
 #![feature(generic_const_items)]
 #![feature(generic_const_parameter_types)]
 #![feature(min_generic_const_args)]
-#![feature(unsized_const_params)]
+#![feature(const_param_ty_trait)]
 #![expect(incomplete_features)]
 
 trait Trait {
diff --git a/tests/ui/const-generics/associated-const-bindings/dyn-compat-self-const-projections-in-assoc-const-ty.rs b/tests/ui/const-generics/associated-const-bindings/dyn-compat-self-const-projections-in-assoc-const-ty.rs
index 623769f5d12f..fb2bc308ae18 100644
--- a/tests/ui/const-generics/associated-const-bindings/dyn-compat-self-const-projections-in-assoc-const-ty.rs
+++ b/tests/ui/const-generics/associated-const-bindings/dyn-compat-self-const-projections-in-assoc-const-ty.rs
@@ -7,7 +7,7 @@
 #![feature(
     adt_const_params,
     min_generic_const_args,
-    unsized_const_params,
+    const_param_ty_trait,
     generic_const_parameter_types
 )]
 #![expect(incomplete_features)]
diff --git a/tests/ui/const-generics/associated-const-bindings/supertraits.rs b/tests/ui/const-generics/associated-const-bindings/supertraits.rs
index cdceb682a854..6c8ae165a50d 100644
--- a/tests/ui/const-generics/associated-const-bindings/supertraits.rs
+++ b/tests/ui/const-generics/associated-const-bindings/supertraits.rs
@@ -6,7 +6,7 @@
 #![feature(
     min_generic_const_args,
     adt_const_params,
-    unsized_const_params,
+    const_param_ty_trait,
     generic_const_parameter_types,
 )]
 #![allow(incomplete_features)]
diff --git a/tests/ui/const-generics/const-param-with-additional-obligations.rs b/tests/ui/const-generics/const-param-with-additional-obligations.rs
index 5110f95d5bf9..8c03cf0a6d37 100644
--- a/tests/ui/const-generics/const-param-with-additional-obligations.rs
+++ b/tests/ui/const-generics/const-param-with-additional-obligations.rs
@@ -1,4 +1,4 @@
-#![feature(adt_const_params, unsized_const_params)]
+#![feature(adt_const_params, const_param_ty_trait)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs
index 9748c14d655d..994863f0fa43 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs
@@ -1,4 +1,4 @@
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs b/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs
index 9f3ab1be2502..6226aaaab6fb 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs
index df8a057b335a..08d85f183c1e 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs
@@ -1,4 +1,4 @@
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs
index 1a5ab46cda19..20306c7f219d 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs
@@ -1,4 +1,4 @@
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![expect(incomplete_features)]
 
 use std::marker::{ConstParamTy_, PhantomData};
diff --git a/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs b/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs
index 80117a27a23d..1661d769c4ea 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![allow(incomplete_features)]
 
 use std::marker::ConstParamTy_;
diff --git a/tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs b/tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs
index 5def3cbb829b..f27cbddaae28 100644
--- a/tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs
+++ b/tests/ui/const-generics/mgca/adt_expr_infers_from_value.rs
@@ -5,7 +5,7 @@
     min_generic_const_args,
     adt_const_params,
     generic_const_parameter_types,
-    unsized_const_params,
+    const_param_ty_trait,
 )]
 #![expect(incomplete_features)]
 
diff --git a/tests/ui/const-generics/mgca/const-ctor.rs b/tests/ui/const-generics/mgca/const-ctor.rs
index 19900b56a816..d84b05f90909 100644
--- a/tests/ui/const-generics/mgca/const-ctor.rs
+++ b/tests/ui/const-generics/mgca/const-ctor.rs
@@ -8,7 +8,7 @@
     min_generic_const_args,
     adt_const_params,
     generic_const_parameter_types,
-    unsized_const_params
+    const_param_ty_trait
 )]
 #![expect(incomplete_features)]
 use std::marker::{ConstParamTy, ConstParamTy_};
diff --git a/tests/ui/const-generics/mgca/generic_const_type_mismatch.rs b/tests/ui/const-generics/mgca/generic_const_type_mismatch.rs
index 948b8ce72148..0c975184dfbd 100644
--- a/tests/ui/const-generics/mgca/generic_const_type_mismatch.rs
+++ b/tests/ui/const-generics/mgca/generic_const_type_mismatch.rs
@@ -5,7 +5,7 @@
     generic_const_items,
     generic_const_parameter_types,
     min_generic_const_args,
-    unsized_const_params
+    const_param_ty_trait
 )]
 use std::marker::ConstParamTy_;
 
diff --git a/tests/ui/generic-const-items/assoc-const-bindings.rs b/tests/ui/generic-const-items/assoc-const-bindings.rs
index c187c87c7763..2ebdda28a69f 100644
--- a/tests/ui/generic-const-items/assoc-const-bindings.rs
+++ b/tests/ui/generic-const-items/assoc-const-bindings.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 
 #![feature(generic_const_items, min_generic_const_args)]
-#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![feature(adt_const_params, const_param_ty_trait, generic_const_parameter_types)]
 #![expect(incomplete_features)]
 
 use std::marker::{ConstParamTy, ConstParamTy_};

From 226b4dd55547998170f220dd93c75775a5f73f73 Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Mon, 2 Mar 2026 19:37:12 -0800
Subject: [PATCH 0145/1059] tests/ui/cfg: add annotations for reference rules

---
 tests/ui/cfg/both-true-false.rs               |   1 +
 tests/ui/cfg/both-true-false.stderr           |   6 +-
 tests/ui/cfg/cfg-false-use-item.rs            |   2 +
 tests/ui/cfg/cfg-family.rs                    |   2 +
 tests/ui/cfg/cfg-panic-abort.rs               |   2 +
 tests/ui/cfg/cfg-panic.rs                     |   2 +
 tests/ui/cfg/cfg-path-error.rs                |   1 +
 tests/ui/cfg/cfg-path-error.stderr            |   8 +-
 tests/ui/cfg/cfg-target-abi.rs                |   2 +
 tests/ui/cfg/cfg-target-family.rs             |   2 +
 tests/ui/cfg/cfg-target-vendor.rs             |   2 +
 tests/ui/cfg/cfg_attr.rs                      |   2 +
 tests/ui/cfg/cfg_false_no_std-1.rs            |   1 +
 tests/ui/cfg/cfg_false_no_std-2.rs            |   1 +
 tests/ui/cfg/cfg_false_no_std.rs              |   1 +
 tests/ui/cfg/cfg_stmt_expr.rs                 |   1 +
 tests/ui/cfg/cfgs-on-items.rs                 |   3 +
 tests/ui/cfg/conditional-compile-arch.rs      |   2 +
 tests/ui/cfg/conditional-compile.rs           |   1 +
 .../ui/cfg/crate-attributes-using-cfg_attr.rs |   1 +
 .../crate-attributes-using-cfg_attr.stderr    |   8 +-
 tests/ui/cfg/invalid-cli-cfg-pred.rs          |   3 +
 tests/ui/cfg/invalid-cli-check-cfg-pred.rs    |   3 +
 tests/ui/cfg/path-kw-as-cfg-pred.rs           |   2 +
 tests/ui/cfg/path-kw-as-cfg-pred.stderr       | 128 +++++++++---------
 tests/ui/cfg/true-false.rs                    |   1 +
 26 files changed, 113 insertions(+), 75 deletions(-)

diff --git a/tests/ui/cfg/both-true-false.rs b/tests/ui/cfg/both-true-false.rs
index 5fca8f654ad8..62a4ef6a2dbe 100644
--- a/tests/ui/cfg/both-true-false.rs
+++ b/tests/ui/cfg/both-true-false.rs
@@ -1,5 +1,6 @@
 /// Test that placing a `cfg(true)` and `cfg(false)` on the same item result in
 //. it being disabled.`
+//@ reference: cfg.attr.duplicates
 
 #[cfg(false)]
 #[cfg(true)]
diff --git a/tests/ui/cfg/both-true-false.stderr b/tests/ui/cfg/both-true-false.stderr
index 1a7c509aec0c..76a5661f0873 100644
--- a/tests/ui/cfg/both-true-false.stderr
+++ b/tests/ui/cfg/both-true-false.stderr
@@ -1,11 +1,11 @@
 error[E0425]: cannot find function `foo` in this scope
-  --> $DIR/both-true-false.rs:13:5
+  --> $DIR/both-true-false.rs:14:5
    |
 LL |     foo();
    |     ^^^ not found in this scope
    |
 note: found an item that was configured out
-  --> $DIR/both-true-false.rs:6:4
+  --> $DIR/both-true-false.rs:7:4
    |
 LL | #[cfg(false)]
    |       ----- the item is gated here
@@ -13,7 +13,7 @@ LL | #[cfg(true)]
 LL | fn foo() {}
    |    ^^^
 note: found an item that was configured out
-  --> $DIR/both-true-false.rs:10:4
+  --> $DIR/both-true-false.rs:11:4
    |
 LL | #[cfg(false)]
    |       ----- the item is gated here
diff --git a/tests/ui/cfg/cfg-false-use-item.rs b/tests/ui/cfg/cfg-false-use-item.rs
index d37b48cdedb7..d907e17a0c11 100644
--- a/tests/ui/cfg/cfg-false-use-item.rs
+++ b/tests/ui/cfg/cfg-false-use-item.rs
@@ -1,6 +1,8 @@
 //! Test that use items with cfg(false) are properly filtered out
 
 //@ run-pass
+//@ reference: cfg.predicate.literal
+//@ reference: cfg.attr.effect
 
 pub fn main() {
     // Make sure that this view item is filtered out because otherwise it would
diff --git a/tests/ui/cfg/cfg-family.rs b/tests/ui/cfg/cfg-family.rs
index a13ae7f9616b..60594c7105f7 100644
--- a/tests/ui/cfg/cfg-family.rs
+++ b/tests/ui/cfg/cfg-family.rs
@@ -1,6 +1,8 @@
 //@ build-pass
 //@ ignore-wasm32 no bare family
 //@ ignore-sgx
+//@ reference: cfg.target_family.unix
+//@ reference: cfg.target_family.windows
 
 #[cfg(windows)]
 pub fn main() {
diff --git a/tests/ui/cfg/cfg-panic-abort.rs b/tests/ui/cfg/cfg-panic-abort.rs
index b39888573b3a..af4e119ef9fe 100644
--- a/tests/ui/cfg/cfg-panic-abort.rs
+++ b/tests/ui/cfg/cfg-panic-abort.rs
@@ -2,6 +2,8 @@
 //@ compile-flags: -C panic=abort
 //@ no-prefer-dynamic
 //@ ignore-backends: gcc
+//@ reference: cfg.panic.def
+//@ reference: cfg.panic.values
 
 #[cfg(panic = "unwind")]
 pub fn bad() -> i32 { }
diff --git a/tests/ui/cfg/cfg-panic.rs b/tests/ui/cfg/cfg-panic.rs
index 4e3ed0cd9c2f..7c911c5754e7 100644
--- a/tests/ui/cfg/cfg-panic.rs
+++ b/tests/ui/cfg/cfg-panic.rs
@@ -1,6 +1,8 @@
 //@ build-pass
 //@ compile-flags: -C panic=unwind
 //@ needs-unwind
+//@ reference: cfg.panic.def
+//@ reference: cfg.panic.values
 
 #[cfg(panic = "abort")]
 pub fn bad() -> i32 { }
diff --git a/tests/ui/cfg/cfg-path-error.rs b/tests/ui/cfg/cfg-path-error.rs
index f22e6be32f3e..9bb10d3a6f6a 100644
--- a/tests/ui/cfg/cfg-path-error.rs
+++ b/tests/ui/cfg/cfg-path-error.rs
@@ -1,4 +1,5 @@
 //@ check-fail
+//@ reference: cfg.option-spec
 
 #![allow(unexpected_cfgs)] // invalid cfgs
 
diff --git a/tests/ui/cfg/cfg-path-error.stderr b/tests/ui/cfg/cfg-path-error.stderr
index bb9b7039c8a3..f3b0a2d3c28e 100644
--- a/tests/ui/cfg/cfg-path-error.stderr
+++ b/tests/ui/cfg/cfg-path-error.stderr
@@ -1,5 +1,5 @@
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/cfg-path-error.rs:5:1
+  --> $DIR/cfg-path-error.rs:6:1
    |
 LL | #[cfg(any(foo, foo::bar))]
    | ^^^^^^^^^^^^^^^--------^^^
@@ -10,7 +10,7 @@ LL | #[cfg(any(foo, foo::bar))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/cfg-path-error.rs:11:1
+  --> $DIR/cfg-path-error.rs:12:1
    |
 LL | #[cfg(any(foo::bar, foo))]
    | ^^^^^^^^^^--------^^^^^^^^
@@ -21,7 +21,7 @@ LL | #[cfg(any(foo::bar, foo))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/cfg-path-error.rs:17:1
+  --> $DIR/cfg-path-error.rs:18:1
    |
 LL | #[cfg(all(foo, foo::bar))]
    | ^^^^^^^^^^^^^^^--------^^^
@@ -32,7 +32,7 @@ LL | #[cfg(all(foo, foo::bar))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/cfg-path-error.rs:23:1
+  --> $DIR/cfg-path-error.rs:24:1
    |
 LL | #[cfg(all(foo::bar, foo))]
    | ^^^^^^^^^^--------^^^^^^^^
diff --git a/tests/ui/cfg/cfg-target-abi.rs b/tests/ui/cfg/cfg-target-abi.rs
index 306ae077325b..b00107118517 100644
--- a/tests/ui/cfg/cfg-target-abi.rs
+++ b/tests/ui/cfg/cfg-target-abi.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ reference: cfg.target_abi.def
+//@ reference: cfg.target_abi.values
 
 #[cfg(target_abi = "eabihf")]
 pub fn main() {
diff --git a/tests/ui/cfg/cfg-target-family.rs b/tests/ui/cfg/cfg-target-family.rs
index 0b1c323307a9..33dc5b1e8242 100644
--- a/tests/ui/cfg/cfg-target-family.rs
+++ b/tests/ui/cfg/cfg-target-family.rs
@@ -1,5 +1,7 @@
 //@ build-pass
 //@ ignore-sgx
+//@ reference: cfg.target_family.def
+//@ reference: cfg.target_family.values
 
 
 #[cfg(target_family = "windows")]
diff --git a/tests/ui/cfg/cfg-target-vendor.rs b/tests/ui/cfg/cfg-target-vendor.rs
index e5de95d04e54..04dfbdb064d0 100644
--- a/tests/ui/cfg/cfg-target-vendor.rs
+++ b/tests/ui/cfg/cfg-target-vendor.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ reference: cfg.target_vendor.def
+//@ reference: cfg.target_vendor.values
 #[cfg(target_vendor = "unknown")]
 pub fn main() {
 }
diff --git a/tests/ui/cfg/cfg_attr.rs b/tests/ui/cfg/cfg_attr.rs
index ba4adafd3a56..1fab79c5e1f2 100644
--- a/tests/ui/cfg/cfg_attr.rs
+++ b/tests/ui/cfg/cfg_attr.rs
@@ -1,5 +1,7 @@
 //@ run-pass
 //@ compile-flags:--cfg set1 --cfg set2
+//@ reference: cfg.cfg_attr.intro
+//@ reference: cfg.cfg_attr.syntax
 
 #![allow(dead_code, unexpected_cfgs)]
 
diff --git a/tests/ui/cfg/cfg_false_no_std-1.rs b/tests/ui/cfg/cfg_false_no_std-1.rs
index 17286e219b86..7f8a43ecdfed 100644
--- a/tests/ui/cfg/cfg_false_no_std-1.rs
+++ b/tests/ui/cfg/cfg_false_no_std-1.rs
@@ -2,6 +2,7 @@
 
 //@ check-pass
 //@ aux-build: cfg_false_lib_no_std_after.rs
+//@ reference: cfg.attr.crate-level-attrs
 
 #![no_std]
 
diff --git a/tests/ui/cfg/cfg_false_no_std-2.rs b/tests/ui/cfg/cfg_false_no_std-2.rs
index 666c90deaf0f..a3816f0e1551 100644
--- a/tests/ui/cfg/cfg_false_no_std-2.rs
+++ b/tests/ui/cfg/cfg_false_no_std-2.rs
@@ -7,6 +7,7 @@
 //@ compile-flags: -Cpanic=abort
 
 //@ aux-build: cfg_false_lib_no_std_before.rs
+//@ reference: cfg.attr.crate-level-attrs
 
 #![no_std]
 
diff --git a/tests/ui/cfg/cfg_false_no_std.rs b/tests/ui/cfg/cfg_false_no_std.rs
index 910f3f8b9ae1..08032c5a91e6 100644
--- a/tests/ui/cfg/cfg_false_no_std.rs
+++ b/tests/ui/cfg/cfg_false_no_std.rs
@@ -2,6 +2,7 @@
 
 //@ check-pass
 //@ aux-build: cfg_false_lib.rs
+//@ reference: cfg.attr.crate-level-attrs
 
 #![no_std]
 
diff --git a/tests/ui/cfg/cfg_stmt_expr.rs b/tests/ui/cfg/cfg_stmt_expr.rs
index 361b159a354f..8681f87b5b30 100644
--- a/tests/ui/cfg/cfg_stmt_expr.rs
+++ b/tests/ui/cfg/cfg_stmt_expr.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ reference: cfg.attr.allowed-positions
 #![allow(dead_code)]
 #![allow(unused_mut)]
 #![allow(unused_variables)]
diff --git a/tests/ui/cfg/cfgs-on-items.rs b/tests/ui/cfg/cfgs-on-items.rs
index 8992a8fca9c3..56f87350fea2 100644
--- a/tests/ui/cfg/cfgs-on-items.rs
+++ b/tests/ui/cfg/cfgs-on-items.rs
@@ -1,5 +1,8 @@
 //@ run-pass
 //@ compile-flags: --cfg fooA --cfg fooB --check-cfg=cfg(fooA,fooB,fooC,bar)
+//@ reference: cfg.predicate.all
+//@ reference: cfg.predicate.any
+//@ reference: cfg.predicate.not
 
 // fooA AND !bar
 #[cfg(all(fooA, not(bar)))]
diff --git a/tests/ui/cfg/conditional-compile-arch.rs b/tests/ui/cfg/conditional-compile-arch.rs
index f16805474074..0d57a50be530 100644
--- a/tests/ui/cfg/conditional-compile-arch.rs
+++ b/tests/ui/cfg/conditional-compile-arch.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ reference: cfg.target_arch.def
+//@ reference: cfg.target_arch.values
 
 #[cfg(target_arch = "x86")]
 pub fn main() { }
diff --git a/tests/ui/cfg/conditional-compile.rs b/tests/ui/cfg/conditional-compile.rs
index 8761197891f5..637bd0e12e8b 100644
--- a/tests/ui/cfg/conditional-compile.rs
+++ b/tests/ui/cfg/conditional-compile.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ reference: cfg.attr.allowed-positions
 #![allow(dead_code)]
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
diff --git a/tests/ui/cfg/crate-attributes-using-cfg_attr.rs b/tests/ui/cfg/crate-attributes-using-cfg_attr.rs
index f99fad881f28..6dbc59ccc4ed 100644
--- a/tests/ui/cfg/crate-attributes-using-cfg_attr.rs
+++ b/tests/ui/cfg/crate-attributes-using-cfg_attr.rs
@@ -1,5 +1,6 @@
 //@ check-fail
 //@ compile-flags:--cfg foo --check-cfg=cfg(foo)
+//@ reference: cfg.cfg_attr.attr-restriction
 
 #![cfg_attr(foo, crate_type="bin")]
 //~^ERROR `crate_type` within
diff --git a/tests/ui/cfg/crate-attributes-using-cfg_attr.stderr b/tests/ui/cfg/crate-attributes-using-cfg_attr.stderr
index 1dfca2b88d0e..3d6f00760502 100644
--- a/tests/ui/cfg/crate-attributes-using-cfg_attr.stderr
+++ b/tests/ui/cfg/crate-attributes-using-cfg_attr.stderr
@@ -1,17 +1,17 @@
 error: `crate_type` within an `#![cfg_attr]` attribute is forbidden
-  --> $DIR/crate-attributes-using-cfg_attr.rs:4:18
+  --> $DIR/crate-attributes-using-cfg_attr.rs:5:18
    |
 LL | #![cfg_attr(foo, crate_type="bin")]
    |                  ^^^^^^^^^^^^^^^^
 
 error: `crate_name` within an `#![cfg_attr]` attribute is forbidden
-  --> $DIR/crate-attributes-using-cfg_attr.rs:7:18
+  --> $DIR/crate-attributes-using-cfg_attr.rs:8:18
    |
 LL | #![cfg_attr(foo, crate_name="bar")]
    |                  ^^^^^^^^^^^^^^^^
 
 error: `crate_type` within an `#![cfg_attr]` attribute is forbidden
-  --> $DIR/crate-attributes-using-cfg_attr.rs:4:18
+  --> $DIR/crate-attributes-using-cfg_attr.rs:5:18
    |
 LL | #![cfg_attr(foo, crate_type="bin")]
    |                  ^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | #![cfg_attr(foo, crate_type="bin")]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: `crate_name` within an `#![cfg_attr]` attribute is forbidden
-  --> $DIR/crate-attributes-using-cfg_attr.rs:7:18
+  --> $DIR/crate-attributes-using-cfg_attr.rs:8:18
    |
 LL | #![cfg_attr(foo, crate_name="bar")]
    |                  ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cfg/invalid-cli-cfg-pred.rs b/tests/ui/cfg/invalid-cli-cfg-pred.rs
index fdfb6b18d96b..817362a40f3d 100644
--- a/tests/ui/cfg/invalid-cli-cfg-pred.rs
+++ b/tests/ui/cfg/invalid-cli-cfg-pred.rs
@@ -1,4 +1,7 @@
 //@ compile-flags: --cfg foo=1x
+//@ reference: cfg.option-spec
+//@ reference: cfg.option-name
+//@ reference: cfg.option-key-value
 
 fn main() {}
 
diff --git a/tests/ui/cfg/invalid-cli-check-cfg-pred.rs b/tests/ui/cfg/invalid-cli-check-cfg-pred.rs
index 30417a912bfc..d5a40f439836 100644
--- a/tests/ui/cfg/invalid-cli-check-cfg-pred.rs
+++ b/tests/ui/cfg/invalid-cli-check-cfg-pred.rs
@@ -1,4 +1,7 @@
 //@ compile-flags: --check-cfg 'foo=1x'
+//@ reference: cfg.option-spec
+//@ reference: cfg.option-name
+//@ reference: cfg.option-key-value
 
 fn main() {}
 
diff --git a/tests/ui/cfg/path-kw-as-cfg-pred.rs b/tests/ui/cfg/path-kw-as-cfg-pred.rs
index d3b419175163..f161e60385b4 100644
--- a/tests/ui/cfg/path-kw-as-cfg-pred.rs
+++ b/tests/ui/cfg/path-kw-as-cfg-pred.rs
@@ -1,4 +1,6 @@
 //@ edition: 2024
+//@ reference: cfg.attr.syntax
+//@ reference: cfg.cfg_attr.syntax
 
 #![allow(unexpected_cfgs)]
 
diff --git a/tests/ui/cfg/path-kw-as-cfg-pred.stderr b/tests/ui/cfg/path-kw-as-cfg-pred.stderr
index f0bc0b67b933..b10149dd0964 100644
--- a/tests/ui/cfg/path-kw-as-cfg-pred.stderr
+++ b/tests/ui/cfg/path-kw-as-cfg-pred.stderr
@@ -1,125 +1,125 @@
 error: `crate` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:70:10
+  --> $DIR/path-kw-as-cfg-pred.rs:72:10
    |
 LL |     cfg!(r#crate);
    |          ^^^^^^^
 
 error: `super` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:72:10
+  --> $DIR/path-kw-as-cfg-pred.rs:74:10
    |
 LL |     cfg!(r#super);
    |          ^^^^^^^
 
 error: `self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:74:10
+  --> $DIR/path-kw-as-cfg-pred.rs:76:10
    |
 LL |     cfg!(r#self);
    |          ^^^^^^
 
 error: `Self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:76:10
+  --> $DIR/path-kw-as-cfg-pred.rs:78:10
    |
 LL |     cfg!(r#Self);
    |          ^^^^^^
 
 error: `_` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:85:10
+  --> $DIR/path-kw-as-cfg-pred.rs:87:10
    |
 LL |     cfg!(r#_);
    |          ^^^
 
 error: `crate` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:88:7
+  --> $DIR/path-kw-as-cfg-pred.rs:90:7
    |
 LL | #[cfg(r#crate)]
    |       ^^^^^^^
 
 error: `super` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:91:7
+  --> $DIR/path-kw-as-cfg-pred.rs:93:7
    |
 LL | #[cfg(r#super)]
    |       ^^^^^^^
 
 error: `self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:94:7
+  --> $DIR/path-kw-as-cfg-pred.rs:96:7
    |
 LL | #[cfg(r#self)]
    |       ^^^^^^
 
 error: `Self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:97:7
+  --> $DIR/path-kw-as-cfg-pred.rs:99:7
    |
 LL | #[cfg(r#Self)]
    |       ^^^^^^
 
 error: `crate` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:100:12
+  --> $DIR/path-kw-as-cfg-pred.rs:102:12
    |
 LL | #[cfg_attr(r#crate, cfg(r#crate))]
    |            ^^^^^^^
 
 error: `crate` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:100:25
+  --> $DIR/path-kw-as-cfg-pred.rs:102:25
    |
 LL | #[cfg_attr(r#crate, cfg(r#crate))]
    |                         ^^^^^^^
 
 error: `super` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:104:12
+  --> $DIR/path-kw-as-cfg-pred.rs:106:12
    |
 LL | #[cfg_attr(r#super, cfg(r#super))]
    |            ^^^^^^^
 
 error: `super` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:104:25
+  --> $DIR/path-kw-as-cfg-pred.rs:106:25
    |
 LL | #[cfg_attr(r#super, cfg(r#super))]
    |                         ^^^^^^^
 
 error: `self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:108:12
+  --> $DIR/path-kw-as-cfg-pred.rs:110:12
    |
 LL | #[cfg_attr(r#self, cfg(r#self))]
    |            ^^^^^^
 
 error: `self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:108:24
+  --> $DIR/path-kw-as-cfg-pred.rs:110:24
    |
 LL | #[cfg_attr(r#self, cfg(r#self))]
    |                        ^^^^^^
 
 error: `Self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:112:12
+  --> $DIR/path-kw-as-cfg-pred.rs:114:12
    |
 LL | #[cfg_attr(r#Self, cfg(r#Self))]
    |            ^^^^^^
 
 error: `Self` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:112:24
+  --> $DIR/path-kw-as-cfg-pred.rs:114:24
    |
 LL | #[cfg_attr(r#Self, cfg(r#Self))]
    |                        ^^^^^^
 
 error: `_` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:121:7
+  --> $DIR/path-kw-as-cfg-pred.rs:123:7
    |
 LL | #[cfg(r#_)]
    |       ^^^
 
 error: `_` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:127:12
+  --> $DIR/path-kw-as-cfg-pred.rs:129:12
    |
 LL | #[cfg_attr(r#_, cfg(r#_))]
    |            ^^^
 
 error: `_` cannot be a raw identifier
-  --> $DIR/path-kw-as-cfg-pred.rs:127:21
+  --> $DIR/path-kw-as-cfg-pred.rs:129:21
    |
 LL | #[cfg_attr(r#_, cfg(r#_))]
    |                     ^^^
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:18:1
+  --> $DIR/path-kw-as-cfg-pred.rs:20:1
    |
 LL | #[cfg(crate)]
    | ^^^^^^-----^^
@@ -130,7 +130,7 @@ LL | #[cfg(crate)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:20:1
+  --> $DIR/path-kw-as-cfg-pred.rs:22:1
    |
 LL | #[cfg(super)]
    | ^^^^^^-----^^
@@ -141,7 +141,7 @@ LL | #[cfg(super)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:22:1
+  --> $DIR/path-kw-as-cfg-pred.rs:24:1
    |
 LL | #[cfg(self)]
    | ^^^^^^----^^
@@ -152,7 +152,7 @@ LL | #[cfg(self)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:24:1
+  --> $DIR/path-kw-as-cfg-pred.rs:26:1
    |
 LL | #[cfg(Self)]
    | ^^^^^^----^^
@@ -163,7 +163,7 @@ LL | #[cfg(Self)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:26:1
+  --> $DIR/path-kw-as-cfg-pred.rs:28:1
    |
 LL | #[cfg_attr(crate, path = "foo")]
    | ^^^^^^^^^^^-----^^^^^^^^^^^^^^^^
@@ -174,7 +174,7 @@ LL | #[cfg_attr(crate, path = "foo")]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:28:1
+  --> $DIR/path-kw-as-cfg-pred.rs:30:1
    |
 LL | #[cfg_attr(super, path = "foo")]
    | ^^^^^^^^^^^-----^^^^^^^^^^^^^^^^
@@ -185,7 +185,7 @@ LL | #[cfg_attr(super, path = "foo")]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:30:1
+  --> $DIR/path-kw-as-cfg-pred.rs:32:1
    |
 LL | #[cfg_attr(self, path = "foo")]
    | ^^^^^^^^^^^----^^^^^^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL | #[cfg_attr(self, path = "foo")]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:32:1
+  --> $DIR/path-kw-as-cfg-pred.rs:34:1
    |
 LL | #[cfg_attr(Self, path = "foo")]
    | ^^^^^^^^^^^----^^^^^^^^^^^^^^^^
@@ -207,7 +207,7 @@ LL | #[cfg_attr(Self, path = "foo")]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:34:18
+  --> $DIR/path-kw-as-cfg-pred.rs:36:18
    |
 LL | #[cfg_attr(true, cfg(crate))]
    |                  ^^^^-----^
@@ -218,7 +218,7 @@ LL | #[cfg_attr(true, cfg(crate))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:36:18
+  --> $DIR/path-kw-as-cfg-pred.rs:38:18
    |
 LL | #[cfg_attr(true, cfg(super))]
    |                  ^^^^-----^
@@ -229,7 +229,7 @@ LL | #[cfg_attr(true, cfg(super))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:38:18
+  --> $DIR/path-kw-as-cfg-pred.rs:40:18
    |
 LL | #[cfg_attr(true, cfg(self))]
    |                  ^^^^----^
@@ -240,7 +240,7 @@ LL | #[cfg_attr(true, cfg(self))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:40:18
+  --> $DIR/path-kw-as-cfg-pred.rs:42:18
    |
 LL | #[cfg_attr(true, cfg(Self))]
    |                  ^^^^----^
@@ -251,25 +251,25 @@ LL | #[cfg_attr(true, cfg(Self))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error: expected identifier, found keyword `struct`
-  --> $DIR/path-kw-as-cfg-pred.rs:43:7
+  --> $DIR/path-kw-as-cfg-pred.rs:45:7
    |
 LL | #[cfg(struct)]
    |       ^^^^^^ expected identifier, found keyword
 
 error: expected identifier, found reserved keyword `priv`
-  --> $DIR/path-kw-as-cfg-pred.rs:45:7
+  --> $DIR/path-kw-as-cfg-pred.rs:47:7
    |
 LL | #[cfg(priv)]
    |       ^^^^ expected identifier, found reserved keyword
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/path-kw-as-cfg-pred.rs:47:7
+  --> $DIR/path-kw-as-cfg-pred.rs:49:7
    |
 LL | #[cfg(_)]
    |       ^ expected identifier, found reserved identifier
 
 error: expected identifier, found keyword `struct`
-  --> $DIR/path-kw-as-cfg-pred.rs:49:12
+  --> $DIR/path-kw-as-cfg-pred.rs:51:12
    |
 LL | #[cfg_attr(struct, path = "foo")]
    |            ^^^^^^ expected identifier, found keyword
@@ -280,7 +280,7 @@ LL | #[cfg_attr(r#struct, path = "foo")]
    |            ++
 
 error: expected identifier, found reserved keyword `priv`
-  --> $DIR/path-kw-as-cfg-pred.rs:51:12
+  --> $DIR/path-kw-as-cfg-pred.rs:53:12
    |
 LL | #[cfg_attr(priv, path = "foo")]
    |            ^^^^ expected identifier, found reserved keyword
@@ -291,31 +291,31 @@ LL | #[cfg_attr(r#priv, path = "foo")]
    |            ++
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/path-kw-as-cfg-pred.rs:53:12
+  --> $DIR/path-kw-as-cfg-pred.rs:55:12
    |
 LL | #[cfg_attr(_, path = "foo")]
    |            ^ expected identifier, found reserved identifier
 
 error: expected identifier, found keyword `struct`
-  --> $DIR/path-kw-as-cfg-pred.rs:55:22
+  --> $DIR/path-kw-as-cfg-pred.rs:57:22
    |
 LL | #[cfg_attr(true, cfg(struct))]
    |                      ^^^^^^ expected identifier, found keyword
 
 error: expected identifier, found reserved keyword `priv`
-  --> $DIR/path-kw-as-cfg-pred.rs:57:22
+  --> $DIR/path-kw-as-cfg-pred.rs:59:22
    |
 LL | #[cfg_attr(true, cfg(priv))]
    |                      ^^^^ expected identifier, found reserved keyword
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/path-kw-as-cfg-pred.rs:59:22
+  --> $DIR/path-kw-as-cfg-pred.rs:61:22
    |
 LL | #[cfg_attr(true, cfg(_))]
    |                      ^ expected identifier, found reserved identifier
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:88:1
+  --> $DIR/path-kw-as-cfg-pred.rs:90:1
    |
 LL | #[cfg(r#crate)]
    | ^^^^^^-------^^
@@ -326,7 +326,7 @@ LL | #[cfg(r#crate)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:91:1
+  --> $DIR/path-kw-as-cfg-pred.rs:93:1
    |
 LL | #[cfg(r#super)]
    | ^^^^^^-------^^
@@ -337,7 +337,7 @@ LL | #[cfg(r#super)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:94:1
+  --> $DIR/path-kw-as-cfg-pred.rs:96:1
    |
 LL | #[cfg(r#self)]
    | ^^^^^^------^^
@@ -348,7 +348,7 @@ LL | #[cfg(r#self)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:97:1
+  --> $DIR/path-kw-as-cfg-pred.rs:99:1
    |
 LL | #[cfg(r#Self)]
    | ^^^^^^------^^
@@ -359,7 +359,7 @@ LL | #[cfg(r#Self)]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:100:1
+  --> $DIR/path-kw-as-cfg-pred.rs:102:1
    |
 LL | #[cfg_attr(r#crate, cfg(r#crate))]
    | ^^^^^^^^^^^-------^^^^^^^^^^^^^^^^
@@ -370,7 +370,7 @@ LL | #[cfg_attr(r#crate, cfg(r#crate))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:104:1
+  --> $DIR/path-kw-as-cfg-pred.rs:106:1
    |
 LL | #[cfg_attr(r#super, cfg(r#super))]
    | ^^^^^^^^^^^-------^^^^^^^^^^^^^^^^
@@ -381,7 +381,7 @@ LL | #[cfg_attr(r#super, cfg(r#super))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:108:1
+  --> $DIR/path-kw-as-cfg-pred.rs:110:1
    |
 LL | #[cfg_attr(r#self, cfg(r#self))]
    | ^^^^^^^^^^^------^^^^^^^^^^^^^^^
@@ -392,7 +392,7 @@ LL | #[cfg_attr(r#self, cfg(r#self))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:112:1
+  --> $DIR/path-kw-as-cfg-pred.rs:114:1
    |
 LL | #[cfg_attr(r#Self, cfg(r#Self))]
    | ^^^^^^^^^^^------^^^^^^^^^^^^^^^
@@ -403,7 +403,7 @@ LL | #[cfg_attr(r#Self, cfg(r#Self))]
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:7:9
+  --> $DIR/path-kw-as-cfg-pred.rs:9:9
    |
 LL |         #[cfg($crate)]
    |         ^^^^^^------^^
@@ -418,7 +418,7 @@ LL |     foo!();
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0539]: malformed `cfg_attr` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:9:9
+  --> $DIR/path-kw-as-cfg-pred.rs:11:9
    |
 LL |         #[cfg_attr($crate, path = "foo")]
    |         ^^^^^^^^^^^------^^^^^^^^^^^^^^^^
@@ -433,7 +433,7 @@ LL |     foo!();
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/path-kw-as-cfg-pred.rs:11:26
+  --> $DIR/path-kw-as-cfg-pred.rs:13:26
    |
 LL |         #[cfg_attr(true, cfg($crate))]
    |                          ^^^^------^
@@ -448,7 +448,7 @@ LL |     foo!();
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:14:9
+  --> $DIR/path-kw-as-cfg-pred.rs:16:9
    |
 LL |         cfg!($crate);
    |         ^^^^^------^
@@ -463,7 +463,7 @@ LL |     foo!();
    = note: this error originates in the macro `cfg` which comes from the expansion of the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:65:5
+  --> $DIR/path-kw-as-cfg-pred.rs:67:5
    |
 LL |     cfg!(crate);
    |     ^^^^^-----^
@@ -474,7 +474,7 @@ LL |     cfg!(crate);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:66:5
+  --> $DIR/path-kw-as-cfg-pred.rs:68:5
    |
 LL |     cfg!(super);
    |     ^^^^^-----^
@@ -485,7 +485,7 @@ LL |     cfg!(super);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:67:5
+  --> $DIR/path-kw-as-cfg-pred.rs:69:5
    |
 LL |     cfg!(self);
    |     ^^^^^----^
@@ -496,7 +496,7 @@ LL |     cfg!(self);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:68:5
+  --> $DIR/path-kw-as-cfg-pred.rs:70:5
    |
 LL |     cfg!(Self);
    |     ^^^^^----^
@@ -507,7 +507,7 @@ LL |     cfg!(Self);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:70:5
+  --> $DIR/path-kw-as-cfg-pred.rs:72:5
    |
 LL |     cfg!(r#crate);
    |     ^^^^^-------^
@@ -518,7 +518,7 @@ LL |     cfg!(r#crate);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:72:5
+  --> $DIR/path-kw-as-cfg-pred.rs:74:5
    |
 LL |     cfg!(r#super);
    |     ^^^^^-------^
@@ -529,7 +529,7 @@ LL |     cfg!(r#super);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:74:5
+  --> $DIR/path-kw-as-cfg-pred.rs:76:5
    |
 LL |     cfg!(r#self);
    |     ^^^^^------^
@@ -540,7 +540,7 @@ LL |     cfg!(r#self);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error[E0539]: malformed `cfg` macro input
-  --> $DIR/path-kw-as-cfg-pred.rs:76:5
+  --> $DIR/path-kw-as-cfg-pred.rs:78:5
    |
 LL |     cfg!(r#Self);
    |     ^^^^^------^
@@ -551,19 +551,19 @@ LL |     cfg!(r#Self);
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
 error: expected identifier, found keyword `struct`
-  --> $DIR/path-kw-as-cfg-pred.rs:79:10
+  --> $DIR/path-kw-as-cfg-pred.rs:81:10
    |
 LL |     cfg!(struct);
    |          ^^^^^^ expected identifier, found keyword
 
 error: expected identifier, found reserved keyword `priv`
-  --> $DIR/path-kw-as-cfg-pred.rs:80:10
+  --> $DIR/path-kw-as-cfg-pred.rs:82:10
    |
 LL |     cfg!(priv);
    |          ^^^^ expected identifier, found reserved keyword
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/path-kw-as-cfg-pred.rs:81:10
+  --> $DIR/path-kw-as-cfg-pred.rs:83:10
    |
 LL |     cfg!(_);
    |          ^ expected identifier, found reserved identifier
diff --git a/tests/ui/cfg/true-false.rs b/tests/ui/cfg/true-false.rs
index 0bd1cf427faf..b8e0e8968c83 100644
--- a/tests/ui/cfg/true-false.rs
+++ b/tests/ui/cfg/true-false.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ reference: cfg.predicate.literal
 
 #![feature(link_cfg)]
 

From 9676838dbc041d4e7f04564f61334eb9b464a231 Mon Sep 17 00:00:00 2001
From: RaphiMuehlbacher <raphi.muehlbacher@gmail.com>
Date: Fri, 6 Mar 2026 09:00:05 +0100
Subject: [PATCH 0146/1059] Add missing `track_caller` to overflowing trait
 methods

---
 library/core/src/ops/arith.rs | 1 +
 library/core/src/ops/bit.rs   | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/library/core/src/ops/arith.rs b/library/core/src/ops/arith.rs
index 6c6479c99845..aec52424af3c 100644
--- a/library/core/src/ops/arith.rs
+++ b/library/core/src/ops/arith.rs
@@ -716,6 +716,7 @@ impl const Neg for $t {
             type Output = $t;
 
             #[inline]
+            #[track_caller]
             #[rustc_inherit_overflow_checks]
             fn neg(self) -> $t { -self }
         }
diff --git a/library/core/src/ops/bit.rs b/library/core/src/ops/bit.rs
index 0cd61b073738..e347a20d2d86 100644
--- a/library/core/src/ops/bit.rs
+++ b/library/core/src/ops/bit.rs
@@ -484,6 +484,7 @@ impl const Shl<$f> for $t {
             type Output = $t;
 
             #[inline]
+            #[track_caller]
             #[rustc_inherit_overflow_checks]
             fn shl(self, other: $f) -> $t {
                 self << other
@@ -606,6 +607,7 @@ impl const Shr<$f> for $t {
             type Output = $t;
 
             #[inline]
+            #[track_caller]
             #[rustc_inherit_overflow_checks]
             fn shr(self, other: $f) -> $t {
                 self >> other
@@ -958,6 +960,7 @@ macro_rules! shl_assign_impl {
         #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const ShlAssign<$f> for $t {
             #[inline]
+            #[track_caller]
             #[rustc_inherit_overflow_checks]
             fn shl_assign(&mut self, other: $f) {
                 *self <<= other
@@ -1044,6 +1047,7 @@ macro_rules! shr_assign_impl {
         #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const ShrAssign<$f> for $t {
             #[inline]
+            #[track_caller]
             #[rustc_inherit_overflow_checks]
             fn shr_assign(&mut self, other: $f) {
                 *self >>= other

From b4f9fac51ab760950f2ceae27660e8f6293aa3b4 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Fri, 6 Mar 2026 09:01:13 +0100
Subject: [PATCH 0147/1059] =?UTF-8?q?perf:=20smol=5Fstr=20=E2=80=94=20avoi?=
 =?UTF-8?q?d=20redundant=20work=20in=20eq=20feat:=20add=20missing=20APIs?=
 =?UTF-8?q?=20to=20smol=5Fstr=20docs:=20Improve=20safety=20documentation?=
 =?UTF-8?q?=20fix:=20borsh=20deserialization=20off-by-one=20for=20inline?=
 =?UTF-8?q?=20threshold?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../rust-analyzer/lib/smol_str/src/borsh.rs   |   2 +-
 .../rust-analyzer/lib/smol_str/src/lib.rs     | 138 +++++++++++++-----
 2 files changed, 103 insertions(+), 37 deletions(-)

diff --git a/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs b/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
index b684a4910c96..944bbecbcf17 100644
--- a/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
@@ -16,7 +16,7 @@ impl BorshDeserialize for SmolStr {
     #[inline]
     fn deserialize_reader<R: Read>(reader: &mut R) -> borsh::io::Result<Self> {
         let len = u32::deserialize_reader(reader)?;
-        if (len as usize) < INLINE_CAP {
+        if (len as usize) <= INLINE_CAP {
             let mut buf = [0u8; INLINE_CAP];
             reader.read_exact(&mut buf[..len as usize])?;
             _ = core::str::from_utf8(&buf[..len as usize]).map_err(|err| {
diff --git a/src/tools/rust-analyzer/lib/smol_str/src/lib.rs b/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
index 0d1f01a32b5a..b30eefc09866 100644
--- a/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
@@ -100,6 +100,24 @@ pub fn is_empty(&self) -> bool {
     pub const fn is_heap_allocated(&self) -> bool {
         matches!(self.0, Repr::Heap(..))
     }
+
+    /// Constructs a `SmolStr` from a byte slice, returning an error if the slice is not valid
+    /// UTF-8.
+    #[inline]
+    pub fn from_utf8(bytes: &[u8]) -> Result<SmolStr, core::str::Utf8Error> {
+        core::str::from_utf8(bytes).map(SmolStr::new)
+    }
+
+    /// Constructs a `SmolStr` from a byte slice without checking that the bytes are valid UTF-8.
+    ///
+    /// # Safety
+    ///
+    /// `bytes` must be valid UTF-8.
+    #[inline]
+    pub unsafe fn from_utf8_unchecked(bytes: &[u8]) -> SmolStr {
+        // SAFETY: caller guarantees bytes are valid UTF-8
+        SmolStr::new(unsafe { core::str::from_utf8_unchecked(bytes) })
+    }
 }
 
 impl Clone for SmolStr {
@@ -116,7 +134,10 @@ fn cold_clone(v: &SmolStr) -> SmolStr {
             return cold_clone(self);
         }
 
-        // SAFETY: We verified that the payload of `Repr` is a POD
+        // SAFETY: The non-heap variants (`Repr::Inline` and `Repr::Static`) contain only
+        // `Copy` data (a `[u8; 23]` + `InlineSize` enum, or a `&'static str` fat pointer)
+        // and carry no drop glue, so a raw `ptr::read` bitwise copy is sound.
+        // The heap variant (`Repr::Heap`) is excluded above.
         unsafe { core::ptr::read(self as *const SmolStr) }
     }
 }
@@ -142,7 +163,12 @@ fn deref(&self) -> &str {
 impl Eq for SmolStr {}
 impl PartialEq<SmolStr> for SmolStr {
     fn eq(&self, other: &SmolStr) -> bool {
-        self.0.ptr_eq(&other.0) || self.as_str() == other.as_str()
+        match (&self.0, &other.0) {
+            (Repr::Inline { len: l_len, buf: l_buf }, Repr::Inline { len: r_len, buf: r_buf }) => {
+                l_len == r_len && l_buf == r_buf
+            }
+            _ => self.as_str() == other.as_str(),
+        }
     }
 }
 
@@ -483,11 +509,15 @@ enum InlineSize {
 }
 
 impl InlineSize {
-    /// SAFETY: `value` must be less than or equal to [`INLINE_CAP`]
+    /// # Safety
+    ///
+    /// `value` must be in the range `0..=23` (i.e. a valid `InlineSize` discriminant).
+    /// Values outside this range would produce an invalid enum discriminant, which is UB.
     #[inline(always)]
     const unsafe fn transmute_from_u8(value: u8) -> Self {
         debug_assert!(value <= InlineSize::_V23 as u8);
-        // SAFETY: The caller is responsible to uphold this invariant
+        // SAFETY: The caller guarantees `value` is a valid discriminant for this
+        // `#[repr(u8)]` enum (0..=23), so the transmute produces a valid `InlineSize`.
         unsafe { mem::transmute::<u8, Self>(value) }
     }
 }
@@ -563,24 +593,15 @@ fn as_str(&self) -> &str {
             Repr::Static(data) => data,
             Repr::Inline { len, buf } => {
                 let len = *len as usize;
-                // SAFETY: len is guaranteed to be <= INLINE_CAP
+                // SAFETY: `len` is an `InlineSize` discriminant (0..=23) which is always
+                // <= INLINE_CAP (23), so `..len` is always in bounds of `buf: [u8; 23]`.
                 let buf = unsafe { buf.get_unchecked(..len) };
-                // SAFETY: buf is guaranteed to be valid utf8 for ..len bytes
+                // SAFETY: All constructors that produce `Repr::Inline` copy from valid
+                // UTF-8 sources (`&str` or char encoding), so `buf[..len]` is valid UTF-8.
                 unsafe { ::core::str::from_utf8_unchecked(buf) }
             }
         }
     }
-
-    fn ptr_eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Heap(l0), Self::Heap(r0)) => Arc::ptr_eq(l0, r0),
-            (Self::Static(l0), Self::Static(r0)) => core::ptr::eq(l0, r0),
-            (Self::Inline { len: l_len, buf: l_buf }, Self::Inline { len: r_len, buf: r_buf }) => {
-                l_len == r_len && l_buf == r_buf
-            }
-            _ => false,
-        }
-    }
 }
 
 /// Convert value to [`SmolStr`] using [`fmt::Display`], potentially without allocating.
@@ -666,7 +687,7 @@ fn to_ascii_lowercase_smolstr(&self) -> SmolStr {
             buf[..len].copy_from_slice(self.as_bytes());
             buf[..len].make_ascii_lowercase();
             SmolStr(Repr::Inline {
-                // SAFETY: `len` is in bounds
+                // SAFETY: `len` is guarded to be <= INLINE_CAP (23), a valid `InlineSize` discriminant.
                 len: unsafe { InlineSize::transmute_from_u8(len as u8) },
                 buf,
             })
@@ -683,7 +704,7 @@ fn to_ascii_uppercase_smolstr(&self) -> SmolStr {
             buf[..len].copy_from_slice(self.as_bytes());
             buf[..len].make_ascii_uppercase();
             SmolStr(Repr::Inline {
-                // SAFETY: `len` is in bounds
+                // SAFETY: `len` is guarded to be <= INLINE_CAP (23), a valid `InlineSize` discriminant.
                 len: unsafe { InlineSize::transmute_from_u8(len as u8) },
                 buf,
             })
@@ -703,8 +724,11 @@ fn replacen_smolstr(&self, from: &str, to: &str, mut count: usize) -> SmolStr {
         if let [from_u8] = from.as_bytes()
             && let [to_u8] = to.as_bytes()
         {
+            // SAFETY: `from` and `to` are single-byte `&str`s. In valid UTF-8, a single-byte
+            // code unit is always in the range 0x00..=0x7F (i.e. ASCII). The closure only
+            // replaces the matching ASCII byte with another ASCII byte, and returns all
+            // other bytes unchanged, so UTF-8 validity is preserved.
             return if self.len() <= count {
-                // SAFETY: `from_u8` & `to_u8` are ascii
                 unsafe { replacen_1_ascii(self, |b| if b == from_u8 { *to_u8 } else { *b }) }
             } else {
                 unsafe {
@@ -736,7 +760,11 @@ fn replacen_smolstr(&self, from: &str, to: &str, mut count: usize) -> SmolStr {
     }
 }
 
-/// SAFETY: `map` fn must only replace ascii with ascii or return unchanged bytes.
+/// # Safety
+///
+/// `map` must satisfy: for every byte `b` in `src`, if `b <= 0x7F` (ASCII) then `map(b)` must
+/// also be `<= 0x7F` (ASCII). If `b > 0x7F` (part of a multi-byte UTF-8 sequence), `map` must
+/// return `b` unchanged. This ensures the output is valid UTF-8 whenever the input is.
 #[inline]
 unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr {
     if src.len() <= INLINE_CAP {
@@ -745,13 +773,16 @@ unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr
             buf[idx] = map(b);
         }
         SmolStr(Repr::Inline {
-            // SAFETY: `len` is in bounds
+            // SAFETY: `src` is a `&str` so `src.len()` <= INLINE_CAP <= 23, which is a
+            // valid `InlineSize` discriminant.
             len: unsafe { InlineSize::transmute_from_u8(src.len() as u8) },
             buf,
         })
     } else {
         let out = src.as_bytes().iter().map(map).collect();
-        // SAFETY: We replaced ascii with ascii on valid utf8 strings.
+        // SAFETY: The caller guarantees `map` only substitutes ASCII bytes with ASCII
+        // bytes and leaves multi-byte UTF-8 continuation bytes untouched, so the
+        // output byte sequence is valid UTF-8.
         unsafe { String::from_utf8_unchecked(out).into() }
     }
 }
@@ -773,9 +804,11 @@ unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr
     let mut is_ascii = [false; N];
 
     while slice.len() >= N {
-        // SAFETY: checked in loop condition
+        // SAFETY: The loop condition guarantees `slice.len() >= N`, so `..N` is in bounds.
         let chunk = unsafe { slice.get_unchecked(..N) };
-        // SAFETY: out_slice has at least same length as input slice and gets sliced with the same offsets
+        // SAFETY: `out_slice` starts with the same length as `slice` (both derived from
+        // `s.len()`) and both are advanced by the same offset `N` each iteration, so
+        // `out_slice.len() >= N` holds whenever `slice.len() >= N`.
         let out_chunk = unsafe { out_slice.get_unchecked_mut(..N) };
 
         for j in 0..N {
@@ -794,6 +827,7 @@ unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr
             out_chunk[j] = convert(&chunk[j]);
         }
 
+        // SAFETY: Same reasoning as above — both slices have len >= N at this point.
         slice = unsafe { slice.get_unchecked(N..) };
         out_slice = unsafe { out_slice.get_unchecked_mut(N..) };
     }
@@ -804,7 +838,9 @@ unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr
         if byte > 127 {
             break;
         }
-        // SAFETY: out_slice has at least same length as input slice
+        // SAFETY: `out_slice` is always the same length as `slice` (both start equal and
+        // are advanced by 1 together), and `slice` is non-empty per the loop condition,
+        // so index 0 and `1..` are in bounds for both.
         unsafe {
             *out_slice.get_unchecked_mut(0) = convert(&byte);
         }
@@ -813,8 +849,10 @@ unsafe fn replacen_1_ascii(src: &str, mut map: impl FnMut(&u8) -> u8) -> SmolStr
     }
 
     unsafe {
-        // SAFETY: we know this is a valid char boundary
-        // since we only skipped over leading ascii bytes
+        // SAFETY: We only advanced past bytes that satisfy `b <= 127`, i.e. ASCII bytes.
+        // In UTF-8, ASCII bytes (0x00..=0x7F) are always single-byte code points and
+        // never appear as continuation bytes, so the remaining `slice` starts at a valid
+        // UTF-8 char boundary.
         let rest = core::str::from_utf8_unchecked(slice);
         (out, rest)
     }
@@ -875,9 +913,9 @@ pub const fn new() -> Self {
 
     /// Builds a [`SmolStr`] from `self`.
     #[must_use]
-    pub fn finish(&self) -> SmolStr {
-        SmolStr(match &self.0 {
-            &SmolStrBuilderRepr::Inline { len, buf } => {
+    pub fn finish(self) -> SmolStr {
+        SmolStr(match self.0 {
+            SmolStrBuilderRepr::Inline { len, buf } => {
                 debug_assert!(len <= INLINE_CAP);
                 Repr::Inline {
                     // SAFETY: We know that `value.len` is less than or equal to the maximum value of `InlineSize`
@@ -885,7 +923,7 @@ pub fn finish(&self) -> SmolStr {
                     buf,
                 }
             }
-            SmolStrBuilderRepr::Heap(heap) => Repr::new(heap),
+            SmolStrBuilderRepr::Heap(heap) => Repr::new(&heap),
         })
     }
 
@@ -900,8 +938,10 @@ pub fn push(&mut self, c: char) {
                     *len += char_len;
                 } else {
                     let mut heap = String::with_capacity(new_len);
-                    // copy existing inline bytes over to the heap
-                    // SAFETY: inline data is guaranteed to be valid utf8 for `old_len` bytes
+                    // SAFETY: `buf[..*len]` was built by prior `push`/`push_str` calls
+                    // that only wrote valid UTF-8 (from `char::encode_utf8` or `&str`
+                    // byte copies), so extending the Vec with these bytes preserves the
+                    // String's UTF-8 invariant.
                     unsafe { heap.as_mut_vec().extend_from_slice(&buf[..*len]) };
                     heap.push(c);
                     self.0 = SmolStrBuilderRepr::Heap(heap);
@@ -926,8 +966,10 @@ pub fn push_str(&mut self, s: &str) {
 
                 let mut heap = String::with_capacity(*len);
 
-                // copy existing inline bytes over to the heap
-                // SAFETY: inline data is guaranteed to be valid utf8 for `old_len` bytes
+                // SAFETY: `buf[..old_len]` was built by prior `push`/`push_str` calls
+                // that only wrote valid UTF-8 (from `char::encode_utf8` or `&str` byte
+                // copies), so extending the Vec with these bytes preserves the String's
+                // UTF-8 invariant.
                 unsafe { heap.as_mut_vec().extend_from_slice(&buf[..old_len]) };
                 heap.push_str(s);
                 self.0 = SmolStrBuilderRepr::Heap(heap);
@@ -945,6 +987,30 @@ fn write_str(&mut self, s: &str) -> fmt::Result {
     }
 }
 
+impl iter::Extend<char> for SmolStrBuilder {
+    fn extend<I: iter::IntoIterator<Item = char>>(&mut self, iter: I) {
+        for c in iter {
+            self.push(c);
+        }
+    }
+}
+
+impl<'a> iter::Extend<&'a str> for SmolStrBuilder {
+    fn extend<I: iter::IntoIterator<Item = &'a str>>(&mut self, iter: I) {
+        for s in iter {
+            self.push_str(s);
+        }
+    }
+}
+
+impl<'a> iter::Extend<&'a String> for SmolStrBuilder {
+    fn extend<I: iter::IntoIterator<Item = &'a String>>(&mut self, iter: I) {
+        for s in iter {
+            self.push_str(s);
+        }
+    }
+}
+
 impl From<SmolStrBuilder> for SmolStr {
     fn from(value: SmolStrBuilder) -> Self {
         value.finish()

From a9fe8d843ee523d8139897c586e91956c965805a Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Fri, 6 Mar 2026 09:38:38 +0100
Subject: [PATCH 0148/1059] Add some missing smol_str API pieces

---
 .../rust-analyzer/lib/smol_str/src/borsh.rs   |   5 +-
 .../rust-analyzer/lib/smol_str/src/lib.rs     | 120 +++++++++++++++++-
 .../rust-analyzer/lib/smol_str/src/serde.rs   |   2 +-
 .../rust-analyzer/lib/smol_str/tests/test.rs  |  24 ++++
 4 files changed, 144 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs b/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
index 944bbecbcf17..44ae513ed444 100644
--- a/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/src/borsh.rs
@@ -29,9 +29,8 @@ fn deserialize_reader<R: Read>(reader: &mut R) -> borsh::io::Result<Self> {
             }))
         } else {
             // u8::vec_from_reader always returns Some on success in current implementation
-            let vec = u8::vec_from_reader(len, reader)?.ok_or_else(|| {
-                Error::new(ErrorKind::Other, "u8::vec_from_reader unexpectedly returned None")
-            })?;
+            let vec = u8::vec_from_reader(len, reader)?
+                .ok_or_else(|| Error::other("u8::vec_from_reader unexpectedly returned None"))?;
             Ok(SmolStr::from(String::from_utf8(vec).map_err(|err| {
                 let msg = err.to_string();
                 Error::new(ErrorKind::InvalidData, msg)
diff --git a/src/tools/rust-analyzer/lib/smol_str/src/lib.rs b/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
index b30eefc09866..55ede286c245 100644
--- a/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/src/lib.rs
@@ -34,13 +34,17 @@
 pub struct SmolStr(Repr);
 
 impl SmolStr {
+    /// The maximum byte length of a string that can be stored inline
+    /// without heap allocation.
+    pub const INLINE_CAP: usize = INLINE_CAP;
+
     /// Constructs an inline variant of `SmolStr`.
     ///
     /// This never allocates.
     ///
     /// # Panics
     ///
-    /// Panics if `text.len() > 23`.
+    /// Panics if `text.len() > `[`SmolStr::INLINE_CAP`].
     #[inline]
     pub const fn new_inline(text: &str) -> SmolStr {
         assert!(text.len() <= INLINE_CAP); // avoids bounds checks in loop
@@ -241,6 +245,48 @@ fn partial_cmp(&self, other: &SmolStr) -> Option<Ordering> {
     }
 }
 
+impl PartialOrd<str> for SmolStr {
+    fn partial_cmp(&self, other: &str) -> Option<Ordering> {
+        Some(self.as_str().cmp(other))
+    }
+}
+
+impl<'a> PartialOrd<&'a str> for SmolStr {
+    fn partial_cmp(&self, other: &&'a str) -> Option<Ordering> {
+        Some(self.as_str().cmp(*other))
+    }
+}
+
+impl PartialOrd<SmolStr> for &str {
+    fn partial_cmp(&self, other: &SmolStr) -> Option<Ordering> {
+        Some((*self).cmp(other.as_str()))
+    }
+}
+
+impl PartialOrd<String> for SmolStr {
+    fn partial_cmp(&self, other: &String) -> Option<Ordering> {
+        Some(self.as_str().cmp(other.as_str()))
+    }
+}
+
+impl PartialOrd<SmolStr> for String {
+    fn partial_cmp(&self, other: &SmolStr) -> Option<Ordering> {
+        Some(self.as_str().cmp(other.as_str()))
+    }
+}
+
+impl<'a> PartialOrd<&'a String> for SmolStr {
+    fn partial_cmp(&self, other: &&'a String) -> Option<Ordering> {
+        Some(self.as_str().cmp(other.as_str()))
+    }
+}
+
+impl PartialOrd<SmolStr> for &String {
+    fn partial_cmp(&self, other: &SmolStr) -> Option<Ordering> {
+        Some(self.as_str().cmp(other.as_str()))
+    }
+}
+
 impl hash::Hash for SmolStr {
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
         self.as_str().hash(hasher);
@@ -385,6 +431,20 @@ fn as_ref(&self) -> &std::path::Path {
     }
 }
 
+impl From<char> for SmolStr {
+    #[inline]
+    fn from(c: char) -> SmolStr {
+        let mut buf = [0; INLINE_CAP];
+        let len = c.len_utf8();
+        c.encode_utf8(&mut buf);
+        SmolStr(Repr::Inline {
+            // SAFETY: A char is at most 4 bytes, which is always <= INLINE_CAP (23).
+            len: unsafe { InlineSize::transmute_from_u8(len as u8) },
+            buf,
+        })
+    }
+}
+
 impl From<&str> for SmolStr {
     #[inline]
     fn from(s: &str) -> SmolStr {
@@ -888,10 +948,18 @@ macro_rules! format_smolstr {
 /// A builder that can be used to efficiently build a [`SmolStr`].
 ///
 /// This won't allocate if the final string fits into the inline buffer.
-#[derive(Clone, Default, Debug, PartialEq, Eq)]
+#[derive(Clone, Default, Debug)]
 pub struct SmolStrBuilder(SmolStrBuilderRepr);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+impl PartialEq for SmolStrBuilder {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
+impl Eq for SmolStrBuilder {}
+
+#[derive(Clone, Debug)]
 enum SmolStrBuilderRepr {
     Inline { len: usize, buf: [u8; INLINE_CAP] },
     Heap(String),
@@ -911,6 +979,52 @@ pub const fn new() -> Self {
         Self(SmolStrBuilderRepr::Inline { buf: [0; INLINE_CAP], len: 0 })
     }
 
+    /// Creates a new empty [`SmolStrBuilder`] with at least the specified capacity.
+    ///
+    /// If `capacity` is less than or equal to [`SmolStr::INLINE_CAP`], the builder
+    /// will use inline storage and not allocate. Otherwise, it will pre-allocate a
+    /// heap buffer of the requested capacity.
+    #[must_use]
+    pub fn with_capacity(capacity: usize) -> Self {
+        if capacity <= INLINE_CAP {
+            Self::new()
+        } else {
+            Self(SmolStrBuilderRepr::Heap(String::with_capacity(capacity)))
+        }
+    }
+
+    /// Returns the number of bytes accumulated in the builder so far.
+    #[inline]
+    pub fn len(&self) -> usize {
+        match &self.0 {
+            SmolStrBuilderRepr::Inline { len, .. } => *len,
+            SmolStrBuilderRepr::Heap(heap) => heap.len(),
+        }
+    }
+
+    /// Returns `true` if the builder has a length of zero bytes.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        match &self.0 {
+            SmolStrBuilderRepr::Inline { len, .. } => *len == 0,
+            SmolStrBuilderRepr::Heap(heap) => heap.is_empty(),
+        }
+    }
+
+    /// Returns a `&str` slice of the builder's current contents.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        match &self.0 {
+            SmolStrBuilderRepr::Inline { len, buf } => {
+                // SAFETY: `buf[..*len]` was built by prior `push`/`push_str` calls
+                // that only wrote valid UTF-8, and `*len <= INLINE_CAP` is maintained
+                // by the inline branch logic.
+                unsafe { core::str::from_utf8_unchecked(&buf[..*len]) }
+            }
+            SmolStrBuilderRepr::Heap(heap) => heap.as_str(),
+        }
+    }
+
     /// Builds a [`SmolStr`] from `self`.
     #[must_use]
     pub fn finish(self) -> SmolStr {
diff --git a/src/tools/rust-analyzer/lib/smol_str/src/serde.rs b/src/tools/rust-analyzer/lib/smol_str/src/serde.rs
index 66cbcd3badc1..9d82d64805c4 100644
--- a/src/tools/rust-analyzer/lib/smol_str/src/serde.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/src/serde.rs
@@ -16,7 +16,7 @@ fn smol_str<'de: 'a, 'a, D>(deserializer: D) -> Result<SmolStr, D::Error>
     impl<'a> Visitor<'a> for SmolStrVisitor {
         type Value = SmolStr;
 
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
             formatter.write_str("a string")
         }
 
diff --git a/src/tools/rust-analyzer/lib/smol_str/tests/test.rs b/src/tools/rust-analyzer/lib/smol_str/tests/test.rs
index 00fab2ee1c7f..83648edeecd0 100644
--- a/src/tools/rust-analyzer/lib/smol_str/tests/test.rs
+++ b/src/tools/rust-analyzer/lib/smol_str/tests/test.rs
@@ -10,6 +10,7 @@
 #[cfg(target_pointer_width = "64")]
 fn smol_str_is_smol() {
     assert_eq!(::std::mem::size_of::<SmolStr>(), ::std::mem::size_of::<String>(),);
+    assert_eq!(::std::mem::size_of::<Option<SmolStr>>(), ::std::mem::size_of::<SmolStr>(),);
 }
 
 #[test]
@@ -332,6 +333,29 @@ fn test_builder_push() {
     assert_eq!("a".repeat(24), s);
 }
 
+#[test]
+fn test_from_char() {
+    // ASCII char
+    let s: SmolStr = 'a'.into();
+    assert_eq!(s, "a");
+    assert!(!s.is_heap_allocated());
+
+    // Multi-byte char (2 bytes)
+    let s: SmolStr = SmolStr::from('ñ');
+    assert_eq!(s, "ñ");
+    assert!(!s.is_heap_allocated());
+
+    // 3-byte char
+    let s: SmolStr = '€'.into();
+    assert_eq!(s, "€");
+    assert!(!s.is_heap_allocated());
+
+    // 4-byte char (emoji)
+    let s: SmolStr = '🦀'.into();
+    assert_eq!(s, "🦀");
+    assert!(!s.is_heap_allocated());
+}
+
 #[cfg(test)]
 mod test_str_ext {
     use smol_str::StrExt;

From 6c28ca91011e8775f859ac87b678d4a39b7e330f Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 23:54:40 -0500
Subject: [PATCH 0149/1059] meta: Allow or fix `unused_features`

These warnings are showing up on the most recent nightly:

    error: feature `f128` is declared but not used
     --> builtins-test/tests/addsub.rs:3:35
      |
    3 | #![cfg_attr(f128_enabled, feature(f128))]
      |                                   ^^^^

It isn't always easy to be more exact with the features we enable, so
mostly ignore this.
---
 library/compiler-builtins/builtins-test-intrinsics/src/main.rs | 2 +-
 library/compiler-builtins/builtins-test/tests/addsub.rs        | 2 +-
 library/compiler-builtins/builtins-test/tests/conv.rs          | 3 ++-
 library/compiler-builtins/builtins-test/tests/div_rem.rs       | 2 +-
 library/compiler-builtins/builtins-test/tests/float_pow.rs     | 2 +-
 library/compiler-builtins/builtins-test/tests/lse.rs           | 1 +
 library/compiler-builtins/builtins-test/tests/mul.rs           | 2 +-
 library/compiler-builtins/crates/libm-macros/tests/basic.rs    | 1 +
 8 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/library/compiler-builtins/builtins-test-intrinsics/src/main.rs b/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
index 848f00de44d1..a3df2c98376c 100644
--- a/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
+++ b/library/compiler-builtins/builtins-test-intrinsics/src/main.rs
@@ -3,7 +3,7 @@
 // compiling a C implementation and forget to implement that intrinsic in Rust, this file will fail
 // to link due to the missing intrinsic (symbol).
 
-#![allow(internal_features)]
+#![allow(internal_features, unused_features)]
 #![deny(dead_code)]
 #![feature(f128)]
 #![feature(f16)]
diff --git a/library/compiler-builtins/builtins-test/tests/addsub.rs b/library/compiler-builtins/builtins-test/tests/addsub.rs
index f3334bd0e2d3..410967967d2a 100644
--- a/library/compiler-builtins/builtins-test/tests/addsub.rs
+++ b/library/compiler-builtins/builtins-test/tests/addsub.rs
@@ -1,4 +1,4 @@
-#![allow(unused_macros)]
+#![allow(unused_macros, unused_features)]
 #![cfg_attr(f16_enabled, feature(f16))]
 #![cfg_attr(f128_enabled, feature(f128))]
 
diff --git a/library/compiler-builtins/builtins-test/tests/conv.rs b/library/compiler-builtins/builtins-test/tests/conv.rs
index 9b04295d2efe..0fd15ad3ee66 100644
--- a/library/compiler-builtins/builtins-test/tests/conv.rs
+++ b/library/compiler-builtins/builtins-test/tests/conv.rs
@@ -1,8 +1,9 @@
 #![cfg_attr(f128_enabled, feature(f128))]
 #![cfg_attr(f16_enabled, feature(f16))]
 // makes configuration easier
-#![allow(unused_macros)]
+#![allow(unused_features)]
 #![allow(unused_imports)]
+#![allow(unused_macros)]
 
 use builtins_test::*;
 use compiler_builtins::float::Float;
diff --git a/library/compiler-builtins/builtins-test/tests/div_rem.rs b/library/compiler-builtins/builtins-test/tests/div_rem.rs
index caee4166c995..4ff86385a963 100644
--- a/library/compiler-builtins/builtins-test/tests/div_rem.rs
+++ b/library/compiler-builtins/builtins-test/tests/div_rem.rs
@@ -1,5 +1,5 @@
 #![feature(f128)]
-#![allow(unused_macros)]
+#![allow(unused_macros, unused_features)]
 
 use builtins_test::*;
 use compiler_builtins::int::sdiv::{__divmoddi4, __divmodsi4, __divmodti4};
diff --git a/library/compiler-builtins/builtins-test/tests/float_pow.rs b/library/compiler-builtins/builtins-test/tests/float_pow.rs
index a17dff27c105..3cea83a255c8 100644
--- a/library/compiler-builtins/builtins-test/tests/float_pow.rs
+++ b/library/compiler-builtins/builtins-test/tests/float_pow.rs
@@ -1,4 +1,4 @@
-#![allow(unused_macros)]
+#![allow(unused_macros, unused_features)]
 #![cfg_attr(f128_enabled, feature(f128))]
 
 #[cfg_attr(x86_no_sse, allow(unused))]
diff --git a/library/compiler-builtins/builtins-test/tests/lse.rs b/library/compiler-builtins/builtins-test/tests/lse.rs
index c45fc161b6c4..d408fe193bcf 100644
--- a/library/compiler-builtins/builtins-test/tests/lse.rs
+++ b/library/compiler-builtins/builtins-test/tests/lse.rs
@@ -1,3 +1,4 @@
+#![allow(unused_features)]
 #![feature(decl_macro)] // so we can use pub(super)
 #![feature(macro_metavar_expr_concat)]
 #![cfg(all(target_arch = "aarch64", feature = "mangled-names"))]
diff --git a/library/compiler-builtins/builtins-test/tests/mul.rs b/library/compiler-builtins/builtins-test/tests/mul.rs
index bbf1157db42f..30516ebaf786 100644
--- a/library/compiler-builtins/builtins-test/tests/mul.rs
+++ b/library/compiler-builtins/builtins-test/tests/mul.rs
@@ -1,6 +1,6 @@
 #![cfg_attr(f16_enabled, feature(f16))]
 #![cfg_attr(f128_enabled, feature(f128))]
-#![allow(unused_macros)]
+#![allow(unused_macros, unused_features)]
 
 use builtins_test::*;
 
diff --git a/library/compiler-builtins/crates/libm-macros/tests/basic.rs b/library/compiler-builtins/crates/libm-macros/tests/basic.rs
index b4276262229f..1876db8f5869 100644
--- a/library/compiler-builtins/crates/libm-macros/tests/basic.rs
+++ b/library/compiler-builtins/crates/libm-macros/tests/basic.rs
@@ -1,3 +1,4 @@
+#![allow(unused_features)]
 #![feature(f16)]
 #![feature(f128)]
 // `STATUS_DLL_NOT_FOUND` on i686 MinGW, not worth looking into.

From c1d0e35db07f961803781cd3e7e49b452056a116 Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Fri, 6 Mar 2026 01:47:22 -0800
Subject: [PATCH 0150/1059] c-b: fix path to CONTRIBUTING.md in README.md

---
 library/compiler-builtins/compiler-builtins/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/compiler-builtins/README.md b/library/compiler-builtins/compiler-builtins/README.md
index a12bd2ee7349..63cbf33d2aea 100644
--- a/library/compiler-builtins/compiler-builtins/README.md
+++ b/library/compiler-builtins/compiler-builtins/README.md
@@ -22,7 +22,7 @@ See `build.rs` for details.
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md).
+See [CONTRIBUTING.md](../CONTRIBUTING.md).
 
 ## Progress
 

From 95fcc2d5f966afa736ef88cf9be6e6e244a38e3c Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 24 Feb 2026 18:29:05 +0800
Subject: [PATCH 0151/1059] fix: cfg_select supports non token-tree tokens

- Fix single non-curly groups is ignored `true => ((),)`, old: `(),`, new: `((),)`

Example
---
```rust
const _: i32 = cfg_select! { true => 2 + 3, _ => 3 + 4 };
```

**Before this PR**

```rust
const _: i32 = cfg_select! { true => 2 /* expected a token tree after `=>` */+ 3, _ => 3 + 4 };
```

**After this PR**

```rust
const _: i32 = 2 + 3;
```
---
 .../macro_expansion_tests/builtin_fn_macro.rs | 12 ++++++++
 .../crates/hir-expand/src/builtin/fn_macro.rs | 30 +++++++++++++++++--
 2 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs
index eeaf865338bd..46cdb39c5b46 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs
@@ -568,6 +568,12 @@ fn cfg_select() {
     _ => { fn true_2() {} }
 }
 
+const _: ((),) = cfg_select! { _ => ((), ) };
+const _: i32 = cfg_select! { true => 2 + 3, _ => 3 + 4 };
+const _: i32 = cfg_select! { false => 2 + 3, _ => 3 + 4 };
+const _: bool = cfg_select! { _ => 2 < 3 };
+const _: bool = cfg_select! { true => foo::<(), fn() -> Foo<i32, i64>>(1,), _ => false };
+
 cfg_select! {
     false => { fn false_3() {} }
 }
@@ -589,6 +595,12 @@ fn true_1() {}
 
 fn true_2() {}
 
+const _: ((),) = ((), );
+const _: i32 = 2+3;
+const _: i32 = 3+4;
+const _: bool = 2<3;
+const _: bool = foo::<(), fn() -> Foo<i32, i64>>(1, );
+
 /* error: none of the predicates in this `cfg_select` evaluated to true */
 
 /* error: expected `=>` after cfg expression */
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
index 949b22b0adaa..2de7290a2198 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
@@ -381,16 +381,40 @@ fn cfg_select_expand(
                 );
             }
         }
-        let expand_to_if_active = match iter.next() {
-            Some(tt::TtElement::Subtree(_, tt)) => tt.remaining(),
-            _ => {
+        let expand_to_if_active = match iter.peek() {
+            Some(tt::TtElement::Subtree(sub, tt)) if sub.delimiter.kind == DelimiterKind::Brace => {
+                iter.next();
+                tt.remaining()
+            }
+            None | Some(TtElement::Leaf(tt::Leaf::Punct(tt::Punct { char: ',', .. }))) => {
                 let err_span = iter.peek().map(|it| it.first_span()).unwrap_or(span);
+                iter.next();
                 return ExpandResult::new(
                     tt::TopSubtree::empty(tt::DelimSpan::from_single(span)),
                     ExpandError::other(err_span, "expected a token tree after `=>`"),
                 );
             }
+            Some(_) => {
+                let expr = expect_fragment(
+                    db,
+                    &mut iter,
+                    parser::PrefixEntryPoint::Expr,
+                    tt.top_subtree().delimiter.delim_span(),
+                );
+                if let Some(err) = expr.err {
+                    return ExpandResult::new(
+                        tt::TopSubtree::empty(tt::DelimSpan::from_single(span)),
+                        err.into(),
+                    );
+                }
+                expr.value
+            }
         };
+        if let Some(TtElement::Leaf(tt::Leaf::Punct(p))) = iter.peek()
+            && p.char == ','
+        {
+            iter.next();
+        }
 
         if expand_to.is_none() && active {
             expand_to = Some(expand_to_if_active);

From 4d24ed1b24d33705e5a6e9eb907e1acf0e3b5bf1 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 20:27:19 +0530
Subject: [PATCH 0152/1059] remove make from extract_type_alias

---
 .../src/handlers/extract_type_alias.rs        | 24 ++++++++++---------
 .../src/ast/syntax_factory/constructors.rs    |  8 +++++++
 2 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
index 769bbd976a26..86c2e25b2144 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
@@ -2,7 +2,7 @@
 use hir::HirDisplay;
 use ide_db::syntax_helpers::node_ext::walk_ty;
 use syntax::{
-    ast::{self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel, make},
+    ast::{self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel, syntax_factory::SyntaxFactory},
     syntax_editor,
 };
 
@@ -44,9 +44,9 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let resolved_ty = if !resolved_ty.contains_unknown() {
         let module = ctx.sema.scope(ty.syntax())?.module();
         let resolved_ty = resolved_ty.display_source_code(ctx.db(), module.into(), false).ok()?;
-        make::ty(&resolved_ty)
+        resolved_ty
     } else {
-        ty.clone()
+        ty.to_string()
     };
 
     acc.add(
@@ -54,7 +54,11 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         "Extract type as type alias",
         target,
         |builder| {
+            
             let mut edit = builder.make_editor(node);
+            let make = SyntaxFactory::without_mappings();
+
+            let resolved_ty = make.ty(&resolved_ty);
 
             let mut known_generics = match item.generic_param_list() {
                 Some(it) => it.generic_params().collect(),
@@ -68,22 +72,20 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             }
             let generics = collect_used_generics(&ty, &known_generics);
             let generic_params =
-                generics.map(|it| make::generic_param_list(it.into_iter().cloned()));
+                generics.map(|it| make.generic_param_list(it.into_iter().cloned()));
 
             // Replace original type with the alias
             let ty_args = generic_params.as_ref().map(|it| it.to_generic_args().generic_args());
             let new_ty = if let Some(ty_args) = ty_args {
-                make::generic_ty_path_segment(make::name_ref("Type"), ty_args)
+                make.generic_ty_path_segment(make.name_ref("Type"), ty_args)
             } else {
-                make::path_segment(make::name_ref("Type"))
-            }
-            .clone_for_update();
+                make.path_segment(make.name_ref("Type"))
+            };
             edit.replace(ty.syntax(), new_ty.syntax());
 
             // Insert new alias
             let ty_alias =
-                make::ty_alias(None, "Type", generic_params, None, None, Some((resolved_ty, None)))
-                    .clone_for_update();
+                make.ty_alias(None, "Type", generic_params, None, None, Some((resolved_ty, None)));
 
             if let Some(cap) = ctx.config.snippet_cap
                 && let Some(name) = ty_alias.name()
@@ -96,7 +98,7 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
                 syntax_editor::Position::before(node),
                 vec![
                     ty_alias.syntax().clone().into(),
-                    make::tokens::whitespace(&format!("\n\n{indent}")).into(),
+                    make.whitespace(&format!("\n\n{indent}")).into(),
                 ],
             );
 
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 27182191c3da..19d4721fe10f 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -287,6 +287,14 @@ pub fn path_segment(&self, name_ref: ast::NameRef) -> ast::PathSegment {
         ast
     }
 
+    pub fn generic_ty_path_segment(
+        &self,
+        name_ref: ast::NameRef,
+        generic_args: impl IntoIterator<Item = ast::GenericArg>,
+    ) -> ast::PathSegment {
+        make::generic_ty_path_segment(name_ref, generic_args).clone_for_update()
+    }
+
     pub fn path_segment_generics(
         &self,
         name_ref: ast::NameRef,

From 9795cd922bc9261861fcbd20334bb88382dfc246 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 21:06:29 +0530
Subject: [PATCH 0153/1059] remove make from add_turbo_fish

---
 .../ide-assists/src/handlers/add_turbo_fish.rs      | 13 +++++++------
 .../ide-assists/src/handlers/extract_type_alias.rs  |  9 +++++----
 .../syntax/src/ast/syntax_factory/constructors.rs   |  4 ++++
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs
index be13b04873c8..c5e722d87e1a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs
@@ -2,7 +2,7 @@
 use ide_db::defs::{Definition, NameRefClass};
 use syntax::{
     AstNode,
-    ast::{self, HasArgList, HasGenericArgs, make, syntax_factory::SyntaxFactory},
+    ast::{self, HasArgList, HasGenericArgs, syntax_factory::SyntaxFactory},
     syntax_editor::Position,
 };
 
@@ -94,20 +94,21 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 ident.text_range(),
                 |builder| {
                     let mut editor = builder.make_editor(let_stmt.syntax());
+                    let make = SyntaxFactory::without_mappings();
 
                     if let_stmt.semicolon_token().is_none() {
                         editor.insert(
                             Position::last_child_of(let_stmt.syntax()),
-                            make::tokens::semicolon(),
+                            make.token(syntax::SyntaxKind::SEMICOLON),
                         );
                     }
 
-                    let placeholder_ty = make::ty_placeholder().clone_for_update();
+                    let placeholder_ty = make.ty_placeholder();
 
                     if let Some(pat) = let_stmt.pat() {
                         let elements = vec![
-                            make::token(syntax::SyntaxKind::COLON).into(),
-                            make::token(syntax::SyntaxKind::WHITESPACE).into(),
+                            make.token(syntax::SyntaxKind::COLON).into(),
+                            make.whitespace(" ").into(),
                             placeholder_ty.syntax().clone().into(),
                         ];
                         editor.insert_all(Position::after(pat.syntax()), elements);
@@ -188,7 +189,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
 
 /// This will create a turbofish generic arg list corresponding to the number of arguments
 fn get_fish_head(make: &SyntaxFactory, number_of_arguments: usize) -> ast::GenericArgList {
-    let args = (0..number_of_arguments).map(|_| make::type_arg(make::ty_placeholder()).into());
+    let args = (0..number_of_arguments).map(|_| make.type_arg(make.ty_placeholder()).into());
     make.generic_arg_list(args, true)
 }
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
index 86c2e25b2144..e4fdac27f47f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
@@ -2,7 +2,10 @@
 use hir::HirDisplay;
 use ide_db::syntax_helpers::node_ext::walk_ty;
 use syntax::{
-    ast::{self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel, syntax_factory::SyntaxFactory},
+    ast::{
+        self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel,
+        syntax_factory::SyntaxFactory,
+    },
     syntax_editor,
 };
 
@@ -43,8 +46,7 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let resolved_ty = ctx.sema.resolve_type(&ty)?;
     let resolved_ty = if !resolved_ty.contains_unknown() {
         let module = ctx.sema.scope(ty.syntax())?.module();
-        let resolved_ty = resolved_ty.display_source_code(ctx.db(), module.into(), false).ok()?;
-        resolved_ty
+        resolved_ty.display_source_code(ctx.db(), module.into(), false).ok()?
     } else {
         ty.to_string()
     };
@@ -54,7 +56,6 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         "Extract type as type alias",
         target,
         |builder| {
-            
             let mut edit = builder.make_editor(node);
             let make = SyntaxFactory::without_mappings();
 
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 19d4721fe10f..159b1918059c 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -295,6 +295,10 @@ pub fn generic_ty_path_segment(
         make::generic_ty_path_segment(name_ref, generic_args).clone_for_update()
     }
 
+    pub fn ty_placeholder(&self) -> ast::Type {
+        make::ty_placeholder().clone_for_update()
+    }
+
     pub fn path_segment_generics(
         &self,
         name_ref: ast::NameRef,

From 50a5d5b46dac58b70d25b8059eb4e80adc474f09 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 21:29:30 +0530
Subject: [PATCH 0154/1059] remove make from convert_bool_to_enum

---
 .../src/handlers/convert_bool_to_enum.rs      | 89 +++++++++++--------
 .../src/ast/syntax_factory/constructors.rs    | 21 +++++
 2 files changed, 73 insertions(+), 37 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
index 434fbbae05c4..934779810054 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
@@ -12,9 +12,10 @@
 };
 use itertools::Itertools;
 use syntax::ast::edit::AstNodeEdit;
+use syntax::ast::syntax_factory::SyntaxFactory;
 use syntax::{
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T,
-    ast::{self, HasName, edit::IndentLevel, make},
+    ast::{self, HasName, edit::IndentLevel},
 };
 
 use crate::{
@@ -62,19 +63,28 @@ pub(crate) fn convert_bool_to_enum(acc: &mut Assists, ctx: &AssistContext<'_>) -
         "Convert boolean to enum",
         target,
         |edit| {
+            let make = SyntaxFactory::without_mappings();
             if let Some(ty) = &ty_annotation {
                 cov_mark::hit!(replaces_ty_annotation);
                 edit.replace(ty.syntax().text_range(), "Bool");
             }
 
             if let Some(initializer) = initializer {
-                replace_bool_expr(edit, initializer);
+                replace_bool_expr(edit, initializer, &make);
             }
 
             let usages = definition.usages(&ctx.sema).all();
-            add_enum_def(edit, ctx, &usages, target_node, &target_module);
+            add_enum_def(edit, ctx, &usages, target_node, &target_module, &make);
             let mut delayed_mutations = Vec::new();
-            replace_usages(edit, ctx, usages, definition, &target_module, &mut delayed_mutations);
+            replace_usages(
+                edit,
+                ctx,
+                usages,
+                definition,
+                &target_module,
+                &mut delayed_mutations,
+                &make,
+            );
             for (scope, path) in delayed_mutations {
                 insert_use(&scope, path, &ctx.config.insert_use);
             }
@@ -168,16 +178,16 @@ fn find_bool_node(ctx: &AssistContext<'_>) -> Option<BoolNodeData> {
     }
 }
 
-fn replace_bool_expr(edit: &mut SourceChangeBuilder, expr: ast::Expr) {
+fn replace_bool_expr(edit: &mut SourceChangeBuilder, expr: ast::Expr, make: &SyntaxFactory) {
     let expr_range = expr.syntax().text_range();
-    let enum_expr = bool_expr_to_enum_expr(expr);
+    let enum_expr = bool_expr_to_enum_expr(expr, make);
     edit.replace(expr_range, enum_expr.syntax().text())
 }
 
 /// Converts an expression of type `bool` to one of the new enum type.
-fn bool_expr_to_enum_expr(expr: ast::Expr) -> ast::Expr {
-    let true_expr = make::expr_path(make::path_from_text("Bool::True"));
-    let false_expr = make::expr_path(make::path_from_text("Bool::False"));
+fn bool_expr_to_enum_expr(expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {
+    let true_expr = make.expr_path(make.path_from_text("Bool::True"));
+    let false_expr = make.expr_path(make.path_from_text("Bool::False"));
 
     if let ast::Expr::Literal(literal) = &expr {
         match literal.kind() {
@@ -186,10 +196,10 @@ fn bool_expr_to_enum_expr(expr: ast::Expr) -> ast::Expr {
             _ => expr,
         }
     } else {
-        make::expr_if(
+        make.expr_if(
             expr,
-            make::tail_only_block_expr(true_expr),
-            Some(ast::ElseBranch::Block(make::tail_only_block_expr(false_expr))),
+            make.tail_only_block_expr(true_expr),
+            Some(ast::ElseBranch::Block(make.tail_only_block_expr(false_expr))),
         )
         .into()
     }
@@ -203,11 +213,13 @@ fn replace_usages(
     target_definition: Definition,
     target_module: &hir::Module,
     delayed_mutations: &mut Vec<(ImportScope, ast::Path)>,
+    make: &SyntaxFactory,
 ) {
     for (file_id, references) in usages {
         edit.edit_file(file_id.file_id(ctx.db()));
 
-        let refs_with_imports = augment_references_with_imports(ctx, references, target_module);
+        let refs_with_imports =
+            augment_references_with_imports(ctx, references, target_module, make);
 
         refs_with_imports.into_iter().rev().for_each(
             |FileReferenceWithImport { range, name, import_data }| {
@@ -224,12 +236,13 @@ fn replace_usages(
                             target_definition,
                             target_module,
                             delayed_mutations,
+                            make,
                         )
                     }
                 } else if let Some(initializer) = find_assignment_usage(&name) {
                     cov_mark::hit!(replaces_assignment);
 
-                    replace_bool_expr(edit, initializer);
+                    replace_bool_expr(edit, initializer, make);
                 } else if let Some((prefix_expr, inner_expr)) = find_negated_usage(&name) {
                     cov_mark::hit!(replaces_negation);
 
@@ -247,7 +260,7 @@ fn replace_usages(
                 {
                     cov_mark::hit!(replaces_record_expr);
 
-                    let enum_expr = bool_expr_to_enum_expr(initializer);
+                    let enum_expr = bool_expr_to_enum_expr(initializer, make);
                     utils::replace_record_field_expr(ctx, edit, record_field, enum_expr);
                 } else if let Some(pat) = find_record_pat_field_usage(&name) {
                     match pat {
@@ -263,6 +276,7 @@ fn replace_usages(
                                     target_definition,
                                     target_module,
                                     delayed_mutations,
+                                    make,
                                 )
                             }
                         }
@@ -272,14 +286,14 @@ fn replace_usages(
                             if let Some(expr) = literal_pat.literal().and_then(|literal| {
                                 literal.syntax().ancestors().find_map(ast::Expr::cast)
                             }) {
-                                replace_bool_expr(edit, expr);
+                                replace_bool_expr(edit, expr, make);
                             }
                         }
                         _ => (),
                     }
                 } else if let Some((ty_annotation, initializer)) = find_assoc_const_usage(&name) {
                     edit.replace(ty_annotation.syntax().text_range(), "Bool");
-                    replace_bool_expr(edit, initializer);
+                    replace_bool_expr(edit, initializer, make);
                 } else if let Some(receiver) = find_method_call_expr_usage(&name) {
                     edit.replace(
                         receiver.syntax().text_range(),
@@ -296,10 +310,10 @@ fn replace_usages(
                             ctx,
                             edit,
                             record_field,
-                            make::expr_bin_op(
+                            make.expr_bin_op(
                                 expr,
                                 ast::BinaryOp::CmpOp(ast::CmpOp::Eq { negated: false }),
-                                make::expr_path(make::path_from_text("Bool::True")),
+                                make.expr_path(make.path_from_text("Bool::True")),
                             ),
                         );
                     } else {
@@ -327,6 +341,7 @@ fn augment_references_with_imports(
     ctx: &AssistContext<'_>,
     references: Vec<FileReference>,
     target_module: &hir::Module,
+    make: &SyntaxFactory,
 ) -> Vec<FileReferenceWithImport> {
     let mut visited_modules = FxHashSet::default();
 
@@ -357,9 +372,9 @@ fn augment_references_with_imports(
                                 cfg,
                             )
                             .map(|mod_path| {
-                                make::path_concat(
+                                make.path_concat(
                                     mod_path_to_ast(&mod_path, edition),
-                                    make::path_from_text("Bool"),
+                                    make.path_from_text("Bool"),
                                 )
                             })?;
 
@@ -458,6 +473,7 @@ fn add_enum_def(
     usages: &UsageSearchResult,
     target_node: SyntaxNode,
     target_module: &hir::Module,
+    make: &SyntaxFactory,
 ) -> Option<()> {
     let insert_before = node_to_insert_before(target_node);
 
@@ -482,7 +498,7 @@ fn add_enum_def(
         .any(|module| module.nearest_non_block_module(ctx.db()) != *target_module);
 
     let indent = IndentLevel::from_node(&insert_before);
-    let enum_def = make_bool_enum(make_enum_pub).reset_indent().indent(indent);
+    let enum_def = make_bool_enum(make_enum_pub, make).reset_indent().indent(indent);
 
     edit.insert(
         insert_before.text_range().start(),
@@ -504,31 +520,30 @@ fn node_to_insert_before(target_node: SyntaxNode) -> SyntaxNode {
         .unwrap_or(target_node)
 }
 
-fn make_bool_enum(make_pub: bool) -> ast::Enum {
-    let derive_eq = make::attr_outer(make::meta_token_tree(
-        make::ext::ident_path("derive"),
-        make::token_tree(
+fn make_bool_enum(make_pub: bool, make: &SyntaxFactory) -> ast::Enum {
+    let derive_eq = make.attr_outer(make.meta_token_tree(
+        make.ident_path("derive"),
+        make.token_tree(
             T!['('],
             vec![
-                NodeOrToken::Token(make::tokens::ident("PartialEq")),
-                NodeOrToken::Token(make::token(T![,])),
-                NodeOrToken::Token(make::tokens::single_space()),
-                NodeOrToken::Token(make::tokens::ident("Eq")),
+                NodeOrToken::Token(make.ident("PartialEq")),
+                NodeOrToken::Token(make.token(T![,])),
+                NodeOrToken::Token(make.whitespace(" ")),
+                NodeOrToken::Token(make.ident("Eq")),
             ],
         ),
     ));
-    make::enum_(
+    make.enum_(
         [derive_eq],
-        if make_pub { Some(make::visibility_pub()) } else { None },
-        make::name("Bool"),
+        if make_pub { Some(make.visibility_pub()) } else { None },
+        make.name("Bool"),
         None,
         None,
-        make::variant_list(vec![
-            make::variant(None, make::name("True"), None, None),
-            make::variant(None, make::name("False"), None, None),
+        make.variant_list(vec![
+            make.variant(None, make.name("True"), None, None),
+            make.variant(None, make.name("False"), None, None),
         ]),
     )
-    .clone_for_update()
 }
 
 #[cfg(test)]
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 159b1918059c..e4aa1680ae2b 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -97,6 +97,19 @@ pub fn struct_(
         make::struct_(visibility, strukt_name, generic_param_list, field_list).clone_for_update()
     }
 
+    pub fn enum_(
+        &self,
+        attrs: impl IntoIterator<Item = ast::Attr>,
+        visibility: Option<ast::Visibility>,
+        enum_name: ast::Name,
+        generic_param_list: Option<ast::GenericParamList>,
+        where_clause: Option<ast::WhereClause>,
+        variant_list: ast::VariantList,
+    ) -> ast::Enum {
+        make::enum_(attrs, visibility, enum_name, generic_param_list, where_clause, variant_list)
+            .clone_for_update()
+    }
+
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
         let ast::Expr::FieldExpr(ast) =
             make::expr_field(receiver.clone(), field).clone_for_update()
@@ -295,6 +308,14 @@ pub fn generic_ty_path_segment(
         make::generic_ty_path_segment(name_ref, generic_args).clone_for_update()
     }
 
+    pub fn tail_only_block_expr(&self, tail_expr: ast::Expr) -> ast::BlockExpr {
+        make::tail_only_block_expr(tail_expr)
+    }
+
+    pub fn expr_bin_op(&self, lhs: ast::Expr, op: ast::BinaryOp, rhs: ast::Expr) -> ast::Expr {
+        make::expr_bin_op(lhs, op, rhs)
+    }
+
     pub fn ty_placeholder(&self) -> ast::Type {
         make::ty_placeholder().clone_for_update()
     }

From 7edd92458629bb485e55f18dc8394a4e91c759e0 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 22:51:52 +0530
Subject: [PATCH 0155/1059] remove make from generate_default_from_new

---
 .../src/handlers/generate_default_from_new.rs       | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
index 48400d436aa6..485184723bdf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
@@ -2,7 +2,7 @@
 use stdx::format_to;
 use syntax::{
     AstNode,
-    ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl, make},
+    ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl, syntax_factory::SyntaxFactory},
 };
 
 use crate::{
@@ -72,7 +72,9 @@ pub(crate) fn generate_default_from_new(acc: &mut Assists, ctx: &AssistContext<'
             let default_code = "    fn default() -> Self {
         Self::new()
     }";
-            let code = generate_trait_impl_text_from_impl(&impl_, self_ty, "Default", default_code);
+            let make = SyntaxFactory::without_mappings();
+            let code =
+                generate_trait_impl_text_from_impl(&impl_, self_ty, "Default", default_code, &make);
             builder.insert(insert_location.end(), code);
         },
     )
@@ -84,6 +86,7 @@ fn generate_trait_impl_text_from_impl(
     self_ty: ast::Type,
     trait_text: &str,
     code: &str,
+    make: &SyntaxFactory,
 ) -> String {
     let generic_params = impl_.generic_param_list().map(|generic_params| {
         let lifetime_params =
@@ -92,18 +95,18 @@ fn generate_trait_impl_text_from_impl(
             // remove defaults since they can't be specified in impls
             let param = match param {
                 ast::TypeOrConstParam::Type(param) => {
-                    let param = make::type_param(param.name()?, param.type_bound_list());
+                    let param = make.type_param(param.name()?, param.type_bound_list());
                     ast::GenericParam::TypeParam(param)
                 }
                 ast::TypeOrConstParam::Const(param) => {
-                    let param = make::const_param(param.name()?, param.ty()?);
+                    let param = make.const_param(param.name()?, param.ty()?);
                     ast::GenericParam::ConstParam(param)
                 }
             };
             Some(param)
         });
 
-        make::generic_param_list(itertools::chain(lifetime_params, ty_or_const_params))
+        make.generic_param_list(itertools::chain(lifetime_params, ty_or_const_params))
     });
 
     let mut buf = String::with_capacity(code.len());

From ab42f51d1aad2f623e606b42a58c928abd861cfb Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 22:58:14 +0530
Subject: [PATCH 0156/1059] remove make from generate_fn_type_alias_from_new

---
 .../src/handlers/generate_fn_type_alias.rs    | 20 +++++++++----------
 .../src/ast/syntax_factory/constructors.rs    | 16 ++++++++++++++-
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
index 7fd94b4bedc8..6bcbd9b0ccc2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
@@ -2,7 +2,7 @@
 use ide_db::assists::{AssistId, GroupLabel};
 use syntax::{
     AstNode,
-    ast::{self, HasGenericParams, HasName, edit::IndentLevel, make},
+    ast::{self, HasGenericParams, HasName, edit::IndentLevel, syntax_factory::SyntaxFactory},
     syntax_editor,
 };
 
@@ -56,6 +56,7 @@ pub(crate) fn generate_fn_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>)
             func_node.syntax().text_range(),
             |builder| {
                 let mut edit = builder.make_editor(func);
+                let make = SyntaxFactory::without_mappings();
 
                 let alias_name = format!("{}Fn", stdx::to_camel_case(&name.to_string()));
 
@@ -68,24 +69,24 @@ pub(crate) fn generate_fn_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>)
                     let is_mut = self_ty.is_mutable_reference();
 
                     if let Some(adt) = self_ty.strip_references().as_adt() {
-                        let inner_type = make::ty(adt.name(ctx.db()).as_str());
+                        let inner_type = make.ty(adt.name(ctx.db()).as_str());
 
                         let ast_self_ty =
-                            if is_ref { make::ty_ref(inner_type, is_mut) } else { inner_type };
+                            if is_ref { make.ty_ref(inner_type, is_mut) } else { inner_type };
 
-                        fn_params_vec.push(make::unnamed_param(ast_self_ty));
+                        fn_params_vec.push(make.unnamed_param(ast_self_ty));
                     }
                 }
 
                 fn_params_vec.extend(param_list.params().filter_map(|p| match style {
                     ParamStyle::Named => Some(p),
-                    ParamStyle::Unnamed => p.ty().map(make::unnamed_param),
+                    ParamStyle::Unnamed => p.ty().map(|ty| make.unnamed_param(ty)),
                 }));
 
                 let generic_params = func_node.generic_param_list();
 
                 let is_unsafe = func_node.unsafe_token().is_some();
-                let ty = make::ty_fn_ptr(
+                let ty = make.ty_fn_ptr(
                     is_unsafe,
                     func_node.abi(),
                     fn_params_vec.into_iter(),
@@ -93,22 +94,21 @@ pub(crate) fn generate_fn_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>)
                 );
 
                 // Insert new alias
-                let ty_alias = make::ty_alias(
+                let ty_alias = make.ty_alias(
                     None,
                     &alias_name,
                     generic_params,
                     None,
                     None,
                     Some((ast::Type::FnPtrType(ty), None)),
-                )
-                .clone_for_update();
+                );
 
                 let indent = IndentLevel::from_node(insertion_node);
                 edit.insert_all(
                     syntax_editor::Position::before(insertion_node),
                     vec![
                         ty_alias.syntax().clone().into(),
-                        make::tokens::whitespace(&format!("\n\n{indent}")).into(),
+                        make.whitespace(&format!("\n\n{indent}")).into(),
                     ],
                 );
 
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index e4aa1680ae2b..1601ff3174a7 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -3,7 +3,7 @@
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
     ast::{
         self, HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,
-        HasTypeBounds, HasVisibility, RangeItem, make,
+        HasTypeBounds, HasVisibility, Param, RangeItem, make,
     },
     syntax_editor::SyntaxMappingBuilder,
 };
@@ -110,6 +110,20 @@ pub fn enum_(
             .clone_for_update()
     }
 
+    pub fn unnamed_param(&self, ty: ast::Type) -> ast::Param {
+        make::unnamed_param(ty).clone_for_update()
+    }
+
+    pub fn ty_fn_ptr<I: Iterator<Item = Param>>(
+        &self,
+        is_unsafe: bool,
+        abi: Option<ast::Abi>,
+        params: I,
+        ret_type: Option<ast::RetType>,
+    ) -> ast::FnPtrType {
+        make::ty_fn_ptr(is_unsafe, abi, params, ret_type).clone_for_update()
+    }
+
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
         let ast::Expr::FieldExpr(ast) =
             make::expr_field(receiver.clone(), field).clone_for_update()

From fa86ca068713378b6feb494ff63631647d32843b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 23:22:37 +0530
Subject: [PATCH 0157/1059] remove make from move_bound

---
 .../ide-assists/src/handlers/move_bounds.rs       | 15 +++++++--------
 .../syntax/src/ast/syntax_factory/constructors.rs | 10 ++++++++++
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
index e5425abab097..e9b77a729438 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
@@ -3,7 +3,7 @@
     ast::{
         self, AstNode, HasName, HasTypeBounds,
         edit_in_place::{GenericParamsOwnerEdit, Removable},
-        make,
+        syntax_factory::SyntaxFactory,
     },
     match_ast,
 };
@@ -50,6 +50,7 @@ pub(crate) fn move_bounds_to_where_clause(
         |edit| {
             let type_param_list = edit.make_mut(type_param_list);
             let parent = edit.make_syntax_mut(parent);
+            let make = SyntaxFactory::without_mappings();
 
             let where_clause: ast::WhereClause = match_ast! {
                 match parent {
@@ -70,7 +71,7 @@ pub(crate) fn move_bounds_to_where_clause(
                     ast::GenericParam::ConstParam(_) => continue,
                 };
                 if let Some(tbl) = param.type_bound_list() {
-                    if let Some(predicate) = build_predicate(generic_param) {
+                    if let Some(predicate) = build_predicate(generic_param, &make) {
                         where_clause.add_predicate(predicate)
                     }
                     tbl.remove()
@@ -80,15 +81,13 @@ pub(crate) fn move_bounds_to_where_clause(
     )
 }
 
-fn build_predicate(param: ast::GenericParam) -> Option<ast::WherePred> {
+fn build_predicate(param: ast::GenericParam, make: &SyntaxFactory) -> Option<ast::WherePred> {
     let target = match &param {
-        ast::GenericParam::TypeParam(t) => {
-            Either::Right(make::ty_path(make::ext::ident_path(&t.name()?.to_string())))
-        }
+        ast::GenericParam::TypeParam(t) => Either::Right(make.ty(&t.name()?.to_string())),
         ast::GenericParam::LifetimeParam(l) => Either::Left(l.lifetime()?),
         ast::GenericParam::ConstParam(_) => return None,
     };
-    let predicate = make::where_pred(
+    let predicate = make.where_pred(
         target,
         match param {
             ast::GenericParam::TypeParam(t) => t.type_bound_list()?,
@@ -97,7 +96,7 @@ fn build_predicate(param: ast::GenericParam) -> Option<ast::WherePred> {
         }
         .bounds(),
     );
-    Some(predicate.clone_for_update())
+    Some(predicate)
 }
 
 #[cfg(test)]
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 1601ff3174a7..f50cd90ce9d0 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1,4 +1,6 @@
 //! Wrappers over [`make`] constructors
+use either::Either;
+
 use crate::{
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
     ast::{
@@ -124,6 +126,14 @@ pub fn ty_fn_ptr<I: Iterator<Item = Param>>(
         make::ty_fn_ptr(is_unsafe, abi, params, ret_type).clone_for_update()
     }
 
+    pub fn where_pred(
+        &self,
+        path: Either<ast::Lifetime, ast::Type>,
+        bounds: impl IntoIterator<Item = ast::TypeBound>,
+    ) -> ast::WherePred {
+        make::where_pred(path, bounds).clone_for_update()
+    }
+
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
         let ast::Expr::FieldExpr(ast) =
             make::expr_field(receiver.clone(), field).clone_for_update()

From 2726293132bdbd7a2847fe4a1d93f90f56062f56 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 23:40:10 +0530
Subject: [PATCH 0158/1059] migrate move bounds to SyntaxEditor API

---
 .../ide-assists/src/handlers/move_bounds.rs   | 85 ++++++++++++++-----
 .../src/ast/syntax_factory/constructors.rs    |  7 ++
 2 files changed, 71 insertions(+), 21 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
index e9b77a729438..01a46c33346a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
@@ -1,11 +1,8 @@
 use either::Either;
 use syntax::{
-    ast::{
-        self, AstNode, HasName, HasTypeBounds,
-        edit_in_place::{GenericParamsOwnerEdit, Removable},
-        syntax_factory::SyntaxFactory,
-    },
+    ast::{self, AstNode, HasGenericParams, HasName, HasTypeBounds, syntax_factory::SyntaxFactory},
     match_ast,
+    syntax_editor::{Position, Removable},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -47,23 +44,70 @@ pub(crate) fn move_bounds_to_where_clause(
         AssistId::refactor_rewrite("move_bounds_to_where_clause"),
         "Move to where clause",
         target,
-        |edit| {
-            let type_param_list = edit.make_mut(type_param_list);
-            let parent = edit.make_syntax_mut(parent);
+        |builder| {
+            let mut edit = builder.make_editor(&parent);
             let make = SyntaxFactory::without_mappings();
 
-            let where_clause: ast::WhereClause = match_ast! {
-                match parent {
-                    ast::Fn(it) => it.get_or_create_where_clause(),
-                    ast::Trait(it) => it.get_or_create_where_clause(),
-                    ast::Impl(it) => it.get_or_create_where_clause(),
-                    ast::Enum(it) => it.get_or_create_where_clause(),
-                    ast::Struct(it) => it.get_or_create_where_clause(),
-                    ast::TypeAlias(it) => it.get_or_create_where_clause(),
-                    _ => return,
+            let new_preds: Vec<ast::WherePred> = type_param_list
+                .generic_params()
+                .filter_map(|param| build_predicate(param, &make))
+                .collect();
+
+            let existing_where: Option<ast::WhereClause> = match_ast! {
+                match (&parent) {
+                    ast::Fn(it) => it.where_clause(),
+                    ast::Trait(it) => it.where_clause(),
+                    ast::Impl(it) => it.where_clause(),
+                    ast::Enum(it) => it.where_clause(),
+                    ast::Struct(it) => it.where_clause(),
+                    ast::TypeAlias(it) => it.where_clause(),
+                    _ => None,
                 }
             };
 
+            let all_preds = existing_where.iter().flat_map(|wc| wc.predicates()).chain(new_preds);
+            let new_where = make.where_clause(all_preds);
+
+            if let Some(existing) = &existing_where {
+                edit.replace(existing.syntax(), new_where.syntax());
+            } else {
+                let pos: Option<Position> = match_ast! {
+                    match (&parent) {
+                        ast::Fn(it) => it.ret_type()
+                            .map(|t| Position::after(t.syntax()))
+                            .or_else(|| it.param_list().map(|t| Position::after(t.syntax()))),
+                        ast::Trait(it) => it.generic_param_list()
+                            .map(|t| Position::after(t.syntax()))
+                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
+                        ast::Impl(it) => it.self_ty()
+                            .map(|t| Position::after(t.syntax())),
+                        ast::Enum(it) => it.generic_param_list()
+                            .map(|t| Position::after(t.syntax()))
+                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
+                        ast::Struct(it) => it.field_list()
+                            .and_then(|fl| match fl {
+                                ast::FieldList::TupleFieldList(it) => {
+                                    Some(Position::after(it.syntax()))
+                                }
+                                ast::FieldList::RecordFieldList(_) => None,
+                            })
+                            .or_else(|| it.generic_param_list()
+                                .map(|t| Position::after(t.syntax())))
+                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
+                        ast::TypeAlias(it) => it.generic_param_list()
+                            .map(|t| Position::after(t.syntax()))
+                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
+                        _ => None,
+                    }
+                };
+                if let Some(pos) = pos {
+                    edit.insert_all(
+                        pos,
+                        vec![make.whitespace(" ").into(), new_where.syntax().clone().into()],
+                    );
+                }
+            }
+
             for generic_param in type_param_list.generic_params() {
                 let param: &dyn HasTypeBounds = match &generic_param {
                     ast::GenericParam::TypeParam(t) => t,
@@ -71,12 +115,11 @@ pub(crate) fn move_bounds_to_where_clause(
                     ast::GenericParam::ConstParam(_) => continue,
                 };
                 if let Some(tbl) = param.type_bound_list() {
-                    if let Some(predicate) = build_predicate(generic_param, &make) {
-                        where_clause.add_predicate(predicate)
-                    }
-                    tbl.remove()
+                    tbl.remove(&mut edit);
                 }
             }
+
+            builder.add_file_edits(ctx.vfs_file_id(), edit);
         },
     )
 }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index f50cd90ce9d0..40412c773334 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -134,6 +134,13 @@ pub fn where_pred(
         make::where_pred(path, bounds).clone_for_update()
     }
 
+    pub fn where_clause(
+        &self,
+        predicates: impl IntoIterator<Item = ast::WherePred>,
+    ) -> ast::WhereClause {
+        make::where_clause(predicates).clone_for_update()
+    }
+
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
         let ast::Expr::FieldExpr(ast) =
             make::expr_field(receiver.clone(), field).clone_for_update()

From 3234fad9352cce63bcbfd30ac47fd7ffa26cad90 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 2 Mar 2026 23:46:46 +0530
Subject: [PATCH 0159/1059] remove make from replace_named_generics_with_impl

---
 .../handlers/replace_named_generic_with_impl.rs   | 15 +++++++--------
 .../syntax/src/ast/syntax_factory/constructors.rs |  4 ++++
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
index df7057835c34..018642a04723 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
@@ -5,9 +5,10 @@
     defs::Definition,
     search::{SearchScope, UsageSearchResult},
 };
+use syntax::ast::syntax_factory::SyntaxFactory;
 use syntax::{
     AstNode,
-    ast::{self, HasGenericParams, HasName, HasTypeBounds, Name, NameLike, PathType, make},
+    ast::{self, HasGenericParams, HasName, HasTypeBounds, Name, NameLike, PathType},
     match_ast,
 };
 
@@ -72,6 +73,7 @@ pub(crate) fn replace_named_generic_with_impl(
         target,
         |edit| {
             let mut editor = edit.make_editor(type_param.syntax());
+            let make = SyntaxFactory::without_mappings();
 
             // remove trait from generic param list
             if let Some(generic_params) = fn_.generic_param_list() {
@@ -83,17 +85,14 @@ pub(crate) fn replace_named_generic_with_impl(
                 if params.is_empty() {
                     editor.delete(generic_params.syntax());
                 } else {
-                    let new_generic_param_list = make::generic_param_list(params);
-                    editor.replace(
-                        generic_params.syntax(),
-                        new_generic_param_list.syntax().clone_for_update(),
-                    );
+                    let new_generic_param_list = make.generic_param_list(params);
+                    editor.replace(generic_params.syntax(), new_generic_param_list.syntax());
                 }
             }
 
-            let new_bounds = make::impl_trait_type(type_bound_list);
+            let new_bounds = make.impl_trait_type(type_bound_list);
             for path_type in path_types_to_replace.iter().rev() {
-                editor.replace(path_type.syntax(), new_bounds.clone_for_update().syntax());
+                editor.replace(path_type.syntax(), new_bounds.syntax());
             }
             edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 40412c773334..50fe56538080 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -141,6 +141,10 @@ pub fn where_clause(
         make::where_clause(predicates).clone_for_update()
     }
 
+    pub fn impl_trait_type(&self, bounds: ast::TypeBoundList) -> ast::ImplTraitType {
+        make::impl_trait_type(bounds).clone_for_update()
+    }
+
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
         let ast::Expr::FieldExpr(ast) =
             make::expr_field(receiver.clone(), field).clone_for_update()

From 6a653172f5049c16d266245a8a1967953c1e3139 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 6 Mar 2026 06:04:10 +0530
Subject: [PATCH 0160/1059] add GetOrCreateWhereClause subtrait in edit to
 provide get_or_create_where_clause

---
 .../ide-assists/src/handlers/move_bounds.rs   |  63 ++---------
 .../crates/syntax/src/syntax_editor.rs        |   2 +-
 .../crates/syntax/src/syntax_editor/edits.rs  | 101 ++++++++++++++++++
 3 files changed, 112 insertions(+), 54 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
index 01a46c33346a..79b8bd5d3d48 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
@@ -1,8 +1,8 @@
 use either::Either;
 use syntax::{
-    ast::{self, AstNode, HasGenericParams, HasName, HasTypeBounds, syntax_factory::SyntaxFactory},
+    ast::{self, AstNode, HasName, HasTypeBounds, syntax_factory::SyntaxFactory},
     match_ast,
-    syntax_editor::{Position, Removable},
+    syntax_editor::{GetOrCreateWhereClause, Removable},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -53,61 +53,18 @@ pub(crate) fn move_bounds_to_where_clause(
                 .filter_map(|param| build_predicate(param, &make))
                 .collect();
 
-            let existing_where: Option<ast::WhereClause> = match_ast! {
+            match_ast! {
                 match (&parent) {
-                    ast::Fn(it) => it.where_clause(),
-                    ast::Trait(it) => it.where_clause(),
-                    ast::Impl(it) => it.where_clause(),
-                    ast::Enum(it) => it.where_clause(),
-                    ast::Struct(it) => it.where_clause(),
-                    ast::TypeAlias(it) => it.where_clause(),
-                    _ => None,
+                    ast::Fn(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    ast::Trait(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    ast::Impl(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    ast::Enum(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    ast::Struct(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    ast::TypeAlias(it) => it.get_or_create_where_clause(&mut edit, &make, new_preds.into_iter()),
+                    _ => return,
                 }
             };
 
-            let all_preds = existing_where.iter().flat_map(|wc| wc.predicates()).chain(new_preds);
-            let new_where = make.where_clause(all_preds);
-
-            if let Some(existing) = &existing_where {
-                edit.replace(existing.syntax(), new_where.syntax());
-            } else {
-                let pos: Option<Position> = match_ast! {
-                    match (&parent) {
-                        ast::Fn(it) => it.ret_type()
-                            .map(|t| Position::after(t.syntax()))
-                            .or_else(|| it.param_list().map(|t| Position::after(t.syntax()))),
-                        ast::Trait(it) => it.generic_param_list()
-                            .map(|t| Position::after(t.syntax()))
-                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
-                        ast::Impl(it) => it.self_ty()
-                            .map(|t| Position::after(t.syntax())),
-                        ast::Enum(it) => it.generic_param_list()
-                            .map(|t| Position::after(t.syntax()))
-                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
-                        ast::Struct(it) => it.field_list()
-                            .and_then(|fl| match fl {
-                                ast::FieldList::TupleFieldList(it) => {
-                                    Some(Position::after(it.syntax()))
-                                }
-                                ast::FieldList::RecordFieldList(_) => None,
-                            })
-                            .or_else(|| it.generic_param_list()
-                                .map(|t| Position::after(t.syntax())))
-                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
-                        ast::TypeAlias(it) => it.generic_param_list()
-                            .map(|t| Position::after(t.syntax()))
-                            .or_else(|| it.name().map(|t| Position::after(t.syntax()))),
-                        _ => None,
-                    }
-                };
-                if let Some(pos) = pos {
-                    edit.insert_all(
-                        pos,
-                        vec![make.whitespace(" ").into(), new_where.syntax().clone().into()],
-                    );
-                }
-            }
-
             for generic_param in type_param_list.generic_params() {
                 let param: &dyn HasTypeBounds = match &generic_param {
                     ast::GenericParam::TypeParam(t) => t,
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
index 5683d891be7a..e6937e4d0f8a 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
@@ -20,7 +20,7 @@
 mod edits;
 mod mapping;
 
-pub use edits::Removable;
+pub use edits::{GetOrCreateWhereClause, Removable};
 pub use mapping::{SyntaxMapping, SyntaxMappingBuilder};
 
 #[derive(Debug)]
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
index 9090f7c9eb14..ad08928923be 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
@@ -10,6 +10,107 @@
     syntax_editor::{Position, SyntaxEditor},
 };
 
+pub trait GetOrCreateWhereClause: ast::HasGenericParams {
+    fn where_clause_position(&self) -> Option<Position>;
+
+    fn get_or_create_where_clause(
+        &self,
+        editor: &mut SyntaxEditor,
+        make: &SyntaxFactory,
+        new_preds: impl Iterator<Item = ast::WherePred>,
+    ) {
+        let existing = self.where_clause();
+        let all_preds: Vec<_> =
+            existing.iter().flat_map(|wc| wc.predicates()).chain(new_preds).collect();
+        let new_where = make.where_clause(all_preds);
+
+        if let Some(existing) = &existing {
+            editor.replace(existing.syntax(), new_where.syntax());
+        } else if let Some(pos) = self.where_clause_position() {
+            editor.insert_all(
+                pos,
+                vec![make.whitespace(" ").into(), new_where.syntax().clone().into()],
+            );
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::Fn {
+    fn where_clause_position(&self) -> Option<Position> {
+        if let Some(ty) = self.ret_type() {
+            Some(Position::after(ty.syntax()))
+        } else if let Some(param_list) = self.param_list() {
+            Some(Position::after(param_list.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::Impl {
+    fn where_clause_position(&self) -> Option<Position> {
+        if let Some(ty) = self.self_ty() {
+            Some(Position::after(ty.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::Trait {
+    fn where_clause_position(&self) -> Option<Position> {
+        if let Some(gpl) = self.generic_param_list() {
+            Some(Position::after(gpl.syntax()))
+        } else if let Some(name) = self.name() {
+            Some(Position::after(name.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::TypeAlias {
+    fn where_clause_position(&self) -> Option<Position> {
+        if let Some(gpl) = self.generic_param_list() {
+            Some(Position::after(gpl.syntax()))
+        } else if let Some(name) = self.name() {
+            Some(Position::after(name.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::Struct {
+    fn where_clause_position(&self) -> Option<Position> {
+        let tfl = self.field_list().and_then(|fl| match fl {
+            ast::FieldList::RecordFieldList(_) => None,
+            ast::FieldList::TupleFieldList(it) => Some(it),
+        });
+        if let Some(tfl) = tfl {
+            Some(Position::after(tfl.syntax()))
+        } else if let Some(gpl) = self.generic_param_list() {
+            Some(Position::after(gpl.syntax()))
+        } else if let Some(name) = self.name() {
+            Some(Position::after(name.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
+impl GetOrCreateWhereClause for ast::Enum {
+    fn where_clause_position(&self) -> Option<Position> {
+        if let Some(gpl) = self.generic_param_list() {
+            Some(Position::after(gpl.syntax()))
+        } else if let Some(name) = self.name() {
+            Some(Position::after(name.syntax()))
+        } else {
+            Some(Position::last_child_of(self.syntax()))
+        }
+    }
+}
+
 impl SyntaxEditor {
     /// Adds a new generic param to the function using `SyntaxEditor`
     pub fn add_generic_param(&mut self, function: &Fn, new_param: GenericParam) {

From 263613601f446208ad59c6c8ae0644b64b6638a6 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 6 Mar 2026 10:12:51 +0000
Subject: [PATCH 0161/1059] Rustup to rustc 1.96.0-nightly (69370dc4a
 2026-03-05)

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 44ae84d9ac69..bc909ed97551 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-04"
+channel = "nightly-2026-03-06"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 7cbc71ed38ad63051e14b01b10959cd954b00955 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 6 Mar 2026 11:32:31 +0100
Subject: [PATCH 0162/1059] libcore float tests: replace macro shadowing by
 const-compatible macro

---
 .../0029-sysroot_tests-disable-f16-math.patch | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/patches/0029-sysroot_tests-disable-f16-math.patch b/patches/0029-sysroot_tests-disable-f16-math.patch
index 6a0244cfde3f..340f6cc9b0e7 100644
--- a/patches/0029-sysroot_tests-disable-f16-math.patch
+++ b/patches/0029-sysroot_tests-disable-f16-math.patch
@@ -19,7 +19,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1557,7 +1557,7 @@ fn s_nan() -> Float {
      name: exp,
      attrs: {
@@ -28,7 +28,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1578,7 +1578,7 @@ fn s_nan() -> Float {
      name: exp2,
      attrs: {
@@ -37,7 +37,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1598,7 +1598,7 @@ fn s_nan() -> Float {
      name: ln,
      attrs: {
@@ -46,7 +46,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1620,7 +1620,7 @@ fn s_nan() -> Float {
      name: log,
      attrs: {
@@ -55,7 +55,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1645,7 +1645,7 @@ fn s_nan() -> Float {
      name: log2,
      attrs: {
@@ -64,7 +64,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1668,7 +1668,7 @@ fn s_nan() -> Float {
      name: log10,
      attrs: {
@@ -73,7 +73,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1692,7 +1692,7 @@ fn s_nan() -> Float {
      name: asinh,
      attrs: {
@@ -82,7 +82,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1725,7 +1725,7 @@ fn s_nan() -> Float {
      name: acosh,
      attrs: {
@@ -91,7 +91,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1753,7 +1753,7 @@ fn s_nan() -> Float {
      name: atanh,
      attrs: {
@@ -100,7 +100,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1779,7 +1779,7 @@ fn s_nan() -> Float {
      name: gamma,
      attrs: {
@@ -109,7 +109,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -1814,7 +1814,7 @@ fn s_nan() -> Float {
      name: ln_gamma,
      attrs: {
@@ -118,7 +118,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 @@ -2027,7 +2027,7 @@ fn s_nan() -> Float {
      attrs: {
          // FIXME(f16_f128): add math tests when available
@@ -127,7 +127,7 @@ index c61961f8584..d7b4fa20322 100644
 +        f16: #[cfg(false)], // FIXME(rust-lang/rustc_codegen_cranelift#1622)
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
-     test<Float> {
+     test {
 -- 
 2.50.1
 

From aeab5b5cab1d2dd03612f88b734d35ac65d22760 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 6 Mar 2026 04:23:11 -0500
Subject: [PATCH 0163/1059] c-b: Export `fminimum_num`, `fmaximum_num` and
 variants

Since we are starting to use the `fmaximum_num` intrinsics, LLVM may
emit these.
---
 .../compiler-builtins/compiler-builtins/src/math/mod.rs   | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/compiler-builtins/compiler-builtins/src/math/mod.rs b/library/compiler-builtins/compiler-builtins/src/math/mod.rs
index 62d729674105..61dfad213cbe 100644
--- a/library/compiler-builtins/compiler-builtins/src/math/mod.rs
+++ b/library/compiler-builtins/compiler-builtins/src/math/mod.rs
@@ -28,8 +28,10 @@ pub mod full_availability {
         fn fdimf16(x: f16, y: f16) -> f16;
         fn floorf16(x: f16) -> f16;
         fn fmaxf16(x: f16, y: f16) -> f16;
+        fn fmaximum_numf16(x: f16, y: f16) -> f16;
         fn fmaximumf16(x: f16, y: f16) -> f16;
         fn fminf16(x: f16, y: f16) -> f16;
+        fn fminimum_numf16(x: f16, y: f16) -> f16;
         fn fminimumf16(x: f16, y: f16) -> f16;
         fn fmodf16(x: f16, y: f16) -> f16;
         fn rintf16(x: f16) -> f16;
@@ -81,8 +83,12 @@ pub mod full_availability {
     // however, so we still provide a fallback.
     libm_intrinsics! {
         fn fmaximum(x: f64, y: f64) -> f64;
+        fn fmaximum_num(x: f64, y: f64) -> f64;
+        fn fmaximum_numf(x: f32, y: f32) -> f32;
         fn fmaximumf(x: f32, y: f32) -> f32;
         fn fminimum(x: f64, y: f64) -> f64;
+        fn fminimum_num(x: f64, y: f64) -> f64;
+        fn fminimum_numf(x: f32, y: f32) -> f32;
         fn fminimumf(x: f32, y: f32) -> f32;
         fn roundeven(x: f64) -> f64;
         fn roundevenf(x: f32) -> f32;
@@ -97,8 +103,10 @@ pub mod full_availability {
         fn floorf128(x: f128) -> f128;
         fn fmaf128(x: f128, y: f128, z: f128) -> f128;
         fn fmaxf128(x: f128, y: f128) -> f128;
+        fn fmaximum_numf128(x: f128, y: f128) -> f128;
         fn fmaximumf128(x: f128, y: f128) -> f128;
         fn fminf128(x: f128, y: f128) -> f128;
+        fn fminimum_numf128(x: f128, y: f128) -> f128;
         fn fminimumf128(x: f128, y: f128) -> f128;
         fn fmodf128(x: f128, y: f128) -> f128;
         fn rintf128(x: f128) -> f128;

From ddb729abdc8fb0bc47e4dcb95b83cef050ef6272 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Fri, 6 Mar 2026 13:38:25 +0100
Subject: [PATCH 0164/1059] fix: Fix invalid `PartialEq` impl for
 `EditionedFileIdData`

This broke the contract of `HashEqLike`, causing interning to return different IDs
---
 .../crates/base-db/src/editioned_file_id.rs    | 14 +++++++++++++-
 .../hir-def/src/nameres/tests/incremental.rs   |  1 -
 .../crates/hir-ty/src/tests/macros.rs          | 10 +++++-----
 .../rust-analyzer/crates/ide-db/src/traits.rs  |  5 ++++-
 .../rust-analyzer/crates/ide/src/typing.rs     | 18 ++++++++----------
 .../crates/test-fixture/src/lib.rs             | 13 +++++++++----
 6 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
index 13fb05d56547..062e3b59d941 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
@@ -20,7 +20,7 @@ pub struct EditionedFileId(
     use zalsa_::interned as zalsa_struct_;
     type Configuration_ = EditionedFileId;
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[derive(Debug, Clone, Eq)]
     pub struct EditionedFileIdData {
         editioned_file_id: span::EditionedFileId,
         krate: Crate,
@@ -52,6 +52,14 @@ struct WithoutCrate {
         editioned_file_id: span::EditionedFileId,
     }
 
+    impl PartialEq for EditionedFileIdData {
+        fn eq(&self, other: &Self) -> bool {
+            let Self { editioned_file_id, krate: _ } = self;
+            let Self { editioned_file_id: other_editioned_file_id, krate: _ } = other;
+            editioned_file_id == other_editioned_file_id
+        }
+    }
+
     impl Hash for EditionedFileIdData {
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
@@ -210,6 +218,8 @@ pub fn from_span(
         ///  1. The file is not in the module tree.
         ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
         ///     (e.g. on enter feature, folding, etc.).
+        // FIXME: Remove this and all the weird crate ignoring plumbing around this
+        // This can cause a variety of weird bugs https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Broken.20token.20mapping/with/577739887
         pub fn from_span_guess_origin(
             db: &dyn RootQueryDb,
             editioned_file_id: span::EditionedFileId,
@@ -281,6 +291,8 @@ pub fn new(db: &dyn salsa::Database, file_id: FileId, edition: Edition, krate: C
     ///  1. The file is not in the module tree.
     ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
     ///     (e.g. on enter feature, folding, etc.).
+    // FIXME: Remove this and all the weird crate ignoring plumbing around this
+    // This can cause a variety of weird bugs https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Broken.20token.20mapping/with/577739887
     #[inline]
     pub fn current_edition_guess_origin(db: &dyn RootQueryDb, file_id: FileId) -> Self {
         Self::from_span_guess_origin(db, span::EditionedFileId::current_edition(file_id))
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
index 225ba958634e..b2a056ff2a60 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
@@ -118,7 +118,6 @@ pub fn foo() {}
         expect![[r#"
             [
                 "crate_local_def_map",
-                "file_item_tree_query",
                 "crate_local_def_map",
             ]
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
index 2f41de64cbbd..28a688d4a39b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
@@ -9,16 +9,16 @@
 fn cfg_impl_def() {
     check_types(
         r#"
-//- /main.rs crate:main deps:foo cfg:test
+//- /main.rs crate:main deps:foo cfg:some_cfg
 use foo::S as T;
 struct S;
 
-#[cfg(test)]
+#[cfg(some_cfg)]
 impl S {
     fn foo1(&self) -> i32 { 0 }
 }
 
-#[cfg(not(test))]
+#[cfg(not(some_cfg))]
 impl S {
     fn foo2(&self) -> i32 { 0 }
 }
@@ -31,12 +31,12 @@ fn test() {
 //- /foo.rs crate:foo
 pub struct S;
 
-#[cfg(not(test))]
+#[cfg(not(some_cfg))]
 impl S {
     pub fn foo3(&self) -> i32 { 0 }
 }
 
-#[cfg(test)]
+#[cfg(some_cfg)]
 impl S {
     pub fn foo4(&self) -> i32 { 0 }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/traits.rs b/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
index 7200e7fbe5ae..41ef50165383 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
@@ -113,6 +113,7 @@ fn assoc_item_of_trait(
 
 #[cfg(test)]
 mod tests {
+    use base_db::RootQueryDb;
     use expect_test::{Expect, expect};
     use hir::{EditionedFileId, FilePosition, Semantics};
     use span::Edition;
@@ -130,7 +131,9 @@ pub(crate) fn position(
         database.apply_change(change_fixture.change);
         let (file_id, range_or_offset) =
             change_fixture.file_position.expect("expected a marker ($0)");
-        let file_id = EditionedFileId::from_span_guess_origin(&database, file_id);
+
+        let &krate = database.relevant_crates(file_id.file_id()).first().unwrap();
+        let file_id = EditionedFileId::from_span(&database, file_id, krate);
         let offset = range_or_offset.expect_offset();
         (database, FilePosition { file_id, offset })
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/typing.rs b/src/tools/rust-analyzer/crates/ide/src/typing.rs
index f8b0dbfe6282..ca2194fceb67 100644
--- a/src/tools/rust-analyzer/crates/ide/src/typing.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/typing.rs
@@ -17,10 +17,7 @@
 
 use either::Either;
 use hir::EditionedFileId;
-use ide_db::{
-    FilePosition, RootDatabase,
-    base_db::{RootQueryDb, SourceDatabase},
-};
+use ide_db::{FilePosition, RootDatabase, base_db::RootQueryDb};
 use span::Edition;
 use std::iter;
 
@@ -73,15 +70,16 @@ pub(crate) fn on_char_typed(
     if !TRIGGER_CHARS.contains(&char_typed) {
         return None;
     }
-    let edition = db
-        .source_root_crates(db.file_source_root(position.file_id).source_root_id(db))
+    let krate = db
+        .relevant_crates(position.file_id)
         .first()
-        .map_or(Edition::CURRENT, |crates| crates.data(db).edition);
-    // FIXME: We are hitting the database here, if we are unlucky this call might block momentarily
-    // causing the editor to feel sluggish! We need to make this bail if it would block too long?
-    let editioned_file_id_wrapper = EditionedFileId::from_span_guess_origin(
+        .copied()
+        .unwrap_or_else(|| *db.all_crates().first().unwrap());
+    let edition = krate.data(db).edition;
+    let editioned_file_id_wrapper = EditionedFileId::from_span(
         db,
         span::EditionedFileId::new(position.file_id, edition),
+        krate,
     );
     let file = &db.parse(editioned_file_id_wrapper);
     let char_matches_position =
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index ca68edd88c05..93d4650cd3c4 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -149,8 +149,9 @@ fn with_single_file(
         let fixture = ChangeFixture::parse(ra_fixture);
         fixture.change.apply(&mut db);
         assert_eq!(fixture.files.len(), 1, "Multiple file found in the fixture");
-        let file = EditionedFileId::from_span_guess_origin(&db, fixture.files[0]);
-        (db, file)
+        let &krate = db.relevant_crates(fixture.files[0].file_id()).first().unwrap();
+        let file_id = EditionedFileId::from_span(&db, fixture.files[0], krate);
+        (db, file_id)
     }
 
     /// See the trait documentation for more information on fixtures.
@@ -165,7 +166,10 @@ fn with_many_files(
         let files = fixture
             .files
             .into_iter()
-            .map(|file| EditionedFileId::from_span_guess_origin(&db, file))
+            .map(|file| {
+                let &krate = db.relevant_crates(file.file_id()).first().unwrap();
+                EditionedFileId::from_span(&db, file, krate)
+            })
             .collect();
         (db, files)
     }
@@ -222,7 +226,8 @@ fn with_range_or_offset(
         let (file_id, range_or_offset) = fixture
             .file_position
             .expect("Could not find file position in fixture. Did you forget to add an `$0`?");
-        let file_id = EditionedFileId::from_span_guess_origin(&db, file_id);
+        let &krate = db.relevant_crates(file_id.file_id()).first().unwrap();
+        let file_id = EditionedFileId::from_span(&db, file_id, krate);
         (db, file_id, range_or_offset)
     }
 

From cc5f0ae9a80146d515c8ec6aa4040a4ba53ec0fb Mon Sep 17 00:00:00 2001
From: WhySoBad <49595640+WhySoBad@users.noreply.github.com>
Date: Fri, 27 Feb 2026 17:11:21 +0100
Subject: [PATCH 0165/1059] Add listen and bind support to socket shim

Some setsockopt options are also supported such that a TcpListener from the standard library can be created
---
 src/tools/miri/src/diagnostics.rs             |  16 +-
 .../miri/src/shims/unix/foreign_items.rs      |  31 ++
 src/tools/miri/src/shims/unix/socket.rs       | 349 ++++++++++++++++--
 .../src/shims/unix/solarish/foreign_items.rs  |  23 ++
 .../libc/libc-socket-with-isolation.rs        |   2 -
 .../miri/tests/pass-dep/libc/libc-socket.rs   | 179 ++++++++-
 .../libc/socket-unsupported-listen-backlog.rs |  27 ++
 .../socket-unsupported-listen-backlog.stderr  |   8 +
 src/tools/miri/tests/pass-dep/shims/socket.rs |  17 +
 src/tools/miri/tests/utils/libc.rs            |  48 +++
 10 files changed, 674 insertions(+), 26 deletions(-)
 create mode 100644 src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
 create mode 100644 src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
 create mode 100644 src/tools/miri/tests/pass-dep/shims/socket.rs

diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index aa67cf255b73..1c64f1e357b5 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -150,6 +150,13 @@ pub enum NonHaltingDiagnostic {
         effective_failure_ordering: AtomicReadOrd,
     },
     FileInProcOpened,
+    SocketListenUnsupportedBacklog {
+        details: bool,
+        /// Unsupported backlog value provided the by the program.
+        provided: i32,
+        /// Supported backlog value by Miri.
+        supported: i32,
+    },
 }
 
 /// Level of Miri specific diagnostics
@@ -656,6 +663,8 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
             | WeakMemoryOutdatedLoad { .. } =>
                 ("tracking was triggered here".to_string(), DiagLevel::Note),
             FileInProcOpened => ("open a file in `/proc`".to_string(), DiagLevel::Warning),
+            SocketListenUnsupportedBacklog { .. } =>
+                ("call to `listen` with unsupported backlog value".to_string(), DiagLevel::Warning),
         };
 
         let title = match &e {
@@ -703,13 +712,18 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
                 };
                 format!("GenMC currently does not model the failure ordering for `compare_exchange`. {was_upgraded_msg}. Miri with GenMC might miss bugs related to this memory access.")
             }
-            FileInProcOpened => format!("files in `/proc` can bypass the Abstract Machine and might not work properly in Miri")
+            FileInProcOpened => format!("files in `/proc` can bypass the Abstract Machine and might not work properly in Miri"),
+            SocketListenUnsupportedBacklog { provided, supported, .. } => format!("called `listen` on socket with backlog value of {provided} but only {supported} is supported")
         };
 
         let notes = match &e {
             ProgressReport { block_count } => {
                 vec![note!("so far, {block_count} basic blocks have been executed")]
             }
+            SocketListenUnsupportedBacklog { details: true, supported, .. } =>
+                vec![note!(
+                    "the given value will be ignored and a backlog of {supported} will be used instead"
+                )],
             _ => vec![],
         };
 
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 130643ec680d..28092156c729 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -550,6 +550,37 @@ fn emulate_foreign_item_inner(
                 let result = this.socket(domain, type_, protocol)?;
                 this.write_scalar(result, dest)?;
             }
+            "bind" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *const _, libc::socklen_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.bind(socket, address, address_len)?;
+                this.write_scalar(result, dest)?;
+            }
+            "listen" => {
+                let [socket, backlog] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, i32) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.listen(socket, backlog)?;
+                this.write_scalar(result, dest)?;
+            }
+            "setsockopt" => {
+                let [socket, level, option_name, option_value, option_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, i32, i32, *const _, libc::socklen_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result =
+                    this.setsockopt(socket, level, option_name, option_value, option_len)?;
+                this.write_scalar(result, dest)?;
+            }
 
             // Time
             "gettimeofday" => {
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 66fe5d8a44a4..eac60e61f461 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -1,13 +1,18 @@
-use std::cell::Cell;
-use std::net::{TcpListener, TcpStream};
+use std::cell::{Cell, RefCell};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, TcpListener};
 
+use rustc_abi::Size;
 use rustc_const_eval::interpret::{InterpResult, interp_ok};
 use rustc_middle::throw_unsup_format;
 use rustc_target::spec::Os;
 
+use crate::diagnostics::SpanDedupDiagnostic;
 use crate::shims::files::{FdId, FileDescription};
 use crate::{OpTy, Scalar, *};
 
+/// Backlog value passed to the `listen` syscall by the standard library
+const SUPPORTED_LISTEN_BACKLOG: i32 = 128;
+
 #[derive(Debug, PartialEq)]
 enum SocketFamily {
     // IPv4 internet protocols
@@ -17,27 +22,25 @@ enum SocketFamily {
 }
 
 #[derive(Debug)]
-enum SocketType {
-    /// Reliable full-duplex communication, based on connections.
-    Stream,
+enum SocketState {
+    /// No syscall after `socket` has been made.
+    Initial,
+    /// The `bind` syscall has been called on the socket.
+    /// This is only reachable from the [`SocketState::Initial`] state.
+    Bound(SocketAddr),
+    /// The `listen` syscall has been called on the socket.
+    /// This is only reachable from the [`SocketState::Bound`] state.
+    #[expect(unused)]
+    Listening(TcpListener),
 }
 
-#[allow(unused)]
-#[derive(Debug)]
-enum SocketKind {
-    TcpListener(TcpListener),
-    TcpStream(TcpStream),
-}
-
-#[allow(unused)]
 #[derive(Debug)]
 struct Socket {
     /// Family of the socket, used to ensure socket only binds/connects to address of
     /// same family.
     family: SocketFamily,
-    /// Type of the socket, either datagram or stream.
-    /// Only stream is supported at the moment!
-    socket_type: SocketType,
+    /// Current state of the inner socket.
+    state: RefCell<SocketState>,
     /// Whether this fd is non-blocking or not.
     is_non_block: Cell<bool>,
 }
@@ -97,16 +100,19 @@ fn socket(
         // Reject if isolation is enabled
         if let IsolatedOp::Reject(reject_with) = this.machine.isolated_op {
             this.reject_in_isolation("`socket`", reject_with)?;
-            this.set_last_error(LibcError("EACCES"))?;
-            return interp_ok(Scalar::from_i32(-1));
+            return this.set_last_error_and_return_i32(LibcError("EACCES"));
         }
 
         let mut is_sock_nonblock = false;
 
         // Interpret the flag. Every flag we recognize is "subtracted" from `flags`, so
         // if there is anything left at the end, that's an unsupported flag.
-        if matches!(this.tcx.sess.target.os, Os::Linux | Os::Android | Os::FreeBsd) {
-            // SOCK_NONBLOCK and SOCK_CLOEXEC only exist on Linux, Android and FreeBSD.
+        if matches!(
+            this.tcx.sess.target.os,
+            Os::Linux | Os::Android | Os::FreeBsd | Os::Solaris | Os::Illumos
+        ) {
+            // SOCK_NONBLOCK and SOCK_CLOEXEC only exist on Linux, Android, FreeBSD,
+            // Solaris, and Illumos targets
             let sock_nonblock = this.eval_libc_i32("SOCK_NONBLOCK");
             let sock_cloexec = this.eval_libc_i32("SOCK_CLOEXEC");
             if flags & sock_nonblock == sock_nonblock {
@@ -148,10 +154,311 @@ fn socket(
         let fds = &mut this.machine.fds;
         let fd = fds.new_ref(Socket {
             family,
+            state: RefCell::new(SocketState::Initial),
             is_non_block: Cell::new(is_sock_nonblock),
-            socket_type: SocketType::Stream,
         });
 
         interp_ok(Scalar::from_i32(fds.insert(fd)))
     }
+
+    fn bind(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let address = match this.socket_address(address, address_len, "bind")? {
+            Ok(addr) => addr,
+            Err(e) => return this.set_last_error_and_return_i32(e),
+        };
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return interp_ok(this.eval_libc("EBADF"));
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return interp_ok(this.eval_libc("ENOTSOCK"));
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        let mut state = socket.state.borrow_mut();
+
+        match *state {
+            SocketState::Initial => {
+                let address_family = match &address {
+                    SocketAddr::V4(_) => SocketFamily::IPv4,
+                    SocketAddr::V6(_) => SocketFamily::IPv6,
+                };
+
+                if socket.family != address_family {
+                    // Attempted to bind an address from a family that doesn't match
+                    // the family of the socket.
+                    let err = if matches!(this.tcx.sess.target.os, Os::Linux | Os::Android) {
+                        // Linux man page states that `EINVAL` is used when there is an addres family mismatch.
+                        // See <https://man7.org/linux/man-pages/man2/bind.2.html>
+                        LibcError("EINVAL")
+                    } else {
+                        // POSIX man page states that `EAFNOSUPPORT` should be used when there is an address
+                        // family mismatch.
+                        // See <https://man7.org/linux/man-pages/man3/bind.3p.html>
+                        LibcError("EAFNOSUPPORT")
+                    };
+                    return this.set_last_error_and_return_i32(err);
+                }
+
+                *state = SocketState::Bound(address);
+            }
+            SocketState::Bound(_) | SocketState::Listening(_) =>
+                throw_unsup_format!(
+                    "bind: socket is already bound and binding a socket \
+                                    multiple times is unsupported"
+                ),
+        }
+
+        interp_ok(Scalar::from_i32(0))
+    }
+
+    fn listen(&mut self, socket: &OpTy<'tcx>, backlog: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let backlog = this.read_scalar(backlog)?.to_i32()?;
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return interp_ok(this.eval_libc("EBADF"));
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return interp_ok(this.eval_libc("ENOTSOCK"));
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        // Only allow the same backlog value as the standard library uses since the standard library
+        // doesn't provide a way to set a custom value.
+        if backlog != SUPPORTED_LISTEN_BACKLOG {
+            // The first time this happens at a particular location, print a warning.
+            static DEDUP: SpanDedupDiagnostic = SpanDedupDiagnostic::new();
+            this.dedup_diagnostic(&DEDUP, |first| {
+                NonHaltingDiagnostic::SocketListenUnsupportedBacklog {
+                    details: first,
+                    provided: backlog,
+                    supported: SUPPORTED_LISTEN_BACKLOG,
+                }
+            });
+        }
+
+        let mut state = socket.state.borrow_mut();
+
+        match &*state {
+            SocketState::Bound(socket_addr) =>
+                match TcpListener::bind(socket_addr) {
+                    Ok(listener) => *state = SocketState::Listening(listener),
+                    Err(e) => return this.set_last_error_and_return_i32(e),
+                },
+            SocketState::Initial => {
+                throw_unsup_format!(
+                    "listen: listening on a socket which isn't bound is unsupported"
+                )
+            }
+            SocketState::Listening(_) => {
+                throw_unsup_format!("listen: listening on a socket multiple times is unsupported")
+            }
+        }
+
+        interp_ok(Scalar::from_i32(0))
+    }
+
+    fn setsockopt(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        level: &OpTy<'tcx>,
+        option_name: &OpTy<'tcx>,
+        option_value: &OpTy<'tcx>,
+        option_len: &OpTy<'tcx>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let level = this.read_scalar(level)?.to_i32()?;
+        let option_name = this.read_scalar(option_name)?.to_i32()?;
+        let socklen_layout = this.libc_ty_layout("socklen_t");
+        let option_len = this.read_scalar(option_len)?.to_int(socklen_layout.size)?;
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return interp_ok(this.eval_libc("EBADF"));
+        };
+
+        let Some(_socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return interp_ok(this.eval_libc("ENOTSOCK"));
+        };
+
+        if level == this.eval_libc_i32("SOL_SOCKET") {
+            let opt_so_reuseaddr = this.eval_libc_i32("SO_REUSEADDR");
+
+            if matches!(this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::NetBsd) {
+                // SO_NOSIGPIPE only exists on MacOS, FreeBSD, and NetBSD.
+                let opt_so_nosigpipe = this.eval_libc_i32("SO_NOSIGPIPE");
+
+                if option_name == opt_so_nosigpipe {
+                    if option_len != 4 {
+                        // Option value should be C-int which is usually 4 bytes.
+                        return this.set_last_error_and_return_i32(LibcError("EINVAL"));
+                    }
+                    let option_value =
+                        this.deref_pointer_as(option_value, this.machine.layouts.i32)?;
+                    let _val = this.read_scalar(&option_value)?.to_i32()?;
+                    // We entirely ignore this value since we do not support signals anyway.
+
+                    return interp_ok(Scalar::from_i32(0));
+                }
+            }
+
+            if option_name == opt_so_reuseaddr {
+                if option_len != 4 {
+                    // Option value should be C-int which is usually 4 bytes.
+                    return this.set_last_error_and_return_i32(LibcError("EINVAL"));
+                }
+                let option_value = this.deref_pointer_as(option_value, this.machine.layouts.i32)?;
+                let _val = this.read_scalar(&option_value)?.to_i32()?;
+                // We entirely ignore this: std always sets REUSEADDR for us, and in the end it's more of a
+                // hint to bypass some arbitrary timeout anyway.
+                return interp_ok(Scalar::from_i32(0));
+            } else {
+                throw_unsup_format!(
+                    "setsockopt: option {option_name:#x} is unsupported for level SOL_SOCKET",
+                );
+            }
+        }
+
+        throw_unsup_format!(
+            "setsockopt: level {level:#x} is unsupported, only SOL_SOCKET is allowed"
+        );
+    }
+}
+
+impl<'tcx> EvalContextPrivExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    /// Attempt to turn an address and length operand into a standard library socket address.
+    ///
+    /// Returns an IO error should the address length not match the address family length.
+    fn socket_address(
+        &self,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+        foreign_name: &'static str,
+    ) -> InterpResult<'tcx, Result<SocketAddr, IoError>> {
+        let this = self.eval_context_ref();
+
+        let socklen_layout = this.libc_ty_layout("socklen_t");
+        // We only support address lengths which can be stored in a u64 since the
+        // size of a layout is also stored in a u64.
+        let address_len: u64 =
+            this.read_scalar(address_len)?.to_int(socklen_layout.size)?.try_into().unwrap();
+
+        // Initially, treat address as generic sockaddr just to extract the family field.
+        let sockaddr_layout = this.libc_ty_layout("sockaddr");
+        if address_len < sockaddr_layout.size.bytes() {
+            // Address length should be at least as big as the generic sockaddr
+            return interp_ok(Err(LibcError("EINVAL")));
+        }
+        let address = this.deref_pointer_as(address, sockaddr_layout)?;
+
+        let family_field = this.project_field_named(&address, "sa_family")?;
+        let family_layout = this.libc_ty_layout("sa_family_t");
+        let family = this.read_scalar(&family_field)?.to_int(family_layout.size)?;
+
+        // Depending on the family, decide whether it's IPv4 or IPv6 and use specialized layout
+        // to extract address and port.
+        let socket_addr = if family == this.eval_libc_i32("AF_INET").into() {
+            let sockaddr_in_layout = this.libc_ty_layout("sockaddr_in");
+            if address_len != sockaddr_in_layout.size.bytes() {
+                // Address length should be exactly the length of an IPv4 address.
+                return interp_ok(Err(LibcError("EINVAL")));
+            }
+            let address = address.transmute(sockaddr_in_layout, this)?;
+
+            let port_field = this.project_field_named(&address, "sin_port")?;
+            // Read bytes and treat them as big endian since port is stored in network byte order.
+            let port_bytes: [u8; 2] = this
+                .read_bytes_ptr_strip_provenance(port_field.ptr(), Size::from_bytes(2))?
+                .try_into()
+                .unwrap();
+            let port = u16::from_be_bytes(port_bytes);
+
+            let addr_field = this.project_field_named(&address, "sin_addr")?;
+            let s_addr_field = this.project_field_named(&addr_field, "s_addr")?;
+            // Read bytes and treat them as big endian since address is stored in network byte order.
+            let addr_bytes: [u8; 4] = this
+                .read_bytes_ptr_strip_provenance(s_addr_field.ptr(), Size::from_bytes(4))?
+                .try_into()
+                .unwrap();
+            let addr_bits = u32::from_be_bytes(addr_bytes);
+
+            SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from_bits(addr_bits), port))
+        } else if family == this.eval_libc_i32("AF_INET6").into() {
+            let sockaddr_in6_layout = this.libc_ty_layout("sockaddr_in6");
+            if address_len != sockaddr_in6_layout.size.bytes() {
+                // Address length should be exactly the length of an IPv6 address.
+                return interp_ok(Err(LibcError("EINVAL")));
+            }
+            // We cannot transmute since the `sockaddr_in6` layout is bigger than the `sockaddr` layout.
+            let address = address.offset(Size::ZERO, sockaddr_in6_layout, this)?;
+
+            let port_field = this.project_field_named(&address, "sin6_port")?;
+            // Read bytes and treat them as big endian since port is stored in network byte order.
+            let port_bytes: [u8; 2] = this
+                .read_bytes_ptr_strip_provenance(port_field.ptr(), Size::from_bytes(2))?
+                .try_into()
+                .unwrap();
+            let port = u16::from_be_bytes(port_bytes);
+
+            let addr_field = this.project_field_named(&address, "sin6_addr")?;
+            let s_addr_field = this
+                .project_field_named(&addr_field, "s6_addr")?
+                .transmute(this.machine.layouts.u128, this)?;
+            // Read bytes and treat them as big endian since address is stored in network byte order.
+            let addr_bytes: [u8; 16] = this
+                .read_bytes_ptr_strip_provenance(s_addr_field.ptr(), Size::from_bytes(16))?
+                .try_into()
+                .unwrap();
+            let addr_bits = u128::from_be_bytes(addr_bytes);
+
+            let flowinfo_field = this.project_field_named(&address, "sin6_flowinfo")?;
+            // flowinfo doesn't get the big endian treatment as this field is stored in native byte order
+            // and not in network byte order.
+            let flowinfo = this.read_scalar(&flowinfo_field)?.to_u32()?;
+
+            let scope_id_field = this.project_field_named(&address, "sin6_scope_id")?;
+            // scope_id doesn't get the big endian treatment as this field is stored in native byte order
+            // and not in network byte order.
+            let scope_id = this.read_scalar(&scope_id_field)?.to_u32()?;
+
+            SocketAddr::V6(SocketAddrV6::new(
+                Ipv6Addr::from_bits(addr_bits),
+                port,
+                flowinfo,
+                scope_id,
+            ))
+        } else {
+            // Socket of other types shouldn't be created in a first place and
+            // thus also no address family of another type should be supported.
+            throw_unsup_format!(
+                "{foreign_name}: address family {family:#x} is unsupported, \
+                                only AF_INET and AF_INET6 are allowed"
+            );
+        };
+
+        interp_ok(Ok(socket_addr))
+    }
 }
diff --git a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
index 723e7bae4cdf..9dbfc6d21712 100644
--- a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
@@ -111,6 +111,29 @@ fn emulate_foreign_item_inner(
                 this.write_scalar(result, dest)?;
             }
 
+            // Network sockets
+            "__xnet_socket" | "__xnet7_socket" => {
+                let [domain, type_, protocol] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, i32, i32) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.socket(domain, type_, protocol)?;
+                this.write_scalar(result, dest)?;
+            }
+
+            "__xnet_bind" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *const _, libc::socklen_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.bind(socket, address, address_len)?;
+                this.write_scalar(result, dest)?;
+            }
+
             // Miscellaneous
             "___errno" => {
                 let [] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socket-with-isolation.rs b/src/tools/miri/tests/pass-dep/libc/libc-socket-with-isolation.rs
index ce4df4de72b6..0826db7e94a1 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socket-with-isolation.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socket-with-isolation.rs
@@ -1,6 +1,4 @@
 //@ignore-target: windows # No libc socket on Windows
-//@ignore-target: solaris # Socket is a macro for __xnet7_socket which has no shim
-//@ignore-target: illumos # Socket is a macro for __xnet7_socket which has no shim
 //@compile-flags: -Zmiri-isolation-error=warn-nobacktrace
 
 use std::io::ErrorKind;
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
index ac9f13367642..1a4c0b2e168e 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
@@ -1,14 +1,31 @@
 //@ignore-target: windows # No libc socket on Windows
-//@ignore-target: solaris # Does socket is a macro for __xnet7_socket which has no shim
-//@ignore-target: illumos # Does socket is a macro for __xnet7_socket which has no shim
 //@compile-flags: -Zmiri-disable-isolation
 
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
+use std::io::{self, ErrorKind};
+
 use libc_utils::*;
 
 fn main() {
     test_socket_close();
+    test_bind_ipv4();
+    test_bind_ipv4_reuseaddr();
+    test_set_reuseaddr_invalid_len();
+    #[cfg(any(
+        target_os = "macos",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    ))]
+    {
+        test_bind_ipv4_nosigpipe();
+        test_set_nosigpipe_invalid_len();
+    }
+    test_bind_ipv4_invalid_addr_len();
+    test_bind_ipv6();
+
+    test_listen();
 }
 
 fn test_socket_close() {
@@ -17,3 +34,161 @@ fn test_socket_close() {
         errno_check(libc::close(sockfd));
     }
 }
+
+fn test_bind_ipv4() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+}
+
+/// Tests binding after the `SO_REUSEADDR` socket option has been set on the newly created socket.
+fn test_bind_ipv4_reuseaddr() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_REUSEADDR, 1 as libc::c_int).unwrap();
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+}
+
+/// Tests setting the `SO_REUSEADDR` socket option but with an invalid length.
+fn test_set_reuseaddr_invalid_len() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    // Value should be of type `libc::c_int` which has size 4 bytes.
+    // By providing a u64 of size 8 bytes we trigger an invalid length error.
+    let err = setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_REUSEADDR, 1u64).unwrap_err();
+    assert_eq!(err.kind(), ErrorKind::InvalidInput);
+    // check that it is the right kind of `InvalidInput`
+    assert_eq!(err.raw_os_error(), Some(libc::EINVAL));
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "dragonfly"
+))]
+/// Tests binding after the `SO_NOSIGPIPE` socket option has been set on the newly created socket.
+/// That flag only exists on BSD-like OSes.
+fn test_bind_ipv4_nosigpipe() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1 as libc::c_int).unwrap();
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "dragonfly"
+))]
+/// Tests setting the `SO_NOSIGPIPE` socket option but with an invalid length.
+fn test_set_nosigpipe_invalid_len() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    // Value should be of type `libc::c_int` which has size 4 bytes.
+    // By providing a u64 of size 8 bytes we trigger an invalid length error.
+    let err = setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1u64).unwrap_err();
+    assert_eq!(err.kind(), ErrorKind::InvalidInput);
+    // check that it is the right kind of `InvalidInput`
+    assert_eq!(err.raw_os_error(), Some(libc::EINVAL));
+}
+
+/// Tests binding an IPv4 socket with an IPv4 address but the addrlen argument
+/// has the wrong size.
+fn test_bind_ipv4_invalid_addr_len() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let err = unsafe {
+        errno_result(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            // Add 1 to the address to make the size invalid.
+            (size_of::<libc::sockaddr_in>() + 1) as libc::socklen_t,
+        ))
+        .unwrap_err()
+    };
+    assert_eq!(err.kind(), ErrorKind::InvalidInput);
+    // check that it is the right kind of `InvalidInput`
+    assert_eq!(err.raw_os_error(), Some(libc::EINVAL));
+}
+
+fn test_bind_ipv6() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET6, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv6_sock_addr(net::IPV6_LOCALHOST, 1234);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in6).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in6>() as libc::socklen_t,
+        ));
+    }
+}
+
+fn test_listen() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    // Use the supported backlog value to avoid the warning.
+    let backlog = 128;
+
+    unsafe {
+        errno_check(libc::listen(sockfd, backlog));
+    }
+}
+
+/// Set a socket option. It's the caller's responsibility to ensure that `T` is
+/// associated with the given socket option.
+///
+/// This function is directly copied from the standard library implementation
+/// for sockets on UNIX targets.
+fn setsockopt<T>(
+    sockfd: i32,
+    level: libc::c_int,
+    option_name: libc::c_int,
+    option_value: T,
+) -> io::Result<()> {
+    let option_len = size_of::<T>() as libc::socklen_t;
+
+    errno_result(unsafe {
+        libc::setsockopt(
+            sockfd,
+            level,
+            option_name,
+            (&raw const option_value) as *const _,
+            option_len,
+        )
+    })?;
+    Ok(())
+}
diff --git a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
new file mode 100644
index 000000000000..193a6c693801
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
@@ -0,0 +1,27 @@
+//@ignore-target: windows # No libc socket on Windows
+//@compile-flags: -Zmiri-disable-isolation
+
+#[path = "../../utils/libc.rs"]
+mod libc_utils;
+use libc_utils::*;
+
+fn main() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 2345);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    // Only supported value is 128, thus we use 127 to trigger the warning.
+    let backlog = 127;
+
+    unsafe {
+        let errno = libc::listen(sockfd, backlog);
+        errno_check(errno);
+    }
+}
diff --git a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
new file mode 100644
index 000000000000..94582af4a6e2
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
@@ -0,0 +1,8 @@
+warning: called `listen` on socket with backlog value of 127 but only 128 is supported
+  --> tests/pass-dep/libc/socket-unsupported-listen-backlog.rs:LL:CC
+   |
+LL |         let errno = libc::listen(sockfd, backlog);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to `listen` with unsupported backlog value
+   |
+   = note: the given value will be ignored and a backlog of 128 will be used instead
+
diff --git a/src/tools/miri/tests/pass-dep/shims/socket.rs b/src/tools/miri/tests/pass-dep/shims/socket.rs
new file mode 100644
index 000000000000..8a1cd68e5d0c
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/shims/socket.rs
@@ -0,0 +1,17 @@
+//@ignore-target: windows # No libc socket on Windows
+//@compile-flags: -Zmiri-disable-isolation
+
+use std::net::TcpListener;
+
+fn main() {
+    create_ipv4_listener();
+    create_ipv6_listener();
+}
+
+fn create_ipv4_listener() {
+    let _listener_ipv4 = TcpListener::bind("127.0.0.1:3456").unwrap();
+}
+
+fn create_ipv6_listener() {
+    let _listener_ipv6 = TcpListener::bind("[::1]:2345").unwrap();
+}
diff --git a/src/tools/miri/tests/utils/libc.rs b/src/tools/miri/tests/utils/libc.rs
index 0cc6ad0334c0..ef22d3af5425 100644
--- a/src/tools/miri/tests/utils/libc.rs
+++ b/src/tools/miri/tests/utils/libc.rs
@@ -157,3 +157,51 @@ pub fn check_epoll_wait_noblock<const N: usize>(epfd: i32, expected: &[Ev]) {
         check_epoll_wait::<N>(epfd, expected, 0);
     }
 }
+
+pub mod net {
+    /// IPv4 localhost address bytes
+    pub const IPV4_LOCALHOST: [u8; 4] = [127, 0, 0, 1];
+    /// IPv6 localhost address bytes
+    pub const IPV6_LOCALHOST: [u8; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+
+    /// Create a libc representation of an IPv4 address given the address bytes and a port.
+    pub fn ipv4_sock_addr(addr_bytes: [u8; 4], port: u16) -> libc::sockaddr_in {
+        libc::sockaddr_in {
+            sin_family: libc::AF_INET as libc::sa_family_t,
+            sin_port: port.to_be(),
+            // `addr_bytes` is already in big-endian and that's the format `sin_addr` expects.
+            #[expect(unnecessary_transmutes)]
+            sin_addr: libc::in_addr {
+                s_addr: unsafe { std::mem::transmute::<[u8; 4], u32>(addr_bytes) },
+            },
+            ..unsafe { core::mem::zeroed() }
+        }
+    }
+
+    /// Create a libc representation of an IPv6 address given the address bytes and a port.
+    ///
+    /// This method sets `flowinfo` and `scope_id` to 0.
+    pub fn ipv6_sock_addr(addr_bytes: [u8; 16], port: u16) -> libc::sockaddr_in6 {
+        ipv6_sock_addr_full(addr_bytes, port, 0, 0)
+    }
+
+    /// Create a libc representation of a full IPv6 address given the address bytes, a port
+    /// as well as a flowinfo and scope id.
+    pub fn ipv6_sock_addr_full(
+        addr_bytes: [u8; 16],
+        port: u16,
+        flowinfo: u32,
+        scope_id: u32,
+    ) -> libc::sockaddr_in6 {
+        #[allow(clippy::needless_update)]
+        libc::sockaddr_in6 {
+            sin6_family: libc::AF_INET6 as libc::sa_family_t,
+            sin6_port: port.to_be(),
+            sin6_addr: libc::in6_addr { s6_addr: addr_bytes },
+            sin6_flowinfo: flowinfo,
+            sin6_scope_id: scope_id,
+            // This is only needed on some targets where an additional `sin6_len` field exists.
+            ..unsafe { core::mem::zeroed() }
+        }
+    }
+}

From e316da9660a6a2d28fc0d93a915056705becf5de Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:16:48 +0000
Subject: [PATCH 0166/1059] Fix unused feature warning

---
 example/std_example.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/example/std_example.rs b/example/std_example.rs
index 408c9b3dad0f..5fef141a3953 100644
--- a/example/std_example.rs
+++ b/example/std_example.rs
@@ -1,7 +1,6 @@
 #![feature(
     core_intrinsics,
     coroutines,
-    stmt_expr_attributes,
     coroutine_trait,
     repr_simd,
     tuple_trait,

From 2d2c5521a2e2c592e587657dbe6277f19b56042d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 6 Mar 2026 15:07:59 +0000
Subject: [PATCH 0167/1059] Fix another unused feature warning

---
 example/neon.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/neon.rs b/example/neon.rs
index fb3e10a41c02..98a2a7af38f6 100644
--- a/example/neon.rs
+++ b/example/neon.rs
@@ -1,6 +1,6 @@
 // Most of these tests are copied from https://github.com/japaric/stdsimd/blob/0f4413d01c4f0c3ffbc5a69e9a37fbc7235b31a9/coresimd/arm/neon.rs
 
-#![feature(portable_simd)]
+#![cfg_attr(target_arch = "aarch64", feature(portable_simd))]
 
 #[cfg(target_arch = "aarch64")]
 use std::arch::aarch64::*;

From 835c745a9ee60493a23fc596e949b20a604ba0e2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 6 Mar 2026 19:47:48 +0800
Subject: [PATCH 0168/1059] internal: shortcuit simple current parameter

---
 .../crates/ide-completion/src/completions/fn_param.rs       | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
index 96dac66b8a19..9a33757d555b 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
@@ -75,9 +75,6 @@ fn fill_fn_params(
     let mut file_params = FxHashMap::default();
 
     let mut extract_params = |f: ast::Fn| {
-        if !is_simple_param(current_param) {
-            return;
-        }
         f.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
             if let Some(pat) = param.pat() {
                 let whole_param = param.to_smolstr();
@@ -88,6 +85,9 @@ fn fill_fn_params(
     };
 
     for node in ctx.token.parent_ancestors() {
+        if !is_simple_param(current_param) {
+            break;
+        }
         match_ast! {
             match node {
                 ast::SourceFile(it) => it.items().filter_map(|item| match item {

From 923582ca0833798fe6943afc9cde35b49ba16ffd Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 6 Mar 2026 20:20:12 +0800
Subject: [PATCH 0169/1059] fix: add ident_pat qualifier to fully fn param

- Do not show commas on label

Example
---
```rust
fn f(foo: (), bar: u32) {}
fn g(foo: (), mut ba$0)
```

**Before this PR**

```rust
fn f(foo: (), bar: u32) {}
fn g(foo: (), bar: u32)
```

**After this PR**

```rust
fn f(foo: (), bar: u32) {}
fn g(foo: (), mut bar: u32)
```
---
 .../src/completions/fn_param.rs               | 34 ++++++++++++++++---
 .../ide-completion/src/render/function.rs     | 33 +++++++++++++++---
 .../ide-completion/src/tests/fn_param.rs      |  2 +-
 3 files changed, 60 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
index 9a33757d555b..bd0b69215cf7 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/fn_param.rs
@@ -30,14 +30,27 @@ pub(crate) fn complete_fn_param(
         _ => return None,
     };
 
+    let qualifier = param_qualifier(param);
     let comma_wrapper = comma_wrapper(ctx);
     let mut add_new_item_to_acc = |label: &str| {
-        let mk_item = |label: &str, range: TextRange| {
-            CompletionItem::new(CompletionItemKind::Binding, range, label, ctx.edition)
+        let label = label.strip_prefix(qualifier.as_str()).unwrap_or(label);
+        let insert = if label.starts_with('#') {
+            // FIXME: `#[attr] it: i32` -> `#[attr] mut it: i32`
+            label.to_smolstr()
+        } else {
+            format_smolstr!("{qualifier}{label}")
+        };
+        let mk_item = |insert_text: &str, range: TextRange| {
+            let mut item =
+                CompletionItem::new(CompletionItemKind::Binding, range, label, ctx.edition);
+            if insert_text != label {
+                item.insert_text(insert_text);
+            }
+            item
         };
         let item = match &comma_wrapper {
-            Some((fmt, range)) => mk_item(&fmt(label), *range),
-            None => mk_item(label, ctx.source_range()),
+            Some((fmt, range)) => mk_item(&fmt(&insert), *range),
+            None => mk_item(&insert, ctx.source_range()),
         };
         // Completion lookup is omitted intentionally here.
         // See the full discussion: https://github.com/rust-lang/rust-analyzer/issues/12073
@@ -214,3 +227,16 @@ fn is_simple_param(param: &ast::Param) -> bool {
         .pat()
         .is_none_or(|pat| matches!(pat, ast::Pat::IdentPat(ident_pat) if ident_pat.pat().is_none()))
 }
+
+fn param_qualifier(param: &ast::Param) -> SmolStr {
+    let mut b = syntax::SmolStrBuilder::new();
+    if let Some(ast::Pat::IdentPat(pat)) = param.pat() {
+        if pat.ref_token().is_some() {
+            b.push_str("ref ");
+        }
+        if pat.mut_token().is_some() {
+            b.push_str("mut ");
+        }
+    }
+    b.finish()
+}
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render/function.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render/function.rs
index 475e00dfcf29..dfa30841e7db 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render/function.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render/function.rs
@@ -678,7 +678,7 @@ fn main() {
     fn complete_fn_param() {
         // has mut kw
         check_edit(
-            "mut bar: u32",
+            "bar: u32",
             r#"
 fn f(foo: (), mut bar: u32) {}
 fn g(foo: (), mut ba$0)
@@ -689,10 +689,35 @@ fn g(foo: (), mut bar: u32)
 "#,
         );
 
-        // has type param
+        // has unmatched mut kw
+        check_edit(
+            "bar: u32",
+            r#"
+fn f(foo: (), bar: u32) {}
+fn g(foo: (), mut ba$0)
+"#,
+            r#"
+fn f(foo: (), bar: u32) {}
+fn g(foo: (), mut bar: u32)
+"#,
+        );
+
         check_edit(
             "mut bar: u32",
             r#"
+fn f(foo: (), mut bar: u32) {}
+fn g(foo: (), ba$0)
+"#,
+            r#"
+fn f(foo: (), mut bar: u32) {}
+fn g(foo: (), mut bar: u32)
+"#,
+        );
+
+        // has type param
+        check_edit(
+            "bar: u32",
+            r#"
 fn g(foo: (), mut ba$0: u32)
 fn f(foo: (), mut bar: u32) {}
 "#,
@@ -707,7 +732,7 @@ fn f(foo: (), mut bar: u32) {}
     fn complete_fn_mut_param_add_comma() {
         // add leading and trailing comma
         check_edit(
-            ", mut bar: u32,",
+            "bar: u32",
             r#"
 fn f(foo: (), mut bar: u32) {}
 fn g(foo: ()mut ba$0 baz: ())
@@ -746,7 +771,7 @@ fn g(foo: (), #[baz = "qux"] mut bar: u32)
         );
 
         check_edit(
-            r#", #[baz = "qux"] mut bar: u32"#,
+            r#"#[baz = "qux"] mut bar: u32"#,
             r#"
 fn f(foo: (), #[baz = "qux"] mut bar: u32) {}
 fn g(foo: ()#[baz = "qux"] mut ba$0)
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/fn_param.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/fn_param.rs
index d6d73da3f140..aaa225642c6f 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/fn_param.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/fn_param.rs
@@ -43,7 +43,7 @@ fn bar(file_id: usize) {}
 fn baz(file$0 id: u32) {}
 "#,
         expect![[r#"
-            bn file_id: usize,
+            bn file_id: usize
             kw mut
             kw ref
         "#]],

From ae25efb4ac3db8dbec8dc9f4d41f427f47600175 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 16:38:53 +0100
Subject: [PATCH 0170/1059] Fix panic by setting the span before it is actually
 needed

---
 clippy_utils/src/diagnostics.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 65c962826900..c0d02aaa6ee8 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -250,9 +250,11 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         }
     }
 
+    let sp = sp.into();
     #[expect(clippy::disallowed_methods)]
-    cx.emit_span_lint(lint, sp, ClippyDiag(|diag: &mut Diag<'_, ()>| {
+    cx.emit_span_lint(lint, sp.clone(), ClippyDiag(|diag: &mut Diag<'_, ()>| {
         diag.primary_message(msg);
+        diag.span(sp);
         f(diag);
         docs_link(diag, lint);
 

From ae909778390ad9af2f919e171a576e0f9211d083 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Fri, 6 Mar 2026 15:43:14 +0000
Subject: [PATCH 0171/1059] fix: Update VFS when a watched file is deleted

When rust-analyzer handles file watching, it previously wouldn't
update the VFS on file deletion. We would discard events where
fs::metadata() isn't available, and we never have metadata for deleted
files.

See also the discussion in rust-lang/rust-analyzer#19907.
---
 .../crates/vfs-notify/src/lib.rs              | 25 ++++++++++++-------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs b/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
index c6393cc6922a..f55ce24597b7 100644
--- a/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
@@ -208,6 +208,22 @@ fn run(mut self, inbox: Receiver<Message>) {
                                 )
                             })
                             .filter_map(|path| -> Option<(AbsPathBuf, Option<Vec<u8>>)> {
+                                // Ignore events for files/directories that we're not watching.
+                                if !(self.watched_file_entries.contains(&path)
+                                    || self
+                                        .watched_dir_entries
+                                        .iter()
+                                        .any(|dir| dir.contains_file(&path)))
+                                {
+                                    return None;
+                                }
+
+                                // For removed files, fs::metadata() will return Err, but
+                                // we still want to update the VFS.
+                                if matches!(event.kind, EventKind::Remove(_)) {
+                                    return Some((path, None));
+                                }
+
                                 let meta = fs::metadata(&path).ok()?;
                                 if meta.file_type().is_dir()
                                     && self
@@ -223,15 +239,6 @@ fn run(mut self, inbox: Receiver<Message>) {
                                     return None;
                                 }
 
-                                if !(self.watched_file_entries.contains(&path)
-                                    || self
-                                        .watched_dir_entries
-                                        .iter()
-                                        .any(|dir| dir.contains_file(&path)))
-                                {
-                                    return None;
-                                }
-
                                 let contents = read(&path);
                                 Some((path, contents))
                             })

From f5991a8f5a7dd8950534fe91445bf163c5554f89 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Tue, 24 Feb 2026 19:29:04 -0500
Subject: [PATCH 0172/1059] fix: Incorrect flychecks with multiple workspaces

When rust-analyzer receives textDocument/didChangeWatchedFiles, we
want to trigger a flycheck in all workspaces if we can't find which
workspace owns those files.

However, since we used .any() instead of .all(), this behaviour was
always triggered when the user had more than one workspace.

Instead, use .all() so we correctly detect when the file it outside of
all workspaces.

---

For cargo-based projects, this just made rust-analyzer slower. For
projects with a custom check command using $saved_file or
{saved_file}, this introduced a race condition that sometimes
prevented diagnostics.

When we see the following flycheck events in this order:

    // Created by textDocument/didSave.
    RequestStateChange(Restart { ... saved_file: Some("foo.rs") })
    // Created by textDocument/didChangeWatchedFiles
    RequestStateChange(Restart { ... saved_file: None })

Then the flycheck debounce takes the last event, we invoke flycheck
with saved_file: None, and no flycheck occurs (because we require a
value to substitute in $saved_file).

Previously the debounce took the first event (until
rust-lang/rust-analyzer#21666), but that just meant a race condition
when events arrive in the opposite order.
---
 src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs   | 2 +-
 .../crates/rust-analyzer/src/handlers/notification.rs          | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index cdaf944bbad4..c41696bf3f6a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -1021,7 +1021,7 @@ fn from_eof(&self) -> Option<CheckMessage> {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 #[serde(untagged)]
 enum JsonMessage {
     Cargo(cargo_metadata::Message),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
index 138310b78f62..09b6794e4f43 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
@@ -295,8 +295,9 @@ pub(crate) fn handle_did_change_watched_files(
     for change in params.changes.iter().unique_by(|&it| &it.uri) {
         if let Ok(path) = from_proto::abs_path(&change.uri) {
             if !trigger_flycheck {
+                // Trigger if no workspaces contain this file.
                 trigger_flycheck =
-                    state.config.workspace_roots().iter().any(|root| !path.starts_with(root));
+                    state.config.workspace_roots().iter().all(|root| !path.starts_with(root));
             }
             state.loader.handle.invalidate(path);
         }

From 56a074bd3567032ef4ee2433d658d78aa727b596 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Fri, 6 Mar 2026 17:09:01 +0000
Subject: [PATCH 0173/1059] fix: File watcher should watch directories
 recursively

Currently rust-analyzer only watches the directory itself, and doesn't
consider children recursively.

This is a problem when the directory itself is deleted and
recreated (e.g. if you're creating all of `mycrate/src/` with a code
generating script). The obvious solution is to configure rust-analyzer
to watch the parent directory (assuming rust-project.json), but that
requires recursive watching.

This problem probably also occurs when switching between git commits.

Instead, watch directories recursively so we can use the file watcher
with parent directories.

See also discussion on rust-lang/rust-analyzer#19907.

I've tested on some decent sized projects (several hundred transitive
dependencies) and performance seemed fine.
---
 src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs b/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
index c6393cc6922a..3214c03a0eab 100644
--- a/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/vfs-notify/src/lib.rs
@@ -317,7 +317,7 @@ fn load_entry(
 
     fn watch(&mut self, path: &Path) {
         if let Some((watcher, _)) = &mut self.watcher {
-            log_notify_error(watcher.watch(path, RecursiveMode::NonRecursive));
+            log_notify_error(watcher.watch(path, RecursiveMode::Recursive));
         }
     }
 

From 65e7758f07a2d5b14c4be67e4bc8dd9281f76a2d Mon Sep 17 00:00:00 2001
From: Jason Haslam <jason@scitools.com>
Date: Fri, 6 Mar 2026 11:35:35 -0700
Subject: [PATCH 0174/1059] Fix syntax/fuzz build error

---
 src/tools/rust-analyzer/crates/syntax/fuzz/Cargo.toml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/fuzz/Cargo.toml b/src/tools/rust-analyzer/crates/syntax/fuzz/Cargo.toml
index b2f238efc025..41db3ddcc550 100644
--- a/src/tools/rust-analyzer/crates/syntax/fuzz/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/syntax/fuzz/Cargo.toml
@@ -23,6 +23,3 @@ path = "fuzz_targets/parser.rs"
 [[bin]]
 name = "reparse"
 path = "fuzz_targets/reparse.rs"
-
-[lints]
-workspace = true

From 2b1bef988c02af11e95ac9d7f24e0e3e36b15844 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 6 Mar 2026 22:01:51 +0100
Subject: [PATCH 0175/1059] readme(target features): mention RUSTDOCFLAGS

---
 src/tools/miri/README.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index c71e45f4e214..4808e53698c6 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -158,11 +158,13 @@ endian-sensitive code.
 
 Controlling target features works similar to regular rustc invocations:
 `RUSTFLAGS="-Ctarget-features=+avx512f" cargo miri test` runs the tests with AVX512 enabled. (Miri
-only supports very few AVX512 intrinsics at the moment.) `-Ctarget-cpu` also works. Unlike regular
-rustc, this command has *two* effects: it builds the code with that target feature available (which
-affects `cfg(target_feature)`), and it tells Miri to consider the "virtual CPU" that the interpreted
-program runs on as having the feature available (meaning the code is allowed to invoke the
-corresponding intrinsics).
+only supports very few AVX512 intrinsics at the moment.) `-Ctarget-cpu` also works. If target
+features are also relevant for doctests, you have to also set `RUSTDOCFLAGS`.
+
+Unlike regular rustc, this flag has *two* effects: it builds the code with that target feature
+available (which affects `cfg(target_feature)`), and it tells Miri to consider the "virtual CPU"
+that the interpreted program runs on as having the feature available (meaning the code is allowed to
+invoke the corresponding intrinsics).
 
 ### Testing multiple different executions
 

From c465c7571a9c83cdb98dbb6311a6774accc8c14a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 6 Mar 2026 21:47:56 +0000
Subject: [PATCH 0176/1059] Another unused feature fix

---
 example/mini_core.rs             | 4 ++--
 example/mini_core_hello_world.rs | 3 ++-
 example/std_example.rs           | 9 +--------
 3 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/example/mini_core.rs b/example/mini_core.rs
index 8a4e3ade667b..5792b85a6245 100644
--- a/example/mini_core.rs
+++ b/example/mini_core.rs
@@ -8,9 +8,9 @@
     rustc_attrs,
     transparent_unions,
     auto_traits,
-    freeze_impls,
-    thread_local
+    freeze_impls
 )]
+#![cfg_attr(not(all(windows, target_env = "gnu")), thread_local)]
 #![no_core]
 #![allow(dead_code, internal_features, ambiguous_wide_pointer_comparisons)]
 
diff --git a/example/mini_core_hello_world.rs b/example/mini_core_hello_world.rs
index c971a7df34b0..182cc3d0e5fa 100644
--- a/example/mini_core_hello_world.rs
+++ b/example/mini_core_hello_world.rs
@@ -1,4 +1,5 @@
-#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local, repr_simd)]
+#![feature(no_core, lang_items, never_type, extern_types, thread_local, repr_simd)]
+#![cfg_attr(not(any(jit, target_vendor = "apple", windows)), feature(linkage))]
 #![no_core]
 #![allow(dead_code, non_camel_case_types, internal_features)]
 
diff --git a/example/std_example.rs b/example/std_example.rs
index 5fef141a3953..360fb76a6224 100644
--- a/example/std_example.rs
+++ b/example/std_example.rs
@@ -1,11 +1,4 @@
-#![feature(
-    core_intrinsics,
-    coroutines,
-    coroutine_trait,
-    repr_simd,
-    tuple_trait,
-    unboxed_closures
-)]
+#![feature(core_intrinsics, coroutines, coroutine_trait, repr_simd, tuple_trait, unboxed_closures)]
 #![allow(internal_features)]
 
 #[cfg(target_arch = "x86_64")]

From ecec8315572cd7992b692ea15bd9d083bc7ec51a Mon Sep 17 00:00:00 2001
From: protonblu <akashchakrabortymsc@gmail.com>
Date: Sat, 7 Mar 2026 12:44:36 +0530
Subject: [PATCH 0177/1059] Migrate unqualify_method_call assist to
 SyntaxEditor

---
 .../src/handlers/unqualify_method_call.rs     | 66 ++++++++-----------
 1 file changed, 28 insertions(+), 38 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
index a58b1da621c7..ef395791e251 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
@@ -1,8 +1,5 @@
 use hir::AsAssocItem;
-use syntax::{
-    TextRange,
-    ast::{self, AstNode, HasArgList, prec::ExprPrecedence},
-};
+use syntax::ast::{self, AstNode, HasArgList, prec::ExprPrecedence, syntax_factory::SyntaxFactory};
 
 use crate::{AssistContext, AssistId, Assists};
 
@@ -36,10 +33,7 @@ pub(crate) fn unqualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>)
     }
 
     let args = call.arg_list()?;
-    let l_paren = args.l_paren_token()?;
-    let mut args_iter = args.args();
-    let first_arg = args_iter.next()?;
-    let second_arg = args_iter.next();
+    let first_arg = args.args().next()?;
 
     let qualifier = path.qualifier()?;
     let method_name = path.segment()?.name_ref()?;
@@ -51,43 +45,33 @@ pub(crate) fn unqualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>)
         return None;
     }
 
-    // `core::ops::Add::add(` -> ``
-    let delete_path =
-        TextRange::new(path.syntax().text_range().start(), l_paren.text_range().end());
-
-    // Parens around `expr` if needed
-    let parens = first_arg.precedence().needs_parentheses_in(ExprPrecedence::Postfix).then(|| {
-        let range = first_arg.syntax().text_range();
-        (range.start(), range.end())
-    });
-
-    // `, ` -> `.add(`
-    let replace_comma = TextRange::new(
-        first_arg.syntax().text_range().end(),
-        second_arg
-            .map(|a| a.syntax().text_range().start())
-            .unwrap_or_else(|| first_arg.syntax().text_range().end()),
-    );
-
     acc.add(
         AssistId::refactor_rewrite("unqualify_method_call"),
         "Unqualify method call",
         call.syntax().text_range(),
-        |edit| {
-            edit.delete(delete_path);
-            if let Some((open, close)) = parens {
-                edit.insert(open, "(");
-                edit.insert(close, ")");
-            }
-            edit.replace(replace_comma, format!(".{method_name}("));
+        |builder| {
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(call.syntax());
+
+            let new_arg_list = make.arg_list(args.args().skip(1));
+            let receiver = if first_arg.precedence().needs_parentheses_in(ExprPrecedence::Postfix) {
+                ast::Expr::from(make.expr_paren(first_arg.clone()))
+            } else {
+                first_arg.clone()
+            };
+            let method_call = make.expr_method_call(receiver, method_name, new_arg_list);
+
+            editor.replace(call.syntax(), method_call.syntax());
 
             if let Some(fun) = fun.as_assoc_item(ctx.db())
                 && let Some(trait_) = fun.container_or_implemented_trait(ctx.db())
                 && !scope.can_use_trait_methods(trait_)
             {
-                // Only add an import for trait methods that are not already imported.
-                add_import(qualifier, ctx, edit);
+                add_import(qualifier, ctx, &make, &mut editor);
             }
+
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
@@ -95,7 +79,8 @@ pub(crate) fn unqualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>)
 fn add_import(
     qualifier: ast::Path,
     ctx: &AssistContext<'_>,
-    edit: &mut ide_db::source_change::SourceChangeBuilder,
+    make: &SyntaxFactory,
+    editor: &mut syntax::syntax_editor::SyntaxEditor,
 ) {
     if let Some(path_segment) = qualifier.segment() {
         // for `<i32 as std::ops::Add>`
@@ -122,8 +107,13 @@ fn add_import(
         );
 
         if let Some(scope) = scope {
-            let scope = edit.make_import_scope_mut(scope);
-            ide_db::imports::insert_use::insert_use(&scope, import, &ctx.config.insert_use);
+            ide_db::imports::insert_use::insert_use_with_editor(
+                &scope,
+                import,
+                &ctx.config.insert_use,
+                editor,
+                make,
+            );
         }
     }
 }

From 58652d5a4312b2d2549d2f631bc301df8e4d7aae Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 09:42:15 +0100
Subject: [PATCH 0178/1059] Fix LegacyKeyValueFormat report from docker build:
 ohos

---
 src/ci/docker/host-x86_64/dist-ohos-aarch64/Dockerfile | 7 +++----
 src/ci/docker/host-x86_64/dist-ohos-x86_64/Dockerfile  | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-ohos-aarch64/Dockerfile b/src/ci/docker/host-x86_64/dist-ohos-aarch64/Dockerfile
index adeaf809f420..f97092e9dd1f 100644
--- a/src/ci/docker/host-x86_64/dist-ohos-aarch64/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-ohos-aarch64/Dockerfile
@@ -40,14 +40,13 @@ ENV \
     AR_aarch64_unknown_linux_ohos=/opt/ohos-sdk/native/llvm/bin/llvm-ar \
     CXX_aarch64_unknown_linux_ohos=/usr/local/bin/aarch64-unknown-linux-ohos-clang++.sh
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-profiler \
+ENV RUST_CONFIGURE_ARGS="--enable-profiler \
     --disable-docs \
     --tools=cargo,clippy,rustdocs,rustfmt,rust-analyzer,rust-analyzer-proc-macro-srv,analysis,src,wasm-component-ld \
     --enable-extended \
-    --enable-sanitizers
+    --enable-sanitizers"
 
-ENV SCRIPT python3 ../x.py dist --host=$TARGETS --target $TARGETS
+ENV SCRIPT="python3 ../x.py dist --host=$TARGETS --target $TARGETS"
 
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
diff --git a/src/ci/docker/host-x86_64/dist-ohos-x86_64/Dockerfile b/src/ci/docker/host-x86_64/dist-ohos-x86_64/Dockerfile
index 98e402adf2a6..e3352e52d691 100644
--- a/src/ci/docker/host-x86_64/dist-ohos-x86_64/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-ohos-x86_64/Dockerfile
@@ -40,14 +40,13 @@ ENV \
     AR_x86_64_unknown_linux_ohos=/opt/ohos-sdk/native/llvm/bin/llvm-ar \
     CXX_x86_64_unknown_linux_ohos=/usr/local/bin/x86_64-unknown-linux-ohos-clang++.sh
 
-ENV RUST_CONFIGURE_ARGS \
-    --enable-profiler \
+ENV RUST_CONFIGURE_ARGS="--enable-profiler \
     --disable-docs \
     --tools=cargo,clippy,rustdocs,rustfmt,rust-analyzer,rust-analyzer-proc-macro-srv,analysis,src,wasm-component-ld \
     --enable-extended \
-    --enable-sanitizers
+    --enable-sanitizers"
 
-ENV SCRIPT python3 ../x.py dist --host=$TARGETS --target $TARGETS
+ENV SCRIPT="python3 ../x.py dist --host=$TARGETS --target $TARGETS"
 
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh

From 82034115efa523a2fa470078901db92d2d4d246f Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 09:45:29 +0100
Subject: [PATCH 0179/1059] Fix LegacyKeyValueFormat report from docker build:
 mips

---
 src/ci/docker/host-x86_64/dist-mips-linux/Dockerfile     | 4 ++--
 src/ci/docker/host-x86_64/dist-mips64-linux/Dockerfile   | 4 ++--
 src/ci/docker/host-x86_64/dist-mips64el-linux/Dockerfile | 4 ++--
 src/ci/docker/host-x86_64/dist-mipsel-linux/Dockerfile   | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-mips-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-mips-linux/Dockerfile
index 4a090dcdd508..3d7f5f81fbec 100644
--- a/src/ci/docker/host-x86_64/dist-mips-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-mips-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=mips-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-mips64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-mips64-linux/Dockerfile
index 18b0375f4008..3c798d737a48 100644
--- a/src/ci/docker/host-x86_64/dist-mips64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-mips64-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=mips64-unknown-linux-gnuabi64
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-mips64el-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-mips64el-linux/Dockerfile
index 87407203880b..32fd634555c2 100644
--- a/src/ci/docker/host-x86_64/dist-mips64el-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-mips64el-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=mips64el-unknown-linux-gnuabi64
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-mipsel-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-mipsel-linux/Dockerfile
index 553f6ea86b72..73ab0cf5bab6 100644
--- a/src/ci/docker/host-x86_64/dist-mipsel-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-mipsel-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=mipsel-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"

From 63a02ac1b37772aaeced31c6def24fbeb5ab209b Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 09:37:38 +0100
Subject: [PATCH 0180/1059] Fix LegacyKeyValueFormat report from docker build:
 i686

---
 .../dist-i586-gnu-i586-i686-musl/Dockerfile       | 10 ++++------
 .../docker/host-x86_64/dist-i686-linux/Dockerfile | 15 +++++++--------
 .../docker/host-x86_64/i686-gnu-nopt/Dockerfile   |  4 ++--
 src/ci/docker/host-x86_64/i686-gnu/Dockerfile     |  4 ++--
 4 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile b/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile
index a62f98b21d22..31d009b6969a 100644
--- a/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile
@@ -57,10 +57,9 @@ RUN ln -s /usr/lib32/libgcc_s.so.1 /musl-i686/lib/
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_CONFIGURE_ARGS \
-      --musl-root-i586=/musl-i586 \
+ENV RUST_CONFIGURE_ARGS="--musl-root-i586=/musl-i586 \
       --musl-root-i686=/musl-i686 \
-      --disable-docs
+      --disable-docs"
 
 # Newer binutils broke things on some vms/distros (i.e., linking against
 # unknown relocs disabled by the following flag), so we need to go out of our
@@ -73,6 +72,5 @@ ENV CFLAGS_i586_unknown_linux_musl=-Wa,-mrelax-relocations=no
 
 ENV TARGETS=i586-unknown-linux-gnu,i686-unknown-linux-musl
 
-ENV SCRIPT \
-      python3 ../x.py --stage 2 test --host='' --target $TARGETS && \
-      python3 ../x.py dist --host='' --target $TARGETS,i586-unknown-linux-musl
+ENV SCRIPT="python3 ../x.py --stage 2 test --host= --target $TARGETS && \
+      python3 ../x.py dist --host= --target $TARGETS,i586-unknown-linux-musl"
diff --git a/src/ci/docker/host-x86_64/dist-i686-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-i686-linux/Dockerfile
index ea5b208a7c1d..8165258cc49f 100644
--- a/src/ci/docker/host-x86_64/dist-i686-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-i686-linux/Dockerfile
@@ -70,15 +70,14 @@ RUN sh /scripts/sccache.sh
 
 ENV HOSTS=i686-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS \
-      --enable-full-tools \
+ENV RUST_CONFIGURE_ARGS="--enable-full-tools \
       --enable-sanitizers \
       --enable-profiler \
       --set target.i686-unknown-linux-gnu.linker=clang \
       --build=i686-unknown-linux-gnu \
       --set llvm.ninja=false \
-      --set rust.jemalloc
-ENV SCRIPT python3 ../x.py dist --build $HOSTS --host $HOSTS --target $HOSTS
+      --set rust.jemalloc"
+ENV SCRIPT="python3 ../x.py dist --build $HOSTS --host $HOSTS --target $HOSTS"
 ENV CARGO_TARGET_I686_UNKNOWN_LINUX_GNU_LINKER=clang
 
 # This was added when we switched from gcc to clang. It's not clear why this is
@@ -89,17 +88,17 @@ ENV CARGO_TARGET_I686_UNKNOWN_LINUX_GNU_LINKER=clang
 # misaligned stack access.
 #
 # Added in #50200 there's some more logs there
-ENV CFLAGS -mstackrealign
+ENV CFLAGS="-mstackrealign"
 
 # When we build cargo in this container, we don't want it to use the system
 # libcurl, instead it should compile its own.
-ENV LIBCURL_NO_PKG_CONFIG 1
+ENV LIBCURL_NO_PKG_CONFIG="1"
 
 # There was a bad interaction between "old" 32-bit binaries on current 64-bit
 # kernels with selinux enabled, where ASLR mmap would sometimes choose a low
 # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`.
 # This is probably a kernel bug, but setting `ulimit -Hs` works around it.
 # See also `src/ci/run.sh` where this takes effect.
-ENV SET_HARD_RLIMIT_STACK 1
+ENV SET_HARD_RLIMIT_STACK="1"
 
-ENV DIST_REQUIRE_ALL_TOOLS 1
+ENV DIST_REQUIRE_ALL_TOOLS="1"
diff --git a/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile b/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile
index be3df9d4036d..fdc296aa891f 100644
--- a/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile
+++ b/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile
@@ -22,8 +22,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_CONFIGURE_ARGS --build=i686-unknown-linux-gnu --disable-optimize-tests
+ENV RUST_CONFIGURE_ARGS="--build=i686-unknown-linux-gnu --disable-optimize-tests"
 COPY scripts/stage_2_test_set1.sh /scripts/
 COPY scripts/stage_2_test_set2.sh /scripts/
 COPY scripts/i686-gnu-nopt-2.sh /scripts/
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
+ENV SCRIPT="Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/docker/host-x86_64/i686-gnu/Dockerfile b/src/ci/docker/host-x86_64/i686-gnu/Dockerfile
index 00cd24b89db8..d0f3d1afa4dc 100644
--- a/src/ci/docker/host-x86_64/i686-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/i686-gnu/Dockerfile
@@ -23,7 +23,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_CONFIGURE_ARGS --build=i686-unknown-linux-gnu
+ENV RUST_CONFIGURE_ARGS="--build=i686-unknown-linux-gnu"
 COPY scripts/stage_2_test_set1.sh /scripts/
 COPY scripts/stage_2_test_set2.sh /scripts/
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
+ENV SCRIPT="Must specify DOCKER_SCRIPT for this image"

From fcfd96e821339803350bef5ae702c72d85768e75 Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 10:14:23 +0100
Subject: [PATCH 0181/1059] Fix LegacyKeyValueFormat report from docker build:
 pr

---
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile | 4 ++--
 src/ci/docker/host-x86_64/pr-check-2/Dockerfile | 5 ++---
 src/ci/docker/host-x86_64/tidy/Dockerfile       | 4 ++--
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
index c1742720f778..a595a079b48f 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -39,7 +39,7 @@ COPY host-x86_64/pr-check-1/validate-toolstate.sh /scripts/
 # Check library crates on all tier 1 targets.
 # We disable optimized compiler built-ins because that requires a C toolchain for the target.
 # We also skip the x86_64-unknown-linux-gnu target as it is well-tested by other jobs.
-ENV SCRIPT \
+ENV SCRIPT=" \
   # Check some tools that aren't included in `x check` by default, to
   # ensure that maintainers can still do check builds locally.
   python3 ../x.py check \
@@ -58,4 +58,4 @@ ENV SCRIPT \
   python3 ../x.py check --set build.optimized-compiler-builtins=false core alloc std --target=aarch64-unknown-linux-gnu,i686-pc-windows-msvc,i686-unknown-linux-gnu,x86_64-apple-darwin,x86_64-pc-windows-gnu,x86_64-pc-windows-msvc && \
   /scripts/validate-toolstate.sh && \
   reuse --include-submodules lint && \
-  python3 ../x.py test collect-license-metadata
+  python3 ../x.py test collect-license-metadata"
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 885bf0b30b18..6b843a6247e8 100644
--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
@@ -30,8 +30,7 @@ ENV RUST_CONFIGURE_ARGS="--set rust.validate-mir-opts=3"
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV SCRIPT \
-        python3 ../x.py check && \
+ENV SCRIPT="python3 ../x.py check && \
         python3 ../x.py clippy ci --stage 2 && \
         python3 ../x.py test --stage 1 core alloc std test proc_macro && \
         # Elsewhere, we run all tests for the host. A number of codegen tests are sensitive to the target pointer
@@ -48,4 +47,4 @@ ENV SCRIPT \
         RUSTDOCFLAGS=\"--document-private-items --document-hidden-items\" python3 ../x.py doc library/test --stage 1 && \
         # The BOOTSTRAP_TRACING flag is added to verify whether the
         # bootstrap process compiles successfully with this flag enabled.
-        BOOTSTRAP_TRACING=1 python3 ../x.py --help
+        BOOTSTRAP_TRACING=1 python3 ../x.py --help"
diff --git a/src/ci/docker/host-x86_64/tidy/Dockerfile b/src/ci/docker/host-x86_64/tidy/Dockerfile
index 133192e8ac21..e84d61e0b99c 100644
--- a/src/ci/docker/host-x86_64/tidy/Dockerfile
+++ b/src/ci/docker/host-x86_64/tidy/Dockerfile
@@ -39,5 +39,5 @@ COPY host-x86_64/pr-check-1/validate-toolstate.sh /scripts/
 
 # NOTE: intentionally uses python2 for x.py so we can test it still works.
 # validate-toolstate only runs in our CI, so it's ok for it to only support python3.
-ENV SCRIPT TIDY_PRINT_DIFF=1 python2.7 ../x.py test \
-  src/tools/tidy tidyselftest --extra-checks=py,cpp,js,spellcheck
+ENV SCRIPT="TIDY_PRINT_DIFF=1 python2.7 ../x.py test \
+  src/tools/tidy tidyselftest --extra-checks=py,cpp,js,spellcheck"

From dceeb20bbc73085a7dfdfd9eeec5918eeb92d60e Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 10:26:23 +0100
Subject: [PATCH 0182/1059] Fix LegacyKeyValueFormat report from docker build:
 various

---
 .../host-x86_64/dist-various-1/Dockerfile     | 10 ++++----
 .../host-x86_64/dist-various-2/Dockerfile     | 20 ++++++++--------
 .../host-x86_64/test-various/Dockerfile       | 23 +++++++++----------
 3 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-various-1/Dockerfile b/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
index ab29d0e80ac2..ff80d0e3c296 100644
--- a/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
@@ -152,16 +152,14 @@ ENV CFLAGS_armv5te_unknown_linux_musleabi="-march=armv5te -marm -mfloat-abi=soft
     CC_riscv64gc_unknown_none_elf=riscv64-unknown-elf-gcc \
     CFLAGS_riscv64gc_unknown_none_elf=-march=rv64gc -mabi=lp64
 
-ENV RUST_CONFIGURE_ARGS \
-      --musl-root-armv5te=/musl-armv5te \
+ENV RUST_CONFIGURE_ARGS="--musl-root-armv5te=/musl-armv5te \
       --musl-root-arm=/musl-arm \
       --musl-root-armhf=/musl-armhf \
       --musl-root-armv7hf=/musl-armv7hf \
-      --disable-docs
+      --disable-docs"
 
-ENV SCRIPT \
-      python3 ../x.py --stage 2 test --host='' --target $RUN_MAKE_TARGETS tests/run-make tests/run-make-cargo && \
-      python3 ../x.py dist --host='' --target $TARGETS
+ENV SCRIPT="python3 ../x.py --stage 2 test --host= --target $RUN_MAKE_TARGETS tests/run-make tests/run-make-cargo && \
+      python3 ../x.py dist --host= --target $TARGETS"
 
 # sccache
 COPY scripts/sccache.sh /scripts/
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 dacf3c0db202..ac169d76ee86 100644
--- a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
@@ -95,16 +95,14 @@ RUN /tmp/freebsd-toolchain.sh i686
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_AR /usr/local/bin/llvm-ar
-ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_RUSTFLAGS \
--C link-arg=--sysroot=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/sysroot \
+ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_AR="/usr/local/bin/llvm-ar"
+ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_RUSTFLAGS="-C link-arg=--sysroot=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/sysroot \
 -Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/sysroot/lib \
--Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/lib
-ENV CARGO_TARGET_AARCH64_UNKNOWN_FUCHSIA_AR /usr/local/bin/llvm-ar
-ENV CARGO_TARGET_AARCH64_UNKNOWN_FUCHSIA_RUSTFLAGS \
--C link-arg=--sysroot=/usr/local/core-linux-amd64-fuchsia-sdk/arch/arm64/sysroot \
+-Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/lib"
+ENV CARGO_TARGET_AARCH64_UNKNOWN_FUCHSIA_AR="/usr/local/bin/llvm-ar"
+ENV CARGO_TARGET_AARCH64_UNKNOWN_FUCHSIA_RUSTFLAGS="-C link-arg=--sysroot=/usr/local/core-linux-amd64-fuchsia-sdk/arch/arm64/sysroot \
 -Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/arm64/sysroot/lib \
--Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/arm64/lib
+-Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/arm64/lib"
 
 ENV TARGETS=x86_64-unknown-fuchsia
 ENV TARGETS=$TARGETS,aarch64-unknown-fuchsia
@@ -136,8 +134,8 @@ RUN ln -s /usr/include/x86_64-linux-gnu/asm /usr/local/include/asm
 # musl-gcc can't find libgcc_s.so.1 since it doesn't use the standard search paths.
 RUN ln -s /usr/riscv64-linux-gnu/lib/libgcc_s.so.1 /usr/lib/gcc-cross/riscv64-linux-gnu/11/
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --enable-lld --enable-llvm-bitcode-linker --disable-docs \
+ENV RUST_CONFIGURE_ARGS="--enable-extended --enable-lld --enable-llvm-bitcode-linker --disable-docs \
   --musl-root-armv7=/musl-armv7 \
-  --musl-root-riscv64gc=/musl-riscv64gc
+  --musl-root-riscv64gc=/musl-riscv64gc"
 
-ENV SCRIPT python3 ../x.py dist --host='' --target $TARGETS && python3 ../x.py dist --host='' --set build.sanitizers=true --target $TARGETS_SANITIZERS
+ENV SCRIPT="python3 ../x.py dist --host= --target $TARGETS && python3 ../x.py dist --host= --set build.sanitizers=true --target $TARGETS_SANITIZERS"
diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile
index 6512240730cc..10ea2646bf3b 100644
--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
+++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
@@ -45,9 +45,8 @@ RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-3
   tar -xz
 ENV WASI_SDK_PATH=/wasi-sdk-30.0-x86_64-linux
 
-ENV RUST_CONFIGURE_ARGS \
-  --musl-root-x86_64=/usr/local/x86_64-linux-musl \
-  --set rust.lld
+ENV RUST_CONFIGURE_ARGS="--musl-root-x86_64=/usr/local/x86_64-linux-musl \
+  --set rust.lld"
 
 # Some run-make tests have assertions about code size, and enabling debug
 # assertions in libstd causes the binary to be much bigger than it would
@@ -58,10 +57,10 @@ ENV NO_OVERFLOW_CHECKS=1
 
 RUN curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v38.0.4/wasmtime-v38.0.4-x86_64-linux.tar.xz | \
   tar -xJ
-ENV PATH "$PATH:/wasmtime-v38.0.4-x86_64-linux"
+ENV PATH="$PATH:/wasmtime-v38.0.4-x86_64-linux"
 
 ENV WASM_WASIP_TARGET=wasm32-wasip1
-ENV WASM_WASIP_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $WASM_WASIP_TARGET \
+ENV WASM_WASIP_SCRIPT="python3 /checkout/x.py --stage 2 test --host= --target $WASM_WASIP_TARGET \
   tests/run-make \
   tests/run-make-cargo \
   tests/ui \
@@ -69,18 +68,18 @@ ENV WASM_WASIP_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $
   tests/codegen-units \
   tests/codegen-llvm \
   tests/assembly-llvm \
-  library/core
+  library/core"
 
 ENV NVPTX_TARGETS=nvptx64-nvidia-cuda
-ENV NVPTX_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $NVPTX_TARGETS \
+ENV NVPTX_SCRIPT="python3 /checkout/x.py --stage 2 test --host= --target $NVPTX_TARGETS \
   tests/run-make \
   tests/run-make-cargo \
-  tests/assembly-llvm
+  tests/assembly-llvm"
 
 ENV MUSL_TARGETS=x86_64-unknown-linux-musl \
     CC_x86_64_unknown_linux_musl=x86_64-linux-musl-gcc \
     CXX_x86_64_unknown_linux_musl=x86_64-linux-musl-g++
-ENV MUSL_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $MUSL_TARGETS
+ENV MUSL_SCRIPT="python3 /checkout/x.py --stage 2 test --host= --target $MUSL_TARGETS"
 
 ENV UEFI_TARGETS=aarch64-unknown-uefi,i686-unknown-uefi,x86_64-unknown-uefi \
     CC_aarch64_unknown_uefi=clang-11 \
@@ -89,9 +88,9 @@ ENV UEFI_TARGETS=aarch64-unknown-uefi,i686-unknown-uefi,x86_64-unknown-uefi \
     CXX_i686_unknown_uefi=clang++-11 \
     CC_x86_64_unknown_uefi=clang-11 \
     CXX_x86_64_unknown_uefi=clang++-11
-ENV UEFI_SCRIPT python3 /checkout/x.py --stage 2 build --host='' --target $UEFI_TARGETS && \
+ENV UEFI_SCRIPT="python3 /checkout/x.py --stage 2 build --host= --target $UEFI_TARGETS && \
   python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target aarch64-unknown-uefi && \
   python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target i686-unknown-uefi && \
-  python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target x86_64-unknown-uefi
+  python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target x86_64-unknown-uefi"
 
-ENV SCRIPT $WASM_WASIP_SCRIPT && $NVPTX_SCRIPT && $MUSL_SCRIPT && $UEFI_SCRIPT
+ENV SCRIPT="$WASM_WASIP_SCRIPT && $NVPTX_SCRIPT && $MUSL_SCRIPT && $UEFI_SCRIPT"

From b9ee655517d90c3be3101bdb24445d06ad1197b1 Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Sat, 7 Mar 2026 10:40:02 +0100
Subject: [PATCH 0183/1059] Fix LegacyKeyValueFormat report from docker build:
 miscellaneous

---
 .../host-x86_64/dist-android/Dockerfile       |  7 +++---
 .../dist-loongarch64-linux/Dockerfile         |  7 +++---
 .../dist-loongarch64-musl/Dockerfile          |  7 +++---
 .../host-x86_64/dist-riscv64-linux/Dockerfile |  4 ++--
 .../host-x86_64/dist-s390x-linux/Dockerfile   |  4 ++--
 .../dist-sparcv9-solaris/Dockerfile           |  4 ++--
 .../host-x86_64/x86_64-fuchsia/Dockerfile     | 23 ++++++++-----------
 .../x86_64-rust-for-linux/Dockerfile          |  4 ++--
 8 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/src/ci/docker/host-x86_64/dist-android/Dockerfile b/src/ci/docker/host-x86_64/dist-android/Dockerfile
index 7b73326e3590..25565564e8da 100644
--- a/src/ci/docker/host-x86_64/dist-android/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-android/Dockerfile
@@ -16,15 +16,14 @@ ENV TARGETS=$TARGETS,i686-linux-android
 ENV TARGETS=$TARGETS,aarch64-linux-android
 ENV TARGETS=$TARGETS,x86_64-linux-android
 
-ENV RUST_CONFIGURE_ARGS \
-      --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
       --enable-profiler \
       --android-ndk=/android/ndk/ \
-      --disable-docs
+      --disable-docs"
 
 ENV PATH=$PATH:/android/ndk/toolchains/llvm/prebuilt/linux-x86_64/bin
 
-ENV SCRIPT python3 ../x.py dist --host='' --target $TARGETS
+ENV SCRIPT="python3 ../x.py dist --host= --target $TARGETS"
 
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
index 96acc5e97e94..3ee8cb9ed7e8 100644
--- a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
@@ -45,14 +45,13 @@ ENV TARGETS=$HOSTS
 ENV TARGETS=$TARGETS,loongarch64-unknown-none
 ENV TARGETS=$TARGETS,loongarch64-unknown-none-softfloat
 
-ENV RUST_CONFIGURE_ARGS \
-      --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
       --enable-full-tools \
       --enable-profiler \
       --enable-sanitizers \
       --disable-docs \
       --set rust.jemalloc \
       --set rust.lto=thin \
-      --set rust.codegen-units=1
+      --set rust.codegen-units=1"
 
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $TARGETS
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $TARGETS"
diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-musl/Dockerfile b/src/ci/docker/host-x86_64/dist-loongarch64-musl/Dockerfile
index 44efc1089017..54c1869a2a04 100644
--- a/src/ci/docker/host-x86_64/dist-loongarch64-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-loongarch64-musl/Dockerfile
@@ -27,8 +27,7 @@ ENV CC_loongarch64_unknown_linux_musl=loongarch64-unknown-linux-musl-gcc \
 
 ENV HOSTS=loongarch64-unknown-linux-musl
 
-ENV RUST_CONFIGURE_ARGS \
-      --enable-extended \
+ENV RUST_CONFIGURE_ARGS="--enable-extended \
       --enable-full-tools \
       --enable-profiler \
       --enable-sanitizers \
@@ -37,6 +36,6 @@ ENV RUST_CONFIGURE_ARGS \
       --set rust.lto=thin \
       --set rust.codegen-units=1 \
       --set target.loongarch64-unknown-linux-musl.crt-static=false \
-      --musl-root-loongarch64=/x-tools/loongarch64-unknown-linux-musl/loongarch64-unknown-linux-musl/sysroot/usr
+      --musl-root-loongarch64=/x-tools/loongarch64-unknown-linux-musl/loongarch64-unknown-linux-musl/sysroot/usr"
 
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
index 4a66564a90ac..3080220c837e 100644
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
@@ -30,5 +30,5 @@ ENV CC_riscv64gc_unknown_linux_gnu=riscv64-unknown-linux-gnu-gcc \
 ENV HOSTS=riscv64gc-unknown-linux-gnu
 ENV TARGETS=riscv64gc-unknown-linux-gnu,riscv64a23-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --enable-profiler --disable-docs
-ENV SCRIPT python3 ../x.py dist --target $TARGETS --host $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --enable-profiler --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --target $TARGETS --host $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-s390x-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-s390x-linux/Dockerfile
index de776911d628..413249e02e87 100644
--- a/src/ci/docker/host-x86_64/dist-s390x-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-s390x-linux/Dockerfile
@@ -26,5 +26,5 @@ ENV \
 
 ENV HOSTS=s390x-unknown-linux-gnu
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --enable-lld --enable-sanitizers --enable-profiler --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --enable-lld --enable-sanitizers --enable-profiler --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/dist-sparcv9-solaris/Dockerfile b/src/ci/docker/host-x86_64/dist-sparcv9-solaris/Dockerfile
index f7852c6364dc..ffe28fca1165 100644
--- a/src/ci/docker/host-x86_64/dist-sparcv9-solaris/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-sparcv9-solaris/Dockerfile
@@ -32,5 +32,5 @@ ENV \
 
 ENV HOSTS=sparcv9-sun-solaris
 
-ENV RUST_CONFIGURE_ARGS --enable-extended --disable-docs
-ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS
+ENV RUST_CONFIGURE_ARGS="--enable-extended --disable-docs"
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"
diff --git a/src/ci/docker/host-x86_64/x86_64-fuchsia/Dockerfile b/src/ci/docker/host-x86_64/x86_64-fuchsia/Dockerfile
index 0cae83a85b3a..ccb7841d83ac 100644
--- a/src/ci/docker/host-x86_64/x86_64-fuchsia/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-fuchsia/Dockerfile
@@ -38,13 +38,12 @@ COPY scripts/shared.sh /tmp/
 COPY scripts/build-fuchsia-toolchain.sh /tmp/
 RUN /tmp/build-fuchsia-toolchain.sh
 
-ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_AR /usr/local/bin/llvm-ar
-ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_RUSTFLAGS \
-  -C panic=abort \
+ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_AR="/usr/local/bin/llvm-ar"
+ENV CARGO_TARGET_X86_64_UNKNOWN_FUCHSIA_RUSTFLAGS="-C panic=abort \
   -C force-unwind-tables=yes \
   -C link-arg=--sysroot=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/sysroot \
   -Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/sysroot/lib \
-  -Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/lib
+  -Lnative=/usr/local/core-linux-amd64-fuchsia-sdk/arch/x64/lib"
 
 ENV TARGETS=x86_64-unknown-fuchsia
 ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnu
@@ -52,17 +51,16 @@ ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnu
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_INSTALL_DIR /checkout/obj/install
+ENV RUST_INSTALL_DIR="/checkout/obj/install"
 RUN mkdir -p $RUST_INSTALL_DIR/etc
 
 # Fuchsia only supports LLVM.
-ENV CODEGEN_BACKENDS llvm
+ENV CODEGEN_BACKENDS="llvm"
 
 # download-rustc is not allowed for `x install`
-ENV NO_DOWNLOAD_CI_RUSTC 1
+ENV NO_DOWNLOAD_CI_RUSTC="1"
 
-ENV RUST_CONFIGURE_ARGS \
-  --prefix=$RUST_INSTALL_DIR \
+ENV RUST_CONFIGURE_ARGS="--prefix=$RUST_INSTALL_DIR \
   --sysconfdir=etc \
   --enable-lld \
   --llvm-libunwind=in-tree \
@@ -72,8 +70,7 @@ ENV RUST_CONFIGURE_ARGS \
   --set target.x86_64-unknown-fuchsia.cxx=/usr/local/bin/clang++ \
   --set target.x86_64-unknown-fuchsia.ar=/usr/local/bin/llvm-ar \
   --set target.x86_64-unknown-fuchsia.ranlib=/usr/local/bin/llvm-ranlib \
-  --set target.x86_64-unknown-fuchsia.linker=/usr/local/bin/ld.lld
+  --set target.x86_64-unknown-fuchsia.linker=/usr/local/bin/ld.lld"
 
-ENV SCRIPT \
-    python3 ../x.py install --target $TARGETS compiler/rustc library/std clippy && \
-    bash ../src/ci/docker/host-x86_64/x86_64-fuchsia/build-fuchsia.sh
+ENV SCRIPT="python3 ../x.py install --target $TARGETS compiler/rustc library/std clippy && \
+    bash ../src/ci/docker/host-x86_64/x86_64-fuchsia/build-fuchsia.sh"
diff --git a/src/ci/docker/host-x86_64/x86_64-rust-for-linux/Dockerfile b/src/ci/docker/host-x86_64/x86_64-rust-for-linux/Dockerfile
index 97298519cf20..28a51ca2d685 100644
--- a/src/ci/docker/host-x86_64/x86_64-rust-for-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-rust-for-linux/Dockerfile
@@ -34,7 +34,7 @@ RUN sh /scripts/sccache.sh
 # RfL needs access to cland, lld and llvm tools
 ENV PATH="${PATH}:/usr/lib/llvm-15/bin"
 
-ENV RUST_CONFIGURE_ARGS --build=x86_64-unknown-linux-gnu
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu"
 
 COPY /scripts/rfl-build.sh /tmp/rfl-build.sh
-ENV SCRIPT bash /tmp/rfl-build.sh
+ENV SCRIPT="bash /tmp/rfl-build.sh"

From 80fa2b5621fe14d496df35faebba1dcb159ea33e Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 7 Mar 2026 16:31:36 +0800
Subject: [PATCH 0184/1059] feat: offer on let-expr for inline_local_variable

Example
---
```rust
fn f() {
    if true
        && let xyz = 0
    {
        xyz$0;
    }
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
fn f() {
    if true
    {
        0;
    }
}
```
---
 .../src/handlers/inline_local_variable.rs     | 146 ++++++++++++++++--
 1 file changed, 133 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_local_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_local_variable.rs
index 5d4bdc6ec76c..f55ef4229e58 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_local_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_local_variable.rs
@@ -1,3 +1,4 @@
+use either::{Either, for_both};
 use hir::{PathResolution, Semantics};
 use ide_db::{
     EditionedFileId, RootDatabase,
@@ -5,8 +6,9 @@
     search::{FileReference, FileReferenceNode, UsageSearchResult},
 };
 use syntax::{
-    SyntaxElement, TextRange,
+    Direction, TextRange,
     ast::{self, AstNode, AstToken, HasName, syntax_factory::SyntaxFactory},
+    syntax_editor::{Element, SyntaxEditor},
 };
 
 use crate::{
@@ -36,12 +38,15 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext<'_>)
     let InlineData { let_stmt, delete_let, references, target } =
         if let Some(path_expr) = ctx.find_node_at_offset::<ast::PathExpr>() {
             inline_usage(&ctx.sema, path_expr, range, file_id)
-        } else if let Some(let_stmt) = ctx.find_node_at_offset::<ast::LetStmt>() {
+        } else if let Some(let_stmt) = ctx.find_node_at_offset() {
             inline_let(&ctx.sema, let_stmt, range, file_id)
         } else {
             None
         }?;
-    let initializer_expr = let_stmt.initializer()?;
+    let initializer_expr = match &let_stmt {
+        either::Either::Left(it) => it.initializer()?,
+        either::Either::Right(it) => it.expr()?,
+    };
 
     let wrap_in_parens = references
         .into_iter()
@@ -81,13 +86,15 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext<'_>)
             let mut editor = builder.make_editor(&target);
             if delete_let {
                 editor.delete(let_stmt.syntax());
-                if let Some(whitespace) = let_stmt
-                    .syntax()
-                    .next_sibling_or_token()
-                    .and_then(SyntaxElement::into_token)
-                    .and_then(ast::Whitespace::cast)
+
+                if let Some(bin_expr) = let_stmt.syntax().parent().and_then(ast::BinExpr::cast)
+                    && let Some(op_token) = bin_expr.op_token()
                 {
-                    editor.delete(whitespace.syntax());
+                    editor.delete(&op_token);
+                    remove_whitespace(op_token, Direction::Prev, &mut editor);
+                    remove_whitespace(let_stmt.syntax(), Direction::Prev, &mut editor);
+                } else {
+                    remove_whitespace(let_stmt.syntax(), Direction::Next, &mut editor);
                 }
             }
 
@@ -116,7 +123,7 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext<'_>)
 }
 
 struct InlineData {
-    let_stmt: ast::LetStmt,
+    let_stmt: Either<ast::LetStmt, ast::LetExpr>,
     delete_let: bool,
     target: ast::NameOrNameRef,
     references: Vec<FileReference>,
@@ -124,11 +131,11 @@ struct InlineData {
 
 fn inline_let(
     sema: &Semantics<'_, RootDatabase>,
-    let_stmt: ast::LetStmt,
+    let_stmt: Either<ast::LetStmt, ast::LetExpr>,
     range: TextRange,
     file_id: EditionedFileId,
 ) -> Option<InlineData> {
-    let bind_pat = match let_stmt.pat()? {
+    let bind_pat = match for_both!(&let_stmt, it => it.pat())? {
         ast::Pat::IdentPat(pat) => pat,
         _ => return None,
     };
@@ -187,7 +194,7 @@ fn inline_usage(
 
     let bind_pat = source.as_ident_pat()?;
 
-    let let_stmt = ast::LetStmt::cast(bind_pat.syntax().parent()?)?;
+    let let_stmt = AstNode::cast(bind_pat.syntax().parent()?)?;
 
     let UsageSearchResult { mut references } = Definition::Local(local).usages(sema).all();
     let mut references = references.remove(&file_id)?;
@@ -197,6 +204,23 @@ fn inline_usage(
     Some(InlineData { let_stmt, delete_let, target: ast::NameOrNameRef::NameRef(name), references })
 }
 
+fn remove_whitespace(elem: impl Element, dir: Direction, editor: &mut SyntaxEditor) {
+    let token = match elem.syntax_element() {
+        syntax::NodeOrToken::Node(node) => match dir {
+            Direction::Next => node.last_token(),
+            Direction::Prev => node.first_token(),
+        },
+        syntax::NodeOrToken::Token(t) => Some(t),
+    };
+    let next_token = match dir {
+        Direction::Next => token.and_then(|it| it.next_token()),
+        Direction::Prev => token.and_then(|it| it.prev_token()),
+    };
+    if let Some(whitespace) = next_token.and_then(ast::Whitespace::cast) {
+        editor.delete(whitespace.syntax());
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -404,6 +428,38 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn test_inline_let_expr() {
+        check_assist(
+            inline_local_variable,
+            r"
+fn bar(a: usize) {}
+fn foo() {
+    if let a$0 = 1
+        && true
+    {
+        a + 1;
+        if a > 10 {}
+        while a > 10 {}
+        let b = a * 10;
+        bar(a);
+    }
+}",
+            r"
+fn bar(a: usize) {}
+fn foo() {
+    if true
+    {
+        1 + 1;
+        if 1 > 10 {}
+        while 1 > 10 {}
+        let b = 1 * 10;
+        bar(1);
+    }
+}",
+        );
+    }
+
     #[test]
     fn test_not_inline_mut_variable() {
         cov_mark::check!(test_not_inline_mut_variable);
@@ -816,6 +872,70 @@ fn f() {
         );
     }
 
+    #[test]
+    fn let_expr_works_on_local_usage() {
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    if let xyz = 0
+        && true
+    {
+        xyz$0;
+    }
+}
+"#,
+            r#"
+fn f() {
+    if true
+    {
+        0;
+    }
+}
+"#,
+        );
+
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    if let xyz = true
+        && xyz$0
+    {
+    }
+}
+"#,
+            r#"
+fn f() {
+    if true
+    {
+    }
+}
+"#,
+        );
+
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    if true
+        && let xyz = 0
+    {
+        xyz$0;
+    }
+}
+"#,
+            r#"
+fn f() {
+    if true
+    {
+        0;
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn does_not_remove_let_when_multiple_usages() {
         check_assist(

From 7cb6912f466bf113336c27b6ee4c73165f265105 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 7 Mar 2026 21:15:11 +1100
Subject: [PATCH 0185/1059] Remove a flaky `got_timeout` assert from two
 channel tests

In CI, the receiver thread can be descheduled for a surprisingly long time, so
there's no guarantee that a timeout actually occurs.
---
 library/std/tests/sync/mpmc.rs | 3 ---
 library/std/tests/sync/mpsc.rs | 3 ---
 2 files changed, 6 deletions(-)

diff --git a/library/std/tests/sync/mpmc.rs b/library/std/tests/sync/mpmc.rs
index bf80ab96a88b..db221ff15890 100644
--- a/library/std/tests/sync/mpmc.rs
+++ b/library/std/tests/sync/mpmc.rs
@@ -475,7 +475,6 @@ fn stress_recv_timeout_two_threads() {
     });
 
     let mut recv_count = 0;
-    let mut got_timeout = false;
     loop {
         match rx.recv_timeout(timeout) {
             Ok(n) => {
@@ -483,7 +482,6 @@ fn stress_recv_timeout_two_threads() {
                 recv_count += 1;
             }
             Err(RecvTimeoutError::Timeout) => {
-                got_timeout = true;
                 continue;
             }
             Err(RecvTimeoutError::Disconnected) => break,
@@ -491,7 +489,6 @@ fn stress_recv_timeout_two_threads() {
     }
 
     assert_eq!(recv_count, stress);
-    assert!(got_timeout);
 }
 
 #[test]
diff --git a/library/std/tests/sync/mpsc.rs b/library/std/tests/sync/mpsc.rs
index 9de4a71987b8..4dc4b955da7c 100644
--- a/library/std/tests/sync/mpsc.rs
+++ b/library/std/tests/sync/mpsc.rs
@@ -438,7 +438,6 @@ fn stress_recv_timeout_two_threads() {
     });
 
     let mut recv_count = 0;
-    let mut got_timeout = false;
     loop {
         match rx.recv_timeout(timeout) {
             Ok(n) => {
@@ -446,7 +445,6 @@ fn stress_recv_timeout_two_threads() {
                 recv_count += 1;
             }
             Err(RecvTimeoutError::Timeout) => {
-                got_timeout = true;
                 continue;
             }
             Err(RecvTimeoutError::Disconnected) => break,
@@ -454,7 +452,6 @@ fn stress_recv_timeout_two_threads() {
     }
 
     assert_eq!(recv_count, stress);
-    assert!(got_timeout);
 }
 
 #[test]

From 946d1189102f748c36fef3b7f53dd5dad3832294 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 4 Mar 2026 23:10:02 +0800
Subject: [PATCH 0186/1059] ci: Bump ct-ng to 1.28.0

---
 .../host-x86_64/dist-riscv64-linux/Dockerfile |   1 -
 .../gcc/8.5.0/0001-divdi3-div-zero.patch      |  37 ------
 .../gcc/8.5.0/0002-hidden-jump-target.patch   | 117 ------------------
 .../glibc/2.29/0001-hidden-jump-target.patch  |  58 ---------
 .../riscv64-unknown-linux-gnu.defconfig       |   2 -
 src/ci/docker/scripts/crosstool-ng.sh         |   2 +-
 6 files changed, 1 insertion(+), 216 deletions(-)
 delete mode 100644 src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0001-divdi3-div-zero.patch
 delete mode 100644 src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
 delete mode 100644 src/ci/docker/host-x86_64/dist-riscv64-linux/patches/glibc/2.29/0001-hidden-jump-target.patch

diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
index 4a66564a90ac..c0084a7cd236 100644
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-riscv64-linux/Dockerfile
@@ -11,7 +11,6 @@ RUN sh /scripts/rustbuild-setup.sh
 WORKDIR /tmp
 
 COPY scripts/crosstool-ng-build.sh /scripts/
-COPY host-x86_64/dist-riscv64-linux/patches/ /tmp/patches/
 COPY host-x86_64/dist-riscv64-linux/riscv64-unknown-linux-gnu.defconfig /tmp/crosstool.defconfig
 RUN /scripts/crosstool-ng-build.sh
 
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0001-divdi3-div-zero.patch b/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0001-divdi3-div-zero.patch
deleted file mode 100644
index f688eaf8029e..000000000000
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0001-divdi3-div-zero.patch
+++ /dev/null
@@ -1,37 +0,0 @@
-From 4013baf99c38f7bca06a51f8301e8fb195ccfa33 Mon Sep 17 00:00:00 2001
-From: Jim Wilson <jimw@sifive.com>
-Date: Tue, 2 Jun 2020 11:19:39 -0700
-Subject: [PATCH] RISC-V: Make __divdi3 handle div by zero same as hardware.
-
-The ISA manual specifies that divide by zero always returns -1 as the result.
-We were failing to do that when the dividend was negative.
-
-Original patch from Virginie Moser.
-
-	libgcc/
-	* config/riscv/div.S (__divdi3): For negative arguments, change bgez
-	to bgtz.
----
- libgcc/config/riscv/div.S | 8 +++++---
- 1 file changed, 5 insertions(+), 3 deletions(-)
-
-diff --git a/libgcc/config/riscv/div.S b/libgcc/config/riscv/div.S
-index 151f8e273ac77..17234324c1e41 100644
---- a/libgcc/config/riscv/div.S
-+++ b/libgcc/config/riscv/div.S
-@@ -107,10 +107,12 @@ FUNC_END (__umoddi3)
-   /* Handle negative arguments to __divdi3.  */
- .L10:
-   neg   a0, a0
--  bgez  a1, .L12      /* Compute __udivdi3(-a0, a1), then negate the result.  */
-+  /* Zero is handled as a negative so that the result will not be inverted.  */
-+  bgtz  a1, .L12     /* Compute __udivdi3(-a0, a1), then negate the result.  */
-+
-   neg   a1, a1
--  j     __udivdi3     /* Compute __udivdi3(-a0, -a1).  */
--.L11:                 /* Compute __udivdi3(a0, -a1), then negate the result.  */
-+  j     __udivdi3    /* Compute __udivdi3(-a0, -a1).  */
-+.L11:                /* Compute __udivdi3(a0, -a1), then negate the result.  */
-   neg   a1, a1
- .L12:
-   move  t0, ra
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch b/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
deleted file mode 100644
index 1ae0ecf6cb5e..000000000000
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/gcc/8.5.0/0002-hidden-jump-target.patch
+++ /dev/null
@@ -1,117 +0,0 @@
-From 45116f342057b7facecd3d05c2091ce3a77eda59 Mon Sep 17 00:00:00 2001
-From: Nelson Chu <nelson.chu@sifive.com>
-Date: Mon, 29 Nov 2021 04:48:20 -0800
-Subject: [PATCH] RISC-V: jal cannot refer to a default visibility symbol for
- shared object.
-
-This is the original binutils bugzilla report,
-https://sourceware.org/bugzilla/show_bug.cgi?id=28509
-
-And this is the first version of the proposed binutils patch,
-https://sourceware.org/pipermail/binutils/2021-November/118398.html
-
-After applying the binutils patch, I get the unexpected error when
-building libgcc,
-
-/scratch/nelsonc/riscv-gnu-toolchain/riscv-gcc/libgcc/config/riscv/div.S:42:
-/scratch/nelsonc/build-upstream/rv64gc-linux/build-install/riscv64-unknown-linux-gnu/bin/ld: relocation R_RISCV_JAL against `__udivdi3' which may bind externally can not be used when making a shared object; recompile with -fPIC
-
-Therefore, this patch add an extra hidden alias symbol for __udivdi3, and
-then use HIDDEN_JUMPTARGET to target a non-preemptible symbol instead.
-The solution is similar to glibc as follows,
-https://sourceware.org/git/?p=glibc.git;a=commit;h=68389203832ab39dd0dbaabbc4059e7fff51c29b
-
-libgcc/ChangeLog:
-
-	* config/riscv/div.S: Add the hidden alias symbol for __udivdi3, and
-	then use HIDDEN_JUMPTARGET to target it since it is non-preemptible.
-	* config/riscv/riscv-asm.h: Added new macros HIDDEN_JUMPTARGET and
-	HIDDEN_DEF.
----
- libgcc/config/riscv/div.S       | 15 ++++++++-------
- libgcc/config/riscv/riscv-asm.h |  6 ++++++
- 2 files changed, 14 insertions(+), 7 deletions(-)
-
-diff --git a/libgcc/config/riscv/div.S b/libgcc/config/riscv/div.S
-index c9bd7879c1e36..723c3b82e48c6 100644
---- a/libgcc/config/riscv/div.S
-+++ b/libgcc/config/riscv/div.S
-@@ -40,7 +40,7 @@ FUNC_BEGIN (__udivsi3)
-   sll    a0, a0, 32
-   sll    a1, a1, 32
-   move   t0, ra
--  jal    __udivdi3
-+  jal    HIDDEN_JUMPTARGET(__udivdi3)
-   sext.w a0, a0
-   jr     t0
- FUNC_END (__udivsi3)
-@@ -52,7 +52,7 @@ FUNC_BEGIN (__umodsi3)
-   srl    a0, a0, 32
-   srl    a1, a1, 32
-   move   t0, ra
--  jal    __udivdi3
-+  jal    HIDDEN_JUMPTARGET(__udivdi3)
-   sext.w a0, a1
-   jr     t0
- FUNC_END (__umodsi3)
-@@ -95,11 +95,12 @@ FUNC_BEGIN (__udivdi3)
- .L5:
-   ret
- FUNC_END (__udivdi3)
-+HIDDEN_DEF (__udivdi3)
- 
- FUNC_BEGIN (__umoddi3)
-   /* Call __udivdi3(a0, a1), then return the remainder, which is in a1.  */
-   move  t0, ra
--  jal   __udivdi3
-+  jal   HIDDEN_JUMPTARGET(__udivdi3)
-   move  a0, a1
-   jr    t0
- FUNC_END (__umoddi3)
-@@ -111,12 +112,12 @@ FUNC_END (__umoddi3)
-   bgtz  a1, .L12     /* Compute __udivdi3(-a0, a1), then negate the result.  */
- 
-   neg   a1, a1
--  j     __udivdi3    /* Compute __udivdi3(-a0, -a1).  */
-+  j     HIDDEN_JUMPTARGET(__udivdi3)     /* Compute __udivdi3(-a0, -a1).  */
- .L11:                /* Compute __udivdi3(a0, -a1), then negate the result.  */
-   neg   a1, a1
- .L12:
-   move  t0, ra
--  jal   __udivdi3
-+  jal   HIDDEN_JUMPTARGET(__udivdi3)
-   neg   a0, a0
-   jr    t0
- FUNC_END (__divdi3)
-@@ -126,7 +127,7 @@ FUNC_BEGIN (__moddi3)
-   bltz   a1, .L31
-   bltz   a0, .L32
- .L30:
--  jal    __udivdi3    /* The dividend is not negative.  */
-+  jal    HIDDEN_JUMPTARGET(__udivdi3)    /* The dividend is not negative.  */
-   move   a0, a1
-   jr     t0
- .L31:
-@@ -134,7 +135,7 @@ FUNC_BEGIN (__moddi3)
-   bgez   a0, .L30
- .L32:
-   neg    a0, a0
--  jal    __udivdi3    /* The dividend is hella negative.  */
-+  jal    HIDDEN_JUMPTARGET(__udivdi3)    /* The dividend is hella negative.  */
-   neg    a0, a1
-   jr     t0
- FUNC_END (__moddi3)
-diff --git a/libgcc/config/riscv/riscv-asm.h b/libgcc/config/riscv/riscv-asm.h
-index 8550707a4a26a..96dd85b0df2e5 100644
---- a/libgcc/config/riscv/riscv-asm.h
-+++ b/libgcc/config/riscv/riscv-asm.h
-@@ -33,3 +33,9 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
- #define FUNC_ALIAS(X,Y)		\
- 	.globl X;		\
- 	X = Y
-+
-+#define CONCAT1(a, b)		CONCAT2(a, b)
-+#define CONCAT2(a, b)		a ## b
-+#define HIDDEN_JUMPTARGET(X)	CONCAT1(__hidden_, X)
-+#define HIDDEN_DEF(X)		FUNC_ALIAS(HIDDEN_JUMPTARGET(X), X);     \
-+				.hidden HIDDEN_JUMPTARGET(X)
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/glibc/2.29/0001-hidden-jump-target.patch b/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/glibc/2.29/0001-hidden-jump-target.patch
deleted file mode 100644
index d267b961d347..000000000000
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/patches/glibc/2.29/0001-hidden-jump-target.patch
+++ /dev/null
@@ -1,58 +0,0 @@
-From 68389203832ab39dd0dbaabbc4059e7fff51c29b Mon Sep 17 00:00:00 2001
-From: Fangrui Song <maskray@google.com>
-Date: Thu, 28 Oct 2021 11:39:49 -0700
-Subject: [PATCH] riscv: Fix incorrect jal with HIDDEN_JUMPTARGET
-
-A non-local STV_DEFAULT defined symbol is by default preemptible in a
-shared object. j/jal cannot target a preemptible symbol. On other
-architectures, such a jump instruction either causes PLT [BZ #18822], or
-if short-ranged, sometimes rejected by the linker (but not by GNU ld's
-riscv port [ld PR/28509]).
-
-Use HIDDEN_JUMPTARGET to target a non-preemptible symbol instead.
-
-With this patch, ld.so and libc.so can be linked with LLD if source
-files are compiled/assembled with -mno-relax/-Wa,-mno-relax.
-
-Acked-by: Palmer Dabbelt <palmer@dabbelt.com>
-Reviewed-by: Adhemerval Zanella  <adhemerval.zanella@linaro.org>
----
- sysdeps/riscv/setjmp.S                     | 2 +-
- sysdeps/unix/sysv/linux/riscv/setcontext.S | 5 +++--
- 2 files changed, 4 insertions(+), 3 deletions(-)
-
-diff --git a/sysdeps/riscv/setjmp.S b/sysdeps/riscv/setjmp.S
-index 0b92016b311..bec7ff80f49 100644
---- a/sysdeps/riscv/setjmp.S
-+++ b/sysdeps/riscv/setjmp.S
-@@ -21,7 +21,7 @@
- 
- ENTRY (_setjmp)
-   li	a1, 0
--  j	__sigsetjmp
-+  j	HIDDEN_JUMPTARGET (__sigsetjmp)
- END (_setjmp)
- ENTRY (setjmp)
-   li	a1, 1
-diff --git a/sysdeps/unix/sysv/linux/riscv/setcontext.S b/sysdeps/unix/sysv/linux/riscv/setcontext.S
-index 9510518750a..e44a68aad47 100644
---- a/sysdeps/unix/sysv/linux/riscv/setcontext.S
-+++ b/sysdeps/unix/sysv/linux/riscv/setcontext.S
-@@ -95,6 +95,7 @@ LEAF (__setcontext)
- 99:	j	__syscall_error
- 
- END (__setcontext)
-+libc_hidden_def (__setcontext)
- weak_alias (__setcontext, setcontext)
- 
- LEAF (__start_context)
-@@ -108,7 +109,7 @@ LEAF (__start_context)
- 	/* Invoke subsequent context if present, else exit(0).  */
- 	mv	a0, s2
- 	beqz	s2, 1f
--	jal	__setcontext
--1:	j	exit
-+	jal	HIDDEN_JUMPTARGET (__setcontext)
-+1:	j	HIDDEN_JUMPTARGET (exit)
- 
- END (__start_context)
diff --git a/src/ci/docker/host-x86_64/dist-riscv64-linux/riscv64-unknown-linux-gnu.defconfig b/src/ci/docker/host-x86_64/dist-riscv64-linux/riscv64-unknown-linux-gnu.defconfig
index f7c93a9d5fc8..75eb356bc958 100644
--- a/src/ci/docker/host-x86_64/dist-riscv64-linux/riscv64-unknown-linux-gnu.defconfig
+++ b/src/ci/docker/host-x86_64/dist-riscv64-linux/riscv64-unknown-linux-gnu.defconfig
@@ -3,8 +3,6 @@ CT_EXPERIMENTAL=y
 CT_PREFIX_DIR="/x-tools/${CT_TARGET}"
 CT_USE_MIRROR=y
 CT_MIRROR_BASE_URL="https://ci-mirrors.rust-lang.org/rustc"
-CT_PATCH_BUNDLED_LOCAL=y
-CT_LOCAL_PATCH_DIR="/tmp/patches"
 CT_ARCH_RISCV=y
 # CT_DEMULTILIB is not set
 CT_ARCH_USE_MMU=y
diff --git a/src/ci/docker/scripts/crosstool-ng.sh b/src/ci/docker/scripts/crosstool-ng.sh
index eee912b0d750..434c662c99c8 100644
--- a/src/ci/docker/scripts/crosstool-ng.sh
+++ b/src/ci/docker/scripts/crosstool-ng.sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 set -ex
 
-CT_NG=1.27.0
+CT_NG=1.28.0
 
 url="https://github.com/crosstool-ng/crosstool-ng/archive/crosstool-ng-$CT_NG.tar.gz"
 curl -Lf $url | tar xzf -

From 0d2e488655fc8be7afa370e8392e7d8b7e49f59e Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 4 Mar 2026 23:10:25 +0800
Subject: [PATCH 0187/1059] ci: loongarch64-linux: Bump binutils to 2.45 and
 gcc to 15.2

---
 src/ci/docker/README.md                                   | 8 ++++----
 .../loongarch64-unknown-linux-gnu.defconfig               | 4 ++--
 .../loongarch64-unknown-linux-musl.defconfig              | 4 ++--
 src/doc/rustc/src/platform-support/loongarch-linux.md     | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index 59cea7aa79a5..b6d01528d8c3 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -261,9 +261,9 @@ For targets: `loongarch64-unknown-linux-gnu`
 - Target options > Bitness = 64-bit
 - Operating System > Target OS = linux
 - Operating System > Linux kernel version = 5.19.16
-- Binary utilities > Version of binutils = 2.42
+- Binary utilities > Version of binutils = 2.45
 - C-library > glibc version = 2.36
-- C compiler > gcc version = 14.2.0
+- C compiler > gcc version = 15.2.0
 - C compiler > C++ = ENABLE -- to cross compile LLVM
 
 ### `loongarch64-unknown-linux-musl.defconfig`
@@ -277,9 +277,9 @@ For targets: `loongarch64-unknown-linux-musl`
 - Target options > Bitness = 64-bit
 - Operating System > Target OS = linux
 - Operating System > Linux kernel version = 5.19.16
-- Binary utilities > Version of binutils = 2.42
+- Binary utilities > Version of binutils = 2.45
 - C-library > musl version = 1.2.5
-- C compiler > gcc version = 14.2.0
+- C compiler > gcc version = 15.2.0
 - C compiler > C++ = ENABLE -- to cross compile LLVM
 
 ### `mips-linux-gnu.defconfig`
diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-linux/loongarch64-unknown-linux-gnu.defconfig b/src/ci/docker/host-x86_64/dist-loongarch64-linux/loongarch64-unknown-linux-gnu.defconfig
index bb1d2d1f8038..9ff9791c0b2c 100644
--- a/src/ci/docker/host-x86_64/dist-loongarch64-linux/loongarch64-unknown-linux-gnu.defconfig
+++ b/src/ci/docker/host-x86_64/dist-loongarch64-linux/loongarch64-unknown-linux-gnu.defconfig
@@ -12,7 +12,7 @@ CT_TARGET_LDFLAGS="-mcmodel=medium"
 CT_KERNEL_LINUX=y
 CT_LINUX_V_5_19=y
 CT_GLIBC_V_2_36=y
-CT_BINUTILS_V_2_42=y
-CT_GCC_V_14=y
+CT_BINUTILS_V_2_45=y
+CT_GCC_V_15=y
 CT_CC_GCC_ENABLE_DEFAULT_PIE=y
 CT_CC_LANG_CXX=y
diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-musl/loongarch64-unknown-linux-musl.defconfig b/src/ci/docker/host-x86_64/dist-loongarch64-musl/loongarch64-unknown-linux-musl.defconfig
index aa1696e131d4..8c1562744fb5 100644
--- a/src/ci/docker/host-x86_64/dist-loongarch64-musl/loongarch64-unknown-linux-musl.defconfig
+++ b/src/ci/docker/host-x86_64/dist-loongarch64-musl/loongarch64-unknown-linux-musl.defconfig
@@ -13,8 +13,8 @@ CT_KERNEL_LINUX=y
 CT_LINUX_V_5_19=y
 CT_LIBC_MUSL=y
 CT_MUSL_V_1_2_5=y
-CT_BINUTILS_V_2_42=y
-CT_GCC_V_14=y
+CT_BINUTILS_V_2_45=y
+CT_GCC_V_15=y
 CT_CC_GCC_ENABLE_DEFAULT_PIE=y
 CT_CC_LANG_CXX=y
 CT_GETTEXT_NEEDED=y
diff --git a/src/doc/rustc/src/platform-support/loongarch-linux.md b/src/doc/rustc/src/platform-support/loongarch-linux.md
index a923218282c1..7817ce6138a0 100644
--- a/src/doc/rustc/src/platform-support/loongarch-linux.md
+++ b/src/doc/rustc/src/platform-support/loongarch-linux.md
@@ -44,8 +44,8 @@ The targets require a reasonably up-to-date LoongArch toolchain on the host.
 Currently the following components are used by the Rust CI to build the target,
 and the versions can be seen as the minimum requirement:
 
-* GNU Binutils 2.42
-* GCC 14.x
+* GNU Binutils 2.45
+* GCC 15.x
 * glibc 2.36
 * linux-headers 5.19
 

From cd9cb3fb5eef0b48bc6ce22b542990a6f6bb05b3 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 4 Mar 2026 23:13:49 +0800
Subject: [PATCH 0188/1059] rustc_target: Enable link relaxation feature for
 LoongArch Linux targets

---
 .../src/spec/targets/loongarch64_unknown_linux_gnu.rs           | 2 +-
 .../src/spec/targets/loongarch64_unknown_linux_musl.rs          | 2 +-
 .../src/spec/targets/loongarch64_unknown_linux_ohos.rs          | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
index 255756b5b4f1..5936ea5e3c63 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
-            features: "+f,+d,+lsx".into(),
+            features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: "lp64d".into(),
             max_atomic_width: Some(64),
             supported_sanitizers: SanitizerSet::ADDRESS
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
index 74b0efd63e77..2951b34ca966 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
-            features: "+f,+d,+lsx".into(),
+            features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: "lp64d".into(),
             max_atomic_width: Some(64),
             crt_static_default: false,
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
index 222cf5c92c56..1dab4febb90f 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
-            features: "+f,+d,+lsx".into(),
+            features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: "lp64d".into(),
             max_atomic_width: Some(64),
             supported_sanitizers: SanitizerSet::ADDRESS

From 50db919f5d5e9ae336afb8a293ac18d494434653 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Fri, 27 Feb 2026 03:48:05 +0000
Subject: [PATCH 0189/1059] Change TODO in compiler to FIXME

---
 .../scripts/test_rustc_tests.sh               |  2 +-
 .../src/intrinsics/mod.rs                     |  8 +-
 .../.github/workflows/failures.yml            |  6 +-
 .../.github/workflows/m68k.yml                |  4 +-
 .../.github/workflows/stdarch.yml             |  4 +-
 .../build_system/src/prepare.rs               |  2 +-
 .../build_system/src/test.rs                  | 12 +--
 .../doc/debugging-libgccjit.md                |  2 +-
 compiler/rustc_codegen_gcc/doc/subtree.md     |  2 +-
 .../example/mini_core_hello_world.rs          |  2 +-
 compiler/rustc_codegen_gcc/src/abi.rs         |  4 +-
 compiler/rustc_codegen_gcc/src/allocator.rs   |  4 +-
 compiler/rustc_codegen_gcc/src/asm.rs         | 24 +++---
 compiler/rustc_codegen_gcc/src/attributes.rs  |  6 +-
 compiler/rustc_codegen_gcc/src/back/lto.rs    |  6 +-
 compiler/rustc_codegen_gcc/src/back/write.rs  |  8 +-
 compiler/rustc_codegen_gcc/src/base.rs        |  8 +-
 compiler/rustc_codegen_gcc/src/builder.rs     | 84 +++++++++----------
 compiler/rustc_codegen_gcc/src/callee.rs      |  4 +-
 compiler/rustc_codegen_gcc/src/common.rs      | 16 ++--
 compiler/rustc_codegen_gcc/src/consts.rs      | 14 ++--
 compiler/rustc_codegen_gcc/src/context.rs     | 26 +++---
 .../rustc_codegen_gcc/src/coverageinfo.rs     |  2 +-
 compiler/rustc_codegen_gcc/src/debuginfo.rs   | 12 +--
 compiler/rustc_codegen_gcc/src/declare.rs     | 18 ++--
 compiler/rustc_codegen_gcc/src/int.rs         | 32 +++----
 .../rustc_codegen_gcc/src/intrinsic/llvm.rs   |  4 +-
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    | 26 +++---
 .../rustc_codegen_gcc/src/intrinsic/simd.rs   | 36 ++++----
 compiler/rustc_codegen_gcc/src/lib.rs         | 12 +--
 compiler/rustc_codegen_gcc/src/mono_item.rs   |  8 +-
 compiler/rustc_codegen_gcc/src/type_.rs       | 10 +--
 compiler/rustc_codegen_gcc/src/type_of.rs     |  4 +-
 .../tests/lang_tests_common.rs                |  4 +-
 .../rustc_mir_build/src/check_unsafety.rs     |  4 +-
 compiler/rustc_session/src/parse.rs           |  2 +-
 36 files changed, 210 insertions(+), 212 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
index 4cad18f2a94f..8712b41c8f8f 100755
--- a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
+++ b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
@@ -175,7 +175,7 @@ rm -r tests/run-make/panic-abort-eh_frame # .eh_frame emitted with panic=abort
 
 # bugs in the test suite
 # ======================
-rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
+rm tests/ui/process/nofile-limit.rs # FIXME some AArch64 linking issue
 rm -r tests/ui/codegen/equal-pointers-unequal # make incorrect assumptions about the location of stack variables
 rm -r tests/incremental/extern_static/issue-49153.rs # assumes reference to undefined static gets optimized away
 
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index ab9a11305baa..c21453d84be0 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -356,10 +356,10 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::fmaf64 => ("fma", 3, fx.tcx.types.f64, types::F64),
         sym::fmaf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128),
         // FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
-        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f16
-        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f32
-        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f64
-        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f128
+        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f16
+        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f32
+        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f64
+        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f128
         sym::copysignf16 => ("copysignf16", 2, fx.tcx.types.f16, types::F16),
         sym::copysignf32 => ("copysignf", 2, fx.tcx.types.f32, types::F32),
         sym::copysignf64 => ("copysign", 2, fx.tcx.types.f64, types::F64),
diff --git a/compiler/rustc_codegen_gcc/.github/workflows/failures.yml b/compiler/rustc_codegen_gcc/.github/workflows/failures.yml
index aa4b4dc22c3e..a2a932893054 100644
--- a/compiler/rustc_codegen_gcc/.github/workflows/failures.yml
+++ b/compiler/rustc_codegen_gcc/.github/workflows/failures.yml
@@ -1,4 +1,4 @@
-# TODO: refactor to avoid duplication with the ci.yml file.
+# FIXME: refactor to avoid duplication with the ci.yml file.
 name: Failures
 
 on:
@@ -92,7 +92,7 @@ jobs:
       run: ./y.sh prepare
 
     - name: Run tests
-      # TODO: re-enable those tests for libgccjit 12.
+      # FIXME: re-enable those tests for libgccjit 12.
       if: matrix.libgccjit_version.gcc != 'libgccjit12.so'
       id: tests
       run: |
@@ -100,7 +100,7 @@ jobs:
         rg --text "test result" output_log >> $GITHUB_STEP_SUMMARY
 
     - name: Run failing ui pattern tests for ICE
-      # TODO: re-enable those tests for libgccjit 12.
+      # FIXME: re-enable those tests for libgccjit 12.
       if: matrix.libgccjit_version.gcc != 'libgccjit12.so'
       id: ui-tests
       run: |
diff --git a/compiler/rustc_codegen_gcc/.github/workflows/m68k.yml b/compiler/rustc_codegen_gcc/.github/workflows/m68k.yml
index 11bc88e67d2d..c36db18ed4aa 100644
--- a/compiler/rustc_codegen_gcc/.github/workflows/m68k.yml
+++ b/compiler/rustc_codegen_gcc/.github/workflows/m68k.yml
@@ -1,4 +1,4 @@
-# TODO: check if qemu-user-static-binfmt is needed (perhaps to run some tests since it probably calls exec).
+# FIXME: check if qemu-user-static-binfmt is needed (perhaps to run some tests since it probably calls exec).
 
 name: m68k CI
 
@@ -24,7 +24,7 @@ jobs:
       matrix:
         commands: [
           "--std-tests",
-          # TODO(antoyo): fix those on m68k.
+          # FIXME(antoyo): fix those on m68k.
           #"--test-libcore",
           #"--extended-rand-tests",
           #"--extended-regex-example-tests",
diff --git a/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml b/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
index c0a0e3344cc2..a58728573168 100644
--- a/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
+++ b/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
@@ -38,7 +38,7 @@ jobs:
     - name: Install packages
       run: sudo apt-get install ninja-build ripgrep
 
-    # TODO: remove when we have binutils version 2.43 in the repo.
+    # FIXME: remove when we have binutils version 2.43 in the repo.
     - name: Install more recent binutils
       run: |
         echo "deb http://archive.ubuntu.com/ubuntu plucky main universe" | sudo tee /etc/apt/sources.list.d/plucky-copies.list
@@ -94,7 +94,7 @@ jobs:
       if: ${{ matrix.cargo_runner }}
       run: |
         # FIXME: these tests fail when the sysroot is compiled with LTO because of a missing symbol in proc-macro.
-        # TODO: remove --skip test_tile_ when it's implemented.
+        # FIXME: remove --skip test_tile_ when it's implemented.
         STDARCH_TEST_SKIP_FUNCTION="xsave,xsaveopt,xsave64,xsaveopt64" STDARCH_TEST_EVERYTHING=1 CHANNEL=release CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="${{ matrix.cargo_runner }}" TARGET=x86_64-unknown-linux-gnu CG_RUSTFLAGS="-Ainternal_features" ./y.sh cargo test --manifest-path build/build_sysroot/sysroot_src/library/stdarch/Cargo.toml -- --skip rtm --skip tbm --skip sse4a --skip test_tile_
 
   # Summary job for the merge queue.
diff --git a/compiler/rustc_codegen_gcc/build_system/src/prepare.rs b/compiler/rustc_codegen_gcc/build_system/src/prepare.rs
index 1e97e8d93274..b62527f241fb 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/prepare.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/prepare.rs
@@ -148,7 +148,7 @@ fn prepare_libcore(
     Ok(())
 }
 
-// TODO: remove when we can ignore warnings in rustdoc tests.
+// FIXME: remove when we can ignore warnings in rustdoc tests.
 fn prepare_rand() -> Result<(), String> {
     // Apply patch for the rand crate.
     let file_path = "patches/crates/0001-Remove-deny-warnings.patch";
diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs
index 096f8c98376c..8189e6b39747 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/test.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs
@@ -285,7 +285,7 @@ fn build_sysroot(env: &Env, args: &TestArg) -> Result<(), String> {
     Ok(())
 }
 
-// TODO(GuillaumeGomez): when rewriting in Rust, refactor with the code in tests/lang_tests_common.rs if possible.
+// FIXME(GuillaumeGomez): when rewriting in Rust, refactor with the code in tests/lang_tests_common.rs if possible.
 fn maybe_run_command_in_vm(
     command: &[&dyn AsRef<OsStr>],
     env: &Env,
@@ -648,16 +648,16 @@ fn test_projects(env: &Env, args: &TestArg) -> Result<(), String> {
         "https://github.com/BurntSushi/memchr",
         "https://github.com/dtolnay/itoa",
         "https://github.com/rust-lang/cfg-if",
-        //"https://github.com/rust-lang-nursery/lazy-static.rs", // TODO: re-enable when the
+        //"https://github.com/rust-lang-nursery/lazy-static.rs", // FIXME: re-enable when the
         //failing test is fixed upstream.
         //"https://github.com/marshallpierce/rust-base64", // FIXME: one test is OOM-killed.
-        // TODO: ignore the base64 test that is OOM-killed.
+        // FIXME: ignore the base64 test that is OOM-killed.
         //"https://github.com/time-rs/time", // FIXME: one test fails (https://github.com/time-rs/time/issues/719).
         "https://github.com/rust-lang/log",
         "https://github.com/bitflags/bitflags",
         //"https://github.com/serde-rs/serde", // FIXME: one test fails.
-        //"https://github.com/rayon-rs/rayon", // TODO: very slow, only run on master?
-        //"https://github.com/rust-lang/cargo", // TODO: very slow, only run on master?
+        //"https://github.com/rayon-rs/rayon", // FIXME: very slow, only run on master?
+        //"https://github.com/rust-lang/cargo", // FIXME: very slow, only run on master?
     ];
 
     let mut env = env.clone();
@@ -699,7 +699,7 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
     println!("[TEST] libcore");
     let path = get_sysroot_dir().join("sysroot_src/library/coretests");
     let _ = remove_dir_all(path.join("target"));
-    // TODO(antoyo): run in release mode when we fix the failures.
+    // FIXME(antoyo): run in release mode when we fix the failures.
     run_cargo_command(&[&"test"], Some(&path), env, args)?;
     Ok(())
 }
diff --git a/compiler/rustc_codegen_gcc/doc/debugging-libgccjit.md b/compiler/rustc_codegen_gcc/doc/debugging-libgccjit.md
index be0ec83f7cdc..b2741b4134da 100644
--- a/compiler/rustc_codegen_gcc/doc/debugging-libgccjit.md
+++ b/compiler/rustc_codegen_gcc/doc/debugging-libgccjit.md
@@ -71,4 +71,4 @@ Maybe by calling the following at the beginning of gdb:
 set substitute-path /usr/src/debug/gcc /path/to/gcc-repo/gcc
 ```
 
-TODO(antoyo): but that's not what I remember I was doing.
+FIXME(antoyo): but that's not what I remember I was doing.
diff --git a/compiler/rustc_codegen_gcc/doc/subtree.md b/compiler/rustc_codegen_gcc/doc/subtree.md
index 5d7af2a066bd..a81b6c9c74bd 100644
--- a/compiler/rustc_codegen_gcc/doc/subtree.md
+++ b/compiler/rustc_codegen_gcc/doc/subtree.md
@@ -47,6 +47,6 @@ git push
 PATH="$HOME/bin:$PATH" ~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_name
 ```
 
-TODO: write a script that does the above.
+FIXME: write a script that does the above.
 
 https://rust-lang.zulipchat.com/#narrow/stream/301329-t-devtools/topic/subtree.20madness/near/258877725
diff --git a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
index d5c386ffb3dd..6e155f89ee5c 100644
--- a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
+++ b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
@@ -275,7 +275,7 @@ unsafe fn uninitialized<T>() -> T {
         }
     }
 
-    // TODO(antoyo): to make this work, support weak linkage.
+    // FIXME(antoyo): to make this work, support weak linkage.
     //unsafe { assert_eq!(ABC as usize, 0); }
 
     &mut (|| Some(0 as *const ())) as &mut dyn FnMut() -> Option<*const ()>;
diff --git a/compiler/rustc_codegen_gcc/src/abi.rs b/compiler/rustc_codegen_gcc/src/abi.rs
index 56ed7c01ed20..4d1274a63d1f 100644
--- a/compiler/rustc_codegen_gcc/src/abi.rs
+++ b/compiler/rustc_codegen_gcc/src/abi.rs
@@ -105,7 +105,7 @@ pub struct FnAbiGcc<'gcc> {
 }
 
 pub trait FnAbiGccExt<'gcc, 'tcx> {
-    // TODO(antoyo): return a function pointer type instead?
+    // FIXME(antoyo): return a function pointer type instead?
     fn gcc_type(&self, cx: &CodegenCx<'gcc, 'tcx>) -> FnAbiGcc<'gcc>;
     fn ptr_to_gcc_type(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc>;
     #[cfg(feature = "master")]
@@ -260,7 +260,7 @@ pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &Arch) -> Option<FnAttri
             &Arch::Nvptx64 => FnAttribute::NvptxKernel,
             arch => panic!("Arch {arch} does not support GpuKernel calling convention"),
         },
-        // TODO(antoyo): check if those AVR attributes are mapped correctly.
+        // FIXME(antoyo): check if those AVR attributes are mapped correctly.
         CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
             InterruptKind::Avr => FnAttribute::AvrSignal,
             InterruptKind::AvrNonBlocking => FnAttribute::AvrInterrupt,
diff --git a/compiler/rustc_codegen_gcc/src/allocator.rs b/compiler/rustc_codegen_gcc/src/allocator.rs
index 1f464d7e1226..6b92174ddf1c 100644
--- a/compiler/rustc_codegen_gcc/src/allocator.rs
+++ b/compiler/rustc_codegen_gcc/src/allocator.rs
@@ -98,7 +98,7 @@ fn create_wrapper_function(
     )));
 
     if tcx.sess.must_emit_unwind_tables() {
-        // TODO(antoyo): emit unwind tables.
+        // FIXME(antoyo): emit unwind tables.
     }
 
     let block = func.new_block("entry");
@@ -138,6 +138,6 @@ fn create_wrapper_function(
         block.end_with_void_return(None);
     }
 
-    // TODO(@Commeownist): Check if we need to emit some extra debugging info in certain circumstances
+    // FIXME(@Commeownist): Check if we need to emit some extra debugging info in certain circumstances
     // as described in https://github.com/rust-lang/rust/commit/77a96ed5646f7c3ee8897693decc4626fe380643
 }
diff --git a/compiler/rustc_codegen_gcc/src/asm.rs b/compiler/rustc_codegen_gcc/src/asm.rs
index 319f3d327873..c5fb257107ff 100644
--- a/compiler/rustc_codegen_gcc/src/asm.rs
+++ b/compiler/rustc_codegen_gcc/src/asm.rs
@@ -308,13 +308,13 @@ fn codegen_inline_asm(
                 }
 
                 InlineAsmOperandRef::SymFn { instance } => {
-                    // TODO(@Amanieu): Additional mangling is needed on
+                    // FIXME(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O)
                     // or byte count suffixes (x86 Windows).
                     constants_len += self.tcx.symbol_name(instance).name.len();
                 }
                 InlineAsmOperandRef::SymStatic { def_id } => {
-                    // TODO(@Amanieu): Additional mangling is needed on
+                    // FIXME(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O).
                     constants_len +=
                         self.tcx.symbol_name(Instance::mono(self.tcx, def_id)).name.len();
@@ -440,7 +440,7 @@ fn codegen_inline_asm(
             match *piece {
                 InlineAsmTemplatePiece::String(ref string) => {
                     for char in string.chars() {
-                        // TODO(antoyo): might also need to escape | if rustc doesn't do it.
+                        // FIXME(antoyo): might also need to escape | if rustc doesn't do it.
                         let escaped_char = match char {
                             '%' => "%%",
                             '{' => "%{",
@@ -496,7 +496,7 @@ fn codegen_inline_asm(
                         }
 
                         InlineAsmOperandRef::SymFn { instance } => {
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)
                             // or byte count suffixes (x86 Windows).
                             let name = self.tcx.symbol_name(instance).name;
@@ -504,7 +504,7 @@ fn codegen_inline_asm(
                         }
 
                         InlineAsmOperandRef::SymStatic { def_id } => {
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O).
                             let instance = Instance::mono(self.tcx, def_id);
                             let name = self.tcx.symbol_name(instance).name;
@@ -557,7 +557,7 @@ fn codegen_inline_asm(
                 InlineAsmArch::PowerPC | InlineAsmArch::PowerPC64 => {
                     // "cc" is cr0 on powerpc.
                 }
-                // TODO(@Commeownist): I'm not 100% sure this one clobber is sufficient
+                // FIXME(@Commeownist): I'm not 100% sure this one clobber is sufficient
                 // on all architectures. For instance, what about FP stack?
                 _ => {
                     extended_asm.add_clobber("cc");
@@ -571,7 +571,7 @@ fn codegen_inline_asm(
             extended_asm.set_volatile_flag(true);
         }
         if !options.contains(InlineAsmOptions::NOSTACK) {
-            // TODO(@Commeownist): figure out how to align stack
+            // FIXME(@Commeownist): figure out how to align stack
         }
         if dest.is_none() && options.contains(InlineAsmOptions::NORETURN) {
             let builtin_unreachable = self.context.get_builtin_function("__builtin_unreachable");
@@ -640,7 +640,7 @@ fn explicit_reg_to_gcc(reg: InlineAsmReg) -> &'static str {
     // For explicit registers, we have to create a register variable: https://stackoverflow.com/a/31774784/389119
     match reg {
         InlineAsmReg::X86(reg) => {
-            // TODO(antoyo): add support for vector register.
+            // FIXME(antoyo): add support for vector register.
             match reg.reg_class() {
                 X86InlineAsmRegClass::reg_byte => {
                     // GCC does not support the `b` suffix, so we just strip it
@@ -901,7 +901,7 @@ fn codegen_global_asm(
                         GlobalAsmOperandRef::SymFn { instance } => {
                             let function = get_fn(self, instance);
                             self.add_used_function(function);
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)
                             // or byte count suffixes (x86 Windows).
                             let name = self.tcx.symbol_name(instance).name;
@@ -909,8 +909,8 @@ fn codegen_global_asm(
                         }
 
                         GlobalAsmOperandRef::SymStatic { def_id } => {
-                            // TODO(antoyo): set the global variable as used.
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(antoyo): set the global variable as used.
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O).
                             let instance = Instance::mono(self.tcx, def_id);
                             let name = self.tcx.symbol_name(instance).name;
@@ -930,7 +930,7 @@ fn codegen_global_asm(
     }
 
     fn mangled_name(&self, instance: Instance<'tcx>) -> String {
-        // TODO(@Amanieu): Additional mangling is needed on
+        // FIXME(@Amanieu): Additional mangling is needed on
         // some targets to add a leading underscore (Mach-O)
         // or byte count suffixes (x86 Windows).
         self.tcx.symbol_name(instance).name.to_string()
diff --git a/compiler/rustc_codegen_gcc/src/attributes.rs b/compiler/rustc_codegen_gcc/src/attributes.rs
index cd8c1206c821..ce1877b308e9 100644
--- a/compiler/rustc_codegen_gcc/src/attributes.rs
+++ b/compiler/rustc_codegen_gcc/src/attributes.rs
@@ -126,19 +126,19 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
         .map(|features| features.name.as_str())
         .flat_map(|feat| to_gcc_features(cx.tcx.sess, feat).into_iter())
         .chain(codegen_fn_attrs.instruction_set.iter().map(|x| match *x {
-            InstructionSetAttr::ArmA32 => "-thumb-mode", // TODO(antoyo): support removing feature.
+            InstructionSetAttr::ArmA32 => "-thumb-mode", // FIXME(antoyo): support removing feature.
             InstructionSetAttr::ArmT32 => "thumb-mode",
         }))
         .collect::<Vec<_>>();
 
-    // TODO(antoyo): cg_llvm adds global features to each function so that LTO keep them.
+    // FIXME(antoyo): cg_llvm adds global features to each function so that LTO keep them.
     // Check if GCC requires the same.
     let mut global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());
     function_features.extend(&mut global_features);
     let target_features = function_features
         .iter()
         .filter_map(|feature| {
-            // TODO(antoyo): support soft-float.
+            // FIXME(antoyo): support soft-float.
             if feature.contains("soft-float") {
                 return None;
             }
diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index 347a15a392af..aee164cf3222 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -10,7 +10,7 @@
 // Maybe that's because the combined object files contain the IR (true) and the final link
 // does not remove it?
 //
-// TODO(antoyo): for performance, check which optimizations the C++ frontend enables.
+// FIXME(antoyo): for performance, check which optimizations the C++ frontend enables.
 // cSpell:disable
 // Fix these warnings:
 // /usr/bin/ld: warning: type of symbol `_RNvNvNvNtCs5JWOrf9uCus_5rayon11thread_pool19WORKER_THREAD_STATE7___getit5___KEY' changed from 1 to 6 in /tmp/ccKeUSiR.ltrans0.ltrans.o
@@ -39,7 +39,7 @@
 use crate::{GccCodegenBackend, GccContext, LtoMode, to_gcc_opt_level};
 
 struct LtoData {
-    // TODO(antoyo): use symbols_below_threshold.
+    // FIXME(antoyo): use symbols_below_threshold.
     //symbols_below_threshold: Vec<String>,
     upstream_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
     tmp_path: TempDir,
@@ -173,7 +173,7 @@ fn fat_lto(
         .filter(|&(_, module)| module.kind == ModuleKind::Regular)
         .map(|(i, _module)| {
             //let cost = unsafe { llvm::LLVMRustModuleCost(module.module_llvm.llmod()) };
-            // TODO(antoyo): compute the cost of a module if GCC allows this.
+            // FIXME(antoyo): compute the cost of a module if GCC allows this.
             (0, i)
         })
         .max();
diff --git a/compiler/rustc_codegen_gcc/src/back/write.rs b/compiler/rustc_codegen_gcc/src/back/write.rs
index 24ea2b66ba7d..64674423de2c 100644
--- a/compiler/rustc_codegen_gcc/src/back/write.rs
+++ b/compiler/rustc_codegen_gcc/src/back/write.rs
@@ -44,7 +44,7 @@ pub(crate) fn codegen(
             let _timer =
                 prof.generic_activity_with_arg("GCC_module_codegen_make_bitcode", &*module.name);
 
-            // TODO(antoyo)
+            // FIXME(antoyo)
             /*if let Some(bitcode_filename) = bc_out.file_name() {
                 cgcx.prof.artifact_size(
                     "llvm_bitcode",
@@ -68,14 +68,14 @@ pub(crate) fn codegen(
                 let _timer = prof
                     .generic_activity_with_arg("GCC_module_codegen_embed_bitcode", &*module.name);
                 if lto_supported {
-                    // TODO(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
+                    // FIXME(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
                     //embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
 
                     context.add_command_line_option("-flto=auto");
                     context.add_command_line_option("-flto-partition=one");
                     context.add_command_line_option("-ffat-lto-objects");
                 }
-                // TODO(antoyo): Send -plugin/usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/liblto_plugin.so to linker (this should be done when specifying the appropriate rustc cli argument).
+                // FIXME(antoyo): Send -plugin/usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/liblto_plugin.so to linker (this should be done when specifying the appropriate rustc cli argument).
                 context
                     .compile_to_file(OutputKind::ObjectFile, bc_out.to_str().expect("path to str"));
             }
@@ -135,7 +135,7 @@ pub(crate) fn codegen(
 
                         // NOTE: without -fuse-linker-plugin, we get the following error:
                         // lto1: internal compiler error: decompressed stream: Destination buffer is too small
-                        // TODO(antoyo): since we do not do LTO when the linker is invoked anymore, perhaps
+                        // FIXME(antoyo): since we do not do LTO when the linker is invoked anymore, perhaps
                         // the following flag is not necessary anymore.
                         context.add_driver_option("-fuse-linker-plugin");
                     }
diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs
index 18058d9491ad..d1637dd663bb 100644
--- a/compiler/rustc_codegen_gcc/src/base.rs
+++ b/compiler/rustc_codegen_gcc/src/base.rs
@@ -50,7 +50,7 @@ pub fn global_linkage_to_gcc(linkage: Linkage) -> GlobalKind {
         Linkage::WeakAny => unimplemented!(),
         Linkage::WeakODR => unimplemented!(),
         Linkage::Internal => GlobalKind::Internal,
-        Linkage::ExternalWeak => GlobalKind::Imported, // TODO(antoyo): should be weak linkage.
+        Linkage::ExternalWeak => GlobalKind::Imported, // FIXME(antoyo): should be weak linkage.
         Linkage::Common => unimplemented!(),
     }
 }
@@ -58,7 +58,7 @@ pub fn global_linkage_to_gcc(linkage: Linkage) -> GlobalKind {
 pub fn linkage_to_gcc(linkage: Linkage) -> FunctionType {
     match linkage {
         Linkage::External => FunctionType::Exported,
-        // TODO(antoyo): set the attribute externally_visible.
+        // FIXME(antoyo): set the attribute externally_visible.
         Linkage::AvailableExternally => FunctionType::Extern,
         Linkage::LinkOnceAny => unimplemented!(),
         Linkage::LinkOnceODR => unimplemented!(),
@@ -198,7 +198,7 @@ fn module_codegen(
         context.set_allow_unreachable_blocks(true);
 
         {
-            // TODO: to make it less error-prone (calling get_target_info() will add the flag
+            // FIXME: to make it less error-prone (calling get_target_info() will add the flag
             // -fsyntax-only), forbid the compilation when get_target_info() is called on a
             // context.
             let f16_type_supported = target_info.supports_target_dependent_type(CType::Float16);
@@ -206,7 +206,7 @@ fn module_codegen(
             let f64_type_supported = target_info.supports_target_dependent_type(CType::Float64);
             let f128_type_supported = target_info.supports_target_dependent_type(CType::Float128);
             let u128_type_supported = target_info.supports_target_dependent_type(CType::UInt128t);
-            // TODO: improve this to avoid passing that many arguments.
+            // FIXME: improve this to avoid passing that many arguments.
             let mut cx = CodegenCx::new(
                 &context,
                 cgu,
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 1d5db049f7dc..6add7f05c2ab 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -38,7 +38,7 @@
 use crate::intrinsic::llvm;
 use crate::type_of::LayoutGccExt;
 
-// TODO(antoyo)
+// FIXME(antoyo)
 type Funclet = ();
 
 enum ExtremumOperation {
@@ -75,7 +75,7 @@ fn atomic_extremum(
         let func = self.current_func();
 
         let load_ordering = match order {
-            // TODO(antoyo): does this make sense?
+            // FIXME(antoyo): does this make sense?
             AtomicOrdering::AcqRel | AtomicOrdering::Release => AtomicOrdering::Acquire,
             _ => order,
         };
@@ -284,8 +284,8 @@ fn check_ptr_call<'b>(
                             func_ptr,
                             index
                         );
-                        // TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
-                        // TODO: remove bitcast now that vector types can be compared?
+                        // FIXME(antoyo): perhaps use __builtin_convertvector for vector casting.
+                        // FIXME: remove bitcast now that vector types can be compared?
                         // ==> We use bitcast to avoid having to do many manual casts from e.g. __m256i to __v32qi (in
                         // the case of _mm256_aesenc_epi128).
                         self.bitcast(actual_val, expected_ty)
@@ -430,7 +430,7 @@ pub fn overflow_call(
         // That's why we assign the result to a local.
         let return_type = self.context.new_type::<bool>();
         let current_func = self.block.get_function();
-        // TODO(antoyo): return the new_call() directly? Since the overflow function has no side-effects.
+        // FIXME(antoyo): return the new_call() directly? Since the overflow function has no side-effects.
         let result = current_func.new_local(
             self.location,
             return_type,
@@ -610,7 +610,7 @@ fn invoke(
 
         let current_block = self.block;
         self.block = try_block;
-        let call = self.call(typ, fn_attrs, None, func, args, None, instance); // TODO(antoyo): use funclet here?
+        let call = self.call(typ, fn_attrs, None, func, args, None, instance); // FIXME(antoyo): use funclet here?
         self.block = current_block;
 
         let return_value =
@@ -648,7 +648,7 @@ fn invoke(
         let condition = self.context.new_rvalue_from_int(self.bool_type, 1);
         self.llbb().end_with_conditional(self.location, condition, then, catch);
         if let Some(_fn_abi) = fn_abi {
-            // TODO(bjorn3): Apply function attributes
+            // FIXME(bjorn3): Apply function attributes
         }
         call_site
     }
@@ -675,7 +675,7 @@ fn fadd(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
         self.assign_to_var(a + b)
     }
 
-    // TODO(antoyo): should we also override the `unchecked_` versions?
+    // FIXME(antoyo): should we also override the `unchecked_` versions?
     fn sub(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
         self.assign_to_var(self.gcc_sub(a, b))
     }
@@ -703,7 +703,7 @@ fn udiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
     }
 
     fn exactudiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): poison if not exact.
+        // FIXME(antoyo): poison if not exact.
         let a_type = a.get_type().to_unsigned(self);
         let a = self.gcc_int_cast(a, a_type);
         let b_type = b.get_type().to_unsigned(self);
@@ -716,7 +716,7 @@ fn sdiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
     }
 
     fn exactsdiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): poison if not exact.
+        // FIXME(antoyo): poison if not exact.
         // FIXME(antoyo): rustc_codegen_ssa::mir::intrinsic uses different types for a and b but they
         // should be the same.
         let typ = a.get_type().to_signed(self);
@@ -737,7 +737,7 @@ fn srem(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
     }
 
     fn frem(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): add check in libgccjit since using the binary operator % causes the following error:
+        // FIXME(antoyo): add check in libgccjit since using the binary operator % causes the following error:
         // during RTL pass: expand
         // libgccjit.so: error: in expmed_mode_index, at expmed.h:240
         // 0x7f0101d58dc6 expmed_mode_index
@@ -789,7 +789,7 @@ fn frem(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
                 return self.context.new_call(self.location, fmod, &[a, b]);
             }
             TypeKind::FP128 => {
-                // TODO(antoyo): use get_simple_function_f128_2args.
+                // FIXME(antoyo): use get_simple_function_f128_2args.
                 let f128_type = self.type_f128();
                 let fmodf128 = self.context.new_function(
                     None,
@@ -837,7 +837,7 @@ fn lshr(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
     }
 
     fn ashr(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): check whether behavior is an arithmetic shift for >> .
+        // FIXME(antoyo): check whether behavior is an arithmetic shift for >> .
         // It seems to be if the value is signed.
         self.gcc_lshr(a, b)
     }
@@ -937,7 +937,7 @@ fn checked_binop(
 
     fn alloca(&mut self, size: Size, align: Align) -> RValue<'gcc> {
         let ty = self.cx.type_array(self.cx.type_i8(), size.bytes()).get_aligned(align.bytes());
-        // TODO(antoyo): It might be better to return a LValue, but fixing the rustc API is non-trivial.
+        // FIXME(antoyo): It might be better to return a LValue, but fixing the rustc API is non-trivial.
         self.current_func()
             .new_local(self.location, ty, format!("stack_var_{}", self.next_value_counter()))
             .get_address(self.location)
@@ -1006,8 +1006,8 @@ fn atomic_load(
         order: AtomicOrdering,
         size: Size,
     ) -> RValue<'gcc> {
-        // TODO(antoyo): use ty.
-        // TODO(antoyo): handle alignment.
+        // FIXME(antoyo): use ty.
+        // FIXME(antoyo): handle alignment.
         let atomic_load =
             self.context.get_builtin_function(format!("__atomic_load_{}", size.bytes()));
         let ordering = self.context.new_rvalue_from_int(self.i32_type, order.to_gcc());
@@ -1128,11 +1128,11 @@ fn write_operand_repeatedly(
     }
 
     fn range_metadata(&mut self, _load: RValue<'gcc>, _range: WrappingRange) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn nonnull_metadata(&mut self, _load: RValue<'gcc>) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn store(&mut self, val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
@@ -1161,7 +1161,7 @@ fn store_with_flags(
             self.cx.context.new_cast(self.location, ptr, modified_destination_type.make_pointer());
         let modified_destination = modified_ptr.dereference(self.location);
         self.llbb().add_assignment(self.location, modified_destination, val);
-        // TODO(antoyo): handle `MemFlags::NONTEMPORAL`.
+        // FIXME(antoyo): handle `MemFlags::NONTEMPORAL`.
         // NOTE: dummy value here since it's never used. FIXME(antoyo): API should not return a value here?
         // When adding support for NONTEMPORAL, make sure to not just emit MOVNT on x86; see the
         // LLVM backend for details.
@@ -1175,7 +1175,7 @@ fn atomic_store(
         order: AtomicOrdering,
         size: Size,
     ) {
-        // TODO(antoyo): handle alignment.
+        // FIXME(antoyo): handle alignment.
         let atomic_store =
             self.context.get_builtin_function(format!("__atomic_store_{}", size.bytes()));
         let ordering = self.context.new_rvalue_from_int(self.i32_type, order.to_gcc());
@@ -1205,7 +1205,7 @@ fn gep(
         let ptr_type = ptr.get_type();
         let mut pointee_type = ptr.get_type();
         // NOTE: we cannot use array indexing here like in inbounds_gep because array indexing is
-        // always considered in bounds in GCC (TODO(antoyo): to be verified).
+        // always considered in bounds in GCC (FIXME(antoyo): to be verified).
         // So, we have to cast to a number.
         let mut result = self.context.new_bitcast(self.location, ptr, self.sizet_type);
         // FIXME(antoyo): if there were more than 1 index, this code is probably wrong and would
@@ -1233,7 +1233,7 @@ fn inbounds_gep(
     ) -> RValue<'gcc> {
         // NOTE: due to opaque pointers now being used, we need to cast here.
         let ptr = self.context.new_cast(self.location, ptr, typ.make_pointer());
-        // NOTE: array indexing is always considered in bounds in GCC (TODO(antoyo): to be verified).
+        // NOTE: array indexing is always considered in bounds in GCC (FIXME(antoyo): to be verified).
         let mut indices = indices.iter();
         let index = indices.next().expect("first index in inbounds_gep");
         let mut result = self.context.new_array_access(self.location, ptr, *index);
@@ -1245,14 +1245,14 @@ fn inbounds_gep(
 
     /* Casts */
     fn trunc(&mut self, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): check that it indeed truncate the value.
+        // FIXME(antoyo): check that it indeed truncate the value.
         self.gcc_int_cast(value, dest_ty)
     }
 
     fn sext(&mut self, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): check that it indeed sign extend the value.
+        // FIXME(antoyo): check that it indeed sign extend the value.
         if dest_ty.dyncast_vector().is_some() {
-            // TODO(antoyo): nothing to do as it is only for LLVM?
+            // FIXME(antoyo): nothing to do as it is only for LLVM?
             return value;
         }
         self.context.new_cast(self.location, value, dest_ty)
@@ -1275,7 +1275,7 @@ fn sitofp(&mut self, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
     }
 
     fn fptrunc(&mut self, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): make sure it truncates.
+        // FIXME(antoyo): make sure it truncates.
         set_rvalue_location(self, self.context.new_cast(self.location, value, dest_ty))
     }
 
@@ -1405,7 +1405,7 @@ fn memcpy(
         let dst = self.pointercast(dst, self.type_i8p());
         let src = self.pointercast(src, self.type_ptr_to(self.type_void()));
         let memcpy = self.context.get_builtin_function("memcpy");
-        // TODO(antoyo): handle aligns and is_volatile.
+        // FIXME(antoyo): handle aligns and is_volatile.
         self.block.add_eval(
             self.location,
             self.context.new_call(self.location, memcpy, &[dst, src, size]),
@@ -1428,7 +1428,7 @@ fn memmove(
         let src = self.pointercast(src, self.type_ptr_to(self.type_void()));
 
         let memmove = self.context.get_builtin_function("memmove");
-        // TODO(antoyo): handle is_volatile.
+        // FIXME(antoyo): handle is_volatile.
         self.block.add_eval(
             self.location,
             self.context.new_call(self.location, memmove, &[dst, src, size]),
@@ -1447,7 +1447,7 @@ fn memset(
         let _is_volatile = flags.contains(MemFlags::VOLATILE);
         let ptr = self.pointercast(ptr, self.type_i8p());
         let memset = self.context.get_builtin_function("memset");
-        // TODO(antoyo): handle align and is_volatile.
+        // FIXME(antoyo): handle align and is_volatile.
         let fill_byte = self.context.new_cast(self.location, fill_byte, self.i32_type);
         let size = self.intcast(size, self.type_size_t(), false);
         self.block.add_eval(
@@ -1599,7 +1599,7 @@ fn cleanup_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RVa
         let value1_type = self.u8_type.make_pointer();
         let ptr = self.cx.context.new_cast(self.location, ptr, value1_type);
         let value1 = ptr;
-        let value2 = zero; // TODO(antoyo): set the proper value here (the type of exception?).
+        let value2 = zero; // FIXME(antoyo): set the proper value here (the type of exception?).
 
         (value1, value2)
     }
@@ -1616,7 +1616,7 @@ fn cleanup_landing_pad(&mut self, _pers_fn: Function<'gcc>) -> (RValue<'gcc>, RV
     }
 
     fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) {
-        // TODO(antoyo): generate the correct landing pad
+        // FIXME(antoyo): generate the correct landing pad
         self.cleanup_landing_pad(pers_fn);
     }
 
@@ -1747,15 +1747,15 @@ fn atomic_fence(&mut self, order: AtomicOrdering, scope: SynchronizationScope) {
     fn set_invariant_load(&mut self, load: RValue<'gcc>) {
         // NOTE: Hack to consider vtable function pointer as non-global-variable function pointer.
         self.normal_function_addresses.borrow_mut().insert(load);
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn lifetime_start(&mut self, _ptr: RValue<'gcc>, _size: Size) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn lifetime_end(&mut self, _ptr: RValue<'gcc>, _size: Size) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn call(
@@ -1771,7 +1771,7 @@ fn call(
         // FIXME(antoyo): remove when having a proper API.
         let gcc_func = unsafe { std::mem::transmute::<RValue<'gcc>, Function<'gcc>>(func) };
         let call = if self.functions.borrow().values().any(|value| *value == gcc_func) {
-            // TODO(antoyo): remove when the API supports a different type for functions.
+            // FIXME(antoyo): remove when the API supports a different type for functions.
             let func: Function<'gcc> = self.cx.rvalue_as_function(func);
             self.function_call(func, args, funclet)
         } else {
@@ -1779,7 +1779,7 @@ fn call(
             self.function_ptr_call(typ, func, args, funclet)
         };
         if let Some(_fn_abi) = fn_abi {
-            // TODO(bjorn3): Apply function attributes
+            // FIXME(bjorn3): Apply function attributes
         }
         call
     }
@@ -1886,7 +1886,7 @@ fn int_min(signed: bool, int_width: u64) -> i128 {
             if signed { i128::MIN >> (128 - int_width) } else { 0 }
         }
 
-        // TODO: rewrite using a generic function with <F: Float>.
+        // FIXME: rewrite using a generic function with <F: Float>.
         let compute_clamp_bounds_half = |signed: bool, int_width: u64| -> (u128, u128) {
             let rounded_min =
                 ieee::Half::from_i128_r(int_min(signed, int_width), Round::TowardZero);
@@ -2023,7 +2023,7 @@ pub fn shuffle_vector(
         block.add_assignment(self.location, mask_var, mask);
         let mask = mask_var.to_rvalue();
 
-        // TODO(antoyo): use a recursive unqualified() here.
+        // FIXME(antoyo): use a recursive unqualified() here.
         let vector_type = v1.get_type().unqualified().dyncast_vector().expect("vector type");
         let element_type = vector_type.get_element_type();
         let vec_num_units = vector_type.get_num_units();
@@ -2387,7 +2387,7 @@ pub fn vector_select(
 
         #[cfg(feature = "master")]
         let (cond, element_type) = {
-            // TODO(antoyo): dyncast_vector should not require a call to unqualified.
+            // FIXME(antoyo): dyncast_vector should not require a call to unqualified.
             let then_val_vector_type =
                 then_val.get_type().unqualified().dyncast_vector().expect("vector type");
             let then_val_element_type = then_val_vector_type.get_element_type();
@@ -2426,7 +2426,7 @@ pub fn vector_select(
         // NOTE: sometimes, the type of else_val can be different than the type of then_val in
         // libgccjit (vector of int vs vector of int32_t), but they should be the same for the AND
         // operation to work.
-        // TODO: remove bitcast now that vector types can be compared?
+        // FIXME: remove bitcast now that vector types can be compared?
         let else_val = self.context.new_bitcast(self.location, else_val, then_val.get_type());
         let else_vals = inverted_masks & else_val;
 
@@ -2508,7 +2508,7 @@ fn to_gcc_comparison(&self) -> ComparisonOp {
 
 impl ToGccComp for RealPredicate {
     fn to_gcc_comparison(&self) -> ComparisonOp {
-        // TODO(antoyo): check that ordered vs non-ordered is respected.
+        // FIXME(antoyo): check that ordered vs non-ordered is respected.
         match *self {
             RealPredicate::RealPredicateFalse => unreachable!(),
             RealPredicate::RealOEQ => ComparisonOp::Equals,
@@ -2550,7 +2550,7 @@ fn to_gcc(self) -> i32 {
         use MemOrdering::*;
 
         let ordering = match self {
-            AtomicOrdering::Relaxed => __ATOMIC_RELAXED, // TODO(antoyo): check if that's the same.
+            AtomicOrdering::Relaxed => __ATOMIC_RELAXED, // FIXME(antoyo): check if that's the same.
             AtomicOrdering::Acquire => __ATOMIC_ACQUIRE,
             AtomicOrdering::Release => __ATOMIC_RELEASE,
             AtomicOrdering::AcqRel => __ATOMIC_ACQ_REL,
diff --git a/compiler/rustc_codegen_gcc/src/callee.rs b/compiler/rustc_codegen_gcc/src/callee.rs
index 8487a85bd035..00f095ed5437 100644
--- a/compiler/rustc_codegen_gcc/src/callee.rs
+++ b/compiler/rustc_codegen_gcc/src/callee.rs
@@ -60,7 +60,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
         // reference. It also occurs when testing libcore and in some
         // other weird situations. Annoying.
         if cx.val_ty(func) != ptrtype {
-            // TODO(antoyo): cast the pointer.
+            // FIXME(antoyo): cast the pointer.
             func
         }
         else {
@@ -76,7 +76,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
         {
             let instance_def_id = instance.def_id();
 
-            // TODO(antoyo): set linkage and attributes.
+            // FIXME(antoyo): set linkage and attributes.
 
             // Apply an appropriate linkage/visibility value to our item that we
             // just declared.
diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
index 79cae9e02826..9e548ac0a8b0 100644
--- a/compiler/rustc_codegen_gcc/src/common.rs
+++ b/compiler/rustc_codegen_gcc/src/common.rs
@@ -26,13 +26,13 @@ pub fn const_u16(&self, i: u16) -> RValue<'gcc> {
     }
 
     fn global_string(&self, string: &str) -> LValue<'gcc> {
-        // TODO(antoyo): handle non-null-terminated strings.
+        // FIXME(antoyo): handle non-null-terminated strings.
         let string = self.context.new_string_literal(string);
         let sym = self.generate_local_symbol_name("str");
         let global = self.declare_private_global(&sym, self.val_ty(string));
         global.global_set_initializer_rvalue(string);
         global
-        // TODO(antoyo): set linkage.
+        // FIXME(antoyo): set linkage.
     }
 
     pub fn const_bitcast(&self, value: RValue<'gcc>, typ: Type<'gcc>) -> RValue<'gcc> {
@@ -204,7 +204,7 @@ fn const_str(&self, s: &str) -> (RValue<'gcc>, RValue<'gcc>) {
 
     fn const_struct(&self, values: &[RValue<'gcc>], packed: bool) -> RValue<'gcc> {
         let fields: Vec<_> = values.iter().map(|value| value.get_type()).collect();
-        // TODO(antoyo): cache the type? It's anonymous, so probably not.
+        // FIXME(antoyo): cache the type? It's anonymous, so probably not.
         let typ = self.type_struct(&fields, packed);
         let struct_type = typ.is_struct().expect("struct type");
         self.context.new_struct_constructor(None, struct_type.as_type(), None, values)
@@ -216,12 +216,12 @@ fn const_vector(&self, values: &[RValue<'gcc>]) -> RValue<'gcc> {
     }
 
     fn const_to_opt_uint(&self, _v: RValue<'gcc>) -> Option<u64> {
-        // TODO(antoyo)
+        // FIXME(antoyo)
         None
     }
 
     fn const_to_opt_u128(&self, _v: RValue<'gcc>, _sign_ext: bool) -> Option<u128> {
-        // TODO(antoyo)
+        // FIXME(antoyo)
         None
     }
 
@@ -236,10 +236,10 @@ fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) ->
                     // NOTE: since the intrinsic _xabort is called with a bitcast, which
                     // is non-const, but expects a constant, do a normal cast instead of a bitcast.
                     // FIXME(antoyo): fix bitcast to work in constant contexts.
-                    // TODO(antoyo): perhaps only use bitcast for pointers?
+                    // FIXME(antoyo): perhaps only use bitcast for pointers?
                     self.context.new_cast(None, value, ty)
                 } else {
-                    // TODO(bjorn3): assert size is correct
+                    // FIXME(bjorn3): assert size is correct
                     self.const_bitcast(value, ty)
                 }
             }
@@ -270,7 +270,7 @@ fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) ->
                             _ => self.static_addr_of(alloc, None),
                         };
                         if !self.sess().fewer_names() {
-                            // TODO(antoyo): set value name.
+                            // FIXME(antoyo): set value name.
                         }
                         value
                     }
diff --git a/compiler/rustc_codegen_gcc/src/consts.rs b/compiler/rustc_codegen_gcc/src/consts.rs
index 8afa57bc28fc..42ff93096850 100644
--- a/compiler/rustc_codegen_gcc/src/consts.rs
+++ b/compiler/rustc_codegen_gcc/src/consts.rs
@@ -166,7 +166,7 @@ fn codegen_static(&mut self, def_id: DefId) {
                 unimplemented!();
             }
         } else {
-            // TODO(antoyo): set link section.
+            // FIXME(antoyo): set link section.
         }
 
         if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
@@ -180,7 +180,7 @@ fn codegen_static(&mut self, def_id: DefId) {
 impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
     /// Add a global value to a list to be stored in the `llvm.used` variable, an array of i8*.
     pub fn add_used_global(&mut self, _global: RValue<'gcc>) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     #[cfg_attr(not(feature = "master"), expect(unused_variables))]
@@ -198,7 +198,7 @@ pub fn static_addr_of_mut(
         let global = match kind {
             Some(kind) if !self.tcx.sess.fewer_names() => {
                 let name = self.generate_local_symbol_name(kind);
-                // TODO(antoyo): check if it's okay that no link_section is set.
+                // FIXME(antoyo): check if it's okay that no link_section is set.
 
                 let typ = self.val_ty(cv).get_aligned(align.bytes());
                 self.declare_private_global(&name[..], typ)
@@ -209,7 +209,7 @@ pub fn static_addr_of_mut(
             }
         };
         global.global_set_initializer_rvalue(cv);
-        // TODO(antoyo): set unnamed address.
+        // FIXME(antoyo): set unnamed address.
         let rvalue = global.get_address(None);
         self.global_lvalues.borrow_mut().insert(rvalue, global);
         rvalue
@@ -276,7 +276,7 @@ pub(crate) fn get_static_inner(&self, def_id: DefId, gcc_type: Type<'gcc>) -> LV
         };
 
         if !def_id.is_local() {
-            let needs_dll_storage_attr = false; // TODO(antoyo)
+            let needs_dll_storage_attr = false; // FIXME(antoyo)
 
             // If this assertion triggers, there's something wrong with commandline
             // argument validation.
@@ -303,7 +303,7 @@ pub(crate) fn get_static_inner(&self, def_id: DefId, gcc_type: Type<'gcc>) -> LV
             }
         }
 
-        // TODO(antoyo): set dll storage class.
+        // FIXME(antoyo): set dll storage class.
 
         self.instances.borrow_mut().insert(instance, global);
         global
@@ -412,7 +412,7 @@ fn check_and_apply_linkage<'gcc, 'tcx>(
         let real_name =
             format!("_rust_extern_with_linkage_{:016x}_{sym}", cx.tcx.stable_crate_id(LOCAL_CRATE));
         let global2 = cx.define_global(&real_name, gcc_type, is_tls, attrs.link_section);
-        // TODO(antoyo): set linkage.
+        // FIXME(antoyo): set linkage.
         let value = cx.const_ptrcast(global1.get_address(None), gcc_type);
         global2.global_set_initializer_rvalue(value);
         global2
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index ada3d73f612e..197b8e767806 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -37,7 +37,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
     pub codegen_unit: &'tcx CodegenUnit<'tcx>,
     pub context: &'gcc Context<'gcc>,
 
-    // TODO(bjorn3): Can this field be removed?
+    // FIXME(bjorn3): Can this field be removed?
     pub current_func: RefCell<Option<Function<'gcc>>>,
     pub normal_function_addresses: RefCell<FxHashSet<RValue<'gcc>>>,
     pub function_address_names: RefCell<FxHashMap<RValue<'gcc>, String>>,
@@ -100,7 +100,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
     pub vtables:
         RefCell<FxHashMap<(Ty<'tcx>, Option<ty::ExistentialTraitRef<'tcx>>), RValue<'gcc>>>,
 
-    // TODO(antoyo): improve the SSA API to not require those.
+    // FIXME(antoyo): improve the SSA API to not require those.
     /// Mapping from function pointer type to indexes of on stack parameters.
     pub on_stack_params: RefCell<FxHashMap<FunctionPtrType<'gcc>, FxHashSet<usize>>>,
     /// Mapping from function to indexes of on stack parameters.
@@ -110,7 +110,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
     pub const_globals: RefCell<FxHashMap<RValue<'gcc>, RValue<'gcc>>>,
 
     /// Map from the address of a global variable (rvalue) to the global variable itself (lvalue).
-    /// TODO(antoyo): remove when the rustc API is fixed.
+    /// FIXME(antoyo): remove when the rustc API is fixed.
     pub global_lvalues: RefCell<FxHashMap<RValue<'gcc>, LValue<'gcc>>>,
 
     /// Cache of constant strings,
@@ -199,7 +199,7 @@ pub fn new(
             let layout = tcx.layout_of(ParamEnv::reveal_all().and(tcx.types.u128)).unwrap();
             let u128_align = layout.align.bytes();*/
 
-            // TODO(antoyo): re-enable the alignment when libgccjit fixed the issue in
+            // FIXME(antoyo): re-enable the alignment when libgccjit fixed the issue in
             // gcc_jit_context_new_array_constructor (it should not use reinterpret_cast).
             let i128_type = new_array_type(context, None, i64_type, 2)/*.get_aligned(i128_align)*/;
             let u128_type = new_array_type(context, None, u64_type, 2)/*.get_aligned(u128_align)*/;
@@ -208,7 +208,7 @@ pub fn new(
 
         let tls_model = to_gcc_tls_mode(tcx.sess.tls_model());
 
-        // TODO(antoyo): set alignment on those types as well.
+        // FIXME(antoyo): set alignment on those types as well.
         let float_type = context.new_type::<f32>();
         let double_type = context.new_type::<f64>();
 
@@ -309,7 +309,7 @@ pub fn new(
             #[cfg(feature = "master")]
             cleanup_blocks: Default::default(),
         };
-        // TODO(antoyo): instead of doing this, add SsizeT to libgccjit.
+        // FIXME(antoyo): instead of doing this, add SsizeT to libgccjit.
         cx.isize_type = usize_type.to_signed(&cx);
         cx
     }
@@ -382,15 +382,15 @@ pub fn bitcast_if_needed(
 impl<'gcc, 'tcx> BackendTypes for CodegenCx<'gcc, 'tcx> {
     type Function = Function<'gcc>;
     type BasicBlock = Block<'gcc>;
-    type Funclet = (); // TODO(antoyo)
+    type Funclet = (); // FIXME(antoyo)
 
     type Value = RValue<'gcc>;
     type Type = Type<'gcc>;
     type FunctionSignature = Type<'gcc>;
 
-    type DIScope = (); // TODO(antoyo)
+    type DIScope = (); // FIXME(antoyo)
     type DILocation = Location<'gcc>;
-    type DIVariable = (); // TODO(antoyo)
+    type DIVariable = (); // FIXME(antoyo)
 }
 
 impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
@@ -414,7 +414,7 @@ fn get_fn_addr(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
         };
         let ptr = func.get_address(None);
 
-        // TODO(antoyo): don't do this twice: i.e. in declare_fn and here.
+        // FIXME(antoyo): don't do this twice: i.e. in declare_fn and here.
         // FIXME(antoyo): the rustc API seems to call get_fn_addr() when not needed (e.g. for FFI).
 
         self.normal_function_addresses.borrow_mut().insert(ptr);
@@ -472,7 +472,7 @@ fn eh_personality(&self) -> Function<'gcc> {
                 self.declare_func(name, self.type_i32(), &[], true)
             }
         };
-        // TODO(antoyo): apply target cpu attributes.
+        // FIXME(antoyo): apply target cpu attributes.
         self.eh_personality.set(Some(func));
         func
     }
@@ -482,11 +482,11 @@ fn sess(&self) -> &Session {
     }
 
     fn set_frame_pointer_type(&self, _llfn: Function<'gcc>) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn apply_target_cpu_attr(&self, _llfn: Function<'gcc>) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function> {
diff --git a/compiler/rustc_codegen_gcc/src/coverageinfo.rs b/compiler/rustc_codegen_gcc/src/coverageinfo.rs
index 4e44f78f23c2..bbe9296661a7 100644
--- a/compiler/rustc_codegen_gcc/src/coverageinfo.rs
+++ b/compiler/rustc_codegen_gcc/src/coverageinfo.rs
@@ -6,6 +6,6 @@
 
 impl<'a, 'gcc, 'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
     fn add_coverage(&mut self, _instance: Instance<'tcx>, _kind: &CoverageKind) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 }
diff --git a/compiler/rustc_codegen_gcc/src/debuginfo.rs b/compiler/rustc_codegen_gcc/src/debuginfo.rs
index 53d3670c1524..cf938a3988ce 100644
--- a/compiler/rustc_codegen_gcc/src/debuginfo.rs
+++ b/compiler/rustc_codegen_gcc/src/debuginfo.rs
@@ -48,7 +48,7 @@ fn dbg_var_value(
     }
 
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
-        // TODO(antoyo): insert reference to gdb debug scripts section global.
+        // FIXME(antoyo): insert reference to gdb debug scripts section global.
     }
 
     /// FIXME(tempdragon): Currently, this function is not yet implemented. It seems that the
@@ -153,7 +153,7 @@ fn make_mir_scope<'gcc, 'tcx>(
         // FIXME(eddyb) this doesn't account for the macro-related
         // `Span` fixups that `rustc_codegen_ssa::mir::debuginfo` does.
 
-        // TODO(tempdragon): Add scope support and then revert to cg_llvm version of this closure
+        // FIXME(tempdragon): Add scope support and then revert to cg_llvm version of this closure
         // NOTE: These variables passed () here.
         // Changed to comply to clippy.
 
@@ -162,7 +162,7 @@ fn make_mir_scope<'gcc, 'tcx>(
         cx.dbg_loc(/* callsite_scope */ (), parent_scope.inlined_at, callsite_span)
     });
     let p_inlined_at = parent_scope.inlined_at;
-    // TODO(tempdragon): dbg_scope: Add support for scope extension here.
+    // FIXME(tempdragon): dbg_scope: Add support for scope extension here.
     inlined_at.or(p_inlined_at);
 
     debug_context.scopes[scope] = DebugScope {
@@ -225,7 +225,7 @@ fn create_vtable_debuginfo(
         _trait_ref: Option<ExistentialTraitRef<'tcx>>,
         _vtable: Self::Value,
     ) {
-        // TODO(antoyo)
+        // FIXME(antoyo)
     }
 
     fn create_function_debug_context(
@@ -262,7 +262,7 @@ fn extend_scope_to_file(
         _scope_metadata: Self::DIScope,
         _file: &SourceFile,
     ) -> Self::DIScope {
-        // TODO(antoyo): implement.
+        // FIXME(antoyo): implement.
     }
 
     fn debuginfo_finalize(&self) {
@@ -285,7 +285,7 @@ fn dbg_scope_fn(
         _fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
         _maybe_definition_llfn: Option<Function<'gcc>>,
     ) -> Self::DIScope {
-        // TODO(antoyo): implement.
+        // FIXME(antoyo): implement.
     }
 
     fn dbg_loc(
diff --git a/compiler/rustc_codegen_gcc/src/declare.rs b/compiler/rustc_codegen_gcc/src/declare.rs
index 6450e2d4039c..4174eebcf7b0 100644
--- a/compiler/rustc_codegen_gcc/src/declare.rs
+++ b/compiler/rustc_codegen_gcc/src/declare.rs
@@ -94,7 +94,7 @@ pub fn declare_entry_fn(
         #[cfg(feature = "master")] callconv: Option<FnAttribute<'gcc>>,
         #[cfg(not(feature = "master"))] callconv: Option<()>,
     ) -> Function<'gcc> {
-        // TODO(antoyo): use the fn_type parameter.
+        // FIXME(antoyo): use the fn_type parameter.
         let const_string = self.context.new_type::<u8>().make_pointer().make_pointer();
         let return_type = self.type_i32();
         let variadic = false;
@@ -142,7 +142,7 @@ pub fn define_global(
     }
 
     pub fn get_declared_value(&self, name: &str) -> Option<RValue<'gcc>> {
-        // TODO(antoyo): use a different field than globals, because this seems to return a function?
+        // FIXME(antoyo): use a different field than globals, because this seems to return a function?
         self.globals.borrow().get(name).cloned()
     }
 }
@@ -166,7 +166,7 @@ fn declare_raw_fn<'gcc>(
         let params: Vec<_> = param_types
             .iter()
             .enumerate()
-            .map(|(index, param)| cx.context.new_parameter(None, *param, format!("param{}", index))) // TODO(antoyo): set name.
+            .map(|(index, param)| cx.context.new_parameter(None, *param, format!("param{}", index))) // FIXME(antoyo): set name.
             .collect();
         #[cfg(not(feature = "master"))]
         let name = &mangle_name(name);
@@ -194,7 +194,7 @@ fn declare_raw_fn<'gcc>(
                 .enumerate()
                 .map(|(index, param)| {
                     cx.context.new_parameter(None, *param, format!("param{}", index))
-                }) // TODO(antoyo): set name.
+                }) // FIXME(antoyo): set name.
                 .collect();
             let gcc_func = cx.context.new_function(
                 None,
@@ -228,11 +228,11 @@ fn declare_raw_fn<'gcc>(
         func
     };
 
-    // TODO(antoyo): set function calling convention.
-    // TODO(antoyo): set unnamed address.
-    // TODO(antoyo): set no red zone function attribute.
-    // TODO(antoyo): set attributes for optimisation.
-    // TODO(antoyo): set attributes for non lazy bind.
+    // FIXME(antoyo): set function calling convention.
+    // FIXME(antoyo): set unnamed address.
+    // FIXME(antoyo): set no red zone function attribute.
+    // FIXME(antoyo): set attributes for optimisation.
+    // FIXME(antoyo): set attributes for non lazy bind.
 
     // FIXME(antoyo): invalid cast.
     func
diff --git a/compiler/rustc_codegen_gcc/src/int.rs b/compiler/rustc_codegen_gcc/src/int.rs
index 51612d604c8f..dfae4eceebe4 100644
--- a/compiler/rustc_codegen_gcc/src/int.rs
+++ b/compiler/rustc_codegen_gcc/src/int.rs
@@ -75,7 +75,7 @@ pub fn gcc_lshr(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
         let b_native = self.is_native_int_type(b_type);
         if a_native && b_native {
             // FIXME(antoyo): remove the casts when libgccjit can shift an unsigned number by a signed number.
-            // TODO(antoyo): cast to unsigned to do a logical shift if that does not work.
+            // FIXME(antoyo): cast to unsigned to do a logical shift if that does not work.
             if a_type.is_signed(self) != b_type.is_signed(self) {
                 let b = self.context.new_cast(self.location, b, a_type);
                 a >> b
@@ -168,7 +168,7 @@ fn additive_operation(
             if a_type != b_type {
                 if a_type.is_vector() {
                     // Vector types need to be bitcast.
-                    // TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
+                    // FIXME(antoyo): perhaps use __builtin_convertvector for vector casting.
                     b = self.context.new_bitcast(self.location, b, a_type);
                 } else {
                     b = self.context.new_cast(self.location, b, a_type);
@@ -228,7 +228,7 @@ fn multiplicative_operation(
             if !a_type.is_compatible_with(b_type) {
                 if a_type.is_vector() {
                     // Vector types need to be bitcast.
-                    // TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
+                    // FIXME(antoyo): perhaps use __builtin_convertvector for vector casting.
                     b = self.context.new_bitcast(self.location, b, a_type);
                 } else {
                     b = self.context.new_cast(self.location, b, a_type);
@@ -255,9 +255,9 @@ fn multiplicative_operation(
     }
 
     pub fn gcc_sdiv(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): check if the types are signed?
+        // FIXME(antoyo): check if the types are signed?
         // 128-bit, signed: __divti3
-        // TODO(antoyo): convert the arguments to signed?
+        // FIXME(antoyo): convert the arguments to signed?
         self.multiplicative_operation(BinaryOp::Divide, "div", true, a, b)
     }
 
@@ -284,7 +284,7 @@ pub fn gcc_checked_binop(
             _ => panic!("tried to get overflow intrinsic for op applied to non-int type"),
         };
 
-        // TODO(antoyo): remove duplication with intrinsic?
+        // FIXME(antoyo): remove duplication with intrinsic?
         let name = if self.is_native_int_type(lhs.get_type()) {
             match oop {
                 OverflowOp::Add => "__builtin_add_overflow",
@@ -306,7 +306,7 @@ pub fn gcc_checked_binop(
                 OverflowOp::Mul => match new_kind {
                     Int(I32) => ("__mulosi4", 32),
                     Int(I64) => ("__mulodi4", 64),
-                    Int(I128) => ("__rust_i128_mulo", 128), // TODO(antoyo): use __muloti4d instead?
+                    Int(I128) => ("__rust_i128_mulo", 128), // FIXME(antoyo): use __muloti4d instead?
                     Uint(U128) => ("__rust_u128_mulo", 128),
                     _ => unreachable!(),
                 },
@@ -317,7 +317,7 @@ pub fn gcc_checked_binop(
         let intrinsic = self.context.get_builtin_function(name);
         let res = self
             .current_func()
-            // TODO(antoyo): is it correct to use rhs type instead of the parameter typ?
+            // FIXME(antoyo): is it correct to use rhs type instead of the parameter typ?
             .new_local(self.location, rhs.get_type(), "binopResult")
             .get_address(self.location);
         let new_type = type_kind_to_gcc_type(new_kind);
@@ -462,7 +462,7 @@ pub fn gcc_icmp(
                     lhs_high = self.context.new_cast(self.location, lhs_high, unsigned_type);
                     rhs_high = self.context.new_cast(self.location, rhs_high, unsigned_type);
                 }
-                // TODO(antoyo): we probably need to handle signed comparison for unsigned
+                // FIXME(antoyo): we probably need to handle signed comparison for unsigned
                 // integers.
                 _ => (),
             }
@@ -556,7 +556,7 @@ pub fn gcc_icmp(
                         self.context.new_rvalue_one(self.int_type),
                     );
                 }
-                // TODO(antoyo): cast to u128 for unsigned comparison. See below.
+                // FIXME(antoyo): cast to u128 for unsigned comparison. See below.
                 IntPredicate::IntUGT => (ComparisonOp::Equals, 2),
                 IntPredicate::IntUGE => (ComparisonOp::GreaterThanEquals, 1),
                 IntPredicate::IntULT => (ComparisonOp::Equals, 0),
@@ -602,7 +602,7 @@ pub fn gcc_icmp(
                         rhs = self.context.new_cast(self.location, rhs, unsigned_type);
                     }
                 }
-                // TODO(antoyo): we probably need to handle signed comparison for unsigned
+                // FIXME(antoyo): we probably need to handle signed comparison for unsigned
                 // integers.
                 _ => (),
             }
@@ -693,7 +693,7 @@ pub fn gcc_shl(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
             b0_block.end_with_jump(self.location, after_block);
 
             // NOTE: cast low to its unsigned type in order to perform a logical right shift.
-            // TODO(antoyo): adjust this ^ comment.
+            // FIXME(antoyo): adjust this ^ comment.
             let unsigned_type = native_int_type.to_unsigned(self.cx);
             let casted_low = self.context.new_cast(self.location, self.low(a), unsigned_type);
             let shift_value = self.context.new_cast(self.location, sixty_four - b, unsigned_type);
@@ -732,7 +732,7 @@ pub fn gcc_bswap(&mut self, mut arg: RValue<'gcc>, width: u64) -> RValue<'gcc> {
             return self.concat_low_high_rvalues(arg_type, swapped_msb, swapped_lsb);
         }
 
-        // TODO(antoyo): check if it's faster to use string literals and a
+        // FIXME(antoyo): check if it's faster to use string literals and a
         // match instead of format!.
         let bswap = self.cx.context.get_builtin_function(format!("__builtin_bswap{}", width));
         // FIXME(antoyo): this cast should not be necessary. Remove
@@ -862,12 +862,12 @@ pub fn gcc_or(
         self.bitwise_operation(BinaryOp::BitwiseOr, a, b, loc)
     }
 
-    // TODO(antoyo): can we use https://github.com/rust-lang/compiler-builtins/blob/master/src/int/mod.rs#L379 instead?
+    // FIXME(antoyo): can we use https://github.com/rust-lang/compiler-builtins/blob/master/src/int/mod.rs#L379 instead?
     pub fn gcc_int_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
         let value_type = value.get_type();
         if self.is_native_int_type_or_bool(dest_typ) && self.is_native_int_type_or_bool(value_type)
         {
-            // TODO: use self.location.
+            // FIXME: use self.location.
             self.context.new_cast(None, value, dest_typ)
         } else if self.is_native_int_type_or_bool(dest_typ) {
             self.context.new_cast(None, self.low(value), dest_typ)
@@ -888,7 +888,7 @@ pub fn gcc_int_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<
             // Since u128 and i128 are the only types that can be unsupported, we know the type of
             // value and the destination type have the same size, so a bitcast is fine.
 
-            // TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
+            // FIXME(antoyo): perhaps use __builtin_convertvector for vector casting.
             self.context.new_bitcast(None, value, dest_typ)
         }
     }
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs b/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
index 11a69acdde42..60e007a25c68 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
@@ -123,7 +123,7 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
     mut args: Cow<'b, [RValue<'gcc>]>,
     func_name: &str,
 ) -> Cow<'b, [RValue<'gcc>]> {
-    // TODO: this might not be a good way to workaround the missing tile builtins.
+    // FIXME: this might not be a good way to workaround the missing tile builtins.
     if func_name == "__builtin_trap" {
         return vec![].into();
     }
@@ -1578,7 +1578,7 @@ pub fn intrinsic<'gcc, 'tcx>(name: &str, cx: &CodegenCx<'gcc, 'tcx>) -> Function
         "llvm.x86.avx512.uitofp.round.v8f32.v8i64" => "__builtin_ia32_cvtuqq2ps512_mask",
         "llvm.x86.avx512.uitofp.round.v4f32.v4i64" => "__builtin_ia32_cvtuqq2ps256_mask",
 
-        // TODO: support the tile builtins:
+        // FIXME: support the tile builtins:
         "llvm.x86.ldtilecfg" => "__builtin_trap",
         "llvm.x86.sttilecfg" => "__builtin_trap",
         "llvm.x86.tileloadd64" => "__builtin_trap",
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index fb1127ab4f48..2d343578062f 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -68,8 +68,8 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         sym::fmaf32 => "fmaf",
         sym::fmaf64 => "fma",
         // FIXME: calling `fma` from libc without FMA target feature uses expensive software emulation
-        sym::fmuladdf32 => "fmaf", // TODO: use gcc intrinsic analogous to llvm.fmuladd.f32
-        sym::fmuladdf64 => "fma",  // TODO: use gcc intrinsic analogous to llvm.fmuladd.f64
+        sym::fmuladdf32 => "fmaf", // FIXME: use gcc intrinsic analogous to llvm.fmuladd.f32
+        sym::fmuladdf64 => "fma",  // FIXME: use gcc intrinsic analogous to llvm.fmuladd.f64
         sym::fabsf32 => "fabsf",
         sym::fabsf64 => "fabs",
         sym::minnumf32 => "fminf",
@@ -131,7 +131,7 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
     Some(cx.context.get_builtin_function(gcc_name))
 }
 
-// TODO(antoyo): We can probably remove these and use the fallback intrinsic implementation.
+// FIXME(antoyo): We can probably remove these and use the fallback intrinsic implementation.
 fn get_simple_function<'gcc, 'tcx>(
     cx: &CodegenCx<'gcc, 'tcx>,
     name: Symbol,
@@ -305,7 +305,7 @@ fn codegen_intrinsic_call(
         let fn_args = instance.args;
 
         let simple = get_simple_intrinsic(self, name);
-        // TODO(antoyo): Only call get_simple_function_f128 and get_simple_function_f128_2args when
+        // FIXME(antoyo): Only call get_simple_function_f128 and get_simple_function_f128_2args when
         // it is the symbols for the supported f128 builtins.
         let simple_func = get_simple_function(self, name)
             .or_else(|| get_simple_function_f128(self, name))
@@ -406,7 +406,7 @@ fn codegen_intrinsic_call(
             sym::volatile_load | sym::unaligned_volatile_load => {
                 let ptr = args[0].immediate();
                 let load = self.volatile_load(result.layout.gcc_type(self), ptr);
-                // TODO(antoyo): set alignment.
+                // FIXME(antoyo): set alignment.
                 if let BackendRepr::Scalar(scalar) = result.layout.backend_repr {
                     self.to_immediate_scalar(load, scalar)
                 } else {
@@ -697,14 +697,14 @@ fn abort(&mut self) {
     }
 
     fn assume(&mut self, value: Self::Value) {
-        // TODO(antoyo): switch to assume when it exists.
+        // FIXME(antoyo): switch to assume when it exists.
         // Or use something like this:
         // #define __assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
         self.expect(value, true);
     }
 
     fn expect(&mut self, cond: Self::Value, _expected: bool) -> Self::Value {
-        // TODO(antoyo)
+        // FIXME(antoyo)
         cond
     }
 
@@ -723,7 +723,7 @@ fn va_start(&mut self, _va_list: RValue<'gcc>) -> RValue<'gcc> {
     }
 
     fn va_end(&mut self, _va_list: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): implement.
+        // FIXME(antoyo): implement.
         self.context.new_rvalue_from_int(self.int_type, 0)
     }
 }
@@ -945,7 +945,7 @@ fn bit_reverse(&mut self, width: u64, value: RValue<'gcc>) -> RValue<'gcc> {
                 if width == 8 { step3 } else { self.gcc_bswap(step3, width) }
             }
             128 => {
-                // TODO(antoyo): find a more efficient implementation?
+                // FIXME(antoyo): find a more efficient implementation?
                 let sixty_four = self.gcc_int(typ, 64);
                 let right_shift = self.gcc_lshr(value, sixty_four);
                 let high = self.gcc_int_cast(right_shift, self.u64_type);
@@ -1026,7 +1026,7 @@ fn use_builtin_function<'a, 'gcc, 'tcx>(
             builder.context.new_cast(builder.location, res, builder.u32_type)
         }
 
-        // TODO(antoyo): use width?
+        // FIXME(antoyo): use width?
         let result_type = self.u32_type;
         let mut arg_type = arg.get_type();
         let arg = if arg_type.is_signed(self.cx) {
@@ -1035,7 +1035,7 @@ fn use_builtin_function<'a, 'gcc, 'tcx>(
         } else {
             arg
         };
-        // TODO(antoyo): write a new function Type::is_compatible_with(&Type) and use it here
+        // FIXME(antoyo): write a new function Type::is_compatible_with(&Type) and use it here
         // instead of using is_uint().
         if arg_type.is_uchar(self.cx) || arg_type.is_ushort(self.cx) || arg_type.is_uint(self.cx) {
             let builtin = if count_leading { "__builtin_clz" } else { "__builtin_ctz" };
@@ -1139,7 +1139,7 @@ fn count_trailing_zeroes_nonzero(&mut self, width: u64, arg: RValue<'gcc>) -> RV
     }
 
     fn pop_count(&mut self, value: RValue<'gcc>) -> RValue<'gcc> {
-        // TODO(antoyo): use the optimized version with fewer operations.
+        // FIXME(antoyo): use the optimized version with fewer operations.
         let result_type = self.u32_type;
         let arg_type = value.get_type();
         let value_type = arg_type.to_unsigned(self.cx);
@@ -1148,7 +1148,7 @@ fn pop_count(&mut self, value: RValue<'gcc>) -> RValue<'gcc> {
             if arg_type.is_signed(self.cx) { self.gcc_int_cast(value, value_type) } else { value };
 
         // only break apart 128-bit ints if they're not natively supported
-        // TODO(antoyo): remove this if/when native 128-bit integers land in libgccjit
+        // FIXME(antoyo): remove this if/when native 128-bit integers land in libgccjit
         if value_type.is_u128(self.cx) && !self.cx.supports_128bit_integers {
             let sixty_four = self.gcc_int(value_type, 64);
             let right_shift = self.gcc_lshr(value, sixty_four);
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index eab067a02b7b..1263b2285a8d 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -53,7 +53,7 @@ macro_rules! require_simd {
         };
     }
 
-    // TODO(antoyo): refactor with the above require_simd macro that was changed in cg_llvm.
+    // FIXME(antoyo): refactor with the above require_simd macro that was changed in cg_llvm.
     #[cfg(feature = "master")]
     macro_rules! require_simd2 {
         ($ty: expr, $variant:ident) => {{
@@ -473,14 +473,14 @@ macro_rules! require_simd2 {
             }
         );
 
-        // TODO(antoyo): For simd_insert, check if the index is a constant of the correct size.
+        // FIXME(antoyo): For simd_insert, check if the index is a constant of the correct size.
         let vector = args[0].immediate();
         let index = args[1].immediate();
         let value = args[2].immediate();
         let variable = bx.current_func().new_local(None, vector.get_type(), "new_vector");
         bx.llbb().add_assignment(None, variable, vector);
         let lvalue = bx.context.new_vector_access(None, variable.to_rvalue(), index);
-        // TODO(antoyo): if simd_insert is constant, use BIT_REF.
+        // FIXME(antoyo): if simd_insert is constant, use BIT_REF.
         bx.llbb().add_assignment(None, lvalue, value);
         return Ok(variable.to_rvalue());
     }
@@ -491,7 +491,7 @@ macro_rules! require_simd2 {
             ret_ty == in_elem,
             InvalidMonomorphization::ReturnType { span, name, in_elem, in_ty, ret_ty }
         );
-        // TODO(antoyo): For simd_extract, check if the index is a constant of the correct size.
+        // FIXME(antoyo): For simd_extract, check if the index is a constant of the correct size.
         let vector = args[0].immediate();
         let index = args[1].immediate();
         return Ok(bx.context.new_vector_access(None, vector, index).to_rvalue());
@@ -737,7 +737,7 @@ macro_rules! arith_binary {
         // endian and MSB-first for big endian.
 
         let vector = args[0].immediate();
-        // TODO(antoyo): dyncast_vector should not require a call to unqualified.
+        // FIXME(antoyo): dyncast_vector should not require a call to unqualified.
         let vector_type = vector.get_type().unqualified().dyncast_vector().expect("vector type");
         let elem_type = vector_type.get_element_type();
 
@@ -832,7 +832,7 @@ macro_rules! return_error {
 
         let intr_name = match name {
             sym::simd_ceil => "ceil",
-            sym::simd_fabs => "fabs", // TODO(antoyo): pand with 170141183420855150465331762880109871103
+            sym::simd_fabs => "fabs", // FIXME(antoyo): pand with 170141183420855150465331762880109871103
             sym::simd_fcos => "cos",
             sym::simd_fexp2 => "exp2",
             sym::simd_fexp => "exp",
@@ -852,7 +852,7 @@ macro_rules! return_error {
         let builtin_name = format!("{}{}", intr_name, elem_ty_str);
         let function = bx.context.get_builtin_function(builtin_name);
 
-        // TODO(antoyo): add platform-specific behavior here for architectures that have these
+        // FIXME(antoyo): add platform-specific behavior here for architectures that have these
         // intrinsics as instructions (for instance, gpus)
         let mut vector_elements = vec![];
         for i in 0..in_len {
@@ -1060,7 +1060,7 @@ fn non_ptr(t: Ty<'_>) -> Ty<'_> {
         assert_eq!(underlying_ty, non_ptr(element_ty0));
 
         // The element type of the third argument must be an integer type of any width:
-        // TODO: also support unsigned integers.
+        // FIXME: also support unsigned integers.
         let (_, element_ty2) = args[2].layout.ty.simd_size_and_type(bx.tcx());
         match *element_ty2.kind() {
             ty::Int(_) => (),
@@ -1175,7 +1175,7 @@ fn non_ptr(t: Ty<'_>) -> Ty<'_> {
         assert_eq!(underlying_ty, non_ptr(element_ty0));
 
         // The element type of the third argument must be a signed integer type of any width:
-        // TODO: also support unsigned integers.
+        // FIXME: also support unsigned integers.
         match *element_ty2.kind() {
             ty::Int(_) => (),
             _ => {
@@ -1273,10 +1273,10 @@ macro_rules! arith_unary {
             }
             (true, true) => {
                 // Algorithm from: https://codereview.stackexchange.com/questions/115869/saturated-signed-addition
-                // TODO(antoyo): improve using conditional operators if possible.
-                // TODO(antoyo): dyncast_vector should not require a call to unqualified.
+                // FIXME(antoyo): improve using conditional operators if possible.
+                // FIXME(antoyo): dyncast_vector should not require a call to unqualified.
                 let arg_type = lhs.get_type().unqualified();
-                // TODO(antoyo): convert lhs and rhs to unsigned.
+                // FIXME(antoyo): convert lhs and rhs to unsigned.
                 let sum = lhs + rhs;
                 let vector_type = arg_type.dyncast_vector().expect("vector type");
                 let unit = vector_type.get_num_units();
@@ -1308,13 +1308,13 @@ macro_rules! arith_unary {
                 res & cmp
             }
             (true, false) => {
-                // TODO(antoyo): dyncast_vector should not require a call to unqualified.
+                // FIXME(antoyo): dyncast_vector should not require a call to unqualified.
                 let arg_type = lhs.get_type().unqualified();
-                // TODO(antoyo): this uses the same algorithm from saturating add, but add the
+                // FIXME(antoyo): this uses the same algorithm from saturating add, but add the
                 // negative of the right operand. Find a proper subtraction algorithm.
                 let rhs = bx.context.new_unary_op(None, UnaryOp::Minus, arg_type, rhs);
 
-                // TODO(antoyo): convert lhs and rhs to unsigned.
+                // FIXME(antoyo): convert lhs and rhs to unsigned.
                 let sum = lhs + rhs;
                 let vector_type = arg_type.dyncast_vector().expect("vector type");
                 let unit = vector_type.get_num_units();
@@ -1391,7 +1391,7 @@ macro_rules! arith_red {
         vector_reduce_fadd_reassoc,
         false,
         add,
-        0.0 // TODO: Use this argument.
+        0.0 // FIXME: Use this argument.
     );
     arith_red!(
         simd_reduce_mul_unordered: BinaryOp::Mult,
@@ -1507,7 +1507,7 @@ macro_rules! bitwise_red {
         // those lanes whose `mask` bit is enabled.
         // The memory addresses corresponding to the “off” lanes are not accessed.
 
-        // TODO: handle the alignment.
+        // FIXME: handle the alignment.
 
         // The element type of the "mask" argument must be a signed integer type of any width
         let mask_ty = in_ty;
@@ -1595,7 +1595,7 @@ macro_rules! bitwise_red {
         // those lanes whose `mask` bit is enabled.
         // The memory addresses corresponding to the “off” lanes are not accessed.
 
-        // TODO: handle the alignment.
+        // FIXME: handle the alignment.
 
         // The element type of the "mask" argument must be a signed integer type of any width
         let mask_ty = in_ty;
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 592eb68ce275..bf13f0b2127b 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -1,5 +1,5 @@
 /*
- * TODO(antoyo): implement equality in libgccjit based on https://zpz.github.io/blog/overloading-equality-operator-in-cpp-class-hierarchy/ (for type equality?)
+ * FIXME(antoyo): implement equality in libgccjit based on https://zpz.github.io/blog/overloading-equality-operator-in-cpp-class-hierarchy/ (for type equality?)
  * For Thin LTO, this might be helpful:
 // cspell:disable-next-line
  * In gcc 4.6 -fwhopr was removed and became default with -flto. The non-whopr path can still be executed via -flto-partition=none.
@@ -8,9 +8,9 @@
  * Maybe some missing optimizations enabled by rustc's LTO is in there: https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
 // cspell:disable-next-line
  * Like -fipa-icf (should be already enabled) and maybe -fdevirtualize-at-ltrans.
- * TODO: disable debug info always being emitted. Perhaps this slows down things?
+ * FIXME: disable debug info always being emitted. Perhaps this slows down things?
  *
- * TODO(antoyo): remove the patches.
+ * FIXME(antoyo): remove the patches.
  */
 
 #![feature(rustc_private)]
@@ -328,7 +328,7 @@ fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> {
             version,
         ));
     }
-    // TODO(antoyo): check if this should only be added when using -Cforce-unwind-tables=n.
+    // FIXME(antoyo): check if this should only be added when using -Cforce-unwind-tables=n.
     context.add_command_line_option("-fno-asynchronous-unwind-tables");
     context
 }
@@ -425,7 +425,7 @@ fn target_machine_factory(
         _opt_level: OptLevel,
         _features: &[String],
     ) -> TargetMachineFactoryFn<Self> {
-        // TODO(antoyo): set opt level.
+        // FIXME(antoyo): set opt level.
         Arc::new(|_, _| ())
     }
 
@@ -531,7 +531,7 @@ fn target_config(sess: &Session, target_info: &LockedTargetInfo) -> TargetConfig
         sess,
         |feature| to_gcc_features(sess, feature),
         |feature| {
-            // TODO: we disable Neon for now since we don't support the LLVM intrinsics for it.
+            // FIXME: we disable Neon for now since we don't support the LLVM intrinsics for it.
             if feature == "neon" {
                 return false;
             }
diff --git a/compiler/rustc_codegen_gcc/src/mono_item.rs b/compiler/rustc_codegen_gcc/src/mono_item.rs
index 31c03eddaca5..1429738a7e7a 100644
--- a/compiler/rustc_codegen_gcc/src/mono_item.rs
+++ b/compiler/rustc_codegen_gcc/src/mono_item.rs
@@ -37,7 +37,7 @@ fn predefine_static(
         #[cfg(feature = "master")]
         global.add_attribute(VarAttribute::Visibility(base::visibility_to_gcc(visibility)));
 
-        // TODO(antoyo): set linkage.
+        // FIXME(antoyo): set linkage.
         self.instances.borrow_mut().insert(instance, global);
     }
 
@@ -69,9 +69,9 @@ fn predefine_fn(
             decl.add_attribute(FnAttribute::Visibility(base::visibility_to_gcc(visibility)));
         }
 
-        // TODO(antoyo): call set_link_section() to allow initializing argc/argv.
-        // TODO(antoyo): set unique comdat.
-        // TODO(antoyo): use inline attribute from there in linkage.set() above.
+        // FIXME(antoyo): call set_link_section() to allow initializing argc/argv.
+        // FIXME(antoyo): set unique comdat.
+        // FIXME(antoyo): use inline attribute from there in linkage.set() above.
 
         self.functions.borrow_mut().insert(symbol_name.to_string(), decl);
         self.function_instances.borrow_mut().insert(instance, decl);
diff --git a/compiler/rustc_codegen_gcc/src/type_.rs b/compiler/rustc_codegen_gcc/src/type_.rs
index 3b1ee53f8336..5252f93a92eb 100644
--- a/compiler/rustc_codegen_gcc/src/type_.rs
+++ b/compiler/rustc_codegen_gcc/src/type_.rs
@@ -66,7 +66,7 @@ pub fn type_ptr_to(&self, ty: Type<'gcc>) -> Type<'gcc> {
     }
 
     pub fn type_ptr_to_ext(&self, ty: Type<'gcc>, _address_space: AddressSpace) -> Type<'gcc> {
-        // TODO(antoyo): use address_space, perhaps with TYPE_ADDR_SPACE?
+        // FIXME(antoyo): use address_space, perhaps with TYPE_ADDR_SPACE?
         ty.make_pointer()
     }
 
@@ -110,7 +110,7 @@ pub fn type_struct(&self, fields: &[Type<'gcc>], packed: bool) -> Type<'gcc> {
             .iter()
             .enumerate()
             .map(|(index, field)| {
-                self.context.new_field(None, *field, format!("field{}_TODO", index))
+                self.context.new_field(None, *field, format!("field{}_FIXME", index))
             })
             .collect();
         let typ = self.context.new_struct_type(None, "struct", &fields).as_type();
@@ -213,7 +213,7 @@ fn type_kind(&self, typ: Type<'gcc>) -> TypeKind {
         } else if typ == self.type_void() {
             TypeKind::Void
         } else {
-            // TODO(antoyo): support other types.
+            // FIXME(antoyo): support other types.
             unimplemented!();
         }
     }
@@ -239,7 +239,7 @@ fn type_kind(&self, typ: Type<'gcc>) -> TypeKind {
         } else if typ == self.type_void() {
             TypeKind::Void
         } else {
-            // TODO(antoyo): support other types.
+            // FIXME(antoyo): support other types.
             unimplemented!();
         }
     }
@@ -288,7 +288,7 @@ fn float_width(&self, typ: Type<'gcc>) -> usize {
         } else {
             panic!("Cannot get width of float type {:?}", typ);
         }
-        // TODO(antoyo): support other sizes.
+        // FIXME(antoyo): support other sizes.
     }
 
     fn int_width(&self, typ: Type<'gcc>) -> u64 {
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index 48d1b0163909..988d50fc0231 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -221,7 +221,7 @@ fn gcc_type<'gcc>(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc> {
             let ty = match *self.ty.kind() {
                 // NOTE: we cannot remove this match like in the LLVM codegen because the call
                 // to fn_ptr_backend_type handle the on-stack attribute.
-                // TODO(antoyo): find a less hackish way to handle the on-stack attribute.
+                // FIXME(antoyo): find a less hackish way to handle the on-stack attribute.
                 ty::FnPtr(sig_tys, hdr) => cx
                     .fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig_tys.with(hdr), ty::List::empty())),
                 _ => self.scalar_gcc_type_at(cx, scalar, Size::ZERO),
@@ -320,7 +320,7 @@ fn scalar_pair_element_gcc_type<'gcc>(
         // immediate, just like `bool` is typically `i8` in memory and only `i1`
         // when immediate.  We need to load/store `bool` as `i8` to avoid
         // crippling LLVM optimizations or triggering other LLVM bugs with `i1`.
-        // TODO(antoyo): this bugs certainly don't happen in this case since the bool type is used instead of i1.
+        // FIXME(antoyo): this bugs certainly don't happen in this case since the bool type is used instead of i1.
         if scalar.is_bool() {
             return cx.type_i1();
         }
diff --git a/compiler/rustc_codegen_gcc/tests/lang_tests_common.rs b/compiler/rustc_codegen_gcc/tests/lang_tests_common.rs
index 0f2cb9231062..fb3e0f0d8f1f 100644
--- a/compiler/rustc_codegen_gcc/tests/lang_tests_common.rs
+++ b/compiler/rustc_codegen_gcc/tests/lang_tests_common.rs
@@ -73,14 +73,14 @@ fn filter(filename: &Path) -> bool {
                 path.to_str().expect("to_str"),
             ]);
 
-            // TODO(antoyo): find a way to send this via a cli argument.
+            // FIXME(antoyo): find a way to send this via a cli argument.
             let test_target = std::env::var("CG_GCC_TEST_TARGET");
             if let Ok(ref target) = test_target {
                 compiler.args(["--target", target]);
                 let linker = format!("{}-gcc", target);
                 compiler.args(&[format!("-Clinker={}", linker)]);
                 let mut env_path = std::env::var("PATH").unwrap_or_default();
-                // TODO(antoyo): find a better way to add the PATH necessary locally.
+                // FIXME(antoyo): find a better way to add the PATH necessary locally.
                 env_path = format!("/opt/m68k-unknown-linux-gnu/bin:{}", env_path);
                 compiler.env("PATH", env_path);
             }
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index f79adb2eb598..ee35539221e6 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -103,9 +103,7 @@ fn emit_deprecated_safe_fn_call(&self, span: Span, kind: &UnsafeOpKind) -> bool
                 let guarantee = format!("that {}", suggestion);
                 let suggestion = sm
                     .indentation_before(span)
-                    .map(|indent| {
-                        format!("{}// TODO: Audit that {}.\n", indent, suggestion) // ignore-tidy-todo
-                    })
+                    .map(|indent| format!("{}// FIXME: Audit that {}.\n", indent, suggestion))
                     .unwrap_or_default();
 
                 self.tcx.emit_node_span_lint(
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index 9c12c480cacd..320ede50bb0c 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -79,7 +79,7 @@ pub fn insert(&self, symbol: Symbol, span: Span) {
     }
 }
 
-// todo: this function now accepts `Session` instead of `ParseSess` and should be relocated
+// FIXME: this function now accepts `Session` instead of `ParseSess` and should be relocated
 /// Construct a diagnostic for a language feature error due to the given `span`.
 /// The `feature`'s `Symbol` is the one you used in `unstable.rs` and `rustc_span::symbol`.
 #[track_caller]

From c4a8355c968464922175bdf3da00a01d93e2ddb1 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Fri, 27 Feb 2026 03:48:05 +0000
Subject: [PATCH 0190/1059] Change TODO in compiler to FIXME

---
 scripts/test_rustc_tests.sh | 2 +-
 src/intrinsics/mod.rs       | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/scripts/test_rustc_tests.sh b/scripts/test_rustc_tests.sh
index 4cad18f2a94f..8712b41c8f8f 100755
--- a/scripts/test_rustc_tests.sh
+++ b/scripts/test_rustc_tests.sh
@@ -175,7 +175,7 @@ rm -r tests/run-make/panic-abort-eh_frame # .eh_frame emitted with panic=abort
 
 # bugs in the test suite
 # ======================
-rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
+rm tests/ui/process/nofile-limit.rs # FIXME some AArch64 linking issue
 rm -r tests/ui/codegen/equal-pointers-unequal # make incorrect assumptions about the location of stack variables
 rm -r tests/incremental/extern_static/issue-49153.rs # assumes reference to undefined static gets optimized away
 
diff --git a/src/intrinsics/mod.rs b/src/intrinsics/mod.rs
index ab9a11305baa..c21453d84be0 100644
--- a/src/intrinsics/mod.rs
+++ b/src/intrinsics/mod.rs
@@ -356,10 +356,10 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::fmaf64 => ("fma", 3, fx.tcx.types.f64, types::F64),
         sym::fmaf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128),
         // FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
-        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f16
-        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f32
-        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f64
-        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f128
+        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f16
+        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f32
+        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f64
+        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f128
         sym::copysignf16 => ("copysignf16", 2, fx.tcx.types.f16, types::F16),
         sym::copysignf32 => ("copysignf", 2, fx.tcx.types.f32, types::F32),
         sym::copysignf64 => ("copysign", 2, fx.tcx.types.f64, types::F64),

From b91901d7513b98172420a6a5c860ecf68473efbb Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Sat, 7 Mar 2026 14:37:30 +0000
Subject: [PATCH 0191/1059] bless ui tests

---
 tests/ui/rust-2024/unsafe-before_exec-suggestion.fixed  | 2 +-
 tests/ui/rust-2024/unsafe-before_exec-suggestion.stderr | 2 +-
 tests/ui/rust-2024/unsafe-env-suggestion.fixed          | 4 ++--
 tests/ui/rust-2024/unsafe-env-suggestion.stderr         | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/ui/rust-2024/unsafe-before_exec-suggestion.fixed b/tests/ui/rust-2024/unsafe-before_exec-suggestion.fixed
index d850428cc1a5..da3e69489814 100644
--- a/tests/ui/rust-2024/unsafe-before_exec-suggestion.fixed
+++ b/tests/ui/rust-2024/unsafe-before_exec-suggestion.fixed
@@ -10,7 +10,7 @@ use std::os::unix::process::CommandExt;
 #[allow(deprecated)]
 fn main() {
     let mut cmd = Command::new("sleep");
-    // TODO: Audit that the closure is async-signal-safe.
+    // FIXME: Audit that the closure is async-signal-safe.
     unsafe { cmd.before_exec(|| Ok(())) };
     //~^ ERROR call to deprecated safe function
     //~| WARN this is accepted in the current edition
diff --git a/tests/ui/rust-2024/unsafe-before_exec-suggestion.stderr b/tests/ui/rust-2024/unsafe-before_exec-suggestion.stderr
index 33893f30ceca..d4b961df55ee 100644
--- a/tests/ui/rust-2024/unsafe-before_exec-suggestion.stderr
+++ b/tests/ui/rust-2024/unsafe-before_exec-suggestion.stderr
@@ -13,7 +13,7 @@ LL | #![deny(deprecated_safe_2024)]
    |         ^^^^^^^^^^^^^^^^^^^^
 help: you can wrap the call in an `unsafe` block if you can guarantee that the closure is async-signal-safe
    |
-LL +     // TODO: Audit that the closure is async-signal-safe.
+LL +     // FIXME: Audit that the closure is async-signal-safe.
 LL ~     unsafe { cmd.before_exec(|| Ok(())) };
    |
 
diff --git a/tests/ui/rust-2024/unsafe-env-suggestion.fixed b/tests/ui/rust-2024/unsafe-env-suggestion.fixed
index 912d082832c4..183e67af6fae 100644
--- a/tests/ui/rust-2024/unsafe-env-suggestion.fixed
+++ b/tests/ui/rust-2024/unsafe-env-suggestion.fixed
@@ -7,11 +7,11 @@ use std::env;
 
 #[deny(unused_unsafe)]
 fn main() {
-    // TODO: Audit that the environment access only happens in single-threaded code.
+    // FIXME: Audit that the environment access only happens in single-threaded code.
     unsafe { env::set_var("FOO", "BAR") };
     //~^ ERROR call to deprecated safe function
     //~| WARN this is accepted in the current edition
-    // TODO: Audit that the environment access only happens in single-threaded code.
+    // FIXME: Audit that the environment access only happens in single-threaded code.
     unsafe { env::remove_var("FOO") };
     //~^ ERROR call to deprecated safe function
     //~| WARN this is accepted in the current edition
diff --git a/tests/ui/rust-2024/unsafe-env-suggestion.stderr b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
index 151e80bb5d9e..234d77b2dc9f 100644
--- a/tests/ui/rust-2024/unsafe-env-suggestion.stderr
+++ b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
@@ -13,7 +13,7 @@ LL | #![deny(deprecated_safe_2024)]
    |         ^^^^^^^^^^^^^^^^^^^^
 help: you can wrap the call in an `unsafe` block if you can guarantee that the environment access only happens in single-threaded code
    |
-LL +     // TODO: Audit that the environment access only happens in single-threaded code.
+LL +     // FIXME: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::set_var("FOO", "BAR") };
    |
 
@@ -27,7 +27,7 @@ LL |     env::remove_var("FOO");
    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/newly-unsafe-functions.html>
 help: you can wrap the call in an `unsafe` block if you can guarantee that the environment access only happens in single-threaded code
    |
-LL +     // TODO: Audit that the environment access only happens in single-threaded code.
+LL +     // FIXME: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::remove_var("FOO") };
    |
 

From ff7e604154380a4ccf22e45b1c8bf65add085b49 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Fri, 13 Feb 2026 10:28:54 +0000
Subject: [PATCH 0192/1059] Stop using rustc_layout_scalar_valid_range_* in
 rustc

---
 compiler/rustc_abi/src/layout.rs              |  4 +-
 compiler/rustc_data_structures/src/lib.rs     |  2 +
 compiler/rustc_hir_id/src/lib.rs              |  2 +-
 compiler/rustc_index_macros/src/lib.rs        | 12 ++-
 compiler/rustc_index_macros/src/newtype.rs    | 83 ++++++++++++++++---
 compiler/rustc_middle/src/middle/region.rs    |  2 +-
 compiler/rustc_middle/src/mir/coverage.rs     |  8 +-
 compiler/rustc_middle/src/mir/mod.rs          |  8 +-
 compiler/rustc_middle/src/mir/query.rs        |  2 +-
 compiler/rustc_middle/src/thir.rs             |  2 +-
 .../rustc_middle/src/ty/typeck_results.rs     |  2 +-
 .../rustc_mir_transform/src/jump_threading.rs |  2 +-
 .../src/graph_checks/statics.rs               |  2 +-
 compiler/rustc_type_ir/src/lib.rs             |  6 +-
 compiler/rustc_type_ir/src/region_kind.rs     |  4 +-
 15 files changed, 107 insertions(+), 34 deletions(-)

diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 2351d58d8e82..ed2d603bf1ff 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -45,7 +45,7 @@
     /// `b` is `FieldIdx(1)` in `VariantIdx(0)`,
     /// `d` is `FieldIdx(1)` in `VariantIdx(1)`, and
     /// `f` is `FieldIdx(1)` in `VariantIdx(0)`.
-    #[cfg_attr(feature = "nightly", derive(rustc_macros::HashStable_Generic))]
+    #[stable_hash_generic]
     #[encodable]
     #[orderable]
     #[gate_rustc_only]
@@ -70,7 +70,7 @@ impl FieldIdx {
     ///
     /// `struct`s, `tuples`, and `unions`s are considered to have a single variant
     /// with variant index zero, aka [`FIRST_VARIANT`].
-    #[cfg_attr(feature = "nightly", derive(rustc_macros::HashStable_Generic))]
+    #[stable_hash_generic]
     #[encodable]
     #[orderable]
     #[gate_rustc_only]
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index b01834aa80d9..e34c14c78c8f 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -28,6 +28,8 @@
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(never_type)]
+#![feature(pattern_type_macro)]
+#![feature(pattern_types)]
 #![feature(ptr_alignment_type)]
 #![feature(rustc_attrs)]
 #![feature(sized_hierarchy)]
diff --git a/compiler/rustc_hir_id/src/lib.rs b/compiler/rustc_hir_id/src/lib.rs
index d07bc88e66af..d6deed59b625 100644
--- a/compiler/rustc_hir_id/src/lib.rs
+++ b/compiler/rustc_hir_id/src/lib.rs
@@ -151,7 +151,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     /// integers starting at zero, so a mapping that maps all or most nodes within
     /// an "item-like" to something else can be implemented by a `Vec` instead of a
     /// tree or hash map.
-    #[derive(HashStable_Generic)]
+    #[stable_hash_generic]
     #[encodable]
     #[orderable]
     pub struct ItemLocalId {}
diff --git a/compiler/rustc_index_macros/src/lib.rs b/compiler/rustc_index_macros/src/lib.rs
index 2b444932f854..96424b0ebcc7 100644
--- a/compiler/rustc_index_macros/src/lib.rs
+++ b/compiler/rustc_index_macros/src/lib.rs
@@ -34,7 +34,17 @@
 ///   optimizations. The default max value is 0xFFFF_FF00.
 /// - `#[gate_rustc_only]`: makes parts of the generated code nightly-only.
 #[proc_macro]
-#[cfg_attr(feature = "nightly", allow_internal_unstable(step_trait, rustc_attrs, trusted_step))]
+#[cfg_attr(
+    feature = "nightly",
+    allow_internal_unstable(
+        step_trait,
+        rustc_attrs,
+        trusted_step,
+        pattern_types,
+        pattern_type_macro,
+        structural_match,
+    )
+)]
 pub fn newtype_index(input: TokenStream) -> TokenStream {
     newtype::newtype(input)
 }
diff --git a/compiler/rustc_index_macros/src/newtype.rs b/compiler/rustc_index_macros/src/newtype.rs
index eedbe630cf2c..282403294db9 100644
--- a/compiler/rustc_index_macros/src/newtype.rs
+++ b/compiler/rustc_index_macros/src/newtype.rs
@@ -18,12 +18,14 @@ fn parse(input: ParseStream<'_>) -> Result<Self> {
         braced!(body in input);
 
         // Any additional `#[derive]` macro paths to apply
-        let mut derive_paths: Vec<Path> = Vec::new();
         let mut debug_format: Option<Lit> = None;
         let mut max = None;
         let mut consts = Vec::new();
         let mut encodable = false;
         let mut ord = false;
+        let mut stable_hash = false;
+        let mut stable_hash_generic = false;
+        let mut stable_hash_no_context = false;
         let mut gate_rustc_only = quote! {};
         let mut gate_rustc_only_cfg = quote! { all() };
 
@@ -42,6 +44,18 @@ fn parse(input: ParseStream<'_>) -> Result<Self> {
                     ord = true;
                     false
                 }
+                "stable_hash" => {
+                    stable_hash = true;
+                    false
+                }
+                "stable_hash_generic" => {
+                    stable_hash_generic = true;
+                    false
+                }
+                "stable_hash_no_context" => {
+                    stable_hash_no_context = true;
+                    false
+                }
                 "max" => {
                     let Meta::NameValue(MetaNameValue { value: Expr::Lit(lit), .. }) = &attr.meta
                     else {
@@ -111,12 +125,6 @@ fn encode(&self, e: &mut E) {
         } else {
             quote! {}
         };
-
-        if ord {
-            derive_paths.push(parse_quote!(Ord));
-            derive_paths.push(parse_quote!(PartialOrd));
-        }
-
         let step = if ord {
             quote! {
                 #gate_rustc_only
@@ -139,6 +147,38 @@ fn backward_checked(start: Self, u: usize) -> Option<Self> {
                         Self::index(start).checked_sub(u).map(Self::from_usize)
                     }
                 }
+                impl ::std::cmp::Ord for #name {
+                    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+                        self.as_u32().cmp(&other.as_u32())
+                    }
+                }
+                impl ::std::cmp::PartialOrd for #name {
+                    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+                        self.as_u32().partial_cmp(&other.as_u32())
+                    }
+                }
+            }
+        } else {
+            quote! {}
+        };
+
+        let hash_stable = if stable_hash {
+            quote! {
+                #gate_rustc_only
+                impl<'__ctx> ::rustc_data_structures::stable_hasher::HashStable<::rustc_middle::ich::StableHashingContext<'__ctx>> for #name {
+                    fn hash_stable(&self, hcx: &mut ::rustc_middle::ich::StableHashingContext<'__ctx>, hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher) {
+                        self.as_u32().hash_stable(hcx, hasher)
+                    }
+                }
+            }
+        } else if stable_hash_generic || stable_hash_no_context {
+            quote! {
+                #gate_rustc_only
+                impl<CTX> ::rustc_data_structures::stable_hasher::HashStable<CTX> for #name {
+                    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher) {
+                        self.as_u32().hash_stable(hcx, hasher)
+                    }
+                }
             }
         } else {
             quote! {}
@@ -154,11 +194,13 @@ fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
 
         Ok(Self(quote! {
             #(#attrs)*
-            #[derive(Clone, Copy, PartialEq, Eq, Hash, #(#derive_paths),*)]
-            #[cfg_attr(#gate_rustc_only_cfg, rustc_layout_scalar_valid_range_end(#max))]
+            #[derive(Clone, Copy)]
             #[cfg_attr(#gate_rustc_only_cfg, rustc_pass_by_value)]
             #vis struct #name {
+                #[cfg(not(#gate_rustc_only_cfg))]
                 private_use_as_methods_instead: u32,
+                #[cfg(#gate_rustc_only_cfg)]
+                private_use_as_methods_instead: pattern_type!(u32 is 0..=#max),
             }
 
             #(#consts)*
@@ -226,7 +268,7 @@ impl #name {
                 /// Prefer using `from_u32`.
                 #[inline]
                 #vis const unsafe fn from_u32_unchecked(value: u32) -> Self {
-                    Self { private_use_as_methods_instead: value }
+                    Self { private_use_as_methods_instead: unsafe { std::mem::transmute(value) } }
                 }
 
                 /// Extracts the value of this index as a `usize`.
@@ -238,7 +280,7 @@ impl #name {
                 /// Extracts the value of this index as a `u32`.
                 #[inline]
                 #vis const fn as_u32(self) -> u32 {
-                    self.private_use_as_methods_instead
+                    unsafe { std::mem::transmute(self.private_use_as_methods_instead) }
                 }
 
                 /// Extracts the value of this index as a `usize`.
@@ -278,6 +320,8 @@ fn index(self) -> usize {
 
             #step
 
+            #hash_stable
+
             impl From<#name> for u32 {
                 #[inline]
                 fn from(v: #name) -> u32 {
@@ -306,6 +350,23 @@ fn from(value: u32) -> Self {
                 }
             }
 
+            impl ::std::cmp::Eq for #name {}
+
+            impl ::std::cmp::PartialEq for #name {
+                fn eq(&self, other: &Self) -> bool {
+                    self.as_u32().eq(&other.as_u32())
+                }
+            }
+
+            #gate_rustc_only
+            impl ::std::marker::StructuralPartialEq for #name {}
+
+            impl ::std::hash::Hash for #name {
+                fn hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
+                    self.as_u32().hash(state)
+                }
+            }
+
             #encodable_impls
             #debug_impl
         }))
diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs
index 990ed8f48fb8..678520e8ce0c 100644
--- a/compiler/rustc_middle/src/middle/region.rs
+++ b/compiler/rustc_middle/src/middle/region.rs
@@ -159,7 +159,7 @@ pub enum ScopeData {
     ///
     /// * The subscope with `first_statement_index == 1` is scope of `c`,
     ///   and thus does not include EXPR_2, but covers the `...`.
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     pub struct FirstStatementIndex {}
diff --git a/compiler/rustc_middle/src/mir/coverage.rs b/compiler/rustc_middle/src/mir/coverage.rs
index fd4c64b9a61c..0bf5094a27c0 100644
--- a/compiler/rustc_middle/src/mir/coverage.rs
+++ b/compiler/rustc_middle/src/mir/coverage.rs
@@ -10,7 +10,7 @@
 rustc_index::newtype_index! {
     /// Used by [`CoverageKind::BlockMarker`] to mark blocks during THIR-to-MIR
     /// lowering, so that those blocks can be identified later.
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[debug_format = "BlockMarkerId({})"]
     pub struct BlockMarkerId {}
@@ -26,7 +26,7 @@ pub struct BlockMarkerId {}
     ///
     /// Note that LLVM handles counter IDs as `uint32_t`, so there is no need
     /// to use a larger representation on the Rust side.
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "CounterId({})"]
@@ -43,7 +43,7 @@ pub struct CounterId {}
     ///
     /// Note that LLVM handles expression IDs as `uint32_t`, so there is no need
     /// to use a larger representation on the Rust side.
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "ExpressionId({})"]
@@ -203,7 +203,7 @@ pub struct CoverageIdsInfo {
     ///
     /// After that pass is complete, the coverage graph no longer exists, so a
     /// BCB is effectively an opaque ID.
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "bcb{}"]
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 8ac532ff4863..1ac8d46f95bd 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -840,7 +840,7 @@ pub fn outermost(span: Span) -> Self {
 // Variables and temps
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "_{}"]
@@ -1264,7 +1264,7 @@ pub struct VarDebugInfo<'tcx> {
     ///     https://rustc-dev-guide.rust-lang.org/appendix/background.html#what-is-a-dataflow-analysis
     /// [`CriticalCallEdges`]: ../../rustc_mir_transform/add_call_guards/enum.AddCallGuards.html#variant.CriticalCallEdges
     /// [guide-mir]: https://rustc-dev-guide.rust-lang.org/mir/
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "bb{}"]
@@ -1398,7 +1398,7 @@ pub fn drop_debuginfo(&mut self) {
 // Scopes
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[debug_format = "scope[{}]"]
     pub struct SourceScope {
@@ -1537,7 +1537,7 @@ pub struct UserTypeProjection {
 }
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[orderable]
     #[debug_format = "promoted[{}]"]
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
index 70954b4cb782..d7d5d63d45a7 100644
--- a/compiler/rustc_middle/src/mir/query.rs
+++ b/compiler/rustc_middle/src/mir/query.rs
@@ -13,7 +13,7 @@
 use crate::ty::{self, CoroutineArgsExt, Ty};
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[debug_format = "_s{}"]
     pub struct CoroutineSavedLocal {}
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 18456e763078..881165706a03 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -44,7 +44,7 @@ macro_rules! thir_with_elements {
     ) => {
         $(
             newtype_index! {
-                #[derive(HashStable)]
+                #[stable_hash]
                 #[debug_format = $format]
                 pub struct $id {}
             }
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 2c5e4957d0ae..b8399215cf81 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -716,7 +716,7 @@ pub fn remove(&mut self, id: hir::HirId) -> bool {
 }
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[stable_hash]
     #[encodable]
     #[debug_format = "UserType({})"]
     pub struct UserTypeAnnotationIndex {
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index 9e8de4926c6e..a1e5d810afc0 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -161,7 +161,7 @@ struct TOFinder<'a, 'tcx> {
 }
 
 rustc_index::newtype_index! {
-    #[derive(Ord, PartialOrd)]
+    #[orderable]
     #[debug_format = "_c{}"]
     struct ConditionIndex {}
 }
diff --git a/compiler/rustc_monomorphize/src/graph_checks/statics.rs b/compiler/rustc_monomorphize/src/graph_checks/statics.rs
index a764d307b3d4..90993e55906f 100644
--- a/compiler/rustc_monomorphize/src/graph_checks/statics.rs
+++ b/compiler/rustc_monomorphize/src/graph_checks/statics.rs
@@ -30,7 +30,7 @@ fn from(value: usize) -> Self {
 }
 
 newtype_index! {
-    #[derive(Ord, PartialOrd)]
+    #[orderable]
     struct StaticSccIdx {}
 }
 
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index 62965f947387..a0b444024ca7 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -123,7 +123,7 @@
     /// is the outer fn.
     ///
     /// [dbi]: https://en.wikipedia.org/wiki/De_Bruijn_index
-    #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+    #[stable_hash_no_context]
     #[encodable]
     #[orderable]
     #[debug_format = "DebruijnIndex({})"]
@@ -333,7 +333,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     /// declared, but a type name in a non-zero universe is a placeholder
     /// type -- an idealized representative of "types in general" that we
     /// use for checking generic functions.
-    #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+    #[stable_hash_no_context]
     #[encodable]
     #[orderable]
     #[debug_format = "U{}"]
@@ -388,7 +388,7 @@ fn default() -> Self {
 }
 
 rustc_index::newtype_index! {
-    #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+    #[stable_hash_generic]
     #[encodable]
     #[orderable]
     #[debug_format = "{}"]
diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs
index e08c274f9f14..6a2fb95e467f 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -4,7 +4,7 @@
 #[cfg(feature = "nightly")]
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 #[cfg(feature = "nightly")]
-use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
+use rustc_macros::{Decodable_NoContext, Encodable_NoContext};
 use rustc_type_ir_macros::GenericTypeVisitable;
 
 use self::RegionKind::*;
@@ -16,7 +16,7 @@
     #[orderable]
     #[debug_format = "'?{}"]
     #[gate_rustc_only]
-    #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+    #[stable_hash_no_context]
     pub struct RegionVid {}
 }
 

From 901cb4cf4006888dc69d95666886960c31e2c75a Mon Sep 17 00:00:00 2001
From: Albab-Hasan <albabhasan276@gmail.com>
Date: Sat, 7 Mar 2026 22:09:48 +0600
Subject: [PATCH 0193/1059] fix: implement ir_print debug for next-solver
 predicate types

seven IrPrint::print_debug implementations in the next-solver were
placeholder stubs that returned "TODO: <typename>" instead of meaningful
output. these are called via the Display impl (and Debug for PatternKind)
of these types, so any solver trace log containing them was unreadable.

implemented proper formatting for each:
- TraitPredicate      -> "T: Trait" / "!T: Trait"
- HostEffectPredicate -> "const T: Trait" / "[const] T: Trait"
- NormalizesTo        -> "AliasTerm(...) -> Term"
- SubtypePredicate    -> "A <: B"
- CoercePredicate     -> "A -> B"
- FnSig               -> "fn([inputs]) -> output"
- PatternKind         -> "start..=end" / "or([...])" / "!null"

also removed the now-unused type_name_of_val import.
---
 .../crates/hir-ty/src/next_solver/ir_print.rs | 29 +++++++++++++------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
index 998aab5a3fff..8569b828ae11 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
@@ -1,7 +1,5 @@
 //! Things related to IR printing in the next-trait-solver.
 
-use std::any::type_name_of_val;
-
 use rustc_type_ir::{self as ty, ir_print::IrPrint};
 
 use super::SolverDefId;
@@ -82,7 +80,10 @@ fn print_debug(
         t: &ty::TraitPredicate<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        match t.polarity {
+            ty::PredicatePolarity::Positive => write!(fmt, "{:?}", t.trait_ref),
+            ty::PredicatePolarity::Negative => write!(fmt, "!{:?}", t.trait_ref),
+        }
     }
 }
 impl<'db> IrPrint<rustc_type_ir::HostEffectPredicate<Self>> for DbInterner<'db> {
@@ -97,7 +98,11 @@ fn print_debug(
         t: &rustc_type_ir::HostEffectPredicate<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        let prefix = match t.constness {
+            ty::BoundConstness::Const => "const",
+            ty::BoundConstness::Maybe => "[const]",
+        };
+        write!(fmt, "{prefix} {:?}", t.trait_ref)
     }
 }
 impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
@@ -183,7 +188,7 @@ fn print_debug(
         t: &ty::NormalizesTo<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        write!(fmt, "{} -> {:?}", t.alias, t.term)
     }
 }
 impl<'db> IrPrint<ty::SubtypePredicate<Self>> for DbInterner<'db> {
@@ -198,7 +203,7 @@ fn print_debug(
         t: &ty::SubtypePredicate<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        write!(fmt, "{:?} <: {:?}", t.a, t.b)
     }
 }
 impl<'db> IrPrint<ty::CoercePredicate<Self>> for DbInterner<'db> {
@@ -210,7 +215,7 @@ fn print_debug(
         t: &ty::CoercePredicate<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        write!(fmt, "{:?} -> {:?}", t.a, t.b)
     }
 }
 impl<'db> IrPrint<ty::FnSig<Self>> for DbInterner<'db> {
@@ -219,7 +224,9 @@ fn print(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Re
     }
 
     fn print_debug(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        let tys = t.inputs_and_output.as_slice();
+        let (output, inputs) = tys.split_last().unwrap();
+        write!(fmt, "fn({:?}) -> {:?}", inputs, output)
     }
 }
 
@@ -235,6 +242,10 @@ fn print_debug(
         t: &rustc_type_ir::PatternKind<DbInterner<'db>>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+        match t {
+            ty::PatternKind::Range { start, end } => write!(fmt, "{:?}..={:?}", start, end),
+            ty::PatternKind::Or(list) => write!(fmt, "or({:?})", list),
+            ty::PatternKind::NotNull => fmt.write_str("!null"),
+        }
     }
 }

From c260a1fb50a1830dcf0d585022e168871024367a Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Thu, 5 Mar 2026 14:56:04 -0800
Subject: [PATCH 0194/1059] Update cfg(bootstrap)

---
 clippy_lints/src/lib.rs    | 1 -
 clippy_utils/src/lib.rs    | 2 --
 clippy_utils/src/ty/mod.rs | 3 ---
 3 files changed, 6 deletions(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4dca8dfe94d0..4d67c158c043 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(bootstrap, feature(if_let_guard))]
 #![feature(box_patterns)]
 #![feature(control_flow_into_value)]
 #![feature(exact_div)]
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 13c687a82b13..1e73e43e0a71 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,9 +1,7 @@
-#![cfg_attr(bootstrap, feature(if_let_guard))]
 #![feature(box_patterns)]
 #![feature(macro_metavar_expr)]
 #![feature(never_type)]
 #![feature(rustc_private)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![feature(unwrap_infallible)]
 #![recursion_limit = "512"]
 #![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index a9e29987bc32..af514778f968 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -28,10 +28,7 @@
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCause};
-#[cfg(bootstrap)]
-use std::assert_matches::debug_assert_matches;
 use std::collections::hash_map::Entry;
-#[cfg(not(bootstrap))]
 use std::debug_assert_matches;
 use std::{iter, mem};
 

From 1ecc9d7e04e9bb6a3bd16384d4f5e4a098d37e24 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 7 Mar 2026 20:01:38 +0100
Subject: [PATCH 0195/1059] Fix ICE in `match_same_arms`

The wrong `TypeckResults` was used in the fallback equality function
passed by the `match_same_arms` and `filter_map` lints. Previously,
those fallback functions had no way of using the proper `TypeckResults`.
Those (one per expression being compared) are now passed to the
registered fallback function.
---
 clippy_lints/src/matches/match_same_arms.rs |  9 ++++++---
 clippy_lints/src/methods/filter_map.rs      |  7 +++++--
 clippy_utils/src/hir_utils.rs               | 20 ++++++++++++++++----
 tests/ui/match_same_arms.fixed              | 16 ++++++++++++++++
 tests/ui/match_same_arms.rs                 | 16 ++++++++++++++++
 5 files changed, 59 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 5b0de80e67fd..a8312a04f36f 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -12,7 +12,7 @@
 use rustc_hir::{Arm, Expr, HirId, HirIdMap, HirIdMapEntry, HirIdSet, Pat, PatExpr, PatExprKind, PatKind, RangeEnd};
 use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, TypeckResults};
 use rustc_span::{ByteSymbol, ErrorGuaranteed, Span, Symbol};
 
 use super::MATCH_SAME_ARMS;
@@ -61,7 +61,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
 
         let check_eq_with_pat = |expr_a: &Expr<'_>, expr_b: &Expr<'_>| {
             let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            let eq_fallback = |a_typeck_results: &TypeckResults<'tcx>,
+                               a: &Expr<'_>,
+                               b_typeck_results: &TypeckResults<'tcx>,
+                               b: &Expr<'_>| {
                 if let Some(a_id) = a.res_local_id()
                     && let Some(b_id) = b.res_local_id()
                     && let entry = match local_map.entry(a_id) {
@@ -71,7 +74,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                     }
                     // the names technically don't have to match; this makes the lint more conservative
                     && cx.tcx.hir_name(a_id) == cx.tcx.hir_name(b_id)
-                    && cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
+                    && a_typeck_results.expr_ty(a) == b_typeck_results.expr_ty(b)
                     && pat_contains_local(lhs.pat, a_id)
                     && pat_contains_local(rhs.pat, b_id)
                 {
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 7b10c37de42d..d2e593fc17df 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -9,6 +9,7 @@
 use rustc_hir::def::Res;
 use rustc_hir::{Closure, Expr, ExprKind, PatKind, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
+use rustc_middle::ty::TypeckResults;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, Symbol};
@@ -136,7 +137,9 @@ pub fn check_map_call(
                     // .map(|y| y[.acceptable_method()].unwrap())
                     && let simple_equal = (receiver.res_local_id() == Some(filter_param_id)
                         && map_arg_peeled.res_local_id() == Some(map_param_id))
-                    && let eq_fallback = (|a: &Expr<'_>, b: &Expr<'_>| {
+                    && let eq_fallback =
+                    (|a_typeck_results: &TypeckResults<'tcx>, a: &Expr<'_>,
+                     b_typeck_results: &TypeckResults<'tcx>, b: &Expr<'_>| {
                         // in `filter(|x| ..)`, replace `*x` with `x`
                         let a_path = if !is_filter_param_ref
                             && let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind
@@ -144,7 +147,7 @@ pub fn check_map_call(
                         // let the filter closure arg and the map closure arg be equal
                         a_path.res_local_id() == Some(filter_param_id)
                             && b.res_local_id() == Some(map_param_id)
-                            && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
+                            && a_typeck_results.expr_ty_adjusted(a) == b_typeck_results.expr_ty_adjusted(b)
                     })
                     && (simple_equal
                         || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(receiver, map_arg_peeled))
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 4e9c64dd63c7..a4d8fd20e4d3 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -26,7 +26,8 @@
 
 /// Callback that is called when two expressions are not equal in the sense of `SpanlessEq`, but
 /// other conditions would make them equal.
-type SpanlessEqCallback<'a> = dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a;
+type SpanlessEqCallback<'a, 'tcx> =
+    dyn FnMut(&TypeckResults<'tcx>, &Expr<'_>, &TypeckResults<'tcx>, &Expr<'_>) -> bool + 'a;
 
 /// Determines how paths are hashed and compared for equality.
 #[derive(Copy, Clone, Debug, Default)]
@@ -59,7 +60,7 @@ pub struct SpanlessEq<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     maybe_typeck_results: Option<(&'tcx TypeckResults<'tcx>, &'tcx TypeckResults<'tcx>)>,
     allow_side_effects: bool,
-    expr_fallback: Option<Box<SpanlessEqCallback<'a>>>,
+    expr_fallback: Option<Box<SpanlessEqCallback<'a, 'tcx>>>,
     path_check: PathCheck,
 }
 
@@ -94,7 +95,10 @@ pub fn paths_by_resolution(self) -> Self {
     }
 
     #[must_use]
-    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+    pub fn expr_fallback(
+        self,
+        expr_fallback: impl FnMut(&TypeckResults<'tcx>, &Expr<'_>, &TypeckResults<'tcx>, &Expr<'_>) -> bool + 'a,
+    ) -> Self {
         Self {
             expr_fallback: Some(Box::new(expr_fallback)),
             ..self
@@ -639,7 +643,15 @@ pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
             ) => false,
         };
         (is_eq && (!self.should_ignore(left) || !self.should_ignore(right)))
-            || self.inner.expr_fallback.as_mut().is_some_and(|f| f(left, right))
+            || self
+                .inner
+                .maybe_typeck_results
+                .is_some_and(|(left_typeck_results, right_typeck_results)| {
+                    self.inner
+                        .expr_fallback
+                        .as_mut()
+                        .is_some_and(|f| f(left_typeck_results, left, right_typeck_results, right))
+                })
     }
 
     fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
diff --git a/tests/ui/match_same_arms.fixed b/tests/ui/match_same_arms.fixed
index 31684a5759fe..8b16fd3193f5 100644
--- a/tests/ui/match_same_arms.fixed
+++ b/tests/ui/match_same_arms.fixed
@@ -140,3 +140,19 @@ fn main() {
         _ => false,
     };
 }
+
+fn issue16678() {
+    // ICE in Rust 1.94.0
+    match true {
+        true => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+        false => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+    }
+}
diff --git a/tests/ui/match_same_arms.rs b/tests/ui/match_same_arms.rs
index 39bee01bac22..3b2d585c579d 100644
--- a/tests/ui/match_same_arms.rs
+++ b/tests/ui/match_same_arms.rs
@@ -149,3 +149,19 @@ fn main() {
         _ => false,
     };
 }
+
+fn issue16678() {
+    // ICE in Rust 1.94.0
+    match true {
+        true => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+        false => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+    }
+}

From 592246e2a13ad701ef8ed7dce4c4b7d1ae337983 Mon Sep 17 00:00:00 2001
From: Ada Bohm <ada@kreatrix.org>
Date: Sat, 7 Mar 2026 21:06:51 +0100
Subject: [PATCH 0196/1059] Added comments

---
 compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs    | 4 ++++
 .../traits/next-solver/find-param-recursion-issue-152716.rs   | 4 ++++
 .../next-solver/find-param-recursion-issue-152716.stderr      | 2 +-
 3 files changed, 9 insertions(+), 1 deletion(-)

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 bb0f16e153da..ace1fc400750 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -1261,6 +1261,10 @@ impl<D, I> TypeVisitor<I> for FindParamInClause<'_, '_, D, I>
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
+    // - `Continue(())`: no generic parameter was found, the type is global
+    // - `Break(Ok(Certainty::Yes))`: a generic parameter was found, the type is non-global
+    // - `Break(Ok(Certainty::Maybe(_)))`: the recursion limit reached, assume that the type is non-global
+    // - `Break(Err(NoSolution))`: normalization failed
     type Result = ControlFlow<Result<Certainty, NoSolution>>;
 
     fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
index e9635f709a99..648796483815 100644
--- a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.rs
@@ -1,6 +1,10 @@
 //@ compile-flags: -Znext-solver
 
 // Regression test for <https://github.com/rust-lang/rust/issues/152716>.
+//
+// This test checks that we hit the recursion limit for recursively defined projections.
+// Normalization of `<T as Proj<'b>>::Assoc` could introduce the same projection again.
+// Previously, we get into an infinite recursion.
 
 trait Trait<T> {}
 trait Proj<'a> {
diff --git a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
index 3aca6cfc9c5a..e2ee83cfadbe 100644
--- a/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
+++ b/tests/ui/traits/next-solver/find-param-recursion-issue-152716.stderr
@@ -1,5 +1,5 @@
 error[E0275]: overflow evaluating the requirement `(): Trait<<T as Proj<'static>>::Assoc>`
-  --> $DIR/find-param-recursion-issue-152716.rs:12:9
+  --> $DIR/find-param-recursion-issue-152716.rs:16:9
    |
 LL |     (): Trait<<T as Proj<'static>>::Assoc>
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

From 9d5b5f8a022e6422529348c832ab0feb14a3447b Mon Sep 17 00:00:00 2001
From: Divyesh <divcodings@gmail.com>
Date: Sun, 8 Mar 2026 01:22:02 +0530
Subject: [PATCH 0197/1059] ide-assists: remove unnecessary clones in two
 assists

---
 .../crates/ide-assists/src/handlers/convert_bool_then.rs    | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
index d2c4ed9b5a2c..236436989e15 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
@@ -102,11 +102,7 @@ pub(crate) fn convert_if_to_bool_then(acc: &mut Assists, ctx: &AssistContext<'_>
                 ast::Expr::BlockExpr(block) => unwrap_trivial_block(block),
                 e => e,
             };
-            let cond = if invert_cond {
-                invert_boolean_expression(&make, cond)
-            } else {
-                cond.clone_for_update()
-            };
+            let cond = if invert_cond { invert_boolean_expression(&make, cond) } else { cond };
 
             let parenthesize = matches!(
                 cond,

From aabb3d8fff4dd5a2e413cd981b426096900f1799 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Sun, 8 Mar 2026 10:56:57 +0900
Subject: [PATCH 0198/1059] Update query documentation to reflect QueryKey
 changes

---
 src/doc/rustc-dev-guide/src/query.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
index 5ab2ab428e81..1621d79db247 100644
--- a/src/doc/rustc-dev-guide/src/query.md
+++ b/src/doc/rustc-dev-guide/src/query.md
@@ -90,7 +90,7 @@ dependencies of the local crate)
 Note that what determines the crate that a query is targeting is not the *kind* of query, but the *key*.
 For example, when you invoke `tcx.type_of(def_id)`, that could be a
 local query or an external query, depending on what crate the `def_id`
-is referring to (see the [`self::keys::Key`][Key] trait for more information on how that works).
+is referring to (see the [`self::keys::QueryKey`][QueryKey] trait for more information on how that works).
 
 Providers always have the same signature:
 
@@ -308,7 +308,7 @@ Let's go over these elements one by one:
   Also used as the name of a struct (`ty::queries::type_of`) that will be generated to represent
   this query.
 - **Query key type:** the type of the argument to this query.
-  This type must implement the [`ty::query::keys::Key`][Key] trait, which
+  This type must implement the [`ty::query::keys::QueryKey`][QueryKey] trait, which
   defines (for example) how to map it to a crate, and so forth.
 - **Result type of query:** the type produced by this query.
   This type should (a) not use `RefCell` or other interior mutability and (b) be
@@ -317,7 +317,7 @@ Let's go over these elements one by one:
 - **Query modifiers:** various flags and options that customize how the
   query is processed (mostly with respect to [incremental compilation][incrcomp]).
 
-[Key]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/query/keys/trait.Key.html
+[QueryKey]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/query/keys/trait.QueryKey.html
 [incrcomp]: queries/incremental-compilation-in-detail.html#query-modifiers
 
 So, to add a query:

From a1a242a54bf414c03a8602fdcdf346970549c9fc Mon Sep 17 00:00:00 2001
From: Jaroslaw Roszyk <roszyk.jarek@gmail.com>
Date: Sun, 8 Mar 2026 02:06:45 +0100
Subject: [PATCH 0199/1059] feat: add --json flag to rust-analyzer parse

---
 .../crates/rust-analyzer/src/cli/flags.rs     |  5 +-
 .../crates/rust-analyzer/src/cli/parse.rs     | 87 ++++++++++++++++++-
 2 files changed, 89 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
index c52206018138..d68f7ab5b7b2 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
@@ -40,6 +40,8 @@
         cmd parse {
             /// Suppress printing.
             optional --no-dump
+            /// Output as JSON.
+            optional --json
         }
 
         /// Parse stdin and print the list of symbols.
@@ -233,6 +235,7 @@ pub struct LspServer {
 #[derive(Debug)]
 pub struct Parse {
     pub no_dump: bool,
+    pub json: bool,
 }
 
 #[derive(Debug)]
@@ -257,8 +260,8 @@ pub struct AnalysisStats {
     pub disable_build_scripts: bool,
     pub disable_proc_macros: bool,
     pub proc_macro_srv: Option<PathBuf>,
-    pub skip_lowering: bool,
     pub skip_lang_items: bool,
+    pub skip_lowering: bool,
     pub skip_inference: bool,
     pub skip_mir_stats: bool,
     pub skip_data_layout: bool,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/parse.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/parse.rs
index 85ec95409ae7..aa1b659d8bcd 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/parse.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/parse.rs
@@ -1,18 +1,101 @@
 //! Read Rust code on stdin, print syntax tree on stdout.
 use ide::Edition;
-use syntax::{AstNode, SourceFile};
+use ide_db::line_index::LineIndex;
+use serde::Serialize;
+use syntax::{AstNode, NodeOrToken, SourceFile, SyntaxNode, SyntaxToken};
 
 use crate::cli::{flags, read_stdin};
 
+#[derive(Serialize)]
+struct JsonNode {
+    kind: String,
+    #[serde(rename = "type")]
+    node_type: &'static str,
+    start: [u32; 3],
+    end: [u32; 3],
+    #[serde(skip_serializing_if = "Option::is_none")]
+    text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    children: Option<Vec<JsonNode>>,
+}
+
+fn pos(line_index: &LineIndex, offset: syntax::TextSize) -> [u32; 3] {
+    let offset_u32 = u32::from(offset);
+    let line_col = line_index.line_col(offset);
+    [offset_u32, line_col.line, line_col.col]
+}
+
 impl flags::Parse {
     pub fn run(self) -> anyhow::Result<()> {
         let _p = tracing::info_span!("flags::Parse::run").entered();
         let text = read_stdin()?;
+        let line_index = LineIndex::new(&text);
         let file = SourceFile::parse(&text, Edition::CURRENT).tree();
+
         if !self.no_dump {
-            println!("{:#?}", file.syntax());
+            if self.json {
+                let json_tree = node_to_json(NodeOrToken::Node(file.syntax().clone()), &line_index);
+                println!("{}", serde_json::to_string(&json_tree)?);
+            } else {
+                println!("{:#?}", file.syntax());
+            }
         }
+
         std::mem::forget(file);
         Ok(())
     }
 }
+
+fn node_to_json(node: NodeOrToken<SyntaxNode, SyntaxToken>, line_index: &LineIndex) -> JsonNode {
+    let range = node.text_range();
+    let kind = format!("{:?}", node.kind());
+
+    match node {
+        NodeOrToken::Node(n) => {
+            let children: Vec<_> =
+                n.children_with_tokens().map(|it| node_to_json(it, line_index)).collect();
+            JsonNode {
+                kind,
+                node_type: "Node",
+                start: pos(line_index, range.start()),
+                end: pos(line_index, range.end()),
+                text: None,
+                children: Some(children),
+            }
+        }
+        NodeOrToken::Token(t) => JsonNode {
+            kind,
+            node_type: "Token",
+            start: pos(line_index, range.start()),
+            end: pos(line_index, range.end()),
+            text: Some(t.text().to_owned()),
+            children: None,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cli::flags;
+
+    #[test]
+    fn test_parse_json_output() {
+        let text = "fn main() {}".to_owned();
+        let flags = flags::Parse { json: true, no_dump: false };
+        let line_index = LineIndex::new(&text);
+
+        let file = SourceFile::parse(&text, Edition::CURRENT).tree();
+
+        let output = if flags.json {
+            let json_tree = node_to_json(NodeOrToken::Node(file.syntax().clone()), &line_index);
+            serde_json::to_string(&json_tree).unwrap()
+        } else {
+            format!("{:#?}", file.syntax())
+        };
+
+        assert!(output.contains(r#""kind":"SOURCE_FILE""#));
+        assert!(output.contains(r#""text":"main""#));
+        assert!(output.contains(r#""start":[0,0,0]"#));
+    }
+}

From e4e8ae7660240d32b79f323066c4e10c9b68aecd Mon Sep 17 00:00:00 2001
From: Albab-Hasan <albabhasan276@gmail.com>
Date: Sun, 8 Mar 2026 11:03:05 +0600
Subject: [PATCH 0200/1059] fix: qualify NormalizesTo and CoercePredicate in
 ir_print debug output

---
 .../rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
index 8569b828ae11..65931549db02 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
@@ -188,7 +188,7 @@ fn print_debug(
         t: &ty::NormalizesTo<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        write!(fmt, "{} -> {:?}", t.alias, t.term)
+        write!(fmt, "NormalizesTo({} -> {:?})", t.alias, t.term)
     }
 }
 impl<'db> IrPrint<ty::SubtypePredicate<Self>> for DbInterner<'db> {
@@ -215,7 +215,7 @@ fn print_debug(
         t: &ty::CoercePredicate<Self>,
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
-        write!(fmt, "{:?} -> {:?}", t.a, t.b)
+        write!(fmt, "CoercePredicate({:?} -> {:?})", t.a, t.b)
     }
 }
 impl<'db> IrPrint<ty::FnSig<Self>> for DbInterner<'db> {

From 063afa7684e9200268b8b142b695a54c92f3b1f6 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sat, 7 Mar 2026 17:01:04 +0000
Subject: [PATCH 0201/1059] introduce granular tidy_ctx.start_check in
 extra_checks

Currently extra_checks acts as a single check. It has some downsides:
- It is completely sequential. If one sub-check fails, next sub-checks are not executed
- sub-checks are not tracked on TidyCtx's failed checks

This commit extract those sub-chekcs into separate functions, and call tidy_ctx.start_check() in each function.
It also add start_check() for prepare functions (installing python/npm packages) because some sub-checks rely on them.
---
 src/tools/tidy/src/extra_checks/mod.rs | 530 +++++++++++++++----------
 1 file changed, 321 insertions(+), 209 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 124de884637e..ccd53453bbf3 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -58,38 +58,6 @@ pub fn check(
     pos_args: Vec<String>,
     tidy_ctx: TidyCtx,
 ) {
-    let mut check = tidy_ctx.start_check("extra_checks");
-
-    if let Err(e) = check_impl(
-        root_path,
-        outdir,
-        librustdoc_path,
-        tools_path,
-        npm,
-        cargo,
-        extra_checks,
-        pos_args,
-        &tidy_ctx,
-    ) {
-        check.error(e);
-    }
-}
-
-fn check_impl(
-    root_path: &Path,
-    outdir: &Path,
-    librustdoc_path: &Path,
-    tools_path: &Path,
-    npm: &Path,
-    cargo: &Path,
-    extra_checks: Option<Vec<String>>,
-    pos_args: Vec<String>,
-    tidy_ctx: &TidyCtx,
-) -> Result<(), Error> {
-    let show_diff =
-        std::env::var("TIDY_PRINT_DIFF").is_ok_and(|v| v.eq_ignore_ascii_case("true") || v == "1");
-    let bless = tidy_ctx.is_bless_enabled();
-
     // Split comma-separated args up
     let mut lint_args = match extra_checks {
         Some(s) => s
@@ -129,12 +97,6 @@ macro_rules! extra_check {
         };
     }
 
-    let rerun_with_bless = |mode: &str, action: &str| {
-        if !bless {
-            eprintln!("rerun tidy with `--extra-checks={mode} --bless` to {action}");
-        }
-    };
-
     let python_lint = extra_check!(Py, Lint);
     let python_fmt = extra_check!(Py, Fmt);
     let shell_lint = extra_check!(Shell, Lint);
@@ -151,204 +113,354 @@ macro_rules! extra_check {
         .partition(|arg| arg.to_str().is_some_and(|s| s.starts_with('-')));
 
     if python_lint || python_fmt || cpp_fmt {
-        let venv_path = outdir.join("venv");
-        let mut reqs_path = root_path.to_owned();
-        reqs_path.extend(PIP_REQ_PATH);
-        py_path = Some(get_or_create_venv(&venv_path, &reqs_path)?);
+        match py_prepare(root_path, outdir, &tidy_ctx) {
+            Ok(p) => py_path = Some(p),
+            Err(_) => return,
+        }
     }
 
     if python_lint {
-        let py_path = py_path.as_ref().unwrap();
-        let args: &[&OsStr] = if bless {
-            eprintln!("linting python files and applying suggestions");
-            &["check".as_ref(), "--fix".as_ref()]
-        } else {
-            eprintln!("linting python files");
-            &["check".as_ref()]
-        };
+        check_python_lint(
+            root_path,
+            outdir,
+            &cfg_args,
+            &file_args,
+            py_path.as_ref().unwrap(),
+            &tidy_ctx,
+        );
+    }
 
-        let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
+    if python_fmt {
+        check_python_fmt(
+            root_path,
+            outdir,
+            &cfg_args,
+            &file_args,
+            py_path.as_ref().unwrap(),
+            &tidy_ctx,
+        );
+    }
 
-        if res.is_err() && show_diff && !bless {
-            eprintln!("\npython linting failed! Printing diff suggestions:");
+    if cpp_fmt {
+        check_cpp_fmt(root_path, &cfg_args, &file_args, py_path.as_ref().unwrap(), &tidy_ctx);
+    }
 
-            let diff_res = run_ruff(
+    if shell_lint {
+        check_shell_lint(root_path, &cfg_args, &file_args, &tidy_ctx);
+    }
+
+    if spellcheck {
+        check_spellcheck(root_path, outdir, cargo, &tidy_ctx);
+    }
+
+    if js_lint || js_typecheck {
+        if js_prepare(root_path, outdir, npm, &tidy_ctx).is_err() {
+            return;
+        }
+    }
+
+    if js_lint {
+        check_js_lint(outdir, librustdoc_path, tools_path, &tidy_ctx);
+    }
+
+    if js_typecheck {
+        check_js_typecheck(outdir, librustdoc_path, &tidy_ctx);
+    }
+}
+
+/// Since python lint, format and cpp format share python env, we need to ensure python env is installed before running those checks.
+fn py_prepare(root_path: &Path, outdir: &Path, tidy_ctx: &TidyCtx) -> Result<PathBuf, Error> {
+    let mut check = tidy_ctx.start_check("extra_checks:py_prepare");
+
+    let venv_path = outdir.join("venv");
+    let mut reqs_path = root_path.to_owned();
+    reqs_path.extend(PIP_REQ_PATH);
+
+    let res = get_or_create_venv(&venv_path, &reqs_path);
+    if let Err(e) = res {
+        check.error(e.to_string());
+        return Err(e);
+    }
+
+    res
+}
+
+/// Since js lint and format share node env, we need to ensure node env is installed before running those checks.
+fn js_prepare(
+    root_path: &Path,
+    outdir: &Path,
+    npm: &Path,
+    tidy_ctx: &TidyCtx,
+) -> Result<(), Error> {
+    let mut check = tidy_ctx.start_check("extra_checks:js_prepare");
+
+    if let Err(e) = rustdoc_js::npm_install(root_path, outdir, npm) {
+        check.error(e.to_string());
+        return Err(e);
+    }
+
+    Ok(())
+}
+
+fn rerun_with_bless(mode: &str, action: &str, bless: bool) {
+    if !bless {
+        eprintln!("rerun tidy with `--extra-checks={mode} --bless` to {action}");
+    }
+}
+
+fn show_diff() -> bool {
+    std::env::var("TIDY_PRINT_DIFF").is_ok_and(|v| v.eq_ignore_ascii_case("true") || v == "1")
+}
+
+fn check_spellcheck(root_path: &Path, outdir: &Path, cargo: &Path, tidy_ctx: &TidyCtx) {
+    let mut check = tidy_ctx.start_check("extra_checks:spellcheck");
+
+    let bless = tidy_ctx.is_bless_enabled();
+
+    let config_path = root_path.join("typos.toml");
+    let mut args = vec!["-c", config_path.as_os_str().to_str().unwrap()];
+    args.extend_from_slice(SPELLCHECK_DIRS);
+
+    if bless {
+        eprintln!("spellchecking files and fixing typos");
+        args.push("--write-changes");
+    } else {
+        eprintln!("spellchecking files");
+    }
+
+    if let Err(e) =
+        spellcheck_runner(root_path, &outdir, &cargo, &args, tidy_ctx.is_running_on_ci())
+    {
+        rerun_with_bless("spellcheck", "fix typos", bless);
+        check.error(e);
+    }
+}
+
+fn check_js_lint(outdir: &Path, librustdoc_path: &Path, tools_path: &Path, tidy_ctx: &TidyCtx) {
+    let mut check = tidy_ctx.start_check("extra_checks:js_lint");
+
+    let bless = tidy_ctx.is_bless_enabled();
+
+    if bless {
+        eprintln!("linting javascript files and applying suggestions");
+    } else {
+        eprintln!("linting javascript files");
+    }
+
+    if let Err(e) = rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless) {
+        rerun_with_bless("js:lint", "apply esplint suggestion", bless);
+        check.error(e);
+        return;
+    }
+
+    if let Err(e) = rustdoc_js::es_check(outdir, librustdoc_path) {
+        check.error(e);
+    }
+}
+
+fn check_js_typecheck(outdir: &Path, librustdoc_path: &Path, tidy_ctx: &TidyCtx) {
+    let mut check = tidy_ctx.start_check("extra_checks:js_typecheck");
+
+    eprintln!("typechecking javascript files");
+    if let Err(e) = rustdoc_js::typecheck(outdir, librustdoc_path) {
+        check.error(e);
+    }
+}
+
+fn check_shell_lint(
+    root_path: &Path,
+    cfg_args: &Vec<&OsStr>,
+    file_args: &Vec<&OsStr>,
+    tidy_ctx: &TidyCtx,
+) {
+    let mut check = tidy_ctx.start_check("extra_checks:shell_lint");
+
+    eprintln!("linting shell files");
+
+    let mut file_args_shc = file_args.clone();
+    let files;
+    if file_args.is_empty() {
+        match find_with_extension(root_path, None, &[OsStr::new("sh")]) {
+            Ok(f) => files = f,
+            Err(e) => {
+                check.error(e);
+                return;
+            }
+        }
+
+        file_args_shc.extend(files.iter().map(|p| p.as_os_str()));
+    }
+
+    if let Err(e) = shellcheck_runner(&merge_args(&cfg_args, &file_args_shc)) {
+        check.error(e);
+    }
+}
+
+fn check_python_lint(
+    root_path: &Path,
+    outdir: &Path,
+    cfg_args: &Vec<&OsStr>,
+    file_args: &Vec<&OsStr>,
+    py_path: &Path,
+    tidy_ctx: &TidyCtx,
+) {
+    let mut check = tidy_ctx.start_check("extra_checks:python_lint");
+
+    let bless = tidy_ctx.is_bless_enabled();
+
+    let args: &[&OsStr] = if bless {
+        eprintln!("linting python files and applying suggestions");
+        &["check".as_ref(), "--fix".as_ref()]
+    } else {
+        eprintln!("linting python files");
+        &["check".as_ref()]
+    };
+
+    let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
+
+    if res.is_err() && show_diff() && !bless {
+        eprintln!("\npython linting failed! Printing diff suggestions:");
+
+        let diff_res = run_ruff(
+            root_path,
+            outdir,
+            py_path,
+            &cfg_args,
+            &file_args,
+            &["check".as_ref(), "--diff".as_ref()],
+        );
+        // `ruff check --diff` will return status 0 if there are no suggestions.
+        if diff_res.is_err() {
+            rerun_with_bless("py:lint", "apply ruff suggestions", bless);
+        }
+    }
+    if let Err(e) = res {
+        check.error(e);
+    }
+}
+
+fn check_python_fmt(
+    root_path: &Path,
+    outdir: &Path,
+    cfg_args: &Vec<&OsStr>,
+    file_args: &Vec<&OsStr>,
+    py_path: &Path,
+    tidy_ctx: &TidyCtx,
+) {
+    let mut check = tidy_ctx.start_check("extra_checks:python_fmt");
+
+    let bless = tidy_ctx.is_bless_enabled();
+
+    let mut args: Vec<&OsStr> = vec!["format".as_ref()];
+    if bless {
+        eprintln!("formatting python files");
+    } else {
+        eprintln!("checking python file formatting");
+        args.push("--check".as_ref());
+    }
+
+    let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &args);
+
+    if res.is_err() && !bless {
+        if show_diff() {
+            eprintln!("\npython formatting does not match! Printing diff:");
+
+            let _ = run_ruff(
                 root_path,
                 outdir,
                 py_path,
                 &cfg_args,
                 &file_args,
-                &["check".as_ref(), "--diff".as_ref()],
+                &["format".as_ref(), "--diff".as_ref()],
             );
-            // `ruff check --diff` will return status 0 if there are no suggestions.
-            if diff_res.is_err() {
-                rerun_with_bless("py:lint", "apply ruff suggestions");
-            }
         }
-        // Rethrow error
-        res?;
+        rerun_with_bless("py:fmt", "reformat Python code", bless);
     }
 
-    if python_fmt {
-        let mut args: Vec<&OsStr> = vec!["format".as_ref()];
-        if bless {
-            eprintln!("formatting python files");
-        } else {
-            eprintln!("checking python file formatting");
-            args.push("--check".as_ref());
-        }
-
-        let py_path = py_path.as_ref().unwrap();
-        let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &args);
-
-        if res.is_err() && !bless {
-            if show_diff {
-                eprintln!("\npython formatting does not match! Printing diff:");
-
-                let _ = run_ruff(
-                    root_path,
-                    outdir,
-                    py_path,
-                    &cfg_args,
-                    &file_args,
-                    &["format".as_ref(), "--diff".as_ref()],
-                );
-            }
-            rerun_with_bless("py:fmt", "reformat Python code");
-        }
-
-        // Rethrow error
-        res?;
+    if let Err(e) = res {
+        check.error(e);
     }
+}
 
-    if cpp_fmt {
-        let mut cfg_args_clang_format = cfg_args.clone();
-        let mut file_args_clang_format = file_args.clone();
-        let config_path = root_path.join(".clang-format");
-        let config_file_arg = format!("file:{}", config_path.display());
-        cfg_args_clang_format.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
-        if bless {
-            eprintln!("formatting C++ files");
-            cfg_args_clang_format.push("-i".as_ref());
-        } else {
-            eprintln!("checking C++ file formatting");
-            cfg_args_clang_format.extend(&["--dry-run".as_ref(), "--Werror".as_ref()]);
+fn check_cpp_fmt(
+    root_path: &Path,
+    cfg_args: &Vec<&OsStr>,
+    file_args: &Vec<&OsStr>,
+    py_path: &Path,
+    tidy_ctx: &TidyCtx,
+) {
+    let mut check = tidy_ctx.start_check("extra_checks:cpp_fmt");
+
+    let bless = tidy_ctx.is_bless_enabled();
+
+    let mut cfg_args_clang_format = cfg_args.clone();
+    let mut file_args_clang_format = file_args.clone();
+    let config_path = root_path.join(".clang-format");
+    let config_file_arg = format!("file:{}", config_path.display());
+    cfg_args_clang_format.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
+    if bless {
+        eprintln!("formatting C++ files");
+        cfg_args_clang_format.push("-i".as_ref());
+    } else {
+        eprintln!("checking C++ file formatting");
+        cfg_args_clang_format.extend(&["--dry-run".as_ref(), "--Werror".as_ref()]);
+    }
+    let files;
+    if file_args_clang_format.is_empty() {
+        let llvm_wrapper = root_path.join("compiler/rustc_llvm/llvm-wrapper");
+        match find_with_extension(
+            root_path,
+            Some(llvm_wrapper.as_path()),
+            &[OsStr::new("h"), OsStr::new("cpp")],
+        ) {
+            Ok(f) => files = f,
+            Err(e) => {
+                check.error(e);
+                return;
+            }
         }
-        let files;
-        if file_args_clang_format.is_empty() {
-            let llvm_wrapper = root_path.join("compiler/rustc_llvm/llvm-wrapper");
-            files = find_with_extension(
-                root_path,
-                Some(llvm_wrapper.as_path()),
-                &[OsStr::new("h"), OsStr::new("cpp")],
-            )?;
-            file_args_clang_format.extend(files.iter().map(|p| p.as_os_str()));
-        }
-        let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
-        let res = py_runner(py_path.as_ref().unwrap(), false, None, "clang-format", &args);
+        file_args_clang_format.extend(files.iter().map(|p| p.as_os_str()));
+    }
+    let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
+    let res = py_runner(py_path, false, None, "clang-format", &args);
 
-        if res.is_err() && show_diff && !bless {
-            eprintln!("\nclang-format linting failed! Printing diff suggestions:");
+    if res.is_err() && show_diff() && !bless {
+        eprintln!("\nclang-format linting failed! Printing diff suggestions:");
 
-            let mut cfg_args_clang_format_diff = cfg_args.clone();
-            cfg_args_clang_format_diff.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
-            for file in file_args_clang_format {
-                let mut formatted = String::new();
-                let mut diff_args = cfg_args_clang_format_diff.clone();
-                diff_args.push(file);
-                let _ = py_runner(
-                    py_path.as_ref().unwrap(),
-                    false,
-                    Some(&mut formatted),
-                    "clang-format",
-                    &diff_args,
+        let mut cfg_args_diff = cfg_args.clone();
+        cfg_args_diff.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
+        for file in file_args {
+            let mut formatted = String::new();
+            let mut diff_args = cfg_args_diff.clone();
+            diff_args.push(file);
+            let _ = py_runner(py_path, false, Some(&mut formatted), "clang-format", &diff_args);
+            if formatted.is_empty() {
+                eprintln!(
+                    "failed to obtain the formatted content for '{}'",
+                    file.to_string_lossy()
                 );
-                if formatted.is_empty() {
-                    eprintln!(
-                        "failed to obtain the formatted content for '{}'",
-                        file.to_string_lossy()
-                    );
-                    continue;
-                }
-                let actual = std::fs::read_to_string(file).unwrap_or_else(|e| {
-                    panic!(
-                        "failed to read the C++ file at '{}' due to '{e}'",
-                        file.to_string_lossy()
+                continue;
+            }
+            let actual = std::fs::read_to_string(file).unwrap_or_else(|e| {
+                panic!("failed to read the C++ file at '{}' due to '{e}'", file.to_string_lossy())
+            });
+            if formatted != actual {
+                let diff = similar::TextDiff::from_lines(&actual, &formatted);
+                eprintln!(
+                    "{}",
+                    diff.unified_diff().context_radius(4).header(
+                        &format!("{} (actual)", file.to_string_lossy()),
+                        &format!("{} (formatted)", file.to_string_lossy())
                     )
-                });
-                if formatted != actual {
-                    let diff = similar::TextDiff::from_lines(&actual, &formatted);
-                    eprintln!(
-                        "{}",
-                        diff.unified_diff().context_radius(4).header(
-                            &format!("{} (actual)", file.to_string_lossy()),
-                            &format!("{} (formatted)", file.to_string_lossy())
-                        )
-                    );
-                }
+                );
             }
-            rerun_with_bless("cpp:fmt", "reformat C++ code");
         }
-        // Rethrow error
-        res?;
+        rerun_with_bless("cpp:fmt", "reformat C++ code", bless);
     }
 
-    if shell_lint {
-        eprintln!("linting shell files");
-
-        let mut file_args_shc = file_args.clone();
-        let files;
-        if file_args_shc.is_empty() {
-            files = find_with_extension(root_path, None, &[OsStr::new("sh")])?;
-            file_args_shc.extend(files.iter().map(|p| p.as_os_str()));
-        }
-
-        shellcheck_runner(&merge_args(&cfg_args, &file_args_shc))?;
+    if let Err(e) = res {
+        check.error(e);
     }
-
-    if spellcheck {
-        let config_path = root_path.join("typos.toml");
-        let mut args = vec!["-c", config_path.as_os_str().to_str().unwrap()];
-
-        args.extend_from_slice(SPELLCHECK_DIRS);
-
-        if bless {
-            eprintln!("spellchecking files and fixing typos");
-            args.push("--write-changes");
-        } else {
-            eprintln!("spellchecking files");
-        }
-        let res = spellcheck_runner(root_path, &outdir, &cargo, &args, tidy_ctx.is_running_on_ci());
-        if res.is_err() {
-            rerun_with_bless("spellcheck", "fix typos");
-        }
-        res?;
-    }
-
-    if js_lint || js_typecheck {
-        rustdoc_js::npm_install(root_path, outdir, npm)?;
-    }
-
-    if js_lint {
-        if bless {
-            eprintln!("linting javascript files and applying suggestions");
-        } else {
-            eprintln!("linting javascript files");
-        }
-        let res = rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless);
-        if res.is_err() {
-            rerun_with_bless("js:lint", "apply eslint suggestions");
-        }
-        res?;
-        rustdoc_js::es_check(outdir, librustdoc_path)?;
-    }
-
-    if js_typecheck {
-        eprintln!("typechecking javascript files");
-        rustdoc_js::typecheck(outdir, librustdoc_path)?;
-    }
-
-    Ok(())
 }
 
 fn run_ruff(

From 201759058d3e5584a366dabf998faaba96b0ce11 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 8 Mar 2026 11:16:26 +0100
Subject: [PATCH 0202/1059] Fix ICE when using the `min_generic_const_args`
 incomplete feature

---
 clippy_utils/src/consts.rs     |  9 +++++++--
 tests/ui/crashes/mgca-16691.rs | 16 ++++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/crashes/mgca-16691.rs

diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 1a75bdff8124..19278708a36a 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -845,8 +845,13 @@ fn fetch_path(&self, qpath: &QPath<'_>, id: HirId) -> Option<ConstValue> {
             {
                 did
             },
-            _ if let Res::Def(DefKind::Const { .. } | DefKind::AssocConst { .. }, did) =
-                self.typeck.qpath_res(qpath, id) =>
+            // TODO: revisit when feature `min_generic_const_args` is stabilized. In the meantime,
+            // `TyCtxt::const_eval_resolve()` will trigger an ICE when evaluating the body of the
+            // `type const` definition.
+            _ if let Res::Def(
+                DefKind::Const { is_type_const: false } | DefKind::AssocConst { is_type_const: false },
+                did,
+            ) = self.typeck.qpath_res(qpath, id) =>
             {
                 self.source.set(ConstantSource::NonLocal);
                 did
diff --git a/tests/ui/crashes/mgca-16691.rs b/tests/ui/crashes/mgca-16691.rs
new file mode 100644
index 000000000000..b7039240770b
--- /dev/null
+++ b/tests/ui/crashes/mgca-16691.rs
@@ -0,0 +1,16 @@
+//@ check-pass
+#![allow(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+trait Trait {
+    type const N: usize;
+    fn process();
+}
+
+impl Trait for () {
+    type const N: usize = 3;
+    fn process() {
+        const N: usize = <()>::N;
+        _ = 0..Self::N;
+    }
+}

From 88619f6d5158baa537f756a3c59ef73186eeeb41 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 8 Mar 2026 12:37:44 +0100
Subject: [PATCH 0203/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to c7b206bba4434ed928e9615f31082a9ef3f67c27.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 7c89bcb9ab04..2de5b4f0d5ae 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-f8704be04fe1150527fc2cf21dd44327f0fe87fb
+c7b206bba4434ed928e9615f31082a9ef3f67c27

From b73ab52a105ecde9515c2207a05dcd53f0f5f630 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 8 Mar 2026 12:42:48 +0100
Subject: [PATCH 0204/1059] fmt

---
 src/tools/miri/src/helpers.rs | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index facfade026be..72bb5c7cfa54 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -774,19 +774,17 @@ fn read_timespec(&mut self, tp: &MPlaceTy<'tcx>) -> InterpResult<'tcx, Option<Du
         let nanoseconds_scalar = this.read_scalar(&nanoseconds_place)?;
         let nanoseconds = nanoseconds_scalar.to_target_isize(this)?;
 
-        interp_ok(
-            try {
-                // tv_sec must be non-negative.
-                let seconds: u64 = seconds.try_into().ok()?;
-                // tv_nsec must be non-negative.
-                let nanoseconds: u32 = nanoseconds.try_into().ok()?;
-                if nanoseconds >= 1_000_000_000 {
-                    // tv_nsec must not be greater than 999,999,999.
-                    None?
-                }
-                Duration::new(seconds, nanoseconds)
-            },
-        )
+        interp_ok(try {
+            // tv_sec must be non-negative.
+            let seconds: u64 = seconds.try_into().ok()?;
+            // tv_nsec must be non-negative.
+            let nanoseconds: u32 = nanoseconds.try_into().ok()?;
+            if nanoseconds >= 1_000_000_000 {
+                // tv_nsec must not be greater than 999,999,999.
+                None?
+            }
+            Duration::new(seconds, nanoseconds)
+        })
     }
 
     /// Read bytes from a byte slice.

From c95f5bcf21667414e5d8225212241267490d895c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 8 Mar 2026 13:11:23 +0100
Subject: [PATCH 0205/1059] guaranteed_ne test: clarify assertion

---
 src/tools/miri/tests/pass/pointers.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/miri/tests/pass/pointers.rs b/src/tools/miri/tests/pass/pointers.rs
index 280a815abc43..388b3e99b726 100644
--- a/src/tools/miri/tests/pass/pointers.rs
+++ b/src/tools/miri/tests/pass/pointers.rs
@@ -137,6 +137,8 @@ fn main() {
     let addr = &13 as *const i32;
     let addr2 = (addr as usize).wrapping_add(usize::MAX).wrapping_add(1);
     assert_eq!(addr.guaranteed_eq(addr2 as *const _), Some(true));
+    // Technically, this assertion could fail as the promoted may truly end up at address 0x100;
+    // here we rely on knowing how Miri assigns memory addresses.
     assert_eq!(addr.guaranteed_ne(0x100 as *const _), Some(true));
 
     wide_ptr_ops();

From 85c4af74fab0893eb375f4e4637d91fb390a9881 Mon Sep 17 00:00:00 2001
From: Santiago Pastorino <spastorino@gmail.com>
Date: Wed, 2 Jul 2025 12:49:45 -0300
Subject: [PATCH 0206/1059] Rustfmt now support use closures on edition 2018

---
 rustfmt.toml                                   | 4 ----
 tests/codegen-llvm/ergonomic-clones/closure.rs | 1 -
 2 files changed, 5 deletions(-)

diff --git a/rustfmt.toml b/rustfmt.toml
index 910eea103798..4750b8541457 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -55,8 +55,4 @@ ignore = [
     # Code automatically generated and included.
     "compiler/rustc_codegen_gcc/src/intrinsic/archs.rs",
     "compiler/rustc_codegen_gcc/example",
-
-    # Rustfmt doesn't support use closures yet
-    "tests/mir-opt/ergonomic-clones/closure.rs",
-    "tests/codegen-llvm/ergonomic-clones/closure.rs",
 ]
diff --git a/tests/codegen-llvm/ergonomic-clones/closure.rs b/tests/codegen-llvm/ergonomic-clones/closure.rs
index b6fc81726419..15a2dd2baebf 100644
--- a/tests/codegen-llvm/ergonomic-clones/closure.rs
+++ b/tests/codegen-llvm/ergonomic-clones/closure.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -C no-prepopulate-passes -Copt-level=0 -Zmir-opt-level=0
 
 #![crate_type = "lib"]
-
 #![feature(ergonomic_clones)]
 #![allow(incomplete_features)]
 

From 6084bf541b23251b9c5b06466e075d176a9445e0 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sun, 8 Mar 2026 23:04:14 +0900
Subject: [PATCH 0207/1059] add regression test for EII declaration conflicting
 with constructor

---
 .../eii-declaration-conflicts-with-constructor.rs  | 11 +++++++++++
 ...i-declaration-conflicts-with-constructor.stderr | 14 ++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.rs
 create mode 100644 tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.stderr

diff --git a/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.rs b/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.rs
new file mode 100644
index 000000000000..23b930cddaa1
--- /dev/null
+++ b/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.rs
@@ -0,0 +1,11 @@
+#![feature(extern_item_impls)]
+
+// Regression test for <https://github.com/rust-lang/rust/issues/153502>:
+
+struct Foo(i32);
+
+#[eii]
+pub fn Foo(x: u64) {}
+//~^ ERROR the name `Foo` is defined multiple times
+
+fn main() {}
diff --git a/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.stderr b/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.stderr
new file mode 100644
index 000000000000..e95ab395ff24
--- /dev/null
+++ b/tests/ui/eii/duplicate/eii-declaration-conflicts-with-constructor.stderr
@@ -0,0 +1,14 @@
+error[E0428]: the name `Foo` is defined multiple times
+  --> $DIR/eii-declaration-conflicts-with-constructor.rs:8:1
+   |
+LL | struct Foo(i32);
+   | ---------------- previous definition of the value `Foo` here
+...
+LL | pub fn Foo(x: u64) {}
+   | ^^^^^^^^^^^^^^^^^^ `Foo` redefined here
+   |
+   = note: `Foo` must be defined only once in the value namespace of this module
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0428`.

From bf4004a24a352182d784db642a8e43b8c1e05396 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Sun, 8 Mar 2026 10:37:47 +0900
Subject: [PATCH 0208/1059] Update conventions for TODO and FIXME comments

---
 src/doc/rustc-dev-guide/src/conventions.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/conventions.md b/src/doc/rustc-dev-guide/src/conventions.md
index 0e08ef9042d1..0440fb0c5e73 100644
--- a/src/doc/rustc-dev-guide/src/conventions.md
+++ b/src/doc/rustc-dev-guide/src/conventions.md
@@ -139,6 +139,8 @@ if foo {
 }
 ```
 
+If you want to leave a note in the codebase, use `// FIXME` instead.
+
 <a id="cio"></a>
 
 ## Using crates from crates.io

From e82f693005ac415c3edc84b7bcb086ea48a549da Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 8 Mar 2026 14:48:56 +0100
Subject: [PATCH 0209/1059] MaybeUninit: mention common mistakes in assume_init
 docs; link to validity invariant docs

---
 library/core/src/mem/maybe_uninit.rs | 36 +++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index ad6479f84c73..7e2c6b9b3bcb 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -8,11 +8,11 @@
 ///
 /// # Initialization invariant
 ///
-/// The compiler, in general, assumes that a variable is properly initialized
+/// The compiler, in general, assumes that a variable is [properly initialized or "valid"][validity]
 /// according to the requirements of the variable's type. For example, a variable of
 /// reference type must be aligned and non-null. This is an invariant that must
 /// *always* be upheld, even in unsafe code. As a consequence, zero-initializing a
-/// variable of reference type causes instantaneous [undefined behavior][ub],
+/// variable of reference type causes instantaneous undefined behavior,
 /// no matter whether that reference ever gets used to access memory:
 ///
 /// ```rust,no_run
@@ -53,6 +53,11 @@
 /// // The equivalent code with `MaybeUninit<i32>`:
 /// let x: i32 = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠️
 /// ```
+///
+/// Conversely, sometimes it is okay to not initialize *all* bytes of a `MaybeUninit`
+/// before calling `assume_init`. For instance, padding bytes do not have to be initialized.
+/// See the field-by-field struct initialization example below for a case of that.
+///
 /// On top of that, remember that most types have additional invariants beyond merely
 /// being considered initialized at the type level. For example, a `1`-initialized [`Vec<T>`]
 /// is considered initialized (under the current implementation; this does not constitute
@@ -197,7 +202,12 @@
 /// );
 /// ```
 /// [`&raw mut`]: https://doc.rust-lang.org/reference/types/pointer.html#r-type.pointer.raw.constructor
-/// [ub]: ../../reference/behavior-considered-undefined.html
+/// [validity]: ../../reference/behavior-considered-undefined.html#r-undefined.validity
+///
+/// Note that we have not initialized the padding, but that's fine -- it does not have to be
+/// initialized. In fact, even if we had initialized the padding in `uninit`, those bytes would be
+/// lost when copying the result: no matter the contents of the padding bytes in `uninit`, they will
+/// always be uninitialized in `foo`.
 ///
 /// # Layout
 ///
@@ -657,11 +667,18 @@ pub const fn as_mut_ptr(&mut self) -> *mut T {
     /// # Safety
     ///
     /// It is up to the caller to guarantee that the `MaybeUninit<T>` really is in an initialized
-    /// state. Calling this when the content is not yet fully initialized causes immediate undefined
-    /// behavior. The [type-level documentation][inv] contains more information about
-    /// this initialization invariant.
+    /// state, i.e., a state that is considered ["valid" for type `T`][validity]. Calling this when
+    /// the content is not yet fully initialized causes immediate undefined behavior. The
+    /// [type-level documentation][inv] contains more information about this initialization
+    /// invariant.
+    ///
+    /// It is a common mistake to assume that this function is safe to call on integers because they
+    /// can hold all bit patterns. It is also a common mistake to think that calling this function
+    /// is UB if any byte is uninitialized. Both of these assumptions are wrong. If that is
+    /// surprising to you, please read the [type-level documentation][inv].
     ///
     /// [inv]: #initialization-invariant
+    /// [validity]: ../../reference/behavior-considered-undefined.html#r-undefined.validity
     ///
     /// On top of that, remember that most types have additional invariants beyond merely
     /// being considered initialized at the type level. For example, a `1`-initialized [`Vec<T>`]
@@ -689,12 +706,13 @@ pub const fn as_mut_ptr(&mut self) -> *mut T {
     /// *Incorrect* usage of this method:
     ///
     /// ```rust,no_run
+    /// # #![allow(invalid_value)]
     /// use std::mem::MaybeUninit;
     ///
-    /// let x = MaybeUninit::<Vec<u32>>::uninit();
-    /// let x_init = unsafe { x.assume_init() };
-    /// // `x` had not been initialized yet, so this last line caused undefined behavior. ⚠️
+    /// let x: i32 = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠️
     /// ```
+    ///
+    /// See the [type-level documentation][#examples] for more examples.
     #[stable(feature = "maybe_uninit", since = "1.36.0")]
     #[rustc_const_stable(feature = "const_maybe_uninit_assume_init_by_value", since = "1.59.0")]
     #[inline(always)]

From b3d440ffdbe8673d3d11210038371123d8c64d80 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 8 Mar 2026 18:41:51 +0200
Subject: [PATCH 0210/1059] Allow duplicate assoc type shorthand resolution if
 it points to the same assoc type

And with the same generic args.
---
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  8 ++++--
 .../crates/hir-ty/src/tests/regression.rs     | 25 +++++++++++++++++++
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index c49e94343793..83b67bf1fe1f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1809,8 +1809,12 @@ fn resolve_type_param_assoc_type_shorthand(
                 return AssocTypeShorthandResolution::Ambiguous {
                     sub_trait_resolution: Some(this_trait_resolution),
                 };
-            } else if supertraits_resolution.is_some() {
-                return AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None };
+            } else if let Some(prev_resolution) = &supertraits_resolution {
+                if prev_resolution == lookup_on_bounded_trait {
+                    return AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None };
+                } else {
+                    continue;
+                }
             } else {
                 let (assoc_type, args) = assoc_type_and_args
                     .get_with(|(assoc_type, args)| (*assoc_type, args.as_ref()))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 1939db0ef5a7..d88801a57b86 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2815,3 +2815,28 @@ fn contains_0<S: Collection<Item = i32>>(points: &S) {
     "#,
     );
 }
+
+#[test]
+fn regression_21773() {
+    check_no_mismatches(
+        r#"
+trait Neg {
+    type Output;
+}
+
+trait Abs: Neg {
+    fn abs(&self) -> Self::Output;
+}
+
+trait SelfAbs: Abs + Neg
+where
+    Self::Output: Neg<Output = Self::Output> + Abs,
+{
+}
+
+fn wrapped_abs<T: SelfAbs<Output = T>>(v: T) -> T {
+    v.abs()
+}
+    "#,
+    );
+}

From c597a88a3813c3329d2cc89e3a1c706a8434c17b Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sun, 8 Mar 2026 18:56:36 +0100
Subject: [PATCH 0211/1059] Remove crate from salsa `EditionedFileId`

---
 .../crates/base-db/src/editioned_file_id.rs   | 321 ++----------------
 .../rust-analyzer/crates/base-db/src/input.rs |   2 +-
 .../rust-analyzer/crates/hir-def/src/db.rs    |   2 +-
 .../src/expr_store/tests/body/block.rs        |   2 +-
 .../crates/hir-def/src/item_tree.rs           |  27 +-
 .../crates/hir-def/src/item_tree/lower.rs     |   8 +-
 .../crates/hir-def/src/item_tree/tests.rs     |   2 +-
 .../hir-def/src/macro_expansion_tests/mbe.rs  |  16 +-
 .../hir-def/src/macro_expansion_tests/mod.rs  |   2 +-
 .../crates/hir-def/src/nameres/collector.rs   |  14 +-
 .../hir-def/src/nameres/mod_resolution.rs     |   5 +-
 .../hir-def/src/nameres/tests/incremental.rs  |   5 +-
 .../crates/hir-expand/src/builtin/fn_macro.rs |   2 +-
 .../rust-analyzer/crates/hir-expand/src/db.rs |   2 +-
 .../crates/hir-expand/src/lib.rs              |  10 +-
 .../crates/hir-expand/src/span_map.rs         |   2 +-
 .../crates/hir-ty/src/tests/incremental.rs    |   7 +
 src/tools/rust-analyzer/crates/hir/src/lib.rs |   2 +-
 .../rust-analyzer/crates/hir/src/semantics.rs |   4 +-
 .../hir/src/semantics/child_by_source.rs      |   3 +-
 .../rust-analyzer/crates/ide-db/src/search.rs |  12 +-
 .../ide-db/src/test_data/test_doc_alias.txt   |   2 +-
 .../test_symbol_index_collection.txt          |  10 +-
 .../test_symbols_exclude_imports.txt          |   2 +-
 .../test_data/test_symbols_with_imports.txt   |   4 +-
 .../rust-analyzer/crates/ide-db/src/traits.rs |   4 +-
 .../crates/ide-ssr/src/from_comment.rs        |   2 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |  13 +-
 .../crates/ide/src/references.rs              |   5 +-
 .../crates/ide/src/signature_help.rs          |   4 +-
 .../rust-analyzer/crates/ide/src/typing.rs    |   6 +-
 .../crates/ide/src/typing/on_enter.rs         |   2 +-
 .../crates/ide/src/view_item_tree.rs          |   5 +-
 .../crates/load-cargo/src/lib.rs              |   6 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  12 +-
 .../crates/rust-analyzer/src/cli/ssr.rs       |   2 +-
 .../crates/test-fixture/src/lib.rs            |  11 +-
 37 files changed, 134 insertions(+), 406 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
index 062e3b59d941..db3730bccdf4 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
@@ -1,317 +1,46 @@
 //! Defines [`EditionedFileId`], an interned wrapper around [`span::EditionedFileId`] that
 //! is interned (so queries can take it) and remembers its crate.
 
-use core::fmt;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 
+use salsa::Database;
 use span::Edition;
 use vfs::FileId;
 
-use crate::{Crate, RootQueryDb};
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct EditionedFileId(
-    salsa::Id,
-    std::marker::PhantomData<&'static salsa::plumbing::interned::Value<EditionedFileId>>,
-);
-
-const _: () = {
-    use salsa::plumbing as zalsa_;
-    use zalsa_::interned as zalsa_struct_;
-    type Configuration_ = EditionedFileId;
-
-    #[derive(Debug, Clone, Eq)]
-    pub struct EditionedFileIdData {
-        editioned_file_id: span::EditionedFileId,
-        krate: Crate,
-    }
-
-    // FIXME: This poses an invalidation problem, if one constructs an `EditionedFileId` with a
-    // different crate then whatever the input of a memo used, it will invalidate the memo causing
-    // it to recompute even if the crate is not really used.
-    /// We like to include the origin crate in an `EditionedFileId` (for use in the item tree),
-    /// but this poses us a problem.
-    ///
-    /// Spans contain `EditionedFileId`s, and we don't want to make them store the crate too
-    /// because that will increase their size, which will increase memory usage significantly.
-    /// Furthermore, things using spans do not generally need the crate: they are using the
-    /// file id for queries like `ast_id_map` or `parse`, which do not care about the crate.
-    ///
-    /// To solve this, we hash **only the `span::EditionedFileId`**, but on still compare
-    /// the crate in equality check. This preserves the invariant of `Hash` and `Eq` -
-    /// although same hashes can be used for different items, same file ids used for multiple
-    /// crates is a rare thing, and different items always have different hashes. Then,
-    /// when we only have a `span::EditionedFileId`, we use the `intern()` method to
-    /// reuse existing file ids, and create new one only if needed. See [`from_span_guess_origin`].
-    ///
-    /// See this for more info: https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Letting.20EditionedFileId.20know.20its.20crate/near/530189401
-    ///
-    /// [`from_span_guess_origin`]: EditionedFileId::from_span_guess_origin
-    #[derive(Hash, PartialEq, Eq)]
-    struct WithoutCrate {
-        editioned_file_id: span::EditionedFileId,
-    }
-
-    impl PartialEq for EditionedFileIdData {
-        fn eq(&self, other: &Self) -> bool {
-            let Self { editioned_file_id, krate: _ } = self;
-            let Self { editioned_file_id: other_editioned_file_id, krate: _ } = other;
-            editioned_file_id == other_editioned_file_id
-        }
-    }
-
-    impl Hash for EditionedFileIdData {
-        #[inline]
-        fn hash<H: Hasher>(&self, state: &mut H) {
-            let EditionedFileIdData { editioned_file_id, krate: _ } = *self;
-            editioned_file_id.hash(state);
-        }
-    }
-
-    impl zalsa_struct_::HashEqLike<WithoutCrate> for EditionedFileIdData {
-        #[inline]
-        fn hash<H: Hasher>(&self, state: &mut H) {
-            Hash::hash(self, state);
-        }
-
-        #[inline]
-        fn eq(&self, data: &WithoutCrate) -> bool {
-            let EditionedFileIdData { editioned_file_id, krate: _ } = *self;
-            editioned_file_id == data.editioned_file_id
-        }
-    }
-
-    impl zalsa_::HasJar for EditionedFileId {
-        type Jar = zalsa_struct_::JarImpl<EditionedFileId>;
-        const KIND: zalsa_::JarKind = zalsa_::JarKind::Struct;
-    }
-
-    zalsa_::register_jar! {
-        zalsa_::ErasedJar::erase::<EditionedFileId>()
-    }
-
-    impl zalsa_struct_::Configuration for EditionedFileId {
-        const LOCATION: salsa::plumbing::Location =
-            salsa::plumbing::Location { file: file!(), line: line!() };
-        const DEBUG_NAME: &'static str = "EditionedFileId";
-        const REVISIONS: std::num::NonZeroUsize = std::num::NonZeroUsize::MAX;
-        const PERSIST: bool = false;
-
-        type Fields<'a> = EditionedFileIdData;
-        type Struct<'db> = EditionedFileId;
-
-        fn serialize<S>(_: &Self::Fields<'_>, _: S) -> Result<S::Ok, S::Error>
-        where
-            S: zalsa_::serde::Serializer,
-        {
-            unimplemented!("attempted to serialize value that set `PERSIST` to false")
-        }
-
-        fn deserialize<'de, D>(_: D) -> Result<Self::Fields<'static>, D::Error>
-        where
-            D: zalsa_::serde::Deserializer<'de>,
-        {
-            unimplemented!("attempted to deserialize value that cannot set `PERSIST` to false");
-        }
-    }
-
-    impl Configuration_ {
-        pub fn ingredient(zalsa: &zalsa_::Zalsa) -> &zalsa_struct_::IngredientImpl<Self> {
-            static CACHE: zalsa_::IngredientCache<zalsa_struct_::IngredientImpl<EditionedFileId>> =
-                zalsa_::IngredientCache::new();
-
-            // SAFETY: `lookup_jar_by_type` returns a valid ingredient index, and the only
-            // ingredient created by our jar is the struct ingredient.
-            unsafe {
-                CACHE.get_or_create(zalsa, || {
-                    zalsa.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>()
-                })
-            }
-        }
-    }
-
-    impl zalsa_::AsId for EditionedFileId {
-        fn as_id(&self) -> salsa::Id {
-            self.0.as_id()
-        }
-    }
-    impl zalsa_::FromId for EditionedFileId {
-        fn from_id(id: salsa::Id) -> Self {
-            Self(<salsa::Id>::from_id(id), std::marker::PhantomData)
-        }
-    }
-
-    unsafe impl Send for EditionedFileId {}
-    unsafe impl Sync for EditionedFileId {}
-
-    impl std::fmt::Debug for EditionedFileId {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            Self::default_debug_fmt(*self, f)
-        }
-    }
-
-    impl zalsa_::SalsaStructInDb for EditionedFileId {
-        type MemoIngredientMap = salsa::plumbing::MemoIngredientSingletonIndex;
-
-        fn lookup_ingredient_index(aux: &zalsa_::Zalsa) -> salsa::plumbing::IngredientIndices {
-            aux.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>().into()
-        }
-
-        fn entries(zalsa: &zalsa_::Zalsa) -> impl Iterator<Item = zalsa_::DatabaseKeyIndex> + '_ {
-            let _ingredient_index =
-                zalsa.lookup_jar_by_type::<zalsa_struct_::JarImpl<EditionedFileId>>();
-            <EditionedFileId>::ingredient(zalsa).entries(zalsa).map(|entry| entry.key())
-        }
-
-        #[inline]
-        fn cast(id: salsa::Id, type_id: std::any::TypeId) -> Option<Self> {
-            if type_id == std::any::TypeId::of::<EditionedFileId>() {
-                Some(<Self as salsa::plumbing::FromId>::from_id(id))
-            } else {
-                None
-            }
-        }
-
-        #[inline]
-        unsafe fn memo_table(
-            zalsa: &zalsa_::Zalsa,
-            id: zalsa_::Id,
-            current_revision: zalsa_::Revision,
-        ) -> zalsa_::MemoTableWithTypes<'_> {
-            // SAFETY: Guaranteed by caller.
-            unsafe {
-                zalsa.table().memos::<zalsa_struct_::Value<EditionedFileId>>(id, current_revision)
-            }
-        }
-    }
-
-    unsafe impl zalsa_::Update for EditionedFileId {
-        unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
-            if unsafe { *old_pointer } != new_value {
-                unsafe { *old_pointer = new_value };
-                true
-            } else {
-                false
-            }
-        }
-    }
-
-    impl EditionedFileId {
-        pub fn from_span(
-            db: &(impl salsa::Database + ?Sized),
-            editioned_file_id: span::EditionedFileId,
-            krate: Crate,
-        ) -> Self {
-            let (zalsa, zalsa_local) = db.zalsas();
-            Configuration_::ingredient(zalsa).intern(
-                zalsa,
-                zalsa_local,
-                EditionedFileIdData { editioned_file_id, krate },
-                |_, data| data,
-            )
-        }
-
-        /// Guesses the crate for the file.
-        ///
-        /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:
-        ///
-        ///  1. The file is not in the module tree.
-        ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
-        ///     (e.g. on enter feature, folding, etc.).
-        // FIXME: Remove this and all the weird crate ignoring plumbing around this
-        // This can cause a variety of weird bugs https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Broken.20token.20mapping/with/577739887
-        pub fn from_span_guess_origin(
-            db: &dyn RootQueryDb,
-            editioned_file_id: span::EditionedFileId,
-        ) -> Self {
-            let (zalsa, zalsa_local) = db.zalsas();
-            Configuration_::ingredient(zalsa).intern(
-                zalsa,
-                zalsa_local,
-                WithoutCrate { editioned_file_id },
-                |_, _| {
-                    // FileId not in the database.
-                    let krate = db
-                        .relevant_crates(editioned_file_id.file_id())
-                        .first()
-                        .copied()
-                        .or_else(|| db.all_crates().first().copied())
-                        .unwrap_or_else(|| {
-                            // What we're doing here is a bit fishy. We rely on the fact that we only need
-                            // the crate in the item tree, and we should not create an `EditionedFileId`
-                            // without a crate except in cases where it does not matter. The chances that
-                            // `all_crates()` will be empty are also very slim, but it can occur during startup.
-                            // In the very unlikely case that there is a bug and we'll use this crate, Salsa
-                            // will panic.
-
-                            // SAFETY: 0 is less than `Id::MAX_U32`.
-                            salsa::plumbing::FromId::from_id(unsafe { salsa::Id::from_index(0) })
-                        });
-                    EditionedFileIdData { editioned_file_id, krate }
-                },
-            )
-        }
-
-        pub fn editioned_file_id(self, db: &dyn salsa::Database) -> span::EditionedFileId {
-            let zalsa = db.zalsa();
-            let fields = Configuration_::ingredient(zalsa).fields(zalsa, self);
-            fields.editioned_file_id
-        }
-
-        pub fn krate(self, db: &dyn salsa::Database) -> Crate {
-            let zalsa = db.zalsa();
-            let fields = Configuration_::ingredient(zalsa).fields(zalsa, self);
-            fields.krate
-        }
-
-        /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
-        pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            zalsa_::with_attached_database(|db| {
-                let zalsa = db.zalsa();
-                let fields = Configuration_::ingredient(zalsa).fields(zalsa, this);
-                fmt::Debug::fmt(fields, f)
-            })
-            .unwrap_or_else(|| {
-                f.debug_tuple("EditionedFileId").field(&zalsa_::AsId::as_id(&this)).finish()
-            })
-        }
-    }
-};
+#[salsa::interned(debug, constructor = from_span_file_id, no_lifetime)]
+#[derive(PartialOrd, Ord)]
+pub struct EditionedFileId {
+    field: span::EditionedFileId,
+}
 
 impl EditionedFileId {
     #[inline]
-    pub fn new(db: &dyn salsa::Database, file_id: FileId, edition: Edition, krate: Crate) -> Self {
-        EditionedFileId::from_span(db, span::EditionedFileId::new(file_id, edition), krate)
-    }
-
-    /// Attaches the current edition and guesses the crate for the file.
-    ///
-    /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:
-    ///
-    ///  1. The file is not in the module tree.
-    ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
-    ///     (e.g. on enter feature, folding, etc.).
-    // FIXME: Remove this and all the weird crate ignoring plumbing around this
-    // This can cause a variety of weird bugs https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Broken.20token.20mapping/with/577739887
-    #[inline]
-    pub fn current_edition_guess_origin(db: &dyn RootQueryDb, file_id: FileId) -> Self {
-        Self::from_span_guess_origin(db, span::EditionedFileId::current_edition(file_id))
+    pub fn new(db: &dyn Database, file_id: FileId, edition: Edition) -> Self {
+        Self::from_span_file_id(db, span::EditionedFileId::new(file_id, edition))
     }
 
     #[inline]
-    pub fn file_id(self, db: &dyn salsa::Database) -> vfs::FileId {
-        let id = self.editioned_file_id(db);
-        id.file_id()
+    pub fn current_edition(db: &dyn Database, file_id: FileId) -> Self {
+        Self::from_span_file_id(db, span::EditionedFileId::current_edition(file_id))
     }
 
     #[inline]
-    pub fn unpack(self, db: &dyn salsa::Database) -> (vfs::FileId, span::Edition) {
-        let id = self.editioned_file_id(db);
-        (id.file_id(), id.edition())
+    pub fn file_id(self, db: &dyn Database) -> vfs::FileId {
+        self.field(db).file_id()
     }
 
     #[inline]
-    pub fn edition(self, db: &dyn salsa::Database) -> Edition {
-        self.editioned_file_id(db).edition()
+    pub fn span_file_id(self, db: &dyn Database) -> span::EditionedFileId {
+        self.field(db)
+    }
+
+    #[inline]
+    pub fn unpack(self, db: &dyn Database) -> (vfs::FileId, span::Edition) {
+        self.field(db).unpack()
+    }
+
+    #[inline]
+    pub fn edition(self, db: &dyn Database) -> Edition {
+        self.field(db).edition()
     }
 }
diff --git a/src/tools/rust-analyzer/crates/base-db/src/input.rs b/src/tools/rust-analyzer/crates/base-db/src/input.rs
index 151aba82a203..246c57edc2df 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/input.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/input.rs
@@ -870,7 +870,7 @@ pub fn shrink_to_fit(&mut self) {
 impl Crate {
     pub fn root_file_id(self, db: &dyn salsa::Database) -> EditionedFileId {
         let data = self.data(db);
-        EditionedFileId::new(db, data.root_file_id, data.edition, self)
+        EditionedFileId::new(db, data.root_file_id, data.edition)
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index ccd4bc9be84a..b0b652a1509c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -96,7 +96,7 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     /// Computes an [`ItemTree`] for the given file or macro expansion.
     #[salsa::invoke(file_item_tree_query)]
     #[salsa::transparent]
-    fn file_item_tree(&self, file_id: HirFileId) -> &ItemTree;
+    fn file_item_tree(&self, file_id: HirFileId, krate: Crate) -> &ItemTree;
 
     /// Turns a MacroId into a MacroDefId, describing the macro's definition post name resolution.
     #[salsa::invoke(macro_def)]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body/block.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body/block.rs
index d457a4ca7a3b..83594ee02169 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body/block.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body/block.rs
@@ -196,7 +196,7 @@ fn f() {
                 ),
                 block: Some(
                     BlockId(
-                        4401,
+                        4801,
                     ),
                 ),
             }"#]],
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
index a1707f17beb0..9825dbfe1cd2 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
@@ -44,6 +44,7 @@
 };
 
 use ast::{AstNode, StructKind};
+use base_db::Crate;
 use cfg::CfgOptions;
 use hir_expand::{
     ExpandTo, HirFileId,
@@ -121,21 +122,23 @@ fn span_for(&self, range: TextRange) -> Span {
 }
 
 #[salsa_macros::tracked(returns(deref))]
-pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+pub(crate) fn file_item_tree_query(
+    db: &dyn DefDatabase,
+    file_id: HirFileId,
+    krate: Crate,
+) -> Arc<ItemTree> {
     let _p = tracing::info_span!("file_item_tree_query", ?file_id).entered();
     static EMPTY: OnceLock<Arc<ItemTree>> = OnceLock::new();
 
-    let ctx = lower::Ctx::new(db, file_id);
+    let ctx = lower::Ctx::new(db, file_id, krate);
     let syntax = db.parse_or_expand(file_id);
     let mut item_tree = match_ast! {
         match syntax {
             ast::SourceFile(file) => {
-                let krate = file_id.krate(db);
                 let root_file_id = krate.root_file_id(db);
                 let extra_top_attrs = (file_id == root_file_id).then(|| {
                     parse_extra_crate_attrs(db, krate).map(|crate_attrs| {
-                        let file_id = root_file_id.editioned_file_id(db);
-                        lower_extra_crate_attrs(db, crate_attrs, file_id, &|| ctx.cfg_options())
+                        lower_extra_crate_attrs(db, crate_attrs, root_file_id.span_file_id(db), &|| ctx.cfg_options())
                     })
                 }).flatten();
                 let top_attrs = match extra_top_attrs {
@@ -190,14 +193,18 @@ pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) ->
 }
 
 #[salsa_macros::tracked(returns(deref))]
-pub(crate) fn block_item_tree_query(db: &dyn DefDatabase, block: BlockId) -> Arc<ItemTree> {
+pub(crate) fn block_item_tree_query(
+    db: &dyn DefDatabase,
+    block: BlockId,
+    krate: Crate,
+) -> Arc<ItemTree> {
     let _p = tracing::info_span!("block_item_tree_query", ?block).entered();
     static EMPTY: OnceLock<Arc<ItemTree>> = OnceLock::new();
 
     let loc = block.lookup(db);
     let block = loc.ast_id.to_node(db);
 
-    let ctx = lower::Ctx::new(db, loc.ast_id.file_id);
+    let ctx = lower::Ctx::new(db, loc.ast_id.file_id, krate);
     let mut item_tree = ctx.lower_block(&block);
     let ItemTree { top_level, top_attrs, attrs, vis, big_data, small_data } = &item_tree;
     if small_data.is_empty()
@@ -356,10 +363,10 @@ pub(crate) fn new(file: HirFileId, block: Option<BlockId>) -> Self {
         Self { file, block }
     }
 
-    pub(crate) fn item_tree<'db>(&self, db: &'db dyn DefDatabase) -> &'db ItemTree {
+    pub(crate) fn item_tree<'db>(&self, db: &'db dyn DefDatabase, krate: Crate) -> &'db ItemTree {
         match self.block {
-            Some(block) => block_item_tree_query(db, block),
-            None => file_item_tree_query(db, self.file),
+            Some(block) => block_item_tree_query(db, block, krate),
+            None => file_item_tree_query(db, self.file, krate),
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
index 3f19e001548e..31c6ef867d2c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
@@ -2,7 +2,7 @@
 
 use std::cell::OnceCell;
 
-use base_db::FxIndexSet;
+use base_db::{Crate, FxIndexSet};
 use cfg::CfgOptions;
 use hir_expand::{
     HirFileId,
@@ -36,12 +36,13 @@ pub(super) struct Ctx<'a> {
     span_map: OnceCell<SpanMap>,
     file: HirFileId,
     cfg_options: OnceCell<&'a CfgOptions>,
+    krate: Crate,
     top_level: Vec<ModItemId>,
     visibilities: FxIndexSet<RawVisibility>,
 }
 
 impl<'a> Ctx<'a> {
-    pub(super) fn new(db: &'a dyn DefDatabase, file: HirFileId) -> Self {
+    pub(super) fn new(db: &'a dyn DefDatabase, file: HirFileId, krate: Crate) -> Self {
         Self {
             db,
             tree: ItemTree::default(),
@@ -51,12 +52,13 @@ pub(super) fn new(db: &'a dyn DefDatabase, file: HirFileId) -> Self {
             span_map: OnceCell::new(),
             visibilities: FxIndexSet::default(),
             top_level: Vec::new(),
+            krate,
         }
     }
 
     #[inline]
     pub(super) fn cfg_options(&self) -> &'a CfgOptions {
-        self.cfg_options.get_or_init(|| self.file.krate(self.db).cfg_options(self.db))
+        self.cfg_options.get_or_init(|| self.krate.cfg_options(self.db))
     }
 
     pub(super) fn span_map(&self) -> SpanMapRef<'_> {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/tests.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/tests.rs
index 1926ed74e869..b71b25a1a51d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/tests.rs
@@ -6,7 +6,7 @@
 
 fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
     let (db, file_id) = TestDB::with_single_file(ra_fixture);
-    let item_tree = db.file_item_tree(file_id.into());
+    let item_tree = db.file_item_tree(file_id.into(), db.test_crate());
     let pretty = item_tree.pretty_print(&db, Edition::CURRENT);
     expect.assert_eq(&pretty);
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe.rs
index 7b5d0103e66e..d93df7af6a73 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mbe.rs
@@ -35,9 +35,9 @@ struct $ident {
     };
 }
 
-struct#0:MacroRules[BE8F, 0]@58..64#17408# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#17408#
-    map#0:MacroRules[BE8F, 0]@86..89#17408#:#0:MacroRules[BE8F, 0]@89..90#17408# #0:MacroRules[BE8F, 0]@89..90#17408#::#0:MacroRules[BE8F, 0]@91..93#17408#std#0:MacroRules[BE8F, 0]@93..96#17408#::#0:MacroRules[BE8F, 0]@96..98#17408#collections#0:MacroRules[BE8F, 0]@98..109#17408#::#0:MacroRules[BE8F, 0]@109..111#17408#HashSet#0:MacroRules[BE8F, 0]@111..118#17408#<#0:MacroRules[BE8F, 0]@118..119#17408#(#0:MacroRules[BE8F, 0]@119..120#17408#)#0:MacroRules[BE8F, 0]@120..121#17408#>#0:MacroRules[BE8F, 0]@121..122#17408#,#0:MacroRules[BE8F, 0]@122..123#17408#
-}#0:MacroRules[BE8F, 0]@132..133#17408#
+struct#0:MacroRules[BE8F, 0]@58..64#18432# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#18432#
+    map#0:MacroRules[BE8F, 0]@86..89#18432#:#0:MacroRules[BE8F, 0]@89..90#18432# #0:MacroRules[BE8F, 0]@89..90#18432#::#0:MacroRules[BE8F, 0]@91..93#18432#std#0:MacroRules[BE8F, 0]@93..96#18432#::#0:MacroRules[BE8F, 0]@96..98#18432#collections#0:MacroRules[BE8F, 0]@98..109#18432#::#0:MacroRules[BE8F, 0]@109..111#18432#HashSet#0:MacroRules[BE8F, 0]@111..118#18432#<#0:MacroRules[BE8F, 0]@118..119#18432#(#0:MacroRules[BE8F, 0]@119..120#18432#)#0:MacroRules[BE8F, 0]@120..121#18432#>#0:MacroRules[BE8F, 0]@121..122#18432#,#0:MacroRules[BE8F, 0]@122..123#18432#
+}#0:MacroRules[BE8F, 0]@132..133#18432#
 "#]],
     );
 }
@@ -197,7 +197,7 @@ macro_rules! mk_struct {
 #[macro_use]
 mod foo;
 
-struct#1:MacroRules[DB0C, 0]@59..65#17408# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#17408#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#17408#;#1:MacroRules[DB0C, 0]@75..76#17408#
+struct#1:MacroRules[DB0C, 0]@59..65#18432# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#18432#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#18432#;#1:MacroRules[DB0C, 0]@75..76#18432#
 "#]],
     );
 }
@@ -423,10 +423,10 @@ macro_rules! m {
 macro_rules! m {
     ($($i:ident),*) => ( impl Bar { $(fn $i() {})* } );
 }
-impl#\17408# Bar#\17408# {#\17408#
-    fn#\17408# foo#\ROOT2024#(#\17408#)#\17408# {#\17408#}#\17408#
-    fn#\17408# bar#\ROOT2024#(#\17408#)#\17408# {#\17408#}#\17408#
-}#\17408#
+impl#\18432# Bar#\18432# {#\18432#
+    fn#\18432# foo#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#
+    fn#\18432# bar#\ROOT2024#(#\18432#)#\18432# {#\18432#}#\18432#
+}#\18432#
 "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
index c63f2c1d786b..8ee93dcaa32d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
@@ -458,7 +458,7 @@ fn $func_name() { todo!() }
     "#;
 
     let (db, file_id) = TestDB::with_single_file(fixture);
-    let krate = file_id.krate(&db);
+    let krate = db.test_crate();
     let def_map = crate_def_map(&db, krate);
     let source = def_map[def_map.root].definition_source(&db);
     let source_file = match source.value {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index e672e83f0194..9c101c127b41 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -279,7 +279,7 @@ fn seed_with_top_level(&mut self) {
         let _p = tracing::info_span!("seed_with_top_level").entered();
 
         let file_id = self.def_map.krate.root_file_id(self.db);
-        let item_tree = self.db.file_item_tree(file_id.into());
+        let item_tree = self.db.file_item_tree(file_id.into(), self.def_map.krate);
         let attrs = match item_tree.top_level_attrs() {
             AttrsOrCfg::Enabled { attrs } => attrs.as_ref(),
             AttrsOrCfg::CfgDisabled(it) => it.1.as_ref(),
@@ -387,7 +387,7 @@ fn seed_with_top_level(&mut self) {
     }
 
     fn seed_with_inner(&mut self, tree_id: TreeId) {
-        let item_tree = tree_id.item_tree(self.db);
+        let item_tree = tree_id.item_tree(self.db, self.def_map.krate);
         let is_cfg_enabled = matches!(item_tree.top_level_attrs(), AttrsOrCfg::Enabled { .. });
         if is_cfg_enabled {
             self.inject_prelude();
@@ -1708,7 +1708,7 @@ fn collect_macro_expansion(
         }
         let file_id = macro_call_id.into();
 
-        let item_tree = self.db.file_item_tree(file_id);
+        let item_tree = self.db.file_item_tree(file_id, self.def_map.krate);
 
         // Derive helpers that are in scope for an item are also in scope for attribute macro expansions
         // of that item (but not derive or fn like macros).
@@ -2335,10 +2335,10 @@ fn collect_module(&mut self, module_ast_id: ItemTreeAstId<Mod>, attrs: Attrs<'_>
                     self.file_id(),
                     &module.name,
                     path_attr.as_deref(),
-                    self.def_collector.def_map.krate,
                 ) {
                     Ok((file_id, is_mod_rs, mod_dir)) => {
-                        let item_tree = db.file_item_tree(file_id.into());
+                        let item_tree =
+                            db.file_item_tree(file_id.into(), self.def_collector.def_map.krate);
                         match item_tree.top_level_attrs() {
                             AttrsOrCfg::CfgDisabled(cfg) => {
                                 self.emit_unconfigured_diagnostic(
@@ -2828,8 +2828,8 @@ fn crate_attrs() {
         let fixture = r#"
 //- /lib.rs crate:foo crate-attr:recursion_limit="4" crate-attr:no_core crate-attr:no_std crate-attr:feature(register_tool)
         "#;
-        let (db, file_id) = TestDB::with_single_file(fixture);
-        let def_map = crate_def_map(&db, file_id.krate(&db));
+        let (db, _) = TestDB::with_single_file(fixture);
+        let def_map = crate_def_map(&db, db.test_crate());
         assert_eq!(def_map.recursion_limit(), 4);
         assert!(def_map.is_no_core());
         assert!(def_map.is_no_std());
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/mod_resolution.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/mod_resolution.rs
index 140b77ac002f..0c50f13edfb6 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/mod_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/mod_resolution.rs
@@ -1,6 +1,6 @@
 //! This module resolves `mod foo;` declaration to file.
 use arrayvec::ArrayVec;
-use base_db::{AnchoredPath, Crate};
+use base_db::AnchoredPath;
 use hir_expand::{EditionedFileId, name::Name};
 
 use crate::{HirFileId, db::DefDatabase};
@@ -62,7 +62,6 @@ pub(super) fn resolve_declaration(
         file_id: HirFileId,
         name: &Name,
         attr_path: Option<&str>,
-        krate: Crate,
     ) -> Result<(EditionedFileId, bool, ModDir), Box<[String]>> {
         let name = name.as_str();
 
@@ -92,7 +91,7 @@ pub(super) fn resolve_declaration(
                 if let Some(mod_dir) = self.child(dir_path, !root_dir_owner) {
                     return Ok((
                         // FIXME: Edition, is this rightr?
-                        EditionedFileId::new(db, file_id, orig_file_id.edition(db), krate),
+                        EditionedFileId::new(db, file_id, orig_file_id.edition(db)),
                         is_mod_rs,
                         mod_dir,
                     ));
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
index b2a056ff2a60..7fedfa03bbd9 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
@@ -118,6 +118,7 @@ pub fn foo() {}
         expect![[r#"
             [
                 "crate_local_def_map",
+                "file_item_tree_query",
                 "crate_local_def_map",
             ]
         "#]],
@@ -603,7 +604,7 @@ impl Tr for () {}
     execute_assert_events(
         &db,
         || {
-            db.file_item_tree(pos.file_id.into());
+            db.file_item_tree(pos.file_id.into(), db.test_crate());
         },
         &[("file_item_tree_query", 1), ("parse", 1)],
         expect![[r#"
@@ -623,7 +624,7 @@ impl Tr for () {}
     execute_assert_events(
         &db,
         || {
-            db.file_item_tree(pos.file_id.into());
+            db.file_item_tree(pos.file_id.into(), db.test_crate());
         },
         &[("file_item_tree_query", 1), ("parse", 1)],
         expect![[r#"
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
index 2de7290a2198..b3572a1cefcc 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
@@ -774,7 +774,7 @@ fn relative_file(
     if res == call_site && !allow_recursion {
         Err(ExpandError::other(err_span, format!("recursive inclusion of `{path_str}`")))
     } else {
-        Ok(EditionedFileId::new(db, res, lookup.krate.data(db).edition, lookup.krate))
+        Ok(EditionedFileId::new(db, res, lookup.krate.data(db).edition))
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
index 51767f87ffb9..363465fdda35 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
@@ -162,7 +162,7 @@ fn syntax_context(db: &dyn ExpandDatabase, file: HirFileId, edition: Edition) ->
 }
 
 fn resolve_span(db: &dyn ExpandDatabase, Span { range, anchor, ctx: _ }: Span) -> FileRange {
-    let file_id = EditionedFileId::from_span_guess_origin(db, anchor.file_id);
+    let file_id = EditionedFileId::from_span_file_id(db, anchor.file_id);
     let anchor_offset =
         db.ast_id_map(file_id.into()).get_erased(anchor.ast_id).text_range().start();
     FileRange { file_id, range: range + anchor_offset }
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs b/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
index 05541e782efd..4b2c75ed386e 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/lib.rs
@@ -386,7 +386,7 @@ pub(crate) fn call_style(&self) -> MacroCallStyle {
 impl HirFileId {
     pub fn edition(self, db: &dyn ExpandDatabase) -> Edition {
         match self {
-            HirFileId::FileId(file_id) => file_id.editioned_file_id(db).edition(),
+            HirFileId::FileId(file_id) => file_id.edition(db),
             HirFileId::MacroFile(m) => db.lookup_intern_macro_call(m).def.edition,
         }
     }
@@ -1118,14 +1118,6 @@ pub fn file_id(self) -> Option<EditionedFileId> {
             HirFileId::MacroFile(_) => None,
         }
     }
-
-    #[inline]
-    pub fn krate(self, db: &dyn ExpandDatabase) -> Crate {
-        match self {
-            HirFileId::FileId(it) => it.krate(db),
-            HirFileId::MacroFile(it) => it.loc(db).krate,
-        }
-    }
 }
 
 impl PartialEq<EditionedFileId> for HirFileId {
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/span_map.rs b/src/tools/rust-analyzer/crates/hir-expand/src/span_map.rs
index 586b8152947b..71d0b880caa1 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/span_map.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/span_map.rs
@@ -135,7 +135,7 @@ pub(crate) fn real_span_map(
     });
 
     Arc::new(RealSpanMap::from_file(
-        editioned_file_id.editioned_file_id(db),
+        editioned_file_id.span_file_id(db),
         pairs.into_boxed_slice(),
         tree.syntax().text_range().end(),
     ))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index cf7ff6f7ecca..faa7b80a89c2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -31,6 +31,7 @@ fn foo() -> i32 {
         &[("InferenceResult::for_body_", 1)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -118,6 +119,7 @@ fn baz() -> i32 {
         &[("InferenceResult::for_body_", 3)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -237,6 +239,7 @@ fn bar() -> f32 {
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -311,6 +314,7 @@ fn bar() -> f32 {
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -386,6 +390,7 @@ fn bar() -> f32 {
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -462,6 +467,7 @@ pub struct SomeStruct {
         &[("TraitImpls::for_crate_", 1)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
@@ -562,6 +568,7 @@ fn main() {
         &[("trait_solve_shim", 0)],
         expect_test::expect![[r#"
             [
+                "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
                 "ast_id_map_shim",
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 11d79e2d7bf8..0b3515fd0498 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1091,7 +1091,7 @@ fn macro_call_diagnostics<'db>(
         let file_id = loc.kind.file_id();
         let mut range = precise_macro_call_location(&loc.kind, db, loc.krate);
         let RenderedExpandError { message, error, kind } = err.render_to_string(db);
-        if Some(err.span().anchor.file_id) == file_id.file_id().map(|it| it.editioned_file_id(db)) {
+        if Some(err.span().anchor.file_id) == file_id.file_id().map(|it| it.span_file_id(db)) {
             range.value = err.span().range
                 + db.ast_id_map(file_id).get_erased(err.span().anchor.ast_id).text_range().start();
         }
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 1cf3b9816082..c816fe967c54 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -472,12 +472,12 @@ pub fn first_crate(&self, file: FileId) -> Option<Crate> {
 
     pub fn attach_first_edition_opt(&self, file: FileId) -> Option<EditionedFileId> {
         let krate = self.file_to_module_defs(file).next()?.krate(self.db);
-        Some(EditionedFileId::new(self.db, file, krate.edition(self.db), krate.id))
+        Some(EditionedFileId::new(self.db, file, krate.edition(self.db)))
     }
 
     pub fn attach_first_edition(&self, file: FileId) -> EditionedFileId {
         self.attach_first_edition_opt(file)
-            .unwrap_or_else(|| EditionedFileId::current_edition_guess_origin(self.db, file))
+            .unwrap_or_else(|| EditionedFileId::current_edition(self.db, file))
     }
 
     pub fn parse_guess_edition(&self, file_id: FileId) -> ast::SourceFile {
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
index c1f72debe54f..143cc14c3377 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
@@ -93,7 +93,6 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
 
 impl ChildBySource for ItemScope {
     fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
-        let krate = file_id.krate(db);
         self.declarations().for_each(|item| add_module_def(db, res, file_id, item));
         self.impls().for_each(|imp| insert_item_loc(db, res, file_id, imp, keys::IMPL));
         self.extern_blocks().for_each(|extern_block| {
@@ -123,6 +122,8 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
             |(ast_id, calls)| {
                 let adt = ast_id.to_node(db);
                 calls.for_each(|(attr_id, call_id, calls)| {
+                    // FIXME: Is this the right crate?
+                    let krate = call_id.lookup(db).krate;
                     // FIXME: Fix cfg_attr handling.
                     let (attr, _, _, _) = attr_id.find_attr_range_with_source(db, krate, &adt);
                     res[keys::DERIVE_MACRO_CALL]
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/search.rs b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
index 4196a13aa3fa..3822eaae2cc7 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/search.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
@@ -169,7 +169,7 @@ fn crate_graph(db: &RootDatabase) -> SearchScope {
             entries.extend(
                 source_root
                     .iter()
-                    .map(|id| (EditionedFileId::new(db, id, crate_data.edition, krate), None)),
+                    .map(|id| (EditionedFileId::new(db, id, crate_data.edition), None)),
             );
         }
         SearchScope { entries }
@@ -183,9 +183,11 @@ fn reverse_dependencies(db: &RootDatabase, of: hir::Crate) -> SearchScope {
 
             let source_root = db.file_source_root(root_file).source_root_id(db);
             let source_root = db.source_root(source_root).source_root(db);
-            entries.extend(source_root.iter().map(|id| {
-                (EditionedFileId::new(db, id, rev_dep.edition(db), rev_dep.into()), None)
-            }));
+            entries.extend(
+                source_root
+                    .iter()
+                    .map(|id| (EditionedFileId::new(db, id, rev_dep.edition(db)), None)),
+            );
         }
         SearchScope { entries }
     }
@@ -199,7 +201,7 @@ fn krate(db: &RootDatabase, of: hir::Crate) -> SearchScope {
         SearchScope {
             entries: source_root
                 .iter()
-                .map(|id| (EditionedFileId::new(db, id, of.edition(db), of.into()), None))
+                .map(|id| (EditionedFileId::new(db, id, of.edition(db)), None))
                 .collect(),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
index 0c28c312f83b..fc98ebb06921 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_doc_alias.txt
@@ -2,7 +2,7 @@
     (
         Module {
             id: ModuleIdLt {
-                [salsa id]: Id(3800),
+                [salsa id]: Id(3400),
             },
         },
         [
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
index 4b588572d328..46d938b5a503 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
@@ -2,7 +2,7 @@
     (
         Module {
             id: ModuleIdLt {
-                [salsa id]: Id(3800),
+                [salsa id]: Id(3400),
             },
         },
         [
@@ -671,7 +671,7 @@
                 def: Module(
                     Module {
                         id: ModuleIdLt {
-                            [salsa id]: Id(3801),
+                            [salsa id]: Id(3401),
                         },
                     },
                 ),
@@ -706,7 +706,7 @@
                 def: Module(
                     Module {
                         id: ModuleIdLt {
-                            [salsa id]: Id(3802),
+                            [salsa id]: Id(3402),
                         },
                     },
                 ),
@@ -998,7 +998,7 @@
     (
         Module {
             id: ModuleIdLt {
-                [salsa id]: Id(3801),
+                [salsa id]: Id(3401),
             },
         },
         [
@@ -1044,7 +1044,7 @@
     (
         Module {
             id: ModuleIdLt {
-                [salsa id]: Id(3802),
+                [salsa id]: Id(3402),
             },
         },
         [
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
index 87f0c7d9a817..aff1d56c56a3 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_exclude_imports.txt
@@ -5,7 +5,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3c00,
+                        4000,
                     ),
                 },
             ),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
index e96aa889ba06..bf5d81cfb149 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbols_with_imports.txt
@@ -5,7 +5,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3c00,
+                        4000,
                     ),
                 },
             ),
@@ -42,7 +42,7 @@
             Struct(
                 Struct {
                     id: StructId(
-                        3c00,
+                        4000,
                     ),
                 },
             ),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/traits.rs b/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
index 41ef50165383..60bdc2d82c16 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/traits.rs
@@ -113,7 +113,6 @@ fn assoc_item_of_trait(
 
 #[cfg(test)]
 mod tests {
-    use base_db::RootQueryDb;
     use expect_test::{Expect, expect};
     use hir::{EditionedFileId, FilePosition, Semantics};
     use span::Edition;
@@ -132,8 +131,7 @@ pub(crate) fn position(
         let (file_id, range_or_offset) =
             change_fixture.file_position.expect("expected a marker ($0)");
 
-        let &krate = database.relevant_crates(file_id.file_id()).first().unwrap();
-        let file_id = EditionedFileId::from_span(&database, file_id, krate);
+        let file_id = EditionedFileId::from_span_file_id(&database, file_id);
         let offset = range_or_offset.expect_offset();
         (database, FilePosition { file_id, offset })
     }
diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/from_comment.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/from_comment.rs
index de26879c2959..181cc74a51d4 100644
--- a/src/tools/rust-analyzer/crates/ide-ssr/src/from_comment.rs
+++ b/src/tools/rust-analyzer/crates/ide-ssr/src/from_comment.rs
@@ -17,7 +17,7 @@ pub fn ssr_from_comment(
     frange: FileRange,
 ) -> Option<(MatchFinder<'_>, TextRange)> {
     let comment = {
-        let file_id = EditionedFileId::current_edition_guess_origin(db, frange.file_id);
+        let file_id = EditionedFileId::current_edition(db, frange.file_id);
 
         let file = db.parse(file_id);
         file.tree().syntax().token_at_offset(frange.range.start()).find_map(ast::Comment::cast)
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 930eaf2262d9..81a771fec89e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -339,8 +339,7 @@ pub fn file_text(&self, file_id: FileId) -> Cancellable<Arc<str>> {
     pub fn parse(&self, file_id: FileId) -> Cancellable<SourceFile> {
         // FIXME edition
         self.with_db(|db| {
-            let editioned_file_id_wrapper =
-                EditionedFileId::current_edition_guess_origin(&self.db, file_id);
+            let editioned_file_id_wrapper = EditionedFileId::current_edition(&self.db, file_id);
 
             db.parse(editioned_file_id_wrapper).tree()
         })
@@ -369,7 +368,7 @@ pub fn extend_selection(&self, frange: FileRange) -> Cancellable<TextRange> {
     /// supported).
     pub fn matching_brace(&self, position: FilePosition) -> Cancellable<Option<TextSize>> {
         self.with_db(|db| {
-            let file_id = EditionedFileId::current_edition_guess_origin(&self.db, position.file_id);
+            let file_id = EditionedFileId::current_edition(&self.db, position.file_id);
             let parse = db.parse(file_id);
             let file = parse.tree();
             matching_brace::matching_brace(&file, position.offset)
@@ -430,7 +429,7 @@ pub fn expand_macro(&self, position: FilePosition) -> Cancellable<Option<Expande
     pub fn join_lines(&self, config: &JoinLinesConfig, frange: FileRange) -> Cancellable<TextEdit> {
         self.with_db(|db| {
             let editioned_file_id_wrapper =
-                EditionedFileId::current_edition_guess_origin(&self.db, frange.file_id);
+                EditionedFileId::current_edition(&self.db, frange.file_id);
             let parse = db.parse(editioned_file_id_wrapper);
             join_lines::join_lines(config, &parse.tree(), frange.range)
         })
@@ -471,8 +470,7 @@ pub fn file_structure(
     ) -> Cancellable<Vec<StructureNode>> {
         // FIXME: Edition
         self.with_db(|db| {
-            let editioned_file_id_wrapper =
-                EditionedFileId::current_edition_guess_origin(&self.db, file_id);
+            let editioned_file_id_wrapper = EditionedFileId::current_edition(&self.db, file_id);
             let source_file = db.parse(editioned_file_id_wrapper).tree();
             file_structure::file_structure(&source_file, config)
         })
@@ -503,8 +501,7 @@ pub fn inlay_hints_resolve(
     /// Returns the set of folding ranges.
     pub fn folding_ranges(&self, file_id: FileId) -> Cancellable<Vec<Fold>> {
         self.with_db(|db| {
-            let editioned_file_id_wrapper =
-                EditionedFileId::current_edition_guess_origin(&self.db, file_id);
+            let editioned_file_id_wrapper = EditionedFileId::current_edition(&self.db, file_id);
 
             folding_ranges::folding_ranges(&db.parse(editioned_file_id_wrapper).tree())
         })
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index 102eb91b74f7..6464c477160b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -1151,10 +1151,7 @@ pub fn quux$0() {}
         check_with_scope(
             code,
             Some(&mut |db| {
-                SearchScope::single_file(EditionedFileId::current_edition_guess_origin(
-                    db,
-                    FileId::from_raw(2),
-                ))
+                SearchScope::single_file(EditionedFileId::current_edition(db, FileId::from_raw(2)))
             }),
             expect![[r#"
                 quux Function FileId(0) 19..35 26..30
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index 9ab07565e9ef..f86974b4ec76 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -1975,8 +1975,8 @@ trait Sub: Super + Super {
 fn f() -> impl Sub<$0
             "#,
             expect![[r#"
-                trait Sub<SubTy = …, SuperTy = …>
-                          ^^^^^^^^^  -----------
+                trait Sub<SuperTy = …, SubTy = …>
+                          ^^^^^^^^^^^  ---------
             "#]],
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/typing.rs b/src/tools/rust-analyzer/crates/ide/src/typing.rs
index ca2194fceb67..11bfb982cf41 100644
--- a/src/tools/rust-analyzer/crates/ide/src/typing.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/typing.rs
@@ -76,11 +76,7 @@ pub(crate) fn on_char_typed(
         .copied()
         .unwrap_or_else(|| *db.all_crates().first().unwrap());
     let edition = krate.data(db).edition;
-    let editioned_file_id_wrapper = EditionedFileId::from_span(
-        db,
-        span::EditionedFileId::new(position.file_id, edition),
-        krate,
-    );
+    let editioned_file_id_wrapper = EditionedFileId::new(db, position.file_id, edition);
     let file = &db.parse(editioned_file_id_wrapper);
     let char_matches_position =
         file.tree().syntax().text().char_at(position.offset) == Some(char_typed);
diff --git a/src/tools/rust-analyzer/crates/ide/src/typing/on_enter.rs b/src/tools/rust-analyzer/crates/ide/src/typing/on_enter.rs
index 76a2802d294c..fdc583a15cc7 100644
--- a/src/tools/rust-analyzer/crates/ide/src/typing/on_enter.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/typing/on_enter.rs
@@ -51,7 +51,7 @@
 // ![On Enter](https://user-images.githubusercontent.com/48062697/113065578-04c21800-91b1-11eb-82b8-22b8c481e645.gif)
 pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<TextEdit> {
     let editioned_file_id_wrapper =
-        ide_db::base_db::EditionedFileId::current_edition_guess_origin(db, position.file_id);
+        ide_db::base_db::EditionedFileId::current_edition(db, position.file_id);
     let parse = db.parse(editioned_file_id_wrapper);
     let file = parse.tree();
     let token = file.syntax().token_at_offset(position.offset).left_biased()?;
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_item_tree.rs b/src/tools/rust-analyzer/crates/ide/src/view_item_tree.rs
index e1a7e4e6ab23..8d84eba7ab65 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_item_tree.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_item_tree.rs
@@ -10,6 +10,9 @@
 // | VS Code | **rust-analyzer: Debug ItemTree** |
 pub(crate) fn view_item_tree(db: &RootDatabase, file_id: FileId) -> String {
     let sema = Semantics::new(db);
+    let Some(krate) = sema.first_crate(file_id) else {
+        return String::new();
+    };
     let file_id = sema.attach_first_edition(file_id);
-    db.file_item_tree(file_id.into()).pretty_print(db, file_id.edition(db))
+    db.file_item_tree(file_id.into(), krate.into()).pretty_print(db, file_id.edition(db))
 }
diff --git a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
index b8ce3a8da4a2..95fcfce29127 100644
--- a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
@@ -638,7 +638,7 @@ fn expand(
                     current_span = Span {
                         range: resolved.range,
                         anchor: SpanAnchor {
-                            file_id: resolved.file_id.editioned_file_id(db),
+                            file_id: resolved.file_id.span_file_id(db),
                             ast_id: span::ROOT_ERASED_FILE_AST_ID,
                         },
                         ctx: current_ctx,
@@ -652,7 +652,7 @@ fn expand(
                 let resolved = db.resolve_span(current_span);
 
                 Ok(SubResponse::SpanSourceResult {
-                    file_id: resolved.file_id.editioned_file_id(db).as_u32(),
+                    file_id: resolved.file_id.span_file_id(db).as_u32(),
                     ast_id: span::ROOT_ERASED_FILE_AST_ID.into_raw(),
                     start: u32::from(resolved.range.start()),
                     end: u32::from(resolved.range.end()),
@@ -684,7 +684,7 @@ fn expand(
                             .text_range();
 
                         let parent_span = Some(ParentSpan {
-                            file_id: editioned_file_id.editioned_file_id(db).as_u32(),
+                            file_id: editioned_file_id.span_file_id(db).as_u32(),
                             ast_id: span::ROOT_ERASED_FILE_AST_ID.into_raw(),
                             start: u32::from(range.start()),
                             end: u32::from(range.end()),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 1995d3889891..caa35879aa00 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -126,7 +126,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
         let source_roots = krates
             .iter()
             .cloned()
-            .map(|krate| db.file_source_root(krate.root_file(db)).source_root_id(db))
+            .map(|krate| (db.file_source_root(krate.root_file(db)).source_root_id(db), krate))
             .unique();
 
         let mut dep_loc = 0;
@@ -137,7 +137,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
         let mut workspace_item_stats = PrettyItemStats::default();
         let mut dep_item_stats = PrettyItemStats::default();
 
-        for source_root_id in source_roots {
+        for (source_root_id, krate) in source_roots {
             let source_root = db.source_root(source_root_id).source_root(db);
             for file_id in source_root.iter() {
                 if let Some(p) = source_root.path_for_file(&file_id)
@@ -148,7 +148,8 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                         let length = db.file_text(file_id).text(db).lines().count();
                         let item_stats = db
                             .file_item_tree(
-                                EditionedFileId::current_edition_guess_origin(db, file_id).into(),
+                                EditionedFileId::current_edition(db, file_id).into(),
+                                krate.into(),
                             )
                             .item_tree_stats()
                             .into();
@@ -160,7 +161,8 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                         let length = db.file_text(file_id).text(db).lines().count();
                         let item_stats = db
                             .file_item_tree(
-                                EditionedFileId::current_edition_guess_origin(db, file_id).into(),
+                                EditionedFileId::current_edition(db, file_id).into(),
+                                krate.into(),
                             )
                             .item_tree_stats()
                             .into();
@@ -492,7 +494,7 @@ struct Acc {
         let mut sw = self.stop_watch();
 
         for &file_id in file_ids {
-            let file_id = file_id.editioned_file_id(db);
+            let file_id = file_id.span_file_id(db);
             let sema = hir::Semantics::new(db);
             let display_target = match sema.first_crate(file_id.file_id()) {
                 Some(krate) => krate.to_display_target(sema.db),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
index 5c69bda723fb..6bc0792daabb 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
@@ -74,7 +74,7 @@ pub fn run(self) -> anyhow::Result<()> {
                 let sr = db.source_root(root).source_root(db);
                 for file_id in sr.iter() {
                     for debug_info in match_finder.debug_where_text_equal(
-                        EditionedFileId::current_edition_guess_origin(db, file_id),
+                        EditionedFileId::current_edition(db, file_id),
                         debug_snippet,
                     ) {
                         println!("{debug_info:#?}");
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index 93d4650cd3c4..e271c32c8626 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -149,8 +149,7 @@ fn with_single_file(
         let fixture = ChangeFixture::parse(ra_fixture);
         fixture.change.apply(&mut db);
         assert_eq!(fixture.files.len(), 1, "Multiple file found in the fixture");
-        let &krate = db.relevant_crates(fixture.files[0].file_id()).first().unwrap();
-        let file_id = EditionedFileId::from_span(&db, fixture.files[0], krate);
+        let file_id = EditionedFileId::from_span_file_id(&db, fixture.files[0]);
         (db, file_id)
     }
 
@@ -166,10 +165,7 @@ fn with_many_files(
         let files = fixture
             .files
             .into_iter()
-            .map(|file| {
-                let &krate = db.relevant_crates(file.file_id()).first().unwrap();
-                EditionedFileId::from_span(&db, file, krate)
-            })
+            .map(|file| EditionedFileId::from_span_file_id(&db, file))
             .collect();
         (db, files)
     }
@@ -226,8 +222,7 @@ fn with_range_or_offset(
         let (file_id, range_or_offset) = fixture
             .file_position
             .expect("Could not find file position in fixture. Did you forget to add an `$0`?");
-        let &krate = db.relevant_crates(file_id.file_id()).first().unwrap();
-        let file_id = EditionedFileId::from_span(&db, file_id, krate);
+        let file_id = EditionedFileId::from_span_file_id(&db, file_id);
         (db, file_id, range_or_offset)
     }
 

From 514f833a6b75de6e66f559efa917fc085dd9604b Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sun, 8 Mar 2026 21:23:36 +0000
Subject: [PATCH 0212/1059] address review comments

---
 src/tools/tidy/src/extra_checks/mod.rs | 50 +++++++++++++++-----------
 1 file changed, 29 insertions(+), 21 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index ccd53453bbf3..a1fe9f3b7763 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -17,7 +17,7 @@
 //! 3. Print the output of the given command. If it fails and `TIDY_PRINT_DIFF`
 //!    is set, rerun the tool to print a suggestion diff (for e.g. CI)
 
-use std::ffi::OsStr;
+use std::ffi::{OsStr, OsString};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str::FromStr;
@@ -113,6 +113,7 @@ macro_rules! extra_check {
         .partition(|arg| arg.to_str().is_some_and(|s| s.starts_with('-')));
 
     if python_lint || python_fmt || cpp_fmt {
+        // Since python lint, format and cpp format share python env, we need to ensure python env is installed before running those checks.
         match py_prepare(root_path, outdir, &tidy_ctx) {
             Ok(p) => py_path = Some(p),
             Err(_) => return,
@@ -154,6 +155,7 @@ macro_rules! extra_check {
     }
 
     if js_lint || js_typecheck {
+        // Since js lint and format share node env, we need to ensure node env is installed before running those checks.
         if js_prepare(root_path, outdir, npm, &tidy_ctx).is_err() {
             return;
         }
@@ -168,41 +170,46 @@ macro_rules! extra_check {
     }
 }
 
-/// Since python lint, format and cpp format share python env, we need to ensure python env is installed before running those checks.
-fn py_prepare(root_path: &Path, outdir: &Path, tidy_ctx: &TidyCtx) -> Result<PathBuf, Error> {
+// It is used by prepare functions because they handle errors themselves, so the caller doesn't need to handle errors.
+struct ErrorGuaranteed(());
+
+fn py_prepare(
+    root_path: &Path,
+    outdir: &Path,
+    tidy_ctx: &TidyCtx,
+) -> Result<PathBuf, ErrorGuaranteed> {
     let mut check = tidy_ctx.start_check("extra_checks:py_prepare");
 
     let venv_path = outdir.join("venv");
     let mut reqs_path = root_path.to_owned();
     reqs_path.extend(PIP_REQ_PATH);
 
-    let res = get_or_create_venv(&venv_path, &reqs_path);
-    if let Err(e) = res {
-        check.error(e.to_string());
-        return Err(e);
+    match get_or_create_venv(&venv_path, &reqs_path) {
+        Ok(p) => Ok(p),
+        Err(e) => {
+            check.error(e);
+            Err(ErrorGuaranteed(()))
+        }
     }
-
-    res
 }
 
-/// Since js lint and format share node env, we need to ensure node env is installed before running those checks.
 fn js_prepare(
     root_path: &Path,
     outdir: &Path,
     npm: &Path,
     tidy_ctx: &TidyCtx,
-) -> Result<(), Error> {
+) -> Result<(), ErrorGuaranteed> {
     let mut check = tidy_ctx.start_check("extra_checks:js_prepare");
 
     if let Err(e) = rustdoc_js::npm_install(root_path, outdir, npm) {
         check.error(e.to_string());
-        return Err(e);
+        return Err(ErrorGuaranteed(()));
     }
 
     Ok(())
 }
 
-fn rerun_with_bless(mode: &str, action: &str, bless: bool) {
+fn show_bless_help(mode: &str, action: &str, bless: bool) {
     if !bless {
         eprintln!("rerun tidy with `--extra-checks={mode} --bless` to {action}");
     }
@@ -231,7 +238,7 @@ fn check_spellcheck(root_path: &Path, outdir: &Path, cargo: &Path, tidy_ctx: &Ti
     if let Err(e) =
         spellcheck_runner(root_path, &outdir, &cargo, &args, tidy_ctx.is_running_on_ci())
     {
-        rerun_with_bless("spellcheck", "fix typos", bless);
+        show_bless_help("spellcheck", "fix typos", bless);
         check.error(e);
     }
 }
@@ -248,7 +255,7 @@ fn check_js_lint(outdir: &Path, librustdoc_path: &Path, tools_path: &Path, tidy_
     }
 
     if let Err(e) = rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless) {
-        rerun_with_bless("js:lint", "apply esplint suggestion", bless);
+        show_bless_help("js:lint", "apply esplint suggestion", bless);
         check.error(e);
         return;
     }
@@ -318,7 +325,7 @@ fn check_python_lint(
 
     let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
 
-    if res.is_err() && show_diff() && !bless {
+    if res.is_err() && !bless && show_diff() {
         eprintln!("\npython linting failed! Printing diff suggestions:");
 
         let diff_res = run_ruff(
@@ -331,7 +338,7 @@ fn check_python_lint(
         );
         // `ruff check --diff` will return status 0 if there are no suggestions.
         if diff_res.is_err() {
-            rerun_with_bless("py:lint", "apply ruff suggestions", bless);
+            show_bless_help("py:lint", "apply ruff suggestions", bless);
         }
     }
     if let Err(e) = res {
@@ -374,7 +381,7 @@ fn check_python_fmt(
                 &["format".as_ref(), "--diff".as_ref()],
             );
         }
-        rerun_with_bless("py:fmt", "reformat Python code", bless);
+        show_bless_help("py:fmt", "reformat Python code", bless);
     }
 
     if let Err(e) = res {
@@ -396,7 +403,8 @@ fn check_cpp_fmt(
     let mut cfg_args_clang_format = cfg_args.clone();
     let mut file_args_clang_format = file_args.clone();
     let config_path = root_path.join(".clang-format");
-    let config_file_arg = format!("file:{}", config_path.display());
+    let mut config_file_arg = OsString::from("file:");
+    config_file_arg.push(&config_path);
     cfg_args_clang_format.extend(&["--style".as_ref(), config_file_arg.as_ref()]);
     if bless {
         eprintln!("formatting C++ files");
@@ -424,7 +432,7 @@ fn check_cpp_fmt(
     let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
     let res = py_runner(py_path, false, None, "clang-format", &args);
 
-    if res.is_err() && show_diff() && !bless {
+    if res.is_err() && !bless && show_diff() {
         eprintln!("\nclang-format linting failed! Printing diff suggestions:");
 
         let mut cfg_args_diff = cfg_args.clone();
@@ -455,7 +463,7 @@ fn check_cpp_fmt(
                 );
             }
         }
-        rerun_with_bless("cpp:fmt", "reformat C++ code", bless);
+        show_bless_help("cpp:fmt", "reformat C++ code", bless);
     }
 
     if let Err(e) = res {

From 95365cc5bf05abef6ddeca9552529fbf0b8df728 Mon Sep 17 00:00:00 2001
From: Karl Meakin <karlwfmeakin@gmail.com>
Date: Mon, 20 Oct 2025 00:17:09 +0100
Subject: [PATCH 0213/1059] Make `unicode_data` tests normal

Instead of generating a standalone executable to test `unicode_data`,
generate normal tests in `coretests`. This ensures tests are always
generated, and will be run as part of the normal testsuite.

Also change the generated tests to loop over lookup tables, rather than
generating a separate `assert_eq!()` statement for every codepoint. The
old approach produced a massive (20,000 lines plus) file which took
minutes to compile!
---
 library/core/src/unicode/mod.rs               |    2 +-
 library/coretests/tests/lib.rs                |    1 +
 library/coretests/tests/unicode.rs            |   97 +
 library/coretests/tests/unicode/test_data.rs  | 2902 +++++++++++++++++
 src/bootstrap/src/core/build_steps/run.rs     |    4 +
 .../src/case_mapping.rs                       |   11 +-
 .../src/fmt_helpers.rs                        |   17 +
 src/tools/unicode-table-generator/src/main.rs |  155 +-
 8 files changed, 3093 insertions(+), 96 deletions(-)
 create mode 100644 library/coretests/tests/unicode/test_data.rs
 create mode 100644 src/tools/unicode-table-generator/src/fmt_helpers.rs

diff --git a/library/core/src/unicode/mod.rs b/library/core/src/unicode/mod.rs
index c71fa754e68f..4c220e3ea012 100644
--- a/library/core/src/unicode/mod.rs
+++ b/library/core/src/unicode/mod.rs
@@ -19,7 +19,7 @@
 pub(crate) mod printable;
 
 #[allow(unreachable_pub)]
-mod unicode_data;
+pub mod unicode_data;
 
 /// The version of [Unicode](https://www.unicode.org/) that the Unicode parts of
 /// `char` and `str` methods are based on.
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 5e303a3c6b79..137ec0fd6901 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -118,6 +118,7 @@
 #![feature(uint_bit_width)]
 #![feature(uint_carryless_mul)]
 #![feature(uint_gather_scatter_bits)]
+#![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
 #![feature(widening_mul)]
diff --git a/library/coretests/tests/unicode.rs b/library/coretests/tests/unicode.rs
index bbace0ef66ca..1fae74f0f11e 100644
--- a/library/coretests/tests/unicode.rs
+++ b/library/coretests/tests/unicode.rs
@@ -1,5 +1,102 @@
+use core::unicode::unicode_data;
+use std::ops::RangeInclusive;
+
+mod test_data;
+
 #[test]
 pub fn version() {
     let (major, _minor, _update) = core::char::UNICODE_VERSION;
     assert!(major >= 10);
 }
+
+#[track_caller]
+fn test_boolean_property(ranges: &[RangeInclusive<char>], lookup: fn(char) -> bool) {
+    let mut start = '\u{80}';
+    for range in ranges {
+        for c in start..*range.start() {
+            assert!(!lookup(c), "{c:?}");
+        }
+        for c in range.clone() {
+            assert!(lookup(c), "{c:?}");
+        }
+        start = char::from_u32(*range.end() as u32 + 1).unwrap();
+    }
+    for c in start..=char::MAX {
+        assert!(!lookup(c), "{c:?}");
+    }
+}
+
+#[track_caller]
+fn test_case_mapping(ranges: &[(char, [char; 3])], lookup: fn(char) -> [char; 3]) {
+    let mut start = '\u{80}';
+    for &(key, val) in ranges {
+        for c in start..key {
+            assert_eq!(lookup(c), [c, '\0', '\0'], "{c:?}");
+        }
+        assert_eq!(lookup(key), val, "{key:?}");
+        start = char::from_u32(key as u32 + 1).unwrap();
+    }
+    for c in start..=char::MAX {
+        assert_eq!(lookup(c), [c, '\0', '\0'], "{c:?}");
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn alphabetic() {
+    test_boolean_property(test_data::ALPHABETIC, unicode_data::alphabetic::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn case_ignorable() {
+    test_boolean_property(test_data::CASE_IGNORABLE, unicode_data::case_ignorable::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn cased() {
+    test_boolean_property(test_data::CASED, unicode_data::cased::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn grapheme_extend() {
+    test_boolean_property(test_data::GRAPHEME_EXTEND, unicode_data::grapheme_extend::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn lowercase() {
+    test_boolean_property(test_data::LOWERCASE, unicode_data::lowercase::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn n() {
+    test_boolean_property(test_data::N, unicode_data::n::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn uppercase() {
+    test_boolean_property(test_data::UPPERCASE, unicode_data::uppercase::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn white_space() {
+    test_boolean_property(test_data::WHITE_SPACE, unicode_data::white_space::lookup);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn to_lowercase() {
+    test_case_mapping(test_data::TO_LOWER, unicode_data::conversions::to_lower);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn to_uppercase() {
+    test_case_mapping(test_data::TO_UPPER, unicode_data::conversions::to_upper);
+}
diff --git a/library/coretests/tests/unicode/test_data.rs b/library/coretests/tests/unicode/test_data.rs
new file mode 100644
index 000000000000..cfc695475b1f
--- /dev/null
+++ b/library/coretests/tests/unicode/test_data.rs
@@ -0,0 +1,2902 @@
+//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
+// ignore-tidy-filelength
+
+use std::ops::RangeInclusive;
+
+#[rustfmt::skip]
+pub(super) static ALPHABETIC: &[RangeInclusive<char>; 759] = &[
+    '\u{aa}'..='\u{aa}', '\u{b5}'..='\u{b5}', '\u{ba}'..='\u{ba}', '\u{c0}'..='\u{d6}',
+    '\u{d8}'..='\u{f6}', '\u{f8}'..='\u{2c1}', '\u{2c6}'..='\u{2d1}', '\u{2e0}'..='\u{2e4}',
+    '\u{2ec}'..='\u{2ec}', '\u{2ee}'..='\u{2ee}', '\u{345}'..='\u{345}', '\u{363}'..='\u{374}',
+    '\u{376}'..='\u{377}', '\u{37a}'..='\u{37d}', '\u{37f}'..='\u{37f}', '\u{386}'..='\u{386}',
+    '\u{388}'..='\u{38a}', '\u{38c}'..='\u{38c}', '\u{38e}'..='\u{3a1}', '\u{3a3}'..='\u{3f5}',
+    '\u{3f7}'..='\u{481}', '\u{48a}'..='\u{52f}', '\u{531}'..='\u{556}', '\u{559}'..='\u{559}',
+    '\u{560}'..='\u{588}', '\u{5b0}'..='\u{5bd}', '\u{5bf}'..='\u{5bf}', '\u{5c1}'..='\u{5c2}',
+    '\u{5c4}'..='\u{5c5}', '\u{5c7}'..='\u{5c7}', '\u{5d0}'..='\u{5ea}', '\u{5ef}'..='\u{5f2}',
+    '\u{610}'..='\u{61a}', '\u{620}'..='\u{657}', '\u{659}'..='\u{65f}', '\u{66e}'..='\u{6d3}',
+    '\u{6d5}'..='\u{6dc}', '\u{6e1}'..='\u{6e8}', '\u{6ed}'..='\u{6ef}', '\u{6fa}'..='\u{6fc}',
+    '\u{6ff}'..='\u{6ff}', '\u{710}'..='\u{73f}', '\u{74d}'..='\u{7b1}', '\u{7ca}'..='\u{7ea}',
+    '\u{7f4}'..='\u{7f5}', '\u{7fa}'..='\u{7fa}', '\u{800}'..='\u{817}', '\u{81a}'..='\u{82c}',
+    '\u{840}'..='\u{858}', '\u{860}'..='\u{86a}', '\u{870}'..='\u{887}', '\u{889}'..='\u{88f}',
+    '\u{897}'..='\u{897}', '\u{8a0}'..='\u{8c9}', '\u{8d4}'..='\u{8df}', '\u{8e3}'..='\u{8e9}',
+    '\u{8f0}'..='\u{93b}', '\u{93d}'..='\u{94c}', '\u{94e}'..='\u{950}', '\u{955}'..='\u{963}',
+    '\u{971}'..='\u{983}', '\u{985}'..='\u{98c}', '\u{98f}'..='\u{990}', '\u{993}'..='\u{9a8}',
+    '\u{9aa}'..='\u{9b0}', '\u{9b2}'..='\u{9b2}', '\u{9b6}'..='\u{9b9}', '\u{9bd}'..='\u{9c4}',
+    '\u{9c7}'..='\u{9c8}', '\u{9cb}'..='\u{9cc}', '\u{9ce}'..='\u{9ce}', '\u{9d7}'..='\u{9d7}',
+    '\u{9dc}'..='\u{9dd}', '\u{9df}'..='\u{9e3}', '\u{9f0}'..='\u{9f1}', '\u{9fc}'..='\u{9fc}',
+    '\u{a01}'..='\u{a03}', '\u{a05}'..='\u{a0a}', '\u{a0f}'..='\u{a10}', '\u{a13}'..='\u{a28}',
+    '\u{a2a}'..='\u{a30}', '\u{a32}'..='\u{a33}', '\u{a35}'..='\u{a36}', '\u{a38}'..='\u{a39}',
+    '\u{a3e}'..='\u{a42}', '\u{a47}'..='\u{a48}', '\u{a4b}'..='\u{a4c}', '\u{a51}'..='\u{a51}',
+    '\u{a59}'..='\u{a5c}', '\u{a5e}'..='\u{a5e}', '\u{a70}'..='\u{a75}', '\u{a81}'..='\u{a83}',
+    '\u{a85}'..='\u{a8d}', '\u{a8f}'..='\u{a91}', '\u{a93}'..='\u{aa8}', '\u{aaa}'..='\u{ab0}',
+    '\u{ab2}'..='\u{ab3}', '\u{ab5}'..='\u{ab9}', '\u{abd}'..='\u{ac5}', '\u{ac7}'..='\u{ac9}',
+    '\u{acb}'..='\u{acc}', '\u{ad0}'..='\u{ad0}', '\u{ae0}'..='\u{ae3}', '\u{af9}'..='\u{afc}',
+    '\u{b01}'..='\u{b03}', '\u{b05}'..='\u{b0c}', '\u{b0f}'..='\u{b10}', '\u{b13}'..='\u{b28}',
+    '\u{b2a}'..='\u{b30}', '\u{b32}'..='\u{b33}', '\u{b35}'..='\u{b39}', '\u{b3d}'..='\u{b44}',
+    '\u{b47}'..='\u{b48}', '\u{b4b}'..='\u{b4c}', '\u{b56}'..='\u{b57}', '\u{b5c}'..='\u{b5d}',
+    '\u{b5f}'..='\u{b63}', '\u{b71}'..='\u{b71}', '\u{b82}'..='\u{b83}', '\u{b85}'..='\u{b8a}',
+    '\u{b8e}'..='\u{b90}', '\u{b92}'..='\u{b95}', '\u{b99}'..='\u{b9a}', '\u{b9c}'..='\u{b9c}',
+    '\u{b9e}'..='\u{b9f}', '\u{ba3}'..='\u{ba4}', '\u{ba8}'..='\u{baa}', '\u{bae}'..='\u{bb9}',
+    '\u{bbe}'..='\u{bc2}', '\u{bc6}'..='\u{bc8}', '\u{bca}'..='\u{bcc}', '\u{bd0}'..='\u{bd0}',
+    '\u{bd7}'..='\u{bd7}', '\u{c00}'..='\u{c0c}', '\u{c0e}'..='\u{c10}', '\u{c12}'..='\u{c28}',
+    '\u{c2a}'..='\u{c39}', '\u{c3d}'..='\u{c44}', '\u{c46}'..='\u{c48}', '\u{c4a}'..='\u{c4c}',
+    '\u{c55}'..='\u{c56}', '\u{c58}'..='\u{c5a}', '\u{c5c}'..='\u{c5d}', '\u{c60}'..='\u{c63}',
+    '\u{c80}'..='\u{c83}', '\u{c85}'..='\u{c8c}', '\u{c8e}'..='\u{c90}', '\u{c92}'..='\u{ca8}',
+    '\u{caa}'..='\u{cb3}', '\u{cb5}'..='\u{cb9}', '\u{cbd}'..='\u{cc4}', '\u{cc6}'..='\u{cc8}',
+    '\u{cca}'..='\u{ccc}', '\u{cd5}'..='\u{cd6}', '\u{cdc}'..='\u{cde}', '\u{ce0}'..='\u{ce3}',
+    '\u{cf1}'..='\u{cf3}', '\u{d00}'..='\u{d0c}', '\u{d0e}'..='\u{d10}', '\u{d12}'..='\u{d3a}',
+    '\u{d3d}'..='\u{d44}', '\u{d46}'..='\u{d48}', '\u{d4a}'..='\u{d4c}', '\u{d4e}'..='\u{d4e}',
+    '\u{d54}'..='\u{d57}', '\u{d5f}'..='\u{d63}', '\u{d7a}'..='\u{d7f}', '\u{d81}'..='\u{d83}',
+    '\u{d85}'..='\u{d96}', '\u{d9a}'..='\u{db1}', '\u{db3}'..='\u{dbb}', '\u{dbd}'..='\u{dbd}',
+    '\u{dc0}'..='\u{dc6}', '\u{dcf}'..='\u{dd4}', '\u{dd6}'..='\u{dd6}', '\u{dd8}'..='\u{ddf}',
+    '\u{df2}'..='\u{df3}', '\u{e01}'..='\u{e3a}', '\u{e40}'..='\u{e46}', '\u{e4d}'..='\u{e4d}',
+    '\u{e81}'..='\u{e82}', '\u{e84}'..='\u{e84}', '\u{e86}'..='\u{e8a}', '\u{e8c}'..='\u{ea3}',
+    '\u{ea5}'..='\u{ea5}', '\u{ea7}'..='\u{eb9}', '\u{ebb}'..='\u{ebd}', '\u{ec0}'..='\u{ec4}',
+    '\u{ec6}'..='\u{ec6}', '\u{ecd}'..='\u{ecd}', '\u{edc}'..='\u{edf}', '\u{f00}'..='\u{f00}',
+    '\u{f40}'..='\u{f47}', '\u{f49}'..='\u{f6c}', '\u{f71}'..='\u{f83}', '\u{f88}'..='\u{f97}',
+    '\u{f99}'..='\u{fbc}', '\u{1000}'..='\u{1036}', '\u{1038}'..='\u{1038}',
+    '\u{103b}'..='\u{103f}', '\u{1050}'..='\u{108f}', '\u{109a}'..='\u{109d}',
+    '\u{10a0}'..='\u{10c5}', '\u{10c7}'..='\u{10c7}', '\u{10cd}'..='\u{10cd}',
+    '\u{10d0}'..='\u{10fa}', '\u{10fc}'..='\u{1248}', '\u{124a}'..='\u{124d}',
+    '\u{1250}'..='\u{1256}', '\u{1258}'..='\u{1258}', '\u{125a}'..='\u{125d}',
+    '\u{1260}'..='\u{1288}', '\u{128a}'..='\u{128d}', '\u{1290}'..='\u{12b0}',
+    '\u{12b2}'..='\u{12b5}', '\u{12b8}'..='\u{12be}', '\u{12c0}'..='\u{12c0}',
+    '\u{12c2}'..='\u{12c5}', '\u{12c8}'..='\u{12d6}', '\u{12d8}'..='\u{1310}',
+    '\u{1312}'..='\u{1315}', '\u{1318}'..='\u{135a}', '\u{1380}'..='\u{138f}',
+    '\u{13a0}'..='\u{13f5}', '\u{13f8}'..='\u{13fd}', '\u{1401}'..='\u{166c}',
+    '\u{166f}'..='\u{167f}', '\u{1681}'..='\u{169a}', '\u{16a0}'..='\u{16ea}',
+    '\u{16ee}'..='\u{16f8}', '\u{1700}'..='\u{1713}', '\u{171f}'..='\u{1733}',
+    '\u{1740}'..='\u{1753}', '\u{1760}'..='\u{176c}', '\u{176e}'..='\u{1770}',
+    '\u{1772}'..='\u{1773}', '\u{1780}'..='\u{17b3}', '\u{17b6}'..='\u{17c8}',
+    '\u{17d7}'..='\u{17d7}', '\u{17dc}'..='\u{17dc}', '\u{1820}'..='\u{1878}',
+    '\u{1880}'..='\u{18aa}', '\u{18b0}'..='\u{18f5}', '\u{1900}'..='\u{191e}',
+    '\u{1920}'..='\u{192b}', '\u{1930}'..='\u{1938}', '\u{1950}'..='\u{196d}',
+    '\u{1970}'..='\u{1974}', '\u{1980}'..='\u{19ab}', '\u{19b0}'..='\u{19c9}',
+    '\u{1a00}'..='\u{1a1b}', '\u{1a20}'..='\u{1a5e}', '\u{1a61}'..='\u{1a74}',
+    '\u{1aa7}'..='\u{1aa7}', '\u{1abf}'..='\u{1ac0}', '\u{1acc}'..='\u{1ace}',
+    '\u{1b00}'..='\u{1b33}', '\u{1b35}'..='\u{1b43}', '\u{1b45}'..='\u{1b4c}',
+    '\u{1b80}'..='\u{1ba9}', '\u{1bac}'..='\u{1baf}', '\u{1bba}'..='\u{1be5}',
+    '\u{1be7}'..='\u{1bf1}', '\u{1c00}'..='\u{1c36}', '\u{1c4d}'..='\u{1c4f}',
+    '\u{1c5a}'..='\u{1c7d}', '\u{1c80}'..='\u{1c8a}', '\u{1c90}'..='\u{1cba}',
+    '\u{1cbd}'..='\u{1cbf}', '\u{1ce9}'..='\u{1cec}', '\u{1cee}'..='\u{1cf3}',
+    '\u{1cf5}'..='\u{1cf6}', '\u{1cfa}'..='\u{1cfa}', '\u{1d00}'..='\u{1dbf}',
+    '\u{1dd3}'..='\u{1df4}', '\u{1e00}'..='\u{1f15}', '\u{1f18}'..='\u{1f1d}',
+    '\u{1f20}'..='\u{1f45}', '\u{1f48}'..='\u{1f4d}', '\u{1f50}'..='\u{1f57}',
+    '\u{1f59}'..='\u{1f59}', '\u{1f5b}'..='\u{1f5b}', '\u{1f5d}'..='\u{1f5d}',
+    '\u{1f5f}'..='\u{1f7d}', '\u{1f80}'..='\u{1fb4}', '\u{1fb6}'..='\u{1fbc}',
+    '\u{1fbe}'..='\u{1fbe}', '\u{1fc2}'..='\u{1fc4}', '\u{1fc6}'..='\u{1fcc}',
+    '\u{1fd0}'..='\u{1fd3}', '\u{1fd6}'..='\u{1fdb}', '\u{1fe0}'..='\u{1fec}',
+    '\u{1ff2}'..='\u{1ff4}', '\u{1ff6}'..='\u{1ffc}', '\u{2071}'..='\u{2071}',
+    '\u{207f}'..='\u{207f}', '\u{2090}'..='\u{209c}', '\u{2102}'..='\u{2102}',
+    '\u{2107}'..='\u{2107}', '\u{210a}'..='\u{2113}', '\u{2115}'..='\u{2115}',
+    '\u{2119}'..='\u{211d}', '\u{2124}'..='\u{2124}', '\u{2126}'..='\u{2126}',
+    '\u{2128}'..='\u{2128}', '\u{212a}'..='\u{212d}', '\u{212f}'..='\u{2139}',
+    '\u{213c}'..='\u{213f}', '\u{2145}'..='\u{2149}', '\u{214e}'..='\u{214e}',
+    '\u{2160}'..='\u{2188}', '\u{24b6}'..='\u{24e9}', '\u{2c00}'..='\u{2ce4}',
+    '\u{2ceb}'..='\u{2cee}', '\u{2cf2}'..='\u{2cf3}', '\u{2d00}'..='\u{2d25}',
+    '\u{2d27}'..='\u{2d27}', '\u{2d2d}'..='\u{2d2d}', '\u{2d30}'..='\u{2d67}',
+    '\u{2d6f}'..='\u{2d6f}', '\u{2d80}'..='\u{2d96}', '\u{2da0}'..='\u{2da6}',
+    '\u{2da8}'..='\u{2dae}', '\u{2db0}'..='\u{2db6}', '\u{2db8}'..='\u{2dbe}',
+    '\u{2dc0}'..='\u{2dc6}', '\u{2dc8}'..='\u{2dce}', '\u{2dd0}'..='\u{2dd6}',
+    '\u{2dd8}'..='\u{2dde}', '\u{2de0}'..='\u{2dff}', '\u{2e2f}'..='\u{2e2f}',
+    '\u{3005}'..='\u{3007}', '\u{3021}'..='\u{3029}', '\u{3031}'..='\u{3035}',
+    '\u{3038}'..='\u{303c}', '\u{3041}'..='\u{3096}', '\u{309d}'..='\u{309f}',
+    '\u{30a1}'..='\u{30fa}', '\u{30fc}'..='\u{30ff}', '\u{3105}'..='\u{312f}',
+    '\u{3131}'..='\u{318e}', '\u{31a0}'..='\u{31bf}', '\u{31f0}'..='\u{31ff}',
+    '\u{3400}'..='\u{4dbf}', '\u{4e00}'..='\u{a48c}', '\u{a4d0}'..='\u{a4fd}',
+    '\u{a500}'..='\u{a60c}', '\u{a610}'..='\u{a61f}', '\u{a62a}'..='\u{a62b}',
+    '\u{a640}'..='\u{a66e}', '\u{a674}'..='\u{a67b}', '\u{a67f}'..='\u{a6ef}',
+    '\u{a717}'..='\u{a71f}', '\u{a722}'..='\u{a788}', '\u{a78b}'..='\u{a7dc}',
+    '\u{a7f1}'..='\u{a805}', '\u{a807}'..='\u{a827}', '\u{a840}'..='\u{a873}',
+    '\u{a880}'..='\u{a8c3}', '\u{a8c5}'..='\u{a8c5}', '\u{a8f2}'..='\u{a8f7}',
+    '\u{a8fb}'..='\u{a8fb}', '\u{a8fd}'..='\u{a8ff}', '\u{a90a}'..='\u{a92a}',
+    '\u{a930}'..='\u{a952}', '\u{a960}'..='\u{a97c}', '\u{a980}'..='\u{a9b2}',
+    '\u{a9b4}'..='\u{a9bf}', '\u{a9cf}'..='\u{a9cf}', '\u{a9e0}'..='\u{a9ef}',
+    '\u{a9fa}'..='\u{a9fe}', '\u{aa00}'..='\u{aa36}', '\u{aa40}'..='\u{aa4d}',
+    '\u{aa60}'..='\u{aa76}', '\u{aa7a}'..='\u{aabe}', '\u{aac0}'..='\u{aac0}',
+    '\u{aac2}'..='\u{aac2}', '\u{aadb}'..='\u{aadd}', '\u{aae0}'..='\u{aaef}',
+    '\u{aaf2}'..='\u{aaf5}', '\u{ab01}'..='\u{ab06}', '\u{ab09}'..='\u{ab0e}',
+    '\u{ab11}'..='\u{ab16}', '\u{ab20}'..='\u{ab26}', '\u{ab28}'..='\u{ab2e}',
+    '\u{ab30}'..='\u{ab5a}', '\u{ab5c}'..='\u{ab69}', '\u{ab70}'..='\u{abea}',
+    '\u{ac00}'..='\u{d7a3}', '\u{d7b0}'..='\u{d7c6}', '\u{d7cb}'..='\u{d7fb}',
+    '\u{f900}'..='\u{fa6d}', '\u{fa70}'..='\u{fad9}', '\u{fb00}'..='\u{fb06}',
+    '\u{fb13}'..='\u{fb17}', '\u{fb1d}'..='\u{fb28}', '\u{fb2a}'..='\u{fb36}',
+    '\u{fb38}'..='\u{fb3c}', '\u{fb3e}'..='\u{fb3e}', '\u{fb40}'..='\u{fb41}',
+    '\u{fb43}'..='\u{fb44}', '\u{fb46}'..='\u{fbb1}', '\u{fbd3}'..='\u{fd3d}',
+    '\u{fd50}'..='\u{fd8f}', '\u{fd92}'..='\u{fdc7}', '\u{fdf0}'..='\u{fdfb}',
+    '\u{fe70}'..='\u{fe74}', '\u{fe76}'..='\u{fefc}', '\u{ff21}'..='\u{ff3a}',
+    '\u{ff41}'..='\u{ff5a}', '\u{ff66}'..='\u{ffbe}', '\u{ffc2}'..='\u{ffc7}',
+    '\u{ffca}'..='\u{ffcf}', '\u{ffd2}'..='\u{ffd7}', '\u{ffda}'..='\u{ffdc}',
+    '\u{10000}'..='\u{1000b}', '\u{1000d}'..='\u{10026}', '\u{10028}'..='\u{1003a}',
+    '\u{1003c}'..='\u{1003d}', '\u{1003f}'..='\u{1004d}', '\u{10050}'..='\u{1005d}',
+    '\u{10080}'..='\u{100fa}', '\u{10140}'..='\u{10174}', '\u{10280}'..='\u{1029c}',
+    '\u{102a0}'..='\u{102d0}', '\u{10300}'..='\u{1031f}', '\u{1032d}'..='\u{1034a}',
+    '\u{10350}'..='\u{1037a}', '\u{10380}'..='\u{1039d}', '\u{103a0}'..='\u{103c3}',
+    '\u{103c8}'..='\u{103cf}', '\u{103d1}'..='\u{103d5}', '\u{10400}'..='\u{1049d}',
+    '\u{104b0}'..='\u{104d3}', '\u{104d8}'..='\u{104fb}', '\u{10500}'..='\u{10527}',
+    '\u{10530}'..='\u{10563}', '\u{10570}'..='\u{1057a}', '\u{1057c}'..='\u{1058a}',
+    '\u{1058c}'..='\u{10592}', '\u{10594}'..='\u{10595}', '\u{10597}'..='\u{105a1}',
+    '\u{105a3}'..='\u{105b1}', '\u{105b3}'..='\u{105b9}', '\u{105bb}'..='\u{105bc}',
+    '\u{105c0}'..='\u{105f3}', '\u{10600}'..='\u{10736}', '\u{10740}'..='\u{10755}',
+    '\u{10760}'..='\u{10767}', '\u{10780}'..='\u{10785}', '\u{10787}'..='\u{107b0}',
+    '\u{107b2}'..='\u{107ba}', '\u{10800}'..='\u{10805}', '\u{10808}'..='\u{10808}',
+    '\u{1080a}'..='\u{10835}', '\u{10837}'..='\u{10838}', '\u{1083c}'..='\u{1083c}',
+    '\u{1083f}'..='\u{10855}', '\u{10860}'..='\u{10876}', '\u{10880}'..='\u{1089e}',
+    '\u{108e0}'..='\u{108f2}', '\u{108f4}'..='\u{108f5}', '\u{10900}'..='\u{10915}',
+    '\u{10920}'..='\u{10939}', '\u{10940}'..='\u{10959}', '\u{10980}'..='\u{109b7}',
+    '\u{109be}'..='\u{109bf}', '\u{10a00}'..='\u{10a03}', '\u{10a05}'..='\u{10a06}',
+    '\u{10a0c}'..='\u{10a13}', '\u{10a15}'..='\u{10a17}', '\u{10a19}'..='\u{10a35}',
+    '\u{10a60}'..='\u{10a7c}', '\u{10a80}'..='\u{10a9c}', '\u{10ac0}'..='\u{10ac7}',
+    '\u{10ac9}'..='\u{10ae4}', '\u{10b00}'..='\u{10b35}', '\u{10b40}'..='\u{10b55}',
+    '\u{10b60}'..='\u{10b72}', '\u{10b80}'..='\u{10b91}', '\u{10c00}'..='\u{10c48}',
+    '\u{10c80}'..='\u{10cb2}', '\u{10cc0}'..='\u{10cf2}', '\u{10d00}'..='\u{10d27}',
+    '\u{10d4a}'..='\u{10d65}', '\u{10d69}'..='\u{10d69}', '\u{10d6f}'..='\u{10d85}',
+    '\u{10e80}'..='\u{10ea9}', '\u{10eab}'..='\u{10eac}', '\u{10eb0}'..='\u{10eb1}',
+    '\u{10ec2}'..='\u{10ec7}', '\u{10efa}'..='\u{10efc}', '\u{10f00}'..='\u{10f1c}',
+    '\u{10f27}'..='\u{10f27}', '\u{10f30}'..='\u{10f45}', '\u{10f70}'..='\u{10f81}',
+    '\u{10fb0}'..='\u{10fc4}', '\u{10fe0}'..='\u{10ff6}', '\u{11000}'..='\u{11045}',
+    '\u{11071}'..='\u{11075}', '\u{11080}'..='\u{110b8}', '\u{110c2}'..='\u{110c2}',
+    '\u{110d0}'..='\u{110e8}', '\u{11100}'..='\u{11132}', '\u{11144}'..='\u{11147}',
+    '\u{11150}'..='\u{11172}', '\u{11176}'..='\u{11176}', '\u{11180}'..='\u{111bf}',
+    '\u{111c1}'..='\u{111c4}', '\u{111ce}'..='\u{111cf}', '\u{111da}'..='\u{111da}',
+    '\u{111dc}'..='\u{111dc}', '\u{11200}'..='\u{11211}', '\u{11213}'..='\u{11234}',
+    '\u{11237}'..='\u{11237}', '\u{1123e}'..='\u{11241}', '\u{11280}'..='\u{11286}',
+    '\u{11288}'..='\u{11288}', '\u{1128a}'..='\u{1128d}', '\u{1128f}'..='\u{1129d}',
+    '\u{1129f}'..='\u{112a8}', '\u{112b0}'..='\u{112e8}', '\u{11300}'..='\u{11303}',
+    '\u{11305}'..='\u{1130c}', '\u{1130f}'..='\u{11310}', '\u{11313}'..='\u{11328}',
+    '\u{1132a}'..='\u{11330}', '\u{11332}'..='\u{11333}', '\u{11335}'..='\u{11339}',
+    '\u{1133d}'..='\u{11344}', '\u{11347}'..='\u{11348}', '\u{1134b}'..='\u{1134c}',
+    '\u{11350}'..='\u{11350}', '\u{11357}'..='\u{11357}', '\u{1135d}'..='\u{11363}',
+    '\u{11380}'..='\u{11389}', '\u{1138b}'..='\u{1138b}', '\u{1138e}'..='\u{1138e}',
+    '\u{11390}'..='\u{113b5}', '\u{113b7}'..='\u{113c0}', '\u{113c2}'..='\u{113c2}',
+    '\u{113c5}'..='\u{113c5}', '\u{113c7}'..='\u{113ca}', '\u{113cc}'..='\u{113cd}',
+    '\u{113d1}'..='\u{113d1}', '\u{113d3}'..='\u{113d3}', '\u{11400}'..='\u{11441}',
+    '\u{11443}'..='\u{11445}', '\u{11447}'..='\u{1144a}', '\u{1145f}'..='\u{11461}',
+    '\u{11480}'..='\u{114c1}', '\u{114c4}'..='\u{114c5}', '\u{114c7}'..='\u{114c7}',
+    '\u{11580}'..='\u{115b5}', '\u{115b8}'..='\u{115be}', '\u{115d8}'..='\u{115dd}',
+    '\u{11600}'..='\u{1163e}', '\u{11640}'..='\u{11640}', '\u{11644}'..='\u{11644}',
+    '\u{11680}'..='\u{116b5}', '\u{116b8}'..='\u{116b8}', '\u{11700}'..='\u{1171a}',
+    '\u{1171d}'..='\u{1172a}', '\u{11740}'..='\u{11746}', '\u{11800}'..='\u{11838}',
+    '\u{118a0}'..='\u{118df}', '\u{118ff}'..='\u{11906}', '\u{11909}'..='\u{11909}',
+    '\u{1190c}'..='\u{11913}', '\u{11915}'..='\u{11916}', '\u{11918}'..='\u{11935}',
+    '\u{11937}'..='\u{11938}', '\u{1193b}'..='\u{1193c}', '\u{1193f}'..='\u{11942}',
+    '\u{119a0}'..='\u{119a7}', '\u{119aa}'..='\u{119d7}', '\u{119da}'..='\u{119df}',
+    '\u{119e1}'..='\u{119e1}', '\u{119e3}'..='\u{119e4}', '\u{11a00}'..='\u{11a32}',
+    '\u{11a35}'..='\u{11a3e}', '\u{11a50}'..='\u{11a97}', '\u{11a9d}'..='\u{11a9d}',
+    '\u{11ab0}'..='\u{11af8}', '\u{11b60}'..='\u{11b67}', '\u{11bc0}'..='\u{11be0}',
+    '\u{11c00}'..='\u{11c08}', '\u{11c0a}'..='\u{11c36}', '\u{11c38}'..='\u{11c3e}',
+    '\u{11c40}'..='\u{11c40}', '\u{11c72}'..='\u{11c8f}', '\u{11c92}'..='\u{11ca7}',
+    '\u{11ca9}'..='\u{11cb6}', '\u{11d00}'..='\u{11d06}', '\u{11d08}'..='\u{11d09}',
+    '\u{11d0b}'..='\u{11d36}', '\u{11d3a}'..='\u{11d3a}', '\u{11d3c}'..='\u{11d3d}',
+    '\u{11d3f}'..='\u{11d41}', '\u{11d43}'..='\u{11d43}', '\u{11d46}'..='\u{11d47}',
+    '\u{11d60}'..='\u{11d65}', '\u{11d67}'..='\u{11d68}', '\u{11d6a}'..='\u{11d8e}',
+    '\u{11d90}'..='\u{11d91}', '\u{11d93}'..='\u{11d96}', '\u{11d98}'..='\u{11d98}',
+    '\u{11db0}'..='\u{11ddb}', '\u{11ee0}'..='\u{11ef6}', '\u{11f00}'..='\u{11f10}',
+    '\u{11f12}'..='\u{11f3a}', '\u{11f3e}'..='\u{11f40}', '\u{11fb0}'..='\u{11fb0}',
+    '\u{12000}'..='\u{12399}', '\u{12400}'..='\u{1246e}', '\u{12480}'..='\u{12543}',
+    '\u{12f90}'..='\u{12ff0}', '\u{13000}'..='\u{1342f}', '\u{13441}'..='\u{13446}',
+    '\u{13460}'..='\u{143fa}', '\u{14400}'..='\u{14646}', '\u{16100}'..='\u{1612e}',
+    '\u{16800}'..='\u{16a38}', '\u{16a40}'..='\u{16a5e}', '\u{16a70}'..='\u{16abe}',
+    '\u{16ad0}'..='\u{16aed}', '\u{16b00}'..='\u{16b2f}', '\u{16b40}'..='\u{16b43}',
+    '\u{16b63}'..='\u{16b77}', '\u{16b7d}'..='\u{16b8f}', '\u{16d40}'..='\u{16d6c}',
+    '\u{16e40}'..='\u{16e7f}', '\u{16ea0}'..='\u{16eb8}', '\u{16ebb}'..='\u{16ed3}',
+    '\u{16f00}'..='\u{16f4a}', '\u{16f4f}'..='\u{16f87}', '\u{16f8f}'..='\u{16f9f}',
+    '\u{16fe0}'..='\u{16fe1}', '\u{16fe3}'..='\u{16fe3}', '\u{16ff0}'..='\u{16ff6}',
+    '\u{17000}'..='\u{18cd5}', '\u{18cff}'..='\u{18d1e}', '\u{18d80}'..='\u{18df2}',
+    '\u{1aff0}'..='\u{1aff3}', '\u{1aff5}'..='\u{1affb}', '\u{1affd}'..='\u{1affe}',
+    '\u{1b000}'..='\u{1b122}', '\u{1b132}'..='\u{1b132}', '\u{1b150}'..='\u{1b152}',
+    '\u{1b155}'..='\u{1b155}', '\u{1b164}'..='\u{1b167}', '\u{1b170}'..='\u{1b2fb}',
+    '\u{1bc00}'..='\u{1bc6a}', '\u{1bc70}'..='\u{1bc7c}', '\u{1bc80}'..='\u{1bc88}',
+    '\u{1bc90}'..='\u{1bc99}', '\u{1bc9e}'..='\u{1bc9e}', '\u{1d400}'..='\u{1d454}',
+    '\u{1d456}'..='\u{1d49c}', '\u{1d49e}'..='\u{1d49f}', '\u{1d4a2}'..='\u{1d4a2}',
+    '\u{1d4a5}'..='\u{1d4a6}', '\u{1d4a9}'..='\u{1d4ac}', '\u{1d4ae}'..='\u{1d4b9}',
+    '\u{1d4bb}'..='\u{1d4bb}', '\u{1d4bd}'..='\u{1d4c3}', '\u{1d4c5}'..='\u{1d505}',
+    '\u{1d507}'..='\u{1d50a}', '\u{1d50d}'..='\u{1d514}', '\u{1d516}'..='\u{1d51c}',
+    '\u{1d51e}'..='\u{1d539}', '\u{1d53b}'..='\u{1d53e}', '\u{1d540}'..='\u{1d544}',
+    '\u{1d546}'..='\u{1d546}', '\u{1d54a}'..='\u{1d550}', '\u{1d552}'..='\u{1d6a5}',
+    '\u{1d6a8}'..='\u{1d6c0}', '\u{1d6c2}'..='\u{1d6da}', '\u{1d6dc}'..='\u{1d6fa}',
+    '\u{1d6fc}'..='\u{1d714}', '\u{1d716}'..='\u{1d734}', '\u{1d736}'..='\u{1d74e}',
+    '\u{1d750}'..='\u{1d76e}', '\u{1d770}'..='\u{1d788}', '\u{1d78a}'..='\u{1d7a8}',
+    '\u{1d7aa}'..='\u{1d7c2}', '\u{1d7c4}'..='\u{1d7cb}', '\u{1df00}'..='\u{1df1e}',
+    '\u{1df25}'..='\u{1df2a}', '\u{1e000}'..='\u{1e006}', '\u{1e008}'..='\u{1e018}',
+    '\u{1e01b}'..='\u{1e021}', '\u{1e023}'..='\u{1e024}', '\u{1e026}'..='\u{1e02a}',
+    '\u{1e030}'..='\u{1e06d}', '\u{1e08f}'..='\u{1e08f}', '\u{1e100}'..='\u{1e12c}',
+    '\u{1e137}'..='\u{1e13d}', '\u{1e14e}'..='\u{1e14e}', '\u{1e290}'..='\u{1e2ad}',
+    '\u{1e2c0}'..='\u{1e2eb}', '\u{1e4d0}'..='\u{1e4eb}', '\u{1e5d0}'..='\u{1e5ed}',
+    '\u{1e5f0}'..='\u{1e5f0}', '\u{1e6c0}'..='\u{1e6de}', '\u{1e6e0}'..='\u{1e6f5}',
+    '\u{1e6fe}'..='\u{1e6ff}', '\u{1e7e0}'..='\u{1e7e6}', '\u{1e7e8}'..='\u{1e7eb}',
+    '\u{1e7ed}'..='\u{1e7ee}', '\u{1e7f0}'..='\u{1e7fe}', '\u{1e800}'..='\u{1e8c4}',
+    '\u{1e900}'..='\u{1e943}', '\u{1e947}'..='\u{1e947}', '\u{1e94b}'..='\u{1e94b}',
+    '\u{1ee00}'..='\u{1ee03}', '\u{1ee05}'..='\u{1ee1f}', '\u{1ee21}'..='\u{1ee22}',
+    '\u{1ee24}'..='\u{1ee24}', '\u{1ee27}'..='\u{1ee27}', '\u{1ee29}'..='\u{1ee32}',
+    '\u{1ee34}'..='\u{1ee37}', '\u{1ee39}'..='\u{1ee39}', '\u{1ee3b}'..='\u{1ee3b}',
+    '\u{1ee42}'..='\u{1ee42}', '\u{1ee47}'..='\u{1ee47}', '\u{1ee49}'..='\u{1ee49}',
+    '\u{1ee4b}'..='\u{1ee4b}', '\u{1ee4d}'..='\u{1ee4f}', '\u{1ee51}'..='\u{1ee52}',
+    '\u{1ee54}'..='\u{1ee54}', '\u{1ee57}'..='\u{1ee57}', '\u{1ee59}'..='\u{1ee59}',
+    '\u{1ee5b}'..='\u{1ee5b}', '\u{1ee5d}'..='\u{1ee5d}', '\u{1ee5f}'..='\u{1ee5f}',
+    '\u{1ee61}'..='\u{1ee62}', '\u{1ee64}'..='\u{1ee64}', '\u{1ee67}'..='\u{1ee6a}',
+    '\u{1ee6c}'..='\u{1ee72}', '\u{1ee74}'..='\u{1ee77}', '\u{1ee79}'..='\u{1ee7c}',
+    '\u{1ee7e}'..='\u{1ee7e}', '\u{1ee80}'..='\u{1ee89}', '\u{1ee8b}'..='\u{1ee9b}',
+    '\u{1eea1}'..='\u{1eea3}', '\u{1eea5}'..='\u{1eea9}', '\u{1eeab}'..='\u{1eebb}',
+    '\u{1f130}'..='\u{1f149}', '\u{1f150}'..='\u{1f169}', '\u{1f170}'..='\u{1f189}',
+    '\u{20000}'..='\u{2a6df}', '\u{2a700}'..='\u{2b81d}', '\u{2b820}'..='\u{2cead}',
+    '\u{2ceb0}'..='\u{2ebe0}', '\u{2ebf0}'..='\u{2ee5d}', '\u{2f800}'..='\u{2fa1d}',
+    '\u{30000}'..='\u{3134a}', '\u{31350}'..='\u{33479}',
+];
+
+#[rustfmt::skip]
+pub(super) static CASE_IGNORABLE: &[RangeInclusive<char>; 459] = &[
+    '\u{a8}'..='\u{a8}', '\u{ad}'..='\u{ad}', '\u{af}'..='\u{af}', '\u{b4}'..='\u{b4}',
+    '\u{b7}'..='\u{b8}', '\u{2b0}'..='\u{36f}', '\u{374}'..='\u{375}', '\u{37a}'..='\u{37a}',
+    '\u{384}'..='\u{385}', '\u{387}'..='\u{387}', '\u{483}'..='\u{489}', '\u{559}'..='\u{559}',
+    '\u{55f}'..='\u{55f}', '\u{591}'..='\u{5bd}', '\u{5bf}'..='\u{5bf}', '\u{5c1}'..='\u{5c2}',
+    '\u{5c4}'..='\u{5c5}', '\u{5c7}'..='\u{5c7}', '\u{5f4}'..='\u{5f4}', '\u{600}'..='\u{605}',
+    '\u{610}'..='\u{61a}', '\u{61c}'..='\u{61c}', '\u{640}'..='\u{640}', '\u{64b}'..='\u{65f}',
+    '\u{670}'..='\u{670}', '\u{6d6}'..='\u{6dd}', '\u{6df}'..='\u{6e8}', '\u{6ea}'..='\u{6ed}',
+    '\u{70f}'..='\u{70f}', '\u{711}'..='\u{711}', '\u{730}'..='\u{74a}', '\u{7a6}'..='\u{7b0}',
+    '\u{7eb}'..='\u{7f5}', '\u{7fa}'..='\u{7fa}', '\u{7fd}'..='\u{7fd}', '\u{816}'..='\u{82d}',
+    '\u{859}'..='\u{85b}', '\u{888}'..='\u{888}', '\u{890}'..='\u{891}', '\u{897}'..='\u{89f}',
+    '\u{8c9}'..='\u{902}', '\u{93a}'..='\u{93a}', '\u{93c}'..='\u{93c}', '\u{941}'..='\u{948}',
+    '\u{94d}'..='\u{94d}', '\u{951}'..='\u{957}', '\u{962}'..='\u{963}', '\u{971}'..='\u{971}',
+    '\u{981}'..='\u{981}', '\u{9bc}'..='\u{9bc}', '\u{9c1}'..='\u{9c4}', '\u{9cd}'..='\u{9cd}',
+    '\u{9e2}'..='\u{9e3}', '\u{9fe}'..='\u{9fe}', '\u{a01}'..='\u{a02}', '\u{a3c}'..='\u{a3c}',
+    '\u{a41}'..='\u{a42}', '\u{a47}'..='\u{a48}', '\u{a4b}'..='\u{a4d}', '\u{a51}'..='\u{a51}',
+    '\u{a70}'..='\u{a71}', '\u{a75}'..='\u{a75}', '\u{a81}'..='\u{a82}', '\u{abc}'..='\u{abc}',
+    '\u{ac1}'..='\u{ac5}', '\u{ac7}'..='\u{ac8}', '\u{acd}'..='\u{acd}', '\u{ae2}'..='\u{ae3}',
+    '\u{afa}'..='\u{aff}', '\u{b01}'..='\u{b01}', '\u{b3c}'..='\u{b3c}', '\u{b3f}'..='\u{b3f}',
+    '\u{b41}'..='\u{b44}', '\u{b4d}'..='\u{b4d}', '\u{b55}'..='\u{b56}', '\u{b62}'..='\u{b63}',
+    '\u{b82}'..='\u{b82}', '\u{bc0}'..='\u{bc0}', '\u{bcd}'..='\u{bcd}', '\u{c00}'..='\u{c00}',
+    '\u{c04}'..='\u{c04}', '\u{c3c}'..='\u{c3c}', '\u{c3e}'..='\u{c40}', '\u{c46}'..='\u{c48}',
+    '\u{c4a}'..='\u{c4d}', '\u{c55}'..='\u{c56}', '\u{c62}'..='\u{c63}', '\u{c81}'..='\u{c81}',
+    '\u{cbc}'..='\u{cbc}', '\u{cbf}'..='\u{cbf}', '\u{cc6}'..='\u{cc6}', '\u{ccc}'..='\u{ccd}',
+    '\u{ce2}'..='\u{ce3}', '\u{d00}'..='\u{d01}', '\u{d3b}'..='\u{d3c}', '\u{d41}'..='\u{d44}',
+    '\u{d4d}'..='\u{d4d}', '\u{d62}'..='\u{d63}', '\u{d81}'..='\u{d81}', '\u{dca}'..='\u{dca}',
+    '\u{dd2}'..='\u{dd4}', '\u{dd6}'..='\u{dd6}', '\u{e31}'..='\u{e31}', '\u{e34}'..='\u{e3a}',
+    '\u{e46}'..='\u{e4e}', '\u{eb1}'..='\u{eb1}', '\u{eb4}'..='\u{ebc}', '\u{ec6}'..='\u{ec6}',
+    '\u{ec8}'..='\u{ece}', '\u{f18}'..='\u{f19}', '\u{f35}'..='\u{f35}', '\u{f37}'..='\u{f37}',
+    '\u{f39}'..='\u{f39}', '\u{f71}'..='\u{f7e}', '\u{f80}'..='\u{f84}', '\u{f86}'..='\u{f87}',
+    '\u{f8d}'..='\u{f97}', '\u{f99}'..='\u{fbc}', '\u{fc6}'..='\u{fc6}',
+    '\u{102d}'..='\u{1030}', '\u{1032}'..='\u{1037}', '\u{1039}'..='\u{103a}',
+    '\u{103d}'..='\u{103e}', '\u{1058}'..='\u{1059}', '\u{105e}'..='\u{1060}',
+    '\u{1071}'..='\u{1074}', '\u{1082}'..='\u{1082}', '\u{1085}'..='\u{1086}',
+    '\u{108d}'..='\u{108d}', '\u{109d}'..='\u{109d}', '\u{10fc}'..='\u{10fc}',
+    '\u{135d}'..='\u{135f}', '\u{1712}'..='\u{1714}', '\u{1732}'..='\u{1733}',
+    '\u{1752}'..='\u{1753}', '\u{1772}'..='\u{1773}', '\u{17b4}'..='\u{17b5}',
+    '\u{17b7}'..='\u{17bd}', '\u{17c6}'..='\u{17c6}', '\u{17c9}'..='\u{17d3}',
+    '\u{17d7}'..='\u{17d7}', '\u{17dd}'..='\u{17dd}', '\u{180b}'..='\u{180f}',
+    '\u{1843}'..='\u{1843}', '\u{1885}'..='\u{1886}', '\u{18a9}'..='\u{18a9}',
+    '\u{1920}'..='\u{1922}', '\u{1927}'..='\u{1928}', '\u{1932}'..='\u{1932}',
+    '\u{1939}'..='\u{193b}', '\u{1a17}'..='\u{1a18}', '\u{1a1b}'..='\u{1a1b}',
+    '\u{1a56}'..='\u{1a56}', '\u{1a58}'..='\u{1a5e}', '\u{1a60}'..='\u{1a60}',
+    '\u{1a62}'..='\u{1a62}', '\u{1a65}'..='\u{1a6c}', '\u{1a73}'..='\u{1a7c}',
+    '\u{1a7f}'..='\u{1a7f}', '\u{1aa7}'..='\u{1aa7}', '\u{1ab0}'..='\u{1add}',
+    '\u{1ae0}'..='\u{1aeb}', '\u{1b00}'..='\u{1b03}', '\u{1b34}'..='\u{1b34}',
+    '\u{1b36}'..='\u{1b3a}', '\u{1b3c}'..='\u{1b3c}', '\u{1b42}'..='\u{1b42}',
+    '\u{1b6b}'..='\u{1b73}', '\u{1b80}'..='\u{1b81}', '\u{1ba2}'..='\u{1ba5}',
+    '\u{1ba8}'..='\u{1ba9}', '\u{1bab}'..='\u{1bad}', '\u{1be6}'..='\u{1be6}',
+    '\u{1be8}'..='\u{1be9}', '\u{1bed}'..='\u{1bed}', '\u{1bef}'..='\u{1bf1}',
+    '\u{1c2c}'..='\u{1c33}', '\u{1c36}'..='\u{1c37}', '\u{1c78}'..='\u{1c7d}',
+    '\u{1cd0}'..='\u{1cd2}', '\u{1cd4}'..='\u{1ce0}', '\u{1ce2}'..='\u{1ce8}',
+    '\u{1ced}'..='\u{1ced}', '\u{1cf4}'..='\u{1cf4}', '\u{1cf8}'..='\u{1cf9}',
+    '\u{1d2c}'..='\u{1d6a}', '\u{1d78}'..='\u{1d78}', '\u{1d9b}'..='\u{1dff}',
+    '\u{1fbd}'..='\u{1fbd}', '\u{1fbf}'..='\u{1fc1}', '\u{1fcd}'..='\u{1fcf}',
+    '\u{1fdd}'..='\u{1fdf}', '\u{1fed}'..='\u{1fef}', '\u{1ffd}'..='\u{1ffe}',
+    '\u{200b}'..='\u{200f}', '\u{2018}'..='\u{2019}', '\u{2024}'..='\u{2024}',
+    '\u{2027}'..='\u{2027}', '\u{202a}'..='\u{202e}', '\u{2060}'..='\u{2064}',
+    '\u{2066}'..='\u{206f}', '\u{2071}'..='\u{2071}', '\u{207f}'..='\u{207f}',
+    '\u{2090}'..='\u{209c}', '\u{20d0}'..='\u{20f0}', '\u{2c7c}'..='\u{2c7d}',
+    '\u{2cef}'..='\u{2cf1}', '\u{2d6f}'..='\u{2d6f}', '\u{2d7f}'..='\u{2d7f}',
+    '\u{2de0}'..='\u{2dff}', '\u{2e2f}'..='\u{2e2f}', '\u{3005}'..='\u{3005}',
+    '\u{302a}'..='\u{302d}', '\u{3031}'..='\u{3035}', '\u{303b}'..='\u{303b}',
+    '\u{3099}'..='\u{309e}', '\u{30fc}'..='\u{30fe}', '\u{a015}'..='\u{a015}',
+    '\u{a4f8}'..='\u{a4fd}', '\u{a60c}'..='\u{a60c}', '\u{a66f}'..='\u{a672}',
+    '\u{a674}'..='\u{a67d}', '\u{a67f}'..='\u{a67f}', '\u{a69c}'..='\u{a69f}',
+    '\u{a6f0}'..='\u{a6f1}', '\u{a700}'..='\u{a721}', '\u{a770}'..='\u{a770}',
+    '\u{a788}'..='\u{a78a}', '\u{a7f1}'..='\u{a7f4}', '\u{a7f8}'..='\u{a7f9}',
+    '\u{a802}'..='\u{a802}', '\u{a806}'..='\u{a806}', '\u{a80b}'..='\u{a80b}',
+    '\u{a825}'..='\u{a826}', '\u{a82c}'..='\u{a82c}', '\u{a8c4}'..='\u{a8c5}',
+    '\u{a8e0}'..='\u{a8f1}', '\u{a8ff}'..='\u{a8ff}', '\u{a926}'..='\u{a92d}',
+    '\u{a947}'..='\u{a951}', '\u{a980}'..='\u{a982}', '\u{a9b3}'..='\u{a9b3}',
+    '\u{a9b6}'..='\u{a9b9}', '\u{a9bc}'..='\u{a9bd}', '\u{a9cf}'..='\u{a9cf}',
+    '\u{a9e5}'..='\u{a9e6}', '\u{aa29}'..='\u{aa2e}', '\u{aa31}'..='\u{aa32}',
+    '\u{aa35}'..='\u{aa36}', '\u{aa43}'..='\u{aa43}', '\u{aa4c}'..='\u{aa4c}',
+    '\u{aa70}'..='\u{aa70}', '\u{aa7c}'..='\u{aa7c}', '\u{aab0}'..='\u{aab0}',
+    '\u{aab2}'..='\u{aab4}', '\u{aab7}'..='\u{aab8}', '\u{aabe}'..='\u{aabf}',
+    '\u{aac1}'..='\u{aac1}', '\u{aadd}'..='\u{aadd}', '\u{aaec}'..='\u{aaed}',
+    '\u{aaf3}'..='\u{aaf4}', '\u{aaf6}'..='\u{aaf6}', '\u{ab5b}'..='\u{ab5f}',
+    '\u{ab69}'..='\u{ab6b}', '\u{abe5}'..='\u{abe5}', '\u{abe8}'..='\u{abe8}',
+    '\u{abed}'..='\u{abed}', '\u{fb1e}'..='\u{fb1e}', '\u{fbb2}'..='\u{fbc2}',
+    '\u{fe00}'..='\u{fe0f}', '\u{fe13}'..='\u{fe13}', '\u{fe20}'..='\u{fe2f}',
+    '\u{fe52}'..='\u{fe52}', '\u{fe55}'..='\u{fe55}', '\u{feff}'..='\u{feff}',
+    '\u{ff07}'..='\u{ff07}', '\u{ff0e}'..='\u{ff0e}', '\u{ff1a}'..='\u{ff1a}',
+    '\u{ff3e}'..='\u{ff3e}', '\u{ff40}'..='\u{ff40}', '\u{ff70}'..='\u{ff70}',
+    '\u{ff9e}'..='\u{ff9f}', '\u{ffe3}'..='\u{ffe3}', '\u{fff9}'..='\u{fffb}',
+    '\u{101fd}'..='\u{101fd}', '\u{102e0}'..='\u{102e0}', '\u{10376}'..='\u{1037a}',
+    '\u{10780}'..='\u{10785}', '\u{10787}'..='\u{107b0}', '\u{107b2}'..='\u{107ba}',
+    '\u{10a01}'..='\u{10a03}', '\u{10a05}'..='\u{10a06}', '\u{10a0c}'..='\u{10a0f}',
+    '\u{10a38}'..='\u{10a3a}', '\u{10a3f}'..='\u{10a3f}', '\u{10ae5}'..='\u{10ae6}',
+    '\u{10d24}'..='\u{10d27}', '\u{10d4e}'..='\u{10d4e}', '\u{10d69}'..='\u{10d6d}',
+    '\u{10d6f}'..='\u{10d6f}', '\u{10eab}'..='\u{10eac}', '\u{10ec5}'..='\u{10ec5}',
+    '\u{10efa}'..='\u{10eff}', '\u{10f46}'..='\u{10f50}', '\u{10f82}'..='\u{10f85}',
+    '\u{11001}'..='\u{11001}', '\u{11038}'..='\u{11046}', '\u{11070}'..='\u{11070}',
+    '\u{11073}'..='\u{11074}', '\u{1107f}'..='\u{11081}', '\u{110b3}'..='\u{110b6}',
+    '\u{110b9}'..='\u{110ba}', '\u{110bd}'..='\u{110bd}', '\u{110c2}'..='\u{110c2}',
+    '\u{110cd}'..='\u{110cd}', '\u{11100}'..='\u{11102}', '\u{11127}'..='\u{1112b}',
+    '\u{1112d}'..='\u{11134}', '\u{11173}'..='\u{11173}', '\u{11180}'..='\u{11181}',
+    '\u{111b6}'..='\u{111be}', '\u{111c9}'..='\u{111cc}', '\u{111cf}'..='\u{111cf}',
+    '\u{1122f}'..='\u{11231}', '\u{11234}'..='\u{11234}', '\u{11236}'..='\u{11237}',
+    '\u{1123e}'..='\u{1123e}', '\u{11241}'..='\u{11241}', '\u{112df}'..='\u{112df}',
+    '\u{112e3}'..='\u{112ea}', '\u{11300}'..='\u{11301}', '\u{1133b}'..='\u{1133c}',
+    '\u{11340}'..='\u{11340}', '\u{11366}'..='\u{1136c}', '\u{11370}'..='\u{11374}',
+    '\u{113bb}'..='\u{113c0}', '\u{113ce}'..='\u{113ce}', '\u{113d0}'..='\u{113d0}',
+    '\u{113d2}'..='\u{113d2}', '\u{113e1}'..='\u{113e2}', '\u{11438}'..='\u{1143f}',
+    '\u{11442}'..='\u{11444}', '\u{11446}'..='\u{11446}', '\u{1145e}'..='\u{1145e}',
+    '\u{114b3}'..='\u{114b8}', '\u{114ba}'..='\u{114ba}', '\u{114bf}'..='\u{114c0}',
+    '\u{114c2}'..='\u{114c3}', '\u{115b2}'..='\u{115b5}', '\u{115bc}'..='\u{115bd}',
+    '\u{115bf}'..='\u{115c0}', '\u{115dc}'..='\u{115dd}', '\u{11633}'..='\u{1163a}',
+    '\u{1163d}'..='\u{1163d}', '\u{1163f}'..='\u{11640}', '\u{116ab}'..='\u{116ab}',
+    '\u{116ad}'..='\u{116ad}', '\u{116b0}'..='\u{116b5}', '\u{116b7}'..='\u{116b7}',
+    '\u{1171d}'..='\u{1171d}', '\u{1171f}'..='\u{1171f}', '\u{11722}'..='\u{11725}',
+    '\u{11727}'..='\u{1172b}', '\u{1182f}'..='\u{11837}', '\u{11839}'..='\u{1183a}',
+    '\u{1193b}'..='\u{1193c}', '\u{1193e}'..='\u{1193e}', '\u{11943}'..='\u{11943}',
+    '\u{119d4}'..='\u{119d7}', '\u{119da}'..='\u{119db}', '\u{119e0}'..='\u{119e0}',
+    '\u{11a01}'..='\u{11a0a}', '\u{11a33}'..='\u{11a38}', '\u{11a3b}'..='\u{11a3e}',
+    '\u{11a47}'..='\u{11a47}', '\u{11a51}'..='\u{11a56}', '\u{11a59}'..='\u{11a5b}',
+    '\u{11a8a}'..='\u{11a96}', '\u{11a98}'..='\u{11a99}', '\u{11b60}'..='\u{11b60}',
+    '\u{11b62}'..='\u{11b64}', '\u{11b66}'..='\u{11b66}', '\u{11c30}'..='\u{11c36}',
+    '\u{11c38}'..='\u{11c3d}', '\u{11c3f}'..='\u{11c3f}', '\u{11c92}'..='\u{11ca7}',
+    '\u{11caa}'..='\u{11cb0}', '\u{11cb2}'..='\u{11cb3}', '\u{11cb5}'..='\u{11cb6}',
+    '\u{11d31}'..='\u{11d36}', '\u{11d3a}'..='\u{11d3a}', '\u{11d3c}'..='\u{11d3d}',
+    '\u{11d3f}'..='\u{11d45}', '\u{11d47}'..='\u{11d47}', '\u{11d90}'..='\u{11d91}',
+    '\u{11d95}'..='\u{11d95}', '\u{11d97}'..='\u{11d97}', '\u{11dd9}'..='\u{11dd9}',
+    '\u{11ef3}'..='\u{11ef4}', '\u{11f00}'..='\u{11f01}', '\u{11f36}'..='\u{11f3a}',
+    '\u{11f40}'..='\u{11f40}', '\u{11f42}'..='\u{11f42}', '\u{11f5a}'..='\u{11f5a}',
+    '\u{13430}'..='\u{13440}', '\u{13447}'..='\u{13455}', '\u{1611e}'..='\u{16129}',
+    '\u{1612d}'..='\u{1612f}', '\u{16af0}'..='\u{16af4}', '\u{16b30}'..='\u{16b36}',
+    '\u{16b40}'..='\u{16b43}', '\u{16d40}'..='\u{16d42}', '\u{16d6b}'..='\u{16d6c}',
+    '\u{16f4f}'..='\u{16f4f}', '\u{16f8f}'..='\u{16f9f}', '\u{16fe0}'..='\u{16fe1}',
+    '\u{16fe3}'..='\u{16fe4}', '\u{16ff2}'..='\u{16ff3}', '\u{1aff0}'..='\u{1aff3}',
+    '\u{1aff5}'..='\u{1affb}', '\u{1affd}'..='\u{1affe}', '\u{1bc9d}'..='\u{1bc9e}',
+    '\u{1bca0}'..='\u{1bca3}', '\u{1cf00}'..='\u{1cf2d}', '\u{1cf30}'..='\u{1cf46}',
+    '\u{1d167}'..='\u{1d169}', '\u{1d173}'..='\u{1d182}', '\u{1d185}'..='\u{1d18b}',
+    '\u{1d1aa}'..='\u{1d1ad}', '\u{1d242}'..='\u{1d244}', '\u{1da00}'..='\u{1da36}',
+    '\u{1da3b}'..='\u{1da6c}', '\u{1da75}'..='\u{1da75}', '\u{1da84}'..='\u{1da84}',
+    '\u{1da9b}'..='\u{1da9f}', '\u{1daa1}'..='\u{1daaf}', '\u{1e000}'..='\u{1e006}',
+    '\u{1e008}'..='\u{1e018}', '\u{1e01b}'..='\u{1e021}', '\u{1e023}'..='\u{1e024}',
+    '\u{1e026}'..='\u{1e02a}', '\u{1e030}'..='\u{1e06d}', '\u{1e08f}'..='\u{1e08f}',
+    '\u{1e130}'..='\u{1e13d}', '\u{1e2ae}'..='\u{1e2ae}', '\u{1e2ec}'..='\u{1e2ef}',
+    '\u{1e4eb}'..='\u{1e4ef}', '\u{1e5ee}'..='\u{1e5ef}', '\u{1e6e3}'..='\u{1e6e3}',
+    '\u{1e6e6}'..='\u{1e6e6}', '\u{1e6ee}'..='\u{1e6ef}', '\u{1e6f5}'..='\u{1e6f5}',
+    '\u{1e6ff}'..='\u{1e6ff}', '\u{1e8d0}'..='\u{1e8d6}', '\u{1e944}'..='\u{1e94b}',
+    '\u{1f3fb}'..='\u{1f3ff}', '\u{e0001}'..='\u{e0001}', '\u{e0020}'..='\u{e007f}',
+    '\u{e0100}'..='\u{e01ef}',
+];
+
+#[rustfmt::skip]
+pub(super) static CASED: &[RangeInclusive<char>; 156] = &[
+    '\u{aa}'..='\u{aa}', '\u{b5}'..='\u{b5}', '\u{ba}'..='\u{ba}', '\u{c0}'..='\u{d6}',
+    '\u{d8}'..='\u{f6}', '\u{f8}'..='\u{1ba}', '\u{1bc}'..='\u{1bf}', '\u{1c4}'..='\u{293}',
+    '\u{296}'..='\u{2b8}', '\u{2c0}'..='\u{2c1}', '\u{2e0}'..='\u{2e4}', '\u{345}'..='\u{345}',
+    '\u{370}'..='\u{373}', '\u{376}'..='\u{377}', '\u{37a}'..='\u{37d}', '\u{37f}'..='\u{37f}',
+    '\u{386}'..='\u{386}', '\u{388}'..='\u{38a}', '\u{38c}'..='\u{38c}', '\u{38e}'..='\u{3a1}',
+    '\u{3a3}'..='\u{3f5}', '\u{3f7}'..='\u{481}', '\u{48a}'..='\u{52f}', '\u{531}'..='\u{556}',
+    '\u{560}'..='\u{588}', '\u{10a0}'..='\u{10c5}', '\u{10c7}'..='\u{10c7}',
+    '\u{10cd}'..='\u{10cd}', '\u{10d0}'..='\u{10fa}', '\u{10fc}'..='\u{10ff}',
+    '\u{13a0}'..='\u{13f5}', '\u{13f8}'..='\u{13fd}', '\u{1c80}'..='\u{1c8a}',
+    '\u{1c90}'..='\u{1cba}', '\u{1cbd}'..='\u{1cbf}', '\u{1d00}'..='\u{1dbf}',
+    '\u{1e00}'..='\u{1f15}', '\u{1f18}'..='\u{1f1d}', '\u{1f20}'..='\u{1f45}',
+    '\u{1f48}'..='\u{1f4d}', '\u{1f50}'..='\u{1f57}', '\u{1f59}'..='\u{1f59}',
+    '\u{1f5b}'..='\u{1f5b}', '\u{1f5d}'..='\u{1f5d}', '\u{1f5f}'..='\u{1f7d}',
+    '\u{1f80}'..='\u{1fb4}', '\u{1fb6}'..='\u{1fbc}', '\u{1fbe}'..='\u{1fbe}',
+    '\u{1fc2}'..='\u{1fc4}', '\u{1fc6}'..='\u{1fcc}', '\u{1fd0}'..='\u{1fd3}',
+    '\u{1fd6}'..='\u{1fdb}', '\u{1fe0}'..='\u{1fec}', '\u{1ff2}'..='\u{1ff4}',
+    '\u{1ff6}'..='\u{1ffc}', '\u{2071}'..='\u{2071}', '\u{207f}'..='\u{207f}',
+    '\u{2090}'..='\u{209c}', '\u{2102}'..='\u{2102}', '\u{2107}'..='\u{2107}',
+    '\u{210a}'..='\u{2113}', '\u{2115}'..='\u{2115}', '\u{2119}'..='\u{211d}',
+    '\u{2124}'..='\u{2124}', '\u{2126}'..='\u{2126}', '\u{2128}'..='\u{2128}',
+    '\u{212a}'..='\u{212d}', '\u{212f}'..='\u{2134}', '\u{2139}'..='\u{2139}',
+    '\u{213c}'..='\u{213f}', '\u{2145}'..='\u{2149}', '\u{214e}'..='\u{214e}',
+    '\u{2160}'..='\u{217f}', '\u{2183}'..='\u{2184}', '\u{24b6}'..='\u{24e9}',
+    '\u{2c00}'..='\u{2ce4}', '\u{2ceb}'..='\u{2cee}', '\u{2cf2}'..='\u{2cf3}',
+    '\u{2d00}'..='\u{2d25}', '\u{2d27}'..='\u{2d27}', '\u{2d2d}'..='\u{2d2d}',
+    '\u{a640}'..='\u{a66d}', '\u{a680}'..='\u{a69d}', '\u{a722}'..='\u{a787}',
+    '\u{a78b}'..='\u{a78e}', '\u{a790}'..='\u{a7dc}', '\u{a7f1}'..='\u{a7f6}',
+    '\u{a7f8}'..='\u{a7fa}', '\u{ab30}'..='\u{ab5a}', '\u{ab5c}'..='\u{ab69}',
+    '\u{ab70}'..='\u{abbf}', '\u{fb00}'..='\u{fb06}', '\u{fb13}'..='\u{fb17}',
+    '\u{ff21}'..='\u{ff3a}', '\u{ff41}'..='\u{ff5a}', '\u{10400}'..='\u{1044f}',
+    '\u{104b0}'..='\u{104d3}', '\u{104d8}'..='\u{104fb}', '\u{10570}'..='\u{1057a}',
+    '\u{1057c}'..='\u{1058a}', '\u{1058c}'..='\u{10592}', '\u{10594}'..='\u{10595}',
+    '\u{10597}'..='\u{105a1}', '\u{105a3}'..='\u{105b1}', '\u{105b3}'..='\u{105b9}',
+    '\u{105bb}'..='\u{105bc}', '\u{10780}'..='\u{10780}', '\u{10783}'..='\u{10785}',
+    '\u{10787}'..='\u{107b0}', '\u{107b2}'..='\u{107ba}', '\u{10c80}'..='\u{10cb2}',
+    '\u{10cc0}'..='\u{10cf2}', '\u{10d50}'..='\u{10d65}', '\u{10d70}'..='\u{10d85}',
+    '\u{118a0}'..='\u{118df}', '\u{16e40}'..='\u{16e7f}', '\u{16ea0}'..='\u{16eb8}',
+    '\u{16ebb}'..='\u{16ed3}', '\u{1d400}'..='\u{1d454}', '\u{1d456}'..='\u{1d49c}',
+    '\u{1d49e}'..='\u{1d49f}', '\u{1d4a2}'..='\u{1d4a2}', '\u{1d4a5}'..='\u{1d4a6}',
+    '\u{1d4a9}'..='\u{1d4ac}', '\u{1d4ae}'..='\u{1d4b9}', '\u{1d4bb}'..='\u{1d4bb}',
+    '\u{1d4bd}'..='\u{1d4c3}', '\u{1d4c5}'..='\u{1d505}', '\u{1d507}'..='\u{1d50a}',
+    '\u{1d50d}'..='\u{1d514}', '\u{1d516}'..='\u{1d51c}', '\u{1d51e}'..='\u{1d539}',
+    '\u{1d53b}'..='\u{1d53e}', '\u{1d540}'..='\u{1d544}', '\u{1d546}'..='\u{1d546}',
+    '\u{1d54a}'..='\u{1d550}', '\u{1d552}'..='\u{1d6a5}', '\u{1d6a8}'..='\u{1d6c0}',
+    '\u{1d6c2}'..='\u{1d6da}', '\u{1d6dc}'..='\u{1d6fa}', '\u{1d6fc}'..='\u{1d714}',
+    '\u{1d716}'..='\u{1d734}', '\u{1d736}'..='\u{1d74e}', '\u{1d750}'..='\u{1d76e}',
+    '\u{1d770}'..='\u{1d788}', '\u{1d78a}'..='\u{1d7a8}', '\u{1d7aa}'..='\u{1d7c2}',
+    '\u{1d7c4}'..='\u{1d7cb}', '\u{1df00}'..='\u{1df09}', '\u{1df0b}'..='\u{1df1e}',
+    '\u{1df25}'..='\u{1df2a}', '\u{1e030}'..='\u{1e06d}', '\u{1e900}'..='\u{1e943}',
+    '\u{1f130}'..='\u{1f149}', '\u{1f150}'..='\u{1f169}', '\u{1f170}'..='\u{1f189}',
+];
+
+#[rustfmt::skip]
+pub(super) static GRAPHEME_EXTEND: &[RangeInclusive<char>; 383] = &[
+    '\u{300}'..='\u{36f}', '\u{483}'..='\u{489}', '\u{591}'..='\u{5bd}', '\u{5bf}'..='\u{5bf}',
+    '\u{5c1}'..='\u{5c2}', '\u{5c4}'..='\u{5c5}', '\u{5c7}'..='\u{5c7}', '\u{610}'..='\u{61a}',
+    '\u{64b}'..='\u{65f}', '\u{670}'..='\u{670}', '\u{6d6}'..='\u{6dc}', '\u{6df}'..='\u{6e4}',
+    '\u{6e7}'..='\u{6e8}', '\u{6ea}'..='\u{6ed}', '\u{711}'..='\u{711}', '\u{730}'..='\u{74a}',
+    '\u{7a6}'..='\u{7b0}', '\u{7eb}'..='\u{7f3}', '\u{7fd}'..='\u{7fd}', '\u{816}'..='\u{819}',
+    '\u{81b}'..='\u{823}', '\u{825}'..='\u{827}', '\u{829}'..='\u{82d}', '\u{859}'..='\u{85b}',
+    '\u{897}'..='\u{89f}', '\u{8ca}'..='\u{8e1}', '\u{8e3}'..='\u{902}', '\u{93a}'..='\u{93a}',
+    '\u{93c}'..='\u{93c}', '\u{941}'..='\u{948}', '\u{94d}'..='\u{94d}', '\u{951}'..='\u{957}',
+    '\u{962}'..='\u{963}', '\u{981}'..='\u{981}', '\u{9bc}'..='\u{9bc}', '\u{9be}'..='\u{9be}',
+    '\u{9c1}'..='\u{9c4}', '\u{9cd}'..='\u{9cd}', '\u{9d7}'..='\u{9d7}', '\u{9e2}'..='\u{9e3}',
+    '\u{9fe}'..='\u{9fe}', '\u{a01}'..='\u{a02}', '\u{a3c}'..='\u{a3c}', '\u{a41}'..='\u{a42}',
+    '\u{a47}'..='\u{a48}', '\u{a4b}'..='\u{a4d}', '\u{a51}'..='\u{a51}', '\u{a70}'..='\u{a71}',
+    '\u{a75}'..='\u{a75}', '\u{a81}'..='\u{a82}', '\u{abc}'..='\u{abc}', '\u{ac1}'..='\u{ac5}',
+    '\u{ac7}'..='\u{ac8}', '\u{acd}'..='\u{acd}', '\u{ae2}'..='\u{ae3}', '\u{afa}'..='\u{aff}',
+    '\u{b01}'..='\u{b01}', '\u{b3c}'..='\u{b3c}', '\u{b3e}'..='\u{b3f}', '\u{b41}'..='\u{b44}',
+    '\u{b4d}'..='\u{b4d}', '\u{b55}'..='\u{b57}', '\u{b62}'..='\u{b63}', '\u{b82}'..='\u{b82}',
+    '\u{bbe}'..='\u{bbe}', '\u{bc0}'..='\u{bc0}', '\u{bcd}'..='\u{bcd}', '\u{bd7}'..='\u{bd7}',
+    '\u{c00}'..='\u{c00}', '\u{c04}'..='\u{c04}', '\u{c3c}'..='\u{c3c}', '\u{c3e}'..='\u{c40}',
+    '\u{c46}'..='\u{c48}', '\u{c4a}'..='\u{c4d}', '\u{c55}'..='\u{c56}', '\u{c62}'..='\u{c63}',
+    '\u{c81}'..='\u{c81}', '\u{cbc}'..='\u{cbc}', '\u{cbf}'..='\u{cc0}', '\u{cc2}'..='\u{cc2}',
+    '\u{cc6}'..='\u{cc8}', '\u{cca}'..='\u{ccd}', '\u{cd5}'..='\u{cd6}', '\u{ce2}'..='\u{ce3}',
+    '\u{d00}'..='\u{d01}', '\u{d3b}'..='\u{d3c}', '\u{d3e}'..='\u{d3e}', '\u{d41}'..='\u{d44}',
+    '\u{d4d}'..='\u{d4d}', '\u{d57}'..='\u{d57}', '\u{d62}'..='\u{d63}', '\u{d81}'..='\u{d81}',
+    '\u{dca}'..='\u{dca}', '\u{dcf}'..='\u{dcf}', '\u{dd2}'..='\u{dd4}', '\u{dd6}'..='\u{dd6}',
+    '\u{ddf}'..='\u{ddf}', '\u{e31}'..='\u{e31}', '\u{e34}'..='\u{e3a}', '\u{e47}'..='\u{e4e}',
+    '\u{eb1}'..='\u{eb1}', '\u{eb4}'..='\u{ebc}', '\u{ec8}'..='\u{ece}', '\u{f18}'..='\u{f19}',
+    '\u{f35}'..='\u{f35}', '\u{f37}'..='\u{f37}', '\u{f39}'..='\u{f39}', '\u{f71}'..='\u{f7e}',
+    '\u{f80}'..='\u{f84}', '\u{f86}'..='\u{f87}', '\u{f8d}'..='\u{f97}', '\u{f99}'..='\u{fbc}',
+    '\u{fc6}'..='\u{fc6}', '\u{102d}'..='\u{1030}', '\u{1032}'..='\u{1037}',
+    '\u{1039}'..='\u{103a}', '\u{103d}'..='\u{103e}', '\u{1058}'..='\u{1059}',
+    '\u{105e}'..='\u{1060}', '\u{1071}'..='\u{1074}', '\u{1082}'..='\u{1082}',
+    '\u{1085}'..='\u{1086}', '\u{108d}'..='\u{108d}', '\u{109d}'..='\u{109d}',
+    '\u{135d}'..='\u{135f}', '\u{1712}'..='\u{1715}', '\u{1732}'..='\u{1734}',
+    '\u{1752}'..='\u{1753}', '\u{1772}'..='\u{1773}', '\u{17b4}'..='\u{17b5}',
+    '\u{17b7}'..='\u{17bd}', '\u{17c6}'..='\u{17c6}', '\u{17c9}'..='\u{17d3}',
+    '\u{17dd}'..='\u{17dd}', '\u{180b}'..='\u{180d}', '\u{180f}'..='\u{180f}',
+    '\u{1885}'..='\u{1886}', '\u{18a9}'..='\u{18a9}', '\u{1920}'..='\u{1922}',
+    '\u{1927}'..='\u{1928}', '\u{1932}'..='\u{1932}', '\u{1939}'..='\u{193b}',
+    '\u{1a17}'..='\u{1a18}', '\u{1a1b}'..='\u{1a1b}', '\u{1a56}'..='\u{1a56}',
+    '\u{1a58}'..='\u{1a5e}', '\u{1a60}'..='\u{1a60}', '\u{1a62}'..='\u{1a62}',
+    '\u{1a65}'..='\u{1a6c}', '\u{1a73}'..='\u{1a7c}', '\u{1a7f}'..='\u{1a7f}',
+    '\u{1ab0}'..='\u{1add}', '\u{1ae0}'..='\u{1aeb}', '\u{1b00}'..='\u{1b03}',
+    '\u{1b34}'..='\u{1b3d}', '\u{1b42}'..='\u{1b44}', '\u{1b6b}'..='\u{1b73}',
+    '\u{1b80}'..='\u{1b81}', '\u{1ba2}'..='\u{1ba5}', '\u{1ba8}'..='\u{1bad}',
+    '\u{1be6}'..='\u{1be6}', '\u{1be8}'..='\u{1be9}', '\u{1bed}'..='\u{1bed}',
+    '\u{1bef}'..='\u{1bf3}', '\u{1c2c}'..='\u{1c33}', '\u{1c36}'..='\u{1c37}',
+    '\u{1cd0}'..='\u{1cd2}', '\u{1cd4}'..='\u{1ce0}', '\u{1ce2}'..='\u{1ce8}',
+    '\u{1ced}'..='\u{1ced}', '\u{1cf4}'..='\u{1cf4}', '\u{1cf8}'..='\u{1cf9}',
+    '\u{1dc0}'..='\u{1dff}', '\u{200c}'..='\u{200c}', '\u{20d0}'..='\u{20f0}',
+    '\u{2cef}'..='\u{2cf1}', '\u{2d7f}'..='\u{2d7f}', '\u{2de0}'..='\u{2dff}',
+    '\u{302a}'..='\u{302f}', '\u{3099}'..='\u{309a}', '\u{a66f}'..='\u{a672}',
+    '\u{a674}'..='\u{a67d}', '\u{a69e}'..='\u{a69f}', '\u{a6f0}'..='\u{a6f1}',
+    '\u{a802}'..='\u{a802}', '\u{a806}'..='\u{a806}', '\u{a80b}'..='\u{a80b}',
+    '\u{a825}'..='\u{a826}', '\u{a82c}'..='\u{a82c}', '\u{a8c4}'..='\u{a8c5}',
+    '\u{a8e0}'..='\u{a8f1}', '\u{a8ff}'..='\u{a8ff}', '\u{a926}'..='\u{a92d}',
+    '\u{a947}'..='\u{a951}', '\u{a953}'..='\u{a953}', '\u{a980}'..='\u{a982}',
+    '\u{a9b3}'..='\u{a9b3}', '\u{a9b6}'..='\u{a9b9}', '\u{a9bc}'..='\u{a9bd}',
+    '\u{a9c0}'..='\u{a9c0}', '\u{a9e5}'..='\u{a9e5}', '\u{aa29}'..='\u{aa2e}',
+    '\u{aa31}'..='\u{aa32}', '\u{aa35}'..='\u{aa36}', '\u{aa43}'..='\u{aa43}',
+    '\u{aa4c}'..='\u{aa4c}', '\u{aa7c}'..='\u{aa7c}', '\u{aab0}'..='\u{aab0}',
+    '\u{aab2}'..='\u{aab4}', '\u{aab7}'..='\u{aab8}', '\u{aabe}'..='\u{aabf}',
+    '\u{aac1}'..='\u{aac1}', '\u{aaec}'..='\u{aaed}', '\u{aaf6}'..='\u{aaf6}',
+    '\u{abe5}'..='\u{abe5}', '\u{abe8}'..='\u{abe8}', '\u{abed}'..='\u{abed}',
+    '\u{fb1e}'..='\u{fb1e}', '\u{fe00}'..='\u{fe0f}', '\u{fe20}'..='\u{fe2f}',
+    '\u{ff9e}'..='\u{ff9f}', '\u{101fd}'..='\u{101fd}', '\u{102e0}'..='\u{102e0}',
+    '\u{10376}'..='\u{1037a}', '\u{10a01}'..='\u{10a03}', '\u{10a05}'..='\u{10a06}',
+    '\u{10a0c}'..='\u{10a0f}', '\u{10a38}'..='\u{10a3a}', '\u{10a3f}'..='\u{10a3f}',
+    '\u{10ae5}'..='\u{10ae6}', '\u{10d24}'..='\u{10d27}', '\u{10d69}'..='\u{10d6d}',
+    '\u{10eab}'..='\u{10eac}', '\u{10efa}'..='\u{10eff}', '\u{10f46}'..='\u{10f50}',
+    '\u{10f82}'..='\u{10f85}', '\u{11001}'..='\u{11001}', '\u{11038}'..='\u{11046}',
+    '\u{11070}'..='\u{11070}', '\u{11073}'..='\u{11074}', '\u{1107f}'..='\u{11081}',
+    '\u{110b3}'..='\u{110b6}', '\u{110b9}'..='\u{110ba}', '\u{110c2}'..='\u{110c2}',
+    '\u{11100}'..='\u{11102}', '\u{11127}'..='\u{1112b}', '\u{1112d}'..='\u{11134}',
+    '\u{11173}'..='\u{11173}', '\u{11180}'..='\u{11181}', '\u{111b6}'..='\u{111be}',
+    '\u{111c0}'..='\u{111c0}', '\u{111c9}'..='\u{111cc}', '\u{111cf}'..='\u{111cf}',
+    '\u{1122f}'..='\u{11231}', '\u{11234}'..='\u{11237}', '\u{1123e}'..='\u{1123e}',
+    '\u{11241}'..='\u{11241}', '\u{112df}'..='\u{112df}', '\u{112e3}'..='\u{112ea}',
+    '\u{11300}'..='\u{11301}', '\u{1133b}'..='\u{1133c}', '\u{1133e}'..='\u{1133e}',
+    '\u{11340}'..='\u{11340}', '\u{1134d}'..='\u{1134d}', '\u{11357}'..='\u{11357}',
+    '\u{11366}'..='\u{1136c}', '\u{11370}'..='\u{11374}', '\u{113b8}'..='\u{113b8}',
+    '\u{113bb}'..='\u{113c0}', '\u{113c2}'..='\u{113c2}', '\u{113c5}'..='\u{113c5}',
+    '\u{113c7}'..='\u{113c9}', '\u{113ce}'..='\u{113d0}', '\u{113d2}'..='\u{113d2}',
+    '\u{113e1}'..='\u{113e2}', '\u{11438}'..='\u{1143f}', '\u{11442}'..='\u{11444}',
+    '\u{11446}'..='\u{11446}', '\u{1145e}'..='\u{1145e}', '\u{114b0}'..='\u{114b0}',
+    '\u{114b3}'..='\u{114b8}', '\u{114ba}'..='\u{114ba}', '\u{114bd}'..='\u{114bd}',
+    '\u{114bf}'..='\u{114c0}', '\u{114c2}'..='\u{114c3}', '\u{115af}'..='\u{115af}',
+    '\u{115b2}'..='\u{115b5}', '\u{115bc}'..='\u{115bd}', '\u{115bf}'..='\u{115c0}',
+    '\u{115dc}'..='\u{115dd}', '\u{11633}'..='\u{1163a}', '\u{1163d}'..='\u{1163d}',
+    '\u{1163f}'..='\u{11640}', '\u{116ab}'..='\u{116ab}', '\u{116ad}'..='\u{116ad}',
+    '\u{116b0}'..='\u{116b7}', '\u{1171d}'..='\u{1171d}', '\u{1171f}'..='\u{1171f}',
+    '\u{11722}'..='\u{11725}', '\u{11727}'..='\u{1172b}', '\u{1182f}'..='\u{11837}',
+    '\u{11839}'..='\u{1183a}', '\u{11930}'..='\u{11930}', '\u{1193b}'..='\u{1193e}',
+    '\u{11943}'..='\u{11943}', '\u{119d4}'..='\u{119d7}', '\u{119da}'..='\u{119db}',
+    '\u{119e0}'..='\u{119e0}', '\u{11a01}'..='\u{11a0a}', '\u{11a33}'..='\u{11a38}',
+    '\u{11a3b}'..='\u{11a3e}', '\u{11a47}'..='\u{11a47}', '\u{11a51}'..='\u{11a56}',
+    '\u{11a59}'..='\u{11a5b}', '\u{11a8a}'..='\u{11a96}', '\u{11a98}'..='\u{11a99}',
+    '\u{11b60}'..='\u{11b60}', '\u{11b62}'..='\u{11b64}', '\u{11b66}'..='\u{11b66}',
+    '\u{11c30}'..='\u{11c36}', '\u{11c38}'..='\u{11c3d}', '\u{11c3f}'..='\u{11c3f}',
+    '\u{11c92}'..='\u{11ca7}', '\u{11caa}'..='\u{11cb0}', '\u{11cb2}'..='\u{11cb3}',
+    '\u{11cb5}'..='\u{11cb6}', '\u{11d31}'..='\u{11d36}', '\u{11d3a}'..='\u{11d3a}',
+    '\u{11d3c}'..='\u{11d3d}', '\u{11d3f}'..='\u{11d45}', '\u{11d47}'..='\u{11d47}',
+    '\u{11d90}'..='\u{11d91}', '\u{11d95}'..='\u{11d95}', '\u{11d97}'..='\u{11d97}',
+    '\u{11ef3}'..='\u{11ef4}', '\u{11f00}'..='\u{11f01}', '\u{11f36}'..='\u{11f3a}',
+    '\u{11f40}'..='\u{11f42}', '\u{11f5a}'..='\u{11f5a}', '\u{13440}'..='\u{13440}',
+    '\u{13447}'..='\u{13455}', '\u{1611e}'..='\u{16129}', '\u{1612d}'..='\u{1612f}',
+    '\u{16af0}'..='\u{16af4}', '\u{16b30}'..='\u{16b36}', '\u{16f4f}'..='\u{16f4f}',
+    '\u{16f8f}'..='\u{16f92}', '\u{16fe4}'..='\u{16fe4}', '\u{16ff0}'..='\u{16ff1}',
+    '\u{1bc9d}'..='\u{1bc9e}', '\u{1cf00}'..='\u{1cf2d}', '\u{1cf30}'..='\u{1cf46}',
+    '\u{1d165}'..='\u{1d169}', '\u{1d16d}'..='\u{1d172}', '\u{1d17b}'..='\u{1d182}',
+    '\u{1d185}'..='\u{1d18b}', '\u{1d1aa}'..='\u{1d1ad}', '\u{1d242}'..='\u{1d244}',
+    '\u{1da00}'..='\u{1da36}', '\u{1da3b}'..='\u{1da6c}', '\u{1da75}'..='\u{1da75}',
+    '\u{1da84}'..='\u{1da84}', '\u{1da9b}'..='\u{1da9f}', '\u{1daa1}'..='\u{1daaf}',
+    '\u{1e000}'..='\u{1e006}', '\u{1e008}'..='\u{1e018}', '\u{1e01b}'..='\u{1e021}',
+    '\u{1e023}'..='\u{1e024}', '\u{1e026}'..='\u{1e02a}', '\u{1e08f}'..='\u{1e08f}',
+    '\u{1e130}'..='\u{1e136}', '\u{1e2ae}'..='\u{1e2ae}', '\u{1e2ec}'..='\u{1e2ef}',
+    '\u{1e4ec}'..='\u{1e4ef}', '\u{1e5ee}'..='\u{1e5ef}', '\u{1e6e3}'..='\u{1e6e3}',
+    '\u{1e6e6}'..='\u{1e6e6}', '\u{1e6ee}'..='\u{1e6ef}', '\u{1e6f5}'..='\u{1e6f5}',
+    '\u{1e8d0}'..='\u{1e8d6}', '\u{1e944}'..='\u{1e94a}', '\u{e0020}'..='\u{e007f}',
+    '\u{e0100}'..='\u{e01ef}',
+];
+
+#[rustfmt::skip]
+pub(super) static LOWERCASE: &[RangeInclusive<char>; 676] = &[
+    '\u{aa}'..='\u{aa}', '\u{b5}'..='\u{b5}', '\u{ba}'..='\u{ba}', '\u{df}'..='\u{f6}',
+    '\u{f8}'..='\u{ff}', '\u{101}'..='\u{101}', '\u{103}'..='\u{103}', '\u{105}'..='\u{105}',
+    '\u{107}'..='\u{107}', '\u{109}'..='\u{109}', '\u{10b}'..='\u{10b}', '\u{10d}'..='\u{10d}',
+    '\u{10f}'..='\u{10f}', '\u{111}'..='\u{111}', '\u{113}'..='\u{113}', '\u{115}'..='\u{115}',
+    '\u{117}'..='\u{117}', '\u{119}'..='\u{119}', '\u{11b}'..='\u{11b}', '\u{11d}'..='\u{11d}',
+    '\u{11f}'..='\u{11f}', '\u{121}'..='\u{121}', '\u{123}'..='\u{123}', '\u{125}'..='\u{125}',
+    '\u{127}'..='\u{127}', '\u{129}'..='\u{129}', '\u{12b}'..='\u{12b}', '\u{12d}'..='\u{12d}',
+    '\u{12f}'..='\u{12f}', '\u{131}'..='\u{131}', '\u{133}'..='\u{133}', '\u{135}'..='\u{135}',
+    '\u{137}'..='\u{138}', '\u{13a}'..='\u{13a}', '\u{13c}'..='\u{13c}', '\u{13e}'..='\u{13e}',
+    '\u{140}'..='\u{140}', '\u{142}'..='\u{142}', '\u{144}'..='\u{144}', '\u{146}'..='\u{146}',
+    '\u{148}'..='\u{149}', '\u{14b}'..='\u{14b}', '\u{14d}'..='\u{14d}', '\u{14f}'..='\u{14f}',
+    '\u{151}'..='\u{151}', '\u{153}'..='\u{153}', '\u{155}'..='\u{155}', '\u{157}'..='\u{157}',
+    '\u{159}'..='\u{159}', '\u{15b}'..='\u{15b}', '\u{15d}'..='\u{15d}', '\u{15f}'..='\u{15f}',
+    '\u{161}'..='\u{161}', '\u{163}'..='\u{163}', '\u{165}'..='\u{165}', '\u{167}'..='\u{167}',
+    '\u{169}'..='\u{169}', '\u{16b}'..='\u{16b}', '\u{16d}'..='\u{16d}', '\u{16f}'..='\u{16f}',
+    '\u{171}'..='\u{171}', '\u{173}'..='\u{173}', '\u{175}'..='\u{175}', '\u{177}'..='\u{177}',
+    '\u{17a}'..='\u{17a}', '\u{17c}'..='\u{17c}', '\u{17e}'..='\u{180}', '\u{183}'..='\u{183}',
+    '\u{185}'..='\u{185}', '\u{188}'..='\u{188}', '\u{18c}'..='\u{18d}', '\u{192}'..='\u{192}',
+    '\u{195}'..='\u{195}', '\u{199}'..='\u{19b}', '\u{19e}'..='\u{19e}', '\u{1a1}'..='\u{1a1}',
+    '\u{1a3}'..='\u{1a3}', '\u{1a5}'..='\u{1a5}', '\u{1a8}'..='\u{1a8}', '\u{1aa}'..='\u{1ab}',
+    '\u{1ad}'..='\u{1ad}', '\u{1b0}'..='\u{1b0}', '\u{1b4}'..='\u{1b4}', '\u{1b6}'..='\u{1b6}',
+    '\u{1b9}'..='\u{1ba}', '\u{1bd}'..='\u{1bf}', '\u{1c6}'..='\u{1c6}', '\u{1c9}'..='\u{1c9}',
+    '\u{1cc}'..='\u{1cc}', '\u{1ce}'..='\u{1ce}', '\u{1d0}'..='\u{1d0}', '\u{1d2}'..='\u{1d2}',
+    '\u{1d4}'..='\u{1d4}', '\u{1d6}'..='\u{1d6}', '\u{1d8}'..='\u{1d8}', '\u{1da}'..='\u{1da}',
+    '\u{1dc}'..='\u{1dd}', '\u{1df}'..='\u{1df}', '\u{1e1}'..='\u{1e1}', '\u{1e3}'..='\u{1e3}',
+    '\u{1e5}'..='\u{1e5}', '\u{1e7}'..='\u{1e7}', '\u{1e9}'..='\u{1e9}', '\u{1eb}'..='\u{1eb}',
+    '\u{1ed}'..='\u{1ed}', '\u{1ef}'..='\u{1f0}', '\u{1f3}'..='\u{1f3}', '\u{1f5}'..='\u{1f5}',
+    '\u{1f9}'..='\u{1f9}', '\u{1fb}'..='\u{1fb}', '\u{1fd}'..='\u{1fd}', '\u{1ff}'..='\u{1ff}',
+    '\u{201}'..='\u{201}', '\u{203}'..='\u{203}', '\u{205}'..='\u{205}', '\u{207}'..='\u{207}',
+    '\u{209}'..='\u{209}', '\u{20b}'..='\u{20b}', '\u{20d}'..='\u{20d}', '\u{20f}'..='\u{20f}',
+    '\u{211}'..='\u{211}', '\u{213}'..='\u{213}', '\u{215}'..='\u{215}', '\u{217}'..='\u{217}',
+    '\u{219}'..='\u{219}', '\u{21b}'..='\u{21b}', '\u{21d}'..='\u{21d}', '\u{21f}'..='\u{21f}',
+    '\u{221}'..='\u{221}', '\u{223}'..='\u{223}', '\u{225}'..='\u{225}', '\u{227}'..='\u{227}',
+    '\u{229}'..='\u{229}', '\u{22b}'..='\u{22b}', '\u{22d}'..='\u{22d}', '\u{22f}'..='\u{22f}',
+    '\u{231}'..='\u{231}', '\u{233}'..='\u{239}', '\u{23c}'..='\u{23c}', '\u{23f}'..='\u{240}',
+    '\u{242}'..='\u{242}', '\u{247}'..='\u{247}', '\u{249}'..='\u{249}', '\u{24b}'..='\u{24b}',
+    '\u{24d}'..='\u{24d}', '\u{24f}'..='\u{293}', '\u{296}'..='\u{2b8}', '\u{2c0}'..='\u{2c1}',
+    '\u{2e0}'..='\u{2e4}', '\u{345}'..='\u{345}', '\u{371}'..='\u{371}', '\u{373}'..='\u{373}',
+    '\u{377}'..='\u{377}', '\u{37a}'..='\u{37d}', '\u{390}'..='\u{390}', '\u{3ac}'..='\u{3ce}',
+    '\u{3d0}'..='\u{3d1}', '\u{3d5}'..='\u{3d7}', '\u{3d9}'..='\u{3d9}', '\u{3db}'..='\u{3db}',
+    '\u{3dd}'..='\u{3dd}', '\u{3df}'..='\u{3df}', '\u{3e1}'..='\u{3e1}', '\u{3e3}'..='\u{3e3}',
+    '\u{3e5}'..='\u{3e5}', '\u{3e7}'..='\u{3e7}', '\u{3e9}'..='\u{3e9}', '\u{3eb}'..='\u{3eb}',
+    '\u{3ed}'..='\u{3ed}', '\u{3ef}'..='\u{3f3}', '\u{3f5}'..='\u{3f5}', '\u{3f8}'..='\u{3f8}',
+    '\u{3fb}'..='\u{3fc}', '\u{430}'..='\u{45f}', '\u{461}'..='\u{461}', '\u{463}'..='\u{463}',
+    '\u{465}'..='\u{465}', '\u{467}'..='\u{467}', '\u{469}'..='\u{469}', '\u{46b}'..='\u{46b}',
+    '\u{46d}'..='\u{46d}', '\u{46f}'..='\u{46f}', '\u{471}'..='\u{471}', '\u{473}'..='\u{473}',
+    '\u{475}'..='\u{475}', '\u{477}'..='\u{477}', '\u{479}'..='\u{479}', '\u{47b}'..='\u{47b}',
+    '\u{47d}'..='\u{47d}', '\u{47f}'..='\u{47f}', '\u{481}'..='\u{481}', '\u{48b}'..='\u{48b}',
+    '\u{48d}'..='\u{48d}', '\u{48f}'..='\u{48f}', '\u{491}'..='\u{491}', '\u{493}'..='\u{493}',
+    '\u{495}'..='\u{495}', '\u{497}'..='\u{497}', '\u{499}'..='\u{499}', '\u{49b}'..='\u{49b}',
+    '\u{49d}'..='\u{49d}', '\u{49f}'..='\u{49f}', '\u{4a1}'..='\u{4a1}', '\u{4a3}'..='\u{4a3}',
+    '\u{4a5}'..='\u{4a5}', '\u{4a7}'..='\u{4a7}', '\u{4a9}'..='\u{4a9}', '\u{4ab}'..='\u{4ab}',
+    '\u{4ad}'..='\u{4ad}', '\u{4af}'..='\u{4af}', '\u{4b1}'..='\u{4b1}', '\u{4b3}'..='\u{4b3}',
+    '\u{4b5}'..='\u{4b5}', '\u{4b7}'..='\u{4b7}', '\u{4b9}'..='\u{4b9}', '\u{4bb}'..='\u{4bb}',
+    '\u{4bd}'..='\u{4bd}', '\u{4bf}'..='\u{4bf}', '\u{4c2}'..='\u{4c2}', '\u{4c4}'..='\u{4c4}',
+    '\u{4c6}'..='\u{4c6}', '\u{4c8}'..='\u{4c8}', '\u{4ca}'..='\u{4ca}', '\u{4cc}'..='\u{4cc}',
+    '\u{4ce}'..='\u{4cf}', '\u{4d1}'..='\u{4d1}', '\u{4d3}'..='\u{4d3}', '\u{4d5}'..='\u{4d5}',
+    '\u{4d7}'..='\u{4d7}', '\u{4d9}'..='\u{4d9}', '\u{4db}'..='\u{4db}', '\u{4dd}'..='\u{4dd}',
+    '\u{4df}'..='\u{4df}', '\u{4e1}'..='\u{4e1}', '\u{4e3}'..='\u{4e3}', '\u{4e5}'..='\u{4e5}',
+    '\u{4e7}'..='\u{4e7}', '\u{4e9}'..='\u{4e9}', '\u{4eb}'..='\u{4eb}', '\u{4ed}'..='\u{4ed}',
+    '\u{4ef}'..='\u{4ef}', '\u{4f1}'..='\u{4f1}', '\u{4f3}'..='\u{4f3}', '\u{4f5}'..='\u{4f5}',
+    '\u{4f7}'..='\u{4f7}', '\u{4f9}'..='\u{4f9}', '\u{4fb}'..='\u{4fb}', '\u{4fd}'..='\u{4fd}',
+    '\u{4ff}'..='\u{4ff}', '\u{501}'..='\u{501}', '\u{503}'..='\u{503}', '\u{505}'..='\u{505}',
+    '\u{507}'..='\u{507}', '\u{509}'..='\u{509}', '\u{50b}'..='\u{50b}', '\u{50d}'..='\u{50d}',
+    '\u{50f}'..='\u{50f}', '\u{511}'..='\u{511}', '\u{513}'..='\u{513}', '\u{515}'..='\u{515}',
+    '\u{517}'..='\u{517}', '\u{519}'..='\u{519}', '\u{51b}'..='\u{51b}', '\u{51d}'..='\u{51d}',
+    '\u{51f}'..='\u{51f}', '\u{521}'..='\u{521}', '\u{523}'..='\u{523}', '\u{525}'..='\u{525}',
+    '\u{527}'..='\u{527}', '\u{529}'..='\u{529}', '\u{52b}'..='\u{52b}', '\u{52d}'..='\u{52d}',
+    '\u{52f}'..='\u{52f}', '\u{560}'..='\u{588}', '\u{10d0}'..='\u{10fa}',
+    '\u{10fc}'..='\u{10ff}', '\u{13f8}'..='\u{13fd}', '\u{1c80}'..='\u{1c88}',
+    '\u{1c8a}'..='\u{1c8a}', '\u{1d00}'..='\u{1dbf}', '\u{1e01}'..='\u{1e01}',
+    '\u{1e03}'..='\u{1e03}', '\u{1e05}'..='\u{1e05}', '\u{1e07}'..='\u{1e07}',
+    '\u{1e09}'..='\u{1e09}', '\u{1e0b}'..='\u{1e0b}', '\u{1e0d}'..='\u{1e0d}',
+    '\u{1e0f}'..='\u{1e0f}', '\u{1e11}'..='\u{1e11}', '\u{1e13}'..='\u{1e13}',
+    '\u{1e15}'..='\u{1e15}', '\u{1e17}'..='\u{1e17}', '\u{1e19}'..='\u{1e19}',
+    '\u{1e1b}'..='\u{1e1b}', '\u{1e1d}'..='\u{1e1d}', '\u{1e1f}'..='\u{1e1f}',
+    '\u{1e21}'..='\u{1e21}', '\u{1e23}'..='\u{1e23}', '\u{1e25}'..='\u{1e25}',
+    '\u{1e27}'..='\u{1e27}', '\u{1e29}'..='\u{1e29}', '\u{1e2b}'..='\u{1e2b}',
+    '\u{1e2d}'..='\u{1e2d}', '\u{1e2f}'..='\u{1e2f}', '\u{1e31}'..='\u{1e31}',
+    '\u{1e33}'..='\u{1e33}', '\u{1e35}'..='\u{1e35}', '\u{1e37}'..='\u{1e37}',
+    '\u{1e39}'..='\u{1e39}', '\u{1e3b}'..='\u{1e3b}', '\u{1e3d}'..='\u{1e3d}',
+    '\u{1e3f}'..='\u{1e3f}', '\u{1e41}'..='\u{1e41}', '\u{1e43}'..='\u{1e43}',
+    '\u{1e45}'..='\u{1e45}', '\u{1e47}'..='\u{1e47}', '\u{1e49}'..='\u{1e49}',
+    '\u{1e4b}'..='\u{1e4b}', '\u{1e4d}'..='\u{1e4d}', '\u{1e4f}'..='\u{1e4f}',
+    '\u{1e51}'..='\u{1e51}', '\u{1e53}'..='\u{1e53}', '\u{1e55}'..='\u{1e55}',
+    '\u{1e57}'..='\u{1e57}', '\u{1e59}'..='\u{1e59}', '\u{1e5b}'..='\u{1e5b}',
+    '\u{1e5d}'..='\u{1e5d}', '\u{1e5f}'..='\u{1e5f}', '\u{1e61}'..='\u{1e61}',
+    '\u{1e63}'..='\u{1e63}', '\u{1e65}'..='\u{1e65}', '\u{1e67}'..='\u{1e67}',
+    '\u{1e69}'..='\u{1e69}', '\u{1e6b}'..='\u{1e6b}', '\u{1e6d}'..='\u{1e6d}',
+    '\u{1e6f}'..='\u{1e6f}', '\u{1e71}'..='\u{1e71}', '\u{1e73}'..='\u{1e73}',
+    '\u{1e75}'..='\u{1e75}', '\u{1e77}'..='\u{1e77}', '\u{1e79}'..='\u{1e79}',
+    '\u{1e7b}'..='\u{1e7b}', '\u{1e7d}'..='\u{1e7d}', '\u{1e7f}'..='\u{1e7f}',
+    '\u{1e81}'..='\u{1e81}', '\u{1e83}'..='\u{1e83}', '\u{1e85}'..='\u{1e85}',
+    '\u{1e87}'..='\u{1e87}', '\u{1e89}'..='\u{1e89}', '\u{1e8b}'..='\u{1e8b}',
+    '\u{1e8d}'..='\u{1e8d}', '\u{1e8f}'..='\u{1e8f}', '\u{1e91}'..='\u{1e91}',
+    '\u{1e93}'..='\u{1e93}', '\u{1e95}'..='\u{1e9d}', '\u{1e9f}'..='\u{1e9f}',
+    '\u{1ea1}'..='\u{1ea1}', '\u{1ea3}'..='\u{1ea3}', '\u{1ea5}'..='\u{1ea5}',
+    '\u{1ea7}'..='\u{1ea7}', '\u{1ea9}'..='\u{1ea9}', '\u{1eab}'..='\u{1eab}',
+    '\u{1ead}'..='\u{1ead}', '\u{1eaf}'..='\u{1eaf}', '\u{1eb1}'..='\u{1eb1}',
+    '\u{1eb3}'..='\u{1eb3}', '\u{1eb5}'..='\u{1eb5}', '\u{1eb7}'..='\u{1eb7}',
+    '\u{1eb9}'..='\u{1eb9}', '\u{1ebb}'..='\u{1ebb}', '\u{1ebd}'..='\u{1ebd}',
+    '\u{1ebf}'..='\u{1ebf}', '\u{1ec1}'..='\u{1ec1}', '\u{1ec3}'..='\u{1ec3}',
+    '\u{1ec5}'..='\u{1ec5}', '\u{1ec7}'..='\u{1ec7}', '\u{1ec9}'..='\u{1ec9}',
+    '\u{1ecb}'..='\u{1ecb}', '\u{1ecd}'..='\u{1ecd}', '\u{1ecf}'..='\u{1ecf}',
+    '\u{1ed1}'..='\u{1ed1}', '\u{1ed3}'..='\u{1ed3}', '\u{1ed5}'..='\u{1ed5}',
+    '\u{1ed7}'..='\u{1ed7}', '\u{1ed9}'..='\u{1ed9}', '\u{1edb}'..='\u{1edb}',
+    '\u{1edd}'..='\u{1edd}', '\u{1edf}'..='\u{1edf}', '\u{1ee1}'..='\u{1ee1}',
+    '\u{1ee3}'..='\u{1ee3}', '\u{1ee5}'..='\u{1ee5}', '\u{1ee7}'..='\u{1ee7}',
+    '\u{1ee9}'..='\u{1ee9}', '\u{1eeb}'..='\u{1eeb}', '\u{1eed}'..='\u{1eed}',
+    '\u{1eef}'..='\u{1eef}', '\u{1ef1}'..='\u{1ef1}', '\u{1ef3}'..='\u{1ef3}',
+    '\u{1ef5}'..='\u{1ef5}', '\u{1ef7}'..='\u{1ef7}', '\u{1ef9}'..='\u{1ef9}',
+    '\u{1efb}'..='\u{1efb}', '\u{1efd}'..='\u{1efd}', '\u{1eff}'..='\u{1f07}',
+    '\u{1f10}'..='\u{1f15}', '\u{1f20}'..='\u{1f27}', '\u{1f30}'..='\u{1f37}',
+    '\u{1f40}'..='\u{1f45}', '\u{1f50}'..='\u{1f57}', '\u{1f60}'..='\u{1f67}',
+    '\u{1f70}'..='\u{1f7d}', '\u{1f80}'..='\u{1f87}', '\u{1f90}'..='\u{1f97}',
+    '\u{1fa0}'..='\u{1fa7}', '\u{1fb0}'..='\u{1fb4}', '\u{1fb6}'..='\u{1fb7}',
+    '\u{1fbe}'..='\u{1fbe}', '\u{1fc2}'..='\u{1fc4}', '\u{1fc6}'..='\u{1fc7}',
+    '\u{1fd0}'..='\u{1fd3}', '\u{1fd6}'..='\u{1fd7}', '\u{1fe0}'..='\u{1fe7}',
+    '\u{1ff2}'..='\u{1ff4}', '\u{1ff6}'..='\u{1ff7}', '\u{2071}'..='\u{2071}',
+    '\u{207f}'..='\u{207f}', '\u{2090}'..='\u{209c}', '\u{210a}'..='\u{210a}',
+    '\u{210e}'..='\u{210f}', '\u{2113}'..='\u{2113}', '\u{212f}'..='\u{212f}',
+    '\u{2134}'..='\u{2134}', '\u{2139}'..='\u{2139}', '\u{213c}'..='\u{213d}',
+    '\u{2146}'..='\u{2149}', '\u{214e}'..='\u{214e}', '\u{2170}'..='\u{217f}',
+    '\u{2184}'..='\u{2184}', '\u{24d0}'..='\u{24e9}', '\u{2c30}'..='\u{2c5f}',
+    '\u{2c61}'..='\u{2c61}', '\u{2c65}'..='\u{2c66}', '\u{2c68}'..='\u{2c68}',
+    '\u{2c6a}'..='\u{2c6a}', '\u{2c6c}'..='\u{2c6c}', '\u{2c71}'..='\u{2c71}',
+    '\u{2c73}'..='\u{2c74}', '\u{2c76}'..='\u{2c7d}', '\u{2c81}'..='\u{2c81}',
+    '\u{2c83}'..='\u{2c83}', '\u{2c85}'..='\u{2c85}', '\u{2c87}'..='\u{2c87}',
+    '\u{2c89}'..='\u{2c89}', '\u{2c8b}'..='\u{2c8b}', '\u{2c8d}'..='\u{2c8d}',
+    '\u{2c8f}'..='\u{2c8f}', '\u{2c91}'..='\u{2c91}', '\u{2c93}'..='\u{2c93}',
+    '\u{2c95}'..='\u{2c95}', '\u{2c97}'..='\u{2c97}', '\u{2c99}'..='\u{2c99}',
+    '\u{2c9b}'..='\u{2c9b}', '\u{2c9d}'..='\u{2c9d}', '\u{2c9f}'..='\u{2c9f}',
+    '\u{2ca1}'..='\u{2ca1}', '\u{2ca3}'..='\u{2ca3}', '\u{2ca5}'..='\u{2ca5}',
+    '\u{2ca7}'..='\u{2ca7}', '\u{2ca9}'..='\u{2ca9}', '\u{2cab}'..='\u{2cab}',
+    '\u{2cad}'..='\u{2cad}', '\u{2caf}'..='\u{2caf}', '\u{2cb1}'..='\u{2cb1}',
+    '\u{2cb3}'..='\u{2cb3}', '\u{2cb5}'..='\u{2cb5}', '\u{2cb7}'..='\u{2cb7}',
+    '\u{2cb9}'..='\u{2cb9}', '\u{2cbb}'..='\u{2cbb}', '\u{2cbd}'..='\u{2cbd}',
+    '\u{2cbf}'..='\u{2cbf}', '\u{2cc1}'..='\u{2cc1}', '\u{2cc3}'..='\u{2cc3}',
+    '\u{2cc5}'..='\u{2cc5}', '\u{2cc7}'..='\u{2cc7}', '\u{2cc9}'..='\u{2cc9}',
+    '\u{2ccb}'..='\u{2ccb}', '\u{2ccd}'..='\u{2ccd}', '\u{2ccf}'..='\u{2ccf}',
+    '\u{2cd1}'..='\u{2cd1}', '\u{2cd3}'..='\u{2cd3}', '\u{2cd5}'..='\u{2cd5}',
+    '\u{2cd7}'..='\u{2cd7}', '\u{2cd9}'..='\u{2cd9}', '\u{2cdb}'..='\u{2cdb}',
+    '\u{2cdd}'..='\u{2cdd}', '\u{2cdf}'..='\u{2cdf}', '\u{2ce1}'..='\u{2ce1}',
+    '\u{2ce3}'..='\u{2ce4}', '\u{2cec}'..='\u{2cec}', '\u{2cee}'..='\u{2cee}',
+    '\u{2cf3}'..='\u{2cf3}', '\u{2d00}'..='\u{2d25}', '\u{2d27}'..='\u{2d27}',
+    '\u{2d2d}'..='\u{2d2d}', '\u{a641}'..='\u{a641}', '\u{a643}'..='\u{a643}',
+    '\u{a645}'..='\u{a645}', '\u{a647}'..='\u{a647}', '\u{a649}'..='\u{a649}',
+    '\u{a64b}'..='\u{a64b}', '\u{a64d}'..='\u{a64d}', '\u{a64f}'..='\u{a64f}',
+    '\u{a651}'..='\u{a651}', '\u{a653}'..='\u{a653}', '\u{a655}'..='\u{a655}',
+    '\u{a657}'..='\u{a657}', '\u{a659}'..='\u{a659}', '\u{a65b}'..='\u{a65b}',
+    '\u{a65d}'..='\u{a65d}', '\u{a65f}'..='\u{a65f}', '\u{a661}'..='\u{a661}',
+    '\u{a663}'..='\u{a663}', '\u{a665}'..='\u{a665}', '\u{a667}'..='\u{a667}',
+    '\u{a669}'..='\u{a669}', '\u{a66b}'..='\u{a66b}', '\u{a66d}'..='\u{a66d}',
+    '\u{a681}'..='\u{a681}', '\u{a683}'..='\u{a683}', '\u{a685}'..='\u{a685}',
+    '\u{a687}'..='\u{a687}', '\u{a689}'..='\u{a689}', '\u{a68b}'..='\u{a68b}',
+    '\u{a68d}'..='\u{a68d}', '\u{a68f}'..='\u{a68f}', '\u{a691}'..='\u{a691}',
+    '\u{a693}'..='\u{a693}', '\u{a695}'..='\u{a695}', '\u{a697}'..='\u{a697}',
+    '\u{a699}'..='\u{a699}', '\u{a69b}'..='\u{a69d}', '\u{a723}'..='\u{a723}',
+    '\u{a725}'..='\u{a725}', '\u{a727}'..='\u{a727}', '\u{a729}'..='\u{a729}',
+    '\u{a72b}'..='\u{a72b}', '\u{a72d}'..='\u{a72d}', '\u{a72f}'..='\u{a731}',
+    '\u{a733}'..='\u{a733}', '\u{a735}'..='\u{a735}', '\u{a737}'..='\u{a737}',
+    '\u{a739}'..='\u{a739}', '\u{a73b}'..='\u{a73b}', '\u{a73d}'..='\u{a73d}',
+    '\u{a73f}'..='\u{a73f}', '\u{a741}'..='\u{a741}', '\u{a743}'..='\u{a743}',
+    '\u{a745}'..='\u{a745}', '\u{a747}'..='\u{a747}', '\u{a749}'..='\u{a749}',
+    '\u{a74b}'..='\u{a74b}', '\u{a74d}'..='\u{a74d}', '\u{a74f}'..='\u{a74f}',
+    '\u{a751}'..='\u{a751}', '\u{a753}'..='\u{a753}', '\u{a755}'..='\u{a755}',
+    '\u{a757}'..='\u{a757}', '\u{a759}'..='\u{a759}', '\u{a75b}'..='\u{a75b}',
+    '\u{a75d}'..='\u{a75d}', '\u{a75f}'..='\u{a75f}', '\u{a761}'..='\u{a761}',
+    '\u{a763}'..='\u{a763}', '\u{a765}'..='\u{a765}', '\u{a767}'..='\u{a767}',
+    '\u{a769}'..='\u{a769}', '\u{a76b}'..='\u{a76b}', '\u{a76d}'..='\u{a76d}',
+    '\u{a76f}'..='\u{a778}', '\u{a77a}'..='\u{a77a}', '\u{a77c}'..='\u{a77c}',
+    '\u{a77f}'..='\u{a77f}', '\u{a781}'..='\u{a781}', '\u{a783}'..='\u{a783}',
+    '\u{a785}'..='\u{a785}', '\u{a787}'..='\u{a787}', '\u{a78c}'..='\u{a78c}',
+    '\u{a78e}'..='\u{a78e}', '\u{a791}'..='\u{a791}', '\u{a793}'..='\u{a795}',
+    '\u{a797}'..='\u{a797}', '\u{a799}'..='\u{a799}', '\u{a79b}'..='\u{a79b}',
+    '\u{a79d}'..='\u{a79d}', '\u{a79f}'..='\u{a79f}', '\u{a7a1}'..='\u{a7a1}',
+    '\u{a7a3}'..='\u{a7a3}', '\u{a7a5}'..='\u{a7a5}', '\u{a7a7}'..='\u{a7a7}',
+    '\u{a7a9}'..='\u{a7a9}', '\u{a7af}'..='\u{a7af}', '\u{a7b5}'..='\u{a7b5}',
+    '\u{a7b7}'..='\u{a7b7}', '\u{a7b9}'..='\u{a7b9}', '\u{a7bb}'..='\u{a7bb}',
+    '\u{a7bd}'..='\u{a7bd}', '\u{a7bf}'..='\u{a7bf}', '\u{a7c1}'..='\u{a7c1}',
+    '\u{a7c3}'..='\u{a7c3}', '\u{a7c8}'..='\u{a7c8}', '\u{a7ca}'..='\u{a7ca}',
+    '\u{a7cd}'..='\u{a7cd}', '\u{a7cf}'..='\u{a7cf}', '\u{a7d1}'..='\u{a7d1}',
+    '\u{a7d3}'..='\u{a7d3}', '\u{a7d5}'..='\u{a7d5}', '\u{a7d7}'..='\u{a7d7}',
+    '\u{a7d9}'..='\u{a7d9}', '\u{a7db}'..='\u{a7db}', '\u{a7f1}'..='\u{a7f4}',
+    '\u{a7f6}'..='\u{a7f6}', '\u{a7f8}'..='\u{a7fa}', '\u{ab30}'..='\u{ab5a}',
+    '\u{ab5c}'..='\u{ab69}', '\u{ab70}'..='\u{abbf}', '\u{fb00}'..='\u{fb06}',
+    '\u{fb13}'..='\u{fb17}', '\u{ff41}'..='\u{ff5a}', '\u{10428}'..='\u{1044f}',
+    '\u{104d8}'..='\u{104fb}', '\u{10597}'..='\u{105a1}', '\u{105a3}'..='\u{105b1}',
+    '\u{105b3}'..='\u{105b9}', '\u{105bb}'..='\u{105bc}', '\u{10780}'..='\u{10780}',
+    '\u{10783}'..='\u{10785}', '\u{10787}'..='\u{107b0}', '\u{107b2}'..='\u{107ba}',
+    '\u{10cc0}'..='\u{10cf2}', '\u{10d70}'..='\u{10d85}', '\u{118c0}'..='\u{118df}',
+    '\u{16e60}'..='\u{16e7f}', '\u{16ebb}'..='\u{16ed3}', '\u{1d41a}'..='\u{1d433}',
+    '\u{1d44e}'..='\u{1d454}', '\u{1d456}'..='\u{1d467}', '\u{1d482}'..='\u{1d49b}',
+    '\u{1d4b6}'..='\u{1d4b9}', '\u{1d4bb}'..='\u{1d4bb}', '\u{1d4bd}'..='\u{1d4c3}',
+    '\u{1d4c5}'..='\u{1d4cf}', '\u{1d4ea}'..='\u{1d503}', '\u{1d51e}'..='\u{1d537}',
+    '\u{1d552}'..='\u{1d56b}', '\u{1d586}'..='\u{1d59f}', '\u{1d5ba}'..='\u{1d5d3}',
+    '\u{1d5ee}'..='\u{1d607}', '\u{1d622}'..='\u{1d63b}', '\u{1d656}'..='\u{1d66f}',
+    '\u{1d68a}'..='\u{1d6a5}', '\u{1d6c2}'..='\u{1d6da}', '\u{1d6dc}'..='\u{1d6e1}',
+    '\u{1d6fc}'..='\u{1d714}', '\u{1d716}'..='\u{1d71b}', '\u{1d736}'..='\u{1d74e}',
+    '\u{1d750}'..='\u{1d755}', '\u{1d770}'..='\u{1d788}', '\u{1d78a}'..='\u{1d78f}',
+    '\u{1d7aa}'..='\u{1d7c2}', '\u{1d7c4}'..='\u{1d7c9}', '\u{1d7cb}'..='\u{1d7cb}',
+    '\u{1df00}'..='\u{1df09}', '\u{1df0b}'..='\u{1df1e}', '\u{1df25}'..='\u{1df2a}',
+    '\u{1e030}'..='\u{1e06d}', '\u{1e922}'..='\u{1e943}',
+];
+
+#[rustfmt::skip]
+pub(super) static N: &[RangeInclusive<char>; 145] = &[
+    '\u{b2}'..='\u{b3}', '\u{b9}'..='\u{b9}', '\u{bc}'..='\u{be}', '\u{660}'..='\u{669}',
+    '\u{6f0}'..='\u{6f9}', '\u{7c0}'..='\u{7c9}', '\u{966}'..='\u{96f}', '\u{9e6}'..='\u{9ef}',
+    '\u{9f4}'..='\u{9f9}', '\u{a66}'..='\u{a6f}', '\u{ae6}'..='\u{aef}', '\u{b66}'..='\u{b6f}',
+    '\u{b72}'..='\u{b77}', '\u{be6}'..='\u{bf2}', '\u{c66}'..='\u{c6f}', '\u{c78}'..='\u{c7e}',
+    '\u{ce6}'..='\u{cef}', '\u{d58}'..='\u{d5e}', '\u{d66}'..='\u{d78}', '\u{de6}'..='\u{def}',
+    '\u{e50}'..='\u{e59}', '\u{ed0}'..='\u{ed9}', '\u{f20}'..='\u{f33}',
+    '\u{1040}'..='\u{1049}', '\u{1090}'..='\u{1099}', '\u{1369}'..='\u{137c}',
+    '\u{16ee}'..='\u{16f0}', '\u{17e0}'..='\u{17e9}', '\u{17f0}'..='\u{17f9}',
+    '\u{1810}'..='\u{1819}', '\u{1946}'..='\u{194f}', '\u{19d0}'..='\u{19da}',
+    '\u{1a80}'..='\u{1a89}', '\u{1a90}'..='\u{1a99}', '\u{1b50}'..='\u{1b59}',
+    '\u{1bb0}'..='\u{1bb9}', '\u{1c40}'..='\u{1c49}', '\u{1c50}'..='\u{1c59}',
+    '\u{2070}'..='\u{2070}', '\u{2074}'..='\u{2079}', '\u{2080}'..='\u{2089}',
+    '\u{2150}'..='\u{2182}', '\u{2185}'..='\u{2189}', '\u{2460}'..='\u{249b}',
+    '\u{24ea}'..='\u{24ff}', '\u{2776}'..='\u{2793}', '\u{2cfd}'..='\u{2cfd}',
+    '\u{3007}'..='\u{3007}', '\u{3021}'..='\u{3029}', '\u{3038}'..='\u{303a}',
+    '\u{3192}'..='\u{3195}', '\u{3220}'..='\u{3229}', '\u{3248}'..='\u{324f}',
+    '\u{3251}'..='\u{325f}', '\u{3280}'..='\u{3289}', '\u{32b1}'..='\u{32bf}',
+    '\u{a620}'..='\u{a629}', '\u{a6e6}'..='\u{a6ef}', '\u{a830}'..='\u{a835}',
+    '\u{a8d0}'..='\u{a8d9}', '\u{a900}'..='\u{a909}', '\u{a9d0}'..='\u{a9d9}',
+    '\u{a9f0}'..='\u{a9f9}', '\u{aa50}'..='\u{aa59}', '\u{abf0}'..='\u{abf9}',
+    '\u{ff10}'..='\u{ff19}', '\u{10107}'..='\u{10133}', '\u{10140}'..='\u{10178}',
+    '\u{1018a}'..='\u{1018b}', '\u{102e1}'..='\u{102fb}', '\u{10320}'..='\u{10323}',
+    '\u{10341}'..='\u{10341}', '\u{1034a}'..='\u{1034a}', '\u{103d1}'..='\u{103d5}',
+    '\u{104a0}'..='\u{104a9}', '\u{10858}'..='\u{1085f}', '\u{10879}'..='\u{1087f}',
+    '\u{108a7}'..='\u{108af}', '\u{108fb}'..='\u{108ff}', '\u{10916}'..='\u{1091b}',
+    '\u{109bc}'..='\u{109bd}', '\u{109c0}'..='\u{109cf}', '\u{109d2}'..='\u{109ff}',
+    '\u{10a40}'..='\u{10a48}', '\u{10a7d}'..='\u{10a7e}', '\u{10a9d}'..='\u{10a9f}',
+    '\u{10aeb}'..='\u{10aef}', '\u{10b58}'..='\u{10b5f}', '\u{10b78}'..='\u{10b7f}',
+    '\u{10ba9}'..='\u{10baf}', '\u{10cfa}'..='\u{10cff}', '\u{10d30}'..='\u{10d39}',
+    '\u{10d40}'..='\u{10d49}', '\u{10e60}'..='\u{10e7e}', '\u{10f1d}'..='\u{10f26}',
+    '\u{10f51}'..='\u{10f54}', '\u{10fc5}'..='\u{10fcb}', '\u{11052}'..='\u{1106f}',
+    '\u{110f0}'..='\u{110f9}', '\u{11136}'..='\u{1113f}', '\u{111d0}'..='\u{111d9}',
+    '\u{111e1}'..='\u{111f4}', '\u{112f0}'..='\u{112f9}', '\u{11450}'..='\u{11459}',
+    '\u{114d0}'..='\u{114d9}', '\u{11650}'..='\u{11659}', '\u{116c0}'..='\u{116c9}',
+    '\u{116d0}'..='\u{116e3}', '\u{11730}'..='\u{1173b}', '\u{118e0}'..='\u{118f2}',
+    '\u{11950}'..='\u{11959}', '\u{11bf0}'..='\u{11bf9}', '\u{11c50}'..='\u{11c6c}',
+    '\u{11d50}'..='\u{11d59}', '\u{11da0}'..='\u{11da9}', '\u{11de0}'..='\u{11de9}',
+    '\u{11f50}'..='\u{11f59}', '\u{11fc0}'..='\u{11fd4}', '\u{12400}'..='\u{1246e}',
+    '\u{16130}'..='\u{16139}', '\u{16a60}'..='\u{16a69}', '\u{16ac0}'..='\u{16ac9}',
+    '\u{16b50}'..='\u{16b59}', '\u{16b5b}'..='\u{16b61}', '\u{16d70}'..='\u{16d79}',
+    '\u{16e80}'..='\u{16e96}', '\u{16ff4}'..='\u{16ff6}', '\u{1ccf0}'..='\u{1ccf9}',
+    '\u{1d2c0}'..='\u{1d2d3}', '\u{1d2e0}'..='\u{1d2f3}', '\u{1d360}'..='\u{1d378}',
+    '\u{1d7ce}'..='\u{1d7ff}', '\u{1e140}'..='\u{1e149}', '\u{1e2f0}'..='\u{1e2f9}',
+    '\u{1e4f0}'..='\u{1e4f9}', '\u{1e5f1}'..='\u{1e5fa}', '\u{1e8c7}'..='\u{1e8cf}',
+    '\u{1e950}'..='\u{1e959}', '\u{1ec71}'..='\u{1ecab}', '\u{1ecad}'..='\u{1ecaf}',
+    '\u{1ecb1}'..='\u{1ecb4}', '\u{1ed01}'..='\u{1ed2d}', '\u{1ed2f}'..='\u{1ed3d}',
+    '\u{1f100}'..='\u{1f10c}', '\u{1fbf0}'..='\u{1fbf9}',
+];
+
+#[rustfmt::skip]
+pub(super) static UPPERCASE: &[RangeInclusive<char>; 659] = &[
+    '\u{c0}'..='\u{d6}', '\u{d8}'..='\u{de}', '\u{100}'..='\u{100}', '\u{102}'..='\u{102}',
+    '\u{104}'..='\u{104}', '\u{106}'..='\u{106}', '\u{108}'..='\u{108}', '\u{10a}'..='\u{10a}',
+    '\u{10c}'..='\u{10c}', '\u{10e}'..='\u{10e}', '\u{110}'..='\u{110}', '\u{112}'..='\u{112}',
+    '\u{114}'..='\u{114}', '\u{116}'..='\u{116}', '\u{118}'..='\u{118}', '\u{11a}'..='\u{11a}',
+    '\u{11c}'..='\u{11c}', '\u{11e}'..='\u{11e}', '\u{120}'..='\u{120}', '\u{122}'..='\u{122}',
+    '\u{124}'..='\u{124}', '\u{126}'..='\u{126}', '\u{128}'..='\u{128}', '\u{12a}'..='\u{12a}',
+    '\u{12c}'..='\u{12c}', '\u{12e}'..='\u{12e}', '\u{130}'..='\u{130}', '\u{132}'..='\u{132}',
+    '\u{134}'..='\u{134}', '\u{136}'..='\u{136}', '\u{139}'..='\u{139}', '\u{13b}'..='\u{13b}',
+    '\u{13d}'..='\u{13d}', '\u{13f}'..='\u{13f}', '\u{141}'..='\u{141}', '\u{143}'..='\u{143}',
+    '\u{145}'..='\u{145}', '\u{147}'..='\u{147}', '\u{14a}'..='\u{14a}', '\u{14c}'..='\u{14c}',
+    '\u{14e}'..='\u{14e}', '\u{150}'..='\u{150}', '\u{152}'..='\u{152}', '\u{154}'..='\u{154}',
+    '\u{156}'..='\u{156}', '\u{158}'..='\u{158}', '\u{15a}'..='\u{15a}', '\u{15c}'..='\u{15c}',
+    '\u{15e}'..='\u{15e}', '\u{160}'..='\u{160}', '\u{162}'..='\u{162}', '\u{164}'..='\u{164}',
+    '\u{166}'..='\u{166}', '\u{168}'..='\u{168}', '\u{16a}'..='\u{16a}', '\u{16c}'..='\u{16c}',
+    '\u{16e}'..='\u{16e}', '\u{170}'..='\u{170}', '\u{172}'..='\u{172}', '\u{174}'..='\u{174}',
+    '\u{176}'..='\u{176}', '\u{178}'..='\u{179}', '\u{17b}'..='\u{17b}', '\u{17d}'..='\u{17d}',
+    '\u{181}'..='\u{182}', '\u{184}'..='\u{184}', '\u{186}'..='\u{187}', '\u{189}'..='\u{18b}',
+    '\u{18e}'..='\u{191}', '\u{193}'..='\u{194}', '\u{196}'..='\u{198}', '\u{19c}'..='\u{19d}',
+    '\u{19f}'..='\u{1a0}', '\u{1a2}'..='\u{1a2}', '\u{1a4}'..='\u{1a4}', '\u{1a6}'..='\u{1a7}',
+    '\u{1a9}'..='\u{1a9}', '\u{1ac}'..='\u{1ac}', '\u{1ae}'..='\u{1af}', '\u{1b1}'..='\u{1b3}',
+    '\u{1b5}'..='\u{1b5}', '\u{1b7}'..='\u{1b8}', '\u{1bc}'..='\u{1bc}', '\u{1c4}'..='\u{1c4}',
+    '\u{1c7}'..='\u{1c7}', '\u{1ca}'..='\u{1ca}', '\u{1cd}'..='\u{1cd}', '\u{1cf}'..='\u{1cf}',
+    '\u{1d1}'..='\u{1d1}', '\u{1d3}'..='\u{1d3}', '\u{1d5}'..='\u{1d5}', '\u{1d7}'..='\u{1d7}',
+    '\u{1d9}'..='\u{1d9}', '\u{1db}'..='\u{1db}', '\u{1de}'..='\u{1de}', '\u{1e0}'..='\u{1e0}',
+    '\u{1e2}'..='\u{1e2}', '\u{1e4}'..='\u{1e4}', '\u{1e6}'..='\u{1e6}', '\u{1e8}'..='\u{1e8}',
+    '\u{1ea}'..='\u{1ea}', '\u{1ec}'..='\u{1ec}', '\u{1ee}'..='\u{1ee}', '\u{1f1}'..='\u{1f1}',
+    '\u{1f4}'..='\u{1f4}', '\u{1f6}'..='\u{1f8}', '\u{1fa}'..='\u{1fa}', '\u{1fc}'..='\u{1fc}',
+    '\u{1fe}'..='\u{1fe}', '\u{200}'..='\u{200}', '\u{202}'..='\u{202}', '\u{204}'..='\u{204}',
+    '\u{206}'..='\u{206}', '\u{208}'..='\u{208}', '\u{20a}'..='\u{20a}', '\u{20c}'..='\u{20c}',
+    '\u{20e}'..='\u{20e}', '\u{210}'..='\u{210}', '\u{212}'..='\u{212}', '\u{214}'..='\u{214}',
+    '\u{216}'..='\u{216}', '\u{218}'..='\u{218}', '\u{21a}'..='\u{21a}', '\u{21c}'..='\u{21c}',
+    '\u{21e}'..='\u{21e}', '\u{220}'..='\u{220}', '\u{222}'..='\u{222}', '\u{224}'..='\u{224}',
+    '\u{226}'..='\u{226}', '\u{228}'..='\u{228}', '\u{22a}'..='\u{22a}', '\u{22c}'..='\u{22c}',
+    '\u{22e}'..='\u{22e}', '\u{230}'..='\u{230}', '\u{232}'..='\u{232}', '\u{23a}'..='\u{23b}',
+    '\u{23d}'..='\u{23e}', '\u{241}'..='\u{241}', '\u{243}'..='\u{246}', '\u{248}'..='\u{248}',
+    '\u{24a}'..='\u{24a}', '\u{24c}'..='\u{24c}', '\u{24e}'..='\u{24e}', '\u{370}'..='\u{370}',
+    '\u{372}'..='\u{372}', '\u{376}'..='\u{376}', '\u{37f}'..='\u{37f}', '\u{386}'..='\u{386}',
+    '\u{388}'..='\u{38a}', '\u{38c}'..='\u{38c}', '\u{38e}'..='\u{38f}', '\u{391}'..='\u{3a1}',
+    '\u{3a3}'..='\u{3ab}', '\u{3cf}'..='\u{3cf}', '\u{3d2}'..='\u{3d4}', '\u{3d8}'..='\u{3d8}',
+    '\u{3da}'..='\u{3da}', '\u{3dc}'..='\u{3dc}', '\u{3de}'..='\u{3de}', '\u{3e0}'..='\u{3e0}',
+    '\u{3e2}'..='\u{3e2}', '\u{3e4}'..='\u{3e4}', '\u{3e6}'..='\u{3e6}', '\u{3e8}'..='\u{3e8}',
+    '\u{3ea}'..='\u{3ea}', '\u{3ec}'..='\u{3ec}', '\u{3ee}'..='\u{3ee}', '\u{3f4}'..='\u{3f4}',
+    '\u{3f7}'..='\u{3f7}', '\u{3f9}'..='\u{3fa}', '\u{3fd}'..='\u{42f}', '\u{460}'..='\u{460}',
+    '\u{462}'..='\u{462}', '\u{464}'..='\u{464}', '\u{466}'..='\u{466}', '\u{468}'..='\u{468}',
+    '\u{46a}'..='\u{46a}', '\u{46c}'..='\u{46c}', '\u{46e}'..='\u{46e}', '\u{470}'..='\u{470}',
+    '\u{472}'..='\u{472}', '\u{474}'..='\u{474}', '\u{476}'..='\u{476}', '\u{478}'..='\u{478}',
+    '\u{47a}'..='\u{47a}', '\u{47c}'..='\u{47c}', '\u{47e}'..='\u{47e}', '\u{480}'..='\u{480}',
+    '\u{48a}'..='\u{48a}', '\u{48c}'..='\u{48c}', '\u{48e}'..='\u{48e}', '\u{490}'..='\u{490}',
+    '\u{492}'..='\u{492}', '\u{494}'..='\u{494}', '\u{496}'..='\u{496}', '\u{498}'..='\u{498}',
+    '\u{49a}'..='\u{49a}', '\u{49c}'..='\u{49c}', '\u{49e}'..='\u{49e}', '\u{4a0}'..='\u{4a0}',
+    '\u{4a2}'..='\u{4a2}', '\u{4a4}'..='\u{4a4}', '\u{4a6}'..='\u{4a6}', '\u{4a8}'..='\u{4a8}',
+    '\u{4aa}'..='\u{4aa}', '\u{4ac}'..='\u{4ac}', '\u{4ae}'..='\u{4ae}', '\u{4b0}'..='\u{4b0}',
+    '\u{4b2}'..='\u{4b2}', '\u{4b4}'..='\u{4b4}', '\u{4b6}'..='\u{4b6}', '\u{4b8}'..='\u{4b8}',
+    '\u{4ba}'..='\u{4ba}', '\u{4bc}'..='\u{4bc}', '\u{4be}'..='\u{4be}', '\u{4c0}'..='\u{4c1}',
+    '\u{4c3}'..='\u{4c3}', '\u{4c5}'..='\u{4c5}', '\u{4c7}'..='\u{4c7}', '\u{4c9}'..='\u{4c9}',
+    '\u{4cb}'..='\u{4cb}', '\u{4cd}'..='\u{4cd}', '\u{4d0}'..='\u{4d0}', '\u{4d2}'..='\u{4d2}',
+    '\u{4d4}'..='\u{4d4}', '\u{4d6}'..='\u{4d6}', '\u{4d8}'..='\u{4d8}', '\u{4da}'..='\u{4da}',
+    '\u{4dc}'..='\u{4dc}', '\u{4de}'..='\u{4de}', '\u{4e0}'..='\u{4e0}', '\u{4e2}'..='\u{4e2}',
+    '\u{4e4}'..='\u{4e4}', '\u{4e6}'..='\u{4e6}', '\u{4e8}'..='\u{4e8}', '\u{4ea}'..='\u{4ea}',
+    '\u{4ec}'..='\u{4ec}', '\u{4ee}'..='\u{4ee}', '\u{4f0}'..='\u{4f0}', '\u{4f2}'..='\u{4f2}',
+    '\u{4f4}'..='\u{4f4}', '\u{4f6}'..='\u{4f6}', '\u{4f8}'..='\u{4f8}', '\u{4fa}'..='\u{4fa}',
+    '\u{4fc}'..='\u{4fc}', '\u{4fe}'..='\u{4fe}', '\u{500}'..='\u{500}', '\u{502}'..='\u{502}',
+    '\u{504}'..='\u{504}', '\u{506}'..='\u{506}', '\u{508}'..='\u{508}', '\u{50a}'..='\u{50a}',
+    '\u{50c}'..='\u{50c}', '\u{50e}'..='\u{50e}', '\u{510}'..='\u{510}', '\u{512}'..='\u{512}',
+    '\u{514}'..='\u{514}', '\u{516}'..='\u{516}', '\u{518}'..='\u{518}', '\u{51a}'..='\u{51a}',
+    '\u{51c}'..='\u{51c}', '\u{51e}'..='\u{51e}', '\u{520}'..='\u{520}', '\u{522}'..='\u{522}',
+    '\u{524}'..='\u{524}', '\u{526}'..='\u{526}', '\u{528}'..='\u{528}', '\u{52a}'..='\u{52a}',
+    '\u{52c}'..='\u{52c}', '\u{52e}'..='\u{52e}', '\u{531}'..='\u{556}',
+    '\u{10a0}'..='\u{10c5}', '\u{10c7}'..='\u{10c7}', '\u{10cd}'..='\u{10cd}',
+    '\u{13a0}'..='\u{13f5}', '\u{1c89}'..='\u{1c89}', '\u{1c90}'..='\u{1cba}',
+    '\u{1cbd}'..='\u{1cbf}', '\u{1e00}'..='\u{1e00}', '\u{1e02}'..='\u{1e02}',
+    '\u{1e04}'..='\u{1e04}', '\u{1e06}'..='\u{1e06}', '\u{1e08}'..='\u{1e08}',
+    '\u{1e0a}'..='\u{1e0a}', '\u{1e0c}'..='\u{1e0c}', '\u{1e0e}'..='\u{1e0e}',
+    '\u{1e10}'..='\u{1e10}', '\u{1e12}'..='\u{1e12}', '\u{1e14}'..='\u{1e14}',
+    '\u{1e16}'..='\u{1e16}', '\u{1e18}'..='\u{1e18}', '\u{1e1a}'..='\u{1e1a}',
+    '\u{1e1c}'..='\u{1e1c}', '\u{1e1e}'..='\u{1e1e}', '\u{1e20}'..='\u{1e20}',
+    '\u{1e22}'..='\u{1e22}', '\u{1e24}'..='\u{1e24}', '\u{1e26}'..='\u{1e26}',
+    '\u{1e28}'..='\u{1e28}', '\u{1e2a}'..='\u{1e2a}', '\u{1e2c}'..='\u{1e2c}',
+    '\u{1e2e}'..='\u{1e2e}', '\u{1e30}'..='\u{1e30}', '\u{1e32}'..='\u{1e32}',
+    '\u{1e34}'..='\u{1e34}', '\u{1e36}'..='\u{1e36}', '\u{1e38}'..='\u{1e38}',
+    '\u{1e3a}'..='\u{1e3a}', '\u{1e3c}'..='\u{1e3c}', '\u{1e3e}'..='\u{1e3e}',
+    '\u{1e40}'..='\u{1e40}', '\u{1e42}'..='\u{1e42}', '\u{1e44}'..='\u{1e44}',
+    '\u{1e46}'..='\u{1e46}', '\u{1e48}'..='\u{1e48}', '\u{1e4a}'..='\u{1e4a}',
+    '\u{1e4c}'..='\u{1e4c}', '\u{1e4e}'..='\u{1e4e}', '\u{1e50}'..='\u{1e50}',
+    '\u{1e52}'..='\u{1e52}', '\u{1e54}'..='\u{1e54}', '\u{1e56}'..='\u{1e56}',
+    '\u{1e58}'..='\u{1e58}', '\u{1e5a}'..='\u{1e5a}', '\u{1e5c}'..='\u{1e5c}',
+    '\u{1e5e}'..='\u{1e5e}', '\u{1e60}'..='\u{1e60}', '\u{1e62}'..='\u{1e62}',
+    '\u{1e64}'..='\u{1e64}', '\u{1e66}'..='\u{1e66}', '\u{1e68}'..='\u{1e68}',
+    '\u{1e6a}'..='\u{1e6a}', '\u{1e6c}'..='\u{1e6c}', '\u{1e6e}'..='\u{1e6e}',
+    '\u{1e70}'..='\u{1e70}', '\u{1e72}'..='\u{1e72}', '\u{1e74}'..='\u{1e74}',
+    '\u{1e76}'..='\u{1e76}', '\u{1e78}'..='\u{1e78}', '\u{1e7a}'..='\u{1e7a}',
+    '\u{1e7c}'..='\u{1e7c}', '\u{1e7e}'..='\u{1e7e}', '\u{1e80}'..='\u{1e80}',
+    '\u{1e82}'..='\u{1e82}', '\u{1e84}'..='\u{1e84}', '\u{1e86}'..='\u{1e86}',
+    '\u{1e88}'..='\u{1e88}', '\u{1e8a}'..='\u{1e8a}', '\u{1e8c}'..='\u{1e8c}',
+    '\u{1e8e}'..='\u{1e8e}', '\u{1e90}'..='\u{1e90}', '\u{1e92}'..='\u{1e92}',
+    '\u{1e94}'..='\u{1e94}', '\u{1e9e}'..='\u{1e9e}', '\u{1ea0}'..='\u{1ea0}',
+    '\u{1ea2}'..='\u{1ea2}', '\u{1ea4}'..='\u{1ea4}', '\u{1ea6}'..='\u{1ea6}',
+    '\u{1ea8}'..='\u{1ea8}', '\u{1eaa}'..='\u{1eaa}', '\u{1eac}'..='\u{1eac}',
+    '\u{1eae}'..='\u{1eae}', '\u{1eb0}'..='\u{1eb0}', '\u{1eb2}'..='\u{1eb2}',
+    '\u{1eb4}'..='\u{1eb4}', '\u{1eb6}'..='\u{1eb6}', '\u{1eb8}'..='\u{1eb8}',
+    '\u{1eba}'..='\u{1eba}', '\u{1ebc}'..='\u{1ebc}', '\u{1ebe}'..='\u{1ebe}',
+    '\u{1ec0}'..='\u{1ec0}', '\u{1ec2}'..='\u{1ec2}', '\u{1ec4}'..='\u{1ec4}',
+    '\u{1ec6}'..='\u{1ec6}', '\u{1ec8}'..='\u{1ec8}', '\u{1eca}'..='\u{1eca}',
+    '\u{1ecc}'..='\u{1ecc}', '\u{1ece}'..='\u{1ece}', '\u{1ed0}'..='\u{1ed0}',
+    '\u{1ed2}'..='\u{1ed2}', '\u{1ed4}'..='\u{1ed4}', '\u{1ed6}'..='\u{1ed6}',
+    '\u{1ed8}'..='\u{1ed8}', '\u{1eda}'..='\u{1eda}', '\u{1edc}'..='\u{1edc}',
+    '\u{1ede}'..='\u{1ede}', '\u{1ee0}'..='\u{1ee0}', '\u{1ee2}'..='\u{1ee2}',
+    '\u{1ee4}'..='\u{1ee4}', '\u{1ee6}'..='\u{1ee6}', '\u{1ee8}'..='\u{1ee8}',
+    '\u{1eea}'..='\u{1eea}', '\u{1eec}'..='\u{1eec}', '\u{1eee}'..='\u{1eee}',
+    '\u{1ef0}'..='\u{1ef0}', '\u{1ef2}'..='\u{1ef2}', '\u{1ef4}'..='\u{1ef4}',
+    '\u{1ef6}'..='\u{1ef6}', '\u{1ef8}'..='\u{1ef8}', '\u{1efa}'..='\u{1efa}',
+    '\u{1efc}'..='\u{1efc}', '\u{1efe}'..='\u{1efe}', '\u{1f08}'..='\u{1f0f}',
+    '\u{1f18}'..='\u{1f1d}', '\u{1f28}'..='\u{1f2f}', '\u{1f38}'..='\u{1f3f}',
+    '\u{1f48}'..='\u{1f4d}', '\u{1f59}'..='\u{1f59}', '\u{1f5b}'..='\u{1f5b}',
+    '\u{1f5d}'..='\u{1f5d}', '\u{1f5f}'..='\u{1f5f}', '\u{1f68}'..='\u{1f6f}',
+    '\u{1fb8}'..='\u{1fbb}', '\u{1fc8}'..='\u{1fcb}', '\u{1fd8}'..='\u{1fdb}',
+    '\u{1fe8}'..='\u{1fec}', '\u{1ff8}'..='\u{1ffb}', '\u{2102}'..='\u{2102}',
+    '\u{2107}'..='\u{2107}', '\u{210b}'..='\u{210d}', '\u{2110}'..='\u{2112}',
+    '\u{2115}'..='\u{2115}', '\u{2119}'..='\u{211d}', '\u{2124}'..='\u{2124}',
+    '\u{2126}'..='\u{2126}', '\u{2128}'..='\u{2128}', '\u{212a}'..='\u{212d}',
+    '\u{2130}'..='\u{2133}', '\u{213e}'..='\u{213f}', '\u{2145}'..='\u{2145}',
+    '\u{2160}'..='\u{216f}', '\u{2183}'..='\u{2183}', '\u{24b6}'..='\u{24cf}',
+    '\u{2c00}'..='\u{2c2f}', '\u{2c60}'..='\u{2c60}', '\u{2c62}'..='\u{2c64}',
+    '\u{2c67}'..='\u{2c67}', '\u{2c69}'..='\u{2c69}', '\u{2c6b}'..='\u{2c6b}',
+    '\u{2c6d}'..='\u{2c70}', '\u{2c72}'..='\u{2c72}', '\u{2c75}'..='\u{2c75}',
+    '\u{2c7e}'..='\u{2c80}', '\u{2c82}'..='\u{2c82}', '\u{2c84}'..='\u{2c84}',
+    '\u{2c86}'..='\u{2c86}', '\u{2c88}'..='\u{2c88}', '\u{2c8a}'..='\u{2c8a}',
+    '\u{2c8c}'..='\u{2c8c}', '\u{2c8e}'..='\u{2c8e}', '\u{2c90}'..='\u{2c90}',
+    '\u{2c92}'..='\u{2c92}', '\u{2c94}'..='\u{2c94}', '\u{2c96}'..='\u{2c96}',
+    '\u{2c98}'..='\u{2c98}', '\u{2c9a}'..='\u{2c9a}', '\u{2c9c}'..='\u{2c9c}',
+    '\u{2c9e}'..='\u{2c9e}', '\u{2ca0}'..='\u{2ca0}', '\u{2ca2}'..='\u{2ca2}',
+    '\u{2ca4}'..='\u{2ca4}', '\u{2ca6}'..='\u{2ca6}', '\u{2ca8}'..='\u{2ca8}',
+    '\u{2caa}'..='\u{2caa}', '\u{2cac}'..='\u{2cac}', '\u{2cae}'..='\u{2cae}',
+    '\u{2cb0}'..='\u{2cb0}', '\u{2cb2}'..='\u{2cb2}', '\u{2cb4}'..='\u{2cb4}',
+    '\u{2cb6}'..='\u{2cb6}', '\u{2cb8}'..='\u{2cb8}', '\u{2cba}'..='\u{2cba}',
+    '\u{2cbc}'..='\u{2cbc}', '\u{2cbe}'..='\u{2cbe}', '\u{2cc0}'..='\u{2cc0}',
+    '\u{2cc2}'..='\u{2cc2}', '\u{2cc4}'..='\u{2cc4}', '\u{2cc6}'..='\u{2cc6}',
+    '\u{2cc8}'..='\u{2cc8}', '\u{2cca}'..='\u{2cca}', '\u{2ccc}'..='\u{2ccc}',
+    '\u{2cce}'..='\u{2cce}', '\u{2cd0}'..='\u{2cd0}', '\u{2cd2}'..='\u{2cd2}',
+    '\u{2cd4}'..='\u{2cd4}', '\u{2cd6}'..='\u{2cd6}', '\u{2cd8}'..='\u{2cd8}',
+    '\u{2cda}'..='\u{2cda}', '\u{2cdc}'..='\u{2cdc}', '\u{2cde}'..='\u{2cde}',
+    '\u{2ce0}'..='\u{2ce0}', '\u{2ce2}'..='\u{2ce2}', '\u{2ceb}'..='\u{2ceb}',
+    '\u{2ced}'..='\u{2ced}', '\u{2cf2}'..='\u{2cf2}', '\u{a640}'..='\u{a640}',
+    '\u{a642}'..='\u{a642}', '\u{a644}'..='\u{a644}', '\u{a646}'..='\u{a646}',
+    '\u{a648}'..='\u{a648}', '\u{a64a}'..='\u{a64a}', '\u{a64c}'..='\u{a64c}',
+    '\u{a64e}'..='\u{a64e}', '\u{a650}'..='\u{a650}', '\u{a652}'..='\u{a652}',
+    '\u{a654}'..='\u{a654}', '\u{a656}'..='\u{a656}', '\u{a658}'..='\u{a658}',
+    '\u{a65a}'..='\u{a65a}', '\u{a65c}'..='\u{a65c}', '\u{a65e}'..='\u{a65e}',
+    '\u{a660}'..='\u{a660}', '\u{a662}'..='\u{a662}', '\u{a664}'..='\u{a664}',
+    '\u{a666}'..='\u{a666}', '\u{a668}'..='\u{a668}', '\u{a66a}'..='\u{a66a}',
+    '\u{a66c}'..='\u{a66c}', '\u{a680}'..='\u{a680}', '\u{a682}'..='\u{a682}',
+    '\u{a684}'..='\u{a684}', '\u{a686}'..='\u{a686}', '\u{a688}'..='\u{a688}',
+    '\u{a68a}'..='\u{a68a}', '\u{a68c}'..='\u{a68c}', '\u{a68e}'..='\u{a68e}',
+    '\u{a690}'..='\u{a690}', '\u{a692}'..='\u{a692}', '\u{a694}'..='\u{a694}',
+    '\u{a696}'..='\u{a696}', '\u{a698}'..='\u{a698}', '\u{a69a}'..='\u{a69a}',
+    '\u{a722}'..='\u{a722}', '\u{a724}'..='\u{a724}', '\u{a726}'..='\u{a726}',
+    '\u{a728}'..='\u{a728}', '\u{a72a}'..='\u{a72a}', '\u{a72c}'..='\u{a72c}',
+    '\u{a72e}'..='\u{a72e}', '\u{a732}'..='\u{a732}', '\u{a734}'..='\u{a734}',
+    '\u{a736}'..='\u{a736}', '\u{a738}'..='\u{a738}', '\u{a73a}'..='\u{a73a}',
+    '\u{a73c}'..='\u{a73c}', '\u{a73e}'..='\u{a73e}', '\u{a740}'..='\u{a740}',
+    '\u{a742}'..='\u{a742}', '\u{a744}'..='\u{a744}', '\u{a746}'..='\u{a746}',
+    '\u{a748}'..='\u{a748}', '\u{a74a}'..='\u{a74a}', '\u{a74c}'..='\u{a74c}',
+    '\u{a74e}'..='\u{a74e}', '\u{a750}'..='\u{a750}', '\u{a752}'..='\u{a752}',
+    '\u{a754}'..='\u{a754}', '\u{a756}'..='\u{a756}', '\u{a758}'..='\u{a758}',
+    '\u{a75a}'..='\u{a75a}', '\u{a75c}'..='\u{a75c}', '\u{a75e}'..='\u{a75e}',
+    '\u{a760}'..='\u{a760}', '\u{a762}'..='\u{a762}', '\u{a764}'..='\u{a764}',
+    '\u{a766}'..='\u{a766}', '\u{a768}'..='\u{a768}', '\u{a76a}'..='\u{a76a}',
+    '\u{a76c}'..='\u{a76c}', '\u{a76e}'..='\u{a76e}', '\u{a779}'..='\u{a779}',
+    '\u{a77b}'..='\u{a77b}', '\u{a77d}'..='\u{a77e}', '\u{a780}'..='\u{a780}',
+    '\u{a782}'..='\u{a782}', '\u{a784}'..='\u{a784}', '\u{a786}'..='\u{a786}',
+    '\u{a78b}'..='\u{a78b}', '\u{a78d}'..='\u{a78d}', '\u{a790}'..='\u{a790}',
+    '\u{a792}'..='\u{a792}', '\u{a796}'..='\u{a796}', '\u{a798}'..='\u{a798}',
+    '\u{a79a}'..='\u{a79a}', '\u{a79c}'..='\u{a79c}', '\u{a79e}'..='\u{a79e}',
+    '\u{a7a0}'..='\u{a7a0}', '\u{a7a2}'..='\u{a7a2}', '\u{a7a4}'..='\u{a7a4}',
+    '\u{a7a6}'..='\u{a7a6}', '\u{a7a8}'..='\u{a7a8}', '\u{a7aa}'..='\u{a7ae}',
+    '\u{a7b0}'..='\u{a7b4}', '\u{a7b6}'..='\u{a7b6}', '\u{a7b8}'..='\u{a7b8}',
+    '\u{a7ba}'..='\u{a7ba}', '\u{a7bc}'..='\u{a7bc}', '\u{a7be}'..='\u{a7be}',
+    '\u{a7c0}'..='\u{a7c0}', '\u{a7c2}'..='\u{a7c2}', '\u{a7c4}'..='\u{a7c7}',
+    '\u{a7c9}'..='\u{a7c9}', '\u{a7cb}'..='\u{a7cc}', '\u{a7ce}'..='\u{a7ce}',
+    '\u{a7d0}'..='\u{a7d0}', '\u{a7d2}'..='\u{a7d2}', '\u{a7d4}'..='\u{a7d4}',
+    '\u{a7d6}'..='\u{a7d6}', '\u{a7d8}'..='\u{a7d8}', '\u{a7da}'..='\u{a7da}',
+    '\u{a7dc}'..='\u{a7dc}', '\u{a7f5}'..='\u{a7f5}', '\u{ff21}'..='\u{ff3a}',
+    '\u{10400}'..='\u{10427}', '\u{104b0}'..='\u{104d3}', '\u{10570}'..='\u{1057a}',
+    '\u{1057c}'..='\u{1058a}', '\u{1058c}'..='\u{10592}', '\u{10594}'..='\u{10595}',
+    '\u{10c80}'..='\u{10cb2}', '\u{10d50}'..='\u{10d65}', '\u{118a0}'..='\u{118bf}',
+    '\u{16e40}'..='\u{16e5f}', '\u{16ea0}'..='\u{16eb8}', '\u{1d400}'..='\u{1d419}',
+    '\u{1d434}'..='\u{1d44d}', '\u{1d468}'..='\u{1d481}', '\u{1d49c}'..='\u{1d49c}',
+    '\u{1d49e}'..='\u{1d49f}', '\u{1d4a2}'..='\u{1d4a2}', '\u{1d4a5}'..='\u{1d4a6}',
+    '\u{1d4a9}'..='\u{1d4ac}', '\u{1d4ae}'..='\u{1d4b5}', '\u{1d4d0}'..='\u{1d4e9}',
+    '\u{1d504}'..='\u{1d505}', '\u{1d507}'..='\u{1d50a}', '\u{1d50d}'..='\u{1d514}',
+    '\u{1d516}'..='\u{1d51c}', '\u{1d538}'..='\u{1d539}', '\u{1d53b}'..='\u{1d53e}',
+    '\u{1d540}'..='\u{1d544}', '\u{1d546}'..='\u{1d546}', '\u{1d54a}'..='\u{1d550}',
+    '\u{1d56c}'..='\u{1d585}', '\u{1d5a0}'..='\u{1d5b9}', '\u{1d5d4}'..='\u{1d5ed}',
+    '\u{1d608}'..='\u{1d621}', '\u{1d63c}'..='\u{1d655}', '\u{1d670}'..='\u{1d689}',
+    '\u{1d6a8}'..='\u{1d6c0}', '\u{1d6e2}'..='\u{1d6fa}', '\u{1d71c}'..='\u{1d734}',
+    '\u{1d756}'..='\u{1d76e}', '\u{1d790}'..='\u{1d7a8}', '\u{1d7ca}'..='\u{1d7ca}',
+    '\u{1e900}'..='\u{1e921}', '\u{1f130}'..='\u{1f149}', '\u{1f150}'..='\u{1f169}',
+    '\u{1f170}'..='\u{1f189}',
+];
+
+#[rustfmt::skip]
+pub(super) static WHITE_SPACE: &[RangeInclusive<char>; 8] = &[
+    '\u{85}'..='\u{85}', '\u{a0}'..='\u{a0}', '\u{1680}'..='\u{1680}', '\u{2000}'..='\u{200a}',
+    '\u{2028}'..='\u{2029}', '\u{202f}'..='\u{202f}', '\u{205f}'..='\u{205f}',
+    '\u{3000}'..='\u{3000}',
+];
+
+#[rustfmt::skip]
+pub(super) static TO_LOWER: &[(char, [char; 3]); 1462] = &[
+    ('\u{c0}', ['\u{e0}', '\u{0}', '\u{0}']), ('\u{c1}', ['\u{e1}', '\u{0}', '\u{0}']),
+    ('\u{c2}', ['\u{e2}', '\u{0}', '\u{0}']), ('\u{c3}', ['\u{e3}', '\u{0}', '\u{0}']),
+    ('\u{c4}', ['\u{e4}', '\u{0}', '\u{0}']), ('\u{c5}', ['\u{e5}', '\u{0}', '\u{0}']),
+    ('\u{c6}', ['\u{e6}', '\u{0}', '\u{0}']), ('\u{c7}', ['\u{e7}', '\u{0}', '\u{0}']),
+    ('\u{c8}', ['\u{e8}', '\u{0}', '\u{0}']), ('\u{c9}', ['\u{e9}', '\u{0}', '\u{0}']),
+    ('\u{ca}', ['\u{ea}', '\u{0}', '\u{0}']), ('\u{cb}', ['\u{eb}', '\u{0}', '\u{0}']),
+    ('\u{cc}', ['\u{ec}', '\u{0}', '\u{0}']), ('\u{cd}', ['\u{ed}', '\u{0}', '\u{0}']),
+    ('\u{ce}', ['\u{ee}', '\u{0}', '\u{0}']), ('\u{cf}', ['\u{ef}', '\u{0}', '\u{0}']),
+    ('\u{d0}', ['\u{f0}', '\u{0}', '\u{0}']), ('\u{d1}', ['\u{f1}', '\u{0}', '\u{0}']),
+    ('\u{d2}', ['\u{f2}', '\u{0}', '\u{0}']), ('\u{d3}', ['\u{f3}', '\u{0}', '\u{0}']),
+    ('\u{d4}', ['\u{f4}', '\u{0}', '\u{0}']), ('\u{d5}', ['\u{f5}', '\u{0}', '\u{0}']),
+    ('\u{d6}', ['\u{f6}', '\u{0}', '\u{0}']), ('\u{d8}', ['\u{f8}', '\u{0}', '\u{0}']),
+    ('\u{d9}', ['\u{f9}', '\u{0}', '\u{0}']), ('\u{da}', ['\u{fa}', '\u{0}', '\u{0}']),
+    ('\u{db}', ['\u{fb}', '\u{0}', '\u{0}']), ('\u{dc}', ['\u{fc}', '\u{0}', '\u{0}']),
+    ('\u{dd}', ['\u{fd}', '\u{0}', '\u{0}']), ('\u{de}', ['\u{fe}', '\u{0}', '\u{0}']),
+    ('\u{100}', ['\u{101}', '\u{0}', '\u{0}']), ('\u{102}', ['\u{103}', '\u{0}', '\u{0}']),
+    ('\u{104}', ['\u{105}', '\u{0}', '\u{0}']), ('\u{106}', ['\u{107}', '\u{0}', '\u{0}']),
+    ('\u{108}', ['\u{109}', '\u{0}', '\u{0}']), ('\u{10a}', ['\u{10b}', '\u{0}', '\u{0}']),
+    ('\u{10c}', ['\u{10d}', '\u{0}', '\u{0}']), ('\u{10e}', ['\u{10f}', '\u{0}', '\u{0}']),
+    ('\u{110}', ['\u{111}', '\u{0}', '\u{0}']), ('\u{112}', ['\u{113}', '\u{0}', '\u{0}']),
+    ('\u{114}', ['\u{115}', '\u{0}', '\u{0}']), ('\u{116}', ['\u{117}', '\u{0}', '\u{0}']),
+    ('\u{118}', ['\u{119}', '\u{0}', '\u{0}']), ('\u{11a}', ['\u{11b}', '\u{0}', '\u{0}']),
+    ('\u{11c}', ['\u{11d}', '\u{0}', '\u{0}']), ('\u{11e}', ['\u{11f}', '\u{0}', '\u{0}']),
+    ('\u{120}', ['\u{121}', '\u{0}', '\u{0}']), ('\u{122}', ['\u{123}', '\u{0}', '\u{0}']),
+    ('\u{124}', ['\u{125}', '\u{0}', '\u{0}']), ('\u{126}', ['\u{127}', '\u{0}', '\u{0}']),
+    ('\u{128}', ['\u{129}', '\u{0}', '\u{0}']), ('\u{12a}', ['\u{12b}', '\u{0}', '\u{0}']),
+    ('\u{12c}', ['\u{12d}', '\u{0}', '\u{0}']), ('\u{12e}', ['\u{12f}', '\u{0}', '\u{0}']),
+    ('\u{130}', ['i', '\u{307}', '\u{0}']), ('\u{132}', ['\u{133}', '\u{0}', '\u{0}']),
+    ('\u{134}', ['\u{135}', '\u{0}', '\u{0}']), ('\u{136}', ['\u{137}', '\u{0}', '\u{0}']),
+    ('\u{139}', ['\u{13a}', '\u{0}', '\u{0}']), ('\u{13b}', ['\u{13c}', '\u{0}', '\u{0}']),
+    ('\u{13d}', ['\u{13e}', '\u{0}', '\u{0}']), ('\u{13f}', ['\u{140}', '\u{0}', '\u{0}']),
+    ('\u{141}', ['\u{142}', '\u{0}', '\u{0}']), ('\u{143}', ['\u{144}', '\u{0}', '\u{0}']),
+    ('\u{145}', ['\u{146}', '\u{0}', '\u{0}']), ('\u{147}', ['\u{148}', '\u{0}', '\u{0}']),
+    ('\u{14a}', ['\u{14b}', '\u{0}', '\u{0}']), ('\u{14c}', ['\u{14d}', '\u{0}', '\u{0}']),
+    ('\u{14e}', ['\u{14f}', '\u{0}', '\u{0}']), ('\u{150}', ['\u{151}', '\u{0}', '\u{0}']),
+    ('\u{152}', ['\u{153}', '\u{0}', '\u{0}']), ('\u{154}', ['\u{155}', '\u{0}', '\u{0}']),
+    ('\u{156}', ['\u{157}', '\u{0}', '\u{0}']), ('\u{158}', ['\u{159}', '\u{0}', '\u{0}']),
+    ('\u{15a}', ['\u{15b}', '\u{0}', '\u{0}']), ('\u{15c}', ['\u{15d}', '\u{0}', '\u{0}']),
+    ('\u{15e}', ['\u{15f}', '\u{0}', '\u{0}']), ('\u{160}', ['\u{161}', '\u{0}', '\u{0}']),
+    ('\u{162}', ['\u{163}', '\u{0}', '\u{0}']), ('\u{164}', ['\u{165}', '\u{0}', '\u{0}']),
+    ('\u{166}', ['\u{167}', '\u{0}', '\u{0}']), ('\u{168}', ['\u{169}', '\u{0}', '\u{0}']),
+    ('\u{16a}', ['\u{16b}', '\u{0}', '\u{0}']), ('\u{16c}', ['\u{16d}', '\u{0}', '\u{0}']),
+    ('\u{16e}', ['\u{16f}', '\u{0}', '\u{0}']), ('\u{170}', ['\u{171}', '\u{0}', '\u{0}']),
+    ('\u{172}', ['\u{173}', '\u{0}', '\u{0}']), ('\u{174}', ['\u{175}', '\u{0}', '\u{0}']),
+    ('\u{176}', ['\u{177}', '\u{0}', '\u{0}']), ('\u{178}', ['\u{ff}', '\u{0}', '\u{0}']),
+    ('\u{179}', ['\u{17a}', '\u{0}', '\u{0}']), ('\u{17b}', ['\u{17c}', '\u{0}', '\u{0}']),
+    ('\u{17d}', ['\u{17e}', '\u{0}', '\u{0}']), ('\u{181}', ['\u{253}', '\u{0}', '\u{0}']),
+    ('\u{182}', ['\u{183}', '\u{0}', '\u{0}']), ('\u{184}', ['\u{185}', '\u{0}', '\u{0}']),
+    ('\u{186}', ['\u{254}', '\u{0}', '\u{0}']), ('\u{187}', ['\u{188}', '\u{0}', '\u{0}']),
+    ('\u{189}', ['\u{256}', '\u{0}', '\u{0}']), ('\u{18a}', ['\u{257}', '\u{0}', '\u{0}']),
+    ('\u{18b}', ['\u{18c}', '\u{0}', '\u{0}']), ('\u{18e}', ['\u{1dd}', '\u{0}', '\u{0}']),
+    ('\u{18f}', ['\u{259}', '\u{0}', '\u{0}']), ('\u{190}', ['\u{25b}', '\u{0}', '\u{0}']),
+    ('\u{191}', ['\u{192}', '\u{0}', '\u{0}']), ('\u{193}', ['\u{260}', '\u{0}', '\u{0}']),
+    ('\u{194}', ['\u{263}', '\u{0}', '\u{0}']), ('\u{196}', ['\u{269}', '\u{0}', '\u{0}']),
+    ('\u{197}', ['\u{268}', '\u{0}', '\u{0}']), ('\u{198}', ['\u{199}', '\u{0}', '\u{0}']),
+    ('\u{19c}', ['\u{26f}', '\u{0}', '\u{0}']), ('\u{19d}', ['\u{272}', '\u{0}', '\u{0}']),
+    ('\u{19f}', ['\u{275}', '\u{0}', '\u{0}']), ('\u{1a0}', ['\u{1a1}', '\u{0}', '\u{0}']),
+    ('\u{1a2}', ['\u{1a3}', '\u{0}', '\u{0}']), ('\u{1a4}', ['\u{1a5}', '\u{0}', '\u{0}']),
+    ('\u{1a6}', ['\u{280}', '\u{0}', '\u{0}']), ('\u{1a7}', ['\u{1a8}', '\u{0}', '\u{0}']),
+    ('\u{1a9}', ['\u{283}', '\u{0}', '\u{0}']), ('\u{1ac}', ['\u{1ad}', '\u{0}', '\u{0}']),
+    ('\u{1ae}', ['\u{288}', '\u{0}', '\u{0}']), ('\u{1af}', ['\u{1b0}', '\u{0}', '\u{0}']),
+    ('\u{1b1}', ['\u{28a}', '\u{0}', '\u{0}']), ('\u{1b2}', ['\u{28b}', '\u{0}', '\u{0}']),
+    ('\u{1b3}', ['\u{1b4}', '\u{0}', '\u{0}']), ('\u{1b5}', ['\u{1b6}', '\u{0}', '\u{0}']),
+    ('\u{1b7}', ['\u{292}', '\u{0}', '\u{0}']), ('\u{1b8}', ['\u{1b9}', '\u{0}', '\u{0}']),
+    ('\u{1bc}', ['\u{1bd}', '\u{0}', '\u{0}']), ('\u{1c4}', ['\u{1c6}', '\u{0}', '\u{0}']),
+    ('\u{1c5}', ['\u{1c6}', '\u{0}', '\u{0}']), ('\u{1c7}', ['\u{1c9}', '\u{0}', '\u{0}']),
+    ('\u{1c8}', ['\u{1c9}', '\u{0}', '\u{0}']), ('\u{1ca}', ['\u{1cc}', '\u{0}', '\u{0}']),
+    ('\u{1cb}', ['\u{1cc}', '\u{0}', '\u{0}']), ('\u{1cd}', ['\u{1ce}', '\u{0}', '\u{0}']),
+    ('\u{1cf}', ['\u{1d0}', '\u{0}', '\u{0}']), ('\u{1d1}', ['\u{1d2}', '\u{0}', '\u{0}']),
+    ('\u{1d3}', ['\u{1d4}', '\u{0}', '\u{0}']), ('\u{1d5}', ['\u{1d6}', '\u{0}', '\u{0}']),
+    ('\u{1d7}', ['\u{1d8}', '\u{0}', '\u{0}']), ('\u{1d9}', ['\u{1da}', '\u{0}', '\u{0}']),
+    ('\u{1db}', ['\u{1dc}', '\u{0}', '\u{0}']), ('\u{1de}', ['\u{1df}', '\u{0}', '\u{0}']),
+    ('\u{1e0}', ['\u{1e1}', '\u{0}', '\u{0}']), ('\u{1e2}', ['\u{1e3}', '\u{0}', '\u{0}']),
+    ('\u{1e4}', ['\u{1e5}', '\u{0}', '\u{0}']), ('\u{1e6}', ['\u{1e7}', '\u{0}', '\u{0}']),
+    ('\u{1e8}', ['\u{1e9}', '\u{0}', '\u{0}']), ('\u{1ea}', ['\u{1eb}', '\u{0}', '\u{0}']),
+    ('\u{1ec}', ['\u{1ed}', '\u{0}', '\u{0}']), ('\u{1ee}', ['\u{1ef}', '\u{0}', '\u{0}']),
+    ('\u{1f1}', ['\u{1f3}', '\u{0}', '\u{0}']), ('\u{1f2}', ['\u{1f3}', '\u{0}', '\u{0}']),
+    ('\u{1f4}', ['\u{1f5}', '\u{0}', '\u{0}']), ('\u{1f6}', ['\u{195}', '\u{0}', '\u{0}']),
+    ('\u{1f7}', ['\u{1bf}', '\u{0}', '\u{0}']), ('\u{1f8}', ['\u{1f9}', '\u{0}', '\u{0}']),
+    ('\u{1fa}', ['\u{1fb}', '\u{0}', '\u{0}']), ('\u{1fc}', ['\u{1fd}', '\u{0}', '\u{0}']),
+    ('\u{1fe}', ['\u{1ff}', '\u{0}', '\u{0}']), ('\u{200}', ['\u{201}', '\u{0}', '\u{0}']),
+    ('\u{202}', ['\u{203}', '\u{0}', '\u{0}']), ('\u{204}', ['\u{205}', '\u{0}', '\u{0}']),
+    ('\u{206}', ['\u{207}', '\u{0}', '\u{0}']), ('\u{208}', ['\u{209}', '\u{0}', '\u{0}']),
+    ('\u{20a}', ['\u{20b}', '\u{0}', '\u{0}']), ('\u{20c}', ['\u{20d}', '\u{0}', '\u{0}']),
+    ('\u{20e}', ['\u{20f}', '\u{0}', '\u{0}']), ('\u{210}', ['\u{211}', '\u{0}', '\u{0}']),
+    ('\u{212}', ['\u{213}', '\u{0}', '\u{0}']), ('\u{214}', ['\u{215}', '\u{0}', '\u{0}']),
+    ('\u{216}', ['\u{217}', '\u{0}', '\u{0}']), ('\u{218}', ['\u{219}', '\u{0}', '\u{0}']),
+    ('\u{21a}', ['\u{21b}', '\u{0}', '\u{0}']), ('\u{21c}', ['\u{21d}', '\u{0}', '\u{0}']),
+    ('\u{21e}', ['\u{21f}', '\u{0}', '\u{0}']), ('\u{220}', ['\u{19e}', '\u{0}', '\u{0}']),
+    ('\u{222}', ['\u{223}', '\u{0}', '\u{0}']), ('\u{224}', ['\u{225}', '\u{0}', '\u{0}']),
+    ('\u{226}', ['\u{227}', '\u{0}', '\u{0}']), ('\u{228}', ['\u{229}', '\u{0}', '\u{0}']),
+    ('\u{22a}', ['\u{22b}', '\u{0}', '\u{0}']), ('\u{22c}', ['\u{22d}', '\u{0}', '\u{0}']),
+    ('\u{22e}', ['\u{22f}', '\u{0}', '\u{0}']), ('\u{230}', ['\u{231}', '\u{0}', '\u{0}']),
+    ('\u{232}', ['\u{233}', '\u{0}', '\u{0}']), ('\u{23a}', ['\u{2c65}', '\u{0}', '\u{0}']),
+    ('\u{23b}', ['\u{23c}', '\u{0}', '\u{0}']), ('\u{23d}', ['\u{19a}', '\u{0}', '\u{0}']),
+    ('\u{23e}', ['\u{2c66}', '\u{0}', '\u{0}']), ('\u{241}', ['\u{242}', '\u{0}', '\u{0}']),
+    ('\u{243}', ['\u{180}', '\u{0}', '\u{0}']), ('\u{244}', ['\u{289}', '\u{0}', '\u{0}']),
+    ('\u{245}', ['\u{28c}', '\u{0}', '\u{0}']), ('\u{246}', ['\u{247}', '\u{0}', '\u{0}']),
+    ('\u{248}', ['\u{249}', '\u{0}', '\u{0}']), ('\u{24a}', ['\u{24b}', '\u{0}', '\u{0}']),
+    ('\u{24c}', ['\u{24d}', '\u{0}', '\u{0}']), ('\u{24e}', ['\u{24f}', '\u{0}', '\u{0}']),
+    ('\u{370}', ['\u{371}', '\u{0}', '\u{0}']), ('\u{372}', ['\u{373}', '\u{0}', '\u{0}']),
+    ('\u{376}', ['\u{377}', '\u{0}', '\u{0}']), ('\u{37f}', ['\u{3f3}', '\u{0}', '\u{0}']),
+    ('\u{386}', ['\u{3ac}', '\u{0}', '\u{0}']), ('\u{388}', ['\u{3ad}', '\u{0}', '\u{0}']),
+    ('\u{389}', ['\u{3ae}', '\u{0}', '\u{0}']), ('\u{38a}', ['\u{3af}', '\u{0}', '\u{0}']),
+    ('\u{38c}', ['\u{3cc}', '\u{0}', '\u{0}']), ('\u{38e}', ['\u{3cd}', '\u{0}', '\u{0}']),
+    ('\u{38f}', ['\u{3ce}', '\u{0}', '\u{0}']), ('\u{391}', ['\u{3b1}', '\u{0}', '\u{0}']),
+    ('\u{392}', ['\u{3b2}', '\u{0}', '\u{0}']), ('\u{393}', ['\u{3b3}', '\u{0}', '\u{0}']),
+    ('\u{394}', ['\u{3b4}', '\u{0}', '\u{0}']), ('\u{395}', ['\u{3b5}', '\u{0}', '\u{0}']),
+    ('\u{396}', ['\u{3b6}', '\u{0}', '\u{0}']), ('\u{397}', ['\u{3b7}', '\u{0}', '\u{0}']),
+    ('\u{398}', ['\u{3b8}', '\u{0}', '\u{0}']), ('\u{399}', ['\u{3b9}', '\u{0}', '\u{0}']),
+    ('\u{39a}', ['\u{3ba}', '\u{0}', '\u{0}']), ('\u{39b}', ['\u{3bb}', '\u{0}', '\u{0}']),
+    ('\u{39c}', ['\u{3bc}', '\u{0}', '\u{0}']), ('\u{39d}', ['\u{3bd}', '\u{0}', '\u{0}']),
+    ('\u{39e}', ['\u{3be}', '\u{0}', '\u{0}']), ('\u{39f}', ['\u{3bf}', '\u{0}', '\u{0}']),
+    ('\u{3a0}', ['\u{3c0}', '\u{0}', '\u{0}']), ('\u{3a1}', ['\u{3c1}', '\u{0}', '\u{0}']),
+    ('\u{3a3}', ['\u{3c3}', '\u{0}', '\u{0}']), ('\u{3a4}', ['\u{3c4}', '\u{0}', '\u{0}']),
+    ('\u{3a5}', ['\u{3c5}', '\u{0}', '\u{0}']), ('\u{3a6}', ['\u{3c6}', '\u{0}', '\u{0}']),
+    ('\u{3a7}', ['\u{3c7}', '\u{0}', '\u{0}']), ('\u{3a8}', ['\u{3c8}', '\u{0}', '\u{0}']),
+    ('\u{3a9}', ['\u{3c9}', '\u{0}', '\u{0}']), ('\u{3aa}', ['\u{3ca}', '\u{0}', '\u{0}']),
+    ('\u{3ab}', ['\u{3cb}', '\u{0}', '\u{0}']), ('\u{3cf}', ['\u{3d7}', '\u{0}', '\u{0}']),
+    ('\u{3d8}', ['\u{3d9}', '\u{0}', '\u{0}']), ('\u{3da}', ['\u{3db}', '\u{0}', '\u{0}']),
+    ('\u{3dc}', ['\u{3dd}', '\u{0}', '\u{0}']), ('\u{3de}', ['\u{3df}', '\u{0}', '\u{0}']),
+    ('\u{3e0}', ['\u{3e1}', '\u{0}', '\u{0}']), ('\u{3e2}', ['\u{3e3}', '\u{0}', '\u{0}']),
+    ('\u{3e4}', ['\u{3e5}', '\u{0}', '\u{0}']), ('\u{3e6}', ['\u{3e7}', '\u{0}', '\u{0}']),
+    ('\u{3e8}', ['\u{3e9}', '\u{0}', '\u{0}']), ('\u{3ea}', ['\u{3eb}', '\u{0}', '\u{0}']),
+    ('\u{3ec}', ['\u{3ed}', '\u{0}', '\u{0}']), ('\u{3ee}', ['\u{3ef}', '\u{0}', '\u{0}']),
+    ('\u{3f4}', ['\u{3b8}', '\u{0}', '\u{0}']), ('\u{3f7}', ['\u{3f8}', '\u{0}', '\u{0}']),
+    ('\u{3f9}', ['\u{3f2}', '\u{0}', '\u{0}']), ('\u{3fa}', ['\u{3fb}', '\u{0}', '\u{0}']),
+    ('\u{3fd}', ['\u{37b}', '\u{0}', '\u{0}']), ('\u{3fe}', ['\u{37c}', '\u{0}', '\u{0}']),
+    ('\u{3ff}', ['\u{37d}', '\u{0}', '\u{0}']), ('\u{400}', ['\u{450}', '\u{0}', '\u{0}']),
+    ('\u{401}', ['\u{451}', '\u{0}', '\u{0}']), ('\u{402}', ['\u{452}', '\u{0}', '\u{0}']),
+    ('\u{403}', ['\u{453}', '\u{0}', '\u{0}']), ('\u{404}', ['\u{454}', '\u{0}', '\u{0}']),
+    ('\u{405}', ['\u{455}', '\u{0}', '\u{0}']), ('\u{406}', ['\u{456}', '\u{0}', '\u{0}']),
+    ('\u{407}', ['\u{457}', '\u{0}', '\u{0}']), ('\u{408}', ['\u{458}', '\u{0}', '\u{0}']),
+    ('\u{409}', ['\u{459}', '\u{0}', '\u{0}']), ('\u{40a}', ['\u{45a}', '\u{0}', '\u{0}']),
+    ('\u{40b}', ['\u{45b}', '\u{0}', '\u{0}']), ('\u{40c}', ['\u{45c}', '\u{0}', '\u{0}']),
+    ('\u{40d}', ['\u{45d}', '\u{0}', '\u{0}']), ('\u{40e}', ['\u{45e}', '\u{0}', '\u{0}']),
+    ('\u{40f}', ['\u{45f}', '\u{0}', '\u{0}']), ('\u{410}', ['\u{430}', '\u{0}', '\u{0}']),
+    ('\u{411}', ['\u{431}', '\u{0}', '\u{0}']), ('\u{412}', ['\u{432}', '\u{0}', '\u{0}']),
+    ('\u{413}', ['\u{433}', '\u{0}', '\u{0}']), ('\u{414}', ['\u{434}', '\u{0}', '\u{0}']),
+    ('\u{415}', ['\u{435}', '\u{0}', '\u{0}']), ('\u{416}', ['\u{436}', '\u{0}', '\u{0}']),
+    ('\u{417}', ['\u{437}', '\u{0}', '\u{0}']), ('\u{418}', ['\u{438}', '\u{0}', '\u{0}']),
+    ('\u{419}', ['\u{439}', '\u{0}', '\u{0}']), ('\u{41a}', ['\u{43a}', '\u{0}', '\u{0}']),
+    ('\u{41b}', ['\u{43b}', '\u{0}', '\u{0}']), ('\u{41c}', ['\u{43c}', '\u{0}', '\u{0}']),
+    ('\u{41d}', ['\u{43d}', '\u{0}', '\u{0}']), ('\u{41e}', ['\u{43e}', '\u{0}', '\u{0}']),
+    ('\u{41f}', ['\u{43f}', '\u{0}', '\u{0}']), ('\u{420}', ['\u{440}', '\u{0}', '\u{0}']),
+    ('\u{421}', ['\u{441}', '\u{0}', '\u{0}']), ('\u{422}', ['\u{442}', '\u{0}', '\u{0}']),
+    ('\u{423}', ['\u{443}', '\u{0}', '\u{0}']), ('\u{424}', ['\u{444}', '\u{0}', '\u{0}']),
+    ('\u{425}', ['\u{445}', '\u{0}', '\u{0}']), ('\u{426}', ['\u{446}', '\u{0}', '\u{0}']),
+    ('\u{427}', ['\u{447}', '\u{0}', '\u{0}']), ('\u{428}', ['\u{448}', '\u{0}', '\u{0}']),
+    ('\u{429}', ['\u{449}', '\u{0}', '\u{0}']), ('\u{42a}', ['\u{44a}', '\u{0}', '\u{0}']),
+    ('\u{42b}', ['\u{44b}', '\u{0}', '\u{0}']), ('\u{42c}', ['\u{44c}', '\u{0}', '\u{0}']),
+    ('\u{42d}', ['\u{44d}', '\u{0}', '\u{0}']), ('\u{42e}', ['\u{44e}', '\u{0}', '\u{0}']),
+    ('\u{42f}', ['\u{44f}', '\u{0}', '\u{0}']), ('\u{460}', ['\u{461}', '\u{0}', '\u{0}']),
+    ('\u{462}', ['\u{463}', '\u{0}', '\u{0}']), ('\u{464}', ['\u{465}', '\u{0}', '\u{0}']),
+    ('\u{466}', ['\u{467}', '\u{0}', '\u{0}']), ('\u{468}', ['\u{469}', '\u{0}', '\u{0}']),
+    ('\u{46a}', ['\u{46b}', '\u{0}', '\u{0}']), ('\u{46c}', ['\u{46d}', '\u{0}', '\u{0}']),
+    ('\u{46e}', ['\u{46f}', '\u{0}', '\u{0}']), ('\u{470}', ['\u{471}', '\u{0}', '\u{0}']),
+    ('\u{472}', ['\u{473}', '\u{0}', '\u{0}']), ('\u{474}', ['\u{475}', '\u{0}', '\u{0}']),
+    ('\u{476}', ['\u{477}', '\u{0}', '\u{0}']), ('\u{478}', ['\u{479}', '\u{0}', '\u{0}']),
+    ('\u{47a}', ['\u{47b}', '\u{0}', '\u{0}']), ('\u{47c}', ['\u{47d}', '\u{0}', '\u{0}']),
+    ('\u{47e}', ['\u{47f}', '\u{0}', '\u{0}']), ('\u{480}', ['\u{481}', '\u{0}', '\u{0}']),
+    ('\u{48a}', ['\u{48b}', '\u{0}', '\u{0}']), ('\u{48c}', ['\u{48d}', '\u{0}', '\u{0}']),
+    ('\u{48e}', ['\u{48f}', '\u{0}', '\u{0}']), ('\u{490}', ['\u{491}', '\u{0}', '\u{0}']),
+    ('\u{492}', ['\u{493}', '\u{0}', '\u{0}']), ('\u{494}', ['\u{495}', '\u{0}', '\u{0}']),
+    ('\u{496}', ['\u{497}', '\u{0}', '\u{0}']), ('\u{498}', ['\u{499}', '\u{0}', '\u{0}']),
+    ('\u{49a}', ['\u{49b}', '\u{0}', '\u{0}']), ('\u{49c}', ['\u{49d}', '\u{0}', '\u{0}']),
+    ('\u{49e}', ['\u{49f}', '\u{0}', '\u{0}']), ('\u{4a0}', ['\u{4a1}', '\u{0}', '\u{0}']),
+    ('\u{4a2}', ['\u{4a3}', '\u{0}', '\u{0}']), ('\u{4a4}', ['\u{4a5}', '\u{0}', '\u{0}']),
+    ('\u{4a6}', ['\u{4a7}', '\u{0}', '\u{0}']), ('\u{4a8}', ['\u{4a9}', '\u{0}', '\u{0}']),
+    ('\u{4aa}', ['\u{4ab}', '\u{0}', '\u{0}']), ('\u{4ac}', ['\u{4ad}', '\u{0}', '\u{0}']),
+    ('\u{4ae}', ['\u{4af}', '\u{0}', '\u{0}']), ('\u{4b0}', ['\u{4b1}', '\u{0}', '\u{0}']),
+    ('\u{4b2}', ['\u{4b3}', '\u{0}', '\u{0}']), ('\u{4b4}', ['\u{4b5}', '\u{0}', '\u{0}']),
+    ('\u{4b6}', ['\u{4b7}', '\u{0}', '\u{0}']), ('\u{4b8}', ['\u{4b9}', '\u{0}', '\u{0}']),
+    ('\u{4ba}', ['\u{4bb}', '\u{0}', '\u{0}']), ('\u{4bc}', ['\u{4bd}', '\u{0}', '\u{0}']),
+    ('\u{4be}', ['\u{4bf}', '\u{0}', '\u{0}']), ('\u{4c0}', ['\u{4cf}', '\u{0}', '\u{0}']),
+    ('\u{4c1}', ['\u{4c2}', '\u{0}', '\u{0}']), ('\u{4c3}', ['\u{4c4}', '\u{0}', '\u{0}']),
+    ('\u{4c5}', ['\u{4c6}', '\u{0}', '\u{0}']), ('\u{4c7}', ['\u{4c8}', '\u{0}', '\u{0}']),
+    ('\u{4c9}', ['\u{4ca}', '\u{0}', '\u{0}']), ('\u{4cb}', ['\u{4cc}', '\u{0}', '\u{0}']),
+    ('\u{4cd}', ['\u{4ce}', '\u{0}', '\u{0}']), ('\u{4d0}', ['\u{4d1}', '\u{0}', '\u{0}']),
+    ('\u{4d2}', ['\u{4d3}', '\u{0}', '\u{0}']), ('\u{4d4}', ['\u{4d5}', '\u{0}', '\u{0}']),
+    ('\u{4d6}', ['\u{4d7}', '\u{0}', '\u{0}']), ('\u{4d8}', ['\u{4d9}', '\u{0}', '\u{0}']),
+    ('\u{4da}', ['\u{4db}', '\u{0}', '\u{0}']), ('\u{4dc}', ['\u{4dd}', '\u{0}', '\u{0}']),
+    ('\u{4de}', ['\u{4df}', '\u{0}', '\u{0}']), ('\u{4e0}', ['\u{4e1}', '\u{0}', '\u{0}']),
+    ('\u{4e2}', ['\u{4e3}', '\u{0}', '\u{0}']), ('\u{4e4}', ['\u{4e5}', '\u{0}', '\u{0}']),
+    ('\u{4e6}', ['\u{4e7}', '\u{0}', '\u{0}']), ('\u{4e8}', ['\u{4e9}', '\u{0}', '\u{0}']),
+    ('\u{4ea}', ['\u{4eb}', '\u{0}', '\u{0}']), ('\u{4ec}', ['\u{4ed}', '\u{0}', '\u{0}']),
+    ('\u{4ee}', ['\u{4ef}', '\u{0}', '\u{0}']), ('\u{4f0}', ['\u{4f1}', '\u{0}', '\u{0}']),
+    ('\u{4f2}', ['\u{4f3}', '\u{0}', '\u{0}']), ('\u{4f4}', ['\u{4f5}', '\u{0}', '\u{0}']),
+    ('\u{4f6}', ['\u{4f7}', '\u{0}', '\u{0}']), ('\u{4f8}', ['\u{4f9}', '\u{0}', '\u{0}']),
+    ('\u{4fa}', ['\u{4fb}', '\u{0}', '\u{0}']), ('\u{4fc}', ['\u{4fd}', '\u{0}', '\u{0}']),
+    ('\u{4fe}', ['\u{4ff}', '\u{0}', '\u{0}']), ('\u{500}', ['\u{501}', '\u{0}', '\u{0}']),
+    ('\u{502}', ['\u{503}', '\u{0}', '\u{0}']), ('\u{504}', ['\u{505}', '\u{0}', '\u{0}']),
+    ('\u{506}', ['\u{507}', '\u{0}', '\u{0}']), ('\u{508}', ['\u{509}', '\u{0}', '\u{0}']),
+    ('\u{50a}', ['\u{50b}', '\u{0}', '\u{0}']), ('\u{50c}', ['\u{50d}', '\u{0}', '\u{0}']),
+    ('\u{50e}', ['\u{50f}', '\u{0}', '\u{0}']), ('\u{510}', ['\u{511}', '\u{0}', '\u{0}']),
+    ('\u{512}', ['\u{513}', '\u{0}', '\u{0}']), ('\u{514}', ['\u{515}', '\u{0}', '\u{0}']),
+    ('\u{516}', ['\u{517}', '\u{0}', '\u{0}']), ('\u{518}', ['\u{519}', '\u{0}', '\u{0}']),
+    ('\u{51a}', ['\u{51b}', '\u{0}', '\u{0}']), ('\u{51c}', ['\u{51d}', '\u{0}', '\u{0}']),
+    ('\u{51e}', ['\u{51f}', '\u{0}', '\u{0}']), ('\u{520}', ['\u{521}', '\u{0}', '\u{0}']),
+    ('\u{522}', ['\u{523}', '\u{0}', '\u{0}']), ('\u{524}', ['\u{525}', '\u{0}', '\u{0}']),
+    ('\u{526}', ['\u{527}', '\u{0}', '\u{0}']), ('\u{528}', ['\u{529}', '\u{0}', '\u{0}']),
+    ('\u{52a}', ['\u{52b}', '\u{0}', '\u{0}']), ('\u{52c}', ['\u{52d}', '\u{0}', '\u{0}']),
+    ('\u{52e}', ['\u{52f}', '\u{0}', '\u{0}']), ('\u{531}', ['\u{561}', '\u{0}', '\u{0}']),
+    ('\u{532}', ['\u{562}', '\u{0}', '\u{0}']), ('\u{533}', ['\u{563}', '\u{0}', '\u{0}']),
+    ('\u{534}', ['\u{564}', '\u{0}', '\u{0}']), ('\u{535}', ['\u{565}', '\u{0}', '\u{0}']),
+    ('\u{536}', ['\u{566}', '\u{0}', '\u{0}']), ('\u{537}', ['\u{567}', '\u{0}', '\u{0}']),
+    ('\u{538}', ['\u{568}', '\u{0}', '\u{0}']), ('\u{539}', ['\u{569}', '\u{0}', '\u{0}']),
+    ('\u{53a}', ['\u{56a}', '\u{0}', '\u{0}']), ('\u{53b}', ['\u{56b}', '\u{0}', '\u{0}']),
+    ('\u{53c}', ['\u{56c}', '\u{0}', '\u{0}']), ('\u{53d}', ['\u{56d}', '\u{0}', '\u{0}']),
+    ('\u{53e}', ['\u{56e}', '\u{0}', '\u{0}']), ('\u{53f}', ['\u{56f}', '\u{0}', '\u{0}']),
+    ('\u{540}', ['\u{570}', '\u{0}', '\u{0}']), ('\u{541}', ['\u{571}', '\u{0}', '\u{0}']),
+    ('\u{542}', ['\u{572}', '\u{0}', '\u{0}']), ('\u{543}', ['\u{573}', '\u{0}', '\u{0}']),
+    ('\u{544}', ['\u{574}', '\u{0}', '\u{0}']), ('\u{545}', ['\u{575}', '\u{0}', '\u{0}']),
+    ('\u{546}', ['\u{576}', '\u{0}', '\u{0}']), ('\u{547}', ['\u{577}', '\u{0}', '\u{0}']),
+    ('\u{548}', ['\u{578}', '\u{0}', '\u{0}']), ('\u{549}', ['\u{579}', '\u{0}', '\u{0}']),
+    ('\u{54a}', ['\u{57a}', '\u{0}', '\u{0}']), ('\u{54b}', ['\u{57b}', '\u{0}', '\u{0}']),
+    ('\u{54c}', ['\u{57c}', '\u{0}', '\u{0}']), ('\u{54d}', ['\u{57d}', '\u{0}', '\u{0}']),
+    ('\u{54e}', ['\u{57e}', '\u{0}', '\u{0}']), ('\u{54f}', ['\u{57f}', '\u{0}', '\u{0}']),
+    ('\u{550}', ['\u{580}', '\u{0}', '\u{0}']), ('\u{551}', ['\u{581}', '\u{0}', '\u{0}']),
+    ('\u{552}', ['\u{582}', '\u{0}', '\u{0}']), ('\u{553}', ['\u{583}', '\u{0}', '\u{0}']),
+    ('\u{554}', ['\u{584}', '\u{0}', '\u{0}']), ('\u{555}', ['\u{585}', '\u{0}', '\u{0}']),
+    ('\u{556}', ['\u{586}', '\u{0}', '\u{0}']), ('\u{10a0}', ['\u{2d00}', '\u{0}', '\u{0}']),
+    ('\u{10a1}', ['\u{2d01}', '\u{0}', '\u{0}']), ('\u{10a2}', ['\u{2d02}', '\u{0}', '\u{0}']),
+    ('\u{10a3}', ['\u{2d03}', '\u{0}', '\u{0}']), ('\u{10a4}', ['\u{2d04}', '\u{0}', '\u{0}']),
+    ('\u{10a5}', ['\u{2d05}', '\u{0}', '\u{0}']), ('\u{10a6}', ['\u{2d06}', '\u{0}', '\u{0}']),
+    ('\u{10a7}', ['\u{2d07}', '\u{0}', '\u{0}']), ('\u{10a8}', ['\u{2d08}', '\u{0}', '\u{0}']),
+    ('\u{10a9}', ['\u{2d09}', '\u{0}', '\u{0}']), ('\u{10aa}', ['\u{2d0a}', '\u{0}', '\u{0}']),
+    ('\u{10ab}', ['\u{2d0b}', '\u{0}', '\u{0}']), ('\u{10ac}', ['\u{2d0c}', '\u{0}', '\u{0}']),
+    ('\u{10ad}', ['\u{2d0d}', '\u{0}', '\u{0}']), ('\u{10ae}', ['\u{2d0e}', '\u{0}', '\u{0}']),
+    ('\u{10af}', ['\u{2d0f}', '\u{0}', '\u{0}']), ('\u{10b0}', ['\u{2d10}', '\u{0}', '\u{0}']),
+    ('\u{10b1}', ['\u{2d11}', '\u{0}', '\u{0}']), ('\u{10b2}', ['\u{2d12}', '\u{0}', '\u{0}']),
+    ('\u{10b3}', ['\u{2d13}', '\u{0}', '\u{0}']), ('\u{10b4}', ['\u{2d14}', '\u{0}', '\u{0}']),
+    ('\u{10b5}', ['\u{2d15}', '\u{0}', '\u{0}']), ('\u{10b6}', ['\u{2d16}', '\u{0}', '\u{0}']),
+    ('\u{10b7}', ['\u{2d17}', '\u{0}', '\u{0}']), ('\u{10b8}', ['\u{2d18}', '\u{0}', '\u{0}']),
+    ('\u{10b9}', ['\u{2d19}', '\u{0}', '\u{0}']), ('\u{10ba}', ['\u{2d1a}', '\u{0}', '\u{0}']),
+    ('\u{10bb}', ['\u{2d1b}', '\u{0}', '\u{0}']), ('\u{10bc}', ['\u{2d1c}', '\u{0}', '\u{0}']),
+    ('\u{10bd}', ['\u{2d1d}', '\u{0}', '\u{0}']), ('\u{10be}', ['\u{2d1e}', '\u{0}', '\u{0}']),
+    ('\u{10bf}', ['\u{2d1f}', '\u{0}', '\u{0}']), ('\u{10c0}', ['\u{2d20}', '\u{0}', '\u{0}']),
+    ('\u{10c1}', ['\u{2d21}', '\u{0}', '\u{0}']), ('\u{10c2}', ['\u{2d22}', '\u{0}', '\u{0}']),
+    ('\u{10c3}', ['\u{2d23}', '\u{0}', '\u{0}']), ('\u{10c4}', ['\u{2d24}', '\u{0}', '\u{0}']),
+    ('\u{10c5}', ['\u{2d25}', '\u{0}', '\u{0}']), ('\u{10c7}', ['\u{2d27}', '\u{0}', '\u{0}']),
+    ('\u{10cd}', ['\u{2d2d}', '\u{0}', '\u{0}']), ('\u{13a0}', ['\u{ab70}', '\u{0}', '\u{0}']),
+    ('\u{13a1}', ['\u{ab71}', '\u{0}', '\u{0}']), ('\u{13a2}', ['\u{ab72}', '\u{0}', '\u{0}']),
+    ('\u{13a3}', ['\u{ab73}', '\u{0}', '\u{0}']), ('\u{13a4}', ['\u{ab74}', '\u{0}', '\u{0}']),
+    ('\u{13a5}', ['\u{ab75}', '\u{0}', '\u{0}']), ('\u{13a6}', ['\u{ab76}', '\u{0}', '\u{0}']),
+    ('\u{13a7}', ['\u{ab77}', '\u{0}', '\u{0}']), ('\u{13a8}', ['\u{ab78}', '\u{0}', '\u{0}']),
+    ('\u{13a9}', ['\u{ab79}', '\u{0}', '\u{0}']), ('\u{13aa}', ['\u{ab7a}', '\u{0}', '\u{0}']),
+    ('\u{13ab}', ['\u{ab7b}', '\u{0}', '\u{0}']), ('\u{13ac}', ['\u{ab7c}', '\u{0}', '\u{0}']),
+    ('\u{13ad}', ['\u{ab7d}', '\u{0}', '\u{0}']), ('\u{13ae}', ['\u{ab7e}', '\u{0}', '\u{0}']),
+    ('\u{13af}', ['\u{ab7f}', '\u{0}', '\u{0}']), ('\u{13b0}', ['\u{ab80}', '\u{0}', '\u{0}']),
+    ('\u{13b1}', ['\u{ab81}', '\u{0}', '\u{0}']), ('\u{13b2}', ['\u{ab82}', '\u{0}', '\u{0}']),
+    ('\u{13b3}', ['\u{ab83}', '\u{0}', '\u{0}']), ('\u{13b4}', ['\u{ab84}', '\u{0}', '\u{0}']),
+    ('\u{13b5}', ['\u{ab85}', '\u{0}', '\u{0}']), ('\u{13b6}', ['\u{ab86}', '\u{0}', '\u{0}']),
+    ('\u{13b7}', ['\u{ab87}', '\u{0}', '\u{0}']), ('\u{13b8}', ['\u{ab88}', '\u{0}', '\u{0}']),
+    ('\u{13b9}', ['\u{ab89}', '\u{0}', '\u{0}']), ('\u{13ba}', ['\u{ab8a}', '\u{0}', '\u{0}']),
+    ('\u{13bb}', ['\u{ab8b}', '\u{0}', '\u{0}']), ('\u{13bc}', ['\u{ab8c}', '\u{0}', '\u{0}']),
+    ('\u{13bd}', ['\u{ab8d}', '\u{0}', '\u{0}']), ('\u{13be}', ['\u{ab8e}', '\u{0}', '\u{0}']),
+    ('\u{13bf}', ['\u{ab8f}', '\u{0}', '\u{0}']), ('\u{13c0}', ['\u{ab90}', '\u{0}', '\u{0}']),
+    ('\u{13c1}', ['\u{ab91}', '\u{0}', '\u{0}']), ('\u{13c2}', ['\u{ab92}', '\u{0}', '\u{0}']),
+    ('\u{13c3}', ['\u{ab93}', '\u{0}', '\u{0}']), ('\u{13c4}', ['\u{ab94}', '\u{0}', '\u{0}']),
+    ('\u{13c5}', ['\u{ab95}', '\u{0}', '\u{0}']), ('\u{13c6}', ['\u{ab96}', '\u{0}', '\u{0}']),
+    ('\u{13c7}', ['\u{ab97}', '\u{0}', '\u{0}']), ('\u{13c8}', ['\u{ab98}', '\u{0}', '\u{0}']),
+    ('\u{13c9}', ['\u{ab99}', '\u{0}', '\u{0}']), ('\u{13ca}', ['\u{ab9a}', '\u{0}', '\u{0}']),
+    ('\u{13cb}', ['\u{ab9b}', '\u{0}', '\u{0}']), ('\u{13cc}', ['\u{ab9c}', '\u{0}', '\u{0}']),
+    ('\u{13cd}', ['\u{ab9d}', '\u{0}', '\u{0}']), ('\u{13ce}', ['\u{ab9e}', '\u{0}', '\u{0}']),
+    ('\u{13cf}', ['\u{ab9f}', '\u{0}', '\u{0}']), ('\u{13d0}', ['\u{aba0}', '\u{0}', '\u{0}']),
+    ('\u{13d1}', ['\u{aba1}', '\u{0}', '\u{0}']), ('\u{13d2}', ['\u{aba2}', '\u{0}', '\u{0}']),
+    ('\u{13d3}', ['\u{aba3}', '\u{0}', '\u{0}']), ('\u{13d4}', ['\u{aba4}', '\u{0}', '\u{0}']),
+    ('\u{13d5}', ['\u{aba5}', '\u{0}', '\u{0}']), ('\u{13d6}', ['\u{aba6}', '\u{0}', '\u{0}']),
+    ('\u{13d7}', ['\u{aba7}', '\u{0}', '\u{0}']), ('\u{13d8}', ['\u{aba8}', '\u{0}', '\u{0}']),
+    ('\u{13d9}', ['\u{aba9}', '\u{0}', '\u{0}']), ('\u{13da}', ['\u{abaa}', '\u{0}', '\u{0}']),
+    ('\u{13db}', ['\u{abab}', '\u{0}', '\u{0}']), ('\u{13dc}', ['\u{abac}', '\u{0}', '\u{0}']),
+    ('\u{13dd}', ['\u{abad}', '\u{0}', '\u{0}']), ('\u{13de}', ['\u{abae}', '\u{0}', '\u{0}']),
+    ('\u{13df}', ['\u{abaf}', '\u{0}', '\u{0}']), ('\u{13e0}', ['\u{abb0}', '\u{0}', '\u{0}']),
+    ('\u{13e1}', ['\u{abb1}', '\u{0}', '\u{0}']), ('\u{13e2}', ['\u{abb2}', '\u{0}', '\u{0}']),
+    ('\u{13e3}', ['\u{abb3}', '\u{0}', '\u{0}']), ('\u{13e4}', ['\u{abb4}', '\u{0}', '\u{0}']),
+    ('\u{13e5}', ['\u{abb5}', '\u{0}', '\u{0}']), ('\u{13e6}', ['\u{abb6}', '\u{0}', '\u{0}']),
+    ('\u{13e7}', ['\u{abb7}', '\u{0}', '\u{0}']), ('\u{13e8}', ['\u{abb8}', '\u{0}', '\u{0}']),
+    ('\u{13e9}', ['\u{abb9}', '\u{0}', '\u{0}']), ('\u{13ea}', ['\u{abba}', '\u{0}', '\u{0}']),
+    ('\u{13eb}', ['\u{abbb}', '\u{0}', '\u{0}']), ('\u{13ec}', ['\u{abbc}', '\u{0}', '\u{0}']),
+    ('\u{13ed}', ['\u{abbd}', '\u{0}', '\u{0}']), ('\u{13ee}', ['\u{abbe}', '\u{0}', '\u{0}']),
+    ('\u{13ef}', ['\u{abbf}', '\u{0}', '\u{0}']), ('\u{13f0}', ['\u{13f8}', '\u{0}', '\u{0}']),
+    ('\u{13f1}', ['\u{13f9}', '\u{0}', '\u{0}']), ('\u{13f2}', ['\u{13fa}', '\u{0}', '\u{0}']),
+    ('\u{13f3}', ['\u{13fb}', '\u{0}', '\u{0}']), ('\u{13f4}', ['\u{13fc}', '\u{0}', '\u{0}']),
+    ('\u{13f5}', ['\u{13fd}', '\u{0}', '\u{0}']), ('\u{1c89}', ['\u{1c8a}', '\u{0}', '\u{0}']),
+    ('\u{1c90}', ['\u{10d0}', '\u{0}', '\u{0}']), ('\u{1c91}', ['\u{10d1}', '\u{0}', '\u{0}']),
+    ('\u{1c92}', ['\u{10d2}', '\u{0}', '\u{0}']), ('\u{1c93}', ['\u{10d3}', '\u{0}', '\u{0}']),
+    ('\u{1c94}', ['\u{10d4}', '\u{0}', '\u{0}']), ('\u{1c95}', ['\u{10d5}', '\u{0}', '\u{0}']),
+    ('\u{1c96}', ['\u{10d6}', '\u{0}', '\u{0}']), ('\u{1c97}', ['\u{10d7}', '\u{0}', '\u{0}']),
+    ('\u{1c98}', ['\u{10d8}', '\u{0}', '\u{0}']), ('\u{1c99}', ['\u{10d9}', '\u{0}', '\u{0}']),
+    ('\u{1c9a}', ['\u{10da}', '\u{0}', '\u{0}']), ('\u{1c9b}', ['\u{10db}', '\u{0}', '\u{0}']),
+    ('\u{1c9c}', ['\u{10dc}', '\u{0}', '\u{0}']), ('\u{1c9d}', ['\u{10dd}', '\u{0}', '\u{0}']),
+    ('\u{1c9e}', ['\u{10de}', '\u{0}', '\u{0}']), ('\u{1c9f}', ['\u{10df}', '\u{0}', '\u{0}']),
+    ('\u{1ca0}', ['\u{10e0}', '\u{0}', '\u{0}']), ('\u{1ca1}', ['\u{10e1}', '\u{0}', '\u{0}']),
+    ('\u{1ca2}', ['\u{10e2}', '\u{0}', '\u{0}']), ('\u{1ca3}', ['\u{10e3}', '\u{0}', '\u{0}']),
+    ('\u{1ca4}', ['\u{10e4}', '\u{0}', '\u{0}']), ('\u{1ca5}', ['\u{10e5}', '\u{0}', '\u{0}']),
+    ('\u{1ca6}', ['\u{10e6}', '\u{0}', '\u{0}']), ('\u{1ca7}', ['\u{10e7}', '\u{0}', '\u{0}']),
+    ('\u{1ca8}', ['\u{10e8}', '\u{0}', '\u{0}']), ('\u{1ca9}', ['\u{10e9}', '\u{0}', '\u{0}']),
+    ('\u{1caa}', ['\u{10ea}', '\u{0}', '\u{0}']), ('\u{1cab}', ['\u{10eb}', '\u{0}', '\u{0}']),
+    ('\u{1cac}', ['\u{10ec}', '\u{0}', '\u{0}']), ('\u{1cad}', ['\u{10ed}', '\u{0}', '\u{0}']),
+    ('\u{1cae}', ['\u{10ee}', '\u{0}', '\u{0}']), ('\u{1caf}', ['\u{10ef}', '\u{0}', '\u{0}']),
+    ('\u{1cb0}', ['\u{10f0}', '\u{0}', '\u{0}']), ('\u{1cb1}', ['\u{10f1}', '\u{0}', '\u{0}']),
+    ('\u{1cb2}', ['\u{10f2}', '\u{0}', '\u{0}']), ('\u{1cb3}', ['\u{10f3}', '\u{0}', '\u{0}']),
+    ('\u{1cb4}', ['\u{10f4}', '\u{0}', '\u{0}']), ('\u{1cb5}', ['\u{10f5}', '\u{0}', '\u{0}']),
+    ('\u{1cb6}', ['\u{10f6}', '\u{0}', '\u{0}']), ('\u{1cb7}', ['\u{10f7}', '\u{0}', '\u{0}']),
+    ('\u{1cb8}', ['\u{10f8}', '\u{0}', '\u{0}']), ('\u{1cb9}', ['\u{10f9}', '\u{0}', '\u{0}']),
+    ('\u{1cba}', ['\u{10fa}', '\u{0}', '\u{0}']), ('\u{1cbd}', ['\u{10fd}', '\u{0}', '\u{0}']),
+    ('\u{1cbe}', ['\u{10fe}', '\u{0}', '\u{0}']), ('\u{1cbf}', ['\u{10ff}', '\u{0}', '\u{0}']),
+    ('\u{1e00}', ['\u{1e01}', '\u{0}', '\u{0}']), ('\u{1e02}', ['\u{1e03}', '\u{0}', '\u{0}']),
+    ('\u{1e04}', ['\u{1e05}', '\u{0}', '\u{0}']), ('\u{1e06}', ['\u{1e07}', '\u{0}', '\u{0}']),
+    ('\u{1e08}', ['\u{1e09}', '\u{0}', '\u{0}']), ('\u{1e0a}', ['\u{1e0b}', '\u{0}', '\u{0}']),
+    ('\u{1e0c}', ['\u{1e0d}', '\u{0}', '\u{0}']), ('\u{1e0e}', ['\u{1e0f}', '\u{0}', '\u{0}']),
+    ('\u{1e10}', ['\u{1e11}', '\u{0}', '\u{0}']), ('\u{1e12}', ['\u{1e13}', '\u{0}', '\u{0}']),
+    ('\u{1e14}', ['\u{1e15}', '\u{0}', '\u{0}']), ('\u{1e16}', ['\u{1e17}', '\u{0}', '\u{0}']),
+    ('\u{1e18}', ['\u{1e19}', '\u{0}', '\u{0}']), ('\u{1e1a}', ['\u{1e1b}', '\u{0}', '\u{0}']),
+    ('\u{1e1c}', ['\u{1e1d}', '\u{0}', '\u{0}']), ('\u{1e1e}', ['\u{1e1f}', '\u{0}', '\u{0}']),
+    ('\u{1e20}', ['\u{1e21}', '\u{0}', '\u{0}']), ('\u{1e22}', ['\u{1e23}', '\u{0}', '\u{0}']),
+    ('\u{1e24}', ['\u{1e25}', '\u{0}', '\u{0}']), ('\u{1e26}', ['\u{1e27}', '\u{0}', '\u{0}']),
+    ('\u{1e28}', ['\u{1e29}', '\u{0}', '\u{0}']), ('\u{1e2a}', ['\u{1e2b}', '\u{0}', '\u{0}']),
+    ('\u{1e2c}', ['\u{1e2d}', '\u{0}', '\u{0}']), ('\u{1e2e}', ['\u{1e2f}', '\u{0}', '\u{0}']),
+    ('\u{1e30}', ['\u{1e31}', '\u{0}', '\u{0}']), ('\u{1e32}', ['\u{1e33}', '\u{0}', '\u{0}']),
+    ('\u{1e34}', ['\u{1e35}', '\u{0}', '\u{0}']), ('\u{1e36}', ['\u{1e37}', '\u{0}', '\u{0}']),
+    ('\u{1e38}', ['\u{1e39}', '\u{0}', '\u{0}']), ('\u{1e3a}', ['\u{1e3b}', '\u{0}', '\u{0}']),
+    ('\u{1e3c}', ['\u{1e3d}', '\u{0}', '\u{0}']), ('\u{1e3e}', ['\u{1e3f}', '\u{0}', '\u{0}']),
+    ('\u{1e40}', ['\u{1e41}', '\u{0}', '\u{0}']), ('\u{1e42}', ['\u{1e43}', '\u{0}', '\u{0}']),
+    ('\u{1e44}', ['\u{1e45}', '\u{0}', '\u{0}']), ('\u{1e46}', ['\u{1e47}', '\u{0}', '\u{0}']),
+    ('\u{1e48}', ['\u{1e49}', '\u{0}', '\u{0}']), ('\u{1e4a}', ['\u{1e4b}', '\u{0}', '\u{0}']),
+    ('\u{1e4c}', ['\u{1e4d}', '\u{0}', '\u{0}']), ('\u{1e4e}', ['\u{1e4f}', '\u{0}', '\u{0}']),
+    ('\u{1e50}', ['\u{1e51}', '\u{0}', '\u{0}']), ('\u{1e52}', ['\u{1e53}', '\u{0}', '\u{0}']),
+    ('\u{1e54}', ['\u{1e55}', '\u{0}', '\u{0}']), ('\u{1e56}', ['\u{1e57}', '\u{0}', '\u{0}']),
+    ('\u{1e58}', ['\u{1e59}', '\u{0}', '\u{0}']), ('\u{1e5a}', ['\u{1e5b}', '\u{0}', '\u{0}']),
+    ('\u{1e5c}', ['\u{1e5d}', '\u{0}', '\u{0}']), ('\u{1e5e}', ['\u{1e5f}', '\u{0}', '\u{0}']),
+    ('\u{1e60}', ['\u{1e61}', '\u{0}', '\u{0}']), ('\u{1e62}', ['\u{1e63}', '\u{0}', '\u{0}']),
+    ('\u{1e64}', ['\u{1e65}', '\u{0}', '\u{0}']), ('\u{1e66}', ['\u{1e67}', '\u{0}', '\u{0}']),
+    ('\u{1e68}', ['\u{1e69}', '\u{0}', '\u{0}']), ('\u{1e6a}', ['\u{1e6b}', '\u{0}', '\u{0}']),
+    ('\u{1e6c}', ['\u{1e6d}', '\u{0}', '\u{0}']), ('\u{1e6e}', ['\u{1e6f}', '\u{0}', '\u{0}']),
+    ('\u{1e70}', ['\u{1e71}', '\u{0}', '\u{0}']), ('\u{1e72}', ['\u{1e73}', '\u{0}', '\u{0}']),
+    ('\u{1e74}', ['\u{1e75}', '\u{0}', '\u{0}']), ('\u{1e76}', ['\u{1e77}', '\u{0}', '\u{0}']),
+    ('\u{1e78}', ['\u{1e79}', '\u{0}', '\u{0}']), ('\u{1e7a}', ['\u{1e7b}', '\u{0}', '\u{0}']),
+    ('\u{1e7c}', ['\u{1e7d}', '\u{0}', '\u{0}']), ('\u{1e7e}', ['\u{1e7f}', '\u{0}', '\u{0}']),
+    ('\u{1e80}', ['\u{1e81}', '\u{0}', '\u{0}']), ('\u{1e82}', ['\u{1e83}', '\u{0}', '\u{0}']),
+    ('\u{1e84}', ['\u{1e85}', '\u{0}', '\u{0}']), ('\u{1e86}', ['\u{1e87}', '\u{0}', '\u{0}']),
+    ('\u{1e88}', ['\u{1e89}', '\u{0}', '\u{0}']), ('\u{1e8a}', ['\u{1e8b}', '\u{0}', '\u{0}']),
+    ('\u{1e8c}', ['\u{1e8d}', '\u{0}', '\u{0}']), ('\u{1e8e}', ['\u{1e8f}', '\u{0}', '\u{0}']),
+    ('\u{1e90}', ['\u{1e91}', '\u{0}', '\u{0}']), ('\u{1e92}', ['\u{1e93}', '\u{0}', '\u{0}']),
+    ('\u{1e94}', ['\u{1e95}', '\u{0}', '\u{0}']), ('\u{1e9e}', ['\u{df}', '\u{0}', '\u{0}']),
+    ('\u{1ea0}', ['\u{1ea1}', '\u{0}', '\u{0}']), ('\u{1ea2}', ['\u{1ea3}', '\u{0}', '\u{0}']),
+    ('\u{1ea4}', ['\u{1ea5}', '\u{0}', '\u{0}']), ('\u{1ea6}', ['\u{1ea7}', '\u{0}', '\u{0}']),
+    ('\u{1ea8}', ['\u{1ea9}', '\u{0}', '\u{0}']), ('\u{1eaa}', ['\u{1eab}', '\u{0}', '\u{0}']),
+    ('\u{1eac}', ['\u{1ead}', '\u{0}', '\u{0}']), ('\u{1eae}', ['\u{1eaf}', '\u{0}', '\u{0}']),
+    ('\u{1eb0}', ['\u{1eb1}', '\u{0}', '\u{0}']), ('\u{1eb2}', ['\u{1eb3}', '\u{0}', '\u{0}']),
+    ('\u{1eb4}', ['\u{1eb5}', '\u{0}', '\u{0}']), ('\u{1eb6}', ['\u{1eb7}', '\u{0}', '\u{0}']),
+    ('\u{1eb8}', ['\u{1eb9}', '\u{0}', '\u{0}']), ('\u{1eba}', ['\u{1ebb}', '\u{0}', '\u{0}']),
+    ('\u{1ebc}', ['\u{1ebd}', '\u{0}', '\u{0}']), ('\u{1ebe}', ['\u{1ebf}', '\u{0}', '\u{0}']),
+    ('\u{1ec0}', ['\u{1ec1}', '\u{0}', '\u{0}']), ('\u{1ec2}', ['\u{1ec3}', '\u{0}', '\u{0}']),
+    ('\u{1ec4}', ['\u{1ec5}', '\u{0}', '\u{0}']), ('\u{1ec6}', ['\u{1ec7}', '\u{0}', '\u{0}']),
+    ('\u{1ec8}', ['\u{1ec9}', '\u{0}', '\u{0}']), ('\u{1eca}', ['\u{1ecb}', '\u{0}', '\u{0}']),
+    ('\u{1ecc}', ['\u{1ecd}', '\u{0}', '\u{0}']), ('\u{1ece}', ['\u{1ecf}', '\u{0}', '\u{0}']),
+    ('\u{1ed0}', ['\u{1ed1}', '\u{0}', '\u{0}']), ('\u{1ed2}', ['\u{1ed3}', '\u{0}', '\u{0}']),
+    ('\u{1ed4}', ['\u{1ed5}', '\u{0}', '\u{0}']), ('\u{1ed6}', ['\u{1ed7}', '\u{0}', '\u{0}']),
+    ('\u{1ed8}', ['\u{1ed9}', '\u{0}', '\u{0}']), ('\u{1eda}', ['\u{1edb}', '\u{0}', '\u{0}']),
+    ('\u{1edc}', ['\u{1edd}', '\u{0}', '\u{0}']), ('\u{1ede}', ['\u{1edf}', '\u{0}', '\u{0}']),
+    ('\u{1ee0}', ['\u{1ee1}', '\u{0}', '\u{0}']), ('\u{1ee2}', ['\u{1ee3}', '\u{0}', '\u{0}']),
+    ('\u{1ee4}', ['\u{1ee5}', '\u{0}', '\u{0}']), ('\u{1ee6}', ['\u{1ee7}', '\u{0}', '\u{0}']),
+    ('\u{1ee8}', ['\u{1ee9}', '\u{0}', '\u{0}']), ('\u{1eea}', ['\u{1eeb}', '\u{0}', '\u{0}']),
+    ('\u{1eec}', ['\u{1eed}', '\u{0}', '\u{0}']), ('\u{1eee}', ['\u{1eef}', '\u{0}', '\u{0}']),
+    ('\u{1ef0}', ['\u{1ef1}', '\u{0}', '\u{0}']), ('\u{1ef2}', ['\u{1ef3}', '\u{0}', '\u{0}']),
+    ('\u{1ef4}', ['\u{1ef5}', '\u{0}', '\u{0}']), ('\u{1ef6}', ['\u{1ef7}', '\u{0}', '\u{0}']),
+    ('\u{1ef8}', ['\u{1ef9}', '\u{0}', '\u{0}']), ('\u{1efa}', ['\u{1efb}', '\u{0}', '\u{0}']),
+    ('\u{1efc}', ['\u{1efd}', '\u{0}', '\u{0}']), ('\u{1efe}', ['\u{1eff}', '\u{0}', '\u{0}']),
+    ('\u{1f08}', ['\u{1f00}', '\u{0}', '\u{0}']), ('\u{1f09}', ['\u{1f01}', '\u{0}', '\u{0}']),
+    ('\u{1f0a}', ['\u{1f02}', '\u{0}', '\u{0}']), ('\u{1f0b}', ['\u{1f03}', '\u{0}', '\u{0}']),
+    ('\u{1f0c}', ['\u{1f04}', '\u{0}', '\u{0}']), ('\u{1f0d}', ['\u{1f05}', '\u{0}', '\u{0}']),
+    ('\u{1f0e}', ['\u{1f06}', '\u{0}', '\u{0}']), ('\u{1f0f}', ['\u{1f07}', '\u{0}', '\u{0}']),
+    ('\u{1f18}', ['\u{1f10}', '\u{0}', '\u{0}']), ('\u{1f19}', ['\u{1f11}', '\u{0}', '\u{0}']),
+    ('\u{1f1a}', ['\u{1f12}', '\u{0}', '\u{0}']), ('\u{1f1b}', ['\u{1f13}', '\u{0}', '\u{0}']),
+    ('\u{1f1c}', ['\u{1f14}', '\u{0}', '\u{0}']), ('\u{1f1d}', ['\u{1f15}', '\u{0}', '\u{0}']),
+    ('\u{1f28}', ['\u{1f20}', '\u{0}', '\u{0}']), ('\u{1f29}', ['\u{1f21}', '\u{0}', '\u{0}']),
+    ('\u{1f2a}', ['\u{1f22}', '\u{0}', '\u{0}']), ('\u{1f2b}', ['\u{1f23}', '\u{0}', '\u{0}']),
+    ('\u{1f2c}', ['\u{1f24}', '\u{0}', '\u{0}']), ('\u{1f2d}', ['\u{1f25}', '\u{0}', '\u{0}']),
+    ('\u{1f2e}', ['\u{1f26}', '\u{0}', '\u{0}']), ('\u{1f2f}', ['\u{1f27}', '\u{0}', '\u{0}']),
+    ('\u{1f38}', ['\u{1f30}', '\u{0}', '\u{0}']), ('\u{1f39}', ['\u{1f31}', '\u{0}', '\u{0}']),
+    ('\u{1f3a}', ['\u{1f32}', '\u{0}', '\u{0}']), ('\u{1f3b}', ['\u{1f33}', '\u{0}', '\u{0}']),
+    ('\u{1f3c}', ['\u{1f34}', '\u{0}', '\u{0}']), ('\u{1f3d}', ['\u{1f35}', '\u{0}', '\u{0}']),
+    ('\u{1f3e}', ['\u{1f36}', '\u{0}', '\u{0}']), ('\u{1f3f}', ['\u{1f37}', '\u{0}', '\u{0}']),
+    ('\u{1f48}', ['\u{1f40}', '\u{0}', '\u{0}']), ('\u{1f49}', ['\u{1f41}', '\u{0}', '\u{0}']),
+    ('\u{1f4a}', ['\u{1f42}', '\u{0}', '\u{0}']), ('\u{1f4b}', ['\u{1f43}', '\u{0}', '\u{0}']),
+    ('\u{1f4c}', ['\u{1f44}', '\u{0}', '\u{0}']), ('\u{1f4d}', ['\u{1f45}', '\u{0}', '\u{0}']),
+    ('\u{1f59}', ['\u{1f51}', '\u{0}', '\u{0}']), ('\u{1f5b}', ['\u{1f53}', '\u{0}', '\u{0}']),
+    ('\u{1f5d}', ['\u{1f55}', '\u{0}', '\u{0}']), ('\u{1f5f}', ['\u{1f57}', '\u{0}', '\u{0}']),
+    ('\u{1f68}', ['\u{1f60}', '\u{0}', '\u{0}']), ('\u{1f69}', ['\u{1f61}', '\u{0}', '\u{0}']),
+    ('\u{1f6a}', ['\u{1f62}', '\u{0}', '\u{0}']), ('\u{1f6b}', ['\u{1f63}', '\u{0}', '\u{0}']),
+    ('\u{1f6c}', ['\u{1f64}', '\u{0}', '\u{0}']), ('\u{1f6d}', ['\u{1f65}', '\u{0}', '\u{0}']),
+    ('\u{1f6e}', ['\u{1f66}', '\u{0}', '\u{0}']), ('\u{1f6f}', ['\u{1f67}', '\u{0}', '\u{0}']),
+    ('\u{1f88}', ['\u{1f80}', '\u{0}', '\u{0}']), ('\u{1f89}', ['\u{1f81}', '\u{0}', '\u{0}']),
+    ('\u{1f8a}', ['\u{1f82}', '\u{0}', '\u{0}']), ('\u{1f8b}', ['\u{1f83}', '\u{0}', '\u{0}']),
+    ('\u{1f8c}', ['\u{1f84}', '\u{0}', '\u{0}']), ('\u{1f8d}', ['\u{1f85}', '\u{0}', '\u{0}']),
+    ('\u{1f8e}', ['\u{1f86}', '\u{0}', '\u{0}']), ('\u{1f8f}', ['\u{1f87}', '\u{0}', '\u{0}']),
+    ('\u{1f98}', ['\u{1f90}', '\u{0}', '\u{0}']), ('\u{1f99}', ['\u{1f91}', '\u{0}', '\u{0}']),
+    ('\u{1f9a}', ['\u{1f92}', '\u{0}', '\u{0}']), ('\u{1f9b}', ['\u{1f93}', '\u{0}', '\u{0}']),
+    ('\u{1f9c}', ['\u{1f94}', '\u{0}', '\u{0}']), ('\u{1f9d}', ['\u{1f95}', '\u{0}', '\u{0}']),
+    ('\u{1f9e}', ['\u{1f96}', '\u{0}', '\u{0}']), ('\u{1f9f}', ['\u{1f97}', '\u{0}', '\u{0}']),
+    ('\u{1fa8}', ['\u{1fa0}', '\u{0}', '\u{0}']), ('\u{1fa9}', ['\u{1fa1}', '\u{0}', '\u{0}']),
+    ('\u{1faa}', ['\u{1fa2}', '\u{0}', '\u{0}']), ('\u{1fab}', ['\u{1fa3}', '\u{0}', '\u{0}']),
+    ('\u{1fac}', ['\u{1fa4}', '\u{0}', '\u{0}']), ('\u{1fad}', ['\u{1fa5}', '\u{0}', '\u{0}']),
+    ('\u{1fae}', ['\u{1fa6}', '\u{0}', '\u{0}']), ('\u{1faf}', ['\u{1fa7}', '\u{0}', '\u{0}']),
+    ('\u{1fb8}', ['\u{1fb0}', '\u{0}', '\u{0}']), ('\u{1fb9}', ['\u{1fb1}', '\u{0}', '\u{0}']),
+    ('\u{1fba}', ['\u{1f70}', '\u{0}', '\u{0}']), ('\u{1fbb}', ['\u{1f71}', '\u{0}', '\u{0}']),
+    ('\u{1fbc}', ['\u{1fb3}', '\u{0}', '\u{0}']), ('\u{1fc8}', ['\u{1f72}', '\u{0}', '\u{0}']),
+    ('\u{1fc9}', ['\u{1f73}', '\u{0}', '\u{0}']), ('\u{1fca}', ['\u{1f74}', '\u{0}', '\u{0}']),
+    ('\u{1fcb}', ['\u{1f75}', '\u{0}', '\u{0}']), ('\u{1fcc}', ['\u{1fc3}', '\u{0}', '\u{0}']),
+    ('\u{1fd8}', ['\u{1fd0}', '\u{0}', '\u{0}']), ('\u{1fd9}', ['\u{1fd1}', '\u{0}', '\u{0}']),
+    ('\u{1fda}', ['\u{1f76}', '\u{0}', '\u{0}']), ('\u{1fdb}', ['\u{1f77}', '\u{0}', '\u{0}']),
+    ('\u{1fe8}', ['\u{1fe0}', '\u{0}', '\u{0}']), ('\u{1fe9}', ['\u{1fe1}', '\u{0}', '\u{0}']),
+    ('\u{1fea}', ['\u{1f7a}', '\u{0}', '\u{0}']), ('\u{1feb}', ['\u{1f7b}', '\u{0}', '\u{0}']),
+    ('\u{1fec}', ['\u{1fe5}', '\u{0}', '\u{0}']), ('\u{1ff8}', ['\u{1f78}', '\u{0}', '\u{0}']),
+    ('\u{1ff9}', ['\u{1f79}', '\u{0}', '\u{0}']), ('\u{1ffa}', ['\u{1f7c}', '\u{0}', '\u{0}']),
+    ('\u{1ffb}', ['\u{1f7d}', '\u{0}', '\u{0}']), ('\u{1ffc}', ['\u{1ff3}', '\u{0}', '\u{0}']),
+    ('\u{2126}', ['\u{3c9}', '\u{0}', '\u{0}']), ('\u{212a}', ['k', '\u{0}', '\u{0}']),
+    ('\u{212b}', ['\u{e5}', '\u{0}', '\u{0}']), ('\u{2132}', ['\u{214e}', '\u{0}', '\u{0}']),
+    ('\u{2160}', ['\u{2170}', '\u{0}', '\u{0}']), ('\u{2161}', ['\u{2171}', '\u{0}', '\u{0}']),
+    ('\u{2162}', ['\u{2172}', '\u{0}', '\u{0}']), ('\u{2163}', ['\u{2173}', '\u{0}', '\u{0}']),
+    ('\u{2164}', ['\u{2174}', '\u{0}', '\u{0}']), ('\u{2165}', ['\u{2175}', '\u{0}', '\u{0}']),
+    ('\u{2166}', ['\u{2176}', '\u{0}', '\u{0}']), ('\u{2167}', ['\u{2177}', '\u{0}', '\u{0}']),
+    ('\u{2168}', ['\u{2178}', '\u{0}', '\u{0}']), ('\u{2169}', ['\u{2179}', '\u{0}', '\u{0}']),
+    ('\u{216a}', ['\u{217a}', '\u{0}', '\u{0}']), ('\u{216b}', ['\u{217b}', '\u{0}', '\u{0}']),
+    ('\u{216c}', ['\u{217c}', '\u{0}', '\u{0}']), ('\u{216d}', ['\u{217d}', '\u{0}', '\u{0}']),
+    ('\u{216e}', ['\u{217e}', '\u{0}', '\u{0}']), ('\u{216f}', ['\u{217f}', '\u{0}', '\u{0}']),
+    ('\u{2183}', ['\u{2184}', '\u{0}', '\u{0}']), ('\u{24b6}', ['\u{24d0}', '\u{0}', '\u{0}']),
+    ('\u{24b7}', ['\u{24d1}', '\u{0}', '\u{0}']), ('\u{24b8}', ['\u{24d2}', '\u{0}', '\u{0}']),
+    ('\u{24b9}', ['\u{24d3}', '\u{0}', '\u{0}']), ('\u{24ba}', ['\u{24d4}', '\u{0}', '\u{0}']),
+    ('\u{24bb}', ['\u{24d5}', '\u{0}', '\u{0}']), ('\u{24bc}', ['\u{24d6}', '\u{0}', '\u{0}']),
+    ('\u{24bd}', ['\u{24d7}', '\u{0}', '\u{0}']), ('\u{24be}', ['\u{24d8}', '\u{0}', '\u{0}']),
+    ('\u{24bf}', ['\u{24d9}', '\u{0}', '\u{0}']), ('\u{24c0}', ['\u{24da}', '\u{0}', '\u{0}']),
+    ('\u{24c1}', ['\u{24db}', '\u{0}', '\u{0}']), ('\u{24c2}', ['\u{24dc}', '\u{0}', '\u{0}']),
+    ('\u{24c3}', ['\u{24dd}', '\u{0}', '\u{0}']), ('\u{24c4}', ['\u{24de}', '\u{0}', '\u{0}']),
+    ('\u{24c5}', ['\u{24df}', '\u{0}', '\u{0}']), ('\u{24c6}', ['\u{24e0}', '\u{0}', '\u{0}']),
+    ('\u{24c7}', ['\u{24e1}', '\u{0}', '\u{0}']), ('\u{24c8}', ['\u{24e2}', '\u{0}', '\u{0}']),
+    ('\u{24c9}', ['\u{24e3}', '\u{0}', '\u{0}']), ('\u{24ca}', ['\u{24e4}', '\u{0}', '\u{0}']),
+    ('\u{24cb}', ['\u{24e5}', '\u{0}', '\u{0}']), ('\u{24cc}', ['\u{24e6}', '\u{0}', '\u{0}']),
+    ('\u{24cd}', ['\u{24e7}', '\u{0}', '\u{0}']), ('\u{24ce}', ['\u{24e8}', '\u{0}', '\u{0}']),
+    ('\u{24cf}', ['\u{24e9}', '\u{0}', '\u{0}']), ('\u{2c00}', ['\u{2c30}', '\u{0}', '\u{0}']),
+    ('\u{2c01}', ['\u{2c31}', '\u{0}', '\u{0}']), ('\u{2c02}', ['\u{2c32}', '\u{0}', '\u{0}']),
+    ('\u{2c03}', ['\u{2c33}', '\u{0}', '\u{0}']), ('\u{2c04}', ['\u{2c34}', '\u{0}', '\u{0}']),
+    ('\u{2c05}', ['\u{2c35}', '\u{0}', '\u{0}']), ('\u{2c06}', ['\u{2c36}', '\u{0}', '\u{0}']),
+    ('\u{2c07}', ['\u{2c37}', '\u{0}', '\u{0}']), ('\u{2c08}', ['\u{2c38}', '\u{0}', '\u{0}']),
+    ('\u{2c09}', ['\u{2c39}', '\u{0}', '\u{0}']), ('\u{2c0a}', ['\u{2c3a}', '\u{0}', '\u{0}']),
+    ('\u{2c0b}', ['\u{2c3b}', '\u{0}', '\u{0}']), ('\u{2c0c}', ['\u{2c3c}', '\u{0}', '\u{0}']),
+    ('\u{2c0d}', ['\u{2c3d}', '\u{0}', '\u{0}']), ('\u{2c0e}', ['\u{2c3e}', '\u{0}', '\u{0}']),
+    ('\u{2c0f}', ['\u{2c3f}', '\u{0}', '\u{0}']), ('\u{2c10}', ['\u{2c40}', '\u{0}', '\u{0}']),
+    ('\u{2c11}', ['\u{2c41}', '\u{0}', '\u{0}']), ('\u{2c12}', ['\u{2c42}', '\u{0}', '\u{0}']),
+    ('\u{2c13}', ['\u{2c43}', '\u{0}', '\u{0}']), ('\u{2c14}', ['\u{2c44}', '\u{0}', '\u{0}']),
+    ('\u{2c15}', ['\u{2c45}', '\u{0}', '\u{0}']), ('\u{2c16}', ['\u{2c46}', '\u{0}', '\u{0}']),
+    ('\u{2c17}', ['\u{2c47}', '\u{0}', '\u{0}']), ('\u{2c18}', ['\u{2c48}', '\u{0}', '\u{0}']),
+    ('\u{2c19}', ['\u{2c49}', '\u{0}', '\u{0}']), ('\u{2c1a}', ['\u{2c4a}', '\u{0}', '\u{0}']),
+    ('\u{2c1b}', ['\u{2c4b}', '\u{0}', '\u{0}']), ('\u{2c1c}', ['\u{2c4c}', '\u{0}', '\u{0}']),
+    ('\u{2c1d}', ['\u{2c4d}', '\u{0}', '\u{0}']), ('\u{2c1e}', ['\u{2c4e}', '\u{0}', '\u{0}']),
+    ('\u{2c1f}', ['\u{2c4f}', '\u{0}', '\u{0}']), ('\u{2c20}', ['\u{2c50}', '\u{0}', '\u{0}']),
+    ('\u{2c21}', ['\u{2c51}', '\u{0}', '\u{0}']), ('\u{2c22}', ['\u{2c52}', '\u{0}', '\u{0}']),
+    ('\u{2c23}', ['\u{2c53}', '\u{0}', '\u{0}']), ('\u{2c24}', ['\u{2c54}', '\u{0}', '\u{0}']),
+    ('\u{2c25}', ['\u{2c55}', '\u{0}', '\u{0}']), ('\u{2c26}', ['\u{2c56}', '\u{0}', '\u{0}']),
+    ('\u{2c27}', ['\u{2c57}', '\u{0}', '\u{0}']), ('\u{2c28}', ['\u{2c58}', '\u{0}', '\u{0}']),
+    ('\u{2c29}', ['\u{2c59}', '\u{0}', '\u{0}']), ('\u{2c2a}', ['\u{2c5a}', '\u{0}', '\u{0}']),
+    ('\u{2c2b}', ['\u{2c5b}', '\u{0}', '\u{0}']), ('\u{2c2c}', ['\u{2c5c}', '\u{0}', '\u{0}']),
+    ('\u{2c2d}', ['\u{2c5d}', '\u{0}', '\u{0}']), ('\u{2c2e}', ['\u{2c5e}', '\u{0}', '\u{0}']),
+    ('\u{2c2f}', ['\u{2c5f}', '\u{0}', '\u{0}']), ('\u{2c60}', ['\u{2c61}', '\u{0}', '\u{0}']),
+    ('\u{2c62}', ['\u{26b}', '\u{0}', '\u{0}']), ('\u{2c63}', ['\u{1d7d}', '\u{0}', '\u{0}']),
+    ('\u{2c64}', ['\u{27d}', '\u{0}', '\u{0}']), ('\u{2c67}', ['\u{2c68}', '\u{0}', '\u{0}']),
+    ('\u{2c69}', ['\u{2c6a}', '\u{0}', '\u{0}']), ('\u{2c6b}', ['\u{2c6c}', '\u{0}', '\u{0}']),
+    ('\u{2c6d}', ['\u{251}', '\u{0}', '\u{0}']), ('\u{2c6e}', ['\u{271}', '\u{0}', '\u{0}']),
+    ('\u{2c6f}', ['\u{250}', '\u{0}', '\u{0}']), ('\u{2c70}', ['\u{252}', '\u{0}', '\u{0}']),
+    ('\u{2c72}', ['\u{2c73}', '\u{0}', '\u{0}']), ('\u{2c75}', ['\u{2c76}', '\u{0}', '\u{0}']),
+    ('\u{2c7e}', ['\u{23f}', '\u{0}', '\u{0}']), ('\u{2c7f}', ['\u{240}', '\u{0}', '\u{0}']),
+    ('\u{2c80}', ['\u{2c81}', '\u{0}', '\u{0}']), ('\u{2c82}', ['\u{2c83}', '\u{0}', '\u{0}']),
+    ('\u{2c84}', ['\u{2c85}', '\u{0}', '\u{0}']), ('\u{2c86}', ['\u{2c87}', '\u{0}', '\u{0}']),
+    ('\u{2c88}', ['\u{2c89}', '\u{0}', '\u{0}']), ('\u{2c8a}', ['\u{2c8b}', '\u{0}', '\u{0}']),
+    ('\u{2c8c}', ['\u{2c8d}', '\u{0}', '\u{0}']), ('\u{2c8e}', ['\u{2c8f}', '\u{0}', '\u{0}']),
+    ('\u{2c90}', ['\u{2c91}', '\u{0}', '\u{0}']), ('\u{2c92}', ['\u{2c93}', '\u{0}', '\u{0}']),
+    ('\u{2c94}', ['\u{2c95}', '\u{0}', '\u{0}']), ('\u{2c96}', ['\u{2c97}', '\u{0}', '\u{0}']),
+    ('\u{2c98}', ['\u{2c99}', '\u{0}', '\u{0}']), ('\u{2c9a}', ['\u{2c9b}', '\u{0}', '\u{0}']),
+    ('\u{2c9c}', ['\u{2c9d}', '\u{0}', '\u{0}']), ('\u{2c9e}', ['\u{2c9f}', '\u{0}', '\u{0}']),
+    ('\u{2ca0}', ['\u{2ca1}', '\u{0}', '\u{0}']), ('\u{2ca2}', ['\u{2ca3}', '\u{0}', '\u{0}']),
+    ('\u{2ca4}', ['\u{2ca5}', '\u{0}', '\u{0}']), ('\u{2ca6}', ['\u{2ca7}', '\u{0}', '\u{0}']),
+    ('\u{2ca8}', ['\u{2ca9}', '\u{0}', '\u{0}']), ('\u{2caa}', ['\u{2cab}', '\u{0}', '\u{0}']),
+    ('\u{2cac}', ['\u{2cad}', '\u{0}', '\u{0}']), ('\u{2cae}', ['\u{2caf}', '\u{0}', '\u{0}']),
+    ('\u{2cb0}', ['\u{2cb1}', '\u{0}', '\u{0}']), ('\u{2cb2}', ['\u{2cb3}', '\u{0}', '\u{0}']),
+    ('\u{2cb4}', ['\u{2cb5}', '\u{0}', '\u{0}']), ('\u{2cb6}', ['\u{2cb7}', '\u{0}', '\u{0}']),
+    ('\u{2cb8}', ['\u{2cb9}', '\u{0}', '\u{0}']), ('\u{2cba}', ['\u{2cbb}', '\u{0}', '\u{0}']),
+    ('\u{2cbc}', ['\u{2cbd}', '\u{0}', '\u{0}']), ('\u{2cbe}', ['\u{2cbf}', '\u{0}', '\u{0}']),
+    ('\u{2cc0}', ['\u{2cc1}', '\u{0}', '\u{0}']), ('\u{2cc2}', ['\u{2cc3}', '\u{0}', '\u{0}']),
+    ('\u{2cc4}', ['\u{2cc5}', '\u{0}', '\u{0}']), ('\u{2cc6}', ['\u{2cc7}', '\u{0}', '\u{0}']),
+    ('\u{2cc8}', ['\u{2cc9}', '\u{0}', '\u{0}']), ('\u{2cca}', ['\u{2ccb}', '\u{0}', '\u{0}']),
+    ('\u{2ccc}', ['\u{2ccd}', '\u{0}', '\u{0}']), ('\u{2cce}', ['\u{2ccf}', '\u{0}', '\u{0}']),
+    ('\u{2cd0}', ['\u{2cd1}', '\u{0}', '\u{0}']), ('\u{2cd2}', ['\u{2cd3}', '\u{0}', '\u{0}']),
+    ('\u{2cd4}', ['\u{2cd5}', '\u{0}', '\u{0}']), ('\u{2cd6}', ['\u{2cd7}', '\u{0}', '\u{0}']),
+    ('\u{2cd8}', ['\u{2cd9}', '\u{0}', '\u{0}']), ('\u{2cda}', ['\u{2cdb}', '\u{0}', '\u{0}']),
+    ('\u{2cdc}', ['\u{2cdd}', '\u{0}', '\u{0}']), ('\u{2cde}', ['\u{2cdf}', '\u{0}', '\u{0}']),
+    ('\u{2ce0}', ['\u{2ce1}', '\u{0}', '\u{0}']), ('\u{2ce2}', ['\u{2ce3}', '\u{0}', '\u{0}']),
+    ('\u{2ceb}', ['\u{2cec}', '\u{0}', '\u{0}']), ('\u{2ced}', ['\u{2cee}', '\u{0}', '\u{0}']),
+    ('\u{2cf2}', ['\u{2cf3}', '\u{0}', '\u{0}']), ('\u{a640}', ['\u{a641}', '\u{0}', '\u{0}']),
+    ('\u{a642}', ['\u{a643}', '\u{0}', '\u{0}']), ('\u{a644}', ['\u{a645}', '\u{0}', '\u{0}']),
+    ('\u{a646}', ['\u{a647}', '\u{0}', '\u{0}']), ('\u{a648}', ['\u{a649}', '\u{0}', '\u{0}']),
+    ('\u{a64a}', ['\u{a64b}', '\u{0}', '\u{0}']), ('\u{a64c}', ['\u{a64d}', '\u{0}', '\u{0}']),
+    ('\u{a64e}', ['\u{a64f}', '\u{0}', '\u{0}']), ('\u{a650}', ['\u{a651}', '\u{0}', '\u{0}']),
+    ('\u{a652}', ['\u{a653}', '\u{0}', '\u{0}']), ('\u{a654}', ['\u{a655}', '\u{0}', '\u{0}']),
+    ('\u{a656}', ['\u{a657}', '\u{0}', '\u{0}']), ('\u{a658}', ['\u{a659}', '\u{0}', '\u{0}']),
+    ('\u{a65a}', ['\u{a65b}', '\u{0}', '\u{0}']), ('\u{a65c}', ['\u{a65d}', '\u{0}', '\u{0}']),
+    ('\u{a65e}', ['\u{a65f}', '\u{0}', '\u{0}']), ('\u{a660}', ['\u{a661}', '\u{0}', '\u{0}']),
+    ('\u{a662}', ['\u{a663}', '\u{0}', '\u{0}']), ('\u{a664}', ['\u{a665}', '\u{0}', '\u{0}']),
+    ('\u{a666}', ['\u{a667}', '\u{0}', '\u{0}']), ('\u{a668}', ['\u{a669}', '\u{0}', '\u{0}']),
+    ('\u{a66a}', ['\u{a66b}', '\u{0}', '\u{0}']), ('\u{a66c}', ['\u{a66d}', '\u{0}', '\u{0}']),
+    ('\u{a680}', ['\u{a681}', '\u{0}', '\u{0}']), ('\u{a682}', ['\u{a683}', '\u{0}', '\u{0}']),
+    ('\u{a684}', ['\u{a685}', '\u{0}', '\u{0}']), ('\u{a686}', ['\u{a687}', '\u{0}', '\u{0}']),
+    ('\u{a688}', ['\u{a689}', '\u{0}', '\u{0}']), ('\u{a68a}', ['\u{a68b}', '\u{0}', '\u{0}']),
+    ('\u{a68c}', ['\u{a68d}', '\u{0}', '\u{0}']), ('\u{a68e}', ['\u{a68f}', '\u{0}', '\u{0}']),
+    ('\u{a690}', ['\u{a691}', '\u{0}', '\u{0}']), ('\u{a692}', ['\u{a693}', '\u{0}', '\u{0}']),
+    ('\u{a694}', ['\u{a695}', '\u{0}', '\u{0}']), ('\u{a696}', ['\u{a697}', '\u{0}', '\u{0}']),
+    ('\u{a698}', ['\u{a699}', '\u{0}', '\u{0}']), ('\u{a69a}', ['\u{a69b}', '\u{0}', '\u{0}']),
+    ('\u{a722}', ['\u{a723}', '\u{0}', '\u{0}']), ('\u{a724}', ['\u{a725}', '\u{0}', '\u{0}']),
+    ('\u{a726}', ['\u{a727}', '\u{0}', '\u{0}']), ('\u{a728}', ['\u{a729}', '\u{0}', '\u{0}']),
+    ('\u{a72a}', ['\u{a72b}', '\u{0}', '\u{0}']), ('\u{a72c}', ['\u{a72d}', '\u{0}', '\u{0}']),
+    ('\u{a72e}', ['\u{a72f}', '\u{0}', '\u{0}']), ('\u{a732}', ['\u{a733}', '\u{0}', '\u{0}']),
+    ('\u{a734}', ['\u{a735}', '\u{0}', '\u{0}']), ('\u{a736}', ['\u{a737}', '\u{0}', '\u{0}']),
+    ('\u{a738}', ['\u{a739}', '\u{0}', '\u{0}']), ('\u{a73a}', ['\u{a73b}', '\u{0}', '\u{0}']),
+    ('\u{a73c}', ['\u{a73d}', '\u{0}', '\u{0}']), ('\u{a73e}', ['\u{a73f}', '\u{0}', '\u{0}']),
+    ('\u{a740}', ['\u{a741}', '\u{0}', '\u{0}']), ('\u{a742}', ['\u{a743}', '\u{0}', '\u{0}']),
+    ('\u{a744}', ['\u{a745}', '\u{0}', '\u{0}']), ('\u{a746}', ['\u{a747}', '\u{0}', '\u{0}']),
+    ('\u{a748}', ['\u{a749}', '\u{0}', '\u{0}']), ('\u{a74a}', ['\u{a74b}', '\u{0}', '\u{0}']),
+    ('\u{a74c}', ['\u{a74d}', '\u{0}', '\u{0}']), ('\u{a74e}', ['\u{a74f}', '\u{0}', '\u{0}']),
+    ('\u{a750}', ['\u{a751}', '\u{0}', '\u{0}']), ('\u{a752}', ['\u{a753}', '\u{0}', '\u{0}']),
+    ('\u{a754}', ['\u{a755}', '\u{0}', '\u{0}']), ('\u{a756}', ['\u{a757}', '\u{0}', '\u{0}']),
+    ('\u{a758}', ['\u{a759}', '\u{0}', '\u{0}']), ('\u{a75a}', ['\u{a75b}', '\u{0}', '\u{0}']),
+    ('\u{a75c}', ['\u{a75d}', '\u{0}', '\u{0}']), ('\u{a75e}', ['\u{a75f}', '\u{0}', '\u{0}']),
+    ('\u{a760}', ['\u{a761}', '\u{0}', '\u{0}']), ('\u{a762}', ['\u{a763}', '\u{0}', '\u{0}']),
+    ('\u{a764}', ['\u{a765}', '\u{0}', '\u{0}']), ('\u{a766}', ['\u{a767}', '\u{0}', '\u{0}']),
+    ('\u{a768}', ['\u{a769}', '\u{0}', '\u{0}']), ('\u{a76a}', ['\u{a76b}', '\u{0}', '\u{0}']),
+    ('\u{a76c}', ['\u{a76d}', '\u{0}', '\u{0}']), ('\u{a76e}', ['\u{a76f}', '\u{0}', '\u{0}']),
+    ('\u{a779}', ['\u{a77a}', '\u{0}', '\u{0}']), ('\u{a77b}', ['\u{a77c}', '\u{0}', '\u{0}']),
+    ('\u{a77d}', ['\u{1d79}', '\u{0}', '\u{0}']), ('\u{a77e}', ['\u{a77f}', '\u{0}', '\u{0}']),
+    ('\u{a780}', ['\u{a781}', '\u{0}', '\u{0}']), ('\u{a782}', ['\u{a783}', '\u{0}', '\u{0}']),
+    ('\u{a784}', ['\u{a785}', '\u{0}', '\u{0}']), ('\u{a786}', ['\u{a787}', '\u{0}', '\u{0}']),
+    ('\u{a78b}', ['\u{a78c}', '\u{0}', '\u{0}']), ('\u{a78d}', ['\u{265}', '\u{0}', '\u{0}']),
+    ('\u{a790}', ['\u{a791}', '\u{0}', '\u{0}']), ('\u{a792}', ['\u{a793}', '\u{0}', '\u{0}']),
+    ('\u{a796}', ['\u{a797}', '\u{0}', '\u{0}']), ('\u{a798}', ['\u{a799}', '\u{0}', '\u{0}']),
+    ('\u{a79a}', ['\u{a79b}', '\u{0}', '\u{0}']), ('\u{a79c}', ['\u{a79d}', '\u{0}', '\u{0}']),
+    ('\u{a79e}', ['\u{a79f}', '\u{0}', '\u{0}']), ('\u{a7a0}', ['\u{a7a1}', '\u{0}', '\u{0}']),
+    ('\u{a7a2}', ['\u{a7a3}', '\u{0}', '\u{0}']), ('\u{a7a4}', ['\u{a7a5}', '\u{0}', '\u{0}']),
+    ('\u{a7a6}', ['\u{a7a7}', '\u{0}', '\u{0}']), ('\u{a7a8}', ['\u{a7a9}', '\u{0}', '\u{0}']),
+    ('\u{a7aa}', ['\u{266}', '\u{0}', '\u{0}']), ('\u{a7ab}', ['\u{25c}', '\u{0}', '\u{0}']),
+    ('\u{a7ac}', ['\u{261}', '\u{0}', '\u{0}']), ('\u{a7ad}', ['\u{26c}', '\u{0}', '\u{0}']),
+    ('\u{a7ae}', ['\u{26a}', '\u{0}', '\u{0}']), ('\u{a7b0}', ['\u{29e}', '\u{0}', '\u{0}']),
+    ('\u{a7b1}', ['\u{287}', '\u{0}', '\u{0}']), ('\u{a7b2}', ['\u{29d}', '\u{0}', '\u{0}']),
+    ('\u{a7b3}', ['\u{ab53}', '\u{0}', '\u{0}']), ('\u{a7b4}', ['\u{a7b5}', '\u{0}', '\u{0}']),
+    ('\u{a7b6}', ['\u{a7b7}', '\u{0}', '\u{0}']), ('\u{a7b8}', ['\u{a7b9}', '\u{0}', '\u{0}']),
+    ('\u{a7ba}', ['\u{a7bb}', '\u{0}', '\u{0}']), ('\u{a7bc}', ['\u{a7bd}', '\u{0}', '\u{0}']),
+    ('\u{a7be}', ['\u{a7bf}', '\u{0}', '\u{0}']), ('\u{a7c0}', ['\u{a7c1}', '\u{0}', '\u{0}']),
+    ('\u{a7c2}', ['\u{a7c3}', '\u{0}', '\u{0}']), ('\u{a7c4}', ['\u{a794}', '\u{0}', '\u{0}']),
+    ('\u{a7c5}', ['\u{282}', '\u{0}', '\u{0}']), ('\u{a7c6}', ['\u{1d8e}', '\u{0}', '\u{0}']),
+    ('\u{a7c7}', ['\u{a7c8}', '\u{0}', '\u{0}']), ('\u{a7c9}', ['\u{a7ca}', '\u{0}', '\u{0}']),
+    ('\u{a7cb}', ['\u{264}', '\u{0}', '\u{0}']), ('\u{a7cc}', ['\u{a7cd}', '\u{0}', '\u{0}']),
+    ('\u{a7ce}', ['\u{a7cf}', '\u{0}', '\u{0}']), ('\u{a7d0}', ['\u{a7d1}', '\u{0}', '\u{0}']),
+    ('\u{a7d2}', ['\u{a7d3}', '\u{0}', '\u{0}']), ('\u{a7d4}', ['\u{a7d5}', '\u{0}', '\u{0}']),
+    ('\u{a7d6}', ['\u{a7d7}', '\u{0}', '\u{0}']), ('\u{a7d8}', ['\u{a7d9}', '\u{0}', '\u{0}']),
+    ('\u{a7da}', ['\u{a7db}', '\u{0}', '\u{0}']), ('\u{a7dc}', ['\u{19b}', '\u{0}', '\u{0}']),
+    ('\u{a7f5}', ['\u{a7f6}', '\u{0}', '\u{0}']), ('\u{ff21}', ['\u{ff41}', '\u{0}', '\u{0}']),
+    ('\u{ff22}', ['\u{ff42}', '\u{0}', '\u{0}']), ('\u{ff23}', ['\u{ff43}', '\u{0}', '\u{0}']),
+    ('\u{ff24}', ['\u{ff44}', '\u{0}', '\u{0}']), ('\u{ff25}', ['\u{ff45}', '\u{0}', '\u{0}']),
+    ('\u{ff26}', ['\u{ff46}', '\u{0}', '\u{0}']), ('\u{ff27}', ['\u{ff47}', '\u{0}', '\u{0}']),
+    ('\u{ff28}', ['\u{ff48}', '\u{0}', '\u{0}']), ('\u{ff29}', ['\u{ff49}', '\u{0}', '\u{0}']),
+    ('\u{ff2a}', ['\u{ff4a}', '\u{0}', '\u{0}']), ('\u{ff2b}', ['\u{ff4b}', '\u{0}', '\u{0}']),
+    ('\u{ff2c}', ['\u{ff4c}', '\u{0}', '\u{0}']), ('\u{ff2d}', ['\u{ff4d}', '\u{0}', '\u{0}']),
+    ('\u{ff2e}', ['\u{ff4e}', '\u{0}', '\u{0}']), ('\u{ff2f}', ['\u{ff4f}', '\u{0}', '\u{0}']),
+    ('\u{ff30}', ['\u{ff50}', '\u{0}', '\u{0}']), ('\u{ff31}', ['\u{ff51}', '\u{0}', '\u{0}']),
+    ('\u{ff32}', ['\u{ff52}', '\u{0}', '\u{0}']), ('\u{ff33}', ['\u{ff53}', '\u{0}', '\u{0}']),
+    ('\u{ff34}', ['\u{ff54}', '\u{0}', '\u{0}']), ('\u{ff35}', ['\u{ff55}', '\u{0}', '\u{0}']),
+    ('\u{ff36}', ['\u{ff56}', '\u{0}', '\u{0}']), ('\u{ff37}', ['\u{ff57}', '\u{0}', '\u{0}']),
+    ('\u{ff38}', ['\u{ff58}', '\u{0}', '\u{0}']), ('\u{ff39}', ['\u{ff59}', '\u{0}', '\u{0}']),
+    ('\u{ff3a}', ['\u{ff5a}', '\u{0}', '\u{0}']),
+    ('\u{10400}', ['\u{10428}', '\u{0}', '\u{0}']),
+    ('\u{10401}', ['\u{10429}', '\u{0}', '\u{0}']),
+    ('\u{10402}', ['\u{1042a}', '\u{0}', '\u{0}']),
+    ('\u{10403}', ['\u{1042b}', '\u{0}', '\u{0}']),
+    ('\u{10404}', ['\u{1042c}', '\u{0}', '\u{0}']),
+    ('\u{10405}', ['\u{1042d}', '\u{0}', '\u{0}']),
+    ('\u{10406}', ['\u{1042e}', '\u{0}', '\u{0}']),
+    ('\u{10407}', ['\u{1042f}', '\u{0}', '\u{0}']),
+    ('\u{10408}', ['\u{10430}', '\u{0}', '\u{0}']),
+    ('\u{10409}', ['\u{10431}', '\u{0}', '\u{0}']),
+    ('\u{1040a}', ['\u{10432}', '\u{0}', '\u{0}']),
+    ('\u{1040b}', ['\u{10433}', '\u{0}', '\u{0}']),
+    ('\u{1040c}', ['\u{10434}', '\u{0}', '\u{0}']),
+    ('\u{1040d}', ['\u{10435}', '\u{0}', '\u{0}']),
+    ('\u{1040e}', ['\u{10436}', '\u{0}', '\u{0}']),
+    ('\u{1040f}', ['\u{10437}', '\u{0}', '\u{0}']),
+    ('\u{10410}', ['\u{10438}', '\u{0}', '\u{0}']),
+    ('\u{10411}', ['\u{10439}', '\u{0}', '\u{0}']),
+    ('\u{10412}', ['\u{1043a}', '\u{0}', '\u{0}']),
+    ('\u{10413}', ['\u{1043b}', '\u{0}', '\u{0}']),
+    ('\u{10414}', ['\u{1043c}', '\u{0}', '\u{0}']),
+    ('\u{10415}', ['\u{1043d}', '\u{0}', '\u{0}']),
+    ('\u{10416}', ['\u{1043e}', '\u{0}', '\u{0}']),
+    ('\u{10417}', ['\u{1043f}', '\u{0}', '\u{0}']),
+    ('\u{10418}', ['\u{10440}', '\u{0}', '\u{0}']),
+    ('\u{10419}', ['\u{10441}', '\u{0}', '\u{0}']),
+    ('\u{1041a}', ['\u{10442}', '\u{0}', '\u{0}']),
+    ('\u{1041b}', ['\u{10443}', '\u{0}', '\u{0}']),
+    ('\u{1041c}', ['\u{10444}', '\u{0}', '\u{0}']),
+    ('\u{1041d}', ['\u{10445}', '\u{0}', '\u{0}']),
+    ('\u{1041e}', ['\u{10446}', '\u{0}', '\u{0}']),
+    ('\u{1041f}', ['\u{10447}', '\u{0}', '\u{0}']),
+    ('\u{10420}', ['\u{10448}', '\u{0}', '\u{0}']),
+    ('\u{10421}', ['\u{10449}', '\u{0}', '\u{0}']),
+    ('\u{10422}', ['\u{1044a}', '\u{0}', '\u{0}']),
+    ('\u{10423}', ['\u{1044b}', '\u{0}', '\u{0}']),
+    ('\u{10424}', ['\u{1044c}', '\u{0}', '\u{0}']),
+    ('\u{10425}', ['\u{1044d}', '\u{0}', '\u{0}']),
+    ('\u{10426}', ['\u{1044e}', '\u{0}', '\u{0}']),
+    ('\u{10427}', ['\u{1044f}', '\u{0}', '\u{0}']),
+    ('\u{104b0}', ['\u{104d8}', '\u{0}', '\u{0}']),
+    ('\u{104b1}', ['\u{104d9}', '\u{0}', '\u{0}']),
+    ('\u{104b2}', ['\u{104da}', '\u{0}', '\u{0}']),
+    ('\u{104b3}', ['\u{104db}', '\u{0}', '\u{0}']),
+    ('\u{104b4}', ['\u{104dc}', '\u{0}', '\u{0}']),
+    ('\u{104b5}', ['\u{104dd}', '\u{0}', '\u{0}']),
+    ('\u{104b6}', ['\u{104de}', '\u{0}', '\u{0}']),
+    ('\u{104b7}', ['\u{104df}', '\u{0}', '\u{0}']),
+    ('\u{104b8}', ['\u{104e0}', '\u{0}', '\u{0}']),
+    ('\u{104b9}', ['\u{104e1}', '\u{0}', '\u{0}']),
+    ('\u{104ba}', ['\u{104e2}', '\u{0}', '\u{0}']),
+    ('\u{104bb}', ['\u{104e3}', '\u{0}', '\u{0}']),
+    ('\u{104bc}', ['\u{104e4}', '\u{0}', '\u{0}']),
+    ('\u{104bd}', ['\u{104e5}', '\u{0}', '\u{0}']),
+    ('\u{104be}', ['\u{104e6}', '\u{0}', '\u{0}']),
+    ('\u{104bf}', ['\u{104e7}', '\u{0}', '\u{0}']),
+    ('\u{104c0}', ['\u{104e8}', '\u{0}', '\u{0}']),
+    ('\u{104c1}', ['\u{104e9}', '\u{0}', '\u{0}']),
+    ('\u{104c2}', ['\u{104ea}', '\u{0}', '\u{0}']),
+    ('\u{104c3}', ['\u{104eb}', '\u{0}', '\u{0}']),
+    ('\u{104c4}', ['\u{104ec}', '\u{0}', '\u{0}']),
+    ('\u{104c5}', ['\u{104ed}', '\u{0}', '\u{0}']),
+    ('\u{104c6}', ['\u{104ee}', '\u{0}', '\u{0}']),
+    ('\u{104c7}', ['\u{104ef}', '\u{0}', '\u{0}']),
+    ('\u{104c8}', ['\u{104f0}', '\u{0}', '\u{0}']),
+    ('\u{104c9}', ['\u{104f1}', '\u{0}', '\u{0}']),
+    ('\u{104ca}', ['\u{104f2}', '\u{0}', '\u{0}']),
+    ('\u{104cb}', ['\u{104f3}', '\u{0}', '\u{0}']),
+    ('\u{104cc}', ['\u{104f4}', '\u{0}', '\u{0}']),
+    ('\u{104cd}', ['\u{104f5}', '\u{0}', '\u{0}']),
+    ('\u{104ce}', ['\u{104f6}', '\u{0}', '\u{0}']),
+    ('\u{104cf}', ['\u{104f7}', '\u{0}', '\u{0}']),
+    ('\u{104d0}', ['\u{104f8}', '\u{0}', '\u{0}']),
+    ('\u{104d1}', ['\u{104f9}', '\u{0}', '\u{0}']),
+    ('\u{104d2}', ['\u{104fa}', '\u{0}', '\u{0}']),
+    ('\u{104d3}', ['\u{104fb}', '\u{0}', '\u{0}']),
+    ('\u{10570}', ['\u{10597}', '\u{0}', '\u{0}']),
+    ('\u{10571}', ['\u{10598}', '\u{0}', '\u{0}']),
+    ('\u{10572}', ['\u{10599}', '\u{0}', '\u{0}']),
+    ('\u{10573}', ['\u{1059a}', '\u{0}', '\u{0}']),
+    ('\u{10574}', ['\u{1059b}', '\u{0}', '\u{0}']),
+    ('\u{10575}', ['\u{1059c}', '\u{0}', '\u{0}']),
+    ('\u{10576}', ['\u{1059d}', '\u{0}', '\u{0}']),
+    ('\u{10577}', ['\u{1059e}', '\u{0}', '\u{0}']),
+    ('\u{10578}', ['\u{1059f}', '\u{0}', '\u{0}']),
+    ('\u{10579}', ['\u{105a0}', '\u{0}', '\u{0}']),
+    ('\u{1057a}', ['\u{105a1}', '\u{0}', '\u{0}']),
+    ('\u{1057c}', ['\u{105a3}', '\u{0}', '\u{0}']),
+    ('\u{1057d}', ['\u{105a4}', '\u{0}', '\u{0}']),
+    ('\u{1057e}', ['\u{105a5}', '\u{0}', '\u{0}']),
+    ('\u{1057f}', ['\u{105a6}', '\u{0}', '\u{0}']),
+    ('\u{10580}', ['\u{105a7}', '\u{0}', '\u{0}']),
+    ('\u{10581}', ['\u{105a8}', '\u{0}', '\u{0}']),
+    ('\u{10582}', ['\u{105a9}', '\u{0}', '\u{0}']),
+    ('\u{10583}', ['\u{105aa}', '\u{0}', '\u{0}']),
+    ('\u{10584}', ['\u{105ab}', '\u{0}', '\u{0}']),
+    ('\u{10585}', ['\u{105ac}', '\u{0}', '\u{0}']),
+    ('\u{10586}', ['\u{105ad}', '\u{0}', '\u{0}']),
+    ('\u{10587}', ['\u{105ae}', '\u{0}', '\u{0}']),
+    ('\u{10588}', ['\u{105af}', '\u{0}', '\u{0}']),
+    ('\u{10589}', ['\u{105b0}', '\u{0}', '\u{0}']),
+    ('\u{1058a}', ['\u{105b1}', '\u{0}', '\u{0}']),
+    ('\u{1058c}', ['\u{105b3}', '\u{0}', '\u{0}']),
+    ('\u{1058d}', ['\u{105b4}', '\u{0}', '\u{0}']),
+    ('\u{1058e}', ['\u{105b5}', '\u{0}', '\u{0}']),
+    ('\u{1058f}', ['\u{105b6}', '\u{0}', '\u{0}']),
+    ('\u{10590}', ['\u{105b7}', '\u{0}', '\u{0}']),
+    ('\u{10591}', ['\u{105b8}', '\u{0}', '\u{0}']),
+    ('\u{10592}', ['\u{105b9}', '\u{0}', '\u{0}']),
+    ('\u{10594}', ['\u{105bb}', '\u{0}', '\u{0}']),
+    ('\u{10595}', ['\u{105bc}', '\u{0}', '\u{0}']),
+    ('\u{10c80}', ['\u{10cc0}', '\u{0}', '\u{0}']),
+    ('\u{10c81}', ['\u{10cc1}', '\u{0}', '\u{0}']),
+    ('\u{10c82}', ['\u{10cc2}', '\u{0}', '\u{0}']),
+    ('\u{10c83}', ['\u{10cc3}', '\u{0}', '\u{0}']),
+    ('\u{10c84}', ['\u{10cc4}', '\u{0}', '\u{0}']),
+    ('\u{10c85}', ['\u{10cc5}', '\u{0}', '\u{0}']),
+    ('\u{10c86}', ['\u{10cc6}', '\u{0}', '\u{0}']),
+    ('\u{10c87}', ['\u{10cc7}', '\u{0}', '\u{0}']),
+    ('\u{10c88}', ['\u{10cc8}', '\u{0}', '\u{0}']),
+    ('\u{10c89}', ['\u{10cc9}', '\u{0}', '\u{0}']),
+    ('\u{10c8a}', ['\u{10cca}', '\u{0}', '\u{0}']),
+    ('\u{10c8b}', ['\u{10ccb}', '\u{0}', '\u{0}']),
+    ('\u{10c8c}', ['\u{10ccc}', '\u{0}', '\u{0}']),
+    ('\u{10c8d}', ['\u{10ccd}', '\u{0}', '\u{0}']),
+    ('\u{10c8e}', ['\u{10cce}', '\u{0}', '\u{0}']),
+    ('\u{10c8f}', ['\u{10ccf}', '\u{0}', '\u{0}']),
+    ('\u{10c90}', ['\u{10cd0}', '\u{0}', '\u{0}']),
+    ('\u{10c91}', ['\u{10cd1}', '\u{0}', '\u{0}']),
+    ('\u{10c92}', ['\u{10cd2}', '\u{0}', '\u{0}']),
+    ('\u{10c93}', ['\u{10cd3}', '\u{0}', '\u{0}']),
+    ('\u{10c94}', ['\u{10cd4}', '\u{0}', '\u{0}']),
+    ('\u{10c95}', ['\u{10cd5}', '\u{0}', '\u{0}']),
+    ('\u{10c96}', ['\u{10cd6}', '\u{0}', '\u{0}']),
+    ('\u{10c97}', ['\u{10cd7}', '\u{0}', '\u{0}']),
+    ('\u{10c98}', ['\u{10cd8}', '\u{0}', '\u{0}']),
+    ('\u{10c99}', ['\u{10cd9}', '\u{0}', '\u{0}']),
+    ('\u{10c9a}', ['\u{10cda}', '\u{0}', '\u{0}']),
+    ('\u{10c9b}', ['\u{10cdb}', '\u{0}', '\u{0}']),
+    ('\u{10c9c}', ['\u{10cdc}', '\u{0}', '\u{0}']),
+    ('\u{10c9d}', ['\u{10cdd}', '\u{0}', '\u{0}']),
+    ('\u{10c9e}', ['\u{10cde}', '\u{0}', '\u{0}']),
+    ('\u{10c9f}', ['\u{10cdf}', '\u{0}', '\u{0}']),
+    ('\u{10ca0}', ['\u{10ce0}', '\u{0}', '\u{0}']),
+    ('\u{10ca1}', ['\u{10ce1}', '\u{0}', '\u{0}']),
+    ('\u{10ca2}', ['\u{10ce2}', '\u{0}', '\u{0}']),
+    ('\u{10ca3}', ['\u{10ce3}', '\u{0}', '\u{0}']),
+    ('\u{10ca4}', ['\u{10ce4}', '\u{0}', '\u{0}']),
+    ('\u{10ca5}', ['\u{10ce5}', '\u{0}', '\u{0}']),
+    ('\u{10ca6}', ['\u{10ce6}', '\u{0}', '\u{0}']),
+    ('\u{10ca7}', ['\u{10ce7}', '\u{0}', '\u{0}']),
+    ('\u{10ca8}', ['\u{10ce8}', '\u{0}', '\u{0}']),
+    ('\u{10ca9}', ['\u{10ce9}', '\u{0}', '\u{0}']),
+    ('\u{10caa}', ['\u{10cea}', '\u{0}', '\u{0}']),
+    ('\u{10cab}', ['\u{10ceb}', '\u{0}', '\u{0}']),
+    ('\u{10cac}', ['\u{10cec}', '\u{0}', '\u{0}']),
+    ('\u{10cad}', ['\u{10ced}', '\u{0}', '\u{0}']),
+    ('\u{10cae}', ['\u{10cee}', '\u{0}', '\u{0}']),
+    ('\u{10caf}', ['\u{10cef}', '\u{0}', '\u{0}']),
+    ('\u{10cb0}', ['\u{10cf0}', '\u{0}', '\u{0}']),
+    ('\u{10cb1}', ['\u{10cf1}', '\u{0}', '\u{0}']),
+    ('\u{10cb2}', ['\u{10cf2}', '\u{0}', '\u{0}']),
+    ('\u{10d50}', ['\u{10d70}', '\u{0}', '\u{0}']),
+    ('\u{10d51}', ['\u{10d71}', '\u{0}', '\u{0}']),
+    ('\u{10d52}', ['\u{10d72}', '\u{0}', '\u{0}']),
+    ('\u{10d53}', ['\u{10d73}', '\u{0}', '\u{0}']),
+    ('\u{10d54}', ['\u{10d74}', '\u{0}', '\u{0}']),
+    ('\u{10d55}', ['\u{10d75}', '\u{0}', '\u{0}']),
+    ('\u{10d56}', ['\u{10d76}', '\u{0}', '\u{0}']),
+    ('\u{10d57}', ['\u{10d77}', '\u{0}', '\u{0}']),
+    ('\u{10d58}', ['\u{10d78}', '\u{0}', '\u{0}']),
+    ('\u{10d59}', ['\u{10d79}', '\u{0}', '\u{0}']),
+    ('\u{10d5a}', ['\u{10d7a}', '\u{0}', '\u{0}']),
+    ('\u{10d5b}', ['\u{10d7b}', '\u{0}', '\u{0}']),
+    ('\u{10d5c}', ['\u{10d7c}', '\u{0}', '\u{0}']),
+    ('\u{10d5d}', ['\u{10d7d}', '\u{0}', '\u{0}']),
+    ('\u{10d5e}', ['\u{10d7e}', '\u{0}', '\u{0}']),
+    ('\u{10d5f}', ['\u{10d7f}', '\u{0}', '\u{0}']),
+    ('\u{10d60}', ['\u{10d80}', '\u{0}', '\u{0}']),
+    ('\u{10d61}', ['\u{10d81}', '\u{0}', '\u{0}']),
+    ('\u{10d62}', ['\u{10d82}', '\u{0}', '\u{0}']),
+    ('\u{10d63}', ['\u{10d83}', '\u{0}', '\u{0}']),
+    ('\u{10d64}', ['\u{10d84}', '\u{0}', '\u{0}']),
+    ('\u{10d65}', ['\u{10d85}', '\u{0}', '\u{0}']),
+    ('\u{118a0}', ['\u{118c0}', '\u{0}', '\u{0}']),
+    ('\u{118a1}', ['\u{118c1}', '\u{0}', '\u{0}']),
+    ('\u{118a2}', ['\u{118c2}', '\u{0}', '\u{0}']),
+    ('\u{118a3}', ['\u{118c3}', '\u{0}', '\u{0}']),
+    ('\u{118a4}', ['\u{118c4}', '\u{0}', '\u{0}']),
+    ('\u{118a5}', ['\u{118c5}', '\u{0}', '\u{0}']),
+    ('\u{118a6}', ['\u{118c6}', '\u{0}', '\u{0}']),
+    ('\u{118a7}', ['\u{118c7}', '\u{0}', '\u{0}']),
+    ('\u{118a8}', ['\u{118c8}', '\u{0}', '\u{0}']),
+    ('\u{118a9}', ['\u{118c9}', '\u{0}', '\u{0}']),
+    ('\u{118aa}', ['\u{118ca}', '\u{0}', '\u{0}']),
+    ('\u{118ab}', ['\u{118cb}', '\u{0}', '\u{0}']),
+    ('\u{118ac}', ['\u{118cc}', '\u{0}', '\u{0}']),
+    ('\u{118ad}', ['\u{118cd}', '\u{0}', '\u{0}']),
+    ('\u{118ae}', ['\u{118ce}', '\u{0}', '\u{0}']),
+    ('\u{118af}', ['\u{118cf}', '\u{0}', '\u{0}']),
+    ('\u{118b0}', ['\u{118d0}', '\u{0}', '\u{0}']),
+    ('\u{118b1}', ['\u{118d1}', '\u{0}', '\u{0}']),
+    ('\u{118b2}', ['\u{118d2}', '\u{0}', '\u{0}']),
+    ('\u{118b3}', ['\u{118d3}', '\u{0}', '\u{0}']),
+    ('\u{118b4}', ['\u{118d4}', '\u{0}', '\u{0}']),
+    ('\u{118b5}', ['\u{118d5}', '\u{0}', '\u{0}']),
+    ('\u{118b6}', ['\u{118d6}', '\u{0}', '\u{0}']),
+    ('\u{118b7}', ['\u{118d7}', '\u{0}', '\u{0}']),
+    ('\u{118b8}', ['\u{118d8}', '\u{0}', '\u{0}']),
+    ('\u{118b9}', ['\u{118d9}', '\u{0}', '\u{0}']),
+    ('\u{118ba}', ['\u{118da}', '\u{0}', '\u{0}']),
+    ('\u{118bb}', ['\u{118db}', '\u{0}', '\u{0}']),
+    ('\u{118bc}', ['\u{118dc}', '\u{0}', '\u{0}']),
+    ('\u{118bd}', ['\u{118dd}', '\u{0}', '\u{0}']),
+    ('\u{118be}', ['\u{118de}', '\u{0}', '\u{0}']),
+    ('\u{118bf}', ['\u{118df}', '\u{0}', '\u{0}']),
+    ('\u{16e40}', ['\u{16e60}', '\u{0}', '\u{0}']),
+    ('\u{16e41}', ['\u{16e61}', '\u{0}', '\u{0}']),
+    ('\u{16e42}', ['\u{16e62}', '\u{0}', '\u{0}']),
+    ('\u{16e43}', ['\u{16e63}', '\u{0}', '\u{0}']),
+    ('\u{16e44}', ['\u{16e64}', '\u{0}', '\u{0}']),
+    ('\u{16e45}', ['\u{16e65}', '\u{0}', '\u{0}']),
+    ('\u{16e46}', ['\u{16e66}', '\u{0}', '\u{0}']),
+    ('\u{16e47}', ['\u{16e67}', '\u{0}', '\u{0}']),
+    ('\u{16e48}', ['\u{16e68}', '\u{0}', '\u{0}']),
+    ('\u{16e49}', ['\u{16e69}', '\u{0}', '\u{0}']),
+    ('\u{16e4a}', ['\u{16e6a}', '\u{0}', '\u{0}']),
+    ('\u{16e4b}', ['\u{16e6b}', '\u{0}', '\u{0}']),
+    ('\u{16e4c}', ['\u{16e6c}', '\u{0}', '\u{0}']),
+    ('\u{16e4d}', ['\u{16e6d}', '\u{0}', '\u{0}']),
+    ('\u{16e4e}', ['\u{16e6e}', '\u{0}', '\u{0}']),
+    ('\u{16e4f}', ['\u{16e6f}', '\u{0}', '\u{0}']),
+    ('\u{16e50}', ['\u{16e70}', '\u{0}', '\u{0}']),
+    ('\u{16e51}', ['\u{16e71}', '\u{0}', '\u{0}']),
+    ('\u{16e52}', ['\u{16e72}', '\u{0}', '\u{0}']),
+    ('\u{16e53}', ['\u{16e73}', '\u{0}', '\u{0}']),
+    ('\u{16e54}', ['\u{16e74}', '\u{0}', '\u{0}']),
+    ('\u{16e55}', ['\u{16e75}', '\u{0}', '\u{0}']),
+    ('\u{16e56}', ['\u{16e76}', '\u{0}', '\u{0}']),
+    ('\u{16e57}', ['\u{16e77}', '\u{0}', '\u{0}']),
+    ('\u{16e58}', ['\u{16e78}', '\u{0}', '\u{0}']),
+    ('\u{16e59}', ['\u{16e79}', '\u{0}', '\u{0}']),
+    ('\u{16e5a}', ['\u{16e7a}', '\u{0}', '\u{0}']),
+    ('\u{16e5b}', ['\u{16e7b}', '\u{0}', '\u{0}']),
+    ('\u{16e5c}', ['\u{16e7c}', '\u{0}', '\u{0}']),
+    ('\u{16e5d}', ['\u{16e7d}', '\u{0}', '\u{0}']),
+    ('\u{16e5e}', ['\u{16e7e}', '\u{0}', '\u{0}']),
+    ('\u{16e5f}', ['\u{16e7f}', '\u{0}', '\u{0}']),
+    ('\u{16ea0}', ['\u{16ebb}', '\u{0}', '\u{0}']),
+    ('\u{16ea1}', ['\u{16ebc}', '\u{0}', '\u{0}']),
+    ('\u{16ea2}', ['\u{16ebd}', '\u{0}', '\u{0}']),
+    ('\u{16ea3}', ['\u{16ebe}', '\u{0}', '\u{0}']),
+    ('\u{16ea4}', ['\u{16ebf}', '\u{0}', '\u{0}']),
+    ('\u{16ea5}', ['\u{16ec0}', '\u{0}', '\u{0}']),
+    ('\u{16ea6}', ['\u{16ec1}', '\u{0}', '\u{0}']),
+    ('\u{16ea7}', ['\u{16ec2}', '\u{0}', '\u{0}']),
+    ('\u{16ea8}', ['\u{16ec3}', '\u{0}', '\u{0}']),
+    ('\u{16ea9}', ['\u{16ec4}', '\u{0}', '\u{0}']),
+    ('\u{16eaa}', ['\u{16ec5}', '\u{0}', '\u{0}']),
+    ('\u{16eab}', ['\u{16ec6}', '\u{0}', '\u{0}']),
+    ('\u{16eac}', ['\u{16ec7}', '\u{0}', '\u{0}']),
+    ('\u{16ead}', ['\u{16ec8}', '\u{0}', '\u{0}']),
+    ('\u{16eae}', ['\u{16ec9}', '\u{0}', '\u{0}']),
+    ('\u{16eaf}', ['\u{16eca}', '\u{0}', '\u{0}']),
+    ('\u{16eb0}', ['\u{16ecb}', '\u{0}', '\u{0}']),
+    ('\u{16eb1}', ['\u{16ecc}', '\u{0}', '\u{0}']),
+    ('\u{16eb2}', ['\u{16ecd}', '\u{0}', '\u{0}']),
+    ('\u{16eb3}', ['\u{16ece}', '\u{0}', '\u{0}']),
+    ('\u{16eb4}', ['\u{16ecf}', '\u{0}', '\u{0}']),
+    ('\u{16eb5}', ['\u{16ed0}', '\u{0}', '\u{0}']),
+    ('\u{16eb6}', ['\u{16ed1}', '\u{0}', '\u{0}']),
+    ('\u{16eb7}', ['\u{16ed2}', '\u{0}', '\u{0}']),
+    ('\u{16eb8}', ['\u{16ed3}', '\u{0}', '\u{0}']),
+    ('\u{1e900}', ['\u{1e922}', '\u{0}', '\u{0}']),
+    ('\u{1e901}', ['\u{1e923}', '\u{0}', '\u{0}']),
+    ('\u{1e902}', ['\u{1e924}', '\u{0}', '\u{0}']),
+    ('\u{1e903}', ['\u{1e925}', '\u{0}', '\u{0}']),
+    ('\u{1e904}', ['\u{1e926}', '\u{0}', '\u{0}']),
+    ('\u{1e905}', ['\u{1e927}', '\u{0}', '\u{0}']),
+    ('\u{1e906}', ['\u{1e928}', '\u{0}', '\u{0}']),
+    ('\u{1e907}', ['\u{1e929}', '\u{0}', '\u{0}']),
+    ('\u{1e908}', ['\u{1e92a}', '\u{0}', '\u{0}']),
+    ('\u{1e909}', ['\u{1e92b}', '\u{0}', '\u{0}']),
+    ('\u{1e90a}', ['\u{1e92c}', '\u{0}', '\u{0}']),
+    ('\u{1e90b}', ['\u{1e92d}', '\u{0}', '\u{0}']),
+    ('\u{1e90c}', ['\u{1e92e}', '\u{0}', '\u{0}']),
+    ('\u{1e90d}', ['\u{1e92f}', '\u{0}', '\u{0}']),
+    ('\u{1e90e}', ['\u{1e930}', '\u{0}', '\u{0}']),
+    ('\u{1e90f}', ['\u{1e931}', '\u{0}', '\u{0}']),
+    ('\u{1e910}', ['\u{1e932}', '\u{0}', '\u{0}']),
+    ('\u{1e911}', ['\u{1e933}', '\u{0}', '\u{0}']),
+    ('\u{1e912}', ['\u{1e934}', '\u{0}', '\u{0}']),
+    ('\u{1e913}', ['\u{1e935}', '\u{0}', '\u{0}']),
+    ('\u{1e914}', ['\u{1e936}', '\u{0}', '\u{0}']),
+    ('\u{1e915}', ['\u{1e937}', '\u{0}', '\u{0}']),
+    ('\u{1e916}', ['\u{1e938}', '\u{0}', '\u{0}']),
+    ('\u{1e917}', ['\u{1e939}', '\u{0}', '\u{0}']),
+    ('\u{1e918}', ['\u{1e93a}', '\u{0}', '\u{0}']),
+    ('\u{1e919}', ['\u{1e93b}', '\u{0}', '\u{0}']),
+    ('\u{1e91a}', ['\u{1e93c}', '\u{0}', '\u{0}']),
+    ('\u{1e91b}', ['\u{1e93d}', '\u{0}', '\u{0}']),
+    ('\u{1e91c}', ['\u{1e93e}', '\u{0}', '\u{0}']),
+    ('\u{1e91d}', ['\u{1e93f}', '\u{0}', '\u{0}']),
+    ('\u{1e91e}', ['\u{1e940}', '\u{0}', '\u{0}']),
+    ('\u{1e91f}', ['\u{1e941}', '\u{0}', '\u{0}']),
+    ('\u{1e920}', ['\u{1e942}', '\u{0}', '\u{0}']),
+    ('\u{1e921}', ['\u{1e943}', '\u{0}', '\u{0}']),
+];
+
+#[rustfmt::skip]
+pub(super) static TO_UPPER: &[(char, [char; 3]); 1554] = &[
+    ('\u{b5}', ['\u{39c}', '\u{0}', '\u{0}']), ('\u{df}', ['S', 'S', '\u{0}']),
+    ('\u{e0}', ['\u{c0}', '\u{0}', '\u{0}']), ('\u{e1}', ['\u{c1}', '\u{0}', '\u{0}']),
+    ('\u{e2}', ['\u{c2}', '\u{0}', '\u{0}']), ('\u{e3}', ['\u{c3}', '\u{0}', '\u{0}']),
+    ('\u{e4}', ['\u{c4}', '\u{0}', '\u{0}']), ('\u{e5}', ['\u{c5}', '\u{0}', '\u{0}']),
+    ('\u{e6}', ['\u{c6}', '\u{0}', '\u{0}']), ('\u{e7}', ['\u{c7}', '\u{0}', '\u{0}']),
+    ('\u{e8}', ['\u{c8}', '\u{0}', '\u{0}']), ('\u{e9}', ['\u{c9}', '\u{0}', '\u{0}']),
+    ('\u{ea}', ['\u{ca}', '\u{0}', '\u{0}']), ('\u{eb}', ['\u{cb}', '\u{0}', '\u{0}']),
+    ('\u{ec}', ['\u{cc}', '\u{0}', '\u{0}']), ('\u{ed}', ['\u{cd}', '\u{0}', '\u{0}']),
+    ('\u{ee}', ['\u{ce}', '\u{0}', '\u{0}']), ('\u{ef}', ['\u{cf}', '\u{0}', '\u{0}']),
+    ('\u{f0}', ['\u{d0}', '\u{0}', '\u{0}']), ('\u{f1}', ['\u{d1}', '\u{0}', '\u{0}']),
+    ('\u{f2}', ['\u{d2}', '\u{0}', '\u{0}']), ('\u{f3}', ['\u{d3}', '\u{0}', '\u{0}']),
+    ('\u{f4}', ['\u{d4}', '\u{0}', '\u{0}']), ('\u{f5}', ['\u{d5}', '\u{0}', '\u{0}']),
+    ('\u{f6}', ['\u{d6}', '\u{0}', '\u{0}']), ('\u{f8}', ['\u{d8}', '\u{0}', '\u{0}']),
+    ('\u{f9}', ['\u{d9}', '\u{0}', '\u{0}']), ('\u{fa}', ['\u{da}', '\u{0}', '\u{0}']),
+    ('\u{fb}', ['\u{db}', '\u{0}', '\u{0}']), ('\u{fc}', ['\u{dc}', '\u{0}', '\u{0}']),
+    ('\u{fd}', ['\u{dd}', '\u{0}', '\u{0}']), ('\u{fe}', ['\u{de}', '\u{0}', '\u{0}']),
+    ('\u{ff}', ['\u{178}', '\u{0}', '\u{0}']), ('\u{101}', ['\u{100}', '\u{0}', '\u{0}']),
+    ('\u{103}', ['\u{102}', '\u{0}', '\u{0}']), ('\u{105}', ['\u{104}', '\u{0}', '\u{0}']),
+    ('\u{107}', ['\u{106}', '\u{0}', '\u{0}']), ('\u{109}', ['\u{108}', '\u{0}', '\u{0}']),
+    ('\u{10b}', ['\u{10a}', '\u{0}', '\u{0}']), ('\u{10d}', ['\u{10c}', '\u{0}', '\u{0}']),
+    ('\u{10f}', ['\u{10e}', '\u{0}', '\u{0}']), ('\u{111}', ['\u{110}', '\u{0}', '\u{0}']),
+    ('\u{113}', ['\u{112}', '\u{0}', '\u{0}']), ('\u{115}', ['\u{114}', '\u{0}', '\u{0}']),
+    ('\u{117}', ['\u{116}', '\u{0}', '\u{0}']), ('\u{119}', ['\u{118}', '\u{0}', '\u{0}']),
+    ('\u{11b}', ['\u{11a}', '\u{0}', '\u{0}']), ('\u{11d}', ['\u{11c}', '\u{0}', '\u{0}']),
+    ('\u{11f}', ['\u{11e}', '\u{0}', '\u{0}']), ('\u{121}', ['\u{120}', '\u{0}', '\u{0}']),
+    ('\u{123}', ['\u{122}', '\u{0}', '\u{0}']), ('\u{125}', ['\u{124}', '\u{0}', '\u{0}']),
+    ('\u{127}', ['\u{126}', '\u{0}', '\u{0}']), ('\u{129}', ['\u{128}', '\u{0}', '\u{0}']),
+    ('\u{12b}', ['\u{12a}', '\u{0}', '\u{0}']), ('\u{12d}', ['\u{12c}', '\u{0}', '\u{0}']),
+    ('\u{12f}', ['\u{12e}', '\u{0}', '\u{0}']), ('\u{131}', ['I', '\u{0}', '\u{0}']),
+    ('\u{133}', ['\u{132}', '\u{0}', '\u{0}']), ('\u{135}', ['\u{134}', '\u{0}', '\u{0}']),
+    ('\u{137}', ['\u{136}', '\u{0}', '\u{0}']), ('\u{13a}', ['\u{139}', '\u{0}', '\u{0}']),
+    ('\u{13c}', ['\u{13b}', '\u{0}', '\u{0}']), ('\u{13e}', ['\u{13d}', '\u{0}', '\u{0}']),
+    ('\u{140}', ['\u{13f}', '\u{0}', '\u{0}']), ('\u{142}', ['\u{141}', '\u{0}', '\u{0}']),
+    ('\u{144}', ['\u{143}', '\u{0}', '\u{0}']), ('\u{146}', ['\u{145}', '\u{0}', '\u{0}']),
+    ('\u{148}', ['\u{147}', '\u{0}', '\u{0}']), ('\u{149}', ['\u{2bc}', 'N', '\u{0}']),
+    ('\u{14b}', ['\u{14a}', '\u{0}', '\u{0}']), ('\u{14d}', ['\u{14c}', '\u{0}', '\u{0}']),
+    ('\u{14f}', ['\u{14e}', '\u{0}', '\u{0}']), ('\u{151}', ['\u{150}', '\u{0}', '\u{0}']),
+    ('\u{153}', ['\u{152}', '\u{0}', '\u{0}']), ('\u{155}', ['\u{154}', '\u{0}', '\u{0}']),
+    ('\u{157}', ['\u{156}', '\u{0}', '\u{0}']), ('\u{159}', ['\u{158}', '\u{0}', '\u{0}']),
+    ('\u{15b}', ['\u{15a}', '\u{0}', '\u{0}']), ('\u{15d}', ['\u{15c}', '\u{0}', '\u{0}']),
+    ('\u{15f}', ['\u{15e}', '\u{0}', '\u{0}']), ('\u{161}', ['\u{160}', '\u{0}', '\u{0}']),
+    ('\u{163}', ['\u{162}', '\u{0}', '\u{0}']), ('\u{165}', ['\u{164}', '\u{0}', '\u{0}']),
+    ('\u{167}', ['\u{166}', '\u{0}', '\u{0}']), ('\u{169}', ['\u{168}', '\u{0}', '\u{0}']),
+    ('\u{16b}', ['\u{16a}', '\u{0}', '\u{0}']), ('\u{16d}', ['\u{16c}', '\u{0}', '\u{0}']),
+    ('\u{16f}', ['\u{16e}', '\u{0}', '\u{0}']), ('\u{171}', ['\u{170}', '\u{0}', '\u{0}']),
+    ('\u{173}', ['\u{172}', '\u{0}', '\u{0}']), ('\u{175}', ['\u{174}', '\u{0}', '\u{0}']),
+    ('\u{177}', ['\u{176}', '\u{0}', '\u{0}']), ('\u{17a}', ['\u{179}', '\u{0}', '\u{0}']),
+    ('\u{17c}', ['\u{17b}', '\u{0}', '\u{0}']), ('\u{17e}', ['\u{17d}', '\u{0}', '\u{0}']),
+    ('\u{17f}', ['S', '\u{0}', '\u{0}']), ('\u{180}', ['\u{243}', '\u{0}', '\u{0}']),
+    ('\u{183}', ['\u{182}', '\u{0}', '\u{0}']), ('\u{185}', ['\u{184}', '\u{0}', '\u{0}']),
+    ('\u{188}', ['\u{187}', '\u{0}', '\u{0}']), ('\u{18c}', ['\u{18b}', '\u{0}', '\u{0}']),
+    ('\u{192}', ['\u{191}', '\u{0}', '\u{0}']), ('\u{195}', ['\u{1f6}', '\u{0}', '\u{0}']),
+    ('\u{199}', ['\u{198}', '\u{0}', '\u{0}']), ('\u{19a}', ['\u{23d}', '\u{0}', '\u{0}']),
+    ('\u{19b}', ['\u{a7dc}', '\u{0}', '\u{0}']), ('\u{19e}', ['\u{220}', '\u{0}', '\u{0}']),
+    ('\u{1a1}', ['\u{1a0}', '\u{0}', '\u{0}']), ('\u{1a3}', ['\u{1a2}', '\u{0}', '\u{0}']),
+    ('\u{1a5}', ['\u{1a4}', '\u{0}', '\u{0}']), ('\u{1a8}', ['\u{1a7}', '\u{0}', '\u{0}']),
+    ('\u{1ad}', ['\u{1ac}', '\u{0}', '\u{0}']), ('\u{1b0}', ['\u{1af}', '\u{0}', '\u{0}']),
+    ('\u{1b4}', ['\u{1b3}', '\u{0}', '\u{0}']), ('\u{1b6}', ['\u{1b5}', '\u{0}', '\u{0}']),
+    ('\u{1b9}', ['\u{1b8}', '\u{0}', '\u{0}']), ('\u{1bd}', ['\u{1bc}', '\u{0}', '\u{0}']),
+    ('\u{1bf}', ['\u{1f7}', '\u{0}', '\u{0}']), ('\u{1c5}', ['\u{1c4}', '\u{0}', '\u{0}']),
+    ('\u{1c6}', ['\u{1c4}', '\u{0}', '\u{0}']), ('\u{1c8}', ['\u{1c7}', '\u{0}', '\u{0}']),
+    ('\u{1c9}', ['\u{1c7}', '\u{0}', '\u{0}']), ('\u{1cb}', ['\u{1ca}', '\u{0}', '\u{0}']),
+    ('\u{1cc}', ['\u{1ca}', '\u{0}', '\u{0}']), ('\u{1ce}', ['\u{1cd}', '\u{0}', '\u{0}']),
+    ('\u{1d0}', ['\u{1cf}', '\u{0}', '\u{0}']), ('\u{1d2}', ['\u{1d1}', '\u{0}', '\u{0}']),
+    ('\u{1d4}', ['\u{1d3}', '\u{0}', '\u{0}']), ('\u{1d6}', ['\u{1d5}', '\u{0}', '\u{0}']),
+    ('\u{1d8}', ['\u{1d7}', '\u{0}', '\u{0}']), ('\u{1da}', ['\u{1d9}', '\u{0}', '\u{0}']),
+    ('\u{1dc}', ['\u{1db}', '\u{0}', '\u{0}']), ('\u{1dd}', ['\u{18e}', '\u{0}', '\u{0}']),
+    ('\u{1df}', ['\u{1de}', '\u{0}', '\u{0}']), ('\u{1e1}', ['\u{1e0}', '\u{0}', '\u{0}']),
+    ('\u{1e3}', ['\u{1e2}', '\u{0}', '\u{0}']), ('\u{1e5}', ['\u{1e4}', '\u{0}', '\u{0}']),
+    ('\u{1e7}', ['\u{1e6}', '\u{0}', '\u{0}']), ('\u{1e9}', ['\u{1e8}', '\u{0}', '\u{0}']),
+    ('\u{1eb}', ['\u{1ea}', '\u{0}', '\u{0}']), ('\u{1ed}', ['\u{1ec}', '\u{0}', '\u{0}']),
+    ('\u{1ef}', ['\u{1ee}', '\u{0}', '\u{0}']), ('\u{1f0}', ['J', '\u{30c}', '\u{0}']),
+    ('\u{1f2}', ['\u{1f1}', '\u{0}', '\u{0}']), ('\u{1f3}', ['\u{1f1}', '\u{0}', '\u{0}']),
+    ('\u{1f5}', ['\u{1f4}', '\u{0}', '\u{0}']), ('\u{1f9}', ['\u{1f8}', '\u{0}', '\u{0}']),
+    ('\u{1fb}', ['\u{1fa}', '\u{0}', '\u{0}']), ('\u{1fd}', ['\u{1fc}', '\u{0}', '\u{0}']),
+    ('\u{1ff}', ['\u{1fe}', '\u{0}', '\u{0}']), ('\u{201}', ['\u{200}', '\u{0}', '\u{0}']),
+    ('\u{203}', ['\u{202}', '\u{0}', '\u{0}']), ('\u{205}', ['\u{204}', '\u{0}', '\u{0}']),
+    ('\u{207}', ['\u{206}', '\u{0}', '\u{0}']), ('\u{209}', ['\u{208}', '\u{0}', '\u{0}']),
+    ('\u{20b}', ['\u{20a}', '\u{0}', '\u{0}']), ('\u{20d}', ['\u{20c}', '\u{0}', '\u{0}']),
+    ('\u{20f}', ['\u{20e}', '\u{0}', '\u{0}']), ('\u{211}', ['\u{210}', '\u{0}', '\u{0}']),
+    ('\u{213}', ['\u{212}', '\u{0}', '\u{0}']), ('\u{215}', ['\u{214}', '\u{0}', '\u{0}']),
+    ('\u{217}', ['\u{216}', '\u{0}', '\u{0}']), ('\u{219}', ['\u{218}', '\u{0}', '\u{0}']),
+    ('\u{21b}', ['\u{21a}', '\u{0}', '\u{0}']), ('\u{21d}', ['\u{21c}', '\u{0}', '\u{0}']),
+    ('\u{21f}', ['\u{21e}', '\u{0}', '\u{0}']), ('\u{223}', ['\u{222}', '\u{0}', '\u{0}']),
+    ('\u{225}', ['\u{224}', '\u{0}', '\u{0}']), ('\u{227}', ['\u{226}', '\u{0}', '\u{0}']),
+    ('\u{229}', ['\u{228}', '\u{0}', '\u{0}']), ('\u{22b}', ['\u{22a}', '\u{0}', '\u{0}']),
+    ('\u{22d}', ['\u{22c}', '\u{0}', '\u{0}']), ('\u{22f}', ['\u{22e}', '\u{0}', '\u{0}']),
+    ('\u{231}', ['\u{230}', '\u{0}', '\u{0}']), ('\u{233}', ['\u{232}', '\u{0}', '\u{0}']),
+    ('\u{23c}', ['\u{23b}', '\u{0}', '\u{0}']), ('\u{23f}', ['\u{2c7e}', '\u{0}', '\u{0}']),
+    ('\u{240}', ['\u{2c7f}', '\u{0}', '\u{0}']), ('\u{242}', ['\u{241}', '\u{0}', '\u{0}']),
+    ('\u{247}', ['\u{246}', '\u{0}', '\u{0}']), ('\u{249}', ['\u{248}', '\u{0}', '\u{0}']),
+    ('\u{24b}', ['\u{24a}', '\u{0}', '\u{0}']), ('\u{24d}', ['\u{24c}', '\u{0}', '\u{0}']),
+    ('\u{24f}', ['\u{24e}', '\u{0}', '\u{0}']), ('\u{250}', ['\u{2c6f}', '\u{0}', '\u{0}']),
+    ('\u{251}', ['\u{2c6d}', '\u{0}', '\u{0}']), ('\u{252}', ['\u{2c70}', '\u{0}', '\u{0}']),
+    ('\u{253}', ['\u{181}', '\u{0}', '\u{0}']), ('\u{254}', ['\u{186}', '\u{0}', '\u{0}']),
+    ('\u{256}', ['\u{189}', '\u{0}', '\u{0}']), ('\u{257}', ['\u{18a}', '\u{0}', '\u{0}']),
+    ('\u{259}', ['\u{18f}', '\u{0}', '\u{0}']), ('\u{25b}', ['\u{190}', '\u{0}', '\u{0}']),
+    ('\u{25c}', ['\u{a7ab}', '\u{0}', '\u{0}']), ('\u{260}', ['\u{193}', '\u{0}', '\u{0}']),
+    ('\u{261}', ['\u{a7ac}', '\u{0}', '\u{0}']), ('\u{263}', ['\u{194}', '\u{0}', '\u{0}']),
+    ('\u{264}', ['\u{a7cb}', '\u{0}', '\u{0}']), ('\u{265}', ['\u{a78d}', '\u{0}', '\u{0}']),
+    ('\u{266}', ['\u{a7aa}', '\u{0}', '\u{0}']), ('\u{268}', ['\u{197}', '\u{0}', '\u{0}']),
+    ('\u{269}', ['\u{196}', '\u{0}', '\u{0}']), ('\u{26a}', ['\u{a7ae}', '\u{0}', '\u{0}']),
+    ('\u{26b}', ['\u{2c62}', '\u{0}', '\u{0}']), ('\u{26c}', ['\u{a7ad}', '\u{0}', '\u{0}']),
+    ('\u{26f}', ['\u{19c}', '\u{0}', '\u{0}']), ('\u{271}', ['\u{2c6e}', '\u{0}', '\u{0}']),
+    ('\u{272}', ['\u{19d}', '\u{0}', '\u{0}']), ('\u{275}', ['\u{19f}', '\u{0}', '\u{0}']),
+    ('\u{27d}', ['\u{2c64}', '\u{0}', '\u{0}']), ('\u{280}', ['\u{1a6}', '\u{0}', '\u{0}']),
+    ('\u{282}', ['\u{a7c5}', '\u{0}', '\u{0}']), ('\u{283}', ['\u{1a9}', '\u{0}', '\u{0}']),
+    ('\u{287}', ['\u{a7b1}', '\u{0}', '\u{0}']), ('\u{288}', ['\u{1ae}', '\u{0}', '\u{0}']),
+    ('\u{289}', ['\u{244}', '\u{0}', '\u{0}']), ('\u{28a}', ['\u{1b1}', '\u{0}', '\u{0}']),
+    ('\u{28b}', ['\u{1b2}', '\u{0}', '\u{0}']), ('\u{28c}', ['\u{245}', '\u{0}', '\u{0}']),
+    ('\u{292}', ['\u{1b7}', '\u{0}', '\u{0}']), ('\u{29d}', ['\u{a7b2}', '\u{0}', '\u{0}']),
+    ('\u{29e}', ['\u{a7b0}', '\u{0}', '\u{0}']), ('\u{345}', ['\u{399}', '\u{0}', '\u{0}']),
+    ('\u{371}', ['\u{370}', '\u{0}', '\u{0}']), ('\u{373}', ['\u{372}', '\u{0}', '\u{0}']),
+    ('\u{377}', ['\u{376}', '\u{0}', '\u{0}']), ('\u{37b}', ['\u{3fd}', '\u{0}', '\u{0}']),
+    ('\u{37c}', ['\u{3fe}', '\u{0}', '\u{0}']), ('\u{37d}', ['\u{3ff}', '\u{0}', '\u{0}']),
+    ('\u{390}', ['\u{399}', '\u{308}', '\u{301}']), ('\u{3ac}', ['\u{386}', '\u{0}', '\u{0}']),
+    ('\u{3ad}', ['\u{388}', '\u{0}', '\u{0}']), ('\u{3ae}', ['\u{389}', '\u{0}', '\u{0}']),
+    ('\u{3af}', ['\u{38a}', '\u{0}', '\u{0}']), ('\u{3b0}', ['\u{3a5}', '\u{308}', '\u{301}']),
+    ('\u{3b1}', ['\u{391}', '\u{0}', '\u{0}']), ('\u{3b2}', ['\u{392}', '\u{0}', '\u{0}']),
+    ('\u{3b3}', ['\u{393}', '\u{0}', '\u{0}']), ('\u{3b4}', ['\u{394}', '\u{0}', '\u{0}']),
+    ('\u{3b5}', ['\u{395}', '\u{0}', '\u{0}']), ('\u{3b6}', ['\u{396}', '\u{0}', '\u{0}']),
+    ('\u{3b7}', ['\u{397}', '\u{0}', '\u{0}']), ('\u{3b8}', ['\u{398}', '\u{0}', '\u{0}']),
+    ('\u{3b9}', ['\u{399}', '\u{0}', '\u{0}']), ('\u{3ba}', ['\u{39a}', '\u{0}', '\u{0}']),
+    ('\u{3bb}', ['\u{39b}', '\u{0}', '\u{0}']), ('\u{3bc}', ['\u{39c}', '\u{0}', '\u{0}']),
+    ('\u{3bd}', ['\u{39d}', '\u{0}', '\u{0}']), ('\u{3be}', ['\u{39e}', '\u{0}', '\u{0}']),
+    ('\u{3bf}', ['\u{39f}', '\u{0}', '\u{0}']), ('\u{3c0}', ['\u{3a0}', '\u{0}', '\u{0}']),
+    ('\u{3c1}', ['\u{3a1}', '\u{0}', '\u{0}']), ('\u{3c2}', ['\u{3a3}', '\u{0}', '\u{0}']),
+    ('\u{3c3}', ['\u{3a3}', '\u{0}', '\u{0}']), ('\u{3c4}', ['\u{3a4}', '\u{0}', '\u{0}']),
+    ('\u{3c5}', ['\u{3a5}', '\u{0}', '\u{0}']), ('\u{3c6}', ['\u{3a6}', '\u{0}', '\u{0}']),
+    ('\u{3c7}', ['\u{3a7}', '\u{0}', '\u{0}']), ('\u{3c8}', ['\u{3a8}', '\u{0}', '\u{0}']),
+    ('\u{3c9}', ['\u{3a9}', '\u{0}', '\u{0}']), ('\u{3ca}', ['\u{3aa}', '\u{0}', '\u{0}']),
+    ('\u{3cb}', ['\u{3ab}', '\u{0}', '\u{0}']), ('\u{3cc}', ['\u{38c}', '\u{0}', '\u{0}']),
+    ('\u{3cd}', ['\u{38e}', '\u{0}', '\u{0}']), ('\u{3ce}', ['\u{38f}', '\u{0}', '\u{0}']),
+    ('\u{3d0}', ['\u{392}', '\u{0}', '\u{0}']), ('\u{3d1}', ['\u{398}', '\u{0}', '\u{0}']),
+    ('\u{3d5}', ['\u{3a6}', '\u{0}', '\u{0}']), ('\u{3d6}', ['\u{3a0}', '\u{0}', '\u{0}']),
+    ('\u{3d7}', ['\u{3cf}', '\u{0}', '\u{0}']), ('\u{3d9}', ['\u{3d8}', '\u{0}', '\u{0}']),
+    ('\u{3db}', ['\u{3da}', '\u{0}', '\u{0}']), ('\u{3dd}', ['\u{3dc}', '\u{0}', '\u{0}']),
+    ('\u{3df}', ['\u{3de}', '\u{0}', '\u{0}']), ('\u{3e1}', ['\u{3e0}', '\u{0}', '\u{0}']),
+    ('\u{3e3}', ['\u{3e2}', '\u{0}', '\u{0}']), ('\u{3e5}', ['\u{3e4}', '\u{0}', '\u{0}']),
+    ('\u{3e7}', ['\u{3e6}', '\u{0}', '\u{0}']), ('\u{3e9}', ['\u{3e8}', '\u{0}', '\u{0}']),
+    ('\u{3eb}', ['\u{3ea}', '\u{0}', '\u{0}']), ('\u{3ed}', ['\u{3ec}', '\u{0}', '\u{0}']),
+    ('\u{3ef}', ['\u{3ee}', '\u{0}', '\u{0}']), ('\u{3f0}', ['\u{39a}', '\u{0}', '\u{0}']),
+    ('\u{3f1}', ['\u{3a1}', '\u{0}', '\u{0}']), ('\u{3f2}', ['\u{3f9}', '\u{0}', '\u{0}']),
+    ('\u{3f3}', ['\u{37f}', '\u{0}', '\u{0}']), ('\u{3f5}', ['\u{395}', '\u{0}', '\u{0}']),
+    ('\u{3f8}', ['\u{3f7}', '\u{0}', '\u{0}']), ('\u{3fb}', ['\u{3fa}', '\u{0}', '\u{0}']),
+    ('\u{430}', ['\u{410}', '\u{0}', '\u{0}']), ('\u{431}', ['\u{411}', '\u{0}', '\u{0}']),
+    ('\u{432}', ['\u{412}', '\u{0}', '\u{0}']), ('\u{433}', ['\u{413}', '\u{0}', '\u{0}']),
+    ('\u{434}', ['\u{414}', '\u{0}', '\u{0}']), ('\u{435}', ['\u{415}', '\u{0}', '\u{0}']),
+    ('\u{436}', ['\u{416}', '\u{0}', '\u{0}']), ('\u{437}', ['\u{417}', '\u{0}', '\u{0}']),
+    ('\u{438}', ['\u{418}', '\u{0}', '\u{0}']), ('\u{439}', ['\u{419}', '\u{0}', '\u{0}']),
+    ('\u{43a}', ['\u{41a}', '\u{0}', '\u{0}']), ('\u{43b}', ['\u{41b}', '\u{0}', '\u{0}']),
+    ('\u{43c}', ['\u{41c}', '\u{0}', '\u{0}']), ('\u{43d}', ['\u{41d}', '\u{0}', '\u{0}']),
+    ('\u{43e}', ['\u{41e}', '\u{0}', '\u{0}']), ('\u{43f}', ['\u{41f}', '\u{0}', '\u{0}']),
+    ('\u{440}', ['\u{420}', '\u{0}', '\u{0}']), ('\u{441}', ['\u{421}', '\u{0}', '\u{0}']),
+    ('\u{442}', ['\u{422}', '\u{0}', '\u{0}']), ('\u{443}', ['\u{423}', '\u{0}', '\u{0}']),
+    ('\u{444}', ['\u{424}', '\u{0}', '\u{0}']), ('\u{445}', ['\u{425}', '\u{0}', '\u{0}']),
+    ('\u{446}', ['\u{426}', '\u{0}', '\u{0}']), ('\u{447}', ['\u{427}', '\u{0}', '\u{0}']),
+    ('\u{448}', ['\u{428}', '\u{0}', '\u{0}']), ('\u{449}', ['\u{429}', '\u{0}', '\u{0}']),
+    ('\u{44a}', ['\u{42a}', '\u{0}', '\u{0}']), ('\u{44b}', ['\u{42b}', '\u{0}', '\u{0}']),
+    ('\u{44c}', ['\u{42c}', '\u{0}', '\u{0}']), ('\u{44d}', ['\u{42d}', '\u{0}', '\u{0}']),
+    ('\u{44e}', ['\u{42e}', '\u{0}', '\u{0}']), ('\u{44f}', ['\u{42f}', '\u{0}', '\u{0}']),
+    ('\u{450}', ['\u{400}', '\u{0}', '\u{0}']), ('\u{451}', ['\u{401}', '\u{0}', '\u{0}']),
+    ('\u{452}', ['\u{402}', '\u{0}', '\u{0}']), ('\u{453}', ['\u{403}', '\u{0}', '\u{0}']),
+    ('\u{454}', ['\u{404}', '\u{0}', '\u{0}']), ('\u{455}', ['\u{405}', '\u{0}', '\u{0}']),
+    ('\u{456}', ['\u{406}', '\u{0}', '\u{0}']), ('\u{457}', ['\u{407}', '\u{0}', '\u{0}']),
+    ('\u{458}', ['\u{408}', '\u{0}', '\u{0}']), ('\u{459}', ['\u{409}', '\u{0}', '\u{0}']),
+    ('\u{45a}', ['\u{40a}', '\u{0}', '\u{0}']), ('\u{45b}', ['\u{40b}', '\u{0}', '\u{0}']),
+    ('\u{45c}', ['\u{40c}', '\u{0}', '\u{0}']), ('\u{45d}', ['\u{40d}', '\u{0}', '\u{0}']),
+    ('\u{45e}', ['\u{40e}', '\u{0}', '\u{0}']), ('\u{45f}', ['\u{40f}', '\u{0}', '\u{0}']),
+    ('\u{461}', ['\u{460}', '\u{0}', '\u{0}']), ('\u{463}', ['\u{462}', '\u{0}', '\u{0}']),
+    ('\u{465}', ['\u{464}', '\u{0}', '\u{0}']), ('\u{467}', ['\u{466}', '\u{0}', '\u{0}']),
+    ('\u{469}', ['\u{468}', '\u{0}', '\u{0}']), ('\u{46b}', ['\u{46a}', '\u{0}', '\u{0}']),
+    ('\u{46d}', ['\u{46c}', '\u{0}', '\u{0}']), ('\u{46f}', ['\u{46e}', '\u{0}', '\u{0}']),
+    ('\u{471}', ['\u{470}', '\u{0}', '\u{0}']), ('\u{473}', ['\u{472}', '\u{0}', '\u{0}']),
+    ('\u{475}', ['\u{474}', '\u{0}', '\u{0}']), ('\u{477}', ['\u{476}', '\u{0}', '\u{0}']),
+    ('\u{479}', ['\u{478}', '\u{0}', '\u{0}']), ('\u{47b}', ['\u{47a}', '\u{0}', '\u{0}']),
+    ('\u{47d}', ['\u{47c}', '\u{0}', '\u{0}']), ('\u{47f}', ['\u{47e}', '\u{0}', '\u{0}']),
+    ('\u{481}', ['\u{480}', '\u{0}', '\u{0}']), ('\u{48b}', ['\u{48a}', '\u{0}', '\u{0}']),
+    ('\u{48d}', ['\u{48c}', '\u{0}', '\u{0}']), ('\u{48f}', ['\u{48e}', '\u{0}', '\u{0}']),
+    ('\u{491}', ['\u{490}', '\u{0}', '\u{0}']), ('\u{493}', ['\u{492}', '\u{0}', '\u{0}']),
+    ('\u{495}', ['\u{494}', '\u{0}', '\u{0}']), ('\u{497}', ['\u{496}', '\u{0}', '\u{0}']),
+    ('\u{499}', ['\u{498}', '\u{0}', '\u{0}']), ('\u{49b}', ['\u{49a}', '\u{0}', '\u{0}']),
+    ('\u{49d}', ['\u{49c}', '\u{0}', '\u{0}']), ('\u{49f}', ['\u{49e}', '\u{0}', '\u{0}']),
+    ('\u{4a1}', ['\u{4a0}', '\u{0}', '\u{0}']), ('\u{4a3}', ['\u{4a2}', '\u{0}', '\u{0}']),
+    ('\u{4a5}', ['\u{4a4}', '\u{0}', '\u{0}']), ('\u{4a7}', ['\u{4a6}', '\u{0}', '\u{0}']),
+    ('\u{4a9}', ['\u{4a8}', '\u{0}', '\u{0}']), ('\u{4ab}', ['\u{4aa}', '\u{0}', '\u{0}']),
+    ('\u{4ad}', ['\u{4ac}', '\u{0}', '\u{0}']), ('\u{4af}', ['\u{4ae}', '\u{0}', '\u{0}']),
+    ('\u{4b1}', ['\u{4b0}', '\u{0}', '\u{0}']), ('\u{4b3}', ['\u{4b2}', '\u{0}', '\u{0}']),
+    ('\u{4b5}', ['\u{4b4}', '\u{0}', '\u{0}']), ('\u{4b7}', ['\u{4b6}', '\u{0}', '\u{0}']),
+    ('\u{4b9}', ['\u{4b8}', '\u{0}', '\u{0}']), ('\u{4bb}', ['\u{4ba}', '\u{0}', '\u{0}']),
+    ('\u{4bd}', ['\u{4bc}', '\u{0}', '\u{0}']), ('\u{4bf}', ['\u{4be}', '\u{0}', '\u{0}']),
+    ('\u{4c2}', ['\u{4c1}', '\u{0}', '\u{0}']), ('\u{4c4}', ['\u{4c3}', '\u{0}', '\u{0}']),
+    ('\u{4c6}', ['\u{4c5}', '\u{0}', '\u{0}']), ('\u{4c8}', ['\u{4c7}', '\u{0}', '\u{0}']),
+    ('\u{4ca}', ['\u{4c9}', '\u{0}', '\u{0}']), ('\u{4cc}', ['\u{4cb}', '\u{0}', '\u{0}']),
+    ('\u{4ce}', ['\u{4cd}', '\u{0}', '\u{0}']), ('\u{4cf}', ['\u{4c0}', '\u{0}', '\u{0}']),
+    ('\u{4d1}', ['\u{4d0}', '\u{0}', '\u{0}']), ('\u{4d3}', ['\u{4d2}', '\u{0}', '\u{0}']),
+    ('\u{4d5}', ['\u{4d4}', '\u{0}', '\u{0}']), ('\u{4d7}', ['\u{4d6}', '\u{0}', '\u{0}']),
+    ('\u{4d9}', ['\u{4d8}', '\u{0}', '\u{0}']), ('\u{4db}', ['\u{4da}', '\u{0}', '\u{0}']),
+    ('\u{4dd}', ['\u{4dc}', '\u{0}', '\u{0}']), ('\u{4df}', ['\u{4de}', '\u{0}', '\u{0}']),
+    ('\u{4e1}', ['\u{4e0}', '\u{0}', '\u{0}']), ('\u{4e3}', ['\u{4e2}', '\u{0}', '\u{0}']),
+    ('\u{4e5}', ['\u{4e4}', '\u{0}', '\u{0}']), ('\u{4e7}', ['\u{4e6}', '\u{0}', '\u{0}']),
+    ('\u{4e9}', ['\u{4e8}', '\u{0}', '\u{0}']), ('\u{4eb}', ['\u{4ea}', '\u{0}', '\u{0}']),
+    ('\u{4ed}', ['\u{4ec}', '\u{0}', '\u{0}']), ('\u{4ef}', ['\u{4ee}', '\u{0}', '\u{0}']),
+    ('\u{4f1}', ['\u{4f0}', '\u{0}', '\u{0}']), ('\u{4f3}', ['\u{4f2}', '\u{0}', '\u{0}']),
+    ('\u{4f5}', ['\u{4f4}', '\u{0}', '\u{0}']), ('\u{4f7}', ['\u{4f6}', '\u{0}', '\u{0}']),
+    ('\u{4f9}', ['\u{4f8}', '\u{0}', '\u{0}']), ('\u{4fb}', ['\u{4fa}', '\u{0}', '\u{0}']),
+    ('\u{4fd}', ['\u{4fc}', '\u{0}', '\u{0}']), ('\u{4ff}', ['\u{4fe}', '\u{0}', '\u{0}']),
+    ('\u{501}', ['\u{500}', '\u{0}', '\u{0}']), ('\u{503}', ['\u{502}', '\u{0}', '\u{0}']),
+    ('\u{505}', ['\u{504}', '\u{0}', '\u{0}']), ('\u{507}', ['\u{506}', '\u{0}', '\u{0}']),
+    ('\u{509}', ['\u{508}', '\u{0}', '\u{0}']), ('\u{50b}', ['\u{50a}', '\u{0}', '\u{0}']),
+    ('\u{50d}', ['\u{50c}', '\u{0}', '\u{0}']), ('\u{50f}', ['\u{50e}', '\u{0}', '\u{0}']),
+    ('\u{511}', ['\u{510}', '\u{0}', '\u{0}']), ('\u{513}', ['\u{512}', '\u{0}', '\u{0}']),
+    ('\u{515}', ['\u{514}', '\u{0}', '\u{0}']), ('\u{517}', ['\u{516}', '\u{0}', '\u{0}']),
+    ('\u{519}', ['\u{518}', '\u{0}', '\u{0}']), ('\u{51b}', ['\u{51a}', '\u{0}', '\u{0}']),
+    ('\u{51d}', ['\u{51c}', '\u{0}', '\u{0}']), ('\u{51f}', ['\u{51e}', '\u{0}', '\u{0}']),
+    ('\u{521}', ['\u{520}', '\u{0}', '\u{0}']), ('\u{523}', ['\u{522}', '\u{0}', '\u{0}']),
+    ('\u{525}', ['\u{524}', '\u{0}', '\u{0}']), ('\u{527}', ['\u{526}', '\u{0}', '\u{0}']),
+    ('\u{529}', ['\u{528}', '\u{0}', '\u{0}']), ('\u{52b}', ['\u{52a}', '\u{0}', '\u{0}']),
+    ('\u{52d}', ['\u{52c}', '\u{0}', '\u{0}']), ('\u{52f}', ['\u{52e}', '\u{0}', '\u{0}']),
+    ('\u{561}', ['\u{531}', '\u{0}', '\u{0}']), ('\u{562}', ['\u{532}', '\u{0}', '\u{0}']),
+    ('\u{563}', ['\u{533}', '\u{0}', '\u{0}']), ('\u{564}', ['\u{534}', '\u{0}', '\u{0}']),
+    ('\u{565}', ['\u{535}', '\u{0}', '\u{0}']), ('\u{566}', ['\u{536}', '\u{0}', '\u{0}']),
+    ('\u{567}', ['\u{537}', '\u{0}', '\u{0}']), ('\u{568}', ['\u{538}', '\u{0}', '\u{0}']),
+    ('\u{569}', ['\u{539}', '\u{0}', '\u{0}']), ('\u{56a}', ['\u{53a}', '\u{0}', '\u{0}']),
+    ('\u{56b}', ['\u{53b}', '\u{0}', '\u{0}']), ('\u{56c}', ['\u{53c}', '\u{0}', '\u{0}']),
+    ('\u{56d}', ['\u{53d}', '\u{0}', '\u{0}']), ('\u{56e}', ['\u{53e}', '\u{0}', '\u{0}']),
+    ('\u{56f}', ['\u{53f}', '\u{0}', '\u{0}']), ('\u{570}', ['\u{540}', '\u{0}', '\u{0}']),
+    ('\u{571}', ['\u{541}', '\u{0}', '\u{0}']), ('\u{572}', ['\u{542}', '\u{0}', '\u{0}']),
+    ('\u{573}', ['\u{543}', '\u{0}', '\u{0}']), ('\u{574}', ['\u{544}', '\u{0}', '\u{0}']),
+    ('\u{575}', ['\u{545}', '\u{0}', '\u{0}']), ('\u{576}', ['\u{546}', '\u{0}', '\u{0}']),
+    ('\u{577}', ['\u{547}', '\u{0}', '\u{0}']), ('\u{578}', ['\u{548}', '\u{0}', '\u{0}']),
+    ('\u{579}', ['\u{549}', '\u{0}', '\u{0}']), ('\u{57a}', ['\u{54a}', '\u{0}', '\u{0}']),
+    ('\u{57b}', ['\u{54b}', '\u{0}', '\u{0}']), ('\u{57c}', ['\u{54c}', '\u{0}', '\u{0}']),
+    ('\u{57d}', ['\u{54d}', '\u{0}', '\u{0}']), ('\u{57e}', ['\u{54e}', '\u{0}', '\u{0}']),
+    ('\u{57f}', ['\u{54f}', '\u{0}', '\u{0}']), ('\u{580}', ['\u{550}', '\u{0}', '\u{0}']),
+    ('\u{581}', ['\u{551}', '\u{0}', '\u{0}']), ('\u{582}', ['\u{552}', '\u{0}', '\u{0}']),
+    ('\u{583}', ['\u{553}', '\u{0}', '\u{0}']), ('\u{584}', ['\u{554}', '\u{0}', '\u{0}']),
+    ('\u{585}', ['\u{555}', '\u{0}', '\u{0}']), ('\u{586}', ['\u{556}', '\u{0}', '\u{0}']),
+    ('\u{587}', ['\u{535}', '\u{552}', '\u{0}']), ('\u{10d0}', ['\u{1c90}', '\u{0}', '\u{0}']),
+    ('\u{10d1}', ['\u{1c91}', '\u{0}', '\u{0}']), ('\u{10d2}', ['\u{1c92}', '\u{0}', '\u{0}']),
+    ('\u{10d3}', ['\u{1c93}', '\u{0}', '\u{0}']), ('\u{10d4}', ['\u{1c94}', '\u{0}', '\u{0}']),
+    ('\u{10d5}', ['\u{1c95}', '\u{0}', '\u{0}']), ('\u{10d6}', ['\u{1c96}', '\u{0}', '\u{0}']),
+    ('\u{10d7}', ['\u{1c97}', '\u{0}', '\u{0}']), ('\u{10d8}', ['\u{1c98}', '\u{0}', '\u{0}']),
+    ('\u{10d9}', ['\u{1c99}', '\u{0}', '\u{0}']), ('\u{10da}', ['\u{1c9a}', '\u{0}', '\u{0}']),
+    ('\u{10db}', ['\u{1c9b}', '\u{0}', '\u{0}']), ('\u{10dc}', ['\u{1c9c}', '\u{0}', '\u{0}']),
+    ('\u{10dd}', ['\u{1c9d}', '\u{0}', '\u{0}']), ('\u{10de}', ['\u{1c9e}', '\u{0}', '\u{0}']),
+    ('\u{10df}', ['\u{1c9f}', '\u{0}', '\u{0}']), ('\u{10e0}', ['\u{1ca0}', '\u{0}', '\u{0}']),
+    ('\u{10e1}', ['\u{1ca1}', '\u{0}', '\u{0}']), ('\u{10e2}', ['\u{1ca2}', '\u{0}', '\u{0}']),
+    ('\u{10e3}', ['\u{1ca3}', '\u{0}', '\u{0}']), ('\u{10e4}', ['\u{1ca4}', '\u{0}', '\u{0}']),
+    ('\u{10e5}', ['\u{1ca5}', '\u{0}', '\u{0}']), ('\u{10e6}', ['\u{1ca6}', '\u{0}', '\u{0}']),
+    ('\u{10e7}', ['\u{1ca7}', '\u{0}', '\u{0}']), ('\u{10e8}', ['\u{1ca8}', '\u{0}', '\u{0}']),
+    ('\u{10e9}', ['\u{1ca9}', '\u{0}', '\u{0}']), ('\u{10ea}', ['\u{1caa}', '\u{0}', '\u{0}']),
+    ('\u{10eb}', ['\u{1cab}', '\u{0}', '\u{0}']), ('\u{10ec}', ['\u{1cac}', '\u{0}', '\u{0}']),
+    ('\u{10ed}', ['\u{1cad}', '\u{0}', '\u{0}']), ('\u{10ee}', ['\u{1cae}', '\u{0}', '\u{0}']),
+    ('\u{10ef}', ['\u{1caf}', '\u{0}', '\u{0}']), ('\u{10f0}', ['\u{1cb0}', '\u{0}', '\u{0}']),
+    ('\u{10f1}', ['\u{1cb1}', '\u{0}', '\u{0}']), ('\u{10f2}', ['\u{1cb2}', '\u{0}', '\u{0}']),
+    ('\u{10f3}', ['\u{1cb3}', '\u{0}', '\u{0}']), ('\u{10f4}', ['\u{1cb4}', '\u{0}', '\u{0}']),
+    ('\u{10f5}', ['\u{1cb5}', '\u{0}', '\u{0}']), ('\u{10f6}', ['\u{1cb6}', '\u{0}', '\u{0}']),
+    ('\u{10f7}', ['\u{1cb7}', '\u{0}', '\u{0}']), ('\u{10f8}', ['\u{1cb8}', '\u{0}', '\u{0}']),
+    ('\u{10f9}', ['\u{1cb9}', '\u{0}', '\u{0}']), ('\u{10fa}', ['\u{1cba}', '\u{0}', '\u{0}']),
+    ('\u{10fd}', ['\u{1cbd}', '\u{0}', '\u{0}']), ('\u{10fe}', ['\u{1cbe}', '\u{0}', '\u{0}']),
+    ('\u{10ff}', ['\u{1cbf}', '\u{0}', '\u{0}']), ('\u{13f8}', ['\u{13f0}', '\u{0}', '\u{0}']),
+    ('\u{13f9}', ['\u{13f1}', '\u{0}', '\u{0}']), ('\u{13fa}', ['\u{13f2}', '\u{0}', '\u{0}']),
+    ('\u{13fb}', ['\u{13f3}', '\u{0}', '\u{0}']), ('\u{13fc}', ['\u{13f4}', '\u{0}', '\u{0}']),
+    ('\u{13fd}', ['\u{13f5}', '\u{0}', '\u{0}']), ('\u{1c80}', ['\u{412}', '\u{0}', '\u{0}']),
+    ('\u{1c81}', ['\u{414}', '\u{0}', '\u{0}']), ('\u{1c82}', ['\u{41e}', '\u{0}', '\u{0}']),
+    ('\u{1c83}', ['\u{421}', '\u{0}', '\u{0}']), ('\u{1c84}', ['\u{422}', '\u{0}', '\u{0}']),
+    ('\u{1c85}', ['\u{422}', '\u{0}', '\u{0}']), ('\u{1c86}', ['\u{42a}', '\u{0}', '\u{0}']),
+    ('\u{1c87}', ['\u{462}', '\u{0}', '\u{0}']), ('\u{1c88}', ['\u{a64a}', '\u{0}', '\u{0}']),
+    ('\u{1c8a}', ['\u{1c89}', '\u{0}', '\u{0}']), ('\u{1d79}', ['\u{a77d}', '\u{0}', '\u{0}']),
+    ('\u{1d7d}', ['\u{2c63}', '\u{0}', '\u{0}']), ('\u{1d8e}', ['\u{a7c6}', '\u{0}', '\u{0}']),
+    ('\u{1e01}', ['\u{1e00}', '\u{0}', '\u{0}']), ('\u{1e03}', ['\u{1e02}', '\u{0}', '\u{0}']),
+    ('\u{1e05}', ['\u{1e04}', '\u{0}', '\u{0}']), ('\u{1e07}', ['\u{1e06}', '\u{0}', '\u{0}']),
+    ('\u{1e09}', ['\u{1e08}', '\u{0}', '\u{0}']), ('\u{1e0b}', ['\u{1e0a}', '\u{0}', '\u{0}']),
+    ('\u{1e0d}', ['\u{1e0c}', '\u{0}', '\u{0}']), ('\u{1e0f}', ['\u{1e0e}', '\u{0}', '\u{0}']),
+    ('\u{1e11}', ['\u{1e10}', '\u{0}', '\u{0}']), ('\u{1e13}', ['\u{1e12}', '\u{0}', '\u{0}']),
+    ('\u{1e15}', ['\u{1e14}', '\u{0}', '\u{0}']), ('\u{1e17}', ['\u{1e16}', '\u{0}', '\u{0}']),
+    ('\u{1e19}', ['\u{1e18}', '\u{0}', '\u{0}']), ('\u{1e1b}', ['\u{1e1a}', '\u{0}', '\u{0}']),
+    ('\u{1e1d}', ['\u{1e1c}', '\u{0}', '\u{0}']), ('\u{1e1f}', ['\u{1e1e}', '\u{0}', '\u{0}']),
+    ('\u{1e21}', ['\u{1e20}', '\u{0}', '\u{0}']), ('\u{1e23}', ['\u{1e22}', '\u{0}', '\u{0}']),
+    ('\u{1e25}', ['\u{1e24}', '\u{0}', '\u{0}']), ('\u{1e27}', ['\u{1e26}', '\u{0}', '\u{0}']),
+    ('\u{1e29}', ['\u{1e28}', '\u{0}', '\u{0}']), ('\u{1e2b}', ['\u{1e2a}', '\u{0}', '\u{0}']),
+    ('\u{1e2d}', ['\u{1e2c}', '\u{0}', '\u{0}']), ('\u{1e2f}', ['\u{1e2e}', '\u{0}', '\u{0}']),
+    ('\u{1e31}', ['\u{1e30}', '\u{0}', '\u{0}']), ('\u{1e33}', ['\u{1e32}', '\u{0}', '\u{0}']),
+    ('\u{1e35}', ['\u{1e34}', '\u{0}', '\u{0}']), ('\u{1e37}', ['\u{1e36}', '\u{0}', '\u{0}']),
+    ('\u{1e39}', ['\u{1e38}', '\u{0}', '\u{0}']), ('\u{1e3b}', ['\u{1e3a}', '\u{0}', '\u{0}']),
+    ('\u{1e3d}', ['\u{1e3c}', '\u{0}', '\u{0}']), ('\u{1e3f}', ['\u{1e3e}', '\u{0}', '\u{0}']),
+    ('\u{1e41}', ['\u{1e40}', '\u{0}', '\u{0}']), ('\u{1e43}', ['\u{1e42}', '\u{0}', '\u{0}']),
+    ('\u{1e45}', ['\u{1e44}', '\u{0}', '\u{0}']), ('\u{1e47}', ['\u{1e46}', '\u{0}', '\u{0}']),
+    ('\u{1e49}', ['\u{1e48}', '\u{0}', '\u{0}']), ('\u{1e4b}', ['\u{1e4a}', '\u{0}', '\u{0}']),
+    ('\u{1e4d}', ['\u{1e4c}', '\u{0}', '\u{0}']), ('\u{1e4f}', ['\u{1e4e}', '\u{0}', '\u{0}']),
+    ('\u{1e51}', ['\u{1e50}', '\u{0}', '\u{0}']), ('\u{1e53}', ['\u{1e52}', '\u{0}', '\u{0}']),
+    ('\u{1e55}', ['\u{1e54}', '\u{0}', '\u{0}']), ('\u{1e57}', ['\u{1e56}', '\u{0}', '\u{0}']),
+    ('\u{1e59}', ['\u{1e58}', '\u{0}', '\u{0}']), ('\u{1e5b}', ['\u{1e5a}', '\u{0}', '\u{0}']),
+    ('\u{1e5d}', ['\u{1e5c}', '\u{0}', '\u{0}']), ('\u{1e5f}', ['\u{1e5e}', '\u{0}', '\u{0}']),
+    ('\u{1e61}', ['\u{1e60}', '\u{0}', '\u{0}']), ('\u{1e63}', ['\u{1e62}', '\u{0}', '\u{0}']),
+    ('\u{1e65}', ['\u{1e64}', '\u{0}', '\u{0}']), ('\u{1e67}', ['\u{1e66}', '\u{0}', '\u{0}']),
+    ('\u{1e69}', ['\u{1e68}', '\u{0}', '\u{0}']), ('\u{1e6b}', ['\u{1e6a}', '\u{0}', '\u{0}']),
+    ('\u{1e6d}', ['\u{1e6c}', '\u{0}', '\u{0}']), ('\u{1e6f}', ['\u{1e6e}', '\u{0}', '\u{0}']),
+    ('\u{1e71}', ['\u{1e70}', '\u{0}', '\u{0}']), ('\u{1e73}', ['\u{1e72}', '\u{0}', '\u{0}']),
+    ('\u{1e75}', ['\u{1e74}', '\u{0}', '\u{0}']), ('\u{1e77}', ['\u{1e76}', '\u{0}', '\u{0}']),
+    ('\u{1e79}', ['\u{1e78}', '\u{0}', '\u{0}']), ('\u{1e7b}', ['\u{1e7a}', '\u{0}', '\u{0}']),
+    ('\u{1e7d}', ['\u{1e7c}', '\u{0}', '\u{0}']), ('\u{1e7f}', ['\u{1e7e}', '\u{0}', '\u{0}']),
+    ('\u{1e81}', ['\u{1e80}', '\u{0}', '\u{0}']), ('\u{1e83}', ['\u{1e82}', '\u{0}', '\u{0}']),
+    ('\u{1e85}', ['\u{1e84}', '\u{0}', '\u{0}']), ('\u{1e87}', ['\u{1e86}', '\u{0}', '\u{0}']),
+    ('\u{1e89}', ['\u{1e88}', '\u{0}', '\u{0}']), ('\u{1e8b}', ['\u{1e8a}', '\u{0}', '\u{0}']),
+    ('\u{1e8d}', ['\u{1e8c}', '\u{0}', '\u{0}']), ('\u{1e8f}', ['\u{1e8e}', '\u{0}', '\u{0}']),
+    ('\u{1e91}', ['\u{1e90}', '\u{0}', '\u{0}']), ('\u{1e93}', ['\u{1e92}', '\u{0}', '\u{0}']),
+    ('\u{1e95}', ['\u{1e94}', '\u{0}', '\u{0}']), ('\u{1e96}', ['H', '\u{331}', '\u{0}']),
+    ('\u{1e97}', ['T', '\u{308}', '\u{0}']), ('\u{1e98}', ['W', '\u{30a}', '\u{0}']),
+    ('\u{1e99}', ['Y', '\u{30a}', '\u{0}']), ('\u{1e9a}', ['A', '\u{2be}', '\u{0}']),
+    ('\u{1e9b}', ['\u{1e60}', '\u{0}', '\u{0}']), ('\u{1ea1}', ['\u{1ea0}', '\u{0}', '\u{0}']),
+    ('\u{1ea3}', ['\u{1ea2}', '\u{0}', '\u{0}']), ('\u{1ea5}', ['\u{1ea4}', '\u{0}', '\u{0}']),
+    ('\u{1ea7}', ['\u{1ea6}', '\u{0}', '\u{0}']), ('\u{1ea9}', ['\u{1ea8}', '\u{0}', '\u{0}']),
+    ('\u{1eab}', ['\u{1eaa}', '\u{0}', '\u{0}']), ('\u{1ead}', ['\u{1eac}', '\u{0}', '\u{0}']),
+    ('\u{1eaf}', ['\u{1eae}', '\u{0}', '\u{0}']), ('\u{1eb1}', ['\u{1eb0}', '\u{0}', '\u{0}']),
+    ('\u{1eb3}', ['\u{1eb2}', '\u{0}', '\u{0}']), ('\u{1eb5}', ['\u{1eb4}', '\u{0}', '\u{0}']),
+    ('\u{1eb7}', ['\u{1eb6}', '\u{0}', '\u{0}']), ('\u{1eb9}', ['\u{1eb8}', '\u{0}', '\u{0}']),
+    ('\u{1ebb}', ['\u{1eba}', '\u{0}', '\u{0}']), ('\u{1ebd}', ['\u{1ebc}', '\u{0}', '\u{0}']),
+    ('\u{1ebf}', ['\u{1ebe}', '\u{0}', '\u{0}']), ('\u{1ec1}', ['\u{1ec0}', '\u{0}', '\u{0}']),
+    ('\u{1ec3}', ['\u{1ec2}', '\u{0}', '\u{0}']), ('\u{1ec5}', ['\u{1ec4}', '\u{0}', '\u{0}']),
+    ('\u{1ec7}', ['\u{1ec6}', '\u{0}', '\u{0}']), ('\u{1ec9}', ['\u{1ec8}', '\u{0}', '\u{0}']),
+    ('\u{1ecb}', ['\u{1eca}', '\u{0}', '\u{0}']), ('\u{1ecd}', ['\u{1ecc}', '\u{0}', '\u{0}']),
+    ('\u{1ecf}', ['\u{1ece}', '\u{0}', '\u{0}']), ('\u{1ed1}', ['\u{1ed0}', '\u{0}', '\u{0}']),
+    ('\u{1ed3}', ['\u{1ed2}', '\u{0}', '\u{0}']), ('\u{1ed5}', ['\u{1ed4}', '\u{0}', '\u{0}']),
+    ('\u{1ed7}', ['\u{1ed6}', '\u{0}', '\u{0}']), ('\u{1ed9}', ['\u{1ed8}', '\u{0}', '\u{0}']),
+    ('\u{1edb}', ['\u{1eda}', '\u{0}', '\u{0}']), ('\u{1edd}', ['\u{1edc}', '\u{0}', '\u{0}']),
+    ('\u{1edf}', ['\u{1ede}', '\u{0}', '\u{0}']), ('\u{1ee1}', ['\u{1ee0}', '\u{0}', '\u{0}']),
+    ('\u{1ee3}', ['\u{1ee2}', '\u{0}', '\u{0}']), ('\u{1ee5}', ['\u{1ee4}', '\u{0}', '\u{0}']),
+    ('\u{1ee7}', ['\u{1ee6}', '\u{0}', '\u{0}']), ('\u{1ee9}', ['\u{1ee8}', '\u{0}', '\u{0}']),
+    ('\u{1eeb}', ['\u{1eea}', '\u{0}', '\u{0}']), ('\u{1eed}', ['\u{1eec}', '\u{0}', '\u{0}']),
+    ('\u{1eef}', ['\u{1eee}', '\u{0}', '\u{0}']), ('\u{1ef1}', ['\u{1ef0}', '\u{0}', '\u{0}']),
+    ('\u{1ef3}', ['\u{1ef2}', '\u{0}', '\u{0}']), ('\u{1ef5}', ['\u{1ef4}', '\u{0}', '\u{0}']),
+    ('\u{1ef7}', ['\u{1ef6}', '\u{0}', '\u{0}']), ('\u{1ef9}', ['\u{1ef8}', '\u{0}', '\u{0}']),
+    ('\u{1efb}', ['\u{1efa}', '\u{0}', '\u{0}']), ('\u{1efd}', ['\u{1efc}', '\u{0}', '\u{0}']),
+    ('\u{1eff}', ['\u{1efe}', '\u{0}', '\u{0}']), ('\u{1f00}', ['\u{1f08}', '\u{0}', '\u{0}']),
+    ('\u{1f01}', ['\u{1f09}', '\u{0}', '\u{0}']), ('\u{1f02}', ['\u{1f0a}', '\u{0}', '\u{0}']),
+    ('\u{1f03}', ['\u{1f0b}', '\u{0}', '\u{0}']), ('\u{1f04}', ['\u{1f0c}', '\u{0}', '\u{0}']),
+    ('\u{1f05}', ['\u{1f0d}', '\u{0}', '\u{0}']), ('\u{1f06}', ['\u{1f0e}', '\u{0}', '\u{0}']),
+    ('\u{1f07}', ['\u{1f0f}', '\u{0}', '\u{0}']), ('\u{1f10}', ['\u{1f18}', '\u{0}', '\u{0}']),
+    ('\u{1f11}', ['\u{1f19}', '\u{0}', '\u{0}']), ('\u{1f12}', ['\u{1f1a}', '\u{0}', '\u{0}']),
+    ('\u{1f13}', ['\u{1f1b}', '\u{0}', '\u{0}']), ('\u{1f14}', ['\u{1f1c}', '\u{0}', '\u{0}']),
+    ('\u{1f15}', ['\u{1f1d}', '\u{0}', '\u{0}']), ('\u{1f20}', ['\u{1f28}', '\u{0}', '\u{0}']),
+    ('\u{1f21}', ['\u{1f29}', '\u{0}', '\u{0}']), ('\u{1f22}', ['\u{1f2a}', '\u{0}', '\u{0}']),
+    ('\u{1f23}', ['\u{1f2b}', '\u{0}', '\u{0}']), ('\u{1f24}', ['\u{1f2c}', '\u{0}', '\u{0}']),
+    ('\u{1f25}', ['\u{1f2d}', '\u{0}', '\u{0}']), ('\u{1f26}', ['\u{1f2e}', '\u{0}', '\u{0}']),
+    ('\u{1f27}', ['\u{1f2f}', '\u{0}', '\u{0}']), ('\u{1f30}', ['\u{1f38}', '\u{0}', '\u{0}']),
+    ('\u{1f31}', ['\u{1f39}', '\u{0}', '\u{0}']), ('\u{1f32}', ['\u{1f3a}', '\u{0}', '\u{0}']),
+    ('\u{1f33}', ['\u{1f3b}', '\u{0}', '\u{0}']), ('\u{1f34}', ['\u{1f3c}', '\u{0}', '\u{0}']),
+    ('\u{1f35}', ['\u{1f3d}', '\u{0}', '\u{0}']), ('\u{1f36}', ['\u{1f3e}', '\u{0}', '\u{0}']),
+    ('\u{1f37}', ['\u{1f3f}', '\u{0}', '\u{0}']), ('\u{1f40}', ['\u{1f48}', '\u{0}', '\u{0}']),
+    ('\u{1f41}', ['\u{1f49}', '\u{0}', '\u{0}']), ('\u{1f42}', ['\u{1f4a}', '\u{0}', '\u{0}']),
+    ('\u{1f43}', ['\u{1f4b}', '\u{0}', '\u{0}']), ('\u{1f44}', ['\u{1f4c}', '\u{0}', '\u{0}']),
+    ('\u{1f45}', ['\u{1f4d}', '\u{0}', '\u{0}']), ('\u{1f50}', ['\u{3a5}', '\u{313}', '\u{0}']),
+    ('\u{1f51}', ['\u{1f59}', '\u{0}', '\u{0}']),
+    ('\u{1f52}', ['\u{3a5}', '\u{313}', '\u{300}']),
+    ('\u{1f53}', ['\u{1f5b}', '\u{0}', '\u{0}']),
+    ('\u{1f54}', ['\u{3a5}', '\u{313}', '\u{301}']),
+    ('\u{1f55}', ['\u{1f5d}', '\u{0}', '\u{0}']),
+    ('\u{1f56}', ['\u{3a5}', '\u{313}', '\u{342}']),
+    ('\u{1f57}', ['\u{1f5f}', '\u{0}', '\u{0}']), ('\u{1f60}', ['\u{1f68}', '\u{0}', '\u{0}']),
+    ('\u{1f61}', ['\u{1f69}', '\u{0}', '\u{0}']), ('\u{1f62}', ['\u{1f6a}', '\u{0}', '\u{0}']),
+    ('\u{1f63}', ['\u{1f6b}', '\u{0}', '\u{0}']), ('\u{1f64}', ['\u{1f6c}', '\u{0}', '\u{0}']),
+    ('\u{1f65}', ['\u{1f6d}', '\u{0}', '\u{0}']), ('\u{1f66}', ['\u{1f6e}', '\u{0}', '\u{0}']),
+    ('\u{1f67}', ['\u{1f6f}', '\u{0}', '\u{0}']), ('\u{1f70}', ['\u{1fba}', '\u{0}', '\u{0}']),
+    ('\u{1f71}', ['\u{1fbb}', '\u{0}', '\u{0}']), ('\u{1f72}', ['\u{1fc8}', '\u{0}', '\u{0}']),
+    ('\u{1f73}', ['\u{1fc9}', '\u{0}', '\u{0}']), ('\u{1f74}', ['\u{1fca}', '\u{0}', '\u{0}']),
+    ('\u{1f75}', ['\u{1fcb}', '\u{0}', '\u{0}']), ('\u{1f76}', ['\u{1fda}', '\u{0}', '\u{0}']),
+    ('\u{1f77}', ['\u{1fdb}', '\u{0}', '\u{0}']), ('\u{1f78}', ['\u{1ff8}', '\u{0}', '\u{0}']),
+    ('\u{1f79}', ['\u{1ff9}', '\u{0}', '\u{0}']), ('\u{1f7a}', ['\u{1fea}', '\u{0}', '\u{0}']),
+    ('\u{1f7b}', ['\u{1feb}', '\u{0}', '\u{0}']), ('\u{1f7c}', ['\u{1ffa}', '\u{0}', '\u{0}']),
+    ('\u{1f7d}', ['\u{1ffb}', '\u{0}', '\u{0}']),
+    ('\u{1f80}', ['\u{1f08}', '\u{399}', '\u{0}']),
+    ('\u{1f81}', ['\u{1f09}', '\u{399}', '\u{0}']),
+    ('\u{1f82}', ['\u{1f0a}', '\u{399}', '\u{0}']),
+    ('\u{1f83}', ['\u{1f0b}', '\u{399}', '\u{0}']),
+    ('\u{1f84}', ['\u{1f0c}', '\u{399}', '\u{0}']),
+    ('\u{1f85}', ['\u{1f0d}', '\u{399}', '\u{0}']),
+    ('\u{1f86}', ['\u{1f0e}', '\u{399}', '\u{0}']),
+    ('\u{1f87}', ['\u{1f0f}', '\u{399}', '\u{0}']),
+    ('\u{1f88}', ['\u{1f08}', '\u{399}', '\u{0}']),
+    ('\u{1f89}', ['\u{1f09}', '\u{399}', '\u{0}']),
+    ('\u{1f8a}', ['\u{1f0a}', '\u{399}', '\u{0}']),
+    ('\u{1f8b}', ['\u{1f0b}', '\u{399}', '\u{0}']),
+    ('\u{1f8c}', ['\u{1f0c}', '\u{399}', '\u{0}']),
+    ('\u{1f8d}', ['\u{1f0d}', '\u{399}', '\u{0}']),
+    ('\u{1f8e}', ['\u{1f0e}', '\u{399}', '\u{0}']),
+    ('\u{1f8f}', ['\u{1f0f}', '\u{399}', '\u{0}']),
+    ('\u{1f90}', ['\u{1f28}', '\u{399}', '\u{0}']),
+    ('\u{1f91}', ['\u{1f29}', '\u{399}', '\u{0}']),
+    ('\u{1f92}', ['\u{1f2a}', '\u{399}', '\u{0}']),
+    ('\u{1f93}', ['\u{1f2b}', '\u{399}', '\u{0}']),
+    ('\u{1f94}', ['\u{1f2c}', '\u{399}', '\u{0}']),
+    ('\u{1f95}', ['\u{1f2d}', '\u{399}', '\u{0}']),
+    ('\u{1f96}', ['\u{1f2e}', '\u{399}', '\u{0}']),
+    ('\u{1f97}', ['\u{1f2f}', '\u{399}', '\u{0}']),
+    ('\u{1f98}', ['\u{1f28}', '\u{399}', '\u{0}']),
+    ('\u{1f99}', ['\u{1f29}', '\u{399}', '\u{0}']),
+    ('\u{1f9a}', ['\u{1f2a}', '\u{399}', '\u{0}']),
+    ('\u{1f9b}', ['\u{1f2b}', '\u{399}', '\u{0}']),
+    ('\u{1f9c}', ['\u{1f2c}', '\u{399}', '\u{0}']),
+    ('\u{1f9d}', ['\u{1f2d}', '\u{399}', '\u{0}']),
+    ('\u{1f9e}', ['\u{1f2e}', '\u{399}', '\u{0}']),
+    ('\u{1f9f}', ['\u{1f2f}', '\u{399}', '\u{0}']),
+    ('\u{1fa0}', ['\u{1f68}', '\u{399}', '\u{0}']),
+    ('\u{1fa1}', ['\u{1f69}', '\u{399}', '\u{0}']),
+    ('\u{1fa2}', ['\u{1f6a}', '\u{399}', '\u{0}']),
+    ('\u{1fa3}', ['\u{1f6b}', '\u{399}', '\u{0}']),
+    ('\u{1fa4}', ['\u{1f6c}', '\u{399}', '\u{0}']),
+    ('\u{1fa5}', ['\u{1f6d}', '\u{399}', '\u{0}']),
+    ('\u{1fa6}', ['\u{1f6e}', '\u{399}', '\u{0}']),
+    ('\u{1fa7}', ['\u{1f6f}', '\u{399}', '\u{0}']),
+    ('\u{1fa8}', ['\u{1f68}', '\u{399}', '\u{0}']),
+    ('\u{1fa9}', ['\u{1f69}', '\u{399}', '\u{0}']),
+    ('\u{1faa}', ['\u{1f6a}', '\u{399}', '\u{0}']),
+    ('\u{1fab}', ['\u{1f6b}', '\u{399}', '\u{0}']),
+    ('\u{1fac}', ['\u{1f6c}', '\u{399}', '\u{0}']),
+    ('\u{1fad}', ['\u{1f6d}', '\u{399}', '\u{0}']),
+    ('\u{1fae}', ['\u{1f6e}', '\u{399}', '\u{0}']),
+    ('\u{1faf}', ['\u{1f6f}', '\u{399}', '\u{0}']),
+    ('\u{1fb0}', ['\u{1fb8}', '\u{0}', '\u{0}']), ('\u{1fb1}', ['\u{1fb9}', '\u{0}', '\u{0}']),
+    ('\u{1fb2}', ['\u{1fba}', '\u{399}', '\u{0}']),
+    ('\u{1fb3}', ['\u{391}', '\u{399}', '\u{0}']),
+    ('\u{1fb4}', ['\u{386}', '\u{399}', '\u{0}']),
+    ('\u{1fb6}', ['\u{391}', '\u{342}', '\u{0}']),
+    ('\u{1fb7}', ['\u{391}', '\u{342}', '\u{399}']),
+    ('\u{1fbc}', ['\u{391}', '\u{399}', '\u{0}']), ('\u{1fbe}', ['\u{399}', '\u{0}', '\u{0}']),
+    ('\u{1fc2}', ['\u{1fca}', '\u{399}', '\u{0}']),
+    ('\u{1fc3}', ['\u{397}', '\u{399}', '\u{0}']),
+    ('\u{1fc4}', ['\u{389}', '\u{399}', '\u{0}']),
+    ('\u{1fc6}', ['\u{397}', '\u{342}', '\u{0}']),
+    ('\u{1fc7}', ['\u{397}', '\u{342}', '\u{399}']),
+    ('\u{1fcc}', ['\u{397}', '\u{399}', '\u{0}']), ('\u{1fd0}', ['\u{1fd8}', '\u{0}', '\u{0}']),
+    ('\u{1fd1}', ['\u{1fd9}', '\u{0}', '\u{0}']),
+    ('\u{1fd2}', ['\u{399}', '\u{308}', '\u{300}']),
+    ('\u{1fd3}', ['\u{399}', '\u{308}', '\u{301}']),
+    ('\u{1fd6}', ['\u{399}', '\u{342}', '\u{0}']),
+    ('\u{1fd7}', ['\u{399}', '\u{308}', '\u{342}']),
+    ('\u{1fe0}', ['\u{1fe8}', '\u{0}', '\u{0}']), ('\u{1fe1}', ['\u{1fe9}', '\u{0}', '\u{0}']),
+    ('\u{1fe2}', ['\u{3a5}', '\u{308}', '\u{300}']),
+    ('\u{1fe3}', ['\u{3a5}', '\u{308}', '\u{301}']),
+    ('\u{1fe4}', ['\u{3a1}', '\u{313}', '\u{0}']), ('\u{1fe5}', ['\u{1fec}', '\u{0}', '\u{0}']),
+    ('\u{1fe6}', ['\u{3a5}', '\u{342}', '\u{0}']),
+    ('\u{1fe7}', ['\u{3a5}', '\u{308}', '\u{342}']),
+    ('\u{1ff2}', ['\u{1ffa}', '\u{399}', '\u{0}']),
+    ('\u{1ff3}', ['\u{3a9}', '\u{399}', '\u{0}']),
+    ('\u{1ff4}', ['\u{38f}', '\u{399}', '\u{0}']),
+    ('\u{1ff6}', ['\u{3a9}', '\u{342}', '\u{0}']),
+    ('\u{1ff7}', ['\u{3a9}', '\u{342}', '\u{399}']),
+    ('\u{1ffc}', ['\u{3a9}', '\u{399}', '\u{0}']), ('\u{214e}', ['\u{2132}', '\u{0}', '\u{0}']),
+    ('\u{2170}', ['\u{2160}', '\u{0}', '\u{0}']), ('\u{2171}', ['\u{2161}', '\u{0}', '\u{0}']),
+    ('\u{2172}', ['\u{2162}', '\u{0}', '\u{0}']), ('\u{2173}', ['\u{2163}', '\u{0}', '\u{0}']),
+    ('\u{2174}', ['\u{2164}', '\u{0}', '\u{0}']), ('\u{2175}', ['\u{2165}', '\u{0}', '\u{0}']),
+    ('\u{2176}', ['\u{2166}', '\u{0}', '\u{0}']), ('\u{2177}', ['\u{2167}', '\u{0}', '\u{0}']),
+    ('\u{2178}', ['\u{2168}', '\u{0}', '\u{0}']), ('\u{2179}', ['\u{2169}', '\u{0}', '\u{0}']),
+    ('\u{217a}', ['\u{216a}', '\u{0}', '\u{0}']), ('\u{217b}', ['\u{216b}', '\u{0}', '\u{0}']),
+    ('\u{217c}', ['\u{216c}', '\u{0}', '\u{0}']), ('\u{217d}', ['\u{216d}', '\u{0}', '\u{0}']),
+    ('\u{217e}', ['\u{216e}', '\u{0}', '\u{0}']), ('\u{217f}', ['\u{216f}', '\u{0}', '\u{0}']),
+    ('\u{2184}', ['\u{2183}', '\u{0}', '\u{0}']), ('\u{24d0}', ['\u{24b6}', '\u{0}', '\u{0}']),
+    ('\u{24d1}', ['\u{24b7}', '\u{0}', '\u{0}']), ('\u{24d2}', ['\u{24b8}', '\u{0}', '\u{0}']),
+    ('\u{24d3}', ['\u{24b9}', '\u{0}', '\u{0}']), ('\u{24d4}', ['\u{24ba}', '\u{0}', '\u{0}']),
+    ('\u{24d5}', ['\u{24bb}', '\u{0}', '\u{0}']), ('\u{24d6}', ['\u{24bc}', '\u{0}', '\u{0}']),
+    ('\u{24d7}', ['\u{24bd}', '\u{0}', '\u{0}']), ('\u{24d8}', ['\u{24be}', '\u{0}', '\u{0}']),
+    ('\u{24d9}', ['\u{24bf}', '\u{0}', '\u{0}']), ('\u{24da}', ['\u{24c0}', '\u{0}', '\u{0}']),
+    ('\u{24db}', ['\u{24c1}', '\u{0}', '\u{0}']), ('\u{24dc}', ['\u{24c2}', '\u{0}', '\u{0}']),
+    ('\u{24dd}', ['\u{24c3}', '\u{0}', '\u{0}']), ('\u{24de}', ['\u{24c4}', '\u{0}', '\u{0}']),
+    ('\u{24df}', ['\u{24c5}', '\u{0}', '\u{0}']), ('\u{24e0}', ['\u{24c6}', '\u{0}', '\u{0}']),
+    ('\u{24e1}', ['\u{24c7}', '\u{0}', '\u{0}']), ('\u{24e2}', ['\u{24c8}', '\u{0}', '\u{0}']),
+    ('\u{24e3}', ['\u{24c9}', '\u{0}', '\u{0}']), ('\u{24e4}', ['\u{24ca}', '\u{0}', '\u{0}']),
+    ('\u{24e5}', ['\u{24cb}', '\u{0}', '\u{0}']), ('\u{24e6}', ['\u{24cc}', '\u{0}', '\u{0}']),
+    ('\u{24e7}', ['\u{24cd}', '\u{0}', '\u{0}']), ('\u{24e8}', ['\u{24ce}', '\u{0}', '\u{0}']),
+    ('\u{24e9}', ['\u{24cf}', '\u{0}', '\u{0}']), ('\u{2c30}', ['\u{2c00}', '\u{0}', '\u{0}']),
+    ('\u{2c31}', ['\u{2c01}', '\u{0}', '\u{0}']), ('\u{2c32}', ['\u{2c02}', '\u{0}', '\u{0}']),
+    ('\u{2c33}', ['\u{2c03}', '\u{0}', '\u{0}']), ('\u{2c34}', ['\u{2c04}', '\u{0}', '\u{0}']),
+    ('\u{2c35}', ['\u{2c05}', '\u{0}', '\u{0}']), ('\u{2c36}', ['\u{2c06}', '\u{0}', '\u{0}']),
+    ('\u{2c37}', ['\u{2c07}', '\u{0}', '\u{0}']), ('\u{2c38}', ['\u{2c08}', '\u{0}', '\u{0}']),
+    ('\u{2c39}', ['\u{2c09}', '\u{0}', '\u{0}']), ('\u{2c3a}', ['\u{2c0a}', '\u{0}', '\u{0}']),
+    ('\u{2c3b}', ['\u{2c0b}', '\u{0}', '\u{0}']), ('\u{2c3c}', ['\u{2c0c}', '\u{0}', '\u{0}']),
+    ('\u{2c3d}', ['\u{2c0d}', '\u{0}', '\u{0}']), ('\u{2c3e}', ['\u{2c0e}', '\u{0}', '\u{0}']),
+    ('\u{2c3f}', ['\u{2c0f}', '\u{0}', '\u{0}']), ('\u{2c40}', ['\u{2c10}', '\u{0}', '\u{0}']),
+    ('\u{2c41}', ['\u{2c11}', '\u{0}', '\u{0}']), ('\u{2c42}', ['\u{2c12}', '\u{0}', '\u{0}']),
+    ('\u{2c43}', ['\u{2c13}', '\u{0}', '\u{0}']), ('\u{2c44}', ['\u{2c14}', '\u{0}', '\u{0}']),
+    ('\u{2c45}', ['\u{2c15}', '\u{0}', '\u{0}']), ('\u{2c46}', ['\u{2c16}', '\u{0}', '\u{0}']),
+    ('\u{2c47}', ['\u{2c17}', '\u{0}', '\u{0}']), ('\u{2c48}', ['\u{2c18}', '\u{0}', '\u{0}']),
+    ('\u{2c49}', ['\u{2c19}', '\u{0}', '\u{0}']), ('\u{2c4a}', ['\u{2c1a}', '\u{0}', '\u{0}']),
+    ('\u{2c4b}', ['\u{2c1b}', '\u{0}', '\u{0}']), ('\u{2c4c}', ['\u{2c1c}', '\u{0}', '\u{0}']),
+    ('\u{2c4d}', ['\u{2c1d}', '\u{0}', '\u{0}']), ('\u{2c4e}', ['\u{2c1e}', '\u{0}', '\u{0}']),
+    ('\u{2c4f}', ['\u{2c1f}', '\u{0}', '\u{0}']), ('\u{2c50}', ['\u{2c20}', '\u{0}', '\u{0}']),
+    ('\u{2c51}', ['\u{2c21}', '\u{0}', '\u{0}']), ('\u{2c52}', ['\u{2c22}', '\u{0}', '\u{0}']),
+    ('\u{2c53}', ['\u{2c23}', '\u{0}', '\u{0}']), ('\u{2c54}', ['\u{2c24}', '\u{0}', '\u{0}']),
+    ('\u{2c55}', ['\u{2c25}', '\u{0}', '\u{0}']), ('\u{2c56}', ['\u{2c26}', '\u{0}', '\u{0}']),
+    ('\u{2c57}', ['\u{2c27}', '\u{0}', '\u{0}']), ('\u{2c58}', ['\u{2c28}', '\u{0}', '\u{0}']),
+    ('\u{2c59}', ['\u{2c29}', '\u{0}', '\u{0}']), ('\u{2c5a}', ['\u{2c2a}', '\u{0}', '\u{0}']),
+    ('\u{2c5b}', ['\u{2c2b}', '\u{0}', '\u{0}']), ('\u{2c5c}', ['\u{2c2c}', '\u{0}', '\u{0}']),
+    ('\u{2c5d}', ['\u{2c2d}', '\u{0}', '\u{0}']), ('\u{2c5e}', ['\u{2c2e}', '\u{0}', '\u{0}']),
+    ('\u{2c5f}', ['\u{2c2f}', '\u{0}', '\u{0}']), ('\u{2c61}', ['\u{2c60}', '\u{0}', '\u{0}']),
+    ('\u{2c65}', ['\u{23a}', '\u{0}', '\u{0}']), ('\u{2c66}', ['\u{23e}', '\u{0}', '\u{0}']),
+    ('\u{2c68}', ['\u{2c67}', '\u{0}', '\u{0}']), ('\u{2c6a}', ['\u{2c69}', '\u{0}', '\u{0}']),
+    ('\u{2c6c}', ['\u{2c6b}', '\u{0}', '\u{0}']), ('\u{2c73}', ['\u{2c72}', '\u{0}', '\u{0}']),
+    ('\u{2c76}', ['\u{2c75}', '\u{0}', '\u{0}']), ('\u{2c81}', ['\u{2c80}', '\u{0}', '\u{0}']),
+    ('\u{2c83}', ['\u{2c82}', '\u{0}', '\u{0}']), ('\u{2c85}', ['\u{2c84}', '\u{0}', '\u{0}']),
+    ('\u{2c87}', ['\u{2c86}', '\u{0}', '\u{0}']), ('\u{2c89}', ['\u{2c88}', '\u{0}', '\u{0}']),
+    ('\u{2c8b}', ['\u{2c8a}', '\u{0}', '\u{0}']), ('\u{2c8d}', ['\u{2c8c}', '\u{0}', '\u{0}']),
+    ('\u{2c8f}', ['\u{2c8e}', '\u{0}', '\u{0}']), ('\u{2c91}', ['\u{2c90}', '\u{0}', '\u{0}']),
+    ('\u{2c93}', ['\u{2c92}', '\u{0}', '\u{0}']), ('\u{2c95}', ['\u{2c94}', '\u{0}', '\u{0}']),
+    ('\u{2c97}', ['\u{2c96}', '\u{0}', '\u{0}']), ('\u{2c99}', ['\u{2c98}', '\u{0}', '\u{0}']),
+    ('\u{2c9b}', ['\u{2c9a}', '\u{0}', '\u{0}']), ('\u{2c9d}', ['\u{2c9c}', '\u{0}', '\u{0}']),
+    ('\u{2c9f}', ['\u{2c9e}', '\u{0}', '\u{0}']), ('\u{2ca1}', ['\u{2ca0}', '\u{0}', '\u{0}']),
+    ('\u{2ca3}', ['\u{2ca2}', '\u{0}', '\u{0}']), ('\u{2ca5}', ['\u{2ca4}', '\u{0}', '\u{0}']),
+    ('\u{2ca7}', ['\u{2ca6}', '\u{0}', '\u{0}']), ('\u{2ca9}', ['\u{2ca8}', '\u{0}', '\u{0}']),
+    ('\u{2cab}', ['\u{2caa}', '\u{0}', '\u{0}']), ('\u{2cad}', ['\u{2cac}', '\u{0}', '\u{0}']),
+    ('\u{2caf}', ['\u{2cae}', '\u{0}', '\u{0}']), ('\u{2cb1}', ['\u{2cb0}', '\u{0}', '\u{0}']),
+    ('\u{2cb3}', ['\u{2cb2}', '\u{0}', '\u{0}']), ('\u{2cb5}', ['\u{2cb4}', '\u{0}', '\u{0}']),
+    ('\u{2cb7}', ['\u{2cb6}', '\u{0}', '\u{0}']), ('\u{2cb9}', ['\u{2cb8}', '\u{0}', '\u{0}']),
+    ('\u{2cbb}', ['\u{2cba}', '\u{0}', '\u{0}']), ('\u{2cbd}', ['\u{2cbc}', '\u{0}', '\u{0}']),
+    ('\u{2cbf}', ['\u{2cbe}', '\u{0}', '\u{0}']), ('\u{2cc1}', ['\u{2cc0}', '\u{0}', '\u{0}']),
+    ('\u{2cc3}', ['\u{2cc2}', '\u{0}', '\u{0}']), ('\u{2cc5}', ['\u{2cc4}', '\u{0}', '\u{0}']),
+    ('\u{2cc7}', ['\u{2cc6}', '\u{0}', '\u{0}']), ('\u{2cc9}', ['\u{2cc8}', '\u{0}', '\u{0}']),
+    ('\u{2ccb}', ['\u{2cca}', '\u{0}', '\u{0}']), ('\u{2ccd}', ['\u{2ccc}', '\u{0}', '\u{0}']),
+    ('\u{2ccf}', ['\u{2cce}', '\u{0}', '\u{0}']), ('\u{2cd1}', ['\u{2cd0}', '\u{0}', '\u{0}']),
+    ('\u{2cd3}', ['\u{2cd2}', '\u{0}', '\u{0}']), ('\u{2cd5}', ['\u{2cd4}', '\u{0}', '\u{0}']),
+    ('\u{2cd7}', ['\u{2cd6}', '\u{0}', '\u{0}']), ('\u{2cd9}', ['\u{2cd8}', '\u{0}', '\u{0}']),
+    ('\u{2cdb}', ['\u{2cda}', '\u{0}', '\u{0}']), ('\u{2cdd}', ['\u{2cdc}', '\u{0}', '\u{0}']),
+    ('\u{2cdf}', ['\u{2cde}', '\u{0}', '\u{0}']), ('\u{2ce1}', ['\u{2ce0}', '\u{0}', '\u{0}']),
+    ('\u{2ce3}', ['\u{2ce2}', '\u{0}', '\u{0}']), ('\u{2cec}', ['\u{2ceb}', '\u{0}', '\u{0}']),
+    ('\u{2cee}', ['\u{2ced}', '\u{0}', '\u{0}']), ('\u{2cf3}', ['\u{2cf2}', '\u{0}', '\u{0}']),
+    ('\u{2d00}', ['\u{10a0}', '\u{0}', '\u{0}']), ('\u{2d01}', ['\u{10a1}', '\u{0}', '\u{0}']),
+    ('\u{2d02}', ['\u{10a2}', '\u{0}', '\u{0}']), ('\u{2d03}', ['\u{10a3}', '\u{0}', '\u{0}']),
+    ('\u{2d04}', ['\u{10a4}', '\u{0}', '\u{0}']), ('\u{2d05}', ['\u{10a5}', '\u{0}', '\u{0}']),
+    ('\u{2d06}', ['\u{10a6}', '\u{0}', '\u{0}']), ('\u{2d07}', ['\u{10a7}', '\u{0}', '\u{0}']),
+    ('\u{2d08}', ['\u{10a8}', '\u{0}', '\u{0}']), ('\u{2d09}', ['\u{10a9}', '\u{0}', '\u{0}']),
+    ('\u{2d0a}', ['\u{10aa}', '\u{0}', '\u{0}']), ('\u{2d0b}', ['\u{10ab}', '\u{0}', '\u{0}']),
+    ('\u{2d0c}', ['\u{10ac}', '\u{0}', '\u{0}']), ('\u{2d0d}', ['\u{10ad}', '\u{0}', '\u{0}']),
+    ('\u{2d0e}', ['\u{10ae}', '\u{0}', '\u{0}']), ('\u{2d0f}', ['\u{10af}', '\u{0}', '\u{0}']),
+    ('\u{2d10}', ['\u{10b0}', '\u{0}', '\u{0}']), ('\u{2d11}', ['\u{10b1}', '\u{0}', '\u{0}']),
+    ('\u{2d12}', ['\u{10b2}', '\u{0}', '\u{0}']), ('\u{2d13}', ['\u{10b3}', '\u{0}', '\u{0}']),
+    ('\u{2d14}', ['\u{10b4}', '\u{0}', '\u{0}']), ('\u{2d15}', ['\u{10b5}', '\u{0}', '\u{0}']),
+    ('\u{2d16}', ['\u{10b6}', '\u{0}', '\u{0}']), ('\u{2d17}', ['\u{10b7}', '\u{0}', '\u{0}']),
+    ('\u{2d18}', ['\u{10b8}', '\u{0}', '\u{0}']), ('\u{2d19}', ['\u{10b9}', '\u{0}', '\u{0}']),
+    ('\u{2d1a}', ['\u{10ba}', '\u{0}', '\u{0}']), ('\u{2d1b}', ['\u{10bb}', '\u{0}', '\u{0}']),
+    ('\u{2d1c}', ['\u{10bc}', '\u{0}', '\u{0}']), ('\u{2d1d}', ['\u{10bd}', '\u{0}', '\u{0}']),
+    ('\u{2d1e}', ['\u{10be}', '\u{0}', '\u{0}']), ('\u{2d1f}', ['\u{10bf}', '\u{0}', '\u{0}']),
+    ('\u{2d20}', ['\u{10c0}', '\u{0}', '\u{0}']), ('\u{2d21}', ['\u{10c1}', '\u{0}', '\u{0}']),
+    ('\u{2d22}', ['\u{10c2}', '\u{0}', '\u{0}']), ('\u{2d23}', ['\u{10c3}', '\u{0}', '\u{0}']),
+    ('\u{2d24}', ['\u{10c4}', '\u{0}', '\u{0}']), ('\u{2d25}', ['\u{10c5}', '\u{0}', '\u{0}']),
+    ('\u{2d27}', ['\u{10c7}', '\u{0}', '\u{0}']), ('\u{2d2d}', ['\u{10cd}', '\u{0}', '\u{0}']),
+    ('\u{a641}', ['\u{a640}', '\u{0}', '\u{0}']), ('\u{a643}', ['\u{a642}', '\u{0}', '\u{0}']),
+    ('\u{a645}', ['\u{a644}', '\u{0}', '\u{0}']), ('\u{a647}', ['\u{a646}', '\u{0}', '\u{0}']),
+    ('\u{a649}', ['\u{a648}', '\u{0}', '\u{0}']), ('\u{a64b}', ['\u{a64a}', '\u{0}', '\u{0}']),
+    ('\u{a64d}', ['\u{a64c}', '\u{0}', '\u{0}']), ('\u{a64f}', ['\u{a64e}', '\u{0}', '\u{0}']),
+    ('\u{a651}', ['\u{a650}', '\u{0}', '\u{0}']), ('\u{a653}', ['\u{a652}', '\u{0}', '\u{0}']),
+    ('\u{a655}', ['\u{a654}', '\u{0}', '\u{0}']), ('\u{a657}', ['\u{a656}', '\u{0}', '\u{0}']),
+    ('\u{a659}', ['\u{a658}', '\u{0}', '\u{0}']), ('\u{a65b}', ['\u{a65a}', '\u{0}', '\u{0}']),
+    ('\u{a65d}', ['\u{a65c}', '\u{0}', '\u{0}']), ('\u{a65f}', ['\u{a65e}', '\u{0}', '\u{0}']),
+    ('\u{a661}', ['\u{a660}', '\u{0}', '\u{0}']), ('\u{a663}', ['\u{a662}', '\u{0}', '\u{0}']),
+    ('\u{a665}', ['\u{a664}', '\u{0}', '\u{0}']), ('\u{a667}', ['\u{a666}', '\u{0}', '\u{0}']),
+    ('\u{a669}', ['\u{a668}', '\u{0}', '\u{0}']), ('\u{a66b}', ['\u{a66a}', '\u{0}', '\u{0}']),
+    ('\u{a66d}', ['\u{a66c}', '\u{0}', '\u{0}']), ('\u{a681}', ['\u{a680}', '\u{0}', '\u{0}']),
+    ('\u{a683}', ['\u{a682}', '\u{0}', '\u{0}']), ('\u{a685}', ['\u{a684}', '\u{0}', '\u{0}']),
+    ('\u{a687}', ['\u{a686}', '\u{0}', '\u{0}']), ('\u{a689}', ['\u{a688}', '\u{0}', '\u{0}']),
+    ('\u{a68b}', ['\u{a68a}', '\u{0}', '\u{0}']), ('\u{a68d}', ['\u{a68c}', '\u{0}', '\u{0}']),
+    ('\u{a68f}', ['\u{a68e}', '\u{0}', '\u{0}']), ('\u{a691}', ['\u{a690}', '\u{0}', '\u{0}']),
+    ('\u{a693}', ['\u{a692}', '\u{0}', '\u{0}']), ('\u{a695}', ['\u{a694}', '\u{0}', '\u{0}']),
+    ('\u{a697}', ['\u{a696}', '\u{0}', '\u{0}']), ('\u{a699}', ['\u{a698}', '\u{0}', '\u{0}']),
+    ('\u{a69b}', ['\u{a69a}', '\u{0}', '\u{0}']), ('\u{a723}', ['\u{a722}', '\u{0}', '\u{0}']),
+    ('\u{a725}', ['\u{a724}', '\u{0}', '\u{0}']), ('\u{a727}', ['\u{a726}', '\u{0}', '\u{0}']),
+    ('\u{a729}', ['\u{a728}', '\u{0}', '\u{0}']), ('\u{a72b}', ['\u{a72a}', '\u{0}', '\u{0}']),
+    ('\u{a72d}', ['\u{a72c}', '\u{0}', '\u{0}']), ('\u{a72f}', ['\u{a72e}', '\u{0}', '\u{0}']),
+    ('\u{a733}', ['\u{a732}', '\u{0}', '\u{0}']), ('\u{a735}', ['\u{a734}', '\u{0}', '\u{0}']),
+    ('\u{a737}', ['\u{a736}', '\u{0}', '\u{0}']), ('\u{a739}', ['\u{a738}', '\u{0}', '\u{0}']),
+    ('\u{a73b}', ['\u{a73a}', '\u{0}', '\u{0}']), ('\u{a73d}', ['\u{a73c}', '\u{0}', '\u{0}']),
+    ('\u{a73f}', ['\u{a73e}', '\u{0}', '\u{0}']), ('\u{a741}', ['\u{a740}', '\u{0}', '\u{0}']),
+    ('\u{a743}', ['\u{a742}', '\u{0}', '\u{0}']), ('\u{a745}', ['\u{a744}', '\u{0}', '\u{0}']),
+    ('\u{a747}', ['\u{a746}', '\u{0}', '\u{0}']), ('\u{a749}', ['\u{a748}', '\u{0}', '\u{0}']),
+    ('\u{a74b}', ['\u{a74a}', '\u{0}', '\u{0}']), ('\u{a74d}', ['\u{a74c}', '\u{0}', '\u{0}']),
+    ('\u{a74f}', ['\u{a74e}', '\u{0}', '\u{0}']), ('\u{a751}', ['\u{a750}', '\u{0}', '\u{0}']),
+    ('\u{a753}', ['\u{a752}', '\u{0}', '\u{0}']), ('\u{a755}', ['\u{a754}', '\u{0}', '\u{0}']),
+    ('\u{a757}', ['\u{a756}', '\u{0}', '\u{0}']), ('\u{a759}', ['\u{a758}', '\u{0}', '\u{0}']),
+    ('\u{a75b}', ['\u{a75a}', '\u{0}', '\u{0}']), ('\u{a75d}', ['\u{a75c}', '\u{0}', '\u{0}']),
+    ('\u{a75f}', ['\u{a75e}', '\u{0}', '\u{0}']), ('\u{a761}', ['\u{a760}', '\u{0}', '\u{0}']),
+    ('\u{a763}', ['\u{a762}', '\u{0}', '\u{0}']), ('\u{a765}', ['\u{a764}', '\u{0}', '\u{0}']),
+    ('\u{a767}', ['\u{a766}', '\u{0}', '\u{0}']), ('\u{a769}', ['\u{a768}', '\u{0}', '\u{0}']),
+    ('\u{a76b}', ['\u{a76a}', '\u{0}', '\u{0}']), ('\u{a76d}', ['\u{a76c}', '\u{0}', '\u{0}']),
+    ('\u{a76f}', ['\u{a76e}', '\u{0}', '\u{0}']), ('\u{a77a}', ['\u{a779}', '\u{0}', '\u{0}']),
+    ('\u{a77c}', ['\u{a77b}', '\u{0}', '\u{0}']), ('\u{a77f}', ['\u{a77e}', '\u{0}', '\u{0}']),
+    ('\u{a781}', ['\u{a780}', '\u{0}', '\u{0}']), ('\u{a783}', ['\u{a782}', '\u{0}', '\u{0}']),
+    ('\u{a785}', ['\u{a784}', '\u{0}', '\u{0}']), ('\u{a787}', ['\u{a786}', '\u{0}', '\u{0}']),
+    ('\u{a78c}', ['\u{a78b}', '\u{0}', '\u{0}']), ('\u{a791}', ['\u{a790}', '\u{0}', '\u{0}']),
+    ('\u{a793}', ['\u{a792}', '\u{0}', '\u{0}']), ('\u{a794}', ['\u{a7c4}', '\u{0}', '\u{0}']),
+    ('\u{a797}', ['\u{a796}', '\u{0}', '\u{0}']), ('\u{a799}', ['\u{a798}', '\u{0}', '\u{0}']),
+    ('\u{a79b}', ['\u{a79a}', '\u{0}', '\u{0}']), ('\u{a79d}', ['\u{a79c}', '\u{0}', '\u{0}']),
+    ('\u{a79f}', ['\u{a79e}', '\u{0}', '\u{0}']), ('\u{a7a1}', ['\u{a7a0}', '\u{0}', '\u{0}']),
+    ('\u{a7a3}', ['\u{a7a2}', '\u{0}', '\u{0}']), ('\u{a7a5}', ['\u{a7a4}', '\u{0}', '\u{0}']),
+    ('\u{a7a7}', ['\u{a7a6}', '\u{0}', '\u{0}']), ('\u{a7a9}', ['\u{a7a8}', '\u{0}', '\u{0}']),
+    ('\u{a7b5}', ['\u{a7b4}', '\u{0}', '\u{0}']), ('\u{a7b7}', ['\u{a7b6}', '\u{0}', '\u{0}']),
+    ('\u{a7b9}', ['\u{a7b8}', '\u{0}', '\u{0}']), ('\u{a7bb}', ['\u{a7ba}', '\u{0}', '\u{0}']),
+    ('\u{a7bd}', ['\u{a7bc}', '\u{0}', '\u{0}']), ('\u{a7bf}', ['\u{a7be}', '\u{0}', '\u{0}']),
+    ('\u{a7c1}', ['\u{a7c0}', '\u{0}', '\u{0}']), ('\u{a7c3}', ['\u{a7c2}', '\u{0}', '\u{0}']),
+    ('\u{a7c8}', ['\u{a7c7}', '\u{0}', '\u{0}']), ('\u{a7ca}', ['\u{a7c9}', '\u{0}', '\u{0}']),
+    ('\u{a7cd}', ['\u{a7cc}', '\u{0}', '\u{0}']), ('\u{a7cf}', ['\u{a7ce}', '\u{0}', '\u{0}']),
+    ('\u{a7d1}', ['\u{a7d0}', '\u{0}', '\u{0}']), ('\u{a7d3}', ['\u{a7d2}', '\u{0}', '\u{0}']),
+    ('\u{a7d5}', ['\u{a7d4}', '\u{0}', '\u{0}']), ('\u{a7d7}', ['\u{a7d6}', '\u{0}', '\u{0}']),
+    ('\u{a7d9}', ['\u{a7d8}', '\u{0}', '\u{0}']), ('\u{a7db}', ['\u{a7da}', '\u{0}', '\u{0}']),
+    ('\u{a7f6}', ['\u{a7f5}', '\u{0}', '\u{0}']), ('\u{ab53}', ['\u{a7b3}', '\u{0}', '\u{0}']),
+    ('\u{ab70}', ['\u{13a0}', '\u{0}', '\u{0}']), ('\u{ab71}', ['\u{13a1}', '\u{0}', '\u{0}']),
+    ('\u{ab72}', ['\u{13a2}', '\u{0}', '\u{0}']), ('\u{ab73}', ['\u{13a3}', '\u{0}', '\u{0}']),
+    ('\u{ab74}', ['\u{13a4}', '\u{0}', '\u{0}']), ('\u{ab75}', ['\u{13a5}', '\u{0}', '\u{0}']),
+    ('\u{ab76}', ['\u{13a6}', '\u{0}', '\u{0}']), ('\u{ab77}', ['\u{13a7}', '\u{0}', '\u{0}']),
+    ('\u{ab78}', ['\u{13a8}', '\u{0}', '\u{0}']), ('\u{ab79}', ['\u{13a9}', '\u{0}', '\u{0}']),
+    ('\u{ab7a}', ['\u{13aa}', '\u{0}', '\u{0}']), ('\u{ab7b}', ['\u{13ab}', '\u{0}', '\u{0}']),
+    ('\u{ab7c}', ['\u{13ac}', '\u{0}', '\u{0}']), ('\u{ab7d}', ['\u{13ad}', '\u{0}', '\u{0}']),
+    ('\u{ab7e}', ['\u{13ae}', '\u{0}', '\u{0}']), ('\u{ab7f}', ['\u{13af}', '\u{0}', '\u{0}']),
+    ('\u{ab80}', ['\u{13b0}', '\u{0}', '\u{0}']), ('\u{ab81}', ['\u{13b1}', '\u{0}', '\u{0}']),
+    ('\u{ab82}', ['\u{13b2}', '\u{0}', '\u{0}']), ('\u{ab83}', ['\u{13b3}', '\u{0}', '\u{0}']),
+    ('\u{ab84}', ['\u{13b4}', '\u{0}', '\u{0}']), ('\u{ab85}', ['\u{13b5}', '\u{0}', '\u{0}']),
+    ('\u{ab86}', ['\u{13b6}', '\u{0}', '\u{0}']), ('\u{ab87}', ['\u{13b7}', '\u{0}', '\u{0}']),
+    ('\u{ab88}', ['\u{13b8}', '\u{0}', '\u{0}']), ('\u{ab89}', ['\u{13b9}', '\u{0}', '\u{0}']),
+    ('\u{ab8a}', ['\u{13ba}', '\u{0}', '\u{0}']), ('\u{ab8b}', ['\u{13bb}', '\u{0}', '\u{0}']),
+    ('\u{ab8c}', ['\u{13bc}', '\u{0}', '\u{0}']), ('\u{ab8d}', ['\u{13bd}', '\u{0}', '\u{0}']),
+    ('\u{ab8e}', ['\u{13be}', '\u{0}', '\u{0}']), ('\u{ab8f}', ['\u{13bf}', '\u{0}', '\u{0}']),
+    ('\u{ab90}', ['\u{13c0}', '\u{0}', '\u{0}']), ('\u{ab91}', ['\u{13c1}', '\u{0}', '\u{0}']),
+    ('\u{ab92}', ['\u{13c2}', '\u{0}', '\u{0}']), ('\u{ab93}', ['\u{13c3}', '\u{0}', '\u{0}']),
+    ('\u{ab94}', ['\u{13c4}', '\u{0}', '\u{0}']), ('\u{ab95}', ['\u{13c5}', '\u{0}', '\u{0}']),
+    ('\u{ab96}', ['\u{13c6}', '\u{0}', '\u{0}']), ('\u{ab97}', ['\u{13c7}', '\u{0}', '\u{0}']),
+    ('\u{ab98}', ['\u{13c8}', '\u{0}', '\u{0}']), ('\u{ab99}', ['\u{13c9}', '\u{0}', '\u{0}']),
+    ('\u{ab9a}', ['\u{13ca}', '\u{0}', '\u{0}']), ('\u{ab9b}', ['\u{13cb}', '\u{0}', '\u{0}']),
+    ('\u{ab9c}', ['\u{13cc}', '\u{0}', '\u{0}']), ('\u{ab9d}', ['\u{13cd}', '\u{0}', '\u{0}']),
+    ('\u{ab9e}', ['\u{13ce}', '\u{0}', '\u{0}']), ('\u{ab9f}', ['\u{13cf}', '\u{0}', '\u{0}']),
+    ('\u{aba0}', ['\u{13d0}', '\u{0}', '\u{0}']), ('\u{aba1}', ['\u{13d1}', '\u{0}', '\u{0}']),
+    ('\u{aba2}', ['\u{13d2}', '\u{0}', '\u{0}']), ('\u{aba3}', ['\u{13d3}', '\u{0}', '\u{0}']),
+    ('\u{aba4}', ['\u{13d4}', '\u{0}', '\u{0}']), ('\u{aba5}', ['\u{13d5}', '\u{0}', '\u{0}']),
+    ('\u{aba6}', ['\u{13d6}', '\u{0}', '\u{0}']), ('\u{aba7}', ['\u{13d7}', '\u{0}', '\u{0}']),
+    ('\u{aba8}', ['\u{13d8}', '\u{0}', '\u{0}']), ('\u{aba9}', ['\u{13d9}', '\u{0}', '\u{0}']),
+    ('\u{abaa}', ['\u{13da}', '\u{0}', '\u{0}']), ('\u{abab}', ['\u{13db}', '\u{0}', '\u{0}']),
+    ('\u{abac}', ['\u{13dc}', '\u{0}', '\u{0}']), ('\u{abad}', ['\u{13dd}', '\u{0}', '\u{0}']),
+    ('\u{abae}', ['\u{13de}', '\u{0}', '\u{0}']), ('\u{abaf}', ['\u{13df}', '\u{0}', '\u{0}']),
+    ('\u{abb0}', ['\u{13e0}', '\u{0}', '\u{0}']), ('\u{abb1}', ['\u{13e1}', '\u{0}', '\u{0}']),
+    ('\u{abb2}', ['\u{13e2}', '\u{0}', '\u{0}']), ('\u{abb3}', ['\u{13e3}', '\u{0}', '\u{0}']),
+    ('\u{abb4}', ['\u{13e4}', '\u{0}', '\u{0}']), ('\u{abb5}', ['\u{13e5}', '\u{0}', '\u{0}']),
+    ('\u{abb6}', ['\u{13e6}', '\u{0}', '\u{0}']), ('\u{abb7}', ['\u{13e7}', '\u{0}', '\u{0}']),
+    ('\u{abb8}', ['\u{13e8}', '\u{0}', '\u{0}']), ('\u{abb9}', ['\u{13e9}', '\u{0}', '\u{0}']),
+    ('\u{abba}', ['\u{13ea}', '\u{0}', '\u{0}']), ('\u{abbb}', ['\u{13eb}', '\u{0}', '\u{0}']),
+    ('\u{abbc}', ['\u{13ec}', '\u{0}', '\u{0}']), ('\u{abbd}', ['\u{13ed}', '\u{0}', '\u{0}']),
+    ('\u{abbe}', ['\u{13ee}', '\u{0}', '\u{0}']), ('\u{abbf}', ['\u{13ef}', '\u{0}', '\u{0}']),
+    ('\u{fb00}', ['F', 'F', '\u{0}']), ('\u{fb01}', ['F', 'I', '\u{0}']),
+    ('\u{fb02}', ['F', 'L', '\u{0}']), ('\u{fb03}', ['F', 'F', 'I']),
+    ('\u{fb04}', ['F', 'F', 'L']), ('\u{fb05}', ['S', 'T', '\u{0}']),
+    ('\u{fb06}', ['S', 'T', '\u{0}']), ('\u{fb13}', ['\u{544}', '\u{546}', '\u{0}']),
+    ('\u{fb14}', ['\u{544}', '\u{535}', '\u{0}']),
+    ('\u{fb15}', ['\u{544}', '\u{53b}', '\u{0}']),
+    ('\u{fb16}', ['\u{54e}', '\u{546}', '\u{0}']),
+    ('\u{fb17}', ['\u{544}', '\u{53d}', '\u{0}']), ('\u{ff41}', ['\u{ff21}', '\u{0}', '\u{0}']),
+    ('\u{ff42}', ['\u{ff22}', '\u{0}', '\u{0}']), ('\u{ff43}', ['\u{ff23}', '\u{0}', '\u{0}']),
+    ('\u{ff44}', ['\u{ff24}', '\u{0}', '\u{0}']), ('\u{ff45}', ['\u{ff25}', '\u{0}', '\u{0}']),
+    ('\u{ff46}', ['\u{ff26}', '\u{0}', '\u{0}']), ('\u{ff47}', ['\u{ff27}', '\u{0}', '\u{0}']),
+    ('\u{ff48}', ['\u{ff28}', '\u{0}', '\u{0}']), ('\u{ff49}', ['\u{ff29}', '\u{0}', '\u{0}']),
+    ('\u{ff4a}', ['\u{ff2a}', '\u{0}', '\u{0}']), ('\u{ff4b}', ['\u{ff2b}', '\u{0}', '\u{0}']),
+    ('\u{ff4c}', ['\u{ff2c}', '\u{0}', '\u{0}']), ('\u{ff4d}', ['\u{ff2d}', '\u{0}', '\u{0}']),
+    ('\u{ff4e}', ['\u{ff2e}', '\u{0}', '\u{0}']), ('\u{ff4f}', ['\u{ff2f}', '\u{0}', '\u{0}']),
+    ('\u{ff50}', ['\u{ff30}', '\u{0}', '\u{0}']), ('\u{ff51}', ['\u{ff31}', '\u{0}', '\u{0}']),
+    ('\u{ff52}', ['\u{ff32}', '\u{0}', '\u{0}']), ('\u{ff53}', ['\u{ff33}', '\u{0}', '\u{0}']),
+    ('\u{ff54}', ['\u{ff34}', '\u{0}', '\u{0}']), ('\u{ff55}', ['\u{ff35}', '\u{0}', '\u{0}']),
+    ('\u{ff56}', ['\u{ff36}', '\u{0}', '\u{0}']), ('\u{ff57}', ['\u{ff37}', '\u{0}', '\u{0}']),
+    ('\u{ff58}', ['\u{ff38}', '\u{0}', '\u{0}']), ('\u{ff59}', ['\u{ff39}', '\u{0}', '\u{0}']),
+    ('\u{ff5a}', ['\u{ff3a}', '\u{0}', '\u{0}']),
+    ('\u{10428}', ['\u{10400}', '\u{0}', '\u{0}']),
+    ('\u{10429}', ['\u{10401}', '\u{0}', '\u{0}']),
+    ('\u{1042a}', ['\u{10402}', '\u{0}', '\u{0}']),
+    ('\u{1042b}', ['\u{10403}', '\u{0}', '\u{0}']),
+    ('\u{1042c}', ['\u{10404}', '\u{0}', '\u{0}']),
+    ('\u{1042d}', ['\u{10405}', '\u{0}', '\u{0}']),
+    ('\u{1042e}', ['\u{10406}', '\u{0}', '\u{0}']),
+    ('\u{1042f}', ['\u{10407}', '\u{0}', '\u{0}']),
+    ('\u{10430}', ['\u{10408}', '\u{0}', '\u{0}']),
+    ('\u{10431}', ['\u{10409}', '\u{0}', '\u{0}']),
+    ('\u{10432}', ['\u{1040a}', '\u{0}', '\u{0}']),
+    ('\u{10433}', ['\u{1040b}', '\u{0}', '\u{0}']),
+    ('\u{10434}', ['\u{1040c}', '\u{0}', '\u{0}']),
+    ('\u{10435}', ['\u{1040d}', '\u{0}', '\u{0}']),
+    ('\u{10436}', ['\u{1040e}', '\u{0}', '\u{0}']),
+    ('\u{10437}', ['\u{1040f}', '\u{0}', '\u{0}']),
+    ('\u{10438}', ['\u{10410}', '\u{0}', '\u{0}']),
+    ('\u{10439}', ['\u{10411}', '\u{0}', '\u{0}']),
+    ('\u{1043a}', ['\u{10412}', '\u{0}', '\u{0}']),
+    ('\u{1043b}', ['\u{10413}', '\u{0}', '\u{0}']),
+    ('\u{1043c}', ['\u{10414}', '\u{0}', '\u{0}']),
+    ('\u{1043d}', ['\u{10415}', '\u{0}', '\u{0}']),
+    ('\u{1043e}', ['\u{10416}', '\u{0}', '\u{0}']),
+    ('\u{1043f}', ['\u{10417}', '\u{0}', '\u{0}']),
+    ('\u{10440}', ['\u{10418}', '\u{0}', '\u{0}']),
+    ('\u{10441}', ['\u{10419}', '\u{0}', '\u{0}']),
+    ('\u{10442}', ['\u{1041a}', '\u{0}', '\u{0}']),
+    ('\u{10443}', ['\u{1041b}', '\u{0}', '\u{0}']),
+    ('\u{10444}', ['\u{1041c}', '\u{0}', '\u{0}']),
+    ('\u{10445}', ['\u{1041d}', '\u{0}', '\u{0}']),
+    ('\u{10446}', ['\u{1041e}', '\u{0}', '\u{0}']),
+    ('\u{10447}', ['\u{1041f}', '\u{0}', '\u{0}']),
+    ('\u{10448}', ['\u{10420}', '\u{0}', '\u{0}']),
+    ('\u{10449}', ['\u{10421}', '\u{0}', '\u{0}']),
+    ('\u{1044a}', ['\u{10422}', '\u{0}', '\u{0}']),
+    ('\u{1044b}', ['\u{10423}', '\u{0}', '\u{0}']),
+    ('\u{1044c}', ['\u{10424}', '\u{0}', '\u{0}']),
+    ('\u{1044d}', ['\u{10425}', '\u{0}', '\u{0}']),
+    ('\u{1044e}', ['\u{10426}', '\u{0}', '\u{0}']),
+    ('\u{1044f}', ['\u{10427}', '\u{0}', '\u{0}']),
+    ('\u{104d8}', ['\u{104b0}', '\u{0}', '\u{0}']),
+    ('\u{104d9}', ['\u{104b1}', '\u{0}', '\u{0}']),
+    ('\u{104da}', ['\u{104b2}', '\u{0}', '\u{0}']),
+    ('\u{104db}', ['\u{104b3}', '\u{0}', '\u{0}']),
+    ('\u{104dc}', ['\u{104b4}', '\u{0}', '\u{0}']),
+    ('\u{104dd}', ['\u{104b5}', '\u{0}', '\u{0}']),
+    ('\u{104de}', ['\u{104b6}', '\u{0}', '\u{0}']),
+    ('\u{104df}', ['\u{104b7}', '\u{0}', '\u{0}']),
+    ('\u{104e0}', ['\u{104b8}', '\u{0}', '\u{0}']),
+    ('\u{104e1}', ['\u{104b9}', '\u{0}', '\u{0}']),
+    ('\u{104e2}', ['\u{104ba}', '\u{0}', '\u{0}']),
+    ('\u{104e3}', ['\u{104bb}', '\u{0}', '\u{0}']),
+    ('\u{104e4}', ['\u{104bc}', '\u{0}', '\u{0}']),
+    ('\u{104e5}', ['\u{104bd}', '\u{0}', '\u{0}']),
+    ('\u{104e6}', ['\u{104be}', '\u{0}', '\u{0}']),
+    ('\u{104e7}', ['\u{104bf}', '\u{0}', '\u{0}']),
+    ('\u{104e8}', ['\u{104c0}', '\u{0}', '\u{0}']),
+    ('\u{104e9}', ['\u{104c1}', '\u{0}', '\u{0}']),
+    ('\u{104ea}', ['\u{104c2}', '\u{0}', '\u{0}']),
+    ('\u{104eb}', ['\u{104c3}', '\u{0}', '\u{0}']),
+    ('\u{104ec}', ['\u{104c4}', '\u{0}', '\u{0}']),
+    ('\u{104ed}', ['\u{104c5}', '\u{0}', '\u{0}']),
+    ('\u{104ee}', ['\u{104c6}', '\u{0}', '\u{0}']),
+    ('\u{104ef}', ['\u{104c7}', '\u{0}', '\u{0}']),
+    ('\u{104f0}', ['\u{104c8}', '\u{0}', '\u{0}']),
+    ('\u{104f1}', ['\u{104c9}', '\u{0}', '\u{0}']),
+    ('\u{104f2}', ['\u{104ca}', '\u{0}', '\u{0}']),
+    ('\u{104f3}', ['\u{104cb}', '\u{0}', '\u{0}']),
+    ('\u{104f4}', ['\u{104cc}', '\u{0}', '\u{0}']),
+    ('\u{104f5}', ['\u{104cd}', '\u{0}', '\u{0}']),
+    ('\u{104f6}', ['\u{104ce}', '\u{0}', '\u{0}']),
+    ('\u{104f7}', ['\u{104cf}', '\u{0}', '\u{0}']),
+    ('\u{104f8}', ['\u{104d0}', '\u{0}', '\u{0}']),
+    ('\u{104f9}', ['\u{104d1}', '\u{0}', '\u{0}']),
+    ('\u{104fa}', ['\u{104d2}', '\u{0}', '\u{0}']),
+    ('\u{104fb}', ['\u{104d3}', '\u{0}', '\u{0}']),
+    ('\u{10597}', ['\u{10570}', '\u{0}', '\u{0}']),
+    ('\u{10598}', ['\u{10571}', '\u{0}', '\u{0}']),
+    ('\u{10599}', ['\u{10572}', '\u{0}', '\u{0}']),
+    ('\u{1059a}', ['\u{10573}', '\u{0}', '\u{0}']),
+    ('\u{1059b}', ['\u{10574}', '\u{0}', '\u{0}']),
+    ('\u{1059c}', ['\u{10575}', '\u{0}', '\u{0}']),
+    ('\u{1059d}', ['\u{10576}', '\u{0}', '\u{0}']),
+    ('\u{1059e}', ['\u{10577}', '\u{0}', '\u{0}']),
+    ('\u{1059f}', ['\u{10578}', '\u{0}', '\u{0}']),
+    ('\u{105a0}', ['\u{10579}', '\u{0}', '\u{0}']),
+    ('\u{105a1}', ['\u{1057a}', '\u{0}', '\u{0}']),
+    ('\u{105a3}', ['\u{1057c}', '\u{0}', '\u{0}']),
+    ('\u{105a4}', ['\u{1057d}', '\u{0}', '\u{0}']),
+    ('\u{105a5}', ['\u{1057e}', '\u{0}', '\u{0}']),
+    ('\u{105a6}', ['\u{1057f}', '\u{0}', '\u{0}']),
+    ('\u{105a7}', ['\u{10580}', '\u{0}', '\u{0}']),
+    ('\u{105a8}', ['\u{10581}', '\u{0}', '\u{0}']),
+    ('\u{105a9}', ['\u{10582}', '\u{0}', '\u{0}']),
+    ('\u{105aa}', ['\u{10583}', '\u{0}', '\u{0}']),
+    ('\u{105ab}', ['\u{10584}', '\u{0}', '\u{0}']),
+    ('\u{105ac}', ['\u{10585}', '\u{0}', '\u{0}']),
+    ('\u{105ad}', ['\u{10586}', '\u{0}', '\u{0}']),
+    ('\u{105ae}', ['\u{10587}', '\u{0}', '\u{0}']),
+    ('\u{105af}', ['\u{10588}', '\u{0}', '\u{0}']),
+    ('\u{105b0}', ['\u{10589}', '\u{0}', '\u{0}']),
+    ('\u{105b1}', ['\u{1058a}', '\u{0}', '\u{0}']),
+    ('\u{105b3}', ['\u{1058c}', '\u{0}', '\u{0}']),
+    ('\u{105b4}', ['\u{1058d}', '\u{0}', '\u{0}']),
+    ('\u{105b5}', ['\u{1058e}', '\u{0}', '\u{0}']),
+    ('\u{105b6}', ['\u{1058f}', '\u{0}', '\u{0}']),
+    ('\u{105b7}', ['\u{10590}', '\u{0}', '\u{0}']),
+    ('\u{105b8}', ['\u{10591}', '\u{0}', '\u{0}']),
+    ('\u{105b9}', ['\u{10592}', '\u{0}', '\u{0}']),
+    ('\u{105bb}', ['\u{10594}', '\u{0}', '\u{0}']),
+    ('\u{105bc}', ['\u{10595}', '\u{0}', '\u{0}']),
+    ('\u{10cc0}', ['\u{10c80}', '\u{0}', '\u{0}']),
+    ('\u{10cc1}', ['\u{10c81}', '\u{0}', '\u{0}']),
+    ('\u{10cc2}', ['\u{10c82}', '\u{0}', '\u{0}']),
+    ('\u{10cc3}', ['\u{10c83}', '\u{0}', '\u{0}']),
+    ('\u{10cc4}', ['\u{10c84}', '\u{0}', '\u{0}']),
+    ('\u{10cc5}', ['\u{10c85}', '\u{0}', '\u{0}']),
+    ('\u{10cc6}', ['\u{10c86}', '\u{0}', '\u{0}']),
+    ('\u{10cc7}', ['\u{10c87}', '\u{0}', '\u{0}']),
+    ('\u{10cc8}', ['\u{10c88}', '\u{0}', '\u{0}']),
+    ('\u{10cc9}', ['\u{10c89}', '\u{0}', '\u{0}']),
+    ('\u{10cca}', ['\u{10c8a}', '\u{0}', '\u{0}']),
+    ('\u{10ccb}', ['\u{10c8b}', '\u{0}', '\u{0}']),
+    ('\u{10ccc}', ['\u{10c8c}', '\u{0}', '\u{0}']),
+    ('\u{10ccd}', ['\u{10c8d}', '\u{0}', '\u{0}']),
+    ('\u{10cce}', ['\u{10c8e}', '\u{0}', '\u{0}']),
+    ('\u{10ccf}', ['\u{10c8f}', '\u{0}', '\u{0}']),
+    ('\u{10cd0}', ['\u{10c90}', '\u{0}', '\u{0}']),
+    ('\u{10cd1}', ['\u{10c91}', '\u{0}', '\u{0}']),
+    ('\u{10cd2}', ['\u{10c92}', '\u{0}', '\u{0}']),
+    ('\u{10cd3}', ['\u{10c93}', '\u{0}', '\u{0}']),
+    ('\u{10cd4}', ['\u{10c94}', '\u{0}', '\u{0}']),
+    ('\u{10cd5}', ['\u{10c95}', '\u{0}', '\u{0}']),
+    ('\u{10cd6}', ['\u{10c96}', '\u{0}', '\u{0}']),
+    ('\u{10cd7}', ['\u{10c97}', '\u{0}', '\u{0}']),
+    ('\u{10cd8}', ['\u{10c98}', '\u{0}', '\u{0}']),
+    ('\u{10cd9}', ['\u{10c99}', '\u{0}', '\u{0}']),
+    ('\u{10cda}', ['\u{10c9a}', '\u{0}', '\u{0}']),
+    ('\u{10cdb}', ['\u{10c9b}', '\u{0}', '\u{0}']),
+    ('\u{10cdc}', ['\u{10c9c}', '\u{0}', '\u{0}']),
+    ('\u{10cdd}', ['\u{10c9d}', '\u{0}', '\u{0}']),
+    ('\u{10cde}', ['\u{10c9e}', '\u{0}', '\u{0}']),
+    ('\u{10cdf}', ['\u{10c9f}', '\u{0}', '\u{0}']),
+    ('\u{10ce0}', ['\u{10ca0}', '\u{0}', '\u{0}']),
+    ('\u{10ce1}', ['\u{10ca1}', '\u{0}', '\u{0}']),
+    ('\u{10ce2}', ['\u{10ca2}', '\u{0}', '\u{0}']),
+    ('\u{10ce3}', ['\u{10ca3}', '\u{0}', '\u{0}']),
+    ('\u{10ce4}', ['\u{10ca4}', '\u{0}', '\u{0}']),
+    ('\u{10ce5}', ['\u{10ca5}', '\u{0}', '\u{0}']),
+    ('\u{10ce6}', ['\u{10ca6}', '\u{0}', '\u{0}']),
+    ('\u{10ce7}', ['\u{10ca7}', '\u{0}', '\u{0}']),
+    ('\u{10ce8}', ['\u{10ca8}', '\u{0}', '\u{0}']),
+    ('\u{10ce9}', ['\u{10ca9}', '\u{0}', '\u{0}']),
+    ('\u{10cea}', ['\u{10caa}', '\u{0}', '\u{0}']),
+    ('\u{10ceb}', ['\u{10cab}', '\u{0}', '\u{0}']),
+    ('\u{10cec}', ['\u{10cac}', '\u{0}', '\u{0}']),
+    ('\u{10ced}', ['\u{10cad}', '\u{0}', '\u{0}']),
+    ('\u{10cee}', ['\u{10cae}', '\u{0}', '\u{0}']),
+    ('\u{10cef}', ['\u{10caf}', '\u{0}', '\u{0}']),
+    ('\u{10cf0}', ['\u{10cb0}', '\u{0}', '\u{0}']),
+    ('\u{10cf1}', ['\u{10cb1}', '\u{0}', '\u{0}']),
+    ('\u{10cf2}', ['\u{10cb2}', '\u{0}', '\u{0}']),
+    ('\u{10d70}', ['\u{10d50}', '\u{0}', '\u{0}']),
+    ('\u{10d71}', ['\u{10d51}', '\u{0}', '\u{0}']),
+    ('\u{10d72}', ['\u{10d52}', '\u{0}', '\u{0}']),
+    ('\u{10d73}', ['\u{10d53}', '\u{0}', '\u{0}']),
+    ('\u{10d74}', ['\u{10d54}', '\u{0}', '\u{0}']),
+    ('\u{10d75}', ['\u{10d55}', '\u{0}', '\u{0}']),
+    ('\u{10d76}', ['\u{10d56}', '\u{0}', '\u{0}']),
+    ('\u{10d77}', ['\u{10d57}', '\u{0}', '\u{0}']),
+    ('\u{10d78}', ['\u{10d58}', '\u{0}', '\u{0}']),
+    ('\u{10d79}', ['\u{10d59}', '\u{0}', '\u{0}']),
+    ('\u{10d7a}', ['\u{10d5a}', '\u{0}', '\u{0}']),
+    ('\u{10d7b}', ['\u{10d5b}', '\u{0}', '\u{0}']),
+    ('\u{10d7c}', ['\u{10d5c}', '\u{0}', '\u{0}']),
+    ('\u{10d7d}', ['\u{10d5d}', '\u{0}', '\u{0}']),
+    ('\u{10d7e}', ['\u{10d5e}', '\u{0}', '\u{0}']),
+    ('\u{10d7f}', ['\u{10d5f}', '\u{0}', '\u{0}']),
+    ('\u{10d80}', ['\u{10d60}', '\u{0}', '\u{0}']),
+    ('\u{10d81}', ['\u{10d61}', '\u{0}', '\u{0}']),
+    ('\u{10d82}', ['\u{10d62}', '\u{0}', '\u{0}']),
+    ('\u{10d83}', ['\u{10d63}', '\u{0}', '\u{0}']),
+    ('\u{10d84}', ['\u{10d64}', '\u{0}', '\u{0}']),
+    ('\u{10d85}', ['\u{10d65}', '\u{0}', '\u{0}']),
+    ('\u{118c0}', ['\u{118a0}', '\u{0}', '\u{0}']),
+    ('\u{118c1}', ['\u{118a1}', '\u{0}', '\u{0}']),
+    ('\u{118c2}', ['\u{118a2}', '\u{0}', '\u{0}']),
+    ('\u{118c3}', ['\u{118a3}', '\u{0}', '\u{0}']),
+    ('\u{118c4}', ['\u{118a4}', '\u{0}', '\u{0}']),
+    ('\u{118c5}', ['\u{118a5}', '\u{0}', '\u{0}']),
+    ('\u{118c6}', ['\u{118a6}', '\u{0}', '\u{0}']),
+    ('\u{118c7}', ['\u{118a7}', '\u{0}', '\u{0}']),
+    ('\u{118c8}', ['\u{118a8}', '\u{0}', '\u{0}']),
+    ('\u{118c9}', ['\u{118a9}', '\u{0}', '\u{0}']),
+    ('\u{118ca}', ['\u{118aa}', '\u{0}', '\u{0}']),
+    ('\u{118cb}', ['\u{118ab}', '\u{0}', '\u{0}']),
+    ('\u{118cc}', ['\u{118ac}', '\u{0}', '\u{0}']),
+    ('\u{118cd}', ['\u{118ad}', '\u{0}', '\u{0}']),
+    ('\u{118ce}', ['\u{118ae}', '\u{0}', '\u{0}']),
+    ('\u{118cf}', ['\u{118af}', '\u{0}', '\u{0}']),
+    ('\u{118d0}', ['\u{118b0}', '\u{0}', '\u{0}']),
+    ('\u{118d1}', ['\u{118b1}', '\u{0}', '\u{0}']),
+    ('\u{118d2}', ['\u{118b2}', '\u{0}', '\u{0}']),
+    ('\u{118d3}', ['\u{118b3}', '\u{0}', '\u{0}']),
+    ('\u{118d4}', ['\u{118b4}', '\u{0}', '\u{0}']),
+    ('\u{118d5}', ['\u{118b5}', '\u{0}', '\u{0}']),
+    ('\u{118d6}', ['\u{118b6}', '\u{0}', '\u{0}']),
+    ('\u{118d7}', ['\u{118b7}', '\u{0}', '\u{0}']),
+    ('\u{118d8}', ['\u{118b8}', '\u{0}', '\u{0}']),
+    ('\u{118d9}', ['\u{118b9}', '\u{0}', '\u{0}']),
+    ('\u{118da}', ['\u{118ba}', '\u{0}', '\u{0}']),
+    ('\u{118db}', ['\u{118bb}', '\u{0}', '\u{0}']),
+    ('\u{118dc}', ['\u{118bc}', '\u{0}', '\u{0}']),
+    ('\u{118dd}', ['\u{118bd}', '\u{0}', '\u{0}']),
+    ('\u{118de}', ['\u{118be}', '\u{0}', '\u{0}']),
+    ('\u{118df}', ['\u{118bf}', '\u{0}', '\u{0}']),
+    ('\u{16e60}', ['\u{16e40}', '\u{0}', '\u{0}']),
+    ('\u{16e61}', ['\u{16e41}', '\u{0}', '\u{0}']),
+    ('\u{16e62}', ['\u{16e42}', '\u{0}', '\u{0}']),
+    ('\u{16e63}', ['\u{16e43}', '\u{0}', '\u{0}']),
+    ('\u{16e64}', ['\u{16e44}', '\u{0}', '\u{0}']),
+    ('\u{16e65}', ['\u{16e45}', '\u{0}', '\u{0}']),
+    ('\u{16e66}', ['\u{16e46}', '\u{0}', '\u{0}']),
+    ('\u{16e67}', ['\u{16e47}', '\u{0}', '\u{0}']),
+    ('\u{16e68}', ['\u{16e48}', '\u{0}', '\u{0}']),
+    ('\u{16e69}', ['\u{16e49}', '\u{0}', '\u{0}']),
+    ('\u{16e6a}', ['\u{16e4a}', '\u{0}', '\u{0}']),
+    ('\u{16e6b}', ['\u{16e4b}', '\u{0}', '\u{0}']),
+    ('\u{16e6c}', ['\u{16e4c}', '\u{0}', '\u{0}']),
+    ('\u{16e6d}', ['\u{16e4d}', '\u{0}', '\u{0}']),
+    ('\u{16e6e}', ['\u{16e4e}', '\u{0}', '\u{0}']),
+    ('\u{16e6f}', ['\u{16e4f}', '\u{0}', '\u{0}']),
+    ('\u{16e70}', ['\u{16e50}', '\u{0}', '\u{0}']),
+    ('\u{16e71}', ['\u{16e51}', '\u{0}', '\u{0}']),
+    ('\u{16e72}', ['\u{16e52}', '\u{0}', '\u{0}']),
+    ('\u{16e73}', ['\u{16e53}', '\u{0}', '\u{0}']),
+    ('\u{16e74}', ['\u{16e54}', '\u{0}', '\u{0}']),
+    ('\u{16e75}', ['\u{16e55}', '\u{0}', '\u{0}']),
+    ('\u{16e76}', ['\u{16e56}', '\u{0}', '\u{0}']),
+    ('\u{16e77}', ['\u{16e57}', '\u{0}', '\u{0}']),
+    ('\u{16e78}', ['\u{16e58}', '\u{0}', '\u{0}']),
+    ('\u{16e79}', ['\u{16e59}', '\u{0}', '\u{0}']),
+    ('\u{16e7a}', ['\u{16e5a}', '\u{0}', '\u{0}']),
+    ('\u{16e7b}', ['\u{16e5b}', '\u{0}', '\u{0}']),
+    ('\u{16e7c}', ['\u{16e5c}', '\u{0}', '\u{0}']),
+    ('\u{16e7d}', ['\u{16e5d}', '\u{0}', '\u{0}']),
+    ('\u{16e7e}', ['\u{16e5e}', '\u{0}', '\u{0}']),
+    ('\u{16e7f}', ['\u{16e5f}', '\u{0}', '\u{0}']),
+    ('\u{16ebb}', ['\u{16ea0}', '\u{0}', '\u{0}']),
+    ('\u{16ebc}', ['\u{16ea1}', '\u{0}', '\u{0}']),
+    ('\u{16ebd}', ['\u{16ea2}', '\u{0}', '\u{0}']),
+    ('\u{16ebe}', ['\u{16ea3}', '\u{0}', '\u{0}']),
+    ('\u{16ebf}', ['\u{16ea4}', '\u{0}', '\u{0}']),
+    ('\u{16ec0}', ['\u{16ea5}', '\u{0}', '\u{0}']),
+    ('\u{16ec1}', ['\u{16ea6}', '\u{0}', '\u{0}']),
+    ('\u{16ec2}', ['\u{16ea7}', '\u{0}', '\u{0}']),
+    ('\u{16ec3}', ['\u{16ea8}', '\u{0}', '\u{0}']),
+    ('\u{16ec4}', ['\u{16ea9}', '\u{0}', '\u{0}']),
+    ('\u{16ec5}', ['\u{16eaa}', '\u{0}', '\u{0}']),
+    ('\u{16ec6}', ['\u{16eab}', '\u{0}', '\u{0}']),
+    ('\u{16ec7}', ['\u{16eac}', '\u{0}', '\u{0}']),
+    ('\u{16ec8}', ['\u{16ead}', '\u{0}', '\u{0}']),
+    ('\u{16ec9}', ['\u{16eae}', '\u{0}', '\u{0}']),
+    ('\u{16eca}', ['\u{16eaf}', '\u{0}', '\u{0}']),
+    ('\u{16ecb}', ['\u{16eb0}', '\u{0}', '\u{0}']),
+    ('\u{16ecc}', ['\u{16eb1}', '\u{0}', '\u{0}']),
+    ('\u{16ecd}', ['\u{16eb2}', '\u{0}', '\u{0}']),
+    ('\u{16ece}', ['\u{16eb3}', '\u{0}', '\u{0}']),
+    ('\u{16ecf}', ['\u{16eb4}', '\u{0}', '\u{0}']),
+    ('\u{16ed0}', ['\u{16eb5}', '\u{0}', '\u{0}']),
+    ('\u{16ed1}', ['\u{16eb6}', '\u{0}', '\u{0}']),
+    ('\u{16ed2}', ['\u{16eb7}', '\u{0}', '\u{0}']),
+    ('\u{16ed3}', ['\u{16eb8}', '\u{0}', '\u{0}']),
+    ('\u{1e922}', ['\u{1e900}', '\u{0}', '\u{0}']),
+    ('\u{1e923}', ['\u{1e901}', '\u{0}', '\u{0}']),
+    ('\u{1e924}', ['\u{1e902}', '\u{0}', '\u{0}']),
+    ('\u{1e925}', ['\u{1e903}', '\u{0}', '\u{0}']),
+    ('\u{1e926}', ['\u{1e904}', '\u{0}', '\u{0}']),
+    ('\u{1e927}', ['\u{1e905}', '\u{0}', '\u{0}']),
+    ('\u{1e928}', ['\u{1e906}', '\u{0}', '\u{0}']),
+    ('\u{1e929}', ['\u{1e907}', '\u{0}', '\u{0}']),
+    ('\u{1e92a}', ['\u{1e908}', '\u{0}', '\u{0}']),
+    ('\u{1e92b}', ['\u{1e909}', '\u{0}', '\u{0}']),
+    ('\u{1e92c}', ['\u{1e90a}', '\u{0}', '\u{0}']),
+    ('\u{1e92d}', ['\u{1e90b}', '\u{0}', '\u{0}']),
+    ('\u{1e92e}', ['\u{1e90c}', '\u{0}', '\u{0}']),
+    ('\u{1e92f}', ['\u{1e90d}', '\u{0}', '\u{0}']),
+    ('\u{1e930}', ['\u{1e90e}', '\u{0}', '\u{0}']),
+    ('\u{1e931}', ['\u{1e90f}', '\u{0}', '\u{0}']),
+    ('\u{1e932}', ['\u{1e910}', '\u{0}', '\u{0}']),
+    ('\u{1e933}', ['\u{1e911}', '\u{0}', '\u{0}']),
+    ('\u{1e934}', ['\u{1e912}', '\u{0}', '\u{0}']),
+    ('\u{1e935}', ['\u{1e913}', '\u{0}', '\u{0}']),
+    ('\u{1e936}', ['\u{1e914}', '\u{0}', '\u{0}']),
+    ('\u{1e937}', ['\u{1e915}', '\u{0}', '\u{0}']),
+    ('\u{1e938}', ['\u{1e916}', '\u{0}', '\u{0}']),
+    ('\u{1e939}', ['\u{1e917}', '\u{0}', '\u{0}']),
+    ('\u{1e93a}', ['\u{1e918}', '\u{0}', '\u{0}']),
+    ('\u{1e93b}', ['\u{1e919}', '\u{0}', '\u{0}']),
+    ('\u{1e93c}', ['\u{1e91a}', '\u{0}', '\u{0}']),
+    ('\u{1e93d}', ['\u{1e91b}', '\u{0}', '\u{0}']),
+    ('\u{1e93e}', ['\u{1e91c}', '\u{0}', '\u{0}']),
+    ('\u{1e93f}', ['\u{1e91d}', '\u{0}', '\u{0}']),
+    ('\u{1e940}', ['\u{1e91e}', '\u{0}', '\u{0}']),
+    ('\u{1e941}', ['\u{1e91f}', '\u{0}', '\u{0}']),
+    ('\u{1e942}', ['\u{1e920}', '\u{0}', '\u{0}']),
+    ('\u{1e943}', ['\u{1e921}', '\u{0}', '\u{0}']),
+];
diff --git a/src/bootstrap/src/core/build_steps/run.rs b/src/bootstrap/src/core/build_steps/run.rs
index 1f6c2facc9c2..2079f3a19019 100644
--- a/src/bootstrap/src/core/build_steps/run.rs
+++ b/src/bootstrap/src/core/build_steps/run.rs
@@ -358,6 +358,8 @@ fn make_run(run: RunConfig<'_>) {
     }
 }
 
+/// The build step for generating the tables in `core/src/char/unicode/unicode_data.rs`
+/// and the tests in `library/coretests/tests/unicode/test_data.rs`.
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct UnicodeTableGenerator;
 
@@ -375,7 +377,9 @@ fn make_run(run: RunConfig<'_>) {
 
     fn run(self, builder: &Builder<'_>) {
         let mut cmd = builder.tool_cmd(Tool::UnicodeTableGenerator);
+        // Generated files that are checked into git:
         cmd.arg(builder.src.join("library/core/src/unicode/unicode_data.rs"));
+        cmd.arg(builder.src.join("library/coretests/tests/unicode/test_data.rs"));
         cmd.run(builder);
     }
 }
diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index 437e1e47dd70..a954cb7114e7 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -1,7 +1,8 @@
 use std::char;
 use std::collections::BTreeMap;
-use std::fmt::{self, Write};
+use std::fmt::Write;
 
+use crate::fmt_helpers::CharEscape;
 use crate::{UnicodeData, fmt_list};
 
 const INDEX_MASK: u32 = 1 << 22;
@@ -75,14 +76,6 @@
     (tables, size)
 }
 
-struct CharEscape(char);
-
-impl fmt::Debug for CharEscape {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "'{}'", self.0.escape_default())
-    }
-}
-
 static HEADER: &str = r"
 pub fn to_lower(c: char) -> [char; 3] {
     if c.is_ascii() {
diff --git a/src/tools/unicode-table-generator/src/fmt_helpers.rs b/src/tools/unicode-table-generator/src/fmt_helpers.rs
new file mode 100644
index 000000000000..97100a45d463
--- /dev/null
+++ b/src/tools/unicode-table-generator/src/fmt_helpers.rs
@@ -0,0 +1,17 @@
+use std::fmt;
+
+/// Wrapper type for formatting a `char` using `escape_default`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct CharEscape(pub char);
+
+impl fmt::Debug for CharEscape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "'{}'", self.0.escape_default())
+    }
+}
+
+impl fmt::Display for CharEscape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index ded9205ffc4b..c0456fcd1ec9 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -72,7 +72,6 @@
 //! or not.
 
 use std::collections::{BTreeMap, HashMap};
-use std::fmt;
 use std::fmt::Write;
 use std::ops::Range;
 
@@ -80,10 +79,12 @@
 
 mod cascading_map;
 mod case_mapping;
+mod fmt_helpers;
 mod raw_emitter;
 mod skiplist;
 mod unicode_download;
 
+use fmt_helpers::CharEscape;
 use raw_emitter::{RawEmitter, emit_codepoints, emit_whitespace};
 
 static PROPERTIES: &[&str] = &[
@@ -188,6 +189,9 @@ fn load_data() -> UnicodeData {
         }
     }
 
+    // Filter out ASCII codepoints.
+    to_lower.retain(|&c, _| c > 0x7f);
+    to_upper.retain(|&c, _| c > 0x7f);
     let mut properties: Vec<(&'static str, Vec<Range<u32>>)> = properties
         .into_iter()
         .map(|(prop, codepoints)| {
@@ -207,26 +211,23 @@ fn load_data() -> UnicodeData {
 }
 
 fn main() {
-    let write_location = std::env::args().nth(1).unwrap_or_else(|| {
-        eprintln!("Must provide path to write unicode tables to");
+    let args = std::env::args().collect::<Vec<_>>();
+
+    if args.len() != 3 {
+        eprintln!("Must provide paths to write unicode tables and tests to");
         eprintln!(
-            "e.g. {} library/core/src/unicode/unicode_data.rs",
-            std::env::args().next().unwrap_or_default()
+            "e.g. {} library/core/src/unicode/unicode_data.rs library/coretests/tests/unicode/test_data.rs",
+            args[0]
         );
         std::process::exit(1);
-    });
+    }
 
-    // Optional test path, which is a Rust source file testing that the unicode
-    // property lookups are correct.
-    let test_path = std::env::args().nth(2);
+    let data_path = &args[1];
+    let test_path = &args[2];
 
     let unicode_data = load_data();
     let ranges_by_property = &unicode_data.ranges;
 
-    if let Some(path) = test_path {
-        std::fs::write(&path, generate_tests(&unicode_data).unwrap()).unwrap();
-    }
-
     let mut table_file = String::new();
     table_file.push_str(
         "//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!\n",
@@ -288,7 +289,10 @@ fn main() {
         table_file.push_str("}\n\n");
     }
 
-    std::fs::write(&write_location, format!("{}\n", table_file.trim_end())).unwrap();
+    let test_file = generate_tests(&unicode_data);
+    std::fs::write(&test_path, test_file).unwrap();
+    std::fs::write(&data_path, table_file).unwrap();
+    eprintln!("Unicode data was generated. Remember to run \"x fmt\"!");
 }
 
 fn version() -> String {
@@ -328,87 +332,66 @@ fn fmt_list<V: std::fmt::Debug>(values: impl IntoIterator<Item = V>) -> String {
     out
 }
 
-fn generate_tests(data: &UnicodeData) -> Result<String, fmt::Error> {
-    let mut s = String::new();
-    writeln!(s, "#![feature(core_intrinsics)]")?;
-    writeln!(s, "#![allow(internal_features, dead_code)]")?;
-    writeln!(s, "// ignore-tidy-filelength")?;
-    writeln!(s, "use std::intrinsics;")?;
-    writeln!(s, "mod unicode_data;")?;
-    writeln!(s, "fn main() {{")?;
+fn generate_tests(data: &UnicodeData) -> String {
+    let mut out = String::from(
+        "\
+//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
+// ignore-tidy-filelength
+
+use std::ops::RangeInclusive;
+",
+    );
     for (property, ranges) in &data.ranges {
-        let prop = property.to_lowercase();
-        writeln!(s, r#"    println!("Testing {prop}");"#)?;
-        writeln!(s, "    {prop}_true();")?;
-        writeln!(s, "    {prop}_false();")?;
-        let (is_true, is_false): (Vec<_>, Vec<_>) = (char::MIN..=char::MAX)
+        let prop_upper = property.to_uppercase();
+        let is_true = (char::MIN..=char::MAX)
             .filter(|c| !c.is_ascii())
             .map(u32::from)
-            .partition(|c| ranges.iter().any(|r| r.contains(c)));
+            .filter(|c| ranges.iter().any(|r| r.contains(c)))
+            .collect::<Vec<_>>();
+        let is_true = ranges_from_set(&is_true)
+            .into_iter()
+            .map(|r| {
+                let start = char::from_u32(r.start).unwrap();
+                let end = char::from_u32(r.end - 1).unwrap();
+                CharEscape(start)..=CharEscape(end)
+            })
+            .collect::<Vec<_>>();
 
-        writeln!(s, "    fn {prop}_true() {{")?;
-        generate_asserts(&mut s, &prop, &is_true, true)?;
-        writeln!(s, "    }}")?;
-
-        writeln!(s, "    fn {prop}_false() {{")?;
-        generate_asserts(&mut s, &prop, &is_false, false)?;
-        writeln!(s, "    }}")?;
+        writeln!(
+            out,
+            r#"
+#[rustfmt::skip]
+pub(super) static {prop_upper}: &[RangeInclusive<char>; {is_true_len}] = &[{is_true}];
+"#,
+            is_true_len = is_true.len(),
+            is_true = fmt_list(is_true),
+        )
+        .unwrap();
     }
 
-    for (name, conversion) in ["to_lower", "to_upper"].iter().zip([&data.to_lower, &data.to_upper])
-    {
-        writeln!(s, r#"    println!("Testing {name}");"#)?;
-        for (c, mapping) in conversion {
-            let c = char::from_u32(*c).unwrap();
-            let mapping = mapping.map(|c| char::from_u32(c).unwrap());
-            writeln!(
-                s,
-                r#"    assert_eq!(unicode_data::conversions::{name}({c:?}), {mapping:?});"#
-            )?;
-        }
-        let unmapped: Vec<_> = (char::MIN..=char::MAX)
-            .filter(|c| !c.is_ascii())
-            .map(u32::from)
-            .filter(|c| !conversion.contains_key(c))
-            .collect();
-        let unmapped_ranges = ranges_from_set(&unmapped);
-        for range in unmapped_ranges {
-            let start = char::from_u32(range.start).unwrap();
-            let end = char::from_u32(range.end - 1).unwrap();
-            writeln!(s, "    for c in {start:?}..={end:?} {{")?;
-            writeln!(
-                s,
-                r#"        assert_eq!(unicode_data::conversions::{name}(c), [c, '\0', '\0']);"#
-            )?;
+    for (name, lut) in ["TO_LOWER", "TO_UPPER"].iter().zip([&data.to_lower, &data.to_upper]) {
+        let lut = lut
+            .iter()
+            .map(|(key, values)| {
+                let key = char::from_u32(*key).unwrap();
+                let values = values.map(|c| char::from_u32(c).unwrap());
+                (CharEscape(key), values.map(CharEscape))
+            })
+            .collect::<Vec<_>>();
 
-            writeln!(s, "    }}")?;
-        }
+        writeln!(
+            out,
+            r#"
+#[rustfmt::skip]
+pub(super) static {name}: &[(char, [char; 3]); {len}] = &[{lut}];
+"#,
+            len = lut.len(),
+            lut = fmt_list(lut),
+        )
+        .unwrap();
     }
 
-    writeln!(s, "}}")?;
-    Ok(s)
-}
-
-fn generate_asserts(
-    s: &mut String,
-    prop: &str,
-    points: &[u32],
-    truthy: bool,
-) -> Result<(), fmt::Error> {
-    let truthy = if truthy { "" } else { "!" };
-    for range in ranges_from_set(points) {
-        let start = char::from_u32(range.start).unwrap();
-        let end = char::from_u32(range.end - 1).unwrap();
-        match range.len() {
-            1 => writeln!(s, "        assert!({truthy}unicode_data::{prop}::lookup({start:?}));")?,
-            _ => {
-                writeln!(s, "        for c in {start:?}..={end:?} {{")?;
-                writeln!(s, "            assert!({truthy}unicode_data::{prop}::lookup(c));")?;
-                writeln!(s, "        }}")?;
-            }
-        }
-    }
-    Ok(())
+    out
 }
 
 /// Group the elements of `set` into contigous ranges

From 724a36dc9ccafd0c7e58456344f970d6ed92a448 Mon Sep 17 00:00:00 2001
From: Karl Meakin <karlwfmeakin@gmail.com>
Date: Sat, 21 Feb 2026 00:02:59 +0000
Subject: [PATCH 0214/1059] Document the case-mapping lookup tables

Add a doc-comment to the top of `case-mapping.rs`.
---
 .../unicode-table-generator/src/case_mapping.rs     | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index a954cb7114e7..f6c8b3353df0 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -1,3 +1,16 @@
+//! Generates lookup tables (LUTs) for "case-mapping": mapping a `char` to its
+//! uppercase or lowercase equivalent(s).
+//!
+//! The first table, `LOWERCASE_TABLE` (respectively `UPPERCASE_TABLE`), is a
+//! sorted array of `(char, u32)` pairs. The case-mapping for a character is
+//! found by binary search.
+//!
+//! If a character expands to multiple characters upon case-folding, the value
+//! in the LUT is actually an index into a second LUT, `LOWERCASE_TABLE_MULTI`
+//! (respectively `UPPERCASE_TABLE_MULTI`). This is signalled by the 22nd bit
+//! of the value being set; since all Unicode code points are less than
+//! 0x110000, this bit is free for us to use.
+
 use std::char;
 use std::collections::BTreeMap;
 use std::fmt::Write;

From 902199b5b194f53e12c1f8b3edb1e2b871d4f77d Mon Sep 17 00:00:00 2001
From: Karl Meakin <karlwfmeakin@gmail.com>
Date: Sun, 22 Feb 2026 04:26:45 +0000
Subject: [PATCH 0215/1059] Compress case-mapping tables

---
 library/core/src/unicode/unicode_data.rs      | 1211 ++++++-----------
 .../src/case_mapping.rs                       |  440 ++++--
 .../src/fmt_helpers.rs                        |   17 +
 src/tools/unicode-table-generator/src/main.rs |    4 +-
 4 files changed, 757 insertions(+), 915 deletions(-)

diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index 429b60a68f43..dd3712669e50 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -7,9 +7,9 @@
 // N               :   463 bytes,   1914 codepoints in 145 ranges (U+0000B2 - U+01FBFA) using skiplist
 // Uppercase       :   799 bytes,   1980 codepoints in 659 ranges (U+0000C0 - U+01F18A) using bitset
 // White_Space     :   256 bytes,     19 codepoints in   8 ranges (U+000085 - U+003001) using cascading
-// to_lower        : 11708 bytes
-// to_upper        : 13656 bytes
-// Total           : 31911 bytes
+// to_lower        :  1112 bytes,   1462 codepoints in 185 ranges (U+0000C0 - U+01E921) using 2-level LUT
+// to_upper        :  1998 bytes,   1554 codepoints in 299 ranges (U+0000B5 - U+01E943) using 2-level LUT
+// Total           :  9657 bytes
 
 #[inline(always)]
 const fn bitset_search<
@@ -758,833 +758,396 @@ pub const fn lookup(c: char) -> bool {
 
 #[rustfmt::skip]
 pub mod conversions {
-    const INDEX_MASK: u32 = 0x400000;
+
+
+    use crate::ops::RangeInclusive;
+
+    struct L1Lut {
+        l2_luts: [L2Lut; 2],
+    }
+
+    struct L2Lut {
+        singles: &'static [(Range, i16)],
+        multis: &'static [(u16, [u16; 3])],
+    }
+
+    #[derive(Copy, Clone)]
+    struct Range {
+        start: u16,
+        len: u8,
+        parity: bool,
+    }
+
+    impl Range {
+        const fn new(range: RangeInclusive<u16>, parity: bool) -> Self {
+            let start = *range.start();
+            let end = *range.end();
+            assert!(start <= end);
+
+            let len = end - start;
+            assert!(len <= 255);
+
+            Self { start, len: len as u8, parity }
+        }
+
+        const fn singleton(start: u16) -> Self {
+            Self::new(start..=start, false)
+        }
+
+        const fn step_by_1(range: RangeInclusive<u16>) -> Self {
+            Self::new(range, false)
+        }
+
+        const fn step_by_2(range: RangeInclusive<u16>) -> Self {
+            Self::new(range, true)
+        }
+
+        const fn start(&self) -> u16 {
+            self.start
+        }
+
+        const fn end(&self) -> u16 {
+            self.start + self.len as u16
+        }
+    }
+
+    fn deconstruct(c: char) -> (u16, u16) {
+        let c = c as u32;
+        let plane = (c >> 16) as u16;
+        let low = c as u16;
+        (plane, low)
+    }
+
+    unsafe fn reconstruct(plane: u16, low: u16) -> char {
+        // SAFETY: The caller must ensure that the result is a valid `char`.
+        unsafe { char::from_u32_unchecked(((plane as u32) << 16) | (low as u32)) }
+    }
+
+    fn lookup(input: char, ascii: char, l1_lut: &L1Lut) -> [char; 3] {
+        if input.is_ascii() {
+            return [ascii, '\0', '\0'];
+        }
+
+        let (input_high, input_low) = deconstruct(input);
+        let Some(l2_lut) = l1_lut.l2_luts.get(input_high as usize) else {
+            return [input, '\0', '\0'];
+        };
+
+        let idx = l2_lut.singles.binary_search_by(|(range, _)| {
+            use crate::cmp::Ordering;
+
+            if input_low < range.start() {
+                Ordering::Greater
+            } else if input_low > range.end() {
+                Ordering::Less
+            } else {
+                Ordering::Equal
+            }
+        });
+        if let Ok(idx) = idx {
+            // SAFETY: binary search guarantees that the index is in bounds.
+            let &(range, output_delta) = unsafe { l2_lut.singles.get_unchecked(idx) };
+            let mask = range.parity as u16;
+            if input_low & mask == range.start() & mask {
+                let output_low = input_low.wrapping_add_signed(output_delta);
+                // SAFETY: Table data are guaranteed to be valid Unicode.
+                let output = unsafe { reconstruct(input_high, output_low) };
+                return [output, '\0', '\0'];
+            }
+        };
+
+        if let Ok(idx) = l2_lut.multis.binary_search_by_key(&input_low, |&(p, _)| p) {
+            // SAFETY: binary search guarantees that the index is in bounds.
+            let &(_, output_lows) = unsafe { l2_lut.multis.get_unchecked(idx) };
+            // SAFETY: Table data are guaranteed to be valid Unicode.
+            let output = output_lows.map(|output_low| unsafe { reconstruct(input_high, output_low) });
+            return output;
+        };
+
+        [input, '\0', '\0']
+    }
 
     pub fn to_lower(c: char) -> [char; 3] {
-        if c.is_ascii() {
-            [(c as u8).to_ascii_lowercase() as char, '\0', '\0']
-        } else {
-            LOWERCASE_TABLE
-                .binary_search_by(|&(key, _)| key.cmp(&c))
-                .map(|i| {
-                    // SAFETY: i is the result of the binary search
-                    let u = unsafe { LOWERCASE_TABLE.get_unchecked(i) }.1;
-                    char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                        // SAFETY: Index comes from statically generated table
-                        unsafe { *LOWERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                    })
-                })
-                .unwrap_or([c, '\0', '\0'])
-        }
+        lookup(c, c.to_ascii_lowercase(), &LOWERCASE_LUT)
     }
 
     pub fn to_upper(c: char) -> [char; 3] {
-        if c.is_ascii() {
-            [(c as u8).to_ascii_uppercase() as char, '\0', '\0']
-        } else {
-            UPPERCASE_TABLE
-                .binary_search_by(|&(key, _)| key.cmp(&c))
-                .map(|i| {
-                    // SAFETY: i is the result of the binary search
-                    let u = unsafe { UPPERCASE_TABLE.get_unchecked(i) }.1;
-                    char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                        // SAFETY: Index comes from statically generated table
-                        unsafe { *UPPERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                    })
-                })
-                .unwrap_or([c, '\0', '\0'])
-        }
+        lookup(c, c.to_ascii_uppercase(), &UPPERCASE_LUT)
     }
 
-    static LOWERCASE_TABLE: &[(char, u32); 1462] = &[
-        ('\u{c0}', 224), ('\u{c1}', 225), ('\u{c2}', 226), ('\u{c3}', 227), ('\u{c4}', 228),
-        ('\u{c5}', 229), ('\u{c6}', 230), ('\u{c7}', 231), ('\u{c8}', 232), ('\u{c9}', 233),
-        ('\u{ca}', 234), ('\u{cb}', 235), ('\u{cc}', 236), ('\u{cd}', 237), ('\u{ce}', 238),
-        ('\u{cf}', 239), ('\u{d0}', 240), ('\u{d1}', 241), ('\u{d2}', 242), ('\u{d3}', 243),
-        ('\u{d4}', 244), ('\u{d5}', 245), ('\u{d6}', 246), ('\u{d8}', 248), ('\u{d9}', 249),
-        ('\u{da}', 250), ('\u{db}', 251), ('\u{dc}', 252), ('\u{dd}', 253), ('\u{de}', 254),
-        ('\u{100}', 257), ('\u{102}', 259), ('\u{104}', 261), ('\u{106}', 263), ('\u{108}', 265),
-        ('\u{10a}', 267), ('\u{10c}', 269), ('\u{10e}', 271), ('\u{110}', 273), ('\u{112}', 275),
-        ('\u{114}', 277), ('\u{116}', 279), ('\u{118}', 281), ('\u{11a}', 283), ('\u{11c}', 285),
-        ('\u{11e}', 287), ('\u{120}', 289), ('\u{122}', 291), ('\u{124}', 293), ('\u{126}', 295),
-        ('\u{128}', 297), ('\u{12a}', 299), ('\u{12c}', 301), ('\u{12e}', 303),
-        ('\u{130}', 4194304), ('\u{132}', 307), ('\u{134}', 309), ('\u{136}', 311),
-        ('\u{139}', 314), ('\u{13b}', 316), ('\u{13d}', 318), ('\u{13f}', 320), ('\u{141}', 322),
-        ('\u{143}', 324), ('\u{145}', 326), ('\u{147}', 328), ('\u{14a}', 331), ('\u{14c}', 333),
-        ('\u{14e}', 335), ('\u{150}', 337), ('\u{152}', 339), ('\u{154}', 341), ('\u{156}', 343),
-        ('\u{158}', 345), ('\u{15a}', 347), ('\u{15c}', 349), ('\u{15e}', 351), ('\u{160}', 353),
-        ('\u{162}', 355), ('\u{164}', 357), ('\u{166}', 359), ('\u{168}', 361), ('\u{16a}', 363),
-        ('\u{16c}', 365), ('\u{16e}', 367), ('\u{170}', 369), ('\u{172}', 371), ('\u{174}', 373),
-        ('\u{176}', 375), ('\u{178}', 255), ('\u{179}', 378), ('\u{17b}', 380), ('\u{17d}', 382),
-        ('\u{181}', 595), ('\u{182}', 387), ('\u{184}', 389), ('\u{186}', 596), ('\u{187}', 392),
-        ('\u{189}', 598), ('\u{18a}', 599), ('\u{18b}', 396), ('\u{18e}', 477), ('\u{18f}', 601),
-        ('\u{190}', 603), ('\u{191}', 402), ('\u{193}', 608), ('\u{194}', 611), ('\u{196}', 617),
-        ('\u{197}', 616), ('\u{198}', 409), ('\u{19c}', 623), ('\u{19d}', 626), ('\u{19f}', 629),
-        ('\u{1a0}', 417), ('\u{1a2}', 419), ('\u{1a4}', 421), ('\u{1a6}', 640), ('\u{1a7}', 424),
-        ('\u{1a9}', 643), ('\u{1ac}', 429), ('\u{1ae}', 648), ('\u{1af}', 432), ('\u{1b1}', 650),
-        ('\u{1b2}', 651), ('\u{1b3}', 436), ('\u{1b5}', 438), ('\u{1b7}', 658), ('\u{1b8}', 441),
-        ('\u{1bc}', 445), ('\u{1c4}', 454), ('\u{1c5}', 454), ('\u{1c7}', 457), ('\u{1c8}', 457),
-        ('\u{1ca}', 460), ('\u{1cb}', 460), ('\u{1cd}', 462), ('\u{1cf}', 464), ('\u{1d1}', 466),
-        ('\u{1d3}', 468), ('\u{1d5}', 470), ('\u{1d7}', 472), ('\u{1d9}', 474), ('\u{1db}', 476),
-        ('\u{1de}', 479), ('\u{1e0}', 481), ('\u{1e2}', 483), ('\u{1e4}', 485), ('\u{1e6}', 487),
-        ('\u{1e8}', 489), ('\u{1ea}', 491), ('\u{1ec}', 493), ('\u{1ee}', 495), ('\u{1f1}', 499),
-        ('\u{1f2}', 499), ('\u{1f4}', 501), ('\u{1f6}', 405), ('\u{1f7}', 447), ('\u{1f8}', 505),
-        ('\u{1fa}', 507), ('\u{1fc}', 509), ('\u{1fe}', 511), ('\u{200}', 513), ('\u{202}', 515),
-        ('\u{204}', 517), ('\u{206}', 519), ('\u{208}', 521), ('\u{20a}', 523), ('\u{20c}', 525),
-        ('\u{20e}', 527), ('\u{210}', 529), ('\u{212}', 531), ('\u{214}', 533), ('\u{216}', 535),
-        ('\u{218}', 537), ('\u{21a}', 539), ('\u{21c}', 541), ('\u{21e}', 543), ('\u{220}', 414),
-        ('\u{222}', 547), ('\u{224}', 549), ('\u{226}', 551), ('\u{228}', 553), ('\u{22a}', 555),
-        ('\u{22c}', 557), ('\u{22e}', 559), ('\u{230}', 561), ('\u{232}', 563), ('\u{23a}', 11365),
-        ('\u{23b}', 572), ('\u{23d}', 410), ('\u{23e}', 11366), ('\u{241}', 578), ('\u{243}', 384),
-        ('\u{244}', 649), ('\u{245}', 652), ('\u{246}', 583), ('\u{248}', 585), ('\u{24a}', 587),
-        ('\u{24c}', 589), ('\u{24e}', 591), ('\u{370}', 881), ('\u{372}', 883), ('\u{376}', 887),
-        ('\u{37f}', 1011), ('\u{386}', 940), ('\u{388}', 941), ('\u{389}', 942), ('\u{38a}', 943),
-        ('\u{38c}', 972), ('\u{38e}', 973), ('\u{38f}', 974), ('\u{391}', 945), ('\u{392}', 946),
-        ('\u{393}', 947), ('\u{394}', 948), ('\u{395}', 949), ('\u{396}', 950), ('\u{397}', 951),
-        ('\u{398}', 952), ('\u{399}', 953), ('\u{39a}', 954), ('\u{39b}', 955), ('\u{39c}', 956),
-        ('\u{39d}', 957), ('\u{39e}', 958), ('\u{39f}', 959), ('\u{3a0}', 960), ('\u{3a1}', 961),
-        ('\u{3a3}', 963), ('\u{3a4}', 964), ('\u{3a5}', 965), ('\u{3a6}', 966), ('\u{3a7}', 967),
-        ('\u{3a8}', 968), ('\u{3a9}', 969), ('\u{3aa}', 970), ('\u{3ab}', 971), ('\u{3cf}', 983),
-        ('\u{3d8}', 985), ('\u{3da}', 987), ('\u{3dc}', 989), ('\u{3de}', 991), ('\u{3e0}', 993),
-        ('\u{3e2}', 995), ('\u{3e4}', 997), ('\u{3e6}', 999), ('\u{3e8}', 1001), ('\u{3ea}', 1003),
-        ('\u{3ec}', 1005), ('\u{3ee}', 1007), ('\u{3f4}', 952), ('\u{3f7}', 1016),
-        ('\u{3f9}', 1010), ('\u{3fa}', 1019), ('\u{3fd}', 891), ('\u{3fe}', 892), ('\u{3ff}', 893),
-        ('\u{400}', 1104), ('\u{401}', 1105), ('\u{402}', 1106), ('\u{403}', 1107),
-        ('\u{404}', 1108), ('\u{405}', 1109), ('\u{406}', 1110), ('\u{407}', 1111),
-        ('\u{408}', 1112), ('\u{409}', 1113), ('\u{40a}', 1114), ('\u{40b}', 1115),
-        ('\u{40c}', 1116), ('\u{40d}', 1117), ('\u{40e}', 1118), ('\u{40f}', 1119),
-        ('\u{410}', 1072), ('\u{411}', 1073), ('\u{412}', 1074), ('\u{413}', 1075),
-        ('\u{414}', 1076), ('\u{415}', 1077), ('\u{416}', 1078), ('\u{417}', 1079),
-        ('\u{418}', 1080), ('\u{419}', 1081), ('\u{41a}', 1082), ('\u{41b}', 1083),
-        ('\u{41c}', 1084), ('\u{41d}', 1085), ('\u{41e}', 1086), ('\u{41f}', 1087),
-        ('\u{420}', 1088), ('\u{421}', 1089), ('\u{422}', 1090), ('\u{423}', 1091),
-        ('\u{424}', 1092), ('\u{425}', 1093), ('\u{426}', 1094), ('\u{427}', 1095),
-        ('\u{428}', 1096), ('\u{429}', 1097), ('\u{42a}', 1098), ('\u{42b}', 1099),
-        ('\u{42c}', 1100), ('\u{42d}', 1101), ('\u{42e}', 1102), ('\u{42f}', 1103),
-        ('\u{460}', 1121), ('\u{462}', 1123), ('\u{464}', 1125), ('\u{466}', 1127),
-        ('\u{468}', 1129), ('\u{46a}', 1131), ('\u{46c}', 1133), ('\u{46e}', 1135),
-        ('\u{470}', 1137), ('\u{472}', 1139), ('\u{474}', 1141), ('\u{476}', 1143),
-        ('\u{478}', 1145), ('\u{47a}', 1147), ('\u{47c}', 1149), ('\u{47e}', 1151),
-        ('\u{480}', 1153), ('\u{48a}', 1163), ('\u{48c}', 1165), ('\u{48e}', 1167),
-        ('\u{490}', 1169), ('\u{492}', 1171), ('\u{494}', 1173), ('\u{496}', 1175),
-        ('\u{498}', 1177), ('\u{49a}', 1179), ('\u{49c}', 1181), ('\u{49e}', 1183),
-        ('\u{4a0}', 1185), ('\u{4a2}', 1187), ('\u{4a4}', 1189), ('\u{4a6}', 1191),
-        ('\u{4a8}', 1193), ('\u{4aa}', 1195), ('\u{4ac}', 1197), ('\u{4ae}', 1199),
-        ('\u{4b0}', 1201), ('\u{4b2}', 1203), ('\u{4b4}', 1205), ('\u{4b6}', 1207),
-        ('\u{4b8}', 1209), ('\u{4ba}', 1211), ('\u{4bc}', 1213), ('\u{4be}', 1215),
-        ('\u{4c0}', 1231), ('\u{4c1}', 1218), ('\u{4c3}', 1220), ('\u{4c5}', 1222),
-        ('\u{4c7}', 1224), ('\u{4c9}', 1226), ('\u{4cb}', 1228), ('\u{4cd}', 1230),
-        ('\u{4d0}', 1233), ('\u{4d2}', 1235), ('\u{4d4}', 1237), ('\u{4d6}', 1239),
-        ('\u{4d8}', 1241), ('\u{4da}', 1243), ('\u{4dc}', 1245), ('\u{4de}', 1247),
-        ('\u{4e0}', 1249), ('\u{4e2}', 1251), ('\u{4e4}', 1253), ('\u{4e6}', 1255),
-        ('\u{4e8}', 1257), ('\u{4ea}', 1259), ('\u{4ec}', 1261), ('\u{4ee}', 1263),
-        ('\u{4f0}', 1265), ('\u{4f2}', 1267), ('\u{4f4}', 1269), ('\u{4f6}', 1271),
-        ('\u{4f8}', 1273), ('\u{4fa}', 1275), ('\u{4fc}', 1277), ('\u{4fe}', 1279),
-        ('\u{500}', 1281), ('\u{502}', 1283), ('\u{504}', 1285), ('\u{506}', 1287),
-        ('\u{508}', 1289), ('\u{50a}', 1291), ('\u{50c}', 1293), ('\u{50e}', 1295),
-        ('\u{510}', 1297), ('\u{512}', 1299), ('\u{514}', 1301), ('\u{516}', 1303),
-        ('\u{518}', 1305), ('\u{51a}', 1307), ('\u{51c}', 1309), ('\u{51e}', 1311),
-        ('\u{520}', 1313), ('\u{522}', 1315), ('\u{524}', 1317), ('\u{526}', 1319),
-        ('\u{528}', 1321), ('\u{52a}', 1323), ('\u{52c}', 1325), ('\u{52e}', 1327),
-        ('\u{531}', 1377), ('\u{532}', 1378), ('\u{533}', 1379), ('\u{534}', 1380),
-        ('\u{535}', 1381), ('\u{536}', 1382), ('\u{537}', 1383), ('\u{538}', 1384),
-        ('\u{539}', 1385), ('\u{53a}', 1386), ('\u{53b}', 1387), ('\u{53c}', 1388),
-        ('\u{53d}', 1389), ('\u{53e}', 1390), ('\u{53f}', 1391), ('\u{540}', 1392),
-        ('\u{541}', 1393), ('\u{542}', 1394), ('\u{543}', 1395), ('\u{544}', 1396),
-        ('\u{545}', 1397), ('\u{546}', 1398), ('\u{547}', 1399), ('\u{548}', 1400),
-        ('\u{549}', 1401), ('\u{54a}', 1402), ('\u{54b}', 1403), ('\u{54c}', 1404),
-        ('\u{54d}', 1405), ('\u{54e}', 1406), ('\u{54f}', 1407), ('\u{550}', 1408),
-        ('\u{551}', 1409), ('\u{552}', 1410), ('\u{553}', 1411), ('\u{554}', 1412),
-        ('\u{555}', 1413), ('\u{556}', 1414), ('\u{10a0}', 11520), ('\u{10a1}', 11521),
-        ('\u{10a2}', 11522), ('\u{10a3}', 11523), ('\u{10a4}', 11524), ('\u{10a5}', 11525),
-        ('\u{10a6}', 11526), ('\u{10a7}', 11527), ('\u{10a8}', 11528), ('\u{10a9}', 11529),
-        ('\u{10aa}', 11530), ('\u{10ab}', 11531), ('\u{10ac}', 11532), ('\u{10ad}', 11533),
-        ('\u{10ae}', 11534), ('\u{10af}', 11535), ('\u{10b0}', 11536), ('\u{10b1}', 11537),
-        ('\u{10b2}', 11538), ('\u{10b3}', 11539), ('\u{10b4}', 11540), ('\u{10b5}', 11541),
-        ('\u{10b6}', 11542), ('\u{10b7}', 11543), ('\u{10b8}', 11544), ('\u{10b9}', 11545),
-        ('\u{10ba}', 11546), ('\u{10bb}', 11547), ('\u{10bc}', 11548), ('\u{10bd}', 11549),
-        ('\u{10be}', 11550), ('\u{10bf}', 11551), ('\u{10c0}', 11552), ('\u{10c1}', 11553),
-        ('\u{10c2}', 11554), ('\u{10c3}', 11555), ('\u{10c4}', 11556), ('\u{10c5}', 11557),
-        ('\u{10c7}', 11559), ('\u{10cd}', 11565), ('\u{13a0}', 43888), ('\u{13a1}', 43889),
-        ('\u{13a2}', 43890), ('\u{13a3}', 43891), ('\u{13a4}', 43892), ('\u{13a5}', 43893),
-        ('\u{13a6}', 43894), ('\u{13a7}', 43895), ('\u{13a8}', 43896), ('\u{13a9}', 43897),
-        ('\u{13aa}', 43898), ('\u{13ab}', 43899), ('\u{13ac}', 43900), ('\u{13ad}', 43901),
-        ('\u{13ae}', 43902), ('\u{13af}', 43903), ('\u{13b0}', 43904), ('\u{13b1}', 43905),
-        ('\u{13b2}', 43906), ('\u{13b3}', 43907), ('\u{13b4}', 43908), ('\u{13b5}', 43909),
-        ('\u{13b6}', 43910), ('\u{13b7}', 43911), ('\u{13b8}', 43912), ('\u{13b9}', 43913),
-        ('\u{13ba}', 43914), ('\u{13bb}', 43915), ('\u{13bc}', 43916), ('\u{13bd}', 43917),
-        ('\u{13be}', 43918), ('\u{13bf}', 43919), ('\u{13c0}', 43920), ('\u{13c1}', 43921),
-        ('\u{13c2}', 43922), ('\u{13c3}', 43923), ('\u{13c4}', 43924), ('\u{13c5}', 43925),
-        ('\u{13c6}', 43926), ('\u{13c7}', 43927), ('\u{13c8}', 43928), ('\u{13c9}', 43929),
-        ('\u{13ca}', 43930), ('\u{13cb}', 43931), ('\u{13cc}', 43932), ('\u{13cd}', 43933),
-        ('\u{13ce}', 43934), ('\u{13cf}', 43935), ('\u{13d0}', 43936), ('\u{13d1}', 43937),
-        ('\u{13d2}', 43938), ('\u{13d3}', 43939), ('\u{13d4}', 43940), ('\u{13d5}', 43941),
-        ('\u{13d6}', 43942), ('\u{13d7}', 43943), ('\u{13d8}', 43944), ('\u{13d9}', 43945),
-        ('\u{13da}', 43946), ('\u{13db}', 43947), ('\u{13dc}', 43948), ('\u{13dd}', 43949),
-        ('\u{13de}', 43950), ('\u{13df}', 43951), ('\u{13e0}', 43952), ('\u{13e1}', 43953),
-        ('\u{13e2}', 43954), ('\u{13e3}', 43955), ('\u{13e4}', 43956), ('\u{13e5}', 43957),
-        ('\u{13e6}', 43958), ('\u{13e7}', 43959), ('\u{13e8}', 43960), ('\u{13e9}', 43961),
-        ('\u{13ea}', 43962), ('\u{13eb}', 43963), ('\u{13ec}', 43964), ('\u{13ed}', 43965),
-        ('\u{13ee}', 43966), ('\u{13ef}', 43967), ('\u{13f0}', 5112), ('\u{13f1}', 5113),
-        ('\u{13f2}', 5114), ('\u{13f3}', 5115), ('\u{13f4}', 5116), ('\u{13f5}', 5117),
-        ('\u{1c89}', 7306), ('\u{1c90}', 4304), ('\u{1c91}', 4305), ('\u{1c92}', 4306),
-        ('\u{1c93}', 4307), ('\u{1c94}', 4308), ('\u{1c95}', 4309), ('\u{1c96}', 4310),
-        ('\u{1c97}', 4311), ('\u{1c98}', 4312), ('\u{1c99}', 4313), ('\u{1c9a}', 4314),
-        ('\u{1c9b}', 4315), ('\u{1c9c}', 4316), ('\u{1c9d}', 4317), ('\u{1c9e}', 4318),
-        ('\u{1c9f}', 4319), ('\u{1ca0}', 4320), ('\u{1ca1}', 4321), ('\u{1ca2}', 4322),
-        ('\u{1ca3}', 4323), ('\u{1ca4}', 4324), ('\u{1ca5}', 4325), ('\u{1ca6}', 4326),
-        ('\u{1ca7}', 4327), ('\u{1ca8}', 4328), ('\u{1ca9}', 4329), ('\u{1caa}', 4330),
-        ('\u{1cab}', 4331), ('\u{1cac}', 4332), ('\u{1cad}', 4333), ('\u{1cae}', 4334),
-        ('\u{1caf}', 4335), ('\u{1cb0}', 4336), ('\u{1cb1}', 4337), ('\u{1cb2}', 4338),
-        ('\u{1cb3}', 4339), ('\u{1cb4}', 4340), ('\u{1cb5}', 4341), ('\u{1cb6}', 4342),
-        ('\u{1cb7}', 4343), ('\u{1cb8}', 4344), ('\u{1cb9}', 4345), ('\u{1cba}', 4346),
-        ('\u{1cbd}', 4349), ('\u{1cbe}', 4350), ('\u{1cbf}', 4351), ('\u{1e00}', 7681),
-        ('\u{1e02}', 7683), ('\u{1e04}', 7685), ('\u{1e06}', 7687), ('\u{1e08}', 7689),
-        ('\u{1e0a}', 7691), ('\u{1e0c}', 7693), ('\u{1e0e}', 7695), ('\u{1e10}', 7697),
-        ('\u{1e12}', 7699), ('\u{1e14}', 7701), ('\u{1e16}', 7703), ('\u{1e18}', 7705),
-        ('\u{1e1a}', 7707), ('\u{1e1c}', 7709), ('\u{1e1e}', 7711), ('\u{1e20}', 7713),
-        ('\u{1e22}', 7715), ('\u{1e24}', 7717), ('\u{1e26}', 7719), ('\u{1e28}', 7721),
-        ('\u{1e2a}', 7723), ('\u{1e2c}', 7725), ('\u{1e2e}', 7727), ('\u{1e30}', 7729),
-        ('\u{1e32}', 7731), ('\u{1e34}', 7733), ('\u{1e36}', 7735), ('\u{1e38}', 7737),
-        ('\u{1e3a}', 7739), ('\u{1e3c}', 7741), ('\u{1e3e}', 7743), ('\u{1e40}', 7745),
-        ('\u{1e42}', 7747), ('\u{1e44}', 7749), ('\u{1e46}', 7751), ('\u{1e48}', 7753),
-        ('\u{1e4a}', 7755), ('\u{1e4c}', 7757), ('\u{1e4e}', 7759), ('\u{1e50}', 7761),
-        ('\u{1e52}', 7763), ('\u{1e54}', 7765), ('\u{1e56}', 7767), ('\u{1e58}', 7769),
-        ('\u{1e5a}', 7771), ('\u{1e5c}', 7773), ('\u{1e5e}', 7775), ('\u{1e60}', 7777),
-        ('\u{1e62}', 7779), ('\u{1e64}', 7781), ('\u{1e66}', 7783), ('\u{1e68}', 7785),
-        ('\u{1e6a}', 7787), ('\u{1e6c}', 7789), ('\u{1e6e}', 7791), ('\u{1e70}', 7793),
-        ('\u{1e72}', 7795), ('\u{1e74}', 7797), ('\u{1e76}', 7799), ('\u{1e78}', 7801),
-        ('\u{1e7a}', 7803), ('\u{1e7c}', 7805), ('\u{1e7e}', 7807), ('\u{1e80}', 7809),
-        ('\u{1e82}', 7811), ('\u{1e84}', 7813), ('\u{1e86}', 7815), ('\u{1e88}', 7817),
-        ('\u{1e8a}', 7819), ('\u{1e8c}', 7821), ('\u{1e8e}', 7823), ('\u{1e90}', 7825),
-        ('\u{1e92}', 7827), ('\u{1e94}', 7829), ('\u{1e9e}', 223), ('\u{1ea0}', 7841),
-        ('\u{1ea2}', 7843), ('\u{1ea4}', 7845), ('\u{1ea6}', 7847), ('\u{1ea8}', 7849),
-        ('\u{1eaa}', 7851), ('\u{1eac}', 7853), ('\u{1eae}', 7855), ('\u{1eb0}', 7857),
-        ('\u{1eb2}', 7859), ('\u{1eb4}', 7861), ('\u{1eb6}', 7863), ('\u{1eb8}', 7865),
-        ('\u{1eba}', 7867), ('\u{1ebc}', 7869), ('\u{1ebe}', 7871), ('\u{1ec0}', 7873),
-        ('\u{1ec2}', 7875), ('\u{1ec4}', 7877), ('\u{1ec6}', 7879), ('\u{1ec8}', 7881),
-        ('\u{1eca}', 7883), ('\u{1ecc}', 7885), ('\u{1ece}', 7887), ('\u{1ed0}', 7889),
-        ('\u{1ed2}', 7891), ('\u{1ed4}', 7893), ('\u{1ed6}', 7895), ('\u{1ed8}', 7897),
-        ('\u{1eda}', 7899), ('\u{1edc}', 7901), ('\u{1ede}', 7903), ('\u{1ee0}', 7905),
-        ('\u{1ee2}', 7907), ('\u{1ee4}', 7909), ('\u{1ee6}', 7911), ('\u{1ee8}', 7913),
-        ('\u{1eea}', 7915), ('\u{1eec}', 7917), ('\u{1eee}', 7919), ('\u{1ef0}', 7921),
-        ('\u{1ef2}', 7923), ('\u{1ef4}', 7925), ('\u{1ef6}', 7927), ('\u{1ef8}', 7929),
-        ('\u{1efa}', 7931), ('\u{1efc}', 7933), ('\u{1efe}', 7935), ('\u{1f08}', 7936),
-        ('\u{1f09}', 7937), ('\u{1f0a}', 7938), ('\u{1f0b}', 7939), ('\u{1f0c}', 7940),
-        ('\u{1f0d}', 7941), ('\u{1f0e}', 7942), ('\u{1f0f}', 7943), ('\u{1f18}', 7952),
-        ('\u{1f19}', 7953), ('\u{1f1a}', 7954), ('\u{1f1b}', 7955), ('\u{1f1c}', 7956),
-        ('\u{1f1d}', 7957), ('\u{1f28}', 7968), ('\u{1f29}', 7969), ('\u{1f2a}', 7970),
-        ('\u{1f2b}', 7971), ('\u{1f2c}', 7972), ('\u{1f2d}', 7973), ('\u{1f2e}', 7974),
-        ('\u{1f2f}', 7975), ('\u{1f38}', 7984), ('\u{1f39}', 7985), ('\u{1f3a}', 7986),
-        ('\u{1f3b}', 7987), ('\u{1f3c}', 7988), ('\u{1f3d}', 7989), ('\u{1f3e}', 7990),
-        ('\u{1f3f}', 7991), ('\u{1f48}', 8000), ('\u{1f49}', 8001), ('\u{1f4a}', 8002),
-        ('\u{1f4b}', 8003), ('\u{1f4c}', 8004), ('\u{1f4d}', 8005), ('\u{1f59}', 8017),
-        ('\u{1f5b}', 8019), ('\u{1f5d}', 8021), ('\u{1f5f}', 8023), ('\u{1f68}', 8032),
-        ('\u{1f69}', 8033), ('\u{1f6a}', 8034), ('\u{1f6b}', 8035), ('\u{1f6c}', 8036),
-        ('\u{1f6d}', 8037), ('\u{1f6e}', 8038), ('\u{1f6f}', 8039), ('\u{1f88}', 8064),
-        ('\u{1f89}', 8065), ('\u{1f8a}', 8066), ('\u{1f8b}', 8067), ('\u{1f8c}', 8068),
-        ('\u{1f8d}', 8069), ('\u{1f8e}', 8070), ('\u{1f8f}', 8071), ('\u{1f98}', 8080),
-        ('\u{1f99}', 8081), ('\u{1f9a}', 8082), ('\u{1f9b}', 8083), ('\u{1f9c}', 8084),
-        ('\u{1f9d}', 8085), ('\u{1f9e}', 8086), ('\u{1f9f}', 8087), ('\u{1fa8}', 8096),
-        ('\u{1fa9}', 8097), ('\u{1faa}', 8098), ('\u{1fab}', 8099), ('\u{1fac}', 8100),
-        ('\u{1fad}', 8101), ('\u{1fae}', 8102), ('\u{1faf}', 8103), ('\u{1fb8}', 8112),
-        ('\u{1fb9}', 8113), ('\u{1fba}', 8048), ('\u{1fbb}', 8049), ('\u{1fbc}', 8115),
-        ('\u{1fc8}', 8050), ('\u{1fc9}', 8051), ('\u{1fca}', 8052), ('\u{1fcb}', 8053),
-        ('\u{1fcc}', 8131), ('\u{1fd8}', 8144), ('\u{1fd9}', 8145), ('\u{1fda}', 8054),
-        ('\u{1fdb}', 8055), ('\u{1fe8}', 8160), ('\u{1fe9}', 8161), ('\u{1fea}', 8058),
-        ('\u{1feb}', 8059), ('\u{1fec}', 8165), ('\u{1ff8}', 8056), ('\u{1ff9}', 8057),
-        ('\u{1ffa}', 8060), ('\u{1ffb}', 8061), ('\u{1ffc}', 8179), ('\u{2126}', 969),
-        ('\u{212a}', 107), ('\u{212b}', 229), ('\u{2132}', 8526), ('\u{2160}', 8560),
-        ('\u{2161}', 8561), ('\u{2162}', 8562), ('\u{2163}', 8563), ('\u{2164}', 8564),
-        ('\u{2165}', 8565), ('\u{2166}', 8566), ('\u{2167}', 8567), ('\u{2168}', 8568),
-        ('\u{2169}', 8569), ('\u{216a}', 8570), ('\u{216b}', 8571), ('\u{216c}', 8572),
-        ('\u{216d}', 8573), ('\u{216e}', 8574), ('\u{216f}', 8575), ('\u{2183}', 8580),
-        ('\u{24b6}', 9424), ('\u{24b7}', 9425), ('\u{24b8}', 9426), ('\u{24b9}', 9427),
-        ('\u{24ba}', 9428), ('\u{24bb}', 9429), ('\u{24bc}', 9430), ('\u{24bd}', 9431),
-        ('\u{24be}', 9432), ('\u{24bf}', 9433), ('\u{24c0}', 9434), ('\u{24c1}', 9435),
-        ('\u{24c2}', 9436), ('\u{24c3}', 9437), ('\u{24c4}', 9438), ('\u{24c5}', 9439),
-        ('\u{24c6}', 9440), ('\u{24c7}', 9441), ('\u{24c8}', 9442), ('\u{24c9}', 9443),
-        ('\u{24ca}', 9444), ('\u{24cb}', 9445), ('\u{24cc}', 9446), ('\u{24cd}', 9447),
-        ('\u{24ce}', 9448), ('\u{24cf}', 9449), ('\u{2c00}', 11312), ('\u{2c01}', 11313),
-        ('\u{2c02}', 11314), ('\u{2c03}', 11315), ('\u{2c04}', 11316), ('\u{2c05}', 11317),
-        ('\u{2c06}', 11318), ('\u{2c07}', 11319), ('\u{2c08}', 11320), ('\u{2c09}', 11321),
-        ('\u{2c0a}', 11322), ('\u{2c0b}', 11323), ('\u{2c0c}', 11324), ('\u{2c0d}', 11325),
-        ('\u{2c0e}', 11326), ('\u{2c0f}', 11327), ('\u{2c10}', 11328), ('\u{2c11}', 11329),
-        ('\u{2c12}', 11330), ('\u{2c13}', 11331), ('\u{2c14}', 11332), ('\u{2c15}', 11333),
-        ('\u{2c16}', 11334), ('\u{2c17}', 11335), ('\u{2c18}', 11336), ('\u{2c19}', 11337),
-        ('\u{2c1a}', 11338), ('\u{2c1b}', 11339), ('\u{2c1c}', 11340), ('\u{2c1d}', 11341),
-        ('\u{2c1e}', 11342), ('\u{2c1f}', 11343), ('\u{2c20}', 11344), ('\u{2c21}', 11345),
-        ('\u{2c22}', 11346), ('\u{2c23}', 11347), ('\u{2c24}', 11348), ('\u{2c25}', 11349),
-        ('\u{2c26}', 11350), ('\u{2c27}', 11351), ('\u{2c28}', 11352), ('\u{2c29}', 11353),
-        ('\u{2c2a}', 11354), ('\u{2c2b}', 11355), ('\u{2c2c}', 11356), ('\u{2c2d}', 11357),
-        ('\u{2c2e}', 11358), ('\u{2c2f}', 11359), ('\u{2c60}', 11361), ('\u{2c62}', 619),
-        ('\u{2c63}', 7549), ('\u{2c64}', 637), ('\u{2c67}', 11368), ('\u{2c69}', 11370),
-        ('\u{2c6b}', 11372), ('\u{2c6d}', 593), ('\u{2c6e}', 625), ('\u{2c6f}', 592),
-        ('\u{2c70}', 594), ('\u{2c72}', 11379), ('\u{2c75}', 11382), ('\u{2c7e}', 575),
-        ('\u{2c7f}', 576), ('\u{2c80}', 11393), ('\u{2c82}', 11395), ('\u{2c84}', 11397),
-        ('\u{2c86}', 11399), ('\u{2c88}', 11401), ('\u{2c8a}', 11403), ('\u{2c8c}', 11405),
-        ('\u{2c8e}', 11407), ('\u{2c90}', 11409), ('\u{2c92}', 11411), ('\u{2c94}', 11413),
-        ('\u{2c96}', 11415), ('\u{2c98}', 11417), ('\u{2c9a}', 11419), ('\u{2c9c}', 11421),
-        ('\u{2c9e}', 11423), ('\u{2ca0}', 11425), ('\u{2ca2}', 11427), ('\u{2ca4}', 11429),
-        ('\u{2ca6}', 11431), ('\u{2ca8}', 11433), ('\u{2caa}', 11435), ('\u{2cac}', 11437),
-        ('\u{2cae}', 11439), ('\u{2cb0}', 11441), ('\u{2cb2}', 11443), ('\u{2cb4}', 11445),
-        ('\u{2cb6}', 11447), ('\u{2cb8}', 11449), ('\u{2cba}', 11451), ('\u{2cbc}', 11453),
-        ('\u{2cbe}', 11455), ('\u{2cc0}', 11457), ('\u{2cc2}', 11459), ('\u{2cc4}', 11461),
-        ('\u{2cc6}', 11463), ('\u{2cc8}', 11465), ('\u{2cca}', 11467), ('\u{2ccc}', 11469),
-        ('\u{2cce}', 11471), ('\u{2cd0}', 11473), ('\u{2cd2}', 11475), ('\u{2cd4}', 11477),
-        ('\u{2cd6}', 11479), ('\u{2cd8}', 11481), ('\u{2cda}', 11483), ('\u{2cdc}', 11485),
-        ('\u{2cde}', 11487), ('\u{2ce0}', 11489), ('\u{2ce2}', 11491), ('\u{2ceb}', 11500),
-        ('\u{2ced}', 11502), ('\u{2cf2}', 11507), ('\u{a640}', 42561), ('\u{a642}', 42563),
-        ('\u{a644}', 42565), ('\u{a646}', 42567), ('\u{a648}', 42569), ('\u{a64a}', 42571),
-        ('\u{a64c}', 42573), ('\u{a64e}', 42575), ('\u{a650}', 42577), ('\u{a652}', 42579),
-        ('\u{a654}', 42581), ('\u{a656}', 42583), ('\u{a658}', 42585), ('\u{a65a}', 42587),
-        ('\u{a65c}', 42589), ('\u{a65e}', 42591), ('\u{a660}', 42593), ('\u{a662}', 42595),
-        ('\u{a664}', 42597), ('\u{a666}', 42599), ('\u{a668}', 42601), ('\u{a66a}', 42603),
-        ('\u{a66c}', 42605), ('\u{a680}', 42625), ('\u{a682}', 42627), ('\u{a684}', 42629),
-        ('\u{a686}', 42631), ('\u{a688}', 42633), ('\u{a68a}', 42635), ('\u{a68c}', 42637),
-        ('\u{a68e}', 42639), ('\u{a690}', 42641), ('\u{a692}', 42643), ('\u{a694}', 42645),
-        ('\u{a696}', 42647), ('\u{a698}', 42649), ('\u{a69a}', 42651), ('\u{a722}', 42787),
-        ('\u{a724}', 42789), ('\u{a726}', 42791), ('\u{a728}', 42793), ('\u{a72a}', 42795),
-        ('\u{a72c}', 42797), ('\u{a72e}', 42799), ('\u{a732}', 42803), ('\u{a734}', 42805),
-        ('\u{a736}', 42807), ('\u{a738}', 42809), ('\u{a73a}', 42811), ('\u{a73c}', 42813),
-        ('\u{a73e}', 42815), ('\u{a740}', 42817), ('\u{a742}', 42819), ('\u{a744}', 42821),
-        ('\u{a746}', 42823), ('\u{a748}', 42825), ('\u{a74a}', 42827), ('\u{a74c}', 42829),
-        ('\u{a74e}', 42831), ('\u{a750}', 42833), ('\u{a752}', 42835), ('\u{a754}', 42837),
-        ('\u{a756}', 42839), ('\u{a758}', 42841), ('\u{a75a}', 42843), ('\u{a75c}', 42845),
-        ('\u{a75e}', 42847), ('\u{a760}', 42849), ('\u{a762}', 42851), ('\u{a764}', 42853),
-        ('\u{a766}', 42855), ('\u{a768}', 42857), ('\u{a76a}', 42859), ('\u{a76c}', 42861),
-        ('\u{a76e}', 42863), ('\u{a779}', 42874), ('\u{a77b}', 42876), ('\u{a77d}', 7545),
-        ('\u{a77e}', 42879), ('\u{a780}', 42881), ('\u{a782}', 42883), ('\u{a784}', 42885),
-        ('\u{a786}', 42887), ('\u{a78b}', 42892), ('\u{a78d}', 613), ('\u{a790}', 42897),
-        ('\u{a792}', 42899), ('\u{a796}', 42903), ('\u{a798}', 42905), ('\u{a79a}', 42907),
-        ('\u{a79c}', 42909), ('\u{a79e}', 42911), ('\u{a7a0}', 42913), ('\u{a7a2}', 42915),
-        ('\u{a7a4}', 42917), ('\u{a7a6}', 42919), ('\u{a7a8}', 42921), ('\u{a7aa}', 614),
-        ('\u{a7ab}', 604), ('\u{a7ac}', 609), ('\u{a7ad}', 620), ('\u{a7ae}', 618),
-        ('\u{a7b0}', 670), ('\u{a7b1}', 647), ('\u{a7b2}', 669), ('\u{a7b3}', 43859),
-        ('\u{a7b4}', 42933), ('\u{a7b6}', 42935), ('\u{a7b8}', 42937), ('\u{a7ba}', 42939),
-        ('\u{a7bc}', 42941), ('\u{a7be}', 42943), ('\u{a7c0}', 42945), ('\u{a7c2}', 42947),
-        ('\u{a7c4}', 42900), ('\u{a7c5}', 642), ('\u{a7c6}', 7566), ('\u{a7c7}', 42952),
-        ('\u{a7c9}', 42954), ('\u{a7cb}', 612), ('\u{a7cc}', 42957), ('\u{a7ce}', 42959),
-        ('\u{a7d0}', 42961), ('\u{a7d2}', 42963), ('\u{a7d4}', 42965), ('\u{a7d6}', 42967),
-        ('\u{a7d8}', 42969), ('\u{a7da}', 42971), ('\u{a7dc}', 411), ('\u{a7f5}', 42998),
-        ('\u{ff21}', 65345), ('\u{ff22}', 65346), ('\u{ff23}', 65347), ('\u{ff24}', 65348),
-        ('\u{ff25}', 65349), ('\u{ff26}', 65350), ('\u{ff27}', 65351), ('\u{ff28}', 65352),
-        ('\u{ff29}', 65353), ('\u{ff2a}', 65354), ('\u{ff2b}', 65355), ('\u{ff2c}', 65356),
-        ('\u{ff2d}', 65357), ('\u{ff2e}', 65358), ('\u{ff2f}', 65359), ('\u{ff30}', 65360),
-        ('\u{ff31}', 65361), ('\u{ff32}', 65362), ('\u{ff33}', 65363), ('\u{ff34}', 65364),
-        ('\u{ff35}', 65365), ('\u{ff36}', 65366), ('\u{ff37}', 65367), ('\u{ff38}', 65368),
-        ('\u{ff39}', 65369), ('\u{ff3a}', 65370), ('\u{10400}', 66600), ('\u{10401}', 66601),
-        ('\u{10402}', 66602), ('\u{10403}', 66603), ('\u{10404}', 66604), ('\u{10405}', 66605),
-        ('\u{10406}', 66606), ('\u{10407}', 66607), ('\u{10408}', 66608), ('\u{10409}', 66609),
-        ('\u{1040a}', 66610), ('\u{1040b}', 66611), ('\u{1040c}', 66612), ('\u{1040d}', 66613),
-        ('\u{1040e}', 66614), ('\u{1040f}', 66615), ('\u{10410}', 66616), ('\u{10411}', 66617),
-        ('\u{10412}', 66618), ('\u{10413}', 66619), ('\u{10414}', 66620), ('\u{10415}', 66621),
-        ('\u{10416}', 66622), ('\u{10417}', 66623), ('\u{10418}', 66624), ('\u{10419}', 66625),
-        ('\u{1041a}', 66626), ('\u{1041b}', 66627), ('\u{1041c}', 66628), ('\u{1041d}', 66629),
-        ('\u{1041e}', 66630), ('\u{1041f}', 66631), ('\u{10420}', 66632), ('\u{10421}', 66633),
-        ('\u{10422}', 66634), ('\u{10423}', 66635), ('\u{10424}', 66636), ('\u{10425}', 66637),
-        ('\u{10426}', 66638), ('\u{10427}', 66639), ('\u{104b0}', 66776), ('\u{104b1}', 66777),
-        ('\u{104b2}', 66778), ('\u{104b3}', 66779), ('\u{104b4}', 66780), ('\u{104b5}', 66781),
-        ('\u{104b6}', 66782), ('\u{104b7}', 66783), ('\u{104b8}', 66784), ('\u{104b9}', 66785),
-        ('\u{104ba}', 66786), ('\u{104bb}', 66787), ('\u{104bc}', 66788), ('\u{104bd}', 66789),
-        ('\u{104be}', 66790), ('\u{104bf}', 66791), ('\u{104c0}', 66792), ('\u{104c1}', 66793),
-        ('\u{104c2}', 66794), ('\u{104c3}', 66795), ('\u{104c4}', 66796), ('\u{104c5}', 66797),
-        ('\u{104c6}', 66798), ('\u{104c7}', 66799), ('\u{104c8}', 66800), ('\u{104c9}', 66801),
-        ('\u{104ca}', 66802), ('\u{104cb}', 66803), ('\u{104cc}', 66804), ('\u{104cd}', 66805),
-        ('\u{104ce}', 66806), ('\u{104cf}', 66807), ('\u{104d0}', 66808), ('\u{104d1}', 66809),
-        ('\u{104d2}', 66810), ('\u{104d3}', 66811), ('\u{10570}', 66967), ('\u{10571}', 66968),
-        ('\u{10572}', 66969), ('\u{10573}', 66970), ('\u{10574}', 66971), ('\u{10575}', 66972),
-        ('\u{10576}', 66973), ('\u{10577}', 66974), ('\u{10578}', 66975), ('\u{10579}', 66976),
-        ('\u{1057a}', 66977), ('\u{1057c}', 66979), ('\u{1057d}', 66980), ('\u{1057e}', 66981),
-        ('\u{1057f}', 66982), ('\u{10580}', 66983), ('\u{10581}', 66984), ('\u{10582}', 66985),
-        ('\u{10583}', 66986), ('\u{10584}', 66987), ('\u{10585}', 66988), ('\u{10586}', 66989),
-        ('\u{10587}', 66990), ('\u{10588}', 66991), ('\u{10589}', 66992), ('\u{1058a}', 66993),
-        ('\u{1058c}', 66995), ('\u{1058d}', 66996), ('\u{1058e}', 66997), ('\u{1058f}', 66998),
-        ('\u{10590}', 66999), ('\u{10591}', 67000), ('\u{10592}', 67001), ('\u{10594}', 67003),
-        ('\u{10595}', 67004), ('\u{10c80}', 68800), ('\u{10c81}', 68801), ('\u{10c82}', 68802),
-        ('\u{10c83}', 68803), ('\u{10c84}', 68804), ('\u{10c85}', 68805), ('\u{10c86}', 68806),
-        ('\u{10c87}', 68807), ('\u{10c88}', 68808), ('\u{10c89}', 68809), ('\u{10c8a}', 68810),
-        ('\u{10c8b}', 68811), ('\u{10c8c}', 68812), ('\u{10c8d}', 68813), ('\u{10c8e}', 68814),
-        ('\u{10c8f}', 68815), ('\u{10c90}', 68816), ('\u{10c91}', 68817), ('\u{10c92}', 68818),
-        ('\u{10c93}', 68819), ('\u{10c94}', 68820), ('\u{10c95}', 68821), ('\u{10c96}', 68822),
-        ('\u{10c97}', 68823), ('\u{10c98}', 68824), ('\u{10c99}', 68825), ('\u{10c9a}', 68826),
-        ('\u{10c9b}', 68827), ('\u{10c9c}', 68828), ('\u{10c9d}', 68829), ('\u{10c9e}', 68830),
-        ('\u{10c9f}', 68831), ('\u{10ca0}', 68832), ('\u{10ca1}', 68833), ('\u{10ca2}', 68834),
-        ('\u{10ca3}', 68835), ('\u{10ca4}', 68836), ('\u{10ca5}', 68837), ('\u{10ca6}', 68838),
-        ('\u{10ca7}', 68839), ('\u{10ca8}', 68840), ('\u{10ca9}', 68841), ('\u{10caa}', 68842),
-        ('\u{10cab}', 68843), ('\u{10cac}', 68844), ('\u{10cad}', 68845), ('\u{10cae}', 68846),
-        ('\u{10caf}', 68847), ('\u{10cb0}', 68848), ('\u{10cb1}', 68849), ('\u{10cb2}', 68850),
-        ('\u{10d50}', 68976), ('\u{10d51}', 68977), ('\u{10d52}', 68978), ('\u{10d53}', 68979),
-        ('\u{10d54}', 68980), ('\u{10d55}', 68981), ('\u{10d56}', 68982), ('\u{10d57}', 68983),
-        ('\u{10d58}', 68984), ('\u{10d59}', 68985), ('\u{10d5a}', 68986), ('\u{10d5b}', 68987),
-        ('\u{10d5c}', 68988), ('\u{10d5d}', 68989), ('\u{10d5e}', 68990), ('\u{10d5f}', 68991),
-        ('\u{10d60}', 68992), ('\u{10d61}', 68993), ('\u{10d62}', 68994), ('\u{10d63}', 68995),
-        ('\u{10d64}', 68996), ('\u{10d65}', 68997), ('\u{118a0}', 71872), ('\u{118a1}', 71873),
-        ('\u{118a2}', 71874), ('\u{118a3}', 71875), ('\u{118a4}', 71876), ('\u{118a5}', 71877),
-        ('\u{118a6}', 71878), ('\u{118a7}', 71879), ('\u{118a8}', 71880), ('\u{118a9}', 71881),
-        ('\u{118aa}', 71882), ('\u{118ab}', 71883), ('\u{118ac}', 71884), ('\u{118ad}', 71885),
-        ('\u{118ae}', 71886), ('\u{118af}', 71887), ('\u{118b0}', 71888), ('\u{118b1}', 71889),
-        ('\u{118b2}', 71890), ('\u{118b3}', 71891), ('\u{118b4}', 71892), ('\u{118b5}', 71893),
-        ('\u{118b6}', 71894), ('\u{118b7}', 71895), ('\u{118b8}', 71896), ('\u{118b9}', 71897),
-        ('\u{118ba}', 71898), ('\u{118bb}', 71899), ('\u{118bc}', 71900), ('\u{118bd}', 71901),
-        ('\u{118be}', 71902), ('\u{118bf}', 71903), ('\u{16e40}', 93792), ('\u{16e41}', 93793),
-        ('\u{16e42}', 93794), ('\u{16e43}', 93795), ('\u{16e44}', 93796), ('\u{16e45}', 93797),
-        ('\u{16e46}', 93798), ('\u{16e47}', 93799), ('\u{16e48}', 93800), ('\u{16e49}', 93801),
-        ('\u{16e4a}', 93802), ('\u{16e4b}', 93803), ('\u{16e4c}', 93804), ('\u{16e4d}', 93805),
-        ('\u{16e4e}', 93806), ('\u{16e4f}', 93807), ('\u{16e50}', 93808), ('\u{16e51}', 93809),
-        ('\u{16e52}', 93810), ('\u{16e53}', 93811), ('\u{16e54}', 93812), ('\u{16e55}', 93813),
-        ('\u{16e56}', 93814), ('\u{16e57}', 93815), ('\u{16e58}', 93816), ('\u{16e59}', 93817),
-        ('\u{16e5a}', 93818), ('\u{16e5b}', 93819), ('\u{16e5c}', 93820), ('\u{16e5d}', 93821),
-        ('\u{16e5e}', 93822), ('\u{16e5f}', 93823), ('\u{16ea0}', 93883), ('\u{16ea1}', 93884),
-        ('\u{16ea2}', 93885), ('\u{16ea3}', 93886), ('\u{16ea4}', 93887), ('\u{16ea5}', 93888),
-        ('\u{16ea6}', 93889), ('\u{16ea7}', 93890), ('\u{16ea8}', 93891), ('\u{16ea9}', 93892),
-        ('\u{16eaa}', 93893), ('\u{16eab}', 93894), ('\u{16eac}', 93895), ('\u{16ead}', 93896),
-        ('\u{16eae}', 93897), ('\u{16eaf}', 93898), ('\u{16eb0}', 93899), ('\u{16eb1}', 93900),
-        ('\u{16eb2}', 93901), ('\u{16eb3}', 93902), ('\u{16eb4}', 93903), ('\u{16eb5}', 93904),
-        ('\u{16eb6}', 93905), ('\u{16eb7}', 93906), ('\u{16eb8}', 93907), ('\u{1e900}', 125218),
-        ('\u{1e901}', 125219), ('\u{1e902}', 125220), ('\u{1e903}', 125221), ('\u{1e904}', 125222),
-        ('\u{1e905}', 125223), ('\u{1e906}', 125224), ('\u{1e907}', 125225), ('\u{1e908}', 125226),
-        ('\u{1e909}', 125227), ('\u{1e90a}', 125228), ('\u{1e90b}', 125229), ('\u{1e90c}', 125230),
-        ('\u{1e90d}', 125231), ('\u{1e90e}', 125232), ('\u{1e90f}', 125233), ('\u{1e910}', 125234),
-        ('\u{1e911}', 125235), ('\u{1e912}', 125236), ('\u{1e913}', 125237), ('\u{1e914}', 125238),
-        ('\u{1e915}', 125239), ('\u{1e916}', 125240), ('\u{1e917}', 125241), ('\u{1e918}', 125242),
-        ('\u{1e919}', 125243), ('\u{1e91a}', 125244), ('\u{1e91b}', 125245), ('\u{1e91c}', 125246),
-        ('\u{1e91d}', 125247), ('\u{1e91e}', 125248), ('\u{1e91f}', 125249), ('\u{1e920}', 125250),
-        ('\u{1e921}', 125251),
-    ];
+    static LOWERCASE_LUT: L1Lut = L1Lut {
+        l2_luts: [
+            L2Lut {
+                singles: &[ // 172 entries, 1032 bytes
+                    (Range::step_by_1(0x00c0..=0x00d6), 32), (Range::step_by_1(0x00d8..=0x00de), 32),
+                    (Range::step_by_2(0x0100..=0x012e), 1), (Range::step_by_2(0x0132..=0x0136), 1),
+                    (Range::step_by_2(0x0139..=0x0147), 1), (Range::step_by_2(0x014a..=0x0176), 1),
+                    (Range::singleton(0x0178), -121), (Range::step_by_2(0x0179..=0x017d), 1),
+                    (Range::singleton(0x0181), 210), (Range::step_by_2(0x0182..=0x0184), 1),
+                    (Range::singleton(0x0186), 206), (Range::singleton(0x0187), 1),
+                    (Range::step_by_1(0x0189..=0x018a), 205), (Range::singleton(0x018b), 1),
+                    (Range::singleton(0x018e), 79), (Range::singleton(0x018f), 202),
+                    (Range::singleton(0x0190), 203), (Range::singleton(0x0191), 1),
+                    (Range::singleton(0x0193), 205), (Range::singleton(0x0194), 207),
+                    (Range::singleton(0x0196), 211), (Range::singleton(0x0197), 209),
+                    (Range::singleton(0x0198), 1), (Range::singleton(0x019c), 211),
+                    (Range::singleton(0x019d), 213), (Range::singleton(0x019f), 214),
+                    (Range::step_by_2(0x01a0..=0x01a4), 1), (Range::singleton(0x01a6), 218),
+                    (Range::singleton(0x01a7), 1), (Range::singleton(0x01a9), 218),
+                    (Range::singleton(0x01ac), 1), (Range::singleton(0x01ae), 218),
+                    (Range::singleton(0x01af), 1), (Range::step_by_1(0x01b1..=0x01b2), 217),
+                    (Range::step_by_2(0x01b3..=0x01b5), 1), (Range::singleton(0x01b7), 219),
+                    (Range::singleton(0x01b8), 1), (Range::singleton(0x01bc), 1), (Range::singleton(0x01c4), 2),
+                    (Range::singleton(0x01c5), 1), (Range::singleton(0x01c7), 2), (Range::singleton(0x01c8), 1),
+                    (Range::singleton(0x01ca), 2), (Range::step_by_2(0x01cb..=0x01db), 1),
+                    (Range::step_by_2(0x01de..=0x01ee), 1), (Range::singleton(0x01f1), 2),
+                    (Range::step_by_2(0x01f2..=0x01f4), 1), (Range::singleton(0x01f6), -97),
+                    (Range::singleton(0x01f7), -56), (Range::step_by_2(0x01f8..=0x021e), 1),
+                    (Range::singleton(0x0220), -130), (Range::step_by_2(0x0222..=0x0232), 1),
+                    (Range::singleton(0x023a), 10795), (Range::singleton(0x023b), 1),
+                    (Range::singleton(0x023d), -163), (Range::singleton(0x023e), 10792),
+                    (Range::singleton(0x0241), 1), (Range::singleton(0x0243), -195),
+                    (Range::singleton(0x0244), 69), (Range::singleton(0x0245), 71),
+                    (Range::step_by_2(0x0246..=0x024e), 1), (Range::step_by_2(0x0370..=0x0372), 1),
+                    (Range::singleton(0x0376), 1), (Range::singleton(0x037f), 116),
+                    (Range::singleton(0x0386), 38), (Range::step_by_1(0x0388..=0x038a), 37),
+                    (Range::singleton(0x038c), 64), (Range::step_by_1(0x038e..=0x038f), 63),
+                    (Range::step_by_1(0x0391..=0x03a1), 32), (Range::step_by_1(0x03a3..=0x03ab), 32),
+                    (Range::singleton(0x03cf), 8), (Range::step_by_2(0x03d8..=0x03ee), 1),
+                    (Range::singleton(0x03f4), -60), (Range::singleton(0x03f7), 1),
+                    (Range::singleton(0x03f9), -7), (Range::singleton(0x03fa), 1),
+                    (Range::step_by_1(0x03fd..=0x03ff), -130), (Range::step_by_1(0x0400..=0x040f), 80),
+                    (Range::step_by_1(0x0410..=0x042f), 32), (Range::step_by_2(0x0460..=0x0480), 1),
+                    (Range::step_by_2(0x048a..=0x04be), 1), (Range::singleton(0x04c0), 15),
+                    (Range::step_by_2(0x04c1..=0x04cd), 1), (Range::step_by_2(0x04d0..=0x052e), 1),
+                    (Range::step_by_1(0x0531..=0x0556), 48), (Range::step_by_1(0x10a0..=0x10c5), 7264),
+                    (Range::singleton(0x10c7), 7264), (Range::singleton(0x10cd), 7264),
+                    (Range::step_by_1(0x13a0..=0x13ef), -26672), (Range::step_by_1(0x13f0..=0x13f5), 8),
+                    (Range::singleton(0x1c89), 1), (Range::step_by_1(0x1c90..=0x1cba), -3008),
+                    (Range::step_by_1(0x1cbd..=0x1cbf), -3008), (Range::step_by_2(0x1e00..=0x1e94), 1),
+                    (Range::singleton(0x1e9e), -7615), (Range::step_by_2(0x1ea0..=0x1efe), 1),
+                    (Range::step_by_1(0x1f08..=0x1f0f), -8), (Range::step_by_1(0x1f18..=0x1f1d), -8),
+                    (Range::step_by_1(0x1f28..=0x1f2f), -8), (Range::step_by_1(0x1f38..=0x1f3f), -8),
+                    (Range::step_by_1(0x1f48..=0x1f4d), -8), (Range::step_by_2(0x1f59..=0x1f5f), -8),
+                    (Range::step_by_1(0x1f68..=0x1f6f), -8), (Range::step_by_1(0x1f88..=0x1f8f), -8),
+                    (Range::step_by_1(0x1f98..=0x1f9f), -8), (Range::step_by_1(0x1fa8..=0x1faf), -8),
+                    (Range::step_by_1(0x1fb8..=0x1fb9), -8), (Range::step_by_1(0x1fba..=0x1fbb), -74),
+                    (Range::singleton(0x1fbc), -9), (Range::step_by_1(0x1fc8..=0x1fcb), -86),
+                    (Range::singleton(0x1fcc), -9), (Range::step_by_1(0x1fd8..=0x1fd9), -8),
+                    (Range::step_by_1(0x1fda..=0x1fdb), -100), (Range::step_by_1(0x1fe8..=0x1fe9), -8),
+                    (Range::step_by_1(0x1fea..=0x1feb), -112), (Range::singleton(0x1fec), -7),
+                    (Range::step_by_1(0x1ff8..=0x1ff9), -128), (Range::step_by_1(0x1ffa..=0x1ffb), -126),
+                    (Range::singleton(0x1ffc), -9), (Range::singleton(0x2126), -7517),
+                    (Range::singleton(0x212a), -8383), (Range::singleton(0x212b), -8262),
+                    (Range::singleton(0x2132), 28), (Range::step_by_1(0x2160..=0x216f), 16),
+                    (Range::singleton(0x2183), 1), (Range::step_by_1(0x24b6..=0x24cf), 26),
+                    (Range::step_by_1(0x2c00..=0x2c2f), 48), (Range::singleton(0x2c60), 1),
+                    (Range::singleton(0x2c62), -10743), (Range::singleton(0x2c63), -3814),
+                    (Range::singleton(0x2c64), -10727), (Range::step_by_2(0x2c67..=0x2c6b), 1),
+                    (Range::singleton(0x2c6d), -10780), (Range::singleton(0x2c6e), -10749),
+                    (Range::singleton(0x2c6f), -10783), (Range::singleton(0x2c70), -10782),
+                    (Range::singleton(0x2c72), 1), (Range::singleton(0x2c75), 1),
+                    (Range::step_by_1(0x2c7e..=0x2c7f), -10815), (Range::step_by_2(0x2c80..=0x2ce2), 1),
+                    (Range::step_by_2(0x2ceb..=0x2ced), 1), (Range::singleton(0x2cf2), 1),
+                    (Range::step_by_2(0xa640..=0xa66c), 1), (Range::step_by_2(0xa680..=0xa69a), 1),
+                    (Range::step_by_2(0xa722..=0xa72e), 1), (Range::step_by_2(0xa732..=0xa76e), 1),
+                    (Range::step_by_2(0xa779..=0xa77b), 1), (Range::singleton(0xa77d), 30204),
+                    (Range::step_by_2(0xa77e..=0xa786), 1), (Range::singleton(0xa78b), 1),
+                    (Range::singleton(0xa78d), 23256), (Range::step_by_2(0xa790..=0xa792), 1),
+                    (Range::step_by_2(0xa796..=0xa7a8), 1), (Range::singleton(0xa7aa), 23228),
+                    (Range::singleton(0xa7ab), 23217), (Range::singleton(0xa7ac), 23221),
+                    (Range::singleton(0xa7ad), 23231), (Range::singleton(0xa7ae), 23228),
+                    (Range::singleton(0xa7b0), 23278), (Range::singleton(0xa7b1), 23254),
+                    (Range::singleton(0xa7b2), 23275), (Range::singleton(0xa7b3), 928),
+                    (Range::step_by_2(0xa7b4..=0xa7c2), 1), (Range::singleton(0xa7c4), -48),
+                    (Range::singleton(0xa7c5), 23229), (Range::singleton(0xa7c6), 30152),
+                    (Range::step_by_2(0xa7c7..=0xa7c9), 1), (Range::singleton(0xa7cb), 23193),
+                    (Range::step_by_2(0xa7cc..=0xa7da), 1), (Range::singleton(0xa7dc), 22975),
+                    (Range::singleton(0xa7f5), 1), (Range::step_by_1(0xff21..=0xff3a), 32),
+                ],
+                multis: &[ // 1 entries, 8 bytes
+                    (0x0130, [0x0069, 0x0307, 0x0000]),
+                ],
+            },
+            L2Lut {
+                singles: &[ // 12 entries, 72 bytes
+                    (Range::step_by_1(0x0400..=0x0427), 40), (Range::step_by_1(0x04b0..=0x04d3), 40),
+                    (Range::step_by_1(0x0570..=0x057a), 39), (Range::step_by_1(0x057c..=0x058a), 39),
+                    (Range::step_by_1(0x058c..=0x0592), 39), (Range::step_by_1(0x0594..=0x0595), 39),
+                    (Range::step_by_1(0x0c80..=0x0cb2), 64), (Range::step_by_1(0x0d50..=0x0d65), 32),
+                    (Range::step_by_1(0x18a0..=0x18bf), 32), (Range::step_by_1(0x6e40..=0x6e5f), 32),
+                    (Range::step_by_1(0x6ea0..=0x6eb8), 27), (Range::step_by_1(0xe900..=0xe921), 34),
+                ],
+                multis: &[ // 0 entries, 0 bytes
+                ],
+            },
+        ],
+    };
 
-    static LOWERCASE_TABLE_MULTI: &[[char; 3]; 1] = &[
-        ['i', '\u{307}', '\u{0}'],
-    ];
-
-    static UPPERCASE_TABLE: &[(char, u32); 1554] = &[
-        ('\u{b5}', 924), ('\u{df}', 4194304), ('\u{e0}', 192), ('\u{e1}', 193), ('\u{e2}', 194),
-        ('\u{e3}', 195), ('\u{e4}', 196), ('\u{e5}', 197), ('\u{e6}', 198), ('\u{e7}', 199),
-        ('\u{e8}', 200), ('\u{e9}', 201), ('\u{ea}', 202), ('\u{eb}', 203), ('\u{ec}', 204),
-        ('\u{ed}', 205), ('\u{ee}', 206), ('\u{ef}', 207), ('\u{f0}', 208), ('\u{f1}', 209),
-        ('\u{f2}', 210), ('\u{f3}', 211), ('\u{f4}', 212), ('\u{f5}', 213), ('\u{f6}', 214),
-        ('\u{f8}', 216), ('\u{f9}', 217), ('\u{fa}', 218), ('\u{fb}', 219), ('\u{fc}', 220),
-        ('\u{fd}', 221), ('\u{fe}', 222), ('\u{ff}', 376), ('\u{101}', 256), ('\u{103}', 258),
-        ('\u{105}', 260), ('\u{107}', 262), ('\u{109}', 264), ('\u{10b}', 266), ('\u{10d}', 268),
-        ('\u{10f}', 270), ('\u{111}', 272), ('\u{113}', 274), ('\u{115}', 276), ('\u{117}', 278),
-        ('\u{119}', 280), ('\u{11b}', 282), ('\u{11d}', 284), ('\u{11f}', 286), ('\u{121}', 288),
-        ('\u{123}', 290), ('\u{125}', 292), ('\u{127}', 294), ('\u{129}', 296), ('\u{12b}', 298),
-        ('\u{12d}', 300), ('\u{12f}', 302), ('\u{131}', 73), ('\u{133}', 306), ('\u{135}', 308),
-        ('\u{137}', 310), ('\u{13a}', 313), ('\u{13c}', 315), ('\u{13e}', 317), ('\u{140}', 319),
-        ('\u{142}', 321), ('\u{144}', 323), ('\u{146}', 325), ('\u{148}', 327),
-        ('\u{149}', 4194305), ('\u{14b}', 330), ('\u{14d}', 332), ('\u{14f}', 334),
-        ('\u{151}', 336), ('\u{153}', 338), ('\u{155}', 340), ('\u{157}', 342), ('\u{159}', 344),
-        ('\u{15b}', 346), ('\u{15d}', 348), ('\u{15f}', 350), ('\u{161}', 352), ('\u{163}', 354),
-        ('\u{165}', 356), ('\u{167}', 358), ('\u{169}', 360), ('\u{16b}', 362), ('\u{16d}', 364),
-        ('\u{16f}', 366), ('\u{171}', 368), ('\u{173}', 370), ('\u{175}', 372), ('\u{177}', 374),
-        ('\u{17a}', 377), ('\u{17c}', 379), ('\u{17e}', 381), ('\u{17f}', 83), ('\u{180}', 579),
-        ('\u{183}', 386), ('\u{185}', 388), ('\u{188}', 391), ('\u{18c}', 395), ('\u{192}', 401),
-        ('\u{195}', 502), ('\u{199}', 408), ('\u{19a}', 573), ('\u{19b}', 42972), ('\u{19e}', 544),
-        ('\u{1a1}', 416), ('\u{1a3}', 418), ('\u{1a5}', 420), ('\u{1a8}', 423), ('\u{1ad}', 428),
-        ('\u{1b0}', 431), ('\u{1b4}', 435), ('\u{1b6}', 437), ('\u{1b9}', 440), ('\u{1bd}', 444),
-        ('\u{1bf}', 503), ('\u{1c5}', 452), ('\u{1c6}', 452), ('\u{1c8}', 455), ('\u{1c9}', 455),
-        ('\u{1cb}', 458), ('\u{1cc}', 458), ('\u{1ce}', 461), ('\u{1d0}', 463), ('\u{1d2}', 465),
-        ('\u{1d4}', 467), ('\u{1d6}', 469), ('\u{1d8}', 471), ('\u{1da}', 473), ('\u{1dc}', 475),
-        ('\u{1dd}', 398), ('\u{1df}', 478), ('\u{1e1}', 480), ('\u{1e3}', 482), ('\u{1e5}', 484),
-        ('\u{1e7}', 486), ('\u{1e9}', 488), ('\u{1eb}', 490), ('\u{1ed}', 492), ('\u{1ef}', 494),
-        ('\u{1f0}', 4194306), ('\u{1f2}', 497), ('\u{1f3}', 497), ('\u{1f5}', 500),
-        ('\u{1f9}', 504), ('\u{1fb}', 506), ('\u{1fd}', 508), ('\u{1ff}', 510), ('\u{201}', 512),
-        ('\u{203}', 514), ('\u{205}', 516), ('\u{207}', 518), ('\u{209}', 520), ('\u{20b}', 522),
-        ('\u{20d}', 524), ('\u{20f}', 526), ('\u{211}', 528), ('\u{213}', 530), ('\u{215}', 532),
-        ('\u{217}', 534), ('\u{219}', 536), ('\u{21b}', 538), ('\u{21d}', 540), ('\u{21f}', 542),
-        ('\u{223}', 546), ('\u{225}', 548), ('\u{227}', 550), ('\u{229}', 552), ('\u{22b}', 554),
-        ('\u{22d}', 556), ('\u{22f}', 558), ('\u{231}', 560), ('\u{233}', 562), ('\u{23c}', 571),
-        ('\u{23f}', 11390), ('\u{240}', 11391), ('\u{242}', 577), ('\u{247}', 582),
-        ('\u{249}', 584), ('\u{24b}', 586), ('\u{24d}', 588), ('\u{24f}', 590), ('\u{250}', 11375),
-        ('\u{251}', 11373), ('\u{252}', 11376), ('\u{253}', 385), ('\u{254}', 390),
-        ('\u{256}', 393), ('\u{257}', 394), ('\u{259}', 399), ('\u{25b}', 400), ('\u{25c}', 42923),
-        ('\u{260}', 403), ('\u{261}', 42924), ('\u{263}', 404), ('\u{264}', 42955),
-        ('\u{265}', 42893), ('\u{266}', 42922), ('\u{268}', 407), ('\u{269}', 406),
-        ('\u{26a}', 42926), ('\u{26b}', 11362), ('\u{26c}', 42925), ('\u{26f}', 412),
-        ('\u{271}', 11374), ('\u{272}', 413), ('\u{275}', 415), ('\u{27d}', 11364),
-        ('\u{280}', 422), ('\u{282}', 42949), ('\u{283}', 425), ('\u{287}', 42929),
-        ('\u{288}', 430), ('\u{289}', 580), ('\u{28a}', 433), ('\u{28b}', 434), ('\u{28c}', 581),
-        ('\u{292}', 439), ('\u{29d}', 42930), ('\u{29e}', 42928), ('\u{345}', 921),
-        ('\u{371}', 880), ('\u{373}', 882), ('\u{377}', 886), ('\u{37b}', 1021), ('\u{37c}', 1022),
-        ('\u{37d}', 1023), ('\u{390}', 4194307), ('\u{3ac}', 902), ('\u{3ad}', 904),
-        ('\u{3ae}', 905), ('\u{3af}', 906), ('\u{3b0}', 4194308), ('\u{3b1}', 913),
-        ('\u{3b2}', 914), ('\u{3b3}', 915), ('\u{3b4}', 916), ('\u{3b5}', 917), ('\u{3b6}', 918),
-        ('\u{3b7}', 919), ('\u{3b8}', 920), ('\u{3b9}', 921), ('\u{3ba}', 922), ('\u{3bb}', 923),
-        ('\u{3bc}', 924), ('\u{3bd}', 925), ('\u{3be}', 926), ('\u{3bf}', 927), ('\u{3c0}', 928),
-        ('\u{3c1}', 929), ('\u{3c2}', 931), ('\u{3c3}', 931), ('\u{3c4}', 932), ('\u{3c5}', 933),
-        ('\u{3c6}', 934), ('\u{3c7}', 935), ('\u{3c8}', 936), ('\u{3c9}', 937), ('\u{3ca}', 938),
-        ('\u{3cb}', 939), ('\u{3cc}', 908), ('\u{3cd}', 910), ('\u{3ce}', 911), ('\u{3d0}', 914),
-        ('\u{3d1}', 920), ('\u{3d5}', 934), ('\u{3d6}', 928), ('\u{3d7}', 975), ('\u{3d9}', 984),
-        ('\u{3db}', 986), ('\u{3dd}', 988), ('\u{3df}', 990), ('\u{3e1}', 992), ('\u{3e3}', 994),
-        ('\u{3e5}', 996), ('\u{3e7}', 998), ('\u{3e9}', 1000), ('\u{3eb}', 1002), ('\u{3ed}', 1004),
-        ('\u{3ef}', 1006), ('\u{3f0}', 922), ('\u{3f1}', 929), ('\u{3f2}', 1017), ('\u{3f3}', 895),
-        ('\u{3f5}', 917), ('\u{3f8}', 1015), ('\u{3fb}', 1018), ('\u{430}', 1040),
-        ('\u{431}', 1041), ('\u{432}', 1042), ('\u{433}', 1043), ('\u{434}', 1044),
-        ('\u{435}', 1045), ('\u{436}', 1046), ('\u{437}', 1047), ('\u{438}', 1048),
-        ('\u{439}', 1049), ('\u{43a}', 1050), ('\u{43b}', 1051), ('\u{43c}', 1052),
-        ('\u{43d}', 1053), ('\u{43e}', 1054), ('\u{43f}', 1055), ('\u{440}', 1056),
-        ('\u{441}', 1057), ('\u{442}', 1058), ('\u{443}', 1059), ('\u{444}', 1060),
-        ('\u{445}', 1061), ('\u{446}', 1062), ('\u{447}', 1063), ('\u{448}', 1064),
-        ('\u{449}', 1065), ('\u{44a}', 1066), ('\u{44b}', 1067), ('\u{44c}', 1068),
-        ('\u{44d}', 1069), ('\u{44e}', 1070), ('\u{44f}', 1071), ('\u{450}', 1024),
-        ('\u{451}', 1025), ('\u{452}', 1026), ('\u{453}', 1027), ('\u{454}', 1028),
-        ('\u{455}', 1029), ('\u{456}', 1030), ('\u{457}', 1031), ('\u{458}', 1032),
-        ('\u{459}', 1033), ('\u{45a}', 1034), ('\u{45b}', 1035), ('\u{45c}', 1036),
-        ('\u{45d}', 1037), ('\u{45e}', 1038), ('\u{45f}', 1039), ('\u{461}', 1120),
-        ('\u{463}', 1122), ('\u{465}', 1124), ('\u{467}', 1126), ('\u{469}', 1128),
-        ('\u{46b}', 1130), ('\u{46d}', 1132), ('\u{46f}', 1134), ('\u{471}', 1136),
-        ('\u{473}', 1138), ('\u{475}', 1140), ('\u{477}', 1142), ('\u{479}', 1144),
-        ('\u{47b}', 1146), ('\u{47d}', 1148), ('\u{47f}', 1150), ('\u{481}', 1152),
-        ('\u{48b}', 1162), ('\u{48d}', 1164), ('\u{48f}', 1166), ('\u{491}', 1168),
-        ('\u{493}', 1170), ('\u{495}', 1172), ('\u{497}', 1174), ('\u{499}', 1176),
-        ('\u{49b}', 1178), ('\u{49d}', 1180), ('\u{49f}', 1182), ('\u{4a1}', 1184),
-        ('\u{4a3}', 1186), ('\u{4a5}', 1188), ('\u{4a7}', 1190), ('\u{4a9}', 1192),
-        ('\u{4ab}', 1194), ('\u{4ad}', 1196), ('\u{4af}', 1198), ('\u{4b1}', 1200),
-        ('\u{4b3}', 1202), ('\u{4b5}', 1204), ('\u{4b7}', 1206), ('\u{4b9}', 1208),
-        ('\u{4bb}', 1210), ('\u{4bd}', 1212), ('\u{4bf}', 1214), ('\u{4c2}', 1217),
-        ('\u{4c4}', 1219), ('\u{4c6}', 1221), ('\u{4c8}', 1223), ('\u{4ca}', 1225),
-        ('\u{4cc}', 1227), ('\u{4ce}', 1229), ('\u{4cf}', 1216), ('\u{4d1}', 1232),
-        ('\u{4d3}', 1234), ('\u{4d5}', 1236), ('\u{4d7}', 1238), ('\u{4d9}', 1240),
-        ('\u{4db}', 1242), ('\u{4dd}', 1244), ('\u{4df}', 1246), ('\u{4e1}', 1248),
-        ('\u{4e3}', 1250), ('\u{4e5}', 1252), ('\u{4e7}', 1254), ('\u{4e9}', 1256),
-        ('\u{4eb}', 1258), ('\u{4ed}', 1260), ('\u{4ef}', 1262), ('\u{4f1}', 1264),
-        ('\u{4f3}', 1266), ('\u{4f5}', 1268), ('\u{4f7}', 1270), ('\u{4f9}', 1272),
-        ('\u{4fb}', 1274), ('\u{4fd}', 1276), ('\u{4ff}', 1278), ('\u{501}', 1280),
-        ('\u{503}', 1282), ('\u{505}', 1284), ('\u{507}', 1286), ('\u{509}', 1288),
-        ('\u{50b}', 1290), ('\u{50d}', 1292), ('\u{50f}', 1294), ('\u{511}', 1296),
-        ('\u{513}', 1298), ('\u{515}', 1300), ('\u{517}', 1302), ('\u{519}', 1304),
-        ('\u{51b}', 1306), ('\u{51d}', 1308), ('\u{51f}', 1310), ('\u{521}', 1312),
-        ('\u{523}', 1314), ('\u{525}', 1316), ('\u{527}', 1318), ('\u{529}', 1320),
-        ('\u{52b}', 1322), ('\u{52d}', 1324), ('\u{52f}', 1326), ('\u{561}', 1329),
-        ('\u{562}', 1330), ('\u{563}', 1331), ('\u{564}', 1332), ('\u{565}', 1333),
-        ('\u{566}', 1334), ('\u{567}', 1335), ('\u{568}', 1336), ('\u{569}', 1337),
-        ('\u{56a}', 1338), ('\u{56b}', 1339), ('\u{56c}', 1340), ('\u{56d}', 1341),
-        ('\u{56e}', 1342), ('\u{56f}', 1343), ('\u{570}', 1344), ('\u{571}', 1345),
-        ('\u{572}', 1346), ('\u{573}', 1347), ('\u{574}', 1348), ('\u{575}', 1349),
-        ('\u{576}', 1350), ('\u{577}', 1351), ('\u{578}', 1352), ('\u{579}', 1353),
-        ('\u{57a}', 1354), ('\u{57b}', 1355), ('\u{57c}', 1356), ('\u{57d}', 1357),
-        ('\u{57e}', 1358), ('\u{57f}', 1359), ('\u{580}', 1360), ('\u{581}', 1361),
-        ('\u{582}', 1362), ('\u{583}', 1363), ('\u{584}', 1364), ('\u{585}', 1365),
-        ('\u{586}', 1366), ('\u{587}', 4194309), ('\u{10d0}', 7312), ('\u{10d1}', 7313),
-        ('\u{10d2}', 7314), ('\u{10d3}', 7315), ('\u{10d4}', 7316), ('\u{10d5}', 7317),
-        ('\u{10d6}', 7318), ('\u{10d7}', 7319), ('\u{10d8}', 7320), ('\u{10d9}', 7321),
-        ('\u{10da}', 7322), ('\u{10db}', 7323), ('\u{10dc}', 7324), ('\u{10dd}', 7325),
-        ('\u{10de}', 7326), ('\u{10df}', 7327), ('\u{10e0}', 7328), ('\u{10e1}', 7329),
-        ('\u{10e2}', 7330), ('\u{10e3}', 7331), ('\u{10e4}', 7332), ('\u{10e5}', 7333),
-        ('\u{10e6}', 7334), ('\u{10e7}', 7335), ('\u{10e8}', 7336), ('\u{10e9}', 7337),
-        ('\u{10ea}', 7338), ('\u{10eb}', 7339), ('\u{10ec}', 7340), ('\u{10ed}', 7341),
-        ('\u{10ee}', 7342), ('\u{10ef}', 7343), ('\u{10f0}', 7344), ('\u{10f1}', 7345),
-        ('\u{10f2}', 7346), ('\u{10f3}', 7347), ('\u{10f4}', 7348), ('\u{10f5}', 7349),
-        ('\u{10f6}', 7350), ('\u{10f7}', 7351), ('\u{10f8}', 7352), ('\u{10f9}', 7353),
-        ('\u{10fa}', 7354), ('\u{10fd}', 7357), ('\u{10fe}', 7358), ('\u{10ff}', 7359),
-        ('\u{13f8}', 5104), ('\u{13f9}', 5105), ('\u{13fa}', 5106), ('\u{13fb}', 5107),
-        ('\u{13fc}', 5108), ('\u{13fd}', 5109), ('\u{1c80}', 1042), ('\u{1c81}', 1044),
-        ('\u{1c82}', 1054), ('\u{1c83}', 1057), ('\u{1c84}', 1058), ('\u{1c85}', 1058),
-        ('\u{1c86}', 1066), ('\u{1c87}', 1122), ('\u{1c88}', 42570), ('\u{1c8a}', 7305),
-        ('\u{1d79}', 42877), ('\u{1d7d}', 11363), ('\u{1d8e}', 42950), ('\u{1e01}', 7680),
-        ('\u{1e03}', 7682), ('\u{1e05}', 7684), ('\u{1e07}', 7686), ('\u{1e09}', 7688),
-        ('\u{1e0b}', 7690), ('\u{1e0d}', 7692), ('\u{1e0f}', 7694), ('\u{1e11}', 7696),
-        ('\u{1e13}', 7698), ('\u{1e15}', 7700), ('\u{1e17}', 7702), ('\u{1e19}', 7704),
-        ('\u{1e1b}', 7706), ('\u{1e1d}', 7708), ('\u{1e1f}', 7710), ('\u{1e21}', 7712),
-        ('\u{1e23}', 7714), ('\u{1e25}', 7716), ('\u{1e27}', 7718), ('\u{1e29}', 7720),
-        ('\u{1e2b}', 7722), ('\u{1e2d}', 7724), ('\u{1e2f}', 7726), ('\u{1e31}', 7728),
-        ('\u{1e33}', 7730), ('\u{1e35}', 7732), ('\u{1e37}', 7734), ('\u{1e39}', 7736),
-        ('\u{1e3b}', 7738), ('\u{1e3d}', 7740), ('\u{1e3f}', 7742), ('\u{1e41}', 7744),
-        ('\u{1e43}', 7746), ('\u{1e45}', 7748), ('\u{1e47}', 7750), ('\u{1e49}', 7752),
-        ('\u{1e4b}', 7754), ('\u{1e4d}', 7756), ('\u{1e4f}', 7758), ('\u{1e51}', 7760),
-        ('\u{1e53}', 7762), ('\u{1e55}', 7764), ('\u{1e57}', 7766), ('\u{1e59}', 7768),
-        ('\u{1e5b}', 7770), ('\u{1e5d}', 7772), ('\u{1e5f}', 7774), ('\u{1e61}', 7776),
-        ('\u{1e63}', 7778), ('\u{1e65}', 7780), ('\u{1e67}', 7782), ('\u{1e69}', 7784),
-        ('\u{1e6b}', 7786), ('\u{1e6d}', 7788), ('\u{1e6f}', 7790), ('\u{1e71}', 7792),
-        ('\u{1e73}', 7794), ('\u{1e75}', 7796), ('\u{1e77}', 7798), ('\u{1e79}', 7800),
-        ('\u{1e7b}', 7802), ('\u{1e7d}', 7804), ('\u{1e7f}', 7806), ('\u{1e81}', 7808),
-        ('\u{1e83}', 7810), ('\u{1e85}', 7812), ('\u{1e87}', 7814), ('\u{1e89}', 7816),
-        ('\u{1e8b}', 7818), ('\u{1e8d}', 7820), ('\u{1e8f}', 7822), ('\u{1e91}', 7824),
-        ('\u{1e93}', 7826), ('\u{1e95}', 7828), ('\u{1e96}', 4194310), ('\u{1e97}', 4194311),
-        ('\u{1e98}', 4194312), ('\u{1e99}', 4194313), ('\u{1e9a}', 4194314), ('\u{1e9b}', 7776),
-        ('\u{1ea1}', 7840), ('\u{1ea3}', 7842), ('\u{1ea5}', 7844), ('\u{1ea7}', 7846),
-        ('\u{1ea9}', 7848), ('\u{1eab}', 7850), ('\u{1ead}', 7852), ('\u{1eaf}', 7854),
-        ('\u{1eb1}', 7856), ('\u{1eb3}', 7858), ('\u{1eb5}', 7860), ('\u{1eb7}', 7862),
-        ('\u{1eb9}', 7864), ('\u{1ebb}', 7866), ('\u{1ebd}', 7868), ('\u{1ebf}', 7870),
-        ('\u{1ec1}', 7872), ('\u{1ec3}', 7874), ('\u{1ec5}', 7876), ('\u{1ec7}', 7878),
-        ('\u{1ec9}', 7880), ('\u{1ecb}', 7882), ('\u{1ecd}', 7884), ('\u{1ecf}', 7886),
-        ('\u{1ed1}', 7888), ('\u{1ed3}', 7890), ('\u{1ed5}', 7892), ('\u{1ed7}', 7894),
-        ('\u{1ed9}', 7896), ('\u{1edb}', 7898), ('\u{1edd}', 7900), ('\u{1edf}', 7902),
-        ('\u{1ee1}', 7904), ('\u{1ee3}', 7906), ('\u{1ee5}', 7908), ('\u{1ee7}', 7910),
-        ('\u{1ee9}', 7912), ('\u{1eeb}', 7914), ('\u{1eed}', 7916), ('\u{1eef}', 7918),
-        ('\u{1ef1}', 7920), ('\u{1ef3}', 7922), ('\u{1ef5}', 7924), ('\u{1ef7}', 7926),
-        ('\u{1ef9}', 7928), ('\u{1efb}', 7930), ('\u{1efd}', 7932), ('\u{1eff}', 7934),
-        ('\u{1f00}', 7944), ('\u{1f01}', 7945), ('\u{1f02}', 7946), ('\u{1f03}', 7947),
-        ('\u{1f04}', 7948), ('\u{1f05}', 7949), ('\u{1f06}', 7950), ('\u{1f07}', 7951),
-        ('\u{1f10}', 7960), ('\u{1f11}', 7961), ('\u{1f12}', 7962), ('\u{1f13}', 7963),
-        ('\u{1f14}', 7964), ('\u{1f15}', 7965), ('\u{1f20}', 7976), ('\u{1f21}', 7977),
-        ('\u{1f22}', 7978), ('\u{1f23}', 7979), ('\u{1f24}', 7980), ('\u{1f25}', 7981),
-        ('\u{1f26}', 7982), ('\u{1f27}', 7983), ('\u{1f30}', 7992), ('\u{1f31}', 7993),
-        ('\u{1f32}', 7994), ('\u{1f33}', 7995), ('\u{1f34}', 7996), ('\u{1f35}', 7997),
-        ('\u{1f36}', 7998), ('\u{1f37}', 7999), ('\u{1f40}', 8008), ('\u{1f41}', 8009),
-        ('\u{1f42}', 8010), ('\u{1f43}', 8011), ('\u{1f44}', 8012), ('\u{1f45}', 8013),
-        ('\u{1f50}', 4194315), ('\u{1f51}', 8025), ('\u{1f52}', 4194316), ('\u{1f53}', 8027),
-        ('\u{1f54}', 4194317), ('\u{1f55}', 8029), ('\u{1f56}', 4194318), ('\u{1f57}', 8031),
-        ('\u{1f60}', 8040), ('\u{1f61}', 8041), ('\u{1f62}', 8042), ('\u{1f63}', 8043),
-        ('\u{1f64}', 8044), ('\u{1f65}', 8045), ('\u{1f66}', 8046), ('\u{1f67}', 8047),
-        ('\u{1f70}', 8122), ('\u{1f71}', 8123), ('\u{1f72}', 8136), ('\u{1f73}', 8137),
-        ('\u{1f74}', 8138), ('\u{1f75}', 8139), ('\u{1f76}', 8154), ('\u{1f77}', 8155),
-        ('\u{1f78}', 8184), ('\u{1f79}', 8185), ('\u{1f7a}', 8170), ('\u{1f7b}', 8171),
-        ('\u{1f7c}', 8186), ('\u{1f7d}', 8187), ('\u{1f80}', 4194319), ('\u{1f81}', 4194320),
-        ('\u{1f82}', 4194321), ('\u{1f83}', 4194322), ('\u{1f84}', 4194323), ('\u{1f85}', 4194324),
-        ('\u{1f86}', 4194325), ('\u{1f87}', 4194326), ('\u{1f88}', 4194327), ('\u{1f89}', 4194328),
-        ('\u{1f8a}', 4194329), ('\u{1f8b}', 4194330), ('\u{1f8c}', 4194331), ('\u{1f8d}', 4194332),
-        ('\u{1f8e}', 4194333), ('\u{1f8f}', 4194334), ('\u{1f90}', 4194335), ('\u{1f91}', 4194336),
-        ('\u{1f92}', 4194337), ('\u{1f93}', 4194338), ('\u{1f94}', 4194339), ('\u{1f95}', 4194340),
-        ('\u{1f96}', 4194341), ('\u{1f97}', 4194342), ('\u{1f98}', 4194343), ('\u{1f99}', 4194344),
-        ('\u{1f9a}', 4194345), ('\u{1f9b}', 4194346), ('\u{1f9c}', 4194347), ('\u{1f9d}', 4194348),
-        ('\u{1f9e}', 4194349), ('\u{1f9f}', 4194350), ('\u{1fa0}', 4194351), ('\u{1fa1}', 4194352),
-        ('\u{1fa2}', 4194353), ('\u{1fa3}', 4194354), ('\u{1fa4}', 4194355), ('\u{1fa5}', 4194356),
-        ('\u{1fa6}', 4194357), ('\u{1fa7}', 4194358), ('\u{1fa8}', 4194359), ('\u{1fa9}', 4194360),
-        ('\u{1faa}', 4194361), ('\u{1fab}', 4194362), ('\u{1fac}', 4194363), ('\u{1fad}', 4194364),
-        ('\u{1fae}', 4194365), ('\u{1faf}', 4194366), ('\u{1fb0}', 8120), ('\u{1fb1}', 8121),
-        ('\u{1fb2}', 4194367), ('\u{1fb3}', 4194368), ('\u{1fb4}', 4194369), ('\u{1fb6}', 4194370),
-        ('\u{1fb7}', 4194371), ('\u{1fbc}', 4194372), ('\u{1fbe}', 921), ('\u{1fc2}', 4194373),
-        ('\u{1fc3}', 4194374), ('\u{1fc4}', 4194375), ('\u{1fc6}', 4194376), ('\u{1fc7}', 4194377),
-        ('\u{1fcc}', 4194378), ('\u{1fd0}', 8152), ('\u{1fd1}', 8153), ('\u{1fd2}', 4194379),
-        ('\u{1fd3}', 4194380), ('\u{1fd6}', 4194381), ('\u{1fd7}', 4194382), ('\u{1fe0}', 8168),
-        ('\u{1fe1}', 8169), ('\u{1fe2}', 4194383), ('\u{1fe3}', 4194384), ('\u{1fe4}', 4194385),
-        ('\u{1fe5}', 8172), ('\u{1fe6}', 4194386), ('\u{1fe7}', 4194387), ('\u{1ff2}', 4194388),
-        ('\u{1ff3}', 4194389), ('\u{1ff4}', 4194390), ('\u{1ff6}', 4194391), ('\u{1ff7}', 4194392),
-        ('\u{1ffc}', 4194393), ('\u{214e}', 8498), ('\u{2170}', 8544), ('\u{2171}', 8545),
-        ('\u{2172}', 8546), ('\u{2173}', 8547), ('\u{2174}', 8548), ('\u{2175}', 8549),
-        ('\u{2176}', 8550), ('\u{2177}', 8551), ('\u{2178}', 8552), ('\u{2179}', 8553),
-        ('\u{217a}', 8554), ('\u{217b}', 8555), ('\u{217c}', 8556), ('\u{217d}', 8557),
-        ('\u{217e}', 8558), ('\u{217f}', 8559), ('\u{2184}', 8579), ('\u{24d0}', 9398),
-        ('\u{24d1}', 9399), ('\u{24d2}', 9400), ('\u{24d3}', 9401), ('\u{24d4}', 9402),
-        ('\u{24d5}', 9403), ('\u{24d6}', 9404), ('\u{24d7}', 9405), ('\u{24d8}', 9406),
-        ('\u{24d9}', 9407), ('\u{24da}', 9408), ('\u{24db}', 9409), ('\u{24dc}', 9410),
-        ('\u{24dd}', 9411), ('\u{24de}', 9412), ('\u{24df}', 9413), ('\u{24e0}', 9414),
-        ('\u{24e1}', 9415), ('\u{24e2}', 9416), ('\u{24e3}', 9417), ('\u{24e4}', 9418),
-        ('\u{24e5}', 9419), ('\u{24e6}', 9420), ('\u{24e7}', 9421), ('\u{24e8}', 9422),
-        ('\u{24e9}', 9423), ('\u{2c30}', 11264), ('\u{2c31}', 11265), ('\u{2c32}', 11266),
-        ('\u{2c33}', 11267), ('\u{2c34}', 11268), ('\u{2c35}', 11269), ('\u{2c36}', 11270),
-        ('\u{2c37}', 11271), ('\u{2c38}', 11272), ('\u{2c39}', 11273), ('\u{2c3a}', 11274),
-        ('\u{2c3b}', 11275), ('\u{2c3c}', 11276), ('\u{2c3d}', 11277), ('\u{2c3e}', 11278),
-        ('\u{2c3f}', 11279), ('\u{2c40}', 11280), ('\u{2c41}', 11281), ('\u{2c42}', 11282),
-        ('\u{2c43}', 11283), ('\u{2c44}', 11284), ('\u{2c45}', 11285), ('\u{2c46}', 11286),
-        ('\u{2c47}', 11287), ('\u{2c48}', 11288), ('\u{2c49}', 11289), ('\u{2c4a}', 11290),
-        ('\u{2c4b}', 11291), ('\u{2c4c}', 11292), ('\u{2c4d}', 11293), ('\u{2c4e}', 11294),
-        ('\u{2c4f}', 11295), ('\u{2c50}', 11296), ('\u{2c51}', 11297), ('\u{2c52}', 11298),
-        ('\u{2c53}', 11299), ('\u{2c54}', 11300), ('\u{2c55}', 11301), ('\u{2c56}', 11302),
-        ('\u{2c57}', 11303), ('\u{2c58}', 11304), ('\u{2c59}', 11305), ('\u{2c5a}', 11306),
-        ('\u{2c5b}', 11307), ('\u{2c5c}', 11308), ('\u{2c5d}', 11309), ('\u{2c5e}', 11310),
-        ('\u{2c5f}', 11311), ('\u{2c61}', 11360), ('\u{2c65}', 570), ('\u{2c66}', 574),
-        ('\u{2c68}', 11367), ('\u{2c6a}', 11369), ('\u{2c6c}', 11371), ('\u{2c73}', 11378),
-        ('\u{2c76}', 11381), ('\u{2c81}', 11392), ('\u{2c83}', 11394), ('\u{2c85}', 11396),
-        ('\u{2c87}', 11398), ('\u{2c89}', 11400), ('\u{2c8b}', 11402), ('\u{2c8d}', 11404),
-        ('\u{2c8f}', 11406), ('\u{2c91}', 11408), ('\u{2c93}', 11410), ('\u{2c95}', 11412),
-        ('\u{2c97}', 11414), ('\u{2c99}', 11416), ('\u{2c9b}', 11418), ('\u{2c9d}', 11420),
-        ('\u{2c9f}', 11422), ('\u{2ca1}', 11424), ('\u{2ca3}', 11426), ('\u{2ca5}', 11428),
-        ('\u{2ca7}', 11430), ('\u{2ca9}', 11432), ('\u{2cab}', 11434), ('\u{2cad}', 11436),
-        ('\u{2caf}', 11438), ('\u{2cb1}', 11440), ('\u{2cb3}', 11442), ('\u{2cb5}', 11444),
-        ('\u{2cb7}', 11446), ('\u{2cb9}', 11448), ('\u{2cbb}', 11450), ('\u{2cbd}', 11452),
-        ('\u{2cbf}', 11454), ('\u{2cc1}', 11456), ('\u{2cc3}', 11458), ('\u{2cc5}', 11460),
-        ('\u{2cc7}', 11462), ('\u{2cc9}', 11464), ('\u{2ccb}', 11466), ('\u{2ccd}', 11468),
-        ('\u{2ccf}', 11470), ('\u{2cd1}', 11472), ('\u{2cd3}', 11474), ('\u{2cd5}', 11476),
-        ('\u{2cd7}', 11478), ('\u{2cd9}', 11480), ('\u{2cdb}', 11482), ('\u{2cdd}', 11484),
-        ('\u{2cdf}', 11486), ('\u{2ce1}', 11488), ('\u{2ce3}', 11490), ('\u{2cec}', 11499),
-        ('\u{2cee}', 11501), ('\u{2cf3}', 11506), ('\u{2d00}', 4256), ('\u{2d01}', 4257),
-        ('\u{2d02}', 4258), ('\u{2d03}', 4259), ('\u{2d04}', 4260), ('\u{2d05}', 4261),
-        ('\u{2d06}', 4262), ('\u{2d07}', 4263), ('\u{2d08}', 4264), ('\u{2d09}', 4265),
-        ('\u{2d0a}', 4266), ('\u{2d0b}', 4267), ('\u{2d0c}', 4268), ('\u{2d0d}', 4269),
-        ('\u{2d0e}', 4270), ('\u{2d0f}', 4271), ('\u{2d10}', 4272), ('\u{2d11}', 4273),
-        ('\u{2d12}', 4274), ('\u{2d13}', 4275), ('\u{2d14}', 4276), ('\u{2d15}', 4277),
-        ('\u{2d16}', 4278), ('\u{2d17}', 4279), ('\u{2d18}', 4280), ('\u{2d19}', 4281),
-        ('\u{2d1a}', 4282), ('\u{2d1b}', 4283), ('\u{2d1c}', 4284), ('\u{2d1d}', 4285),
-        ('\u{2d1e}', 4286), ('\u{2d1f}', 4287), ('\u{2d20}', 4288), ('\u{2d21}', 4289),
-        ('\u{2d22}', 4290), ('\u{2d23}', 4291), ('\u{2d24}', 4292), ('\u{2d25}', 4293),
-        ('\u{2d27}', 4295), ('\u{2d2d}', 4301), ('\u{a641}', 42560), ('\u{a643}', 42562),
-        ('\u{a645}', 42564), ('\u{a647}', 42566), ('\u{a649}', 42568), ('\u{a64b}', 42570),
-        ('\u{a64d}', 42572), ('\u{a64f}', 42574), ('\u{a651}', 42576), ('\u{a653}', 42578),
-        ('\u{a655}', 42580), ('\u{a657}', 42582), ('\u{a659}', 42584), ('\u{a65b}', 42586),
-        ('\u{a65d}', 42588), ('\u{a65f}', 42590), ('\u{a661}', 42592), ('\u{a663}', 42594),
-        ('\u{a665}', 42596), ('\u{a667}', 42598), ('\u{a669}', 42600), ('\u{a66b}', 42602),
-        ('\u{a66d}', 42604), ('\u{a681}', 42624), ('\u{a683}', 42626), ('\u{a685}', 42628),
-        ('\u{a687}', 42630), ('\u{a689}', 42632), ('\u{a68b}', 42634), ('\u{a68d}', 42636),
-        ('\u{a68f}', 42638), ('\u{a691}', 42640), ('\u{a693}', 42642), ('\u{a695}', 42644),
-        ('\u{a697}', 42646), ('\u{a699}', 42648), ('\u{a69b}', 42650), ('\u{a723}', 42786),
-        ('\u{a725}', 42788), ('\u{a727}', 42790), ('\u{a729}', 42792), ('\u{a72b}', 42794),
-        ('\u{a72d}', 42796), ('\u{a72f}', 42798), ('\u{a733}', 42802), ('\u{a735}', 42804),
-        ('\u{a737}', 42806), ('\u{a739}', 42808), ('\u{a73b}', 42810), ('\u{a73d}', 42812),
-        ('\u{a73f}', 42814), ('\u{a741}', 42816), ('\u{a743}', 42818), ('\u{a745}', 42820),
-        ('\u{a747}', 42822), ('\u{a749}', 42824), ('\u{a74b}', 42826), ('\u{a74d}', 42828),
-        ('\u{a74f}', 42830), ('\u{a751}', 42832), ('\u{a753}', 42834), ('\u{a755}', 42836),
-        ('\u{a757}', 42838), ('\u{a759}', 42840), ('\u{a75b}', 42842), ('\u{a75d}', 42844),
-        ('\u{a75f}', 42846), ('\u{a761}', 42848), ('\u{a763}', 42850), ('\u{a765}', 42852),
-        ('\u{a767}', 42854), ('\u{a769}', 42856), ('\u{a76b}', 42858), ('\u{a76d}', 42860),
-        ('\u{a76f}', 42862), ('\u{a77a}', 42873), ('\u{a77c}', 42875), ('\u{a77f}', 42878),
-        ('\u{a781}', 42880), ('\u{a783}', 42882), ('\u{a785}', 42884), ('\u{a787}', 42886),
-        ('\u{a78c}', 42891), ('\u{a791}', 42896), ('\u{a793}', 42898), ('\u{a794}', 42948),
-        ('\u{a797}', 42902), ('\u{a799}', 42904), ('\u{a79b}', 42906), ('\u{a79d}', 42908),
-        ('\u{a79f}', 42910), ('\u{a7a1}', 42912), ('\u{a7a3}', 42914), ('\u{a7a5}', 42916),
-        ('\u{a7a7}', 42918), ('\u{a7a9}', 42920), ('\u{a7b5}', 42932), ('\u{a7b7}', 42934),
-        ('\u{a7b9}', 42936), ('\u{a7bb}', 42938), ('\u{a7bd}', 42940), ('\u{a7bf}', 42942),
-        ('\u{a7c1}', 42944), ('\u{a7c3}', 42946), ('\u{a7c8}', 42951), ('\u{a7ca}', 42953),
-        ('\u{a7cd}', 42956), ('\u{a7cf}', 42958), ('\u{a7d1}', 42960), ('\u{a7d3}', 42962),
-        ('\u{a7d5}', 42964), ('\u{a7d7}', 42966), ('\u{a7d9}', 42968), ('\u{a7db}', 42970),
-        ('\u{a7f6}', 42997), ('\u{ab53}', 42931), ('\u{ab70}', 5024), ('\u{ab71}', 5025),
-        ('\u{ab72}', 5026), ('\u{ab73}', 5027), ('\u{ab74}', 5028), ('\u{ab75}', 5029),
-        ('\u{ab76}', 5030), ('\u{ab77}', 5031), ('\u{ab78}', 5032), ('\u{ab79}', 5033),
-        ('\u{ab7a}', 5034), ('\u{ab7b}', 5035), ('\u{ab7c}', 5036), ('\u{ab7d}', 5037),
-        ('\u{ab7e}', 5038), ('\u{ab7f}', 5039), ('\u{ab80}', 5040), ('\u{ab81}', 5041),
-        ('\u{ab82}', 5042), ('\u{ab83}', 5043), ('\u{ab84}', 5044), ('\u{ab85}', 5045),
-        ('\u{ab86}', 5046), ('\u{ab87}', 5047), ('\u{ab88}', 5048), ('\u{ab89}', 5049),
-        ('\u{ab8a}', 5050), ('\u{ab8b}', 5051), ('\u{ab8c}', 5052), ('\u{ab8d}', 5053),
-        ('\u{ab8e}', 5054), ('\u{ab8f}', 5055), ('\u{ab90}', 5056), ('\u{ab91}', 5057),
-        ('\u{ab92}', 5058), ('\u{ab93}', 5059), ('\u{ab94}', 5060), ('\u{ab95}', 5061),
-        ('\u{ab96}', 5062), ('\u{ab97}', 5063), ('\u{ab98}', 5064), ('\u{ab99}', 5065),
-        ('\u{ab9a}', 5066), ('\u{ab9b}', 5067), ('\u{ab9c}', 5068), ('\u{ab9d}', 5069),
-        ('\u{ab9e}', 5070), ('\u{ab9f}', 5071), ('\u{aba0}', 5072), ('\u{aba1}', 5073),
-        ('\u{aba2}', 5074), ('\u{aba3}', 5075), ('\u{aba4}', 5076), ('\u{aba5}', 5077),
-        ('\u{aba6}', 5078), ('\u{aba7}', 5079), ('\u{aba8}', 5080), ('\u{aba9}', 5081),
-        ('\u{abaa}', 5082), ('\u{abab}', 5083), ('\u{abac}', 5084), ('\u{abad}', 5085),
-        ('\u{abae}', 5086), ('\u{abaf}', 5087), ('\u{abb0}', 5088), ('\u{abb1}', 5089),
-        ('\u{abb2}', 5090), ('\u{abb3}', 5091), ('\u{abb4}', 5092), ('\u{abb5}', 5093),
-        ('\u{abb6}', 5094), ('\u{abb7}', 5095), ('\u{abb8}', 5096), ('\u{abb9}', 5097),
-        ('\u{abba}', 5098), ('\u{abbb}', 5099), ('\u{abbc}', 5100), ('\u{abbd}', 5101),
-        ('\u{abbe}', 5102), ('\u{abbf}', 5103), ('\u{fb00}', 4194394), ('\u{fb01}', 4194395),
-        ('\u{fb02}', 4194396), ('\u{fb03}', 4194397), ('\u{fb04}', 4194398), ('\u{fb05}', 4194399),
-        ('\u{fb06}', 4194400), ('\u{fb13}', 4194401), ('\u{fb14}', 4194402), ('\u{fb15}', 4194403),
-        ('\u{fb16}', 4194404), ('\u{fb17}', 4194405), ('\u{ff41}', 65313), ('\u{ff42}', 65314),
-        ('\u{ff43}', 65315), ('\u{ff44}', 65316), ('\u{ff45}', 65317), ('\u{ff46}', 65318),
-        ('\u{ff47}', 65319), ('\u{ff48}', 65320), ('\u{ff49}', 65321), ('\u{ff4a}', 65322),
-        ('\u{ff4b}', 65323), ('\u{ff4c}', 65324), ('\u{ff4d}', 65325), ('\u{ff4e}', 65326),
-        ('\u{ff4f}', 65327), ('\u{ff50}', 65328), ('\u{ff51}', 65329), ('\u{ff52}', 65330),
-        ('\u{ff53}', 65331), ('\u{ff54}', 65332), ('\u{ff55}', 65333), ('\u{ff56}', 65334),
-        ('\u{ff57}', 65335), ('\u{ff58}', 65336), ('\u{ff59}', 65337), ('\u{ff5a}', 65338),
-        ('\u{10428}', 66560), ('\u{10429}', 66561), ('\u{1042a}', 66562), ('\u{1042b}', 66563),
-        ('\u{1042c}', 66564), ('\u{1042d}', 66565), ('\u{1042e}', 66566), ('\u{1042f}', 66567),
-        ('\u{10430}', 66568), ('\u{10431}', 66569), ('\u{10432}', 66570), ('\u{10433}', 66571),
-        ('\u{10434}', 66572), ('\u{10435}', 66573), ('\u{10436}', 66574), ('\u{10437}', 66575),
-        ('\u{10438}', 66576), ('\u{10439}', 66577), ('\u{1043a}', 66578), ('\u{1043b}', 66579),
-        ('\u{1043c}', 66580), ('\u{1043d}', 66581), ('\u{1043e}', 66582), ('\u{1043f}', 66583),
-        ('\u{10440}', 66584), ('\u{10441}', 66585), ('\u{10442}', 66586), ('\u{10443}', 66587),
-        ('\u{10444}', 66588), ('\u{10445}', 66589), ('\u{10446}', 66590), ('\u{10447}', 66591),
-        ('\u{10448}', 66592), ('\u{10449}', 66593), ('\u{1044a}', 66594), ('\u{1044b}', 66595),
-        ('\u{1044c}', 66596), ('\u{1044d}', 66597), ('\u{1044e}', 66598), ('\u{1044f}', 66599),
-        ('\u{104d8}', 66736), ('\u{104d9}', 66737), ('\u{104da}', 66738), ('\u{104db}', 66739),
-        ('\u{104dc}', 66740), ('\u{104dd}', 66741), ('\u{104de}', 66742), ('\u{104df}', 66743),
-        ('\u{104e0}', 66744), ('\u{104e1}', 66745), ('\u{104e2}', 66746), ('\u{104e3}', 66747),
-        ('\u{104e4}', 66748), ('\u{104e5}', 66749), ('\u{104e6}', 66750), ('\u{104e7}', 66751),
-        ('\u{104e8}', 66752), ('\u{104e9}', 66753), ('\u{104ea}', 66754), ('\u{104eb}', 66755),
-        ('\u{104ec}', 66756), ('\u{104ed}', 66757), ('\u{104ee}', 66758), ('\u{104ef}', 66759),
-        ('\u{104f0}', 66760), ('\u{104f1}', 66761), ('\u{104f2}', 66762), ('\u{104f3}', 66763),
-        ('\u{104f4}', 66764), ('\u{104f5}', 66765), ('\u{104f6}', 66766), ('\u{104f7}', 66767),
-        ('\u{104f8}', 66768), ('\u{104f9}', 66769), ('\u{104fa}', 66770), ('\u{104fb}', 66771),
-        ('\u{10597}', 66928), ('\u{10598}', 66929), ('\u{10599}', 66930), ('\u{1059a}', 66931),
-        ('\u{1059b}', 66932), ('\u{1059c}', 66933), ('\u{1059d}', 66934), ('\u{1059e}', 66935),
-        ('\u{1059f}', 66936), ('\u{105a0}', 66937), ('\u{105a1}', 66938), ('\u{105a3}', 66940),
-        ('\u{105a4}', 66941), ('\u{105a5}', 66942), ('\u{105a6}', 66943), ('\u{105a7}', 66944),
-        ('\u{105a8}', 66945), ('\u{105a9}', 66946), ('\u{105aa}', 66947), ('\u{105ab}', 66948),
-        ('\u{105ac}', 66949), ('\u{105ad}', 66950), ('\u{105ae}', 66951), ('\u{105af}', 66952),
-        ('\u{105b0}', 66953), ('\u{105b1}', 66954), ('\u{105b3}', 66956), ('\u{105b4}', 66957),
-        ('\u{105b5}', 66958), ('\u{105b6}', 66959), ('\u{105b7}', 66960), ('\u{105b8}', 66961),
-        ('\u{105b9}', 66962), ('\u{105bb}', 66964), ('\u{105bc}', 66965), ('\u{10cc0}', 68736),
-        ('\u{10cc1}', 68737), ('\u{10cc2}', 68738), ('\u{10cc3}', 68739), ('\u{10cc4}', 68740),
-        ('\u{10cc5}', 68741), ('\u{10cc6}', 68742), ('\u{10cc7}', 68743), ('\u{10cc8}', 68744),
-        ('\u{10cc9}', 68745), ('\u{10cca}', 68746), ('\u{10ccb}', 68747), ('\u{10ccc}', 68748),
-        ('\u{10ccd}', 68749), ('\u{10cce}', 68750), ('\u{10ccf}', 68751), ('\u{10cd0}', 68752),
-        ('\u{10cd1}', 68753), ('\u{10cd2}', 68754), ('\u{10cd3}', 68755), ('\u{10cd4}', 68756),
-        ('\u{10cd5}', 68757), ('\u{10cd6}', 68758), ('\u{10cd7}', 68759), ('\u{10cd8}', 68760),
-        ('\u{10cd9}', 68761), ('\u{10cda}', 68762), ('\u{10cdb}', 68763), ('\u{10cdc}', 68764),
-        ('\u{10cdd}', 68765), ('\u{10cde}', 68766), ('\u{10cdf}', 68767), ('\u{10ce0}', 68768),
-        ('\u{10ce1}', 68769), ('\u{10ce2}', 68770), ('\u{10ce3}', 68771), ('\u{10ce4}', 68772),
-        ('\u{10ce5}', 68773), ('\u{10ce6}', 68774), ('\u{10ce7}', 68775), ('\u{10ce8}', 68776),
-        ('\u{10ce9}', 68777), ('\u{10cea}', 68778), ('\u{10ceb}', 68779), ('\u{10cec}', 68780),
-        ('\u{10ced}', 68781), ('\u{10cee}', 68782), ('\u{10cef}', 68783), ('\u{10cf0}', 68784),
-        ('\u{10cf1}', 68785), ('\u{10cf2}', 68786), ('\u{10d70}', 68944), ('\u{10d71}', 68945),
-        ('\u{10d72}', 68946), ('\u{10d73}', 68947), ('\u{10d74}', 68948), ('\u{10d75}', 68949),
-        ('\u{10d76}', 68950), ('\u{10d77}', 68951), ('\u{10d78}', 68952), ('\u{10d79}', 68953),
-        ('\u{10d7a}', 68954), ('\u{10d7b}', 68955), ('\u{10d7c}', 68956), ('\u{10d7d}', 68957),
-        ('\u{10d7e}', 68958), ('\u{10d7f}', 68959), ('\u{10d80}', 68960), ('\u{10d81}', 68961),
-        ('\u{10d82}', 68962), ('\u{10d83}', 68963), ('\u{10d84}', 68964), ('\u{10d85}', 68965),
-        ('\u{118c0}', 71840), ('\u{118c1}', 71841), ('\u{118c2}', 71842), ('\u{118c3}', 71843),
-        ('\u{118c4}', 71844), ('\u{118c5}', 71845), ('\u{118c6}', 71846), ('\u{118c7}', 71847),
-        ('\u{118c8}', 71848), ('\u{118c9}', 71849), ('\u{118ca}', 71850), ('\u{118cb}', 71851),
-        ('\u{118cc}', 71852), ('\u{118cd}', 71853), ('\u{118ce}', 71854), ('\u{118cf}', 71855),
-        ('\u{118d0}', 71856), ('\u{118d1}', 71857), ('\u{118d2}', 71858), ('\u{118d3}', 71859),
-        ('\u{118d4}', 71860), ('\u{118d5}', 71861), ('\u{118d6}', 71862), ('\u{118d7}', 71863),
-        ('\u{118d8}', 71864), ('\u{118d9}', 71865), ('\u{118da}', 71866), ('\u{118db}', 71867),
-        ('\u{118dc}', 71868), ('\u{118dd}', 71869), ('\u{118de}', 71870), ('\u{118df}', 71871),
-        ('\u{16e60}', 93760), ('\u{16e61}', 93761), ('\u{16e62}', 93762), ('\u{16e63}', 93763),
-        ('\u{16e64}', 93764), ('\u{16e65}', 93765), ('\u{16e66}', 93766), ('\u{16e67}', 93767),
-        ('\u{16e68}', 93768), ('\u{16e69}', 93769), ('\u{16e6a}', 93770), ('\u{16e6b}', 93771),
-        ('\u{16e6c}', 93772), ('\u{16e6d}', 93773), ('\u{16e6e}', 93774), ('\u{16e6f}', 93775),
-        ('\u{16e70}', 93776), ('\u{16e71}', 93777), ('\u{16e72}', 93778), ('\u{16e73}', 93779),
-        ('\u{16e74}', 93780), ('\u{16e75}', 93781), ('\u{16e76}', 93782), ('\u{16e77}', 93783),
-        ('\u{16e78}', 93784), ('\u{16e79}', 93785), ('\u{16e7a}', 93786), ('\u{16e7b}', 93787),
-        ('\u{16e7c}', 93788), ('\u{16e7d}', 93789), ('\u{16e7e}', 93790), ('\u{16e7f}', 93791),
-        ('\u{16ebb}', 93856), ('\u{16ebc}', 93857), ('\u{16ebd}', 93858), ('\u{16ebe}', 93859),
-        ('\u{16ebf}', 93860), ('\u{16ec0}', 93861), ('\u{16ec1}', 93862), ('\u{16ec2}', 93863),
-        ('\u{16ec3}', 93864), ('\u{16ec4}', 93865), ('\u{16ec5}', 93866), ('\u{16ec6}', 93867),
-        ('\u{16ec7}', 93868), ('\u{16ec8}', 93869), ('\u{16ec9}', 93870), ('\u{16eca}', 93871),
-        ('\u{16ecb}', 93872), ('\u{16ecc}', 93873), ('\u{16ecd}', 93874), ('\u{16ece}', 93875),
-        ('\u{16ecf}', 93876), ('\u{16ed0}', 93877), ('\u{16ed1}', 93878), ('\u{16ed2}', 93879),
-        ('\u{16ed3}', 93880), ('\u{1e922}', 125184), ('\u{1e923}', 125185), ('\u{1e924}', 125186),
-        ('\u{1e925}', 125187), ('\u{1e926}', 125188), ('\u{1e927}', 125189), ('\u{1e928}', 125190),
-        ('\u{1e929}', 125191), ('\u{1e92a}', 125192), ('\u{1e92b}', 125193), ('\u{1e92c}', 125194),
-        ('\u{1e92d}', 125195), ('\u{1e92e}', 125196), ('\u{1e92f}', 125197), ('\u{1e930}', 125198),
-        ('\u{1e931}', 125199), ('\u{1e932}', 125200), ('\u{1e933}', 125201), ('\u{1e934}', 125202),
-        ('\u{1e935}', 125203), ('\u{1e936}', 125204), ('\u{1e937}', 125205), ('\u{1e938}', 125206),
-        ('\u{1e939}', 125207), ('\u{1e93a}', 125208), ('\u{1e93b}', 125209), ('\u{1e93c}', 125210),
-        ('\u{1e93d}', 125211), ('\u{1e93e}', 125212), ('\u{1e93f}', 125213), ('\u{1e940}', 125214),
-        ('\u{1e941}', 125215), ('\u{1e942}', 125216), ('\u{1e943}', 125217),
-    ];
-
-    static UPPERCASE_TABLE_MULTI: &[[char; 3]; 102] = &[
-        ['S', 'S', '\u{0}'], ['\u{2bc}', 'N', '\u{0}'], ['J', '\u{30c}', '\u{0}'],
-        ['\u{399}', '\u{308}', '\u{301}'], ['\u{3a5}', '\u{308}', '\u{301}'],
-        ['\u{535}', '\u{552}', '\u{0}'], ['H', '\u{331}', '\u{0}'], ['T', '\u{308}', '\u{0}'],
-        ['W', '\u{30a}', '\u{0}'], ['Y', '\u{30a}', '\u{0}'], ['A', '\u{2be}', '\u{0}'],
-        ['\u{3a5}', '\u{313}', '\u{0}'], ['\u{3a5}', '\u{313}', '\u{300}'],
-        ['\u{3a5}', '\u{313}', '\u{301}'], ['\u{3a5}', '\u{313}', '\u{342}'],
-        ['\u{1f08}', '\u{399}', '\u{0}'], ['\u{1f09}', '\u{399}', '\u{0}'],
-        ['\u{1f0a}', '\u{399}', '\u{0}'], ['\u{1f0b}', '\u{399}', '\u{0}'],
-        ['\u{1f0c}', '\u{399}', '\u{0}'], ['\u{1f0d}', '\u{399}', '\u{0}'],
-        ['\u{1f0e}', '\u{399}', '\u{0}'], ['\u{1f0f}', '\u{399}', '\u{0}'],
-        ['\u{1f08}', '\u{399}', '\u{0}'], ['\u{1f09}', '\u{399}', '\u{0}'],
-        ['\u{1f0a}', '\u{399}', '\u{0}'], ['\u{1f0b}', '\u{399}', '\u{0}'],
-        ['\u{1f0c}', '\u{399}', '\u{0}'], ['\u{1f0d}', '\u{399}', '\u{0}'],
-        ['\u{1f0e}', '\u{399}', '\u{0}'], ['\u{1f0f}', '\u{399}', '\u{0}'],
-        ['\u{1f28}', '\u{399}', '\u{0}'], ['\u{1f29}', '\u{399}', '\u{0}'],
-        ['\u{1f2a}', '\u{399}', '\u{0}'], ['\u{1f2b}', '\u{399}', '\u{0}'],
-        ['\u{1f2c}', '\u{399}', '\u{0}'], ['\u{1f2d}', '\u{399}', '\u{0}'],
-        ['\u{1f2e}', '\u{399}', '\u{0}'], ['\u{1f2f}', '\u{399}', '\u{0}'],
-        ['\u{1f28}', '\u{399}', '\u{0}'], ['\u{1f29}', '\u{399}', '\u{0}'],
-        ['\u{1f2a}', '\u{399}', '\u{0}'], ['\u{1f2b}', '\u{399}', '\u{0}'],
-        ['\u{1f2c}', '\u{399}', '\u{0}'], ['\u{1f2d}', '\u{399}', '\u{0}'],
-        ['\u{1f2e}', '\u{399}', '\u{0}'], ['\u{1f2f}', '\u{399}', '\u{0}'],
-        ['\u{1f68}', '\u{399}', '\u{0}'], ['\u{1f69}', '\u{399}', '\u{0}'],
-        ['\u{1f6a}', '\u{399}', '\u{0}'], ['\u{1f6b}', '\u{399}', '\u{0}'],
-        ['\u{1f6c}', '\u{399}', '\u{0}'], ['\u{1f6d}', '\u{399}', '\u{0}'],
-        ['\u{1f6e}', '\u{399}', '\u{0}'], ['\u{1f6f}', '\u{399}', '\u{0}'],
-        ['\u{1f68}', '\u{399}', '\u{0}'], ['\u{1f69}', '\u{399}', '\u{0}'],
-        ['\u{1f6a}', '\u{399}', '\u{0}'], ['\u{1f6b}', '\u{399}', '\u{0}'],
-        ['\u{1f6c}', '\u{399}', '\u{0}'], ['\u{1f6d}', '\u{399}', '\u{0}'],
-        ['\u{1f6e}', '\u{399}', '\u{0}'], ['\u{1f6f}', '\u{399}', '\u{0}'],
-        ['\u{1fba}', '\u{399}', '\u{0}'], ['\u{391}', '\u{399}', '\u{0}'],
-        ['\u{386}', '\u{399}', '\u{0}'], ['\u{391}', '\u{342}', '\u{0}'],
-        ['\u{391}', '\u{342}', '\u{399}'], ['\u{391}', '\u{399}', '\u{0}'],
-        ['\u{1fca}', '\u{399}', '\u{0}'], ['\u{397}', '\u{399}', '\u{0}'],
-        ['\u{389}', '\u{399}', '\u{0}'], ['\u{397}', '\u{342}', '\u{0}'],
-        ['\u{397}', '\u{342}', '\u{399}'], ['\u{397}', '\u{399}', '\u{0}'],
-        ['\u{399}', '\u{308}', '\u{300}'], ['\u{399}', '\u{308}', '\u{301}'],
-        ['\u{399}', '\u{342}', '\u{0}'], ['\u{399}', '\u{308}', '\u{342}'],
-        ['\u{3a5}', '\u{308}', '\u{300}'], ['\u{3a5}', '\u{308}', '\u{301}'],
-        ['\u{3a1}', '\u{313}', '\u{0}'], ['\u{3a5}', '\u{342}', '\u{0}'],
-        ['\u{3a5}', '\u{308}', '\u{342}'], ['\u{1ffa}', '\u{399}', '\u{0}'],
-        ['\u{3a9}', '\u{399}', '\u{0}'], ['\u{38f}', '\u{399}', '\u{0}'],
-        ['\u{3a9}', '\u{342}', '\u{0}'], ['\u{3a9}', '\u{342}', '\u{399}'],
-        ['\u{3a9}', '\u{399}', '\u{0}'], ['F', 'F', '\u{0}'], ['F', 'I', '\u{0}'],
-        ['F', 'L', '\u{0}'], ['F', 'F', 'I'], ['F', 'F', 'L'], ['S', 'T', '\u{0}'],
-        ['S', 'T', '\u{0}'], ['\u{544}', '\u{546}', '\u{0}'], ['\u{544}', '\u{535}', '\u{0}'],
-        ['\u{544}', '\u{53b}', '\u{0}'], ['\u{54e}', '\u{546}', '\u{0}'],
-        ['\u{544}', '\u{53d}', '\u{0}'],
-    ];
+    static UPPERCASE_LUT: L1Lut = L1Lut {
+        l2_luts: [
+            L2Lut {
+                singles: &[ // 185 entries, 1110 bytes
+                    (Range::singleton(0x00b5), 743), (Range::step_by_1(0x00e0..=0x00f6), -32),
+                    (Range::step_by_1(0x00f8..=0x00fe), -32), (Range::singleton(0x00ff), 121),
+                    (Range::step_by_2(0x0101..=0x012f), -1), (Range::singleton(0x0131), -232),
+                    (Range::step_by_2(0x0133..=0x0137), -1), (Range::step_by_2(0x013a..=0x0148), -1),
+                    (Range::step_by_2(0x014b..=0x0177), -1), (Range::step_by_2(0x017a..=0x017e), -1),
+                    (Range::singleton(0x017f), -300), (Range::singleton(0x0180), 195),
+                    (Range::step_by_2(0x0183..=0x0185), -1), (Range::singleton(0x0188), -1),
+                    (Range::singleton(0x018c), -1), (Range::singleton(0x0192), -1),
+                    (Range::singleton(0x0195), 97), (Range::singleton(0x0199), -1),
+                    (Range::singleton(0x019a), 163), (Range::singleton(0x019b), -22975),
+                    (Range::singleton(0x019e), 130), (Range::step_by_2(0x01a1..=0x01a5), -1),
+                    (Range::singleton(0x01a8), -1), (Range::singleton(0x01ad), -1),
+                    (Range::singleton(0x01b0), -1), (Range::step_by_2(0x01b4..=0x01b6), -1),
+                    (Range::singleton(0x01b9), -1), (Range::singleton(0x01bd), -1),
+                    (Range::singleton(0x01bf), 56), (Range::singleton(0x01c5), -1),
+                    (Range::singleton(0x01c6), -2), (Range::singleton(0x01c8), -1),
+                    (Range::singleton(0x01c9), -2), (Range::singleton(0x01cb), -1),
+                    (Range::singleton(0x01cc), -2), (Range::step_by_2(0x01ce..=0x01dc), -1),
+                    (Range::singleton(0x01dd), -79), (Range::step_by_2(0x01df..=0x01ef), -1),
+                    (Range::singleton(0x01f2), -1), (Range::singleton(0x01f3), -2),
+                    (Range::singleton(0x01f5), -1), (Range::step_by_2(0x01f9..=0x021f), -1),
+                    (Range::step_by_2(0x0223..=0x0233), -1), (Range::singleton(0x023c), -1),
+                    (Range::step_by_1(0x023f..=0x0240), 10815), (Range::singleton(0x0242), -1),
+                    (Range::step_by_2(0x0247..=0x024f), -1), (Range::singleton(0x0250), 10783),
+                    (Range::singleton(0x0251), 10780), (Range::singleton(0x0252), 10782),
+                    (Range::singleton(0x0253), -210), (Range::singleton(0x0254), -206),
+                    (Range::step_by_1(0x0256..=0x0257), -205), (Range::singleton(0x0259), -202),
+                    (Range::singleton(0x025b), -203), (Range::singleton(0x025c), -23217),
+                    (Range::singleton(0x0260), -205), (Range::singleton(0x0261), -23221),
+                    (Range::singleton(0x0263), -207), (Range::singleton(0x0264), -23193),
+                    (Range::singleton(0x0265), -23256), (Range::singleton(0x0266), -23228),
+                    (Range::singleton(0x0268), -209), (Range::singleton(0x0269), -211),
+                    (Range::singleton(0x026a), -23228), (Range::singleton(0x026b), 10743),
+                    (Range::singleton(0x026c), -23231), (Range::singleton(0x026f), -211),
+                    (Range::singleton(0x0271), 10749), (Range::singleton(0x0272), -213),
+                    (Range::singleton(0x0275), -214), (Range::singleton(0x027d), 10727),
+                    (Range::singleton(0x0280), -218), (Range::singleton(0x0282), -23229),
+                    (Range::singleton(0x0283), -218), (Range::singleton(0x0287), -23254),
+                    (Range::singleton(0x0288), -218), (Range::singleton(0x0289), -69),
+                    (Range::step_by_1(0x028a..=0x028b), -217), (Range::singleton(0x028c), -71),
+                    (Range::singleton(0x0292), -219), (Range::singleton(0x029d), -23275),
+                    (Range::singleton(0x029e), -23278), (Range::singleton(0x0345), 84),
+                    (Range::step_by_2(0x0371..=0x0373), -1), (Range::singleton(0x0377), -1),
+                    (Range::step_by_1(0x037b..=0x037d), 130), (Range::singleton(0x03ac), -38),
+                    (Range::step_by_1(0x03ad..=0x03af), -37), (Range::step_by_1(0x03b1..=0x03c1), -32),
+                    (Range::singleton(0x03c2), -31), (Range::step_by_1(0x03c3..=0x03cb), -32),
+                    (Range::singleton(0x03cc), -64), (Range::step_by_1(0x03cd..=0x03ce), -63),
+                    (Range::singleton(0x03d0), -62), (Range::singleton(0x03d1), -57),
+                    (Range::singleton(0x03d5), -47), (Range::singleton(0x03d6), -54),
+                    (Range::singleton(0x03d7), -8), (Range::step_by_2(0x03d9..=0x03ef), -1),
+                    (Range::singleton(0x03f0), -86), (Range::singleton(0x03f1), -80),
+                    (Range::singleton(0x03f2), 7), (Range::singleton(0x03f3), -116),
+                    (Range::singleton(0x03f5), -96), (Range::singleton(0x03f8), -1),
+                    (Range::singleton(0x03fb), -1), (Range::step_by_1(0x0430..=0x044f), -32),
+                    (Range::step_by_1(0x0450..=0x045f), -80), (Range::step_by_2(0x0461..=0x0481), -1),
+                    (Range::step_by_2(0x048b..=0x04bf), -1), (Range::step_by_2(0x04c2..=0x04ce), -1),
+                    (Range::singleton(0x04cf), -15), (Range::step_by_2(0x04d1..=0x052f), -1),
+                    (Range::step_by_1(0x0561..=0x0586), -48), (Range::step_by_1(0x10d0..=0x10fa), 3008),
+                    (Range::step_by_1(0x10fd..=0x10ff), 3008), (Range::step_by_1(0x13f8..=0x13fd), -8),
+                    (Range::singleton(0x1c80), -6254), (Range::singleton(0x1c81), -6253),
+                    (Range::singleton(0x1c82), -6244), (Range::step_by_1(0x1c83..=0x1c84), -6242),
+                    (Range::singleton(0x1c85), -6243), (Range::singleton(0x1c86), -6236),
+                    (Range::singleton(0x1c87), -6181), (Range::singleton(0x1c88), -30270),
+                    (Range::singleton(0x1c8a), -1), (Range::singleton(0x1d79), -30204),
+                    (Range::singleton(0x1d7d), 3814), (Range::singleton(0x1d8e), -30152),
+                    (Range::step_by_2(0x1e01..=0x1e95), -1), (Range::singleton(0x1e9b), -59),
+                    (Range::step_by_2(0x1ea1..=0x1eff), -1), (Range::step_by_1(0x1f00..=0x1f07), 8),
+                    (Range::step_by_1(0x1f10..=0x1f15), 8), (Range::step_by_1(0x1f20..=0x1f27), 8),
+                    (Range::step_by_1(0x1f30..=0x1f37), 8), (Range::step_by_1(0x1f40..=0x1f45), 8),
+                    (Range::step_by_2(0x1f51..=0x1f57), 8), (Range::step_by_1(0x1f60..=0x1f67), 8),
+                    (Range::step_by_1(0x1f70..=0x1f71), 74), (Range::step_by_1(0x1f72..=0x1f75), 86),
+                    (Range::step_by_1(0x1f76..=0x1f77), 100), (Range::step_by_1(0x1f78..=0x1f79), 128),
+                    (Range::step_by_1(0x1f7a..=0x1f7b), 112), (Range::step_by_1(0x1f7c..=0x1f7d), 126),
+                    (Range::step_by_1(0x1fb0..=0x1fb1), 8), (Range::singleton(0x1fbe), -7205),
+                    (Range::step_by_1(0x1fd0..=0x1fd1), 8), (Range::step_by_1(0x1fe0..=0x1fe1), 8),
+                    (Range::singleton(0x1fe5), 7), (Range::singleton(0x214e), -28),
+                    (Range::step_by_1(0x2170..=0x217f), -16), (Range::singleton(0x2184), -1),
+                    (Range::step_by_1(0x24d0..=0x24e9), -26), (Range::step_by_1(0x2c30..=0x2c5f), -48),
+                    (Range::singleton(0x2c61), -1), (Range::singleton(0x2c65), -10795),
+                    (Range::singleton(0x2c66), -10792), (Range::step_by_2(0x2c68..=0x2c6c), -1),
+                    (Range::singleton(0x2c73), -1), (Range::singleton(0x2c76), -1),
+                    (Range::step_by_2(0x2c81..=0x2ce3), -1), (Range::step_by_2(0x2cec..=0x2cee), -1),
+                    (Range::singleton(0x2cf3), -1), (Range::step_by_1(0x2d00..=0x2d25), -7264),
+                    (Range::singleton(0x2d27), -7264), (Range::singleton(0x2d2d), -7264),
+                    (Range::step_by_2(0xa641..=0xa66d), -1), (Range::step_by_2(0xa681..=0xa69b), -1),
+                    (Range::step_by_2(0xa723..=0xa72f), -1), (Range::step_by_2(0xa733..=0xa76f), -1),
+                    (Range::step_by_2(0xa77a..=0xa77c), -1), (Range::step_by_2(0xa77f..=0xa787), -1),
+                    (Range::singleton(0xa78c), -1), (Range::step_by_2(0xa791..=0xa793), -1),
+                    (Range::singleton(0xa794), 48), (Range::step_by_2(0xa797..=0xa7a9), -1),
+                    (Range::step_by_2(0xa7b5..=0xa7c3), -1), (Range::step_by_2(0xa7c8..=0xa7ca), -1),
+                    (Range::step_by_2(0xa7cd..=0xa7db), -1), (Range::singleton(0xa7f6), -1),
+                    (Range::singleton(0xab53), -928), (Range::step_by_1(0xab70..=0xabbf), 26672),
+                    (Range::step_by_1(0xff41..=0xff5a), -32),
+                ],
+                multis: &[ // 102 entries, 816 bytes
+                    (0x00df, [0x0053, 0x0053, 0x0000]), (0x0149, [0x02bc, 0x004e, 0x0000]),
+                    (0x01f0, [0x004a, 0x030c, 0x0000]), (0x0390, [0x0399, 0x0308, 0x0301]),
+                    (0x03b0, [0x03a5, 0x0308, 0x0301]), (0x0587, [0x0535, 0x0552, 0x0000]),
+                    (0x1e96, [0x0048, 0x0331, 0x0000]), (0x1e97, [0x0054, 0x0308, 0x0000]),
+                    (0x1e98, [0x0057, 0x030a, 0x0000]), (0x1e99, [0x0059, 0x030a, 0x0000]),
+                    (0x1e9a, [0x0041, 0x02be, 0x0000]), (0x1f50, [0x03a5, 0x0313, 0x0000]),
+                    (0x1f52, [0x03a5, 0x0313, 0x0300]), (0x1f54, [0x03a5, 0x0313, 0x0301]),
+                    (0x1f56, [0x03a5, 0x0313, 0x0342]), (0x1f80, [0x1f08, 0x0399, 0x0000]),
+                    (0x1f81, [0x1f09, 0x0399, 0x0000]), (0x1f82, [0x1f0a, 0x0399, 0x0000]),
+                    (0x1f83, [0x1f0b, 0x0399, 0x0000]), (0x1f84, [0x1f0c, 0x0399, 0x0000]),
+                    (0x1f85, [0x1f0d, 0x0399, 0x0000]), (0x1f86, [0x1f0e, 0x0399, 0x0000]),
+                    (0x1f87, [0x1f0f, 0x0399, 0x0000]), (0x1f88, [0x1f08, 0x0399, 0x0000]),
+                    (0x1f89, [0x1f09, 0x0399, 0x0000]), (0x1f8a, [0x1f0a, 0x0399, 0x0000]),
+                    (0x1f8b, [0x1f0b, 0x0399, 0x0000]), (0x1f8c, [0x1f0c, 0x0399, 0x0000]),
+                    (0x1f8d, [0x1f0d, 0x0399, 0x0000]), (0x1f8e, [0x1f0e, 0x0399, 0x0000]),
+                    (0x1f8f, [0x1f0f, 0x0399, 0x0000]), (0x1f90, [0x1f28, 0x0399, 0x0000]),
+                    (0x1f91, [0x1f29, 0x0399, 0x0000]), (0x1f92, [0x1f2a, 0x0399, 0x0000]),
+                    (0x1f93, [0x1f2b, 0x0399, 0x0000]), (0x1f94, [0x1f2c, 0x0399, 0x0000]),
+                    (0x1f95, [0x1f2d, 0x0399, 0x0000]), (0x1f96, [0x1f2e, 0x0399, 0x0000]),
+                    (0x1f97, [0x1f2f, 0x0399, 0x0000]), (0x1f98, [0x1f28, 0x0399, 0x0000]),
+                    (0x1f99, [0x1f29, 0x0399, 0x0000]), (0x1f9a, [0x1f2a, 0x0399, 0x0000]),
+                    (0x1f9b, [0x1f2b, 0x0399, 0x0000]), (0x1f9c, [0x1f2c, 0x0399, 0x0000]),
+                    (0x1f9d, [0x1f2d, 0x0399, 0x0000]), (0x1f9e, [0x1f2e, 0x0399, 0x0000]),
+                    (0x1f9f, [0x1f2f, 0x0399, 0x0000]), (0x1fa0, [0x1f68, 0x0399, 0x0000]),
+                    (0x1fa1, [0x1f69, 0x0399, 0x0000]), (0x1fa2, [0x1f6a, 0x0399, 0x0000]),
+                    (0x1fa3, [0x1f6b, 0x0399, 0x0000]), (0x1fa4, [0x1f6c, 0x0399, 0x0000]),
+                    (0x1fa5, [0x1f6d, 0x0399, 0x0000]), (0x1fa6, [0x1f6e, 0x0399, 0x0000]),
+                    (0x1fa7, [0x1f6f, 0x0399, 0x0000]), (0x1fa8, [0x1f68, 0x0399, 0x0000]),
+                    (0x1fa9, [0x1f69, 0x0399, 0x0000]), (0x1faa, [0x1f6a, 0x0399, 0x0000]),
+                    (0x1fab, [0x1f6b, 0x0399, 0x0000]), (0x1fac, [0x1f6c, 0x0399, 0x0000]),
+                    (0x1fad, [0x1f6d, 0x0399, 0x0000]), (0x1fae, [0x1f6e, 0x0399, 0x0000]),
+                    (0x1faf, [0x1f6f, 0x0399, 0x0000]), (0x1fb2, [0x1fba, 0x0399, 0x0000]),
+                    (0x1fb3, [0x0391, 0x0399, 0x0000]), (0x1fb4, [0x0386, 0x0399, 0x0000]),
+                    (0x1fb6, [0x0391, 0x0342, 0x0000]), (0x1fb7, [0x0391, 0x0342, 0x0399]),
+                    (0x1fbc, [0x0391, 0x0399, 0x0000]), (0x1fc2, [0x1fca, 0x0399, 0x0000]),
+                    (0x1fc3, [0x0397, 0x0399, 0x0000]), (0x1fc4, [0x0389, 0x0399, 0x0000]),
+                    (0x1fc6, [0x0397, 0x0342, 0x0000]), (0x1fc7, [0x0397, 0x0342, 0x0399]),
+                    (0x1fcc, [0x0397, 0x0399, 0x0000]), (0x1fd2, [0x0399, 0x0308, 0x0300]),
+                    (0x1fd3, [0x0399, 0x0308, 0x0301]), (0x1fd6, [0x0399, 0x0342, 0x0000]),
+                    (0x1fd7, [0x0399, 0x0308, 0x0342]), (0x1fe2, [0x03a5, 0x0308, 0x0300]),
+                    (0x1fe3, [0x03a5, 0x0308, 0x0301]), (0x1fe4, [0x03a1, 0x0313, 0x0000]),
+                    (0x1fe6, [0x03a5, 0x0342, 0x0000]), (0x1fe7, [0x03a5, 0x0308, 0x0342]),
+                    (0x1ff2, [0x1ffa, 0x0399, 0x0000]), (0x1ff3, [0x03a9, 0x0399, 0x0000]),
+                    (0x1ff4, [0x038f, 0x0399, 0x0000]), (0x1ff6, [0x03a9, 0x0342, 0x0000]),
+                    (0x1ff7, [0x03a9, 0x0342, 0x0399]), (0x1ffc, [0x03a9, 0x0399, 0x0000]),
+                    (0xfb00, [0x0046, 0x0046, 0x0000]), (0xfb01, [0x0046, 0x0049, 0x0000]),
+                    (0xfb02, [0x0046, 0x004c, 0x0000]), (0xfb03, [0x0046, 0x0046, 0x0049]),
+                    (0xfb04, [0x0046, 0x0046, 0x004c]), (0xfb05, [0x0053, 0x0054, 0x0000]),
+                    (0xfb06, [0x0053, 0x0054, 0x0000]), (0xfb13, [0x0544, 0x0546, 0x0000]),
+                    (0xfb14, [0x0544, 0x0535, 0x0000]), (0xfb15, [0x0544, 0x053b, 0x0000]),
+                    (0xfb16, [0x054e, 0x0546, 0x0000]), (0xfb17, [0x0544, 0x053d, 0x0000]),
+                ],
+            },
+            L2Lut {
+                singles: &[ // 12 entries, 72 bytes
+                    (Range::step_by_1(0x0428..=0x044f), -40), (Range::step_by_1(0x04d8..=0x04fb), -40),
+                    (Range::step_by_1(0x0597..=0x05a1), -39), (Range::step_by_1(0x05a3..=0x05b1), -39),
+                    (Range::step_by_1(0x05b3..=0x05b9), -39), (Range::step_by_1(0x05bb..=0x05bc), -39),
+                    (Range::step_by_1(0x0cc0..=0x0cf2), -64), (Range::step_by_1(0x0d70..=0x0d85), -32),
+                    (Range::step_by_1(0x18c0..=0x18df), -32), (Range::step_by_1(0x6e60..=0x6e7f), -32),
+                    (Range::step_by_1(0x6ebb..=0x6ed3), -27), (Range::step_by_1(0xe922..=0xe943), -34),
+                ],
+                multis: &[ // 0 entries, 0 bytes
+                ],
+            },
+        ],
+    };
 }
diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index f6c8b3353df0..6345cb8ef253 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -1,128 +1,390 @@
 //! Generates lookup tables (LUTs) for "case-mapping": mapping a `char` to its
 //! uppercase or lowercase equivalent(s).
 //!
-//! The first table, `LOWERCASE_TABLE` (respectively `UPPERCASE_TABLE`), is a
-//! sorted array of `(char, u32)` pairs. The case-mapping for a character is
-//! found by binary search.
+//! # Lookup algorithm
 //!
-//! If a character expands to multiple characters upon case-folding, the value
-//! in the LUT is actually an index into a second LUT, `LOWERCASE_TABLE_MULTI`
-//! (respectively `UPPERCASE_TABLE_MULTI`). This is signalled by the 22nd bit
-//! of the value being set; since all Unicode code points are less than
-//! 0x110000, this bit is free for us to use.
+//! The LUT is split into two levels:
+//!
+//! The 1st level LUT is simply an array of `L2Lut`s. The correct `L2Lut` is
+//! found by splitting the input `codepoint` into an `(input_high, input_low)`
+//! pair (Unicode plane and lower 16 bits, respectively), and using `input_high`
+//! as the index.
+//!
+//! The 2nd level LUT is further split into two separate tables:
+//! - `singles`, for characters that map to a single codepoint.
+//! - `multis`, for characters that map to 2 or 3 codepoints (eg `ß` -> `SS`).
+//!
+//! `singles` is a sorted slice of `(input_low, output_delta)` pairs. The correct
+//! pair is found by binary search. The final output codepoint is reconstructed
+//! with `input_high << 16 | (input_low + output_delta)`.
+//!
+//! `multis` is a sorted slice of `(input_low, [output_low1, output_low2,
+//! output_low3])` pairs. The correct pair is found by binary search. The final
+//! output codepoints are reconstructed with `input_high << 16 | output_low`.
+//!
+//! # Size optimizations
+//!
+//! Splitting the LUT into `L1Lut` and `L2Lut` means we do not need to store the
+//! upper 16 bits of every entry in the `L2Lut`, since every character stays
+//! within the same plane when case-mapped. This cuts the total size of the LUT
+//! in half.
+//!
+//! Storing the delta between the input codepoint and output codepoint in
+//! `singles` allows us to combine contiguous ranges which all map to codepoints
+//! the same distance away. For example, all of the accented letters in Latin-1
+//! that map to a single codepoint can be case-mapped by adding or subtracting
+//! 32.
+//!
+//! We also combine adjacent entries which only differ by 2, and indicate by
+//! setting the `parity` bit in the `Range` struct. An input codepoint belongs
+//! to the `Range` if `input_low & range.parity == range.start & range.parity`.
+//! This allows us to combine even more entries, without increasing the size of
+//! each entry.
 
-use std::char;
 use std::collections::BTreeMap;
-use std::fmt::Write;
+use std::fmt;
+use std::ops::RangeInclusive;
 
-use crate::fmt_helpers::CharEscape;
+use crate::fmt_helpers::Hex;
 use crate::{UnicodeData, fmt_list};
 
-const INDEX_MASK: u32 = 1 << 22;
-
-pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [usize; 2]) {
+pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [(String, usize); 2]) {
     let mut file = String::new();
 
-    write!(file, "const INDEX_MASK: u32 = 0x{INDEX_MASK:x};").unwrap();
     file.push_str("\n\n");
     file.push_str(HEADER.trim_start());
     file.push('\n');
-    let (lower_tables, lower_size) = generate_tables("LOWER", &data.to_lower);
+    let (lower_tables, lower_desc, lower_size) = generate_tables("LOWER", &data.to_lower);
     file.push_str(&lower_tables);
     file.push_str("\n\n");
-    let (upper_tables, upper_size) = generate_tables("UPPER", &data.to_upper);
+    let (upper_tables, upper_desc, upper_size) = generate_tables("UPPER", &data.to_upper);
     file.push_str(&upper_tables);
-    (file, [lower_size, upper_size])
+    (file, [(lower_desc, lower_size), (upper_desc, upper_size)])
 }
 
-fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize) {
-    let mut mappings = Vec::with_capacity(data.len());
-    let mut multis = Vec::new();
+// So far, only planes 0 and 1 (Basic Multilingual Plane and Supplementary
+// Multilingual Plane, respectively) have case mappings. If that changes, increment this.
+const NUM_PLANES: u16 = 2;
 
-    for (&key, &[a, b, c]) in data.iter() {
-        let key = char::from_u32(key).unwrap();
+/// Split a codepoint into its plane (upper 16 bits) and position within the plane (lower 16 bits).
+fn deconstruct(c: u32) -> (u16, u16) {
+    let high = (c >> 16) as u16;
+    assert!(high <= NUM_PLANES);
 
-        if key.is_ascii() {
-            continue;
-        }
+    let low = c as u16;
+    (high, low)
+}
 
-        let value = if b == 0 && c == 0 {
-            a
-        } else {
-            multis.push([
-                CharEscape(char::from_u32(a).unwrap()),
-                CharEscape(char::from_u32(b).unwrap()),
-                CharEscape(char::from_u32(c).unwrap()),
-            ]);
+#[derive(Debug, Clone)]
+struct L1Lut {
+    /// Keyed by bits 16..=31 of the code point. So far, only planes 0 and 1
+    /// have case mappings, so we don't need to bother storing the plane numbers.
+    l2_luts: [L2Lut; NUM_PLANES as usize],
+}
 
-            INDEX_MASK | (u32::try_from(multis.len()).unwrap() - 1)
-        };
+impl Default for L1Lut {
+    fn default() -> Self {
+        Self { l2_luts: [L2Lut::default(), L2Lut::default()] }
+    }
+}
 
-        mappings.push((CharEscape(key), value));
+impl L1Lut {
+    fn size(&self) -> usize {
+        self.l2_luts.iter().map(|l2| l2.size()).sum()
+    }
+}
+
+#[derive(Default, Clone)]
+struct L2Lut {
+    /// Keyed by bits 0..=15 of the code point, see `Range` struct for how
+    /// membership is tested.
+    singles: Vec<(Range, i16)>,
+
+    /// Keyed by bits 0..=15 of the code point, value is the lower 16-bits of the 2 or 3 code points that the char expands to.
+    multis: Vec<(Hex<u16>, [Hex<u16>; 3])>,
+}
+
+/// A compact encoding of a `Range<u16>` in only 4 bytes.
+/// If `parity` is false, the range represents code points `start..=start+len`,
+/// with step 1.
+/// If `parity` is true, the range represents code points `start..=start+len`,
+/// with step 2.
+/// Membership can be tested with `range.start() <= codepoint && codepoint <=
+/// range.end() && (codepoint & parity == start & parity)`.
+#[derive(Copy, Clone)]
+struct Range {
+    start: u16,
+    len: u8,
+    parity: bool,
+    // 7 bits left for any more flags we may want in the future.
+}
+
+impl Range {
+    const fn new(range: RangeInclusive<u16>, parity: bool) -> Self {
+        let start = *range.start();
+        let end = *range.end();
+        assert!(start <= end);
+
+        let len = end - start;
+        assert!(len <= 255);
+
+        Self { start, len: len as u8, parity }
     }
 
-    let mut tables = String::new();
-    let mut size = 0;
+    const fn singleton(start: u16) -> Self {
+        Self::new(start..=start, false)
+    }
 
-    size += size_of_val(mappings.as_slice());
-    write!(
-        tables,
-        "static {}CASE_TABLE: &[(char, u32); {}] = &[{}];",
-        case,
-        mappings.len(),
-        fmt_list(mappings),
-    )
-    .unwrap();
+    const fn start(&self) -> u16 {
+        self.start
+    }
 
-    tables.push_str("\n\n");
+    const fn end(&self) -> u16 {
+        self.start + self.len as u16
+    }
 
-    size += size_of_val(multis.as_slice());
-    write!(
-        tables,
-        "static {}CASE_TABLE_MULTI: &[[char; 3]; {}] = &[{}];",
-        case,
-        multis.len(),
-        fmt_list(multis),
-    )
-    .unwrap();
+    const fn len(&self) -> u16 {
+        self.len as u16 + 1
+    }
+}
 
-    (tables, size)
+impl fmt::Debug for Range {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.len() == 1 {
+            return write!(f, "Range::singleton({})", Hex(self.start));
+        }
+
+        let range = Hex(self.start)..=Hex(self.end());
+        match self.parity {
+            false => write!(f, "Range::step_by_1({range:?})"),
+            true => write!(f, "Range::step_by_2({range:?})"),
+        }
+    }
+}
+
+impl L2Lut {
+    fn size(&self) -> usize {
+        size_of_val(self.singles.as_slice()) + size_of_val(self.multis.as_slice())
+    }
+}
+
+impl fmt::Debug for L2Lut {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let singles = self.singles.as_slice();
+        let singles = fmt::from_fn(|f| {
+            write!(f, "&[ // {} entries, {} bytes", singles.len(), size_of_val(singles))?;
+            write!(f, "{}]", fmt_list(singles))
+        });
+
+        let multis = self.multis.as_slice();
+        let multis = fmt::from_fn(|f| {
+            write!(f, "&[ // {} entries, {} bytes", multis.len(), size_of_val(multis))?;
+            write!(f, "{}]", fmt_list(multis))
+        });
+
+        f.debug_struct("L2Lut").field("singles", &singles).field("multis", &multis).finish()
+    }
+}
+
+fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, String, usize) {
+    let mut l1_lut = L1Lut::default();
+
+    for (&input, &output) in data.iter() {
+        assert!(input > 0x7f);
+
+        let (input_high, input_low) = deconstruct(input);
+        let l2_lut = &mut l1_lut.l2_luts[input_high as usize];
+
+        match output {
+            [output, 0, 0] => {
+                let (output_high, output_low) = deconstruct(output);
+                assert_eq!(
+                    output_high, input_high,
+                    "Case-mapping a character should not change its plane"
+                );
+                let delta = output_low as i16 - input_low as i16;
+                let range = Range::singleton(input_low);
+                l2_lut.singles.push((range, delta));
+            }
+            _ => {
+                let output_lows = output.map(|output| {
+                    let (output_high, output_low) = deconstruct(output);
+                    assert_eq!(
+                        output_high, input_high,
+                        "Case-mapping a character should not change its plane"
+                    );
+                    Hex(output_low)
+                });
+                l2_lut.multis.push((Hex(input_low), output_lows));
+            }
+        }
+    }
+
+    // Combine adjacent contiguous ranges which apply the same delta.
+    // eg `(0x1234..=0x1234, +1), (0x1235..=0x1235, +1), (0x1236..=0x1236, +1)`
+    // becomes `(Range::step_by_1(0x1234..=0x1236), +1)`.
+    for l2_lut in &mut l1_lut.l2_luts {
+        l2_lut.singles = l2_lut
+            .singles
+            .chunk_by(|(left_range, left_delta), (right_range, right_delta)| {
+                left_delta == right_delta && right_range.end() - left_range.start() == 1
+            })
+            .map(|chunk| {
+                let &(first_range, _delta) = chunk.first().unwrap();
+                let &(last_range, delta) = chunk.last().unwrap();
+                (Range::new(first_range.start()..=last_range.end(), false), delta)
+            })
+            .collect();
+    }
+
+    // Combine adjacent ranges which differ by 2, since we can encode that with the parity bit in the Range struct.
+    // eg `(0x1234..=0x1234, +1), (0x1236..=0x1236, +1), (0x1238..=0x1238, +1)`
+    // becomes `(Range::step_by_2(0x1234..=0x1238), +1)`.
+    for l2_lut in &mut l1_lut.l2_luts {
+        l2_lut.singles = l2_lut
+            .singles
+            .chunk_by(|(left_range, left_delta), (right_range, right_delta)| {
+                left_delta == right_delta
+                    && left_range.len() == 1
+                    && right_range.len() == 1
+                    && right_range.end() - left_range.start() == 2
+            })
+            .map(|chunk| {
+                let &(first_range, _delta) = chunk.first().unwrap();
+                let &(last_range, delta) = chunk.last().unwrap();
+                let parity = chunk.len() > 1;
+                (Range::new(first_range.start()..=last_range.end(), parity), delta)
+            })
+            .collect();
+    }
+
+    let size = l1_lut.size();
+    let num_ranges =
+        l1_lut.l2_luts.iter().map(|l2| l2.singles.len() + l2.multis.len()).sum::<usize>();
+    let table = format!("static {case}CASE_LUT: L1Lut = {l1_lut:#?};");
+    let desc = format!(
+        "{:6} codepoints in {:3} ranges (U+{:06X} - U+{:06X}) using 2-level LUT",
+        data.len(),
+        num_ranges,
+        data.first_key_value().map(|(&k, _)| k).unwrap(),
+        data.last_key_value().map(|(&k, _)| k).unwrap(),
+    );
+    (table, desc, size)
 }
 
 static HEADER: &str = r"
-pub fn to_lower(c: char) -> [char; 3] {
-    if c.is_ascii() {
-        [(c as u8).to_ascii_lowercase() as char, '\0', '\0']
-    } else {
-        LOWERCASE_TABLE
-            .binary_search_by(|&(key, _)| key.cmp(&c))
-            .map(|i| {
-                // SAFETY: i is the result of the binary search
-                let u = unsafe { LOWERCASE_TABLE.get_unchecked(i) }.1;
-                char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                    // SAFETY: Index comes from statically generated table
-                    unsafe { *LOWERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                })
-            })
-            .unwrap_or([c, '\0', '\0'])
+use crate::ops::RangeInclusive;
+
+struct L1Lut {
+    l2_luts: [L2Lut; 2],
+}
+
+struct L2Lut {
+    singles: &'static [(Range, i16)],
+    multis: &'static [(u16, [u16; 3])],
+}
+
+#[derive(Copy, Clone)]
+struct Range {
+    start: u16,
+    len: u8,
+    parity: bool,
+}
+
+impl Range {
+    const fn new(range: RangeInclusive<u16>, parity: bool) -> Self {
+        let start = *range.start();
+        let end = *range.end();
+        assert!(start <= end);
+
+        let len = end - start;
+        assert!(len <= 255);
+
+        Self { start, len: len as u8, parity }
+    }
+
+    const fn singleton(start: u16) -> Self {
+        Self::new(start..=start, false)
+    }
+
+    const fn step_by_1(range: RangeInclusive<u16>) -> Self {
+        Self::new(range, false)
+    }
+
+    const fn step_by_2(range: RangeInclusive<u16>) -> Self {
+        Self::new(range, true)
+    }
+
+    const fn start(&self) -> u16 {
+        self.start
+    }
+
+    const fn end(&self) -> u16 {
+        self.start + self.len as u16
     }
 }
 
-pub fn to_upper(c: char) -> [char; 3] {
-    if c.is_ascii() {
-        [(c as u8).to_ascii_uppercase() as char, '\0', '\0']
-    } else {
-        UPPERCASE_TABLE
-            .binary_search_by(|&(key, _)| key.cmp(&c))
-            .map(|i| {
-                // SAFETY: i is the result of the binary search
-                let u = unsafe { UPPERCASE_TABLE.get_unchecked(i) }.1;
-                char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                    // SAFETY: Index comes from statically generated table
-                    unsafe { *UPPERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                })
-            })
-            .unwrap_or([c, '\0', '\0'])
+fn deconstruct(c: char) -> (u16, u16) {
+    let c = c as u32;
+    let plane = (c >> 16) as u16;
+    let low = c as u16;
+    (plane, low)
+}
+
+unsafe fn reconstruct(plane: u16, low: u16) -> char {
+    // SAFETY: The caller must ensure that the result is a valid `char`.
+    unsafe { char::from_u32_unchecked(((plane as u32) << 16) | (low as u32)) }
+}
+
+fn lookup(input: char, ascii: char, l1_lut: &L1Lut) -> [char; 3] {
+    if input.is_ascii() {
+        return [ascii, '\0', '\0'];
     }
+
+    let (input_high, input_low) = deconstruct(input);
+    let Some(l2_lut) = l1_lut.l2_luts.get(input_high as usize) else {
+        return [input, '\0', '\0'];
+    };
+
+    let idx = l2_lut.singles.binary_search_by(|(range, _)| {
+        use crate::cmp::Ordering;
+
+        if input_low < range.start() {
+            Ordering::Greater
+        } else if input_low > range.end() {
+            Ordering::Less
+        } else {
+            Ordering::Equal
+        }
+    });
+    if let Ok(idx) = idx {
+        // SAFETY: binary search guarantees that the index is in bounds.
+        let &(range, output_delta) = unsafe { l2_lut.singles.get_unchecked(idx) };
+        let mask = range.parity as u16;
+        if input_low & mask == range.start() & mask {
+            let output_low = input_low.wrapping_add_signed(output_delta);
+            // SAFETY: Table data are guaranteed to be valid Unicode.
+            let output = unsafe { reconstruct(input_high, output_low) };
+            return [output, '\0', '\0'];
+        }
+    };
+
+    if let Ok(idx) = l2_lut.multis.binary_search_by_key(&input_low, |&(p, _)| p) {
+        // SAFETY: binary search guarantees that the index is in bounds.
+        let &(_, output_lows) = unsafe { l2_lut.multis.get_unchecked(idx) };
+        // SAFETY: Table data are guaranteed to be valid Unicode.
+        let output = output_lows.map(|output_low| unsafe { reconstruct(input_high, output_low) });
+        return output;
+    };
+
+    [input, '\0', '\0']
+}
+
+pub fn to_lower(c: char) -> [char; 3] {
+    lookup(c, c.to_ascii_lowercase(), &LOWERCASE_LUT)
+}
+
+pub fn to_upper(c: char) -> [char; 3] {
+    lookup(c, c.to_ascii_uppercase(), &UPPERCASE_LUT)
 }
 ";
diff --git a/src/tools/unicode-table-generator/src/fmt_helpers.rs b/src/tools/unicode-table-generator/src/fmt_helpers.rs
index 97100a45d463..1ec12bc50436 100644
--- a/src/tools/unicode-table-generator/src/fmt_helpers.rs
+++ b/src/tools/unicode-table-generator/src/fmt_helpers.rs
@@ -1,5 +1,22 @@
 use std::fmt;
 
+/// Wrapper type for formatting a `T` using its `LowerHex` implementation.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Hex<T>(pub T);
+
+impl<T: fmt::LowerHex> fmt::Debug for Hex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let nibbles = 2 * std::mem::size_of::<T>();
+        write!(f, "0x{:0width$x}", self.0, width = nibbles)
+    }
+}
+
+impl<T: fmt::LowerHex> fmt::Display for Hex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
 /// Wrapper type for formatting a `char` using `escape_default`.
 #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct CharEscape(pub char);
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index c0456fcd1ec9..4e7c40efc123 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -259,8 +259,8 @@ fn main() {
         total_bytes += emitter.bytes_used;
     }
     let (conversions, sizes) = case_mapping::generate_case_mapping(&unicode_data);
-    for (name, size) in ["to_lower", "to_upper"].iter().zip(sizes) {
-        table_file.push_str(&format!("// {:16}: {:5} bytes\n", name, size));
+    for (name, (desc, size)) in ["to_lower", "to_upper"].iter().zip(sizes) {
+        table_file.push_str(&format!("// {:16}: {:5} bytes, {desc}\n", name, size,));
         total_bytes += size;
     }
     table_file.push_str(&format!("// {:16}: {:5} bytes\n", "Total", total_bytes));

From e41bf75d1e3f6f2234da78fac4e0d39d85dff544 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 6 Mar 2026 17:25:52 +1100
Subject: [PATCH 0216/1059] Move `ActiveJobGuard` definition next to its impls.

---
 compiler/rustc_query_impl/src/execution.rs | 28 +++++++++++-----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 11749f3fb82d..ba27cd5dd030 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -104,20 +104,6 @@ pub(crate) fn gather_active_jobs<'tcx, C>(
     Some(())
 }
 
-/// Guard object representing the responsibility to execute a query job and
-/// mark it as completed.
-///
-/// This will poison the relevant query key if it is dropped without calling
-/// [`Self::complete`].
-struct ActiveJobGuard<'tcx, K>
-where
-    K: Eq + Hash + Copy,
-{
-    state: &'tcx QueryState<'tcx, K>,
-    key: K,
-    key_hash: u64,
-}
-
 #[cold]
 #[inline(never)]
 fn mk_cycle<'tcx, C: QueryCache>(
@@ -148,6 +134,20 @@ fn mk_cycle<'tcx, C: QueryCache>(
     }
 }
 
+/// Guard object representing the responsibility to execute a query job and
+/// mark it as completed.
+///
+/// This will poison the relevant query key if it is dropped without calling
+/// [`Self::complete`].
+struct ActiveJobGuard<'tcx, K>
+where
+    K: Eq + Hash + Copy,
+{
+    state: &'tcx QueryState<'tcx, K>,
+    key: K,
+    key_hash: u64,
+}
+
 impl<'tcx, K> ActiveJobGuard<'tcx, K>
 where
     K: Eq + Hash + Copy,

From 18ade8478e90d85e9386dfcec84dd878b1b66aad Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 6 Mar 2026 17:02:31 +1100
Subject: [PATCH 0217/1059] Streamline `ActiveJobGuard` completion.

`ActiveJobGuard::complete` and `ActiveJobGuard::drop` have very similar
code, though non-essential structural differences obscure this a little.

This commit factors out the common code into a new method
`ActiveJobGuard::complete_inner`. It also inlines and remove
`expect_job`, which ends up having a single call site.
---
 compiler/rustc_query_impl/src/execution.rs | 77 +++++++++-------------
 1 file changed, 32 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index ba27cd5dd030..57d503ef7b07 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -1,5 +1,5 @@
 use std::hash::Hash;
-use std::mem;
+use std::mem::ManuallyDrop;
 
 use rustc_data_structures::hash_table::{Entry, HashTable};
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -26,17 +26,6 @@ fn equivalent_key<K: Eq, V>(k: K) -> impl Fn(&(K, V)) -> bool {
     move |x| x.0 == k
 }
 
-/// Obtains the enclosed [`QueryJob`], or panics if this query evaluation
-/// was poisoned by a panic.
-fn expect_job<'tcx>(status: ActiveKeyStatus<'tcx>) -> QueryJob<'tcx> {
-    match status {
-        ActiveKeyStatus::Started(job) => job,
-        ActiveKeyStatus::Poisoned => {
-            panic!("job for query failed to start and was poisoned")
-        }
-    }
-}
-
 pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
     state.active.lock_shards().all(|shard| shard.is_empty())
 }
@@ -154,33 +143,45 @@ impl<'tcx, K> ActiveJobGuard<'tcx, K>
 {
     /// Completes the query by updating the query cache with the `result`,
     /// signals the waiter, and forgets the guard so it won't poison the query.
-    fn complete<C>(self, cache: &C, result: C::Value, dep_node_index: DepNodeIndex)
+    fn complete<C>(self, cache: &C, value: C::Value, dep_node_index: DepNodeIndex)
     where
         C: QueryCache<Key = K>,
     {
-        // Forget ourself so our destructor won't poison the query.
-        // (Extract fields by value first to make sure we don't leak anything.)
-        let Self { state, key, key_hash }: Self = self;
-        mem::forget(self);
-
         // Mark as complete before we remove the job from the active state
         // so no other thread can re-execute this query.
-        cache.complete(key, result, dep_node_index);
+        cache.complete(self.key, value, dep_node_index);
 
-        let job = {
-            // don't keep the lock during the `unwrap()` of the retrieved value, or we taint the
-            // underlying shard.
-            // since unwinding also wants to look at this map, this can also prevent a double
-            // panic.
-            let mut shard = state.active.lock_shard_by_hash(key_hash);
-            match shard.find_entry(key_hash, equivalent_key(key)) {
-                Err(_) => None,
-                Ok(occupied) => Some(occupied.remove().0.1),
+        let mut this = ManuallyDrop::new(self);
+
+        // Drop everything without poisoning the query.
+        this.drop_and_maybe_poison(/* poison */ false);
+    }
+
+    fn drop_and_maybe_poison(&mut self, poison: bool) {
+        let status = {
+            let mut shard = self.state.active.lock_shard_by_hash(self.key_hash);
+            match shard.find_entry(self.key_hash, equivalent_key(self.key)) {
+                Err(_) => {
+                    // Note: we must not panic while holding the lock, because unwinding also looks
+                    // at this map, which can result in a double panic. So drop it first.
+                    drop(shard);
+                    panic!();
+                }
+                Ok(occupied) => {
+                    let ((key, status), vacant) = occupied.remove();
+                    if poison {
+                        vacant.insert((key, ActiveKeyStatus::Poisoned));
+                    }
+                    status
+                }
             }
         };
-        let job = expect_job(job.expect("active query job entry"));
 
-        job.signal_complete();
+        // Also signal the completion of the job, so waiters will continue execution.
+        match status {
+            ActiveKeyStatus::Started(job) => job.signal_complete(),
+            ActiveKeyStatus::Poisoned => panic!(),
+        }
     }
 }
 
@@ -192,21 +193,7 @@ impl<'tcx, K> Drop for ActiveJobGuard<'tcx, K>
     #[cold]
     fn drop(&mut self) {
         // Poison the query so jobs waiting on it panic.
-        let Self { state, key, key_hash } = *self;
-        let job = {
-            let mut shard = state.active.lock_shard_by_hash(key_hash);
-            match shard.find_entry(key_hash, equivalent_key(key)) {
-                Err(_) => panic!(),
-                Ok(occupied) => {
-                    let ((key, value), vacant) = occupied.remove();
-                    vacant.insert((key, ActiveKeyStatus::Poisoned));
-                    expect_job(value)
-                }
-            }
-        };
-        // Also signal the completion of the job, so waiters
-        // will continue execution.
-        job.signal_complete();
+        self.drop_and_maybe_poison(/* poison */ true);
     }
 }
 

From a5fa3995d6421c43e8b9a2ada45cc7301f9d495c Mon Sep 17 00:00:00 2001
From: Taym Haddadi <haddadi.taym@gmail.com>
Date: Mon, 9 Mar 2026 02:08:04 +0100
Subject: [PATCH 0218/1059] Fix semicolon-inside-block inside try_blocks

Signed-off-by: Taym Haddadi <haddadi.taym@gmail.com>
---
 clippy_lints/src/semicolon_block.rs    | 2 +-
 tests/ui/semicolon_inside_block.fixed  | 9 +++++++++
 tests/ui/semicolon_inside_block.rs     | 9 +++++++++
 tests/ui/semicolon_inside_block.stderr | 8 ++++----
 4 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 7c68762b22c0..e806123596b8 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -170,7 +170,7 @@ fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block, _),
                 ..
-            }) if !block.span.from_expansion() => {
+            }) if !block.span.from_expansion() && !block.targeted_by_break => {
                 let attrs = cx.tcx.hir_attrs(stmt.hir_id);
                 if !attrs.is_empty() && !cx.tcx.features().stmt_expr_attributes() {
                     return;
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 468f0a5b1e47..c7174881a4fa 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -7,6 +7,7 @@
     clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
+#![feature(try_blocks)]
 
 macro_rules! m {
     (()) => {
@@ -106,3 +107,11 @@ pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
 }
+
+fn issue_try_blocks() {
+    // try blocks should NOT trigger semicolon_inside_block:
+    // moving `;` inside changes the return type (e.g. `Option<i32>` -> `Option<()>`)
+    // which in turn changes the type constraints on `?` operators inside the block,
+    // causing type errors.
+    try { Some(1)? };
+}
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 101374af2647..25be9bee4f53 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -7,6 +7,7 @@
     clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
+#![feature(try_blocks)]
 
 macro_rules! m {
     (()) => {
@@ -106,3 +107,11 @@ pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
 }
+
+fn issue_try_blocks() {
+    // try blocks should NOT trigger semicolon_inside_block:
+    // moving `;` inside changes the return type (e.g. `Option<i32>` -> `Option<()>`)
+    // which in turn changes the type constraints on `?` operators inside the block,
+    // causing type errors.
+    try { Some(1)? };
+}
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
index 2046dd1c36be..e16590374295 100644
--- a/tests/ui/semicolon_inside_block.stderr
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -1,5 +1,5 @@
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:39:5
+  --> tests/ui/semicolon_inside_block.rs:40:5
    |
 LL |     { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:41:5
+  --> tests/ui/semicolon_inside_block.rs:42:5
    |
 LL |     unsafe { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     unsafe { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:50:5
+  --> tests/ui/semicolon_inside_block.rs:51:5
    |
 LL | /     {
 LL | |
@@ -41,7 +41,7 @@ LL ~     }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:64:5
+  --> tests/ui/semicolon_inside_block.rs:65:5
    |
 LL |     { m!(()) };
    |     ^^^^^^^^^^^

From c15947596f521dcf3f3d90515fee2dd2e8435587 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Mon, 9 Mar 2026 10:11:42 +0900
Subject: [PATCH 0219/1059] Fix typo in feature gate check

---
 src/doc/rustc-dev-guide/src/feature-gate-check.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/feature-gate-check.md b/src/doc/rustc-dev-guide/src/feature-gate-check.md
index 59e50837c52e..038a14ac070e 100644
--- a/src/doc/rustc-dev-guide/src/feature-gate-check.md
+++ b/src/doc/rustc-dev-guide/src/feature-gate-check.md
@@ -8,7 +8,7 @@ nightly-only `#![feature(...)]` opt-in.
 This chapter documents the implementation
 of feature gating: where gates are defined, how they are enabled, and how usage is verified.
 
-<!-- data-check: Feb 2026 -->
+<!-- date-check: Feb 2026 -->
 
 ## Feature Definitions
 

From 091f319bcd2d6ce40fbb4ee28e7ffe88d639c061 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 9 Mar 2026 04:43:44 +0000
Subject: [PATCH 0220/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to eda4fc7733ee89e484d7120cafbd80dcb2fce66e.
---
 src/tools/rust-analyzer/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index 7c89bcb9ab04..db9492636f6a 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-f8704be04fe1150527fc2cf21dd44327f0fe87fb
+eda4fc7733ee89e484d7120cafbd80dcb2fce66e

From 91c3763234b547a20fa868330030f905da894a02 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 9 Mar 2026 04:46:28 +0000
Subject: [PATCH 0221/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to eda4fc7733ee89e484d7120cafbd80dcb2fce66e.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 4dedd81b0066..db9492636f6a 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-e7d90c695a39426baf5ae705de2f9570a72229de
+eda4fc7733ee89e484d7120cafbd80dcb2fce66e

From 0adea80424ab3af069c9e196da0ae75ae0147f99 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 9 Mar 2026 11:43:54 +0800
Subject: [PATCH 0222/1059] Fix other predicate for
 replace_is_method_with_if_let_method

- Fix parentheses for replace_is_method_with_if_let_method

Example
---
```rust
fn main() {
    let x = Some(1);
    if x.is_som$0e_and(predicate) {}
}
```

**Before this PR**

```rust
fn main() {
    let x = Some(1);
    if let Some(x1) = x {}
}
```

**After this PR**

```rust
fn main() {
    let x = Some(1);
    if let Some(x1) = x && predicate(x1) {}
}
```
---
 .../replace_is_method_with_if_let_method.rs   | 90 +++++++++++++++----
 .../src/handlers/replace_method_eager_lazy.rs | 16 +---
 .../crates/ide-assists/src/utils.rs           | 15 ++++
 3 files changed, 92 insertions(+), 29 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
index d22e951b5dab..38d8c38ef23d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
@@ -1,8 +1,11 @@
 use either::Either;
 use ide_db::syntax_helpers::suggest_name;
-use syntax::ast::{self, AstNode, HasArgList, syntax_factory::SyntaxFactory};
+use syntax::ast::{self, AstNode, HasArgList, prec::ExprPrecedence, syntax_factory::SyntaxFactory};
 
-use crate::{AssistContext, AssistId, Assists, utils::cover_let_chain};
+use crate::{
+    AssistContext, AssistId, Assists,
+    utils::{cover_let_chain, wrap_paren, wrap_paren_in_call},
+};
 
 // Assist: replace_is_some_with_if_let_some
 //
@@ -39,6 +42,7 @@ pub(crate) fn replace_is_method_with_if_let_method(
     match method_kind {
         "is_some" | "is_ok" => {
             let receiver = call_expr.receiver()?;
+            let make = SyntaxFactory::with_mappings();
 
             let mut name_generator = suggest_name::NameGenerator::new_from_scope_locals(
                 ctx.sema.scope(has_cond.syntax()),
@@ -48,7 +52,7 @@ pub(crate) fn replace_is_method_with_if_let_method(
             } else {
                 name_generator.for_variable(&receiver, &ctx.sema)
             };
-            let (pat, predicate) = method_predicate(&call_expr).unzip();
+            let (pat, predicate) = method_predicate(&call_expr, &var_name, &make);
 
             let (assist_id, message, text) = if method_kind == "is_some" {
                 ("replace_is_some_with_if_let_some", "Replace `is_some` with `let Some`", "Some")
@@ -61,13 +65,9 @@ pub(crate) fn replace_is_method_with_if_let_method(
                 message,
                 call_expr.syntax().text_range(),
                 |edit| {
-                    let make = SyntaxFactory::with_mappings();
                     let mut editor = edit.make_editor(call_expr.syntax());
 
-                    let var_pat = pat.unwrap_or_else(|| {
-                        make.ident_pat(false, false, make.name(&var_name)).into()
-                    });
-                    let pat = make.tuple_struct_pat(make.ident_path(text), [var_pat]).into();
+                    let pat = make.tuple_struct_pat(make.ident_path(text), [pat]).into();
                     let let_expr = make.expr_let(pat, receiver);
 
                     if let Some(cap) = ctx.config.snippet_cap
@@ -81,6 +81,7 @@ pub(crate) fn replace_is_method_with_if_let_method(
 
                     let new_expr = if let Some(predicate) = predicate {
                         let op = ast::BinaryOp::LogicOp(ast::LogicOp::And);
+                        let predicate = wrap_paren(predicate, &make, ExprPrecedence::LAnd);
                         make.expr_bin(let_expr.into(), op, predicate).into()
                     } else {
                         ast::Expr::from(let_expr)
@@ -96,14 +97,23 @@ pub(crate) fn replace_is_method_with_if_let_method(
     }
 }
 
-fn method_predicate(call_expr: &ast::MethodCallExpr) -> Option<(ast::Pat, ast::Expr)> {
-    let argument = call_expr.arg_list()?.args().next()?;
-    match argument {
-        ast::Expr::ClosureExpr(it) => {
-            let pat = it.param_list()?.params().next()?.pat()?;
-            Some((pat, it.body()?))
-        }
-        _ => None,
+fn method_predicate(
+    call_expr: &ast::MethodCallExpr,
+    name: &str,
+    make: &SyntaxFactory,
+) -> (ast::Pat, Option<ast::Expr>) {
+    let argument = call_expr.arg_list().and_then(|it| it.args().next());
+    if let Some(ast::Expr::ClosureExpr(it)) = argument.clone()
+        && let Some(pat) = it.param_list().and_then(|it| it.params().next()?.pat())
+    {
+        (pat, it.body())
+    } else {
+        let pat = make.ident_pat(false, false, make.name(name));
+        let expr = argument.map(|expr| {
+            let arg_list = make.arg_list([make.expr_path(make.ident_path(name))]);
+            make.expr_call(wrap_paren_in_call(expr, make), arg_list).into()
+        });
+        (pat.into(), expr)
     }
 }
 
@@ -232,6 +242,54 @@ fn main() {
     let x = Some(1);
     if let Some(it) = x && it != 3 {}
 }
+"#,
+        );
+
+        check_assist(
+            replace_is_method_with_if_let_method,
+            r#"
+fn main() {
+    let x = Some(1);
+    if x.is_som$0e_and(|it| it != 3 || it > 10) {}
+}
+"#,
+            r#"
+fn main() {
+    let x = Some(1);
+    if let Some(it) = x && (it != 3 || it > 10) {}
+}
+"#,
+        );
+
+        check_assist(
+            replace_is_method_with_if_let_method,
+            r#"
+fn main() {
+    let x = Some(1);
+    if x.is_som$0e_and(predicate) {}
+}
+"#,
+            r#"
+fn main() {
+    let x = Some(1);
+    if let Some(x1) = x && predicate(x1) {}
+}
+"#,
+        );
+
+        check_assist(
+            replace_is_method_with_if_let_method,
+            r#"
+fn main() {
+    let x = Some(1);
+    if x.is_som$0e_and(func.f) {}
+}
+"#,
+            r#"
+fn main() {
+    let x = Some(1);
+    if let Some(x1) = x && (func.f)(x1) {}
+}
 "#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_method_eager_lazy.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_method_eager_lazy.rs
index 6ca3e26ca018..6e4dd8cb73a6 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_method_eager_lazy.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_method_eager_lazy.rs
@@ -2,10 +2,10 @@
 use ide_db::{RootDatabase, assists::AssistId, defs::Definition};
 use syntax::{
     AstNode,
-    ast::{self, Expr, HasArgList, make},
+    ast::{self, Expr, HasArgList, make, syntax_factory::SyntaxFactory},
 };
 
-use crate::{AssistContext, Assists};
+use crate::{AssistContext, Assists, utils::wrap_paren_in_call};
 
 // Assist: replace_with_lazy_method
 //
@@ -177,11 +177,7 @@ fn into_call(param: &Expr, sema: &Semantics<'_, RootDatabase>) -> Expr {
         }
     })()
     .unwrap_or_else(|| {
-        let callable = if needs_parens_in_call(param) {
-            make::expr_paren(param.clone()).into()
-        } else {
-            param.clone()
-        };
+        let callable = wrap_paren_in_call(param.clone(), &SyntaxFactory::without_mappings());
         make::expr_call(callable, make::arg_list(Vec::new())).into()
     })
 }
@@ -200,12 +196,6 @@ fn ends_is(name: &str, end: &str) -> bool {
     name.strip_suffix(end).is_some_and(|s| s.is_empty() || s.ends_with('_'))
 }
 
-fn needs_parens_in_call(param: &Expr) -> bool {
-    let call = make::expr_call(make::ext::expr_unit(), make::arg_list(Vec::new()));
-    let callable = call.expr().expect("invalid make call");
-    param.needs_parens_in_place_of(call.syntax(), callable.syntax())
-}
-
 #[cfg(test)]
 mod tests {
     use crate::tests::check_assist;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index b4055e77ccf8..1c1c98cb7a39 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -25,6 +25,7 @@
         edit::{AstNodeEdit, IndentLevel},
         edit_in_place::AttrsOwnerEdit,
         make,
+        prec::ExprPrecedence,
         syntax_factory::SyntaxFactory,
     },
     syntax_editor::{Element, Removable, SyntaxEditor},
@@ -97,6 +98,20 @@ pub(crate) fn wrap_block(expr: &ast::Expr) -> ast::BlockExpr {
     }
 }
 
+pub(crate) fn wrap_paren(expr: ast::Expr, make: &SyntaxFactory, prec: ExprPrecedence) -> ast::Expr {
+    if expr.precedence().needs_parentheses_in(prec) { make.expr_paren(expr).into() } else { expr }
+}
+
+pub(crate) fn wrap_paren_in_call(expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {
+    if needs_parens_in_call(&expr) { make.expr_paren(expr).into() } else { expr }
+}
+
+fn needs_parens_in_call(param: &ast::Expr) -> bool {
+    let call = make::expr_call(make::ext::expr_unit(), make::arg_list(Vec::new()));
+    let callable = call.expr().expect("invalid make call");
+    param.needs_parens_in_place_of(call.syntax(), callable.syntax())
+}
+
 /// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
 /// `#[test_case(...)]`, `#[tokio::test]` and similar.
 /// Also a regular `#[test]` annotation is supported.

From 9983a569ca7c2f445b88f3189ace677b22e8563e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 9 Mar 2026 16:38:57 +1100
Subject: [PATCH 0223/1059] Inline and remove `QueryLatch::wait_on_inner`.

It has a single call site.
---
 compiler/rustc_middle/src/query/job.rs | 46 +++++++++++++-------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index f1a2b3a34d0e..afa1d9a5ec20 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -104,7 +104,29 @@ pub fn wait_on(
     ) -> Result<(), CycleError<QueryStackDeferred<'tcx>>> {
         let waiter =
             Arc::new(QueryWaiter { query, span, cycle: Mutex::new(None), condvar: Condvar::new() });
-        self.wait_on_inner(tcx, &waiter);
+
+        // Awaits the caller on this latch by blocking the current thread.
+        {
+            let mut info = self.info.lock();
+            if !info.complete {
+                // We push the waiter on to the `waiters` list. It can be accessed inside
+                // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
+                // Both of these will remove it from the `waiters` list before resuming
+                // this thread.
+                info.waiters.push(Arc::clone(&waiter));
+
+                // If this detects a deadlock and the deadlock handler wants to resume this thread
+                // we have to be in the `wait` call. This is ensured by the deadlock handler
+                // getting the self.info lock.
+                rustc_thread_pool::mark_blocked();
+                tcx.jobserver_proxy.release_thread();
+                waiter.condvar.wait(&mut info);
+                // Release the lock before we potentially block in `acquire_thread`
+                drop(info);
+                tcx.jobserver_proxy.acquire_thread();
+            }
+        }
+
         // FIXME: Get rid of this lock. We have ownership of the QueryWaiter
         // although another thread may still have a Arc reference so we cannot
         // use Arc::get_mut
@@ -115,28 +137,6 @@ pub fn wait_on(
         }
     }
 
-    /// Awaits the caller on this latch by blocking the current thread.
-    fn wait_on_inner(&self, tcx: TyCtxt<'tcx>, waiter: &Arc<QueryWaiter<'tcx>>) {
-        let mut info = self.info.lock();
-        if !info.complete {
-            // We push the waiter on to the `waiters` list. It can be accessed inside
-            // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
-            // Both of these will remove it from the `waiters` list before resuming
-            // this thread.
-            info.waiters.push(Arc::clone(waiter));
-
-            // If this detects a deadlock and the deadlock handler wants to resume this thread
-            // we have to be in the `wait` call. This is ensured by the deadlock handler
-            // getting the self.info lock.
-            rustc_thread_pool::mark_blocked();
-            tcx.jobserver_proxy.release_thread();
-            waiter.condvar.wait(&mut info);
-            // Release the lock before we potentially block in `acquire_thread`
-            drop(info);
-            tcx.jobserver_proxy.acquire_thread();
-        }
-    }
-
     /// Sets the latch and resumes all waiters on it
     fn set(&self) {
         let mut info = self.info.lock();

From c6c4c89d1c5a2dfe6a4fb3d5d0efcbc402a366c3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 8 Mar 2026 15:46:35 +0100
Subject: [PATCH 0224/1059] native calls: more gracefully handle function
 pointers with unsupported types

---
 src/tools/miri/src/shims/native_lib/mod.rs    | 73 ++++++++++++-------
 .../fail/call_fn_ptr_with_generic.rs          |  9 +++
 ...all_fn_ptr_with_unsupported.notrace.stderr | 31 ++++++++
 .../fail/call_fn_ptr_with_unsupported.rs      | 32 ++++++++
 .../call_fn_ptr_with_unsupported.trace.stderr | 32 ++++++++
 .../native-lib/fail/struct_not_extern_c.rs    |  2 +-
 .../fail/struct_not_extern_c.stderr           |  2 +-
 7 files changed, 152 insertions(+), 29 deletions(-)
 create mode 100644 src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.notrace.stderr
 create mode 100644 src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.trace.stderr

diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 8a761855c432..6a281ddbb7b2 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -245,7 +245,9 @@ fn op_to_ffi_arg(&self, v: &OpTy<'tcx>, tracing: bool) -> InterpResult<'tcx, Own
 
         // This should go first so that we emit unsupported before doing a bunch
         // of extra work for types that aren't supported yet.
-        let ty = this.ty_to_ffitype(v.layout)?;
+        let ty = this
+            .ty_to_ffitype(v.layout)
+            .map_err(|ty| err_unsup_format!("unsupported argument type for native call: {ty}"))?;
 
         // Helper to print a warning when a pointer is shared with the native code.
         let expose = |prov: Provenance| -> InterpResult<'tcx> {
@@ -363,31 +365,31 @@ fn ffi_ret_to_mem(&mut self, v: Box<[u8]>, dest: &MPlaceTy<'tcx>) -> InterpResul
     /// Parses an ADT to construct the matching libffi type.
     fn adt_to_ffitype(
         &self,
-        orig_ty: Ty<'_>,
+        orig_ty: Ty<'tcx>,
         adt_def: ty::AdtDef<'tcx>,
         args: &'tcx ty::List<ty::GenericArg<'tcx>>,
-    ) -> InterpResult<'tcx, FfiType> {
+    ) -> Result<FfiType, Ty<'tcx>> {
         let this = self.eval_context_ref();
         // TODO: unions, etc.
         if !adt_def.is_struct() {
-            throw_unsup_format!("passing an enum or union over FFI: {orig_ty}");
+            return Err(orig_ty);
         }
         // TODO: Certain non-C reprs should be okay also.
         if !adt_def.repr().c() {
-            throw_unsup_format!("passing a non-#[repr(C)] {} over FFI: {orig_ty}", adt_def.descr())
+            return Err(orig_ty);
         }
 
         let mut fields = vec![];
         for field in &adt_def.non_enum_variant().fields {
-            let layout = this.layout_of(field.ty(*this.tcx, args))?;
+            let layout = this.layout_of(field.ty(*this.tcx, args)).map_err(|_err| orig_ty)?;
             fields.push(this.ty_to_ffitype(layout)?);
         }
 
-        interp_ok(FfiType::structure(fields))
+        Ok(FfiType::structure(fields))
     }
 
     /// Gets the matching libffi type for a given Ty.
-    fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> InterpResult<'tcx, FfiType> {
+    fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> Result<FfiType, Ty<'tcx>> {
         use rustc_abi::{AddressSpace, BackendRepr, Float, Integer, Primitive};
 
         // `BackendRepr::Scalar` is also a signal to pass this type as a scalar in the ABI. This
@@ -396,7 +398,7 @@ fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> InterpResult<'tcx, FfiType
         if let BackendRepr::Scalar(s) = layout.backend_repr {
             // Simple sanity-check: this cannot be `repr(C)`.
             assert!(!layout.ty.ty_adt_def().is_some_and(|adt| adt.repr().c()));
-            return interp_ok(match s.primitive() {
+            return Ok(match s.primitive() {
                 Primitive::Int(Integer::I8, /* signed */ true) => FfiType::i8(),
                 Primitive::Int(Integer::I16, /* signed */ true) => FfiType::i16(),
                 Primitive::Int(Integer::I32, /* signed */ true) => FfiType::i32(),
@@ -408,17 +410,15 @@ fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> InterpResult<'tcx, FfiType
                 Primitive::Float(Float::F32) => FfiType::f32(),
                 Primitive::Float(Float::F64) => FfiType::f64(),
                 Primitive::Pointer(AddressSpace::ZERO) => FfiType::pointer(),
-                _ => throw_unsup_format!("unsupported scalar type for native call: {}", layout.ty),
+                _ => return Err(layout.ty),
             });
         }
-        interp_ok(match layout.ty.kind() {
+        Ok(match layout.ty.kind() {
             // Scalar types have already been handled above.
             ty::Adt(adt_def, args) => self.adt_to_ffitype(layout.ty, *adt_def, args)?,
             // Rust uses `()` as return type for `void` function, which becomes `Tuple([])`.
             ty::Tuple(t_list) if t_list.len() == 0 => FfiType::void(),
-            _ => {
-                throw_unsup_format!("unsupported type for native call: {}", layout.ty)
-            }
+            _ => return Err(layout.ty),
         })
     }
 }
@@ -427,6 +427,7 @@ fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> InterpResult<'tcx, FfiType
 /// native code.
 struct LibffiClosureData<'tcx> {
     ecx_interchange: &'static Cell<usize>,
+    unsupported: bool,
     marker: PhantomData<MiriInterpCx<'tcx>>,
 }
 
@@ -441,22 +442,32 @@ pub fn build_libffi_closure<'tcx, 'this>(
     fn_sig: rustc_middle::ty::FnSig<'tcx>,
 ) -> InterpResult<'tcx, unsafe extern "C" fn()> {
     // Compute argument and return types in libffi representation.
-    let mut args = Vec::new();
-    for input in fn_sig.inputs().iter() {
-        let layout = this.layout_of(*input)?;
-        let ty = this.ty_to_ffitype(layout)?;
-        args.push(ty);
-    }
-    let res_type = fn_sig.output();
-    let res_type = {
-        let layout = this.layout_of(res_type)?;
-        this.ty_to_ffitype(layout)?
+    let closure_builder = try {
+        let mut closure_builder = libffi::middle::Builder::new();
+        for &input in fn_sig.inputs().iter() {
+            let layout = this.layout_of(input).map_err(|_| input)?;
+            let ty = this.ty_to_ffitype(layout)?;
+            closure_builder = closure_builder.arg(ty);
+        }
+        let res_type = fn_sig.output();
+        let res_type = {
+            let layout = this.layout_of(res_type).map_err(|_| res_type)?;
+            this.ty_to_ffitype(layout)?
+        };
+        closure_builder.res(res_type)
     };
+    let mut unsupported = false;
+    let closure_builder = closure_builder.unwrap_or_else(|_| {
+        unsupported = true;
+        // We hope that a closure which aborts execution is works correctly even if we don't
+        // set its signature.
+        libffi::middle::Builder::new()
+    });
 
     // Build the actual closure.
-    let closure_builder = libffi::middle::Builder::new().args(args).res(res_type);
     let data = LibffiClosureData {
         ecx_interchange: this.machine.native_lib_ecx_interchange,
+        unsupported,
         marker: PhantomData,
     };
     let data = Box::leak(Box::new(data));
@@ -486,7 +497,13 @@ pub fn build_libffi_closure<'tcx, 'this>(
             .as_mut()
             .expect("libffi closure called while no FFI call is active")
     };
-    let err = err_unsup_format!("calling a function pointer through the FFI boundary");
+    let err = if data.unsupported {
+        err_unsup_format!(
+            "calling a function pointer with unsupported argument/return type through the FFI boundary"
+        )
+    } else {
+        err_unsup_format!("calling a function pointer through the FFI boundary")
+    };
 
     crate::diagnostics::report_result(ecx, err.into());
     // We abort the execution at this point as we cannot return the
@@ -524,7 +541,9 @@ fn call_native_fn(
         for arg in args.iter() {
             libffi_args.push(this.op_to_ffi_arg(arg, tracing)?);
         }
-        let ret_ty = this.ty_to_ffitype(dest.layout)?;
+        let ret_ty = this
+            .ty_to_ffitype(dest.layout)
+            .map_err(|ty| err_unsup_format!("unsupported return type for native call: {ty}"))?;
 
         // Prepare all exposed memory (both previously exposed, and just newly exposed since a
         // pointer was passed as argument). Uninitialised memory is left as-is, but any data
diff --git a/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_generic.rs b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_generic.rs
index 8be29c0c121a..061e5134c80e 100644
--- a/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_generic.rs
+++ b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_generic.rs
@@ -16,7 +16,16 @@ extern "C" fn id<T>(x: T) -> T {
         x
     }
 
+    fn pass_via_id_fn_ptr<T>(x: T) -> T {
+        let f = id::<T> as extern "C" fn(T) -> T;
+        f(x)
+    }
+
     unsafe {
+        // As long as we keep the function pointer on the Rust side, this is all fine.
+        let closure = || ();
+        pass_via_id_fn_ptr(closure)();
+        // When we pass it to FFI, we get the expected error.
         call_fn_ptr(id::<i32>); //~ ERROR: unsupported operation: calling a function pointer through the FFI boundary
     }
 }
diff --git a/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.notrace.stderr b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.notrace.stderr
new file mode 100644
index 000000000000..a3e98a162ea2
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.notrace.stderr
@@ -0,0 +1,31 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+   |
+LL |         call_fn_ptr(std::mem::transmute(f));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sharing memory with a native function
+   |
+   = help: when memory is shared with a native function call, Miri stops tracking initialization and provenance for that memory
+   = help: in particular, Miri assumes that the native call initializes all memory it has access to
+   = help: Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory
+   = help: what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+
+error: unsupported operation: calling a function pointer with unsupported argument/return type through the FFI boundary
+  --> tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+   |
+LL |         call_fn_ptr(std::mem::transmute(f));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsupported operation occurred here
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
diff --git a/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.rs b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.rs
new file mode 100644
index 000000000000..a079651b3fd8
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.rs
@@ -0,0 +1,32 @@
+//@revisions: trace notrace
+//@[trace] only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
+//@[trace] compile-flags: -Zmiri-native-lib-enable-tracing
+//@compile-flags: -Zmiri-permissive-provenance
+
+fn main() {
+    pass_fn_ptr()
+}
+
+fn pass_fn_ptr() {
+    extern "C" {
+        fn call_fn_ptr(s: extern "C" fn(i32) -> i32);
+    }
+
+    extern "C" fn id<T>(x: T) -> T {
+        x
+    }
+
+    fn make_fn_ptr_for_type<T>(_x: &T) -> extern "C" fn(T) -> T {
+        id::<T> as extern "C" fn(T) -> T
+    }
+
+    unsafe {
+        let closure = || ();
+        let f = make_fn_ptr_for_type(&closure);
+        // Transmute the type around so C can invoke this -- with the entirely wrong signature.
+        // Wht we're hoping for is that Miri just ignores all the arguments and aborts
+        // with a reasonable error instead.
+        call_fn_ptr(std::mem::transmute(f));
+        //~^ ERROR: unsupported operation: calling a function pointer with unsupported argument/return type
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.trace.stderr b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.trace.stderr
new file mode 100644
index 000000000000..72448b2ab0ff
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/call_fn_ptr_with_unsupported.trace.stderr
@@ -0,0 +1,32 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+   |
+LL |         call_fn_ptr(std::mem::transmute(f));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sharing memory with a native function
+   |
+   = help: when memory is shared with a native function call, Miri can only track initialisation and provenance on a best-effort basis
+   = help: in particular, Miri assumes that the native call initializes all memory it has written to
+   = help: Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory
+   = help: what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free
+   = help: tracing memory accesses in native code is not yet fully implemented, so there can be further imprecisions beyond what is documented here
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+
+error: unsupported operation: calling a function pointer with unsupported argument/return type through the FFI boundary
+  --> tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+   |
+LL |         call_fn_ptr(std::mem::transmute(f));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsupported operation occurred here
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: stack backtrace:
+           0: pass_fn_ptr
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+           1: main
+               at tests/native-lib/fail/call_fn_ptr_with_unsupported.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
diff --git a/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
index cf8315e0fd9d..27ae6c477a84 100644
--- a/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
+++ b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
@@ -15,5 +15,5 @@ pub struct PassMe {
 
 fn main() {
     let pass_me = PassMe { value: 42, other_value: 1337 };
-    unsafe { pass_struct(pass_me) }; //~ ERROR: unsupported operation: passing a non-#[repr(C)] struct over FFI
+    unsafe { pass_struct(pass_me) }; //~ ERROR: unsupported operation: unsupported argument type for native call
 }
diff --git a/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
index a9158a0c6bac..fd701e0e302e 100644
--- a/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
+++ b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
@@ -1,4 +1,4 @@
-error: unsupported operation: passing a non-#[repr(C)] struct over FFI: PassMe
+error: unsupported operation: unsupported argument type for native call: PassMe
   --> tests/native-lib/fail/struct_not_extern_c.rs:LL:CC
    |
 LL |     unsafe { pass_struct(pass_me) };

From 94acbebb088551e084bc77af64a818df6ec75248 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 9 Mar 2026 08:57:10 +0000
Subject: [PATCH 0225/1059] add test for proc-macros with custom panic payloads

---
 tests/ui/proc-macro/any-panic-payload.rs      | 17 ++++++++++++++
 tests/ui/proc-macro/any-panic-payload.stderr  | 20 +++++++++++++++++
 .../proc-macro/auxiliary/any-panic-payload.rs | 22 +++++++++++++++++++
 3 files changed, 59 insertions(+)
 create mode 100644 tests/ui/proc-macro/any-panic-payload.rs
 create mode 100644 tests/ui/proc-macro/any-panic-payload.stderr
 create mode 100644 tests/ui/proc-macro/auxiliary/any-panic-payload.rs

diff --git a/tests/ui/proc-macro/any-panic-payload.rs b/tests/ui/proc-macro/any-panic-payload.rs
new file mode 100644
index 000000000000..7a83a4e73a04
--- /dev/null
+++ b/tests/ui/proc-macro/any-panic-payload.rs
@@ -0,0 +1,17 @@
+//! Make sure that proc-macros which panic with a payload other than
+//! `String` or `&'static str` do not ICE.
+//@ proc-macro: any-panic-payload.rs
+
+extern crate any_panic_payload;
+
+use any_panic_payload::*;
+
+cause_panic!(); //~ ERROR proc macro panicked
+
+#[cause_panic_attr] //~ ERROR custom attribute panicked
+struct A;
+
+#[derive(CausePanic)] //~ ERROR proc-macro derive panicked
+struct B;
+
+fn main() {}
diff --git a/tests/ui/proc-macro/any-panic-payload.stderr b/tests/ui/proc-macro/any-panic-payload.stderr
new file mode 100644
index 000000000000..bb369b80e920
--- /dev/null
+++ b/tests/ui/proc-macro/any-panic-payload.stderr
@@ -0,0 +1,20 @@
+error: proc macro panicked
+  --> $DIR/any-panic-payload.rs:9:1
+   |
+LL | cause_panic!();
+   | ^^^^^^^^^^^^^^
+
+error: custom attribute panicked
+  --> $DIR/any-panic-payload.rs:11:1
+   |
+LL | #[cause_panic_attr]
+   | ^^^^^^^^^^^^^^^^^^^
+
+error: proc-macro derive panicked
+  --> $DIR/any-panic-payload.rs:14:10
+   |
+LL | #[derive(CausePanic)]
+   |          ^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/proc-macro/auxiliary/any-panic-payload.rs b/tests/ui/proc-macro/auxiliary/any-panic-payload.rs
new file mode 100644
index 000000000000..e78f82506831
--- /dev/null
+++ b/tests/ui/proc-macro/auxiliary/any-panic-payload.rs
@@ -0,0 +1,22 @@
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+fn boom() -> TokenStream {
+    std::panic::panic_any(42)
+}
+
+#[proc_macro]
+pub fn cause_panic(_: TokenStream) -> TokenStream {
+    boom()
+}
+
+#[proc_macro_attribute]
+pub fn cause_panic_attr(_: TokenStream, _: TokenStream) -> TokenStream {
+    boom()
+}
+
+#[proc_macro_derive(CausePanic)]
+pub fn cause_panic_derive(_: TokenStream) -> TokenStream {
+    boom()
+}

From e63664773ceea6e9e7c4b405c79c951aa8725420 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Mon, 9 Mar 2026 09:11:06 +0000
Subject: [PATCH 0226/1059] Move some ui tests

* Move dyn-drop to dyn-keyword
* Reorganize `tests/ui/empty` into specific dirs

remove tests/ui/empty/empty-linkname.rs duplicate of tests/ui/error-codes/E0454.rs
* Move `missing-trait-bounds` to `trait-bound/missing-trait-bounds`
* bless traits/missing-trait-bounds tests
* Move `recursion_limit` to `recursion/recursion_limit`
* Move `version` to `compile-flags`
---
 src/tools/tidy/src/issues.txt                 |  6 -----
 tests/ui/README.md                            | 24 -------------------
 .../no_link/auxiliary/empty-struct.rs         |  1 +
 .../no_link/no-link-struct.rs}                |  2 +-
 .../version-info-flags.rs                     |  0
 tests/ui/dyn-drop/dyn-drop.rs                 | 15 ------------
 tests/ui/dyn-keyword/dyn-drop.rs              | 15 ++++++++++++
 .../{dyn-drop => dyn-keyword}/dyn-drop.stderr | 12 +++++-----
 tests/ui/empty/auxiliary/two_macros.rs        |  5 ----
 tests/ui/empty/empty-linkname.rs              |  4 ----
 tests/ui/empty/empty-linkname.stderr          |  9 -------
 tests/ui/empty/issue-37026.rs                 |  8 -------
 .../unused}/empty-attributes.rs               |  0
 .../unused}/empty-attributes.stderr           |  0
 tests/ui/{empty => macros}/empty-comment.rs   |  0
 .../ui/{empty => macros}/empty-comment.stderr |  0
 .../macro-use-empty.rs}                       |  0
 .../macro-use-empty.stderr}                   |  4 ++--
 .../empty-never-array.rs                      |  0
 .../empty-never-array.stderr                  |  0
 .../future-stream-buffer-unordered-40003.rs}  |  0
 .../{ => recursion}/recursion_limit/empty.rs  |  0
 .../recursion_limit/empty.stderr              |  0
 .../invalid-attribute-105700.rs}              |  0
 .../invalid-attribute-105700.stderr}          |  4 ++--
 .../recursion_limit/invalid_digit.rs          |  0
 .../recursion_limit/invalid_digit.stderr      |  0
 .../recursion_limit/invalid_digit_type.rs     |  0
 .../recursion_limit/invalid_digit_type.stderr |  0
 .../recursion_limit/invalid_macro.rs          |  0
 .../recursion_limit/invalid_macro.stderr      |  0
 .../recursion_limit/no-value.rs               |  0
 .../recursion_limit/no-value.stderr           |  0
 .../recursion_limit/overflow.rs               |  0
 .../recursion_limit/overflow.stderr           |  0
 .../recursion_limit/zero-overflow.rs          |  0
 .../recursion_limit/zero-overflow.stderr      |  0
 .../{ => recursion}/recursion_limit/zero.rs   |  0
 .../recursion_limit/zero.stderr               |  0
 .../auxiliary/empty-struct.rs                 |  0
 .../empty-struct-braces-expr.rs               |  0
 .../empty-struct-braces-expr.stderr           |  0
 .../empty-struct-braces-pat-1.rs              |  0
 .../empty-struct-braces-pat-1.stderr          |  0
 .../empty-struct-braces-pat-2.rs              |  0
 .../empty-struct-braces-pat-2.stderr          |  0
 .../empty-struct-braces-pat-3.rs              |  0
 .../empty-struct-braces-pat-3.stderr          |  0
 .../empty-struct-tuple-pat.rs                 |  0
 .../empty-struct-tuple-pat.stderr             |  0
 .../empty-struct-unit-expr.rs                 |  0
 .../empty-struct-unit-expr.stderr             |  0
 .../empty-struct-unit-pat.rs                  |  0
 .../empty-struct-unit-pat.stderr              |  0
 .../auxiliary/struct-69725.rs}                |  0
 .../derive-clone-missing-bound-69725.fixed}   |  6 ++---
 .../derive-clone-missing-bound-69725.rs}      |  6 ++---
 .../derive-clone-missing-bound-69725.stderr}  | 12 +++++-----
 .../duplicate-bounds-diagnostic-35677.fixed}  |  0
 .../duplicate-bounds-diagnostic-35677.rs}     |  0
 .../duplicate-bounds-diagnostic-35677.stderr} |  2 +-
 .../missing-trait-bound-for-op.fixed          |  0
 .../missing-trait-bound-for-op.rs             |  0
 .../missing-trait-bound-for-op.stderr         |  0
 .../missing-trait-bounds-for-method-call.rs   |  0
 ...issing-trait-bounds-for-method-call.stderr |  0
 tests/ui/typeck/auxiliary/empty-struct.rs     |  2 ++
 .../typeck/struct-pattern-mismatch-37026.rs   |  8 +++++++
 .../struct-pattern-mismatch-37026.stderr}     | 12 +++++-----
 69 files changed, 56 insertions(+), 101 deletions(-)
 create mode 100644 tests/ui/attributes/no_link/auxiliary/empty-struct.rs
 rename tests/ui/{empty/no-link.rs => attributes/no_link/no-link-struct.rs} (76%)
 rename tests/ui/{version => compile-flags}/version-info-flags.rs (100%)
 delete mode 100644 tests/ui/dyn-drop/dyn-drop.rs
 create mode 100644 tests/ui/dyn-keyword/dyn-drop.rs
 rename tests/ui/{dyn-drop => dyn-keyword}/dyn-drop.stderr (88%)
 delete mode 100644 tests/ui/empty/auxiliary/two_macros.rs
 delete mode 100644 tests/ui/empty/empty-linkname.rs
 delete mode 100644 tests/ui/empty/empty-linkname.stderr
 delete mode 100644 tests/ui/empty/issue-37026.rs
 rename tests/ui/{empty => lint/unused}/empty-attributes.rs (100%)
 rename tests/ui/{empty => lint/unused}/empty-attributes.stderr (100%)
 rename tests/ui/{empty => macros}/empty-comment.rs (100%)
 rename tests/ui/{empty => macros}/empty-comment.stderr (100%)
 rename tests/ui/{empty/empty-macro-use.rs => macros/macro-use-empty.rs} (100%)
 rename tests/ui/{empty/empty-macro-use.stderr => macros/macro-use-empty.stderr} (88%)
 rename tests/ui/{empty => never_type}/empty-never-array.rs (100%)
 rename tests/ui/{empty => never_type}/empty-never-array.stderr (100%)
 rename tests/ui/{recursion_limit/issue-40003.rs => recursion/future-stream-buffer-unordered-40003.rs} (100%)
 rename tests/ui/{ => recursion}/recursion_limit/empty.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/empty.stderr (100%)
 rename tests/ui/{recursion_limit/issue-105700.rs => recursion/recursion_limit/invalid-attribute-105700.rs} (100%)
 rename tests/ui/{recursion_limit/issue-105700.stderr => recursion/recursion_limit/invalid-attribute-105700.stderr} (66%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_digit.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_digit.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_digit_type.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_digit_type.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_macro.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/invalid_macro.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/no-value.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/no-value.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/overflow.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/overflow.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/zero-overflow.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/zero-overflow.stderr (100%)
 rename tests/ui/{ => recursion}/recursion_limit/zero.rs (100%)
 rename tests/ui/{ => recursion}/recursion_limit/zero.stderr (100%)
 rename tests/ui/{empty => resolve}/auxiliary/empty-struct.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-expr.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-expr.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-1.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-1.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-2.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-2.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-3.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-braces-pat-3.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-tuple-pat.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-tuple-pat.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-unit-expr.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-unit-expr.stderr (100%)
 rename tests/ui/{empty => resolve}/empty-struct-unit-pat.rs (100%)
 rename tests/ui/{empty => resolve}/empty-struct-unit-pat.stderr (100%)
 rename tests/ui/{missing-trait-bounds/auxiliary/issue-69725.rs => traits/missing-trait-bounds/auxiliary/struct-69725.rs} (100%)
 rename tests/ui/{missing-trait-bounds/issue-69725.fixed => traits/missing-trait-bounds/derive-clone-missing-bound-69725.fixed} (64%)
 rename tests/ui/{missing-trait-bounds/issue-69725.rs => traits/missing-trait-bounds/derive-clone-missing-bound-69725.rs} (62%)
 rename tests/ui/{missing-trait-bounds/issue-69725.stderr => traits/missing-trait-bounds/derive-clone-missing-bound-69725.stderr} (54%)
 rename tests/ui/{missing-trait-bounds/issue-35677.fixed => traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.fixed} (100%)
 rename tests/ui/{missing-trait-bounds/issue-35677.rs => traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.rs} (100%)
 rename tests/ui/{missing-trait-bounds/issue-35677.stderr => traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.stderr} (93%)
 rename tests/ui/{ => traits}/missing-trait-bounds/missing-trait-bound-for-op.fixed (100%)
 rename tests/ui/{ => traits}/missing-trait-bounds/missing-trait-bound-for-op.rs (100%)
 rename tests/ui/{ => traits}/missing-trait-bounds/missing-trait-bound-for-op.stderr (100%)
 rename tests/ui/{ => traits}/missing-trait-bounds/missing-trait-bounds-for-method-call.rs (100%)
 rename tests/ui/{ => traits}/missing-trait-bounds/missing-trait-bounds-for-method-call.stderr (100%)
 create mode 100644 tests/ui/typeck/auxiliary/empty-struct.rs
 create mode 100644 tests/ui/typeck/struct-pattern-mismatch-37026.rs
 rename tests/ui/{empty/issue-37026.stderr => typeck/struct-pattern-mismatch-37026.stderr} (64%)

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index a533598cb4bd..d9f3e943da82 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -927,7 +927,6 @@ ui/dst/issue-90528-unsizing-suggestion-3.rs
 ui/dst/issue-90528-unsizing-suggestion-4.rs
 ui/dyn-keyword/issue-5153.rs
 ui/dyn-keyword/issue-56327-dyn-trait-in-macro-is-okay.rs
-ui/empty/issue-37026.rs
 ui/enum-discriminant/auxiliary/issue-41394.rs
 ui/enum-discriminant/issue-104519.rs
 ui/enum-discriminant/issue-41394-rpass.rs
@@ -1706,9 +1705,6 @@ ui/mismatched_types/issue-47706.rs
 ui/mismatched_types/issue-74918-missing-lifetime.rs
 ui/mismatched_types/issue-75361-mismatched-impl.rs
 ui/mismatched_types/issue-84976.rs
-ui/missing-trait-bounds/auxiliary/issue-69725.rs
-ui/missing-trait-bounds/issue-35677.rs
-ui/missing-trait-bounds/issue-69725.rs
 ui/modules/auxiliary/issue-13872-1.rs
 ui/modules/auxiliary/issue-13872-2.rs
 ui/modules/auxiliary/issue-13872-3.rs
@@ -2292,8 +2288,6 @@ ui/recursion/issue-38591-non-regular-dropck-recursion.rs
 ui/recursion/issue-83150.rs
 ui/recursion/issue-86784.rs
 ui/recursion/issue-95134.rs
-ui/recursion_limit/issue-105700.rs
-ui/recursion_limit/issue-40003.rs
 ui/regions/issue-101280.rs
 ui/regions/issue-102374.rs
 ui/regions/issue-102392.rs
diff --git a/tests/ui/README.md b/tests/ui/README.md
index 689a61b47269..248f1208d8d9 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -498,10 +498,6 @@ See:
 
 Previously known as "object safety".
 
-## `tests/ui/dyn-drop/`: `dyn Drop`
-
-**FIXME**: Contains a single test, used only to check the `dyn_drop` lint (which is normally `warn` level).
-
 ## `tests/ui/dyn-keyword/`: `dyn` and Dynamic Dispatch
 
 The `dyn` keyword is used to highlight that calls to methods on the associated Trait are dynamically dispatched. To use the trait this way, it must be dyn-compatible - tests about dyn-compatibility belong in `tests/ui/dyn-compatibility/`, while more general tests on dynamic dispatch belong here.
@@ -518,10 +514,6 @@ These tests run in specific Rust editions, such as Rust 2015 or Rust 2018, and c
 
 Exercises `eii` keyword.
 
-## `tests/ui/empty/`: Various tests related to the concept of "empty"
-
-**FIXME**: These tests need better homes, this is not very informative.
-
 ## `tests/ui/entry-point/`: `main` function
 
 Tests exercising the `main` entry-point.
@@ -940,12 +932,6 @@ Something is missing which could be added to fix (e.g. suggestions).
 
 **FIXME**: this is way too vague, tests should be rehomed.
 
-## `tests/ui/missing-trait-bounds/`
-
-Tests for checking missing trait bounds, and their diagnostics.
-
-**FIXME**: Maybe a subdirectory of `ui/trait-bounds` would be more appropriate.
-
 ## `tests/ui/modules/`
 
 Tests on the module system.
@@ -1173,12 +1159,6 @@ Broad category of tests exercising recursions (compile test and run time), in fu
 
 Also exercises the `#![recursion_limit = ""]` attribute.
 
-## `tests/ui/recursion_limit/`: `#![recursion_limit = ""]`
-
-Sets a recursion limit on recursive code.
-
-**FIXME**: Should be merged with `tests/ui/recursion/`.
-
 ## `tests/ui/reflection/`
 
 Exercises the `#![feature(type_info)]` feature.
@@ -1601,10 +1581,6 @@ Tests on `enum` variants.
 
 **FIXME**: Should be rehomed with `tests/ui/enum/`.
 
-## `tests/ui/version/`
-
-**FIXME**: Contains a single test described as "Check that rustc accepts various version info flags.", should be rehomed.
-
 ## `tests/ui/wasm/`
 
 These tests target the `wasm32` architecture specifically. They are usually regression tests for WASM-specific bugs which were observed in the past.
diff --git a/tests/ui/attributes/no_link/auxiliary/empty-struct.rs b/tests/ui/attributes/no_link/auxiliary/empty-struct.rs
new file mode 100644
index 000000000000..091db1e76c39
--- /dev/null
+++ b/tests/ui/attributes/no_link/auxiliary/empty-struct.rs
@@ -0,0 +1 @@
+pub struct XEmpty {}
diff --git a/tests/ui/empty/no-link.rs b/tests/ui/attributes/no_link/no-link-struct.rs
similarity index 76%
rename from tests/ui/empty/no-link.rs
rename to tests/ui/attributes/no_link/no-link-struct.rs
index 9f78714b7694..40b0c53185f9 100644
--- a/tests/ui/empty/no-link.rs
+++ b/tests/ui/attributes/no_link/no-link-struct.rs
@@ -5,5 +5,5 @@
 extern crate empty_struct;
 
 fn main() {
-    empty_struct::XEmpty1 {};
+    empty_struct::XEmpty {};
 }
diff --git a/tests/ui/version/version-info-flags.rs b/tests/ui/compile-flags/version-info-flags.rs
similarity index 100%
rename from tests/ui/version/version-info-flags.rs
rename to tests/ui/compile-flags/version-info-flags.rs
diff --git a/tests/ui/dyn-drop/dyn-drop.rs b/tests/ui/dyn-drop/dyn-drop.rs
deleted file mode 100644
index f336949d2cb7..000000000000
--- a/tests/ui/dyn-drop/dyn-drop.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![deny(dyn_drop)]
-fn foo(_: Box<dyn Drop>) {} //~ ERROR
-fn bar(_: &dyn Drop) {} //~ERROR
-fn baz(_: *mut dyn Drop) {} //~ ERROR
-struct Foo {
-  _x: Box<dyn Drop> //~ ERROR
-}
-trait Bar {
-  type T: ?Sized;
-}
-struct Baz {}
-impl Bar for Baz {
-  type T = dyn Drop; //~ ERROR
-}
-fn main() {}
diff --git a/tests/ui/dyn-keyword/dyn-drop.rs b/tests/ui/dyn-keyword/dyn-drop.rs
new file mode 100644
index 000000000000..81753c94a775
--- /dev/null
+++ b/tests/ui/dyn-keyword/dyn-drop.rs
@@ -0,0 +1,15 @@
+#![deny(dyn_drop)]
+fn foo(_: Box<dyn Drop>) {} //~ ERROR: types that do not implement `Drop` can still have drop glue,
+fn bar(_: &dyn Drop) {} //~ ERROR: types that do not implement `Drop` can still have drop glue,
+fn baz(_: *mut dyn Drop) {} //~ ERROR: types that do not implement `Drop` can still have drop glue,
+struct Foo {
+    _x: Box<dyn Drop>, //~ ERROR: types that do not implement `Drop` can still have drop glue,
+}
+trait Bar {
+    type T: ?Sized;
+}
+struct Baz {}
+impl Bar for Baz {
+    type T = dyn Drop; //~ ERROR: types that do not implement `Drop` can still have drop glue,
+}
+fn main() {}
diff --git a/tests/ui/dyn-drop/dyn-drop.stderr b/tests/ui/dyn-keyword/dyn-drop.stderr
similarity index 88%
rename from tests/ui/dyn-drop/dyn-drop.stderr
rename to tests/ui/dyn-keyword/dyn-drop.stderr
index 8210d8a4c48f..969327ecb84e 100644
--- a/tests/ui/dyn-drop/dyn-drop.stderr
+++ b/tests/ui/dyn-keyword/dyn-drop.stderr
@@ -23,16 +23,16 @@ LL | fn baz(_: *mut dyn Drop) {}
    |                    ^^^^
 
 error: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
-  --> $DIR/dyn-drop.rs:6:15
+  --> $DIR/dyn-drop.rs:6:17
    |
-LL |   _x: Box<dyn Drop>
-   |               ^^^^
+LL |     _x: Box<dyn Drop>,
+   |                 ^^^^
 
 error: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
-  --> $DIR/dyn-drop.rs:13:16
+  --> $DIR/dyn-drop.rs:13:18
    |
-LL |   type T = dyn Drop;
-   |                ^^^^
+LL |     type T = dyn Drop;
+   |                  ^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/empty/auxiliary/two_macros.rs b/tests/ui/empty/auxiliary/two_macros.rs
deleted file mode 100644
index 2330c75c8e0c..000000000000
--- a/tests/ui/empty/auxiliary/two_macros.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[macro_export]
-macro_rules! macro_one { () => ("one") }
-
-#[macro_export]
-macro_rules! macro_two { () => ("two") }
diff --git a/tests/ui/empty/empty-linkname.rs b/tests/ui/empty/empty-linkname.rs
deleted file mode 100644
index 7113d913cd0f..000000000000
--- a/tests/ui/empty/empty-linkname.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#[link(name = "")] //~ ERROR: link name must not be empty
-extern "C" {}
-
-fn main() {}
diff --git a/tests/ui/empty/empty-linkname.stderr b/tests/ui/empty/empty-linkname.stderr
deleted file mode 100644
index 9fbcbc3ca9dc..000000000000
--- a/tests/ui/empty/empty-linkname.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0454]: link name must not be empty
-  --> $DIR/empty-linkname.rs:1:15
-   |
-LL | #[link(name = "")]
-   |               ^^ empty link name
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0454`.
diff --git a/tests/ui/empty/issue-37026.rs b/tests/ui/empty/issue-37026.rs
deleted file mode 100644
index 2b9dfdcb0f17..000000000000
--- a/tests/ui/empty/issue-37026.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ aux-build:empty-struct.rs
-
-extern crate empty_struct;
-
-fn main() {
-    let empty_struct::XEmpty2 = (); //~ ERROR mismatched types
-    let empty_struct::XEmpty6(..) = (); //~ ERROR mismatched types
-}
diff --git a/tests/ui/empty/empty-attributes.rs b/tests/ui/lint/unused/empty-attributes.rs
similarity index 100%
rename from tests/ui/empty/empty-attributes.rs
rename to tests/ui/lint/unused/empty-attributes.rs
diff --git a/tests/ui/empty/empty-attributes.stderr b/tests/ui/lint/unused/empty-attributes.stderr
similarity index 100%
rename from tests/ui/empty/empty-attributes.stderr
rename to tests/ui/lint/unused/empty-attributes.stderr
diff --git a/tests/ui/empty/empty-comment.rs b/tests/ui/macros/empty-comment.rs
similarity index 100%
rename from tests/ui/empty/empty-comment.rs
rename to tests/ui/macros/empty-comment.rs
diff --git a/tests/ui/empty/empty-comment.stderr b/tests/ui/macros/empty-comment.stderr
similarity index 100%
rename from tests/ui/empty/empty-comment.stderr
rename to tests/ui/macros/empty-comment.stderr
diff --git a/tests/ui/empty/empty-macro-use.rs b/tests/ui/macros/macro-use-empty.rs
similarity index 100%
rename from tests/ui/empty/empty-macro-use.rs
rename to tests/ui/macros/macro-use-empty.rs
diff --git a/tests/ui/empty/empty-macro-use.stderr b/tests/ui/macros/macro-use-empty.stderr
similarity index 88%
rename from tests/ui/empty/empty-macro-use.stderr
rename to tests/ui/macros/macro-use-empty.stderr
index 0b23dd4e1721..f3997ad3c27f 100644
--- a/tests/ui/empty/empty-macro-use.stderr
+++ b/tests/ui/macros/macro-use-empty.stderr
@@ -1,5 +1,5 @@
 error: cannot find macro `macro_two` in this scope
-  --> $DIR/empty-macro-use.rs:8:5
+  --> $DIR/macro-use-empty.rs:8:5
    |
 LL |     macro_two!();
    |     ^^^^^^^^^
@@ -10,7 +10,7 @@ LL + use two_macros::macro_two;
    |
 
 warning: unused attribute
-  --> $DIR/empty-macro-use.rs:3:12
+  --> $DIR/macro-use-empty.rs:3:12
    |
 LL | #[macro_use()]
    |            ^^ help: remove these parentheses
diff --git a/tests/ui/empty/empty-never-array.rs b/tests/ui/never_type/empty-never-array.rs
similarity index 100%
rename from tests/ui/empty/empty-never-array.rs
rename to tests/ui/never_type/empty-never-array.rs
diff --git a/tests/ui/empty/empty-never-array.stderr b/tests/ui/never_type/empty-never-array.stderr
similarity index 100%
rename from tests/ui/empty/empty-never-array.stderr
rename to tests/ui/never_type/empty-never-array.stderr
diff --git a/tests/ui/recursion_limit/issue-40003.rs b/tests/ui/recursion/future-stream-buffer-unordered-40003.rs
similarity index 100%
rename from tests/ui/recursion_limit/issue-40003.rs
rename to tests/ui/recursion/future-stream-buffer-unordered-40003.rs
diff --git a/tests/ui/recursion_limit/empty.rs b/tests/ui/recursion/recursion_limit/empty.rs
similarity index 100%
rename from tests/ui/recursion_limit/empty.rs
rename to tests/ui/recursion/recursion_limit/empty.rs
diff --git a/tests/ui/recursion_limit/empty.stderr b/tests/ui/recursion/recursion_limit/empty.stderr
similarity index 100%
rename from tests/ui/recursion_limit/empty.stderr
rename to tests/ui/recursion/recursion_limit/empty.stderr
diff --git a/tests/ui/recursion_limit/issue-105700.rs b/tests/ui/recursion/recursion_limit/invalid-attribute-105700.rs
similarity index 100%
rename from tests/ui/recursion_limit/issue-105700.rs
rename to tests/ui/recursion/recursion_limit/invalid-attribute-105700.rs
diff --git a/tests/ui/recursion_limit/issue-105700.stderr b/tests/ui/recursion/recursion_limit/invalid-attribute-105700.stderr
similarity index 66%
rename from tests/ui/recursion_limit/issue-105700.stderr
rename to tests/ui/recursion/recursion_limit/invalid-attribute-105700.stderr
index fd53d248c4e0..31e230cc6400 100644
--- a/tests/ui/recursion_limit/issue-105700.stderr
+++ b/tests/ui/recursion/recursion_limit/invalid-attribute-105700.stderr
@@ -1,10 +1,10 @@
 error: recursion limit reached while expanding `#[invalid_attribute]`
-  --> $DIR/issue-105700.rs:6:1
+  --> $DIR/invalid-attribute-105700.rs:6:1
    |
 LL | #![invalid_attribute]
    | ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "8"]` attribute to your crate (`issue_105700`)
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "8"]` attribute to your crate (`invalid_attribute_105700`)
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/invalid_digit.rs b/tests/ui/recursion/recursion_limit/invalid_digit.rs
similarity index 100%
rename from tests/ui/recursion_limit/invalid_digit.rs
rename to tests/ui/recursion/recursion_limit/invalid_digit.rs
diff --git a/tests/ui/recursion_limit/invalid_digit.stderr b/tests/ui/recursion/recursion_limit/invalid_digit.stderr
similarity index 100%
rename from tests/ui/recursion_limit/invalid_digit.stderr
rename to tests/ui/recursion/recursion_limit/invalid_digit.stderr
diff --git a/tests/ui/recursion_limit/invalid_digit_type.rs b/tests/ui/recursion/recursion_limit/invalid_digit_type.rs
similarity index 100%
rename from tests/ui/recursion_limit/invalid_digit_type.rs
rename to tests/ui/recursion/recursion_limit/invalid_digit_type.rs
diff --git a/tests/ui/recursion_limit/invalid_digit_type.stderr b/tests/ui/recursion/recursion_limit/invalid_digit_type.stderr
similarity index 100%
rename from tests/ui/recursion_limit/invalid_digit_type.stderr
rename to tests/ui/recursion/recursion_limit/invalid_digit_type.stderr
diff --git a/tests/ui/recursion_limit/invalid_macro.rs b/tests/ui/recursion/recursion_limit/invalid_macro.rs
similarity index 100%
rename from tests/ui/recursion_limit/invalid_macro.rs
rename to tests/ui/recursion/recursion_limit/invalid_macro.rs
diff --git a/tests/ui/recursion_limit/invalid_macro.stderr b/tests/ui/recursion/recursion_limit/invalid_macro.stderr
similarity index 100%
rename from tests/ui/recursion_limit/invalid_macro.stderr
rename to tests/ui/recursion/recursion_limit/invalid_macro.stderr
diff --git a/tests/ui/recursion_limit/no-value.rs b/tests/ui/recursion/recursion_limit/no-value.rs
similarity index 100%
rename from tests/ui/recursion_limit/no-value.rs
rename to tests/ui/recursion/recursion_limit/no-value.rs
diff --git a/tests/ui/recursion_limit/no-value.stderr b/tests/ui/recursion/recursion_limit/no-value.stderr
similarity index 100%
rename from tests/ui/recursion_limit/no-value.stderr
rename to tests/ui/recursion/recursion_limit/no-value.stderr
diff --git a/tests/ui/recursion_limit/overflow.rs b/tests/ui/recursion/recursion_limit/overflow.rs
similarity index 100%
rename from tests/ui/recursion_limit/overflow.rs
rename to tests/ui/recursion/recursion_limit/overflow.rs
diff --git a/tests/ui/recursion_limit/overflow.stderr b/tests/ui/recursion/recursion_limit/overflow.stderr
similarity index 100%
rename from tests/ui/recursion_limit/overflow.stderr
rename to tests/ui/recursion/recursion_limit/overflow.stderr
diff --git a/tests/ui/recursion_limit/zero-overflow.rs b/tests/ui/recursion/recursion_limit/zero-overflow.rs
similarity index 100%
rename from tests/ui/recursion_limit/zero-overflow.rs
rename to tests/ui/recursion/recursion_limit/zero-overflow.rs
diff --git a/tests/ui/recursion_limit/zero-overflow.stderr b/tests/ui/recursion/recursion_limit/zero-overflow.stderr
similarity index 100%
rename from tests/ui/recursion_limit/zero-overflow.stderr
rename to tests/ui/recursion/recursion_limit/zero-overflow.stderr
diff --git a/tests/ui/recursion_limit/zero.rs b/tests/ui/recursion/recursion_limit/zero.rs
similarity index 100%
rename from tests/ui/recursion_limit/zero.rs
rename to tests/ui/recursion/recursion_limit/zero.rs
diff --git a/tests/ui/recursion_limit/zero.stderr b/tests/ui/recursion/recursion_limit/zero.stderr
similarity index 100%
rename from tests/ui/recursion_limit/zero.stderr
rename to tests/ui/recursion/recursion_limit/zero.stderr
diff --git a/tests/ui/empty/auxiliary/empty-struct.rs b/tests/ui/resolve/auxiliary/empty-struct.rs
similarity index 100%
rename from tests/ui/empty/auxiliary/empty-struct.rs
rename to tests/ui/resolve/auxiliary/empty-struct.rs
diff --git a/tests/ui/empty/empty-struct-braces-expr.rs b/tests/ui/resolve/empty-struct-braces-expr.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-expr.rs
rename to tests/ui/resolve/empty-struct-braces-expr.rs
diff --git a/tests/ui/empty/empty-struct-braces-expr.stderr b/tests/ui/resolve/empty-struct-braces-expr.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-expr.stderr
rename to tests/ui/resolve/empty-struct-braces-expr.stderr
diff --git a/tests/ui/empty/empty-struct-braces-pat-1.rs b/tests/ui/resolve/empty-struct-braces-pat-1.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-1.rs
rename to tests/ui/resolve/empty-struct-braces-pat-1.rs
diff --git a/tests/ui/empty/empty-struct-braces-pat-1.stderr b/tests/ui/resolve/empty-struct-braces-pat-1.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-1.stderr
rename to tests/ui/resolve/empty-struct-braces-pat-1.stderr
diff --git a/tests/ui/empty/empty-struct-braces-pat-2.rs b/tests/ui/resolve/empty-struct-braces-pat-2.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-2.rs
rename to tests/ui/resolve/empty-struct-braces-pat-2.rs
diff --git a/tests/ui/empty/empty-struct-braces-pat-2.stderr b/tests/ui/resolve/empty-struct-braces-pat-2.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-2.stderr
rename to tests/ui/resolve/empty-struct-braces-pat-2.stderr
diff --git a/tests/ui/empty/empty-struct-braces-pat-3.rs b/tests/ui/resolve/empty-struct-braces-pat-3.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-3.rs
rename to tests/ui/resolve/empty-struct-braces-pat-3.rs
diff --git a/tests/ui/empty/empty-struct-braces-pat-3.stderr b/tests/ui/resolve/empty-struct-braces-pat-3.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-braces-pat-3.stderr
rename to tests/ui/resolve/empty-struct-braces-pat-3.stderr
diff --git a/tests/ui/empty/empty-struct-tuple-pat.rs b/tests/ui/resolve/empty-struct-tuple-pat.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-tuple-pat.rs
rename to tests/ui/resolve/empty-struct-tuple-pat.rs
diff --git a/tests/ui/empty/empty-struct-tuple-pat.stderr b/tests/ui/resolve/empty-struct-tuple-pat.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-tuple-pat.stderr
rename to tests/ui/resolve/empty-struct-tuple-pat.stderr
diff --git a/tests/ui/empty/empty-struct-unit-expr.rs b/tests/ui/resolve/empty-struct-unit-expr.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-unit-expr.rs
rename to tests/ui/resolve/empty-struct-unit-expr.rs
diff --git a/tests/ui/empty/empty-struct-unit-expr.stderr b/tests/ui/resolve/empty-struct-unit-expr.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-unit-expr.stderr
rename to tests/ui/resolve/empty-struct-unit-expr.stderr
diff --git a/tests/ui/empty/empty-struct-unit-pat.rs b/tests/ui/resolve/empty-struct-unit-pat.rs
similarity index 100%
rename from tests/ui/empty/empty-struct-unit-pat.rs
rename to tests/ui/resolve/empty-struct-unit-pat.rs
diff --git a/tests/ui/empty/empty-struct-unit-pat.stderr b/tests/ui/resolve/empty-struct-unit-pat.stderr
similarity index 100%
rename from tests/ui/empty/empty-struct-unit-pat.stderr
rename to tests/ui/resolve/empty-struct-unit-pat.stderr
diff --git a/tests/ui/missing-trait-bounds/auxiliary/issue-69725.rs b/tests/ui/traits/missing-trait-bounds/auxiliary/struct-69725.rs
similarity index 100%
rename from tests/ui/missing-trait-bounds/auxiliary/issue-69725.rs
rename to tests/ui/traits/missing-trait-bounds/auxiliary/struct-69725.rs
diff --git a/tests/ui/missing-trait-bounds/issue-69725.fixed b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.fixed
similarity index 64%
rename from tests/ui/missing-trait-bounds/issue-69725.fixed
rename to tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.fixed
index f23468abcb0a..aea046b1e771 100644
--- a/tests/ui/missing-trait-bounds/issue-69725.fixed
+++ b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.fixed
@@ -1,9 +1,9 @@
 //@ run-rustfix
-//@ aux-build:issue-69725.rs
+//@ aux-build:struct-69725.rs
 #![allow(dead_code)]
 
-extern crate issue_69725;
-use issue_69725::Struct;
+extern crate struct_69725;
+use struct_69725::Struct;
 
 fn crash<A>() where A: Clone {
     let _ = Struct::<A>::new().clone();
diff --git a/tests/ui/missing-trait-bounds/issue-69725.rs b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.rs
similarity index 62%
rename from tests/ui/missing-trait-bounds/issue-69725.rs
rename to tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.rs
index a51d2540b4cc..1ea88954e001 100644
--- a/tests/ui/missing-trait-bounds/issue-69725.rs
+++ b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.rs
@@ -1,9 +1,9 @@
 //@ run-rustfix
-//@ aux-build:issue-69725.rs
+//@ aux-build:struct-69725.rs
 #![allow(dead_code)]
 
-extern crate issue_69725;
-use issue_69725::Struct;
+extern crate struct_69725;
+use struct_69725::Struct;
 
 fn crash<A>() {
     let _ = Struct::<A>::new().clone();
diff --git a/tests/ui/missing-trait-bounds/issue-69725.stderr b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.stderr
similarity index 54%
rename from tests/ui/missing-trait-bounds/issue-69725.stderr
rename to tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.stderr
index 20d2213f4f5f..bed40b83bc37 100644
--- a/tests/ui/missing-trait-bounds/issue-69725.stderr
+++ b/tests/ui/traits/missing-trait-bounds/derive-clone-missing-bound-69725.stderr
@@ -1,17 +1,17 @@
-error[E0599]: the method `clone` exists for struct `issue_69725::Struct<A>`, but its trait bounds were not satisfied
-  --> $DIR/issue-69725.rs:9:32
+error[E0599]: the method `clone` exists for struct `struct_69725::Struct<A>`, but its trait bounds were not satisfied
+  --> $DIR/derive-clone-missing-bound-69725.rs:9:32
    |
 LL |     let _ = Struct::<A>::new().clone();
-   |                                ^^^^^ method cannot be called on `issue_69725::Struct<A>` due to unsatisfied trait bounds
+   |                                ^^^^^ method cannot be called on `struct_69725::Struct<A>` due to unsatisfied trait bounds
    |
-  ::: $DIR/auxiliary/issue-69725.rs:2:1
+  ::: $DIR/auxiliary/struct-69725.rs:2:1
    |
 LL | pub struct Struct<A>(A);
-   | -------------------- doesn't satisfy `issue_69725::Struct<A>: Clone`
+   | -------------------- doesn't satisfy `struct_69725::Struct<A>: Clone`
    |
    = note: the following trait bounds were not satisfied:
            `A: Clone`
-           which is required by `issue_69725::Struct<A>: Clone`
+           which is required by `struct_69725::Struct<A>: Clone`
 help: consider restricting the type parameter to satisfy the trait bound
    |
 LL | fn crash<A>() where A: Clone {
diff --git a/tests/ui/missing-trait-bounds/issue-35677.fixed b/tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.fixed
similarity index 100%
rename from tests/ui/missing-trait-bounds/issue-35677.fixed
rename to tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.fixed
diff --git a/tests/ui/missing-trait-bounds/issue-35677.rs b/tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.rs
similarity index 100%
rename from tests/ui/missing-trait-bounds/issue-35677.rs
rename to tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.rs
diff --git a/tests/ui/missing-trait-bounds/issue-35677.stderr b/tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.stderr
similarity index 93%
rename from tests/ui/missing-trait-bounds/issue-35677.stderr
rename to tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.stderr
index 3bfdd4da6dac..778a5664c0d7 100644
--- a/tests/ui/missing-trait-bounds/issue-35677.stderr
+++ b/tests/ui/traits/missing-trait-bounds/duplicate-bounds-diagnostic-35677.stderr
@@ -1,5 +1,5 @@
 error[E0599]: the method `is_subset` exists for reference `&HashSet<T>`, but its trait bounds were not satisfied
-  --> $DIR/issue-35677.rs:7:10
+  --> $DIR/duplicate-bounds-diagnostic-35677.rs:7:10
    |
 LL |     this.is_subset(other)
    |          ^^^^^^^^^ method cannot be called on `&HashSet<T>` due to unsatisfied trait bounds
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.fixed b/tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.fixed
similarity index 100%
rename from tests/ui/missing-trait-bounds/missing-trait-bound-for-op.fixed
rename to tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.fixed
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.rs b/tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.rs
similarity index 100%
rename from tests/ui/missing-trait-bounds/missing-trait-bound-for-op.rs
rename to tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.rs
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr b/tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.stderr
similarity index 100%
rename from tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
rename to tests/ui/traits/missing-trait-bounds/missing-trait-bound-for-op.stderr
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bounds-for-method-call.rs b/tests/ui/traits/missing-trait-bounds/missing-trait-bounds-for-method-call.rs
similarity index 100%
rename from tests/ui/missing-trait-bounds/missing-trait-bounds-for-method-call.rs
rename to tests/ui/traits/missing-trait-bounds/missing-trait-bounds-for-method-call.rs
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bounds-for-method-call.stderr b/tests/ui/traits/missing-trait-bounds/missing-trait-bounds-for-method-call.stderr
similarity index 100%
rename from tests/ui/missing-trait-bounds/missing-trait-bounds-for-method-call.stderr
rename to tests/ui/traits/missing-trait-bounds/missing-trait-bounds-for-method-call.stderr
diff --git a/tests/ui/typeck/auxiliary/empty-struct.rs b/tests/ui/typeck/auxiliary/empty-struct.rs
new file mode 100644
index 000000000000..b9ce9de82142
--- /dev/null
+++ b/tests/ui/typeck/auxiliary/empty-struct.rs
@@ -0,0 +1,2 @@
+pub struct XEmpty1;
+pub struct XEmpty2();
diff --git a/tests/ui/typeck/struct-pattern-mismatch-37026.rs b/tests/ui/typeck/struct-pattern-mismatch-37026.rs
new file mode 100644
index 000000000000..f879ef4edeaf
--- /dev/null
+++ b/tests/ui/typeck/struct-pattern-mismatch-37026.rs
@@ -0,0 +1,8 @@
+//@ aux-build:empty-struct.rs
+
+extern crate empty_struct;
+
+fn main() {
+    let empty_struct::XEmpty1 = (); //~ ERROR mismatched types
+    let empty_struct::XEmpty2(..) = (); //~ ERROR mismatched types
+}
diff --git a/tests/ui/empty/issue-37026.stderr b/tests/ui/typeck/struct-pattern-mismatch-37026.stderr
similarity index 64%
rename from tests/ui/empty/issue-37026.stderr
rename to tests/ui/typeck/struct-pattern-mismatch-37026.stderr
index 75c3ab13cacc..b1b40d348210 100644
--- a/tests/ui/empty/issue-37026.stderr
+++ b/tests/ui/typeck/struct-pattern-mismatch-37026.stderr
@@ -1,18 +1,18 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-37026.rs:6:9
+  --> $DIR/struct-pattern-mismatch-37026.rs:6:9
    |
-LL |     let empty_struct::XEmpty2 = ();
+LL |     let empty_struct::XEmpty1 = ();
    |         ^^^^^^^^^^^^^^^^^^^^^   -- this expression has type `()`
    |         |
-   |         expected `()`, found `XEmpty2`
+   |         expected `()`, found `XEmpty1`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-37026.rs:7:9
+  --> $DIR/struct-pattern-mismatch-37026.rs:7:9
    |
-LL |     let empty_struct::XEmpty6(..) = ();
+LL |     let empty_struct::XEmpty2(..) = ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^   -- this expression has type `()`
    |         |
-   |         expected `()`, found `XEmpty6`
+   |         expected `()`, found `XEmpty2`
 
 error: aborting due to 2 previous errors
 

From 00980f438e92c00a9fe87331af1e5793f9319f4c Mon Sep 17 00:00:00 2001
From: James Barford-Evans <james.barford-evans@arm.com>
Date: Thu, 19 Feb 2026 11:56:28 +0000
Subject: [PATCH 0227/1059] Test for armv7 `get_unchecked(...)` inlining

---
 .../inlining-target-feature-differences.rs    | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 tests/codegen-llvm/inlining-target-feature-differences.rs

diff --git a/tests/codegen-llvm/inlining-target-feature-differences.rs b/tests/codegen-llvm/inlining-target-feature-differences.rs
new file mode 100644
index 000000000000..7c544d7dd3e2
--- /dev/null
+++ b/tests/codegen-llvm/inlining-target-feature-differences.rs
@@ -0,0 +1,19 @@
+//@ only-arm
+//@ ignore-backends: gcc
+
+#![feature(arm_target_feature)]
+#![crate_type = "lib"]
+#![no_std]
+
+#[inline]
+fn callee_neon(a: i32, b: i32) -> i32 {
+    a + b
+}
+
+#[no_mangle]
+#[target_feature(enable = "neon")]
+pub fn caller_neon(x: i32, y: i32) -> i32 {
+    // CHECK-LABEL: define noundef i32 @caller_neon(
+    // CHECK: [[R:%[0-9A-Za-z_.]+]] = add
+    callee_neon(x, y)
+}

From 167567407260e4c211374eb3dd25eef0157220c5 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Mon, 9 Mar 2026 11:08:57 +0100
Subject: [PATCH 0228/1059] Do not re-query source roots per crate in
 analysis-stats

---
 .../rust-analyzer/crates/base-db/src/editioned_file_id.rs    | 2 +-
 src/tools/rust-analyzer/crates/ide/src/typing.rs             | 5 ++---
 .../crates/rust-analyzer/src/cli/analysis_stats.rs           | 2 +-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
index db3730bccdf4..8721f3a0ff3b 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs
@@ -1,5 +1,5 @@
 //! Defines [`EditionedFileId`], an interned wrapper around [`span::EditionedFileId`] that
-//! is interned (so queries can take it) and remembers its crate.
+//! is interned (so queries can take it) and stores only the underlying `span::EditionedFileId`.
 
 use std::hash::Hash;
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/typing.rs b/src/tools/rust-analyzer/crates/ide/src/typing.rs
index 11bfb982cf41..e8b0c92dcb20 100644
--- a/src/tools/rust-analyzer/crates/ide/src/typing.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/typing.rs
@@ -70,12 +70,11 @@ pub(crate) fn on_char_typed(
     if !TRIGGER_CHARS.contains(&char_typed) {
         return None;
     }
-    let krate = db
+    let edition = db
         .relevant_crates(position.file_id)
         .first()
         .copied()
-        .unwrap_or_else(|| *db.all_crates().first().unwrap());
-    let edition = krate.data(db).edition;
+        .map_or(Edition::CURRENT, |krate| krate.data(db).edition);
     let editioned_file_id_wrapper = EditionedFileId::new(db, position.file_id, edition);
     let file = &db.parse(editioned_file_id_wrapper);
     let char_matches_position =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index caa35879aa00..82f04aa78ebb 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -127,7 +127,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             .iter()
             .cloned()
             .map(|krate| (db.file_source_root(krate.root_file(db)).source_root_id(db), krate))
-            .unique();
+            .unique_by(|(source_root_id, _)| *source_root_id);
 
         let mut dep_loc = 0;
         let mut workspace_loc = 0;

From 4019a92ca82a480e31156c7ecf83e646989ebeb7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 7 Mar 2026 18:39:39 +0100
Subject: [PATCH 0229/1059] Add new `rustc_errors::DiagDecorator` type

---
 compiler/rustc_errors/src/diagnostic.rs | 11 +++++++++++
 compiler/rustc_errors/src/lib.rs        |  4 ++--
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 631ed54cc024..2aac669d744a 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -128,6 +128,17 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
     }
 }
 
+/// Type used to emit diagnostic through a closure instead of implementing the `Diagnostic` trait.
+pub struct DiagDecorator<F: FnOnce(&mut Diag<'_, ()>)>(pub F);
+
+impl<'a, F: FnOnce(&mut Diag<'_, ()>)> Diagnostic<'a, ()> for DiagDecorator<F> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+        let mut diag = Diag::new(dcx, level, "");
+        (self.0)(&mut diag);
+        diag
+    }
+}
+
 /// Trait implemented by error types. This should not be implemented manually. Instead, use
 /// `#[derive(Subdiagnostic)]` -- see [rustc_macros::Subdiagnostic].
 #[rustc_diagnostic_item = "Subdiagnostic"]
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 0a111538fc89..a96eceb6c715 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -36,8 +36,8 @@
 pub use codes::*;
 pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, LintBuffer};
 pub use diagnostic::{
-    BugAbort, Diag, DiagInner, DiagLocation, DiagStyledString, Diagnostic, EmissionGuarantee,
-    FatalAbort, StringPart, Subdiag, Subdiagnostic,
+    BugAbort, Diag, DiagDecorator, DiagInner, DiagLocation, DiagStyledString, Diagnostic,
+    EmissionGuarantee, FatalAbort, StringPart, Subdiag, Subdiagnostic,
 };
 pub use diagnostic_impls::{
     DiagSymbolList, ElidedLifetimeInPathSubdiag, ExpectedLifetimeParameter,

From c45bf4a888f2f9f505b50fdcadd6f6ab85cdf786 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 15:41:35 +0100
Subject: [PATCH 0230/1059] Remove `TyCtxt::node_span_lint` usage from
 `rustc_lint`

---
 .../src/default_could_be_derived.rs           | 99 ++++++++++---------
 compiler/rustc_lint/src/transmute.rs          | 27 +++--
 2 files changed, 72 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_lint/src/default_could_be_derived.rs b/compiler/rustc_lint/src/default_could_be_derived.rs
index 0db2f6a3565c..9d4b79a45453 100644
--- a/compiler/rustc_lint/src/default_could_be_derived.rs
+++ b/compiler/rustc_lint/src/default_could_be_derived.rs
@@ -1,5 +1,5 @@
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{Applicability, Diag};
+use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, Level};
 use rustc_hir as hir;
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
@@ -147,50 +147,59 @@ fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_
 
         let hir_id = cx.tcx.local_def_id_to_hir_id(impl_id);
         let span = cx.tcx.hir_span_with_body(hir_id);
-        cx.tcx.node_span_lint(DEFAULT_OVERRIDES_DEFAULT_FIELDS, hir_id, span, |diag| {
-            mk_lint(cx.tcx, diag, type_def_id, orig_fields, fields, span);
-        });
-    }
-}
-
-fn mk_lint(
-    tcx: TyCtxt<'_>,
-    diag: &mut Diag<'_, ()>,
-    type_def_id: DefId,
-    orig_fields: FxHashMap<Symbol, &hir::FieldDef<'_>>,
-    fields: &[hir::ExprField<'_>],
-    impl_span: Span,
-) {
-    diag.primary_message("`Default` impl doesn't use the declared default field values");
-
-    // For each field in the struct expression
-    //   - if the field in the type has a default value, it should be removed
-    //   - elif the field is an expression that could be a default value, it should be used as the
-    //     field's default value (FIXME: not done).
-    //   - else, we wouldn't touch this field, it would remain in the manual impl
-    let mut removed_all_fields = true;
-    for field in fields {
-        if orig_fields.get(&field.ident.name).and_then(|f| f.default).is_some() {
-            diag.span_label(field.expr.span, "this field has a default value");
-        } else {
-            removed_all_fields = false;
-        }
-    }
-
-    if removed_all_fields {
-        let msg = "to avoid divergence in behavior between `Struct { .. }` and \
-                   `<Struct as Default>::default()`, derive the `Default`";
-        diag.multipart_suggestion(
-            msg,
-            vec![
-                (tcx.def_span(type_def_id).shrink_to_lo(), "#[derive(Default)] ".to_string()),
-                (impl_span, String::new()),
-            ],
-            Applicability::MachineApplicable,
+        cx.tcx.emit_node_span_lint(
+            DEFAULT_OVERRIDES_DEFAULT_FIELDS,
+            hir_id,
+            span,
+            WrongDefaultImpl { tcx: cx.tcx, type_def_id, orig_fields, fields, impl_span: span },
         );
-    } else {
-        let msg = "use the default values in the `impl` with `Struct { mandatory_field, .. }` to \
-                   avoid them diverging over time";
-        diag.help(msg);
+    }
+}
+
+struct WrongDefaultImpl<'a, 'hir, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    type_def_id: DefId,
+    orig_fields: FxHashMap<Symbol, &'a hir::FieldDef<'hir>>,
+    fields: &'a [hir::ExprField<'hir>],
+    impl_span: Span,
+}
+
+impl<'a, 'b, 'hir, 'tcx> Diagnostic<'a, ()> for WrongDefaultImpl<'b, 'hir, 'tcx> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+        let Self { tcx, type_def_id, orig_fields, fields, impl_span } = self;
+        let mut diag =
+            Diag::new(dcx, level, "`Default` impl doesn't use the declared default field values");
+
+        // For each field in the struct expression
+        //   - if the field in the type has a default value, it should be removed
+        //   - elif the field is an expression that could be a default value, it should be used as the
+        //     field's default value (FIXME: not done).
+        //   - else, we wouldn't touch this field, it would remain in the manual impl
+        let mut removed_all_fields = true;
+        for field in fields {
+            if orig_fields.get(&field.ident.name).and_then(|f| f.default).is_some() {
+                diag.span_label(field.expr.span, "this field has a default value");
+            } else {
+                removed_all_fields = false;
+            }
+        }
+
+        if removed_all_fields {
+            diag.multipart_suggestion(
+                "to avoid divergence in behavior between `Struct { .. }` and \
+                 `<Struct as Default>::default()`, derive the `Default`",
+                vec![
+                    (tcx.def_span(type_def_id).shrink_to_lo(), "#[derive(Default)] ".to_string()),
+                    (impl_span, String::new()),
+                ],
+                Applicability::MachineApplicable,
+            );
+        } else {
+            diag.help(
+                "use the default values in the `impl` with `Struct { mandatory_field, .. }` to \
+                       avoid them diverging over time",
+            );
+        }
+        diag
     }
 }
diff --git a/compiler/rustc_lint/src/transmute.rs b/compiler/rustc_lint/src/transmute.rs
index cbb9ca6aa00f..4ee25ac008eb 100644
--- a/compiler/rustc_lint/src/transmute.rs
+++ b/compiler/rustc_lint/src/transmute.rs
@@ -357,15 +357,24 @@ fn check_unnecessary_transmute<'tcx>(
         _ => return,
     };
 
-    cx.tcx.node_span_lint(UNNECESSARY_TRANSMUTES, expr.hir_id, expr.span, |diag| {
-        diag.primary_message("unnecessary transmute");
-        if let Some(sugg) = sugg {
-            diag.multipart_suggestion("replace this with", sugg, Applicability::MachineApplicable);
-        }
-        if let Some(help) = help {
-            diag.help(help);
-        }
-    });
+    cx.tcx.emit_node_span_lint(
+        UNNECESSARY_TRANSMUTES,
+        expr.hir_id,
+        expr.span,
+        rustc_errors::DiagDecorator(|diag| {
+            diag.primary_message("unnecessary transmute");
+            if let Some(sugg) = sugg {
+                diag.multipart_suggestion(
+                    "replace this with",
+                    sugg,
+                    Applicability::MachineApplicable,
+                );
+            }
+            if let Some(help) = help {
+                diag.help(help);
+            }
+        }),
+    );
 }
 
 #[derive(Diagnostic)]

From 01aff0d7fa7b81dff674a282832b49a76d8af0f6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 16:09:48 +0100
Subject: [PATCH 0231/1059] Remove `TyCtxt::node_span_lint` usage from
 `rustc_middle`

---
 compiler/rustc_middle/src/middle/stability.rs      | 11 ++++++++---
 compiler/rustc_middle/src/mir/interpret/queries.rs | 13 +++++++------
 compiler/rustc_middle/src/ty/context.rs            | 13 +++++++++----
 3 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 628d35814684..06e4a287460b 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -564,9 +564,14 @@ pub fn check_optional_stability(
         unmarked: impl FnOnce(Span, DefId),
     ) -> bool {
         let soft_handler = |lint, span, msg: String| {
-            self.node_span_lint(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, |lint| {
-                lint.primary_message(msg);
-            })
+            self.emit_node_span_lint(
+                lint,
+                id.unwrap_or(hir::CRATE_HIR_ID),
+                span,
+                rustc_errors::DiagDecorator(|lint| {
+                    lint.primary_message(msg);
+                }),
+            );
         };
         let eval_result =
             self.eval_stability_allow_unstable(def_id, id, span, method_span, allow_unstable);
diff --git a/compiler/rustc_middle/src/mir/interpret/queries.rs b/compiler/rustc_middle/src/mir/interpret/queries.rs
index 89034981cbd6..2b7fd3eac99d 100644
--- a/compiler/rustc_middle/src/mir/interpret/queries.rs
+++ b/compiler/rustc_middle/src/mir/interpret/queries.rs
@@ -1,5 +1,6 @@
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
+use rustc_macros::Diagnostic;
 use rustc_session::lint;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
@@ -93,6 +94,10 @@ pub fn const_eval_resolve_for_typeck(
         ct: ty::UnevaluatedConst<'tcx>,
         span: Span,
     ) -> ConstToValTreeResult<'tcx> {
+        #[derive(Diagnostic)]
+        #[diag("cannot use constants which depend on generic parameters in types")]
+        struct ConstDependingOnGenericParam;
+
         // Cannot resolve `Unevaluated` constants that contain inference
         // variables. We reject those here since `resolve`
         // would fail otherwise.
@@ -139,15 +144,11 @@ pub fn const_eval_resolve_for_typeck(
                 let mir_body = self.mir_for_ctfe(cid.instance.def_id());
                 if mir_body.is_polymorphic {
                     let Some(local_def_id) = ct.def.as_local() else { return };
-                    self.node_span_lint(
+                    self.emit_node_span_lint(
                         lint::builtin::CONST_EVALUATABLE_UNCHECKED,
                         self.local_def_id_to_hir_id(local_def_id),
                         self.def_span(ct.def),
-                        |lint| {
-                            lint.primary_message(
-                                "cannot use constants which depend on generic parameters in types",
-                            );
-                        },
+                        ConstDependingOnGenericParam,
                     )
                 }
             }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 64af9e7f0998..80f748f64087 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -38,6 +38,7 @@
 use rustc_hir::limit::Limit;
 use rustc_hir::{self as hir, CRATE_HIR_ID, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
+use rustc_macros::Diagnostic;
 use rustc_session::Session;
 use rustc_session::config::CrateType;
 use rustc_session::cstore::{CrateStoreDyn, Untracked};
@@ -1685,6 +1686,12 @@ pub fn finish(self) {
     }
 
     pub fn report_unused_features(self) {
+        #[derive(Diagnostic)]
+        #[diag("feature `{$feature}` is declared but not used")]
+        struct UnusedFeature {
+            feature: Symbol,
+        }
+
         // Collect first to avoid holding the lock while linting.
         let used_features = self.sess.used_features.lock();
         let unused_features = self
@@ -1703,13 +1710,11 @@ pub fn report_unused_features(self) {
             .collect::<Vec<_>>();
 
         for (feature, span) in unused_features {
-            self.node_span_lint(
+            self.emit_node_span_lint(
                 rustc_session::lint::builtin::UNUSED_FEATURES,
                 CRATE_HIR_ID,
                 span,
-                |lint| {
-                    lint.primary_message(format!("feature `{}` is declared but not used", feature));
-                },
+                UnusedFeature { feature },
             );
         }
     }

From 0d974a2cc044c58e6b2ae9df4014c0cf03262aef Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 16:17:10 +0100
Subject: [PATCH 0232/1059] Remove `TyCtxt::node_span_lint` usage from
 `rustc_mir_build`

---
 .../src/thir/pattern/migration.rs             |  13 +-
 .../migration_lint.stderr                     | 128 +++++++++---------
 2 files changed, 73 insertions(+), 68 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/pattern/migration.rs b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
index 9a5cc08e6c4c..96021704d329 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/migration.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
@@ -55,10 +55,15 @@ pub(super) fn emit<'tcx>(self, tcx: TyCtxt<'tcx>, pat_id: HirId) {
             self.format_subdiagnostics(&mut err);
             err.emit();
         } else {
-            tcx.node_span_lint(lint::builtin::RUST_2024_INCOMPATIBLE_PAT, pat_id, spans, |diag| {
-                diag.primary_message(primary_message);
-                self.format_subdiagnostics(diag);
-            });
+            tcx.emit_node_span_lint(
+                lint::builtin::RUST_2024_INCOMPATIBLE_PAT,
+                pat_id,
+                spans,
+                rustc_errors::DiagDecorator(|diag| {
+                    diag.primary_message(primary_message);
+                    self.format_subdiagnostics(diag);
+                }),
+            );
         }
     }
 
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
index 01fcfdc8be6e..4963e80ec8cc 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
@@ -4,13 +4,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let Foo(mut x) = &Foo(0);
    |             ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:25:9
    |
 LL |     let Foo(mut x) = &Foo(0);
    |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: the lint level is defined here
   --> $DIR/migration_lint.rs:7:9
    |
@@ -27,13 +27,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let Foo(mut x) = &mut Foo(0);
    |             ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:30:9
    |
 LL |     let Foo(mut x) = &mut Foo(0);
    |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(mut x) = &mut Foo(0);
@@ -45,13 +45,13 @@ error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2
 LL |     let Foo(ref x) = &Foo(0);
    |             ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:35:9
    |
 LL |     let Foo(ref x) = &Foo(0);
    |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: remove the unnecessary binding modifier
    |
 LL -     let Foo(ref x) = &Foo(0);
@@ -64,13 +64,13 @@ error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2
 LL |     let Foo(ref x) = &mut Foo(0);
    |             ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:40:9
    |
 LL |     let Foo(ref x) = &mut Foo(0);
    |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(ref x) = &mut Foo(0);
@@ -82,13 +82,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let Foo(&x) = &Foo(&0);
    |             ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:57:9
    |
 LL |     let Foo(&x) = &Foo(&0);
    |         ^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&x) = &Foo(&0);
@@ -100,13 +100,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let Foo(&mut x) = &Foo(&mut 0);
    |             ^^^^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:62:9
    |
 LL |     let Foo(&mut x) = &Foo(&mut 0);
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&mut x) = &Foo(&mut 0);
@@ -118,13 +118,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let Foo(&x) = &mut Foo(&0);
    |             ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:67:9
    |
 LL |     let Foo(&x) = &mut Foo(&0);
    |         ^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(&x) = &mut Foo(&0);
@@ -136,13 +136,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let Foo(&mut x) = &mut Foo(&mut 0);
    |             ^^^^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:72:9
    |
 LL |     let Foo(&mut x) = &mut Foo(&mut 0);
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(&mut x) = &mut Foo(&mut 0);
@@ -154,13 +154,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     if let Some(&x) = &&&&&Some(&0u8) {
    |                 ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:81:12
    |
 LL |     if let Some(&x) = &&&&&Some(&0u8) {
    |            ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&Some(&x) = &&&&&Some(&0u8) {
@@ -172,13 +172,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
    |                 ^^^^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:87:12
    |
 LL |     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
    |            ^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
@@ -190,13 +190,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     if let Some(&x) = &&&&&mut Some(&0u8) {
    |                 ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:93:12
    |
 LL |     if let Some(&x) = &&&&&mut Some(&0u8) {
    |            ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
@@ -208,13 +208,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
    |                 ^^^^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:99:12
    |
 LL |     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
@@ -226,13 +226,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
    |                     ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:111:9
    |
 LL |     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
    |         ^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern and borrow explicitly using variable binding modes
    |
 LL |     let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
@@ -246,13 +246,13 @@ LL |     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
    |                     |
    |                     reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:117:9
    |
 LL |     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
@@ -266,13 +266,13 @@ LL |     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
    |                        |
    |                        reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:124:12
    |
 LL |     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
@@ -306,8 +306,6 @@ LL |     let [&mut [ref a]] = &mut [&mut &[0]];
    |          |
    |          reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:145:15
    |
@@ -318,6 +316,8 @@ note: matching on a reference type with a non-reference pattern implicitly borro
    |
 LL |     let [&mut [ref a]] = &mut [&mut &[0]];
    |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let &mut [&mut &[ref a]] = &mut [&mut &[0]];
@@ -329,13 +329,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let [&(_)] = &[&0];
    |          ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:150:9
    |
 LL |     let [&(_)] = &[&0];
    |         ^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&(_)] = &[&0];
@@ -349,13 +349,13 @@ LL |     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
    |                  |
    |                  explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:157:9
    |
 LL |     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: remove the unnecessary binding modifiers
    |
 LL -     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
@@ -370,13 +370,13 @@ LL |     let Struct { ref a, ref mut b, c } = &mut Struct { a: 0, b: 0, c: 0 };
    |                  |
    |                  explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:164:9
    |
 LL |     let Struct { ref a, ref mut b, c } = &mut Struct { a: 0, b: 0, c: 0 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &mut Struct { ref a, ref mut b, ref mut c } = &mut Struct { a: 0, b: 0, c: 0 };
@@ -390,13 +390,13 @@ LL |     let Struct { a: &[ref a], b: &mut [[b]], c } = &mut &Struct { a: &[0],
    |                     |
    |                     reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:172:9
    |
 LL |     let Struct { a: &[ref a], b: &mut [[b]], c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &mut &Struct { a: &[ref a], b: &mut [&[ref b]], ref c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
@@ -408,13 +408,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let Foo(&ref a) = &Foo(&0);
    |             ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:180:9
    |
 LL |     let Foo(&ref a) = &Foo(&0);
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&ref a) = &Foo(&0);
@@ -426,13 +426,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let (&a, b, [c], [(d, [e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
    |          ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:186:9
    |
 LL |     let (&a, b, [c], [(d, [e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &(&a, ref b, &[ref c], &mut [&mut (ref d, &[ref e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
@@ -444,13 +444,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let (a, [b], [mut c]) = &(0, &mut [0], &[0]);
    |                   ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:196:9
    |
 LL |     let (a, [b], [mut c]) = &(0, &mut [0], &[0]);
    |         ^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &(ref a, &mut [ref b], &[mut c]) = &(0, &mut [0], &[0]);
@@ -464,13 +464,13 @@ LL |     let (&a, (b, &[ref c])) = &(&0, &mut (0, &[0]));
    |          |
    |          reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:204:9
    |
 LL |     let (&a, (b, &[ref c])) = &(&0, &mut (0, &[0]));
    |         ^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     let &(&a, &mut (ref b, &[ref c])) = &(&0, &mut (0, &[0]));
@@ -482,13 +482,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let [mut a @ b] = &[0];
    |          ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:212:9
    |
 LL |     let [mut a @ b] = &[0];
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &[mut a @ ref b] = &[0];
@@ -500,13 +500,13 @@ error: cannot mutably bind by value within an implicitly-borrowing pattern in Ru
 LL |     let [a @ mut b] = &[0];
    |              ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:219:9
    |
 LL |     let [a @ mut b] = &[0];
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &[ref a @ mut b] = &[0];
@@ -520,8 +520,6 @@ LL |     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
    |              |
    |              reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:226:31
    |
@@ -532,6 +530,8 @@ note: matching on a reference type with a non-reference pattern implicitly borro
    |
 LL |     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
    |          ^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let [&Foo(&ref a @ ref b), &Foo(&ref c @ d)] = [&Foo(&0); 2];
@@ -545,8 +545,6 @@ LL |     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
    |              |
    |              reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:235:33
    |
@@ -557,6 +555,8 @@ note: matching on a reference type with a non-reference pattern implicitly borro
    |
 LL |     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
    |          ^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let [&Foo(&ref a @ [ref b]), &Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
@@ -586,13 +586,13 @@ error: cannot explicitly dereference within an implicitly-borrowing pattern in R
 LL |     let [&migration_lint_macros::bind_ref!(a)] = &[&0];
    |          ^ reference pattern not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:249:9
    |
 LL |     let [&migration_lint_macros::bind_ref!(a)] = &[&0];
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&migration_lint_macros::bind_ref!(a)] = &[&0];
@@ -606,13 +606,13 @@ LL |     let (mut a, ref b) = &(0, 0);
    |          |
    |          `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:255:9
    |
 LL |     let (mut a, ref b) = &(0, 0);
    |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &(mut a, ref b) = &(0, 0);
@@ -626,13 +626,13 @@ LL |     let (mut a, &b) = &(0, &0);
    |          |
    |          `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:261:9
    |
 LL |     let (mut a, &b) = &(0, &0);
    |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &(mut a, &b) = &(0, &0);
@@ -647,13 +647,13 @@ LL |     let (mut a, ref b, &c) = &(0, 0, &0);
    |          |      explicit `ref` binding modifier not allowed when implicitly borrowing
    |          `mut` binding modifier not allowed when implicitly borrowing
    |
-   = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:267:9
    |
 LL |     let (mut a, ref b, &c) = &(0, 0, &0);
    |         ^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
 help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &(mut a, ref b, &c) = &(0, 0, &0);

From 3a64713bd54add4c390271d46efbb7c4e0c9f184 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 16:27:50 +0100
Subject: [PATCH 0233/1059] Remove `TyCtxt::node_span_lint` usage from
 `rustc_mir_transform`

---
 compiler/rustc_mir_transform/src/errors.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index 6f0f9cc23a55..00b67b656459 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -19,11 +19,11 @@ pub(crate) fn emit_inline_always_target_feature_diagnostic<'a, 'tcx>(
     caller_def_id: DefId,
     callee_only: &[&'a str],
 ) {
-    tcx.node_span_lint(
+    tcx.emit_node_span_lint(
         lint::builtin::INLINE_ALWAYS_MISMATCHING_TARGET_FEATURES,
         tcx.local_def_id_to_hir_id(caller_def_id.as_local().unwrap()),
         call_span,
-        |lint| {
+        rustc_errors::DiagDecorator(|lint| {
             let callee = tcx.def_path_str(callee_def_id);
             let caller = tcx.def_path_str(caller_def_id);
 
@@ -46,7 +46,7 @@ pub(crate) fn emit_inline_always_target_feature_diagnostic<'a, 'tcx>(
                 format!("#[target_feature(enable = \"{feats}\")]\n"),
                 lint::Applicability::MaybeIncorrect,
             );
-        },
+        }),
     );
 }
 

From 4e2a519d127e8147dafb54cad9d5386c43fbb0bf Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 17:03:53 +0100
Subject: [PATCH 0234/1059] Remove `TyCtxt::node_span_lint` usage from
 `rustc_trait_selection`

---
 .../src/traits/specialize/mod.rs                    | 13 +++++++++----
 .../coherence-fn-covariant-bound-vs-static.stderr   |  2 +-
 .../ui/coherence/coherence-fn-implied-bounds.stderr |  2 +-
 tests/ui/coherence/coherence-fn-inputs.stderr       |  2 +-
 .../coherence/coherence-free-vs-bound-region.stderr |  2 +-
 tests/ui/coherence/coherence-subtyping.stderr       |  2 +-
 tests/ui/coherence/coherence-wasm-bindgen.stderr    |  4 ++--
 ...egion-constraints-on-unification.explicit.stderr |  4 ++--
 tests/ui/const-generics/invariant.stderr            |  2 +-
 9 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
index e66aa6bc4a9e..fa9d617604e5 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
@@ -578,10 +578,15 @@ fn decorate<'tcx, G: EmissionGuarantee>(
             let lint = match kind {
                 FutureCompatOverlapErrorKind::LeakCheck => COHERENCE_LEAK_CHECK,
             };
-            tcx.node_span_lint(lint, tcx.local_def_id_to_hir_id(impl_def_id), impl_span, |err| {
-                err.primary_message(msg());
-                decorate(tcx, &overlap, impl_span, err);
-            });
+            tcx.emit_node_span_lint(
+                lint,
+                tcx.local_def_id_to_hir_id(impl_def_id),
+                impl_span,
+                rustc_errors::DiagDecorator(|err| {
+                    err.primary_message(msg());
+                    decorate(tcx, &overlap, impl_span, err);
+                }),
+            );
             Ok(())
         }
     }
diff --git a/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr b/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
index 41164e99e6d0..0558def70cff 100644
--- a/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
+++ b/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
@@ -6,9 +6,9 @@ LL | impl Trait for for<'r> fn(fn(&'r ())) {}
 LL | impl<'a> Trait for fn(fn(&'a ())) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `for<'r> fn(fn(&'r ()))`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = note: `#[warn(coherence_leak_check)]` (part of `#[warn(future_incompatible)]`) on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/coherence-fn-implied-bounds.stderr b/tests/ui/coherence/coherence-fn-implied-bounds.stderr
index ece3288989d7..aaad1acb2235 100644
--- a/tests/ui/coherence/coherence-fn-implied-bounds.stderr
+++ b/tests/ui/coherence/coherence-fn-implied-bounds.stderr
@@ -7,9 +7,9 @@ LL |
 LL | impl Trait for for<'c> fn(&'c &'c u32, &'c &'c u32) -> &'c u32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `for<'a, 'b> fn(&'a &'b u32, &'b &'a u32) -> &'b u32`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
 note: the lint level is defined here
   --> $DIR/coherence-fn-implied-bounds.rs:15:9
    |
diff --git a/tests/ui/coherence/coherence-fn-inputs.stderr b/tests/ui/coherence/coherence-fn-inputs.stderr
index 75df33913a97..6a0f2ee2b1c2 100644
--- a/tests/ui/coherence/coherence-fn-inputs.stderr
+++ b/tests/ui/coherence/coherence-fn-inputs.stderr
@@ -6,9 +6,9 @@ LL | impl Trait for for<'a, 'b> fn(&'a u32, &'b u32) {}
 LL | impl Trait for for<'c> fn(&'c u32, &'c u32) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `for<'a, 'b> fn(&'a u32, &'b u32)`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = note: `#[warn(coherence_leak_check)]` (part of `#[warn(future_incompatible)]`) on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/coherence-free-vs-bound-region.stderr b/tests/ui/coherence/coherence-free-vs-bound-region.stderr
index e45cf5ad3a4c..9884e1b041ad 100644
--- a/tests/ui/coherence/coherence-free-vs-bound-region.stderr
+++ b/tests/ui/coherence/coherence-free-vs-bound-region.stderr
@@ -7,9 +7,9 @@ LL |
 LL | impl TheTrait for fn(&u8) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `fn(&u8)`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
 note: the lint level is defined here
   --> $DIR/coherence-free-vs-bound-region.rs:10:9
    |
diff --git a/tests/ui/coherence/coherence-subtyping.stderr b/tests/ui/coherence/coherence-subtyping.stderr
index f380ea878291..7817d929da97 100644
--- a/tests/ui/coherence/coherence-subtyping.stderr
+++ b/tests/ui/coherence/coherence-subtyping.stderr
@@ -7,9 +7,9 @@ LL |
 LL | impl TheTrait for for<'a> fn(&'a u8, &'a u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = note: `#[warn(coherence_leak_check)]` (part of `#[warn(future_incompatible)]`) on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/coherence-wasm-bindgen.stderr b/tests/ui/coherence/coherence-wasm-bindgen.stderr
index 939f1fce9a40..65c64b9beece 100644
--- a/tests/ui/coherence/coherence-wasm-bindgen.stderr
+++ b/tests/ui/coherence/coherence-wasm-bindgen.stderr
@@ -13,10 +13,10 @@ LL | |     A: RefFromWasmAbi,
 LL | |     R: ReturnWasmAbi,
    | |_____________________^ conflicting implementation for `&dyn Fn(&_) -> _`
    |
-   = warning: the behavior may change in a future release
-   = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
    = note: downstream crates may implement trait `FromWasmAbi` for type `&_`
    = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
+   = warning: the behavior may change in a future release
+   = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
 note: the lint level is defined here
   --> $DIR/coherence-wasm-bindgen.rs:10:9
    |
diff --git a/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr b/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
index 8d59cbc3466b..697a1bc81dbf 100644
--- a/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
+++ b/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
@@ -6,10 +6,10 @@ LL | impl<T: ?Sized + Marker> FnMarker for fn(T) {}
 LL | impl<T: ?Sized> FnMarker for fn(&T) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `fn(&_)`
    |
-   = warning: the behavior may change in a future release
-   = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
    = note: downstream crates may implement trait `Marker` for type `&_`
    = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
+   = warning: the behavior may change in a future release
+   = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
 note: the lint level is defined here
   --> $DIR/negative-coherence-placeholder-region-constraints-on-unification.rs:4:11
    |
diff --git a/tests/ui/const-generics/invariant.stderr b/tests/ui/const-generics/invariant.stderr
index 095219f6e5fa..465f708d8f13 100644
--- a/tests/ui/const-generics/invariant.stderr
+++ b/tests/ui/const-generics/invariant.stderr
@@ -7,9 +7,9 @@ LL | impl SadBee for for<'a> fn(&'a ()) {
 LL | impl SadBee for fn(&'static ()) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `for<'a> fn(&'a ())`
    |
+   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = warning: the behavior may change in a future release
    = note: for more information, see issue #56105 <https://github.com/rust-lang/rust/issues/56105>
-   = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
    = note: `#[warn(coherence_leak_check)]` (part of `#[warn(future_incompatible)]`) on by default
 
 error[E0308]: mismatched types

From 344344b83ec89d42b50dc4168c3766528e37ce2a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Mar 2026 19:01:31 +0100
Subject: [PATCH 0235/1059] Remove `TyCtxt::node_span_lint` usage from
 `librustdoc`

---
 src/librustdoc/html/markdown.rs               |  15 +-
 .../passes/check_doc_test_visibility.rs       |  24 ++-
 .../passes/collect_intra_doc_links.rs         | 109 +++++++------
 .../passes/lint/check_code_block_syntax.rs    | 118 ++++++++------
 src/librustdoc/passes/lint/html_tags.rs       | 149 +++++++++---------
 .../passes/lint/redundant_explicit_links.rs   | 113 +++++++++++--
 .../passes/lint/unescaped_backticks.rs        |   4 +-
 7 files changed, 325 insertions(+), 207 deletions(-)

diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index c472c20a7dc7..2171ca989779 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -799,14 +799,7 @@ pub(crate) fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId, sp: Span) -> ExtraInfo<
     }
 
     fn error_invalid_codeblock_attr(&self, msg: impl Into<DiagMessage>) {
-        self.tcx.node_span_lint(
-            crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
-            self.tcx.local_def_id_to_hir_id(self.def_id),
-            self.sp,
-            |lint| {
-                lint.primary_message(msg);
-            },
-        );
+        self.error_invalid_codeblock_attr_with_help(msg, |_| {});
     }
 
     fn error_invalid_codeblock_attr_with_help(
@@ -814,14 +807,14 @@ fn error_invalid_codeblock_attr_with_help(
         msg: impl Into<DiagMessage>,
         f: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
     ) {
-        self.tcx.node_span_lint(
+        self.tcx.emit_node_span_lint(
             crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
             self.tcx.local_def_id_to_hir_id(self.def_id),
             self.sp,
-            |lint| {
+            rustc_errors::DiagDecorator(|lint| {
                 lint.primary_message(msg);
                 f(lint);
-            },
+            }),
         );
     }
 }
diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs
index 39116061f485..40dfdb890d66 100644
--- a/src/librustdoc/passes/check_doc_test_visibility.rs
+++ b/src/librustdoc/passes/check_doc_test_visibility.rs
@@ -6,6 +6,7 @@
 //! - PRIVATE_DOC_TESTS: this lint is **STABLE** and looks for private items with doctests.
 
 use rustc_hir as hir;
+use rustc_macros::Diagnostic;
 use rustc_middle::lint::{LevelAndSource, LintLevelSource};
 use rustc_session::lint;
 use tracing::debug;
@@ -116,6 +117,14 @@ pub(crate) fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -
 }
 
 pub(crate) fn look_for_tests(cx: &DocContext<'_>, dox: &str, item: &Item) {
+    #[derive(Diagnostic)]
+    #[diag("missing code example in this documentation")]
+    struct MissingCodeExample;
+
+    #[derive(Diagnostic)]
+    #[diag("documentation test in private item")]
+    struct DoctestInPrivateItem;
+
     let Some(hir_id) = DocContext::as_local_hir_id(cx.tcx, item.item_id) else {
         // If non-local, no need to check anything.
         return;
@@ -129,20 +138,21 @@ pub(crate) fn look_for_tests(cx: &DocContext<'_>, dox: &str, item: &Item) {
         if should_have_doc_example(cx, item) {
             debug!("reporting error for {item:?} (hir_id={hir_id:?})");
             let sp = item.attr_span(cx.tcx);
-            cx.tcx.node_span_lint(crate::lint::MISSING_DOC_CODE_EXAMPLES, hir_id, sp, |lint| {
-                lint.primary_message("missing code example in this documentation");
-            });
+            cx.tcx.emit_node_span_lint(
+                crate::lint::MISSING_DOC_CODE_EXAMPLES,
+                hir_id,
+                sp,
+                MissingCodeExample,
+            );
         }
     } else if tests.found_tests > 0
         && !cx.cache.effective_visibilities.is_exported(cx.tcx, item.item_id.expect_def_id())
     {
-        cx.tcx.node_span_lint(
+        cx.tcx.emit_node_span_lint(
             crate::lint::PRIVATE_DOC_TESTS,
             hir_id,
             item.attr_span(cx.tcx),
-            |lint| {
-                lint.primary_message("documentation test in private item");
-            },
+            DoctestInPrivateItem,
         );
     }
 }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 697b35ad8e85..3e68ed950ce1 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -1914,61 +1914,70 @@ fn report_diagnostic(
 
     let sp = item.attr_span(tcx);
 
-    tcx.node_span_lint(lint, hir_id, sp, |lint| {
-        lint.primary_message(msg);
+    tcx.emit_node_span_lint(
+        lint,
+        hir_id,
+        sp,
+        rustc_errors::DiagDecorator(|lint| {
+            lint.primary_message(msg);
 
-        let (span, link_range) = match link_range {
-            MarkdownLinkRange::Destination(md_range) => {
-                let mut md_range = md_range.clone();
-                let sp =
-                    source_span_for_markdown_range(tcx, dox, &md_range, &item.attrs.doc_strings)
-                        .map(|(mut sp, _)| {
-                            while dox.as_bytes().get(md_range.start) == Some(&b' ')
-                                || dox.as_bytes().get(md_range.start) == Some(&b'`')
-                            {
-                                md_range.start += 1;
-                                sp = sp.with_lo(sp.lo() + BytePos(1));
-                            }
-                            while dox.as_bytes().get(md_range.end - 1) == Some(&b' ')
-                                || dox.as_bytes().get(md_range.end - 1) == Some(&b'`')
-                            {
-                                md_range.end -= 1;
-                                sp = sp.with_hi(sp.hi() - BytePos(1));
-                            }
-                            sp
-                        });
-                (sp, MarkdownLinkRange::Destination(md_range))
-            }
-            MarkdownLinkRange::WholeLink(md_range) => (
-                source_span_for_markdown_range(tcx, dox, md_range, &item.attrs.doc_strings)
-                    .map(|(sp, _)| sp),
-                link_range.clone(),
-            ),
-        };
+            let (span, link_range) = match link_range {
+                MarkdownLinkRange::Destination(md_range) => {
+                    let mut md_range = md_range.clone();
+                    let sp = source_span_for_markdown_range(
+                        tcx,
+                        dox,
+                        &md_range,
+                        &item.attrs.doc_strings,
+                    )
+                    .map(|(mut sp, _)| {
+                        while dox.as_bytes().get(md_range.start) == Some(&b' ')
+                            || dox.as_bytes().get(md_range.start) == Some(&b'`')
+                        {
+                            md_range.start += 1;
+                            sp = sp.with_lo(sp.lo() + BytePos(1));
+                        }
+                        while dox.as_bytes().get(md_range.end - 1) == Some(&b' ')
+                            || dox.as_bytes().get(md_range.end - 1) == Some(&b'`')
+                        {
+                            md_range.end -= 1;
+                            sp = sp.with_hi(sp.hi() - BytePos(1));
+                        }
+                        sp
+                    });
+                    (sp, MarkdownLinkRange::Destination(md_range))
+                }
+                MarkdownLinkRange::WholeLink(md_range) => (
+                    source_span_for_markdown_range(tcx, dox, md_range, &item.attrs.doc_strings)
+                        .map(|(sp, _)| sp),
+                    link_range.clone(),
+                ),
+            };
 
-        if let Some(sp) = span {
-            lint.span(sp);
-        } else {
-            // blah blah blah\nblah\nblah [blah] blah blah\nblah blah
-            //                       ^     ~~~~
-            //                       |     link_range
-            //                       last_new_line_offset
-            let md_range = link_range.inner_range().clone();
-            let last_new_line_offset = dox[..md_range.start].rfind('\n').map_or(0, |n| n + 1);
-            let line = dox[last_new_line_offset..].lines().next().unwrap_or("");
+            if let Some(sp) = span {
+                lint.span(sp);
+            } else {
+                // blah blah blah\nblah\nblah [blah] blah blah\nblah blah
+                //                       ^     ~~~~
+                //                       |     link_range
+                //                       last_new_line_offset
+                let md_range = link_range.inner_range().clone();
+                let last_new_line_offset = dox[..md_range.start].rfind('\n').map_or(0, |n| n + 1);
+                let line = dox[last_new_line_offset..].lines().next().unwrap_or("");
 
-            // Print the line containing the `md_range` and manually mark it with '^'s.
-            lint.note(format!(
-                "the link appears in this line:\n\n{line}\n\
+                // Print the line containing the `md_range` and manually mark it with '^'s.
+                lint.note(format!(
+                    "the link appears in this line:\n\n{line}\n\
                      {indicator: <before$}{indicator:^<found$}",
-                indicator = "",
-                before = md_range.start - last_new_line_offset,
-                found = md_range.len(),
-            ));
-        }
+                    indicator = "",
+                    before = md_range.start - last_new_line_offset,
+                    found = md_range.len(),
+                ));
+            }
 
-        decorate(lint, span, link_range);
-    });
+            decorate(lint, span, link_range);
+        }),
+    );
 }
 
 /// Reports a link that failed to resolve.
diff --git a/src/librustdoc/passes/lint/check_code_block_syntax.rs b/src/librustdoc/passes/lint/check_code_block_syntax.rs
index e94fd996947b..1c017f9a635c 100644
--- a/src/librustdoc/passes/lint/check_code_block_syntax.rs
+++ b/src/librustdoc/passes/lint/check_code_block_syntax.rs
@@ -6,13 +6,13 @@
 use rustc_data_structures::sync::Lock;
 use rustc_errors::emitter::Emitter;
 use rustc_errors::formatting::format_diag_message;
-use rustc_errors::{Applicability, DiagCtxt, DiagInner};
+use rustc_errors::{Applicability, Diag, DiagCtxt, DiagCtxtHandle, DiagInner, Diagnostic, Level};
 use rustc_parse::{source_str_to_stream, unwrap_or_emit_fatal};
 use rustc_resolve::rustdoc::source_span_for_markdown_range;
 use rustc_session::parse::ParseSess;
 use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId, Transparency};
 use rustc_span::source_map::{FilePathMapping, SourceMap};
-use rustc_span::{DUMMY_SP, FileName, InnerSpan};
+use rustc_span::{DUMMY_SP, FileName, InnerSpan, Span};
 
 use crate::clean;
 use crate::core::DocContext;
@@ -34,12 +34,72 @@ fn check_rust_syntax(
     dox: &str,
     code_block: RustCodeBlock,
 ) {
+    struct CodeblockError<'a> {
+        buffer: &'a Buffer,
+        code_block: RustCodeBlock,
+        span: Span,
+        is_precise_span: bool,
+    }
+
+    impl<'a, 'b> Diagnostic<'a, ()> for CodeblockError<'b> {
+        fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+            let Self { buffer, code_block, span, is_precise_span } = self;
+
+            let mut lint = Diag::new(
+                dcx,
+                level,
+                if buffer.has_errors {
+                    "could not parse code block as Rust code"
+                } else {
+                    "Rust code block is empty"
+                },
+            );
+
+            let empty_block = code_block.lang_string == Default::default() && code_block.is_fenced;
+            let is_ignore = code_block.lang_string.ignore != markdown::Ignore::None;
+
+            let explanation = if is_ignore {
+                "`ignore` code blocks require valid Rust code for syntax highlighting; \
+                 mark blocks that do not contain Rust code as text"
+            } else {
+                "mark blocks that do not contain Rust code as text"
+            };
+
+            if is_precise_span {
+                if is_ignore {
+                    // Giving an accurate suggestion is hard because `ignore` might not have come
+                    // first in the list. Just give a `help` instead.
+                    lint.span_help(
+                        span.from_inner(InnerSpan::new(0, 3)),
+                        format!("{explanation}: ```text"),
+                    );
+                } else if empty_block {
+                    lint.span_suggestion(
+                        span.from_inner(InnerSpan::new(0, 3)).shrink_to_hi(),
+                        explanation,
+                        "text",
+                        Applicability::MachineApplicable,
+                    );
+                }
+            } else if empty_block || is_ignore {
+                lint.help(format!("{explanation}: ```text"));
+            }
+
+            // FIXME(#67563): Provide more context for these errors by displaying the spans inline.
+            for message in buffer.messages.iter() {
+                lint.note(message.clone());
+            }
+
+            lint
+        }
+    }
+
     let buffer = Arc::new(Lock::new(Buffer::default()));
     let emitter = BufferEmitter { buffer: Arc::clone(&buffer) };
 
     let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
     let dcx = DiagCtxt::new(Box::new(emitter)).disable_warnings();
-    let source = dox[code_block.code]
+    let source = dox[code_block.code.clone()]
         .lines()
         .map(|line| crate::html::markdown::map_line(line).for_code())
         .intersperse(Cow::Borrowed("\n"))
@@ -75,11 +135,8 @@ fn check_rust_syntax(
         return;
     };
 
-    let empty_block = code_block.lang_string == Default::default() && code_block.is_fenced;
-    let is_ignore = code_block.lang_string.ignore != markdown::Ignore::None;
-
     // The span and whether it is precise or not.
-    let (sp, precise_span) = match source_span_for_markdown_range(
+    let (span, is_precise_span) = match source_span_for_markdown_range(
         cx.tcx,
         dox,
         &code_block.range,
@@ -89,51 +146,16 @@ fn check_rust_syntax(
         None => (item.attr_span(cx.tcx), false),
     };
 
-    let msg = if buffer.has_errors {
-        "could not parse code block as Rust code"
-    } else {
-        "Rust code block is empty"
-    };
-
     // Finally build and emit the completed diagnostic.
     // All points of divergence have been handled earlier so this can be
     // done the same way whether the span is precise or not.
     let hir_id = cx.tcx.local_def_id_to_hir_id(local_id);
-    cx.tcx.node_span_lint(crate::lint::INVALID_RUST_CODEBLOCKS, hir_id, sp, |lint| {
-        lint.primary_message(msg);
-
-        let explanation = if is_ignore {
-            "`ignore` code blocks require valid Rust code for syntax highlighting; \
-                    mark blocks that do not contain Rust code as text"
-        } else {
-            "mark blocks that do not contain Rust code as text"
-        };
-
-        if precise_span {
-            if is_ignore {
-                // giving an accurate suggestion is hard because `ignore` might not have come first in the list.
-                // just give a `help` instead.
-                lint.span_help(
-                    sp.from_inner(InnerSpan::new(0, 3)),
-                    format!("{explanation}: ```text"),
-                );
-            } else if empty_block {
-                lint.span_suggestion(
-                    sp.from_inner(InnerSpan::new(0, 3)).shrink_to_hi(),
-                    explanation,
-                    "text",
-                    Applicability::MachineApplicable,
-                );
-            }
-        } else if empty_block || is_ignore {
-            lint.help(format!("{explanation}: ```text"));
-        }
-
-        // FIXME(#67563): Provide more context for these errors by displaying the spans inline.
-        for message in buffer.messages.iter() {
-            lint.note(message.clone());
-        }
-    });
+    cx.tcx.emit_node_span_lint(
+        crate::lint::INVALID_RUST_CODEBLOCKS,
+        hir_id,
+        span,
+        CodeblockError { buffer: &buffer, code_block, span, is_precise_span },
+    );
 }
 
 #[derive(Default)]
diff --git a/src/librustdoc/passes/lint/html_tags.rs b/src/librustdoc/passes/lint/html_tags.rs
index 4e374fe3cd56..86b8e7b6f86a 100644
--- a/src/librustdoc/passes/lint/html_tags.rs
+++ b/src/librustdoc/passes/lint/html_tags.rs
@@ -21,86 +21,91 @@ pub(crate) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
             Some((sp, _)) => sp,
             None => item.attr_span(tcx),
         };
-        tcx.node_span_lint(crate::lint::INVALID_HTML_TAGS, hir_id, sp, |lint| {
-            use rustc_lint_defs::Applicability;
+        tcx.emit_node_span_lint(
+            crate::lint::INVALID_HTML_TAGS,
+            hir_id,
+            sp,
+            rustc_errors::DiagDecorator(|lint| {
+                use rustc_lint_defs::Applicability;
 
-            lint.primary_message(msg);
+                lint.primary_message(msg);
 
-            // If a tag looks like `<this>`, it might actually be a generic.
-            // We don't try to detect stuff `<like, this>` because that's not valid HTML,
-            // and we don't try to detect stuff `<like this>` because that's not valid Rust.
-            let mut generics_end = range.end;
-            if is_open_tag
-                && dox[..generics_end].ends_with('>')
-                && let Some(mut generics_start) = extract_path_backwards(dox, range.start)
-            {
-                while generics_start != 0
-                    && generics_end < dox.len()
-                    && dox.as_bytes()[generics_start - 1] == b'<'
-                    && dox.as_bytes()[generics_end] == b'>'
+                // If a tag looks like `<this>`, it might actually be a generic.
+                // We don't try to detect stuff `<like, this>` because that's not valid HTML,
+                // and we don't try to detect stuff `<like this>` because that's not valid Rust.
+                let mut generics_end = range.end;
+                if is_open_tag
+                    && dox[..generics_end].ends_with('>')
+                    && let Some(mut generics_start) = extract_path_backwards(dox, range.start)
                 {
-                    generics_end += 1;
-                    generics_start -= 1;
-                    if let Some(new_start) = extract_path_backwards(dox, generics_start) {
-                        generics_start = new_start;
+                    while generics_start != 0
+                        && generics_end < dox.len()
+                        && dox.as_bytes()[generics_start - 1] == b'<'
+                        && dox.as_bytes()[generics_end] == b'>'
+                    {
+                        generics_end += 1;
+                        generics_start -= 1;
+                        if let Some(new_start) = extract_path_backwards(dox, generics_start) {
+                            generics_start = new_start;
+                        }
+                        if let Some(new_end) = extract_path_forward(dox, generics_end) {
+                            generics_end = new_end;
+                        }
                     }
                     if let Some(new_end) = extract_path_forward(dox, generics_end) {
                         generics_end = new_end;
                     }
+                    let generics_sp = match source_span_for_markdown_range(
+                        tcx,
+                        dox,
+                        &(generics_start..generics_end),
+                        &item.attrs.doc_strings,
+                    ) {
+                        Some((sp, _)) => sp,
+                        None => item.attr_span(tcx),
+                    };
+                    // Sometimes, we only extract part of a path. For example, consider this:
+                    //
+                    //     <[u32] as IntoIter<u32>>::Item
+                    //                       ^^^^^ unclosed HTML tag `u32`
+                    //
+                    // We don't have any code for parsing fully-qualified trait paths.
+                    // In theory, we could add it, but doing it correctly would require
+                    // parsing the entire path grammar, which is problematic because of
+                    // overlap between the path grammar and Markdown.
+                    //
+                    // The example above shows that ambiguity. Is `[u32]` intended to be an
+                    // intra-doc link to the u32 primitive, or is it intended to be a slice?
+                    //
+                    // If the below conditional were removed, we would suggest this, which is
+                    // not what the user probably wants.
+                    //
+                    //     <[u32] as `IntoIter<u32>`>::Item
+                    //
+                    // We know that the user actually wants to wrap the whole thing in a code
+                    // block, but the only reason we know that is because `u32` does not, in
+                    // fact, implement IntoIter. If the example looks like this:
+                    //
+                    //     <[Vec<i32>] as IntoIter<i32>::Item
+                    //
+                    // The ideal fix would be significantly different.
+                    if (generics_start > 0 && dox.as_bytes()[generics_start - 1] == b'<')
+                        || (generics_end < dox.len() && dox.as_bytes()[generics_end] == b'>')
+                    {
+                        return;
+                    }
+                    // multipart form is chosen here because ``Vec<i32>`` would be confusing.
+                    lint.multipart_suggestion(
+                        "try marking as source code",
+                        vec![
+                            (generics_sp.shrink_to_lo(), String::from("`")),
+                            (generics_sp.shrink_to_hi(), String::from("`")),
+                        ],
+                        Applicability::MaybeIncorrect,
+                    );
                 }
-                if let Some(new_end) = extract_path_forward(dox, generics_end) {
-                    generics_end = new_end;
-                }
-                let generics_sp = match source_span_for_markdown_range(
-                    tcx,
-                    dox,
-                    &(generics_start..generics_end),
-                    &item.attrs.doc_strings,
-                ) {
-                    Some((sp, _)) => sp,
-                    None => item.attr_span(tcx),
-                };
-                // Sometimes, we only extract part of a path. For example, consider this:
-                //
-                //     <[u32] as IntoIter<u32>>::Item
-                //                       ^^^^^ unclosed HTML tag `u32`
-                //
-                // We don't have any code for parsing fully-qualified trait paths.
-                // In theory, we could add it, but doing it correctly would require
-                // parsing the entire path grammar, which is problematic because of
-                // overlap between the path grammar and Markdown.
-                //
-                // The example above shows that ambiguity. Is `[u32]` intended to be an
-                // intra-doc link to the u32 primitive, or is it intended to be a slice?
-                //
-                // If the below conditional were removed, we would suggest this, which is
-                // not what the user probably wants.
-                //
-                //     <[u32] as `IntoIter<u32>`>::Item
-                //
-                // We know that the user actually wants to wrap the whole thing in a code
-                // block, but the only reason we know that is because `u32` does not, in
-                // fact, implement IntoIter. If the example looks like this:
-                //
-                //     <[Vec<i32>] as IntoIter<i32>::Item
-                //
-                // The ideal fix would be significantly different.
-                if (generics_start > 0 && dox.as_bytes()[generics_start - 1] == b'<')
-                    || (generics_end < dox.len() && dox.as_bytes()[generics_end] == b'>')
-                {
-                    return;
-                }
-                // multipart form is chosen here because ``Vec<i32>`` would be confusing.
-                lint.multipart_suggestion(
-                    "try marking as source code",
-                    vec![
-                        (generics_sp.shrink_to_lo(), String::from("`")),
-                        (generics_sp.shrink_to_hi(), String::from("`")),
-                    ],
-                    Applicability::MaybeIncorrect,
-                );
-            }
-        });
+            }),
+        );
     };
 
     let mut tagp = TagParser::new();
diff --git a/src/librustdoc/passes/lint/redundant_explicit_links.rs b/src/librustdoc/passes/lint/redundant_explicit_links.rs
index e49f54f6df94..84dba5d2f115 100644
--- a/src/librustdoc/passes/lint/redundant_explicit_links.rs
+++ b/src/librustdoc/passes/lint/redundant_explicit_links.rs
@@ -1,7 +1,7 @@
 use std::ops::Range;
 
 use rustc_ast::NodeId;
-use rustc_errors::SuggestionStyle;
+use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, Level, SuggestionStyle};
 use rustc_hir::HirId;
 use rustc_hir::def::{DefKind, DocLinkResMap, Namespace, Res};
 use rustc_lint_defs::Applicability;
@@ -9,8 +9,8 @@
     BrokenLink, BrokenLinkCallback, CowStr, Event, LinkType, OffsetIter, Parser, Tag,
 };
 use rustc_resolve::rustdoc::{prepare_to_doc_link_resolution, source_span_for_markdown_range};
-use rustc_span::Symbol;
 use rustc_span::def_id::DefId;
+use rustc_span::{Span, Symbol};
 
 use crate::clean::Item;
 use crate::clean::utils::{find_nearest_parent_module, inherits_doc_hidden};
@@ -154,6 +154,42 @@ fn check_inline_or_reference_unknown_redundancy(
     link_data: LinkData,
     (open, close): (u8, u8),
 ) -> Option<()> {
+    struct RedundantExplicitLinks {
+        explicit_span: Span,
+        display_span: Span,
+        link_span: Span,
+        display_link: String,
+    }
+
+    impl<'a> Diagnostic<'a, ()> for RedundantExplicitLinks {
+        fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+            let Self { explicit_span, display_span, link_span, display_link } = self;
+
+            let mut diag = Diag::new(dcx, level, "redundant explicit link target")
+                .with_span_label(
+                    explicit_span,
+                    "explicit target is redundant",
+                )
+                .with_span_label(
+                    display_span,
+                    "because label contains path that resolves to same destination",
+                )
+                .with_note(
+                    "when a link's destination is not specified,\nthe label is used to resolve intra-doc links"
+                );
+            // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
+            // FIXME2 (GuillaumeGomez): Why isn't there a `with_` equivalent for this method?
+            diag.span_suggestion_with_style(
+                link_span,
+                "remove explicit link target",
+                format!("[{}]", display_link),
+                Applicability::MaybeIncorrect,
+                SuggestionStyle::ShowAlways,
+            );
+            diag
+        }
+    }
+
     let (resolvable_link, resolvable_link_range) =
         (&link_data.resolvable_link?, &link_data.resolvable_link_range?);
     let (dest_res, display_res) =
@@ -192,13 +228,17 @@ fn check_inline_or_reference_unknown_redundancy(
             return None;
         };
 
-        cx.tcx.node_span_lint(crate::lint::REDUNDANT_EXPLICIT_LINKS, hir_id, explicit_span, |lint| {
-            lint.primary_message("redundant explicit link target")
-                .span_label(explicit_span, "explicit target is redundant")
-                .span_label(display_span, "because label contains path that resolves to same destination")
-                .note("when a link's destination is not specified,\nthe label is used to resolve intra-doc links")
-                .span_suggestion_with_style(link_span, "remove explicit link target", format!("[{}]", link_data.display_link), Applicability::MaybeIncorrect, SuggestionStyle::ShowAlways);
-        });
+        cx.tcx.emit_node_span_lint(
+            crate::lint::REDUNDANT_EXPLICIT_LINKS,
+            hir_id,
+            explicit_span,
+            RedundantExplicitLinks {
+                explicit_span,
+                display_span,
+                link_span,
+                display_link: link_data.display_link,
+            },
+        );
     }
 
     None
@@ -215,6 +255,41 @@ fn check_reference_redundancy(
     dest: &CowStr<'_>,
     link_data: LinkData,
 ) -> Option<()> {
+    struct RedundantExplicitLinkTarget {
+        explicit_span: Span,
+        display_span: Span,
+        def_span: Span,
+        link_span: Span,
+        display_link: String,
+    }
+
+    impl<'a> Diagnostic<'a, ()> for RedundantExplicitLinkTarget {
+        fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+            let Self { explicit_span, display_span, def_span, link_span, display_link } = self;
+
+            let mut diag = Diag::new(dcx, level, "redundant explicit link target")
+                .with_span_label(explicit_span, "explicit target is redundant")
+                .with_span_label(
+                    display_span,
+                    "because label contains path that resolves to same destination",
+                )
+                .with_span_note(def_span, "referenced explicit link target defined here")
+                .with_note(
+                    "when a link's destination is not specified,\nthe label is used to resolve intra-doc links"
+                );
+            // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
+            // FIXME2 (GuillaumeGomez): Why isn't there a `with_` equivalent for this method?
+            diag.span_suggestion_with_style(
+                link_span,
+                "remove explicit link target",
+                format!("[{}]", display_link),
+                Applicability::MaybeIncorrect,
+                SuggestionStyle::ShowAlways,
+            );
+            diag
+        }
+    }
+
     let (resolvable_link, resolvable_link_range) =
         (&link_data.resolvable_link?, &link_data.resolvable_link_range?);
     let (dest_res, display_res) =
@@ -259,14 +334,18 @@ fn check_reference_redundancy(
             &item.attrs.doc_strings,
         )?;
 
-        cx.tcx.node_span_lint(crate::lint::REDUNDANT_EXPLICIT_LINKS, hir_id, explicit_span, |lint| {
-            lint.primary_message("redundant explicit link target")
-            .span_label(explicit_span, "explicit target is redundant")
-                .span_label(display_span, "because label contains path that resolves to same destination")
-                .span_note(def_span, "referenced explicit link target defined here")
-                .note("when a link's destination is not specified,\nthe label is used to resolve intra-doc links")
-                .span_suggestion_with_style(link_span, "remove explicit link target", format!("[{}]", link_data.display_link), Applicability::MaybeIncorrect, SuggestionStyle::ShowAlways);
-        });
+        cx.tcx.emit_node_span_lint(
+            crate::lint::REDUNDANT_EXPLICIT_LINKS,
+            hir_id,
+            explicit_span,
+            RedundantExplicitLinkTarget {
+                explicit_span,
+                display_span,
+                def_span,
+                link_span,
+                display_link: link_data.display_link,
+            },
+        );
     }
 
     None
diff --git a/src/librustdoc/passes/lint/unescaped_backticks.rs b/src/librustdoc/passes/lint/unescaped_backticks.rs
index b791e024545f..4c33b82d14b4 100644
--- a/src/librustdoc/passes/lint/unescaped_backticks.rs
+++ b/src/librustdoc/passes/lint/unescaped_backticks.rs
@@ -52,7 +52,7 @@ pub(crate) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
                     None => item.attr_span(tcx),
                 };
 
-                tcx.node_span_lint(crate::lint::UNESCAPED_BACKTICKS, hir_id, span, |lint| {
+                tcx.emit_node_span_lint(crate::lint::UNESCAPED_BACKTICKS, hir_id, span, rustc_errors::DiagDecorator(|lint| {
                     lint.primary_message("unescaped backtick");
 
                     let mut help_emitted = false;
@@ -156,7 +156,7 @@ pub(crate) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
                         '\\',
                         "if you meant to use a literal backtick, escape it",
                     );
-                });
+                }));
             }
             Event::Code(_) => {
                 let element = element_stack

From d31a17fb0f783717a884928246947c139b207a4d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 8 Mar 2026 15:29:54 +0100
Subject: [PATCH 0236/1059] Use `DiagDecorator` instead of `derive(Diagnostic)`
 in `compiler/rustc_middle/src/mir/interpret/queries.rs`

---
 compiler/rustc_middle/src/mir/interpret/queries.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/interpret/queries.rs b/compiler/rustc_middle/src/mir/interpret/queries.rs
index 2b7fd3eac99d..00ac8e66cda7 100644
--- a/compiler/rustc_middle/src/mir/interpret/queries.rs
+++ b/compiler/rustc_middle/src/mir/interpret/queries.rs
@@ -1,6 +1,5 @@
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
-use rustc_macros::Diagnostic;
 use rustc_session::lint;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
@@ -94,10 +93,6 @@ pub fn const_eval_resolve_for_typeck(
         ct: ty::UnevaluatedConst<'tcx>,
         span: Span,
     ) -> ConstToValTreeResult<'tcx> {
-        #[derive(Diagnostic)]
-        #[diag("cannot use constants which depend on generic parameters in types")]
-        struct ConstDependingOnGenericParam;
-
         // Cannot resolve `Unevaluated` constants that contain inference
         // variables. We reject those here since `resolve`
         // would fail otherwise.
@@ -148,7 +143,11 @@ pub fn const_eval_resolve_for_typeck(
                         lint::builtin::CONST_EVALUATABLE_UNCHECKED,
                         self.local_def_id_to_hir_id(local_def_id),
                         self.def_span(ct.def),
-                        ConstDependingOnGenericParam,
+                        rustc_errors::DiagDecorator(|lint| {
+                            lint.primary_message(
+                                "cannot use constants which depend on generic parameters in types",
+                            );
+                        }),
                     )
                 }
             }

From e0829846cede092c09ddad33710cfedfaaab81a3 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 9 Mar 2026 12:28:02 +0200
Subject: [PATCH 0237/1059] Fix a stupid typo

---
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 83b67bf1fe1f..49594f34fd73 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1805,22 +1805,27 @@ fn resolve_type_param_assoc_type_shorthand(
                 }
                 AssocTypeShorthandResolution::Cycle => return AssocTypeShorthandResolution::Cycle,
             };
+            let (assoc_type, args) = assoc_type_and_args
+                .get_with(|(assoc_type, args)| (*assoc_type, args.as_ref()))
+                .skip_binder();
+            let args = EarlyBinder::bind(args).instantiate(interner, bounded_trait_ref.args);
+            let current_result = StoredEarlyBinder::bind((assoc_type, args.store()));
             if let Some(this_trait_resolution) = this_trait_resolution {
                 return AssocTypeShorthandResolution::Ambiguous {
                     sub_trait_resolution: Some(this_trait_resolution),
                 };
             } else if let Some(prev_resolution) = &supertraits_resolution {
-                if prev_resolution == lookup_on_bounded_trait {
-                    return AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None };
-                } else {
+                if let AssocTypeShorthandResolution::Ambiguous {
+                    sub_trait_resolution: Some(prev_resolution),
+                }
+                | AssocTypeShorthandResolution::Resolved(prev_resolution) = prev_resolution
+                    && *prev_resolution == current_result
+                {
                     continue;
+                } else {
+                    return AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None };
                 }
             } else {
-                let (assoc_type, args) = assoc_type_and_args
-                    .get_with(|(assoc_type, args)| (*assoc_type, args.as_ref()))
-                    .skip_binder();
-                let args = EarlyBinder::bind(args).instantiate(interner, bounded_trait_ref.args);
-                let current_result = StoredEarlyBinder::bind((assoc_type, args.store()));
                 supertraits_resolution = Some(match lookup_on_bounded_trait {
                     AssocTypeShorthandResolution::Resolved(_) => {
                         AssocTypeShorthandResolution::Resolved(current_result)

From 9bbe2cd55abfd7b8f1580d4f658aad4e0801e5e8 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 20:41:56 -0500
Subject: [PATCH 0238/1059] additional logging for doctest spawning

---
 src/librustdoc/doctest.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 5d3715c70e08..a61f85bd4007 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -32,7 +32,7 @@
 use rustc_span::{FileName, RemapPathScopeComponents, Span};
 use rustc_target::spec::{Target, TargetTuple};
 use tempfile::{Builder as TempFileBuilder, TempDir};
-use tracing::debug;
+use tracing::{debug, info};
 
 use self::rust::HirCollector;
 use crate::config::{MergeDoctests, Options as RustdocOptions, OutputFormat};
@@ -692,7 +692,7 @@ fn run_test(
         compiler.stderr(Stdio::piped());
     }
 
-    debug!("compiler invocation for doctest: {compiler:?}");
+    info!("compiler invocation for doctest: {compiler:?}");
 
     let mut child = match compiler.spawn() {
         Ok(child) => child,
@@ -759,7 +759,7 @@ fn run_test(
             runner_compiler.stderr(Stdio::inherit());
         }
         runner_compiler.arg("--error-format=short");
-        debug!("compiler invocation for doctest runner: {runner_compiler:?}");
+        info!("compiler invocation for doctest runner: {runner_compiler:?}");
 
         let status = if !status.success() {
             status
@@ -859,6 +859,8 @@ fn drop(&mut self) {
         cmd.current_dir(run_directory);
     }
 
+    info!("running doctest executable: {cmd:?}");
+
     let result = if doctest.is_multiple_tests() || rustdoc_options.no_capture {
         cmd.status().map(|status| process::Output {
             status,

From 225b7e001247ff1f6bbfffa884a078a5a3545f8c Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 4 Mar 2026 11:36:25 +0100
Subject: [PATCH 0239/1059] fix ICE in `const_c_variadic` when passing ZSTs

---
 .../rustc_const_eval/src/interpret/call.rs    | 13 ++++++++----
 .../rustc_const_eval/src/interpret/stack.rs   |  4 ++--
 .../tests/pass/c-variadic-ignored-argument.rs | 21 +++++++++++++++++++
 .../const-eval/c-variadic-ignored-argument.rs | 18 ++++++++++++++++
 4 files changed, 50 insertions(+), 6 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/c-variadic-ignored-argument.rs
 create mode 100644 tests/ui/consts/const-eval/c-variadic-ignored-argument.rs

diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 25458a7cbd11..419babd39d29 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -12,7 +12,7 @@
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
 use rustc_middle::ty::{self, AdtDef, Instance, Ty, VariantDef};
 use rustc_middle::{bug, mir, span_bug};
-use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
+use rustc_target::callconv::{ArgAbi, FnAbi};
 use tracing::field::Empty;
 use tracing::{info, instrument, trace};
 
@@ -284,7 +284,7 @@ fn pass_argument<'x, 'y>(
         'tcx: 'y,
     {
         assert_eq!(callee_ty, callee_abi.layout.ty);
-        if callee_abi.mode == PassMode::Ignore {
+        if callee_abi.is_ignore() {
             // This one is skipped. Still must be made live though!
             if !already_live {
                 self.storage_live(callee_arg.as_local().unwrap())?;
@@ -450,7 +450,7 @@ pub fn init_stack_frame(
             let mut caller_args = args
                 .iter()
                 .zip(caller_fn_abi.args.iter())
-                .filter(|arg_and_abi| !matches!(arg_and_abi.1.mode, PassMode::Ignore));
+                .filter(|arg_and_abi| !arg_and_abi.1.is_ignore());
 
             // Now we have to spread them out across the callee's locals,
             // taking into account the `spread_arg`. If we could write
@@ -480,7 +480,12 @@ pub fn init_stack_frame(
 
                     // Consume the remaining arguments by putting them into the variable argument
                     // list.
-                    let varargs = self.allocate_varargs(&mut caller_args, &mut callee_args_abis)?;
+                    let varargs = self.allocate_varargs(
+                        &mut caller_args,
+                        // "Ignored" arguments aren't actually passed, so the callee should also
+                        // ignore them. (`pass_argument` does this for regular arguments.)
+                        (&mut callee_args_abis).filter(|(_, abi)| !abi.is_ignore()),
+                    )?;
                     // When the frame is dropped, these variable arguments are deallocated.
                     self.frame_mut().va_list = varargs.clone();
                     let key = self.va_list_ptr(varargs.into());
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 6da6ed2ec757..b0f34264ad84 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -631,8 +631,8 @@ impl<'a, 'tcx: 'a, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// of variadic arguments. Return a list of the places that hold those arguments.
     pub(crate) fn allocate_varargs<I, J>(
         &mut self,
-        caller_args: &mut I,
-        callee_abis: &mut J,
+        caller_args: I,
+        mut callee_abis: J,
     ) -> InterpResult<'tcx, Vec<MPlaceTy<'tcx, M::Provenance>>>
     where
         I: Iterator<Item = (&'a FnArg<'tcx, M::Provenance>, &'a ArgAbi<'tcx, Ty<'tcx>>)>,
diff --git a/src/tools/miri/tests/pass/c-variadic-ignored-argument.rs b/src/tools/miri/tests/pass/c-variadic-ignored-argument.rs
new file mode 100644
index 000000000000..b41e1b0f076a
--- /dev/null
+++ b/src/tools/miri/tests/pass/c-variadic-ignored-argument.rs
@@ -0,0 +1,21 @@
+//@ ignore-target: windows # does not ignore ZST arguments
+//@ ignore-target: powerpc # does not ignore ZST arguments
+//@ ignore-target: s390x # does not ignore ZST arguments
+//@ ignore-target: sparc # does not ignore ZST arguments
+#![feature(c_variadic)]
+
+// Some platforms ignore ZSTs, meaning that the argument is not passed, even though it is part
+// of the callee's ABI. Test that this doesn't trip any asserts.
+//
+// NOTE: this  test only succeeds when the `()` argument uses `Passmode::Ignore`. For some targets,
+// notably msvc, such arguments are not ignored, which would cause UB when attempting to read the
+// second `i32` argument while the next item in the variable argument list is `()`.
+
+fn main() {
+    unsafe extern "C" fn variadic(mut ap: ...) {
+        ap.arg::<i32>();
+        ap.arg::<i32>();
+    }
+
+    unsafe { variadic(0i32, (), 1i32) }
+}
diff --git a/tests/ui/consts/const-eval/c-variadic-ignored-argument.rs b/tests/ui/consts/const-eval/c-variadic-ignored-argument.rs
new file mode 100644
index 000000000000..fe700eea186e
--- /dev/null
+++ b/tests/ui/consts/const-eval/c-variadic-ignored-argument.rs
@@ -0,0 +1,18 @@
+//@ build-pass
+//@ compile-flags: --emit=obj
+#![feature(c_variadic)]
+#![feature(const_c_variadic)]
+#![feature(const_destruct)]
+#![crate_type = "lib"]
+
+// Regression test for when a c-variadic argument is `PassMode::Ignore`. The caller won't pass the
+// argument, but the callee ABI does have the argument. Ensure that const-eval is able to handle
+// this case without tripping any asserts.
+
+const unsafe extern "C" fn read_n<const N: usize>(_: ...) {}
+
+unsafe fn read_too_many() {
+    const { read_n::<0>((), 1i32) }
+}
+
+fn read_as<T>() -> () {}

From 36e5a99db0ead4065560ba4e22e102d73851ea57 Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Fri, 17 Oct 2025 16:49:55 +0200
Subject: [PATCH 0240/1059] add a test for tuple coercions

---
 tests/ui/tuple/coercion-never.rs     | 14 ++++++++++++++
 tests/ui/tuple/coercion-never.stderr | 25 +++++++++++++++++++++++++
 tests/ui/tuple/coercion-slice.rs     | 12 ++++++++++++
 tests/ui/tuple/coercion-slice.stderr | 14 ++++++++++++++
 4 files changed, 65 insertions(+)
 create mode 100644 tests/ui/tuple/coercion-never.rs
 create mode 100644 tests/ui/tuple/coercion-never.stderr
 create mode 100644 tests/ui/tuple/coercion-slice.rs
 create mode 100644 tests/ui/tuple/coercion-slice.stderr

diff --git a/tests/ui/tuple/coercion-never.rs b/tests/ui/tuple/coercion-never.rs
new file mode 100644
index 000000000000..3c536dd5232e
--- /dev/null
+++ b/tests/ui/tuple/coercion-never.rs
@@ -0,0 +1,14 @@
+// This test checks if tuple elements are a coercion site or not.
+// Note that the code here is a degenerate case, but you can get similar effects in real code, when
+// unifying match arms, for example.
+//
+// See also coercion-slice.rs
+
+fn main() {
+    let _: ((),) = (loop {},);
+
+    ((),) = (loop {},); //~ error: mismatched types
+
+    let x = (loop {},);
+    let _: ((),) = x; //~ error: mismatched types
+}
diff --git a/tests/ui/tuple/coercion-never.stderr b/tests/ui/tuple/coercion-never.stderr
new file mode 100644
index 000000000000..d7566f08808a
--- /dev/null
+++ b/tests/ui/tuple/coercion-never.stderr
@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> $DIR/coercion-never.rs:10:6
+   |
+LL |     ((),) = (loop {},);
+   |      ^^     ---------- this expression has type `(!,)`
+   |      |
+   |      expected `!`, found `()`
+   |
+   = note:   expected type `!`
+           found unit type `()`
+
+error[E0308]: mismatched types
+  --> $DIR/coercion-never.rs:13:20
+   |
+LL |     let _: ((),) = x;
+   |            -----   ^ expected `((),)`, found `(!,)`
+   |            |
+   |            expected due to this
+   |
+   = note: expected tuple `((),)`
+              found tuple `(!,)`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/tuple/coercion-slice.rs b/tests/ui/tuple/coercion-slice.rs
new file mode 100644
index 000000000000..250265f28ff0
--- /dev/null
+++ b/tests/ui/tuple/coercion-slice.rs
@@ -0,0 +1,12 @@
+// This test checks if tuple elements are a coercion site or not.
+// Note that the code here is a degenerate case, but you can get similar effects in real code, when
+// unifying match arms, for example.
+//
+// See also: coercion-never.rs
+
+fn main() {
+    let _: (&[u8],) = (&[],);
+
+    let y = (&[],);
+    let _: (&[u8],) = y; //~ error: mismatched types
+}
diff --git a/tests/ui/tuple/coercion-slice.stderr b/tests/ui/tuple/coercion-slice.stderr
new file mode 100644
index 000000000000..a8ae7db4490c
--- /dev/null
+++ b/tests/ui/tuple/coercion-slice.stderr
@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/coercion-slice.rs:11:23
+   |
+LL |     let _: (&[u8],) = y;
+   |            --------   ^ expected `(&[u8],)`, found `(&[_; 0],)`
+   |            |
+   |            expected due to this
+   |
+   = note: expected tuple `(&[u8],)`
+              found tuple `(&[_; 0],)`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From 3398ea27ce13a955b19ecd19b2dcdbac3836777f Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Fri, 17 Oct 2025 14:30:57 +0200
Subject: [PATCH 0241/1059] always make tuple elements a coercion site

---
 compiler/rustc_hir_typeck/src/expr.rs         | 29 +++++++++----------
 compiler/rustc_middle/src/ty/sty.rs           | 12 +++++++-
 tests/ui/loops/loop-break-value.stderr        |  4 +--
 .../regress/divergent-block-with-tail.stderr  |  4 +--
 tests/ui/tuple/array-diagnostics.rs           |  2 +-
 tests/ui/tuple/array-diagnostics.stderr       |  2 +-
 tests/ui/tuple/coercion-never.rs              |  6 ++--
 tests/ui/tuple/coercion-never.stderr          | 25 ----------------
 8 files changed, 34 insertions(+), 50 deletions(-)
 delete mode 100644 tests/ui/tuple/coercion-never.stderr

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 2de101a1e452..e45d1cf8b5e3 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1792,27 +1792,24 @@ fn check_expr_repeat(
 
     fn check_expr_tuple(
         &self,
-        elts: &'tcx [hir::Expr<'tcx>],
+        elements: &'tcx [hir::Expr<'tcx>],
         expected: Expectation<'tcx>,
         expr: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
-        let flds = expected.only_has_type(self).and_then(|ty| {
-            let ty = self.try_structurally_resolve_type(expr.span, ty);
-            match ty.kind() {
-                ty::Tuple(flds) => Some(&flds[..]),
-                _ => None,
-            }
+        let mut expectations = expected
+            .only_has_type(self)
+            .and_then(|ty| self.try_structurally_resolve_type(expr.span, ty).opt_tuple_fields())
+            .unwrap_or_default()
+            .iter();
+
+        let elements = elements.iter().map(|e| {
+            let ty = expectations.next().unwrap_or_else(|| self.next_ty_var(e.span));
+            self.check_expr_coercible_to_type(e, ty, None);
+            ty
         });
 
-        let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
-            Some(fs) if i < fs.len() => {
-                let ety = fs[i];
-                self.check_expr_coercible_to_type(e, ety, None);
-                ety
-            }
-            _ => self.check_expr_with_expectation(e, NoExpectation),
-        });
-        let tuple = Ty::new_tup_from_iter(self.tcx, elt_ts_iter);
+        let tuple = Ty::new_tup_from_iter(self.tcx, elements);
+
         if let Err(guar) = tuple.error_reported() {
             Ty::new_error(self.tcx, guar)
         } else {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index d0d8fad4b120..2acc58422902 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1592,7 +1592,8 @@ pub fn ty_adt_def(self) -> Option<AdtDef<'tcx>> {
         }
     }
 
-    /// Iterates over tuple fields.
+    /// Returns a list of tuple type arguments.
+    ///
     /// Panics when called on anything but a tuple.
     #[inline]
     pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>> {
@@ -1602,6 +1603,15 @@ pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>> {
         }
     }
 
+    /// Returns a list of tuple type arguments, or `None` if `self` isn't a tuple.
+    #[inline]
+    pub fn opt_tuple_fields(self) -> Option<&'tcx List<Ty<'tcx>>> {
+        match self.kind() {
+            Tuple(args) => Some(args),
+            _ => None,
+        }
+    }
+
     /// If the type contains variants, returns the valid range of variant indices.
     //
     // FIXME: This requires the optimized MIR in the case of coroutines.
diff --git a/tests/ui/loops/loop-break-value.stderr b/tests/ui/loops/loop-break-value.stderr
index 3b9735510bd7..8810d16ca598 100644
--- a/tests/ui/loops/loop-break-value.stderr
+++ b/tests/ui/loops/loop-break-value.stderr
@@ -232,10 +232,10 @@ LL |         break (break, break);
    |               ||      |
    |               ||      expected because of this `break`
    |               |expected because of this `break`
-   |               expected `()`, found `(!, !)`
+   |               expected `()`, found `(_, _)`
    |
    = note: expected unit type `()`
-                  found tuple `(!, !)`
+                  found tuple `(_, _)`
 
 error[E0308]: mismatched types
   --> $DIR/loop-break-value.rs:89:15
diff --git a/tests/ui/never_type/regress/divergent-block-with-tail.stderr b/tests/ui/never_type/regress/divergent-block-with-tail.stderr
index 1f205e896788..94cf5e5fa915 100644
--- a/tests/ui/never_type/regress/divergent-block-with-tail.stderr
+++ b/tests/ui/never_type/regress/divergent-block-with-tail.stderr
@@ -22,10 +22,10 @@ error[E0308]: mismatched types
 LL | fn f() -> isize {
    |           ----- expected `isize` because of return type
 LL |     (return 1, return 2)
-   |     ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `(!, !)`
+   |     ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `(_, _)`
    |
    = note: expected type `isize`
-             found tuple `(!, !)`
+             found tuple `(_, _)`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/tuple/array-diagnostics.rs b/tests/ui/tuple/array-diagnostics.rs
index 1929dab07316..0a88e9cc3a51 100644
--- a/tests/ui/tuple/array-diagnostics.rs
+++ b/tests/ui/tuple/array-diagnostics.rs
@@ -1,7 +1,7 @@
 fn main() {
     let _tmp = [
         ("C200B40A82", 3),
-        ("C200B40A83", 4) //~ ERROR: expected function, found `(&'static str, {integer})` [E0618]
+        ("C200B40A83", 4) //~ ERROR: expected function, found `(&str, {integer})` [E0618]
         ("C200B40A8537", 5),
     ];
 }
diff --git a/tests/ui/tuple/array-diagnostics.stderr b/tests/ui/tuple/array-diagnostics.stderr
index 629ca2b37fa5..b8f7840ea4b6 100644
--- a/tests/ui/tuple/array-diagnostics.stderr
+++ b/tests/ui/tuple/array-diagnostics.stderr
@@ -1,4 +1,4 @@
-error[E0618]: expected function, found `(&'static str, {integer})`
+error[E0618]: expected function, found `(&str, {integer})`
   --> $DIR/array-diagnostics.rs:4:9
    |
 LL |         ("C200B40A83", 4)
diff --git a/tests/ui/tuple/coercion-never.rs b/tests/ui/tuple/coercion-never.rs
index 3c536dd5232e..3e4c4480c6f1 100644
--- a/tests/ui/tuple/coercion-never.rs
+++ b/tests/ui/tuple/coercion-never.rs
@@ -3,12 +3,14 @@
 // unifying match arms, for example.
 //
 // See also coercion-slice.rs
+//
+//@ check-pass
 
 fn main() {
     let _: ((),) = (loop {},);
 
-    ((),) = (loop {},); //~ error: mismatched types
+    ((),) = (loop {},);
 
     let x = (loop {},);
-    let _: ((),) = x; //~ error: mismatched types
+    let _: ((),) = x;
 }
diff --git a/tests/ui/tuple/coercion-never.stderr b/tests/ui/tuple/coercion-never.stderr
deleted file mode 100644
index d7566f08808a..000000000000
--- a/tests/ui/tuple/coercion-never.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/coercion-never.rs:10:6
-   |
-LL |     ((),) = (loop {},);
-   |      ^^     ---------- this expression has type `(!,)`
-   |      |
-   |      expected `!`, found `()`
-   |
-   = note:   expected type `!`
-           found unit type `()`
-
-error[E0308]: mismatched types
-  --> $DIR/coercion-never.rs:13:20
-   |
-LL |     let _: ((),) = x;
-   |            -----   ^ expected `((),)`, found `(!,)`
-   |            |
-   |            expected due to this
-   |
-   = note: expected tuple `((),)`
-              found tuple `(!,)`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.

From 76a750a531d36acef812cddefa87c18b47612e95 Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Wed, 29 Oct 2025 19:29:29 +0100
Subject: [PATCH 0242/1059] miri/const eval: support `MaybeDangling`

---
 .../src/interpret/validity.rs                 | 69 ++++++++++++-------
 .../src/borrow_tracker/stacked_borrows/mod.rs |  4 ++
 .../src/borrow_tracker/tree_borrows/mod.rs    |  3 +
 .../maybe_dangling_unalighed.rs               | 15 ++++
 .../maybe_dangling_unalighed.stderr           | 13 ++++
 .../fail/validity/maybe_dangling_null.rs      | 13 ++++
 .../fail/validity/maybe_dangling_null.stderr  | 13 ++++
 .../tests/pass/both_borrows/maybe_dangling.rs | 59 ++++++++++++++++
 .../stacked_borrows/stack-printing.stdout     |  4 +-
 9 files changed, 167 insertions(+), 26 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
 create mode 100644 src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
 create mode 100644 src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
 create mode 100644 src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
 create mode 100644 src/tools/miri/tests/pass/both_borrows/maybe_dangling.rs

diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 2cf490350e90..b72927f455c7 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -7,6 +7,7 @@
 use std::borrow::Cow;
 use std::fmt::Write;
 use std::hash::Hash;
+use std::mem;
 use std::num::NonZero;
 
 use either::{Left, Right};
@@ -288,6 +289,8 @@ struct ValidityVisitor<'rt, 'tcx, M: Machine<'tcx>> {
     /// If this is `Some`, then `reset_provenance_and_padding` must be true (but not vice versa:
     /// we might not track data vs padding bytes if the operand isn't stored in memory anyway).
     data_bytes: Option<RangeSet>,
+    /// True if we are inside of `MaybeDangling`. This disables pointer access checks.
+    may_dangle: bool,
 }
 
 impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
@@ -489,7 +492,8 @@ fn check_safe_pointer(
         if place.layout.is_unsized() {
             self.check_wide_ptr_meta(place.meta(), place.layout)?;
         }
-        // Make sure this is dereferenceable and all.
+
+        // Determine size and alignment of pointee.
         let size_and_align = try_validation!(
             self.ecx.size_and_align_of_val(&place),
             self.path,
@@ -503,27 +507,33 @@ fn check_safe_pointer(
             // alignment and size determined by the layout (size will be 0,
             // alignment should take attributes into account).
             .unwrap_or_else(|| (place.layout.size, place.layout.align.abi));
-        // Direct call to `check_ptr_access_align` checks alignment even on CTFE machines.
-        try_validation!(
-            self.ecx.check_ptr_access(
-                place.ptr(),
-                size,
-                CheckInAllocMsg::Dereferenceable, // will anyway be replaced by validity message
-            ),
-            self.path,
-            Ub(DanglingIntPointer { addr: 0, .. }) => NullPtr { ptr_kind, maybe: false },
-            Ub(DanglingIntPointer { addr: i, .. }) => DanglingPtrNoProvenance {
-                ptr_kind,
-                // FIXME this says "null pointer" when null but we need translate
-                pointer: format!("{}", Pointer::<Option<AllocId>>::without_provenance(i))
-            },
-            Ub(PointerOutOfBounds { .. }) => DanglingPtrOutOfBounds {
-                ptr_kind
-            },
-            Ub(PointerUseAfterFree(..)) => DanglingPtrUseAfterFree {
-                ptr_kind,
-            },
-        );
+
+        if !self.may_dangle {
+            // Make sure this is dereferenceable and all.
+
+            // Direct call to `check_ptr_access_align` checks alignment even on CTFE machines.
+            // Call `check_ptr_access` to avoid checking alignment here.
+            try_validation!(
+                self.ecx.check_ptr_access(
+                    place.ptr(),
+                    size,
+                    CheckInAllocMsg::Dereferenceable, // will anyway be replaced by validity message
+                ),
+                self.path,
+                Ub(DanglingIntPointer { addr: 0, .. }) => NullPtr { ptr_kind, maybe: false },
+                Ub(DanglingIntPointer { addr: i, .. }) => DanglingPtrNoProvenance {
+                    ptr_kind,
+                    pointer: format!("{}", Pointer::<Option<AllocId>>::without_provenance(i))
+                },
+                Ub(PointerOutOfBounds { .. }) => DanglingPtrOutOfBounds {
+                    ptr_kind
+                },
+                Ub(PointerUseAfterFree(..)) => DanglingPtrUseAfterFree {
+                    ptr_kind,
+                },
+            );
+        }
+
         try_validation!(
             self.ecx.check_ptr_align(
                 place.ptr(),
@@ -536,8 +546,10 @@ fn check_safe_pointer(
                 found_bytes: has.bytes()
             },
         );
-        // Make sure this is non-null. We checked dereferenceability above, but if `size` is zero
-        // that does not imply non-null.
+
+        // Make sure this is non-null. This is obviously needed when `may_dangle` is set,
+        // but even if we did check dereferenceability above that would still allow null
+        // pointers if `size` is zero.
         let scalar = Scalar::from_maybe_pointer(place.ptr(), self.ecx);
         if self.ecx.scalar_may_be_null(scalar)? {
             let maybe = !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
@@ -1265,6 +1277,14 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                     ty::PatternKind::Or(_patterns) => {}
                 }
             }
+            ty::Adt(adt, _) if adt.is_maybe_dangling() => {
+                let old_may_dangle = mem::replace(&mut self.may_dangle, true);
+
+                let inner = self.ecx.project_field(val, FieldIdx::ZERO)?;
+                self.visit_value(&inner)?;
+
+                self.may_dangle = old_may_dangle;
+            }
             _ => {
                 // default handler
                 try_validation!(
@@ -1350,6 +1370,7 @@ fn validate_operand_internal(
                 ecx,
                 reset_provenance_and_padding,
                 data_bytes: reset_padding.then_some(RangeSet(Vec::new())),
+                may_dangle: false,
             };
             v.visit_value(val)?;
             v.reset_padding(val)?;
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index 617b619a7df9..66e804d972b7 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -917,6 +917,7 @@ fn retag_ptr_inplace(
                     RetagInfo { cause: self.retag_cause, in_field: self.in_field },
                 )?;
                 self.ecx.write_immediate(*val, place)?;
+
                 interp_ok(())
             }
         }
@@ -964,6 +965,9 @@ fn visit_value(&mut self, place: &PlaceTy<'tcx>) -> InterpResult<'tcx> {
                         // even if field retagging is not enabled. *shrug*)
                         self.walk_value(place)?;
                     }
+                    ty::Adt(adt, _) if adt.is_maybe_dangling() => {
+                        // Skip traversing for everything inside of `MaybeDangling`
+                    }
                     _ => {
                         // Not a reference/pointer/box. Recurse.
                         let in_field = mem::replace(&mut self.in_field, true); // remember and restore old value
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 1a7c0af2988a..a20550232730 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -523,6 +523,9 @@ fn visit_value(&mut self, place: &PlaceTy<'tcx>) -> InterpResult<'tcx> {
                         // even if field retagging is not enabled. *shrug*)
                         self.walk_value(place)?;
                     }
+                    ty::Adt(adt, _) if adt.is_maybe_dangling() => {
+                        // Skip traversing for everything inside of `MaybeDangling`
+                    }
                     _ => {
                         // Not a reference/pointer/box. Recurse.
                         self.walk_value(place)?;
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
new file mode 100644
index 000000000000..92917c88b731
--- /dev/null
+++ b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
@@ -0,0 +1,15 @@
+// Test that an unaligned `MaybeDangling<&u8>` is still detected as UB.
+//
+//@compile-flags: -Zmiri-disable-stacked-borrows
+#![feature(maybe_dangling)]
+
+use std::mem::{MaybeDangling, transmute};
+
+fn main() {
+    let a = [1u16, 0u16];
+    unsafe {
+        let unaligned = MaybeDangling::new(a.as_ptr().byte_add(1));
+        transmute::<MaybeDangling<*const u16>, MaybeDangling<&u16>>(unaligned)
+        //~^ ERROR: Undefined Behavior: constructing invalid value: encountered an unaligned reference
+    };
+}
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
new file mode 100644
index 000000000000..9a50a031cf96
--- /dev/null
+++ b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
@@ -0,0 +1,13 @@
+error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+  --> tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs:LL:CC
+   |
+LL |         transmute::<MaybeDangling<*const u16>, MaybeDangling<&u16>>(unaligned)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs b/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
new file mode 100644
index 000000000000..21dba864a3f1
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
@@ -0,0 +1,13 @@
+// Test that a null `MaybeDangling<&u8>` is still detected as UB.
+//
+//@compile-flags: -Zmiri-disable-stacked-borrows
+#![feature(maybe_dangling)]
+
+use std::mem::{MaybeDangling, transmute};
+use std::ptr::null;
+
+fn main() {
+    let null = MaybeDangling::new(null());
+    unsafe { transmute::<MaybeDangling<*const u8>, MaybeDangling<&u8>>(null) };
+    //~^ ERROR: Undefined Behavior: constructing invalid value: encountered a null reference
+}
diff --git a/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr b/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
new file mode 100644
index 000000000000..650234777ccf
--- /dev/null
+++ b/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
@@ -0,0 +1,13 @@
+error: Undefined Behavior: constructing invalid value: encountered a null reference
+  --> tests/fail/validity/maybe_dangling_null.rs:LL:CC
+   |
+LL |     unsafe { transmute::<MaybeDangling<*const u8>, MaybeDangling<&u8>>(null) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/pass/both_borrows/maybe_dangling.rs b/src/tools/miri/tests/pass/both_borrows/maybe_dangling.rs
new file mode 100644
index 000000000000..fe2b526d94b1
--- /dev/null
+++ b/src/tools/miri/tests/pass/both_borrows/maybe_dangling.rs
@@ -0,0 +1,59 @@
+// Check that `MaybeDangling` actually prevents UB when it wraps dangling
+// boxes and references
+//
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
+#![feature(maybe_dangling)]
+
+use std::mem::{self, MaybeDangling};
+use std::ptr::drop_in_place;
+
+fn main() {
+    boxy();
+    reference();
+    write_through_shared_ref();
+}
+
+fn boxy() {
+    let mut x = MaybeDangling::new(Box::new(1));
+
+    // make the box dangle
+    unsafe { drop_in_place(x.as_mut()) };
+
+    // move the dangling box (without `MaybeDangling` this causes UB)
+    let x: MaybeDangling<Box<u32>> = x;
+
+    mem::forget(x);
+}
+
+fn reference() {
+    let x = {
+        let local = 0;
+
+        // erase the lifetime to make a dangling reference
+        unsafe {
+            mem::transmute::<MaybeDangling<&u32>, MaybeDangling<&u32>>(MaybeDangling::new(&local))
+        }
+    };
+
+    // move the dangling reference (without `MaybeDangling` this causes UB)
+    let _x: MaybeDangling<&u32> = x;
+}
+
+fn write_through_shared_ref() {
+    // Under the current models, we do not forbid writing through
+    // `MaybeDangling<&i32>`. That's not yet finally decided, but meanwhile
+    // ensure we document this and notice when it changes.
+
+    unsafe {
+        let mutref = &mut 0;
+        write_through_shr(mem::transmute(mutref));
+    }
+
+    fn write_through_shr(x: MaybeDangling<&i32>) {
+        unsafe {
+            let y: *mut i32 = mem::transmute(x);
+            y.write(1);
+        }
+    }
+}
diff --git a/src/tools/miri/tests/pass/stacked_borrows/stack-printing.stdout b/src/tools/miri/tests/pass/stacked_borrows/stack-printing.stdout
index de7da309271d..296339e73845 100644
--- a/src/tools/miri/tests/pass/stacked_borrows/stack-printing.stdout
+++ b/src/tools/miri/tests/pass/stacked_borrows/stack-printing.stdout
@@ -1,6 +1,6 @@
 0..1: [ SharedReadWrite<TAG> ]
 0..1: [ SharedReadWrite<TAG> ]
 0..1: [ SharedReadWrite<TAG> ]
-0..1: [ SharedReadWrite<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> ]
-0..1: [ SharedReadWrite<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> SharedReadOnly<TAG> ]
+0..1: [ SharedReadWrite<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> Unique<TAG> ]
+0..1: [ SharedReadWrite<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> Disabled<TAG> SharedReadOnly<TAG> ]
 0..1: [ unknown-bottom(..<TAG>) ]

From 4ff68e41875c472d4e8a6fee8d3f52d0e27b259c Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 17 Feb 2026 17:01:16 +0100
Subject: [PATCH 0243/1059] use the unstable carryless_mul instead of a manual
 implementation

---
 src/tools/miri/src/lib.rs           |  1 +
 src/tools/miri/src/shims/x86/mod.rs | 16 +---------------
 2 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index c40eedf87f57..e0e908d671b6 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -22,6 +22,7 @@
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
 #![feature(macro_metavar_expr)]
+#![feature(uint_carryless_mul)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,
diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index dc0d8d48ac9b..ce6538c8ca27 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -1178,21 +1178,7 @@ fn pclmulqdq<'tcx>(
         let index = if (imm8 & 0x10) == 0 { lo } else { hi };
         let right = ecx.read_scalar(&ecx.project_index(&right, index)?)?.to_u64()?;
 
-        // Perform carry-less multiplication.
-        //
-        // This operation is like long multiplication, but ignores all carries.
-        // That idea corresponds to the xor operator, which is used in the implementation.
-        //
-        // Wikipedia has an example https://en.wikipedia.org/wiki/Carry-less_product#Example
-        let mut result: u128 = 0;
-
-        for i in 0..64 {
-            // if the i-th bit in right is set
-            if (right & (1 << i)) != 0 {
-                // xor result with `left` shifted to the left by i positions
-                result ^= u128::from(left) << i;
-            }
-        }
+        let result = left.widening_carryless_mul(right);
 
         let dest = ecx.project_index(&dest, i)?;
         ecx.write_scalar(Scalar::from_u128(result), &dest)?;

From cd7cf17d774f6650b6dc134e17747023196c542f Mon Sep 17 00:00:00 2001
From: Fuqiao Xue <xfq@w3.org>
Date: Fri, 6 Mar 2026 16:08:50 +0800
Subject: [PATCH 0244/1059] Add rationale for intentional
 potential_query_instability allows

---
 compiler/rustc_type_ir/src/search_graph/mod.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 7c58cd7303eb..e0c6c777c09a 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -247,6 +247,8 @@ impl CandidateHeadUsages {
     pub fn merge_usages(&mut self, other: CandidateHeadUsages) {
         if let Some(other_usages) = other.usages {
             if let Some(ref mut self_usages) = self.usages {
+                // Each head is merged independently, so the final usage counts are the same
+                // regardless of hash iteration order.
                 #[allow(rustc::potential_query_instability)]
                 for (head_index, head) in other_usages.into_iter() {
                     let HeadUsages { inductive, unknown, coinductive, forced_ambiguity } = head;
@@ -501,6 +503,8 @@ fn insert(&mut self, input: X::Input, paths_to_nested: PathsToNested) {
     /// to all nested goals of that nested goal are also inductive. Otherwise the paths are
     /// the same as for the child.
     fn extend_from_child(&mut self, step_kind: PathKind, nested_goals: &NestedGoals<X>) {
+        // Each nested goal is updated independently, and `insert` only unions paths for that
+        // goal, so traversal order cannot affect the result.
         #[allow(rustc::potential_query_instability)]
         for (input, paths_to_nested) in nested_goals.iter() {
             let paths_to_nested = paths_to_nested.extend_with(step_kind);
@@ -508,6 +512,8 @@ fn extend_from_child(&mut self, step_kind: PathKind, nested_goals: &NestedGoals<
         }
     }
 
+    // This helper intentionally exposes unstable hash iteration so each caller must opt in
+    // locally and justify why its traversal is order-insensitive.
     #[cfg_attr(feature = "nightly", rustc_lint_query_instability)]
     #[allow(rustc::potential_query_instability)]
     fn iter(&self) -> impl Iterator<Item = (X::Input, PathsToNested)> + '_ {
@@ -710,6 +716,8 @@ pub fn finish_single_candidate(&mut self) -> CandidateHeadUsages {
     pub fn ignore_candidate_head_usages(&mut self, usages: CandidateHeadUsages) {
         if let Some(usages) = usages.usages {
             let (entry_index, entry) = self.stack.last_mut_with_index().unwrap();
+            // Ignoring usages only mutates the state for the current `head_index`, so the
+            // resulting per-head state is unchanged by iteration order.
             #[allow(rustc::potential_query_instability)]
             for (head_index, usages) in usages.into_iter() {
                 if head_index == entry_index {
@@ -901,6 +909,8 @@ fn handle_overflow(&mut self, cx: X, input: X::Input) -> X::Result {
     /// don't depend on its value.
     fn clear_dependent_provisional_results_for_rerun(&mut self) {
         let rerun_index = self.stack.next_index();
+        // Each cached entry is filtered independently based on whether it depends on
+        // `rerun_index`, so bucket traversal order does not matter.
         #[allow(rustc::potential_query_instability)]
         self.provisional_cache.retain(|_, entries| {
             entries.retain(|entry| {
@@ -958,6 +968,8 @@ fn rebase_provisional_cache_entries(
         rebase_reason: RebaseReason,
     ) {
         let popped_head_index = self.stack.next_index();
+        // Rebasing decisions depend only on each provisional entry and the current stack state,
+        // so traversing the cache in hash order cannot change the final cache contents.
         #[allow(rustc::potential_query_instability)]
         self.provisional_cache.retain(|&input, entries| {
             entries.retain_mut(|entry| {
@@ -1139,6 +1151,8 @@ fn candidate_is_applicable(
 
         // The global cache entry is also invalid if there's a provisional cache entry
         // would apply for any of its nested goals.
+        // Any matching provisional entry rejects the candidate,
+        // so iteration order only affects when we return `false`, not the final answer.
         #[allow(rustc::potential_query_instability)]
         for (input, path_from_global_entry) in nested_goals.iter() {
             let Some(entries) = self.provisional_cache.get(&input) else {

From 1d81c5021a21453e77ca2a0cd7f2a8006e9775ae Mon Sep 17 00:00:00 2001
From: Luca Palmieri <20745048+LukeMathWalker@users.noreply.github.com>
Date: Mon, 2 Mar 2026 12:54:24 +0100
Subject: [PATCH 0245/1059] feat(rustdoc-json): Add optional support for rkyv
 (de)serialization

---
 Cargo.lock                                 | 124 ++++++++++
 src/bootstrap/src/core/build_steps/test.rs |   2 +-
 src/rustdoc-json-types/Cargo.toml          |   2 +
 src/rustdoc-json-types/lib.rs              | 259 ++++++++++++++++++++-
 src/rustdoc-json-types/tests.rs            | 115 +++++++++
 5 files changed, 497 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7f1cf4850c8a..a913c39cef47 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -376,12 +376,41 @@ version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
+[[package]]
+name = "bytecheck"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0caa33a2c0edca0419d15ac723dff03f1956f7978329b1e3b5fdaaaed9d3ca8b"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "rancor",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "bytecount"
 version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
 
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
 [[package]]
 name = "camino"
 version = "1.2.1"
@@ -2476,6 +2505,26 @@ dependencies = [
 name = "miropt-test-tools"
 version = "0.1.0"
 
+[[package]]
+name = "munge"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c"
+dependencies = [
+ "munge_macro",
+]
+
+[[package]]
+name = "munge_macro"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "new_debug_unreachable"
 version = "1.0.6"
@@ -3047,6 +3096,26 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "ptr_meta"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b9a0cf95a1196af61d4f1cbdab967179516d9a4a4312af1f31948f8f6224a79"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "pulldown-cmark"
 version = "0.11.3"
@@ -3092,6 +3161,15 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "rancor"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a063ea72381527c2a0561da9c80000ef822bdd7c3241b1cc1b12100e3df081ee"
+dependencies = [
+ "ptr_meta",
+]
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -3275,6 +3353,15 @@ dependencies = [
 name = "remote-test-server"
 version = "0.1.0"
 
+[[package]]
+name = "rend"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cadadef317c2f20755a64d7fdc48f9e7178ee6b0e1f7fce33fa60f1d68a276e6"
+dependencies = [
+ "bytecheck",
+]
+
 [[package]]
 name = "replace-version-placeholder"
 version = "0.1.0"
@@ -3283,6 +3370,36 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "rkyv"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a30e631b7f4a03dee9056b8ef6982e8ba371dd5bedb74d3ec86df4499132c70"
+dependencies = [
+ "bytecheck",
+ "bytes",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "munge",
+ "ptr_meta",
+ "rancor",
+ "rend",
+ "rkyv_derive",
+ "tinyvec",
+ "uuid",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "run_make_support"
 version = "0.0.0"
@@ -4789,6 +4906,7 @@ name = "rustdoc-json-types"
 version = "0.1.0"
 dependencies = [
  "bincode",
+ "rkyv",
  "rustc-hash 2.1.1",
  "serde",
  "serde_derive",
@@ -5127,6 +5245,12 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
 [[package]]
 name = "similar"
 version = "2.7.0"
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 88f10775333d..ab1d2b8a24b6 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3302,7 +3302,7 @@ fn run(self, builder: &Builder<'_>) {
             builder.kind,
             "src/rustdoc-json-types",
             SourceType::InTree,
-            &[],
+            &["rkyv_0_8".to_owned()],
         );
 
         // FIXME: this looks very wrong, libtest doesn't accept `-C` arguments and the quotes are fishy.
diff --git a/src/rustdoc-json-types/Cargo.toml b/src/rustdoc-json-types/Cargo.toml
index a38d34ef0e7d..7e4e53ccaf0d 100644
--- a/src/rustdoc-json-types/Cargo.toml
+++ b/src/rustdoc-json-types/Cargo.toml
@@ -8,11 +8,13 @@ path = "lib.rs"
 
 [features]
 default = ["rustc-hash"]
+rkyv_0_8 = ["dep:rkyv"]
 
 [dependencies]
 serde = "1.0"
 serde_derive = "1.0"
 rustc-hash = { version = "2.0", optional = true }
+rkyv = { version = "0.8", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index 9a59de4f844a..3cf1fa22b246 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -3,7 +3,11 @@
 //! These types are the public API exposed through the `--output-format json` flag. The [`Crate`]
 //! struct is the root of the JSON blob and all other items are contained within.
 //!
-//! We expose a `rustc-hash` feature that is disabled by default. This feature switches the
+//! # Feature Flags
+//!
+//! ## `rustc-hash`
+//!
+//! We expose a `rustc-hash` feature, disabled by default. This feature switches the
 //! [`std::collections::HashMap`] for [`rustc_hash::FxHashMap`] to improve the performance of said
 //! `HashMap` in specific situations.
 //!
@@ -12,8 +16,79 @@
 //! turning this feature on, as [`FxHashMap`][2] only concerns itself with hash speed, and may
 //! increase the number of collisions.
 //!
+//! ## `rkyv_0_8`
+//!
+//! We expose a `rkyv_0_8` feature, disabled by default. When enabled, it derives `rkyv`'s
+//! [`Archive`](rkyv::Archive), [`Serialize`](rkyv::Serialize) and [`Deserialize`](rkyv::Deserialize)
+//! traits for all types in this crate. Furthermore, it exposes the corresponding `Archived*` types
+//! (e.g. [`ArchivedId`] for [`Id`]).
+//!
+//! `rkyv` lets you works with JSON output without paying the deserialization cost _upfront_,
+//! thanks to [zero-copy deserialization][3].
+//! You can perform various types of analyses on the `Archived*` version of the relevant types,
+//! incurring the full deserialization cost only for the subset of items you actually need.
+//!
 //! [1]: https://rust-lang.zulipchat.com/#narrow/channel/266220-t-rustdoc/topic/rustc-hash.20and.20performance.20of.20rustdoc-types/near/474855731
 //! [2]: https://crates.io/crates/rustc-hash
+//! [3]: https://rkyv.org/zero-copy-deserialization.html
+
+// # On `rkyv` Derives
+//
+// In most cases, it's enough to add `#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]`
+// on top of a type to derive the relevant `rkyv` traits.
+//
+// There are a few exceptions, though, where more complex macro options are required.
+// The following sections break down the patterns that are showcased by `rkyv'`s
+// [JSON schema example](https://github.com/rkyv/rkyv/blob/985b0230a0b9cb9fce4a4ee9facb6af148e27c8e/rkyv/examples/json_like_schema.rs).
+//
+// ## Recursive Types
+//
+// Let's look at the `Type` enum as an example. It stores a `Box<Type>` in its `Slice` variant.
+// A "vanilla" `rkyv` annotation will cause an overflow in the compiler when
+// building the crate, since the bounds generated by the macro will be self-referential and thus
+// trap the compiler into a never-ending loop.
+//
+// To prevent this issue, `#[rkyv(omit_bounds)]` must be added to the relevant field.
+//
+// ## Co-Recursive Types
+//
+// The same problem occurs if a type is co-recursive—i.e. it doesn't _directly_ store a pointer
+// to another instance of the same type, but one of its fields does, transitively.
+//
+// For example, let's look at `Path`:
+//
+// - `Path` has a field of type `Option<Box<GenericArgs>>`
+// - One of the variants in `GenericArgs` has a field of type `Vec<GenericArg>`
+// - One of the variants of `GenericArg` has a field of type `Type`
+// - `Type::ResolvedPath` stores a `Path` instance
+//
+// The same logic of the recursive case applies here: we must use `#[rkyv(omit_bounds)]` to break the cycle.
+//
+// ## Additional Bounds
+//
+// Whenever `#[rkyv(omit_bounds)]` is added to a field or variant, `rkyv` omits _all_ traits bounds for that
+// field in the generated impl. This may result in compilation errors due to insufficient bounds in the
+// generated code.
+//
+// To add _some_ bounds back, `rkyv` exposes four knobs:
+//
+// - `#[rkyv(archive_bounds(..))]` to add predicates to all generated impls
+// - `#[rkyv(serialize_bounds(..))]` to add predicates to just the `Serialize` impl
+// - `#[rkyv(deserialize_bounds(..))]` to add predicates to just the `Deserialize` impl
+// - `#[rkyv(bytecheck(bounds(..)))]` to add predicates to just the `CheckBytes` impl
+//
+// In particular, we use the following annotations in this crate:
+//
+// - `serialize_bounds(__S: rkyv::ser::Writer + rkyv::ser::Allocator, __S::Error: rkyv::rancor::Source)` for serializing
+//   variable-length types like `Vec<T>`. `rkyv`'s zero-copy format requires the serializer to be able
+//   to write bytes (`Writer`) and allocate scratch space (`Allocator`) for these types
+//   ([`rkyv`'s `Vec` impl bounds](https://docs.rs/rkyv/0.8.15/rkyv/trait.Serialize.html#impl-Serialize%3CS%3E-for-Vec%3CT%3E)).
+//   The `Error: Source` bound lets error types compose.
+// - `deserialize_bounds(__D::Error: rkyv::rancor::Source)` so that errors from deserializing fields behind
+//   `omit_bounds` (e.g. `Box<T>`, `Vec<T>`) can compose via the `Source` trait.
+// - `bytecheck(bounds(__C: rkyv::validation::ArchiveContext, __C::Error: rkyv::rancor::Source))` for validating
+//   archived data. Checking that bytes represent a valid archived value requires an `ArchiveContext` that tracks
+//   validation state (e.g. subtree ranges, to prevent overlapping/out-of-bounds archived data).
 
 #[cfg(not(feature = "rustc-hash"))]
 use std::collections::HashMap;
@@ -46,6 +121,8 @@
 /// about the language items in the local crate, as well as info about external items to allow
 /// tools to find or link to them.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Crate {
     /// The id of the root [`Module`] item of the local crate.
     pub root: Id,
@@ -69,6 +146,8 @@ pub struct Crate {
 
 /// Information about a target
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Target {
     /// The target triple for which this documentation was generated
     pub triple: String,
@@ -99,6 +178,8 @@ pub struct Target {
 /// [1]: https://doc.rust-lang.org/stable/reference/attributes/codegen.html#the-target_feature-attribute
 /// [2]: https://doc.rust-lang.org/reference/conditional-compilation.html#target_feature
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct TargetFeature {
     /// The name of this target feature.
     pub name: String,
@@ -123,6 +204,8 @@ pub struct TargetFeature {
 
 /// Metadata of a crate, either the same crate on which `rustdoc` was invoked, or its dependency.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct ExternalCrate {
     /// The name of the crate.
     ///
@@ -140,6 +223,7 @@ pub struct ExternalCrate {
     ///
     /// This will typically be a `.rlib` or `.rmeta`. It can be used to determine which crate
     /// this was in terms of whatever build-system invoked rustc.
+    #[cfg_attr(feature = "rkyv_0_8", rkyv(with = rkyv::with::AsString))]
     pub path: PathBuf,
 }
 
@@ -150,6 +234,8 @@ pub struct ExternalCrate {
 /// question, or can be used by a tool that takes the json output of multiple crates to find
 /// the actual item definition with all the relevant info.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct ItemSummary {
     /// Can be used to look up the name and html_root_url of the crate this item came from in the
     /// `external_crates` map.
@@ -171,6 +257,8 @@ pub struct ItemSummary {
 /// The `Item` data type holds fields that can apply to any of these,
 /// and leaves kind-specific details (like function args or enum variants) to the `inner` field.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Item {
     /// The unique identifier of this item. Can be used to find this item in various mappings.
     pub id: Id,
@@ -209,6 +297,8 @@ pub struct Item {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 /// An attribute, e.g. `#[repr(C)]`
 ///
@@ -256,6 +346,8 @@ pub enum Attribute {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 /// The contents of a `#[repr(...)]` attribute.
 ///
 /// Used in [`Attribute::Repr`].
@@ -275,6 +367,8 @@ pub struct AttributeRepr {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 /// The kind of `#[repr]`.
 ///
@@ -294,8 +388,11 @@ pub enum ReprKind {
 
 /// A range of source code.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Span {
     /// The path to the source file for this span relative to the path `rustdoc` was invoked with.
+    #[cfg_attr(feature = "rkyv_0_8", rkyv(with = rkyv::with::AsString))]
     pub filename: PathBuf,
     /// One indexed Line and Column of the first character of the `Span`.
     pub begin: (usize, usize),
@@ -305,6 +402,8 @@ pub struct Span {
 
 /// Information about the deprecation of an [`Item`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Deprecation {
     /// Usually a version number when this [`Item`] first became deprecated.
     pub since: Option<String>,
@@ -314,6 +413,8 @@ pub struct Deprecation {
 
 /// Visibility of an [`Item`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum Visibility {
     /// Explicitly public visibility set with `pub`.
@@ -337,6 +438,8 @@ pub enum Visibility {
 
 /// Dynamic trait object type (`dyn Trait`).
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct DynTrait {
     /// All the traits implemented. One of them is the vtable, and the rest must be auto traits.
     pub traits: Vec<PolyTrait>,
@@ -352,6 +455,8 @@ pub struct DynTrait {
 
 /// A trait and potential HRTBs
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct PolyTrait {
     /// The path to the trait.
     #[serde(rename = "trait")]
@@ -371,6 +476,18 @@ pub struct PolyTrait {
 ///                    ^^^^^
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(serialize_bounds(
+    __S: rkyv::ser::Writer + rkyv::ser::Allocator,
+    __S::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(deserialize_bounds(
+    __D::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(bytecheck(bounds(
+    __C: rkyv::validation::ArchiveContext,
+))))]
 #[serde(rename_all = "snake_case")]
 pub enum GenericArgs {
     /// `<'a, 32, B: Copy, C = u32>`
@@ -387,8 +504,10 @@ pub enum GenericArgs {
     /// `Fn(A, B) -> C`
     Parenthesized {
         /// The input types, enclosed in parentheses.
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         inputs: Vec<Type>,
         /// The output type provided after the `->`, if present.
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         output: Option<Type>,
     },
     /// `T::method(..)`
@@ -399,6 +518,8 @@ pub enum GenericArgs {
 ///
 /// Part of [`GenericArgs`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum GenericArg {
     /// A lifetime argument.
@@ -429,6 +550,8 @@ pub enum GenericArg {
 
 /// A constant.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Constant {
     /// The stringified expression of this constant. Note that its mapping to the original
     /// source code is unstable and it's not guaranteed that it'll match the source code.
@@ -448,10 +571,24 @@ pub struct Constant {
 ///              ^^^^^^^^^^  ^^^^^^^^^^^^^^^
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(serialize_bounds(
+    __S: rkyv::ser::Writer + rkyv::ser::Allocator,
+    __S::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(deserialize_bounds(
+    __D::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(bytecheck(bounds(
+    __C: rkyv::validation::ArchiveContext,
+    <__C as rkyv::rancor::Fallible>::Error: rkyv::rancor::Source,
+))))]
 pub struct AssocItemConstraint {
     /// The name of the associated type/constant.
     pub name: String,
     /// Arguments provided to the associated type/constant.
+    #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
     pub args: Option<Box<GenericArgs>>,
     /// The kind of bound applied to the associated type/constant.
     pub binding: AssocItemConstraintKind,
@@ -459,6 +596,8 @@ pub struct AssocItemConstraint {
 
 /// The way in which an associate type/constant is bound.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum AssocItemConstraintKind {
     /// The required value/type is specified exactly. e.g.
@@ -487,6 +626,8 @@ pub enum AssocItemConstraintKind {
 /// should treat them as opaque keys to lookup items, and avoid attempting
 /// to parse them, or otherwise depend on any implementation details.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)))]
 // FIXME(aDotInTheVoid): Consider making this non-public in rustdoc-types.
 pub struct Id(pub u32);
 
@@ -494,6 +635,9 @@ pub enum AssocItemConstraintKind {
 ///
 /// Part of [`ItemSummary`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(compare(PartialEq)))]
 #[serde(rename_all = "snake_case")]
 pub enum ItemKind {
     /// A module declaration, e.g. `mod foo;` or `mod foo {}`
@@ -569,6 +713,8 @@ pub enum ItemKind {
 ///
 /// Part of [`Item`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum ItemEnum {
     /// A module declaration, e.g. `mod foo;` or `mod foo {}`
@@ -684,6 +830,8 @@ pub enum ItemEnum {
 
 /// A module declaration, e.g. `mod foo;` or `mod foo {}`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Module {
     /// Whether this is the root item of a crate.
     ///
@@ -699,6 +847,8 @@ pub struct Module {
 
 /// A `union`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Union {
     /// The generic parameters and where clauses on this union.
     pub generics: Generics,
@@ -716,6 +866,8 @@ pub struct Union {
 
 /// A `struct`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Struct {
     /// The kind of the struct (e.g. unit, tuple-like or struct-like) and the data specific to it,
     /// i.e. fields.
@@ -729,6 +881,8 @@ pub struct Struct {
 
 /// The kind of a [`Struct`] and the data specific to it, i.e. fields.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum StructKind {
     /// A struct with no fields and no parentheses.
@@ -766,6 +920,8 @@ pub enum StructKind {
 
 /// An `enum`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Enum {
     /// Information about the type parameters and `where` clauses of the enum.
     pub generics: Generics,
@@ -781,6 +937,8 @@ pub struct Enum {
 
 /// A variant of an enum.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Variant {
     /// Whether the variant is plain, a tuple-like, or struct-like. Contains the fields.
     pub kind: VariantKind,
@@ -790,6 +948,8 @@ pub struct Variant {
 
 /// The kind of an [`Enum`] [`Variant`] and the data specific to it, i.e. fields.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum VariantKind {
     /// A variant with no parentheses
@@ -833,6 +993,8 @@ pub enum VariantKind {
 
 /// The value that distinguishes a variant in an [`Enum`] from other variants.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Discriminant {
     /// The expression that produced the discriminant.
     ///
@@ -851,6 +1013,8 @@ pub struct Discriminant {
 
 /// A set of fundamental properties of a function.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct FunctionHeader {
     /// Is this function marked as `const`?
     pub is_const: bool,
@@ -871,6 +1035,8 @@ pub struct FunctionHeader {
 /// See the [Rustonomicon section](https://doc.rust-lang.org/nightly/nomicon/ffi.html#ffi-and-unwinding)
 /// on unwinding for more info.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub enum Abi {
     // We only have a concrete listing here for stable ABI's because there are so many
     // See rustc_ast_passes::feature_gate::PostExpansionVisitor::check_abi for the list
@@ -898,6 +1064,8 @@ pub enum Abi {
 
 /// A function declaration (including methods and other associated functions).
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Function {
     /// Information about the function signature, or declaration.
     pub sig: FunctionSignature,
@@ -911,6 +1079,8 @@ pub struct Function {
 
 /// Generic parameters accepted by an item and `where` clauses imposed on it and the parameters.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Generics {
     /// A list of generic parameter definitions (e.g. `<T: Clone + Hash, U: Copy>`).
     pub params: Vec<GenericParamDef>,
@@ -920,6 +1090,8 @@ pub struct Generics {
 
 /// One generic parameter accepted by an item.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct GenericParamDef {
     /// Name of the parameter.
     /// ```rust
@@ -934,6 +1106,18 @@ pub struct GenericParamDef {
 
 /// The kind of a [`GenericParamDef`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(serialize_bounds(
+    __S: rkyv::ser::Writer + rkyv::ser::Allocator,
+    __S::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(deserialize_bounds(
+    __D::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(bytecheck(bounds(
+    __C: rkyv::validation::ArchiveContext,
+))))]
 #[serde(rename_all = "snake_case")]
 pub enum GenericParamDefKind {
     /// Denotes a lifetime parameter.
@@ -956,6 +1140,7 @@ pub enum GenericParamDefKind {
         /// fn default2<T: Default>() -> [T; 2] where T: Clone { todo!() }
         /// //             ^^^^^^^
         /// ```
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         bounds: Vec<GenericBound>,
         /// The default type for this parameter, if provided, e.g.
         ///
@@ -963,6 +1148,7 @@ pub enum GenericParamDefKind {
         /// trait PartialEq<Rhs = Self> {}
         /// //                    ^^^^
         /// ```
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         default: Option<Type>,
         /// This is normally `false`, which means that this generic parameter is
         /// declared in the Rust source text.
@@ -994,6 +1180,7 @@ pub enum GenericParamDefKind {
     Const {
         /// The type of the constant as declared.
         #[serde(rename = "type")]
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         type_: Type,
         /// The stringified expression for the default value, if provided. It's not guaranteed that
         /// it'll match the actual source code for the default value.
@@ -1007,6 +1194,8 @@ pub enum GenericParamDefKind {
 /// //                         ^^^^^^^^^^
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum WherePredicate {
     /// A type is expected to comply with a set of bounds
@@ -1053,6 +1242,8 @@ pub enum WherePredicate {
 
 /// Either a trait bound or a lifetime bound.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum GenericBound {
     /// A trait bound.
@@ -1083,6 +1274,8 @@ pub enum GenericBound {
 
 /// A set of modifiers applied to a trait.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum TraitBoundModifier {
     /// Marks the absence of a modifier.
@@ -1098,6 +1291,8 @@ pub enum TraitBoundModifier {
 
 /// One precise capturing argument. See [the rust reference](https://doc.rust-lang.org/reference/types/impl-trait.html#precise-capturing).
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum PreciseCapturingArg {
     /// A lifetime.
@@ -1115,6 +1310,8 @@ pub enum PreciseCapturingArg {
 /// Either a type or a constant, usually stored as the right-hand side of an equation in places like
 /// [`AssocItemConstraint`]
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum Term {
     /// A type.
@@ -1139,6 +1336,18 @@ pub enum Term {
 
 /// A type.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(serialize_bounds(
+    __S: rkyv::ser::Writer + rkyv::ser::Allocator,
+    __S::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(deserialize_bounds(
+    __D::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(bytecheck(bounds(
+    __C: rkyv::validation::ArchiveContext,
+))))]
 #[serde(rename_all = "snake_case")]
 pub enum Type {
     /// Structs, enums, unions and type aliases, e.g. `std::option::Option<u32>`
@@ -1150,15 +1359,16 @@ pub enum Type {
     /// Built-in numeric types (e.g. `u32`, `f32`), `bool`, `char`.
     Primitive(String),
     /// A function pointer type, e.g. `fn(u32) -> u32`, `extern "C" fn() -> *const u8`
-    FunctionPointer(Box<FunctionPointer>),
+    FunctionPointer(#[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))] Box<FunctionPointer>),
     /// A tuple type, e.g. `(String, u32, Box<usize>)`
-    Tuple(Vec<Type>),
+    Tuple(#[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))] Vec<Type>),
     /// An unsized slice type, e.g. `[u32]`.
-    Slice(Box<Type>),
+    Slice(#[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))] Box<Type>),
     /// An array type, e.g. `[u32; 15]`
     Array {
         /// The type of the contained element.
         #[serde(rename = "type")]
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         type_: Box<Type>,
         /// The stringified expression that is the length of the array.
         ///
@@ -1171,6 +1381,7 @@ pub enum Type {
     Pat {
         /// The base type, e.g. the `u32` in `u32 is 1..`
         #[serde(rename = "type")]
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         type_: Box<Type>,
         #[doc(hidden)]
         __pat_unstable_do_not_use: String,
@@ -1185,6 +1396,7 @@ pub enum Type {
         is_mutable: bool,
         /// The type of the pointee.
         #[serde(rename = "type")]
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         type_: Box<Type>,
     },
     /// `&'a mut String`, `&str`, etc.
@@ -1195,6 +1407,7 @@ pub enum Type {
         is_mutable: bool,
         /// The type of the pointee, e.g. the `i32` in `&'a mut i32`
         #[serde(rename = "type")]
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         type_: Box<Type>,
     },
     /// Associated types like `<Type as Trait>::Name` and `T::Item` where
@@ -1213,6 +1426,7 @@ pub enum Type {
         /// <core::slice::IterMut<'static, u32> as BetterIterator>::Item<'static>
         /// //                                                          ^^^^^^^^^
         /// ```
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         args: Option<Box<GenericArgs>>,
         /// The type with which this type is associated.
         ///
@@ -1220,6 +1434,7 @@ pub enum Type {
         /// <core::array::IntoIter<u32, 42> as Iterator>::Item
         /// // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         /// ```
+        #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
         self_type: Box<Type>,
         /// `None` iff this is an *inherent* associated type.
         #[serde(rename = "trait")]
@@ -1229,6 +1444,19 @@ pub enum Type {
 
 /// A type that has a simple path to it. This is the kind of type of structs, unions, enums, etc.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(serialize_bounds(
+    __S: rkyv::ser::Writer + rkyv::ser::Allocator,
+    __S::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(deserialize_bounds(
+    __D::Error: rkyv::rancor::Source,
+)))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(bytecheck(bounds(
+    __C: rkyv::validation::ArchiveContext,
+    <__C as rkyv::rancor::Fallible>::Error: rkyv::rancor::Source,
+))))]
 pub struct Path {
     /// The path of the type.
     ///
@@ -1252,11 +1480,14 @@ pub struct Path {
     /// std::borrow::Cow<'static, str>
     /// //              ^^^^^^^^^^^^^^
     /// ```
+    #[cfg_attr(feature = "rkyv_0_8", rkyv(omit_bounds))]
     pub args: Option<Box<GenericArgs>>,
 }
 
 /// A type that is a function pointer.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct FunctionPointer {
     /// The signature of the function.
     pub sig: FunctionSignature,
@@ -1273,6 +1504,8 @@ pub struct FunctionPointer {
 
 /// The signature of a function.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct FunctionSignature {
     /// List of argument names and their type.
     ///
@@ -1291,6 +1524,8 @@ pub struct FunctionSignature {
 
 /// A `trait` declaration.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Trait {
     /// Whether the trait is marked `auto` and is thus implemented automatically
     /// for all applicable types.
@@ -1315,6 +1550,8 @@ pub struct Trait {
 ///
 /// See [the tracking issue](https://github.com/rust-lang/rust/issues/41517)
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct TraitAlias {
     /// Information about the type parameters and `where` clauses of the alias.
     pub generics: Generics,
@@ -1324,6 +1561,8 @@ pub struct TraitAlias {
 
 /// An `impl` block.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Impl {
     /// Whether this impl is for an unsafe trait.
     pub is_unsafe: bool,
@@ -1362,6 +1601,8 @@ pub struct Impl {
 
 /// A `use` statement.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub struct Use {
     /// The full path being imported.
@@ -1380,6 +1621,8 @@ pub struct Use {
 
 /// A procedural macro.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct ProcMacro {
     /// How this macro is supposed to be called: `foo!()`, `#[foo]` or `#[derive(foo)]`
     pub kind: MacroKind,
@@ -1403,6 +1646,8 @@ pub struct ProcMacro {
 
 /// The way a [`ProcMacro`] is declared to be used.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 #[serde(rename_all = "snake_case")]
 pub enum MacroKind {
     /// A bang macro `foo!()`.
@@ -1415,6 +1660,8 @@ pub enum MacroKind {
 
 /// A type alias declaration, e.g. `type Pig = std::borrow::Cow<'static, str>;`
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct TypeAlias {
     /// The type referred to by this alias.
     #[serde(rename = "type")]
@@ -1425,6 +1672,8 @@ pub struct TypeAlias {
 
 /// A `static` declaration.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Static {
     /// The type of the static.
     #[serde(rename = "type")]
@@ -1455,6 +1704,8 @@ pub struct Static {
 
 /// A primitive type declaration. Declarations of this kind can only come from the core library.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv_0_8", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
+#[cfg_attr(feature = "rkyv_0_8", rkyv(derive(Debug)))]
 pub struct Primitive {
     /// The name of the type.
     pub name: String,
diff --git a/src/rustdoc-json-types/tests.rs b/src/rustdoc-json-types/tests.rs
index b9363fcf1b71..e878350e43b9 100644
--- a/src/rustdoc-json-types/tests.rs
+++ b/src/rustdoc-json-types/tests.rs
@@ -38,3 +38,118 @@ fn test_union_info_roundtrip() {
     let decoded: ItemEnum = bincode::deserialize(&encoded).unwrap();
     assert_eq!(u, decoded);
 }
+
+#[cfg(feature = "rkyv_0_8")]
+mod rkyv {
+    use std::fmt::Debug;
+
+    use rkyv::Archive;
+    use rkyv::api::high::{HighDeserializer, HighSerializer};
+    use rkyv::bytecheck::CheckBytes;
+    use rkyv::rancor::Strategy;
+    use rkyv::ser::allocator::ArenaHandle;
+    use rkyv::util::AlignedVec;
+    use rkyv::validation::Validator;
+    use rkyv::validation::archive::ArchiveValidator;
+    use rkyv::validation::shared::SharedValidator;
+
+    use crate::*;
+
+    #[test]
+    /// A test to exercise the (de)serialization roundtrip for a representative selection of types,
+    /// covering most of the rkyv-specific attributes we had to had.
+    fn test_rkyv_roundtrip() {
+        // Standard derives: a plain struct and union, mirroring the existing serde/bincode tests.
+        let s = ItemEnum::Struct(Struct {
+            generics: Generics { params: vec![], where_predicates: vec![] },
+            kind: StructKind::Plain { fields: vec![Id(1), Id(2)], has_stripped_fields: false },
+            impls: vec![Id(3)],
+        });
+        rkyv_roundtrip(&s);
+
+        let u = ItemEnum::Union(Union {
+            generics: Generics { params: vec![], where_predicates: vec![] },
+            has_stripped_fields: false,
+            fields: vec![Id(1)],
+            impls: vec![],
+        });
+        rkyv_roundtrip(&u);
+
+        // Extra trait derives, via rkyv(derive(PartialEq, Eq, PartialOrd, Ord, Hash)), on the archived type.
+        rkyv_roundtrip(&Id(99));
+
+        // Recursive cycle-breaking: `BorrowedRef` has omit_bounds on its `Box<Type>` field.
+        let ty = Type::BorrowedRef {
+            lifetime: Some("'a".to_string()),
+            is_mutable: false,
+            type_: Box::new(Type::Primitive("str".to_string())),
+        };
+        rkyv_roundtrip(&ty);
+
+        // `Slice` and `Tuple` are tuple-variant fields with omit_bounds on the unnamed field,
+        // which required special syntax (attribute inside the parentheses) to compile.
+        let ty = Type::Slice(Box::new(Type::Tuple(vec![
+            Type::Primitive("u32".to_string()),
+            Type::Generic("T".to_string()),
+        ])));
+        rkyv_roundtrip(&ty);
+
+        // `Path` has serialize_bounds/deserialize_bounds and omit_bounds on its `args` field.
+        // `GenericArgs::AngleBracketed` exercises the full recursive chain: `Path` -> `GenericArgs` -> `GenericArg` -> `Type`.
+        let path = Path {
+            path: "std::option::Option".to_string(),
+            id: Id(42),
+            args: Some(Box::new(GenericArgs::AngleBracketed {
+                args: vec![GenericArg::Type(Type::Primitive("u32".to_string()))],
+                constraints: vec![],
+            })),
+        };
+        rkyv_roundtrip(&path);
+
+        // `FunctionPointer` is a `Box<FunctionPointer>` behind `omit_bounds` in `Type`.
+        // It transitively contains `Type` via `FunctionSignature`, exercising the cycle from the other direction.
+        let fp = Type::FunctionPointer(Box::new(FunctionPointer {
+            sig: FunctionSignature {
+                inputs: vec![("x".to_string(), Type::Primitive("i32".to_string()))],
+                output: Some(Type::Primitive("bool".to_string())),
+                is_c_variadic: false,
+            },
+            generic_params: vec![],
+            header: FunctionHeader {
+                is_const: false,
+                is_unsafe: false,
+                is_async: false,
+                abi: Abi::Rust,
+            },
+        }));
+        rkyv_roundtrip(&fp);
+    }
+
+    /// A helper function for roundtrip testing of rkyv-powered deserialization.
+    fn rkyv_roundtrip<T>(value: &T)
+    where
+        T: PartialEq
+            + Debug
+            + Archive
+            + for<'a> rkyv::Serialize<
+                HighSerializer<AlignedVec, ArenaHandle<'a>, rkyv::rancor::Error>,
+            >,
+        T::Archived: rkyv::Deserialize<T, HighDeserializer<rkyv::rancor::Error>>
+            + Debug
+            + for<'a> CheckBytes<
+                Strategy<Validator<ArchiveValidator<'a>, SharedValidator>, rkyv::rancor::Error>,
+            >,
+    {
+        let bytes =
+            rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Error>(value, AlignedVec::new())
+                .unwrap();
+        let archived = rkyv::api::high::access::<T::Archived, rkyv::rancor::Error>(&bytes)
+            .expect("Failed to access archived data");
+        let deserialized: T = rkyv::api::deserialize_using::<_, _, rkyv::rancor::Error>(
+            archived,
+            &mut rkyv::de::Pool::new(),
+        )
+        .unwrap();
+        assert_eq!(value, &deserialized);
+    }
+}

From 342ad0401a16aebfa2e2160a099764168a4fe2f5 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Mon, 9 Mar 2026 12:39:47 +0000
Subject: [PATCH 0246/1059] ast_passes: unsupported arch w/ scalable vectors

Emit an error when attempting to compile a `#[rustc_scalable_vector]`
type for a architecture that fundamentally doesn't support scalable
vectors. Ultimately this is just a diagnostic improvement for an internal
attribute as users should never be doing this.
---
 .../rustc_ast_passes/src/ast_validation.rs    | 15 ++--
 compiler/rustc_ast_passes/src/errors.rs       |  7 ++
 compiler/rustc_target/src/spec/mod.rs         | 13 ++++
 .../src/directives/directive_names.rs         |  1 +
 .../ui/scalable-vectors/bad-architectures.rs  | 13 ++++
 .../scalable-vectors/bad-architectures.stderr |  8 ++
 tests/ui/scalable-vectors/fn-trait.rs         |  1 +
 tests/ui/scalable-vectors/fn-trait.stderr     |  2 +-
 .../{illegal_init.rs => illegal-init.rs}      |  1 +
 ...llegal_init.stderr => illegal-init.stderr} |  2 +-
 .../illformed-element-type.rs                 |  1 +
 .../illformed-element-type.stderr             | 30 +++----
 .../illformed-tuples-of-scalable-vectors.rs   |  1 +
 ...llformed-tuples-of-scalable-vectors.stderr | 12 +--
 .../illformed-within-types.rs                 |  1 +
 .../illformed-within-types.stderr             | 10 +--
 tests/ui/scalable-vectors/illformed.rs        |  1 +
 tests/ui/scalable-vectors/illformed.stderr    | 34 ++++----
 tests/ui/scalable-vectors/invalid.rs          |  1 +
 tests/ui/scalable-vectors/invalid.stderr      | 78 +++++++++----------
 .../ui/scalable-vectors/wellformed-arrays.rs  |  1 +
 tests/ui/scalable-vectors/wellformed.rs       |  1 +
 22 files changed, 145 insertions(+), 89 deletions(-)
 create mode 100644 tests/ui/scalable-vectors/bad-architectures.rs
 create mode 100644 tests/ui/scalable-vectors/bad-architectures.stderr
 rename tests/ui/scalable-vectors/{illegal_init.rs => illegal-init.rs} (94%)
 rename tests/ui/scalable-vectors/{illegal_init.stderr => illegal-init.stderr} (87%)

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index c8dbba006f6d..2308502df070 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1371,11 +1371,16 @@ fn visit_item(&mut self, item: &'a Item) {
             ItemKind::Struct(ident, generics, vdata) => {
                 self.with_tilde_const(Some(TildeConstReason::Struct { span: item.span }), |this| {
                     // Scalable vectors can only be tuple structs
-                    let is_scalable_vector =
-                        item.attrs.iter().any(|attr| attr.has_name(sym::rustc_scalable_vector));
-                    if is_scalable_vector && !matches!(vdata, VariantData::Tuple(..)) {
-                        this.dcx()
-                            .emit_err(errors::ScalableVectorNotTupleStruct { span: item.span });
+                    let scalable_vector_attr =
+                        item.attrs.iter().find(|attr| attr.has_name(sym::rustc_scalable_vector));
+                    if let Some(attr) = scalable_vector_attr {
+                        if !matches!(vdata, VariantData::Tuple(..)) {
+                            this.dcx()
+                                .emit_err(errors::ScalableVectorNotTupleStruct { span: item.span });
+                        }
+                        if !self.sess.target.arch.supports_scalable_vectors() {
+                            this.dcx().emit_err(errors::ScalableVectorBadArch { span: attr.span });
+                        }
                     }
 
                     match vdata {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index edc175b99088..4a39e22ac220 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -1133,3 +1133,10 @@ pub(crate) struct ScalableVectorNotTupleStruct {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("scalable vectors are not supported on this architecture")]
+pub(crate) struct ScalableVectorBadArch {
+    #[primary_span]
+    pub span: Span,
+}
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index a4460a372517..77cc6dd1036c 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1956,6 +1956,19 @@ pub fn supports_c_variadic_definitions(&self) -> bool {
             | X86_64 | Xtensa => true,
         }
     }
+
+    /// Whether `#[rustc_scalable_vector]` is supported for a target architecture
+    pub fn supports_scalable_vectors(&self) -> bool {
+        use Arch::*;
+
+        match self {
+            AArch64 | RiscV32 | RiscV64 => true,
+            AmdGpu | Arm | Arm64EC | Avr | Bpf | CSky | Hexagon | LoongArch32 | LoongArch64
+            | M68k | Mips | Mips32r6 | Mips64 | Mips64r6 | Msp430 | Nvptx64 | PowerPC
+            | PowerPC64 | S390x | Sparc | Sparc64 | SpirV | Wasm32 | Wasm64 | X86 | X86_64
+            | Xtensa | Other(_) => false,
+        }
+    }
 }
 
 crate::target_spec_enum! {
diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index d2a71a42e076..2fc5c0e8ec1e 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -105,6 +105,7 @@
     "ignore-powerpc",
     "ignore-powerpc64",
     "ignore-remote",
+    "ignore-riscv32",
     "ignore-riscv64",
     "ignore-rustc-debug-assertions",
     "ignore-rustc_abi-x86-sse2",
diff --git a/tests/ui/scalable-vectors/bad-architectures.rs b/tests/ui/scalable-vectors/bad-architectures.rs
new file mode 100644
index 000000000000..3323423316bf
--- /dev/null
+++ b/tests/ui/scalable-vectors/bad-architectures.rs
@@ -0,0 +1,13 @@
+//@ ignore-aarch64
+//@ ignore-riscv32
+//@ ignore-riscv64
+
+// Confirm that non-AArch64 and non-RISC-V targets error when compiling scalable vectors
+// (see #153593)
+
+#![crate_type = "lib"]
+#![feature(rustc_attrs)]
+
+#[rustc_scalable_vector(4)]
+//~^ ERROR: scalable vectors are not supported on this architecture
+struct ScalableVec(i32);
diff --git a/tests/ui/scalable-vectors/bad-architectures.stderr b/tests/ui/scalable-vectors/bad-architectures.stderr
new file mode 100644
index 000000000000..94308a40e77d
--- /dev/null
+++ b/tests/ui/scalable-vectors/bad-architectures.stderr
@@ -0,0 +1,8 @@
+error: scalable vectors are not supported on this architecture
+  --> $DIR/bad-architectures.rs:11:1
+   |
+LL | #[rustc_scalable_vector(4)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/scalable-vectors/fn-trait.rs b/tests/ui/scalable-vectors/fn-trait.rs
index 5203b5fa0efd..47b29202a671 100644
--- a/tests/ui/scalable-vectors/fn-trait.rs
+++ b/tests/ui/scalable-vectors/fn-trait.rs
@@ -1,3 +1,4 @@
+//@ only-aarch64
 #![allow(internal_features)]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/scalable-vectors/fn-trait.stderr b/tests/ui/scalable-vectors/fn-trait.stderr
index 4d00272dd1b5..8945069b10f8 100644
--- a/tests/ui/scalable-vectors/fn-trait.stderr
+++ b/tests/ui/scalable-vectors/fn-trait.stderr
@@ -1,5 +1,5 @@
 error: scalable vectors cannot be tuple fields
-  --> $DIR/fn-trait.rs:9:8
+  --> $DIR/fn-trait.rs:10:8
    |
 LL |     T: Fn(ScalableSimdFloat),
    |        ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/scalable-vectors/illegal_init.rs b/tests/ui/scalable-vectors/illegal-init.rs
similarity index 94%
rename from tests/ui/scalable-vectors/illegal_init.rs
rename to tests/ui/scalable-vectors/illegal-init.rs
index e8c0447fea42..c37a10b3f886 100644
--- a/tests/ui/scalable-vectors/illegal_init.rs
+++ b/tests/ui/scalable-vectors/illegal-init.rs
@@ -1,3 +1,4 @@
+//@ only-aarch64
 #![allow(incomplete_features, internal_features)]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/scalable-vectors/illegal_init.stderr b/tests/ui/scalable-vectors/illegal-init.stderr
similarity index 87%
rename from tests/ui/scalable-vectors/illegal_init.stderr
rename to tests/ui/scalable-vectors/illegal-init.stderr
index db0fffcf3b77..0cd99cf52d50 100644
--- a/tests/ui/scalable-vectors/illegal_init.stderr
+++ b/tests/ui/scalable-vectors/illegal-init.stderr
@@ -1,5 +1,5 @@
 error: scalable vector types cannot be initialised using their constructor
-  --> $DIR/illegal_init.rs:8:15
+  --> $DIR/illegal-init.rs:9:15
    |
 LL |     let foo = svint32_t(1);
    |               ^^^^^^^^^ you can create scalable vectors using intrinsics
diff --git a/tests/ui/scalable-vectors/illformed-element-type.rs b/tests/ui/scalable-vectors/illformed-element-type.rs
index 469ca006f5e9..8461b0a067ff 100644
--- a/tests/ui/scalable-vectors/illformed-element-type.rs
+++ b/tests/ui/scalable-vectors/illformed-element-type.rs
@@ -1,4 +1,5 @@
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![allow(internal_features)]
 #![feature(extern_types)]
 #![feature(never_type)]
diff --git a/tests/ui/scalable-vectors/illformed-element-type.stderr b/tests/ui/scalable-vectors/illformed-element-type.stderr
index f8ca8b76215f..52a434657070 100644
--- a/tests/ui/scalable-vectors/illformed-element-type.stderr
+++ b/tests/ui/scalable-vectors/illformed-element-type.stderr
@@ -1,5 +1,5 @@
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:15:1
+  --> $DIR/illformed-element-type.rs:16:1
    |
 LL | struct TyChar(char);
    | ^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL | struct TyChar(char);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:19:1
+  --> $DIR/illformed-element-type.rs:20:1
    |
 LL | struct TyConstPtr(*const u8);
    | ^^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL | struct TyConstPtr(*const u8);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:23:1
+  --> $DIR/illformed-element-type.rs:24:1
    |
 LL | struct TyMutPtr(*mut u8);
    | ^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL | struct TyMutPtr(*mut u8);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:27:1
+  --> $DIR/illformed-element-type.rs:28:1
    |
 LL | struct TyStruct(Foo);
    | ^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL | struct TyStruct(Foo);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:31:1
+  --> $DIR/illformed-element-type.rs:32:1
    |
 LL | struct TyEnum(Bar);
    | ^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL | struct TyEnum(Bar);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:35:1
+  --> $DIR/illformed-element-type.rs:36:1
    |
 LL | struct TyUnion(Baz);
    | ^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL | struct TyUnion(Baz);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:39:1
+  --> $DIR/illformed-element-type.rs:40:1
    |
 LL | struct TyForeign(Qux);
    | ^^^^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL | struct TyForeign(Qux);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:43:1
+  --> $DIR/illformed-element-type.rs:44:1
    |
 LL | struct TyArray([u32; 4]);
    | ^^^^^^^^^^^^^^
@@ -63,7 +63,7 @@ LL | struct TyArray([u32; 4]);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:47:1
+  --> $DIR/illformed-element-type.rs:48:1
    |
 LL | struct TySlice([u32]);
    | ^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL | struct TySlice([u32]);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:51:1
+  --> $DIR/illformed-element-type.rs:52:1
    |
 LL | struct TyRef<'a>(&'a u32);
    | ^^^^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL | struct TyRef<'a>(&'a u32);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:55:1
+  --> $DIR/illformed-element-type.rs:56:1
    |
 LL | struct TyFnPtr(fn(u32) -> u32);
    | ^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL | struct TyFnPtr(fn(u32) -> u32);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:59:1
+  --> $DIR/illformed-element-type.rs:60:1
    |
 LL | struct TyDyn(dyn std::io::Write);
    | ^^^^^^^^^^^^
@@ -95,7 +95,7 @@ LL | struct TyDyn(dyn std::io::Write);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:63:1
+  --> $DIR/illformed-element-type.rs:64:1
    |
 LL | struct TyNever(!);
    | ^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL | struct TyNever(!);
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:67:1
+  --> $DIR/illformed-element-type.rs:68:1
    |
 LL | struct TyTuple((u32, u32));
    | ^^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL | struct TyTuple((u32, u32));
    = help: only `u*`, `i*`, `f*` and `bool` types are accepted
 
 error: element type of a scalable vector must be a primitive scalar
-  --> $DIR/illformed-element-type.rs:77:1
+  --> $DIR/illformed-element-type.rs:78:1
    |
 LL | struct TyInvalidAlias(InvalidAlias);
    | ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.rs b/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.rs
index 4f89a8f9055e..37d516144ca3 100644
--- a/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.rs
+++ b/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.rs
@@ -1,4 +1,5 @@
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![allow(internal_features)]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.stderr b/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.stderr
index f5fd963204a2..6cf1394471f3 100644
--- a/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.stderr
+++ b/tests/ui/scalable-vectors/illformed-tuples-of-scalable-vectors.stderr
@@ -1,35 +1,35 @@
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:15:1
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:16:1
    |
 LL | struct Struct { x: ValidI64, y: ValidI64 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: all fields in a scalable vector struct must be the same type
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:19:39
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:20:39
    |
 LL | struct DifferentVectorTypes(ValidI64, ValidI32);
    |                                       ^^^^^^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:23:23
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:24:23
    |
 LL | struct NonVectorTypes(u32, u64);
    |                       ^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:27:32
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:28:32
    |
 LL | struct DifferentNonVectorTypes(u32, u64);
    |                                ^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:31:34
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:32:34
    |
 LL | struct SomeVectorTypes(ValidI64, u64);
    |                                  ^^^
 
 error: scalable vector structs cannot contain other scalable vector structs
-  --> $DIR/illformed-tuples-of-scalable-vectors.rs:35:20
+  --> $DIR/illformed-tuples-of-scalable-vectors.rs:36:20
    |
 LL | struct NestedTuple(ValidTuple, ValidTuple);
    |                    ^^^^^^^^^^
diff --git a/tests/ui/scalable-vectors/illformed-within-types.rs b/tests/ui/scalable-vectors/illformed-within-types.rs
index 81d960e4d4e1..d34d1ba2d7eb 100644
--- a/tests/ui/scalable-vectors/illformed-within-types.rs
+++ b/tests/ui/scalable-vectors/illformed-within-types.rs
@@ -1,4 +1,5 @@
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![allow(internal_features)]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/scalable-vectors/illformed-within-types.stderr b/tests/ui/scalable-vectors/illformed-within-types.stderr
index e76ef26f2aa4..b95452779f60 100644
--- a/tests/ui/scalable-vectors/illformed-within-types.stderr
+++ b/tests/ui/scalable-vectors/illformed-within-types.stderr
@@ -1,29 +1,29 @@
 error: scalable vectors cannot be fields of a struct
-  --> $DIR/illformed-within-types.rs:9:8
+  --> $DIR/illformed-within-types.rs:10:8
    |
 LL |     x: ValidI64,
    |        ^^^^^^^^
 
 error: scalable vectors cannot be tuple fields
-  --> $DIR/illformed-within-types.rs:11:15
+  --> $DIR/illformed-within-types.rs:12:15
    |
 LL |     in_tuple: (ValidI64,),
    |               ^^^^^^^^^^^
 
 error: scalable vectors cannot be fields of a struct
-  --> $DIR/illformed-within-types.rs:15:20
+  --> $DIR/illformed-within-types.rs:16:20
    |
 LL | struct TupleStruct(ValidI64);
    |                    ^^^^^^^^
 
 error: scalable vectors cannot be fields of a variant
-  --> $DIR/illformed-within-types.rs:19:26
+  --> $DIR/illformed-within-types.rs:20:26
    |
 LL |     StructVariant { _ty: ValidI64 },
    |                          ^^^^^^^^
 
 error: scalable vectors cannot be fields of a variant
-  --> $DIR/illformed-within-types.rs:21:18
+  --> $DIR/illformed-within-types.rs:22:18
    |
 LL |     TupleVariant(ValidI64),
    |                  ^^^^^^^^
diff --git a/tests/ui/scalable-vectors/illformed.rs b/tests/ui/scalable-vectors/illformed.rs
index de135413a9f2..d8730f40e102 100644
--- a/tests/ui/scalable-vectors/illformed.rs
+++ b/tests/ui/scalable-vectors/illformed.rs
@@ -1,4 +1,5 @@
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![allow(internal_features)]
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/scalable-vectors/illformed.stderr b/tests/ui/scalable-vectors/illformed.stderr
index bdf519c91058..ba584a4ad4d5 100644
--- a/tests/ui/scalable-vectors/illformed.stderr
+++ b/tests/ui/scalable-vectors/illformed.stderr
@@ -1,29 +1,29 @@
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:6:1
+  --> $DIR/illformed.rs:7:1
    |
 LL | struct NoFieldsStructWithElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:15:1
+  --> $DIR/illformed.rs:16:1
    |
 LL | struct NoFieldsUnitWithElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:20:1
+  --> $DIR/illformed.rs:21:1
    |
 LL | struct NoFieldsStructWithoutElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:29:1
+  --> $DIR/illformed.rs:30:1
    |
 LL | struct NoFieldsUnitWithoutElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:34:1
+  --> $DIR/illformed.rs:35:1
    |
 LL | / struct MultipleFieldsStructWithElementCount {
 LL | |
@@ -34,7 +34,7 @@ LL | | }
    | |_^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:46:1
+  --> $DIR/illformed.rs:47:1
    |
 LL | / struct MultipleFieldsStructWithoutElementCount {
 LL | |
@@ -44,13 +44,13 @@ LL | | }
    | |_^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:58:1
+  --> $DIR/illformed.rs:59:1
    |
 LL | struct SingleFieldStruct { _ty: f64 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:6:1
+  --> $DIR/illformed.rs:7:1
    |
 LL | struct NoFieldsStructWithElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,7 +58,7 @@ LL | struct NoFieldsStructWithElementCount {}
    = help: scalable vector types' only field must be a primitive scalar type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:11:1
+  --> $DIR/illformed.rs:12:1
    |
 LL | struct NoFieldsTupleWithElementCount();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL | struct NoFieldsTupleWithElementCount();
    = help: scalable vector types' only field must be a primitive scalar type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:15:1
+  --> $DIR/illformed.rs:16:1
    |
 LL | struct NoFieldsUnitWithElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL | struct NoFieldsUnitWithElementCount;
    = help: scalable vector types' only field must be a primitive scalar type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:20:1
+  --> $DIR/illformed.rs:21:1
    |
 LL | struct NoFieldsStructWithoutElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL | struct NoFieldsStructWithoutElementCount {}
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:25:1
+  --> $DIR/illformed.rs:26:1
    |
 LL | struct NoFieldsTupleWithoutElementCount();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL | struct NoFieldsTupleWithoutElementCount();
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:29:1
+  --> $DIR/illformed.rs:30:1
    |
 LL | struct NoFieldsUnitWithoutElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -98,25 +98,25 @@ LL | struct NoFieldsUnitWithoutElementCount;
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
 error: scalable vectors cannot have multiple fields
-  --> $DIR/illformed.rs:34:1
+  --> $DIR/illformed.rs:35:1
    |
 LL | struct MultipleFieldsStructWithElementCount {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors cannot have multiple fields
-  --> $DIR/illformed.rs:42:1
+  --> $DIR/illformed.rs:43:1
    |
 LL | struct MultipleFieldsTupleWithElementCount(f32, u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed.rs:48:5
+  --> $DIR/illformed.rs:49:5
    |
 LL |     _ty: f32,
    |     ^^^^^^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed.rs:54:47
+  --> $DIR/illformed.rs:55:47
    |
 LL | struct MultipleFieldsTupleWithoutElementCount(f32, u32);
    |                                               ^^^
diff --git a/tests/ui/scalable-vectors/invalid.rs b/tests/ui/scalable-vectors/invalid.rs
index 90e9839c9e11..0b6a915e5ccd 100644
--- a/tests/ui/scalable-vectors/invalid.rs
+++ b/tests/ui/scalable-vectors/invalid.rs
@@ -1,4 +1,5 @@
 //@ edition: 2024
+//@ only-aarch64
 #![allow(internal_features, unused_imports, unused_macros)]
 #![feature(extern_types)]
 #![feature(gen_blocks)]
diff --git a/tests/ui/scalable-vectors/invalid.stderr b/tests/ui/scalable-vectors/invalid.stderr
index d73b5abf7030..a8ef99e2f8bc 100644
--- a/tests/ui/scalable-vectors/invalid.stderr
+++ b/tests/ui/scalable-vectors/invalid.stderr
@@ -1,11 +1,11 @@
 error: allow, cfg, cfg_attr, deny, expect, forbid, and warn are the only allowed built-in attributes in function parameters
-  --> $DIR/invalid.rs:109:11
+  --> $DIR/invalid.rs:110:11
    |
 LL | fn barqux(#[rustc_scalable_vector(4)] _x: u32) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on extern crates
-  --> $DIR/invalid.rs:9:1
+  --> $DIR/invalid.rs:10:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on use statements
-  --> $DIR/invalid.rs:13:1
+  --> $DIR/invalid.rs:14:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on statics
-  --> $DIR/invalid.rs:17:1
+  --> $DIR/invalid.rs:18:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on constants
-  --> $DIR/invalid.rs:21:1
+  --> $DIR/invalid.rs:22:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on modules
-  --> $DIR/invalid.rs:25:1
+  --> $DIR/invalid.rs:26:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on foreign modules
-  --> $DIR/invalid.rs:30:1
+  --> $DIR/invalid.rs:31:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on foreign statics
-  --> $DIR/invalid.rs:33:5
+  --> $DIR/invalid.rs:34:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on foreign types
-  --> $DIR/invalid.rs:36:5
+  --> $DIR/invalid.rs:37:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on foreign functions
-  --> $DIR/invalid.rs:39:5
+  --> $DIR/invalid.rs:40:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on type aliases
-  --> $DIR/invalid.rs:44:1
+  --> $DIR/invalid.rs:45:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on enums
-  --> $DIR/invalid.rs:48:1
+  --> $DIR/invalid.rs:49:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on type parameters
-  --> $DIR/invalid.rs:50:10
+  --> $DIR/invalid.rs:51:10
    |
 LL | enum Bar<#[rustc_scalable_vector(4)] T> {
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL | enum Bar<#[rustc_scalable_vector(4)] T> {
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on enum variants
-  --> $DIR/invalid.rs:52:5
+  --> $DIR/invalid.rs:53:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on struct fields
-  --> $DIR/invalid.rs:58:5
+  --> $DIR/invalid.rs:59:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on unions
-  --> $DIR/invalid.rs:63:1
+  --> $DIR/invalid.rs:64:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -125,7 +125,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on traits
-  --> $DIR/invalid.rs:70:1
+  --> $DIR/invalid.rs:71:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on associated types
-  --> $DIR/invalid.rs:73:5
+  --> $DIR/invalid.rs:74:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on associated consts
-  --> $DIR/invalid.rs:76:5
+  --> $DIR/invalid.rs:77:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on provided trait methods
-  --> $DIR/invalid.rs:79:5
+  --> $DIR/invalid.rs:80:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on trait aliases
-  --> $DIR/invalid.rs:84:1
+  --> $DIR/invalid.rs:85:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on inherent impl blocks
-  --> $DIR/invalid.rs:88:1
+  --> $DIR/invalid.rs:89:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -173,7 +173,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on inherent methods
-  --> $DIR/invalid.rs:91:5
+  --> $DIR/invalid.rs:92:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on trait impl blocks
-  --> $DIR/invalid.rs:96:1
+  --> $DIR/invalid.rs:97:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -189,7 +189,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on macro defs
-  --> $DIR/invalid.rs:103:1
+  --> $DIR/invalid.rs:104:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on functions
-  --> $DIR/invalid.rs:107:1
+  --> $DIR/invalid.rs:108:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on function params
-  --> $DIR/invalid.rs:109:11
+  --> $DIR/invalid.rs:110:11
    |
 LL | fn barqux(#[rustc_scalable_vector(4)] _x: u32) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL | fn barqux(#[rustc_scalable_vector(4)] _x: u32) {}
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on functions
-  --> $DIR/invalid.rs:113:1
+  --> $DIR/invalid.rs:114:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -221,7 +221,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on functions
-  --> $DIR/invalid.rs:117:1
+  --> $DIR/invalid.rs:118:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on functions
-  --> $DIR/invalid.rs:121:1
+  --> $DIR/invalid.rs:122:1
    |
 LL | #[rustc_scalable_vector(4)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL | #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on closures
-  --> $DIR/invalid.rs:126:14
+  --> $DIR/invalid.rs:127:14
    |
 LL |     let _x = #[rustc_scalable_vector(4)] || { };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -245,7 +245,7 @@ LL |     let _x = #[rustc_scalable_vector(4)] || { };
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on expressions
-  --> $DIR/invalid.rs:128:14
+  --> $DIR/invalid.rs:129:14
    |
 LL |     let _y = #[rustc_scalable_vector(4)] 3 + 4;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL |     let _y = #[rustc_scalable_vector(4)] 3 + 4;
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on statements
-  --> $DIR/invalid.rs:130:5
+  --> $DIR/invalid.rs:131:5
    |
 LL |     #[rustc_scalable_vector(4)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL |     #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error: `#[rustc_scalable_vector]` attribute cannot be used on match arms
-  --> $DIR/invalid.rs:135:9
+  --> $DIR/invalid.rs:136:9
    |
 LL |         #[rustc_scalable_vector(4)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -269,7 +269,7 @@ LL |         #[rustc_scalable_vector(4)]
    = help: `#[rustc_scalable_vector]` can only be applied to structs
 
 error[E0539]: malformed `rustc_scalable_vector` attribute input
-  --> $DIR/invalid.rs:142:1
+  --> $DIR/invalid.rs:143:1
    |
 LL | #[rustc_scalable_vector("4")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^---^^
@@ -286,7 +286,7 @@ LL + #[rustc_scalable_vector]
    |
 
 error[E0805]: malformed `rustc_scalable_vector` attribute input
-  --> $DIR/invalid.rs:146:1
+  --> $DIR/invalid.rs:147:1
    |
 LL | #[rustc_scalable_vector(4, 2)]
    | ^^^^^^^^^^^^^^^^^^^^^^^------^
@@ -303,7 +303,7 @@ LL + #[rustc_scalable_vector]
    |
 
 error[E0539]: malformed `rustc_scalable_vector` attribute input
-  --> $DIR/invalid.rs:150:1
+  --> $DIR/invalid.rs:151:1
    |
 LL | #[rustc_scalable_vector(count = "4")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^-----------^^
@@ -320,7 +320,7 @@ LL + #[rustc_scalable_vector]
    |
 
 error: element count in `rustc_scalable_vector` is too large: `65536`
-  --> $DIR/invalid.rs:154:1
+  --> $DIR/invalid.rs:155:1
    |
 LL | #[rustc_scalable_vector(65536)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -328,7 +328,7 @@ LL | #[rustc_scalable_vector(65536)]
    = note: the value may not exceed `u16::MAX`
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/invalid.rs:162:18
+  --> $DIR/invalid.rs:163:18
    |
 LL | struct OkayNoArg(f32);
    |                  ^^^
diff --git a/tests/ui/scalable-vectors/wellformed-arrays.rs b/tests/ui/scalable-vectors/wellformed-arrays.rs
index b8f0bf291eea..6a26a8595fa6 100644
--- a/tests/ui/scalable-vectors/wellformed-arrays.rs
+++ b/tests/ui/scalable-vectors/wellformed-arrays.rs
@@ -1,5 +1,6 @@
 //@ check-pass
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![feature(rustc_attrs)]
 
 #[rustc_scalable_vector(16)]
diff --git a/tests/ui/scalable-vectors/wellformed.rs b/tests/ui/scalable-vectors/wellformed.rs
index cb6a22d6c433..da300d53ef88 100644
--- a/tests/ui/scalable-vectors/wellformed.rs
+++ b/tests/ui/scalable-vectors/wellformed.rs
@@ -1,5 +1,6 @@
 //@ check-pass
 //@ compile-flags: --crate-type=lib
+//@ only-aarch64
 #![feature(rustc_attrs)]
 
 #[rustc_scalable_vector(16)]

From 44d6cd2344cd636f4ea371d56ae3d27aaa110ad6 Mon Sep 17 00:00:00 2001
From: Alan Somers <asomers@gmail.com>
Date: Thu, 5 Mar 2026 12:46:23 -0700
Subject: [PATCH 0247/1059] Fix environ on FreeBSD with cdylib targets that use
 -Wl,--no-undefined .

Instead of relying on the linker to find the 'environ' symbol, use
dlsym.

Fixes #153451
Sponsored by:	ConnectWise
---
 library/std/src/sys/env/unix.rs | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/env/unix.rs b/library/std/src/sys/env/unix.rs
index 66805ce3fa71..7a19f97b3ad5 100644
--- a/library/std/src/sys/env/unix.rs
+++ b/library/std/src/sys/env/unix.rs
@@ -38,8 +38,25 @@ pub unsafe fn environ() -> *mut *const *const c_char {
     unsafe { libc::_NSGetEnviron() as *mut *const *const c_char }
 }
 
+// On FreeBSD, environ comes from CRT rather than libc
+#[cfg(target_os = "freebsd")]
+pub unsafe fn environ() -> *mut *const *const c_char {
+    use crate::sync::LazyLock;
+
+    struct Environ(*mut *const *const c_char);
+    unsafe impl Send for Environ {}
+    unsafe impl Sync for Environ {}
+
+    static ENVIRON: LazyLock<Environ> = LazyLock::new(|| {
+        Environ(unsafe {
+            libc::dlsym(libc::RTLD_DEFAULT, c"environ".as_ptr()) as *mut *const *const c_char
+        })
+    });
+    ENVIRON.0
+}
+
 // Use the `environ` static which is part of POSIX.
-#[cfg(not(target_vendor = "apple"))]
+#[cfg(not(any(target_os = "freebsd", target_vendor = "apple")))]
 pub unsafe fn environ() -> *mut *const *const c_char {
     unsafe extern "C" {
         static mut environ: *const *const c_char;

From 2c7690e1e6b18ebf51e84e4b08a35903cee64f6b Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Mon, 9 Mar 2026 23:36:26 +0800
Subject: [PATCH 0248/1059] Mark stable features as used to avoid trigger
 unused_features

---
 compiler/rustc_passes/src/stability.rs          |  6 ++++++
 .../ui/lint/unused-features/stable-features.rs  | 17 +++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 tests/ui/lint/unused-features/stable-features.rs

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index ec6d48cbea2e..18263506a03b 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -964,6 +964,9 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
     let mut lang_features = UnordSet::default();
     for EnabledLangFeature { gate_name, attr_sp, stable_since } in enabled_lang_features {
         if let Some(version) = stable_since {
+            // Mark the feature as enabled, to ensure that it is not marked as unused.
+            let _ = tcx.features().enabled(*gate_name);
+
             // Warn if the user has enabled an already-stable lang feature.
             unnecessary_stable_feature_lint(tcx, *attr_sp, *gate_name, *version);
         }
@@ -1021,6 +1024,9 @@ fn check_features<'tcx>(
             if let FeatureStability::AcceptedSince(since) = stability
                 && let Some(span) = remaining_lib_features.get(&feature)
             {
+                // Mark the feature as enabled, to ensure that it is not marked as unused.
+                let _ = tcx.features().enabled(feature);
+
                 // Warn if the user has enabled an already-stable lib feature.
                 if let Some(implies) = all_implications.get(&feature) {
                     unnecessary_partially_stable_feature_lint(tcx, *span, feature, *implies, since);
diff --git a/tests/ui/lint/unused-features/stable-features.rs b/tests/ui/lint/unused-features/stable-features.rs
new file mode 100644
index 000000000000..d27be14b86d5
--- /dev/null
+++ b/tests/ui/lint/unused-features/stable-features.rs
@@ -0,0 +1,17 @@
+//@ check-pass
+
+#![deny(warnings)]
+#![allow(stable_features)]
+
+// Lang feature
+#![feature(lint_reasons)]
+
+// Lib feature
+#![feature(euclidean_division)]
+
+#[allow(unused_variables, reason = "my reason")]
+fn main() {
+    let x = ();
+
+    let _ = 42.0_f32.div_euclid(3.0);
+}

From dfd5e905c5f26a2ae9682468b1c30a6ccd60cc20 Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Mon, 9 Mar 2026 23:38:30 +0800
Subject: [PATCH 0249/1059] Bless other tests

---
 .../ui/lint/unused-features/unused-library-features.rs |  3 +--
 .../unused-features/unused-library-features.stderr     | 10 ++--------
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/tests/ui/lint/unused-features/unused-library-features.rs b/tests/ui/lint/unused-features/unused-library-features.rs
index 75afd32e56cb..2f53ab66b160 100644
--- a/tests/ui/lint/unused-features/unused-library-features.rs
+++ b/tests/ui/lint/unused-features/unused-library-features.rs
@@ -5,8 +5,7 @@
 #![feature(step_trait)]
 //~^ ERROR feature `step_trait` is declared but not used
 #![feature(is_sorted)]
-//~^ ERROR feature `is_sorted` is declared but not used
-//~^^ WARN the feature `is_sorted` has been stable since 1.82.0 and no longer requires an attribute to enable
+//~^ WARN the feature `is_sorted` has been stable since 1.82.0 and no longer requires an attribute to enable
 
 // Enabled via cfg_attr, unused
 #![cfg_attr(all(), feature(slice_ptr_get))]
diff --git a/tests/ui/lint/unused-features/unused-library-features.stderr b/tests/ui/lint/unused-features/unused-library-features.stderr
index e259058d6c33..bf71e269e2f0 100644
--- a/tests/ui/lint/unused-features/unused-library-features.stderr
+++ b/tests/ui/lint/unused-features/unused-library-features.stderr
@@ -18,17 +18,11 @@ note: the lint level is defined here
 LL | #![deny(unused_features)]
    |         ^^^^^^^^^^^^^^^
 
-error: feature `is_sorted` is declared but not used
-  --> $DIR/unused-library-features.rs:7:12
-   |
-LL | #![feature(is_sorted)]
-   |            ^^^^^^^^^
-
 error: feature `slice_ptr_get` is declared but not used
-  --> $DIR/unused-library-features.rs:12:28
+  --> $DIR/unused-library-features.rs:11:28
    |
 LL | #![cfg_attr(all(), feature(slice_ptr_get))]
    |                            ^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors; 1 warning emitted
 

From 28131e1b8f7dfe58935cd8dbe25e70fe95781080 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 17:18:55 +0100
Subject: [PATCH 0250/1059] Update `sysinfo` version to `0.38.4`

---
 Cargo.lock                    | 12 ++++++------
 src/bootstrap/Cargo.lock      | 12 ++++++------
 src/bootstrap/Cargo.toml      |  2 +-
 src/tools/opt-dist/Cargo.toml |  2 +-
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1e6d8f682d04..039dc0b0ea4d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2622,9 +2622,9 @@ dependencies = [
 
 [[package]]
 name = "objc2-core-foundation"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
  "bitflags",
 ]
@@ -2637,9 +2637,9 @@ checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
 
 [[package]]
 name = "objc2-io-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71c1c64d6120e51cd86033f67176b1cb66780c2efe34dec55176f77befd93c0a"
+checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15"
 dependencies = [
  "libc",
  "objc2-core-foundation",
@@ -5315,9 +5315,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.38.2"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1efc19935b4b66baa6f654ac7924c192f55b175c00a7ab72410fc24284dacda8"
+checksum = "92ab6a2f8bfe508deb3c6406578252e491d299cbbf3bc0529ecc3313aee4a52f"
 dependencies = [
  "libc",
  "objc2-core-foundation",
diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index f9499d9927f2..d694f8e13f11 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -472,18 +472,18 @@ dependencies = [
 
 [[package]]
 name = "objc2-core-foundation"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "objc2-io-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71c1c64d6120e51cd86033f67176b1cb66780c2efe34dec55176f77befd93c0a"
+checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15"
 dependencies = [
  "libc",
  "objc2-core-foundation",
@@ -743,9 +743,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.38.2"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1efc19935b4b66baa6f654ac7924c192f55b175c00a7ab72410fc24284dacda8"
+checksum = "92ab6a2f8bfe508deb3c6406578252e491d299cbbf3bc0529ecc3313aee4a52f"
 dependencies = [
  "libc",
  "memchr",
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index 0019e9e6d92e..7187a5a951de 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -57,7 +57,7 @@ walkdir = "2.4"
 xz2 = "0.1"
 
 # Dependencies needed by the build-metrics feature
-sysinfo = { version = "0.38.2", default-features = false, optional = true, features = ["system"] }
+sysinfo = { version = "0.38.4", default-features = false, optional = true, features = ["system"] }
 
 # Dependencies needed by the `tracing` feature
 chrono = { version = "0.4", default-features = false, optional = true, features = ["now", "std"] }
diff --git a/src/tools/opt-dist/Cargo.toml b/src/tools/opt-dist/Cargo.toml
index b6547eff007b..29d302b52566 100644
--- a/src/tools/opt-dist/Cargo.toml
+++ b/src/tools/opt-dist/Cargo.toml
@@ -10,7 +10,7 @@ log = "0.4"
 anyhow = "1"
 humantime = "2"
 humansize = "2"
-sysinfo = { version = "0.38.2", default-features = false, features = ["disk"] }
+sysinfo = { version = "0.38.4", default-features = false, features = ["disk"] }
 fs_extra = "1"
 camino = "1"
 tar = "0.4"

From db5599bf29565f08960c70b9d67536841e4ae978 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 9 Mar 2026 18:01:03 +0100
Subject: [PATCH 0251/1059] Update books

---
 src/doc/embedded-book | 2 +-
 src/doc/nomicon       | 2 +-
 src/doc/reference     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index 99d0341ff4e0..e88aa4403b4b 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit 99d0341ff4e06757490af8fceee790c4ede50bc0
+Subproject commit e88aa4403b4bf2071c8df9509160477e40179099
diff --git a/src/doc/nomicon b/src/doc/nomicon
index b8f254a991b8..cc6a6bae8c3b 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit b8f254a991b8b7e8f704527f0d4f343a4697dfa9
+Subproject commit cc6a6bae8c3bfa389974e533c54694662c1a9de6
diff --git a/src/doc/reference b/src/doc/reference
index 50a1075e879b..c49e89cc8c7c 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 50a1075e879be75aeec436252c84eef0fad489f4
+Subproject commit c49e89cc8c7c2c43ca625a8d5b7ad9a53a9ce978

From 4c48a5bf5f2684f4021b46f9adb6fa3e8587bf8b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 18:07:09 +0100
Subject: [PATCH 0252/1059] Remove usage of `TyCtxt::node_span_lint` in
 librustdoc

---
 src/librustdoc/passes/lint/bare_urls.rs | 53 ++++++++++++++-----------
 1 file changed, 29 insertions(+), 24 deletions(-)

diff --git a/src/librustdoc/passes/lint/bare_urls.rs b/src/librustdoc/passes/lint/bare_urls.rs
index 49fca2ded677..44fff58eb261 100644
--- a/src/librustdoc/passes/lint/bare_urls.rs
+++ b/src/librustdoc/passes/lint/bare_urls.rs
@@ -6,7 +6,7 @@
 use std::sync::LazyLock;
 
 use regex::Regex;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, DiagDecorator};
 use rustc_hir::HirId;
 use rustc_resolve::rustdoc::pulldown_cmark::{Event, Parser, Tag};
 use rustc_resolve::rustdoc::source_span_for_markdown_range;
@@ -24,30 +24,35 @@ pub(super) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
         let maybe_sp = source_span_for_markdown_range(cx.tcx, dox, &range, &item.attrs.doc_strings)
             .map(|(sp, _)| sp);
         let sp = maybe_sp.unwrap_or_else(|| item.attr_span(cx.tcx));
-        cx.tcx.node_span_lint(crate::lint::BARE_URLS, hir_id, sp, |lint| {
-            lint.primary_message(msg)
-                .note("bare URLs are not automatically turned into clickable links");
-            // The fallback of using the attribute span is suitable for
-            // highlighting where the error is, but not for placing the < and >
-            if let Some(sp) = maybe_sp {
-                if let Some(without_brackets) = without_brackets {
-                    lint.multipart_suggestion(
-                        "use an automatic link instead",
-                        vec![(sp, format!("<{without_brackets}>"))],
-                        Applicability::MachineApplicable,
-                    );
-                } else {
-                    lint.multipart_suggestion(
-                        "use an automatic link instead",
-                        vec![
-                            (sp.shrink_to_lo(), "<".to_string()),
-                            (sp.shrink_to_hi(), ">".to_string()),
-                        ],
-                        Applicability::MachineApplicable,
-                    );
+        cx.tcx.emit_node_span_lint(
+            crate::lint::BARE_URLS,
+            hir_id,
+            sp,
+            DiagDecorator(|lint| {
+                lint.primary_message(msg)
+                    .note("bare URLs are not automatically turned into clickable links");
+                // The fallback of using the attribute span is suitable for
+                // highlighting where the error is, but not for placing the < and >
+                if let Some(sp) = maybe_sp {
+                    if let Some(without_brackets) = without_brackets {
+                        lint.multipart_suggestion(
+                            "use an automatic link instead",
+                            vec![(sp, format!("<{without_brackets}>"))],
+                            Applicability::MachineApplicable,
+                        );
+                    } else {
+                        lint.multipart_suggestion(
+                            "use an automatic link instead",
+                            vec![
+                                (sp.shrink_to_lo(), "<".to_string()),
+                                (sp.shrink_to_hi(), ">".to_string()),
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+                    }
                 }
-            }
-        });
+            }),
+        );
     };
 
     let mut p = Parser::new_ext(dox, main_body_opts()).into_offset_iter();

From c5c8d6bac78d57da9e5c71969fc5e52b5f384efe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Mon, 9 Mar 2026 18:16:46 +0100
Subject: [PATCH 0253/1059] Ping fmease on parser modifications

---
 triagebot.toml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 8d6401c49056..55f30978f48a 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1012,6 +1012,13 @@ cc = ["@lcnr"]
 message = "HIR ty lowering was modified"
 cc = ["@fmease"]
 
+[mentions."compiler/rustc_parse"]
+message = """
+The parser was modified, potentially altering the grammar of (stable) Rust
+which would be a breaking change.
+"""
+cc = ["@fmease"]
+
 [mentions."library/core/src/mem/type_info.rs"]
 message = """
 The reflection data structures are tied exactly to the implementation

From 59dfb9ef46bd43cbd26bba5de463fbaf77e39fac Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 18:42:28 +0100
Subject: [PATCH 0254/1059] remove concept of soft-unstable features

---
 .../src/attributes/stability.rs               | 17 +---
 .../src/session_diagnostics.rs                |  7 --
 compiler/rustc_hir/src/stability.rs           |  1 -
 compiler/rustc_lint/src/lib.rs                |  1 +
 compiler/rustc_lint_defs/src/builtin.rs       | 17 ----
 compiler/rustc_middle/src/middle/stability.rs | 56 ++++---------
 compiler/rustc_passes/src/stability.rs        |  1 -
 compiler/rustc_resolve/src/errors.rs          | 13 +---
 compiler/rustc_resolve/src/macros.rs          | 15 +---
 compiler/rustc_span/src/symbol.rs             |  1 -
 src/librustdoc/clean/types.rs                 |  2 +-
 .../issue-43106-gating-of-test.rs             |  1 -
 .../issue-43106-gating-of-test.stderr         |  2 +-
 tests/ui/imports/issue-28134.rs               |  1 -
 tests/ui/imports/issue-28134.stderr           |  2 +-
 tests/ui/where-clauses/cfg_attribute.a.stderr | 78 +++++++++----------
 tests/ui/where-clauses/cfg_attribute.b.stderr | 78 +++++++++----------
 tests/ui/where-clauses/cfg_attribute.rs       |  1 -
 .../ui/where-clauses/unsupported_attribute.rs |  1 -
 .../unsupported_attribute.stderr              | 40 +++++-----
 20 files changed, 118 insertions(+), 217 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index e35c10996ceb..6ddd9f2c1fb5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -376,7 +376,6 @@ pub(crate) fn parse_unstability<S: Stage>(
     let mut reason = None;
     let mut issue = None;
     let mut issue_num = None;
-    let mut is_soft = false;
     let mut implied_by = None;
     let mut old_name = None;
 
@@ -423,12 +422,6 @@ pub(crate) fn parse_unstability<S: Stage>(
                     },
                 };
             }
-            Some(sym::soft) => {
-                if let Err(span) = args.no_args() {
-                    cx.emit_err(session_diagnostics::SoftNoArgs { span });
-                }
-                is_soft = true;
-            }
             Some(sym::implied_by) => {
                 insert_value_into_option_or_error(cx, &param, &mut implied_by, word.unwrap())?
             }
@@ -438,14 +431,7 @@ pub(crate) fn parse_unstability<S: Stage>(
             _ => {
                 cx.expected_specific_argument(
                     param.span(),
-                    &[
-                        sym::feature,
-                        sym::reason,
-                        sym::issue,
-                        sym::soft,
-                        sym::implied_by,
-                        sym::old_name,
-                    ],
+                    &[sym::feature, sym::reason, sym::issue, sym::implied_by, sym::old_name],
                 );
                 return None;
             }
@@ -468,7 +454,6 @@ pub(crate) fn parse_unstability<S: Stage>(
             let level = StabilityLevel::Unstable {
                 reason: UnstableReason::from_opt_reason(reason),
                 issue: issue_num,
-                is_soft,
                 implied_by,
                 old_name,
             };
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 7c2044ec235a..751b8f8646ab 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -374,13 +374,6 @@ pub(crate) struct InvalidSince {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("`soft` should not have any arguments")]
-pub(crate) struct SoftNoArgs {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("unknown version literal format, assuming it refers to a future version")]
 pub(crate) struct UnknownVersionLiteral {
diff --git a/compiler/rustc_hir/src/stability.rs b/compiler/rustc_hir/src/stability.rs
index 9297f8e6cdcd..d00e1f2d4e8c 100644
--- a/compiler/rustc_hir/src/stability.rs
+++ b/compiler/rustc_hir/src/stability.rs
@@ -112,7 +112,6 @@ pub enum StabilityLevel {
         reason: UnstableReason,
         /// Relevant `rust-lang/rust` issue.
         issue: Option<NonZero<u32>>,
-        is_soft: bool,
         /// If part of a feature is stabilized and a new feature is added for the remaining parts,
         /// then the `implied_by` attribute is used to indicate which now-stable feature previously
         /// contained an item.
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 1790eac7bef5..2f773b9e166c 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -642,6 +642,7 @@ macro_rules! add_lint_group {
          see <https://github.com/rust-lang/rust/issues/40107> for more information",
     );
     store.register_removed("wasm_c_abi", "the wasm C ABI has been fixed");
+    store.register_removed("soft_unstable", "the general soft-unstable mechanism has been removed");
 }
 
 fn register_internals(store: &mut LintStore) {
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 38ffecbafa06..0fcc6e4524a5 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -105,7 +105,6 @@
         SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
         SHADOWING_SUPERTRAIT_ITEMS,
         SINGLE_USE_LIFETIMES,
-        SOFT_UNSTABLE,
         STABLE_FEATURES,
         TAIL_EXPR_DROP_ORDER,
         TEST_UNSTABLE_LINT,
@@ -2317,22 +2316,6 @@
     };
 }
 
-declare_lint! {
-    /// The `soft_unstable` lint detects unstable features that were unintentionally allowed on
-    /// stable. This is a [future-incompatible] lint to transition this to a hard error in the
-    /// future. See [issue #64266] for more details.
-    ///
-    /// [issue #64266]: https://github.com/rust-lang/rust/issues/64266
-    /// [future-incompatible]: ../index.md#future-incompatible-lints
-    pub SOFT_UNSTABLE,
-    Deny,
-    "a feature gate that doesn't break dependent crates",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: fcw!(FutureReleaseError #64266),
-        report_in_deps: true,
-    };
-}
-
 declare_lint! {
     /// The `inline_no_sanitize` lint detects incompatible use of
     /// [`#[inline(always)]`][inline] and [`#[sanitize(xyz = "off")]`][sanitize].
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 06e4a287460b..e76c9a8c0b5a 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -11,7 +11,7 @@
 use rustc_hir::{self as hir, ConstStability, DefaultBodyStability, HirId, Stability};
 use rustc_macros::{Decodable, Encodable, HashStable, Subdiagnostic};
 use rustc_session::Session;
-use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE};
+use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE};
 use rustc_session::lint::{BuiltinLintDiag, DeprecatedSinceKind, Level, Lint};
 use rustc_session::parse::feature_err_issue;
 use rustc_span::{Span, Symbol, sym};
@@ -68,9 +68,7 @@ pub fn report_unstable(
     reason: Option<Symbol>,
     issue: Option<NonZero<u32>>,
     suggestion: Option<(Span, String, String, Applicability)>,
-    is_soft: bool,
     span: Span,
-    soft_handler: impl FnOnce(&'static Lint, Span, String),
     kind: UnstableKind,
 ) {
     let qual = match kind {
@@ -83,18 +81,14 @@ pub fn report_unstable(
         None => format!("use of unstable{qual} library feature `{feature}`"),
     };
 
-    if is_soft {
-        soft_handler(SOFT_UNSTABLE, span, msg)
-    } else {
-        let mut err = feature_err_issue(sess, feature, span, GateIssue::Library(issue), msg);
-        if let Some((inner_types, msg, sugg, applicability)) = suggestion {
-            err.span_suggestion(inner_types, msg, sugg, applicability);
-        }
-        if let UnstableKind::Const(kw) = kind {
-            err.span_label(kw, "trait is not stable as const yet");
-        }
-        err.emit();
+    let mut err = feature_err_issue(sess, feature, span, GateIssue::Library(issue), msg);
+    if let Some((inner_types, msg, sugg, applicability)) = suggestion {
+        err.span_suggestion(inner_types, msg, sugg, applicability);
     }
+    if let UnstableKind::Const(kw) = kind {
+        err.span_label(kw, "trait is not stable as const yet");
+    }
+    err.emit();
 }
 
 fn deprecation_lint(is_in_effect: bool) -> &'static Lint {
@@ -266,7 +260,6 @@ pub enum EvalResult {
         reason: Option<Symbol>,
         issue: Option<NonZero<u32>>,
         suggestion: Option<(Span, String, String, Applicability)>,
-        is_soft: bool,
     },
     /// The item does not have the `#[stable]` or `#[unstable]` marker assigned.
     Unmarked,
@@ -386,7 +379,7 @@ pub fn eval_stability_allow_unstable(
 
         match stability {
             Some(Stability {
-                level: hir::StabilityLevel::Unstable { reason, issue, is_soft, implied_by, .. },
+                level: hir::StabilityLevel::Unstable { reason, issue, implied_by, .. },
                 feature,
                 ..
             }) => {
@@ -428,13 +421,7 @@ pub fn eval_stability_allow_unstable(
                 }
 
                 let suggestion = suggestion_for_allocator_api(self, def_id, span, feature);
-                EvalResult::Deny {
-                    feature,
-                    reason: reason.to_opt_reason(),
-                    issue,
-                    suggestion,
-                    is_soft,
-                }
+                EvalResult::Deny { feature, reason: reason.to_opt_reason(), issue, suggestion }
             }
             Some(_) => {
                 // Stable APIs are always ok to call and deprecated APIs are
@@ -469,7 +456,7 @@ pub fn eval_default_body_stability(self, def_id: DefId, span: Span) -> EvalResul
 
         match stability {
             Some(DefaultBodyStability {
-                level: hir::StabilityLevel::Unstable { reason, issue, is_soft, .. },
+                level: hir::StabilityLevel::Unstable { reason, issue, .. },
                 feature,
             }) => {
                 if span.allows_unstable(feature) {
@@ -485,7 +472,6 @@ pub fn eval_default_body_stability(self, def_id: DefId, span: Span) -> EvalResul
                     reason: reason.to_opt_reason(),
                     issue,
                     suggestion: None,
-                    is_soft,
                 }
             }
             Some(_) => {
@@ -563,30 +549,18 @@ pub fn check_optional_stability(
         allow_unstable: AllowUnstable,
         unmarked: impl FnOnce(Span, DefId),
     ) -> bool {
-        let soft_handler = |lint, span, msg: String| {
-            self.emit_node_span_lint(
-                lint,
-                id.unwrap_or(hir::CRATE_HIR_ID),
-                span,
-                rustc_errors::DiagDecorator(|lint| {
-                    lint.primary_message(msg);
-                }),
-            );
-        };
         let eval_result =
             self.eval_stability_allow_unstable(def_id, id, span, method_span, allow_unstable);
         let is_allowed = matches!(eval_result, EvalResult::Allow);
         match eval_result {
             EvalResult::Allow => {}
-            EvalResult::Deny { feature, reason, issue, suggestion, is_soft } => report_unstable(
+            EvalResult::Deny { feature, reason, issue, suggestion } => report_unstable(
                 self.sess,
                 feature,
                 reason,
                 issue,
                 suggestion,
-                is_soft,
                 span,
-                soft_handler,
                 UnstableKind::Regular,
             ),
             EvalResult::Unmarked => unmarked(span, def_id),
@@ -623,12 +597,10 @@ pub fn check_const_stability(self, def_id: DefId, span: Span, const_kw_span: Spa
 
         match stability {
             Some(ConstStability {
-                level: hir::StabilityLevel::Unstable { reason, issue, is_soft, implied_by, .. },
+                level: hir::StabilityLevel::Unstable { reason, issue, implied_by, .. },
                 feature,
                 ..
             }) => {
-                assert!(!is_soft);
-
                 if span.allows_unstable(feature) {
                     debug!("body stability: skipping span={:?} since it is internal", span);
                     return;
@@ -652,9 +624,7 @@ pub fn check_const_stability(self, def_id: DefId, span: Span, const_kw_span: Spa
                     reason.to_opt_reason(),
                     issue,
                     None,
-                    false,
                     span,
-                    |_, _, _| {},
                     UnstableKind::Const(const_kw_span),
                 );
             }
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index ec6d48cbea2e..9b13e4841ea5 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -131,7 +131,6 @@ fn inherit_stability(def_kind: DefKind) -> bool {
     level: StabilityLevel::Unstable {
         reason: UnstableReason::Default,
         issue: NonZero::new(27812),
-        is_soft: false,
         implied_by: None,
         old_name: None,
     },
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 63ffdbc37f7d..a56d91492f67 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1,7 +1,7 @@
 use rustc_errors::codes::*;
 use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{
-    Applicability, Diag, DiagCtxtHandle, DiagMessage, Diagnostic, ElidedLifetimeInPathSubdiag,
+    Applicability, Diag, DiagCtxtHandle, Diagnostic, ElidedLifetimeInPathSubdiag,
     EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic, msg,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
@@ -1454,17 +1454,6 @@ pub(crate) struct MacroRuleNeverUsed {
     pub name: Symbol,
 }
 
-pub(crate) struct UnstableFeature {
-    pub msg: DiagMessage,
-}
-
-impl<'a> Diagnostic<'a, ()> for UnstableFeature {
-    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
-        let Self { msg } = self;
-        Diag::new(dcx, level, msg)
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag("`extern crate` is not idiomatic in the new edition")]
 pub(crate) struct ExternCrateNotIdiomatic {
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 551d89ee6022..dd38679f36e7 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -1064,8 +1064,7 @@ fn check_stability_and_deprecation(
     ) {
         let span = path.span;
         if let Some(stability) = &ext.stability
-            && let StabilityLevel::Unstable { reason, issue, is_soft, implied_by, .. } =
-                stability.level
+            && let StabilityLevel::Unstable { reason, issue, implied_by, .. } = stability.level
         {
             let feature = stability.feature;
 
@@ -1073,25 +1072,13 @@ fn check_stability_and_deprecation(
                 |feature| self.tcx.features().enabled(feature) || span.allows_unstable(feature);
             let allowed_by_implication = implied_by.is_some_and(|feature| is_allowed(feature));
             if !is_allowed(feature) && !allowed_by_implication {
-                let lint_buffer = &mut self.lint_buffer;
-                let soft_handler = |lint, span, msg: String| {
-                    lint_buffer.buffer_lint(
-                        lint,
-                        node_id,
-                        span,
-                        // FIXME make this translatable
-                        errors::UnstableFeature { msg: msg.into() },
-                    )
-                };
                 stability::report_unstable(
                     self.tcx.sess,
                     feature,
                     reason.to_opt_reason(),
                     issue,
                     None,
-                    is_soft,
                     span,
-                    soft_handler,
                     stability::UnstableKind::Regular,
                 );
             }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 257ac3f51c2c..135a4c16952d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1914,7 +1914,6 @@
         slice_len_fn,
         slice_patterns,
         slicing_syntax,
-        soft,
         sparc,
         sparc64,
         sparc_target_feature,
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index c595a0ae2d48..431e9ff476f5 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -2430,7 +2430,7 @@ mod size_asserts {
     static_assert_size!(GenericParamDef, 40);
     static_assert_size!(Generics, 16);
     static_assert_size!(Item, 8);
-    static_assert_size!(ItemInner, 144);
+    static_assert_size!(ItemInner, 136);
     static_assert_size!(ItemKind, 48);
     static_assert_size!(PathSegment, 32);
     static_assert_size!(Type, 32);
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-test.rs b/tests/ui/feature-gates/issue-43106-gating-of-test.rs
index 38c92d933fdd..cc4c73d916bd 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-test.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-test.rs
@@ -1,6 +1,5 @@
 // The non-crate level cases are in issue-43106-gating-of-builtin-attrs.rs.
 
-#![allow(soft_unstable)]
 #![test                    = "4200"]
 //~^ ERROR `test` attribute cannot be used at crate level
 fn main() {}
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-test.stderr b/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
index 2fc220dc47bd..6e706b151b72 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
@@ -1,5 +1,5 @@
 error: `test` attribute cannot be used at crate level
-  --> $DIR/issue-43106-gating-of-test.rs:4:1
+  --> $DIR/issue-43106-gating-of-test.rs:3:1
    |
 LL | #![test                    = "4200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/imports/issue-28134.rs b/tests/ui/imports/issue-28134.rs
index aef2fe8facdc..01d7274098cd 100644
--- a/tests/ui/imports/issue-28134.rs
+++ b/tests/ui/imports/issue-28134.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: --test
 
-#![allow(soft_unstable)]
 #![test]
 //~^ ERROR `test` attribute cannot be used at crate level
diff --git a/tests/ui/imports/issue-28134.stderr b/tests/ui/imports/issue-28134.stderr
index e47aa15e87a9..33df87e3a747 100644
--- a/tests/ui/imports/issue-28134.stderr
+++ b/tests/ui/imports/issue-28134.stderr
@@ -1,5 +1,5 @@
 error: `test` attribute cannot be used at crate level
-  --> $DIR/issue-28134.rs:4:1
+  --> $DIR/issue-28134.rs:3:1
    |
 LL | #![test]
    | ^^^^^^^^
diff --git a/tests/ui/where-clauses/cfg_attribute.a.stderr b/tests/ui/where-clauses/cfg_attribute.a.stderr
index 0ede890eb44f..ee81072e7006 100644
--- a/tests/ui/where-clauses/cfg_attribute.a.stderr
+++ b/tests/ui/where-clauses/cfg_attribute.a.stderr
@@ -1,83 +1,83 @@
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:32:7
+  --> $DIR/cfg_attribute.rs:31:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:43:11
+  --> $DIR/cfg_attribute.rs:42:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:54:11
+  --> $DIR/cfg_attribute.rs:53:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:66:7
+  --> $DIR/cfg_attribute.rs:65:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:76:11
+  --> $DIR/cfg_attribute.rs:75:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:87:11
+  --> $DIR/cfg_attribute.rs:86:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:100:7
+  --> $DIR/cfg_attribute.rs:99:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:114:7
+  --> $DIR/cfg_attribute.rs:113:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:129:7
+  --> $DIR/cfg_attribute.rs:128:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:144:7
+  --> $DIR/cfg_attribute.rs:143:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:155:7
+  --> $DIR/cfg_attribute.rs:154:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:165:11
+  --> $DIR/cfg_attribute.rs:164:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:178:7
+  --> $DIR/cfg_attribute.rs:177:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:32:5
+  --> $DIR/cfg_attribute.rs:31:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:35:5
+  --> $DIR/cfg_attribute.rs:34:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:66:5
+  --> $DIR/cfg_attribute.rs:65:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:69:5
+  --> $DIR/cfg_attribute.rs:68:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:100:5
+  --> $DIR/cfg_attribute.rs:99:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:103:5
+  --> $DIR/cfg_attribute.rs:102:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:114:5
+  --> $DIR/cfg_attribute.rs:113:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:117:5
+  --> $DIR/cfg_attribute.rs:116:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:129:5
+  --> $DIR/cfg_attribute.rs:128:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:132:5
+  --> $DIR/cfg_attribute.rs:131:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:144:5
+  --> $DIR/cfg_attribute.rs:143:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:147:5
+  --> $DIR/cfg_attribute.rs:146:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -173,7 +173,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:155:5
+  --> $DIR/cfg_attribute.rs:154:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:158:5
+  --> $DIR/cfg_attribute.rs:157:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -189,7 +189,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:178:5
+  --> $DIR/cfg_attribute.rs:177:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:181:5
+  --> $DIR/cfg_attribute.rs:180:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:43:9
+  --> $DIR/cfg_attribute.rs:42:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:46:9
+  --> $DIR/cfg_attribute.rs:45:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -221,7 +221,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:54:9
+  --> $DIR/cfg_attribute.rs:53:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:57:9
+  --> $DIR/cfg_attribute.rs:56:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:76:9
+  --> $DIR/cfg_attribute.rs:75:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -245,7 +245,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:79:9
+  --> $DIR/cfg_attribute.rs:78:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:87:9
+  --> $DIR/cfg_attribute.rs:86:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:90:9
+  --> $DIR/cfg_attribute.rs:89:9
    |
 LL |         #[rustfmt::skip] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -269,7 +269,7 @@ LL |         #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:165:9
+  --> $DIR/cfg_attribute.rs:164:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:168:9
+  --> $DIR/cfg_attribute.rs:167:9
    |
 LL |         #[rustfmt::skip] ():,
    |         ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/where-clauses/cfg_attribute.b.stderr b/tests/ui/where-clauses/cfg_attribute.b.stderr
index 0ede890eb44f..ee81072e7006 100644
--- a/tests/ui/where-clauses/cfg_attribute.b.stderr
+++ b/tests/ui/where-clauses/cfg_attribute.b.stderr
@@ -1,83 +1,83 @@
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:32:7
+  --> $DIR/cfg_attribute.rs:31:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:43:11
+  --> $DIR/cfg_attribute.rs:42:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:54:11
+  --> $DIR/cfg_attribute.rs:53:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:66:7
+  --> $DIR/cfg_attribute.rs:65:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:76:11
+  --> $DIR/cfg_attribute.rs:75:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:87:11
+  --> $DIR/cfg_attribute.rs:86:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:100:7
+  --> $DIR/cfg_attribute.rs:99:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:114:7
+  --> $DIR/cfg_attribute.rs:113:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:129:7
+  --> $DIR/cfg_attribute.rs:128:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:144:7
+  --> $DIR/cfg_attribute.rs:143:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:155:7
+  --> $DIR/cfg_attribute.rs:154:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:165:11
+  --> $DIR/cfg_attribute.rs:164:11
    |
 LL |         #[derive(Clone)] ():,
    |           ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/cfg_attribute.rs:178:7
+  --> $DIR/cfg_attribute.rs:177:7
    |
 LL |     #[derive(Clone)] ():,
    |       ^^^^^^ not a non-macro attribute
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:32:5
+  --> $DIR/cfg_attribute.rs:31:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:35:5
+  --> $DIR/cfg_attribute.rs:34:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:66:5
+  --> $DIR/cfg_attribute.rs:65:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:69:5
+  --> $DIR/cfg_attribute.rs:68:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:100:5
+  --> $DIR/cfg_attribute.rs:99:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:103:5
+  --> $DIR/cfg_attribute.rs:102:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:114:5
+  --> $DIR/cfg_attribute.rs:113:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:117:5
+  --> $DIR/cfg_attribute.rs:116:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:129:5
+  --> $DIR/cfg_attribute.rs:128:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:132:5
+  --> $DIR/cfg_attribute.rs:131:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:144:5
+  --> $DIR/cfg_attribute.rs:143:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:147:5
+  --> $DIR/cfg_attribute.rs:146:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -173,7 +173,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:155:5
+  --> $DIR/cfg_attribute.rs:154:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:158:5
+  --> $DIR/cfg_attribute.rs:157:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -189,7 +189,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:178:5
+  --> $DIR/cfg_attribute.rs:177:5
    |
 LL |     #[derive(Clone)] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL |     #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:181:5
+  --> $DIR/cfg_attribute.rs:180:5
    |
 LL |     #[rustfmt::skip] ():,
    |     ^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL |     #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:43:9
+  --> $DIR/cfg_attribute.rs:42:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:46:9
+  --> $DIR/cfg_attribute.rs:45:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -221,7 +221,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:54:9
+  --> $DIR/cfg_attribute.rs:53:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:57:9
+  --> $DIR/cfg_attribute.rs:56:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:76:9
+  --> $DIR/cfg_attribute.rs:75:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -245,7 +245,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:79:9
+  --> $DIR/cfg_attribute.rs:78:9
    |
 LL |         #[rustfmt::skip] ():;
    |         ^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL |         #[rustfmt::skip] ():;
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:87:9
+  --> $DIR/cfg_attribute.rs:86:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:90:9
+  --> $DIR/cfg_attribute.rs:89:9
    |
 LL |         #[rustfmt::skip] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -269,7 +269,7 @@ LL |         #[rustfmt::skip] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:165:9
+  --> $DIR/cfg_attribute.rs:164:9
    |
 LL |         #[derive(Clone)] ():,
    |         ^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL |         #[derive(Clone)] ():,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:168:9
+  --> $DIR/cfg_attribute.rs:167:9
    |
 LL |         #[rustfmt::skip] ():,
    |         ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/where-clauses/cfg_attribute.rs b/tests/ui/where-clauses/cfg_attribute.rs
index 8cbca0bee75d..13ba070990b7 100644
--- a/tests/ui/where-clauses/cfg_attribute.rs
+++ b/tests/ui/where-clauses/cfg_attribute.rs
@@ -7,7 +7,6 @@
 #![feature(custom_test_frameworks)]
 #![feature(derive_const)]
 #![feature(where_clause_attrs)]
-#![allow(soft_unstable)]
 
 use std::marker::PhantomData;
 
diff --git a/tests/ui/where-clauses/unsupported_attribute.rs b/tests/ui/where-clauses/unsupported_attribute.rs
index 75213e176610..e86274f3ed5e 100644
--- a/tests/ui/where-clauses/unsupported_attribute.rs
+++ b/tests/ui/where-clauses/unsupported_attribute.rs
@@ -5,7 +5,6 @@
 #![feature(custom_test_frameworks)]
 #![feature(derive_const)]
 #![feature(where_clause_attrs)]
-#![allow(soft_unstable)]
 
 trait Trait {}
 
diff --git a/tests/ui/where-clauses/unsupported_attribute.stderr b/tests/ui/where-clauses/unsupported_attribute.stderr
index e69eff976c3f..e55a7c380c2b 100644
--- a/tests/ui/where-clauses/unsupported_attribute.stderr
+++ b/tests/ui/where-clauses/unsupported_attribute.stderr
@@ -1,17 +1,17 @@
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/unsupported_attribute.rs:28:7
+  --> $DIR/unsupported_attribute.rs:27:7
    |
 LL |     #[derive(Clone)] T: Trait,
    |       ^^^^^^ not a non-macro attribute
 
 error: expected non-macro attribute, found attribute macro `derive`
-  --> $DIR/unsupported_attribute.rs:31:7
+  --> $DIR/unsupported_attribute.rs:30:7
    |
 LL |     #[derive(Clone)] 'a: 'static,
    |       ^^^^^^ not a non-macro attribute
 
 error: `#[ignore]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:16:5
+  --> $DIR/unsupported_attribute.rs:15:5
    |
 LL |     #[ignore] T: Trait,
    |     ^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     #[ignore] T: Trait,
    = help: `#[ignore]` can only be applied to functions
 
 error: `#[ignore]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:17:5
+  --> $DIR/unsupported_attribute.rs:16:5
    |
 LL |     #[ignore] 'a: 'static,
    |     ^^^^^^^^^
@@ -27,7 +27,7 @@ LL |     #[ignore] 'a: 'static,
    = help: `#[ignore]` can only be applied to functions
 
 error: `#[should_panic]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:18:5
+  --> $DIR/unsupported_attribute.rs:17:5
    |
 LL |     #[should_panic] T: Trait,
    |     ^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL |     #[should_panic] T: Trait,
    = help: `#[should_panic]` can only be applied to functions
 
 error: `#[should_panic]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:19:5
+  --> $DIR/unsupported_attribute.rs:18:5
    |
 LL |     #[should_panic] 'a: 'static,
    |     ^^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL |     #[should_panic] 'a: 'static,
    = help: `#[should_panic]` can only be applied to functions
 
 error: `#[macro_use]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:20:5
+  --> $DIR/unsupported_attribute.rs:19:5
    |
 LL |     #[macro_use] T: Trait,
    |     ^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |     #[macro_use] T: Trait,
    = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 error: `#[macro_use]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:21:5
+  --> $DIR/unsupported_attribute.rs:20:5
    |
 LL |     #[macro_use] 'a: 'static,
    |     ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL |     #[macro_use] 'a: 'static,
    = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 error: `#[deprecated]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:24:5
+  --> $DIR/unsupported_attribute.rs:23:5
    |
 LL |     #[deprecated] T: Trait,
    |     ^^^^^^^^^^^^^
@@ -67,7 +67,7 @@ LL |     #[deprecated] T: Trait,
    = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, and use statements
 
 error: `#[deprecated]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:25:5
+  --> $DIR/unsupported_attribute.rs:24:5
    |
 LL |     #[deprecated] 'a: 'static,
    |     ^^^^^^^^^^^^^
@@ -75,7 +75,7 @@ LL |     #[deprecated] 'a: 'static,
    = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, and use statements
 
 error: `#[automatically_derived]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:26:5
+  --> $DIR/unsupported_attribute.rs:25:5
    |
 LL |     #[automatically_derived] T: Trait,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |     #[automatically_derived] T: Trait,
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 error: `#[automatically_derived]` attribute cannot be used on where predicates
-  --> $DIR/unsupported_attribute.rs:27:5
+  --> $DIR/unsupported_attribute.rs:26:5
    |
 LL |     #[automatically_derived] 'a: 'static,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL |     #[automatically_derived] 'a: 'static,
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:14:5
+  --> $DIR/unsupported_attribute.rs:13:5
    |
 LL |     #[doc = "doc"] T: Trait,
    |     ^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     #[doc = "doc"] T: Trait,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:15:5
+  --> $DIR/unsupported_attribute.rs:14:5
    |
 LL |     #[doc = "doc"] 'a: 'static,
    |     ^^^^^^^^^^^^^^
@@ -107,7 +107,7 @@ LL |     #[doc = "doc"] 'a: 'static,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:22:5
+  --> $DIR/unsupported_attribute.rs:21:5
    |
 LL |     #[allow(unused)] T: Trait,
    |     ^^^^^^^^^^^^^^^^
@@ -115,7 +115,7 @@ LL |     #[allow(unused)] T: Trait,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:23:5
+  --> $DIR/unsupported_attribute.rs:22:5
    |
 LL |     #[allow(unused)] 'a: 'static,
    |     ^^^^^^^^^^^^^^^^
@@ -123,7 +123,7 @@ LL |     #[allow(unused)] 'a: 'static,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:28:5
+  --> $DIR/unsupported_attribute.rs:27:5
    |
 LL |     #[derive(Clone)] T: Trait,
    |     ^^^^^^^^^^^^^^^^
@@ -131,7 +131,7 @@ LL |     #[derive(Clone)] T: Trait,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:31:5
+  --> $DIR/unsupported_attribute.rs:30:5
    |
 LL |     #[derive(Clone)] 'a: 'static,
    |     ^^^^^^^^^^^^^^^^
@@ -139,7 +139,7 @@ LL |     #[derive(Clone)] 'a: 'static,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:34:5
+  --> $DIR/unsupported_attribute.rs:33:5
    |
 LL |     #[rustfmt::skip] T: Trait,
    |     ^^^^^^^^^^^^^^^^
@@ -147,7 +147,7 @@ LL |     #[rustfmt::skip] T: Trait,
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
 error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:35:5
+  --> $DIR/unsupported_attribute.rs:34:5
    |
 LL |     #[rustfmt::skip] 'a: 'static,
    |     ^^^^^^^^^^^^^^^^

From 752f75dd977b48f67d264248ad126eb816319cbe Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 21:09:34 +0100
Subject: [PATCH 0255/1059] document that older LLVM versions come with
 increased risk

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index 3d0e130b6aaa..fb340342502a 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -6,7 +6,10 @@ Rust supports building against multiple LLVM versions:
 * Tip-of-tree for the current LLVM development branch is usually supported within a few days.
   PRs for such fixes are tagged with `llvm-main`.
 * The latest released major version is always supported.
-* The one or two preceding major versions are usually supported.
+* The one or two preceding major versions are usually supported in the sense that they are expected
+  to build successfully and pass most tests. However, fixes for miscompilations often do not get
+  backported to past LLVM versions, so using rustc with older versions of LLVM comes with an
+  increased risk of soundness bugs. We strongly recommend using the latest version of LLVM.
 
 By default, Rust uses its own fork in the [rust-lang/llvm-project repository].
 This fork is based on a `release/$N.x` branch of the upstream project, where

From ca9bd0d157819aeb46dc93bd4c6e9a9446841275 Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Mon, 9 Mar 2026 20:47:08 +0000
Subject: [PATCH 0256/1059] rustdoc-json: Improve docs for
 `ItemEnum::item_kind`

Fixes https://github.com/rust-lang/rust/pull/153279#discussion_r2875219461
---
 src/rustdoc-json-types/lib.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index 54fb833f40b6..72a3f8b224a4 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -683,7 +683,13 @@ pub enum ItemEnum {
 }
 
 impl ItemEnum {
-    /// Returns the [`ItemKind`] of this item.
+    /// Get just the kind of this item, but with no further data.
+    ///
+    /// ```rust
+    /// # use rustdoc_json_types::{ItemKind, ItemEnum};
+    /// let item = ItemEnum::ExternCrate { name: "libc".to_owned(), rename: None };
+    /// assert_eq!(item.item_kind(), ItemKind::ExternCrate);
+    /// ```
     pub fn item_kind(&self) -> ItemKind {
         match self {
             ItemEnum::Module(_) => ItemKind::Module,

From 744c50315dc52cd6d9f09b80561c936afa2b3b96 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 12:12:30 +0100
Subject: [PATCH 0257/1059] Add missing `Diag::with_span_suggestion_with_style`
 method

---
 compiler/rustc_errors/src/diagnostic.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 2aac669d744a..18f1af36b620 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -934,6 +934,7 @@ pub fn span_suggestion(
         self
     } }
 
+    with_fn! { with_span_suggestion_with_style,
     /// [`Diag::span_suggestion()`] but you can set the [`SuggestionStyle`].
     pub fn span_suggestion_with_style(
         &mut self,
@@ -956,7 +957,7 @@ pub fn span_suggestion_with_style(
             applicability,
         });
         self
-    }
+    } }
 
     with_fn! { with_span_suggestion_verbose,
     /// Always show the suggested change.

From a4a37ed163a6c1d227b58047d91457589c611cf8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 22:32:51 +0100
Subject: [PATCH 0258/1059] Use `Diag::with_span_suggestion_with_style` method
 in librustdoc

---
 .../passes/lint/redundant_explicit_links.rs   | 44 +++++++++----------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/src/librustdoc/passes/lint/redundant_explicit_links.rs b/src/librustdoc/passes/lint/redundant_explicit_links.rs
index 84dba5d2f115..13bc4c079aa7 100644
--- a/src/librustdoc/passes/lint/redundant_explicit_links.rs
+++ b/src/librustdoc/passes/lint/redundant_explicit_links.rs
@@ -165,7 +165,7 @@ impl<'a> Diagnostic<'a, ()> for RedundantExplicitLinks {
         fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             let Self { explicit_span, display_span, link_span, display_link } = self;
 
-            let mut diag = Diag::new(dcx, level, "redundant explicit link target")
+            Diag::new(dcx, level, "redundant explicit link target")
                 .with_span_label(
                     explicit_span,
                     "explicit target is redundant",
@@ -176,17 +176,15 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 )
                 .with_note(
                     "when a link's destination is not specified,\nthe label is used to resolve intra-doc links"
-                );
-            // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
-            // FIXME2 (GuillaumeGomez): Why isn't there a `with_` equivalent for this method?
-            diag.span_suggestion_with_style(
-                link_span,
-                "remove explicit link target",
-                format!("[{}]", display_link),
-                Applicability::MaybeIncorrect,
-                SuggestionStyle::ShowAlways,
-            );
-            diag
+                )
+                // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
+                .with_span_suggestion_with_style(
+                    link_span,
+                    "remove explicit link target",
+                    format!("[{}]", display_link),
+                    Applicability::MaybeIncorrect,
+                    SuggestionStyle::ShowAlways,
+                )
         }
     }
 
@@ -267,7 +265,7 @@ impl<'a> Diagnostic<'a, ()> for RedundantExplicitLinkTarget {
         fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             let Self { explicit_span, display_span, def_span, link_span, display_link } = self;
 
-            let mut diag = Diag::new(dcx, level, "redundant explicit link target")
+            Diag::new(dcx, level, "redundant explicit link target")
                 .with_span_label(explicit_span, "explicit target is redundant")
                 .with_span_label(
                     display_span,
@@ -276,17 +274,15 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 .with_span_note(def_span, "referenced explicit link target defined here")
                 .with_note(
                     "when a link's destination is not specified,\nthe label is used to resolve intra-doc links"
-                );
-            // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
-            // FIXME2 (GuillaumeGomez): Why isn't there a `with_` equivalent for this method?
-            diag.span_suggestion_with_style(
-                link_span,
-                "remove explicit link target",
-                format!("[{}]", display_link),
-                Applicability::MaybeIncorrect,
-                SuggestionStyle::ShowAlways,
-            );
-            diag
+                )
+                // FIXME (GuillaumeGomez): We cannot use `derive(Diagnostic)` because of this method.
+                .with_span_suggestion_with_style(
+                    link_span,
+                    "remove explicit link target",
+                    format!("[{}]", display_link),
+                    Applicability::MaybeIncorrect,
+                    SuggestionStyle::ShowAlways,
+                )
         }
     }
 

From 1db5d7741dc9c2163ab44a361464a705cbb667e1 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Mon, 9 Mar 2026 21:37:06 +0000
Subject: [PATCH 0259/1059] address review: use Option for functions which
 already handle errors

---
 src/tools/tidy/src/extra_checks/mod.rs | 33 +++++++++-----------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index a1fe9f3b7763..4ba2da7b5d3f 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -114,10 +114,11 @@ macro_rules! extra_check {
 
     if python_lint || python_fmt || cpp_fmt {
         // Since python lint, format and cpp format share python env, we need to ensure python env is installed before running those checks.
-        match py_prepare(root_path, outdir, &tidy_ctx) {
-            Ok(p) => py_path = Some(p),
-            Err(_) => return,
+        let p = py_prepare(root_path, outdir, &tidy_ctx);
+        if p.is_none() {
+            return;
         }
+        py_path = p;
     }
 
     if python_lint {
@@ -156,7 +157,7 @@ macro_rules! extra_check {
 
     if js_lint || js_typecheck {
         // Since js lint and format share node env, we need to ensure node env is installed before running those checks.
-        if js_prepare(root_path, outdir, npm, &tidy_ctx).is_err() {
+        if js_prepare(root_path, outdir, npm, &tidy_ctx).is_none() {
             return;
         }
     }
@@ -170,14 +171,7 @@ macro_rules! extra_check {
     }
 }
 
-// It is used by prepare functions because they handle errors themselves, so the caller doesn't need to handle errors.
-struct ErrorGuaranteed(());
-
-fn py_prepare(
-    root_path: &Path,
-    outdir: &Path,
-    tidy_ctx: &TidyCtx,
-) -> Result<PathBuf, ErrorGuaranteed> {
+fn py_prepare(root_path: &Path, outdir: &Path, tidy_ctx: &TidyCtx) -> Option<PathBuf> {
     let mut check = tidy_ctx.start_check("extra_checks:py_prepare");
 
     let venv_path = outdir.join("venv");
@@ -185,28 +179,23 @@ fn py_prepare(
     reqs_path.extend(PIP_REQ_PATH);
 
     match get_or_create_venv(&venv_path, &reqs_path) {
-        Ok(p) => Ok(p),
+        Ok(p) => Some(p),
         Err(e) => {
             check.error(e);
-            Err(ErrorGuaranteed(()))
+            None
         }
     }
 }
 
-fn js_prepare(
-    root_path: &Path,
-    outdir: &Path,
-    npm: &Path,
-    tidy_ctx: &TidyCtx,
-) -> Result<(), ErrorGuaranteed> {
+fn js_prepare(root_path: &Path, outdir: &Path, npm: &Path, tidy_ctx: &TidyCtx) -> Option<()> {
     let mut check = tidy_ctx.start_check("extra_checks:js_prepare");
 
     if let Err(e) = rustdoc_js::npm_install(root_path, outdir, npm) {
         check.error(e.to_string());
-        return Err(ErrorGuaranteed(()));
+        return None;
     }
 
-    Ok(())
+    Some(())
 }
 
 fn show_bless_help(mode: &str, action: &str, bless: bool) {

From f2cf26f3f08a87eb7fd999e5c582aeb0c3506902 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 9 Mar 2026 16:43:52 +1100
Subject: [PATCH 0260/1059] Streamline `QueryLatch::wait_on`.

This commit moves the handling of the trivial "complete" case to the
top of the method. This avoids uselessly constructing a waiter in that
case. It also avoids the need for a separate block scope for `info`.
---
 compiler/rustc_middle/src/query/job.rs | 40 +++++++++++++-------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index afa1d9a5ec20..23ca15d3f8a1 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -102,30 +102,30 @@ pub fn wait_on(
         query: Option<QueryJobId>,
         span: Span,
     ) -> Result<(), CycleError<QueryStackDeferred<'tcx>>> {
+        let mut info = self.info.lock();
+        if info.complete {
+            return Ok(());
+        }
+
         let waiter =
             Arc::new(QueryWaiter { query, span, cycle: Mutex::new(None), condvar: Condvar::new() });
 
-        // Awaits the caller on this latch by blocking the current thread.
-        {
-            let mut info = self.info.lock();
-            if !info.complete {
-                // We push the waiter on to the `waiters` list. It can be accessed inside
-                // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
-                // Both of these will remove it from the `waiters` list before resuming
-                // this thread.
-                info.waiters.push(Arc::clone(&waiter));
+        // We push the waiter on to the `waiters` list. It can be accessed inside
+        // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
+        // Both of these will remove it from the `waiters` list before resuming
+        // this thread.
+        info.waiters.push(Arc::clone(&waiter));
 
-                // If this detects a deadlock and the deadlock handler wants to resume this thread
-                // we have to be in the `wait` call. This is ensured by the deadlock handler
-                // getting the self.info lock.
-                rustc_thread_pool::mark_blocked();
-                tcx.jobserver_proxy.release_thread();
-                waiter.condvar.wait(&mut info);
-                // Release the lock before we potentially block in `acquire_thread`
-                drop(info);
-                tcx.jobserver_proxy.acquire_thread();
-            }
-        }
+        // Awaits the caller on this latch by blocking the current thread.
+        // If this detects a deadlock and the deadlock handler wants to resume this thread
+        // we have to be in the `wait` call. This is ensured by the deadlock handler
+        // getting the self.info lock.
+        rustc_thread_pool::mark_blocked();
+        tcx.jobserver_proxy.release_thread();
+        waiter.condvar.wait(&mut info);
+        // Release the lock before we potentially block in `acquire_thread`
+        drop(info);
+        tcx.jobserver_proxy.acquire_thread();
 
         // FIXME: Get rid of this lock. We have ownership of the QueryWaiter
         // although another thread may still have a Arc reference so we cannot

From e54a3d33efb5fe255cdc2339e6221bbe253dcd38 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 18:13:08 +0100
Subject: [PATCH 0261/1059] Remove usage of `TyCtxt::node_span_lint` in clippy

---
 src/tools/clippy/clippy.toml                             | 2 +-
 src/tools/clippy/clippy_utils/src/diagnostics.rs         | 4 ++--
 src/tools/clippy/tests/ui-internal/disallow_span_lint.rs | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/tools/clippy/clippy.toml b/src/tools/clippy/clippy.toml
index d9bcfd17606e..4aa0a426e512 100644
--- a/src/tools/clippy/clippy.toml
+++ b/src/tools/clippy/clippy.toml
@@ -13,5 +13,5 @@ path = "rustc_lint::context::LintContext::span_lint"
 reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
-path = "rustc_middle::ty::context::TyCtxt::node_span_lint"
+path = "rustc_middle::ty::context::TyCtxt::emit_node_span_lint"
 reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
diff --git a/src/tools/clippy/clippy_utils/src/diagnostics.rs b/src/tools/clippy/clippy_utils/src/diagnostics.rs
index c0d02aaa6ee8..88dd3d96b266 100644
--- a/src/tools/clippy/clippy_utils/src/diagnostics.rs
+++ b/src/tools/clippy/clippy_utils/src/diagnostics.rs
@@ -326,14 +326,14 @@ pub fn span_lint_hir_and_then(
     f: impl FnOnce(&mut Diag<'_, ()>),
 ) {
     #[expect(clippy::disallowed_methods)]
-    cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
+    cx.tcx.emit_node_span_lint(lint, hir_id, sp, rustc_errors::DiagDecorator(|diag| {
         diag.primary_message(msg);
         f(diag);
         docs_link(diag, lint);
 
         #[cfg(debug_assertions)]
         validate_diag(diag);
-    });
+    }));
 }
 
 /// Add a span lint with a suggestion on how to fix it.
diff --git a/src/tools/clippy/tests/ui-internal/disallow_span_lint.rs b/src/tools/clippy/tests/ui-internal/disallow_span_lint.rs
index 36e4158f6e68..cd69a12f89d4 100644
--- a/src/tools/clippy/tests/ui-internal/disallow_span_lint.rs
+++ b/src/tools/clippy/tests/ui-internal/disallow_span_lint.rs
@@ -6,7 +6,7 @@
 extern crate rustc_lint;
 extern crate rustc_middle;
 
-use rustc_errors::{DiagMessage, MultiSpan};
+use rustc_errors::{DiagDecorator, DiagMessage, MultiSpan};
 use rustc_hir::hir_id::HirId;
 use rustc_lint::{Lint, LintContext};
 use rustc_middle::ty::TyCtxt;
@@ -19,10 +19,10 @@ pub fn a(cx: impl LintContext, lint: &'static Lint, span: impl Into<MultiSpan>,
 }
 
 pub fn b(tcx: TyCtxt<'_>, lint: &'static Lint, hir_id: HirId, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
-    tcx.node_span_lint(lint, hir_id, span, |lint| {
+    tcx.emit_node_span_lint(lint, hir_id, span, DiagDecorator(|lint| {
         //~^ disallowed_methods
         lint.primary_message(msg);
-    });
+    }));
 }
 
 fn main() {}

From 562e9812d43c6e559491eb8a0c4433d7096f8338 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 18:13:47 +0100
Subject: [PATCH 0262/1059] Remove `TyCtxt::node_span_lint` method

---
 compiler/rustc_middle/src/ty/context.rs | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 80f748f64087..a99e685c1308 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2542,21 +2542,6 @@ pub fn emit_node_span_lint(
         diag_lint_level(self.sess, lint, level, Some(span.into()), decorator)
     }
 
-    /// Emit a lint at the appropriate level for a hir node, with an associated span.
-    ///
-    /// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
-    #[track_caller]
-    pub fn node_span_lint(
-        self,
-        lint: &'static Lint,
-        hir_id: HirId,
-        span: impl Into<MultiSpan>,
-        decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
-    ) {
-        let level = self.lint_level_at_node(lint, hir_id);
-        lint_level(self.sess, lint, level, Some(span.into()), decorate);
-    }
-
     /// Find the appropriate span where `use` and outer attributes can be inserted at.
     pub fn crate_level_attribute_injection_span(self) -> Span {
         let node = self.hir_node(hir::CRATE_HIR_ID);

From 4d7624e1d1084a6130c458177994e93ba1aeba4a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 20:50:10 +0100
Subject: [PATCH 0263/1059] Remove `TyCtxt::node_span_lint` mention in docs

---
 compiler/rustc_middle/src/lint.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
index eb1628762ffe..1c37dd0f82f4 100644
--- a/compiler/rustc_middle/src/lint.rs
+++ b/compiler/rustc_middle/src/lint.rs
@@ -298,7 +298,6 @@ fn explain_lint_level_source(
 /// If you are looking to implement a lint, look for higher level functions,
 /// for example:
 /// - [`TyCtxt::emit_node_span_lint`]
-/// - [`TyCtxt::node_span_lint`]
 /// - [`TyCtxt::node_lint`]
 /// - `LintContext::opt_span_lint`
 ///
@@ -488,7 +487,6 @@ fn lint_level_impl(
 /// for example:
 ///
 /// - [`TyCtxt::emit_node_span_lint`]
-/// - [`TyCtxt::node_span_lint`]
 /// - [`TyCtxt::node_lint`]
 /// - `LintContext::opt_span_lint`
 ///

From ab867a90e1500f0c483a6c6c215e10d213be0447 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 9 Mar 2026 18:13:08 +0100
Subject: [PATCH 0264/1059] Remove usage of `TyCtxt::node_span_lint` in clippy

---
 clippy.toml                             | 2 +-
 clippy_utils/src/diagnostics.rs         | 4 ++--
 tests/ui-internal/disallow_span_lint.rs | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/clippy.toml b/clippy.toml
index d9bcfd17606e..4aa0a426e512 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -13,5 +13,5 @@ path = "rustc_lint::context::LintContext::span_lint"
 reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
-path = "rustc_middle::ty::context::TyCtxt::node_span_lint"
+path = "rustc_middle::ty::context::TyCtxt::emit_node_span_lint"
 reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index c0d02aaa6ee8..88dd3d96b266 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -326,14 +326,14 @@ pub fn span_lint_hir_and_then(
     f: impl FnOnce(&mut Diag<'_, ()>),
 ) {
     #[expect(clippy::disallowed_methods)]
-    cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
+    cx.tcx.emit_node_span_lint(lint, hir_id, sp, rustc_errors::DiagDecorator(|diag| {
         diag.primary_message(msg);
         f(diag);
         docs_link(diag, lint);
 
         #[cfg(debug_assertions)]
         validate_diag(diag);
-    });
+    }));
 }
 
 /// Add a span lint with a suggestion on how to fix it.
diff --git a/tests/ui-internal/disallow_span_lint.rs b/tests/ui-internal/disallow_span_lint.rs
index 36e4158f6e68..cd69a12f89d4 100644
--- a/tests/ui-internal/disallow_span_lint.rs
+++ b/tests/ui-internal/disallow_span_lint.rs
@@ -6,7 +6,7 @@
 extern crate rustc_lint;
 extern crate rustc_middle;
 
-use rustc_errors::{DiagMessage, MultiSpan};
+use rustc_errors::{DiagDecorator, DiagMessage, MultiSpan};
 use rustc_hir::hir_id::HirId;
 use rustc_lint::{Lint, LintContext};
 use rustc_middle::ty::TyCtxt;
@@ -19,10 +19,10 @@ pub fn a(cx: impl LintContext, lint: &'static Lint, span: impl Into<MultiSpan>,
 }
 
 pub fn b(tcx: TyCtxt<'_>, lint: &'static Lint, hir_id: HirId, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
-    tcx.node_span_lint(lint, hir_id, span, |lint| {
+    tcx.emit_node_span_lint(lint, hir_id, span, DiagDecorator(|lint| {
         //~^ disallowed_methods
         lint.primary_message(msg);
-    });
+    }));
 }
 
 fn main() {}

From 141b0d87570d340ec5eadcfffa70d8750bdfc516 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <27117322+fanninpm@users.noreply.github.com>
Date: Mon, 2 Mar 2026 21:35:48 -0500
Subject: [PATCH 0265/1059] Add high-priority ICE: 146965

---
 tests/crashes/146965.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 tests/crashes/146965.rs

diff --git a/tests/crashes/146965.rs b/tests/crashes/146965.rs
new file mode 100644
index 000000000000..d6719568ebb4
--- /dev/null
+++ b/tests/crashes/146965.rs
@@ -0,0 +1,29 @@
+//@ known-bug: #146965
+//@ compile-flags: --crate-type lib
+
+fn conjure<T>() -> T {
+    panic!()
+}
+
+pub trait Ring {
+    type Element;
+}
+impl<T> Ring for T {
+    type Element = u16;
+}
+
+// Removing the : Ring bound makes it not ICE
+fn map_coeff<T: Ring>(f: impl Fn(<T as Ring>::Element)) {
+    let c = conjure::<<T as Ring>::Element>();
+    f(c);
+}
+
+// Adding a : Ring bound makes it not ICE
+fn gcd<T>() {
+    map_coeff::<T>(|_: u16| {});
+}
+
+// Removing the : Ring bound makes it not ICE
+pub fn bivariate_factorization<T: Ring>() {
+    gcd::<T>();
+}

From 3ea17bec62b190b66e9fc71ea649cd533fdf58d7 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <27117322+fanninpm@users.noreply.github.com>
Date: Mon, 2 Mar 2026 21:36:26 -0500
Subject: [PATCH 0266/1059] Add high-priority ICE: 150263

---
 tests/crashes/150263.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 tests/crashes/150263.rs

diff --git a/tests/crashes/150263.rs b/tests/crashes/150263.rs
new file mode 100644
index 000000000000..6e3b2a2f3f85
--- /dev/null
+++ b/tests/crashes/150263.rs
@@ -0,0 +1,21 @@
+//@ known-bug: #150263
+//@ compile-flags: --crate-type lib
+
+pub trait Scope {
+    type Timestamp;
+}
+impl<G> Scope for G {
+    type Timestamp = ();
+}
+
+pub fn create<G: Scope>() {
+    enter::<G>();
+}
+
+fn enter<G>() {
+    unary::<G>(|_: <G as Scope>::Timestamp| {});
+}
+
+fn unary<G: Scope>(constructor: impl FnOnce(G::Timestamp)) {
+    constructor(None.unwrap());
+}

From 13a5c24606170f3ee1e3d1351df85c191961da7e Mon Sep 17 00:00:00 2001
From: Padraic Fanning <27117322+fanninpm@users.noreply.github.com>
Date: Fri, 6 Mar 2026 20:18:59 -0500
Subject: [PATCH 0267/1059] Fix compile flags

---
 tests/crashes/146965.rs | 2 +-
 tests/crashes/150263.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/crashes/146965.rs b/tests/crashes/146965.rs
index d6719568ebb4..d663ccb35817 100644
--- a/tests/crashes/146965.rs
+++ b/tests/crashes/146965.rs
@@ -1,5 +1,5 @@
 //@ known-bug: #146965
-//@ compile-flags: --crate-type lib
+//@ compile-flags: --crate-type lib -C opt-level=3
 
 fn conjure<T>() -> T {
     panic!()
diff --git a/tests/crashes/150263.rs b/tests/crashes/150263.rs
index 6e3b2a2f3f85..44d0fdbdda9b 100644
--- a/tests/crashes/150263.rs
+++ b/tests/crashes/150263.rs
@@ -1,5 +1,5 @@
 //@ known-bug: #150263
-//@ compile-flags: --crate-type lib
+//@ compile-flags: --crate-type lib -C opt-level=3
 
 pub trait Scope {
     type Timestamp;

From d2e3ab641ac3d4ea2e351724b22d6b9f20021b01 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 9 Mar 2026 17:57:43 +0100
Subject: [PATCH 0268/1059] std: move `sys::pal::os` to `sys::paths`
 (rename/delete only)

---
 library/std/src/sys/pal/solid/os.rs           | 56 -----------------
 library/std/src/sys/pal/teeos/os.rs           | 62 -------------------
 library/std/src/sys/pal/xous/os.rs            | 57 -----------------
 library/std/src/sys/pal/zkvm/os.rs            | 57 -----------------
 .../sys/{pal/hermit/os.rs => paths/hermit.rs} |  0
 .../sys/{pal/motor/os.rs => paths/motor.rs}   |  0
 .../src/sys/{pal/sgx/os.rs => paths/sgx.rs}   |  0
 .../src/sys/{pal/uefi/os.rs => paths/uefi.rs} |  0
 .../src/sys/{pal/unix/os.rs => paths/unix.rs} |  0
 .../os.rs => paths/unsupported.rs}            |  0
 .../src/sys/{pal/wasi/os.rs => paths/wasi.rs} |  0
 .../{pal/windows/os.rs => paths/windows.rs}   |  0
 12 files changed, 232 deletions(-)
 delete mode 100644 library/std/src/sys/pal/solid/os.rs
 delete mode 100644 library/std/src/sys/pal/teeos/os.rs
 delete mode 100644 library/std/src/sys/pal/xous/os.rs
 delete mode 100644 library/std/src/sys/pal/zkvm/os.rs
 rename library/std/src/sys/{pal/hermit/os.rs => paths/hermit.rs} (100%)
 rename library/std/src/sys/{pal/motor/os.rs => paths/motor.rs} (100%)
 rename library/std/src/sys/{pal/sgx/os.rs => paths/sgx.rs} (100%)
 rename library/std/src/sys/{pal/uefi/os.rs => paths/uefi.rs} (100%)
 rename library/std/src/sys/{pal/unix/os.rs => paths/unix.rs} (100%)
 rename library/std/src/sys/{pal/unsupported/os.rs => paths/unsupported.rs} (100%)
 rename library/std/src/sys/{pal/wasi/os.rs => paths/wasi.rs} (100%)
 rename library/std/src/sys/{pal/windows/os.rs => paths/windows.rs} (100%)

diff --git a/library/std/src/sys/pal/solid/os.rs b/library/std/src/sys/pal/solid/os.rs
deleted file mode 100644
index 79bb91b17996..000000000000
--- a/library/std/src/sys/pal/solid/os.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use super::unsupported;
-use crate::ffi::{OsStr, OsString};
-use crate::path::{self, PathBuf};
-use crate::{fmt, io};
-
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(&'a !);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        *self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no standard temporary directory on this platform")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/pal/teeos/os.rs b/library/std/src/sys/pal/teeos/os.rs
deleted file mode 100644
index c86fa555e411..000000000000
--- a/library/std/src/sys/pal/teeos/os.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//! Implementation of `std::os` functionality for teeos
-
-use core::marker::PhantomData;
-
-use super::unsupported;
-use crate::ffi::{OsStr, OsString};
-use crate::path::PathBuf;
-use crate::{fmt, io, path};
-
-// Everything below are stubs and copied from unsupported.rs
-
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem on this platform")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/pal/xous/os.rs b/library/std/src/sys/pal/xous/os.rs
deleted file mode 100644
index fe8addeafd2b..000000000000
--- a/library/std/src/sys/pal/xous/os.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use super::unsupported;
-use crate::ffi::{OsStr, OsString};
-use crate::marker::PhantomData;
-use crate::path::{self, PathBuf};
-use crate::{fmt, io};
-
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem on this platform")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/pal/zkvm/os.rs b/library/std/src/sys/pal/zkvm/os.rs
deleted file mode 100644
index fe8addeafd2b..000000000000
--- a/library/std/src/sys/pal/zkvm/os.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use super::unsupported;
-use crate::ffi::{OsStr, OsString};
-use crate::marker::PhantomData;
-use crate::path::{self, PathBuf};
-use crate::{fmt, io};
-
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem on this platform")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/pal/hermit/os.rs b/library/std/src/sys/paths/hermit.rs
similarity index 100%
rename from library/std/src/sys/pal/hermit/os.rs
rename to library/std/src/sys/paths/hermit.rs
diff --git a/library/std/src/sys/pal/motor/os.rs b/library/std/src/sys/paths/motor.rs
similarity index 100%
rename from library/std/src/sys/pal/motor/os.rs
rename to library/std/src/sys/paths/motor.rs
diff --git a/library/std/src/sys/pal/sgx/os.rs b/library/std/src/sys/paths/sgx.rs
similarity index 100%
rename from library/std/src/sys/pal/sgx/os.rs
rename to library/std/src/sys/paths/sgx.rs
diff --git a/library/std/src/sys/pal/uefi/os.rs b/library/std/src/sys/paths/uefi.rs
similarity index 100%
rename from library/std/src/sys/pal/uefi/os.rs
rename to library/std/src/sys/paths/uefi.rs
diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/paths/unix.rs
similarity index 100%
rename from library/std/src/sys/pal/unix/os.rs
rename to library/std/src/sys/paths/unix.rs
diff --git a/library/std/src/sys/pal/unsupported/os.rs b/library/std/src/sys/paths/unsupported.rs
similarity index 100%
rename from library/std/src/sys/pal/unsupported/os.rs
rename to library/std/src/sys/paths/unsupported.rs
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/paths/wasi.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/os.rs
rename to library/std/src/sys/paths/wasi.rs
diff --git a/library/std/src/sys/pal/windows/os.rs b/library/std/src/sys/paths/windows.rs
similarity index 100%
rename from library/std/src/sys/pal/windows/os.rs
rename to library/std/src/sys/paths/windows.rs

From f4a95d35d3804e6e238785ed7b4aa252ce10bc3f Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 9 Mar 2026 18:37:36 +0100
Subject: [PATCH 0269/1059] std: move leftover Windows error test

---
 library/std/src/sys/io/error/windows.rs                        | 3 +++
 .../std/src/sys/{pal/windows/os => io/error/windows}/tests.rs  | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)
 rename library/std/src/sys/{pal/windows/os => io/error/windows}/tests.rs (93%)

diff --git a/library/std/src/sys/io/error/windows.rs b/library/std/src/sys/io/error/windows.rs
index d7607082a30a..c093443f3033 100644
--- a/library/std/src/sys/io/error/windows.rs
+++ b/library/std/src/sys/io/error/windows.rs
@@ -1,6 +1,9 @@
 use crate::sys::pal::{api, c};
 use crate::{io, ptr};
 
+#[cfg(test)]
+mod tests;
+
 pub fn errno() -> i32 {
     api::get_last_error().code as i32
 }
diff --git a/library/std/src/sys/pal/windows/os/tests.rs b/library/std/src/sys/io/error/windows/tests.rs
similarity index 93%
rename from library/std/src/sys/pal/windows/os/tests.rs
rename to library/std/src/sys/io/error/windows/tests.rs
index 458d6e11c209..7fc545ad0066 100644
--- a/library/std/src/sys/pal/windows/os/tests.rs
+++ b/library/std/src/sys/io/error/windows/tests.rs
@@ -1,5 +1,5 @@
 use crate::io::Error;
-use crate::sys::c;
+use crate::sys::pal::c;
 
 // tests `error_string` above
 #[test]

From be5f0708e4f493c028120fd2bf1bbadbd4e3bef4 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 9 Mar 2026 18:43:11 +0100
Subject: [PATCH 0270/1059] std: move `sys::pal::os` to `sys::paths`

---
 library/std/src/env.rs                     | 20 ++++----
 library/std/src/sys/args/windows.rs        |  2 +-
 library/std/src/sys/mod.rs                 |  1 +
 library/std/src/sys/pal/hermit/mod.rs      |  1 -
 library/std/src/sys/pal/motor/mod.rs       |  2 -
 library/std/src/sys/pal/sgx/mod.rs         |  1 -
 library/std/src/sys/pal/solid/mod.rs       |  1 -
 library/std/src/sys/pal/teeos/mod.rs       |  1 -
 library/std/src/sys/pal/trusty/mod.rs      |  2 -
 library/std/src/sys/pal/uefi/mod.rs        |  1 -
 library/std/src/sys/pal/unix/mod.rs        |  1 -
 library/std/src/sys/pal/unsupported/mod.rs |  2 -
 library/std/src/sys/pal/vexos/mod.rs       |  3 --
 library/std/src/sys/pal/wasi/mod.rs        |  1 -
 library/std/src/sys/pal/wasm/mod.rs        |  3 --
 library/std/src/sys/pal/windows/mod.rs     |  1 -
 library/std/src/sys/pal/xous/mod.rs        |  1 -
 library/std/src/sys/pal/zkvm/mod.rs        |  1 -
 library/std/src/sys/paths/hermit.rs        | 51 +------------------
 library/std/src/sys/paths/mod.rs           | 59 ++++++++++++++++++++++
 library/std/src/sys/paths/motor.rs         | 48 +-----------------
 library/std/src/sys/paths/sgx.rs           | 58 ++-------------------
 library/std/src/sys/paths/uefi.rs          |  4 +-
 library/std/src/sys/paths/unix.rs          |  6 +--
 library/std/src/sys/paths/unsupported.rs   |  2 +-
 library/std/src/sys/paths/wasi.rs          | 48 ++----------------
 library/std/src/sys/paths/windows.rs       | 33 ++++--------
 27 files changed, 99 insertions(+), 255 deletions(-)
 create mode 100644 library/std/src/sys/paths/mod.rs

diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index edf0127a665e..d3e4417656e9 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -15,7 +15,7 @@
 use crate::num::NonZero;
 use crate::ops::Try;
 use crate::path::{Path, PathBuf};
-use crate::sys::{env as env_imp, os as os_imp};
+use crate::sys::{env as env_imp, paths as paths_imp};
 use crate::{array, fmt, io, sys};
 
 /// Returns the current working directory as a [`PathBuf`].
@@ -51,7 +51,7 @@
 #[doc(alias = "GetCurrentDirectory")]
 #[stable(feature = "env", since = "1.0.0")]
 pub fn current_dir() -> io::Result<PathBuf> {
-    os_imp::getcwd()
+    paths_imp::getcwd()
 }
 
 /// Changes the current working directory to the specified path.
@@ -78,7 +78,7 @@ pub fn current_dir() -> io::Result<PathBuf> {
 #[doc(alias = "chdir", alias = "SetCurrentDirectory", alias = "SetCurrentDirectoryW")]
 #[stable(feature = "env", since = "1.0.0")]
 pub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    os_imp::chdir(path.as_ref())
+    paths_imp::chdir(path.as_ref())
 }
 
 /// An iterator over a snapshot of the environment variables of this process.
@@ -444,7 +444,7 @@ pub unsafe fn remove_var<K: AsRef<OsStr>>(key: K) {
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "env", since = "1.0.0")]
 pub struct SplitPaths<'a> {
-    inner: os_imp::SplitPaths<'a>,
+    inner: paths_imp::SplitPaths<'a>,
 }
 
 /// Parses input according to platform conventions for the `PATH`
@@ -480,7 +480,7 @@ pub struct SplitPaths<'a> {
 /// ```
 #[stable(feature = "env", since = "1.0.0")]
 pub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths<'_> {
-    SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) }
+    SplitPaths { inner: paths_imp::split_paths(unparsed.as_ref()) }
 }
 
 #[stable(feature = "env", since = "1.0.0")]
@@ -508,7 +508,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 #[derive(Debug)]
 #[stable(feature = "env", since = "1.0.0")]
 pub struct JoinPathsError {
-    inner: os_imp::JoinPathsError,
+    inner: paths_imp::JoinPathsError,
 }
 
 /// Joins a collection of [`Path`]s appropriately for the `PATH`
@@ -579,7 +579,7 @@ pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
     I: IntoIterator<Item = T>,
     T: AsRef<OsStr>,
 {
-    os_imp::join_paths(paths.into_iter()).map_err(|e| JoinPathsError { inner: e })
+    paths_imp::join_paths(paths.into_iter()).map_err(|e| JoinPathsError { inner: e })
 }
 
 #[stable(feature = "env", since = "1.0.0")]
@@ -641,7 +641,7 @@ fn description(&self) -> &str {
 #[must_use]
 #[stable(feature = "env", since = "1.0.0")]
 pub fn home_dir() -> Option<PathBuf> {
-    os_imp::home_dir()
+    paths_imp::home_dir()
 }
 
 /// Returns the path of a temporary directory.
@@ -701,7 +701,7 @@ pub fn home_dir() -> Option<PathBuf> {
 #[doc(alias = "GetTempPath", alias = "GetTempPath2")]
 #[stable(feature = "env", since = "1.0.0")]
 pub fn temp_dir() -> PathBuf {
-    os_imp::temp_dir()
+    paths_imp::temp_dir()
 }
 
 /// Returns the full filesystem path of the current running executable.
@@ -752,7 +752,7 @@ pub fn temp_dir() -> PathBuf {
 /// ```
 #[stable(feature = "env", since = "1.0.0")]
 pub fn current_exe() -> io::Result<PathBuf> {
-    os_imp::current_exe()
+    paths_imp::current_exe()
 }
 
 /// An iterator over the arguments of a process, yielding a [`String`] value for
diff --git a/library/std/src/sys/args/windows.rs b/library/std/src/sys/args/windows.rs
index c1988657ff1b..3c6995e37278 100644
--- a/library/std/src/sys/args/windows.rs
+++ b/library/std/src/sys/args/windows.rs
@@ -12,9 +12,9 @@
 use crate::os::windows::prelude::*;
 use crate::path::{Path, PathBuf};
 use crate::sys::helpers::WStrUnits;
-use crate::sys::pal::os::current_exe;
 use crate::sys::pal::{ensure_no_nuls, fill_utf16_buf};
 use crate::sys::path::get_long_path;
+use crate::sys::paths::current_exe;
 use crate::sys::{AsInner, c, to_u16s};
 use crate::{io, iter, ptr};
 
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index 5ad23972860b..fe0c10395241 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -18,6 +18,7 @@
 pub mod net;
 pub mod os_str;
 pub mod path;
+pub mod paths;
 pub mod pipe;
 pub mod platform_version;
 pub mod process;
diff --git a/library/std/src/sys/pal/hermit/mod.rs b/library/std/src/sys/pal/hermit/mod.rs
index f10a090a6e91..b18dc5b103b5 100644
--- a/library/std/src/sys/pal/hermit/mod.rs
+++ b/library/std/src/sys/pal/hermit/mod.rs
@@ -22,7 +22,6 @@
 use crate::sys::env;
 
 pub mod futex;
-pub mod os;
 pub mod time;
 
 pub fn unsupported<T>() -> io::Result<T> {
diff --git a/library/std/src/sys/pal/motor/mod.rs b/library/std/src/sys/pal/motor/mod.rs
index a520375a4bbf..705413cbe0a7 100644
--- a/library/std/src/sys/pal/motor/mod.rs
+++ b/library/std/src/sys/pal/motor/mod.rs
@@ -1,7 +1,5 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
-pub mod os;
-
 pub use moto_rt::futex;
 
 use crate::io;
diff --git a/library/std/src/sys/pal/sgx/mod.rs b/library/std/src/sys/pal/sgx/mod.rs
index 1de3ca4a5d79..2b284cc40b94 100644
--- a/library/std/src/sys/pal/sgx/mod.rs
+++ b/library/std/src/sys/pal/sgx/mod.rs
@@ -10,7 +10,6 @@
 
 pub mod abi;
 mod libunwind_integration;
-pub mod os;
 pub mod thread_parking;
 pub mod waitqueue;
 
diff --git a/library/std/src/sys/pal/solid/mod.rs b/library/std/src/sys/pal/solid/mod.rs
index 1376af8304cf..c3f9e4794590 100644
--- a/library/std/src/sys/pal/solid/mod.rs
+++ b/library/std/src/sys/pal/solid/mod.rs
@@ -19,7 +19,6 @@ pub mod itron {
 // `error` is `pub(crate)` so that it can be accessed by `itron/error.rs` as
 // `crate::sys::error`
 pub(crate) mod error;
-pub mod os;
 pub use self::itron::thread_parking;
 
 // SAFETY: must be called only once during runtime initialization.
diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index 7d2ecdbf7ec4..5caed277dbf5 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -7,7 +7,6 @@
 #![allow(dead_code)]
 
 pub mod conf;
-pub mod os;
 #[path = "../unix/time.rs"]
 pub mod time;
 
diff --git a/library/std/src/sys/pal/trusty/mod.rs b/library/std/src/sys/pal/trusty/mod.rs
index b785c2dbb789..ec2d938ed836 100644
--- a/library/std/src/sys/pal/trusty/mod.rs
+++ b/library/std/src/sys/pal/trusty/mod.rs
@@ -3,7 +3,5 @@
 #[path = "../unsupported/common.rs"]
 #[deny(unsafe_op_in_unsafe_fn)]
 mod common;
-#[path = "../unsupported/os.rs"]
-pub mod os;
 
 pub use common::*;
diff --git a/library/std/src/sys/pal/uefi/mod.rs b/library/std/src/sys/pal/uefi/mod.rs
index e4a8f50e4274..67499d2c6f17 100644
--- a/library/std/src/sys/pal/uefi/mod.rs
+++ b/library/std/src/sys/pal/uefi/mod.rs
@@ -14,7 +14,6 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
 pub mod helpers;
-pub mod os;
 pub mod system_time;
 
 #[cfg(test)]
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index 9931b4de0b9b..0be150a0bfaa 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -8,7 +8,6 @@
 pub mod futex;
 #[cfg(target_os = "linux")]
 pub mod linux;
-pub mod os;
 pub mod stack_overflow;
 pub mod sync;
 pub mod thread_parking;
diff --git a/library/std/src/sys/pal/unsupported/mod.rs b/library/std/src/sys/pal/unsupported/mod.rs
index 0f157819d5a6..c4b14ab44436 100644
--- a/library/std/src/sys/pal/unsupported/mod.rs
+++ b/library/std/src/sys/pal/unsupported/mod.rs
@@ -1,6 +1,4 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
-pub mod os;
-
 mod common;
 pub use common::*;
diff --git a/library/std/src/sys/pal/vexos/mod.rs b/library/std/src/sys/pal/vexos/mod.rs
index d1380ab8dff1..61bbe78f718a 100644
--- a/library/std/src/sys/pal/vexos/mod.rs
+++ b/library/std/src/sys/pal/vexos/mod.rs
@@ -1,6 +1,3 @@
-#[path = "../unsupported/os.rs"]
-pub mod os;
-
 #[expect(dead_code)]
 #[path = "../unsupported/common.rs"]
 mod unsupported_common;
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasi/mod.rs
index 66d91078a5d5..6f6099350925 100644
--- a/library/std/src/sys/pal/wasi/mod.rs
+++ b/library/std/src/sys/pal/wasi/mod.rs
@@ -10,7 +10,6 @@
 #[allow(unused)]
 #[path = "../wasm/atomics/futex.rs"]
 pub mod futex;
-pub mod os;
 pub mod stack_overflow;
 #[path = "../unix/time.rs"]
 pub mod time;
diff --git a/library/std/src/sys/pal/wasm/mod.rs b/library/std/src/sys/pal/wasm/mod.rs
index 5f56eddd6a81..24a2ab8eca30 100644
--- a/library/std/src/sys/pal/wasm/mod.rs
+++ b/library/std/src/sys/pal/wasm/mod.rs
@@ -16,9 +16,6 @@
 
 #![deny(unsafe_op_in_unsafe_fn)]
 
-#[path = "../unsupported/os.rs"]
-pub mod os;
-
 #[cfg(target_feature = "atomics")]
 #[path = "atomics/futex.rs"]
 pub mod futex;
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 0cd915261471..b67ba3774978 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -18,7 +18,6 @@
 #[cfg(not(target_vendor = "win7"))]
 pub mod futex;
 pub mod handle;
-pub mod os;
 pub mod time;
 cfg_select! {
     // We don't care about printing nice error messages for panic=immediate-abort
diff --git a/library/std/src/sys/pal/xous/mod.rs b/library/std/src/sys/pal/xous/mod.rs
index 9b22fb88c998..b5b3fd91b4fa 100644
--- a/library/std/src/sys/pal/xous/mod.rs
+++ b/library/std/src/sys/pal/xous/mod.rs
@@ -1,6 +1,5 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-pub mod os;
 pub mod params;
 
 #[path = "../unsupported/common.rs"]
diff --git a/library/std/src/sys/pal/zkvm/mod.rs b/library/std/src/sys/pal/zkvm/mod.rs
index 1b18adb811d9..1a64d3c93d70 100644
--- a/library/std/src/sys/pal/zkvm/mod.rs
+++ b/library/std/src/sys/pal/zkvm/mod.rs
@@ -11,7 +11,6 @@
 pub const WORD_SIZE: usize = size_of::<u32>();
 
 pub mod abi;
-pub mod os;
 
 use crate::io as std_io;
 
diff --git a/library/std/src/sys/paths/hermit.rs b/library/std/src/sys/paths/hermit.rs
index 188caded55d4..36f667d30053 100644
--- a/library/std/src/sys/paths/hermit.rs
+++ b/library/std/src/sys/paths/hermit.rs
@@ -1,57 +1,10 @@
-use crate::ffi::{OsStr, OsString};
-use crate::marker::PhantomData;
-use crate::path::{self, PathBuf};
-use crate::sys::unsupported;
-use crate::{fmt, io};
+use crate::io;
+use crate::path::PathBuf;
 
 pub fn getcwd() -> io::Result<PathBuf> {
     Ok(PathBuf::from("/"))
 }
 
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on hermit yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
 pub fn temp_dir() -> PathBuf {
     PathBuf::from("/tmp")
 }
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/paths/mod.rs b/library/std/src/sys/paths/mod.rs
new file mode 100644
index 000000000000..8880a837af7f
--- /dev/null
+++ b/library/std/src/sys/paths/mod.rs
@@ -0,0 +1,59 @@
+cfg_select! {
+    target_os = "hermit" => {
+        mod hermit;
+        #[expect(dead_code)]
+        mod unsupported;
+        mod imp {
+            pub use super::hermit::{getcwd, temp_dir};
+            pub use super::unsupported::{chdir, SplitPaths, split_paths, JoinPathsError, join_paths, current_exe, home_dir};
+        }
+    }
+    target_os = "motor" => {
+        mod motor;
+        #[expect(dead_code)]
+        mod unsupported;
+        mod imp {
+            pub use super::motor::{getcwd, chdir, current_exe, temp_dir};
+            pub use super::unsupported::{SplitPaths, split_paths, JoinPathsError, join_paths, home_dir};
+        }
+    }
+    all(target_vendor = "fortanix", target_env = "sgx") => {
+        mod sgx;
+        #[expect(dead_code)]
+        mod unsupported;
+        mod imp {
+            pub use super::sgx::chdir;
+            pub use super::unsupported::{getcwd, SplitPaths, split_paths, JoinPathsError, join_paths, current_exe, temp_dir, home_dir};
+        }
+    }
+    target_os = "uefi" => {
+        mod uefi;
+        use uefi as imp;
+    }
+    target_family = "unix" => {
+        mod unix;
+        use unix as imp;
+    }
+    target_os = "wasi" => {
+        mod wasi;
+        #[expect(dead_code)]
+        mod unsupported;
+        mod imp {
+            pub use super::wasi::{getcwd, chdir, temp_dir};
+            pub use super::unsupported::{current_exe, SplitPaths, split_paths, JoinPathsError, join_paths, home_dir};
+        }
+    }
+    target_os = "windows" => {
+        mod windows;
+        use windows as imp;
+    }
+    _ => {
+        mod unsupported;
+        use unsupported as imp;
+    }
+}
+
+pub use imp::{
+    JoinPathsError, SplitPaths, chdir, current_exe, getcwd, home_dir, join_paths, split_paths,
+    temp_dir,
+};
diff --git a/library/std/src/sys/paths/motor.rs b/library/std/src/sys/paths/motor.rs
index 0af579303306..33d746b13d59 100644
--- a/library/std/src/sys/paths/motor.rs
+++ b/library/std/src/sys/paths/motor.rs
@@ -1,10 +1,7 @@
-use super::map_motor_error;
-use crate::error::Error as StdError;
-use crate::ffi::{OsStr, OsString};
-use crate::marker::PhantomData;
+use crate::io;
 use crate::os::motor::ffi::OsStrExt;
 use crate::path::{self, PathBuf};
-use crate::{fmt, io};
+use crate::sys::pal::map_motor_error;
 
 pub fn getcwd() -> io::Result<PathBuf> {
     moto_rt::fs::getcwd().map(PathBuf::from).map_err(map_motor_error)
@@ -14,43 +11,6 @@ pub fn chdir(path: &path::Path) -> io::Result<()> {
     moto_rt::fs::chdir(path.as_os_str().as_str()).map_err(map_motor_error)
 }
 
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl StdError for JoinPathsError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        "not supported on this platform yet"
-    }
-}
-
 pub fn current_exe() -> io::Result<PathBuf> {
     moto_rt::process::current_exe().map(PathBuf::from).map_err(map_motor_error)
 }
@@ -58,7 +18,3 @@ pub fn current_exe() -> io::Result<PathBuf> {
 pub fn temp_dir() -> PathBuf {
     PathBuf::from(moto_rt::fs::TEMP_DIR)
 }
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/paths/sgx.rs b/library/std/src/sys/paths/sgx.rs
index 5b0af37a3d37..6a4cbe93b1b8 100644
--- a/library/std/src/sys/paths/sgx.rs
+++ b/library/std/src/sys/paths/sgx.rs
@@ -1,57 +1,7 @@
-use crate::ffi::{OsStr, OsString};
-use crate::marker::PhantomData;
-use crate::path::{self, PathBuf};
-use crate::sys::{sgx_ineffective, unsupported};
-use crate::{fmt, io};
+use crate::io;
+use crate::path::Path;
+use crate::sys::pal::sgx_ineffective;
 
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
+pub fn chdir(_: &Path) -> io::Result<()> {
     sgx_ineffective(())
 }
-
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported in SGX yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem in SGX")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
diff --git a/library/std/src/sys/paths/uefi.rs b/library/std/src/sys/paths/uefi.rs
index b25be430a3f8..7fddcfdff772 100644
--- a/library/std/src/sys/paths/uefi.rs
+++ b/library/std/src/sys/paths/uefi.rs
@@ -1,9 +1,9 @@
 use r_efi::efi::protocols::{device_path, loaded_image_device_path};
 
-use super::{helpers, unsupported_err};
 use crate::ffi::{OsStr, OsString};
 use crate::os::uefi::ffi::{OsStrExt, OsStringExt};
 use crate::path::{self, PathBuf};
+use crate::sys::pal::{helpers, unsupported_err};
 use crate::{fmt, io};
 
 const PATHS_SEP: u16 = b';' as u16;
@@ -115,7 +115,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
 }
 
 pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem on this platform")
+    panic!("UEFI doesn't have a dedicated temp directory")
 }
 
 pub fn home_dir() -> Option<PathBuf> {
diff --git a/library/std/src/sys/paths/unix.rs b/library/std/src/sys/paths/unix.rs
index f69614c2077c..544d495340db 100644
--- a/library/std/src/sys/paths/unix.rs
+++ b/library/std/src/sys/paths/unix.rs
@@ -7,8 +7,8 @@
 use crate::ffi::{CStr, OsStr, OsString};
 use crate::os::unix::prelude::*;
 use crate::path::{self, PathBuf};
-use crate::sys::cvt;
 use crate::sys::helpers::run_path_with_cstr;
+use crate::sys::pal::cvt;
 use crate::{fmt, io, iter, mem, ptr, slice, str};
 
 const PATH_SEPARATOR: u8 = b':';
@@ -47,7 +47,7 @@ pub fn getcwd() -> io::Result<PathBuf> {
 
 #[cfg(target_os = "espidf")]
 pub fn chdir(_p: &path::Path) -> io::Result<()> {
-    super::unsupported::unsupported()
+    crate::sys::pal::unsupported::unsupported()
 }
 
 #[cfg(not(target_os = "espidf"))]
@@ -372,7 +372,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
 
 #[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita"))]
 pub fn current_exe() -> io::Result<PathBuf> {
-    super::unsupported::unsupported()
+    crate::sys::pal::unsupported::unsupported()
 }
 
 #[cfg(target_os = "fuchsia")]
diff --git a/library/std/src/sys/paths/unsupported.rs b/library/std/src/sys/paths/unsupported.rs
index fe8addeafd2b..024830a254fd 100644
--- a/library/std/src/sys/paths/unsupported.rs
+++ b/library/std/src/sys/paths/unsupported.rs
@@ -1,7 +1,7 @@
-use super::unsupported;
 use crate::ffi::{OsStr, OsString};
 use crate::marker::PhantomData;
 use crate::path::{self, PathBuf};
+use crate::sys::pal::unsupported;
 use crate::{fmt, io};
 
 pub fn getcwd() -> io::Result<PathBuf> {
diff --git a/library/std/src/sys/paths/wasi.rs b/library/std/src/sys/paths/wasi.rs
index b1c26acc68cb..1e1f951cd679 100644
--- a/library/std/src/sys/paths/wasi.rs
+++ b/library/std/src/sys/paths/wasi.rs
@@ -1,12 +1,10 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-use crate::ffi::{CStr, OsStr, OsString};
-use crate::marker::PhantomData;
+use crate::ffi::{CStr, OsString};
+use crate::io;
 use crate::os::wasi::prelude::*;
 use crate::path::{self, PathBuf};
 use crate::sys::helpers::run_path_with_cstr;
-use crate::sys::unsupported;
-use crate::{fmt, io};
 
 pub fn getcwd() -> io::Result<PathBuf> {
     let mut buf = Vec::with_capacity(512);
@@ -42,46 +40,6 @@ pub fn chdir(p: &path::Path) -> io::Result<()> {
     }
 }
 
-pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on wasm yet".fmt(f)
-    }
-}
-
-impl crate::error::Error for JoinPathsError {}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
 pub fn temp_dir() -> PathBuf {
-    panic!("no filesystem on wasm")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
+    panic!("not supported by WASI yet")
 }
diff --git a/library/std/src/sys/paths/windows.rs b/library/std/src/sys/paths/windows.rs
index 30cad2a05683..cfdc93847a97 100644
--- a/library/std/src/sys/paths/windows.rs
+++ b/library/std/src/sys/paths/windows.rs
@@ -2,17 +2,13 @@
 
 #![allow(nonstandard_style)]
 
-#[cfg(test)]
-mod tests;
-
-use super::api;
-#[cfg(not(target_vendor = "uwp"))]
-use super::api::WinError;
 use crate::ffi::{OsStr, OsString};
 use crate::os::windows::ffi::EncodeWide;
 use crate::os::windows::prelude::*;
 use crate::path::{self, PathBuf};
-use crate::sys::pal::{c, cvt};
+#[cfg(not(target_vendor = "uwp"))]
+use crate::sys::pal::api::WinError;
+use crate::sys::pal::{api, c, cvt, fill_utf16_buf, os2path};
 use crate::{fmt, io, ptr};
 
 pub struct SplitPaths<'a> {
@@ -56,11 +52,7 @@ fn next(&mut self) -> Option<PathBuf> {
             }
         }
 
-        if !must_yield && in_progress.is_empty() {
-            None
-        } else {
-            Some(super::os2path(&in_progress))
-        }
+        if !must_yield && in_progress.is_empty() { None } else { Some(os2path(&in_progress)) }
     }
 }
 
@@ -104,14 +96,11 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 impl crate::error::Error for JoinPathsError {}
 
 pub fn current_exe() -> io::Result<PathBuf> {
-    super::fill_utf16_buf(
-        |buf, sz| unsafe { c::GetModuleFileNameW(ptr::null_mut(), buf, sz) },
-        super::os2path,
-    )
+    fill_utf16_buf(|buf, sz| unsafe { c::GetModuleFileNameW(ptr::null_mut(), buf, sz) }, os2path)
 }
 
 pub fn getcwd() -> io::Result<PathBuf> {
-    super::fill_utf16_buf(|buf, sz| unsafe { c::GetCurrentDirectoryW(sz, buf) }, super::os2path)
+    fill_utf16_buf(|buf, sz| unsafe { c::GetCurrentDirectoryW(sz, buf) }, os2path)
 }
 
 pub fn chdir(p: &path::Path) -> io::Result<()> {
@@ -123,7 +112,7 @@ pub fn chdir(p: &path::Path) -> io::Result<()> {
 }
 
 pub fn temp_dir() -> PathBuf {
-    super::fill_utf16_buf(|buf, sz| unsafe { c::GetTempPath2W(sz, buf) }, super::os2path).unwrap()
+    fill_utf16_buf(|buf, sz| unsafe { c::GetTempPath2W(sz, buf) }, os2path).unwrap()
 }
 
 #[cfg(all(not(target_vendor = "uwp"), not(target_vendor = "win7")))]
@@ -132,7 +121,7 @@ fn home_dir_crt() -> Option<PathBuf> {
         // Defined in processthreadsapi.h.
         const CURRENT_PROCESS_TOKEN: usize = -4_isize as usize;
 
-        super::fill_utf16_buf(
+        fill_utf16_buf(
             |buf, mut sz| {
                 // GetUserProfileDirectoryW does not quite use the usual protocol for
                 // negotiating the buffer size, so we have to translate.
@@ -146,7 +135,7 @@ fn home_dir_crt() -> Option<PathBuf> {
                     _ => sz - 1, // sz includes the null terminator
                 }
             },
-            super::os2path,
+            os2path,
         )
         .ok()
     }
@@ -163,7 +152,7 @@ fn home_dir_crt() -> Option<PathBuf> {
             return None;
         }
         let _handle = Handle::from_raw_handle(token);
-        super::fill_utf16_buf(
+        fill_utf16_buf(
             |buf, mut sz| {
                 match c::GetUserProfileDirectoryW(token, buf, &mut sz) {
                     0 if api::get_last_error() != WinError::INSUFFICIENT_BUFFER => 0,
@@ -171,7 +160,7 @@ fn home_dir_crt() -> Option<PathBuf> {
                     _ => sz - 1, // sz includes the null terminator
                 }
             },
-            super::os2path,
+            os2path,
         )
         .ok()
     }

From 98be8f7659a67caae28527fd7c37ba23b5d7ad3b Mon Sep 17 00:00:00 2001
From: Lars Schumann <LarsSchumann@mail.de>
Date: Mon, 9 Mar 2026 23:26:14 +0000
Subject: [PATCH 0271/1059] Fix Vec::const_make_global for 0 capacity and ZST's

---
 library/alloc/src/vec/mod.rs    | 14 ++++++++++++++
 library/alloctests/tests/vec.rs | 22 ++++++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 7796f3b8b2fb..8fbdb9a394ae 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -898,6 +898,20 @@ pub const fn const_make_global(mut self) -> &'static [T]
     where
         T: Freeze,
     {
+        // const_make_global requires the pointer to point to the beginning of a heap allocation,
+        // which is not the case when `self.capacity()` is 0, which is why we instead return a new slice.
+        if self.capacity() == 0 {
+            _ = ManuallyDrop::new(self);
+            return &[];
+        }
+
+        // if `T::IS_ZST`, the pointer we give to `const_make_global` would again not
+        // point to the start of a heap allocation
+        if T::IS_ZST {
+            let me = ManuallyDrop::new(self);
+            return unsafe { slice::from_raw_parts(NonNull::<T>::dangling().as_ptr(), me.len) };
+        }
+
         unsafe { core::intrinsics::const_make_global(self.as_mut_ptr().cast()) };
         let me = ManuallyDrop::new(self);
         unsafe { slice::from_raw_parts(me.as_ptr(), me.len) }
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
index 5ab305f7a504..db7da0db47d7 100644
--- a/library/alloctests/tests/vec.rs
+++ b/library/alloctests/tests/vec.rs
@@ -2764,3 +2764,25 @@ fn const_heap() {
 
     assert_eq!([1, 2, 4, 8, 16, 32], X);
 }
+
+// regression test for issue #153158. `const_make_global` previously assumed `Vec<T>`'s buf
+// always has a heap allocation, which lead to compilation errors.
+#[test]
+fn const_make_global_empty_or_zst_regression() {
+    const EMPTY_SLICE: &'static [i32] = {
+        let empty_vec: Vec<i32> = Vec::new();
+        empty_vec.const_make_global()
+    };
+
+    assert_eq!(EMPTY_SLICE, &[]);
+
+    const ZST_SLICE: &'static [()] = {
+        let mut zst_vec: Vec<()> = Vec::new();
+        zst_vec.push(());
+        zst_vec.push(());
+        zst_vec.push(());
+        zst_vec.const_make_global()
+    };
+
+    assert_eq!(ZST_SLICE, &[(), (), ()]);
+}

From 50ee6f9de6b9a97f6193053ad8d77a16b468761f Mon Sep 17 00:00:00 2001
From: Lars Schumann <LarsSchumann@mail.de>
Date: Tue, 10 Mar 2026 00:39:33 +0000
Subject: [PATCH 0272/1059] combine 0 capacity and ZST cases

---
 library/alloc/src/vec/mod.rs | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 8fbdb9a394ae..4c27a5ce0751 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -898,23 +898,17 @@ pub const fn const_make_global(mut self) -> &'static [T]
     where
         T: Freeze,
     {
-        // const_make_global requires the pointer to point to the beginning of a heap allocation,
-        // which is not the case when `self.capacity()` is 0, which is why we instead return a new slice.
-        if self.capacity() == 0 {
-            _ = ManuallyDrop::new(self);
-            return &[];
-        }
-
-        // if `T::IS_ZST`, the pointer we give to `const_make_global` would again not
-        // point to the start of a heap allocation
-        if T::IS_ZST {
+        // `const_make_global` requires the pointer to point to the beginning of a heap allocation,
+        // which is not the case when `self.capacity()` is 0, or if `T::IS_ZST`,
+        // which is why we instead return a new slice in this case.
+        if self.capacity() == 0 || T::IS_ZST {
             let me = ManuallyDrop::new(self);
-            return unsafe { slice::from_raw_parts(NonNull::<T>::dangling().as_ptr(), me.len) };
+            unsafe { slice::from_raw_parts(NonNull::<T>::dangling().as_ptr(), me.len) }
+        } else {
+            unsafe { core::intrinsics::const_make_global(self.as_mut_ptr().cast()) };
+            let me = ManuallyDrop::new(self);
+            unsafe { slice::from_raw_parts(me.as_ptr(), me.len) }
         }
-
-        unsafe { core::intrinsics::const_make_global(self.as_mut_ptr().cast()) };
-        let me = ManuallyDrop::new(self);
-        unsafe { slice::from_raw_parts(me.as_ptr(), me.len) }
     }
 }
 

From a5f88c783eb7090d3c154a58a0d260a99fef8791 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Tue, 10 Mar 2026 00:48:27 -0400
Subject: [PATCH 0273/1059] add autodiff download instructions

---
 .../src/autodiff/installation.md              | 49 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/autodiff/installation.md b/src/doc/rustc-dev-guide/src/autodiff/installation.md
index e05fdc1160f2..6b66a9dcb2d5 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/installation.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/installation.md
@@ -1,6 +1,50 @@
 # Installation
 
-In the near future, `std::autodiff` should become available in nightly builds for users. As a contributor however, you will still need to build rustc from source. Please be aware that the msvc target is not supported at the moment, all other tier 1 targets should work. Please open an issue if you encounter any problems on a supported tier 1 target, or if you successfully build this project on a tier2/tier3 target.
+In the near future, `std::autodiff` should become available for users via rustup. As a rustc/enzyme/autodiff contributor however, you will still need to build rustc from source. 
+For the meantime, you can download up-to-date builds to enable `std::autodiff` on your latest nightly toolchain, if you are using either of:  
+**Linux**, with `x86_64-unknown-linux-gnu` or `aarch64-unknown-linux-gnu`  
+**Windows**, with `x86_64-llvm-mingw` or `aarch64-llvm-mingw`  
+
+You can also download slightly outdated builds for **Apple** (aarch64-apple), which should generally work for now. 
+
+If you need any other platform, you can build rustc including autodiff from source. Please open an issue if you want to help enabling automatic builds for your prefered target.
+
+## Installation guide
+
+If you want to use `std::autodiff` and don't plan to contribute PR's to the project, then we recommend to just use your existing nightly installation and download the missing component. In the future, rustup will be able to do it for you.
+For now, you'll have to manually download and copy it.
+
+1) On our github repository, find the last merged PR: [`Repo`]
+2) Scroll down to the lower end of the PR, where you'll find a rust-bors message saying `Test successful` with a `CI` link. 
+3) Click on the `CI` link, and grep for your target. E.g. `dist-x86_64-linux` or `dist-aarch64-llvm-mingw` and click `Load summary`. 
+4) Under the `CI artifacts` section, find the `enzyme-nightly` artifact, download, and unpack it.
+5) Copy the artifact (libEnzyme-22.so for linux, libEnzyme-22.dylib for apple, etc.), which should be in a folder named `enzyme-preview`, to your rust toolchain directory. E.g. for linux: `cp  ~/Downloads/enzyme-nightly-x86_64-unknown-linux-gnu/enzyme-preview/lib/rustlib/x86_64-unknown-linux-gnu/lib/libEnzyme-22.so ~/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib`
+
+Apple support was temporarily reverted, due to downstream breakages. If you want to download autodiff for apple, please look at the artifacts from this [`run`].
+
+## Installation guide for Nix user.
+
+This setup was recommended by a nix and autodiff user. It uses [`Overlay`]. Please verify for yourself if you are comfortable using that repository.
+In that case you might use the following nix configuration to get a rustc that supports `std::autodiff`.
+```nix
+{
+  enzymeLib = pkgs.fetchzip {
+    url = "https://ci-artifacts.rust-lang.org/rustc-builds/ec818fda361ca216eb186f5cf45131bd9c776bb4/enzyme-nightly-x86_64-unknown-linux-gnu.tar.xz";
+    sha256 = "sha256-Rnrop44vzS+qmYNaRoMNNMFyAc3YsMnwdNGYMXpZ5VY=";
+  };
+  
+  rustToolchain = pkgs.symlinkJoin {
+    name = "rust-with-enzyme";
+    paths = [pkgs.rust-bin.nightly.latest.default];
+    nativeBuildInputs = [pkgs.makeWrapper];
+    postBuild = ''
+      libdir=$out/lib/rustlib/x86_64-unknown-linux-gnu/lib
+      cp ${enzymeLib}/enzyme-preview/lib/rustlib/x86_64-unknown-linux-gnu/lib/libEnzyme-22.so $libdir/
+      wrapProgram $out/bin/rustc --add-flags "--sysroot $out"
+    '';
+  };
+}
+```
 
 ## Build instructions
 
@@ -87,3 +131,6 @@ ninja
 ```
 This will build Enzyme, and you can find it in `Enzyme/enzyme/build/lib/<LLD/Clang/LLVM/lib>Enzyme.so`. (Endings might differ based on your OS).
 
+[`Repo`]: https://github.com/rust-lang/rust/
+[`run`]: https://github.com/rust-lang/rust/pull/153026#issuecomment-3950046599
+[`Overlay`]: https://github.com/oxalica/rust-overlay

From 557653d3aff2c0d3296ba033928146fb191395c9 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Tue, 10 Mar 2026 05:13:53 +0000
Subject: [PATCH 0274/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 2d76d9bc76f27b03b4899e72ce561c7ac2c5cf6b.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 2de5b4f0d5ae..24a7dd2899d5 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-c7b206bba4434ed928e9615f31082a9ef3f67c27
+2d76d9bc76f27b03b4899e72ce561c7ac2c5cf6b

From c9fc358c466ed26aac060b3fe711637be55b52dc Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Tue, 10 Mar 2026 15:28:04 +0900
Subject: [PATCH 0275/1059] add regression test for inherent assoc type
 mismatch ICE

---
 ...inherent-assoc-ty-mismatch-issue-153539.rs | 21 +++++++++++++
 ...rent-assoc-ty-mismatch-issue-153539.stderr | 31 +++++++++++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
 create mode 100644 tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr

diff --git a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
new file mode 100644
index 000000000000..019765a1909f
--- /dev/null
+++ b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Znext-solver=globally
+#![feature(inherent_associated_types)]
+//~^ WARN the feature `inherent_associated_types` is incomplete
+
+// Regression test for https://github.com/rust-lang/rust/issues/153539:
+
+struct S<'a>(&'a ());
+
+impl<X> S<'_> {
+    //~^ ERROR the type parameter `X` is not constrained by the impl trait, self type, or predicates
+    type P = ();
+}
+
+fn ret_ref_local<'e>() -> &'e i32 {
+    let f: for<'a> fn(&'a i32) -> S<'a>::P = |x| _ = x;
+
+    f(&1)
+    //~^ ERROR mismatched types
+}
+
+fn main() {}
diff --git a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr
new file mode 100644
index 000000000000..66ca01e845f3
--- /dev/null
+++ b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr
@@ -0,0 +1,31 @@
+warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/inherent-assoc-ty-mismatch-issue-153539.rs:2:12
+   |
+LL | #![feature(inherent_associated_types)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error[E0207]: the type parameter `X` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/inherent-assoc-ty-mismatch-issue-153539.rs:9:6
+   |
+LL | impl<X> S<'_> {
+   |      ^ unconstrained type parameter
+
+error[E0308]: mismatched types
+  --> $DIR/inherent-assoc-ty-mismatch-issue-153539.rs:17:5
+   |
+LL | fn ret_ref_local<'e>() -> &'e i32 {
+   |                           ------- expected `&'e i32` because of return type
+...
+LL |     f(&1)
+   |     ^^^^^ expected `&i32`, found associated type
+   |
+   = help: consider constraining the associated type `S<'_>::P` to `&'e i32`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0207, E0308.
+For more information about an error, try `rustc --explain E0207`.

From a92006f5c99f551fe7367e35532b398aa462474a Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Tue, 10 Mar 2026 15:28:29 +0900
Subject: [PATCH 0276/1059] avoid projection-only suggestions for inherent
 assoc types

---
 .../error_reporting/infer/note_and_explain.rs | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index adb2d2c185ca..0fde0009debe 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -272,18 +272,21 @@ fn foo(&self, x: T) -> T { x }
                                 values.found, values.expected,
                             )
                         };
-                        if !(self.suggest_constraining_opaque_associated_type(
-                            diag,
-                            msg,
-                            proj_ty,
-                            values.expected,
-                        ) || self.suggest_constraint(
-                            diag,
-                            &msg,
-                            body_owner_def_id,
-                            proj_ty,
-                            values.expected,
-                        )) {
+                        let suggested_projection_constraint = proj_ty.kind(tcx)
+                            == ty::AliasTyKind::Projection
+                            && (self.suggest_constraining_opaque_associated_type(
+                                diag,
+                                msg,
+                                proj_ty,
+                                values.expected,
+                            ) || self.suggest_constraint(
+                                diag,
+                                &msg,
+                                body_owner_def_id,
+                                proj_ty,
+                                values.expected,
+                            ));
+                        if !suggested_projection_constraint {
                             diag.help(msg());
                             diag.note(
                                 "for more information, visit \

From 0e0babcc5e5d3b0a0bf33b875731fb11a4e62f4b Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Tue, 10 Mar 2026 01:03:35 -0700
Subject: [PATCH 0277/1059] docs(fs): Clarify that File::lock coordinates
 across processes

---
 library/std/src/fs.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index 885bf376b98a..9643d3fcae66 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -815,7 +815,8 @@ pub fn sync_data(&self) -> io::Result<()> {
 
     /// Acquire an exclusive lock on the file. Blocks until the lock can be acquired.
     ///
-    /// This acquires an exclusive lock; no other file handle to this file may acquire another lock.
+    /// This acquires an exclusive lock; no other file handle to this file, in this or any other
+    /// process, may acquire another lock.
     ///
     /// This lock may be advisory or mandatory. This lock is meant to interact with [`lock`],
     /// [`try_lock`], [`lock_shared`], [`try_lock_shared`], and [`unlock`]. Its interactions with
@@ -868,8 +869,8 @@ pub fn lock(&self) -> io::Result<()> {
 
     /// Acquire a shared (non-exclusive) lock on the file. Blocks until the lock can be acquired.
     ///
-    /// This acquires a shared lock; more than one file handle may hold a shared lock, but none may
-    /// hold an exclusive lock at the same time.
+    /// This acquires a shared lock; more than one file handle, in this or any other process, may
+    /// hold a shared lock, but none may hold an exclusive lock at the same time.
     ///
     /// This lock may be advisory or mandatory. This lock is meant to interact with [`lock`],
     /// [`try_lock`], [`lock_shared`], [`try_lock_shared`], and [`unlock`]. Its interactions with
@@ -923,7 +924,8 @@ pub fn lock_shared(&self) -> io::Result<()> {
     /// Returns `Err(TryLockError::WouldBlock)` if a different lock is already held on this file
     /// (via another handle/descriptor).
     ///
-    /// This acquires an exclusive lock; no other file handle to this file may acquire another lock.
+    /// This acquires an exclusive lock; no other file handle to this file, in this or any other
+    /// process, may acquire another lock.
     ///
     /// This lock may be advisory or mandatory. This lock is meant to interact with [`lock`],
     /// [`try_lock`], [`lock_shared`], [`try_lock_shared`], and [`unlock`]. Its interactions with
@@ -987,8 +989,8 @@ pub fn try_lock(&self) -> Result<(), TryLockError> {
     /// Returns `Err(TryLockError::WouldBlock)` if a different lock is already held on this file
     /// (via another handle/descriptor).
     ///
-    /// This acquires a shared lock; more than one file handle may hold a shared lock, but none may
-    /// hold an exclusive lock at the same time.
+    /// This acquires a shared lock; more than one file handle, in this or any other process, may
+    /// hold a shared lock, but none may hold an exclusive lock at the same time.
     ///
     /// This lock may be advisory or mandatory. This lock is meant to interact with [`lock`],
     /// [`try_lock`], [`lock_shared`], [`try_lock_shared`], and [`unlock`]. Its interactions with

From 1f05c768be37d3d54ae8ebb61357957602d40052 Mon Sep 17 00:00:00 2001
From: Luca Palmieri <20745048+LukeMathWalker@users.noreply.github.com>
Date: Tue, 10 Mar 2026 09:46:45 +0100
Subject: [PATCH 0278/1059] doc: Avoid intra-doc links that don't resolve if
 the rkyv_0_8 feature isn't enabled

---
 src/rustdoc-json-types/lib.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index 3cf1fa22b246..21f83617ef34 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -19,18 +19,20 @@
 //! ## `rkyv_0_8`
 //!
 //! We expose a `rkyv_0_8` feature, disabled by default. When enabled, it derives `rkyv`'s
-//! [`Archive`](rkyv::Archive), [`Serialize`](rkyv::Serialize) and [`Deserialize`](rkyv::Deserialize)
-//! traits for all types in this crate. Furthermore, it exposes the corresponding `Archived*` types
-//! (e.g. [`ArchivedId`] for [`Id`]).
+//! [`Archive`][3], [`Serialize`][4] and [`Deserialize`][5] traits for all types in this crate.
+//! Furthermore, it exposes the corresponding `Archived*` types (e.g. `ArchivedId` for [`Id`]).
 //!
 //! `rkyv` lets you works with JSON output without paying the deserialization cost _upfront_,
-//! thanks to [zero-copy deserialization][3].
+//! thanks to [zero-copy deserialization][6].
 //! You can perform various types of analyses on the `Archived*` version of the relevant types,
 //! incurring the full deserialization cost only for the subset of items you actually need.
 //!
 //! [1]: https://rust-lang.zulipchat.com/#narrow/channel/266220-t-rustdoc/topic/rustc-hash.20and.20performance.20of.20rustdoc-types/near/474855731
 //! [2]: https://crates.io/crates/rustc-hash
-//! [3]: https://rkyv.org/zero-copy-deserialization.html
+//! [3]: https://docs.rs/rkyv/0.8.15/rkyv/trait.Archive.html
+//! [4]: https://docs.rs/rkyv/0.8.15/rkyv/trait.Serialize.html
+//! [5]: https://docs.rs/rkyv/0.8.15/rkyv/trait.Deserialize.html
+//! [6]: https://rkyv.org/zero-copy-deserialization.html
 
 // # On `rkyv` Derives
 //

From 8caaf1d1e04160385ec9f861f431693047d83b09 Mon Sep 17 00:00:00 2001
From: Frank King <frankking1729@gmail.com>
Date: Fri, 30 Jan 2026 10:48:18 +0800
Subject: [PATCH 0279/1059] Support coercion between references and pinned
 references

---
 compiler/rustc_hir_analysis/src/autoderef.rs  |   2 +
 compiler/rustc_hir_typeck/src/autoderef.rs    |   4 +
 compiler/rustc_hir_typeck/src/coercion.rs     |  65 +++++
 .../rustc_hir_typeck/src/expr_use_visitor.rs  |  12 +-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |   3 +
 compiler/rustc_lint/src/autorefs.rs           |   4 +-
 compiler/rustc_middle/src/ty/adjustment.rs    |   5 +
 compiler/rustc_mir_build/src/thir/cx/expr.rs  |  44 ++++
 .../pin-coercion-check.normal.stderr          | 227 ++++++++++++++++++
 .../pin-coercion-check.pin_ergonomics.stderr  | 155 ++++++++++++
 tests/ui/pin-ergonomics/pin-coercion-check.rs |  66 +++++
 tests/ui/pin-ergonomics/pin-coercion.rs       |  56 +++++
 12 files changed, 640 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/pin-ergonomics/pin-coercion-check.normal.stderr
 create mode 100644 tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
 create mode 100644 tests/ui/pin-ergonomics/pin-coercion-check.rs
 create mode 100644 tests/ui/pin-ergonomics/pin-coercion.rs

diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index 1f06b1c94237..aae20f369b91 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -17,6 +17,8 @@ pub enum AutoderefKind {
     Builtin,
     /// A type which must dispatch to a `Deref` implementation.
     Overloaded,
+    /// A pinned reference type, such as `Pin<&T>` and `Pin<&mut T>`.
+    Pin,
 }
 struct AutoderefSnapshot<'tcx> {
     at_start: bool,
diff --git a/compiler/rustc_hir_typeck/src/autoderef.rs b/compiler/rustc_hir_typeck/src/autoderef.rs
index f7700179d2a3..8ae4918edbfd 100644
--- a/compiler/rustc_hir_typeck/src/autoderef.rs
+++ b/compiler/rustc_hir_typeck/src/autoderef.rs
@@ -6,6 +6,7 @@
 use rustc_hir_analysis::autoderef::{Autoderef, AutoderefKind};
 use rustc_infer::infer::InferOk;
 use rustc_infer::traits::PredicateObligations;
+use rustc_middle::bug;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, DerefAdjustKind, OverloadedDeref};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
@@ -62,6 +63,9 @@ pub(crate) fn adjust_steps_as_infer_ok(
                         })
                         .unwrap_or(DerefAdjustKind::Builtin)
                 }
+                AutoderefKind::Pin => {
+                    bug!("Pin autoderef kind should not be present in the steps")
+                }
                 AutoderefKind::Builtin => DerefAdjustKind::Builtin,
             })
             .zip_eq(targets)
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 8a73125d6476..95eb1cfbea96 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -269,12 +269,21 @@ fn coerce(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
                 return self.coerce_to_raw_ptr(a, b, b_mutbl);
             }
             ty::Ref(r_b, _, mutbl_b) => {
+                if self.tcx.features().pin_ergonomics()
+                    && a.pinned_ty().is_some_and(|ty| ty.is_ref())
+                    && let Ok(coerce) = self.commit_if_ok(|_| self.coerce_maybe_pinned_ref(a, b))
+                {
+                    return Ok(coerce);
+                }
                 return self.coerce_to_ref(a, b, r_b, mutbl_b);
             }
             ty::Adt(pin, _)
                 if self.tcx.features().pin_ergonomics()
                     && self.tcx.is_lang_item(pin.did(), hir::LangItem::Pin) =>
             {
+                if a.is_ref() && b.pinned_ty().is_some_and(|ty| ty.is_ref()) {
+                    return self.coerce_maybe_pinned_ref(a, b);
+                }
                 let pin_coerce = self.commit_if_ok(|_| self.coerce_to_pin_ref(a, b));
                 if pin_coerce.is_ok() {
                     return pin_coerce;
@@ -847,6 +856,62 @@ fn coerce_to_pin_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
         self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b), ForceLeakCheck::No)
     }
 
+    /// Coerce pinned reference to regular reference or vice versa
+    ///
+    /// - `Pin<&mut T>` <-> `&mut T` when `T: Unpin`
+    /// - `Pin<&T>` <-> `&T` when `T: Unpin`
+    /// - `Pin<&mut T>` <-> `Pin<&T>` when `T: Unpin`
+    #[instrument(skip(self), level = "trace")]
+    fn coerce_maybe_pinned_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+        let span = self.cause.span;
+        let Some((a_ty, a_pinnedness, a_mutbl, a_region)) = a.maybe_pinned_ref() else {
+            span_bug!(span, "expect pinned reference or reference, found {:?}", a);
+        };
+        let Some((_b_ty, b_pinnedness, b_mutbl, _b_region)) = b.maybe_pinned_ref() else {
+            span_bug!(span, "expect pinned reference or reference, found {:?}", b);
+        };
+        use ty::Pinnedness::*;
+        if a_pinnedness == b_pinnedness {
+            span_bug!(span, "expect different pinnedness, found {:?} and {:?}", a, b);
+        }
+
+        coerce_mutbls(a_mutbl, b_mutbl)?;
+
+        let (deref, borrow) = match (a_pinnedness, b_pinnedness) {
+            (Not, Not) | (Pinned, Pinned) => {
+                span_bug!(span, "expect different pinnedness, found {:?} and {:?}", a, b)
+            }
+            (Pinned, Not) => {
+                let mutbl = AutoBorrowMutability::new(b_mutbl, AllowTwoPhase::Yes);
+                (DerefAdjustKind::Pin, AutoBorrow::Ref(mutbl))
+            }
+            (Not, Pinned) => (DerefAdjustKind::Builtin, AutoBorrow::Pin(b_mutbl)),
+        };
+        let mut coerce = self.unify_and(
+            // update a with b's pinnedness and mutability since we'll be coercing pinnedness and mutability
+            match b_pinnedness {
+                Pinned => Ty::new_pinned_ref(self.tcx, a_region, a_ty, b_mutbl),
+                Not => Ty::new_ref(self.tcx, a_region, a_ty, b_mutbl),
+            },
+            b,
+            [Adjustment { kind: Adjust::Deref(deref), target: a_ty }],
+            Adjust::Borrow(borrow),
+            ForceLeakCheck::No,
+        )?;
+
+        // Create an obligation for `a_ty: Unpin`.
+        let cause =
+            self.cause(self.cause.span, ObligationCauseCode::Coercion { source: a, target: b });
+        let pred = ty::TraitRef::new(
+            self.tcx,
+            self.tcx.require_lang_item(hir::LangItem::Unpin, self.cause.span),
+            [a_ty],
+        );
+        let obligation = Obligation::new(self.tcx, cause, self.fcx.param_env, pred);
+        coerce.obligations.push(obligation);
+        Ok(coerce)
+    }
+
     fn coerce_from_fn_pointer(
         &self,
         a: Ty<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index 0a492c795b29..5905e5610f72 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -736,7 +736,7 @@ fn walk_adjustment(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
                     self.consume_or_copy(&place_with_id, place_with_id.hir_id);
                 }
 
-                adjustment::Adjust::Deref(DerefAdjustKind::Builtin) => {}
+                adjustment::Adjust::Deref(DerefAdjustKind::Builtin | DerefAdjustKind::Pin) => {}
 
                 // Autoderefs for overloaded Deref calls in fact reference
                 // their receiver. That is, if we have `(*x)` where `x`
@@ -800,6 +800,16 @@ fn walk_autoref(
                     ty::BorrowKind::from_mutbl(m),
                 );
             }
+
+            adjustment::AutoBorrow::Pin(m) => {
+                debug!("walk_autoref: expr.hir_id={} base_place={:?}", expr.hir_id, base_place);
+
+                self.delegate.borrow_mut().borrow(
+                    base_place,
+                    base_place.hir_id,
+                    ty::BorrowKind::from_mutbl(m),
+                );
+            }
         }
     }
 
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index c24d1127d5a6..f817ca842147 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -331,6 +331,9 @@ pub(crate) fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment
                 Adjust::Deref(DerefAdjustKind::Builtin) => {
                     // FIXME(const_trait_impl): We *could* enforce `&T: [const] Deref` here.
                 }
+                Adjust::Deref(DerefAdjustKind::Pin) => {
+                    // FIXME(const_trait_impl): We *could* enforce `Pin<&T>: [const] Deref` here.
+                }
                 Adjust::Pointer(_pointer_coercion) => {
                     // FIXME(const_trait_impl): We should probably enforce these.
                 }
diff --git a/compiler/rustc_lint/src/autorefs.rs b/compiler/rustc_lint/src/autorefs.rs
index 34049288ea80..910a2918f9f7 100644
--- a/compiler/rustc_lint/src/autorefs.rs
+++ b/compiler/rustc_lint/src/autorefs.rs
@@ -173,7 +173,7 @@ fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<(Muta
         Adjust::NeverToAny
         | Adjust::Pointer(..)
         | Adjust::ReborrowPin(..)
-        | Adjust::Deref(DerefAdjustKind::Builtin)
-        | Adjust::Borrow(AutoBorrow::RawPtr(..)) => None,
+        | Adjust::Deref(DerefAdjustKind::Builtin | DerefAdjustKind::Pin)
+        | Adjust::Borrow(AutoBorrow::RawPtr(..) | AutoBorrow::Pin(..)) => None,
     }
 }
diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
index 6d546aede4cf..58687be7440b 100644
--- a/compiler/rustc_middle/src/ty/adjustment.rs
+++ b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -105,6 +105,7 @@ pub enum Adjust {
     Pointer(PointerCoercion),
 
     /// Take a pinned reference and reborrow as a `Pin<&mut T>` or `Pin<&T>`.
+    // FIXME(pin_ergonomics): This can be replaced with a `Deref(Pin)` followed by a `Borrow(Pin)`
     ReborrowPin(hir::Mutability),
 }
 
@@ -112,6 +113,7 @@ pub enum Adjust {
 pub enum DerefAdjustKind {
     Builtin,
     Overloaded(OverloadedDeref),
+    Pin,
 }
 
 /// An overloaded autoderef step, representing a `Deref(Mut)::deref(_mut)`
@@ -196,6 +198,9 @@ pub enum AutoBorrow {
 
     /// Converts from T to *T.
     RawPtr(hir::Mutability),
+
+    /// Converts from T to Pin<&T>.
+    Pin(hir::Mutability),
 }
 
 /// Information for `CoerceUnsized` impls, storing information we
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index c5eeb8b1aa85..c646b0fc45ea 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -143,6 +143,19 @@ fn apply_adjustment(
                 adjust_span(&mut expr);
                 ExprKind::Deref { arg: self.thir.exprs.push(expr) }
             }
+            Adjust::Deref(DerefAdjustKind::Pin) => {
+                adjust_span(&mut expr);
+                // pointer = ($expr).pointer
+                let pin_ty = expr.ty.pinned_ty().expect("Deref(Pin) with non-Pin type");
+                let pointer_target = ExprKind::Field {
+                    lhs: self.thir.exprs.push(expr),
+                    variant_index: FIRST_VARIANT,
+                    name: FieldIdx::ZERO,
+                };
+                let expr = Expr { temp_scope_id, ty: pin_ty, span, kind: pointer_target };
+                // expr = *pointer
+                ExprKind::Deref { arg: self.thir.exprs.push(expr) }
+            }
             Adjust::Deref(DerefAdjustKind::Overloaded(deref)) => {
                 // We don't need to do call adjust_span here since
                 // deref coercions always start with a built-in deref.
@@ -177,6 +190,37 @@ fn apply_adjustment(
             Adjust::Borrow(AutoBorrow::RawPtr(mutability)) => {
                 ExprKind::RawBorrow { mutability, arg: self.thir.exprs.push(expr) }
             }
+            Adjust::Borrow(AutoBorrow::Pin(mutbl)) => {
+                // expr = &pin (mut|const|) arget
+                let borrow_kind = match mutbl {
+                    hir::Mutability::Mut => BorrowKind::Mut { kind: mir::MutBorrowKind::Default },
+                    hir::Mutability::Not => BorrowKind::Shared,
+                };
+                let new_pin_target =
+                    Ty::new_ref(self.tcx, self.tcx.lifetimes.re_erased, expr.ty, mutbl);
+                let arg = self.thir.exprs.push(expr);
+                let expr = self.thir.exprs.push(Expr {
+                    temp_scope_id,
+                    ty: new_pin_target,
+                    span,
+                    kind: ExprKind::Borrow { borrow_kind, arg },
+                });
+
+                // kind = Pin { pointer }
+                let pin_did = self.tcx.require_lang_item(rustc_hir::LangItem::Pin, span);
+                let args = self.tcx.mk_args(&[new_pin_target.into()]);
+                let kind = ExprKind::Adt(Box::new(AdtExpr {
+                    adt_def: self.tcx.adt_def(pin_did),
+                    variant_index: FIRST_VARIANT,
+                    args,
+                    fields: Box::new([FieldExpr { name: FieldIdx::ZERO, expr }]),
+                    user_ty: None,
+                    base: AdtExprBase::None,
+                }));
+
+                debug!(?kind);
+                kind
+            }
             Adjust::ReborrowPin(mutbl) => {
                 debug!("apply ReborrowPin adjustment");
                 // Rewrite `$expr` as `Pin { __pointer: &(mut)? *($expr).__pointer }`
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.normal.stderr b/tests/ui/pin-ergonomics/pin-coercion-check.normal.stderr
new file mode 100644
index 000000000000..0806ad64448c
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.normal.stderr
@@ -0,0 +1,227 @@
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:9:36
+   |
+LL |     |x: Pin<&mut T>| -> &mut T { x.get_mut() };
+   |                                    ^^^^^^^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required by a bound in `Pin::<&'a mut T>::get_mut`
+  --> $SRC_DIR/core/src/pin.rs:LL:COL
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn get<T: std::marker::Unpin, U: Unpin>() {
+   |         ++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:18:34
+   |
+LL |     |x: Pin<&mut T>| -> &mut T { x };
+   |                         ------   ^ expected `&mut T`, found `Pin<&mut T>`
+   |                         |
+   |                         expected `&mut T` because of return type
+   |
+   = note: expected mutable reference `&mut T`
+                         found struct `Pin<&mut T>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&mut T>| -> &mut T { &mut x };
+   |                                  ++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:21:30
+   |
+LL |     |x: Pin<&mut T>| -> &T { x };
+   |                         --   ^ expected `&T`, found `Pin<&mut T>`
+   |                         |
+   |                         expected `&T` because of return type
+   |
+   = note: expected reference `&T`
+                 found struct `Pin<&mut T>`
+help: consider borrowing here
+   |
+LL |     |x: Pin<&mut T>| -> &T { &x };
+   |                              +
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:24:26
+   |
+LL |     |x: Pin<&T>| -> &T { x };
+   |                     --   ^ expected `&T`, found `Pin<&T>`
+   |                     |
+   |                     expected `&T` because of return type
+   |
+   = note: expected reference `&T`
+                 found struct `Pin<&T>`
+help: consider borrowing here
+   |
+LL |     |x: Pin<&T>| -> &T { &x };
+   |                          +
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:27:30
+   |
+LL |     |x: Pin<&T>| -> &mut T { x };
+   |                     ------   ^ expected `&mut T`, found `Pin<&T>`
+   |                     |
+   |                     expected `&mut T` because of return type
+   |
+   = note: expected mutable reference `&mut T`
+                         found struct `Pin<&T>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&T>| -> &mut T { &mut x };
+   |                              ++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:31:34
+   |
+LL |     |x: Pin<&mut U>| -> &mut U { x };
+   |                         ------   ^ expected `&mut U`, found `Pin<&mut U>`
+   |                         |
+   |                         expected `&mut U` because of return type
+   |
+   = note: expected mutable reference `&mut U`
+                         found struct `Pin<&mut U>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&mut U>| -> &mut U { &mut x };
+   |                                  ++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:33:30
+   |
+LL |     |x: Pin<&mut U>| -> &U { x };
+   |                         --   ^ expected `&U`, found `Pin<&mut U>`
+   |                         |
+   |                         expected `&U` because of return type
+   |
+   = note: expected reference `&U`
+                 found struct `Pin<&mut U>`
+help: consider borrowing here
+   |
+LL |     |x: Pin<&mut U>| -> &U { &x };
+   |                              +
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:35:26
+   |
+LL |     |x: Pin<&U>| -> &U { x };
+   |                     --   ^ expected `&U`, found `Pin<&U>`
+   |                     |
+   |                     expected `&U` because of return type
+   |
+   = note: expected reference `&U`
+                 found struct `Pin<&U>`
+help: consider borrowing here
+   |
+LL |     |x: Pin<&U>| -> &U { &x };
+   |                          +
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:37:30
+   |
+LL |     |x: Pin<&U>| -> &mut U { x };
+   |                     ------   ^ expected `&mut U`, found `Pin<&U>`
+   |                     |
+   |                     expected `&mut U` because of return type
+   |
+   = note: expected mutable reference `&mut U`
+                         found struct `Pin<&U>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&U>| -> &mut U { &mut x };
+   |                              ++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:43:34
+   |
+LL |     |x: &mut T| -> Pin<&mut T> { x };
+   |                    -----------   ^ expected `Pin<&mut T>`, found `&mut T`
+   |                    |
+   |                    expected `Pin<&mut T>` because of return type
+   |
+   = note:         expected struct `Pin<&mut T>`
+           found mutable reference `&mut T`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:46:30
+   |
+LL |     |x: &mut T| -> Pin<&T> { x };
+   |                    -------   ^ expected `Pin<&T>`, found `&mut T`
+   |                    |
+   |                    expected `Pin<&T>` because of return type
+   |
+   = note:         expected struct `Pin<&T>`
+           found mutable reference `&mut T`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:49:26
+   |
+LL |     |x: &T| -> Pin<&T> { x };
+   |                -------   ^ expected `Pin<&T>`, found `&T`
+   |                |
+   |                expected `Pin<&T>` because of return type
+   |
+   = note: expected struct `Pin<&T>`
+           found reference `&T`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:52:30
+   |
+LL |     |x: &T| -> Pin<&mut T> { x };
+   |                -----------   ^ expected `Pin<&mut T>`, found `&T`
+   |                |
+   |                expected `Pin<&mut T>` because of return type
+   |
+   = note: expected struct `Pin<&mut T>`
+           found reference `&T`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:56:34
+   |
+LL |     |x: &mut U| -> Pin<&mut U> { x };
+   |                    -----------   ^ expected `Pin<&mut U>`, found `&mut U`
+   |                    |
+   |                    expected `Pin<&mut U>` because of return type
+   |
+   = note:         expected struct `Pin<&mut U>`
+           found mutable reference `&mut U`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:58:30
+   |
+LL |     |x: &mut U| -> Pin<&U> { x };
+   |                    -------   ^ expected `Pin<&U>`, found `&mut U`
+   |                    |
+   |                    expected `Pin<&U>` because of return type
+   |
+   = note:         expected struct `Pin<&U>`
+           found mutable reference `&mut U`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:60:26
+   |
+LL |     |x: &U| -> Pin<&U> { x };
+   |                -------   ^ expected `Pin<&U>`, found `&U`
+   |                |
+   |                expected `Pin<&U>` because of return type
+   |
+   = note: expected struct `Pin<&U>`
+           found reference `&U`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:62:30
+   |
+LL |     |x: &U| -> Pin<&mut U> { x };
+   |                -----------   ^ expected `Pin<&mut U>`, found `&U`
+   |                |
+   |                expected `Pin<&mut U>` because of return type
+   |
+   = note: expected struct `Pin<&mut U>`
+           found reference `&U`
+
+error: aborting due to 17 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
new file mode 100644
index 000000000000..ce343fd24a5b
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
@@ -0,0 +1,155 @@
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:9:36
+   |
+LL |     |x: Pin<&mut T>| -> &mut T { x.get_mut() };
+   |                                    ^^^^^^^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required by a bound in `Pin::<&'a mut T>::get_mut`
+  --> $SRC_DIR/core/src/pin.rs:LL:COL
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn get<T: std::marker::Unpin, U: Unpin>() {
+   |         ++++++++++++++++++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:18:34
+   |
+LL |     |x: Pin<&mut T>| -> &mut T { x };
+   |                                  ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&mut T>` to `&mut T`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:21:30
+   |
+LL |     |x: Pin<&mut T>| -> &T { x };
+   |                              ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&mut T>` to `&T`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:24:26
+   |
+LL |     |x: Pin<&T>| -> &T { x };
+   |                          ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&T>` to `&T`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:27:30
+   |
+LL |     |x: Pin<&T>| -> &mut T { x };
+   |                     ------   ^ expected `&mut T`, found `Pin<&T>`
+   |                     |
+   |                     expected `&mut T` because of return type
+   |
+   = note: expected mutable reference `&mut T`
+                         found struct `Pin<&T>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&T>| -> &mut T { &mut x };
+   |                              ++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:37:30
+   |
+LL |     |x: Pin<&U>| -> &mut U { x };
+   |                     ------   ^ expected `&mut U`, found `Pin<&U>`
+   |                     |
+   |                     expected `&mut U` because of return type
+   |
+   = note: expected mutable reference `&mut U`
+                         found struct `Pin<&U>`
+help: consider mutably borrowing here
+   |
+LL |     |x: Pin<&U>| -> &mut U { &mut x };
+   |                              ++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:43:34
+   |
+LL |     |x: &mut T| -> Pin<&mut T> { x };
+   |                                  ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&mut T` to `Pin<&mut T>`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:46:30
+   |
+LL |     |x: &mut T| -> Pin<&T> { x };
+   |                              ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&mut T` to `Pin<&T>`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0277]: `T` cannot be unpinned
+  --> $DIR/pin-coercion-check.rs:49:26
+   |
+LL |     |x: &T| -> Pin<&T> { x };
+   |                          ^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&T` to `Pin<&T>`
+help: consider restricting type parameter `T` with trait `Unpin`
+   |
+LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
+   |                ++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:52:30
+   |
+LL |     |x: &T| -> Pin<&mut T> { x };
+   |                -----------   ^ types differ in mutability
+   |                |
+   |                expected `Pin<&mut T>` because of return type
+   |
+   = note: expected struct `Pin<&mut T>`
+           found reference `&T`
+
+error[E0308]: mismatched types
+  --> $DIR/pin-coercion-check.rs:62:30
+   |
+LL |     |x: &U| -> Pin<&mut U> { x };
+   |                -----------   ^ types differ in mutability
+   |                |
+   |                expected `Pin<&mut U>` because of return type
+   |
+   = note: expected struct `Pin<&mut U>`
+           found reference `&U`
+
+error: aborting due to 11 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.rs b/tests/ui/pin-ergonomics/pin-coercion-check.rs
new file mode 100644
index 000000000000..9b51851219cc
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.rs
@@ -0,0 +1,66 @@
+//@ revisions: pin_ergonomics normal
+//@ edition:2024
+#![cfg_attr(pin_ergonomics, feature(pin_ergonomics))]
+#![allow(incomplete_features)]
+
+use std::pin::Pin;
+
+fn get<T, U: Unpin>() {
+    |x: Pin<&mut T>| -> &mut T { x.get_mut() }; //~ ERROR `T` cannot be unpinned
+    |x: Pin<&T>| -> &T { x.get_ref() };
+
+    |x: Pin<&mut U>| -> &mut U { x.get_mut() };
+    |x: Pin<&U>| -> &U { x.get_ref() };
+}
+
+fn pin_to_ref<T, U: Unpin>() {
+    // T: !Unpin
+    |x: Pin<&mut T>| -> &mut T { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: Pin<&mut T>| -> &T { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: Pin<&T>| -> &T { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: Pin<&T>| -> &mut T { x };
+    //~^ ERROR mismatched types
+
+    // U: Unpin
+    |x: Pin<&mut U>| -> &mut U { x };
+    //[normal]~^ ERROR mismatched types
+    |x: Pin<&mut U>| -> &U { x };
+    //[normal]~^ ERROR mismatched types
+    |x: Pin<&U>| -> &U { x };
+    //[normal]~^ ERROR mismatched types
+    |x: Pin<&U>| -> &mut U { x };
+    //~^ ERROR mismatched types
+}
+
+fn ref_to_pin<T, U: Unpin>() {
+    // T: !Unpin
+    |x: &mut T| -> Pin<&mut T> { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: &mut T| -> Pin<&T> { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: &T| -> Pin<&T> { x };
+    //[normal]~^ ERROR mismatched types
+    //[pin_ergonomics]~^^ ERROR `T` cannot be unpinned
+    |x: &T| -> Pin<&mut T> { x };
+    //~^ ERROR mismatched types
+
+    // U: Unpin
+    |x: &mut U| -> Pin<&mut U> { x };
+    //[normal]~^ ERROR mismatched types
+    |x: &mut U| -> Pin<&U> { x };
+    //[normal]~^ ERROR mismatched types
+    |x: &U| -> Pin<&U> { x };
+    //[normal]~^ ERROR mismatched types
+    |x: &U| -> Pin<&mut U> { x };
+    //~^ ERROR mismatched types
+}
+
+fn main() {}
diff --git a/tests/ui/pin-ergonomics/pin-coercion.rs b/tests/ui/pin-ergonomics/pin-coercion.rs
new file mode 100644
index 000000000000..6ace4b97edb3
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pin-coercion.rs
@@ -0,0 +1,56 @@
+//@ run-pass
+//@ edition:2024
+#![feature(pin_ergonomics)]
+#![allow(incomplete_features)]
+#![deny(dead_code)]
+
+use std::cell::RefCell;
+
+fn coerce_mut_to_pin_mut<T: Unpin>(x: &mut T) -> &pin mut T {
+    x
+}
+fn coerce_ref_to_pin_ref<T: Unpin>(x: &T) -> &pin const T {
+    x
+}
+fn coerce_pin_mut_to_mut<T: Unpin>(x: &pin mut T) -> &mut T {
+    x
+}
+fn coerce_pin_ref_to_ref<T: Unpin>(x: &pin const T) -> &T {
+    x
+}
+
+fn coerce_pin_mut_to_ref<T: Unpin>(x: &pin mut T) -> &T {
+    x
+}
+fn coerce_mut_to_pin_ref<T: Unpin>(x: &mut T) -> &pin const T {
+    x
+}
+
+fn test(x: &mut RefCell<String>) {
+    let mut x: &pin mut _ = coerce_mut_to_pin_mut(x);
+    x.get_mut().get_mut().push_str("&mut T -> &pin mut T\n");
+    let x_ref: &_ = coerce_pin_mut_to_ref(x.as_mut());
+    x_ref.borrow_mut().push_str("&pin mut T -> &T\n");
+    let x: &mut _ = coerce_pin_mut_to_mut(x);
+    x.get_mut().push_str("&pin mut T -> &mut T\n");
+    let x: &pin const _ = coerce_mut_to_pin_ref(x);
+    x.borrow_mut().push_str("&mut T -> &pin const T\n");
+    let x: &_ = coerce_pin_ref_to_ref(x);
+    x.borrow_mut().push_str("&pin const T -> &T\n");
+    let x: &pin const _ = coerce_ref_to_pin_ref(x);
+    x.borrow_mut().push_str("&T -> &pin const T\n");
+}
+
+fn main() {
+    let mut x = RefCell::new(String::new());
+    test(&mut x);
+    assert_eq!(
+        x.borrow().as_str(),
+        "&mut T -> &pin mut T\n\
+        &pin mut T -> &T\n\
+        &pin mut T -> &mut T\n\
+        &mut T -> &pin const T\n\
+        &pin const T -> &T\n\
+        &T -> &pin const T\n"
+    );
+}

From 3f75db3be71396752e77c3f86c258020f3626ad8 Mon Sep 17 00:00:00 2001
From: Frank King <frankking1729@gmail.com>
Date: Wed, 4 Feb 2026 16:59:16 +0800
Subject: [PATCH 0280/1059] Remove `coerce_maybe_pinned_ref`.

Use `coerce_to_pin_ref` and `coerce_pin_ref_to_ref` instead.
---
 compiler/rustc_hir_analysis/src/autoderef.rs  |   2 -
 compiler/rustc_hir_typeck/src/autoderef.rs    |   4 -
 compiler/rustc_hir_typeck/src/coercion.rs     | 174 ++++++++----------
 .../rustc_hir_typeck/src/expr_use_visitor.rs  |  12 +-
 compiler/rustc_middle/src/ty/sty.rs           |   8 +
 .../pin-coercion-check.pin_ergonomics.stderr  |  10 +-
 6 files changed, 89 insertions(+), 121 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index aae20f369b91..1f06b1c94237 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -17,8 +17,6 @@ pub enum AutoderefKind {
     Builtin,
     /// A type which must dispatch to a `Deref` implementation.
     Overloaded,
-    /// A pinned reference type, such as `Pin<&T>` and `Pin<&mut T>`.
-    Pin,
 }
 struct AutoderefSnapshot<'tcx> {
     at_start: bool,
diff --git a/compiler/rustc_hir_typeck/src/autoderef.rs b/compiler/rustc_hir_typeck/src/autoderef.rs
index 8ae4918edbfd..f7700179d2a3 100644
--- a/compiler/rustc_hir_typeck/src/autoderef.rs
+++ b/compiler/rustc_hir_typeck/src/autoderef.rs
@@ -6,7 +6,6 @@
 use rustc_hir_analysis::autoderef::{Autoderef, AutoderefKind};
 use rustc_infer::infer::InferOk;
 use rustc_infer::traits::PredicateObligations;
-use rustc_middle::bug;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, DerefAdjustKind, OverloadedDeref};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
@@ -63,9 +62,6 @@ pub(crate) fn adjust_steps_as_infer_ok(
                         })
                         .unwrap_or(DerefAdjustKind::Builtin)
                 }
-                AutoderefKind::Pin => {
-                    bug!("Pin autoderef kind should not be present in the steps")
-                }
                 AutoderefKind::Builtin => DerefAdjustKind::Builtin,
             })
             .zip_eq(targets)
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 95eb1cfbea96..2b9974779c56 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -270,21 +270,17 @@ fn coerce(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
             }
             ty::Ref(r_b, _, mutbl_b) => {
                 if self.tcx.features().pin_ergonomics()
-                    && a.pinned_ty().is_some_and(|ty| ty.is_ref())
-                    && let Ok(coerce) = self.commit_if_ok(|_| self.coerce_maybe_pinned_ref(a, b))
+                    && let Ok(pin_coerce) =
+                        self.commit_if_ok(|_| self.coerce_pin_ref_to_ref(a, b, mutbl_b))
                 {
-                    return Ok(coerce);
+                    return Ok(pin_coerce);
                 }
                 return self.coerce_to_ref(a, b, r_b, mutbl_b);
             }
-            ty::Adt(pin, _)
-                if self.tcx.features().pin_ergonomics()
-                    && self.tcx.is_lang_item(pin.did(), hir::LangItem::Pin) =>
+            _ if self.tcx.features().pin_ergonomics()
+                && let Some((_, ty::Pinnedness::Pinned, mut_b, _)) = b.maybe_pinned_ref() =>
             {
-                if a.is_ref() && b.pinned_ty().is_some_and(|ty| ty.is_ref()) {
-                    return self.coerce_maybe_pinned_ref(a, b);
-                }
-                let pin_coerce = self.commit_if_ok(|_| self.coerce_to_pin_ref(a, b));
+                let pin_coerce = self.commit_if_ok(|_| self.coerce_to_pin_ref(a, b, mut_b));
                 if pin_coerce.is_ok() {
                     return pin_coerce;
                 }
@@ -799,116 +795,102 @@ fn coerce_unsized_old_solver(
         Ok(())
     }
 
-    /// Applies reborrowing for `Pin`
+    /// Create an obligation for `ty: Unpin`.
+    fn unpin_obligation(&self, ty: Ty<'tcx>) -> PredicateObligation<'tcx> {
+        let pred = ty::TraitRef::new(
+            self.tcx,
+            self.tcx.require_lang_item(hir::LangItem::Unpin, self.cause.span),
+            [ty],
+        );
+        PredicateObligation::new(self.tcx, self.cause.clone(), self.param_env, pred)
+    }
+
+    /// Coerces from a pinned reference to a normal reference.
+    #[instrument(skip(self), level = "trace")]
+    fn coerce_pin_ref_to_ref(
+        &self,
+        a: Ty<'tcx>,
+        b: Ty<'tcx>,
+        mut_b: hir::Mutability,
+    ) -> CoerceResult<'tcx> {
+        debug_assert!(self.shallow_resolve(a) == a);
+        debug_assert!(self.shallow_resolve(b) == b);
+        debug_assert!(self.tcx.features().pin_ergonomics());
+
+        let Some((a_ty, ty::Pinnedness::Pinned, mut_a, r_a)) = a.maybe_pinned_ref() else {
+            debug!("not fitting pinned ref to ref coercion (`{:?}` -> `{:?}`)", a, b);
+            return Err(TypeError::Mismatch);
+        };
+
+        coerce_mutbls(mut_a, mut_b)?;
+
+        let a = Ty::new_ref(self.tcx, r_a, a_ty, mut_b);
+        let mut coerce = self.unify_and(
+            a,
+            b,
+            [Adjustment { kind: Adjust::Deref(DerefAdjustKind::Pin), target: a_ty }],
+            Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::new(mut_b, self.allow_two_phase))),
+            ForceLeakCheck::No,
+        )?;
+        coerce.obligations.push(self.unpin_obligation(a_ty));
+        Ok(coerce)
+    }
+
+    /// Applies reborrowing and auto-borrowing that results to `Pin<&T>` or `Pin<&mut T>`:
     ///
-    /// We currently only support reborrowing `Pin<&mut T>` as `Pin<&mut T>`. This is accomplished
-    /// by inserting a call to `Pin::as_mut` during MIR building.
+    /// Currently we only support the following coercions:
+    /// - Reborrowing `Pin<&mut T>` -> `Pin<&mut T>`
+    /// - Reborrowing `Pin<&T>` -> `Pin<&T>`
+    /// - Auto-borrowing `&mut T` -> `Pin<&mut T>` where `T: Unpin`
+    /// - Auto-borrowing `&mut T` -> `Pin<&T>` where `T: Unpin`
+    /// - Auto-borrowing `&T` -> `Pin<&T>` where `T: Unpin`
     ///
     /// In the future we might want to support other reborrowing coercions, such as:
-    /// - `Pin<&mut T>` as `Pin<&T>`
-    /// - `Pin<&T>` as `Pin<&T>`
     /// - `Pin<Box<T>>` as `Pin<&T>`
     /// - `Pin<Box<T>>` as `Pin<&mut T>`
     #[instrument(skip(self), level = "trace")]
-    fn coerce_to_pin_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+    fn coerce_to_pin_ref(
+        &self,
+        a: Ty<'tcx>,
+        b: Ty<'tcx>,
+        mut_b: hir::Mutability,
+    ) -> CoerceResult<'tcx> {
         debug_assert!(self.shallow_resolve(a) == a);
         debug_assert!(self.shallow_resolve(b) == b);
+        debug_assert!(self.tcx.features().pin_ergonomics());
 
-        // We need to make sure the two types are compatible for coercion.
-        // Then we will build a ReborrowPin adjustment and return that as an InferOk.
-
-        // Right now we can only reborrow if this is a `Pin<&mut T>`.
-        let extract_pin_mut = |ty: Ty<'tcx>| {
-            // Get the T out of Pin<T>
-            let (pin, ty) = match ty.kind() {
-                ty::Adt(pin, args) if self.tcx.is_lang_item(pin.did(), hir::LangItem::Pin) => {
-                    (*pin, args[0].expect_ty())
-                }
-                _ => {
-                    debug!("can't reborrow {:?} as pinned", ty);
-                    return Err(TypeError::Mismatch);
-                }
-            };
-            // Make sure the T is something we understand (just `&mut U` for now)
-            match ty.kind() {
-                ty::Ref(region, ty, mutbl) => Ok((pin, *region, *ty, *mutbl)),
-                _ => {
-                    debug!("can't reborrow pin of inner type {:?}", ty);
-                    Err(TypeError::Mismatch)
-                }
+        // We need to deref the reference first before we reborrow it to a pinned reference.
+        let (deref, a_ty, mut_a, r_a, unpin_obligation) = match a.maybe_pinned_ref() {
+            // no `Unpin` required when reborrowing a pinned reference to a pinned reference
+            Some((a_ty, ty::Pinnedness::Pinned, mut_a, r_a)) => {
+                (DerefAdjustKind::Pin, a_ty, mut_a, r_a, None)
+            }
+            // `Unpin` required when reborrowing a non-pinned reference to a pinned reference
+            Some((a_ty, ty::Pinnedness::Not, mut_a, r_a)) => {
+                (DerefAdjustKind::Builtin, a_ty, mut_a, r_a, Some(self.unpin_obligation(a_ty)))
+            }
+            None => {
+                debug!("can't reborrow {:?} as pinned", a);
+                return Err(TypeError::Mismatch);
             }
         };
 
-        let (pin, a_region, a_ty, mut_a) = extract_pin_mut(a)?;
-        let (_, _, _b_ty, mut_b) = extract_pin_mut(b)?;
-
         coerce_mutbls(mut_a, mut_b)?;
 
         // update a with b's mutability since we'll be coercing mutability
-        let a = Ty::new_adt(
-            self.tcx,
-            pin,
-            self.tcx.mk_args(&[Ty::new_ref(self.tcx, a_region, a_ty, mut_b).into()]),
-        );
+        let a = Ty::new_pinned_ref(self.tcx, r_a, a_ty, mut_b);
 
         // To complete the reborrow, we need to make sure we can unify the inner types, and if so we
         // add the adjustments.
-        self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b), ForceLeakCheck::No)
-    }
-
-    /// Coerce pinned reference to regular reference or vice versa
-    ///
-    /// - `Pin<&mut T>` <-> `&mut T` when `T: Unpin`
-    /// - `Pin<&T>` <-> `&T` when `T: Unpin`
-    /// - `Pin<&mut T>` <-> `Pin<&T>` when `T: Unpin`
-    #[instrument(skip(self), level = "trace")]
-    fn coerce_maybe_pinned_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
-        let span = self.cause.span;
-        let Some((a_ty, a_pinnedness, a_mutbl, a_region)) = a.maybe_pinned_ref() else {
-            span_bug!(span, "expect pinned reference or reference, found {:?}", a);
-        };
-        let Some((_b_ty, b_pinnedness, b_mutbl, _b_region)) = b.maybe_pinned_ref() else {
-            span_bug!(span, "expect pinned reference or reference, found {:?}", b);
-        };
-        use ty::Pinnedness::*;
-        if a_pinnedness == b_pinnedness {
-            span_bug!(span, "expect different pinnedness, found {:?} and {:?}", a, b);
-        }
-
-        coerce_mutbls(a_mutbl, b_mutbl)?;
-
-        let (deref, borrow) = match (a_pinnedness, b_pinnedness) {
-            (Not, Not) | (Pinned, Pinned) => {
-                span_bug!(span, "expect different pinnedness, found {:?} and {:?}", a, b)
-            }
-            (Pinned, Not) => {
-                let mutbl = AutoBorrowMutability::new(b_mutbl, AllowTwoPhase::Yes);
-                (DerefAdjustKind::Pin, AutoBorrow::Ref(mutbl))
-            }
-            (Not, Pinned) => (DerefAdjustKind::Builtin, AutoBorrow::Pin(b_mutbl)),
-        };
         let mut coerce = self.unify_and(
-            // update a with b's pinnedness and mutability since we'll be coercing pinnedness and mutability
-            match b_pinnedness {
-                Pinned => Ty::new_pinned_ref(self.tcx, a_region, a_ty, b_mutbl),
-                Not => Ty::new_ref(self.tcx, a_region, a_ty, b_mutbl),
-            },
+            a,
             b,
             [Adjustment { kind: Adjust::Deref(deref), target: a_ty }],
-            Adjust::Borrow(borrow),
+            Adjust::Borrow(AutoBorrow::Pin(mut_b)),
             ForceLeakCheck::No,
         )?;
 
-        // Create an obligation for `a_ty: Unpin`.
-        let cause =
-            self.cause(self.cause.span, ObligationCauseCode::Coercion { source: a, target: b });
-        let pred = ty::TraitRef::new(
-            self.tcx,
-            self.tcx.require_lang_item(hir::LangItem::Unpin, self.cause.span),
-            [a_ty],
-        );
-        let obligation = Obligation::new(self.tcx, cause, self.fcx.param_env, pred);
-        coerce.obligations.push(obligation);
+        coerce.obligations.extend(unpin_obligation);
         Ok(coerce)
     }
 
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index 5905e5610f72..b6dfda33142c 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -791,17 +791,7 @@ fn walk_autoref(
                 );
             }
 
-            adjustment::AutoBorrow::RawPtr(m) => {
-                debug!("walk_autoref: expr.hir_id={} base_place={:?}", expr.hir_id, base_place);
-
-                self.delegate.borrow_mut().borrow(
-                    base_place,
-                    base_place.hir_id,
-                    ty::BorrowKind::from_mutbl(m),
-                );
-            }
-
-            adjustment::AutoBorrow::Pin(m) => {
+            adjustment::AutoBorrow::RawPtr(m) | adjustment::AutoBorrow::Pin(m) => {
                 debug!("walk_autoref: expr.hir_id={} base_place={:?}", expr.hir_id, base_place);
 
                 self.delegate.borrow_mut().borrow(
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 2acc58422902..9c22d158154f 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1365,6 +1365,14 @@ pub fn pinned_ty(self) -> Option<Ty<'tcx>> {
         }
     }
 
+    /// Returns the type, pinnedness, mutability, and the region of a reference (`&T` or `&mut T`)
+    /// or a pinned-reference type (`Pin<&T>` or `Pin<&mut T>`).
+    ///
+    /// Regarding the [`pin_ergonomics`] feature, one of the goals is to make pinned references
+    /// (`Pin<&T>` and `Pin<&mut T>`) behaves similar to normal references (`&T` and `&mut T`).
+    /// This function is useful when references and pinned references are processed similarly.
+    ///
+    /// [`pin_ergonomics`]: https://github.com/rust-lang/rust/issues/130494
     pub fn maybe_pinned_ref(
         self,
     ) -> Option<(Ty<'tcx>, ty::Pinnedness, ty::Mutability, Region<'tcx>)> {
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
index ce343fd24a5b..2046af91d69c 100644
--- a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
@@ -21,7 +21,6 @@ LL |     |x: Pin<&mut T>| -> &mut T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `Pin<&mut T>` to `&mut T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -35,7 +34,6 @@ LL |     |x: Pin<&mut T>| -> &T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `Pin<&mut T>` to `&T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -49,7 +47,6 @@ LL |     |x: Pin<&T>| -> &T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `Pin<&T>` to `&T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -93,7 +90,6 @@ LL |     |x: &mut T| -> Pin<&mut T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `&mut T` to `Pin<&mut T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
@@ -107,7 +103,6 @@ LL |     |x: &mut T| -> Pin<&T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `&mut T` to `Pin<&T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
@@ -121,7 +116,6 @@ LL |     |x: &T| -> Pin<&T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
-   = note: required for the cast from `&T` to `Pin<&T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
@@ -131,7 +125,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:52:30
    |
 LL |     |x: &T| -> Pin<&mut T> { x };
-   |                -----------   ^ types differ in mutability
+   |                -----------   ^ expected `Pin<&mut T>`, found `&T`
    |                |
    |                expected `Pin<&mut T>` because of return type
    |
@@ -142,7 +136,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:62:30
    |
 LL |     |x: &U| -> Pin<&mut U> { x };
-   |                -----------   ^ types differ in mutability
+   |                -----------   ^ expected `Pin<&mut U>`, found `&U`
    |                |
    |                expected `Pin<&mut U>` because of return type
    |

From 7be286e5f0812438d6ffd089c1079f77574c7480 Mon Sep 17 00:00:00 2001
From: Frank King <frankking1729@gmail.com>
Date: Sat, 28 Feb 2026 16:37:30 +0800
Subject: [PATCH 0281/1059] Retain the `types differ in mutability` diagnostics

---
 compiler/rustc_hir_typeck/src/coercion.rs     | 110 +++++++++++-------
 .../pin-coercion-check.pin_ergonomics.stderr  |   8 +-
 2 files changed, 74 insertions(+), 44 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 2b9974779c56..5fe5f0b13e54 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -114,6 +114,26 @@ fn success<'tcx>(
     Ok(InferOk { value: (adj, target), obligations })
 }
 
+/// Data extracted from a reference (pinned or not) for coercion to a reference (pinned or not).
+struct CoerceMaybePinnedRef<'tcx> {
+    /// coercion source, must be a pinned (i.e. `Pin<&T>` or `Pin<&mut T>`) or normal reference (`&T` or `&mut T`)
+    a: Ty<'tcx>,
+    /// coercion target, must be a pinned (i.e. `Pin<&T>` or `Pin<&mut T>`) or normal reference (`&T` or `&mut T`)
+    b: Ty<'tcx>,
+    /// referent type of the source
+    a_ty: Ty<'tcx>,
+    /// pinnedness of the source
+    a_pin: ty::Pinnedness,
+    /// mutability of the source
+    a_mut: ty::Mutability,
+    /// region of the source
+    a_r: ty::Region<'tcx>,
+    /// pinnedness of the target
+    b_pin: ty::Pinnedness,
+    /// mutability of the target
+    b_mut: ty::Mutability,
+}
+
 /// Whether to force a leak check to occur in `Coerce::unify_raw`.
 /// Note that leak checks may still occur evn with `ForceLeakCheck::No`.
 ///
@@ -269,21 +289,13 @@ fn coerce(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
                 return self.coerce_to_raw_ptr(a, b, b_mutbl);
             }
             ty::Ref(r_b, _, mutbl_b) => {
-                if self.tcx.features().pin_ergonomics()
-                    && let Ok(pin_coerce) =
-                        self.commit_if_ok(|_| self.coerce_pin_ref_to_ref(a, b, mutbl_b))
-                {
-                    return Ok(pin_coerce);
+                if let Some(pin_ref_to_ref) = self.maybe_pin_ref_to_ref(a, b) {
+                    return self.coerce_pin_ref_to_ref(pin_ref_to_ref);
                 }
                 return self.coerce_to_ref(a, b, r_b, mutbl_b);
             }
-            _ if self.tcx.features().pin_ergonomics()
-                && let Some((_, ty::Pinnedness::Pinned, mut_b, _)) = b.maybe_pinned_ref() =>
-            {
-                let pin_coerce = self.commit_if_ok(|_| self.coerce_to_pin_ref(a, b, mut_b));
-                if pin_coerce.is_ok() {
-                    return pin_coerce;
-                }
+            _ if let Some(to_pin_ref) = self.maybe_to_pin_ref(a, b) => {
+                return self.coerce_to_pin_ref(to_pin_ref);
             }
             _ => {}
         }
@@ -805,37 +817,62 @@ fn unpin_obligation(&self, ty: Ty<'tcx>) -> PredicateObligation<'tcx> {
         PredicateObligation::new(self.tcx, self.cause.clone(), self.param_env, pred)
     }
 
+    /// Checks if the given types are compatible for coercion to a pinned reference.
+    fn maybe_pin_ref_to_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> Option<CoerceMaybePinnedRef<'tcx>> {
+        if !self.tcx.features().pin_ergonomics() {
+            return None;
+        }
+        if let Some((a_ty, a_pin @ ty::Pinnedness::Pinned, a_mut, a_r)) = a.maybe_pinned_ref()
+            && let Some((_, b_pin @ ty::Pinnedness::Not, b_mut, _)) = b.maybe_pinned_ref()
+        {
+            return Some(CoerceMaybePinnedRef { a, b, a_ty, a_pin, a_mut, a_r, b_pin, b_mut });
+        }
+        debug!("not fitting pinned ref to ref coercion (`{:?}` -> `{:?}`)", a, b);
+        None
+    }
+
     /// Coerces from a pinned reference to a normal reference.
     #[instrument(skip(self), level = "trace")]
     fn coerce_pin_ref_to_ref(
         &self,
-        a: Ty<'tcx>,
-        b: Ty<'tcx>,
-        mut_b: hir::Mutability,
+        CoerceMaybePinnedRef { a, b, a_ty, a_pin, a_mut, a_r, b_pin, b_mut }: CoerceMaybePinnedRef<
+            'tcx,
+        >,
     ) -> CoerceResult<'tcx> {
         debug_assert!(self.shallow_resolve(a) == a);
         debug_assert!(self.shallow_resolve(b) == b);
         debug_assert!(self.tcx.features().pin_ergonomics());
+        debug_assert_eq!(a_pin, ty::Pinnedness::Pinned);
+        debug_assert_eq!(b_pin, ty::Pinnedness::Not);
 
-        let Some((a_ty, ty::Pinnedness::Pinned, mut_a, r_a)) = a.maybe_pinned_ref() else {
-            debug!("not fitting pinned ref to ref coercion (`{:?}` -> `{:?}`)", a, b);
-            return Err(TypeError::Mismatch);
-        };
+        coerce_mutbls(a_mut, b_mut)?;
 
-        coerce_mutbls(mut_a, mut_b)?;
-
-        let a = Ty::new_ref(self.tcx, r_a, a_ty, mut_b);
+        let a = Ty::new_ref(self.tcx, a_r, a_ty, b_mut);
         let mut coerce = self.unify_and(
             a,
             b,
             [Adjustment { kind: Adjust::Deref(DerefAdjustKind::Pin), target: a_ty }],
-            Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::new(mut_b, self.allow_two_phase))),
+            Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::new(b_mut, self.allow_two_phase))),
             ForceLeakCheck::No,
         )?;
         coerce.obligations.push(self.unpin_obligation(a_ty));
         Ok(coerce)
     }
 
+    /// Checks if the given types are compatible for coercion to a pinned reference.
+    fn maybe_to_pin_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> Option<CoerceMaybePinnedRef<'tcx>> {
+        if !self.tcx.features().pin_ergonomics() {
+            return None;
+        }
+        if let Some((a_ty, a_pin, a_mut, a_r)) = a.maybe_pinned_ref()
+            && let Some((_, b_pin @ ty::Pinnedness::Pinned, b_mut, _)) = b.maybe_pinned_ref()
+        {
+            return Some(CoerceMaybePinnedRef { a, b, a_ty, a_pin, a_mut, a_r, b_pin, b_mut });
+        }
+        debug!("not fitting ref to pinned ref coercion (`{:?}` -> `{:?}`)", a, b);
+        None
+    }
+
     /// Applies reborrowing and auto-borrowing that results to `Pin<&T>` or `Pin<&mut T>`:
     ///
     /// Currently we only support the following coercions:
@@ -851,34 +888,27 @@ fn coerce_pin_ref_to_ref(
     #[instrument(skip(self), level = "trace")]
     fn coerce_to_pin_ref(
         &self,
-        a: Ty<'tcx>,
-        b: Ty<'tcx>,
-        mut_b: hir::Mutability,
+        CoerceMaybePinnedRef { a, b, a_ty, a_pin, a_mut, a_r, b_pin, b_mut }: CoerceMaybePinnedRef<
+            'tcx,
+        >,
     ) -> CoerceResult<'tcx> {
         debug_assert!(self.shallow_resolve(a) == a);
         debug_assert!(self.shallow_resolve(b) == b);
         debug_assert!(self.tcx.features().pin_ergonomics());
+        debug_assert_eq!(b_pin, ty::Pinnedness::Pinned);
 
         // We need to deref the reference first before we reborrow it to a pinned reference.
-        let (deref, a_ty, mut_a, r_a, unpin_obligation) = match a.maybe_pinned_ref() {
+        let (deref, unpin_obligation) = match a_pin {
             // no `Unpin` required when reborrowing a pinned reference to a pinned reference
-            Some((a_ty, ty::Pinnedness::Pinned, mut_a, r_a)) => {
-                (DerefAdjustKind::Pin, a_ty, mut_a, r_a, None)
-            }
+            ty::Pinnedness::Pinned => (DerefAdjustKind::Pin, None),
             // `Unpin` required when reborrowing a non-pinned reference to a pinned reference
-            Some((a_ty, ty::Pinnedness::Not, mut_a, r_a)) => {
-                (DerefAdjustKind::Builtin, a_ty, mut_a, r_a, Some(self.unpin_obligation(a_ty)))
-            }
-            None => {
-                debug!("can't reborrow {:?} as pinned", a);
-                return Err(TypeError::Mismatch);
-            }
+            ty::Pinnedness::Not => (DerefAdjustKind::Builtin, Some(self.unpin_obligation(a_ty))),
         };
 
-        coerce_mutbls(mut_a, mut_b)?;
+        coerce_mutbls(a_mut, b_mut)?;
 
         // update a with b's mutability since we'll be coercing mutability
-        let a = Ty::new_pinned_ref(self.tcx, r_a, a_ty, mut_b);
+        let a = Ty::new_pinned_ref(self.tcx, a_r, a_ty, b_mut);
 
         // To complete the reborrow, we need to make sure we can unify the inner types, and if so we
         // add the adjustments.
@@ -886,7 +916,7 @@ fn coerce_to_pin_ref(
             a,
             b,
             [Adjustment { kind: Adjust::Deref(deref), target: a_ty }],
-            Adjust::Borrow(AutoBorrow::Pin(mut_b)),
+            Adjust::Borrow(AutoBorrow::Pin(b_mut)),
             ForceLeakCheck::No,
         )?;
 
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
index 2046af91d69c..d0558b6bf2fd 100644
--- a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
@@ -56,7 +56,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:27:30
    |
 LL |     |x: Pin<&T>| -> &mut T { x };
-   |                     ------   ^ expected `&mut T`, found `Pin<&T>`
+   |                     ------   ^ types differ in mutability
    |                     |
    |                     expected `&mut T` because of return type
    |
@@ -71,7 +71,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:37:30
    |
 LL |     |x: Pin<&U>| -> &mut U { x };
-   |                     ------   ^ expected `&mut U`, found `Pin<&U>`
+   |                     ------   ^ types differ in mutability
    |                     |
    |                     expected `&mut U` because of return type
    |
@@ -125,7 +125,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:52:30
    |
 LL |     |x: &T| -> Pin<&mut T> { x };
-   |                -----------   ^ expected `Pin<&mut T>`, found `&T`
+   |                -----------   ^ types differ in mutability
    |                |
    |                expected `Pin<&mut T>` because of return type
    |
@@ -136,7 +136,7 @@ error[E0308]: mismatched types
   --> $DIR/pin-coercion-check.rs:62:30
    |
 LL |     |x: &U| -> Pin<&mut U> { x };
-   |                -----------   ^ expected `Pin<&mut U>`, found `&U`
+   |                -----------   ^ types differ in mutability
    |                |
    |                expected `Pin<&mut U>` because of return type
    |

From d38c8c0ef5fde3d0525310e2337ba1adef49a6b7 Mon Sep 17 00:00:00 2001
From: Frank King <frankking1729@gmail.com>
Date: Mon, 2 Mar 2026 15:25:14 +0800
Subject: [PATCH 0282/1059] Add  `ObligationCauseCode::Coercion` to the `Unpin`
 obligation

---
 compiler/rustc_hir_typeck/src/coercion.rs     | 22 ++++++++++++++-----
 .../pin-coercion-check.pin_ergonomics.stderr  |  6 +++++
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 5fe5f0b13e54..bfc677046e0f 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -807,17 +807,23 @@ fn coerce_unsized_old_solver(
         Ok(())
     }
 
-    /// Create an obligation for `ty: Unpin`.
-    fn unpin_obligation(&self, ty: Ty<'tcx>) -> PredicateObligation<'tcx> {
+    /// Create an obligation for `ty: Unpin`, where .
+    fn unpin_obligation(
+        &self,
+        source: Ty<'tcx>,
+        target: Ty<'tcx>,
+        ty: Ty<'tcx>,
+    ) -> PredicateObligation<'tcx> {
         let pred = ty::TraitRef::new(
             self.tcx,
             self.tcx.require_lang_item(hir::LangItem::Unpin, self.cause.span),
             [ty],
         );
-        PredicateObligation::new(self.tcx, self.cause.clone(), self.param_env, pred)
+        let cause = self.cause(self.cause.span, ObligationCauseCode::Coercion { source, target });
+        PredicateObligation::new(self.tcx, cause, self.param_env, pred)
     }
 
-    /// Checks if the given types are compatible for coercion to a pinned reference.
+    /// Checks if the given types are compatible for coercion from a pinned reference to a normal reference.
     fn maybe_pin_ref_to_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> Option<CoerceMaybePinnedRef<'tcx>> {
         if !self.tcx.features().pin_ergonomics() {
             return None;
@@ -847,6 +853,8 @@ fn coerce_pin_ref_to_ref(
 
         coerce_mutbls(a_mut, b_mut)?;
 
+        let unpin_obligation = self.unpin_obligation(a, b, a_ty);
+
         let a = Ty::new_ref(self.tcx, a_r, a_ty, b_mut);
         let mut coerce = self.unify_and(
             a,
@@ -855,7 +863,7 @@ fn coerce_pin_ref_to_ref(
             Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::new(b_mut, self.allow_two_phase))),
             ForceLeakCheck::No,
         )?;
-        coerce.obligations.push(self.unpin_obligation(a_ty));
+        coerce.obligations.push(unpin_obligation);
         Ok(coerce)
     }
 
@@ -902,7 +910,9 @@ fn coerce_to_pin_ref(
             // no `Unpin` required when reborrowing a pinned reference to a pinned reference
             ty::Pinnedness::Pinned => (DerefAdjustKind::Pin, None),
             // `Unpin` required when reborrowing a non-pinned reference to a pinned reference
-            ty::Pinnedness::Not => (DerefAdjustKind::Builtin, Some(self.unpin_obligation(a_ty))),
+            ty::Pinnedness::Not => {
+                (DerefAdjustKind::Builtin, Some(self.unpin_obligation(a, b, a_ty)))
+            }
         };
 
         coerce_mutbls(a_mut, b_mut)?;
diff --git a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
index d0558b6bf2fd..3dc59cecb3c1 100644
--- a/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
+++ b/tests/ui/pin-ergonomics/pin-coercion-check.pin_ergonomics.stderr
@@ -21,6 +21,7 @@ LL |     |x: Pin<&mut T>| -> &mut T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&mut T>` to `&mut T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -34,6 +35,7 @@ LL |     |x: Pin<&mut T>| -> &T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&mut T>` to `&T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -47,6 +49,7 @@ LL |     |x: Pin<&T>| -> &T { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `Pin<&T>` to `&T`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn pin_to_ref<T: std::marker::Unpin, U: Unpin>() {
@@ -90,6 +93,7 @@ LL |     |x: &mut T| -> Pin<&mut T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&mut T` to `Pin<&mut T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
@@ -103,6 +107,7 @@ LL |     |x: &mut T| -> Pin<&T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&mut T` to `Pin<&T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {
@@ -116,6 +121,7 @@ LL |     |x: &T| -> Pin<&T> { x };
    |
    = note: consider using the `pin!` macro
            consider using `Box::pin` if you need to access the pinned value outside of the current scope
+   = note: required for the cast from `&T` to `Pin<&T>`
 help: consider restricting type parameter `T` with trait `Unpin`
    |
 LL | fn ref_to_pin<T: std::marker::Unpin, U: Unpin>() {

From db1060e5bbf07a1203a31f9d87474dd3d3ff1e5e Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Tue, 10 Mar 2026 18:32:20 +0900
Subject: [PATCH 0283/1059] use `#![expect(incomplete_features)]`

---
 .../inherent-assoc-ty-mismatch-issue-153539.rs        |  2 +-
 .../inherent-assoc-ty-mismatch-issue-153539.stderr    | 11 +----------
 2 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
index 019765a1909f..960e19c21a2c 100644
--- a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
+++ b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Znext-solver=globally
 #![feature(inherent_associated_types)]
-//~^ WARN the feature `inherent_associated_types` is incomplete
+#![expect(incomplete_features)]
 
 // Regression test for https://github.com/rust-lang/rust/issues/153539:
 
diff --git a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr
index 66ca01e845f3..74d88889223f 100644
--- a/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr
+++ b/tests/ui/associated-inherent-types/inherent-assoc-ty-mismatch-issue-153539.stderr
@@ -1,12 +1,3 @@
-warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/inherent-assoc-ty-mismatch-issue-153539.rs:2:12
-   |
-LL | #![feature(inherent_associated_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0207]: the type parameter `X` is not constrained by the impl trait, self type, or predicates
   --> $DIR/inherent-assoc-ty-mismatch-issue-153539.rs:9:6
    |
@@ -25,7 +16,7 @@ LL |     f(&1)
    = help: consider constraining the associated type `S<'_>::P` to `&'e i32`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0207, E0308.
 For more information about an error, try `rustc --explain E0207`.

From fb65707d325d5f44fd72908c41206973453ed0f4 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 6 Mar 2026 11:42:10 +0000
Subject: [PATCH 0284/1059] Move freeze_* methods to OpenOptionsExt2

---
 library/std/src/os/windows/fs.rs | 35 +++++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/library/std/src/os/windows/fs.rs b/library/std/src/os/windows/fs.rs
index 73f3e589e243..7fd46b31f7d8 100644
--- a/library/std/src/os/windows/fs.rs
+++ b/library/std/src/os/windows/fs.rs
@@ -138,6 +138,8 @@ fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
 }
 
 /// Windows-specific extensions to [`fs::OpenOptions`].
+// WARNING: This trait is not sealed. DON'T add any new methods!
+// Add them to OpenOptionsExt2 instead.
 #[stable(feature = "open_options_ext", since = "1.10.0")]
 pub trait OpenOptionsExt {
     /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]
@@ -305,18 +307,6 @@ pub trait OpenOptionsExt {
     ///     https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
     #[stable(feature = "open_options_ext", since = "1.10.0")]
     fn security_qos_flags(&mut self, flags: u32) -> &mut Self;
-
-    /// If set to `true`, prevent the "last access time" of the file from being changed.
-    ///
-    /// Default to `false`.
-    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
-    fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self;
-
-    /// If set to `true`, prevent the "last write time" of the file from being changed.
-    ///
-    /// Default to `false`.
-    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
-    fn freeze_last_write_time(&mut self, freeze: bool) -> &mut Self;
 }
 
 #[stable(feature = "open_options_ext", since = "1.10.0")]
@@ -345,7 +335,28 @@ fn security_qos_flags(&mut self, flags: u32) -> &mut OpenOptions {
         self.as_inner_mut().security_qos_flags(flags);
         self
     }
+}
 
+#[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+pub trait OpenOptionsExt2: Sealed {
+    /// If set to `true`, prevent the "last access time" of the file from being changed.
+    ///
+    /// Default to `false`.
+    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+    fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self;
+
+    /// If set to `true`, prevent the "last write time" of the file from being changed.
+    ///
+    /// Default to `false`.
+    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+    fn freeze_last_write_time(&mut self, freeze: bool) -> &mut Self;
+}
+
+#[unstable(feature = "sealed", issue = "none")]
+impl Sealed for OpenOptions {}
+
+#[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+impl OpenOptionsExt2 for OpenOptions {
     fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self {
         self.as_inner_mut().freeze_last_access_time(freeze);
         self

From f1f0b4504a6303da44205548c2747ad346287bfc Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 20:42:31 -0500
Subject: [PATCH 0285/1059] downgrade duplicate features from hard-error ->
 deny-by-default

---
 .../src/error_codes/E0636.md                  |  4 ++-
 compiler/rustc_lint_defs/src/builtin.rs       | 28 +++++++++++++++++++
 compiler/rustc_passes/src/errors.rs           | 14 ++++------
 compiler/rustc_passes/src/stability.rs        | 13 +++++++--
 .../feature-gates/duplicate-features.stderr   |  7 +++--
 5 files changed, 52 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0636.md b/compiler/rustc_error_codes/src/error_codes/E0636.md
index 41fd701a8ede..18e5af6f87e1 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0636.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0636.md
@@ -1,8 +1,10 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The same feature is enabled multiple times with `#![feature]` attributes
 
 Erroneous code example:
 
-```compile_fail,E0636
+```compile_fail
 #![allow(stable_features)]
 #![feature(rust1)]
 #![feature(rust1)] // error: the feature `rust1` has already been enabled
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 38ffecbafa06..cdd8f3f42c3f 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -39,6 +39,7 @@
         DEPRECATED_IN_FUTURE,
         DEPRECATED_SAFE_2024,
         DEPRECATED_WHERE_CLAUSE_LOCATION,
+        DUPLICATE_FEATURES,
         DUPLICATE_MACRO_ATTRIBUTES,
         ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
         ELIDED_LIFETIMES_IN_PATHS,
@@ -1093,6 +1094,33 @@
     "unused features found in crate-level `#[feature]` directives"
 }
 
+declare_lint! {
+    /// The `duplicate_features` lint detects duplicate features found in
+    /// crate-level [`feature` attributes].
+    ///
+    /// Note: This lint used to be a hard error (E0636).
+    ///
+    /// [`feature` attributes]: https://doc.rust-lang.org/nightly/unstable-book/
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// # #![allow(internal_features)]
+    /// #![feature(rustc_attrs)]
+    /// #![feature(rustc_attrs)]
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Enabling a feature more than once is a no-op.
+    /// To avoid this warning, remove the second `feature()` attribute.
+    pub DUPLICATE_FEATURES,
+    Deny,
+    "duplicate features found in crate-level `#[feature]` directives"
+}
+
 declare_lint! {
     /// The `stable_features` lint detects a [`feature` attribute] that
     /// has since been made stable.
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 7c7698ac3bb8..228f21c81b94 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -987,14 +987,6 @@ pub(crate) struct ImpliedFeatureNotExist {
     pub implied_by: Symbol,
 }
 
-#[derive(Diagnostic)]
-#[diag("the feature `{$feature}` has already been enabled", code = E0636)]
-pub(crate) struct DuplicateFeatureErr {
-    #[primary_span]
-    pub span: Span,
-    pub feature: Symbol,
-}
-
 #[derive(Diagnostic)]
 #[diag(
     "attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`"
@@ -1144,6 +1136,12 @@ pub(crate) struct ProcMacroBadSig {
     pub kind: ProcMacroKind,
 }
 
+#[derive(Diagnostic)]
+#[diag("the feature `{$feature}` has already been enabled")]
+pub(crate) struct DuplicateFeature {
+    pub feature: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(
     "the feature `{$feature}` has been stable since {$since} and no longer requires an attribute to enable"
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index ec6d48cbea2e..5b53cf1fa217 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -969,7 +969,7 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
         }
         if !lang_features.insert(gate_name) {
             // Warn if the user enables a lang feature multiple times.
-            tcx.dcx().emit_err(errors::DuplicateFeatureErr { span: *attr_sp, feature: *gate_name });
+            duplicate_feature_lint(tcx, *attr_sp, *gate_name);
         }
     }
 
@@ -978,7 +978,7 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
     for EnabledLibFeature { gate_name, attr_sp } in enabled_lib_features {
         if remaining_lib_features.contains_key(gate_name) {
             // Warn if the user enables a lib feature multiple times.
-            tcx.dcx().emit_err(errors::DuplicateFeatureErr { span: *attr_sp, feature: *gate_name });
+            duplicate_feature_lint(tcx, *attr_sp, *gate_name);
         }
         remaining_lib_features.insert(*gate_name, *attr_sp);
     }
@@ -1160,3 +1160,12 @@ fn unnecessary_stable_feature_lint(
         errors::UnnecessaryStableFeature { feature, since },
     );
 }
+
+fn duplicate_feature_lint(tcx: TyCtxt<'_>, span: Span, feature: Symbol) {
+    tcx.emit_node_span_lint(
+        lint::builtin::DUPLICATE_FEATURES,
+        hir::CRATE_HIR_ID,
+        span,
+        errors::DuplicateFeature { feature },
+    );
+}
diff --git a/tests/ui/feature-gates/duplicate-features.stderr b/tests/ui/feature-gates/duplicate-features.stderr
index f667a5b9623f..81a9eeb9650c 100644
--- a/tests/ui/feature-gates/duplicate-features.stderr
+++ b/tests/ui/feature-gates/duplicate-features.stderr
@@ -1,10 +1,12 @@
-error[E0636]: the feature `if_let` has already been enabled
+error: the feature `if_let` has already been enabled
   --> $DIR/duplicate-features.rs:7:12
    |
 LL | #![feature(if_let)]
    |            ^^^^^^
+   |
+   = note: `#[deny(duplicate_features)]` on by default
 
-error[E0636]: the feature `rust1` has already been enabled
+error: the feature `rust1` has already been enabled
   --> $DIR/duplicate-features.rs:4:12
    |
 LL | #![feature(rust1)]
@@ -12,4 +14,3 @@ LL | #![feature(rust1)]
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0636`.

From efe2e6c6c6cf3b66b3a97f581e3e3b71ece0d540 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 20:43:14 -0500
Subject: [PATCH 0286/1059] rustdoc moves `incomplete_features` attr up to the
 top level

---
 compiler/rustc_span/src/symbol.rs | 1 +
 src/librustdoc/doctest/make.rs    | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 257ac3f51c2c..48cdf46b821f 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1073,6 +1073,7 @@
         include_bytes,
         include_str,
         inclusive_range_syntax,
+        incomplete_features,
         index,
         index_mut,
         infer_outlives_requirements,
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index a77efaaed8d5..7dd738abca43 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -555,7 +555,10 @@ fn check_item(item: &ast::Item, info: &mut ParseSourceInfo, crate_name: &Option<
                     // consider it only as a crate-level attribute.
                     if attr.has_name(sym::allow)
                         && let Some(list) = attr.meta_item_list()
-                        && list.iter().any(|sub_attr| sub_attr.has_name(sym::internal_features))
+                        && list.iter().any(|sub_attr| {
+                            sub_attr.has_name(sym::internal_features)
+                                || sub_attr.has_name(sym::incomplete_features)
+                        })
                     {
                         push_to_s(&mut info.crate_attrs, source, attr.span, &mut prev_span_hi);
                     } else {

From acba81e6891d0bef49c3646e2ca68ffd04343e68 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 20:44:11 -0500
Subject: [PATCH 0287/1059] core doctests support panic=abort

---
 library/core/src/intrinsics/mir.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index 939298268c93..7659e0042b37 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -62,7 +62,9 @@
 //!
 //! # Examples
 //!
-//! ```rust
+#![cfg_attr(panic = "unwind", doc = "```rust")]
+// This test can't support panic=abort because it generates an UnwindContinue MIR terminator.
+#![cfg_attr(panic = "abort", doc = "```ignore")]
 //! #![feature(core_intrinsics, custom_mir)]
 //! #![allow(internal_features)]
 //! #![allow(unused_assignments)]

From 505d07da2859fa3fd2fde699be62e8adbbcb45cc Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 20:44:38 -0500
Subject: [PATCH 0288/1059] core and alloc doctests support doctest merging

---
 library/alloc/src/lib.rs         | 2 +-
 library/core/src/alloc/global.rs | 2 +-
 library/core/src/hint.rs         | 2 +-
 library/core/src/lib.rs          | 2 +-
 library/core/src/range.rs        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 73e93657b02f..7ac9cdc3833d 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -63,7 +63,7 @@
 #![doc(
     html_playground_url = "https://play.rust-lang.org/",
     issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
-    test(no_crate_inject, attr(allow(unused_variables), deny(warnings)))
+    test(no_crate_inject, attr(allow(unused_variables, duplicate_features), deny(warnings)))
 )]
 #![doc(auto_cfg(hide(no_global_oom_handling, no_rc, no_sync, target_has_atomic = "ptr")))]
 #![doc(rust_logo)]
diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs
index bf3d3e0a5aca..e97398aa5dc4 100644
--- a/library/core/src/alloc/global.rs
+++ b/library/core/src/alloc/global.rs
@@ -19,7 +19,7 @@
 ///
 /// # Example
 ///
-/// ```
+/// ```standalone_crate
 /// use std::alloc::{GlobalAlloc, Layout};
 /// use std::cell::UnsafeCell;
 /// use std::ptr::null_mut;
diff --git a/library/core/src/hint.rs b/library/core/src/hint.rs
index 03ed04dc5a66..a8e01e6e78b4 100644
--- a/library/core/src/hint.rs
+++ b/library/core/src/hint.rs
@@ -514,7 +514,7 @@ pub const fn black_box<T>(dummy: T) -> T {
 /// macro_rules! make_error {
 ///     ($($args:expr),*) => {
 ///         core::hint::must_use({
-///             let error = $crate::make_error(core::format_args!($($args),*));
+///             let error = make_error(core::format_args!($($args),*));
 ///             error
 ///         })
 ///     };
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 29869dd91982..e12c43068245 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -48,7 +48,7 @@
     html_playground_url = "https://play.rust-lang.org/",
     issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
     test(no_crate_inject, attr(deny(warnings))),
-    test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
+    test(attr(allow(dead_code, deprecated, unused_variables, unused_mut, duplicate_features)))
 )]
 #![doc(rust_logo)]
 #![doc(auto_cfg(hide(
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index d12a4ef43e49..3c2c40d49200 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -584,7 +584,7 @@ fn from(value: legacy::RangeFrom<T>) -> Self {
 ///
 /// The `..=last` syntax is a `RangeToInclusive`:
 ///
-/// ```
+/// ```standalone_crate
 /// #![feature(new_range)]
 /// assert_eq!((..=5), std::range::RangeToInclusive { last: 5 });
 /// ```

From 9d6407799fd0addc429b84ed60fa562a164f34f4 Mon Sep 17 00:00:00 2001
From: Urhengulas <johann.hemmann@ferrous-systems.com>
Date: Thu, 26 Feb 2026 13:17:10 +0100
Subject: [PATCH 0289/1059] Allow running unit/integration tests without doc
 tests and benches

---
 src/bootstrap/src/core/build_steps/test.rs | 44 ++++++++++------------
 src/bootstrap/src/core/config/flags.rs     | 43 ++++++++++++---------
 src/bootstrap/src/lib.rs                   | 24 ++++++++----
 3 files changed, 61 insertions(+), 50 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 71353397b207..d13036250225 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -41,7 +41,7 @@
     linker_args, linker_flags, t, target_supports_cranelift_backend, up_to_date,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
-use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, envify};
+use crate::{CLang, CodegenBackendKind, GitRepo, Mode, PathSet, TestTarget, envify};
 
 mod compiletest;
 
@@ -174,7 +174,7 @@ fn run(self, builder: &Builder<'_>) {
         );
         run_cargo_test(cargo, &[], &[], "linkchecker self tests", bootstrap_host, builder);
 
-        if builder.doc_tests == DocTests::No {
+        if !builder.test_target.runs_doctests() {
             return;
         }
 
@@ -807,15 +807,14 @@ fn run(self, builder: &Builder<'_>) {
 
         // We're not using `prepare_cargo_test` so we have to do this ourselves.
         // (We're not using that as the test-cargo-miri crate is not known to bootstrap.)
-        match builder.doc_tests {
-            DocTests::Yes => {}
-            DocTests::No => {
-                cargo.args(["--lib", "--bins", "--examples", "--tests", "--benches"]);
+        match builder.test_target {
+            TestTarget::AllTargets => {
+                cargo.args(["--lib", "--bins", "--examples", "--tests", "--benches"])
             }
-            DocTests::Only => {
-                cargo.arg("--doc");
-            }
-        }
+            TestTarget::Default => &mut cargo,
+            TestTarget::DocOnly => cargo.arg("--doc"),
+            TestTarget::Tests => cargo.arg("--tests"),
+        };
         cargo.arg("--").args(builder.config.test_args());
 
         // Finally, run everything.
@@ -1193,7 +1192,7 @@ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 
     fn is_default_step(builder: &Builder<'_>) -> bool {
         builder.config.nodejs.is_some()
-            && builder.doc_tests != DocTests::Only
+            && builder.test_target != TestTarget::DocOnly
             && get_browser_ui_test_version(builder).is_some()
     }
 
@@ -1283,7 +1282,7 @@ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
     }
 
     fn is_default_step(builder: &Builder<'_>) -> bool {
-        builder.doc_tests != DocTests::Only
+        builder.test_target != TestTarget::DocOnly
     }
 
     fn make_run(run: RunConfig<'_>) {
@@ -1839,7 +1838,7 @@ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
     }
 
     fn run(self, builder: &Builder<'_>) {
-        if builder.doc_tests == DocTests::Only {
+        if builder.test_target == TestTarget::DocOnly {
             return;
         }
 
@@ -2957,15 +2956,12 @@ fn prepare_cargo_test(
         cargo.arg("--message-format=json");
     }
 
-    match builder.doc_tests {
-        DocTests::Only => {
-            cargo.arg("--doc");
-        }
-        DocTests::No => {
-            cargo.args(["--bins", "--examples", "--tests", "--benches"]);
-        }
-        DocTests::Yes => {}
-    }
+    match builder.test_target {
+        TestTarget::AllTargets => cargo.args(["--bins", "--examples", "--tests", "--benches"]),
+        TestTarget::Default => &mut cargo,
+        TestTarget::DocOnly => cargo.arg("--doc"),
+        TestTarget::Tests => cargo.arg("--tests"),
+    };
 
     for krate in crates {
         cargo.arg("-p").arg(krate);
@@ -3834,7 +3830,7 @@ fn make_run(run: RunConfig<'_>) {
         let host = run.build_triple();
         let compilers = RustcPrivateCompilers::new(run.builder, run.builder.top_stage, host);
 
-        if builder.doc_tests == DocTests::Only {
+        if builder.test_target == TestTarget::DocOnly {
             return;
         }
 
@@ -3955,7 +3951,7 @@ fn make_run(run: RunConfig<'_>) {
         let host = run.build_triple();
         let compilers = RustcPrivateCompilers::new(run.builder, run.builder.top_stage, host);
 
-        if builder.doc_tests == DocTests::Only {
+        if builder.test_target == TestTarget::DocOnly {
             return;
         }
 
diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index bf089d25ffec..c86f0de7551c 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -15,7 +15,7 @@
 use crate::core::builder::{Builder, Kind};
 use crate::core::config::Config;
 use crate::core::config::target_selection::{TargetSelectionList, target_selection_list};
-use crate::{Build, CodegenBackendKind, DocTests};
+use crate::{Build, CodegenBackendKind, TestTarget};
 
 #[derive(Copy, Clone, Default, Debug, ValueEnum)]
 pub enum Color {
@@ -357,7 +357,7 @@ pub enum Subcommand {
         should be compiled and run. For example:
             ./x.py test tests/ui
             ./x.py test library/std --test-args hash_map
-            ./x.py test library/std --stage 0 --no-doc
+            ./x.py test library/std --stage 0 --all-targets
             ./x.py test tests/ui --bless
             ./x.py test tests/ui --compare-mode next-solver
         Note that `test tests/* --stage N` does NOT depend on `build compiler/rustc --stage N`;
@@ -382,11 +382,14 @@ pub enum Subcommand {
         #[arg(long, value_name = "ARGS", allow_hyphen_values(true))]
         compiletest_rustc_args: Vec<String>,
         #[arg(long)]
-        /// do not run doc tests
-        no_doc: bool,
+        /// Run all test targets (no doc tests)
+        all_targets: bool,
         #[arg(long)]
-        /// only run doc tests
+        /// Only run doc tests
         doc: bool,
+        /// Only run unit and integration tests
+        #[arg(long)]
+        tests: bool,
         #[arg(long)]
         /// whether to automatically update stderr/stdout files
         bless: bool,
@@ -436,11 +439,14 @@ pub enum Subcommand {
         /// (e.g. libtest, compiletest or rustdoc)
         test_args: Vec<String>,
         #[arg(long)]
-        /// do not run doc tests
-        no_doc: bool,
+        /// Run all test targets (no doc tests)
+        all_targets: bool,
         #[arg(long)]
-        /// only run doc tests
+        /// Only run doc tests
         doc: bool,
+        /// Only run unit and integration tests
+        #[arg(long)]
+        tests: bool,
     },
     /// Build and run some benchmarks
     Bench {
@@ -552,18 +558,19 @@ pub fn fail_fast(&self) -> bool {
         }
     }
 
-    pub fn doc_tests(&self) -> DocTests {
+    pub fn test_target(&self) -> TestTarget {
         match *self {
-            Subcommand::Test { doc, no_doc, .. } | Subcommand::Miri { no_doc, doc, .. } => {
-                if doc {
-                    DocTests::Only
-                } else if no_doc {
-                    DocTests::No
-                } else {
-                    DocTests::Yes
+            Subcommand::Test { all_targets, doc, tests, .. }
+            | Subcommand::Miri { all_targets, doc, tests, .. } => match (all_targets, doc, tests) {
+                (true, true, _) | (true, _, true) | (_, true, true) => {
+                    panic!("You can only set one of `--all-targets`, `--doc` and `--tests`.")
                 }
-            }
-            _ => DocTests::Yes,
+                (true, false, false) => TestTarget::AllTargets,
+                (false, true, false) => TestTarget::DocOnly,
+                (false, false, true) => TestTarget::Tests,
+                (false, false, false) => TestTarget::Default,
+            },
+            _ => TestTarget::Default,
         }
     }
 
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index b9a914f53cec..f1303814f6d7 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -177,13 +177,21 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
 }
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-pub enum DocTests {
-    /// Run normal tests and doc tests (default).
-    Yes,
-    /// Do not run any doc tests.
-    No,
+pub enum TestTarget {
+    /// Run unit, integration and doc tests (default).
+    Default,
+    /// Run unit, integration, doc tests, examples, bins, benchmarks (no doc tests).
+    AllTargets,
     /// Only run doc tests.
-    Only,
+    DocOnly,
+    /// Only run unit and integration tests.
+    Tests,
+}
+
+impl TestTarget {
+    fn runs_doctests(&self) -> bool {
+        matches!(self, TestTarget::DocOnly | TestTarget::Default)
+    }
 }
 
 pub enum GitRepo {
@@ -222,7 +230,7 @@ pub struct Build {
     in_tree_gcc_info: GitInfo,
     local_rebuild: bool,
     fail_fast: bool,
-    doc_tests: DocTests,
+    test_target: TestTarget,
     verbosity: usize,
 
     /// Build triple for the pre-compiled snapshot compiler.
@@ -540,7 +548,7 @@ pub fn new(mut config: Config) -> Build {
             initial_sysroot: config.initial_sysroot.clone(),
             local_rebuild: config.local_rebuild,
             fail_fast: config.cmd.fail_fast(),
-            doc_tests: config.cmd.doc_tests(),
+            test_target: config.cmd.test_target(),
             verbosity: config.exec_ctx.verbosity as usize,
 
             host_target: config.host_target,

From 2a2cafa722f6c7b57ff2ca1b0a57bb56bf3d07fa Mon Sep 17 00:00:00 2001
From: Urhengulas <johann.hemmann@ferrous-systems.com>
Date: Thu, 26 Feb 2026 16:26:34 +0100
Subject: [PATCH 0290/1059] Reflect removal of `--no-doc` in documentation

- `./x run generate-completions`
- Search and replace `--no-doc` with `--all-targets`
  This is to keep the behaviour the same.
- Document `./x test --tests` in `rustc-dev-guide`
- Add change info
---
 library/alloctests/benches/vec_deque_append.rs |  2 +-
 src/bootstrap/mk/Makefile.in                   |  2 +-
 src/bootstrap/src/utils/change_tracker.rs      |  7 ++++++-
 src/doc/rustc-dev-guide/src/tests/intro.md     |  3 ++-
 src/etc/completions/x.fish                     | 10 ++++++----
 src/etc/completions/x.ps1                      | 10 ++++++----
 src/etc/completions/x.py.fish                  | 10 ++++++----
 src/etc/completions/x.py.ps1                   | 10 ++++++----
 src/etc/completions/x.py.sh                    |  4 ++--
 src/etc/completions/x.py.zsh                   | 10 ++++++----
 src/etc/completions/x.sh                       |  4 ++--
 src/etc/completions/x.zsh                      | 10 ++++++----
 12 files changed, 50 insertions(+), 32 deletions(-)

diff --git a/library/alloctests/benches/vec_deque_append.rs b/library/alloctests/benches/vec_deque_append.rs
index 7c805da97376..71dc0813f9cc 100644
--- a/library/alloctests/benches/vec_deque_append.rs
+++ b/library/alloctests/benches/vec_deque_append.rs
@@ -8,7 +8,7 @@
 fn main() {
     if cfg!(miri) {
         // Don't benchmark Miri...
-        // (Due to bootstrap quirks, this gets picked up by `x.py miri library/alloc --no-doc`.)
+        // (Due to bootstrap quirks, this gets picked up by `x.py miri library/alloc --all-targets`.)
         return;
     }
     let a: VecDeque<i32> = (0..VECDEQUE_LEN).collect();
diff --git a/src/bootstrap/mk/Makefile.in b/src/bootstrap/mk/Makefile.in
index 5f956f03ecb1..0268906a4664 100644
--- a/src/bootstrap/mk/Makefile.in
+++ b/src/bootstrap/mk/Makefile.in
@@ -64,7 +64,7 @@ check-aux:
 		library/core \
 		library/alloc \
 		$(BOOTSTRAP_ARGS) \
-		--no-doc
+		--all-targets
 	# Some doctests use file system operations to demonstrate dealing with `Result`,
 	# so we have to run them with isolation disabled.
 	$(Q)MIRIFLAGS="-Zmiri-disable-isolation" \
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 1077077cb97a..f8af8f3bec03 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -73,7 +73,7 @@ pub fn human_readable_changes(changes: &[ChangeInfo]) -> String {
 /// Keeps track of major changes made to the bootstrap configuration.
 ///
 /// If you make any major changes (such as adding new values or changing default values),
-/// please ensure adding `ChangeInfo` to the end(because the list must be sorted by the merge date)
+/// please ensure adding `ChangeInfo` to the end (because the list must be sorted by the merge date)
 /// of this list.
 pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
     ChangeInfo {
@@ -611,4 +611,9 @@ pub fn human_readable_changes(changes: &[ChangeInfo]) -> String {
         severity: ChangeSeverity::Info,
         summary: "New option `llvm.offload-clang-dir` to allow building an in-tree llvm offload and openmp runtime with an external clang.",
     },
+    ChangeInfo {
+        change_id: 153143,
+        severity: ChangeSeverity::Warning,
+        summary: "`x.py test --no-doc` is renamed to `--all-targets`. Additionally `--tests` is added which only executes unit and integration tests.",
+    },
 ];
diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index c13f8bde2994..82fb9597cb50 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -62,7 +62,8 @@ would require recompiling the entire standard library, and the entirety of
 package tests:
 
 * `--doc` — Only runs documentation tests in the package.
-* `--no-doc` — Run all tests *except* documentation tests.
+* `--all-targets` — Run all tests *except* documentation tests.
+* `--tests` — Only runs unit and integration tests
 
 [tidy-unit-tests]: https://github.com/rust-lang/rust/blob/HEAD/src/tools/tidy/src/unit_tests.rs
 
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index a837be680dcd..7aa1e27efe49 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -329,8 +329,9 @@ complete -c x -n "__fish_x_using_subcommand test" -l reproducible-artifact -d 'A
 complete -c x -n "__fish_x_using_subcommand test" -l set -d 'override options in bootstrap.toml' -r -f
 complete -c x -n "__fish_x_using_subcommand test" -l ci -d 'Make bootstrap to behave as it\'s running on the CI environment or not' -r -f -a "{true\t'',false\t''}"
 complete -c x -n "__fish_x_using_subcommand test" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x -n "__fish_x_using_subcommand test" -l no-doc -d 'do not run doc tests'
-complete -c x -n "__fish_x_using_subcommand test" -l doc -d 'only run doc tests'
+complete -c x -n "__fish_x_using_subcommand test" -l all-targets -d 'Run all test targets (no doc tests)'
+complete -c x -n "__fish_x_using_subcommand test" -l doc -d 'Only run doc tests'
+complete -c x -n "__fish_x_using_subcommand test" -l tests -d 'Only run unit and integration tests'
 complete -c x -n "__fish_x_using_subcommand test" -l bless -d 'whether to automatically update stderr/stdout files'
 complete -c x -n "__fish_x_using_subcommand test" -l force-rerun -d 'rerun tests even if the inputs are unchanged'
 complete -c x -n "__fish_x_using_subcommand test" -l only-modified -d 'only run tests that result has been changed'
@@ -374,8 +375,9 @@ complete -c x -n "__fish_x_using_subcommand miri" -l reproducible-artifact -d 'A
 complete -c x -n "__fish_x_using_subcommand miri" -l set -d 'override options in bootstrap.toml' -r -f
 complete -c x -n "__fish_x_using_subcommand miri" -l ci -d 'Make bootstrap to behave as it\'s running on the CI environment or not' -r -f -a "{true\t'',false\t''}"
 complete -c x -n "__fish_x_using_subcommand miri" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x -n "__fish_x_using_subcommand miri" -l no-doc -d 'do not run doc tests'
-complete -c x -n "__fish_x_using_subcommand miri" -l doc -d 'only run doc tests'
+complete -c x -n "__fish_x_using_subcommand miri" -l all-targets -d 'Run all test targets (no doc tests)'
+complete -c x -n "__fish_x_using_subcommand miri" -l doc -d 'Only run doc tests'
+complete -c x -n "__fish_x_using_subcommand miri" -l tests -d 'Only run unit and integration tests'
 complete -c x -n "__fish_x_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x -n "__fish_x_using_subcommand miri" -s i -l incremental -d 'use incremental compilation'
 complete -c x -n "__fish_x_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 1a02adbddfea..3aa06ac97d48 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -376,8 +376,9 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in bootstrap.toml')
             [CompletionResult]::new('--ci', '--ci', [CompletionResultType]::ParameterName, 'Make bootstrap to behave as it''s running on the CI environment or not')
             [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
+            [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
             [CompletionResult]::new('--bless', '--bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files')
             [CompletionResult]::new('--force-rerun', '--force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged')
             [CompletionResult]::new('--only-modified', '--only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed')
@@ -428,8 +429,9 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in bootstrap.toml')
             [CompletionResult]::new('--ci', '--ci', [CompletionResultType]::ParameterName, 'Make bootstrap to behave as it''s running on the CI environment or not')
             [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
+            [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 63b7987fb290..55938ea47697 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -329,8 +329,9 @@ complete -c x.py -n "__fish_x.py_using_subcommand test" -l reproducible-artifact
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l set -d 'override options in bootstrap.toml' -r -f
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l ci -d 'Make bootstrap to behave as it\'s running on the CI environment or not' -r -f -a "{true\t'',false\t''}"
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-doc -d 'do not run doc tests'
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l doc -d 'only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l all-targets -d 'Run all test targets (no doc tests)'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l doc -d 'Only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l tests -d 'Only run unit and integration tests'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l bless -d 'whether to automatically update stderr/stdout files'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l force-rerun -d 'rerun tests even if the inputs are unchanged'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l only-modified -d 'only run tests that result has been changed'
@@ -374,8 +375,9 @@ complete -c x.py -n "__fish_x.py_using_subcommand miri" -l reproducible-artifact
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l set -d 'override options in bootstrap.toml' -r -f
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l ci -d 'Make bootstrap to behave as it\'s running on the CI environment or not' -r -f -a "{true\t'',false\t''}"
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-doc -d 'do not run doc tests'
-complete -c x.py -n "__fish_x.py_using_subcommand miri" -l doc -d 'only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l all-targets -d 'Run all test targets (no doc tests)'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l doc -d 'Only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l tests -d 'Only run unit and integration tests'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -s i -l incremental -d 'use incremental compilation'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index cac70f722098..5eacd5f27e5e 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -376,8 +376,9 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in bootstrap.toml')
             [CompletionResult]::new('--ci', '--ci', [CompletionResultType]::ParameterName, 'Make bootstrap to behave as it''s running on the CI environment or not')
             [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
+            [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
             [CompletionResult]::new('--bless', '--bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files')
             [CompletionResult]::new('--force-rerun', '--force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged')
             [CompletionResult]::new('--only-modified', '--only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed')
@@ -428,8 +429,9 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in bootstrap.toml')
             [CompletionResult]::new('--ci', '--ci', [CompletionResultType]::ParameterName, 'Make bootstrap to behave as it''s running on the CI environment or not')
             [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
+            [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh
index cff17f431d33..dcbb785c03ff 100644
--- a/src/etc/completions/x.py.sh
+++ b/src/etc/completions/x.py.sh
@@ -2145,7 +2145,7 @@ _x.py() {
             return 0
             ;;
         x.py__miri)
-            opts="-v -i -j -h --no-fail-fast --test-args --no-doc --doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3875,7 +3875,7 @@ _x.py() {
             return 0
             ;;
         x.py__test)
-            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --no-doc --doc --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 47cdaf97befc..12a48f2b7fe8 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -376,8 +376,9 @@ _arguments "${_arguments_options[@]}" : \
 '*--set=[override options in bootstrap.toml]:section.option=value:' \
 '--ci=[Make bootstrap to behave as it'\''s running on the CI environment or not]:bool:(true false)' \
 '--no-fail-fast[run all tests regardless of failure]' \
-'--no-doc[do not run doc tests]' \
-'--doc[only run doc tests]' \
+'--all-targets[Run all test targets (no doc tests)]' \
+'--doc[Only run doc tests]' \
+'--tests[Only run unit and integration tests]' \
 '--bless[whether to automatically update stderr/stdout files]' \
 '--force-rerun[rerun tests even if the inputs are unchanged]' \
 '--only-modified[only run tests that result has been changed]' \
@@ -430,8 +431,9 @@ _arguments "${_arguments_options[@]}" : \
 '*--set=[override options in bootstrap.toml]:section.option=value:' \
 '--ci=[Make bootstrap to behave as it'\''s running on the CI environment or not]:bool:(true false)' \
 '--no-fail-fast[run all tests regardless of failure]' \
-'--no-doc[do not run doc tests]' \
-'--doc[only run doc tests]' \
+'--all-targets[Run all test targets (no doc tests)]' \
+'--doc[Only run doc tests]' \
+'--tests[Only run unit and integration tests]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \
diff --git a/src/etc/completions/x.sh b/src/etc/completions/x.sh
index 700617bfeba0..a902e6534c70 100644
--- a/src/etc/completions/x.sh
+++ b/src/etc/completions/x.sh
@@ -2145,7 +2145,7 @@ _x() {
             return 0
             ;;
         x__miri)
-            opts="-v -i -j -h --no-fail-fast --test-args --no-doc --doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3875,7 +3875,7 @@ _x() {
             return 0
             ;;
         x__test)
-            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --no-doc --doc --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index b960be4a1b10..7f6ad77a4a54 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -376,8 +376,9 @@ _arguments "${_arguments_options[@]}" : \
 '*--set=[override options in bootstrap.toml]:section.option=value:' \
 '--ci=[Make bootstrap to behave as it'\''s running on the CI environment or not]:bool:(true false)' \
 '--no-fail-fast[run all tests regardless of failure]' \
-'--no-doc[do not run doc tests]' \
-'--doc[only run doc tests]' \
+'--all-targets[Run all test targets (no doc tests)]' \
+'--doc[Only run doc tests]' \
+'--tests[Only run unit and integration tests]' \
 '--bless[whether to automatically update stderr/stdout files]' \
 '--force-rerun[rerun tests even if the inputs are unchanged]' \
 '--only-modified[only run tests that result has been changed]' \
@@ -430,8 +431,9 @@ _arguments "${_arguments_options[@]}" : \
 '*--set=[override options in bootstrap.toml]:section.option=value:' \
 '--ci=[Make bootstrap to behave as it'\''s running on the CI environment or not]:bool:(true false)' \
 '--no-fail-fast[run all tests regardless of failure]' \
-'--no-doc[do not run doc tests]' \
-'--doc[only run doc tests]' \
+'--all-targets[Run all test targets (no doc tests)]' \
+'--doc[Only run doc tests]' \
+'--tests[Only run unit and integration tests]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \

From c555edb70e157d016cce7e0100eb303d4936d75a Mon Sep 17 00:00:00 2001
From: Urhengulas <johann.hemmann@ferrous-systems.com>
Date: Tue, 10 Mar 2026 12:14:47 +0100
Subject: [PATCH 0291/1059] Add `./x test --no-doc` back and print a warning

---
 src/bootstrap/src/core/config/config.rs |  6 ++++++
 src/bootstrap/src/core/config/flags.rs  | 17 +++++++++++++++++
 src/etc/completions/x.fish              |  2 ++
 src/etc/completions/x.ps1               |  2 ++
 src/etc/completions/x.py.fish           |  2 ++
 src/etc/completions/x.py.ps1            |  2 ++
 src/etc/completions/x.py.sh             |  4 ++--
 src/etc/completions/x.py.zsh            |  2 ++
 src/etc/completions/x.sh                |  4 ++--
 src/etc/completions/x.zsh               |  2 ++
 10 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 17f256188e1b..2c3b5251e12f 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -415,6 +415,12 @@ pub(crate) fn parse_inner(
             "flags.exclude" = ?flags_exclude
         );
 
+        if flags_cmd.no_doc() {
+            eprintln!(
+                "WARN: `x.py test --no-doc` is renamed to `--all-targets`. `--no-doc` will be removed in the near future. Additionally `--tests` is added which only executes unit and integration tests."
+            )
+        }
+
         // Set config values based on flags.
         let mut exec_ctx = ExecutionContext::new(flags_verbose, flags_cmd.fail_fast());
         exec_ctx.set_dry_run(if flags_dry_run { DryRun::UserSelected } else { DryRun::Disabled });
diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index c86f0de7551c..a2e5def39d07 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -428,6 +428,11 @@ pub enum Subcommand {
         #[arg(long)]
         /// Ignore `//@ ignore-backends` directives.
         bypass_ignore_backends: bool,
+
+        /// Deprecated. Use `--all-targets` or `--tests` instead.
+        #[arg(long)]
+        #[doc(hidden)]
+        no_doc: bool,
     },
     /// Build and run some test suites *in Miri*
     Miri {
@@ -447,6 +452,11 @@ pub enum Subcommand {
         /// Only run unit and integration tests
         #[arg(long)]
         tests: bool,
+
+        /// Deprecated. Use `--all-targets` or `--tests` instead.
+        #[arg(long)]
+        #[doc(hidden)]
+        no_doc: bool,
     },
     /// Build and run some benchmarks
     Bench {
@@ -574,6 +584,13 @@ pub fn test_target(&self) -> TestTarget {
         }
     }
 
+    pub fn no_doc(&self) -> bool {
+        match *self {
+            Subcommand::Test { no_doc, .. } | Subcommand::Miri { no_doc, .. } => no_doc,
+            _ => false,
+        }
+    }
+
     pub fn bless(&self) -> bool {
         match *self {
             Subcommand::Test { bless, .. } => bless,
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index 7aa1e27efe49..427e46a32a48 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -338,6 +338,7 @@ complete -c x -n "__fish_x_using_subcommand test" -l only-modified -d 'only run
 complete -c x -n "__fish_x_using_subcommand test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`'
 complete -c x -n "__fish_x_using_subcommand test" -l no-capture -d 'don\'t capture stdout/stderr of tests'
 complete -c x -n "__fish_x_using_subcommand test" -l bypass-ignore-backends -d 'Ignore `//@ ignore-backends` directives'
+complete -c x -n "__fish_x_using_subcommand test" -l no-doc -d 'Deprecated. Use `--all-targets` or `--tests` instead'
 complete -c x -n "__fish_x_using_subcommand test" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x -n "__fish_x_using_subcommand test" -s i -l incremental -d 'use incremental compilation'
 complete -c x -n "__fish_x_using_subcommand test" -l include-default-paths -d 'include default paths in addition to the provided ones'
@@ -378,6 +379,7 @@ complete -c x -n "__fish_x_using_subcommand miri" -l no-fail-fast -d 'run all te
 complete -c x -n "__fish_x_using_subcommand miri" -l all-targets -d 'Run all test targets (no doc tests)'
 complete -c x -n "__fish_x_using_subcommand miri" -l doc -d 'Only run doc tests'
 complete -c x -n "__fish_x_using_subcommand miri" -l tests -d 'Only run unit and integration tests'
+complete -c x -n "__fish_x_using_subcommand miri" -l no-doc -d 'Deprecated. Use `--all-targets` or `--tests` instead'
 complete -c x -n "__fish_x_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x -n "__fish_x_using_subcommand miri" -s i -l incremental -d 'use incremental compilation'
 complete -c x -n "__fish_x_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 3aa06ac97d48..ffaadf247034 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -385,6 +385,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--rustfix-coverage', '--rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`')
             [CompletionResult]::new('--no-capture', '--no-capture', [CompletionResultType]::ParameterName, 'don''t capture stdout/stderr of tests')
             [CompletionResult]::new('--bypass-ignore-backends', '--bypass-ignore-backends', [CompletionResultType]::ParameterName, 'Ignore `//@ ignore-backends` directives')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'Deprecated. Use `--all-targets` or `--tests` instead')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
@@ -432,6 +433,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
             [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
             [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'Deprecated. Use `--all-targets` or `--tests` instead')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 55938ea47697..df5e7f3a6dda 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -338,6 +338,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand test" -l only-modified -d 'onl
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-capture -d 'don\'t capture stdout/stderr of tests'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l bypass-ignore-backends -d 'Ignore `//@ ignore-backends` directives'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-doc -d 'Deprecated. Use `--all-targets` or `--tests` instead'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -s i -l incremental -d 'use incremental compilation'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l include-default-paths -d 'include default paths in addition to the provided ones'
@@ -378,6 +379,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-fail-fast -d 'run
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l all-targets -d 'Run all test targets (no doc tests)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l doc -d 'Only run doc tests'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l tests -d 'Only run unit and integration tests'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-doc -d 'Deprecated. Use `--all-targets` or `--tests` instead'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -s i -l incremental -d 'use incremental compilation'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 5eacd5f27e5e..644c033d455f 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -385,6 +385,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--rustfix-coverage', '--rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`')
             [CompletionResult]::new('--no-capture', '--no-capture', [CompletionResultType]::ParameterName, 'don''t capture stdout/stderr of tests')
             [CompletionResult]::new('--bypass-ignore-backends', '--bypass-ignore-backends', [CompletionResultType]::ParameterName, 'Ignore `//@ ignore-backends` directives')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'Deprecated. Use `--all-targets` or `--tests` instead')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
@@ -432,6 +433,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Run all test targets (no doc tests)')
             [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'Only run doc tests')
             [CompletionResult]::new('--tests', '--tests', [CompletionResultType]::ParameterName, 'Only run unit and integration tests')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'Deprecated. Use `--all-targets` or `--tests` instead')
             [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
             [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh
index dcbb785c03ff..0d3765623c2f 100644
--- a/src/etc/completions/x.py.sh
+++ b/src/etc/completions/x.py.sh
@@ -2145,7 +2145,7 @@ _x.py() {
             return 0
             ;;
         x.py__miri)
-            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --no-doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3875,7 +3875,7 @@ _x.py() {
             return 0
             ;;
         x.py__test)
-            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --no-doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 12a48f2b7fe8..caed118ae845 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -385,6 +385,7 @@ _arguments "${_arguments_options[@]}" : \
 '--rustfix-coverage[enable this to generate a Rustfix coverage file, which is saved in \`/<build_base>/rustfix_missing_coverage.txt\`]' \
 '--no-capture[don'\''t capture stdout/stderr of tests]' \
 '--bypass-ignore-backends[Ignore \`//@ ignore-backends\` directives]' \
+'--no-doc[Deprecated. Use \`--all-targets\` or \`--tests\` instead]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \
@@ -434,6 +435,7 @@ _arguments "${_arguments_options[@]}" : \
 '--all-targets[Run all test targets (no doc tests)]' \
 '--doc[Only run doc tests]' \
 '--tests[Only run unit and integration tests]' \
+'--no-doc[Deprecated. Use \`--all-targets\` or \`--tests\` instead]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \
diff --git a/src/etc/completions/x.sh b/src/etc/completions/x.sh
index a902e6534c70..d72258aa1b9f 100644
--- a/src/etc/completions/x.sh
+++ b/src/etc/completions/x.sh
@@ -2145,7 +2145,7 @@ _x() {
             return 0
             ;;
         x__miri)
-            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --all-targets --doc --tests --no-doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3875,7 +3875,7 @@ _x() {
             return 0
             ;;
         x__test)
-            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --no-fail-fast --test-args --compiletest-rustc-args --all-targets --doc --tests --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --test-codegen-backend --bypass-ignore-backends --no-doc --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --stage --keep-stage --keep-stage-std --src --jobs --warnings --json-output --compile-time-deps --color --bypass-bootstrap-lock --rust-profile-generate --rust-profile-use --llvm-profile-use --llvm-profile-generate --enable-bolt-settings --skip-stage0-validation --reproducible-artifact --set --ci --skip-std-check-if-no-download-rustc --help [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index 7f6ad77a4a54..68aeb021b731 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -385,6 +385,7 @@ _arguments "${_arguments_options[@]}" : \
 '--rustfix-coverage[enable this to generate a Rustfix coverage file, which is saved in \`/<build_base>/rustfix_missing_coverage.txt\`]' \
 '--no-capture[don'\''t capture stdout/stderr of tests]' \
 '--bypass-ignore-backends[Ignore \`//@ ignore-backends\` directives]' \
+'--no-doc[Deprecated. Use \`--all-targets\` or \`--tests\` instead]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \
@@ -434,6 +435,7 @@ _arguments "${_arguments_options[@]}" : \
 '--all-targets[Run all test targets (no doc tests)]' \
 '--doc[Only run doc tests]' \
 '--tests[Only run unit and integration tests]' \
+'--no-doc[Deprecated. Use \`--all-targets\` or \`--tests\` instead]' \
 '*-v[use verbose output (-vv for very verbose)]' \
 '*--verbose[use verbose output (-vv for very verbose)]' \
 '-i[use incremental compilation]' \

From f760fdd8dc150a3f187255f919fb024786ffa93e Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Thu, 19 Feb 2026 11:03:14 +0000
Subject: [PATCH 0292/1059] hir_analysis: check number of vectors in tuples

Introduces a new check in `rustc_hir_analysis` enforcing that tuples of
scalable vectors should only up to eight vectors.
---
 .../rustc_hir_analysis/src/check/check.rs     | 13 ++++-
 tests/ui/scalable-vectors/illformed.rs        | 14 ++++--
 tests/ui/scalable-vectors/illformed.stderr    | 50 +++++++++++--------
 3 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 4157b110fbf6..837eb2b1a5fd 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1489,8 +1489,17 @@ fn check_scalable_vector(tcx: TyCtxt<'_>, span: Span, def_id: LocalDefId, scalab
             return;
         }
         ScalableElt::Container if fields.is_empty() => {
-            let mut err =
-                tcx.dcx().struct_span_err(span, "scalable vectors must have a single field");
+            let mut err = tcx
+                .dcx()
+                .struct_span_err(span, "scalable vector tuples must have at least one field");
+            err.help("tuples of scalable vectors can only contain multiple of the same scalable vector type");
+            err.emit();
+            return;
+        }
+        ScalableElt::Container if fields.len() > 8 => {
+            let mut err = tcx
+                .dcx()
+                .struct_span_err(span, "scalable vector tuples can have at most eight fields");
             err.help("tuples of scalable vectors can only contain multiple of the same scalable vector type");
             err.emit();
             return;
diff --git a/tests/ui/scalable-vectors/illformed.rs b/tests/ui/scalable-vectors/illformed.rs
index d8730f40e102..0122b3735ff2 100644
--- a/tests/ui/scalable-vectors/illformed.rs
+++ b/tests/ui/scalable-vectors/illformed.rs
@@ -3,6 +3,9 @@
 #![allow(internal_features)]
 #![feature(rustc_attrs)]
 
+#[rustc_scalable_vector(4)]
+struct Valid(f32);
+
 #[rustc_scalable_vector(4)]
 struct NoFieldsStructWithElementCount {}
 //~^ ERROR: scalable vectors must have a single field
@@ -19,16 +22,16 @@ struct NoFieldsStructWithElementCount {}
 
 #[rustc_scalable_vector]
 struct NoFieldsStructWithoutElementCount {}
-//~^ ERROR: scalable vectors must have a single field
+//~^ ERROR: scalable vector tuples must have at least one field
 //~^^ ERROR: scalable vectors must be tuple structs
 
 #[rustc_scalable_vector]
 struct NoFieldsTupleWithoutElementCount();
-//~^ ERROR: scalable vectors must have a single field
+//~^ ERROR: scalable vector tuples must have at least one field
 
 #[rustc_scalable_vector]
 struct NoFieldsUnitWithoutElementCount;
-//~^ ERROR: scalable vectors must have a single field
+//~^ ERROR: scalable vector tuples must have at least one field
 //~^^ ERROR: scalable vectors must be tuple structs
 
 #[rustc_scalable_vector(4)]
@@ -58,3 +61,8 @@ struct MultipleFieldsStructWithoutElementCount {
 #[rustc_scalable_vector(2)]
 struct SingleFieldStruct { _ty: f64 }
 //~^ ERROR: scalable vectors must be tuple structs
+
+#[rustc_scalable_vector]
+struct TooManyFieldsWithoutElementCount(
+    Valid, Valid, Valid, Valid, Valid, Valid, Valid, Valid, Valid);
+//~^^ ERROR: scalable vector tuples can have at most eight fields
diff --git a/tests/ui/scalable-vectors/illformed.stderr b/tests/ui/scalable-vectors/illformed.stderr
index ba584a4ad4d5..29640f023e21 100644
--- a/tests/ui/scalable-vectors/illformed.stderr
+++ b/tests/ui/scalable-vectors/illformed.stderr
@@ -1,29 +1,29 @@
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:7:1
+  --> $DIR/illformed.rs:10:1
    |
 LL | struct NoFieldsStructWithElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:16:1
+  --> $DIR/illformed.rs:19:1
    |
 LL | struct NoFieldsUnitWithElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:21:1
+  --> $DIR/illformed.rs:24:1
    |
 LL | struct NoFieldsStructWithoutElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:30:1
+  --> $DIR/illformed.rs:33:1
    |
 LL | struct NoFieldsUnitWithoutElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:35:1
+  --> $DIR/illformed.rs:38:1
    |
 LL | / struct MultipleFieldsStructWithElementCount {
 LL | |
@@ -34,7 +34,7 @@ LL | | }
    | |_^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:47:1
+  --> $DIR/illformed.rs:50:1
    |
 LL | / struct MultipleFieldsStructWithoutElementCount {
 LL | |
@@ -44,13 +44,13 @@ LL | | }
    | |_^
 
 error: scalable vectors must be tuple structs
-  --> $DIR/illformed.rs:59:1
+  --> $DIR/illformed.rs:62:1
    |
 LL | struct SingleFieldStruct { _ty: f64 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:7:1
+  --> $DIR/illformed.rs:10:1
    |
 LL | struct NoFieldsStructWithElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,7 +58,7 @@ LL | struct NoFieldsStructWithElementCount {}
    = help: scalable vector types' only field must be a primitive scalar type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:12:1
+  --> $DIR/illformed.rs:15:1
    |
 LL | struct NoFieldsTupleWithElementCount();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,31 +66,31 @@ LL | struct NoFieldsTupleWithElementCount();
    = help: scalable vector types' only field must be a primitive scalar type
 
 error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:16:1
+  --> $DIR/illformed.rs:19:1
    |
 LL | struct NoFieldsUnitWithElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: scalable vector types' only field must be a primitive scalar type
 
-error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:21:1
+error: scalable vector tuples must have at least one field
+  --> $DIR/illformed.rs:24:1
    |
 LL | struct NoFieldsStructWithoutElementCount {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
-error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:26:1
+error: scalable vector tuples must have at least one field
+  --> $DIR/illformed.rs:29:1
    |
 LL | struct NoFieldsTupleWithoutElementCount();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
-error: scalable vectors must have a single field
-  --> $DIR/illformed.rs:30:1
+error: scalable vector tuples must have at least one field
+  --> $DIR/illformed.rs:33:1
    |
 LL | struct NoFieldsUnitWithoutElementCount;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -98,28 +98,36 @@ LL | struct NoFieldsUnitWithoutElementCount;
    = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
 
 error: scalable vectors cannot have multiple fields
-  --> $DIR/illformed.rs:35:1
+  --> $DIR/illformed.rs:38:1
    |
 LL | struct MultipleFieldsStructWithElementCount {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vectors cannot have multiple fields
-  --> $DIR/illformed.rs:43:1
+  --> $DIR/illformed.rs:46:1
    |
 LL | struct MultipleFieldsTupleWithElementCount(f32, u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed.rs:49:5
+  --> $DIR/illformed.rs:52:5
    |
 LL |     _ty: f32,
    |     ^^^^^^^^
 
 error: scalable vector structs can only have scalable vector fields
-  --> $DIR/illformed.rs:55:47
+  --> $DIR/illformed.rs:58:47
    |
 LL | struct MultipleFieldsTupleWithoutElementCount(f32, u32);
    |                                               ^^^
 
-error: aborting due to 17 previous errors
+error: scalable vector tuples can have at most eight fields
+  --> $DIR/illformed.rs:66:1
+   |
+LL | struct TooManyFieldsWithoutElementCount(
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: tuples of scalable vectors can only contain multiple of the same scalable vector type
+
+error: aborting due to 18 previous errors
 

From db5e2dc248fe5bb26f70d7baec46a3bca9fa3e1d Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Mon, 2 Mar 2026 16:58:49 +0000
Subject: [PATCH 0293/1059] abi: s/ScalableVector/SimdScalableVector

Renaming to remove any ambiguity as to what "vector" refers to in this
context
---
 compiler/rustc_abi/src/callconv.rs            |  2 +-
 compiler/rustc_abi/src/layout.rs              |  6 +++---
 compiler/rustc_abi/src/lib.rs                 | 20 +++++++++----------
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    |  2 +-
 compiler/rustc_codegen_gcc/src/type_of.rs     |  6 +++---
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  2 +-
 compiler/rustc_codegen_llvm/src/type_of.rs    |  6 +++---
 compiler/rustc_codegen_llvm/src/va_arg.rs     |  4 ++--
 compiler/rustc_codegen_ssa/src/mir/operand.rs |  4 ++--
 .../rustc_const_eval/src/interpret/place.rs   |  2 +-
 .../src/interpret/validity.rs                 |  2 +-
 .../src/util/check_validity_requirement.rs    |  2 +-
 compiler/rustc_mir_transform/src/gvn.rs       |  2 +-
 .../src/mono_checks/abi_check.rs              |  2 +-
 .../src/unstable/convert/stable/abi.rs        |  2 +-
 .../rustc_target/src/callconv/loongarch.rs    |  2 +-
 compiler/rustc_target/src/callconv/mod.rs     |  4 ++--
 compiler/rustc_target/src/callconv/riscv.rs   |  2 +-
 compiler/rustc_target/src/callconv/sparc64.rs |  2 +-
 compiler/rustc_target/src/callconv/x86.rs     |  2 +-
 compiler/rustc_target/src/callconv/x86_64.rs  |  2 +-
 .../rustc_target/src/callconv/x86_win64.rs    |  2 +-
 compiler/rustc_ty_utils/src/abi.rs            |  2 +-
 .../rustc_ty_utils/src/layout/invariant.rs    |  2 +-
 24 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_abi/src/callconv.rs b/compiler/rustc_abi/src/callconv.rs
index 5b43a6c5881d..7ad7088b3089 100644
--- a/compiler/rustc_abi/src/callconv.rs
+++ b/compiler/rustc_abi/src/callconv.rs
@@ -83,7 +83,7 @@ pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, H
                 }))
             }
 
-            BackendRepr::ScalableVector { .. } => {
+            BackendRepr::SimdScalableVector { .. } => {
                 unreachable!("`homogeneous_aggregate` should not be called for scalable vectors")
             }
 
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 2351d58d8e82..d4dd235eaea6 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -484,7 +484,7 @@ pub fn layout_of_union<
                 BackendRepr::Scalar(..)
                 | BackendRepr::ScalarPair(..)
                 | BackendRepr::SimdVector { .. }
-                | BackendRepr::ScalableVector { .. }
+                | BackendRepr::SimdScalableVector { .. }
                 | BackendRepr::Memory { .. } => repr,
             },
         };
@@ -557,7 +557,7 @@ fn layout_of_struct<
                     hide_niches(b);
                 }
                 BackendRepr::SimdVector { element, .. }
-                | BackendRepr::ScalableVector { element, .. } => hide_niches(element),
+                | BackendRepr::SimdScalableVector { element, .. } => hide_niches(element),
                 BackendRepr::Memory { sized: _ } => {}
             }
             st.largest_niche = None;
@@ -1560,7 +1560,7 @@ fn vector_type_layout<FieldIdx, VariantIdx, F>(
         elt.size.checked_mul(count, dl).ok_or_else(|| LayoutCalculatorError::SizeOverflow)?;
     let (repr, align) = match kind {
         VectorKind::Scalable => {
-            (BackendRepr::ScalableVector { element, count }, dl.llvmlike_vector_align(size))
+            (BackendRepr::SimdScalableVector { element, count }, dl.llvmlike_vector_align(size))
         }
         // Non-power-of-two vectors have padding up to the next power-of-two.
         // If we're a packed repr, remove the padding while keeping the alignment as close
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index ce5f257abae9..21ca92d46d1c 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1731,7 +1731,7 @@ impl AddressSpace {
 pub enum BackendRepr {
     Scalar(Scalar),
     ScalarPair(Scalar, Scalar),
-    ScalableVector {
+    SimdScalableVector {
         element: Scalar,
         count: u64,
     },
@@ -1758,7 +1758,7 @@ pub fn is_unsized(&self) -> bool {
             // fully implemented, scalable vectors will remain `Sized`, they just won't be
             // `const Sized` - whether `is_unsized` continues to return `false` at that point will
             // need to be revisited and will depend on what `is_unsized` is used for.
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::SimdVector { .. } => false,
             BackendRepr::Memory { sized } => !sized,
         }
@@ -1801,7 +1801,7 @@ pub fn scalar_align<C: HasDataLayout>(&self, cx: &C) -> Option<Align> {
             // The align of a Vector can vary in surprising ways
             BackendRepr::SimdVector { .. }
             | BackendRepr::Memory { .. }
-            | BackendRepr::ScalableVector { .. } => None,
+            | BackendRepr::SimdScalableVector { .. } => None,
         }
     }
 
@@ -1825,7 +1825,7 @@ pub fn scalar_size<C: HasDataLayout>(&self, cx: &C) -> Option<Size> {
             // The size of a Vector can vary in surprising ways
             BackendRepr::SimdVector { .. }
             | BackendRepr::Memory { .. }
-            | BackendRepr::ScalableVector { .. } => None,
+            | BackendRepr::SimdScalableVector { .. } => None,
         }
     }
 
@@ -1840,8 +1840,8 @@ pub fn to_union(&self) -> Self {
                 BackendRepr::SimdVector { element: element.to_union(), count }
             }
             BackendRepr::Memory { .. } => BackendRepr::Memory { sized: true },
-            BackendRepr::ScalableVector { element, count } => {
-                BackendRepr::ScalableVector { element: element.to_union(), count }
+            BackendRepr::SimdScalableVector { element, count } => {
+                BackendRepr::SimdScalableVector { element: element.to_union(), count }
             }
         }
     }
@@ -2085,7 +2085,7 @@ pub fn is_aggregate(&self) -> bool {
         match self.backend_repr {
             BackendRepr::Scalar(_)
             | BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. } => false,
+            | BackendRepr::SimdScalableVector { .. } => false,
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => true,
         }
     }
@@ -2182,13 +2182,13 @@ pub fn is_1zst(&self) -> bool {
 
     /// Returns `true` if the size of the type is only known at runtime.
     pub fn is_runtime_sized(&self) -> bool {
-        matches!(self.backend_repr, BackendRepr::ScalableVector { .. })
+        matches!(self.backend_repr, BackendRepr::SimdScalableVector { .. })
     }
 
     /// Returns the elements count of a scalable vector.
     pub fn scalable_vector_element_count(&self) -> Option<u64> {
         match self.backend_repr {
-            BackendRepr::ScalableVector { count, .. } => Some(count),
+            BackendRepr::SimdScalableVector { count, .. } => Some(count),
             _ => None,
         }
     }
@@ -2201,7 +2201,7 @@ pub fn is_zst(&self) -> bool {
         match self.backend_repr {
             BackendRepr::Scalar(_)
             | BackendRepr::ScalarPair(..)
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::SimdVector { .. } => false,
             BackendRepr::Memory { sized } => sized && self.size.bytes() == 0,
         }
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index fb1127ab4f48..046a08c3df0d 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -505,7 +505,7 @@ fn codegen_intrinsic_call(
                 let layout = self.layout_of(tp_ty).layout;
                 let _use_integer_compare = match layout.backend_repr() {
                     Scalar(_) | ScalarPair(_, _) => true,
-                    SimdVector { .. } | ScalableVector { .. } => false,
+                    SimdVector { .. } | SimdScalableVector { .. } => false,
                     Memory { .. } => {
                         // For rusty ABIs, small aggregates are actually passed
                         // as `RegKind::Integer` (see `FnAbi::adjust_for_abi`),
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index 48d1b0163909..65f4fc68f05f 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -85,7 +85,7 @@ fn uncached_gcc_type<'gcc, 'tcx>(
             );
         }
         BackendRepr::Memory { .. } => {}
-        BackendRepr::ScalableVector { .. } => todo!(),
+        BackendRepr::SimdScalableVector { .. } => todo!(),
     }
 
     let name = match *layout.ty.kind() {
@@ -181,7 +181,7 @@ fn is_gcc_immediate(&self) -> bool {
         match self.backend_repr {
             BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => true,
             // FIXME(rustc_scalable_vector): Not yet implemented in rustc_codegen_gcc.
-            BackendRepr::ScalableVector { .. } => todo!(),
+            BackendRepr::SimdScalableVector { .. } => todo!(),
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => false,
         }
     }
@@ -191,7 +191,7 @@ fn is_gcc_scalar_pair(&self) -> bool {
             BackendRepr::ScalarPair(..) => true,
             BackendRepr::Scalar(_)
             | BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::Memory { .. } => false,
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index af50afa057ed..8ceb7ba29737 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -493,7 +493,7 @@ fn codegen_intrinsic_call(
                 let use_integer_compare = match layout.backend_repr() {
                     Scalar(_) | ScalarPair(_, _) => true,
                     SimdVector { .. } => false,
-                    ScalableVector { .. } => {
+                    SimdScalableVector { .. } => {
                         tcx.dcx().emit_err(InvalidMonomorphization::NonScalableType {
                             span,
                             name: sym::raw_eq,
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 1ed06fbd2821..e586ed0dd6b0 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -24,7 +24,7 @@ fn uncached_llvm_type<'a, 'tcx>(
             let element = layout.scalar_llvm_type_at(cx, element);
             return cx.type_vector(element, count);
         }
-        BackendRepr::ScalableVector { ref element, count } => {
+        BackendRepr::SimdScalableVector { ref element, count } => {
             let element = if element.is_bool() {
                 cx.type_i1()
             } else {
@@ -187,7 +187,7 @@ fn is_llvm_immediate(&self) -> bool {
         match self.backend_repr {
             BackendRepr::Scalar(_)
             | BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. } => true,
+            | BackendRepr::SimdScalableVector { .. } => true,
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => false,
         }
     }
@@ -197,7 +197,7 @@ fn is_llvm_scalar_pair(&self) -> bool {
             BackendRepr::ScalarPair(..) => true,
             BackendRepr::Scalar(_)
             | BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::Memory { .. } => false,
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index 9e6b36646434..98d2c3f131b0 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -551,7 +551,7 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
             registers_for_primitive(scalar1.primitive());
             registers_for_primitive(scalar2.primitive());
         }
-        BackendRepr::SimdVector { .. } | BackendRepr::ScalableVector { .. } => {
+        BackendRepr::SimdVector { .. } | BackendRepr::SimdScalableVector { .. } => {
             // Because no instance of VaArgSafe uses a non-scalar `BackendRepr`.
             unreachable!(
                 "No x86-64 SysV va_arg implementation for {:?}",
@@ -692,7 +692,7 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
         }
         // The Previous match on `BackendRepr` means control flow already escaped.
         BackendRepr::SimdVector { .. }
-        | BackendRepr::ScalableVector { .. }
+        | BackendRepr::SimdScalableVector { .. }
         | BackendRepr::Memory { .. } => unreachable!(),
     };
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 85fa890453d8..e1d1ef858c01 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -404,7 +404,7 @@ pub(crate) fn extract_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
                 }
                 BackendRepr::ScalarPair(_, _)
                 | BackendRepr::Memory { .. }
-                | BackendRepr::ScalableVector { .. } => bug!(),
+                | BackendRepr::SimdScalableVector { .. } => bug!(),
             })
         };
 
@@ -691,7 +691,7 @@ pub(super) fn new(layout: TyAndLayout<'tcx>) -> Self {
             BackendRepr::ScalarPair(a, b) => {
                 OperandValueBuilder::Pair(Either::Right(a), Either::Right(b))
             }
-            BackendRepr::SimdVector { .. } | BackendRepr::ScalableVector { .. } => {
+            BackendRepr::SimdVector { .. } | BackendRepr::SimdScalableVector { .. } => {
                 OperandValueBuilder::Vector(Either::Right(()))
             }
             BackendRepr::Memory { .. } => {
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index 8df284f0028a..b410e8f6c57e 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -904,7 +904,7 @@ pub(super) fn copy_op_no_validate(
             }
             // Everything else can only exist in memory anyway, so it doesn't matter.
             BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::Memory { .. } => true,
         };
 
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index b72927f455c7..677bbf5d41e6 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -1331,7 +1331,7 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                     self.visit_scalar(b, b_layout)?;
                 }
             }
-            BackendRepr::SimdVector { .. } | BackendRepr::ScalableVector { .. } => {
+            BackendRepr::SimdVector { .. } | BackendRepr::SimdScalableVector { .. } => {
                 // No checks here, we assume layout computation gets this right.
                 // (This is harder to check since Miri does not represent these as `Immediate`. We
                 // also cannot use field projections since this might be a newtype around a vector.)
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index 939f9151680b..384d7858366d 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -119,7 +119,7 @@ fn check_validity_requirement_lax<'tcx>(
             }
             BackendRepr::SimdVector { element: s, count } => count == 0 || scalar_allows_raw_init(s),
             BackendRepr::Memory { .. } => true, // Fields are checked below.
-            BackendRepr::ScalableVector { element, .. } => scalar_allows_raw_init(element),
+            BackendRepr::SimdScalableVector { element, .. } => scalar_allows_raw_init(element),
         };
 
     if !valid {
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 517bc61e5eb0..245ee6ec1cb7 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1699,7 +1699,7 @@ fn transmute_may_have_niche_of_interest_to_backend(
                 !a.is_always_valid(&self.ecx) || !b.is_always_valid(&self.ecx)
             }
             BackendRepr::SimdVector { .. }
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::Memory { .. } => false,
         }
     }
diff --git a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
index a5f2ba2f1ced..0921e57844b0 100644
--- a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
+++ b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
@@ -36,7 +36,7 @@ fn passes_vectors_by_value(mode: &PassMode, repr: &BackendRepr) -> UsesVectorReg
             UsesVectorRegisters::FixedVector
         }
         PassMode::Direct(..) | PassMode::Pair(..)
-            if matches!(repr, BackendRepr::ScalableVector { .. }) =>
+            if matches!(repr, BackendRepr::SimdScalableVector { .. }) =>
         {
             UsesVectorRegisters::ScalableVector
         }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/abi.rs b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
index 582a02e91824..b3edc6194c30 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/abi.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
@@ -265,7 +265,7 @@ fn stable<'cx>(
             rustc_abi::BackendRepr::SimdVector { element, count } => {
                 ValueAbi::Vector { element: element.stable(tables, cx), count }
             }
-            rustc_abi::BackendRepr::ScalableVector { element, count } => {
+            rustc_abi::BackendRepr::SimdScalableVector { element, count } => {
                 ValueAbi::ScalableVector { element: element.stable(tables, cx), count }
             }
             rustc_abi::BackendRepr::Memory { sized } => ValueAbi::Aggregate { sized },
diff --git a/compiler/rustc_target/src/callconv/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
index d74d15446eaf..054e9a00ea6f 100644
--- a/compiler/rustc_target/src/callconv/loongarch.rs
+++ b/compiler/rustc_target/src/callconv/loongarch.rs
@@ -88,7 +88,7 @@ fn should_use_fp_conv_helper<'a, Ty, C>(
         BackendRepr::SimdVector { .. } => {
             return Err(CannotUseFpConv);
         }
-        BackendRepr::ScalableVector { .. } => panic!("scalable vectors are unsupported"),
+        BackendRepr::SimdScalableVector { .. } => panic!("scalable vectors are unsupported"),
         BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => match arg_layout.fields {
             FieldsShape::Primitive => {
                 unreachable!("aggregates can't have `FieldsShape::Primitive`")
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 4083e28c09cb..7dc270795281 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -392,7 +392,7 @@ pub fn new(
             ),
             BackendRepr::SimdVector { .. } => PassMode::Direct(ArgAttributes::new()),
             BackendRepr::Memory { .. } => Self::indirect_pass_mode(&layout),
-            BackendRepr::ScalableVector { .. } => PassMode::Direct(ArgAttributes::new()),
+            BackendRepr::SimdScalableVector { .. } => PassMode::Direct(ArgAttributes::new()),
         };
         ArgAbi { layout, mode }
     }
@@ -878,7 +878,7 @@ fn layout_is_noundef<'a, Ty, C>(layout: TyAndLayout<'a, Ty>, cx: &C) -> bool
                 matches!(layout.variants, Variants::Single { .. }) && fields_are_noundef(layout, cx)
             }
         },
-        BackendRepr::SimdVector { .. } | BackendRepr::ScalableVector { .. } => false,
+        BackendRepr::SimdVector { .. } | BackendRepr::SimdScalableVector { .. } => false,
     }
 }
 
diff --git a/compiler/rustc_target/src/callconv/riscv.rs b/compiler/rustc_target/src/callconv/riscv.rs
index f166b8330516..18efdc5804fb 100644
--- a/compiler/rustc_target/src/callconv/riscv.rs
+++ b/compiler/rustc_target/src/callconv/riscv.rs
@@ -91,7 +91,7 @@ fn should_use_fp_conv_helper<'a, Ty, C>(
                 }
             }
         },
-        BackendRepr::SimdVector { .. } | BackendRepr::ScalableVector { .. } => {
+        BackendRepr::SimdVector { .. } | BackendRepr::SimdScalableVector { .. } => {
             return Err(CannotUseFpConv);
         }
         BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => match arg_layout.fields {
diff --git a/compiler/rustc_target/src/callconv/sparc64.rs b/compiler/rustc_target/src/callconv/sparc64.rs
index f55d03d89e8f..55f264d89bb4 100644
--- a/compiler/rustc_target/src/callconv/sparc64.rs
+++ b/compiler/rustc_target/src/callconv/sparc64.rs
@@ -65,7 +65,7 @@ fn classify<'a, Ty, C>(
             Primitive::Int(_, _) | Primitive::Pointer(_) => { /* pass in integer registers */ }
         },
         BackendRepr::SimdVector { .. } => {}
-        BackendRepr::ScalableVector { .. } => {}
+        BackendRepr::SimdScalableVector { .. } => {}
         BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => match arg_layout.fields {
             FieldsShape::Primitive => {
                 unreachable!("aggregates can't have `FieldsShape::Primitive`")
diff --git a/compiler/rustc_target/src/callconv/x86.rs b/compiler/rustc_target/src/callconv/x86.rs
index 5e8cab0ee987..9aaa411db6c0 100644
--- a/compiler/rustc_target/src/callconv/x86.rs
+++ b/compiler/rustc_target/src/callconv/x86.rs
@@ -103,7 +103,7 @@ fn contains_vector<'a, Ty, C>(cx: &C, layout: TyAndLayout<'a, Ty>) -> bool
                         }
                         false
                     }
-                    BackendRepr::ScalableVector { .. } => {
+                    BackendRepr::SimdScalableVector { .. } => {
                         panic!("scalable vectors are unsupported")
                     }
                 }
diff --git a/compiler/rustc_target/src/callconv/x86_64.rs b/compiler/rustc_target/src/callconv/x86_64.rs
index 8fab4e444228..dc73907c0c18 100644
--- a/compiler/rustc_target/src/callconv/x86_64.rs
+++ b/compiler/rustc_target/src/callconv/x86_64.rs
@@ -59,7 +59,7 @@ fn classify<'a, Ty, C>(
 
             BackendRepr::SimdVector { .. } => Class::Sse,
 
-            BackendRepr::ScalableVector { .. } => panic!("scalable vectors are unsupported"),
+            BackendRepr::SimdScalableVector { .. } => panic!("scalable vectors are unsupported"),
 
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => {
                 for i in 0..layout.fields.count() {
diff --git a/compiler/rustc_target/src/callconv/x86_win64.rs b/compiler/rustc_target/src/callconv/x86_win64.rs
index 4026c4f471a7..624563c68e5b 100644
--- a/compiler/rustc_target/src/callconv/x86_win64.rs
+++ b/compiler/rustc_target/src/callconv/x86_win64.rs
@@ -25,7 +25,7 @@ pub(crate) fn compute_abi_info<'a, Ty, C: HasTargetSpec>(cx: &C, fn_abi: &mut Fn
                 // FIXME(eddyb) there should be a size cap here
                 // (probably what clang calls "illegal vectors").
             }
-            BackendRepr::ScalableVector { .. } => panic!("scalable vectors are unsupported"),
+            BackendRepr::SimdScalableVector { .. } => panic!("scalable vectors are unsupported"),
             BackendRepr::Scalar(scalar) => {
                 if is_ret && matches!(scalar.primitive(), Primitive::Int(Integer::I128, _)) {
                     if cx.target_spec().rustc_abi == Some(RustcAbi::Softfloat) {
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 44762caf6e83..5008794bcb19 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -485,7 +485,7 @@ fn fn_arg_sanity_check<'tcx>(
                 match arg.layout.backend_repr {
                     BackendRepr::Scalar(_)
                     | BackendRepr::SimdVector { .. }
-                    | BackendRepr::ScalableVector { .. } => {}
+                    | BackendRepr::SimdScalableVector { .. } => {}
                     BackendRepr::ScalarPair(..) => {
                         panic!("`PassMode::Direct` used for ScalarPair type {}", arg.layout.ty)
                     }
diff --git a/compiler/rustc_ty_utils/src/layout/invariant.rs b/compiler/rustc_ty_utils/src/layout/invariant.rs
index 166e44d3c486..03ac1674dbd5 100644
--- a/compiler/rustc_ty_utils/src/layout/invariant.rs
+++ b/compiler/rustc_ty_utils/src/layout/invariant.rs
@@ -250,7 +250,7 @@ fn check_layout_abi<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayout<'tcx>) {
                 // And the size has to be element * count plus alignment padding, of course
                 assert!(size == (element_size * count).align_to(align));
             }
-            BackendRepr::Memory { .. } | BackendRepr::ScalableVector { .. } => {} // Nothing to check.
+            BackendRepr::Memory { .. } | BackendRepr::SimdScalableVector { .. } => {} // Nothing to check.
         }
     }
 

From b7674995b13e5d7831558d57aef031fb11cf9c66 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Mon, 2 Mar 2026 15:04:25 +0000
Subject: [PATCH 0294/1059] abi: s/VectorKind/SimdVectorKind

Renaming to remove any ambiguity as to what "vector" refers to in this
context.
---
 compiler/rustc_abi/src/layout.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index d4dd235eaea6..93c01f289d42 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -210,7 +210,7 @@ pub fn scalable_vector_type<FieldIdx, VariantIdx, F>(
         VariantIdx: Idx,
         F: AsRef<LayoutData<FieldIdx, VariantIdx>> + fmt::Debug,
     {
-        vector_type_layout(VectorKind::Scalable, self.cx.data_layout(), element, count)
+        vector_type_layout(SimdVectorKind::Scalable, self.cx.data_layout(), element, count)
     }
 
     pub fn simd_type<FieldIdx, VariantIdx, F>(
@@ -224,7 +224,7 @@ pub fn simd_type<FieldIdx, VariantIdx, F>(
         VariantIdx: Idx,
         F: AsRef<LayoutData<FieldIdx, VariantIdx>> + fmt::Debug,
     {
-        let kind = if repr_packed { VectorKind::PackedFixed } else { VectorKind::Fixed };
+        let kind = if repr_packed { SimdVectorKind::PackedFixed } else { SimdVectorKind::Fixed };
         vector_type_layout(kind, self.cx.data_layout(), element, count)
     }
 
@@ -1524,7 +1524,7 @@ fn format_field_niches<
     }
 }
 
-enum VectorKind {
+enum SimdVectorKind {
     /// `#[rustc_scalable_vector]`
     Scalable,
     /// `#[repr(simd, packed)]`
@@ -1534,7 +1534,7 @@ enum VectorKind {
 }
 
 fn vector_type_layout<FieldIdx, VariantIdx, F>(
-    kind: VectorKind,
+    kind: SimdVectorKind,
     dl: &TargetDataLayout,
     element: F,
     count: u64,
@@ -1559,16 +1559,16 @@ fn vector_type_layout<FieldIdx, VariantIdx, F>(
     let size =
         elt.size.checked_mul(count, dl).ok_or_else(|| LayoutCalculatorError::SizeOverflow)?;
     let (repr, align) = match kind {
-        VectorKind::Scalable => {
+        SimdVectorKind::Scalable => {
             (BackendRepr::SimdScalableVector { element, count }, dl.llvmlike_vector_align(size))
         }
         // Non-power-of-two vectors have padding up to the next power-of-two.
         // If we're a packed repr, remove the padding while keeping the alignment as close
         // to a vector as possible.
-        VectorKind::PackedFixed if !count.is_power_of_two() => {
+        SimdVectorKind::PackedFixed if !count.is_power_of_two() => {
             (BackendRepr::Memory { sized: true }, Align::max_aligned_factor(size))
         }
-        VectorKind::PackedFixed | VectorKind::Fixed => {
+        SimdVectorKind::PackedFixed | SimdVectorKind::Fixed => {
             (BackendRepr::SimdVector { element, count }, dl.llvmlike_vector_align(size))
         }
     };

From b707e7ae52065f659f08fe6fd5858623b83da5e4 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 6 Mar 2026 15:58:10 +0300
Subject: [PATCH 0295/1059] Remove `FromCycleError` trait before code
 formatting

Currently `QueryVTable`'s `value_from_cycle_error` function pointer uses the `FromCycleError` trait to call query cycle handling code and to construct an erroneous query output value.
This trick however relies too heavily on trait impl specialization and makes those impls inconsistent (which is bad AFAIK).
Instead this commit directly modifies `value_from_cycle_error` function pointer upon vtable initialization and gets rid of `FromCycleError`.
---
 .../rustc_query_impl/src/from_cycle_error.rs  | 117 +++++++-----------
 compiler/rustc_query_impl/src/lib.rs          |   5 +-
 compiler/rustc_query_impl/src/plumbing.rs     |   6 +-
 3 files changed, 51 insertions(+), 77 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index eb6942ba491f..a8df8b23441c 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 use std::fmt::Write;
+use std::iter;
 use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxHashSet;
@@ -9,55 +10,56 @@
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::dep_graph::DepKind;
 use rustc_middle::query::CycleError;
+use rustc_middle::query::erase::erase_val;
 use rustc_middle::query::plumbing::CyclePlaceholder;
-use rustc_middle::ty::{self, Representability, Ty, TyCtxt};
+use rustc_middle::queries::QueryVTables;
+use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{ErrorGuaranteed, Span};
 
 use crate::job::report_cycle;
 
-pub(crate) trait FromCycleError<'tcx>: Sized {
-    /// Try to produce a `Self` value that represents an error form (e.g. `TyKind::Error`).
-    ///
-    /// Note: the default impl calls `raise_fatal`, ending compilation immediately! Only a few
-    /// types override this with a non-fatal impl.
-    fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self;
+pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
+    vtables.type_of.value_from_cycle_error =
+        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+
+    vtables.type_of_opaque_hir_typeck.value_from_cycle_error =
+        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+
+    vtables.erase_and_anonymize_regions_ty.value_from_cycle_error =
+        |tcx, _, guar| erase_val(Ty::new_error(tcx, guar));
+
+    vtables.type_of_opaque.value_from_cycle_error =
+        |_, _, guar| erase_val(Err(CyclePlaceholder(guar)));
+
+    vtables.fn_sig.value_from_cycle_error = |tcx, cycle, guar| erase_val(fn_sig(tcx, cycle, guar));
+
+    vtables.check_representability.value_from_cycle_error =
+        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+
+    vtables.check_representability_adt_ty.value_from_cycle_error =
+        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+
+    vtables.variances_of.value_from_cycle_error =
+        |tcx, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
+
+    vtables.layout_of.value_from_cycle_error =
+        |tcx, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
 }
 
-impl<'tcx, T> FromCycleError<'tcx> for T {
-    default fn from_cycle_error(
-        tcx: TyCtxt<'tcx>,
-        cycle_error: CycleError,
-        _guar: ErrorGuaranteed,
-    ) -> T {
+    pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
         let Some(guar) = tcx.sess.dcx().has_errors() else {
             bug!(
-                "<{} as FromCycleError>::from_cycle_error called without errors: {:#?}",
-                std::any::type_name::<T>(),
+                "`from_cycle_error_default` on query `{query_name}` called without errors: {:#?}",
                 cycle_error.cycle,
             );
         };
-        guar.raise_fatal();
+        guar.raise_fatal()
     }
-}
 
-impl<'tcx> FromCycleError<'tcx> for Ty<'_> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>, _: CycleError, guar: ErrorGuaranteed) -> Self {
-        // SAFETY: This is never called when `Self` is not `Ty<'tcx>`.
-        // FIXME: Represent the above fact in the trait system somehow.
-        unsafe { std::mem::transmute::<Ty<'tcx>, Ty<'_>>(Ty::new_error(tcx, guar)) }
-    }
-}
-
-impl<'tcx> FromCycleError<'tcx> for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
-    fn from_cycle_error(_tcx: TyCtxt<'tcx>, _: CycleError, guar: ErrorGuaranteed) -> Self {
-        Err(CyclePlaceholder(guar))
-    }
-}
-
-impl<'tcx> FromCycleError<'tcx> for ty::Binder<'_, ty::FnSig<'_>> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
+    fn fn_sig<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
         let err = Ty::new_error(tcx, guar);
 
         let arity = if let Some(info) = cycle_error.cycle.get(0)
@@ -72,26 +74,20 @@ fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuara
             unreachable!()
         };
 
-        let fn_sig = ty::Binder::dummy(tcx.mk_fn_sig(
+        ty::EarlyBinder::bind(ty::Binder::dummy(tcx.mk_fn_sig(
             std::iter::repeat_n(err, arity),
             err,
             false,
             rustc_hir::Safety::Safe,
             rustc_abi::ExternAbi::Rust,
-        ));
-
-        // SAFETY: This is never called when `Self` is not `ty::Binder<'tcx, ty::FnSig<'tcx>>`.
-        // FIXME: Represent the above fact in the trait system somehow.
-        unsafe { std::mem::transmute::<ty::PolyFnSig<'tcx>, ty::Binder<'_, ty::FnSig<'_>>>(fn_sig) }
+        )))
     }
-}
 
-impl<'tcx> FromCycleError<'tcx> for Representability {
-    fn from_cycle_error(
+    fn check_representability<'tcx>(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
         _guar: ErrorGuaranteed,
-    ) -> Self {
+    ) -> ! {
         let mut item_and_field_ids = Vec::new();
         let mut representable_ids = FxHashSet::default();
         for info in &cycle_error.cycle {
@@ -120,28 +116,14 @@ fn from_cycle_error(
         // We used to continue here, but the cycle error printed next is actually less useful than
         // the error produced by `recursive_type_error`.
         let guar = recursive_type_error(tcx, item_and_field_ids, &representable_ids);
-        guar.raise_fatal();
+        guar.raise_fatal()
     }
-}
 
-impl<'tcx> FromCycleError<'tcx> for ty::EarlyBinder<'_, Ty<'_>> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
-        ty::EarlyBinder::bind(Ty::from_cycle_error(tcx, cycle_error, guar))
-    }
-}
-
-impl<'tcx> FromCycleError<'tcx> for ty::EarlyBinder<'_, ty::Binder<'_, ty::FnSig<'_>>> {
-    fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
-        ty::EarlyBinder::bind(ty::Binder::from_cycle_error(tcx, cycle_error, guar))
-    }
-}
-
-impl<'tcx> FromCycleError<'tcx> for &[ty::Variance] {
-    fn from_cycle_error(
+    fn variances_of<'tcx>(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
         _guar: ErrorGuaranteed,
-    ) -> Self {
+    ) -> &'tcx [ty::Variance] {
         search_for_cycle_permutation(
             &cycle_error.cycle,
             |cycle| {
@@ -150,7 +132,7 @@ fn from_cycle_error(
                     && let Some(def_id) = info.frame.def_id
                 {
                     let n = tcx.generics_of(def_id).own_params.len();
-                    ControlFlow::Break(vec![ty::Bivariant; n].leak())
+                    ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
                 } else {
                     ControlFlow::Continue(())
                 }
@@ -163,7 +145,6 @@ fn from_cycle_error(
             },
         )
     }
-}
 
 // Take a cycle of `Q` and try `try_cycle` on every permutation, falling back to `otherwise`.
 fn search_for_cycle_permutation<Q, T>(
@@ -184,12 +165,11 @@ fn search_for_cycle_permutation<Q, T>(
     otherwise()
 }
 
-impl<'tcx, T> FromCycleError<'tcx> for Result<T, &'_ ty::layout::LayoutError<'_>> {
-    fn from_cycle_error(
+    fn layout_of<'tcx>(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
         _guar: ErrorGuaranteed,
-    ) -> Self {
+    ) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
         let diag = search_for_cycle_permutation(
             &cycle_error.cycle,
             |cycle| {
@@ -267,13 +247,8 @@ fn from_cycle_error(
         );
 
         let guar = diag.emit();
-
-        // tcx.arena.alloc cannot be used because we are not allowed to use &'tcx LayoutError under
-        // min_specialization. Since this is an error path anyways, leaking doesn't matter (and really,
-        // tcx.arena.alloc is pretty much equal to leaking).
-        Err(Box::leak(Box::new(ty::layout::LayoutError::Cycle(guar))))
+        Err(tcx.arena.alloc(LayoutError::Cycle(guar)))
     }
-}
 
 // item_and_field_ids should form a cycle where each field contains the
 // type in the next element in the list
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index d92d80dbfb86..6482384f99ea 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -18,7 +18,6 @@
 use rustc_span::Span;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
-use crate::from_cycle_error::FromCycleError;
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
 use crate::profiling_support::QueryKeyStringCache;
 
@@ -52,9 +51,11 @@ pub fn query_system<'tcx>(
     on_disk_cache: Option<OnDiskCache>,
     incremental: bool,
 ) -> QuerySystem<'tcx> {
+    let mut query_vtables = make_query_vtables(incremental);
+    from_cycle_error::specialize_query_vtables(&mut query_vtables);
     QuerySystem {
         arenas: Default::default(),
-        query_vtables: make_query_vtables(incremental),
+        query_vtables,
         on_disk_cache,
         local_providers,
         extern_providers,
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index f4649b2403a6..558ecdda5c4b 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -467,10 +467,8 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                     #[cfg(not($cache_on_disk))]
                     is_loadable_from_disk_fn: |_tcx, _key, _index| false,
 
-                    value_from_cycle_error: |tcx, cycle, guar| {
-                        let result: queries::$name::Value<'tcx> =
-                            FromCycleError::from_cycle_error(tcx, cycle, guar);
-                        erase::erase_val(result)
+                    value_from_cycle_error: |tcx, cycle, _| {
+                        $crate::from_cycle_error::default(tcx, cycle, stringify!($name))
                     },
 
                     #[cfg($no_hash)]

From 94187453541be9f80889f0fe9cfa5318c242229d Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 6 Mar 2026 16:00:20 +0300
Subject: [PATCH 0296/1059] Run code formatter

---
 .../rustc_query_impl/src/from_cycle_error.rs  | 345 +++++++++---------
 1 file changed, 174 insertions(+), 171 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index a8df8b23441c..2599c2fde5d0 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -9,10 +9,10 @@
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::dep_graph::DepKind;
+use rustc_middle::queries::QueryVTables;
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
 use rustc_middle::query::plumbing::CyclePlaceholder;
-use rustc_middle::queries::QueryVTables;
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -49,102 +49,106 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
         |tcx, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
 }
 
-    pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
-        let Some(guar) = tcx.sess.dcx().has_errors() else {
-            bug!(
-                "`from_cycle_error_default` on query `{query_name}` called without errors: {:#?}",
-                cycle_error.cycle,
-            );
-        };
-        guar.raise_fatal()
-    }
+pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
+    let Some(guar) = tcx.sess.dcx().has_errors() else {
+        bug!(
+            "`from_cycle_error_default` on query `{query_name}` called without errors: {:#?}",
+            cycle_error.cycle,
+        );
+    };
+    guar.raise_fatal()
+}
 
-    fn fn_sig<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
-        let err = Ty::new_error(tcx, guar);
+fn fn_sig<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cycle_error: CycleError,
+    guar: ErrorGuaranteed,
+) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
+    let err = Ty::new_error(tcx, guar);
 
-        let arity = if let Some(info) = cycle_error.cycle.get(0)
-            && info.frame.dep_kind == DepKind::fn_sig
-            && let Some(def_id) = info.frame.def_id
-            && let Some(node) = tcx.hir_get_if_local(def_id)
-            && let Some(sig) = node.fn_sig()
+    let arity = if let Some(info) = cycle_error.cycle.get(0)
+        && info.frame.dep_kind == DepKind::fn_sig
+        && let Some(def_id) = info.frame.def_id
+        && let Some(node) = tcx.hir_get_if_local(def_id)
+        && let Some(sig) = node.fn_sig()
+    {
+        sig.decl.inputs.len()
+    } else {
+        tcx.dcx().abort_if_errors();
+        unreachable!()
+    };
+
+    ty::EarlyBinder::bind(ty::Binder::dummy(tcx.mk_fn_sig(
+        std::iter::repeat_n(err, arity),
+        err,
+        false,
+        rustc_hir::Safety::Safe,
+        rustc_abi::ExternAbi::Rust,
+    )))
+}
+
+fn check_representability<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cycle_error: CycleError,
+    _guar: ErrorGuaranteed,
+) -> ! {
+    let mut item_and_field_ids = Vec::new();
+    let mut representable_ids = FxHashSet::default();
+    for info in &cycle_error.cycle {
+        if info.frame.dep_kind == DepKind::check_representability
+            && let Some(field_id) = info.frame.def_id
+            && let Some(field_id) = field_id.as_local()
+            && let Some(DefKind::Field) = info.frame.info.def_kind
         {
-            sig.decl.inputs.len()
-        } else {
-            tcx.dcx().abort_if_errors();
-            unreachable!()
-        };
-
-        ty::EarlyBinder::bind(ty::Binder::dummy(tcx.mk_fn_sig(
-            std::iter::repeat_n(err, arity),
-            err,
-            false,
-            rustc_hir::Safety::Safe,
-            rustc_abi::ExternAbi::Rust,
-        )))
-    }
-
-    fn check_representability<'tcx>(
-        tcx: TyCtxt<'tcx>,
-        cycle_error: CycleError,
-        _guar: ErrorGuaranteed,
-    ) -> ! {
-        let mut item_and_field_ids = Vec::new();
-        let mut representable_ids = FxHashSet::default();
-        for info in &cycle_error.cycle {
-            if info.frame.dep_kind == DepKind::check_representability
-                && let Some(field_id) = info.frame.def_id
-                && let Some(field_id) = field_id.as_local()
-                && let Some(DefKind::Field) = info.frame.info.def_kind
-            {
-                let parent_id = tcx.parent(field_id.to_def_id());
-                let item_id = match tcx.def_kind(parent_id) {
-                    DefKind::Variant => tcx.parent(parent_id),
-                    _ => parent_id,
-                };
-                item_and_field_ids.push((item_id.expect_local(), field_id));
-            }
+            let parent_id = tcx.parent(field_id.to_def_id());
+            let item_id = match tcx.def_kind(parent_id) {
+                DefKind::Variant => tcx.parent(parent_id),
+                _ => parent_id,
+            };
+            item_and_field_ids.push((item_id.expect_local(), field_id));
         }
-        for info in &cycle_error.cycle {
-            if info.frame.dep_kind == DepKind::check_representability_adt_ty
-                && let Some(def_id) = info.frame.def_id_for_ty_in_cycle
-                && let Some(def_id) = def_id.as_local()
-                && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
-            {
-                representable_ids.insert(def_id);
-            }
+    }
+    for info in &cycle_error.cycle {
+        if info.frame.dep_kind == DepKind::check_representability_adt_ty
+            && let Some(def_id) = info.frame.def_id_for_ty_in_cycle
+            && let Some(def_id) = def_id.as_local()
+            && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
+        {
+            representable_ids.insert(def_id);
         }
-        // We used to continue here, but the cycle error printed next is actually less useful than
-        // the error produced by `recursive_type_error`.
-        let guar = recursive_type_error(tcx, item_and_field_ids, &representable_ids);
-        guar.raise_fatal()
     }
+    // We used to continue here, but the cycle error printed next is actually less useful than
+    // the error produced by `recursive_type_error`.
+    let guar = recursive_type_error(tcx, item_and_field_ids, &representable_ids);
+    guar.raise_fatal()
+}
 
-    fn variances_of<'tcx>(
-        tcx: TyCtxt<'tcx>,
-        cycle_error: CycleError,
-        _guar: ErrorGuaranteed,
-    ) -> &'tcx [ty::Variance] {
-        search_for_cycle_permutation(
-            &cycle_error.cycle,
-            |cycle| {
-                if let Some(info) = cycle.get(0)
-                    && info.frame.dep_kind == DepKind::variances_of
-                    && let Some(def_id) = info.frame.def_id
-                {
-                    let n = tcx.generics_of(def_id).own_params.len();
-                    ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
-                } else {
-                    ControlFlow::Continue(())
-                }
-            },
-            || {
-                span_bug!(
-                    cycle_error.usage.as_ref().unwrap().0,
-                    "only `variances_of` returns `&[ty::Variance]`"
-                )
-            },
-        )
-    }
+fn variances_of<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cycle_error: CycleError,
+    _guar: ErrorGuaranteed,
+) -> &'tcx [ty::Variance] {
+    search_for_cycle_permutation(
+        &cycle_error.cycle,
+        |cycle| {
+            if let Some(info) = cycle.get(0)
+                && info.frame.dep_kind == DepKind::variances_of
+                && let Some(def_id) = info.frame.def_id
+            {
+                let n = tcx.generics_of(def_id).own_params.len();
+                ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
+            } else {
+                ControlFlow::Continue(())
+            }
+        },
+        || {
+            span_bug!(
+                cycle_error.usage.as_ref().unwrap().0,
+                "only `variances_of` returns `&[ty::Variance]`"
+            )
+        },
+    )
+}
 
 // Take a cycle of `Q` and try `try_cycle` on every permutation, falling back to `otherwise`.
 fn search_for_cycle_permutation<Q, T>(
@@ -165,90 +169,89 @@ fn search_for_cycle_permutation<Q, T>(
     otherwise()
 }
 
-    fn layout_of<'tcx>(
-        tcx: TyCtxt<'tcx>,
-        cycle_error: CycleError,
-        _guar: ErrorGuaranteed,
-    ) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
-        let diag = search_for_cycle_permutation(
-            &cycle_error.cycle,
-            |cycle| {
-                if cycle[0].frame.dep_kind == DepKind::layout_of
-                    && let Some(def_id) = cycle[0].frame.def_id_for_ty_in_cycle
-                    && let Some(def_id) = def_id.as_local()
-                    && let def_kind = tcx.def_kind(def_id)
-                    && matches!(def_kind, DefKind::Closure)
-                    && let Some(coroutine_kind) = tcx.coroutine_kind(def_id)
-                {
-                    // FIXME: `def_span` for an fn-like coroutine will point to the fn's body
-                    // due to interactions between the desugaring into a closure expr and the
-                    // def_span code. I'm not motivated to fix it, because I tried and it was
-                    // not working, so just hack around it by grabbing the parent fn's span.
-                    let span = if coroutine_kind.is_fn_like() {
-                        tcx.def_span(tcx.local_parent(def_id))
-                    } else {
-                        tcx.def_span(def_id)
-                    };
-                    let mut diag = struct_span_code_err!(
-                        tcx.sess.dcx(),
-                        span,
-                        E0733,
-                        "recursion in {} {} requires boxing",
-                        tcx.def_kind_descr_article(def_kind, def_id.to_def_id()),
-                        tcx.def_kind_descr(def_kind, def_id.to_def_id()),
-                    );
-                    for (i, info) in cycle.iter().enumerate() {
-                        if info.frame.dep_kind != DepKind::layout_of {
-                            continue;
-                        }
-                        let Some(frame_def_id) = info.frame.def_id_for_ty_in_cycle else {
-                            continue;
-                        };
-                        let Some(frame_coroutine_kind) = tcx.coroutine_kind(frame_def_id) else {
-                            continue;
-                        };
-                        let frame_span =
-                            info.frame.info.default_span(cycle[(i + 1) % cycle.len()].span);
-                        if frame_span.is_dummy() {
-                            continue;
-                        }
-                        if i == 0 {
-                            diag.span_label(frame_span, "recursive call here");
-                        } else {
-                            let coroutine_span: Span = if frame_coroutine_kind.is_fn_like() {
-                                tcx.def_span(tcx.parent(frame_def_id))
-                            } else {
-                                tcx.def_span(frame_def_id)
-                            };
-                            let mut multispan = MultiSpan::from_span(coroutine_span);
-                            multispan
-                                .push_span_label(frame_span, "...leading to this recursive call");
-                            diag.span_note(
-                                multispan,
-                                format!("which leads to this {}", tcx.def_descr(frame_def_id)),
-                            );
-                        }
-                    }
-                    // FIXME: We could report a structured suggestion if we had
-                    // enough info here... Maybe we can use a hacky HIR walker.
-                    if matches!(
-                        coroutine_kind,
-                        hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)
-                    ) {
-                        diag.note("a recursive `async fn` call must introduce indirection such as `Box::pin` to avoid an infinitely sized future");
-                    }
-
-                    ControlFlow::Break(diag)
+fn layout_of<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cycle_error: CycleError,
+    _guar: ErrorGuaranteed,
+) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
+    let diag = search_for_cycle_permutation(
+        &cycle_error.cycle,
+        |cycle| {
+            if cycle[0].frame.dep_kind == DepKind::layout_of
+                && let Some(def_id) = cycle[0].frame.def_id_for_ty_in_cycle
+                && let Some(def_id) = def_id.as_local()
+                && let def_kind = tcx.def_kind(def_id)
+                && matches!(def_kind, DefKind::Closure)
+                && let Some(coroutine_kind) = tcx.coroutine_kind(def_id)
+            {
+                // FIXME: `def_span` for an fn-like coroutine will point to the fn's body
+                // due to interactions between the desugaring into a closure expr and the
+                // def_span code. I'm not motivated to fix it, because I tried and it was
+                // not working, so just hack around it by grabbing the parent fn's span.
+                let span = if coroutine_kind.is_fn_like() {
+                    tcx.def_span(tcx.local_parent(def_id))
                 } else {
-                    ControlFlow::Continue(())
+                    tcx.def_span(def_id)
+                };
+                let mut diag = struct_span_code_err!(
+                    tcx.sess.dcx(),
+                    span,
+                    E0733,
+                    "recursion in {} {} requires boxing",
+                    tcx.def_kind_descr_article(def_kind, def_id.to_def_id()),
+                    tcx.def_kind_descr(def_kind, def_id.to_def_id()),
+                );
+                for (i, info) in cycle.iter().enumerate() {
+                    if info.frame.dep_kind != DepKind::layout_of {
+                        continue;
+                    }
+                    let Some(frame_def_id) = info.frame.def_id_for_ty_in_cycle else {
+                        continue;
+                    };
+                    let Some(frame_coroutine_kind) = tcx.coroutine_kind(frame_def_id) else {
+                        continue;
+                    };
+                    let frame_span =
+                        info.frame.info.default_span(cycle[(i + 1) % cycle.len()].span);
+                    if frame_span.is_dummy() {
+                        continue;
+                    }
+                    if i == 0 {
+                        diag.span_label(frame_span, "recursive call here");
+                    } else {
+                        let coroutine_span: Span = if frame_coroutine_kind.is_fn_like() {
+                            tcx.def_span(tcx.parent(frame_def_id))
+                        } else {
+                            tcx.def_span(frame_def_id)
+                        };
+                        let mut multispan = MultiSpan::from_span(coroutine_span);
+                        multispan.push_span_label(frame_span, "...leading to this recursive call");
+                        diag.span_note(
+                            multispan,
+                            format!("which leads to this {}", tcx.def_descr(frame_def_id)),
+                        );
+                    }
+                }
+                // FIXME: We could report a structured suggestion if we had
+                // enough info here... Maybe we can use a hacky HIR walker.
+                if matches!(
+                    coroutine_kind,
+                    hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)
+                ) {
+                    diag.note("a recursive `async fn` call must introduce indirection such as `Box::pin` to avoid an infinitely sized future");
                 }
-            },
-            || report_cycle(tcx.sess, &cycle_error),
-        );
 
-        let guar = diag.emit();
-        Err(tcx.arena.alloc(LayoutError::Cycle(guar)))
-    }
+                ControlFlow::Break(diag)
+            } else {
+                ControlFlow::Continue(())
+            }
+        },
+        || report_cycle(tcx.sess, &cycle_error),
+    );
+
+    let guar = diag.emit();
+    Err(tcx.arena.alloc(LayoutError::Cycle(guar)))
+}
 
 // item_and_field_ids should form a cycle where each field contains the
 // type in the next element in the list

From 84442006abc09626ba04b966d42d86633de7e164 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 24 Feb 2026 22:13:04 -0500
Subject: [PATCH 0297/1059] Rustdoc lints on duplicate, unused, and stable
 features

---
 src/librustdoc/core.rs                                | 3 +++
 tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs | 1 -
 tests/rustdoc-html/doc-cfg/doc-cfg.rs                 | 1 -
 tests/rustdoc-ui/issues/issue-79494.rs                | 2 --
 tests/rustdoc-ui/issues/issue-79494.stderr            | 2 +-
 tests/rustdoc-ui/rustc-check-passes.rs                | 2 +-
 tests/rustdoc-ui/rustc-check-passes.stderr            | 5 +++--
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index bb41758c7a2e..331f02c639aa 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -232,6 +232,9 @@ pub(crate) fn create_config(
         rustc_lint::builtin::RENAMED_AND_REMOVED_LINTS.name.to_string(),
         rustc_lint::builtin::UNKNOWN_LINTS.name.to_string(),
         rustc_lint::builtin::UNEXPECTED_CFGS.name.to_string(),
+        rustc_lint::builtin::DUPLICATE_FEATURES.name.to_string(),
+        rustc_lint::builtin::UNUSED_FEATURES.name.to_string(),
+        rustc_lint::builtin::STABLE_FEATURES.name.to_string(),
         // this lint is needed to support `#[expect]` attributes
         rustc_lint::builtin::UNFULFILLED_LINT_EXPECTATIONS.name.to_string(),
     ];
diff --git a/tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs b/tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs
index c79d07ff5bd7..96cc612b597c 100644
--- a/tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs
+++ b/tests/rustdoc-html/assoc/assoc-type-bindings-20646.rs
@@ -3,7 +3,6 @@
 
 // https://github.com/rust-lang/rust/issues/20646
 #![crate_name="issue_20646"]
-#![feature(associated_types)]
 
 extern crate issue_20646;
 
diff --git a/tests/rustdoc-html/doc-cfg/doc-cfg.rs b/tests/rustdoc-html/doc-cfg/doc-cfg.rs
index 652c8419b4fb..ba2a8de5b29e 100644
--- a/tests/rustdoc-html/doc-cfg/doc-cfg.rs
+++ b/tests/rustdoc-html/doc-cfg/doc-cfg.rs
@@ -1,5 +1,4 @@
 #![feature(doc_cfg)]
-#![feature(target_feature, cfg_target_feature)]
 
 //@ has doc_cfg/struct.Portable.html
 //@ !has - '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' ''
diff --git a/tests/rustdoc-ui/issues/issue-79494.rs b/tests/rustdoc-ui/issues/issue-79494.rs
index 737c00a0269b..c80e0a984213 100644
--- a/tests/rustdoc-ui/issues/issue-79494.rs
+++ b/tests/rustdoc-ui/issues/issue-79494.rs
@@ -1,6 +1,4 @@
 //@ only-64bit
 
-#![feature(const_transmute)]
-
 pub const ZST: &[u8] = unsafe { std::mem::transmute(1usize) };
 //~^ ERROR transmuting from 8-byte type to 16-byte type
diff --git a/tests/rustdoc-ui/issues/issue-79494.stderr b/tests/rustdoc-ui/issues/issue-79494.stderr
index fa797bfd50a6..31ed8f18ab07 100644
--- a/tests/rustdoc-ui/issues/issue-79494.stderr
+++ b/tests/rustdoc-ui/issues/issue-79494.stderr
@@ -1,5 +1,5 @@
 error[E0080]: transmuting from 8-byte type to 16-byte type: `usize` -> `&[u8]`
-  --> $DIR/issue-79494.rs:5:33
+  --> $DIR/issue-79494.rs:3:33
    |
 LL | pub const ZST: &[u8] = unsafe { std::mem::transmute(1usize) };
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `ZST` failed here
diff --git a/tests/rustdoc-ui/rustc-check-passes.rs b/tests/rustdoc-ui/rustc-check-passes.rs
index 56d59164d68f..54028a6d18ee 100644
--- a/tests/rustdoc-ui/rustc-check-passes.rs
+++ b/tests/rustdoc-ui/rustc-check-passes.rs
@@ -1,4 +1,4 @@
 #![feature(rustdoc_internals)]
-#![feature(rustdoc_internals)] //~ ERROR
+#![feature(rustdoc_internals)] //~ ERROR duplicate
 
 pub fn foo() {}
diff --git a/tests/rustdoc-ui/rustc-check-passes.stderr b/tests/rustdoc-ui/rustc-check-passes.stderr
index 5b20d1128c59..2789d8236d32 100644
--- a/tests/rustdoc-ui/rustc-check-passes.stderr
+++ b/tests/rustdoc-ui/rustc-check-passes.stderr
@@ -1,9 +1,10 @@
-error[E0636]: the feature `rustdoc_internals` has already been enabled
+error: the feature `rustdoc_internals` has already been enabled
   --> $DIR/rustc-check-passes.rs:2:12
    |
 LL | #![feature(rustdoc_internals)]
    |            ^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[deny(duplicate_features)]` on by default
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0636`.

From 10c92ecb1250f2042954b5f6d8a1b249739e672a Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 10 Mar 2026 11:56:12 +0100
Subject: [PATCH 0298/1059] `x b error_index_generator` works even if
 submodules aren't checked out

---
 src/bootstrap/src/core/build_steps/tool.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index d86159d3cc7e..e6148af61767 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -600,6 +600,12 @@ fn make_run(run: RunConfig<'_>) {
     }
 
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
+        builder.require_submodule(
+            "src/doc/reference",
+            Some("error_index_generator requires mdbook-spec"),
+        );
+        builder
+            .require_submodule("src/doc/book", Some("error_index_generator requires mdbook-trpl"));
         builder.ensure(ToolBuild {
             build_compiler: self.compilers.build_compiler,
             target: self.compilers.target(),

From cca28656e5caf70a5d3fb2c2668683f397b946fd Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Thu, 29 Jan 2026 12:51:51 +0000
Subject: [PATCH 0299/1059] sess: `-Zbranch-protection` is a target modifier

`-Zbranch-protection` only makes sense if the entire crate graph has
the option set, otherwise the security properties that branch protection
provides won't be effective. This flag is unstable so I don't think this
warrants an MCP.
---
 compiler/rustc_session/src/options.rs          |  2 +-
 .../aarch64-naked-fn-no-bti-prolog.rs          |  2 +-
 .../rmake.rs                                   |  1 +
 .../run-make/pointer-auth-link-with-c/rmake.rs | 18 +++++++++++++++---
 4 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 74b3aa11d0d8..e9e4ddaa6056 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2240,7 +2240,7 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
         (default: no)"),
     box_noalias: bool = (true, parse_bool, [TRACKED],
         "emit noalias metadata for box (default: yes)"),
-    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED],
+    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED TARGET_MODIFIER],
         "set options for branch target identification and pointer authentication on AArch64"),
     build_sdylib_interface: bool = (false, parse_bool, [UNTRACKED],
         "whether the stable interface is being built"),
diff --git a/tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs b/tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
index 860ecc3cfcd0..430d4a59da6d 100644
--- a/tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
+++ b/tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -C no-prepopulate-passes -Zbranch-protection=bti
+//@ compile-flags: -C no-prepopulate-passes -Zbranch-protection=bti -Cunsafe-allow-abi-mismatch=branch-protection
 //@ assembly-output: emit-asm
 //@ needs-asm-support
 //@ only-aarch64
diff --git a/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs b/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
index 2ac5fdee063c..1d06fe118e06 100644
--- a/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
+++ b/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
@@ -32,6 +32,7 @@ fn main() {
         .opt_level("2")
         .linker(&env_var("CLANG"))
         .link_arg("-fuse-ld=lld")
+        .arg("-Cunsafe-allow-abi-mismatch=branch-protection")
         .arg("-Zbranch-protection=bti,gcs,pac-ret,leaf")
         .input("test.rs")
         .output("test.bin")
diff --git a/tests/run-make/pointer-auth-link-with-c/rmake.rs b/tests/run-make/pointer-auth-link-with-c/rmake.rs
index 1ddcb79d64ff..1ac68c95559c 100644
--- a/tests/run-make/pointer-auth-link-with-c/rmake.rs
+++ b/tests/run-make/pointer-auth-link-with-c/rmake.rs
@@ -15,7 +15,11 @@
 
 fn main() {
     build_native_static_lib("test");
-    rustc().arg("-Zbranch-protection=bti,gcs,pac-ret,leaf").input("test.rs").run();
+    rustc()
+        .arg("-Cunsafe-allow-abi-mismatch=branch-protection")
+        .arg("-Zbranch-protection=bti,gcs,pac-ret,leaf")
+        .input("test.rs")
+        .run();
     run("test");
     cc().arg("-v")
         .arg("-c")
@@ -25,7 +29,11 @@ fn main() {
         .run();
     let obj_file = if is_windows_msvc() { "test.obj" } else { "test" };
     llvm_ar().obj_to_ar().output_input("libtest.a", &obj_file).run();
-    rustc().arg("-Zbranch-protection=bti,gcs,pac-ret,leaf").input("test.rs").run();
+    rustc()
+        .arg("-Cunsafe-allow-abi-mismatch=branch-protection")
+        .arg("-Zbranch-protection=bti,gcs,pac-ret,leaf")
+        .input("test.rs")
+        .run();
     run("test");
 
     // FIXME: +pc was only recently added to LLVM
@@ -37,6 +45,10 @@ fn main() {
     //     .run();
     // let obj_file = if is_windows_msvc() { "test.obj" } else { "test" };
     // llvm_ar().obj_to_ar().output_input("libtest.a", &obj_file).run();
-    // rustc().arg("-Zbranch-protection=bti,pac-ret,pc,leaf").input("test.rs").run();
+    // rustc()
+    //     .arg("-Cunsafe-allow-abi-mismatch=branch-protection")
+    //     .arg("-Zbranch-protection=bti,pac-ret,pc,leaf")
+    //     .input("test.rs")
+    //     .run();
     // run("test");
 }

From 1384f66c1c603b1567de2e2ffc068688f5fa7745 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Tue, 10 Mar 2026 13:11:00 +0000
Subject: [PATCH 0300/1059] triagebot: remove myself from some mention groups

I haven't worked in these areas for a little while, but happy to still be
pinged if someone wanted.
---
 triagebot.toml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/triagebot.toml b/triagebot.toml
index a3a5928a8f36..86192295e0cd 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1177,7 +1177,7 @@ cc = ["@oli-obk", "@RalfJung", "@JakobDegen", "@vakaras"]
 
 [mentions."compiler/rustc_error_messages"]
 message = "`rustc_error_messages` was changed"
-cc = ["@davidtwco", "@TaKO8Ki"]
+cc = ["@TaKO8Ki"]
 
 [mentions."compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs"]
 message = "`rustc_errors::annotate_snippet_emitter_writer` was changed"
@@ -1189,11 +1189,11 @@ cc = ["@Muscraft"]
 
 [mentions."compiler/rustc_errors/src/formatting.rs"]
 message = "`rustc_errors::formatting` was changed"
-cc = ["@davidtwco", "@TaKO8Ki", "@JonathanBrouwer"]
+cc = ["@TaKO8Ki", "@JonathanBrouwer"]
 
 [mentions."compiler/rustc_macros/src/diagnostics"]
 message = "`rustc_macros::diagnostics` was changed"
-cc = ["@davidtwco", "@TaKO8Ki", "@JonathanBrouwer"]
+cc = ["@TaKO8Ki", "@JonathanBrouwer"]
 
 [mentions."compiler/rustc_public"]
 message = "This PR changes rustc_public"

From 407e421f7fe7fba44863b1c216519b512d8b8948 Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Tue, 10 Mar 2026 08:13:41 -0400
Subject: [PATCH 0301/1059] Unify same-span labels in move error diagnostics

---
 .../src/diagnostics/move_errors.rs            |  29 +--
 .../rustc_borrowck/src/session_diagnostics.rs |  10 +
 .../borrowck/access-mode-in-closures.stderr   |   5 +-
 ...ck-for-loop-correct-cmt-for-pattern.stderr |   9 +-
 .../borrowck-move-error-with-note.stderr      |   5 +-
 .../borrowck-move-in-irrefut-pat.stderr       |   9 +-
 ...rrowck-move-out-of-struct-with-dtor.stderr |  11 +-
 ...-move-out-of-tuple-struct-with-dtor.stderr |  11 +-
 .../borrowck/borrowck-vec-pattern-nesting.rs  |   6 +-
 .../borrowck-vec-pattern-nesting.stderr       |  20 +-
 tests/ui/borrowck/issue-51301.stderr          |   3 +-
 tests/ui/borrowck/issue-51415.stderr          |   3 +-
 ...constructing-destructing-struct-let.stderr |   3 +-
 ...nstructing-destructing-struct-match.stderr |   5 +-
 ...ving-wrong-ref-pattern-issue-132806.stderr |   3 +-
 ...tions-destructuring-assignment-drop.stderr |   3 +-
 .../moves/issue-99470-move-out-of-some.stderr |   5 +-
 tests/ui/moves/move-out-of-array-ref.stderr   |  12 +-
 tests/ui/moves/move-out-of-slice-1.stderr     |   5 +-
 .../moves-based-on-type-block-bad.stderr      |   5 +-
 tests/ui/nll/move-errors.stderr               |  26 +-
 .../ui/pattern/by-move-pattern-binding.stderr |  11 +-
 .../cant_move_out_of_pattern.stderr           |  20 +-
 ...terns-default-binding-modes-fixable.stderr |   3 +-
 ...-ref-patterns-default-binding-modes.stderr |   3 +-
 .../mut-pattern-of-immutable-borrow.stderr    |  10 +-
 .../borrowck-errors.classic2021.stderr        |   3 +-
 .../borrowck-errors.classic2024.stderr        |  12 +-
 .../borrowck-errors.stable2021.stderr         |   3 +-
 .../borrowck-errors.structural2021.stderr     |   3 +-
 .../borrowck-errors.structural2024.stderr     |   3 +-
 tests/ui/pin-ergonomics/pin-pattern.stderr    |   9 +-
 .../rfc-2005-default-binding-mode/for.stderr  |   3 +-
 .../dont-suggest-ref/move-into-closure.stderr | 157 ++++--------
 .../dont-suggest-ref/simple.stderr            | 225 +++++-------------
 .../non_copy_move_out_of_tuple.stderr         |   3 +-
 ...ption-content-move-from-tuple-match.stderr |   5 +-
 .../error-tainting-issue-122904.stderr        |   3 +-
 .../recursive-drop-elaboration-2.stderr       |   3 +-
 .../recursive-drop-elaboration.stderr         |   6 +-
 40 files changed, 193 insertions(+), 480 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 54253babafa7..89e008f06ebc 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -990,30 +990,25 @@ fn add_move_error_details(
             let bind_to = &self.body.local_decls[*local];
             let binding_span = bind_to.source_info.span;
 
-            if j == 0 {
-                err.span_label(binding_span, "data moved here");
-            } else {
-                err.span_label(binding_span, "...and here");
-            }
-
             if binds_to.len() == 1 {
                 let place_desc = self.local_name(*local).map(|sym| format!("`{sym}`"));
 
-                if !desugar_spans.contains(&binding_span)
-                    && let Some(expr) = self.find_expr(binding_span)
-                {
-                    // The binding_span doesn't correspond to a let binding desugaring
-                    // and is an expression where calling `.clone()` would be valid.
-                    let local_place: PlaceRef<'tcx> = (*local).into();
-                    self.suggest_cloning(err, local_place, bind_to.ty, expr, None);
-                }
-
-                err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
-                    is_partial_move: false,
+                err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::LabelMovedHere {
                     ty: bind_to.ty,
                     place: place_desc.as_deref().unwrap_or("the place"),
                     span: binding_span,
                 });
+
+                if !desugar_spans.contains(&binding_span)
+                    && let Some(expr) = self.find_expr(binding_span)
+                {
+                    let local_place: PlaceRef<'tcx> = (*local).into();
+                    self.suggest_cloning(err, local_place, bind_to.ty, expr, None);
+                }
+            } else if j == 0 {
+                err.span_label(binding_span, "data moved here");
+            } else {
+                err.span_label(binding_span, "...and here");
             }
         }
 
diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs
index fea5c2b99037..b2f33d64f0d9 100644
--- a/compiler/rustc_borrowck/src/session_diagnostics.rs
+++ b/compiler/rustc_borrowck/src/session_diagnostics.rs
@@ -570,6 +570,16 @@ pub(crate) enum TypeNoCopy<'a, 'tcx> {
         #[primary_span]
         span: Span,
     },
+    #[label(
+        "data moved here because {$place} has type `{$ty}`, which does not implement the `Copy` \
+         trait"
+    )]
+    LabelMovedHere {
+        ty: Ty<'tcx>,
+        place: &'a str,
+        #[primary_span]
+        span: Span,
+    },
     #[note(
         "{$is_partial_move ->
             [true] partial move
diff --git a/tests/ui/borrowck/access-mode-in-closures.stderr b/tests/ui/borrowck/access-mode-in-closures.stderr
index b9a45edb330c..94593d51fdf5 100644
--- a/tests/ui/borrowck/access-mode-in-closures.stderr
+++ b/tests/ui/borrowck/access-mode-in-closures.stderr
@@ -2,10 +2,7 @@ error[E0507]: cannot move out of `s` which is behind a shared reference
   --> $DIR/access-mode-in-closures.rs:8:15
    |
 LL |         match *s { S(v) => v }
-   |               ^^     -
-   |                      |
-   |                      data moved here
-   |                      move occurs because `v` has type `Vec<isize>`, which does not implement the `Copy` trait
+   |               ^^     - data moved here because `v` has type `Vec<isize>`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
diff --git a/tests/ui/borrowck/borrowck-for-loop-correct-cmt-for-pattern.stderr b/tests/ui/borrowck/borrowck-for-loop-correct-cmt-for-pattern.stderr
index f9ced03e0f03..1ff5c78df780 100644
--- a/tests/ui/borrowck/borrowck-for-loop-correct-cmt-for-pattern.stderr
+++ b/tests/ui/borrowck/borrowck-for-loop-correct-cmt-for-pattern.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     for &a in x.iter() {
    |          -    ^^^^^^^^
    |          |
-   |          data moved here
-   |          move occurs because `a` has type `&mut i32`, which does not implement the `Copy` trait
+   |          data moved here because `a` has type `&mut i32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -19,8 +18,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     for &a in &f.a {
    |          -    ^^^^
    |          |
-   |          data moved here
-   |          move occurs because `a` has type `Box<isize>`, which does not implement the `Copy` trait
+   |          data moved here because `a` has type `Box<isize>`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -34,8 +32,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     for &a in x.iter() {
    |          -    ^^^^^^^^
    |          |
-   |          data moved here
-   |          move occurs because `a` has type `Box<i32>`, which does not implement the `Copy` trait
+   |          data moved here because `a` has type `Box<i32>`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/borrowck/borrowck-move-error-with-note.stderr b/tests/ui/borrowck/borrowck-move-error-with-note.stderr
index 722c2c1443a7..e9f0395fa0d4 100644
--- a/tests/ui/borrowck/borrowck-move-error-with-note.stderr
+++ b/tests/ui/borrowck/borrowck-move-error-with-note.stderr
@@ -44,10 +44,7 @@ error[E0507]: cannot move out of `a.a` which is behind a shared reference
 LL |     match a.a {
    |           ^^^
 LL |         n => {
-   |         -
-   |         |
-   |         data moved here
-   |         move occurs because `n` has type `Box<isize>`, which does not implement the `Copy` trait
+   |         - data moved here because `n` has type `Box<isize>`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
diff --git a/tests/ui/borrowck/borrowck-move-in-irrefut-pat.stderr b/tests/ui/borrowck/borrowck-move-in-irrefut-pat.stderr
index 21bd073321b8..c67499c7d6d7 100644
--- a/tests/ui/borrowck/borrowck-move-in-irrefut-pat.stderr
+++ b/tests/ui/borrowck/borrowck-move-in-irrefut-pat.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL | fn arg_item(&_x: &String) {}
    |             ^--
    |              |
-   |              data moved here
-   |              move occurs because `_x` has type `String`, which does not implement the `Copy` trait
+   |              data moved here because `_x` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -19,8 +18,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     with(|&_x| ())
    |           ^--
    |            |
-   |            data moved here
-   |            move occurs because `_x` has type `String`, which does not implement the `Copy` trait
+   |            data moved here because `_x` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -34,8 +32,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let &_x = &"hi".to_string();
    |          --   ^^^^^^^^^^^^^^^^^
    |          |
-   |          data moved here
-   |          move occurs because `_x` has type `String`, which does not implement the `Copy` trait
+   |          data moved here because `_x` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/borrowck/borrowck-move-out-of-struct-with-dtor.stderr b/tests/ui/borrowck/borrowck-move-out-of-struct-with-dtor.stderr
index 58f706c65ff2..fa77eddb4965 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-struct-with-dtor.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-struct-with-dtor.stderr
@@ -5,10 +5,7 @@ LL |     match (S {f:"foo".to_string()}) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot move out of here
 LL |
 LL |         S {f:_s} => {}
-   |              --
-   |              |
-   |              data moved here
-   |              move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |              -- data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -21,8 +18,7 @@ error[E0509]: cannot move out of type `S`, which implements the `Drop` trait
 LL |     let S {f:_s} = S {f:"foo".to_string()};
    |              --    ^^^^^^^^^^^^^^^^^^^^^^^ cannot move out of here
    |              |
-   |              data moved here
-   |              move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |              data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -35,8 +31,7 @@ error[E0509]: cannot move out of type `S`, which implements the `Drop` trait
 LL | fn move_in_fn_arg(S {f:_s}: S) {
    |                   ^^^^^--^
    |                   |    |
-   |                   |    data moved here
-   |                   |    move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |                   |    data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |                   cannot move out of here
    |
 help: consider borrowing the pattern binding
diff --git a/tests/ui/borrowck/borrowck-move-out-of-tuple-struct-with-dtor.stderr b/tests/ui/borrowck/borrowck-move-out-of-tuple-struct-with-dtor.stderr
index 160a1f99f63f..17e9792b628d 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-tuple-struct-with-dtor.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-tuple-struct-with-dtor.stderr
@@ -5,10 +5,7 @@ LL |     match S("foo".to_string()) {
    |           ^^^^^^^^^^^^^^^^^^^^ cannot move out of here
 LL |
 LL |         S(_s) => {}
-   |           --
-   |           |
-   |           data moved here
-   |           move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |           -- data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -21,8 +18,7 @@ error[E0509]: cannot move out of type `S`, which implements the `Drop` trait
 LL |     let S(_s) = S("foo".to_string());
    |           --    ^^^^^^^^^^^^^^^^^^^^ cannot move out of here
    |           |
-   |           data moved here
-   |           move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |           data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -35,8 +31,7 @@ error[E0509]: cannot move out of type `S`, which implements the `Drop` trait
 LL | fn move_in_fn_arg(S(_s): S) {
    |                   ^^--^
    |                   | |
-   |                   | data moved here
-   |                   | move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |                   | data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |                   cannot move out of here
    |
 help: consider borrowing the pattern binding
diff --git a/tests/ui/borrowck/borrowck-vec-pattern-nesting.rs b/tests/ui/borrowck/borrowck-vec-pattern-nesting.rs
index 400e5f010ecb..657c4789aa30 100644
--- a/tests/ui/borrowck/borrowck-vec-pattern-nesting.rs
+++ b/tests/ui/borrowck/borrowck-vec-pattern-nesting.rs
@@ -35,8 +35,7 @@ fn c() {
         //~^ ERROR cannot move out
         //~| NOTE cannot move out
         &mut [_a,
-        //~^ NOTE data moved here
-        //~| NOTE move occurs because `_a` has type
+        //~^ NOTE data moved here because `_a` has type
         //~| HELP consider removing the mutable borrow
             ..
         ] => {
@@ -59,8 +58,7 @@ fn d() {
         &mut [
         //~^ HELP consider removing the mutable borrow
          _b] => {}
-        //~^ NOTE data moved here
-        //~| NOTE move occurs because `_b` has type
+        //~^ NOTE data moved here because `_b` has type
         _ => {}
     }
     let a = vec[0]; //~ ERROR cannot move out
diff --git a/tests/ui/borrowck/borrowck-vec-pattern-nesting.stderr b/tests/ui/borrowck/borrowck-vec-pattern-nesting.stderr
index fff997fd5559..a002b7e3d7f6 100644
--- a/tests/ui/borrowck/borrowck-vec-pattern-nesting.stderr
+++ b/tests/ui/borrowck/borrowck-vec-pattern-nesting.stderr
@@ -29,10 +29,7 @@ LL |     match vec {
    |           ^^^ cannot move out of here
 ...
 LL |         &mut [_a,
-   |               --
-   |               |
-   |               data moved here
-   |               move occurs because `_a` has type `Box<isize>`, which does not implement the `Copy` trait
+   |               -- data moved here because `_a` has type `Box<isize>`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -41,7 +38,7 @@ LL +         [_a,
    |
 
 error[E0508]: cannot move out of type `[Box<isize>]`, a non-copy slice
-  --> $DIR/borrowck-vec-pattern-nesting.rs:46:13
+  --> $DIR/borrowck-vec-pattern-nesting.rs:45:13
    |
 LL |     let a = vec[0];
    |             ^^^^^^
@@ -59,16 +56,13 @@ LL |     let a = vec[0].clone();
    |                   ++++++++
 
 error[E0508]: cannot move out of type `[Box<isize>]`, a non-copy slice
-  --> $DIR/borrowck-vec-pattern-nesting.rs:56:11
+  --> $DIR/borrowck-vec-pattern-nesting.rs:55:11
    |
 LL |     match vec {
    |           ^^^ cannot move out of here
 ...
 LL |          _b] => {}
-   |          --
-   |          |
-   |          data moved here
-   |          move occurs because `_b` has type `Box<isize>`, which does not implement the `Copy` trait
+   |          -- data moved here because `_b` has type `Box<isize>`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -77,7 +71,7 @@ LL +         [
    |
 
 error[E0508]: cannot move out of type `[Box<isize>]`, a non-copy slice
-  --> $DIR/borrowck-vec-pattern-nesting.rs:66:13
+  --> $DIR/borrowck-vec-pattern-nesting.rs:64:13
    |
 LL |     let a = vec[0];
    |             ^^^^^^
@@ -95,7 +89,7 @@ LL |     let a = vec[0].clone();
    |                   ++++++++
 
 error[E0508]: cannot move out of type `[Box<isize>]`, a non-copy slice
-  --> $DIR/borrowck-vec-pattern-nesting.rs:76:11
+  --> $DIR/borrowck-vec-pattern-nesting.rs:74:11
    |
 LL |     match vec {
    |           ^^^ cannot move out of here
@@ -114,7 +108,7 @@ LL +         [_a, _b, _c] => {}
    |
 
 error[E0508]: cannot move out of type `[Box<isize>]`, a non-copy slice
-  --> $DIR/borrowck-vec-pattern-nesting.rs:87:13
+  --> $DIR/borrowck-vec-pattern-nesting.rs:85:13
    |
 LL |     let a = vec[0];
    |             ^^^^^^
diff --git a/tests/ui/borrowck/issue-51301.stderr b/tests/ui/borrowck/issue-51301.stderr
index c0b06437093a..b5c06649e864 100644
--- a/tests/ui/borrowck/issue-51301.stderr
+++ b/tests/ui/borrowck/issue-51301.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |             .find(|(&event_type, _)| event == event_type)
    |                    ^^----------^^^^
    |                      |
-   |                      data moved here
-   |                      move occurs because `event_type` has type `EventType`, which does not implement the `Copy` trait
+   |                      data moved here because `event_type` has type `EventType`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/borrowck/issue-51415.stderr b/tests/ui/borrowck/issue-51415.stderr
index e51e0b33ebd3..dd44c5e5f037 100644
--- a/tests/ui/borrowck/issue-51415.stderr
+++ b/tests/ui/borrowck/issue-51415.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let opt = a.iter().enumerate().find(|(_, &s)| {
    |                                          ^^^^^-^
    |                                               |
-   |                                               data moved here
-   |                                               move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |                                               data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
index 45c7a8bb475a..4e7797c93b51 100644
--- a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
+++ b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
@@ -4,8 +4,7 @@ error[E0509]: cannot move out of type `X`, which implements the `Drop` trait
 LL |     let X { x: y } = x;
    |                -     ^ cannot move out of here
    |                |
-   |                data moved here
-   |                move occurs because `y` has type `String`, which does not implement the `Copy` trait
+   |                data moved here because `y` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
index 837904cbae07..0b5f80fc5608 100644
--- a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
+++ b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
@@ -5,10 +5,7 @@ LL |     match x {
    |           ^ cannot move out of here
 LL |
 LL |         X { x: y } => println!("contents: {}", y)
-   |                -
-   |                |
-   |                data moved here
-   |                move occurs because `y` has type `String`, which does not implement the `Copy` trait
+   |                - data moved here because `y` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr
index ff579f934137..5f66c2eb6787 100644
--- a/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr
+++ b/tests/ui/moves/do-not-suggest-removing-wrong-ref-pattern-issue-132806.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let _ = HashMap::<String, i32>::new().iter().filter(|&(&_k, &_v)| { true });
    |                                                          ^^^--^^^^^^
    |                                                             |
-   |                                                             data moved here
-   |                                                             move occurs because `_k` has type `String`, which does not implement the `Copy` trait
+   |                                                             data moved here because `_k` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/moves/invalid-suggestions-destructuring-assignment-drop.stderr b/tests/ui/moves/invalid-suggestions-destructuring-assignment-drop.stderr
index c2bc85ee6bee..21f51907b5e7 100644
--- a/tests/ui/moves/invalid-suggestions-destructuring-assignment-drop.stderr
+++ b/tests/ui/moves/invalid-suggestions-destructuring-assignment-drop.stderr
@@ -4,8 +4,7 @@ error[E0509]: cannot move out of type `Thing`, which implements the `Drop` trait
 LL |     Thing(*&mut String::new()) = Thing(String::new());
    |           -------------------    ^^^^^^^^^^^^^^^^^^^^ cannot move out of here
    |           |
-   |           data moved here
-   |           move occurs because the place has type `String`, which does not implement the `Copy` trait
+   |           data moved here because the place has type `String`, which does not implement the `Copy` trait
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/moves/issue-99470-move-out-of-some.stderr b/tests/ui/moves/issue-99470-move-out-of-some.stderr
index 71ec5adfdeac..59e4e7d073d9 100644
--- a/tests/ui/moves/issue-99470-move-out-of-some.stderr
+++ b/tests/ui/moves/issue-99470-move-out-of-some.stderr
@@ -5,10 +5,7 @@ LL |     match x {
    |           ^
 LL |
 LL |         &Some(_y) => (),
-   |               --
-   |               |
-   |               data moved here
-   |               move occurs because `_y` has type `Box<i32>`, which does not implement the `Copy` trait
+   |               -- data moved here because `_y` has type `Box<i32>`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/moves/move-out-of-array-ref.stderr b/tests/ui/moves/move-out-of-array-ref.stderr
index 26d4996d6cb1..5c3e0ad5872c 100644
--- a/tests/ui/moves/move-out-of-array-ref.stderr
+++ b/tests/ui/moves/move-out-of-array-ref.stderr
@@ -4,8 +4,7 @@ error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
 LL |     let [_, e, _, _] = *a;
    |             -          ^^ cannot move out of here
    |             |
-   |             data moved here
-   |             move occurs because `e` has type `D`, which does not implement the `Copy` trait
+   |             data moved here because `e` has type `D`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -19,8 +18,7 @@ error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
 LL |     let [_, s @ .. , _] = *a;
    |             -             ^^ cannot move out of here
    |             |
-   |             data moved here
-   |             move occurs because `s` has type `[D; 2]`, which does not implement the `Copy` trait
+   |             data moved here because `s` has type `[D; 2]`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -34,8 +32,7 @@ error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
 LL |     let [_, e, _, _] = *a;
    |             -          ^^ cannot move out of here
    |             |
-   |             data moved here
-   |             move occurs because `e` has type `D`, which does not implement the `Copy` trait
+   |             data moved here because `e` has type `D`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -49,8 +46,7 @@ error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
 LL |     let [_, s @ .. , _] = *a;
    |             -             ^^ cannot move out of here
    |             |
-   |             data moved here
-   |             move occurs because `s` has type `[D; 2]`, which does not implement the `Copy` trait
+   |             data moved here because `s` has type `[D; 2]`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
diff --git a/tests/ui/moves/move-out-of-slice-1.stderr b/tests/ui/moves/move-out-of-slice-1.stderr
index 86533714474b..4b917554057c 100644
--- a/tests/ui/moves/move-out-of-slice-1.stderr
+++ b/tests/ui/moves/move-out-of-slice-1.stderr
@@ -4,10 +4,7 @@ error[E0508]: cannot move out of type `[A]`, a non-copy slice
 LL |     match a {
    |           ^ cannot move out of here
 LL |         box [a] => {},
-   |              -
-   |              |
-   |              data moved here
-   |              move occurs because `a` has type `A`, which does not implement the `Copy` trait
+   |              - data moved here because `a` has type `A`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/moves/moves-based-on-type-block-bad.stderr b/tests/ui/moves/moves-based-on-type-block-bad.stderr
index 431ee1c0bb1b..31417b59f099 100644
--- a/tests/ui/moves/moves-based-on-type-block-bad.stderr
+++ b/tests/ui/moves/moves-based-on-type-block-bad.stderr
@@ -5,10 +5,7 @@ LL |             match hellothere.x {
    |                   ^^^^^^^^^^^^
 LL |                 box E::Foo(_) => {}
 LL |                 box E::Bar(x) => println!("{}", x.to_string()),
-   |                            -
-   |                            |
-   |                            data moved here
-   |                            move occurs because `x` has type `Box<isize>`, which does not implement the `Copy` trait
+   |                            - data moved here because `x` has type `Box<isize>`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
diff --git a/tests/ui/nll/move-errors.stderr b/tests/ui/nll/move-errors.stderr
index bcb2ab84a239..c1ec357cab06 100644
--- a/tests/ui/nll/move-errors.stderr
+++ b/tests/ui/nll/move-errors.stderr
@@ -108,8 +108,7 @@ error[E0507]: cannot move out of `a` which is behind a shared reference
 LL |     let A(s) = *a;
    |           -    ^^
    |           |
-   |           data moved here
-   |           move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |           data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -123,8 +122,7 @@ error[E0509]: cannot move out of type `D`, which implements the `Drop` trait
 LL |     let C(D(s)) = c;
    |             -     ^ cannot move out of here
    |             |
-   |             data moved here
-   |             move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |             data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -170,10 +168,7 @@ LL |     match x {
    |           ^ cannot move out of here
 ...
 LL |         B::U(D(s)) => (),
-   |                -
-   |                |
-   |                data moved here
-   |                move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |                - data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -187,10 +182,7 @@ LL |     match x {
    |           ^ cannot move out of here
 ...
 LL |         (D(s), &t) => (),
-   |            -
-   |            |
-   |            data moved here
-   |            move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |            - data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -204,10 +196,7 @@ LL |     match x {
    |           ^
 ...
 LL |         (D(s), &t) => (),
-   |                 -
-   |                 |
-   |                 data moved here
-   |                 move occurs because `t` has type `String`, which does not implement the `Copy` trait
+   |                 - data moved here because `t` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -243,10 +232,7 @@ LL |     match *x {
    |           ^^
 LL |
 LL |         Ok(s) | Err(s) => (),
-   |            -
-   |            |
-   |            data moved here
-   |            move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |            - data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
diff --git a/tests/ui/pattern/by-move-pattern-binding.stderr b/tests/ui/pattern/by-move-pattern-binding.stderr
index 203e37dc387c..4a65bf3ea27f 100644
--- a/tests/ui/pattern/by-move-pattern-binding.stderr
+++ b/tests/ui/pattern/by-move-pattern-binding.stderr
@@ -5,10 +5,7 @@ LL |     match &s.x {
    |           ^^^^
 LL |         &E::Foo => {}
 LL |         &E::Bar(identifier) => f(identifier.clone())
-   |                 ----------
-   |                 |
-   |                 data moved here
-   |                 move occurs because `identifier` has type `String`, which does not implement the `Copy` trait
+   |                 ---------- data moved here because `identifier` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -22,8 +19,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let &E::Bar(identifier) = &s.x {
    |                    ----------    ^^^^
    |                    |
-   |                    data moved here
-   |                    move occurs because `identifier` has type `String`, which does not implement the `Copy` trait
+   |                    data moved here because `identifier` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -37,8 +33,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let &E::Bar(identifier) = &s.x else {
    |                 ----------    ^^^^
    |                 |
-   |                 data moved here
-   |                 move occurs because `identifier` has type `String`, which does not implement the `Copy` trait
+   |                 data moved here because `identifier` has type `String`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
index 532dd496b235..119b86d52885 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
@@ -5,10 +5,7 @@ LL |     match b {
    |           ^ cannot move out of here
 LL |
 LL |         deref!([x]) => x,
-   |                 -
-   |                 |
-   |                 data moved here
-   |                 move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |                 - data moved here because `x` has type `Struct`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -22,10 +19,7 @@ LL |     match rc {
    |           ^^
 LL |
 LL |         deref!(x) => x,
-   |                -
-   |                |
-   |                data moved here
-   |                move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |                - data moved here because `x` has type `Struct`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -39,10 +33,7 @@ LL |     match b {
    |           ^ cannot move out of here
 LL |
 LL |         [x] => x,
-   |          -
-   |          |
-   |          data moved here
-   |          move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |          - data moved here because `x` has type `Struct`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -56,10 +47,7 @@ LL |     match rc {
    |           ^^
 LL |
 LL |         Container(x) => x,
-   |                   -
-   |                   |
-   |                   data moved here
-   |                   move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |                   - data moved here because `x` has type `Struct`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
index 85379d6605bc..6e974b4f4da0 100644
--- a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
+++ b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     let (a, mut b) = &mut p;
    |             -----    ^^^^^^
    |             |
-   |             data moved here
-   |             move occurs because `b` has type `U`, which does not implement the `Copy` trait
+   |             data moved here because `b` has type `U`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
index 494e5e2b2e85..2be222d19e68 100644
--- a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
+++ b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let (a, mut b) = &p;
    |             -----    ^^
    |             |
-   |             data moved here
-   |             move occurs because `b` has type `U`, which does not implement the `Copy` trait
+   |             data moved here because `b` has type `U`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/pattern/mut-pattern-of-immutable-borrow.stderr b/tests/ui/pattern/mut-pattern-of-immutable-borrow.stderr
index be1b5fadb0dd..f9ef1efa6b2e 100644
--- a/tests/ui/pattern/mut-pattern-of-immutable-borrow.stderr
+++ b/tests/ui/pattern/mut-pattern-of-immutable-borrow.stderr
@@ -4,10 +4,7 @@ error[E0507]: cannot move out of `arg.field` as enum variant `Some` which is beh
 LL |     match arg.field {
    |           ^^^^^^^^^
 LL |         Some(s) => s.push('a'),
-   |              -
-   |              |
-   |              data moved here
-   |              move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |              - data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -31,10 +28,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     match &arg.field {
    |           ^^^^^^^^^^
 LL |         Some(mut s) => s.push('a'),
-   |              -----
-   |              |
-   |              data moved here
-   |              move occurs because `s` has type `String`, which does not implement the `Copy` trait
+   |              ----- data moved here because `s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2021.stderr
index 6391619fddf0..ba1654c64d92 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2021.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2021.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       -     ^^^^^^^^^^^^^^^^^^^
    |                       |
-   |                       data moved here
-   |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |                       data moved here because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr
index 1106342e62e4..102d44e7b523 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr
@@ -4,8 +4,7 @@ error[E0508]: cannot move out of type `[&mut i32; 1]`, a non-copy array
 LL |     let [&x] = &[&mut 0];
    |           -    ^^^^^^^^^ cannot move out of here
    |           |
-   |           data moved here
-   |           move occurs because `x` has type `&mut i32`, which does not implement the `Copy` trait
+   |           data moved here because `x` has type `&mut i32`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -18,8 +17,7 @@ error[E0508]: cannot move out of type `[&mut i32; 1]`, a non-copy array
 LL |     let [&x] = &mut [&mut 0];
    |           -    ^^^^^^^^^^^^^ cannot move out of here
    |           |
-   |           data moved here
-   |           move occurs because `x` has type `&mut i32`, which does not implement the `Copy` trait
+   |           data moved here because `x` has type `&mut i32`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
@@ -32,8 +30,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       -     ^^^^^^^^^^^^^^^^^^^
    |                       |
-   |                       data moved here
-   |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |                       data moved here because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -69,8 +66,7 @@ error[E0508]: cannot move out of type `[&mut i32; 1]`, a non-copy array
 LL |     let [&mut x] = &mut [&mut 0];
    |               -    ^^^^^^^^^^^^^ cannot move out of here
    |               |
-   |               data moved here
-   |               move occurs because `x` has type `&mut i32`, which does not implement the `Copy` trait
+   |               data moved here because `x` has type `&mut i32`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr
index ac84fdf7f95f..f9e61394cb51 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr
@@ -36,8 +36,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       -     ^^^^^^^^^^^^^^^^^^^
    |                       |
-   |                       data moved here
-   |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |                       data moved here because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2021.stderr
index 0e431326cb91..ac53c0dc89f8 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2021.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2021.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       -     ^^^^^^^^^^^^^^^^^^^
    |                       |
-   |                       data moved here
-   |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |                       data moved here because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
index 0e431326cb91..ac53c0dc89f8 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let Some(&Some(x)) = Some(&Some(&mut 0)) {
    |                       -     ^^^^^^^^^^^^^^^^^^^
    |                       |
-   |                       data moved here
-   |                       move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+   |                       data moved here because `x` has type `&mut u32`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/pin-ergonomics/pin-pattern.stderr b/tests/ui/pin-ergonomics/pin-pattern.stderr
index 49f7a396f3ce..c0e8b2d40c70 100644
--- a/tests/ui/pin-ergonomics/pin-pattern.stderr
+++ b/tests/ui/pin-ergonomics/pin-pattern.stderr
@@ -91,8 +91,7 @@ error[E0507]: cannot move out of `foo_mut.pointer` which is behind a mutable ref
 LL |     let &pin mut Foo(x) = foo_mut;
    |                      -    ^^^^^^^
    |                      |
-   |                      data moved here
-   |                      move occurs because `x` has type `T`, which does not implement the `Copy` trait
+   |                      data moved here because `x` has type `T`, which does not implement the `Copy` trait
    |
 help: consider removing the pinned mutable borrow
    |
@@ -106,8 +105,7 @@ error[E0507]: cannot move out of `foo_const.pointer` which is behind a shared re
 LL |     let &pin const Foo(x) = foo_const;
    |                        -    ^^^^^^^^^
    |                        |
-   |                        data moved here
-   |                        move occurs because `x` has type `T`, which does not implement the `Copy` trait
+   |                        data moved here because `x` has type `T`, which does not implement the `Copy` trait
    |
 help: consider removing the pinned borrow
    |
@@ -138,8 +136,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     ((&pin mut x,),): &'a pin mut (&'a mut (&'a pin mut Foo<T>,),),
    |     ^^^^^^^^^^^-^^^^
    |                |
-   |                data moved here
-   |                move occurs because `x` has type `Foo<T>`, which does not implement the `Copy` trait
+   |                data moved here because `x` has type `Foo<T>`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
index 8f720daf11ee..48aba17db3c2 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     for (n, mut m) in &tups {
    |             -----     ^^^^^
    |             |
-   |             data moved here
-   |             move occurs because `m` has type `Foo`, which does not implement the `Copy` trait
+   |             data moved here because `m` has type `Foo`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr b/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
index 99409dfd5c5e..03f02223165d 100644
--- a/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
+++ b/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
@@ -9,8 +9,7 @@ LL |     consume_fn(|| {
 LL |         let X(_t) = x;
    |               --    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -34,8 +33,7 @@ LL |     consume_fn(|| {
 LL |         if let Either::One(_t) = e { }
    |                            --    ^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -59,8 +57,7 @@ LL |     consume_fn(|| {
 LL |         while let Either::One(_t) = e { }
    |                               --    ^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -85,10 +82,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t)
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -113,10 +107,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t) => (),
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -140,8 +131,7 @@ LL |     consume_fn(|| {
 LL |         let X(mut _t) = x;
    |               ------    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -165,8 +155,7 @@ LL |     consume_fn(|| {
 LL |         if let Either::One(mut _t) = em { }
    |                            ------    ^^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -190,8 +179,7 @@ LL |     consume_fn(|| {
 LL |         while let Either::One(mut _t) = em { }
    |                               ------    ^^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -216,10 +204,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t)
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -244,10 +229,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t) => (),
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:14:18
@@ -270,8 +252,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         let X(_t) = x;
    |               --    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -295,8 +276,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         if let Either::One(_t) = e { }
    |                            --    ^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -320,8 +300,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         while let Either::One(_t) = e { }
    |                               --    ^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -346,10 +325,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t)
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -374,10 +350,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t) => (),
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -401,8 +374,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         let X(mut _t) = x;
    |               ------    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -426,8 +398,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         if let Either::One(mut _t) = em { }
    |                            ------    ^^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -451,8 +422,7 @@ LL |     <() as T>::consume_fn(|| {
 LL |         while let Either::One(mut _t) = em { }
    |                               ------    ^^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -477,10 +447,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t)
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -505,10 +472,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t) => (),
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:40:22
@@ -531,8 +495,7 @@ LL |     ().method_consume_fn(|| {
 LL |         let X(_t) = x;
    |               --    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -556,8 +519,7 @@ LL |     ().method_consume_fn(|| {
 LL |         if let Either::One(_t) = e { }
    |                            --    ^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -581,8 +543,7 @@ LL |     ().method_consume_fn(|| {
 LL |         while let Either::One(_t) = e { }
    |                               --    ^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -607,10 +568,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t)
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -635,10 +593,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t) => (),
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -662,8 +617,7 @@ LL |     ().method_consume_fn(|| {
 LL |         let X(mut _t) = x;
    |               ------    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -687,8 +641,7 @@ LL |     ().method_consume_fn(|| {
 LL |         if let Either::One(mut _t) = em { }
    |                            ------    ^^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -712,8 +665,7 @@ LL |     ().method_consume_fn(|| {
 LL |         while let Either::One(mut _t) = em { }
    |                               ------    ^^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -738,10 +690,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t)
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -766,10 +715,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t) => (),
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:51:29
@@ -792,8 +738,7 @@ LL |     consume_fnmut(|| {
 LL |         let X(_t) = x;
    |               --    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -817,8 +762,7 @@ LL |     consume_fnmut(|| {
 LL |         if let Either::One(_t) = e { }
    |                            --    ^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -842,8 +786,7 @@ LL |     consume_fnmut(|| {
 LL |         while let Either::One(_t) = e { }
    |                               --    ^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -868,10 +811,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t)
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -896,10 +836,7 @@ LL |         match e {
    |               ^
 ...
 LL |             Either::One(_t) => (),
-   |                         --
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -923,8 +860,7 @@ LL |     consume_fnmut(|| {
 LL |         let X(mut _t) = x;
    |               ------    ^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -948,8 +884,7 @@ LL |     consume_fnmut(|| {
 LL |         if let Either::One(mut _t) = em { }
    |                            ------    ^^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -973,8 +908,7 @@ LL |     consume_fnmut(|| {
 LL |         while let Either::One(mut _t) = em { }
    |                               ------    ^^
    |                               |
-   |                               data moved here
-   |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                               data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -999,10 +933,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t)
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -1027,10 +958,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t) => (),
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
@@ -1055,10 +983,7 @@ LL |         match em {
    |               ^^
 ...
 LL |             Either::One(mut _t) => (),
-   |                         ------
-   |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         ------ data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:26:21
diff --git a/tests/ui/suggestions/dont-suggest-ref/simple.stderr b/tests/ui/suggestions/dont-suggest-ref/simple.stderr
index 41571bf9b2ca..8e7582fbe588 100644
--- a/tests/ui/suggestions/dont-suggest-ref/simple.stderr
+++ b/tests/ui/suggestions/dont-suggest-ref/simple.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of `s` which is behind a shared reference
 LL |     let X(_t) = *s;
    |           --    ^^
    |           |
-   |           data moved here
-   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |           data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -19,8 +18,7 @@ error[E0507]: cannot move out of `r` as enum variant `One` which is behind a sha
 LL |     if let Either::One(_t) = *r { }
    |                        --    ^^
    |                        |
-   |                        data moved here
-   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                        data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -34,8 +32,7 @@ error[E0507]: cannot move out of `r` as enum variant `One` which is behind a sha
 LL |     while let Either::One(_t) = *r { }
    |                           --    ^^
    |                           |
-   |                           data moved here
-   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                           data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -50,10 +47,7 @@ LL |     match *r {
    |           ^^
 ...
 LL |         Either::One(_t)
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -68,10 +62,7 @@ LL |     match *r {
    |           ^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -85,8 +76,7 @@ error[E0507]: cannot move out of `sm` which is behind a mutable reference
 LL |     let X(_t) = *sm;
    |           --    ^^^
    |           |
-   |           data moved here
-   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |           data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -100,8 +90,7 @@ error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mu
 LL |     if let Either::One(_t) = *rm { }
    |                        --    ^^^
    |                        |
-   |                        data moved here
-   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                        data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -115,8 +104,7 @@ error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mu
 LL |     while let Either::One(_t) = *rm { }
    |                           --    ^^^
    |                           |
-   |                           data moved here
-   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                           data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -131,10 +119,7 @@ LL |     match *rm {
    |           ^^^
 ...
 LL |         Either::One(_t)
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -149,10 +134,7 @@ LL |     match *rm {
    |           ^^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -167,10 +149,7 @@ LL |     match *rm {
    |           ^^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the dereference here
    |
@@ -184,8 +163,7 @@ error[E0507]: cannot move out of index of `Vec<X>`
 LL |     let X(_t) = vs[0];
    |           --    ^^^^^
    |           |
-   |           data moved here
-   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |           data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -198,8 +176,7 @@ error[E0507]: cannot move out of index of `Vec<Either>`
 LL |     if let Either::One(_t) = vr[0] { }
    |                        --    ^^^^^
    |                        |
-   |                        data moved here
-   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                        data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -212,8 +189,7 @@ error[E0507]: cannot move out of index of `Vec<Either>`
 LL |     while let Either::One(_t) = vr[0] { }
    |                           --    ^^^^^
    |                           |
-   |                           data moved here
-   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                           data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -227,10 +203,7 @@ LL |     match vr[0] {
    |           ^^^^^
 ...
 LL |         Either::One(_t)
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -244,10 +217,7 @@ LL |     match vr[0] {
    |           ^^^^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -260,8 +230,7 @@ error[E0507]: cannot move out of index of `Vec<X>`
 LL |     let X(_t) = vsm[0];
    |           --    ^^^^^^
    |           |
-   |           data moved here
-   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |           data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -274,8 +243,7 @@ error[E0507]: cannot move out of index of `Vec<Either>`
 LL |     if let Either::One(_t) = vrm[0] { }
    |                        --    ^^^^^^
    |                        |
-   |                        data moved here
-   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                        data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -288,8 +256,7 @@ error[E0507]: cannot move out of index of `Vec<Either>`
 LL |     while let Either::One(_t) = vrm[0] { }
    |                           --    ^^^^^^
    |                           |
-   |                           data moved here
-   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                           data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -303,10 +270,7 @@ LL |     match vrm[0] {
    |           ^^^^^^
 ...
 LL |         Either::One(_t)
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -320,10 +284,7 @@ LL |     match vrm[0] {
    |           ^^^^^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -337,10 +298,7 @@ LL |     match vrm[0] {
    |           ^^^^^^
 ...
 LL |         Either::One(_t) => (),
-   |                     --
-   |                     |
-   |                     data moved here
-   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                     -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider borrowing here
    |
@@ -353,8 +311,7 @@ error[E0507]: cannot move out of `s` which is behind a shared reference
 LL |     let &X(_t) = s;
    |            --    ^
    |            |
-   |            data moved here
-   |            move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |            data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -368,8 +325,7 @@ error[E0507]: cannot move out of `r` as enum variant `One` which is behind a sha
 LL |     if let &Either::One(_t) = r { }
    |                         --    ^
    |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -383,8 +339,7 @@ error[E0507]: cannot move out of `r` as enum variant `One` which is behind a sha
 LL |     while let &Either::One(_t) = r { }
    |                            --    ^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -399,10 +354,7 @@ LL |     match r {
    |           ^
 LL |
 LL |         &Either::One(_t)
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -417,10 +369,7 @@ LL |     match r {
    |           ^
 LL |
 LL |         &Either::One(_t) => (),
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -435,10 +384,7 @@ LL |     match r {
    |           ^
 LL |
 LL |         &Either::One(_t) => (),
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -452,8 +398,7 @@ error[E0507]: cannot move out of `sm` which is behind a mutable reference
 LL |     let &mut X(_t) = sm;
    |                --    ^^
    |                |
-   |                data moved here
-   |                move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |                data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -467,8 +412,7 @@ error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mu
 LL |     if let &mut Either::One(_t) = rm { }
    |                             --    ^^
    |                             |
-   |                             data moved here
-   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                             data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -482,8 +426,7 @@ error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mu
 LL |     while let &mut Either::One(_t) = rm { }
    |                                --    ^^
    |                                |
-   |                                data moved here
-   |                                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                                data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -522,10 +465,7 @@ LL |     match rm {
    |           ^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -540,10 +480,7 @@ LL |     match rm {
    |           ^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -558,10 +495,7 @@ LL |     match rm {
    |           ^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -575,8 +509,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let (&X(_t),) = (&x.clone(),);
    |             --      ^^^^^^^^^^^^^
    |             |
-   |             data moved here
-   |             move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |             data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -590,8 +523,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let (&Either::One(_t),) = (&e.clone(),) { }
    |                          --      ^^^^^^^^^^^^^
    |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -605,8 +537,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     while let (&Either::One(_t),) = (&e.clone(),) { }
    |                             --      ^^^^^^^^^^^^^
    |                             |
-   |                             data moved here
-   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                             data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -621,10 +552,7 @@ LL |     match (&e.clone(),) {
    |           ^^^^^^^^^^^^^
 LL |
 LL |         (&Either::One(_t),)
-   |                       --
-   |                       |
-   |                       data moved here
-   |                       move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                       -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -638,8 +566,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     let (&mut X(_t),) = (&mut xm.clone(),);
    |                 --      ^^^^^^^^^^^^^^^^^^
    |                 |
-   |                 data moved here
-   |                 move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |                 data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -653,8 +580,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
    |                              --      ^^^^^^^^^^^^^^^^^^
    |                              |
-   |                              data moved here
-   |                              move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                              data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -668,8 +594,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
    |                                 --      ^^^^^^^^^^^^^^^^^^
    |                                 |
-   |                                 data moved here
-   |                                 move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                                 data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -707,8 +632,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     let &X(_t) = &x;
    |            --    ^^
    |            |
-   |            data moved here
-   |            move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |            data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -722,8 +646,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     if let &Either::One(_t) = &e { }
    |                         --    ^^
    |                         |
-   |                         data moved here
-   |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                         data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -737,8 +660,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     while let &Either::One(_t) = &e { }
    |                            --    ^^
    |                            |
-   |                            data moved here
-   |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                            data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -753,10 +675,7 @@ LL |     match &e {
    |           ^^
 LL |
 LL |         &Either::One(_t)
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -771,10 +690,7 @@ LL |     match &e {
    |           ^^
 LL |
 LL |         &Either::One(_t) => (),
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -789,10 +705,7 @@ LL |     match &e {
    |           ^^
 LL |
 LL |         &Either::One(_t) => (),
-   |                      --
-   |                      |
-   |                      data moved here
-   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                      -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -806,8 +719,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     let &mut X(_t) = &mut xm;
    |                --    ^^^^^^^
    |                |
-   |                data moved here
-   |                move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |                data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -821,8 +733,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     if let &mut Either::One(_t) = &mut em { }
    |                             --    ^^^^^^^
    |                             |
-   |                             data moved here
-   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                             data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -836,8 +747,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     while let &mut Either::One(_t) = &mut em { }
    |                                --    ^^^^^^^
    |                                |
-   |                                data moved here
-   |                                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                                data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -852,10 +762,7 @@ LL |     match &mut em {
    |           ^^^^^^^
 LL |
 LL |         &mut Either::One(_t)
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -870,10 +777,7 @@ LL |     match &mut em {
    |           ^^^^^^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -888,10 +792,7 @@ LL |     match &mut em {
    |           ^^^^^^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -906,10 +807,7 @@ LL |     match &mut em {
    |           ^^^^^^^
 LL |
 LL |         &mut Either::One(_t) => (),
-   |                          --
-   |                          |
-   |                          data moved here
-   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
+   |                          -- data moved here because `_t` has type `X`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -923,8 +821,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     fn f1(&X(_t): &X) { }
    |           ^^^--^
    |              |
-   |              data moved here
-   |              move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |              data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -938,8 +835,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     fn f2(&mut X(_t): &mut X) { }
    |           ^^^^^^^--^
    |                  |
-   |                  data moved here
-   |                  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |                  data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -953,8 +849,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     fn f3((&X(_t),): (&X,)) { }
    |           ^^^^--^^^
    |               |
-   |               data moved here
-   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |               data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -968,8 +863,7 @@ error[E0507]: cannot move out of a mutable reference
 LL |     fn f4((&mut X(_t),): (&mut X,)) { }
    |           ^^^^^^^^--^^^
    |                   |
-   |                   data moved here
-   |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
+   |                   data moved here because `_t` has type `Y`, which does not implement the `Copy` trait
    |
 help: consider removing the mutable borrow
    |
@@ -983,8 +877,7 @@ error[E0507]: cannot move out of `a.a` as enum variant `Some` which is behind a
 LL |     let Some(_s) = a.a else {
    |              --    ^^^
    |              |
-   |              data moved here
-   |              move occurs because `_s` has type `String`, which does not implement the `Copy` trait
+   |              data moved here because `_s` has type `String`, which does not implement the `Copy` trait
    |
 help: consider borrowing the pattern binding
    |
diff --git a/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr b/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr
index 62f24324fcc1..89ce53bf5476 100644
--- a/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr
+++ b/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr
@@ -4,8 +4,7 @@ error[E0507]: cannot move out of `tuple.0` which is behind a shared reference
 LL |     (b,) = *tuple;
    |      -     ^^^^^^
    |      |
-   |      data moved here
-   |      move occurs because the place has type `NonCopy`, which does not implement the `Copy` trait
+   |      data moved here because the place has type `NonCopy`, which does not implement the `Copy` trait
    |
 note: if `NonCopy` implemented `Clone`, you could clone the value
   --> $DIR/non_copy_move_out_of_tuple.rs:3:1
diff --git a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
index c93570c579ee..2546634c6cad 100644
--- a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
+++ b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
@@ -5,10 +5,7 @@ LL |     match (a, b) {
    |           ^^^^^^
 LL |
 LL |         (None, &c) => &c.unwrap(),
-   |                 -
-   |                 |
-   |                 data moved here
-   |                 move occurs because `c` has type `Option<String>`, which does not implement the `Copy` trait
+   |                 - data moved here because `c` has type `Option<String>`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/type-alias-impl-trait/error-tainting-issue-122904.stderr b/tests/ui/type-alias-impl-trait/error-tainting-issue-122904.stderr
index 956ce3e5936b..c5e347e59de7 100644
--- a/tests/ui/type-alias-impl-trait/error-tainting-issue-122904.stderr
+++ b/tests/ui/type-alias-impl-trait/error-tainting-issue-122904.stderr
@@ -16,8 +16,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     with_positive(|&n| ());
    |                    ^-
    |                     |
-   |                     data moved here
-   |                     move occurs because `n` has type `S`, which does not implement the `Copy` trait
+   |                     data moved here because `n` has type `S`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
index e1fdd222ee14..94cd9a312ca1 100644
--- a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
@@ -16,8 +16,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     with_positive(|&n| ());
    |                    ^-
    |                     |
-   |                     data moved here
-   |                     move occurs because `n` has type `S`, which does not implement the `Copy` trait
+   |                     data moved here because `n` has type `S`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
index 8b5dc950afdd..dc282f30b45b 100644
--- a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
@@ -16,8 +16,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     with_positive(|&n| ());
    |                    ^-
    |                     |
-   |                     data moved here
-   |                     move occurs because `n` has type `S`, which does not implement the `Copy` trait
+   |                     data moved here because `n` has type `S`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |
@@ -31,8 +30,7 @@ error[E0507]: cannot move out of a shared reference
 LL |     with_positive(|&a| ());
    |                    ^-
    |                     |
-   |                     data moved here
-   |                     move occurs because `a` has type `S`, which does not implement the `Copy` trait
+   |                     data moved here because `a` has type `S`, which does not implement the `Copy` trait
    |
 help: consider removing the borrow
    |

From cd09c1a326a6989c8b6e1fbefbe62510365b88d7 Mon Sep 17 00:00:00 2001
From: guoyu <guoyu0730@gmail.com>
Date: Tue, 10 Mar 2026 21:46:14 +0800
Subject: [PATCH 0302/1059] fix: handle multi-byte UTF-8 identifiers in
 `NameGenerator::suggest_name`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`split_numeric_suffix` used `rfind` to locate the last non-numeric
character and then split at `pos + 1`. Since `rfind` returns a byte
offset, this panics when the last non-numeric character is multi-byte
(e.g. CJK identifiers like `日本語`).

Use `str::ceil_char_boundary` to advance past the full character before
splitting.
---
 .../ide-db/src/syntax_helpers/suggest_name.rs      | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
index 5d1e876ea298..3a785fbe80a0 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
@@ -89,6 +89,12 @@
 ///
 /// assert_eq!(generator.suggest_name("b2"), "b2");
 /// assert_eq!(generator.suggest_name("b"), "b3");
+///
+/// // Multi-byte UTF-8 identifiers (e.g. CJK) are handled correctly
+/// assert_eq!(generator.suggest_name("日本語"), "日本語");
+/// assert_eq!(generator.suggest_name("日本語"), "日本語1");
+/// assert_eq!(generator.suggest_name("données3"), "données3");
+/// assert_eq!(generator.suggest_name("données"), "données4");
 /// ```
 #[derive(Debug, Default)]
 pub struct NameGenerator {
@@ -262,11 +268,15 @@ fn insert(&mut self, name: &str) {
     /// Remove the numeric suffix from the name
     ///
     /// # Examples
-    /// `a1b2c3` -> `a1b2c`
+    /// `a1b2c3` -> (`a1b2c`, Some(3))
     fn split_numeric_suffix(name: &str) -> (&str, Option<usize>) {
         let pos =
             name.rfind(|c: char| !c.is_numeric()).expect("Name cannot be empty or all-numeric");
-        let (prefix, suffix) = name.split_at(pos + 1);
+        // `rfind` returns the byte offset of the matched character, which may be
+        // multi-byte (e.g. CJK identifiers). Use `ceil_char_boundary` to advance
+        // past the full character to the next valid split point.
+        let split = name.ceil_char_boundary(pos + 1);
+        let (prefix, suffix) = name.split_at(split);
         (prefix, suffix.parse().ok())
     }
 }

From 40ac87e2995d3ccfea94bc02741069750b1c166c Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Tue, 10 Mar 2026 13:51:41 +0000
Subject: [PATCH 0303/1059] Mark an unreachable match arm as such

Synchronize which elements have code paths and which are unreachable betwen def collector and build reduced graph
---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 4 +++-
 compiler/rustc_resolve/src/def_collector.rs       | 5 ++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index a280acc0d51d..80538aebf5f6 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -1474,7 +1474,9 @@ fn visit_assoc_item(&mut self, item: &'a AssocItem, ctxt: AssocCtxt) {
                 return;
             }
 
-            AssocItemKind::DelegationMac(..) => bug!(),
+            AssocItemKind::DelegationMac(..) => {
+                span_bug!(item.span, "delegation mac should already have been removed")
+            }
         };
         let vis = self.resolve_visibility(&item.vis);
         let feed = self.r.feed(item.id);
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 81820e049716..de36f01b6d0e 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -358,9 +358,12 @@ fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) {
                 },
             ),
             AssocItemKind::Type(box TyAlias { ident, .. }) => (*ident, DefKind::AssocTy),
-            AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => {
+            AssocItemKind::MacCall(..) => {
                 return self.visit_macro_invoc(i.id);
             }
+            AssocItemKind::DelegationMac(..) => {
+                span_bug!(i.span, "degation mac invoc should have already been handled")
+            }
         };
 
         let def = self.create_def(i.id, Some(ident.name), def_kind, i.span);

From de351814b37907ccadf3cb503218b340698e394d Mon Sep 17 00:00:00 2001
From: Jakob Koschel <jakobkoschel@google.com>
Date: Tue, 17 Feb 2026 13:53:43 +0000
Subject: [PATCH 0304/1059] Create x86_64-unknown-linux-gnu{m,t}san target
 which enables {M,T}SAN by default

Similar like we've done it for `x86_64-unknown-linux-gnuasan`, in order
to distribute sanitizer instrumented standard libraries without
introducing new rustc flags, this adds a new dedicated target. With the
target, we can distribute the instrumented standard libraries through
a separate rustup component.
---
 compiler/rustc_target/src/spec/mod.rs         |  2 +
 .../targets/x86_64_unknown_linux_gnumsan.rs   | 16 ++++++
 .../targets/x86_64_unknown_linux_gnutsan.rs   | 16 ++++++
 src/bootstrap/src/core/build_steps/llvm.rs    |  2 +
 src/bootstrap/src/core/sanity.rs              |  2 +
 .../host-x86_64/dist-various-2/Dockerfile     |  2 +
 src/doc/rustc/src/SUMMARY.md                  |  2 +
 src/doc/rustc/src/platform-support.md         |  2 +
 .../x86_64-unknown-linux-gnumsan.md           | 56 +++++++++++++++++++
 .../x86_64-unknown-linux-gnutsan.md           | 56 +++++++++++++++++++
 tests/assembly-llvm/targets/targets-elf.rs    |  6 ++
 11 files changed, 162 insertions(+)
 create mode 100644 compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnumsan.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnutsan.rs
 create mode 100644 src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnumsan.md
 create mode 100644 src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnutsan.md

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 77cc6dd1036c..6682361a92fe 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1815,6 +1815,8 @@ fn $module() {
     ("x86_64-pc-cygwin", x86_64_pc_cygwin),
 
     ("x86_64-unknown-linux-gnuasan", x86_64_unknown_linux_gnuasan),
+    ("x86_64-unknown-linux-gnumsan", x86_64_unknown_linux_gnumsan),
+    ("x86_64-unknown-linux-gnutsan", x86_64_unknown_linux_gnutsan),
 }
 
 /// Cow-Vec-Str: Cow<'static, [Cow<'static, str>]>
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnumsan.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnumsan.rs
new file mode 100644
index 000000000000..377aae8bf073
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnumsan.rs
@@ -0,0 +1,16 @@
+use crate::spec::{SanitizerSet, Target, TargetMetadata};
+
+pub(crate) fn target() -> Target {
+    let mut base = super::x86_64_unknown_linux_gnu::target();
+    base.metadata = TargetMetadata {
+        description: Some(
+            "64-bit Linux (kernel 3.2+, glibc 2.17+) with MSAN enabled by default".into(),
+        ),
+        tier: Some(2),
+        host_tools: Some(false),
+        std: Some(true),
+    };
+    base.supported_sanitizers = SanitizerSet::MEMORY;
+    base.default_sanitizers = SanitizerSet::MEMORY;
+    base
+}
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnutsan.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnutsan.rs
new file mode 100644
index 000000000000..bbe377ca74a6
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnutsan.rs
@@ -0,0 +1,16 @@
+use crate::spec::{SanitizerSet, Target, TargetMetadata};
+
+pub(crate) fn target() -> Target {
+    let mut base = super::x86_64_unknown_linux_gnu::target();
+    base.metadata = TargetMetadata {
+        description: Some(
+            "64-bit Linux (kernel 3.2+, glibc 2.17+) with TSAN enabled by default".into(),
+        ),
+        tier: Some(2),
+        host_tools: Some(false),
+        std: Some(true),
+    };
+    base.supported_sanitizers = SanitizerSet::THREAD;
+    base.default_sanitizers = SanitizerSet::THREAD;
+    base
+}
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index 0c607cb6ba6f..d7480fe08e46 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -1552,6 +1552,8 @@ fn supported_sanitizers(
             &["asan", "dfsan", "lsan", "msan", "safestack", "tsan", "rtsan"],
         ),
         "x86_64-unknown-linux-gnuasan" => common_libs("linux", "x86_64", &["asan"]),
+        "x86_64-unknown-linux-gnumsan" => common_libs("linux", "x86_64", &["msan"]),
+        "x86_64-unknown-linux-gnutsan" => common_libs("linux", "x86_64", &["tsan"]),
         "x86_64-unknown-linux-musl" => {
             common_libs("linux", "x86_64", &["asan", "lsan", "msan", "tsan"])
         }
diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index ca8af279b92b..c4a6b68aedee 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -37,6 +37,8 @@ pub struct Finder {
 /// when the newly-bumped stage 0 compiler now knows about the formerly-missing targets.
 const STAGE0_MISSING_TARGETS: &[&str] = &[
     // just a dummy comment so the list doesn't get onelined
+    "x86_64-unknown-linux-gnumsan",
+    "x86_64-unknown-linux-gnutsan",
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM
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 dacf3c0db202..b655fe78bf8c 100644
--- a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
@@ -126,6 +126,8 @@ ENV TARGETS=$TARGETS,x86_64-unknown-uefi
 ENV TARGETS=$TARGETS,riscv64gc-unknown-linux-musl
 
 ENV TARGETS_SANITIZERS=x86_64-unknown-linux-gnuasan
+ENV TARGETS_SANITIZERS=$TARGETS_SANITIZERS,x86_64-unknown-linux-gnumsan
+ENV TARGETS_SANITIZERS=$TARGETS_SANITIZERS,x86_64-unknown-linux-gnutsan
 
 # As per https://bugs.launchpad.net/ubuntu/+source/gcc-defaults/+bug/1300211
 # we need asm in the search path for gcc-9 (for gnux32) but not in the search path of the
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 9049828c8b12..cc10f476780c 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -155,5 +155,7 @@
     - [x86_64-unknown-linux-none](platform-support/x86_64-unknown-linux-none.md)
     - [x86_64-unknown-none](platform-support/x86_64-unknown-none.md)
     - [x86_64-unknown-linux-gnuasan](platform-support/x86_64-unknown-linux-gnuasan.md)
+    - [x86_64-unknown-linux-gnumsan](platform-support/x86_64-unknown-linux-gnumsan.md)
+    - [x86_64-unknown-linux-gnutsan](platform-support/x86_64-unknown-linux-gnutsan.md)
     - [xtensa-\*-none-elf](platform-support/xtensa.md)
     - [\*-nuttx-\*](platform-support/nuttx.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index a8b2111a901e..26dd6b31b899 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -216,6 +216,8 @@ target | std | notes
 [`x86_64-fortanix-unknown-sgx`](platform-support/x86_64-fortanix-unknown-sgx.md) | ✓ | [Fortanix ABI] for 64-bit Intel SGX
 [`x86_64-linux-android`](platform-support/android.md) | ✓ | 64-bit x86 Android
 [`x86_64-unknown-linux-gnuasan`](platform-support/x86_64-unknown-linux-gnuasan.md) | ✓ | 64-bit Linux (kernel 3.2+, glibc 2.17+) with ASAN enabled by default
+[`x86_64-unknown-linux-gnumsan`](platform-support/x86_64-unknown-linux-gnumsan.md) | ✓ | 64-bit Linux (kernel 3.2+, glibc 2.17+) with MSAN enabled by default
+[`x86_64-unknown-linux-gnutsan`](platform-support/x86_64-unknown-linux-gnutsan.md) | ✓ | 64-bit Linux (kernel 3.2+, glibc 2.17+) with TSAN enabled by default
 [`x86_64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | 64-bit x86 Fuchsia
 `x86_64-unknown-linux-gnux32` | ✓ | 64-bit Linux (x32 ABI) (kernel 4.15+, glibc 2.27)
 [`x86_64-unknown-none`](platform-support/x86_64-unknown-none.md) | * | Freestanding/bare-metal x86_64, softfloat
diff --git a/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnumsan.md b/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnumsan.md
new file mode 100644
index 000000000000..3b56436d0a1c
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnumsan.md
@@ -0,0 +1,56 @@
+# `x86_64-unknown-linux-gnumsan`
+
+**Tier: 2**
+
+Target mirroring `x86_64-unknown-linux-gnu` with MemorySanitizer enabled by
+default.
+The goal of this target is to allow shipping MSAN-instrumented standard
+libraries through rustup, enabling a fully instrumented binary without requiring
+nightly features (build-std).
+Once build-std stabilizes, this target is no longer needed and will be removed.
+
+## Target maintainers
+
+- [@jakos-sec](https://github.com/jakos-sec)
+- [@1c3t3a](https://github.com/1c3t3a)
+- [@rust-lang/project-exploit-mitigations][project-exploit-mitigations]
+
+## Requirements
+
+The target is for cross-compilation only. Host tools are not supported, since
+there is no need to have the host tools instrumented with MSAN. std is fully
+supported.
+
+In all other aspects the target is equivalent to `x86_64-unknown-linux-gnu`.
+
+## Building the target
+
+The target can be built by enabling it for a rustc build:
+
+```toml
+[build]
+target = ["x86_64-unknown-linux-gnumsan"]
+```
+
+## Building Rust programs
+
+Rust programs can be compiled by adding this target via rustup:
+
+```sh
+$ rustup target add x86_64-unknown-linux-gnumsan
+```
+
+and then compiling with the target:
+
+```sh
+$ rustc foo.rs --target x86_64-unknown-linux-gnumsan
+```
+
+## Testing
+
+Created binaries will run on Linux without any external requirements.
+
+## Cross-compilation toolchains and C code
+
+The target supports C code and should use the same toolchain target as
+`x86_64-unknown-linux-gnu`.
diff --git a/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnutsan.md b/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnutsan.md
new file mode 100644
index 000000000000..71488f476cd5
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/x86_64-unknown-linux-gnutsan.md
@@ -0,0 +1,56 @@
+# `x86_64-unknown-linux-gnutsan`
+
+**Tier: 2**
+
+Target mirroring `x86_64-unknown-linux-gnu` with ThreadSanitizer enabled by
+default.
+The goal of this target is to allow shipping TSAN-instrumented standard
+libraries through rustup, enabling a fully instrumented binary without requiring
+nightly features (build-std).
+Once build-std stabilizes, this target is no longer needed and will be removed.
+
+## Target maintainers
+
+- [@jakos-sec](https://github.com/jakos-sec)
+- [@1c3t3a](https://github.com/1c3t3a)
+- [@rust-lang/project-exploit-mitigations][project-exploit-mitigations]
+
+## Requirements
+
+The target is for cross-compilation only. Host tools are not supported, since
+there is no need to have the host tools instrumented with TSAN. std is fully
+supported.
+
+In all other aspects the target is equivalent to `x86_64-unknown-linux-gnu`.
+
+## Building the target
+
+The target can be built by enabling it for a rustc build:
+
+```toml
+[build]
+target = ["x86_64-unknown-linux-gnutsan"]
+```
+
+## Building Rust programs
+
+Rust programs can be compiled by adding this target via rustup:
+
+```sh
+$ rustup target add x86_64-unknown-linux-gnutsan
+```
+
+and then compiling with the target:
+
+```sh
+$ rustc foo.rs --target x86_64-unknown-linux-gnutsan
+```
+
+## Testing
+
+Created binaries will run on Linux without any external requirements.
+
+## Cross-compilation toolchains and C code
+
+The target supports C code and should use the same toolchain target as
+`x86_64-unknown-linux-gnu`.
diff --git a/tests/assembly-llvm/targets/targets-elf.rs b/tests/assembly-llvm/targets/targets-elf.rs
index b7deb6686cfe..ce6629b4f27c 100644
--- a/tests/assembly-llvm/targets/targets-elf.rs
+++ b/tests/assembly-llvm/targets/targets-elf.rs
@@ -709,6 +709,12 @@
 //@ revisions: x86_64_unknown_linux_gnuasan
 //@ [x86_64_unknown_linux_gnuasan] compile-flags: --target x86_64-unknown-linux-gnuasan
 //@ [x86_64_unknown_linux_gnuasan] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_linux_gnumsan
+//@ [x86_64_unknown_linux_gnumsan] compile-flags: --target x86_64-unknown-linux-gnumsan
+//@ [x86_64_unknown_linux_gnumsan] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_linux_gnutsan
+//@ [x86_64_unknown_linux_gnutsan] compile-flags: --target x86_64-unknown-linux-gnutsan
+//@ [x86_64_unknown_linux_gnutsan] needs-llvm-components: x86
 //@ revisions: x86_64_unknown_linux_musl
 //@ [x86_64_unknown_linux_musl] compile-flags: --target x86_64-unknown-linux-musl
 //@ [x86_64_unknown_linux_musl] needs-llvm-components: x86

From 8f7af978eec77c7dae8c99b738713e90c9b40a03 Mon Sep 17 00:00:00 2001
From: Albab-Hasan <albabhasan276@gmail.com>
Date: Tue, 10 Mar 2026 21:08:45 +0600
Subject: [PATCH 0305/1059] fix: implement naming convention validation for
 `union` types.

generated with ai assistance (claude sonnet 4.6).
---
 .../hir-ty/src/diagnostics/decl_check.rs      | 96 ++++++++++++++++++-
 .../src/handlers/incorrect_case.rs            | 42 ++++++++
 2 files changed, 134 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
index 29da1b0c513b..0931b859656f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -17,7 +17,7 @@
 
 use hir_def::{
     AdtId, ConstId, EnumId, EnumVariantId, FunctionId, HasModule, ItemContainerId, Lookup,
-    ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, attrs::AttrFlags,
+    ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId, attrs::AttrFlags,
     db::DefDatabase, hir::Pat, item_tree::FieldsShape, signatures::StaticFlags, src::HasSource,
 };
 use hir_expand::{
@@ -77,6 +77,7 @@ pub enum IdentType {
     Structure,
     Trait,
     TypeAlias,
+    Union,
     Variable,
     Variant,
 }
@@ -94,6 +95,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             IdentType::Structure => "Structure",
             IdentType::Trait => "Trait",
             IdentType::TypeAlias => "Type alias",
+            IdentType::Union => "Union",
             IdentType::Variable => "Variable",
             IdentType::Variant => "Variant",
         };
@@ -146,9 +148,7 @@ fn validate_adt(&mut self, adt: AdtId) {
         match adt {
             AdtId::StructId(struct_id) => self.validate_struct(struct_id),
             AdtId::EnumId(enum_id) => self.validate_enum(enum_id),
-            AdtId::UnionId(_) => {
-                // FIXME: Unions aren't yet supported by this validator.
-            }
+            AdtId::UnionId(union_id) => self.validate_union(union_id),
         }
     }
 
@@ -383,6 +383,94 @@ fn validate_struct_fields(&mut self, struct_id: StructId) {
         }
     }
 
+    fn validate_union(&mut self, union_id: UnionId) {
+        // Check the union name.
+        let data = self.db.union_signature(union_id);
+
+        // rustc implementation excuses repr(C) since C unions predominantly don't
+        // use camel case.
+        let has_repr_c = AttrFlags::repr(self.db, union_id.into()).is_some_and(|repr| repr.c());
+        if !has_repr_c {
+            self.create_incorrect_case_diagnostic_for_item_name(
+                union_id,
+                &data.name,
+                CaseType::UpperCamelCase,
+                IdentType::Union,
+            );
+        }
+
+        // Check the field names.
+        self.validate_union_fields(union_id);
+    }
+
+    /// Check incorrect names for union fields.
+    fn validate_union_fields(&mut self, union_id: UnionId) {
+        let data = union_id.fields(self.db);
+        let edition = self.edition(union_id);
+        let mut union_fields_replacements = data
+            .fields()
+            .iter()
+            .filter_map(|(_, field)| {
+                to_lower_snake_case(&field.name.display_no_db(edition).to_smolstr()).map(
+                    |new_name| Replacement {
+                        current_name: field.name.clone(),
+                        suggested_text: new_name,
+                        expected_case: CaseType::LowerSnakeCase,
+                    },
+                )
+            })
+            .peekable();
+
+        // XXX: Only look at sources if we do have incorrect names.
+        if union_fields_replacements.peek().is_none() {
+            return;
+        }
+
+        let union_loc = union_id.lookup(self.db);
+        let union_src = union_loc.source(self.db);
+
+        let Some(union_fields_list) = union_src.value.record_field_list() else {
+            always!(
+                union_fields_replacements.peek().is_none(),
+                "Replacements ({:?}) were generated for a union fields \
+                which had no fields list: {:?}",
+                union_fields_replacements.collect::<Vec<_>>(),
+                union_src
+            );
+            return;
+        };
+        let mut union_fields_iter = union_fields_list.fields();
+        for field_replacement in union_fields_replacements {
+            // We assume that parameters in replacement are in the same order as in the
+            // actual params list, but just some of them (ones that named correctly) are skipped.
+            let field = loop {
+                if let Some(field) = union_fields_iter.next() {
+                    let Some(field_name) = field.name() else {
+                        continue;
+                    };
+                    if field_name.as_name() == field_replacement.current_name {
+                        break field;
+                    }
+                } else {
+                    never!(
+                        "Replacement ({:?}) was generated for a union field \
+                        which was not found: {:?}",
+                        field_replacement,
+                        union_src
+                    );
+                    return;
+                }
+            };
+
+            self.create_incorrect_case_diagnostic_for_ast_node(
+                field_replacement,
+                union_src.file_id,
+                &field,
+                IdentType::Field,
+            );
+        }
+    }
+
     fn validate_enum(&mut self, enum_id: EnumId) {
         // Check the enum name.
         let data = self.db.enum_signature(enum_id);
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
index c47449f2593d..5410f8b58a9a 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
@@ -262,6 +262,48 @@ struct SomeStruct { SomeField: u8 }
         );
     }
 
+    #[test]
+    fn incorrect_union_names() {
+        check_diagnostics(
+            r#"
+union non_camel_case_name { field: u8 }
+   // ^^^^^^^^^^^^^^^^^^^ 💡 warn: Union `non_camel_case_name` should have UpperCamelCase name, e.g. `NonCamelCaseName`
+
+union SCREAMING_CASE { field: u8 }
+   // ^^^^^^^^^^^^^^ 💡 warn: Union `SCREAMING_CASE` should have UpperCamelCase name, e.g. `ScreamingCase`
+"#,
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_camel_cased_acronyms_in_union_name() {
+        check_diagnostics(
+            r#"
+union AABB { field: u8 }
+"#,
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_repr_c_union() {
+        check_diagnostics(
+            r#"
+#[repr(C)]
+union my_union { field: u8 }
+"#,
+        );
+    }
+
+    #[test]
+    fn incorrect_union_field() {
+        check_diagnostics(
+            r#"
+union SomeUnion { SomeField: u8 }
+               // ^^^^^^^^^ 💡 warn: Field `SomeField` should have snake_case name, e.g. `some_field`
+"#,
+        );
+    }
+
     #[test]
     fn incorrect_enum_names() {
         check_diagnostics(

From 4bd7718430143cd3bc071ed33fbfec12eac4a0f9 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Tue, 10 Mar 2026 16:01:31 +0900
Subject: [PATCH 0306/1059] Remove emoji :)

---
 src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
index fc8fe402bfa9..317b7c2564cb 100644
--- a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
+++ b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -110,7 +110,6 @@ Also, using `x` rather than `x.py` is recommended as:
 Notice that this is not absolute.
 For instance, using Nushell in VSCode on Win10,
 typing `x` or `./x` still opens `x.py` in an editor rather than invoking the program.
-:)
 
 In the rest of this guide, we use `x` rather than `x.py` directly.
 The following command:

From 8fc7440ceca81538e9ff23b17cb01da01e440db4 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 10 Mar 2026 16:04:12 +0000
Subject: [PATCH 0307/1059] Fix

---
 example/mini_core.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/mini_core.rs b/example/mini_core.rs
index 5792b85a6245..8f4d0cd217dc 100644
--- a/example/mini_core.rs
+++ b/example/mini_core.rs
@@ -10,7 +10,7 @@
     auto_traits,
     freeze_impls
 )]
-#![cfg_attr(not(all(windows, target_env = "gnu")), thread_local)]
+#![cfg_attr(not(all(windows, target_env = "gnu")), feature(thread_local))]
 #![no_core]
 #![allow(dead_code, internal_features, ambiguous_wide_pointer_comparisons)]
 

From 916d760c47119535dc692c4df14a3b7808c8e67f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Mar 2026 17:14:01 +0100
Subject: [PATCH 0308/1059] Replace `TyCtxt::node_lint` call with
 `TyCtxt::emit_node_lint` in `rustc_codegen_ssa`

---
 compiler/rustc_codegen_ssa/src/mir/block.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index cf643931717b..bf91d6d93883 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1019,10 +1019,9 @@ fn codegen_call_terminator(
                         if let Some(hir_id) =
                             terminator.source_info.scope.lint_root(&self.mir.source_scopes)
                         {
-                            let msg = "tail calling a function marked with `#[track_caller]` has no special effect";
-                            bx.tcx().node_lint(TAIL_CALL_TRACK_CALLER, hir_id, |d| {
-                                _ = d.primary_message(msg).span(fn_span)
-                            });
+                            bx.tcx().emit_node_lint(TAIL_CALL_TRACK_CALLER, hir_id, rustc_errors::DiagDecorator(|d| {
+                                _ = d.primary_message("tail calling a function marked with `#[track_caller]` has no special effect").span(fn_span)
+                            }));
                         }
 
                         let instance = ty::Instance::resolve_for_fn_ptr(

From 944d70ffa19c9812ef68fa16fd7bae03cae72d60 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Mar 2026 17:25:18 +0100
Subject: [PATCH 0309/1059] Replace `TyCtxt::node_lint` call with
 `TyCtxt::emit_node_lint` in `rustc_hir_typeck`

---
 compiler/rustc_hir_typeck/src/method/confirm.rs  | 12 +++++++++---
 tests/ui/imports/ambiguous-trait-in-scope.stderr | 14 +++++++-------
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index 608bc7dffd9c..b90d5b40bec6 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -736,12 +736,18 @@ fn lint_ambiguously_glob_imported_traits(
         let trait_name = self.tcx.item_name(pick.item.container_id(self.tcx));
         let import_span = self.tcx.hir_span_if_local(pick.import_ids[0].to_def_id()).unwrap();
 
-        self.tcx.node_lint(AMBIGUOUS_GLOB_IMPORTED_TRAITS, segment.hir_id, |diag| {
-            diag.primary_message(format!("Use of ambiguously glob imported trait `{trait_name}`"))
+        self.tcx.emit_node_lint(
+            AMBIGUOUS_GLOB_IMPORTED_TRAITS,
+            segment.hir_id,
+            rustc_errors::DiagDecorator(|diag| {
+                diag.primary_message(format!(
+                    "Use of ambiguously glob imported trait `{trait_name}`"
+                ))
                 .span(segment.ident.span)
                 .span_label(import_span, format!("`{trait_name}` imported ambiguously here"))
                 .help(format!("Import `{trait_name}` explicitly"));
-        });
+            }),
+        );
     }
 
     fn upcast(
diff --git a/tests/ui/imports/ambiguous-trait-in-scope.stderr b/tests/ui/imports/ambiguous-trait-in-scope.stderr
index cac1f4bb73fb..9360e104bf24 100644
--- a/tests/ui/imports/ambiguous-trait-in-scope.stderr
+++ b/tests/ui/imports/ambiguous-trait-in-scope.stderr
@@ -7,9 +7,9 @@ LL |     use m2::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
    = note: `#[warn(ambiguous_glob_imported_traits)]` (part of `#[warn(future_incompatible)]`) on by default
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
@@ -49,9 +49,9 @@ LL |     use m2::*;
 LL |     0u8.method2();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 warning: Use of ambiguously glob imported trait `Trait`
   --> $DIR/ambiguous-trait-in-scope.rs:49:9
@@ -62,9 +62,9 @@ LL |     use m2_reexport::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
   --> $DIR/ambiguous-trait-in-scope.rs:51:9
@@ -88,9 +88,9 @@ LL |     use ambig_reexport::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
   --> $DIR/ambiguous-trait-in-scope.rs:58:9
@@ -115,9 +115,9 @@ LL |     use external::m2::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
   --> $DIR/ambiguous-trait-in-scope.rs:66:9
@@ -142,9 +142,9 @@ LL |     use external::m2_reexport::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
   --> $DIR/ambiguous-trait-in-scope.rs:74:9
@@ -168,9 +168,9 @@ LL |     use external::ambig_reexport::*;
 LL |     0u8.method1();
    |         ^^^^^^^
    |
+   = help: Import `Trait` explicitly
    = 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 #147992 <https://github.com/rust-lang/rust/issues/147992>
-   = help: Import `Trait` explicitly
 
 error[E0599]: no method named `method2` found for type `u8` in the current scope
   --> $DIR/ambiguous-trait-in-scope.rs:81:9

From c653287dfae2e41a01cab0d5ff16d257f7b43a14 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Mar 2026 17:28:14 +0100
Subject: [PATCH 0310/1059] Replace `TyCtxt::node_lint` call with
 `TyCtxt::emit_node_lint` in `librustdoc`

---
 src/librustdoc/core.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index bb41758c7a2e..0813816b470a 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -400,16 +400,16 @@ pub(crate) fn run_global_ctxt(
             {}/rustdoc/how-to-write-documentation.html",
             crate::DOC_RUST_LANG_ORG_VERSION
         );
-        tcx.node_lint(
+        tcx.emit_node_lint(
             crate::lint::MISSING_CRATE_LEVEL_DOCS,
             DocContext::as_local_hir_id(tcx, krate.module.item_id).unwrap(),
-            |lint| {
+            rustc_errors::DiagDecorator(|lint| {
                 if let Some(local_def_id) = krate.module.item_id.as_local_def_id() {
                     lint.span(tcx.def_span(local_def_id));
                 }
                 lint.primary_message("no documentation found for this crate's top-level module");
                 lint.help(help);
-            },
+            }),
         );
     }
 

From ff67fd035af41dad9606339f8b6e9d8d029d9759 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Tue, 10 Mar 2026 16:59:52 +0000
Subject: [PATCH 0311/1059] Add test for #109804

Close #109804.
---
 .../suggest-remove-reference-in-where-clause.rs   |  4 ++++
 ...uggest-remove-reference-in-where-clause.stderr | 15 +++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 tests/ui/traits/suggest-remove-reference-in-where-clause.rs
 create mode 100644 tests/ui/traits/suggest-remove-reference-in-where-clause.stderr

diff --git a/tests/ui/traits/suggest-remove-reference-in-where-clause.rs b/tests/ui/traits/suggest-remove-reference-in-where-clause.rs
new file mode 100644
index 000000000000..8e73e04e032f
--- /dev/null
+++ b/tests/ui/traits/suggest-remove-reference-in-where-clause.rs
@@ -0,0 +1,4 @@
+use std::borrow::Borrow;
+pub const F: for<'a> fn(&'a &'static String) -> &'a str = <&'static String as Borrow<str>>::borrow;
+//~^ ERROR E0277
+fn main() {}
diff --git a/tests/ui/traits/suggest-remove-reference-in-where-clause.stderr b/tests/ui/traits/suggest-remove-reference-in-where-clause.stderr
new file mode 100644
index 000000000000..e7e2da92ee02
--- /dev/null
+++ b/tests/ui/traits/suggest-remove-reference-in-where-clause.stderr
@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `&'static String: Borrow<str>` is not satisfied
+  --> $DIR/suggest-remove-reference-in-where-clause.rs:2:60
+   |
+LL | pub const F: for<'a> fn(&'a &'static String) -> &'a str = <&'static String as Borrow<str>>::borrow;
+   |                                                            ^^^^^^^^^^^^^^^ the trait `Borrow<str>` is not implemented for `&'static String`
+   |
+help: consider removing the leading `&`-reference
+   |
+LL - pub const F: for<'a> fn(&'a &'static String) -> &'a str = <&'static String as Borrow<str>>::borrow;
+LL + pub const F: for<'a> fn(&'a &'static String) -> &'a str = <String as Borrow<str>>::borrow;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

From e9d76c811afceb4a76452339a9abb4d986753c4b Mon Sep 17 00:00:00 2001
From: linshuy2 <linshuy2@illinois.edu>
Date: Tue, 10 Mar 2026 15:40:48 +0000
Subject: [PATCH 0312/1059] fix: `match_same_arms` FP with associated consts

---
 clippy_utils/src/consts.rs     |  3 ++-
 tests/ui/match_same_arms.fixed | 16 ++++++++++++++++
 tests/ui/match_same_arms.rs    | 16 ++++++++++++++++
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 19278708a36a..51db6b6b64c7 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -841,7 +841,8 @@ fn fetch_path(&self, qpath: &QPath<'_>, id: HirId) -> Option<ConstValue> {
                     && ty.span.ctxt() == self.ctxt.get()
                     && ty_name.ident.span.ctxt() == self.ctxt.get()
                     && matches!(ty_path.res, Res::PrimTy(_))
-                    && let Some((DefKind::AssocConst { .. }, did)) = self.typeck.type_dependent_def(id) =>
+                    && let Some((DefKind::AssocConst { .. }, did)) = self.typeck.type_dependent_def(id)
+                    && self.tcx.inherent_impl_of_assoc(did).is_some() =>
             {
                 did
             },
diff --git a/tests/ui/match_same_arms.fixed b/tests/ui/match_same_arms.fixed
index 8b16fd3193f5..b0ab833c7835 100644
--- a/tests/ui/match_same_arms.fixed
+++ b/tests/ui/match_same_arms.fixed
@@ -156,3 +156,19 @@ fn issue16678() {
         },
     }
 }
+
+fn issue16698() {
+    trait Foo {
+        const X: u8;
+    }
+    impl Foo for u8 {
+        const X: u8 = 2;
+    }
+    impl Foo for i8 {
+        const X: u8 = 2;
+    }
+    match true {
+        false => u8::X,
+        true => i8::X,
+    };
+}
diff --git a/tests/ui/match_same_arms.rs b/tests/ui/match_same_arms.rs
index 3b2d585c579d..9c7899122afb 100644
--- a/tests/ui/match_same_arms.rs
+++ b/tests/ui/match_same_arms.rs
@@ -165,3 +165,19 @@ fn wrapper(_arg: ()) {
         },
     }
 }
+
+fn issue16698() {
+    trait Foo {
+        const X: u8;
+    }
+    impl Foo for u8 {
+        const X: u8 = 2;
+    }
+    impl Foo for i8 {
+        const X: u8 = 2;
+    }
+    match true {
+        false => u8::X,
+        true => i8::X,
+    };
+}

From 18ebaa9111b46a43477d5e747d859cffc436b70f Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 11 Mar 2026 02:45:19 +0900
Subject: [PATCH 0313/1059] add a regression test for issue 153599

---
 .../stability-implications-non-local-defid.rs | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 tests/ui/delegation/generics/stability-implications-non-local-defid.rs

diff --git a/tests/ui/delegation/generics/stability-implications-non-local-defid.rs b/tests/ui/delegation/generics/stability-implications-non-local-defid.rs
new file mode 100644
index 000000000000..f8b7874f2806
--- /dev/null
+++ b/tests/ui/delegation/generics/stability-implications-non-local-defid.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+#![feature(staged_api)]
+#![unstable(feature = "foo", issue = "none")]
+
+pub mod m {
+    #[unstable(feature = "foo", issue = "none")]
+    pub struct W<I, F> {
+        pub inner: std::iter::Map<I, F>,
+    }
+
+    #[unstable(feature = "foo", issue = "none")]
+    impl<B, I: Iterator, F: FnMut(I::Item) -> B> Iterator for W<I, F> {
+        type Item = B;
+        reuse Iterator::{next, fold} { self.inner }
+    }
+}
+
+fn main() {}

From 005a1eddd724bd6d3e01f66497b42164052e17ea Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Tue, 10 Mar 2026 17:43:34 +0000
Subject: [PATCH 0314/1059] internal: Fix test_loading_rust_analyzer when
 rust-project.json is present

load_workspace_at() looks at parent directories. If rust-analyzer is
in a directory (e.g. a monorepo) where a parent directory contains a
rust-project.json, that configuration wins over the Cargo.toml and the
test fails.

One easy way of testing this is deliberately writing an invalid JSON
file to the parent directory.

```
$ echo '{' > ../rust-project.json
$ cargo t -p load-cargo
---- tests::test_loading_rust_analyzer stdout ----

thread 'tests::test_loading_rust_analyzer' (38576150) panicked at crates/load-cargo/src/lib.rs:756:81:
called `Result::unwrap()` on an `Err` value: Failed to load the project at /Users/wilfred/src/rust-project.json

Caused by:
    0: Failed to deserialize json file /Users/wilfred/src/rust-project.json
    1: EOF while parsing an object at line 2 column 0
```

Instead, explicitly load the cargo workspace so the presence of a
rust-project.json never changes the result of the test.

AI disclosure: Written with help from Claude.
---
 .../rust-analyzer/crates/load-cargo/src/lib.rs      | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
index 95fcfce29127..83b1d1cd7a46 100644
--- a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
@@ -744,7 +744,15 @@ mod tests {
 
     #[test]
     fn test_loading_rust_analyzer() {
-        let path = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
+        let cargo_toml_path = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("Cargo.toml");
+        let cargo_toml_path = AbsPathBuf::assert_utf8(cargo_toml_path);
+        let manifest = ProjectManifest::from_manifest_file(cargo_toml_path).unwrap();
+
         let cargo_config = CargoConfig { set_test: true, ..CargoConfig::default() };
         let load_cargo_config = LoadCargoConfig {
             load_out_dirs_from_check: false,
@@ -752,8 +760,9 @@ fn test_loading_rust_analyzer() {
             prefill_caches: false,
             proc_macro_processes: 1,
         };
+        let workspace = ProjectWorkspace::load(manifest, &cargo_config, &|_| {}).unwrap();
         let (db, _vfs, _proc_macro) =
-            load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {}).unwrap();
+            load_workspace(workspace, &cargo_config.extra_env, &load_cargo_config).unwrap();
 
         let n_crates = db.all_crates().len();
         // RA has quite a few crates, but the exact count doesn't matter

From 32a35bcb426d433f84b7d0ba816bcee61cd889b4 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@ferrous-systems.com>
Date: Tue, 10 Mar 2026 19:12:12 +0100
Subject: [PATCH 0315/1059] Remove outdated comment

---
 src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs b/src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs
index 92ddd7fa8b07..424655ed651b 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/fixup.rs
@@ -208,7 +208,6 @@ pub(crate) fn fixup_syntax(
                         ]);
                     }
                 },
-                // FIXME: foo::
                 ast::MatchExpr(it) => {
                     if it.expr().is_none() {
                         let match_token = match it.match_token() {

From ce2de643fc94a687f8fc2ba89495fa754bd87624 Mon Sep 17 00:00:00 2001
From: "LevitatingBusinessMan (Rein Fernhout)" <me@levitati.ng>
Date: Tue, 10 Mar 2026 19:21:19 +0100
Subject: [PATCH 0316/1059] assign mpsc_is_disconnected issue 153668

---
 library/std/src/sync/mpsc.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sync/mpsc.rs b/library/std/src/sync/mpsc.rs
index 2abf7bfe341d..a1c49bb83010 100644
--- a/library/std/src/sync/mpsc.rs
+++ b/library/std/src/sync/mpsc.rs
@@ -626,7 +626,7 @@ pub fn send(&self, t: T) -> Result<(), SendError<T>> {
     /// drop(rx);
     /// assert!(tx.is_disconnected());
     /// ```
-    #[unstable(feature = "mpsc_is_disconnected", issue = "none")]
+    #[unstable(feature = "mpsc_is_disconnected", issue = "153668")]
     pub fn is_disconnected(&self) -> bool {
         self.inner.is_disconnected()
     }
@@ -1080,7 +1080,7 @@ pub fn try_iter(&self) -> TryIter<'_, T> {
     /// drop(tx);
     /// assert!(rx.is_disconnected());
     /// ```
-    #[unstable(feature = "mpsc_is_disconnected", issue = "none")]
+    #[unstable(feature = "mpsc_is_disconnected", issue = "153668")]
     pub fn is_disconnected(&self) -> bool {
         self.inner.is_disconnected()
     }

From d65ddf6dbfcea96052e18a421e8e54b182e0ea9d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Mar 2026 17:28:47 +0100
Subject: [PATCH 0317/1059] Remove `TyCtxt::node_lint` method

---
 compiler/rustc_middle/src/lint.rs       |  1 -
 compiler/rustc_middle/src/ty/context.rs | 16 +---------------
 2 files changed, 1 insertion(+), 16 deletions(-)

diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
index 1c37dd0f82f4..c1496436f20f 100644
--- a/compiler/rustc_middle/src/lint.rs
+++ b/compiler/rustc_middle/src/lint.rs
@@ -487,7 +487,6 @@ fn lint_level_impl(
 /// for example:
 ///
 /// - [`TyCtxt::emit_node_span_lint`]
-/// - [`TyCtxt::node_lint`]
 /// - `LintContext::opt_span_lint`
 ///
 /// This function will replace `lint_level` once all its callers have been replaced
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index a99e685c1308..11f2d575a659 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -55,7 +55,7 @@
 use crate::dep_graph::{DepGraph, DepKindVTable, DepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::infer::canonical::{CanonicalParamEnvCache, CanonicalVarKind};
-use crate::lint::{diag_lint_level, lint_level};
+use crate::lint::diag_lint_level;
 use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
 use crate::middle::resolve_bound_vars;
@@ -2585,20 +2585,6 @@ pub fn emit_node_lint(
         diag_lint_level(self.sess, lint, level, None, decorator);
     }
 
-    /// Emit a lint at the appropriate level for a hir node.
-    ///
-    /// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
-    #[track_caller]
-    pub fn node_lint(
-        self,
-        lint: &'static Lint,
-        id: HirId,
-        decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
-    ) {
-        let level = self.lint_level_at_node(lint, id);
-        lint_level(self.sess, lint, level, None, decorate);
-    }
-
     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx [TraitCandidate<'tcx>]> {
         let map = self.in_scope_traits_map(id.owner)?;
         let candidates = map.get(&id.local_id)?;

From 2765e4a61c88379535cf92699258f4769aa9c1b1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Mar 2026 17:30:18 +0100
Subject: [PATCH 0318/1059] Remove `rustc_middle::lint_level` function

---
 compiler/rustc_lint/src/context.rs |   2 +-
 compiler/rustc_middle/src/lint.rs  | 188 -----------------------------
 2 files changed, 1 insertion(+), 189 deletions(-)

diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index d7a0a02f085a..ecf71f93cf5e 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -514,7 +514,7 @@ pub trait LintContext {
     // set the span in their `decorate` function (preferably using set_span).
     /// Emit a lint at the appropriate level, with an optional associated span.
     ///
-    /// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
+    /// [`diag_lint_level`]: rustc_middle::lint::diag_lint_level#decorate-signature
     #[track_caller]
     fn opt_span_diag_lint<S: Into<MultiSpan>>(
         &self,
diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
index c1496436f20f..f302f18f3b47 100644
--- a/compiler/rustc_middle/src/lint.rs
+++ b/compiler/rustc_middle/src/lint.rs
@@ -293,194 +293,6 @@ fn explain_lint_level_source(
     }
 }
 
-/// The innermost function for emitting lints.
-///
-/// If you are looking to implement a lint, look for higher level functions,
-/// for example:
-/// - [`TyCtxt::emit_node_span_lint`]
-/// - [`TyCtxt::node_lint`]
-/// - `LintContext::opt_span_lint`
-///
-/// ## `decorate`
-///
-/// It is not intended to call `emit`/`cancel` on the `Diag` passed in the `decorate` callback.
-#[track_caller]
-pub fn lint_level(
-    sess: &Session,
-    lint: &'static Lint,
-    level: LevelAndSource,
-    span: Option<MultiSpan>,
-    decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
-) {
-    // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to
-    // the "real" work.
-    #[track_caller]
-    fn lint_level_impl(
-        sess: &Session,
-        lint: &'static Lint,
-        level: LevelAndSource,
-        span: Option<MultiSpan>,
-        decorate: Box<dyn '_ + for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>)>,
-    ) {
-        let LevelAndSource { level, lint_id, src } = level;
-
-        // Check for future incompatibility lints and issue a stronger warning.
-        let future_incompatible = lint.future_incompatible;
-
-        let has_future_breakage = future_incompatible.map_or(
-            // Default allow lints trigger too often for testing.
-            sess.opts.unstable_opts.future_incompat_test && lint.default_level != Level::Allow,
-            |incompat| incompat.report_in_deps,
-        );
-
-        // Convert lint level to error level.
-        let err_level = match level {
-            Level::Allow => {
-                if has_future_breakage {
-                    rustc_errors::Level::Allow
-                } else {
-                    return;
-                }
-            }
-            Level::Expect => {
-                // This case is special as we actually allow the lint itself in this context, but
-                // we can't return early like in the case for `Level::Allow` because we still
-                // need the lint diagnostic to be emitted to `rustc_error::DiagCtxtInner`.
-                //
-                // We can also not mark the lint expectation as fulfilled here right away, as it
-                // can still be cancelled in the decorate function. All of this means that we simply
-                // create a `Diag` and continue as we would for warnings.
-                rustc_errors::Level::Expect
-            }
-            Level::ForceWarn => rustc_errors::Level::ForceWarning,
-            Level::Warn => rustc_errors::Level::Warning,
-            Level::Deny | Level::Forbid => rustc_errors::Level::Error,
-        };
-        let mut err = Diag::new(sess.dcx(), err_level, "");
-        if let Some(span) = span {
-            err.span(span);
-        }
-        if let Some(lint_id) = lint_id {
-            err.lint_id(lint_id);
-        }
-
-        // If this code originates in a foreign macro, aka something that this crate
-        // did not itself author, then it's likely that there's nothing this crate
-        // can do about it. We probably want to skip the lint entirely.
-        if err.span.primary_spans().iter().any(|s| s.in_external_macro(sess.source_map())) {
-            // Any suggestions made here are likely to be incorrect, so anything we
-            // emit shouldn't be automatically fixed by rustfix.
-            err.disable_suggestions();
-
-            // If this is a future incompatible that is not an edition fixing lint
-            // it'll become a hard error, so we have to emit *something*. Also,
-            // if this lint occurs in the expansion of a macro from an external crate,
-            // allow individual lints to opt-out from being reported.
-            let incompatible = future_incompatible.is_some_and(|f| f.reason.edition().is_none());
-
-            // In rustc, for the find_attr macro, we want to always emit this.
-            // This completely circumvents normal lint checking, which usually doesn't happen for macros from other crates.
-            // However, we kind of want that when using find_attr from another rustc crate. So we cheat a little.
-            let is_in_find_attr = sess.enable_internal_lints()
-                && err.span.primary_spans().iter().any(|s| {
-                    s.source_callee().is_some_and(
-                    |i| matches!(i.kind, ExpnKind::Macro(_, name) if name.as_str() == "find_attr")
-                    )
-                });
-
-            if !incompatible && !lint.report_in_external_macro && !is_in_find_attr {
-                err.cancel();
-
-                // Don't continue further, since we don't want to have
-                // `diag_span_note_once` called for a diagnostic that isn't emitted.
-                return;
-            }
-        }
-
-        err.is_lint(lint.name_lower(), has_future_breakage);
-
-        // Lint diagnostics that are covered by the expect level will not be emitted outside
-        // the compiler. It is therefore not necessary to add any information for the user.
-        // This will therefore directly call the decorate function which will in turn emit
-        // the diagnostic.
-        if let Level::Expect = level {
-            decorate(&mut err);
-            err.emit();
-            return;
-        }
-
-        if let Some(future_incompatible) = future_incompatible {
-            let explanation = match future_incompatible.reason {
-                FutureIncompatibilityReason::FutureReleaseError(_) => {
-                    "this was previously accepted by the compiler but is being phased out; \
-                         it will become a hard error in a future release!"
-                        .to_owned()
-                }
-                FutureIncompatibilityReason::FutureReleaseSemanticsChange(_) => {
-                    "this will change its meaning in a future release!".to_owned()
-                }
-                FutureIncompatibilityReason::EditionError(EditionFcw { edition, .. }) => {
-                    let current_edition = sess.edition();
-                    format!(
-                        "this is accepted in the current edition (Rust {current_edition}) but is a hard error in Rust {edition}!"
-                    )
-                }
-                FutureIncompatibilityReason::EditionSemanticsChange(EditionFcw {
-                    edition, ..
-                }) => {
-                    format!("this changes meaning in Rust {edition}")
-                }
-                FutureIncompatibilityReason::EditionAndFutureReleaseError(EditionFcw {
-                    edition,
-                    ..
-                }) => {
-                    format!(
-                        "this was previously accepted by the compiler but is being phased out; \
-                         it will become a hard error in Rust {edition} and in a future release in all editions!"
-                    )
-                }
-                FutureIncompatibilityReason::EditionAndFutureReleaseSemanticsChange(
-                    EditionFcw { edition, .. },
-                ) => {
-                    format!(
-                        "this changes meaning in Rust {edition} and in a future release in all editions!"
-                    )
-                }
-                FutureIncompatibilityReason::Custom(reason, _) => reason.to_owned(),
-                FutureIncompatibilityReason::Unreachable => unreachable!(),
-            };
-
-            if future_incompatible.explain_reason {
-                err.warn(explanation);
-            }
-
-            let citation =
-                format!("for more information, see {}", future_incompatible.reason.reference());
-            err.note(citation);
-        }
-
-        // Finally, run `decorate`. `decorate` can call `trimmed_path_str` (directly or indirectly),
-        // so we need to make sure when we do call `decorate` that the diagnostic is eventually
-        // emitted or we'll get a `must_produce_diag` ICE.
-        //
-        // When is a diagnostic *eventually* emitted? Well, that is determined by 2 factors:
-        // 1. If the corresponding `rustc_errors::Level` is beyond warning, i.e. `ForceWarning(_)`
-        //    or `Error`, then the diagnostic will be emitted regardless of CLI options.
-        // 2. If the corresponding `rustc_errors::Level` is warning, then that can be affected by
-        //    `-A warnings` or `--cap-lints=xxx` on the command line. In which case, the diagnostic
-        //    will be emitted if `can_emit_warnings` is true.
-        let skip = err_level == rustc_errors::Level::Warning && !sess.dcx().can_emit_warnings();
-
-        if !skip {
-            decorate(&mut err);
-        }
-
-        explain_lint_level_source(sess, lint, level, src, &mut err);
-        err.emit()
-    }
-    lint_level_impl(sess, lint, level, span, Box::new(decorate))
-}
-
 /// The innermost function for emitting lints implementing the [`trait@Diagnostic`] trait.
 ///
 /// If you are looking to implement a lint, look for higher level functions,

From 3c3a35213c508eeb7f5e121ad299a135122733ed Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Sat, 7 Mar 2026 13:04:19 -0800
Subject: [PATCH 0319/1059] tests/ui/binop: add annotations for reference rules

---
 tests/ui/binop/augmented-assignment.rs       |  1 +
 tests/ui/binop/binary-minus-without-space.rs |  3 +
 tests/ui/binop/binop-consume-args.rs         |  1 +
 tests/ui/binop/binop-consume-args.stderr     | 80 ++++++++++----------
 tests/ui/binop/binop-move-semantics.rs       |  1 +
 tests/ui/binop/binop-move-semantics.stderr   | 26 +++----
 tests/ui/binop/operator-overloading.rs       |  3 +
 7 files changed, 62 insertions(+), 53 deletions(-)

diff --git a/tests/ui/binop/augmented-assignment.rs b/tests/ui/binop/augmented-assignment.rs
index 755ecb466ceb..a8de7ae1d3fc 100644
--- a/tests/ui/binop/augmented-assignment.rs
+++ b/tests/ui/binop/augmented-assignment.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ reference: expr.arith-logic.behavior
 
 #![allow(unused_imports)]
 #![deny(unused_assignments)]
diff --git a/tests/ui/binop/binary-minus-without-space.rs b/tests/ui/binop/binary-minus-without-space.rs
index c80c0c88fcbc..64243ebbb94e 100644
--- a/tests/ui/binop/binary-minus-without-space.rs
+++ b/tests/ui/binop/binary-minus-without-space.rs
@@ -1,4 +1,7 @@
 //@ run-pass
+//@ reference: expr.arith-logic.syntax
+//@ reference: patterns.literal.syntax
+//@ reference: patterns.literal.intro
 // Check that issue #954 stays fixed
 
 
diff --git a/tests/ui/binop/binop-consume-args.rs b/tests/ui/binop/binop-consume-args.rs
index 8d6c725d7560..1bd803ce4c8f 100644
--- a/tests/ui/binop/binop-consume-args.rs
+++ b/tests/ui/binop/binop-consume-args.rs
@@ -1,3 +1,4 @@
+//@ reference: expr.arith-logic.behavior
 // Test that binary operators consume their arguments
 
 use std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitXor, BitOr, Shl, Shr};
diff --git a/tests/ui/binop/binop-consume-args.stderr b/tests/ui/binop/binop-consume-args.stderr
index d9d92a44766d..2b2bb1062049 100644
--- a/tests/ui/binop/binop-consume-args.stderr
+++ b/tests/ui/binop/binop-consume-args.stderr
@@ -1,5 +1,5 @@
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:7:10
+  --> $DIR/binop-consume-args.rs:8:10
    |
 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -9,7 +9,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:5:8
+  --> $DIR/binop-consume-args.rs:6:8
    |
 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -23,7 +23,7 @@ LL | fn add<A: Add<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:8:10
+  --> $DIR/binop-consume-args.rs:9:10
    |
 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -34,7 +34,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:5:30
+  --> $DIR/binop-consume-args.rs:6:30
    |
 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -46,7 +46,7 @@ LL | fn add<A: Add<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:13:10
+  --> $DIR/binop-consume-args.rs:14:10
    |
 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -56,7 +56,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:11:8
+  --> $DIR/binop-consume-args.rs:12:8
    |
 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -70,7 +70,7 @@ LL | fn sub<A: Sub<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:14:10
+  --> $DIR/binop-consume-args.rs:15:10
    |
 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -81,7 +81,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:11:30
+  --> $DIR/binop-consume-args.rs:12:30
    |
 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -93,7 +93,7 @@ LL | fn sub<A: Sub<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:19:10
+  --> $DIR/binop-consume-args.rs:20:10
    |
 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -103,7 +103,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:17:8
+  --> $DIR/binop-consume-args.rs:18:8
    |
 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -117,7 +117,7 @@ LL | fn mul<A: Mul<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:20:10
+  --> $DIR/binop-consume-args.rs:21:10
    |
 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -128,7 +128,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:17:30
+  --> $DIR/binop-consume-args.rs:18:30
    |
 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -140,7 +140,7 @@ LL | fn mul<A: Mul<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:25:10
+  --> $DIR/binop-consume-args.rs:26:10
    |
 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -150,7 +150,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:23:8
+  --> $DIR/binop-consume-args.rs:24:8
    |
 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -164,7 +164,7 @@ LL | fn div<A: Div<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:26:10
+  --> $DIR/binop-consume-args.rs:27:10
    |
 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -175,7 +175,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:23:30
+  --> $DIR/binop-consume-args.rs:24:30
    |
 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -187,7 +187,7 @@ LL | fn div<A: Div<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:31:10
+  --> $DIR/binop-consume-args.rs:32:10
    |
 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -197,7 +197,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:29:8
+  --> $DIR/binop-consume-args.rs:30:8
    |
 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -211,7 +211,7 @@ LL | fn rem<A: Rem<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:32:10
+  --> $DIR/binop-consume-args.rs:33:10
    |
 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -222,7 +222,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:29:30
+  --> $DIR/binop-consume-args.rs:30:30
    |
 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -234,7 +234,7 @@ LL | fn rem<A: Rem<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:37:10
+  --> $DIR/binop-consume-args.rs:38:10
    |
 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -244,7 +244,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:35:11
+  --> $DIR/binop-consume-args.rs:36:11
    |
 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
    |           ^ consider constraining this type parameter with `Clone`
@@ -258,7 +258,7 @@ LL | fn bitand<A: BitAnd<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                                   ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:38:10
+  --> $DIR/binop-consume-args.rs:39:10
    |
 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                               --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -269,7 +269,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:35:36
+  --> $DIR/binop-consume-args.rs:36:36
    |
 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                    ^ consider constraining this type parameter with `Clone`
@@ -281,7 +281,7 @@ LL | fn bitand<A: BitAnd<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                                     ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:43:10
+  --> $DIR/binop-consume-args.rs:44:10
    |
 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                     --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -291,7 +291,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:41:10
+  --> $DIR/binop-consume-args.rs:42:10
    |
 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
    |          ^ consider constraining this type parameter with `Clone`
@@ -305,7 +305,7 @@ LL | fn bitor<A: BitOr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                                 ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:44:10
+  --> $DIR/binop-consume-args.rs:45:10
    |
 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                             --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -316,7 +316,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:41:34
+  --> $DIR/binop-consume-args.rs:42:34
    |
 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                  ^ consider constraining this type parameter with `Clone`
@@ -328,7 +328,7 @@ LL | fn bitor<A: BitOr<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                                   ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:49:10
+  --> $DIR/binop-consume-args.rs:50:10
    |
 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -338,7 +338,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:47:11
+  --> $DIR/binop-consume-args.rs:48:11
    |
 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
    |           ^ consider constraining this type parameter with `Clone`
@@ -352,7 +352,7 @@ LL | fn bitxor<A: BitXor<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                                   ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:50:10
+  --> $DIR/binop-consume-args.rs:51:10
    |
 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                               --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -363,7 +363,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:47:36
+  --> $DIR/binop-consume-args.rs:48:36
    |
 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                    ^ consider constraining this type parameter with `Clone`
@@ -375,7 +375,7 @@ LL | fn bitxor<A: BitXor<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                                     ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:55:10
+  --> $DIR/binop-consume-args.rs:56:10
    |
 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -385,7 +385,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:53:8
+  --> $DIR/binop-consume-args.rs:54:8
    |
 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -399,7 +399,7 @@ LL | fn shl<A: Shl<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:56:10
+  --> $DIR/binop-consume-args.rs:57:10
    |
 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -410,7 +410,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:53:30
+  --> $DIR/binop-consume-args.rs:54:30
    |
 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
@@ -422,7 +422,7 @@ LL | fn shl<A: Shl<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
    |                               ++++++
 
 error[E0382]: use of moved value: `lhs`
-  --> $DIR/binop-consume-args.rs:61:10
+  --> $DIR/binop-consume-args.rs:62:10
    |
 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
@@ -432,7 +432,7 @@ LL |     drop(lhs);
    |          ^^^ value used here after move
    |
 help: if `A` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:59:8
+  --> $DIR/binop-consume-args.rs:60:8
    |
 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
    |        ^ consider constraining this type parameter with `Clone`
@@ -446,7 +446,7 @@ LL | fn shr<A: Shr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
    |                             ++++++
 
 error[E0382]: use of moved value: `rhs`
-  --> $DIR/binop-consume-args.rs:62:10
+  --> $DIR/binop-consume-args.rs:63:10
    |
 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
@@ -457,7 +457,7 @@ LL |     drop(rhs);
    |          ^^^ value used here after move
    |
 help: if `B` implemented `Clone`, you could clone the value
-  --> $DIR/binop-consume-args.rs:59:30
+  --> $DIR/binop-consume-args.rs:60:30
    |
 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
    |                              ^ consider constraining this type parameter with `Clone`
diff --git a/tests/ui/binop/binop-move-semantics.rs b/tests/ui/binop/binop-move-semantics.rs
index b5133ea7c92a..c49613c02d50 100644
--- a/tests/ui/binop/binop-move-semantics.rs
+++ b/tests/ui/binop/binop-move-semantics.rs
@@ -1,3 +1,4 @@
+//@ reference: expr.arith-logic.behavior
 // Test that move restrictions are enforced on overloaded binary operations
 
 use std::ops::Add;
diff --git a/tests/ui/binop/binop-move-semantics.stderr b/tests/ui/binop/binop-move-semantics.stderr
index 2e661c44abd1..029a94a49452 100644
--- a/tests/ui/binop/binop-move-semantics.stderr
+++ b/tests/ui/binop/binop-move-semantics.stderr
@@ -1,5 +1,5 @@
 error[E0382]: use of moved value: `x`
-  --> $DIR/binop-move-semantics.rs:8:5
+  --> $DIR/binop-move-semantics.rs:9:5
    |
 LL |   fn double_move<T: Add<Output=()>>(x: T) {
    |                                     - move occurs because `x` has type `T`, which does not implement the `Copy` trait
@@ -12,7 +12,7 @@ LL | |     x;
    |       `x` moved due to usage in operator
    |
 help: if `T` implemented `Clone`, you could clone the value
-  --> $DIR/binop-move-semantics.rs:5:16
+  --> $DIR/binop-move-semantics.rs:6:16
    |
 LL | fn double_move<T: Add<Output=()>>(x: T) {
    |                ^ consider constraining this type parameter with `Clone`
@@ -26,7 +26,7 @@ LL | fn double_move<T: Add<Output=()> + Copy>(x: T) {
    |                                  ++++++
 
 error[E0382]: borrow of moved value: `x`
-  --> $DIR/binop-move-semantics.rs:14:5
+  --> $DIR/binop-move-semantics.rs:15:5
    |
 LL | fn move_then_borrow<T: Add<Output=()> + Clone>(x: T) {
    |                                                - move occurs because `x` has type `T`, which does not implement the `Copy` trait
@@ -46,7 +46,7 @@ LL | fn move_then_borrow<T: Add<Output=()> + Clone + Copy>(x: T) {
    |                                               ++++++
 
 error[E0505]: cannot move out of `x` because it is borrowed
-  --> $DIR/binop-move-semantics.rs:21:5
+  --> $DIR/binop-move-semantics.rs:22:5
    |
 LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
    |                                     - binding `x` declared here
@@ -60,7 +60,7 @@ LL |     use_mut(n); use_imm(m);
    |                         - borrow later used here
    |
 help: if `T` implemented `Clone`, you could clone the value
-  --> $DIR/binop-move-semantics.rs:17:18
+  --> $DIR/binop-move-semantics.rs:18:18
    |
 LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
    |                  ^ consider constraining this type parameter with `Clone`
@@ -68,7 +68,7 @@ LL |     let m = &x;
    |              - you could clone this value
 
 error[E0505]: cannot move out of `y` because it is borrowed
-  --> $DIR/binop-move-semantics.rs:23:5
+  --> $DIR/binop-move-semantics.rs:24:5
    |
 LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
    |                                           ----- binding `y` declared here
@@ -82,7 +82,7 @@ LL |     use_mut(n); use_imm(m);
    |             - borrow later used here
    |
 help: if `T` implemented `Clone`, you could clone the value
-  --> $DIR/binop-move-semantics.rs:17:18
+  --> $DIR/binop-move-semantics.rs:18:18
    |
 LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
    |                  ^ consider constraining this type parameter with `Clone`
@@ -91,7 +91,7 @@ LL |     let n = &mut y;
    |                  - you could clone this value
 
 error[E0507]: cannot move out of `*m` which is behind a mutable reference
-  --> $DIR/binop-move-semantics.rs:30:5
+  --> $DIR/binop-move-semantics.rs:31:5
    |
 LL |       *m
    |       -^
@@ -105,7 +105,7 @@ LL | |     *n;
 note: calling this operator moves the left-hand side
   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
 help: if `T` implemented `Clone`, you could clone the value
-  --> $DIR/binop-move-semantics.rs:26:24
+  --> $DIR/binop-move-semantics.rs:27:24
    |
 LL | fn illegal_dereference<T: Add<Output=()>>(mut x: T, y: T) {
    |                        ^ consider constraining this type parameter with `Clone`
@@ -114,13 +114,13 @@ LL |     *m
    |     -- you could clone this value
 
 error[E0507]: cannot move out of `*n` which is behind a shared reference
-  --> $DIR/binop-move-semantics.rs:32:5
+  --> $DIR/binop-move-semantics.rs:33:5
    |
 LL |     *n;
    |     ^^ move occurs because `*n` has type `T`, which does not implement the `Copy` trait
    |
 help: if `T` implemented `Clone`, you could clone the value
-  --> $DIR/binop-move-semantics.rs:26:24
+  --> $DIR/binop-move-semantics.rs:27:24
    |
 LL | fn illegal_dereference<T: Add<Output=()>>(mut x: T, y: T) {
    |                        ^ consider constraining this type parameter with `Clone`
@@ -129,7 +129,7 @@ LL |     *n;
    |     -- you could clone this value
 
 error[E0502]: cannot borrow `f` as immutable because it is also borrowed as mutable
-  --> $DIR/binop-move-semantics.rs:54:5
+  --> $DIR/binop-move-semantics.rs:55:5
    |
 LL |       &mut f
    |       ------
@@ -144,7 +144,7 @@ LL | |     &f;
    |       immutable borrow occurs here
 
 error[E0502]: cannot borrow `f` as mutable because it is also borrowed as immutable
-  --> $DIR/binop-move-semantics.rs:62:5
+  --> $DIR/binop-move-semantics.rs:63:5
    |
 LL |       &f
    |       --
diff --git a/tests/ui/binop/operator-overloading.rs b/tests/ui/binop/operator-overloading.rs
index 7f29856194e0..76a9ed079a09 100644
--- a/tests/ui/binop/operator-overloading.rs
+++ b/tests/ui/binop/operator-overloading.rs
@@ -1,4 +1,7 @@
 //@ run-pass
+//@ reference: expr.arith-logic.behavior
+//@ reference: expr.array.index.trait
+//@ reference: expr.negate.results
 
 #![allow(unused_variables)]
 use std::cmp;

From c12ab08c14b1f607c4799893bcb2752c6fed34b4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 16:12:05 +1100
Subject: [PATCH 0320/1059] Move `Spanned`.

It's defined in `rustc_span::source_map` which doesn't make any sense
because it has nothing to do with source maps. This commit moves it to
the crate root, a more sensible spot for something this basic.
---
 compiler/rustc_ast/src/ast.rs                     |  5 +++--
 compiler/rustc_ast/src/mut_visit.rs               |  3 +--
 compiler/rustc_ast/src/visit.rs                   |  3 +--
 compiler/rustc_ast_lowering/src/expr.rs           |  3 +--
 compiler/rustc_ast_lowering/src/pat.rs            |  3 +--
 compiler/rustc_ast_passes/src/feature_gate.rs     |  3 +--
 compiler/rustc_ast_pretty/src/pprust/state.rs     |  6 ++++--
 compiler/rustc_borrowck/src/diagnostics/mod.rs    |  3 +--
 compiler/rustc_borrowck/src/type_check/mod.rs     |  3 +--
 .../src/deriving/generic/ty.rs                    |  3 +--
 compiler/rustc_codegen_cranelift/src/abi/mod.rs   |  2 +-
 compiler/rustc_codegen_cranelift/src/common.rs    |  3 +--
 .../rustc_codegen_cranelift/src/intrinsics/mod.rs |  3 +--
 compiler/rustc_codegen_gcc/src/context.rs         |  3 +--
 compiler/rustc_codegen_llvm/src/context.rs        |  3 +--
 compiler/rustc_codegen_ssa/src/mir/block.rs       |  3 +--
 compiler/rustc_const_eval/src/interpret/step.rs   |  2 +-
 compiler/rustc_errors/src/diagnostic.rs           |  3 +--
 compiler/rustc_expand/src/build.rs                |  3 +--
 compiler/rustc_hir/src/hir.rs                     |  3 +--
 compiler/rustc_hir_analysis/src/check/check.rs    |  2 +-
 compiler/rustc_hir_analysis/src/check/region.rs   |  8 ++++----
 compiler/rustc_hir_pretty/src/lib.rs              |  4 ++--
 compiler/rustc_hir_typeck/src/errors.rs           |  3 +--
 compiler/rustc_hir_typeck/src/expr.rs             |  3 +--
 .../rustc_hir_typeck/src/fn_ctxt/suggestions.rs   |  3 +--
 compiler/rustc_hir_typeck/src/op.rs               |  3 +--
 compiler/rustc_lint/src/builtin.rs                |  3 +--
 compiler/rustc_lint/src/invalid_from_utf8.rs      |  3 +--
 compiler/rustc_lint/src/unused.rs                 |  2 +-
 compiler/rustc_middle/src/mir/mod.rs              |  3 +--
 compiler/rustc_middle/src/mir/syntax.rs           |  3 +--
 compiler/rustc_middle/src/queries.rs              |  3 +--
 compiler/rustc_middle/src/query/erase.rs          |  3 +--
 compiler/rustc_middle/src/query/on_disk_cache.rs  |  3 +--
 compiler/rustc_middle/src/ty/codec.rs             |  3 +--
 compiler/rustc_middle/src/ty/structural_impls.rs  |  2 +-
 .../src/builder/custom/parse/instruction.rs       |  3 +--
 .../rustc_mir_build/src/builder/expr/as_rvalue.rs |  3 +--
 compiler/rustc_mir_build/src/builder/expr/into.rs |  3 +--
 compiler/rustc_mir_build/src/builder/expr/stmt.rs |  2 +-
 .../rustc_mir_build/src/builder/matches/test.rs   |  3 +--
 compiler/rustc_mir_build/src/builder/scope.rs     |  3 +--
 compiler/rustc_mir_transform/src/coroutine.rs     |  3 +--
 .../rustc_mir_transform/src/elaborate_drop.rs     |  3 +--
 .../src/function_item_references.rs               |  3 +--
 compiler/rustc_mir_transform/src/inline.rs        |  2 +-
 compiler/rustc_mir_transform/src/lib.rs           |  3 +--
 .../rustc_mir_transform/src/mentioned_items.rs    |  2 +-
 .../rustc_mir_transform/src/promote_consts.rs     |  3 +--
 compiler/rustc_mir_transform/src/shim.rs          |  3 +--
 compiler/rustc_monomorphize/src/collector.rs      |  3 +--
 .../src/mono_checks/move_check.rs                 |  3 +--
 compiler/rustc_parse/src/parser/diagnostics.rs    |  3 +--
 compiler/rustc_parse/src/parser/expr.rs           |  9 ++++-----
 compiler/rustc_parse/src/parser/item.rs           |  4 ++--
 compiler/rustc_parse/src/parser/pat.rs            |  3 +--
 compiler/rustc_passes/src/abi_test.rs             |  3 +--
 compiler/rustc_passes/src/layout_test.rs          |  3 +--
 compiler/rustc_resolve/src/diagnostics.rs         |  6 ++++--
 compiler/rustc_resolve/src/errors.rs              |  3 +--
 compiler/rustc_resolve/src/late.rs                |  3 +--
 compiler/rustc_span/src/lib.rs                    | 14 ++++++++++++++
 compiler/rustc_span/src/source_map.rs             | 15 ---------------
 .../clippy/clippy_lints/src/bool_comparison.rs    |  3 +--
 .../clippy_lints/src/casts/manual_dangling_ptr.rs |  2 +-
 .../src/floating_point_arithmetic/custom_abs.rs   |  2 +-
 .../src/floating_point_arithmetic/expm1.rs        |  2 +-
 .../src/floating_point_arithmetic/hypot.rs        |  2 +-
 .../src/floating_point_arithmetic/ln1p.rs         |  2 +-
 .../src/floating_point_arithmetic/log_division.rs |  2 +-
 .../src/floating_point_arithmetic/mul_add.rs      |  2 +-
 .../src/floating_point_arithmetic/powi.rs         |  2 +-
 .../src/floating_point_arithmetic/radians.rs      |  2 +-
 src/tools/clippy/clippy_lints/src/len_zero.rs     |  3 +--
 .../clippy_lints/src/loops/manual_slice_fill.rs   |  3 +--
 src/tools/clippy/clippy_lints/src/loops/utils.rs  |  2 +-
 src/tools/clippy/clippy_lints/src/manual_strip.rs |  3 +--
 .../src/matches/match_like_matches.rs             |  2 +-
 .../case_sensitive_file_extension_comparisons.rs  |  2 +-
 .../clippy/clippy_lints/src/methods/get_first.rs  |  2 +-
 .../clippy_lints/src/methods/get_last_with_len.rs |  2 +-
 .../clippy_lints/src/methods/manual_contains.rs   |  2 +-
 .../clippy_lints/src/methods/open_options.rs      |  2 +-
 .../clippy_lints/src/methods/suspicious_splitn.rs |  2 +-
 .../src/methods/vec_resize_to_zero.rs             |  3 +--
 .../src/missing_asserts_for_indexing.rs           |  3 +--
 .../src/operators/const_comparisons.rs            |  3 +--
 .../src/operators/float_equality_without_abs.rs   |  2 +-
 .../clippy_lints/src/operators/manual_div_ceil.rs |  2 +-
 src/tools/clippy/clippy_lints/src/precedence.rs   |  2 +-
 src/tools/clippy/clippy_lints/src/ranges.rs       |  3 +--
 src/tools/clippy/clippy_lints/src/strings.rs      |  2 +-
 .../src/suspicious_operation_groupings.rs         |  2 +-
 src/tools/clippy/clippy_lints/src/swap.rs         |  3 +--
 .../src/lint_without_lint_pass.rs                 |  3 +--
 src/tools/rustfmt/src/patterns.rs                 |  2 +-
 src/tools/rustfmt/src/spanned.rs                  |  4 ++--
 tests/ui-fulldeps/pprust-expr-roundtrip.rs        |  3 +--
 99 files changed, 128 insertions(+), 183 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 5258f179d95d..74cc1ec17e6f 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -30,8 +30,9 @@
 use rustc_data_structures::tagged_ptr::Tag;
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, Walkable};
 pub use rustc_span::AttrId;
-use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
+use rustc_span::{
+    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, respan, sym,
+};
 use thin_vec::{ThinVec, thin_vec};
 
 use crate::attr::data_structures::CfgEntry;
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index be8e1d22c9db..881b6ff107b5 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -11,8 +11,7 @@
 use std::panic;
 
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Spanned, Symbol};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index c3c1c518d849..bdf290f9a9e6 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -15,8 +15,7 @@
 
 pub use rustc_ast_ir::visit::VisitorResult;
 pub use rustc_ast_ir::{try_visit, visit_opt, walk_list, walk_visitable_list};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Spanned, Symbol};
 use thin_vec::ThinVec;
 
 use crate::ast::*;
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 4a2992038003..305df4065196 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -13,8 +13,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::errors::report_lit_error;
-use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{ByteSymbol, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
+use rustc_span::{ByteSymbol, DUMMY_SP, DesugaringKind, Ident, Span, Spanned, Symbol, respan, sym};
 use thin_vec::{ThinVec, thin_vec};
 use visit::{Visitor, walk_expr};
 
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index e066bce95158..c1c13977e103 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -6,8 +6,7 @@
 use rustc_hir::definitions::DefPathData;
 use rustc_hir::{self as hir, LangItem, Target};
 use rustc_middle::span_bug;
-use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{DesugaringKind, Ident, Span};
+use rustc_span::{DesugaringKind, Ident, Span, Spanned, respan};
 
 use super::errors::{
     ArbitraryExpressionInPattern, ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding,
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 72679d745665..ea8521a83140 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -7,8 +7,7 @@
 use rustc_hir::attrs::AttributeKind;
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_warn};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Span, Spanned, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::errors;
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index c85d6f454321..4ba5dc541342 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -20,9 +20,11 @@
     RangeEnd, RangeSyntax, Safety, SelfKind, Term, attr,
 };
 use rustc_span::edition::Edition;
-use rustc_span::source_map::{SourceMap, Spanned};
+use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::IdentPrinter;
-use rustc_span::{BytePos, CharPos, DUMMY_SP, FileName, Ident, Pos, Span, Symbol, kw, sym};
+use rustc_span::{
+    BytePos, CharPos, DUMMY_SP, FileName, Ident, Pos, Span, Spanned, Symbol, kw, sym,
+};
 
 use crate::pp::Breaks::{Consistent, Inconsistent};
 use crate::pp::{self, BoxMarker, Breaks};
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index af8f723ff378..cb11d35c44b6 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -23,8 +23,7 @@
 use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveOutIndex};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Spanned, Symbol, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::call_kind::{CallDesugaringKind, call_kind};
 use rustc_trait_selection::infer::InferCtxtExt;
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 29d38af472c2..9aa8f7a2067a 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -32,8 +32,7 @@
 use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_span::def_id::CRATE_DEF_ID;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, sym};
+use rustc_span::{Span, Spanned, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
index 1458553d4925..e7972c5436e1 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
@@ -4,8 +4,7 @@
 pub(crate) use Ty::*;
 use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind, TyKind};
 use rustc_expand::base::ExtCtxt;
-use rustc_span::source_map::respan;
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};
+use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, respan};
 use thin_vec::ThinVec;
 
 /// A path, e.g., `::std::option::Option::<i32>` (global). Has support
diff --git a/compiler/rustc_codegen_cranelift/src/abi/mod.rs b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
index 97a19b8976d3..13f5ad5157ce 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
@@ -20,7 +20,7 @@
 use rustc_middle::ty::layout::FnAbiOf;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::Session;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_target::callconv::{FnAbi, PassMode};
 use rustc_target::spec::Arch;
 use smallvec::{SmallVec, smallvec};
diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs
index b11f42408f58..b22afca847aa 100644
--- a/compiler/rustc_codegen_cranelift/src/common.rs
+++ b/compiler/rustc_codegen_cranelift/src/common.rs
@@ -6,8 +6,7 @@
 use rustc_middle::ty::layout::{
     self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers,
 };
-use rustc_span::Symbol;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Spanned, Symbol};
 use rustc_target::callconv::FnAbi;
 use rustc_target::spec::{Arch, HasTargetSpec, Target};
 
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index ab9a11305baa..da8569dac746 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -24,8 +24,7 @@ macro_rules! intrinsic_args {
 use rustc_middle::ty::GenericArgsRef;
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, sym};
+use rustc_span::{Spanned, Symbol, sym};
 use rustc_target::spec::PanicStrategy;
 
 pub(crate) use self::llvm::codegen_llvm_intrinsic_call;
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index ada3d73f612e..5423ee5390fe 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -21,8 +21,7 @@
 use rustc_session::Session;
 #[cfg(feature = "master")]
 use rustc_session::config::DebugInfo;
-use rustc_span::source_map::respan;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, respan};
 use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, Target, TlsModel, X86Abi};
 
 #[cfg(feature = "master")]
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 2760683dad9d..28aa12cc83dc 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -25,8 +25,7 @@
 use rustc_session::config::{
     BranchProtection, CFGuard, CFProtection, CrateType, DebugInfo, FunctionReturn, PAuthKey, PacRet,
 };
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, Symbol};
+use rustc_span::{DUMMY_SP, Span, Spanned, Symbol};
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{
     Abi, Arch, Env, HasTargetSpec, Os, RelocModel, SmallDataThresholdSupport, Target, TlsModel,
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index cf643931717b..d4c10689f65c 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -12,8 +12,7 @@
 use rustc_middle::ty::{self, Instance, Ty, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::OptLevel;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 use rustc_target::callconv::{ArgAbi, ArgAttributes, CastTarget, FnAbi, PassMode};
 use tracing::{debug, info};
 
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 083fd97aec4d..2dee1157e2a1 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -10,7 +10,7 @@
 use rustc_index::IndexSlice;
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_middle::{bug, mir, span_bug};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_target::callconv::FnAbi;
 use tracing::field::Empty;
 use tracing::{info, instrument, trace};
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 631ed54cc024..2764a009237b 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -11,8 +11,7 @@
 use rustc_error_messages::{DiagArgMap, DiagArgName, DiagArgValue, IntoDiagArg};
 use rustc_lint_defs::{Applicability, LintExpectationId};
 use rustc_macros::{Decodable, Encodable};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, Symbol};
+use rustc_span::{DUMMY_SP, Span, Spanned, Symbol};
 use tracing::debug;
 
 use crate::{
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
index 19a2d65762e8..3680f24707df 100644
--- a/compiler/rustc_expand/src/build.rs
+++ b/compiler/rustc_expand/src/build.rs
@@ -5,8 +5,7 @@
     self as ast, AnonConst, AttrItem, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind,
     MgcaDisambiguation, PatKind, UnOp, attr, token, tokenstream,
 };
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, Span, Spanned, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
 use crate::base::ExtCtxt;
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 45a363b97722..7cce0eda4dda 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -23,9 +23,8 @@
 use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::source_map::Spanned;
 use rustc_span::{
-    BytePos, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Ident, Span, Symbol, kw, sym,
+    BytePos, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, sym,
 };
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use smallvec::SmallVec;
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 4157b110fbf6..83b4833b51b0 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -24,7 +24,7 @@
     TypeVisitable, TypeVisitableExt, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_target::spec::{AbiMap, AbiMapping};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits;
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index 0c611e6c4c9e..8865638e3af2 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -18,7 +18,7 @@
 use rustc_middle::middle::region::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint;
-use rustc_span::source_map;
+use rustc_span::Spanned;
 use tracing::debug;
 
 #[derive(Debug, Copy, Clone)]
@@ -181,7 +181,7 @@ fn resolve_cond<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, cond: &'tcx hi
         // operands will be terminated). Any temporaries that would need to be dropped will be
         // dropped before we leave this operator's scope; terminating them here would be redundant.
         hir::ExprKind::Binary(
-            source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
+            Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
             _,
             _,
         ) => false,
@@ -264,7 +264,7 @@ fn resolve_expr<'tcx>(
         // scopes, meaning that temporaries cannot outlive them.
         // This ensures fixed size stacks.
         hir::ExprKind::Binary(
-            source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
+            Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
             left,
             right,
         ) => {
@@ -293,7 +293,7 @@ fn resolve_expr<'tcx>(
                 // This is purely an optimization to reduce the number of
                 // terminating scopes.
                 hir::ExprKind::Binary(
-                    source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
+                    Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
                     ..,
                 ) => false,
                 // otherwise: mark it as terminating
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index e806d72d3dd2..82540a932741 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -23,8 +23,8 @@
     GenericParam, GenericParamKind, HirId, ImplicitSelfKind, LifetimeParamKind, Node, PatKind,
     PreciseCapturingArg, RangeEnd, Term, TyFieldPath, TyPatKind,
 };
-use rustc_span::source_map::{SourceMap, Spanned};
-use rustc_span::{DUMMY_SP, FileName, Ident, Span, Symbol, kw, sym};
+use rustc_span::source_map::SourceMap;
+use rustc_span::{DUMMY_SP, FileName, Ident, Span, Spanned, Symbol, kw, sym};
 
 pub fn id_to_string(cx: &dyn rustc_hir::intravisit::HirTyCtxt<'_>, hir_id: HirId) -> String {
     to_string(&cx, |s| s.print_node(cx.hir_node(hir_id)))
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 5c6a66403019..6eef15684697 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -14,8 +14,7 @@
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::edition::{Edition, LATEST_STABLE_EDITION};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Spanned, Symbol};
 
 use crate::FnCtxt;
 
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 2de101a1e452..e35129f58351 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -34,8 +34,7 @@
 use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::hygiene::DesugaringKind;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol, kw, sym};
+use rustc_span::{Ident, Span, Spanned, Symbol, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt};
 use tracing::{debug, instrument, trace};
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 801f5acf9d2f..a2f4c57bd442 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -23,8 +23,7 @@
     suggest_constraining_type_params,
 };
 use rustc_session::errors::ExprParenthesesNeeded;
-use rustc_span::source_map::Spanned;
-use rustc_span::{ExpnKind, Ident, MacroKind, Span, Symbol, sym};
+use rustc_span::{ExpnKind, Ident, MacroKind, Span, Spanned, Symbol, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::DefIdOrName;
 use rustc_trait_selection::infer::InferCtxtExt;
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index 4b325a7ad14a..cf61728f7c2a 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -13,8 +13,7 @@
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::errors::ExprParenthesesNeeded;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, Spanned, Symbol, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{FulfillmentError, Obligation, ObligationCtxt};
 use tracing::debug;
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 54c8c75b88fc..af590d98c301 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -39,8 +39,7 @@
 use rustc_session::lint::fcw;
 use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
 use rustc_span::edition::Edition;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Ident, InnerSpan, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, InnerSpan, Span, Spanned, Symbol, kw, sym};
 use rustc_target::asm::InlineAsmArch;
 use rustc_trait_selection::infer::{InferCtxtExt, TyCtxtInferExt};
 use rustc_trait_selection::traits;
diff --git a/compiler/rustc_lint/src/invalid_from_utf8.rs b/compiler/rustc_lint/src/invalid_from_utf8.rs
index 41b670c92c4c..f095d0a6a2f4 100644
--- a/compiler/rustc_lint/src/invalid_from_utf8.rs
+++ b/compiler/rustc_lint/src/invalid_from_utf8.rs
@@ -3,8 +3,7 @@
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_session::{declare_lint, declare_lint_pass};
-use rustc_span::source_map::Spanned;
-use rustc_span::sym;
+use rustc_span::{Spanned, sym};
 
 use crate::lints::InvalidFromUtf8Diag;
 use crate::{LateContext, LateLintPass, LintContext};
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 03a566efc8a5..2864cf9032a1 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -600,7 +600,7 @@ fn check_unused_delims_expr(
                     && !value.span.from_expansion()
                     && (ctx != UnusedDelimsCtx::LetScrutineeExpr
                         || !matches!(inner.kind, ast::ExprKind::Binary(
-                                rustc_span::source_map::Spanned { node, .. },
+                                rustc_span::Spanned { node, .. },
                                 _,
                                 _,
                             ) if node.is_lazy()))
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 8ac532ff4863..2dd205e8468d 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -24,8 +24,7 @@
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
 use rustc_serialize::{Decodable, Encodable};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, Symbol};
+use rustc_span::{DUMMY_SP, Span, Spanned, Symbol};
 use tracing::{debug, trace};
 
 pub use self::query::*;
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index c3da2f039485..455089f285d1 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -11,8 +11,7 @@
 use rustc_index::IndexVec;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, Spanned, Symbol};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use smallvec::SmallVec;
 
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 2636fc7024ca..c20a389f56b9 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -96,8 +96,7 @@
 };
 use rustc_session::lint::LintExpectationId;
 use rustc_span::def_id::LOCAL_CRATE;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, LocalExpnId, Span, Symbol};
+use rustc_span::{DUMMY_SP, LocalExpnId, Span, Spanned, Symbol};
 use rustc_target::spec::PanicStrategy;
 
 use crate::infer::canonical::{self, Canonical};
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 4d4833b4943e..a02f6f89b9b9 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -10,8 +10,7 @@
 use std::mem::MaybeUninit;
 
 use rustc_ast::tokenstream::TokenStream;
-use rustc_span::ErrorGuaranteed;
-use rustc_span::source_map::Spanned;
+use rustc_span::{ErrorGuaranteed, Spanned};
 
 use crate::mir::interpret::EvalToValTreeResult;
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 8db48fc2f995..6968e5b7d6d8 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -17,10 +17,9 @@
 use rustc_span::hygiene::{
     ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextKey,
 };
-use rustc_span::source_map::Spanned;
 use rustc_span::{
     BlobDecoder, BytePos, ByteSymbol, CachingSourceMapView, ExpnData, ExpnHash, RelativeBytePos,
-    SourceFile, Span, SpanDecoder, SpanEncoder, StableSourceFileId, Symbol,
+    SourceFile, Span, SpanDecoder, SpanEncoder, Spanned, StableSourceFileId, Symbol,
 };
 
 use crate::dep_graph::{DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index d1987f51f6e0..6652c5a758da 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -15,8 +15,7 @@
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::Const;
 use rustc_serialize::{Decodable, Encodable};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, SpanDecoder, SpanEncoder};
+use rustc_span::{Span, SpanDecoder, SpanEncoder, Spanned};
 
 use crate::arena::ArenaAllocatable;
 use crate::infer::canonical::{CanonicalVarKind, CanonicalVarKinds};
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 04985dd3acde..68e43bbbea20 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -8,7 +8,7 @@
 use rustc_abi::TyAndLayout;
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::LocalDefId;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_type_ir::{ConstKind, TypeFolder, VisitorResult, try_visit};
 
 use super::{GenericArg, GenericArgKind, Pattern, Region};
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 13082d408ec0..a47a2e08c9f4 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -4,8 +4,7 @@
 use rustc_middle::thir::*;
 use rustc_middle::ty;
 use rustc_middle::ty::cast::mir_cast_kind;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 
 use super::{PResult, ParseCtxt, parse_by_kind};
 use crate::builder::custom::ParseError;
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index 0f206c1f01ec..a1b41510f1e1 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -11,8 +11,7 @@
 use rustc_middle::ty::cast::{CastTy, mir_cast_kind};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, Ty, UpvarArgs};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Spanned};
 use tracing::debug;
 
 use crate::builder::expr::as_place::PlaceBase;
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index 24d184121ffd..446b2939e370 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -10,8 +10,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::thir::*;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, sym};
+use rustc_span::{DUMMY_SP, Spanned, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, instrument};
 
diff --git a/compiler/rustc_mir_build/src/builder/expr/stmt.rs b/compiler/rustc_mir_build/src/builder/expr/stmt.rs
index 3d603afbaa4a..99e16d182a97 100644
--- a/compiler/rustc_mir_build/src/builder/expr/stmt.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/stmt.rs
@@ -2,7 +2,7 @@
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::thir::*;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use tracing::debug;
 
 use crate::builder::scope::{BreakableTarget, LintLevel};
diff --git a/compiler/rustc_mir_build/src/builder/matches/test.rs b/compiler/rustc_mir_build/src/builder/matches/test.rs
index 5c3173a7b148..d8911870d3ad 100644
--- a/compiler/rustc_mir_build/src/builder/matches/test.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/test.rs
@@ -14,8 +14,7 @@
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt};
 use rustc_span::def_id::DefId;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Span, Spanned, Symbol, sym};
 use tracing::{debug, instrument};
 
 use crate::builder::Builder;
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index b10df60e0f75..91610e768d01 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -94,8 +94,7 @@
 use rustc_middle::{bug, span_bug};
 use rustc_pattern_analysis::rustc::RustcPatCtxt;
 use rustc_session::lint::Level;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Spanned};
 use tracing::{debug, instrument};
 
 use super::matches::BuiltMatchTree;
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index c83b10a5e583..332196e3afee 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -83,8 +83,7 @@
     Analysis, Results, ResultsCursor, ResultsVisitor, visit_reachable_results,
 };
 use rustc_span::def_id::{DefId, LocalDefId};
-use rustc_span::source_map::dummy_spanned;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, dummy_spanned};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::TyCtxtInferExt as _;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode, ObligationCtxt};
diff --git a/compiler/rustc_mir_transform/src/elaborate_drop.rs b/compiler/rustc_mir_transform/src/elaborate_drop.rs
index e17629215b79..1fe745a5d519 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drop.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drop.rs
@@ -9,8 +9,7 @@
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, GenericArg, GenericArgsRef, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug, traits};
-use rustc_span::DUMMY_SP;
-use rustc_span::source_map::{Spanned, dummy_spanned};
+use rustc_span::{DUMMY_SP, Spanned, dummy_spanned};
 use tracing::{debug, instrument};
 
 use crate::patch::MirPatch;
diff --git a/compiler/rustc_mir_transform/src/function_item_references.rs b/compiler/rustc_mir_transform/src/function_item_references.rs
index 2ae8f43cf6c8..0216e0d4cfbc 100644
--- a/compiler/rustc_mir_transform/src/function_item_references.rs
+++ b/compiler/rustc_mir_transform/src/function_item_references.rs
@@ -5,8 +5,7 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Ty, TyCtxt};
 use rustc_session::lint::builtin::FUNCTION_ITEM_REFERENCES;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, sym};
+use rustc_span::{Span, Spanned, sym};
 
 use crate::errors;
 
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 9069f279e981..afcea3236dbd 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -15,7 +15,7 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
 use rustc_session::config::{DebugInfo, OptLevel};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use tracing::{debug, instrument, trace, trace_span};
 
 use crate::cost_checker::{CostChecker, is_call_like};
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 6bf4221d9ab7..094aae499c4b 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -27,8 +27,7 @@
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, query, span_bug};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, sym};
+use rustc_span::{DUMMY_SP, Spanned, sym};
 use tracing::debug;
 
 #[macro_use]
diff --git a/compiler/rustc_mir_transform/src/mentioned_items.rs b/compiler/rustc_mir_transform/src/mentioned_items.rs
index a9f2c32171c3..c98ca2f4da52 100644
--- a/compiler/rustc_mir_transform/src/mentioned_items.rs
+++ b/compiler/rustc_mir_transform/src/mentioned_items.rs
@@ -3,7 +3,7 @@
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::Session;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 pub(super) struct MentionedItems;
 
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 3f5a630a2174..a47b3ce64ed2 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -23,8 +23,7 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, GenericArgs, List, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, mir, span_bug};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 use tracing::{debug, instrument};
 
 /// A `MirPass` for promotion.
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index 1abbfed1a822..4fd0629befec 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -12,8 +12,7 @@
     self, CoroutineArgs, CoroutineArgsExt, EarlyBinder, GenericArgs, Ty, TyCtxt,
 };
 use rustc_middle::{bug, span_bug};
-use rustc_span::source_map::{Spanned, dummy_spanned};
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Spanned, dummy_spanned};
 use tracing::{debug, instrument};
 
 use crate::deref_separator::deref_finder;
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 3aa55cc8eb9f..e56c6dc32ff1 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -236,8 +236,7 @@
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{DebugInfo, EntryFnType};
-use rustc_span::source_map::{Spanned, dummy_spanned, respan};
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Spanned, dummy_spanned, respan};
 use tracing::{debug, instrument, trace};
 
 use crate::collector::autodiff::collect_autodiff_fn;
diff --git a/compiler/rustc_monomorphize/src/mono_checks/move_check.rs b/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
index a8f3104c0d98..a24b0443d39c 100644
--- a/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
+++ b/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
@@ -6,8 +6,7 @@
 use rustc_middle::mir::{self, Location, traversal};
 use rustc_middle::ty::{self, AssocTag, Instance, Ty, TyCtxt, TypeFoldable};
 use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, sym};
+use rustc_span::{Ident, Span, Spanned, sym};
 use tracing::{debug, trace};
 
 use crate::errors::LargeAssignmentsLint;
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 284e651d94ad..47ac91feefd4 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -16,9 +16,8 @@
     pluralize,
 };
 use rustc_session::errors::ExprParenthesesNeeded;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::used_keywords;
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, SpanSnippetError, Symbol, kw, sym};
+use rustc_span::{BytePos, DUMMY_SP, Ident, Span, SpanSnippetError, Spanned, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 use tracing::{debug, trace};
 
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 4297086983b4..adfc68f4bb22 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -25,8 +25,7 @@
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP;
 use rustc_span::edition::Edition;
-use rustc_span::source_map::{self, Spanned};
-use rustc_span::{BytePos, ErrorGuaranteed, Ident, Pos, Span, Symbol, kw, sym};
+use rustc_span::{BytePos, ErrorGuaranteed, Ident, Pos, Span, Spanned, Symbol, kw, respan, sym};
 use thin_vec::{ThinVec, thin_vec};
 use tracing::instrument;
 
@@ -296,12 +295,12 @@ pub(super) fn parse_expr_assoc_rest_with(
             let span = self.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
             lhs = match op {
                 AssocOp::Binary(ast_op) => {
-                    let binary = self.mk_binary(source_map::respan(cur_op_span, ast_op), lhs, rhs);
+                    let binary = self.mk_binary(respan(cur_op_span, ast_op), lhs, rhs);
                     self.mk_expr(span, binary)
                 }
                 AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs, cur_op_span)),
                 AssocOp::AssignOp(aop) => {
-                    let aopexpr = self.mk_assign_op(source_map::respan(cur_op_span, aop), lhs, rhs);
+                    let aopexpr = self.mk_assign_op(respan(cur_op_span, aop), lhs, rhs);
                     self.mk_expr(span, aopexpr)
                 }
                 AssocOp::Cast | AssocOp::Range(_) => {
@@ -409,7 +408,7 @@ pub(super) fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> {
             }
             _ => return None,
         };
-        Some(source_map::respan(span, op))
+        Some(respan(span, op))
     }
 
     /// Checks if this expression is a successfully parsed statement.
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index db5be5feaeb6..0f4927432f6f 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -13,7 +13,7 @@
 use rustc_session::lint::builtin::VARARGS_WITHOUT_PATTERN;
 use rustc_span::edit_distance::edit_distance;
 use rustc_span::edition::Edition;
-use rustc_span::{DUMMY_SP, ErrorGuaranteed, Ident, Span, Symbol, kw, source_map, sym};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Ident, Span, Symbol, kw, respan, sym};
 use thin_vec::{ThinVec, thin_vec};
 use tracing::debug;
 
@@ -3557,7 +3557,7 @@ fn parse_self_param(&mut self) -> PResult<'a, Option<Param>> {
             _ => return Ok(None),
         };
 
-        let eself = source_map::respan(eself_lo.to(eself_hi), eself);
+        let eself = respan(eself_lo.to(eself_hi), eself);
         Ok(Some(Param::from_self(AttrVec::default(), eself, eself_ident)))
     }
 
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 528b69abbf1a..7ee7781f6be0 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -12,8 +12,7 @@
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, Diag, DiagArgValue, PResult, StashKey};
 use rustc_session::errors::ExprParenthesesNeeded;
-use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{BytePos, ErrorGuaranteed, Ident, Span, kw, sym};
+use rustc_span::{BytePos, ErrorGuaranteed, Ident, Span, Spanned, kw, respan, sym};
 use thin_vec::{ThinVec, thin_vec};
 
 use super::{ForceCollect, Parser, PathStyle, Restrictions, Trailing, UsePreAttrPos};
diff --git a/compiler/rustc_passes/src/abi_test.rs b/compiler/rustc_passes/src/abi_test.rs
index 3da0978e5ff8..7d1ee1ffbc36 100644
--- a/compiler/rustc_passes/src/abi_test.rs
+++ b/compiler/rustc_passes/src/abi_test.rs
@@ -5,8 +5,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{FnAbiError, LayoutError};
 use rustc_middle::ty::{self, GenericArgs, Instance, Ty, TyCtxt};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 use rustc_target::callconv::FnAbi;
 
 use super::layout_test::ensure_wf;
diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs
index 68834cf7d55a..f4f5ae6c1683 100644
--- a/compiler/rustc_passes/src/layout_test.rs
+++ b/compiler/rustc_passes/src/layout_test.rs
@@ -6,8 +6,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutError, LayoutOfHelpers};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::TyCtxtInferExt;
 use rustc_trait_selection::traits;
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 1b1198af41c0..12cc5649c41d 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -32,8 +32,10 @@
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::MacroKind;
-use rustc_span::source_map::{SourceMap, Spanned};
-use rustc_span::{BytePos, Ident, RemapPathScopeComponents, Span, Symbol, SyntaxContext, kw, sym};
+use rustc_span::source_map::SourceMap;
+use rustc_span::{
+    BytePos, Ident, RemapPathScopeComponents, Span, Spanned, Symbol, SyntaxContext, kw, sym,
+};
 use thin_vec::{ThinVec, thin_vec};
 use tracing::{debug, instrument};
 
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 63ffdbc37f7d..7ab85e5a205f 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -5,8 +5,7 @@
     EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic, msg,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Spanned, Symbol};
 
 use crate::Res;
 use crate::late::PatternSource;
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 1e2daff6d97c..453fe9d7a8e0 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -37,8 +37,7 @@
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
 use rustc_session::parse::feature_err;
-use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Spanned, Symbol, kw, respan, sym};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index a1d43d986384..d7d2ecb5bbe7 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -90,6 +90,20 @@
 #[cfg(test)]
 mod tests;
 
+#[derive(Clone, Encodable, Decodable, Debug, Copy, PartialEq, Hash, HashStable_Generic)]
+pub struct Spanned<T> {
+    pub node: T,
+    pub span: Span,
+}
+
+pub fn respan<T>(sp: Span, t: T) -> Spanned<T> {
+    Spanned { node: t, span: sp }
+}
+
+pub fn dummy_spanned<T>(t: T) -> Spanned<T> {
+    respan(DUMMY_SP, t)
+}
+
 /// Per-session global variables: this struct is stored in thread-local storage
 /// in such a way that it is accessible without any kind of handle to all
 /// threads within the compilation session, but is not accessible outside the
diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs
index 35694be9e492..ec335e7b4339 100644
--- a/compiler/rustc_span/src/source_map.rs
+++ b/compiler/rustc_span/src/source_map.rs
@@ -15,7 +15,6 @@
 
 use rustc_data_structures::sync::{IntoDynSyncSend, MappedReadGuard, ReadGuard, RwLock};
 use rustc_data_structures::unhash::UnhashMap;
-use rustc_macros::{Decodable, Encodable};
 use tracing::{debug, instrument, trace};
 
 use crate::*;
@@ -74,20 +73,6 @@ fn deref(&self) -> &Self::Target {
     impl<T> !DerefMut for MonotonicVec<T> {}
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, Copy, PartialEq, Hash, HashStable_Generic)]
-pub struct Spanned<T> {
-    pub node: T,
-    pub span: Span,
-}
-
-pub fn respan<T>(sp: Span, t: T) -> Spanned<T> {
-    Spanned { node: t, span: sp }
-}
-
-pub fn dummy_spanned<T>(t: T) -> Spanned<T> {
-    respan(DUMMY_SP, t)
-}
-
 // _____________________________________________________________________________
 // SourceFile, MultiByteChar, FileName, FileLines
 //
diff --git a/src/tools/clippy/clippy_lints/src/bool_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_comparison.rs
index 722095909a6f..feeefefc3b8f 100644
--- a/src/tools/clippy/clippy_lints/src/bool_comparison.rs
+++ b/src/tools/clippy/clippy_lints/src/bool_comparison.rs
@@ -6,8 +6,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
index 56779e8ce3d9..55b0945f0962 100644
--- a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, Ty, TyKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_DANGLING_PTR;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/custom_abs.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
index d12a32e15881..6578cf20e637 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
@@ -7,7 +7,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::SyntaxContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs
index 9a4c97569308..bf376a51fec9 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/hypot.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/hypot.rs
index 49f8ba4bf825..8d3bd8084db8 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/hypot.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/hypot.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/ln1p.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/ln1p.rs
index 4c9aa96b5042..f37737c71aee 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/ln1p.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/ln1p.rs
@@ -4,7 +4,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/log_division.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/log_division.rs
index e3419ffad72a..947935369de1 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/log_division.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/log_division.rs
@@ -4,7 +4,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs
index e0a6498f62fd..888d5b7b762a 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs
@@ -5,7 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/powi.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/powi.rs
index a61a2a82c023..b0b65b357d7a 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/powi.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/powi.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/radians.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/radians.rs
index 2021f00a97e8..8480626133fd 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/radians.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/radians.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use std::f32::consts as f32_consts;
 use std::f64::consts as f64_consts;
 
diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs
index d683abd3d33b..f906bba423b3 100644
--- a/src/tools/clippy/clippy_lints/src/len_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/len_zero.rs
@@ -13,8 +13,7 @@
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, Spanned, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
index a2ff60a3d8ac..5d09f755bcd1 100644
--- a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
@@ -13,8 +13,7 @@
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
-use rustc_span::sym;
+use rustc_span::{Spanned, sym};
 
 use super::MANUAL_SLICE_FILL;
 
diff --git a/src/tools/clippy/clippy_lints/src/loops/utils.rs b/src/tools/clippy/clippy_lints/src/loops/utils.rs
index 2c37e2679d97..86f4e606a176 100644
--- a/src/tools/clippy/clippy_lints/src/loops/utils.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/utils.rs
@@ -8,7 +8,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_span::symbol::{Symbol, sym};
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/src/tools/clippy/clippy_lints/src/manual_strip.rs b/src/tools/clippy/clippy_lints/src/manual_strip.rs
index 526163244596..e0a60e3747a0 100644
--- a/src/tools/clippy/clippy_lints/src/manual_strip.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_strip.rs
@@ -15,8 +15,7 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext as _};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, SyntaxContext};
+use rustc_span::{Spanned, Symbol, SyntaxContext};
 use std::iter;
 
 declare_clippy_lint! {
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
index 347560b14eea..3a16c2ed8790 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
@@ -10,7 +10,7 @@
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MATCH_LIKE_MATCHES_MACRO;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index b4b10e972f6d..23a0046dec76 100644
--- a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -8,7 +8,7 @@
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/get_first.rs b/src/tools/clippy/clippy_lints/src/methods/get_first.rs
index 414c4e0cd381..cb5d1ec374fc 100644
--- a/src/tools/clippy/clippy_lints/src/methods/get_first.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/get_first.rs
@@ -7,7 +7,7 @@
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::GET_FIRST;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs b/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs
index 171079f52d9a..14e40328a416 100644
--- a/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs
@@ -5,7 +5,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::GET_LAST_WITH_LEN;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs
index d2906b2776f8..f1d399e1bbd2 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs
@@ -9,7 +9,7 @@
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, HirId, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_CONTAINS;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/open_options.rs b/src/tools/clippy/clippy_lints/src/methods/open_options.rs
index 1b520a9edb56..042558d645e6 100644
--- a/src/tools/clippy/clippy_lints/src/methods/open_options.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/open_options.rs
@@ -8,7 +8,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::{NONSENSICAL_OPEN_OPTIONS, SUSPICIOUS_OPEN_OPTIONS};
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs b/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs
index be1481ebb996..98b7834178f2 100644
--- a/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs
@@ -3,7 +3,7 @@
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::Symbol;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUSPICIOUS_SPLITN;
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs b/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs
index 5debaab2067b..8979f9973d6f 100644
--- a/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs
@@ -5,8 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, sym};
+use rustc_span::{Span, Spanned, sym};
 
 use super::VEC_RESIZE_TO_ZERO;
 
diff --git a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
index 2773f537efc6..b5becbdeb30d 100644
--- a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -15,8 +15,7 @@
 use rustc_hir::{Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, Spanned, Symbol, sym};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
index 56001a185771..e5a5b46b7b2e 100644
--- a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
@@ -7,8 +7,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::HasTyCtxt;
 use rustc_middle::ty::{Ty, TypeckResults};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 
 use clippy_utils::SpanlessEq;
 use clippy_utils::diagnostics::span_lint_and_note;
diff --git a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
index 97b3c0d02e84..6c6221525b57 100644
--- a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -6,7 +6,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::FLOAT_EQUALITY_WITHOUT_ABS;
 
diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
index 6751532ecbc7..a0f61f6d36c4 100644
--- a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs
@@ -9,7 +9,7 @@
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_DIV_CEIL;
 
diff --git a/src/tools/clippy/clippy_lints/src/precedence.rs b/src/tools/clippy/clippy_lints/src/precedence.rs
index 034fe8edc715..1f0371c78200 100644
--- a/src/tools/clippy/clippy_lints/src/precedence.rs
+++ b/src/tools/clippy/clippy_lints/src/precedence.rs
@@ -5,7 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/ranges.rs b/src/tools/clippy/clippy_lints/src/ranges.rs
index 61087ad88457..39019c646bd5 100644
--- a/src/tools/clippy/clippy_lints/src/ranges.rs
+++ b/src/tools/clippy/clippy_lints/src/ranges.rs
@@ -14,8 +14,7 @@
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::{self, ClauseKind, GenericArgKind, PredicatePolarity, Ty};
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DesugaringKind, Span};
+use rustc_span::{DesugaringKind, Span, Spanned};
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs
index ab11c37b5041..61b5842ea542 100644
--- a/src/tools/clippy/clippy_lints/src/strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strings.rs
@@ -11,7 +11,7 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/suspicious_operation_groupings.rs b/src/tools/clippy/clippy_lints/src/suspicious_operation_groupings.rs
index 9fa4d2c142b5..44e35b8dc71b 100644
--- a/src/tools/clippy/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/src/tools/clippy/clippy_lints/src/suspicious_operation_groupings.rs
@@ -8,7 +8,7 @@
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
diff --git a/src/tools/clippy/clippy_lints/src/swap.rs b/src/tools/clippy/clippy_lints/src/swap.rs
index 0c78ed84adc4..01482b2475f7 100644
--- a/src/tools/clippy/clippy_lints/src/swap.rs
+++ b/src/tools/clippy/clippy_lints/src/swap.rs
@@ -14,9 +14,8 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
-use rustc_span::{Span, SyntaxContext};
+use rustc_span::{Span, Spanned, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs b/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
index f56b6f31550b..cab1422c3000 100644
--- a/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
+++ b/src/tools/clippy/clippy_lints_internal/src/lint_without_lint_pass.rs
@@ -12,9 +12,8 @@
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
+use rustc_span::{Span, Spanned};
 
 declare_tool_lint! {
     /// ### What it does
diff --git a/src/tools/rustfmt/src/patterns.rs b/src/tools/rustfmt/src/patterns.rs
index df2a8dc5c6fd..0a9ff4771b0e 100644
--- a/src/tools/rustfmt/src/patterns.rs
+++ b/src/tools/rustfmt/src/patterns.rs
@@ -361,7 +361,7 @@ pub(crate) fn rewrite_range_pat<T: Rewrite>(
     shape: Shape,
     lhs: &Option<Box<T>>,
     rhs: &Option<Box<T>>,
-    end_kind: &rustc_span::source_map::Spanned<RangeEnd>,
+    end_kind: &rustc_span::Spanned<RangeEnd>,
     span: Span,
 ) -> RewriteResult {
     let infix = match end_kind.node {
diff --git a/src/tools/rustfmt/src/spanned.rs b/src/tools/rustfmt/src/spanned.rs
index 020651e2daac..143fb1dea222 100644
--- a/src/tools/rustfmt/src/spanned.rs
+++ b/src/tools/rustfmt/src/spanned.rs
@@ -1,7 +1,7 @@
 use std::cmp::max;
 
 use rustc_ast::ast;
-use rustc_span::{Span, source_map};
+use rustc_span::Span;
 
 use crate::macros::MacroArg;
 use crate::patterns::RangeOperand;
@@ -18,7 +18,7 @@ fn span(&self) -> Span {
     }
 }
 
-impl<T> Spanned for source_map::Spanned<T> {
+impl<T> Spanned for rustc_span::Spanned<T> {
     fn span(&self) -> Span {
         self.span
     }
diff --git a/tests/ui-fulldeps/pprust-expr-roundtrip.rs b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
index 8d7425186680..84f9a09990fd 100644
--- a/tests/ui-fulldeps/pprust-expr-roundtrip.rs
+++ b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
@@ -38,9 +38,8 @@
 use rustc_ast::*;
 use rustc_ast_pretty::pprust;
 use rustc_session::parse::ParseSess;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
-use rustc_span::DUMMY_SP;
+use rustc_span::{DUMMY_SP, Spanned};
 use thin_vec::{thin_vec, ThinVec};
 
 // Helper functions for building exprs

From f599afe624270ba1ded875cb06e6b9f628ec1f26 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 16:12:05 +1100
Subject: [PATCH 0321/1059] Move `Spanned`.

It's defined in `rustc_span::source_map` which doesn't make any sense
because it has nothing to do with source maps. This commit moves it to
the crate root, a more sensible spot for something this basic.
---
 clippy_lints/src/bool_comparison.rs                            | 3 +--
 clippy_lints/src/casts/manual_dangling_ptr.rs                  | 2 +-
 clippy_lints/src/floating_point_arithmetic/custom_abs.rs       | 2 +-
 clippy_lints/src/floating_point_arithmetic/expm1.rs            | 2 +-
 clippy_lints/src/floating_point_arithmetic/hypot.rs            | 2 +-
 clippy_lints/src/floating_point_arithmetic/ln1p.rs             | 2 +-
 clippy_lints/src/floating_point_arithmetic/log_division.rs     | 2 +-
 clippy_lints/src/floating_point_arithmetic/mul_add.rs          | 2 +-
 clippy_lints/src/floating_point_arithmetic/powi.rs             | 2 +-
 clippy_lints/src/floating_point_arithmetic/radians.rs          | 2 +-
 clippy_lints/src/len_zero.rs                                   | 3 +--
 clippy_lints/src/loops/manual_slice_fill.rs                    | 3 +--
 clippy_lints/src/loops/utils.rs                                | 2 +-
 clippy_lints/src/manual_strip.rs                               | 3 +--
 clippy_lints/src/matches/match_like_matches.rs                 | 2 +-
 .../src/methods/case_sensitive_file_extension_comparisons.rs   | 2 +-
 clippy_lints/src/methods/get_first.rs                          | 2 +-
 clippy_lints/src/methods/get_last_with_len.rs                  | 2 +-
 clippy_lints/src/methods/manual_contains.rs                    | 2 +-
 clippy_lints/src/methods/open_options.rs                       | 2 +-
 clippy_lints/src/methods/suspicious_splitn.rs                  | 2 +-
 clippy_lints/src/methods/vec_resize_to_zero.rs                 | 3 +--
 clippy_lints/src/missing_asserts_for_indexing.rs               | 3 +--
 clippy_lints/src/operators/const_comparisons.rs                | 3 +--
 clippy_lints/src/operators/float_equality_without_abs.rs       | 2 +-
 clippy_lints/src/operators/manual_div_ceil.rs                  | 2 +-
 clippy_lints/src/precedence.rs                                 | 2 +-
 clippy_lints/src/ranges.rs                                     | 3 +--
 clippy_lints/src/strings.rs                                    | 2 +-
 clippy_lints/src/suspicious_operation_groupings.rs             | 2 +-
 clippy_lints/src/swap.rs                                       | 3 +--
 clippy_lints_internal/src/lint_without_lint_pass.rs            | 3 +--
 32 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/clippy_lints/src/bool_comparison.rs b/clippy_lints/src/bool_comparison.rs
index 722095909a6f..feeefefc3b8f 100644
--- a/clippy_lints/src/bool_comparison.rs
+++ b/clippy_lints/src/bool_comparison.rs
@@ -6,8 +6,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/casts/manual_dangling_ptr.rs b/clippy_lints/src/casts/manual_dangling_ptr.rs
index 56779e8ce3d9..55b0945f0962 100644
--- a/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, Ty, TyKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_DANGLING_PTR;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/custom_abs.rs b/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
index d12a32e15881..6578cf20e637 100644
--- a/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
+++ b/clippy_lints/src/floating_point_arithmetic/custom_abs.rs
@@ -7,7 +7,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::SyntaxContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/expm1.rs b/clippy_lints/src/floating_point_arithmetic/expm1.rs
index 9a4c97569308..bf376a51fec9 100644
--- a/clippy_lints/src/floating_point_arithmetic/expm1.rs
+++ b/clippy_lints/src/floating_point_arithmetic/expm1.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/hypot.rs b/clippy_lints/src/floating_point_arithmetic/hypot.rs
index 49f8ba4bf825..8d3bd8084db8 100644
--- a/clippy_lints/src/floating_point_arithmetic/hypot.rs
+++ b/clippy_lints/src/floating_point_arithmetic/hypot.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/ln1p.rs b/clippy_lints/src/floating_point_arithmetic/ln1p.rs
index 4c9aa96b5042..f37737c71aee 100644
--- a/clippy_lints/src/floating_point_arithmetic/ln1p.rs
+++ b/clippy_lints/src/floating_point_arithmetic/ln1p.rs
@@ -4,7 +4,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::IMPRECISE_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/log_division.rs b/clippy_lints/src/floating_point_arithmetic/log_division.rs
index e3419ffad72a..947935369de1 100644
--- a/clippy_lints/src/floating_point_arithmetic/log_division.rs
+++ b/clippy_lints/src/floating_point_arithmetic/log_division.rs
@@ -4,7 +4,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/mul_add.rs b/clippy_lints/src/floating_point_arithmetic/mul_add.rs
index e0a6498f62fd..888d5b7b762a 100644
--- a/clippy_lints/src/floating_point_arithmetic/mul_add.rs
+++ b/clippy_lints/src/floating_point_arithmetic/mul_add.rs
@@ -5,7 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/powi.rs b/clippy_lints/src/floating_point_arithmetic/powi.rs
index a61a2a82c023..b0b65b357d7a 100644
--- a/clippy_lints/src/floating_point_arithmetic/powi.rs
+++ b/clippy_lints/src/floating_point_arithmetic/powi.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUBOPTIMAL_FLOPS;
 
diff --git a/clippy_lints/src/floating_point_arithmetic/radians.rs b/clippy_lints/src/floating_point_arithmetic/radians.rs
index 2021f00a97e8..8480626133fd 100644
--- a/clippy_lints/src/floating_point_arithmetic/radians.rs
+++ b/clippy_lints/src/floating_point_arithmetic/radians.rs
@@ -6,7 +6,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use std::f32::consts as f32_consts;
 use std::f64::consts as f64_consts;
 
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index d683abd3d33b..f906bba423b3 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -13,8 +13,7 @@
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, Spanned, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/loops/manual_slice_fill.rs b/clippy_lints/src/loops/manual_slice_fill.rs
index a2ff60a3d8ac..5d09f755bcd1 100644
--- a/clippy_lints/src/loops/manual_slice_fill.rs
+++ b/clippy_lints/src/loops/manual_slice_fill.rs
@@ -13,8 +13,7 @@
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
-use rustc_span::sym;
+use rustc_span::{Spanned, sym};
 
 use super::MANUAL_SLICE_FILL;
 
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 2c37e2679d97..86f4e606a176 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -8,7 +8,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_span::symbol::{Symbol, sym};
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 526163244596..e0a60e3747a0 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -15,8 +15,7 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext as _};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, SyntaxContext};
+use rustc_span::{Spanned, Symbol, SyntaxContext};
 use std::iter;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 347560b14eea..3a16c2ed8790 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -10,7 +10,7 @@
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MATCH_LIKE_MATCHES_MACRO;
 
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index b4b10e972f6d..23a0046dec76 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -8,7 +8,7 @@
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS;
 
diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index 414c4e0cd381..cb5d1ec374fc 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -7,7 +7,7 @@
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::GET_FIRST;
 
diff --git a/clippy_lints/src/methods/get_last_with_len.rs b/clippy_lints/src/methods/get_last_with_len.rs
index 171079f52d9a..14e40328a416 100644
--- a/clippy_lints/src/methods/get_last_with_len.rs
+++ b/clippy_lints/src/methods/get_last_with_len.rs
@@ -5,7 +5,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::GET_LAST_WITH_LEN;
 
diff --git a/clippy_lints/src/methods/manual_contains.rs b/clippy_lints/src/methods/manual_contains.rs
index d2906b2776f8..f1d399e1bbd2 100644
--- a/clippy_lints/src/methods/manual_contains.rs
+++ b/clippy_lints/src/methods/manual_contains.rs
@@ -9,7 +9,7 @@
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, HirId, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_CONTAINS;
 
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index 1b520a9edb56..042558d645e6 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -8,7 +8,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::{NONSENSICAL_OPEN_OPTIONS, SUSPICIOUS_OPEN_OPTIONS};
 
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index be1481ebb996..98b7834178f2 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -3,7 +3,7 @@
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::Symbol;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::SUSPICIOUS_SPLITN;
 
diff --git a/clippy_lints/src/methods/vec_resize_to_zero.rs b/clippy_lints/src/methods/vec_resize_to_zero.rs
index 5debaab2067b..8979f9973d6f 100644
--- a/clippy_lints/src/methods/vec_resize_to_zero.rs
+++ b/clippy_lints/src/methods/vec_resize_to_zero.rs
@@ -5,8 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, sym};
+use rustc_span::{Span, Spanned, sym};
 
 use super::VEC_RESIZE_TO_ZERO;
 
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 2773f537efc6..b5becbdeb30d 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -15,8 +15,7 @@
 use rustc_hir::{Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, Spanned, Symbol, sym};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 56001a185771..e5a5b46b7b2e 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -7,8 +7,7 @@
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::HasTyCtxt;
 use rustc_middle::ty::{Ty, TypeckResults};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Span, Spanned};
 
 use clippy_utils::SpanlessEq;
 use clippy_utils::diagnostics::span_lint_and_note;
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index 97b3c0d02e84..6c6221525b57 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -6,7 +6,7 @@
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::FLOAT_EQUALITY_WITHOUT_ABS;
 
diff --git a/clippy_lints/src/operators/manual_div_ceil.rs b/clippy_lints/src/operators/manual_div_ceil.rs
index 6751532ecbc7..a0f61f6d36c4 100644
--- a/clippy_lints/src/operators/manual_div_ceil.rs
+++ b/clippy_lints/src/operators/manual_div_ceil.rs
@@ -9,7 +9,7 @@
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 use super::MANUAL_DIV_CEIL;
 
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 034fe8edc715..1f0371c78200 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -5,7 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 61087ad88457..39019c646bd5 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -14,8 +14,7 @@
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::{self, ClauseKind, GenericArgKind, PredicatePolarity, Ty};
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Spanned;
-use rustc_span::{DesugaringKind, Span};
+use rustc_span::{DesugaringKind, Span, Spanned};
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index ab11c37b5041..61b5842ea542 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -11,7 +11,7 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 9fa4d2c142b5..44e35b8dc71b 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -8,7 +8,7 @@
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 0c78ed84adc4..01482b2475f7 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -14,9 +14,8 @@
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
-use rustc_span::{Span, SyntaxContext};
+use rustc_span::{Span, Spanned, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints_internal/src/lint_without_lint_pass.rs b/clippy_lints_internal/src/lint_without_lint_pass.rs
index f56b6f31550b..cab1422c3000 100644
--- a/clippy_lints_internal/src/lint_without_lint_pass.rs
+++ b/clippy_lints_internal/src/lint_without_lint_pass.rs
@@ -12,9 +12,8 @@
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
+use rustc_span::{Span, Spanned};
 
 declare_tool_lint! {
     /// ### What it does

From f441cc675bfa7bc98630a21f8f9b3a63d2e19c20 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 16:12:05 +1100
Subject: [PATCH 0322/1059] Move `Spanned`.

It's defined in `rustc_span::source_map` which doesn't make any sense
because it has nothing to do with source maps. This commit moves it to
the crate root, a more sensible spot for something this basic.
---
 src/abi/mod.rs        | 2 +-
 src/common.rs         | 3 +--
 src/intrinsics/mod.rs | 3 +--
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/abi/mod.rs b/src/abi/mod.rs
index 97a19b8976d3..13f5ad5157ce 100644
--- a/src/abi/mod.rs
+++ b/src/abi/mod.rs
@@ -20,7 +20,7 @@
 use rustc_middle::ty::layout::FnAbiOf;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::Session;
-use rustc_span::source_map::Spanned;
+use rustc_span::Spanned;
 use rustc_target::callconv::{FnAbi, PassMode};
 use rustc_target::spec::Arch;
 use smallvec::{SmallVec, smallvec};
diff --git a/src/common.rs b/src/common.rs
index b11f42408f58..b22afca847aa 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -6,8 +6,7 @@
 use rustc_middle::ty::layout::{
     self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers,
 };
-use rustc_span::Symbol;
-use rustc_span::source_map::Spanned;
+use rustc_span::{Spanned, Symbol};
 use rustc_target::callconv::FnAbi;
 use rustc_target::spec::{Arch, HasTargetSpec, Target};
 
diff --git a/src/intrinsics/mod.rs b/src/intrinsics/mod.rs
index ab9a11305baa..da8569dac746 100644
--- a/src/intrinsics/mod.rs
+++ b/src/intrinsics/mod.rs
@@ -24,8 +24,7 @@ macro_rules! intrinsic_args {
 use rustc_middle::ty::GenericArgsRef;
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
-use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, sym};
+use rustc_span::{Spanned, Symbol, sym};
 use rustc_target::spec::PanicStrategy;
 
 pub(crate) use self::llvm::codegen_llvm_intrinsic_call;

From 321d6f8d4aa5302ff4a6a692d0b166ebed7b8755 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Tue, 10 Mar 2026 17:16:55 -0400
Subject: [PATCH 0323/1059] Make Enzyme has dependent on LLVM hash

---
 src/bootstrap/src/core/build_steps/llvm.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index 0c607cb6ba6f..b0f8cdd28e82 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -1151,12 +1151,18 @@ fn run(self, builder: &Builder<'_>) -> Self::Output {
 
         let LlvmResult { host_llvm_config, llvm_cmake_dir } = builder.ensure(Llvm { target });
 
+        // Enzyme links against LLVM. If we update the LLVM submodule libLLVM might get a new
+        // version number, in which case Enzyme will now fail to find LLVM. By including the LLVM
+        // hash into the Enzyme hash we force a rebuild of Enzyme when updating LLVM.
+        let enzyme_hash_input = builder.in_tree_llvm_info.sha().unwrap_or_default().to_owned()
+            + builder.enzyme_info.sha().unwrap_or_default();
+
         static STAMP_HASH_MEMO: OnceLock<String> = OnceLock::new();
         let smart_stamp_hash = STAMP_HASH_MEMO.get_or_init(|| {
             generate_smart_stamp_hash(
                 builder,
                 &builder.config.src.join("src/tools/enzyme"),
-                builder.enzyme_info.sha().unwrap_or_default(),
+                &enzyme_hash_input,
             )
         });
 

From 86da9312dc68ffb72cd1d28a99946dc4d37690c1 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Tue, 10 Mar 2026 22:15:04 +0800
Subject: [PATCH 0324/1059] mir-opt: Drop invalid debuginfos after
 SingleUseConsts.

---
 compiler/rustc_middle/src/mir/statement.rs    | 11 +++--
 .../src/single_use_consts.rs                  |  4 ++
 .../src/strip_debuginfo.rs                    | 27 +++++-----
 ...sts.invalid_debuginfo.SingleUseConsts.diff | 49 +++++++++++++++++++
 tests/mir-opt/debuginfo/single_use_consts.rs  | 25 ++++++++++
 5 files changed, 96 insertions(+), 20 deletions(-)
 create mode 100644 tests/mir-opt/debuginfo/single_use_consts.invalid_debuginfo.SingleUseConsts.diff
 create mode 100644 tests/mir-opt/debuginfo/single_use_consts.rs

diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 48dcef298d66..f66c4755de4d 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -1050,11 +1050,12 @@ pub fn extend(&mut self, debuginfos: &Self) {
         self.0.extend_from_slice(debuginfos);
     }
 
-    pub fn retain<F>(&mut self, f: F)
-    where
-        F: FnMut(&StmtDebugInfo<'tcx>) -> bool,
-    {
-        self.0.retain(f);
+    pub fn retain_locals(&mut self, locals: &DenseBitSet<Local>) {
+        self.retain(|debuginfo| match debuginfo {
+            StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => {
+                locals.contains(*local)
+            }
+        });
     }
 }
 
diff --git a/compiler/rustc_mir_transform/src/single_use_consts.rs b/compiler/rustc_mir_transform/src/single_use_consts.rs
index 6d33736d64ec..91e040d5cbc8 100644
--- a/compiler/rustc_mir_transform/src/single_use_consts.rs
+++ b/compiler/rustc_mir_transform/src/single_use_consts.rs
@@ -5,6 +5,8 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 
+use crate::strip_debuginfo::drop_invalid_debuginfos;
+
 /// Various parts of MIR building introduce temporaries that are commonly not needed.
 ///
 /// Notably, `if CONST` and `match CONST` end up being used-once temporaries, which
@@ -82,6 +84,8 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
                 );
             }
         }
+
+        drop_invalid_debuginfos(body);
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/strip_debuginfo.rs b/compiler/rustc_mir_transform/src/strip_debuginfo.rs
index 7fec25ccb521..5931a4666024 100644
--- a/compiler/rustc_mir_transform/src/strip_debuginfo.rs
+++ b/compiler/rustc_mir_transform/src/strip_debuginfo.rs
@@ -32,24 +32,21 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             )
         });
 
-        let debuginfo_locals = debuginfo_locals(body);
-        for data in body.basic_blocks.as_mut_preserves_cfg() {
-            for stmt in data.statements.iter_mut() {
-                stmt.debuginfos.retain(|debuginfo| match debuginfo {
-                    StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => {
-                        debuginfo_locals.contains(*local)
-                    }
-                });
-            }
-            data.after_last_stmt_debuginfos.retain(|debuginfo| match debuginfo {
-                StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => {
-                    debuginfo_locals.contains(*local)
-                }
-            });
-        }
+        drop_invalid_debuginfos(body);
     }
 
     fn is_required(&self) -> bool {
         true
     }
 }
+
+// Drop invalid debuginfos when strip locals in `var_debug_info`.
+pub(super) fn drop_invalid_debuginfos(body: &mut Body<'_>) {
+    let debuginfo_locals = debuginfo_locals(body);
+    for data in body.basic_blocks.as_mut_preserves_cfg() {
+        for stmt in data.statements.iter_mut() {
+            stmt.debuginfos.retain_locals(&debuginfo_locals);
+        }
+        data.after_last_stmt_debuginfos.retain_locals(&debuginfo_locals);
+    }
+}
diff --git a/tests/mir-opt/debuginfo/single_use_consts.invalid_debuginfo.SingleUseConsts.diff b/tests/mir-opt/debuginfo/single_use_consts.invalid_debuginfo.SingleUseConsts.diff
new file mode 100644
index 000000000000..09e9f26546a8
--- /dev/null
+++ b/tests/mir-opt/debuginfo/single_use_consts.invalid_debuginfo.SingleUseConsts.diff
@@ -0,0 +1,49 @@
+- // MIR for `invalid_debuginfo` before SingleUseConsts
++ // MIR for `invalid_debuginfo` after SingleUseConsts
+  
+  fn invalid_debuginfo() -> () {
+      let mut _0: ();
+      let _1: ();
+      scope 1 (inlined foo) {
+          let _2: ();
+          let mut _3: &isize;
+          let _4: &isize;
+          let _5: isize;
+          let mut _6: &isize;
+          scope 2 (inlined bar) {
+-             debug x => _4;
++             debug x => const foo::promoted[0];
+              let _7: isize;
+              let mut _9: &isize;
+              let _10: &isize;
+              scope 3 {
+-                 debug a => _7;
++                 debug a => const 1_isize;
+                  let mut _8: &isize;
+                  scope 4 {
+-                     debug z => _4;
++                     debug z => const foo::promoted[0];
+                  }
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_4);
+-         _4 = const foo::promoted[0];
++         nop;
+          StorageLive(_7);
+-         _7 = const 1_isize;
+-         // DBG: _4 = &_7;
++         nop;
+          StorageDead(_7);
+-         _1 = const ();
++         nop;
+          StorageDead(_4);
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/single_use_consts.rs b/tests/mir-opt/debuginfo/single_use_consts.rs
new file mode 100644
index 000000000000..eeae4cb7b81c
--- /dev/null
+++ b/tests/mir-opt/debuginfo/single_use_consts.rs
@@ -0,0 +1,25 @@
+//@ test-mir-pass: SingleUseConsts
+//@ compile-flags: -g -Zinline-mir -Zmir-enable-passes=+InstSimplify-after-simplifycfg,+DeadStoreElimination-final,+DestinationPropagation -Zvalidate-mir
+//! Regression test for <https://github.com/rust-lang/rust/issues/33013>.
+
+#![crate_type = "lib"]
+
+// EMIT_MIR single_use_consts.invalid_debuginfo.SingleUseConsts.diff
+pub fn invalid_debuginfo() {
+    // CHECK-LABEL: fn invalid_debuginfo(
+    // CHEK: debug x => const
+    // CHEK: debug z => const
+    // CHECK-NOT: DBG
+    // CHECK: return
+    foo();
+}
+
+pub fn foo() {
+    bar(&1);
+}
+
+fn bar(x: &isize) {
+    let a = 1;
+    let mut z = x;
+    z = &a;
+}

From d7923d4b3828b1ce4330266172dc6a9515b163a3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 10 Mar 2026 22:55:52 +0100
Subject: [PATCH 0325/1059] simd_add/sub/mul/neg: document overflow behavior

---
 library/core/src/intrinsics/simd.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
index 5fb2102c319e..50d887197379 100644
--- a/library/core/src/intrinsics/simd.rs
+++ b/library/core/src/intrinsics/simd.rs
@@ -62,6 +62,7 @@
 /// Adds two simd vectors elementwise.
 ///
 /// `T` must be a vector of integers or floats.
+/// For integers, wrapping arithmetic is used.
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn simd_add<T>(x: T, y: T) -> T;
@@ -69,6 +70,7 @@
 /// Subtracts `rhs` from `lhs` elementwise.
 ///
 /// `T` must be a vector of integers or floats.
+/// For integers, wrapping arithmetic is used.
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn simd_sub<T>(lhs: T, rhs: T) -> T;
@@ -76,6 +78,7 @@
 /// Multiplies two simd vectors elementwise.
 ///
 /// `T` must be a vector of integers or floats.
+/// For integers, wrapping arithmetic is used.
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn simd_mul<T>(x: T, y: T) -> T;
@@ -233,8 +236,7 @@
 /// Negates a vector elementwise.
 ///
 /// `T` must be a vector of integers or floats.
-///
-/// Rust panics for `-<int>::Min` due to overflow, but it is not UB with this intrinsic.
+/// For integers, wrapping arithmetic is used.
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn simd_neg<T>(x: T) -> T;

From de94c5cd347a18699b9cc8e838b204616ed569a2 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 10 Mar 2026 23:28:32 +0100
Subject: [PATCH 0326/1059] improve target feature diagnostic

---
 compiler/rustc_codegen_ssa/src/errors.rs      | 17 ++++-
 .../rustc_codegen_ssa/src/target_features.rs  |  5 +-
 tests/auxiliary/minicore.rs                   |  2 +
 tests/ui/target-feature/invalid-attribute.rs  | 17 ++++-
 .../target-feature/invalid-attribute.stderr   | 76 +++++++++++--------
 5 files changed, 77 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index be1965f67491..41337fc21a7b 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -1248,8 +1248,21 @@ pub(crate) struct FeatureNotValid<'a> {
     #[primary_span]
     #[label("`{$feature}` is not valid for this target")]
     pub span: Span,
-    #[help("consider removing the leading `+` in the feature name")]
-    pub plus_hint: bool,
+    #[subdiagnostic]
+    pub plus_hint: Option<RemovePlusFromFeatureName<'a>>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    "consider removing the leading `+` in the feature name",
+    code = "enable = \"{stripped}\"",
+    applicability = "maybe-incorrect",
+    style = "verbose"
+)]
+pub struct RemovePlusFromFeatureName<'a> {
+    #[primary_span]
+    pub span: Span,
+    pub stripped: &'a str,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index e9209657984e..08a02831312c 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -14,7 +14,7 @@
 use rustc_target::target_features::{RUSTC_SPECIFIC_FEATURES, Stability};
 use smallvec::SmallVec;
 
-use crate::errors::FeatureNotValid;
+use crate::errors::{FeatureNotValid, RemovePlusFromFeatureName};
 use crate::{errors, target_features};
 
 /// Compute the enabled target features from the `#[target_feature]` function attribute.
@@ -34,7 +34,8 @@ pub(crate) fn from_target_feature_attr(
         let Some(stability) = rust_target_features.get(feature_str) else {
             let plus_hint = feature_str
                 .strip_prefix('+')
-                .is_some_and(|stripped| rust_target_features.contains_key(stripped));
+                .filter(|stripped| rust_target_features.contains_key(*stripped))
+                .map(|stripped| RemovePlusFromFeatureName { span: feature_span, stripped });
             tcx.dcx().emit_err(FeatureNotValid {
                 feature: feature_str,
                 span: feature_span,
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 17f325d58278..c91c5dfbeb15 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -236,6 +236,8 @@ pub trait Sync {}
     ]
 );
 
+impl Sync for () {}
+
 #[lang = "drop_in_place"]
 fn drop_in_place<T>(_: *mut T) {}
 
diff --git a/tests/ui/target-feature/invalid-attribute.rs b/tests/ui/target-feature/invalid-attribute.rs
index a958700231a3..47068fbb25d4 100644
--- a/tests/ui/target-feature/invalid-attribute.rs
+++ b/tests/ui/target-feature/invalid-attribute.rs
@@ -1,14 +1,20 @@
-//@ only-x86_64
+//@ add-minicore
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
 
 #![warn(unused_attributes)]
+#![feature(no_core)]
+#![no_core]
+
+use minicore::*;
 
 #[target_feature(enable = "sse2")]
 //~^ ERROR attribute cannot be used on
-extern crate alloc;
+extern crate minicore;
 
 #[target_feature(enable = "sse2")]
 //~^ ERROR attribute cannot be used on
-use alloc::alloc::alloc;
+use minicore::mem::transmute;
 
 #[target_feature(enable = "sse2")]
 //~^ ERROR attribute cannot be used on
@@ -112,3 +118,8 @@ fn main() {
 //~^ ERROR `+sse2` is not valid for this target
 //~| NOTE `+sse2` is not valid for this target
 unsafe fn hey() {}
+
+#[target_feature(enable = "+sse5")]
+//~^ ERROR `+sse5` is not valid for this target
+//~| NOTE `+sse5` is not valid for this target
+unsafe fn typo() {}
diff --git a/tests/ui/target-feature/invalid-attribute.stderr b/tests/ui/target-feature/invalid-attribute.stderr
index 05a836b01af5..fbc35cfdc325 100644
--- a/tests/ui/target-feature/invalid-attribute.stderr
+++ b/tests/ui/target-feature/invalid-attribute.stderr
@@ -1,5 +1,5 @@
 error: `#[target_feature]` attribute cannot be used on extern crates
-  --> $DIR/invalid-attribute.rs:5:1
+  --> $DIR/invalid-attribute.rs:11:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on use statements
-  --> $DIR/invalid-attribute.rs:9:1
+  --> $DIR/invalid-attribute.rs:15:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on foreign modules
-  --> $DIR/invalid-attribute.rs:13:1
+  --> $DIR/invalid-attribute.rs:19:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error[E0539]: malformed `target_feature` attribute input
-  --> $DIR/invalid-attribute.rs:17:1
+  --> $DIR/invalid-attribute.rs:23:1
    |
 LL | #[target_feature = "+sse2"]
    | ^^^^^^^^^^^^^^^^^---------^
@@ -32,7 +32,7 @@ LL | #[target_feature = "+sse2"]
    | help: must be of the form: `#[target_feature(enable = "feat1, feat2")]`
 
 error[E0539]: malformed `target_feature` attribute input
-  --> $DIR/invalid-attribute.rs:23:1
+  --> $DIR/invalid-attribute.rs:29:1
    |
 LL | #[target_feature(bar)]
    | ^^^^^^^^^^^^^^^^^---^^
@@ -41,7 +41,7 @@ LL | #[target_feature(bar)]
    | help: must be of the form: `#[target_feature(enable = "feat1, feat2")]`
 
 error[E0539]: malformed `target_feature` attribute input
-  --> $DIR/invalid-attribute.rs:26:1
+  --> $DIR/invalid-attribute.rs:32:1
    |
 LL | #[target_feature(disable = "baz")]
    | ^^^^^^^^^^^^^^^^^-------^^^^^^^^^^
@@ -50,7 +50,7 @@ LL | #[target_feature(disable = "baz")]
    | help: must be of the form: `#[target_feature(enable = "feat1, feat2")]`
 
 error: `#[target_feature]` attribute cannot be used on modules
-  --> $DIR/invalid-attribute.rs:31:1
+  --> $DIR/invalid-attribute.rs:37:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,7 +58,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on constants
-  --> $DIR/invalid-attribute.rs:35:1
+  --> $DIR/invalid-attribute.rs:41:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on structs
-  --> $DIR/invalid-attribute.rs:39:1
+  --> $DIR/invalid-attribute.rs:45:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on enums
-  --> $DIR/invalid-attribute.rs:43:1
+  --> $DIR/invalid-attribute.rs:49:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on unions
-  --> $DIR/invalid-attribute.rs:47:1
+  --> $DIR/invalid-attribute.rs:53:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on type aliases
-  --> $DIR/invalid-attribute.rs:54:1
+  --> $DIR/invalid-attribute.rs:60:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -98,7 +98,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on traits
-  --> $DIR/invalid-attribute.rs:58:1
+  --> $DIR/invalid-attribute.rs:64:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -106,7 +106,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on statics
-  --> $DIR/invalid-attribute.rs:69:1
+  --> $DIR/invalid-attribute.rs:75:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,14 +114,6 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on trait impl blocks
-  --> $DIR/invalid-attribute.rs:73:1
-   |
-LL | #[target_feature(enable = "sse2")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: `#[target_feature]` can only be applied to functions
-
-error: `#[target_feature]` attribute cannot be used on inherent impl blocks
   --> $DIR/invalid-attribute.rs:79:1
    |
 LL | #[target_feature(enable = "sse2")]
@@ -129,8 +121,16 @@ LL | #[target_feature(enable = "sse2")]
    |
    = help: `#[target_feature]` can only be applied to functions
 
+error: `#[target_feature]` attribute cannot be used on inherent impl blocks
+  --> $DIR/invalid-attribute.rs:85:1
+   |
+LL | #[target_feature(enable = "sse2")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `#[target_feature]` can only be applied to functions
+
 error: `#[target_feature]` attribute cannot be used on expressions
-  --> $DIR/invalid-attribute.rs:100:5
+  --> $DIR/invalid-attribute.rs:106:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -138,7 +138,7 @@ LL |     #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on closures
-  --> $DIR/invalid-attribute.rs:106:5
+  --> $DIR/invalid-attribute.rs:112:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,7 +146,7 @@ LL |     #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can be applied to functions and methods
 
 error[E0658]: cannot use `#[inline(always)]` with `#[target_feature]`
-  --> $DIR/invalid-attribute.rs:62:1
+  --> $DIR/invalid-attribute.rs:68:1
    |
 LL | #[inline(always)]
    | ^^^^^^^^^^^^^^^^^
@@ -156,13 +156,13 @@ LL | #[inline(always)]
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: the feature named `foo` is not valid for this target
-  --> $DIR/invalid-attribute.rs:20:18
+  --> $DIR/invalid-attribute.rs:26:18
    |
 LL | #[target_feature(enable = "foo")]
    |                  ^^^^^^^^^^^^^^ `foo` is not valid for this target
 
 error[E0046]: not all trait items implemented, missing: `foo`
-  --> $DIR/invalid-attribute.rs:75:1
+  --> $DIR/invalid-attribute.rs:81:1
    |
 LL | impl Quux for u8 {}
    | ^^^^^^^^^^^^^^^^ missing `foo` in implementation
@@ -171,7 +171,7 @@ LL |     fn foo();
    |     --------- `foo` from trait
 
 error: `#[target_feature(..)]` cannot be applied to safe trait method
-  --> $DIR/invalid-attribute.rs:89:5
+  --> $DIR/invalid-attribute.rs:95:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be applied to safe trait method
@@ -180,13 +180,13 @@ LL |     fn foo() {}
    |     -------- not an `unsafe` function
 
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/invalid-attribute.rs:92:5
+  --> $DIR/invalid-attribute.rs:98:5
    |
 LL |     fn foo() {}
    |     ^^^^^^^^ expected safe fn, found unsafe fn
    |
 note: type in trait
-  --> $DIR/invalid-attribute.rs:84:5
+  --> $DIR/invalid-attribute.rs:90:5
    |
 LL |     fn foo();
    |     ^^^^^^^^^
@@ -194,14 +194,24 @@ LL |     fn foo();
               found signature `#[target_features] fn()`
 
 error: the feature named `+sse2` is not valid for this target
-  --> $DIR/invalid-attribute.rs:111:18
+  --> $DIR/invalid-attribute.rs:117:18
    |
 LL | #[target_feature(enable = "+sse2")]
    |                  ^^^^^^^^^^^^^^^^ `+sse2` is not valid for this target
    |
-   = help: consider removing the leading `+` in the feature name
+help: consider removing the leading `+` in the feature name
+   |
+LL - #[target_feature(enable = "+sse2")]
+LL + #[target_feature(enable = "sse2")]
+   |
 
-error: aborting due to 24 previous errors
+error: the feature named `+sse5` is not valid for this target
+  --> $DIR/invalid-attribute.rs:122:18
+   |
+LL | #[target_feature(enable = "+sse5")]
+   |                  ^^^^^^^^^^^^^^^^ `+sse5` is not valid for this target
+
+error: aborting due to 25 previous errors
 
 Some errors have detailed explanations: E0046, E0053, E0539, E0658.
 For more information about an error, try `rustc --explain E0046`.

From 73fe905f3c43f8829c36b04eb52ba534e448fa53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Tue, 10 Mar 2026 21:53:03 +0000
Subject: [PATCH 0327/1059] Detect inherent method behind deref being shadowed
 by trait method

```
error[E0277]: the trait bound `Rc<RefCell<S>>: Borrow<S>` is not satisfied
  --> $DIR/shadowed-intrinsic-method-deref.rs:16:22
   |
LL |     let sb : &S = &s.borrow();
   |                      ^^^^^^ the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
   |
help: the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
      but trait `Borrow<RefCell<S>>` is implemented for it
  --> $SRC_DIR/alloc/src/rc.rs:LL:COL
   = help: for that trait implementation, expected `RefCell<S>`, found `S`
   = note: there's an inherent method on `RefCell<S>` of the same name, which can be auto-dereferenced from `&RefCell<T>`
help: to access the inherent method on `RefCell<S>`, use the fully-qualified path
   |
LL -     let sb : &S = &s.borrow();
LL +     let sb : &S = &RefCell::borrow(&s);
   |
```

In the example above, method `borrow` is available both on `<RefCell<S> as Borrow<S>>` *and* on `RefCell<S>`. Adding the import `use std::borrow::Borrow;` causes `s.borrow()` to find the former instead of the latter. We now point out that the other exists, and provide a suggestion on how to call it.
---
 .../traits/fulfillment_errors.rs              |  1 +
 .../src/error_reporting/traits/suggestions.rs | 73 +++++++++++++++++++
 ...diagnostic-derive-doc-comment-field.stderr |  1 +
 .../diagnostic-derive-inline.stderr           |  1 +
 .../shadowed-intrinsic-method-deref.fixed     | 21 ++++++
 .../shadowed-intrinsic-method-deref.rs        | 21 ++++++
 .../shadowed-intrinsic-method-deref.stderr    | 20 +++++
 7 files changed, 138 insertions(+)
 create mode 100644 tests/ui/methods/shadowed-intrinsic-method-deref.fixed
 create mode 100644 tests/ui/methods/shadowed-intrinsic-method-deref.rs
 create mode 100644 tests/ui/methods/shadowed-intrinsic-method-deref.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 364152475e94..fdb385902212 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -3178,6 +3178,7 @@ fn try_to_add_help_message(
 
             self.suggest_tuple_wrapping(err, root_obligation, obligation);
         }
+        self.suggest_shadowed_inherent_method(err, obligation, trait_predicate);
     }
 
     fn add_help_message_for_fn_trait(
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 14aff65d4b51..ee2f8d9783cf 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4916,6 +4916,79 @@ pub(super) fn suggest_tuple_wrapping(
         }
     }
 
+    pub(super) fn suggest_shadowed_inherent_method(
+        &self,
+        err: &mut Diag<'_>,
+        obligation: &PredicateObligation<'tcx>,
+        trait_predicate: ty::PolyTraitPredicate<'tcx>,
+    ) {
+        let ObligationCauseCode::FunctionArg { call_hir_id, .. } = obligation.cause.code() else {
+            return;
+        };
+        let Node::Expr(call) = self.tcx.hir_node(*call_hir_id) else { return };
+        let hir::ExprKind::MethodCall(segment, rcvr, args, ..) = call.kind else { return };
+        let Some(typeck) = &self.typeck_results else { return };
+        let Some(rcvr_ty) = typeck.expr_ty_adjusted_opt(rcvr) else { return };
+        let rcvr_ty = self.resolve_vars_if_possible(rcvr_ty);
+        let autoderef = (self.autoderef_steps)(rcvr_ty);
+        for (ty, def_id) in autoderef.iter().filter_map(|(ty, obligations)| {
+            if let ty::Adt(def, _) = ty.kind()
+                && *ty != rcvr_ty.peel_refs()
+                && obligations.iter().all(|obligation| self.predicate_may_hold(obligation))
+            {
+                Some((ty, def.did()))
+            } else {
+                None
+            }
+        }) {
+            for impl_def_id in self.tcx.inherent_impls(def_id) {
+                if *impl_def_id == trait_predicate.def_id() {
+                    continue;
+                }
+                for m in self
+                    .tcx
+                    .provided_trait_methods(*impl_def_id)
+                    .filter(|m| m.name() == segment.ident.name)
+                {
+                    let fn_sig = self.tcx.fn_sig(m.def_id);
+                    if fn_sig.skip_binder().inputs().skip_binder().len() != args.len() + 1 {
+                        continue;
+                    }
+                    let rcvr_ty = fn_sig.skip_binder().input(0).skip_binder();
+                    let (mutability, _ty) = match rcvr_ty.kind() {
+                        ty::Ref(_, ty, hir::Mutability::Mut) => ("&mut ", ty),
+                        ty::Ref(_, ty, _) => ("&", ty),
+                        _ => ("", &rcvr_ty),
+                    };
+                    let path = self.tcx.def_path_str(def_id);
+                    err.note(format!(
+                        "there's an inherent method on `{ty}` of the same name, which can be \
+                         auto-dereferenced from `{rcvr_ty}`"
+                    ));
+                    err.multipart_suggestion(
+                        format!(
+                            "to access the inherent method on `{ty}`, use the fully-qualified path",
+                        ),
+                        vec![
+                            (
+                                call.span.until(rcvr.span),
+                                format!("{path}::{}({}", m.name(), mutability),
+                            ),
+                            match &args {
+                                [] => (
+                                    rcvr.span.shrink_to_hi().with_hi(call.span.hi()),
+                                    ")".to_string(),
+                                ),
+                                [first, ..] => (rcvr.span.between(first.span), ", ".to_string()),
+                            },
+                        ],
+                        Applicability::MaybeIncorrect,
+                    );
+                }
+            }
+        }
+    }
+
     pub(super) fn explain_hrtb_projection(
         &self,
         diag: &mut Diag<'_>,
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.stderr b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.stderr
index 9149baaa4087..48a338db297e 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.stderr
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-doc-comment-field.stderr
@@ -13,6 +13,7 @@ help: the nightly-only, unstable trait `IntoDiagArg` is not implemented for `Not
 LL | struct NotIntoDiagArg;
    | ^^^^^^^^^^^^^^^^^^^^^
    = help: normalized in stderr
+   = note: there's an inherent method on `DiagInner` of the same name, which can be auto-dereferenced from `&mut DiagInner`
 note: required by a bound in `Diag::<'a, G>::arg`
   --> $COMPILER_DIR/rustc_errors/src/diagnostic.rs:LL:CC
   ::: $COMPILER_DIR/rustc_errors/src/diagnostic.rs:LL:CC
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
index 48138fc9fb55..28800016cea9 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
@@ -589,6 +589,7 @@ help: the nightly-only, unstable trait `IntoDiagArg` is not implemented for `Hel
 LL | struct Hello {}
    | ^^^^^^^^^^^^
    = help: normalized in stderr
+   = note: there's an inherent method on `DiagInner` of the same name, which can be auto-dereferenced from `&mut DiagInner`
 note: required by a bound in `Diag::<'a, G>::arg`
   --> $COMPILER_DIR/rustc_errors/src/diagnostic.rs:LL:CC
   ::: $COMPILER_DIR/rustc_errors/src/diagnostic.rs:LL:CC
diff --git a/tests/ui/methods/shadowed-intrinsic-method-deref.fixed b/tests/ui/methods/shadowed-intrinsic-method-deref.fixed
new file mode 100644
index 000000000000..927c168af568
--- /dev/null
+++ b/tests/ui/methods/shadowed-intrinsic-method-deref.fixed
@@ -0,0 +1,21 @@
+//@ run-rustfix
+#![allow(unused_imports)]
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::borrow::Borrow; // Without this import, the code would compile.
+
+pub struct S {
+    flag: bool,
+}
+
+type SCell = Rc<RefCell<S>>;
+
+fn main() {
+    // Type annotations just for clarity
+    let s : SCell = Rc::new(RefCell::new(S {flag: false}));
+    let sb : &S = &RefCell::borrow(&s);
+    //~^ ERROR: the trait bound `Rc<RefCell<S>>: Borrow<S>` is not satisfied [E0277]
+    //~| NOTE: the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
+    //~| NOTE: there's an inherent method on `RefCell<S>` of the same name
+    println!("{:?}", sb.flag);
+}
diff --git a/tests/ui/methods/shadowed-intrinsic-method-deref.rs b/tests/ui/methods/shadowed-intrinsic-method-deref.rs
new file mode 100644
index 000000000000..1e8ddb152d87
--- /dev/null
+++ b/tests/ui/methods/shadowed-intrinsic-method-deref.rs
@@ -0,0 +1,21 @@
+//@ run-rustfix
+#![allow(unused_imports)]
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::borrow::Borrow; // Without this import, the code would compile.
+
+pub struct S {
+    flag: bool,
+}
+
+type SCell = Rc<RefCell<S>>;
+
+fn main() {
+    // Type annotations just for clarity
+    let s : SCell = Rc::new(RefCell::new(S {flag: false}));
+    let sb : &S = &s.borrow();
+    //~^ ERROR: the trait bound `Rc<RefCell<S>>: Borrow<S>` is not satisfied [E0277]
+    //~| NOTE: the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
+    //~| NOTE: there's an inherent method on `RefCell<S>` of the same name
+    println!("{:?}", sb.flag);
+}
diff --git a/tests/ui/methods/shadowed-intrinsic-method-deref.stderr b/tests/ui/methods/shadowed-intrinsic-method-deref.stderr
new file mode 100644
index 000000000000..4e0c5dfc55f0
--- /dev/null
+++ b/tests/ui/methods/shadowed-intrinsic-method-deref.stderr
@@ -0,0 +1,20 @@
+error[E0277]: the trait bound `Rc<RefCell<S>>: Borrow<S>` is not satisfied
+  --> $DIR/shadowed-intrinsic-method-deref.rs:16:22
+   |
+LL |     let sb : &S = &s.borrow();
+   |                      ^^^^^^ the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
+   |
+help: the trait `Borrow<S>` is not implemented for `Rc<RefCell<S>>`
+      but trait `Borrow<RefCell<S>>` is implemented for it
+  --> $SRC_DIR/alloc/src/rc.rs:LL:COL
+   = help: for that trait implementation, expected `RefCell<S>`, found `S`
+   = note: there's an inherent method on `RefCell<S>` of the same name, which can be auto-dereferenced from `&RefCell<T>`
+help: to access the inherent method on `RefCell<S>`, use the fully-qualified path
+   |
+LL -     let sb : &S = &s.borrow();
+LL +     let sb : &S = &RefCell::borrow(&s);
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

From b36ee95a648153c1f00c27e6e741e2eeb838d34a Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 10 Mar 2026 17:06:59 -0700
Subject: [PATCH 0328/1059] ci: add runners for vanilla LLVM 22

Ubuntu 26.04 has `llvm-22` packages that we can test with.
The `Dockerfile` is otherwise the same as the `llvm-21` runners.
---
 .../host-x86_64/x86_64-gnu-llvm-22/Dockerfile | 66 +++++++++++++++++++
 src/ci/github-actions/jobs.yml                | 25 +++++++
 2 files changed, 91 insertions(+)
 create mode 100644 src/ci/docker/host-x86_64/x86_64-gnu-llvm-22/Dockerfile

diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-22/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-22/Dockerfile
new file mode 100644
index 000000000000..a22e8de90804
--- /dev/null
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-22/Dockerfile
@@ -0,0 +1,66 @@
+FROM ubuntu:26.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  bzip2 \
+  g++ \
+  gcc-multilib \
+  make \
+  ninja-build \
+  file \
+  curl \
+  ca-certificates \
+  python3 \
+  git \
+  cmake \
+  sudo \
+  gdb \
+  llvm-22-tools \
+  llvm-22-dev \
+  libedit-dev \
+  libssl-dev \
+  pkg-config \
+  zlib1g-dev \
+  xz-utils \
+  nodejs \
+  mingw-w64 \
+  # libgccjit dependencies
+  flex \
+  libmpfr-dev \
+  libgmp-dev \
+  libmpc3 \
+  libmpc-dev \
+  && rm -rf /var/lib/apt/lists/*
+
+# Install powershell (universal package) so we can test x.ps1 on Linux
+# FIXME: need a "universal" version that supports libicu74, but for now it still works to ignore that dep.
+RUN curl -sL "https://github.com/PowerShell/PowerShell/releases/download/v7.3.1/powershell_7.3.1-1.deb_amd64.deb" > powershell.deb && \
+    dpkg --ignore-depends=libicu72 -i powershell.deb && \
+    rm -f powershell.deb
+
+COPY scripts/sccache.sh /scripts/
+RUN sh /scripts/sccache.sh
+
+# We are disabling CI LLVM since this builder is intentionally using a host
+# LLVM, rather than the typical src/llvm-project LLVM.
+ENV NO_DOWNLOAD_CI_LLVM 1
+ENV EXTERNAL_LLVM 1
+
+# Using llvm-link-shared due to libffi issues -- see #34486
+ENV RUST_CONFIGURE_ARGS \
+      --build=x86_64-unknown-linux-gnu \
+      --llvm-root=/usr/lib/llvm-22 \
+      --enable-llvm-link-shared \
+      --set rust.randomize-layout=true \
+      --set rust.thin-lto-import-instr-limit=10
+
+COPY scripts/shared.sh /scripts/
+
+COPY scripts/x86_64-gnu-llvm.sh /scripts/
+COPY scripts/x86_64-gnu-llvm2.sh /scripts/
+COPY scripts/x86_64-gnu-llvm3.sh /scripts/
+COPY scripts/stage_2_test_set1.sh /scripts/
+COPY scripts/stage_2_test_set2.sh /scripts/
+
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 0687d142a350..fd4d6bdb3ba3 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -426,6 +426,31 @@ auto:
       DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
     <<: *job-linux-4c
 
+  # The x86_64-gnu-llvm-22 job is split into multiple jobs to run tests in parallel.
+  # x86_64-gnu-llvm-22-1 skips tests that run in x86_64-gnu-llvm-22-{2,3}.
+  - name: x86_64-gnu-llvm-22-1
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-22
+      DOCKER_SCRIPT: stage_2_test_set2.sh
+    <<: *job-linux-4c
+
+  # Skip tests that run in x86_64-gnu-llvm-22-{1,3}
+  - name: x86_64-gnu-llvm-22-2
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-22
+      DOCKER_SCRIPT: x86_64-gnu-llvm2.sh
+    <<: *job-linux-4c
+
+  # Skip tests that run in x86_64-gnu-llvm-22-{1,2}
+  - name: x86_64-gnu-llvm-22-3
+    env:
+      RUST_BACKTRACE: 1
+      IMAGE: x86_64-gnu-llvm-22
+      DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
+    <<: *job-linux-4c
+
   - name: x86_64-gnu-nopt
     <<: *job-linux-4c
 

From ed25d008a0e3c848d5c9d3724002cae154d44843 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 11 Mar 2026 00:43:04 +0000
Subject: [PATCH 0329/1059] Tweak E0599 note

When not finding a method for a type, but finding it for a single other impl, special case the output to emit a single message instead of a list.

```
error[E0599]: no associated item named `C` found for struct `Fail<i32, u32>` in the current scope
  --> $DIR/wrong-projection-self-ty-invalid-bivariant-arg2.rs:15:23
   |
LL | struct Fail<T: Proj<Assoc = U>, U>(T);
   | ---------------------------------- associated item `C` not found for this struct
...
LL |     Fail::<i32, u32>::C
   |                       ^ associated item not found in `Fail<i32, u32>`
   |
   = note: the associated item was found for `Fail<i32, i32>`
```
instead of

```
   = note: the associated item was found for
           - `Fail<i32, i32>`
```
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 68 +++++++++++--------
 ...ction-self-ty-invalid-bivariant-arg.stderr |  3 +-
 ...tion-self-ty-invalid-bivariant-arg2.stderr |  3 +-
 tests/ui/const-generics/lookup-method.stderr  |  3 +-
 tests/ui/issues/issue-30123.stderr            |  3 +-
 ...ethod-not-found-generic-arg-elision.stderr |  3 +-
 .../ufc-method-call.different_name.stderr     |  3 +-
 .../method_resolution.current.stderr          |  3 +-
 8 files changed, 47 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 1fe82bc7ff6b..9d496c66f968 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -14,7 +14,7 @@
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, MultiSpan, StashKey, listify, pluralize, struct_span_code_err,
+    Applicability, Diag, MultiSpan, StashKey, StringPart, listify, pluralize, struct_span_code_err,
 };
 use rustc_hir::attrs::diagnostic::OnUnimplementedNote;
 use rustc_hir::def::{CtorKind, DefKind, Res};
@@ -1413,33 +1413,45 @@ fn set_not_found_span_label(
                         }
                     })
                     .collect::<Vec<_>>();
-                if !inherent_impls_candidate.is_empty() {
-                    inherent_impls_candidate.sort_by_key(|&id| self.tcx.def_path_str(id));
-                    inherent_impls_candidate.dedup();
-
-                    // number of types to show at most
-                    let limit = if inherent_impls_candidate.len() == 5 { 5 } else { 4 };
-                    let type_candidates = inherent_impls_candidate
-                        .iter()
-                        .take(limit)
-                        .map(|impl_item| {
-                            format!(
-                                "- `{}`",
-                                self.tcx.at(span).type_of(*impl_item).instantiate_identity()
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join("\n");
-                    let additional_types = if inherent_impls_candidate.len() > limit {
-                        format!("\nand {} more types", inherent_impls_candidate.len() - limit)
-                    } else {
-                        "".to_string()
-                    };
-                    err.note(format!(
-                        "the {item_kind} was found for\n{type_candidates}{additional_types}"
-                    ));
-                    *find_candidate_for_method = mode == Mode::MethodCall;
-                }
+                inherent_impls_candidate.sort_by_key(|&id| self.tcx.def_path_str(id));
+                inherent_impls_candidate.dedup();
+                let msg = match &inherent_impls_candidate[..] {
+                    [] => return,
+                    [only] => {
+                        vec![
+                            StringPart::normal(format!("the {item_kind} was found for `")),
+                            StringPart::highlighted(
+                                self.tcx.at(span).type_of(*only).instantiate_identity().to_string(),
+                            ),
+                            StringPart::normal(format!("`")),
+                        ]
+                    }
+                    candidates => {
+                        // number of types to show at most
+                        let limit = if candidates.len() == 5 { 5 } else { 4 };
+                        let type_candidates = candidates
+                            .iter()
+                            .take(limit)
+                            .map(|impl_item| {
+                                format!(
+                                    "- `{}`",
+                                    self.tcx.at(span).type_of(*impl_item).instantiate_identity()
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        let additional_types = if candidates.len() > limit {
+                            format!("\nand {} more types", candidates.len() - limit)
+                        } else {
+                            "".to_string()
+                        };
+                        vec![StringPart::normal(format!(
+                            "the {item_kind} was found for\n{type_candidates}{additional_types}"
+                        ))]
+                    }
+                };
+                err.highlighted_note(msg);
+                *find_candidate_for_method = mode == Mode::MethodCall;
             }
         } else {
             let ty_str = if ty_str.len() > 50 { String::new() } else { format!("on `{ty_str}` ") };
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
index c58163931071..b17682eb83e4 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
@@ -16,8 +16,7 @@ LL | struct Fail<T>;
 LL |     Fail::<()>::C
    |                 ^ associated item not found in `Fail<()>`
    |
-   = note: the associated item was found for
-           - `Fail<i32>`
+   = note: the associated item was found for `Fail<i32>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
index 165e89010b68..d0c7df9de43b 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
@@ -24,8 +24,7 @@ LL | struct Fail<T: Proj<Assoc = U>, U>(T);
 LL |     Fail::<i32, u32>::C
    |                       ^ associated item not found in `Fail<i32, u32>`
    |
-   = note: the associated item was found for
-           - `Fail<i32, i32>`
+   = note: the associated item was found for `Fail<i32, i32>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/lookup-method.stderr b/tests/ui/const-generics/lookup-method.stderr
index 4cbd1e17c7be..f55812c1d0d0 100644
--- a/tests/ui/const-generics/lookup-method.stderr
+++ b/tests/ui/const-generics/lookup-method.stderr
@@ -7,8 +7,7 @@ LL | struct Builder<const A: bool, const B: bool>;
 LL |     b.cast().build();
    |              ^^^^^ method not found in `Builder<false, true>`
    |
-   = note: the method was found for
-           - `Builder<true, true>`
+   = note: the method was found for `Builder<true, true>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-30123.stderr b/tests/ui/issues/issue-30123.stderr
index 3ed1f34c44aa..db2e3dd78dd9 100644
--- a/tests/ui/issues/issue-30123.stderr
+++ b/tests/ui/issues/issue-30123.stderr
@@ -9,8 +9,7 @@ note: if you're trying to build a new `issue_30123_aux::Graph<i32, i32>`, consid
    |
 LL |     pub fn new() -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^
-   = note: the function or associated item was found for
-           - `issue_30123_aux::Graph<N, E, Undirected>`
+   = note: the function or associated item was found for `issue_30123_aux::Graph<N, E, Undirected>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/methods/method-not-found-generic-arg-elision.stderr b/tests/ui/methods/method-not-found-generic-arg-elision.stderr
index 75fabc27b0f7..3b4c761741b9 100644
--- a/tests/ui/methods/method-not-found-generic-arg-elision.stderr
+++ b/tests/ui/methods/method-not-found-generic-arg-elision.stderr
@@ -7,8 +7,7 @@ LL | struct Point<T> {
 LL |     let d = point_i32.distance();
    |                       ^^^^^^^^ method not found in `Point<i32>`
    |
-   = note: the method was found for
-           - `Point<f64>`
+   = note: the method was found for `Point<f64>`
 
 error[E0599]: no method named `other` found for struct `Point<T>` in the current scope
   --> $DIR/method-not-found-generic-arg-elision.rs:84:23
diff --git a/tests/ui/privacy/ufc-method-call.different_name.stderr b/tests/ui/privacy/ufc-method-call.different_name.stderr
index 16496c480dd1..c65fe51ca240 100644
--- a/tests/ui/privacy/ufc-method-call.different_name.stderr
+++ b/tests/ui/privacy/ufc-method-call.different_name.stderr
@@ -7,8 +7,7 @@ LL |     pub struct Foo<T>(T);
 LL |     test::Foo::<test::B>::foo();
    |                           ^^^ function or associated item not found in `Foo<B>`
    |
-   = note: the function or associated item was found for
-           - `Foo<A>`
+   = note: the function or associated item was found for `Foo<A>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/method_resolution.current.stderr b/tests/ui/type-alias-impl-trait/method_resolution.current.stderr
index 07e7126f8a05..660e4351d0ca 100644
--- a/tests/ui/type-alias-impl-trait/method_resolution.current.stderr
+++ b/tests/ui/type-alias-impl-trait/method_resolution.current.stderr
@@ -7,8 +7,7 @@ LL | struct Bar<T>(T);
 LL |         self.bar()
    |              ^^^ method not found in `Bar<u32>`
    |
-   = note: the method was found for
-           - `Bar<Foo>`
+   = note: the method was found for `Bar<Foo>`
 
 error: aborting due to 1 previous error
 

From 05ac9d4da294072ed7518524cc8c66f4db6959be Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 10 Mar 2026 15:26:20 -0600
Subject: [PATCH 0330/1059] Remove string content from panics

String content can be useful for debugging panics, particularly when you
are working on a small codebase where you can infer more about the path
taken through your program based on the content of the string.

In production deployments that upload crashes for centralized debugging,
string content poses a risk to user privacy. The string can accidentally
contain information that the user is not expecting to share with the
development team.

On balance it seems like the risks outweigh the benefits. It is easy to
add a `dbg!()` statement to gather more information in development; but
comparatively tricky to ensure panics are sanitized by every rust app
that monitors their production deployments.

Ref https://internals.rust-lang.org/t/stop-including-string-content-in-index-panics/24067
---
 library/alloctests/tests/str.rs | 28 ++++++++++------------------
 library/core/src/str/mod.rs     | 16 ++++++----------
 library/core/src/wtf8.rs        | 14 +++++++++++---
 3 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/library/alloctests/tests/str.rs b/library/alloctests/tests/str.rs
index 52cc8afeee90..c0bcdb8500af 100644
--- a/library/alloctests/tests/str.rs
+++ b/library/alloctests/tests/str.rs
@@ -612,14 +612,14 @@ fn test_slice_fail() {
             data: "abcdef";
             good: data[4..4] == "";
             bad: data[4..3];
-            message: "begin > end (4 > 3)";
+            message: "byte range starts at 4 but ends at 3";
         }
 
         in mod rangeinclusive_neg_width {
             data: "abcdef";
             good: data[4..=3] == "";
             bad: data[4..=2];
-            message: "begin > end (4 > 3)";
+            message: "byte range starts at 4 but ends at 3";
         }
     }
 
@@ -659,49 +659,49 @@ mod boundary {
                 data: super::DATA;
                 bad: data[super::BAD_START..super::GOOD_END];
                 message:
-                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
+                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5 of string)";
             }
 
             in mod range_2 {
                 data: super::DATA;
                 bad: data[super::GOOD_START..super::BAD_END];
                 message:
-                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of";
+                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7 of string)";
             }
 
             in mod rangefrom {
                 data: super::DATA;
                 bad: data[super::BAD_START..];
                 message:
-                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
+                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5 of string)";
             }
 
             in mod rangeto {
                 data: super::DATA;
                 bad: data[..super::BAD_END];
                 message:
-                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of";
+                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7 of string)";
             }
 
             in mod rangeinclusive_1 {
                 data: super::DATA;
                 bad: data[super::BAD_START..=super::GOOD_END_INCL];
                 message:
-                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
+                    "start byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5 of string)";
             }
 
             in mod rangeinclusive_2 {
                 data: super::DATA;
                 bad: data[super::GOOD_START..=super::BAD_END_INCL];
                 message:
-                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of";
+                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7 of string)";
             }
 
             in mod rangetoinclusive {
                 data: super::DATA;
                 bad: data[..=super::BAD_END_INCL];
                 message:
-                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of";
+                    "end byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7 of string)";
             }
         }
     }
@@ -716,18 +716,10 @@ mod boundary {
 
     // check the panic includes the prefix of the sliced string
     #[test]
-    #[should_panic(
-        expected = "end byte index 1024 is out of bounds of `Lorem ipsum dolor sit amet"
-    )]
+    #[should_panic(expected = "end byte index 1024 is out of bounds for string of length 416")]
     fn test_slice_fail_truncated_1() {
         let _ = &LOREM_PARAGRAPH[..1024];
     }
-    // check the truncation in the panic message
-    #[test]
-    #[should_panic(expected = "luctus, im`[...]")]
-    fn test_slice_fail_truncated_2() {
-        let _ = &LOREM_PARAGRAPH[..1024];
-    }
 }
 
 #[test]
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 98354643aa40..0d52bfb8c9aa 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -81,25 +81,21 @@ const fn slice_error_fail_ct(_: &str, _: usize, _: usize) -> ! {
 
 #[track_caller]
 fn slice_error_fail_rt(s: &str, begin: usize, end: usize) -> ! {
-    const MAX_DISPLAY_LENGTH: usize = 256;
-    let trunc_len = s.floor_char_boundary(MAX_DISPLAY_LENGTH);
-    let s_trunc = &s[..trunc_len];
-    let ellipsis = if trunc_len < s.len() { "[...]" } else { "" };
     let len = s.len();
 
     // 1. begin is OOB.
     if begin > len {
-        panic!("start byte index {begin} is out of bounds of `{s_trunc}`{ellipsis}");
+        panic!("start byte index {begin} is out of bounds for string of length {len}");
     }
 
     // 2. end is OOB.
     if end > len {
-        panic!("end byte index {end} is out of bounds of `{s_trunc}`{ellipsis}");
+        panic!("end byte index {end} is out of bounds for string of length {len}");
     }
 
     // 3. range is backwards.
     if begin > end {
-        panic!("begin > end ({begin} > {end}) when slicing `{s_trunc}`{ellipsis}")
+        panic!("byte range starts at {begin} but ends at {end}");
     }
 
     // 4. begin is inside a character.
@@ -109,7 +105,7 @@ fn slice_error_fail_rt(s: &str, begin: usize, end: usize) -> ! {
         let range = floor..ceil;
         let ch = s[floor..ceil].chars().next().unwrap();
         panic!(
-            "start byte index {begin} is not a char boundary; it is inside {ch:?} (bytes {range:?}) of `{s_trunc}`{ellipsis}"
+            "start byte index {begin} is not a char boundary; it is inside {ch:?} (bytes {range:?} of string)"
         )
     }
 
@@ -120,7 +116,7 @@ fn slice_error_fail_rt(s: &str, begin: usize, end: usize) -> ! {
         let range = floor..ceil;
         let ch = s[floor..ceil].chars().next().unwrap();
         panic!(
-            "end byte index {end} is not a char boundary; it is inside {ch:?} (bytes {range:?}) of `{s_trunc}`{ellipsis}"
+            "end byte index {end} is not a char boundary; it is inside {ch:?} (bytes {range:?} of string)"
         )
     }
 
@@ -128,7 +124,7 @@ fn slice_error_fail_rt(s: &str, begin: usize, end: usize) -> ! {
     // This test cannot be combined with 2. above because for cases like
     // `"abcαβγ"[4..9]` the error is that 4 is inside 'α', not that 9 is OOB.
     debug_assert_eq!(end, len);
-    panic!("end byte index {end} is out of bounds of `{s_trunc}`{ellipsis}");
+    panic!("end byte index {end} is out of bounds for string of length {len}");
 }
 
 impl str {
diff --git a/library/core/src/wtf8.rs b/library/core/src/wtf8.rs
index 7214918db6c3..ba922f81d928 100644
--- a/library/core/src/wtf8.rs
+++ b/library/core/src/wtf8.rs
@@ -484,11 +484,19 @@ unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {
     }
 }
 
-/// Copied from core::str::raw::slice_error_fail
 #[inline(never)]
 fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {
-    assert!(begin <= end);
-    panic!("index {begin} and/or {end} in `{s:?}` do not lie on character boundary");
+    let len = s.len();
+    if end > len {
+        panic!("end byte index {end} is out of bounds for string of length {len}");
+    }
+    if begin > end {
+        panic!("byte range starts at {begin} but ends at {end}");
+    }
+    if !s.is_code_point_boundary(begin) {
+        panic!("byte index {begin} is not a code point boundary");
+    }
+    panic!("byte index {end} is not a code point boundary");
 }
 
 /// Iterator for the code points of a WTF-8 string.

From e108da9dc263aa28fed4b5a51d5e08311be2355f Mon Sep 17 00:00:00 2001
From: James Kay <twey@twey.co.uk>
Date: Wed, 11 Mar 2026 02:25:56 +0000
Subject: [PATCH 0331/1059] `std`: include `dlmalloc` for all non-wasi Wasm
 targets

Currently, building std for a custom Wasm target with an OS other than `unknown` will fail, because `sys/alloc/mod.rs` will attempt to use `sys/alloc/wasm.rs`, the dlmalloc-based allocator used on `wasm32-unknown-unknown`.  However, currently dlmalloc is only pulled in when `target_os = "unknown"`.

Instead, we should make `Cargo.toml` and `alloc/mod.rs` match: either
- disable `wasm.rs` in `alloc/mod.rs` where `not(target_os = "unknown")`, or
- pull in `dlmalloc` for all Wasm targets with  `target_family = "wasm32"` that aren't covered by the [upper branches of `alloc/mod.rs`](https://github.com/rust-lang/rust/blob/main/library/std/src/sys/alloc/mod.rs#L72-L100).

This PR takes the latter approach, because it allows more code to compile without a custom allocator.
---
 library/std/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 1b7a41d69736..740d37617547 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -62,7 +62,7 @@ path = "../windows_link"
 rand = { version = "0.9.0", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.4.0"
 
-[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
+[target.'cfg(any(all(target_family = "wasm", not(target_os = "wasi")), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
 dlmalloc = { version = "0.2.10", features = ['rustc-dep-of-std'] }
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]

From 7ec050ac609988a083b42d66b7ed33dc513b5597 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 10 Mar 2026 20:49:18 -0600
Subject: [PATCH 0332/1059] Fix tests and tidy up wtf-8 failures

Co-authored-by: TKanX <124454788+TKanX@users.noreply.github.com>
---
 library/core/src/wtf8.rs                                       | 3 +++
 tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/library/core/src/wtf8.rs b/library/core/src/wtf8.rs
index ba922f81d928..a0978c3dafb4 100644
--- a/library/core/src/wtf8.rs
+++ b/library/core/src/wtf8.rs
@@ -487,6 +487,9 @@ unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {
 #[inline(never)]
 fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {
     let len = s.len();
+    if begin > len {
+        panic!("start byte index {begin} is out of bounds for string of length {len}");
+    }
     if end > len {
         panic!("end byte index {end} is out of bounds for string of length {len}");
     }
diff --git a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
index aee60c94f106..e07f35648827 100644
--- a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
+++ b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
@@ -1,4 +1,4 @@
 
 thread 'main' ($TID) panicked at $DIR/const-eval-select-backtrace-std.rs:6:8:
-start byte index 1 is out of bounds of ``
+start byte index 1 is out of bounds for string of length 0
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

From c6b7f630a5365ccfe2d4f24c7f5a4cc8499c5a55 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 5 Mar 2026 12:25:24 -0700
Subject: [PATCH 0333/1059] rustdoc: rename `--emit` names

These new names are pithier and match up with the rest of our
terminology:

- `--emit=html-static-files` matches the default name of the directory that
  it actually emits, which is `static.files` (the hyphen is used for
  emit because every other emit option uses hyphens, but the directory
  uses a dot because we don't want its name to conflict with a crate).
- `--emit=html-non-static-files` matches the convention that emit is a noun,
  not an adjective. It also matches up with static-files, and it
  logically groups with other data formats.

This commit changes the docs, but leaves in support for the old names,
to break the cycle with cargo and docs.rs. This commit needs merged,
then cargo and docs.rs will be updated to use the new names, then,
finally, the old names will be removed.
---
 src/librustdoc/config.rs                           | 14 +++++++++-----
 src/librustdoc/html/render/write_shared.rs         |  2 +-
 src/librustdoc/lib.rs                              |  2 +-
 tests/run-make/emit-shared-files/rmake.rs          |  4 ++--
 .../rustdoc-default-output/output-default.stdout   |  2 +-
 5 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 3d4b4e969157..f1fdce48181c 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -322,8 +322,8 @@ pub(crate) enum ModuleSorting {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum EmitType {
-    Toolchain,
-    InvocationSpecific,
+    HtmlStaticFiles,
+    HtmlNonStaticFiles,
     DepInfo(Option<OutFileName>),
 }
 
@@ -332,8 +332,12 @@ impl FromStr for EmitType {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "toolchain-shared-resources" => Ok(Self::Toolchain),
-            "invocation-specific" => Ok(Self::InvocationSpecific),
+            // old nightly-only choices that are going away soon
+            "toolchain-shared-resources" => Ok(Self::HtmlStaticFiles),
+            "invocation-specific" => Ok(Self::HtmlNonStaticFiles),
+            // modern choices
+            "html-static-files" => Ok(Self::HtmlStaticFiles),
+            "html-non-static-files" => Ok(Self::HtmlNonStaticFiles),
             "dep-info" => Ok(Self::DepInfo(None)),
             option => match option.strip_prefix("dep-info=") {
                 Some("-") => Ok(Self::DepInfo(Some(OutFileName::Stdout))),
@@ -346,7 +350,7 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
 
 impl RenderOptions {
     pub(crate) fn should_emit_crate(&self) -> bool {
-        self.emit.is_empty() || self.emit.contains(&EmitType::InvocationSpecific)
+        self.emit.is_empty() || self.emit.contains(&EmitType::HtmlNonStaticFiles)
     }
 
     pub(crate) fn dep_info(&self) -> Option<Option<&OutFileName>> {
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index 1b5dbeed8de8..b1c77063ca94 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -218,7 +218,7 @@ fn write_static_files(
         try_err!(fs::write(&dst_path, buffer), &dst_path);
     }
 
-    if opt.emit.is_empty() || opt.emit.contains(&EmitType::Toolchain) {
+    if opt.emit.is_empty() || opt.emit.contains(&EmitType::HtmlStaticFiles) {
         static_files::for_each(|f: &static_files::StaticFile| {
             let filename = static_dir.join(f.output_filename());
             let contents: &[u8] =
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 8cad0210ea34..3445221e4dce 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -537,7 +537,7 @@ fn opts() -> Vec<RustcOptGroup> {
             "",
             "emit",
             "Comma separated list of types of output for rustdoc to emit",
-            "[toolchain-shared-resources,invocation-specific,dep-info]",
+            "[html-static-files,html-non-static-files,dep-info]",
         ),
         opt(Unstable, FlagMulti, "", "no-run", "Compile doctests without running them", ""),
         opt(
diff --git a/tests/run-make/emit-shared-files/rmake.rs b/tests/run-make/emit-shared-files/rmake.rs
index bd868d4fd19e..9841dce27fa2 100644
--- a/tests/run-make/emit-shared-files/rmake.rs
+++ b/tests/run-make/emit-shared-files/rmake.rs
@@ -34,7 +34,7 @@ fn main() {
 
     rustdoc()
         .arg("-Zunstable-options")
-        .arg("--emit=toolchain-shared-resources")
+        .arg("--emit=html-static-files")
         .out_dir("toolchain-only")
         .arg("--resource-suffix=-xxx")
         .args(&["--extend-css", "z.css"])
@@ -68,7 +68,7 @@ fn main() {
 
     rustdoc()
         .arg("-Zunstable-options")
-        .arg("--emit=toolchain-shared-resources")
+        .arg("--emit=html-static-files")
         .out_dir("all-shared")
         .arg("--resource-suffix=-xxx")
         .args(&["--extend-css", "z.css"])
diff --git a/tests/run-make/rustdoc-default-output/output-default.stdout b/tests/run-make/rustdoc-default-output/output-default.stdout
index 4e28be347cbb..bc3a67a1ebcd 100644
--- a/tests/run-make/rustdoc-default-output/output-default.stdout
+++ b/tests/run-make/rustdoc-default-output/output-default.stdout
@@ -150,7 +150,7 @@ Options:
         --generate-redirect-map 
                         Generate JSON file at the top level instead of
                         generating HTML redirection files
-        --emit [toolchain-shared-resources,invocation-specific,dep-info]
+        --emit [html-static-files,html-non-static-files,dep-info]
                         Comma separated list of types of output for rustdoc to
                         emit
         --no-run        Compile doctests without running them

From 3a558f6389a565e58ca59d2d009ed70a4093b9a3 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 9 Mar 2026 20:09:15 +1100
Subject: [PATCH 0334/1059] Eliminate `QueryLatchInfo`.

The boolean `complete` flag indicates whether the `waiters` vec is still
in use, which means the `waiters` vec must be empty when `complete` is
true. This is achieved by using `drain` on the waiters just after
`complete` is set.

We can do better by using the type system to make invalid combinations
impossible. This commit removes `complete` and puts the waiters inside
an `Option`. `Some` means the query job is still active, and `None` once
it is complete. And `QueryLatchInfo` is eliminated.

(The `Arc<Mutex<Option<Vec<Arc<QueryWaiter<'tcx>>>>>>` type is a
mouthful, but when it's all in one place I find it easier to understand
than when it's split across two types. And we can use `Option` methods
like `as_ref`, `as_mut`, and `take`, which is nice.)
---
 compiler/rustc_middle/src/query/job.rs | 40 +++++++++++---------------
 compiler/rustc_query_impl/src/job.rs   |  2 +-
 2 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index 23ca15d3f8a1..923eae045cae 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -77,22 +77,15 @@ pub struct QueryWaiter<'tcx> {
     pub cycle: Mutex<Option<CycleError<QueryStackDeferred<'tcx>>>>,
 }
 
-#[derive(Debug)]
-pub struct QueryLatchInfo<'tcx> {
-    pub complete: bool,
-    pub waiters: Vec<Arc<QueryWaiter<'tcx>>>,
-}
-
 #[derive(Clone, Debug)]
 pub struct QueryLatch<'tcx> {
-    pub info: Arc<Mutex<QueryLatchInfo<'tcx>>>,
+    /// The `Option` is `Some(..)` when the job is active, and `None` once completed.
+    pub waiters: Arc<Mutex<Option<Vec<Arc<QueryWaiter<'tcx>>>>>>,
 }
 
 impl<'tcx> QueryLatch<'tcx> {
     fn new() -> Self {
-        QueryLatch {
-            info: Arc::new(Mutex::new(QueryLatchInfo { complete: false, waiters: Vec::new() })),
-        }
+        QueryLatch { waiters: Arc::new(Mutex::new(Some(Vec::new()))) }
     }
 
     /// Awaits for the query job to complete.
@@ -102,10 +95,10 @@ pub fn wait_on(
         query: Option<QueryJobId>,
         span: Span,
     ) -> Result<(), CycleError<QueryStackDeferred<'tcx>>> {
-        let mut info = self.info.lock();
-        if info.complete {
-            return Ok(());
-        }
+        let mut waiters_guard = self.waiters.lock();
+        let Some(waiters) = &mut *waiters_guard else {
+            return Ok(()); // already complete
+        };
 
         let waiter =
             Arc::new(QueryWaiter { query, span, cycle: Mutex::new(None), condvar: Condvar::new() });
@@ -114,7 +107,7 @@ pub fn wait_on(
         // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
         // Both of these will remove it from the `waiters` list before resuming
         // this thread.
-        info.waiters.push(Arc::clone(&waiter));
+        waiters.push(Arc::clone(&waiter));
 
         // Awaits the caller on this latch by blocking the current thread.
         // If this detects a deadlock and the deadlock handler wants to resume this thread
@@ -122,9 +115,9 @@ pub fn wait_on(
         // getting the self.info lock.
         rustc_thread_pool::mark_blocked();
         tcx.jobserver_proxy.release_thread();
-        waiter.condvar.wait(&mut info);
+        waiter.condvar.wait(&mut waiters_guard);
         // Release the lock before we potentially block in `acquire_thread`
-        drop(info);
+        drop(waiters_guard);
         tcx.jobserver_proxy.acquire_thread();
 
         // FIXME: Get rid of this lock. We have ownership of the QueryWaiter
@@ -139,11 +132,10 @@ pub fn wait_on(
 
     /// Sets the latch and resumes all waiters on it
     fn set(&self) {
-        let mut info = self.info.lock();
-        debug_assert!(!info.complete);
-        info.complete = true;
+        let mut waiters_guard = self.waiters.lock();
+        let waiters = waiters_guard.take().unwrap(); // mark the latch as complete
         let registry = rustc_thread_pool::Registry::current();
-        for waiter in info.waiters.drain(..) {
+        for waiter in waiters {
             rustc_thread_pool::mark_unblocked(&registry);
             waiter.condvar.notify_one();
         }
@@ -152,9 +144,9 @@ fn set(&self) {
     /// Removes a single waiter from the list of waiters.
     /// This is used to break query cycles.
     pub fn extract_waiter(&self, waiter: usize) -> Arc<QueryWaiter<'tcx>> {
-        let mut info = self.info.lock();
-        debug_assert!(!info.complete);
+        let mut waiters_guard = self.waiters.lock();
+        let waiters = waiters_guard.as_mut().expect("non-empty waiters vec");
         // Remove the waiter from the list of waiters
-        info.waiters.remove(waiter)
+        waiters.remove(waiter)
     }
 }
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 2a7f7bf5efd4..9c095603cc84 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -136,7 +136,7 @@ fn visit_waiters<'tcx>(
 
     // Visit the explicit waiters which use condvars and are resumable
     if let Some(latch) = job_map.latch_of(query) {
-        for (i, waiter) in latch.info.lock().waiters.iter().enumerate() {
+        for (i, waiter) in latch.waiters.lock().as_ref().unwrap().iter().enumerate() {
             if let Some(waiter_query) = waiter.query {
                 // Return a value which indicates that this waiter can be resumed
                 visit(waiter.span, waiter_query).map_break(|_| Some((query, i)))?;

From 637a4162f0b3f2e5dc0978f1c45230e905157844 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 5 Mar 2026 16:37:52 +1100
Subject: [PATCH 0335/1059] Use `impl_erasable_for_simple_types!` for two more
 types.

These two types fit the pattern because they have no generics.
---
 compiler/rustc_middle/src/query/erase.rs | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 4d4833b4943e..da56b0827966 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -17,7 +17,6 @@
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
 use crate::query::plumbing::CyclePlaceholder;
 use crate::traits::solve;
-use crate::ty::adjustment::CoerceUnsizedInfo;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::{mir, traits};
 
@@ -162,10 +161,6 @@ impl Erasable for Result<Option<ty::Instance<'_>>, rustc_errors::ErrorGuaranteed
         [u8; size_of::<Result<Option<ty::Instance<'static>>, rustc_errors::ErrorGuaranteed>>()];
 }
 
-impl Erasable for Result<CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>>()];
-}
-
 impl Erasable
     for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, rustc_errors::ErrorGuaranteed>
 {
@@ -196,10 +191,6 @@ impl Erasable for Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled> {
         [u8; size_of::<Result<mir::ConstAlloc<'static>, mir::interpret::ErrorHandled>>()];
 }
 
-impl Erasable for Result<mir::ConstValue, mir::interpret::ErrorHandled> {
-    type Storage = [u8; size_of::<Result<mir::ConstValue, mir::interpret::ErrorHandled>>()];
-}
-
 impl Erasable for Option<(mir::ConstValue, Ty<'_>)> {
     type Storage = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
 }
@@ -343,6 +334,8 @@ impl Erasable for $ty {
     Result<(), rustc_errors::ErrorGuaranteed>,
     Result<(), rustc_middle::traits::query::NoSolution>,
     Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
+    Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>,
+    Result<mir::ConstValue, mir::interpret::ErrorHandled>,
     rustc_abi::ReprOptions,
     rustc_ast::expand::allocator::AllocatorKind,
     rustc_hir::DefaultBodyStability,

From 313549977ade7851a224441b4c6a796676d280b4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 5 Mar 2026 16:40:59 +1100
Subject: [PATCH 0336/1059] Remove out-of-date docs.

The `DerefMut` impl for `Providers` was removed in #151096.
---
 src/doc/rustc-dev-guide/src/query.md | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
index 5ab2ab428e81..437dd8daa70b 100644
--- a/src/doc/rustc-dev-guide/src/query.md
+++ b/src/doc/rustc-dev-guide/src/query.md
@@ -168,12 +168,6 @@ pub fn provide(providers: &mut rustc_middle::util::Providers) {
 }
 ```
 
-Note that `util::Providers` implements `DerefMut` to `query::Providers` so callers of the `provide` functions can pass in a `util::Providers` and it will just work for provider functions that accept `query::Providers` too
-
-- This function takes a mutable reference to the `query::Providers` struct and sets the fields to point to the correct provider functions.
-- You can also assign queries individually, e.g. `providers.type_of = type_of;`.
-- You can assign fields individually for each provider type (local, external, and hooks).
-
 #### Adding a new provider
 
 Suppose you want to add a new query called `fubar`.

From 0e1e0b0957a074574228f253b7f203864229a944 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 9 Mar 2026 14:58:46 +1100
Subject: [PATCH 0337/1059] Minimize some visibilities.

---
 compiler/rustc_middle/src/dep_graph/graph.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index 963d5f1a53bd..f9be7ad36c3f 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -865,7 +865,7 @@ pub(crate) fn register_dep_node_debug_str<F>(&self, dep_node: DepNode, debug_str
         dep_node_debug.borrow_mut().insert(dep_node, debug_str);
     }
 
-    pub fn dep_node_debug_str(&self, dep_node: DepNode) -> Option<String> {
+    pub(crate) fn dep_node_debug_str(&self, dep_node: DepNode) -> Option<String> {
         self.data.as_ref()?.dep_node_debug.borrow().get(&dep_node).cloned()
     }
 
@@ -1103,7 +1103,7 @@ pub fn exec_cache_promotions<'tcx>(&self, tcx: TyCtxt<'tcx>) {
         }
     }
 
-    pub fn finish_encoding(&self) -> FileEncodeResult {
+    pub(crate) fn finish_encoding(&self) -> FileEncodeResult {
         if let Some(data) = &self.data { data.current.encoder.finish(&data.current) } else { Ok(0) }
     }
 

From 282e8ec275c5d0338179af8dc92ec5f81651a786 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 9 Mar 2026 15:23:58 +1100
Subject: [PATCH 0338/1059] Rename some parameters.

`tcx` is the usual name for `TyCtxt` parameters.
---
 compiler/rustc_driver_impl/src/lib.rs        | 10 +++++-----
 compiler/rustc_middle/src/dep_graph/graph.rs |  8 ++++----
 src/librustdoc/lib.rs                        | 10 +++++-----
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 8fec629161ea..bdaed5bb42ee 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -353,16 +353,16 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
     })
 }
 
-fn dump_feature_usage_metrics(tcxt: TyCtxt<'_>, metrics_dir: &Path) {
-    let hash = tcxt.crate_hash(LOCAL_CRATE);
-    let crate_name = tcxt.crate_name(LOCAL_CRATE);
+fn dump_feature_usage_metrics(tcx: TyCtxt<'_>, metrics_dir: &Path) {
+    let hash = tcx.crate_hash(LOCAL_CRATE);
+    let crate_name = tcx.crate_name(LOCAL_CRATE);
     let metrics_file_name = format!("unstable_feature_usage_metrics-{crate_name}-{hash}.json");
     let metrics_path = metrics_dir.join(metrics_file_name);
-    if let Err(error) = tcxt.features().dump_feature_usage_metrics(metrics_path) {
+    if let Err(error) = tcx.features().dump_feature_usage_metrics(metrics_path) {
         // FIXME(yaahc): once metrics can be enabled by default we will want "failure to emit
         // default metrics" to only produce a warning when metrics are enabled by default and emit
         // an error only when the user manually enables metrics
-        tcxt.dcx().emit_err(UnstableFeatureUsage { error });
+        tcx.dcx().emit_err(UnstableFeatureUsage { error });
     }
 }
 
diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index f9be7ad36c3f..d410d9a48cd1 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -292,7 +292,7 @@ pub fn with_task<'tcx, A: Debug, R>(
 
     pub fn with_anon_task<'tcx, OP, R>(
         &self,
-        cx: TyCtxt<'tcx>,
+        tcx: TyCtxt<'tcx>,
         dep_kind: DepKind,
         op: OP,
     ) -> (R, DepNodeIndex)
@@ -301,7 +301,7 @@ pub fn with_anon_task<'tcx, OP, R>(
     {
         match self.data() {
             Some(data) => {
-                let (result, index) = data.with_anon_task_inner(cx, dep_kind, op);
+                let (result, index) = data.with_anon_task_inner(tcx, dep_kind, op);
                 self.read_index(index);
                 (result, index)
             }
@@ -379,14 +379,14 @@ pub fn with_task<'tcx, A: Debug, R>(
     /// how to make that work with `anon` in `execute_job_incr`, though.
     pub fn with_anon_task_inner<'tcx, OP, R>(
         &self,
-        cx: TyCtxt<'tcx>,
+        tcx: TyCtxt<'tcx>,
         dep_kind: DepKind,
         op: OP,
     ) -> (R, DepNodeIndex)
     where
         OP: FnOnce() -> R,
     {
-        debug_assert!(!cx.is_eval_always(dep_kind));
+        debug_assert!(!tcx.is_eval_always(dep_kind));
 
         // Large numbers of reads are common enough here that pre-sizing `read_set`
         // to 128 actually helps perf on some benchmarks.
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 55075001e0fe..8c1069dd6d39 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -954,15 +954,15 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
     })
 }
 
-fn dump_feature_usage_metrics(tcxt: TyCtxt<'_>, metrics_dir: &Path) {
-    let hash = tcxt.crate_hash(LOCAL_CRATE);
-    let crate_name = tcxt.crate_name(LOCAL_CRATE);
+fn dump_feature_usage_metrics(tcx: TyCtxt<'_>, metrics_dir: &Path) {
+    let hash = tcx.crate_hash(LOCAL_CRATE);
+    let crate_name = tcx.crate_name(LOCAL_CRATE);
     let metrics_file_name = format!("unstable_feature_usage_metrics-{crate_name}-{hash}.json");
     let metrics_path = metrics_dir.join(metrics_file_name);
-    if let Err(error) = tcxt.features().dump_feature_usage_metrics(metrics_path) {
+    if let Err(error) = tcx.features().dump_feature_usage_metrics(metrics_path) {
         // FIXME(yaahc): once metrics can be enabled by default we will want "failure to emit
         // default metrics" to only produce a warning when metrics are enabled by default and emit
         // an error only when the user manually enables metrics
-        tcxt.dcx().err(format!("cannot emit feature usage metrics: {error}"));
+        tcx.dcx().err(format!("cannot emit feature usage metrics: {error}"));
     }
 }

From 1287ccc14c9417701a9d902d19f644ec8720fd86 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 11 Mar 2026 15:53:32 +1100
Subject: [PATCH 0339/1059] Remove an unnecessary `allow` attribute.

---
 compiler/rustc_middle/src/query/plumbing.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index ad0b6f7c335e..8df7d4ff661e 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -320,7 +320,6 @@ fn $name:ident($($K:tt)*) -> $V:ty
         non_queries { $($_:tt)* }
     ) => {
         $(
-            #[allow(unused_lifetimes)]
             pub mod $name {
                 use super::*;
                 use $crate::query::erase::{self, Erased};

From 10b3ba7ae6c7268b9bb32aa87feb759d157d8177 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Wed, 11 Mar 2026 07:27:58 +0000
Subject: [PATCH 0340/1059] doc/rustc: clarify how to contact arm-maintainers

Addresses feedback from <https://github.com/rust-lang/rust/pull/147268#discussion_r2838223188>
---
 src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md  | 1 +
 src/doc/rustc/src/platform-support/aarch64-unknown-none.md       | 1 +
 src/doc/rustc/src/platform-support/aarch64v8r-unknown-none.md    | 1 +
 .../rustc/src/platform-support/armv7-unknown-linux-gnueabi.md    | 1 +
 src/doc/rustc/src/platform-support/armv7a-none-eabi.md           | 1 +
 src/doc/rustc/src/platform-support/armv7r-none-eabi.md           | 1 +
 src/doc/rustc/src/platform-support/armv8r-none-eabihf.md         | 1 +
 src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md        | 1 +
 src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md         | 1 +
 src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md    | 1 +
 src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md    | 1 +
 src/doc/rustc/src/platform-support/unknown-uefi.md               | 1 +
 12 files changed, 12 insertions(+)

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
index baa46135d534..36609d5742cc 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
@@ -7,6 +7,7 @@ Target for 64-bit little endian ARMv8-A Linux 4.1+ programs using glibc 2.17+.
 ## Target maintainers
 
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index 5d1201bbf426..b9386f07fe2d 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -16,6 +16,7 @@ Processors in this family include the [Arm Cortex-A35, 53, 76, etc][aarch64-cpus
 
 - [Rust Embedded Devices Working Group Arm Team]
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
diff --git a/src/doc/rustc/src/platform-support/aarch64v8r-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64v8r-unknown-none.md
index 9e232b320516..bbe9d8b3ba87 100644
--- a/src/doc/rustc/src/platform-support/aarch64v8r-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64v8r-unknown-none.md
@@ -16,6 +16,7 @@ For Armv8-R CPUs running in AArch32 mode (such as the Arm Cortex-R52), see
 
 - [Rust Embedded Devices Working Group Arm Team]
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
diff --git a/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md
index c2fe63a49087..c7888571df3d 100644
--- a/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md
+++ b/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md
@@ -8,6 +8,7 @@ Target for 32-bit little endian ARMv7-A Linux 3.2+ programs using glibc 2.17+.
 ## Target maintainers
 
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 555f69e81a02..0fa09d3955ff 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -24,6 +24,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 - [Rust Embedded Devices Working Group Arm Team]
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 20fd55c6abd6..5f95af44a793 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -22,6 +22,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 - [@chrisnc](https://github.com/chrisnc)
 - [Rust Embedded Devices Working Group Arm Team]
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index 73d88bcb89a1..1ff36b47beb2 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -26,6 +26,7 @@ For Armv8-R CPUs running in AArch64 mode (such as the Arm Cortex-R82), see
 - [@chrisnc](https://github.com/chrisnc)
 - [Rust Embedded Devices Working Group Arm Team]
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
diff --git a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
index 192e013d3a43..1f91e2f18631 100644
--- a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
@@ -24,6 +24,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 - [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
index b04cb7bfacfa..90f641d6e4f8 100644
--- a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
@@ -25,6 +25,7 @@ only option because there is no FPU support in [Armv7-M].
 
 - [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
index 104520854b49..20fdb18eafa5 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
@@ -25,6 +25,7 @@ only option because there is no FPU support in [Armv8-M] Baseline.
 
 - [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
index 5cc535ce376b..ab77153be92b 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
@@ -28,6 +28,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 - [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 - [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com
diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md
index e8989616b844..d286ab4fb35a 100644
--- a/src/doc/rustc/src/platform-support/unknown-uefi.md
+++ b/src/doc/rustc/src/platform-support/unknown-uefi.md
@@ -16,6 +16,7 @@ Available targets:
 - [@dvdhrm](https://github.com/dvdhrm)
 - [@nicholasbishop](https://github.com/nicholasbishop)
 - (for `aarch64-unknown-uefi` only) [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+    - Use `@rustbot ping arm-maintainers` to ping us
 
 [arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
 [arm_email]: mailto:rust@arm.com

From accbfccd597b332a36d6d22335d1d7d8e9507619 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Wed, 11 Mar 2026 07:22:26 +0000
Subject: [PATCH 0341/1059] Unconditionally error when trying to create a const
 coroutine

---
 compiler/rustc_ast_lowering/src/expr.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 4a2992038003..e86a2f33b87b 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -231,6 +231,7 @@ pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
                         e.id,
                         expr_hir_id,
                         *coroutine_kind,
+                        *constness,
                         fn_decl,
                         body,
                         *fn_decl_span,
@@ -1158,6 +1159,7 @@ fn lower_expr_coroutine_closure(
         closure_id: NodeId,
         closure_hir_id: HirId,
         coroutine_kind: CoroutineKind,
+        constness: Const,
         decl: &FnDecl,
         body: &Expr,
         fn_decl_span: Span,
@@ -1204,6 +1206,10 @@ fn lower_expr_coroutine_closure(
         let fn_decl =
             self.lower_fn_decl(&decl, closure_id, fn_decl_span, FnDeclKind::Closure, None);
 
+        if let Const::Yes(span) = constness {
+            self.dcx().span_err(span, "const coroutines are not supported");
+        }
+
         let c = self.arena.alloc(hir::Closure {
             def_id: closure_def_id,
             binder: binder_clause,
@@ -1217,7 +1223,7 @@ fn lower_expr_coroutine_closure(
             // knows that a `FnDecl` output type like `-> &str` actually means
             // "coroutine that returns &str", rather than directly returning a `&str`.
             kind: hir::ClosureKind::CoroutineClosure(coroutine_desugaring),
-            constness: hir::Constness::NotConst,
+            constness: self.lower_constness(constness),
         });
         hir::ExprKind::Closure(c)
     }

From be78a0d629bd6058c2fd3b9b405a8484434ebcfb Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sun, 8 Mar 2026 23:04:49 +0900
Subject: [PATCH 0342/1059] avoid ICE when EII target resolves to a constructor

remove span_delayed_bug
---
 .../rustc_hir_analysis/src/check/compare_eii.rs     | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/compiler/rustc_hir_analysis/src/check/compare_eii.rs b/compiler/rustc_hir_analysis/src/check/compare_eii.rs
index 9443aaac2258..29213058d1d5 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_eii.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_eii.rs
@@ -9,6 +9,7 @@
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{Applicability, E0806, struct_span_code_err};
 use rustc_hir::attrs::EiiImplResolution;
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, FnSig, HirId, ItemKind, find_attr};
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
@@ -37,6 +38,14 @@ pub(crate) fn compare_eii_function_types<'tcx>(
     eii_name: Symbol,
     eii_attr_span: Span,
 ) -> Result<(), ErrorGuaranteed> {
+    // Error recovery can resolve the EII target to another value item with the same name,
+    // such as a tuple-struct constructor. Skip the comparison in that case and rely on the
+    // earlier name-resolution error instead of ICEing while building EII diagnostics.
+    // See <https://github.com/rust-lang/rust/issues/153502>.
+    if !is_foreign_function(tcx, foreign_item) {
+        return Ok(());
+    }
+
     check_is_structurally_compatible(tcx, external_impl, foreign_item, eii_name, eii_attr_span)?;
 
     let external_impl_span = tcx.def_span(external_impl);
@@ -442,3 +451,7 @@ fn get_declaration_sig<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Option<&'
     let hir_id: HirId = tcx.local_def_id_to_hir_id(def_id);
     tcx.hir_fn_sig_by_hir_id(hir_id)
 }
+
+fn is_foreign_function(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
+    tcx.is_foreign_item(def_id) && matches!(tcx.def_kind(def_id), DefKind::Fn)
+}

From 3399ed3c9a25d51b777f10ac7dafc4bbb64eff35 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 5 Mar 2026 17:30:22 +1100
Subject: [PATCH 0343/1059] Simplify `type_of_opaque`.

There is a bunch of complexity supporting the "cannot check whether the
hidden type of opaque type satisfies auto traits" error that shows up in
`tests/ui/impl-trait/auto-trait-leak.rs`. This is an obscure error that
shows up in a single test. If we are willing to downgrade that error
message to a cycle error, we can do the following.

- Simplify the `type_of_opaque` return value.
- Remove the `cycle_stash` query modifier.
- Remove the `CyclePlaceholder` type.
- Remove the `SelectionError::OpaqueTypeAutoTraitLeakageUnknown`
  variant.
- Remove a `FromCycleError` impl.
- Remove `report_opaque_type_auto_trait_leakage`.
- Remove the `StashKey::Cycle` variant.
- Remove the `CycleErrorHandling::Stash` variant.

That's a lot! I think this is a worthwhile trade-off.
---
 compiler/rustc_errors/src/lib.rs              |  2 -
 .../rustc_hir_analysis/src/collect/type_of.rs | 17 ++--
 compiler/rustc_macros/src/query.rs            |  9 --
 compiler/rustc_middle/src/queries.rs          | 12 +--
 compiler/rustc_middle/src/query/erase.rs      |  5 --
 compiler/rustc_middle/src/query/modifiers.rs  |  5 --
 compiler/rustc_middle/src/query/plumbing.rs   |  5 --
 compiler/rustc_middle/src/traits/mod.rs       |  4 -
 compiler/rustc_query_impl/src/execution.rs    | 12 +--
 .../rustc_query_impl/src/from_cycle_error.rs  |  4 -
 .../traits/fulfillment_errors.rs              | 33 -------
 .../src/traits/select/mod.rs                  | 14 ++-
 .../auto-trait-leakage/auto-trait-leak.rs     |  3 +-
 .../auto-trait-leakage/auto-trait-leak.stderr | 90 ++++++++++++++++---
 .../type-alias-impl-trait/in-where-clause.rs  |  1 -
 .../in-where-clause.stderr                    | 21 +----
 16 files changed, 92 insertions(+), 145 deletions(-)

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index a96eceb6c715..9b3dba15f55e 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -371,8 +371,6 @@ pub enum StashKey {
     MaybeFruTypo,
     CallAssocMethod,
     AssociatedTypeSuggestion,
-    /// Query cycle detected, stashing in favor of a better error.
-    Cycle,
     UndeterminedMacroResolution,
     /// Used by `Parser::maybe_recover_trailing_expr`
     ExprInPat,
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 23df419d06a7..f2ae5c1f928d 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -4,7 +4,6 @@
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::{self as hir, AmbigArg, HirId};
-use rustc_middle::query::plumbing::CyclePlaceholder;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, DefiningScopeKind, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
@@ -183,10 +182,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
             }
         },
 
-        Node::OpaqueTy(..) => tcx.type_of_opaque(def_id).map_or_else(
-            |CyclePlaceholder(guar)| Ty::new_error(tcx, guar),
-            |ty| ty.instantiate_identity(),
-        ),
+        Node::OpaqueTy(..) => tcx.type_of_opaque(def_id).instantiate_identity(),
 
         Node::ForeignItem(foreign_item) => match foreign_item.kind {
             ForeignItemKind::Fn(..) => {
@@ -249,12 +245,9 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
     }
 }
 
-pub(super) fn type_of_opaque(
-    tcx: TyCtxt<'_>,
-    def_id: DefId,
-) -> Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
+pub(super) fn type_of_opaque(tcx: TyCtxt<'_>, def_id: DefId) -> ty::EarlyBinder<'_, Ty<'_>> {
     if let Some(def_id) = def_id.as_local() {
-        Ok(match tcx.hir_node_by_def_id(def_id).expect_opaque_ty().origin {
+        match tcx.hir_node_by_def_id(def_id).expect_opaque_ty().origin {
             hir::OpaqueTyOrigin::TyAlias { in_assoc_ty: false, .. } => {
                 opaque::find_opaque_ty_constraints_for_tait(
                     tcx,
@@ -287,11 +280,11 @@ pub(super) fn type_of_opaque(
                     DefiningScopeKind::MirBorrowck,
                 )
             }
-        })
+        }
     } else {
         // Foreign opaque type will go through the foreign provider
         // and load the type from metadata.
-        Ok(tcx.type_of(def_id))
+        tcx.type_of(def_id)
     }
 }
 
diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index 05a28c48f806..ed5951fe1c03 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -144,7 +144,6 @@ struct QueryModifiers {
     arena_cache: Option<Ident>,
     cache_on_disk_if: Option<CacheOnDiskIf>,
     cycle_delay_bug: Option<Ident>,
-    cycle_stash: Option<Ident>,
     depth_limit: Option<Ident>,
     desc: Desc,
     eval_always: Option<Ident>,
@@ -159,7 +158,6 @@ fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModifiers> {
     let mut cache_on_disk_if = None;
     let mut desc = None;
     let mut cycle_delay_bug = None;
-    let mut cycle_stash = None;
     let mut no_hash = None;
     let mut anon = None;
     let mut eval_always = None;
@@ -195,8 +193,6 @@ macro_rules! try_insert {
             try_insert!(arena_cache = modifier);
         } else if modifier == "cycle_delay_bug" {
             try_insert!(cycle_delay_bug = modifier);
-        } else if modifier == "cycle_stash" {
-            try_insert!(cycle_stash = modifier);
         } else if modifier == "no_hash" {
             try_insert!(no_hash = modifier);
         } else if modifier == "anon" {
@@ -221,7 +217,6 @@ macro_rules! try_insert {
         cache_on_disk_if,
         desc,
         cycle_delay_bug,
-        cycle_stash,
         no_hash,
         anon,
         eval_always,
@@ -257,7 +252,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         arena_cache,
         cache_on_disk_if,
         cycle_delay_bug,
-        cycle_stash,
         depth_limit,
         desc: _,
         eval_always,
@@ -273,8 +267,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
 
     let cycle_error_handling = if cycle_delay_bug.is_some() {
         quote! { DelayBug }
-    } else if cycle_stash.is_some() {
-        quote! { Stash }
     } else {
         quote! { Error }
     };
@@ -411,7 +403,6 @@ macro_rules! doc_link {
     doc_link!(
         arena_cache,
         cycle_delay_bug,
-        cycle_stash,
         no_hash,
         anon,
         eval_always,
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index c20a389f56b9..25ac06a6ed09 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -33,7 +33,6 @@
 //! - `cache_on_disk_if { ... }`: Cache the query result to disk if the provided block evaluates to
 //!   true. The query key identifier is available for use within the block, as is `tcx`.
 //! - `cycle_delay_bug`: If a dependency cycle is detected, emit a delayed bug instead of aborting immediately.
-//! - `cycle_stash`: If a dependency cycle is detected, stash the error for later handling.
 //! - `no_hash`: Do not hash the query result for incremental compilation; just mark as dirty if recomputed.
 //! - `anon`: Make the query anonymous in the dependency graph (no dep node is created).
 //! - `eval_always`: Always evaluate the query, ignoring its dependencies and cached results.
@@ -118,7 +117,6 @@
     CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions, NormalizationErrorInMono,
 };
 use crate::query::describe_as_module;
-use crate::query::plumbing::CyclePlaceholder;
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
     CanonicalMethodAutoderefStepsGoal, CanonicalPredicateGoal, CanonicalTypeOpAscribeUserTypeGoal,
@@ -339,22 +337,16 @@
         feedable
     }
 
-    /// Returns the *hidden type* of the opaque type given by `DefId` unless a cycle occurred.
-    ///
-    /// This is a specialized instance of [`Self::type_of`] that detects query cycles.
-    /// Unless `CyclePlaceholder` needs to be handled separately, call [`Self::type_of`] instead.
-    /// This is used to improve the error message in cases where revealing the hidden type
-    /// for auto-trait leakage cycles.
+    /// Returns the *hidden type* of the opaque type given by `DefId`.
     ///
     /// # Panics
     ///
     /// This query will panic if the given definition is not an opaque type.
-    query type_of_opaque(key: DefId) -> Result<ty::EarlyBinder<'tcx, Ty<'tcx>>, CyclePlaceholder> {
+    query type_of_opaque(key: DefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         desc {
             "computing type of opaque `{path}`",
             path = tcx.def_path_str(key),
         }
-        cycle_stash
     }
     query type_of_opaque_hir_typeck(key: LocalDefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         desc {
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index a02f6f89b9b9..fc96566b069a 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -14,7 +14,6 @@
 
 use crate::mir::interpret::EvalToValTreeResult;
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
-use crate::query::plumbing::CyclePlaceholder;
 use crate::traits::solve;
 use crate::ty::adjustment::CoerceUnsizedInfo;
 use crate::ty::{self, Ty, TyCtxt};
@@ -212,10 +211,6 @@ impl Erasable for Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop> {
         [u8; size_of::<Result<&'static ty::List<Ty<'static>>, ty::util::AlwaysRequiresDrop>>()];
 }
 
-impl Erasable for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
-    type Storage = [u8; size_of::<Result<ty::EarlyBinder<'static, Ty<'_>>, CyclePlaceholder>>()];
-}
-
 impl Erasable
     for Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>
 {
diff --git a/compiler/rustc_middle/src/query/modifiers.rs b/compiler/rustc_middle/src/query/modifiers.rs
index 2bc70dd588df..eb9fc330a231 100644
--- a/compiler/rustc_middle/src/query/modifiers.rs
+++ b/compiler/rustc_middle/src/query/modifiers.rs
@@ -28,11 +28,6 @@
 /// A cycle error results in a delay_bug call
 pub(crate) struct cycle_delay_bug;
 
-/// # `cycle_stash` query modifier
-///
-/// A cycle error results in a stashed cycle error that can be unstashed and canceled later
-pub(crate) struct cycle_stash;
-
 /// # `depth_limit` query modifier
 ///
 /// Whether the query has a call depth limit
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index ad0b6f7c335e..72330eab30d5 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -7,7 +7,6 @@
 use rustc_data_structures::sync::{AtomicU64, WorkerLocal};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
-use rustc_macros::HashStable;
 use rustc_span::{ErrorGuaranteed, Span};
 pub use sealed::IntoQueryParam;
 
@@ -58,7 +57,6 @@ pub enum ActiveKeyStatus<'tcx> {
 pub enum CycleErrorHandling {
     Error,
     DelayBug,
-    Stash,
 }
 
 #[derive(Clone, Debug)]
@@ -651,9 +649,6 @@ fn into_query_param(self) -> LocalDefId {
     }
 }
 
-#[derive(Copy, Clone, Debug, HashStable)]
-pub struct CyclePlaceholder(pub ErrorGuaranteed);
-
 #[cold]
 pub(crate) fn default_query(name: &str, key: &dyn std::fmt::Debug) -> ! {
     bug!(
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index 2fca85c9f2f1..a940365b9008 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -633,10 +633,6 @@ pub enum SelectionError<'tcx> {
     NotConstEvaluatable(NotConstEvaluatable),
     /// Exceeded the recursion depth during type projection.
     Overflow(OverflowError),
-    /// Computing an opaque type's hidden type caused an error (e.g. a cycle error).
-    /// We can thus not know whether the hidden type implements an auto trait, so
-    /// we should not presume anything about it.
-    OpaqueTypeAutoTraitLeakageUnknown(DefId),
     /// Error for a `ConstArgHasType` goal
     ConstArgHasWrongType { ct: ty::Const<'tcx>, ct_ty: Ty<'tcx>, expected_ty: Ty<'tcx> },
 }
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 57d503ef7b07..52e92d02b462 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -5,7 +5,7 @@
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_data_structures::{outline, sharded, sync};
-use rustc_errors::{FatalError, StashKey};
+use rustc_errors::FatalError;
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
@@ -110,16 +110,6 @@ fn mk_cycle<'tcx, C: QueryCache>(
             let guar = error.delay_as_bug();
             (query.value_from_cycle_error)(tcx, cycle_error, guar)
         }
-        CycleErrorHandling::Stash => {
-            let guar = if let Some(root) = cycle_error.cycle.first()
-                && let Some(span) = root.frame.info.span
-            {
-                error.stash(span, StashKey::Cycle).unwrap()
-            } else {
-                error.emit()
-            };
-            (query.value_from_cycle_error)(tcx, cycle_error, guar)
-        }
     }
 }
 
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 2599c2fde5d0..0b7f69765823 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -12,7 +12,6 @@
 use rustc_middle::queries::QueryVTables;
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
-use rustc_middle::query::plumbing::CyclePlaceholder;
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -31,9 +30,6 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
     vtables.erase_and_anonymize_regions_ty.value_from_cycle_error =
         |tcx, _, guar| erase_val(Ty::new_error(tcx, guar));
 
-    vtables.type_of_opaque.value_from_cycle_error =
-        |_, _, guar| erase_val(Err(CyclePlaceholder(guar)));
-
     vtables.fn_sig.value_from_cycle_error = |tcx, cycle, guar| erase_val(fn_sig(tcx, cycle, guar));
 
     vtables.check_representability.value_from_cycle_error =
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 364152475e94..f6f7635e5feb 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -756,11 +756,6 @@ pub fn report_selection_error(
                 }
             }
 
-            SelectionError::OpaqueTypeAutoTraitLeakageUnknown(def_id) => return self.report_opaque_type_auto_trait_leakage(
-                &obligation,
-                def_id,
-            ),
-
             SelectionError::TraitDynIncompatible(did) => {
                 let violations = self.tcx.dyn_compatibility_violations(did);
                 report_dyn_incompatibility(self.tcx, span, None, did, violations)
@@ -3330,34 +3325,6 @@ fn report_cyclic_signature_error(
         )
     }
 
-    fn report_opaque_type_auto_trait_leakage(
-        &self,
-        obligation: &PredicateObligation<'tcx>,
-        def_id: DefId,
-    ) -> ErrorGuaranteed {
-        let name = match self.tcx.local_opaque_ty_origin(def_id.expect_local()) {
-            hir::OpaqueTyOrigin::FnReturn { .. } | hir::OpaqueTyOrigin::AsyncFn { .. } => {
-                "opaque type".to_string()
-            }
-            hir::OpaqueTyOrigin::TyAlias { .. } => {
-                format!("`{}`", self.tcx.def_path_debug_str(def_id))
-            }
-        };
-        let mut err = self.dcx().struct_span_err(
-            obligation.cause.span,
-            format!("cannot check whether the hidden type of {name} satisfies auto traits"),
-        );
-
-        err.note(
-            "fetching the hidden types of an opaque inside of the defining scope is not supported. \
-            You can try moving the opaque type and the item that actually registers a hidden type into a new submodule",
-        );
-        err.span_note(self.tcx.def_span(def_id), "opaque type is declared here");
-
-        self.note_obligation_cause(&mut err, &obligation);
-        self.dcx().try_steal_replace_and_emit_err(self.tcx.def_span(def_id), StashKey::Cycle, err)
-    }
-
     fn report_signature_mismatch_error(
         &self,
         obligation: &PredicateObligation<'tcx>,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index a7f47a8615c2..83d199fa8b4c 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2404,15 +2404,11 @@ fn constituent_types_for_auto_trait(
                     // We can resolve the opaque type to its hidden type,
                     // which enforces a DAG between the functions requiring
                     // the auto trait bounds in question.
-                    match self.tcx().type_of_opaque(def_id) {
-                        Ok(ty) => ty::Binder::dummy(AutoImplConstituents {
-                            types: vec![ty.instantiate(self.tcx(), args)],
-                            assumptions: vec![],
-                        }),
-                        Err(_) => {
-                            return Err(SelectionError::OpaqueTypeAutoTraitLeakageUnknown(def_id));
-                        }
-                    }
+                    let ty = self.tcx().type_of_opaque(def_id);
+                    ty::Binder::dummy(AutoImplConstituents {
+                        types: vec![ty.instantiate(self.tcx(), args)],
+                        assumptions: vec![],
+                    })
                 }
             }
         })
diff --git a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
index de4f523c23aa..c2fab7d4c5f6 100644
--- a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
+++ b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
@@ -8,7 +8,7 @@ fn main() {}
 // Cycles should work as the deferred obligations are
 // independently resolved and only require the concrete
 // return type, which can't depend on the obligation.
-fn cycle1() -> impl Clone {
+fn cycle1() -> impl Clone { //~ ERROR: cycle detected
     send(cycle2().clone());
 
     Rc::new(Cell::new(5))
@@ -16,7 +16,6 @@ fn cycle1() -> impl Clone {
 
 fn cycle2() -> impl Clone {
     send(cycle1().clone());
-    //~^ ERROR: cannot check whether the hidden type of opaque type satisfies auto traits
 
     Rc::new(String::from("foo"))
 }
diff --git a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.stderr b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.stderr
index cc9939f2d57f..ae1051699988 100644
--- a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.stderr
+++ b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.stderr
@@ -1,22 +1,84 @@
-error: cannot check whether the hidden type of opaque type satisfies auto traits
-  --> $DIR/auto-trait-leak.rs:18:10
-   |
-LL |     send(cycle1().clone());
-   |     ---- ^^^^^^^^^^^^^^^^
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = note: fetching the hidden types of an opaque inside of the defining scope is not supported. You can try moving the opaque type and the item that actually registers a hidden type into a new submodule
-note: opaque type is declared here
+error[E0391]: cycle detected when computing type of opaque `cycle1::{opaque#0}`
   --> $DIR/auto-trait-leak.rs:11:16
    |
 LL | fn cycle1() -> impl Clone {
    |                ^^^^^^^^^^
-note: required by a bound in `send`
-  --> $DIR/auto-trait-leak.rs:4:12
    |
-LL | fn send<T: Send>(_: T) {}
-   |            ^^^^ required by this bound in `send`
+note: ...which requires borrow-checking `cycle1`...
+  --> $DIR/auto-trait-leak.rs:11:1
+   |
+LL | fn cycle1() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires promoting constants in MIR for `cycle1`...
+  --> $DIR/auto-trait-leak.rs:11:1
+   |
+LL | fn cycle1() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires checking if `cycle1` contains FFI-unwind calls...
+  --> $DIR/auto-trait-leak.rs:11:1
+   |
+LL | fn cycle1() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires building MIR for `cycle1`...
+  --> $DIR/auto-trait-leak.rs:11:1
+   |
+LL | fn cycle1() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires match-checking `cycle1`...
+  --> $DIR/auto-trait-leak.rs:11:1
+   |
+LL | fn cycle1() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires type-checking `cycle1`...
+  --> $DIR/auto-trait-leak.rs:12:5
+   |
+LL |     send(cycle2().clone());
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   = note: ...which requires evaluating trait selection obligation `cycle2::{opaque#0}: core::marker::Send`...
+note: ...which requires computing type of opaque `cycle2::{opaque#0}`...
+  --> $DIR/auto-trait-leak.rs:17:16
+   |
+LL | fn cycle2() -> impl Clone {
+   |                ^^^^^^^^^^
+note: ...which requires borrow-checking `cycle2`...
+  --> $DIR/auto-trait-leak.rs:17:1
+   |
+LL | fn cycle2() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires promoting constants in MIR for `cycle2`...
+  --> $DIR/auto-trait-leak.rs:17:1
+   |
+LL | fn cycle2() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires checking if `cycle2` contains FFI-unwind calls...
+  --> $DIR/auto-trait-leak.rs:17:1
+   |
+LL | fn cycle2() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires building MIR for `cycle2`...
+  --> $DIR/auto-trait-leak.rs:17:1
+   |
+LL | fn cycle2() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires match-checking `cycle2`...
+  --> $DIR/auto-trait-leak.rs:17:1
+   |
+LL | fn cycle2() -> impl Clone {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires type-checking `cycle2`...
+  --> $DIR/auto-trait-leak.rs:18:5
+   |
+LL |     send(cycle1().clone());
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   = note: ...which requires evaluating trait selection obligation `cycle1::{opaque#0}: core::marker::Send`...
+   = note: ...which again requires computing type of opaque `cycle1::{opaque#0}`, completing the cycle
+note: cycle used when computing type of `cycle1::{opaque#0}`
+  --> $DIR/auto-trait-leak.rs:11:16
+   |
+LL | fn cycle1() -> impl Clone {
+   |                ^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/type-alias-impl-trait/in-where-clause.rs b/tests/ui/type-alias-impl-trait/in-where-clause.rs
index 8d5bfc48a66e..f4b788b5b680 100644
--- a/tests/ui/type-alias-impl-trait/in-where-clause.rs
+++ b/tests/ui/type-alias-impl-trait/in-where-clause.rs
@@ -11,7 +11,6 @@ fn foo() -> Bar
     Bar: Send,
 {
     [0; 1 + 2]
-    //~^ ERROR: type annotations needed: cannot satisfy `Bar: Send`
 }
 
 fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/in-where-clause.stderr b/tests/ui/type-alias-impl-trait/in-where-clause.stderr
index 81be8c8362e3..fcb590a961c1 100644
--- a/tests/ui/type-alias-impl-trait/in-where-clause.stderr
+++ b/tests/ui/type-alias-impl-trait/in-where-clause.stderr
@@ -1,19 +1,3 @@
-error[E0283]: type annotations needed: cannot satisfy `Bar: Send`
-  --> $DIR/in-where-clause.rs:13:9
-   |
-LL |     [0; 1 + 2]
-   |         ^^^^^
-   |
-   = note: cannot satisfy `Bar: Send`
-note: required by a bound in `foo`
-  --> $DIR/in-where-clause.rs:11:10
-   |
-LL | fn foo() -> Bar
-   |    --- required by a bound in this function
-LL | where
-LL |     Bar: Send,
-   |          ^^^^ required by this bound in `foo`
-
 error[E0391]: cycle detected when computing type of opaque `Bar::{opaque#0}`
   --> $DIR/in-where-clause.rs:5:12
    |
@@ -77,7 +61,6 @@ LL | type Bar = impl Sized;
    = note: cycle used when evaluating trait selection obligation `Bar: core::marker::Send`
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0283, E0391.
-For more information about an error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0391`.

From 59733c61e88ab0dd4b2cdb097677b44a15b1fa9e Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Wed, 11 Mar 2026 11:09:43 +0000
Subject: [PATCH 0344/1059] remove `.ftl` checks from tidy

---
 src/tools/tidy/src/style.rs    | 11 ++---------
 src/tools/tidy/src/ui_tests.rs |  1 -
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 111fe89e7eb0..3c2cddb2516d 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -227,8 +227,6 @@ fn should_ignore(line: &str) -> bool {
 /// Returns `true` if `line` is allowed to be longer than the normal limit.
 fn long_line_is_ok(extension: &str, is_error_code: bool, max_columns: usize, line: &str) -> bool {
     match extension {
-        // fluent files are allowed to be any length
-        "ftl" => true,
         // non-error code markdown is allowed to be any length
         "md" if !is_error_code => true,
         // HACK(Ezrashaw): there is no way to split a markdown header over multiple lines
@@ -357,7 +355,7 @@ fn skip(path: &Path, is_dir: bool) -> bool {
             return false;
         }
 
-        let extensions = ["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "ftl", "goml"];
+        let extensions = ["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "goml"];
 
         // NB: don't skip paths without extensions (or else we'll skip all directories and will only check top level files)
         if path.extension().is_none_or(|ext| !extensions.iter().any(|e| ext == OsStr::new(e))) {
@@ -602,12 +600,7 @@ fn skip(path: &Path, is_dir: bool) -> bool {
                     err(DOUBLE_SPACE_AFTER_DOT)
                 }
 
-                if filename.ends_with(".ftl") {
-                    let line_backticks = trimmed.chars().filter(|ch| *ch == '`').count();
-                    if line_backticks % 2 == 1 {
-                        suppressible_tidy_err!(err, skip_odd_backticks, "odd number of backticks");
-                    }
-                } else if trimmed.contains("//") {
+                if trimmed.contains("//") {
                     let (start_line, mut backtick_count) = comment_block.unwrap_or((i + 1, 0));
                     let line_backticks = trimmed.chars().filter(|ch| *ch == '`').count();
                     let comment_text = trimmed.split("//").nth(1).unwrap();
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index c16cfbe899b7..50ec41198767 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -214,7 +214,6 @@ fn check_unexpected_extension(check: &mut RunningCheck, file_path: &Path, ext: &
         "stdout", // expected stdout file, corresponds to a rs file
         "fixed",  // expected source file after applying fixes
         "md",     // test directory descriptions
-        "ftl",    // translation tests
     ];
 
     const EXTENSION_EXCEPTION_PATHS: &[&str] = &[

From 0059012ab24e2a556682fcb21c16852bc3c14610 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 10 Mar 2026 18:20:32 +1100
Subject: [PATCH 0345/1059] Introduce `for_each_query_vtable!` to move more
 code out of query macros

---
 compiler/rustc_query_impl/src/execution.rs    |  31 +++-
 compiler/rustc_query_impl/src/job.rs          |   2 +-
 compiler/rustc_query_impl/src/lib.rs          |  11 +-
 compiler/rustc_query_impl/src/plumbing.rs     | 147 +++++++-----------
 .../rustc_query_impl/src/profiling_support.rs |  33 +++-
 5 files changed, 128 insertions(+), 96 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 57d503ef7b07..a240a7d035cc 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -16,8 +16,8 @@
 use rustc_middle::verify_ich::incremental_verify_ich;
 use rustc_span::{DUMMY_SP, Span};
 
-use crate::collect_active_jobs_from_all_queries;
 use crate::dep_graph::{DepNode, DepNodeIndex};
+use crate::for_each_query_vtable;
 use crate::job::{QueryJobInfo, QueryJobMap, find_cycle_in_stack, report_cycle};
 use crate::plumbing::{current_query_job, next_job_id, start_query};
 
@@ -30,6 +30,33 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
     state.active.lock_shards().all(|shard| shard.is_empty())
 }
 
+/// Returns a map of currently active query jobs, collected from all queries.
+///
+/// If `require_complete` is `true`, this function locks all shards of the
+/// query results to produce a complete map, which always returns `Ok`.
+/// Otherwise, it may return an incomplete map as an error if any shard
+/// lock cannot be acquired.
+///
+/// Prefer passing `false` to `require_complete` to avoid potential deadlocks,
+/// especially when called from within a deadlock handler, unless a
+/// complete map is needed and no deadlock is possible at this call site.
+pub fn collect_active_jobs_from_all_queries<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    require_complete: bool,
+) -> Result<QueryJobMap<'tcx>, QueryJobMap<'tcx>> {
+    let mut job_map_out = QueryJobMap::default();
+    let mut complete = true;
+
+    for_each_query_vtable!(ALL, tcx, |query| {
+        let res = gather_active_jobs(query, tcx, require_complete, &mut job_map_out);
+        if res.is_none() {
+            complete = false;
+        }
+    });
+
+    if complete { Ok(job_map_out) } else { Err(job_map_out) }
+}
+
 /// Internal plumbing for collecting the set of active jobs for this query.
 ///
 /// Should only be called from `collect_active_jobs_from_all_queries`.
@@ -37,7 +64,7 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
 /// (We arbitrarily use the word "gather" when collecting the jobs for
 /// each individual query, so that we have distinct function names to
 /// grep for.)
-pub(crate) fn gather_active_jobs<'tcx, C>(
+fn gather_active_jobs<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     require_complete: bool,
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 2a7f7bf5efd4..744bac4722a9 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -14,7 +14,7 @@
 use rustc_session::Session;
 use rustc_span::{DUMMY_SP, Span};
 
-use crate::collect_active_jobs_from_all_queries;
+use crate::execution::collect_active_jobs_from_all_queries;
 
 /// Map from query job IDs to job information collected by
 /// `collect_active_jobs_from_all_queries`.
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 6482384f99ea..41642f66967d 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -11,15 +11,15 @@
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::dep_graph;
 use rustc_middle::queries::{self, ExternProviders, Providers};
-use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
+use rustc_middle::query::on_disk_cache::OnDiskCache;
 use rustc_middle::query::plumbing::{QuerySystem, QueryVTable};
 use rustc_middle::query::{AsLocalQueryKey, QueryCache, QueryMode};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
+pub use crate::execution::collect_active_jobs_from_all_queries;
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
-use crate::profiling_support::QueryKeyStringCache;
 
 #[macro_use]
 mod plumbing;
@@ -66,7 +66,8 @@ pub fn query_system<'tcx>(
 rustc_middle::rustc_with_all_queries! { define_queries! }
 
 pub fn provide(providers: &mut rustc_middle::util::Providers) {
-    providers.hooks.alloc_self_profile_query_strings = alloc_self_profile_query_strings;
-    providers.hooks.query_key_hash_verify_all = query_key_hash_verify_all;
-    providers.hooks.encode_all_query_results = encode_all_query_results;
+    providers.hooks.alloc_self_profile_query_strings =
+        profiling_support::alloc_self_profile_query_strings;
+    providers.hooks.query_key_hash_verify_all = plumbing::query_key_hash_verify_all;
+    providers.hooks.encode_all_query_results = plumbing::encode_all_query_results;
 }
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 558ecdda5c4b..ddce89234590 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -33,7 +33,7 @@
 use crate::error::{QueryOverflow, QueryOverflowNote};
 use crate::execution::{all_inactive, force_query};
 use crate::job::find_dep_kind_root;
-use crate::{GetQueryVTable, collect_active_jobs_from_all_queries};
+use crate::{GetQueryVTable, collect_active_jobs_from_all_queries, for_each_query_vtable};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
     let job_map =
@@ -146,7 +146,17 @@ pub(crate) fn create_deferred_query_stack_frame<'tcx, C>(
     QueryStackFrame::new(info, kind, def_id, def_id_for_ty_in_cycle)
 }
 
-pub(crate) fn encode_query_results<'a, 'tcx, C, V>(
+pub(crate) fn encode_all_query_results<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    encoder: &mut CacheEncoder<'_, 'tcx>,
+    query_result_index: &mut EncodedDepNodeIndex,
+) {
+    for_each_query_vtable!(CACHE_ON_DISK, tcx, |query| {
+        encode_query_results(tcx, query, encoder, query_result_index)
+    });
+}
+
+fn encode_query_results<'a, 'tcx, C, V>(
     tcx: TyCtxt<'tcx>,
     query: &'tcx QueryVTable<'tcx, C>,
     encoder: &mut CacheEncoder<'a, 'tcx>,
@@ -172,7 +182,17 @@ pub(crate) fn encode_query_results<'a, 'tcx, C, V>(
     });
 }
 
-pub(crate) fn query_key_hash_verify<'tcx, C: QueryCache>(
+pub(crate) fn query_key_hash_verify_all<'tcx>(tcx: TyCtxt<'tcx>) {
+    if tcx.sess.opts.unstable_opts.incremental_verify_ich || cfg!(debug_assertions) {
+        tcx.sess.time("query_key_hash_verify_all", || {
+            for_each_query_vtable!(ALL, tcx, |query| {
+                query_key_hash_verify(query, tcx);
+            });
+        });
+    }
+}
+
+fn query_key_hash_verify<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
 ) {
@@ -510,95 +530,48 @@ pub fn make_query_vtables<'tcx>(incremental: bool) -> queries::QueryVTables<'tcx
             }
         }
 
-        /// Returns a map of currently active query jobs, collected from all queries.
+        /// Given a filter condition (e.g. `ALL` or `CACHE_ON_DISK`), a `tcx`,
+        /// and a closure expression that accepts `&QueryVTable`, this macro
+        /// calls that closure with each query vtable that satisfies the filter
+        /// condition.
         ///
-        /// If `require_complete` is `true`, this function locks all shards of the
-        /// query results to produce a complete map, which always returns `Ok`.
-        /// Otherwise, it may return an incomplete map as an error if any shard
-        /// lock cannot be acquired.
+        /// This needs to be a macro, because the vtables can have different
+        /// key/value/cache types for different queries.
         ///
-        /// Prefer passing `false` to `require_complete` to avoid potential deadlocks,
-        /// especially when called from within a deadlock handler, unless a
-        /// complete map is needed and no deadlock is possible at this call site.
-        pub fn collect_active_jobs_from_all_queries<'tcx>(
-            tcx: TyCtxt<'tcx>,
-            require_complete: bool,
-        ) -> Result<QueryJobMap<'tcx>, QueryJobMap<'tcx>> {
-            let mut job_map_out = QueryJobMap::default();
-            let mut complete = true;
-
-            $(
-                let res = crate::execution::gather_active_jobs(
-                    &tcx.query_system.query_vtables.$name,
-                    tcx,
-                    require_complete,
-                    &mut job_map_out,
-                );
-                if res.is_none() {
-                    complete = false;
-                }
-            )*
-
-            if complete { Ok(job_map_out) } else { Err(job_map_out) }
-        }
-
-        /// All self-profiling events generated by the query engine use
-        /// virtual `StringId`s for their `event_id`. This method makes all
-        /// those virtual `StringId`s point to actual strings.
+        /// This macro's argument syntax is specifically intended to look like
+        /// plain Rust code, so that `for_each_query_vtable!(..)` calls will be
+        /// formatted by rustfmt.
         ///
-        /// If we are recording only summary data, the ids will point to
-        /// just the query names. If we are recording query keys too, we
-        /// allocate the corresponding strings here.
-        pub fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
-            if !tcx.prof.enabled() {
-                return;
-            }
+        /// To avoid too much nested-macro complication, filter conditions are
+        /// implemented by hand as needed.
+        macro_rules! for_each_query_vtable {
+            // Call with all queries.
+            (ALL, $tcx:expr, $closure:expr) => {{
+                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
+                $(
+                    let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                        &tcx.query_system.query_vtables.$name;
+                    $closure(query);
+                )*
+            }};
 
-            let _prof_timer = tcx.sess.prof.generic_activity("self_profile_alloc_query_strings");
-
-            let mut string_cache = QueryKeyStringCache::new();
-
-            $(
-                $crate::profiling_support::alloc_self_profile_query_strings_for_query_cache(
-                    tcx,
-                    stringify!($name),
-                    &tcx.query_system.query_vtables.$name.cache,
-                    &mut string_cache,
-                );
-            )*
-
-            tcx.sess.prof.store_query_cache_hits();
+            // Only call with queries that can potentially cache to disk.
+            //
+            // This allows the use of trait bounds that only need to be satisfied
+            // by the subset of queries that actually cache to disk.
+            (CACHE_ON_DISK, $tcx:expr, $closure:expr) => {{
+                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
+                $(
+                    #[cfg($cache_on_disk)]
+                    {
+                        let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                            &tcx.query_system.query_vtables.$name;
+                        $closure(query);
+                    }
+                )*
+            }}
         }
 
-        fn encode_all_query_results<'tcx>(
-            tcx: TyCtxt<'tcx>,
-            encoder: &mut CacheEncoder<'_, 'tcx>,
-            query_result_index: &mut EncodedDepNodeIndex,
-        ) {
-            $(
-                #[cfg($cache_on_disk)]
-                {
-                    $crate::plumbing::encode_query_results(
-                        tcx,
-                        &tcx.query_system.query_vtables.$name,
-                        encoder,
-                        query_result_index,
-                    )
-                }
-            )*
-        }
-
-        pub fn query_key_hash_verify_all<'tcx>(tcx: TyCtxt<'tcx>) {
-            if tcx.sess.opts.unstable_opts.incremental_verify_ich || cfg!(debug_assertions) {
-                tcx.sess.time("query_key_hash_verify_all", || {
-                    $(
-                        $crate::plumbing::query_key_hash_verify(
-                            &tcx.query_system.query_vtables.$name,
-                            tcx
-                        );
-                    )*
-                })
-            }
-        }
+        pub(crate) use for_each_query_vtable;
     }
 }
diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs
index 0c0e966f1fa4..08fbd88ac8ee 100644
--- a/compiler/rustc_query_impl/src/profiling_support.rs
+++ b/compiler/rustc_query_impl/src/profiling_support.rs
@@ -7,8 +7,11 @@
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::DefPathData;
 use rustc_middle::query::QueryCache;
+use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::ty::TyCtxt;
 
+use crate::for_each_query_vtable;
+
 pub(crate) struct QueryKeyStringCache {
     def_id_cache: FxHashMap<DefId, StringId>,
 }
@@ -172,10 +175,38 @@ fn spec_to_self_profile_string(&self, builder: &mut QueryKeyStringBuilder<'_, '_
     }
 }
 
+/// All self-profiling events generated by the query engine use
+/// virtual `StringId`s for their `event_id`. This method makes all
+/// those virtual `StringId`s point to actual strings.
+///
+/// If we are recording only summary data, the ids will point to
+/// just the query names. If we are recording query keys too, we
+/// allocate the corresponding strings here.
+pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
+    if !tcx.prof.enabled() {
+        return;
+    }
+
+    let _prof_timer = tcx.sess.prof.generic_activity("self_profile_alloc_query_strings");
+
+    let mut string_cache = QueryKeyStringCache::new();
+
+    for_each_query_vtable!(ALL, tcx, |query: &QueryVTable<'_, _>| {
+        alloc_self_profile_query_strings_for_query_cache(
+            tcx,
+            query.name,
+            &query.cache,
+            &mut string_cache,
+        );
+    });
+
+    tcx.sess.prof.store_query_cache_hits();
+}
+
 /// Allocate the self-profiling query strings for a single query cache. This
 /// method is called from `alloc_self_profile_query_strings` which knows all
 /// the queries via macro magic.
-pub(crate) fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
+fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
     tcx: TyCtxt<'tcx>,
     query_name: &'static str,
     query_cache: &C,

From d066ff726319231ac519ecbc3e1d2996320f34a0 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 11 Mar 2026 13:49:56 +1100
Subject: [PATCH 0346/1059] Pass the vtable to
 `alloc_self_profile_query_strings_for_query_cache`

This simplifies the inner function's signature, and makes it more consistent
with other uses of `for_each_query_vtable!`.
---
 .../rustc_query_impl/src/profiling_support.rs | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs
index 08fbd88ac8ee..c88bc8845ebd 100644
--- a/compiler/rustc_query_impl/src/profiling_support.rs
+++ b/compiler/rustc_query_impl/src/profiling_support.rs
@@ -191,13 +191,8 @@ pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
 
     let mut string_cache = QueryKeyStringCache::new();
 
-    for_each_query_vtable!(ALL, tcx, |query: &QueryVTable<'_, _>| {
-        alloc_self_profile_query_strings_for_query_cache(
-            tcx,
-            query.name,
-            &query.cache,
-            &mut string_cache,
-        );
+    for_each_query_vtable!(ALL, tcx, |query| {
+        alloc_self_profile_query_strings_for_query_cache(tcx, query, &mut string_cache);
     });
 
     tcx.sess.prof.store_query_cache_hits();
@@ -208,8 +203,7 @@ pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
 /// the queries via macro magic.
 fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
     tcx: TyCtxt<'tcx>,
-    query_name: &'static str,
-    query_cache: &C,
+    query: &'tcx QueryVTable<'tcx, C>,
     string_cache: &mut QueryKeyStringCache,
 ) where
     C: QueryCache,
@@ -224,14 +218,14 @@ fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
         if profiler.query_key_recording_enabled() {
             let mut query_string_builder = QueryKeyStringBuilder::new(profiler, tcx, string_cache);
 
-            let query_name = profiler.get_or_alloc_cached_string(query_name);
+            let query_name = profiler.get_or_alloc_cached_string(query.name);
 
             // Since building the string representation of query keys might
             // need to invoke queries itself, we cannot keep the query caches
             // locked while doing so. Instead we copy out the
             // `(query_key, dep_node_index)` pairs and release the lock again.
             let mut query_keys_and_indices = Vec::new();
-            query_cache.for_each(&mut |k, _, i| query_keys_and_indices.push((*k, i)));
+            query.cache.for_each(&mut |k, _, i| query_keys_and_indices.push((*k, i)));
 
             // Now actually allocate the strings. If allocating the strings
             // generates new entries in the query cache, we'll miss them but
@@ -252,14 +246,14 @@ fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
             }
         } else {
             // In this branch we don't allocate query keys
-            let query_name = profiler.get_or_alloc_cached_string(query_name);
+            let query_name = profiler.get_or_alloc_cached_string(query.name);
             let event_id = event_id_builder.from_label(query_name).to_string_id();
 
             // FIXME(eddyb) make this O(1) by using a pre-cached query name `EventId`,
             // instead of passing the `DepNodeIndex` to `finish_with_query_invocation_id`,
             // when recording the event in the first place.
             let mut query_invocation_ids = Vec::new();
-            query_cache.for_each(&mut |_, _, i| {
+            query.cache.for_each(&mut |_, _, i| {
                 query_invocation_ids.push(i.into());
             });
 

From 9fcec027de891d48960a3965973bab1854372eb6 Mon Sep 17 00:00:00 2001
From: ralpha <ralph.bisschops.dev@gmail.com>
Date: Wed, 11 Mar 2026 13:28:59 +0100
Subject: [PATCH 0347/1059] unused_macro_rules switched used and unused
 comments

---
 compiler/rustc_lint_defs/src/builtin.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 38ffecbafa06..6f7a47c36817 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -1032,8 +1032,8 @@
     /// ```rust
     /// #[warn(unused_macro_rules)]
     /// macro_rules! unused_empty {
-    ///     (hello) => { println!("Hello, world!") }; // This rule is unused
-    ///     () => { println!("empty") }; // This rule is used
+    ///     (hello) => { println!("Hello, world!") }; // This rule is used
+    ///     () => { println!("empty") }; // This rule is unused
     /// }
     ///
     /// fn main() {

From 5f3d696d9d2a3f31777b0ee876781dd1522d5017 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 11 Mar 2026 12:41:29 +0000
Subject: [PATCH 0348/1059] Rustup to rustc 1.96.0-nightly (2d76d9bc7
 2026-03-09)

---
 ...sroot_tests-Add-missing-feature-gate.patch | 37 +++++++++++++++++++
 rust-toolchain.toml                           |  2 +-
 2 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 patches/0030-sysroot_tests-Add-missing-feature-gate.patch

diff --git a/patches/0030-sysroot_tests-Add-missing-feature-gate.patch b/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
new file mode 100644
index 000000000000..f2985f4f83d9
--- /dev/null
+++ b/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
@@ -0,0 +1,37 @@
+From baa9c656ba61633f2e5785fc47bc8f88ed2f738e Mon Sep 17 00:00:00 2001
+From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
+Date: Wed, 11 Mar 2026 12:34:47 +0000
+Subject: [PATCH] Add missing feature gate
+
+---
+ coretests/benches/lib.rs | 1 +
+ coretests/tests/lib.rs   | 1 +
+ 2 file changed, 2 insertion(+)
+
+diff --git a/coretests/benches/lib.rs b/coretests/benches/lib.rs
+index 150b9b3..281aa75 100644
+--- a/coretests/benches/lib.rs
++++ b/coretests/benches/lib.rs
+@@ -8,6 +8,7 @@
+ #![feature(iter_array_chunks)]
+ #![feature(iter_next_chunk)]
+ #![feature(iter_advance_by)]
++#![feature(num_internals)]
+ #![feature(uint_gather_scatter_bits)]
+ 
+ extern crate test;
+diff --git a/coretests/tests/lib.rs b/coretests/tests/lib.rs
+index ecdb687..ab2cf77 100644
+--- a/coretests/tests/lib.rs
++++ b/coretests/tests/lib.rs
+@@ -88,6 +88,7 @@
+ #![feature(non_exhaustive_omitted_patterns_lint)]
+ #![feature(nonzero_from_str_radix)]
+ #![feature(numfmt)]
++#![feature(num_internals)]
+ #![feature(one_sided_range)]
+ #![feature(panic_internals)]
+ #![feature(pattern)]
+-- 
+2.43.0
+
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index bc909ed97551..6789958e3722 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-06"
+channel = "nightly-2026-03-10"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From d81cc6846c6aee24270390ed9c0df229d3ce488a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9C=9D=E5=80=89=E6=B0=B4=E5=B8=8C?=
 <asakuramizu111@gmail.com>
Date: Wed, 11 Mar 2026 20:41:57 +0800
Subject: [PATCH 0349/1059] fix: add EII function aliases to exported symbols

---
 compiler/rustc_codegen_ssa/src/back/symbol_export.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
index 557b00b911aa..3269fc5c9c1d 100644
--- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
+++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -199,6 +199,14 @@ fn exported_non_generic_symbols_provider_local<'tcx>(
         }))
     }
 
+    symbols.extend(sorted.iter().flat_map(|&(&def_id, &info)| {
+        tcx.codegen_fn_attrs(def_id).foreign_item_symbol_aliases.iter().map(
+            move |&(foreign_item, _linkage, _visibility)| {
+                (ExportedSymbol::NonGeneric(foreign_item), info)
+            },
+        )
+    }));
+
     if tcx.entry_fn(()).is_some() {
         let exported_symbol =
             ExportedSymbol::NoDefId(SymbolName::new(tcx, tcx.sess.target.entry_name.as_ref()));

From 94361fba3e9b26ca9040625a5de6d6ed1724f4cf Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 15:38:21 +0100
Subject: [PATCH 0350/1059] interpret: go back to regular string interpolation
 for error messages

---
 compiler/rustc_abi/src/lib.rs                 |  18 +-
 .../src/const_eval/dummy_machine.rs           |  11 +-
 .../rustc_const_eval/src/const_eval/error.rs  | 101 ++-
 .../src/const_eval/machine.rs                 |  33 +-
 compiler/rustc_const_eval/src/errors.rs       | 708 +-----------------
 .../rustc_const_eval/src/interpret/call.rs    |  23 +-
 .../rustc_const_eval/src/interpret/cast.rs    |   9 +-
 .../src/interpret/eval_context.rs             |  20 +-
 .../src/interpret/intrinsics.rs               |  71 +-
 .../rustc_const_eval/src/interpret/memory.rs  | 105 +--
 .../src/interpret/validity.rs                 | 349 ++++++---
 compiler/rustc_const_eval/src/lib.rs          |   2 -
 .../src/util/check_validity_requirement.rs    |  19 +-
 compiler/rustc_errors/src/diagnostic_impls.rs |   9 +-
 .../src/mir/interpret/allocation.rs           |   4 +-
 .../rustc_middle/src/mir/interpret/error.rs   | 513 ++++++++-----
 .../rustc_middle/src/mir/interpret/mod.rs     |  29 +-
 .../rustc_middle/src/mir/interpret/pointer.rs |   6 +
 compiler/rustc_middle/src/mir/mod.rs          |   2 +-
 compiler/rustc_middle/src/mir/terminator.rs   | 114 +--
 compiler/rustc_middle/src/ty/layout.rs        |  26 +-
 compiler/rustc_mir_transform/src/errors.rs    |   6 +-
 .../src/known_panics_lint.rs                  |   2 +-
 compiler/rustc_target/src/spec/json.rs        |   6 +-
 .../stacked_borrows/diagnostics.rs            |  21 +-
 .../tree_borrows/diagnostics.rs               |   4 +-
 src/tools/miri/src/diagnostics.rs             |  46 +-
 .../tests/pass/alloc-access-tracking.stderr   |   4 +-
 28 files changed, 809 insertions(+), 1452 deletions(-)

diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 21ca92d46d1c..253dff6f8e75 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1000,20 +1000,6 @@ pub enum AlignFromBytesError {
     TooLarge(u64),
 }
 
-impl AlignFromBytesError {
-    pub fn diag_ident(self) -> &'static str {
-        match self {
-            Self::NotPowerOfTwo(_) => "not_power_of_two",
-            Self::TooLarge(_) => "too_large",
-        }
-    }
-
-    pub fn align(self) -> u64 {
-        let (Self::NotPowerOfTwo(align) | Self::TooLarge(align)) = self;
-        align
-    }
-}
-
 impl fmt::Debug for AlignFromBytesError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self, f)
@@ -1023,8 +1009,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 impl fmt::Display for AlignFromBytesError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            AlignFromBytesError::NotPowerOfTwo(align) => write!(f, "`{align}` is not a power of 2"),
-            AlignFromBytesError::TooLarge(align) => write!(f, "`{align}` is too large"),
+            AlignFromBytesError::NotPowerOfTwo(align) => write!(f, "{align} is not a power of 2"),
+            AlignFromBytesError::TooLarge(align) => write!(f, "{align} is too large"),
         }
     }
 }
diff --git a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
index f41b68bb1f7e..7c5f867929f0 100644
--- a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
@@ -25,17 +25,8 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(f, $($tt)*)
         }
     }
+    impl rustc_middle::mir::interpret::MachineStopType for Zst {}
 
-    impl rustc_middle::mir::interpret::MachineStopType for Zst {
-        fn diagnostic_message(&self) -> rustc_errors::DiagMessage {
-            self.to_string().into()
-        }
-
-        fn add_args(
-            self: Box<Self>,
-            _: &mut dyn FnMut(rustc_errors::DiagArgName, rustc_errors::DiagArgValue),
-        ) {}
-    }
     throw_machine_stop!(Zst)
 }}
 
diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 41d21bd74f98..61e8e433d517 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -1,15 +1,17 @@
-use std::mem;
+use std::{fmt, mem};
 
-use rustc_errors::{Diag, DiagArgName, DiagArgValue, DiagMessage, IntoDiagArg};
+use rustc_errors::Diag;
 use rustc_middle::mir::AssertKind;
-use rustc_middle::mir::interpret::{AllocId, Provenance, ReportedErrorInfo, UndefinedBehaviorInfo};
+use rustc_middle::mir::interpret::{
+    AllocId, Provenance, ReportedErrorInfo, UndefinedBehaviorInfo, UnsupportedOpInfo,
+};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::ConstInt;
 use rustc_middle::ty::layout::LayoutError;
 use rustc_span::{Span, Symbol};
 
 use super::CompileTimeMachine;
-use crate::errors::{self, FrameNote, ReportErrorExt};
+use crate::errors::{self, FrameNote};
 use crate::interpret::{
     CtfeProvenance, ErrorHandled, Frame, InterpCx, InterpErrorInfo, InterpErrorKind,
     MachineStopType, Pointer, err_inval, err_machine_stop,
@@ -40,65 +42,49 @@ pub enum ConstEvalErrKind {
     ConstMakeGlobalWithOffset(Pointer<Option<CtfeProvenance>>),
 }
 
-impl MachineStopType for ConstEvalErrKind {
-    fn diagnostic_message(&self) -> DiagMessage {
+impl fmt::Display for ConstEvalErrKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use ConstEvalErrKind::*;
-        use rustc_errors::msg;
-
         match self {
-            ConstAccessesMutGlobal => "constant accesses mutable global memory".into(),
+            ConstAccessesMutGlobal => write!(f, "constant accesses mutable global memory"),
             ModifiedGlobal => {
-                "modifying a static's initial value from another static's initializer".into()
+                write!(f, "modifying a static's initial value from another static's initializer")
             }
-            Panic { .. } => msg!("evaluation panicked: {$msg}"),
+            Panic { msg, .. } => write!(f, "evaluation panicked: {msg}"),
             RecursiveStatic => {
-                "encountered static that tried to access itself during initialization".into()
+                write!(f, "encountered static that tried to access itself during initialization")
             }
-            AssertFailure(x) => x.diagnostic_message(),
+            AssertFailure(x) => write!(f, "{x}"),
             WriteThroughImmutablePointer => {
-                msg!(
+                write!(
+                    f,
                     "writing through a pointer that was derived from a shared (immutable) reference"
                 )
             }
-            ConstMakeGlobalPtrAlreadyMadeGlobal { .. } => {
-                msg!("attempting to call `const_make_global` twice on the same allocation {$alloc}")
-            }
-            ConstMakeGlobalPtrIsNonHeap(_) => {
-                msg!(
-                    "pointer passed to `const_make_global` does not point to a heap allocation: {$ptr}"
+            ConstMakeGlobalPtrAlreadyMadeGlobal(alloc) => {
+                write!(
+                    f,
+                    "attempting to call `const_make_global` twice on the same allocation {alloc}"
                 )
             }
-            ConstMakeGlobalWithDanglingPtr(_) => {
-                msg!("pointer passed to `const_make_global` is dangling: {$ptr}")
+            ConstMakeGlobalPtrIsNonHeap(ptr) => {
+                write!(
+                    f,
+                    "pointer passed to `const_make_global` does not point to a heap allocation: {ptr}"
+                )
             }
-            ConstMakeGlobalWithOffset(_) => {
-                msg!("making {$ptr} global which does not point to the beginning of an object")
+            ConstMakeGlobalWithDanglingPtr(ptr) => {
+                write!(f, "pointer passed to `const_make_global` is dangling: {ptr}")
             }
-        }
-    }
-    fn add_args(self: Box<Self>, adder: &mut dyn FnMut(DiagArgName, DiagArgValue)) {
-        use ConstEvalErrKind::*;
-        match *self {
-            RecursiveStatic
-            | ConstAccessesMutGlobal
-            | ModifiedGlobal
-            | WriteThroughImmutablePointer => {}
-            AssertFailure(kind) => kind.add_args(adder),
-            Panic { msg, .. } => {
-                adder("msg".into(), msg.into_diag_arg(&mut None));
-            }
-            ConstMakeGlobalPtrIsNonHeap(ptr)
-            | ConstMakeGlobalWithOffset(ptr)
-            | ConstMakeGlobalWithDanglingPtr(ptr) => {
-                adder("ptr".into(), format!("{ptr:?}").into_diag_arg(&mut None));
-            }
-            ConstMakeGlobalPtrAlreadyMadeGlobal(alloc) => {
-                adder("alloc".into(), alloc.into_diag_arg(&mut None));
+            ConstMakeGlobalWithOffset(ptr) => {
+                write!(f, "making {ptr} global which does not point to the beginning of an object")
             }
         }
     }
 }
 
+impl MachineStopType for ConstEvalErrKind {}
+
 /// The errors become [`InterpErrorKind::MachineStop`] when being raised.
 impl<'tcx> Into<InterpErrorInfo<'tcx>> for ConstEvalErrKind {
     fn into(self) -> InterpErrorInfo<'tcx> {
@@ -207,14 +193,20 @@ pub(super) fn report<'tcx, C, F>(
         _ => {
             let (our_span, frames) = get_span_and_frames();
             let span = span.substitute_dummy(our_span);
-            let mut err = tcx.dcx().struct_span_err(our_span, error.diagnostic_message());
-            // We allow invalid programs in infallible promoteds since invalid layouts can occur
-            // anyway (e.g. due to size overflow). And we allow OOM as that can happen any time.
-            let allowed_in_infallible = matches!(
+            let mut err = tcx.dcx().struct_span_err(our_span, error.to_string());
+            if matches!(
                 error,
-                InterpErrorKind::ResourceExhaustion(_) | InterpErrorKind::InvalidProgram(_)
-            );
-
+                InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::ValidationError {
+                    ptr_bytes_warning: true,
+                    ..
+                }) | InterpErrorKind::Unsupported(
+                    UnsupportedOpInfo::ReadPointerAsInt(..)
+                        | UnsupportedOpInfo::ReadPartialPointer(..)
+                )
+            ) {
+                err.help("this code performed an operation that depends on the underlying bytes representing a pointer");
+                err.help("the absolute address of a pointer is not known at compile-time, so such operations are not supported");
+            }
             if let InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::InvalidUninitBytes(
                 Some((alloc_id, _access)),
             )) = error
@@ -229,7 +221,12 @@ pub(super) fn report<'tcx, C, F>(
                 err.subdiagnostic(raw_bytes);
             }
 
-            error.add_args(&mut err);
+            // We allow invalid programs in infallible promoteds since invalid layouts can occur
+            // anyway (e.g. due to size overflow). And we allow OOM as that can happen any time.
+            let allowed_in_infallible = matches!(
+                error,
+                InterpErrorKind::ResourceExhaustion(_) | InterpErrorKind::InvalidProgram(_)
+            );
 
             mk(&mut err, span, frames);
             let g = err.emit();
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index e88123334dd5..a19bf0b4da8b 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -5,7 +5,6 @@
 use rustc_abi::{Align, FIRST_VARIANT, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
-use rustc_errors::msg;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, CRATE_HIR_ID, LangItem, find_attr};
 use rustc_middle::mir::AssertMessage;
@@ -24,7 +23,7 @@
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
     GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
     compile_time_machine, ensure_monomorphic_enough, err_inval, interp_ok, throw_exhaust,
-    throw_inval, throw_ub, throw_ub_custom, throw_unsup, throw_unsup_format,
+    throw_inval, throw_ub, throw_ub_format, throw_unsup, throw_unsup_format,
     type_implements_dyn_trait,
 };
 
@@ -489,18 +488,9 @@ fn call_intrinsic(
 
                 let align = match Align::from_bytes(align) {
                     Ok(a) => a,
-                    Err(err) => throw_ub_custom!(
-                        msg!(
-                            "invalid align passed to `{$name}`: {$align} is {$err_kind ->
-                                [not_power_of_two] not a power of 2
-                                [too_large] too large
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        name = "const_allocate",
-                        err_kind = err.diag_ident(),
-                        align = err.align()
-                    ),
+                    Err(err) => {
+                        throw_ub_format!("invalid align passed to `const_allocate`: {err}")
+                    }
                 };
 
                 let ptr = ecx.allocate_ptr(
@@ -519,18 +509,9 @@ fn call_intrinsic(
                 let size = Size::from_bytes(size);
                 let align = match Align::from_bytes(align) {
                     Ok(a) => a,
-                    Err(err) => throw_ub_custom!(
-                        msg!(
-                            "invalid align passed to `{$name}`: {$align} is {$err_kind ->
-                                [not_power_of_two] not a power of 2
-                                [too_large] too large
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        name = "const_deallocate",
-                        err_kind = err.diag_ident(),
-                        align = err.align()
-                    ),
+                    Err(err) => {
+                        throw_ub_format!("invalid align passed to `const_deallocate`: {err}")
+                    }
                 };
 
                 // If an allocation is created in an another const,
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 07d001e9d847..1097eecf3121 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -1,22 +1,11 @@
 use std::borrow::Cow;
-use std::fmt::Write;
 
-use either::Either;
-use rustc_abi::WrappingRange;
 use rustc_errors::codes::*;
 use rustc_errors::formatting::DiagMessageAddArg;
-use rustc_errors::{
-    Diag, DiagArgMap, DiagArgValue, DiagMessage, Diagnostic, EmissionGuarantee, Level, MultiSpan,
-    Subdiagnostic, format_diag_message, msg,
-};
+use rustc_errors::{Diag, DiagArgValue, EmissionGuarantee, MultiSpan, Subdiagnostic, msg};
 use rustc_hir::ConstContext;
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_middle::mir::interpret::{
-    CtfeProvenance, ExpectedKind, InterpErrorKind, InvalidMetaKind, InvalidProgramInfo,
-    Misalignment, Pointer, PointerKind, ResourceExhaustionInfo, UndefinedBehaviorInfo,
-    UnsupportedOpInfo, ValidationErrorInfo,
-};
-use rustc_middle::ty::{self, Mutability, Ty};
+use rustc_middle::ty::{Mutability, Ty};
 use rustc_span::{Span, Symbol};
 
 use crate::interpret::InternKind;
@@ -609,699 +598,6 @@ pub struct LiveDrop<'tcx> {
     pub dropped_at: Span,
 }
 
-pub trait ReportErrorExt {
-    /// Returns the diagnostic message for this error.
-    fn diagnostic_message(&self) -> DiagMessage;
-    fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>);
-
-    fn debug(self) -> String
-    where
-        Self: Sized,
-    {
-        ty::tls::with(move |tcx| {
-            let dcx = tcx.dcx();
-            let mut diag = dcx.struct_allow(DiagMessage::Str(String::new().into()));
-            let message = self.diagnostic_message();
-            self.add_args(&mut diag);
-            let s = format_diag_message(&message, &diag.args).into_owned();
-            diag.cancel();
-            s
-        })
-    }
-}
-
-impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
-    fn diagnostic_message(&self) -> DiagMessage {
-        use UndefinedBehaviorInfo::*;
-
-        match self {
-            Ub(msg) => msg.clone().into(),
-            Custom(x) => (x.msg)(),
-            ValidationError(e) => e.diagnostic_message(),
-
-            Unreachable => "entering unreachable code".into(),
-            BoundsCheckFailed { .. } => msg!("indexing out of bounds: the len is {$len} but the index is {$index}"),
-            DivisionByZero => "dividing by zero".into(),
-            RemainderByZero => "calculating the remainder with a divisor of zero".into(),
-            DivisionOverflow => "overflow in signed division (dividing MIN by -1)".into(),
-            RemainderOverflow => "overflow in signed remainder (dividing MIN by -1)".into(),
-            PointerArithOverflow => "overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`".into(),
-            ArithOverflow { .. } => msg!("arithmetic overflow in `{$intrinsic}`"),
-            ShiftOverflow { .. } => msg!("overflowing shift by {$shift_amount} in `{$intrinsic}`"),
-            InvalidMeta(InvalidMetaKind::SliceTooBig) => "invalid metadata in wide pointer: slice is bigger than largest supported object".into(),
-            InvalidMeta(InvalidMetaKind::TooBig) => "invalid metadata in wide pointer: total size is bigger than largest supported object".into(),
-            UnterminatedCString(_) => "reading a null-terminated string starting at {$pointer} with no null found before end of allocation".into(),
-            PointerUseAfterFree(_, _) => msg!(
-                "{$operation ->
-                    [MemoryAccess] memory access failed
-                    [InboundsPointerArithmetic] in-bounds pointer arithmetic failed
-                    *[Dereferenceable] pointer not dereferenceable
-                }: {$alloc_id} has been freed, so this pointer is dangling"
-            ),
-            PointerOutOfBounds { .. } => msg!(
-                "{$operation ->
-                    [MemoryAccess] memory access failed
-                    [InboundsPointerArithmetic] in-bounds pointer arithmetic failed
-                    *[Dereferenceable] pointer not dereferenceable
-                }: {$operation ->
-                    [MemoryAccess] attempting to access {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    [InboundsPointerArithmetic] attempting to offset pointer by {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    *[Dereferenceable] pointer must {$inbounds_size ->
-                        [0] point to some allocation
-                        [1] be dereferenceable for 1 byte
-                        *[x] be dereferenceable for {$inbounds_size} bytes
-                    }
-                }, but got {$pointer} which {$ptr_offset_is_neg ->
-                    [true] points to before the beginning of the allocation
-                    *[false] {$inbounds_size_is_neg ->
-                        [false] {$alloc_size_minus_ptr_offset ->
-                            [0] is at or beyond the end of the allocation of size {$alloc_size ->
-                                [1] 1 byte
-                                *[x] {$alloc_size} bytes
-                            }
-                            [1] is only 1 byte from the end of the allocation
-                            *[x] is only {$alloc_size_minus_ptr_offset} bytes from the end of the allocation
-                        }
-                        *[true] {$ptr_offset_abs ->
-                            [0] is at the beginning of the allocation
-                            *[other] is only {$ptr_offset_abs} bytes from the beginning of the allocation
-                        }
-                    }
-                }"
-            ),
-            DanglingIntPointer { addr: 0, .. } => msg!(
-                "{$operation ->
-                    [MemoryAccess] memory access failed
-                    [InboundsPointerArithmetic] in-bounds pointer arithmetic failed
-                    *[Dereferenceable] pointer not dereferenceable
-                }: {$operation ->
-                    [MemoryAccess] attempting to access {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    [InboundsPointerArithmetic] attempting to offset pointer by {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    *[Dereferenceable] pointer must {$inbounds_size ->
-                        [0] point to some allocation
-                        [1] be dereferenceable for 1 byte
-                        *[x] be dereferenceable for {$inbounds_size} bytes
-                    }
-                }, but got null pointer"),
-            DanglingIntPointer { .. } => msg!(
-                "{$operation ->
-                    [MemoryAccess] memory access failed
-                    [InboundsPointerArithmetic] in-bounds pointer arithmetic failed
-                    *[Dereferenceable] pointer not dereferenceable
-                }: {$operation ->
-                    [MemoryAccess] attempting to access {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    [InboundsPointerArithmetic] attempting to offset pointer by {$inbounds_size ->
-                        [1] 1 byte
-                        *[x] {$inbounds_size} bytes
-                    }
-                    *[Dereferenceable] pointer must {$inbounds_size ->
-                        [0] point to some allocation
-                        [1] be dereferenceable for 1 byte
-                        *[x] be dereferenceable for {$inbounds_size} bytes
-                    }
-                }, but got {$pointer} which is a dangling pointer (it has no provenance)"),
-            AlignmentCheckFailed { .. } => msg!(
-                "{$msg ->
-                    [AccessedPtr] accessing memory
-                    *[other] accessing memory based on pointer
-                } with alignment {$has}, but alignment {$required} is required"
-            ),
-            WriteToReadOnly(_) => msg!("writing to {$allocation} which is read-only"),
-            DerefFunctionPointer(_) => msg!("accessing {$allocation} which contains a function"),
-            DerefVTablePointer(_) => msg!("accessing {$allocation} which contains a vtable"),
-            DerefVaListPointer(_) => msg!("accessing {$allocation} which contains a variable argument list"),
-            DerefTypeIdPointer(_) => msg!("accessing {$allocation} which contains a `TypeId`"),
-            InvalidBool(_) => msg!("interpreting an invalid 8-bit value as a bool: 0x{$value}"),
-            InvalidChar(_) => msg!("interpreting an invalid 32-bit value as a char: 0x{$value}"),
-            InvalidTag(_) => msg!("enum value has invalid tag: {$tag}"),
-            InvalidFunctionPointer(_) => msg!("using {$pointer} as function pointer but it does not point to a function"),
-            InvalidVaListPointer(_) => msg!("using {$pointer} as variable argument list pointer but it does not point to a variable argument list"),
-            InvalidVTablePointer(_) => msg!("using {$pointer} as vtable pointer but it does not point to a vtable"),
-            InvalidVTableTrait { .. } => msg!("using vtable for `{$vtable_dyn_type}` but `{$expected_dyn_type}` was expected"),
-            InvalidStr(_) => msg!("this string is not valid UTF-8: {$err}"),
-            InvalidUninitBytes(None) => "using uninitialized data, but this operation requires initialized memory".into(),
-            InvalidUninitBytes(Some(_)) => msg!("reading memory at {$alloc}{$access}, but memory is uninitialized at {$uninit}, and this operation requires initialized memory"),
-            DeadLocal => "accessing a dead local variable".into(),
-            ScalarSizeMismatch(_) => msg!("scalar size mismatch: expected {$target_size} bytes but got {$data_size} bytes instead"),
-            UninhabitedEnumVariantWritten(_) => "writing discriminant of an uninhabited enum variant".into(),
-            UninhabitedEnumVariantRead(_) => "read discriminant of an uninhabited enum variant".into(),
-            InvalidNichedEnumVariantWritten { .. } => {
-                msg!("trying to set discriminant of a {$ty} to the niched variant, but the value does not match")
-            }
-            AbiMismatchArgument { .. } => msg!("calling a function whose parameter #{$arg_idx} has type {$callee_ty} passing argument of type {$caller_ty}"),
-            AbiMismatchReturn { .. } => msg!("calling a function with return type {$callee_ty} passing return place of type {$caller_ty}"),
-            VaArgOutOfBounds => "more C-variadic arguments read than were passed".into(),
-            CVariadicMismatch { ..} => "calling a function where the caller and callee disagree on whether the function is C-variadic".into(),
-            CVariadicFixedCountMismatch { .. } => msg!("calling a C-variadic function with {$caller} fixed arguments, but the function expects {$callee}"),
-        }
-    }
-
-    fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        use UndefinedBehaviorInfo::*;
-        match self {
-            Ub(_) => {}
-            Custom(custom) => {
-                (custom.add_args)(&mut |name, value| {
-                    diag.arg(name, value);
-                });
-            }
-            ValidationError(e) => e.add_args(diag),
-
-            Unreachable
-            | DivisionByZero
-            | RemainderByZero
-            | DivisionOverflow
-            | RemainderOverflow
-            | PointerArithOverflow
-            | InvalidMeta(InvalidMetaKind::SliceTooBig)
-            | InvalidMeta(InvalidMetaKind::TooBig)
-            | InvalidUninitBytes(None)
-            | DeadLocal
-            | VaArgOutOfBounds
-            | UninhabitedEnumVariantWritten(_)
-            | UninhabitedEnumVariantRead(_) => {}
-
-            ArithOverflow { intrinsic } => {
-                diag.arg("intrinsic", intrinsic);
-            }
-            ShiftOverflow { intrinsic, shift_amount } => {
-                diag.arg("intrinsic", intrinsic);
-                diag.arg(
-                    "shift_amount",
-                    match shift_amount {
-                        Either::Left(v) => v.to_string(),
-                        Either::Right(v) => v.to_string(),
-                    },
-                );
-            }
-            BoundsCheckFailed { len, index } => {
-                diag.arg("len", len);
-                diag.arg("index", index);
-            }
-            UnterminatedCString(ptr)
-            | InvalidFunctionPointer(ptr)
-            | InvalidVaListPointer(ptr)
-            | InvalidVTablePointer(ptr) => {
-                diag.arg("pointer", ptr);
-            }
-            InvalidVTableTrait { expected_dyn_type, vtable_dyn_type } => {
-                diag.arg("expected_dyn_type", expected_dyn_type.to_string());
-                diag.arg("vtable_dyn_type", vtable_dyn_type.to_string());
-            }
-            PointerUseAfterFree(alloc_id, msg) => {
-                diag.arg("alloc_id", alloc_id).arg("operation", format!("{:?}", msg));
-            }
-            PointerOutOfBounds { alloc_id, alloc_size, ptr_offset, inbounds_size, msg } => {
-                diag.arg("alloc_size", alloc_size.bytes());
-                diag.arg("pointer", {
-                    let mut out = format!("{:?}", alloc_id);
-                    if ptr_offset > 0 {
-                        write!(out, "+{:#x}", ptr_offset).unwrap();
-                    } else if ptr_offset < 0 {
-                        write!(out, "-{:#x}", ptr_offset.unsigned_abs()).unwrap();
-                    }
-                    out
-                });
-                diag.arg("inbounds_size", inbounds_size);
-                diag.arg("inbounds_size_is_neg", inbounds_size < 0);
-                diag.arg("inbounds_size_abs", inbounds_size.unsigned_abs());
-                diag.arg("ptr_offset", ptr_offset);
-                diag.arg("ptr_offset_is_neg", ptr_offset < 0);
-                diag.arg("ptr_offset_abs", ptr_offset.unsigned_abs());
-                diag.arg(
-                    "alloc_size_minus_ptr_offset",
-                    alloc_size.bytes().saturating_sub(ptr_offset as u64),
-                );
-                diag.arg("operation", format!("{:?}", msg));
-            }
-            DanglingIntPointer { addr, inbounds_size, msg } => {
-                if addr != 0 {
-                    diag.arg(
-                        "pointer",
-                        Pointer::<Option<CtfeProvenance>>::without_provenance(addr).to_string(),
-                    );
-                }
-
-                diag.arg("inbounds_size", inbounds_size);
-                diag.arg("inbounds_size_is_neg", inbounds_size < 0);
-                diag.arg("inbounds_size_abs", inbounds_size.unsigned_abs());
-                diag.arg("operation", format!("{:?}", msg));
-            }
-            AlignmentCheckFailed(Misalignment { required, has }, msg) => {
-                diag.arg("required", required.bytes());
-                diag.arg("has", has.bytes());
-                diag.arg("msg", format!("{msg:?}"));
-            }
-            WriteToReadOnly(alloc)
-            | DerefFunctionPointer(alloc)
-            | DerefVTablePointer(alloc)
-            | DerefVaListPointer(alloc)
-            | DerefTypeIdPointer(alloc) => {
-                diag.arg("allocation", alloc);
-            }
-            InvalidBool(b) => {
-                diag.arg("value", format!("{b:02x}"));
-            }
-            InvalidChar(c) => {
-                diag.arg("value", format!("{c:08x}"));
-            }
-            InvalidTag(tag) => {
-                diag.arg("tag", format!("{tag:x}"));
-            }
-            InvalidStr(err) => {
-                diag.arg("err", format!("{err}"));
-            }
-            InvalidUninitBytes(Some((alloc, info))) => {
-                diag.arg("alloc", alloc);
-                diag.arg("access", info.access);
-                diag.arg("uninit", info.bad);
-            }
-            ScalarSizeMismatch(info) => {
-                diag.arg("target_size", info.target_size);
-                diag.arg("data_size", info.data_size);
-            }
-            InvalidNichedEnumVariantWritten { enum_ty } => {
-                diag.arg("ty", enum_ty);
-            }
-            AbiMismatchArgument { arg_idx, caller_ty, callee_ty } => {
-                diag.arg("arg_idx", arg_idx + 1); // adjust for 1-indexed lists in output
-                diag.arg("caller_ty", caller_ty);
-                diag.arg("callee_ty", callee_ty);
-            }
-            AbiMismatchReturn { caller_ty, callee_ty } => {
-                diag.arg("caller_ty", caller_ty);
-                diag.arg("callee_ty", callee_ty);
-            }
-            CVariadicMismatch { caller_is_c_variadic, callee_is_c_variadic } => {
-                diag.arg("caller_is_c_variadic", caller_is_c_variadic);
-                diag.arg("callee_is_c_variadic", callee_is_c_variadic);
-            }
-            CVariadicFixedCountMismatch { caller, callee } => {
-                diag.arg("caller", caller);
-                diag.arg("callee", callee);
-            }
-        }
-    }
-}
-
-impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
-    fn diagnostic_message(&self) -> DiagMessage {
-        use rustc_middle::mir::interpret::ValidationErrorKind::*;
-
-        match self.kind {
-            PtrToUninhabited { ptr_kind: PointerKind::Box, .. } => {
-                msg!("{$front_matter}: encountered a box pointing to uninhabited type {$ty}")
-            }
-            PtrToUninhabited { ptr_kind: PointerKind::Ref(_), .. } => {
-                msg!("{$front_matter}: encountered a reference pointing to uninhabited type {$ty}")
-            }
-
-            PointerAsInt { .. } => {
-                msg!("{$front_matter}: encountered a pointer, but {$expected}")
-            }
-            PartialPointer => {
-                msg!("{$front_matter}: encountered a partial pointer or a mix of pointers")
-            }
-            MutableRefToImmutable => {
-                msg!(
-                    "{$front_matter}: encountered mutable reference or box pointing to read-only memory"
-                )
-            }
-            NullFnPtr { .. } => {
-                msg!(
-                    "{$front_matter}: encountered a {$maybe ->
-                        [true] maybe-null
-                        *[false] null
-                    } function pointer"
-                )
-            }
-            NeverVal => {
-                msg!("{$front_matter}: encountered a value of the never type `!`")
-            }
-            NonnullPtrMaybeNull { .. } => {
-                msg!(
-                    "{$front_matter}: encountered a maybe-null pointer, but expected something that is definitely non-zero"
-                )
-            }
-            PtrOutOfRange { .. } => {
-                msg!(
-                    "{$front_matter}: encountered a pointer with unknown absolute address, but expected something that is definitely {$in_range}"
-                )
-            }
-            OutOfRange { .. } => {
-                msg!("{$front_matter}: encountered {$value}, but expected something {$in_range}")
-            }
-            UnsafeCellInImmutable => {
-                msg!("{$front_matter}: encountered `UnsafeCell` in read-only memory")
-            }
-            UninhabitedVal { .. } => {
-                msg!("{$front_matter}: encountered a value of uninhabited type `{$ty}`")
-            }
-            InvalidEnumTag { .. } => {
-                msg!("{$front_matter}: encountered {$value}, but expected a valid enum tag")
-            }
-            UninhabitedEnumVariant => {
-                msg!("{$front_matter}: encountered an uninhabited enum variant")
-            }
-            Uninit { .. } => {
-                msg!("{$front_matter}: encountered uninitialized memory, but {$expected}")
-            }
-            InvalidVTablePtr { .. } => {
-                msg!("{$front_matter}: encountered {$value}, but expected a vtable pointer")
-            }
-            InvalidMetaWrongTrait { .. } => {
-                msg!(
-                    "{$front_matter}: wrong trait in wide pointer vtable: expected `{$expected_dyn_type}`, but encountered `{$vtable_dyn_type}`"
-                )
-            }
-            InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Box } => {
-                msg!(
-                    "{$front_matter}: encountered invalid box metadata: slice is bigger than largest supported object"
-                )
-            }
-            InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Ref(_) } => {
-                msg!(
-                    "{$front_matter}: encountered invalid reference metadata: slice is bigger than largest supported object"
-                )
-            }
-
-            InvalidMetaTooLarge { ptr_kind: PointerKind::Box } => {
-                msg!(
-                    "{$front_matter}: encountered invalid box metadata: total size is bigger than largest supported object"
-                )
-            }
-            InvalidMetaTooLarge { ptr_kind: PointerKind::Ref(_) } => {
-                msg!(
-                    "{$front_matter}: encountered invalid reference metadata: total size is bigger than largest supported object"
-                )
-            }
-            UnalignedPtr { ptr_kind: PointerKind::Ref(_), .. } => {
-                msg!(
-                    "{$front_matter}: encountered an unaligned reference (required {$required_bytes} byte alignment but found {$found_bytes})"
-                )
-            }
-            UnalignedPtr { ptr_kind: PointerKind::Box, .. } => {
-                msg!(
-                    "{$front_matter}: encountered an unaligned box (required {$required_bytes} byte alignment but found {$found_bytes})"
-                )
-            }
-
-            NullPtr { ptr_kind: PointerKind::Box, .. } => {
-                msg!(
-                    "{$front_matter}: encountered a {$maybe ->
-                        [true] maybe-null
-                        *[false] null
-                    } box"
-                )
-            }
-            NullPtr { ptr_kind: PointerKind::Ref(_), .. } => {
-                msg!(
-                    "{$front_matter}: encountered a {$maybe ->
-                        [true] maybe-null
-                        *[false] null
-                    } reference"
-                )
-            }
-            DanglingPtrNoProvenance { ptr_kind: PointerKind::Box, .. } => {
-                msg!("{$front_matter}: encountered a dangling box ({$pointer} has no provenance)")
-            }
-            DanglingPtrNoProvenance { ptr_kind: PointerKind::Ref(_), .. } => {
-                msg!(
-                    "{$front_matter}: encountered a dangling reference ({$pointer} has no provenance)"
-                )
-            }
-            DanglingPtrOutOfBounds { ptr_kind: PointerKind::Box } => {
-                msg!(
-                    "{$front_matter}: encountered a dangling box (going beyond the bounds of its allocation)"
-                )
-            }
-            DanglingPtrOutOfBounds { ptr_kind: PointerKind::Ref(_) } => {
-                msg!(
-                    "{$front_matter}: encountered a dangling reference (going beyond the bounds of its allocation)"
-                )
-            }
-            DanglingPtrUseAfterFree { ptr_kind: PointerKind::Box } => {
-                msg!("{$front_matter}: encountered a dangling box (use-after-free)")
-            }
-            DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref(_) } => {
-                msg!("{$front_matter}: encountered a dangling reference (use-after-free)")
-            }
-            InvalidBool { .. } => {
-                msg!("{$front_matter}: encountered {$value}, but expected a boolean")
-            }
-            InvalidChar { .. } => {
-                msg!(
-                    "{$front_matter}: encountered {$value}, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)"
-                )
-            }
-            InvalidFnPtr { .. } => {
-                msg!("{$front_matter}: encountered {$value}, but expected a function pointer")
-            }
-        }
-    }
-
-    fn add_args<G: EmissionGuarantee>(self, err: &mut Diag<'_, G>) {
-        use rustc_errors::msg;
-        use rustc_middle::mir::interpret::ValidationErrorKind::*;
-
-        if let PointerAsInt { .. } | PartialPointer = self.kind {
-            err.help(msg!("this code performed an operation that depends on the underlying bytes representing a pointer"));
-            err.help(msg!("the absolute address of a pointer is not known at compile-time, so such operations are not supported"));
-        }
-
-        let message = if let Some(path) = self.path {
-            format_diag_message(
-                &msg!("constructing invalid value at {$path}"),
-                &DiagArgMap::from_iter([("path".into(), DiagArgValue::Str(path.into()))]),
-            )
-        } else {
-            Cow::Borrowed("constructing invalid value")
-        };
-
-        err.arg("front_matter", message);
-
-        fn add_range_arg<G: EmissionGuarantee>(
-            r: WrappingRange,
-            max_hi: u128,
-            err: &mut Diag<'_, G>,
-        ) {
-            let WrappingRange { start: lo, end: hi } = r;
-            assert!(hi <= max_hi);
-            let msg = if lo > hi {
-                msg!("less or equal to {$hi}, or greater or equal to {$lo}")
-            } else if lo == hi {
-                msg!("equal to {$lo}")
-            } else if lo == 0 {
-                assert!(hi < max_hi, "should not be printing if the range covers everything");
-                msg!("less or equal to {$hi}")
-            } else if hi == max_hi {
-                assert!(lo > 0, "should not be printing if the range covers everything");
-                msg!("greater or equal to {$lo}")
-            } else {
-                msg!("in the range {$lo}..={$hi}")
-            };
-
-            let message = format_diag_message(
-                &msg,
-                &DiagArgMap::from_iter([
-                    ("lo".into(), DiagArgValue::Str(lo.to_string().into())),
-                    ("hi".into(), DiagArgValue::Str(hi.to_string().into())),
-                ]),
-            );
-            err.arg("in_range", message);
-        }
-
-        match self.kind {
-            PtrToUninhabited { ty, .. } | UninhabitedVal { ty } => {
-                err.arg("ty", ty);
-            }
-            PointerAsInt { expected } | Uninit { expected } => {
-                let msg = match expected {
-                    ExpectedKind::Reference => "expected a reference",
-                    ExpectedKind::Box => "expected a box",
-                    ExpectedKind::RawPtr => "expected a raw pointer",
-                    ExpectedKind::InitScalar => "expected initialized scalar value",
-                    ExpectedKind::Bool => "expected a boolean",
-                    ExpectedKind::Char => "expected a unicode scalar value",
-                    ExpectedKind::Float => "expected a floating point number",
-                    ExpectedKind::Int => "expected an integer",
-                    ExpectedKind::FnPtr => "expected a function pointer",
-                    ExpectedKind::EnumTag => "expected a valid enum tag",
-                    ExpectedKind::Str => "expected a string",
-                };
-                err.arg("expected", msg);
-            }
-            InvalidEnumTag { value }
-            | InvalidVTablePtr { value }
-            | InvalidBool { value }
-            | InvalidChar { value }
-            | InvalidFnPtr { value } => {
-                err.arg("value", value);
-            }
-            PtrOutOfRange { range, max_value } => add_range_arg(range, max_value, err),
-            OutOfRange { range, max_value, value } => {
-                err.arg("value", value);
-                add_range_arg(range, max_value, err);
-            }
-            UnalignedPtr { required_bytes, found_bytes, .. } => {
-                err.arg("required_bytes", required_bytes);
-                err.arg("found_bytes", found_bytes);
-            }
-            DanglingPtrNoProvenance { pointer, .. } => {
-                err.arg("pointer", pointer);
-            }
-            InvalidMetaWrongTrait { vtable_dyn_type, expected_dyn_type } => {
-                err.arg("vtable_dyn_type", vtable_dyn_type.to_string());
-                err.arg("expected_dyn_type", expected_dyn_type.to_string());
-            }
-            NullPtr { maybe, .. } | NullFnPtr { maybe } => {
-                err.arg("maybe", maybe);
-            }
-            MutableRefToImmutable
-            | NonnullPtrMaybeNull
-            | NeverVal
-            | UnsafeCellInImmutable
-            | InvalidMetaSliceTooLarge { .. }
-            | InvalidMetaTooLarge { .. }
-            | DanglingPtrUseAfterFree { .. }
-            | DanglingPtrOutOfBounds { .. }
-            | UninhabitedEnumVariant
-            | PartialPointer => {}
-        }
-    }
-}
-
-impl ReportErrorExt for UnsupportedOpInfo {
-    fn diagnostic_message(&self) -> DiagMessage {
-        match self {
-            UnsupportedOpInfo::Unsupported(s) => s.clone().into(),
-            UnsupportedOpInfo::ExternTypeField => {
-                "`extern type` field does not have a known offset".into()
-            }
-            UnsupportedOpInfo::UnsizedLocal => "unsized locals are not supported".into(),
-            UnsupportedOpInfo::ReadPartialPointer(_) => {
-                msg!("unable to read parts of a pointer from memory at {$ptr}")
-            }
-            UnsupportedOpInfo::ReadPointerAsInt(_) => "unable to turn pointer into integer".into(),
-            UnsupportedOpInfo::ThreadLocalStatic(_) => {
-                msg!("cannot access thread local static `{$did}`")
-            }
-            UnsupportedOpInfo::ExternStatic(_) => {
-                msg!("cannot access extern static `{$did}`")
-            }
-        }
-        .into()
-    }
-
-    fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        use UnsupportedOpInfo::*;
-
-        if let ReadPointerAsInt(_) | ReadPartialPointer(_) = self {
-            diag.help("this code performed an operation that depends on the underlying bytes representing a pointer");
-            diag.help("the absolute address of a pointer is not known at compile-time, so such operations are not supported");
-        }
-        match self {
-            // `ReadPointerAsInt(Some(info))` is never printed anyway, it only serves as an error to
-            // be further processed by validity checking which then turns it into something nice to
-            // print. So it's not worth the effort of having diagnostics that can print the `info`.
-            UnsizedLocal
-            | UnsupportedOpInfo::ExternTypeField
-            | Unsupported(_)
-            | ReadPointerAsInt(_) => {}
-            ReadPartialPointer(ptr) => {
-                diag.arg("ptr", ptr);
-            }
-            ThreadLocalStatic(did) | ExternStatic(did) => rustc_middle::ty::tls::with(|tcx| {
-                diag.arg("did", tcx.def_path_str(did));
-            }),
-        }
-    }
-}
-
-impl<'tcx> ReportErrorExt for InterpErrorKind<'tcx> {
-    fn diagnostic_message(&self) -> DiagMessage {
-        match self {
-            InterpErrorKind::UndefinedBehavior(ub) => ub.diagnostic_message(),
-            InterpErrorKind::Unsupported(e) => e.diagnostic_message(),
-            InterpErrorKind::InvalidProgram(e) => e.diagnostic_message(),
-            InterpErrorKind::ResourceExhaustion(e) => e.diagnostic_message(),
-            InterpErrorKind::MachineStop(e) => e.diagnostic_message(),
-        }
-    }
-    fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        match self {
-            InterpErrorKind::UndefinedBehavior(ub) => ub.add_args(diag),
-            InterpErrorKind::Unsupported(e) => e.add_args(diag),
-            InterpErrorKind::InvalidProgram(e) => e.add_args(diag),
-            InterpErrorKind::ResourceExhaustion(e) => e.add_args(diag),
-            InterpErrorKind::MachineStop(e) => e.add_args(&mut |name, value| {
-                diag.arg(name, value);
-            }),
-        }
-    }
-}
-
-impl<'tcx> ReportErrorExt for InvalidProgramInfo<'tcx> {
-    fn diagnostic_message(&self) -> DiagMessage {
-        match self {
-            InvalidProgramInfo::TooGeneric => "encountered overly generic constant".into(),
-            InvalidProgramInfo::AlreadyReported(_) => {
-                "an error has already been reported elsewhere (this should not usually be printed)"
-                    .into()
-            }
-            InvalidProgramInfo::Layout(e) => e.diagnostic_message(),
-        }
-    }
-    fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        match self {
-            InvalidProgramInfo::TooGeneric | InvalidProgramInfo::AlreadyReported(_) => {}
-            InvalidProgramInfo::Layout(e) => {
-                // The level doesn't matter, `dummy_diag` is consumed without it being used.
-                let dummy_level = Level::Bug;
-                let dummy_diag: Diag<'_, ()> = e.into_diagnostic().into_diag(diag.dcx, dummy_level);
-                for (name, val) in dummy_diag.args.iter() {
-                    diag.arg(name.clone(), val.clone());
-                }
-                dummy_diag.cancel();
-            }
-        }
-    }
-}
-
-impl ReportErrorExt for ResourceExhaustionInfo {
-    fn diagnostic_message(&self) -> DiagMessage {
-        match self {
-            ResourceExhaustionInfo::StackFrameLimitReached => {
-                "reached the configured maximum number of stack frames"
-            }
-            ResourceExhaustionInfo::MemoryExhausted => {
-                "tried to allocate more memory than available to compiler"
-            }
-            ResourceExhaustionInfo::AddressSpaceFull => {
-                "there are no more free addresses in the address space"
-            }
-            ResourceExhaustionInfo::Interrupted => "compilation was interrupted",
-        }
-        .into()
-    }
-    fn add_args<G: EmissionGuarantee>(self, _: &mut Diag<'_, G>) {}
-}
-
 impl rustc_errors::IntoDiagArg for InternKind {
     fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(match self {
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index b207244349d8..0381571ef6da 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -6,7 +6,6 @@
 
 use either::{Left, Right};
 use rustc_abi::{self as abi, ExternAbi, FieldIdx, Integer, VariantIdx};
-use rustc_errors::msg;
 use rustc_hir::def_id::DefId;
 use rustc_hir::find_attr;
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
@@ -19,7 +18,7 @@
 use super::{
     CtfeProvenance, FnVal, ImmTy, InterpCx, InterpResult, MPlaceTy, Machine, OpTy, PlaceTy,
     Projectable, Provenance, ReturnAction, ReturnContinuation, Scalar, interp_ok, throw_ub,
-    throw_ub_custom,
+    throw_ub_format,
 };
 use crate::enter_trace_span;
 use crate::interpret::EnteredTraceSpan;
@@ -293,7 +292,7 @@ fn pass_argument<'x, 'y>(
         }
         // Find next caller arg.
         let Some((caller_arg, caller_abi)) = caller_args.next() else {
-            throw_ub_custom!(msg!("calling a function with fewer arguments than it requires"));
+            throw_ub_format!("calling a function with fewer arguments than it requires");
         };
         assert_eq!(caller_arg.layout().layout, caller_abi.layout.layout);
         // Sadly we cannot assert that `caller_arg.layout().ty` and `caller_abi.layout.ty` are
@@ -364,12 +363,10 @@ pub fn init_stack_frame(
         let callee_fn_abi = self.fn_abi_of_instance_no_deduced_attrs(instance, extra_tys)?;
 
         if caller_fn_abi.conv != callee_fn_abi.conv {
-            throw_ub_custom!(
-                rustc_errors::msg!(
-                    "calling a function with calling convention \"{$callee_conv}\" using calling convention \"{$caller_conv}\""
-                ),
-                callee_conv = format!("{}", callee_fn_abi.conv),
-                caller_conv = format!("{}", caller_fn_abi.conv),
+            throw_ub_format!(
+                "calling a function with calling convention \"{callee_conv}\" using calling convention \"{caller_conv}\"",
+                callee_conv = callee_fn_abi.conv,
+                caller_conv = caller_fn_abi.conv,
             )
         }
 
@@ -544,7 +541,7 @@ pub fn init_stack_frame(
                 "mismatch between callee ABI and callee body arguments"
             );
             if caller_args.next().is_some() {
-                throw_ub_custom!(msg!("calling a function with more arguments than it expected"));
+                throw_ub_format!("calling a function with more arguments than it expected");
             }
             // Don't forget to check the return type!
             if !self.check_argument_compat(&caller_fn_abi.ret, &callee_fn_abi.ret)? {
@@ -744,9 +741,7 @@ pub(super) fn init_fn_call(
                 let vtable_entries = self.vtable_entries(receiver_trait.principal(), dyn_ty);
                 let Some(ty::VtblEntry::Method(fn_inst)) = vtable_entries.get(idx).copied() else {
                     // FIXME(fee1-dead) these could be variants of the UB info enum instead of this
-                    throw_ub_custom!(msg!(
-                        "`dyn` call trying to call something that is not a method"
-                    ));
+                    throw_ub_format!("`dyn` call trying to call something that is not a method");
                 };
                 trace!("Virtual call dispatches to {fn_inst:#?}");
                 // We can also do the lookup based on `def_id` and `dyn_ty`, and check that that
@@ -952,7 +947,7 @@ pub(super) fn return_from_current_stack_frame(
             }
         );
         if unwinding && self.frame_idx() == 0 {
-            throw_ub_custom!(msg!("unwinding past the topmost frame of the stack"));
+            throw_ub_format!("unwinding past the topmost frame of the stack");
         }
 
         // Get out the return value. Must happen *before* the frame is popped as we have to get the
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 6972a79226f3..faef78253428 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -3,7 +3,6 @@
 use rustc_abi::{FieldIdx, Integer};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_apfloat::{Float, FloatConvert};
-use rustc_errors::msg;
 use rustc_middle::mir::CastKind;
 use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
 use rustc_middle::ty::adjustment::PointerCoercion;
@@ -15,7 +14,7 @@
 use super::util::ensure_monomorphic_enough;
 use super::{
     FnVal, ImmTy, Immediate, InterpCx, Machine, OpTy, PlaceTy, err_inval, interp_ok, throw_ub,
-    throw_ub_custom,
+    throw_ub_format,
 };
 use crate::enter_trace_span;
 use crate::interpret::Writeable;
@@ -139,10 +138,8 @@ pub fn cast(
                 assert!(dest.layout.is_sized());
                 assert_eq!(cast_ty, dest.layout.ty); // we otherwise ignore `cast_ty` enirely...
                 if src.layout.size != dest.layout.size {
-                    throw_ub_custom!(
-                        msg!(
-                            "transmuting from {$src_bytes}-byte type to {$dest_bytes}-byte type: `{$src}` -> `{$dest}`"
-                        ),
+                    throw_ub_format!(
+                        "transmuting from {src_bytes}-byte type to {dest_bytes}-byte type: `{src}` -> `{dest}`",
                         src_bytes = src.layout.size.bytes(),
                         dest_bytes = dest.layout.size.bytes(),
                         src = src.layout.ty,
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 956be147d748..0bfe012bfe7a 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -2,7 +2,6 @@
 
 use either::{Left, Right};
 use rustc_abi::{Align, HasDataLayout, Size, TargetDataLayout};
-use rustc_errors::{DiagCtxtHandle, format_diag_message, msg};
 use rustc_hir::def_id::DefId;
 use rustc_hir::limit::Limit;
 use rustc_middle::mir::interpret::{ErrorHandled, InvalidMetaKind, ReportedErrorInfo};
@@ -22,9 +21,9 @@
 use super::{
     Frame, FrameInfo, GlobalId, InterpErrorInfo, InterpErrorKind, InterpResult, MPlaceTy, Machine,
     MemPlaceMeta, Memory, OpTy, Place, PlaceTy, PointerArithmetic, Projectable, Provenance,
-    err_inval, interp_ok, throw_inval, throw_ub, throw_ub_custom,
+    err_inval, interp_ok, throw_inval, throw_ub, throw_ub_format,
 };
-use crate::{ReportErrorExt, enter_trace_span, util};
+use crate::{enter_trace_span, util};
 
 pub struct InterpCx<'tcx, M: Machine<'tcx>> {
     /// Stores the `Machine` instance.
@@ -228,17 +227,10 @@ pub(super) fn from_known_layout<'tcx>(
 ///
 /// This is NOT the preferred way to render an error; use `report` from `const_eval` instead.
 /// However, this is useful when error messages appear in ICEs.
-pub fn format_interp_error<'tcx>(dcx: DiagCtxtHandle<'_>, e: InterpErrorInfo<'tcx>) -> String {
+pub fn format_interp_error<'tcx>(e: InterpErrorInfo<'tcx>) -> String {
     let (e, backtrace) = e.into_parts();
     backtrace.print_backtrace();
-    // FIXME(fee1-dead), HACK: we want to use the error as title therefore we can just extract the
-    // label and arguments from the InterpError.
-    let mut diag = dcx.struct_allow("");
-    let msg = e.diagnostic_message();
-    e.add_args(&mut diag);
-    let msg = format_diag_message(&msg, &diag.args).into_owned();
-    diag.cancel();
-    msg
+    e.to_string()
 }
 
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
@@ -556,9 +548,7 @@ pub fn unwind_to_block(&mut self, target: mir::UnwindAction) -> InterpResult<'tc
             mir::UnwindAction::Cleanup(block) => Left(mir::Location { block, statement_index: 0 }),
             mir::UnwindAction::Continue => Right(self.frame_mut().body.span),
             mir::UnwindAction::Unreachable => {
-                throw_ub_custom!(msg!(
-                    "unwinding past a stack frame that does not allow unwinding"
-                ));
+                throw_ub_format!("unwinding past a stack frame that does not allow unwinding");
             }
             mir::UnwindAction::Terminate(reason) => {
                 self.frame_mut().loc = Right(self.frame_mut().body.span);
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index c9106d691f7c..7f7c69adf4f8 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -8,7 +8,6 @@
 
 use rustc_abi::{FieldIdx, HasDataLayout, Size, VariantIdx};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
-use rustc_errors::msg;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
@@ -21,8 +20,8 @@
 use super::util::ensure_monomorphic_enough;
 use super::{
     AllocId, CheckInAllocMsg, ImmTy, InterpCx, InterpResult, Machine, OpTy, PlaceTy, Pointer,
-    PointerArithmetic, Projectable, Provenance, Scalar, err_ub_custom, err_unsup_format, interp_ok,
-    throw_inval, throw_ub, throw_ub_custom, throw_ub_format, throw_unsup_format,
+    PointerArithmetic, Projectable, Provenance, Scalar, err_ub_format, err_unsup_format, interp_ok,
+    throw_inval, throw_ub, throw_ub_format, throw_unsup_format,
 };
 use crate::interpret::Writeable;
 
@@ -402,10 +401,8 @@ pub fn eval_intrinsic(
                         }
                         _ => {
                             // Not into the same allocation -- this is UB.
-                            throw_ub_custom!(
-                                msg!(
-                                    "`{$name}` called on two different pointers that are not both derived from the same allocation"
-                                ),
+                            throw_ub_format!(
+                                "`{name}` called on two different pointers that are not both derived from the same allocation",
                                 name = intrinsic_name,
                             );
                         }
@@ -425,16 +422,11 @@ pub fn eval_intrinsic(
                     if overflowed.to_bool()? {
                         // a < b
                         if intrinsic_name == sym::ptr_offset_from_unsigned {
-                            throw_ub_custom!(
-                                msg!(
-                                    "`ptr_offset_from_unsigned` called when first pointer has smaller {$is_addr ->
-                                        [true] address
-                                        *[false] offset
-                                    } than second: {$a_offset} < {$b_offset}"
-                                ),
+                            throw_ub_format!(
+                                "`ptr_offset_from_unsigned` called when first pointer has smaller {is_addr} than second: {a_offset} < {b_offset}",
                                 a_offset = a_offset,
                                 b_offset = b_offset,
-                                is_addr = is_addr,
+                                is_addr = if is_addr { "address" } else { "offset" },
                             );
                         }
                         // The signed form of the intrinsic allows this. If we interpret the
@@ -442,11 +434,8 @@ pub fn eval_intrinsic(
                         // seems *positive* or equal to isize::MIN, they were more than isize::MAX apart.
                         let dist = val.to_target_isize(self)?;
                         if dist >= 0 || i128::from(dist) == self.pointer_size().signed_int_min() {
-                            throw_ub_custom!(
-                                msg!(
-                                    "`{$name}` called when first pointer is too far before second"
-                                ),
-                                name = intrinsic_name,
+                            throw_ub_format!(
+                                "`{intrinsic_name}` called when first pointer is too far before second"
                             );
                         }
                         dist
@@ -456,11 +445,8 @@ pub fn eval_intrinsic(
                         // If converting to isize produced a *negative* result, we had an overflow
                         // because they were more than isize::MAX apart.
                         if dist < 0 {
-                            throw_ub_custom!(
-                                msg!(
-                                    "`{$name}` called when first pointer is too far ahead of second"
-                                ),
-                                name = intrinsic_name,
+                            throw_ub_format!(
+                                "`{intrinsic_name}` called when first pointer is too far ahead of second"
                             );
                         }
                         dist
@@ -477,14 +463,12 @@ pub fn eval_intrinsic(
                             && let Ok((b_alloc_id, ..)) = self.ptr_try_get_alloc_id(b, 0)
                             && a_alloc_id == b_alloc_id
                         {
-                            err_ub_custom!(
-                                msg!("`{$name}` called on two different pointers where the memory range between them is not in-bounds of an allocation"),
-                                name = intrinsic_name,
+                            err_ub_format!(
+                                "`{intrinsic_name}` called on two different pointers where the memory range between them is not in-bounds of an allocation"
                             )
                         } else {
-                            err_ub_custom!(
-                                msg!("`{$name}` called on two different pointers that are not both derived from the same allocation"),
-                                name = intrinsic_name,
+                            err_ub_format!(
+                                "`{intrinsic_name}` called on two different pointers that are not both derived from the same allocation"
                             )
                         }
                     })?;
@@ -497,9 +481,8 @@ pub fn eval_intrinsic(
                 )
                 .map_err_kind(|_| {
                     // Make the error more specific.
-                    err_ub_custom!(
-                        msg!("`{$name}` called on two different pointers that are not both derived from the same allocation"),
-                        name = intrinsic_name,
+                    err_ub_format!(
+                        "`{intrinsic_name}` called on two different pointers that are not both derived from the same allocation"
                     )
                 })?;
 
@@ -779,7 +762,7 @@ pub(super) fn eval_nondiverging_intrinsic(
                 let op = self.eval_operand(op, None)?;
                 let cond = self.read_scalar(&op)?.to_bool()?;
                 if !cond {
-                    throw_ub_custom!(msg!("`assume` called with `false`"));
+                    throw_ub_format!("`assume` called with `false`");
                 }
                 interp_ok(())
             }
@@ -809,7 +792,7 @@ pub fn numeric_intrinsic(
         let bits_out = match name {
             sym::ctpop => u128::from(bits.count_ones()),
             sym::ctlz_nonzero | sym::cttz_nonzero if bits == 0 => {
-                throw_ub_custom!(msg!("`{$name}` called on 0"), name = name,);
+                throw_ub_format!("`{name}` called on 0");
             }
             sym::ctlz | sym::ctlz_nonzero => u128::from(bits.leading_zeros()) - extra,
             sym::cttz | sym::cttz_nonzero => u128::from((bits << extra).trailing_zeros()) - extra,
@@ -841,11 +824,7 @@ pub fn exact_div(
         let rem = self.binary_op(BinOp::Rem, a, b)?;
         // sign does not matter for 0 test, so `to_bits` is fine
         if rem.to_scalar().to_bits(a.layout.size)? != 0 {
-            throw_ub_custom!(
-                msg!("exact_div: {$a} cannot be divided by {$b} without remainder"),
-                a = format!("{a}"),
-                b = format!("{b}")
-            )
+            throw_ub_format!("exact_div: {a} cannot be divided by {b} without remainder")
         }
         // `Rem` says this is all right, so we can let `Div` do its job.
         let res = self.binary_op(BinOp::Div, a, b)?;
@@ -926,8 +905,8 @@ pub(crate) fn copy_intrinsic(
         let (size, align) = (layout.size, layout.align.abi);
 
         let size = self.compute_size_in_bytes(size, count).ok_or_else(|| {
-            err_ub_custom!(
-                msg!("overflow computing total size of `{$name}`"),
+            err_ub_format!(
+                "overflow computing total size of `{name}`",
                 name = if nonoverlapping { "copy_nonoverlapping" } else { "copy" }
             )
         })?;
@@ -990,9 +969,9 @@ pub fn write_bytes_intrinsic(
 
         // `checked_mul` enforces a too small bound (the correct one would probably be target_isize_max),
         // but no actual allocation can be big enough for the difference to be noticeable.
-        let len = self.compute_size_in_bytes(layout.size, count).ok_or_else(|| {
-            err_ub_custom!(msg!("overflow computing total size of `{$name}`"), name = name)
-        })?;
+        let len = self
+            .compute_size_in_bytes(layout.size, count)
+            .ok_or_else(|| err_ub_format!("overflow computing total size of `{name}`"))?;
 
         let bytes = std::iter::repeat_n(byte, len.bytes_usize());
         self.write_bytes_ptr(dst, bytes)
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 8a864f372b9c..214d653d23c1 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -14,17 +14,16 @@
 use rustc_abi::{Align, HasDataLayout, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
-use rustc_errors::msg;
+use rustc_middle::bug;
 use rustc_middle::mir::display_allocation;
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
-use rustc_middle::{bug, throw_ub_format};
 use tracing::{debug, instrument, trace};
 
 use super::{
     AllocBytes, AllocId, AllocInit, AllocMap, AllocRange, Allocation, CheckAlignMsg,
     CheckInAllocMsg, CtfeProvenance, GlobalAlloc, InterpCx, InterpResult, MPlaceTy, Machine,
     MayLeak, Misalignment, Pointer, PointerArithmetic, Provenance, Scalar, alloc_range, err_ub,
-    err_ub_custom, interp_ok, throw_ub, throw_ub_custom, throw_unsup, throw_unsup_format,
+    err_ub_format, interp_ok, throw_ub, throw_ub_format, throw_unsup, throw_unsup_format,
 };
 use crate::const_eval::ConstEvalErrKind;
 
@@ -310,16 +309,8 @@ pub fn reallocate_ptr(
     ) -> InterpResult<'tcx, Pointer<M::Provenance>> {
         let (alloc_id, offset, _prov) = self.ptr_get_alloc_id(ptr, 0)?;
         if offset.bytes() != 0 {
-            throw_ub_custom!(
-                msg!(
-                    "{$kind ->
-                        [dealloc] deallocating
-                        [realloc] reallocating
-                        *[other] {\"\"}
-                    } {$ptr} which does not point to the beginning of an object"
-                ),
-                ptr = format!("{ptr:?}"),
-                kind = "realloc"
+            throw_ub_format!(
+                "reallocating {ptr} which does not point to the beginning of an object"
             );
         }
 
@@ -393,19 +384,11 @@ pub fn deallocate_ptr(
         kind: MemoryKind<M::MemoryKind>,
     ) -> InterpResult<'tcx> {
         let (alloc_id, offset, prov) = self.ptr_get_alloc_id(ptr, 0)?;
-        trace!("deallocating: {alloc_id:?}");
+        trace!("deallocating: {alloc_id}");
 
         if offset.bytes() != 0 {
-            throw_ub_custom!(
-                msg!(
-                    "{$kind ->
-                        [dealloc] deallocating
-                        [realloc] reallocating
-                        *[other] {\"\"}
-                    } {$ptr} which does not point to the beginning of an object"
-                ),
-                ptr = format!("{ptr:?}"),
-                kind = "dealloc",
+            throw_ub_format!(
+                "deallocating {ptr} which does not point to the beginning of an object"
             );
         }
 
@@ -413,60 +396,16 @@ pub fn deallocate_ptr(
             // Deallocating global memory -- always an error
             return Err(match self.tcx.try_get_global_alloc(alloc_id) {
                 Some(GlobalAlloc::Function { .. }) => {
-                    err_ub_custom!(
-                        msg!(
-                            "deallocating {$alloc_id}, which is {$kind ->
-                                [fn] a function
-                                [vtable] a vtable
-                                [static_mem] static memory
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        alloc_id = alloc_id,
-                        kind = "fn",
-                    )
+                    err_ub_format!("deallocating {alloc_id}, which is a function")
                 }
                 Some(GlobalAlloc::VTable(..)) => {
-                    err_ub_custom!(
-                        msg!(
-                            "deallocating {$alloc_id}, which is {$kind ->
-                                [fn] a function
-                                [vtable] a vtable
-                                [static_mem] static memory
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        alloc_id = alloc_id,
-                        kind = "vtable",
-                    )
+                    err_ub_format!("deallocating {alloc_id}, which is a vtable")
                 }
                 Some(GlobalAlloc::TypeId { .. }) => {
-                    err_ub_custom!(
-                        msg!(
-                            "deallocating {$alloc_id}, which is {$kind ->
-                                [fn] a function
-                                [vtable] a vtable
-                                [static_mem] static memory
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        alloc_id = alloc_id,
-                        kind = "typeid",
-                    )
+                    err_ub_format!("deallocating {alloc_id}, which is a type id")
                 }
                 Some(GlobalAlloc::Static(..) | GlobalAlloc::Memory(..)) => {
-                    err_ub_custom!(
-                        msg!(
-                            "deallocating {$alloc_id}, which is {$kind ->
-                                [fn] a function
-                                [vtable] a vtable
-                                [static_mem] static memory
-                                *[other] {\"\"}
-                            }"
-                        ),
-                        alloc_id = alloc_id,
-                        kind = "static_mem"
-                    )
+                    err_ub_format!("deallocating {alloc_id}, which is static memory")
                 }
                 None => err_ub!(PointerUseAfterFree(alloc_id, CheckInAllocMsg::MemoryAccess)),
             })
@@ -474,25 +413,17 @@ pub fn deallocate_ptr(
         };
 
         if alloc.mutability.is_not() {
-            throw_ub_custom!(msg!("deallocating immutable allocation {$alloc}"), alloc = alloc_id,);
+            throw_ub_format!("deallocating immutable allocation {alloc_id}");
         }
         if alloc_kind != kind {
-            throw_ub_custom!(
-                msg!(
-                    "deallocating {$alloc}, which is {$alloc_kind} memory, using {$kind} deallocation operation"
-                ),
-                alloc = alloc_id,
-                alloc_kind = format!("{alloc_kind}"),
-                kind = format!("{kind}"),
+            throw_ub_format!(
+                "deallocating {alloc_id}, which is {alloc_kind} memory, using {kind} deallocation operation",
             );
         }
         if let Some((size, align)) = old_size_and_align {
             if size != alloc.size() || align != alloc.align {
-                throw_ub_custom!(
-                    msg!(
-                        "incorrect layout on deallocation: {$alloc} has size {$size} and alignment {$align}, but gave size {$size_found} and alignment {$align_found}"
-                    ),
-                    alloc = alloc_id,
+                throw_ub_format!(
+                    "incorrect layout on deallocation: {alloc_id} has size {size} and alignment {align}, but gave size {size_found} and alignment {align_found}",
                     size = alloc.size().bytes(),
                     align = alloc.align.bytes(),
                     size_found = size.bytes(),
@@ -1653,9 +1584,7 @@ pub fn mem_copy_repeatedly(
                     if (src_offset <= dest_offset && src_offset + size > dest_offset)
                         || (dest_offset <= src_offset && dest_offset + size > src_offset)
                     {
-                        throw_ub_custom!(msg!(
-                            "`copy_nonoverlapping` called on overlapping ranges"
-                        ));
+                        throw_ub_format!("`copy_nonoverlapping` called on overlapping ranges");
                     }
                 }
             }
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 677bbf5d41e6..41a4cb2f23a1 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -5,7 +5,7 @@
 //! to be const-safe.
 
 use std::borrow::Cow;
-use std::fmt::Write;
+use std::fmt::{self, Write};
 use std::hash::Hash;
 use std::mem;
 use std::num::NonZero;
@@ -20,10 +20,9 @@
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_middle::bug;
-use rustc_middle::mir::interpret::ValidationErrorKind::{self, *};
 use rustc_middle::mir::interpret::{
-    ExpectedKind, InterpErrorKind, InvalidMetaKind, Misalignment, PointerKind, Provenance,
-    UnsupportedOpInfo, ValidationErrorInfo, alloc_range, interp_ok,
+    InterpErrorKind, InvalidMetaKind, Misalignment, Provenance, UnsupportedOpInfo, alloc_range,
+    interp_ok,
 };
 use rustc_middle::ty::layout::{LayoutCx, TyAndLayout};
 use rustc_middle::ty::{self, Ty};
@@ -46,7 +45,7 @@
 use super::UnsupportedOpInfo::*;
 
 macro_rules! err_validation_failure {
-    ($where:expr, $kind: expr) => {{
+    ($where:expr,  $msg:expr ) => {{
         let where_ = &$where;
         let path = if !where_.is_empty() {
             let mut path = String::new();
@@ -56,13 +55,20 @@ macro_rules! err_validation_failure {
             None
         };
 
-        err_ub!(ValidationError(ValidationErrorInfo { path, kind: $kind }))
+        #[allow(unused)]
+        use ValidationErrorKind::*;
+        let msg = ValidationErrorKind::from($msg);
+        err_ub!(ValidationError {
+            path,
+            ptr_bytes_warning: msg.ptr_bytes_warning(),
+            msg: msg.to_string(),
+        })
     }};
 }
 
 macro_rules! throw_validation_failure {
-    ($where:expr, $kind: expr) => {
-        do yeet err_validation_failure!($where, $kind)
+    ($where:expr, $msg:expr ) => {
+        do yeet err_validation_failure!($where, $msg)
     };
 }
 
@@ -73,32 +79,15 @@ macro_rules! throw_validation_failure {
 /// can possibly happen:
 ///
 /// ```ignore(illustrative)
-/// let v = try_validation!(some_fn(), some_path, {
-///     Foo | Bar | Baz => { "some failure" },
+/// let v = try_validation!(some_fn(x), some_path, {
+///     Foo | Bar | Baz => format!("some failure involving {x}"),
 /// });
 /// ```
 ///
 /// The patterns must be of type `UndefinedBehaviorInfo`.
-/// An additional expected parameter can also be added to the failure message:
-///
-/// ```ignore(illustrative)
-/// let v = try_validation!(some_fn(), some_path, {
-///     Foo | Bar | Baz => { "some failure" } expected { "something that wasn't a failure" },
-/// });
-/// ```
-///
-/// An additional nicety is that both parameters actually take format args, so you can just write
-/// the format string in directly:
-///
-/// ```ignore(illustrative)
-/// let v = try_validation!(some_fn(), some_path, {
-///     Foo | Bar | Baz => { "{:?}", some_failure } expected { "{}", expected_value },
-/// });
-/// ```
-///
 macro_rules! try_validation {
     ($e:expr, $where:expr,
-    $( $( $p:pat_param )|+ => $kind: expr ),+ $(,)?
+    $( $( $p:pat_param )|+ => $msg:expr ),+ $(,)?
     ) => {{
         $e.map_err_kind(|e| {
             // We catch the error and turn it into a validation failure. We are okay with
@@ -108,7 +97,7 @@ macro_rules! try_validation {
                     $($p)|+ => {
                         err_validation_failure!(
                             $where,
-                            $kind
+                            $msg
                         )
                     }
                 ),+,
@@ -118,6 +107,130 @@ macro_rules! try_validation {
     }};
 }
 
+#[derive(Debug, Clone, Copy)]
+enum PointerKind {
+    Ref(Mutability),
+    Box,
+}
+
+impl fmt::Display for PointerKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let str = match self {
+            PointerKind::Ref(_) => "reference",
+            PointerKind::Box => "box",
+        };
+        write!(f, "{str}")
+    }
+}
+
+#[derive(Debug)]
+enum ExpectedKind {
+    Reference,
+    Box,
+    RawPtr,
+    InitScalar,
+    Bool,
+    Char,
+    Float,
+    Int,
+    FnPtr,
+    Str,
+}
+
+impl fmt::Display for ExpectedKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let str = match self {
+            ExpectedKind::Reference => "expected a reference",
+            ExpectedKind::Box => "expected a box",
+            ExpectedKind::RawPtr => "expected a raw pointer",
+            ExpectedKind::InitScalar => "expected initialized scalar value",
+            ExpectedKind::Bool => "expected a boolean",
+            ExpectedKind::Char => "expected a unicode scalar value",
+            ExpectedKind::Float => "expected a floating point number",
+            ExpectedKind::Int => "expected an integer",
+            ExpectedKind::FnPtr => "expected a function pointer",
+            ExpectedKind::Str => "expected a string",
+        };
+        write!(f, "{str}")
+    }
+}
+
+impl From<PointerKind> for ExpectedKind {
+    fn from(x: PointerKind) -> ExpectedKind {
+        match x {
+            PointerKind::Box => ExpectedKind::Box,
+            PointerKind::Ref(_) => ExpectedKind::Reference,
+        }
+    }
+}
+
+/// Validation errors that can be emitted in one than one place get a variant here so that
+/// we format them consistently. Everything else uses the `String` fallback.
+#[derive(Debug)]
+enum ValidationErrorKind<'tcx> {
+    Uninit {
+        expected: ExpectedKind,
+    },
+    PointerAsInt {
+        expected: ExpectedKind,
+    },
+    PartialPointer,
+    InvalidMetaWrongTrait {
+        /// The vtable that was actually referenced by the wide pointer metadata.
+        vtable_dyn_type: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+        /// The vtable that was expected at the point in MIR that it was accessed.
+        expected_dyn_type: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+    },
+    GeneralError {
+        msg: String,
+    },
+}
+
+impl<'tcx> ValidationErrorKind<'tcx> {
+    // We don't do this via `fmt::Display` to so that we can do a move in the `GeneralError` case.
+    fn to_string(self) -> String {
+        use ValidationErrorKind::*;
+        match self {
+            Uninit { expected } => format!("encountered uninitialized memory, but {expected}"),
+            PointerAsInt { expected } => format!("encountered a pointer, but {expected}"),
+            PartialPointer => format!("encountered a partial pointer or a mix of pointers"),
+            InvalidMetaWrongTrait { vtable_dyn_type, expected_dyn_type } => format!(
+                "wrong trait in wide pointer vtable: expected `{expected_dyn_type}`, but encountered `{vtable_dyn_type}`"
+            ),
+            GeneralError { msg } => msg,
+        }
+    }
+
+    fn ptr_bytes_warning(&self) -> bool {
+        use ValidationErrorKind::*;
+        matches!(self, PointerAsInt { .. } | PartialPointer)
+    }
+}
+
+impl<'tcx> From<String> for ValidationErrorKind<'tcx> {
+    fn from(msg: String) -> Self {
+        ValidationErrorKind::GeneralError { msg }
+    }
+}
+
+fn fmt_range(r: WrappingRange, max_hi: u128) -> String {
+    let WrappingRange { start: lo, end: hi } = r;
+    assert!(hi <= max_hi);
+    if lo > hi {
+        format!("less or equal to {hi}, or greater or equal to {lo}")
+    } else if lo == hi {
+        format!("equal to {lo}")
+    } else if lo == 0 {
+        assert!(hi < max_hi, "should not be printing if the range covers everything");
+        format!("less or equal to {hi}")
+    } else if hi == max_hi {
+        assert!(lo > 0, "should not be printing if the range covers everything");
+        format!("greater or equal to {lo}")
+    } else {
+        format!("in the range {lo}..={hi}")
+    }
+}
+
 /// We want to show a nice path to the invalid field for diagnostics,
 /// but avoid string operations in the happy case where no error happens.
 /// So we track a `Vec<PathElem>` where `PathElem` contains all the data we
@@ -193,7 +306,6 @@ fn track(&mut self, val: T, path: impl FnOnce() -> PATH) {
     }
 }
 
-// FIXME make this translatable as well?
 /// Format a path
 fn write_path(out: &mut String, path: &[PathElem]) {
     use self::PathElem::*;
@@ -459,10 +571,9 @@ fn check_wide_ptr_meta(
                     self.ecx.get_ptr_vtable_ty(vtable, Some(data)),
                     self.path,
                     Ub(DanglingIntPointer{ .. } | InvalidVTablePointer(..)) =>
-                        InvalidVTablePtr { value: format!("{vtable}") },
-                    Ub(InvalidVTableTrait { vtable_dyn_type, expected_dyn_type }) => {
-                        InvalidMetaWrongTrait { vtable_dyn_type, expected_dyn_type }
-                    },
+                        format!("encountered {vtable}, but expected a vtable pointer"),
+                    Ub(InvalidVTableTrait { vtable_dyn_type, expected_dyn_type }) =>
+                        InvalidMetaWrongTrait { expected_dyn_type, vtable_dyn_type },
                 );
             }
             ty::Slice(..) | ty::Str => {
@@ -497,10 +608,13 @@ fn check_safe_pointer(
         let size_and_align = try_validation!(
             self.ecx.size_and_align_of_val(&place),
             self.path,
-            Ub(InvalidMeta(msg)) => match msg {
-                InvalidMetaKind::SliceTooBig => InvalidMetaSliceTooLarge { ptr_kind },
-                InvalidMetaKind::TooBig => InvalidMetaTooLarge { ptr_kind },
-            }
+            Ub(InvalidMeta(msg)) => format!(
+                "encountered invalid {ptr_kind} metadata: {}",
+                match msg {
+                    InvalidMetaKind::SliceTooBig => "slice is bigger than largest supported object",
+                    InvalidMetaKind::TooBig => "total size is bigger than largest supported object",
+                }
+            )
         );
         let (size, align) = size_and_align
             // for the purpose of validity, consider foreign types to have
@@ -508,11 +622,8 @@ fn check_safe_pointer(
             // alignment should take attributes into account).
             .unwrap_or_else(|| (place.layout.size, place.layout.align.abi));
 
+        // If we're not allow to dangle, make sure this is dereferenceable.
         if !self.may_dangle {
-            // Make sure this is dereferenceable and all.
-
-            // Direct call to `check_ptr_access_align` checks alignment even on CTFE machines.
-            // Call `check_ptr_access` to avoid checking alignment here.
             try_validation!(
                 self.ecx.check_ptr_access(
                     place.ptr(),
@@ -520,31 +631,31 @@ fn check_safe_pointer(
                     CheckInAllocMsg::Dereferenceable, // will anyway be replaced by validity message
                 ),
                 self.path,
-                Ub(DanglingIntPointer { addr: 0, .. }) => NullPtr { ptr_kind, maybe: false },
-                Ub(DanglingIntPointer { addr: i, .. }) => DanglingPtrNoProvenance {
-                    ptr_kind,
-                    pointer: format!("{}", Pointer::<Option<AllocId>>::without_provenance(i))
-                },
-                Ub(PointerOutOfBounds { .. }) => DanglingPtrOutOfBounds {
-                    ptr_kind
-                },
-                Ub(PointerUseAfterFree(..)) => DanglingPtrUseAfterFree {
-                    ptr_kind,
-                },
+                Ub(DanglingIntPointer { addr: 0, .. }) =>
+                    format!("encountered a null {ptr_kind}"),
+                Ub(DanglingIntPointer { addr: i, .. }) =>
+                    format!(
+                        "encountered a dangling {ptr_kind} ({ptr} has no provenance)",
+                        ptr = Pointer::<Option<AllocId>>::without_provenance(i)
+                    ),
+                Ub(PointerOutOfBounds { .. }) =>
+                    format!("encountered a dangling {ptr_kind} (going beyond the bounds of its allocation)"),
+                Ub(PointerUseAfterFree(..)) =>
+                    format!("encountered a dangling {ptr_kind} (use-after-free)"),
             );
         }
-
+        // Check alignment after dereferenceable (if both are violated, trigger the error above).
         try_validation!(
             self.ecx.check_ptr_align(
                 place.ptr(),
                 align,
             ),
             self.path,
-            Ub(AlignmentCheckFailed(Misalignment { required, has }, _msg)) => UnalignedPtr {
-                ptr_kind,
-                required_bytes: required.bytes(),
-                found_bytes: has.bytes()
-            },
+            Ub(AlignmentCheckFailed(Misalignment { required, has }, _msg)) => format!(
+                "encountered an unaligned {ptr_kind} (required {required_bytes} byte alignment but found {found_bytes})",
+                required_bytes = required.bytes(),
+                found_bytes = has.bytes()
+            ),
         );
 
         // Make sure this is non-null. This is obviously needed when `may_dangle` is set,
@@ -553,12 +664,21 @@ fn check_safe_pointer(
         let scalar = Scalar::from_maybe_pointer(place.ptr(), self.ecx);
         if self.ecx.scalar_may_be_null(scalar)? {
             let maybe = !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
-            throw_validation_failure!(self.path, NullPtr { ptr_kind, maybe })
+            throw_validation_failure!(
+                self.path,
+                format!(
+                    "encountered a {maybe}null {ptr_kind}",
+                    maybe = if maybe { "maybe-" } else { "" }
+                )
+            )
         }
         // Do not allow references to uninhabited types.
         if place.layout.is_uninhabited() {
             let ty = place.layout.ty;
-            throw_validation_failure!(self.path, PtrToUninhabited { ptr_kind, ty })
+            throw_validation_failure!(
+                self.path,
+                format!("encountered a {ptr_kind} pointing to uninhabited type {ty}")
+            )
         }
         // Recursive checking
         if let Some(ref_tracking) = self.ref_tracking.as_deref_mut() {
@@ -586,7 +706,10 @@ fn check_safe_pointer(
                         // though for zero-sized references this isn't really UB.
                         // A potential future alternative would be to resurrect this as a zero-sized allocation
                         // (which codegen will then compile to an aligned dummy pointer anyway).
-                        throw_validation_failure!(self.path, DanglingPtrUseAfterFree { ptr_kind });
+                        throw_validation_failure!(
+                            self.path,
+                            format!("encountered a dangling {ptr_kind} (use-after-free)")
+                        );
                     };
                     let (size, _align) =
                         global_alloc.size_and_align(*self.ecx.tcx, self.ecx.typing_env);
@@ -649,7 +772,12 @@ fn check_safe_pointer(
                             && alloc_actual_mutbl == Mutability::Not
                         {
                             // This can actually occur with transmutes.
-                            throw_validation_failure!(self.path, MutableRefToImmutable);
+                            throw_validation_failure!(
+                                self.path,
+                                format!(
+                                    "encountered mutable reference or box pointing to read-only memory"
+                                )
+                            );
                         }
                     }
                 }
@@ -692,9 +820,8 @@ fn try_visit_primitive(
                 try_validation!(
                     scalar.to_bool(),
                     self.path,
-                    Ub(InvalidBool(..)) => ValidationErrorKind::InvalidBool {
-                        value: format!("{scalar:x}"),
-                    }
+                    Ub(InvalidBool(..)) =>
+                        format!("encountered {scalar:x}, but expected a boolean"),
                 );
                 if self.reset_provenance_and_padding {
                     self.ecx.clear_provenance(value)?;
@@ -707,9 +834,9 @@ fn try_visit_primitive(
                 try_validation!(
                     scalar.to_char(),
                     self.path,
-                    Ub(InvalidChar(..)) => ValidationErrorKind::InvalidChar {
-                        value: format!("{scalar:x}"),
-                    }
+                    Ub(InvalidChar(..)) =>
+                        format!("encountered {scalar:x}, but expected a valid unicode scalar value \
+                          (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)")
                 );
                 if self.reset_provenance_and_padding {
                     self.ecx.clear_provenance(value)?;
@@ -755,7 +882,7 @@ fn try_visit_primitive(
                         self.ecx.get_ptr_fn(ptr),
                         self.path,
                         Ub(DanglingIntPointer{ .. } | InvalidFunctionPointer(..)) =>
-                            InvalidFnPtr { value: format!("{ptr}") },
+                            format!("encountered {ptr}, but expected a function pointer"),
                     );
                     // FIXME: Check if the signature matches
                 } else {
@@ -764,7 +891,13 @@ fn try_visit_primitive(
                     if self.ecx.scalar_may_be_null(scalar)? {
                         let maybe =
                             !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
-                        throw_validation_failure!(self.path, NullFnPtr { maybe });
+                        throw_validation_failure!(
+                            self.path,
+                            format!(
+                                "encountered a {maybe}null function pointer",
+                                maybe = if maybe { "maybe-" } else { "" }
+                            )
+                        );
                     }
                 }
                 if self.reset_provenance_and_padding {
@@ -777,7 +910,12 @@ fn try_visit_primitive(
                 }
                 interp_ok(true)
             }
-            ty::Never => throw_validation_failure!(self.path, NeverVal),
+            ty::Never => {
+                throw_validation_failure!(
+                    self.path,
+                    format!("encountered a value of the never type `!`")
+                )
+            }
             ty::Foreign(..) | ty::FnDef(..) => {
                 // Nothing to check.
                 interp_ok(true)
@@ -826,7 +964,12 @@ fn visit_scalar(
                 if start == 1 && end == max_value {
                     // Only null is the niche. So make sure the ptr is NOT null.
                     if self.ecx.scalar_may_be_null(scalar)? {
-                        throw_validation_failure!(self.path, NonnullPtrMaybeNull)
+                        throw_validation_failure!(
+                            self.path,
+                            format!(
+                                "encountered a maybe-null pointer, but expected something that is definitely non-zero"
+                            )
+                        )
                     } else {
                         return interp_ok(());
                     }
@@ -834,11 +977,13 @@ fn visit_scalar(
                     // Easy. (This is reachable if `enforce_number_validity` is set.)
                     return interp_ok(());
                 } else {
-                    // Conservatively, we reject, because the pointer *could* have a bad
-                    // value.
+                    // Conservatively, we reject, because the pointer *could* have a bad value.
                     throw_validation_failure!(
                         self.path,
-                        PtrOutOfRange { range: valid_range, max_value }
+                        format!(
+                            "encountered a pointer with unknown absolute address, but expected something that is definitely {in_range}",
+                            in_range = fmt_range(valid_range, max_value)
+                        )
                     )
                 }
             }
@@ -849,7 +994,10 @@ fn visit_scalar(
         } else {
             throw_validation_failure!(
                 self.path,
-                OutOfRange { value: format!("{bits}"), range: valid_range, max_value }
+                format!(
+                    "encountered {bits}, but expected something {in_range}",
+                    in_range = fmt_range(valid_range, max_value)
+                )
             )
         }
     }
@@ -1054,10 +1202,10 @@ fn read_discriminant(
             interp_ok(try_validation!(
                 this.ecx.read_discriminant(val),
                 this.path,
-                Ub(InvalidTag(val)) => InvalidEnumTag {
-                    value: format!("{val:x}"),
-                },
-                Ub(UninhabitedEnumVariantRead(_)) => UninhabitedEnumVariant,
+                Ub(InvalidTag(val)) =>
+                    format!("encountered {val:x}, but expected a valid enum tag"),
+                Ub(UninhabitedEnumVariantRead(_)) =>
+                    format!("encountered an uninhabited enum variant"),
                 // Uninit / bad provenance are not possible since the field was already previously
                 // checked at its integer type.
             ))
@@ -1104,7 +1252,10 @@ fn visit_union(
             let zst = self.ecx.size_and_align_of_val(val)?.is_some_and(|(s, _a)| s.bytes() == 0);
             if !zst && !val.layout.ty.is_freeze(*self.ecx.tcx, self.ecx.typing_env) {
                 if !self.in_mutable_memory(val) {
-                    throw_validation_failure!(self.path, UnsafeCellInImmutable);
+                    throw_validation_failure!(
+                        self.path,
+                        format!("encountered `UnsafeCell` in read-only memory")
+                    );
                 }
             }
         }
@@ -1154,7 +1305,10 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                 && def.is_unsafe_cell()
             {
                 if !self.in_mutable_memory(val) {
-                    throw_validation_failure!(self.path, UnsafeCellInImmutable);
+                    throw_validation_failure!(
+                        self.path,
+                        format!("encountered `UnsafeCell` in read-only memory")
+                    );
                 }
             }
         }
@@ -1164,11 +1318,14 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
             ty::Str => {
                 let mplace = val.assert_mem_place(); // strings are unsized and hence never immediate
                 let len = mplace.len(self.ecx)?;
+                let expected = ExpectedKind::Str;
                 try_validation!(
                     self.ecx.read_bytes_ptr_strip_provenance(mplace.ptr(), Size::from_bytes(len)),
                     self.path,
-                    Ub(InvalidUninitBytes(..)) => Uninit { expected: ExpectedKind::Str },
-                    Unsup(ReadPointerAsInt(_)) => PointerAsInt { expected: ExpectedKind::Str }
+                    Ub(InvalidUninitBytes(..)) =>
+                        Uninit { expected },
+                    Unsup(ReadPointerAsInt(_)) =>
+                        PointerAsInt { expected },
                 );
             }
             ty::Array(tys, ..) | ty::Slice(tys)
@@ -1199,7 +1356,10 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                     Left(mplace) => mplace,
                     Right(imm) => match *imm {
                         Immediate::Uninit =>
-                            throw_validation_failure!(self.path, Uninit { expected }),
+                            throw_validation_failure!(
+                                self.path,
+                                Uninit { expected }
+                            ),
                         Immediate::Scalar(..) | Immediate::ScalarPair(..) =>
                             bug!("arrays/slices can never have Scalar/ScalarPair layout"),
                     }
@@ -1229,7 +1389,7 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                             if matches!(kind, Ub(InvalidUninitBytes(_))) {
                                 err_validation_failure!(self.path, Uninit { expected })
                             } else {
-                                err_validation_failure!(self.path, PointerAsInt { expected })
+                                err_validation_failure!(self.path, PointerAsInt {expected})
                             }
                         }
 
@@ -1292,9 +1452,8 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                     self.path,
                     // It's not great to catch errors here, since we can't give a very good path,
                     // but it's better than ICEing.
-                    Ub(InvalidVTableTrait { vtable_dyn_type, expected_dyn_type }) => {
-                        InvalidMetaWrongTrait { vtable_dyn_type, expected_dyn_type }
-                    },
+                    Ub(InvalidVTableTrait { vtable_dyn_type, expected_dyn_type }) =>
+                        InvalidMetaWrongTrait { expected_dyn_type, vtable_dyn_type },
                 );
             }
         }
@@ -1310,7 +1469,10 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
         // MyNewtype and then the scalar in there).
         if val.layout.is_uninhabited() {
             let ty = val.layout.ty;
-            throw_validation_failure!(self.path, UninhabitedVal { ty });
+            throw_validation_failure!(
+                self.path,
+                format!("encountered a value of uninhabited type `{ty}`")
+            );
         }
         match val.layout.backend_repr {
             BackendRepr::Scalar(scalar_layout) => {
@@ -1383,10 +1545,7 @@ fn validate_operand_internal(
                     | InterpErrorKind::InvalidProgram(_)
                     | InterpErrorKind::Unsupported(UnsupportedOpInfo::ExternTypeField)
             ) {
-                bug!(
-                    "Unexpected error during validation: {}",
-                    format_interp_error(self.tcx.dcx(), err)
-                );
+                bug!("Unexpected error during validation: {}", format_interp_error(err));
             }
             err
         })
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index ade6f1c09475..a9fff6d59326 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -22,8 +22,6 @@
 use rustc_middle::ty;
 use rustc_middle::util::Providers;
 
-pub use self::errors::ReportErrorExt;
-
 pub fn provide(providers: &mut Providers) {
     const_eval::provide(&mut providers.queries);
     providers.queries.tag_for_variant = const_eval::tag_for_variant_provider;
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index 384d7858366d..00835a3cc990 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -2,6 +2,7 @@
 use rustc_middle::ty::layout::{
     HasTyCtxt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, ValidityRequirement,
 };
+use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{PseudoCanonicalInput, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, ty};
 use rustc_span::DUMMY_SP;
@@ -70,13 +71,19 @@ fn check_validity_requirement_strict<'tcx>(
     // due to this.
     // The value we are validating is temporary and discarded at the end of this function, so
     // there is no point in resetting provenance and padding.
-    cx.validate_operand(
-        &allocated.into(),
-        /*recursive*/ false,
-        /*reset_provenance_and_padding*/ false,
+    // This is pretty inefficient: we do the full path tracking and even format an error message
+    // in case there is a problem, only to entirely throw that away again. For a nightly-only
+    // option this is fine, but if this is ever meant to be stable we should probably add
+    // a "fast mode" to validation.
+    with_no_trimmed_paths!(
+        cx.validate_operand(
+            &allocated.into(),
+            /*recursive*/ false,
+            /*reset_provenance_and_padding*/ false,
+        )
+        .discard_err()
+        .is_some()
     )
-    .discard_err()
-    .is_some()
 }
 
 /// Implements the 'lax' (default) version of the [`check_validity_requirement`] checks; see that
diff --git a/compiler/rustc_errors/src/diagnostic_impls.rs b/compiler/rustc_errors/src/diagnostic_impls.rs
index 42c605d34814..e50cbbbf06e0 100644
--- a/compiler/rustc_errors/src/diagnostic_impls.rs
+++ b/compiler/rustc_errors/src/diagnostic_impls.rs
@@ -59,15 +59,10 @@ fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
             }
             TargetDataLayoutErrors::InvalidAlignment { cause, err } => {
                 Diag::new(dcx, level, msg!(
-                    "invalid alignment for `{$cause}` in \"data-layout\": `{$align}` is {$err_kind ->
-                        [not_power_of_two] not a power of 2
-                        [too_large] too large
-                        *[other] {\"\"}
-                    }"
+                    "invalid alignment for `{$cause}` in \"data-layout\": {$err}"
                 ))
                 .with_arg("cause", cause)
-                .with_arg("err_kind", err.diag_ident())
-                .with_arg("align", err.align())
+                .with_arg("err", err.to_string())
             }
             TargetDataLayoutErrors::InconsistentTargetArchitecture { dl, target } => {
                 Diag::new(dcx, level, msg!(
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index 7fa818ba7d3a..c0dfc18689ba 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -341,13 +341,13 @@ pub fn to_interp_error<'tcx>(self, alloc_id: AllocId) -> InterpErrorKind<'tcx> {
 }
 
 /// The information that makes up a memory access: offset and size.
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct AllocRange {
     pub start: Size,
     pub size: Size,
 }
 
-impl fmt::Debug for AllocRange {
+impl fmt::Display for AllocRange {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "[{:#x}..{:#x}]", self.start.bytes(), self.end().bytes())
     }
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 035ffd362a6b..2c3d114a0f25 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -4,9 +4,9 @@
 use std::{convert, fmt, mem, ops};
 
 use either::Either;
-use rustc_abi::{Align, Size, VariantIdx, WrappingRange};
+use rustc_abi::{Align, Size, VariantIdx};
 use rustc_data_structures::sync::Lock;
-use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, ErrorGuaranteed, IntoDiagArg};
+use rustc_errors::{DiagArgValue, ErrorGuaranteed, IntoDiagArg};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_session::CtfeBacktrace;
 use rustc_span::def_id::DefId;
@@ -14,8 +14,9 @@
 
 use super::{AllocId, AllocRange, ConstAllocation, Pointer, Scalar};
 use crate::error;
+use crate::mir::interpret::CtfeProvenance;
 use crate::mir::{ConstAlloc, ConstValue};
-use crate::ty::{self, Mutability, Ty, TyCtxt, ValTree, layout, tls};
+use crate::ty::{self, Ty, TyCtxt, ValTree, layout, tls};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
 pub enum ErrorHandled {
@@ -240,20 +241,6 @@ fn from(kind: InterpErrorKind<'tcx>) -> Self {
     }
 }
 
-/// Error information for when the program we executed turned out not to actually be a valid
-/// program. This cannot happen in stand-alone Miri (except for layout errors that are only detect
-/// during monomorphization), but it can happen during CTFE/ConstProp where we work on generic code
-/// or execution does not have all information available.
-#[derive(Debug)]
-pub enum InvalidProgramInfo<'tcx> {
-    /// Resolution can fail if we are in a too generic context.
-    TooGeneric,
-    /// Abort in case errors are already reported.
-    AlreadyReported(ReportedErrorInfo),
-    /// An error occurred during layout computation.
-    Layout(layout::LayoutError<'tcx>),
-}
-
 /// Details of why a pointer had to be in-bounds.
 #[derive(Debug, Copy, Clone)]
 pub enum CheckInAllocMsg {
@@ -265,6 +252,17 @@ pub enum CheckInAllocMsg {
     Dereferenceable,
 }
 
+impl fmt::Display for CheckInAllocMsg {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CheckInAllocMsg::*;
+        match self {
+            MemoryAccess => write!(f, "memory access failed"),
+            InboundsPointerArithmetic => write!(f, "in-bounds pointer arithmetic failed"),
+            Dereferenceable => write!(f, "pointer not dereferenceable"),
+        }
+    }
+}
+
 /// Details of which pointer is not aligned.
 #[derive(Debug, Copy, Clone)]
 pub enum CheckAlignMsg {
@@ -314,34 +312,13 @@ pub struct Misalignment {
     pub required: Align,
 }
 
-macro_rules! impl_into_diag_arg_through_debug {
-    ($($ty:ty),*$(,)?) => {$(
-        impl IntoDiagArg for $ty {
-            fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-                DiagArgValue::Str(Cow::Owned(format!("{self:?}")))
-            }
-        }
-    )*}
-}
-
-// These types have nice `Debug` output so we can just use them in diagnostics.
-impl_into_diag_arg_through_debug! {
-    AllocId,
-    Pointer<AllocId>,
-    AllocRange,
-}
-
 /// Error information for when the program caused Undefined Behavior.
 #[derive(Debug)]
 pub enum UndefinedBehaviorInfo<'tcx> {
     /// Free-form case. Only for errors that are never caught! Used by miri
     Ub(String),
-    // FIXME(fee1-dead) these should all be actual variants of the enum instead of dynamically
-    // dispatched
-    /// A custom (free-form) fluent-translated error, created by `err_ub_custom!`.
-    Custom(crate::error::CustomSubdiagnostic<'tcx>),
     /// Validation error.
-    ValidationError(ValidationErrorInfo<'tcx>),
+    ValidationError { path: Option<String>, msg: String, ptr_bytes_warning: bool },
 
     /// Unreachable code was executed.
     Unreachable,
@@ -446,135 +423,257 @@ pub enum UndefinedBehaviorInfo<'tcx> {
     CVariadicFixedCountMismatch { caller: u32, callee: u32 },
 }
 
-#[derive(Debug, Clone, Copy)]
-pub enum PointerKind {
-    Ref(Mutability),
-    Box,
-}
+impl<'tcx> fmt::Display for UndefinedBehaviorInfo<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use UndefinedBehaviorInfo::*;
 
-impl IntoDiagArg for PointerKind {
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-        DiagArgValue::Str(
-            match self {
-                Self::Ref(_) => "ref",
-                Self::Box => "box",
+        fn fmt_in_alloc_attempt(
+            f: &mut fmt::Formatter<'_>,
+            msg: CheckInAllocMsg,
+            inbounds_size: i64,
+        ) -> fmt::Result {
+            let inbounds_size_fmt = if inbounds_size == 1 {
+                format_args!("1 byte")
+            } else {
+                format_args!("{inbounds_size} bytes")
+            };
+            write!(f, "{msg}: ")?;
+            match msg {
+                CheckInAllocMsg::MemoryAccess => {
+                    write!(f, "attempting to access {inbounds_size_fmt}")
+                }
+                CheckInAllocMsg::InboundsPointerArithmetic => {
+                    write!(f, "attempting to offset pointer by {inbounds_size_fmt}")
+                }
+                CheckInAllocMsg::Dereferenceable if inbounds_size == 0 => {
+                    write!(f, "pointer must point to some allocation")
+                }
+                CheckInAllocMsg::Dereferenceable => {
+                    write!(f, "pointer must be dereferenceable for {inbounds_size_fmt}")
+                }
             }
-            .into(),
-        )
-    }
-}
+        }
 
-#[derive(Debug)]
-pub struct ValidationErrorInfo<'tcx> {
-    pub path: Option<String>,
-    pub kind: ValidationErrorKind<'tcx>,
-}
+        match self {
+            Ub(msg) => write!(f, "{msg}"),
 
-#[derive(Debug)]
-pub enum ExpectedKind {
-    Reference,
-    Box,
-    RawPtr,
-    InitScalar,
-    Bool,
-    Char,
-    Float,
-    Int,
-    FnPtr,
-    EnumTag,
-    Str,
-}
+            ValidationError { path: None, msg, .. } => {
+                write!(f, "constructing invalid value: {msg}")
+            }
+            ValidationError { path: Some(path), msg, .. } => {
+                write!(f, "constructing invalid value at {path}: {msg}")
+            }
 
-impl From<PointerKind> for ExpectedKind {
-    fn from(x: PointerKind) -> ExpectedKind {
-        match x {
-            PointerKind::Box => ExpectedKind::Box,
-            PointerKind::Ref(_) => ExpectedKind::Reference,
+            Unreachable => write!(f, "entering unreachable code"),
+            BoundsCheckFailed { len, index } => {
+                write!(f, "indexing out of bounds: the len is {len} but the index is {index}")
+            }
+            DivisionByZero => write!(f, "dividing by zero"),
+            RemainderByZero => write!(f, "calculating the remainder with a divisor of zero"),
+            DivisionOverflow => write!(f, "overflow in signed division (dividing MIN by -1)"),
+            RemainderOverflow => write!(f, "overflow in signed remainder (dividing MIN by -1)"),
+            PointerArithOverflow => write!(
+                f,
+                "overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`"
+            ),
+            ArithOverflow { intrinsic } => write!(f, "arithmetic overflow in `{intrinsic}`"),
+            ShiftOverflow { shift_amount, intrinsic } => {
+                write!(f, "overflowing shift by {shift_amount} in `{intrinsic}`")
+            }
+            InvalidMeta(InvalidMetaKind::SliceTooBig) => write!(
+                f,
+                "invalid metadata in wide pointer: slice is bigger than largest supported object"
+            ),
+            InvalidMeta(InvalidMetaKind::TooBig) => write!(
+                f,
+                "invalid metadata in wide pointer: total size is bigger than largest supported object"
+            ),
+            UnterminatedCString(ptr) => write!(
+                f,
+                "reading a null-terminated string starting at {ptr} with no null found before end of allocation"
+            ),
+            PointerUseAfterFree(alloc_id, msg) => {
+                write!(f, "{msg}: {alloc_id} has been freed, so this pointer is dangling")
+            }
+            &PointerOutOfBounds { alloc_id, alloc_size, ptr_offset, inbounds_size, msg } => {
+                fmt_in_alloc_attempt(f, msg, inbounds_size)?;
+                write!(f, ", but got ")?;
+                // Write pointer. Offset might be negative so we cannot use the normal `impl Display
+                // for Pointer`.
+                write!(f, "{}", alloc_id)?;
+                if ptr_offset > 0 {
+                    write!(f, "+{:#x}", ptr_offset)?;
+                } else if ptr_offset < 0 {
+                    write!(f, "-{:#x}", ptr_offset.unsigned_abs())?;
+                }
+                // Write why it is invalid.
+                write!(f, " which ")?;
+                if ptr_offset < 0 {
+                    write!(f, "points to before the beginning of the allocation")
+                } else if inbounds_size < 0 {
+                    // We expected the ptr to have memory to its left, but it does not.
+                    if ptr_offset == 0 {
+                        write!(f, "is at the beginning of the allocation")
+                    } else {
+                        write!(f, "is only {ptr_offset} bytes from the beginning of the allocation")
+                    }
+                } else {
+                    let ptr_offset = ptr_offset as u64;
+                    let alloc_size = alloc_size.bytes();
+                    if ptr_offset >= alloc_size {
+                        let size = if alloc_size == 1 {
+                            format_args!("1 byte")
+                        } else {
+                            format_args!("{alloc_size} bytes")
+                        };
+                        write!(f, "is at or beyond the end of the allocation of size {size}",)
+                    } else {
+                        let dist_to_end = alloc_size - ptr_offset;
+                        let dist = if dist_to_end == 1 {
+                            format_args!("1 byte")
+                        } else {
+                            format_args!("{dist_to_end} bytes")
+                        };
+                        write!(f, "is only {dist} from the end of the allocation",)
+                    }
+                }
+            }
+            &DanglingIntPointer { addr: 0, inbounds_size, msg } => {
+                fmt_in_alloc_attempt(f, msg, inbounds_size)?;
+                write!(f, ", but got null pointer")
+            }
+            &DanglingIntPointer { addr, inbounds_size, msg } => {
+                fmt_in_alloc_attempt(f, msg, inbounds_size)?;
+                write!(
+                    f,
+                    ", but got {ptr} which is a dangling pointer (it has no provenance)",
+                    ptr = Pointer::<Option<CtfeProvenance>>::without_provenance(addr),
+                )
+            }
+            AlignmentCheckFailed(misalign, msg) => {
+                write!(
+                    f,
+                    "{acc} with alignment {has}, but alignment {required} is required",
+                    acc = match msg {
+                        CheckAlignMsg::AccessedPtr => "accessing memory",
+                        CheckAlignMsg::BasedOn => "accessing memory based on pointer",
+                    },
+                    has = misalign.has.bytes(),
+                    required = misalign.required.bytes(),
+                )
+            }
+            WriteToReadOnly(alloc) => write!(f, "writing to {alloc} which is read-only"),
+            DerefFunctionPointer(alloc) => {
+                write!(f, "accessing {alloc} which contains a function")
+            }
+            DerefVTablePointer(alloc) => write!(f, "accessing {alloc} which contains a vtable"),
+            DerefVaListPointer(alloc) => {
+                write!(f, "accessing {alloc} which contains a variable argument list")
+            }
+            DerefTypeIdPointer(alloc) => write!(f, "accessing {alloc} which contains a `TypeId`"),
+            InvalidBool(value) => {
+                write!(f, "interpreting an invalid 8-bit value as a bool: 0x{value:02x}")
+            }
+            InvalidChar(value) => {
+                write!(f, "interpreting an invalid 32-bit value as a char: 0x{value:08x}")
+            }
+            InvalidTag(tag) => write!(f, "enum value has invalid tag: {tag:x}"),
+            InvalidFunctionPointer(ptr) => {
+                write!(f, "using {ptr} as function pointer but it does not point to a function")
+            }
+            InvalidVaListPointer(ptr) => write!(
+                f,
+                "using {ptr} as variable argument list pointer but it does not point to a variable argument list"
+            ),
+            InvalidVTablePointer(ptr) => {
+                write!(f, "using {ptr} as vtable pointer but it does not point to a vtable")
+            }
+            InvalidVTableTrait { vtable_dyn_type, expected_dyn_type } => write!(
+                f,
+                "using vtable for `{vtable_dyn_type}` but `{expected_dyn_type}` was expected"
+            ),
+            InvalidStr(err) => write!(f, "this string is not valid UTF-8: {err}"),
+            InvalidUninitBytes(None) => {
+                write!(
+                    f,
+                    "using uninitialized data, but this operation requires initialized memory"
+                )
+            }
+            InvalidUninitBytes(Some((alloc, info))) => write!(
+                f,
+                "reading memory at {alloc}{access}, but memory is uninitialized at {uninit}, and this operation requires initialized memory",
+                access = info.access,
+                uninit = info.bad,
+            ),
+            DeadLocal => write!(f, "accessing a dead local variable"),
+            ScalarSizeMismatch(mismatch) => write!(
+                f,
+                "scalar size mismatch: expected {target_size} bytes but got {data_size} bytes instead",
+                target_size = mismatch.target_size,
+                data_size = mismatch.data_size,
+            ),
+            UninhabitedEnumVariantWritten(_) => {
+                write!(f, "writing discriminant of an uninhabited enum variant")
+            }
+            UninhabitedEnumVariantRead(_) => {
+                write!(f, "read discriminant of an uninhabited enum variant")
+            }
+            InvalidNichedEnumVariantWritten { enum_ty } => {
+                write!(
+                    f,
+                    "trying to set discriminant of a {enum_ty} to the niched variant, but the value does not match"
+                )
+            }
+            AbiMismatchArgument { arg_idx, caller_ty, callee_ty } => write!(
+                f,
+                "calling a function whose parameter #{arg_idx} has type {callee_ty} passing argument of type {caller_ty}",
+                arg_idx = arg_idx + 1, // adjust for 1-indexed lists in output
+            ),
+            AbiMismatchReturn { caller_ty, callee_ty } => write!(
+                f,
+                "calling a function with return type {callee_ty} passing return place of type {caller_ty}"
+            ),
+            VaArgOutOfBounds => write!(f, "more C-variadic arguments read than were passed"),
+            CVariadicMismatch { .. } => write!(
+                f,
+                "calling a function where the caller and callee disagree on whether the function is C-variadic"
+            ),
+            CVariadicFixedCountMismatch { caller, callee } => write!(
+                f,
+                "calling a C-variadic function with {caller} fixed arguments, but the function expects {callee}"
+            ),
         }
     }
 }
 
+/// Error information for when the program we executed turned out not to actually be a valid
+/// program. This cannot happen in stand-alone Miri (except for layout errors that are only detect
+/// during monomorphization), but it can happen during CTFE/ConstProp where we work on generic code
+/// or execution does not have all information available.
 #[derive(Debug)]
-pub enum ValidationErrorKind<'tcx> {
-    PointerAsInt {
-        expected: ExpectedKind,
-    },
-    PartialPointer,
-    PtrToUninhabited {
-        ptr_kind: PointerKind,
-        ty: Ty<'tcx>,
-    },
-    MutableRefToImmutable,
-    UnsafeCellInImmutable,
-    NullFnPtr {
-        /// Records whether this pointer is definitely null or just may be null.
-        maybe: bool,
-    },
-    NeverVal,
-    NonnullPtrMaybeNull,
-    PtrOutOfRange {
-        range: WrappingRange,
-        max_value: u128,
-    },
-    OutOfRange {
-        value: String,
-        range: WrappingRange,
-        max_value: u128,
-    },
-    UninhabitedVal {
-        ty: Ty<'tcx>,
-    },
-    InvalidEnumTag {
-        value: String,
-    },
-    UninhabitedEnumVariant,
-    Uninit {
-        expected: ExpectedKind,
-    },
-    InvalidVTablePtr {
-        value: String,
-    },
-    InvalidMetaWrongTrait {
-        /// The vtable that was actually referenced by the wide pointer metadata.
-        vtable_dyn_type: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
-        /// The vtable that was expected at the point in MIR that it was accessed.
-        expected_dyn_type: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
-    },
-    InvalidMetaSliceTooLarge {
-        ptr_kind: PointerKind,
-    },
-    InvalidMetaTooLarge {
-        ptr_kind: PointerKind,
-    },
-    UnalignedPtr {
-        ptr_kind: PointerKind,
-        required_bytes: u64,
-        found_bytes: u64,
-    },
-    NullPtr {
-        ptr_kind: PointerKind,
-        /// Records whether this pointer is definitely null or just may be null.
-        maybe: bool,
-    },
-    DanglingPtrNoProvenance {
-        ptr_kind: PointerKind,
-        pointer: String,
-    },
-    DanglingPtrOutOfBounds {
-        ptr_kind: PointerKind,
-    },
-    DanglingPtrUseAfterFree {
-        ptr_kind: PointerKind,
-    },
-    InvalidBool {
-        value: String,
-    },
-    InvalidChar {
-        value: String,
-    },
-    InvalidFnPtr {
-        value: String,
-    },
+pub enum InvalidProgramInfo<'tcx> {
+    /// Resolution can fail if we are in a too generic context.
+    TooGeneric,
+    /// Abort in case errors are already reported.
+    AlreadyReported(ReportedErrorInfo),
+    /// An error occurred during layout computation.
+    Layout(layout::LayoutError<'tcx>),
+}
+
+impl<'tcx> fmt::Display for InvalidProgramInfo<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use InvalidProgramInfo::*;
+        match self {
+            TooGeneric => write!(f, "encountered overly generic constant"),
+            AlreadyReported(_) => {
+                write!(
+                    f,
+                    "an error has already been reported elsewhere (this should not usually be printed)"
+                )
+            }
+            Layout(e) => write!(f, "{e}"),
+        }
+    }
 }
 
 /// Error information for when the program did something that might (or might not) be correct
@@ -604,6 +703,37 @@ pub enum UnsupportedOpInfo {
     ExternStatic(DefId),
 }
 
+impl fmt::Display for UnsupportedOpInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use UnsupportedOpInfo::*;
+        match self {
+            Unsupported(s) => write!(f, "{s}"),
+            ExternTypeField => {
+                write!(f, "`extern type` field does not have a known offset")
+            }
+            UnsizedLocal => write!(f, "unsized locals are not supported"),
+            ReadPartialPointer(ptr) => {
+                write!(f, "unable to read parts of a pointer from memory at {ptr}")
+            }
+            ReadPointerAsInt(_) => write!(f, "unable to turn pointer into integer"),
+            &ThreadLocalStatic(did) => {
+                write!(
+                    f,
+                    "cannot access thread local static `{did}`",
+                    did = ty::tls::with(|tcx| tcx.def_path_str(did))
+                )
+            }
+            &ExternStatic(did) => {
+                write!(
+                    f,
+                    "cannot access extern static `{did}`",
+                    did = ty::tls::with(|tcx| tcx.def_path_str(did))
+                )
+            }
+        }
+    }
+}
+
 /// Error information for when the program exhausted the resources granted to it
 /// by the interpreter.
 #[derive(Debug)]
@@ -618,15 +748,27 @@ pub enum ResourceExhaustionInfo {
     Interrupted,
 }
 
-/// A trait for machine-specific errors (or other "machine stop" conditions).
-pub trait MachineStopType: Any + fmt::Debug + Send {
-    /// The diagnostic message for this error
-    fn diagnostic_message(&self) -> DiagMessage;
-    /// Add diagnostic arguments by passing name and value pairs to `adder`, which are passed to
-    /// fluent for formatting the translated diagnostic message.
-    fn add_args(self: Box<Self>, adder: &mut dyn FnMut(DiagArgName, DiagArgValue));
+impl fmt::Display for ResourceExhaustionInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use ResourceExhaustionInfo::*;
+        match self {
+            StackFrameLimitReached => {
+                write!(f, "reached the configured maximum number of stack frames")
+            }
+            MemoryExhausted => {
+                write!(f, "tried to allocate more memory than available to compiler")
+            }
+            AddressSpaceFull => {
+                write!(f, "there are no more free addresses in the address space")
+            }
+            Interrupted => write!(f, "compilation was interrupted"),
+        }
+    }
 }
 
+/// A trait for machine-specific errors (or other "machine stop" conditions).
+pub trait MachineStopType: Any + fmt::Display + fmt::Debug + Send {}
+
 impl dyn MachineStopType {
     #[inline(always)]
     pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
@@ -639,11 +781,11 @@ pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
 pub enum InterpErrorKind<'tcx> {
     /// The program caused undefined behavior.
     UndefinedBehavior(UndefinedBehaviorInfo<'tcx>),
+    /// The program was invalid (ill-typed, bad MIR, not sufficiently monomorphized, ...).
+    InvalidProgram(InvalidProgramInfo<'tcx>),
     /// The program did something the interpreter does not support (some of these *might* be UB
     /// but the interpreter is not sure).
     Unsupported(UnsupportedOpInfo),
-    /// The program was invalid (ill-typed, bad MIR, not sufficiently monomorphized, ...).
-    InvalidProgram(InvalidProgramInfo<'tcx>),
     /// The program exhausted the interpreter's resources (stack/heap too big,
     /// execution takes too long, ...).
     ResourceExhaustion(ResourceExhaustionInfo),
@@ -652,6 +794,19 @@ pub enum InterpErrorKind<'tcx> {
     MachineStop(Box<dyn MachineStopType>),
 }
 
+impl<'tcx> fmt::Display for InterpErrorKind<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use InterpErrorKind::*;
+        match self {
+            Unsupported(msg) => write!(f, "{msg}"),
+            InvalidProgram(msg) => write!(f, "{msg}"),
+            UndefinedBehavior(msg) => write!(f, "{msg}"),
+            ResourceExhaustion(msg) => write!(f, "{msg}"),
+            MachineStop(msg) => write!(f, "{msg}"),
+        }
+    }
+}
+
 impl InterpErrorKind<'_> {
     /// Some errors do string formatting even if the error is never printed.
     /// To avoid performance issues, there are places where we want to be sure to never raise these formatting errors,
@@ -704,25 +859,6 @@ macro_rules! err_ub_format {
     ($($tt:tt)*) => { $crate::err_ub!(Ub(format!($($tt)*))) };
 }
 
-#[macro_export]
-macro_rules! err_ub_custom {
-    ($msg:expr $(, $($name:ident = $value:expr),* $(,)?)?) => {{
-        $(
-            let ($($name,)*) = ($($value,)*);
-        )?
-        $crate::err_ub!(Custom(
-            $crate::error::CustomSubdiagnostic {
-                msg: || $msg,
-                add_args: Box::new(move |mut set_arg| {
-                    $($(
-                        set_arg(stringify!($name).into(), rustc_errors::IntoDiagArg::into_diag_arg($name, &mut None));
-                    )*)?
-                })
-            }
-        ))
-    }};
-}
-
 #[macro_export]
 macro_rules! err_exhaust {
     ($($tt:tt)*) => {
@@ -765,11 +901,6 @@ macro_rules! throw_ub_format {
     ($($tt:tt)*) => { do yeet $crate::err_ub_format!($($tt)*) };
 }
 
-#[macro_export]
-macro_rules! throw_ub_custom {
-    ($($tt:tt)*) => { do yeet $crate::err_ub_custom!($($tt)*) };
-}
-
 #[macro_export]
 macro_rules! throw_exhaust {
     ($($tt:tt)*) => { do yeet $crate::err_exhaust!($($tt)*) };
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
index 654404f9790c..b3ec4439e354 100644
--- a/compiler/rustc_middle/src/mir/interpret/mod.rs
+++ b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -24,9 +24,9 @@
 use tracing::{debug, trace};
 // Also make the error macros available from this module.
 pub use {
-    err_exhaust, err_inval, err_machine_stop, err_ub, err_ub_custom, err_ub_format, err_unsup,
-    err_unsup_format, throw_exhaust, throw_inval, throw_machine_stop, throw_ub, throw_ub_custom,
-    throw_ub_format, throw_unsup, throw_unsup_format,
+    err_exhaust, err_inval, err_machine_stop, err_ub, err_ub_format, err_unsup, err_unsup_format,
+    throw_exhaust, throw_inval, throw_machine_stop, throw_ub, throw_ub_format, throw_unsup,
+    throw_unsup_format,
 };
 
 pub use self::allocation::{
@@ -35,11 +35,10 @@
 };
 pub use self::error::{
     BadBytesAccess, CheckAlignMsg, CheckInAllocMsg, ErrorHandled, EvalStaticInitializerRawResult,
-    EvalToAllocationRawResult, EvalToConstValueResult, EvalToValTreeResult, ExpectedKind,
-    InterpErrorInfo, InterpErrorKind, InterpResult, InvalidMetaKind, InvalidProgramInfo,
-    MachineStopType, Misalignment, PointerKind, ReportedErrorInfo, ResourceExhaustionInfo,
-    ScalarSizeMismatch, UndefinedBehaviorInfo, UnsupportedOpInfo, ValTreeCreationError,
-    ValidationErrorInfo, ValidationErrorKind, interp_ok,
+    EvalToAllocationRawResult, EvalToConstValueResult, EvalToValTreeResult, InterpErrorInfo,
+    InterpErrorKind, InterpResult, InvalidMetaKind, InvalidProgramInfo, MachineStopType,
+    Misalignment, ReportedErrorInfo, ResourceExhaustionInfo, ScalarSizeMismatch,
+    UndefinedBehaviorInfo, UnsupportedOpInfo, ValTreeCreationError, interp_ok,
 };
 pub use self::pointer::{CtfeProvenance, Pointer, PointerArithmetic, Provenance};
 pub use self::value::Scalar;
@@ -76,15 +75,21 @@ pub fn display(self, tcx: TyCtxt<'tcx>) -> String {
 #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct AllocId(pub NonZero<u64>);
 
-// We want the `Debug` output to be readable as it is used by `derive(Debug)` for
-// all the Miri types.
-impl fmt::Debug for AllocId {
+// AllocId show up in const-eval error messages
+impl fmt::Display for AllocId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if f.alternate() { write!(f, "a{}", self.0) } else { write!(f, "alloc{}", self.0) }
     }
 }
 
-// No "Display" since AllocIds are not usually user-visible.
+// We want the `Debug` output to be readable as it is used by `derive(Debug)` for
+// all the Miri types.
+impl fmt::Debug for AllocId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Dispatch to `Display` impl.
+        fmt::Display::fmt(self, f)
+    }
+}
 
 #[derive(TyDecodable, TyEncodable)]
 enum AllocDiscriminant {
diff --git a/compiler/rustc_middle/src/mir/interpret/pointer.rs b/compiler/rustc_middle/src/mir/interpret/pointer.rs
index b6bcc87ff041..e135404f28e7 100644
--- a/compiler/rustc_middle/src/mir/interpret/pointer.rs
+++ b/compiler/rustc_middle/src/mir/interpret/pointer.rs
@@ -241,6 +241,12 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
+impl<Prov: Provenance> fmt::Display for Pointer<Prov> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Provenance::fmt(self, f)
+    }
+}
+
 impl<Prov: Provenance> fmt::Debug for Pointer<Option<Prov>> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.provenance {
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 2dd205e8468d..b029112ed8a0 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -14,7 +14,7 @@
 pub use rustc_ast::{Mutability, Pinnedness};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::graph::dominators::Dominators;
-use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, ErrorGuaranteed, IntoDiagArg};
+use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
 use rustc_hir::{
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index 650c44aa41fb..7931c80bed6c 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -326,36 +326,42 @@ pub fn fmt_assert_args<W: fmt::Write>(&self, f: &mut W) -> fmt::Result
             }
         }
     }
+}
 
-    /// Format the diagnostic message for use in a lint (e.g. when the assertion fails during const-eval).
-    ///
-    /// Needs to be kept in sync with the run-time behavior (which is defined by
-    /// `AssertKind::panic_function` and the lang items mentioned in its docs).
-    /// Note that we deliberately show more details here than we do at runtime, such as the actual
-    /// numbers that overflowed -- it is much easier to do so here than at runtime.
-    pub fn diagnostic_message(&self) -> DiagMessage {
+/// Format the diagnostic message for use in a lint (e.g. when the assertion fails during const-eval).
+///
+/// Needs to be kept in sync with the run-time behavior (which is defined by
+/// `AssertKind::panic_function` and the lang items mentioned in its docs).
+/// Note that we deliberately show more details here than we do at runtime, such as the actual
+/// numbers that overflowed -- it is much easier to do so here than at runtime.
+impl<O: fmt::Debug> fmt::Display for AssertKind<O> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         use AssertKind::*;
 
         match self {
-            BoundsCheck { .. } => {
-                msg!("index out of bounds: the length is {$len} but the index is {$index}")
+            BoundsCheck { len, index } => {
+                write!(f, "index out of bounds: the length is {len:?} but the index is {index:?}")
             }
-            Overflow(BinOp::Shl, _, _) => {
-                msg!("attempt to shift left by `{$val}`, which would overflow")
+            Overflow(BinOp::Shl, _, val) => {
+                write!(f, "attempt to shift left by `{val:#?}`, which would overflow")
             }
-            Overflow(BinOp::Shr, _, _) => {
-                msg!("attempt to shift right by `{$val}`, which would overflow")
+            Overflow(BinOp::Shr, _, val) => {
+                write!(f, "attempt to shift right by `{val:#?}`, which would overflow")
             }
-            Overflow(_, _, _) => {
-                msg!("attempt to compute `{$left} {$op} {$right}`, which would overflow")
+            Overflow(binop, left, right) => {
+                write!(
+                    f,
+                    "attempt to compute `{left:#?} {op} {right:#?}`, which would overflow",
+                    op = binop.to_hir_binop().as_str()
+                )
             }
-            OverflowNeg(_) => msg!("attempt to negate `{$val}`, which would overflow"),
-            DivisionByZero(_) => msg!("attempt to divide `{$val}` by zero"),
-            RemainderByZero(_) => {
-                msg!("attempt to calculate the remainder of `{$val}` with a divisor of zero")
+            OverflowNeg(val) => write!(f, "attempt to negate `{val:#?}`, which would overflow"),
+            DivisionByZero(val) => write!(f, "attempt to divide `{val:#?}` by zero"),
+            RemainderByZero(val) => {
+                write!(f, "attempt to calculate the remainder of `{val:#?}` with a divisor of zero")
             }
             ResumedAfterReturn(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
-                msg!("`async fn` resumed after completion")
+                write!(f, "`async fn` resumed after completion")
             }
             ResumedAfterReturn(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
                 todo!()
@@ -364,84 +370,43 @@ pub fn diagnostic_message(&self) -> DiagMessage {
                 bug!("gen blocks can be resumed after they return and will keep returning `None`")
             }
             ResumedAfterReturn(CoroutineKind::Coroutine(_)) => {
-                msg!("coroutine resumed after completion")
+                write!(f, "coroutine resumed after completion")
             }
             ResumedAfterPanic(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
-                msg!("`async fn` resumed after panicking")
+                write!(f, "`async fn` resumed after panicking")
             }
             ResumedAfterPanic(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
                 todo!()
             }
             ResumedAfterPanic(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
-                msg!("`gen` fn or block cannot be further iterated on after it panicked")
+                write!(f, "`gen` fn or block cannot be further iterated on after it panicked")
             }
             ResumedAfterPanic(CoroutineKind::Coroutine(_)) => {
-                msg!("coroutine resumed after panicking")
+                write!(f, "coroutine resumed after panicking")
             }
-            NullPointerDereference => msg!("null pointer dereference occurred"),
-            InvalidEnumConstruction(_) => {
-                msg!("trying to construct an enum from an invalid value `{$source}`")
+            NullPointerDereference => write!(f, "null pointer dereference occurred"),
+            InvalidEnumConstruction(source) => {
+                write!(f, "trying to construct an enum from an invalid value `{source:#?}`")
             }
             ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
-                msg!("`async fn` resumed after async drop")
+                write!(f, "`async fn` resumed after async drop")
             }
             ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, _)) => {
                 todo!()
             }
             ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Gen, _)) => {
-                msg!("`gen` fn or block cannot be further iterated on after it async dropped")
+                write!(f, "`gen` fn or block cannot be further iterated on after it async dropped")
             }
             ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
-                msg!("coroutine resumed after async drop")
+                write!(f, "coroutine resumed after async drop")
             }
 
-            MisalignedPointerDereference { .. } => msg!(
-                "misaligned pointer dereference: address must be a multiple of {$required} but is {$found}"
+            MisalignedPointerDereference { required, found } => write!(
+                f,
+                "misaligned pointer dereference: address must be a multiple of {required:#?} but is {found:#?}"
             ),
         }
     }
-
-    pub fn add_args(self, adder: &mut dyn FnMut(DiagArgName, DiagArgValue))
-    where
-        O: fmt::Debug,
-    {
-        use AssertKind::*;
-
-        macro_rules! add {
-            ($name: expr, $value: expr) => {
-                adder($name.into(), $value.into_diag_arg(&mut None));
-            };
-        }
-
-        match self {
-            BoundsCheck { len, index } => {
-                add!("len", format!("{len:?}"));
-                add!("index", format!("{index:?}"));
-            }
-            Overflow(BinOp::Shl | BinOp::Shr, _, val)
-            | DivisionByZero(val)
-            | RemainderByZero(val)
-            | OverflowNeg(val) => {
-                add!("val", format!("{val:#?}"));
-            }
-            Overflow(binop, left, right) => {
-                add!("op", binop.to_hir_binop().as_str());
-                add!("left", format!("{left:#?}"));
-                add!("right", format!("{right:#?}"));
-            }
-            ResumedAfterReturn(_)
-            | ResumedAfterPanic(_)
-            | NullPointerDereference
-            | ResumedAfterDrop(_) => {}
-            MisalignedPointerDereference { required, found } => {
-                add!("required", format!("{required:#?}"));
-                add!("found", format!("{found:#?}"));
-            }
-            InvalidEnumConstruction(source) => {
-                add!("source", format!("{source:#?}"));
-            }
-        }
-    }
 }
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
@@ -510,7 +475,6 @@ pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<
 }
 
 pub use helper::*;
-use rustc_errors::msg;
 
 mod helper {
     use super::*;
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index fe8f8abf7f57..ebd428168daa 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -7,9 +7,8 @@
     PointerKind, Primitive, ReprFlags, ReprOptions, Scalar, Size, TagEncoding, TargetDataLayout,
     TyAbiInterface, VariantIdx, Variants,
 };
-use rustc_error_messages::DiagMessage;
 use rustc_errors::{
-    Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level, msg,
+    Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
 };
 use rustc_hir as hir;
 use rustc_hir::LangItem;
@@ -266,29 +265,6 @@ pub enum LayoutError<'tcx> {
 }
 
 impl<'tcx> LayoutError<'tcx> {
-    pub fn diagnostic_message(&self) -> DiagMessage {
-        use LayoutError::*;
-
-        match self {
-            Unknown(_) => msg!("the type `{$ty}` has an unknown layout"),
-            SizeOverflow(_) => {
-                msg!("values of the type `{$ty}` are too big for the target architecture")
-            }
-            InvalidSimd { kind: SimdLayoutError::TooManyLanes(_), .. } => {
-                msg!("the SIMD type `{$ty}` has more elements than the limit {$max_lanes}")
-            }
-            InvalidSimd { kind: SimdLayoutError::ZeroLength, .. } => {
-                msg!("the SIMD type `{$ty}` has zero elements")
-            }
-            TooGeneric(_) => msg!("the type `{$ty}` does not have a fixed layout"),
-            NormalizationFailure(_, _) => msg!(
-                "unable to determine layout for `{$ty}` because `{$failure_ty}` cannot be normalized"
-            ),
-            Cycle(_) => msg!("a cycle occurred during layout computation"),
-            ReferencesError(_) => msg!("the type has an unknown layout"),
-        }
-    }
-
     pub fn into_diagnostic(self) -> crate::error::LayoutError<'tcx> {
         use LayoutError::*;
 
diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index 00b67b656459..daee8de96513 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -145,11 +145,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 }
             },
         );
-        let label = self.assert_kind.diagnostic_message();
-        self.assert_kind.add_args(&mut |name, value| {
-            diag.arg(name, value);
-        });
-        diag.span_label(self.span, label);
+        diag.span_label(self.span, self.assert_kind.to_string());
         diag
     }
 }
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index c4994417ed7e..8d0922db8f40 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -241,7 +241,7 @@ fn use_ecx<F, T>(&mut self, f: F) -> Option<T>
                 assert!(
                     !err.kind().formatted_string(),
                     "known panics lint encountered formatting error: {}",
-                    format_interp_error(self.ecx.tcx.dcx(), err),
+                    format_interp_error(err),
                 );
                 err
             })
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index 20fbb687b308..d8ef2484a95c 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -42,11 +42,7 @@ pub fn from_json(json: &str) -> Result<(Target, TargetWarnings), String> {
         }
 
         let alignment_error = |field_name: &str, error: AlignFromBytesError| -> String {
-            let msg = match error {
-                AlignFromBytesError::NotPowerOfTwo(_) => "not a power of 2 number of bytes",
-                AlignFromBytesError::TooLarge(_) => "too large",
-            };
-            format!("`{}` bits is not a valid value for {field_name}: {msg}", error.align() * 8)
+            format!("invalid value for {field_name}: {error}")
         };
 
         macro_rules! forward {
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
index 36e574c8e57f..6b7c0adc8afb 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
@@ -37,17 +37,14 @@ fn generate_diagnostic(&self) -> (String, SpanData) {
         let tag = self.retag.new_tag;
         if let Some(perm) = self.retag.permission {
             (
-                format!(
-                    "{tag:?} was created by a {:?} retag at offsets {:?}",
-                    perm, self.retag.range,
-                ),
+                format!("{tag:?} was created by a {perm:?} retag at offsets {}", self.retag.range),
                 self.span.data(),
             )
         } else {
             assert!(self.retag.range.size == Size::ZERO);
             (
                 format!(
-                    "{tag:?} would have been created here, but this is a zero-size retag ({:?}) so the tag in question does not exist anywhere",
+                    "{tag:?} would have been created here, but this is a zero-size retag ({}) so the tag in question does not exist anywhere",
                     self.retag.range,
                 ),
                 self.span.data(),
@@ -79,12 +76,12 @@ fn generate_diagnostic(&self) -> (String, SpanData) {
             // For a FnEntry retag, our Span points at the caller.
             // See `DiagnosticCx::log_invalidation`.
             format!(
-                "{:?} was later invalidated at offsets {:?} by a {} inside this call",
+                "{:?} was later invalidated at offsets {} by a {} inside this call",
                 self.tag, self.range, self.cause
             )
         } else {
             format!(
-                "{:?} was later invalidated at offsets {:?} by a {}",
+                "{:?} was later invalidated at offsets {} by a {}",
                 self.tag, self.range, self.cause
             )
         };
@@ -343,7 +340,7 @@ pub fn get_logs_relevant_to(
                 if self.history.root.0.tag() == tag {
                     Some((
                         format!(
-                            "{tag:?} was created here, as the root tag for {:?}",
+                            "{tag:?} was created here, as the root tag for {}",
                             self.history.id
                         ),
                         self.history.root.1.data(),
@@ -383,7 +380,7 @@ pub(super) fn grant_error(&self, stack: &Stack) -> InterpErrorKind<'tcx> {
         let perm =
             op.permission.expect("`start_grant` must be called before calling `grant_error`");
         let action = format!(
-            "trying to retag from {:?} for {:?} permission at {:?}[{:#x}]",
+            "trying to retag from {:?} for {:?} permission at {}[{:#x}]",
             op.orig_tag,
             perm,
             self.history.id,
@@ -410,7 +407,7 @@ pub(super) fn access_error(&self, stack: &Stack) -> InterpErrorKind<'tcx> {
             Operation::Dealloc(_) => return self.dealloc_error(stack),
         };
         let action = format!(
-            "attempting a {access} using {tag:?} at {alloc_id:?}[{offset:#x}]",
+            "attempting a {access} using {tag:?} at {alloc_id}[{offset:#x}]",
             access = op.kind,
             tag = op.tag,
             alloc_id = self.history.id,
@@ -455,7 +452,7 @@ pub fn dealloc_error(&self, stack: &Stack) -> InterpErrorKind<'tcx> {
         };
         err_sb_ub(
             format!(
-                "attempting deallocation using {tag:?} at {alloc_id:?}{cause}",
+                "attempting deallocation using {tag:?} at {alloc_id}{cause}",
                 tag = op.tag,
                 alloc_id = self.history.id,
                 cause = error_cause(stack, op.tag),
@@ -488,7 +485,7 @@ pub fn check_tracked_tag_popped(&self, item: &Item, global: &GlobalStateInner) {
 }
 
 fn operation_summary(operation: &str, alloc_id: AllocId, alloc_range: AllocRange) -> String {
-    format!("this error occurs as part of {operation} at {alloc_id:?}{alloc_range:?}")
+    format!("this error occurs as part of {operation} at {alloc_id}{alloc_range}")
 }
 
 fn error_cause(stack: &Stack, prov_extra: ProvenanceExtra) -> &'static str {
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
index 055baca8542f..093dada405af 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
@@ -157,7 +157,7 @@ fn extend(&mut self, new_history: History, tag_name: &'static str, show_initial_
             // to the user. The meaningful one is `access_range`.
             let access = access_cause.print_as_access(is_foreign);
             let access_range_text = match access_range {
-                Some(r) => format!("at offsets {r:?}"),
+                Some(r) => format!("at offsets {r}"),
                 None => format!("on every location previously accessed by this tag"),
             };
             self.events.push((
@@ -339,7 +339,7 @@ pub fn build<'tcx>(self) -> InterpErrorKind<'tcx> {
         // all tags through which an access would cause UB.
         let accessed_is_conflicting = accessed.map(|a| a.tag) == Some(conflicting.tag);
         let title = format!(
-            "{cause} through {accessed_str} at {alloc_id:?}[{error_offset:#x}] is forbidden",
+            "{cause} through {accessed_str} at {alloc_id}[{error_offset:#x}] is forbidden",
             alloc_id = self.access_info.alloc_id
         );
         let (title, details, conflicting_tag_name) = match self.error_kind {
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 367012e56ad9..7992819aafd0 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -4,7 +4,7 @@
 
 use rustc_abi::{Align, Size};
 use rustc_data_structures::fx::{FxBuildHasher, FxHashSet};
-use rustc_errors::{Diag, DiagMessage, Level};
+use rustc_errors::{Diag, Level};
 use rustc_span::{DUMMY_SP, Span, SpanData, Symbol};
 
 use crate::borrow_tracker::stacked_borrows::diagnostics::TagHistory;
@@ -106,16 +106,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
-impl MachineStopType for TerminationInfo {
-    fn diagnostic_message(&self) -> DiagMessage {
-        self.to_string().into()
-    }
-    fn add_args(
-        self: Box<Self>,
-        _: &mut dyn FnMut(std::borrow::Cow<'static, str>, rustc_errors::DiagArgValue),
-    ) {
-    }
-}
+impl MachineStopType for TerminationInfo {}
 
 /// Miri specific diagnostics
 pub enum NonHaltingDiagnostic {
@@ -354,16 +345,14 @@ pub fn report_result<'tcx>(
         (title, helps)
     } else {
         let title = match res.kind() {
-            UndefinedBehavior(ValidationError(validation_err))
-                if matches!(
-                    validation_err.kind,
-                    ValidationErrorKind::PointerAsInt { .. } | ValidationErrorKind::PartialPointer
-                ) =>
-            {
+            UndefinedBehavior(UndefinedBehaviorInfo::ValidationError {
+                ptr_bytes_warning: true,
+                ..
+            }) => {
                 ecx.handle_ice(); // print interpreter backtrace (this is outside the eval `catch_unwind`)
                 bug!(
                     "This validation error should be impossible in Miri: {}",
-                    format_interp_error(ecx.tcx.dcx(), res)
+                    format_interp_error(res)
                 );
             }
             UndefinedBehavior(_) => "Undefined Behavior",
@@ -380,10 +369,7 @@ pub fn report_result<'tcx>(
             ) => "post-monomorphization error",
             _ => {
                 ecx.handle_ice(); // print interpreter backtrace (this is outside the eval `catch_unwind`)
-                bug!(
-                    "This error should be impossible in Miri: {}",
-                    format_interp_error(ecx.tcx.dcx(), res)
-                );
+                bug!("This error should be impossible in Miri: {}", format_interp_error(res));
             }
         };
         #[rustfmt::skip]
@@ -411,10 +397,10 @@ pub fn report_result<'tcx>(
                 match info {
                     PointerUseAfterFree(alloc_id, _) | PointerOutOfBounds { alloc_id, .. } => {
                         if let Some(span) = ecx.machine.allocated_span(*alloc_id) {
-                            helps.push(note_span!(span, "{:?} was allocated here:", alloc_id));
+                            helps.push(note_span!(span, "{alloc_id} was allocated here:"));
                         }
                         if let Some(span) = ecx.machine.deallocated_span(*alloc_id) {
-                            helps.push(note_span!(span, "{:?} was deallocated here:", alloc_id));
+                            helps.push(note_span!(span, "{alloc_id} was deallocated here:"));
                         }
                     }
                     AbiMismatchArgument { .. } | AbiMismatchReturn { .. } => {
@@ -447,7 +433,7 @@ pub fn report_result<'tcx>(
         UndefinedBehavior(InvalidUninitBytes(Some((alloc_id, access)))) => {
             writeln!(
                 extra,
-                "Uninitialized memory occurred at {alloc_id:?}{range:?}, in this allocation:",
+                "Uninitialized memory occurred at {alloc_id}{range}, in this allocation:",
                 range = access.bad,
             )
             .unwrap();
@@ -460,7 +446,7 @@ pub fn report_result<'tcx>(
     if let Some(title) = title {
         write!(primary_msg, "{title}: ").unwrap();
     }
-    write!(primary_msg, "{}", format_interp_error(ecx.tcx.dcx(), res)).unwrap();
+    write!(primary_msg, "{}", format_interp_error(res)).unwrap();
 
     if labels.is_empty() {
         labels.push(format!(
@@ -510,7 +496,7 @@ pub fn report_leaks<'tcx>(
     let mut any_pruned = false;
     for (id, kind, alloc) in leaks {
         let mut title = format!(
-            "memory leaked: {id:?} ({}, size: {:?}, align: {:?})",
+            "memory leaked: {id:?} ({}, size: {}, align: {})",
             kind,
             alloc.size().bytes(),
             alloc.align.bytes()
@@ -665,17 +651,17 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
                 format!("created {tag:?} with {perm} derived from unknown tag"),
             CreatedPointerTag(tag, Some(perm), Some((alloc_id, range, orig_tag))) =>
                 format!(
-                    "created tag {tag:?} with {perm} at {alloc_id:?}{range:?} derived from {orig_tag:?}"
+                    "created tag {tag:?} with {perm} at {alloc_id}{range} derived from {orig_tag:?}"
                 ),
             PoppedPointerTag(item, cause) => format!("popped tracked tag for item {item:?}{cause}"),
             TrackingAlloc(id, size, align) =>
                 format!(
-                    "now tracking allocation {id:?} of {size} bytes (alignment {align} bytes)",
+                    "now tracking allocation {id} of {size} bytes (alignment {align} bytes)",
                     size = size.bytes(),
                     align = align.bytes(),
                 ),
             AccessedAlloc(id, range, access_kind) =>
-                format!("{access_kind} at {id:?}[{}..{}]", range.start.bytes(), range.end().bytes()),
+                format!("{access_kind} at {id}{range}"),
             FreedAlloc(id) => format!("freed allocation {id:?}"),
             RejectedIsolatedOp(op) => format!("{op} was made to return an error due to isolation"),
             ProgressReport { .. } =>
diff --git a/src/tools/miri/tests/pass/alloc-access-tracking.stderr b/src/tools/miri/tests/pass/alloc-access-tracking.stderr
index f1c9241beded..6c780e78e91b 100644
--- a/src/tools/miri/tests/pass/alloc-access-tracking.stderr
+++ b/src/tools/miri/tests/pass/alloc-access-tracking.stderr
@@ -4,13 +4,13 @@ note: now tracking allocation ALLOC of 123 bytes (alignment ALIGN bytes)
 LL |         utils::miri_track_alloc(ptr);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ tracking was triggered here
 
-note: write access at ALLOC[0..1]
+note: write access at ALLOC[0x0..0x1]
   --> tests/pass/alloc-access-tracking.rs:LL:CC
    |
 LL |         *ptr = 42; // Crucially, only a write is printed here, no read!
    |         ^^^^^^^^^ tracking was triggered here
 
-note: read access at ALLOC[0..1]
+note: read access at ALLOC[0x0..0x1]
   --> tests/pass/alloc-access-tracking.rs:LL:CC
    |
 LL |         assert_eq!(*ptr, 42);

From 90f7d7e07475697fa5b9eedd26d74f2a309b4d31 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 15:47:34 +0100
Subject: [PATCH 0351/1059] clean up some unused leftovers

---
 compiler/rustc_const_eval/src/errors.rs    |  2 --
 compiler/rustc_middle/src/error.rs         | 26 +---------------------
 compiler/rustc_middle/src/ty/consts/int.rs |  9 --------
 3 files changed, 1 insertion(+), 36 deletions(-)

diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 1097eecf3121..3943be0cf15e 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -383,8 +383,6 @@ pub struct RawBytesNote {
     pub bytes: String,
 }
 
-// FIXME(fee1-dead) do not use stringly typed `ConstContext`
-
 #[derive(Diagnostic)]
 #[diag(
     r#"cannot match on `{$ty}` in {$kind ->
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index dfb99fb98513..d173335e9aa2 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -1,8 +1,7 @@
+use std::io;
 use std::path::Path;
-use std::{fmt, io};
 
 use rustc_errors::codes::*;
-use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 
@@ -114,29 +113,6 @@ pub(super) struct ConstNotUsedTraitAlias {
     pub span: Span,
 }
 
-pub struct CustomSubdiagnostic<'a> {
-    pub msg: fn() -> DiagMessage,
-    pub add_args: Box<dyn FnOnce(&mut dyn FnMut(DiagArgName, DiagArgValue)) + 'a>,
-}
-
-impl<'a> CustomSubdiagnostic<'a> {
-    pub fn label(x: fn() -> DiagMessage) -> Self {
-        Self::label_and_then(x, |_| {})
-    }
-    pub fn label_and_then<F: FnOnce(&mut dyn FnMut(DiagArgName, DiagArgValue)) + 'a>(
-        msg: fn() -> DiagMessage,
-        f: F,
-    ) -> Self {
-        Self { msg, add_args: Box::new(move |x| f(x)) }
-    }
-}
-
-impl fmt::Debug for CustomSubdiagnostic<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("CustomSubdiagnostic").finish_non_exhaustive()
-    }
-}
-
 #[derive(Diagnostic)]
 pub enum LayoutError<'tcx> {
     #[diag("the type `{$ty}` has an unknown layout")]
diff --git a/compiler/rustc_middle/src/ty/consts/int.rs b/compiler/rustc_middle/src/ty/consts/int.rs
index eaf67ae23ad2..180ccd9301c4 100644
--- a/compiler/rustc_middle/src/ty/consts/int.rs
+++ b/compiler/rustc_middle/src/ty/consts/int.rs
@@ -4,7 +4,6 @@
 use rustc_abi::Size;
 use rustc_apfloat::Float;
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
-use rustc_errors::{DiagArgValue, IntoDiagArg};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
 use crate::ty::TyCtxt;
@@ -137,14 +136,6 @@ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     }
 }
 
-impl IntoDiagArg for ConstInt {
-    // FIXME this simply uses the Debug impl, but we could probably do better by converting both
-    // to an inherent method that returns `Cow`.
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-        DiagArgValue::Str(format!("{self:?}").into())
-    }
-}
-
 /// The raw bytes of a simple value.
 ///
 /// This is a packed struct in order to allow this type to be optimally embedded in enums

From fe1f92af4b010113a5d4b9d596209ee4637d7045 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 17:54:10 +0100
Subject: [PATCH 0352/1059] de-duplicate LayoutError formatting

---
 compiler/rustc_codegen_gcc/src/context.rs     |  2 +-
 compiler/rustc_codegen_llvm/src/context.rs    |  2 +-
 .../src/debuginfo/type_names.rs               |  2 +-
 .../rustc_hir_analysis/src/check/check.rs     |  3 +--
 compiler/rustc_middle/src/error.rs            | 27 -------------------
 compiler/rustc_middle/src/ty/layout.rs        | 26 +-----------------
 compiler/rustc_middle/src/ty/vtable.rs        |  2 +-
 compiler/rustc_passes/src/abi_test.rs         | 13 +++------
 compiler/rustc_passes/src/layout_test.rs      |  4 +--
 9 files changed, 11 insertions(+), 70 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index 5423ee5390fe..64ab92b3a914 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -538,7 +538,7 @@ fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) ->
         | LayoutError::InvalidSimd { .. }
         | LayoutError::ReferencesError(_) = err
         {
-            self.tcx.dcx().emit_fatal(respan(span, err.into_diagnostic()))
+            self.tcx.dcx().span_fatal(span, err.to_string())
         } else {
             self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
         }
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 28aa12cc83dc..545a9add911d 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -1135,7 +1135,7 @@ fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) ->
         | LayoutError::ReferencesError(_)
         | LayoutError::InvalidSimd { .. } = err
         {
-            self.tcx.dcx().emit_fatal(Spanned { span, node: err.into_diagnostic() })
+            self.tcx.dcx().span_fatal(span, err.to_string())
         } else {
             self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
         }
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index d3b2caca4742..d207cdca4d4b 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -95,7 +95,7 @@ fn push_debuginfo_type_name<'tcx>(
                         // Computing the layout can still fail here, e.g. if the target architecture
                         // cannot represent the type. See
                         // https://github.com/rust-lang/rust/issues/94961.
-                        tcx.dcx().emit_fatal(e.into_diagnostic());
+                        tcx.dcx().fatal(e.to_string());
                     }
                 }
             } else {
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 1f5eed25029b..32cfa3003eeb 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -24,7 +24,6 @@
     TypeVisitable, TypeVisitableExt, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
-use rustc_span::Spanned;
 use rustc_target::spec::{AbiMap, AbiMapping};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits;
@@ -216,7 +215,7 @@ fn check_static_inhabited(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         // SIMD types with invalid layout (e.g., zero-length) should emit an error
         Err(e @ LayoutError::InvalidSimd { .. }) => {
             let ty_span = tcx.ty_span(def_id);
-            tcx.dcx().emit_err(Spanned { span: ty_span, node: e.into_diagnostic() });
+            tcx.dcx().span_err(ty_span, e.to_string());
             return;
         }
         // Generic statics are rejected, but we still reach this case.
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index d173335e9aa2..44ac747726a6 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -113,33 +113,6 @@ pub(super) struct ConstNotUsedTraitAlias {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-pub enum LayoutError<'tcx> {
-    #[diag("the type `{$ty}` has an unknown layout")]
-    Unknown { ty: Ty<'tcx> },
-
-    #[diag("the type `{$ty}` does not have a fixed layout")]
-    TooGeneric { ty: Ty<'tcx> },
-
-    #[diag("values of the type `{$ty}` are too big for the target architecture")]
-    Overflow { ty: Ty<'tcx> },
-
-    #[diag("the SIMD type `{$ty}` has more elements than the limit {$max_lanes}")]
-    SimdTooManyLanes { ty: Ty<'tcx>, max_lanes: u64 },
-
-    #[diag("the SIMD type `{$ty}` has zero elements")]
-    SimdZeroLength { ty: Ty<'tcx> },
-
-    #[diag("unable to determine layout for `{$ty}` because `{$failure_ty}` cannot be normalized")]
-    NormalizationFailure { ty: Ty<'tcx>, failure_ty: String },
-
-    #[diag("a cycle occurred during layout computation")]
-    Cycle,
-
-    #[diag("the type has an unknown layout")]
-    ReferencesError,
-}
-
 #[derive(Diagnostic)]
 #[diag("erroneous constant encountered")]
 pub(crate) struct ErroneousConstant {
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index ebd428168daa..4ca51c078bef 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -264,30 +264,6 @@ pub enum LayoutError<'tcx> {
     Cycle(ErrorGuaranteed),
 }
 
-impl<'tcx> LayoutError<'tcx> {
-    pub fn into_diagnostic(self) -> crate::error::LayoutError<'tcx> {
-        use LayoutError::*;
-
-        use crate::error::LayoutError as E;
-        match self {
-            Unknown(ty) => E::Unknown { ty },
-            SizeOverflow(ty) => E::Overflow { ty },
-            InvalidSimd { ty, kind: SimdLayoutError::TooManyLanes(max_lanes) } => {
-                E::SimdTooManyLanes { ty, max_lanes }
-            }
-            InvalidSimd { ty, kind: SimdLayoutError::ZeroLength } => E::SimdZeroLength { ty },
-            TooGeneric(ty) => E::TooGeneric { ty },
-            NormalizationFailure(ty, e) => {
-                E::NormalizationFailure { ty, failure_ty: e.get_type_for_failure() }
-            }
-            Cycle(_) => E::Cycle,
-            ReferencesError(_) => E::ReferencesError,
-        }
-    }
-}
-
-// FIXME: Once the other errors that embed this error have been converted to translatable
-// diagnostics, this Display impl should be removed.
 impl<'tcx> fmt::Display for LayoutError<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
@@ -1309,7 +1285,7 @@ pub enum FnAbiError<'tcx> {
 impl<'a, 'b, G: EmissionGuarantee> Diagnostic<'a, G> for FnAbiError<'b> {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         match self {
-            Self::Layout(e) => e.into_diagnostic().into_diag(dcx, level),
+            Self::Layout(e) => Diag::new(dcx, level, e.to_string()),
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/vtable.rs b/compiler/rustc_middle/src/ty/vtable.rs
index edb1eaea3027..8a376e542945 100644
--- a/compiler/rustc_middle/src/ty/vtable.rs
+++ b/compiler/rustc_middle/src/ty/vtable.rs
@@ -101,7 +101,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
 
     let layout = match tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)) {
         Ok(layout) => layout,
-        Err(e) => tcx.dcx().emit_fatal(e.into_diagnostic()),
+        Err(e) => tcx.dcx().fatal(e.to_string()),
     };
     assert!(layout.is_sized(), "can't create a vtable for an unsized type");
     let size = layout.size.bytes();
diff --git a/compiler/rustc_passes/src/abi_test.rs b/compiler/rustc_passes/src/abi_test.rs
index 7d1ee1ffbc36..35bfad3a877f 100644
--- a/compiler/rustc_passes/src/abi_test.rs
+++ b/compiler/rustc_passes/src/abi_test.rs
@@ -5,7 +5,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{FnAbiError, LayoutError};
 use rustc_middle::ty::{self, GenericArgs, Instance, Ty, TyCtxt};
-use rustc_span::{Span, Spanned};
+use rustc_span::Span;
 use rustc_target::callconv::FnAbi;
 
 use super::layout_test::ensure_wf;
@@ -44,10 +44,7 @@ fn unwrap_fn_abi<'tcx>(
     match abi {
         Ok(abi) => abi,
         Err(FnAbiError::Layout(layout_error)) => {
-            tcx.dcx().emit_fatal(Spanned {
-                node: layout_error.into_diagnostic(),
-                span: tcx.def_span(item_def_id),
-            });
+            tcx.dcx().span_fatal(tcx.def_span(item_def_id), layout_error.to_string());
         }
     }
 }
@@ -65,11 +62,7 @@ fn dump_abi_of_fn_item(
         Ok(None) => {
             // Not sure what to do here, but `LayoutError::Unknown` seems reasonable?
             let ty = tcx.type_of(item_def_id).instantiate_identity();
-            tcx.dcx().emit_fatal(Spanned {
-                node: LayoutError::Unknown(ty).into_diagnostic(),
-
-                span: tcx.def_span(item_def_id),
-            });
+            tcx.dcx().span_fatal(tcx.def_span(item_def_id), LayoutError::Unknown(ty).to_string());
         }
         Err(_guaranteed) => return,
     };
diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs
index f4f5ae6c1683..1a9054a51ca3 100644
--- a/compiler/rustc_passes/src/layout_test.rs
+++ b/compiler/rustc_passes/src/layout_test.rs
@@ -6,7 +6,7 @@
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutError, LayoutOfHelpers};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::{Span, Spanned};
+use rustc_span::Span;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::TyCtxtInferExt;
 use rustc_trait_selection::traits;
@@ -115,7 +115,7 @@ fn dump_layout_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attrs: &[RustcLayout
         }
 
         Err(layout_error) => {
-            tcx.dcx().emit_err(Spanned { node: layout_error.into_diagnostic(), span });
+            tcx.dcx().span_err(span, layout_error.to_string());
         }
     }
 }

From bc4dfa5e3338ddd8eece1ba741f38ee69e2f636c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 11 Mar 2026 15:17:23 +0100
Subject: [PATCH 0353/1059] miri-test-libstd: use --tests and update some
 comments

---
 library/alloctests/benches/lib.rs              | 2 +-
 library/alloctests/benches/vec_deque_append.rs | 5 -----
 library/coretests/benches/lib.rs               | 2 +-
 library/std/benches/lib.rs                     | 2 +-
 library/std/benches/path.rs                    | 5 -----
 src/bootstrap/mk/Makefile.in                   | 2 +-
 6 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/library/alloctests/benches/lib.rs b/library/alloctests/benches/lib.rs
index 721d685527fe..4a25778d88c8 100644
--- a/library/alloctests/benches/lib.rs
+++ b/library/alloctests/benches/lib.rs
@@ -1,4 +1,4 @@
-// Disabling in Miri as these would take too long.
+// This is marked as `test = true` and hence picked up by `./x miri`, but that would be too slow.
 #![cfg(not(miri))]
 #![feature(iter_next_chunk)]
 #![feature(repr_simd)]
diff --git a/library/alloctests/benches/vec_deque_append.rs b/library/alloctests/benches/vec_deque_append.rs
index 71dc0813f9cc..180981abc06f 100644
--- a/library/alloctests/benches/vec_deque_append.rs
+++ b/library/alloctests/benches/vec_deque_append.rs
@@ -6,11 +6,6 @@
 const BENCH_N: usize = 1000;
 
 fn main() {
-    if cfg!(miri) {
-        // Don't benchmark Miri...
-        // (Due to bootstrap quirks, this gets picked up by `x.py miri library/alloc --all-targets`.)
-        return;
-    }
     let a: VecDeque<i32> = (0..VECDEQUE_LEN).collect();
     let b: VecDeque<i32> = (0..VECDEQUE_LEN).collect();
 
diff --git a/library/coretests/benches/lib.rs b/library/coretests/benches/lib.rs
index 150b9b33f457..6b65ecaf4edc 100644
--- a/library/coretests/benches/lib.rs
+++ b/library/coretests/benches/lib.rs
@@ -1,6 +1,6 @@
 // wasm32 does not support benches (no time).
 #![cfg(not(target_arch = "wasm32"))]
-// Disabling in Miri as these would take too long.
+// This is marked as `test = true` and hence picked up by `./x miri`, but that would be too slow.
 #![cfg(not(miri))]
 #![feature(flt2dec)]
 #![feature(test)]
diff --git a/library/std/benches/lib.rs b/library/std/benches/lib.rs
index e749d9c0f799..2707b414f578 100644
--- a/library/std/benches/lib.rs
+++ b/library/std/benches/lib.rs
@@ -1,4 +1,4 @@
-// Disabling in Miri as these would take too long.
+// This is marked as `test = true` and hence picked up by `./x miri`, but that would be too slow.
 #![cfg(not(miri))]
 #![feature(test)]
 
diff --git a/library/std/benches/path.rs b/library/std/benches/path.rs
index 912c783b31e4..b6d5a8672aa6 100644
--- a/library/std/benches/path.rs
+++ b/library/std/benches/path.rs
@@ -4,7 +4,6 @@
 use std::path::*;
 
 #[bench]
-#[cfg_attr(miri, ignore)] // Miri isn't fast...
 fn bench_path_cmp_fast_path_buf_sort(b: &mut test::Bencher) {
     let prefix = "my/home";
     let mut paths: Vec<_> =
@@ -18,7 +17,6 @@ fn bench_path_cmp_fast_path_buf_sort(b: &mut test::Bencher) {
 }
 
 #[bench]
-#[cfg_attr(miri, ignore)] // Miri isn't fast...
 fn bench_path_cmp_fast_path_long(b: &mut test::Bencher) {
     let prefix = "/my/home/is/my/castle/and/my/castle/has/a/rusty/workbench/";
     let paths: Vec<_> =
@@ -37,7 +35,6 @@ fn bench_path_cmp_fast_path_long(b: &mut test::Bencher) {
 }
 
 #[bench]
-#[cfg_attr(miri, ignore)] // Miri isn't fast...
 fn bench_path_cmp_fast_path_short(b: &mut test::Bencher) {
     let prefix = "my/home";
     let paths: Vec<_> =
@@ -80,7 +77,6 @@ fn bench_path_file_name(b: &mut test::Bencher) {
 }
 
 #[bench]
-#[cfg_attr(miri, ignore)] // Miri isn't fast...
 fn bench_path_hashset(b: &mut test::Bencher) {
     let prefix = "/my/home/is/my/castle/and/my/castle/has/a/rusty/workbench/";
     let paths: Vec<_> =
@@ -99,7 +95,6 @@ fn bench_path_hashset(b: &mut test::Bencher) {
 }
 
 #[bench]
-#[cfg_attr(miri, ignore)] // Miri isn't fast...
 fn bench_path_hashset_miss(b: &mut test::Bencher) {
     let prefix = "/my/home/is/my/castle/and/my/castle/has/a/rusty/workbench/";
     let paths: Vec<_> =
diff --git a/src/bootstrap/mk/Makefile.in b/src/bootstrap/mk/Makefile.in
index 0268906a4664..d675181f1941 100644
--- a/src/bootstrap/mk/Makefile.in
+++ b/src/bootstrap/mk/Makefile.in
@@ -64,7 +64,7 @@ check-aux:
 		library/core \
 		library/alloc \
 		$(BOOTSTRAP_ARGS) \
-		--all-targets
+		--tests # exclude doc tests
 	# Some doctests use file system operations to demonstrate dealing with `Result`,
 	# so we have to run them with isolation disabled.
 	$(Q)MIRIFLAGS="-Zmiri-disable-isolation" \

From 86880c90c21fe294eabb931fb3e69b69564b1832 Mon Sep 17 00:00:00 2001
From: GokhanKabar <gokhankabar@hotmail.fr>
Date: Wed, 11 Mar 2026 16:39:22 +0100
Subject: [PATCH 0354/1059] Fix ICE in fn_delegation when child segment
 resolves to a trait

When a delegation path like `reuse Trait::<> as bar4` has a child segment
that resolves to a trait instead of a function, the compiler would ICE
because `lower_generic_args_of_path` asserts that `self_ty` is `Some`
when `has_self` is true and `parent` is `None`.

Fix this by filtering out non-function child segments early using
`.filter()` in the method chain, so that when the child segment resolves
to a trait (error recovery for E0423), we skip generic args computation
entirely and return an empty list via `unwrap_or_default()`.

Also make `get_segment` return `Option` by using `opt_def_id()` instead
of `def_id()` to gracefully handle unresolved segments.
---
 compiler/rustc_hir_analysis/src/delegation.rs | 48 ++++++++++---------
 .../reuse-trait-path-with-empty-generics.rs   | 14 ++++++
 ...euse-trait-path-with-empty-generics.stderr |  9 ++++
 3 files changed, 49 insertions(+), 22 deletions(-)
 create mode 100644 tests/ui/delegation/reuse-trait-path-with-empty-generics.rs
 create mode 100644 tests/ui/delegation/reuse-trait-path-with-empty-generics.stderr

diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index ad23868fffd6..17b127cf6281 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -597,31 +597,35 @@ fn get_delegation_user_specified_args<'tcx>(
             .as_slice()
     });
 
-    let child_args = info.child_args_segment_id.and_then(get_segment).map(|(segment, def_id)| {
-        let parent_args = if let Some(parent_args) = parent_args {
-            parent_args
-        } else {
-            let parent = tcx.parent(def_id);
-            if matches!(tcx.def_kind(parent), DefKind::Trait) {
-                ty::GenericArgs::identity_for_item(tcx, parent).as_slice()
+    let child_args = info
+        .child_args_segment_id
+        .and_then(get_segment)
+        .filter(|(_, def_id)| matches!(tcx.def_kind(*def_id), DefKind::Fn | DefKind::AssocFn))
+        .map(|(segment, def_id)| {
+            let parent_args = if let Some(parent_args) = parent_args {
+                parent_args
             } else {
-                &[]
-            }
-        };
+                let parent = tcx.parent(def_id);
+                if matches!(tcx.def_kind(parent), DefKind::Trait) {
+                    ty::GenericArgs::identity_for_item(tcx, parent).as_slice()
+                } else {
+                    &[]
+                }
+            };
 
-        let args = lowerer
-            .lower_generic_args_of_path(
-                segment.ident.span,
-                def_id,
-                parent_args,
-                segment,
-                None,
-                GenericArgPosition::Value,
-            )
-            .0;
+            let args = lowerer
+                .lower_generic_args_of_path(
+                    segment.ident.span,
+                    def_id,
+                    parent_args,
+                    segment,
+                    None,
+                    GenericArgPosition::Value,
+                )
+                .0;
 
-        &args[parent_args.len()..]
-    });
+            &args[parent_args.len()..]
+        });
 
     (parent_args.unwrap_or_default(), child_args.unwrap_or_default())
 }
diff --git a/tests/ui/delegation/reuse-trait-path-with-empty-generics.rs b/tests/ui/delegation/reuse-trait-path-with-empty-generics.rs
new file mode 100644
index 000000000000..08645e150044
--- /dev/null
+++ b/tests/ui/delegation/reuse-trait-path-with-empty-generics.rs
@@ -0,0 +1,14 @@
+//@ needs-rustc-debug-assertions
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait {
+    fn bar4();
+}
+
+impl Trait for () {
+    reuse Trait::<> as bar4;
+    //~^ ERROR expected function, found trait `Trait`
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/reuse-trait-path-with-empty-generics.stderr b/tests/ui/delegation/reuse-trait-path-with-empty-generics.stderr
new file mode 100644
index 000000000000..eaed6cb33c50
--- /dev/null
+++ b/tests/ui/delegation/reuse-trait-path-with-empty-generics.stderr
@@ -0,0 +1,9 @@
+error[E0423]: expected function, found trait `Trait`
+  --> $DIR/reuse-trait-path-with-empty-generics.rs:10:11
+   |
+LL |     reuse Trait::<> as bar4;
+   |           ^^^^^^^^^ not a function
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0423`.

From 965f1e76816ab6d837f83a2ef0c95af794f0cc8b Mon Sep 17 00:00:00 2001
From: Romain Perier <romain.perier@gmail.com>
Date: Thu, 1 Jan 2026 18:53:27 +0100
Subject: [PATCH 0355/1059] Introduce #[diagnostic::on_move]

This might be helpful for smart pointers to explains why they aren't Copy
and what to do instead or just to let the user know that .clone() is very
cheap and can be called without a performance penalty.
---
 .../src/attributes/diagnostic/mod.rs          | 12 +++-
 .../src/attributes/diagnostic/on_move.rs      | 72 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  2 +
 .../rustc_borrowck/src/borrowck_errors.rs     | 25 ++++---
 .../src/diagnostics/conflict_errors.rs        | 57 +++++++++++++--
 compiler/rustc_feature/src/builtin_attrs.rs   |  1 +
 compiler/rustc_feature/src/unstable.rs        |  2 +
 .../rustc_hir/src/attrs/data_structures.rs    |  7 +-
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 compiler/rustc_lint/src/early/diagnostics.rs  | 12 ++++
 compiler/rustc_lint/src/lints.rs              | 29 ++++++++
 compiler/rustc_lint_defs/src/lib.rs           |  8 +++
 compiler/rustc_passes/src/check_attr.rs       | 57 +++++++++++++++
 compiler/rustc_passes/src/errors.rs           |  7 ++
 compiler/rustc_resolve/src/macros.rs          |  2 +-
 compiler/rustc_span/src/symbol.rs             |  2 +
 .../on_move/auxiliary/other.rs                |  8 +++
 .../error_is_shown_in_downstream_crates.rs    | 14 ++++
 ...error_is_shown_in_downstream_crates.stderr | 21 ++++++
 .../on_move/on_move_simple.rs                 | 17 +++++
 .../on_move/on_move_simple.stderr             | 29 ++++++++
 .../on_move/on_move_with_format.rs            | 32 +++++++++
 .../on_move/on_move_with_format.stderr        | 55 ++++++++++++++
 .../report_warning_on_duplicated_options.rs   | 22 ++++++
 ...eport_warning_on_duplicated_options.stderr | 49 +++++++++++++
 .../report_warning_on_invalid_formats.rs      | 18 +++++
 .../report_warning_on_invalid_formats.stderr  | 38 ++++++++++
 ...ort_warning_on_invalid_meta_item_syntax.rs | 14 ++++
 ...warning_on_invalid_meta_item_syntax.stderr | 38 ++++++++++
 ...on_malformed_options_without_delimiters.rs | 18 +++++
 ...alformed_options_without_delimiters.stderr | 44 ++++++++++++
 ...g_on_malformed_options_without_literals.rs | 18 +++++
 ..._malformed_options_without_literals.stderr | 44 ++++++++++++
 .../report_warning_on_missing_options.rs      | 14 ++++
 .../report_warning_on_missing_options.stderr  | 38 ++++++++++
 .../on_move/report_warning_on_non_adt.rs      | 23 ++++++
 .../on_move/report_warning_on_non_adt.stderr  | 41 +++++++++++
 .../report_warning_on_unknown_options.rs      | 19 +++++
 .../report_warning_on_unknown_options.stderr  | 38 ++++++++++
 .../feature-gate-diagnostic-on-move.rs        | 18 +++++
 .../feature-gate-diagnostic-on-move.stderr    | 29 ++++++++
 41 files changed, 975 insertions(+), 20 deletions(-)
 create mode 100644 compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/auxiliary/other.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/on_move_simple.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/on_move_simple.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/on_move_with_format.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/on_move_with_format.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.stderr
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.rs
 create mode 100644 tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.stderr
 create mode 100644 tests/ui/feature-gates/feature-gate-diagnostic-on-move.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-diagnostic-on-move.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
index 8f114b328448..63780676bead 100644
--- a/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
@@ -22,6 +22,7 @@
 
 pub(crate) mod do_not_recommend;
 pub(crate) mod on_const;
+pub(crate) mod on_move;
 pub(crate) mod on_unimplemented;
 
 #[derive(Copy, Clone)]
@@ -32,6 +33,8 @@ pub(crate) enum Mode {
     DiagnosticOnUnimplemented,
     /// `#[diagnostic::on_const]`
     DiagnosticOnConst,
+    /// `#[diagnostic::on_move]`
+    DiagnosticOnMove,
 }
 
 fn merge_directives<S: Stage>(
@@ -113,6 +116,13 @@ fn parse_directive_items<'p, S: Stage>(
                         span,
                     );
                 }
+                Mode::DiagnosticOnMove => {
+                    cx.emit_lint(
+                        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        AttributeLintKind::MalformedOnMoveAttr { span },
+                        span,
+                    );
+                }
             }
             continue;
         }}
@@ -132,7 +142,7 @@ fn parse_directive_items<'p, S: Stage>(
                 Mode::RustcOnUnimplemented => {
                     cx.emit_err(NoValueInOnUnimplemented { span: item.span() });
                 }
-                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst => {
+                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst | Mode::DiagnosticOnMove => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         AttributeLintKind::IgnoredDiagnosticOption {
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs
new file mode 100644
index 000000000000..006b3b66658e
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs
@@ -0,0 +1,72 @@
+use rustc_feature::template;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::lints::AttributeLintKind;
+use rustc_session::lint::builtin::MALFORMED_DIAGNOSTIC_ATTRIBUTES;
+use rustc_span::sym;
+
+use crate::attributes::diagnostic::*;
+use crate::attributes::prelude::*;
+use crate::context::{AcceptContext, Stage};
+use crate::parser::ArgParser;
+use crate::target_checking::{ALL_TARGETS, AllowedTargets};
+
+#[derive(Default)]
+pub(crate) struct OnMoveParser {
+    span: Option<Span>,
+    directive: Option<(Span, Directive)>,
+}
+
+impl OnMoveParser {
+    fn parse<'sess, S: Stage>(
+        &mut self,
+        cx: &mut AcceptContext<'_, 'sess, S>,
+        args: &ArgParser,
+        mode: Mode,
+    ) {
+        if !cx.features().diagnostic_on_move() {
+            return;
+        }
+
+        let span = cx.attr_span;
+        self.span = Some(span);
+        let Some(list) = args.list() else {
+            cx.emit_lint(
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                AttributeLintKind::MissingOptionsForOnMove,
+                span,
+            );
+            return;
+        };
+
+        if list.is_empty() {
+            cx.emit_lint(
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                AttributeLintKind::OnMoveMalformedAttrExpectedLiteralOrDelimiter,
+                list.span,
+            );
+            return;
+        }
+
+        if let Some(directive) = parse_directive_items(cx, mode, list.mixed(), true) {
+            merge_directives(cx, &mut self.directive, (span, directive));
+        }
+    }
+}
+impl<S: Stage> AttributeParser<S> for OnMoveParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
+        &[sym::diagnostic, sym::on_move],
+        template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
+        |this, cx, args| {
+            this.parse(cx, args, Mode::DiagnosticOnMove);
+        },
+    )];
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        if let Some(span) = self.span {
+            Some(AttributeKind::OnMove { span, directive: self.directive.map(|d| Box::new(d.1)) })
+        } else {
+            None
+        }
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 190568bed508..259a73de5985 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -29,6 +29,7 @@
 use crate::attributes::deprecation::*;
 use crate::attributes::diagnostic::do_not_recommend::*;
 use crate::attributes::diagnostic::on_const::*;
+use crate::attributes::diagnostic::on_move::*;
 use crate::attributes::diagnostic::on_unimplemented::*;
 use crate::attributes::doc::*;
 use crate::attributes::dummy::*;
@@ -149,6 +150,7 @@ mod late {
         MacroUseParser,
         NakedParser,
         OnConstParser,
+        OnMoveParser,
         OnUnimplementedParser,
         RustcAlignParser,
         RustcAlignStaticParser,
diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index 0d3c554e4176..4fcb5f3b5a94 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -324,18 +324,23 @@ pub(crate) fn cannot_act_on_moved_value(
         verb: &str,
         optional_adverb_for_moved: &str,
         moved_path: Option<String>,
+        primary_message: Option<String>,
     ) -> Diag<'infcx> {
-        let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
+        if let Some(primary_message) = primary_message {
+            struct_span_code_err!(self.dcx(), use_span, E0382, "{}", primary_message)
+        } else {
+            let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
 
-        struct_span_code_err!(
-            self.dcx(),
-            use_span,
-            E0382,
-            "{} of {}moved value{}",
-            verb,
-            optional_adverb_for_moved,
-            moved_path,
-        )
+            struct_span_code_err!(
+                self.dcx(),
+                use_span,
+                E0382,
+                "{} of {}moved value{}",
+                verb,
+                optional_adverb_for_moved,
+                moved_path,
+            )
+        }
     }
 
     pub(crate) fn cannot_borrow_path_as_mutable_because(
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 641121597848..7bbce730c165 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -6,12 +6,16 @@
 use either::Either;
 use hir::{ClosureKind, Path};
 use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, MultiSpan, struct_span_code_err};
 use rustc_hir as hir;
+use rustc_hir::attrs::diagnostic::FormatArgs;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{Visitor, walk_block, walk_expr};
-use rustc_hir::{CoroutineDesugaring, CoroutineKind, CoroutineSource, LangItem, PatField};
+use rustc_hir::{
+    CoroutineDesugaring, CoroutineKind, CoroutineSource, LangItem, PatField, find_attr,
+};
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::{
@@ -138,6 +142,36 @@ pub(crate) fn report_use_of_moved_or_uninitialized(
             let partial_str = if is_partial_move { "partial " } else { "" };
             let partially_str = if is_partial_move { "partially " } else { "" };
 
+            let (on_move_message, on_move_label, on_move_notes) = if let ty::Adt(item_def, args) =
+                self.body.local_decls[moved_place.local].ty.kind()
+                && let Some(Some(directive)) = find_attr!(self.infcx.tcx, item_def.did(), OnMove { directive, .. }  => directive)
+            {
+                let item_name = self.infcx.tcx.item_name(item_def.did()).to_string();
+                let mut generic_args: Vec<_> = self
+                    .infcx
+                    .tcx
+                    .generics_of(item_def.did())
+                    .own_params
+                    .iter()
+                    .filter_map(|param| Some((param.name, args[param.index as usize].to_string())))
+                    .collect();
+                generic_args.push((kw::SelfUpper, item_name));
+
+                let args = FormatArgs {
+                    this: String::new(),
+                    trait_sugared: String::new(),
+                    item_context: "",
+                    generic_args,
+                };
+                (
+                    directive.message.as_ref().map(|e| e.1.format(&args)),
+                    directive.label.as_ref().map(|e| e.1.format(&args)),
+                    directive.notes.iter().map(|e| e.format(&args)).collect(),
+                )
+            } else {
+                (None, None, ThinVec::new())
+            };
+
             let mut err = self.cannot_act_on_moved_value(
                 span,
                 desired_action.as_noun(),
@@ -146,8 +180,13 @@ pub(crate) fn report_use_of_moved_or_uninitialized(
                     moved_place,
                     DescribePlaceOpt { including_downcast: true, including_tuple_field: true },
                 ),
+                on_move_message,
             );
 
+            for note in on_move_notes {
+                err.note(note);
+            }
+
             let reinit_spans = maybe_reinitialized_locations
                 .iter()
                 .take(3)
@@ -275,12 +314,16 @@ pub(crate) fn report_use_of_moved_or_uninitialized(
             if needs_note {
                 if let Some(local) = place.as_local() {
                     let span = self.body.local_decls[local].source_info.span;
-                    err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
-                        is_partial_move,
-                        ty,
-                        place: &note_msg,
-                        span,
-                    });
+                    if let Some(on_move_label) = on_move_label {
+                        err.span_label(span, on_move_label);
+                    } else {
+                        err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
+                            is_partial_move,
+                            ty,
+                            place: &note_msg,
+                            span,
+                        });
+                    }
                 } else {
                     err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Note {
                         is_partial_move,
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 3a2f548902d1..d74450e67cf1 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1587,6 +1587,7 @@ pub fn is_stable_diagnostic_attribute(sym: Symbol, features: &Features) -> bool
     match sym {
         sym::on_unimplemented | sym::do_not_recommend => true,
         sym::on_const => features.diagnostic_on_const(),
+        sym::on_move => features.diagnostic_on_move(),
         _ => false,
     }
 }
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 39e886227d94..18e03d94a997 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -470,6 +470,8 @@ pub fn internal(&self, feature: Symbol) -> bool {
     (unstable, derive_from, "1.91.0", Some(144889)),
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
     (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
+    /// Allows giving on-move borrowck custom diagnostic messages for a type
+    (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(150935)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index e8476c3d8c73..deb22fcaa269 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -1180,13 +1180,18 @@ pub enum AttributeKind {
         directive: Option<Box<Directive>>,
     },
 
+    /// Represents `#[diagnostic::on_move]`
+    OnMove {
+        span: Span,
+        directive: Option<Box<Directive>>,
+    },
+
     /// Represents `#[rustc_on_unimplemented]` and `#[diagnostic::on_unimplemented]`.
     OnUnimplemented {
         span: Span,
         /// None if the directive was malformed in some way.
         directive: Option<Box<Directive>>,
     },
-
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 27128f699637..c19fc6976c6e 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -77,6 +77,7 @@ pub fn encode_cross_crate(&self) -> EncodeCrossCrate {
             NoStd(..) => No,
             NonExhaustive(..) => Yes, // Needed for rustdoc
             OnConst { .. } => Yes,
+            OnMove { .. } => Yes,
             OnUnimplemented { .. } => Yes,
             Optimize(..) => No,
             PanicRuntime => No,
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 458553fa747c..c282eb34cf4d 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -498,6 +498,18 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             &AttributeLintKind::MissingOptionsForOnConst => {
                 lints::MissingOptionsForOnConstAttr.into_diag(dcx, level)
             }
+            &AttributeLintKind::MalformedOnMoveAttr { span } => {
+                lints::MalformedOnMoveAttrLint { span }.into_diag(dcx, level)
+            }
+            &AttributeLintKind::OnMoveMalformedFormatLiterals { name } => {
+                lints::OnMoveMalformedFormatLiterals { name }.into_diag(dcx, level)
+            }
+            &AttributeLintKind::OnMoveMalformedAttrExpectedLiteralOrDelimiter => {
+                lints::OnMoveMalformedAttrExpectedLiteralOrDelimiter.into_diag(dcx, level)
+            }
+            &AttributeLintKind::MissingOptionsForOnMove => {
+                lints::MissingOptionsForOnMoveAttr.into_diag(dcx, level)
+            }
         }
     }
 }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index d8b62e81b0cb..02448035216e 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3953,6 +3953,11 @@ pub(crate) struct IgnoredDiagnosticOption {
 #[help("at least one of the `message`, `note` and `label` options are expected")]
 pub(crate) struct MissingOptionsForOnConstAttr;
 
+#[derive(Diagnostic)]
+#[diag("missing options for `on_move` attribute")]
+#[help("at least one of the `message`, `note` and `label` options are expected")]
+pub(crate) struct MissingOptionsForOnMoveAttr;
+
 #[derive(Diagnostic)]
 #[diag("malformed `on_unimplemented` attribute")]
 #[help("only `message`, `note` and `label` are allowed as options")]
@@ -3973,3 +3978,27 @@ pub(crate) struct MalformedOnConstAttrLint {
 #[diag("`Eq::assert_receiver_is_total_eq` should never be implemented by hand")]
 #[note("this method was used to add checks to the `Eq` derive macro")]
 pub(crate) struct EqInternalMethodImplemented;
+
+#[derive(Diagnostic)]
+#[diag("unknown or malformed `on_move` attribute")]
+#[help(
+    "only `message`, `note` and `label` are allowed as options. Their values must be string literals"
+)]
+pub(crate) struct MalformedOnMoveAttrLint {
+    #[label("invalid option found here")]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("unknown parameter `{$name}`")]
+#[help("expect `Self` as format argument")]
+pub(crate) struct OnMoveMalformedFormatLiterals {
+    pub name: Symbol,
+}
+
+#[derive(Diagnostic)]
+#[diag("expected a literal or missing delimiter")]
+#[help(
+    "only literals are allowed as values for the `message`, `note` and `label` options. These options must be separated by a comma"
+)]
+pub(crate) struct OnMoveMalformedAttrExpectedLiteralOrDelimiter;
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 1492df50a418..ef7067b25baa 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -840,6 +840,9 @@ pub enum AttributeLintKind {
     MalformedOnConstAttr {
         span: Span,
     },
+    MalformedOnMoveAttr {
+        span: Span,
+    },
     MalformedDiagnosticFormat {
         warning: FormatWarning,
     },
@@ -855,6 +858,11 @@ pub enum AttributeLintKind {
     },
     MissingOptionsForOnUnimplemented,
     MissingOptionsForOnConst,
+    MissingOptionsForOnMove,
+    OnMoveMalformedFormatLiterals {
+        name: Symbol,
+    },
+    OnMoveMalformedAttrExpectedLiteralOrDelimiter,
 }
 
 #[derive(Debug, Clone, HashStable_Generic)]
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index bec6ab7e8355..e495088c5564 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -74,6 +74,10 @@ struct DiagnosticOnConstOnlyForNonConstTraitImpls {
     item_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[diagnostic::on_move]` can only be applied to enums, structs or unions")]
+struct DiagnosticOnMoveOnlyForAdt;
+
 fn target_from_impl_item<'tcx>(tcx: TyCtxt<'tcx>, impl_item: &hir::ImplItem<'_>) -> Target {
     match impl_item.kind {
         hir::ImplItemKind::Const(..) => Target::AssocConst,
@@ -233,6 +237,9 @@ fn check_attributes(
                 Attribute::Parsed(AttributeKind::DoNotRecommend{attr_span}) => {self.check_do_not_recommend(*attr_span, hir_id, target, item)},
                 Attribute::Parsed(AttributeKind::OnUnimplemented{span, directive}) => {self.check_diagnostic_on_unimplemented(*span, hir_id, target,directive.as_deref())},
                 Attribute::Parsed(AttributeKind::OnConst{span, ..}) => {self.check_diagnostic_on_const(*span, hir_id, target, item)}
+                Attribute::Parsed(AttributeKind::OnMove { span, directive }) => {
+                    self.check_diagnostic_on_move(*span, hir_id, target, directive.as_deref())
+                },
                 Attribute::Parsed(
                     // tidy-alphabetical-start
                     AttributeKind::RustcAllowIncoherentImpl(..)
@@ -684,6 +691,56 @@ fn check_diagnostic_on_const(
         // The traits' or the impls'?
     }
 
+    /// Checks if `#[diagnostic::on_move]` is applied to an ADT definition
+    fn check_diagnostic_on_move(
+        &self,
+        attr_span: Span,
+        hir_id: HirId,
+        target: Target,
+        directive: Option<&Directive>,
+    ) {
+        if !matches!(target, Target::Enum | Target::Struct | Target::Union) {
+            self.tcx.emit_node_span_lint(
+                MISPLACED_DIAGNOSTIC_ATTRIBUTES,
+                hir_id,
+                attr_span,
+                DiagnosticOnMoveOnlyForAdt,
+            );
+        }
+
+        if let Some(directive) = directive {
+            if let Node::Item(Item {
+                kind:
+                    ItemKind::Struct(_, generics, _)
+                    | ItemKind::Enum(_, generics, _)
+                    | ItemKind::Union(_, generics, _),
+                ..
+            }) = self.tcx.hir_node(hir_id)
+            {
+                directive.visit_params(&mut |argument_name, span| {
+                    let has_generic = generics.params.iter().any(|p| {
+                        if !matches!(p.kind, GenericParamKind::Lifetime { .. })
+                            && let ParamName::Plain(name) = p.name
+                            && name.name == argument_name
+                        {
+                            true
+                        } else {
+                            false
+                        }
+                    });
+                    if !has_generic {
+                        self.tcx.emit_node_span_lint(
+                            MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+                            hir_id,
+                            span,
+                            errors::OnMoveMalformedFormatLiterals { name: argument_name },
+                        )
+                    }
+                });
+            }
+        }
+    }
+
     /// Checks if an `#[inline]` is applied to a function or a closure.
     fn check_inline(&self, hir_id: HirId, attr_span: Span, kind: &InlineAttr, target: Target) {
         match target {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 7c7698ac3bb8..de3b2e96f6dd 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1434,3 +1434,10 @@ pub(crate) struct UnknownFormatParameterForOnUnimplementedAttr {
     #[help(r#"expect either a generic argument name or {"`{Self}`"} as format argument"#)]
     pub help: bool,
 }
+
+#[derive(Diagnostic)]
+#[diag("unknown parameter `{$name}`")]
+#[help(r#"expect either a generic argument name or {"`{Self}`"} as format argument"#)]
+pub(crate) struct OnMoveMalformedFormatLiterals {
+    pub name: Symbol,
+}
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 551d89ee6022..54bca9be5765 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -707,7 +707,7 @@ fn smart_resolve_macro_path(
         }
 
         const DIAG_ATTRS: &[Symbol] =
-            &[sym::on_unimplemented, sym::do_not_recommend, sym::on_const];
+            &[sym::on_unimplemented, sym::do_not_recommend, sym::on_const, sym::on_move];
 
         if res == Res::NonMacroAttr(NonMacroAttrKind::Tool)
             && let [namespace, attribute, ..] = &*path.segments
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 257ac3f51c2c..1e59ff33f8dc 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -797,6 +797,7 @@
         diagnostic,
         diagnostic_namespace,
         diagnostic_on_const,
+        diagnostic_on_move,
         dialect,
         direct,
         discriminant_kind,
@@ -1406,6 +1407,7 @@
         omit_gdb_pretty_printer_section,
         on,
         on_const,
+        on_move,
         on_unimplemented,
         opaque,
         opaque_generic_const_args,
diff --git a/tests/ui/diagnostic_namespace/on_move/auxiliary/other.rs b/tests/ui/diagnostic_namespace/on_move/auxiliary/other.rs
new file mode 100644
index 000000000000..6cff8f4a19b5
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/auxiliary/other.rs
@@ -0,0 +1,8 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo",
+    label = "Bar",
+)]
+#[derive(Debug)]
+pub struct Foo;
diff --git a/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.rs b/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.rs
new file mode 100644
index 000000000000..69c61e62cfc6
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.rs
@@ -0,0 +1,14 @@
+//@ aux-build:other.rs
+
+extern crate other;
+
+use other::Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.stderr b/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.stderr
new file mode 100644
index 000000000000..8cfe8d6af3f6
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/error_is_shown_in_downstream_crates.stderr
@@ -0,0 +1,21 @@
+error[E0382]: Foo
+  --> $DIR/error_is_shown_in_downstream_crates.rs:12:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/error_is_shown_in_downstream_crates.rs:7:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/on_move_simple.rs b/tests/ui/diagnostic_namespace/on_move/on_move_simple.rs
new file mode 100644
index 000000000000..e6112e783bd1
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/on_move_simple.rs
@@ -0,0 +1,17 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo",
+    label = "Bar",
+)]
+#[derive(Debug)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/on_move_simple.stderr b/tests/ui/diagnostic_namespace/on_move/on_move_simple.stderr
new file mode 100644
index 000000000000..483ff5a407bb
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/on_move_simple.stderr
@@ -0,0 +1,29 @@
+error[E0382]: Foo
+  --> $DIR/on_move_simple.rs:15:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/on_move_simple.rs:10:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/on_move_simple.rs:8:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/on_move_with_format.rs b/tests/ui/diagnostic_namespace/on_move/on_move_with_format.rs
new file mode 100644
index 000000000000..f2025c2b2271
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/on_move_with_format.rs
@@ -0,0 +1,32 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo for {Self}",
+    label = "Bar for {Self}",
+)]
+#[derive(Debug)]
+struct Foo;
+
+#[diagnostic::on_move(
+    message="Foo for {X}",
+    label="Bar for {X}",
+)]
+struct MyType<X> {
+    _x: X,
+}
+
+fn takes_foo(_: Foo) {}
+
+fn takes_mytype<X>(_: MyType<X>) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo for Foo
+
+    let mytype = MyType { _x: 0 };
+    takes_mytype(mytype);
+    let baz = mytype;
+    //~^ERROR Foo for i32
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/on_move_with_format.stderr b/tests/ui/diagnostic_namespace/on_move/on_move_with_format.stderr
new file mode 100644
index 000000000000..6868f1571be8
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/on_move_with_format.stderr
@@ -0,0 +1,55 @@
+error[E0382]: Foo for Foo
+  --> $DIR/on_move_with_format.rs:25:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar for Foo
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/on_move_with_format.rs:18:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/on_move_with_format.rs:8:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error[E0382]: Foo for i32
+  --> $DIR/on_move_with_format.rs:30:15
+   |
+LL |     let mytype = MyType { _x: 0 };
+   |         ------ Bar for i32
+LL |     takes_mytype(mytype);
+   |                  ------ value moved here
+LL |     let baz = mytype;
+   |               ^^^^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_mytype` to borrow instead if owning the value isn't necessary
+  --> $DIR/on_move_with_format.rs:20:23
+   |
+LL | fn takes_mytype<X>(_: MyType<X>) {}
+   |    ------------       ^^^^^^^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `MyType<i32>` implemented `Clone`, you could clone the value
+  --> $DIR/on_move_with_format.rs:14:1
+   |
+LL | struct MyType<X> {
+   | ^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_mytype(mytype);
+   |                  ------ you could clone this value
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.rs
new file mode 100644
index 000000000000..1af3daf0f315
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.rs
@@ -0,0 +1,22 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "first message",
+    label = "first label",
+)]
+#[diagnostic::on_move(
+    message = "second message",
+    //~^ WARN `message` is ignored due to previous definition of `message` [malformed_diagnostic_attributes]
+    label = "second label",
+    //~^ WARN `label` is ignored due to previous definition of `label` [malformed_diagnostic_attributes]
+)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR first message
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.stderr
new file mode 100644
index 000000000000..f02f97014981
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_duplicated_options.stderr
@@ -0,0 +1,49 @@
+warning: `message` is ignored due to previous definition of `message`
+  --> $DIR/report_warning_on_duplicated_options.rs:8:5
+   |
+LL |     message = "first message",
+   |     ------------------------- `message` is first declared here
+...
+LL |     message = "second message",
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `message` is later redundantly declared here
+   |
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+warning: `label` is ignored due to previous definition of `label`
+  --> $DIR/report_warning_on_duplicated_options.rs:10:5
+   |
+LL |     label = "first label",
+   |     --------------------- `label` is first declared here
+...
+LL |     label = "second label",
+   |     ^^^^^^^^^^^^^^^^^^^^^^ `label` is later redundantly declared here
+
+error[E0382]: first message
+  --> $DIR/report_warning_on_duplicated_options.rs:20:15
+   |
+LL |     let foo = Foo;
+   |         --- first label
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_duplicated_options.rs:15:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_duplicated_options.rs:13:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 2 warnings emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.rs
new file mode 100644
index 000000000000..f403ad1ff480
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.rs
@@ -0,0 +1,18 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo {Baz}",
+    //~^WARN unknown parameter `Baz`
+    label = "Bar",
+)]
+#[derive(Debug)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.stderr
new file mode 100644
index 000000000000..efb43c3562a4
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_formats.stderr
@@ -0,0 +1,38 @@
+warning: unknown parameter `Baz`
+  --> $DIR/report_warning_on_invalid_formats.rs:4:21
+   |
+LL |     message = "Foo {Baz}",
+   |                     ^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+   = note: `#[warn(malformed_diagnostic_format_literals)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: Foo {Baz}
+  --> $DIR/report_warning_on_invalid_formats.rs:16:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_invalid_formats.rs:11:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_invalid_formats.rs:9:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.rs
new file mode 100644
index 000000000000..2050403210d5
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.rs
@@ -0,0 +1,14 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move = "foo"]
+//~^WARN missing options for `on_move` attribute [malformed_diagnostic_attributes]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR use of moved value: `foo`
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.stderr
new file mode 100644
index 000000000000..39992b02e580
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_invalid_meta_item_syntax.stderr
@@ -0,0 +1,38 @@
+warning: missing options for `on_move` attribute
+  --> $DIR/report_warning_on_invalid_meta_item_syntax.rs:3:1
+   |
+LL | #[diagnostic::on_move = "foo"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: at least one of the `message`, `note` and `label` options are expected
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: use of moved value: `foo`
+  --> $DIR/report_warning_on_invalid_meta_item_syntax.rs:12:15
+   |
+LL |     let foo = Foo;
+   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_invalid_meta_item_syntax.rs:7:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_invalid_meta_item_syntax.rs:5:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.rs
new file mode 100644
index 000000000000..b5bb103d3f27
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.rs
@@ -0,0 +1,18 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+//~^ WARN expected a literal or missing delimiter [malformed_diagnostic_attributes]
+//~| HELP only literals are allowed as values for the `message`, `note` and `label` options. These options must be separated by a comma
+    message = "Foo"
+    label = "Bar",
+)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR use of moved value: `foo`
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.stderr
new file mode 100644
index 000000000000..00d0657bfcbd
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_delimiters.stderr
@@ -0,0 +1,44 @@
+warning: expected a literal or missing delimiter
+  --> $DIR/report_warning_on_malformed_options_without_delimiters.rs:3:22
+   |
+LL |   #[diagnostic::on_move(
+   |  ______________________^
+LL | |
+LL | |
+LL | |     message = "Foo"
+LL | |     label = "Bar",
+LL | | )]
+   | |_^
+   |
+   = help: only literals are allowed as values for the `message`, `note` and `label` options. These options must be separated by a comma
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: use of moved value: `foo`
+  --> $DIR/report_warning_on_malformed_options_without_delimiters.rs:16:15
+   |
+LL |     let foo = Foo;
+   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_malformed_options_without_delimiters.rs:11:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_malformed_options_without_delimiters.rs:9:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.rs
new file mode 100644
index 000000000000..c676b87ad857
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.rs
@@ -0,0 +1,18 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+//~^ WARN expected a literal or missing delimiter [malformed_diagnostic_attributes]
+//~| HELP only literals are allowed as values for the `message`, `note` and `label` options. These options must be separated by a comma
+    message = Foo,
+    label = "Bar",
+)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR use of moved value: `foo`
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.stderr
new file mode 100644
index 000000000000..6dc230b68c5f
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_malformed_options_without_literals.stderr
@@ -0,0 +1,44 @@
+warning: expected a literal or missing delimiter
+  --> $DIR/report_warning_on_malformed_options_without_literals.rs:3:22
+   |
+LL |   #[diagnostic::on_move(
+   |  ______________________^
+LL | |
+LL | |
+LL | |     message = Foo,
+LL | |     label = "Bar",
+LL | | )]
+   | |_^
+   |
+   = help: only literals are allowed as values for the `message`, `note` and `label` options. These options must be separated by a comma
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: use of moved value: `foo`
+  --> $DIR/report_warning_on_malformed_options_without_literals.rs:16:15
+   |
+LL |     let foo = Foo;
+   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_malformed_options_without_literals.rs:11:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_malformed_options_without_literals.rs:9:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.rs
new file mode 100644
index 000000000000..e5603fd24ec9
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.rs
@@ -0,0 +1,14 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move]
+//~^WARN missing options for `on_move` attribute [malformed_diagnostic_attributes]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR use of moved value: `foo`
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.stderr
new file mode 100644
index 000000000000..f4e6d69faecb
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_missing_options.stderr
@@ -0,0 +1,38 @@
+warning: missing options for `on_move` attribute
+  --> $DIR/report_warning_on_missing_options.rs:3:1
+   |
+LL | #[diagnostic::on_move]
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: at least one of the `message`, `note` and `label` options are expected
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: use of moved value: `foo`
+  --> $DIR/report_warning_on_missing_options.rs:12:15
+   |
+LL |     let foo = Foo;
+   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_missing_options.rs:7:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_missing_options.rs:5:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.rs
new file mode 100644
index 000000000000..33e78ea5fc1f
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.rs
@@ -0,0 +1,23 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo",
+    label = "Bar",
+)]
+struct Foo;
+
+#[diagnostic::on_move(
+//~^WARN `#[diagnostic::on_move]` can only be applied to enums, structs or unions
+    message = "Foo",
+    label = "Bar",
+)]
+trait MyTrait {}
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.stderr
new file mode 100644
index 000000000000..29c987fba48f
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_non_adt.stderr
@@ -0,0 +1,41 @@
+warning: `#[diagnostic::on_move]` can only be applied to enums, structs or unions
+  --> $DIR/report_warning_on_non_adt.rs:9:1
+   |
+LL | / #[diagnostic::on_move(
+LL | |
+LL | |     message = "Foo",
+LL | |     label = "Bar",
+LL | | )]
+   | |__^
+   |
+   = note: `#[warn(misplaced_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: Foo
+  --> $DIR/report_warning_on_non_adt.rs:21:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_non_adt.rs:16:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_non_adt.rs:7:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.rs b/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.rs
new file mode 100644
index 000000000000..651f6184cfac
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.rs
@@ -0,0 +1,19 @@
+#![feature(diagnostic_on_move)]
+
+#[diagnostic::on_move(
+    message = "Foo",
+    label = "Bar",
+    baz="Baz"
+    //~^WARN unknown or malformed `on_move` attribute
+    //~|HELP only `message`, `note` and `label` are allowed as options. Their values must be string literals
+)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR Foo
+}
diff --git a/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.stderr b/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.stderr
new file mode 100644
index 000000000000..a09b8a96d2d1
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_move/report_warning_on_unknown_options.stderr
@@ -0,0 +1,38 @@
+warning: unknown or malformed `on_move` attribute
+  --> $DIR/report_warning_on_unknown_options.rs:6:5
+   |
+LL |     baz="Baz"
+   |     ^^^^^^^^^ invalid option found here
+   |
+   = help: only `message`, `note` and `label` are allowed as options. Their values must be string literals
+   = note: `#[warn(malformed_diagnostic_attributes)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+error[E0382]: Foo
+  --> $DIR/report_warning_on_unknown_options.rs:17:15
+   |
+LL |     let foo = Foo;
+   |         --- Bar
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/report_warning_on_unknown_options.rs:12:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/report_warning_on_unknown_options.rs:10:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/feature-gates/feature-gate-diagnostic-on-move.rs b/tests/ui/feature-gates/feature-gate-diagnostic-on-move.rs
new file mode 100644
index 000000000000..a1f3b1fbbc86
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-diagnostic-on-move.rs
@@ -0,0 +1,18 @@
+//! This is an unusual feature gate test, as it doesn't test the feature
+//! gate, but the fact that not adding the feature gate will cause the
+//! diagnostic to not emit the custom diagnostic message
+//!
+#[diagnostic::on_move(
+    message = "Foo"
+)]
+#[derive(Debug)]
+struct Foo;
+
+fn takes_foo(_: Foo) {}
+
+fn main() {
+    let foo = Foo;
+    takes_foo(foo);
+    let bar = foo;
+    //~^ERROR use of moved value: `foo`
+}
diff --git a/tests/ui/feature-gates/feature-gate-diagnostic-on-move.stderr b/tests/ui/feature-gates/feature-gate-diagnostic-on-move.stderr
new file mode 100644
index 000000000000..9ba6f272cf92
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-diagnostic-on-move.stderr
@@ -0,0 +1,29 @@
+error[E0382]: use of moved value: `foo`
+  --> $DIR/feature-gate-diagnostic-on-move.rs:16:15
+   |
+LL |     let foo = Foo;
+   |         --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL |     takes_foo(foo);
+   |               --- value moved here
+LL |     let bar = foo;
+   |               ^^^ value used here after move
+   |
+note: consider changing this parameter type in function `takes_foo` to borrow instead if owning the value isn't necessary
+  --> $DIR/feature-gate-diagnostic-on-move.rs:11:17
+   |
+LL | fn takes_foo(_: Foo) {}
+   |    ---------    ^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/feature-gate-diagnostic-on-move.rs:9:1
+   |
+LL | struct Foo;
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     takes_foo(foo);
+   |               --- you could clone this value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.

From 99e1940adb9083a012aa4e651555c794cc22994f Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Wed, 11 Mar 2026 11:47:43 -0400
Subject: [PATCH 0356/1059] Show named lifetime in closure upvar diagnostics
 instead of synthetic '1

---
 .../src/diagnostics/region_name.rs            | 120 ++++++++++++++++++
 .../borrowck/closure-upvar-named-lifetime.rs  |  41 ++++++
 .../closure-upvar-named-lifetime.stderr       | 116 +++++++++++++++++
 3 files changed, 277 insertions(+)
 create mode 100644 tests/ui/borrowck/closure-upvar-named-lifetime.rs
 create mode 100644 tests/ui/borrowck/closure-upvar-named-lifetime.stderr

diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index fba0879e8133..9f65052643e5 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -372,6 +372,119 @@ fn give_name_from_error_region(&self, fr: RegionVid) -> Option<RegionName> {
         }
     }
 
+    /// For closure/coroutine upvar regions, attempts to find a named lifetime
+    /// from the parent function's signature that corresponds to the anonymous
+    /// region `fr`. This handles cases where a parent function's named lifetime
+    /// (like `'a`) appears in a captured variable's type but gets assigned a
+    /// separate `RegionVid` without an `external_name` during region renumbering.
+    ///
+    /// Works by getting the parent function's parameter type (with real named
+    /// lifetimes via `liberate_late_bound_regions`), then structurally walking
+    /// both the parent's parameter type and the closure's upvar type to find
+    /// where `fr` appears and what named lifetime is at the same position.
+    #[instrument(level = "trace", skip(self))]
+    fn give_name_if_we_can_match_upvar_args(
+        &self,
+        fr: RegionVid,
+        upvar_index: usize,
+    ) -> Option<RegionName> {
+        let tcx = self.infcx.tcx;
+        let defining_ty = self.regioncx.universal_regions().defining_ty;
+
+        let closure_def_id = match defining_ty {
+            DefiningTy::Closure(def_id, _)
+            | DefiningTy::Coroutine(def_id, _)
+            | DefiningTy::CoroutineClosure(def_id, _) => def_id,
+            _ => return None,
+        };
+
+        let parent_def_id = tcx.parent(closure_def_id);
+
+        // Only works if the parent is a function with a fn_sig.
+        if !matches!(tcx.def_kind(parent_def_id), DefKind::Fn | DefKind::AssocFn) {
+            return None;
+        }
+
+        // Find which parameter index this upvar corresponds to by matching
+        // the captured variable's HirId against the parent's parameter patterns.
+        // This only matches simple bindings (not destructuring patterns) and
+        // only when the upvar is a direct parameter (not a local variable).
+        let captured_place = self.upvars.get(upvar_index)?;
+        let upvar_hir_id = captured_place.get_root_variable();
+        let parent_local_def_id = parent_def_id.as_local()?;
+        let parent_body = tcx.hir_body_owned_by(parent_local_def_id);
+        let param_index =
+            parent_body.params.iter().position(|param| param.pat.hir_id == upvar_hir_id)?;
+
+        // Get the parent fn's signature with liberated late-bound regions,
+        // so we have `ReLateParam` instead of `ReBound`.
+        let parent_fn_sig = tcx.fn_sig(parent_def_id).instantiate_identity();
+        let liberated_sig = tcx.liberate_late_bound_regions(parent_def_id, parent_fn_sig);
+        let parent_param_ty = *liberated_sig.inputs().get(param_index)?;
+
+        // Get the upvar's NLL type (with ReVar regions from renumbering).
+        let upvar_nll_ty = *defining_ty.upvar_tys().get(upvar_index)?;
+
+        debug!(
+            "give_name_if_we_can_match_upvar_args: parent_param_ty={:?}, upvar_nll_ty={:?}",
+            parent_param_ty, upvar_nll_ty
+        );
+
+        // Collect free regions from both types in structural order.
+        // This only works when both types have the same structure, i.e.
+        // the upvar captures the whole variable, not a partial place like
+        // `x.field`. Bail out if the region counts differ, since that means
+        // the types diverged and positional correspondence is unreliable.
+        let mut parent_regions = vec![];
+        tcx.for_each_free_region(&parent_param_ty, |r| parent_regions.push(r));
+
+        let mut nll_regions = vec![];
+        tcx.for_each_free_region(&upvar_nll_ty, |r| nll_regions.push(r));
+
+        if parent_regions.len() != nll_regions.len() {
+            debug!(
+                "give_name_if_we_can_match_upvar_args: region count mismatch ({} vs {})",
+                parent_regions.len(),
+                nll_regions.len()
+            );
+            return None;
+        }
+
+        for (parent_r, nll_r) in iter::zip(&parent_regions, &nll_regions) {
+            if nll_r.as_var() == fr {
+                match parent_r.kind() {
+                    ty::ReLateParam(late_param) => {
+                        if let Some(name) = late_param.kind.get_name(tcx) {
+                            let span = late_param
+                                .kind
+                                .get_id()
+                                .and_then(|id| tcx.hir_span_if_local(id))
+                                .unwrap_or(DUMMY_SP);
+                            return Some(RegionName {
+                                name,
+                                source: RegionNameSource::NamedLateParamRegion(span),
+                            });
+                        }
+                    }
+                    ty::ReEarlyParam(ebr) => {
+                        if ebr.is_named() {
+                            let def_id =
+                                tcx.generics_of(parent_def_id).region_param(ebr, tcx).def_id;
+                            let span = tcx.hir_span_if_local(def_id).unwrap_or(DUMMY_SP);
+                            return Some(RegionName {
+                                name: ebr.name,
+                                source: RegionNameSource::NamedEarlyParamRegion(span),
+                            });
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        None
+    }
+
     /// Finds an argument that contains `fr` and label it with a fully
     /// elaborated type, returning something like `'1`. Result looks
     /// like:
@@ -644,6 +757,13 @@ fn try_match_adt_and_generic_args<'hir>(
     #[instrument(level = "trace", skip(self))]
     fn give_name_if_anonymous_region_appears_in_upvars(&self, fr: RegionVid) -> Option<RegionName> {
         let upvar_index = self.regioncx.get_upvar_index_for_region(self.infcx.tcx, fr)?;
+
+        // Before synthesizing an anonymous name like `'1`, try to find a
+        // named lifetime from the parent function's signature that matches.
+        if let Some(region_name) = self.give_name_if_we_can_match_upvar_args(fr, upvar_index) {
+            return Some(region_name);
+        }
+
         let (upvar_name, upvar_span) = self.regioncx.get_upvar_name_and_span_for_region(
             self.infcx.tcx,
             self.upvars,
diff --git a/tests/ui/borrowck/closure-upvar-named-lifetime.rs b/tests/ui/borrowck/closure-upvar-named-lifetime.rs
new file mode 100644
index 000000000000..a0ce192201b1
--- /dev/null
+++ b/tests/ui/borrowck/closure-upvar-named-lifetime.rs
@@ -0,0 +1,41 @@
+// Regression test for #153545.
+//
+// When a closure captures a variable whose type involves a named
+// lifetime from the parent function, diagnostics should use the
+// actual lifetime name (e.g., `'a`) instead of a synthetic name
+// like `'1`.
+
+use std::cell::RefCell;
+use std::sync::Arc;
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+
+fn apply<'a>(
+    f: Arc<dyn Fn(Entry<'a, String, String>) + 'a>,
+) -> impl Fn(RefCell<HashMap<String, String>>)
+{
+    move |map| {
+    //~^ ERROR hidden type for `impl Fn(RefCell<HashMap<String, String>>)` captures lifetime that does not appear in bounds
+        let value = map.borrow_mut().entry("foo".to_string());
+        //~^ ERROR `map` does not live long enough
+        //~| ERROR temporary value dropped while borrowed
+        let wrapped_value = value;
+        f(wrapped_value);
+    }
+}
+
+// Also test with Box instead of Arc, a simpler captured type.
+fn apply_box<'a>(
+    f: Box<dyn Fn(Entry<'a, String, String>) + 'a>,
+) -> impl Fn(RefCell<HashMap<String, String>>)
+{
+    move |map| {
+    //~^ ERROR hidden type for `impl Fn(RefCell<HashMap<String, String>>)` captures lifetime that does not appear in bounds
+        let value = map.borrow_mut().entry("foo".to_string());
+        //~^ ERROR `map` does not live long enough
+        //~| ERROR temporary value dropped while borrowed
+        f(value);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/borrowck/closure-upvar-named-lifetime.stderr b/tests/ui/borrowck/closure-upvar-named-lifetime.stderr
new file mode 100644
index 000000000000..fc7c59fa97c8
--- /dev/null
+++ b/tests/ui/borrowck/closure-upvar-named-lifetime.stderr
@@ -0,0 +1,116 @@
+error[E0597]: `map` does not live long enough
+  --> $DIR/closure-upvar-named-lifetime.rs:19:21
+   |
+LL | fn apply<'a>(
+   |          -- lifetime `'a` defined here
+...
+LL |     move |map| {
+   |           --- binding `map` declared here
+LL |
+LL |         let value = map.borrow_mut().entry("foo".to_string());
+   |                     ^^^ borrowed value does not live long enough
+...
+LL |         f(wrapped_value);
+   |         ---------------- argument requires that `map` is borrowed for `'a`
+LL |     }
+   |     - `map` dropped here while still borrowed
+   |
+note: requirement that the value outlives `'a` introduced here
+  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/closure-upvar-named-lifetime.rs:19:21
+   |
+LL | fn apply<'a>(
+   |          -- lifetime `'a` defined here
+...
+LL |         let value = map.borrow_mut().entry("foo".to_string());
+   |                     ^^^^^^^^^^^^^^^^                         - temporary value is freed at the end of this statement
+   |                     |
+   |                     creates a temporary value which is freed while still in use
+...
+LL |         f(wrapped_value);
+   |         ---------------- argument requires that borrow lasts for `'a`
+   |
+note: requirement that the value outlives `'a` introduced here
+  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
+
+error[E0700]: hidden type for `impl Fn(RefCell<HashMap<String, String>>)` captures lifetime that does not appear in bounds
+  --> $DIR/closure-upvar-named-lifetime.rs:17:5
+   |
+LL |   fn apply<'a>(
+   |            -- hidden type `{closure@$DIR/closure-upvar-named-lifetime.rs:17:5: 17:15}` captures the lifetime `'a` as defined here
+LL |       f: Arc<dyn Fn(Entry<'a, String, String>) + 'a>,
+LL |   ) -> impl Fn(RefCell<HashMap<String, String>>)
+   |        ----------------------------------------- opaque type defined here
+LL |   {
+LL | /     move |map| {
+LL | |
+LL | |         let value = map.borrow_mut().entry("foo".to_string());
+...  |
+LL | |         f(wrapped_value);
+LL | |     }
+   | |_____^
+   |
+help: add a `use<...>` bound to explicitly capture `'a`
+   |
+LL | ) -> impl Fn(RefCell<HashMap<String, String>>) + use<'a>
+   |                                                +++++++++
+
+error[E0597]: `map` does not live long enough
+  --> $DIR/closure-upvar-named-lifetime.rs:34:21
+   |
+LL | fn apply_box<'a>(
+   |              -- lifetime `'a` defined here
+...
+LL |     move |map| {
+   |           --- binding `map` declared here
+LL |
+LL |         let value = map.borrow_mut().entry("foo".to_string());
+   |                     ^^^ borrowed value does not live long enough
+...
+LL |         f(value);
+   |         -------- argument requires that `map` is borrowed for `'a`
+LL |     }
+   |     - `map` dropped here while still borrowed
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/closure-upvar-named-lifetime.rs:34:21
+   |
+LL | fn apply_box<'a>(
+   |              -- lifetime `'a` defined here
+...
+LL |         let value = map.borrow_mut().entry("foo".to_string());
+   |                     ^^^^^^^^^^^^^^^^                         - temporary value is freed at the end of this statement
+   |                     |
+   |                     creates a temporary value which is freed while still in use
+...
+LL |         f(value);
+   |         -------- argument requires that borrow lasts for `'a`
+
+error[E0700]: hidden type for `impl Fn(RefCell<HashMap<String, String>>)` captures lifetime that does not appear in bounds
+  --> $DIR/closure-upvar-named-lifetime.rs:32:5
+   |
+LL |   fn apply_box<'a>(
+   |                -- hidden type `{closure@$DIR/closure-upvar-named-lifetime.rs:32:5: 32:15}` captures the lifetime `'a` as defined here
+LL |       f: Box<dyn Fn(Entry<'a, String, String>) + 'a>,
+LL |   ) -> impl Fn(RefCell<HashMap<String, String>>)
+   |        ----------------------------------------- opaque type defined here
+LL |   {
+LL | /     move |map| {
+LL | |
+LL | |         let value = map.borrow_mut().entry("foo".to_string());
+...  |
+LL | |         f(value);
+LL | |     }
+   | |_____^
+   |
+help: add a `use<...>` bound to explicitly capture `'a`
+   |
+LL | ) -> impl Fn(RefCell<HashMap<String, String>>) + use<'a>
+   |                                                +++++++++
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0597, E0700, E0716.
+For more information about an error, try `rustc --explain E0597`.

From 84a2d2a92c1f3c9f79cf632eaf2d6498e031dec5 Mon Sep 17 00:00:00 2001
From: Paul Murphy <murp@redhat.com>
Date: Tue, 10 Feb 2026 15:27:00 -0600
Subject: [PATCH 0357/1059] Pass -pg to linker when using -Zinstrument-mcount

Clang and gcc use this option to control linking behavior too. Some
targets need to be linked against a special crt which enables
profiling at runtime.

This makes using gprof a little easier with Rust binaries. Otherwise,
rustc must be passed `-Clink-args=-pg` to ensure the correct startup
code is linked.
---
 compiler/rustc_codegen_ssa/src/back/link.rs   |  4 ++++
 compiler/rustc_codegen_ssa/src/back/linker.rs |  7 +++++++
 .../instrument-mcount-link-pg/main.rs         |  3 +++
 .../instrument-mcount-link-pg/rmake.rs        | 19 +++++++++++++++++++
 4 files changed, 33 insertions(+)
 create mode 100644 tests/run-make/instrument-mcount-link-pg/main.rs
 create mode 100644 tests/run-make/instrument-mcount-link-pg/rmake.rs

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 56dca6c8b902..29ae1548b743 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -2767,6 +2767,10 @@ fn add_order_independent_options(
         cmd.pgo_gen();
     }
 
+    if sess.opts.unstable_opts.instrument_mcount {
+        cmd.enable_profiling();
+    }
+
     if sess.opts.cg.control_flow_guard != CFGuard::Disabled {
         cmd.control_flow_guard();
     }
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 3ace1a8c266c..55ee9b1b974a 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -352,6 +352,7 @@ fn add_eh_frame_header(&mut self) {}
     fn add_no_exec(&mut self) {}
     fn add_as_needed(&mut self) {}
     fn reset_per_library_state(&mut self) {}
+    fn enable_profiling(&mut self) {}
 }
 
 impl dyn Linker + '_ {
@@ -732,6 +733,12 @@ fn pgo_gen(&mut self) {
         self.link_or_cc_args(&["-u", "__llvm_profile_runtime"]);
     }
 
+    fn enable_profiling(&mut self) {
+        // This flag is also used when linking to choose target specific
+        // libraries needed to enable profiling.
+        self.cc_arg("-pg");
+    }
+
     fn control_flow_guard(&mut self) {}
 
     fn ehcont_guard(&mut self) {}
diff --git a/tests/run-make/instrument-mcount-link-pg/main.rs b/tests/run-make/instrument-mcount-link-pg/main.rs
new file mode 100644
index 000000000000..47ad8c634112
--- /dev/null
+++ b/tests/run-make/instrument-mcount-link-pg/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello World!");
+}
diff --git a/tests/run-make/instrument-mcount-link-pg/rmake.rs b/tests/run-make/instrument-mcount-link-pg/rmake.rs
new file mode 100644
index 000000000000..184bd9429bfd
--- /dev/null
+++ b/tests/run-make/instrument-mcount-link-pg/rmake.rs
@@ -0,0 +1,19 @@
+// When building a binary instrumented with mcount, verify the
+// binary is linked with the correct crt to enable profiling.
+//
+//@ only-gnu
+//@ ignore-cross-compile
+
+use run_make_support::{path, run, rustc};
+
+fn main() {
+    // Compile instrumentation enabled binary, and verify -pg is passed
+    let link_args =
+        rustc().input("main.rs").arg("-Zinstrument-mcount").print("link-args").run().stdout_utf8();
+    assert!(link_args.contains("\"-pg\""));
+
+    // Run it, and verify gmon.out is created
+    assert!(!path("gmon.out").exists());
+    run("main");
+    assert!(path("gmon.out").exists());
+}

From e2923eb86a18b2e288e88605a61c21fcc38f8c82 Mon Sep 17 00:00:00 2001
From: James Kay <twey@twey.co.uk>
Date: Wed, 11 Mar 2026 16:49:12 +0000
Subject: [PATCH 0358/1059] `std`: don't depend on `dlmalloc` when `cfg(unix)`

---
 library/std/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 740d37617547..7a8ccdbc5043 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -62,7 +62,7 @@ path = "../windows_link"
 rand = { version = "0.9.0", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.4.0"
 
-[target.'cfg(any(all(target_family = "wasm", not(target_os = "wasi")), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
+[target.'cfg(any(all(target_family = "wasm", not(any(unix, target_os = "wasi"))), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
 dlmalloc = { version = "0.2.10", features = ['rustc-dep-of-std'] }
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]

From c909ae5a35dc6ebaae7324f16d008e4196b1936a Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Wed, 11 Mar 2026 18:26:49 +0000
Subject: [PATCH 0359/1059] add test that an incomplete feature emits a warning

---
 compiler/rustc_feature/src/unstable.rs             |  2 ++
 compiler/rustc_span/src/symbol.rs                  |  1 +
 tests/ui/feature-gates/incomplete-features.rs      | 13 +++++++++++++
 .../feature-gates/incomplete-features.warn.stderr  | 14 ++++++++++++++
 4 files changed, 30 insertions(+)
 create mode 100644 tests/ui/feature-gates/incomplete-features.rs
 create mode 100644 tests/ui/feature-gates/incomplete-features.warn.stderr

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 39e886227d94..ebb912ed90d0 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -257,6 +257,8 @@ pub fn internal(&self, feature: Symbol) -> bool {
     (internal, rustc_attrs, "1.0.0", None),
     /// Allows using the `#[stable]` and `#[unstable]` attributes.
     (internal, staged_api, "1.0.0", None),
+    /// Perma-unstable, only used to test the `incomplete_features` lint.
+    (incomplete, test_incomplete_feature, "CURRENT_RUSTC_VERSION", None),
     /// Added for testing unstable lints; perma-unstable.
     (internal, test_unstable_lint, "1.60.0", None),
     /// Use for stable + negative coherence and strict coherence depending on trait's
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 257ac3f51c2c..7e4c80df3f7c 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2005,6 +2005,7 @@
         test_2018_feature,
         test_accepted_feature,
         test_case,
+        test_incomplete_feature,
         test_removed_feature,
         test_runner,
         test_unstable_lint,
diff --git a/tests/ui/feature-gates/incomplete-features.rs b/tests/ui/feature-gates/incomplete-features.rs
new file mode 100644
index 000000000000..7f8f1a46ebcb
--- /dev/null
+++ b/tests/ui/feature-gates/incomplete-features.rs
@@ -0,0 +1,13 @@
+//! Make sure that incomplete features emit the `incomplete_features` lint.
+
+// gate-test-test_incomplete_feature
+
+//@ check-pass
+//@ revisions: warn expect
+
+#![cfg_attr(warn, warn(incomplete_features))]
+#![cfg_attr(expect, expect(incomplete_features))]
+
+#![feature(test_incomplete_feature)] //[warn]~ WARN the feature `test_incomplete_feature` is incomplete
+
+fn main() {}
diff --git a/tests/ui/feature-gates/incomplete-features.warn.stderr b/tests/ui/feature-gates/incomplete-features.warn.stderr
new file mode 100644
index 000000000000..7dda9f3648da
--- /dev/null
+++ b/tests/ui/feature-gates/incomplete-features.warn.stderr
@@ -0,0 +1,14 @@
+warning: the feature `test_incomplete_feature` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/incomplete-features.rs:11:12
+   |
+LL | #![feature(test_incomplete_feature)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/incomplete-features.rs:8:24
+   |
+LL | #![cfg_attr(warn, warn(incomplete_features))]
+   |                        ^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+

From db26b5b8e01a621417e08a7609f4216b6768ad43 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 11 Mar 2026 18:07:27 -0500
Subject: [PATCH 0360/1059] editorconfig: css uses tabs

---
 .editorconfig | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.editorconfig b/.editorconfig
index 6c8560aa1f54..d2d788d2172f 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -12,6 +12,9 @@ trim_trailing_whitespace = true
 indent_style = space
 indent_size = 4
 
+[*.css]
+indent_style = tab
+
 # some tests need trailing whitespace in output snapshots
 [tests/**]
 trim_trailing_whitespace = false

From 858b82da3b62b44ce0ee9d24fa29dea640f793c8 Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Sun, 8 Mar 2026 22:37:03 -0400
Subject: [PATCH 0361/1059] Simplify find_attr! for HirId usage

Add a HasAttrs<'tcx, Tcx> trait to rustc_hir that allows find_attr! to
accept DefId, LocalDefId, OwnerId, and HirId directly, instead of
requiring callers to manually fetch the attribute slice first.

The trait is defined in rustc_hir with a generic Tcx parameter to avoid
a dependency cycle (rustc_hir cannot depend on rustc_middle). The four
concrete impls for TyCtxt are in rustc_middle.
---
 .../src/const_eval/fn_queries.rs              |  2 +-
 compiler/rustc_hir/src/attrs/mod.rs           | 26 +++++++++++-----
 compiler/rustc_hir_typeck/src/loops.rs        |  4 +--
 .../rustc_interface/src/proc_macro_decls.rs   |  2 +-
 compiler/rustc_middle/src/ty/mod.rs           | 30 +++++++++++++++++++
 compiler/rustc_mir_build/src/builder/mod.rs   |  2 +-
 compiler/rustc_mir_build/src/thir/cx/expr.rs  |  4 +--
 compiler/rustc_mir_build/src/thir/cx/mod.rs   |  2 +-
 .../clippy_lints/src/functions/must_use.rs    |  6 ++--
 .../clippy_lints/src/incompatible_msrv.rs     |  2 +-
 .../clippy_lints/src/manual_non_exhaustive.rs |  4 +--
 .../clippy_lints/src/methods/is_empty.rs      |  2 +-
 src/tools/clippy/clippy_utils/src/lib.rs      |  6 ++--
 13 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
index ad4c9aa5ff9b..0b5065f12f80 100644
--- a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
@@ -37,7 +37,7 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Constness {
             }
         }
         Node::TraitItem(ti @ TraitItem { kind: TraitItemKind::Fn(..), .. }) => {
-            if find_attr!(tcx.hir_attrs(ti.hir_id()), RustcNonConstTraitMethod) {
+            if find_attr!(tcx, ti.hir_id(), RustcNonConstTraitMethod) {
                 Constness::NotConst
             } else {
                 tcx.trait_def(tcx.local_parent(def_id)).constness
diff --git a/compiler/rustc_hir/src/attrs/mod.rs b/compiler/rustc_hir/src/attrs/mod.rs
index 09fa144a1604..b3c1deaa48fa 100644
--- a/compiler/rustc_hir/src/attrs/mod.rs
+++ b/compiler/rustc_hir/src/attrs/mod.rs
@@ -13,6 +13,15 @@
 mod encode_cross_crate;
 mod pretty_printing;
 
+/// A trait for types that can provide a list of attributes given a `TyCtxt`.
+///
+/// It allows `find_attr!` to accept either a `DefId`, `LocalDefId`, `OwnerId`, or `HirId`.
+/// It is defined here with a generic `Tcx` because `rustc_hir` can't depend on `rustc_middle`.
+/// The concrete implementations are in `rustc_middle`.
+pub trait HasAttrs<'tcx, Tcx> {
+    fn get_attrs(self, tcx: &Tcx) -> &'tcx [crate::Attribute];
+}
+
 /// Finds attributes in sequences of attributes by pattern matching.
 ///
 /// A little like `matches` but for attributes.
@@ -34,10 +43,12 @@
 ///
 /// As a convenience, this macro can do that for you!
 ///
-/// Instead of providing an attribute list, provide the `tcx` and a `DefId`.
+/// Instead of providing an attribute list, provide the `tcx` and an id
+/// (a `DefId`, `LocalDefId`, `OwnerId` or `HirId`).
 ///
 /// ```rust,ignore (illustrative)
 /// find_attr!(tcx, def_id, <pattern>)
+/// find_attr!(tcx, hir_id, <pattern>)
 /// ```
 ///
 /// Another common case is finding attributes applied to the root of the current crate.
@@ -55,13 +66,14 @@ macro_rules! find_attr {
         $crate::find_attr!($tcx.hir_krate_attrs(), $pattern $(if $guard)? => $e)
     };
 
-    ($tcx: expr, $def_id: expr, $pattern: pat $(if $guard: expr)?) => {
-        $crate::find_attr!($tcx, $def_id, $pattern $(if $guard)? => ()).is_some()
+    ($tcx: expr, $id: expr, $pattern: pat $(if $guard: expr)?) => {
+        $crate::find_attr!($tcx, $id, $pattern $(if $guard)? => ()).is_some()
     };
-    ($tcx: expr, $def_id: expr, $pattern: pat $(if $guard: expr)? => $e: expr) => {{
-        #[allow(deprecated)] {
-            $crate::find_attr!($tcx.get_all_attrs($def_id), $pattern $(if $guard)? => $e)
-        }
+    ($tcx: expr, $id: expr, $pattern: pat $(if $guard: expr)? => $e: expr) => {{
+        $crate::find_attr!(
+            $crate::attrs::HasAttrs::get_attrs($id, &$tcx),
+            $pattern $(if $guard)? => $e
+        )
     }};
 
 
diff --git a/compiler/rustc_hir_typeck/src/loops.rs b/compiler/rustc_hir_typeck/src/loops.rs
index e77c93641e1a..21b408064fac 100644
--- a/compiler/rustc_hir_typeck/src/loops.rs
+++ b/compiler/rustc_hir_typeck/src/loops.rs
@@ -207,7 +207,7 @@ fn visit_expr(&mut self, e: &'hir hir::Expr<'hir>) {
                 };
 
                 // A `#[const_continue]` must break to a block in a `#[loop_match]`.
-                if find_attr!(self.tcx.hir_attrs(e.hir_id), ConstContinue(_)) {
+                if find_attr!(self.tcx, e.hir_id, ConstContinue(_)) {
                     let Some(label) = break_destination.label else {
                         let span = e.span;
                         self.tcx.dcx().emit_fatal(ConstContinueBadLabel { span });
@@ -420,7 +420,7 @@ fn is_loop_match(
         e: &'hir hir::Expr<'hir>,
         body: &'hir hir::Block<'hir>,
     ) -> Option<Destination> {
-        if !find_attr!(self.tcx.hir_attrs(e.hir_id), LoopMatch(_)) {
+        if !find_attr!(self.tcx, e.hir_id, LoopMatch(_)) {
             return None;
         }
 
diff --git a/compiler/rustc_interface/src/proc_macro_decls.rs b/compiler/rustc_interface/src/proc_macro_decls.rs
index 63fed51b020a..eb60c61b0af7 100644
--- a/compiler/rustc_interface/src/proc_macro_decls.rs
+++ b/compiler/rustc_interface/src/proc_macro_decls.rs
@@ -7,7 +7,7 @@ fn proc_macro_decls_static(tcx: TyCtxt<'_>, (): ()) -> Option<LocalDefId> {
     let mut decls = None;
 
     for id in tcx.hir_free_items() {
-        if find_attr!(tcx.hir_attrs(id.hir_id()), RustcProcMacroDecls) {
+        if find_attr!(tcx, id.hir_id(), RustcProcMacroDecls) {
             decls = Some(id.owner_id.def_id);
         }
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 6abe7d146699..282d566a4a94 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2199,6 +2199,36 @@ pub fn fn_abi_of_instance(
     }
 }
 
+// `HasAttrs` impls: allow `find_attr!(tcx, id, ...)` to work with both DefId-like types and HirId.
+
+impl<'tcx> hir::attrs::HasAttrs<'tcx, TyCtxt<'tcx>> for DefId {
+    fn get_attrs(self, tcx: &TyCtxt<'tcx>) -> &'tcx [hir::Attribute] {
+        if let Some(did) = self.as_local() {
+            tcx.hir_attrs(tcx.local_def_id_to_hir_id(did))
+        } else {
+            tcx.attrs_for_def(self)
+        }
+    }
+}
+
+impl<'tcx> hir::attrs::HasAttrs<'tcx, TyCtxt<'tcx>> for LocalDefId {
+    fn get_attrs(self, tcx: &TyCtxt<'tcx>) -> &'tcx [hir::Attribute] {
+        tcx.hir_attrs(tcx.local_def_id_to_hir_id(self))
+    }
+}
+
+impl<'tcx> hir::attrs::HasAttrs<'tcx, TyCtxt<'tcx>> for hir::OwnerId {
+    fn get_attrs(self, tcx: &TyCtxt<'tcx>) -> &'tcx [hir::Attribute] {
+        hir::attrs::HasAttrs::get_attrs(self.def_id, tcx)
+    }
+}
+
+impl<'tcx> hir::attrs::HasAttrs<'tcx, TyCtxt<'tcx>> for hir::HirId {
+    fn get_attrs(self, tcx: &TyCtxt<'tcx>) -> &'tcx [hir::Attribute] {
+        tcx.hir_attrs(self)
+    }
+}
+
 pub fn provide(providers: &mut Providers) {
     closure::provide(providers);
     context::provide(providers);
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index bcac45199437..01c1e2e79b50 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -491,7 +491,7 @@ fn construct_fn<'tcx>(
     };
 
     if let Some((dialect, phase)) =
-        find_attr!(tcx.hir_attrs(fn_id), CustomMir(dialect, phase, _) => (dialect, phase))
+        find_attr!(tcx, fn_id, CustomMir(dialect, phase, _) => (dialect, phase))
     {
         return custom::build_custom_mir(
             tcx,
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index c5eeb8b1aa85..b868fa7984b6 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -873,7 +873,7 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
             hir::ExprKind::Ret(v) => ExprKind::Return { value: v.map(|v| self.mirror_expr(v)) },
             hir::ExprKind::Become(call) => ExprKind::Become { value: self.mirror_expr(call) },
             hir::ExprKind::Break(dest, ref value) => {
-                if find_attr!(self.tcx.hir_attrs(expr.hir_id), ConstContinue(_)) {
+                if find_attr!(self.tcx, expr.hir_id, ConstContinue(_)) {
                     match dest.target_id {
                         Ok(target_id) => {
                             let (Some(value), Some(_)) = (value, dest.label) else {
@@ -938,7 +938,7 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
                 match_source,
             },
             hir::ExprKind::Loop(body, ..) => {
-                if find_attr!(self.tcx.hir_attrs(expr.hir_id), LoopMatch(_)) {
+                if find_attr!(self.tcx, expr.hir_id, LoopMatch(_)) {
                     let dcx = self.tcx.dcx();
 
                     // Accept either `state = expr` or `state = expr;`.
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 60cb509ee9dd..e3bba5d2f935 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -104,7 +104,7 @@ fn new(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
             typing_env: ty::TypingEnv::non_body_analysis(tcx, def),
             typeck_results,
             body_owner: def.to_def_id(),
-            apply_adjustments: !find_attr!(tcx.hir_attrs(hir_id), CustomMir(..) => ()).is_some(),
+            apply_adjustments: !find_attr!(tcx, hir_id, CustomMir(..)),
         }
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/functions/must_use.rs b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
index 04c657104fe1..7c1b3ef225c6 100644
--- a/src/tools/clippy/clippy_lints/src/functions/must_use.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
@@ -24,7 +24,7 @@
 
 pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     let attrs = cx.tcx.hir_attrs(item.hir_id());
-    let attr = find_attr!(cx.tcx.hir_attrs(item.hir_id()), MustUse { span, reason } => (span, reason));
+    let attr = find_attr!(cx.tcx, item.hir_id(), MustUse { span, reason } => (span, reason));
     if let hir::ItemKind::Fn {
         ref sig,
         body: ref body_id,
@@ -65,7 +65,7 @@ pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Imp
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         let attrs = cx.tcx.hir_attrs(item.hir_id());
-        let attr = find_attr!(cx.tcx.hir_attrs(item.hir_id()), MustUse { span, reason } => (span, reason));
+        let attr = find_attr!(cx.tcx, item.hir_id(), MustUse { span, reason } => (span, reason));
         if let Some((attr_span, reason)) = attr {
             check_needless_must_use(
                 cx,
@@ -98,7 +98,7 @@ pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Tr
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
 
         let attrs = cx.tcx.hir_attrs(item.hir_id());
-        let attr = find_attr!(cx.tcx.hir_attrs(item.hir_id()), MustUse { span, reason } => (span, reason));
+        let attr = find_attr!(cx.tcx, item.hir_id(), MustUse { span, reason } => (span, reason));
         if let Some((attr_span, reason)) = attr {
             check_needless_must_use(
                 cx,
diff --git a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
index ad81810b58cb..1ae8198a432d 100644
--- a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
+++ b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
@@ -269,5 +269,5 @@ fn check_ty(&mut self, cx: &LateContext<'tcx>, hir_ty: &'tcx hir::Ty<'tcx, Ambig
 fn is_under_cfg_attribute(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     cx.tcx
         .hir_parent_id_iter(hir_id)
-        .any(|id| find_attr!(cx.tcx.hir_attrs(id), CfgTrace(..) | CfgAttrTrace))
+        .any(|id| find_attr!(cx.tcx, id, CfgTrace(..) | CfgAttrTrace))
 }
diff --git a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
index 9ababe87f9de..703c9137d543 100644
--- a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
@@ -92,7 +92,7 @@ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
                         .then_some((v.def_id, v.span))
                 });
                 if let Ok((id, span)) = iter.exactly_one()
-                    && !find_attr!(cx.tcx.hir_attrs(item.hir_id()), NonExhaustive(..))
+                    && !find_attr!(cx.tcx, item.hir_id(), NonExhaustive(..))
                 {
                     self.potential_enums.push((item.owner_id.def_id, id, item.span, span));
                 }
@@ -113,7 +113,7 @@ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
                         "this seems like a manual implementation of the non-exhaustive pattern",
                         |diag| {
                             if let Some(non_exhaustive_span) =
-                                find_attr!(cx.tcx.hir_attrs(item.hir_id()), NonExhaustive(span) => *span)
+                                find_attr!(cx.tcx, item.hir_id(), NonExhaustive(span) => *span)
                             {
                                 diag.span_note(non_exhaustive_span, "the struct is already non-exhaustive");
                             } else {
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
index 4577be34d4a7..cfda39ed08ff 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
@@ -39,7 +39,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
 fn is_under_cfg(cx: &LateContext<'_>, id: HirId) -> bool {
     cx.tcx
         .hir_parent_id_iter(id)
-        .any(|id| find_attr!(cx.tcx.hir_attrs(id), CfgTrace(..)))
+        .any(|id| find_attr!(cx.tcx, id, CfgTrace(..)))
 }
 
 /// Similar to [`clippy_utils::expr_or_init`], but does not go up the chain if the initialization
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 1e73e43e0a71..ac66b1e5338d 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -1710,7 +1710,7 @@ pub fn has_attr(attrs: &[hir::Attribute], symbol: Symbol) -> bool {
 }
 
 pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    find_attr!(cx.tcx.hir_attrs(hir_id), Repr { .. })
+    find_attr!(cx.tcx, hir_id, Repr { .. })
 }
 
 pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
@@ -2362,7 +2362,7 @@ fn with_test_item_names(tcx: TyCtxt<'_>, module: LocalModDefId, f: impl FnOnce(&
                     && let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
                     // We could also check for the type name `test::TestDescAndFn`
                     && let Res::Def(DefKind::Struct, _) = path.res
-                    && find_attr!(tcx.hir_attrs(item.hir_id()), RustcTestMarker(..))
+                    && find_attr!(tcx, item.hir_id(), RustcTestMarker(..))
                 {
                     names.push(ident.name);
                 }
@@ -2420,7 +2420,7 @@ pub fn is_test_function(tcx: TyCtxt<'_>, fn_def_id: LocalDefId) -> bool {
 /// This only checks directly applied attributes, to see if a node is inside a `#[cfg(test)]` parent
 /// use [`is_in_cfg_test`]
 pub fn is_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
-    if let Some(cfgs) = find_attr!(tcx.hir_attrs(id), CfgTrace(cfgs) => cfgs)
+    if let Some(cfgs) = find_attr!(tcx, id, CfgTrace(cfgs) => cfgs)
         && cfgs
             .iter()
             .any(|(cfg, _)| matches!(cfg, CfgEntry::NameValue { name: sym::test, .. }))

From 5e305ab74dee728f17b833d620cc7832685c4804 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 12 Mar 2026 02:05:08 +0100
Subject: [PATCH 0362/1059] sembr src/backend/updating-llvm.md

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index fb340342502a..56fa49ef2a2e 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -7,9 +7,11 @@ Rust supports building against multiple LLVM versions:
   PRs for such fixes are tagged with `llvm-main`.
 * The latest released major version is always supported.
 * The one or two preceding major versions are usually supported in the sense that they are expected
-  to build successfully and pass most tests. However, fixes for miscompilations often do not get
+  to build successfully and pass most tests.
+  However, fixes for miscompilations often do not get
   backported to past LLVM versions, so using rustc with older versions of LLVM comes with an
-  increased risk of soundness bugs. We strongly recommend using the latest version of LLVM.
+  increased risk of soundness bugs.
+  We strongly recommend using the latest version of LLVM.
 
 By default, Rust uses its own fork in the [rust-lang/llvm-project repository].
 This fork is based on a `release/$N.x` branch of the upstream project, where

From 5de87cd04af71d5f8893f14f88a2baf8358cacef Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 12 Mar 2026 02:08:20 +0100
Subject: [PATCH 0363/1059] sembr src/diagnostics/translation.md

---
 src/doc/rustc-dev-guide/src/diagnostics/translation.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/diagnostics/translation.md b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
index cf95727e2a67..a22ede5e9c3b 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/translation.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
@@ -31,8 +31,7 @@ There are two ways of writing translatable diagnostics:
    ("Simple" diagnostics being those that don't require a lot of logic in
    deciding to emit subdiagnostics and can therefore be represented as diagnostic structs).
    See [the diagnostic and subdiagnostic structs documentation](./diagnostic-structs.md).
-2. Using typed identifiers with `Diag` APIs (in
-   `Diagnostic` or `Subdiagnostic` implementations).
+2. Using typed identifiers with `Diag` APIs (in `Diagnostic` or `Subdiagnostic` implementations).
 
 When adding or changing a translatable diagnostic,
 you don't need to worry about the translations.

From 7963b55d9a163103f60b67dd7db453f9a39fc24e Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 12 Mar 2026 02:09:02 +0100
Subject: [PATCH 0364/1059] sembr src/git.md

---
 src/doc/rustc-dev-guide/src/git.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/git.md b/src/doc/rustc-dev-guide/src/git.md
index 34e419fa5225..faa2d8f2a3a2 100644
--- a/src/doc/rustc-dev-guide/src/git.md
+++ b/src/doc/rustc-dev-guide/src/git.md
@@ -383,7 +383,9 @@ Both the upside and downside of this is that it simplifies the history.
 On the one hand, you lose track of the steps in which changes were made, but
 the history becomes easier to work with.
 
-The easiest way to squash your commits in a PR on the `rust-lang/rust` repository is to use the `@bors squash` command in a comment on the PR. By default, [bors] combines all commit messages of the PR into the squashed commit message. To customize the commit message, use `@bors squash msg=<commit message>`.
+The easiest way to squash your commits in a PR on the `rust-lang/rust` repository is to use the `@bors squash` command in a comment on the PR.
+By default, [bors] combines all commit messages of the PR into the squashed commit message.
+To customize the commit message, use `@bors squash msg=<commit message>`.
 
 
 If you want to squash commits using local git operations, read on below.

From 751562faf55a0734d27ebb17281926338b632829 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 12 Mar 2026 02:10:03 +0100
Subject: [PATCH 0365/1059] sembr src/tracing.md

---
 src/doc/rustc-dev-guide/src/tracing.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tracing.md b/src/doc/rustc-dev-guide/src/tracing.md
index 151670d08997..78a0fe4af2ff 100644
--- a/src/doc/rustc-dev-guide/src/tracing.md
+++ b/src/doc/rustc-dev-guide/src/tracing.md
@@ -14,8 +14,8 @@ of `tracing-subscriber`](https://docs.rs/tracing-subscriber/0.2.24/tracing_subsc
 
 ## Environment variables
 
-This is an overview of the environment variables rustc accepts to customize
-its tracing output. The definition of these can mostly be found in `compiler/rustc_log/src/lib.rs`.
+This is an overview of the environment variables rustc accepts to customize its tracing output.
+The definition of these can mostly be found in `compiler/rustc_log/src/lib.rs`.
 
 |  Name                     | Usage                                                                                                                   |
 | ------------------------- | ----------------------------------------------------------------------------------------------------------------------- |

From 9729bb2558d6e3a3e430304b18d7f5211ffc2427 Mon Sep 17 00:00:00 2001
From: Asuna <SpriteOvO@gmail.com>
Date: Wed, 11 Mar 2026 09:37:35 +0000
Subject: [PATCH 0366/1059] Add macro matcher for `guard` fragment specifier

---
 compiler/rustc_ast/src/ast.rs                 |  16 +-
 compiler/rustc_ast/src/token.rs               |   5 +
 compiler/rustc_ast/src/visit.rs               |   1 +
 compiler/rustc_ast_lowering/src/expr.rs       |   4 +-
 compiler/rustc_ast_lowering/src/pat.rs        |   7 +-
 compiler/rustc_ast_pretty/src/pprust/state.rs |   4 +-
 .../rustc_ast_pretty/src/pprust/state/expr.rs |   4 +-
 compiler/rustc_expand/src/mbe/macro_rules.rs  |  58 ++++-
 compiler/rustc_expand/src/mbe/transcribe.rs   |  16 +-
 compiler/rustc_feature/src/unstable.rs        |   2 +
 compiler/rustc_parse/src/parser/expr.rs       | 128 ++++++----
 compiler/rustc_parse/src/parser/mod.rs        |   1 +
 .../rustc_parse/src/parser/nonterminal.rs     |  10 +-
 compiler/rustc_parse/src/parser/pat.rs        |  28 ++-
 compiler/rustc_resolve/src/late.rs            |   4 +-
 compiler/rustc_span/src/symbol.rs             |   2 +
 .../clippy/clippy_utils/src/ast_utils/mod.rs  |   2 +-
 src/tools/rustfmt/src/matches.rs              |  10 +-
 .../feature-gate-macro-guard-matcher.rs       |   5 +
 .../feature-gate-macro-guard-matcher.stderr   |  13 +
 tests/ui/macros/macro-follow-rpass.rs         |   3 +-
 tests/ui/macros/macro-follow.rs               |   7 +-
 tests/ui/macros/macro-follow.stderr           | 238 ++++++++++--------
 tests/ui/macros/macro-guard-matcher.rs        |  17 ++
 tests/ui/macros/macro-guard-matcher.stderr    |  17 ++
 .../macros/macro-input-future-proofing.stderr |   6 +-
 ...-pat-pattern-followed-by-or-in-2021.stderr |   6 +-
 ...acro-pat2021-pattern-followed-by-or.stderr |   6 +-
 tests/ui/macros/stringify.rs                  |  17 ++
 29 files changed, 441 insertions(+), 196 deletions(-)
 create mode 100644 tests/ui/feature-gates/feature-gate-macro-guard-matcher.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-macro-guard-matcher.stderr
 create mode 100644 tests/ui/macros/macro-guard-matcher.rs
 create mode 100644 tests/ui/macros/macro-guard-matcher.stderr

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 74cc1ec17e6f..024624cd3bb8 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -938,7 +938,7 @@ pub enum PatKind {
     Never,
 
     /// A guard pattern (e.g., `x if guard(x)`).
-    Guard(Box<Pat>, Box<Expr>),
+    Guard(Box<Pat>, Box<Guard>),
 
     /// Parentheses in patterns used for grouping (i.e., `(PAT)`).
     Paren(Box<Pat>),
@@ -1346,7 +1346,7 @@ pub struct Arm {
     /// Match arm pattern, e.g. `10` in `match foo { 10 => {}, _ => {} }`.
     pub pat: Box<Pat>,
     /// Match arm guard, e.g. `n > 10` in `match foo { n if n > 10 => {}, _ => {} }`.
-    pub guard: Option<Box<Expr>>,
+    pub guard: Option<Box<Guard>>,
     /// Match arm body. Omitted if the pattern is a never pattern.
     pub body: Option<Box<Expr>>,
     pub span: Span,
@@ -3954,6 +3954,18 @@ impl ConstBlockItem {
     pub const IDENT: Ident = Ident { name: kw::Underscore, span: DUMMY_SP };
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct Guard {
+    pub cond: Expr,
+    pub span_with_leading_if: Span,
+}
+
+impl Guard {
+    pub fn span(&self) -> Span {
+        self.cond.span
+    }
+}
+
 // Adding a new variant? Please update `test_item` in `tests/ui/macros/stringify.rs`.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index f82513094aa1..62ec06358517 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -94,6 +94,7 @@ pub enum MetaVarKind {
     },
     Path,
     Vis,
+    Guard,
     TT,
 }
 
@@ -114,6 +115,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             MetaVarKind::Meta { .. } => sym::meta,
             MetaVarKind::Path => sym::path,
             MetaVarKind::Vis => sym::vis,
+            MetaVarKind::Guard => sym::guard,
             MetaVarKind::TT => sym::tt,
         };
         write!(f, "{sym}")
@@ -1124,6 +1126,7 @@ pub enum NonterminalKind {
     Meta,
     Path,
     Vis,
+    Guard,
     TT,
 }
 
@@ -1161,6 +1164,7 @@ pub fn from_symbol(
             sym::meta => NonterminalKind::Meta,
             sym::path => NonterminalKind::Path,
             sym::vis => NonterminalKind::Vis,
+            sym::guard => NonterminalKind::Guard,
             sym::tt => NonterminalKind::TT,
             _ => return None,
         })
@@ -1182,6 +1186,7 @@ fn symbol(self) -> Symbol {
             NonterminalKind::Meta => sym::meta,
             NonterminalKind::Path => sym::path,
             NonterminalKind::Vis => sym::vis,
+            NonterminalKind::Guard => sym::guard,
             NonterminalKind::TT => sym::tt,
         }
     }
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index bdf290f9a9e6..6aa8d5f38ad2 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -442,6 +442,7 @@ pub fn ctxt(&self) -> Option<FnCtxt> {
             FormatArguments,
             FormatPlaceholder,
             GenericParamKind,
+            Guard,
             Impl,
             ImplPolarity,
             Inline,
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 305df4065196..35a74a63b8e4 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -639,7 +639,7 @@ fn wrap_in_try_constructor(
 
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
         let pat = self.lower_pat(&arm.pat);
-        let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond));
+        let guard = arm.guard.as_ref().map(|guard| self.lower_expr(&guard.cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
         self.lower_attrs(hir_id, &arm.attrs, arm.span, Target::Arm);
@@ -662,7 +662,7 @@ fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
             } else if let Some(body) = &arm.body {
                 self.dcx().emit_err(NeverPatternWithBody { span: body.span });
             } else if let Some(g) = &arm.guard {
-                self.dcx().emit_err(NeverPatternWithGuard { span: g.span });
+                self.dcx().emit_err(NeverPatternWithGuard { span: g.span() });
             }
 
             // We add a fake `loop {}` arm body so that it typecks to `!`. The mir lowering of never
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index c1c13977e103..3aadf09597ee 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -133,8 +133,11 @@ fn lower_pat_mut(&mut self, mut pattern: &Pat) -> hir::Pat<'hir> {
                             self.lower_range_end(end, e2.is_some()),
                         );
                     }
-                    PatKind::Guard(inner, cond) => {
-                        break hir::PatKind::Guard(self.lower_pat(inner), self.lower_expr(cond));
+                    PatKind::Guard(inner, guard) => {
+                        break hir::PatKind::Guard(
+                            self.lower_pat(inner),
+                            self.lower_expr(&guard.cond),
+                        );
                     }
                     PatKind::Slice(pats) => break self.lower_pat_slice(pats),
                     PatKind::Rest => {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 4ba5dc541342..1f07ee71c420 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1889,12 +1889,12 @@ fn print_pat(&mut self, pat: &ast::Pat) {
                     self.print_expr(e, FixupContext::default());
                 }
             }
-            PatKind::Guard(subpat, condition) => {
+            PatKind::Guard(subpat, guard) => {
                 self.popen();
                 self.print_pat(subpat);
                 self.space();
                 self.word_space("if");
-                self.print_expr(condition, FixupContext::default());
+                self.print_expr(&guard.cond, FixupContext::default());
                 self.pclose();
             }
             PatKind::Slice(elts) => {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 9b4ff2b63bd4..f6db4cdef722 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -880,9 +880,9 @@ fn print_arm(&mut self, arm: &ast::Arm) {
         self.print_outer_attributes(&arm.attrs);
         self.print_pat(&arm.pat);
         self.space();
-        if let Some(e) = &arm.guard {
+        if let Some(guard) = &arm.guard {
             self.word_space("if");
-            self.print_expr(e, FixupContext::default());
+            self.print_expr(&guard.cond, FixupContext::default());
             self.space();
         }
 
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 7ff49e040f6f..82d941a289e0 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -724,7 +724,7 @@ pub fn compile_declarative_macro(
             let args = p.parse_token_tree();
             check_args_parens(sess, sym::attr, &args);
             let args = parse_one_tt(args, RulePart::Pattern, sess, node_id, features, edition);
-            check_emission(check_lhs(sess, node_id, &args));
+            check_emission(check_lhs(sess, features, node_id, &args));
             if let Some(guar) = check_no_eof(sess, &p, "expected macro attr body") {
                 return dummy_syn_ext(guar);
             }
@@ -773,7 +773,7 @@ pub fn compile_declarative_macro(
         };
         let lhs_tt = p.parse_token_tree();
         let lhs_tt = parse_one_tt(lhs_tt, RulePart::Pattern, sess, node_id, features, edition);
-        check_emission(check_lhs(sess, node_id, &lhs_tt));
+        check_emission(check_lhs(sess, features, node_id, &lhs_tt));
         if let Err(e) = p.expect(exp!(FatArrow)) {
             return dummy_syn_ext(e.emit());
         }
@@ -870,21 +870,27 @@ fn check_args_empty(sess: &Session, args: &tokenstream::TokenTree) -> Result<(),
     }
 }
 
-fn check_lhs(sess: &Session, node_id: NodeId, lhs: &mbe::TokenTree) -> Result<(), ErrorGuaranteed> {
-    let e1 = check_lhs_nt_follows(sess, node_id, lhs);
+fn check_lhs(
+    sess: &Session,
+    features: &Features,
+    node_id: NodeId,
+    lhs: &mbe::TokenTree,
+) -> Result<(), ErrorGuaranteed> {
+    let e1 = check_lhs_nt_follows(sess, features, node_id, lhs);
     let e2 = check_lhs_no_empty_seq(sess, slice::from_ref(lhs));
     e1.and(e2)
 }
 
 fn check_lhs_nt_follows(
     sess: &Session,
+    features: &Features,
     node_id: NodeId,
     lhs: &mbe::TokenTree,
 ) -> Result<(), ErrorGuaranteed> {
     // lhs is going to be like TokenTree::Delimited(...), where the
     // entire lhs is those tts. Or, it can be a "bare sequence", not wrapped in parens.
     if let mbe::TokenTree::Delimited(.., delimited) = lhs {
-        check_matcher(sess, node_id, &delimited.tts)
+        check_matcher(sess, features, node_id, &delimited.tts)
     } else {
         let msg = "invalid macro matcher; matchers must be contained in balanced delimiters";
         Err(sess.dcx().span_err(lhs.span(), msg))
@@ -989,12 +995,13 @@ fn check_rhs(sess: &Session, rhs: &mbe::TokenTree) -> Result<(), ErrorGuaranteed
 
 fn check_matcher(
     sess: &Session,
+    features: &Features,
     node_id: NodeId,
     matcher: &[mbe::TokenTree],
 ) -> Result<(), ErrorGuaranteed> {
     let first_sets = FirstSets::new(matcher);
     let empty_suffix = TokenSet::empty();
-    check_matcher_core(sess, node_id, &first_sets, matcher, &empty_suffix)?;
+    check_matcher_core(sess, features, node_id, &first_sets, matcher, &empty_suffix)?;
     Ok(())
 }
 
@@ -1331,6 +1338,7 @@ fn add_all(&mut self, other: &Self) {
 // see `FirstSets::new`.
 fn check_matcher_core<'tt>(
     sess: &Session,
+    features: &Features,
     node_id: NodeId,
     first_sets: &FirstSets<'tt>,
     matcher: &'tt [mbe::TokenTree],
@@ -1369,6 +1377,17 @@ fn check_matcher_core<'tt>(
             | TokenTree::MetaVar(..)
             | TokenTree::MetaVarDecl { .. }
             | TokenTree::MetaVarExpr(..) => {
+                if let TokenTree::MetaVarDecl { kind: NonterminalKind::Guard, .. } = token
+                    && !features.macro_guard_matcher()
+                {
+                    feature_err(
+                        sess,
+                        sym::macro_guard_matcher,
+                        token.span(),
+                        "`guard` fragments in macro are unstable",
+                    )
+                    .emit();
+                }
                 if token_can_be_followed_by_any(token) {
                     // don't need to track tokens that work with any,
                     last.replace_with_irrelevant();
@@ -1385,7 +1404,7 @@ fn check_matcher_core<'tt>(
                     d.delim.as_close_token_kind(),
                     span.close,
                 ));
-                check_matcher_core(sess, node_id, first_sets, &d.tts, &my_suffix)?;
+                check_matcher_core(sess, features, node_id, first_sets, &d.tts, &my_suffix)?;
                 // don't track non NT tokens
                 last.replace_with_irrelevant();
 
@@ -1417,7 +1436,14 @@ fn check_matcher_core<'tt>(
                 // At this point, `suffix_first` is built, and
                 // `my_suffix` is some TokenSet that we can use
                 // for checking the interior of `seq_rep`.
-                let next = check_matcher_core(sess, node_id, first_sets, &seq_rep.tts, my_suffix)?;
+                let next = check_matcher_core(
+                    sess,
+                    features,
+                    node_id,
+                    first_sets,
+                    &seq_rep.tts,
+                    my_suffix,
+                )?;
                 if next.maybe_empty {
                     last.add_all(&next);
                 } else {
@@ -1609,7 +1635,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
                 }
             }
             NonterminalKind::Pat(PatParam { .. }) => {
-                const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`|`", "`if`", "`in`"];
+                const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`|`", "`if`", "`if let`", "`in`"];
                 match tok {
                     TokenTree::Token(token) => match token.kind {
                         FatArrow | Comma | Eq | Or => IsInFollow::Yes,
@@ -1618,11 +1644,12 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
                         }
                         _ => IsInFollow::No(TOKENS),
                     },
+                    TokenTree::MetaVarDecl { kind: NonterminalKind::Guard, .. } => IsInFollow::Yes,
                     _ => IsInFollow::No(TOKENS),
                 }
             }
             NonterminalKind::Pat(PatWithOr) => {
-                const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`if`", "`in`"];
+                const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`if`", "`if let`", "`in`"];
                 match tok {
                     TokenTree::Token(token) => match token.kind {
                         FatArrow | Comma | Eq => IsInFollow::Yes,
@@ -1631,6 +1658,17 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
                         }
                         _ => IsInFollow::No(TOKENS),
                     },
+                    TokenTree::MetaVarDecl { kind: NonterminalKind::Guard, .. } => IsInFollow::Yes,
+                    _ => IsInFollow::No(TOKENS),
+                }
+            }
+            NonterminalKind::Guard => {
+                const TOKENS: &[&str] = &["`=>`", "`,`", "`{`"];
+                match tok {
+                    TokenTree::Token(token) => match token.kind {
+                        FatArrow | Comma | OpenBrace => IsInFollow::Yes,
+                        _ => IsInFollow::No(TOKENS),
+                    },
                     _ => IsInFollow::No(TOKENS),
                 }
             }
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 09f006c3de57..dcf2cd1fa36a 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -12,7 +12,8 @@
 use rustc_session::parse::ParseSess;
 use rustc_span::hygiene::{LocalExpnId, Transparency};
 use rustc_span::{
-    Ident, MacroRulesNormalizedIdent, Span, Symbol, SyntaxContext, sym, with_metavar_spans,
+    BytePos, Ident, MacroRulesNormalizedIdent, Span, Symbol, SyntaxContext, kw, sym,
+    with_metavar_spans,
 };
 use smallvec::{SmallVec, smallvec};
 
@@ -556,6 +557,19 @@ fn transcribe_pnr<'tx>(
         ParseNtResult::Vis(vis) => {
             mk_delimited(vis.span, MetaVarKind::Vis, TokenStream::from_ast(vis))
         }
+        ParseNtResult::Guard(guard) => {
+            // FIXME(macro_guard_matcher):
+            // Perhaps it would be better to treat the leading `if` as part of `ast::Guard` during parsing?
+            // Currently they are separate, but in macros we match and emit the leading `if` for `:guard` matchers, which creates some inconsistency.
+
+            let leading_if_span =
+                guard.span_with_leading_if.with_hi(guard.span_with_leading_if.lo() + BytePos(2));
+            let mut ts =
+                TokenStream::token_alone(token::Ident(kw::If, IdentIsRaw::No), leading_if_span);
+            ts.push_stream(TokenStream::from_ast(&guard.cond));
+
+            mk_delimited(guard.span_with_leading_if, MetaVarKind::Guard, ts)
+        }
     };
 
     tscx.result.push(tt);
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 39e886227d94..b5db4e20d0d3 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -565,6 +565,8 @@ pub fn internal(&self, feature: Symbol) -> bool {
     (unstable, macro_attr, "1.91.0", Some(143547)),
     /// Allow `macro_rules!` derive rules
     (unstable, macro_derive, "1.91.0", Some(143549)),
+    /// Allow `$x:guard` matcher in macros
+    (unstable, macro_guard_matcher, "CURRENT_RUSTC_VERSION", Some(153104)),
     /// Give access to additional metadata about declarative macro meta-variables.
     (unstable, macro_metavar_expr, "1.61.0", Some(83527)),
     /// Provides a way to concatenate identifiers using metavariable expressions.
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index adfc68f4bb22..79f370bb828c 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -15,8 +15,8 @@
 use rustc_ast::{
     self as ast, AnonConst, Arm, AssignOp, AssignOpKind, AttrStyle, AttrVec, BinOp, BinOpKind,
     BlockCheckMode, CaptureBy, ClosureBinder, DUMMY_NODE_ID, Expr, ExprField, ExprKind, FnDecl,
-    FnRetTy, Label, MacCall, MetaItemLit, MgcaDisambiguation, Movability, Param, RangeLimits,
-    StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
+    FnRetTy, Guard, Label, MacCall, MetaItemLit, MgcaDisambiguation, Movability, Param,
+    RangeLimits, StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::{Applicability, Diag, PResult, StashKey, Subdiagnostic};
@@ -2762,7 +2762,7 @@ pub fn parse_expr_cond(
 
     /// Parses a `let $pat = $expr` pseudo-expression.
     fn parse_expr_let(&mut self, restrictions: Restrictions) -> PResult<'a, Box<Expr>> {
-        let recovered = if !restrictions.contains(Restrictions::ALLOW_LET) {
+        let recovered: Recovered = if !restrictions.contains(Restrictions::ALLOW_LET) {
             let err = errors::ExpectedExpressionFoundLet {
                 span: self.token.span,
                 reason: errors::ForbiddenLetReason::OtherForbidden,
@@ -3458,20 +3458,54 @@ pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> {
         })
     }
 
-    fn parse_match_arm_guard(&mut self) -> PResult<'a, Option<Box<Expr>>> {
+    pub(crate) fn eat_metavar_guard(&mut self) -> Option<Box<Guard>> {
+        self.eat_metavar_seq_with_matcher(
+            |mv_kind| matches!(mv_kind, MetaVarKind::Guard),
+            |this| this.parse_match_arm_guard(),
+        )
+        .flatten()
+    }
+
+    fn parse_match_arm_guard(&mut self) -> PResult<'a, Option<Box<Guard>>> {
+        if let Some(guard) = self.eat_metavar_guard() {
+            return Ok(Some(guard));
+        }
+
         if !self.eat_keyword(exp!(If)) {
             // No match arm guard present.
             return Ok(None);
         }
+        self.expect_match_arm_guard_cond(ForceCollect::No).map(Some)
+    }
 
-        let mut cond = self.parse_match_guard_condition()?;
+    pub(crate) fn expect_match_arm_guard(
+        &mut self,
+        force_collect: ForceCollect,
+    ) -> PResult<'a, Box<Guard>> {
+        if let Some(guard) = self.eat_metavar_guard() {
+            return Ok(guard);
+        }
+
+        self.expect_keyword(exp!(If))?;
+        self.expect_match_arm_guard_cond(force_collect)
+    }
+
+    fn expect_match_arm_guard_cond(
+        &mut self,
+        force_collect: ForceCollect,
+    ) -> PResult<'a, Box<Guard>> {
+        let leading_if_span = self.prev_token.span;
+
+        let mut cond = self.parse_match_guard_condition(force_collect)?;
+        let cond_span = cond.span;
 
         CondChecker::new(self, LetChainsPolicy::AlwaysAllowed).visit_expr(&mut cond);
 
-        Ok(Some(cond))
+        let guard = Guard { cond: *cond, span_with_leading_if: leading_if_span.to(cond_span) };
+        Ok(Box::new(guard))
     }
 
-    fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (Pat, Option<Box<Expr>>)> {
+    fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (Pat, Option<Box<Guard>>)> {
         if self.token == token::OpenParen {
             let left = self.token.span;
             let pat = self.parse_pat_no_top_guard(
@@ -3487,10 +3521,10 @@ fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (Pat, Option<Box<Expr
                 // FIXME(guard_patterns): convert this to a normal guard instead
                 let span = pat.span;
                 let ast::PatKind::Paren(subpat) = pat.kind else { unreachable!() };
-                let ast::PatKind::Guard(_, mut cond) = subpat.kind else { unreachable!() };
-                self.psess.gated_spans.ungate_last(sym::guard_patterns, cond.span);
+                let ast::PatKind::Guard(_, mut guard) = subpat.kind else { unreachable!() };
+                self.psess.gated_spans.ungate_last(sym::guard_patterns, guard.span());
                 let mut checker = CondChecker::new(self, LetChainsPolicy::AlwaysAllowed);
-                checker.visit_expr(&mut cond);
+                checker.visit_expr(&mut guard.cond);
 
                 let right = self.prev_token.span;
                 self.dcx().emit_err(errors::ParenthesesInMatchPat {
@@ -3498,14 +3532,10 @@ fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (Pat, Option<Box<Expr
                     sugg: errors::ParenthesesInMatchPatSugg { left, right },
                 });
 
-                Ok((
-                    self.mk_pat(span, ast::PatKind::Wild),
-                    (if let Some(guar) = checker.found_incorrect_let_chain {
-                        Some(self.mk_expr_err(cond.span, guar))
-                    } else {
-                        Some(cond)
-                    }),
-                ))
+                if let Some(guar) = checker.found_incorrect_let_chain {
+                    guard.cond = *self.mk_expr_err(guard.span(), guar);
+                }
+                Ok((self.mk_pat(span, ast::PatKind::Wild), Some(guard)))
             } else {
                 Ok((pat, self.parse_match_arm_guard()?))
             }
@@ -3521,33 +3551,47 @@ fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (Pat, Option<Box<Expr
         }
     }
 
-    fn parse_match_guard_condition(&mut self) -> PResult<'a, Box<Expr>> {
+    fn parse_match_guard_condition(
+        &mut self,
+        force_collect: ForceCollect,
+    ) -> PResult<'a, Box<Expr>> {
         let attrs = self.parse_outer_attributes()?;
-        match self.parse_expr_res(Restrictions::ALLOW_LET | Restrictions::IN_IF_GUARD, attrs) {
-            Ok((expr, _)) => Ok(expr),
-            Err(mut err) => {
-                if self.prev_token == token::OpenBrace {
-                    let sugg_sp = self.prev_token.span.shrink_to_lo();
-                    // Consume everything within the braces, let's avoid further parse
-                    // errors.
-                    self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
-                    let msg = "you might have meant to start a match arm after the match guard";
-                    if self.eat(exp!(CloseBrace)) {
-                        let applicability = if self.token != token::FatArrow {
-                            // We have high confidence that we indeed didn't have a struct
-                            // literal in the match guard, but rather we had some operation
-                            // that ended in a path, immediately followed by a block that was
-                            // meant to be the match arm.
-                            Applicability::MachineApplicable
-                        } else {
-                            Applicability::MaybeIncorrect
-                        };
-                        err.span_suggestion_verbose(sugg_sp, msg, "=> ", applicability);
+        let expr = self.collect_tokens(
+            None,
+            AttrWrapper::empty(),
+            force_collect,
+            |this, _empty_attrs| {
+                match this
+                    .parse_expr_res(Restrictions::ALLOW_LET | Restrictions::IN_IF_GUARD, attrs)
+                {
+                    Ok((expr, _)) => Ok((expr, Trailing::No, UsePreAttrPos::No)),
+                    Err(mut err) => {
+                        if this.prev_token == token::OpenBrace {
+                            let sugg_sp = this.prev_token.span.shrink_to_lo();
+                            // Consume everything within the braces, let's avoid further parse
+                            // errors.
+                            this.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
+                            let msg =
+                                "you might have meant to start a match arm after the match guard";
+                            if this.eat(exp!(CloseBrace)) {
+                                let applicability = if this.token != token::FatArrow {
+                                    // We have high confidence that we indeed didn't have a struct
+                                    // literal in the match guard, but rather we had some operation
+                                    // that ended in a path, immediately followed by a block that was
+                                    // meant to be the match arm.
+                                    Applicability::MachineApplicable
+                                } else {
+                                    Applicability::MaybeIncorrect
+                                };
+                                err.span_suggestion_verbose(sugg_sp, msg, "=> ", applicability);
+                            }
+                        }
+                        Err(err)
                     }
                 }
-                Err(err)
-            }
-        }
+            },
+        )?;
+        Ok(expr)
     }
 
     pub(crate) fn is_builtin(&self) -> bool {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 36ca8a7d6133..8c1c3c7025f5 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1788,4 +1788,5 @@ pub enum ParseNtResult {
     Meta(Box<ast::AttrItem>),
     Path(Box<ast::Path>),
     Vis(Box<ast::Visibility>),
+    Guard(Box<ast::Guard>),
 }
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
index 706b454835fa..ddf1b10e5235 100644
--- a/compiler/rustc_parse/src/parser/nonterminal.rs
+++ b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -31,7 +31,8 @@ fn may_be_ident(kind: MetaVarKind) -> bool {
 
                 MetaVarKind::Item
                 | MetaVarKind::Block
-                | MetaVarKind::Vis => false,
+                | MetaVarKind::Vis
+                | MetaVarKind::Guard => false,
 
                 MetaVarKind::Ident
                 | MetaVarKind::Lifetime
@@ -86,7 +87,8 @@ fn may_be_ident(kind: MetaVarKind) -> bool {
                     | MetaVarKind::Ty { .. }
                     | MetaVarKind::Meta { .. }
                     | MetaVarKind::Path
-                    | MetaVarKind::Vis => false,
+                    | MetaVarKind::Vis
+                    | MetaVarKind::Guard => false,
                     MetaVarKind::Lifetime | MetaVarKind::Ident | MetaVarKind::TT => {
                         unreachable!()
                     }
@@ -103,6 +105,7 @@ fn may_be_ident(kind: MetaVarKind) -> bool {
                 token::Lifetime(..) | token::NtLifetime(..) => true,
                 _ => false,
             },
+            NonterminalKind::Guard => token.is_keyword(kw::If),
             NonterminalKind::TT | NonterminalKind::Item | NonterminalKind::Stmt => {
                 token.kind.close_delim().is_none()
             }
@@ -196,6 +199,9 @@ pub fn parse_nonterminal(&mut self, kind: NonterminalKind) -> PResult<'a, ParseN
                     }))
                 }
             }
+            NonterminalKind::Guard => {
+                Ok(ParseNtResult::Guard(self.expect_match_arm_guard(ForceCollect::Yes)?))
+            }
         }
     }
 }
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 7ee7781f6be0..a21d19b6d3a2 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -6,8 +6,9 @@
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{
-    self as ast, Arm, AttrVec, BindingMode, ByRef, Expr, ExprKind, LocalKind, MacCall, Mutability,
-    Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax, Stmt, StmtKind,
+    self as ast, Arm, AttrVec, BindingMode, ByRef, Expr, ExprKind, Guard, LocalKind, MacCall,
+    Mutability, Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax, Stmt,
+    StmtKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, Diag, DiagArgValue, PResult, StashKey};
@@ -110,11 +111,19 @@ pub fn parse_pat_allow_top_guard(
         let pat = self.parse_pat_no_top_guard(expected, rc, ra, rt)?;
 
         if self.eat_keyword(exp!(If)) {
-            let cond = self.parse_expr()?;
+            let guard = if let Some(guard) = self.eat_metavar_guard() {
+                guard
+            } else {
+                let leading_if_span = self.prev_token.span;
+                let cond = self.parse_expr()?;
+                let cond_span = cond.span;
+                Box::new(Guard { cond: *cond, span_with_leading_if: leading_if_span.to(cond_span) })
+            };
+
             // Feature-gate guard patterns
-            self.psess.gated_spans.gate(sym::guard_patterns, cond.span);
-            let span = pat.span.to(cond.span);
-            Ok(self.mk_pat(span, PatKind::Guard(Box::new(pat), cond)))
+            self.psess.gated_spans.gate(sym::guard_patterns, guard.span());
+            let span = pat.span.to(guard.span());
+            Ok(self.mk_pat(span, PatKind::Guard(Box::new(pat), guard)))
         } else {
             Ok(pat)
         }
@@ -601,17 +610,18 @@ fn maybe_add_suggestions_then_emit(
                                 }
                                 Some(guard) => {
                                     // Are parentheses required around the old guard?
-                                    let wrap_guard = guard.precedence() <= ExprPrecedence::LAnd;
+                                    let wrap_guard =
+                                        guard.cond.precedence() <= ExprPrecedence::LAnd;
 
                                     err.subdiagnostic(
                                         UnexpectedExpressionInPatternSugg::UpdateGuard {
                                             ident_span,
                                             guard_lo: if wrap_guard {
-                                                Some(guard.span.shrink_to_lo())
+                                                Some(guard.span().shrink_to_lo())
                                             } else {
                                                 None
                                             },
-                                            guard_hi: guard.span.shrink_to_hi(),
+                                            guard_hi: guard.span().shrink_to_hi(),
                                             guard_hi_paren: if wrap_guard { ")" } else { "" },
                                             ident,
                                             expr,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 453fe9d7a8e0..d5cb3aefec0f 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -4054,7 +4054,7 @@ fn check_consistent_bindings(&mut self, pat: &'ast Pat) {
     fn resolve_arm(&mut self, arm: &'ast Arm) {
         self.with_rib(ValueNS, RibKind::Normal, |this| {
             this.resolve_pattern_top(&arm.pat, PatternSource::Match);
-            visit_opt!(this, visit_expr, &arm.guard);
+            visit_opt!(this, visit_expr, arm.guard.as_ref().map(|g| &g.cond));
             visit_opt!(this, visit_expr, &arm.body);
         });
     }
@@ -4196,7 +4196,7 @@ fn resolve_pattern_inner(
                     let subpat_bindings = bindings.pop().unwrap().1;
                     self.with_rib(ValueNS, RibKind::Normal, |this| {
                         *this.innermost_rib_bindings(ValueNS) = subpat_bindings.clone();
-                        this.resolve_expr(guard, None);
+                        this.resolve_expr(&guard.cond, None);
                     });
                     // Propagate the subpattern's bindings upwards.
                     // FIXME(guard_patterns): For `if let` guards, we'll also need to get the
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 257ac3f51c2c..96bda60c363e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1027,6 +1027,7 @@
         global_registration,
         globs,
         gt,
+        guard,
         guard_patterns,
         half_open_range_patterns,
         half_open_range_patterns_in_slices,
@@ -1190,6 +1191,7 @@
         macro_derive,
         macro_escape,
         macro_export,
+        macro_guard_matcher,
         macro_lifetime_matcher,
         macro_literal_matcher,
         macro_metavar_expr,
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
index 50cfb0ed89de..9a463d1a9d71 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -280,7 +280,7 @@ pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
     l.is_placeholder == r.is_placeholder
         && eq_pat(&l.pat, &r.pat)
         && eq_expr_opt(l.body.as_deref(), r.body.as_deref())
-        && eq_expr_opt(l.guard.as_deref(), r.guard.as_deref())
+        && eq_expr_opt(l.guard.as_deref().map(|g| &g.cond), r.guard.as_deref().map(|g| &g.cond))
         && over(&l.attrs, &r.attrs, eq_attr)
 }
 
diff --git a/src/tools/rustfmt/src/matches.rs b/src/tools/rustfmt/src/matches.rs
index 4741abbe4658..50c0db8ac06e 100644
--- a/src/tools/rustfmt/src/matches.rs
+++ b/src/tools/rustfmt/src/matches.rs
@@ -571,7 +571,7 @@ fn rewrite_match_body(
 // The `if ...` guard on a match arm.
 fn rewrite_guard(
     context: &RewriteContext<'_>,
-    guard: &Option<Box<ast::Expr>>,
+    guard: &Option<Box<ast::Guard>>,
     shape: Shape,
     // The amount of space used up on this line for the pattern in
     // the arm (excludes offset).
@@ -586,7 +586,7 @@ fn rewrite_guard(
             .and_then(|s| s.sub_width_opt(5));
         if !multiline_pattern {
             if let Some(cond_shape) = cond_shape {
-                if let Ok(cond_str) = guard.rewrite_result(context, cond_shape) {
+                if let Ok(cond_str) = guard.cond.rewrite_result(context, cond_shape) {
                     if !cond_str.contains('\n') || pattern_width <= context.config.tab_spaces() {
                         return Ok(format!(" if {cond_str}"));
                     }
@@ -597,9 +597,9 @@ fn rewrite_guard(
         // Not enough space to put the guard after the pattern, try a newline.
         // 3 = `if `, 5 = ` => {`
         let cond_shape = Shape::indented(shape.indent.block_indent(context.config), context.config)
-            .offset_left(3, guard.span)?
-            .sub_width(5, guard.span)?;
-        let cond_str = guard.rewrite_result(context, cond_shape)?;
+            .offset_left(3, guard.span())?
+            .sub_width(5, guard.span())?;
+        let cond_str = guard.cond.rewrite_result(context, cond_shape)?;
         Ok(format!(
             "{}if {}",
             cond_shape.indent.to_string_with_newline(context.config),
diff --git a/tests/ui/feature-gates/feature-gate-macro-guard-matcher.rs b/tests/ui/feature-gates/feature-gate-macro-guard-matcher.rs
new file mode 100644
index 000000000000..662161f19fac
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-macro-guard-matcher.rs
@@ -0,0 +1,5 @@
+fn main() {
+    macro_rules! m {
+        ($x:guard) => {}; //~ ERROR `guard` fragments in macro are unstable
+    }
+}
diff --git a/tests/ui/feature-gates/feature-gate-macro-guard-matcher.stderr b/tests/ui/feature-gates/feature-gate-macro-guard-matcher.stderr
new file mode 100644
index 000000000000..0977f944f74f
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-macro-guard-matcher.stderr
@@ -0,0 +1,13 @@
+error[E0658]: `guard` fragments in macro are unstable
+  --> $DIR/feature-gate-macro-guard-matcher.rs:3:10
+   |
+LL |         ($x:guard) => {};
+   |          ^^^^^^^^
+   |
+   = note: see issue #153104 <https://github.com/rust-lang/rust/issues/153104> for more information
+   = help: add `#![feature(macro_guard_matcher)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/macros/macro-follow-rpass.rs b/tests/ui/macros/macro-follow-rpass.rs
index 8551b1887708..d94142365628 100644
--- a/tests/ui/macros/macro-follow-rpass.rs
+++ b/tests/ui/macros/macro-follow-rpass.rs
@@ -3,13 +3,14 @@
 #![allow(unused_macros)]
 // Check the macro follow sets (see corresponding cfail test).
 
-// FOLLOW(pat) = {FatArrow, Comma, Eq, Or, Ident(if), Ident(in)}
+// FOLLOW(pat) = {FatArrow, Comma, Eq, Or, Ident(if), MetaVarDecl(Guard), Ident(in)}
 macro_rules! follow_pat {
     ($p:pat =>) => {};
     ($p:pat ,) => {};
     ($p:pat =) => {};
     ($p:pat |) => {};
     ($p:pat if) => {};
+    ($p:pat if let) => {};
     ($p:pat in) => {};
 }
 // FOLLOW(expr) = {FatArrow, Comma, Semicolon}
diff --git a/tests/ui/macros/macro-follow.rs b/tests/ui/macros/macro-follow.rs
index 923c9bd6cedc..874bad6a7431 100644
--- a/tests/ui/macros/macro-follow.rs
+++ b/tests/ui/macros/macro-follow.rs
@@ -2,9 +2,10 @@
 //
 // Check the macro follow sets (see corresponding rpass test).
 
+#![feature(macro_guard_matcher)]
 #![allow(unused_macros)]
 
-// FOLLOW(pat) = {FatArrow, Comma, Eq, Or, Ident(if), Ident(in)}
+// FOLLOW(pat) = {FatArrow, Comma, Eq, Or, Ident(if), MetaVarDecl(Guard), Ident(in)}
 macro_rules! follow_pat {
     ($p:pat ()) => {};       //~ERROR  `$p:pat` is followed by `(`
     ($p:pat []) => {};       //~ERROR  `$p:pat` is followed by `[`
@@ -47,6 +48,7 @@ macro_rules! follow_expr {
     ($e:expr $t:tt) => {};    //~ERROR `$e:expr` is followed by `$t:tt`
     ($e:expr $i:item) => {};  //~ERROR `$e:expr` is followed by `$i:item`
     ($e:expr $m:meta) => {};  //~ERROR `$e:expr` is followed by `$m:meta`
+    ($e:expr $g:guard) => {}; //~ERROR `$e:expr` is followed by `$g:guard`
 }
 // FOLLOW(ty) = {OpenDelim(Brace), Comma, FatArrow, Colon, Eq, Gt, Semi, Or,
 //               Ident(as), Ident(where), OpenDelim(Bracket), Nonterminal(Block)}
@@ -66,6 +68,7 @@ macro_rules! follow_ty {
     ($t:ty $r:tt) => {};    //~ERROR `$t:ty` is followed by `$r:tt`
     ($t:ty $i:item) => {};  //~ERROR `$t:ty` is followed by `$i:item`
     ($t:ty $m:meta) => {};  //~ERROR `$t:ty` is followed by `$m:meta`
+    ($t:ty $g:guard) => {}; //~ERROR `$t:ty` is followed by `$g:guard`
 }
 // FOLLOW(stmt) = FOLLOW(expr)
 macro_rules! follow_stmt {
@@ -90,6 +93,7 @@ macro_rules! follow_stmt {
     ($s:stmt $t:tt) => {};    //~ERROR `$s:stmt` is followed by `$t:tt`
     ($s:stmt $i:item) => {};  //~ERROR `$s:stmt` is followed by `$i:item`
     ($s:stmt $m:meta) => {};  //~ERROR `$s:stmt` is followed by `$m:meta`
+    ($s:stmt $g:guard) => {}; //~ERROR `$s:stmt` is followed by `$g:guard`
 }
 // FOLLOW(path) = FOLLOW(ty)
 macro_rules! follow_path {
@@ -108,6 +112,7 @@ macro_rules! follow_path {
     ($p:path $t:tt) => {};    //~ERROR `$p:path` is followed by `$t:tt`
     ($p:path $i:item) => {};  //~ERROR `$p:path` is followed by `$i:item`
     ($p:path $m:meta) => {};  //~ERROR `$p:path` is followed by `$m:meta`
+    ($p:path $g:guard) => {}; //~ERROR `$p:path` is followed by `$g:guard`
 }
 // FOLLOW(block) = any token
 // FOLLOW(ident) = any token
diff --git a/tests/ui/macros/macro-follow.stderr b/tests/ui/macros/macro-follow.stderr
index 92491dc26d12..78d167added7 100644
--- a/tests/ui/macros/macro-follow.stderr
+++ b/tests/ui/macros/macro-follow.stderr
@@ -1,141 +1,141 @@
 error: `$p:pat` is followed by `(`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:9:13
+  --> $DIR/macro-follow.rs:10:13
    |
 LL |     ($p:pat ()) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `[`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:10:13
+  --> $DIR/macro-follow.rs:11:13
    |
 LL |     ($p:pat []) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `{`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:11:13
+  --> $DIR/macro-follow.rs:12:13
    |
 LL |     ($p:pat {}) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `:`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:12:13
+  --> $DIR/macro-follow.rs:13:13
    |
 LL |     ($p:pat :) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `>`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:13:13
+  --> $DIR/macro-follow.rs:14:13
    |
 LL |     ($p:pat >) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `+`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:14:13
+  --> $DIR/macro-follow.rs:15:13
    |
 LL |     ($p:pat +) => {};
    |             ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `ident`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:15:13
+  --> $DIR/macro-follow.rs:16:13
    |
 LL |     ($p:pat ident) => {};
    |             ^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$q:pat`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:16:13
+  --> $DIR/macro-follow.rs:17:13
    |
 LL |     ($p:pat $q:pat) => {};
    |             ^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$e:expr`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:17:13
+  --> $DIR/macro-follow.rs:18:13
    |
 LL |     ($p:pat $e:expr) => {};
    |             ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$t:ty`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:18:13
+  --> $DIR/macro-follow.rs:19:13
    |
 LL |     ($p:pat $t:ty) => {};
    |             ^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$s:stmt`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:19:13
+  --> $DIR/macro-follow.rs:20:13
    |
 LL |     ($p:pat $s:stmt) => {};
    |             ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$q:path`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:20:13
+  --> $DIR/macro-follow.rs:21:13
    |
 LL |     ($p:pat $q:path) => {};
    |             ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$b:block`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:21:13
+  --> $DIR/macro-follow.rs:22:13
    |
 LL |     ($p:pat $b:block) => {};
    |             ^^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$i:ident`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:22:13
+  --> $DIR/macro-follow.rs:23:13
    |
 LL |     ($p:pat $i:ident) => {};
    |             ^^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$t:tt`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:23:13
+  --> $DIR/macro-follow.rs:24:13
    |
 LL |     ($p:pat $t:tt) => {};
    |             ^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$i:item`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:24:13
+  --> $DIR/macro-follow.rs:25:13
    |
 LL |     ($p:pat $i:item) => {};
    |             ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$p:pat` is followed by `$m:meta`, which is not allowed for `pat` fragments
-  --> $DIR/macro-follow.rs:25:13
+  --> $DIR/macro-follow.rs:26:13
    |
 LL |     ($p:pat $m:meta) => {};
    |             ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$e:expr` is followed by `(`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:29:14
+  --> $DIR/macro-follow.rs:30:14
    |
 LL |     ($e:expr ()) => {};
    |              ^ not allowed after `expr` fragments
@@ -143,7 +143,7 @@ LL |     ($e:expr ()) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `[`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:30:14
+  --> $DIR/macro-follow.rs:31:14
    |
 LL |     ($e:expr []) => {};
    |              ^ not allowed after `expr` fragments
@@ -151,7 +151,7 @@ LL |     ($e:expr []) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `{`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:31:14
+  --> $DIR/macro-follow.rs:32:14
    |
 LL |     ($e:expr {}) => {};
    |              ^ not allowed after `expr` fragments
@@ -159,7 +159,7 @@ LL |     ($e:expr {}) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `=`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:32:14
+  --> $DIR/macro-follow.rs:33:14
    |
 LL |     ($e:expr =) => {};
    |              ^ not allowed after `expr` fragments
@@ -167,7 +167,7 @@ LL |     ($e:expr =) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `|`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:33:14
+  --> $DIR/macro-follow.rs:34:14
    |
 LL |     ($e:expr |) => {};
    |              ^ not allowed after `expr` fragments
@@ -175,7 +175,7 @@ LL |     ($e:expr |) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `:`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:34:14
+  --> $DIR/macro-follow.rs:35:14
    |
 LL |     ($e:expr :) => {};
    |              ^ not allowed after `expr` fragments
@@ -183,7 +183,7 @@ LL |     ($e:expr :) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `>`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:35:14
+  --> $DIR/macro-follow.rs:36:14
    |
 LL |     ($e:expr >) => {};
    |              ^ not allowed after `expr` fragments
@@ -191,7 +191,7 @@ LL |     ($e:expr >) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `+`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:36:14
+  --> $DIR/macro-follow.rs:37:14
    |
 LL |     ($e:expr +) => {};
    |              ^ not allowed after `expr` fragments
@@ -199,7 +199,7 @@ LL |     ($e:expr +) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `ident`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:37:14
+  --> $DIR/macro-follow.rs:38:14
    |
 LL |     ($e:expr ident) => {};
    |              ^^^^^ not allowed after `expr` fragments
@@ -207,7 +207,7 @@ LL |     ($e:expr ident) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `if`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:38:14
+  --> $DIR/macro-follow.rs:39:14
    |
 LL |     ($e:expr if) => {};
    |              ^^ not allowed after `expr` fragments
@@ -215,7 +215,7 @@ LL |     ($e:expr if) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `in`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:39:14
+  --> $DIR/macro-follow.rs:40:14
    |
 LL |     ($e:expr in) => {};
    |              ^^ not allowed after `expr` fragments
@@ -223,7 +223,7 @@ LL |     ($e:expr in) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$p:pat`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:40:14
+  --> $DIR/macro-follow.rs:41:14
    |
 LL |     ($e:expr $p:pat) => {};
    |              ^^^^^^ not allowed after `expr` fragments
@@ -231,7 +231,7 @@ LL |     ($e:expr $p:pat) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$f:expr`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:41:14
+  --> $DIR/macro-follow.rs:42:14
    |
 LL |     ($e:expr $f:expr) => {};
    |              ^^^^^^^ not allowed after `expr` fragments
@@ -239,7 +239,7 @@ LL |     ($e:expr $f:expr) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$t:ty`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:42:14
+  --> $DIR/macro-follow.rs:43:14
    |
 LL |     ($e:expr $t:ty) => {};
    |              ^^^^^ not allowed after `expr` fragments
@@ -247,7 +247,7 @@ LL |     ($e:expr $t:ty) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$s:stmt`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:43:14
+  --> $DIR/macro-follow.rs:44:14
    |
 LL |     ($e:expr $s:stmt) => {};
    |              ^^^^^^^ not allowed after `expr` fragments
@@ -255,7 +255,7 @@ LL |     ($e:expr $s:stmt) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$p:path`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:44:14
+  --> $DIR/macro-follow.rs:45:14
    |
 LL |     ($e:expr $p:path) => {};
    |              ^^^^^^^ not allowed after `expr` fragments
@@ -263,7 +263,7 @@ LL |     ($e:expr $p:path) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$b:block`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:45:14
+  --> $DIR/macro-follow.rs:46:14
    |
 LL |     ($e:expr $b:block) => {};
    |              ^^^^^^^^ not allowed after `expr` fragments
@@ -271,7 +271,7 @@ LL |     ($e:expr $b:block) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$i:ident`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:46:14
+  --> $DIR/macro-follow.rs:47:14
    |
 LL |     ($e:expr $i:ident) => {};
    |              ^^^^^^^^ not allowed after `expr` fragments
@@ -279,7 +279,7 @@ LL |     ($e:expr $i:ident) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$t:tt`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:47:14
+  --> $DIR/macro-follow.rs:48:14
    |
 LL |     ($e:expr $t:tt) => {};
    |              ^^^^^ not allowed after `expr` fragments
@@ -287,7 +287,7 @@ LL |     ($e:expr $t:tt) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$i:item`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:48:14
+  --> $DIR/macro-follow.rs:49:14
    |
 LL |     ($e:expr $i:item) => {};
    |              ^^^^^^^ not allowed after `expr` fragments
@@ -295,15 +295,23 @@ LL |     ($e:expr $i:item) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$e:expr` is followed by `$m:meta`, which is not allowed for `expr` fragments
-  --> $DIR/macro-follow.rs:49:14
+  --> $DIR/macro-follow.rs:50:14
    |
 LL |     ($e:expr $m:meta) => {};
    |              ^^^^^^^ not allowed after `expr` fragments
    |
    = note: allowed there are: `=>`, `,` or `;`
 
+error: `$e:expr` is followed by `$g:guard`, which is not allowed for `expr` fragments
+  --> $DIR/macro-follow.rs:51:14
+   |
+LL |     ($e:expr $g:guard) => {};
+   |              ^^^^^^^^ not allowed after `expr` fragments
+   |
+   = note: allowed there are: `=>`, `,` or `;`
+
 error: `$t:ty` is followed by `(`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:54:12
+  --> $DIR/macro-follow.rs:56:12
    |
 LL |     ($t:ty ()) => {};
    |            ^ not allowed after `ty` fragments
@@ -311,7 +319,7 @@ LL |     ($t:ty ()) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `+`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:56:12
+  --> $DIR/macro-follow.rs:58:12
    |
 LL |     ($t:ty +) => {};
    |            ^ not allowed after `ty` fragments
@@ -319,7 +327,7 @@ LL |     ($t:ty +) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `ident`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:57:12
+  --> $DIR/macro-follow.rs:59:12
    |
 LL |     ($t:ty ident) => {};
    |            ^^^^^ not allowed after `ty` fragments
@@ -327,7 +335,7 @@ LL |     ($t:ty ident) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `if`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:58:12
+  --> $DIR/macro-follow.rs:60:12
    |
 LL |     ($t:ty if) => {};
    |            ^^ not allowed after `ty` fragments
@@ -335,7 +343,7 @@ LL |     ($t:ty if) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$p:pat`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:59:12
+  --> $DIR/macro-follow.rs:61:12
    |
 LL |     ($t:ty $p:pat) => {};
    |            ^^^^^^ not allowed after `ty` fragments
@@ -343,7 +351,7 @@ LL |     ($t:ty $p:pat) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$e:expr`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:60:12
+  --> $DIR/macro-follow.rs:62:12
    |
 LL |     ($t:ty $e:expr) => {};
    |            ^^^^^^^ not allowed after `ty` fragments
@@ -351,7 +359,7 @@ LL |     ($t:ty $e:expr) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$r:ty`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:61:12
+  --> $DIR/macro-follow.rs:63:12
    |
 LL |     ($t:ty $r:ty) => {};
    |            ^^^^^ not allowed after `ty` fragments
@@ -359,7 +367,7 @@ LL |     ($t:ty $r:ty) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$s:stmt`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:62:12
+  --> $DIR/macro-follow.rs:64:12
    |
 LL |     ($t:ty $s:stmt) => {};
    |            ^^^^^^^ not allowed after `ty` fragments
@@ -367,7 +375,7 @@ LL |     ($t:ty $s:stmt) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$p:path`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:63:12
+  --> $DIR/macro-follow.rs:65:12
    |
 LL |     ($t:ty $p:path) => {};
    |            ^^^^^^^ not allowed after `ty` fragments
@@ -375,7 +383,7 @@ LL |     ($t:ty $p:path) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$i:ident`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:65:12
+  --> $DIR/macro-follow.rs:67:12
    |
 LL |     ($t:ty $i:ident) => {};
    |            ^^^^^^^^ not allowed after `ty` fragments
@@ -383,7 +391,7 @@ LL |     ($t:ty $i:ident) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$r:tt`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:66:12
+  --> $DIR/macro-follow.rs:68:12
    |
 LL |     ($t:ty $r:tt) => {};
    |            ^^^^^ not allowed after `ty` fragments
@@ -391,7 +399,7 @@ LL |     ($t:ty $r:tt) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$i:item`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:67:12
+  --> $DIR/macro-follow.rs:69:12
    |
 LL |     ($t:ty $i:item) => {};
    |            ^^^^^^^ not allowed after `ty` fragments
@@ -399,15 +407,23 @@ LL |     ($t:ty $i:item) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$t:ty` is followed by `$m:meta`, which is not allowed for `ty` fragments
-  --> $DIR/macro-follow.rs:68:12
+  --> $DIR/macro-follow.rs:70:12
    |
 LL |     ($t:ty $m:meta) => {};
    |            ^^^^^^^ not allowed after `ty` fragments
    |
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
+error: `$t:ty` is followed by `$g:guard`, which is not allowed for `ty` fragments
+  --> $DIR/macro-follow.rs:71:12
+   |
+LL |     ($t:ty $g:guard) => {};
+   |            ^^^^^^^^ not allowed after `ty` fragments
+   |
+   = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
+
 error: `$s:stmt` is followed by `(`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:72:14
+  --> $DIR/macro-follow.rs:75:14
    |
 LL |     ($s:stmt ()) => {};
    |              ^ not allowed after `stmt` fragments
@@ -415,7 +431,7 @@ LL |     ($s:stmt ()) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `[`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:73:14
+  --> $DIR/macro-follow.rs:76:14
    |
 LL |     ($s:stmt []) => {};
    |              ^ not allowed after `stmt` fragments
@@ -423,7 +439,7 @@ LL |     ($s:stmt []) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `{`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:74:14
+  --> $DIR/macro-follow.rs:77:14
    |
 LL |     ($s:stmt {}) => {};
    |              ^ not allowed after `stmt` fragments
@@ -431,7 +447,7 @@ LL |     ($s:stmt {}) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `=`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:75:14
+  --> $DIR/macro-follow.rs:78:14
    |
 LL |     ($s:stmt =) => {};
    |              ^ not allowed after `stmt` fragments
@@ -439,7 +455,7 @@ LL |     ($s:stmt =) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `|`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:76:14
+  --> $DIR/macro-follow.rs:79:14
    |
 LL |     ($s:stmt |) => {};
    |              ^ not allowed after `stmt` fragments
@@ -447,7 +463,7 @@ LL |     ($s:stmt |) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `:`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:77:14
+  --> $DIR/macro-follow.rs:80:14
    |
 LL |     ($s:stmt :) => {};
    |              ^ not allowed after `stmt` fragments
@@ -455,7 +471,7 @@ LL |     ($s:stmt :) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `>`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:78:14
+  --> $DIR/macro-follow.rs:81:14
    |
 LL |     ($s:stmt >) => {};
    |              ^ not allowed after `stmt` fragments
@@ -463,7 +479,7 @@ LL |     ($s:stmt >) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `+`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:79:14
+  --> $DIR/macro-follow.rs:82:14
    |
 LL |     ($s:stmt +) => {};
    |              ^ not allowed after `stmt` fragments
@@ -471,7 +487,7 @@ LL |     ($s:stmt +) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `ident`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:80:14
+  --> $DIR/macro-follow.rs:83:14
    |
 LL |     ($s:stmt ident) => {};
    |              ^^^^^ not allowed after `stmt` fragments
@@ -479,7 +495,7 @@ LL |     ($s:stmt ident) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `if`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:81:14
+  --> $DIR/macro-follow.rs:84:14
    |
 LL |     ($s:stmt if) => {};
    |              ^^ not allowed after `stmt` fragments
@@ -487,7 +503,7 @@ LL |     ($s:stmt if) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `in`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:82:14
+  --> $DIR/macro-follow.rs:85:14
    |
 LL |     ($s:stmt in) => {};
    |              ^^ not allowed after `stmt` fragments
@@ -495,7 +511,7 @@ LL |     ($s:stmt in) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$p:pat`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:83:14
+  --> $DIR/macro-follow.rs:86:14
    |
 LL |     ($s:stmt $p:pat) => {};
    |              ^^^^^^ not allowed after `stmt` fragments
@@ -503,7 +519,7 @@ LL |     ($s:stmt $p:pat) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$e:expr`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:84:14
+  --> $DIR/macro-follow.rs:87:14
    |
 LL |     ($s:stmt $e:expr) => {};
    |              ^^^^^^^ not allowed after `stmt` fragments
@@ -511,7 +527,7 @@ LL |     ($s:stmt $e:expr) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$t:ty`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:85:14
+  --> $DIR/macro-follow.rs:88:14
    |
 LL |     ($s:stmt $t:ty) => {};
    |              ^^^^^ not allowed after `stmt` fragments
@@ -519,7 +535,7 @@ LL |     ($s:stmt $t:ty) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$t:stmt`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:86:14
+  --> $DIR/macro-follow.rs:89:14
    |
 LL |     ($s:stmt $t:stmt) => {};
    |              ^^^^^^^ not allowed after `stmt` fragments
@@ -527,7 +543,7 @@ LL |     ($s:stmt $t:stmt) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$p:path`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:87:14
+  --> $DIR/macro-follow.rs:90:14
    |
 LL |     ($s:stmt $p:path) => {};
    |              ^^^^^^^ not allowed after `stmt` fragments
@@ -535,7 +551,7 @@ LL |     ($s:stmt $p:path) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$b:block`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:88:14
+  --> $DIR/macro-follow.rs:91:14
    |
 LL |     ($s:stmt $b:block) => {};
    |              ^^^^^^^^ not allowed after `stmt` fragments
@@ -543,7 +559,7 @@ LL |     ($s:stmt $b:block) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$i:ident`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:89:14
+  --> $DIR/macro-follow.rs:92:14
    |
 LL |     ($s:stmt $i:ident) => {};
    |              ^^^^^^^^ not allowed after `stmt` fragments
@@ -551,7 +567,7 @@ LL |     ($s:stmt $i:ident) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$t:tt`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:90:14
+  --> $DIR/macro-follow.rs:93:14
    |
 LL |     ($s:stmt $t:tt) => {};
    |              ^^^^^ not allowed after `stmt` fragments
@@ -559,7 +575,7 @@ LL |     ($s:stmt $t:tt) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$i:item`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:91:14
+  --> $DIR/macro-follow.rs:94:14
    |
 LL |     ($s:stmt $i:item) => {};
    |              ^^^^^^^ not allowed after `stmt` fragments
@@ -567,23 +583,31 @@ LL |     ($s:stmt $i:item) => {};
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$s:stmt` is followed by `$m:meta`, which is not allowed for `stmt` fragments
-  --> $DIR/macro-follow.rs:92:14
+  --> $DIR/macro-follow.rs:95:14
    |
 LL |     ($s:stmt $m:meta) => {};
    |              ^^^^^^^ not allowed after `stmt` fragments
    |
    = note: allowed there are: `=>`, `,` or `;`
 
-error: `$p:path` is followed by `(`, which is not allowed for `path` fragments
+error: `$s:stmt` is followed by `$g:guard`, which is not allowed for `stmt` fragments
   --> $DIR/macro-follow.rs:96:14
    |
+LL |     ($s:stmt $g:guard) => {};
+   |              ^^^^^^^^ not allowed after `stmt` fragments
+   |
+   = note: allowed there are: `=>`, `,` or `;`
+
+error: `$p:path` is followed by `(`, which is not allowed for `path` fragments
+  --> $DIR/macro-follow.rs:100:14
+   |
 LL |     ($p:path ()) => {};
    |              ^ not allowed after `path` fragments
    |
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `+`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:98:14
+  --> $DIR/macro-follow.rs:102:14
    |
 LL |     ($p:path +) => {};
    |              ^ not allowed after `path` fragments
@@ -591,7 +615,7 @@ LL |     ($p:path +) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `ident`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:99:14
+  --> $DIR/macro-follow.rs:103:14
    |
 LL |     ($p:path ident) => {};
    |              ^^^^^ not allowed after `path` fragments
@@ -599,7 +623,7 @@ LL |     ($p:path ident) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `if`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:100:14
+  --> $DIR/macro-follow.rs:104:14
    |
 LL |     ($p:path if) => {};
    |              ^^ not allowed after `path` fragments
@@ -607,7 +631,7 @@ LL |     ($p:path if) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$q:pat`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:101:14
+  --> $DIR/macro-follow.rs:105:14
    |
 LL |     ($p:path $q:pat) => {};
    |              ^^^^^^ not allowed after `path` fragments
@@ -615,7 +639,7 @@ LL |     ($p:path $q:pat) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$e:expr`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:102:14
+  --> $DIR/macro-follow.rs:106:14
    |
 LL |     ($p:path $e:expr) => {};
    |              ^^^^^^^ not allowed after `path` fragments
@@ -623,7 +647,7 @@ LL |     ($p:path $e:expr) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$t:ty`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:103:14
+  --> $DIR/macro-follow.rs:107:14
    |
 LL |     ($p:path $t:ty) => {};
    |              ^^^^^ not allowed after `path` fragments
@@ -631,7 +655,7 @@ LL |     ($p:path $t:ty) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$s:stmt`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:104:14
+  --> $DIR/macro-follow.rs:108:14
    |
 LL |     ($p:path $s:stmt) => {};
    |              ^^^^^^^ not allowed after `path` fragments
@@ -639,7 +663,7 @@ LL |     ($p:path $s:stmt) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$q:path`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:105:14
+  --> $DIR/macro-follow.rs:109:14
    |
 LL |     ($p:path $q:path) => {};
    |              ^^^^^^^ not allowed after `path` fragments
@@ -647,7 +671,7 @@ LL |     ($p:path $q:path) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$i:ident`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:107:14
+  --> $DIR/macro-follow.rs:111:14
    |
 LL |     ($p:path $i:ident) => {};
    |              ^^^^^^^^ not allowed after `path` fragments
@@ -655,7 +679,7 @@ LL |     ($p:path $i:ident) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$t:tt`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:108:14
+  --> $DIR/macro-follow.rs:112:14
    |
 LL |     ($p:path $t:tt) => {};
    |              ^^^^^ not allowed after `path` fragments
@@ -663,7 +687,7 @@ LL |     ($p:path $t:tt) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$i:item`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:109:14
+  --> $DIR/macro-follow.rs:113:14
    |
 LL |     ($p:path $i:item) => {};
    |              ^^^^^^^ not allowed after `path` fragments
@@ -671,12 +695,20 @@ LL |     ($p:path $i:item) => {};
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
 error: `$p:path` is followed by `$m:meta`, which is not allowed for `path` fragments
-  --> $DIR/macro-follow.rs:110:14
+  --> $DIR/macro-follow.rs:114:14
    |
 LL |     ($p:path $m:meta) => {};
    |              ^^^^^^^ not allowed after `path` fragments
    |
    = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
 
-error: aborting due to 85 previous errors
+error: `$p:path` is followed by `$g:guard`, which is not allowed for `path` fragments
+  --> $DIR/macro-follow.rs:115:14
+   |
+LL |     ($p:path $g:guard) => {};
+   |              ^^^^^^^^ not allowed after `path` fragments
+   |
+   = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
+
+error: aborting due to 89 previous errors
 
diff --git a/tests/ui/macros/macro-guard-matcher.rs b/tests/ui/macros/macro-guard-matcher.rs
new file mode 100644
index 000000000000..81a4412686de
--- /dev/null
+++ b/tests/ui/macros/macro-guard-matcher.rs
@@ -0,0 +1,17 @@
+#![feature(macro_guard_matcher)]
+
+fn main() {
+    macro_rules! m {
+        ($x:guard) => {};
+    }
+
+    // Accepts
+    m!(if true);
+    m!(if let Some(x) = Some(1));
+    m!(if let Some(x) = Some(1) && x == 1);
+    m!(if let Some(x) = Some(Some(1)) && let Some(1) = x);
+    m!(if let Some(x) = Some(Some(1)) && let Some(y) = x && y == 1);
+
+    // Rejects
+    m!(let Some(x) = Some(1)); //~ERROR no rules expected keyword `let`
+}
diff --git a/tests/ui/macros/macro-guard-matcher.stderr b/tests/ui/macros/macro-guard-matcher.stderr
new file mode 100644
index 000000000000..eddb0de9c4c5
--- /dev/null
+++ b/tests/ui/macros/macro-guard-matcher.stderr
@@ -0,0 +1,17 @@
+error: no rules expected keyword `let`
+  --> $DIR/macro-guard-matcher.rs:16:8
+   |
+LL |     macro_rules! m {
+   |     -------------- when calling this macro
+...
+LL |     m!(let Some(x) = Some(1));
+   |        ^^^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$x:guard`
+  --> $DIR/macro-guard-matcher.rs:5:10
+   |
+LL |         ($x:guard) => {};
+   |          ^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/macros/macro-input-future-proofing.stderr b/tests/ui/macros/macro-input-future-proofing.stderr
index 11960db98743..a12cc9f9b416 100644
--- a/tests/ui/macros/macro-input-future-proofing.stderr
+++ b/tests/ui/macros/macro-input-future-proofing.stderr
@@ -20,7 +20,7 @@ error: `$pa:pat` is followed by `>`, which is not allowed for `pat` fragments
 LL |     ($pa:pat >) => ();
    |              ^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$pa:pat` is followed by `$pb:pat`, which is not allowed for `pat` fragments
   --> $DIR/macro-input-future-proofing.rs:14:14
@@ -28,7 +28,7 @@ error: `$pa:pat` is followed by `$pb:pat`, which is not allowed for `pat` fragme
 LL |     ($pa:pat $pb:pat $ty:ty ,) => ();
    |              ^^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$pb:pat` is followed by `$ty:ty`, which is not allowed for `pat` fragments
   --> $DIR/macro-input-future-proofing.rs:14:22
@@ -36,7 +36,7 @@ error: `$pb:pat` is followed by `$ty:ty`, which is not allowed for `pat` fragmen
 LL |     ($pa:pat $pb:pat $ty:ty ,) => ();
    |                      ^^^^^^ not allowed after `pat` fragments
    |
-   = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `|`, `if`, `if let` or `in`
 
 error: `$ty:ty` is followed by `-`, which is not allowed for `ty` fragments
   --> $DIR/macro-input-future-proofing.rs:17:17
diff --git a/tests/ui/macros/macro-pat-pattern-followed-by-or-in-2021.stderr b/tests/ui/macros/macro-pat-pattern-followed-by-or-in-2021.stderr
index a06487be3d60..9179fbc31961 100644
--- a/tests/ui/macros/macro-pat-pattern-followed-by-or-in-2021.stderr
+++ b/tests/ui/macros/macro-pat-pattern-followed-by-or-in-2021.stderr
@@ -6,7 +6,7 @@ LL | macro_rules! foo { ($x:pat | $y:pat) => {} }
    |                     |
    |                     help: try a `pat_param` fragment specifier instead: `$x:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: `$x:pat` is followed by `|`, which is not allowed for `pat` fragments
   --> $DIR/macro-pat-pattern-followed-by-or-in-2021.rs:4:32
@@ -16,7 +16,7 @@ LL | macro_rules! bar { ($($x:pat)+ | $($y:pat)+) => {} }
    |                       |
    |                       help: try a `pat_param` fragment specifier instead: `$x:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: `$pat:pat` may be followed by `|`, which is not allowed for `pat` fragments
   --> $DIR/macro-pat-pattern-followed-by-or-in-2021.rs:7:36
@@ -26,7 +26,7 @@ LL |     ( $expr:expr , $( $( $pat:pat )|+ => $expr_arm:expr ),+ ) => {
    |                          |
    |                          help: try a `pat_param` fragment specifier instead: `$pat:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/macros/macro-pat2021-pattern-followed-by-or.stderr b/tests/ui/macros/macro-pat2021-pattern-followed-by-or.stderr
index c3754dde080a..af76e3f095f1 100644
--- a/tests/ui/macros/macro-pat2021-pattern-followed-by-or.stderr
+++ b/tests/ui/macros/macro-pat2021-pattern-followed-by-or.stderr
@@ -6,7 +6,7 @@ LL | macro_rules! foo { ($x:pat | $y:pat) => {} }
    |                     |
    |                     help: try a `pat_param` fragment specifier instead: `$x:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: `$x:pat` is followed by `|`, which is not allowed for `pat` fragments
   --> $DIR/macro-pat2021-pattern-followed-by-or.rs:7:28
@@ -16,7 +16,7 @@ LL | macro_rules! ogg { ($x:pat | $y:pat_param) => {} }
    |                     |
    |                     help: try a `pat_param` fragment specifier instead: `$x:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: `$pat:pat` may be followed by `|`, which is not allowed for `pat` fragments
   --> $DIR/macro-pat2021-pattern-followed-by-or.rs:9:35
@@ -26,7 +26,7 @@ LL |     ( $expr:expr , $( $( $pat:pat)|+ => $expr_arm:pat),+ ) => {
    |                          |
    |                          help: try a `pat_param` fragment specifier instead: `$pat:pat_param`
    |
-   = note: allowed there are: `=>`, `,`, `=`, `if` or `in`
+   = note: allowed there are: `=>`, `,`, `=`, `if`, `if let` or `in`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
index 3f331b0dd5f1..af2ba7a809ad 100644
--- a/tests/ui/macros/stringify.rs
+++ b/tests/ui/macros/stringify.rs
@@ -14,6 +14,7 @@
 #![feature(trait_alias)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
+#![feature(macro_guard_matcher)]
 #![deny(unused_macros)]
 
 // These macros force the use of AST pretty-printing by converting the input to
@@ -27,6 +28,7 @@
 macro_rules! stmt { ($stmt:stmt) => { stringify!($stmt) }; }
 macro_rules! ty { ($ty:ty) => { stringify!($ty) }; }
 macro_rules! vis { ($vis:vis) => { stringify!($vis) }; }
+macro_rules! guard { ($guard:guard) => { stringify!($guard) }; }
 
 macro_rules! c1 {
     ($frag:ident, [$($tt:tt)*], $s:literal) => {
@@ -792,6 +794,21 @@ fn test_vis() {
     // Attributes are not allowed on visibilities.
 }
 
+#[test]
+fn test_guard() {
+    c1!(guard, [ if true ], "if true");
+    c1!(guard, [ if let Some(x) = Some(1) ], "if let Some(x) = Some(1)");
+    c1!(guard, [ if let Some(x) = Some(1) && x == 1 ], "if let Some(x) = Some(1) && x == 1");
+    c1!(guard,
+        [ if let Some(x) = Some(Some(1)) && let Some(1) = x ],
+        "if let Some(x) = Some(Some(1)) && let Some(1) = x"
+    );
+    c1!(guard,
+        [ if let Some(x) = Some(Some(1)) && let Some(y) = x && y == 1 ],
+        "if let Some(x) = Some(Some(1)) && let Some(y) = x && y == 1"
+    );
+}
+
 macro_rules! p {
     ([$($tt:tt)*], $s:literal) => {
         assert_eq!(stringify!($($tt)*), $s);

From cfcbcb715c5120e481b2d1303b590a5eb2417e55 Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Wed, 11 Mar 2026 15:10:45 -0700
Subject: [PATCH 0367/1059] fix(query): Pass query key to
 value_from_cycle_error

Co-authored-by: Daria Sukhonina <zetanumbers@users.noreply.github.com>
Co-authored-by: Nicholas Nethercote <nnethercote@users.noreply.github.com>
---
 compiler/rustc_middle/src/query/plumbing.rs   |  8 ++++--
 compiler/rustc_query_impl/src/execution.rs    | 12 +++++----
 .../rustc_query_impl/src/from_cycle_error.rs  | 25 ++++++++-----------
 compiler/rustc_query_impl/src/plumbing.rs     |  2 +-
 4 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 72330eab30d5..33c38adcef05 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -136,8 +136,12 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     /// For `no_hash` queries, this function pointer is None.
     pub hash_value_fn: Option<fn(&mut StableHashingContext<'_>, &C::Value) -> Fingerprint>,
 
-    pub value_from_cycle_error:
-        fn(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> C::Value,
+    pub value_from_cycle_error: fn(
+        tcx: TyCtxt<'tcx>,
+        key: C::Key,
+        cycle_error: CycleError,
+        guar: ErrorGuaranteed,
+    ) -> C::Value,
     pub format_value: fn(&C::Value) -> String,
 
     /// Formats a human-readable description of this query and its key, as
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index a892958d6a81..d8dc004f1cf7 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -125,17 +125,18 @@ fn gather_active_jobs<'tcx, C>(
 fn mk_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    key: C::Key,
     cycle_error: CycleError,
 ) -> C::Value {
     let error = report_cycle(tcx.sess, &cycle_error);
     match query.cycle_error_handling {
         CycleErrorHandling::Error => {
             let guar = error.emit();
-            (query.value_from_cycle_error)(tcx, cycle_error, guar)
+            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
         }
         CycleErrorHandling::DelayBug => {
             let guar = error.delay_as_bug();
-            (query.value_from_cycle_error)(tcx, cycle_error, guar)
+            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
         }
     }
 }
@@ -219,6 +220,7 @@ fn drop(&mut self) {
 fn cycle_error<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    key: C::Key,
     try_execute: QueryJobId,
     span: Span,
 ) -> (C::Value, Option<DepNodeIndex>) {
@@ -229,7 +231,7 @@ fn cycle_error<'tcx, C: QueryCache>(
         .expect("failed to collect active queries");
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
-    (mk_cycle(query, tcx, error.lift()), None)
+    (mk_cycle(query, tcx, key, error.lift()), None)
 }
 
 #[inline(always)]
@@ -274,7 +276,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
 
             (v, Some(index))
         }
-        Err(cycle) => (mk_cycle(query, tcx, cycle.lift()), None),
+        Err(cycle) => (mk_cycle(query, tcx, key, cycle.lift()), None),
     }
 }
 
@@ -337,7 +339,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
                         // If we are single-threaded we know that we have cycle error,
                         // so we just return the error.
-                        cycle_error(query, tcx, id, span)
+                        cycle_error(query, tcx, key, id, span)
                     }
                 }
                 ActiveKeyStatus::Poisoned => FatalError.raise(),
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 0b7f69765823..c69d3eb9a0f0 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -15,34 +15,34 @@
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_span::def_id::LocalDefId;
+use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{ErrorGuaranteed, Span};
 
 use crate::job::report_cycle;
 
 pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
     vtables.type_of.value_from_cycle_error =
-        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
 
     vtables.type_of_opaque_hir_typeck.value_from_cycle_error =
-        |tcx, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
 
     vtables.erase_and_anonymize_regions_ty.value_from_cycle_error =
-        |tcx, _, guar| erase_val(Ty::new_error(tcx, guar));
+        |tcx, _, _, guar| erase_val(Ty::new_error(tcx, guar));
 
-    vtables.fn_sig.value_from_cycle_error = |tcx, cycle, guar| erase_val(fn_sig(tcx, cycle, guar));
+    vtables.fn_sig.value_from_cycle_error = |tcx, key, _, guar| erase_val(fn_sig(tcx, key, guar));
 
     vtables.check_representability.value_from_cycle_error =
-        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
 
     vtables.check_representability_adt_ty.value_from_cycle_error =
-        |tcx, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
 
     vtables.variances_of.value_from_cycle_error =
-        |tcx, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
+        |tcx, _, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
 
     vtables.layout_of.value_from_cycle_error =
-        |tcx, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
+        |tcx, _, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
 }
 
 pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
@@ -57,15 +57,12 @@ pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_na
 
 fn fn_sig<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    def_id: DefId,
     guar: ErrorGuaranteed,
 ) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
     let err = Ty::new_error(tcx, guar);
 
-    let arity = if let Some(info) = cycle_error.cycle.get(0)
-        && info.frame.dep_kind == DepKind::fn_sig
-        && let Some(def_id) = info.frame.def_id
-        && let Some(node) = tcx.hir_get_if_local(def_id)
+    let arity = if let Some(node) = tcx.hir_get_if_local(def_id)
         && let Some(sig) = node.fn_sig()
     {
         sig.decl.inputs.len()
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index ddce89234590..78d5fd3de1f0 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -487,7 +487,7 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                     #[cfg(not($cache_on_disk))]
                     is_loadable_from_disk_fn: |_tcx, _key, _index| false,
 
-                    value_from_cycle_error: |tcx, cycle, _| {
+                    value_from_cycle_error: |tcx, _, cycle, _| {
                         $crate::from_cycle_error::default(tcx, cycle, stringify!($name))
                     },
 

From 3464048bc49281f0f947178081f4d41993d253e1 Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Wed, 11 Mar 2026 15:10:55 -0700
Subject: [PATCH 0368/1059] test(parallel): Add regression test for #153391

Co-authored-by: Daria Sukhonina <zetanumbers@users.noreply.github.com>
---
 .../parallel-rustc/fn-sig-cycle-ice-153391.rs | 18 +++++++++++
 .../fn-sig-cycle-ice-153391.stderr            | 31 +++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs
 create mode 100644 tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr

diff --git a/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs
new file mode 100644
index 000000000000..0108ada8c08c
--- /dev/null
+++ b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.rs
@@ -0,0 +1,18 @@
+// Regression test for #153391.
+//
+//@ edition:2024
+//@ compile-flags: -Z threads=16
+//@ compare-output-by-lines
+//@ ignore-test (#142063)
+
+trait A {
+    fn g() -> B;
+    //~^ ERROR expected a type, found a trait
+}
+
+trait B {
+    fn bar(&self, x: &A);
+    //~^ ERROR expected a type, found a trait
+}
+
+fn main() {}
diff --git a/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr
new file mode 100644
index 000000000000..4d348cf22f4e
--- /dev/null
+++ b/tests/ui/parallel-rustc/fn-sig-cycle-ice-153391.stderr
@@ -0,0 +1,31 @@
+error[E0782]: expected a type, found a trait
+  --> $DIR/fn-sig-cycle-ice-153391.rs:8:15
+   |
+LL |     fn g() -> B;
+   |               ^
+   |
+help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn g() -> impl B;
+   |               ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/fn-sig-cycle-ice-153391.rs:13:23
+   |
+LL |     fn bar(&self, x: &A);
+   |                       ^
+   |
+   = note: `A` is dyn-incompatible, otherwise a trait object could be used
+help: use a new generic type parameter, constrained by `A`
+   |
+LL -     fn bar(&self, x: &A);
+LL +     fn bar<T: A>(&self, x: &T);
+   |
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn bar(&self, x: &impl A);
+   |                       ++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0782`.

From 4d47b07353e2d5014f08dc5ff9b913c1df1e2c58 Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Wed, 11 Mar 2026 22:39:51 -0400
Subject: [PATCH 0369/1059] Detect existing turbofish on method calls to
 suppress useless suggestion

---
 .../error_reporting/infer/need_type_info.rs   |  5 +++-
 .../inference/useless-turbofish-suggestion.rs | 28 +++++++++++++++++++
 .../useless-turbofish-suggestion.stderr       | 20 +++++++++++++
 3 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/inference/useless-turbofish-suggestion.rs
 create mode 100644 tests/ui/inference/useless-turbofish-suggestion.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 80e97d36c23f..629bd30d88e8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -1030,12 +1030,15 @@ fn expr_inferred_arg_iter(
                         let args = self.node_args_opt(expr.hir_id)?;
                         let span = tcx.hir_span(segment.hir_id);
                         let insert_span = segment.ident.span.shrink_to_hi().with_hi(span.hi());
+                        let have_turbofish = segment.args.is_some_and(|args| {
+                            args.args.iter().any(|arg| arg.is_ty_or_const())
+                        });
                         InsertableGenericArgs {
                             insert_span,
                             args,
                             generics_def_id: def_id,
                             def_id,
-                            have_turbofish: false,
+                            have_turbofish,
                         }
                     };
                     return Box::new(insertable.into_iter());
diff --git a/tests/ui/inference/useless-turbofish-suggestion.rs b/tests/ui/inference/useless-turbofish-suggestion.rs
new file mode 100644
index 000000000000..ed86df6296ca
--- /dev/null
+++ b/tests/ui/inference/useless-turbofish-suggestion.rs
@@ -0,0 +1,28 @@
+// Regression test for #153732.
+//
+// When a method call already has turbofish type arguments, don't suggest
+// rewriting them — the suggestion just rewrites user syntax into
+// fully-qualified form without resolving anything.
+//
+// The span still points at the method name rather than the unresolved `_`;
+// fixing that is left as future work.
+
+struct S;
+
+impl S {
+    fn f<A, B>(self, _a: A) -> B {
+        todo!()
+    }
+}
+
+fn with_turbofish() {
+    S.f::<u32, _>(42);
+    //~^ ERROR type annotations needed
+}
+
+fn without_turbofish() {
+    S.f(42);
+    //~^ ERROR type annotations needed
+}
+
+fn main() {}
diff --git a/tests/ui/inference/useless-turbofish-suggestion.stderr b/tests/ui/inference/useless-turbofish-suggestion.stderr
new file mode 100644
index 000000000000..25b05801aa47
--- /dev/null
+++ b/tests/ui/inference/useless-turbofish-suggestion.stderr
@@ -0,0 +1,20 @@
+error[E0282]: type annotations needed
+  --> $DIR/useless-turbofish-suggestion.rs:19:7
+   |
+LL |     S.f::<u32, _>(42);
+   |       ^ cannot infer type of the type parameter `B` declared on the method `f`
+
+error[E0282]: type annotations needed
+  --> $DIR/useless-turbofish-suggestion.rs:24:7
+   |
+LL |     S.f(42);
+   |       ^ cannot infer type of the type parameter `B` declared on the method `f`
+   |
+help: consider specifying the generic arguments
+   |
+LL |     S.f::<i32, B>(42);
+   |        ++++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0282`.

From ab1002013e1524f1230dd7a3158fb020c12160fa Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 12 Mar 2026 05:16:00 +0000
Subject: [PATCH 0370/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to d1ee5e59a964a419b84b760812a35075034f4861.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 24a7dd2899d5..998ecc08a8e1 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-2d76d9bc76f27b03b4899e72ce561c7ac2c5cf6b
+d1ee5e59a964a419b84b760812a35075034f4861

From 5064056dd3971930ad83eaaccf91f1561a274f0d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 9 Mar 2026 16:15:38 +0100
Subject: [PATCH 0371/1059] interpreter error reporting: remove arguments that
 are always the same

---
 .../rustc_const_eval/src/const_eval/error.rs  | 25 +++----
 .../src/const_eval/eval_queries.rs            | 68 ++++++++-----------
 2 files changed, 37 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 61e8e433d517..d01dc0b8bd41 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -8,7 +8,7 @@
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::ConstInt;
 use rustc_middle::ty::layout::LayoutError;
-use rustc_span::{Span, Symbol};
+use rustc_span::{DUMMY_SP, Span, Symbol};
 
 use super::CompileTimeMachine;
 use crate::errors::{self, FrameNote};
@@ -164,36 +164,29 @@ pub fn get_span_and_frames<'tcx>(
 /// This will use the `mk` function for adding more information to the error.
 /// You can use it to add a stacktrace of current execution according to
 /// `get_span_and_frames` or just give context on where the const eval error happened.
-pub(super) fn report<'tcx, C, F>(
+pub(super) fn report<'tcx>(
     ecx: &InterpCx<'tcx, CompileTimeMachine<'tcx>>,
     error: InterpErrorKind<'tcx>,
-    span: Span,
-    get_span_and_frames: C,
-    mk: F,
-) -> ErrorHandled
-where
-    C: FnOnce() -> (Span, Vec<FrameNote>),
-    F: FnOnce(&mut Diag<'_>, Span, Vec<FrameNote>),
-{
+    mk: impl FnOnce(&mut Diag<'_>, Span, Vec<FrameNote>),
+) -> ErrorHandled {
     let tcx = ecx.tcx.tcx;
     // Special handling for certain errors
     match error {
         // Don't emit a new diagnostic for these errors, they are already reported elsewhere or
         // should remain silent.
-        err_inval!(AlreadyReported(info)) => ErrorHandled::Reported(info, span),
+        err_inval!(AlreadyReported(info)) => ErrorHandled::Reported(info, DUMMY_SP),
         err_inval!(Layout(LayoutError::TooGeneric(_))) | err_inval!(TooGeneric) => {
-            ErrorHandled::TooGeneric(span)
+            ErrorHandled::TooGeneric(DUMMY_SP)
         }
         err_inval!(Layout(LayoutError::ReferencesError(guar))) => {
             // This can occur in infallible promoteds e.g. when a non-existent type or field is
             // encountered.
-            ErrorHandled::Reported(ReportedErrorInfo::allowed_in_infallible(guar), span)
+            ErrorHandled::Reported(ReportedErrorInfo::allowed_in_infallible(guar), DUMMY_SP)
         }
         // Report remaining errors.
         _ => {
-            let (our_span, frames) = get_span_and_frames();
-            let span = span.substitute_dummy(our_span);
-            let mut err = tcx.dcx().struct_span_err(our_span, error.to_string());
+            let (span, frames) = super::get_span_and_frames(ecx.tcx, ecx.stack());
+            let mut err = tcx.dcx().struct_span_err(span, error.to_string());
             if matches!(
                 error,
                 InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::ValidationError {
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 2dbf2cc91058..a12f8606bbea 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -11,8 +11,8 @@
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, throw_inval};
+use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument, trace};
 
 use super::{CanAccessMutGlobal, CompileTimeInterpCx, CompileTimeMachine};
@@ -458,32 +458,26 @@ fn report_eval_error<'tcx>(
     let (error, backtrace) = error.into_parts();
     backtrace.print_backtrace();
 
-    super::report(
-        ecx,
-        error,
-        DUMMY_SP,
-        || super::get_span_and_frames(ecx.tcx, ecx.stack()),
-        |diag, span, frames| {
-            let num_frames = frames.len();
-            // FIXME(oli-obk): figure out how to use structured diagnostics again.
-            diag.code(E0080);
-            diag.span_label(
-                span,
-                msg!(
-                    "evaluation of `{$instance}` failed {$num_frames ->
+    super::report(ecx, error, |diag, span, frames| {
+        let num_frames = frames.len();
+        // FIXME(oli-obk): figure out how to use structured diagnostics again.
+        diag.code(E0080);
+        diag.span_label(
+            span,
+            msg!(
+                "evaluation of `{$instance}` failed {$num_frames ->
                         [0] here
                         *[other] inside this call
                     }"
-                ),
-            );
-            for frame in frames {
-                diag.subdiagnostic(frame);
-            }
-            // Add after the frame rendering above, as it adds its own `instance` args.
-            diag.arg("instance", with_no_trimmed_paths!(cid.instance.to_string()));
-            diag.arg("num_frames", num_frames);
-        },
-    )
+            ),
+        );
+        for frame in frames {
+            diag.subdiagnostic(frame);
+        }
+        // Add after the frame rendering above, as it adds its own `instance` args.
+        diag.arg("instance", with_no_trimmed_paths!(cid.instance.to_string()));
+        diag.arg("num_frames", num_frames);
+    })
 }
 
 #[inline(never)]
@@ -506,20 +500,14 @@ fn report_validation_error<'tcx>(
     let raw_bytes =
         errors::RawBytesNote { size: info.size.bytes(), align: info.align.bytes(), bytes };
 
-    crate::const_eval::report(
-        ecx,
-        error,
-        DUMMY_SP,
-        || crate::const_eval::get_span_and_frames(ecx.tcx, ecx.stack()),
-        move |diag, span, frames| {
-            // FIXME(oli-obk): figure out how to use structured diagnostics again.
-            diag.code(E0080);
-            diag.span_label(span, "it is undefined behavior to use this value");
-            diag.note("the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.");
-            for frame in frames {
-                diag.subdiagnostic(frame);
-            }
-            diag.subdiagnostic(raw_bytes);
-        },
-    )
+    crate::const_eval::report(ecx, error, move |diag, span, frames| {
+        // FIXME(oli-obk): figure out how to use structured diagnostics again.
+        diag.code(E0080);
+        diag.span_label(span, "it is undefined behavior to use this value");
+        diag.note("the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.");
+        for frame in frames {
+            diag.subdiagnostic(frame);
+        }
+        diag.subdiagnostic(raw_bytes);
+    })
 }

From 46e3c4d2583f0983ffd9c5be3e2d4ce646bf8376 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 11 Mar 2026 15:40:03 +0100
Subject: [PATCH 0372/1059] further cleanup and deduplication

---
 .../rustc_const_eval/src/const_eval/error.rs  |  3 ++-
 .../src/const_eval/eval_queries.rs            | 21 +++++--------------
 2 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index d01dc0b8bd41..c48b33e29eb6 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -1,6 +1,6 @@
 use std::{fmt, mem};
 
-use rustc_errors::Diag;
+use rustc_errors::{Diag, E0080};
 use rustc_middle::mir::AssertKind;
 use rustc_middle::mir::interpret::{
     AllocId, Provenance, ReportedErrorInfo, UndefinedBehaviorInfo, UnsupportedOpInfo,
@@ -187,6 +187,7 @@ pub(super) fn report<'tcx>(
         _ => {
             let (span, frames) = super::get_span_and_frames(ecx.tcx, ecx.stack());
             let mut err = tcx.dcx().struct_span_err(span, error.to_string());
+            err.code(E0080);
             if matches!(
                 error,
                 InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::ValidationError {
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index a12f8606bbea..b74d2963a30d 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -2,7 +2,6 @@
 
 use either::{Left, Right};
 use rustc_abi::{self as abi, BackendRepr};
-use rustc_errors::{E0080, msg};
 use rustc_hir::def::DefKind;
 use rustc_middle::mir::interpret::{AllocId, ErrorHandled, InterpErrorInfo, ReportedErrorInfo};
 use rustc_middle::mir::{self, ConstAlloc, ConstValue};
@@ -460,23 +459,17 @@ fn report_eval_error<'tcx>(
 
     super::report(ecx, error, |diag, span, frames| {
         let num_frames = frames.len();
-        // FIXME(oli-obk): figure out how to use structured diagnostics again.
-        diag.code(E0080);
         diag.span_label(
             span,
-            msg!(
-                "evaluation of `{$instance}` failed {$num_frames ->
-                        [0] here
-                        *[other] inside this call
-                    }"
+            format!(
+                "evaluation of `{instance}` failed {where_}",
+                instance = with_no_trimmed_paths!(cid.instance.to_string()),
+                where_ = if num_frames == 0 { "here" } else { "inside this call" },
             ),
         );
         for frame in frames {
             diag.subdiagnostic(frame);
         }
-        // Add after the frame rendering above, as it adds its own `instance` args.
-        diag.arg("instance", with_no_trimmed_paths!(cid.instance.to_string()));
-        diag.arg("num_frames", num_frames);
     })
 }
 
@@ -501,13 +494,9 @@ fn report_validation_error<'tcx>(
         errors::RawBytesNote { size: info.size.bytes(), align: info.align.bytes(), bytes };
 
     crate::const_eval::report(ecx, error, move |diag, span, frames| {
-        // FIXME(oli-obk): figure out how to use structured diagnostics again.
-        diag.code(E0080);
         diag.span_label(span, "it is undefined behavior to use this value");
         diag.note("the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.");
-        for frame in frames {
-            diag.subdiagnostic(frame);
-        }
+        assert!(frames.is_empty()); // we just report validation errors for the final const here
         diag.subdiagnostic(raw_bytes);
     })
 }

From ac062fd2238552eaddfd429e71bff14c066c5ea2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 11 Mar 2026 17:20:41 +0100
Subject: [PATCH 0373/1059] Allow auto jobs to be non-blocking

---
 src/ci/citool/src/jobs.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/ci/citool/src/jobs.rs b/src/ci/citool/src/jobs.rs
index 245ab31fa644..cc93761e9604 100644
--- a/src/ci/citool/src/jobs.rs
+++ b/src/ci/citool/src/jobs.rs
@@ -200,12 +200,14 @@ fn equivalent_modulo_carve_out(pr_job: &Job, auto_job: &Job) -> anyhow::Result<(
         equivalent_modulo_carve_out(pr_job, auto_job)?;
     }
 
-    // Auto CI jobs must all "fail-fast" to avoid wasting Auto CI resources. For instance, `tidy`.
+    // Auto CI should "fail-fast" to avoid wasting Auto CI resources.
+    // However, some experimental auto jobs can be made optional, for example if we are unsure about
+    // their flakiness. Those have to be prefixed with `optional-`.
     for auto_job in &db.auto_jobs {
-        if auto_job.continue_on_error == Some(true) {
+        if auto_job.continue_on_error == Some(true) && !auto_job.name.starts_with("optional-") {
             return Err(anyhow!(
-                "Auto job `{}` cannot have `continue_on_error: true`",
-                auto_job.name
+                "Auto job `{job}` cannot have `continue_on_error: true`. If the job should be optional, name it `optional-{job}`.",
+                job = auto_job.name
             ));
         }
     }

From 96e4833bead3217951fcd4604a3b1a3a92b59059 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 12 Mar 2026 09:07:02 +0100
Subject: [PATCH 0374/1059] Add new CI job that runs tests with a toolchain
 built with multiple threads

---
 .../Dockerfile                                | 36 +++++++++++++++++++
 src/ci/github-actions/jobs.yml                |  5 +++
 2 files changed, 41 insertions(+)
 create mode 100644 src/ci/docker/host-x86_64/optional-x86_64-gnu-parallel-frontend/Dockerfile

diff --git a/src/ci/docker/host-x86_64/optional-x86_64-gnu-parallel-frontend/Dockerfile b/src/ci/docker/host-x86_64/optional-x86_64-gnu-parallel-frontend/Dockerfile
new file mode 100644
index 000000000000..8f7c7ebe3555
--- /dev/null
+++ b/src/ci/docker/host-x86_64/optional-x86_64-gnu-parallel-frontend/Dockerfile
@@ -0,0 +1,36 @@
+FROM ubuntu:22.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  g++ \
+  make \
+  ninja-build \
+  file \
+  curl \
+  ca-certificates \
+  python3 \
+  git \
+  cmake \
+  sudo \
+  gdb \
+  libssl-dev \
+  pkg-config \
+  xz-utils \
+  mingw-w64 \
+  zlib1g-dev \
+  libzstd-dev \
+  && rm -rf /var/lib/apt/lists/*
+
+COPY scripts/sccache.sh /scripts/
+RUN sh /scripts/sccache.sh
+
+ENV RUST_CONFIGURE_ARGS \
+ --build=x86_64-unknown-linux-gnu \
+ --enable-sanitizers \
+ --enable-profiler \
+ --enable-compiler-docs \
+ --set llvm.libzstd=true
+
+# Build the toolchain with multiple parallel frontend threads and then run tests
+# Tests are still compiled serially at the moment (intended to be changed in follow-ups).
+ENV SCRIPT python3 ../x.py --stage 2 test --set rust.parallel-frontend-threads=4
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 0687d142a350..563083cd450b 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -348,6 +348,11 @@ auto:
   - name: x86_64-gnu
     <<: *job-linux-4c
 
+  - name: optional-x86_64-gnu-parallel-frontend
+    # This test can be flaky, so do not cancel CI if it fails, for now.
+    continue_on_error: true
+    <<: *job-linux-4c
+
   - name: x86_64-gnu-gcc
     doc_url: https://rustc-dev-guide.rust-lang.org/tests/codegen-backend-tests/cg_gcc.html
     <<: *job-linux-4c

From b3333b3aafbc572009f3ca5f3e183ac82bd9218c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 12 Mar 2026 09:35:56 +0100
Subject: [PATCH 0375/1059] Document optional auto jobs in the rustc-dev-guide

---
 src/doc/rustc-dev-guide/src/tests/ci.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index 6b63f68b29ee..5161194492e6 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -109,6 +109,12 @@ The live results can be seen on [the GitHub Actions workflows page].
 At any given time, at most a single `auto` build is being executed.
 Find out more in [Merging PRs serially with bors](#merging-prs-serially-with-bors).
 
+Normally, when an auto job fails, the whole CI workflow immediately ends. However, it can be useful to
+create auto jobs that are "non-blocking", or optional, to test them on CI for some time before blocking
+merges on them. This can be useful if those jobs can be flaky.
+
+To do that, prefix such a job with `optional-`, and set `continue_on_error: true` for it in [`jobs.yml`]. 
+
 [platform tiers]: https://forge.rust-lang.org/release/platform-support.html#rust-platform-support
 [auto]: https://github.com/rust-lang/rust/tree/automation/bors/auto
 

From 687d7dbc23753f3d6eca80cccd57dc3432325a8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Thu, 12 Mar 2026 09:36:46 +0100
Subject: [PATCH 0376/1059] actually make the is-fn test test what it says it
 tests

---
 tests/ui/async-await/async-closures/is-fn.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/async-await/async-closures/is-fn.rs b/tests/ui/async-await/async-closures/is-fn.rs
index 45c2b6ae342b..1d546cd44b49 100644
--- a/tests/ui/async-await/async-closures/is-fn.rs
+++ b/tests/ui/async-await/async-closures/is-fn.rs
@@ -9,11 +9,11 @@
 
 extern crate block_on;
 
-// Check that closures that don't capture any state may implement `Fn`.
+// Check that async closures that don't capture any state may implement `Fn`.
 
 fn main() {
     block_on::block_on(async {
-        async fn call_once<F: Future>(x: impl FnOnce(&'static str) -> F) -> F::Output {
+        async fn call_once<F: Future>(x: impl Fn(&'static str) -> F) -> F::Output {
             x("hello, world").await
         }
         call_once(async |x: &'static str| {

From 06704919507893e4e26a3fc0adf5aefaf0356199 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Thu, 12 Mar 2026 03:52:53 -0500
Subject: [PATCH 0377/1059] Don't add empty target features for
 target-cpu=native on macOS

LLVM does not support host feature detection (only host cpu
detection) on apple platforms. As such, the returned feature
string will be empty. Adding this empty string to the target-features
attribute results in a verifier error on LLVM 22.

Fix this by not adding the empty string to the target features.
The reason why this was not caught by the target-cpu-native test
is that it requires a function that adds *some* target features,
otherwise the attribute is omitted entirely. We achieve this with
a somewhat peculiar construction that enables `neon` if it's
already enabled. (This is to avoid enabling it on softfloat targets.)
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 4 +++-
 tests/run-make/target-cpu-native/foo.rs      | 8 ++++++++
 tests/run-make/target-cpu-native/rmake.rs    | 7 ++++++-
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index fbb582fe8601..85b515f2ef9c 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -702,7 +702,9 @@ pub(crate) fn global_llvm_features(sess: &Session, only_base_features: bool) ->
 
                 features_string
             };
-            features.extend(features_string.split(',').map(String::from));
+            if !features_string.is_empty() {
+                features.extend(features_string.split(',').map(String::from));
+            }
         }
         Some(_) | None => {}
     };
diff --git a/tests/run-make/target-cpu-native/foo.rs b/tests/run-make/target-cpu-native/foo.rs
index f328e4d9d04c..5abcd25abc3f 100644
--- a/tests/run-make/target-cpu-native/foo.rs
+++ b/tests/run-make/target-cpu-native/foo.rs
@@ -1 +1,9 @@
 fn main() {}
+
+// This forces explicit emission of a +neon target feature on targets
+// where it is implied by the target-cpu, like aarch64-apple-darwin.
+// This is a regression test for #153397.
+#[cfg(target_feature = "neon")]
+#[target_feature(enable = "neon")]
+#[unsafe(no_mangle)]
+pub fn with_neon() {}
diff --git a/tests/run-make/target-cpu-native/rmake.rs b/tests/run-make/target-cpu-native/rmake.rs
index 7b7974f30978..5791bf01bba2 100644
--- a/tests/run-make/target-cpu-native/rmake.rs
+++ b/tests/run-make/target-cpu-native/rmake.rs
@@ -8,7 +8,12 @@
 use run_make_support::{run, rustc};
 
 fn main() {
-    let out = rustc().input("foo.rs").arg("-Ctarget-cpu=native").run().stderr_utf8();
+    let out = rustc()
+        .input("foo.rs")
+        .arg("-Ctarget-cpu=native")
+        .arg("-Zverify-llvm-ir")
+        .run()
+        .stderr_utf8();
     run("foo");
     // There should be zero warnings emitted - the bug would cause "unknown CPU `native`"
     // to be printed out.

From ae4ddd2806b7abcabf33fb6ef61f01c5e675c8b9 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Thu, 12 Mar 2026 08:44:28 +0000
Subject: [PATCH 0378/1059] Reject const closures outside const contexts

---
 compiler/rustc_ast_lowering/src/expr.rs       | 11 ++++++--
 compiler/rustc_ast_lowering/src/item.rs       | 24 +++++++++++++++---
 compiler/rustc_ast_lowering/src/lib.rs        |  2 ++
 .../const-closure-issue-125866-error.rs       |  4 +--
 .../const-closure-issue-125866-pass.rs        | 25 -------------------
 ...closure-const_trait_impl-ice-113381.stderr |  7 +++---
 tests/ui/traits/const-traits/gate.rs          |  6 ++---
 tests/ui/traits/const-traits/gate.stderr      | 14 +++++------
 ...-const-op-const-closure-non-const-outer.rs |  2 +-
 ...st-op-const-closure-non-const-outer.stderr |  7 +++---
 10 files changed, 50 insertions(+), 52 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/const-closure-issue-125866-pass.rs

diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index e86a2f33b87b..46b33a481214 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1062,7 +1062,7 @@ fn lower_expr_closure(
         binder: &ClosureBinder,
         capture_clause: CaptureBy,
         closure_id: NodeId,
-        constness: Const,
+        mut constness: Const,
         movability: Movability,
         decl: &FnDecl,
         body: &Expr,
@@ -1072,11 +1072,18 @@ fn lower_expr_closure(
         let closure_def_id = self.local_def_id(closure_id);
         let (binder_clause, generic_params) = self.lower_closure_binder(binder);
 
+        if let Const::Yes(span) = constness {
+            if !self.is_in_const_context {
+                self.dcx().span_err(span, "cannot use `const` closures outside of const contexts");
+                constness = Const::No;
+            }
+        }
+
         let (body_id, closure_kind) = self.with_new_scopes(fn_decl_span, move |this| {
             let mut coroutine_kind = find_attr!(attrs, Coroutine(_) => hir::CoroutineKind::Coroutine(Movability::Movable));
 
             // FIXME(contracts): Support contracts on closures?
-            let body_id = this.lower_fn_body(decl, None, |this| {
+            let body_id = this.lower_fn_body(decl, None, constness, |this| {
                 this.coroutine_kind = coroutine_kind;
                 let e = this.lower_expr_mut(body);
                 coroutine_kind = this.coroutine_kind;
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index ed78b77a704f..e2ac38caf295 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1,3 +1,5 @@
+use std::mem;
+
 use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
@@ -345,6 +347,7 @@ fn lower_item_kind(
                         body.as_deref(),
                         attrs,
                         contract.as_deref(),
+                        header.constness,
                     );
 
                     let itctx = ImplTraitContext::Universal;
@@ -1024,6 +1027,7 @@ fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
                     Some(body),
                     attrs,
                     contract.as_deref(),
+                    sig.header.constness,
                 );
                 let (generics, sig) = self.lower_method_sig(
                     generics,
@@ -1217,6 +1221,7 @@ fn lower_impl_item(
                     body.as_deref(),
                     attrs,
                     contract.as_deref(),
+                    sig.header.constness,
                 );
                 let (generics, sig) = self.lower_method_sig(
                     generics,
@@ -1346,11 +1351,13 @@ pub(super) fn lower_body(
         f: impl FnOnce(&mut Self) -> (&'hir [hir::Param<'hir>], hir::Expr<'hir>),
     ) -> hir::BodyId {
         let prev_coroutine_kind = self.coroutine_kind.take();
+        let prev_is_in_const_context = mem::take(&mut self.is_in_const_context);
         let task_context = self.task_context.take();
         let (parameters, result) = f(self);
         let body_id = self.record_body(parameters, result);
         self.task_context = task_context;
         self.coroutine_kind = prev_coroutine_kind;
+        self.is_in_const_context = prev_is_in_const_context;
         body_id
     }
 
@@ -1369,9 +1376,13 @@ pub(super) fn lower_fn_body(
         &mut self,
         decl: &FnDecl,
         contract: Option<&FnContract>,
+        constness: Const,
         body: impl FnOnce(&mut Self) -> hir::Expr<'hir>,
     ) -> hir::BodyId {
         self.lower_body(|this| {
+            if let Const::Yes(_) = constness {
+                this.is_in_const_context = true;
+            }
             let params =
                 this.arena.alloc_from_iter(decl.inputs.iter().map(|x| this.lower_param(x)));
 
@@ -1389,8 +1400,9 @@ fn lower_fn_body_block(
         decl: &FnDecl,
         body: &Block,
         contract: Option<&FnContract>,
+        constness: Const,
     ) -> hir::BodyId {
-        self.lower_fn_body(decl, contract, |this| this.lower_block_expr(body))
+        self.lower_fn_body(decl, contract, constness, |this| this.lower_block_expr(body))
     }
 
     pub(super) fn lower_const_body(&mut self, span: Span, expr: Option<&Expr>) -> hir::BodyId {
@@ -1398,7 +1410,10 @@ pub(super) fn lower_const_body(&mut self, span: Span, expr: Option<&Expr>) -> hi
             (
                 &[],
                 match expr {
-                    Some(expr) => this.lower_expr_mut(expr),
+                    Some(expr) => {
+                        this.is_in_const_context = true;
+                        this.lower_expr_mut(expr)
+                    }
                     None => this.expr_err(span, this.dcx().span_delayed_bug(span, "no block")),
                 },
             )
@@ -1417,12 +1432,13 @@ fn lower_maybe_coroutine_body(
         body: Option<&Block>,
         attrs: &'hir [hir::Attribute],
         contract: Option<&FnContract>,
+        constness: Const,
     ) -> hir::BodyId {
         let Some(body) = body else {
             // Functions without a body are an error, except if this is an intrinsic. For those we
             // create a fake body so that the entire rest of the compiler doesn't have to deal with
             // this as a special case.
-            return self.lower_fn_body(decl, contract, |this| {
+            return self.lower_fn_body(decl, contract, constness, |this| {
                 if find_attr!(attrs, RustcIntrinsic) || this.tcx.is_sdylib_interface_build() {
                     let span = this.lower_span(span);
                     let empty_block = hir::Block {
@@ -1447,7 +1463,7 @@ fn lower_maybe_coroutine_body(
         };
         let Some(coroutine_kind) = coroutine_kind else {
             // Typical case: not a coroutine.
-            return self.lower_fn_body_block(decl, body, contract);
+            return self.lower_fn_body_block(decl, body, contract, constness);
         };
         // FIXME(contracts): Support contracts on async fn.
         self.lower_body(|this| {
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index c3525d124670..e8092b540ec8 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -129,6 +129,7 @@ struct LoweringContext<'a, 'hir> {
     loop_scope: Option<HirId>,
     is_in_loop_condition: bool,
     is_in_dyn_type: bool,
+    is_in_const_context: bool,
 
     current_hir_id_owner: hir::OwnerId,
     item_local_id_counter: hir::ItemLocalId,
@@ -190,6 +191,7 @@ fn new(
             loop_scope: None,
             is_in_loop_condition: false,
             is_in_dyn_type: false,
+            is_in_const_context: false,
             coroutine_kind: None,
             task_context: None,
             current_item: None,
diff --git a/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs b/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
index 7a44920bb729..e13ee39631a3 100644
--- a/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
+++ b/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
@@ -16,9 +16,9 @@
 }
 
 fn main() {
-    let x = create_array(const |i| 2 * i as u32);
+    let x = const { create_array(const |i| 2 * i as u32) };
     assert_eq!(x, [0, 2, 4, 6, 8]);
 
-    let y = create_array(const |i| 2 * i as u32 + 1);
+    let y = const { create_array(const |i| 2 * i as u32 + 1) };
     assert_eq!(y, [1, 3, 5, 7, 9]);
 }
diff --git a/tests/ui/traits/const-traits/const-closure-issue-125866-pass.rs b/tests/ui/traits/const-traits/const-closure-issue-125866-pass.rs
deleted file mode 100644
index af7375172e67..000000000000
--- a/tests/ui/traits/const-traits/const-closure-issue-125866-pass.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ check-pass
-
-#![allow(incomplete_features)]
-#![feature(const_closures, const_trait_impl)]
-
-const fn create_array<const N: usize>(mut f: impl [const] FnMut(usize) -> u32 + Copy) -> [u32; N] {
-    let mut array = [0; N];
-    let mut i = 0;
-    loop {
-        array[i] = f(i);
-        i += 1;
-        if i == N {
-            break;
-        }
-    }
-    array
-}
-
-fn main() {
-    let x = create_array(const |i| 2 * i as u32);
-    assert_eq!(x, [0, 2, 4, 6, 8]);
-
-    let y = create_array(const |i| 2 * i as u32 + 1);
-    assert_eq!(y, [1, 3, 5, 7, 9]);
-}
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
index dab3f14161fa..bbe736b94b5b 100644
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
+++ b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
@@ -1,9 +1,8 @@
-error[E0277]: the trait bound `{closure@$DIR/const_closure-const_trait_impl-ice-113381.rs:15:6: 15:14}: [const] Fn()` is not satisfied
-  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:15:5
+error: cannot use `const` closures outside of const contexts
+  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:15:6
    |
 LL |     (const || (()).foo())();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |      ^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/gate.rs b/tests/ui/traits/const-traits/gate.rs
index 3f348c841393..86b42099d289 100644
--- a/tests/ui/traits/const-traits/gate.rs
+++ b/tests/ui/traits/const-traits/gate.rs
@@ -1,13 +1,13 @@
 // gate-test-const_closures
 
 fn main() {
-    (const || {})();
+    const { (const || {})() };
     //~^ ERROR: const closures are experimental
-    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:6: 4:14}: [const] Fn()` is not satisfied
+    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: [const] Fn()` is not satisfied
 }
 
 macro_rules! e {
-    ($e:expr) => {}
+    ($e:expr) => {};
 }
 
 e!((const || {}));
diff --git a/tests/ui/traits/const-traits/gate.stderr b/tests/ui/traits/const-traits/gate.stderr
index 6bef2c511ce7..b86217943d77 100644
--- a/tests/ui/traits/const-traits/gate.stderr
+++ b/tests/ui/traits/const-traits/gate.stderr
@@ -1,8 +1,8 @@
 error[E0658]: const closures are experimental
-  --> $DIR/gate.rs:4:6
+  --> $DIR/gate.rs:4:14
    |
-LL |     (const || {})();
-   |      ^^^^^
+LL |     const { (const || {})() };
+   |              ^^^^^
    |
    = note: see issue #106003 <https://github.com/rust-lang/rust/issues/106003> for more information
    = help: add `#![feature(const_closures)]` to the crate attributes to enable
@@ -18,11 +18,11 @@ LL | e!((const || {}));
    = help: add `#![feature(const_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:6: 4:14}: [const] Fn()` is not satisfied
-  --> $DIR/gate.rs:4:5
+error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: [const] Fn()` is not satisfied
+  --> $DIR/gate.rs:4:13
    |
-LL |     (const || {})();
-   |     ^^^^^^^^^^^^^^^
+LL |     const { (const || {})() };
+   |             ^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
index de5bedf0ace7..a13fab3b21db 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
@@ -13,5 +13,5 @@ fn main() {
     // #150052 deduplicate diagnostics for const trait supertraits
     // so we only get one error here
     (const || { (()).foo() })();
-    //~^ ERROR: }: [const] Fn()` is not satisfied
+    //~^ ERROR: cannot use `const` closures outside of const contexts
 }
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
index efbedca1c7e7..43c98ec7c661 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
@@ -1,9 +1,8 @@
-error[E0277]: the trait bound `{closure@$DIR/non-const-op-const-closure-non-const-outer.rs:15:6: 15:14}: [const] Fn()` is not satisfied
-  --> $DIR/non-const-op-const-closure-non-const-outer.rs:15:5
+error: cannot use `const` closures outside of const contexts
+  --> $DIR/non-const-op-const-closure-non-const-outer.rs:15:6
    |
 LL |     (const || { (()).foo() })();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |      ^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.

From e8a46117795f82f35e2f4087516a8743e28ba174 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Thu, 12 Mar 2026 08:38:41 +0000
Subject: [PATCH 0379/1059] Const closure's const context is the same as their
 parent

---
 compiler/rustc_middle/src/hir/map.rs                   | 10 ++++++----
 tests/ui/traits/const-traits/call-const-closure.rs     |  3 +--
 tests/ui/traits/const-traits/call-const-closure.stderr |  2 +-
 tests/ui/traits/const-traits/call.rs                   |  2 +-
 tests/ui/traits/const-traits/call.stderr               |  2 +-
 tests/ui/traits/const-traits/gate.rs                   |  2 +-
 tests/ui/traits/const-traits/gate.stderr               |  2 +-
 7 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index cf1b863f754c..fc2a7fbd4fa9 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -310,16 +310,18 @@ pub fn hir_body_owner_kind(self, def_id: impl Into<DefId>) -> BodyOwnerKind {
     /// This should only be used for determining the context of a body, a return
     /// value of `Some` does not always suggest that the owner of the body is `const`,
     /// just that it has to be checked as if it were.
-    pub fn hir_body_const_context(self, def_id: LocalDefId) -> Option<ConstContext> {
-        let def_id = def_id.into();
+    pub fn hir_body_const_context(self, local_def_id: LocalDefId) -> Option<ConstContext> {
+        let def_id = local_def_id.into();
         let ccx = match self.hir_body_owner_kind(def_id) {
             BodyOwnerKind::Const { inline } => ConstContext::Const { inline },
             BodyOwnerKind::Static(mutability) => ConstContext::Static(mutability),
 
             BodyOwnerKind::Fn if self.is_constructor(def_id) => return None,
-            BodyOwnerKind::Fn | BodyOwnerKind::Closure if self.is_const_fn(def_id) => {
-                ConstContext::ConstFn
+            // Const closures use their parent's const context
+            BodyOwnerKind::Closure if self.is_const_fn(def_id) => {
+                return self.hir_body_const_context(self.local_parent(local_def_id));
             }
+            BodyOwnerKind::Fn if self.is_const_fn(def_id) => ConstContext::ConstFn,
             BodyOwnerKind::Fn | BodyOwnerKind::Closure | BodyOwnerKind::GlobalAsm => return None,
         };
 
diff --git a/tests/ui/traits/const-traits/call-const-closure.rs b/tests/ui/traits/const-traits/call-const-closure.rs
index c4293579aea8..a26f7be1148d 100644
--- a/tests/ui/traits/const-traits/call-const-closure.rs
+++ b/tests/ui/traits/const-traits/call-const-closure.rs
@@ -14,8 +14,7 @@ fn foo(&self) {}
 
 const FOO: () = {
     (const || ().foo())();
-    //~^ ERROR the trait bound `(): [const] Bar` is not satisfied
-    // FIXME(const_trait_impl): The constness environment for const closures is wrong.
+    //~^ ERROR the trait bound `(): const Bar` is not satisfied
 };
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/call-const-closure.stderr b/tests/ui/traits/const-traits/call-const-closure.stderr
index 9a851a97f186..16b936d58aaf 100644
--- a/tests/ui/traits/const-traits/call-const-closure.stderr
+++ b/tests/ui/traits/const-traits/call-const-closure.stderr
@@ -1,4 +1,4 @@
-error[E0277]: the trait bound `(): [const] Bar` is not satisfied
+error[E0277]: the trait bound `(): const Bar` is not satisfied
   --> $DIR/call-const-closure.rs:16:18
    |
 LL |     (const || ().foo())();
diff --git a/tests/ui/traits/const-traits/call.rs b/tests/ui/traits/const-traits/call.rs
index 360c08e1b7fe..e93ea4ccbd70 100644
--- a/tests/ui/traits/const-traits/call.rs
+++ b/tests/ui/traits/const-traits/call.rs
@@ -5,7 +5,7 @@
 
 const _: () = {
     assert!((const || true)());
-    //~^ ERROR }: [const] Fn()` is not satisfied
+    //~^ ERROR }: const Fn()` is not satisfied
 };
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/call.stderr b/tests/ui/traits/const-traits/call.stderr
index 8e32cab6dfcf..3503938327a9 100644
--- a/tests/ui/traits/const-traits/call.stderr
+++ b/tests/ui/traits/const-traits/call.stderr
@@ -1,4 +1,4 @@
-error[E0277]: the trait bound `{closure@$DIR/call.rs:7:14: 7:22}: [const] Fn()` is not satisfied
+error[E0277]: the trait bound `{closure@$DIR/call.rs:7:14: 7:22}: const Fn()` is not satisfied
   --> $DIR/call.rs:7:13
    |
 LL |     assert!((const || true)());
diff --git a/tests/ui/traits/const-traits/gate.rs b/tests/ui/traits/const-traits/gate.rs
index 86b42099d289..0821a45edb5e 100644
--- a/tests/ui/traits/const-traits/gate.rs
+++ b/tests/ui/traits/const-traits/gate.rs
@@ -3,7 +3,7 @@
 fn main() {
     const { (const || {})() };
     //~^ ERROR: const closures are experimental
-    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: [const] Fn()` is not satisfied
+    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: const Fn()` is not satisfied
 }
 
 macro_rules! e {
diff --git a/tests/ui/traits/const-traits/gate.stderr b/tests/ui/traits/const-traits/gate.stderr
index b86217943d77..af5905524437 100644
--- a/tests/ui/traits/const-traits/gate.stderr
+++ b/tests/ui/traits/const-traits/gate.stderr
@@ -18,7 +18,7 @@ LL | e!((const || {}));
    = help: add `#![feature(const_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: [const] Fn()` is not satisfied
+error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: const Fn()` is not satisfied
   --> $DIR/gate.rs:4:13
    |
 LL |     const { (const || {})() };

From 675290a40d580f5063bad9ec24ed3a94da96339b Mon Sep 17 00:00:00 2001
From: Urhengulas <johann.hemmann@ferrous-systems.com>
Date: Wed, 11 Mar 2026 17:29:12 +0100
Subject: [PATCH 0380/1059] Fix that `./x test --no-doc` actually keeps the
 same behaviour for backwards compatability

---
 src/bootstrap/src/core/config/flags.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index a2e5def39d07..1665448e6d3c 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -570,16 +570,21 @@ pub fn fail_fast(&self) -> bool {
 
     pub fn test_target(&self) -> TestTarget {
         match *self {
-            Subcommand::Test { all_targets, doc, tests, .. }
-            | Subcommand::Miri { all_targets, doc, tests, .. } => match (all_targets, doc, tests) {
-                (true, true, _) | (true, _, true) | (_, true, true) => {
-                    panic!("You can only set one of `--all-targets`, `--doc` and `--tests`.")
+            Subcommand::Test { mut all_targets, doc, tests, no_doc, .. }
+            | Subcommand::Miri { mut all_targets, doc, tests, no_doc, .. } => {
+                // for backwards compatibility --no-doc keeps working
+                all_targets = all_targets || no_doc;
+
+                match (all_targets, doc, tests) {
+                    (true, true, _) | (true, _, true) | (_, true, true) => {
+                        panic!("You can only set one of `--all-targets`, `--doc` and `--tests`.")
+                    }
+                    (true, false, false) => TestTarget::AllTargets,
+                    (false, true, false) => TestTarget::DocOnly,
+                    (false, false, true) => TestTarget::Tests,
+                    (false, false, false) => TestTarget::Default,
                 }
-                (true, false, false) => TestTarget::AllTargets,
-                (false, true, false) => TestTarget::DocOnly,
-                (false, false, true) => TestTarget::Tests,
-                (false, false, false) => TestTarget::Default,
-            },
+            }
             _ => TestTarget::Default,
         }
     }

From 6e954d376a84ac6da5006abba7800d5663c51639 Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Thu, 12 Mar 2026 06:28:54 -0400
Subject: [PATCH 0381/1059] Bless issue-23041 test after turbofish suggestion
 suppression

---
 tests/ui/issues/issue-23041.stderr | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/ui/issues/issue-23041.stderr b/tests/ui/issues/issue-23041.stderr
index bd0e457fa9da..4d7266c7c98d 100644
--- a/tests/ui/issues/issue-23041.stderr
+++ b/tests/ui/issues/issue-23041.stderr
@@ -3,12 +3,6 @@ error[E0282]: type annotations needed
    |
 LL |     b.downcast_ref::<fn(_)->_>();
    |       ^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the method `downcast_ref`
-   |
-help: consider specifying the generic argument
-   |
-LL -     b.downcast_ref::<fn(_)->_>();
-LL +     b.downcast_ref::<fn(_) -> _>();
-   |
 
 error: aborting due to 1 previous error
 

From 23c24d2bffe202cd38d9b45c54b14984f3b55072 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Thu, 12 Mar 2026 11:43:59 +0000
Subject: [PATCH 0382/1059] fix: Clarify error messages when proc-macro-srv
 changes working directory

I'm investigating issues where users see a load of logs of the form:

```
Failed to set the current working dir to /redacted/path. Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }
```

This is tricky to debug because there's two different code paths that
write exactly the same error message. Ensure they're unique.
---
 src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
index 734cb4ecc169..0bdc379cb626 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
@@ -328,7 +328,7 @@ fn apply(
                 let prev_working_dir = std::env::current_dir().ok();
                 if let Err(err) = std::env::set_current_dir(dir) {
                     eprintln!(
-                        "Failed to set the current working dir to {}. Error: {err:?}",
+                        "Failed to change the current working dir to {}. Error: {err:?}",
                         dir.display()
                     )
                 }
@@ -370,7 +370,7 @@ fn drop(&mut self) {
             && let Err(err) = std::env::set_current_dir(dir)
         {
             eprintln!(
-                "Failed to set the current working dir to {}. Error: {:?}",
+                "Failed to change the current working dir back to {}. Error: {:?}",
                 dir.display(),
                 err
             )

From 01e3d8549cc1d55963cc116b91ceeab8a97ffd64 Mon Sep 17 00:00:00 2001
From: Urhengulas <johann.hemmann@ferrous-systems.com>
Date: Thu, 12 Mar 2026 14:23:26 +0100
Subject: [PATCH 0383/1059] Include optional `dso_local` marker for functions
 in `enum-[match,transparent-extract].rs`

---
 tests/codegen-llvm/enum/enum-match.rs               | 4 ++--
 tests/codegen-llvm/enum/enum-transparent-extract.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/codegen-llvm/enum/enum-match.rs b/tests/codegen-llvm/enum/enum-match.rs
index 20e2006e3eb7..6d8b97328f8e 100644
--- a/tests/codegen-llvm/enum/enum-match.rs
+++ b/tests/codegen-llvm/enum/enum-match.rs
@@ -739,7 +739,7 @@ pub enum Tricky {
 
 const _: () = assert!(std::intrinsics::discriminant_value(&Tricky::V100) == 100);
 
-// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @discriminant6(i8 noundef{{( zeroext)?}} %e)
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @discriminant6(i8 noundef{{( zeroext)?}} %e)
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %e, -66
 // CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], -56
@@ -767,7 +767,7 @@ pub enum TransportErr {
 
 #[no_mangle]
 pub fn match7(result: OpenResult) -> u8 {
-    // CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match7(i32{{.+}}%result)
+    // CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match7(i32{{.+}}%result)
     // CHECK-NEXT: start:
     // CHECK-NEXT: %[[NOT_OK:.+]] = icmp ne i32 %result, -1
     // CHECK-NEXT: %[[RET:.+]] = zext i1 %[[NOT_OK]] to i8
diff --git a/tests/codegen-llvm/enum/enum-transparent-extract.rs b/tests/codegen-llvm/enum/enum-transparent-extract.rs
index c54bb3e66e73..45387c03d28e 100644
--- a/tests/codegen-llvm/enum/enum-transparent-extract.rs
+++ b/tests/codegen-llvm/enum/enum-transparent-extract.rs
@@ -9,7 +9,7 @@ pub enum Never {}
 
 #[no_mangle]
 pub fn make_unmake_result_never(x: i32) -> i32 {
-    // CHECK-LABEL: define i32 @make_unmake_result_never(i32{{( signext)?}} %x)
+    // CHECK-LABEL: define{{( dso_local)?}} i32 @make_unmake_result_never(i32{{( signext)?}} %x)
     // CHECK: start:
     // CHECK-NEXT: br label %[[next:bb.*]]
     // CHECK: [[next]]:
@@ -22,7 +22,7 @@ pub fn make_unmake_result_never(x: i32) -> i32 {
 
 #[no_mangle]
 pub fn extract_control_flow_never(x: ControlFlow<&str, Never>) -> &str {
-    // CHECK-LABEL: define { ptr, i64 } @extract_control_flow_never(ptr %x.0, i64 %x.1)
+    // CHECK-LABEL: define{{( dso_local)?}} { ptr, i64 } @extract_control_flow_never(ptr %x.0, i64 %x.1)
     // CHECK: start:
     // CHECK-NEXT: br label %[[next:bb.*]]
     // CHECK: [[next]]:

From bee28ef7b23f48b759ce6c358a50cba5d24698d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Thu, 12 Mar 2026 14:24:32 +0100
Subject: [PATCH 0384/1059] Remove `MTLock`

---
 compiler/rustc_data_structures/src/sync.rs    | 37 -------------------
 compiler/rustc_monomorphize/src/collector.rs  | 22 +++++------
 src/doc/rustc-dev-guide/src/parallel-rustc.md |  1 -
 3 files changed, 11 insertions(+), 49 deletions(-)

diff --git a/compiler/rustc_data_structures/src/sync.rs b/compiler/rustc_data_structures/src/sync.rs
index 31768fe189ae..327c28fd1389 100644
--- a/compiler/rustc_data_structures/src/sync.rs
+++ b/compiler/rustc_data_structures/src/sync.rs
@@ -21,11 +21,6 @@
 //! | `Lock<T>`               | `RefCell<T>`        | `RefCell<T>` or                 |
 //! |                         |                     | `parking_lot::Mutex<T>`         |
 //! | `RwLock<T>`             | `RefCell<T>`        | `parking_lot::RwLock<T>`        |
-//! | `MTLock<T>`        [^1] | `T`                 | `Lock<T>`                       |
-//!
-//! [^1]: `MTLock` is similar to `Lock`, but the serial version avoids the cost
-//! of a `RefCell`. This is appropriate when interior mutability is not
-//! required.
 
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hash};
@@ -106,38 +101,6 @@ pub fn set_dyn_thread_safe_mode(mode: bool) {
     }
 }
 
-// FIXME(parallel_compiler): Get rid of these aliases across the compiler.
-
-#[derive(Debug, Default)]
-pub struct MTLock<T>(Lock<T>);
-
-impl<T> MTLock<T> {
-    #[inline(always)]
-    pub fn new(inner: T) -> Self {
-        MTLock(Lock::new(inner))
-    }
-
-    #[inline(always)]
-    pub fn into_inner(self) -> T {
-        self.0.into_inner()
-    }
-
-    #[inline(always)]
-    pub fn get_mut(&mut self) -> &mut T {
-        self.0.get_mut()
-    }
-
-    #[inline(always)]
-    pub fn lock(&self) -> LockGuard<'_, T> {
-        self.0.lock()
-    }
-
-    #[inline(always)]
-    pub fn lock_mut(&self) -> LockGuard<'_, T> {
-        self.lock()
-    }
-}
-
 /// This makes locks panic if they are already held.
 /// It is only useful when you are running in a single thread
 const ERROR_CHECKING: bool = false;
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index f6bb70b21446..8bd6730ab0eb 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -209,7 +209,7 @@
 use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::sync::{MTLock, par_for_each_in};
+use rustc_data_structures::sync::{Lock, par_for_each_in};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_hir as hir;
 use rustc_hir::attrs::InlineAttr;
@@ -251,12 +251,12 @@ pub(crate) enum MonoItemCollectionStrategy {
 /// The state that is shared across the concurrent threads that are doing collection.
 struct SharedState<'tcx> {
     /// Items that have been or are currently being recursively collected.
-    visited: MTLock<UnordSet<MonoItem<'tcx>>>,
+    visited: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Items that have been or are currently being recursively treated as "mentioned", i.e., their
     /// consts are evaluated but nothing is added to the collection.
-    mentioned: MTLock<UnordSet<MonoItem<'tcx>>>,
+    mentioned: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Which items are being used where, for better errors.
-    usage_map: MTLock<UsageMap<'tcx>>,
+    usage_map: Lock<UsageMap<'tcx>>,
 }
 
 pub(crate) struct UsageMap<'tcx> {
@@ -359,7 +359,7 @@ fn collect_items_root<'tcx>(
     state: &SharedState<'tcx>,
     recursion_limit: Limit,
 ) {
-    if !state.visited.lock_mut().insert(starting_item.node) {
+    if !state.visited.lock().insert(starting_item.node) {
         // We've been here already, no need to search again.
         return;
     }
@@ -568,7 +568,7 @@ fn collect_items_rec<'tcx>(
     // This is part of the output of collection and hence only relevant for "used" items.
     // ("Mentioned" items are only considered internally during collection.)
     if mode == CollectionMode::UsedItems {
-        state.usage_map.lock_mut().record_used(starting_item.node, &used_items);
+        state.usage_map.lock().record_used(starting_item.node, &used_items);
     }
 
     {
@@ -576,13 +576,13 @@ fn collect_items_rec<'tcx>(
         if mode == CollectionMode::UsedItems {
             used_items
                 .items
-                .retain(|k, _| visited.get_mut_or_init(|| state.visited.lock_mut()).insert(*k));
+                .retain(|k, _| visited.get_mut_or_init(|| state.visited.lock()).insert(*k));
         }
 
         let mut mentioned = OnceCell::default();
         mentioned_items.items.retain(|k, _| {
             !visited.get_or_init(|| state.visited.lock()).contains(k)
-                && mentioned.get_mut_or_init(|| state.mentioned.lock_mut()).insert(*k)
+                && mentioned.get_mut_or_init(|| state.mentioned.lock()).insert(*k)
         });
     }
     if mode == CollectionMode::MentionedItems {
@@ -1810,9 +1810,9 @@ pub(crate) fn collect_crate_mono_items<'tcx>(
     debug!("building mono item graph, beginning at roots");
 
     let state = SharedState {
-        visited: MTLock::new(UnordSet::default()),
-        mentioned: MTLock::new(UnordSet::default()),
-        usage_map: MTLock::new(UsageMap::new()),
+        visited: Lock::new(UnordSet::default()),
+        mentioned: Lock::new(UnordSet::default()),
+        usage_map: Lock::new(UsageMap::new()),
     };
     let recursion_limit = tcx.recursion_limit();
 
diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index ce69b66c2daf..f83aaa639ecc 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -48,7 +48,6 @@ are implemented differently depending on whether `parallel-compiler` is true.
 | -------------------------------- | --------------------------------------------------- | ------------ |
 | Lock\<T> | (parking_lot::Mutex\<T>) | (std::cell::RefCell) |
 | RwLock\<T> | (parking_lot::RwLock\<T>) | (std::cell::RefCell) |
-| MTLock\<T> | (Lock\<T>) | (T) |
 | ReadGuard | parking_lot::RwLockReadGuard | std::cell::Ref |
 | MappedReadGuard | parking_lot::MappedRwLockReadGuard | std::cell::Ref |
 | WriteGuard | parking_lot::RwLockWriteGuard | std::cell::RefMut |

From 3f919c09216074541aaa3e4d6cfd31fc1c381e3e Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 4 Feb 2026 13:00:50 +0000
Subject: [PATCH 0385/1059] Pass Session to make_codegen_backend callback

---
 compiler/rustc_interface/src/interface.rs | 31 ++++++++++-------------
 src/tools/miri/src/bin/miri.rs            | 22 ++++++++--------
 2 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index 91b7f234d5f6..ed08e4916436 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -22,7 +22,6 @@
 use rustc_session::{CompilerIO, EarlyDiagCtxt, Session, lint};
 use rustc_span::source_map::{FileLoader, RealFileLoader, SourceMapInputs};
 use rustc_span::{FileName, sym};
-use rustc_target::spec::Target;
 use tracing::trace;
 
 use crate::util;
@@ -364,8 +363,7 @@ pub struct Config {
     /// hotswapping branch of cg_clif" for "setting the codegen backend from a
     /// custom driver where the custom codegen backend has arbitrary data."
     /// (See #102759.)
-    pub make_codegen_backend:
-        Option<Box<dyn FnOnce(&config::Options, &Target) -> Box<dyn CodegenBackend> + Send>>,
+    pub make_codegen_backend: Option<Box<dyn FnOnce(&Session) -> Box<dyn CodegenBackend> + Send>>,
 
     /// The inner atomic value is set to true when a feature marked as `internal` is
     /// enabled. Makes it so that "please report a bug" is hidden, as ICEs with
@@ -419,20 +417,6 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
             // impl `Send`. Creating a new one is fine.
             let early_dcx = EarlyDiagCtxt::new(config.opts.error_format);
 
-            let codegen_backend = match config.make_codegen_backend {
-                None => util::get_codegen_backend(
-                    &early_dcx,
-                    &config.opts.sysroot,
-                    config.opts.unstable_opts.codegen_backend.as_deref(),
-                    &target,
-                ),
-                Some(make_codegen_backend) => {
-                    // N.B. `make_codegen_backend` takes precedence over
-                    // `target.default_codegen_backend`, which is ignored in this case.
-                    make_codegen_backend(&config.opts, &target)
-                }
-            };
-
             let temps_dir = config.opts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
 
             let mut sess = rustc_session::build_session(
@@ -450,6 +434,19 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                 config.using_internal_features,
             );
 
+            let codegen_backend = match config.make_codegen_backend {
+                None => util::get_codegen_backend(
+                    &early_dcx,
+                    &sess.opts.sysroot,
+                    sess.opts.unstable_opts.codegen_backend.as_deref(),
+                    &sess.target,
+                ),
+                Some(make_codegen_backend) => {
+                    // N.B. `make_codegen_backend` takes precedence over
+                    // `target.default_codegen_backend`, which is ignored in this case.
+                    make_codegen_backend(&sess)
+                }
+            };
             codegen_backend.init(&sess);
             sess.replaced_intrinsics = FxHashSet::from_iter(codegen_backend.replaced_intrinsics());
             sess.thin_lto_supported = codegen_backend.thin_lto_supported();
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 3766debb159d..d20ae911d019 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -18,7 +18,6 @@
 extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
-extern crate rustc_target;
 
 /// See docs in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc/src/main.rs
 /// and https://github.com/rust-lang/rust/pull/146627 for why we need this.
@@ -42,7 +41,6 @@
 use std::process::ExitCode;
 use std::rc::Rc;
 use std::str::FromStr;
-use std::sync::Once;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use miri::{
@@ -66,10 +64,9 @@
 use rustc_middle::query::LocalCrate;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::EarlyDiagCtxt;
-use rustc_session::config::{CrateType, ErrorOutputType, OptLevel, Options};
+use rustc_session::config::{CrateType, ErrorOutputType, OptLevel};
+use rustc_session::{EarlyDiagCtxt, Session};
 use rustc_span::def_id::DefId;
-use rustc_target::spec::Target;
 
 use crate::log::setup::{deinit_loggers, init_early_loggers, init_late_loggers};
 
@@ -174,18 +171,21 @@ fn run_many_seeds(
 /// Generates the codegen backend for code that Miri will interpret: we basically
 /// use the dummy backend, except that we put the LLVM backend in charge of
 /// target features.
-fn make_miri_codegen_backend(opts: &Options, target: &Target) -> Box<dyn CodegenBackend> {
-    let early_dcx = EarlyDiagCtxt::new(opts.error_format);
+fn make_miri_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
+    let early_dcx = EarlyDiagCtxt::new(sess.opts.error_format);
 
     // Use the target_config method of the default codegen backend (eg LLVM) to ensure the
     // calculated target features match said backend by respecting eg -Ctarget-cpu.
-    let target_config_backend =
-        rustc_interface::util::get_codegen_backend(&early_dcx, &opts.sysroot, None, target);
-    let target_config_backend_init = Once::new();
+    let target_config_backend = rustc_interface::util::get_codegen_backend(
+        &early_dcx,
+        &sess.opts.sysroot,
+        None,
+        &sess.target,
+    );
+    target_config_backend.init(sess);
 
     Box::new(DummyCodegenBackend {
         target_config_override: Some(Box::new(move |sess| {
-            target_config_backend_init.call_once(|| target_config_backend.init(sess));
             target_config_backend.target_config(sess)
         })),
     })

From d87d7b94f8fb2125dbbe8359d3cb084cff17c365 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Thu, 12 Mar 2026 17:25:05 +0300
Subject: [PATCH 0386/1059] Always generate generics that match trait in trait
 impl scenario

---
 compiler/rustc_ast_lowering/src/delegation.rs |   6 +-
 .../src/delegation/generics.rs                |  81 +++++++--
 compiler/rustc_hir_analysis/src/delegation.rs |   8 +-
 .../generics/impl-trait-wrong-args-count.rs   |  40 -----
 .../impl-trait-wrong-args-count.stderr        |  74 ---------
 .../generics/trait-impl-wrong-args-count.rs   | 111 +++++++++++++
 .../trait-impl-wrong-args-count.stderr        | 156 ++++++++++++++++++
 7 files changed, 340 insertions(+), 136 deletions(-)
 delete mode 100644 tests/ui/delegation/generics/impl-trait-wrong-args-count.rs
 delete mode 100644 tests/ui/delegation/generics/impl-trait-wrong-args-count.stderr
 create mode 100644 tests/ui/delegation/generics/trait-impl-wrong-args-count.rs
 create mode 100644 tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 1d634c03255e..fa11e0476340 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -724,9 +724,11 @@ fn process_segment(
         result: &mut GenericsGenerationResult<'hir>,
         add_lifetimes: bool,
     ) -> hir::PathSegment<'hir> {
+        let details = result.generics.args_propagation_details();
+
         // The first condition is needed when there is SelfAndUserSpecified case,
         // we don't want to propagate generics params in this situation.
-        let segment = if !result.generics.is_user_specified()
+        let segment = if details.should_propagate
             && let Some(args) = result
                 .generics
                 .into_hir_generics(self, item_id, span)
@@ -737,7 +739,7 @@ fn process_segment(
             segment.clone()
         };
 
-        if result.generics.is_user_specified() {
+        if details.use_args_in_sig_inheritance {
             result.args_segment_id = Some(segment.hir_id);
         }
 
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index 9e7ec04d38fb..6bfe73fb0d8f 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -20,6 +20,10 @@ pub(super) enum DelegationGenerics<T> {
     /// In free-to-trait reuse, when user specified args for trait `reuse Trait::<i32>::foo;`
     /// in this case we need to both generate `Self` and process user args.
     SelfAndUserSpecified(Option<T>),
+    /// In delegations from trait impl to other entities like free functions or trait functions,
+    /// we want to generate a function whose generics matches generics of signature function
+    /// in trait.
+    TraitImpl(Option<T>, bool /* Has user-specified args */),
 }
 
 /// Used for storing either AST generics or their lowered HIR version. Firstly we obtain
@@ -48,12 +52,29 @@ pub(super) struct GenericsGenerationResults<'hir> {
     pub(super) child: GenericsGenerationResult<'hir>,
 }
 
+pub(super) struct GenericArgsPropagationDetails {
+    pub(super) should_propagate: bool,
+    pub(super) use_args_in_sig_inheritance: bool,
+}
+
 impl<T> DelegationGenerics<T> {
-    fn is_user_specified(&self) -> bool {
-        matches!(
-            self,
-            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. }
-        )
+    fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
+        match self {
+            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. } => {
+                GenericArgsPropagationDetails {
+                    should_propagate: false,
+                    use_args_in_sig_inheritance: true,
+                }
+            }
+            DelegationGenerics::TraitImpl(_, user_specified) => GenericArgsPropagationDetails {
+                should_propagate: !*user_specified,
+                use_args_in_sig_inheritance: false,
+            },
+            DelegationGenerics::Default(_) => GenericArgsPropagationDetails {
+                should_propagate: true,
+                use_args_in_sig_inheritance: false,
+            },
+        }
     }
 }
 
@@ -77,6 +98,12 @@ pub(super) fn into_hir_generics(
                 DelegationGenerics::SelfAndUserSpecified(generics) => {
                     DelegationGenerics::SelfAndUserSpecified(generics.as_mut().map(process_params))
                 }
+                DelegationGenerics::TraitImpl(generics, user_specified) => {
+                    DelegationGenerics::TraitImpl(
+                        generics.as_mut().map(process_params),
+                        *user_specified,
+                    )
+                }
             };
 
             *self = HirOrAstGenerics::Hir(hir_generics);
@@ -91,7 +118,8 @@ fn hir_generics_or_empty(&self) -> &'hir hir::Generics<'hir> {
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => hir::Generics::empty(),
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => {
                     generics.unwrap_or(hir::Generics::empty())
                 }
             },
@@ -111,17 +139,18 @@ pub(super) fn into_generic_args(
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => None,
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => generics.map(|generics| {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => generics.map(|generics| {
                     ctx.create_generics_args_from_params(generics.params, add_lifetimes, span)
                 }),
             },
         }
     }
 
-    pub(super) fn is_user_specified(&self) -> bool {
+    pub(super) fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
         match self {
-            HirOrAstGenerics::Ast(ast_generics) => ast_generics.is_user_specified(),
-            HirOrAstGenerics::Hir(hir_generics) => hir_generics.is_user_specified(),
+            HirOrAstGenerics::Ast(ast_generics) => ast_generics.args_propagation_details(),
+            HirOrAstGenerics::Hir(hir_generics) => hir_generics.args_propagation_details(),
         }
     }
 }
@@ -215,10 +244,29 @@ pub(super) fn lower_delegation_generics(
         item_id: NodeId,
         span: Span,
     ) -> GenericsGenerationResults<'hir> {
-        let delegation_in_free_ctx = !matches!(
-            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id))),
-            DefKind::Trait | DefKind::Impl { .. }
-        );
+        let delegation_parent_kind =
+            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id)));
+
+        let segments = &delegation.path.segments;
+        let len = segments.len();
+        let child_user_specified = segments[len - 1].args.is_some();
+
+        // If we are in trait impl always generate function whose generics matches
+        // those that are defined in trait.
+        if matches!(delegation_parent_kind, DefKind::Impl { of_trait: true }) {
+            // Considering parent generics, during signature inheritance
+            // we will take those args that are in trait impl header trait ref.
+            let parent = GenericsGenerationResult::new(DelegationGenerics::Default(None));
+
+            let generics = self.get_fn_like_generics(root_fn_id, span);
+            let child = DelegationGenerics::TraitImpl(generics, child_user_specified);
+            let child = GenericsGenerationResult::new(child);
+
+            return GenericsGenerationResults { parent, child };
+        }
+
+        let delegation_in_free_ctx =
+            !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
         let root_function_in_trait =
             matches!(self.tcx.def_kind(self.tcx.parent(root_fn_id)), DefKind::Trait);
@@ -234,9 +282,6 @@ pub(super) fn lower_delegation_generics(
             )
         };
 
-        let segments = &delegation.path.segments;
-        let len = segments.len();
-
         let can_add_generics_to_parent = len >= 2
             && self.get_resolution_id(segments[len - 2].id).is_some_and(|def_id| {
                 matches!(self.tcx.def_kind(def_id), DefKind::Trait | DefKind::TraitAlias)
@@ -256,7 +301,7 @@ pub(super) fn lower_delegation_generics(
             DelegationGenerics::Default(None)
         };
 
-        let child_generics = if segments[len - 1].args.is_some() {
+        let child_generics = if child_user_specified {
             DelegationGenerics::UserSpecified
         } else {
             DelegationGenerics::Default(self.get_fn_like_generics(root_fn_id, span))
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index 3392a72daec1..64cf9cb6403e 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -338,10 +338,14 @@ fn create_generic_args<'tcx>(
         | (FnKind::AssocTrait, FnKind::AssocTrait) => delegation_args,
 
         (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
-            // Special case, as user specifies Trait args in impl trait header, we want to treat
-            // them as parent args.
+            // Special case, as user specifies Trait args in trait impl header, we want to treat
+            // them as parent args. We always generate a function whose generics match
+            // child generics in trait.
             let parent = tcx.local_parent(delegation_id);
             parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
+
+            assert!(child_args.is_empty(), "Child args can not be used in trait impl case");
+
             tcx.mk_args(&delegation_args[delegation_parent_args_count..])
         }
 
diff --git a/tests/ui/delegation/generics/impl-trait-wrong-args-count.rs b/tests/ui/delegation/generics/impl-trait-wrong-args-count.rs
deleted file mode 100644
index 8c9b7d5a9e4e..000000000000
--- a/tests/ui/delegation/generics/impl-trait-wrong-args-count.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![feature(fn_delegation)]
-#![allow(incomplete_features)]
-
-mod to_reuse {
-    pub fn bar<'a: 'a, 'b: 'b, A, B>(x: &super::XX) {}
-    pub fn bar1(x: &super::XX) {}
-    pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
-}
-
-trait Trait<'a, 'b, 'c, A, B, const N: usize>: Sized {
-    fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
-    fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
-    fn bar2(&self) {}
-    fn bar3(&self) {}
-    fn bar4<X, Y, Z>(&self) {}
-}
-
-struct X<'x1, 'x2, 'x3, 'x4, X1, X2, const X3: usize>(
-    &'x1 X1, &'x2 X2, &'x3 X1, &'x4 [usize; X3]);
-type XX = X::<'static, 'static, 'static, 'static, i32, i32, 3>;
-
-impl<'a, 'b, 'c, A, B, const N: usize> Trait<'a, 'b, 'c, A, B, N> for XX {
-    reuse to_reuse::bar;
-    //~^ ERROR: function takes at most 2 generic arguments but 3 generic arguments were supplied
-
-    reuse to_reuse::bar1;
-    //~^ ERROR: function takes 0 generic arguments but 3 generic arguments were supplied
-
-    reuse to_reuse::bar2;
-    //~^ ERROR: type annotations needed
-    //~| ERROR: type annotations needed
-
-    reuse to_reuse::bar2::<i32, i32, i32, i32, i32, i32, 123, true> as bar3;
-
-    reuse to_reuse::bar2::<i32, i32, i32, i32, i32, i32, 123, true> as bar4;
-    //~^ ERROR: method `bar4` has 0 type parameters but its trait declaration has 3 type parameters
-}
-
-fn main() {
-}
diff --git a/tests/ui/delegation/generics/impl-trait-wrong-args-count.stderr b/tests/ui/delegation/generics/impl-trait-wrong-args-count.stderr
deleted file mode 100644
index 2a94ac0bfe03..000000000000
--- a/tests/ui/delegation/generics/impl-trait-wrong-args-count.stderr
+++ /dev/null
@@ -1,74 +0,0 @@
-error[E0049]: method `bar4` has 0 type parameters but its trait declaration has 3 type parameters
-  --> $DIR/impl-trait-wrong-args-count.rs:35:21
-   |
-LL |     fn bar4<X, Y, Z>(&self) {}
-   |             -  -  -
-   |             |
-   |             expected 3 type parameters
-...
-LL |     reuse to_reuse::bar2::<i32, i32, i32, i32, i32, i32, 123, true> as bar4;
-   |                     ^^^^ found 0 type parameters
-
-error[E0107]: function takes at most 2 generic arguments but 3 generic arguments were supplied
-  --> $DIR/impl-trait-wrong-args-count.rs:23:21
-   |
-LL |     fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
-   |                                  ----------------- help: remove the unnecessary generic argument
-...
-LL |     reuse to_reuse::bar;
-   |                     ^^^ expected at most 2 generic arguments
-   |
-note: function defined here, with at most 2 generic parameters: `A`, `B`
-  --> $DIR/impl-trait-wrong-args-count.rs:5:12
-   |
-LL |     pub fn bar<'a: 'a, 'b: 'b, A, B>(x: &super::XX) {}
-   |            ^^^                 -  -
-
-error[E0107]: function takes 0 generic arguments but 3 generic arguments were supplied
-  --> $DIR/impl-trait-wrong-args-count.rs:26:21
-   |
-LL |     reuse to_reuse::bar1;
-   |                     ^^^^ expected 0 generic arguments
-   |
-note: function defined here, with 0 generic parameters
-  --> $DIR/impl-trait-wrong-args-count.rs:6:12
-   |
-LL |     pub fn bar1(x: &super::XX) {}
-   |            ^^^^
-
-error[E0284]: type annotations needed
-  --> $DIR/impl-trait-wrong-args-count.rs:29:21
-   |
-LL |     reuse to_reuse::bar2;
-   |                     ^^^^ cannot infer the value of the const parameter `X` declared on the function `bar2`
-   |
-note: required by a const generic parameter in `bar2`
-  --> $DIR/impl-trait-wrong-args-count.rs:7:35
-   |
-LL |     pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
-   |                                   ^^^^^^^^^^^^^^ required by this const generic parameter in `bar2`
-help: consider specifying the generic arguments
-   |
-LL |     reuse to_reuse::bar2::<A, B, C, D, E, F, X, Y>;
-   |                         ++++++++++++++++++++++++++
-
-error[E0284]: type annotations needed
-  --> $DIR/impl-trait-wrong-args-count.rs:29:21
-   |
-LL |     reuse to_reuse::bar2;
-   |                     ^^^^ cannot infer the value of the const parameter `Y` declared on the function `bar2`
-   |
-note: required by a const generic parameter in `bar2`
-  --> $DIR/impl-trait-wrong-args-count.rs:7:51
-   |
-LL |     pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
-   |                                                   ^^^^^^^^^^^^^ required by this const generic parameter in `bar2`
-help: consider specifying the generic arguments
-   |
-LL |     reuse to_reuse::bar2::<A, B, C, D, E, F, X, Y>;
-   |                         ++++++++++++++++++++++++++
-
-error: aborting due to 5 previous errors
-
-Some errors have detailed explanations: E0049, E0107, E0284.
-For more information about an error, try `rustc --explain E0049`.
diff --git a/tests/ui/delegation/generics/trait-impl-wrong-args-count.rs b/tests/ui/delegation/generics/trait-impl-wrong-args-count.rs
new file mode 100644
index 000000000000..7cb98ff307fd
--- /dev/null
+++ b/tests/ui/delegation/generics/trait-impl-wrong-args-count.rs
@@ -0,0 +1,111 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+// Testing delegation from trait impl to free functions.
+mod test_1 {
+    mod to_reuse {
+        pub fn bar<'a: 'a, 'b: 'b, A, B>(x: &super::XX) {}
+        pub fn bar1(x: &super::XX) {}
+        pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
+    }
+
+    trait Trait<'a, 'b, 'c, A, B, const N: usize>: Sized {
+        fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+        fn bar2(&self) {}
+        fn bar3(&self) {}
+        fn bar4<X, Y, Z>(&self) {}
+    }
+
+    struct X<'x1, 'x2, 'x3, 'x4, X1, X2, const X3: usize>(
+        &'x1 X1, &'x2 X2, &'x3 X1, &'x4 [usize; X3]);
+    type XX = X::<'static, 'static, 'static, 'static, i32, i32, 3>;
+
+    impl<'a, 'b, 'c, A, B, const N: usize> Trait<'a, 'b, 'c, A, B, N> for XX {
+        reuse to_reuse::bar;
+        //~^ ERROR: function takes at most 2 generic arguments but 3 generic arguments were supplied
+
+        reuse to_reuse::bar1;
+        //~^ ERROR: function takes 0 generic arguments but 3 generic arguments were supplied
+
+        reuse to_reuse::bar2;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+
+        reuse to_reuse::bar2::<i32, i32, i32, i32, i32, i32, 123, true> as bar3;
+
+        reuse to_reuse::bar2::<i32, i32, i32, i32, i32, i32, 123, true> as bar4;
+    }
+}
+
+// Testing delegations of trait impl to other different trait
+// with errors in Trait1 generics count.
+mod test_2 {
+    trait Trait<A, const N: usize> {
+        fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar2() {}
+        fn bar3() {}
+        fn bar4<X, Y, Z>() {}
+    }
+
+    trait Trait1<A, B> {
+        fn bar<'x: 'x, AA, BB, const NN: usize>() {}
+    }
+
+    struct X;
+
+    impl<A, B> Trait1<A, B> for X {}
+
+    impl Trait<String, 1> for X {
+        reuse <X as Trait1>::bar;
+        //~^ ERROR: missing generics for trait
+
+        reuse <X as Trait1::<bool, bool>>::bar as bar1;
+
+        reuse <X as Trait1::<bool, bool>>::bar::<'static, u32, u32, 1> as bar2;
+
+        reuse <X as Trait1>::bar::<'static, u32, u32, 1> as bar3;
+        //~^ ERROR: missing generics for trait
+
+        reuse <X as Trait1>::bar as bar4;
+        //~^ ERROR: missing generics for trait
+    }
+}
+
+// Testing delegations of trait impl to other different trait
+// with Trait1::bar and Trait1::foo wrong generics count.
+mod test_3 {
+    trait Trait<A, const N: usize> {
+        fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar2() {}
+        fn bar3<X, Y, Z>() {}
+    }
+
+    trait Trait1<A, B> {
+        fn bar() {}
+        fn foo<X, Y>() {}
+    }
+
+    struct X;
+
+    impl<A, B> Trait1<A, B> for X {}
+
+    impl Trait<String, 1> for X {
+        reuse <X as Trait1::<(), ()>>::bar;
+        //~^ ERROR: associated function takes 0 generic arguments but 3 generic arguments were supplied
+
+        reuse <X as Trait1::<(), ()>>::bar as bar1;
+        //~^ ERROR: associated function takes 0 generic arguments but 3 generic arguments were supplied
+
+        reuse <X as Trait1::<(), ()>>::foo as bar2;
+        //~^ ERROR: type annotations needed
+
+        reuse <X as Trait1::<(), ()>>::foo as bar3;
+        //~^ ERROR: associated function takes at most 2 generic arguments but 3 generic arguments were supplied
+    }
+}
+
+fn main() {
+}
diff --git a/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr b/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr
new file mode 100644
index 000000000000..00dfedef47b5
--- /dev/null
+++ b/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr
@@ -0,0 +1,156 @@
+error[E0107]: function takes at most 2 generic arguments but 3 generic arguments were supplied
+  --> $DIR/trait-impl-wrong-args-count.rs:25:25
+   |
+LL |         fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+   |                                      ----------------- help: remove the unnecessary generic argument
+...
+LL |         reuse to_reuse::bar;
+   |                         ^^^ expected at most 2 generic arguments
+   |
+note: function defined here, with at most 2 generic parameters: `A`, `B`
+  --> $DIR/trait-impl-wrong-args-count.rs:7:16
+   |
+LL |         pub fn bar<'a: 'a, 'b: 'b, A, B>(x: &super::XX) {}
+   |                ^^^                 -  -
+
+error[E0107]: function takes 0 generic arguments but 3 generic arguments were supplied
+  --> $DIR/trait-impl-wrong-args-count.rs:28:25
+   |
+LL |         reuse to_reuse::bar1;
+   |                         ^^^^ expected 0 generic arguments
+   |
+note: function defined here, with 0 generic parameters
+  --> $DIR/trait-impl-wrong-args-count.rs:8:16
+   |
+LL |         pub fn bar1(x: &super::XX) {}
+   |                ^^^^
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-impl-wrong-args-count.rs:31:25
+   |
+LL |         reuse to_reuse::bar2;
+   |                         ^^^^ cannot infer the value of the const parameter `X` declared on the function `bar2`
+   |
+note: required by a const generic parameter in `bar2`
+  --> $DIR/trait-impl-wrong-args-count.rs:9:39
+   |
+LL |         pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
+   |                                       ^^^^^^^^^^^^^^ required by this const generic parameter in `bar2`
+help: consider specifying the generic arguments
+   |
+LL |         reuse to_reuse::bar2::<A, B, C, D, E, F, X, Y>;
+   |                             ++++++++++++++++++++++++++
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-impl-wrong-args-count.rs:31:25
+   |
+LL |         reuse to_reuse::bar2;
+   |                         ^^^^ cannot infer the value of the const parameter `Y` declared on the function `bar2`
+   |
+note: required by a const generic parameter in `bar2`
+  --> $DIR/trait-impl-wrong-args-count.rs:9:55
+   |
+LL |         pub fn bar2<A, B, C, D, E, F, const X: usize, const Y: bool>(x: &super::XX) {}
+   |                                                       ^^^^^^^^^^^^^ required by this const generic parameter in `bar2`
+help: consider specifying the generic arguments
+   |
+LL |         reuse to_reuse::bar2::<A, B, C, D, E, F, X, Y>;
+   |                             ++++++++++++++++++++++++++
+
+error[E0107]: missing generics for trait `test_2::Trait1`
+  --> $DIR/trait-impl-wrong-args-count.rs:61:21
+   |
+LL |         reuse <X as Trait1>::bar;
+   |                     ^^^^^^ expected 2 generic arguments
+   |
+note: trait defined here, with 2 generic parameters: `A`, `B`
+  --> $DIR/trait-impl-wrong-args-count.rs:52:11
+   |
+LL |     trait Trait1<A, B> {
+   |           ^^^^^^ -  -
+help: add missing generic arguments
+   |
+LL |         reuse <X as Trait1<A, B>>::bar;
+   |                           ++++++
+
+error[E0107]: missing generics for trait `test_2::Trait1`
+  --> $DIR/trait-impl-wrong-args-count.rs:68:21
+   |
+LL |         reuse <X as Trait1>::bar::<'static, u32, u32, 1> as bar3;
+   |                     ^^^^^^ expected 2 generic arguments
+   |
+note: trait defined here, with 2 generic parameters: `A`, `B`
+  --> $DIR/trait-impl-wrong-args-count.rs:52:11
+   |
+LL |     trait Trait1<A, B> {
+   |           ^^^^^^ -  -
+help: add missing generic arguments
+   |
+LL |         reuse <X as Trait1<A, B>>::bar::<'static, u32, u32, 1> as bar3;
+   |                           ++++++
+
+error[E0107]: missing generics for trait `test_2::Trait1`
+  --> $DIR/trait-impl-wrong-args-count.rs:71:21
+   |
+LL |         reuse <X as Trait1>::bar as bar4;
+   |                     ^^^^^^ expected 2 generic arguments
+   |
+note: trait defined here, with 2 generic parameters: `A`, `B`
+  --> $DIR/trait-impl-wrong-args-count.rs:52:11
+   |
+LL |     trait Trait1<A, B> {
+   |           ^^^^^^ -  -
+help: add missing generic arguments
+   |
+LL |         reuse <X as Trait1<A, B>>::bar as bar4;
+   |                           ++++++
+
+error[E0107]: associated function takes 0 generic arguments but 3 generic arguments were supplied
+  --> $DIR/trait-impl-wrong-args-count.rs:96:40
+   |
+LL |         reuse <X as Trait1::<(), ()>>::bar;
+   |                                        ^^^ expected 0 generic arguments
+   |
+note: associated function defined here, with 0 generic parameters
+  --> $DIR/trait-impl-wrong-args-count.rs:87:12
+   |
+LL |         fn bar() {}
+   |            ^^^
+
+error[E0107]: associated function takes 0 generic arguments but 3 generic arguments were supplied
+  --> $DIR/trait-impl-wrong-args-count.rs:99:40
+   |
+LL |         reuse <X as Trait1::<(), ()>>::bar as bar1;
+   |                                        ^^^ expected 0 generic arguments
+   |
+note: associated function defined here, with 0 generic parameters
+  --> $DIR/trait-impl-wrong-args-count.rs:87:12
+   |
+LL |         fn bar() {}
+   |            ^^^
+
+error[E0282]: type annotations needed
+  --> $DIR/trait-impl-wrong-args-count.rs:102:40
+   |
+LL |         reuse <X as Trait1::<(), ()>>::foo as bar2;
+   |                                        ^^^ cannot infer type of the type parameter `X` declared on the associated function `foo`
+
+error[E0107]: associated function takes at most 2 generic arguments but 3 generic arguments were supplied
+  --> $DIR/trait-impl-wrong-args-count.rs:105:40
+   |
+LL |         fn bar3<X, Y, Z>() {}
+   |                     --- help: remove the unnecessary generic argument
+...
+LL |         reuse <X as Trait1::<(), ()>>::foo as bar3;
+   |                                        ^^^ expected at most 2 generic arguments
+   |
+note: associated function defined here, with at most 2 generic parameters: `X`, `Y`
+  --> $DIR/trait-impl-wrong-args-count.rs:88:12
+   |
+LL |         fn foo<X, Y>() {}
+   |            ^^^ -  -
+
+error: aborting due to 11 previous errors
+
+Some errors have detailed explanations: E0107, E0282, E0284.
+For more information about an error, try `rustc --explain E0107`.

From 8459d6bf3a6ba46368c6649f1cc7d9ba332c9e9c Mon Sep 17 00:00:00 2001
From: Sinan Nalkaya <sardok@gmail.com>
Date: Thu, 12 Mar 2026 13:14:40 +0100
Subject: [PATCH 0387/1059] Fix std doctest build for SGX target.

---
 library/std/src/os/fd/raw.rs              | 2 +-
 library/std/src/sys/net/connection/sgx.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/os/fd/raw.rs b/library/std/src/os/fd/raw.rs
index 39e374174646..0d96958b6cca 100644
--- a/library/std/src/os/fd/raw.rs
+++ b/library/std/src/os/fd/raw.rs
@@ -16,7 +16,7 @@
 use crate::os::hermit::io::OwnedFd;
 #[cfg(all(not(target_os = "hermit"), not(target_os = "motor")))]
 use crate::os::raw;
-#[cfg(all(doc, not(target_arch = "wasm32")))]
+#[cfg(all(doc, not(any(target_arch = "wasm32", target_env = "sgx"))))]
 use crate::os::unix::io::AsFd;
 #[cfg(unix)]
 use crate::os::unix::io::OwnedFd;
diff --git a/library/std/src/sys/net/connection/sgx.rs b/library/std/src/sys/net/connection/sgx.rs
index 8c9c17d3f171..6a625664494b 100644
--- a/library/std/src/sys/net/connection/sgx.rs
+++ b/library/std/src/sys/net/connection/sgx.rs
@@ -68,8 +68,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 ///
 /// SGX doesn't support DNS resolution but rather accepts hostnames in
 /// the same place as socket addresses. So, to make e.g.
-/// ```rust
-/// TcpStream::connect("example.com:80")`
+/// ```rust,ignore (incomplete example)
+/// TcpStream::connect("example.com:80")
 /// ```
 /// work, the DNS lookup returns a special error (`NonIpSockAddr`) instead,
 /// which contains the hostname being looked up. When `.to_socket_addrs()`

From 2199d07e2bff538c4636a01a07ac0b31850af648 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 2 Feb 2025 15:51:14 +0000
Subject: [PATCH 0388/1059] Move env/file_depinfo from ParseSess to Session

---
 compiler/rustc_builtin_macros/src/env.rs      |  4 +--
 .../rustc_builtin_macros/src/source_util.rs   |  1 -
 compiler/rustc_driver_impl/src/lib.rs         |  2 +-
 .../rustc_expand/src/proc_macro_server.rs     |  5 ++--
 compiler/rustc_interface/src/interface.rs     | 15 ++++++-----
 compiler/rustc_interface/src/passes.rs        |  6 ++---
 compiler/rustc_session/src/options.rs         |  6 ++---
 compiler/rustc_session/src/parse.rs           |  8 +-----
 compiler/rustc_session/src/session.rs         |  8 ++++++
 src/librustdoc/core.rs                        |  2 +-
 src/librustdoc/doctest.rs                     |  2 +-
 src/tools/clippy/src/driver.rs                | 26 +++++++++----------
 tests/ui-fulldeps/run-compiler-twice.rs       |  2 +-
 13 files changed, 45 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/env.rs b/compiler/rustc_builtin_macros/src/env.rs
index 12f59467ffd1..f60113dbfc9b 100644
--- a/compiler/rustc_builtin_macros/src/env.rs
+++ b/compiler/rustc_builtin_macros/src/env.rs
@@ -51,7 +51,7 @@ pub(crate) fn expand_option_env<'cx>(
 
     let sp = cx.with_def_site_ctxt(sp);
     let value = lookup_env(cx, var);
-    cx.sess.psess.env_depinfo.borrow_mut().insert((var, value.as_ref().ok().copied()));
+    cx.sess.env_depinfo.borrow_mut().insert((var, value.as_ref().ok().copied()));
     let e = match value {
         Err(VarError::NotPresent) => {
             let lt = cx.lifetime(sp, Ident::new(kw::StaticLifetime, sp));
@@ -130,7 +130,7 @@ pub(crate) fn expand_env<'cx>(
 
     let span = cx.with_def_site_ctxt(sp);
     let value = lookup_env(cx, var);
-    cx.sess.psess.env_depinfo.borrow_mut().insert((var, value.as_ref().ok().copied()));
+    cx.sess.env_depinfo.borrow_mut().insert((var, value.as_ref().ok().copied()));
     let e = match value {
         Err(err) => {
             let ExprKind::Lit(token::Lit {
diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index 16003c8ba135..ab7a9c3bccb3 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -277,7 +277,6 @@ fn load_binary_file(
     match cx.source_map().load_binary_file(&resolved_path) {
         Ok(data) => {
             cx.sess
-                .psess
                 .file_depinfo
                 .borrow_mut()
                 .insert(Symbol::intern(&resolved_path.to_string_lossy()));
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 8fec629161ea..ea69d9d07815 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -214,7 +214,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         file_loader: None,
         lint_caps: Default::default(),
         psess_created: None,
-        hash_untracked_state: None,
+        track_state: None,
         register_lints: None,
         override_queries: None,
         extra_symbols: Vec::new(),
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 839e68d0bb43..037afbb9f550 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -475,14 +475,15 @@ fn injected_env_var(&mut self, var: &str) -> Option<String> {
     }
 
     fn track_env_var(&mut self, var: &str, value: Option<&str>) {
-        self.psess()
+        self.ecx
+            .sess
             .env_depinfo
             .borrow_mut()
             .insert((Symbol::intern(var), value.map(Symbol::intern)));
     }
 
     fn track_path(&mut self, path: &str) {
-        self.psess().file_depinfo.borrow_mut().insert(Symbol::intern(path));
+        self.ecx.sess.file_depinfo.borrow_mut().insert(Symbol::intern(path));
     }
 
     fn literal_from_str(&mut self, s: &str) -> Result<Literal<Self::Span, Self::Symbol>, String> {
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index ed08e4916436..fa4d4588caab 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -336,11 +336,14 @@ pub struct Config {
     /// This is a callback from the driver that is called when [`ParseSess`] is created.
     pub psess_created: Option<Box<dyn FnOnce(&mut ParseSess) + Send>>,
 
-    /// This is a callback to hash otherwise untracked state used by the caller, if the
-    /// hash changes between runs the incremental cache will be cleared.
+    /// This is a callback to track otherwise untracked state used by the caller.
     ///
-    /// e.g. used by Clippy to hash its config file
-    pub hash_untracked_state: Option<Box<dyn FnOnce(&Session, &mut StableHasher) + Send>>,
+    /// You can write to `sess.env_depinfo` and `sess.file_depinfo` to track env vars and files.
+    /// To track any other state you can write to the given hasher. If the hash changes between
+    /// runs the incremental cache will be cleared.
+    ///
+    /// The hashing functionality has no known user. FIXME should this be removed?
+    pub track_state: Option<Box<dyn FnOnce(&Session, &mut StableHasher) + Send>>,
 
     /// This is a callback from the driver that is called when we're registering lints;
     /// it is called during lint loading when we have the LintStore in a non-shared state.
@@ -464,9 +467,9 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                 psess_created(&mut sess.psess);
             }
 
-            if let Some(hash_untracked_state) = config.hash_untracked_state {
+            if let Some(track_state) = config.track_state {
                 let mut hasher = StableHasher::new();
-                hash_untracked_state(&sess, &mut hasher);
+                track_state(&sess, &mut hasher);
                 sess.opts.untracked_state_hash = hasher.finish()
             }
 
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index a280b2a2a6bf..db88baa0ca19 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -495,7 +495,7 @@ fn env_var_os<'tcx>(tcx: TyCtxt<'tcx>, key: &'tcx OsStr) -> Option<&'tcx OsStr>
     // NOTE: This only works for passes run before `write_dep_info`. See that
     // for extension points for configuring environment variables to be
     // properly change-tracked.
-    tcx.sess.psess.env_depinfo.borrow_mut().insert((
+    tcx.sess.env_depinfo.borrow_mut().insert((
         Symbol::intern(&key.to_string_lossy()),
         value.as_ref().and_then(|value| value.to_str()).map(|value| Symbol::intern(value)),
     ));
@@ -607,7 +607,7 @@ fn write_out_deps(tcx: TyCtxt<'_>, outputs: &OutputFilenames, out_filenames: &[P
 
         // Account for explicitly marked-to-track files
         // (e.g. accessed in proc macros).
-        let file_depinfo = sess.psess.file_depinfo.borrow();
+        let file_depinfo = sess.file_depinfo.borrow();
 
         let normalize_path = |path: PathBuf| escape_dep_filename(&path.to_string_lossy());
 
@@ -719,7 +719,7 @@ fn hash_iter_files<P: AsRef<Path>>(
             }
 
             // Emit special comments with information about accessed environment variables.
-            let env_depinfo = sess.psess.env_depinfo.borrow();
+            let env_depinfo = sess.env_depinfo.borrow();
             if !env_depinfo.is_empty() {
                 // We will soon sort, so the initial order does not matter.
                 #[allow(rustc::potential_query_instability)]
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 74b3aa11d0d8..c625e86ccd9b 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -419,9 +419,9 @@ pub struct Options {
         /// directory to store intermediate results.
         incremental: Option<PathBuf> [UNTRACKED],
         assert_incr_state: Option<IncrementalStateAssertion> [UNTRACKED],
-        /// Set by the `Config::hash_untracked_state` callback for custom
-        /// drivers to invalidate the incremental cache
-        #[rustc_lint_opt_deny_field_access("should only be used via `Config::hash_untracked_state`")]
+        /// Set based on the result of the `Config::track_state` callback
+        /// for custom drivers to invalidate the incremental cache.
+        #[rustc_lint_opt_deny_field_access("should only be used via `Config::track_state`")]
         untracked_state_hash: Hash64 [TRACKED_NO_CRATE_HASH],
 
         unstable_opts: UnstableOptions [SUBSTRUCT UnstableOptionsTargetModifiers UnstableOptions],
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index 9c12c480cacd..bb60da36bbb7 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -6,7 +6,7 @@
 
 use rustc_ast::attr::AttrIdGenerator;
 use rustc_ast::node_id::NodeId;
-use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::sync::{AppendOnlyVec, Lock};
 use rustc_errors::annotate_snippet_emitter_writer::AnnotateSnippetEmitter;
 use rustc_errors::emitter::{EmitterWithNote, stderr_destination};
@@ -264,10 +264,6 @@ pub struct ParseSess {
     pub ambiguous_block_expr_parse: Lock<FxIndexMap<Span, Span>>,
     pub gated_spans: GatedSpans,
     pub symbol_gallery: SymbolGallery,
-    /// Environment variables accessed during the build and their values when they exist.
-    pub env_depinfo: Lock<FxIndexSet<(Symbol, Option<Symbol>)>>,
-    /// File paths accessed during the build.
-    pub file_depinfo: Lock<FxIndexSet<Symbol>>,
     /// Whether cfg(version) should treat the current release as incomplete
     pub assume_incomplete_release: bool,
     /// Spans passed to `proc_macro::quote_span`. Each span has a numerical
@@ -303,8 +299,6 @@ pub fn with_dcx(dcx: DiagCtxt, source_map: Arc<SourceMap>) -> Self {
             ambiguous_block_expr_parse: Lock::new(Default::default()),
             gated_spans: GatedSpans::default(),
             symbol_gallery: SymbolGallery::default(),
-            env_depinfo: Default::default(),
-            file_depinfo: Default::default(),
             assume_incomplete_release: false,
             proc_macro_quoted_spans: Default::default(),
             attr_id_generator: AttrIdGenerator::new(),
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 0548380331be..8290bdf91a03 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -143,6 +143,12 @@ pub struct Session {
     /// None signifies that this is not tracked.
     pub using_internal_features: &'static AtomicBool,
 
+    /// Environment variables accessed during the build and their values when they exist.
+    pub env_depinfo: Lock<FxIndexSet<(Symbol, Option<Symbol>)>>,
+
+    /// File paths accessed during the build.
+    pub file_depinfo: Lock<FxIndexSet<Symbol>>,
+
     target_filesearch: FileSearch,
     host_filesearch: FileSearch,
 
@@ -1095,6 +1101,8 @@ pub fn build_session(
         unstable_target_features: Default::default(),
         cfg_version,
         using_internal_features,
+        env_depinfo: Default::default(),
+        file_depinfo: Default::default(),
         target_filesearch,
         host_filesearch,
         invocation_temp,
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 89b4df1a51ce..a875d6d00221 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -296,7 +296,7 @@ pub(crate) fn create_config(
         file_loader: None,
         lint_caps,
         psess_created: None,
-        hash_untracked_state: None,
+        track_state: None,
         register_lints: Some(Box::new(crate::lint::register_lints)),
         override_queries: Some(|_sess, providers| {
             // We do not register late module lints, so this only runs `MissingDoc`.
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index a61f85bd4007..bfcdc3a50558 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -190,7 +190,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
         file_loader: None,
         lint_caps,
         psess_created: None,
-        hash_untracked_state: None,
+        track_state: None,
         register_lints: Some(Box::new(crate::lint::register_lints)),
         override_queries: None,
         extra_symbols: Vec::new(),
diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs
index f27cb6708709..7b7aac09643a 100644
--- a/src/tools/clippy/src/driver.rs
+++ b/src/tools/clippy/src/driver.rs
@@ -23,9 +23,8 @@
 use clippy_utils::sym;
 use declare_clippy_lint::LintListBuilder;
 use rustc_interface::interface;
-use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::ErrorOutputType;
-use rustc_session::parse::ParseSess;
+use rustc_session::{EarlyDiagCtxt, Session};
 use rustc_span::symbol::Symbol;
 
 use std::env;
@@ -81,17 +80,16 @@ fn test_has_arg() {
     assert!(!has_arg(args, "--bar"));
 }
 
-fn track_clippy_args(psess: &mut ParseSess, args_env_var: Option<&str>) {
-    psess
-        .env_depinfo
-        .get_mut()
+fn track_clippy_args(sess: &Session, args_env_var: Option<&str>) {
+    sess.env_depinfo
+        .borrow_mut()
         .insert((sym::CLIPPY_ARGS, args_env_var.map(Symbol::intern)));
 }
 
 /// Track files that may be accessed at runtime in `file_depinfo` so that cargo will re-run clippy
 /// when any of them are modified
-fn track_files(psess: &mut ParseSess) {
-    let file_depinfo = psess.file_depinfo.get_mut();
+fn track_files(sess: &Session) {
+    let mut file_depinfo = sess.file_depinfo.borrow_mut();
 
     // Used by `clippy::cargo` lints and to determine the MSRV. `cargo clippy` executes `clippy-driver`
     // with the current directory set to `CARGO_MANIFEST_DIR` so a relative path is fine
@@ -123,8 +121,8 @@ struct RustcCallbacks {
 impl rustc_driver::Callbacks for RustcCallbacks {
     fn config(&mut self, config: &mut interface::Config) {
         let clippy_args_var = self.clippy_args_var.take();
-        config.psess_created = Some(Box::new(move |psess| {
-            track_clippy_args(psess, clippy_args_var.as_deref());
+        config.track_state = Some(Box::new(move |sess, _hasher| {
+            track_clippy_args(sess, clippy_args_var.as_deref());
         }));
         config.extra_symbols = sym::EXTRA_SYMBOLS.into();
     }
@@ -140,13 +138,13 @@ fn config(&mut self, config: &mut interface::Config) {
         let conf_path = clippy_config::lookup_conf_file();
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
-        config.psess_created = Some(Box::new(move |psess| {
-            track_clippy_args(psess, clippy_args_var.as_deref());
-            track_files(psess);
+        config.track_state = Some(Box::new(move |sess, _hasher| {
+            track_clippy_args(sess, clippy_args_var.as_deref());
+            track_files(sess);
 
             // Trigger a rebuild if CLIPPY_CONF_DIR changes. The value must be a valid string so
             // changes between dirs that are invalid UTF-8 will not trigger rebuilds
-            psess.env_depinfo.get_mut().insert((
+            sess.env_depinfo.borrow_mut().insert((
                 sym::CLIPPY_CONF_DIR,
                 env::var("CLIPPY_CONF_DIR").ok().map(|dir| Symbol::intern(&dir)),
             ));
diff --git a/tests/ui-fulldeps/run-compiler-twice.rs b/tests/ui-fulldeps/run-compiler-twice.rs
index bd92cc6218f1..d99d9c42d547 100644
--- a/tests/ui-fulldeps/run-compiler-twice.rs
+++ b/tests/ui-fulldeps/run-compiler-twice.rs
@@ -66,7 +66,7 @@ fn compile(code: String, output: PathBuf, sysroot: Sysroot, linker: Option<&Path
         file_loader: None,
         lint_caps: Default::default(),
         psess_created: None,
-        hash_untracked_state: None,
+        track_state: None,
         register_lints: None,
         override_queries: None,
         extra_symbols: Vec::new(),

From 62bd45d7beeaf32c7a0739c8f3814f616b994034 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 2 Feb 2025 15:51:14 +0000
Subject: [PATCH 0389/1059] Move env/file_depinfo from ParseSess to Session

---
 src/driver.rs | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/driver.rs b/src/driver.rs
index f27cb6708709..7b7aac09643a 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -23,9 +23,8 @@
 use clippy_utils::sym;
 use declare_clippy_lint::LintListBuilder;
 use rustc_interface::interface;
-use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::ErrorOutputType;
-use rustc_session::parse::ParseSess;
+use rustc_session::{EarlyDiagCtxt, Session};
 use rustc_span::symbol::Symbol;
 
 use std::env;
@@ -81,17 +80,16 @@ fn test_has_arg() {
     assert!(!has_arg(args, "--bar"));
 }
 
-fn track_clippy_args(psess: &mut ParseSess, args_env_var: Option<&str>) {
-    psess
-        .env_depinfo
-        .get_mut()
+fn track_clippy_args(sess: &Session, args_env_var: Option<&str>) {
+    sess.env_depinfo
+        .borrow_mut()
         .insert((sym::CLIPPY_ARGS, args_env_var.map(Symbol::intern)));
 }
 
 /// Track files that may be accessed at runtime in `file_depinfo` so that cargo will re-run clippy
 /// when any of them are modified
-fn track_files(psess: &mut ParseSess) {
-    let file_depinfo = psess.file_depinfo.get_mut();
+fn track_files(sess: &Session) {
+    let mut file_depinfo = sess.file_depinfo.borrow_mut();
 
     // Used by `clippy::cargo` lints and to determine the MSRV. `cargo clippy` executes `clippy-driver`
     // with the current directory set to `CARGO_MANIFEST_DIR` so a relative path is fine
@@ -123,8 +121,8 @@ struct RustcCallbacks {
 impl rustc_driver::Callbacks for RustcCallbacks {
     fn config(&mut self, config: &mut interface::Config) {
         let clippy_args_var = self.clippy_args_var.take();
-        config.psess_created = Some(Box::new(move |psess| {
-            track_clippy_args(psess, clippy_args_var.as_deref());
+        config.track_state = Some(Box::new(move |sess, _hasher| {
+            track_clippy_args(sess, clippy_args_var.as_deref());
         }));
         config.extra_symbols = sym::EXTRA_SYMBOLS.into();
     }
@@ -140,13 +138,13 @@ fn config(&mut self, config: &mut interface::Config) {
         let conf_path = clippy_config::lookup_conf_file();
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
-        config.psess_created = Some(Box::new(move |psess| {
-            track_clippy_args(psess, clippy_args_var.as_deref());
-            track_files(psess);
+        config.track_state = Some(Box::new(move |sess, _hasher| {
+            track_clippy_args(sess, clippy_args_var.as_deref());
+            track_files(sess);
 
             // Trigger a rebuild if CLIPPY_CONF_DIR changes. The value must be a valid string so
             // changes between dirs that are invalid UTF-8 will not trigger rebuilds
-            psess.env_depinfo.get_mut().insert((
+            sess.env_depinfo.borrow_mut().insert((
                 sym::CLIPPY_CONF_DIR,
                 env::var("CLIPPY_CONF_DIR").ok().map(|dir| Symbol::intern(&dir)),
             ));

From 2c85a53b5d51314c2712d5699ff381a49d0b393b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 12 Mar 2026 18:36:37 +0100
Subject: [PATCH 0390/1059] Reduce clippy lints HTML size by removing a CSS
 class

---
 util/gh-pages/index_template.html |  6 +++---
 util/gh-pages/style.css           | 11 ++++++-----
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/util/gh-pages/index_template.html b/util/gh-pages/index_template.html
index 35254fcfab79..26ca901fcd22 100644
--- a/util/gh-pages/index_template.html
+++ b/util/gh-pages/index_template.html
@@ -174,13 +174,13 @@ Otherwise, have a great day =^.^=
                     <h2 class="lint-title"> {# #}
                         <div class="panel-title-name" id="lint-{{lint.id}}"> {# #}
                             {{lint.id ~}}
-                            <a href="#{{lint.id}}" class="anchor label label-default">&para;</a> {#+ #}
-                            <a href="" class="copy-to-clipboard anchor label label-default"> {# #}
+                            <a href="#{{lint.id}}" class="anchor label">&para;</a> {#+ #}
+                            <a href="" class="copy-to-clipboard anchor label"> {# #}
                                 &#128203; {# #}
                             </a> {# #}
                         </div> {# #}
 
-                        <span class="label label-default lint-group group-{{lint.group}}">{{lint.group}}</span> {#+ #}
+                        <span class="label lint-group group-{{lint.group}}">{{lint.group}}</span> {#+ #}
 
                         <span class="label lint-level level-{{lint.level}}">{{lint.level}}</span> {#+ #}
 
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index 59868ddce847..4f1935ba972f 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -1,5 +1,6 @@
 body {
     --icon-filter: initial;
+    --label-background: #777;
 }
 
 body.ayu {
@@ -230,7 +231,10 @@ button .caret {
 
 .panel-title-name { flex: 1; min-width: 400px;}
 
-.panel-title-name .anchor { display: none; }
+.panel-title-name .anchor {
+    display: none;
+    background-color: var(--label-background);
+}
 article:hover .panel-title-name .anchor { display: inline;}
 
 .search-control {
@@ -397,10 +401,6 @@ article:hover .panel-title-name .anchor { display: inline;}
     text-decoration: none;
 }
 
-.label-default {
-    background-color: #777;
-}
-
 .lint-level {
     min-width: 4em;
 }
@@ -420,6 +420,7 @@ article:hover .panel-title-name .anchor { display: inline;}
 
 .lint-group {
     min-width: 8em;
+    background-color: var(--label-background);
 }
 .group-deprecated {
     opacity: 0.5;

From 862729e745885103a4834e1f206c47d7f94687d6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 12 Mar 2026 18:37:00 +0100
Subject: [PATCH 0391/1059] Rename `rustc_middle::lint::diag_lint_level` into
 `emit_lint_base`

---
 compiler/rustc_codegen_ssa/src/back/link.rs |  6 +++---
 compiler/rustc_lint/src/context.rs          |  2 +-
 compiler/rustc_lint/src/levels.rs           | 10 +++++-----
 compiler/rustc_middle/src/lint.rs           |  9 +++------
 compiler/rustc_middle/src/ty/context.rs     |  6 +++---
 5 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 56dca6c8b902..7a3d5a6bb224 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -30,7 +30,7 @@
     walk_native_lib_search_dirs,
 };
 use rustc_middle::bug;
-use rustc_middle::lint::diag_lint_level;
+use rustc_middle::lint::emit_lint_base;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
@@ -784,7 +784,7 @@ fn for_each(bytes: &[u8], mut f: impl FnMut(&str, &mut String)) -> String {
     }
 
     let lint_msg = |msg| {
-        diag_lint_level(
+        emit_lint_base(
             sess,
             LINKER_MESSAGES,
             levels.linker_messages,
@@ -793,7 +793,7 @@ fn for_each(bytes: &[u8], mut f: impl FnMut(&str, &mut String)) -> String {
         );
     };
     let lint_info = |msg| {
-        diag_lint_level(sess, LINKER_INFO, levels.linker_info, None, LinkerOutput { inner: msg });
+        emit_lint_base(sess, LINKER_INFO, levels.linker_info, None, LinkerOutput { inner: msg });
     };
 
     if !escaped_stderr.is_empty() {
diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index ecf71f93cf5e..9c2907cfacf7 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -514,7 +514,7 @@ pub trait LintContext {
     // set the span in their `decorate` function (preferably using set_span).
     /// Emit a lint at the appropriate level, with an optional associated span.
     ///
-    /// [`diag_lint_level`]: rustc_middle::lint::diag_lint_level#decorate-signature
+    /// [`emit_lint_base`]: rustc_middle::lint::emit_lint_base#decorate-signature
     #[track_caller]
     fn opt_span_diag_lint<S: Into<MultiSpan>>(
         &self,
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 6f3a7e945d93..5536bfc0176a 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -12,7 +12,7 @@
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::{
-    LevelAndSource, LintExpectation, LintLevelSource, ShallowLintLevelMap, diag_lint_level,
+    LevelAndSource, LintExpectation, LintLevelSource, ShallowLintLevelMap, emit_lint_base,
     reveal_actual_level,
 };
 use rustc_middle::query::Providers;
@@ -981,7 +981,7 @@ fn into_diag(
         if self.lint_added_lints {
             let lint = builtin::UNKNOWN_LINTS;
             let level = self.lint_level(builtin::UNKNOWN_LINTS);
-            diag_lint_level(
+            emit_lint_base(
                 self.sess,
                 lint,
                 level,
@@ -1008,7 +1008,7 @@ pub(crate) fn opt_span_diag_lint(
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
         let level = self.lint_level(lint);
-        diag_lint_level(self.sess, lint, level, span, decorator)
+        emit_lint_base(self.sess, lint, level, span, decorator)
     }
 
     #[track_caller]
@@ -1019,13 +1019,13 @@ pub fn emit_span_lint(
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
         let level = self.lint_level(lint);
-        diag_lint_level(self.sess, lint, level, Some(span), decorator);
+        emit_lint_base(self.sess, lint, level, Some(span), decorator);
     }
 
     #[track_caller]
     pub fn emit_lint(&self, lint: &'static Lint, decorator: impl for<'a> Diagnostic<'a, ()>) {
         let level = self.lint_level(lint);
-        diag_lint_level(self.sess, lint, level, None, decorator);
+        emit_lint_base(self.sess, lint, level, None, decorator);
     }
 }
 
diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
index f302f18f3b47..c42783fc77e3 100644
--- a/compiler/rustc_middle/src/lint.rs
+++ b/compiler/rustc_middle/src/lint.rs
@@ -300,11 +300,8 @@ fn explain_lint_level_source(
 ///
 /// - [`TyCtxt::emit_node_span_lint`]
 /// - `LintContext::opt_span_lint`
-///
-/// This function will replace `lint_level` once all its callers have been replaced
-/// with `diag_lint_level`.
 #[track_caller]
-pub fn diag_lint_level<'a, D: Diagnostic<'a, ()> + 'a>(
+pub fn emit_lint_base<'a, D: Diagnostic<'a, ()> + 'a>(
     sess: &'a Session,
     lint: &'static Lint,
     level: LevelAndSource,
@@ -314,7 +311,7 @@ pub fn diag_lint_level<'a, D: Diagnostic<'a, ()> + 'a>(
     // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to
     // the "real" work.
     #[track_caller]
-    fn diag_lint_level_impl<'a>(
+    fn emit_lint_base_impl<'a>(
         sess: &'a Session,
         lint: &'static Lint,
         level: LevelAndSource,
@@ -498,7 +495,7 @@ fn diag_lint_level_impl<'a>(
         explain_lint_level_source(sess, lint, level, src, &mut err);
         err.emit();
     }
-    diag_lint_level_impl(
+    emit_lint_base_impl(
         sess,
         lint,
         level,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 11f2d575a659..91105f416c8f 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -55,7 +55,7 @@
 use crate::dep_graph::{DepGraph, DepKindVTable, DepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::infer::canonical::{CanonicalParamEnvCache, CanonicalVarKind};
-use crate::lint::diag_lint_level;
+use crate::lint::emit_lint_base;
 use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
 use crate::middle::resolve_bound_vars;
@@ -2539,7 +2539,7 @@ pub fn emit_node_span_lint(
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
         let level = self.lint_level_at_node(lint, hir_id);
-        diag_lint_level(self.sess, lint, level, Some(span.into()), decorator)
+        emit_lint_base(self.sess, lint, level, Some(span.into()), decorator)
     }
 
     /// Find the appropriate span where `use` and outer attributes can be inserted at.
@@ -2582,7 +2582,7 @@ pub fn emit_node_lint(
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
         let level = self.lint_level_at_node(lint, id);
-        diag_lint_level(self.sess, lint, level, None, decorator);
+        emit_lint_base(self.sess, lint, level, None, decorator);
     }
 
     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx [TraitCandidate<'tcx>]> {

From fd45124860b739675e0df36a6531dbc98536f5a8 Mon Sep 17 00:00:00 2001
From: zedddie <zedddie@protonmail.com>
Date: Thu, 12 Mar 2026 18:44:21 +0100
Subject: [PATCH 0392/1059] add generic & unresolved inference variables
 handling in `select_transmute_obligation_for_reporting`

---
 .../src/error_reporting/traits/fulfillment_errors.rs  |  4 ++++
 .../generic-transmute-from-regression.rs              | 11 +++++++++++
 .../generic-transmute-from-regression.stderr          | 11 +++++++++++
 3 files changed, 26 insertions(+)
 create mode 100644 tests/ui/transmutability/generic-transmute-from-regression.rs
 create mode 100644 tests/ui/transmutability/generic-transmute-from-regression.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index d5383fd4d083..598a7407c1aa 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -2832,6 +2832,10 @@ fn select_transmute_obligation_for_reporting(
         trait_predicate: ty::PolyTraitPredicate<'tcx>,
         root_obligation: &PredicateObligation<'tcx>,
     ) -> (PredicateObligation<'tcx>, ty::PolyTraitPredicate<'tcx>) {
+        if obligation.predicate.has_non_region_param() || obligation.has_non_region_infer() {
+            return (obligation.clone(), trait_predicate);
+        }
+
         let ocx = ObligationCtxt::new(self);
         let normalized_predicate = self.tcx.erase_and_anonymize_regions(
             self.tcx.instantiate_bound_regions_with_erased(trait_predicate),
diff --git a/tests/ui/transmutability/generic-transmute-from-regression.rs b/tests/ui/transmutability/generic-transmute-from-regression.rs
new file mode 100644
index 000000000000..38568243ed9d
--- /dev/null
+++ b/tests/ui/transmutability/generic-transmute-from-regression.rs
@@ -0,0 +1,11 @@
+//! Regression test for: <https://github.com/rust-lang/rust/issues/153755>
+#![feature(transmutability)]
+
+fn foo<T, U>(x: T) -> U {
+    unsafe {
+        std::mem::TransmuteFrom::transmute(x)
+        //~^ ERROR: the trait bound `U: TransmuteFrom<T, _>` is not satisfied [E0277]
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmutability/generic-transmute-from-regression.stderr b/tests/ui/transmutability/generic-transmute-from-regression.stderr
new file mode 100644
index 000000000000..3912aec0a9c8
--- /dev/null
+++ b/tests/ui/transmutability/generic-transmute-from-regression.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `U: TransmuteFrom<T, _>` is not satisfied
+  --> $DIR/generic-transmute-from-regression.rs:6:44
+   |
+LL |         std::mem::TransmuteFrom::transmute(x)
+   |         ---------------------------------- ^ the nightly-only, unstable trait `TransmuteFrom<T, _>` is not implemented for `U`
+   |         |
+   |         required by a bound introduced by this call
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

From 512d5fd676035517132c9b7e2cd43cd3b24432fa Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Thu, 12 Mar 2026 20:24:48 +0100
Subject: [PATCH 0393/1059] tests/debuginfo/basic-stepping.rs: Add lldb test

Also move the FIXME to the source code to avoid duplication, and also
suppress harmless warnings that are annoying when you compile manually.
---
 tests/debuginfo/basic-stepping.rs | 57 +++++++++++++++++++++++++++++--
 1 file changed, 55 insertions(+), 2 deletions(-)

diff --git a/tests/debuginfo/basic-stepping.rs b/tests/debuginfo/basic-stepping.rs
index 744f8f5dd654..6aa8aeceb1e6 100644
--- a/tests/debuginfo/basic-stepping.rs
+++ b/tests/debuginfo/basic-stepping.rs
@@ -14,9 +14,9 @@
 //@ revisions: default-mir-passes no-SingleUseConsts-mir-pass
 //@ [no-SingleUseConsts-mir-pass] compile-flags: -Zmir-enable-passes=-SingleUseConsts
 
+// === GDB TESTS ===================================================================================
+
 //@ gdb-command: run
-// FIXME(#97083): Should we be able to break on initialization of zero-sized types?
-// FIXME(#97083): Right now the first breakable line is:
 //@ gdb-check:   let mut c = 27;
 //@ gdb-command: next
 //@ gdb-check:   let d = c = 99;
@@ -39,9 +39,62 @@
 //@ gdb-command: next
 //@ gdb-check:   let m: *const() = &a;
 
+// === LLDB TESTS ==================================================================================
+
+// Unlike gdb, lldb will display 7 lines of context by default. It seems
+// impossible to get it down to 1. The best we can do is to show the current
+// line and one above. That is not ideal, but it will do for now.
+//@ lldb-command: settings set stop-line-count-before 1
+//@ lldb-command: settings set stop-line-count-after 0
+
+//@ lldb-command: run
+// In `breakpoint_callback()` in `./src/etc/lldb_batchmode.py` we do
+// `SetSelectedFrame()`, which causes LLDB to show the current line and one line
+// before (since we changed `stop-line-count-before`). Note that
+// `normalize_whitespace()` in `lldb_batchmode.py` removes the newlines of the
+// output. So the current line and the line before actually ends up on the same
+// output line. That's fine.
+//@ lldb-check:   [...]let mut c = 27;[...]
+//@ lldb-command: next
+// From now on we must manually `frame select` to see the current line (and one
+// line before).
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let d = c = 99;[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ [no-SingleUseConsts-mir-pass] lldb-check:   [...]let e = "hi bob";[...]
+//@ [no-SingleUseConsts-mir-pass] lldb-command: next
+//@ [no-SingleUseConsts-mir-pass] lldb-command: frame select
+//@ [no-SingleUseConsts-mir-pass] lldb-check:   [...]let f = b"hi bob";[...]
+//@ [no-SingleUseConsts-mir-pass] lldb-command: next
+//@ [no-SingleUseConsts-mir-pass] lldb-command: frame select
+//@ [no-SingleUseConsts-mir-pass] lldb-check:   [...]let g = b'9';[...]
+//@ [no-SingleUseConsts-mir-pass] lldb-command: next
+//@ [no-SingleUseConsts-mir-pass] lldb-command: frame select
+//@ lldb-check:   [...]let h = ["whatever"; 8];[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let i = [1,2,3,4];[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let j = (23, "hi");[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let k = 2..3;[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let l = &i[k];[...]
+//@ lldb-command: next
+//@ lldb-command: frame select
+//@ lldb-check:   [...]let m: *const() = &a;[...]
+
+#![allow(unused_assignments, unused_variables)]
+
 fn main () {
     let a = (); // #break
     let b : [i32; 0] = [];
+    // FIXME(#97083): Should we be able to break on initialization of zero-sized types?
+    // FIXME(#97083): Right now the first breakable line is:
     let mut c = 27;
     let d = c = 99;
     let e = "hi bob";

From cc2c5f9b8d19bae79ed8f1671c9ea4feea9f76a2 Mon Sep 17 00:00:00 2001
From: Paul Murphy <murp@redhat.com>
Date: Thu, 12 Mar 2026 09:14:06 -0500
Subject: [PATCH 0394/1059] Fix mcount name for *-windows-gnu targets

mingw exposes the `_mcount` symbol for profiling.
---
 compiler/rustc_target/src/spec/base/windows_gnu.rs     | 1 +
 compiler/rustc_target/src/spec/base/windows_gnullvm.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs
index d2fe42b90306..cee3f9122699 100644
--- a/compiler/rustc_target/src/spec/base/windows_gnu.rs
+++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs
@@ -106,6 +106,7 @@ pub(crate) fn opts() -> TargetOptions {
         // FIXME(davidtwco): Support Split DWARF on Windows GNU - may require LLVM changes to
         // output DWO, despite using DWARF, doesn't use ELF..
         supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
+        mcount: "_mcount".into(),
         ..Default::default()
     }
 }
diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
index 3bd8ebd0ed3d..8e26852d0371 100644
--- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
+++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
@@ -53,6 +53,7 @@ pub(crate) fn opts() -> TargetOptions {
         // FIXME(davidtwco): Support Split DWARF on Windows GNU - may require LLVM changes to
         // output DWO, despite using DWARF, doesn't use ELF..
         supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
+        mcount: "_mcount".into(),
         ..Default::default()
     }
 }

From 87c25522c6cace676266e64cbbe7774d5eae89fe Mon Sep 17 00:00:00 2001
From: Paul Murphy <murp@redhat.com>
Date: Thu, 12 Mar 2026 11:54:56 -0500
Subject: [PATCH 0395/1059] Link extra libraries when using mcount on
 *-windows-gnu targets

libgmon needs to be linked. This also requires readding a few
other system libraries to satisfy its dependencies.
---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 55ee9b1b974a..89cd1528ced9 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -737,6 +737,13 @@ fn enable_profiling(&mut self) {
         // This flag is also used when linking to choose target specific
         // libraries needed to enable profiling.
         self.cc_arg("-pg");
+        // On windows-gnu targets, libgmon also needs to be linked, and this
+        // requires readding libraries to satisfy its dependencies.
+        if self.sess.target.is_like_windows {
+            self.cc_arg("-lgmon");
+            self.cc_arg("-lkernel32");
+            self.cc_arg("-lmsvcrt");
+        }
     }
 
     fn control_flow_guard(&mut self) {}

From 919fd6b64c80182a778d85949bca49a35ef0a7ea Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Fri, 27 Feb 2026 15:34:17 +0000
Subject: [PATCH 0396/1059] add new unstable flag for minimal recursion

---
 compiler/rustc_interface/src/limits.rs        | 15 ++++++++----
 compiler/rustc_interface/src/passes.rs        |  2 +-
 compiler/rustc_interface/src/tests.rs         |  1 +
 compiler/rustc_session/src/options.rs         |  2 ++
 .../src/compiler-flags/min-recursive-limit.md | 12 ++++++++++
 ...recursion-limit-attr-lower-than-default.rs | 20 ++++++++++++++++
 .../min-recursion-limit-attr-wins.rs          | 24 +++++++++++++++++++
 .../min-recursion-limit-cli-wins.rs           | 24 +++++++++++++++++++
 .../min-recursion-limit-no-attr.rs            | 23 ++++++++++++++++++
 9 files changed, 118 insertions(+), 5 deletions(-)
 create mode 100644 src/doc/unstable-book/src/compiler-flags/min-recursive-limit.md
 create mode 100644 tests/ui/recursion/recursion_limit/min-recursion-limit-attr-lower-than-default.rs
 create mode 100644 tests/ui/recursion/recursion_limit/min-recursion-limit-attr-wins.rs
 create mode 100644 tests/ui/recursion/recursion_limit/min-recursion-limit-cli-wins.rs
 create mode 100644 tests/ui/recursion/recursion_limit/min-recursion-limit-no-attr.rs

diff --git a/compiler/rustc_interface/src/limits.rs b/compiler/rustc_interface/src/limits.rs
index e0fc91f3b723..8ae0743886ce 100644
--- a/compiler/rustc_interface/src/limits.rs
+++ b/compiler/rustc_interface/src/limits.rs
@@ -11,13 +11,13 @@
 use rustc_hir::limit::Limit;
 use rustc_hir::{Attribute, find_attr};
 use rustc_middle::query::Providers;
-use rustc_session::Limits;
+use rustc_session::{Limits, Session};
 
 pub(crate) fn provide(providers: &mut Providers) {
     providers.limits = |tcx, ()| {
         let attrs = tcx.hir_krate_attrs();
         Limits {
-            recursion_limit: get_recursion_limit(tcx.hir_krate_attrs()),
+            recursion_limit: get_recursion_limit(tcx.hir_krate_attrs(), tcx.sess),
             move_size_limit: find_attr!(attrs, MoveSizeLimit { limit, .. } => *limit)
                 .unwrap_or(Limit::new(tcx.sess.opts.unstable_opts.move_size_limit.unwrap_or(0))),
             type_length_limit: find_attr!(attrs, TypeLengthLimit { limit, .. } => *limit)
@@ -30,6 +30,13 @@ pub(crate) fn provide(providers: &mut Providers) {
 }
 
 // This one is separate because it must be read prior to macro expansion.
-pub(crate) fn get_recursion_limit(attrs: &[Attribute]) -> Limit {
-    find_attr!(attrs, RecursionLimit { limit, .. } => *limit).unwrap_or(Limit::new(128))
+pub(crate) fn get_recursion_limit(attrs: &[Attribute], sess: &Session) -> Limit {
+    let limit_from_crate =
+        find_attr!(attrs, RecursionLimit { limit, .. } => limit.0).unwrap_or(128);
+    Limit::new(
+        sess.opts
+            .unstable_opts
+            .min_recursion_limit
+            .map_or(limit_from_crate, |min| min.max(limit_from_crate)),
+    )
 }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index a280b2a2a6bf..5cf4b1546320 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -1429,5 +1429,5 @@ fn get_recursion_limit(krate_attrs: &[ast::Attribute], sess: &Session) -> Limit
         // So, no lints here to avoid duplicates.
         ShouldEmit::EarlyFatal { also_emit_lints: false },
     );
-    crate::limits::get_recursion_limit(attr.as_slice())
+    crate::limits::get_recursion_limit(attr.as_slice(), sess)
 }
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 88056a0db966..6c2924dfe9bd 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -822,6 +822,7 @@ macro_rules! tracked {
     tracked!(maximal_hir_to_mir_coverage, true);
     tracked!(merge_functions, Some(MergeFunctions::Disabled));
     tracked!(min_function_alignment, Some(Align::EIGHT));
+    tracked!(min_recursion_limit, Some(256));
     tracked!(mir_emit_retag, true);
     tracked!(mir_enable_passes, vec![("DestProp".to_string(), false)]);
     tracked!(mir_opt_level, Some(4));
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 74b3aa11d0d8..0bc432a0ff06 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2456,6 +2456,8 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
         "the directory metrics emitted by rustc are dumped into (implicitly enables default set of metrics)"),
     min_function_alignment: Option<Align> = (None, parse_align, [TRACKED],
         "align all functions to at least this many bytes. Must be a power of 2"),
+    min_recursion_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "set a minimum recursion limit (final limit = max(this, recursion_limit_from_crate))"),
     mir_emit_retag: bool = (false, parse_bool, [TRACKED],
         "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
         (default: no)"),
diff --git a/src/doc/unstable-book/src/compiler-flags/min-recursive-limit.md b/src/doc/unstable-book/src/compiler-flags/min-recursive-limit.md
new file mode 100644
index 000000000000..c00cdb95c032
--- /dev/null
+++ b/src/doc/unstable-book/src/compiler-flags/min-recursive-limit.md
@@ -0,0 +1,12 @@
+# `min-recursion-limit`
+
+This flag sets a minimum recursion limit for the compiler. The final recursion limit is calculated as `max(min_recursion_limit, recursion_limit_from_crate)`. This cannot ever lower the recursion limit. Unless the current crate has an explicitly low `recursion_limit` attribute, any value less than the current default does not have an effect.
+
+The recursion limit affects (among other things):
+
+- macro expansion
+- the trait solver
+- const evaluation
+- query depth
+
+This flag is particularly useful when using the next trait solver (`-Z next-solver`), which may require a higher recursion limit for crates that were compiled successfully with the old solver.
diff --git a/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-lower-than-default.rs b/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-lower-than-default.rs
new file mode 100644
index 000000000000..d9de45b5735e
--- /dev/null
+++ b/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-lower-than-default.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Z min-recursion-limit=0
+//@ check-pass
+
+// Checks that `min-recursion-limit` cannot lower the default recursion limit
+
+macro_rules! count {
+    () => {};
+    ($_:tt $($rest:tt)*) => { count!($($rest)*) };
+}
+
+fn main() {
+    // 100
+    count!(
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+    );
+}
diff --git a/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-wins.rs b/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-wins.rs
new file mode 100644
index 000000000000..44c9f76f3785
--- /dev/null
+++ b/tests/ui/recursion/recursion_limit/min-recursion-limit-attr-wins.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Z min-recursion-limit=256
+//@ check-pass
+#![recursion_limit = "128"]
+
+macro_rules! count {
+    () => {};
+    ($_:tt $($rest:tt)*) => { count!($($rest)*) };
+}
+
+fn main() {
+    // 200
+    count!(
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+    );
+}
diff --git a/tests/ui/recursion/recursion_limit/min-recursion-limit-cli-wins.rs b/tests/ui/recursion/recursion_limit/min-recursion-limit-cli-wins.rs
new file mode 100644
index 000000000000..10dc9cfe06b2
--- /dev/null
+++ b/tests/ui/recursion/recursion_limit/min-recursion-limit-cli-wins.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Z min-recursion-limit=64
+//@ check-pass
+#![recursion_limit = "256"]
+
+macro_rules! count {
+    () => {};
+    ($_:tt $($rest:tt)*) => { count!($($rest)*) };
+}
+
+fn main() {
+    // 200
+    count!(
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+    );
+}
diff --git a/tests/ui/recursion/recursion_limit/min-recursion-limit-no-attr.rs b/tests/ui/recursion/recursion_limit/min-recursion-limit-no-attr.rs
new file mode 100644
index 000000000000..f918ec86c141
--- /dev/null
+++ b/tests/ui/recursion/recursion_limit/min-recursion-limit-no-attr.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Z min-recursion-limit=256
+//@ check-pass
+
+macro_rules! count {
+    () => {};
+    ($_:tt $($rest:tt)*) => { count!($($rest)*) };
+}
+
+fn main() {
+    // 200
+    count!(
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+        a a a a a a a a a a a a a a a a a a a a
+    );
+}

From 772e4560ed4a1c58c36288407df0eac6686e02ea Mon Sep 17 00:00:00 2001
From: Oscar Bray <oscarbray@gmail.com>
Date: Thu, 12 Mar 2026 22:36:14 +0000
Subject: [PATCH 0397/1059] Compiletest: Fix compare-output-by-lines directive

Fixes: https://github.com/rust-lang/rust/issues/148235

This was checking that the blessed stderr was a
subset of the stderr. Additionally, when re-blessing
it would re-bless the subset that matched. So, when
an extra line or comment was added and the line
numbers changed, it would bless it without the line
numbers.
---
 src/tools/compiletest/src/runtest.rs          | 20 +++++++++++++++----
 .../cycle_crash-issue-135870.stderr           | 12 ++++++++++-
 .../ty-variance-issue-124423.stderr           | 13 ++++++------
 .../ty-variance-issue-127971.stderr           |  3 ++-
 .../unexpected-type-issue-120601.stderr       | 17 ++++++++++------
 5 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index fce3269b149a..69a9e04afe1c 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2718,18 +2718,19 @@ fn compare_output(
         // Wrapper tools set by `runner` might provide extra output on failure,
         // for example a WebAssembly runtime might print the stack trace of an
         // `unreachable` instruction by default.
-        //
+        let compare_output_by_lines_subset = self.config.runner.is_some();
+
         // Also, some tests like `ui/parallel-rustc` have non-deterministic
         // orders of output, so we need to compare by lines.
-        let compare_output_by_lines =
-            self.props.compare_output_by_lines || self.config.runner.is_some();
+        let compare_output_by_lines = self.props.compare_output_by_lines;
 
         let tmp;
-        let (expected, actual): (&str, &str) = if compare_output_by_lines {
+        let (expected, actual): (&str, &str) = if compare_output_by_lines_subset {
             let actual_lines: HashSet<_> = actual.lines().collect();
             let expected_lines: Vec<_> = expected.lines().collect();
             let mut used = expected_lines.clone();
             used.retain(|line| actual_lines.contains(line));
+
             // check if `expected` contains a subset of the lines of `actual`
             if used.len() == expected_lines.len() && (expected.is_empty() == actual.is_empty()) {
                 return CompareOutcome::Same;
@@ -2738,9 +2739,20 @@ fn compare_output(
                 // if we have no lines to check, force a full overwite
                 ("", actual)
             } else {
+                // this prints/blesses the subset, not the actual
                 tmp = (expected_lines.join("\n"), used.join("\n"));
                 (&tmp.0, &tmp.1)
             }
+        } else if compare_output_by_lines {
+            let mut actual_lines: Vec<&str> = actual.lines().collect();
+            let mut expected_lines: Vec<&str> = expected.lines().collect();
+            actual_lines.sort_unstable();
+            expected_lines.sort_unstable();
+            if actual_lines == expected_lines {
+                return CompareOutcome::Same;
+            } else {
+                (expected, actual)
+            }
         } else {
             (expected, actual)
         };
diff --git a/tests/ui/parallel-rustc/cycle_crash-issue-135870.stderr b/tests/ui/parallel-rustc/cycle_crash-issue-135870.stderr
index b80d0f92fcfa..a5c6ad5e90ba 100644
--- a/tests/ui/parallel-rustc/cycle_crash-issue-135870.stderr
+++ b/tests/ui/parallel-rustc/cycle_crash-issue-135870.stderr
@@ -1,12 +1,22 @@
+error[E0391]: cycle detected when checking if `FOO` is a trivial const
   --> $DIR/cycle_crash-issue-135870.rs:6:1
    |
 LL | const FOO: usize = FOO;
    | ^^^^^^^^^^^^^^^^
    |
+note: ...which requires building MIR for `FOO`...
+  --> $DIR/cycle_crash-issue-135870.rs:6:1
    |
 LL | const FOO: usize = FOO;
+   | ^^^^^^^^^^^^^^^^
+   = note: ...which again requires checking if `FOO` is a trivial const, completing the cycle
+note: cycle used when simplifying constant for the type system `FOO`
+  --> $DIR/cycle_crash-issue-135870.rs:6:1
+   |
+LL | const FOO: usize = FOO;
+   | ^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0391`.
\ No newline at end of file
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr b/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
index bf9ad85dfc5c..631f43eea906 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
+++ b/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
@@ -244,10 +244,10 @@ LL | fn elided4(_: &impl Copy + 'a) ->  new  { x(x) }
    |                                    ^^^ not found in this scope
 
 error[E0224]: at least one trait is required for an object type
-  --> $DIR/ty-variance-issue-124423.rs:35:39
+  --> $DIR/ty-variance-issue-124423.rs:55:40
    |
-LL | fn elided3(_: &impl Copy + 'a) -> Box<dyn 'a> { Box::new(x) }
-   |                                       ^^^^^^
+LL | impl<'a> LifetimeTrait<'a> for &'a Box<dyn 'a> {}
+   |                                        ^^^^^^
 
 error[E0224]: at least one trait is required for an object type
   --> $DIR/ty-variance-issue-124423.rs:41:40
@@ -256,10 +256,10 @@ LL | fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
    |                                        ^^^^^^
 
 error[E0224]: at least one trait is required for an object type
-  --> $DIR/ty-variance-issue-124423.rs:55:40
+  --> $DIR/ty-variance-issue-124423.rs:35:39
    |
-LL | impl<'a> LifetimeTrait<'a> for &'a Box<dyn 'a> {}
-   |                                        ^^^^^^
+LL | fn elided3(_: &impl Copy + 'a) -> Box<dyn 'a> { Box::new(x) }
+   |                                       ^^^^^^
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/ty-variance-issue-124423.rs:8:34
@@ -278,6 +278,7 @@ note: if you're trying to build a new `Box<_, _>` consider using one of the foll
       Box::<T>::new_uninit
       Box::<T>::new_zeroed
       Box::<T>::try_new
+      and 27 others
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
 error: aborting due to 30 previous errors
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr b/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
index 55d52d35f4a8..dce4acfc4ca7 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
+++ b/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
@@ -104,9 +104,10 @@ note: if you're trying to build a new `Box<_, _>` consider using one of the foll
       Box::<T>::new_uninit
       Box::<T>::new_zeroed
       Box::<T>::try_new
+      and 27 others
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
 error: aborting due to 11 previous errors
 
 Some errors have detailed explanations: E0121, E0224, E0261, E0599.
-For more information about an error, try `rustc --explain E0121`.
\ No newline at end of file
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/parallel-rustc/unexpected-type-issue-120601.stderr b/tests/ui/parallel-rustc/unexpected-type-issue-120601.stderr
index da225ad82bc7..70471719a70d 100644
--- a/tests/ui/parallel-rustc/unexpected-type-issue-120601.stderr
+++ b/tests/ui/parallel-rustc/unexpected-type-issue-120601.stderr
@@ -1,4 +1,5 @@
 error[E0670]: `async fn` is not permitted in Rust 2015
+  --> $DIR/unexpected-type-issue-120601.rs:10:1
    |
 LL | async fn foo() -> Result<(), ()> {
    | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -7,6 +8,7 @@ LL | async fn foo() -> Result<(), ()> {
    = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
 error[E0670]: `async fn` is not permitted in Rust 2015
+  --> $DIR/unexpected-type-issue-120601.rs:16:1
    |
 LL | async fn tuple() -> Tuple {
    | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -15,6 +17,7 @@ LL | async fn tuple() -> Tuple {
    = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
 error[E0670]: `async fn` is not permitted in Rust 2015
+  --> $DIR/unexpected-type-issue-120601.rs:21:1
    |
 LL | async fn match_() {
    | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -22,12 +25,8 @@ LL | async fn match_() {
    = help: pass `--edition 2024` to `rustc`
    = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
-error[E0425]: cannot find function, tuple struct or tuple variant `Unstable2` in this scope
-   |
-LL |     Unstable2(())
-   |     ^^^^^^^^^ not found in this scope
-
 error[E0308]: mismatched types
+  --> $DIR/unexpected-type-issue-120601.rs:23:9
    |
 LL |     match tuple() {
    |           ------- this expression has type `impl Future<Output = Tuple>`
@@ -41,7 +40,13 @@ help: consider `await`ing on the `Future`
 LL |     match tuple().await {
    |                  ++++++
 
+error[E0425]: cannot find function, tuple struct or tuple variant `Unstable2` in this scope
+  --> $DIR/unexpected-type-issue-120601.rs:11:5
+   |
+LL |     Unstable2(())
+   |     ^^^^^^^^^ not found in this scope
+
 error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0308, E0425, E0670.
-For more information about an error, try `rustc --explain E0308`.
\ No newline at end of file
+For more information about an error, try `rustc --explain E0308`.

From 52dfa94cdcd3ed16f31c6afbf406826e2c5688dd Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 10 Mar 2026 18:18:55 -0700
Subject: [PATCH 0398/1059] Update the minimum external LLVM to 21

---
 compiler/rustc_codegen_llvm/src/abi.rs        | 27 ++++----
 compiler/rustc_codegen_llvm/src/attributes.rs | 14 ++--
 compiler/rustc_codegen_llvm/src/context.rs    | 16 -----
 compiler/rustc_codegen_llvm/src/errors.rs     |  4 --
 compiler/rustc_codegen_llvm/src/llvm_util.rs  | 20 ------
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   | 29 +-------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 10 ---
 src/bootstrap/src/core/build_steps/llvm.rs    |  4 +-
 src/ci/docker/README.md                       |  8 +--
 .../Dockerfile                                |  6 +-
 .../host-x86_64/x86_64-gnu-llvm-20/Dockerfile | 66 -------------------
 src/ci/github-actions/jobs.yml                | 35 ++--------
 tests/assembly-llvm/aarch64-pointer-auth.rs   |  1 -
 tests/assembly-llvm/asm/s390x-types.rs        |  1 -
 tests/assembly-llvm/nvptx-safe-naming.rs      |  6 +-
 .../sanitizer/kcfi/emit-arity-indicator.rs    |  1 -
 .../assembly-llvm/x86_64-windows-float-abi.rs |  3 +-
 tests/codegen-llvm/cffi/c-variadic-va_list.rs |  1 -
 tests/codegen-llvm/cffi/c-variadic.rs         |  1 -
 tests/codegen-llvm/dead_on_return.rs          |  1 -
 tests/codegen-llvm/deduced-param-attrs.rs     | 24 +++----
 .../codegen-llvm/enum/enum-discriminant-eq.rs | 44 ++++---------
 tests/codegen-llvm/issues/issue-101082.rs     |  1 -
 .../issues/issue-122734-match-eq.rs           |  1 -
 ...e-138497-nonzero-remove-trailing-zeroes.rs |  1 -
 .../issues/saturating-sub-index-139759.rs     |  1 -
 .../lib-optimizations/append-elements.rs      |  1 -
 tests/codegen-llvm/option-niche-eq.rs         | 10 ++-
 tests/codegen-llvm/read-only-capture-opt.rs   |  1 -
 .../riscv-abi/call-llvm-intrinsics.rs         |  1 -
 .../sanitizer/kcfi/add-kcfi-arity-flag.rs     |  1 -
 tests/codegen-llvm/slice-range-indexing.rs    |  1 -
 tests/codegen-llvm/str-range-indexing.rs      |  1 -
 tests/codegen-llvm/vec-calloc.rs              | 21 +++---
 tests/run-make/repr128-dwarf/main.rs          |  8 +--
 tests/run-make/repr128-dwarf/rmake.rs         | 21 +-----
 .../kcfi-arity-requires-llvm-21-0-0.rs        | 11 ----
 .../kcfi-arity-requires-llvm-21-0-0.stderr    |  4 --
 38 files changed, 68 insertions(+), 339 deletions(-)
 rename src/ci/docker/host-aarch64/{aarch64-gnu-llvm-20 => aarch64-gnu-llvm-21}/Dockerfile (94%)
 delete mode 100644 src/ci/docker/host-x86_64/x86_64-gnu-llvm-20/Dockerfile
 delete mode 100644 tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.rs
 delete mode 100644 tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.stderr

diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 994077251acc..a6e841e440a2 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -23,7 +23,6 @@
 use crate::builder::Builder;
 use crate::context::CodegenCx;
 use crate::llvm::{self, Attribute, AttributePlace, Type, Value};
-use crate::llvm_util;
 use crate::type_of::LayoutLlvmExt;
 
 trait ArgAttributesExt {
@@ -46,6 +45,12 @@ fn apply_attrs_to_callsite(
     (ArgAttribute::NoUndef, llvm::AttributeKind::NoUndef),
 ];
 
+const CAPTURES_ATTRIBUTES: [(ArgAttribute, llvm::AttributeKind); 3] = [
+    (ArgAttribute::CapturesNone, llvm::AttributeKind::CapturesNone),
+    (ArgAttribute::CapturesAddress, llvm::AttributeKind::CapturesAddress),
+    (ArgAttribute::CapturesReadOnly, llvm::AttributeKind::CapturesReadOnly),
+];
+
 fn get_attrs<'ll>(this: &ArgAttributes, cx: &CodegenCx<'ll, '_>) -> SmallVec<[&'ll Attribute; 8]> {
     let mut regular = this.regular;
 
@@ -82,18 +87,10 @@ fn apply_attrs_to_callsite(
                 attrs.push(llattr.create_attr(cx.llcx));
             }
         }
-        // captures(...) is only available since LLVM 21.
-        if (21, 0, 0) <= llvm_util::get_version() {
-            const CAPTURES_ATTRIBUTES: [(ArgAttribute, llvm::AttributeKind); 3] = [
-                (ArgAttribute::CapturesNone, llvm::AttributeKind::CapturesNone),
-                (ArgAttribute::CapturesAddress, llvm::AttributeKind::CapturesAddress),
-                (ArgAttribute::CapturesReadOnly, llvm::AttributeKind::CapturesReadOnly),
-            ];
-            for (attr, llattr) in CAPTURES_ATTRIBUTES {
-                if regular.contains(attr) {
-                    attrs.push(llattr.create_attr(cx.llcx));
-                    break;
-                }
+        for (attr, llattr) in CAPTURES_ATTRIBUTES {
+            if regular.contains(attr) {
+                attrs.push(llattr.create_attr(cx.llcx));
+                break;
             }
         }
     } else if cx.tcx.sess.sanitizers().contains(SanitizerSet::MEMORY) {
@@ -508,9 +505,7 @@ fn apply_attrs_llfn(
                 }
                 PassMode::Indirect { attrs, meta_attrs: None, on_stack: false } => {
                     let i = apply(attrs);
-                    if cx.sess().opts.optimize != config::OptLevel::No
-                        && llvm_util::get_version() >= (21, 0, 0)
-                    {
+                    if cx.sess().opts.optimize != config::OptLevel::No {
                         attributes::apply_to_llfn(
                             llfn,
                             llvm::AttributePlace::Argument(i),
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 546fa87ff561..d51adb6e13b0 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -506,15 +506,11 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         to_add.push(llvm::CreateAllocKindAttr(cx.llcx, AllocKindFlags::Free));
         // applies to argument place instead of function place
         let allocated_pointer = AttributeKind::AllocatedPointer.create_attr(cx.llcx);
-        let attrs: &[_] = if llvm_util::get_version() >= (21, 0, 0) {
-            // "Does not capture provenance" means "if the function call stashes the pointer somewhere,
-            // accessing that pointer after the function returns is UB". That is definitely the case here since
-            // freeing will destroy the provenance.
-            let captures_addr = AttributeKind::CapturesAddress.create_attr(cx.llcx);
-            &[allocated_pointer, captures_addr]
-        } else {
-            &[allocated_pointer]
-        };
+        // "Does not capture provenance" means "if the function call stashes the pointer somewhere,
+        // accessing that pointer after the function returns is UB". That is definitely the case here since
+        // freeing will destroy the provenance.
+        let captures_addr = AttributeKind::CapturesAddress.create_attr(cx.llcx);
+        let attrs = &[allocated_pointer, captures_addr];
         attributes::apply_to_llfn(llfn, AttributePlace::Argument(0), attrs);
     }
     if let Some(align) = codegen_fn_attrs.alignment {
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 545a9add911d..cc4c5e2c9291 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -190,17 +190,6 @@ pub(crate) unsafe fn create_module<'ll>(
     let mut target_data_layout = sess.target.data_layout.to_string();
     let llvm_version = llvm_util::get_version();
 
-    if llvm_version < (21, 0, 0) {
-        if sess.target.arch == Arch::Nvptx64 {
-            // LLVM 21 updated the default layout on nvptx: https://github.com/llvm/llvm-project/pull/124961
-            target_data_layout = target_data_layout.replace("e-p6:32:32-i64", "e-i64");
-        }
-        if sess.target.arch == Arch::AmdGpu {
-            // LLVM 21 adds the address width for address space 8.
-            // See https://github.com/llvm/llvm-project/pull/139419
-            target_data_layout = target_data_layout.replace("p8:128:128:128:48", "p8:128:128")
-        }
-    }
     if llvm_version < (22, 0, 0) {
         if sess.target.arch == Arch::Avr {
             // LLVM 22.0 updated the default layout on avr: https://github.com/llvm/llvm-project/pull/153010
@@ -342,11 +331,6 @@ pub(crate) unsafe fn create_module<'ll>(
         // Add "kcfi-arity" module flag if KCFI arity indicator is enabled. (See
         // https://github.com/llvm/llvm-project/pull/117121.)
         if sess.is_sanitizer_kcfi_arity_enabled() {
-            // KCFI arity indicator requires LLVM 21.0.0 or later.
-            if llvm_version < (21, 0, 0) {
-                tcx.dcx().emit_err(crate::errors::SanitizerKcfiArityRequiresLLVM2100);
-            }
-
             llvm::add_module_flag_u32(
                 llmod,
                 llvm::ModuleFlagMergeBehavior::Override,
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index a7b5bdbf7bdf..9fb406516f66 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -204,7 +204,3 @@ pub(crate) struct MismatchedDataLayout<'a> {
 pub(crate) struct FixedX18InvalidArch<'a> {
     pub arch: &'a str,
 }
-
-#[derive(Diagnostic)]
-#[diag("`-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later")]
-pub(crate) struct SanitizerKcfiArityRequiresLLVM2100;
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 85b515f2ef9c..2423880ab869 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -254,10 +254,6 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         },
 
         // Filter out features that are not supported by the current LLVM version
-        Arch::LoongArch32 | Arch::LoongArch64 => match s {
-            "32s" if major < 21 => None,
-            s => Some(LLVMFeature::new(s)),
-        },
         Arch::PowerPC | Arch::PowerPC64 => match s {
             "power8-crypto" => Some(LLVMFeature::new("crypto")),
             s => Some(LLVMFeature::new(s)),
@@ -372,23 +368,12 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
     let (major, _, _) = version;
 
     cfg.has_reliable_f16 = match (target_arch, target_os) {
-        // LLVM crash without neon <https://github.com/llvm/llvm-project/issues/129394> (fixed in LLVM 20.1.1)
-        (Arch::AArch64, _)
-            if !cfg.target_features.iter().any(|f| f.as_str() == "neon")
-                && version < (20, 1, 1) =>
-        {
-            false
-        }
         // Unsupported <https://github.com/llvm/llvm-project/issues/94434> (fixed in llvm22)
         (Arch::Arm64EC, _) if major < 22 => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/50374> (fixed in llvm21)
-        (Arch::S390x, _) if major < 21 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
         (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
         // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
         (Arch::CSky, _) if major < 22 => false, // (fixed in llvm22)
-        (Arch::Hexagon, _) if major < 21 => false, // (fixed in llvm21)
-        (Arch::LoongArch32 | Arch::LoongArch64, _) if major < 21 => false, // (fixed in llvm21)
         (Arch::PowerPC | Arch::PowerPC64, _) if major < 22 => false, // (fixed in llvm22)
         (Arch::Sparc | Arch::Sparc64, _) if major < 22 => false, // (fixed in llvm22)
         (Arch::Wasm32 | Arch::Wasm64, _) if major < 22 => false, // (fixed in llvm22)
@@ -403,8 +388,6 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         (Arch::AmdGpu, _) => false,
         // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
         (Arch::Arm64EC, _) => false,
-        // Selection bug <https://github.com/llvm/llvm-project/issues/96432> (fixed in LLVM 20.1.0)
-        (Arch::Mips64 | Arch::Mips64r6, _) if version < (20, 1, 0) => false,
         // Selection bug <https://github.com/llvm/llvm-project/issues/95471>. This issue is closed
         // but basic math still does not work.
         (Arch::Nvptx64, _) => false,
@@ -413,9 +396,6 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         (Arch::PowerPC | Arch::PowerPC64, _) => false,
         // ABI unsupported  <https://github.com/llvm/llvm-project/issues/41838>
         (Arch::Sparc, _) => false,
-        // Stack alignment bug <https://github.com/llvm/llvm-project/issues/77401>. NB: tests may
-        // not fail if our compiler-builtins is linked. (fixed in llvm21)
-        (Arch::X86, _) if major < 21 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
         (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
         // There are no known problems on other platforms, so the only requirement is that symbols
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index a47179c14d27..00d03f023924 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -301,12 +301,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
   std::string Error;
   auto Trip = Triple(Triple::normalize(TripleStr));
-  const llvm::Target *TheTarget =
-#if LLVM_VERSION_GE(21, 0)
-      TargetRegistry::lookupTarget(Trip, Error);
-#else
-      TargetRegistry::lookupTarget(Trip.getTriple(), Error);
-#endif
+  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Trip, Error);
   if (TheTarget == nullptr) {
     LLVMRustSetLastError(Error.c_str());
     return nullptr;
@@ -367,13 +362,8 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
   Options.EmitStackSizeSection = EmitStackSizeSection;
 
-#if LLVM_VERSION_GE(21, 0)
   TargetMachine *TM = TheTarget->createTargetMachine(Trip, CPU, Feature,
                                                      Options, RM, CM, OptLevel);
-#else
-  TargetMachine *TM = TheTarget->createTargetMachine(
-      Trip.getTriple(), CPU, Feature, Options, RM, CM, OptLevel);
-#endif
 
   if (LargeDataThreshold != 0) {
     TM->setLargeDataThreshold(LargeDataThreshold);
@@ -701,12 +691,8 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   if (LintIR) {
     PipelineStartEPCallbacks.push_back([](ModulePassManager &MPM,
                                           OptimizationLevel Level) {
-#if LLVM_VERSION_GE(21, 0)
       MPM.addPass(
           createModuleToFunctionPassAdaptor(LintPass(/*AbortOnError=*/true)));
-#else
-      MPM.addPass(createModuleToFunctionPassAdaptor(LintPass()));
-#endif
     });
   }
 
@@ -1210,12 +1196,8 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules, size_t num_modules,
   // Convert the preserved symbols set from string to GUID, this is then needed
   // for internalization.
   for (size_t i = 0; i < num_symbols; i++) {
-#if LLVM_VERSION_GE(21, 0)
     auto GUID =
         GlobalValue::getGUIDAssumingExternalLinkage(preserved_symbols[i]);
-#else
-    auto GUID = GlobalValue::getGUID(preserved_symbols[i]);
-#endif
     Ret->GUIDPreservedSymbols.insert(GUID);
   }
 
@@ -1474,21 +1456,12 @@ extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
   DenseSet<GlobalValue::GUID> CfiFunctionDecls;
 
   // Based on the 'InProcessThinBackend' constructor in LLVM
-#if LLVM_VERSION_GE(21, 0)
   for (auto &Name : Data->Index.cfiFunctionDefs().symbols())
     CfiFunctionDefs.insert(GlobalValue::getGUIDAssumingExternalLinkage(
         GlobalValue::dropLLVMManglingEscape(Name)));
   for (auto &Name : Data->Index.cfiFunctionDecls().symbols())
     CfiFunctionDecls.insert(GlobalValue::getGUIDAssumingExternalLinkage(
         GlobalValue::dropLLVMManglingEscape(Name)));
-#else
-  for (auto &Name : Data->Index.cfiFunctionDefs())
-    CfiFunctionDefs.insert(
-        GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
-  for (auto &Name : Data->Index.cfiFunctionDecls())
-    CfiFunctionDecls.insert(
-        GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
-#endif
 
   Key = llvm::computeLTOCacheKey(conf, Data->Index, ModId, ImportList,
                                  ExportList, ResolvedODR, DefinedGlobals,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index eabc1c94f26e..16796541d4fd 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -137,11 +137,7 @@ extern "C" void LLVMRustSetLastError(const char *Err) {
 
 extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
                                             const char *Target) {
-#if LLVM_VERSION_GE(21, 0)
   unwrap(M)->setTargetTriple(Triple(Triple::normalize(Target)));
-#else
-  unwrap(M)->setTargetTriple(Triple::normalize(Target));
-#endif
 }
 
 extern "C" void LLVMRustPrintPassTimings(RustStringRef OutBuf) {
@@ -452,11 +448,7 @@ static Attribute::AttrKind fromRust(LLVMRustAttributeKind Kind) {
   case LLVMRustAttributeKind::DeadOnUnwind:
     return Attribute::DeadOnUnwind;
   case LLVMRustAttributeKind::DeadOnReturn:
-#if LLVM_VERSION_GE(21, 0)
     return Attribute::DeadOnReturn;
-#else
-    report_fatal_error("DeadOnReturn attribute requires LLVM 21 or later");
-#endif
   case LLVMRustAttributeKind::CapturesAddress:
   case LLVMRustAttributeKind::CapturesReadOnly:
   case LLVMRustAttributeKind::CapturesNone:
@@ -514,7 +506,6 @@ extern "C" void LLVMRustEraseInstFromParent(LLVMValueRef Instr) {
 
 extern "C" LLVMAttributeRef
 LLVMRustCreateAttrNoValue(LLVMContextRef C, LLVMRustAttributeKind RustAttr) {
-#if LLVM_VERSION_GE(21, 0)
   if (RustAttr == LLVMRustAttributeKind::CapturesNone) {
     return wrap(Attribute::getWithCaptureInfo(*unwrap(C), CaptureInfo::none()));
   }
@@ -527,7 +518,6 @@ LLVMRustCreateAttrNoValue(LLVMContextRef C, LLVMRustAttributeKind RustAttr) {
         *unwrap(C), CaptureInfo(CaptureComponents::Address |
                                 CaptureComponents::ReadProvenance)));
   }
-#endif
 #if LLVM_VERSION_GE(23, 0)
   if (RustAttr == LLVMRustAttributeKind::DeadOnReturn) {
     return wrap(Attribute::getWithDeadOnReturnInfo(*unwrap(C),
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index b0f8cdd28e82..a6cb6a430882 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -631,11 +631,11 @@ fn check_llvm_version(builder: &Builder<'_>, llvm_config: &Path) {
     let version = get_llvm_version(builder, llvm_config);
     let mut parts = version.split('.').take(2).filter_map(|s| s.parse::<u32>().ok());
     if let (Some(major), Some(_minor)) = (parts.next(), parts.next())
-        && major >= 20
+        && major >= 21
     {
         return;
     }
-    panic!("\n\nbad LLVM version: {version}, need >=20\n\n")
+    panic!("\n\nbad LLVM version: {version}, need >=21\n\n")
 }
 
 fn configure_cmake(
diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index b6d01528d8c3..6e5a38a3c515 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -14,9 +14,9 @@ To run a specific CI job locally, you can use the `citool` Rust crate:
 cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>
 ```
 
-For example, to run the `x86_64-gnu-llvm-20-1` job:
+For example, to run the `x86_64-gnu-llvm-21-1` job:
 ```
-cargo run --manifest-path src/ci/citool/Cargo.toml run-local x86_64-gnu-llvm-20-1
+cargo run --manifest-path src/ci/citool/Cargo.toml run-local x86_64-gnu-llvm-21-1
 ```
 
 The job will output artifacts in an `obj/<image-name>` dir at the root of a repository. Note
@@ -27,10 +27,10 @@ Docker image executed in the given CI job.
 while locally, to the `obj/<image-name>` directory. This is primarily to prevent
 strange linker errors when using multiple Docker images.
 
-For some Linux workflows (for example `x86_64-gnu-llvm-20-N`), the process is more involved. You will need to see which script is executed for the given workflow inside the [`jobs.yml`](../github-actions/jobs.yml) file and pass it through the `DOCKER_SCRIPT` environment variable. For example, to reproduce the `x86_64-gnu-llvm-20-3` workflow, you can run the following script:
+For some Linux workflows (for example `x86_64-gnu-llvm-21-N`), the process is more involved. You will need to see which script is executed for the given workflow inside the [`jobs.yml`](../github-actions/jobs.yml) file and pass it through the `DOCKER_SCRIPT` environment variable. For example, to reproduce the `x86_64-gnu-llvm-21-3` workflow, you can run the following script:
 
 ```
-DOCKER_SCRIPT=x86_64-gnu-llvm3.sh ./src/ci/docker/run.sh x86_64-gnu-llvm-20
+DOCKER_SCRIPT=x86_64-gnu-llvm3.sh ./src/ci/docker/run.sh x86_64-gnu-llvm-21
 ```
 
 ## Local Development
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-21/Dockerfile
similarity index 94%
rename from src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
rename to src/ci/docker/host-aarch64/aarch64-gnu-llvm-21/Dockerfile
index 5dbca7e7b675..c364ac27aaa5 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-21/Dockerfile
@@ -15,8 +15,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
   cmake \
   sudo \
   gdb \
-  llvm-20-tools \
-  llvm-20-dev \
+  llvm-21-tools \
+  llvm-21-dev \
   libedit-dev \
   libssl-dev \
   pkg-config \
@@ -42,7 +42,7 @@ ENV EXTERNAL_LLVM="1"
 
 # Using llvm-link-shared due to libffi issues -- see #34486
 ENV RUST_CONFIGURE_ARGS="--build=aarch64-unknown-linux-gnu \
-      --llvm-root=/usr/lib/llvm-20 \
+      --llvm-root=/usr/lib/llvm-21 \
       --enable-llvm-link-shared \
       --set rust.randomize-layout=true \
       --set rust.thin-lto-import-instr-limit=10"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-20/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-20/Dockerfile
deleted file mode 100644
index 92c2631000f9..000000000000
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-20/Dockerfile
+++ /dev/null
@@ -1,66 +0,0 @@
-FROM ubuntu:25.04
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-  bzip2 \
-  g++ \
-  gcc-multilib \
-  make \
-  ninja-build \
-  file \
-  curl \
-  ca-certificates \
-  python3 \
-  git \
-  cmake \
-  sudo \
-  gdb \
-  llvm-20-tools \
-  llvm-20-dev \
-  libedit-dev \
-  libssl-dev \
-  pkg-config \
-  zlib1g-dev \
-  xz-utils \
-  nodejs \
-  mingw-w64 \
-  # libgccjit dependencies
-  flex \
-  libmpfr-dev \
-  libgmp-dev \
-  libmpc3 \
-  libmpc-dev \
-  && rm -rf /var/lib/apt/lists/*
-
-# Install powershell (universal package) so we can test x.ps1 on Linux
-# FIXME: need a "universal" version that supports libicu74, but for now it still works to ignore that dep.
-RUN curl -sL "https://github.com/PowerShell/PowerShell/releases/download/v7.3.1/powershell_7.3.1-1.deb_amd64.deb" > powershell.deb && \
-    dpkg --ignore-depends=libicu72 -i powershell.deb && \
-    rm -f powershell.deb
-
-COPY scripts/sccache.sh /scripts/
-RUN sh /scripts/sccache.sh
-
-# We are disabling CI LLVM since this builder is intentionally using a host
-# LLVM, rather than the typical src/llvm-project LLVM.
-ENV NO_DOWNLOAD_CI_LLVM 1
-ENV EXTERNAL_LLVM 1
-
-# Using llvm-link-shared due to libffi issues -- see #34486
-ENV RUST_CONFIGURE_ARGS \
-      --build=x86_64-unknown-linux-gnu \
-      --llvm-root=/usr/lib/llvm-20 \
-      --enable-llvm-link-shared \
-      --set rust.randomize-layout=true \
-      --set rust.thin-lto-import-instr-limit=10
-
-COPY scripts/shared.sh /scripts/
-
-COPY scripts/x86_64-gnu-llvm.sh /scripts/
-COPY scripts/x86_64-gnu-llvm2.sh /scripts/
-COPY scripts/x86_64-gnu-llvm3.sh /scripts/
-COPY scripts/stage_2_test_set1.sh /scripts/
-COPY scripts/stage_2_test_set2.sh /scripts/
-
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 563083cd450b..a70e4acf94a3 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -122,19 +122,19 @@ pr:
       # tidy. This speeds up the PR CI job by ~1 minute.
       SKIP_SUBMODULES: src/gcc
     <<: *job-linux-4c
-  - name: x86_64-gnu-llvm-20
+  - name: x86_64-gnu-llvm-21
     env:
       ENABLE_GCC_CODEGEN: "1"
       DOCKER_SCRIPT: x86_64-gnu-llvm.sh
     <<: *job-linux-4c
-  - name: aarch64-gnu-llvm-20-1
+  - name: aarch64-gnu-llvm-21-1
     env:
-      IMAGE: aarch64-gnu-llvm-20
+      IMAGE: aarch64-gnu-llvm-21
       DOCKER_SCRIPT: stage_2_test_set1.sh
     <<: *job-aarch64-linux
-  - name: aarch64-gnu-llvm-20-2
+  - name: aarch64-gnu-llvm-21-2
     env:
-      IMAGE: aarch64-gnu-llvm-20
+      IMAGE: aarch64-gnu-llvm-21
       DOCKER_SCRIPT: stage_2_test_set2.sh
     <<: *job-aarch64-linux
   - name: x86_64-gnu-tools
@@ -381,31 +381,6 @@ auto:
   - name: x86_64-gnu-distcheck
     <<: *job-linux-4c
 
-  # The x86_64-gnu-llvm-20 job is split into multiple jobs to run tests in parallel.
-  # x86_64-gnu-llvm-20-1 skips tests that run in x86_64-gnu-llvm-20-{2,3}.
-  - name: x86_64-gnu-llvm-20-1
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-20
-      DOCKER_SCRIPT: stage_2_test_set2.sh
-    <<: *job-linux-4c
-
-  # Skip tests that run in x86_64-gnu-llvm-20-{1,3}
-  - name: x86_64-gnu-llvm-20-2
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-20
-      DOCKER_SCRIPT: x86_64-gnu-llvm2.sh
-    <<: *job-linux-4c
-
-  # Skip tests that run in x86_64-gnu-llvm-20-{1,2}
-  - name: x86_64-gnu-llvm-20-3
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-20
-      DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
-    <<: *job-linux-4c
-
   # The x86_64-gnu-llvm-21 job is split into multiple jobs to run tests in parallel.
   # x86_64-gnu-llvm-21-1 skips tests that run in x86_64-gnu-llvm-21-{2,3}.
   - name: x86_64-gnu-llvm-21-1
diff --git a/tests/assembly-llvm/aarch64-pointer-auth.rs b/tests/assembly-llvm/aarch64-pointer-auth.rs
index cf255d6aa639..2406e8ccb5dc 100644
--- a/tests/assembly-llvm/aarch64-pointer-auth.rs
+++ b/tests/assembly-llvm/aarch64-pointer-auth.rs
@@ -5,7 +5,6 @@
 //@ assembly-output: emit-asm
 //@ needs-llvm-components: aarch64
 //@ compile-flags: --target aarch64-unknown-linux-gnu
-//@ [GCS] min-llvm-version: 21
 //@ [GCS] ignore-apple (XCode version needs updating)
 //@ [GCS] compile-flags: -Z branch-protection=gcs
 //@ [PACRET] compile-flags: -Z branch-protection=pac-ret,leaf
diff --git a/tests/assembly-llvm/asm/s390x-types.rs b/tests/assembly-llvm/asm/s390x-types.rs
index 10e2966ace0a..dee7eb553cde 100644
--- a/tests/assembly-llvm/asm/s390x-types.rs
+++ b/tests/assembly-llvm/asm/s390x-types.rs
@@ -6,7 +6,6 @@
 //@[s390x_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-feature=+vector
 //@[s390x_vector] needs-llvm-components: systemz
 //@ compile-flags: -Zmerge-functions=disabled
-//@ min-llvm-version: 21
 
 #![feature(no_core, repr_simd, f16, f128)]
 #![cfg_attr(s390x_vector, feature(asm_experimental_reg))]
diff --git a/tests/assembly-llvm/nvptx-safe-naming.rs b/tests/assembly-llvm/nvptx-safe-naming.rs
index 85415b6ca5b5..050c3fb9d93b 100644
--- a/tests/assembly-llvm/nvptx-safe-naming.rs
+++ b/tests/assembly-llvm/nvptx-safe-naming.rs
@@ -1,9 +1,6 @@
 //@ assembly-output: ptx-linker
 //@ compile-flags: --crate-type cdylib
 //@ only-nvptx64
-//@ revisions: LLVM20 LLVM21
-//@ [LLVM21] min-llvm-version: 21
-//@ [LLVM20] max-llvm-major-version: 20
 
 #![feature(abi_ptx)]
 #![no_std]
@@ -18,8 +15,7 @@
 #[no_mangle]
 pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
     // CHECK:      call.uni (retval0),
-    // LLVM20-NEXT: [[IMPL_FN]]
-    // LLVM21-SAME: [[IMPL_FN]]
+    // CHECK-SAME: [[IMPL_FN]]
     *b = deep::private::MyStruct::new(*a).square();
 }
 
diff --git a/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs b/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
index 63fe7e2bd536..ba9cabd6cef7 100644
--- a/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
+++ b/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
@@ -5,7 +5,6 @@
 //@ assembly-output: emit-asm
 //@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu -Cllvm-args=-x86-asm-syntax=intel -Ctarget-feature=-crt-static -Cpanic=abort -Zsanitizer=kcfi -Zsanitizer-kcfi-arity -Copt-level=0
 //@ [x86_64] needs-llvm-components: x86
-//@ min-llvm-version: 21.0.0
 
 #![crate_type = "lib"]
 #![feature(no_core)]
diff --git a/tests/assembly-llvm/x86_64-windows-float-abi.rs b/tests/assembly-llvm/x86_64-windows-float-abi.rs
index 8f5cc1e94486..51daff56789e 100644
--- a/tests/assembly-llvm/x86_64-windows-float-abi.rs
+++ b/tests/assembly-llvm/x86_64-windows-float-abi.rs
@@ -37,8 +37,7 @@ pub extern "C" fn second_f64(_: f64, x: f64) -> f64 {
 }
 
 // CHECK-LABEL: second_f128
-// FIXME(llvm21): this can be just %rdx instead of the regex once we don't test on LLVM 20
-// CHECK: movaps {{(%xmm1|\(%rdx\))}}, %xmm0
+// CHECK: movaps (%rdx), %xmm0
 // CHECK-NEXT: retq
 #[no_mangle]
 pub extern "C" fn second_f128(_: f128, x: f128) -> f128 {
diff --git a/tests/codegen-llvm/cffi/c-variadic-va_list.rs b/tests/codegen-llvm/cffi/c-variadic-va_list.rs
index b2f5ffc3495b..0b3cda677ce2 100644
--- a/tests/codegen-llvm/cffi/c-variadic-va_list.rs
+++ b/tests/codegen-llvm/cffi/c-variadic-va_list.rs
@@ -1,6 +1,5 @@
 //@ needs-unwind
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 #![feature(c_variadic)]
diff --git a/tests/codegen-llvm/cffi/c-variadic.rs b/tests/codegen-llvm/cffi/c-variadic.rs
index 7a2e2ba5047e..5df256961de5 100644
--- a/tests/codegen-llvm/cffi/c-variadic.rs
+++ b/tests/codegen-llvm/cffi/c-variadic.rs
@@ -1,6 +1,5 @@
 //@ needs-unwind
 //@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 #![feature(c_variadic)]
diff --git a/tests/codegen-llvm/dead_on_return.rs b/tests/codegen-llvm/dead_on_return.rs
index 3c1940d6ba7c..79f936550e89 100644
--- a/tests/codegen-llvm/dead_on_return.rs
+++ b/tests/codegen-llvm/dead_on_return.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -C opt-level=3
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 #![allow(unused_assignments, unused_variables)]
diff --git a/tests/codegen-llvm/deduced-param-attrs.rs b/tests/codegen-llvm/deduced-param-attrs.rs
index b24c74a2f840..6a5e79ae460c 100644
--- a/tests/codegen-llvm/deduced-param-attrs.rs
+++ b/tests/codegen-llvm/deduced-param-attrs.rs
@@ -1,8 +1,5 @@
 //@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
 //@ compile-flags: -Cpanic=abort -Csymbol-mangling-version=v0
-//@ revisions: LLVM21 LLVM20
-//@ [LLVM21] min-llvm-version: 21
-//@ [LLVM20] max-llvm-major-version: 20
 #![feature(custom_mir, core_intrinsics, unboxed_closures)]
 #![crate_type = "lib"]
 extern crate core;
@@ -37,15 +34,13 @@ pub fn mutate(mut b: Big) {
     black_box(&b);
 }
 
-// LLVM21-LABEL: @deref_mut({{.*}}readonly {{.*}}captures(none) {{.*}}%c)
-// LLVM20-LABEL: @deref_mut({{.*}}readonly                      {{.*}}%c)
+// CHECK-LABEL: @deref_mut({{.*}}readonly {{.*}}captures(none) {{.*}}%c)
 #[unsafe(no_mangle)]
 pub fn deref_mut(c: (BigCell, &mut usize)) {
     *c.1 = 42;
 }
 
-// LLVM21-LABEL: @call_copy_arg(ptr {{.*}}readonly {{.*}}captures(none){{.*}})
-// LLVM20-LABEL: @call_copy_arg(ptr {{.*}}readonly                     {{.*}})
+// CHECK-LABEL: @call_copy_arg(ptr {{.*}}readonly {{.*}}captures(none){{.*}})
 #[unsafe(no_mangle)]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub fn call_copy_arg(a: Big) {
@@ -61,7 +56,7 @@ pub fn call_copy_arg(a: Big) {
 
 // CHECK-LABEL: @call_move_arg(
 // CHECK-NOT:   readonly
-// LLVM21-SAME: captures(address)
+// CHECK-SAME:  captures(address)
 // CHECK-SAME:  )
 #[unsafe(no_mangle)]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
@@ -84,8 +79,7 @@ fn shared_borrow<T>(a: T) {
 //
 // CHECK-LABEL: ; deduced_param_attrs::shared_borrow::<deduced_param_attrs::Big>
 // CHECK-NEXT:  ;
-// LLVM21-NEXT: (ptr {{.*}}readonly {{.*}}captures(address) {{.*}}%a)
-// LLVM20-NEXT: (ptr {{.*}}readonly                         {{.*}}%a)
+// CHECK-NEXT:  (ptr {{.*}}readonly {{.*}}captures(address) {{.*}}%a)
 pub static A0: fn(Big) = shared_borrow;
 
 // !Freeze parameter can be mutated through a shared borrow.
@@ -113,16 +107,14 @@ fn consume<T>(_: T) {}
 //
 // CHECK-LABEL: ; deduced_param_attrs::consume::<deduced_param_attrs::BigCell>
 // CHECK-NEXT:  ;
-// LLVM21-NEXT: (ptr {{.*}}readonly {{.*}}captures(none) {{.*}})
-// LLVM20-NEXT: (ptr {{.*}}readonly                      {{.*}})
+// CHECK-NEXT:  (ptr {{.*}}readonly {{.*}}captures(none) {{.*}})
 pub static B0: fn(BigCell) = consume;
 
 // The parameter needs to be dropped.
 //
 // CHECK-LABEL: ; deduced_param_attrs::consume::<deduced_param_attrs::BigDrop>
 // CHECK-NEXT:  ;
-// LLVM21-NEXT: (ptr {{.*}}captures(address) {{.*}})
-// LLVM20-NEXT: (ptr                         {{.*}})
+// CHECK-NEXT:  (ptr {{.*}}captures(address) {{.*}})
 pub static B1: fn(BigDrop) = consume;
 
 fn consume_parts<T>(t: (T, T)) {
@@ -160,13 +152,13 @@ pub fn manually_drop_field(a: fn() -> BigDrop, mut b: ManuallyDrop<BigDrop>) {
     loop {}
 }
 
-// LLVM21-LABEL: @not_captured_return_place(ptr{{.*}} captures(none) {{.*}}%_0)
+// CHECK-LABEL: @not_captured_return_place(ptr{{.*}} captures(none) {{.*}}%_0)
 #[unsafe(no_mangle)]
 pub fn not_captured_return_place() -> [u8; 80] {
     [0u8; 80]
 }
 
-// LLVM21-LABEL: @captured_return_place(ptr{{.*}} captures(address) {{.*}}%_0)
+// CHECK-LABEL: @captured_return_place(ptr{{.*}} captures(address) {{.*}}%_0)
 #[unsafe(no_mangle)]
 pub fn captured_return_place() -> [u8; 80] {
     black_box([0u8; 80])
diff --git a/tests/codegen-llvm/enum/enum-discriminant-eq.rs b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
index 68cd58643e84..72fb7e00c902 100644
--- a/tests/codegen-llvm/enum/enum-discriminant-eq.rs
+++ b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
@@ -1,8 +1,5 @@
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
 //@ only-64bit
-//@ revisions: LLVM20 LLVM21
-//@ [LLVM21] min-llvm-version: 21
-//@ [LLVM20] max-llvm-major-version: 20
 
 // The `derive(PartialEq)` on enums with field-less variants compares discriminants,
 // so make sure we emit that in some reasonable way.
@@ -92,21 +89,16 @@ pub fn mid_bool_eq_discr(a: Mid<bool>, b: Mid<bool>) -> bool {
 
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, 3
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // LLVM20: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
     // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i8 %a, 1
-    // LLVM20: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, 3
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // LLVM20: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
     // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i8 %b, 1
-    // LLVM20: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
 
-    // LLVM21: %[[A_MOD_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 3
-    // LLVM21: %[[B_MOD_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 3
+    // CHECK: %[[A_MOD_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 3
+    // CHECK: %[[B_MOD_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 3
 
-    // LLVM20: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
-    // LLVM21: %[[R:.+]] = icmp eq i8 %[[A_MOD_DISCR]], %[[B_MOD_DISCR]]
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_MOD_DISCR]], %[[B_MOD_DISCR]]
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == discriminant_value(&b)
 }
@@ -117,21 +109,16 @@ pub fn mid_ord_eq_discr(a: Mid<Ordering>, b: Mid<Ordering>) -> bool {
 
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, 3
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // LLVM20: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
     // CHECK: %[[A_IS_NICHE:.+]] = icmp sgt i8 %a, 1
-    // LLVM20: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, 3
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // LLVM20: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
     // CHECK: %[[B_IS_NICHE:.+]] = icmp sgt i8 %b, 1
-    // LLVM20: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
 
-    // LLVM21: %[[A_MOD_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 3
-    // LLVM21: %[[B_MOD_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 3
+    // CHECK: %[[A_MOD_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 3
+    // CHECK: %[[B_MOD_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 3
 
-    // LLVM20: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
-    // LLVM21: %[[R:.+]] = icmp eq i8 %[[A_MOD_DISCR]], %[[B_MOD_DISCR]]
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_MOD_DISCR]], %[[B_MOD_DISCR]]
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == discriminant_value(&b)
 }
@@ -150,18 +137,14 @@ pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
 
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, -127
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // LLVM20: %[[A_REL_DISCR:.+]] = xor i8 %a, -128
     // CHECK: %[[A_IS_NICHE:.+]] = icmp slt i8 %a, 0
-    // LLVM20: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, -127
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // LLVM20: %[[B_REL_DISCR:.+]] = xor i8 %b, -128
     // CHECK: %[[B_IS_NICHE:.+]] = icmp slt i8 %b, 0
-    // LLVM20: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
 
-    // LLVM21: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 -127
-    // LLVM21: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 -127
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %a, i8 -127
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %b, i8 -127
 
     // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
     // CHECK: ret i1 %[[R]]
@@ -177,22 +160,17 @@ pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i128 %a, 6
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
     // CHECK: %[[A_TRUNC:.+]] = trunc nuw nsw i128 %a to i64
-    // LLVM20: %[[A_REL_DISCR:.+]] = add nsw i64 %[[A_TRUNC]], -5
     // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i128 %a, 4
-    // LLVM20: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_REL_DISCR]], i64 1
 
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i128 %b, 6
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
     // CHECK: %[[B_TRUNC:.+]] = trunc nuw nsw i128 %b to i64
-    // LLVM20: %[[B_REL_DISCR:.+]] = add nsw i64 %[[B_TRUNC]], -5
     // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i128 %b, 4
-    // LLVM20: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_REL_DISCR]], i64 1
 
-    // LLVM21: %[[A_MODIFIED_TAG:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_TRUNC]], i64 6
-    // LLVM21: %[[B_MODIFIED_TAG:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_TRUNC]], i64 6
-    // LLVM21: %[[R:.+]] = icmp eq i64 %[[A_MODIFIED_TAG]], %[[B_MODIFIED_TAG]]
+    // CHECK: %[[A_MODIFIED_TAG:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_TRUNC]], i64 6
+    // CHECK: %[[B_MODIFIED_TAG:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_TRUNC]], i64 6
+    // CHECK: %[[R:.+]] = icmp eq i64 %[[A_MODIFIED_TAG]], %[[B_MODIFIED_TAG]]
 
-    // LLVM20: %[[R:.+]] = icmp eq i64 %[[A_DISCR]], %[[B_DISCR]]
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == discriminant_value(&b)
 }
diff --git a/tests/codegen-llvm/issues/issue-101082.rs b/tests/codegen-llvm/issues/issue-101082.rs
index 0c1f90f951a7..403fc9a55846 100644
--- a/tests/codegen-llvm/issues/issue-101082.rs
+++ b/tests/codegen-llvm/issues/issue-101082.rs
@@ -11,7 +11,6 @@
 // at the time still sometimes fails, so only verify it for the power-of-two size
 // - https://github.com/llvm/llvm-project/issues/134735
 //@[x86-64-v3] only-x86_64
-//@[x86-64-v3] min-llvm-version: 21
 //@[x86-64-v3] compile-flags: -Ctarget-cpu=x86-64-v3
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/issues/issue-122734-match-eq.rs b/tests/codegen-llvm/issues/issue-122734-match-eq.rs
index 89858972677f..643c2f959e3c 100644
--- a/tests/codegen-llvm/issues/issue-122734-match-eq.rs
+++ b/tests/codegen-llvm/issues/issue-122734-match-eq.rs
@@ -1,4 +1,3 @@
-//@ min-llvm-version: 21
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
 //! Tests that matching + eq on `Option<FieldlessEnum>` produces a simple compare with no branching
 
diff --git a/tests/codegen-llvm/issues/issue-138497-nonzero-remove-trailing-zeroes.rs b/tests/codegen-llvm/issues/issue-138497-nonzero-remove-trailing-zeroes.rs
index 77cdbaf2bfe5..bd2c42ad2bdf 100644
--- a/tests/codegen-llvm/issues/issue-138497-nonzero-remove-trailing-zeroes.rs
+++ b/tests/codegen-llvm/issues/issue-138497-nonzero-remove-trailing-zeroes.rs
@@ -1,7 +1,6 @@
 //! This test checks that removing trailing zeroes from a `NonZero`,
 //! then creating a new `NonZero` from the result does not panic.
 
-//@ min-llvm-version: 21
 //@ compile-flags: -O -Zmerge-functions=disabled
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/issues/saturating-sub-index-139759.rs b/tests/codegen-llvm/issues/saturating-sub-index-139759.rs
index eac2f4d306b9..8c2a4ce9ecb3 100644
--- a/tests/codegen-llvm/issues/saturating-sub-index-139759.rs
+++ b/tests/codegen-llvm/issues/saturating-sub-index-139759.rs
@@ -2,7 +2,6 @@
 // index doesn't generate another bounds check.
 
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/lib-optimizations/append-elements.rs b/tests/codegen-llvm/lib-optimizations/append-elements.rs
index 5d7d746dbb6c..47211e3f388a 100644
--- a/tests/codegen-llvm/lib-optimizations/append-elements.rs
+++ b/tests/codegen-llvm/lib-optimizations/append-elements.rs
@@ -1,6 +1,5 @@
 //@ compile-flags: -O -Zmerge-functions=disabled
 //@ needs-deterministic-layouts
-//@ min-llvm-version: 21
 //@ ignore-std-debug-assertions (causes different value naming)
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/option-niche-eq.rs b/tests/codegen-llvm/option-niche-eq.rs
index e9c3fa2407e7..377a5fb19487 100644
--- a/tests/codegen-llvm/option-niche-eq.rs
+++ b/tests/codegen-llvm/option-niche-eq.rs
@@ -1,6 +1,4 @@
-//@ revisions: REGULAR LLVM21
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ [LLVM21] min-llvm-version: 21
 #![crate_type = "lib"]
 
 extern crate core;
@@ -76,11 +74,11 @@ pub fn niche_eq(l: Option<EnumWithNiche>, r: Option<EnumWithNiche>) -> bool {
     l == r
 }
 
-// LLVM21-LABEL: @bool_eq
+// CHECK-LABEL: @bool_eq
 #[no_mangle]
 pub fn bool_eq(l: Option<bool>, r: Option<bool>) -> bool {
-    // LLVM21: start:
-    // LLVM21-NEXT: icmp eq i8
-    // LLVM21-NEXT: ret i1
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i8
+    // CHECK-NEXT: ret i1
     l == r
 }
diff --git a/tests/codegen-llvm/read-only-capture-opt.rs b/tests/codegen-llvm/read-only-capture-opt.rs
index 78d56f8efc23..b2680fb103f6 100644
--- a/tests/codegen-llvm/read-only-capture-opt.rs
+++ b/tests/codegen-llvm/read-only-capture-opt.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -C opt-level=3 -Z mir-opt-level=0
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs b/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
index fb520d38df3c..c384eeae39fb 100644
--- a/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
+++ b/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
@@ -5,7 +5,6 @@
 //@ [riscv32gc] needs-llvm-components: riscv
 //@ [riscv64gc] compile-flags: --target riscv64gc-unknown-linux-gnu
 //@ [riscv64gc] needs-llvm-components: riscv
-//@ min-llvm-version: 21
 
 #![feature(link_llvm_intrinsics)]
 #![feature(no_core, lang_items)]
diff --git a/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
index a8e3b034eae7..7a0e3b1da250 100644
--- a/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
+++ b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
@@ -5,7 +5,6 @@
 //@ [x86_64] compile-flags: --target x86_64-unknown-none
 //@ [x86_64] needs-llvm-components: x86
 //@ compile-flags: -Ctarget-feature=-crt-static -Cpanic=abort -Zsanitizer=kcfi -Zsanitizer-kcfi-arity
-//@ min-llvm-version: 21.0.0
 
 #![feature(no_core, lang_items)]
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/slice-range-indexing.rs b/tests/codegen-llvm/slice-range-indexing.rs
index c4b3492dc4dc..de28fa284f45 100644
--- a/tests/codegen-llvm/slice-range-indexing.rs
+++ b/tests/codegen-llvm/slice-range-indexing.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/str-range-indexing.rs b/tests/codegen-llvm/str-range-indexing.rs
index dee1a3a41c46..5fa8e0dd17d3 100644
--- a/tests/codegen-llvm/str-range-indexing.rs
+++ b/tests/codegen-llvm/str-range-indexing.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 21
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/vec-calloc.rs b/tests/codegen-llvm/vec-calloc.rs
index 4e893cc736c9..020359017415 100644
--- a/tests/codegen-llvm/vec-calloc.rs
+++ b/tests/codegen-llvm/vec-calloc.rs
@@ -1,6 +1,4 @@
-//@ revisions: normal llvm21
 //@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@ [llvm21] min-llvm-version: 21
 //@ only-x86_64
 
 #![crate_type = "lib"]
@@ -178,21 +176,20 @@ pub fn vec_option_i32(n: usize) -> Vec<Option<i32>> {
     vec![None; n]
 }
 
-// LLVM21-LABEL: @vec_array
-#[cfg(llvm21)]
+// CHECK-LABEL: @vec_array
 #[no_mangle]
 pub fn vec_array(n: usize) -> Vec<[u32; 1_000_000]> {
-    // LLVM21-NOT: call {{.*}}alloc::vec::from_elem
-    // LLVM21-NOT: call {{.*}}reserve
-    // LLVM21-NOT: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
 
-    // LLVM21: call {{.*}}__rust_alloc_zeroed(
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
 
-    // LLVM21-NOT: call {{.*}}alloc::vec::from_elem
-    // LLVM21-NOT: call {{.*}}reserve
-    // LLVM21-NOT: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
 
-    // LLVM21: ret void
+    // CHECK: ret void
     vec![[0; 1_000_000]; 3]
 }
 
diff --git a/tests/run-make/repr128-dwarf/main.rs b/tests/run-make/repr128-dwarf/main.rs
index a8a414fd72e4..a50c950a0c40 100644
--- a/tests/run-make/repr128-dwarf/main.rs
+++ b/tests/run-make/repr128-dwarf/main.rs
@@ -17,7 +17,6 @@ pub enum I128Enum {
     I128D = i128::MAX.to_le(),
 }
 
-#[cfg(not(old_llvm))]
 #[repr(u128)]
 pub enum U128VariantEnum {
     VariantU128A(u8) = 0_u128.to_le(),
@@ -26,7 +25,6 @@ pub enum U128VariantEnum {
     VariantU128D = u128::MAX.to_le(),
 }
 
-#[cfg(not(old_llvm))]
 #[repr(i128)]
 pub enum I128VariantEnum {
     VariantI128A(u8) = 0_i128.to_le(),
@@ -37,13 +35,9 @@ pub enum I128VariantEnum {
 
 pub fn f(_: U128Enum, _: I128Enum) {}
 
-#[cfg(not(old_llvm))]
 pub fn g(_: U128VariantEnum, _: I128VariantEnum) {}
 
 fn main() {
     f(U128Enum::U128A, I128Enum::I128A);
-    #[cfg(not(old_llvm))]
-    {
-        g(U128VariantEnum::VariantU128A(1), I128VariantEnum::VariantI128A(2));
-    }
+    g(U128VariantEnum::VariantU128A(1), I128VariantEnum::VariantI128A(2));
 }
diff --git a/tests/run-make/repr128-dwarf/rmake.rs b/tests/run-make/repr128-dwarf/rmake.rs
index 96c65d7d8977..38c69d510733 100644
--- a/tests/run-make/repr128-dwarf/rmake.rs
+++ b/tests/run-make/repr128-dwarf/rmake.rs
@@ -13,25 +13,8 @@
 use run_make_support::{gimli, object, rfs, rustc};
 
 fn main() {
-    // Before LLVM 20, 128-bit enums with variants didn't emit debuginfo correctly.
-    // This check can be removed once Rust no longer supports LLVM 18 and 19.
-    let llvm_version = rustc()
-        .verbose()
-        .arg("--version")
-        .run()
-        .stdout_utf8()
-        .lines()
-        .filter_map(|line| line.strip_prefix("LLVM version: "))
-        .map(|version| version.split(".").next().unwrap().parse::<u32>().unwrap())
-        .next()
-        .unwrap();
-    let is_old_llvm = llvm_version < 20;
-
     let output = PathBuf::from("repr128");
     let mut rustc = rustc();
-    if is_old_llvm {
-        rustc.cfg("old_llvm");
-    }
     rustc.input("main.rs").output(&output).arg("-Cdebuginfo=2").run();
     // Mach-O uses packed debug info
     let dsym_location = output
@@ -88,7 +71,7 @@ fn main() {
 
         while let Some((_, entry)) = cursor.next_dfs().unwrap() {
             match entry.tag() {
-                gimli::constants::DW_TAG_variant if !is_old_llvm => {
+                gimli::constants::DW_TAG_variant => {
                     let Some(value) = entry.attr(gimli::constants::DW_AT_discr_value).unwrap()
                     else {
                         // `std` enums might have variants without `DW_AT_discr_value`.
@@ -143,7 +126,7 @@ fn main() {
     if !enumerators_to_find.is_empty() {
         panic!("Didn't find debug enumerator entries for {enumerators_to_find:?}");
     }
-    if !is_old_llvm && !variants_to_find.is_empty() {
+    if !variants_to_find.is_empty() {
         panic!("Didn't find debug variant entries for {variants_to_find:?}");
     }
 }
diff --git a/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.rs b/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.rs
deleted file mode 100644
index c3046708e4eb..000000000000
--- a/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Verifies that `-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later.
-//
-//@ needs-sanitizer-kcfi
-//@ compile-flags: -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Cpanic=abort -Zsanitizer=kcfi -Zsanitizer-kcfi-arity
-//@ build-fail
-//@ max-llvm-major-version: 20
-
-//~? ERROR `-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later
-#![feature(no_core)]
-#![no_core]
-#![no_main]
diff --git a/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.stderr b/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.stderr
deleted file mode 100644
index c5f886e3a390..000000000000
--- a/tests/ui/sanitizer/kcfi-arity-requires-llvm-21-0-0.stderr
+++ /dev/null
@@ -1,4 +0,0 @@
-error: `-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later
-
-error: aborting due to 1 previous error
-

From 814c7508a9d6ddf37e338d97696384e10faec49e Mon Sep 17 00:00:00 2001
From: Zachary S <zasample18+github@gmail.com>
Date: Thu, 12 Mar 2026 18:52:14 -0500
Subject: [PATCH 0399/1059] Remove PointerLikeCandidate

---
 compiler/rustc_middle/src/traits/select.rs    |  3 ---
 .../src/traits/select/confirmation.rs         | 24 -------------------
 .../src/traits/select/mod.rs                  |  1 -
 3 files changed, 28 deletions(-)

diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
index 3a32029c60bd..8499e61ee485 100644
--- a/compiler/rustc_middle/src/traits/select.rs
+++ b/compiler/rustc_middle/src/traits/select.rs
@@ -163,9 +163,6 @@ pub enum SelectionCandidate<'tcx> {
     /// types generated for a fn pointer type (e.g., `fn(int) -> int`)
     FnPointerCandidate,
 
-    /// Builtin impl of the `PointerLike` trait.
-    PointerLikeCandidate,
-
     TraitAliasCandidate,
 
     /// Matching `dyn Trait` with a supertrait of `Trait`. The index is the
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 9e7637df2649..e948994b8689 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -115,11 +115,6 @@ pub(super) fn confirm_candidate(
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
             }
 
-            PointerLikeCandidate => {
-                let data = self.confirm_pointer_like_candidate(obligation);
-                ImplSource::Builtin(BuiltinImplSource::Misc, data)
-            }
-
             TraitAliasCandidate => {
                 let data = self.confirm_trait_alias_candidate(obligation);
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
@@ -638,25 +633,6 @@ fn confirm_fn_pointer_candidate(
         Ok(nested)
     }
 
-    fn confirm_pointer_like_candidate(
-        &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
-    ) -> PredicateObligations<'tcx> {
-        debug!(?obligation, "confirm_pointer_like_candidate");
-        let placeholder_predicate = self.infcx.enter_forall_and_leak_universe(obligation.predicate);
-        let self_ty = self.infcx.shallow_resolve(placeholder_predicate.self_ty());
-        let ty::Pat(base, _) = *self_ty.kind() else { bug!() };
-        let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
-
-        self.collect_predicates_for_types(
-            obligation.param_env,
-            cause,
-            obligation.recursion_depth + 1,
-            placeholder_predicate.def_id(),
-            vec![base],
-        )
-    }
-
     fn confirm_trait_alias_candidate(
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index a7f47a8615c2..217907193047 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2038,7 +2038,6 @@ fn winnow_candidates(
                 | TraitUpcastingUnsizeCandidate(_)
                 | BuiltinObjectCandidate
                 | BuiltinUnsizeCandidate
-                | PointerLikeCandidate
                 | BikeshedGuaranteedNoDropCandidate => false,
                 // Non-global param candidates have already been handled, global
                 // where-bounds get ignored.

From 949570f8016391b3182361c8fba34ae0eef3e154 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 12 Mar 2026 19:01:39 -0700
Subject: [PATCH 0400/1059] rustdoc-search: update to stringdex 0.0.6

This update includes a few optimizations that reduce the size and
index building time:

- the wire format uses two bits to store four possibilities, instead of
  only handling three
  https://gitlab.com/notriddle/stringdex/-/merge_requests/34

- the hashes themselves are 40 bits instead of 48, and inlining is able
  to still fit enough data by storing runs
  https://gitlab.com/notriddle/stringdex/-/merge_requests/35

- scanning for duplicates takes advantage of the rarity of conflicts,
  using an array with 32 bit numbers and only pulling in the other 8
  bits when actually needed
  https://gitlab.com/notriddle/stringdex/-/merge_requests/37
---
 Cargo.lock                                 |    4 +-
 src/librustdoc/Cargo.toml                  |    2 +-
 src/librustdoc/html/static/js/stringdex.js | 1069 +++++++++++++-------
 3 files changed, 691 insertions(+), 384 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ba41143ff61d..2230ea023bcf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5372,9 +5372,9 @@ dependencies = [
 
 [[package]]
 name = "stringdex"
-version = "0.0.5"
+version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07ab85c3f308f022ce6861ab57576b5b6ebc4835f9577e67e0f35f6c351e3f0a"
+checksum = "155cb460a7ede06f71ac9961e28d3ba4b3408355e233f8edd158b957ceba3950"
 dependencies = [
  "stacker",
 ]
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index 033d3ecdd03d..440d54b007a1 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -22,7 +22,7 @@ rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 smallvec = "1.8.1"
-stringdex = "=0.0.5"
+stringdex = "=0.0.6"
 tempfile = "3"
 threadpool = "1.8.1"
 tracing = "0.1"
diff --git a/src/librustdoc/html/static/js/stringdex.js b/src/librustdoc/html/static/js/stringdex.js
index 720ac58e76e0..f5384e0fd58a 100644
--- a/src/librustdoc/html/static/js/stringdex.js
+++ b/src/librustdoc/html/static/js/stringdex.js
@@ -55,21 +55,66 @@ class RoaringBitmap {
             this.consumed_len_bytes = pspecial - i;
             return this;
         } else if (u8array[i] > 0xe0) {
-            // Special representation of tiny sets that are runs
-            const lspecial = u8array[i] & 0x0f;
-            this.keysAndCardinalities = new Uint8Array(lspecial * 4);
-            i += 1;
-            const key = u8array[i + 2] | (u8array[i + 3] << 8);
-            const value = u8array[i] | (u8array[i + 1] << 8);
-            const container = new RoaringBitmapRun(1, new Uint8Array(4));
-            container.array[0] = value & 0xFF;
-            container.array[1] = (value >> 8) & 0xFF;
-            container.array[2] = lspecial - 1;
-            this.containers.push(container);
-            this.keysAndCardinalities[0] = key & 0xFF;
-            this.keysAndCardinalities[1] = (key >> 8) & 0xFF;
-            this.keysAndCardinalities[2] = lspecial - 1;
-            this.consumed_len_bytes = 5;
+            // Special representation of a node with multiple runs
+            const run_count_m1 = (u8array[i] & 0x0f);
+            const run_count = run_count_m1 + 1;
+            this.keysAndCardinalities = new Uint8Array(run_count * 4);
+            // the run keys and values
+            let pspecial = i + 1;
+            // the run lengths
+            let pnspecial = pspecial + (run_count * 4);
+            /** @type {number|null} */
+            let previous_key = null;
+            /** @type {RoaringBitmapRun|null} */
+            let previous_container = null;
+            for (let j = 0; j < run_count; j += 1) {
+                const key = u8array[pspecial + 2] | (u8array[pspecial + 3] << 8);
+                const value = u8array[pspecial] | (u8array[pspecial + 1] << 8);
+                const run_length_m1 = j % 2 === 0 ?
+                    (u8array[pnspecial] >> 4) :
+                    (u8array[pnspecial] & 0x0f);
+                if (j % 2 !== 0) {
+                    pnspecial += 1;
+                }
+                pspecial += 4;
+                if (key === previous_key && previous_container !== null) {
+                    const new_container_array = new Uint8Array(
+                        (previous_container.runcount + 1) * 4,
+                    );
+                    new_container_array.set(previous_container.array);
+                    new_container_array[previous_container.runcount * 4] = value & 0xFF;
+                    new_container_array[(previous_container.runcount * 4) + 1] =
+                        (value >> 8) & 0xFF;
+                    new_container_array[(previous_container.runcount * 4) + 2] =
+                        run_length_m1;
+                    previous_container.array = new_container_array;
+                    previous_container.runcount += 1;
+                    let cardinalitym1 =
+                        this.keysAndCardinalities[(this.containers.length * 4) - 2] |
+                        (this.keysAndCardinalities[(this.containers.length * 4) - 1] << 8);
+                    cardinalitym1 += run_length_m1 + 1;
+                    this.keysAndCardinalities[(this.containers.length * 4) - 2] =
+                        cardinalitym1 & 0xFF;
+                    this.keysAndCardinalities[(this.containers.length * 4) - 1] =
+                        (cardinalitym1 >> 8) & 0xFF;
+                } else {
+                    previous_key = key;
+                    previous_container = new RoaringBitmapRun(1, Uint8Array.of(
+                        value & 0xFF,
+                        (value >> 8) & 0xFF,
+                        run_length_m1,
+                        0,
+                    ));
+                    this.containers.push(previous_container);
+                    this.keysAndCardinalities[(this.containers.length * 4) - 4] = key & 0xFF;
+                    this.keysAndCardinalities[(this.containers.length * 4) - 3] = (key >> 8) & 0xFF;
+                    this.keysAndCardinalities[(this.containers.length * 4) - 2] = run_length_m1;
+                }
+            }
+            if (run_count % 2 !== 0) {
+                pnspecial += 1;
+            }
+            this.consumed_len_bytes = pnspecial - i;
             return this;
         } else if (u8array[i] > 0xd0) {
             // Special representation of tiny sets that are close together
@@ -100,6 +145,26 @@ class RoaringBitmap {
             }
             this.consumed_len_bytes = pspecial - i;
             return this;
+        } else if (u8array[i] > 0x80) {
+            // Special representation of tiny sets that are runs
+            const lspecial = u8array[i] & 0x3f;
+            const lspecialm1 = lspecial - 1;
+            this.keysAndCardinalities = new Uint8Array(4);
+            i += 1;
+            const key = u8array[i + 2] | (u8array[i + 3] << 8);
+            const value = u8array[i] | (u8array[i + 1] << 8);
+            const container = new RoaringBitmapRun(1, new Uint8Array(4));
+            container.array[0] = value & 0xFF;
+            container.array[1] = (value >> 8) & 0xFF;
+            container.array[2] = lspecialm1 & 0xFF;
+            container.array[3] = lspecialm1 >> 8;
+            this.containers.push(container);
+            this.keysAndCardinalities[0] = key & 0xFF;
+            this.keysAndCardinalities[1] = (key >> 8) & 0xFF;
+            this.keysAndCardinalities[2] = lspecialm1 & 0xFF;
+            this.keysAndCardinalities[3] = lspecialm1 >> 8;
+            this.consumed_len_bytes = 5;
+            return this;
         } else if (u8array[i] < 0x3a) {
             // Special representation of tiny sets with arbitrary 32-bit integers
             const lspecial = u8array[i];
@@ -801,7 +866,7 @@ class HashTable {
         for (let i = 0; i < l; i += 1) {
             const value = values[i];
             if (value !== undefined) {
-                yield [keys.subarray(i * 6, (i + 1) * 6), value];
+                yield [keys.subarray(i * 5, (i + 1) * 5), value];
             }
         }
     }
@@ -818,7 +883,7 @@ class HashTable {
             const l = values.length;
             this.capacityClass += 1;
             const capacity = 1 << this.capacityClass;
-            this.keys = new Uint8Array(capacity * 6);
+            this.keys = new Uint8Array(capacity * 5);
             this.values = [];
             for (let i = 0; i < capacity; i += 1) {
                 this.values.push(undefined);
@@ -827,7 +892,7 @@ class HashTable {
             for (let i = 0; i < l; i += 1) {
                 const oldValue = values[i];
                 if (oldValue !== undefined) {
-                    this.setNoGrow(keys, i * 6, oldValue);
+                    this.setNoGrow(keys, i * 5, oldValue);
                 }
             }
         }
@@ -844,25 +909,24 @@ class HashTable {
         const values = this.values;
         const l = 1 << this.capacityClass;
         // because we know that our values are already hashed,
-        // just chop off the lower four bytes
+        // just chop off the first byte
         let slot = (
-            (key[start + 2] << 24) |
-            (key[start + 3] << 16) |
-            (key[start + 4] << 8) |
-            key[start + 5]
+            (key[start + 1] << 24) |
+            (key[start + 2] << 16) |
+            (key[start + 3] << 8) |
+            key[start + 4]
         ) & mask;
         for (let distance = 0; distance < l; ) {
-            const j = slot * 6;
+            const j = slot * 5;
             const otherValue = values[slot];
             if (otherValue === undefined) {
                 values[slot] = value;
-                const keysStart = slot * 6;
+                const keysStart = slot * 5;
                 keys[keysStart + 0] = key[start + 0];
                 keys[keysStart + 1] = key[start + 1];
                 keys[keysStart + 2] = key[start + 2];
                 keys[keysStart + 3] = key[start + 3];
                 keys[keysStart + 4] = key[start + 4];
-                keys[keysStart + 5] = key[start + 5];
                 this.size += 1;
                 break;
             } else if (
@@ -870,15 +934,14 @@ class HashTable {
                 key[start + 1] === keys[j + 1] &&
                 key[start + 2] === keys[j + 2] &&
                 key[start + 3] === keys[j + 3] &&
-                key[start + 4] === keys[j + 4] &&
-                key[start + 5] === keys[j + 5]
+                key[start + 4] === keys[j + 4]
             ) {
                 values[slot] = value;
                 break;
             } else {
                 const otherPreferredSlot = (
-                    (keys[j + 2] << 24) | (keys[j + 3] << 16) |
-                    (keys[j + 4] << 8) | keys[j + 5]
+                    (keys[j + 1] << 24) | (keys[j + 2] << 16) |
+                    (keys[j + 3] << 8) | keys[j + 4]
                 ) & mask;
                 const otherDistance = otherPreferredSlot <= slot ?
                     slot - otherPreferredSlot :
@@ -888,7 +951,7 @@ class HashTable {
                     // then insert our node in its place and swap
                     //
                     // https://cglab.ca/~abeinges/blah/robinhood-part-1/
-                    const otherKey = keys.slice(j, j + 6);
+                    const otherKey = keys.slice(j, j + 5);
                     values[slot] = value;
                     value = otherValue;
                     keys[j + 0] = key[start + 0];
@@ -896,7 +959,6 @@ class HashTable {
                     keys[j + 2] = key[start + 2];
                     keys[j + 3] = key[start + 3];
                     keys[j + 4] = key[start + 4];
-                    keys[j + 5] = key[start + 5];
                     key = otherKey;
                     start = 0;
                     distance = otherDistance;
@@ -912,7 +974,7 @@ class HashTable {
      * @returns {T|undefined}
      */
     get(key) {
-        if (key.length !== 6) {
+        if (key.length !== 5) {
             throw "invalid key";
         }
         return this.getWithOffsetKey(key, 0);
@@ -931,13 +993,13 @@ class HashTable {
         // because we know that our values are already hashed,
         // just chop off the lower four bytes
         let slot = (
-            (key[start + 2] << 24) |
-            (key[start + 3] << 16) |
-            (key[start + 4] << 8) |
-            key[start + 5]
+            (key[start + 1] << 24) |
+            (key[start + 2] << 16) |
+            (key[start + 3] << 8) |
+            key[start + 4]
         ) & mask;
         for (let distance = 0; distance < l; distance += 1) {
-            const j = slot * 6;
+            const j = slot * 5;
             const value = values[slot];
             if (value === undefined) {
                 break;
@@ -946,14 +1008,13 @@ class HashTable {
                 key[start + 1] === keys[j + 1] &&
                 key[start + 2] === keys[j + 2] &&
                 key[start + 3] === keys[j + 3] &&
-                key[start + 4] === keys[j + 4] &&
-                key[start + 5] === keys[j + 5]
+                key[start + 4] === keys[j + 4]
             ) {
                 return value;
             } else {
                 const otherPreferredSlot = (
-                    (keys[j + 2] << 24) | (keys[j + 3] << 16) |
-                    (keys[j + 4] << 8) | keys[j + 5]
+                    (keys[j + 1] << 24) | (keys[j + 2] << 16) |
+                    (keys[j + 3] << 8) | keys[j + 4]
                 ) & mask;
                 const otherDistance = otherPreferredSlot <= slot ?
                     slot - otherPreferredSlot :
@@ -1133,61 +1194,56 @@ function loadDatabase(hooks) {
         dataColumns: new Map(),
         dataColumnsBuckets: new HashTable(),
         searchTreeLoadByNodeID: function(nodeid) {
-            const existingPromise = registry.searchTreePromises.get(nodeid);
-            if (existingPromise) {
-                return existingPromise;
-            }
             /** @type {Promise<SearchTree>} */
             let newPromise;
             if ((nodeid[0] & 0x80) !== 0) {
-                const isWhole = (nodeid[0] & 0x40) !== 0;
-                let leaves;
-                if ((nodeid[0] & 0x10) !== 0) {
-                    let id1 = (nodeid[2] << 8) | nodeid[3];
-                    if ((nodeid[0] & 0x20) !== 0) {
-                        // when data is present, id1 can be up to 20 bits
-                        id1 |= ((nodeid[1] & 0x0f) << 16);
-                    } else {
-                        // otherwise, we fit in 28
-                        id1 |= ((nodeid[0] & 0x0f) << 24) | (nodeid[1] << 16);
-                    }
-                    const id2 = id1 + ((nodeid[4] << 8) | nodeid[5]);
-                    leaves = RoaringBitmap.makeSingleton(id1)
-                        .union(RoaringBitmap.makeSingleton(id2));
-                } else if (!isWhole && (nodeid[0] & 0xf0) === 0x80) {
-                    const id1 = ((nodeid[0] & 0x0f) << 16) | (nodeid[1] << 8) | nodeid[2];
-                    const id2 = id1 + ((nodeid[3] << 4) | ((nodeid[4] >> 4) & 0x0f));
-                    const id3 = id2 + (((nodeid[4] & 0x0f) << 8) | nodeid[5]);
-                    leaves = RoaringBitmap.makeSingleton(id1)
-                        .union(RoaringBitmap.makeSingleton(id2))
-                        .union(RoaringBitmap.makeSingleton(id3));
+                const isSuffixOnly = (nodeid[0] & 0x40) !== 0;
+                const isRun = (nodeid[0] & 0x20) !== 0;
+                const lengthOrData = nodeid[0] & 0x1F;
+                const id = (nodeid[1] << 24) | (nodeid[2] << 16) | (nodeid[3] << 8) | nodeid[4];
+                let bitmap;
+                if (isRun) {
+                    bitmap = new RoaringBitmap(null);
+                    bitmap.containers.push(new RoaringBitmapRun(
+                        1,
+                        Uint8Array.of(
+                            id & 0xFF,
+                            (id >> 8) & 0xFF,
+                            lengthOrData,
+                            0,
+                        ),
+                    ));
+                    bitmap.keysAndCardinalities = Uint8Array.of(
+                        (id >> 16) & 0xff,
+                        (id >> 24) & 0xff,
+                        lengthOrData,
+                        0,
+                    );
                 } else {
-                    leaves = RoaringBitmap.makeSingleton(
-                        (nodeid[2] << 24) | (nodeid[3] << 16) |
-                        (nodeid[4] << 8) | nodeid[5],
+                    bitmap = RoaringBitmap.makeSingleton(id);
+                }
+                let tree;
+                if (isSuffixOnly) {
+                    tree = new SuffixSearchTree(
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        isRun ? 0 : (lengthOrData + 1),
+                        bitmap,
+                    );
+                } else {
+                    tree = new PrefixSearchTree(
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        isRun ? EMPTY_UINT8 : Uint8Array.of(LONG_ALPHABET.chars[lengthOrData]),
+                        bitmap,
+                        EMPTY_BITMAP,
                     );
                 }
-                if (isWhole) {
-                    const data = (nodeid[0] & 0x20) !== 0 ?
-                        Uint8Array.of(((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4)) :
-                        EMPTY_UINT8;
-                    newPromise = Promise.resolve(new PrefixSearchTree(
-                        EMPTY_SEARCH_TREE_BRANCHES,
-                        EMPTY_SEARCH_TREE_BRANCHES,
-                        data,
-                        leaves,
-                        EMPTY_BITMAP,
-                    ));
-                } else {
-                    const data = (nodeid[0] & 0xf0) === 0x80 ? 0 : (
-                        ((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4));
-                    newPromise = Promise.resolve(new SuffixSearchTree(
-                        EMPTY_SEARCH_TREE_BRANCHES,
-                        data,
-                        leaves,
-                    ));
-                }
+                newPromise = Promise.resolve(tree);
             } else {
+                const existingPromise = registry.searchTreePromises.get(nodeid);
+                if (existingPromise) {
+                    return existingPromise;
+                }
                 const hashHex = makeHexFromUint8Array(nodeid);
                 newPromise = new Promise((resolve, reject) => {
                     const cb = registry.searchTreeLoadPromiseCallbacks.get(nodeid);
@@ -1211,8 +1267,8 @@ function loadDatabase(hooks) {
                         hooks.loadTreeByHash(hashHex);
                     }
                 });
+                registry.searchTreePromises.set(nodeid, newPromise);
             }
-            registry.searchTreePromises.set(nodeid, newPromise);
             return newPromise;
         },
         dataLoadByNameAndHash: function(name, hash) {
@@ -1277,8 +1333,8 @@ function loadDatabase(hooks) {
         getNodeID(i) {
             return new Uint8Array(
                 this.nodeids.buffer,
-                this.nodeids.byteOffset + (i * 6),
-                6,
+                this.nodeids.byteOffset + (i * 5),
+                5,
             );
         }
         // https://github.com/microsoft/TypeScript/issues/17227
@@ -1385,113 +1441,310 @@ function loadDatabase(hooks) {
         EMPTY_UINT8,
     );
 
-    /** @type {number[]} */
-    const SHORT_ALPHABITMAP_CHARS = [];
+    class Alphabet {
+        constructor() {
+            /** @type {number[]} */
+            this.chars = [];
+            /** @type {number} */
+            this.len = 0;
+            /** @type {number} */
+            this.bytes = 0;
+            /** @type {number} */
+            this.flag = 0;
+            /** @type {number} */
+            this.bitwidth = 0;
+        }
+        /**
+         * @param {number} c
+         * @returns {boolean}
+         */
+        contains(c) {
+            return this.chars.indexOf(c) !== -1;
+        }
+        /**
+         * @param {number} c
+         * @returns {number}
+         */
+        index(c) {
+            return this.chars.indexOf(c);
+        }
+    }
+
+    /** @type {Alphabet} */
+    const VOWELONLY_ALPHABITMAP = Object.assign(
+        new Alphabet(),
+        {
+            chars: [0x61, 0x65, 0x69, 0x6f, 0x75],
+            len: 5,
+            bytes: 0,
+            flag: 0x80,
+        },
+    );
+
+    /** @type {Alphabet} */
+    const CONSONANTSONLY_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [],
+            len: 21,
+            bytes: 2,
+            flag: 0xc0,
+        },
+    );
+    for (let i = 0x61; i <= 0x7A; ++i) {
+        if (i === 0x61 || i === 0x65 || i === 0x69 || i === 0x6f || i === 0x75) {
+            // 21 bits, 26 letters, so skip aeiou
+            continue;
+        }
+        CONSONANTSONLY_ALPHABET.chars.push(i);
+    }
+
+    /** @type {Alphabet} */
+    const HEX_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [],
+            len: 16,
+            bytes: 2,
+            flag: 0xfc,
+        },
+    );
+    for (let i = 0x30; i <= 0x39; ++i) {
+        HEX_ALPHABET.chars.push(i);
+    }
+    for (let i = 0x61; i <= 0x66; ++i) {
+        HEX_ALPHABET.chars.push(i);
+    }
+
+    /** @type {Alphabet} */
+    const SHORT_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [],
+            len: 24,
+            bytes: 3,
+            flag: 0xfd,
+        },
+    );
     for (let i = 0x61; i <= 0x7A; ++i) {
         if (i === 0x76 || i === 0x71) {
             // 24 entries, 26 letters, so we skip q and v
             continue;
         }
-        SHORT_ALPHABITMAP_CHARS.push(i);
+        SHORT_ALPHABET.chars.push(i);
     }
 
-    /** @type {number[]} */
-    const LONG_ALPHABITMAP_CHARS = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36];
+    /** @type {Alphabet} */
+    const LONG_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [0x31, 0x32, 0x33, 0x34, 0x35, 0x36],
+            len: 32,
+            bytes: 4,
+            flag: 0xfe,
+        },
+    );
     for (let i = 0x61; i <= 0x7A; ++i) {
-        LONG_ALPHABITMAP_CHARS.push(i);
+        LONG_ALPHABET.chars.push(i);
+    }
+
+    /** @type {Alphabet} */
+    const ASCII_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [],
+            len: 128,
+            bytes: 16,
+            flag: 0xf0,
+            /**
+             * @param {number} c
+             * @returns {boolean}
+             */
+            contains(c) {
+                return c <= 0x7f;
+            },
+            /**
+             * @param {number} c
+             * @returns {number}
+             */
+            index(c) {
+                return c;
+            },
+        },
+    );
+    for (let i = 0x00; i <= 0x7f; ++i) {
+        ASCII_ALPHABET.chars.push(i);
+    }
+
+    /** @type {Alphabet} */
+    const RAWBYTE_ALPHABET = Object.assign(
+        new Alphabet(),
+        {
+            chars: [],
+            len: 256,
+            bytes: 32,
+            flag: 0xff,
+            /**
+             * @param {number} _c
+             * @returns {boolean}
+             */
+            contains(_c) {
+                return true;
+            },
+            /**
+             * @param {number} c
+             * @returns {number}
+             */
+            index(c) {
+                return c;
+            },
+        },
+    );
+    for (let i = 0x00; i <= 0xff; ++i) {
+        RAWBYTE_ALPHABET.chars.push(i);
     }
 
     /**
-     * @template ST
-     * @param {number[]} alphabitmap_chars
-     * @param {number} width
-     * @return {(typeof SearchTreeBranches<ST>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
+     * Parse an alphabet and buffer where the flag is right at the beginning.
+     * @param {number} start
+     * @param {Uint8Array} buf
+     * @returns {{"alphabet": Alphabet, "consumed_len_bytes": number, "len": number}?}
      */
-    function makeSearchTreeBranchesAlphaBitmapClass(alphabitmap_chars, width) {
-        const bitwidth = width * 8;
+    Alphabet.parse = function(start, buf) {
+        const flag = buf[start];
+        const parsed = Alphabet.parseFlag(flag, start + 1, buf);
+        if (!parsed) {
+            return null;
+        }
+        parsed.consumed_len_bytes += 1;
+        return parsed;
+    };
+
+    /**
+     * Parse an alphabet and buffer where the flag is not at the beginning.
+     * @param {number} flag
+     * @param {number} i
+     * @param {Uint8Array} buf
+     * @returns {{"alphabet": Alphabet, "consumed_len_bytes": number, "len": number}?}
+     */
+    Alphabet.parseFlag = function(flag, i, buf) {
+        if (flag <= 0x80) {
+            return null;
+        }
+        const alphabet = flag === RAWBYTE_ALPHABET.flag ? RAWBYTE_ALPHABET : (
+            flag === ASCII_ALPHABET.flag ? ASCII_ALPHABET : (
+            flag === LONG_ALPHABET.flag ? LONG_ALPHABET : (
+            flag === SHORT_ALPHABET.flag ? SHORT_ALPHABET : (
+            flag === HEX_ALPHABET.flag ? HEX_ALPHABET : (
+            flag >= CONSONANTSONLY_ALPHABET.flag ? CONSONANTSONLY_ALPHABET : VOWELONLY_ALPHABITMAP
+        )))));
+        let len = alphabet === CONSONANTSONLY_ALPHABET || alphabet === VOWELONLY_ALPHABITMAP ?
+            bitCount(flag & 0x1f) : 0;
+        for (let ix = 0; ix < alphabet.bytes; ++ix) {
+            len += bitCount(buf[i]);
+            i += 1;
+        }
+        return {alphabet, consumed_len_bytes: alphabet.bytes, len};
+    };
+
+    /**
+     * @template ST
+     * @extends SearchTreeBranches<ST>
+     */
+    class SearchTreeBranchesAlphaBitmap extends SearchTreeBranches {
         /**
-         * @extends SearchTreeBranches<ST>
+         * @param {Alphabet} alphabet
+         * @param {Uint8Array} buffer
+         * @param {Uint8Array} nodeids
          */
-        const cls = class SearchTreeBranchesAlphaBitmap extends SearchTreeBranches {
-            /**
-             * @param {number} bitmap
-             * @param {Uint8Array} nodeids
-             */
-            constructor(bitmap, nodeids) {
-                super(nodeids.length / 6, nodeids);
-                if (nodeids.length / 6 !== bitCount(bitmap)) {
-                    throw new Error(`mismatch ${bitmap} ${nodeids}`);
+        constructor(alphabet, buffer, nodeids) {
+            let bitmap;
+            if (alphabet === VOWELONLY_ALPHABITMAP) {
+                bitmap = new Uint8Array(1);
+                bitmap[0] = buffer[0] & 0x1f;
+            } else if (alphabet === CONSONANTSONLY_ALPHABET) {
+                bitmap = new Uint8Array(3);
+                bitmap[0] = buffer[1];
+                bitmap[1] = buffer[2];
+                bitmap[2] = buffer[0] & 0x1f;
+            } else {
+                bitmap = buffer.subarray(1);
+            }
+            let cardinality = 0;
+            for (let i = 0; i < bitmap.length; ++i) {
+                cardinality += bitCount(bitmap[i]);
+            }
+            super(cardinality, nodeids);
+            this.bitmap = bitmap;
+            this.alphabet = alphabet;
+        }
+        /**
+         * Yields [character, SearchTree] pairs.
+         * @returns {Generator<[number, Promise<ST>|null]>}
+         */
+        * entries() {
+            let i = 0;
+            let j = 0;
+            while (i < this.alphabet.len) {
+                if (this.bitmap[i >> 3] & (1 << (i & 0x07))) {
+                    yield [this.alphabet.chars[i], this.subtrees[j]];
+                    j += 1;
                 }
-                this.bitmap = bitmap;
-                this.nodeids = nodeids;
+                i += 1;
             }
-            /** @returns {Generator<[number, Promise<ST>|null]>} */
-            * entries() {
-                let i = 0;
-                let j = 0;
-                while (i < bitwidth) {
-                    if (this.bitmap & (1 << i)) {
-                        yield [alphabitmap_chars[i], this.subtrees[j]];
-                        j += 1;
-                    }
-                    i += 1;
-                }
+        }
+        /**
+         * Given a character, returns the numbered index of the search
+         * tree, or -1 if there isn't one.
+         * @param {number} c
+         * @returns {number}
+         */
+        getIndex(c) {
+            //return this.getKeys().indexOf(c);
+            if (!this.alphabet.contains(c)) {
+                return -1;
             }
-            /**
-             * @param {number} k
-             * @returns {number}
-             */
-            getIndex(k) {
-                //return this.getKeys().indexOf(k);
-                const ix = alphabitmap_chars.indexOf(k);
-                if (ix < 0) {
-                    return ix;
-                }
-                const result = bitCount(~(0xffffffff << ix) & this.bitmap);
-                return result >= this.subtrees.length ? -1 : result;
-            }
-            /**
-             * @param {number} branch_index
-             * @returns {number}
-             */
-            getKey(branch_index) {
-                return this.getKeys()[branch_index];
-            }
-            /**
-             * @returns {Uint8Array}
-             */
-            getKeys() {
-                const length = bitCount(this.bitmap);
-                const result = new Uint8Array(length);
-                let result_index = 0;
-                for (let alpha_index = 0; alpha_index < bitwidth; ++alpha_index) {
-                    if (this.bitmap & (1 << alpha_index)) {
-                        result[result_index] = alphabitmap_chars[alpha_index];
-                        result_index += 1;
-                    }
+            const k = this.alphabet.index(c);
+            if (this.bitmap[k >> 3] & (1 << (k & 0x07))) {
+                let result = bitCount(~(0xff << (k & 0x07)) & this.bitmap[k >> 3]);
+                for (let ix = 0; ix < (k >> 3); ++ix) {
+                    result += bitCount(this.bitmap[ix]);
                 }
                 return result;
+            } else {
+                return -1;
             }
-        };
-        cls.ALPHABITMAP_CHARS = alphabitmap_chars;
-        cls.width = width;
-        return cls;
+        }
+        /**
+         * Given the numbered index of a search tree, returns the key.
+         * This is the exact opposite of getIndex().
+         * @param {number} branch_index
+         * @returns {number}
+         */
+        getKey(branch_index) {
+            return this.getKeys()[branch_index];
+        }
+        /**
+         * Returns a list of one-byte keys.
+         * @returns {Uint8Array}
+         */
+        getKeys() {
+            let length = 0;
+            for (let i = 0; i < this.bitmap.length; ++i) {
+                length += bitCount(this.bitmap[i]);
+            }
+            const result = new Uint8Array(length);
+            let result_index = 0;
+            for (let ix = 0; ix < this.alphabet.len; ++ix) {
+                if (this.bitmap[ix >> 3] & (1 << (ix & 0x07))) {
+                    result[result_index] = this.alphabet.chars[ix];
+                    result_index += 1;
+                }
+            }
+            return result;
+        }
     }
 
-    /**
-     * @template ST
-     * @type {(typeof SearchTreeBranches<any>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
-     */
-    const SearchTreeBranchesShortAlphaBitmap =
-        makeSearchTreeBranchesAlphaBitmapClass(SHORT_ALPHABITMAP_CHARS, 3);
-
-    /**
-     * @template ST
-     * @type {(typeof SearchTreeBranches<any>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
-     */
-    const SearchTreeBranchesLongAlphaBitmap =
-        makeSearchTreeBranchesAlphaBitmapClass(LONG_ALPHABITMAP_CHARS, 4);
-
     /**
      * @typedef {PrefixSearchTree|SuffixSearchTree|InlineNeighborsTree} SearchTree
      * @typedef {PrefixTrie|SuffixTrie} Trie
@@ -2347,19 +2600,15 @@ function loadDatabase(hooks) {
             const has_branches = (encoded[i] & 0x04) !== 0;
             /** @type {boolean} */
             const is_suffixes_only = (encoded[i] & 0x01) !== 0;
-            let leaves_count = ((encoded[i] >> 4) & 0x07) + 1;
-            let leaves_is_run = (encoded[i] >> 7) !== 0;
+            const leaves_count = (encoded[i] >> 4) & 0x07;
+            const leaves_is_run = (encoded[i] >> 7) !== 0;
             i += 1;
-            let branch_count = 0;
+            let branch_flag = 0;
             if (has_branches) {
-                branch_count = encoded[i] + 1;
+                branch_flag = encoded[i];
                 i += 1;
             }
             const dlen = encoded[i] & 0x3f;
-            if ((encoded[i] & 0x80) !== 0) {
-                leaves_count = 0;
-                leaves_is_run = false;
-            }
             i += 1;
             /** @type {Uint8Array} */
             let data = EMPTY_UINT8;
@@ -2367,13 +2616,25 @@ function loadDatabase(hooks) {
                 data = encoded.subarray(i, i + dlen);
                 i += dlen;
             }
+            const branch_flag_alphabet = Alphabet.parseFlag(branch_flag, i, encoded);
+            let branch_alphabitmap = EMPTY_UINT8;
+            if (branch_flag_alphabet) {
+                branch_alphabitmap = new Uint8Array(branch_flag_alphabet.consumed_len_bytes + 1);
+                branch_alphabitmap[0] = branch_flag;
+                branch_alphabitmap.set(
+                    encoded.subarray(i, i + branch_flag_alphabet.consumed_len_bytes),
+                    1,
+                );
+                i += branch_flag_alphabet.consumed_len_bytes;
+            }
+            const branch_count = branch_flag_alphabet ? branch_flag_alphabet.len : branch_flag;
             const leaf_value_upper = encoded[i] | (encoded[i + 1] << 8);
             i += 2;
             /** @type {Promise<SearchTree>[]} */
             const branch_nodes = [];
             for (let j = 0; j < branch_count; j += 1) {
                 const branch_dlen = encoded[i] & 0x0f;
-                const branch_leaves_count = ((encoded[i] >> 4) & 0x07) + 1;
+                const branch_leaves_count = (encoded[i] >> 4) & 0x07;
                 const branch_leaves_is_run = (encoded[i] >> 7) !== 0;
                 i += 1;
                 /** @type {Uint8Array} */
@@ -2427,14 +2688,22 @@ function loadDatabase(hooks) {
                         ),
                 ));
             }
-            /** @type {SearchTreeBranchesArray<SearchTree>} */
+            /** @type {SearchTreeBranches<SearchTree>} */
             const branches = branch_count === 0 ?
                 EMPTY_SEARCH_TREE_BRANCHES :
-                new SearchTreeBranchesArray(
-                    encoded.subarray(i, i + branch_count),
-                    EMPTY_UINT8,
-                );
-            i += branch_count;
+                branch_flag_alphabet ?
+                    new SearchTreeBranchesAlphaBitmap(
+                        branch_flag_alphabet.alphabet,
+                        branch_alphabitmap,
+                        EMPTY_UINT8,
+                    ) :
+                    new SearchTreeBranchesArray(
+                        encoded.subarray(i, i + branch_count),
+                        EMPTY_UINT8,
+                    );
+            if (!branch_flag_alphabet) {
+                i += branch_count;
+            }
             branches.subtrees = branch_nodes;
             let leaves = EMPTY_BITMAP;
             if (leaves_count !== 0) {
@@ -2556,7 +2825,7 @@ function loadDatabase(hooks) {
                     k += 1;
                 }
                 const end = k;
-                const bucket = {hash: hashes.subarray(i * 6, (i + 1) * 6), data: null, end, count};
+                const bucket = {hash: hashes.subarray(i * 5, (i + 1) * 5), data: null, end, count};
                 this.buckets.push(bucket);
                 this.bucket_keys.push(start);
             }
@@ -2698,7 +2967,7 @@ function loadDatabase(hooks) {
      */
     function loadColumnFromBytes(data) {
         const hashBuf = Uint8Array.of(0, 0, 0, 0, 0, 0, 0, 0);
-        const truncatedHash = hashBuf.subarray(2, 8);
+        const truncatedHash = hashBuf.subarray(3, 8);
         siphashOfBytes(data, 0, 0, 0, 0, hashBuf);
         const cb = registry.dataColumnLoadPromiseCallbacks.get(truncatedHash);
         if (cb) {
@@ -2744,7 +3013,7 @@ function loadDatabase(hooks) {
         /** @type {HashTable<SearchTree>} */
         const stash = new HashTable();
         const hash = Uint8Array.of(0, 0, 0, 0, 0, 0, 0, 0);
-        const truncatedHash = new Uint8Array(hash.buffer, 2, 6);
+        const truncatedHash = hash.subarray(3, 8);
         // used for handling compressed (that is, relative-offset) nodes
         /** @type {{hash: Uint8Array, used: boolean}[]} */
         const hash_history = [];
@@ -2764,12 +3033,12 @@ function loadDatabase(hooks) {
          * @param {number} i
          * @param {number} compression_tag
          * @returns {{
-         *     "cpbranches": Uint8Array,
-         *     "csbranches": Uint8Array,
          *     "might_have_prefix_branches": SearchTreeBranches<SearchTree>,
          *     "branches": SearchTreeBranches<SearchTree>,
+         *     "branches_header": Uint8Array,
          *     "cpnodes": Uint8Array,
          *     "csnodes": Uint8Array,
+         *     "branches_keys": Uint8Array,
          *     "consumed_len_bytes": number,
          * }}
          */
@@ -2786,49 +3055,63 @@ function loadDatabase(hooks) {
             const any_children_are_compressed =
                 (compression_tag & 0xF0) !== 0x00 || is_long_compressed;
             const start_point = i;
-            let cplen;
-            let cslen;
             /**
-             * @type {(
-             *   typeof SearchTreeBranches<SearchTree> &
-             *   {"ALPHABITMAP_CHARS": number[], "width": number}
-             * )?}
+             * @type {Alphabet|null}
              */
-            let alphabitmap = null;
+            let cpalphabet = null;
+            /**
+             * @type {Uint8Array}
+             */
+            let cpalphabitmap = EMPTY_UINT8;
+            /**
+             * @type {number}
+             */
+            let cplen;
+            /**
+             * @type {Alphabet|null}
+             */
+            let csalphabet = null;
+            /**
+             * @type {Uint8Array}
+             */
+            let csalphabitmap = EMPTY_UINT8;
+            /**
+             * @type {number}
+             */
+            let cslen;
+            // might-have-prefix nodes
             if (is_pure_suffixes_only_node) {
                 cplen = 0;
-                cslen = input[i];
-                i += 1;
-                if (cslen >= 0xc0) {
-                    alphabitmap = SearchTreeBranchesLongAlphaBitmap;
-                    cslen = cslen & 0x3F;
-                } else if (cslen >= 0x80) {
-                    alphabitmap = SearchTreeBranchesShortAlphaBitmap;
-                    cslen = cslen & 0x7F;
-                }
             } else {
-                cplen = input[i];
-                i += 1;
-                cslen = input[i];
-                i += 1;
-                if (cplen === 0xff && cslen === 0xff) {
-                    cplen = 0x100;
-                    cslen = 0;
-                } else if (cplen >= 0xc0 && cslen >= 0xc0) {
-                    alphabitmap = SearchTreeBranchesLongAlphaBitmap;
-                    cplen = cplen & 0x3F;
-                    cslen = cslen & 0x3F;
-                } else if (cplen >= 0x80 && cslen >= 0x80) {
-                    alphabitmap = SearchTreeBranchesShortAlphaBitmap;
-                    cplen = cplen & 0x7F;
-                    cslen = cslen & 0x7F;
+                const parsed = Alphabet.parse(i, input);
+                if (parsed) {
+                    cpalphabitmap = input.subarray(i, i + parsed.consumed_len_bytes);
+                    cpalphabet = parsed.alphabet;
+                    cplen = parsed.len;
+                    i += parsed.consumed_len_bytes;
+                } else {
+                    cplen = input[i];
+                    i += 1;
                 }
             }
+            // suffix-only nodes
+            const parsed = Alphabet.parse(i, input);
+            if (parsed) {
+                csalphabitmap = input.subarray(i, i + parsed.consumed_len_bytes);
+                csalphabet = parsed.alphabet;
+                cslen = parsed.len;
+                i += parsed.consumed_len_bytes;
+            } else {
+                cslen = input[i];
+                i += 1;
+            }
+            const branches_header = input.subarray(start_point, i);
+            // now process the hashes, offsets, or stack
             let j = 0;
             /** @type {Uint8Array} */
             let cpnodes;
             if (any_children_are_compressed) {
-                cpnodes = cplen === 0 ? EMPTY_UINT8 : new Uint8Array(cplen * 6);
+                cpnodes = cplen === 0 ? EMPTY_UINT8 : new Uint8Array(cplen * 5);
                 while (j < cplen) {
                     const is_compressed = all_children_are_compressed ||
                         ((0x10 << j) & compression_tag) !== 0;
@@ -2845,29 +3128,28 @@ function loadDatabase(hooks) {
                         hash_history[slot].used = true;
                         cpnodes.set(
                             hash_history[slot].hash,
-                            j * 6,
+                            j * 5,
                         );
                     } else {
-                        const joff = j * 6;
+                        const joff = j * 5;
                         cpnodes[joff + 0] = input[i + 0];
                         cpnodes[joff + 1] = input[i + 1];
                         cpnodes[joff + 2] = input[i + 2];
                         cpnodes[joff + 3] = input[i + 3];
                         cpnodes[joff + 4] = input[i + 4];
-                        cpnodes[joff + 5] = input[i + 5];
-                        i += 6;
+                        i += 5;
                     }
                     j += 1;
                 }
             } else {
-                cpnodes = cplen === 0 ? EMPTY_UINT8 : input.subarray(i, i + (cplen * 6));
-                i += cplen * 6;
+                cpnodes = cplen === 0 ? EMPTY_UINT8 : input.subarray(i, i + (cplen * 5));
+                i += cplen * 5;
             }
             j = 0;
             /** @type {Uint8Array} */
             let csnodes;
             if (any_children_are_compressed) {
-                csnodes = cslen === 0 ? EMPTY_UINT8 : new Uint8Array(cslen * 6);
+                csnodes = cslen === 0 ? EMPTY_UINT8 : new Uint8Array(cslen * 5);
                 while (j < cslen) {
                     const is_compressed = all_children_are_compressed ||
                         ((0x10 << (cplen + j)) & compression_tag) !== 0;
@@ -2884,138 +3166,146 @@ function loadDatabase(hooks) {
                         hash_history[slot].used = true;
                         csnodes.set(
                             hash_history[slot].hash,
-                            j * 6,
+                            j * 5,
                         );
                     } else {
-                        const joff = j * 6;
+                        const joff = j * 5;
                         csnodes[joff + 0] = input[i + 0];
                         csnodes[joff + 1] = input[i + 1];
                         csnodes[joff + 2] = input[i + 2];
                         csnodes[joff + 3] = input[i + 3];
                         csnodes[joff + 4] = input[i + 4];
-                        csnodes[joff + 5] = input[i + 5];
-                        i += 6;
+                        i += 5;
                     }
                     j += 1;
                 }
             } else {
-                csnodes = cslen === 0 ? EMPTY_UINT8 : input.subarray(i, i + (cslen * 6));
-                i += cslen * 6;
+                csnodes = cslen === 0 ? EMPTY_UINT8 : input.subarray(i, i + (cslen * 5));
+                i += cslen * 5;
             }
-            let cpbranches;
+            const start_point_keys = i;
             let might_have_prefix_branches;
             if (cplen === 0) {
-                cpbranches = EMPTY_UINT8;
                 might_have_prefix_branches = EMPTY_SEARCH_TREE_BRANCHES;
-            } else if (alphabitmap) {
-                cpbranches = new Uint8Array(input.buffer, i + input.byteOffset, alphabitmap.width);
-                const branchset = (alphabitmap.width === 4 ? (input[i + 3] << 24) : 0) |
-                    (input[i + 2] << 16) |
-                    (input[i + 1] << 8) |
-                    input[i];
-                might_have_prefix_branches = new alphabitmap(branchset, cpnodes);
-                i += alphabitmap.width;
+            } else if (cpalphabet) {
+                might_have_prefix_branches = new SearchTreeBranchesAlphaBitmap(
+                    cpalphabet,
+                    cpalphabitmap,
+                    cpnodes,
+                );
             } else {
-                cpbranches = new Uint8Array(input.buffer, i + input.byteOffset, cplen);
-                might_have_prefix_branches = new SearchTreeBranchesArray(cpbranches, cpnodes);
+                might_have_prefix_branches = new SearchTreeBranchesArray(
+                    new Uint8Array(input.buffer, i + input.byteOffset, cplen),
+                    cpnodes,
+                );
                 i += cplen;
             }
-            let csbranches;
             let branches;
             if (cslen === 0) {
-                csbranches = EMPTY_UINT8;
                 branches = might_have_prefix_branches;
-            } else if (alphabitmap) {
-                csbranches = new Uint8Array(input.buffer, i + input.byteOffset, alphabitmap.width);
-                const branchset = (alphabitmap.width === 4 ? (input[i + 3] << 24) : 0) |
-                    (input[i + 2] << 16) |
-                    (input[i + 1] << 8) |
-                    input[i];
-                if (cplen === 0) {
-                    branches = new alphabitmap(branchset, csnodes);
-                } else {
-                    const cpoffset = i - alphabitmap.width;
-                    const cpbranchset =
-                        (alphabitmap.width === 4 ? (input[cpoffset + 3] << 24) : 0) |
-                        (input[cpoffset + 2] << 16) |
-                        (input[cpoffset + 1] << 8) |
-                        input[cpoffset];
-                    const hashes = new Uint8Array((cplen + cslen) * 6);
-                    let cpi = 0;
-                    let csi = 0;
-                    let j = 0;
-                    for (let k = 0; k < alphabitmap.ALPHABITMAP_CHARS.length; k += 1) {
-                        if (branchset & (1 << k)) {
-                            hashes[j + 0] = csnodes[csi + 0];
-                            hashes[j + 1] = csnodes[csi + 1];
-                            hashes[j + 2] = csnodes[csi + 2];
-                            hashes[j + 3] = csnodes[csi + 3];
-                            hashes[j + 4] = csnodes[csi + 4];
-                            hashes[j + 5] = csnodes[csi + 5];
-                            j += 6;
-                            csi += 6;
-                        } else if (cpbranchset & (1 << k)) {
-                            hashes[j + 0] = cpnodes[cpi + 0];
-                            hashes[j + 1] = cpnodes[cpi + 1];
-                            hashes[j + 2] = cpnodes[cpi + 2];
-                            hashes[j + 3] = cpnodes[cpi + 3];
-                            hashes[j + 4] = cpnodes[cpi + 4];
-                            hashes[j + 5] = cpnodes[cpi + 5];
-                            j += 6;
-                            cpi += 6;
-                        }
-                    }
-                    branches = new alphabitmap(branchset | cpbranchset, hashes);
-                }
-                i += alphabitmap.width;
             } else {
-                csbranches = new Uint8Array(input.buffer, i + input.byteOffset, cslen);
-                if (cplen === 0) {
-                    branches = new SearchTreeBranchesArray(csbranches, csnodes);
+                if (csalphabet) {
+                    branches = new SearchTreeBranchesAlphaBitmap(
+                        csalphabet,
+                        csalphabitmap,
+                        csnodes,
+                    );
                 } else {
-                    const branchset = new Uint8Array(cplen + cslen);
-                    const hashes = new Uint8Array((cplen + cslen) * 6);
-                    let cpi = 0;
-                    let csi = 0;
-                    let j = 0;
-                    while (cpi < cplen || csi < cslen) {
-                        if (cpi >= cplen || (csi < cslen && cpbranches[cpi] > csbranches[csi])) {
-                            branchset[j] = csbranches[csi];
-                            const joff = j * 6;
-                            const csioff = csi * 6;
-                            hashes[joff + 0] = csnodes[csioff + 0];
-                            hashes[joff + 1] = csnodes[csioff + 1];
-                            hashes[joff + 2] = csnodes[csioff + 2];
-                            hashes[joff + 3] = csnodes[csioff + 3];
-                            hashes[joff + 4] = csnodes[csioff + 4];
-                            hashes[joff + 5] = csnodes[csioff + 5];
-                            csi += 1;
-                        } else {
-                            branchset[j] = cpbranches[cpi];
-                            const joff = j * 6;
-                            const cpioff = cpi * 6;
-                            hashes[joff + 0] = cpnodes[cpioff + 0];
-                            hashes[joff + 1] = cpnodes[cpioff + 1];
-                            hashes[joff + 2] = cpnodes[cpioff + 2];
-                            hashes[joff + 3] = cpnodes[cpioff + 3];
-                            hashes[joff + 4] = cpnodes[cpioff + 4];
-                            hashes[joff + 5] = cpnodes[cpioff + 5];
-                            cpi += 1;
-                        }
-                        j += 1;
-                    }
-                    branches = new SearchTreeBranchesArray(branchset, hashes);
+                    branches = new SearchTreeBranchesArray(
+                        new Uint8Array(input.buffer, i + input.byteOffset, cslen),
+                        csnodes,
+                    );
+                    i += cslen;
+                }
+                if (cplen !== 0) {
+                    const hashes = new Uint8Array((cplen + cslen) * 5);
+                    if (cplen + cslen > 32) {
+                        const raw_bits = new Uint8Array(RAWBYTE_ALPHABET.bytes + 1);
+                        raw_bits[0] = RAWBYTE_ALPHABET.flag;
+                        const bits = raw_bits.subarray(1);
+                        const mhp_keys = might_have_prefix_branches.getKeys();
+                        const so_keys = branches.getKeys();
+                        let mhp_i = 0;
+                        let so_i = 0;
+                        let j = 0;
+                        while (mhp_i < cplen || so_i < cslen) {
+                            if (so_i === cslen || mhp_keys[mhp_i] < so_keys[so_i]) {
+                                const joff = j * 5;
+                                const mhp_off = mhp_i * 5;
+                                hashes[joff + 0] = cpnodes[mhp_off + 0];
+                                hashes[joff + 1] = cpnodes[mhp_off + 1];
+                                hashes[joff + 2] = cpnodes[mhp_off + 2];
+                                hashes[joff + 3] = cpnodes[mhp_off + 3];
+                                hashes[joff + 4] = cpnodes[mhp_off + 4];
+                                const ix = mhp_keys[mhp_i];
+                                bits[ix >> 3] |= 1 << (ix & 0x07);
+                                mhp_i += 1;
+                            } else {
+                                const joff = j * 5;
+                                const so_off = so_i * 5;
+                                hashes[joff + 0] = csnodes[so_off + 0];
+                                hashes[joff + 1] = csnodes[so_off + 1];
+                                hashes[joff + 2] = csnodes[so_off + 2];
+                                hashes[joff + 3] = csnodes[so_off + 3];
+                                hashes[joff + 4] = csnodes[so_off + 4];
+                                const ix = so_keys[so_i];
+                                bits[ix >> 3] |= 1 << (ix & 0x07);
+                                so_i += 1;
+                            }
+                            j += 1;
+                        }
+                        branches = new SearchTreeBranchesAlphaBitmap(
+                            RAWBYTE_ALPHABET,
+                            raw_bits,
+                            hashes,
+                        );
+                    } else {
+                        const merged_keys = new Uint8Array(cplen + cslen);
+                        const mhp_keys = might_have_prefix_branches.getKeys();
+                        const so_keys = branches.getKeys();
+                        let mhp_i = 0;
+                        let so_i = 0;
+                        let j = 0;
+                        while (mhp_i < cplen || so_i < cslen) {
+                            if (so_i === cslen || mhp_keys[mhp_i] < so_keys[so_i]) {
+                                const joff = j * 5;
+                                const mhp_off = mhp_i * 5;
+                                hashes[joff + 0] = cpnodes[mhp_off + 0];
+                                hashes[joff + 1] = cpnodes[mhp_off + 1];
+                                hashes[joff + 2] = cpnodes[mhp_off + 2];
+                                hashes[joff + 3] = cpnodes[mhp_off + 3];
+                                hashes[joff + 4] = cpnodes[mhp_off + 4];
+                                merged_keys[j] = mhp_keys[mhp_i];
+                                mhp_i += 1;
+                            } else {
+                                const joff = j * 5;
+                                const so_off = so_i * 5;
+                                hashes[joff + 0] = csnodes[so_off + 0];
+                                hashes[joff + 1] = csnodes[so_off + 1];
+                                hashes[joff + 2] = csnodes[so_off + 2];
+                                hashes[joff + 3] = csnodes[so_off + 3];
+                                hashes[joff + 4] = csnodes[so_off + 4];
+                                merged_keys[j] = so_keys[so_i];
+                                so_i += 1;
+                            }
+                            j += 1;
+                        }
+                        branches = new SearchTreeBranchesArray(
+                            merged_keys,
+                            hashes,
+                        );
+                    }
                 }
-                i += cslen;
             }
+            const branches_keys = input.subarray(start_point_keys, i);
             return {
                 consumed_len_bytes: i - start_point,
-                cpbranches,
-                csbranches,
                 cpnodes,
                 csnodes,
                 branches,
                 might_have_prefix_branches,
+                branches_header,
+                branches_keys,
             };
         }
         while (i < l) {
@@ -3038,26 +3328,23 @@ function loadDatabase(hooks) {
             /** @type {number} */
             let no_leaves_flag;
             /** @type {number} */
-            let inline_neighbors_flag;
+            let no_branches_flag;
             if (is_data_compressed && is_pure_suffixes_only_node) {
                 dlen = 0;
                 no_leaves_flag = 0x80;
-                inline_neighbors_flag = 0;
+                no_branches_flag = 0;
             } else {
                 dlen = input[i] & 0x3F;
                 no_leaves_flag = input[i] & 0x80;
-                inline_neighbors_flag = input[i] & 0x40;
+                no_branches_flag = input[i] & 0x40;
                 i += 1;
             }
-            if (inline_neighbors_flag !== 0) {
+            if (no_leaves_flag !== 0 && no_branches_flag !== 0) {
                 // node with packed leaves and common 16bit prefix
-                const leaves_count = no_leaves_flag !== 0 ?
-                    0 :
-                    ((compression_tag >> 4) & 0x07) + 1;
-                const leaves_is_run = no_leaves_flag === 0 &&
-                    ((compression_tag >> 4) & 0x08) !== 0;
-                const branch_count = is_long_compressed ?
-                    ((compression_tag >> 8) & 0xff) + 1 :
+                const leaves_count = (compression_tag >> 4) & 0x07;
+                const leaves_is_run = ((compression_tag >> 4) & 0x08) !== 0;
+                const branch_flag = is_long_compressed ?
+                    (compression_tag >> 8) & 0xff :
                     0;
                 if (is_data_compressed) {
                     data = data_history[data_history.length - dlen - 1];
@@ -3071,12 +3358,17 @@ function loadDatabase(hooks) {
                     i += dlen;
                 }
                 const branches_start = i;
+                const branch_flag_alphabet = Alphabet.parseFlag(branch_flag, i, input);
+                const branch_count = branch_flag_alphabet ? branch_flag_alphabet.len : branch_flag;
+                if (branch_flag_alphabet) {
+                    i += branch_flag_alphabet.consumed_len_bytes;
+                }
                 // leaf_value_upper
                 i += 2;
                 // branch_nodes
                 for (let j = 0; j < branch_count; j += 1) {
                     const branch_dlen = input[i] & 0x0f;
-                    const branch_leaves_count = ((input[i] >> 4) & 0x0f) + 1;
+                    const branch_leaves_count = (input[i] >> 4) & 0x0f;
                     const branch_leaves_is_run = (input[i] >> 7) !== 0;
                     i += 1;
                     if (!is_pure_suffixes_only_node) {
@@ -3089,7 +3381,9 @@ function loadDatabase(hooks) {
                     }
                 }
                 // branch keys
-                i += branch_count;
+                if (!branch_flag_alphabet) {
+                    i += branch_count;
+                }
                 // leaves
                 if (leaves_is_run) {
                     i += 2;
@@ -3099,7 +3393,7 @@ function loadDatabase(hooks) {
                 if (is_data_compressed) {
                     const clen = (
                         1 + // first compression header byte
-                        (is_long_compressed ? 1 : 0) + // branch count
+                        (is_long_compressed ? 1 : 0) + // branch flag
                         1 + // data length and other flags
                         dlen + // data
                         (i - branches_start) // branches and leaves
@@ -3112,7 +3406,7 @@ function loadDatabase(hooks) {
                         canonical[ci] = input[start + ci];
                         ci += 1;
                     }
-                    canonical[ci] = dlen | no_leaves_flag | 0x40;
+                    canonical[ci] = dlen | 0xc0;
                     ci += 1;
                     for (let j = 0; j < dlen; j += 1) {
                         canonical[ci] = data[j];
@@ -3145,16 +3439,25 @@ function loadDatabase(hooks) {
                         new Uint8Array(input.buffer, i + input.byteOffset, dlen);
                     i += dlen;
                 }
-                const coffset = i;
                 const {
-                    cpbranches,
-                    csbranches,
                     cpnodes,
                     csnodes,
                     consumed_len_bytes: branches_consumed_len_bytes,
                     branches,
                     might_have_prefix_branches,
-                } = makeBranchesFromBinaryData(input, i, compression_tag);
+                    branches_header,
+                    branches_keys,
+                } = no_branches_flag !== 0 ?
+                    {
+                        cpnodes: EMPTY_UINT8,
+                        csnodes: EMPTY_UINT8,
+                        consumed_len_bytes: 0,
+                        branches: EMPTY_SEARCH_TREE_BRANCHES,
+                        might_have_prefix_branches: EMPTY_SEARCH_TREE_BRANCHES,
+                        branches_header: EMPTY_UINT8,
+                        branches_keys: EMPTY_UINT8,
+                    } :
+                    makeBranchesFromBinaryData(input, i, compression_tag);
                 i += branches_consumed_len_bytes;
                 let whole;
                 let suffix;
@@ -3175,10 +3478,11 @@ function loadDatabase(hooks) {
                     );
                     const clen = (
                         // lengths of children and data
-                        (is_data_compressed ? 2 : 3) +
+                        (is_data_compressed ? 1 : 2) +
                         // branches
+                        branches_header.length +
                         csnodes.length +
-                        csbranches.length +
+                        branches_keys.length +
                         // leaves
                         suffix.consumed_len_bytes
                     );
@@ -3192,15 +3496,15 @@ function loadDatabase(hooks) {
                     } else {
                         canonical[ci] = 1;
                         ci += 1;
-                        canonical[ci] = dlen | no_leaves_flag;
+                        canonical[ci] = dlen | no_leaves_flag | no_branches_flag;
                         ci += 1;
                     }
-                    canonical[ci] = input[coffset]; // suffix child count
-                    ci += 1;
+                    canonical.set(branches_header, ci);
+                    ci += branches_header.length;
                     canonical.set(csnodes, ci);
                     ci += csnodes.length;
-                    canonical.set(csbranches, ci);
-                    ci += csbranches.length;
+                    canonical.set(branches_keys, ci);
+                    ci += branches_keys.length;
                     const leavesOffset = i - suffix.consumed_len_bytes;
                     for (let j = leavesOffset; j < i; j += 1) {
                         canonical[ci + j - leavesOffset] = input[j];
@@ -3228,10 +3532,11 @@ function loadDatabase(hooks) {
                         suffix,
                     );
                     const clen = (
-                        4 + // lengths of children and data
+                        2 + // lengths of children and data
                         dlen +
+                        branches_header.length +
                         cpnodes.length + csnodes.length +
-                        cpbranches.length + csbranches.length +
+                        branches_keys.length +
                         whole.consumed_len_bytes +
                         suffix.consumed_len_bytes
                     );
@@ -3241,22 +3546,18 @@ function loadDatabase(hooks) {
                     let ci = 0;
                     canonical[ci] = 0;
                     ci += 1;
-                    canonical[ci] = dlen | no_leaves_flag;
+                    canonical[ci] = dlen | no_leaves_flag | no_branches_flag;
                     ci += 1;
                     canonical.set(data, ci);
                     ci += data.length;
-                    canonical[ci] = input[coffset]; // prefix child count
-                    ci += 1;
-                    canonical[ci] = input[coffset + 1]; // suffix child count
-                    ci += 1;
+                    canonical.set(branches_header, ci);
+                    ci += branches_header.length;
                     canonical.set(cpnodes, ci);
                     ci += cpnodes.length;
                     canonical.set(csnodes, ci);
                     ci += csnodes.length;
-                    canonical.set(cpbranches, ci);
-                    ci += cpbranches.length;
-                    canonical.set(csbranches, ci);
-                    ci += csbranches.length;
+                    canonical.set(branches_keys, ci);
+                    ci += branches_keys.length;
                     const leavesOffset = i - whole.consumed_len_bytes - suffix.consumed_len_bytes;
                     for (let j = leavesOffset; j < i; j += 1) {
                         canonical[ci + j - leavesOffset] = input[j];
@@ -3275,7 +3576,13 @@ function loadDatabase(hooks) {
                     consumed_len_bytes: branches_consumed_len_bytes,
                     branches,
                     might_have_prefix_branches,
-                } = makeBranchesFromBinaryData(input, i, compression_tag);
+                } = no_branches_flag !== 0 ?
+                    {
+                        consumed_len_bytes: 0,
+                        branches: EMPTY_SEARCH_TREE_BRANCHES,
+                        might_have_prefix_branches: EMPTY_SEARCH_TREE_BRANCHES,
+                    } :
+                    makeBranchesFromBinaryData(input, i, compression_tag);
                 i += branches_consumed_len_bytes;
                 let whole;
                 let suffix;
@@ -3317,7 +3624,7 @@ function loadDatabase(hooks) {
                         suffix,
                     );
             }
-            hash[2] &= 0x7f;
+            hash[3] &= 0x7f;
             hash_history.push({hash: truncatedHash.slice(), used: false});
             if (data.length !== 0) {
                 data_history.push(data);
@@ -3330,8 +3637,8 @@ function loadDatabase(hooks) {
                 while (j < lb) {
                     // node id with a 1 in its most significant bit is inlined, and, so
                     // it won't be in the stash
-                    if ((tree_branch_nodeids[j * 6] & 0x80) === 0) {
-                        const subtree = stash.getWithOffsetKey(tree_branch_nodeids, j * 6);
+                    if ((tree_branch_nodeids[j * 5] & 0x80) === 0) {
+                        const subtree = stash.getWithOffsetKey(tree_branch_nodeids, j * 5);
                         if (subtree !== undefined) {
                             tree_branch_subtrees[j] = Promise.resolve(subtree);
                         }
@@ -3347,8 +3654,8 @@ function loadDatabase(hooks) {
                 while (j < lb) {
                     // node id with a 1 in its most significant bit is inlined, and, so
                     // it won't be in the stash
-                    if ((tree_mhp_branch_nodeids[j * 6] & 0x80) === 0) {
-                        const subtree = stash.getWithOffsetKey(tree_mhp_branch_nodeids, j * 6);
+                    if ((tree_mhp_branch_nodeids[j * 5] & 0x80) === 0) {
+                        const subtree = stash.getWithOffsetKey(tree_mhp_branch_nodeids, j * 5);
                         if (subtree !== undefined) {
                             tree_mhp_branch_subtrees[j] = Promise.resolve(subtree);
                         }

From 16dcceb5bc222db8a5a15f057ef767a5799e20d5 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 5 Mar 2026 10:48:06 +1100
Subject: [PATCH 0401/1059] Avoid duplicated query modifier comments.

By removing the ones in `compiler/rustc_middle/src/queries.rs`, and
making `compiler/rustc_middle/src/query/modifiers.rs` the single
source of truth.
---
 compiler/rustc_middle/src/queries.rs         | 20 +---------
 compiler/rustc_middle/src/query/modifiers.rs | 41 ++++++++++++++------
 2 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 25ac06a6ed09..d4d9b9c0189d 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -23,26 +23,10 @@
 //! ## Query Modifiers
 //!
 //! Query modifiers are special flags that alter the behavior of a query. They are parsed and processed by the `rustc_macros`
-//! The main modifiers are:
 //!
-//! - `desc { ... }`: Sets the human-readable description for diagnostics and profiling. Required
-//!   for every query. The block should contain a `format!`-style string literal followed by
-//!   optional arguments. The query key identifier is available for use within the block, as is
-//!   `tcx`.
-//! - `arena_cache`: Use an arena for in-memory caching of the query result.
-//! - `cache_on_disk_if { ... }`: Cache the query result to disk if the provided block evaluates to
-//!   true. The query key identifier is available for use within the block, as is `tcx`.
-//! - `cycle_delay_bug`: If a dependency cycle is detected, emit a delayed bug instead of aborting immediately.
-//! - `no_hash`: Do not hash the query result for incremental compilation; just mark as dirty if recomputed.
-//! - `anon`: Make the query anonymous in the dependency graph (no dep node is created).
-//! - `eval_always`: Always evaluate the query, ignoring its dependencies and cached results.
-//! - `depth_limit`: Impose a recursion depth limit on the query to prevent stack overflows.
-//! - `separate_provide_extern`: Use separate provider functions for local and external crates.
-//! - `feedable`: Allow the query result to be set from another query ("fed" externally).
+//! For the list of modifiers, see [`rustc_middle::query::modifiers`].
 //!
-//! For the up-to-date list, see the `QueryModifiers` struct in
-//! [`rustc_macros/src/query.rs`](https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_macros/src/query.rs)
-//! and for more details in incremental compilation, see the
+//! For more details on incremental compilation, see the
 //! [Query modifiers in incremental compilation](https://rustc-dev-guide.rust-lang.org/queries/incremental-compilation-in-detail.html#query-modifiers) section of the rustc-dev-guide.
 //!
 //! ## Query Expansion and Code Generation
diff --git a/compiler/rustc_middle/src/query/modifiers.rs b/compiler/rustc_middle/src/query/modifiers.rs
index eb9fc330a231..100d1ac52769 100644
--- a/compiler/rustc_middle/src/query/modifiers.rs
+++ b/compiler/rustc_middle/src/query/modifiers.rs
@@ -4,43 +4,59 @@
 //! modifier names in the query list, and to allow find-all-references to list
 //! all queries that use a particular modifier.
 #![allow(unused, non_camel_case_types)]
-// FIXME: Update and clarify documentation for these modifiers.
 
 // tidy-alphabetical-start
 //
 /// # `anon` query modifier
 ///
-/// Generate a dep node based on the dependencies of the query
+/// Generate a dep node based not on the query key, but on the query's dependencies.
 pub(crate) struct anon;
 
 /// # `arena_cache` query modifier
 ///
-/// Use this type for the in-memory cache.
+/// Query return values must impl `Copy` and be small, but some queries must return values that
+/// doesn't meet those criteria. Queries marked with this modifier have their values allocated in
+/// an arena and the query returns a reference to the value. There are two cases.
+/// - If the provider function returns `T` then the query will return `&'tcx T`.
+/// - If the provider function returns `Option<T>` then the query will return `Option<&'tcx T>`.
+///
+/// The query plumbing takes care of the arenas and the type manipulations.
 pub(crate) struct arena_cache;
 
-/// # `cache_on_disk_if` query modifier
+/// # `cache_on_disk_if { ... }` query modifier
 ///
-/// Cache the query to disk if the `Block` returns true.
+/// Cache the query result to disk if the provided block evaluates to true. The query key
+/// identifier is available for use within the block, as is `tcx`.
 pub(crate) struct cache_on_disk_if;
 
 /// # `cycle_delay_bug` query modifier
 ///
-/// A cycle error results in a delay_bug call
+/// If a dependency cycle is detected, emit a delayed bug instead of a normal error.
 pub(crate) struct cycle_delay_bug;
 
 /// # `depth_limit` query modifier
 ///
-/// Whether the query has a call depth limit
+/// Impose a recursion call depth limit on the query to prevent stack overflow.
 pub(crate) struct depth_limit;
 
-/// # `desc` query modifier
+/// # `desc { ... }` query modifier
 ///
-/// The description of the query. This modifier is required on every query.
+/// The human-readable description of the query, for diagnostics and profiling. Required for every
+/// query. The block should contain a `format!`-style string literal followed by optional
+/// arguments. The query key identifier is available for use within the block, as is `tcx`.
 pub(crate) struct desc;
 
 /// # `eval_always` query modifier
 ///
-/// Always evaluate the query, ignoring its dependencies
+/// Queries with this modifier do not track their dependencies, and are treated as always having a
+/// red (dirty) dependency instead. This is necessary for queries that interact with state that
+/// isn't tracked by the query system.
+///
+/// It can also improve performance for queries that are so likely to be dirtied by any change that
+/// it's not worth tracking their actual dependencies at all.
+///
+/// As with all queries, the return value is still cached in memory for the rest of the compiler
+/// session.
 pub(crate) struct eval_always;
 
 /// # `feedable` query modifier
@@ -50,12 +66,13 @@
 
 /// # `no_hash` query modifier
 ///
-/// Don't hash the result, instead just mark a query red if it runs
+/// Do not hash the query's return value for incremental compilation. If the value needs to be
+/// recomputed, always mark its node as red (dirty).
 pub(crate) struct no_hash;
 
 /// # `separate_provide_extern` query modifier
 ///
-/// Use a separate query provider for local and extern crates
+/// Use separate query provider functions for local and extern crates.
 pub(crate) struct separate_provide_extern;
 
 // tidy-alphabetical-end

From 73e56e8e86d9ea3f9643b5b977203df262c8ce6c Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 12 Mar 2026 10:58:18 +1100
Subject: [PATCH 0402/1059] Don't recompute `key_hash` in `wait_for_query`.

We compute `key_hash` in `try_execute_query`, so we can just pass the
value in.
---
 compiler/rustc_query_impl/src/execution.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index d8dc004f1cf7..eab9eaef35ca 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -240,6 +240,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
     tcx: TyCtxt<'tcx>,
     span: Span,
     key: C::Key,
+    key_hash: u64,
     latch: QueryLatch<'tcx>,
     current: Option<QueryJobId>,
 ) -> (C::Value, Option<DepNodeIndex>) {
@@ -248,8 +249,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
     // self-profiler.
     let query_blocked_prof_timer = tcx.prof.query_blocked();
 
-    // With parallel queries we might just have to wait on some other
-    // thread.
+    // With parallel queries we might just have to wait on some other thread.
     let result = latch.wait_on(tcx, current, span);
 
     match result {
@@ -258,7 +258,6 @@ fn wait_for_query<'tcx, C: QueryCache>(
                 outline(|| {
                     // We didn't find the query result in the query cache. Check if it was
                     // poisoned due to a panic instead.
-                    let key_hash = sharded::make_hash(&key);
                     let shard = query.state.active.lock_shard_by_hash(key_hash);
                     match shard.find(key_hash, equivalent_key(key)) {
                         // The query we waited on panicked. Continue unwinding here.
@@ -311,8 +310,8 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
     match state_lock.entry(key_hash, equivalent_key(key), |(k, _)| sharded::make_hash(k)) {
         Entry::Vacant(entry) => {
-            // Nothing has computed or is computing the query, so we start a new job and insert it in the
-            // state map.
+            // Nothing has computed or is computing the query, so we start a new job and insert it
+            // in the state map.
             let id = next_job_id(tcx);
             let job = QueryJob::new(id, span, current_job_id);
             entry.insert((key, ActiveKeyStatus::Started(job)));
@@ -332,7 +331,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
                         // Only call `wait_for_query` if we're using a Rayon thread pool
                         // as it will attempt to mark the worker thread as blocked.
-                        wait_for_query(query, tcx, span, key, latch, current_job_id)
+                        wait_for_query(query, tcx, span, key, key_hash, latch, current_job_id)
                     } else {
                         let id = job.id;
                         drop(state_lock);

From b3b6627dbb183c9b3012f13ca1775eeaa92b3193 Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Thu, 12 Mar 2026 19:55:48 -0700
Subject: [PATCH 0403/1059] Derive Macro Eq: link to more detailed
 documentation

Match the other derive macros in the module (Ord, PartialEq, PartialOrd) by
linking to the section in the trait documentation about how the derive macro
works.
---
 library/core/src/cmp.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index b3dc435dda17..49d7487c2803 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -357,6 +357,7 @@ fn assert_fields_are_eq(&self) {}
 }
 
 /// Derive macro generating an impl of the trait [`Eq`].
+/// The behavior of this macro is described in detail [here](Eq#derivable).
 #[rustc_builtin_macro]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow_internal_unstable(core_intrinsics, derive_eq_internals, structural_match)]

From 8b0c2591fa30da5474a08f584002c237f575f4f4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 12 Mar 2026 11:03:30 +1100
Subject: [PATCH 0404/1059] Inline and remove `execute_job`.

`execute_job` has a single call site in `try_execute_query`. This commit
inlines and removes `execute_job`, but also puts the part that checks
feedable results in its own separate function, `check_feedable`, because
it's a nicely separate piece of logic.

The big win here is that all the code dealing with the `QueryState` is
now together in `try_execute_query`: get the lock, do the lookup, drop
the lock, create the job guard, and complete the job guard. Previously
these steps were split across two functions which I found hard to
follow.

This commit purely moves code around, there are no other changes.
---
 compiler/rustc_query_impl/src/execution.rs | 110 ++++++++++-----------
 1 file changed, 54 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index eab9eaef35ca..9fe0879d2be4 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -319,7 +319,28 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
             // Drop the lock before we start executing the query
             drop(state_lock);
 
-            execute_job::<C, INCR>(query, tcx, key, key_hash, id, dep_node)
+            // Set up a guard object that will automatically poison the query if a
+            // panic occurs while executing the query (or any intermediate plumbing).
+            let job_guard = ActiveJobGuard { state: &query.state, key, key_hash };
+
+            debug_assert_eq!(tcx.dep_graph.is_fully_enabled(), INCR);
+
+            // Delegate to another function to actually execute the query job.
+            let (value, dep_node_index) = if INCR {
+                execute_job_incr(query, tcx, key, dep_node, id)
+            } else {
+                execute_job_non_incr(query, tcx, key, id)
+            };
+
+            let cache = &query.cache;
+            if query.feedable {
+                check_feedable_consistency(tcx, query, key, &value);
+            }
+
+            // Tell the guard to perform completion bookkeeping, and also to not poison the query.
+            job_guard.complete(cache, value, dep_node_index);
+
+            (value, Some(dep_node_index))
         }
         Entry::Occupied(mut entry) => {
             match &mut entry.get_mut().1 {
@@ -348,67 +369,44 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 }
 
 #[inline(always)]
-fn execute_job<'tcx, C: QueryCache, const INCR: bool>(
-    query: &'tcx QueryVTable<'tcx, C>,
+fn check_feedable_consistency<'tcx, C: QueryCache>(
     tcx: TyCtxt<'tcx>,
+    query: &'tcx QueryVTable<'tcx, C>,
     key: C::Key,
-    key_hash: u64,
-    id: QueryJobId,
-    dep_node: Option<DepNode>,
-) -> (C::Value, Option<DepNodeIndex>) {
-    // Set up a guard object that will automatically poison the query if a
-    // panic occurs while executing the query (or any intermediate plumbing).
-    let job_guard = ActiveJobGuard { state: &query.state, key, key_hash };
+    value: &C::Value,
+) {
+    // We should not compute queries that also got a value via feeding.
+    // This can't happen, as query feeding adds the very dependencies to the fed query
+    // as its feeding query had. So if the fed query is red, so is its feeder, which will
+    // get evaluated first, and re-feed the query.
+    let Some((cached_value, _)) = query.cache.lookup(&key) else { return };
 
-    debug_assert_eq!(tcx.dep_graph.is_fully_enabled(), INCR);
-
-    // Delegate to another function to actually execute the query job.
-    let (value, dep_node_index) = if INCR {
-        execute_job_incr(query, tcx, key, dep_node, id)
-    } else {
-        execute_job_non_incr(query, tcx, key, id)
+    let Some(hash_value_fn) = query.hash_value_fn else {
+        panic!(
+            "no_hash fed query later has its value computed.\n\
+            Remove `no_hash` modifier to allow recomputation.\n\
+            The already cached value: {}",
+            (query.format_value)(&cached_value)
+        );
     };
 
-    let cache = &query.cache;
-    if query.feedable {
-        // We should not compute queries that also got a value via feeding.
-        // This can't happen, as query feeding adds the very dependencies to the fed query
-        // as its feeding query had. So if the fed query is red, so is its feeder, which will
-        // get evaluated first, and re-feed the query.
-        if let Some((cached_value, _)) = cache.lookup(&key) {
-            let Some(hash_value_fn) = query.hash_value_fn else {
-                panic!(
-                    "no_hash fed query later has its value computed.\n\
-                    Remove `no_hash` modifier to allow recomputation.\n\
-                    The already cached value: {}",
-                    (query.format_value)(&cached_value)
-                );
-            };
-
-            let (old_hash, new_hash) = tcx.with_stable_hashing_context(|mut hcx| {
-                (hash_value_fn(&mut hcx, &cached_value), hash_value_fn(&mut hcx, &value))
-            });
-            let formatter = query.format_value;
-            if old_hash != new_hash {
-                // We have an inconsistency. This can happen if one of the two
-                // results is tainted by errors.
-                assert!(
-                    tcx.dcx().has_errors().is_some(),
-                    "Computed query value for {:?}({:?}) is inconsistent with fed value,\n\
-                        computed={:#?}\nfed={:#?}",
-                    query.dep_kind,
-                    key,
-                    formatter(&value),
-                    formatter(&cached_value),
-                );
-            }
-        }
+    let (old_hash, new_hash) = tcx.with_stable_hashing_context(|mut hcx| {
+        (hash_value_fn(&mut hcx, &cached_value), hash_value_fn(&mut hcx, value))
+    });
+    let formatter = query.format_value;
+    if old_hash != new_hash {
+        // We have an inconsistency. This can happen if one of the two
+        // results is tainted by errors.
+        assert!(
+            tcx.dcx().has_errors().is_some(),
+            "Computed query value for {:?}({:?}) is inconsistent with fed value,\n\
+                computed={:#?}\nfed={:#?}",
+            query.dep_kind,
+            key,
+            formatter(value),
+            formatter(&cached_value),
+        );
     }
-
-    // Tell the guard to perform completion bookkeeping, and also to not poison the query.
-    job_guard.complete(cache, value, dep_node_index);
-
-    (value, Some(dep_node_index))
 }
 
 // Fast path for when incr. comp. is off.

From f0c27602b1dc19f939e51cf907d9bedfc6ae5088 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 12 Mar 2026 12:09:40 +1100
Subject: [PATCH 0405/1059] Some tiny improvements to `try_execute_query`.

The previous commit inlined `execute_job` without changing any of its
code. This commit does a few tiny follow-up changes.
---
 compiler/rustc_query_impl/src/execution.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 9fe0879d2be4..bc21dc54f634 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -316,7 +316,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
             let job = QueryJob::new(id, span, current_job_id);
             entry.insert((key, ActiveKeyStatus::Started(job)));
 
-            // Drop the lock before we start executing the query
+            // Drop the lock before we start executing the query.
             drop(state_lock);
 
             // Set up a guard object that will automatically poison the query if a
@@ -332,13 +332,13 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
                 execute_job_non_incr(query, tcx, key, id)
             };
 
-            let cache = &query.cache;
             if query.feedable {
                 check_feedable_consistency(tcx, query, key, &value);
             }
 
-            // Tell the guard to perform completion bookkeeping, and also to not poison the query.
-            job_guard.complete(cache, value, dep_node_index);
+            // Tell the guard to insert `value` in the cache and remove the status entry from
+            // `query.state`.
+            job_guard.complete(&query.cache, value, dep_node_index);
 
             (value, Some(dep_node_index))
         }

From 3add6f19d0a4370c198ec83a248ce7bad9de9c6a Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Thu, 12 Mar 2026 21:37:19 -0700
Subject: [PATCH 0406/1059] rustfmt.toml: drop ignore of deleted test

---
 rustfmt.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rustfmt.toml b/rustfmt.toml
index 4750b8541457..60808190d8a5 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -20,7 +20,6 @@ ignore = [
     "/tests/incremental/",            # These tests are somewhat sensitive to source code layout.
     "/tests/pretty/",                 # These tests are very sensitive to source code layout.
     "/tests/run-make/export",         # These tests contain syntax errors.
-    "/tests/run-make/translation/test.rs", # This test contains syntax errors.
     "/tests/rustdoc-html/",           # Some have syntax errors, some are whitespace-sensitive.
     "/tests/rustdoc-gui/",            # Some tests are sensitive to source code layout.
     "/tests/rustdoc-ui/",             # Some have syntax errors, some are whitespace-sensitive.

From ea674ecb09a9d6ecd08c3c209b56e3abe084b5cf Mon Sep 17 00:00:00 2001
From: Tim Siegel <siegeltr@gmail.com>
Date: Wed, 4 Mar 2026 14:09:56 -0500
Subject: [PATCH 0407/1059] core: lift FIXME comment from option.rs to
 iter::try_process

This FIXME is relevant not only to Option but other similar cases that
use iter::try_process(). The referenced issue 11084 was closed in 2021,
and the related PR 59605 was not merged due to inconclusive results.
---
 library/core/src/iter/adapters/mod.rs | 3 +++
 library/core/src/option.rs            | 3 ---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs
index d0b89fdbb584..ca950a138f31 100644
--- a/library/core/src/iter/adapters/mod.rs
+++ b/library/core/src/iter/adapters/mod.rs
@@ -155,6 +155,9 @@ pub(crate) fn try_process<I, T, R, F, U>(iter: I, mut f: F) -> ChangeOutputType<
     for<'a> F: FnMut(GenericShunt<'a, I, R>) -> U,
     R: Residual<U>,
 {
+    // FIXME(#11084): we might be able to get rid of GenericShunt in favor of
+    // Iterator::scan, as performance should be comparable
+
     let mut residual = None;
     let shunt = GenericShunt { iter, residual: &mut residual };
     let value = f(shunt);
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 8920ea959eb3..d4dd33b94819 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2758,9 +2758,6 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
     /// so the final value of `shared` is 6 (= `3 + 2 + 1`), not 16.
     #[inline]
     fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V> {
-        // FIXME(#11084): This could be replaced with Iterator::scan when this
-        // performance bug is closed.
-
         iter::try_process(iter.into_iter(), |i| i.collect())
     }
 }

From 49163144b19ea28f8c656090918e75345e1fb032 Mon Sep 17 00:00:00 2001
From: Abhinav <satsyndicate@gmail.com>
Date: Sun, 8 Mar 2026 19:05:28 +0530
Subject: [PATCH 0408/1059] Fix grammar in Pin documentation

---
 library/core/src/pin.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index c4981facc04c..eb92e62aaeb3 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -600,7 +600,7 @@
 //! automatically called [`Pin::get_unchecked_mut`].
 //!
 //! This can never cause a problem in purely safe code because creating a pinning pointer to
-//! a type which has an address-sensitive (thus does not implement `Unpin`) requires `unsafe`,
+//! a type which has address-sensitive states (and thus does not implement `Unpin`) requires `unsafe`,
 //! but it is important to note that choosing to take advantage of pinning-related guarantees
 //! to justify validity in the implementation of your type has consequences for that type's
 //! [`Drop`][Drop] implementation as well: if an element of your type could have been pinned,

From bf631b32835bc0a24e2c496cddba9a473ad37e8a Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Fri, 13 Mar 2026 06:41:11 +0100
Subject: [PATCH 0409/1059] compiletest: Use PYTHONPATH for lldb too, not only
 gdb

That allows you to e.g. run debuginfo tests with lldb-15 on Ubuntu 24.04 like this:

    sudo apt install lldb-15 python3-six
    PYTHONPATH=/usr/lib/python3/dist-packages ./x --set build.lldb=lldb-15 test tests/debuginfo/basic-stepping.rs
---
 .../compiletest/src/runtest/debuginfo.rs      | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/tools/compiletest/src/runtest/debuginfo.rs b/src/tools/compiletest/src/runtest/debuginfo.rs
index 9d6edaddc1b7..6534902e0940 100644
--- a/src/tools/compiletest/src/runtest/debuginfo.rs
+++ b/src/tools/compiletest/src/runtest/debuginfo.rs
@@ -310,12 +310,7 @@ fn run_debuginfo_gdb_test(&self) {
 
             let mut gdb = Command::new(self.config.gdb.as_ref().unwrap());
 
-            // FIXME: we are propagating `PYTHONPATH` from the environment, not a compiletest flag!
-            let pythonpath = if let Ok(pp) = std::env::var("PYTHONPATH") {
-                format!("{pp}:{rust_pp_module_abs_path}")
-            } else {
-                rust_pp_module_abs_path.to_string()
-            };
+            let pythonpath = with_pythonpath_prepended(&rust_pp_module_abs_path);
             gdb.args(debugger_opts).env("PYTHONPATH", pythonpath);
 
             debugger_run_result =
@@ -458,7 +453,8 @@ fn run_lldb(
         debugger_script: &Utf8Path,
     ) -> ProcRes {
         // Path containing `lldb_batchmode.py`, so that the `script` command can import it.
-        let pythonpath = self.config.src_root.join("src/etc");
+        let rust_pp_module_abs_path = self.config.src_root.join("src/etc");
+        let pythonpath = with_pythonpath_prepended(&rust_pp_module_abs_path);
 
         let mut cmd = Command::new(lldb);
         cmd.arg("--one-line")
@@ -471,3 +467,12 @@ fn run_lldb(
         self.run_command_to_procres(&mut cmd)
     }
 }
+
+fn with_pythonpath_prepended(some_path: &Utf8Path) -> String {
+    // FIXME: we are propagating `PYTHONPATH` from the environment, not a compiletest flag!
+    if let Ok(pp) = std::env::var("PYTHONPATH") {
+        format!("{pp}:{some_path}")
+    } else {
+        some_path.to_string()
+    }
+}

From 85967c4de4fbbabf14728a0e7d1cc1c8101da1f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Fri, 6 Mar 2026 10:29:23 +0100
Subject: [PATCH 0410/1059] Add a `TaggedQueryKey` to identify a query instance

---
 Cargo.lock                                    |  1 -
 compiler/rustc_middle/src/query/job.rs        | 16 +---
 compiler/rustc_middle/src/query/mod.rs        |  2 +-
 compiler/rustc_middle/src/query/plumbing.rs   | 90 ++++++++++++++----
 compiler/rustc_middle/src/query/stack.rs      | 94 +------------------
 compiler/rustc_query_impl/Cargo.toml          |  1 -
 compiler/rustc_query_impl/src/execution.rs    | 13 ++-
 .../rustc_query_impl/src/from_cycle_error.rs  | 18 ++--
 compiler/rustc_query_impl/src/job.rs          | 59 ++++++------
 compiler/rustc_query_impl/src/lib.rs          |  2 +-
 compiler/rustc_query_impl/src/plumbing.rs     | 65 +++----------
 11 files changed, 140 insertions(+), 221 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ba41143ff61d..202e801846b8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4575,7 +4575,6 @@ dependencies = [
  "rustc_macros",
  "rustc_middle",
  "rustc_serialize",
- "rustc_session",
  "rustc_span",
  "rustc_thread_pool",
  "tracing",
diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index 923eae045cae..2747935942b5 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -7,21 +7,15 @@
 use rustc_span::Span;
 
 use crate::query::plumbing::CycleError;
-use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+use crate::query::stack::QueryStackFrame;
 use crate::ty::TyCtxt;
 
 /// Represents a span and a query key.
 #[derive(Clone, Debug)]
-pub struct QueryInfo<I> {
+pub struct QueryInfo<'tcx> {
     /// The span corresponding to the reason for which this query was required.
     pub span: Span,
-    pub frame: QueryStackFrame<I>,
-}
-
-impl<'tcx> QueryInfo<QueryStackDeferred<'tcx>> {
-    pub(crate) fn lift(&self) -> QueryInfo<QueryStackFrameExtra> {
-        QueryInfo { span: self.span, frame: self.frame.lift() }
-    }
+    pub frame: QueryStackFrame<'tcx>,
 }
 
 /// A value uniquely identifying an active query job.
@@ -74,7 +68,7 @@ pub struct QueryWaiter<'tcx> {
     pub query: Option<QueryJobId>,
     pub condvar: Condvar,
     pub span: Span,
-    pub cycle: Mutex<Option<CycleError<QueryStackDeferred<'tcx>>>>,
+    pub cycle: Mutex<Option<CycleError<'tcx>>>,
 }
 
 #[derive(Clone, Debug)]
@@ -94,7 +88,7 @@ pub fn wait_on(
         tcx: TyCtxt<'tcx>,
         query: Option<QueryJobId>,
         span: Span,
-    ) -> Result<(), CycleError<QueryStackDeferred<'tcx>>> {
+    ) -> Result<(), CycleError<'tcx>> {
         let mut waiters_guard = self.waiters.lock();
         let Some(waiters) = &mut *waiters_guard else {
             return Ok(()); // already complete
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index ef96ebb83bff..9876441f5218 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -7,7 +7,7 @@
     ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, IntoQueryParam, QueryMode,
     QueryState, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
 };
-pub use self::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
 use crate::ty::TyCtxt;
 
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 33c38adcef05..1337dfc25d69 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -12,9 +12,9 @@
 
 use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
-use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables};
+use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
-use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+use crate::query::stack::QueryStackFrame;
 use crate::query::{QueryCache, QueryInfo, QueryJob};
 use crate::ty::TyCtxt;
 
@@ -60,19 +60,10 @@ pub enum CycleErrorHandling {
 }
 
 #[derive(Clone, Debug)]
-pub struct CycleError<I = QueryStackFrameExtra> {
+pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
-    pub usage: Option<(Span, QueryStackFrame<I>)>,
-    pub cycle: Vec<QueryInfo<I>>,
-}
-
-impl<'tcx> CycleError<QueryStackDeferred<'tcx>> {
-    pub fn lift(&self) -> CycleError<QueryStackFrameExtra> {
-        CycleError {
-            usage: self.usage.as_ref().map(|(span, frame)| (*span, frame.lift())),
-            cycle: self.cycle.iter().map(|info| info.lift()).collect(),
-        }
-    }
+    pub usage: Option<(Span, QueryStackFrame<'tcx>)>,
+    pub cycle: Vec<QueryInfo<'tcx>>,
 }
 
 #[derive(Debug)]
@@ -139,16 +130,12 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     pub value_from_cycle_error: fn(
         tcx: TyCtxt<'tcx>,
         key: C::Key,
-        cycle_error: CycleError,
+        cycle_error: CycleError<'tcx>,
         guar: ErrorGuaranteed,
     ) -> C::Value,
     pub format_value: fn(&C::Value) -> String,
 
-    /// Formats a human-readable description of this query and its key, as
-    /// specified by the `desc` query modifier.
-    ///
-    /// Used when reporting query cycle errors and similar problems.
-    pub description_fn: fn(TyCtxt<'tcx>, C::Key) -> String,
+    pub create_tagged_key: fn(C::Key) -> TaggedQueryKey<'tcx>,
 
     /// Function pointer that is called by the query methods on [`TyCtxt`] and
     /// friends[^1], after they have checked the in-memory cache and found no
@@ -524,6 +511,69 @@ pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
             }
         )*
 
+        /// Identifies a query by kind and key. This is in contrast to `QueryJobId` which is just a number.
+        #[allow(non_camel_case_types)]
+        #[derive(Clone, Debug)]
+        pub enum TaggedQueryKey<'tcx> {
+            $(
+                $name($name::Key<'tcx>),
+            )*
+        }
+
+        impl<'tcx> TaggedQueryKey<'tcx> {
+            /// Formats a human-readable description of this query and its key, as
+            /// specified by the `desc` query modifier.
+            ///
+            /// Used when reporting query cycle errors and similar problems.
+            pub fn description(&self, tcx: TyCtxt<'tcx>) -> String {
+                let (name, description) = ty::print::with_no_queries!(match self {
+                    $(
+                        TaggedQueryKey::$name(key) => (stringify!($name), _description_fns::$name(tcx, *key)),
+                    )*
+                });
+                if tcx.sess.verbose_internals() {
+                    format!("{description} [{name:?}]")
+                } else {
+                    description
+                }
+            }
+
+            /// Returns the default span for this query if `span` is a dummy span.
+            pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
+                if !span.is_dummy() {
+                    return span
+                }
+                if let TaggedQueryKey::def_span(..) = self {
+                    // The `def_span` query is used to calculate `default_span`,
+                    // so exit to avoid infinite recursion.
+                    return DUMMY_SP
+                }
+                match self {
+                    $(
+                        TaggedQueryKey::$name(key) => crate::query::QueryKey::default_span(key, tcx),
+                    )*
+                }
+            }
+
+            pub fn def_kind(&self, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
+                // This is used to reduce code generation as it
+                // can be reused for queries with the same key type.
+                fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
+                    key.key_as_def_id().and_then(|def_id| def_id.as_local()).map(|def_id| tcx.def_kind(def_id))
+                }
+
+                if let TaggedQueryKey::def_kind(..) = self {
+                    // Try to avoid infinite recursion.
+                    return None
+                }
+                match self {
+                    $(
+                        TaggedQueryKey::$name(key) => inner(key, tcx),
+                    )*
+                }
+            }
+        }
+
         /// Holds a `QueryVTable` for each query.
         pub struct QueryVTables<'tcx> {
             $(
diff --git a/compiler/rustc_middle/src/query/stack.rs b/compiler/rustc_middle/src/query/stack.rs
index fd80c7edd602..d47c3523a96b 100644
--- a/compiler/rustc_middle/src/query/stack.rs
+++ b/compiler/rustc_middle/src/query/stack.rs
@@ -1,106 +1,18 @@
 use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::mem::transmute;
-use std::sync::Arc;
 
-use rustc_data_structures::sync::{DynSend, DynSync};
-use rustc_hir::def::DefKind;
-use rustc_span::Span;
 use rustc_span::def_id::DefId;
 
 use crate::dep_graph::DepKind;
+use crate::queries::TaggedQueryKey;
 
 /// Description of a frame in the query stack.
 ///
 /// This is mostly used in case of cycles for error reporting.
 #[derive(Clone, Debug)]
-pub struct QueryStackFrame<I> {
-    /// This field initially stores a `QueryStackDeferred` during collection,
-    /// but can later be changed to `QueryStackFrameExtra` containing concrete information
-    /// by calling `lift`. This is done so that collecting query does not need to invoke
-    /// queries, instead `lift` will call queries in a more appropriate location.
-    pub info: I,
-
+pub struct QueryStackFrame<'tcx> {
+    pub tagged_key: TaggedQueryKey<'tcx>,
     pub dep_kind: DepKind,
     pub def_id: Option<DefId>,
     /// A def-id that is extracted from a `Ty` in a query key
     pub def_id_for_ty_in_cycle: Option<DefId>,
 }
-
-impl<'tcx> QueryStackFrame<QueryStackDeferred<'tcx>> {
-    #[inline]
-    pub fn new(
-        info: QueryStackDeferred<'tcx>,
-        dep_kind: DepKind,
-        def_id: Option<DefId>,
-        def_id_for_ty_in_cycle: Option<DefId>,
-    ) -> Self {
-        Self { info, def_id, dep_kind, def_id_for_ty_in_cycle }
-    }
-
-    pub fn lift(&self) -> QueryStackFrame<QueryStackFrameExtra> {
-        QueryStackFrame {
-            info: self.info.extract(),
-            dep_kind: self.dep_kind,
-            def_id: self.def_id,
-            def_id_for_ty_in_cycle: self.def_id_for_ty_in_cycle,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct QueryStackFrameExtra {
-    pub description: String,
-    pub span: Option<Span>,
-    pub def_kind: Option<DefKind>,
-}
-
-impl QueryStackFrameExtra {
-    #[inline]
-    pub fn new(description: String, span: Option<Span>, def_kind: Option<DefKind>) -> Self {
-        Self { description, span, def_kind }
-    }
-
-    // FIXME(eddyb) Get more valid `Span`s on queries.
-    #[inline]
-    pub fn default_span(&self, span: Span) -> Span {
-        if !span.is_dummy() {
-            return span;
-        }
-        self.span.unwrap_or(span)
-    }
-}
-
-/// Track a 'side effect' for a particular query.
-/// This is used to hold a closure which can create `QueryStackFrameExtra`.
-#[derive(Clone)]
-pub struct QueryStackDeferred<'tcx> {
-    _dummy: PhantomData<&'tcx ()>,
-
-    // `extract` may contain references to 'tcx, but we can't tell drop checking that it won't
-    // access it in the destructor.
-    extract: Arc<dyn Fn() -> QueryStackFrameExtra + DynSync + DynSend>,
-}
-
-impl<'tcx> QueryStackDeferred<'tcx> {
-    pub fn new<C: Copy + DynSync + DynSend + 'tcx>(
-        context: C,
-        extract: fn(C) -> QueryStackFrameExtra,
-    ) -> Self {
-        let extract: Arc<dyn Fn() -> QueryStackFrameExtra + DynSync + DynSend + 'tcx> =
-            Arc::new(move || extract(context));
-        // SAFETY: The `extract` closure does not access 'tcx in its destructor as the only
-        // captured variable is `context` which is Copy and cannot have a destructor.
-        Self { _dummy: PhantomData, extract: unsafe { transmute(extract) } }
-    }
-
-    pub fn extract(&self) -> QueryStackFrameExtra {
-        (self.extract)()
-    }
-}
-
-impl<'tcx> Debug for QueryStackDeferred<'tcx> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("QueryStackDeferred")
-    }
-}
diff --git a/compiler/rustc_query_impl/Cargo.toml b/compiler/rustc_query_impl/Cargo.toml
index 449d2ed5334a..1c3f0f98ae17 100644
--- a/compiler/rustc_query_impl/Cargo.toml
+++ b/compiler/rustc_query_impl/Cargo.toml
@@ -14,7 +14,6 @@ rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_serialize = { path = "../rustc_serialize" }
-rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_thread_pool = { path = "../rustc_thread_pool" }
 tracing = "0.1"
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index d8dc004f1cf7..90bbb7aad522 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -48,7 +48,7 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
     let mut complete = true;
 
     for_each_query_vtable!(ALL, tcx, |query| {
-        let res = gather_active_jobs(query, tcx, require_complete, &mut job_map_out);
+        let res = gather_active_jobs(query, require_complete, &mut job_map_out);
         if res.is_none() {
             complete = false;
         }
@@ -66,7 +66,6 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
 /// grep for.)
 fn gather_active_jobs<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
-    tcx: TyCtxt<'tcx>,
     require_complete: bool,
     job_map_out: &mut QueryJobMap<'tcx>, // Out-param; job info is gathered into this map
 ) -> Option<()>
@@ -113,7 +112,7 @@ fn gather_active_jobs<'tcx, C>(
     // Call `make_frame` while we're not holding a `state.active` lock as `make_frame` may call
     // queries leading to a deadlock.
     for (key, job) in active {
-        let frame = crate::plumbing::create_deferred_query_stack_frame(tcx, query, key);
+        let frame = crate::plumbing::create_query_stack_frame(query, key);
         job_map_out.insert(job.id, QueryJobInfo { frame, job });
     }
 
@@ -126,9 +125,9 @@ fn mk_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     key: C::Key,
-    cycle_error: CycleError,
+    cycle_error: CycleError<'tcx>,
 ) -> C::Value {
-    let error = report_cycle(tcx.sess, &cycle_error);
+    let error = report_cycle(tcx, &cycle_error);
     match query.cycle_error_handling {
         CycleErrorHandling::Error => {
             let guar = error.emit();
@@ -231,7 +230,7 @@ fn cycle_error<'tcx, C: QueryCache>(
         .expect("failed to collect active queries");
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
-    (mk_cycle(query, tcx, key, error.lift()), None)
+    (mk_cycle(query, tcx, key, error), None)
 }
 
 #[inline(always)]
@@ -276,7 +275,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
 
             (v, Some(index))
         }
-        Err(cycle) => (mk_cycle(query, tcx, key, cycle.lift()), None),
+        Err(cycle) => (mk_cycle(query, tcx, key, cycle), None),
     }
 }
 
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index c69d3eb9a0f0..10baaa9209d0 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -45,7 +45,11 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
         |tcx, _, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
 }
 
-pub(crate) fn default<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError, query_name: &str) -> ! {
+pub(crate) fn default<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cycle_error: CycleError<'tcx>,
+    query_name: &str,
+) -> ! {
     let Some(guar) = tcx.sess.dcx().has_errors() else {
         bug!(
             "`from_cycle_error_default` on query `{query_name}` called without errors: {:#?}",
@@ -82,7 +86,7 @@ fn fn_sig<'tcx>(
 
 fn check_representability<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    cycle_error: CycleError<'tcx>,
     _guar: ErrorGuaranteed,
 ) -> ! {
     let mut item_and_field_ids = Vec::new();
@@ -91,7 +95,7 @@ fn check_representability<'tcx>(
         if info.frame.dep_kind == DepKind::check_representability
             && let Some(field_id) = info.frame.def_id
             && let Some(field_id) = field_id.as_local()
-            && let Some(DefKind::Field) = info.frame.info.def_kind
+            && let Some(DefKind::Field) = info.frame.tagged_key.def_kind(tcx)
         {
             let parent_id = tcx.parent(field_id.to_def_id());
             let item_id = match tcx.def_kind(parent_id) {
@@ -118,7 +122,7 @@ fn check_representability<'tcx>(
 
 fn variances_of<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    cycle_error: CycleError<'tcx>,
     _guar: ErrorGuaranteed,
 ) -> &'tcx [ty::Variance] {
     search_for_cycle_permutation(
@@ -164,7 +168,7 @@ fn search_for_cycle_permutation<Q, T>(
 
 fn layout_of<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    cycle_error: CycleError<'tcx>,
     _guar: ErrorGuaranteed,
 ) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
     let diag = search_for_cycle_permutation(
@@ -205,7 +209,7 @@ fn layout_of<'tcx>(
                         continue;
                     };
                     let frame_span =
-                        info.frame.info.default_span(cycle[(i + 1) % cycle.len()].span);
+                        info.frame.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
                     if frame_span.is_dummy() {
                         continue;
                     }
@@ -239,7 +243,7 @@ fn layout_of<'tcx>(
                 ControlFlow::Continue(())
             }
         },
-        || report_cycle(tcx.sess, &cycle_error),
+        || report_cycle(tcx, &cycle_error),
     );
 
     let guar = diag.emit();
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 01f36d06c047..ae32ad01b157 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -7,11 +7,9 @@
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
 use rustc_middle::query::{
-    CycleError, QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryStackDeferred, QueryStackFrame,
-    QueryWaiter,
+    CycleError, QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
 };
 use rustc_middle::ty::TyCtxt;
-use rustc_session::Session;
 use rustc_span::{DUMMY_SP, Span};
 
 use crate::execution::collect_active_jobs_from_all_queries;
@@ -31,7 +29,7 @@ pub(crate) fn insert(&mut self, id: QueryJobId, info: QueryJobInfo<'tcx>) {
         self.map.insert(id, info);
     }
 
-    fn frame_of(&self, id: QueryJobId) -> &QueryStackFrame<QueryStackDeferred<'tcx>> {
+    fn frame_of(&self, id: QueryJobId) -> &QueryStackFrame<'tcx> {
         &self.map[&id].frame
     }
 
@@ -50,7 +48,7 @@ fn latch_of(&self, id: QueryJobId) -> Option<&QueryLatch<'tcx>> {
 
 #[derive(Clone, Debug)]
 pub(crate) struct QueryJobInfo<'tcx> {
-    pub(crate) frame: QueryStackFrame<QueryStackDeferred<'tcx>>,
+    pub(crate) frame: QueryStackFrame<'tcx>,
     pub(crate) job: QueryJob<'tcx>,
 }
 
@@ -59,7 +57,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
     job_map: QueryJobMap<'tcx>,
     current_job: &Option<QueryJobId>,
     span: Span,
-) -> CycleError<QueryStackDeferred<'tcx>> {
+) -> CycleError<'tcx> {
     // Find the waitee amongst `current_job` parents
     let mut cycle = Vec::new();
     let mut current_job = Option::clone(current_job);
@@ -395,12 +393,12 @@ pub fn print_query_stack<'tcx>(
         let Some(query_info) = job_map.map.get(&query) else {
             break;
         };
-        let query_extra = query_info.frame.info.extract();
+        let description = query_info.frame.tagged_key.description(tcx);
         if Some(count_printed) < limit_frames || limit_frames.is_none() {
             // Only print to stderr as many stack frames as `num_frames` when present.
             dcx.struct_failure_note(format!(
                 "#{} [{:?}] {}",
-                count_printed, query_info.frame.dep_kind, query_extra.description
+                count_printed, query_info.frame.dep_kind, description
             ))
             .with_span(query_info.job.span)
             .emit();
@@ -411,7 +409,7 @@ pub fn print_query_stack<'tcx>(
             let _ = writeln!(
                 file,
                 "#{} [{:?}] {}",
-                count_total, query_info.frame.dep_kind, query_extra.description
+                count_total, query_info.frame.dep_kind, description
             );
         }
 
@@ -427,18 +425,18 @@ pub fn print_query_stack<'tcx>(
 
 #[inline(never)]
 #[cold]
-pub(crate) fn report_cycle<'a>(
-    sess: &'a Session,
-    CycleError { usage, cycle: stack }: &CycleError,
-) -> Diag<'a> {
+pub(crate) fn report_cycle<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    CycleError { usage, cycle: stack }: &CycleError<'tcx>,
+) -> Diag<'tcx> {
     assert!(!stack.is_empty());
 
-    let span = stack[0].frame.info.default_span(stack[1 % stack.len()].span);
+    let span = stack[0].frame.tagged_key.default_span(tcx, stack[1 % stack.len()].span);
 
     let mut cycle_stack = Vec::new();
 
     use crate::error::StackCount;
-    let stack_bottom = stack[0].frame.info.description.to_owned();
+    let stack_bottom = stack[0].frame.tagged_key.description(tcx);
     let stack_count = if stack.len() == 1 {
         StackCount::Single { stack_bottom: stack_bottom.clone() }
     } else {
@@ -447,27 +445,32 @@ pub(crate) fn report_cycle<'a>(
 
     for i in 1..stack.len() {
         let frame = &stack[i].frame;
-        let span = frame.info.default_span(stack[(i + 1) % stack.len()].span);
+        let span = frame.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
         cycle_stack
-            .push(crate::error::CycleStack { span, desc: frame.info.description.to_owned() });
+            .push(crate::error::CycleStack { span, desc: frame.tagged_key.description(tcx) });
     }
 
     let mut cycle_usage = None;
     if let Some((span, ref query)) = *usage {
         cycle_usage = Some(crate::error::CycleUsage {
-            span: query.info.default_span(span),
-            usage: query.info.description.to_string(),
+            span: query.tagged_key.default_span(tcx, span),
+            usage: query.tagged_key.description(tcx),
         });
     }
 
-    let alias =
-        if stack.iter().all(|entry| matches!(entry.frame.info.def_kind, Some(DefKind::TyAlias))) {
-            Some(crate::error::Alias::Ty)
-        } else if stack.iter().all(|entry| entry.frame.info.def_kind == Some(DefKind::TraitAlias)) {
-            Some(crate::error::Alias::Trait)
-        } else {
-            None
-        };
+    let alias = if stack
+        .iter()
+        .all(|entry| matches!(entry.frame.tagged_key.def_kind(tcx), Some(DefKind::TyAlias)))
+    {
+        Some(crate::error::Alias::Ty)
+    } else if stack
+        .iter()
+        .all(|entry| entry.frame.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
+    {
+        Some(crate::error::Alias::Trait)
+    } else {
+        None
+    };
 
     let cycle_diag = crate::error::Cycle {
         span,
@@ -479,5 +482,5 @@ pub(crate) fn report_cycle<'a>(
         note_span: (),
     };
 
-    sess.dcx().create_err(cycle_diag)
+    tcx.sess.dcx().create_err(cycle_diag)
 }
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 41642f66967d..aaf9c78feb7f 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -10,7 +10,7 @@
 
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::dep_graph;
-use rustc_middle::queries::{self, ExternProviders, Providers};
+use rustc_middle::queries::{self, ExternProviders, Providers, TaggedQueryKey};
 use rustc_middle::query::on_disk_cache::OnDiskCache;
 use rustc_middle::query::plumbing::{QuerySystem, QueryVTable};
 use rustc_middle::query::{AsLocalQueryKey, QueryCache, QueryMode};
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 78d5fd3de1f0..0a84a8b23c07 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -18,14 +18,10 @@
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
 };
 use rustc_middle::query::plumbing::QueryVTable;
-use rustc_middle::query::{
-    QueryCache, QueryJobId, QueryKey, QueryMode, QueryStackDeferred, QueryStackFrame,
-    QueryStackFrameExtra, erase,
-};
+use rustc_middle::query::{QueryCache, QueryJobId, QueryKey, QueryMode, QueryStackFrame, erase};
+use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::codec::TyEncoder;
-use rustc_middle::ty::print::with_reduced_queries;
 use rustc_middle::ty::tls::{self, ImplicitCtxt};
-use rustc_middle::ty::{self, TyCtxt};
 use rustc_serialize::{Decodable, Encodable};
 use rustc_span::DUMMY_SP;
 use rustc_span::def_id::LOCAL_CRATE;
@@ -47,7 +43,7 @@ fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
 
     tcx.sess.dcx().emit_fatal(QueryOverflow {
         span: info.job.span,
-        note: QueryOverflowNote { desc: info.frame.info.extract().description, depth },
+        note: QueryOverflowNote { desc: info.frame.tagged_key.description(tcx), depth },
         suggested_limit,
         crate_name: tcx.crate_name(LOCAL_CRATE),
     });
@@ -90,60 +86,23 @@ pub(crate) fn start_query<R>(
     })
 }
 
-/// The deferred part of a deferred query stack frame.
-fn mk_query_stack_frame_extra<'tcx, Cache>(
-    (tcx, vtable, key): (TyCtxt<'tcx>, &'tcx QueryVTable<'tcx, Cache>, Cache::Key),
-) -> QueryStackFrameExtra
-where
-    Cache: QueryCache,
-    Cache::Key: QueryKey,
-{
-    let def_id = key.key_as_def_id();
-
-    // If reduced queries are requested, we may be printing a query stack due
-    // to a panic. Avoid using `default_span` and `def_kind` in that case.
-    let reduce_queries = with_reduced_queries();
-
-    // Avoid calling queries while formatting the description
-    let description = ty::print::with_no_queries!((vtable.description_fn)(tcx, key));
-    let description = if tcx.sess.verbose_internals() {
-        format!("{description} [{name:?}]", name = vtable.name)
-    } else {
-        description
-    };
-    let span = if vtable.dep_kind == DepKind::def_span || reduce_queries {
-        // The `def_span` query is used to calculate `default_span`,
-        // so exit to avoid infinite recursion.
-        None
-    } else {
-        Some(key.default_span(tcx))
-    };
-
-    let def_kind = if vtable.dep_kind == DepKind::def_kind || reduce_queries {
-        // Try to avoid infinite recursion.
-        None
-    } else {
-        def_id.and_then(|def_id| def_id.as_local()).map(|def_id| tcx.def_kind(def_id))
-    };
-    QueryStackFrameExtra::new(description, span, def_kind)
-}
-
-pub(crate) fn create_deferred_query_stack_frame<'tcx, C>(
-    tcx: TyCtxt<'tcx>,
+pub(crate) fn create_query_stack_frame<'tcx, C>(
     vtable: &'tcx QueryVTable<'tcx, C>,
     key: C::Key,
-) -> QueryStackFrame<QueryStackDeferred<'tcx>>
+) -> QueryStackFrame<'tcx>
 where
     C: QueryCache<Key: QueryKey + DynSend + DynSync>,
     QueryVTable<'tcx, C>: DynSync,
 {
-    let kind = vtable.dep_kind;
-
     let def_id: Option<DefId> = key.key_as_def_id();
     let def_id_for_ty_in_cycle: Option<DefId> = key.def_id_for_ty_in_cycle();
 
-    let info = QueryStackDeferred::new((tcx, vtable, key), mk_query_stack_frame_extra);
-    QueryStackFrame::new(info, kind, def_id, def_id_for_ty_in_cycle)
+    QueryStackFrame {
+        tagged_key: (vtable.create_tagged_key)(key),
+        dep_kind: vtable.dep_kind,
+        def_id,
+        def_id_for_ty_in_cycle,
+    }
 }
 
 pub(crate) fn encode_all_query_results<'tcx>(
@@ -500,7 +459,7 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                     }),
 
                     format_value: |value| format!("{:?}", erase::restore_val::<queries::$name::Value<'tcx>>(*value)),
-                    description_fn: $crate::queries::_description_fns::$name,
+                    create_tagged_key: TaggedQueryKey::$name,
                     execute_query_fn: if incremental {
                         query_impl::$name::execute_query_incr::__rust_end_short_backtrace
                     } else {

From 9e97c57cc8fff134c6beb7d1e520c2724d7a0a75 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 13 Mar 2026 10:00:39 +0000
Subject: [PATCH 0411/1059] relocate several ui tests

---
 tests/ui/README.md                                     | 10 ----------
 .../box-arithmetic-14915.rs                            |  0
 .../box-arithmetic-14915.stderr                        |  0
 .../less-than-greater-than.rs                          |  0
 .../less-than-greater-than.stderr                      |  0
 tests/ui/{operator-recovery => binop}/spaceship.rs     |  0
 tests/ui/{operator-recovery => binop}/spaceship.stderr |  0
 .../removed-syntax-obsolete-in-place.rs}               |  0
 .../removed-syntax-obsolete-in-place.stderr}           |  4 ++--
 9 files changed, 2 insertions(+), 12 deletions(-)
 rename tests/ui/{operator-recovery => binop}/box-arithmetic-14915.rs (100%)
 rename tests/ui/{operator-recovery => binop}/box-arithmetic-14915.stderr (100%)
 rename tests/ui/{operator-recovery => binop}/less-than-greater-than.rs (100%)
 rename tests/ui/{operator-recovery => binop}/less-than-greater-than.stderr (100%)
 rename tests/ui/{operator-recovery => binop}/spaceship.rs (100%)
 rename tests/ui/{operator-recovery => binop}/spaceship.stderr (100%)
 rename tests/ui/{obsolete-in-place/bad.rs => parser/removed-syntax/removed-syntax-obsolete-in-place.rs} (100%)
 rename tests/ui/{obsolete-in-place/bad.stderr => parser/removed-syntax/removed-syntax-obsolete-in-place.stderr} (77%)

diff --git a/tests/ui/README.md b/tests/ui/README.md
index 248f1208d8d9..9911353af5cd 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -1000,12 +1000,6 @@ Tests on lifetimes on objects, such as a lifetime bound not being able to be ded
 
 **FIXME**: Just a more specific subset of `ui/lifetimes`.
 
-## `tests/ui/obsolete-in-place/`
-
-Contains a single test. Check that we reject the ancient Rust syntax `x <- y` and `in(BINDING) {}` construct.
-
-**FIXME**: Definitely should be rehomed, maybe to `tests/ui/deprecation/`.
-
 ## `tests/ui/offload`
 
 Exercises the offload feature.
@@ -1023,10 +1017,6 @@ Exercises the [`std::mem::offset_of` macro](https://doc.rust-lang.org/beta/std/m
 
 Exercises the `#[rustc_on_unimplemented]`.
 
-## `tests/ui/operator-recovery/`
-
-**FIXME**: Probably move under `tests/ui/binop/` or `tests/ui/parser/`.
-
 ## `tests/ui/or-patterns/`
 
 Exercises `||` and `|` in patterns.
diff --git a/tests/ui/operator-recovery/box-arithmetic-14915.rs b/tests/ui/binop/box-arithmetic-14915.rs
similarity index 100%
rename from tests/ui/operator-recovery/box-arithmetic-14915.rs
rename to tests/ui/binop/box-arithmetic-14915.rs
diff --git a/tests/ui/operator-recovery/box-arithmetic-14915.stderr b/tests/ui/binop/box-arithmetic-14915.stderr
similarity index 100%
rename from tests/ui/operator-recovery/box-arithmetic-14915.stderr
rename to tests/ui/binop/box-arithmetic-14915.stderr
diff --git a/tests/ui/operator-recovery/less-than-greater-than.rs b/tests/ui/binop/less-than-greater-than.rs
similarity index 100%
rename from tests/ui/operator-recovery/less-than-greater-than.rs
rename to tests/ui/binop/less-than-greater-than.rs
diff --git a/tests/ui/operator-recovery/less-than-greater-than.stderr b/tests/ui/binop/less-than-greater-than.stderr
similarity index 100%
rename from tests/ui/operator-recovery/less-than-greater-than.stderr
rename to tests/ui/binop/less-than-greater-than.stderr
diff --git a/tests/ui/operator-recovery/spaceship.rs b/tests/ui/binop/spaceship.rs
similarity index 100%
rename from tests/ui/operator-recovery/spaceship.rs
rename to tests/ui/binop/spaceship.rs
diff --git a/tests/ui/operator-recovery/spaceship.stderr b/tests/ui/binop/spaceship.stderr
similarity index 100%
rename from tests/ui/operator-recovery/spaceship.stderr
rename to tests/ui/binop/spaceship.stderr
diff --git a/tests/ui/obsolete-in-place/bad.rs b/tests/ui/parser/removed-syntax/removed-syntax-obsolete-in-place.rs
similarity index 100%
rename from tests/ui/obsolete-in-place/bad.rs
rename to tests/ui/parser/removed-syntax/removed-syntax-obsolete-in-place.rs
diff --git a/tests/ui/obsolete-in-place/bad.stderr b/tests/ui/parser/removed-syntax/removed-syntax-obsolete-in-place.stderr
similarity index 77%
rename from tests/ui/obsolete-in-place/bad.stderr
rename to tests/ui/parser/removed-syntax/removed-syntax-obsolete-in-place.stderr
index a1321a46351a..7cdc85be349a 100644
--- a/tests/ui/obsolete-in-place/bad.stderr
+++ b/tests/ui/parser/removed-syntax/removed-syntax-obsolete-in-place.stderr
@@ -1,5 +1,5 @@
 error: unexpected token: `<-`
-  --> $DIR/bad.rs:5:7
+  --> $DIR/removed-syntax-obsolete-in-place.rs:5:7
    |
 LL |     x <- y;
    |       ^^
@@ -10,7 +10,7 @@ LL |     x < - y;
    |        +
 
 error: expected expression, found keyword `in`
-  --> $DIR/bad.rs:10:5
+  --> $DIR/removed-syntax-obsolete-in-place.rs:10:5
    |
 LL |     in(foo) { bar };
    |     ^^ expected expression

From f1f5709e62e7ffbcedd9702f4c1ecafb01258d99 Mon Sep 17 00:00:00 2001
From: Tony Kan <tianchengkan@gmail.com>
Date: Wed, 11 Mar 2026 19:25:32 -0700
Subject: [PATCH 0412/1059] test(delegation): Add regression tests for #153743
 and #153744

---
 .../ice-non-fn-target-in-trait-impl.rs        | 20 +++++++++++++++++++
 .../ice-non-fn-target-in-trait-impl.stderr    | 15 ++++++++++++++
 2 files changed, 35 insertions(+)
 create mode 100644 tests/ui/delegation/ice-non-fn-target-in-trait-impl.rs
 create mode 100644 tests/ui/delegation/ice-non-fn-target-in-trait-impl.stderr

diff --git a/tests/ui/delegation/ice-non-fn-target-in-trait-impl.rs b/tests/ui/delegation/ice-non-fn-target-in-trait-impl.rs
new file mode 100644
index 000000000000..ebb826f832bc
--- /dev/null
+++ b/tests/ui/delegation/ice-non-fn-target-in-trait-impl.rs
@@ -0,0 +1,20 @@
+// Regression test for #153743 and #153744.
+// Delegation to a module or crate root inside a trait impl
+// should emit a resolution error, not ICE.
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait {
+    fn bar();
+    fn bar2();
+}
+
+impl Trait for () {
+    reuse std::path::<> as bar;
+    //~^ ERROR expected function, found module `std::path`
+    reuse core::<> as bar2;
+    //~^ ERROR expected function, found crate `core`
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/ice-non-fn-target-in-trait-impl.stderr b/tests/ui/delegation/ice-non-fn-target-in-trait-impl.stderr
new file mode 100644
index 000000000000..bed13b0a3a9b
--- /dev/null
+++ b/tests/ui/delegation/ice-non-fn-target-in-trait-impl.stderr
@@ -0,0 +1,15 @@
+error[E0423]: expected function, found module `std::path`
+  --> $DIR/ice-non-fn-target-in-trait-impl.rs:14:11
+   |
+LL |     reuse std::path::<> as bar;
+   |           ^^^^^^^^^^^^^ not a function
+
+error[E0423]: expected function, found crate `core`
+  --> $DIR/ice-non-fn-target-in-trait-impl.rs:16:11
+   |
+LL |     reuse core::<> as bar2;
+   |           ^^^^^^^^ not a function
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0423`.

From 86c5da6b8be5f77354d08748188942c436710a36 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 13 Mar 2026 10:28:04 +0000
Subject: [PATCH 0413/1059] delete some duplicated tests

---
 tests/ui/moves/move-1-unique.rs     | 25 -------------------------
 tests/ui/moves/move-2-unique.rs     | 10 ----------
 tests/ui/moves/move-4-unique.rs     | 18 ------------------
 tests/ui/moves/move-arg-2-unique.rs | 12 ------------
 tests/ui/moves/move-scalar.rs       | 10 ----------
 5 files changed, 75 deletions(-)
 delete mode 100644 tests/ui/moves/move-1-unique.rs
 delete mode 100644 tests/ui/moves/move-2-unique.rs
 delete mode 100644 tests/ui/moves/move-4-unique.rs
 delete mode 100644 tests/ui/moves/move-arg-2-unique.rs
 delete mode 100644 tests/ui/moves/move-scalar.rs

diff --git a/tests/ui/moves/move-1-unique.rs b/tests/ui/moves/move-1-unique.rs
deleted file mode 100644
index c97bfaaaf1a5..000000000000
--- a/tests/ui/moves/move-1-unique.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ run-pass
-#![allow(unused_mut)]
-#![allow(dead_code)]
-
-#[derive(Clone)]
-struct Triple {
-    x: isize,
-    y: isize,
-    z: isize,
-}
-
-fn test(x: bool, foo: Box<Triple>) -> isize {
-    let bar = foo;
-    let mut y: Box<Triple>;
-    if x { y = bar; } else { y = Box::new(Triple{x: 4, y: 5, z: 6}); }
-    return y.y;
-}
-
-pub fn main() {
-    let x: Box<_> = Box::new(Triple{x: 1, y: 2, z: 3});
-    assert_eq!(test(true, x.clone()), 2);
-    assert_eq!(test(true, x.clone()), 2);
-    assert_eq!(test(true, x.clone()), 2);
-    assert_eq!(test(false, x), 5);
-}
diff --git a/tests/ui/moves/move-2-unique.rs b/tests/ui/moves/move-2-unique.rs
deleted file mode 100644
index 2204ea95741d..000000000000
--- a/tests/ui/moves/move-2-unique.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-struct X { x: isize, y: isize, z: isize }
-
-pub fn main() {
-    let x: Box<_> = Box::new(X {x: 1, y: 2, z: 3});
-    let y = x;
-    assert_eq!(y.y, 2);
-}
diff --git a/tests/ui/moves/move-4-unique.rs b/tests/ui/moves/move-4-unique.rs
deleted file mode 100644
index 09e0f11a8b44..000000000000
--- a/tests/ui/moves/move-4-unique.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-struct Triple {a: isize, b: isize, c: isize}
-
-fn test(foo: Box<Triple>) -> Box<Triple> {
-    let foo = foo;
-    let bar = foo;
-    let baz = bar;
-    let quux = baz;
-    return quux;
-}
-
-pub fn main() {
-    let x = Box::new(Triple{a: 1, b: 2, c: 3});
-    let y = test(x);
-    assert_eq!(y.c, 3);
-}
diff --git a/tests/ui/moves/move-arg-2-unique.rs b/tests/ui/moves/move-arg-2-unique.rs
deleted file mode 100644
index d9a03be0ed2d..000000000000
--- a/tests/ui/moves/move-arg-2-unique.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-
-fn test(foo: Box<Vec<isize>> ) { assert_eq!((*foo)[0], 10); }
-
-pub fn main() {
-    let x = Box::new(vec![10]);
-    // Test forgetting a local by move-in
-    test(x);
-
-    // Test forgetting a temporary by move-in.
-    test(Box::new(vec![10]));
-}
diff --git a/tests/ui/moves/move-scalar.rs b/tests/ui/moves/move-scalar.rs
deleted file mode 100644
index e8cf5632b322..000000000000
--- a/tests/ui/moves/move-scalar.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-#![allow(unused_mut)]
-
-pub fn main() {
-
-    let y: isize = 42;
-    let mut x: isize;
-    x = y;
-    assert_eq!(x, 42);
-}

From 1f44a11518096de272003492a8fe2c300dbf2989 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Tue, 3 Mar 2026 11:34:00 +0100
Subject: [PATCH 0414/1059] Replace `visit_waiters` with
 `abstracted_waiters_of`

---
 compiler/rustc_middle/src/query/job.rs |  10 +-
 compiler/rustc_query_impl/src/job.rs   | 159 ++++++++++++++-----------
 2 files changed, 98 insertions(+), 71 deletions(-)

diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index 2747935942b5..b2e5649106ce 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -65,7 +65,7 @@ pub fn signal_complete(self) {
 
 #[derive(Debug)]
 pub struct QueryWaiter<'tcx> {
-    pub query: Option<QueryJobId>,
+    pub parent: Option<QueryJobId>,
     pub condvar: Condvar,
     pub span: Span,
     pub cycle: Mutex<Option<CycleError<'tcx>>>,
@@ -94,8 +94,12 @@ pub fn wait_on(
             return Ok(()); // already complete
         };
 
-        let waiter =
-            Arc::new(QueryWaiter { query, span, cycle: Mutex::new(None), condvar: Condvar::new() });
+        let waiter = Arc::new(QueryWaiter {
+            parent: query,
+            span,
+            cycle: Mutex::new(None),
+            condvar: Condvar::new(),
+        });
 
         // We push the waiter on to the `waiters` list. It can be accessed inside
         // the `wait` call below, by 1) the `set` method or 2) by deadlock detection.
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index ae32ad01b157..900fca23c952 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -111,38 +111,44 @@ pub(crate) fn find_dep_kind_root<'tcx>(
     last_layout
 }
 
-/// A resumable waiter of a query. The usize is the index into waiters in the query's latch
-type Waiter = (QueryJobId, usize);
+/// The locaton of a resumable waiter. The usize is the index into waiters in the query's latch.
+/// We'll use this to remove the waiter using `QueryLatch::extract_waiter` if we're waking it up.
+type ResumableWaiterLocation = (QueryJobId, usize);
 
-/// Visits all the non-resumable and resumable waiters of a query.
-/// Only waiters in a query are visited.
-/// `visit` is called for every waiter and is passed a query waiting on `query`
-/// and a span indicating the reason the query waited on `query`.
-/// If `visit` returns `Break`, this function also returns `Break`,
-/// and if all `visit` calls returns `Continue` it also returns `Continue`.
-/// For visits of non-resumable waiters it returns the return value of `visit`.
-/// For visits of resumable waiters it returns information required to resume that waiter.
-fn visit_waiters<'tcx>(
-    job_map: &QueryJobMap<'tcx>,
-    query: QueryJobId,
-    mut visit: impl FnMut(Span, QueryJobId) -> ControlFlow<Option<Waiter>>,
-) -> ControlFlow<Option<Waiter>> {
-    // Visit the parent query which is a non-resumable waiter since it's on the same stack
-    if let Some(parent) = job_map.parent_of(query) {
-        visit(job_map.span_of(query), parent)?;
-    }
+/// This abstracts over non-resumable waiters which are found in `QueryJob`'s `parent` field
+/// and resumable waiters are in `latch` field.
+struct AbstractedWaiter {
+    /// The span corresponding to the reason for why we're waiting on this query.
+    span: Span,
+    /// The query which we are waiting from, if none the waiter is from a compiler root.
+    parent: Option<QueryJobId>,
+    resumable: Option<ResumableWaiterLocation>,
+}
 
-    // Visit the explicit waiters which use condvars and are resumable
+/// Returns all the non-resumable and resumable waiters of a query.
+/// This is used so we can uniformly loop over both non-resumable and resumable waiters.
+fn abstracted_waiters_of(job_map: &QueryJobMap<'_>, query: QueryJobId) -> Vec<AbstractedWaiter> {
+    let mut result = Vec::new();
+
+    // Add the parent which is a non-resumable waiter since it's on the same stack
+    result.push(AbstractedWaiter {
+        span: job_map.span_of(query),
+        parent: job_map.parent_of(query),
+        resumable: None,
+    });
+
+    // Add the explicit waiters which use condvars and are resumable
     if let Some(latch) = job_map.latch_of(query) {
         for (i, waiter) in latch.waiters.lock().as_ref().unwrap().iter().enumerate() {
-            if let Some(waiter_query) = waiter.query {
-                // Return a value which indicates that this waiter can be resumed
-                visit(waiter.span, waiter_query).map_break(|_| Some((query, i)))?;
-            }
+            result.push(AbstractedWaiter {
+                span: waiter.span,
+                parent: waiter.parent,
+                resumable: Some((query, i)),
+            });
         }
     }
 
-    ControlFlow::Continue(())
+    result
 }
 
 /// Look for query cycles by doing a depth first search starting at `query`.
@@ -155,13 +161,13 @@ fn cycle_check<'tcx>(
     span: Span,
     stack: &mut Vec<(Span, QueryJobId)>,
     visited: &mut FxHashSet<QueryJobId>,
-) -> ControlFlow<Option<Waiter>> {
+) -> ControlFlow<Option<ResumableWaiterLocation>> {
     if !visited.insert(query) {
-        return if let Some(p) = stack.iter().position(|q| q.1 == query) {
+        return if let Some(pos) = stack.iter().position(|q| q.1 == query) {
             // We detected a query cycle, fix up the initial span and return Some
 
             // Remove previous stack entries
-            stack.drain(0..p);
+            stack.drain(0..pos);
             // Replace the span for the first query with the cycle cause
             stack[0].0 = span;
             ControlFlow::Break(None)
@@ -174,16 +180,23 @@ fn cycle_check<'tcx>(
     stack.push((span, query));
 
     // Visit all the waiters
-    let r = visit_waiters(job_map, query, |span, successor| {
-        cycle_check(job_map, successor, span, stack, visited)
-    });
-
-    // Remove the entry in our stack if we didn't find a cycle
-    if r.is_continue() {
-        stack.pop();
+    for abstracted_waiter in abstracted_waiters_of(job_map, query) {
+        let Some(parent) = abstracted_waiter.parent else {
+            // Skip waiters which are not queries
+            continue;
+        };
+        if let ControlFlow::Break(maybe_resumable) =
+            cycle_check(job_map, parent, abstracted_waiter.span, stack, visited)
+        {
+            // Return the resumable waiter in `waiter.resumable` if present
+            return ControlFlow::Break(abstracted_waiter.resumable.or(maybe_resumable));
+        }
     }
 
-    r
+    // Remove the entry in our stack since we didn't find a cycle
+    stack.pop();
+
+    ControlFlow::Continue(())
 }
 
 /// Finds out if there's a path to the compiler root (aka. code which isn't in a query)
@@ -193,18 +206,26 @@ fn connected_to_root<'tcx>(
     job_map: &QueryJobMap<'tcx>,
     query: QueryJobId,
     visited: &mut FxHashSet<QueryJobId>,
-) -> ControlFlow<Option<Waiter>> {
+) -> bool {
     // We already visited this or we're deliberately ignoring it
     if !visited.insert(query) {
-        return ControlFlow::Continue(());
+        return false;
     }
 
-    // This query is connected to the root (it has no query parent), return true
-    if job_map.parent_of(query).is_none() {
-        return ControlFlow::Break(None);
+    // Visit all the waiters
+    for abstracted_waiter in abstracted_waiters_of(job_map, query) {
+        match abstracted_waiter.parent {
+            // This query is connected to the root
+            None => return true,
+            Some(parent) => {
+                if connected_to_root(job_map, parent, visited) {
+                    return true;
+                }
+            }
+        }
     }
 
-    visit_waiters(job_map, query, |_, successor| connected_to_root(job_map, successor, visited))
+    false
 }
 
 /// Looks for query cycles starting from the last query in `jobs`.
@@ -220,7 +241,7 @@ fn remove_cycle<'tcx>(
     let mut visited = FxHashSet::default();
     let mut stack = Vec::new();
     // Look for a cycle starting with the last query in `jobs`
-    if let ControlFlow::Break(waiter) =
+    if let ControlFlow::Break(resumable) =
         cycle_check(job_map, jobs.pop().unwrap(), DUMMY_SP, &mut stack, &mut visited)
     {
         // The stack is a vector of pairs of spans and queries; reverse it so that
@@ -242,7 +263,7 @@ fn remove_cycle<'tcx>(
 
         struct EntryPoint {
             query_in_cycle: QueryJobId,
-            waiter: Option<(Span, QueryJobId)>,
+            query_waiting_on_cycle: Option<(Span, QueryJobId)>,
         }
 
         // Find the queries in the cycle which are
@@ -250,36 +271,36 @@ struct EntryPoint {
         let entry_points = stack
             .iter()
             .filter_map(|&(_, query_in_cycle)| {
-                if job_map.parent_of(query_in_cycle).is_none() {
-                    // This query is connected to the root (it has no query parent)
-                    Some(EntryPoint { query_in_cycle, waiter: None })
-                } else {
-                    let mut waiter_on_cycle = None;
-                    // Find a direct waiter who leads to the root
-                    let _ = visit_waiters(job_map, query_in_cycle, |span, waiter| {
-                        // Mark all the other queries in the cycle as already visited
-                        let mut visited = FxHashSet::from_iter(stack.iter().map(|q| q.1));
+                let mut entrypoint = false;
+                let mut query_waiting_on_cycle = None;
 
-                        if connected_to_root(job_map, waiter, &mut visited).is_break() {
-                            waiter_on_cycle = Some((span, waiter));
-                            ControlFlow::Break(None)
-                        } else {
-                            ControlFlow::Continue(())
-                        }
-                    });
+                // Find a direct waiter who leads to the root
+                for abstracted_waiter in abstracted_waiters_of(job_map, query_in_cycle) {
+                    let Some(parent) = abstracted_waiter.parent else {
+                        // The query in the cycle is directly connected to root.
+                        entrypoint = true;
+                        continue;
+                    };
 
-                    waiter_on_cycle.map(|waiter_on_cycle| EntryPoint {
-                        query_in_cycle,
-                        waiter: Some(waiter_on_cycle),
-                    })
+                    // Mark all the other queries in the cycle as already visited,
+                    // so paths to the root through the cycle itself won't count.
+                    let mut visited = FxHashSet::from_iter(stack.iter().map(|q| q.1));
+
+                    if connected_to_root(job_map, parent, &mut visited) {
+                        query_waiting_on_cycle = Some((abstracted_waiter.span, parent));
+                        entrypoint = true;
+                        break;
+                    }
                 }
+
+                entrypoint.then_some(EntryPoint { query_in_cycle, query_waiting_on_cycle })
             })
             .collect::<Vec<EntryPoint>>();
 
         // Pick an entry point, preferring ones with waiters
         let entry_point = entry_points
             .iter()
-            .find(|entry_point| entry_point.waiter.is_some())
+            .find(|entry_point| entry_point.query_waiting_on_cycle.is_some())
             .unwrap_or(&entry_points[0]);
 
         // Shift the stack so that our entry point is first
@@ -289,7 +310,9 @@ struct EntryPoint {
             stack.rotate_left(pos);
         }
 
-        let usage = entry_point.waiter.map(|(span, job)| (span, job_map.frame_of(job).clone()));
+        let usage = entry_point
+            .query_waiting_on_cycle
+            .map(|(span, job)| (span, job_map.frame_of(job).clone()));
 
         // Create the cycle error
         let error = CycleError {
@@ -300,9 +323,9 @@ struct EntryPoint {
                 .collect(),
         };
 
-        // We unwrap `waiter` here since there must always be one
+        // We unwrap `resumable` here since there must always be one
         // edge which is resumable / waited using a query latch
-        let (waitee_query, waiter_idx) = waiter.unwrap();
+        let (waitee_query, waiter_idx) = resumable.unwrap();
 
         // Extract the waiter we want to resume
         let waiter = job_map.latch_of(waitee_query).unwrap().extract_waiter(waiter_idx);

From 1d7b33214316140dc51f725e417a4180a3d49497 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 11 Mar 2026 20:35:41 +1100
Subject: [PATCH 0415/1059] Remove `Representability`.

Its last meaningful uses were removed in #153493.
---
 compiler/rustc_middle/src/queries.rs            | 4 ++--
 compiler/rustc_middle/src/query/erase.rs        | 1 -
 compiler/rustc_middle/src/ty/adt.rs             | 5 -----
 compiler/rustc_ty_utils/src/representability.rs | 8 +++-----
 4 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index d4d9b9c0189d..d6891b9cde2b 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -564,7 +564,7 @@
     }
 
     /// Checks whether a type is representable or infinitely sized
-    query check_representability(key: LocalDefId) -> rustc_middle::ty::Representability {
+    query check_representability(key: LocalDefId) {
         desc { "checking if `{}` is representable", tcx.def_path_str(key) }
         // Infinitely sized types will cause a cycle. The custom `FromCycleError` impl for
         // `Representability` will print a custom error about the infinite size and then abort
@@ -580,7 +580,7 @@
 
     /// An implementation detail for the `check_representability` query. See that query for more
     /// details, particularly on the modifiers.
-    query check_representability_adt_ty(key: Ty<'tcx>) -> rustc_middle::ty::Representability {
+    query check_representability_adt_ty(key: Ty<'tcx>) {
         desc { "checking if `{}` is representable", key }
         cycle_delay_bug
         anon
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 65c6b7551bc6..d15e0b2a122b 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -383,7 +383,6 @@ impl Erasable for $ty {
     rustc_middle::ty::Destructor,
     rustc_middle::ty::fast_reject::SimplifiedType,
     rustc_middle::ty::ImplPolarity,
-    rustc_middle::ty::Representability,
     rustc_middle::ty::UnusedGenericParams,
     rustc_middle::ty::util::AlwaysRequiresDrop,
     rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index ac51e5bd2289..ae3c45877900 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -751,8 +751,3 @@ pub fn sizedness_constraint(
         if self.is_struct() { tcx.adt_sizedness_constraint((self.did(), sizedness)) } else { None }
     }
 }
-
-/// This type exists just so a `FromCycleError` impl can be made for the `check_representability`
-/// query.
-#[derive(Clone, Copy, Debug, HashStable)]
-pub struct Representability;
diff --git a/compiler/rustc_ty_utils/src/representability.rs b/compiler/rustc_ty_utils/src/representability.rs
index 1814e7604a2d..cef964ab139a 100644
--- a/compiler/rustc_ty_utils/src/representability.rs
+++ b/compiler/rustc_ty_utils/src/representability.rs
@@ -2,7 +2,7 @@
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::bug;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, Representability, Ty, TyCtxt};
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::def_id::LocalDefId;
 
 pub(crate) fn provide(providers: &mut Providers) {
@@ -14,7 +14,7 @@ pub(crate) fn provide(providers: &mut Providers) {
     };
 }
 
-fn check_representability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Representability {
+fn check_representability(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     match tcx.def_kind(def_id) {
         DefKind::Struct | DefKind::Union | DefKind::Enum => {
             for variant in tcx.adt_def(def_id).variants() {
@@ -28,7 +28,6 @@ fn check_representability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Representabili
         }
         def_kind => bug!("unexpected {def_kind:?}"),
     }
-    Representability
 }
 
 fn check_representability_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
@@ -67,7 +66,7 @@ fn check_representability_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
 // Looking at the query cycle above, we know that `Bar` is representable
 // because `check_representability_adt_ty(Bar<..>)` is in the cycle and
 // `check_representability(Bar)` is *not* in the cycle.
-fn check_representability_adt_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Representability {
+fn check_representability_adt_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
     let ty::Adt(adt, args) = ty.kind() else { bug!("expected adt") };
     if let Some(def_id) = adt.did().as_local() {
         let _ = tcx.check_representability(def_id);
@@ -82,7 +81,6 @@ fn check_representability_adt_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Repre
             }
         }
     }
-    Representability
 }
 
 fn params_in_repr(tcx: TyCtxt<'_>, def_id: LocalDefId) -> DenseBitSet<u32> {

From 834b7e7e434bff95a44ce50160efada3426487cb Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 11 Mar 2026 17:20:51 +1100
Subject: [PATCH 0416/1059] Streamline active job collection.

`collect_active_jobs_from_all_queries` takes a `require_complete` bool,
and then some callers `expect` a full map result while others allow a
partial map result. The end result is four possible combinations, but
only three of them are used/make sense.

This commit introduces `CollectActiveJobsKind`, a three-value enum that
describes the three sensible combinations, and rewrites
`collect_active_jobs_from_all_queries` around it. This makes it and its
call sites much clearer, and removes the weird `Option<()>` and
`Result<QueryJobMap, QueryJobMap>` return types.

Other changes of note.
- `active` is removed. The comment about `make_frame` is out of date,
  and `create_deferred_query_stack_frame` *is* safe to call with the
  query state locked.
- When shard locking failure is allowed, collection no longer stops on
  the first failed shard.
---
 compiler/rustc_interface/src/util.rs       |  10 +-
 compiler/rustc_query_impl/src/execution.rs | 103 +++++++++++----------
 compiler/rustc_query_impl/src/job.rs       |   5 +-
 compiler/rustc_query_impl/src/lib.rs       |   2 +-
 compiler/rustc_query_impl/src/plumbing.rs  |   8 +-
 5 files changed, 66 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index bacdad25c50b..e81f0133e3b6 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -18,7 +18,7 @@
 use rustc_metadata::{DylibError, EncodedMetadata, load_symbol_from_dylib};
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::ty::{CurrentGcx, TyCtxt};
-use rustc_query_impl::collect_active_jobs_from_all_queries;
+use rustc_query_impl::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
 use rustc_session::config::{
     Cfg, CrateType, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple,
 };
@@ -253,9 +253,11 @@ pub(crate) fn run_in_thread_pool_with_globals<
                                     unsafe { &*(session_globals as *const SessionGlobals) },
                                     || {
                                         // Ensure there were no errors collecting all active jobs.
-                                        // We need the complete map to ensure we find a cycle to break.
-                                        collect_active_jobs_from_all_queries(tcx, false).expect(
-                                            "failed to collect active queries in deadlock handler",
+                                        // We need the complete map to ensure we find a cycle to
+                                        // break.
+                                        collect_active_jobs_from_all_queries(
+                                            tcx,
+                                            CollectActiveJobsKind::FullNoContention,
                                         )
                                     },
                                 );
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 9cb6eababbce..fbb5fe04b95b 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -15,6 +15,7 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
 use rustc_span::{DUMMY_SP, Span};
+use tracing::warn;
 
 use crate::dep_graph::{DepNode, DepNodeIndex};
 use crate::for_each_query_vtable;
@@ -30,6 +31,21 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
     state.active.lock_shards().all(|shard| shard.is_empty())
 }
 
+#[derive(Clone, Copy)]
+pub enum CollectActiveJobsKind {
+    /// We need the full query job map, and we are willing to wait to obtain the query state
+    /// shard lock(s).
+    Full,
+
+    /// We need the full query job map, and we shouldn't need to wait to obtain the shard lock(s),
+    /// because we are in a place where nothing else could hold the shard lock(s).
+    FullNoContention,
+
+    /// We can get by without the full query job map, so we won't bother waiting to obtain the
+    /// shard lock(s) if they're not already unlocked.
+    PartialAllowed,
+}
+
 /// Returns a map of currently active query jobs, collected from all queries.
 ///
 /// If `require_complete` is `true`, this function locks all shards of the
@@ -42,19 +58,15 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
 /// complete map is needed and no deadlock is possible at this call site.
 pub fn collect_active_jobs_from_all_queries<'tcx>(
     tcx: TyCtxt<'tcx>,
-    require_complete: bool,
-) -> Result<QueryJobMap<'tcx>, QueryJobMap<'tcx>> {
-    let mut job_map_out = QueryJobMap::default();
-    let mut complete = true;
+    collect_kind: CollectActiveJobsKind,
+) -> QueryJobMap<'tcx> {
+    let mut job_map = QueryJobMap::default();
 
     for_each_query_vtable!(ALL, tcx, |query| {
-        let res = gather_active_jobs(query, require_complete, &mut job_map_out);
-        if res.is_none() {
-            complete = false;
-        }
+        gather_active_jobs(query, collect_kind, &mut job_map);
     });
 
-    if complete { Ok(job_map_out) } else { Err(job_map_out) }
+    job_map
 }
 
 /// Internal plumbing for collecting the set of active jobs for this query.
@@ -64,59 +76,49 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
 /// (We arbitrarily use the word "gather" when collecting the jobs for
 /// each individual query, so that we have distinct function names to
 /// grep for.)
+///
+/// Aborts if jobs can't be gathered as specified by `collect_kind`.
 fn gather_active_jobs<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
-    require_complete: bool,
-    job_map_out: &mut QueryJobMap<'tcx>, // Out-param; job info is gathered into this map
-) -> Option<()>
-where
+    collect_kind: CollectActiveJobsKind,
+    job_map: &mut QueryJobMap<'tcx>,
+) where
     C: QueryCache<Key: QueryKey + DynSend + DynSync>,
     QueryVTable<'tcx, C>: DynSync,
 {
-    let mut active = Vec::new();
-
-    // Helper to gather active jobs from a single shard.
     let mut gather_shard_jobs = |shard: &HashTable<(C::Key, ActiveKeyStatus<'tcx>)>| {
-        for (k, v) in shard.iter() {
-            if let ActiveKeyStatus::Started(ref job) = *v {
-                active.push((*k, job.clone()));
+        for (key, status) in shard.iter() {
+            if let ActiveKeyStatus::Started(job) = status {
+                // This function is safe to call with the shard locked because it is very simple.
+                let frame = crate::plumbing::create_query_stack_frame(query, *key);
+                job_map.insert(job.id, QueryJobInfo { frame, job: job.clone() });
             }
         }
     };
 
-    // Lock shards and gather jobs from each shard.
-    if require_complete {
-        for shard in query.state.active.lock_shards() {
-            gather_shard_jobs(&shard);
+    match collect_kind {
+        CollectActiveJobsKind::Full => {
+            for shard in query.state.active.lock_shards() {
+                gather_shard_jobs(&shard);
+            }
         }
-    } else {
-        // We use try_lock_shards here since we are called from the
-        // deadlock handler, and this shouldn't be locked.
-        for shard in query.state.active.try_lock_shards() {
-            // This can be called during unwinding, and the function has a `try_`-prefix, so
-            // don't `unwrap()` here, just manually check for `None` and do best-effort error
-            // reporting.
-            match shard {
-                None => {
-                    tracing::warn!(
-                        "Failed to collect active jobs for query with name `{}`!",
-                        query.name
-                    );
-                    return None;
+        CollectActiveJobsKind::FullNoContention => {
+            for shard in query.state.active.try_lock_shards() {
+                match shard {
+                    Some(shard) => gather_shard_jobs(&shard),
+                    None => panic!("Failed to collect active jobs for query `{}`!", query.name),
+                }
+            }
+        }
+        CollectActiveJobsKind::PartialAllowed => {
+            for shard in query.state.active.try_lock_shards() {
+                match shard {
+                    Some(shard) => gather_shard_jobs(&shard),
+                    None => warn!("Failed to collect active jobs for query `{}`!", query.name),
                 }
-                Some(shard) => gather_shard_jobs(&shard),
             }
         }
     }
-
-    // Call `make_frame` while we're not holding a `state.active` lock as `make_frame` may call
-    // queries leading to a deadlock.
-    for (key, job) in active {
-        let frame = crate::plumbing::create_query_stack_frame(query, key);
-        job_map_out.insert(job.id, QueryJobInfo { frame, job });
-    }
-
-    Some(())
 }
 
 #[cold]
@@ -223,11 +225,10 @@ fn cycle_error<'tcx, C: QueryCache>(
     try_execute: QueryJobId,
     span: Span,
 ) -> (C::Value, Option<DepNodeIndex>) {
-    // Ensure there was no errors collecting all active jobs.
+    // Ensure there were no errors collecting all active jobs.
     // We need the complete map to ensure we find a cycle to break.
-    let job_map = collect_active_jobs_from_all_queries(tcx, false)
-        .ok()
-        .expect("failed to collect active queries");
+    let job_map =
+        collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::FullNoContention);
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
     (mk_cycle(query, tcx, key, error), None)
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index ae32ad01b157..64ed9b6b51bf 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -12,7 +12,7 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_span::{DUMMY_SP, Span};
 
-use crate::execution::collect_active_jobs_from_all_queries;
+use crate::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
 
 /// Map from query job IDs to job information collected by
 /// `collect_active_jobs_from_all_queries`.
@@ -383,8 +383,7 @@ pub fn print_query_stack<'tcx>(
     let mut count_total = 0;
 
     // Make use of a partial query job map if we fail to take locks collecting active queries.
-    let job_map: QueryJobMap<'_> = collect_active_jobs_from_all_queries(tcx, false)
-        .unwrap_or_else(|partial_job_map| partial_job_map);
+    let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::PartialAllowed);
 
     if let Some(ref mut file) = file {
         let _ = writeln!(file, "\n\nquery stack during panic:");
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index aaf9c78feb7f..44c97d19914c 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -18,7 +18,7 @@
 use rustc_span::Span;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
-pub use crate::execution::collect_active_jobs_from_all_queries;
+pub use crate::execution::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
 
 #[macro_use]
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 0a84a8b23c07..0e92d0c47596 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -29,11 +29,13 @@
 use crate::error::{QueryOverflow, QueryOverflowNote};
 use crate::execution::{all_inactive, force_query};
 use crate::job::find_dep_kind_root;
-use crate::{GetQueryVTable, collect_active_jobs_from_all_queries, for_each_query_vtable};
+use crate::{
+    CollectActiveJobsKind, GetQueryVTable, collect_active_jobs_from_all_queries,
+    for_each_query_vtable,
+};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
-    let job_map =
-        collect_active_jobs_from_all_queries(tcx, true).expect("failed to collect active queries");
+    let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::Full);
     let (info, depth) = find_dep_kind_root(job, job_map);
 
     let suggested_limit = match tcx.recursion_limit() {

From c6c150b0e0fba4a46a900c887d8e75e35f8a942d Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 11 Mar 2026 20:37:22 +1100
Subject: [PATCH 0417/1059] Remove `CycleErrorHandling`.

Currently if a cycle error occurs the error is created, then handled
according to `CycleErrorHandling` (which comes from the
`cycle_delay_bug` query modifer, or lack thereof), and then
`value_from_cycle_error` is called.

This commit changes things so the error is created and then just passed
to `value_from_cycle_error`. This gives `value_from_cycle_error` full
control over how it's handled, eliminating the need for
`CycleErrorHandling`. This makes things simpler overall.
---
 compiler/rustc_macros/src/query.rs            | 15 ----
 compiler/rustc_middle/src/queries.rs          | 15 ++--
 compiler/rustc_middle/src/query/mod.rs        |  4 +-
 compiler/rustc_middle/src/query/modifiers.rs  |  5 --
 compiler/rustc_middle/src/query/plumbing.rs   | 22 ++----
 .../rustc_query_impl/src/dep_kind_vtables.rs  |  1 -
 compiler/rustc_query_impl/src/execution.rs    | 15 +---
 .../rustc_query_impl/src/from_cycle_error.rs  | 73 +++++++++----------
 compiler/rustc_query_impl/src/plumbing.rs     | 10 +--
 9 files changed, 56 insertions(+), 104 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index ed5951fe1c03..a0c5b38d0136 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -143,7 +143,6 @@ struct QueryModifiers {
     anon: Option<Ident>,
     arena_cache: Option<Ident>,
     cache_on_disk_if: Option<CacheOnDiskIf>,
-    cycle_delay_bug: Option<Ident>,
     depth_limit: Option<Ident>,
     desc: Desc,
     eval_always: Option<Ident>,
@@ -157,7 +156,6 @@ fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModifiers> {
     let mut arena_cache = None;
     let mut cache_on_disk_if = None;
     let mut desc = None;
-    let mut cycle_delay_bug = None;
     let mut no_hash = None;
     let mut anon = None;
     let mut eval_always = None;
@@ -191,8 +189,6 @@ macro_rules! try_insert {
             try_insert!(cache_on_disk_if = CacheOnDiskIf { modifier, block });
         } else if modifier == "arena_cache" {
             try_insert!(arena_cache = modifier);
-        } else if modifier == "cycle_delay_bug" {
-            try_insert!(cycle_delay_bug = modifier);
         } else if modifier == "no_hash" {
             try_insert!(no_hash = modifier);
         } else if modifier == "anon" {
@@ -216,7 +212,6 @@ macro_rules! try_insert {
         arena_cache,
         cache_on_disk_if,
         desc,
-        cycle_delay_bug,
         no_hash,
         anon,
         eval_always,
@@ -251,7 +246,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         anon,
         arena_cache,
         cache_on_disk_if,
-        cycle_delay_bug,
         depth_limit,
         desc: _,
         eval_always,
@@ -264,13 +258,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
     let anon = anon.is_some();
     let arena_cache = arena_cache.is_some();
     let cache_on_disk = cache_on_disk_if.is_some();
-
-    let cycle_error_handling = if cycle_delay_bug.is_some() {
-        quote! { DelayBug }
-    } else {
-        quote! { Error }
-    };
-
     let depth_limit = depth_limit.is_some();
     let eval_always = eval_always.is_some();
     let feedable = feedable.is_some();
@@ -289,7 +276,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         anon: #anon,
         arena_cache: #arena_cache,
         cache_on_disk: #cache_on_disk,
-        cycle_error_handling: #cycle_error_handling,
         depth_limit: #depth_limit,
         eval_always: #eval_always,
         feedable: #feedable,
@@ -402,7 +388,6 @@ macro_rules! doc_link {
 
     doc_link!(
         arena_cache,
-        cycle_delay_bug,
         no_hash,
         anon,
         eval_always,
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index d6891b9cde2b..6c30762725b7 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -564,13 +564,13 @@
     }
 
     /// Checks whether a type is representable or infinitely sized
+    //
+    // Infinitely sized types will cause a cycle. The `value_from_cycle_error` impl will print
+    // a custom error about the infinite size and then abort compilation. (In the past we
+    // recovered and continued, but in practice that leads to confusing subsequent error
+    // messages about cycles that then abort.)
     query check_representability(key: LocalDefId) {
         desc { "checking if `{}` is representable", tcx.def_path_str(key) }
-        // Infinitely sized types will cause a cycle. The custom `FromCycleError` impl for
-        // `Representability` will print a custom error about the infinite size and then abort
-        // compilation. (In the past we recovered and continued, but in practice that leads to
-        // confusing subsequent error messages about cycles that then abort.)
-        cycle_delay_bug
         // We don't want recursive representability calls to be forced with
         // incremental compilation because, if a cycle occurs, we need the
         // entire cycle to be in memory for diagnostics. This means we can't
@@ -582,7 +582,6 @@
     /// details, particularly on the modifiers.
     query check_representability_adt_ty(key: Ty<'tcx>) {
         desc { "checking if `{}` is representable", key }
-        cycle_delay_bug
         anon
     }
 
@@ -1027,7 +1026,6 @@
         desc { "computing the variances of `{}`", tcx.def_path_str(def_id) }
         cache_on_disk_if { def_id.is_local() }
         separate_provide_extern
-        cycle_delay_bug
     }
 
     /// Gets a map with the inferred outlives-predicates of every item in the local crate.
@@ -1160,7 +1158,6 @@
         desc { "computing function signature of `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
         separate_provide_extern
-        cycle_delay_bug
     }
 
     /// Performs lint checking for the module.
@@ -1751,8 +1748,6 @@
     ) -> Result<ty::layout::TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
         depth_limit
         desc { "computing layout of `{}`", key.value }
-        // we emit our own error during query cycle handling
-        cycle_delay_bug
     }
 
     /// Compute a `FnAbi` suitable for indirect calls, i.e. to `fn` pointers.
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 9876441f5218..b8fd88f2af17 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -4,8 +4,8 @@
 pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
-    ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, IntoQueryParam, QueryMode,
-    QueryState, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
+    ActiveKeyStatus, CycleError, EnsureMode, IntoQueryParam, QueryMode, QueryState, TyCtxtAt,
+    TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
 };
 pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
diff --git a/compiler/rustc_middle/src/query/modifiers.rs b/compiler/rustc_middle/src/query/modifiers.rs
index 100d1ac52769..ad9b9de119d5 100644
--- a/compiler/rustc_middle/src/query/modifiers.rs
+++ b/compiler/rustc_middle/src/query/modifiers.rs
@@ -29,11 +29,6 @@
 /// identifier is available for use within the block, as is `tcx`.
 pub(crate) struct cache_on_disk_if;
 
-/// # `cycle_delay_bug` query modifier
-///
-/// If a dependency cycle is detected, emit a delayed bug instead of a normal error.
-pub(crate) struct cycle_delay_bug;
-
 /// # `depth_limit` query modifier
 ///
 /// Impose a recursion call depth limit on the query to prevent stack overflow.
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index a85412158830..f38889846524 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -5,9 +5,10 @@
 use rustc_data_structures::hash_table::HashTable;
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::sync::{AtomicU64, WorkerLocal};
+use rustc_errors::Diag;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
-use rustc_span::{ErrorGuaranteed, Span};
+use rustc_span::Span;
 pub use sealed::IntoQueryParam;
 
 use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
@@ -49,16 +50,6 @@ pub enum ActiveKeyStatus<'tcx> {
     Poisoned,
 }
 
-/// How a particular query deals with query cycle errors.
-///
-/// Inspected by the code that actually handles cycle errors, to decide what
-/// approach to use.
-#[derive(Copy, Clone)]
-pub enum CycleErrorHandling {
-    Error,
-    DelayBug,
-}
-
 #[derive(Clone, Debug)]
 pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
@@ -98,8 +89,6 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     pub feedable: bool,
 
     pub dep_kind: DepKind,
-    /// How this query deals with query cycle errors.
-    pub cycle_error_handling: CycleErrorHandling,
     pub state: QueryState<'tcx, C::Key>,
     pub cache: C,
 
@@ -127,12 +116,16 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     /// For `no_hash` queries, this function pointer is None.
     pub hash_value_fn: Option<fn(&mut StableHashingContext<'_>, &C::Value) -> Fingerprint>,
 
+    /// Function pointer that handles a cycle error. `error` must be consumed, e.g. with `emit` (if
+    /// it should be emitted) or `delay_as_bug` (if it need not be emitted because an alternative
+    /// error is created and emitted).
     pub value_from_cycle_error: fn(
         tcx: TyCtxt<'tcx>,
         key: C::Key,
         cycle_error: CycleError<'tcx>,
-        guar: ErrorGuaranteed,
+        error: Diag<'_>,
     ) -> C::Value,
+
     pub format_value: fn(&C::Value) -> String,
 
     pub create_tagged_key: fn(C::Key) -> TaggedQueryKey<'tcx>,
@@ -295,7 +288,6 @@ fn $name:ident($($K:tt)*) -> $V:ty
                     anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
-                    cycle_error_handling: $cycle_error_handling:ident,
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 3bc2e35b02bc..34ef70f141b9 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -136,7 +136,6 @@ fn $name:ident($K:ty) -> $V:ty
                     anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
-                    cycle_error_handling: $cycle_error_handling:ident,
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 9cb6eababbce..b4823954a4ea 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -9,8 +9,8 @@
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
-    ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, QueryCache, QueryJob, QueryJobId,
-    QueryKey, QueryLatch, QueryMode, QueryState,
+    ActiveKeyStatus, CycleError, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey,
+    QueryLatch, QueryMode, QueryState,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
@@ -128,16 +128,7 @@ fn mk_cycle<'tcx, C: QueryCache>(
     cycle_error: CycleError<'tcx>,
 ) -> C::Value {
     let error = report_cycle(tcx, &cycle_error);
-    match query.cycle_error_handling {
-        CycleErrorHandling::Error => {
-            let guar = error.emit();
-            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
-        }
-        CycleErrorHandling::DelayBug => {
-            let guar = error.delay_as_bug();
-            (query.value_from_cycle_error)(tcx, key, cycle_error, guar)
-        }
-    }
+    (query.value_from_cycle_error)(tcx, key, cycle_error, error)
 }
 
 /// Guard object representing the responsibility to execute a query job and
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 10baaa9209d0..6a3155c02949 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -5,14 +5,14 @@
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
+use rustc_errors::{Applicability, Diag, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::dep_graph::DepKind;
 use rustc_middle::queries::QueryVTables;
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
-use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
+use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::{DefId, LocalDefId};
@@ -21,41 +21,45 @@
 use crate::job::report_cycle;
 
 pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
-    vtables.type_of.value_from_cycle_error =
-        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+    vtables.type_of.value_from_cycle_error = |tcx, _, _, err| {
+        let guar = err.emit();
+        erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
+    };
 
-    vtables.type_of_opaque_hir_typeck.value_from_cycle_error =
-        |tcx, _, _, guar| erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)));
+    vtables.type_of_opaque_hir_typeck.value_from_cycle_error = |tcx, _, _, err| {
+        let guar = err.emit();
+        erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
+    };
 
-    vtables.erase_and_anonymize_regions_ty.value_from_cycle_error =
-        |tcx, _, _, guar| erase_val(Ty::new_error(tcx, guar));
+    vtables.erase_and_anonymize_regions_ty.value_from_cycle_error = |tcx, _, _, err| {
+        let guar = err.emit();
+        erase_val(Ty::new_error(tcx, guar))
+    };
 
-    vtables.fn_sig.value_from_cycle_error = |tcx, key, _, guar| erase_val(fn_sig(tcx, key, guar));
+    vtables.fn_sig.value_from_cycle_error = |tcx, key, _, err| {
+        let guar = err.delay_as_bug();
+        erase_val(fn_sig(tcx, key, guar))
+    };
 
     vtables.check_representability.value_from_cycle_error =
-        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, _err| check_representability(tcx, cycle);
 
     vtables.check_representability_adt_ty.value_from_cycle_error =
-        |tcx, _, cycle, guar| check_representability(tcx, cycle, guar);
+        |tcx, _, cycle, _err| check_representability(tcx, cycle);
 
-    vtables.variances_of.value_from_cycle_error =
-        |tcx, _, cycle, guar| erase_val(variances_of(tcx, cycle, guar));
+    vtables.variances_of.value_from_cycle_error = |tcx, _, cycle, err| {
+        let _guar = err.delay_as_bug();
+        erase_val(variances_of(tcx, cycle))
+    };
 
-    vtables.layout_of.value_from_cycle_error =
-        |tcx, _, cycle, guar| erase_val(layout_of(tcx, cycle, guar));
+    vtables.layout_of.value_from_cycle_error = |tcx, _, cycle, err| {
+        let _guar = err.delay_as_bug();
+        erase_val(Err(layout_of(tcx, cycle)))
+    }
 }
 
-pub(crate) fn default<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError<'tcx>,
-    query_name: &str,
-) -> ! {
-    let Some(guar) = tcx.sess.dcx().has_errors() else {
-        bug!(
-            "`from_cycle_error_default` on query `{query_name}` called without errors: {:#?}",
-            cycle_error.cycle,
-        );
-    };
+pub(crate) fn default(err: Diag<'_>) -> ! {
+    let guar = err.emit();
     guar.raise_fatal()
 }
 
@@ -84,11 +88,7 @@ fn fn_sig<'tcx>(
     )))
 }
 
-fn check_representability<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError<'tcx>,
-    _guar: ErrorGuaranteed,
-) -> ! {
+fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> ! {
     let mut item_and_field_ids = Vec::new();
     let mut representable_ids = FxHashSet::default();
     for info in &cycle_error.cycle {
@@ -120,11 +120,7 @@ fn check_representability<'tcx>(
     guar.raise_fatal()
 }
 
-fn variances_of<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError<'tcx>,
-    _guar: ErrorGuaranteed,
-) -> &'tcx [ty::Variance] {
+fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> &'tcx [ty::Variance] {
     search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
@@ -169,8 +165,7 @@ fn search_for_cycle_permutation<Q, T>(
 fn layout_of<'tcx>(
     tcx: TyCtxt<'tcx>,
     cycle_error: CycleError<'tcx>,
-    _guar: ErrorGuaranteed,
-) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
+) -> &'tcx ty::layout::LayoutError<'tcx> {
     let diag = search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
@@ -247,7 +242,7 @@ fn layout_of<'tcx>(
     );
 
     let guar = diag.emit();
-    Err(tcx.arena.alloc(LayoutError::Cycle(guar)))
+    tcx.arena.alloc(LayoutError::Cycle(guar))
 }
 
 // item_and_field_ids should form a cycle where each field contains the
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 0a84a8b23c07..661ea99bbf02 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -295,7 +295,6 @@ fn $name:ident($K:ty) -> $V:ty
                     anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
-                    cycle_error_handling: $cycle_error_handling:ident,
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
@@ -409,8 +408,6 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                     depth_limit: $depth_limit,
                     feedable: $feedable,
                     dep_kind: dep_graph::DepKind::$name,
-                    cycle_error_handling:
-                        rustc_middle::query::CycleErrorHandling::$cycle_error_handling,
                     state: Default::default(),
                     cache: Default::default(),
 
@@ -446,8 +443,11 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                     #[cfg(not($cache_on_disk))]
                     is_loadable_from_disk_fn: |_tcx, _key, _index| false,
 
-                    value_from_cycle_error: |tcx, _, cycle, _| {
-                        $crate::from_cycle_error::default(tcx, cycle, stringify!($name))
+                    // The default just emits `err` and then aborts.
+                    // `from_cycle_error::specialize_query_vtables` overwrites this default for
+                    // certain queries.
+                    value_from_cycle_error: |_tcx, _key, _cycle, err| {
+                        $crate::from_cycle_error::default(err)
                     },
 
                     #[cfg($no_hash)]

From a280f542642d3d668fdfa848613b15e9570552a5 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 13 Mar 2026 12:15:40 +0100
Subject: [PATCH 0418/1059] Remove unused `LintContext::emit_diag_lint` method

---
 compiler/rustc_lint/src/context.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index 9c2907cfacf7..da28c63c9f28 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -535,12 +535,6 @@ fn emit_span_lint<S: Into<MultiSpan>>(
         self.opt_span_diag_lint(lint, Some(span), decorator);
     }
 
-    /// Emit a lint from a lint struct (some type that implements `Diagnostic`, typically
-    /// generated by `#[derive(Diagnostic)]`).
-    fn emit_diag_lint(&self, lint: &'static Lint, decorator: impl for<'a> Diagnostic<'a, ()>) {
-        self.opt_span_diag_lint(lint, None as Option<Span>, decorator);
-    }
-
     /// This returns the lint level for the given lint at the current location.
     fn get_lint_level(&self, lint: &'static Lint) -> LevelAndSource;
 

From e485708b84b357a8fc40d7e0550042f0ca6c2920 Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Thu, 12 Mar 2026 17:39:29 -0400
Subject: [PATCH 0419/1059] Point turbofish inference errors at the uninferred
 generic arg

---
 .../error_reporting/infer/need_type_info.rs   | 24 ++++++++++++++-----
 .../generic_const_exprs/issue-105608.stderr   |  4 ++--
 .../inference/useless-turbofish-suggestion.rs | 11 ++++++---
 .../useless-turbofish-suggestion.stderr       | 14 +++++++----
 tests/ui/issues/issue-23041.stderr            |  4 ++--
 .../issue-42234-unknown-receiver-type.stderr  |  4 ++--
 6 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 629bd30d88e8..921fab554348 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -1260,21 +1260,33 @@ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
                 have_turbofish,
             } = args;
             let generics = tcx.generics_of(generics_def_id);
-            if let Some(mut argument_index) = generics
+            if let Some((argument_index, _)) = generics
                 .own_args(args)
                 .iter()
-                .position(|&arg| self.generic_arg_contains_target(arg))
+                .enumerate()
+                .find(|&(_, &arg)| self.generic_arg_contains_target(arg))
             {
-                if generics.has_own_self() {
-                    argument_index += 1;
-                }
                 let args = self.tecx.resolve_vars_if_possible(args);
                 let generic_args =
                     &generics.own_args_no_defaults(tcx, args)[generics.own_counts().lifetimes..];
                 let span = match expr.kind {
-                    ExprKind::MethodCall(path, ..) => path.ident.span,
+                    ExprKind::MethodCall(segment, ..)
+                        if have_turbofish
+                            && let Some(hir_args) = segment.args
+                            && let Some(idx) =
+                                argument_index.checked_sub(generics.own_counts().lifetimes)
+                            && let Some(arg) =
+                                hir_args.args.get(hir_args.num_lifetime_params() + idx) =>
+                    {
+                        arg.span()
+                    }
+                    ExprKind::MethodCall(segment, ..) => segment.ident.span,
                     _ => expr.span,
                 };
+                let mut argument_index = argument_index;
+                if generics.has_own_self() {
+                    argument_index += 1;
+                }
 
                 self.update_infer_source(InferSource {
                     span,
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr b/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
index cc35035edf95..dede51416bfa 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/issue-105608.rs:13:22
+  --> $DIR/issue-105608.rs:13:28
    |
 LL |     Combination::<0>.and::<_>().and::<_>();
-   |                      ^^^ cannot infer type of the type parameter `M` declared on the method `and`
+   |                            ^ cannot infer type of the type parameter `M` declared on the method `and`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inference/useless-turbofish-suggestion.rs b/tests/ui/inference/useless-turbofish-suggestion.rs
index ed86df6296ca..64dbfff64c52 100644
--- a/tests/ui/inference/useless-turbofish-suggestion.rs
+++ b/tests/ui/inference/useless-turbofish-suggestion.rs
@@ -4,8 +4,8 @@
 // rewriting them — the suggestion just rewrites user syntax into
 // fully-qualified form without resolving anything.
 //
-// The span still points at the method name rather than the unresolved `_`;
-// fixing that is left as future work.
+// When a turbofish is present, the diagnostic points at the specific
+// uninferred generic argument rather than the method name.
 
 struct S;
 
@@ -15,11 +15,16 @@ fn f<A, B>(self, _a: A) -> B {
     }
 }
 
-fn with_turbofish() {
+fn turbofish_second_arg() {
     S.f::<u32, _>(42);
     //~^ ERROR type annotations needed
 }
 
+fn turbofish_first_arg() {
+    S.f::<_, _>(42);
+    //~^ ERROR type annotations needed
+}
+
 fn without_turbofish() {
     S.f(42);
     //~^ ERROR type annotations needed
diff --git a/tests/ui/inference/useless-turbofish-suggestion.stderr b/tests/ui/inference/useless-turbofish-suggestion.stderr
index 25b05801aa47..ccd30b415f65 100644
--- a/tests/ui/inference/useless-turbofish-suggestion.stderr
+++ b/tests/ui/inference/useless-turbofish-suggestion.stderr
@@ -1,11 +1,17 @@
 error[E0282]: type annotations needed
-  --> $DIR/useless-turbofish-suggestion.rs:19:7
+  --> $DIR/useless-turbofish-suggestion.rs:19:16
    |
 LL |     S.f::<u32, _>(42);
-   |       ^ cannot infer type of the type parameter `B` declared on the method `f`
+   |                ^ cannot infer type of the type parameter `B` declared on the method `f`
 
 error[E0282]: type annotations needed
-  --> $DIR/useless-turbofish-suggestion.rs:24:7
+  --> $DIR/useless-turbofish-suggestion.rs:24:14
+   |
+LL |     S.f::<_, _>(42);
+   |              ^ cannot infer type of the type parameter `B` declared on the method `f`
+
+error[E0282]: type annotations needed
+  --> $DIR/useless-turbofish-suggestion.rs:29:7
    |
 LL |     S.f(42);
    |       ^ cannot infer type of the type parameter `B` declared on the method `f`
@@ -15,6 +21,6 @@ help: consider specifying the generic arguments
 LL |     S.f::<i32, B>(42);
    |        ++++++++++
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-23041.stderr b/tests/ui/issues/issue-23041.stderr
index 4d7266c7c98d..b348a8695f6f 100644
--- a/tests/ui/issues/issue-23041.stderr
+++ b/tests/ui/issues/issue-23041.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/issue-23041.rs:6:7
+  --> $DIR/issue-23041.rs:6:22
    |
 LL |     b.downcast_ref::<fn(_)->_>();
-   |       ^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the method `downcast_ref`
+   |                      ^^^^^^^^ cannot infer type of the type parameter `T` declared on the method `downcast_ref`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/span/issue-42234-unknown-receiver-type.stderr b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
index f16006a8e085..9ebe7d64584d 100644
--- a/tests/ui/span/issue-42234-unknown-receiver-type.stderr
+++ b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
@@ -12,10 +12,10 @@ LL |     let x: Option<_> = None::<T>;
    |                            +++++
 
 error[E0282]: type annotations needed
-  --> $DIR/issue-42234-unknown-receiver-type.rs:12:10
+  --> $DIR/issue-42234-unknown-receiver-type.rs:12:16
    |
 LL |         .sum::<_>()
-   |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
+   |                ^ cannot infer type of the type parameter `S` declared on the method `sum`
 
 error: aborting due to 2 previous errors
 

From 9d45c1e1d4fdd26749e602ef4771845f7dcb48b6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 13 Mar 2026 12:31:51 +0100
Subject: [PATCH 0420/1059] Rename `LintContext::opt_span_diag_lint` method
 into `opt_span_lint`

---
 compiler/rustc_lint/src/context.rs | 10 +++++-----
 compiler/rustc_lint/src/early.rs   |  4 ++--
 compiler/rustc_lint/src/levels.rs  |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index da28c63c9f28..752c2220d414 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -516,7 +516,7 @@ pub trait LintContext {
     ///
     /// [`emit_lint_base`]: rustc_middle::lint::emit_lint_base#decorate-signature
     #[track_caller]
-    fn opt_span_diag_lint<S: Into<MultiSpan>>(
+    fn opt_span_lint<S: Into<MultiSpan>>(
         &self,
         lint: &'static Lint,
         span: Option<S>,
@@ -532,7 +532,7 @@ fn emit_span_lint<S: Into<MultiSpan>>(
         span: S,
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
-        self.opt_span_diag_lint(lint, Some(span), decorator);
+        self.opt_span_lint(lint, Some(span), decorator);
     }
 
     /// This returns the lint level for the given lint at the current location.
@@ -588,7 +588,7 @@ fn sess(&self) -> &Session {
         self.tcx.sess
     }
 
-    fn opt_span_diag_lint<S: Into<MultiSpan>>(
+    fn opt_span_lint<S: Into<MultiSpan>>(
         &self,
         lint: &'static Lint,
         span: Option<S>,
@@ -613,13 +613,13 @@ fn sess(&self) -> &Session {
         self.builder.sess()
     }
 
-    fn opt_span_diag_lint<S: Into<MultiSpan>>(
+    fn opt_span_lint<S: Into<MultiSpan>>(
         &self,
         lint: &'static Lint,
         span: Option<S>,
         decorator: impl for<'a> Diagnostic<'a, ()>,
     ) {
-        self.builder.opt_span_diag_lint(lint, span.map(|s| s.into()), decorator)
+        self.builder.opt_span_lint(lint, span.map(|s| s.into()), decorator)
     }
 
     fn get_lint_level(&self, lint: &'static Lint) -> LevelAndSource {
diff --git a/compiler/rustc_lint/src/early.rs b/compiler/rustc_lint/src/early.rs
index 92232c7d230b..c0eca3b5197b 100644
--- a/compiler/rustc_lint/src/early.rs
+++ b/compiler/rustc_lint/src/early.rs
@@ -39,7 +39,7 @@ fn check_id(&mut self, id: ast::NodeId) {
             let BufferedEarlyLint { span, node_id: _, lint_id, diagnostic } = early_lint;
             match diagnostic {
                 DecorateDiagCompat::Builtin(b) => {
-                    self.context.opt_span_diag_lint(
+                    self.context.opt_span_lint(
                         lint_id.lint,
                         span,
                         DecorateBuiltinLint {
@@ -50,7 +50,7 @@ fn check_id(&mut self, id: ast::NodeId) {
                     );
                 }
                 DecorateDiagCompat::Dynamic(d) => {
-                    self.context.opt_span_diag_lint(lint_id.lint, span, d);
+                    self.context.opt_span_lint(lint_id.lint, span, d);
                 }
             }
         }
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 5536bfc0176a..2b859b65c9f8 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -1001,7 +1001,7 @@ pub fn lint_level(&self, lint: &'static Lint) -> LevelAndSource {
     /// Used to emit a lint-related diagnostic based on the current state of
     /// this lint context.
     #[track_caller]
-    pub(crate) fn opt_span_diag_lint(
+    pub(crate) fn opt_span_lint(
         &self,
         lint: &'static Lint,
         span: Option<MultiSpan>,

From 6e2522e6e23fb5195d1413e79d077b66a5c1a3a2 Mon Sep 17 00:00:00 2001
From: Lars Schumann <LarsSchumann@mail.de>
Date: Fri, 13 Mar 2026 11:54:06 +0000
Subject: [PATCH 0421/1059] constify Step trait and all of its implementations

---
 library/core/src/array/mod.rs   |  6 ++-
 library/core/src/iter/range.rs  | 27 ++++++++-----
 library/core/src/net/ip_addr.rs | 18 ++++++---
 library/core/src/slice/cmp.rs   | 69 ++++++++++++++++++++++++---------
 tests/codegen-llvm/array-cmp.rs | 21 +++++-----
 5 files changed, 94 insertions(+), 47 deletions(-)

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 4a2cf1527744..b11684157890 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -405,7 +405,8 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output {
 
 /// Implements comparison of arrays [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd, const N: usize> PartialOrd for [T; N] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialOrd, const N: usize> const PartialOrd for [T; N] {
     #[inline]
     fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering> {
         PartialOrd::partial_cmp(&&self[..], &&other[..])
@@ -430,7 +431,8 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output {
 
 /// Implements comparison of arrays [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord, const N: usize> Ord for [T; N] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Ord, const N: usize> const Ord for [T; N] {
     #[inline]
     fn cmp(&self, other: &[T; N]) -> Ordering {
         Ord::cmp(&&self[..], &&other[..])
diff --git a/library/core/src/iter/range.rs b/library/core/src/iter/range.rs
index 350b5d31e894..951bb5d0029f 100644
--- a/library/core/src/iter/range.rs
+++ b/library/core/src/iter/range.rs
@@ -29,7 +29,8 @@ unsafe impl TrustedStep for $type {}
             unstable `Step` trait"
 )]
 #[unstable(feature = "step_trait", issue = "42168")]
-pub trait Step: Clone + PartialOrd + Sized {
+#[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+pub const trait Step: [const] Clone + [const] PartialOrd + Sized {
     /// Returns the bounds on the number of *successor* steps required to get from `start` to `end`
     /// like [`Iterator::size_hint()`][Iterator::size_hint()].
     ///
@@ -262,7 +263,8 @@ macro_rules! step_integer_impls {
         $(
             #[allow(unreachable_patterns)]
             #[unstable(feature = "step_trait", issue = "42168")]
-            impl Step for $u_narrower {
+            #[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+            impl const Step for $u_narrower {
                 step_identical_methods!();
                 step_unsigned_methods!();
 
@@ -296,7 +298,8 @@ fn backward_checked(start: Self, n: usize) -> Option<Self> {
 
             #[allow(unreachable_patterns)]
             #[unstable(feature = "step_trait", issue = "42168")]
-            impl Step for $i_narrower {
+            #[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+            impl const Step for $i_narrower {
                 step_identical_methods!();
                 step_signed_methods!($u_narrower);
 
@@ -362,7 +365,8 @@ fn backward_checked(start: Self, n: usize) -> Option<Self> {
         $(
             #[allow(unreachable_patterns)]
             #[unstable(feature = "step_trait", issue = "42168")]
-            impl Step for $u_wider {
+            #[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+            impl const Step for $u_wider {
                 step_identical_methods!();
                 step_unsigned_methods!();
 
@@ -392,7 +396,8 @@ fn backward_checked(start: Self, n: usize) -> Option<Self> {
 
             #[allow(unreachable_patterns)]
             #[unstable(feature = "step_trait", issue = "42168")]
-            impl Step for $i_wider {
+            #[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+            impl const Step for $i_wider {
                 step_identical_methods!();
                 step_signed_methods!($u_wider);
 
@@ -449,7 +454,8 @@ fn backward_checked(start: Self, n: usize) -> Option<Self> {
 }
 
 #[unstable(feature = "step_trait", issue = "42168")]
-impl Step for char {
+#[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+impl const Step for char {
     #[inline]
     fn steps_between(&start: &char, &end: &char) -> (usize, Option<usize>) {
         let start = start as u32;
@@ -536,7 +542,8 @@ unsafe fn backward_unchecked(start: char, count: usize) -> char {
 }
 
 #[unstable(feature = "step_trait", issue = "42168")]
-impl Step for AsciiChar {
+#[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+impl const Step for AsciiChar {
     #[inline]
     fn steps_between(&start: &AsciiChar, &end: &AsciiChar) -> (usize, Option<usize>) {
         Step::steps_between(&start.to_u8(), &end.to_u8())
@@ -578,7 +585,8 @@ unsafe fn backward_unchecked(start: AsciiChar, count: usize) -> AsciiChar {
 }
 
 #[unstable(feature = "step_trait", issue = "42168")]
-impl Step for Ipv4Addr {
+#[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+impl const Step for Ipv4Addr {
     #[inline]
     fn steps_between(&start: &Ipv4Addr, &end: &Ipv4Addr) -> (usize, Option<usize>) {
         u32::steps_between(&start.to_bits(), &end.to_bits())
@@ -610,7 +618,8 @@ unsafe fn backward_unchecked(start: Ipv4Addr, count: usize) -> Ipv4Addr {
 }
 
 #[unstable(feature = "step_trait", issue = "42168")]
-impl Step for Ipv6Addr {
+#[rustc_const_unstable(feature = "step_trait", issue = "42168")]
+impl const Step for Ipv6Addr {
     #[inline]
     fn steps_between(&start: &Ipv6Addr, &end: &Ipv6Addr) -> (usize, Option<usize>) {
         u128::steps_between(&start.to_bits(), &end.to_bits())
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index a1bfd774710d..d18a92208854 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -68,7 +68,8 @@ pub enum IpAddr {
 /// assert!("0xcb.0x0.0x71.0x00".parse::<Ipv4Addr>().is_err()); // all octets are in hex
 /// ```
 #[rustc_diagnostic_item = "Ipv4Addr"]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Ipv4Addr {
     octets: [u8; 4],
@@ -161,7 +162,8 @@ fn hash<H: Hasher>(&self, state: &mut H) {
 /// assert_eq!(localhost.is_loopback(), true);
 /// ```
 #[rustc_diagnostic_item = "Ipv6Addr"]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Ipv6Addr {
     octets: [u8; 16],
@@ -1183,7 +1185,8 @@ fn eq(&self, other: &IpAddr) -> bool {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd for Ipv4Addr {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const PartialOrd for Ipv4Addr {
     #[inline]
     fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
         Some(self.cmp(other))
@@ -1213,7 +1216,8 @@ fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Ord for Ipv4Addr {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const Ord for Ipv4Addr {
     #[inline]
     fn cmp(&self, other: &Ipv4Addr) -> Ordering {
         self.octets.cmp(&other.octets)
@@ -2177,7 +2181,8 @@ fn eq(&self, other: &Ipv6Addr) -> bool {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd for Ipv6Addr {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const PartialOrd for Ipv6Addr {
     #[inline]
     fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
         Some(self.cmp(other))
@@ -2207,7 +2212,8 @@ fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Ord for Ipv6Addr {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const Ord for Ipv6Addr {
     #[inline]
     fn cmp(&self, other: &Ipv6Addr) -> Ordering {
         self.segments().cmp(&other.segments())
diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index 2390ca74a8e0..69a01eef88f9 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -3,7 +3,9 @@
 use super::{from_raw_parts, memchr};
 use crate::ascii;
 use crate::cmp::{self, BytewiseEq, Ordering};
+use crate::convert::Infallible;
 use crate::intrinsics::compare_bytes;
+use crate::marker::Destruct;
 use crate::mem::SizedTypeProperties;
 use crate::num::NonZero;
 use crate::ops::ControlFlow;
@@ -33,7 +35,8 @@ impl<T: [const] Eq> const Eq for [T] {}
 
 /// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Ord for [T] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Ord> const Ord for [T] {
     fn cmp(&self, other: &[T]) -> Ordering {
         SliceOrd::compare(self, other)
     }
@@ -52,7 +55,8 @@ const fn as_underlying(x: ControlFlow<bool>) -> u8 {
 
 /// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd> PartialOrd for [T] {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialOrd> const PartialOrd for [T] {
     #[inline]
     fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {
         SlicePartialOrd::partial_compare(self, other)
@@ -175,19 +179,31 @@ const trait SliceChain: Sized {
 
 type AlwaysBreak<B> = ControlFlow<B, crate::convert::Infallible>;
 
-impl<A: PartialOrd> SlicePartialOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd> const SlicePartialOrd for A {
     default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
-        let elem_chain = |a, b| match PartialOrd::partial_cmp(a, b) {
-            Some(Ordering::Equal) => ControlFlow::Continue(()),
-            non_eq => ControlFlow::Break(non_eq),
-        };
-        let len_chain = |a: &_, b: &_| ControlFlow::Break(usize::partial_cmp(a, b));
+        // FIXME(const-hack): revert this to a const closure once possible
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        const fn elem_chain<A: [const] PartialOrd>(a: &A, b: &A) -> ControlFlow<Option<Ordering>> {
+            match PartialOrd::partial_cmp(a, b) {
+                Some(Ordering::Equal) => ControlFlow::Continue(()),
+                non_eq => ControlFlow::Break(non_eq),
+            }
+        }
+
+        // FIXME(const-hack): revert this to a const closure once possible
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        const fn len_chain(a: &usize, b: &usize) -> ControlFlow<Option<Ordering>, Infallible> {
+            ControlFlow::Break(usize::partial_cmp(a, b))
+        }
+
         let AlwaysBreak::Break(b) = chaining_impl(left, right, elem_chain, len_chain);
         b
     }
 }
 
-impl<A: PartialOrd> SliceChain for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd> const SliceChain for A {
     default fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
         chaining_impl(left, right, PartialOrd::__chaining_lt, usize::__chaining_lt)
     }
@@ -202,12 +218,13 @@ impl<A: PartialOrd> SliceChain for A {
     }
 }
 
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 #[inline]
-fn chaining_impl<'l, 'r, A: PartialOrd, B, C>(
+const fn chaining_impl<'l, 'r, A: PartialOrd, B, C>(
     left: &'l [A],
     right: &'r [A],
-    elem_chain: impl Fn(&'l A, &'r A) -> ControlFlow<B>,
-    len_chain: impl for<'a> FnOnce(&'a usize, &'a usize) -> ControlFlow<B, C>,
+    elem_chain: impl [const] Fn(&'l A, &'r A) -> ControlFlow<B> + [const] Destruct,
+    len_chain: impl for<'a> [const] FnOnce(&'a usize, &'a usize) -> ControlFlow<B, C> + [const] Destruct,
 ) -> ControlFlow<B, C> {
     let l = cmp::min(left.len(), right.len());
 
@@ -216,8 +233,11 @@ fn chaining_impl<'l, 'r, A: PartialOrd, B, C>(
     let lhs = &left[..l];
     let rhs = &right[..l];
 
-    for i in 0..l {
+    // FIXME(const-hack): revert this to `for i in 0..l` once `impl const Iterator for Range<T>`
+    let mut i: usize = 0;
+    while i < l {
         elem_chain(&lhs[i], &rhs[i])?;
+        i += 1;
     }
 
     len_chain(&left.len(), &right.len())
@@ -270,13 +290,24 @@ const trait SliceOrd: Sized {
     fn compare(left: &[Self], right: &[Self]) -> Ordering;
 }
 
-impl<A: Ord> SliceOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] Ord> const SliceOrd for A {
     default fn compare(left: &[Self], right: &[Self]) -> Ordering {
-        let elem_chain = |a, b| match Ord::cmp(a, b) {
-            Ordering::Equal => ControlFlow::Continue(()),
-            non_eq => ControlFlow::Break(non_eq),
-        };
-        let len_chain = |a: &_, b: &_| ControlFlow::Break(usize::cmp(a, b));
+        // FIXME(const-hack): revert this to a const closure once possible
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        const fn elem_chain<A: [const] Ord>(a: &A, b: &A) -> ControlFlow<Ordering> {
+            match Ord::cmp(a, b) {
+                Ordering::Equal => ControlFlow::Continue(()),
+                non_eq => ControlFlow::Break(non_eq),
+            }
+        }
+
+        // FIXME(const-hack): revert this to a const closure once possible
+        #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+        const fn len_chain(a: &usize, b: &usize) -> ControlFlow<Ordering, Infallible> {
+            ControlFlow::Break(usize::cmp(a, b))
+        }
+
         let AlwaysBreak::Break(b) = chaining_impl(left, right, elem_chain, len_chain);
         b
     }
diff --git a/tests/codegen-llvm/array-cmp.rs b/tests/codegen-llvm/array-cmp.rs
index 0d3376554017..0106b9c15c11 100644
--- a/tests/codegen-llvm/array-cmp.rs
+++ b/tests/codegen-llvm/array-cmp.rs
@@ -39,16 +39,6 @@ pub fn compare() -> bool {
     // CHECK: %[[EQ00:.+]] = icmp eq i16 %[[A00]], %[[B00]]
     // CHECK-NEXT: br i1 %[[EQ00]], label %[[L01:.+]], label %[[EXIT_S:.+]]
 
-    // CHECK: [[L01]]:
-    // CHECK: %[[PA01:.+]] = getelementptr{{.+}}i8, ptr %a, {{i32|i64}} 2
-    // CHECK: %[[PB01:.+]] = getelementptr{{.+}}i8, ptr %b, {{i32|i64}} 2
-    // CHECK: %[[A01:.+]] = load i16, ptr %[[PA01]]
-    // CHECK: %[[B01:.+]] = load i16, ptr %[[PB01]]
-    // CHECK-NOT: cmp
-    // CHECK: %[[EQ01:.+]] = icmp eq i16 %[[A01]], %[[B01]]
-    // CHECK-NEXT: br i1 %[[EQ01]], label %[[L10:.+]], label %[[EXIT_U:.+]]
-
-    // CHECK: [[L10]]:
     // CHECK: %[[PA10:.+]] = getelementptr{{.+}}i8, ptr %a, {{i32|i64}} 4
     // CHECK: %[[PB10:.+]] = getelementptr{{.+}}i8, ptr %b, {{i32|i64}} 4
     // CHECK: %[[A10:.+]] = load i16, ptr %[[PA10]]
@@ -64,7 +54,16 @@ pub fn compare() -> bool {
     // CHECK: %[[B11:.+]] = load i16, ptr %[[PB11]]
     // CHECK-NOT: cmp
     // CHECK: %[[EQ11:.+]] = icmp eq i16 %[[A11]], %[[B11]]
-    // CHECK-NEXT: br i1 %[[EQ11]], label %[[DONE:.+]], label %[[EXIT_U]]
+    // CHECK-NEXT: br i1 %[[EQ11]], label %[[DONE:.+]], label %[[EXIT_U:.+]]
+
+    // CHECK: [[L01]]:
+    // CHECK: %[[PA01:.+]] = getelementptr{{.+}}i8, ptr %a, {{i32|i64}} 2
+    // CHECK: %[[PB01:.+]] = getelementptr{{.+}}i8, ptr %b, {{i32|i64}} 2
+    // CHECK: %[[A01:.+]] = load i16, ptr %[[PA01]]
+    // CHECK: %[[B01:.+]] = load i16, ptr %[[PB01]]
+    // CHECK-NOT: cmp
+    // CHECK: %[[EQ01:.+]] = icmp eq i16 %[[A01]], %[[B01]]
+    // CHECK-NEXT: br i1 %[[EQ01]], label %{{.+}}, label %[[EXIT_U]]
 
     // CHECK: [[DONE]]:
     // CHECK: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_S]] ], [ %{{.+}}, %[[EXIT_U]] ], [ true, %[[L11]] ]

From 3771c65b5323bd30e963fb4a7b089be52e0f7fbe Mon Sep 17 00:00:00 2001
From: aisr <china.xuhui@gmail.com>
Date: Fri, 13 Mar 2026 18:59:18 +0800
Subject: [PATCH 0422/1059] add safety doc for CString::from_vec_unchecked and
 async_drop_in_place

---
 library/alloc/src/ffi/c_str.rs        | 4 ++++
 library/core/src/future/async_drop.rs | 9 +++++++++
 2 files changed, 13 insertions(+)

diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs
index fba967c04895..b2f4277458f1 100644
--- a/library/alloc/src/ffi/c_str.rs
+++ b/library/alloc/src/ffi/c_str.rs
@@ -321,6 +321,10 @@ fn spec_new_impl(self) -> Result<CString, NulError> {
     /// assertion is made that `v` contains no 0 bytes, and it requires an
     /// actual byte vector, not anything that can be converted to one with Into.
     ///
+    /// # Safety
+    ///
+    /// The caller must ensure `v` contains no nul bytes in its contents.
+    ///
     /// # Examples
     ///
     /// ```
diff --git a/library/core/src/future/async_drop.rs b/library/core/src/future/async_drop.rs
index c48c3f2ba281..106493fd3e81 100644
--- a/library/core/src/future/async_drop.rs
+++ b/library/core/src/future/async_drop.rs
@@ -41,6 +41,15 @@ pub trait AsyncDrop {
 }
 
 /// Async drop.
+///
+/// # Safety
+///
+/// The pointer `_to_drop` must be valid for both reads and writes,
+/// not only for the duration of this function call,
+/// but also until the returned future has completed.
+/// See [ptr::drop_in_place] for additional safety concerns.
+///
+/// [ptr::drop_in_place]: crate::ptr::drop_in_place()
 #[unstable(feature = "async_drop", issue = "126482")]
 #[lang = "async_drop_in_place"]
 pub async unsafe fn async_drop_in_place<T: ?Sized>(_to_drop: *mut T) {

From e09936e820524a32544a3681e259d8127d02b596 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Fri, 6 Mar 2026 06:26:50 +0000
Subject: [PATCH 0423/1059] Add codegen tidy check enforcing FIXME over TODO

---
 src/tools/tidy/src/codegen.rs | 60 +++++++++++++++++++++++++++++++++++
 src/tools/tidy/src/lib.rs     |  1 +
 src/tools/tidy/src/main.rs    |  1 +
 src/tools/tidy/src/style.rs   |  4 ++-
 4 files changed, 65 insertions(+), 1 deletion(-)
 create mode 100644 src/tools/tidy/src/codegen.rs

diff --git a/src/tools/tidy/src/codegen.rs b/src/tools/tidy/src/codegen.rs
new file mode 100644
index 000000000000..b87e19c40a8f
--- /dev/null
+++ b/src/tools/tidy/src/codegen.rs
@@ -0,0 +1,60 @@
+//! Tidy check for codegen backend TODO policy.
+
+use std::ffi::OsStr;
+use std::path::Path;
+
+use crate::diagnostics::{CheckId, TidyCtx};
+use crate::walk::walk;
+
+fn is_codegen_repo_path(path: &Path) -> bool {
+    const CODEGEN_REPO_PATHS: &[&str] =
+        &["compiler/rustc_codegen_cranelift", "compiler/rustc_codegen_gcc"];
+
+    CODEGEN_REPO_PATHS.iter().any(|repo| path.ancestors().any(|p| p.ends_with(Path::new(repo))))
+}
+
+fn has_supported_extension(path: &Path) -> bool {
+    const EXTENSIONS: &[&str] =
+        &["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "ftl", "toml", "yml", "yaml"];
+    path.extension().is_some_and(|ext| EXTENSIONS.iter().any(|e| ext == OsStr::new(e)))
+}
+
+pub fn check(path: &Path, tidy_ctx: TidyCtx) {
+    let mut check = tidy_ctx.start_check(CheckId::new("codegen").path(path));
+
+    fn skip(path: &Path, is_dir: bool) -> bool {
+        if path.file_name().is_some_and(|name| name.to_string_lossy().starts_with(".#")) {
+            // Editor temp file.
+            return true;
+        }
+
+        if is_dir {
+            return false;
+        }
+
+        // Scan only selected text file types.
+        !has_supported_extension(path)
+    }
+
+    walk(path, skip, &mut |entry, contents| {
+        let file = entry.path();
+
+        if !is_codegen_repo_path(file) {
+            return;
+        }
+
+        for (i, line) in contents.split('\n').enumerate() {
+            let trimmed = line.trim();
+
+            // TODO policy for codegen-only trees.
+            if trimmed.contains("TODO") {
+                check.error(format!(
+                    "{}:{}: TODO is used for tasks that should be done before merging a PR; \
+                     if you want to leave a message in the codebase use FIXME",
+                    file.display(),
+                    i + 1
+                ));
+            }
+        }
+    });
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 2cb8df782d28..292808b90cbf 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -104,6 +104,7 @@ pub fn files_modified(
 pub mod alphabetical;
 pub mod arg_parser;
 pub mod bins;
+pub mod codegen;
 pub mod debug_artifacts;
 pub mod deps;
 pub mod diagnostics;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 0e9885138d1e..1b5baf2a2197 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -109,6 +109,7 @@ macro_rules! check {
         check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path]);
         check!(target_policy, &root_path);
         check!(gcc_submodule, &root_path, &compiler_path);
+        check!(codegen, &compiler_path);
 
         // Checks that only make sense for the std libs.
         check!(pal, &library_path);
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 111fe89e7eb0..3e62cc9852db 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -378,6 +378,7 @@ fn skip(path: &Path, is_dir: bool) -> bool {
     // In some cases, a style check would be triggered by its own implementation
     // or comments. A simple workaround is to just allowlist this file.
     let this_file = Path::new(file!());
+    let codegen_file = Path::new("src/tools/tidy/src/codegen.rs");
 
     walk(path, skip, &mut |entry, contents| {
         let file = entry.path();
@@ -449,6 +450,7 @@ fn skip(path: &Path, is_dir: bool) -> bool {
         let is_this_file = file.ends_with(this_file) || this_file.ends_with(file);
         let is_test_for_this_file =
             is_test && file.parent().unwrap().ends_with(this_file.with_extension(""));
+        let is_codegen_tidy_file = file.ends_with(codegen_file);
         // scanning the whole file for multiple needles at once is more efficient than
         // executing lines times needles separate searches.
         let any_problematic_line =
@@ -516,7 +518,7 @@ fn skip(path: &Path, is_dir: bool) -> bool {
             if line.contains('\r') {
                 suppressible_tidy_err!(err, skip_cr, "CR character");
             }
-            if !is_this_file {
+            if !is_this_file && !is_codegen_tidy_file {
                 let directive_line_starts = ["// ", "# ", "/* ", "<!-- "];
                 let possible_line_start =
                     directive_line_starts.into_iter().any(|s| line.starts_with(s));

From 6e7d6d78217f0311ed37d67ec85119020a1e847d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 12 Mar 2026 16:43:36 +0100
Subject: [PATCH 0424/1059] Add `Wake` diagnostic item for `alloc::task::Wake`

---
 library/alloc/src/task.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/alloc/src/task.rs b/library/alloc/src/task.rs
index aa1901314e37..bc668f78bf74 100644
--- a/library/alloc/src/task.rs
+++ b/library/alloc/src/task.rs
@@ -87,6 +87,7 @@
 /// ```
 #[cfg(target_has_atomic = "ptr")]
 #[stable(feature = "wake_trait", since = "1.51.0")]
+#[rustc_diagnostic_item = "Wake"]
 pub trait Wake {
     /// Wake this task.
     #[stable(feature = "wake_trait", since = "1.51.0")]

From b7c226c0b0587b0bf38bcc54ea4d65e3d3484db9 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Fri, 6 Mar 2026 12:12:26 -0500
Subject: [PATCH 0425/1059] tests: accept new GEP source element type

---
 tests/codegen-llvm/gep-index.rs           | 8 ++++----
 tests/codegen-llvm/issues/issue-118306.rs | 2 +-
 tests/codegen-llvm/ptr-arithmetic.rs      | 6 +++---
 tests/codegen-llvm/slice-iter-nonnull.rs  | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/codegen-llvm/gep-index.rs b/tests/codegen-llvm/gep-index.rs
index bfb2511af87a..c7c644e42d9f 100644
--- a/tests/codegen-llvm/gep-index.rs
+++ b/tests/codegen-llvm/gep-index.rs
@@ -11,27 +11,27 @@
 // CHECK-LABEL: @index_on_struct(
 #[no_mangle]
 fn index_on_struct(a: &[Foo], index: usize) -> &Foo {
-    // CHECK: getelementptr inbounds{{( nuw)?}} %Foo, ptr %a.0, {{i64|i32}} %index
+    // CHECK: getelementptr inbounds{{( nuw)?}} {{%Foo|\[8 x i8\]}}, ptr %a.0, {{i64|i32}} %index
     &a[index]
 }
 
 // CHECK-LABEL: @offset_on_struct(
 #[no_mangle]
 fn offset_on_struct(a: *const Foo, index: usize) -> *const Foo {
-    // CHECK: getelementptr inbounds{{( nuw)?}} %Foo, ptr %a, {{i64|i32}} %index
+    // CHECK: getelementptr inbounds{{( nuw)?}} {{%Foo|\[8 x i8\]}}, ptr %a, {{i64|i32}} %index
     unsafe { a.add(index) }
 }
 
 // CHECK-LABEL: @index_on_i32(
 #[no_mangle]
 fn index_on_i32(a: &[i32], index: usize) -> &i32 {
-    // CHECK: getelementptr inbounds{{( nuw)?}} i32, ptr %a.0, {{i64|i32}} %index
+    // CHECK: getelementptr inbounds{{( nuw)?}} {{i32|\[4 x i8\]}}, ptr %a.0, {{i64|i32}} %index
     &a[index]
 }
 
 // CHECK-LABEL: @offset_on_i32(
 #[no_mangle]
 fn offset_on_i32(a: *const i32, index: usize) -> *const i32 {
-    // CHECK: getelementptr inbounds{{( nuw)?}} i32, ptr %a, {{i64|i32}} %index
+    // CHECK: getelementptr inbounds{{( nuw)?}} {{i32|\[4 x i8\]}}, ptr %a, {{i64|i32}} %index
     unsafe { a.add(index) }
 }
diff --git a/tests/codegen-llvm/issues/issue-118306.rs b/tests/codegen-llvm/issues/issue-118306.rs
index 934a7687b601..ea8b24317ff1 100644
--- a/tests/codegen-llvm/issues/issue-118306.rs
+++ b/tests/codegen-llvm/issues/issue-118306.rs
@@ -11,7 +11,7 @@ pub fn branchy(input: u64) -> u64 {
     // CHECK-LABEL: @branchy(
     // CHECK-NEXT:  start:
     // CHECK-NEXT:    [[_2:%.*]] = and i64 [[INPUT:%.*]], 3
-    // CHECK-NEXT:    [[SWITCH_GEP:%.*]] = getelementptr inbounds{{( nuw)?}} {{\[4 x i64\]|i64}}, ptr @switch.table.branchy{{(, i64 0)?}}, i64 [[_2]]
+    // CHECK-NEXT:    [[SWITCH_GEP:%.*]] = getelementptr inbounds{{( nuw)?}} {{\[4 x i64\]|i64|\[8 x i8\]}}, ptr @switch.table.branchy{{(, i64 0)?}}, i64 [[_2]]
     // CHECK-NEXT:    [[SWITCH_LOAD:%.*]] = load i64, ptr [[SWITCH_GEP]]
     // CHECK-NEXT:    ret i64 [[SWITCH_LOAD]]
     match input % 4 {
diff --git a/tests/codegen-llvm/ptr-arithmetic.rs b/tests/codegen-llvm/ptr-arithmetic.rs
index fc4441ef4486..c0ae28ca70ad 100644
--- a/tests/codegen-llvm/ptr-arithmetic.rs
+++ b/tests/codegen-llvm/ptr-arithmetic.rs
@@ -6,7 +6,7 @@
 // CHECK-SAME: [[WORD:i[0-9]+]] noundef %n)
 #[no_mangle]
 pub unsafe fn i32_add(p: *const i32, n: usize) -> *const i32 {
-    // CHECK: %[[TEMP:.+]] = getelementptr inbounds{{( nuw)?}} i32, ptr %p, [[WORD]] %n
+    // CHECK: %[[TEMP:.+]] = getelementptr inbounds{{( nuw)?}} {{i32|\[4 x i8\]}}, ptr %p, [[WORD]] %n
     // CHECK: ret ptr %[[TEMP]]
     p.add(n)
 }
@@ -18,7 +18,7 @@ pub unsafe fn i32_add(p: *const i32, n: usize) -> *const i32 {
 #[no_mangle]
 pub unsafe fn i32_sub(p: *const i32, n: usize) -> *const i32 {
     // CHECK: %[[DELTA:.+]] = sub nsw [[WORD]] 0, %n
-    // CHECK: %[[TEMP:.+]] = getelementptr inbounds i32, ptr %p, [[WORD]] %[[DELTA]]
+    // CHECK: %[[TEMP:.+]] = getelementptr inbounds {{i32|\[4 x i8\]}}, ptr %p, [[WORD]] %[[DELTA]]
     // CHECK: ret ptr %[[TEMP]]
     p.sub(n)
 }
@@ -27,7 +27,7 @@ pub unsafe fn i32_sub(p: *const i32, n: usize) -> *const i32 {
 // CHECK-SAME: [[WORD:i[0-9]+]] noundef %d)
 #[no_mangle]
 pub unsafe fn i32_offset(p: *const i32, d: isize) -> *const i32 {
-    // CHECK: %[[TEMP:.+]] = getelementptr inbounds i32, ptr %p, [[WORD]] %d
+    // CHECK: %[[TEMP:.+]] = getelementptr inbounds {{i32|\[4 x i8\]}}, ptr %p, [[WORD]] %d
     // CHECK: ret ptr %[[TEMP]]
     p.offset(d)
 }
diff --git a/tests/codegen-llvm/slice-iter-nonnull.rs b/tests/codegen-llvm/slice-iter-nonnull.rs
index 280594456c93..6b8416662314 100644
--- a/tests/codegen-llvm/slice-iter-nonnull.rs
+++ b/tests/codegen-llvm/slice-iter-nonnull.rs
@@ -55,7 +55,7 @@ pub fn slice_iter_next_back<'a>(it: &mut std::slice::Iter<'a, u32>) -> Option<&'
 #[no_mangle]
 pub fn slice_iter_new(slice: &[u32]) -> std::slice::Iter<'_, u32> {
     // CHECK-NOT: slice
-    // CHECK: %[[END:.+]] = getelementptr inbounds{{( nuw)?}} i32{{.+}} %slice.0{{.+}} %slice.1
+    // CHECK: %[[END:.+]] = getelementptr inbounds{{( nuw)?}} {{i32|\[4 x i8\]}}{{.+}} %slice.0{{.+}} %slice.1
     // CHECK-NOT: slice
     // CHECK: insertvalue {{.+}} ptr %slice.0, 0
     // CHECK-NOT: slice
@@ -70,7 +70,7 @@ pub fn slice_iter_new(slice: &[u32]) -> std::slice::Iter<'_, u32> {
 #[no_mangle]
 pub fn slice_iter_mut_new(slice: &mut [u32]) -> std::slice::IterMut<'_, u32> {
     // CHECK-NOT: slice
-    // CHECK: %[[END:.+]] = getelementptr inbounds{{( nuw)?}} i32{{.+}} %slice.0{{.+}} %slice.1
+    // CHECK: %[[END:.+]] = getelementptr inbounds{{( nuw)?}} {{i32|\[4 x i8\]}}{{.+}} %slice.0{{.+}} %slice.1
     // CHECK-NOT: slice
     // CHECK: insertvalue {{.+}} ptr %slice.0, 0
     // CHECK-NOT: slice

From 201bbb30a4faa261f488afae6b6fb66d4b210e0d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 13 Mar 2026 22:34:06 +0800
Subject: [PATCH 0426/1059] fix: offer on const like path-expr for
 'extract_variable'

Example
---
```rust
struct Foo;
fn foo() -> Foo {
    $0Foo$0
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
struct Foo;
fn foo() -> Foo {
    let foo = Foo;
    foo
}
```
---
 .../src/handlers/extract_variable.rs          | 61 +++++++++++++++++--
 1 file changed, 56 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
index 7c6018414217..6cba52a3b9fd 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
@@ -75,7 +75,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
             .next()
             .and_then(ast::Expr::cast)
         {
-            expr.syntax().ancestors().find_map(valid_target_expr)?.syntax().clone()
+            expr.syntax().ancestors().find_map(valid_target_expr(ctx))?.syntax().clone()
         } else {
             return None;
         }
@@ -96,7 +96,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
     let to_extract = node
         .descendants()
         .take_while(|it| range.contains_range(it.text_range()))
-        .find_map(valid_target_expr)?;
+        .find_map(valid_target_expr(ctx))?;
 
     let ty = ctx.sema.type_of_expr(&to_extract).map(TypeInfo::adjusted);
     if matches!(&ty, Some(ty_info) if ty_info.is_unit()) {
@@ -283,14 +283,19 @@ fn peel_parens(mut expr: ast::Expr) -> ast::Expr {
 
 /// Check whether the node is a valid expression which can be extracted to a variable.
 /// In general that's true for any expression, but in some cases that would produce invalid code.
-fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
-    match node.kind() {
-        SyntaxKind::PATH_EXPR | SyntaxKind::LOOP_EXPR | SyntaxKind::LET_EXPR => None,
+fn valid_target_expr(ctx: &AssistContext<'_>) -> impl Fn(SyntaxNode) -> Option<ast::Expr> {
+    |node| match node.kind() {
+        SyntaxKind::LOOP_EXPR | SyntaxKind::LET_EXPR => None,
         SyntaxKind::BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
         SyntaxKind::RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
         SyntaxKind::BLOCK_EXPR => {
             ast::BlockExpr::cast(node).filter(|it| it.is_standalone()).map(ast::Expr::from)
         }
+        SyntaxKind::PATH_EXPR => {
+            let path_expr = ast::PathExpr::cast(node)?;
+            let path_resolution = ctx.sema.resolve_path(&path_expr.path()?)?;
+            like_const_value(ctx, path_resolution).then_some(path_expr.into())
+        }
         _ => ast::Expr::cast(node),
     }
 }
@@ -455,6 +460,31 @@ fn from(to_extract: &ast::Expr, kind: &ExtractionKind) -> Option<Anchor> {
     }
 }
 
+fn like_const_value(ctx: &AssistContext<'_>, path_resolution: hir::PathResolution) -> bool {
+    let db = ctx.db();
+    let adt_like_const_value = |adt: Option<hir::Adt>| matches!(adt, Some(hir::Adt::Struct(s)) if s.kind(db) == hir::StructKind::Unit);
+    match path_resolution {
+        hir::PathResolution::Def(def) => match def {
+            hir::ModuleDef::Adt(adt) => adt_like_const_value(Some(adt)),
+            hir::ModuleDef::Variant(variant) => variant.kind(db) == hir::StructKind::Unit,
+            hir::ModuleDef::TypeAlias(ty) => adt_like_const_value(ty.ty(db).as_adt()),
+            hir::ModuleDef::Const(_) | hir::ModuleDef::Static(_) => true,
+            hir::ModuleDef::Trait(_)
+            | hir::ModuleDef::BuiltinType(_)
+            | hir::ModuleDef::Macro(_)
+            | hir::ModuleDef::Module(_) => false,
+            hir::ModuleDef::Function(_) => false, // no extract named function
+        },
+        hir::PathResolution::SelfType(ty) => adt_like_const_value(ty.self_ty(db).as_adt()),
+        hir::PathResolution::ConstParam(_) => true,
+        hir::PathResolution::Local(_)
+        | hir::PathResolution::TypeParam(_)
+        | hir::PathResolution::BuiltinAttr(_)
+        | hir::PathResolution::ToolModule(_)
+        | hir::PathResolution::DeriveHelper(_) => false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     // NOTE: We use check_assist_by_label, but not check_assist_not_applicable_by_label
@@ -1747,6 +1777,27 @@ fn main() {
         );
     }
 
+    #[test]
+    fn extract_non_local_path_expr() {
+        check_assist_by_label(
+            extract_variable,
+            r#"
+struct Foo;
+fn foo() -> Foo {
+    $0Foo$0
+}
+"#,
+            r#"
+struct Foo;
+fn foo() -> Foo {
+    let $0foo = Foo;
+    foo
+}
+"#,
+            "Extract into variable",
+        );
+    }
+
     #[test]
     fn extract_var_for_return_not_applicable() {
         check_assist_not_applicable(extract_variable, "fn foo() { $0return$0; } ");

From 83c0242cf4583427bbf666dbba9b9045732eb089 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 13 Mar 2026 09:39:09 -0400
Subject: [PATCH 0427/1059] Update cargo submodule

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index 90ed291a50ef..cbb9bb8bd0fb 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 90ed291a50efc459e0c380d7b455777ed41c6799
+Subproject commit cbb9bb8bd0fb272b1be0d63a010701ecb3d1d6d3

From 3eb071edf929794d455c116350f2845202c13dca Mon Sep 17 00:00:00 2001
From: khyperia <953151+khyperia@users.noreply.github.com>
Date: Fri, 13 Mar 2026 17:03:58 +0100
Subject: [PATCH 0428/1059] Flip "region lattice" in RegionKind doc comment

---
 compiler/rustc_type_ir/src/region_kind.rs     | 68 ++++++++++---------
 .../src/early-late-parameters.md              |  6 ++
 2 files changed, 43 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs
index e08c274f9f14..3df2d8c489c6 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -34,26 +34,26 @@ pub struct RegionVid {}
 /// In general, the region lattice looks like
 ///
 /// ```text
-/// static ----------+-----...------+       (greatest)
+/// empty(Un) --------                      (smallest)
+/// |                 \
+/// ...                \
+/// |                   \
+/// empty(U1) --         \
+/// |           \         placeholder(Un)
+/// |            \                  |
+/// empty(root)   placeholder(U1)   |
+/// |                |              |
+/// |                |              |
 /// |                |              |
 /// param regions    |              |
 /// |                |              |
-/// |                |              |
-/// |                |              |
-/// empty(root)   placeholder(U1)   |
-/// |            /                  |
-/// |           /         placeholder(Un)
-/// empty(U1) --         /
-/// |                   /
-/// ...                /
-/// |                 /
-/// empty(Un) --------                      (smallest)
+/// static ----------+-----...------+       (greatest)
 /// ```
 ///
-/// Early-bound/free regions are the named lifetimes in scope from the
-/// function declaration. They have relationships to one another
-/// determined based on the declared relationships from the
-/// function.
+/// Lifetimes in scope from a function declaration are represented via
+/// [`RegionKind::ReEarlyParam`]/[`RegionKind::ReLateParam`]. They
+/// have relationships to one another and `'static` based on the
+/// declared relationships from the function.
 ///
 /// Note that inference variables and bound regions are not included
 /// in this diagram. In the case of inference variables, they should
@@ -62,29 +62,36 @@ pub struct RegionVid {}
 /// include -- the diagram indicates the relationship between free
 /// regions.
 ///
+/// You can read more about the distinction between early and late bound
+/// parameters in the rustc dev guide: [Early vs Late bound parameters].
+///
+/// A note on subtyping: If we assume that references take their region
+/// covariantly, and use that to define the subtyping relationship of regions,
+/// it may be somewhat surprising that `'empty` is Top and `'static` is Bottom,
+/// and that "`'a` is a subtype of `'b`" is defined as "`'a` is bigger than
+/// `'b`" - good to keep in mind.
+///
 /// ## Inference variables
 ///
 /// During region inference, we sometimes create inference variables,
-/// represented as `ReVar`. These will be inferred by the code in
-/// `infer::lexical_region_resolve` to some free region from the
-/// lattice above (the minimal region that meets the
+/// represented as [`RegionKind::ReVar`]. These will be inferred by
+/// the code in `infer::lexical_region_resolve` to some free region
+/// from the lattice above (the minimal region that meets the
 /// constraints).
 ///
 /// During NLL checking, where regions are defined differently, we
-/// also use `ReVar` -- in that case, the index is used to index into
-/// the NLL region checker's data structures. The variable may in fact
-/// represent either a free region or an inference variable, in that
-/// case.
+/// also use [`RegionKind::ReVar`] -- in that case, the index is used
+/// to index into the NLL region checker's data structures. The
+/// variable may in fact represent either a free region or an
+/// inference variable, in that case.
 ///
 /// ## Bound Regions
 ///
 /// These are regions that are stored behind a binder and must be instantiated
-/// with some concrete region before being used. There are two kind of
-/// bound regions: early-bound, which are bound in an item's `Generics`,
-/// and are instantiated by an `GenericArgs`, and late-bound, which are part of
-/// higher-ranked types (e.g., `for<'a> fn(&'a ())`), and are instantiated by
-/// the likes of `liberate_late_bound_regions`. The distinction exists
-/// because higher-ranked lifetimes aren't supported in all places. See [1][2].
+/// with some concrete region before being used. A type can be wrapped in a
+/// `Binder`, which introduces new type/const/lifetime variables (e.g., `for<'a>
+/// fn(&'a ())`). These parameters are referred to via [`RegionKind::ReBound`].
+/// You can instantiate them by the likes of `liberate_late_bound_regions`.
 ///
 /// Unlike `Param`s, bound regions are not supposed to exist "in the wild"
 /// outside their binder, e.g., in types passed to type inference, and
@@ -123,8 +130,7 @@ pub struct RegionVid {}
 /// happen, you can use `leak_check`. This is more clearly explained
 /// by the [rustc dev guide].
 ///
-/// [1]: https://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/
-/// [2]: https://smallcultfollowing.com/babysteps/blog/2013/11/04/intermingled-parameter-lists/
+/// [Early vs Late bound parameters]: https://rustc-dev-guide.rust-lang.org/early-late-parameters.html
 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
 #[derive_where(Clone, Copy, Hash, PartialEq; I: Interner)]
 #[derive(GenericTypeVisitable)]
@@ -160,7 +166,7 @@ pub enum RegionKind<I: Interner> {
     /// more info about early and late bound lifetime parameters.
     ReLateParam(I::LateParamRegion),
 
-    /// Static data that has an "infinite" lifetime. Top in the region lattice.
+    /// Static data that has an "infinite" lifetime. Bottom in the region lattice.
     ReStatic,
 
     /// A region variable. Should not exist outside of type inference.
diff --git a/src/doc/rustc-dev-guide/src/early-late-parameters.md b/src/doc/rustc-dev-guide/src/early-late-parameters.md
index c472bdc2c481..7651dee4ae23 100644
--- a/src/doc/rustc-dev-guide/src/early-late-parameters.md
+++ b/src/doc/rustc-dev-guide/src/early-late-parameters.md
@@ -3,6 +3,12 @@
 
 > **NOTE**: This chapter largely talks about early/late bound as being solely relevant when discussing function item types/function definitions. This is potentially not completely true, async blocks and closures should likely be discussed somewhat in this chapter.
 
+See also these blog posts from when the distinction between early and late bound parameters was
+introduced: [Intermingled parameter lists] and [Intermingled parameter lists, take 2].
+
+[Intermingled parameter lists]: https://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/
+[Intermingled parameter lists, take 2]: https://smallcultfollowing.com/babysteps/blog/2013/11/04/intermingled-parameter-lists/
+
 ## What does it mean to be "early" bound or "late" bound
 
 Every function definition has a corresponding ZST that implements the `Fn*` traits known as a [function item type][function_item_type]. This part of the chapter will talk a little bit about the "desugaring" of function item types as it is useful context for explaining the difference between early bound and late bound generic parameters.

From d19a07b2a9d7f0a18409485451c12632b93ff674 Mon Sep 17 00:00:00 2001
From: Guillaume <guillaume.alabre@gmail.com>
Date: Wed, 4 Mar 2026 00:47:53 +0100
Subject: [PATCH 0429/1059] Fix LegacyKeyValueFormat report from docker build:
 x86_64-gnu

---
 .../docker/host-x86_64/x86_64-gnu-aux/Dockerfile   |  4 ++--
 .../docker/host-x86_64/x86_64-gnu-debug/Dockerfile | 14 ++++++--------
 .../host-x86_64/x86_64-gnu-distcheck/Dockerfile    |  6 +++---
 .../docker/host-x86_64/x86_64-gnu-gcc/Dockerfile   | 11 +++++------
 .../host-x86_64/x86_64-gnu-llvm-21/Dockerfile      | 11 +++++------
 .../docker/host-x86_64/x86_64-gnu-miri/Dockerfile  |  9 ++++-----
 .../docker/host-x86_64/x86_64-gnu-nopt/Dockerfile  |  8 ++++----
 .../docker/host-x86_64/x86_64-gnu-tools/Dockerfile | 11 +++++------
 src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile    |  7 +++----
 9 files changed, 37 insertions(+), 44 deletions(-)

diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-aux/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-aux/Dockerfile
index d4113736b544..95ddaab7f44b 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-aux/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-aux/Dockerfile
@@ -29,5 +29,5 @@ RUN sh /scripts/sccache.sh
 ENV NO_DEBUG_ASSERTIONS=1
 ENV NO_OVERFLOW_CHECKS=1
 
-ENV RUST_CONFIGURE_ARGS --build=x86_64-unknown-linux-gnu
-ENV RUST_CHECK_TARGET check-aux
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu"
+ENV RUST_CHECK_TARGET="check-aux"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
index 54b13c4397f4..5287d6b8956f 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
@@ -29,20 +29,19 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUSTBUILD_FORCE_CLANG_BASED_TESTS 1
+ENV RUSTBUILD_FORCE_CLANG_BASED_TESTS="1"
 
 # llvm.use-linker conflicts with downloading CI LLVM
-ENV NO_DOWNLOAD_CI_LLVM 1
+ENV NO_DOWNLOAD_CI_LLVM="1"
 
-ENV RUST_CONFIGURE_ARGS \
-      --build=x86_64-unknown-linux-gnu \
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
       --enable-debug \
       --enable-lld \
       --set rust.debuginfo-level-tests=2 \
       --set llvm.use-linker=lld \
       --set target.x86_64-unknown-linux-gnu.linker=clang \
       --set target.x86_64-unknown-linux-gnu.cc=clang \
-      --set target.x86_64-unknown-linux-gnu.cxx=clang++
+      --set target.x86_64-unknown-linux-gnu.cxx=clang++"
 
 # This job checks:
 # - That ui tests can be built with `-Cdebuginfo=1`
@@ -53,7 +52,6 @@ ENV RUST_CONFIGURE_ARGS \
 # - That the tests with `//@ needs-force-clang-based-tests` pass, since they
 #   don't run by default unless RUSTBUILD_FORCE_CLANG_BASED_TESTS is set.
 
-ENV SCRIPT \
-  python3 ../x.py --stage 2 build && \
+ENV SCRIPT="python3 ../x.py --stage 2 build && \
   python3 ../x.py --stage 2 test tests/ui && \
-  python3 ../x.py --stage 2 test tests/run-make tests/run-make-cargo
+  python3 ../x.py --stage 2 test tests/run-make tests/run-make-cargo"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-distcheck/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-distcheck/Dockerfile
index 5bafd89cfd91..5ab44df7a803 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-distcheck/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-distcheck/Dockerfile
@@ -1,5 +1,5 @@
 # Runs `distcheck`, which is a collection of smoke tests:
-# 
+#
 # - Run `make check` from an unpacked dist tarball to make sure we can at the
 #   minimum run check steps from those sources.
 # - Check that selected dist components at least have expected directory shape
@@ -34,6 +34,6 @@ COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
 # Make distcheck builds faster
-ENV DISTCHECK_CONFIGURE_ARGS "--enable-sccache"
+ENV DISTCHECK_CONFIGURE_ARGS="--enable-sccache"
 
-ENV SCRIPT python3 ../x.py test distcheck
+ENV SCRIPT="python3 ../x.py test distcheck"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
index f9c1ea531add..2208ed3ffbe1 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-gcc/Dockerfile
@@ -31,15 +31,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV NO_DEBUG_ASSERTIONS 1
-ENV RUST_CONFIGURE_ARGS \
- --build=x86_64-unknown-linux-gnu \
+ENV NO_DEBUG_ASSERTIONS="1"
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
  --enable-sanitizers \
  --enable-profiler \
  --enable-compiler-docs \
  --set llvm.libzstd=true \
- --set 'rust.codegen-backends=[\"llvm\",\"gcc\"]'
-ENV SCRIPT python3 ../x.py \
+ --set rust.codegen-backends=[\\\"llvm\\\",\\\"gcc\\\"]"
+ENV SCRIPT="python3 ../x.py \
   --stage 2 \
   test tests \
   --test-codegen-backend gcc \
@@ -51,4 +50,4 @@ ENV SCRIPT python3 ../x.py \
   --skip tests/rustdoc-js-std \
   --skip tests/rustdoc-json \
   --skip tests/rustdoc-ui \
-  --set 'rust.codegen-backends=[\"llvm\",\"gcc\"]'
+  --set rust.codegen-backends=[\\\"llvm\\\",\\\"gcc\\\"]"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile
index f0314854411f..fc9673552107 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-21/Dockerfile
@@ -44,16 +44,15 @@ RUN sh /scripts/sccache.sh
 
 # We are disabling CI LLVM since this builder is intentionally using a host
 # LLVM, rather than the typical src/llvm-project LLVM.
-ENV NO_DOWNLOAD_CI_LLVM 1
-ENV EXTERNAL_LLVM 1
+ENV NO_DOWNLOAD_CI_LLVM="1"
+ENV EXTERNAL_LLVM="1"
 
 # Using llvm-link-shared due to libffi issues -- see #34486
-ENV RUST_CONFIGURE_ARGS \
-      --build=x86_64-unknown-linux-gnu \
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
       --llvm-root=/usr/lib/llvm-21 \
       --enable-llvm-link-shared \
       --set rust.randomize-layout=true \
-      --set rust.thin-lto-import-instr-limit=10
+      --set rust.thin-lto-import-instr-limit=10"
 
 COPY scripts/shared.sh /scripts/
 
@@ -63,4 +62,4 @@ COPY scripts/x86_64-gnu-llvm3.sh /scripts/
 COPY scripts/stage_2_test_set1.sh /scripts/
 COPY scripts/stage_2_test_set2.sh /scripts/
 
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
+ENV SCRIPT="Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-miri/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-miri/Dockerfile
index db4fca71d637..e478b8004421 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-miri/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-miri/Dockerfile
@@ -34,11 +34,10 @@ ENV GCC_EXEC_PREFIX="/usr/lib/gcc/"
 
 COPY host-x86_64/x86_64-gnu-miri/check-miri.sh /tmp/
 
-ENV RUST_CONFIGURE_ARGS \
-  --build=x86_64-unknown-linux-gnu \
-  --enable-new-symbol-mangling
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
+  --enable-new-symbol-mangling"
 
-ENV HOST_TARGET x86_64-unknown-linux-gnu
+ENV HOST_TARGET="x86_64-unknown-linux-gnu"
 
 # FIXME(#133381): currently rustc alt builds do *not* have rustc debug
 # assertions enabled! Therefore, we cannot force download CI rustc.
@@ -46,4 +45,4 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 
 COPY scripts/shared.sh /scripts/
 
-ENV SCRIPT /tmp/check-miri.sh ../x.py
+ENV SCRIPT="/tmp/check-miri.sh ../x.py"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile
index 854c36ee01c1..6020dc8877c1 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile
@@ -22,8 +22,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_CONFIGURE_ARGS --build=x86_64-unknown-linux-gnu \
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
   --disable-optimize-tests \
-  --set rust.test-compare-mode
-ENV SCRIPT python3 ../x.py test --stage 1 --set rust.optimize=false library/std \
-  && python3 ../x.py --stage 2 test
+  --set rust.test-compare-mode"
+ENV SCRIPT="python3 ../x.py test --stage 1 --set rust.optimize=false library/std \
+  && python3 ../x.py --stage 2 test"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
index 278e40eb71fa..3eb424ceef4a 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
@@ -76,12 +76,11 @@ COPY scripts/nodejs.sh /scripts/
 RUN sh /scripts/nodejs.sh /node
 ENV PATH="/node/bin:${PATH}"
 
-ENV RUST_CONFIGURE_ARGS \
-  --build=x86_64-unknown-linux-gnu \
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
   --save-toolstates=/tmp/toolstate/toolstates.json \
-  --enable-new-symbol-mangling
+  --enable-new-symbol-mangling"
 
-ENV HOST_TARGET x86_64-unknown-linux-gnu
+ENV HOST_TARGET="x86_64-unknown-linux-gnu"
 
 # FIXME(#133381): currently rustc alt builds do *not* have rustc debug
 # assertions enabled! Therefore, we cannot force download CI rustc.
@@ -89,5 +88,5 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 
 COPY scripts/shared.sh /scripts/
 
-ENV SCRIPT /tmp/checktools.sh ../x.py && \
-  python3 ../x.py test tests/rustdoc-gui --stage 2 --test-args "'--jobs 1'"
+ENV SCRIPT="/tmp/checktools.sh ../x.py && \
+  python3 ../x.py test tests/rustdoc-gui --stage 2 --test-args '--jobs 1'"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
index 83c2aa8cfb3b..7ca2dbb7d9f3 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
@@ -24,10 +24,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-ENV RUST_CONFIGURE_ARGS \
- --build=x86_64-unknown-linux-gnu \
+ENV RUST_CONFIGURE_ARGS="--build=x86_64-unknown-linux-gnu \
  --enable-sanitizers \
  --enable-profiler \
  --enable-compiler-docs \
- --set llvm.libzstd=true
-ENV SCRIPT python3 ../x.py --stage 2 test
+ --set llvm.libzstd=true"
+ENV SCRIPT="python3 ../x.py --stage 2 test"

From 791f4f9315cdf85c5137c26070f2818d332d66b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Thu, 12 Mar 2026 15:55:28 +0100
Subject: [PATCH 0430/1059] Remove `value_from_cycle_error` specialization for
 `type_of_opaque_hir_typeck`

---
 compiler/rustc_query_impl/src/from_cycle_error.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 6a3155c02949..3cca35601feb 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -26,11 +26,6 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
         erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
     };
 
-    vtables.type_of_opaque_hir_typeck.value_from_cycle_error = |tcx, _, _, err| {
-        let guar = err.emit();
-        erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
-    };
-
     vtables.erase_and_anonymize_regions_ty.value_from_cycle_error = |tcx, _, _, err| {
         let guar = err.emit();
         erase_val(Ty::new_error(tcx, guar))

From cdbe2b35b55bb38ac503e0989e69cca9aa530ce5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Thu, 12 Mar 2026 16:35:50 +0100
Subject: [PATCH 0431/1059] Remove `value_from_cycle_error` specialization for
 `erase_and_anonymize_regions_ty`

---
 compiler/rustc_query_impl/src/from_cycle_error.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 3cca35601feb..0cc3b2cf7eec 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -26,11 +26,6 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
         erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
     };
 
-    vtables.erase_and_anonymize_regions_ty.value_from_cycle_error = |tcx, _, _, err| {
-        let guar = err.emit();
-        erase_val(Ty::new_error(tcx, guar))
-    };
-
     vtables.fn_sig.value_from_cycle_error = |tcx, key, _, err| {
         let guar = err.delay_as_bug();
         erase_val(fn_sig(tcx, key, guar))

From fed57899b93d6e17b00bf00326d7b9aebdccc6e0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Thu, 12 Mar 2026 17:02:49 +0100
Subject: [PATCH 0432/1059] Remove `value_from_cycle_error` specialization for
 `type_of`

---
 .../rustc_query_impl/src/from_cycle_error.rs  |  5 --
 tests/incremental/const-generic-type-cycle.rs |  2 -
 tests/ui/consts/issue-103790.rs               |  1 -
 tests/ui/consts/issue-103790.stderr           | 14 +----
 .../ui/delegation/unsupported.current.stderr  | 19 +++---
 tests/ui/delegation/unsupported.next.stderr   | 15 +----
 tests/ui/delegation/unsupported.rs            |  1 -
 ...ompatability-via-leakage-cycle.next.stderr | 62 +------------------
 tests/ui/issues/issue-34373.rs                |  1 -
 tests/ui/issues/issue-34373.stderr            | 16 +----
 ...ce-hir-wf-check-anon-const-issue-122199.rs |  1 -
 ...ir-wf-check-anon-const-issue-122199.stderr | 10 +--
 ...ce-hir-wf-check-anon-const-issue-122989.rs |  2 -
 ...ir-wf-check-anon-const-issue-122989.stderr | 22 +------
 14 files changed, 20 insertions(+), 151 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 0cc3b2cf7eec..8214f80cda41 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -21,11 +21,6 @@
 use crate::job::report_cycle;
 
 pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
-    vtables.type_of.value_from_cycle_error = |tcx, _, _, err| {
-        let guar = err.emit();
-        erase_val(ty::EarlyBinder::bind(Ty::new_error(tcx, guar)))
-    };
-
     vtables.fn_sig.value_from_cycle_error = |tcx, key, _, err| {
         let guar = err.delay_as_bug();
         erase_val(fn_sig(tcx, key, guar))
diff --git a/tests/incremental/const-generic-type-cycle.rs b/tests/incremental/const-generic-type-cycle.rs
index 5bcbc1d5dafe..85b8092787e2 100644
--- a/tests/incremental/const-generic-type-cycle.rs
+++ b/tests/incremental/const-generic-type-cycle.rs
@@ -13,7 +13,5 @@ trait Bar<const N: usize> {}
 #[cfg(cfail)]
 trait Bar<const N: dyn BB> {}
 //[cfail]~^ ERROR cycle detected when computing type of `Bar::N`
-//[cfail]~| ERROR cycle detected when computing type of `Bar::N`
-//[cfail]~| ERROR `(dyn Bar<{ 2 + 1 }> + 'static)` is forbidden as the type of a const generic parameter
 
 trait BB = Bar<{ 2 + 1 }>;
diff --git a/tests/ui/consts/issue-103790.rs b/tests/ui/consts/issue-103790.rs
index 869a43e4018b..a85833a56537 100644
--- a/tests/ui/consts/issue-103790.rs
+++ b/tests/ui/consts/issue-103790.rs
@@ -5,6 +5,5 @@
 //~^ ERROR the name `S` is already used for a generic parameter in this item's generic parameters
 //~| ERROR missing generics for struct `S`
 //~| ERROR cycle detected when computing type of `S::S`
-//~| ERROR `()` is forbidden as the type of a const generic parameter
 
 fn main() {}
diff --git a/tests/ui/consts/issue-103790.stderr b/tests/ui/consts/issue-103790.stderr
index adfac02bd0ce..e442c64e70ce 100644
--- a/tests/ui/consts/issue-103790.stderr
+++ b/tests/ui/consts/issue-103790.stderr
@@ -36,19 +36,7 @@ LL | struct S<const S: (), const S: S = { S }>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: `()` is forbidden as the type of a const generic parameter
-  --> $DIR/issue-103790.rs:4:19
-   |
-LL | struct S<const S: (), const S: S = { S }>;
-   |                   ^^
-   |
-   = note: the only supported types are integers, `bool`, and `char`
-help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
-   |
-LL + #![feature(adt_const_params)]
-   |
-
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0107, E0391, E0403.
 For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/delegation/unsupported.current.stderr b/tests/ui/delegation/unsupported.current.stderr
index 9bc2eec068fe..657f99027173 100644
--- a/tests/ui/delegation/unsupported.current.stderr
+++ b/tests/ui/delegation/unsupported.current.stderr
@@ -29,18 +29,13 @@ note: ...which requires comparing an impl and trait method signature, inferring
 LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
    = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`, completing the cycle
-   = note: cycle used when checking effective visibilities
+note: cycle used when checking assoc item `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret` is compatible with trait definition
+  --> $DIR/unsupported.rs:33:24
+   |
+LL |         reuse ToReuse::opaque_ret;
+   |                        ^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0283]: type annotations needed
-  --> $DIR/unsupported.rs:54:18
-   |
-LL |     reuse Trait::foo;
-   |                  ^^^ cannot infer type
-   |
-   = note: cannot satisfy `_: effects::Trait`
+error: aborting due to 2 previous errors
 
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0283, E0391.
-For more information about an error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/delegation/unsupported.next.stderr b/tests/ui/delegation/unsupported.next.stderr
index 08bc49513bad..90b17752cd8b 100644
--- a/tests/ui/delegation/unsupported.next.stderr
+++ b/tests/ui/delegation/unsupported.next.stderr
@@ -25,18 +25,9 @@ note: ...which requires comparing an impl and trait method signature, inferring
 LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
    = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`, completing the cycle
-   = note: cycle used when checking effective visibilities
+   = note: cycle used when computing implied outlives bounds for `<u16 as opaque::ToReuse>::opaque_ret::{anon_assoc#0}` (hack disabled = false)
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0283]: type annotations needed
-  --> $DIR/unsupported.rs:54:18
-   |
-LL |     reuse Trait::foo;
-   |                  ^^^ cannot infer type
-   |
-   = note: cannot satisfy `_: effects::Trait`
+error: aborting due to 2 previous errors
 
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0283, E0391.
-For more information about an error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/delegation/unsupported.rs b/tests/ui/delegation/unsupported.rs
index 1681888e34ea..adb798aab71d 100644
--- a/tests/ui/delegation/unsupported.rs
+++ b/tests/ui/delegation/unsupported.rs
@@ -52,7 +52,6 @@ const trait Trait {
     }
 
     reuse Trait::foo;
-    //~^ ERROR type annotations needed
 }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/method-compatability-via-leakage-cycle.next.stderr b/tests/ui/impl-trait/in-trait/method-compatability-via-leakage-cycle.next.stderr
index f0a20367a4a1..87640517ddb2 100644
--- a/tests/ui/impl-trait/in-trait/method-compatability-via-leakage-cycle.next.stderr
+++ b/tests/ui/impl-trait/in-trait/method-compatability-via-leakage-cycle.next.stderr
@@ -57,66 +57,6 @@ LL |     fn foo(b: bool) -> impl Sized {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0391]: cycle detected when computing type of `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo::{anon_assoc#0}`
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:24
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |                        ^^^^^^^^^^
-   |
-note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires computing type of `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo::{opaque#0}`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:24
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |                        ^^^^^^^^^^
-note: ...which requires computing type of opaque `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo::{opaque#0}`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:24
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |                        ^^^^^^^^^^
-note: ...which requires borrow-checking `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires promoting constants in MIR for `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires checking if `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo` contains FFI-unwind calls...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires building MIR for `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires match-checking `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: ...which requires type-checking `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo`...
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: ...which again requires computing type of `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo::{anon_assoc#0}`, completing the cycle
-note: cycle used when checking assoc item `<impl at $DIR/method-compatability-via-leakage-cycle.rs:17:1: 17:19>::foo` is compatible with trait definition
-  --> $DIR/method-compatability-via-leakage-cycle.rs:21:5
-   |
-LL |     fn foo(b: bool) -> impl Sized {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-34373.rs b/tests/ui/issues/issue-34373.rs
index 765bfc20a451..a9bd79f6830b 100644
--- a/tests/ui/issues/issue-34373.rs
+++ b/tests/ui/issues/issue-34373.rs
@@ -6,7 +6,6 @@ fn foo(_: T) {}
 
 pub struct Foo<T = Box<dyn Trait<DefaultFoo>>>;
 //~^ ERROR cycle detected when computing type of `Foo::T`
-//~| ERROR type parameter `T` is never used
 type DefaultFoo = Foo;
 
 fn main() {
diff --git a/tests/ui/issues/issue-34373.stderr b/tests/ui/issues/issue-34373.stderr
index 6d68de8fb3b8..995f2f4022b6 100644
--- a/tests/ui/issues/issue-34373.stderr
+++ b/tests/ui/issues/issue-34373.stderr
@@ -5,7 +5,7 @@ LL | pub struct Foo<T = Box<dyn Trait<DefaultFoo>>>;
    |                                  ^^^^^^^^^^
    |
 note: ...which requires expanding type alias `DefaultFoo`...
-  --> $DIR/issue-34373.rs:10:19
+  --> $DIR/issue-34373.rs:9:19
    |
 LL | type DefaultFoo = Foo;
    |                   ^^^
@@ -17,16 +17,6 @@ LL | pub struct Foo<T = Box<dyn Trait<DefaultFoo>>>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error[E0392]: type parameter `T` is never used
-  --> $DIR/issue-34373.rs:7:16
-   |
-LL | pub struct Foo<T = Box<dyn Trait<DefaultFoo>>>;
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unused type parameter
-   |
-   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
-   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
+error: aborting due to 1 previous error
 
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0391, E0392.
-For more information about an error, try `rustc --explain E0391`.
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
index 072a699a6b5b..732a5c334e50 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
@@ -4,7 +4,6 @@ trait Trait<const N: dyn Trait = bar> {
     fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
         //~^ ERROR the name `N` is already used for a generic parameter in this item's generic parameters
         //~| ERROR expected value, found builtin type `u32`
-        //~| ERROR defaults for generic parameters are not allowed here
         bar
         //~^ ERROR cannot find value `bar` in this scope
     }
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
index 47f3e83fae21..ce567b9043f0 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
@@ -20,7 +20,7 @@ LL |     fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
    |                                 ^^^ not a value
 
 error[E0425]: cannot find value `bar` in this scope
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:8:9
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:7:9
    |
 LL |         bar
    |         ^^^ not found in this scope
@@ -39,13 +39,7 @@ LL | trait Trait<const N: dyn Trait = bar> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: defaults for generic parameters are not allowed here
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:4:12
-   |
-LL |     fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0391, E0403, E0423, E0425.
 For more information about an error, try `rustc --explain E0391`.
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
index 13d7a800c51f..f2b9f037ea5f 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
@@ -4,13 +4,11 @@ trait Foo<const N: Bar<2>> {
     //~^ WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
     //~| ERROR cycle detected when computing type of `Foo::N`
-    //~| ERROR `(dyn Bar<2> + 'static)` is forbidden as the type of a const generic parameter
     fn func() {}
 }
 
 trait Bar<const M: Foo<2>> {}
 //~^ WARN trait objects without an explicit `dyn` are deprecated
 //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-//~| ERROR `(dyn Foo<2> + 'static)` is forbidden as the type of a const generic parameter
 
 fn main() {}
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
index f9a855d3b93b..4024f57af4ff 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
@@ -13,7 +13,7 @@ LL | trait Foo<const N: dyn Bar<2>> {
    |                    +++
 
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:20
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:20
    |
 LL | trait Bar<const M: Foo<2>> {}
    |                    ^^^^^^
@@ -32,7 +32,7 @@ LL | trait Foo<const N: Bar<2>> {
    |           ^^^^^^^^^^^^^^^
    |
 note: ...which requires computing type of `Bar::M`...
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:11
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:11
    |
 LL | trait Bar<const M: Foo<2>> {}
    |           ^^^^^^^^^^^^^^^
@@ -44,22 +44,6 @@ LL | trait Foo<const N: Bar<2>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: `(dyn Bar<2> + 'static)` is forbidden as the type of a const generic parameter
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:3:20
-   |
-LL | trait Foo<const N: Bar<2>> {
-   |                    ^^^^^^
-   |
-   = note: the only supported types are integers, `bool`, and `char`
-
-error: `(dyn Foo<2> + 'static)` is forbidden as the type of a const generic parameter
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:11:20
-   |
-LL | trait Bar<const M: Foo<2>> {}
-   |                    ^^^^^^
-   |
-   = note: the only supported types are integers, `bool`, and `char`
-
-error: aborting due to 3 previous errors; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0391`.

From 384f363b7023244df33bef7eb8070a334eae9b48 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Fri, 13 Mar 2026 14:32:54 -0400
Subject: [PATCH 0433/1059] change "error finalizing incremental compilation"
 from warning to note

The warning has no error code, so in a `-D warnings` environment, it's
impossible to ignore if it consistently breaks your build.  Change it
to a note so it is still visible, but doesn't break the build
---
 compiler/rustc_incremental/src/persist/fs.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index f73cc4d43e8c..cf80a7ac2c46 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -366,7 +366,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
         }
         Err(e) => {
             // Warn about the error. However, no need to abort compilation now.
-            sess.dcx().emit_warn(errors::Finalize { path: &incr_comp_session_dir, err: e });
+            sess.dcx().emit_note(errors::Finalize { path: &incr_comp_session_dir, err: e });
 
             debug!("finalize_session_directory() - error, marking as invalid");
             // Drop the file lock, so we can garage collect

From 7e72e74ea631f124809cb63f7330a09fdd165756 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Fri, 13 Mar 2026 19:34:37 +0100
Subject: [PATCH 0434/1059] mir_build only depends on lint_defs, not lints

This speeds up incremental compile times when modifying rustc_lint.
---
 Cargo.lock                                               | 2 +-
 compiler/rustc_mir_build/Cargo.toml                      | 2 +-
 compiler/rustc_mir_build/src/thir/pattern/check_match.rs | 2 +-
 compiler/rustc_mir_build/src/thir/pattern/migration.rs   | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 202e801846b8..911f773ccd90 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4344,7 +4344,7 @@ dependencies = [
  "rustc_hir",
  "rustc_index",
  "rustc_infer",
- "rustc_lint",
+ "rustc_lint_defs",
  "rustc_macros",
  "rustc_middle",
  "rustc_pattern_analysis",
diff --git a/compiler/rustc_mir_build/Cargo.toml b/compiler/rustc_mir_build/Cargo.toml
index f05183d7c068..fa22e07612cf 100644
--- a/compiler/rustc_mir_build/Cargo.toml
+++ b/compiler/rustc_mir_build/Cargo.toml
@@ -15,7 +15,7 @@ rustc_errors = { path = "../rustc_errors" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }
-rustc_lint = { path = "../rustc_lint" }
+rustc_lint_defs = { path = "../rustc_lint_defs" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_pattern_analysis = { path = "../rustc_pattern_analysis" }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index e844f1114d61..b2c1eab097ab 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -8,7 +8,7 @@
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, BindingMode, ByRef, HirId, MatchSource};
 use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::Level;
+use rustc_lint_defs::Level;
 use rustc_middle::bug;
 use rustc_middle::thir::visit::Visitor;
 use rustc_middle::thir::*;
diff --git a/compiler/rustc_mir_build/src/thir/pattern/migration.rs b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
index 96021704d329..75e23c3a2ff1 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/migration.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
@@ -3,7 +3,7 @@
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee, MultiSpan, pluralize};
 use rustc_hir::{BindingMode, ByRef, HirId, Mutability};
-use rustc_lint as lint;
+use rustc_lint_defs::builtin::RUST_2024_INCOMPATIBLE_PAT;
 use rustc_middle::ty::{self, Rust2024IncompatiblePatInfo, TyCtxt};
 use rustc_span::{Ident, Span};
 
@@ -56,7 +56,7 @@ pub(super) fn emit<'tcx>(self, tcx: TyCtxt<'tcx>, pat_id: HirId) {
             err.emit();
         } else {
             tcx.emit_node_span_lint(
-                lint::builtin::RUST_2024_INCOMPATIBLE_PAT,
+                RUST_2024_INCOMPATIBLE_PAT,
                 pat_id,
                 spans,
                 rustc_errors::DiagDecorator(|diag| {

From 1867653c81ac31900ae623e3970dba8f833bf870 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Wed, 11 Mar 2026 07:37:29 +0000
Subject: [PATCH 0435/1059] Allow calling const closures in const items

---
 .../src/collect/predicates_of.rs              |  3 +++
 .../src/ty/context/impl_interner.rs           |  5 +++++
 compiler/rustc_middle/src/ty/mod.rs           |  6 +-----
 .../src/solve/assembly/structural_traits.rs   | 21 ++++++++++++++-----
 .../src/solve/effect_goals.rs                 |  3 ++-
 compiler/rustc_type_ir/src/interner.rs        |  1 +
 tests/ui/traits/const-traits/call.rs          |  3 +--
 tests/ui/traits/const-traits/call.stderr      |  9 --------
 8 files changed, 29 insertions(+), 22 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/call.stderr

diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index e16fa5492979..98999232a743 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -1069,6 +1069,9 @@ pub(super) fn const_conditions<'tcx>(
         },
         // N.B. Tuple ctors are unconditionally constant.
         Node::Ctor(hir::VariantData::Tuple { .. }) => return Default::default(),
+        Node::Expr(hir::Expr { kind: hir::ExprKind::Closure(_), .. }) => {
+            (hir::Generics::empty(), None, tcx.is_conditionally_const(tcx.local_parent(def_id)))
+        }
         _ => bug!("const_conditions called on wrong item: {def_id:?}"),
     };
 
diff --git a/compiler/rustc_middle/src/ty/context/impl_interner.rs b/compiler/rustc_middle/src/ty/context/impl_interner.rs
index e59573976af5..5179a77d6cb6 100644
--- a/compiler/rustc_middle/src/ty/context/impl_interner.rs
+++ b/compiler/rustc_middle/src/ty/context/impl_interner.rs
@@ -402,6 +402,11 @@ fn fn_is_const(self, def_id: DefId) -> bool {
         self.is_conditionally_const(def_id)
     }
 
+    fn closure_is_const(self, def_id: DefId) -> bool {
+        debug_assert_matches!(self.def_kind(def_id), DefKind::Closure);
+        self.constness(def_id) == hir::Constness::Const
+    }
+
     fn alias_has_const_conditions(self, def_id: DefId) -> bool {
         debug_assert_matches!(self.def_kind(def_id), DefKind::AssocTy | DefKind::OpaqueTy);
         self.is_conditionally_const(def_id)
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 6abe7d146699..01c351de9319 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2118,11 +2118,7 @@ pub fn is_conditionally_const(self, def_id: impl Into<DefId>) -> bool {
                 // FIXME(const_trait_impl): ATPITs could be conditionally const?
                 hir::OpaqueTyOrigin::TyAlias { .. } => false,
             },
-            DefKind::Closure => {
-                // Closures and RPITs will eventually have const conditions
-                // for `[const]` bounds.
-                false
-            }
+            DefKind::Closure => self.constness(def_id) == hir::Constness::Const,
             DefKind::Ctor(_, CtorKind::Const)
             | DefKind::Mod
             | DefKind::Struct
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 05ea217c1de0..cd74e87b670f 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -661,10 +661,11 @@ fn coroutine_closure_to_ambiguous_coroutine<I: Interner>(
 ///
 /// Doing so on all calls to `extract_tupled_inputs_and_output_from_callable`
 /// would be wasteful.
+#[instrument(level = "trace", skip(cx), ret)]
 pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
     cx: I,
     self_ty: I::Ty,
-) -> Result<(ty::Binder<I, (I::Ty, I::Ty)>, I::FunctionId, I::GenericArgs), NoSolution> {
+) -> Result<(ty::Binder<I, (I::Ty, I::Ty)>, I::DefId, I::GenericArgs), NoSolution> {
     match self_ty.kind() {
         ty::FnDef(def_id, args) => {
             let sig = cx.fn_sig(def_id);
@@ -675,7 +676,7 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
                 Ok((
                     sig.instantiate(cx, args)
                         .map_bound(|sig| (Ty::new_tup(cx, sig.inputs().as_slice()), sig.output())),
-                    def_id,
+                    def_id.into(),
                     args,
                 ))
             } else {
@@ -686,9 +687,19 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
         ty::FnPtr(..) => {
             return Err(NoSolution);
         }
-        // `Closure`s are not const for now.
-        ty::Closure(..) => {
-            return Err(NoSolution);
+        ty::Closure(def, args) => {
+            if cx.closure_is_const(def) {
+                let closure_args = args.as_closure();
+                Ok((
+                    closure_args
+                        .sig()
+                        .map_bound(|sig| (sig.inputs().get(0).unwrap(), sig.output())),
+                    def.into(),
+                    args,
+                ))
+            } else {
+                return Err(NoSolution);
+            }
         }
         // `CoroutineClosure`s are not const for now.
         ty::CoroutineClosure(..) => {
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 4da76b88b5de..4b1e4b2de571 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -272,6 +272,7 @@ fn consider_builtin_fn_ptr_trait_candidate(
         todo!("Fn* are not yet const")
     }
 
+    #[instrument(level = "trace", skip_all, ret)]
     fn consider_builtin_fn_trait_candidates(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
@@ -289,7 +290,7 @@ fn consider_builtin_fn_trait_candidates(
         let output_is_sized_pred =
             ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]);
         let requirements = cx
-            .const_conditions(def_id.into())
+            .const_conditions(def_id)
             .iter_instantiated(cx, args)
             .map(|trait_ref| {
                 (
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index e77e7af071b9..25f7c36e9985 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -308,6 +308,7 @@ fn impl_super_outlives(
 
     fn impl_is_const(self, def_id: Self::ImplId) -> bool;
     fn fn_is_const(self, def_id: Self::FunctionId) -> bool;
+    fn closure_is_const(self, def_id: Self::ClosureId) -> bool;
     fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool;
     fn const_conditions(
         self,
diff --git a/tests/ui/traits/const-traits/call.rs b/tests/ui/traits/const-traits/call.rs
index e93ea4ccbd70..41883f648513 100644
--- a/tests/ui/traits/const-traits/call.rs
+++ b/tests/ui/traits/const-traits/call.rs
@@ -1,11 +1,10 @@
-// FIXME(const_trait_impl) check-pass
+//@ check-pass
 //@ compile-flags: -Znext-solver
 #![feature(const_closures, const_trait_impl)]
 #![allow(incomplete_features)]
 
 const _: () = {
     assert!((const || true)());
-    //~^ ERROR }: const Fn()` is not satisfied
 };
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/call.stderr b/tests/ui/traits/const-traits/call.stderr
deleted file mode 100644
index 3503938327a9..000000000000
--- a/tests/ui/traits/const-traits/call.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0277]: the trait bound `{closure@$DIR/call.rs:7:14: 7:22}: const Fn()` is not satisfied
-  --> $DIR/call.rs:7:13
-   |
-LL |     assert!((const || true)());
-   |             ^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.

From 60bd8e36cd8f2b534ba2979ddc04cef7a34dca32 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Fri, 13 Mar 2026 07:37:12 +0000
Subject: [PATCH 0436/1059] Enable the const_closures feature gate to silence
 an unrelated error

---
 .../ice-112822-expected-type-for-param.rs     |  5 +++--
 .../ice-112822-expected-type-for-param.stderr | 19 ++++---------------
 2 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
index 8ee3db445d07..d20abdd57f5c 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
@@ -1,8 +1,9 @@
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_closures)]
+#![allow(incomplete_features)]
 
 const fn test() -> impl [const] Fn() {
     //~^ ERROR: }: [const] Fn()` is not satisfied
-    const move || { //~ ERROR const closures are experimental
+    const move || {
         let sl: &[u8] = b"foo";
 
         match sl {
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
index abbe0a0070aa..eebfd5c11e66 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
@@ -1,20 +1,9 @@
-error[E0658]: const closures are experimental
-  --> $DIR/ice-112822-expected-type-for-param.rs:5:5
-   |
-LL |     const move || {
-   |     ^^^^^
-   |
-   = note: see issue #106003 <https://github.com/rust-lang/rust/issues/106003> for more information
-   = help: add `#![feature(const_closures)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0277]: the trait bound `{closure@$DIR/ice-112822-expected-type-for-param.rs:5:5: 5:18}: [const] Fn()` is not satisfied
-  --> $DIR/ice-112822-expected-type-for-param.rs:3:20
+error[E0277]: the trait bound `{closure@$DIR/ice-112822-expected-type-for-param.rs:6:5: 6:18}: [const] Fn()` is not satisfied
+  --> $DIR/ice-112822-expected-type-for-param.rs:4:20
    |
 LL | const fn test() -> impl [const] Fn() {
    |                    ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0277, E0658.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0277`.

From 8629126289a5d631ccae4d96384de18afde587eb Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Fri, 13 Mar 2026 07:47:24 +0000
Subject: [PATCH 0437/1059] Allow calling const closures on the old solver

---
 .../src/traits/effects.rs                     | 17 +++++++++---
 tests/ui/traits/const-traits/call.rs          |  3 ++-
 .../const-closure-parse-not-item.rs           |  3 +--
 .../const-closure-parse-not-item.stderr       |  9 -------
 tests/ui/traits/const-traits/gate.rs          |  3 ++-
 tests/ui/traits/const-traits/gate.stderr      | 26 +++++++++++++++----
 .../ice-112822-expected-type-for-param.rs     |  5 ++--
 .../ice-112822-expected-type-for-param.stderr | 14 ++++++----
 8 files changed, 51 insertions(+), 29 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/const-closure-parse-not-item.stderr

diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index 66c949a38cea..026ab3a527a1 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -519,10 +519,21 @@ fn evaluate_host_effect_for_fn_goal<'tcx>(
         // We may support function pointers at some point in the future
         ty::FnPtr(..) => return Err(EvaluationFailure::NoSolution),
 
-        // Closures could implement `[const] Fn`,
+        // Coroutines could implement `[const] Fn`,
         // but they don't really need to right now.
-        ty::Closure(..) | ty::CoroutineClosure(_, _) => {
-            return Err(EvaluationFailure::NoSolution);
+        ty::CoroutineClosure(_, _) => return Err(EvaluationFailure::NoSolution),
+
+        ty::Closure(def, args) => {
+            // For now we limit ourselves to closures without binders. The next solver can handle them.
+            let sig =
+                args.as_closure().sig().no_bound_vars().ok_or(EvaluationFailure::NoSolution)?;
+            (
+                def,
+                tcx.mk_args_from_iter(
+                    [ty::GenericArg::from(*sig.inputs().get(0).unwrap()), sig.output().into()]
+                        .into_iter(),
+                ),
+            )
         }
 
         // Everything else needs explicit impls or cannot have an impl
diff --git a/tests/ui/traits/const-traits/call.rs b/tests/ui/traits/const-traits/call.rs
index 41883f648513..0a76de907232 100644
--- a/tests/ui/traits/const-traits/call.rs
+++ b/tests/ui/traits/const-traits/call.rs
@@ -1,5 +1,6 @@
 //@ check-pass
-//@ compile-flags: -Znext-solver
+//@[next] compile-flags: -Znext-solver
+//@revisions: next old
 #![feature(const_closures, const_trait_impl)]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/traits/const-traits/const-closure-parse-not-item.rs b/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
index 35127eda5c03..22ce427b6ab9 100644
--- a/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
+++ b/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
@@ -1,5 +1,4 @@
-//@ known-bug: #110395
-// FIXME check-pass
+//@check-pass
 
 #![feature(const_trait_impl, const_closures)]
 #![allow(incomplete_features)]
diff --git a/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr b/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
deleted file mode 100644
index 1d8d5ff1b4f2..000000000000
--- a/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0277]: the trait bound `{closure@$DIR/const-closure-parse-not-item.rs:8:5: 8:18}: [const] Fn()` is not satisfied
-  --> $DIR/const-closure-parse-not-item.rs:7:20
-   |
-LL | const fn test() -> impl [const] Fn() {
-   |                    ^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/gate.rs b/tests/ui/traits/const-traits/gate.rs
index 0821a45edb5e..c9f56df35531 100644
--- a/tests/ui/traits/const-traits/gate.rs
+++ b/tests/ui/traits/const-traits/gate.rs
@@ -3,7 +3,8 @@
 fn main() {
     const { (const || {})() };
     //~^ ERROR: const closures are experimental
-    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: const Fn()` is not satisfied
+    //~| ERROR: cannot call conditionally-const closure in constants
+    //~| ERROR:  `Fn` is not yet stable as a const trait
 }
 
 macro_rules! e {
diff --git a/tests/ui/traits/const-traits/gate.stderr b/tests/ui/traits/const-traits/gate.stderr
index af5905524437..788878292b6f 100644
--- a/tests/ui/traits/const-traits/gate.stderr
+++ b/tests/ui/traits/const-traits/gate.stderr
@@ -9,7 +9,7 @@ LL |     const { (const || {})() };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: const closures are experimental
-  --> $DIR/gate.rs:13:5
+  --> $DIR/gate.rs:14:5
    |
 LL | e!((const || {}));
    |     ^^^^^
@@ -18,13 +18,29 @@ LL | e!((const || {}));
    = help: add `#![feature(const_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:14: 4:22}: const Fn()` is not satisfied
+error[E0658]: cannot call conditionally-const closure in constants
   --> $DIR/gate.rs:4:13
    |
 LL |     const { (const || {})() };
    |             ^^^^^^^^^^^^^^^
+   |
+   = note: closures need an RFC before allowed to be called in constants
+   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 3 previous errors
+error: `Fn` is not yet stable as a const trait
+  --> $DIR/gate.rs:4:13
+   |
+LL |     const { (const || {})() };
+   |             ^^^^^^^^^^^^^^^
+   |
+help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+   |
+LL + #![feature(const_trait_impl)]
+   |
 
-Some errors have detailed explanations: E0277, E0658.
-For more information about an error, try `rustc --explain E0277`.
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
index d20abdd57f5c..832e88c189d6 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
@@ -1,15 +1,14 @@
-#![feature(const_trait_impl, const_closures)]
+#![feature(const_trait_impl, const_closures, const_cmp)]
 #![allow(incomplete_features)]
 
 const fn test() -> impl [const] Fn() {
-    //~^ ERROR: }: [const] Fn()` is not satisfied
     const move || {
         let sl: &[u8] = b"foo";
 
         match sl {
             [first, remainder @ ..] => {
                 assert_eq!(first, &b'f');
-                // FIXME(const_closures) ^ ERROR cannot call non-const function
+                //~^ ERROR cannot call non-const function
             }
             [] => panic!(),
         }
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
index eebfd5c11e66..7c6bec43ff40 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
@@ -1,9 +1,13 @@
-error[E0277]: the trait bound `{closure@$DIR/ice-112822-expected-type-for-param.rs:6:5: 6:18}: [const] Fn()` is not satisfied
-  --> $DIR/ice-112822-expected-type-for-param.rs:4:20
+error[E0015]: cannot call non-const function `core::panicking::assert_failed::<&u8, &u8>` in constant functions
+  --> $DIR/ice-112822-expected-type-for-param.rs:10:17
    |
-LL | const fn test() -> impl [const] Fn() {
-   |                    ^^^^^^^^^^^^^^^^^
+LL |                 assert_eq!(first, &b'f');
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: function `assert_failed` is not const
+  --> $SRC_DIR/core/src/panicking.rs:LL:COL
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0015`.

From c521b8084fb910e4a809c0611944fc9404138615 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Fri, 13 Mar 2026 10:23:50 +0000
Subject: [PATCH 0438/1059] Remove the incomplete marker from const closures

---
 compiler/rustc_feature/src/unstable.rs                          | 2 +-
 tests/ui/traits/const-traits/call-const-closure.rs              | 1 -
 tests/ui/traits/const-traits/call-const-closure.stderr          | 2 +-
 tests/ui/traits/const-traits/call.rs                            | 1 -
 .../ui/traits/const-traits/const-closure-issue-125866-error.rs  | 1 -
 .../traits/const-traits/const-closure-issue-125866-error.stderr | 2 +-
 tests/ui/traits/const-traits/const-closure-parse-not-item.rs    | 1 -
 .../const-traits/const_closure-const_trait_impl-ice-113381.rs   | 1 -
 .../const_closure-const_trait_impl-ice-113381.stderr            | 2 +-
 .../traits/const-traits/ice-112822-expected-type-for-param.rs   | 1 -
 .../const-traits/ice-112822-expected-type-for-param.stderr      | 2 +-
 .../const-traits/non-const-op-const-closure-non-const-outer.rs  | 1 -
 .../non-const-op-const-closure-non-const-outer.stderr           | 2 +-
 13 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 39e886227d94..ae356118c93e 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -429,7 +429,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows defining and calling c-variadic functions in const contexts.
     (unstable, const_c_variadic, "1.95.0", Some(151787)),
     /// Allows `const || {}` closures in const contexts.
-    (incomplete, const_closures, "1.68.0", Some(106003)),
+    (unstable, const_closures, "1.68.0", Some(106003)),
     /// Allows using `[const] Destruct` bounds and calling drop impls in const contexts.
     (unstable, const_destruct, "1.85.0", Some(133214)),
     /// Allows `for _ in _` loops in const contexts.
diff --git a/tests/ui/traits/const-traits/call-const-closure.rs b/tests/ui/traits/const-traits/call-const-closure.rs
index a26f7be1148d..c819df5d1d08 100644
--- a/tests/ui/traits/const-traits/call-const-closure.rs
+++ b/tests/ui/traits/const-traits/call-const-closure.rs
@@ -2,7 +2,6 @@
 //@ edition:2021
 
 #![feature(const_trait_impl, const_closures)]
-#![allow(incomplete_features)]
 
 const trait Bar {
     fn foo(&self);
diff --git a/tests/ui/traits/const-traits/call-const-closure.stderr b/tests/ui/traits/const-traits/call-const-closure.stderr
index 16b936d58aaf..7f4728b7e321 100644
--- a/tests/ui/traits/const-traits/call-const-closure.stderr
+++ b/tests/ui/traits/const-traits/call-const-closure.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `(): const Bar` is not satisfied
-  --> $DIR/call-const-closure.rs:16:18
+  --> $DIR/call-const-closure.rs:15:18
    |
 LL |     (const || ().foo())();
    |                  ^^^
diff --git a/tests/ui/traits/const-traits/call.rs b/tests/ui/traits/const-traits/call.rs
index 0a76de907232..71dea1ef4e04 100644
--- a/tests/ui/traits/const-traits/call.rs
+++ b/tests/ui/traits/const-traits/call.rs
@@ -2,7 +2,6 @@
 //@[next] compile-flags: -Znext-solver
 //@revisions: next old
 #![feature(const_closures, const_trait_impl)]
-#![allow(incomplete_features)]
 
 const _: () = {
     assert!((const || true)());
diff --git a/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs b/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
index e13ee39631a3..55fae27eb6dd 100644
--- a/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
+++ b/tests/ui/traits/const-traits/const-closure-issue-125866-error.rs
@@ -1,4 +1,3 @@
-#![allow(incomplete_features)]
 #![feature(const_closures, const_trait_impl)]
 
 const fn create_array<const N: usize>(mut f: impl FnMut(usize) -> u32 + Copy) -> [u32; N] {
diff --git a/tests/ui/traits/const-traits/const-closure-issue-125866-error.stderr b/tests/ui/traits/const-traits/const-closure-issue-125866-error.stderr
index 1eadd1d84269..448b343e2caa 100644
--- a/tests/ui/traits/const-traits/const-closure-issue-125866-error.stderr
+++ b/tests/ui/traits/const-traits/const-closure-issue-125866-error.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `impl FnMut(usize) -> u32 + Copy: [const] FnMut(usize)` is not satisfied
-  --> $DIR/const-closure-issue-125866-error.rs:8:22
+  --> $DIR/const-closure-issue-125866-error.rs:7:22
    |
 LL |         array[i] = f(i);
    |                    - ^
diff --git a/tests/ui/traits/const-traits/const-closure-parse-not-item.rs b/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
index 22ce427b6ab9..ce20b05a8133 100644
--- a/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
+++ b/tests/ui/traits/const-traits/const-closure-parse-not-item.rs
@@ -1,7 +1,6 @@
 //@check-pass
 
 #![feature(const_trait_impl, const_closures)]
-#![allow(incomplete_features)]
 
 const fn test() -> impl [const] Fn() {
     const move || {}
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
index e355ee724d1b..85613d9147a3 100644
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
+++ b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
@@ -1,7 +1,6 @@
 //@ known-bug: #110395
 //@ compile-flags: -Znext-solver
 #![feature(const_closures, const_trait_impl)]
-#![allow(incomplete_features)]
 
 trait Foo {
     fn foo(&self);
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
index bbe736b94b5b..2bafddd7cf78 100644
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
+++ b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
@@ -1,5 +1,5 @@
 error: cannot use `const` closures outside of const contexts
-  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:15:6
+  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:14:6
    |
 LL |     (const || (()).foo())();
    |      ^^^^^
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
index 832e88c189d6..1f35abbb9d6a 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.rs
@@ -1,5 +1,4 @@
 #![feature(const_trait_impl, const_closures, const_cmp)]
-#![allow(incomplete_features)]
 
 const fn test() -> impl [const] Fn() {
     const move || {
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
index 7c6bec43ff40..73340f15cbb8 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
@@ -1,5 +1,5 @@
 error[E0015]: cannot call non-const function `core::panicking::assert_failed::<&u8, &u8>` in constant functions
-  --> $DIR/ice-112822-expected-type-for-param.rs:10:17
+  --> $DIR/ice-112822-expected-type-for-param.rs:9:17
    |
 LL |                 assert_eq!(first, &b'f');
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
index a13fab3b21db..58402cbaec81 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.rs
@@ -1,5 +1,4 @@
 #![feature(const_closures, const_trait_impl)]
-#![allow(incomplete_features)]
 
 trait Foo {
     fn foo(&self);
diff --git a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
index 43c98ec7c661..f5521b90cc2d 100644
--- a/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
+++ b/tests/ui/traits/const-traits/non-const-op-const-closure-non-const-outer.stderr
@@ -1,5 +1,5 @@
 error: cannot use `const` closures outside of const contexts
-  --> $DIR/non-const-op-const-closure-non-const-outer.rs:15:6
+  --> $DIR/non-const-op-const-closure-non-const-outer.rs:14:6
    |
 LL |     (const || { (()).foo() })();
    |      ^^^^^

From 9503c31c8b132333e96ec9c40b4bb620643dd3d8 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github@oli-obk.de>
Date: Fri, 13 Mar 2026 11:01:54 +0000
Subject: [PATCH 0439/1059] Some test cleanups

---
 ...sure.stderr => call-const-closure.next.stderr} |  2 +-
 .../const-traits/call-const-closure.old.stderr    | 14 ++++++++++++++
 .../ui/traits/const-traits/call-const-closure.rs  |  3 ++-
 .../const_closure-const_trait_impl-ice-113381.rs  | 15 ---------------
 ...nst_closure-const_trait_impl-ice-113381.stderr |  8 --------
 5 files changed, 17 insertions(+), 25 deletions(-)
 rename tests/ui/traits/const-traits/{call-const-closure.stderr => call-const-closure.next.stderr} (89%)
 create mode 100644 tests/ui/traits/const-traits/call-const-closure.old.stderr
 delete mode 100644 tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
 delete mode 100644 tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr

diff --git a/tests/ui/traits/const-traits/call-const-closure.stderr b/tests/ui/traits/const-traits/call-const-closure.next.stderr
similarity index 89%
rename from tests/ui/traits/const-traits/call-const-closure.stderr
rename to tests/ui/traits/const-traits/call-const-closure.next.stderr
index 7f4728b7e321..16b936d58aaf 100644
--- a/tests/ui/traits/const-traits/call-const-closure.stderr
+++ b/tests/ui/traits/const-traits/call-const-closure.next.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `(): const Bar` is not satisfied
-  --> $DIR/call-const-closure.rs:15:18
+  --> $DIR/call-const-closure.rs:16:18
    |
 LL |     (const || ().foo())();
    |                  ^^^
diff --git a/tests/ui/traits/const-traits/call-const-closure.old.stderr b/tests/ui/traits/const-traits/call-const-closure.old.stderr
new file mode 100644
index 000000000000..16b936d58aaf
--- /dev/null
+++ b/tests/ui/traits/const-traits/call-const-closure.old.stderr
@@ -0,0 +1,14 @@
+error[E0277]: the trait bound `(): const Bar` is not satisfied
+  --> $DIR/call-const-closure.rs:16:18
+   |
+LL |     (const || ().foo())();
+   |                  ^^^
+   |
+help: make the `impl` of trait `Bar` `const`
+   |
+LL | impl const Bar for () {
+   |      +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/call-const-closure.rs b/tests/ui/traits/const-traits/call-const-closure.rs
index c819df5d1d08..2cf561ae6db1 100644
--- a/tests/ui/traits/const-traits/call-const-closure.rs
+++ b/tests/ui/traits/const-traits/call-const-closure.rs
@@ -1,4 +1,5 @@
-//@ compile-flags: -Znext-solver
+//@[next] compile-flags: -Znext-solver
+//@ revisions: next old
 //@ edition:2021
 
 #![feature(const_trait_impl, const_closures)]
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
deleted file mode 100644
index 85613d9147a3..000000000000
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ known-bug: #110395
-//@ compile-flags: -Znext-solver
-#![feature(const_closures, const_trait_impl)]
-
-trait Foo {
-    fn foo(&self);
-}
-
-impl Foo for () {
-    fn foo(&self) {}
-}
-
-fn main() {
-    (const || (()).foo())();
-}
diff --git a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr b/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
deleted file mode 100644
index 2bafddd7cf78..000000000000
--- a/tests/ui/traits/const-traits/const_closure-const_trait_impl-ice-113381.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: cannot use `const` closures outside of const contexts
-  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:14:6
-   |
-LL |     (const || (()).foo())();
-   |      ^^^^^
-
-error: aborting due to 1 previous error
-

From 314e224fa5cd0312975eaac809203baa108e743a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 11:14:18 +1100
Subject: [PATCH 0440/1059] Streamline `find_dep_kind_root`.

`current_id` is removable.
---
 compiler/rustc_query_impl/src/job.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 64ed9b6b51bf..bb906794bf23 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -88,6 +88,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
     panic!("did not find a cycle")
 }
 
+/// Finds the job closest to the root with a `DepKind` matching the `DepKind` of `id`.
 #[cold]
 #[inline(never)]
 pub(crate) fn find_dep_kind_root<'tcx>(
@@ -95,18 +96,16 @@ pub(crate) fn find_dep_kind_root<'tcx>(
     job_map: QueryJobMap<'tcx>,
 ) -> (QueryJobInfo<'tcx>, usize) {
     let mut depth = 1;
-    let info = &job_map.map[&id];
+    let mut info = &job_map.map[&id];
     let dep_kind = info.frame.dep_kind;
-    let mut current_id = info.job.parent;
     let mut last_layout = (info.clone(), depth);
 
-    while let Some(id) = current_id {
-        let info = &job_map.map[&id];
+    while let Some(id) = info.job.parent {
+        info = &job_map.map[&id];
         if info.frame.dep_kind == dep_kind {
             depth += 1;
             last_layout = (info.clone(), depth);
         }
-        current_id = info.job.parent;
     }
     last_layout
 }

From ddd1a69483c9a5503b5f2e0b563d9b015f164b86 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 14:00:45 +1100
Subject: [PATCH 0441/1059] Remove `Clone` derive on `QueryJobInfo`.

This requires refactoring `depth_limit_error` to do some extra work
immediately instead of returning a cloned `info`.
---
 compiler/rustc_query_impl/src/job.rs      | 14 ++++++++------
 compiler/rustc_query_impl/src/plumbing.rs |  8 ++++----
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index bb906794bf23..67995ccfc490 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -46,7 +46,7 @@ fn latch_of(&self, id: QueryJobId) -> Option<&QueryLatch<'tcx>> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub(crate) struct QueryJobInfo<'tcx> {
     pub(crate) frame: QueryStackFrame<'tcx>,
     pub(crate) job: QueryJob<'tcx>,
@@ -88,26 +88,28 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
     panic!("did not find a cycle")
 }
 
-/// Finds the job closest to the root with a `DepKind` matching the `DepKind` of `id`.
+/// Finds the job closest to the root with a `DepKind` matching the `DepKind` of `id` and returns
+/// information about it.
 #[cold]
 #[inline(never)]
 pub(crate) fn find_dep_kind_root<'tcx>(
+    tcx: TyCtxt<'tcx>,
     id: QueryJobId,
     job_map: QueryJobMap<'tcx>,
-) -> (QueryJobInfo<'tcx>, usize) {
+) -> (Span, String, usize) {
     let mut depth = 1;
     let mut info = &job_map.map[&id];
     let dep_kind = info.frame.dep_kind;
-    let mut last_layout = (info.clone(), depth);
+    let mut last_info = info;
 
     while let Some(id) = info.job.parent {
         info = &job_map.map[&id];
         if info.frame.dep_kind == dep_kind {
             depth += 1;
-            last_layout = (info.clone(), depth);
+            last_info = info;
         }
     }
-    last_layout
+    (last_info.job.span, last_info.frame.tagged_key.description(tcx), depth)
 }
 
 /// A resumable waiter of a query. The usize is the index into waiters in the query's latch
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index bece2e56c0a8..66c62d6125b1 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -36,16 +36,16 @@
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
     let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::Full);
-    let (info, depth) = find_dep_kind_root(job, job_map);
+    let (span, desc, depth) = find_dep_kind_root(tcx, job, job_map);
 
     let suggested_limit = match tcx.recursion_limit() {
         Limit(0) => Limit(2),
         limit => limit * 2,
     };
 
-    tcx.sess.dcx().emit_fatal(QueryOverflow {
-        span: info.job.span,
-        note: QueryOverflowNote { desc: info.frame.tagged_key.description(tcx), depth },
+    tcx.dcx().emit_fatal(QueryOverflow {
+        span,
+        note: QueryOverflowNote { desc, depth },
         suggested_limit,
         crate_name: tcx.crate_name(LOCAL_CRATE),
     });

From b1b87ffdbc24e3928bf0aa4c766cd731ebbc641e Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Thu, 12 Mar 2026 12:35:39 -0700
Subject: [PATCH 0442/1059] Add overview documentation for `std::mem`.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I heard that `std::mem` sounds scary to some people, and how it’s
described — “Basic functions for dealing with memory” — sounds even to
me like something that should be avoided, not even because it would be
unsafe, but because it is too low-level.

Let’s fix that by telling people about what they can actually find in
the module, without having to read all the individual item descriptions.
---
 library/core/src/mem/mod.rs | 31 ++++++++++++++++++++++++++++---
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index d8521e79006e..b321908fd9e7 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -1,7 +1,32 @@
-//! Basic functions for dealing with memory.
+//! Basic functions for dealing with memory, values, and types.
 //!
-//! This module contains functions for querying the size and alignment of
-//! types, initializing and manipulating memory.
+//! The contents of this module can be seen as belonging to a few families:
+//!
+//! * [`drop`], [`replace`], [`swap`], and [`take`]
+//!   are safe functions for moving values in particular ways.
+//!   They are useful in everyday Rust code.
+//!
+//! * [`size_of`], [`size_of_val`], [`align_of`], [`align_of_val`], and [`offset_of`]
+//!   give information about the representation of values in memory.
+//!
+//! * [`discriminant`]
+//!   allows comparing the variants of [`enum`] values while ignoring their fields.
+//!
+//! * [`forget`] and [`ManuallyDrop`]
+//!   prevent destructors from running, which is used in certain kinds of ownership transfer.
+//!   [`needs_drop`]
+//!   tells you whether a type’s destructor even does anything.
+//!
+//! * [`transmute`], [`transmute_copy`], and [`MaybeUninit`]
+//!   convert and construct values in [`unsafe`] ways.
+//!
+//! See also the [`alloc`] and [`ptr`] modules for more primitive operations on memory.
+//!
+// core::alloc exists but doesn’t contain all the items we want to discuss
+//! [`alloc`]: ../../std/alloc/index.html
+//! [`enum`]: ../../std/keyword.enum.html
+//! [`ptr`]: crate::ptr
+//! [`unsafe`]: ../../std/keyword.unsafe.html
 
 #![stable(feature = "rust1", since = "1.0.0")]
 

From 5a8191f0a7105dbd4797d1bf400c6e8568cc2b27 Mon Sep 17 00:00:00 2001
From: kartikohlan <kartik7ohlan@gmail.com>
Date: Fri, 13 Mar 2026 20:58:05 -0400
Subject: [PATCH 0443/1059] Updated dates

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md        | 6 +++---
 .../src/borrow-check/region-inference/member-constraints.md | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/error-codes.md      | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/lintstore.md        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index 56fa49ef2a2e..617a7a940f10 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -1,6 +1,6 @@
 # Updating LLVM
 
-<!-- date-check: Aug 2024 -->
+<!-- date-check: March 2026 -->
 Rust supports building against multiple LLVM versions:
 
 * Tip-of-tree for the current LLVM development branch is usually supported within a few days.
@@ -91,7 +91,7 @@ An example PR: [#59089](https://github.com/rust-lang/rust/pull/59089)
 
 ## New LLVM Release Updates
 
-<!-- date-check: Jul 2023 -->
+<!-- date-check: March 2026 -->
 
 Unlike bugfixes,
 updating to a new release of LLVM typically requires a lot more work.
@@ -172,7 +172,7 @@ so let's go through each in detail.
    You'll change at least
    `src/llvm-project` and will likely also change [`llvm-wrapper`] as well.
 
-   <!-- date-check: mar 2025 -->
+   <!-- date-check: March 2026 -->
    > For prior art, here are some previous LLVM updates:
    > - [LLVM 17](https://github.com/rust-lang/rust/pull/115959)
    > - [LLVM 18](https://github.com/rust-lang/rust/pull/120055)
diff --git a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
index 2804c97724f5..2fe0a7b5808d 100644
--- a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
+++ b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
@@ -92,7 +92,7 @@ member constraints come in.
 ## Choices are always lifetime parameters
 
 At present, the "choice" regions from a member constraint are always lifetime
-parameters from the current function. As of <!-- date-check --> October 2021,
+parameters from the current function. As of <!-- date-check --> March 2026,
 this falls out from the placement of impl Trait, though in the future it may not
 be the case. We take some advantage of this fact, as it simplifies the current
 code. In particular, we don't have to consider a case like `'0 member of ['1,
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
index 9a302f9100f1..b5bb44cec348 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
@@ -10,7 +10,7 @@ Note that not all _historical_ (no longer emitted) error codes have explanations
 The explanations are written in Markdown (see the [CommonMark Spec] for
 specifics around syntax), and all of them are linked in the [`rustc_error_codes`] crate.
 Please read [RFC 1567] for details on how to format and write long error codes.
-As of <!-- date-check --> February 2023, there is an
+As of <!-- date-check --> March 2026, there is an
 effort[^new-explanations] to replace this largely outdated RFC with a new more flexible standard.
 
 Error explanations should expand on the error message and provide details about
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
index 7b98bc62116b..301a1e055425 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -21,7 +21,7 @@ which boils down to a static with type [`&rustc_lint_defs::Lint`]
 as the macro is somewhat unwieldy to add new fields to,
 like all macros).
 
-As of <!-- date-check --> Aug 2022,
+As of <!-- date-check --> March 2026,
 we lint against direct declarations without the use of the macro.
 
 Lint declarations don't carry any "state" - they are merely global identifiers

From 6699c13683a302e6457be7f9fb930ef8102b1982 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 12 Mar 2026 21:29:15 +1100
Subject: [PATCH 0444/1059] Move the big `rustc_query_impl` macro into a
 physical `query_impl.rs`

Moving the macro and its expansion into the same physical file resolves a lot
of tension in the current module arrangement.

Code in the macro is now free to use plain imports in the same file, and there
is no longer any question of whether `mod query_impl` should be declared inside
the macro, or surrounding a separate expansion site.
---
 compiler/rustc_query_impl/src/execution.rs    |   2 +-
 compiler/rustc_query_impl/src/lib.rs          |  14 +-
 compiler/rustc_query_impl/src/plumbing.rs     | 263 +----------------
 .../rustc_query_impl/src/profiling_support.rs |   2 +-
 compiler/rustc_query_impl/src/query_impl.rs   | 266 ++++++++++++++++++
 5 files changed, 275 insertions(+), 272 deletions(-)
 create mode 100644 compiler/rustc_query_impl/src/query_impl.rs

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 2b535d64cf70..eae91a2b2e56 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -18,9 +18,9 @@
 use tracing::warn;
 
 use crate::dep_graph::{DepNode, DepNodeIndex};
-use crate::for_each_query_vtable;
 use crate::job::{QueryJobInfo, QueryJobMap, find_cycle_in_stack, report_cycle};
 use crate::plumbing::{current_query_job, next_job_id, start_query};
+use crate::query_impl::for_each_query_vtable;
 
 #[inline]
 fn equivalent_key<K: Eq, V>(k: K) -> impl Fn(&(K, V)) -> bool {
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 44c97d19914c..c62ea3e289fc 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -10,26 +10,24 @@
 
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::dep_graph;
-use rustc_middle::queries::{self, ExternProviders, Providers, TaggedQueryKey};
+use rustc_middle::queries::{ExternProviders, Providers};
+use rustc_middle::query::QueryCache;
 use rustc_middle::query::on_disk_cache::OnDiskCache;
 use rustc_middle::query::plumbing::{QuerySystem, QueryVTable};
-use rustc_middle::query::{AsLocalQueryKey, QueryCache, QueryMode};
 use rustc_middle::ty::TyCtxt;
-use rustc_span::Span;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
 pub use crate::execution::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
 
-#[macro_use]
-mod plumbing;
-
 mod dep_kind_vtables;
 mod error;
 mod execution;
 mod from_cycle_error;
 mod job;
+mod plumbing;
 mod profiling_support;
+mod query_impl;
 
 /// Trait that knows how to look up the [`QueryVTable`] for a particular query.
 ///
@@ -51,7 +49,7 @@ pub fn query_system<'tcx>(
     on_disk_cache: Option<OnDiskCache>,
     incremental: bool,
 ) -> QuerySystem<'tcx> {
-    let mut query_vtables = make_query_vtables(incremental);
+    let mut query_vtables = query_impl::make_query_vtables(incremental);
     from_cycle_error::specialize_query_vtables(&mut query_vtables);
     QuerySystem {
         arenas: Default::default(),
@@ -63,8 +61,6 @@ pub fn query_system<'tcx>(
     }
 }
 
-rustc_middle::rustc_with_all_queries! { define_queries! }
-
 pub fn provide(providers: &mut rustc_middle::util::Providers) {
     providers.hooks.alloc_self_profile_query_strings =
         profiling_support::alloc_self_profile_query_strings;
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index bece2e56c0a8..a346836057d9 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -1,7 +1,3 @@
-//! The implementation of the query system itself. This defines the macros that
-//! generate the actual methods on tcx which find and execute the provider,
-//! manage the caches, and so forth.
-
 use std::num::NonZero;
 
 use rustc_data_structures::sync::{DynSend, DynSync};
@@ -29,10 +25,8 @@
 use crate::error::{QueryOverflow, QueryOverflowNote};
 use crate::execution::{all_inactive, force_query};
 use crate::job::find_dep_kind_root;
-use crate::{
-    CollectActiveJobsKind, GetQueryVTable, collect_active_jobs_from_all_queries,
-    for_each_query_vtable,
-};
+use crate::query_impl::for_each_query_vtable;
+use crate::{CollectActiveJobsKind, GetQueryVTable, collect_active_jobs_from_all_queries};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
     let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::Full);
@@ -283,256 +277,3 @@ pub(crate) fn force_from_dep_node_inner<'tcx, Q: GetQueryVTable<'tcx>>(
         false
     }
 }
-
-macro_rules! define_queries {
-    (
-        // Note: `$K` and `$V` are unused but present so this can be called by
-        // `rustc_with_all_queries`.
-        queries {
-            $(
-                $(#[$attr:meta])*
-                fn $name:ident($K:ty) -> $V:ty
-                {
-                    // Search for (QMODLIST) to find all occurrences of this query modifier list.
-                    anon: $anon:literal,
-                    arena_cache: $arena_cache:literal,
-                    cache_on_disk: $cache_on_disk:literal,
-                    depth_limit: $depth_limit:literal,
-                    eval_always: $eval_always:literal,
-                    feedable: $feedable:literal,
-                    no_hash: $no_hash:literal,
-                    returns_error_guaranteed: $returns_error_guaranteed:literal,
-                    separate_provide_extern: $separate_provide_extern:literal,
-                }
-            )*
-        }
-        // Non-queries are unused here.
-        non_queries { $($_:tt)* }
-    ) => {
-        pub(crate) mod query_impl { $(pub(crate) mod $name {
-            use super::super::*;
-            use ::rustc_middle::query::erase::{self, Erased};
-
-            // It seems to be important that every query has its own monomorphic
-            // copy of `execute_query_incr` and `execute_query_non_incr`.
-            // Trying to inline these wrapper functions into their generic
-            // "inner" helpers tends to break `tests/run-make/short-ice`.
-
-            pub(crate) mod execute_query_incr {
-                use super::*;
-
-                // Adding `__rust_end_short_backtrace` marker to backtraces so that we emit the frames
-                // when `RUST_BACKTRACE=1`, add a new mod with `$name` here is to allow duplicate naming
-                #[inline(never)]
-                pub(crate) fn __rust_end_short_backtrace<'tcx>(
-                    tcx: TyCtxt<'tcx>,
-                    span: Span,
-                    key: queries::$name::Key<'tcx>,
-                    mode: QueryMode,
-                ) -> Option<Erased<queries::$name::Value<'tcx>>> {
-                    #[cfg(debug_assertions)]
-                    let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
-                    execution::execute_query_incr_inner(
-                        &tcx.query_system.query_vtables.$name,
-                        tcx,
-                        span,
-                        key,
-                        mode
-                    )
-                }
-            }
-
-            pub(crate) mod execute_query_non_incr {
-                use super::*;
-
-                #[inline(never)]
-                pub(crate) fn __rust_end_short_backtrace<'tcx>(
-                    tcx: TyCtxt<'tcx>,
-                    span: Span,
-                    key: queries::$name::Key<'tcx>,
-                    __mode: QueryMode,
-                ) -> Option<Erased<queries::$name::Value<'tcx>>> {
-                    Some(execution::execute_query_non_incr_inner(
-                        &tcx.query_system.query_vtables.$name,
-                        tcx,
-                        span,
-                        key,
-                    ))
-                }
-            }
-
-            /// Defines an `invoke_provider` function that calls the query's provider,
-            /// to be used as a function pointer in the query's vtable.
-            ///
-            /// To mark a short-backtrace boundary, the function's actual name
-            /// (after demangling) must be `__rust_begin_short_backtrace`.
-            mod invoke_provider_fn {
-                use super::*;
-                use ::rustc_middle::queries::$name::{Key, Value, provided_to_erased};
-
-                #[inline(never)]
-                pub(crate) fn __rust_begin_short_backtrace<'tcx>(
-                    tcx: TyCtxt<'tcx>,
-                    key: Key<'tcx>,
-                ) -> Erased<Value<'tcx>> {
-                    #[cfg(debug_assertions)]
-                    let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
-
-                    // Call the actual provider function for this query.
-
-                    #[cfg($separate_provide_extern)]
-                    let provided_value = if let Some(local_key) = key.as_local_key() {
-                        (tcx.query_system.local_providers.$name)(tcx, local_key)
-                    } else {
-                        (tcx.query_system.extern_providers.$name)(tcx, key)
-                    };
-
-                    #[cfg(not($separate_provide_extern))]
-                    let provided_value = (tcx.query_system.local_providers.$name)(tcx, key);
-
-                    rustc_middle::ty::print::with_reduced_queries!({
-                        tracing::trace!(?provided_value);
-                    });
-
-                    // Erase the returned value, because `QueryVTable` uses erased values.
-                    // For queries with `arena_cache`, this also arena-allocates the value.
-                    provided_to_erased(tcx, provided_value)
-                }
-            }
-
-            pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
-                -> QueryVTable<'tcx, queries::$name::Cache<'tcx>>
-            {
-                QueryVTable {
-                    name: stringify!($name),
-                    anon: $anon,
-                    eval_always: $eval_always,
-                    depth_limit: $depth_limit,
-                    feedable: $feedable,
-                    dep_kind: dep_graph::DepKind::$name,
-                    state: Default::default(),
-                    cache: Default::default(),
-
-                    invoke_provider_fn: self::invoke_provider_fn::__rust_begin_short_backtrace,
-
-                    #[cfg($cache_on_disk)]
-                    will_cache_on_disk_for_key_fn:
-                        rustc_middle::queries::_cache_on_disk_if_fns::$name,
-                    #[cfg(not($cache_on_disk))]
-                    will_cache_on_disk_for_key_fn: |_, _| false,
-
-                    #[cfg($cache_on_disk)]
-                    try_load_from_disk_fn: |tcx, key, prev_index, index| {
-                        // Check the `cache_on_disk_if` condition for this key.
-                        if !rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) {
-                            return None;
-                        }
-
-                        let value: queries::$name::ProvidedValue<'tcx> =
-                            $crate::plumbing::try_load_from_disk(tcx, prev_index, index)?;
-
-                        // Arena-alloc the value if appropriate, and erase it.
-                        Some(queries::$name::provided_to_erased(tcx, value))
-                    },
-                    #[cfg(not($cache_on_disk))]
-                    try_load_from_disk_fn: |_tcx, _key, _prev_index, _index| None,
-
-                    #[cfg($cache_on_disk)]
-                    is_loadable_from_disk_fn: |tcx, key, index| -> bool {
-                        rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) &&
-                            $crate::plumbing::loadable_from_disk(tcx, index)
-                    },
-                    #[cfg(not($cache_on_disk))]
-                    is_loadable_from_disk_fn: |_tcx, _key, _index| false,
-
-                    // The default just emits `err` and then aborts.
-                    // `from_cycle_error::specialize_query_vtables` overwrites this default for
-                    // certain queries.
-                    value_from_cycle_error: |_tcx, _key, _cycle, err| {
-                        $crate::from_cycle_error::default(err)
-                    },
-
-                    #[cfg($no_hash)]
-                    hash_value_fn: None,
-                    #[cfg(not($no_hash))]
-                    hash_value_fn: Some(|hcx, erased_value: &erase::Erased<queries::$name::Value<'tcx>>| {
-                        let value = erase::restore_val(*erased_value);
-                        rustc_middle::dep_graph::hash_result(hcx, &value)
-                    }),
-
-                    format_value: |value| format!("{:?}", erase::restore_val::<queries::$name::Value<'tcx>>(*value)),
-                    create_tagged_key: TaggedQueryKey::$name,
-                    execute_query_fn: if incremental {
-                        query_impl::$name::execute_query_incr::__rust_end_short_backtrace
-                    } else {
-                        query_impl::$name::execute_query_non_incr::__rust_end_short_backtrace
-                    },
-                }
-            }
-
-            /// Marker type that implements [`GetQueryVTable`] for this query.
-            pub(crate) enum VTableGetter {}
-
-            impl<'tcx> GetQueryVTable<'tcx> for VTableGetter {
-                type Cache = rustc_middle::queries::$name::Cache<'tcx>;
-
-                #[inline(always)]
-                fn query_vtable(tcx: TyCtxt<'tcx>) -> &'tcx QueryVTable<'tcx, Self::Cache> {
-                    &tcx.query_system.query_vtables.$name
-                }
-            }
-        })*}
-
-        pub fn make_query_vtables<'tcx>(incremental: bool) -> queries::QueryVTables<'tcx> {
-            queries::QueryVTables {
-                $(
-                    $name: query_impl::$name::make_query_vtable(incremental),
-                )*
-            }
-        }
-
-        /// Given a filter condition (e.g. `ALL` or `CACHE_ON_DISK`), a `tcx`,
-        /// and a closure expression that accepts `&QueryVTable`, this macro
-        /// calls that closure with each query vtable that satisfies the filter
-        /// condition.
-        ///
-        /// This needs to be a macro, because the vtables can have different
-        /// key/value/cache types for different queries.
-        ///
-        /// This macro's argument syntax is specifically intended to look like
-        /// plain Rust code, so that `for_each_query_vtable!(..)` calls will be
-        /// formatted by rustfmt.
-        ///
-        /// To avoid too much nested-macro complication, filter conditions are
-        /// implemented by hand as needed.
-        macro_rules! for_each_query_vtable {
-            // Call with all queries.
-            (ALL, $tcx:expr, $closure:expr) => {{
-                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
-                $(
-                    let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
-                        &tcx.query_system.query_vtables.$name;
-                    $closure(query);
-                )*
-            }};
-
-            // Only call with queries that can potentially cache to disk.
-            //
-            // This allows the use of trait bounds that only need to be satisfied
-            // by the subset of queries that actually cache to disk.
-            (CACHE_ON_DISK, $tcx:expr, $closure:expr) => {{
-                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
-                $(
-                    #[cfg($cache_on_disk)]
-                    {
-                        let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
-                            &tcx.query_system.query_vtables.$name;
-                        $closure(query);
-                    }
-                )*
-            }}
-        }
-
-        pub(crate) use for_each_query_vtable;
-    }
-}
diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs
index c88bc8845ebd..c34938cdb386 100644
--- a/compiler/rustc_query_impl/src/profiling_support.rs
+++ b/compiler/rustc_query_impl/src/profiling_support.rs
@@ -10,7 +10,7 @@
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::ty::TyCtxt;
 
-use crate::for_each_query_vtable;
+use crate::query_impl::for_each_query_vtable;
 
 pub(crate) struct QueryKeyStringCache {
     def_id_cache: FxHashMap<DefId, StringId>,
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
new file mode 100644
index 000000000000..f833ec387104
--- /dev/null
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -0,0 +1,266 @@
+use rustc_middle::queries::TaggedQueryKey;
+use rustc_middle::query::plumbing::QueryVTable;
+use rustc_middle::query::{AsLocalQueryKey, QueryMode};
+use rustc_middle::ty::TyCtxt;
+use rustc_middle::{dep_graph, queries};
+use rustc_span::Span;
+
+use crate::{GetQueryVTable, execution, query_impl};
+
+macro_rules! define_queries {
+    (
+        // Note: `$K` and `$V` are unused but present so this can be called by
+        // `rustc_with_all_queries`.
+        queries {
+            $(
+                $(#[$attr:meta])*
+                fn $name:ident($K:ty) -> $V:ty
+                {
+                    // Search for (QMODLIST) to find all occurrences of this query modifier list.
+                    anon: $anon:literal,
+                    arena_cache: $arena_cache:literal,
+                    cache_on_disk: $cache_on_disk:literal,
+                    depth_limit: $depth_limit:literal,
+                    eval_always: $eval_always:literal,
+                    feedable: $feedable:literal,
+                    no_hash: $no_hash:literal,
+                    returns_error_guaranteed: $returns_error_guaranteed:literal,
+                    separate_provide_extern: $separate_provide_extern:literal,
+                }
+            )*
+        }
+        // Non-queries are unused here.
+        non_queries { $($_:tt)* }
+    ) => {
+        // This macro expects to be expanded into `crate::query_impl`, which is this file.
+        $(
+            pub(crate) mod $name {
+                use super::*;
+                use ::rustc_middle::query::erase::{self, Erased};
+
+                // It seems to be important that every query has its own monomorphic
+                // copy of `execute_query_incr` and `execute_query_non_incr`.
+                // Trying to inline these wrapper functions into their generic
+                // "inner" helpers tends to break `tests/run-make/short-ice`.
+
+                pub(crate) mod execute_query_incr {
+                    use super::*;
+
+                    // Adding `__rust_end_short_backtrace` marker to backtraces so that we emit the frames
+                    // when `RUST_BACKTRACE=1`, add a new mod with `$name` here is to allow duplicate naming
+                    #[inline(never)]
+                    pub(crate) fn __rust_end_short_backtrace<'tcx>(
+                        tcx: TyCtxt<'tcx>,
+                        span: Span,
+                        key: queries::$name::Key<'tcx>,
+                        mode: QueryMode,
+                    ) -> Option<Erased<queries::$name::Value<'tcx>>> {
+                        #[cfg(debug_assertions)]
+                        let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
+                        execution::execute_query_incr_inner(
+                            &tcx.query_system.query_vtables.$name,
+                            tcx,
+                            span,
+                            key,
+                            mode
+                        )
+                    }
+                }
+
+                pub(crate) mod execute_query_non_incr {
+                    use super::*;
+
+                    #[inline(never)]
+                    pub(crate) fn __rust_end_short_backtrace<'tcx>(
+                        tcx: TyCtxt<'tcx>,
+                        span: Span,
+                        key: queries::$name::Key<'tcx>,
+                        __mode: QueryMode,
+                    ) -> Option<Erased<queries::$name::Value<'tcx>>> {
+                        Some(execution::execute_query_non_incr_inner(
+                            &tcx.query_system.query_vtables.$name,
+                            tcx,
+                            span,
+                            key,
+                        ))
+                    }
+                }
+
+                /// Defines an `invoke_provider` function that calls the query's provider,
+                /// to be used as a function pointer in the query's vtable.
+                ///
+                /// To mark a short-backtrace boundary, the function's actual name
+                /// (after demangling) must be `__rust_begin_short_backtrace`.
+                mod invoke_provider_fn {
+                    use super::*;
+                    use ::rustc_middle::queries::$name::{Key, Value, provided_to_erased};
+
+                    #[inline(never)]
+                    pub(crate) fn __rust_begin_short_backtrace<'tcx>(
+                        tcx: TyCtxt<'tcx>,
+                        key: Key<'tcx>,
+                    ) -> Erased<Value<'tcx>> {
+                        #[cfg(debug_assertions)]
+                        let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
+
+                        // Call the actual provider function for this query.
+
+                        #[cfg($separate_provide_extern)]
+                        let provided_value = if let Some(local_key) = key.as_local_key() {
+                            (tcx.query_system.local_providers.$name)(tcx, local_key)
+                        } else {
+                            (tcx.query_system.extern_providers.$name)(tcx, key)
+                        };
+
+                        #[cfg(not($separate_provide_extern))]
+                        let provided_value = (tcx.query_system.local_providers.$name)(tcx, key);
+
+                        rustc_middle::ty::print::with_reduced_queries!({
+                            tracing::trace!(?provided_value);
+                        });
+
+                        // Erase the returned value, because `QueryVTable` uses erased values.
+                        // For queries with `arena_cache`, this also arena-allocates the value.
+                        provided_to_erased(tcx, provided_value)
+                    }
+                }
+
+                pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
+                    -> QueryVTable<'tcx, queries::$name::Cache<'tcx>>
+                {
+                    QueryVTable {
+                        name: stringify!($name),
+                        anon: $anon,
+                        eval_always: $eval_always,
+                        depth_limit: $depth_limit,
+                        feedable: $feedable,
+                        dep_kind: dep_graph::DepKind::$name,
+                        state: Default::default(),
+                        cache: Default::default(),
+
+                        invoke_provider_fn: self::invoke_provider_fn::__rust_begin_short_backtrace,
+
+                        #[cfg($cache_on_disk)]
+                        will_cache_on_disk_for_key_fn:
+                            rustc_middle::queries::_cache_on_disk_if_fns::$name,
+                        #[cfg(not($cache_on_disk))]
+                        will_cache_on_disk_for_key_fn: |_, _| false,
+
+                        #[cfg($cache_on_disk)]
+                        try_load_from_disk_fn: |tcx, key, prev_index, index| {
+                            // Check the `cache_on_disk_if` condition for this key.
+                            if !rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) {
+                                return None;
+                            }
+
+                            let value: queries::$name::ProvidedValue<'tcx> =
+                                $crate::plumbing::try_load_from_disk(tcx, prev_index, index)?;
+
+                            // Arena-alloc the value if appropriate, and erase it.
+                            Some(queries::$name::provided_to_erased(tcx, value))
+                        },
+                        #[cfg(not($cache_on_disk))]
+                        try_load_from_disk_fn: |_tcx, _key, _prev_index, _index| None,
+
+                        #[cfg($cache_on_disk)]
+                        is_loadable_from_disk_fn: |tcx, key, index| -> bool {
+                            rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) &&
+                                $crate::plumbing::loadable_from_disk(tcx, index)
+                        },
+                        #[cfg(not($cache_on_disk))]
+                        is_loadable_from_disk_fn: |_tcx, _key, _index| false,
+
+                        // The default just emits `err` and then aborts.
+                        // `from_cycle_error::specialize_query_vtables` overwrites this default for
+                        // certain queries.
+                        value_from_cycle_error: |_tcx, _key, _cycle, err| {
+                            $crate::from_cycle_error::default(err)
+                        },
+
+                        #[cfg($no_hash)]
+                        hash_value_fn: None,
+                        #[cfg(not($no_hash))]
+                        hash_value_fn: Some(|hcx, erased_value: &erase::Erased<queries::$name::Value<'tcx>>| {
+                            let value = erase::restore_val(*erased_value);
+                            rustc_middle::dep_graph::hash_result(hcx, &value)
+                        }),
+
+                        format_value: |value| format!("{:?}", erase::restore_val::<queries::$name::Value<'tcx>>(*value)),
+                        create_tagged_key: TaggedQueryKey::$name,
+                        execute_query_fn: if incremental {
+                            query_impl::$name::execute_query_incr::__rust_end_short_backtrace
+                        } else {
+                            query_impl::$name::execute_query_non_incr::__rust_end_short_backtrace
+                        },
+                    }
+                }
+
+                /// Marker type that implements [`GetQueryVTable`] for this query.
+                pub(crate) enum VTableGetter {}
+
+                impl<'tcx> GetQueryVTable<'tcx> for VTableGetter {
+                    type Cache = rustc_middle::queries::$name::Cache<'tcx>;
+
+                    #[inline(always)]
+                    fn query_vtable(tcx: TyCtxt<'tcx>) -> &'tcx QueryVTable<'tcx, Self::Cache> {
+                        &tcx.query_system.query_vtables.$name
+                    }
+                }
+            }
+        )*
+
+        pub(crate) fn make_query_vtables<'tcx>(incremental: bool) -> queries::QueryVTables<'tcx> {
+            queries::QueryVTables {
+                $(
+                    $name: query_impl::$name::make_query_vtable(incremental),
+                )*
+            }
+        }
+
+        /// Given a filter condition (e.g. `ALL` or `CACHE_ON_DISK`), a `tcx`,
+        /// and a closure expression that accepts `&QueryVTable`, this macro
+        /// calls that closure with each query vtable that satisfies the filter
+        /// condition.
+        ///
+        /// This needs to be a macro, because the vtables can have different
+        /// key/value/cache types for different queries.
+        ///
+        /// This macro's argument syntax is specifically intended to look like
+        /// plain Rust code, so that `for_each_query_vtable!(..)` calls will be
+        /// formatted by rustfmt.
+        ///
+        /// To avoid too much nested-macro complication, filter conditions are
+        /// implemented by hand as needed.
+        macro_rules! for_each_query_vtable {
+            // Call with all queries.
+            (ALL, $tcx:expr, $closure:expr) => {{
+                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
+                $(
+                    let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                        &tcx.query_system.query_vtables.$name;
+                    $closure(query);
+                )*
+            }};
+
+            // Only call with queries that can potentially cache to disk.
+            //
+            // This allows the use of trait bounds that only need to be satisfied
+            // by the subset of queries that actually cache to disk.
+            (CACHE_ON_DISK, $tcx:expr, $closure:expr) => {{
+                let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
+                $(
+                    #[cfg($cache_on_disk)]
+                    {
+                        let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                            &tcx.query_system.query_vtables.$name;
+                        $closure(query);
+                    }
+                )*
+            }}
+        }
+
+        pub(crate) use for_each_query_vtable;
+    }
+}
+
+rustc_middle::rustc_with_all_queries! { define_queries! }

From 69ea0c506d3be9f53809feb631c62d327d4b617e Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 12 Mar 2026 21:29:15 +1100
Subject: [PATCH 0445/1059] Use more fully-qualified paths and local imports in
 `query_impl`

---
 compiler/rustc_query_impl/src/query_impl.rs | 51 ++++++++++++---------
 1 file changed, 30 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index f833ec387104..d5fb90871e76 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -1,11 +1,11 @@
 use rustc_middle::queries::TaggedQueryKey;
+use rustc_middle::query::erase::{self, Erased};
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{AsLocalQueryKey, QueryMode};
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::{dep_graph, queries};
 use rustc_span::Span;
 
-use crate::{GetQueryVTable, execution, query_impl};
+use crate::GetQueryVTable;
 
 macro_rules! define_queries {
     (
@@ -36,7 +36,6 @@ fn $name:ident($K:ty) -> $V:ty
         $(
             pub(crate) mod $name {
                 use super::*;
-                use ::rustc_middle::query::erase::{self, Erased};
 
                 // It seems to be important that every query has its own monomorphic
                 // copy of `execute_query_incr` and `execute_query_non_incr`.
@@ -45,6 +44,7 @@ pub(crate) mod $name {
 
                 pub(crate) mod execute_query_incr {
                     use super::*;
+                    use rustc_middle::queries::$name::{Key, Value};
 
                     // Adding `__rust_end_short_backtrace` marker to backtraces so that we emit the frames
                     // when `RUST_BACKTRACE=1`, add a new mod with `$name` here is to allow duplicate naming
@@ -52,12 +52,12 @@ pub(crate) mod execute_query_incr {
                     pub(crate) fn __rust_end_short_backtrace<'tcx>(
                         tcx: TyCtxt<'tcx>,
                         span: Span,
-                        key: queries::$name::Key<'tcx>,
+                        key: Key<'tcx>,
                         mode: QueryMode,
-                    ) -> Option<Erased<queries::$name::Value<'tcx>>> {
+                    ) -> Option<Erased<Value<'tcx>>> {
                         #[cfg(debug_assertions)]
                         let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
-                        execution::execute_query_incr_inner(
+                        crate::execution::execute_query_incr_inner(
                             &tcx.query_system.query_vtables.$name,
                             tcx,
                             span,
@@ -69,15 +69,16 @@ pub(crate) fn __rust_end_short_backtrace<'tcx>(
 
                 pub(crate) mod execute_query_non_incr {
                     use super::*;
+                    use rustc_middle::queries::$name::{Key, Value};
 
                     #[inline(never)]
                     pub(crate) fn __rust_end_short_backtrace<'tcx>(
                         tcx: TyCtxt<'tcx>,
                         span: Span,
-                        key: queries::$name::Key<'tcx>,
+                        key: Key<'tcx>,
                         __mode: QueryMode,
-                    ) -> Option<Erased<queries::$name::Value<'tcx>>> {
-                        Some(execution::execute_query_non_incr_inner(
+                    ) -> Option<Erased<Value<'tcx>>> {
+                        Some(crate::execution::execute_query_non_incr_inner(
                             &tcx.query_system.query_vtables.$name,
                             tcx,
                             span,
@@ -93,7 +94,7 @@ pub(crate) fn __rust_end_short_backtrace<'tcx>(
                 /// (after demangling) must be `__rust_begin_short_backtrace`.
                 mod invoke_provider_fn {
                     use super::*;
-                    use ::rustc_middle::queries::$name::{Key, Value, provided_to_erased};
+                    use rustc_middle::queries::$name::{Key, Value, provided_to_erased};
 
                     #[inline(never)]
                     pub(crate) fn __rust_begin_short_backtrace<'tcx>(
@@ -126,15 +127,17 @@ pub(crate) fn __rust_begin_short_backtrace<'tcx>(
                 }
 
                 pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
-                    -> QueryVTable<'tcx, queries::$name::Cache<'tcx>>
+                    -> QueryVTable<'tcx, rustc_middle::queries::$name::Cache<'tcx>>
                 {
+                    use rustc_middle::queries::$name::Value;
+
                     QueryVTable {
                         name: stringify!($name),
                         anon: $anon,
                         eval_always: $eval_always,
                         depth_limit: $depth_limit,
                         feedable: $feedable,
-                        dep_kind: dep_graph::DepKind::$name,
+                        dep_kind: rustc_middle::dep_graph::DepKind::$name,
                         state: Default::default(),
                         cache: Default::default(),
 
@@ -148,16 +151,18 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
 
                         #[cfg($cache_on_disk)]
                         try_load_from_disk_fn: |tcx, key, prev_index, index| {
+                            use rustc_middle::queries::$name::{ProvidedValue, provided_to_erased};
+
                             // Check the `cache_on_disk_if` condition for this key.
                             if !rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) {
                                 return None;
                             }
 
-                            let value: queries::$name::ProvidedValue<'tcx> =
+                            let loaded_value: ProvidedValue<'tcx> =
                                 $crate::plumbing::try_load_from_disk(tcx, prev_index, index)?;
 
                             // Arena-alloc the value if appropriate, and erase it.
-                            Some(queries::$name::provided_to_erased(tcx, value))
+                            Some(provided_to_erased(tcx, loaded_value))
                         },
                         #[cfg(not($cache_on_disk))]
                         try_load_from_disk_fn: |_tcx, _key, _prev_index, _index| None,
@@ -180,17 +185,19 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                         #[cfg($no_hash)]
                         hash_value_fn: None,
                         #[cfg(not($no_hash))]
-                        hash_value_fn: Some(|hcx, erased_value: &erase::Erased<queries::$name::Value<'tcx>>| {
+                        hash_value_fn: Some(|hcx, erased_value: &erase::Erased<Value<'tcx>>| {
                             let value = erase::restore_val(*erased_value);
                             rustc_middle::dep_graph::hash_result(hcx, &value)
                         }),
 
-                        format_value: |value| format!("{:?}", erase::restore_val::<queries::$name::Value<'tcx>>(*value)),
+                        format_value: |erased_value: &erase::Erased<Value<'tcx>>| {
+                            format!("{:?}", erase::restore_val(*erased_value))
+                        },
                         create_tagged_key: TaggedQueryKey::$name,
                         execute_query_fn: if incremental {
-                            query_impl::$name::execute_query_incr::__rust_end_short_backtrace
+                            crate::query_impl::$name::execute_query_incr::__rust_end_short_backtrace
                         } else {
-                            query_impl::$name::execute_query_non_incr::__rust_end_short_backtrace
+                            crate::query_impl::$name::execute_query_non_incr::__rust_end_short_backtrace
                         },
                     }
                 }
@@ -209,10 +216,12 @@ fn query_vtable(tcx: TyCtxt<'tcx>) -> &'tcx QueryVTable<'tcx, Self::Cache> {
             }
         )*
 
-        pub(crate) fn make_query_vtables<'tcx>(incremental: bool) -> queries::QueryVTables<'tcx> {
-            queries::QueryVTables {
+        pub(crate) fn make_query_vtables<'tcx>(incremental: bool)
+            -> rustc_middle::queries::QueryVTables<'tcx>
+        {
+            rustc_middle::queries::QueryVTables {
                 $(
-                    $name: query_impl::$name::make_query_vtable(incremental),
+                    $name: crate::query_impl::$name::make_query_vtable(incremental),
                 )*
             }
         }

From 7d4ee745ebec42583a519f3440e5342c5e5b8a6f Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 13 Mar 2026 13:49:59 +1100
Subject: [PATCH 0446/1059] Don't pass a separate `DepKind` to `query_feed`

The query's dep kind can be obtained from its vtable instead.

This commit also renames the `query_vtable` parameter to `query`, to be more
consistent with other functions that take a QueryVTable.
---
 compiler/rustc_middle/src/queries.rs        |  2 +-
 compiler/rustc_middle/src/query/inner.rs    | 26 ++++++++++-----------
 compiler/rustc_middle/src/query/plumbing.rs |  1 -
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 6c30762725b7..ffe96c9db3da 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -120,7 +120,7 @@
     self, CrateInherentImpls, GenericArg, GenericArgsRef, LitToConstInput, PseudoCanonicalInput,
     SizedTraitKind, Ty, TyCtxt, TyCtxtFeed,
 };
-use crate::{dep_graph, mir, thir};
+use crate::{mir, thir};
 
 // Each of these queries corresponds to a function pointer field in the
 // `Providers` struct for requesting a value of that type, and a method
diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
index 2c3959805d9d..7395c5476dc1 100644
--- a/compiler/rustc_middle/src/query/inner.rs
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -4,7 +4,7 @@
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
 use crate::dep_graph;
-use crate::dep_graph::{DepKind, DepNodeKey};
+use crate::dep_graph::DepNodeKey;
 use crate::query::erase::{self, Erasable, Erased};
 use crate::query::plumbing::QueryVTable;
 use crate::query::{EnsureMode, QueryCache, QueryMode};
@@ -98,26 +98,26 @@ pub(crate) fn query_ensure_result<'tcx, C, T>(
     }
 }
 
-/// Common implementation of query feeding, used by `define_feedable!`.
+/// "Feeds" a feedable query by adding a given key/value pair to its in-memory cache.
+/// Called by macro-generated methods of [`rustc_middle::ty::TyCtxtFeed`].
 pub(crate) fn query_feed<'tcx, C>(
     tcx: TyCtxt<'tcx>,
-    dep_kind: DepKind,
-    query_vtable: &QueryVTable<'tcx, C>,
+    query: &'tcx QueryVTable<'tcx, C>,
     key: C::Key,
     value: C::Value,
 ) where
     C: QueryCache,
     C::Key: DepNodeKey<'tcx>,
 {
-    let format_value = query_vtable.format_value;
+    let format_value = query.format_value;
 
     // Check whether the in-memory cache already has a value for this key.
-    match try_get_cached(tcx, &query_vtable.cache, key) {
+    match try_get_cached(tcx, &query.cache, key) {
         Some(old) => {
             // The query already has a cached value for this key.
             // That's OK if both values are the same, i.e. they have the same hash,
             // so now we check their hashes.
-            if let Some(hash_value_fn) = query_vtable.hash_value_fn {
+            if let Some(hash_value_fn) = query.hash_value_fn {
                 let (old_hash, value_hash) = tcx.with_stable_hashing_context(|ref mut hcx| {
                     (hash_value_fn(hcx, &old), hash_value_fn(hcx, &value))
                 });
@@ -126,7 +126,7 @@ pub(crate) fn query_feed<'tcx, C>(
                     // results is tainted by errors. In this case, delay a bug to
                     // ensure compilation is doomed, and keep the `old` value.
                     tcx.dcx().delayed_bug(format!(
-                        "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
+                        "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
                         old value: {old}\nnew value: {value}",
                         old = format_value(&old),
                         value = format_value(&value),
@@ -137,7 +137,7 @@ pub(crate) fn query_feed<'tcx, C>(
                 // If feeding the same value multiple times needs to be supported,
                 // the query should not be marked `no_hash`.
                 bug!(
-                    "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
+                    "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
                     old value: {old}\nnew value: {value}",
                     old = format_value(&old),
                     value = format_value(&value),
@@ -147,15 +147,15 @@ pub(crate) fn query_feed<'tcx, C>(
         None => {
             // There is no cached value for this key, so feed the query by
             // adding the provided value to the cache.
-            let dep_node = dep_graph::DepNode::construct(tcx, dep_kind, &key);
+            let dep_node = dep_graph::DepNode::construct(tcx, query.dep_kind, &key);
             let dep_node_index = tcx.dep_graph.with_feed_task(
                 dep_node,
                 tcx,
                 &value,
-                query_vtable.hash_value_fn,
-                query_vtable.format_value,
+                query.hash_value_fn,
+                query.format_value,
             );
-            query_vtable.cache.complete(key, value, dep_node_index);
+            query.cache.complete(key, value, dep_node_index);
         }
     }
 }
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index f38889846524..128350a89ecf 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -493,7 +493,6 @@ pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
                     let erased_value = $name::provided_to_erased(self.tcx, value);
                     $crate::query::inner::query_feed(
                         self.tcx,
-                        dep_graph::DepKind::$name,
                         &self.tcx.query_system.query_vtables.$name,
                         key,
                         erased_value,

From 17c079625c1f8ccd91a9a810e3bd8af73e67ebe8 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 14 Mar 2026 00:03:43 +0100
Subject: [PATCH 0447/1059] tests/debuginfo/basic-stepping.rs: Add cdb test

---
 tests/debuginfo/basic-stepping.rs | 39 +++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/tests/debuginfo/basic-stepping.rs b/tests/debuginfo/basic-stepping.rs
index 6aa8aeceb1e6..c82120e8a426 100644
--- a/tests/debuginfo/basic-stepping.rs
+++ b/tests/debuginfo/basic-stepping.rs
@@ -88,6 +88,45 @@
 //@ lldb-command: frame select
 //@ lldb-check:   [...]let m: *const() = &a;[...]
 
+// === CDB TESTS ===================================================================================
+
+// Enable source line support. See
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/debuggercmds/-lines--toggle-source-line-support-.
+//@ cdb-command: .lines -e
+// Display source lines and source line numbers at the command prompt. See
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/debuggercmds/l---l---set-source-options-.
+//@ cdb-command: l+s
+// Enter "source mode" so `p` steps source lines and not assembly instructions.
+//@ cdb-command: l+t
+
+// `g` means "go". See
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/debuggercmds/g--go-.
+//@ cdb-command: g
+// `p` means "step". See
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/debuggercmds/p--step-.
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let mut c = 27;
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let d = c = 99;
+//@ [no-SingleUseConsts-mir-pass] cdb-command: p
+//@ [no-SingleUseConsts-mir-pass] cdb-check:   [...]:     let e = "hi bob";
+//@ [no-SingleUseConsts-mir-pass] cdb-command: p
+//@ [no-SingleUseConsts-mir-pass] cdb-check:   [...]:     let f = b"hi bob";
+//@ [no-SingleUseConsts-mir-pass] cdb-command: p
+//@ [no-SingleUseConsts-mir-pass] cdb-check:   [...]:     let g = b'9';
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let h = ["whatever"; 8];
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let i = [1,2,3,4];
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let j = (23, "hi");
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let k = 2..3;
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let l = &i[k];
+//@ cdb-command: p
+//@ cdb-check:   [...]:     let m: *const() = &a;
+
 #![allow(unused_assignments, unused_variables)]
 
 fn main () {

From 9a91c4f3b798f3f90ef2841dfe192241b9b8430a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 14 Mar 2026 09:39:32 +0100
Subject: [PATCH 0448/1059] TB comment typo fixes

---
 src/tools/miri/src/borrow_tracker/tree_borrows/wildcard.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/wildcard.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/wildcard.rs
index b03635de70ae..a3f7d6176555 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/wildcard.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/wildcard.rs
@@ -50,8 +50,8 @@ pub fn to_relatedness(self) -> Option<AccessRelatedness> {
     }
 }
 
-/// Caches information about where in the tree exposed nodes with permission to do reads/ rites are
-/// located. [`ExposedCache`] stores this information a single location (or rather, a range of
+/// Caches information about where in the tree exposed nodes with permission to do reads/writes are
+/// located. [`ExposedCache`] stores this information for a single location (or rather, a range of
 /// homogeneous locations) for all nodes in an allocation.
 ///
 /// Nodes not in this map have a default [`ExposedCacheNode`], i.e. they have no exposed children.

From c4fb58ff9a8ddd916cfb8fb285b152d482aa5a6a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 12 Mar 2026 11:51:19 +0100
Subject: [PATCH 0449/1059] target specs: tighten checks for llvm_abiname and
 llvm_floatabi, and tie them to cfg(target_abi)

---
 .../rustc_target/src/spec/base/apple/mod.rs   |   7 +-
 compiler/rustc_target/src/spec/mod.rs         | 289 +++++++++++++++---
 2 files changed, 255 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index 542c5e278499..18b41d10062b 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -127,7 +127,12 @@ pub(crate) fn base(
     let link_env_remove = link_env_remove(&os);
     let unversioned_llvm_target = unversioned_llvm_target(&os, arch, env);
     let mut opts = TargetOptions {
-        llvm_floatabi: Some(FloatAbi::Hard),
+        llvm_floatabi: if arch.target_arch() == crate::spec::Arch::Arm {
+            Some(FloatAbi::Hard)
+        } else {
+            // `llvm_floatabi` makes no sense on x86 and aarch64.
+            None
+        },
         os,
         env: env.target_env(),
         abi: env.target_abi(),
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 77cc6dd1036c..a28794eee458 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1005,7 +1005,7 @@ pub enum FloatAbi {
     pub enum RustcAbi {
         /// On x86-32 only: make use of SSE and SSE2 for ABI purposes.
         X86Sse2 = "x86-sse2",
-        /// On x86-32/64 and S390x: do not use any FPU or SIMD registers for the ABI.
+        /// On x86-32/64, aarch64, and S390x: do not use any FPU or SIMD registers for the ABI.
         Softfloat = "softfloat", "x86-softfloat",
     }
 
@@ -3183,69 +3183,277 @@ macro_rules! check_matches {
             );
         }
 
-        // Check that RISC-V targets always specify which ABI they use,
-        // and that ARM targets specify their float ABI.
+        // Check ABI flag consistency, for the architectures where we have proper ABI treatment.
+        // To ensure targets are trated consistently, please consult with the team before allowing
+        // new cases.
         match self.arch {
-            Arch::RiscV32 => {
+            Arch::X86 => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on x86-32");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on x86-32");
                 check_matches!(
-                    &*self.llvm_abiname,
-                    "ilp32" | "ilp32f" | "ilp32d" | "ilp32e",
-                    "invalid RISC-V ABI name: {}",
+                    (&self.rustc_abi, &self.abi),
+                    // FIXME: we do not currently set a target_abi for softfloat targets here,
+                    // but we probably should, so we already allow it.
+                    (Some(RustcAbi::Softfloat), Abi::SoftFloat | Abi::Unspecified | Abi::Other(_))
+                        | (
+                            Some(RustcAbi::X86Sse2) | None,
+                            Abi::Uwp | Abi::Llvm | Abi::Sim | Abi::Unspecified | Abi::Other(_)
+                        ),
+                    "invalid x86-32 Rust-specific ABI and `cfg(target_abi)` combination:\n\
+                    Rust-specific ABI: {:?}\n\
+                    cfg(target_abi): {}",
+                    self.rustc_abi,
+                    self.abi,
+                );
+            }
+            Arch::X86_64 => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on x86-64");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on x86-64");
+                // FIXME: we do not currently set a target_abi for softfloat targets here, but we
+                // probably should, so we already allow it.
+                // FIXME: Ensure that target_abi = "x32" correlates with actually using that ABI.
+                // Do any of the others need a similar check?
+                check_matches!(
+                    (&self.rustc_abi, &self.abi),
+                    (Some(RustcAbi::Softfloat), Abi::SoftFloat | Abi::Unspecified | Abi::Other(_))
+                        | (
+                            None,
+                            Abi::X32
+                                | Abi::Llvm
+                                | Abi::Fortanix
+                                | Abi::Uwp
+                                | Abi::MacAbi
+                                | Abi::Sim
+                                | Abi::Unspecified
+                                | Abi::Other(_)
+                        ),
+                    "invalid x86-64 Rust-specific ABI and `cfg(target_abi)` combination:\n\
+                    Rust-specific ABI: {:?}\n\
+                    cfg(target_abi): {}",
+                    self.rustc_abi,
+                    self.abi,
+                );
+            }
+            Arch::RiscV32 => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
+                check_matches!(
+                    (&*self.llvm_abiname, &self.abi),
+                    ("ilp32", Abi::Unspecified | Abi::Other(_))
+                        | ("ilp32f", Abi::Unspecified | Abi::Other(_))
+                        | ("ilp32d", Abi::Unspecified | Abi::Other(_))
+                        | ("ilp32e", Abi::Ilp32e),
+                    "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
                     self.llvm_abiname,
+                    self.abi,
                 );
             }
             Arch::RiscV64 => {
                 // Note that the `lp64e` is still unstable as it's not (yet) part of the ELF psABI.
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
                 check_matches!(
-                    &*self.llvm_abiname,
-                    "lp64" | "lp64f" | "lp64d" | "lp64e",
-                    "invalid RISC-V ABI name: {}",
+                    (&*self.llvm_abiname, &self.abi),
+                    ("lp64", Abi::Unspecified | Abi::Other(_))
+                        | ("lp64f", Abi::Unspecified | Abi::Other(_))
+                        | ("lp64d", Abi::Unspecified | Abi::Other(_))
+                        | ("lp64e", Abi::Unspecified | Abi::Other(_)),
+                    "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
                     self.llvm_abiname,
+                    self.abi,
                 );
             }
             Arch::Arm => {
-                check!(
-                    self.llvm_floatabi.is_some(),
-                    "ARM targets must set `llvm-floatabi` to `hard` or `soft`",
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on ARM");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on ARM");
+                check_matches!(
+                    (&self.llvm_floatabi, &self.abi),
+                    (
+                        Some(FloatAbi::Hard),
+                        Abi::EabiHf | Abi::Uwp | Abi::Unspecified | Abi::Other(_)
+                    ) | (Some(FloatAbi::Soft), Abi::Eabi),
+                    "Invalid combination of float ABI and `cfg(target_abi)` for ARM target\n\
+                     float ABI: {:?}\n\
+                     cfg(target_abi): {}",
+                    self.llvm_floatabi,
+                    self.abi,
                 )
             }
-            // PowerPC64 targets that are not AIX must set their ABI to either ELFv1 or ELFv2
+            Arch::AArch64 => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on aarch64");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on aarch64");
+                // FIXME: Ensure that target_abi = "ilp32" correlates with actually using that ABI.
+                // Do any of the others need a similar check?
+                check_matches!(
+                    (&self.rustc_abi, &self.abi),
+                    (Some(RustcAbi::Softfloat), Abi::SoftFloat)
+                        | (
+                            None,
+                            Abi::Ilp32
+                                | Abi::Llvm
+                                | Abi::MacAbi
+                                | Abi::Sim
+                                | Abi::Uwp
+                                | Abi::Unspecified
+                                | Abi::Other(_)
+                        ),
+                    "invalid aarch64 Rust-specific ABI and `cfg(target_abi)` combination:\n\
+                    Rust-specific ABI: {:?}\n\
+                    cfg(target_abi): {}",
+                    self.rustc_abi,
+                    self.abi,
+                );
+            }
+            Arch::PowerPC => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on PowerPC");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on PowerPC");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on PowerPC");
+                // FIXME: Check that `target_abi` matches the actually configured ABI (with or
+                // without SPE).
+                check_matches!(
+                    self.abi,
+                    Abi::Spe | Abi::Unspecified | Abi::Other(_),
+                    "invalid `target_abi` for PowerPC"
+                );
+            }
             Arch::PowerPC64 => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on PowerPC64");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on PowerPC64");
+                // PowerPC64 targets that are not AIX must set their ABI to either ELFv1 or ELFv2
                 if self.os == Os::Aix {
-                    check!(
-                        self.llvm_abiname.is_empty(),
-                        "AIX targets always use the AIX ABI and `llvm_abiname` should be left empty",
+                    // FIXME: Check that `target_abi` matches the actually configured ABI
+                    // (vec-default vs vec-ext).
+                    check_matches!(
+                        (&*self.llvm_abiname, &self.abi),
+                        ("", Abi::VecDefault | Abi::VecExtAbi),
+                        "invalid PowerPC64 AIX ABI name and `cfg(target_abi)` combination:\n\
+                        ABI name: {}\n\
+                        cfg(target_abi): {}",
+                        self.llvm_abiname,
+                        self.abi,
                     );
                 } else if self.endian == Endian::Big {
                     check_matches!(
-                        &*self.llvm_abiname,
-                        "elfv1" | "elfv2",
-                        "invalid PowerPC64 ABI name: {}",
+                        (&*self.llvm_abiname, &self.abi),
+                        ("elfv1", Abi::ElfV1) | ("elfv2", Abi::ElfV2),
+                        "invalid PowerPC64 big-endian ABI name and `cfg(target_abi)` combination:\n\
+                        ABI name: {}\n\
+                        cfg(target_abi): {}",
                         self.llvm_abiname,
+                        self.abi,
                     );
                 } else {
-                    check!(
-                        self.llvm_abiname == "elfv2",
-                        "little-endian PowerPC64 targets only support the `elfv2` ABI",
+                    check_matches!(
+                        (&*self.llvm_abiname, &self.abi),
+                        ("elfv2", Abi::ElfV2),
+                        "invalid PowerPC64 little-endian ABI name and `cfg(target_abi)` combination:\n\
+                        ABI name: {}\n\
+                        cfg(target_abi): {}",
+                        self.llvm_abiname,
+                        self.abi,
                     );
                 }
             }
-            _ => {}
-        }
-
-        // Check consistency of Rust ABI declaration.
-        if let Some(rust_abi) = self.rustc_abi {
-            match rust_abi {
-                RustcAbi::X86Sse2 => check_matches!(
-                    self.arch,
-                    Arch::X86,
-                    "`x86-sse2` ABI is only valid for x86-32 targets"
-                ),
-                RustcAbi::Softfloat => check_matches!(
-                    self.arch,
-                    Arch::X86 | Arch::X86_64 | Arch::S390x | Arch::AArch64,
-                    "`softfloat` ABI is only valid for x86, s390x, and aarch64 targets"
-                ),
+            Arch::S390x => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on s390x");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on s390x");
+                check_matches!(
+                    (&self.rustc_abi, &self.abi),
+                    (Some(RustcAbi::Softfloat), Abi::SoftFloat)
+                        | (None, Abi::Unspecified | Abi::Other(_)),
+                    "invalid s390x Rust-specific ABI and `cfg(target_abi)` combination:\n\
+                    Rust-specific ABI: {:?}\n\
+                    cfg(target_abi): {}",
+                    self.rustc_abi,
+                    self.abi,
+                );
+            }
+            Arch::LoongArch32 => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
+                check_matches!(
+                    (&*self.llvm_abiname, &self.abi),
+                    ("ilp32s", Abi::SoftFloat)
+                        | ("ilp32f", Abi::Unspecified | Abi::Other(_))
+                        | ("ilp32d", Abi::Unspecified | Abi::Other(_)),
+                    "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
+                    self.llvm_abiname,
+                    self.abi,
+                );
+            }
+            Arch::LoongArch64 => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
+                check_matches!(
+                    (&*self.llvm_abiname, &self.abi),
+                    ("lp64s", Abi::SoftFloat)
+                        | ("lp64f", Abi::Unspecified | Abi::Other(_))
+                        | ("lp64d", Abi::Unspecified | Abi::Other(_)),
+                    "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
+                    self.llvm_abiname,
+                    self.abi,
+                );
+            }
+            Arch::Mips => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
+                check_matches!(
+                    (&*self.llvm_abiname, &self.abi),
+                    // FIXME: we should force it to always be non-empty.
+                    ("o32", Abi::Unspecified | Abi::Other(_))
+                        | ("", Abi::Unspecified | Abi::Other(_)),
+                    "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
+                    self.llvm_abiname,
+                    self.abi,
+                );
+            }
+            Arch::Mips64 | Arch::Mips64r6 => {
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
+                check_matches!(
+                    (&*self.llvm_abiname, &self.abi),
+                    ("n64", Abi::Abi64),
+                    "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
+                     ABI name: {}\n\
+                     cfg(target_abi): {}",
+                    self.llvm_abiname,
+                    self.abi,
+                );
+            }
+            Arch::CSky => {
+                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on CSky");
+                check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on CSky");
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on CSky");
+                // FIXME: Check that `target_abi` matches the actually configured ABI (v2 vs v2hf).
+                check_matches!(
+                    self.abi,
+                    Abi::AbiV2 | Abi::AbiV2Hf,
+                    "invalid `target_abi` for CSky"
+                );
+            }
+            ref arch => {
+                check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on {arch}");
+                // Ensure consistency among built-in targets, but give JSON targets the opportunity
+                // to experiment with these.
+                if kind == TargetKind::Builtin {
+                    check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on {arch}");
+                    check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on {arch}");
+                    check_matches!(
+                        self.abi,
+                        Abi::Unspecified | Abi::Other(_),
+                        "`target_abi` is unused on {arch}"
+                    );
+                }
             }
         }
 
@@ -3305,7 +3513,8 @@ fn test_target(mut self) {
         let recycled_target =
             Target::from_json(&serde_json::to_string(&self.to_json()).unwrap()).map(|(j, _)| j);
         self.update_to_cli();
-        self.check_consistency(TargetKind::Builtin).unwrap();
+        self.check_consistency(TargetKind::Builtin)
+            .unwrap_or_else(|err| panic!("Target consistency check failed:\n{err}"));
         assert_eq!(recycled_target, Ok(self));
     }
 

From 02ac1909090fa115fef35fa454cdad80839d19f0 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 31 Jan 2026 02:10:07 -0600
Subject: [PATCH 0450/1059] dec2flt: Rename `Integer` to `Int`

This is more consistent with what the trait is called elsewhere in tree
(specifically compiler-builtins and test-float-parse).
---
 library/core/src/num/imp/dec2flt/float.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/num/imp/dec2flt/float.rs b/library/core/src/num/imp/dec2flt/float.rs
index 21aabdc8addb..1ccc50fde590 100644
--- a/library/core/src/num/imp/dec2flt/float.rs
+++ b/library/core/src/num/imp/dec2flt/float.rs
@@ -12,7 +12,7 @@ pub trait CastInto<T: Copy>: Copy {
 }
 
 /// Collection of traits that allow us to be generic over integer size.
-pub trait Integer:
+pub trait Int:
     Sized
     + Clone
     + Copy
@@ -37,7 +37,7 @@ fn cast(self) -> i16 {
                 }
             }
 
-            impl Integer for $ty {
+            impl Int for $ty {
                 const ZERO: Self = 0;
                 const ONE: Self = 1;
             }
@@ -68,7 +68,7 @@ pub trait RawFloat:
     + Debug
 {
     /// The unsigned integer with the same size as the float
-    type Int: Integer + Into<u64>;
+    type Int: Int + Into<u64>;
 
     /* general constants */
 

From b07c0439a4d2da5c67ab50ceff6415071049a474 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 31 Jan 2026 02:57:22 -0600
Subject: [PATCH 0451/1059] dec2flt: Split up the `RawFloat` trait

`RawFloat` is currently used specifically for the implementation of the
lemire algorithm, but it is useful for more than that. Split it into
three different traits:

* `Float`: Anything that is reasonably applicable to all floating point
  types.
* `FloatExt`: Items that should be part of `Float` but don't work for
  all float types. This will eventually be merged back into `Float`.
* `Lemire`: Items that are specific to the Lemire algorithm.
---
 library/core/src/num/imp/dec2flt/decimal.rs   |   9 +-
 library/core/src/num/imp/dec2flt/float.rs     | 209 ++++++++++--------
 library/core/src/num/imp/dec2flt/lemire.rs    |   4 +-
 library/core/src/num/imp/dec2flt/mod.rs       |   6 +-
 library/core/src/num/imp/dec2flt/parse.rs     |   4 +-
 library/core/src/num/imp/dec2flt/slow.rs      |   4 +-
 library/core/src/num/imp/flt2dec/decoder.rs   |   4 +-
 library/coretests/tests/num/dec2flt/float.rs  |  95 ++++----
 library/coretests/tests/num/dec2flt/lemire.rs |   2 +-
 9 files changed, 180 insertions(+), 157 deletions(-)

diff --git a/library/core/src/num/imp/dec2flt/decimal.rs b/library/core/src/num/imp/dec2flt/decimal.rs
index 27a53d4b9e75..583f6bcf3302 100644
--- a/library/core/src/num/imp/dec2flt/decimal.rs
+++ b/library/core/src/num/imp/dec2flt/decimal.rs
@@ -1,9 +1,8 @@
 //! Representation of a float as the significant digits and exponent.
 
-use dec2flt::float::RawFloat;
-use dec2flt::fpu::set_precision;
-
 use crate::num::imp::dec2flt;
+use dec2flt::float::Lemire;
+use dec2flt::fpu::set_precision;
 
 const INT_POW10: [u64; 16] = [
     1,
@@ -36,7 +35,7 @@ pub struct Decimal {
 impl Decimal {
     /// Detect if the float can be accurately reconstructed from native floats.
     #[inline]
-    fn can_use_fast_path<F: RawFloat>(&self) -> bool {
+    fn can_use_fast_path<F: Lemire>(&self) -> bool {
         F::MIN_EXPONENT_FAST_PATH <= self.exponent
             && self.exponent <= F::MAX_EXPONENT_DISGUISED_FAST_PATH
             && self.mantissa <= F::MAX_MANTISSA_FAST_PATH
@@ -53,7 +52,7 @@ fn can_use_fast_path<F: RawFloat>(&self) -> bool {
     ///
     /// There is an exception: disguised fast-path cases, where we can shift
     /// powers-of-10 from the exponent to the significant digits.
-    pub fn try_fast_path<F: RawFloat>(&self) -> Option<F> {
+    pub fn try_fast_path<F: Lemire>(&self) -> Option<F> {
         // Here we need to work around <https://github.com/rust-lang/rust/issues/114479>.
         // The fast path crucially depends on arithmetic being rounded to the correct number of bits
         // without any intermediate rounding. On x86 (without SSE or SSE2) this requires the precision
diff --git a/library/core/src/num/imp/dec2flt/float.rs b/library/core/src/num/imp/dec2flt/float.rs
index 1ccc50fde590..da581a457f49 100644
--- a/library/core/src/num/imp/dec2flt/float.rs
+++ b/library/core/src/num/imp/dec2flt/float.rs
@@ -48,12 +48,8 @@ impl Int for $ty {
 int!(u16, u32, u64);
 
 /// A helper trait to avoid duplicating basically all the conversion code for IEEE floats.
-///
-/// See the parent module's doc comment for why this is necessary.
-///
-/// Should **never ever** be implemented for other types or be used outside the `dec2flt` module.
 #[doc(hidden)]
-pub trait RawFloat:
+pub trait Float:
     Sized
     + Div<Output = Self>
     + Neg<Output = Self>
@@ -128,8 +124,6 @@ pub trait RawFloat:
     const MIN_EXPONENT_ROUND_TO_EVEN: i32;
     const MAX_EXPONENT_ROUND_TO_EVEN: i32;
 
-    /* limits related to Fast pathing */
-
     /// Largest decimal exponent for a non-infinite value.
     ///
     /// This is the max exponent in binary converted to the max exponent in decimal. Allows fast
@@ -151,41 +145,19 @@ pub trait RawFloat:
     /// compile time since intermediates exceed the range of an `f64`.
     const SMALLEST_POWER_OF_TEN: i32;
 
-    /// Maximum exponent for a fast path case, or `⌊(SIG_BITS+1)/log2(5)⌋`
-    // assuming FLT_EVAL_METHOD = 0
-    const MAX_EXPONENT_FAST_PATH: i64 = {
-        let log2_5 = f64::consts::LOG2_10 - 1.0;
-        (Self::SIG_TOTAL_BITS as f64 / log2_5) as i64
-    };
-
-    /// Minimum exponent for a fast path case, or `-⌊(SIG_BITS+1)/log2(5)⌋`
-    const MIN_EXPONENT_FAST_PATH: i64 = -Self::MAX_EXPONENT_FAST_PATH;
-
-    /// Maximum exponent that can be represented for a disguised-fast path case.
-    /// This is `MAX_EXPONENT_FAST_PATH + ⌊(SIG_BITS+1)/log2(10)⌋`
-    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 =
-        Self::MAX_EXPONENT_FAST_PATH + (Self::SIG_TOTAL_BITS as f64 / f64::consts::LOG2_10) as i64;
-
-    /// Maximum mantissa for the fast-path (`1 << 53` for f64).
-    const MAX_MANTISSA_FAST_PATH: u64 = 1 << Self::SIG_TOTAL_BITS;
-
-    /// Converts integer into float through an as cast.
-    /// This is only called in the fast-path algorithm, and therefore
-    /// will not lose precision, since the value will always have
-    /// only if the value is <= Self::MAX_MANTISSA_FAST_PATH.
-    fn from_u64(v: u64) -> Self;
-
-    /// Performs a raw transmutation from an integer.
-    fn from_u64_bits(v: u64) -> Self;
-
-    /// Gets a small power-of-ten for fast-path multiplication.
-    fn pow10_fast_path(exponent: usize) -> Self;
-
     /// Returns the category that this number falls into.
     fn classify(self) -> FpCategory;
 
     /// Transmute to the integer representation
     fn to_bits(self) -> Self::Int;
+}
+
+/// Items that ideally would be on `Float`, but don't apply to all float types because they
+/// rely on the mantissa fitting into a `u64` (which isn't true for `f128`).
+#[doc(hidden)]
+pub trait FloatExt: Float {
+    /// Performs a raw transmutation from an integer.
+    fn from_u64_bits(v: u64) -> Self;
 
     /// Returns the mantissa, exponent and sign as integers.
     ///
@@ -212,6 +184,41 @@ fn integer_decode(self) -> (u64, i16, i8) {
     }
 }
 
+/// Extension to `Float` that are necessary for parsing using the Lemire method.
+///
+/// See the parent module's doc comment for why this is necessary.
+///
+/// Not intended for use outside of the `dec2flt` module.
+#[doc(hidden)]
+pub trait Lemire: FloatExt {
+    /// Maximum exponent for a fast path case, or `⌊(SIG_BITS+1)/log2(5)⌋`
+    // assuming FLT_EVAL_METHOD = 0
+    const MAX_EXPONENT_FAST_PATH: i64 = {
+        let log2_5 = f64::consts::LOG2_10 - 1.0;
+        (Self::SIG_TOTAL_BITS as f64 / log2_5) as i64
+    };
+
+    /// Minimum exponent for a fast path case, or `-⌊(SIG_BITS+1)/log2(5)⌋`
+    const MIN_EXPONENT_FAST_PATH: i64 = -Self::MAX_EXPONENT_FAST_PATH;
+
+    /// Maximum exponent that can be represented for a disguised-fast path case.
+    /// This is `MAX_EXPONENT_FAST_PATH + ⌊(SIG_BITS+1)/log2(10)⌋`
+    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 =
+        Self::MAX_EXPONENT_FAST_PATH + (Self::SIG_TOTAL_BITS as f64 / f64::consts::LOG2_10) as i64;
+
+    /// Maximum mantissa for the fast-path (`1 << 53` for f64).
+    const MAX_MANTISSA_FAST_PATH: u64 = 1 << Self::SIG_TOTAL_BITS;
+
+    /// Gets a small power-of-ten for fast-path multiplication.
+    fn pow10_fast_path(exponent: usize) -> Self;
+
+    /// Converts integer into float through an as cast.
+    /// This is only called in the fast-path algorithm, and therefore
+    /// will not lose precision, since the value will always have
+    /// only if the value is <= Self::MAX_MANTISSA_FAST_PATH.
+    fn from_u64(v: u64) -> Self;
+}
+
 /// Solve for `b` in `10^b = 2^a`
 const fn pow2_to_pow10(a: i64) -> i64 {
     let res = (a as f64) / f64::consts::LOG2_10;
@@ -219,7 +226,7 @@ const fn pow2_to_pow10(a: i64) -> i64 {
 }
 
 #[cfg(target_has_reliable_f16)]
-impl RawFloat for f16 {
+impl Float for f16 {
     type Int = u16;
 
     const INFINITY: Self = Self::INFINITY;
@@ -236,23 +243,6 @@ impl RawFloat for f16 {
     const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 5;
     const SMALLEST_POWER_OF_TEN: i32 = -27;
 
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-
-    #[inline]
-    fn from_u64_bits(v: u64) -> Self {
-        Self::from_bits((v & 0xFFFF) as u16)
-    }
-
-    fn pow10_fast_path(exponent: usize) -> Self {
-        #[allow(clippy::use_self)]
-        const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
-        TABLE[exponent & 7]
-    }
-
     fn to_bits(self) -> Self::Int {
         self.to_bits()
     }
@@ -262,7 +252,30 @@ fn classify(self) -> FpCategory {
     }
 }
 
-impl RawFloat for f32 {
+#[cfg(target_has_reliable_f16)]
+impl FloatExt for f16 {
+    #[inline]
+    fn from_u64_bits(v: u64) -> Self {
+        Self::from_bits((v & 0xFFFF) as u16)
+    }
+}
+
+#[cfg(target_has_reliable_f16)]
+impl Lemire for f16 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        #[allow(clippy::use_self)]
+        const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
+        TABLE[exponent & 7]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
+
+impl Float for f32 {
     type Int = u32;
 
     const INFINITY: Self = f32::INFINITY;
@@ -279,24 +292,6 @@ impl RawFloat for f32 {
     const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 10;
     const SMALLEST_POWER_OF_TEN: i32 = -65;
 
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-
-    #[inline]
-    fn from_u64_bits(v: u64) -> Self {
-        f32::from_bits((v & 0xFFFFFFFF) as u32)
-    }
-
-    fn pow10_fast_path(exponent: usize) -> Self {
-        #[allow(clippy::use_self)]
-        const TABLE: [f32; 16] =
-            [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.];
-        TABLE[exponent & 15]
-    }
-
     fn to_bits(self) -> Self::Int {
         self.to_bits()
     }
@@ -306,7 +301,29 @@ fn classify(self) -> FpCategory {
     }
 }
 
-impl RawFloat for f64 {
+impl FloatExt for f32 {
+    #[inline]
+    fn from_u64_bits(v: u64) -> Self {
+        f32::from_bits((v & 0xFFFFFFFF) as u32)
+    }
+}
+
+impl Lemire for f32 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        #[allow(clippy::use_self)]
+        const TABLE: [f32; 16] =
+            [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.];
+        TABLE[exponent & 15]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
+
+impl Float for f64 {
     type Int = u64;
 
     const INFINITY: Self = Self::INFINITY;
@@ -323,25 +340,6 @@ impl RawFloat for f64 {
     const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 23;
     const SMALLEST_POWER_OF_TEN: i32 = -342;
 
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-
-    #[inline]
-    fn from_u64_bits(v: u64) -> Self {
-        f64::from_bits(v)
-    }
-
-    fn pow10_fast_path(exponent: usize) -> Self {
-        const TABLE: [f64; 32] = [
-            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
-            1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 0., 0., 0., 0., 0., 0., 0., 0., 0.,
-        ];
-        TABLE[exponent & 31]
-    }
-
     fn to_bits(self) -> Self::Int {
         self.to_bits()
     }
@@ -350,3 +348,26 @@ fn classify(self) -> FpCategory {
         self.classify()
     }
 }
+
+impl FloatExt for f64 {
+    #[inline]
+    fn from_u64_bits(v: u64) -> Self {
+        f64::from_bits(v)
+    }
+}
+
+impl Lemire for f64 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        const TABLE: [f64; 32] = [
+            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
+            1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+        ];
+        TABLE[exponent & 31]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
diff --git a/library/core/src/num/imp/dec2flt/lemire.rs b/library/core/src/num/imp/dec2flt/lemire.rs
index c3f2723509d0..8a97618cf738 100644
--- a/library/core/src/num/imp/dec2flt/lemire.rs
+++ b/library/core/src/num/imp/dec2flt/lemire.rs
@@ -1,7 +1,7 @@
 //! Implementation of the Eisel-Lemire algorithm.
 
 use dec2flt::common::BiasedFp;
-use dec2flt::float::RawFloat;
+use dec2flt::float::Float;
 use dec2flt::table::{LARGEST_POWER_OF_FIVE, POWER_OF_FIVE_128, SMALLEST_POWER_OF_FIVE};
 
 use crate::num::imp::dec2flt;
@@ -24,7 +24,7 @@
 /// at a Gigabyte per Second" in section 5, "Fast Algorithm", and
 /// section 6, "Exact Numbers And Ties", available online:
 /// <https://arxiv.org/abs/2101.11408.pdf>.
-pub fn compute_float<F: RawFloat>(q: i64, mut w: u64) -> BiasedFp {
+pub fn compute_float<F: Float>(q: i64, mut w: u64) -> BiasedFp {
     let fp_zero = BiasedFp::zero_pow2(0);
     let fp_inf = BiasedFp::zero_pow2(F::INFINITE_POWER);
     let fp_error = BiasedFp::zero_pow2(-1);
diff --git a/library/core/src/num/imp/dec2flt/mod.rs b/library/core/src/num/imp/dec2flt/mod.rs
index 3f5724add62b..33e606694bc3 100644
--- a/library/core/src/num/imp/dec2flt/mod.rs
+++ b/library/core/src/num/imp/dec2flt/mod.rs
@@ -88,7 +88,7 @@
 )]
 
 use common::BiasedFp;
-use float::RawFloat;
+use float::{FloatExt, Lemire};
 use lemire::compute_float;
 use parse::{parse_inf_nan, parse_number};
 use slow::parse_long_mantissa;
@@ -120,7 +120,7 @@ pub fn pfe_invalid() -> ParseFloatError {
 }
 
 /// Converts a `BiasedFp` to the closest machine float type.
-fn biased_fp_to_float<F: RawFloat>(x: BiasedFp) -> F {
+fn biased_fp_to_float<F: FloatExt>(x: BiasedFp) -> F {
     let mut word = x.m;
     word |= (x.p_biased as u64) << F::SIG_BITS;
     F::from_u64_bits(word)
@@ -128,7 +128,7 @@ fn biased_fp_to_float<F: RawFloat>(x: BiasedFp) -> F {
 
 /// Converts a decimal string into a floating point number.
 #[inline(always)] // Will be inlined into a function with `#[inline(never)]`, see above
-pub fn dec2flt<F: RawFloat>(s: &str) -> Result<F, ParseFloatError> {
+pub fn dec2flt<F: Lemire>(s: &str) -> Result<F, ParseFloatError> {
     let mut s = s.as_bytes();
     let Some(&c) = s.first() else { return Err(pfe_empty()) };
     let negative = c == b'-';
diff --git a/library/core/src/num/imp/dec2flt/parse.rs b/library/core/src/num/imp/dec2flt/parse.rs
index e4049bc164c6..e4e3e5bc0c0e 100644
--- a/library/core/src/num/imp/dec2flt/parse.rs
+++ b/library/core/src/num/imp/dec2flt/parse.rs
@@ -2,7 +2,7 @@
 
 use dec2flt::common::{ByteSlice, is_8digits};
 use dec2flt::decimal::Decimal;
-use dec2flt::float::RawFloat;
+use dec2flt::float::Float;
 
 use crate::num::imp::dec2flt;
 
@@ -197,7 +197,7 @@ pub fn parse_number(s: &[u8]) -> Option<Decimal> {
 }
 
 /// Try to parse a special, non-finite float.
-pub(crate) fn parse_inf_nan<F: RawFloat>(s: &[u8], negative: bool) -> Option<F> {
+pub(crate) fn parse_inf_nan<F: Float>(s: &[u8], negative: bool) -> Option<F> {
     // Since a valid string has at most the length 8, we can load
     // all relevant characters into a u64 and work from there.
     // This also generates much better code.
diff --git a/library/core/src/num/imp/dec2flt/slow.rs b/library/core/src/num/imp/dec2flt/slow.rs
index 089b12f5be22..784f3e00f5b4 100644
--- a/library/core/src/num/imp/dec2flt/slow.rs
+++ b/library/core/src/num/imp/dec2flt/slow.rs
@@ -2,7 +2,7 @@
 
 use dec2flt::common::BiasedFp;
 use dec2flt::decimal_seq::{DecimalSeq, parse_decimal_seq};
-use dec2flt::float::RawFloat;
+use dec2flt::float::Float;
 
 use crate::num::imp::dec2flt;
 
@@ -25,7 +25,7 @@
 ///
 /// The algorithms described here are based on "Processing Long Numbers Quickly",
 /// available here: <https://arxiv.org/pdf/2101.11408.pdf#section.11>.
-pub(crate) fn parse_long_mantissa<F: RawFloat>(s: &[u8]) -> BiasedFp {
+pub(crate) fn parse_long_mantissa<F: Float>(s: &[u8]) -> BiasedFp {
     const MAX_SHIFT: usize = 60;
     const NUM_POWERS: usize = 19;
     const POWERS: [u8; 19] =
diff --git a/library/core/src/num/imp/flt2dec/decoder.rs b/library/core/src/num/imp/flt2dec/decoder.rs
index 3d6ad6608efe..6f8fb2b954f3 100644
--- a/library/core/src/num/imp/flt2dec/decoder.rs
+++ b/library/core/src/num/imp/flt2dec/decoder.rs
@@ -1,7 +1,7 @@
 //! Decodes a floating-point value into individual parts and error ranges.
 
 use crate::num::FpCategory;
-use crate::num::imp::dec2flt::float::RawFloat;
+use crate::num::imp::dec2flt::float::FloatExt;
 
 /// Decoded unsigned finite value, such that:
 ///
@@ -40,7 +40,7 @@ pub enum FullDecoded {
 }
 
 /// A floating point type which can be `decode`d.
-pub trait DecodableFloat: RawFloat + Copy {
+pub trait DecodableFloat: FloatExt + Copy {
     /// The minimum positive normalized value.
     fn min_pos_norm_value() -> Self;
 }
diff --git a/library/coretests/tests/num/dec2flt/float.rs b/library/coretests/tests/num/dec2flt/float.rs
index 25e12435b472..aa4c59dd66ea 100644
--- a/library/coretests/tests/num/dec2flt/float.rs
+++ b/library/coretests/tests/num/dec2flt/float.rs
@@ -1,4 +1,4 @@
-use core::num::imp::dec2flt::float::RawFloat;
+use core::num::imp::dec2flt::float::{Float, FloatExt, Lemire};
 
 use crate::num::{ldexp_f32, ldexp_f64};
 
@@ -56,57 +56,60 @@ fn test_f64_integer_decode() {
 #[test]
 #[cfg(target_has_reliable_f16)]
 fn test_f16_consts() {
-    assert_eq!(<f16 as RawFloat>::INFINITY, f16::INFINITY);
-    assert_eq!(<f16 as RawFloat>::NEG_INFINITY, -f16::INFINITY);
-    assert_eq!(<f16 as RawFloat>::NAN.to_bits(), f16::NAN.to_bits());
-    assert_eq!(<f16 as RawFloat>::NEG_NAN.to_bits(), (-f16::NAN).to_bits());
-    assert_eq!(<f16 as RawFloat>::SIG_BITS, 10);
-    assert_eq!(<f16 as RawFloat>::MIN_EXPONENT_ROUND_TO_EVEN, -22);
-    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_ROUND_TO_EVEN, 5);
-    assert_eq!(<f16 as RawFloat>::MIN_EXPONENT_FAST_PATH, -4);
-    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_FAST_PATH, 4);
-    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_DISGUISED_FAST_PATH, 7);
-    assert_eq!(<f16 as RawFloat>::EXP_MIN, -14);
-    assert_eq!(<f16 as RawFloat>::EXP_SAT, 0x1f);
-    assert_eq!(<f16 as RawFloat>::SMALLEST_POWER_OF_TEN, -27);
-    assert_eq!(<f16 as RawFloat>::LARGEST_POWER_OF_TEN, 4);
-    assert_eq!(<f16 as RawFloat>::MAX_MANTISSA_FAST_PATH, 2048);
+    assert_eq!(<f16 as Float>::INFINITY, f16::INFINITY);
+    assert_eq!(<f16 as Float>::NEG_INFINITY, -f16::INFINITY);
+    assert_eq!(<f16 as Float>::NAN.to_bits(), f16::NAN.to_bits());
+    assert_eq!(<f16 as Float>::NEG_NAN.to_bits(), (-f16::NAN).to_bits());
+    assert_eq!(<f16 as Float>::SIG_BITS, 10);
+    assert_eq!(<f16 as Float>::MIN_EXPONENT_ROUND_TO_EVEN, -22);
+    assert_eq!(<f16 as Float>::MAX_EXPONENT_ROUND_TO_EVEN, 5);
+    assert_eq!(<f16 as Float>::EXP_MIN, -14);
+    assert_eq!(<f16 as Float>::EXP_SAT, 0x1f);
+    assert_eq!(<f16 as Float>::SMALLEST_POWER_OF_TEN, -27);
+    assert_eq!(<f16 as Float>::LARGEST_POWER_OF_TEN, 4);
+
+    assert_eq!(<f16 as Lemire>::MIN_EXPONENT_FAST_PATH, -4);
+    assert_eq!(<f16 as Lemire>::MAX_EXPONENT_FAST_PATH, 4);
+    assert_eq!(<f16 as Lemire>::MAX_EXPONENT_DISGUISED_FAST_PATH, 7);
+    assert_eq!(<f16 as Lemire>::MAX_MANTISSA_FAST_PATH, 2048);
 }
 
 #[test]
 fn test_f32_consts() {
-    assert_eq!(<f32 as RawFloat>::INFINITY, f32::INFINITY);
-    assert_eq!(<f32 as RawFloat>::NEG_INFINITY, -f32::INFINITY);
-    assert_eq!(<f32 as RawFloat>::NAN.to_bits(), f32::NAN.to_bits());
-    assert_eq!(<f32 as RawFloat>::NEG_NAN.to_bits(), (-f32::NAN).to_bits());
-    assert_eq!(<f32 as RawFloat>::SIG_BITS, 23);
-    assert_eq!(<f32 as RawFloat>::MIN_EXPONENT_ROUND_TO_EVEN, -17);
-    assert_eq!(<f32 as RawFloat>::MAX_EXPONENT_ROUND_TO_EVEN, 10);
-    assert_eq!(<f32 as RawFloat>::MIN_EXPONENT_FAST_PATH, -10);
-    assert_eq!(<f32 as RawFloat>::MAX_EXPONENT_FAST_PATH, 10);
-    assert_eq!(<f32 as RawFloat>::MAX_EXPONENT_DISGUISED_FAST_PATH, 17);
-    assert_eq!(<f32 as RawFloat>::EXP_MIN, -126);
-    assert_eq!(<f32 as RawFloat>::EXP_SAT, 0xff);
-    assert_eq!(<f32 as RawFloat>::SMALLEST_POWER_OF_TEN, -65);
-    assert_eq!(<f32 as RawFloat>::LARGEST_POWER_OF_TEN, 38);
-    assert_eq!(<f32 as RawFloat>::MAX_MANTISSA_FAST_PATH, 16777216);
+    assert_eq!(<f32 as Float>::INFINITY, f32::INFINITY);
+    assert_eq!(<f32 as Float>::NEG_INFINITY, -f32::INFINITY);
+    assert_eq!(<f32 as Float>::NAN.to_bits(), f32::NAN.to_bits());
+    assert_eq!(<f32 as Float>::NEG_NAN.to_bits(), (-f32::NAN).to_bits());
+    assert_eq!(<f32 as Float>::SIG_BITS, 23);
+    assert_eq!(<f32 as Float>::MIN_EXPONENT_ROUND_TO_EVEN, -17);
+    assert_eq!(<f32 as Float>::MAX_EXPONENT_ROUND_TO_EVEN, 10);
+    assert_eq!(<f32 as Float>::EXP_MIN, -126);
+    assert_eq!(<f32 as Float>::EXP_SAT, 0xff);
+    assert_eq!(<f32 as Float>::SMALLEST_POWER_OF_TEN, -65);
+    assert_eq!(<f32 as Float>::LARGEST_POWER_OF_TEN, 38);
+
+    assert_eq!(<f32 as Lemire>::MIN_EXPONENT_FAST_PATH, -10);
+    assert_eq!(<f32 as Lemire>::MAX_EXPONENT_FAST_PATH, 10);
+    assert_eq!(<f32 as Lemire>::MAX_EXPONENT_DISGUISED_FAST_PATH, 17);
+    assert_eq!(<f32 as Lemire>::MAX_MANTISSA_FAST_PATH, 16777216);
 }
 
 #[test]
 fn test_f64_consts() {
-    assert_eq!(<f64 as RawFloat>::INFINITY, f64::INFINITY);
-    assert_eq!(<f64 as RawFloat>::NEG_INFINITY, -f64::INFINITY);
-    assert_eq!(<f64 as RawFloat>::NAN.to_bits(), f64::NAN.to_bits());
-    assert_eq!(<f64 as RawFloat>::NEG_NAN.to_bits(), (-f64::NAN).to_bits());
-    assert_eq!(<f64 as RawFloat>::SIG_BITS, 52);
-    assert_eq!(<f64 as RawFloat>::MIN_EXPONENT_ROUND_TO_EVEN, -4);
-    assert_eq!(<f64 as RawFloat>::MAX_EXPONENT_ROUND_TO_EVEN, 23);
-    assert_eq!(<f64 as RawFloat>::MIN_EXPONENT_FAST_PATH, -22);
-    assert_eq!(<f64 as RawFloat>::MAX_EXPONENT_FAST_PATH, 22);
-    assert_eq!(<f64 as RawFloat>::MAX_EXPONENT_DISGUISED_FAST_PATH, 37);
-    assert_eq!(<f64 as RawFloat>::EXP_MIN, -1022);
-    assert_eq!(<f64 as RawFloat>::EXP_SAT, 0x7ff);
-    assert_eq!(<f64 as RawFloat>::SMALLEST_POWER_OF_TEN, -342);
-    assert_eq!(<f64 as RawFloat>::LARGEST_POWER_OF_TEN, 308);
-    assert_eq!(<f64 as RawFloat>::MAX_MANTISSA_FAST_PATH, 9007199254740992);
+    assert_eq!(<f64 as Float>::INFINITY, f64::INFINITY);
+    assert_eq!(<f64 as Float>::NEG_INFINITY, -f64::INFINITY);
+    assert_eq!(<f64 as Float>::NAN.to_bits(), f64::NAN.to_bits());
+    assert_eq!(<f64 as Float>::NEG_NAN.to_bits(), (-f64::NAN).to_bits());
+    assert_eq!(<f64 as Float>::SIG_BITS, 52);
+    assert_eq!(<f64 as Float>::MIN_EXPONENT_ROUND_TO_EVEN, -4);
+    assert_eq!(<f64 as Float>::MAX_EXPONENT_ROUND_TO_EVEN, 23);
+    assert_eq!(<f64 as Float>::EXP_MIN, -1022);
+    assert_eq!(<f64 as Float>::EXP_SAT, 0x7ff);
+    assert_eq!(<f64 as Float>::SMALLEST_POWER_OF_TEN, -342);
+    assert_eq!(<f64 as Float>::LARGEST_POWER_OF_TEN, 308);
+
+    assert_eq!(<f64 as Lemire>::MIN_EXPONENT_FAST_PATH, -22);
+    assert_eq!(<f64 as Lemire>::MAX_EXPONENT_FAST_PATH, 22);
+    assert_eq!(<f64 as Lemire>::MAX_EXPONENT_DISGUISED_FAST_PATH, 37);
+    assert_eq!(<f64 as Lemire>::MAX_MANTISSA_FAST_PATH, 9007199254740992);
 }
diff --git a/library/coretests/tests/num/dec2flt/lemire.rs b/library/coretests/tests/num/dec2flt/lemire.rs
index e4ce533ba44d..6679dca148aa 100644
--- a/library/coretests/tests/num/dec2flt/lemire.rs
+++ b/library/coretests/tests/num/dec2flt/lemire.rs
@@ -1,6 +1,6 @@
 use core::num::imp::dec2flt;
 
-use dec2flt::float::RawFloat;
+use dec2flt::float::Float;
 use dec2flt::lemire::compute_float;
 
 #[cfg(target_has_reliable_f16)]

From bec94a33d541667abb706e8bab4dc791e64e87cc Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Sat, 31 Jan 2026 03:13:08 -0600
Subject: [PATCH 0452/1059] dec2flt: Move internal traits to better locations

`Float` and `FloatExt` are already used by both parsing and printing, so
move them out of `dec2flt` to a new module in `num::imp`. `Int` `Cast`
have the potential to be used more places in the future, so move them
there as well. `Lemire` is the only remaining trait; since it is small,
move it into the `dec2flt` root.

The `fmt::LowerExp` bound is removed from `Float` here since the trait
is moving into a module without `#[cfg(not(no_fp_fmt_parse))]` and it
isn't implemented with that config (it's not easily possible to add
`cfg` attributes to a single supertrait, unfortunately). This isn't a
problem since it isn't actually being used.
---
 library/core/src/num/imp/dec2flt/decimal.rs   |   5 +-
 library/core/src/num/imp/dec2flt/lemire.rs    |   3 +-
 library/core/src/num/imp/dec2flt/mod.rs       |  90 ++++++++++++++-
 library/core/src/num/imp/dec2flt/parse.rs     |   3 +-
 library/core/src/num/imp/dec2flt/slow.rs      |   3 +-
 library/core/src/num/imp/flt2dec/decoder.rs   |   2 +-
 library/core/src/num/imp/mod.rs               |   3 +
 .../num/imp/{dec2flt/float.rs => traits.rs}   | 106 +++---------------
 library/coretests/tests/lib.rs                |   1 +
 library/coretests/tests/num/dec2flt/float.rs  |   3 +-
 library/coretests/tests/num/dec2flt/lemire.rs |   3 +-
 11 files changed, 113 insertions(+), 109 deletions(-)
 rename library/core/src/num/imp/{dec2flt/float.rs => traits.rs} (74%)

diff --git a/library/core/src/num/imp/dec2flt/decimal.rs b/library/core/src/num/imp/dec2flt/decimal.rs
index 583f6bcf3302..c9b0cc531b38 100644
--- a/library/core/src/num/imp/dec2flt/decimal.rs
+++ b/library/core/src/num/imp/dec2flt/decimal.rs
@@ -1,9 +1,10 @@
 //! Representation of a float as the significant digits and exponent.
 
-use crate::num::imp::dec2flt;
-use dec2flt::float::Lemire;
+use dec2flt::Lemire;
 use dec2flt::fpu::set_precision;
 
+use crate::num::imp::dec2flt;
+
 const INT_POW10: [u64; 16] = [
     1,
     10,
diff --git a/library/core/src/num/imp/dec2flt/lemire.rs b/library/core/src/num/imp/dec2flt/lemire.rs
index 8a97618cf738..f89d16c84347 100644
--- a/library/core/src/num/imp/dec2flt/lemire.rs
+++ b/library/core/src/num/imp/dec2flt/lemire.rs
@@ -1,10 +1,9 @@
 //! Implementation of the Eisel-Lemire algorithm.
 
 use dec2flt::common::BiasedFp;
-use dec2flt::float::Float;
 use dec2flt::table::{LARGEST_POWER_OF_FIVE, POWER_OF_FIVE_128, SMALLEST_POWER_OF_FIVE};
 
-use crate::num::imp::dec2flt;
+use crate::num::imp::{Float, dec2flt};
 
 /// Compute w * 10^q using an extended-precision float representation.
 ///
diff --git a/library/core/src/num/imp/dec2flt/mod.rs b/library/core/src/num/imp/dec2flt/mod.rs
index 33e606694bc3..76b8d416ee0f 100644
--- a/library/core/src/num/imp/dec2flt/mod.rs
+++ b/library/core/src/num/imp/dec2flt/mod.rs
@@ -88,24 +88,104 @@
 )]
 
 use common::BiasedFp;
-use float::{FloatExt, Lemire};
 use lemire::compute_float;
 use parse::{parse_inf_nan, parse_number};
 use slow::parse_long_mantissa;
 
+use crate::f64;
 use crate::num::ParseFloatError;
 use crate::num::float_parse::FloatErrorKind;
+use crate::num::imp::FloatExt;
 
 mod common;
 pub mod decimal;
 pub mod decimal_seq;
 mod fpu;
-mod slow;
-mod table;
-// float is used in flt2dec, and all are used in unit tests.
-pub mod float;
 pub mod lemire;
 pub mod parse;
+mod slow;
+mod table;
+
+/// Extension to `Float` that are necessary for parsing using the Lemire method.
+///
+/// See the parent module's doc comment for why this is necessary.
+///
+/// Not intended for use outside of the `dec2flt` module.
+#[doc(hidden)]
+pub trait Lemire: FloatExt {
+    /// Maximum exponent for a fast path case, or `⌊(SIG_BITS+1)/log2(5)⌋`
+    // assuming FLT_EVAL_METHOD = 0
+    const MAX_EXPONENT_FAST_PATH: i64 = {
+        let log2_5 = f64::consts::LOG2_10 - 1.0;
+        (Self::SIG_TOTAL_BITS as f64 / log2_5) as i64
+    };
+
+    /// Minimum exponent for a fast path case, or `-⌊(SIG_BITS+1)/log2(5)⌋`
+    const MIN_EXPONENT_FAST_PATH: i64 = -Self::MAX_EXPONENT_FAST_PATH;
+
+    /// Maximum exponent that can be represented for a disguised-fast path case.
+    /// This is `MAX_EXPONENT_FAST_PATH + ⌊(SIG_BITS+1)/log2(10)⌋`
+    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 =
+        Self::MAX_EXPONENT_FAST_PATH + (Self::SIG_TOTAL_BITS as f64 / f64::consts::LOG2_10) as i64;
+
+    /// Maximum mantissa for the fast-path (`1 << 53` for f64).
+    const MAX_MANTISSA_FAST_PATH: u64 = 1 << Self::SIG_TOTAL_BITS;
+
+    /// Gets a small power-of-ten for fast-path multiplication.
+    fn pow10_fast_path(exponent: usize) -> Self;
+
+    /// Converts integer into float through an as cast.
+    /// This is only called in the fast-path algorithm, and therefore
+    /// will not lose precision, since the value will always have
+    /// only if the value is <= Self::MAX_MANTISSA_FAST_PATH.
+    fn from_u64(v: u64) -> Self;
+}
+
+#[cfg(target_has_reliable_f16)]
+impl Lemire for f16 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        #[allow(clippy::use_self)]
+        const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
+        TABLE[exponent & 7]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
+
+impl Lemire for f32 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        #[allow(clippy::use_self)]
+        const TABLE: [f32; 16] =
+            [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.];
+        TABLE[exponent & 15]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
+
+impl Lemire for f64 {
+    fn pow10_fast_path(exponent: usize) -> Self {
+        const TABLE: [f64; 32] = [
+            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
+            1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+        ];
+        TABLE[exponent & 31]
+    }
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+}
 
 #[inline]
 pub(super) fn pfe_empty() -> ParseFloatError {
diff --git a/library/core/src/num/imp/dec2flt/parse.rs b/library/core/src/num/imp/dec2flt/parse.rs
index e4e3e5bc0c0e..ee55eadbc7b9 100644
--- a/library/core/src/num/imp/dec2flt/parse.rs
+++ b/library/core/src/num/imp/dec2flt/parse.rs
@@ -2,9 +2,8 @@
 
 use dec2flt::common::{ByteSlice, is_8digits};
 use dec2flt::decimal::Decimal;
-use dec2flt::float::Float;
 
-use crate::num::imp::dec2flt;
+use crate::num::imp::{Float, dec2flt};
 
 const MIN_19DIGIT_INT: u64 = 100_0000_0000_0000_0000;
 
diff --git a/library/core/src/num/imp/dec2flt/slow.rs b/library/core/src/num/imp/dec2flt/slow.rs
index 784f3e00f5b4..f1b2525cf38e 100644
--- a/library/core/src/num/imp/dec2flt/slow.rs
+++ b/library/core/src/num/imp/dec2flt/slow.rs
@@ -2,9 +2,8 @@
 
 use dec2flt::common::BiasedFp;
 use dec2flt::decimal_seq::{DecimalSeq, parse_decimal_seq};
-use dec2flt::float::Float;
 
-use crate::num::imp::dec2flt;
+use crate::num::imp::{Float, dec2flt};
 
 /// Parse the significant digits and biased, binary exponent of a float.
 ///
diff --git a/library/core/src/num/imp/flt2dec/decoder.rs b/library/core/src/num/imp/flt2dec/decoder.rs
index 6f8fb2b954f3..5ccc91f4c9fa 100644
--- a/library/core/src/num/imp/flt2dec/decoder.rs
+++ b/library/core/src/num/imp/flt2dec/decoder.rs
@@ -1,7 +1,7 @@
 //! Decodes a floating-point value into individual parts and error ranges.
 
 use crate::num::FpCategory;
-use crate::num::imp::dec2flt::float::FloatExt;
+use crate::num::imp::FloatExt;
 
 /// Decoded unsigned finite value, such that:
 ///
diff --git a/library/core/src/num/imp/mod.rs b/library/core/src/num/imp/mod.rs
index d35409f91bde..6fccfd1c238e 100644
--- a/library/core/src/num/imp/mod.rs
+++ b/library/core/src/num/imp/mod.rs
@@ -16,3 +16,6 @@
 pub(crate) mod int_sqrt;
 pub(crate) mod libm;
 pub(crate) mod overflow_panic;
+mod traits;
+
+pub use traits::{Float, FloatExt, Int};
diff --git a/library/core/src/num/imp/dec2flt/float.rs b/library/core/src/num/imp/traits.rs
similarity index 74%
rename from library/core/src/num/imp/dec2flt/float.rs
rename to library/core/src/num/imp/traits.rs
index da581a457f49..7b84f7a4a5aa 100644
--- a/library/core/src/num/imp/dec2flt/float.rs
+++ b/library/core/src/num/imp/traits.rs
@@ -1,10 +1,14 @@
-//! Helper trait for generic float types.
+//! Numeric traits used for internal implementations.
 
-use core::f64;
+#![doc(hidden)]
+#![unstable(
+    feature = "num_internals",
+    reason = "internal routines only exposed for testing",
+    issue = "none"
+)]
 
-use crate::fmt::{Debug, LowerExp};
 use crate::num::FpCategory;
-use crate::ops::{self, Add, Div, Mul, Neg};
+use crate::{f64, fmt, ops};
 
 /// Lossy `as` casting between two types.
 pub trait CastInto<T: Copy>: Copy {
@@ -16,7 +20,7 @@ pub trait Int:
     Sized
     + Clone
     + Copy
-    + Debug
+    + fmt::Debug
     + ops::Shr<u32, Output = Self>
     + ops::Shl<u32, Output = Self>
     + ops::BitAnd<Output = Self>
@@ -51,17 +55,16 @@ impl Int for $ty {
 #[doc(hidden)]
 pub trait Float:
     Sized
-    + Div<Output = Self>
-    + Neg<Output = Self>
-    + Mul<Output = Self>
-    + Add<Output = Self>
-    + LowerExp
+    + ops::Div<Output = Self>
+    + ops::Neg<Output = Self>
+    + ops::Mul<Output = Self>
+    + ops::Add<Output = Self>
+    + fmt::Debug
     + PartialEq
     + PartialOrd
     + Default
     + Clone
     + Copy
-    + Debug
 {
     /// The unsigned integer with the same size as the float
     type Int: Int + Into<u64>;
@@ -184,41 +187,6 @@ fn integer_decode(self) -> (u64, i16, i8) {
     }
 }
 
-/// Extension to `Float` that are necessary for parsing using the Lemire method.
-///
-/// See the parent module's doc comment for why this is necessary.
-///
-/// Not intended for use outside of the `dec2flt` module.
-#[doc(hidden)]
-pub trait Lemire: FloatExt {
-    /// Maximum exponent for a fast path case, or `⌊(SIG_BITS+1)/log2(5)⌋`
-    // assuming FLT_EVAL_METHOD = 0
-    const MAX_EXPONENT_FAST_PATH: i64 = {
-        let log2_5 = f64::consts::LOG2_10 - 1.0;
-        (Self::SIG_TOTAL_BITS as f64 / log2_5) as i64
-    };
-
-    /// Minimum exponent for a fast path case, or `-⌊(SIG_BITS+1)/log2(5)⌋`
-    const MIN_EXPONENT_FAST_PATH: i64 = -Self::MAX_EXPONENT_FAST_PATH;
-
-    /// Maximum exponent that can be represented for a disguised-fast path case.
-    /// This is `MAX_EXPONENT_FAST_PATH + ⌊(SIG_BITS+1)/log2(10)⌋`
-    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 =
-        Self::MAX_EXPONENT_FAST_PATH + (Self::SIG_TOTAL_BITS as f64 / f64::consts::LOG2_10) as i64;
-
-    /// Maximum mantissa for the fast-path (`1 << 53` for f64).
-    const MAX_MANTISSA_FAST_PATH: u64 = 1 << Self::SIG_TOTAL_BITS;
-
-    /// Gets a small power-of-ten for fast-path multiplication.
-    fn pow10_fast_path(exponent: usize) -> Self;
-
-    /// Converts integer into float through an as cast.
-    /// This is only called in the fast-path algorithm, and therefore
-    /// will not lose precision, since the value will always have
-    /// only if the value is <= Self::MAX_MANTISSA_FAST_PATH.
-    fn from_u64(v: u64) -> Self;
-}
-
 /// Solve for `b` in `10^b = 2^a`
 const fn pow2_to_pow10(a: i64) -> i64 {
     let res = (a as f64) / f64::consts::LOG2_10;
@@ -260,21 +228,6 @@ fn from_u64_bits(v: u64) -> Self {
     }
 }
 
-#[cfg(target_has_reliable_f16)]
-impl Lemire for f16 {
-    fn pow10_fast_path(exponent: usize) -> Self {
-        #[allow(clippy::use_self)]
-        const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
-        TABLE[exponent & 7]
-    }
-
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-}
-
 impl Float for f32 {
     type Int = u32;
 
@@ -308,21 +261,6 @@ fn from_u64_bits(v: u64) -> Self {
     }
 }
 
-impl Lemire for f32 {
-    fn pow10_fast_path(exponent: usize) -> Self {
-        #[allow(clippy::use_self)]
-        const TABLE: [f32; 16] =
-            [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.];
-        TABLE[exponent & 15]
-    }
-
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-}
-
 impl Float for f64 {
     type Int = u64;
 
@@ -355,19 +293,3 @@ fn from_u64_bits(v: u64) -> Self {
         f64::from_bits(v)
     }
 }
-
-impl Lemire for f64 {
-    fn pow10_fast_path(exponent: usize) -> Self {
-        const TABLE: [f64; 32] = [
-            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
-            1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 0., 0., 0., 0., 0., 0., 0., 0., 0.,
-        ];
-        TABLE[exponent & 31]
-    }
-
-    #[inline]
-    fn from_u64(v: u64) -> Self {
-        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
-        v as _
-    }
-}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 72112f8b0113..b3fd53cbb9dc 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -88,6 +88,7 @@
 #![feature(next_index)]
 #![feature(non_exhaustive_omitted_patterns_lint)]
 #![feature(nonzero_from_str_radix)]
+#![feature(num_internals)]
 #![feature(numfmt)]
 #![feature(one_sided_range)]
 #![feature(panic_internals)]
diff --git a/library/coretests/tests/num/dec2flt/float.rs b/library/coretests/tests/num/dec2flt/float.rs
index aa4c59dd66ea..0713c5c651fb 100644
--- a/library/coretests/tests/num/dec2flt/float.rs
+++ b/library/coretests/tests/num/dec2flt/float.rs
@@ -1,4 +1,5 @@
-use core::num::imp::dec2flt::float::{Float, FloatExt, Lemire};
+use core::num::imp::dec2flt::Lemire;
+use core::num::imp::{Float, FloatExt};
 
 use crate::num::{ldexp_f32, ldexp_f64};
 
diff --git a/library/coretests/tests/num/dec2flt/lemire.rs b/library/coretests/tests/num/dec2flt/lemire.rs
index 6679dca148aa..e5a7ae346f42 100644
--- a/library/coretests/tests/num/dec2flt/lemire.rs
+++ b/library/coretests/tests/num/dec2flt/lemire.rs
@@ -1,6 +1,5 @@
-use core::num::imp::dec2flt;
+use core::num::imp::{Float, dec2flt};
 
-use dec2flt::float::Float;
 use dec2flt::lemire::compute_float;
 
 #[cfg(target_has_reliable_f16)]

From 0a90f8ddc27a88ec02b3f6897c8dc7c165cd5502 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 14 Mar 2026 21:03:59 +1100
Subject: [PATCH 0453/1059] Use named fields in ChunkedBitSet's `Chunk::Mixed`

This helps to clarify that the field with type `ChunkSize` is a count of 1s,
not a length or size.
---
 compiler/rustc_index/src/bit_set.rs       | 81 ++++++++++++-----------
 compiler/rustc_index/src/bit_set/tests.rs | 24 +++----
 2 files changed, 56 insertions(+), 49 deletions(-)

diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 184fa409d960..68384c73ba25 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -509,14 +509,20 @@ enum Chunk {
     /// to store the length, which would make this type larger. These excess
     /// words are always zero, as are any excess bits in the final in-use word.
     ///
-    /// The `ChunkSize` field is the count of 1s set in the chunk, and
-    /// must satisfy `0 < count < chunk_domain_size`.
-    ///
     /// The words are within an `Rc` because it's surprisingly common to
     /// duplicate an entire chunk, e.g. in `ChunkedBitSet::clone_from()`, or
     /// when a `Mixed` chunk is union'd into a `Zeros` chunk. When we do need
     /// to modify a chunk we use `Rc::make_mut`.
-    Mixed(ChunkSize, Rc<[Word; CHUNK_WORDS]>),
+    Mixed {
+        /// Count of set bits (1s) in this chunk's words.
+        ///
+        /// Invariant: `0 < ones_count < chunk_domain_size`.
+        ///
+        /// Tracking this separately allows individual insert/remove calls to
+        /// know that the chunk has become all-zeroes or all-ones, in O(1) time.
+        ones_count: ChunkSize,
+        words: Rc<[Word; CHUNK_WORDS]>,
+    },
 }
 
 // This type is used a lot. Make sure it doesn't unintentionally get bigger.
@@ -613,7 +619,7 @@ pub fn contains(&self, elem: T) -> bool {
         match &chunk {
             Zeros => false,
             Ones => true,
-            Mixed(_, words) => {
+            Mixed { ones_count: _, words } => {
                 let (word_index, mask) = chunk_word_index_and_mask(elem);
                 (words[word_index] & mask) != 0
             }
@@ -644,19 +650,19 @@ pub fn insert(&mut self, elem: T) -> bool {
 
                     let (word_index, mask) = chunk_word_index_and_mask(elem);
                     words_ref[word_index] |= mask;
-                    *chunk = Mixed(1, words);
+                    *chunk = Mixed { ones_count: 1, words };
                 } else {
                     *chunk = Ones;
                 }
                 true
             }
             Ones => false,
-            Mixed(ref mut count, ref mut words) => {
+            Mixed { ref mut ones_count, ref mut words } => {
                 // We skip all the work if the bit is already set.
                 let (word_index, mask) = chunk_word_index_and_mask(elem);
                 if (words[word_index] & mask) == 0 {
-                    *count += 1;
-                    if *count < chunk_domain_size {
+                    *ones_count += 1;
+                    if *ones_count < chunk_domain_size {
                         let words = Rc::make_mut(words);
                         words[word_index] |= mask;
                     } else {
@@ -702,18 +708,18 @@ pub fn remove(&mut self, elem: T) -> bool {
                     );
                     let (word_index, mask) = chunk_word_index_and_mask(elem);
                     words_ref[word_index] &= !mask;
-                    *chunk = Mixed(chunk_domain_size - 1, words);
+                    *chunk = Mixed { ones_count: chunk_domain_size - 1, words };
                 } else {
                     *chunk = Zeros;
                 }
                 true
             }
-            Mixed(ref mut count, ref mut words) => {
+            Mixed { ref mut ones_count, ref mut words } => {
                 // We skip all the work if the bit is already clear.
                 let (word_index, mask) = chunk_word_index_and_mask(elem);
                 if (words[word_index] & mask) != 0 {
-                    *count -= 1;
-                    if *count > 0 {
+                    *ones_count -= 1;
+                    if *ones_count > 0 {
                         let words = Rc::make_mut(words);
                         words[word_index] &= !mask;
                     } else {
@@ -732,7 +738,7 @@ fn chunk_iter(&self, chunk_index: usize) -> ChunkIter<'_> {
         match self.chunks.get(chunk_index) {
             Some(Zeros) => ChunkIter::Zeros,
             Some(Ones) => ChunkIter::Ones(0..chunk_domain_size as usize),
-            Some(Mixed(_, words)) => {
+            Some(Mixed { ones_count: _, words }) => {
                 let num_words = num_words(chunk_domain_size as usize);
                 ChunkIter::Mixed(BitIter::new(&words[0..num_words]))
             }
@@ -765,14 +771,14 @@ fn union(&mut self, other: &ChunkedBitSet<T>) -> bool {
 
             match (&mut self_chunk, &other_chunk) {
                 (_, Zeros) | (Ones, _) => {}
-                (Zeros, _) | (Mixed(..), Ones) => {
+                (Zeros, _) | (Mixed { .. }, Ones) => {
                     // `other_chunk` fully overwrites `self_chunk`
                     *self_chunk = other_chunk.clone();
                     changed = true;
                 }
                 (
-                    Mixed(self_chunk_count, self_chunk_words),
-                    Mixed(_other_chunk_count, other_chunk_words),
+                    Mixed { ones_count: self_chunk_ones, words: self_chunk_words },
+                    Mixed { ones_count: _, words: other_chunk_words },
                 ) => {
                     // First check if the operation would change
                     // `self_chunk.words`. If not, we can avoid allocating some
@@ -807,8 +813,8 @@ fn union(&mut self, other: &ChunkedBitSet<T>) -> bool {
                         op,
                     );
                     debug_assert!(has_changed);
-                    *self_chunk_count = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
-                    if *self_chunk_count == chunk_domain_size {
+                    *self_chunk_ones = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
+                    if *self_chunk_ones == chunk_domain_size {
                         *self_chunk = Ones;
                     }
                     changed = true;
@@ -839,11 +845,11 @@ fn subtract(&mut self, other: &ChunkedBitSet<T>) -> bool {
 
             match (&mut self_chunk, &other_chunk) {
                 (Zeros, _) | (_, Zeros) => {}
-                (Ones | Mixed(..), Ones) => {
+                (Ones | Mixed { .. }, Ones) => {
                     changed = true;
                     *self_chunk = Zeros;
                 }
-                (Ones, Mixed(other_chunk_count, other_chunk_words)) => {
+                (Ones, Mixed { ones_count: other_chunk_ones, words: other_chunk_words }) => {
                     changed = true;
                     let num_words = num_words(chunk_domain_size as usize);
                     debug_assert!(num_words > 0 && num_words <= CHUNK_WORDS);
@@ -854,16 +860,17 @@ fn subtract(&mut self, other: &ChunkedBitSet<T>) -> bool {
                         *word = !*word & tail_mask;
                         tail_mask = Word::MAX;
                     }
-                    let self_chunk_count = chunk_domain_size - *other_chunk_count;
+                    let self_chunk_ones = chunk_domain_size - *other_chunk_ones;
                     debug_assert_eq!(
-                        self_chunk_count,
+                        self_chunk_ones,
                         count_ones(&self_chunk_words[0..num_words]) as ChunkSize
                     );
-                    *self_chunk = Mixed(self_chunk_count, Rc::new(self_chunk_words));
+                    *self_chunk =
+                        Mixed { ones_count: self_chunk_ones, words: Rc::new(self_chunk_words) };
                 }
                 (
-                    Mixed(self_chunk_count, self_chunk_words),
-                    Mixed(_other_chunk_count, other_chunk_words),
+                    Mixed { ones_count: self_chunk_ones, words: self_chunk_words },
+                    Mixed { ones_count: _, words: other_chunk_words },
                 ) => {
                     // See `ChunkedBitSet::union` for details on what is happening here.
                     let num_words = num_words(chunk_domain_size as usize);
@@ -883,8 +890,8 @@ fn subtract(&mut self, other: &ChunkedBitSet<T>) -> bool {
                         op,
                     );
                     debug_assert!(has_changed);
-                    *self_chunk_count = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
-                    if *self_chunk_count == 0 {
+                    *self_chunk_ones = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
+                    if *self_chunk_ones == 0 {
                         *self_chunk = Zeros;
                     }
                     changed = true;
@@ -915,13 +922,13 @@ fn intersect(&mut self, other: &ChunkedBitSet<T>) -> bool {
 
             match (&mut self_chunk, &other_chunk) {
                 (Zeros, _) | (_, Ones) => {}
-                (Ones, Zeros | Mixed(..)) | (Mixed(..), Zeros) => {
+                (Ones, Zeros | Mixed { .. }) | (Mixed { .. }, Zeros) => {
                     changed = true;
                     *self_chunk = other_chunk.clone();
                 }
                 (
-                    Mixed(self_chunk_count, self_chunk_words),
-                    Mixed(_other_chunk_count, other_chunk_words),
+                    Mixed { ones_count: self_chunk_ones, words: self_chunk_words },
+                    Mixed { ones_count: _, words: other_chunk_words },
                 ) => {
                     // See `ChunkedBitSet::union` for details on what is happening here.
                     let num_words = num_words(chunk_domain_size as usize);
@@ -941,8 +948,8 @@ fn intersect(&mut self, other: &ChunkedBitSet<T>) -> bool {
                         op,
                     );
                     debug_assert!(has_changed);
-                    *self_chunk_count = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
-                    if *self_chunk_count == 0 {
+                    *self_chunk_ones = count_ones(&self_chunk_words[0..num_words]) as ChunkSize;
+                    if *self_chunk_ones == 0 {
                         *self_chunk = Zeros;
                     }
                     changed = true;
@@ -1023,11 +1030,11 @@ fn assert_valid(&self, chunk_domain_size: ChunkSize) {
         assert!(chunk_domain_size as usize <= CHUNK_BITS);
         match *self {
             Zeros | Ones => {}
-            Mixed(count, ref words) => {
-                assert!(0 < count && count < chunk_domain_size);
+            Mixed { ones_count, ref words } => {
+                assert!(0 < ones_count && ones_count < chunk_domain_size);
 
                 // Check the number of set bits matches `count`.
-                assert_eq!(count_ones(words.as_slice()) as ChunkSize, count);
+                assert_eq!(count_ones(words.as_slice()) as ChunkSize, ones_count);
 
                 // Check the not-in-use words are all zeroed.
                 let num_words = num_words(chunk_domain_size as usize);
@@ -1043,7 +1050,7 @@ fn count(&self, chunk_domain_size: ChunkSize) -> usize {
         match *self {
             Zeros => 0,
             Ones => chunk_domain_size as usize,
-            Mixed(count, _) => count as usize,
+            Mixed { ones_count, words: _ } => usize::from(ones_count),
         }
     }
 }
diff --git a/compiler/rustc_index/src/bit_set/tests.rs b/compiler/rustc_index/src/bit_set/tests.rs
index 341e0622df75..a0184c5c47f3 100644
--- a/compiler/rustc_index/src/bit_set/tests.rs
+++ b/compiler/rustc_index/src/bit_set/tests.rs
@@ -162,16 +162,16 @@ fn chunked_bitset() {
     assert!(!b100.contains(20) && b100.contains(30) && !b100.contains(99) && b100.contains(50));
     assert_eq!(
         b100.chunks(),
-        vec![Mixed(
-            97,
+        vec![Mixed {
+            ones_count: 97,
             #[rustfmt::skip]
-            Rc::new([
+            words: Rc::new([
                 0b11111111_11111111_11111110_11111111_11111111_11101111_11111111_11111111,
                 0b00000000_00000000_00000000_00000111_11111111_11111111_11111111_11111111,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0,
             ])
-        )],
+        }],
     );
     b100.assert_valid();
     let mut num_removed = 0;
@@ -228,14 +228,14 @@ fn chunked_bitset() {
         b4096.chunks(),
         #[rustfmt::skip]
         vec![
-            Mixed(1, Rc::new([
+            Mixed { ones_count: 1, words:Rc::new([
                 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-            ])),
-            Mixed(1, Rc::new([
+            ])},
+            Mixed { ones_count: 1, words: Rc::new([
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8000_0000_0000_0000
-            ])),
+            ])},
         ],
     );
     assert_eq!(b4096.count(), 2);
@@ -265,14 +265,14 @@ fn chunked_bitset() {
         #[rustfmt::skip]
         vec![
             Zeros,
-            Mixed(1, Rc::new([
+            Mixed { ones_count: 1, words: Rc::new([
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0100_0000_0000_0000, 0,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            ])),
-            Mixed(1, Rc::new([
+            ])},
+            Mixed { ones_count: 1, words: Rc::new([
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0100, 0,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            ])),
+            ])},
             Zeros,
             Zeros,
         ],

From 2662303112bcfa768f525c9bcf8f3bb5d62acdd3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 12 Mar 2026 12:39:41 +0100
Subject: [PATCH 0454/1059] mips: require LLVM ABI to be explicitly set, but
 also allow n32

---
 compiler/rustc_codegen_ssa/src/back/metadata.rs       | 11 +++--------
 compiler/rustc_target/src/spec/mod.rs                 | 10 +++++-----
 .../src/spec/targets/mips_mti_none_elf.rs             |  1 +
 .../src/spec/targets/mips_unknown_linux_gnu.rs        |  1 +
 .../src/spec/targets/mips_unknown_linux_musl.rs       |  7 ++++++-
 .../src/spec/targets/mips_unknown_linux_uclibc.rs     |  1 +
 .../src/spec/targets/mipsel_mti_none_elf.rs           |  1 +
 .../rustc_target/src/spec/targets/mipsel_sony_psp.rs  |  1 +
 .../src/spec/targets/mipsel_unknown_linux_gnu.rs      |  1 +
 .../src/spec/targets/mipsel_unknown_linux_musl.rs     |  2 +-
 .../src/spec/targets/mipsel_unknown_linux_uclibc.rs   |  1 +
 .../src/spec/targets/mipsel_unknown_netbsd.rs         |  1 +
 .../src/spec/targets/mipsel_unknown_none.rs           |  1 +
 .../src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs |  1 +
 .../spec/targets/mipsisa32r6el_unknown_linux_gnu.rs   |  1 +
 15 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 8a2a6823fdf4..240267c362f6 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -294,18 +294,13 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
                 _ => elf::EF_MIPS_ARCH_64R2,
             };
 
-            // If the ABI is explicitly given, use it, or default to O32 on 32-bit MIPS,
-            // which is the only "true" 32-bit option that LLVM supports.
+            // Use the explicitly given ABI.
             match sess.target.options.llvm_abiname.as_ref() {
                 "o32" if is_32bit => e_flags |= elf::EF_MIPS_ABI_O32,
                 "n32" if !is_32bit => e_flags |= elf::EF_MIPS_ABI2,
                 "n64" if !is_32bit => {}
-                "" if is_32bit => e_flags |= elf::EF_MIPS_ABI_O32,
-                "" => sess.dcx().fatal("LLVM ABI must be specified for 64-bit MIPS targets"),
-                s if is_32bit => {
-                    sess.dcx().fatal(format!("invalid LLVM ABI `{}` for 32-bit MIPS target", s))
-                }
-                s => sess.dcx().fatal(format!("invalid LLVM ABI `{}` for 64-bit MIPS target", s)),
+                // The rest is invalid (which is already ensured by the target spec check).
+                s => bug!("invalid LLVM ABI `{}` for MIPS target", s),
             };
 
             if sess.target.options.relocation_model != RelocModel::Static {
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index a28794eee458..8683e4f51279 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -3402,14 +3402,12 @@ macro_rules! check_matches {
                     self.abi,
                 );
             }
-            Arch::Mips => {
+            Arch::Mips | Arch::Mips32r6 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
                     (&*self.llvm_abiname, &self.abi),
-                    // FIXME: we should force it to always be non-empty.
-                    ("o32", Abi::Unspecified | Abi::Other(_))
-                        | ("", Abi::Unspecified | Abi::Other(_)),
+                    ("o32", Abi::Unspecified | Abi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3422,7 +3420,9 @@ macro_rules! check_matches {
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
                     (&*self.llvm_abiname, &self.abi),
-                    ("n64", Abi::Abi64),
+                    // No in-tree targets use "n32" but at least for now we let out-of-tree targets
+                    // experiment with that.
+                    ("n64", Abi::Abi64) | ("n32", Abi::Unspecified | Abi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
diff --git a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
index 54039925e795..ed024c6f9cd4 100644
--- a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
@@ -24,6 +24,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
 
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
 
             features: "+mips32r2,+soft-float,+noabicalls".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
index ea6e237895ae..9eb3173d64bc 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
@@ -18,6 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
             features: "+mips32r2,+fpxx,+nooddspreg".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
index ab68c2495b5a..5737e42f9919 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
@@ -18,6 +18,11 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),
         arch: Arch::Mips,
-        options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base },
+        options: TargetOptions {
+            endian: Endian::Big,
+            llvm_abiname: "o32".into(),
+            mcount: "_mcount".into(),
+            ..base
+        },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
index c699f7e20b06..d9bfa12169c3 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
@@ -18,6 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
index 06c4d14be432..767c57e3e860 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
@@ -24,6 +24,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Little,
             cpu: "mips32r2".into(),
 
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
 
             features: "+mips32r2,+soft-float,+noabicalls".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
index 370e585f65ad..bc8f29c1bf1e 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
@@ -36,6 +36,7 @@ pub(crate) fn target() -> Target {
 
             // PSP does not support trap-on-condition instructions.
             llvm_args: cvs!["-mno-check-zero-division"],
+            llvm_abiname: "o32".into(),
             pre_link_args,
             link_script: Some(LINKER_SCRIPT.into()),
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
index 79a22e518b0c..752de4623e91 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
@@ -16,6 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r2".into(),
             features: "+mips32r2,+fpxx,+nooddspreg".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
index 8c64b17a37b5..fb3375285d50 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
@@ -16,6 +16,6 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),
         arch: Arch::Mips,
-        options: TargetOptions { mcount: "_mcount".into(), ..base },
+        options: TargetOptions { llvm_abiname: "o32".into(), mcount: "_mcount".into(), ..base },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
index 295b1788877c..830cdd1238db 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
@@ -16,6 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
index 69b232d71ea1..262062940030 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
@@ -20,6 +20,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Mips,
         options: TargetOptions {
             features: "+soft-float".into(),
+            llvm_abiname: "o32".into(),
             mcount: "__mcount".into(),
             endian: Endian::Little,
             ..base
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
index 7012651afc34..b66be0bef216 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
@@ -23,6 +23,7 @@ pub(crate) fn target() -> Target {
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float,+noabicalls".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             linker: Some("rust-lld".into()),
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
index b45511446d8d..9b063365b8d5 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
@@ -18,6 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r6".into(),
             features: "+mips32r6".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
index 36845029de3b..a5a05d56a492 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
@@ -16,6 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r6".into(),
             features: "+mips32r6".into(),
+            llvm_abiname: "o32".into(),
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 

From 5e62d4f1c8fb9409c5163c3f473a01075fa4c348 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 14 Mar 2026 11:10:56 +0000
Subject: [PATCH 0455/1059] Bump undici from 6.21.3 to 6.24.1 in /editors/code

Bumps [undici](https://github.com/nodejs/undici) from 6.21.3 to 6.24.1.
- [Release notes](https://github.com/nodejs/undici/releases)
- [Commits](https://github.com/nodejs/undici/compare/v6.21.3...v6.24.1)

---
updated-dependencies:
- dependency-name: undici
  dependency-version: 6.24.1
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/rust-analyzer/editors/code/package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index be0bdc8d55bb..4bddc28c1ef7 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -6719,9 +6719,9 @@
             "license": "MIT"
         },
         "node_modules/undici": {
-            "version": "6.21.3",
-            "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.3.tgz",
-            "integrity": "sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw==",
+            "version": "6.24.1",
+            "resolved": "https://registry.npmjs.org/undici/-/undici-6.24.1.tgz",
+            "integrity": "sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA==",
             "dev": true,
             "license": "MIT",
             "engines": {

From dd0b7c41691b6e1e023dfc8a6b77553c13b56026 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 11 Mar 2026 13:05:17 +0100
Subject: [PATCH 0456/1059] add `f16` support

---
 src/tools/miri/src/helpers.rs                 |  16 ++
 src/tools/miri/src/intrinsics/math.rs         | 205 +++++++++++-------
 src/tools/miri/src/intrinsics/simd.rs         |  17 +-
 src/tools/miri/src/lib.rs                     |   1 +
 src/tools/miri/src/math.rs                    | 110 +++++++---
 src/tools/miri/tests/pass/float.rs            | 144 +++++++++++-
 .../tests/pass/intrinsics/portable-simd.rs    |  25 +++
 7 files changed, 396 insertions(+), 122 deletions(-)

diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index 72bb5c7cfa54..cbce44ca5875 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -209,6 +209,22 @@ fn to_soft(self) -> Self::SoftFloat {
     }
 }
 
+impl ToHost for rustc_apfloat::ieee::Half {
+    type HostFloat = f16;
+
+    fn to_host(self) -> Self::HostFloat {
+        f16::from_bits(self.to_bits().try_into().unwrap())
+    }
+}
+
+impl ToSoft for f16 {
+    type SoftFloat = rustc_apfloat::ieee::Half;
+
+    fn to_soft(self) -> Self::SoftFloat {
+        Float::from_bits(self.to_bits().into())
+    }
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Checks if the given crate/module exists.
diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index 0cc4342f0d55..59c728dc4282 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -3,6 +3,7 @@
 use rustc_middle::ty::{self, FloatTy};
 
 use self::helpers::{ToHost, ToSoft};
+use self::math::{HostFloatOperation, IeeeExt};
 use super::check_intrinsic_arg_count;
 use crate::*;
 
@@ -20,6 +21,42 @@ fn sqrt<'tcx, F: Float + FloatConvert<F> + Into<Scalar>>(
     this.write_scalar(res, dest)
 }
 
+#[derive(Debug, Clone, Copy)]
+enum HostFloatUnaryOp {
+    Sin,
+    Cos,
+    Exp,
+    Exp2,
+    Log,
+    Log10,
+    Log2,
+}
+
+fn is_host_unary_float_op(intrinsic_name: &str) -> Option<(FloatTy, HostFloatUnaryOp)> {
+    let (op, ty) = intrinsic_name.rsplit_once('f')?;
+
+    let float_ty = match ty {
+        "16" => FloatTy::F16,
+        "32" => FloatTy::F32,
+        "64" => FloatTy::F64,
+        "128" => FloatTy::F128,
+        _ => return None,
+    };
+
+    let host_float_op = match op {
+        "sin" => HostFloatUnaryOp::Sin,
+        "cos" => HostFloatUnaryOp::Cos,
+        "exp" => HostFloatUnaryOp::Exp,
+        "exp2" => HostFloatUnaryOp::Exp2,
+        "log" => HostFloatUnaryOp::Log,
+        "log10" => HostFloatUnaryOp::Log10,
+        "log2" => HostFloatUnaryOp::Log2,
+        _ => return None,
+    };
+
+    Some((float_ty, host_float_op))
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn emulate_math_intrinsic(
@@ -108,94 +145,84 @@ fn emulate_math_intrinsic(
             }
 
             // Operations that need host floats.
-            #[rustfmt::skip]
-            | "sinf32"
-            | "cosf32"
-            | "expf32"
-            | "exp2f32"
-            | "logf32"
-            | "log10f32"
-            | "log2f32"
-            => {
+            _ if let Some((float_ty, host_float_op)) = is_host_unary_float_op(intrinsic_name) => {
+                use rustc_apfloat::ieee::{IeeeFloat, Semantics};
+
+                fn eval_host_float_operation<'tcx, S: Semantics>(
+                    this: &mut MiriInterpCx<'tcx>,
+                    f: IeeeFloat<S>,
+                    intrinsic_name: &str,
+                    host_float_op: HostFloatUnaryOp,
+                    dest: &MPlaceTy<'tcx>,
+                ) -> InterpResult<'tcx, ()>
+                where
+                    IeeeFloat<S>: HostFloatOperation + IeeeExt + Float,
+                    IeeeFloat<S>: Into<rustc_const_eval::interpret::Scalar<machine::Provenance>>,
+                {
+                    use HostFloatOperation;
+
+                    let res =
+                        math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+                            // Using host floats (but it's fine, these operations do not have
+                            // guaranteed precision).
+                            let res = match host_float_op {
+                                HostFloatUnaryOp::Sin => HostFloatOperation::host_sin(f),
+                                HostFloatUnaryOp::Cos => HostFloatOperation::host_cos(f),
+                                HostFloatUnaryOp::Exp => HostFloatOperation::host_exp(f),
+                                HostFloatUnaryOp::Exp2 => HostFloatOperation::host_exp2(f),
+                                HostFloatUnaryOp::Log => HostFloatOperation::host_log(f),
+                                HostFloatUnaryOp::Log10 => HostFloatOperation::host_log10(f),
+                                HostFloatUnaryOp::Log2 => HostFloatOperation::host_log2(f),
+                            };
+
+                            // Apply a relative error of 4ULP to introduce some non-determinism
+                            // simulating imprecise implementations and optimizations.
+                            let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                            // Clamp the result to the guaranteed range of this function according to the C standard,
+                            // if any.
+                            math::clamp_float_value(intrinsic_name, res)
+                        });
+
+                    let res = this.adjust_nan(res, &[f]);
+                    this.write_scalar(res, dest)
+                }
+
                 let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-
-                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let host = f.to_host();
-                    let res = match intrinsic_name {
-                        "sinf32" => host.sin(),
-                        "cosf32" => host.cos(),
-                        "expf32" => host.exp(),
-                        "exp2f32" => host.exp2(),
-                        "logf32" => host.ln(),
-                        "log10f32" => host.log10(),
-                        "log2f32" => host.log2(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(
-                        this,
-                        res,
-                        4,
-                    );
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(intrinsic_name, res)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
+                match float_ty {
+                    FloatTy::F16 => {
+                        let f = this.read_scalar(f)?.to_f16()?;
+                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
+                    }
+                    FloatTy::F32 => {
+                        let f = this.read_scalar(f)?.to_f32()?;
+                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
+                    }
+                    FloatTy::F64 => {
+                        let f = this.read_scalar(f)?.to_f64()?;
+                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
+                    }
+                    FloatTy::F128 => todo!("f128"), // FIXME(f128)
+                };
             }
 
-            #[rustfmt::skip]
-            | "sinf64"
-            | "cosf64"
-            | "expf64"
-            | "exp2f64"
-            | "logf64"
-            | "log10f64"
-            | "log2f64"
-            => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
+            "powf16" => {
+                let [f1, f2] = check_intrinsic_arg_count(args)?;
+                let f1 = this.read_scalar(f1)?.to_f16()?;
+                let f2 = this.read_scalar(f2)?.to_f16()?;
 
-                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let host = f.to_host();
-                    let res = match intrinsic_name {
-                        "sinf64" => host.sin(),
-                        "cosf64" => host.cos(),
-                        "expf64" => host.exp(),
-                        "exp2f64" => host.exp2(),
-                        "logf64" => host.ln(),
-                        "log10f64" => host.log10(),
-                        "log2f64" => host.log2(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
+                let res =
+                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                        let res = f1.to_host().powf(f2.to_host()).to_soft();
 
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(
-                        this,
-                        res,
-                        4,
-                    );
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(intrinsic_name, res)
-                });
-                let res = this.adjust_nan(res, &[f]);
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        math::apply_random_float_error_ulp(this, res, 4)
+                    });
+                let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
-
             "powf32" => {
                 let [f1, f2] = check_intrinsic_arg_count(args)?;
                 let f1 = this.read_scalar(f1)?.to_f32()?;
@@ -231,6 +258,22 @@ fn emulate_math_intrinsic(
                 this.write_scalar(res, dest)?;
             }
 
+            "powif16" => {
+                let [f, i] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f16()?;
+                let i = this.read_scalar(i)?.to_i32()?;
+
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                    let res = f.to_host().powi(i).to_soft();
+
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    math::apply_random_float_error_ulp(this, res, 4)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
             "powif32" => {
                 let [f, i] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 2b176093cb36..652a734e0afc 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -42,7 +42,22 @@ fn emulate_simd_intrinsic(
                     // Using host floats except for sqrt (but it's fine, these operations do not
                     // have guaranteed precision).
                     let val = match float_ty {
-                        FloatTy::F16 => unimplemented!("f16_f128"),
+                        FloatTy::F16 => {
+                            let f = op.to_scalar().to_f16()?;
+                            let res = match intrinsic_name {
+                                "fsqrt" => math::sqrt(f),
+                                "fsin" => f.to_host().sin().to_soft(),
+                                "fcos" => f.to_host().cos().to_soft(),
+                                "fexp" => f.to_host().exp().to_soft(),
+                                "fexp2" => f.to_host().exp2().to_soft(),
+                                "flog" => f.to_host().ln().to_soft(),
+                                "flog2" => f.to_host().log2().to_soft(),
+                                "flog10" => f.to_host().log10().to_soft(),
+                                _ => bug!(),
+                            };
+                            let res = this.adjust_nan(res, &[f]);
+                            Scalar::from(res)
+                        }
                         FloatTy::F32 => {
                             let f = op.to_scalar().to_f32()?;
                             let res = match intrinsic_name {
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index e0e908d671b6..2f6c80772635 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -9,6 +9,7 @@
     feature(abort_unwind)
 )]
 #![feature(rustc_private)]
+#![feature(f16)]
 #![feature(float_gamma)]
 #![feature(float_erf)]
 #![feature(map_try_insert)]
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index f9ff4c84c129..3bd1459a9354 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -1,11 +1,11 @@
 use std::ops::Neg;
-use std::{f32, f64};
 
 use rand::Rng as _;
 use rustc_apfloat::Float;
-use rustc_apfloat::ieee::{DoubleS, IeeeFloat, Semantics, SingleS};
+use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, Semantics, SingleS};
 use rustc_middle::ty::{self, FloatTy, ScalarInt};
 
+use self::helpers::{ToHost, ToSoft};
 use crate::*;
 
 /// Disturbes a floating-point result by a relative error in the range (-2^scale, 2^scale).
@@ -108,6 +108,21 @@ pub(crate) fn apply_random_float_error_to_imm<'tcx>(
     interp_ok(ImmTy::from_scalar_int(res, val.layout))
 }
 
+/// Remove `f16`/`f32`/`f64`/`f128` suffix, if any.
+///
+/// Also strip trailing `f` (indicates "float"), with an exception for "erf" to avoid
+/// removing that `f`.
+fn strip_float_suffix(intrinsic_name: &str) -> &str {
+    let name = intrinsic_name
+        .strip_suffix("f16")
+        .or_else(|| intrinsic_name.strip_suffix("f32"))
+        .or_else(|| intrinsic_name.strip_suffix("f64"))
+        .or_else(|| intrinsic_name.strip_suffix("f128"))
+        .unwrap_or(intrinsic_name);
+
+    if name == "erf" { name } else { name.strip_suffix("f").unwrap_or(name) }
+}
+
 /// Given a floating-point operation and a floating-point value, clamps the result to the output
 /// range of the given operation according to the C standard, if any.
 pub(crate) fn clamp_float_value<S: Semantics>(
@@ -123,40 +138,33 @@ pub(crate) fn clamp_float_value<S: Semantics>(
     let pi = IeeeFloat::<S>::pi();
     let pi_over_2 = (pi / two).value;
 
-    match intrinsic_name {
+    match strip_float_suffix(intrinsic_name) {
         // sin, cos, tanh: [-1, 1]
-        #[rustfmt::skip]
-        | "sinf32"
-        | "sinf64"
-        | "cosf32"
-        | "cosf64"
-        | "tanhf"
-        | "tanh"
-         => val.clamp(one.neg(), one),
+        "sin" | "cos" | "tanh" => val.clamp(one.neg(), one),
 
         // exp: [0, +INF)
-        "expf32" | "exp2f32" | "expf64" | "exp2f64" => val.maximum(zero),
+        "exp" | "exp2" => val.maximum(zero),
 
         // cosh: [1, +INF)
-        "coshf" | "cosh" => val.maximum(one),
+        "cosh" => val.maximum(one),
 
         // acos: [0, π]
-        "acosf" | "acos" => val.clamp(zero, pi),
+        "acos" => val.clamp(zero, pi),
 
         // asin: [-π, +π]
-        "asinf" | "asin" => val.clamp(pi.neg(), pi),
+        "asin" => val.clamp(pi.neg(), pi),
 
         // atan: (-π/2, +π/2)
-        "atanf" | "atan" => val.clamp(pi_over_2.neg(), pi_over_2),
+        "atan" => val.clamp(pi_over_2.neg(), pi_over_2),
 
         // erfc: (-1, 1)
-        "erff" | "erf" => val.clamp(one.neg(), one),
+        "erf" => val.clamp(one.neg(), one),
 
         // erfc: (0, 2)
-        "erfcf" | "erfc" => val.clamp(zero, two),
+        "erfc" => val.clamp(zero, two),
 
         // atan2(y, x): arctan(y/x) in [−π, +π]
-        "atan2f" | "atan2" => val.clamp(pi.neg(), pi),
+        "atan2" => val.clamp(pi.neg(), pi),
 
         _ => val,
     }
@@ -210,15 +218,7 @@ pub(crate) fn fixed_float_value<S: Semantics>(
     let pi_over_2 = (pi / two).value;
     let pi_over_4 = (pi_over_2 / two).value;
 
-    // Remove `f32`/`f64` suffix, if any.
-    let name = intrinsic_name
-        .strip_suffix("f32")
-        .or_else(|| intrinsic_name.strip_suffix("f64"))
-        .unwrap_or(intrinsic_name);
-    // Also strip trailing `f` (indicates "float"), with an exception for "erf" to avoid
-    // removing that `f`.
-    let name = if name == "erf" { name } else { name.strip_suffix("f").unwrap_or(name) };
-    Some(match (name, args) {
+    Some(match (strip_float_suffix(intrinsic_name), args) {
         // cos(±0) and cosh(±0)= 1
         ("cos" | "cosh", [input]) if input.is_zero() => one,
 
@@ -400,6 +400,57 @@ pub(crate) fn sqrt<F: Float>(x: F) -> F {
     }
 }
 
+pub trait HostFloatOperation {
+    fn host_sin(x: Self) -> Self;
+    fn host_cos(x: Self) -> Self;
+    fn host_exp(x: Self) -> Self;
+    fn host_exp2(x: Self) -> Self;
+    fn host_log(x: Self) -> Self;
+    fn host_log10(x: Self) -> Self;
+    fn host_log2(x: Self) -> Self;
+    // fn host_powf(x: Self, y: Self) -> Self;
+    // fn host_powi(x: Self, y: i32) -> Self;
+}
+
+macro_rules! impl_float_host_operations {
+    ($ty:ty) => {
+        impl HostFloatOperation for $ty {
+            fn host_sin(x: Self) -> Self {
+                x.to_host().sin().to_soft()
+            }
+            fn host_cos(x: Self) -> Self {
+                x.to_host().cos().to_soft()
+            }
+            fn host_exp(x: Self) -> Self {
+                x.to_host().exp().to_soft()
+            }
+            fn host_exp2(x: Self) -> Self {
+                x.to_host().exp2().to_soft()
+            }
+            fn host_log(x: Self) -> Self {
+                x.to_host().ln().to_soft()
+            }
+            fn host_log10(x: Self) -> Self {
+                x.to_host().log10().to_soft()
+            }
+            fn host_log2(x: Self) -> Self {
+                x.to_host().log2().to_soft()
+            }
+
+            // fn host_powf(x: Self, y: Self) -> Self {
+            //     x.to_host().powf(y.to_host()).to_soft()
+            // }
+            // fn host_powi(x: Self, y: i32) -> Self {
+            //     x.to_host().powi(y).to_soft()
+            // }
+        }
+    };
+}
+
+impl_float_host_operations!(IeeeFloat<HalfS>);
+impl_float_host_operations!(IeeeFloat<SingleS>);
+impl_float_host_operations!(IeeeFloat<DoubleS>);
+
 /// Extend functionality of `rustc_apfloat` softfloats for IEEE float types.
 pub trait IeeeExt: rustc_apfloat::Float {
     // Some values we use:
@@ -433,12 +484,13 @@ impl IeeeExt for IeeeFloat<$semantic> {
             #[inline]
             fn pi() -> Self {
                 // We take the value from the standard library as the most reasonable source for an exact π here.
-                Self::from_bits($float_ty::consts::PI.to_bits().into())
+                Self::from_bits(core::$float_ty::consts::PI.to_bits().into())
             }
         }
     };
 }
 
+impl_ieee_pi!(f16, HalfS);
 impl_ieee_pi!(f32, SingleS);
 impl_ieee_pi!(f64, DoubleS);
 
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 052c83d1aa31..7384c2cb0074 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -14,7 +14,7 @@
 use std::cmp::min;
 use std::fmt::{Debug, Display, LowerHex};
 use std::hint::black_box;
-use std::{f32, f64};
+use std::{f16, f32, f64, f128};
 
 use utils::check_nondet;
 
@@ -1014,14 +1014,20 @@ fn rounding() {
 }
 
 fn mul_add() {
-    // FIXME(f16_f128): add when supported
-
+    assert_eq!(3.0f16.mul_add(2.0f16, 5.0f16), 11.0);
     assert_eq!(3.0f32.mul_add(2.0f32, 5.0f32), 11.0);
-    assert_eq!(0.0f32.mul_add(-2.0, f32::consts::E), f32::consts::E);
-    assert_eq!(3.0f64.mul_add(2.0, 5.0), 11.0);
+    assert_eq!(3.0f64.mul_add(2.0f64, 5.0f64), 11.0);
+    assert_eq!(3.0f128.mul_add(2.0f128, 5.0f128), 11.0);
+
+    assert_eq!(0.0f16.mul_add(-2.0f16, f16::consts::E), f16::consts::E);
+    assert_eq!(0.0f32.mul_add(-2.0f32, f32::consts::E), f32::consts::E);
     assert_eq!(0.0f64.mul_add(-2.0f64, f64::consts::E), f64::consts::E);
+    assert_eq!(0.0f128.mul_add(-2.0f128, f128::consts::E), f128::consts::E);
+
+    assert_eq!((-3.2f16).mul_add(2.4, f16::NEG_INFINITY), f16::NEG_INFINITY);
     assert_eq!((-3.2f32).mul_add(2.4, f32::NEG_INFINITY), f32::NEG_INFINITY);
     assert_eq!((-3.2f64).mul_add(2.4, f64::NEG_INFINITY), f64::NEG_INFINITY);
+    assert_eq!((-3.2f128).mul_add(2.4, f128::NEG_INFINITY), f128::NEG_INFINITY);
 
     let f = f32::mul_add(
         -0.000000000000000000000000000000000000014728589,
@@ -1039,9 +1045,11 @@ fn ldexp(a: f64, b: i32) -> f64 {
         unsafe { ldexp(a, b) }
     }
 
+    assert_approx_eq!(25f16.powi(-2), 0.0016f16);
     assert_approx_eq!(25f32.powi(-2), 0.0016f32);
     assert_approx_eq!(23.2f64.powi(2), 538.24f64);
 
+    assert_approx_eq!(25f16.powf(-2f16), 0.0016f16);
     assert_approx_eq!(25f32.powf(-2f32), 0.0016f32);
     assert_approx_eq!(400f64.powf(0.5f64), 20f64);
 
@@ -1049,81 +1057,111 @@ fn ldexp(a: f64, b: i32) -> f64 {
     // and thus must be exactly equal to that value.
     // C standard says:
     // 1^y = 1 for any y, even a NaN.
+    assert_eq!(1f16.powf(10.0), 1.0);
     assert_eq!(1f32.powf(10.0), 1.0);
     assert_eq!(1f64.powf(100.0), 1.0);
+    assert_eq!(1f16.powf(f16::INFINITY), 1.0);
     assert_eq!(1f32.powf(f32::INFINITY), 1.0);
     assert_eq!(1f64.powf(f64::INFINITY), 1.0);
+    assert_eq!(1f16.powf(f16::NAN), 1.0);
     assert_eq!(1f32.powf(f32::NAN), 1.0);
     assert_eq!(1f64.powf(f64::NAN), 1.0);
 
     // f*::NAN is a quiet NAN and should return 1 as well.
+    assert_eq!(f16::NAN.powf(0.0), 1.0);
     assert_eq!(f32::NAN.powf(0.0), 1.0);
     assert_eq!(f64::NAN.powf(0.0), 1.0);
 
+    assert_eq!(42f16.powf(0.0), 1.0);
     assert_eq!(42f32.powf(0.0), 1.0);
     assert_eq!(42f64.powf(0.0), 1.0);
+    assert_eq!(f16::INFINITY.powf(0.0), 1.0);
     assert_eq!(f32::INFINITY.powf(0.0), 1.0);
     assert_eq!(f64::INFINITY.powf(0.0), 1.0);
+    assert_eq!(f16::NEG_INFINITY.powi(3), f16::NEG_INFINITY);
     assert_eq!(f32::NEG_INFINITY.powi(3), f32::NEG_INFINITY);
     assert_eq!(f32::NEG_INFINITY.powi(2), f32::INFINITY);
+    assert_eq!(f16::INFINITY.powi(3), f16::INFINITY);
     assert_eq!(f64::INFINITY.powi(3), f64::INFINITY);
     assert_eq!(f64::INFINITY.powi(2), f64::INFINITY);
 
     // f*::NAN is a quiet NAN and should return 1 as well.
+    assert_eq!(f16::NAN.powi(0), 1.0);
     assert_eq!(f32::NAN.powi(0), 1.0);
     assert_eq!(f64::NAN.powi(0), 1.0);
 
+    assert_eq!(10.0f16.powi(0), 1.0);
     assert_eq!(10.0f32.powi(0), 1.0);
     assert_eq!(10.0f64.powi(0), 1.0);
+    assert_eq!(f16::INFINITY.powi(0), 1.0);
     assert_eq!(f32::INFINITY.powi(0), 1.0);
     assert_eq!(f64::INFINITY.powi(0), 1.0);
 
+    assert_eq!((-1f16).powf(f16::INFINITY), 1.0);
     assert_eq!((-1f32).powf(f32::INFINITY), 1.0);
     assert_eq!((-1f64).powf(f64::INFINITY), 1.0);
+    assert_eq!((-1f16).powf(f16::NEG_INFINITY), 1.0);
     assert_eq!((-1f32).powf(f32::NEG_INFINITY), 1.0);
     assert_eq!((-1f64).powf(f64::NEG_INFINITY), 1.0);
 
+    assert_eq!(0f16.powi(10), 0.0);
     assert_eq!(0f32.powi(10), 0.0);
     assert_eq!(0f64.powi(100), 0.0);
+    assert_eq!(0f16.powi(9), 0.0);
     assert_eq!(0f32.powi(9), 0.0);
     assert_eq!(0f64.powi(99), 0.0);
 
+    assert_biteq((-0f16).powf(10.0), 0.0, "-0^x = +0 where x is positive");
     assert_biteq((-0f32).powf(10.0), 0.0, "-0^x = +0 where x is positive");
     assert_biteq((-0f64).powf(100.0), 0.0, "-0^x = +0 where x is positive");
+    assert_biteq((-0f16).powf(9.0), -0.0, "-0^x = -0 where x is negative");
     assert_biteq((-0f32).powf(9.0), -0.0, "-0^x = -0 where x is negative");
     assert_biteq((-0f64).powf(99.0), -0.0, "-0^x = -0 where x is negative");
 
+    assert_biteq((-0f16).powi(10), 0.0, "-0^x = +0 where x is positive");
     assert_biteq((-0f32).powi(10), 0.0, "-0^x = +0 where x is positive");
     assert_biteq((-0f64).powi(100), 0.0, "-0^x = +0 where x is positive");
+    assert_biteq((-0f16).powi(9), -0.0, "-0^x = -0 where x is negative");
     assert_biteq((-0f32).powi(9), -0.0, "-0^x = -0 where x is negative");
     assert_biteq((-0f64).powi(99), -0.0, "-0^x = -0 where x is negative");
 
+    assert_approx_eq!(1f16.exp(), f16::consts::E);
     assert_approx_eq!(1f32.exp(), f32::consts::E);
     assert_approx_eq!(1f64.exp(), f64::consts::E);
+    assert_eq!(0f16.exp(), 1.0);
     assert_eq!(0f32.exp(), 1.0);
     assert_eq!(0f64.exp(), 1.0);
 
+    assert_approx_eq!(1f16.exp_m1(), f16::consts::E - 1.0);
     assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
     assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
+    assert_approx_eq!(f16::NEG_INFINITY.exp_m1(), -1.0);
     assert_approx_eq!(f32::NEG_INFINITY.exp_m1(), -1.0);
     assert_approx_eq!(f64::NEG_INFINITY.exp_m1(), -1.0);
 
+    assert_approx_eq!(10f16.exp2(), 1024f16);
     assert_approx_eq!(10f32.exp2(), 1024f32);
     assert_approx_eq!(50f64.exp2(), 1125899906842624f64);
+    assert_eq!(0f16.exp2(), 1.0);
     assert_eq!(0f32.exp2(), 1.0);
     assert_eq!(0f64.exp2(), 1.0);
 
+    assert_approx_eq!(f16::consts::E.ln(), 1f16);
     assert_approx_eq!(f32::consts::E.ln(), 1f32);
     assert_approx_eq!(f64::consts::E.ln(), 1f64);
+    assert_eq!(1f16.ln(), 0.0);
     assert_eq!(1f32.ln(), 0.0);
     assert_eq!(1f64.ln(), 0.0);
 
+    assert_approx_eq!(0f16.ln_1p(), 0f16);
     assert_approx_eq!(0f32.ln_1p(), 0f32);
     assert_approx_eq!(0f64.ln_1p(), 0f64);
 
+    assert_approx_eq!(10f16.log10(), 1f16);
     assert_approx_eq!(10f32.log10(), 1f32);
     assert_approx_eq!(f64::consts::E.log10(), f64::consts::LOG10_E);
 
+    assert_approx_eq!(8f16.log2(), 3f16);
     assert_approx_eq!(8f32.log2(), 3f32);
     assert_approx_eq!(f64::consts::E.log2(), f64::consts::LOG2_E);
 
@@ -1133,9 +1171,11 @@ fn ldexp(a: f64, b: i32) -> f64 {
         assert_approx_eq!(3.0f64.abs_sub(5.0), 0.0);
     }
 
+    assert_approx_eq!(27.0f16.cbrt(), 3.0f16);
     assert_approx_eq!(27.0f32.cbrt(), 3.0f32);
     assert_approx_eq!(27.0f64.cbrt(), 3.0f64);
 
+    assert_approx_eq!(3.0f16.hypot(4.0f16), 5.0f16);
     assert_approx_eq!(3.0f32.hypot(4.0f32), 5.0f32);
     assert_approx_eq!(3.0f64.hypot(4.0f64), 5.0f64);
 
@@ -1146,70 +1186,94 @@ fn ldexp(a: f64, b: i32) -> f64 {
 
     // Trigonometric functions.
 
+    assert_eq!(0f16.sin(), 0f16);
     assert_eq!(0f32.sin(), 0f32);
     assert_eq!(0f64.sin(), 0f64);
-    assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
+    assert_approx_eq!(f16::consts::FRAC_PI_6.sin(), 0.5);
     assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
     // Increase error tolerance to 16ULP because of the extra operation.
+    assert_approx_eq!(f16::consts::FRAC_PI_4.sin().asin(), f16::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
+    assert_biteq(0.0f16.asin(), 0.0f16, "asin(+0) = +0");
+    assert_biteq((-0.0f16).asin(), -0.0, "asin(-0) = -0");
     assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
     assert_biteq((-0.0f32).asin(), -0.0, "asin(-0) = -0");
     assert_biteq(0.0f64.asin(), 0.0, "asin(+0) = +0");
     assert_biteq((-0.0f64).asin(), -0.0, "asin(-0) = -0");
 
+    assert_approx_eq!(1.0f16.sinh(), 1.1752012f16);
     assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
     assert_approx_eq!(1.0f64.sinh(), 1.1752011936438014f64);
+    assert_approx_eq!(2.0f16.asinh(), 1.443635475178810342493276740273105f16);
     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 
     // Ensure `sin` always returns something that is a valid input for `asin`, and same for
     // `cos` and `acos`.
+    let halve_pi_f16 = std::f16::consts::FRAC_PI_2;
     let halve_pi_f32 = std::f32::consts::FRAC_PI_2;
     let halve_pi_f64 = std::f64::consts::FRAC_PI_2;
+    let pi_f16 = std::f16::consts::PI;
     let pi_f32 = std::f32::consts::PI;
     let pi_f64 = std::f64::consts::PI;
     for _ in 0..64 {
         // sin() should be clamped to [-1, 1] so asin() can never return NaN
+        assert!(!halve_pi_f16.sin().asin().is_nan());
         assert!(!halve_pi_f32.sin().asin().is_nan());
         assert!(!halve_pi_f64.sin().asin().is_nan());
         // cos() should be clamped to [-1, 1] so acos() can never return NaN
+        assert!(!pi_f16.cos().acos().is_nan());
         assert!(!pi_f32.cos().acos().is_nan());
         assert!(!pi_f64.cos().acos().is_nan());
     }
 
+    assert_eq!(0f16.cos(), 1f16);
     assert_eq!(0f32.cos(), 1f32);
     assert_eq!(0f64.cos(), 1f64);
-    assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
+    assert_approx_eq!(f16::consts::FRAC_PI_3.cos(), 0.5);
     assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
     // Increase error tolerance to 16ULP because of the extra operation.
+    assert_approx_eq!(f16::consts::FRAC_PI_4.cos().acos(), f16::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
+    assert_biteq(1.0f16.acos(), 0.0, "acos(1) = 0");
     assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
     assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
 
+    assert_approx_eq!(1.0f16.cosh(), 1.5430806f16);
     assert_approx_eq!(1.0f32.cosh(), 1.5430806f32);
     assert_approx_eq!(1.0f64.cosh(), 1.5430806348152437f64);
+    assert_eq!(0.0f16.cosh(), 1.0);
     assert_eq!(0.0f32.cosh(), 1.0);
     assert_eq!(0.0f64.cosh(), 1.0);
+    assert_eq!((-0.0f16).cosh(), 1.0);
     assert_eq!((-0.0f32).cosh(), 1.0);
     assert_eq!((-0.0f64).cosh(), 1.0);
+    assert_approx_eq!(2.0f16.acosh(), 1.31695789692481670862504634730796844f16);
     assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 
+    assert_approx_eq!(1.0f16.tan(), 1.557408f16);
     assert_approx_eq!(1.0f32.tan(), 1.557408f32);
     assert_approx_eq!(1.0f64.tan(), 1.5574077246549023f64);
+    assert_approx_eq!(1.0_f16, 1.0_f16.tan().atan());
     assert_approx_eq!(1.0_f32, 1.0_f32.tan().atan());
     assert_approx_eq!(1.0_f64, 1.0_f64.tan().atan());
+    assert_approx_eq!(1.0f16.atan2(2.0f16), 0.46364761f16);
     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
     // C standard defines a bunch of fixed outputs for atan2
     macro_rules! fixed_atan2_cases{
         ($float_type:ident) => {{
             use std::$float_type::consts::{PI, FRAC_PI_2, FRAC_PI_4};
-            use $float_type::{INFINITY, NEG_INFINITY};
+
+            // The core::$float_type::INFINITY constant is deprecated, and not available for f16.
+            // Associated items cannot be brought into scope with a `use`, hence the `const`s.
+            const INFINITY: $float_type = <$float_type>::INFINITY;
+            const NEG_INFINITY: $float_type = <$float_type>::NEG_INFINITY;
 
             // atan2(±0,−0) = ±π.
             assert_eq!($float_type::atan2(0.0, -0.0), PI, "atan2(0,−0) = π");
@@ -1244,9 +1308,14 @@ macro_rules! fixed_atan2_cases{
             assert_eq!($float_type::atan2(NEG_INFINITY, INFINITY), -FRAC_PI_4, "atan2(-∞, +∞) = -π/4");
         }}
     }
+    fixed_atan2_cases!(f16);
     fixed_atan2_cases!(f32);
     fixed_atan2_cases!(f64);
 
+    assert_approx_eq!(
+        1.0f16.tanh(),
+        (1.0 - f16::consts::E.powi(-2)) / (1.0 + f16::consts::E.powi(-2))
+    );
     assert_approx_eq!(
         1.0f32.tanh(),
         (1.0 - f32::consts::E.powi(-2)) / (1.0 + f32::consts::E.powi(-2))
@@ -1255,22 +1324,31 @@ macro_rules! fixed_atan2_cases{
         1.0f64.tanh(),
         (1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
     );
+    assert_eq!(f16::INFINITY.tanh(), 1.0);
+    assert_eq!(f16::NEG_INFINITY.tanh(), -1.0);
     assert_eq!(f32::INFINITY.tanh(), 1.0);
     assert_eq!(f32::NEG_INFINITY.tanh(), -1.0);
     assert_eq!(f64::INFINITY.tanh(), 1.0);
     assert_eq!(f64::NEG_INFINITY.tanh(), -1.0);
 
+    assert_approx_eq!(0.5f16.atanh(), 0.54930614433405484569762261846126285f16);
     assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
     assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
 
+    assert_approx_eq!(5.0f16.gamma(), 24.0);
     assert_approx_eq!(5.0f32.gamma(), 24.0);
     assert_approx_eq!(5.0f64.gamma(), 24.0);
+    assert_approx_eq!((-0.5f16).gamma(), (-2.0) * f16::consts::PI.sqrt());
     assert_approx_eq!((-0.5f32).gamma(), (-2.0) * f32::consts::PI.sqrt());
     assert_approx_eq!((-0.5f64).gamma(), (-2.0) * f64::consts::PI.sqrt());
 
+    assert_eq!(2.0f16.ln_gamma(), (0.0, 1));
     assert_eq!(2.0f32.ln_gamma(), (0.0, 1));
     assert_eq!(2.0f64.ln_gamma(), (0.0, 1));
     // Gamma(-0.5) = -2*sqrt(π)
+    let (val, sign) = (-0.5f16).ln_gamma();
+    assert_approx_eq!(val, (2.0 * f16::consts::PI.sqrt()).ln());
+    assert_eq!(sign, -1);
     let (val, sign) = (-0.5f32).ln_gamma();
     assert_approx_eq!(val, (2.0 * f32::consts::PI.sqrt()).ln());
     assert_eq!(sign, -1);
@@ -1278,14 +1356,19 @@ macro_rules! fixed_atan2_cases{
     assert_approx_eq!(val, (2.0 * f64::consts::PI.sqrt()).ln());
     assert_eq!(sign, -1);
 
+    assert_approx_eq!(1.0f16.erf(), 0.84270079294971486934122063508260926f16);
     assert_approx_eq!(1.0f32.erf(), 0.84270079294971486934122063508260926f32);
     assert_approx_eq!(1.0f64.erf(), 0.84270079294971486934122063508260926f64);
+    assert_eq!(f16::INFINITY.erf(), 1.0);
     assert_eq!(f32::INFINITY.erf(), 1.0);
     assert_eq!(f64::INFINITY.erf(), 1.0);
+    assert_approx_eq!(1.0f16.erfc(), 0.15729920705028513065877936491739074f16);
     assert_approx_eq!(1.0f32.erfc(), 0.15729920705028513065877936491739074f32);
     assert_approx_eq!(1.0f64.erfc(), 0.15729920705028513065877936491739074f64);
+    assert_eq!(f16::NEG_INFINITY.erfc(), 2.0);
     assert_eq!(f32::NEG_INFINITY.erfc(), 2.0);
     assert_eq!(f64::NEG_INFINITY.erfc(), 2.0);
+    assert_eq!(f16::INFINITY.erfc(), 0.0);
     assert_eq!(f32::INFINITY.erfc(), 0.0);
     assert_eq!(f64::INFINITY.erfc(), 0.0);
 }
@@ -1407,9 +1490,14 @@ fn test_operations_f128(a: f128, b: f128) {
 }
 
 fn test_fmuladd() {
-    use std::intrinsics::{fmuladdf32, fmuladdf64};
+    use std::intrinsics::{fmuladdf16, fmuladdf32, fmuladdf64};
 
-    // FIXME(f16_f128): add when supported
+    // FIXME(f128): add when supported
+
+    #[inline(never)]
+    fn test_operations_f16(a: f16, b: f16, c: f16) {
+        assert_approx_eq!(fmuladdf16(a, b, c), a * b + c);
+    }
 
     #[inline(never)]
     fn test_operations_f32(a: f32, b: f32, c: f32) {
@@ -1421,6 +1509,7 @@ fn test_operations_f64(a: f64, b: f64, c: f64) {
         assert_approx_eq!(fmuladdf64(a, b, c), a * b + c);
     }
 
+    test_operations_f16(0.1, 0.2, 0.3);
     test_operations_f32(0.1, 0.2, 0.3);
     test_operations_f64(1.1, 1.2, 1.3);
 }
@@ -1464,6 +1553,39 @@ macro_rules! test_operations_f {
 
     fn test_operations_f16(a: f16, b: f16) {
         test_operations_f!(a, b);
+        check_nondet(|| a.powf(b));
+        check_nondet(|| a.powi(2));
+        check_nondet(|| a.log(b));
+        check_nondet(|| a.exp());
+        check_nondet(|| 10f16.exp2());
+        check_nondet(|| f16::consts::E.ln());
+        check_nondet(|| 10f16.log10());
+        check_nondet(|| 8f16.log2());
+        check_nondet(|| 1f16.sin());
+        check_nondet(|| 1f16.cos());
+
+        // these functions are implemented by calling the `f32` version, which means the little
+        // rounding errors Miri introduces are discarded by the cast down to `f16`.
+        // Just skip the test for them.
+        //
+        // check_nondet(|| 1f16.ln_1p());
+        // check_nondet(|| 27.0f16.cbrt());
+        // check_nondet(|| 3.0f16.hypot(4.0f16));
+        // check_nondet(|| 1.0f16.tan());
+        // check_nondet(|| 1.0f16.asin());
+        // check_nondet(|| 5.0f16.acos());
+        // check_nondet(|| 1.0f16.atan());
+        // check_nondet(|| 1.0f16.atan2(2.0f16));
+        // check_nondet(|| 1.0f16.sinh());
+        // check_nondet(|| 1.0f16.cosh());
+        // check_nondet(|| 1.0f16.tanh());
+        // check_nondet(|| 1.0f16.asinh());
+        // check_nondet(|| 2.0f16.acosh());
+        // check_nondet(|| 0.5f16.atanh());
+        // check_nondet(|| 5.0f16.gamma());
+        // check_nondet(|| 5.0f16.ln_gamma());
+        // check_nondet(|| 5.0f16.erf());
+        // check_nondet(|| 5.0f16.erfc());
     }
     fn test_operations_f32(a: f32, b: f32) {
         test_operations_f!(a, b);
@@ -1536,7 +1658,7 @@ fn test_operations_f128(a: f128, b: f128) {
         test_operations_f!(a, b);
     }
 
-    test_operations_f16(5., 7.);
+    test_operations_f16(3., 5.);
     test_operations_f32(12., 5.);
     test_operations_f64(19., 11.);
     test_operations_f128(25., 18.);
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index 6c5e06518f56..554011dd02e8 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -41,6 +41,7 @@ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
 
 type f16x2 = PackedSimd<f16, 2>;
 type f16x4 = PackedSimd<f16, 4>;
+type f16x8 = PackedSimd<f16, 8>;
 
 type f128x2 = PackedSimd<f128, 2>;
 type f128x4 = PackedSimd<f128, 4>;
@@ -934,6 +935,18 @@ fn simd_float_intrinsics() {
     use intrinsics::*;
 
     // These are just smoke tests to ensure the intrinsics can be called.
+    unsafe {
+        let a = f16x8::splat(10.0);
+        simd_fsqrt(a);
+        simd_fsin(a);
+        simd_fcos(a);
+        simd_fexp(a);
+        simd_fexp2(a);
+        simd_flog(a);
+        simd_flog2(a);
+        simd_flog10(a);
+    }
+
     unsafe {
         let a = f32x4::splat(10.0);
         simd_fsqrt(a);
@@ -945,6 +958,18 @@ fn simd_float_intrinsics() {
         simd_flog2(a);
         simd_flog10(a);
     }
+
+    unsafe {
+        let a = f64x2::splat(10.0);
+        simd_fsqrt(a);
+        simd_fsin(a);
+        simd_fcos(a);
+        simd_fexp(a);
+        simd_fexp2(a);
+        simd_flog(a);
+        simd_flog2(a);
+        simd_flog10(a);
+    }
 }
 
 fn simd_masked_loadstore() {

From eee0dc9bb137a4725cc6d397d0b88233e8ad40ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Tue, 3 Mar 2026 11:34:00 +0100
Subject: [PATCH 0457/1059] Rename `cycle_check` to `find_cycle`

---
 compiler/rustc_query_impl/src/job.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 7151d0b52fe2..6a14100a8e3d 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -151,11 +151,11 @@ fn abstracted_waiters_of(job_map: &QueryJobMap<'_>, query: QueryJobId) -> Vec<Ab
     result
 }
 
-/// Look for query cycles by doing a depth first search starting at `query`.
+/// Looks for a query cycle by doing a depth first search starting at `query`.
 /// `span` is the reason for the `query` to execute. This is initially DUMMY_SP.
 /// If a cycle is detected, this initial value is replaced with the span causing
-/// the cycle.
-fn cycle_check<'tcx>(
+/// the cycle. `stack` will contain just the cycle on return if detected.
+fn find_cycle<'tcx>(
     job_map: &QueryJobMap<'tcx>,
     query: QueryJobId,
     span: Span,
@@ -186,7 +186,7 @@ fn cycle_check<'tcx>(
             continue;
         };
         if let ControlFlow::Break(maybe_resumable) =
-            cycle_check(job_map, parent, abstracted_waiter.span, stack, visited)
+            find_cycle(job_map, parent, abstracted_waiter.span, stack, visited)
         {
             // Return the resumable waiter in `waiter.resumable` if present
             return ControlFlow::Break(abstracted_waiter.resumable.or(maybe_resumable));
@@ -228,7 +228,7 @@ fn connected_to_root<'tcx>(
     false
 }
 
-/// Looks for query cycles starting from the last query in `jobs`.
+/// Looks for a query cycle using the last query in `jobs`.
 /// If a cycle is found, all queries in the cycle is removed from `jobs` and
 /// the function return true.
 /// If a cycle was not found, the starting query is removed from `jobs` and
@@ -242,7 +242,7 @@ fn remove_cycle<'tcx>(
     let mut stack = Vec::new();
     // Look for a cycle starting with the last query in `jobs`
     if let ControlFlow::Break(resumable) =
-        cycle_check(job_map, jobs.pop().unwrap(), DUMMY_SP, &mut stack, &mut visited)
+        find_cycle(job_map, jobs.pop().unwrap(), DUMMY_SP, &mut stack, &mut visited)
     {
         // The stack is a vector of pairs of spans and queries; reverse it so that
         // the earlier entries require later entries

From 5f090d0a50acbfc5aa99bbc6b8b7ea1bd83d6d69 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 14 Mar 2026 12:31:30 +0100
Subject: [PATCH 0458/1059] share more code across the different float types

---
 src/tools/miri/src/helpers.rs         |  61 -------
 src/tools/miri/src/intrinsics/math.rs | 252 ++++++++------------------
 src/tools/miri/src/intrinsics/simd.rs | 110 +++++------
 src/tools/miri/src/math.rs            | 195 ++++++++++++++++----
 src/tools/miri/src/shims/math.rs      |   2 +-
 5 files changed, 280 insertions(+), 340 deletions(-)

diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index cbce44ca5875..a40ad4b55317 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -5,7 +5,6 @@
 
 use rand::RngCore;
 use rustc_abi::{Align, ExternAbi, FieldIdx, FieldsShape, Size, Variants};
-use rustc_apfloat::Float;
 use rustc_data_structures::fx::{FxBuildHasher, FxHashSet};
 use rustc_hir::Safety;
 use rustc_hir::def::{DefKind, Namespace};
@@ -165,66 +164,6 @@ pub fn iter_exported_symbols<'tcx>(
     interp_ok(())
 }
 
-/// Convert a softfloat type to its corresponding hostfloat type.
-pub trait ToHost {
-    type HostFloat;
-    fn to_host(self) -> Self::HostFloat;
-}
-
-/// Convert a hostfloat type to its corresponding softfloat type.
-pub trait ToSoft {
-    type SoftFloat;
-    fn to_soft(self) -> Self::SoftFloat;
-}
-
-impl ToHost for rustc_apfloat::ieee::Double {
-    type HostFloat = f64;
-
-    fn to_host(self) -> Self::HostFloat {
-        f64::from_bits(self.to_bits().try_into().unwrap())
-    }
-}
-
-impl ToSoft for f64 {
-    type SoftFloat = rustc_apfloat::ieee::Double;
-
-    fn to_soft(self) -> Self::SoftFloat {
-        Float::from_bits(self.to_bits().into())
-    }
-}
-
-impl ToHost for rustc_apfloat::ieee::Single {
-    type HostFloat = f32;
-
-    fn to_host(self) -> Self::HostFloat {
-        f32::from_bits(self.to_bits().try_into().unwrap())
-    }
-}
-
-impl ToSoft for f32 {
-    type SoftFloat = rustc_apfloat::ieee::Single;
-
-    fn to_soft(self) -> Self::SoftFloat {
-        Float::from_bits(self.to_bits().into())
-    }
-}
-
-impl ToHost for rustc_apfloat::ieee::Half {
-    type HostFloat = f16;
-
-    fn to_host(self) -> Self::HostFloat {
-        f16::from_bits(self.to_bits().try_into().unwrap())
-    }
-}
-
-impl ToSoft for f16 {
-    type SoftFloat = rustc_apfloat::ieee::Half;
-
-    fn to_soft(self) -> Self::SoftFloat {
-        Float::from_bits(self.to_bits().into())
-    }
-}
-
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Checks if the given crate/module exists.
diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index 59c728dc4282..fbd2aff4b50a 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -1,9 +1,9 @@
+use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, Semantics, SingleS};
 use rustc_apfloat::{self, Float, FloatConvert, Round};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, FloatTy};
 
-use self::helpers::{ToHost, ToSoft};
-use self::math::{HostFloatOperation, IeeeExt};
+use self::math::{HostFloatOperation, HostUnaryFloatOp, IeeeExt, host_unary_float_op};
 use super::check_intrinsic_arg_count;
 use crate::*;
 
@@ -13,26 +13,11 @@ fn sqrt<'tcx, F: Float + FloatConvert<F> + Into<Scalar>>(
     dest: &MPlaceTy<'tcx>,
 ) -> InterpResult<'tcx> {
     let [f] = check_intrinsic_arg_count(args)?;
-    let f = this.read_scalar(f)?;
-    let f: F = f.to_float()?;
-    // Sqrt is specified to be fully precise.
-    let res = math::sqrt(f);
-    let res = this.adjust_nan(res, &[f]);
-    this.write_scalar(res, dest)
+    math::sqrt_op::<F>(this, f, dest)
 }
 
-#[derive(Debug, Clone, Copy)]
-enum HostFloatUnaryOp {
-    Sin,
-    Cos,
-    Exp,
-    Exp2,
-    Log,
-    Log10,
-    Log2,
-}
-
-fn is_host_unary_float_op(intrinsic_name: &str) -> Option<(FloatTy, HostFloatUnaryOp)> {
+/// Determine which float operation on which type this is.
+fn is_host_unary_float_op(intrinsic_name: &str) -> Option<(FloatTy, HostUnaryFloatOp)> {
     let (op, ty) = intrinsic_name.rsplit_once('f')?;
 
     let float_ty = match ty {
@@ -44,19 +29,68 @@ fn is_host_unary_float_op(intrinsic_name: &str) -> Option<(FloatTy, HostFloatUna
     };
 
     let host_float_op = match op {
-        "sin" => HostFloatUnaryOp::Sin,
-        "cos" => HostFloatUnaryOp::Cos,
-        "exp" => HostFloatUnaryOp::Exp,
-        "exp2" => HostFloatUnaryOp::Exp2,
-        "log" => HostFloatUnaryOp::Log,
-        "log10" => HostFloatUnaryOp::Log10,
-        "log2" => HostFloatUnaryOp::Log2,
+        "sin" => HostUnaryFloatOp::Sin,
+        "cos" => HostUnaryFloatOp::Cos,
+        "exp" => HostUnaryFloatOp::Exp,
+        "exp2" => HostUnaryFloatOp::Exp2,
+        "log" => HostUnaryFloatOp::Log,
+        "log10" => HostUnaryFloatOp::Log10,
+        "log2" => HostUnaryFloatOp::Log2,
         _ => return None,
     };
 
     Some((float_ty, host_float_op))
 }
 
+fn pow_intrinsic<'tcx, S: Semantics>(
+    this: &mut MiriInterpCx<'tcx>,
+    args: &[OpTy<'tcx>],
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx, ()>
+where
+    IeeeFloat<S>: HostFloatOperation + IeeeExt + Float + Into<Scalar>,
+{
+    let [f1, f2] = check_intrinsic_arg_count(args)?;
+    let f1: IeeeFloat<S> = this.read_scalar(f1)?.to_float()?;
+    let f2: IeeeFloat<S> = this.read_scalar(f2)?.to_float()?;
+
+    let res = math::fixed_float_value(this, "pow", &[f1, f2]).unwrap_or_else(|| {
+        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+        let res = f1.host_powf(f2);
+
+        // Apply a relative error of 4ULP to introduce some non-determinism
+        // simulating imprecise implementations and optimizations.
+        math::apply_random_float_error_ulp(this, res, 4)
+    });
+    let res = this.adjust_nan(res, &[f1, f2]);
+    this.write_scalar(res, dest)?;
+    interp_ok(())
+}
+fn powi_intrinsic<'tcx, S: Semantics>(
+    this: &mut MiriInterpCx<'tcx>,
+    args: &[OpTy<'tcx>],
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx, ()>
+where
+    IeeeFloat<S>: HostFloatOperation + IeeeExt + Float + Into<Scalar>,
+{
+    let [f, i] = check_intrinsic_arg_count(args)?;
+    let f: IeeeFloat<S> = this.read_scalar(f)?.to_float()?;
+    let i = this.read_scalar(i)?.to_i32()?;
+
+    let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+        let res = f.host_powi(i);
+
+        // Apply a relative error of 4ULP to introduce some non-determinism
+        // simulating imprecise implementations and optimizations.
+        math::apply_random_float_error_ulp(this, res, 4)
+    });
+    let res = this.adjust_nan(res, &[f]);
+    this.write_scalar(res, dest)?;
+    interp_ok(())
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn emulate_math_intrinsic(
@@ -145,167 +179,23 @@ fn emulate_math_intrinsic(
             }
 
             // Operations that need host floats.
-            _ if let Some((float_ty, host_float_op)) = is_host_unary_float_op(intrinsic_name) => {
-                use rustc_apfloat::ieee::{IeeeFloat, Semantics};
-
-                fn eval_host_float_operation<'tcx, S: Semantics>(
-                    this: &mut MiriInterpCx<'tcx>,
-                    f: IeeeFloat<S>,
-                    intrinsic_name: &str,
-                    host_float_op: HostFloatUnaryOp,
-                    dest: &MPlaceTy<'tcx>,
-                ) -> InterpResult<'tcx, ()>
-                where
-                    IeeeFloat<S>: HostFloatOperation + IeeeExt + Float,
-                    IeeeFloat<S>: Into<rustc_const_eval::interpret::Scalar<machine::Provenance>>,
-                {
-                    use HostFloatOperation;
-
-                    let res =
-                        math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
-                            // Using host floats (but it's fine, these operations do not have
-                            // guaranteed precision).
-                            let res = match host_float_op {
-                                HostFloatUnaryOp::Sin => HostFloatOperation::host_sin(f),
-                                HostFloatUnaryOp::Cos => HostFloatOperation::host_cos(f),
-                                HostFloatUnaryOp::Exp => HostFloatOperation::host_exp(f),
-                                HostFloatUnaryOp::Exp2 => HostFloatOperation::host_exp2(f),
-                                HostFloatUnaryOp::Log => HostFloatOperation::host_log(f),
-                                HostFloatUnaryOp::Log10 => HostFloatOperation::host_log10(f),
-                                HostFloatUnaryOp::Log2 => HostFloatOperation::host_log2(f),
-                            };
-
-                            // Apply a relative error of 4ULP to introduce some non-determinism
-                            // simulating imprecise implementations and optimizations.
-                            let res = math::apply_random_float_error_ulp(this, res, 4);
-
-                            // Clamp the result to the guaranteed range of this function according to the C standard,
-                            // if any.
-                            math::clamp_float_value(intrinsic_name, res)
-                        });
-
-                    let res = this.adjust_nan(res, &[f]);
-                    this.write_scalar(res, dest)
-                }
-
+            _ if let Some((float_ty, op)) = is_host_unary_float_op(intrinsic_name) => {
                 let [f] = check_intrinsic_arg_count(args)?;
                 match float_ty {
-                    FloatTy::F16 => {
-                        let f = this.read_scalar(f)?.to_f16()?;
-                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
-                    }
-                    FloatTy::F32 => {
-                        let f = this.read_scalar(f)?.to_f32()?;
-                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
-                    }
-                    FloatTy::F64 => {
-                        let f = this.read_scalar(f)?.to_f64()?;
-                        eval_host_float_operation(this, f, intrinsic_name, host_float_op, dest)?;
-                    }
+                    FloatTy::F16 => host_unary_float_op::<HalfS>(this, f, op, dest)?,
+                    FloatTy::F32 => host_unary_float_op::<SingleS>(this, f, op, dest)?,
+                    FloatTy::F64 => host_unary_float_op::<DoubleS>(this, f, op, dest)?,
                     FloatTy::F128 => todo!("f128"), // FIXME(f128)
                 };
             }
 
-            "powf16" => {
-                let [f1, f2] = check_intrinsic_arg_count(args)?;
-                let f1 = this.read_scalar(f1)?.to_f16()?;
-                let f2 = this.read_scalar(f2)?.to_f16()?;
+            "powf16" => pow_intrinsic::<HalfS>(this, args, dest)?,
+            "powf32" => pow_intrinsic::<SingleS>(this, args, dest)?,
+            "powf64" => pow_intrinsic::<DoubleS>(this, args, dest)?,
 
-                let res =
-                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f1.to_host().powf(f2.to_host()).to_soft();
-
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(this, res, 4)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-            "powf32" => {
-                let [f1, f2] = check_intrinsic_arg_count(args)?;
-                let f1 = this.read_scalar(f1)?.to_f32()?;
-                let f2 = this.read_scalar(f2)?.to_f32()?;
-
-                let res =
-                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f1.to_host().powf(f2.to_host()).to_soft();
-
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(this, res, 4)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-            "powf64" => {
-                let [f1, f2] = check_intrinsic_arg_count(args)?;
-                let f1 = this.read_scalar(f1)?.to_f64()?;
-                let f2 = this.read_scalar(f2)?.to_f64()?;
-
-                let res =
-                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f1.to_host().powf(f2.to_host()).to_soft();
-
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(this, res, 4)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "powif16" => {
-                let [f, i] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f16()?;
-                let i = this.read_scalar(i)?.to_i32()?;
-
-                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f.to_host().powi(i).to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    math::apply_random_float_error_ulp(this, res, 4)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "powif32" => {
-                let [f, i] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-                let i = this.read_scalar(i)?.to_i32()?;
-
-                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f.to_host().powi(i).to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    math::apply_random_float_error_ulp(this, res, 4)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "powif64" => {
-                let [f, i] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-                let i = this.read_scalar(i)?.to_i32()?;
-
-                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f.to_host().powi(i).to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    math::apply_random_float_error_ulp(this, res, 4)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
+            "powif16" => powi_intrinsic::<HalfS>(this, args, dest)?,
+            "powif32" => powi_intrinsic::<SingleS>(this, args, dest)?,
+            "powif64" => powi_intrinsic::<DoubleS>(this, args, dest)?,
 
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 652a734e0afc..235f815ba2f2 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -1,8 +1,9 @@
+use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, SingleS};
 use rustc_middle::ty;
 use rustc_middle::ty::FloatTy;
 
 use super::check_intrinsic_arg_count;
-use crate::helpers::{ToHost, ToSoft};
+use crate::math::{HostUnaryFloatOp, host_unary_float_op};
 use crate::*;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -17,16 +18,8 @@ fn emulate_simd_intrinsic(
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
         match intrinsic_name {
-            #[rustfmt::skip]
-            | "fsqrt"
-            | "fsin"
-            | "fcos"
-            | "fexp"
-            | "fexp2"
-            | "flog"
-            | "flog2"
-            | "flog10"
-            => {
+            // Operations we can do with soft-floats.
+            "fsqrt" => {
                 let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
@@ -34,66 +27,53 @@ fn emulate_simd_intrinsic(
                 assert_eq!(dest_len, op_len);
 
                 for i in 0..dest_len {
-                    let op = this.read_immediate(&this.project_index(&op, i)?)?;
+                    let op = this.project_index(&op, i)?;
+                    let dest = this.project_index(&dest, i)?;
+                    let ty::Float(float_ty) = op.layout.ty.kind() else {
+                        span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
+                    };
+                    match float_ty {
+                        FloatTy::F16 => math::sqrt_op::<IeeeFloat<HalfS>>(this, &op, &dest)?,
+                        FloatTy::F32 => math::sqrt_op::<IeeeFloat<SingleS>>(this, &op, &dest)?,
+                        FloatTy::F64 => math::sqrt_op::<IeeeFloat<DoubleS>>(this, &op, &dest)?,
+                        FloatTy::F128 => unimplemented!("f128"),
+                    };
+                }
+            }
+
+            // Operations that need host floats.
+            "fsin" | "fcos" | "fexp" | "fexp2" | "flog" | "flog2" | "flog10" => {
+                let [op] = check_intrinsic_arg_count(args)?;
+                let (op, op_len) = this.project_to_simd(op)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(dest_len, op_len);
+
+                let host_op = match intrinsic_name {
+                    "fsin" => HostUnaryFloatOp::Sin,
+                    "fcos" => HostUnaryFloatOp::Cos,
+                    "fexp" => HostUnaryFloatOp::Exp,
+                    "fexp2" => HostUnaryFloatOp::Exp2,
+                    "flog" => HostUnaryFloatOp::Log,
+                    "flog2" => HostUnaryFloatOp::Log2,
+                    "flog10" => HostUnaryFloatOp::Log10,
+                    _ => bug!(),
+                };
+
+                for i in 0..dest_len {
+                    let op = this.project_index(&op, i)?;
                     let dest = this.project_index(&dest, i)?;
                     let ty::Float(float_ty) = op.layout.ty.kind() else {
                         span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
                     };
                     // Using host floats except for sqrt (but it's fine, these operations do not
                     // have guaranteed precision).
-                    let val = match float_ty {
-                        FloatTy::F16 => {
-                            let f = op.to_scalar().to_f16()?;
-                            let res = match intrinsic_name {
-                                "fsqrt" => math::sqrt(f),
-                                "fsin" => f.to_host().sin().to_soft(),
-                                "fcos" => f.to_host().cos().to_soft(),
-                                "fexp" => f.to_host().exp().to_soft(),
-                                "fexp2" => f.to_host().exp2().to_soft(),
-                                "flog" => f.to_host().ln().to_soft(),
-                                "flog2" => f.to_host().log2().to_soft(),
-                                "flog10" => f.to_host().log10().to_soft(),
-                                _ => bug!(),
-                            };
-                            let res = this.adjust_nan(res, &[f]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F32 => {
-                            let f = op.to_scalar().to_f32()?;
-                            let res = match intrinsic_name {
-                                "fsqrt" => math::sqrt(f),
-                                "fsin" => f.to_host().sin().to_soft(),
-                                "fcos" => f.to_host().cos().to_soft(),
-                                "fexp" => f.to_host().exp().to_soft(),
-                                "fexp2" => f.to_host().exp2().to_soft(),
-                                "flog" => f.to_host().ln().to_soft(),
-                                "flog2" => f.to_host().log2().to_soft(),
-                                "flog10" => f.to_host().log10().to_soft(),
-                                _ => bug!(),
-                            };
-                            let res = this.adjust_nan(res, &[f]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F64 => {
-                            let f = op.to_scalar().to_f64()?;
-                            let res = match intrinsic_name {
-                                "fsqrt" => math::sqrt(f),
-                                "fsin" => f.to_host().sin().to_soft(),
-                                "fcos" => f.to_host().cos().to_soft(),
-                                "fexp" => f.to_host().exp().to_soft(),
-                                "fexp2" => f.to_host().exp2().to_soft(),
-                                "flog" => f.to_host().ln().to_soft(),
-                                "flog2" => f.to_host().log2().to_soft(),
-                                "flog10" => f.to_host().log10().to_soft(),
-                                _ => bug!(),
-                            };
-                            let res = this.adjust_nan(res, &[f]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F128 => unimplemented!("f16_f128"),
-                    };
-
-                    this.write_scalar(val, &dest)?;
+                    match float_ty {
+                        FloatTy::F16 => host_unary_float_op::<HalfS>(this, &op, host_op, &dest)?,
+                        FloatTy::F32 => host_unary_float_op::<SingleS>(this, &op, host_op, &dest)?,
+                        FloatTy::F64 => host_unary_float_op::<DoubleS>(this, &op, host_op, &dest)?,
+                        FloatTy::F128 => unimplemented!("f128"),
+                    }
                 }
             }
             "expose_provenance" => {
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 3bd1459a9354..a46d849a18ea 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -1,13 +1,72 @@
 use std::ops::Neg;
 
 use rand::Rng as _;
-use rustc_apfloat::Float;
 use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, Semantics, SingleS};
+use rustc_apfloat::{Float, FloatConvert};
 use rustc_middle::ty::{self, FloatTy, ScalarInt};
 
-use self::helpers::{ToHost, ToSoft};
 use crate::*;
 
+/// Convert a softfloat type to its corresponding hostfloat type.
+pub trait ToHost {
+    type HostFloat;
+    fn to_host(self) -> Self::HostFloat;
+}
+
+/// Convert a hostfloat type to its corresponding softfloat type.
+pub trait ToSoft {
+    type SoftFloat;
+    fn to_soft(self) -> Self::SoftFloat;
+}
+
+impl ToHost for rustc_apfloat::ieee::Double {
+    type HostFloat = f64;
+
+    fn to_host(self) -> Self::HostFloat {
+        f64::from_bits(self.to_bits().try_into().unwrap())
+    }
+}
+
+impl ToSoft for f64 {
+    type SoftFloat = rustc_apfloat::ieee::Double;
+
+    fn to_soft(self) -> Self::SoftFloat {
+        Float::from_bits(self.to_bits().into())
+    }
+}
+
+impl ToHost for rustc_apfloat::ieee::Single {
+    type HostFloat = f32;
+
+    fn to_host(self) -> Self::HostFloat {
+        f32::from_bits(self.to_bits().try_into().unwrap())
+    }
+}
+
+impl ToSoft for f32 {
+    type SoftFloat = rustc_apfloat::ieee::Single;
+
+    fn to_soft(self) -> Self::SoftFloat {
+        Float::from_bits(self.to_bits().into())
+    }
+}
+
+impl ToHost for rustc_apfloat::ieee::Half {
+    type HostFloat = f16;
+
+    fn to_host(self) -> Self::HostFloat {
+        f16::from_bits(self.to_bits().try_into().unwrap())
+    }
+}
+
+impl ToSoft for f16 {
+    type SoftFloat = rustc_apfloat::ieee::Half;
+
+    fn to_soft(self) -> Self::SoftFloat {
+        Float::from_bits(self.to_bits().into())
+    }
+}
+
 /// Disturbes a floating-point result by a relative error in the range (-2^scale, 2^scale).
 pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     ecx: &mut crate::MiriInterpCx<'_>,
@@ -400,49 +459,60 @@ pub(crate) fn sqrt<F: Float>(x: F) -> F {
     }
 }
 
+pub fn sqrt_op<'tcx, F: Float + FloatConvert<F> + Into<Scalar>>(
+    this: &mut MiriInterpCx<'tcx>,
+    f: &OpTy<'tcx>,
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx> {
+    let f: F = this.read_scalar(f)?.to_float()?;
+    // Sqrt is specified to be fully precise.
+    let res = math::sqrt(f);
+    let res = this.adjust_nan(res, &[f]);
+    this.write_scalar(res, dest)
+}
+
 pub trait HostFloatOperation {
-    fn host_sin(x: Self) -> Self;
-    fn host_cos(x: Self) -> Self;
-    fn host_exp(x: Self) -> Self;
-    fn host_exp2(x: Self) -> Self;
-    fn host_log(x: Self) -> Self;
-    fn host_log10(x: Self) -> Self;
-    fn host_log2(x: Self) -> Self;
-    // fn host_powf(x: Self, y: Self) -> Self;
-    // fn host_powi(x: Self, y: i32) -> Self;
+    fn host_sin(self) -> Self;
+    fn host_cos(self) -> Self;
+    fn host_exp(self) -> Self;
+    fn host_exp2(self) -> Self;
+    fn host_log(self) -> Self;
+    fn host_log10(self) -> Self;
+    fn host_log2(self) -> Self;
+    fn host_powf(self, y: Self) -> Self;
+    fn host_powi(self, y: i32) -> Self;
 }
 
 macro_rules! impl_float_host_operations {
     ($ty:ty) => {
         impl HostFloatOperation for $ty {
-            fn host_sin(x: Self) -> Self {
-                x.to_host().sin().to_soft()
+            fn host_sin(self) -> Self {
+                self.to_host().sin().to_soft()
             }
-            fn host_cos(x: Self) -> Self {
-                x.to_host().cos().to_soft()
+            fn host_cos(self) -> Self {
+                self.to_host().cos().to_soft()
             }
-            fn host_exp(x: Self) -> Self {
-                x.to_host().exp().to_soft()
+            fn host_exp(self) -> Self {
+                self.to_host().exp().to_soft()
             }
-            fn host_exp2(x: Self) -> Self {
-                x.to_host().exp2().to_soft()
+            fn host_exp2(self) -> Self {
+                self.to_host().exp2().to_soft()
             }
-            fn host_log(x: Self) -> Self {
-                x.to_host().ln().to_soft()
+            fn host_log(self) -> Self {
+                self.to_host().ln().to_soft()
             }
-            fn host_log10(x: Self) -> Self {
-                x.to_host().log10().to_soft()
+            fn host_log10(self) -> Self {
+                self.to_host().log10().to_soft()
             }
-            fn host_log2(x: Self) -> Self {
-                x.to_host().log2().to_soft()
+            fn host_log2(self) -> Self {
+                self.to_host().log2().to_soft()
+            }
+            fn host_powf(self, y: Self) -> Self {
+                self.to_host().powf(y.to_host()).to_soft()
+            }
+            fn host_powi(self, y: i32) -> Self {
+                self.to_host().powi(y).to_soft()
             }
-
-            // fn host_powf(x: Self, y: Self) -> Self {
-            //     x.to_host().powf(y.to_host()).to_soft()
-            // }
-            // fn host_powi(x: Self, y: i32) -> Self {
-            //     x.to_host().powi(y).to_soft()
-            // }
         }
     };
 }
@@ -451,6 +521,67 @@ fn host_log2(x: Self) -> Self {
 impl_float_host_operations!(IeeeFloat<SingleS>);
 impl_float_host_operations!(IeeeFloat<DoubleS>);
 
+#[derive(Debug, Clone, Copy)]
+pub enum HostUnaryFloatOp {
+    Sin,
+    Cos,
+    Exp,
+    Exp2,
+    Log,
+    Log10,
+    Log2,
+}
+
+pub fn host_unary_float_op<'tcx, S: Semantics>(
+    this: &mut MiriInterpCx<'tcx>,
+    f: &OpTy<'tcx>,
+    op: HostUnaryFloatOp,
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx>
+where
+    IeeeFloat<S>: HostFloatOperation + IeeeExt + Float + Into<Scalar>,
+{
+    use HostFloatOperation;
+
+    let f: IeeeFloat<S> = this.read_scalar(f)?.to_float()?;
+
+    // The fixed-value and clamping functions need the name as a string.
+    let name = match op {
+        HostUnaryFloatOp::Sin => "sin",
+        HostUnaryFloatOp::Cos => "cos",
+        HostUnaryFloatOp::Exp => "exp",
+        HostUnaryFloatOp::Exp2 => "exp2",
+        HostUnaryFloatOp::Log => "log",
+        HostUnaryFloatOp::Log10 => "log10",
+        HostUnaryFloatOp::Log2 => "log2",
+    };
+    let res = math::fixed_float_value(this, name, &[f]).unwrap_or_else(|| {
+        // Using host floats (but it's fine, these operations do not have
+        // guaranteed precision).
+        let res = match op {
+            HostUnaryFloatOp::Sin => f.host_sin(),
+            HostUnaryFloatOp::Cos => f.host_cos(),
+            HostUnaryFloatOp::Exp => f.host_exp(),
+            HostUnaryFloatOp::Exp2 => f.host_exp2(),
+            HostUnaryFloatOp::Log => f.host_log(),
+            HostUnaryFloatOp::Log10 => f.host_log10(),
+            HostUnaryFloatOp::Log2 => f.host_log2(),
+        };
+
+        // Apply a relative error of 4ULP to introduce some non-determinism
+        // simulating imprecise implementations and optimizations.
+        let res = math::apply_random_float_error_ulp(this, res, 4);
+
+        // Clamp the result to the guaranteed range of this function according to the C standard,
+        // if any.
+        math::clamp_float_value(name, res)
+    });
+
+    let res = this.adjust_nan(res, &[f]);
+    this.write_scalar(res, dest)?;
+    interp_ok(())
+}
+
 /// Extend functionality of `rustc_apfloat` softfloats for IEEE float types.
 pub trait IeeeExt: rustc_apfloat::Float {
     // Some values we use:
diff --git a/src/tools/miri/src/shims/math.rs b/src/tools/miri/src/shims/math.rs
index 576e76494bcb..ef185aa2a3e9 100644
--- a/src/tools/miri/src/shims/math.rs
+++ b/src/tools/miri/src/shims/math.rs
@@ -4,7 +4,7 @@
 use rustc_span::Symbol;
 use rustc_target::callconv::FnAbi;
 
-use self::helpers::{ToHost, ToSoft};
+use self::math::{ToHost, ToSoft};
 use crate::*;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}

From c34e7ffda7356c37945e5e56e7372c0d5d1bf1bc Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 14 Mar 2026 17:05:44 +0800
Subject: [PATCH 0459/1059] Migrate 'convert_named_struct_to_tuple_struct'
 assist

---
 .../convert_named_struct_to_tuple_struct.rs   | 131 +++++++++++-------
 1 file changed, 83 insertions(+), 48 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
index e518c39dabc2..706cef412047 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
@@ -1,9 +1,12 @@
+use std::ops::RangeInclusive;
+
 use either::Either;
 use ide_db::{defs::Definition, search::FileReference};
-use itertools::Itertools;
 use syntax::{
-    SyntaxKind,
-    ast::{self, AstNode, HasAttrs, HasGenericParams, HasVisibility},
+    SyntaxElement, SyntaxKind, SyntaxNode, T, TextRange,
+    ast::{
+        self, AstNode, HasAttrs, HasGenericParams, HasVisibility, syntax_factory::SyntaxFactory,
+    },
     match_ast,
     syntax_editor::{Position, SyntaxEditor},
 };
@@ -81,17 +84,17 @@ pub(crate) fn convert_named_struct_to_tuple_struct(
         AssistId::refactor_rewrite("convert_named_struct_to_tuple_struct"),
         "Convert to tuple struct",
         strukt_or_variant.syntax().text_range(),
-        |edit| {
-            edit_field_references(ctx, edit, record_fields.fields());
-            edit_struct_references(ctx, edit, strukt_def);
-            edit_struct_def(ctx, edit, &strukt_or_variant, record_fields);
+        |builder| {
+            edit_field_references(ctx, builder, record_fields.fields());
+            edit_struct_references(ctx, builder, strukt_def);
+            edit_struct_def(ctx, builder, &strukt_or_variant, record_fields);
         },
     )
 }
 
 fn edit_struct_def(
     ctx: &AssistContext<'_>,
-    edit: &mut SourceChangeBuilder,
+    builder: &mut SourceChangeBuilder,
     strukt: &Either<ast::Struct, ast::Variant>,
     record_fields: ast::RecordFieldList,
 ) {
@@ -108,24 +111,23 @@ fn edit_struct_def(
         let field = ast::TupleField::cast(field_syntax)?;
         Some(field)
     });
-    let tuple_fields = ast::make::tuple_field_list(tuple_fields);
-    let record_fields_text_range = record_fields.syntax().text_range();
 
-    edit.edit_file(ctx.vfs_file_id());
-    edit.replace(record_fields_text_range, tuple_fields.syntax().text());
+    let make = SyntaxFactory::without_mappings();
+    let mut edit = builder.make_editor(strukt.syntax());
 
+    let tuple_fields = make.tuple_field_list(tuple_fields);
+
+    let mut elements = vec![tuple_fields.syntax().clone().into()];
     if let Either::Left(strukt) = strukt {
         if let Some(w) = strukt.where_clause() {
-            let mut where_clause = w.to_string();
-            if where_clause.ends_with(',') {
-                where_clause.pop();
-            }
-            where_clause.push(';');
+            edit.delete(w.syntax());
 
-            edit.delete(w.syntax().text_range());
-            edit.insert(record_fields_text_range.end(), ast::make::tokens::single_newline().text());
-            edit.insert(record_fields_text_range.end(), where_clause);
-            edit.insert(record_fields_text_range.end(), ast::make::tokens::single_newline().text());
+            elements.extend([
+                make.whitespace("\n").into(),
+                remove_trailing_comma(w).into(),
+                make.token(T![;]).into(),
+                make.whitespace("\n").into(),
+            ]);
 
             if let Some(tok) = strukt
                 .generic_param_list()
@@ -133,25 +135,28 @@ fn edit_struct_def(
                 .and_then(|tok| tok.next_token())
                 .filter(|tok| tok.kind() == SyntaxKind::WHITESPACE)
             {
-                edit.delete(tok.text_range());
+                edit.delete(tok);
             }
         } else {
-            edit.insert(record_fields_text_range.end(), ";");
+            elements.push(make.token(T![;]).into());
         }
     }
+    edit.replace_with_many(record_fields.syntax(), elements);
 
     if let Some(tok) = record_fields
         .l_curly_token()
         .and_then(|tok| tok.prev_token())
         .filter(|tok| tok.kind() == SyntaxKind::WHITESPACE)
     {
-        edit.delete(tok.text_range())
+        edit.delete(tok)
     }
+
+    builder.add_file_edits(ctx.vfs_file_id(), edit);
 }
 
 fn edit_struct_references(
     ctx: &AssistContext<'_>,
-    edit: &mut SourceChangeBuilder,
+    builder: &mut SourceChangeBuilder,
     strukt: Either<hir::Struct, hir::Variant>,
 ) {
     let strukt_def = match strukt {
@@ -161,17 +166,20 @@ fn edit_struct_references(
     let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
     for (file_id, refs) in usages {
-        edit.edit_file(file_id.file_id(ctx.db()));
+        let source = ctx.sema.parse(file_id);
+        let mut edit = builder.make_editor(source.syntax());
         for r in refs {
-            process_struct_name_reference(ctx, r, edit);
+            process_struct_name_reference(ctx, r, &mut edit, &source);
         }
+        builder.add_file_edits(file_id.file_id(ctx.db()), edit);
     }
 }
 
 fn process_struct_name_reference(
     ctx: &AssistContext<'_>,
     r: FileReference,
-    edit: &mut SourceChangeBuilder,
+    edit: &mut SyntaxEditor,
+    source: &ast::SourceFile,
 ) -> Option<()> {
     // First check if it's the last semgnet of a path that directly belongs to a record
     // expression/pattern.
@@ -186,6 +194,7 @@ fn process_struct_name_reference(
         // struct we want to edit.
         return None;
     }
+    let make = SyntaxFactory::without_mappings();
 
     // FIXME: Processing RecordPat and RecordExpr for unordered fields, and insert RestPat
     let parent = full_path.syntax().parent()?;
@@ -195,20 +204,17 @@ fn process_struct_name_reference(
                 // When we failed to get the original range for the whole struct expression node,
                 // we can't provide any reasonable edit. Leave it untouched.
                 let file_range = ctx.sema.original_range_opt(record_struct_pat.syntax())?;
-                edit.replace(
-                    file_range.range,
-                    ast::make::tuple_struct_pat(
-                        record_struct_pat.path()?,
-                        record_struct_pat
-                            .record_pat_field_list()?
-                            .fields()
-                            .filter_map(|pat| pat.pat())
-                            .chain(record_struct_pat.record_pat_field_list()?
-                                .rest_pat()
-                                .map(Into::into))
-                    )
-                    .to_string()
+                let new = make.tuple_struct_pat(
+                    record_struct_pat.path()?,
+                    record_struct_pat
+                        .record_pat_field_list()?
+                        .fields()
+                        .filter_map(|pat| pat.pat())
+                        .chain(record_struct_pat.record_pat_field_list()?
+                            .rest_pat()
+                            .map(Into::into))
                 );
+                edit.replace_all(cover_range(source, file_range.range), vec![new.syntax().clone().into()]);
             },
             ast::RecordExpr(record_expr) => {
                 // When we failed to get the original range for the whole struct pattern node,
@@ -218,10 +224,9 @@ fn process_struct_name_reference(
                 let args = record_expr
                     .record_expr_field_list()?
                     .fields()
-                    .filter_map(|f| f.expr())
-                    .join(", ");
-
-                edit.replace(file_range.range, format!("{path}({args})"));
+                    .filter_map(|f| f.expr());
+                let new = make.expr_call(make.expr_path(path), make.arg_list(args));
+                edit.replace_all(cover_range(source, file_range.range), vec![new.syntax().clone().into()]);
             },
             _ => {}
         }
@@ -232,9 +237,10 @@ fn process_struct_name_reference(
 
 fn edit_field_references(
     ctx: &AssistContext<'_>,
-    edit: &mut SourceChangeBuilder,
+    builder: &mut SourceChangeBuilder,
     fields: impl Iterator<Item = ast::RecordField>,
 ) {
+    let make = SyntaxFactory::without_mappings();
     for (index, field) in fields.enumerate() {
         let field = match ctx.sema.to_def(&field) {
             Some(it) => it,
@@ -243,19 +249,48 @@ fn edit_field_references(
         let def = Definition::Field(field);
         let usages = def.usages(&ctx.sema).all();
         for (file_id, refs) in usages {
-            edit.edit_file(file_id.file_id(ctx.db()));
+            let source = ctx.sema.parse(file_id);
+            let mut edit = builder.make_editor(source.syntax());
+
             for r in refs {
                 if let Some(name_ref) = r.name.as_name_ref() {
                     // Only edit the field reference if it's part of a `.field` access
                     if name_ref.syntax().parent().and_then(ast::FieldExpr::cast).is_some() {
-                        edit.replace(r.range, index.to_string());
+                        edit.replace_all(
+                            cover_range(&source, r.range),
+                            vec![make.name_ref(&index.to_string()).syntax().clone().into()],
+                        );
                     }
                 }
             }
+
+            builder.add_file_edits(file_id.file_id(ctx.db()), edit);
         }
     }
 }
 
+fn cover_range(source: &ast::SourceFile, range: TextRange) -> RangeInclusive<SyntaxElement> {
+    let node = match source.syntax().covering_element(range) {
+        syntax::NodeOrToken::Node(node) => node,
+        syntax::NodeOrToken::Token(t) => t.parent().unwrap(),
+    };
+    let mut iter = node.children_with_tokens().filter(|it| range.contains_range(it.text_range()));
+    let first = iter.next().unwrap_or(node.into());
+    let last = iter.last().unwrap_or_else(|| first.clone());
+    first..=last
+}
+
+fn remove_trailing_comma(w: ast::WhereClause) -> SyntaxNode {
+    let w = w.syntax().clone_subtree();
+    let mut editor = SyntaxEditor::new(w.clone());
+    if let Some(last) = w.last_child_or_token()
+        && last.kind() == T![,]
+    {
+        editor.delete(last);
+    }
+    editor.finish().new_root().clone()
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};

From 31f31ab2fe7e1306a4d52806b654ab3ff8621d25 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 11 Mar 2026 18:33:28 +0800
Subject: [PATCH 0460/1059] Fix overlap edit on record to tuple assist uses
 self

Example
---
```rust
struct $0Foo { field1: u32 }
impl Foo {
    fn clone(&self) -> Self {
        Self { field1: self.field1 }
    }
}
```

**Before this PR**

Panic

**After this PR**

```rust
struct Foo(u32);
impl Foo {
    fn clone(&self) -> Self {
        Self(self.0)
    }
}
```
---
 .../convert_named_struct_to_tuple_struct.rs   | 216 +++++++++++++++---
 .../rust-analyzer/crates/syntax/src/algo.rs   |  16 ++
 2 files changed, 202 insertions(+), 30 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
index 706cef412047..8dfd4598dfa1 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
@@ -3,12 +3,13 @@
 use either::Either;
 use ide_db::{defs::Definition, search::FileReference};
 use syntax::{
-    SyntaxElement, SyntaxKind, SyntaxNode, T, TextRange,
+    NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, T, TextRange,
+    algo::next_non_trivia_token,
     ast::{
         self, AstNode, HasAttrs, HasGenericParams, HasVisibility, syntax_factory::SyntaxFactory,
     },
     match_ast,
-    syntax_editor::{Position, SyntaxEditor},
+    syntax_editor::{Element, Position, SyntaxEditor},
 };
 
 use crate::{AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder};
@@ -194,39 +195,32 @@ fn process_struct_name_reference(
         // struct we want to edit.
         return None;
     }
-    let make = SyntaxFactory::without_mappings();
 
     // FIXME: Processing RecordPat and RecordExpr for unordered fields, and insert RestPat
     let parent = full_path.syntax().parent()?;
     match_ast! {
         match parent {
             ast::RecordPat(record_struct_pat) => {
-                // When we failed to get the original range for the whole struct expression node,
-                // we can't provide any reasonable edit. Leave it untouched.
-                let file_range = ctx.sema.original_range_opt(record_struct_pat.syntax())?;
-                let new = make.tuple_struct_pat(
-                    record_struct_pat.path()?,
-                    record_struct_pat
-                        .record_pat_field_list()?
-                        .fields()
-                        .filter_map(|pat| pat.pat())
-                        .chain(record_struct_pat.record_pat_field_list()?
-                            .rest_pat()
-                            .map(Into::into))
-                );
-                edit.replace_all(cover_range(source, file_range.range), vec![new.syntax().clone().into()]);
-            },
-            ast::RecordExpr(record_expr) => {
                 // When we failed to get the original range for the whole struct pattern node,
                 // we can't provide any reasonable edit. Leave it untouched.
-                let file_range = ctx.sema.original_range_opt(record_expr.syntax())?;
-                let path = record_expr.path()?;
-                let args = record_expr
-                    .record_expr_field_list()?
-                    .fields()
-                    .filter_map(|f| f.expr());
-                let new = make.expr_call(make.expr_path(path), make.arg_list(args));
-                edit.replace_all(cover_range(source, file_range.range), vec![new.syntax().clone().into()]);
+                record_to_tuple_struct_like(
+                    ctx,
+                    source,
+                    edit,
+                    record_struct_pat.record_pat_field_list()?,
+                    |it| it.fields().filter_map(|it| it.name_ref()),
+                );
+            },
+            ast::RecordExpr(record_expr) => {
+                // When we failed to get the original range for the whole struct expression node,
+                // we can't provide any reasonable edit. Leave it untouched.
+                record_to_tuple_struct_like(
+                    ctx,
+                    source,
+                    edit,
+                    record_expr.record_expr_field_list()?,
+                    |it| it.fields().filter_map(|it| it.name_ref()),
+                );
             },
             _ => {}
         }
@@ -235,6 +229,61 @@ fn process_struct_name_reference(
     Some(())
 }
 
+fn record_to_tuple_struct_like<T, I>(
+    ctx: &AssistContext<'_>,
+    source: &ast::SourceFile,
+    edit: &mut SyntaxEditor,
+    field_list: T,
+    fields: impl FnOnce(&T) -> I,
+) -> Option<()>
+where
+    T: AstNode,
+    I: IntoIterator<Item = ast::NameRef>,
+{
+    let make = SyntaxFactory::without_mappings();
+    let orig = ctx.sema.original_range_opt(field_list.syntax())?;
+    let list_range = cover_range(source, orig.range);
+
+    let l_curly = match list_range.start() {
+        NodeOrToken::Node(node) => node.first_token()?,
+        NodeOrToken::Token(t) => t.clone(),
+    };
+    let r_curly = match list_range.end() {
+        NodeOrToken::Node(node) => node.last_token()?,
+        NodeOrToken::Token(t) => t.clone(),
+    };
+
+    if l_curly.kind() == T!['{'] {
+        delete_whitespace(edit, l_curly.prev_token());
+        delete_whitespace(edit, l_curly.next_token());
+        edit.replace(l_curly, make.token(T!['(']));
+    }
+    if r_curly.kind() == T!['}'] {
+        delete_whitespace(edit, r_curly.prev_token());
+        edit.replace(r_curly, make.token(T![')']));
+    }
+
+    for name_ref in fields(&field_list) {
+        let Some(orig) = ctx.sema.original_range_opt(name_ref.syntax()) else { continue };
+        let name_range = cover_range(source, orig.range);
+
+        if let Some(colon) = next_non_trivia_token(name_range.end().clone())
+            && colon.kind() == T![:]
+        {
+            edit.delete(&colon);
+            edit.delete_all(name_range);
+
+            if let Some(next) = next_non_trivia_token(colon.clone())
+                && next.kind() != T!['}']
+            {
+                // Avoid overlapping delete whitespace on `{ field: }`
+                delete_whitespace(edit, colon.next_token());
+            }
+        }
+    }
+    Some(())
+}
+
 fn edit_field_references(
     ctx: &AssistContext<'_>,
     builder: &mut SourceChangeBuilder,
@@ -271,8 +320,8 @@ fn edit_field_references(
 
 fn cover_range(source: &ast::SourceFile, range: TextRange) -> RangeInclusive<SyntaxElement> {
     let node = match source.syntax().covering_element(range) {
-        syntax::NodeOrToken::Node(node) => node,
-        syntax::NodeOrToken::Token(t) => t.parent().unwrap(),
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(t) => t.parent().unwrap(),
     };
     let mut iter = node.children_with_tokens().filter(|it| range.contains_range(it.text_range()));
     let first = iter.next().unwrap_or(node.into());
@@ -280,6 +329,15 @@ fn cover_range(source: &ast::SourceFile, range: TextRange) -> RangeInclusive<Syn
     first..=last
 }
 
+fn delete_whitespace(edit: &mut SyntaxEditor, whitespace: Option<impl Element>) {
+    let Some(whitespace) = whitespace else { return };
+    let NodeOrToken::Token(token) = whitespace.syntax_element() else { return };
+
+    if token.kind() == SyntaxKind::WHITESPACE && !token.text().contains('\n') {
+        edit.delete(token);
+    }
+}
+
 fn remove_trailing_comma(w: ast::WhereClause) -> SyntaxNode {
     let w = w.syntax().clone_subtree();
     let mut editor = SyntaxEditor::new(w.clone());
@@ -712,6 +770,102 @@ struct Wrap<T>(T)
         );
     }
 
+    #[test]
+    fn convert_constructor_expr_uses_self() {
+        // regression test for #21595
+        check_assist(
+            convert_named_struct_to_tuple_struct,
+            r#"
+struct $0Foo { field1: u32 }
+impl Foo {
+    fn clone(&self) -> Self {
+        Self { field1: self.field1 }
+    }
+}"#,
+            r#"
+struct Foo(u32);
+impl Foo {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}"#,
+        );
+
+        check_assist(
+            convert_named_struct_to_tuple_struct,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+struct $0Foo { field1: u32 }
+impl Foo {
+    fn clone(&self) -> Self {
+        id!(Self { field1: self.field1 })
+    }
+}"#,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+struct Foo(u32);
+impl Foo {
+    fn clone(&self) -> Self {
+        id!(Self(self.0))
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn convert_pat_uses_self() {
+        // regression test for #21595
+        check_assist(
+            convert_named_struct_to_tuple_struct,
+            r#"
+enum Foo {
+    $0Value { field: &'static Foo },
+    Nil,
+}
+fn foo(foo: &Foo) {
+    if let Foo::Value { field: Foo::Value { field } } = foo {}
+}"#,
+            r#"
+enum Foo {
+    Value(&'static Foo),
+    Nil,
+}
+fn foo(foo: &Foo) {
+    if let Foo::Value(Foo::Value(field)) = foo {}
+}"#,
+        );
+
+        check_assist(
+            convert_named_struct_to_tuple_struct,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+enum Foo {
+    $0Value { field: &'static Foo },
+    Nil,
+}
+fn foo(foo: &Foo) {
+    if let id!(Foo::Value { field: Foo::Value { field } }) = foo {}
+}"#,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+enum Foo {
+    Value(&'static Foo),
+    Nil,
+}
+fn foo(foo: &Foo) {
+    if let id!(Foo::Value(Foo::Value(field))) = foo {}
+}"#,
+        );
+    }
+
     #[test]
     fn not_applicable_other_than_record_variant() {
         check_assist_not_applicable(
@@ -1077,7 +1231,9 @@ macro_rules! id {
 
 fn test() {
     id! {
-        let s = Struct(42);
+        let s = Struct(
+            42,
+        );
         let Struct(value) = s;
         let Struct(inner) = s;
     }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/algo.rs b/src/tools/rust-analyzer/crates/syntax/src/algo.rs
index 3ab9c902625f..c679921b3f65 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/algo.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/algo.rs
@@ -132,3 +132,19 @@ pub fn previous_non_trivia_token(e: impl Into<SyntaxElement>) -> Option<SyntaxTo
     }
     None
 }
+
+pub fn next_non_trivia_token(e: impl Into<SyntaxElement>) -> Option<SyntaxToken> {
+    let mut token = match e.into() {
+        SyntaxElement::Node(n) => n.last_token()?,
+        SyntaxElement::Token(t) => t,
+    }
+    .next_token();
+    while let Some(inner) = token {
+        if !inner.kind().is_trivia() {
+            return Some(inner);
+        } else {
+            token = inner.next_token();
+        }
+    }
+    None
+}

From cf47e2cdd43dc9e238035cfbb5f6aa1a03fb2630 Mon Sep 17 00:00:00 2001
From: WhySoBad <49595640+WhySoBad@users.noreply.github.com>
Date: Fri, 13 Mar 2026 17:32:02 +0100
Subject: [PATCH 0461/1059] Add `getsockname` shim

---
 src/tools/miri/src/diagnostics.rs             |   2 +-
 .../miri/src/shims/unix/foreign_items.rs      |  10 +
 src/tools/miri/src/shims/unix/socket.rs       | 213 +++++++++++++++++-
 .../miri/tests/pass-dep/libc/libc-socket.rs   | 182 ++++++++++++++-
 src/tools/miri/tests/pass-dep/shims/socket.rs |   4 +-
 5 files changed, 401 insertions(+), 10 deletions(-)

diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 777e6581e1d1..0b40fda8c9dc 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -714,7 +714,7 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
                 format!("GenMC currently does not model the failure ordering for `compare_exchange`. {was_upgraded_msg}. Miri with GenMC might miss bugs related to this memory access.")
             }
             FileInProcOpened => format!("files in `/proc` can bypass the Abstract Machine and might not work properly in Miri"),
-            SocketListenUnsupportedBacklog { provided, supported, .. } => format!("called `listen` on socket with backlog value of {provided} but only {supported} is supported")
+            SocketListenUnsupportedBacklog { provided, supported, .. } => format!("called `listen` on socket with backlog value of {provided} but only {supported} is supported"),
         };
 
         let notes = match &e {
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 28092156c729..9a24cbc5048a 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -581,6 +581,16 @@ fn emulate_foreign_item_inner(
                     this.setsockopt(socket, level, option_name, option_value, option_len)?;
                 this.write_scalar(result, dest)?;
             }
+            "getsockname" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, *mut _) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.getsockname(socket, address, address_len)?;
+                this.write_scalar(result, dest)?;
+            }
 
             // Time
             "gettimeofday" => {
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index eac60e61f461..af645f88a4c4 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -1,4 +1,5 @@
 use std::cell::{Cell, RefCell};
+use std::iter;
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, TcpListener};
 
 use rustc_abi::Size;
@@ -30,7 +31,6 @@ enum SocketState {
     Bound(SocketAddr),
     /// The `listen` syscall has been called on the socket.
     /// This is only reachable from the [`SocketState::Bound`] state.
-    #[expect(unused)]
     Listening(TcpListener),
 }
 
@@ -345,6 +345,62 @@ fn setsockopt(
             "setsockopt: level {level:#x} is unsupported, only SOL_SOCKET is allowed"
         );
     }
+
+    fn getsockname(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let address_ptr = this.read_pointer(address)?;
+        let address_len_ptr = this.read_pointer(address_len)?;
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return this.set_last_error_and_return_i32(LibcError("EBADF"));
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return this.set_last_error_and_return_i32(LibcError("ENOTSOCK"));
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        let state = socket.state.borrow();
+
+        let address = match &*state {
+            SocketState::Bound(address) => {
+                if address.port() == 0 {
+                    // The socket is bound to a zero-port which means it gets assigned a random
+                    // port. Since we don't yet have an underlying socket, we don't know what this
+                    // random port will be and thus this is unsupported.
+                    throw_unsup_format!(
+                        "getsockname: when the port is 0, getting the socket address before \
+                                        calling `listen` or `connect` is unsupported"
+                    )
+                }
+
+                *address
+            }
+            SocketState::Listening(listener) =>
+                match listener.local_addr() {
+                    Ok(address) => address,
+                    Err(e) => return this.set_last_error_and_return_i32(e),
+                },
+            // For non-bound sockets the POSIX manual says the returned address is unspecified.
+            // Often this is 0.0.0.0:0 and thus we set it to this value.
+            _ => SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0)),
+        };
+
+        match this.write_socket_address(&address, address_ptr, address_len_ptr, "getsockname")? {
+            Ok(_) => interp_ok(Scalar::from_i32(0)),
+            Err(e) => this.set_last_error_and_return_i32(e),
+        }
+    }
 }
 
 impl<'tcx> EvalContextPrivExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -461,4 +517,159 @@ fn socket_address(
 
         interp_ok(Ok(socket_addr))
     }
+
+    /// Attempt to write a standard library socket address into a pointer.
+    ///
+    /// The `address_len_ptr` parameter serves both as input and output parameter.
+    /// On input, it points to the size of the buffer `address_ptr` points to, and
+    /// on output it points to the non-truncated size of the written address in the
+    /// buffer pointed to by `address_ptr`.
+    ///
+    /// If the address buffer doesn't fit the whole address, the address is truncated to not
+    /// overflow the buffer.
+    fn write_socket_address(
+        &mut self,
+        address: &SocketAddr,
+        address_ptr: Pointer,
+        address_len_ptr: Pointer,
+        foreign_name: &'static str,
+    ) -> InterpResult<'tcx, Result<(), IoError>> {
+        let this = self.eval_context_mut();
+
+        if address_ptr == Pointer::null() || address_len_ptr == Pointer::null() {
+            // The POSIX man page doesn't account for the cases where the `address_ptr` or
+            // `address_len_ptr` could be null pointers. Thus, this behavior is undefined!
+            throw_ub_format!(
+                "{foreign_name}: writing a socket address but the address or the length pointer is a null pointer"
+            )
+        }
+
+        let socklen_layout = this.libc_ty_layout("socklen_t");
+        let address_buffer_len_place = this.ptr_to_mplace(address_len_ptr, socklen_layout);
+        // We only support buffer lengths which can be stored in a u64 since the
+        // size of a layout in bytes is also stored in a u64.
+        let address_buffer_len: u64 = this
+            .read_scalar(&address_buffer_len_place)?
+            .to_int(socklen_layout.size)?
+            .try_into()
+            .unwrap();
+
+        let (address_buffer, address_layout) = match address {
+            SocketAddr::V4(address) => {
+                // IPv4 address bytes; already stored in network byte order.
+                let address_bytes = address.ip().octets();
+                // Port needs to be manually turned into network byte order.
+                let port = address.port().to_be();
+
+                let sockaddr_in_layout = this.libc_ty_layout("sockaddr_in");
+                // Allocate new buffer on the stack with the `sockaddr_in` layout.
+                // We need a temporary buffer as `address_ptr` might not point to a large enough
+                // buffer, in which case we have to truncate.
+                let address_buffer = this.allocate(sockaddr_in_layout, MemoryKind::Stack)?;
+                // Zero the whole buffer as some libc targets have additional fields which we fill
+                // with zero bytes (just like the standard library does it).
+                this.write_bytes_ptr(
+                    address_buffer.ptr(),
+                    iter::repeat_n(0, address_buffer.layout.size.bytes_usize()),
+                )?;
+
+                let sin_family_field = this.project_field_named(&address_buffer, "sin_family")?;
+                // We cannot simply write the `AF_INET` scalar into the `sin_family_field` because on most
+                // systems the field has a layout of 16-bit whilst the scalar has a size of 32-bit.
+                // Since the `AF_INET` constant is chosen such that it can safely be converted into
+                // a 16-bit integer, we use the following logic to get a scalar of the right size.
+                let af_inet = this.eval_libc("AF_INET");
+                let address_family =
+                    Scalar::from_int(af_inet.to_int(af_inet.size())?, sin_family_field.layout.size);
+                this.write_scalar(address_family, &sin_family_field)?;
+
+                let sin_port_field = this.project_field_named(&address_buffer, "sin_port")?;
+                // Write the port in target native endianness bytes as we already converted it
+                // to big endian above.
+                this.write_bytes_ptr(sin_port_field.ptr(), port.to_ne_bytes())?;
+
+                let sin_addr_field = this.project_field_named(&address_buffer, "sin_addr")?;
+                let s_addr_field = this.project_field_named(&sin_addr_field, "s_addr")?;
+                this.write_bytes_ptr(s_addr_field.ptr(), address_bytes)?;
+
+                (address_buffer, sockaddr_in_layout)
+            }
+            SocketAddr::V6(address) => {
+                // IPv6 address bytes; already stored in network byte order.
+                let address_bytes = address.ip().octets();
+                // Port needs to be manually turned into network byte order.
+                let port = address.port().to_be();
+                // Flowinfo is stored in native byte order.
+                let flowinfo = address.flowinfo();
+                // Scope id is stored in native byte order.
+                let scope_id = address.scope_id();
+
+                let sockaddr_in6_layout = this.libc_ty_layout("sockaddr_in6");
+                // Allocate new buffer on the stack with the `sockaddr_in6` layout.
+                // We need a temporary buffer as `address_ptr` might not point to a large enough
+                // buffer, in which case we have to truncate.
+                let address_buffer = this.allocate(sockaddr_in6_layout, MemoryKind::Stack)?;
+                // Zero the whole buffer as some libc targets have additional fields which we fill
+                // with zero bytes (just like the standard library does it).
+                this.write_bytes_ptr(
+                    address_buffer.ptr(),
+                    iter::repeat_n(0, address_buffer.layout.size.bytes_usize()),
+                )?;
+
+                let sin6_family_field = this.project_field_named(&address_buffer, "sin6_family")?;
+                // We cannot simply write the `AF_INET6` scalar into the `sin6_family_field` because on most
+                // systems the field has a layout of 16-bit whilst the scalar has a size of 32-bit.
+                // Since the `AF_INET6` constant is chosen such that it can safely be converted into
+                // a 16-bit integer, we use the following logic to get a scalar of the right size.
+                let af_inet6 = this.eval_libc("AF_INET6");
+                let address_family = Scalar::from_int(
+                    af_inet6.to_int(af_inet6.size())?,
+                    sin6_family_field.layout.size,
+                );
+                this.write_scalar(address_family, &sin6_family_field)?;
+
+                let sin6_port_field = this.project_field_named(&address_buffer, "sin6_port")?;
+                // Write the port in target native endianness bytes as we already converted it
+                // to big endian above.
+                this.write_bytes_ptr(sin6_port_field.ptr(), port.to_ne_bytes())?;
+
+                let sin6_flowinfo_field =
+                    this.project_field_named(&address_buffer, "sin6_flowinfo")?;
+                this.write_scalar(Scalar::from_u32(flowinfo), &sin6_flowinfo_field)?;
+
+                let sin6_scope_id_field =
+                    this.project_field_named(&address_buffer, "sin6_scope_id")?;
+                this.write_scalar(Scalar::from_u32(scope_id), &sin6_scope_id_field)?;
+
+                let sin6_addr_field = this.project_field_named(&address_buffer, "sin6_addr")?;
+                let s6_addr_field = this.project_field_named(&sin6_addr_field, "s6_addr")?;
+                this.write_bytes_ptr(s6_addr_field.ptr(), address_bytes)?;
+
+                (address_buffer, sockaddr_in6_layout)
+            }
+        };
+
+        // Copy the truncated address into the pointer pointed to by `address_ptr`.
+        this.mem_copy(
+            address_buffer.ptr(),
+            address_ptr,
+            // Truncate the address to fit the provided buffer.
+            address_layout.size.min(Size::from_bytes(address_buffer_len)),
+            // The buffers are guaranteed to not overlap since the `address_buffer`
+            // was just newly allocated on the stack.
+            true,
+        )?;
+        // Deallocate the address buffer as it was only needed to construct the address and
+        // copy it into the buffer pointed to by `address_ptr`.
+        this.deallocate_ptr(address_buffer.ptr(), None, MemoryKind::Stack)?;
+        // Size of the non-truncated address.
+        let address_len = address_layout.size.bytes();
+
+        this.write_scalar(
+            Scalar::from_uint(address_len, socklen_layout.size),
+            &address_buffer_len_place,
+        )?;
+
+        interp_ok(Ok(()))
+    }
 }
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
index 1a4c0b2e168e..0a5f8c226af4 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
@@ -4,6 +4,7 @@
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
 use std::io::{self, ErrorKind};
+use std::mem::MaybeUninit;
 
 use libc_utils::*;
 
@@ -26,6 +27,11 @@ fn main() {
     test_bind_ipv6();
 
     test_listen();
+
+    test_getsockname_ipv4();
+    test_getsockname_ipv4_random_port();
+    test_getsockname_ipv4_unbound();
+    test_getsockname_ipv6();
 }
 
 fn test_socket_close() {
@@ -38,7 +44,7 @@ fn test_socket_close() {
 fn test_bind_ipv4() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
     unsafe {
         errno_check(libc::bind(
             sockfd,
@@ -52,7 +58,7 @@ fn test_bind_ipv4() {
 fn test_bind_ipv4_reuseaddr() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
     setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_REUSEADDR, 1 as libc::c_int).unwrap();
     unsafe {
         errno_check(libc::bind(
@@ -86,7 +92,7 @@ fn test_set_reuseaddr_invalid_len() {
 fn test_bind_ipv4_nosigpipe() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
     setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1 as libc::c_int).unwrap();
     unsafe {
         errno_check(libc::bind(
@@ -120,7 +126,7 @@ fn test_set_nosigpipe_invalid_len() {
 fn test_bind_ipv4_invalid_addr_len() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
     let err = unsafe {
         errno_result(libc::bind(
             sockfd,
@@ -138,7 +144,7 @@ fn test_bind_ipv4_invalid_addr_len() {
 fn test_bind_ipv6() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET6, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv6_sock_addr(net::IPV6_LOCALHOST, 1234);
+    let addr = net::ipv6_sock_addr(net::IPV6_LOCALHOST, 0);
     unsafe {
         errno_check(libc::bind(
             sockfd,
@@ -151,7 +157,7 @@ fn test_bind_ipv6() {
 fn test_listen() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 1234);
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
     unsafe {
         errno_check(libc::bind(
             sockfd,
@@ -168,6 +174,137 @@ fn test_listen() {
     }
 }
 
+/// Test the `getsockname` syscall on an IPv4 socket which is bound.
+/// The `getsockname` syscall should return the same address as to
+/// which the socket was bound to.
+fn test_getsockname_ipv4() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 6789);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+    // Use the supported backlog value to avoid the warning.
+    let backlog = 128;
+
+    unsafe {
+        errno_check(libc::listen(sockfd, backlog));
+    }
+
+    let sockname =
+        sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V4(sock_addr) = sockname else {
+        // We bound an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+
+    assert_eq!(addr.sin_family, sock_addr.sin_family);
+    assert_eq!(addr.sin_port, sock_addr.sin_port);
+    assert_eq!(addr.sin_addr.s_addr, sock_addr.sin_addr.s_addr);
+}
+
+/// Test the `getsockname` syscall on an IPv4 socket which is bound
+/// but the port was zero.
+/// The `getsockname` syscall should return the same address as to
+/// which the socket was bound to but the port should be non-zero.
+fn test_getsockname_ipv4_random_port() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    // Use zero-port to let the OS choose a free port to bind to.
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+    // Use the supported backlog value to avoid the warning.
+    let backlog = 128;
+
+    unsafe {
+        errno_check(libc::listen(sockfd, backlog));
+    }
+
+    let sockname =
+        sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V4(sock_addr) = sockname else {
+        // We bound an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+    assert_eq!(addr.sin_family, sock_addr.sin_family);
+    // The bound port must not be the zero port.
+    assert!(sock_addr.sin_port > 0);
+    assert_eq!(addr.sin_addr.s_addr, sock_addr.sin_addr.s_addr);
+}
+
+/// Test the `getsockname` syscall on an IPv4 socket which is not bound.
+/// The `getsockname` syscall should return 0.0.0.0:0
+fn test_getsockname_ipv4_unbound() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+
+    let sockname =
+        sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
+
+    // Libc representation of an unspecified IPv4 address with zero port.
+    let addr = net::ipv4_sock_addr([0, 0, 0, 0], 0);
+    let LibcSocketAddr::V4(sock_addr) = sockname else {
+        // We bound an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+
+    assert_eq!(addr.sin_family, sock_addr.sin_family);
+    assert_eq!(addr.sin_port, sock_addr.sin_port);
+    assert_eq!(addr.sin_addr.s_addr, sock_addr.sin_addr.s_addr);
+}
+
+/// Test the `getsockname` syscall on an IPv6 socket which is bound.
+/// The `getsockname` syscall should return the same address as to
+/// which the socket was bound to.
+fn test_getsockname_ipv6() {
+    let sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET6, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv6_sock_addr(net::IPV6_LOCALHOST, 1234);
+    unsafe {
+        errno_check(libc::bind(
+            sockfd,
+            (&addr as *const libc::sockaddr_in6).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in6>() as libc::socklen_t,
+        ));
+    }
+    // Use the supported backlog value to avoid the warning.
+    let backlog = 128;
+
+    unsafe {
+        errno_check(libc::listen(sockfd, backlog));
+    }
+
+    let sockname =
+        sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V6(sock_addr) = sockname else {
+        // We bound an IPv6 address so we also expect
+        // an IPv6 address to be returned.
+        panic!()
+    };
+
+    assert_eq!(addr.sin6_family, sock_addr.sin6_family);
+    assert_eq!(addr.sin6_port, sock_addr.sin6_port);
+    assert_eq!(addr.sin6_flowinfo, sock_addr.sin6_flowinfo);
+    assert_eq!(addr.sin6_scope_id, sock_addr.sin6_scope_id);
+    assert_eq!(addr.sin6_addr.s6_addr, sock_addr.sin6_addr.s6_addr);
+}
+
 /// Set a socket option. It's the caller's responsibility to ensure that `T` is
 /// associated with the given socket option.
 ///
@@ -192,3 +329,36 @@ fn setsockopt<T>(
     })?;
     Ok(())
 }
+
+enum LibcSocketAddr {
+    V4(libc::sockaddr_in),
+    V6(libc::sockaddr_in6),
+}
+
+/// Wraps a call to a platform function that returns a socket address.
+/// This is very much the same as the function with the same name in the
+/// standard library implementation.
+fn sockname<F>(f: F) -> io::Result<LibcSocketAddr>
+where
+    F: FnOnce(*mut libc::sockaddr, *mut libc::socklen_t) -> libc::c_int,
+{
+    let mut storage = MaybeUninit::<libc::sockaddr_storage>::zeroed();
+    let mut len = size_of::<libc::sockaddr_storage>() as libc::socklen_t;
+    errno_result(f(storage.as_mut_ptr().cast(), &mut len))?;
+    // SAFETY:
+    // The caller guarantees that the storage has been successfully initialized
+    // and its size written to `len` if `f` returns a success.
+    unsafe {
+        match (*storage.as_ptr()).ss_family as libc::c_int {
+            libc::AF_INET => {
+                assert!(len as usize >= size_of::<libc::sockaddr_in>());
+                Ok(LibcSocketAddr::V4(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in)))
+            }
+            libc::AF_INET6 => {
+                assert!(len as usize >= size_of::<libc::sockaddr_in6>());
+                Ok(LibcSocketAddr::V6(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in6)))
+            }
+            _ => Err(io::Error::new(ErrorKind::InvalidInput, "invalid argument")),
+        }
+    }
+}
diff --git a/src/tools/miri/tests/pass-dep/shims/socket.rs b/src/tools/miri/tests/pass-dep/shims/socket.rs
index 8a1cd68e5d0c..787dd5e27399 100644
--- a/src/tools/miri/tests/pass-dep/shims/socket.rs
+++ b/src/tools/miri/tests/pass-dep/shims/socket.rs
@@ -9,9 +9,9 @@ fn main() {
 }
 
 fn create_ipv4_listener() {
-    let _listener_ipv4 = TcpListener::bind("127.0.0.1:3456").unwrap();
+    let _listener_ipv4 = TcpListener::bind("127.0.0.1:0").unwrap();
 }
 
 fn create_ipv6_listener() {
-    let _listener_ipv6 = TcpListener::bind("[::1]:2345").unwrap();
+    let _listener_ipv6 = TcpListener::bind("[::1]:0").unwrap();
 }

From 24d86b5f2b69665d6b6c0868239e37da221f2e19 Mon Sep 17 00:00:00 2001
From: Bhavya Gautam <gautambhavya899@gmail.com>
Date: Tue, 3 Mar 2026 06:35:43 +0000
Subject: [PATCH 0462/1059] Fix rust build failure for vxworks

---
 library/std/build.rs                          | 24 +++++++++++++++
 library/std/src/os/vxworks/fs.rs              | 30 +++++++++++++++++++
 library/std/src/sys/fs/unix.rs                | 18 ++++++++---
 src/doc/rustc/src/platform-support/vxworks.md |  6 ++++
 4 files changed, 74 insertions(+), 4 deletions(-)

diff --git a/library/std/build.rs b/library/std/build.rs
index c0a6e30b3808..5f2e441bf7d8 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -79,4 +79,28 @@ fn main() {
     println!("cargo:rustc-cfg=backtrace_in_libstd");
 
     println!("cargo:rustc-env=STD_ENV_ARCH={}", env::var("CARGO_CFG_TARGET_ARCH").unwrap());
+
+    println!("cargo:rustc-check-cfg=cfg(vxworks_lt_25_09)");
+
+    if target_os == "vxworks" {
+        match vxworks_version_code() {
+            Some((major, minor)) if (major, minor) < (25, 9) => {
+                println!("cargo:rustc-cfg=vxworks_lt_25_09");
+            }
+            _ => {}
+        }
+    }
+}
+
+/// Retrieve the VxWorks release version from the environment variable set by the VxWorks build
+/// environment, in `(minor, patch)` form.
+fn vxworks_version_code() -> Option<(u32, u32)> {
+    let version = env::var("WIND_RELEASE_ID").ok()?;
+
+    let mut pieces = version.trim().split(['.']);
+
+    let major: u32 = pieces.next().and_then(|x| x.parse().ok()).unwrap_or(0);
+    let minor: u32 = pieces.next().and_then(|x| x.parse().ok()).unwrap_or(0);
+
+    Some((major, minor))
 }
diff --git a/library/std/src/os/vxworks/fs.rs b/library/std/src/os/vxworks/fs.rs
index b88ed19b067a..a21748ce9fe0 100644
--- a/library/std/src/os/vxworks/fs.rs
+++ b/library/std/src/os/vxworks/fs.rs
@@ -69,24 +69,54 @@ fn st_rdev(&self) -> u64 {
     fn st_size(&self) -> u64 {
         self.as_inner().as_inner().st_size as u64
     }
+    #[cfg(vxworks_lt_25_09)]
     fn st_atime(&self) -> i64 {
         self.as_inner().as_inner().st_atime as i64
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_atime(&self) -> i64 {
+        self.as_inner().as_inner().st_atim.tv_sec as i64
+    }
+    #[cfg(vxworks_lt_25_09)]
     fn st_atime_nsec(&self) -> i64 {
         0
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_atime_nsec(&self) -> i64 {
+        self.as_inner().as_inner().st_atim.tv_nsec as i64
+    }
+    #[cfg(vxworks_lt_25_09)]
     fn st_mtime(&self) -> i64 {
         self.as_inner().as_inner().st_mtime as i64
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_mtime(&self) -> i64 {
+        self.as_inner().as_inner().st_mtim.tv_sec as i64
+    }
+    #[cfg(vxworks_lt_25_09)]
     fn st_mtime_nsec(&self) -> i64 {
         0
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_mtime_nsec(&self) -> i64 {
+        self.as_inner().as_inner().st_mtim.tv_nsec as i64
+    }
+    #[cfg(vxworks_lt_25_09)]
     fn st_ctime(&self) -> i64 {
         self.as_inner().as_inner().st_ctime as i64
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_ctime(&self) -> i64 {
+        self.as_inner().as_inner().st_ctim.tv_sec as i64
+    }
+    #[cfg(vxworks_lt_25_09)]
     fn st_ctime_nsec(&self) -> i64 {
         0
     }
+    #[cfg(not(vxworks_lt_25_09))]
+    fn st_ctime_nsec(&self) -> i64 {
+        self.as_inner().as_inner().st_ctim.tv_nsec as i64
+    }
     fn st_blksize(&self) -> u64 {
         self.as_inner().as_inner().st_blksize as u64
     }
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 7db474544f04..2a8571871b73 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -634,7 +634,7 @@ pub fn modified(&self) -> io::Result<SystemTime> {
     }
 
     #[cfg(any(
-        target_os = "vxworks",
+        all(target_os = "vxworks", vxworks_lt_25_09),
         target_os = "espidf",
         target_os = "vita",
         target_os = "rtems",
@@ -643,7 +643,12 @@ pub fn modified(&self) -> io::Result<SystemTime> {
         SystemTime::new(self.stat.st_mtime as i64, 0)
     }
 
-    #[cfg(any(target_os = "horizon", target_os = "hurd", target_os = "nuttx"))]
+    #[cfg(any(
+        target_os = "horizon",
+        target_os = "hurd",
+        target_os = "nuttx",
+        all(target_os = "vxworks", not(vxworks_lt_25_09))
+    ))]
     pub fn modified(&self) -> io::Result<SystemTime> {
         SystemTime::new(self.stat.st_mtim.tv_sec as i64, self.stat.st_mtim.tv_nsec as i64)
     }
@@ -669,7 +674,7 @@ pub fn accessed(&self) -> io::Result<SystemTime> {
     }
 
     #[cfg(any(
-        target_os = "vxworks",
+        all(target_os = "vxworks", vxworks_lt_25_09),
         target_os = "espidf",
         target_os = "vita",
         target_os = "rtems"
@@ -678,7 +683,12 @@ pub fn accessed(&self) -> io::Result<SystemTime> {
         SystemTime::new(self.stat.st_atime as i64, 0)
     }
 
-    #[cfg(any(target_os = "horizon", target_os = "hurd", target_os = "nuttx"))]
+    #[cfg(any(
+        target_os = "horizon",
+        target_os = "hurd",
+        target_os = "nuttx",
+        all(target_os = "vxworks", not(vxworks_lt_25_09))
+    ))]
     pub fn accessed(&self) -> io::Result<SystemTime> {
         SystemTime::new(self.stat.st_atim.tv_sec as i64, self.stat.st_atim.tv_nsec as i64)
     }
diff --git a/src/doc/rustc/src/platform-support/vxworks.md b/src/doc/rustc/src/platform-support/vxworks.md
index 091c757a2ee3..0cf3822f759e 100644
--- a/src/doc/rustc/src/platform-support/vxworks.md
+++ b/src/doc/rustc/src/platform-support/vxworks.md
@@ -28,6 +28,12 @@ Target triplets available:
 
 The minimum supported version is VxWorks 7.
 
+### Environment
+
+#### `WIND_RELEASE_ID`
+
+In VxWorks build environment, the environment variable `WIND_RELEASE_ID` indicates the VxWorks release version used for the build. The `WIND_RELEASE_ID` can be used to conditionally compile features/code or handle version specific behaviour.
+
 ## Building
 
 Rust for each target can be cross-compiled with its specific target vsb configuration. Std support is added but not yet fully tested.

From 67633abc1731f64fa6e08a804c085b2b0f89a02c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:07:38 -0500
Subject: [PATCH 0463/1059] support: Add `Hexi` for printing integers in hex

Add a wrapper similar to `Hexf` to print integers with proper padding.
---
 .../libm/src/math/support/hex_float.rs        | 49 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/library/compiler-builtins/libm/src/math/support/hex_float.rs b/library/compiler-builtins/libm/src/math/support/hex_float.rs
index 81f6b86686c4..fd070e6bf4da 100644
--- a/library/compiler-builtins/libm/src/math/support/hex_float.rs
+++ b/library/compiler-builtins/libm/src/math/support/hex_float.rs
@@ -328,7 +328,7 @@ const fn hex_digit(c: u8) -> Option<u8> {
 mod hex_fmt {
     use core::fmt;
 
-    use crate::support::Float;
+    use crate::support::{Float, Int};
 
     /// Format a floating point number as its IEEE hex (`%a`) representation.
     pub struct Hexf<F>(pub F);
@@ -456,6 +456,53 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             }
         }
     }
+
+    pub struct Hexi<F>(pub F);
+
+    impl<I: Int> fmt::LowerHex for Hexi<I> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            cfg_if! {
+                if #[cfg(feature = "compiler-builtins")] {
+                    let _ = f;
+                    unimplemented!()
+                } else {
+                    write!(f, "{:#0width$x}", self.0, width = ((I::BITS / 4) + 2) as usize)
+                }
+            }
+        }
+    }
+
+    impl<T> fmt::Debug for Hexi<T>
+    where
+        Hexi<T>: fmt::LowerHex,
+    {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            cfg_if! {
+                if #[cfg(feature = "compiler-builtins")] {
+                    let _ = f;
+                    unimplemented!()
+                } else {
+                    fmt::LowerHex::fmt(self, f)
+                }
+            }
+        }
+    }
+
+    impl<T> fmt::Display for Hexi<T>
+    where
+        Hexi<T>: fmt::LowerHex,
+    {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            cfg_if! {
+                if #[cfg(feature = "compiler-builtins")] {
+                    let _ = f;
+                    unimplemented!()
+                } else {
+                    fmt::LowerHex::fmt(self, f)
+                }
+            }
+        }
+    }
 }
 
 #[cfg(any(test, feature = "unstable-public-internals"))]

From ccd10428843e84e20fb51c2c1a08f107836a853e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:09:37 -0500
Subject: [PATCH 0464/1059] support: Add different NaN types to the `Float`
 trait

Make `Float::NAN` a qNaN, add sNaNs, and add operations to check whether
a NaN is quiet or signaling.

The MIPS values are checked against https://gcc.godbolt.org/z/1bhsd5ana.
---
 .../libm-test/src/f8_impl.rs                  |   9 +-
 .../libm/src/math/support/float_traits.rs     | 126 +++++++++++++++++-
 2 files changed, 127 insertions(+), 8 deletions(-)

diff --git a/library/compiler-builtins/libm-test/src/f8_impl.rs b/library/compiler-builtins/libm-test/src/f8_impl.rs
index 905c7d7fde92..9f19f518e2a3 100644
--- a/library/compiler-builtins/libm-test/src/f8_impl.rs
+++ b/library/compiler-builtins/libm-test/src/f8_impl.rs
@@ -25,12 +25,16 @@ impl Float for f8 {
     const NEG_ZERO: Self = Self(0b1_0000_000);
     const ONE: Self = Self(0b0_0111_000);
     const NEG_ONE: Self = Self(0b1_0111_000);
-    const MAX: Self = Self(0b0_1110_111);
-    const MIN: Self = Self(0b1_1110_111);
     const INFINITY: Self = Self(0b0_1111_000);
     const NEG_INFINITY: Self = Self(0b1_1111_000);
+    const MAX: Self = Self(0b0_1110_111);
+    const MIN: Self = Self(0b1_1110_111);
+
     const NAN: Self = Self(0b0_1111_100);
+    const SNAN: Self = Self(0b0_1111_001);
     const NEG_NAN: Self = Self(0b1_1111_100);
+    const NEG_SNAN: Self = Self(0b1_1111_001);
+
     const MIN_POSITIVE_NORMAL: Self = Self(1 << Self::SIG_BITS);
     // FIXME: incorrect values
     const EPSILON: Self = Self::ZERO;
@@ -44,6 +48,7 @@ impl Float for f8 {
     const SIG_MASK: Self::Int = 0b0_0000_111;
     const EXP_MASK: Self::Int = 0b0_1111_000;
     const IMPLICIT_BIT: Self::Int = 0b0_0001_000;
+    const SIG_TOP_BIT: Self::Int = Self::IMPLICIT_BIT >> 1;
 
     fn to_bits(self) -> Self::Int {
         self.0
diff --git a/library/compiler-builtins/libm/src/math/support/float_traits.rs b/library/compiler-builtins/libm/src/math/support/float_traits.rs
index 9f2ce532ed17..944546601c9c 100644
--- a/library/compiler-builtins/libm/src/math/support/float_traits.rs
+++ b/library/compiler-builtins/libm/src/math/support/float_traits.rs
@@ -2,6 +2,12 @@
 
 use super::int_traits::{CastFrom, Int, MinInt};
 
+/// Whether MIPS sNaN/qNaNs should be used.
+///
+/// Note that MIPS is doing some general migration here, though this is only available on (rare)
+/// modern MIPS hardware per discussion at <https://github.com/WebAssembly/design/issues/976>.
+const MIPS_NAN: bool = cfg!(target_arch = "mips") || cfg!(target_arch = "mips64");
+
 /// Trait for some basic operations on floats
 // #[allow(dead_code)]
 #[allow(dead_code)] // Some constants are only used with tests
@@ -34,10 +40,16 @@ pub trait Float:
     const NEG_ONE: Self;
     const INFINITY: Self;
     const NEG_INFINITY: Self;
-    const NAN: Self;
-    const NEG_NAN: Self;
     const MAX: Self;
     const MIN: Self;
+
+    /// Quiet NaN.
+    const NAN: Self;
+    /// Signaling NaN.
+    const SNAN: Self;
+    const NEG_NAN: Self;
+    const NEG_SNAN: Self;
+
     const EPSILON: Self;
     const PI: Self;
     const NEG_PI: Self;
@@ -84,6 +96,9 @@ pub trait Float:
     /// The implicit bit of the float format
     const IMPLICIT_BIT: Self::Int;
 
+    /// A mask for the top bit of the significand, useful for NaN ops.
+    const SIG_TOP_BIT: Self::Int;
+
     /// Returns `self` transmuted to `Self::Int`
     fn to_bits(self) -> Self::Int;
 
@@ -116,6 +131,24 @@ fn eq_repr(self, rhs: Self) -> bool {
     /// Returns true if the value is NaN.
     fn is_nan(self) -> bool;
 
+    fn is_qnan(self) -> bool {
+        if !self.is_nan() {
+            return false;
+        }
+
+        let top = self.to_bits() & Self::SIG_TOP_BIT;
+
+        if MIPS_NAN {
+            top == Self::Int::ZERO
+        } else {
+            top != Self::Int::ZERO
+        }
+    }
+
+    fn is_snan(self) -> bool {
+        self.is_nan() && !self.is_qnan()
+    }
+
     /// Returns true if the value is +inf or -inf.
     fn is_infinite(self) -> bool;
 
@@ -223,13 +256,28 @@ impl Float for $ty {
             const NEG_ONE: Self = -1.0;
             const INFINITY: Self = Self::INFINITY;
             const NEG_INFINITY: Self = Self::NEG_INFINITY;
-            const NAN: Self = Self::NAN;
-            // NAN isn't guaranteed to be positive but it usually is. We only use this for
-            // tests.
-            const NEG_NAN: Self = $from_bits($to_bits(Self::NAN) | Self::SIGN_MASK);
             const MAX: Self = -Self::MIN;
             // Sign bit set, saturated mantissa, saturated exponent with last bit zeroed
             const MIN: Self = $from_bits(Self::Int::MAX & !(1 << Self::SIG_BITS));
+
+            // The default NaN seems to set one of the top two significand bits on most
+            // platforms (sNaN vs. qNaN). For mips, the significand is all 1s (with the
+            // exception of the signaling bit).
+            const NAN: Self = $from_bits(if MIPS_NAN {
+                Self::EXP_MASK | (Self::SIG_TOP_BIT - 1)
+            } else {
+                Self::EXP_MASK | Self::SIG_TOP_BIT
+            });
+            const SNAN: Self = $from_bits(if MIPS_NAN {
+                Self::EXP_MASK | Self::SIG_MASK
+            } else {
+                Self::EXP_MASK | (Self::SIG_TOP_BIT >> 1)
+            });
+            // NAN isn't guaranteed to be positive but it usually is. We only use these for
+            // tests.
+            const NEG_NAN: Self = $from_bits($to_bits(Self::NAN) | Self::SIGN_MASK);
+            const NEG_SNAN: Self = $from_bits($to_bits(Self::SNAN) | Self::SIGN_MASK);
+
             const EPSILON: Self = <$ty>::EPSILON;
 
             // Exponent is a 1 in the LSB
@@ -246,6 +294,7 @@ impl Float for $ty {
             const SIG_MASK: Self::Int = (1 << Self::SIG_BITS) - 1;
             const EXP_MASK: Self::Int = !(Self::SIGN_MASK | Self::SIG_MASK);
             const IMPLICIT_BIT: Self::Int = 1 << Self::SIG_BITS;
+            const SIG_TOP_BIT: Self::Int = Self::IMPLICIT_BIT >> 1;
 
             fn to_bits(self) -> Self::Int {
                 self.to_bits()
@@ -450,6 +499,17 @@ fn check_f16() {
         assert_eq!(f16::EXP_MAX, 15);
         assert_eq!(f16::EXP_MIN, -14);
         assert_eq!(f16::EXP_MIN_SUBNORM, -24);
+        assert_biteq!(f16::NAN, <f16 as Float>::NAN);
+        // Value of NAN and FLT16_SNAN in C. We don't strictly need to match up, but it is good to
+        // be aware if there are platforms where we don't.
+        if MIPS_NAN {
+            assert_biteq!(f16::NAN, f16::from_bits(0x7fbf));
+            assert_biteq!(f16::SNAN, f16::from_bits(0x7fff));
+        } else {
+            assert_biteq!(f16::NAN, f16::from_bits(0x7e00));
+            assert_biteq!(f16::SNAN, f16::from_bits(0x7d00));
+        }
+        assert!(f16::NAN.is_qnan());
 
         // `exp_unbiased`
         assert_eq!(f16::FRAC_PI_2.exp_unbiased(), 0);
@@ -476,6 +536,21 @@ fn check_f32() {
         assert_eq!(f32::EXP_MAX, 127);
         assert_eq!(f32::EXP_MIN, -126);
         assert_eq!(f32::EXP_MIN_SUBNORM, -149);
+        assert_biteq!(f32::NAN, <f32 as Float>::NAN);
+        // Value of NAN and FLT_SNAN in C. We don't strictly need to match up, but it is good to
+        // be aware if there are platforms where we don't.
+        if MIPS_NAN {
+            assert_biteq!(f32::NAN, f32::from_bits(0x7fbfffff));
+            assert_biteq!(f32::SNAN, f32::from_bits(0x7fffffff));
+        } else {
+            assert_biteq!(f32::NAN, f32::from_bits(0x7fc00000));
+            assert_biteq!(f32::SNAN, f32::from_bits(0x7fa00000));
+        }
+        assert!(f32::NAN.is_qnan());
+        // FIXME(rust-lang/rust#115567): x87 use in `is_snan` quiets the sNaN
+        if !cfg!(x86_no_sse) {
+            assert!(f32::SNAN.is_snan());
+        }
 
         // `exp_unbiased`
         assert_eq!(f32::FRAC_PI_2.exp_unbiased(), 0);
@@ -506,6 +581,21 @@ fn check_f64() {
         assert_eq!(f64::EXP_MAX, 1023);
         assert_eq!(f64::EXP_MIN, -1022);
         assert_eq!(f64::EXP_MIN_SUBNORM, -1074);
+        assert_biteq!(f64::NAN, <f64 as Float>::NAN);
+        // Value of NAN and DBL_SNAN in C. We don't strictly need to match up, but it is good to
+        // be aware if there are platforms where we don't.
+        if MIPS_NAN {
+            assert_biteq!(f64::NAN, f64::from_bits(0x7ff7ffffffffffff));
+            assert_biteq!(f64::SNAN, f64::from_bits(0x7fffffffffffffff));
+        } else {
+            assert_biteq!(f64::NAN, f64::from_bits(0x7ff8000000000000));
+            assert_biteq!(f64::SNAN, f64::from_bits(0x7ff4000000000000));
+        }
+        assert!(f64::NAN.is_qnan());
+        // FIXME(rust-lang/rust#115567): x87 use in `is_snan` quiets the sNaN
+        if !cfg!(x86_no_sse) {
+            assert!(f64::SNAN.is_snan());
+        }
 
         // `exp_unbiased`
         assert_eq!(f64::FRAC_PI_2.exp_unbiased(), 0);
@@ -537,6 +627,30 @@ fn check_f128() {
         assert_eq!(f128::EXP_MAX, 16383);
         assert_eq!(f128::EXP_MIN, -16382);
         assert_eq!(f128::EXP_MIN_SUBNORM, -16494);
+        assert_biteq!(f128::NAN, <f128 as Float>::NAN);
+        // Value of NAN and FLT128_SNAN in C. We don't strictly need to match up, but it is good to
+        // be aware if there are platforms where we don't.
+        if MIPS_NAN {
+            assert_biteq!(
+                f128::NAN,
+                f128::from_bits(0x7fff7fffffffffffffffffffffffffff)
+            );
+            assert_biteq!(
+                f128::SNAN,
+                f128::from_bits(0x7fffffffffffffffffffffffffffffff)
+            );
+        } else {
+            assert_biteq!(
+                f128::NAN,
+                f128::from_bits(0x7fff8000000000000000000000000000)
+            );
+            assert_biteq!(
+                f128::SNAN,
+                f128::from_bits(0x7fff4000000000000000000000000000)
+            );
+        }
+        assert!(f128::NAN.is_qnan());
+        assert!(f128::SNAN.is_snan());
 
         // `exp_unbiased`
         assert_eq!(f128::FRAC_PI_2.exp_unbiased(), 0);

From 3a352497c3ac93654abaa8a376fc14ac448bbfa2 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:05:55 -0500
Subject: [PATCH 0465/1059] support: Print sNaN or qNaN for hex floats

Give more descriptive output in tests since we sometimes need to treat
these differently. We still don't parse `sNaN`/`qNaN` for now, though we
could in the future.
---
 .../libm/src/math/support/hex_float.rs        | 51 ++++++++++++++++---
 1 file changed, 44 insertions(+), 7 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/support/hex_float.rs b/library/compiler-builtins/libm/src/math/support/hex_float.rs
index fd070e6bf4da..5be0d3159de3 100644
--- a/library/compiler-builtins/libm/src/math/support/hex_float.rs
+++ b/library/compiler-builtins/libm/src/math/support/hex_float.rs
@@ -340,8 +340,10 @@ pub(super) fn fmt_any_hex<F: Float>(x: &F, f: &mut fmt::Formatter<'_>) -> fmt::R
             write!(f, "-")?;
         }
 
-        if x.is_nan() {
-            return write!(f, "NaN");
+        if x.is_snan() {
+            return write!(f, "sNaN");
+        } else if x.is_nan() {
+            return write!(f, "qNaN");
         } else if x.is_infinite() {
             return write!(f, "inf");
         } else if *x == F::ZERO {
@@ -511,6 +513,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 #[cfg(test)]
 mod parse_tests {
     extern crate std;
+    use std::string::String;
     use std::{format, println};
 
     use super::*;
@@ -559,6 +562,16 @@ fn rounding_properties(s: &str) -> Result<(), HexFloatParseError> {
         }
         Ok(())
     }
+
+    #[cfg_attr(not(f16_enabled), expect(unused))]
+    pub fn canonicalize_snan_str(s: String) -> String {
+        if s.contains("sNaN") || s.contains("qNaN") {
+            s.replace("sNaN", "NaN").replace("qNaN", "NaN")
+        } else {
+            s
+        }
+    }
+
     #[test]
     #[cfg(f16_enabled)]
     fn test_rounding() {
@@ -566,7 +579,11 @@ fn test_rounding() {
         for i in -n..n {
             let u = i.rotate_right(11) as u32;
             let s = format!("{}", Hexf(f32::from_bits(u)));
-            assert!(rounding_properties(&s).is_ok());
+            let s = canonicalize_snan_str(s);
+            match rounding_properties(&s) {
+                Ok(()) => (),
+                Err(e) => panic!("failed rounding properties for `{s}`: {e:?}"),
+            }
         }
     }
 
@@ -1099,8 +1116,11 @@ fn test_f16() {
         use std::format;
         // Exhaustively check that `f16` roundtrips.
         for x in 0..=u16::MAX {
+            use super::parse_tests::canonicalize_snan_str;
+
             let f = f16::from_bits(x);
             let s = format!("{}", Hexf(f));
+            let s = canonicalize_snan_str(s);
             let from_s = hf16(&s);
 
             if f.is_nan() && from_s.is_nan() {
@@ -1119,6 +1139,8 @@ fn test_f16() {
     #[cfg(f16_enabled)]
     fn test_f16_to_f32() {
         use std::format;
+
+        use super::parse_tests::canonicalize_snan_str;
         // Exhaustively check that these are equivalent for all `f16`:
         //  - `f16 -> f32`
         //  - `f16 -> str -> f32`
@@ -1127,8 +1149,10 @@ fn test_f16_to_f32() {
         for x in 0..=u16::MAX {
             let f16 = f16::from_bits(x);
             let s16 = format!("{}", Hexf(f16));
+            let s16 = canonicalize_snan_str(s16);
             let f32 = f16 as f32;
             let s32 = format!("{}", Hexf(f32));
+            let s32 = canonicalize_snan_str(s32);
 
             let a = hf32(&s16);
             let b = hf32(&s32);
@@ -1169,8 +1193,17 @@ fn spot_checks() {
         assert_eq!(Hexf(f32::NEG_ZERO).to_string(), "-0x0p+0");
         assert_eq!(Hexf(f64::NEG_ZERO).to_string(), "-0x0p+0");
 
-        assert_eq!(Hexf(f32::NAN).to_string(), "NaN");
-        assert_eq!(Hexf(f64::NAN).to_string(), "NaN");
+        assert_eq!(Hexf(f32::NAN).to_string(), "qNaN");
+        assert_eq!(Hexf(f64::NAN).to_string(), "qNaN");
+        assert_eq!(Hexf(f32::NEG_NAN).to_string(), "-qNaN");
+        assert_eq!(Hexf(f64::NEG_NAN).to_string(), "-qNaN");
+        if !cfg!(x86_no_sse) {
+            // FIXME(rust-lang/rust#115567): calls quiet the sNaN
+            assert_eq!(Hexf(f32::SNAN).to_string(), "sNaN");
+            assert_eq!(Hexf(f64::SNAN).to_string(), "sNaN");
+            assert_eq!(Hexf(f32::NEG_SNAN).to_string(), "-sNaN");
+            assert_eq!(Hexf(f64::NEG_SNAN).to_string(), "-sNaN");
+        }
 
         assert_eq!(Hexf(f32::INFINITY).to_string(), "inf");
         assert_eq!(Hexf(f64::INFINITY).to_string(), "inf");
@@ -1184,7 +1217,9 @@ fn spot_checks() {
             assert_eq!(Hexf(f16::MIN).to_string(), "-0x1.ffcp+15");
             assert_eq!(Hexf(f16::ZERO).to_string(), "0x0p+0");
             assert_eq!(Hexf(f16::NEG_ZERO).to_string(), "-0x0p+0");
-            assert_eq!(Hexf(f16::NAN).to_string(), "NaN");
+            assert_eq!(Hexf(f16::NAN).to_string(), "qNaN");
+            assert_eq!(Hexf(f16::SNAN).to_string(), "sNaN");
+            assert_eq!(Hexf(f16::NEG_NAN).to_string(), "-qNaN");
             assert_eq!(Hexf(f16::INFINITY).to_string(), "inf");
             assert_eq!(Hexf(f16::NEG_INFINITY).to_string(), "-inf");
         }
@@ -1201,7 +1236,9 @@ fn spot_checks() {
             );
             assert_eq!(Hexf(f128::ZERO).to_string(), "0x0p+0");
             assert_eq!(Hexf(f128::NEG_ZERO).to_string(), "-0x0p+0");
-            assert_eq!(Hexf(f128::NAN).to_string(), "NaN");
+            assert_eq!(Hexf(f128::NAN).to_string(), "qNaN");
+            assert_eq!(Hexf(f128::SNAN).to_string(), "sNaN");
+            assert_eq!(Hexf(f128::NEG_NAN).to_string(), "-qNaN");
             assert_eq!(Hexf(f128::INFINITY).to_string(), "inf");
             assert_eq!(Hexf(f128::NEG_INFINITY).to_string(), "-inf");
         }

From 7a698be60580b1e9d68620e4ca3a8517eed654f5 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 5 Mar 2026 19:11:20 -0500
Subject: [PATCH 0466/1059] min,max: Add tests for signaling NaNs and update
 documentation

We do handle signaling NaNs properly, with the exception of raising
exceptions as IEEE 754 requires. Add tests to this effect for
`fmin`, `fminimum`, `fminimum_num`, and the max variants.
---
 .../libm/src/math/fmin_fmax.rs                | 109 ++++++++++++--
 .../libm/src/math/fminimum_fmaximum.rs        | 137 +++++++++++++-----
 .../libm/src/math/fminimum_fmaximum_num.rs    | 115 +++++++++++++--
 .../libm/src/math/generic/fmax.rs             |  10 +-
 .../libm/src/math/generic/fmaximum.rs         |   3 +-
 .../libm/src/math/generic/fmaximum_num.rs     |   3 +-
 .../libm/src/math/generic/fmin.rs             |  10 +-
 .../libm/src/math/generic/fminimum.rs         |   3 +-
 .../libm/src/math/generic/fminimum_num.rs     |   3 +-
 9 files changed, 330 insertions(+), 63 deletions(-)

diff --git a/library/compiler-builtins/libm/src/math/fmin_fmax.rs b/library/compiler-builtins/libm/src/math/fmin_fmax.rs
index c4c1b0435dd2..ead9e6599f1b 100644
--- a/library/compiler-builtins/libm/src/math/fmin_fmax.rs
+++ b/library/compiler-builtins/libm/src/math/fmin_fmax.rs
@@ -77,9 +77,12 @@ pub fn fmaxf128(x: f128, y: f128) -> f128 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::support::hex_float::Hexi;
     use crate::support::{Float, Hexf};
 
     fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
+        // Note that (YaN, sNaN) and (sNaN, YaN) results differ from 754-2008. This is intentional,
+        // see comments in the generic implementations.
         let cases = [
             (F::ZERO, F::ZERO, F::ZERO),
             (F::ZERO, F::ONE, F::ZERO),
@@ -88,6 +91,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ZERO, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::ZERO, F::NAN, F::ZERO),
             (F::ZERO, F::NEG_NAN, F::ZERO),
+            (F::ZERO, F::SNAN, F::ZERO),
+            (F::ZERO, F::NEG_SNAN, F::ZERO),
             (F::NEG_ZERO, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ZERO, F::ONE, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_ONE, F::NEG_ONE),
@@ -95,6 +100,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ZERO, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_ZERO, F::NAN, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_NAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::SNAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::NEG_SNAN, F::NEG_ZERO),
             (F::ONE, F::ZERO, F::ZERO),
             (F::ONE, F::NEG_ZERO, F::NEG_ZERO),
             (F::ONE, F::ONE, F::ONE),
@@ -103,6 +110,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ONE, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::ONE, F::NAN, F::ONE),
             (F::ONE, F::NEG_NAN, F::ONE),
+            (F::ONE, F::SNAN, F::ONE),
+            (F::ONE, F::NEG_SNAN, F::ONE),
             (F::NEG_ONE, F::ZERO, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_ZERO, F::NEG_ONE),
             (F::NEG_ONE, F::ONE, F::NEG_ONE),
@@ -111,6 +120,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ONE, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_ONE, F::NAN, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_NAN, F::NEG_ONE),
+            (F::NEG_ONE, F::SNAN, F::NEG_ONE),
+            (F::NEG_ONE, F::NEG_SNAN, F::NEG_ONE),
             (F::INFINITY, F::ZERO, F::ZERO),
             (F::INFINITY, F::NEG_ZERO, F::NEG_ZERO),
             (F::INFINITY, F::ONE, F::ONE),
@@ -119,6 +130,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::INFINITY, F::NAN, F::INFINITY),
             (F::INFINITY, F::NEG_NAN, F::INFINITY),
+            (F::INFINITY, F::SNAN, F::INFINITY),
+            (F::INFINITY, F::NEG_SNAN, F::INFINITY),
             (F::NEG_INFINITY, F::ZERO, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_ZERO, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::ONE, F::NEG_INFINITY),
@@ -127,6 +140,8 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NAN, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_NAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::SNAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::NEG_SNAN, F::NEG_INFINITY),
             (F::NAN, F::ZERO, F::ZERO),
             (F::NAN, F::NEG_ZERO, F::NEG_ZERO),
             (F::NAN, F::ONE, F::ONE),
@@ -140,6 +155,18 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_NAN, F::NEG_ONE, F::NEG_ONE),
             (F::NEG_NAN, F::INFINITY, F::INFINITY),
             (F::NEG_NAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::SNAN, F::ZERO, F::ZERO),
+            (F::SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::SNAN, F::ONE, F::ONE),
+            (F::SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::SNAN, F::INFINITY, F::INFINITY),
+            (F::SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::NEG_SNAN, F::ZERO, F::ZERO),
+            (F::NEG_SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::NEG_SNAN, F::ONE, F::ONE),
+            (F::NEG_SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::NEG_SNAN, F::INFINITY, F::INFINITY),
+            (F::NEG_SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
         ];
 
         for (x, y, res) in cases {
@@ -147,12 +174,29 @@ fn fmin_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             assert_biteq!(val, res, "fmin({}, {})", Hexf(x), Hexf(y));
         }
 
-        // Ordering between zeros and NaNs does not matter
+        // Ordering between zeros does not matter
         assert_eq!(f(F::ZERO, F::NEG_ZERO), F::ZERO);
         assert_eq!(f(F::NEG_ZERO, F::ZERO), F::ZERO);
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+
+        // Selection between NaNs does not matter, it just must be quiet
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        // These operations should technically return a qnan, but LLVM optimizes out our
+        // `* 1.0` canonicalization.
+        assert!(f(F::NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::SNAN).is_nan());
+        assert!(f(F::SNAN, F::NAN).is_nan());
+        assert!(f(F::SNAN, F::NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN).is_nan());
     }
 
     #[test]
@@ -186,6 +230,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ZERO, F::NEG_INFINITY, F::ZERO),
             (F::ZERO, F::NAN, F::ZERO),
             (F::ZERO, F::NEG_NAN, F::ZERO),
+            (F::ZERO, F::SNAN, F::ZERO),
+            (F::ZERO, F::NEG_SNAN, F::ZERO),
             (F::NEG_ZERO, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ZERO, F::ONE, F::ONE),
             (F::NEG_ZERO, F::NEG_ONE, F::NEG_ZERO),
@@ -193,6 +239,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ZERO, F::NEG_INFINITY, F::NEG_ZERO),
             (F::NEG_ZERO, F::NAN, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_NAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::SNAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::NEG_SNAN, F::NEG_ZERO),
             (F::ONE, F::ZERO, F::ONE),
             (F::ONE, F::NEG_ZERO, F::ONE),
             (F::ONE, F::ONE, F::ONE),
@@ -201,6 +249,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ONE, F::NEG_INFINITY, F::ONE),
             (F::ONE, F::NAN, F::ONE),
             (F::ONE, F::NEG_NAN, F::ONE),
+            (F::ONE, F::SNAN, F::ONE),
+            (F::ONE, F::NEG_SNAN, F::ONE),
             (F::NEG_ONE, F::ZERO, F::ZERO),
             (F::NEG_ONE, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ONE, F::ONE, F::ONE),
@@ -209,6 +259,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ONE, F::NEG_INFINITY, F::NEG_ONE),
             (F::NEG_ONE, F::NAN, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_NAN, F::NEG_ONE),
+            (F::NEG_ONE, F::SNAN, F::NEG_ONE),
+            (F::NEG_ONE, F::NEG_SNAN, F::NEG_ONE),
             (F::INFINITY, F::ZERO, F::INFINITY),
             (F::INFINITY, F::NEG_ZERO, F::INFINITY),
             (F::INFINITY, F::ONE, F::INFINITY),
@@ -217,6 +269,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::INFINITY, F::NEG_INFINITY, F::INFINITY),
             (F::INFINITY, F::NAN, F::INFINITY),
             (F::INFINITY, F::NEG_NAN, F::INFINITY),
+            (F::INFINITY, F::SNAN, F::INFINITY),
+            (F::INFINITY, F::NEG_SNAN, F::INFINITY),
             (F::NEG_INFINITY, F::ZERO, F::ZERO),
             (F::NEG_INFINITY, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_INFINITY, F::ONE, F::ONE),
@@ -225,6 +279,8 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NAN, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_NAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::SNAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::NEG_SNAN, F::NEG_INFINITY),
             (F::NAN, F::ZERO, F::ZERO),
             (F::NAN, F::NEG_ZERO, F::NEG_ZERO),
             (F::NAN, F::ONE, F::ONE),
@@ -238,19 +294,54 @@ fn fmax_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_NAN, F::NEG_ONE, F::NEG_ONE),
             (F::NEG_NAN, F::INFINITY, F::INFINITY),
             (F::NEG_NAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::SNAN, F::ZERO, F::ZERO),
+            (F::SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::SNAN, F::ONE, F::ONE),
+            (F::SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::SNAN, F::INFINITY, F::INFINITY),
+            (F::SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::NEG_SNAN, F::ZERO, F::ZERO),
+            (F::NEG_SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::NEG_SNAN, F::ONE, F::ONE),
+            (F::NEG_SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::NEG_SNAN, F::INFINITY, F::INFINITY),
+            (F::NEG_SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
         ];
 
         for (x, y, res) in cases {
             let val = f(x, y);
-            assert_biteq!(val, res, "fmax({}, {})", Hexf(x), Hexf(y));
+            assert_biteq!(
+                val,
+                res,
+                "fmax({}, {}) ({}, {})",
+                Hexf(x),
+                Hexf(y),
+                Hexi(x.to_bits()),
+                Hexi(y.to_bits()),
+            );
         }
 
-        // Ordering between zeros and NaNs does not matter
+        // Ordering between zeros
         assert_eq!(f(F::ZERO, F::NEG_ZERO), F::ZERO);
         assert_eq!(f(F::NEG_ZERO, F::ZERO), F::ZERO);
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+
+        // Selection between NaNs does not matter, it just must be quiet
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        assert!(f(F::NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::SNAN).is_nan());
+        assert!(f(F::SNAN, F::NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::SNAN, F::SNAN).is_nan());
     }
 
     #[test]
diff --git a/library/compiler-builtins/libm/src/math/fminimum_fmaximum.rs b/library/compiler-builtins/libm/src/math/fminimum_fmaximum.rs
index a3c9c9c3991b..ffc724e3a8d7 100644
--- a/library/compiler-builtins/libm/src/math/fminimum_fmaximum.rs
+++ b/library/compiler-builtins/libm/src/math/fminimum_fmaximum.rs
@@ -69,6 +69,7 @@ pub fn fmaximumf128(x: f128, y: f128) -> f128 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::support::hex_float::Hexi;
     use crate::support::{Float, Hexf};
 
     fn fminimum_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
@@ -122,29 +123,63 @@ fn fminimum_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NAN, F::INFINITY, F::NAN),
             (F::NAN, F::NEG_INFINITY, F::NAN),
             (F::NAN, F::NAN, F::NAN),
+            (F::NAN, F::SNAN, F::NAN),
         ];
 
         for (x, y, res) in cases {
             let val = f(x, y);
-            assert_biteq!(val, res, "fminimum({}, {})", Hexf(x), Hexf(y));
+            assert_biteq!(
+                val,
+                res,
+                "fminimum({}, {}) ({}, {})",
+                Hexf(x),
+                Hexf(y),
+                Hexi(x.to_bits()),
+                Hexi(y.to_bits()),
+            );
         }
 
-        // Ordering between NaNs does not matter
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::ZERO, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_ZERO, F::NEG_NAN).is_nan());
-        assert!(f(F::ONE, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_ONE, F::NEG_NAN).is_nan());
-        assert!(f(F::INFINITY, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_INFINITY, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::ZERO).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_ZERO).is_nan());
-        assert!(f(F::NEG_NAN, F::ONE).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_ONE).is_nan());
-        assert!(f(F::NEG_NAN, F::INFINITY).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_INFINITY).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+        // On platforms where operations only return a single canonical NaN (e.g. RISC-V), the
+        // result may not exactly match one of the inputs which is fine.
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::ZERO, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_ZERO, F::NEG_NAN).is_qnan());
+        assert!(f(F::ONE, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_ONE, F::NEG_NAN).is_qnan());
+        assert!(f(F::INFINITY, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_INFINITY, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::ZERO).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_ZERO).is_qnan());
+        assert!(f(F::NEG_NAN, F::ONE).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_ONE).is_qnan());
+        assert!(f(F::NEG_NAN, F::INFINITY).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_INFINITY).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        // These operations should technically return a qnan, but LLVM optimizes out our
+        // `* 1.0` canonicalization.
+        assert!(f(F::INFINITY, F::SNAN,).is_nan());
+        assert!(f(F::NEG_INFINITY, F::SNAN,).is_nan());
+        assert!(f(F::NEG_ONE, F::SNAN,).is_nan());
+        assert!(f(F::NEG_SNAN, F::INFINITY).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_INFINITY).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_ONE).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_ZERO).is_nan());
+        assert!(f(F::NEG_SNAN, F::ONE).is_nan());
+        assert!(f(F::NEG_SNAN, F::ZERO).is_nan());
+        assert!(f(F::NEG_ZERO, F::SNAN,).is_nan());
+        assert!(f(F::ONE, F::SNAN,).is_nan());
+        assert!(f(F::SNAN, F::INFINITY,).is_nan());
+        assert!(f(F::SNAN, F::NEG_INFINITY,).is_nan());
+        assert!(f(F::SNAN, F::NEG_ONE,).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN,).is_nan());
+        assert!(f(F::SNAN, F::NEG_ZERO,).is_nan());
+        assert!(f(F::SNAN, F::ONE,).is_nan());
+        assert!(f(F::SNAN, F::SNAN,).is_nan());
+        assert!(f(F::SNAN, F::ZERO,).is_nan());
+        assert!(f(F::ZERO, F::SNAN,).is_nan());
     }
 
     #[test]
@@ -220,29 +255,63 @@ fn fmaximum_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NAN, F::INFINITY, F::NAN),
             (F::NAN, F::NEG_INFINITY, F::NAN),
             (F::NAN, F::NAN, F::NAN),
+            (F::NAN, F::SNAN, F::NAN),
         ];
 
         for (x, y, res) in cases {
             let val = f(x, y);
-            assert_biteq!(val, res, "fmaximum({}, {})", Hexf(x), Hexf(y));
+            assert_biteq!(
+                val,
+                res,
+                "fmaximum({}, {}) ({}, {})",
+                Hexf(x),
+                Hexf(y),
+                Hexi(x.to_bits()),
+                Hexi(y.to_bits()),
+            );
         }
 
-        // Ordering between NaNs does not matter
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::ZERO, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_ZERO, F::NEG_NAN).is_nan());
-        assert!(f(F::ONE, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_ONE, F::NEG_NAN).is_nan());
-        assert!(f(F::INFINITY, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_INFINITY, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::ZERO).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_ZERO).is_nan());
-        assert!(f(F::NEG_NAN, F::ONE).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_ONE).is_nan());
-        assert!(f(F::NEG_NAN, F::INFINITY).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_INFINITY).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+        // On platforms where operations only return a single canonical NaN (e.g. RISC-V), the
+        // result may not exactly match one of the inputs which is fine.
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::ZERO, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_ZERO, F::NEG_NAN).is_qnan());
+        assert!(f(F::ONE, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_ONE, F::NEG_NAN).is_qnan());
+        assert!(f(F::INFINITY, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_INFINITY, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::ZERO).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_ZERO).is_qnan());
+        assert!(f(F::NEG_NAN, F::ONE).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_ONE).is_qnan());
+        assert!(f(F::NEG_NAN, F::INFINITY).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_INFINITY).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        // These operations should technically return a qnan, but LLVM optimizes out our
+        // `* 1.0` canonicalization.
+        assert!(f(F::INFINITY, F::SNAN,).is_nan());
+        assert!(f(F::NEG_INFINITY, F::SNAN,).is_nan());
+        assert!(f(F::NEG_ONE, F::SNAN,).is_nan());
+        assert!(f(F::NEG_SNAN, F::INFINITY).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_INFINITY).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_ONE).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_ZERO).is_nan());
+        assert!(f(F::NEG_SNAN, F::ONE).is_nan());
+        assert!(f(F::NEG_SNAN, F::ZERO).is_nan());
+        assert!(f(F::NEG_ZERO, F::SNAN,).is_nan());
+        assert!(f(F::ONE, F::SNAN,).is_nan());
+        assert!(f(F::SNAN, F::INFINITY,).is_nan());
+        assert!(f(F::SNAN, F::NEG_INFINITY,).is_nan());
+        assert!(f(F::SNAN, F::NEG_ONE,).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN,).is_nan());
+        assert!(f(F::SNAN, F::NEG_ZERO,).is_nan());
+        assert!(f(F::SNAN, F::ONE,).is_nan());
+        assert!(f(F::SNAN, F::SNAN,).is_nan());
+        assert!(f(F::SNAN, F::ZERO,).is_nan());
+        assert!(f(F::ZERO, F::SNAN,).is_nan());
     }
 
     #[test]
diff --git a/library/compiler-builtins/libm/src/math/fminimum_fmaximum_num.rs b/library/compiler-builtins/libm/src/math/fminimum_fmaximum_num.rs
index 612cefe756e3..3157f8a3fee8 100644
--- a/library/compiler-builtins/libm/src/math/fminimum_fmaximum_num.rs
+++ b/library/compiler-builtins/libm/src/math/fminimum_fmaximum_num.rs
@@ -69,6 +69,7 @@ pub fn fmaximum_numf128(x: f128, y: f128) -> f128 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::support::hex_float::Hexi;
     use crate::support::{Float, Hexf};
 
     fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
@@ -81,6 +82,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ZERO, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::ZERO, F::NAN, F::ZERO),
             (F::ZERO, F::NEG_NAN, F::ZERO),
+            (F::ZERO, F::SNAN, F::ZERO),
+            (F::ZERO, F::NEG_SNAN, F::ZERO),
             (F::NEG_ZERO, F::ZERO, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ZERO, F::ONE, F::NEG_ZERO),
@@ -89,6 +92,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ZERO, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_ZERO, F::NAN, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_NAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::SNAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::NEG_SNAN, F::NEG_ZERO),
             (F::ONE, F::ZERO, F::ZERO),
             (F::ONE, F::NEG_ZERO, F::NEG_ZERO),
             (F::ONE, F::ONE, F::ONE),
@@ -97,6 +102,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ONE, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::ONE, F::NAN, F::ONE),
             (F::ONE, F::NEG_NAN, F::ONE),
+            (F::ONE, F::SNAN, F::ONE),
+            (F::ONE, F::NEG_SNAN, F::ONE),
             (F::NEG_ONE, F::ZERO, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_ZERO, F::NEG_ONE),
             (F::NEG_ONE, F::ONE, F::NEG_ONE),
@@ -105,6 +112,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ONE, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_ONE, F::NAN, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_NAN, F::NEG_ONE),
+            (F::NEG_ONE, F::SNAN, F::NEG_ONE),
+            (F::NEG_ONE, F::NEG_SNAN, F::NEG_ONE),
             (F::INFINITY, F::ZERO, F::ZERO),
             (F::INFINITY, F::NEG_ZERO, F::NEG_ZERO),
             (F::INFINITY, F::ONE, F::ONE),
@@ -113,6 +122,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::INFINITY, F::NAN, F::INFINITY),
             (F::INFINITY, F::NEG_NAN, F::INFINITY),
+            (F::INFINITY, F::SNAN, F::INFINITY),
+            (F::INFINITY, F::NEG_SNAN, F::INFINITY),
             (F::NEG_INFINITY, F::ZERO, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_ZERO, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::ONE, F::NEG_INFINITY),
@@ -121,6 +132,8 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NAN, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_NAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::SNAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::NEG_SNAN, F::NEG_INFINITY),
             (F::NAN, F::ZERO, F::ZERO),
             (F::NAN, F::NEG_ZERO, F::NEG_ZERO),
             (F::NAN, F::ONE, F::ONE),
@@ -134,17 +147,52 @@ fn fminimum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_NAN, F::NEG_ONE, F::NEG_ONE),
             (F::NEG_NAN, F::INFINITY, F::INFINITY),
             (F::NEG_NAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::SNAN, F::ZERO, F::ZERO),
+            (F::SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::SNAN, F::ONE, F::ONE),
+            (F::SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::SNAN, F::INFINITY, F::INFINITY),
+            (F::SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::NEG_SNAN, F::ZERO, F::ZERO),
+            (F::NEG_SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::NEG_SNAN, F::ONE, F::ONE),
+            (F::NEG_SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::NEG_SNAN, F::INFINITY, F::INFINITY),
+            (F::NEG_SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
         ];
 
         for (x, y, expected) in cases {
             let actual = f(x, y);
-            assert_biteq!(actual, expected, "fminimum_num({}, {})", Hexf(x), Hexf(y));
+            assert_biteq!(
+                actual,
+                expected,
+                "fminimum_num({}, {}) ({}, {})",
+                Hexf(x),
+                Hexf(y),
+                Hexi(x.to_bits()),
+                Hexi(y.to_bits()),
+            );
         }
 
-        // Ordering between NaNs does not matter
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+        // Selection between NaNs does not matter, it just must be quiet
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        // These operations should technically return a qnan, but LLVM optimizes out our
+        // `* 1.0` canonicalization.
+        assert!(f(F::NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::SNAN).is_nan());
+        assert!(f(F::SNAN, F::NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::SNAN, F::SNAN).is_nan());
     }
 
     #[test]
@@ -179,6 +227,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ZERO, F::NEG_INFINITY, F::ZERO),
             (F::ZERO, F::NAN, F::ZERO),
             (F::ZERO, F::NEG_NAN, F::ZERO),
+            (F::ZERO, F::SNAN, F::ZERO),
+            (F::ZERO, F::NEG_SNAN, F::ZERO),
             (F::NEG_ZERO, F::ZERO, F::ZERO),
             (F::NEG_ZERO, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ZERO, F::ONE, F::ONE),
@@ -187,6 +237,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ZERO, F::NEG_INFINITY, F::NEG_ZERO),
             (F::NEG_ZERO, F::NAN, F::NEG_ZERO),
             (F::NEG_ZERO, F::NEG_NAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::SNAN, F::NEG_ZERO),
+            (F::NEG_ZERO, F::NEG_SNAN, F::NEG_ZERO),
             (F::ONE, F::ZERO, F::ONE),
             (F::ONE, F::NEG_ZERO, F::ONE),
             (F::ONE, F::ONE, F::ONE),
@@ -195,6 +247,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::ONE, F::NEG_INFINITY, F::ONE),
             (F::ONE, F::NAN, F::ONE),
             (F::ONE, F::NEG_NAN, F::ONE),
+            (F::ONE, F::SNAN, F::ONE),
+            (F::ONE, F::NEG_SNAN, F::ONE),
             (F::NEG_ONE, F::ZERO, F::ZERO),
             (F::NEG_ONE, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_ONE, F::ONE, F::ONE),
@@ -203,6 +257,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_ONE, F::NEG_INFINITY, F::NEG_ONE),
             (F::NEG_ONE, F::NAN, F::NEG_ONE),
             (F::NEG_ONE, F::NEG_NAN, F::NEG_ONE),
+            (F::NEG_ONE, F::SNAN, F::NEG_ONE),
+            (F::NEG_ONE, F::NEG_SNAN, F::NEG_ONE),
             (F::INFINITY, F::ZERO, F::INFINITY),
             (F::INFINITY, F::NEG_ZERO, F::INFINITY),
             (F::INFINITY, F::ONE, F::INFINITY),
@@ -211,6 +267,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::INFINITY, F::NEG_INFINITY, F::INFINITY),
             (F::INFINITY, F::NAN, F::INFINITY),
             (F::INFINITY, F::NEG_NAN, F::INFINITY),
+            (F::INFINITY, F::SNAN, F::INFINITY),
+            (F::INFINITY, F::NEG_SNAN, F::INFINITY),
             (F::NEG_INFINITY, F::ZERO, F::ZERO),
             (F::NEG_INFINITY, F::NEG_ZERO, F::NEG_ZERO),
             (F::NEG_INFINITY, F::ONE, F::ONE),
@@ -219,6 +277,8 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_INFINITY, F::NEG_INFINITY, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NAN, F::NEG_INFINITY),
             (F::NEG_INFINITY, F::NEG_NAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::SNAN, F::NEG_INFINITY),
+            (F::NEG_INFINITY, F::NEG_SNAN, F::NEG_INFINITY),
             (F::NAN, F::ZERO, F::ZERO),
             (F::NAN, F::NEG_ZERO, F::NEG_ZERO),
             (F::NAN, F::ONE, F::ONE),
@@ -232,17 +292,52 @@ fn fmaximum_num_spec_test<F: Float>(f: impl Fn(F, F) -> F) {
             (F::NEG_NAN, F::NEG_ONE, F::NEG_ONE),
             (F::NEG_NAN, F::INFINITY, F::INFINITY),
             (F::NEG_NAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::SNAN, F::ZERO, F::ZERO),
+            (F::SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::SNAN, F::ONE, F::ONE),
+            (F::SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::SNAN, F::INFINITY, F::INFINITY),
+            (F::SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
+            (F::NEG_SNAN, F::ZERO, F::ZERO),
+            (F::NEG_SNAN, F::NEG_ZERO, F::NEG_ZERO),
+            (F::NEG_SNAN, F::ONE, F::ONE),
+            (F::NEG_SNAN, F::NEG_ONE, F::NEG_ONE),
+            (F::NEG_SNAN, F::INFINITY, F::INFINITY),
+            (F::NEG_SNAN, F::NEG_INFINITY, F::NEG_INFINITY),
         ];
 
         for (x, y, expected) in cases {
             let actual = f(x, y);
-            assert_biteq!(actual, expected, "fmaximum_num({}, {})", Hexf(x), Hexf(y));
+            assert_biteq!(
+                actual,
+                expected,
+                "fmaximum_num({}, {}) ({}, {})",
+                Hexf(x),
+                Hexf(y),
+                Hexi(x.to_bits()),
+                Hexi(y.to_bits()),
+            );
         }
 
-        // Ordering between NaNs does not matter
-        assert!(f(F::NAN, F::NEG_NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NAN).is_nan());
-        assert!(f(F::NEG_NAN, F::NEG_NAN).is_nan());
+        // Selection between NaNs does not matter, it just must be quiet
+        assert!(f(F::NAN, F::NEG_NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NAN).is_qnan());
+        assert!(f(F::NEG_NAN, F::NEG_NAN).is_qnan());
+
+        // These operations should technically return a qnan, but LLVM optimizes out our
+        // `* 1.0` canonicalization.
+        assert!(f(F::NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_NAN, F::SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::NEG_SNAN, F::SNAN).is_nan());
+        assert!(f(F::SNAN, F::NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_NAN).is_nan());
+        assert!(f(F::SNAN, F::NEG_SNAN).is_nan());
+        assert!(f(F::SNAN, F::SNAN).is_nan());
     }
 
     #[test]
diff --git a/library/compiler-builtins/libm/src/math/generic/fmax.rs b/library/compiler-builtins/libm/src/math/generic/fmax.rs
index b05804704d03..bdd46cc38a81 100644
--- a/library/compiler-builtins/libm/src/math/generic/fmax.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fmax.rs
@@ -8,11 +8,15 @@
 //! - Otherwise, either `x` or `y`, canonicalized
 //! - -0.0 and +0.0 may be disregarded (unlike newer operations)
 //!
-//! Excluded from our implementation is sNaN handling.
+//! We do not treat sNaN and qNaN differently; even though IEEE technically requires this, (a call
+//! with sNaN should return qNaN rather than the other result), it breaks associativity so isn't
+//! desired behavior. C23 does not differentiate between sNaN and qNaN, so we do not either. More
+//! on the problems with `minNum` [here][minnum-removal].
 //!
-//! More on the differences: [link].
+//! IEEE also specifies that a sNaN in either argument should signal invalid, but we do not
+//! implement this.
 //!
-//! [link]: https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf
+//! [minnum-removal]: https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf
 
 use crate::support::Float;
 
diff --git a/library/compiler-builtins/libm/src/math/generic/fmaximum.rs b/library/compiler-builtins/libm/src/math/generic/fmaximum.rs
index 55a031e18ee8..1fa48f964804 100644
--- a/library/compiler-builtins/libm/src/math/generic/fmaximum.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fmaximum.rs
@@ -7,7 +7,8 @@
 //! - +0.0 if x and y are zero with opposite signs
 //! - qNaN if either operation is NaN
 //!
-//! Excluded from our implementation is sNaN handling.
+//! Note that the IEEE 754-2019 specifies that a sNaN in either argument should signal invalid,
+//! but we do not implement this.
 
 use crate::support::Float;
 
diff --git a/library/compiler-builtins/libm/src/math/generic/fmaximum_num.rs b/library/compiler-builtins/libm/src/math/generic/fmaximum_num.rs
index 2dc60b2d237f..c7ca50a89dc8 100644
--- a/library/compiler-builtins/libm/src/math/generic/fmaximum_num.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fmaximum_num.rs
@@ -9,7 +9,8 @@
 //! - Non-NaN if one operand is NaN
 //! - qNaN if both operands are NaNx
 //!
-//! Excluded from our implementation is sNaN handling.
+//! Note that the IEEE 754-2019 specifies that a sNaN in either argument should signal invalid,
+//! but we do not implement this.
 
 use crate::support::Float;
 
diff --git a/library/compiler-builtins/libm/src/math/generic/fmin.rs b/library/compiler-builtins/libm/src/math/generic/fmin.rs
index e2245bf9e137..e7755e82345c 100644
--- a/library/compiler-builtins/libm/src/math/generic/fmin.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fmin.rs
@@ -8,11 +8,15 @@
 //! - Otherwise, either `x` or `y`, canonicalized
 //! - -0.0 and +0.0 may be disregarded (unlike newer operations)
 //!
-//! Excluded from our implementation is sNaN handling.
+//! We do not treat sNaN and qNaN differently; even though IEEE technically requires this, (a call
+//! with sNaN should return qNaN rather than the other result), it breaks associativity so isn't
+//! desired behavior. C23 does not differentiate between sNaN and qNaN, so we do not either. More
+//! on the problems with `minNum` [here][minnum-removal].
 //!
-//! More on the differences: [link].
+//! IEEE also specifies that a sNaN in either argument should signal invalid, but we do not
+//! implement this.
 //!
-//! [link]: https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf
+//! [minnum-removal]: https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/minNum_maxNum_Removal_Demotion_v3.pdf
 
 use crate::support::Float;
 
diff --git a/library/compiler-builtins/libm/src/math/generic/fminimum.rs b/library/compiler-builtins/libm/src/math/generic/fminimum.rs
index aa68b1291d42..82e72d644064 100644
--- a/library/compiler-builtins/libm/src/math/generic/fminimum.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fminimum.rs
@@ -7,7 +7,8 @@
 //! - -0.0 if x and y are zero with opposite signs
 //! - qNaN if either operation is NaN
 //!
-//! Excluded from our implementation is sNaN handling.
+//! Note that the IEEE 754-2019 specifies that a sNaN in either argument should signal invalid,
+//! but we do not implement this.
 
 use crate::support::Float;
 
diff --git a/library/compiler-builtins/libm/src/math/generic/fminimum_num.rs b/library/compiler-builtins/libm/src/math/generic/fminimum_num.rs
index 265bd4605ce3..5b5271b123ba 100644
--- a/library/compiler-builtins/libm/src/math/generic/fminimum_num.rs
+++ b/library/compiler-builtins/libm/src/math/generic/fminimum_num.rs
@@ -9,7 +9,8 @@
 //! - Non-NaN if one operand is NaN
 //! - qNaN if both operands are NaNx
 //!
-//! Excluded from our implementation is sNaN handling.
+//! Note that the IEEE 754-2019 specifies that a sNaN in either argument should signal invalid,
+//! but we do not implement this.
 
 use crate::support::Float;
 

From 1a30924b1723b19f461b136cd98549549d637419 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Sat, 14 Mar 2026 13:22:17 +0100
Subject: [PATCH 0467/1059] Remove `def_id_for_ty_in_cycle`

---
 compiler/rustc_middle/src/query/keys.rs       | 24 -------------------
 compiler/rustc_middle/src/query/stack.rs      |  2 --
 .../rustc_query_impl/src/from_cycle_error.rs  | 18 +++++++-------
 compiler/rustc_query_impl/src/plumbing.rs     |  2 --
 4 files changed, 9 insertions(+), 37 deletions(-)

diff --git a/compiler/rustc_middle/src/query/keys.rs b/compiler/rustc_middle/src/query/keys.rs
index 54b72c5b6714..e5e56b8e28b2 100644
--- a/compiler/rustc_middle/src/query/keys.rs
+++ b/compiler/rustc_middle/src/query/keys.rs
@@ -45,11 +45,6 @@ pub trait QueryKey: Sized + QueryKeyBounds {
     fn key_as_def_id(&self) -> Option<DefId> {
         None
     }
-
-    /// Used to detect when ADT def ids are used as keys in a cycle for better error reporting.
-    fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
-        None
-    }
 }
 
 pub trait AsLocalQueryKey: QueryKey {
@@ -265,14 +260,6 @@ impl<'tcx> QueryKey for Ty<'tcx> {
     fn default_span(&self, _: TyCtxt<'_>) -> Span {
         DUMMY_SP
     }
-
-    fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
-        match *self.kind() {
-            ty::Adt(adt, _) => Some(adt.did()),
-            ty::Coroutine(def_id, ..) => Some(def_id),
-            _ => None,
-        }
-    }
 }
 
 impl<'tcx> QueryKey for (Ty<'tcx>, Ty<'tcx>) {
@@ -291,10 +278,6 @@ impl<'tcx, T: QueryKey> QueryKey for ty::PseudoCanonicalInput<'tcx, T> {
     fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
         self.value.default_span(tcx)
     }
-
-    fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
-        self.value.def_id_for_ty_in_cycle()
-    }
 }
 
 impl QueryKey for Symbol {
@@ -371,13 +354,6 @@ impl<'tcx> QueryKey for (ValidityRequirement, ty::PseudoCanonicalInput<'tcx, Ty<
     fn default_span(&self, _: TyCtxt<'_>) -> Span {
         DUMMY_SP
     }
-
-    fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
-        match self.1.value.kind() {
-            ty::Adt(adt, _) => Some(adt.did()),
-            _ => None,
-        }
-    }
 }
 
 impl<'tcx> QueryKey for (ty::Instance<'tcx>, CollectionMode) {
diff --git a/compiler/rustc_middle/src/query/stack.rs b/compiler/rustc_middle/src/query/stack.rs
index d47c3523a96b..6599ad3c6f54 100644
--- a/compiler/rustc_middle/src/query/stack.rs
+++ b/compiler/rustc_middle/src/query/stack.rs
@@ -13,6 +13,4 @@ pub struct QueryStackFrame<'tcx> {
     pub tagged_key: TaggedQueryKey<'tcx>,
     pub dep_kind: DepKind,
     pub def_id: Option<DefId>,
-    /// A def-id that is extracted from a `Ty` in a query key
-    pub def_id_for_ty_in_cycle: Option<DefId>,
 }
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 8214f80cda41..2e2f23d6b866 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -9,7 +9,7 @@
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::dep_graph::DepKind;
-use rustc_middle::queries::QueryVTables;
+use rustc_middle::queries::{QueryVTables, TaggedQueryKey};
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
 use rustc_middle::ty::layout::LayoutError;
@@ -91,9 +91,9 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
         }
     }
     for info in &cycle_error.cycle {
-        if info.frame.dep_kind == DepKind::check_representability_adt_ty
-            && let Some(def_id) = info.frame.def_id_for_ty_in_cycle
-            && let Some(def_id) = def_id.as_local()
+        if let TaggedQueryKey::check_representability_adt_ty(key) = info.frame.tagged_key
+            && let Some(adt) = key.ty_adt_def()
+            && let Some(def_id) = adt.did().as_local()
             && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
         {
             representable_ids.insert(def_id);
@@ -154,8 +154,8 @@ fn layout_of<'tcx>(
     let diag = search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
-            if cycle[0].frame.dep_kind == DepKind::layout_of
-                && let Some(def_id) = cycle[0].frame.def_id_for_ty_in_cycle
+            if let TaggedQueryKey::layout_of(key) = cycle[0].frame.tagged_key
+                && let ty::Coroutine(def_id, _) = key.value.kind()
                 && let Some(def_id) = def_id.as_local()
                 && let def_kind = tcx.def_kind(def_id)
                 && matches!(def_kind, DefKind::Closure)
@@ -179,10 +179,10 @@ fn layout_of<'tcx>(
                     tcx.def_kind_descr(def_kind, def_id.to_def_id()),
                 );
                 for (i, info) in cycle.iter().enumerate() {
-                    if info.frame.dep_kind != DepKind::layout_of {
+                    let TaggedQueryKey::layout_of(frame_key) = info.frame.tagged_key else {
                         continue;
-                    }
-                    let Some(frame_def_id) = info.frame.def_id_for_ty_in_cycle else {
+                    };
+                    let &ty::Coroutine(frame_def_id, _) = frame_key.value.kind() else {
                         continue;
                     };
                     let Some(frame_coroutine_kind) = tcx.coroutine_kind(frame_def_id) else {
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index a346836057d9..d1b115d593eb 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -91,13 +91,11 @@ pub(crate) fn create_query_stack_frame<'tcx, C>(
     QueryVTable<'tcx, C>: DynSync,
 {
     let def_id: Option<DefId> = key.key_as_def_id();
-    let def_id_for_ty_in_cycle: Option<DefId> = key.def_id_for_ty_in_cycle();
 
     QueryStackFrame {
         tagged_key: (vtable.create_tagged_key)(key),
         dep_kind: vtable.dep_kind,
         def_id,
-        def_id_for_ty_in_cycle,
     }
 }
 

From c92bb95f6efafde008e66f48a8e661c3ee702b6c Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sat, 14 Mar 2026 14:31:38 +0000
Subject: [PATCH 0468/1059] merge and cleanup the
 `generate-deriving-span-tests.py` tests

---
 src/etc/generate-deriving-span-tests.py       | 121 ------------------
 .../derives-span-Clone-enum-struct-variant.rs |  13 --
 ...ives-span-Clone-enum-struct-variant.stderr |  18 ---
 tests/ui/derives/derives-span-Clone-enum.rs   |  13 --
 .../ui/derives/derives-span-Clone-enum.stderr |  18 ---
 tests/ui/derives/derives-span-Clone-struct.rs |  11 --
 .../derives/derives-span-Clone-struct.stderr  |  18 ---
 .../derives-span-Clone-tuple-struct.rs        |  11 --
 .../derives-span-Clone-tuple-struct.stderr    |  18 ---
 tests/ui/derives/derives-span-Clone.rs        |  30 +++++
 tests/ui/derives/derives-span-Clone.stderr    |  63 +++++++++
 .../derives-span-Debug-enum-struct-variant.rs |  13 --
 ...ives-span-Debug-enum-struct-variant.stderr |  19 ---
 tests/ui/derives/derives-span-Debug-enum.rs   |  13 --
 .../ui/derives/derives-span-Debug-enum.stderr |  19 ---
 tests/ui/derives/derives-span-Debug-struct.rs |  11 --
 .../derives/derives-span-Debug-struct.stderr  |  19 ---
 .../derives-span-Debug-tuple-struct.rs        |  11 --
 .../derives-span-Debug-tuple-struct.stderr    |  19 ---
 tests/ui/derives/derives-span-Debug.rs        |  29 +++++
 tests/ui/derives/derives-span-Debug.stderr    |  67 ++++++++++
 .../ui/derives/derives-span-Default-struct.rs |  11 --
 .../derives-span-Default-struct.stderr        |  18 ---
 .../derives-span-Default-tuple-struct.rs      |  11 --
 .../derives-span-Default-tuple-struct.stderr  |  18 ---
 tests/ui/derives/derives-span-Default.rs      |  16 +++
 tests/ui/derives/derives-span-Default.stderr  |  33 +++++
 .../derives-span-Eq-enum-struct-variant.rs    |  13 --
 ...derives-span-Eq-enum-struct-variant.stderr |  20 ---
 tests/ui/derives/derives-span-Eq-enum.rs      |  13 --
 tests/ui/derives/derives-span-Eq-enum.stderr  |  20 ---
 tests/ui/derives/derives-span-Eq-struct.rs    |  11 --
 .../ui/derives/derives-span-Eq-struct.stderr  |  20 ---
 .../derives/derives-span-Eq-tuple-struct.rs   |  11 --
 .../derives-span-Eq-tuple-struct.stderr       |  20 ---
 tests/ui/derives/derives-span-Eq.rs           |  31 +++++
 tests/ui/derives/derives-span-Eq.stderr       |  71 ++++++++++
 .../derives-span-Hash-enum-struct-variant.rs  |  13 --
 ...rives-span-Hash-enum-struct-variant.stderr |  18 ---
 tests/ui/derives/derives-span-Hash-enum.rs    |  12 --
 .../ui/derives/derives-span-Hash-enum.stderr  |  18 ---
 tests/ui/derives/derives-span-Hash-struct.rs  |  11 --
 .../derives/derives-span-Hash-struct.stderr   |  18 ---
 .../derives/derives-span-Hash-tuple-struct.rs |  11 --
 .../derives-span-Hash-tuple-struct.stderr     |  18 ---
 tests/ui/derives/derives-span-Hash.rs         |  30 +++++
 tests/ui/derives/derives-span-Hash.stderr     |  63 +++++++++
 .../derives-span-Ord-enum-struct-variant.rs   |  13 --
 ...erives-span-Ord-enum-struct-variant.stderr |  18 ---
 tests/ui/derives/derives-span-Ord-enum.rs     |  13 --
 tests/ui/derives/derives-span-Ord-enum.stderr |  18 ---
 tests/ui/derives/derives-span-Ord-struct.rs   |  11 --
 .../ui/derives/derives-span-Ord-struct.stderr |  18 ---
 .../derives/derives-span-Ord-tuple-struct.rs  |  11 --
 .../derives-span-Ord-tuple-struct.stderr      |  18 ---
 tests/ui/derives/derives-span-Ord.rs          |  31 +++++
 tests/ui/derives/derives-span-Ord.stderr      |  63 +++++++++
 ...ives-span-PartialEq-enum-struct-variant.rs |  13 --
 ...-span-PartialEq-enum-struct-variant.stderr |  23 ----
 .../ui/derives/derives-span-PartialEq-enum.rs |  13 --
 .../derives-span-PartialEq-enum.stderr        |  23 ----
 .../derives/derives-span-PartialEq-struct.rs  |  11 --
 .../derives-span-PartialEq-struct.stderr      |  23 ----
 .../derives-span-PartialEq-tuple-struct.rs    |  11 --
 ...derives-span-PartialEq-tuple-struct.stderr |  23 ----
 tests/ui/derives/derives-span-PartialEq.rs    |  29 +++++
 .../ui/derives/derives-span-PartialEq.stderr  |  83 ++++++++++++
 ...ves-span-PartialOrd-enum-struct-variant.rs |  13 --
 ...span-PartialOrd-enum-struct-variant.stderr |  19 ---
 .../derives/derives-span-PartialOrd-enum.rs   |  13 --
 .../derives-span-PartialOrd-enum.stderr       |  19 ---
 .../derives/derives-span-PartialOrd-struct.rs |  11 --
 .../derives-span-PartialOrd-struct.stderr     |  19 ---
 .../derives-span-PartialOrd-tuple-struct.rs   |  11 --
 ...erives-span-PartialOrd-tuple-struct.stderr |  19 ---
 tests/ui/derives/derives-span-PartialOrd.rs   |  31 +++++
 .../ui/derives/derives-span-PartialOrd.stderr |  67 ++++++++++
 tests/ui/derives/deriving-primitive.rs        |   5 -
 tests/ui/derives/deriving-primitive.stderr    |  16 ---
 79 files changed, 737 insertions(+), 1075 deletions(-)
 delete mode 100755 src/etc/generate-deriving-span-tests.py
 delete mode 100644 tests/ui/derives/derives-span-Clone-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-Clone-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-Clone-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-Clone-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Clone-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Clone-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Clone-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Clone.rs
 create mode 100644 tests/ui/derives/derives-span-Clone.stderr
 delete mode 100644 tests/ui/derives/derives-span-Debug-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-Debug-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-Debug-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-Debug-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Debug-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Debug-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Debug-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Debug.rs
 create mode 100644 tests/ui/derives/derives-span-Debug.stderr
 delete mode 100644 tests/ui/derives/derives-span-Default-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Default-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Default-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Default-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Default.rs
 create mode 100644 tests/ui/derives/derives-span-Default.stderr
 delete mode 100644 tests/ui/derives/derives-span-Eq-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-Eq-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-Eq-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-Eq-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Eq-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Eq-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Eq-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Eq.rs
 create mode 100644 tests/ui/derives/derives-span-Eq.stderr
 delete mode 100644 tests/ui/derives/derives-span-Hash-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-Hash-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-Hash-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-Hash-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Hash-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Hash-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Hash-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Hash.rs
 create mode 100644 tests/ui/derives/derives-span-Hash.stderr
 delete mode 100644 tests/ui/derives/derives-span-Ord-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-Ord-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-Ord-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-Ord-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Ord-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-Ord-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-Ord-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-Ord.rs
 create mode 100644 tests/ui/derives/derives-span-Ord.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-PartialEq.rs
 create mode 100644 tests/ui/derives/derives-span-PartialEq.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-enum.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-enum.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-struct.stderr
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-tuple-struct.rs
 delete mode 100644 tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
 create mode 100644 tests/ui/derives/derives-span-PartialOrd.rs
 create mode 100644 tests/ui/derives/derives-span-PartialOrd.stderr
 delete mode 100644 tests/ui/derives/deriving-primitive.rs
 delete mode 100644 tests/ui/derives/deriving-primitive.stderr

diff --git a/src/etc/generate-deriving-span-tests.py b/src/etc/generate-deriving-span-tests.py
deleted file mode 100755
index 2e810d7df97b..000000000000
--- a/src/etc/generate-deriving-span-tests.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/usr/bin/env python
-
-"""
-This script creates a pile of UI tests check that all the
-derives have spans that point to the fields, rather than the
-#[derive(...)] line.
-
-sample usage: src/etc/generate-deriving-span-tests.py
-"""
-
-import os
-import stat
-
-TEST_DIR = os.path.abspath(
-    os.path.join(os.path.dirname(__file__), "../test/ui/derives/")
-)
-
-TEMPLATE = """\
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-{error_deriving}
-struct Error;
-{code}
-fn main() {{}}
-"""
-
-ENUM_STRING = """
-#[derive({traits})]
-enum Enum {{
-   A(
-     Error {errors}
-     )
-}}
-"""
-ENUM_STRUCT_VARIANT_STRING = """
-#[derive({traits})]
-enum Enum {{
-   A {{
-     x: Error {errors}
-   }}
-}}
-"""
-STRUCT_STRING = """
-#[derive({traits})]
-struct Struct {{
-    x: Error {errors}
-}}
-"""
-STRUCT_TUPLE_STRING = """
-#[derive({traits})]
-struct Struct(
-    Error {errors}
-);
-"""
-
-ENUM_TUPLE, ENUM_STRUCT, STRUCT_FIELDS, STRUCT_TUPLE = range(4)
-
-
-def create_test_case(type, trait, super_traits, error_count):
-    string = [
-        ENUM_STRING,
-        ENUM_STRUCT_VARIANT_STRING,
-        STRUCT_STRING,
-        STRUCT_TUPLE_STRING,
-    ][type]
-    all_traits = ",".join([trait] + super_traits)
-    super_traits = ",".join(super_traits)
-    error_deriving = "#[derive(%s)]" % super_traits if super_traits else ""
-
-    errors = "\n".join("//~%s ERROR" % ("^" * n) for n in range(error_count))
-    code = string.format(traits=all_traits, errors=errors)
-    return TEMPLATE.format(error_deriving=error_deriving, code=code)
-
-
-def write_file(name, string):
-    test_file = os.path.join(TEST_DIR, "derives-span-%s.rs" % name)
-
-    # set write permission if file exists, so it can be changed
-    if os.path.exists(test_file):
-        os.chmod(test_file, stat.S_IWUSR)
-
-    with open(test_file, "w") as f:
-        f.write(string)
-
-    # mark file read-only
-    os.chmod(test_file, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
-
-
-ENUM = 1
-STRUCT = 2
-ALL = STRUCT | ENUM
-
-traits = {
-    "Default": (STRUCT, [], 1),
-    "FromPrimitive": (0, [], 0),  # only works for C-like enums
-    "Decodable": (0, [], 0),  # FIXME: quoting gives horrible spans
-    "Encodable": (0, [], 0),  # FIXME: quoting gives horrible spans
-}
-
-for trait, supers, errs in [
-    ("Clone", [], 1),
-    ("PartialEq", [], 2),
-    ("PartialOrd", ["PartialEq"], 1),
-    ("Eq", ["PartialEq"], 1),
-    ("Ord", ["Eq", "PartialOrd", "PartialEq"], 1),
-    ("Debug", [], 1),
-    ("Hash", [], 1),
-]:
-    traits[trait] = (ALL, supers, errs)
-
-for trait, (types, super_traits, error_count) in traits.items():
-
-    def mk(ty, t=trait, st=super_traits, ec=error_count):
-        return create_test_case(ty, t, st, ec)
-
-    if types & ENUM:
-        write_file(trait + "-enum", mk(ENUM_TUPLE))
-        write_file(trait + "-enum-struct-variant", mk(ENUM_STRUCT))
-    if types & STRUCT:
-        write_file(trait + "-struct", mk(STRUCT_FIELDS))
-        write_file(trait + "-tuple-struct", mk(STRUCT_TUPLE))
diff --git a/tests/ui/derives/derives-span-Clone-enum-struct-variant.rs b/tests/ui/derives/derives-span-Clone-enum-struct-variant.rs
deleted file mode 100644
index b556d442420e..000000000000
--- a/tests/ui/derives/derives-span-Clone-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Clone)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
deleted file mode 100644
index 9aeb3a8c03d2..000000000000
--- a/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Clone` is not satisfied
-  --> $DIR/derives-span-Clone-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(Clone)]
-   |          ----- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ the trait `Clone` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Clone)]`
-   |
-LL + #[derive(Clone)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-enum.rs b/tests/ui/derives/derives-span-Clone-enum.rs
deleted file mode 100644
index 9bb4f486c3ef..000000000000
--- a/tests/ui/derives/derives-span-Clone-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Clone)]
-enum Enum {
-   A(
-     Error //~ ERROR
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Clone-enum.stderr b/tests/ui/derives/derives-span-Clone-enum.stderr
deleted file mode 100644
index 6b4f22416631..000000000000
--- a/tests/ui/derives/derives-span-Clone-enum.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Clone` is not satisfied
-  --> $DIR/derives-span-Clone-enum.rs:9:6
-   |
-LL | #[derive(Clone)]
-   |          ----- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ the trait `Clone` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Clone)]`
-   |
-LL + #[derive(Clone)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-struct.rs b/tests/ui/derives/derives-span-Clone-struct.rs
deleted file mode 100644
index f151636f848a..000000000000
--- a/tests/ui/derives/derives-span-Clone-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Clone)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Clone-struct.stderr b/tests/ui/derives/derives-span-Clone-struct.stderr
deleted file mode 100644
index 17e3f0eccf92..000000000000
--- a/tests/ui/derives/derives-span-Clone-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Clone` is not satisfied
-  --> $DIR/derives-span-Clone-struct.rs:8:5
-   |
-LL | #[derive(Clone)]
-   |          ----- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Clone` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Clone)]`
-   |
-LL + #[derive(Clone)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-tuple-struct.rs b/tests/ui/derives/derives-span-Clone-tuple-struct.rs
deleted file mode 100644
index 7a62885324eb..000000000000
--- a/tests/ui/derives/derives-span-Clone-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Clone)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Clone-tuple-struct.stderr b/tests/ui/derives/derives-span-Clone-tuple-struct.stderr
deleted file mode 100644
index f8380d197b06..000000000000
--- a/tests/ui/derives/derives-span-Clone-tuple-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Clone` is not satisfied
-  --> $DIR/derives-span-Clone-tuple-struct.rs:8:5
-   |
-LL | #[derive(Clone)]
-   |          ----- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Clone` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Clone)]`
-   |
-LL + #[derive(Clone)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone.rs b/tests/ui/derives/derives-span-Clone.rs
new file mode 100644
index 000000000000..985fbd36db6d
--- /dev/null
+++ b/tests/ui/derives/derives-span-Clone.rs
@@ -0,0 +1,30 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Clone)] line.
+
+struct Error;
+
+#[derive(Clone)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(Clone)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+
+#[derive(Clone)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Clone)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Clone.stderr b/tests/ui/derives/derives-span-Clone.stderr
new file mode 100644
index 000000000000..daf8ef209819
--- /dev/null
+++ b/tests/ui/derives/derives-span-Clone.stderr
@@ -0,0 +1,63 @@
+error[E0277]: the trait bound `Error: Clone` is not satisfied
+  --> $DIR/derives-span-Clone.rs:9:9
+   |
+LL | #[derive(Clone)]
+   |          ----- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ the trait `Clone` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Clone)]`
+   |
+LL + #[derive(Clone)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Clone` is not satisfied
+  --> $DIR/derives-span-Clone.rs:16:9
+   |
+LL | #[derive(Clone)]
+   |          ----- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ the trait `Clone` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Clone)]`
+   |
+LL + #[derive(Clone)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Clone` is not satisfied
+  --> $DIR/derives-span-Clone.rs:22:5
+   |
+LL | #[derive(Clone)]
+   |          ----- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Clone` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Clone)]`
+   |
+LL + #[derive(Clone)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Clone` is not satisfied
+  --> $DIR/derives-span-Clone.rs:27:5
+   |
+LL | #[derive(Clone)]
+   |          ----- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Clone` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Clone)]`
+   |
+LL + #[derive(Clone)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-enum-struct-variant.rs b/tests/ui/derives/derives-span-Debug-enum-struct-variant.rs
deleted file mode 100644
index 949597bc8f6e..000000000000
--- a/tests/ui/derives/derives-span-Debug-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Debug)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
deleted file mode 100644
index 147910b715f5..000000000000
--- a/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: `Error` doesn't implement `Debug`
-  --> $DIR/derives-span-Debug-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(Debug)]
-   |          ----- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ the trait `Debug` is not implemented for `Error`
-   |
-   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
-help: consider annotating `Error` with `#[derive(Debug)]`
-   |
-LL + #[derive(Debug)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-enum.rs b/tests/ui/derives/derives-span-Debug-enum.rs
deleted file mode 100644
index b2a39708ceb9..000000000000
--- a/tests/ui/derives/derives-span-Debug-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Debug)]
-enum Enum {
-   A(
-     Error //~ ERROR
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Debug-enum.stderr b/tests/ui/derives/derives-span-Debug-enum.stderr
deleted file mode 100644
index 6f97ceb02d3a..000000000000
--- a/tests/ui/derives/derives-span-Debug-enum.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: `Error` doesn't implement `Debug`
-  --> $DIR/derives-span-Debug-enum.rs:9:6
-   |
-LL | #[derive(Debug)]
-   |          ----- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ the trait `Debug` is not implemented for `Error`
-   |
-   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
-help: consider annotating `Error` with `#[derive(Debug)]`
-   |
-LL + #[derive(Debug)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-struct.rs b/tests/ui/derives/derives-span-Debug-struct.rs
deleted file mode 100644
index cf91c9436a62..000000000000
--- a/tests/ui/derives/derives-span-Debug-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Debug)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Debug-struct.stderr b/tests/ui/derives/derives-span-Debug-struct.stderr
deleted file mode 100644
index 46d69a892f25..000000000000
--- a/tests/ui/derives/derives-span-Debug-struct.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: `Error` doesn't implement `Debug`
-  --> $DIR/derives-span-Debug-struct.rs:8:5
-   |
-LL | #[derive(Debug)]
-   |          ----- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Debug` is not implemented for `Error`
-   |
-   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
-help: consider annotating `Error` with `#[derive(Debug)]`
-   |
-LL + #[derive(Debug)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-tuple-struct.rs b/tests/ui/derives/derives-span-Debug-tuple-struct.rs
deleted file mode 100644
index cea973c91a78..000000000000
--- a/tests/ui/derives/derives-span-Debug-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Debug)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Debug-tuple-struct.stderr b/tests/ui/derives/derives-span-Debug-tuple-struct.stderr
deleted file mode 100644
index a3feeff6df37..000000000000
--- a/tests/ui/derives/derives-span-Debug-tuple-struct.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: `Error` doesn't implement `Debug`
-  --> $DIR/derives-span-Debug-tuple-struct.rs:8:5
-   |
-LL | #[derive(Debug)]
-   |          ----- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Debug` is not implemented for `Error`
-   |
-   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
-help: consider annotating `Error` with `#[derive(Debug)]`
-   |
-LL + #[derive(Debug)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug.rs b/tests/ui/derives/derives-span-Debug.rs
new file mode 100644
index 000000000000..1bc10a04c6f1
--- /dev/null
+++ b/tests/ui/derives/derives-span-Debug.rs
@@ -0,0 +1,29 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Debug)] line.
+
+struct Error;
+
+#[derive(Debug)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(Debug)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+#[derive(Debug)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Debug)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Debug.stderr b/tests/ui/derives/derives-span-Debug.stderr
new file mode 100644
index 000000000000..e4a2560db451
--- /dev/null
+++ b/tests/ui/derives/derives-span-Debug.stderr
@@ -0,0 +1,67 @@
+error[E0277]: `Error` doesn't implement `Debug`
+  --> $DIR/derives-span-Debug.rs:9:9
+   |
+LL | #[derive(Debug)]
+   |          ----- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ the trait `Debug` is not implemented for `Error`
+   |
+   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
+help: consider annotating `Error` with `#[derive(Debug)]`
+   |
+LL + #[derive(Debug)]
+LL | struct Error;
+   |
+
+error[E0277]: `Error` doesn't implement `Debug`
+  --> $DIR/derives-span-Debug.rs:16:9
+   |
+LL | #[derive(Debug)]
+   |          ----- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ the trait `Debug` is not implemented for `Error`
+   |
+   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
+help: consider annotating `Error` with `#[derive(Debug)]`
+   |
+LL + #[derive(Debug)]
+LL | struct Error;
+   |
+
+error[E0277]: `Error` doesn't implement `Debug`
+  --> $DIR/derives-span-Debug.rs:21:5
+   |
+LL | #[derive(Debug)]
+   |          ----- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Debug` is not implemented for `Error`
+   |
+   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
+help: consider annotating `Error` with `#[derive(Debug)]`
+   |
+LL + #[derive(Debug)]
+LL | struct Error;
+   |
+
+error[E0277]: `Error` doesn't implement `Debug`
+  --> $DIR/derives-span-Debug.rs:26:5
+   |
+LL | #[derive(Debug)]
+   |          ----- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Debug` is not implemented for `Error`
+   |
+   = note: add `#[derive(Debug)]` to `Error` or manually `impl Debug for Error`
+help: consider annotating `Error` with `#[derive(Debug)]`
+   |
+LL + #[derive(Debug)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Default-struct.rs b/tests/ui/derives/derives-span-Default-struct.rs
deleted file mode 100644
index 71fd5829e758..000000000000
--- a/tests/ui/derives/derives-span-Default-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Default)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Default-struct.stderr b/tests/ui/derives/derives-span-Default-struct.stderr
deleted file mode 100644
index 442081f78ce7..000000000000
--- a/tests/ui/derives/derives-span-Default-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Default` is not satisfied
-  --> $DIR/derives-span-Default-struct.rs:8:5
-   |
-LL | #[derive(Default)]
-   |          ------- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Default` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Default)]`
-   |
-LL + #[derive(Default)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Default-tuple-struct.rs b/tests/ui/derives/derives-span-Default-tuple-struct.rs
deleted file mode 100644
index 463f7d230ca4..000000000000
--- a/tests/ui/derives/derives-span-Default-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Default)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Default-tuple-struct.stderr b/tests/ui/derives/derives-span-Default-tuple-struct.stderr
deleted file mode 100644
index e786ec1e9dab..000000000000
--- a/tests/ui/derives/derives-span-Default-tuple-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Default` is not satisfied
-  --> $DIR/derives-span-Default-tuple-struct.rs:8:5
-   |
-LL | #[derive(Default)]
-   |          ------- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Default` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Default)]`
-   |
-LL + #[derive(Default)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Default.rs b/tests/ui/derives/derives-span-Default.rs
new file mode 100644
index 000000000000..7ea91acf823d
--- /dev/null
+++ b/tests/ui/derives/derives-span-Default.rs
@@ -0,0 +1,16 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Default)] line.
+
+struct Error;
+
+#[derive(Default)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Default)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Default.stderr b/tests/ui/derives/derives-span-Default.stderr
new file mode 100644
index 000000000000..9c606171cde8
--- /dev/null
+++ b/tests/ui/derives/derives-span-Default.stderr
@@ -0,0 +1,33 @@
+error[E0277]: the trait bound `Error: Default` is not satisfied
+  --> $DIR/derives-span-Default.rs:8:5
+   |
+LL | #[derive(Default)]
+   |          ------- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Default` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Default)]`
+   |
+LL + #[derive(Default)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Default` is not satisfied
+  --> $DIR/derives-span-Default.rs:13:5
+   |
+LL | #[derive(Default)]
+   |          ------- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Default` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Default)]`
+   |
+LL + #[derive(Default)]
+LL | struct Error;
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-enum-struct-variant.rs b/tests/ui/derives/derives-span-Eq-enum-struct-variant.rs
deleted file mode 100644
index d2dab8687f77..000000000000
--- a/tests/ui/derives/derives-span-Eq-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(Eq,PartialEq)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
deleted file mode 100644
index 42dc8d46b575..000000000000
--- a/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0277]: the trait bound `Error: Eq` is not satisfied
-  --> $DIR/derives-span-Eq-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(Eq,PartialEq)]
-   |          -- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ the trait `Eq` is not implemented for `Error`
-   |
-note: required by a bound in `std::cmp::AssertParamIsEq`
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-help: consider annotating `Error` with `#[derive(Eq)]`
-   |
-LL + #[derive(Eq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-enum.rs b/tests/ui/derives/derives-span-Eq-enum.rs
deleted file mode 100644
index c6c0d4321083..000000000000
--- a/tests/ui/derives/derives-span-Eq-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(Eq,PartialEq)]
-enum Enum {
-   A(
-     Error //~ ERROR
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Eq-enum.stderr b/tests/ui/derives/derives-span-Eq-enum.stderr
deleted file mode 100644
index ef1d9e3242ad..000000000000
--- a/tests/ui/derives/derives-span-Eq-enum.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0277]: the trait bound `Error: Eq` is not satisfied
-  --> $DIR/derives-span-Eq-enum.rs:9:6
-   |
-LL | #[derive(Eq,PartialEq)]
-   |          -- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ the trait `Eq` is not implemented for `Error`
-   |
-note: required by a bound in `std::cmp::AssertParamIsEq`
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-help: consider annotating `Error` with `#[derive(Eq)]`
-   |
-LL + #[derive(Eq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-struct.rs b/tests/ui/derives/derives-span-Eq-struct.rs
deleted file mode 100644
index df310039847d..000000000000
--- a/tests/ui/derives/derives-span-Eq-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(Eq,PartialEq)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Eq-struct.stderr b/tests/ui/derives/derives-span-Eq-struct.stderr
deleted file mode 100644
index bae7bb0361df..000000000000
--- a/tests/ui/derives/derives-span-Eq-struct.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0277]: the trait bound `Error: Eq` is not satisfied
-  --> $DIR/derives-span-Eq-struct.rs:8:5
-   |
-LL | #[derive(Eq,PartialEq)]
-   |          -- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Eq` is not implemented for `Error`
-   |
-note: required by a bound in `std::cmp::AssertParamIsEq`
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-help: consider annotating `Error` with `#[derive(Eq)]`
-   |
-LL + #[derive(Eq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-tuple-struct.rs b/tests/ui/derives/derives-span-Eq-tuple-struct.rs
deleted file mode 100644
index abf6526b9007..000000000000
--- a/tests/ui/derives/derives-span-Eq-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(Eq,PartialEq)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Eq-tuple-struct.stderr b/tests/ui/derives/derives-span-Eq-tuple-struct.stderr
deleted file mode 100644
index 13396cb27246..000000000000
--- a/tests/ui/derives/derives-span-Eq-tuple-struct.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0277]: the trait bound `Error: Eq` is not satisfied
-  --> $DIR/derives-span-Eq-tuple-struct.rs:8:5
-   |
-LL | #[derive(Eq,PartialEq)]
-   |          -- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Eq` is not implemented for `Error`
-   |
-note: required by a bound in `std::cmp::AssertParamIsEq`
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-help: consider annotating `Error` with `#[derive(Eq)]`
-   |
-LL + #[derive(Eq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq.rs b/tests/ui/derives/derives-span-Eq.rs
new file mode 100644
index 000000000000..d2c889c10b9e
--- /dev/null
+++ b/tests/ui/derives/derives-span-Eq.rs
@@ -0,0 +1,31 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Eq)] line.
+
+#[derive(PartialEq)]
+struct Error;
+
+#[derive(Eq, PartialEq)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(Eq, PartialEq)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+
+#[derive(Eq, PartialEq)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Eq, PartialEq)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Eq.stderr b/tests/ui/derives/derives-span-Eq.stderr
new file mode 100644
index 000000000000..02da9e2ade45
--- /dev/null
+++ b/tests/ui/derives/derives-span-Eq.stderr
@@ -0,0 +1,71 @@
+error[E0277]: the trait bound `Error: Eq` is not satisfied
+  --> $DIR/derives-span-Eq.rs:10:9
+   |
+LL | #[derive(Eq, PartialEq)]
+   |          -- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ the trait `Eq` is not implemented for `Error`
+   |
+note: required by a bound in `std::cmp::AssertParamIsEq`
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+help: consider annotating `Error` with `#[derive(Eq)]`
+   |
+LL + #[derive(Eq)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Eq` is not satisfied
+  --> $DIR/derives-span-Eq.rs:17:9
+   |
+LL | #[derive(Eq, PartialEq)]
+   |          -- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ the trait `Eq` is not implemented for `Error`
+   |
+note: required by a bound in `std::cmp::AssertParamIsEq`
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+help: consider annotating `Error` with `#[derive(Eq)]`
+   |
+LL + #[derive(Eq)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Eq` is not satisfied
+  --> $DIR/derives-span-Eq.rs:23:5
+   |
+LL | #[derive(Eq, PartialEq)]
+   |          -- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Eq` is not implemented for `Error`
+   |
+note: required by a bound in `std::cmp::AssertParamIsEq`
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+help: consider annotating `Error` with `#[derive(Eq)]`
+   |
+LL + #[derive(Eq)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Eq` is not satisfied
+  --> $DIR/derives-span-Eq.rs:28:5
+   |
+LL | #[derive(Eq, PartialEq)]
+   |          -- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Eq` is not implemented for `Error`
+   |
+note: required by a bound in `std::cmp::AssertParamIsEq`
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+help: consider annotating `Error` with `#[derive(Eq)]`
+   |
+LL + #[derive(Eq)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-enum-struct-variant.rs b/tests/ui/derives/derives-span-Hash-enum-struct-variant.rs
deleted file mode 100644
index 3018a7b6d03e..000000000000
--- a/tests/ui/derives/derives-span-Hash-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Hash)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
deleted file mode 100644
index 9854b61d31bb..000000000000
--- a/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Hash` is not satisfied
-  --> $DIR/derives-span-Hash-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(Hash)]
-   |          ---- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ the trait `Hash` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Hash)]`
-   |
-LL + #[derive(Hash)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-enum.rs b/tests/ui/derives/derives-span-Hash-enum.rs
deleted file mode 100644
index 8ce7df18f06f..000000000000
--- a/tests/ui/derives/derives-span-Hash-enum.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-struct Error;
-
-#[derive(Hash)]
-enum Enum {
-   A(
-     Error //~ ERROR
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Hash-enum.stderr b/tests/ui/derives/derives-span-Hash-enum.stderr
deleted file mode 100644
index 60e7d0cf1ff9..000000000000
--- a/tests/ui/derives/derives-span-Hash-enum.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Hash` is not satisfied
-  --> $DIR/derives-span-Hash-enum.rs:8:6
-   |
-LL | #[derive(Hash)]
-   |          ---- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ the trait `Hash` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Hash)]`
-   |
-LL + #[derive(Hash)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-struct.rs b/tests/ui/derives/derives-span-Hash-struct.rs
deleted file mode 100644
index fa5e2af6be87..000000000000
--- a/tests/ui/derives/derives-span-Hash-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Hash)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Hash-struct.stderr b/tests/ui/derives/derives-span-Hash-struct.stderr
deleted file mode 100644
index 3851cf8ce8b0..000000000000
--- a/tests/ui/derives/derives-span-Hash-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Hash` is not satisfied
-  --> $DIR/derives-span-Hash-struct.rs:8:5
-   |
-LL | #[derive(Hash)]
-   |          ---- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Hash` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Hash)]`
-   |
-LL + #[derive(Hash)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-tuple-struct.rs b/tests/ui/derives/derives-span-Hash-tuple-struct.rs
deleted file mode 100644
index 3822bce1466e..000000000000
--- a/tests/ui/derives/derives-span-Hash-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(Hash)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Hash-tuple-struct.stderr b/tests/ui/derives/derives-span-Hash-tuple-struct.stderr
deleted file mode 100644
index e5a3e7a55664..000000000000
--- a/tests/ui/derives/derives-span-Hash-tuple-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Hash` is not satisfied
-  --> $DIR/derives-span-Hash-tuple-struct.rs:8:5
-   |
-LL | #[derive(Hash)]
-   |          ---- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Hash` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Hash)]`
-   |
-LL + #[derive(Hash)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash.rs b/tests/ui/derives/derives-span-Hash.rs
new file mode 100644
index 000000000000..73dacb67c6b6
--- /dev/null
+++ b/tests/ui/derives/derives-span-Hash.rs
@@ -0,0 +1,30 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Hash)] line.
+
+struct Error;
+
+#[derive(Hash)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(Hash)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+
+#[derive(Hash)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Hash)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Hash.stderr b/tests/ui/derives/derives-span-Hash.stderr
new file mode 100644
index 000000000000..41ba8d42ac5a
--- /dev/null
+++ b/tests/ui/derives/derives-span-Hash.stderr
@@ -0,0 +1,63 @@
+error[E0277]: the trait bound `Error: Hash` is not satisfied
+  --> $DIR/derives-span-Hash.rs:9:9
+   |
+LL | #[derive(Hash)]
+   |          ---- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ the trait `Hash` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Hash)]`
+   |
+LL + #[derive(Hash)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Hash` is not satisfied
+  --> $DIR/derives-span-Hash.rs:16:9
+   |
+LL | #[derive(Hash)]
+   |          ---- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ the trait `Hash` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Hash)]`
+   |
+LL + #[derive(Hash)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Hash` is not satisfied
+  --> $DIR/derives-span-Hash.rs:22:5
+   |
+LL | #[derive(Hash)]
+   |          ---- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Hash` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Hash)]`
+   |
+LL + #[derive(Hash)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Hash` is not satisfied
+  --> $DIR/derives-span-Hash.rs:27:5
+   |
+LL | #[derive(Hash)]
+   |          ---- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Hash` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Hash)]`
+   |
+LL + #[derive(Hash)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-enum-struct-variant.rs b/tests/ui/derives/derives-span-Ord-enum-struct-variant.rs
deleted file mode 100644
index 62355cc2d961..000000000000
--- a/tests/ui/derives/derives-span-Ord-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(Eq,PartialOrd,PartialEq)]
-struct Error;
-
-#[derive(Ord,Eq,PartialOrd,PartialEq)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
deleted file mode 100644
index e253a9173fc5..000000000000
--- a/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Ord` is not satisfied
-  --> $DIR/derives-span-Ord-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(Ord,Eq,PartialOrd,PartialEq)]
-   |          --- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ the trait `Ord` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Ord)]`
-   |
-LL + #[derive(Ord)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-enum.rs b/tests/ui/derives/derives-span-Ord-enum.rs
deleted file mode 100644
index 72738931d10f..000000000000
--- a/tests/ui/derives/derives-span-Ord-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(Eq,PartialOrd,PartialEq)]
-struct Error;
-
-#[derive(Ord,Eq,PartialOrd,PartialEq)]
-enum Enum {
-   A(
-     Error //~ ERROR
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Ord-enum.stderr b/tests/ui/derives/derives-span-Ord-enum.stderr
deleted file mode 100644
index 8a92458b51ca..000000000000
--- a/tests/ui/derives/derives-span-Ord-enum.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Ord` is not satisfied
-  --> $DIR/derives-span-Ord-enum.rs:9:6
-   |
-LL | #[derive(Ord,Eq,PartialOrd,PartialEq)]
-   |          --- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ the trait `Ord` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Ord)]`
-   |
-LL + #[derive(Ord)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-struct.rs b/tests/ui/derives/derives-span-Ord-struct.rs
deleted file mode 100644
index 53d4c2c22b55..000000000000
--- a/tests/ui/derives/derives-span-Ord-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(Eq,PartialOrd,PartialEq)]
-struct Error;
-
-#[derive(Ord,Eq,PartialOrd,PartialEq)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Ord-struct.stderr b/tests/ui/derives/derives-span-Ord-struct.stderr
deleted file mode 100644
index ae110d51196f..000000000000
--- a/tests/ui/derives/derives-span-Ord-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Ord` is not satisfied
-  --> $DIR/derives-span-Ord-struct.rs:8:5
-   |
-LL | #[derive(Ord,Eq,PartialOrd,PartialEq)]
-   |          --- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ the trait `Ord` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Ord)]`
-   |
-LL + #[derive(Ord)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-tuple-struct.rs b/tests/ui/derives/derives-span-Ord-tuple-struct.rs
deleted file mode 100644
index 4e09c2709864..000000000000
--- a/tests/ui/derives/derives-span-Ord-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(Eq,PartialOrd,PartialEq)]
-struct Error;
-
-#[derive(Ord,Eq,PartialOrd,PartialEq)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-Ord-tuple-struct.stderr b/tests/ui/derives/derives-span-Ord-tuple-struct.stderr
deleted file mode 100644
index e2a6d5266b71..000000000000
--- a/tests/ui/derives/derives-span-Ord-tuple-struct.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0277]: the trait bound `Error: Ord` is not satisfied
-  --> $DIR/derives-span-Ord-tuple-struct.rs:8:5
-   |
-LL | #[derive(Ord,Eq,PartialOrd,PartialEq)]
-   |          --- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ the trait `Ord` is not implemented for `Error`
-   |
-help: consider annotating `Error` with `#[derive(Ord)]`
-   |
-LL + #[derive(Ord)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord.rs b/tests/ui/derives/derives-span-Ord.rs
new file mode 100644
index 000000000000..91c3b50a030d
--- /dev/null
+++ b/tests/ui/derives/derives-span-Ord.rs
@@ -0,0 +1,31 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(Ord)] line.
+
+#[derive(Eq, PartialOrd, PartialEq)]
+struct Error;
+
+#[derive(Ord, Eq, PartialOrd, PartialEq)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(Ord, Eq, PartialOrd, PartialEq)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+
+#[derive(Ord, Eq, PartialOrd, PartialEq)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(Ord, Eq, PartialOrd, PartialEq)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-Ord.stderr b/tests/ui/derives/derives-span-Ord.stderr
new file mode 100644
index 000000000000..b0aaad19003d
--- /dev/null
+++ b/tests/ui/derives/derives-span-Ord.stderr
@@ -0,0 +1,63 @@
+error[E0277]: the trait bound `Error: Ord` is not satisfied
+  --> $DIR/derives-span-Ord.rs:10:9
+   |
+LL | #[derive(Ord, Eq, PartialOrd, PartialEq)]
+   |          --- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ the trait `Ord` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Ord)]`
+   |
+LL + #[derive(Ord)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Ord` is not satisfied
+  --> $DIR/derives-span-Ord.rs:17:9
+   |
+LL | #[derive(Ord, Eq, PartialOrd, PartialEq)]
+   |          --- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ the trait `Ord` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Ord)]`
+   |
+LL + #[derive(Ord)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Ord` is not satisfied
+  --> $DIR/derives-span-Ord.rs:23:5
+   |
+LL | #[derive(Ord, Eq, PartialOrd, PartialEq)]
+   |          --- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ the trait `Ord` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Ord)]`
+   |
+LL + #[derive(Ord)]
+LL | struct Error;
+   |
+
+error[E0277]: the trait bound `Error: Ord` is not satisfied
+  --> $DIR/derives-span-Ord.rs:28:5
+   |
+LL | #[derive(Ord, Eq, PartialOrd, PartialEq)]
+   |          --- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ the trait `Ord` is not implemented for `Error`
+   |
+help: consider annotating `Error` with `#[derive(Ord)]`
+   |
+LL + #[derive(Ord)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.rs b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.rs
deleted file mode 100644
index 67a27729db7e..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(PartialEq)]
-enum Enum {
-   A {
-     x: Error //~ ERROR
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
deleted file mode 100644
index 09104289c64a..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0369]: binary operation `==` cannot be applied to type `&Error`
-  --> $DIR/derives-span-PartialEq-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(PartialEq)]
-   |          --------- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^
-   |
-note: an implementation of `PartialEq` might be missing for `Error`
-  --> $DIR/derives-span-PartialEq-enum-struct-variant.rs:4:1
-   |
-LL | struct Error;
-   | ^^^^^^^^^^^^ must implement `PartialEq`
-help: consider annotating `Error` with `#[derive(PartialEq)]`
-   |
-LL + #[derive(PartialEq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-enum.rs b/tests/ui/derives/derives-span-PartialEq-enum.rs
deleted file mode 100644
index 0becc7e0d10f..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(PartialEq)]
-enum Enum {
-   A(
-     Error //~ ERROR
-   )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialEq-enum.stderr b/tests/ui/derives/derives-span-PartialEq-enum.stderr
deleted file mode 100644
index 40dca92ef23c..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-enum.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0369]: binary operation `==` cannot be applied to type `&Error`
-  --> $DIR/derives-span-PartialEq-enum.rs:9:6
-   |
-LL | #[derive(PartialEq)]
-   |          --------- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^
-   |
-note: an implementation of `PartialEq` might be missing for `Error`
-  --> $DIR/derives-span-PartialEq-enum.rs:4:1
-   |
-LL | struct Error;
-   | ^^^^^^^^^^^^ must implement `PartialEq`
-help: consider annotating `Error` with `#[derive(PartialEq)]`
-   |
-LL + #[derive(PartialEq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-struct.rs b/tests/ui/derives/derives-span-PartialEq-struct.rs
deleted file mode 100644
index c92ef5fadf73..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(PartialEq)]
-struct Struct {
-    x: Error //~ ERROR
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialEq-struct.stderr b/tests/ui/derives/derives-span-PartialEq-struct.stderr
deleted file mode 100644
index cfd9fc41d061..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-struct.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0369]: binary operation `==` cannot be applied to type `Error`
-  --> $DIR/derives-span-PartialEq-struct.rs:8:5
-   |
-LL | #[derive(PartialEq)]
-   |          --------- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^
-   |
-note: an implementation of `PartialEq` might be missing for `Error`
-  --> $DIR/derives-span-PartialEq-struct.rs:4:1
-   |
-LL | struct Error;
-   | ^^^^^^^^^^^^ must implement `PartialEq`
-help: consider annotating `Error` with `#[derive(PartialEq)]`
-   |
-LL + #[derive(PartialEq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-tuple-struct.rs b/tests/ui/derives/derives-span-PartialEq-tuple-struct.rs
deleted file mode 100644
index 10ac347aa0be..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-
-struct Error;
-
-#[derive(PartialEq)]
-struct Struct(
-    Error //~ ERROR
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr b/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
deleted file mode 100644
index 4e35cbb534d9..000000000000
--- a/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0369]: binary operation `==` cannot be applied to type `Error`
-  --> $DIR/derives-span-PartialEq-tuple-struct.rs:8:5
-   |
-LL | #[derive(PartialEq)]
-   |          --------- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^
-   |
-note: an implementation of `PartialEq` might be missing for `Error`
-  --> $DIR/derives-span-PartialEq-tuple-struct.rs:4:1
-   |
-LL | struct Error;
-   | ^^^^^^^^^^^^ must implement `PartialEq`
-help: consider annotating `Error` with `#[derive(PartialEq)]`
-   |
-LL + #[derive(PartialEq)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq.rs b/tests/ui/derives/derives-span-PartialEq.rs
new file mode 100644
index 000000000000..ef79f095f46e
--- /dev/null
+++ b/tests/ui/derives/derives-span-PartialEq.rs
@@ -0,0 +1,29 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(PartialEq)] line.
+
+struct Error;
+
+#[derive(PartialEq)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(PartialEq)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+#[derive(PartialEq)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(PartialEq)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialEq.stderr b/tests/ui/derives/derives-span-PartialEq.stderr
new file mode 100644
index 000000000000..c2e928885ce2
--- /dev/null
+++ b/tests/ui/derives/derives-span-PartialEq.stderr
@@ -0,0 +1,83 @@
+error[E0369]: binary operation `==` cannot be applied to type `&Error`
+  --> $DIR/derives-span-PartialEq.rs:9:9
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^
+   |
+note: an implementation of `PartialEq` might be missing for `Error`
+  --> $DIR/derives-span-PartialEq.rs:4:1
+   |
+LL | struct Error;
+   | ^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `Error` with `#[derive(PartialEq)]`
+   |
+LL + #[derive(PartialEq)]
+LL | struct Error;
+   |
+
+error[E0369]: binary operation `==` cannot be applied to type `&Error`
+  --> $DIR/derives-span-PartialEq.rs:16:9
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^
+   |
+note: an implementation of `PartialEq` might be missing for `Error`
+  --> $DIR/derives-span-PartialEq.rs:4:1
+   |
+LL | struct Error;
+   | ^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `Error` with `#[derive(PartialEq)]`
+   |
+LL + #[derive(PartialEq)]
+LL | struct Error;
+   |
+
+error[E0369]: binary operation `==` cannot be applied to type `Error`
+  --> $DIR/derives-span-PartialEq.rs:21:5
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^
+   |
+note: an implementation of `PartialEq` might be missing for `Error`
+  --> $DIR/derives-span-PartialEq.rs:4:1
+   |
+LL | struct Error;
+   | ^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `Error` with `#[derive(PartialEq)]`
+   |
+LL + #[derive(PartialEq)]
+LL | struct Error;
+   |
+
+error[E0369]: binary operation `==` cannot be applied to type `Error`
+  --> $DIR/derives-span-PartialEq.rs:26:5
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^
+   |
+note: an implementation of `PartialEq` might be missing for `Error`
+  --> $DIR/derives-span-PartialEq.rs:4:1
+   |
+LL | struct Error;
+   | ^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `Error` with `#[derive(PartialEq)]`
+   |
+LL + #[derive(PartialEq)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.rs b/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.rs
deleted file mode 100644
index a769c137657c..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(PartialOrd,PartialEq)]
-enum Enum {
-   A {
-     x: Error //~ ERROR can't compare `Error` with `Error`
-   }
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr b/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
deleted file mode 100644
index 7fe09d45cc1b..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: can't compare `Error` with `Error`
-  --> $DIR/derives-span-PartialOrd-enum-struct-variant.rs:9:6
-   |
-LL | #[derive(PartialOrd,PartialEq)]
-   |          ---------- in this derive macro expansion
-...
-LL |      x: Error
-   |      ^^^^^^^^ no implementation for `Error < Error` and `Error > Error`
-   |
-   = help: the trait `PartialOrd` is not implemented for `Error`
-help: consider annotating `Error` with `#[derive(PartialOrd)]`
-   |
-LL + #[derive(PartialOrd)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum.rs b/tests/ui/derives/derives-span-PartialOrd-enum.rs
deleted file mode 100644
index 4f0d794e42d7..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-enum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(PartialOrd,PartialEq)]
-enum Enum {
-   A(
-     Error //~ ERROR can't compare `Error` with `Error`
-     )
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum.stderr b/tests/ui/derives/derives-span-PartialOrd-enum.stderr
deleted file mode 100644
index 2a14e6e96187..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-enum.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: can't compare `Error` with `Error`
-  --> $DIR/derives-span-PartialOrd-enum.rs:9:6
-   |
-LL | #[derive(PartialOrd,PartialEq)]
-   |          ---------- in this derive macro expansion
-...
-LL |      Error
-   |      ^^^^^ no implementation for `Error < Error` and `Error > Error`
-   |
-   = help: the trait `PartialOrd` is not implemented for `Error`
-help: consider annotating `Error` with `#[derive(PartialOrd)]`
-   |
-LL + #[derive(PartialOrd)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-struct.rs b/tests/ui/derives/derives-span-PartialOrd-struct.rs
deleted file mode 100644
index da857c674357..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(PartialOrd,PartialEq)]
-struct Struct {
-    x: Error //~ ERROR can't compare `Error` with `Error`
-}
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialOrd-struct.stderr b/tests/ui/derives/derives-span-PartialOrd-struct.stderr
deleted file mode 100644
index 0904e3ace8f0..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-struct.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: can't compare `Error` with `Error`
-  --> $DIR/derives-span-PartialOrd-struct.rs:8:5
-   |
-LL | #[derive(PartialOrd,PartialEq)]
-   |          ---------- in this derive macro expansion
-LL | struct Struct {
-LL |     x: Error
-   |     ^^^^^^^^ no implementation for `Error < Error` and `Error > Error`
-   |
-   = help: the trait `PartialOrd` is not implemented for `Error`
-help: consider annotating `Error` with `#[derive(PartialOrd)]`
-   |
-LL + #[derive(PartialOrd)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.rs b/tests/ui/derives/derives-span-PartialOrd-tuple-struct.rs
deleted file mode 100644
index 61d507670880..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
-
-#[derive(PartialEq)]
-struct Error;
-
-#[derive(PartialOrd,PartialEq)]
-struct Struct(
-    Error //~ ERROR can't compare `Error` with `Error`
-);
-
-fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr b/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
deleted file mode 100644
index 501fea02e8ef..000000000000
--- a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: can't compare `Error` with `Error`
-  --> $DIR/derives-span-PartialOrd-tuple-struct.rs:8:5
-   |
-LL | #[derive(PartialOrd,PartialEq)]
-   |          ---------- in this derive macro expansion
-LL | struct Struct(
-LL |     Error
-   |     ^^^^^ no implementation for `Error < Error` and `Error > Error`
-   |
-   = help: the trait `PartialOrd` is not implemented for `Error`
-help: consider annotating `Error` with `#[derive(PartialOrd)]`
-   |
-LL + #[derive(PartialOrd)]
-LL | struct Error;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd.rs b/tests/ui/derives/derives-span-PartialOrd.rs
new file mode 100644
index 000000000000..7f7f188b1abb
--- /dev/null
+++ b/tests/ui/derives/derives-span-PartialOrd.rs
@@ -0,0 +1,31 @@
+//! Check that all the derives have spans that point to the fields,
+//! rather than the #[derive(PartialOrd)] line.
+
+#[derive(PartialEq)]
+struct Error;
+
+#[derive(PartialOrd, PartialEq)]
+enum EnumStructVariant {
+    A {
+        x: Error, //~ ERROR
+    },
+}
+
+#[derive(PartialOrd, PartialEq)]
+enum EnumTupleVariant {
+    A(
+        Error, //~ ERROR
+    ),
+}
+
+#[derive(PartialOrd, PartialEq)]
+struct Struct {
+    x: Error, //~ ERROR
+}
+
+#[derive(PartialOrd, PartialEq)]
+struct TupleStruct(
+    Error, //~ ERROR
+);
+
+fn main() {}
diff --git a/tests/ui/derives/derives-span-PartialOrd.stderr b/tests/ui/derives/derives-span-PartialOrd.stderr
new file mode 100644
index 000000000000..3429ee19ccf6
--- /dev/null
+++ b/tests/ui/derives/derives-span-PartialOrd.stderr
@@ -0,0 +1,67 @@
+error[E0277]: can't compare `Error` with `Error`
+  --> $DIR/derives-span-PartialOrd.rs:10:9
+   |
+LL | #[derive(PartialOrd, PartialEq)]
+   |          ---------- in this derive macro expansion
+...
+LL |         x: Error,
+   |         ^^^^^^^^ no implementation for `Error < Error` and `Error > Error`
+   |
+   = help: the trait `PartialOrd` is not implemented for `Error`
+help: consider annotating `Error` with `#[derive(PartialOrd)]`
+   |
+LL + #[derive(PartialOrd)]
+LL | struct Error;
+   |
+
+error[E0277]: can't compare `Error` with `Error`
+  --> $DIR/derives-span-PartialOrd.rs:17:9
+   |
+LL | #[derive(PartialOrd, PartialEq)]
+   |          ---------- in this derive macro expansion
+...
+LL |         Error,
+   |         ^^^^^ no implementation for `Error < Error` and `Error > Error`
+   |
+   = help: the trait `PartialOrd` is not implemented for `Error`
+help: consider annotating `Error` with `#[derive(PartialOrd)]`
+   |
+LL + #[derive(PartialOrd)]
+LL | struct Error;
+   |
+
+error[E0277]: can't compare `Error` with `Error`
+  --> $DIR/derives-span-PartialOrd.rs:23:5
+   |
+LL | #[derive(PartialOrd, PartialEq)]
+   |          ---------- in this derive macro expansion
+LL | struct Struct {
+LL |     x: Error,
+   |     ^^^^^^^^ no implementation for `Error < Error` and `Error > Error`
+   |
+   = help: the trait `PartialOrd` is not implemented for `Error`
+help: consider annotating `Error` with `#[derive(PartialOrd)]`
+   |
+LL + #[derive(PartialOrd)]
+LL | struct Error;
+   |
+
+error[E0277]: can't compare `Error` with `Error`
+  --> $DIR/derives-span-PartialOrd.rs:28:5
+   |
+LL | #[derive(PartialOrd, PartialEq)]
+   |          ---------- in this derive macro expansion
+LL | struct TupleStruct(
+LL |     Error,
+   |     ^^^^^ no implementation for `Error < Error` and `Error > Error`
+   |
+   = help: the trait `PartialOrd` is not implemented for `Error`
+help: consider annotating `Error` with `#[derive(PartialOrd)]`
+   |
+LL + #[derive(PartialOrd)]
+LL | struct Error;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/deriving-primitive.rs b/tests/ui/derives/deriving-primitive.rs
deleted file mode 100644
index 1173eca640fc..000000000000
--- a/tests/ui/derives/deriving-primitive.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[derive(FromPrimitive)] //~ ERROR cannot find derive macro `FromPrimitive` in this scope
-                         //~| ERROR cannot find derive macro `FromPrimitive` in this scope
-enum Foo {}
-
-fn main() {}
diff --git a/tests/ui/derives/deriving-primitive.stderr b/tests/ui/derives/deriving-primitive.stderr
deleted file mode 100644
index b39637825e56..000000000000
--- a/tests/ui/derives/deriving-primitive.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: cannot find derive macro `FromPrimitive` in this scope
-  --> $DIR/deriving-primitive.rs:1:10
-   |
-LL | #[derive(FromPrimitive)]
-   |          ^^^^^^^^^^^^^
-
-error: cannot find derive macro `FromPrimitive` in this scope
-  --> $DIR/deriving-primitive.rs:1:10
-   |
-LL | #[derive(FromPrimitive)]
-   |          ^^^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
-

From 4aa2d6fbf48d830dd6f914fa9558c173e40fbbe0 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 14 Mar 2026 22:12:50 +0800
Subject: [PATCH 0469/1059] Fix field ref in macro for
 'convert_tuple_struct_to_named_struct'

---
 .../handlers/convert_tuple_struct_to_named_struct.rs   | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
index f8b9bb68db81..ba22224b6be2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -252,13 +252,15 @@ fn edit_field_references(
         let usages = def.usages(&ctx.sema).all();
         for (file_id, refs) in usages {
             let source = ctx.sema.parse(file_id);
-            let source = source.syntax();
-            let mut editor = edit.make_editor(source);
+            let mut editor = edit.make_editor(source.syntax());
             for r in refs {
                 if let Some(name_ref) = r.name.as_name_ref()
-                    && let Some(original) = ctx.sema.original_ast_node(name_ref.clone())
+                    && let Some(original) = ctx.sema.original_range_opt(name_ref.syntax())
                 {
-                    editor.replace(original.syntax(), name.syntax());
+                    editor.replace_all(
+                        cover_edit_range(&source, original.range),
+                        vec![name.syntax().clone().into()],
+                    );
                 }
             }
             edit.add_file_edits(file_id.file_id(ctx.db()), editor);

From 77a20144b57bb9c5c3cf7379f6235822597c573d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 14 Mar 2026 19:59:40 +0800
Subject: [PATCH 0470/1059] Fix overlap edit on tuple to record assist expr
 uses self

Example
---
```rust
struct T$0(u8);
fn test(t: T) {
    T(t.0);
}
```

**Before this PR**

Panic

**After this PR**

```rust
struct T { field1: u8 }
fn test(t: T) {
    T { field1: t.field1 };
}
```
---
 .../convert_named_struct_to_tuple_struct.rs   |  25 +-
 .../convert_tuple_struct_to_named_struct.rs   | 264 ++++++++++++------
 .../crates/ide-assists/src/utils.rs           |  14 +
 3 files changed, 198 insertions(+), 105 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
index 8dfd4598dfa1..42fceb85336b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
@@ -1,9 +1,7 @@
-use std::ops::RangeInclusive;
-
 use either::Either;
 use ide_db::{defs::Definition, search::FileReference};
 use syntax::{
-    NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, T, TextRange,
+    NodeOrToken, SyntaxKind, SyntaxNode, T,
     algo::next_non_trivia_token,
     ast::{
         self, AstNode, HasAttrs, HasGenericParams, HasVisibility, syntax_factory::SyntaxFactory,
@@ -12,7 +10,9 @@
     syntax_editor::{Element, Position, SyntaxEditor},
 };
 
-use crate::{AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder};
+use crate::{
+    AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder, utils::cover_edit_range,
+};
 
 // Assist: convert_named_struct_to_tuple_struct
 //
@@ -242,7 +242,7 @@ fn record_to_tuple_struct_like<T, I>(
 {
     let make = SyntaxFactory::without_mappings();
     let orig = ctx.sema.original_range_opt(field_list.syntax())?;
-    let list_range = cover_range(source, orig.range);
+    let list_range = cover_edit_range(source, orig.range);
 
     let l_curly = match list_range.start() {
         NodeOrToken::Node(node) => node.first_token()?,
@@ -265,7 +265,7 @@ fn record_to_tuple_struct_like<T, I>(
 
     for name_ref in fields(&field_list) {
         let Some(orig) = ctx.sema.original_range_opt(name_ref.syntax()) else { continue };
-        let name_range = cover_range(source, orig.range);
+        let name_range = cover_edit_range(source, orig.range);
 
         if let Some(colon) = next_non_trivia_token(name_range.end().clone())
             && colon.kind() == T![:]
@@ -306,7 +306,7 @@ fn edit_field_references(
                     // Only edit the field reference if it's part of a `.field` access
                     if name_ref.syntax().parent().and_then(ast::FieldExpr::cast).is_some() {
                         edit.replace_all(
-                            cover_range(&source, r.range),
+                            cover_edit_range(&source, r.range),
                             vec![make.name_ref(&index.to_string()).syntax().clone().into()],
                         );
                     }
@@ -318,17 +318,6 @@ fn edit_field_references(
     }
 }
 
-fn cover_range(source: &ast::SourceFile, range: TextRange) -> RangeInclusive<SyntaxElement> {
-    let node = match source.syntax().covering_element(range) {
-        NodeOrToken::Node(node) => node,
-        NodeOrToken::Token(t) => t.parent().unwrap(),
-    };
-    let mut iter = node.children_with_tokens().filter(|it| range.contains_range(it.text_range()));
-    let first = iter.next().unwrap_or(node.into());
-    let last = iter.last().unwrap_or_else(|| first.clone());
-    first..=last
-}
-
 fn delete_whitespace(edit: &mut SyntaxEditor, whitespace: Option<impl Element>) {
     let Some(whitespace) = whitespace else { return };
     let NodeOrToken::Token(token) = whitespace.syntax_element() else { return };
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
index ba22224b6be2..f1eae8386637 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -1,17 +1,21 @@
 use either::Either;
-use hir::FileRangeWrapper;
-use ide_db::defs::{Definition, NameRefClass};
-use std::ops::RangeInclusive;
+use ide_db::{
+    defs::{Definition, NameRefClass},
+    search::FileReference,
+};
 use syntax::{
-    SyntaxElement, SyntaxKind, SyntaxNode, T, TextSize,
+    SyntaxKind, T,
     ast::{
-        self, AstNode, HasAttrs, HasGenericParams, HasVisibility, syntax_factory::SyntaxFactory,
+        self, AstNode, HasArgList, HasAttrs, HasGenericParams, HasVisibility,
+        syntax_factory::SyntaxFactory,
     },
     match_ast,
     syntax_editor::{Element, Position, SyntaxEditor},
 };
 
-use crate::{AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder};
+use crate::{
+    AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder, utils::cover_edit_range,
+};
 
 // Assist: convert_tuple_struct_to_named_struct
 //
@@ -147,93 +151,121 @@ fn edit_struct_references(
     };
     let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
-    let edit_node = |node: SyntaxNode| -> Option<SyntaxNode> {
-        let make = SyntaxFactory::without_mappings();
-        match_ast! {
-            match node {
-                ast::TupleStructPat(tuple_struct_pat) => {
-                    Some(make.record_pat_with_fields(
-                        tuple_struct_pat.path()?,
-                        generate_record_pat_list(&tuple_struct_pat, names),
-                    ).syntax().clone())
-                },
-                // for tuple struct creations like Foo(42)
-                ast::CallExpr(call_expr) => {
-                    let path = call_expr.syntax().descendants().find_map(ast::PathExpr::cast).and_then(|expr| expr.path())?;
-
-                    // this also includes method calls like Foo::new(42), we should skip them
-                    if let Some(name_ref) = path.segment().and_then(|s| s.name_ref()) {
-                        match NameRefClass::classify(&ctx.sema, &name_ref) {
-                            Some(NameRefClass::Definition(Definition::SelfType(_), _)) => {},
-                            Some(NameRefClass::Definition(def, _)) if def == strukt_def => {},
-                            _ => return None,
-                        };
-                    }
-
-                    let arg_list = call_expr.syntax().descendants().find_map(ast::ArgList::cast)?;
-                    Some(
-                        make.record_expr(
-                            path,
-                            ast::make::record_expr_field_list(arg_list.args().zip(names).map(
-                                |(expr, name)| {
-                                    ast::make::record_expr_field(
-                                        ast::make::name_ref(&name.to_string()),
-                                        Some(expr),
-                                    )
-                                },
-                            )),
-                        ).syntax().clone()
-                    )
-                },
-                _ => None,
-            }
-        }
-    };
-
     for (file_id, refs) in usages {
         let source = ctx.sema.parse(file_id);
-        let source = source.syntax();
+        let mut editor = edit.make_editor(source.syntax());
 
-        let mut editor = edit.make_editor(source);
-        for r in refs.iter().rev() {
-            if let Some((old_node, new_node)) = r
-                .name
-                .syntax()
-                .ancestors()
-                .find_map(|node| Some((node.clone(), edit_node(node.clone())?)))
-            {
-                if let Some(old_node) = ctx.sema.original_syntax_node_rooted(&old_node) {
-                    editor.replace(old_node, new_node);
-                } else {
-                    let FileRangeWrapper { file_id: _, range } = ctx.sema.original_range(&old_node);
-                    let parent = source.covering_element(range);
-                    match parent {
-                        SyntaxElement::Token(token) => {
-                            editor.replace(token, new_node.syntax_element());
-                        }
-                        SyntaxElement::Node(parent_node) => {
-                            // replace the part of macro
-                            // ```
-                            // foo!(a, Test::A(0));
-                            //     ^^^^^^^^^^^^^^^ // parent_node
-                            //         ^^^^^^^^^^  // replace_range
-                            // ```
-                            let start = parent_node
-                                .children_with_tokens()
-                                .find(|t| t.text_range().contains(range.start()));
-                            let end = parent_node
-                                .children_with_tokens()
-                                .find(|t| t.text_range().contains(range.end() - TextSize::new(1)));
-                            if let (Some(start), Some(end)) = (start, end) {
-                                let replace_range = RangeInclusive::new(start, end);
-                                editor.replace_all(replace_range, vec![new_node.into()]);
-                            }
-                        }
+        for r in refs {
+            process_struct_name_reference(ctx, r, &mut editor, &source, &strukt_def, names);
+        }
+
+        edit.add_file_edits(file_id.file_id(ctx.db()), editor);
+    }
+}
+
+fn process_struct_name_reference(
+    ctx: &AssistContext<'_>,
+    r: FileReference,
+    editor: &mut SyntaxEditor,
+    source: &ast::SourceFile,
+    strukt_def: &Definition,
+    names: &[ast::Name],
+) -> Option<()> {
+    let make = SyntaxFactory::without_mappings();
+    let name_ref = r.name.as_name_ref()?;
+    let path_segment = name_ref.syntax().parent().and_then(ast::PathSegment::cast)?;
+    let full_path = path_segment.syntax().parent().and_then(ast::Path::cast)?.top_path();
+
+    if full_path.segment()?.name_ref()? != *name_ref {
+        // `name_ref` isn't the last segment of the path, so `full_path` doesn't point to the
+        // struct we want to edit.
+        return None;
+    }
+
+    let parent = full_path.syntax().parent()?;
+    match_ast! {
+        match parent {
+            ast::TupleStructPat(tuple_struct_pat) => {
+                let range = ctx.sema.original_range_opt(tuple_struct_pat.syntax())?.range;
+                let new = make.record_pat_with_fields(
+                    full_path,
+                    generate_record_pat_list(&tuple_struct_pat, names),
+                );
+                editor.replace_all(cover_edit_range(source, range), vec![new.syntax().clone().into()]);
+            },
+            ast::PathExpr(path_expr) => {
+                let call_expr = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
+
+                // this also includes method calls like Foo::new(42), we should skip them
+                match NameRefClass::classify(&ctx.sema, name_ref) {
+                    Some(NameRefClass::Definition(Definition::SelfType(_), _)) => {},
+                    Some(NameRefClass::Definition(def, _)) if def == *strukt_def => {},
+                    _ => return None,
+                }
+
+                let arg_list = call_expr.arg_list()?;
+                let mut first_insert = vec![];
+                for (expr, name) in arg_list.args().zip(names) {
+                    let range = ctx.sema.original_range_opt(expr.syntax())?.range;
+                    let place = cover_edit_range(source, range);
+                    let elements = vec![
+                        make.name_ref(&name.text()).syntax().clone().into(),
+                        make.token(T![:]).into(),
+                        make.whitespace(" ").into(),
+                    ];
+                    if first_insert.is_empty() {
+                        // XXX: SyntaxEditor cannot insert after deleted element
+                        first_insert = elements;
+                    } else {
+                        editor.insert_all(Position::before(place.start()), elements);
                     }
                 }
-            }
+                process_delimiter(ctx, source, editor, &arg_list, first_insert);
+            },
+            _ => {}
         }
-        edit.add_file_edits(file_id.file_id(ctx.db()), editor);
+    }
+    Some(())
+}
+
+fn process_delimiter(
+    ctx: &AssistContext<'_>,
+    source: &ast::SourceFile,
+    editor: &mut SyntaxEditor,
+    list: &impl AstNode,
+    first_insert: Vec<syntax::SyntaxElement>,
+) {
+    let Some(range) = ctx.sema.original_range_opt(list.syntax()) else { return };
+    let place = cover_edit_range(source, range.range);
+
+    let l_paren = match place.start() {
+        syntax::NodeOrToken::Node(node) => node.first_token(),
+        syntax::NodeOrToken::Token(t) => Some(t.clone()),
+    };
+    let r_paren = match place.end() {
+        syntax::NodeOrToken::Node(node) => node.last_token(),
+        syntax::NodeOrToken::Token(t) => Some(t.clone()),
+    };
+
+    let make = SyntaxFactory::without_mappings();
+    if let Some(l_paren) = l_paren
+        && l_paren.kind() == T!['(']
+    {
+        let mut open_delim = vec![
+            make.whitespace(" ").into(),
+            make.token(T!['{']).into(),
+            make.whitespace(" ").into(),
+        ];
+        open_delim.extend(first_insert);
+        editor.replace_with_many(l_paren, open_delim);
+    }
+    if let Some(r_paren) = r_paren
+        && r_paren.kind() == T![')']
+    {
+        editor.replace_with_many(
+            r_paren,
+            vec![make.whitespace(" ").into(), make.token(T!['}']).into()],
+        );
     }
 }
 
@@ -741,6 +773,64 @@ struct Wrap<T>
 "#,
         );
     }
+
+    #[test]
+    fn convert_expr_uses_self() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+struct T$0(u8);
+fn test(t: T) {
+    T(t.0);
+    id!(T(t.0));
+}"#,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+struct T { field1: u8 }
+fn test(t: T) {
+    T { field1: t.field1 };
+    id!(T { field1: t.field1 });
+}"#,
+        );
+    }
+
+    #[test]
+    #[ignore = "FIXME overlap edits in nested uses self"]
+    fn convert_pat_uses_self() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+enum T {
+    $0Value(&'static T),
+    Nil,
+}
+fn test(t: T) {
+    if let T::Value(T::Value(t)) = t {}
+    if let id!(T::Value(T::Value(t))) = t {}
+}"#,
+            r#"
+macro_rules! id {
+    ($($t:tt)*) => { $($t)* }
+}
+enum T {
+    Value { field1: &'static T },
+    Nil,
+}
+fn test(t: T) {
+    if let T::Value { field1: T::Value { field1: t } } = t {}
+    if let id!(T::Value { field1: T::Value { field1: t } }) = t {}
+}"#,
+        );
+    }
+
     #[test]
     fn not_applicable_other_than_tuple_variant() {
         check_assist_not_applicable(
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index b4055e77ccf8..a3178aba1269 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1254,6 +1254,20 @@ pub(crate) fn cover_let_chain(mut expr: ast::Expr, range: TextRange) -> Option<a
     }
 }
 
+pub(crate) fn cover_edit_range(
+    source: &impl AstNode,
+    range: TextRange,
+) -> std::ops::RangeInclusive<syntax::SyntaxElement> {
+    let node = match source.syntax().covering_element(range) {
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(t) => t.parent().unwrap(),
+    };
+    let mut iter = node.children_with_tokens().filter(|it| range.contains_range(it.text_range()));
+    let first = iter.next().unwrap_or(node.into());
+    let last = iter.last().unwrap_or_else(|| first.clone());
+    first..=last
+}
+
 pub(crate) fn is_selected(
     it: &impl AstNode,
     selection: syntax::TextRange,

From 425df0dedb4e20be0bab9d028e6444a7339ea937 Mon Sep 17 00:00:00 2001
From: Zakarum <zaq.dev@icloud.com>
Date: Thu, 19 Feb 2026 15:17:01 +0100
Subject: [PATCH 0471/1059] Do not emit separator as before elements

---
 library/core/src/iter/adapters/intersperse.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/library/core/src/iter/adapters/intersperse.rs b/library/core/src/iter/adapters/intersperse.rs
index bb94ed0a0a17..f33a67a98310 100644
--- a/library/core/src/iter/adapters/intersperse.rs
+++ b/library/core/src/iter/adapters/intersperse.rs
@@ -57,8 +57,9 @@ fn next(&mut self) -> Option<Self::Item> {
                 }
             }
         } else {
-            self.started = true;
-            self.iter.next()
+            let item = self.iter.next();
+            self.started = item.is_some();
+            item
         }
     }
 
@@ -173,8 +174,9 @@ fn next(&mut self) -> Option<Self::Item> {
                 }
             }
         } else {
-            self.started = true;
-            self.iter.next()
+            let item = self.iter.next();
+            self.started = item.is_some();
+            item
         }
     }
 

From b2d9051502c662298cf1a599ec31c11e0afcba65 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 14 Mar 2026 17:02:45 +0100
Subject: [PATCH 0472/1059] internal: Refactor `MirLowerCtx` to use
 `&ExpressionStore` instead of `&Body`

---
 .../crates/hir-ty/src/consteval.rs            |   4 +-
 .../rust-analyzer/crates/hir-ty/src/mir.rs    |   5 +-
 .../crates/hir-ty/src/mir/lower.rs            | 118 +++++++++++-------
 .../crates/hir-ty/src/mir/lower/as_place.rs   |   4 +-
 .../hir-ty/src/mir/lower/pattern_matching.rs  |  15 ++-
 5 files changed, 92 insertions(+), 54 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 5bc2446fdd2d..07e9f70faea6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -28,7 +28,7 @@
     traits::StoredParamEnvAndCrate,
 };
 
-use super::mir::{interpret_mir, lower_to_mir, pad16};
+use super::mir::{interpret_mir, lower_body_to_mir, pad16};
 
 pub fn unknown_const<'db>(_ty: Ty<'db>) -> Const<'db> {
     Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed))
@@ -333,7 +333,7 @@ fn has_closure(body: &Body, expr: ExprId) -> bool {
             return c;
         }
     }
-    if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr)
+    if let Ok(mir_body) = lower_body_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr)
         && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None)
     {
         return result;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
index 664238601108..bf17c784682c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -40,7 +40,10 @@
 pub use eval::{
     Evaluator, MirEvalError, VTableMap, interpret_mir, pad16, render_const_using_debug_impl,
 };
-pub use lower::{MirLowerError, lower_to_mir, mir_body_for_closure_query, mir_body_query};
+pub use lower::{
+    MirLowerError, lower_body_to_mir, lower_to_mir_with_store, mir_body_for_closure_query,
+    mir_body_query,
+};
 pub use monomorphization::{
     monomorphized_mir_body_for_closure_query, monomorphized_mir_body_query,
 };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 8d5e5c2e6e74..2e849bcf3a12 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -82,7 +82,7 @@ struct MirLowerCtx<'a, 'db> {
     labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>,
     discr_temp: Option<Place>,
     db: &'db dyn HirDatabase,
-    body: &'a Body,
+    store: &'a ExpressionStore,
     infer: &'a InferenceResult,
     types: &'db crate::next_solver::DefaultAny<'db>,
     resolver: Resolver<'db>,
@@ -285,7 +285,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
     fn new(
         db: &'db dyn HirDatabase,
         owner: DefWithBodyId,
-        body: &'a Body,
+        store: &'a ExpressionStore,
         infer: &'a InferenceResult,
     ) -> Self {
         let mut basic_blocks = Arena::new();
@@ -316,7 +316,7 @@ fn new(
             result: mir,
             db,
             infer,
-            body,
+            store,
             types: crate::next_solver::default_types(db),
             owner,
             resolver,
@@ -354,7 +354,7 @@ fn lower_expr_to_some_operand(
         current: BasicBlockId,
     ) -> Result<'db, Option<(Operand, BasicBlockId)>> {
         if !self.has_adjustments(expr_id)
-            && let Expr::Literal(l) = &self.body[expr_id]
+            && let Expr::Literal(l) = &self.store[expr_id]
         {
             let ty = self.expr_ty_without_adjust(expr_id);
             return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));
@@ -461,7 +461,7 @@ fn lower_expr_to_place_without_adjust(
         place: Place,
         mut current: BasicBlockId,
     ) -> Result<'db, Option<BasicBlockId>> {
-        match &self.body[expr_id] {
+        match &self.store[expr_id] {
             Expr::OffsetOf(_) => {
                 not_supported!("builtin#offset_of")
             }
@@ -500,7 +500,7 @@ fn lower_expr_to_place_without_adjust(
                     } else {
                         let resolver_guard =
                             self.resolver.update_to_inner_scope(self.db, self.owner, expr_id);
-                        let hygiene = self.body.expr_path_hygiene(expr_id);
+                        let hygiene = self.store.expr_path_hygiene(expr_id);
                         let result = self
                             .resolver
                             .resolve_path_in_value_ns_fully(self.db, p, hygiene)
@@ -509,7 +509,7 @@ fn lower_expr_to_place_without_adjust(
                                     self.db,
                                     p,
                                     DisplayTarget::from_crate(self.db, self.krate()),
-                                    self.body,
+                                    self.store,
                                 )
                             })?;
                         self.resolver.reset_to_guard(resolver_guard);
@@ -882,7 +882,7 @@ fn lower_expr_to_place_without_adjust(
                 let variant_id =
                     self.infer.variant_resolution_for_expr(expr_id).ok_or_else(|| match path {
                         Some(p) => MirLowerError::UnresolvedName(
-                            hir_display_with_store(&**p, self.body)
+                            hir_display_with_store(&**p, self.store)
                                 .display(self.db, self.display_target())
                                 .to_string(),
                         ),
@@ -1382,7 +1382,7 @@ fn lower_expr_to_place_without_adjust(
     }
 
     fn push_field_projection(&mut self, place: &mut Place, expr_id: ExprId) -> Result<'db, ()> {
-        if let Expr::Field { expr, name } = &self.body[expr_id] {
+        if let Expr::Field { expr, name } = &self.store[expr_id] {
             if let TyKind::Tuple(..) = self.expr_ty_after_adjustments(*expr).kind() {
                 let index =
                     name.as_tuple_index().ok_or(MirLowerError::TypeError("named field on tuple"))?
@@ -1411,7 +1411,7 @@ fn lower_literal_or_const_to_operand(
         ty: Ty<'db>,
         loc: &ExprId,
     ) -> Result<'db, Operand> {
-        match &self.body[*loc] {
+        match &self.store[*loc] {
             Expr::Literal(l) => self.lower_literal_to_operand(ty, l),
             Expr::Path(c) => {
                 let owner = self.owner;
@@ -1421,7 +1421,7 @@ fn lower_literal_or_const_to_operand(
                         self.db,
                         c,
                         DisplayTarget::from_crate(db, owner.krate(db)),
-                        self.body,
+                        self.store,
                     )
                 };
                 let pr = self
@@ -1859,7 +1859,7 @@ fn lower_block_to_place(
                         }
                     } else {
                         let mut err = None;
-                        self.body.walk_bindings_in_pat(*pat, |b| {
+                        self.store.walk_bindings_in_pat(*pat, |b| {
                             if let Err(e) = self.push_storage_live(b, current) {
                                 err = Some(e);
                             }
@@ -1913,9 +1913,9 @@ fn lower_params_and_bindings(
         self.result.param_locals.extend(params.clone().map(|(it, ty)| {
             let local_id = self.result.locals.alloc(Local { ty: ty.store() });
             self.drop_scopes.last_mut().unwrap().locals.push(local_id);
-            if let Pat::Bind { id, subpat: None } = self.body[it]
+            if let Pat::Bind { id, subpat: None } = self.store[it]
                 && matches!(
-                    self.body[id].mode,
+                    self.store[id].mode,
                     BindingAnnotation::Unannotated | BindingAnnotation::Mutable
                 )
             {
@@ -1924,7 +1924,7 @@ fn lower_params_and_bindings(
             local_id
         }));
         // and then rest of bindings
-        for (id, _) in self.body.bindings() {
+        for (id, _) in self.store.bindings() {
             if !pick_binding(id) {
                 continue;
             }
@@ -1953,7 +1953,7 @@ fn lower_params_and_bindings(
             .into_iter()
             .skip(base_param_count + self_binding.is_some() as usize);
         for ((param, _), local) in params.zip(local_params) {
-            if let Pat::Bind { id, .. } = self.body[param]
+            if let Pat::Bind { id, .. } = self.store[param]
                 && local == self.binding_local(id)?
             {
                 continue;
@@ -2115,7 +2115,7 @@ pub fn mir_body_for_closure_query<'db>(
         implementation_error!("closure expression is not closure");
     };
     let (captures, kind) = infer.closure_info(closure);
-    let mut ctx = MirLowerCtx::new(db, owner, &body, infer);
+    let mut ctx = MirLowerCtx::new(db, owner, &body.store, infer);
     // 0 is return local
     ctx.result.locals.alloc(Local { ty: infer.expr_ty(*root).store() });
     let closure_local = ctx.result.locals.alloc(Local {
@@ -2205,7 +2205,7 @@ pub fn mir_body_for_closure_query<'db>(
         .result
         .binding_locals
         .into_iter()
-        .filter(|it| ctx.body.binding_owner(it.0) == Some(expr))
+        .filter(|it| ctx.store.binding_owner(it.0) == Some(expr))
         .collect();
     if let Some(err) = err {
         return Err(MirLowerError::UnresolvedUpvar(err));
@@ -2245,7 +2245,7 @@ pub fn mir_body_query<'db>(
     let _p = tracing::info_span!("mir_body_query", ?detail).entered();
     let body = db.body(def);
     let infer = InferenceResult::for_body(db, def);
-    let mut result = lower_to_mir(db, def, &body, infer, body.body_expr)?;
+    let mut result = lower_body_to_mir(db, def, &body, infer, body.body_expr)?;
     result.shrink_to_fit();
     Ok(Arc::new(result))
 }
@@ -2258,44 +2258,74 @@ pub(crate) fn mir_body_cycle_result<'db>(
     Err(MirLowerError::Loop)
 }
 
-pub fn lower_to_mir<'db>(
+/// Extracts params from `body.params`/`body.self_param` and the callable signature,
+/// then delegates to [`lower_to_mir_with_store`].
+pub fn lower_body_to_mir<'db>(
     db: &'db dyn HirDatabase,
     owner: DefWithBodyId,
     body: &Body,
     infer: &InferenceResult,
-    // FIXME: root_expr should always be the body.body_expr, but since `X` in `[(); X]` doesn't have its own specific body yet, we
-    // need to take this input explicitly.
+    // FIXME: root_expr should always be the body.body_expr,
+    // but this is currently also used for `X` in `[(); X]` which live in the same expression store
     root_expr: ExprId,
+) -> Result<'db, MirBody> {
+    let is_root = root_expr == body.body_expr;
+    // Extract params and self_param only when lowering the body's root expression for a function.
+    if is_root && let DefWithBodyId::FunctionId(fid) = owner {
+        let callable_sig =
+            db.callable_item_signature(fid.into()).instantiate_identity().skip_binder();
+        let mut param_tys = callable_sig.inputs().iter().copied();
+        let self_param = body.self_param.and_then(|id| Some((id, param_tys.next()?)));
+
+        lower_to_mir_with_store(
+            db,
+            owner,
+            &body.store,
+            infer,
+            root_expr,
+            body.params.iter().copied().zip(param_tys),
+            self_param,
+            is_root,
+        )
+    } else {
+        lower_to_mir_with_store(
+            db,
+            owner,
+            &body.store,
+            infer,
+            root_expr,
+            iter::empty(),
+            None,
+            is_root,
+        )
+    }
+}
+
+/// # Parameters
+/// - `is_root`: `true` when `root_expr` is the body's top-level expression (picks
+///   bindings with no owner); `false` when lowering an inline const or anonymous
+///   const (picks bindings owned by `root_expr`).
+pub fn lower_to_mir_with_store<'db>(
+    db: &'db dyn HirDatabase,
+    owner: DefWithBodyId,
+    store: &ExpressionStore,
+    infer: &InferenceResult,
+    root_expr: ExprId,
+    params: impl Iterator<Item = (PatId, Ty<'db>)> + Clone,
+    self_param: Option<(BindingId, Ty<'db>)>,
+    is_root: bool,
 ) -> Result<'db, MirBody> {
     if infer.type_mismatches().next().is_some() || infer.is_erroneous() {
         return Err(MirLowerError::HasErrors);
     }
-    let mut ctx = MirLowerCtx::new(db, owner, body, infer);
+    let mut ctx = MirLowerCtx::new(db, owner, store, infer);
     // 0 is return local
     ctx.result.locals.alloc(Local { ty: ctx.expr_ty_after_adjustments(root_expr).store() });
     let binding_picker = |b: BindingId| {
-        let owner = ctx.body.binding_owner(b);
-        if root_expr == body.body_expr { owner.is_none() } else { owner == Some(root_expr) }
-    };
-    // 1 to param_len is for params
-    // FIXME: replace with let chain once it becomes stable
-    let current = 'b: {
-        if body.body_expr == root_expr {
-            // otherwise it's an inline const, and has no parameter
-            if let DefWithBodyId::FunctionId(fid) = owner {
-                let callable_sig =
-                    db.callable_item_signature(fid.into()).instantiate_identity().skip_binder();
-                let mut params = callable_sig.inputs().iter().copied();
-                let self_param = body.self_param.and_then(|id| Some((id, params.next()?)));
-                break 'b ctx.lower_params_and_bindings(
-                    body.params.iter().zip(params).map(|(it, y)| (*it, y)),
-                    self_param,
-                    binding_picker,
-                )?;
-            }
-        }
-        ctx.lower_params_and_bindings([].into_iter(), None, binding_picker)?
+        let owner = ctx.store.binding_owner(b);
+        if is_root { owner.is_none() } else { owner == Some(root_expr) }
     };
+    let current = ctx.lower_params_and_bindings(params, self_param, binding_picker)?;
     if let Some(current) = ctx.lower_expr_to_place(root_expr, return_slot().into(), current)? {
         let current = ctx.pop_drop_scope_assert_finished(current, root_expr.into())?;
         ctx.set_terminator(current, TerminatorKind::Return, root_expr.into());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
index cf05ec27ac37..17dc95fb248a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
@@ -137,11 +137,11 @@ pub(super) fn lower_expr_as_place_without_adjust(
             }
             this.lower_expr_to_some_place_without_adjust(expr_id, current)
         };
-        match &self.body[expr_id] {
+        match &self.store[expr_id] {
             Expr::Path(p) => {
                 let resolver_guard =
                     self.resolver.update_to_inner_scope(self.db, self.owner, expr_id);
-                let hygiene = self.body.expr_path_hygiene(expr_id);
+                let hygiene = self.store.expr_path_hygiene(expr_id);
                 let resolved = self.resolver.resolve_path_in_value_ns_fully(self.db, p, hygiene);
                 self.resolver.reset_to_guard(resolver_guard);
                 let Some(pr) = resolved else {
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 83139821e3b8..99c5f0fc653f 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
@@ -131,7 +131,7 @@ fn pattern_match_inner(
                 .collect::<Vec<_>>()
                 .into(),
         );
-        Ok(match &self.body[pattern] {
+        Ok(match &self.store[pattern] {
             Pat::Missing => return Err(MirLowerError::IncompletePattern),
             Pat::Wild => (current, current_else),
             Pat::Tuple { args, ellipsis } => {
@@ -322,7 +322,7 @@ fn pattern_match_inner(
                 }
                 if let &Some(slice) = slice
                     && mode != MatchingMode::Check
-                    && let Pat::Bind { id, subpat: _ } = self.body[slice]
+                    && let Pat::Bind { id, subpat: _ } = self.store[slice]
                 {
                     let next_place = cond_place.project(
                         ProjectionElem::Subslice {
@@ -363,9 +363,14 @@ fn pattern_match_inner(
                 )?,
                 None => {
                     let unresolved_name = || {
-                        MirLowerError::unresolved_path(self.db, p, self.display_target(), self.body)
+                        MirLowerError::unresolved_path(
+                            self.db,
+                            p,
+                            self.display_target(),
+                            self.store,
+                        )
                     };
-                    let hygiene = self.body.pat_path_hygiene(pattern);
+                    let hygiene = self.store.pat_path_hygiene(pattern);
                     let pr = self
                         .resolver
                         .resolve_path_in_value_ns(self.db, p, hygiene)
@@ -432,7 +437,7 @@ fn pattern_match_inner(
                     (next, Some(else_target))
                 }
             },
-            Pat::Lit(l) => match &self.body[*l] {
+            Pat::Lit(l) => match &self.store[*l] {
                 Expr::Literal(l) => {
                     if mode == MatchingMode::Check {
                         let c = self.lower_literal_to_operand(self.infer.pat_ty(pattern), l)?;

From a27fdfbf0189c78574293e03dd0c0d82c96b81eb Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 14 Mar 2026 16:31:19 +0100
Subject: [PATCH 0473/1059] tests/debuginfo/basic-stepping.rs: Remove
 ignore-aarch64

It works now.
---
 tests/debuginfo/basic-stepping.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/debuginfo/basic-stepping.rs b/tests/debuginfo/basic-stepping.rs
index c82120e8a426..238ab12c186e 100644
--- a/tests/debuginfo/basic-stepping.rs
+++ b/tests/debuginfo/basic-stepping.rs
@@ -2,7 +2,6 @@
 //! time works intuitively, e.g. that `next` takes you to the next source line.
 //! Regression test for <https://github.com/rust-lang/rust/issues/33013>.
 
-//@ ignore-aarch64: Doesn't work yet.
 //@ ignore-loongarch64: Doesn't work yet.
 //@ ignore-riscv64: Doesn't work yet.
 //@ ignore-backends: gcc

From 800d9ea8e85087f1d2bbe9eddad94614367904b4 Mon Sep 17 00:00:00 2001
From: Mahdi Ali-Raihan <asder8215@gmail.com>
Date: Sat, 14 Mar 2026 13:00:55 -0400
Subject: [PATCH 0474/1059] Lifted intersperse and intersperse_with Fused
 restrictions and updated documentation + tests

---
 library/core/src/iter/adapters/intersperse.rs |  25 +---
 library/core/src/iter/traits/iterator.rs      |  44 ++++--
 .../tests/iter/adapters/intersperse.rs        | 126 ++++++++----------
 3 files changed, 95 insertions(+), 100 deletions(-)

diff --git a/library/core/src/iter/adapters/intersperse.rs b/library/core/src/iter/adapters/intersperse.rs
index f33a67a98310..f64dea2df862 100644
--- a/library/core/src/iter/adapters/intersperse.rs
+++ b/library/core/src/iter/adapters/intersperse.rs
@@ -1,5 +1,4 @@
 use crate::fmt;
-use crate::iter::{Fuse, FusedIterator};
 
 /// An iterator adapter that places a separator between all elements.
 ///
@@ -14,15 +13,7 @@ pub struct Intersperse<I: Iterator>
     started: bool,
     separator: I::Item,
     next_item: Option<I::Item>,
-    iter: Fuse<I>,
-}
-
-#[unstable(feature = "iter_intersperse", issue = "79524")]
-impl<I> FusedIterator for Intersperse<I>
-where
-    I: FusedIterator,
-    I::Item: Clone,
-{
+    iter: I,
 }
 
 impl<I: Iterator> Intersperse<I>
@@ -30,7 +21,7 @@ impl<I: Iterator> Intersperse<I>
     I::Item: Clone,
 {
     pub(in crate::iter) fn new(iter: I, separator: I::Item) -> Self {
-        Self { started: false, separator, next_item: None, iter: iter.fuse() }
+        Self { started: false, separator, next_item: None, iter }
     }
 }
 
@@ -96,15 +87,7 @@ pub struct IntersperseWith<I, G>
     started: bool,
     separator: G,
     next_item: Option<I::Item>,
-    iter: Fuse<I>,
-}
-
-#[unstable(feature = "iter_intersperse", issue = "79524")]
-impl<I, G> FusedIterator for IntersperseWith<I, G>
-where
-    I: FusedIterator,
-    G: FnMut() -> I::Item,
-{
+    iter: I,
 }
 
 #[unstable(feature = "iter_intersperse", issue = "79524")]
@@ -147,7 +130,7 @@ impl<I, G> IntersperseWith<I, G>
     G: FnMut() -> I::Item,
 {
     pub(in crate::iter) fn new(iter: I, separator: G) -> Self {
-        Self { started: false, separator, next_item: None, iter: iter.fuse() }
+        Self { started: false, separator, next_item: None, iter }
     }
 }
 
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index 2e82f4577182..11b1c04ce0e2 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -635,11 +635,24 @@ fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>
     /// of the original iterator.
     ///
     /// Specifically on fused iterators, it is guaranteed that the new iterator
-    /// places a copy of `separator` between adjacent `Some(_)` items. However,
-    /// for non-fused iterators, [`intersperse`] will create a new iterator that
-    /// is a fused version of the original iterator and place a copy of `separator`
-    /// between adjacent `Some(_)` items. This behavior for non-fused iterators
-    /// is subject to change.
+    /// places a copy of `separator` between *adjacent* `Some(_)` items. For non-fused iterators,
+    /// it is guaranteed that [`intersperse`] will create a new iterator that places a copy
+    /// of `separator` between `Some(_)` items, particularly just right before the subsequent
+    /// `Some(_)` item.
+    ///
+    /// For example, consider the following non-fused iterator:
+    ///
+    /// ```text
+    /// Some(1) -> Some(2) -> None -> Some(3) -> Some(4) -> ...
+    /// ```
+    ///
+    /// If this non-fused iterator were to be interspersed with `0`,
+    /// then the interspersed iterator will produce:
+    ///
+    /// ```text
+    /// Some(1) -> Some(0) -> Some(2) -> None -> Some(0) -> Some(3) -> Some(0) ->
+    /// Some(4) -> ...
+    /// ```
     ///
     /// In case `separator` does not implement [`Clone`] or needs to be
     /// computed every time, use [`intersperse_with`].
@@ -688,10 +701,23 @@ fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
     ///
     /// Specifically on fused iterators, it is guaranteed that the new iterator
     /// places an item generated by `separator` between adjacent `Some(_)` items.
-    /// However, for non-fused iterators, [`intersperse_with`] will create a new
-    /// iterator that is a fused version of the original iterator and place an item
-    /// generated by `separator` between adjacent `Some(_)` items. This
-    /// behavior for non-fused iterators is subject to change.
+    /// For non-fused iterators, it is guaranteed that [`intersperse_with`] will
+    /// create a new iterator that places an item generated by `separator` between `Some(_)`
+    /// items, particularly just right before the subsequent `Some(_)` item.
+    ///
+    /// For example, consider the following non-fused iterator:
+    ///
+    /// ```text
+    /// Some(1) -> Some(2) -> None -> Some(3) -> Some(4) -> ...
+    /// ```
+    ///
+    /// If this non-fused iterator were to be interspersed with a `separator` closure
+    /// that returns `0` repeatedly, the interspersed iterator will produce:
+    ///
+    /// ```text
+    /// Some(1) -> Some(0) -> Some(2) -> None -> Some(0) -> Some(3) -> Some(0) ->
+    /// Some(4) -> ...
+    /// ```
     ///
     /// The `separator` closure will be called exactly once each time an item
     /// is placed between two adjacent items from the underlying iterator;
diff --git a/library/coretests/tests/iter/adapters/intersperse.rs b/library/coretests/tests/iter/adapters/intersperse.rs
index df6be79308be..bcb7709077cd 100644
--- a/library/coretests/tests/iter/adapters/intersperse.rs
+++ b/library/coretests/tests/iter/adapters/intersperse.rs
@@ -153,10 +153,6 @@ fn test_try_fold_specialization_intersperse_err() {
     assert_eq!(iter.next(), None);
 }
 
-// FIXME(iter_intersperse): `intersperse` current behavior may change for
-// non-fused iterators, so this test will likely have to
-// be adjusted; see PR #152855 and issue #79524
-// if `intersperse` doesn't change, remove this FIXME.
 #[test]
 fn test_non_fused_iterator_intersperse() {
     #[derive(Debug)]
@@ -183,24 +179,26 @@ fn next(&mut self) -> Option<Self::Item> {
     }
 
     let counter = 0;
-    // places a 2 between `Some(_)` items
+    // places a 1 between `Some(_)` items
     let non_fused_iter = TestCounter { counter };
-    let mut intersperse_iter = non_fused_iter.intersperse(2);
-    // Since `intersperse` currently transforms the original
-    // iterator into a fused iterator, this intersperse_iter
-    // should always have `None`
-    for _ in 0..counter + 6 {
-        assert_eq!(intersperse_iter.next(), None);
-    }
+    let mut intersperse_iter = non_fused_iter.intersperse(1);
+    // Interspersed iter produces:
+    // `None` -> `Some(2)` -> `None` -> `Some(1)` -> Some(4)` -> `None` ->  `Some(1)` ->
+    // `Some(6)` -> and then `None` endlessly
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(2));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(4));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(6));
+    assert_eq!(intersperse_iter.next(), None);
 
-    // Extra check to make sure it is `None` after processing 6 items
+    // Extra check to make sure it is `None` after processing all items
     assert_eq!(intersperse_iter.next(), None);
 }
 
-// FIXME(iter_intersperse): `intersperse` current behavior may change for
-// non-fused iterators, so this test will likely have to
-// be adjusted; see PR #152855 and issue #79524
-// if `intersperse` doesn't change, remove this FIXME.
 #[test]
 fn test_non_fused_iterator_intersperse_2() {
     #[derive(Debug)]
@@ -228,35 +226,26 @@ fn next(&mut self) -> Option<Self::Item> {
     }
 
     let counter = 0;
-    // places a 2 between `Some(_)` items
+    // places a 100 between `Some(_)` items
     let non_fused_iter = TestCounter { counter };
-    let mut intersperse_iter = non_fused_iter.intersperse(2);
-    // Since `intersperse` currently transforms the original
-    // iterator into a fused iterator, this interspersed iter
-    // will be `Some(1)` -> `Some(2)` -> `Some(2)` -> and then
-    // `None` endlessly
-    let mut items_processed = 0;
-    for num in 0..counter + 6 {
-        if num < 3 {
-            if num % 2 != 0 {
-                assert_eq!(intersperse_iter.next(), Some(2));
-            } else {
-                items_processed += 1;
-                assert_eq!(intersperse_iter.next(), Some(items_processed));
-            }
-        } else {
-            assert_eq!(intersperse_iter.next(), None);
-        }
-    }
+    let mut intersperse_iter = non_fused_iter.intersperse(100);
+    // Interspersed iter produces:
+    // `Some(1)` -> `Some(100)` -> `Some(2)` -> `None` -> `Some(100)`
+    //  -> `Some(4)` -> `Some(100)` -> `Some(5)` -> `None` endlessly
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(2));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(4));
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(5));
+    assert_eq!(intersperse_iter.next(), None);
 
     // Extra check to make sure it is `None` after processing 6 items
     assert_eq!(intersperse_iter.next(), None);
 }
 
-// FIXME(iter_intersperse): `intersperse_with` current behavior may change for
-// non-fused iterators, so this test will likely have to
-// be adjusted; see PR #152855 and issue #79524
-// if `intersperse_with` doesn't change, remove this FIXME.
 #[test]
 fn test_non_fused_iterator_intersperse_with() {
     #[derive(Debug)]
@@ -285,22 +274,24 @@ fn next(&mut self) -> Option<Self::Item> {
     let counter = 0;
     let non_fused_iter = TestCounter { counter };
     // places a 2 between `Some(_)` items
-    let mut intersperse_iter = non_fused_iter.intersperse_with(|| 2);
-    // Since `intersperse` currently transforms the original
-    // iterator into a fused iterator, this intersperse_iter
-    // should always have `None`
-    for _ in 0..counter + 6 {
-        assert_eq!(intersperse_iter.next(), None);
-    }
+    let mut intersperse_iter = non_fused_iter.intersperse_with(|| 1);
+    // Interspersed iter produces:
+    // `None` -> `Some(2)` -> `None` -> `Some(1)` -> Some(4)` -> `None` ->  `Some(1)` ->
+    // `Some(6)` -> and then `None` endlessly
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(2));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(4));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(6));
+    assert_eq!(intersperse_iter.next(), None);
 
     // Extra check to make sure it is `None` after processing 6 items
     assert_eq!(intersperse_iter.next(), None);
 }
 
-// FIXME(iter_intersperse): `intersperse_with` current behavior may change for
-// non-fused iterators, so this test will likely have to
-// be adjusted; see PR #152855 and issue #79524
-// if `intersperse_with` doesn't change, remove this FIXME.
 #[test]
 fn test_non_fused_iterator_intersperse_with_2() {
     #[derive(Debug)]
@@ -328,26 +319,21 @@ fn next(&mut self) -> Option<Self::Item> {
     }
 
     let counter = 0;
-    // places a 2 between `Some(_)` items
+    // places a 100 between `Some(_)` items
     let non_fused_iter = TestCounter { counter };
-    let mut intersperse_iter = non_fused_iter.intersperse(2);
-    // Since `intersperse` currently transforms the original
-    // iterator into a fused iterator, this interspersed iter
-    // will be `Some(1)` -> `Some(2)` -> `Some(2)` -> and then
-    // `None` endlessly
-    let mut items_processed = 0;
-    for num in 0..counter + 6 {
-        if num < 3 {
-            if num % 2 != 0 {
-                assert_eq!(intersperse_iter.next(), Some(2));
-            } else {
-                items_processed += 1;
-                assert_eq!(intersperse_iter.next(), Some(items_processed));
-            }
-        } else {
-            assert_eq!(intersperse_iter.next(), None);
-        }
-    }
+    let mut intersperse_iter = non_fused_iter.intersperse_with(|| 100);
+    // Interspersed iter produces:
+    // `Some(1)` -> `Some(100)` -> `Some(2)` -> `None` -> `Some(100)`
+    //  -> `Some(4)` -> `Some(100)` -> `Some(5)` -> `None` endlessly
+    assert_eq!(intersperse_iter.next(), Some(1));
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(2));
+    assert_eq!(intersperse_iter.next(), None);
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(4));
+    assert_eq!(intersperse_iter.next(), Some(100));
+    assert_eq!(intersperse_iter.next(), Some(5));
+    assert_eq!(intersperse_iter.next(), None);
 
     // Extra check to make sure it is `None` after processing 6 items
     assert_eq!(intersperse_iter.next(), None);

From 491852c7700c53e6a3779b3ea0e1d4d3197445a7 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sat, 14 Mar 2026 20:22:14 +0200
Subject: [PATCH 0475/1059] Infer generic args for trait ref and its assoc type

This was already there before the switch to the new solver, but it was reverted during the switch for some reason.
---
 .../crates/hir-ty/src/lower/path.rs             |  4 ++--
 .../src/handlers/incorrect_generics_len.rs      | 17 +++++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index 79f29d370f5c..81a944128d23 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -183,7 +183,7 @@ pub(crate) fn lower_partly_resolved_path(
                         let trait_ref = self.lower_trait_ref_from_resolved_path(
                             trait_,
                             Ty::new_error(self.ctx.interner, ErrorGuaranteed),
-                            false,
+                            infer_args,
                         );
                         tracing::debug!(?trait_ref);
                         self.skip_resolved_segment();
@@ -201,7 +201,7 @@ pub(crate) fn lower_partly_resolved_path(
                                 // this point (`trait_ref.substitution`).
                                 let substitution = self.substs_from_path_segment(
                                     associated_ty.into(),
-                                    false,
+                                    infer_args,
                                     None,
                                     true,
                                 );
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_generics_len.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_generics_len.rs
index 894e044642cc..25220704e04d 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_generics_len.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_generics_len.rs
@@ -220,6 +220,23 @@ fn enum_type_alias_default_param() {
 
 fn main() {
     let _ = Result::<()>::Ok(());
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn type_as_trait_does_not_count() {
+        check_diagnostics(
+            r#"
+pub trait Lock<T> {
+    fn new(b: T) -> Self;
+}
+pub trait LockChoice {
+    type Lock<T>: Lock<T>;
+}
+fn f<L: LockChoice>() {
+    <L as LockChoice>::Lock::new(());
 }
         "#,
         );

From 681750bd4606b0142fdf7e4b6013c508506bfb24 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 14 Mar 2026 16:35:00 +0100
Subject: [PATCH 0476/1059] add fixmes for f128

also implement sqrt for f128 (using softfloat) and test sqrt for f16 and f128
---
 src/tools/miri/src/intrinsics/math.rs                |  2 ++
 src/tools/miri/src/intrinsics/simd.rs                |  6 +++---
 .../miri/tests/pass/intrinsics/portable-simd.rs      | 12 ++++++++++++
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index fbd2aff4b50a..fc7101df9ed0 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -192,10 +192,12 @@ fn emulate_math_intrinsic(
             "powf16" => pow_intrinsic::<HalfS>(this, args, dest)?,
             "powf32" => pow_intrinsic::<SingleS>(this, args, dest)?,
             "powf64" => pow_intrinsic::<DoubleS>(this, args, dest)?,
+            "powf128" => todo!("f128"), // FIXME(f128)
 
             "powif16" => powi_intrinsic::<HalfS>(this, args, dest)?,
             "powif32" => powi_intrinsic::<SingleS>(this, args, dest)?,
             "powif64" => powi_intrinsic::<DoubleS>(this, args, dest)?,
+            "powif128" => todo!("f128"), // FIXME(f128)
 
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 235f815ba2f2..74582bc58900 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -1,4 +1,4 @@
-use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, SingleS};
+use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, QuadS, SingleS};
 use rustc_middle::ty;
 use rustc_middle::ty::FloatTy;
 
@@ -36,7 +36,7 @@ fn emulate_simd_intrinsic(
                         FloatTy::F16 => math::sqrt_op::<IeeeFloat<HalfS>>(this, &op, &dest)?,
                         FloatTy::F32 => math::sqrt_op::<IeeeFloat<SingleS>>(this, &op, &dest)?,
                         FloatTy::F64 => math::sqrt_op::<IeeeFloat<DoubleS>>(this, &op, &dest)?,
-                        FloatTy::F128 => unimplemented!("f128"),
+                        FloatTy::F128 => math::sqrt_op::<IeeeFloat<QuadS>>(this, &op, &dest)?,
                     };
                 }
             }
@@ -72,7 +72,7 @@ fn emulate_simd_intrinsic(
                         FloatTy::F16 => host_unary_float_op::<HalfS>(this, &op, host_op, &dest)?,
                         FloatTy::F32 => host_unary_float_op::<SingleS>(this, &op, host_op, &dest)?,
                         FloatTy::F64 => host_unary_float_op::<DoubleS>(this, &op, host_op, &dest)?,
-                        FloatTy::F128 => unimplemented!("f128"),
+                        FloatTy::F128 => unimplemented!("f128"), // FIXME(f128)
                     }
                 }
             }
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index 554011dd02e8..b4fd8e216533 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -17,6 +17,7 @@
 use std::simd::StdFloat;
 use std::simd::prelude::*;
 
+// The `portable_simd` crate currently does not support f16 or f128 vectors, so we define our own.
 #[repr(simd, packed)]
 #[derive(Copy)]
 struct PackedSimd<T, const N: usize>([T; N]);
@@ -113,6 +114,9 @@ macro_rules! assert_eq {
             f16x4::splat(f16::NEG_INFINITY)
         );
 
+        assert_eq!(simd_fsqrt(simd_mul(a, a)), a);
+        assert_eq!(simd_fsqrt(simd_mul(b, b)), simd_fabs(b));
+
         assert_eq!(simd_eq(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([0, !0, 0, 0]));
         assert_eq!(simd_ne(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([!0, 0, !0, !0]));
         assert_eq!(simd_le(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([0, !0, !0, 0]));
@@ -324,6 +328,9 @@ macro_rules! assert_eq {
             f128x4::splat(f128::NEG_INFINITY)
         );
 
+        assert_eq!(simd_fsqrt(simd_mul(a, a)), a);
+        assert_eq!(simd_fsqrt(simd_mul(b, b)), simd_fabs(b));
+
         assert_eq!(simd_eq(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([0, !0, 0, 0]));
         assert_eq!(simd_ne(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([!0, 0, !0, !0]));
         assert_eq!(simd_le(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([0, !0, !0, 0]));
@@ -970,6 +977,11 @@ fn simd_float_intrinsics() {
         simd_flog2(a);
         simd_flog10(a);
     }
+
+    unsafe {
+        let a = f128x2::splat(10.0);
+        simd_fsqrt(a);
+    }
 }
 
 fn simd_masked_loadstore() {

From 87d8f5885b4f289477e48090a86356302437cec9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 17:23:34 +0000
Subject: [PATCH 0477/1059] Provide more context on type errors in const
 context

- On `const` and `static` point at the type (like we do for let bindings)
- On fn calls, point at const parameter in fn definition
- On type, point at const parameter in type definition
- On array type lengths, explain that array length is always `usize`
- On enum variant discriminant, mention `repr`
---
 compiler/rustc_hir_typeck/src/lib.rs          | 112 +++++++++++++++++-
 .../closure-in-array-len.stderr               |   1 +
 ...lice-only-once-semantic-restriction.stderr |   4 +-
 ...g-assoc-type-because-of-assoc-const.stderr |   4 +-
 .../defaults-in-other-trait-items.rs          |   1 +
 .../defaults-in-other-trait-items.stderr      |   6 +-
 tests/ui/associated-types/issue-26681.stderr  |   4 +-
 tests/ui/closures/issue-90871.stderr          |   1 +
 .../byte-string-u8-validation.rs              |   1 +
 .../byte-string-u8-validation.stderr          |   7 +-
 .../mismatch-raw-ptr-in-adt.stderr            |  10 ++
 .../transmutable-ice-110969.stderr            |   4 +-
 .../unsized-anon-const-err-1.stderr           |   4 +-
 .../unsized-anon-const-func-err.stderr        |   4 +-
 .../unsized-anon-const-struct-err.stderr      |   4 +-
 .../bad-generic-in-copy-impl.stderr           |   3 +
 .../generic_const_exprs/error_in_ty.stderr    |  12 ++
 .../generic_const_exprs/issue-105257.stderr   |   4 +-
 .../generic_const_exprs/opaque_type.stderr    |   1 +
 .../invalid-patterns.64bit.stderr             |  24 ++++
 .../ui/const-generics/ogca/basic-fail.stderr  |   4 +-
 tests/ui/const-generics/opaque_types.stderr   |   5 +
 .../vec-macro-in-static-array.stderr          |   4 +-
 .../consts/array-literal-len-mismatch.stderr  |   7 +-
 tests/ui/consts/const-array-oob-arith.rs      |   6 +-
 tests/ui/consts/const-array-oob-arith.stderr  |  16 +--
 .../const-eval/array-len-mismatch-type.stderr |   1 +
 tests/ui/consts/const-eval/const-eval-span.rs |   5 +-
 .../consts/const-eval/const-eval-span.stderr  |   2 +
 tests/ui/consts/const-integer-bool-ops.rs     |  10 ++
 tests/ui/consts/const-integer-bool-ops.stderr |  78 +++++++-----
 .../const-result-no-expect-suggestion.stderr  |   4 +-
 .../ui/consts/const-slice-array-deref.stderr  |   4 +-
 tests/ui/consts/const-tup-index-span.rs       |   7 +-
 tests/ui/consts/const-tup-index-span.stderr   |   4 +-
 tests/ui/consts/const-type-mismatch.stderr    |   8 +-
 tests/ui/consts/enum-discr-type-err.stderr    |   2 +
 tests/ui/consts/issue-104768.stderr           |   4 +-
 tests/ui/consts/issue-39974.rs                |  10 +-
 tests/ui/consts/issue-39974.stderr            |   8 +-
 ...issue-69310-array-size-lit-wrong-ty.stderr |   4 +
 tests/ui/consts/nested_erroneous_ctfe.stderr  |   1 +
 .../promoted-type-error-issue-133968.stderr   |   4 +-
 .../ui/diagnostic-width/long-span.long.stderr |   6 +-
 .../diagnostic-width/long-span.longest.stderr |   6 +-
 .../diagnostic-width/long-span.short.stderr   |   6 +-
 .../long-span.shortest.stderr                 |   6 +-
 .../brackets-to-braces-single-element.stderr  |   4 +-
 .../discriminant-ill-typed.rs                 |  40 ++++---
 .../discriminant-ill-typed.stderr             |  22 ++--
 .../enum/closure-in-enum-issue-48838.stderr   |   1 +
 .../enum-discriminant-type-mismatch-8761.rs   |  10 +-
 ...num-discriminant-type-mismatch-8761.stderr |   4 +-
 .../assoc-const-missing-type.stderr           |   5 +-
 ...-unconstrained-inference-vars-69306.stderr |   8 +-
 tests/ui/issues/issue-31910.rs                |   9 +-
 tests/ui/issues/issue-31910.stderr            |   2 +
 .../lifetimes/unusual-rib-combinations.stderr |   2 +
 .../array-len-is-closure.stderr               |   1 +
 .../array-repeat-unit-struct.rs               |   5 +-
 .../array-repeat-unit-struct.stderr           |   2 +
 .../regress/loop-in-array-length.stderr       |   1 +
 tests/ui/numeric/const-scope.stderr           |   8 +-
 tests/ui/parser/pat-lt-bracket-6.stderr       |   4 +-
 tests/ui/parser/pat-lt-bracket-7.stderr       |   4 +-
 ...recover-for-loop-parens-around-head.stderr |   4 +-
 tests/ui/proc-macro/macro-brackets.stderr     |   4 +-
 tests/ui/repeat-expr/repeat_count.stderr      |  13 ++
 tests/ui/self/issue-61882.stderr              |   4 +-
 tests/ui/static/bad-const-type.rs             |   5 +-
 tests/ui/static/bad-const-type.stderr         |   4 +-
 tests/ui/static/issue-5216.stderr             |   4 +-
 .../arrays/issue-103783-array-length.stderr   |   2 +
 tests/ui/type/pattern_types/nested.stderr     |   4 +-
 .../pattern_type_mismatch.stderr              |  16 ++-
 ...range-expr-root-of-constant-issue-40749.rs |  14 ++-
 ...e-expr-root-of-constant-issue-40749.stderr |   1 +
 77 files changed, 497 insertions(+), 143 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 77c95fd55be3..200cef49f35d 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -41,7 +41,7 @@
 use fn_ctxt::FnCtxt;
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_err};
+use rustc_errors::{Applicability, Diag, ErrorGuaranteed, pluralize, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{HirId, HirIdMap, Node};
@@ -204,7 +204,9 @@ fn typeck_with_inspect<'tcx>(
             );
         }
 
-        fcx.check_expr_coercible_to_type(body.value, expected_type, None);
+        fcx.check_expr_coercible_to_type_or_error(body.value, expected_type, None, |err, _| {
+            extend_err_with_const_context(err, tcx, node);
+        });
 
         fcx.write_ty(id, expected_type);
     };
@@ -274,6 +276,112 @@ fn typeck_with_inspect<'tcx>(
     typeck_results
 }
 
+fn extend_err_with_const_context(err: &mut Diag<'_>, tcx: TyCtxt<'_>, node: hir::Node<'_>) {
+    match node {
+        hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(ty, _), .. })
+        | hir::Node::TraitItem(hir::TraitItem {
+            kind: hir::TraitItemKind::Const(ty, _, _), ..
+        }) => {
+            // Point at the `Type` in `const NAME: Type = value;`.
+            err.span_label(ty.span, "expected because of the type of the associated constant");
+        }
+        hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(_, _, ty, _), .. }) => {
+            // Point at the `Type` in `const NAME: Type = value;`.
+            err.span_label(ty.span, "expected because of the type of the constant");
+        }
+        hir::Node::Item(hir::Item { kind: hir::ItemKind::Static(_, _, ty, _), .. }) => {
+            // Point at the `Type` in `static NAME: Type = value;`.
+            err.span_label(ty.span, "expected because of the type of the static");
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::Ty(parent) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::TyKind::Array(_ty, _len) = parent.kind =>
+        {
+            // `[type; len]` in type context.
+            err.note("array length can only be `usize`");
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::Expr(parent) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::ExprKind::Repeat(_ty, _len) = parent.kind =>
+        {
+            // `[type; len]` in expr context.
+            err.note("array length can only be `usize`");
+        }
+        // FIXME: support method calls too.
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::Expr(expr) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::ExprKind::Path(path) = expr.kind
+                && let hir::QPath::Resolved(_, path) = path
+                && let Res::Def(_, def_id) = path.res =>
+        {
+            // `foo<N>()` in expression context, point at `foo`'s const parameter.
+            if let Some(i) =
+                path.segments.iter().last().and_then(|segment| segment.args).and_then(|args| {
+                    args.args.iter().position(|arg| {
+                        matches!(arg, hir::GenericArg::Const(arg) if arg.hir_id == parent.hir_id)
+                    })
+                })
+            {
+                let generics = tcx.generics_of(def_id);
+                let param = &generics.param_at(i, tcx);
+                let sp = tcx.def_span(param.def_id);
+                err.span_note(sp, "expected because of the type of the const parameter");
+            }
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::Ty(ty) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::TyKind::Path(path) = ty.kind
+                && let hir::QPath::Resolved(_, path) = path
+                && let Res::Def(_, def_id) = path.res =>
+        {
+            // `Foo<N>` in type context, point at `Foo`'s const parameter.
+            if let Some(i) =
+                path.segments.iter().last().and_then(|segment| segment.args).and_then(|args| {
+                    args.args.iter().position(|arg| {
+                        matches!(arg, hir::GenericArg::Const(arg) if arg.hir_id == parent.hir_id)
+                    })
+                })
+            {
+                let generics = tcx.generics_of(def_id);
+                let param = &generics.param_at(i, tcx);
+                let sp = tcx.def_span(param.def_id);
+                err.span_note(sp, "expected because of the type of the const parameter");
+            }
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::Variant(_variant) = tcx.parent_hir_node(anon.hir_id) =>
+        {
+            // FIXME: point at `repr` when present in the type.
+            err.note(
+                "enum variant discriminant can only be of a primitive type compatible with the \
+                 enum's `repr`",
+            );
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::GenericParam(param) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::GenericParamKind::Const { ty, .. } = param.kind =>
+        {
+            // `fn foo<const N: usize = ()>` point at the `usize`.
+            err.span_label(ty.span, "expected because of the type of the const parameter");
+        }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::ConstArg(parent) = tcx.parent_hir_node(anon.hir_id)
+                && let hir::Node::TyPat(ty_pat) = tcx.parent_hir_node(parent.hir_id)
+                && let hir::Node::Ty(ty) = tcx.parent_hir_node(ty_pat.hir_id)
+                && let hir::TyKind::Pat(ty, _) = ty.kind =>
+        {
+            // Point at `char` in `pattern_type!(char is 1..=1)`.
+            err.span_label(ty.span, "the pattern must match the type");
+        }
+        _ => {}
+    }
+}
+
 fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Option<Ty<'tcx>> {
     let tcx = fcx.tcx;
     let def_id = fcx.body_id;
diff --git a/tests/ui/array-slice-vec/closure-in-array-len.stderr b/tests/ui/array-slice-vec/closure-in-array-len.stderr
index decdde042c6f..04841f1d1f66 100644
--- a/tests/ui/array-slice-vec/closure-in-array-len.stderr
+++ b/tests/ui/array-slice-vec/closure-in-array-len.stderr
@@ -6,6 +6,7 @@ LL |     fn([u8; |x: u8| {}]),
    |
    = note: expected type `usize`
            found closure `{closure@$DIR/closure-in-array-len.rs:3:13: 3:20}`
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/array-slice-vec/subslice-only-once-semantic-restriction.stderr b/tests/ui/array-slice-vec/subslice-only-once-semantic-restriction.stderr
index 4d6078788b22..d665125608af 100644
--- a/tests/ui/array-slice-vec/subslice-only-once-semantic-restriction.stderr
+++ b/tests/ui/array-slice-vec/subslice-only-once-semantic-restriction.stderr
@@ -16,7 +16,9 @@ error[E0308]: mismatched types
   --> $DIR/subslice-only-once-semantic-restriction.rs:11:30
    |
 LL | const RECOVERY_WITNESS: () = 0;
-   |                              ^ expected `()`, found integer
+   |                         --   ^ expected `()`, found integer
+   |                         |
+   |                         expected because of the type of the constant
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr b/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
index 3b89ed66b355..50bafc96acaa 100644
--- a/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
+++ b/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/suggest-contraining-assoc-type-because-of-assoc-const.rs:13:21
    |
 LL |     const N: C::M = 4u8;
-   |                     ^^^ expected associated type, found `u8`
+   |              ----   ^^^ expected associated type, found `u8`
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected associated type `<C as O>::M`
                          found type `u8`
diff --git a/tests/ui/associated-types/defaults-in-other-trait-items.rs b/tests/ui/associated-types/defaults-in-other-trait-items.rs
index 3de64e0d0db6..7b3e7f96acb5 100644
--- a/tests/ui/associated-types/defaults-in-other-trait-items.rs
+++ b/tests/ui/associated-types/defaults-in-other-trait-items.rs
@@ -37,6 +37,7 @@ trait AssocConst {
     //~^ ERROR mismatched types
     //~| NOTE expected associated type, found `u8`
     //~| NOTE expected associated type `<Self as AssocConst>::Ty`
+    //~| NOTE expected because
 }
 
 // An impl can, however
diff --git a/tests/ui/associated-types/defaults-in-other-trait-items.stderr b/tests/ui/associated-types/defaults-in-other-trait-items.stderr
index 56abd6ebf73b..fe9023e52324 100644
--- a/tests/ui/associated-types/defaults-in-other-trait-items.stderr
+++ b/tests/ui/associated-types/defaults-in-other-trait-items.stderr
@@ -19,13 +19,15 @@ LL |     type Ty = u8;
    |     ------- associated type defaults can't be assumed inside the trait defining them
 ...
 LL |     const C: Self::Ty = 0u8;
-   |                         ^^^ expected associated type, found `u8`
+   |              --------   ^^^ expected associated type, found `u8`
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected associated type `<Self as AssocConst>::Ty`
                          found type `u8`
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-in-other-trait-items.rs:54:9
+  --> $DIR/defaults-in-other-trait-items.rs:55:9
    |
 LL |     type Res = isize;
    |     -------- associated type defaults can't be assumed inside the trait defining them
diff --git a/tests/ui/associated-types/issue-26681.stderr b/tests/ui/associated-types/issue-26681.stderr
index 5fb1a4ef3f5f..798f0eb392c4 100644
--- a/tests/ui/associated-types/issue-26681.stderr
+++ b/tests/ui/associated-types/issue-26681.stderr
@@ -4,7 +4,9 @@ error[E0308]: mismatched types
 LL |     type Fv: Foo = u8;
    |     ------------ associated type defaults can't be assumed inside the trait defining them
 LL |     const C: <Self::Fv as Foo>::Bar = 6665;
-   |                                       ^^^^ expected associated type, found integer
+   |              ----------------------   ^^^^ expected associated type, found integer
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected associated type `<<Self as Baz>::Fv as Foo>::Bar`
                          found type `{integer}`
diff --git a/tests/ui/closures/issue-90871.stderr b/tests/ui/closures/issue-90871.stderr
index 140f24982140..a70c761201b6 100644
--- a/tests/ui/closures/issue-90871.stderr
+++ b/tests/ui/closures/issue-90871.stderr
@@ -20,6 +20,7 @@ LL |     type_ascribe!(2, n([u8; || 1]))
    |
    = note: expected type `usize`
            found closure `{closure@$DIR/issue-90871.rs:4:29: 4:31}`
+   = note: array length can only be `usize`
 help: use parentheses to call this closure
    |
 LL |     type_ascribe!(2, n([u8; (|| 1)()]))
diff --git a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs
index d49fb49d253c..5d6e34804c5c 100644
--- a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs
+++ b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs
@@ -9,6 +9,7 @@
 //~^ ERROR rustc_dump_predicates
 //~| NOTE Binder { value: ConstArgHasType(T/#0, &'static [*mut u8; 3_usize]), bound_vars: [] }
 //~| NOTE Binder { value: TraitPredicate(<ConstBytes<b"AAA"> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+//~| NOTE expected because of the type of the const parameter
 
 where
     ConstBytes<b"AAA">: Sized;
diff --git a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr
index 1273a74102a2..34c65af7cd97 100644
--- a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr
+++ b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr
@@ -1,11 +1,16 @@
 error[E0308]: mismatched types
-  --> $DIR/byte-string-u8-validation.rs:14:16
+  --> $DIR/byte-string-u8-validation.rs:15:16
    |
 LL |     ConstBytes<b"AAA">: Sized;
    |                ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
    |
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
+note: expected because of the type of the const parameter
+  --> $DIR/byte-string-u8-validation.rs:8:19
+   |
+LL | struct ConstBytes<const T: &'static [*mut u8; 3]>
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: rustc_dump_predicates
   --> $DIR/byte-string-u8-validation.rs:8:1
diff --git a/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr b/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr
index d7eec45bae0f..14afd18f82a7 100644
--- a/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr
+++ b/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr
@@ -15,6 +15,11 @@ LL |     let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;
    |
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
+note: expected because of the type of the const parameter
+  --> $DIR/mismatch-raw-ptr-in-adt.rs:5:19
+   |
+LL | struct ConstBytes<const T: &'static [*mut u8; 3]>;
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/mismatch-raw-ptr-in-adt.rs:9:46
@@ -24,6 +29,11 @@ LL |     let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;
    |
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
+note: expected because of the type of the const parameter
+  --> $DIR/mismatch-raw-ptr-in-adt.rs:5:19
+   |
+LL | struct ConstBytes<const T: &'static [*mut u8; 3]>;
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
index 967166856147..bc8feaf5214a 100644
--- a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
+++ b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
@@ -16,7 +16,9 @@ error[E0308]: mismatched types
   --> $DIR/transmutable-ice-110969.rs:25:29
    |
 LL |         const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
+   |                      ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
+   |                      |
+   |                      expected because of the type of the associated constant
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-1.stderr b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-1.stderr
index daea55efbbc7..4125461f92b2 100644
--- a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-1.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-1.stderr
@@ -36,7 +36,9 @@ error[E0308]: mismatched types
   --> $DIR/unsized-anon-const-err-1.rs:8:34
    |
 LL |     const EMPTY_MATRIX: Matrix = [[0; 4]; 4];
-   |                                  ^^^^^^^^^^^ expected `[&u32]`, found `[&u32; 4]`
+   |                         ------   ^^^^^^^^^^^ expected `[&u32]`, found `[&u32; 4]`
+   |                         |
+   |                         expected because of the type of the constant
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/unsized-anon-const-func-err.stderr b/tests/ui/const-generics/adt_const_params/unsized-anon-const-func-err.stderr
index 14a41e87e4aa..9e22119cf87f 100644
--- a/tests/ui/const-generics/adt_const_params/unsized-anon-const-func-err.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized-anon-const-func-err.stderr
@@ -21,7 +21,9 @@ error[E0308]: mismatched types
   --> $DIR/unsized-anon-const-func-err.rs:9:22
    |
 LL | const VALUE: [u32] = [0; 4];
-   |                      ^^^^^^ expected `[u32]`, found `[u32; 4]`
+   |              -----   ^^^^^^ expected `[u32]`, found `[u32; 4]`
+   |              |
+   |              expected because of the type of the constant
 
 error[E0277]: the size for values of type `[u32]` cannot be known at compilation time
   --> $DIR/unsized-anon-const-func-err.rs:14:12
diff --git a/tests/ui/const-generics/adt_const_params/unsized-anon-const-struct-err.stderr b/tests/ui/const-generics/adt_const_params/unsized-anon-const-struct-err.stderr
index d9a13976d68a..d81eeb465d6f 100644
--- a/tests/ui/const-generics/adt_const_params/unsized-anon-const-struct-err.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized-anon-const-struct-err.stderr
@@ -30,7 +30,9 @@ error[E0308]: mismatched types
   --> $DIR/unsized-anon-const-struct-err.rs:6:22
    |
 LL | const VALUE: [u32] = [0; 4];
-   |                      ^^^^^^ expected `[u32]`, found `[u32; 4]`
+   |              -----   ^^^^^^ expected `[u32]`, found `[u32; 4]`
+   |              |
+   |              expected because of the type of the constant
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/const-generics/bad-generic-in-copy-impl.stderr b/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
index fbd546d42fb5..c2cf80f38eca 100644
--- a/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
+++ b/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
@@ -3,6 +3,8 @@ error[E0308]: mismatched types
    |
 LL |     x: [u8; SIZE],
    |             ^^^^ expected `usize`, found `u32`
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/bad-generic-in-copy-impl.rs:3:13
@@ -10,6 +12,7 @@ error[E0308]: mismatched types
 LL |     x: [u8; SIZE],
    |             ^^^^ expected `usize`, found `u32`
    |
+   = note: array length can only be `usize`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/const-generics/generic_const_exprs/error_in_ty.stderr b/tests/ui/const-generics/generic_const_exprs/error_in_ty.stderr
index 58f0d31b0960..e10ea5a44b26 100644
--- a/tests/ui/const-generics/generic_const_exprs/error_in_ty.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/error_in_ty.stderr
@@ -29,12 +29,24 @@ error[E0308]: mismatched types
    |
 LL | impl A<2> {
    |        ^ expected `[usize; x]`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/error_in_ty.rs:6:14
+   |
+LL | pub struct A<const z: [usize; x]> {}
+   |              ^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/error_in_ty.rs:16:8
    |
 LL | impl A<2> {
    |        ^ expected `[usize; x]`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/error_in_ty.rs:6:14
+   |
+LL | pub struct A<const z: [usize; x]> {}
+   |              ^^^^^^^^^^^^^^^^^^^
 
 error[E0592]: duplicate definitions with name `B`
   --> $DIR/error_in_ty.rs:12:5
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr b/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
index 1d0ab56519cf..c90feb404181 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
@@ -14,7 +14,9 @@ error[E0308]: mismatched types
   --> $DIR/issue-105257.rs:5:29
    |
 LL |     fn fnc<const N: usize = "">(&self) {}
-   |                             ^^ expected `usize`, found `&str`
+   |                     -----   ^^ expected `usize`, found `&str`
+   |                     |
+   |                     expected because of the type of the const parameter
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/generic_const_exprs/opaque_type.stderr b/tests/ui/const-generics/generic_const_exprs/opaque_type.stderr
index 9f48a8563c8a..fd597cbde193 100644
--- a/tests/ui/const-generics/generic_const_exprs/opaque_type.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/opaque_type.stderr
@@ -9,6 +9,7 @@ LL |     let _: [u8; (N / 2) as Foo] = [0; (N / 2) as usize];
    |
    = note:     expected type `usize`
            found opaque type `Foo`
+   = note: array length can only be `usize`
 
 error[E0605]: non-primitive cast: `usize` as `Foo`
   --> $DIR/opaque_type.rs:11:17
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
index df7c2a0a8629..9392a171510d 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
@@ -3,24 +3,48 @@ error[E0308]: mismatched types
    |
 LL |   get_flag::<false, 0xFF>();
    |                     ^^^^ expected `char`, found `u8`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:34
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:33:14
    |
 LL |   get_flag::<7, 'c'>();
    |              ^ expected `bool`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:13
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:35:14
    |
 LL |   get_flag::<42, 0x5ad>();
    |              ^^ expected `bool`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:13
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:35:18
    |
 LL |   get_flag::<42, 0x5ad>();
    |                  ^^^^^ expected `char`, found `u8`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:34
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x1..0x4], and this operation requires initialized memory
   --> $DIR/invalid-patterns.rs:40:32
diff --git a/tests/ui/const-generics/ogca/basic-fail.stderr b/tests/ui/const-generics/ogca/basic-fail.stderr
index ce4e8eb1471c..b1808deacd27 100644
--- a/tests/ui/const-generics/ogca/basic-fail.stderr
+++ b/tests/ui/const-generics/ogca/basic-fail.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/basic-fail.rs:15:30
    |
 LL | const ARR: [(); ADD1::<0>] = [(); INC::<0>];
-   |                              ^^^^^^^^^^^^^^ expected an array with a size of const { N + 1 }, found one with a size of const { N + 1 }
+   |            ---------------   ^^^^^^^^^^^^^^ expected an array with a size of const { N + 1 }, found one with a size of const { N + 1 }
+   |            |
+   |            expected because of the type of the constant
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/opaque_types.stderr b/tests/ui/const-generics/opaque_types.stderr
index f67e1c8ce699..d49a643e0d87 100644
--- a/tests/ui/const-generics/opaque_types.stderr
+++ b/tests/ui/const-generics/opaque_types.stderr
@@ -30,6 +30,11 @@ LL |     foo::<42>();
    |
    = note: expected opaque type `Foo`
                      found type `{integer}`
+note: expected because of the type of the const parameter
+  --> $DIR/opaque_types.rs:6:8
+   |
+LL | fn foo<const C: Foo>() {}
+   |        ^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/vec-macro-in-static-array.stderr b/tests/ui/const-generics/vec-macro-in-static-array.stderr
index 63d7b0c89fa1..ae08cad556fc 100644
--- a/tests/ui/const-generics/vec-macro-in-static-array.stderr
+++ b/tests/ui/const-generics/vec-macro-in-static-array.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/vec-macro-in-static-array.rs:5:26
    |
 LL | static VEC: [u32; 256] = vec![];
-   |                          ^^^^^^ expected `[u32; 256]`, found `Vec<_>`
+   |             ----------   ^^^^^^ expected `[u32; 256]`, found `Vec<_>`
+   |             |
+   |             expected because of the type of the static
    |
    = note: expected array `[u32; 256]`
              found struct `Vec<_>`
diff --git a/tests/ui/consts/array-literal-len-mismatch.stderr b/tests/ui/consts/array-literal-len-mismatch.stderr
index 39b8a647324b..782d059a294c 100644
--- a/tests/ui/consts/array-literal-len-mismatch.stderr
+++ b/tests/ui/consts/array-literal-len-mismatch.stderr
@@ -2,9 +2,10 @@ error[E0308]: mismatched types
   --> $DIR/array-literal-len-mismatch.rs:1:26
    |
 LL | const NUMBERS: [u8; 3] = [10, 20];
-   |                     -    ^^^^^^^^ expected an array with a size of 3, found one with a size of 2
-   |                     |
-   |                     help: consider specifying the actual array length: `2`
+   |                -------   ^^^^^^^^ expected an array with a size of 3, found one with a size of 2
+   |                |    |
+   |                |    help: consider specifying the actual array length: `2`
+   |                expected because of the type of the constant
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-array-oob-arith.rs b/tests/ui/consts/const-array-oob-arith.rs
index 8e5c56e0ea82..97f8406a10f0 100644
--- a/tests/ui/consts/const-array-oob-arith.rs
+++ b/tests/ui/consts/const-array-oob-arith.rs
@@ -4,10 +4,12 @@
 const BONG: [i32; (ARR[0] - 41) as usize] = [5];
 const BLUB: [i32; (ARR[0] - 40) as usize] = [5];
 //~^ ERROR: mismatched types
-//~| NOTE expected an array
+//~| NOTE: expected an array
+//~| NOTE: expected because
 const BOO: [i32; (ARR[0] - 41) as usize] = [5, 99];
 //~^ ERROR: mismatched types
-//~| NOTE expected an array
+//~| NOTE: expected an array
+//~| NOTE: expected because
 
 fn main() {
     let _ = VAL;
diff --git a/tests/ui/consts/const-array-oob-arith.stderr b/tests/ui/consts/const-array-oob-arith.stderr
index d3299082aa14..d37ae5e4a7b3 100644
--- a/tests/ui/consts/const-array-oob-arith.stderr
+++ b/tests/ui/consts/const-array-oob-arith.stderr
@@ -2,17 +2,19 @@ error[E0308]: mismatched types
   --> $DIR/const-array-oob-arith.rs:5:45
    |
 LL | const BLUB: [i32; (ARR[0] - 40) as usize] = [5];
-   |                   ----------------------    ^^^ expected an array with a size of 2, found one with a size of 1
-   |                   |
-   |                   help: consider specifying the actual array length: `1`
+   |             -----------------------------   ^^^ expected an array with a size of 2, found one with a size of 1
+   |             |     |
+   |             |     help: consider specifying the actual array length: `1`
+   |             expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-array-oob-arith.rs:8:44
+  --> $DIR/const-array-oob-arith.rs:9:44
    |
 LL | const BOO: [i32; (ARR[0] - 41) as usize] = [5, 99];
-   |                  ----------------------    ^^^^^^^ expected an array with a size of 1, found one with a size of 2
-   |                  |
-   |                  help: consider specifying the actual array length: `2`
+   |            -----------------------------   ^^^^^^^ expected an array with a size of 1, found one with a size of 2
+   |            |     |
+   |            |     help: consider specifying the actual array length: `2`
+   |            expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const-eval/array-len-mismatch-type.stderr b/tests/ui/consts/const-eval/array-len-mismatch-type.stderr
index ce641f4a74b9..915fc8e394b3 100644
--- a/tests/ui/consts/const-eval/array-len-mismatch-type.stderr
+++ b/tests/ui/consts/const-eval/array-len-mismatch-type.stderr
@@ -4,6 +4,7 @@ error[E0308]: mismatched types
 LL | pub struct Data([[&'static str]; 5_i32]);
    |                                  ^^^^^ expected `usize`, found `i32`
    |
+   = note: array length can only be `usize`
 help: change the type of the numeric literal from `i32` to `usize`
    |
 LL - pub struct Data([[&'static str]; 5_i32]);
diff --git a/tests/ui/consts/const-eval/const-eval-span.rs b/tests/ui/consts/const-eval/const-eval-span.rs
index f1904c76b6c1..1846da22cd3d 100644
--- a/tests/ui/consts/const-eval/const-eval-span.rs
+++ b/tests/ui/consts/const-eval/const-eval-span.rs
@@ -7,8 +7,9 @@
 
 enum E {
     V = CONSTANT,
-    //~^ ERROR mismatched types
-    //~| NOTE expected `isize`, found `S`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `isize`, found `S`
+    //~| NOTE: enum variant discriminant
 }
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/const-eval-span.stderr b/tests/ui/consts/const-eval/const-eval-span.stderr
index ba11759a7106..ff17da5a04d7 100644
--- a/tests/ui/consts/const-eval/const-eval-span.stderr
+++ b/tests/ui/consts/const-eval/const-eval-span.stderr
@@ -3,6 +3,8 @@ error[E0308]: mismatched types
    |
 LL |     V = CONSTANT,
    |         ^^^^^^^^ expected `isize`, found `S`
+   |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-integer-bool-ops.rs b/tests/ui/consts/const-integer-bool-ops.rs
index fbbd51adfe88..e1da3e750876 100644
--- a/tests/ui/consts/const-integer-bool-ops.rs
+++ b/tests/ui/consts/const-integer-bool-ops.rs
@@ -5,6 +5,7 @@
 //~| NOTE expected `bool`, found integer
 //~| ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARR: [i32; X] = [99; 34];
 
 const X1: usize = 42 || 39;
@@ -14,6 +15,7 @@
 //~| NOTE expected `bool`, found integer
 //~| ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARR1: [i32; X1] = [99; 47];
 
 const X2: usize = -42 || -39;
@@ -23,6 +25,7 @@
 //~| NOTE expected `bool`, found integer
 //~| ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARR2: [i32; X2] = [99; 18446744073709551607];
 
 const X3: usize = -42 && -39;
@@ -32,36 +35,43 @@
 //~| NOTE expected `bool`, found integer
 //~| ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARR3: [i32; X3] = [99; 6];
 
 const Y: usize = 42.0 == 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR: [i32; Y] = [99; 1];
 
 const Y1: usize = 42.0 >= 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR1: [i32; Y1] = [99; 1];
 
 const Y2: usize = 42.0 <= 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR2: [i32; Y2] = [99; 1];
 
 const Y3: usize = 42.0 > 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR3: [i32; Y3] = [99; 0];
 
 const Y4: usize = 42.0 < 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR4: [i32; Y4] = [99; 0];
 
 const Y5: usize = 42.0 != 42.0;
 //~^ ERROR mismatched types
 //~| NOTE expected `usize`, found `bool`
+//~| NOTE expected because
 const ARRR5: [i32; Y5] = [99; 0];
 
 fn main() {
diff --git a/tests/ui/consts/const-integer-bool-ops.stderr b/tests/ui/consts/const-integer-bool-ops.stderr
index 4e503e5a5c0a..5212a5cfeb1e 100644
--- a/tests/ui/consts/const-integer-bool-ops.stderr
+++ b/tests/ui/consts/const-integer-bool-ops.stderr
@@ -14,97 +14,117 @@ error[E0308]: mismatched types
   --> $DIR/const-integer-bool-ops.rs:1:18
    |
 LL | const X: usize = 42 && 39;
-   |                  ^^^^^^^^ expected `usize`, found `bool`
+   |          -----   ^^^^^^^^ expected `usize`, found `bool`
+   |          |
+   |          expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:10:19
+  --> $DIR/const-integer-bool-ops.rs:11:19
    |
 LL | const X1: usize = 42 || 39;
    |                   ^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:10:25
+  --> $DIR/const-integer-bool-ops.rs:11:25
    |
 LL | const X1: usize = 42 || 39;
    |                         ^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:10:19
+  --> $DIR/const-integer-bool-ops.rs:11:19
    |
 LL | const X1: usize = 42 || 39;
-   |                   ^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:19:19
+  --> $DIR/const-integer-bool-ops.rs:21:19
    |
 LL | const X2: usize = -42 || -39;
    |                   ^^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:19:26
+  --> $DIR/const-integer-bool-ops.rs:21:26
    |
 LL | const X2: usize = -42 || -39;
    |                          ^^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:19:19
+  --> $DIR/const-integer-bool-ops.rs:21:19
    |
 LL | const X2: usize = -42 || -39;
-   |                   ^^^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:28:19
+  --> $DIR/const-integer-bool-ops.rs:31:19
    |
 LL | const X3: usize = -42 && -39;
    |                   ^^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:28:26
+  --> $DIR/const-integer-bool-ops.rs:31:26
    |
 LL | const X3: usize = -42 && -39;
    |                          ^^^ expected `bool`, found integer
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:28:19
+  --> $DIR/const-integer-bool-ops.rs:31:19
    |
 LL | const X3: usize = -42 && -39;
-   |                   ^^^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:37:18
+  --> $DIR/const-integer-bool-ops.rs:41:18
    |
 LL | const Y: usize = 42.0 == 42.0;
-   |                  ^^^^^^^^^^^^ expected `usize`, found `bool`
-
-error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:42:19
-   |
-LL | const Y1: usize = 42.0 >= 42.0;
-   |                   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |          -----   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |          |
+   |          expected because of the type of the constant
 
 error[E0308]: mismatched types
   --> $DIR/const-integer-bool-ops.rs:47:19
    |
-LL | const Y2: usize = 42.0 <= 42.0;
-   |                   ^^^^^^^^^^^^ expected `usize`, found `bool`
+LL | const Y1: usize = 42.0 >= 42.0;
+   |           -----   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:52:19
+  --> $DIR/const-integer-bool-ops.rs:53:19
+   |
+LL | const Y2: usize = 42.0 <= 42.0;
+   |           -----   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
+
+error[E0308]: mismatched types
+  --> $DIR/const-integer-bool-ops.rs:59:19
    |
 LL | const Y3: usize = 42.0 > 42.0;
-   |                   ^^^^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:57:19
+  --> $DIR/const-integer-bool-ops.rs:65:19
    |
 LL | const Y4: usize = 42.0 < 42.0;
-   |                   ^^^^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error[E0308]: mismatched types
-  --> $DIR/const-integer-bool-ops.rs:62:19
+  --> $DIR/const-integer-bool-ops.rs:71:19
    |
 LL | const Y5: usize = 42.0 != 42.0;
-   |                   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |           -----   ^^^^^^^^^^^^ expected `usize`, found `bool`
+   |           |
+   |           expected because of the type of the constant
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/consts/const-result-no-expect-suggestion.stderr b/tests/ui/consts/const-result-no-expect-suggestion.stderr
index 70aa306ae3c8..337065f9f5e0 100644
--- a/tests/ui/consts/const-result-no-expect-suggestion.stderr
+++ b/tests/ui/consts/const-result-no-expect-suggestion.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/const-result-no-expect-suggestion.rs:5:19
    |
 LL | const TEST: u32 = f(2);
-   |                   ^^^^ expected `u32`, found `Result<u32, ()>`
+   |             ---   ^^^^ expected `u32`, found `Result<u32, ()>`
+   |             |
+   |             expected because of the type of the constant
    |
    = note: expected type `u32`
               found enum `Result<u32, ()>`
diff --git a/tests/ui/consts/const-slice-array-deref.stderr b/tests/ui/consts/const-slice-array-deref.stderr
index b1d069280885..e7513d01cd0e 100644
--- a/tests/ui/consts/const-slice-array-deref.stderr
+++ b/tests/ui/consts/const-slice-array-deref.stderr
@@ -11,7 +11,9 @@ error[E0308]: mismatched types
   --> $DIR/const-slice-array-deref.rs:1:20
    |
 LL | const ONE: [u16] = [1];
-   |                    ^^^ expected `[u16]`, found `[u16; 1]`
+   |            -----   ^^^ expected `[u16]`, found `[u16; 1]`
+   |            |
+   |            expected because of the type of the constant
 
 error[E0161]: cannot move a value of type `[u16]`
   --> $DIR/const-slice-array-deref.rs:5:28
diff --git a/tests/ui/consts/const-tup-index-span.rs b/tests/ui/consts/const-tup-index-span.rs
index 4cb7143b4351..6896625c3785 100644
--- a/tests/ui/consts/const-tup-index-span.rs
+++ b/tests/ui/consts/const-tup-index-span.rs
@@ -1,9 +1,10 @@
 // Test spans of errors
 
 const TUP: (usize,) = 5usize << 64;
-//~^ ERROR mismatched types
-//~| NOTE expected `(usize,)`, found `usize`
-//~| NOTE expected tuple `(usize,)`
+//~^ ERROR: mismatched types
+//~| NOTE: expected `(usize,)`, found `usize`
+//~| NOTE: expected tuple `(usize,)`
+//~| NOTE: expected because
 const ARR: [i32; TUP.0] = [];
 
 fn main() {
diff --git a/tests/ui/consts/const-tup-index-span.stderr b/tests/ui/consts/const-tup-index-span.stderr
index 792e18aa8fd4..fe4290961816 100644
--- a/tests/ui/consts/const-tup-index-span.stderr
+++ b/tests/ui/consts/const-tup-index-span.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/const-tup-index-span.rs:3:23
    |
 LL | const TUP: (usize,) = 5usize << 64;
-   |                       ^^^^^^^^^^^^ expected `(usize,)`, found `usize`
+   |            --------   ^^^^^^^^^^^^ expected `(usize,)`, found `usize`
+   |            |
+   |            expected because of the type of the constant
    |
    = note: expected tuple `(usize,)`
                found type `usize`
diff --git a/tests/ui/consts/const-type-mismatch.stderr b/tests/ui/consts/const-type-mismatch.stderr
index 17bb27d4b72f..d36ef1188f41 100644
--- a/tests/ui/consts/const-type-mismatch.stderr
+++ b/tests/ui/consts/const-type-mismatch.stderr
@@ -2,13 +2,17 @@ error[E0308]: mismatched types
   --> $DIR/const-type-mismatch.rs:4:21
    |
 LL | const TWELVE: u16 = TEN + 2;
-   |                     ^^^^^^^ expected `u16`, found `u8`
+   |               ---   ^^^^^^^ expected `u16`, found `u8`
+   |               |
+   |               expected because of the type of the constant
 
 error[E0308]: mismatched types
   --> $DIR/const-type-mismatch.rs:9:27
    |
 LL |     const ALSO_TEN: u16 = TEN;
-   |                           ^^^ expected `u16`, found `u8`
+   |                     ---   ^^^ expected `u16`, found `u8`
+   |                     |
+   |                     expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/enum-discr-type-err.stderr b/tests/ui/consts/enum-discr-type-err.stderr
index 9a09d6a96f1a..c676a96ad34a 100644
--- a/tests/ui/consts/enum-discr-type-err.stderr
+++ b/tests/ui/consts/enum-discr-type-err.stderr
@@ -10,6 +10,7 @@ LL | |     B = T,
 LL | | }
    | |_- in this macro invocation
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0308]: mismatched types
@@ -24,6 +25,7 @@ LL | |     B = T,
 LL | | }
    | |_- in this macro invocation
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-104768.stderr b/tests/ui/consts/issue-104768.stderr
index bd4a54de0ae4..81b4575b361b 100644
--- a/tests/ui/consts/issue-104768.stderr
+++ b/tests/ui/consts/issue-104768.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/issue-104768.rs:1:15
    |
 LL | const A: &_ = 0_u32;
-   |               ^^^^^ expected `&_`, found `u32`
+   |          --   ^^^^^ expected `&_`, found `u32`
+   |          |
+   |          expected because of the type of the constant
    |
    = note: expected reference `&'static _`
                    found type `u32`
diff --git a/tests/ui/consts/issue-39974.rs b/tests/ui/consts/issue-39974.rs
index adc65d9be0d0..7d9f1b6cf474 100644
--- a/tests/ui/consts/issue-39974.rs
+++ b/tests/ui/consts/issue-39974.rs
@@ -1,11 +1,13 @@
 const LENGTH: f64 = 2;
-//~^ ERROR mismatched types
-//~| NOTE expected `f64`, found integer
+//~^ ERROR: mismatched types
+//~| NOTE: expected `f64`, found integer
+//~| NOTE: expected because
 
 struct Thing {
     f: [[f64; 2]; LENGTH],
-    //~^ ERROR mismatched types
-    //~| NOTE expected `usize`, found `f64`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `usize`, found `f64`
+    //~| NOTE: array length
 }
 
 fn main() {
diff --git a/tests/ui/consts/issue-39974.stderr b/tests/ui/consts/issue-39974.stderr
index 1c15debb1199..784a19445055 100644
--- a/tests/ui/consts/issue-39974.stderr
+++ b/tests/ui/consts/issue-39974.stderr
@@ -1,14 +1,18 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-39974.rs:6:19
+  --> $DIR/issue-39974.rs:7:19
    |
 LL |     f: [[f64; 2]; LENGTH],
    |                   ^^^^^^ expected `usize`, found `f64`
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/issue-39974.rs:1:21
    |
 LL | const LENGTH: f64 = 2;
-   |                     ^ expected `f64`, found integer
+   |               ---   ^ expected `f64`, found integer
+   |               |
+   |               expected because of the type of the constant
    |
 help: use a float literal
    |
diff --git a/tests/ui/consts/issue-69310-array-size-lit-wrong-ty.stderr b/tests/ui/consts/issue-69310-array-size-lit-wrong-ty.stderr
index 7078b4bd7be1..1210ae87642d 100644
--- a/tests/ui/consts/issue-69310-array-size-lit-wrong-ty.stderr
+++ b/tests/ui/consts/issue-69310-array-size-lit-wrong-ty.stderr
@@ -3,12 +3,16 @@ error[E0308]: mismatched types
    |
 LL | const A: [(); 0.1] = [()];
    |               ^^^ expected `usize`, found floating-point number
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/issue-69310-array-size-lit-wrong-ty.rs:11:15
    |
 LL | const B: [(); b"a"] = [()];
    |               ^^^^ expected `usize`, found `&[u8; 1]`
+   |
+   = note: array length can only be `usize`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/nested_erroneous_ctfe.stderr b/tests/ui/consts/nested_erroneous_ctfe.stderr
index db298246e7cf..b13a6dca2b38 100644
--- a/tests/ui/consts/nested_erroneous_ctfe.stderr
+++ b/tests/ui/consts/nested_erroneous_ctfe.stderr
@@ -6,6 +6,7 @@ LL |     [9; || [9; []]];
    |
    = note: expected type `usize`
              found array `[_; 0]`
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/promoted-type-error-issue-133968.stderr b/tests/ui/consts/promoted-type-error-issue-133968.stderr
index 24f1268e4b6e..a6f67a2056da 100644
--- a/tests/ui/consts/promoted-type-error-issue-133968.stderr
+++ b/tests/ui/consts/promoted-type-error-issue-133968.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/promoted-type-error-issue-133968.rs:4:29
    |
 LL | static STR: &'static [u8] = "a b";
-   |                             ^^^^^ expected `&[u8]`, found `&str`
+   |             -------------   ^^^^^ expected `&[u8]`, found `&str`
+   |             |
+   |             expected because of the type of the static
    |
    = note: expected reference `&'static [u8]`
               found reference `&'static str`
diff --git a/tests/ui/diagnostic-width/long-span.long.stderr b/tests/ui/diagnostic-width/long-span.long.stderr
index 252b17912dee..526719678afe 100644
--- a/tests/ui/diagnostic-width/long-span.long.stderr
+++ b/tests/ui/diagnostic-width/long-span.long.stderr
@@ -9,8 +9,10 @@ LL │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, …, 0, 0, 0, 0, 0, 0, 0] + [0, 0, 0,
 error[E0308]: mismatched types
    ╭▸ $DIR/long-span.rs:9:15
    │
-LL │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, …, 0, 0, 0, 0, 0, 0, 0];
-   ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+LL │ …t D: u8 = [0, 0, 0, 0, 0, 0, 0, 0… 0, 0, 0, 0, 0, 0, 0, 0, 0];
+   │       ┬─   ━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+   │       │
+   ╰╴      expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/diagnostic-width/long-span.longest.stderr b/tests/ui/diagnostic-width/long-span.longest.stderr
index 2e77c3689223..0b1ca9a22fd6 100644
--- a/tests/ui/diagnostic-width/long-span.longest.stderr
+++ b/tests/ui/diagnostic-width/long-span.longest.stderr
@@ -9,8 +9,10 @@ LL | ... = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...0, 0, 0, 0, 0, 0, 0, 0, 0
 error[E0308]: mismatched types
   --> $DIR/long-span.rs:9:15
    |
-LL | ... = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `[{integer}; 1680]`
+LL | ...D: u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,..., 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+   |       --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `[{integer}; 1680]`
+   |       |
+   |       expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/diagnostic-width/long-span.short.stderr b/tests/ui/diagnostic-width/long-span.short.stderr
index b4803e31aaab..bd86a048c434 100644
--- a/tests/ui/diagnostic-width/long-span.short.stderr
+++ b/tests/ui/diagnostic-width/long-span.short.stderr
@@ -9,8 +9,10 @@ LL │ …u8 = [0, 0, 0…0] + [0, 0, 0…0];
 error[E0308]: mismatched types
    ╭▸ $DIR/long-span.rs:9:15
    │
-LL │ …u8 = [0, 0, 0…0];
-   ╰╴      ━━━━━━━━…━━ expected `u8`, found `[{integer}; 1680]`
+LL │ …t D: u8 = [0,…, 0, 0];
+   │       ┬─   ━━━…━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+   │       │
+   ╰╴      expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/diagnostic-width/long-span.shortest.stderr b/tests/ui/diagnostic-width/long-span.shortest.stderr
index 1de1a4acd929..4d9e413287b6 100644
--- a/tests/ui/diagnostic-width/long-span.shortest.stderr
+++ b/tests/ui/diagnostic-width/long-span.shortest.stderr
@@ -9,8 +9,10 @@ LL | ... = [0, 0, 0...0] + [0, 0, 0...0];
 error[E0308]: mismatched types
   --> $DIR/long-span.rs:9:15
    |
-LL | ... = [0, 0, 0...0];
-   |       ^^^^^^^^...^^ expected `u8`, found `[{integer}; 1680]`
+LL | ...D: u8 = [0,..., 0, 0];
+   |       --   ^^^...^^^^^^^ expected `u8`, found `[{integer}; 1680]`
+   |       |
+   |       expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/did_you_mean/brackets-to-braces-single-element.stderr b/tests/ui/did_you_mean/brackets-to-braces-single-element.stderr
index d4aeb1eee96a..83a34e2bcd07 100644
--- a/tests/ui/did_you_mean/brackets-to-braces-single-element.stderr
+++ b/tests/ui/did_you_mean/brackets-to-braces-single-element.stderr
@@ -14,7 +14,9 @@ error[E0308]: mismatched types
   --> $DIR/brackets-to-braces-single-element.rs:4:19
    |
 LL | const B: &[u32] = &{ 1 };
-   |                   ^^^^^^ expected `&[u32]`, found `&{integer}`
+   |          ------   ^^^^^^ expected `&[u32]`, found `&{integer}`
+   |          |
+   |          expected because of the type of the constant
    |
    = note: expected reference `&'static [u32]`
               found reference `&{integer}`
diff --git a/tests/ui/enum-discriminant/discriminant-ill-typed.rs b/tests/ui/enum-discriminant/discriminant-ill-typed.rs
index e3cbd01a1ddf..1e456425cdd8 100644
--- a/tests/ui/enum-discriminant/discriminant-ill-typed.rs
+++ b/tests/ui/enum-discriminant/discriminant-ill-typed.rs
@@ -13,8 +13,9 @@ enum A {
         Ok = i8::MAX - 1,
         Ok2,
         OhNo = 0_u8,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `i8`, found `u8`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `i8`, found `u8`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -26,8 +27,9 @@ enum A {
         Ok = u8::MAX - 1,
         Ok2,
         OhNo = 0_i8,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `u8`, found `i8`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `u8`, found `i8`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -39,8 +41,9 @@ enum A {
         Ok = i16::MAX - 1,
         Ok2,
         OhNo = 0_u16,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `i16`, found `u16`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `i16`, found `u16`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -52,8 +55,9 @@ enum A {
         Ok = u16::MAX - 1,
         Ok2,
         OhNo = 0_i16,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `u16`, found `i16`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `u16`, found `i16`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -65,8 +69,9 @@ enum A {
         Ok = i32::MAX - 1,
         Ok2,
         OhNo = 0_u32,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `i32`, found `u32`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `i32`, found `u32`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -78,8 +83,9 @@ enum A {
         Ok = u32::MAX - 1,
         Ok2,
         OhNo = 0_i32,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `u32`, found `i32`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `u32`, found `i32`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -91,8 +97,9 @@ enum A {
         Ok = i64::MAX - 1,
         Ok2,
         OhNo = 0_u64,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `i64`, found `u64`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `i64`, found `u64`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
@@ -104,8 +111,9 @@ enum A {
         Ok = u64::MAX - 1,
         Ok2,
         OhNo = 0_i64,
-        //~^ ERROR mismatched types
-        //~| NOTE expected `u64`, found `i64`
+        //~^ ERROR: mismatched types
+        //~| NOTE: expected `u64`, found `i64`
+        //~| NOTE: enum variant discriminant
     }
 
     let x = A::Ok;
diff --git a/tests/ui/enum-discriminant/discriminant-ill-typed.stderr b/tests/ui/enum-discriminant/discriminant-ill-typed.stderr
index e9508b7fe962..794447295320 100644
--- a/tests/ui/enum-discriminant/discriminant-ill-typed.stderr
+++ b/tests/ui/enum-discriminant/discriminant-ill-typed.stderr
@@ -4,6 +4,7 @@ error[E0308]: mismatched types
 LL |         OhNo = 0_u8,
    |                ^^^^ expected `i8`, found `u8`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `u8` to `i8`
    |
 LL -         OhNo = 0_u8,
@@ -11,11 +12,12 @@ LL +         OhNo = 0_i8,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:28:16
+  --> $DIR/discriminant-ill-typed.rs:29:16
    |
 LL |         OhNo = 0_i8,
    |                ^^^^ expected `u8`, found `i8`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `i8` to `u8`
    |
 LL -         OhNo = 0_i8,
@@ -23,11 +25,12 @@ LL +         OhNo = 0_u8,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:41:16
+  --> $DIR/discriminant-ill-typed.rs:43:16
    |
 LL |         OhNo = 0_u16,
    |                ^^^^^ expected `i16`, found `u16`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `u16` to `i16`
    |
 LL -         OhNo = 0_u16,
@@ -35,11 +38,12 @@ LL +         OhNo = 0_i16,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:54:16
+  --> $DIR/discriminant-ill-typed.rs:57:16
    |
 LL |         OhNo = 0_i16,
    |                ^^^^^ expected `u16`, found `i16`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `i16` to `u16`
    |
 LL -         OhNo = 0_i16,
@@ -47,11 +51,12 @@ LL +         OhNo = 0_u16,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:67:16
+  --> $DIR/discriminant-ill-typed.rs:71:16
    |
 LL |         OhNo = 0_u32,
    |                ^^^^^ expected `i32`, found `u32`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `u32` to `i32`
    |
 LL -         OhNo = 0_u32,
@@ -59,11 +64,12 @@ LL +         OhNo = 0_i32,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:80:16
+  --> $DIR/discriminant-ill-typed.rs:85:16
    |
 LL |         OhNo = 0_i32,
    |                ^^^^^ expected `u32`, found `i32`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `i32` to `u32`
    |
 LL -         OhNo = 0_i32,
@@ -71,11 +77,12 @@ LL +         OhNo = 0_u32,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:93:16
+  --> $DIR/discriminant-ill-typed.rs:99:16
    |
 LL |         OhNo = 0_u64,
    |                ^^^^^ expected `i64`, found `u64`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `u64` to `i64`
    |
 LL -         OhNo = 0_u64,
@@ -83,11 +90,12 @@ LL +         OhNo = 0_i64,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/discriminant-ill-typed.rs:106:16
+  --> $DIR/discriminant-ill-typed.rs:113:16
    |
 LL |         OhNo = 0_i64,
    |                ^^^^^ expected `u64`, found `i64`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `i64` to `u64`
    |
 LL -         OhNo = 0_i64,
diff --git a/tests/ui/enum/closure-in-enum-issue-48838.stderr b/tests/ui/enum/closure-in-enum-issue-48838.stderr
index 17e6c3433343..6c84efe73e42 100644
--- a/tests/ui/enum/closure-in-enum-issue-48838.stderr
+++ b/tests/ui/enum/closure-in-enum-issue-48838.stderr
@@ -6,6 +6,7 @@ LL |     Square = |x| x,
    |
    = note: expected type `isize`
            found closure `{closure@$DIR/closure-in-enum-issue-48838.rs:2:14: 2:17}`
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/enum/enum-discriminant-type-mismatch-8761.rs b/tests/ui/enum/enum-discriminant-type-mismatch-8761.rs
index ae09b919dc15..63973be83774 100644
--- a/tests/ui/enum/enum-discriminant-type-mismatch-8761.rs
+++ b/tests/ui/enum/enum-discriminant-type-mismatch-8761.rs
@@ -1,11 +1,13 @@
 // https://github.com/rust-lang/rust/issues/8761
 enum Foo {
     A = 1i64,
-    //~^ ERROR mismatched types
-    //~| NOTE expected `isize`, found `i64`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `isize`, found `i64`
+    //~| NOTE: enum variant discriminant
     B = 2u8
-    //~^ ERROR mismatched types
-    //~| NOTE expected `isize`, found `u8`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `isize`, found `u8`
+    //~| NOTE: enum variant discriminant
 }
 
 fn main() {}
diff --git a/tests/ui/enum/enum-discriminant-type-mismatch-8761.stderr b/tests/ui/enum/enum-discriminant-type-mismatch-8761.stderr
index f1645183e176..d256a2ed644b 100644
--- a/tests/ui/enum/enum-discriminant-type-mismatch-8761.stderr
+++ b/tests/ui/enum/enum-discriminant-type-mismatch-8761.stderr
@@ -4,6 +4,7 @@ error[E0308]: mismatched types
 LL |     A = 1i64,
    |         ^^^^ expected `isize`, found `i64`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `i64` to `isize`
    |
 LL -     A = 1i64,
@@ -11,11 +12,12 @@ LL +     A = 1isize,
    |
 
 error[E0308]: mismatched types
-  --> $DIR/enum-discriminant-type-mismatch-8761.rs:6:9
+  --> $DIR/enum-discriminant-type-mismatch-8761.rs:7:9
    |
 LL |     B = 2u8
    |         ^^^ expected `isize`, found `u8`
    |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 help: change the type of the numeric literal from `u8` to `isize`
    |
 LL -     B = 2u8
diff --git a/tests/ui/generic-const-items/assoc-const-missing-type.stderr b/tests/ui/generic-const-items/assoc-const-missing-type.stderr
index 7c79133d64ec..b7fb625a9ea5 100644
--- a/tests/ui/generic-const-items/assoc-const-missing-type.stderr
+++ b/tests/ui/generic-const-items/assoc-const-missing-type.stderr
@@ -2,8 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/assoc-const-missing-type.rs:12:18
    |
 LL |     const K<T> = ();
-   |             -    ^^ expected type parameter `T`, found `()`
-   |             |
+   |             - -  ^^ expected type parameter `T`, found `()`
+   |             | |
+   |             | expected because of the type of the associated constant
    |             expected this type parameter
    |
    = note: expected type parameter `T`
diff --git a/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
index f2fd4340a580..8bc0f0a5e92f 100644
--- a/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
+++ b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
@@ -22,7 +22,9 @@ error[E0308]: mismatched types
 LL | impl<T> S0<T> {
    |      - found this type parameter
 LL |     const C: S0<u8> = Self(0);
-   |                       ^^^^^^^ expected `S0<u8>`, found `S0<T>`
+   |              ------   ^^^^^^^ expected `S0<u8>`, found `S0<T>`
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected struct `S0<u8>`
               found struct `S0<T>`
@@ -89,7 +91,9 @@ error[E0308]: mismatched types
 LL | impl<T> S1<T, u8> {
    |      - found this type parameter
 LL |     const C: S1<u8, u8> = Self(0, 1);
-   |                           ^^^^^^^^^^ expected `S1<u8, u8>`, found `S1<T, u8>`
+   |              ----------   ^^^^^^^^^^ expected `S1<u8, u8>`, found `S1<T, u8>`
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected struct `S1<u8, _>`
               found struct `S1<T, _>`
diff --git a/tests/ui/issues/issue-31910.rs b/tests/ui/issues/issue-31910.rs
index fc82fda0ccd8..697bbf6fe6d1 100644
--- a/tests/ui/issues/issue-31910.rs
+++ b/tests/ui/issues/issue-31910.rs
@@ -1,9 +1,10 @@
 enum Enum<T: Trait> {
-    //~^ ERROR `T` is never used
-    //~| NOTE unused type parameter
+    //~^ ERROR: `T` is never used
+    //~| NOTE: unused type parameter
     X = Trait::Number,
-    //~^ ERROR mismatched types
-    //~| NOTE expected `isize`, found `i32`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `isize`, found `i32`
+    //~| NOTE: enum variant discriminant
 }
 
 trait Trait {
diff --git a/tests/ui/issues/issue-31910.stderr b/tests/ui/issues/issue-31910.stderr
index 56e4cee53d63..765db15e8285 100644
--- a/tests/ui/issues/issue-31910.stderr
+++ b/tests/ui/issues/issue-31910.stderr
@@ -3,6 +3,8 @@ error[E0308]: mismatched types
    |
 LL |     X = Trait::Number,
    |         ^^^^^^^^^^^^^ expected `isize`, found `i32`
+   |
+   = note: enum variant discriminant can only be of a primitive type compatible with the enum's `repr`
 
 error[E0392]: type parameter `T` is never used
   --> $DIR/issue-31910.rs:1:11
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.stderr b/tests/ui/lifetimes/unusual-rib-combinations.stderr
index 7f44ab2ed6b4..1ce50903ff10 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.stderr
+++ b/tests/ui/lifetimes/unusual-rib-combinations.stderr
@@ -37,6 +37,8 @@ error[E0308]: mismatched types
    |
 LL | fn a() -> [u8; foo()] {
    |                ^^^^^ expected `usize`, found `()`
+   |
+   = note: array length can only be `usize`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/mismatched_types/array-len-is-closure.stderr b/tests/ui/mismatched_types/array-len-is-closure.stderr
index db5d801871bc..a6f9518c3e63 100644
--- a/tests/ui/mismatched_types/array-len-is-closure.stderr
+++ b/tests/ui/mismatched_types/array-len-is-closure.stderr
@@ -6,6 +6,7 @@ LL |     [1; || {}];
    |
    = note: expected type `usize`
            found closure `{closure@$DIR/array-len-is-closure.rs:4:9: 4:11}`
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/mismatched_types/array-repeat-unit-struct.rs b/tests/ui/mismatched_types/array-repeat-unit-struct.rs
index db05e1daedbd..f92f97ed587b 100644
--- a/tests/ui/mismatched_types/array-repeat-unit-struct.rs
+++ b/tests/ui/mismatched_types/array-repeat-unit-struct.rs
@@ -4,6 +4,7 @@
 
 fn main() {
     let b = [0; S];
-    //~^ ERROR mismatched types
-    //~| NOTE expected `usize`, found `S`
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `usize`, found `S`
+    //~| NOTE: array length
 }
diff --git a/tests/ui/mismatched_types/array-repeat-unit-struct.stderr b/tests/ui/mismatched_types/array-repeat-unit-struct.stderr
index 9a9cc946f82a..155adb5363a2 100644
--- a/tests/ui/mismatched_types/array-repeat-unit-struct.stderr
+++ b/tests/ui/mismatched_types/array-repeat-unit-struct.stderr
@@ -3,6 +3,8 @@ error[E0308]: mismatched types
    |
 LL |     let b = [0; S];
    |                 ^ expected `usize`, found `S`
+   |
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/never_type/regress/loop-in-array-length.stderr b/tests/ui/never_type/regress/loop-in-array-length.stderr
index a51eb46fb244..fc0a670d08dc 100644
--- a/tests/ui/never_type/regress/loop-in-array-length.stderr
+++ b/tests/ui/never_type/regress/loop-in-array-length.stderr
@@ -14,6 +14,7 @@ LL |     [(); & { loop { continue } } ];
    |
    = note:   expected type `usize`
            found reference `&_`
+   = note: array length can only be `usize`
 help: consider removing the borrow
    |
 LL -     [(); & { loop { continue } } ];
diff --git a/tests/ui/numeric/const-scope.stderr b/tests/ui/numeric/const-scope.stderr
index 2c8d4da9d218..4851a20fcf0e 100644
--- a/tests/ui/numeric/const-scope.stderr
+++ b/tests/ui/numeric/const-scope.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/const-scope.rs:1:16
    |
 LL | const C: i32 = 1i8;
-   |                ^^^ expected `i32`, found `i8`
+   |          ---   ^^^ expected `i32`, found `i8`
+   |          |
+   |          expected because of the type of the constant
    |
 help: change the type of the numeric literal from `i8` to `i32`
    |
@@ -14,7 +16,9 @@ error[E0308]: mismatched types
   --> $DIR/const-scope.rs:2:15
    |
 LL | const D: i8 = C;
-   |               ^ expected `i8`, found `i32`
+   |          --   ^ expected `i8`, found `i32`
+   |          |
+   |          expected because of the type of the constant
 
 error[E0308]: mismatched types
   --> $DIR/const-scope.rs:5:18
diff --git a/tests/ui/parser/pat-lt-bracket-6.stderr b/tests/ui/parser/pat-lt-bracket-6.stderr
index 83c88d1085ef..6f91967b8b82 100644
--- a/tests/ui/parser/pat-lt-bracket-6.stderr
+++ b/tests/ui/parser/pat-lt-bracket-6.stderr
@@ -24,7 +24,9 @@ error[E0308]: mismatched types
   --> $DIR/pat-lt-bracket-6.rs:10:30
    |
 LL | const RECOVERY_WITNESS: () = 0;
-   |                              ^ expected `()`, found integer
+   |                         --   ^ expected `()`, found integer
+   |                         |
+   |                         expected because of the type of the constant
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/parser/pat-lt-bracket-7.stderr b/tests/ui/parser/pat-lt-bracket-7.stderr
index cc457a4e64e2..5cdb94cb8176 100644
--- a/tests/ui/parser/pat-lt-bracket-7.stderr
+++ b/tests/ui/parser/pat-lt-bracket-7.stderr
@@ -11,7 +11,9 @@ error[E0308]: mismatched types
   --> $DIR/pat-lt-bracket-7.rs:9:30
    |
 LL | const RECOVERY_WITNESS: () = 0;
-   |                              ^ expected `()`, found integer
+   |                         --   ^ expected `()`, found integer
+   |                         |
+   |                         expected because of the type of the constant
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/parser/recover/recover-for-loop-parens-around-head.stderr b/tests/ui/parser/recover/recover-for-loop-parens-around-head.stderr
index 2bc7952def79..8b784d02a01d 100644
--- a/tests/ui/parser/recover/recover-for-loop-parens-around-head.stderr
+++ b/tests/ui/parser/recover/recover-for-loop-parens-around-head.stderr
@@ -14,7 +14,9 @@ error[E0308]: mismatched types
   --> $DIR/recover-for-loop-parens-around-head.rs:13:40
    |
 LL |         const _RECOVERY_WITNESS: u32 = 0u8;
-   |                                        ^^^ expected `u32`, found `u8`
+   |                                  ---   ^^^ expected `u32`, found `u8`
+   |                                  |
+   |                                  expected because of the type of the constant
    |
 help: change the type of the numeric literal from `u8` to `u32`
    |
diff --git a/tests/ui/proc-macro/macro-brackets.stderr b/tests/ui/proc-macro/macro-brackets.stderr
index f14b5fed6b9e..00c1c6b0f4cf 100644
--- a/tests/ui/proc-macro/macro-brackets.stderr
+++ b/tests/ui/proc-macro/macro-brackets.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/macro-brackets.rs:11:21
    |
 LL | id![static X: u32 = 'a';];
-   |                     ^^^ expected `u32`, found `char`
+   |               ---   ^^^ expected `u32`, found `char`
+   |               |
+   |               expected because of the type of the static
    |
 help: you can cast a `char` to a `u32`, since a `char` always occupies 4 bytes
    |
diff --git a/tests/ui/repeat-expr/repeat_count.stderr b/tests/ui/repeat-expr/repeat_count.stderr
index eb9581b8f7ae..e2cecf9973b8 100644
--- a/tests/ui/repeat-expr/repeat_count.stderr
+++ b/tests/ui/repeat-expr/repeat_count.stderr
@@ -15,24 +15,32 @@ error[E0308]: mismatched types
    |
 LL |     let b = [0; ()];
    |                 ^^ expected `usize`, found `()`
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:12:17
    |
 LL |     let c = [0; true];
    |                 ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:15:17
    |
 LL |     let d = [0; 0.5];
    |                 ^^^ expected `usize`, found floating-point number
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:18:17
    |
 LL |     let e = [0; "foo"];
    |                 ^^^^^ expected `usize`, found `&str`
+   |
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:21:17
@@ -41,6 +49,7 @@ LL |     let f = [0; -4_isize];
    |                 ^^^^^^^^ expected `usize`, found `isize`
    |
    = note: `-4_isize` cannot fit into type `usize`
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:25:23
@@ -49,6 +58,7 @@ LL |     let g = [0_usize; -1_isize];
    |                       ^^^^^^^^ expected `usize`, found `isize`
    |
    = note: `-1_isize` cannot fit into type `usize`
+   = note: array length can only be `usize`
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:29:17
@@ -56,6 +66,7 @@ error[E0308]: mismatched types
 LL |     let h = [0; 4u8];
    |                 ^^^ expected `usize`, found `u8`
    |
+   = note: array length can only be `usize`
 help: change the type of the numeric literal from `u8` to `usize`
    |
 LL -     let h = [0; 4u8];
@@ -67,6 +78,8 @@ error[E0308]: mismatched types
    |
 LL |     let i = [0; I { i: () }];
    |                 ^^^^^^^^^^^ expected `usize`, found `I`
+   |
+   = note: array length can only be `usize`
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/self/issue-61882.stderr b/tests/ui/self/issue-61882.stderr
index 96f4e41de174..867e3e97ac37 100644
--- a/tests/ui/self/issue-61882.stderr
+++ b/tests/ui/self/issue-61882.stderr
@@ -16,7 +16,9 @@ error[E0308]: mismatched types
   --> $DIR/issue-61882.rs:4:22
    |
 LL |     const B: A<u8> = Self(0);
-   |                      ^^^^^^^ expected `A<u8>`, found `A<bool>`
+   |              -----   ^^^^^^^ expected `A<u8>`, found `A<bool>`
+   |              |
+   |              expected because of the type of the associated constant
    |
    = note: expected struct `A<u8>`
               found struct `A<bool>`
diff --git a/tests/ui/static/bad-const-type.rs b/tests/ui/static/bad-const-type.rs
index d4e6352d7c1c..696fa295af41 100644
--- a/tests/ui/static/bad-const-type.rs
+++ b/tests/ui/static/bad-const-type.rs
@@ -1,4 +1,5 @@
 static i: String = 10;
-//~^ ERROR mismatched types
-//~| NOTE expected `String`, found integer
+//~^ ERROR: mismatched types
+//~| NOTE: expected `String`, found integer
+//~| NOTE: expected because
 fn main() { println!("{}", i); }
diff --git a/tests/ui/static/bad-const-type.stderr b/tests/ui/static/bad-const-type.stderr
index 8573a11ef291..12ecb73d94da 100644
--- a/tests/ui/static/bad-const-type.stderr
+++ b/tests/ui/static/bad-const-type.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/bad-const-type.rs:1:20
    |
 LL | static i: String = 10;
-   |                    ^^ expected `String`, found integer
+   |           ------   ^^ expected `String`, found integer
+   |           |
+   |           expected because of the type of the static
    |
 help: try using a conversion method
    |
diff --git a/tests/ui/static/issue-5216.stderr b/tests/ui/static/issue-5216.stderr
index 99c8b1aa131a..9748223e3d1d 100644
--- a/tests/ui/static/issue-5216.stderr
+++ b/tests/ui/static/issue-5216.stderr
@@ -18,7 +18,9 @@ error[E0308]: mismatched types
   --> $DIR/issue-5216.rs:8:19
    |
 LL | pub static D: T = g;
-   |                   ^ expected `Box<dyn FnMut() + Sync>`, found fn item
+   |               -   ^ expected `Box<dyn FnMut() + Sync>`, found fn item
+   |               |
+   |               expected because of the type of the static
    |
    = note: expected struct `Box<(dyn FnMut() + Sync + 'static)>`
              found fn item `fn() {g}`
diff --git a/tests/ui/transmutability/arrays/issue-103783-array-length.stderr b/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
index 02ac40741cb7..18f6e9b4ed10 100644
--- a/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
+++ b/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
@@ -3,6 +3,8 @@ error[E0308]: mismatched types
    |
 LL |     type NaughtyLenArray = [u32; 3.14159];
    |                                  ^^^^^^^ expected `usize`, found floating-point number
+   |
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/pattern_types/nested.stderr b/tests/ui/type/pattern_types/nested.stderr
index 7893cc849248..cb491a78945c 100644
--- a/tests/ui/type/pattern_types/nested.stderr
+++ b/tests/ui/type/pattern_types/nested.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/nested.rs:10:63
    |
 LL | const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!();
-   |                                                               ^ expected `(u32) is 1..`, found integer
+   |                                  -------------------------    ^ expected `(u32) is 1..`, found integer
+   |                                  |
+   |                                  the pattern must match the type
    |
    = note: expected pattern type `(u32) is 1..`
                       found type `{integer}`
diff --git a/tests/ui/type/pattern_types/pattern_type_mismatch.stderr b/tests/ui/type/pattern_types/pattern_type_mismatch.stderr
index 4af92a89c445..129e4b5cdc7b 100644
--- a/tests/ui/type/pattern_types/pattern_type_mismatch.stderr
+++ b/tests/ui/type/pattern_types/pattern_type_mismatch.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/pattern_type_mismatch.rs:8:41
    |
 LL | const BAD_NESTING4: pattern_type!(u8 is 'a'..='a') = todo!();
-   |                                         ^^^ expected `u8`, found `char`
+   |                                   --    ^^^ expected `u8`, found `char`
+   |                                   |
+   |                                   the pattern must match the type
    |
 help: if you meant to write a byte literal, prefix with `b`
    |
@@ -13,7 +15,9 @@ error[E0308]: mismatched types
   --> $DIR/pattern_type_mismatch.rs:8:47
    |
 LL | const BAD_NESTING4: pattern_type!(u8 is 'a'..='a') = todo!();
-   |                                               ^^^ expected `u8`, found `char`
+   |                                   --          ^^^ expected `u8`, found `char`
+   |                                   |
+   |                                   the pattern must match the type
    |
 help: if you meant to write a byte literal, prefix with `b`
    |
@@ -24,13 +28,17 @@ error[E0308]: mismatched types
   --> $DIR/pattern_type_mismatch.rs:12:43
    |
 LL | const BAD_NESTING5: pattern_type!(char is 1..=1) = todo!();
-   |                                           ^ expected `char`, found `u8`
+   |                                   ----    ^ expected `char`, found `u8`
+   |                                   |
+   |                                   the pattern must match the type
 
 error[E0308]: mismatched types
   --> $DIR/pattern_type_mismatch.rs:12:47
    |
 LL | const BAD_NESTING5: pattern_type!(char is 1..=1) = todo!();
-   |                                               ^ expected `char`, found `u8`
+   |                                   ----        ^ expected `char`, found `u8`
+   |                                   |
+   |                                   the pattern must match the type
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/wf/range-expr-root-of-constant-issue-40749.rs b/tests/ui/wf/range-expr-root-of-constant-issue-40749.rs
index bec92448d1c8..07e4b9addaa1 100644
--- a/tests/ui/wf/range-expr-root-of-constant-issue-40749.rs
+++ b/tests/ui/wf/range-expr-root-of-constant-issue-40749.rs
@@ -1,9 +1,11 @@
 fn main() {
     [0; ..10];
-    //~^ ERROR mismatched types
-    //~| NOTE expected type `usize`
-    //~| NOTE found struct `RangeTo<{integer}>`
-    //~| NOTE expected `usize`, found `RangeTo<{integer}>
-    //~| NOTE in this expansion of desugaring of range expression
-    //~| NOTE in this expansion of desugaring of range expression
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected type `usize`
+    //~| NOTE: found struct `RangeTo<{integer}>`
+    //~| NOTE: expected `usize`, found `RangeTo<{integer}>
+    //~| NOTE: array length can only be `usize`
+    //~| NOTE: in this expansion of desugaring of range expression
+    //~| NOTE: in this expansion of desugaring of range expression
+    //~| NOTE: in this expansion of desugaring of range expression
 }
diff --git a/tests/ui/wf/range-expr-root-of-constant-issue-40749.stderr b/tests/ui/wf/range-expr-root-of-constant-issue-40749.stderr
index 482773a39440..daddbe9fa469 100644
--- a/tests/ui/wf/range-expr-root-of-constant-issue-40749.stderr
+++ b/tests/ui/wf/range-expr-root-of-constant-issue-40749.stderr
@@ -6,6 +6,7 @@ LL |     [0; ..10];
    |
    = note: expected type `usize`
             found struct `RangeTo<{integer}>`
+   = note: array length can only be `usize`
 
 error: aborting due to 1 previous error
 

From 2e4a420db08a0bb5a43834227aef532a9de3b3ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 18:02:00 +0000
Subject: [PATCH 0478/1059] Explain that default field values aren't compatible
 with type parameters unless going through the type parameter

```
error[E0308]: mismatched types
  --> $DIR/struct-type-parameter-with-default.rs:5:12
   |
LL | struct Foo<T = String> {
   |            ---------- expected this type parameter
LL |     x: T = String::new(),
   |            ^^^^^^^^^^^^^ expected type parameter `T`, found `String`
   |
   = note: expected type parameter `T`
                      found struct `String`
   = note: the type of default fields referencing type parameters can't be assumed inside the struct defining them
```
---
 compiler/rustc_hir_typeck/src/lib.rs           | 18 ++++++++++++++++--
 .../struct-type-parameter-with-default.rs      | 11 +++++++++++
 .../struct-type-parameter-with-default.stderr  | 15 +++++++++++++++
 3 files changed, 42 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/structs/default-field-values/struct-type-parameter-with-default.rs
 create mode 100644 tests/ui/structs/default-field-values/struct-type-parameter-with-default.stderr

diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 200cef49f35d..734e5136f880 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -205,7 +205,7 @@ fn typeck_with_inspect<'tcx>(
         }
 
         fcx.check_expr_coercible_to_type_or_error(body.value, expected_type, None, |err, _| {
-            extend_err_with_const_context(err, tcx, node);
+            extend_err_with_const_context(err, tcx, node, expected_type);
         });
 
         fcx.write_ty(id, expected_type);
@@ -276,7 +276,12 @@ fn typeck_with_inspect<'tcx>(
     typeck_results
 }
 
-fn extend_err_with_const_context(err: &mut Diag<'_>, tcx: TyCtxt<'_>, node: hir::Node<'_>) {
+fn extend_err_with_const_context(
+    err: &mut Diag<'_>,
+    tcx: TyCtxt<'_>,
+    node: hir::Node<'_>,
+    expected_ty: Ty<'_>,
+) {
     match node {
         hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(ty, _), .. })
         | hir::Node::TraitItem(hir::TraitItem {
@@ -378,6 +383,15 @@ fn extend_err_with_const_context(err: &mut Diag<'_>, tcx: TyCtxt<'_>, node: hir:
             // Point at `char` in `pattern_type!(char is 1..=1)`.
             err.span_label(ty.span, "the pattern must match the type");
         }
+        hir::Node::AnonConst(anon)
+            if let hir::Node::Field(_) = tcx.parent_hir_node(anon.hir_id)
+                && let ty::Param(_) = expected_ty.kind() =>
+        {
+            err.note(
+                "the type of default fields referencing type parameters can't be assumed inside \
+                 the struct defining them",
+            );
+        }
         _ => {}
     }
 }
diff --git a/tests/ui/structs/default-field-values/struct-type-parameter-with-default.rs b/tests/ui/structs/default-field-values/struct-type-parameter-with-default.rs
new file mode 100644
index 000000000000..c9e5aa9afb41
--- /dev/null
+++ b/tests/ui/structs/default-field-values/struct-type-parameter-with-default.rs
@@ -0,0 +1,11 @@
+// Test for #147748, providing additional clarification that default field values aren't compatible
+// with type parameters unless going through the type parameter.
+#![feature(default_field_values)]
+struct Foo<T = String> { //~ NOTE: expected this type parameter
+    x: T = String::new(),
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected type parameter
+    //~| NOTE: expected type parameter
+    //~| NOTE: the type of default fields referencing type parameters can't be assumed inside the struct defining them
+}
+fn main() {}
diff --git a/tests/ui/structs/default-field-values/struct-type-parameter-with-default.stderr b/tests/ui/structs/default-field-values/struct-type-parameter-with-default.stderr
new file mode 100644
index 000000000000..553b49023835
--- /dev/null
+++ b/tests/ui/structs/default-field-values/struct-type-parameter-with-default.stderr
@@ -0,0 +1,15 @@
+error[E0308]: mismatched types
+  --> $DIR/struct-type-parameter-with-default.rs:5:12
+   |
+LL | struct Foo<T = String> {
+   |            ---------- expected this type parameter
+LL |     x: T = String::new(),
+   |            ^^^^^^^^^^^^^ expected type parameter `T`, found `String`
+   |
+   = note: expected type parameter `T`
+                      found struct `String`
+   = note: the type of default fields referencing type parameters can't be assumed inside the struct defining them
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From 724c1a02e11e3b7d3f18a99bea11d450ebd82c2f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 19:15:56 +0000
Subject: [PATCH 0479/1059] Update rustdoc-ui test

---
 tests/rustdoc-ui/track-diagnostics.rs     | 1 +
 tests/rustdoc-ui/track-diagnostics.stderr | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/rustdoc-ui/track-diagnostics.rs b/tests/rustdoc-ui/track-diagnostics.rs
index f8e710659a5c..6a5d1b53b3c7 100644
--- a/tests/rustdoc-ui/track-diagnostics.rs
+++ b/tests/rustdoc-ui/track-diagnostics.rs
@@ -11,3 +11,4 @@
 //~^ ERROR mismatched types
 //~| NOTE created at
 //~| NOTE expected `A`, found `B`
+//~| NOTE expected because of the type of the const
diff --git a/tests/rustdoc-ui/track-diagnostics.stderr b/tests/rustdoc-ui/track-diagnostics.stderr
index a25fd2862aaf..c7dfe07c596f 100644
--- a/tests/rustdoc-ui/track-diagnostics.stderr
+++ b/tests/rustdoc-ui/track-diagnostics.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> $DIR/track-diagnostics.rs:LL:CC
    |
 LL | pub const S: A = B;
-   |                  ^ expected `A`, found `B`
+   |              -   ^ expected `A`, found `B`
+   |              |
+   |              expected because of the type of the constant
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs:LL:CC
 

From ff0ce4f5fa83a03082ed6efb3f0088dcd935be92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 20:12:18 +0000
Subject: [PATCH 0480/1059] Make some suggestions verbose

---
 compiler/rustc_trait_selection/src/errors.rs   |  9 ++++++---
 .../consts/array-literal-len-mismatch.stderr   |  9 +++++++--
 tests/ui/consts/const-array-oob-arith.stderr   | 18 ++++++++++++++----
 tests/ui/inference/array-len-mismatch.stderr   | 18 ++++++++++++++----
 4 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs
index 6f63c1d663f1..34b9c9988f35 100644
--- a/compiler/rustc_trait_selection/src/errors.rs
+++ b/compiler/rustc_trait_selection/src/errors.rs
@@ -1707,7 +1707,8 @@ pub enum TypeErrorAdditionalDiags {
     #[suggestion(
         "if you meant to write a byte literal, prefix with `b`",
         code = "b'{code}'",
-        applicability = "machine-applicable"
+        applicability = "machine-applicable",
+        style = "verbose"
     )]
     MeantByteLiteral {
         #[primary_span]
@@ -1717,7 +1718,8 @@ pub enum TypeErrorAdditionalDiags {
     #[suggestion(
         "if you meant to write a `char` literal, use single quotes",
         code = "'{code}'",
-        applicability = "machine-applicable"
+        applicability = "machine-applicable",
+        style = "verbose"
     )]
     MeantCharLiteral {
         #[primary_span]
@@ -1737,7 +1739,8 @@ pub enum TypeErrorAdditionalDiags {
     #[suggestion(
         "consider specifying the actual array length",
         code = "{length}",
-        applicability = "maybe-incorrect"
+        applicability = "maybe-incorrect",
+        style = "verbose"
     )]
     ConsiderSpecifyingLength {
         #[primary_span]
diff --git a/tests/ui/consts/array-literal-len-mismatch.stderr b/tests/ui/consts/array-literal-len-mismatch.stderr
index 782d059a294c..bf828ff5acf5 100644
--- a/tests/ui/consts/array-literal-len-mismatch.stderr
+++ b/tests/ui/consts/array-literal-len-mismatch.stderr
@@ -3,9 +3,14 @@ error[E0308]: mismatched types
    |
 LL | const NUMBERS: [u8; 3] = [10, 20];
    |                -------   ^^^^^^^^ expected an array with a size of 3, found one with a size of 2
-   |                |    |
-   |                |    help: consider specifying the actual array length: `2`
+   |                |
    |                expected because of the type of the constant
+   |
+help: consider specifying the actual array length
+   |
+LL - const NUMBERS: [u8; 3] = [10, 20];
+LL + const NUMBERS: [u8; 2] = [10, 20];
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-array-oob-arith.stderr b/tests/ui/consts/const-array-oob-arith.stderr
index d37ae5e4a7b3..0cb654237ab5 100644
--- a/tests/ui/consts/const-array-oob-arith.stderr
+++ b/tests/ui/consts/const-array-oob-arith.stderr
@@ -3,18 +3,28 @@ error[E0308]: mismatched types
    |
 LL | const BLUB: [i32; (ARR[0] - 40) as usize] = [5];
    |             -----------------------------   ^^^ expected an array with a size of 2, found one with a size of 1
-   |             |     |
-   |             |     help: consider specifying the actual array length: `1`
+   |             |
    |             expected because of the type of the constant
+   |
+help: consider specifying the actual array length
+   |
+LL - const BLUB: [i32; (ARR[0] - 40) as usize] = [5];
+LL + const BLUB: [i32; 1] = [5];
+   |
 
 error[E0308]: mismatched types
   --> $DIR/const-array-oob-arith.rs:9:44
    |
 LL | const BOO: [i32; (ARR[0] - 41) as usize] = [5, 99];
    |            -----------------------------   ^^^^^^^ expected an array with a size of 1, found one with a size of 2
-   |            |     |
-   |            |     help: consider specifying the actual array length: `2`
+   |            |
    |            expected because of the type of the constant
+   |
+help: consider specifying the actual array length
+   |
+LL - const BOO: [i32; (ARR[0] - 41) as usize] = [5, 99];
+LL + const BOO: [i32; 2] = [5, 99];
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/inference/array-len-mismatch.stderr b/tests/ui/inference/array-len-mismatch.stderr
index 7146e3803d53..94813d404b2b 100644
--- a/tests/ui/inference/array-len-mismatch.stderr
+++ b/tests/ui/inference/array-len-mismatch.stderr
@@ -3,18 +3,28 @@ error[E0308]: mismatched types
    |
 LL |     let wrong: [u8; 3] = [10, 20];
    |                -------   ^^^^^^^^ expected an array with a size of 3, found one with a size of 2
-   |                |    |
-   |                |    help: consider specifying the actual array length: `2`
+   |                |
    |                expected due to this
+   |
+help: consider specifying the actual array length
+   |
+LL -     let wrong: [u8; 3] = [10, 20];
+LL +     let wrong: [u8; 2] = [10, 20];
+   |
 
 error[E0308]: mismatched types
   --> $DIR/array-len-mismatch.rs:9:26
    |
 LL |     let wrong: [u8; 3] = returns_arr();
    |                -------   ^^^^^^^^^^^^^ expected an array with a size of 3, found one with a size of 2
-   |                |    |
-   |                |    help: consider specifying the actual array length: `2`
+   |                |
    |                expected due to this
+   |
+help: consider specifying the actual array length
+   |
+LL -     let wrong: [u8; 3] = returns_arr();
+LL +     let wrong: [u8; 2] = returns_arr();
+   |
 
 error: aborting due to 2 previous errors
 

From bfca1f1187bdcf653f744e382a129889dc743204 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 20:43:57 +0000
Subject: [PATCH 0481/1059] fix clippy test

---
 src/tools/clippy/tests/ui/track-diagnostics.stderr | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/tools/clippy/tests/ui/track-diagnostics.stderr b/src/tools/clippy/tests/ui/track-diagnostics.stderr
index 45262ba618f2..438d3ac378e1 100644
--- a/src/tools/clippy/tests/ui/track-diagnostics.stderr
+++ b/src/tools/clippy/tests/ui/track-diagnostics.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> tests/ui/track-diagnostics.rs:LL:CC
    |
 LL | const S: A = B;
-   |              ^ expected `A`, found `B`
+   |          -   ^ expected `A`, found `B`
+   |          |
+   |          expected because of the type of the constant
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs:LL:CC
 

From e389568d920963504c49edc1cc277643471a0907 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 20:43:57 +0000
Subject: [PATCH 0482/1059] fix clippy test

---
 tests/ui/track-diagnostics.stderr | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/ui/track-diagnostics.stderr b/tests/ui/track-diagnostics.stderr
index 45262ba618f2..438d3ac378e1 100644
--- a/tests/ui/track-diagnostics.stderr
+++ b/tests/ui/track-diagnostics.stderr
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
   --> tests/ui/track-diagnostics.rs:LL:CC
    |
 LL | const S: A = B;
-   |              ^ expected `A`, found `B`
+   |          -   ^ expected `A`, found `B`
+   |          |
+   |          expected because of the type of the constant
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs:LL:CC
 

From 75511819a482f25f5cd221f68b60f80b866c0644 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 22:40:28 +0000
Subject: [PATCH 0483/1059] Turn label into structured suggestion for
 `.as_ref()` and `.as_mut()`

```
error[E0382]: use of moved value: `foo`
  --> $DIR/as-ref-2.rs:10:14
   |
LL |     let foo = Some(Struct);
   |         --- move occurs because `foo` has type `Option<Struct>`, which does not implement the `Copy` trait
LL |     let _x: Option<Struct> = foo.map(|s| bar(&s));
   |                                  ---------------- `foo` moved due to this method call
LL |     let _y = foo;
   |              ^^^ value used here after move
   |
note: `Option::<T>::map` takes ownership of the receiver `self`, which moves `foo`
  --> $SRC_DIR/core/src/option.rs:LL:COL
help: consider calling `.as_ref()` to borrow the value's contents
   |
LL |     let _x: Option<Struct> = foo.as_ref().map(|s| bar(&s));
   |                                 +++++++++
help: consider calling `.as_mut()` to mutably borrow the value's contents
   |
LL |     let _x: Option<Struct> = foo.as_mut().map(|s| bar(&s));
   |                                 +++++++++
```
---
 compiler/rustc_borrowck/src/diagnostics/mod.rs |  4 +++-
 .../rustc_borrowck/src/session_diagnostics.rs  | 13 ++++++++++++-
 .../suggest-as-ref-on-mut-closure.stderr       |  9 ++++++++-
 tests/ui/suggestions/as-ref-2.stderr           | 12 +++++++++---
 tests/ui/suggestions/option-content-move.fixed |  4 ++--
 .../ui/suggestions/option-content-move.stderr  | 18 ++++++++++++++++--
 6 files changed, 50 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index cb11d35c44b6..8b4bda8f7fef 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -1377,7 +1377,9 @@ fn explain_captures(
                         matches!(tcx.get_diagnostic_name(def_id), Some(sym::Option | sym::Result))
                     });
                     if is_option_or_result && maybe_reinitialized_locations_is_empty {
-                        err.subdiagnostic(CaptureReasonLabel::BorrowContent { var_span });
+                        err.subdiagnostic(CaptureReasonLabel::BorrowContent {
+                            var_span: var_span.shrink_to_hi(),
+                        });
                     }
                     if let Some((CallDesugaringKind::ForLoopIntoIter, _)) = desugaring {
                         let ty = moved_place.ty(self.body, tcx).ty;
diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs
index b2f33d64f0d9..cd4d1f16b21a 100644
--- a/compiler/rustc_borrowck/src/session_diagnostics.rs
+++ b/compiler/rustc_borrowck/src/session_diagnostics.rs
@@ -456,7 +456,18 @@ pub(crate) enum CaptureReasonLabel<'a> {
         is_move_msg: bool,
         is_loop_message: bool,
     },
-    #[label("help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents")]
+    #[suggestion(
+        "consider calling `.as_ref()` to borrow the value's contents",
+        applicability = "maybe-incorrect",
+        code = ".as_ref()",
+        style = "verbose"
+    )]
+    #[suggestion(
+        "consider calling `.as_mut()` to mutably borrow the value's contents",
+        applicability = "maybe-incorrect",
+        code = ".as_mut()",
+        style = "verbose"
+    )]
     BorrowContent {
         #[primary_span]
         var_span: Span,
diff --git a/tests/ui/borrowck/suggest-as-ref-on-mut-closure.stderr b/tests/ui/borrowck/suggest-as-ref-on-mut-closure.stderr
index 9b4061af967e..e2199fa90f26 100644
--- a/tests/ui/borrowck/suggest-as-ref-on-mut-closure.stderr
+++ b/tests/ui/borrowck/suggest-as-ref-on-mut-closure.stderr
@@ -4,11 +4,18 @@ error[E0507]: cannot move out of `*cb` which is behind a mutable reference
 LL |     cb.map(|cb| cb());
    |     ^^ -------------- `*cb` moved due to this method call
    |     |
-   |     help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents
    |     move occurs because `*cb` has type `Option<&mut dyn FnMut()>`, which does not implement the `Copy` trait
    |
 note: `Option::<T>::map` takes ownership of the receiver `self`, which moves `*cb`
   --> $SRC_DIR/core/src/option.rs:LL:COL
+help: consider calling `.as_ref()` to borrow the value's contents
+   |
+LL |     cb.as_ref().map(|cb| cb());
+   |       +++++++++
+help: consider calling `.as_mut()` to mutably borrow the value's contents
+   |
+LL |     cb.as_mut().map(|cb| cb());
+   |       +++++++++
 help: you could `clone` the value and consume it, if the `&mut dyn FnMut(): Clone` trait bound could be satisfied
    |
 LL |     <Option<&mut dyn FnMut()> as Clone>::clone(&cb).map(|cb| cb());
diff --git a/tests/ui/suggestions/as-ref-2.stderr b/tests/ui/suggestions/as-ref-2.stderr
index 309285775374..b183c8b2faee 100644
--- a/tests/ui/suggestions/as-ref-2.stderr
+++ b/tests/ui/suggestions/as-ref-2.stderr
@@ -4,14 +4,20 @@ error[E0382]: use of moved value: `foo`
 LL |     let foo = Some(Struct);
    |         --- move occurs because `foo` has type `Option<Struct>`, which does not implement the `Copy` trait
 LL |     let _x: Option<Struct> = foo.map(|s| bar(&s));
-   |                              --- ---------------- `foo` moved due to this method call
-   |                              |
-   |                              help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents
+   |                                  ---------------- `foo` moved due to this method call
 LL |     let _y = foo;
    |              ^^^ value used here after move
    |
 note: `Option::<T>::map` takes ownership of the receiver `self`, which moves `foo`
   --> $SRC_DIR/core/src/option.rs:LL:COL
+help: consider calling `.as_ref()` to borrow the value's contents
+   |
+LL |     let _x: Option<Struct> = foo.as_ref().map(|s| bar(&s));
+   |                                 +++++++++
+help: consider calling `.as_mut()` to mutably borrow the value's contents
+   |
+LL |     let _x: Option<Struct> = foo.as_mut().map(|s| bar(&s));
+   |                                 +++++++++
 help: you could `clone` the value and consume it, if the `Struct: Clone` trait bound could be satisfied
    |
 LL |     let _x: Option<Struct> = foo.clone().map(|s| bar(&s));
diff --git a/tests/ui/suggestions/option-content-move.fixed b/tests/ui/suggestions/option-content-move.fixed
index 4a5a9483c20c..0720146280f9 100644
--- a/tests/ui/suggestions/option-content-move.fixed
+++ b/tests/ui/suggestions/option-content-move.fixed
@@ -7,7 +7,7 @@ impl LipogramCorpora {
     pub fn validate_all(&mut self) -> Result<(), char> {
         for selection in &self.selections {
             if selection.1.is_some() {
-                if <Option<String> as Clone>::clone(&selection.1.clone()).unwrap().contains(selection.0) {
+                if <Option<String> as Clone>::clone(&selection.1.clone()).as_mut().as_ref().unwrap().contains(selection.0) {
                 //~^ ERROR cannot move out of `selection.1`
                     return Err(selection.0);
                 }
@@ -25,7 +25,7 @@ impl LipogramCorpora2 {
     pub fn validate_all(&mut self) -> Result<(), char> {
         for selection in &self.selections {
             if selection.1.is_ok() {
-                if <Result<String, String> as Clone>::clone(&selection.1.clone()).unwrap().contains(selection.0) {
+                if <Result<String, String> as Clone>::clone(&selection.1.clone()).as_mut().as_ref().unwrap().contains(selection.0) {
                 //~^ ERROR cannot move out of `selection.1`
                     return Err(selection.0);
                 }
diff --git a/tests/ui/suggestions/option-content-move.stderr b/tests/ui/suggestions/option-content-move.stderr
index a382a04344ae..09c6f39fd803 100644
--- a/tests/ui/suggestions/option-content-move.stderr
+++ b/tests/ui/suggestions/option-content-move.stderr
@@ -4,11 +4,18 @@ error[E0507]: cannot move out of `selection.1` which is behind a shared referenc
 LL |                 if selection.1.unwrap().contains(selection.0) {
    |                    ^^^^^^^^^^^ -------- `selection.1` moved due to this method call
    |                    |
-   |                    help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents
    |                    move occurs because `selection.1` has type `Option<String>`, which does not implement the `Copy` trait
    |
 note: `Option::<T>::unwrap` takes ownership of the receiver `self`, which moves `selection.1`
   --> $SRC_DIR/core/src/option.rs:LL:COL
+help: consider calling `.as_ref()` to borrow the value's contents
+   |
+LL |                 if selection.1.as_ref().unwrap().contains(selection.0) {
+   |                               +++++++++
+help: consider calling `.as_mut()` to mutably borrow the value's contents
+   |
+LL |                 if selection.1.as_mut().unwrap().contains(selection.0) {
+   |                               +++++++++
 help: you can `clone` the value and consume it, but this might not be your desired behavior
    |
 LL |                 if <Option<String> as Clone>::clone(&selection.1).unwrap().contains(selection.0) {
@@ -24,11 +31,18 @@ error[E0507]: cannot move out of `selection.1` which is behind a shared referenc
 LL |                 if selection.1.unwrap().contains(selection.0) {
    |                    ^^^^^^^^^^^ -------- `selection.1` moved due to this method call
    |                    |
-   |                    help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents
    |                    move occurs because `selection.1` has type `Result<String, String>`, which does not implement the `Copy` trait
    |
 note: `Result::<T, E>::unwrap` takes ownership of the receiver `self`, which moves `selection.1`
   --> $SRC_DIR/core/src/result.rs:LL:COL
+help: consider calling `.as_ref()` to borrow the value's contents
+   |
+LL |                 if selection.1.as_ref().unwrap().contains(selection.0) {
+   |                               +++++++++
+help: consider calling `.as_mut()` to mutably borrow the value's contents
+   |
+LL |                 if selection.1.as_mut().unwrap().contains(selection.0) {
+   |                               +++++++++
 help: you can `clone` the value and consume it, but this might not be your desired behavior
    |
 LL |                 if <Result<String, String> as Clone>::clone(&selection.1).unwrap().contains(selection.0) {

From 4eb9e661ec4bcaae73d084ea24add520c83a7c5e Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 16 Mar 2024 14:53:41 -0400
Subject: [PATCH 0484/1059] Extend ASCII fast paths of `char` methods beyond
 ASCII

---
 library/core/src/char/methods.rs | 33 ++++++++++++++++++++------------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index 87b328c91287..284a3eeb75df 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -777,8 +777,9 @@ pub const fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] {
     #[inline]
     pub fn is_alphabetic(self) -> bool {
         match self {
-            'a'..='z' | 'A'..='Z' => true,
-            c => c > '\x7f' && unicode::Alphabetic(c),
+            'A'..='Z' | 'a'..='z' => true,
+            '\0'..='\u{A9}' => false,
+            _ => unicode::Alphabetic(self),
         }
     }
 
@@ -819,7 +820,8 @@ pub fn is_alphabetic(self) -> bool {
     pub const fn is_lowercase(self) -> bool {
         match self {
             'a'..='z' => true,
-            c => c > '\x7f' && unicode::Lowercase(c),
+            '\0'..='\u{A9}' => false,
+            _ => unicode::Lowercase(self),
         }
     }
 
@@ -860,7 +862,8 @@ pub const fn is_lowercase(self) -> bool {
     pub const fn is_uppercase(self) -> bool {
         match self {
             'A'..='Z' => true,
-            c => c > '\x7f' && unicode::Uppercase(c),
+            '\0'..='\u{BF}' => false,
+            _ => unicode::Uppercase(self),
         }
     }
 
@@ -893,7 +896,8 @@ pub const fn is_uppercase(self) -> bool {
     pub const fn is_whitespace(self) -> bool {
         match self {
             ' ' | '\x09'..='\x0d' => true,
-            c => c > '\x7f' && unicode::White_Space(c),
+            '\0'..='\u{84}' => false,
+            _ => unicode::White_Space(self),
         }
     }
 
@@ -920,10 +924,10 @@ pub const fn is_whitespace(self) -> bool {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn is_alphanumeric(self) -> bool {
-        if self.is_ascii() {
-            self.is_ascii_alphanumeric()
-        } else {
-            unicode::Alphabetic(self) || unicode::N(self)
+        match self {
+            '0'..='9' | 'A'..='Z' | 'a'..='z' => true,
+            '\0'..='\u{A9}' => false,
+            _ => unicode::Alphabetic(self) || unicode::N(self),
         }
     }
 
@@ -969,7 +973,7 @@ pub fn is_control(self) -> bool {
     #[must_use]
     #[inline]
     pub(crate) fn is_grapheme_extended(self) -> bool {
-        !self.is_ascii() && unicode::Grapheme_Extend(self)
+        self > '\u{02FF}' && unicode::Grapheme_Extend(self)
     }
 
     /// Returns `true` if this `char` has the `Cased` property.
@@ -985,7 +989,11 @@ pub(crate) fn is_grapheme_extended(self) -> bool {
     #[doc(hidden)]
     #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
     pub fn is_cased(self) -> bool {
-        if self.is_ascii() { self.is_ascii_alphabetic() } else { unicode::Cased(self) }
+        match self {
+            'A'..='Z' | 'a'..='z' => true,
+            '\0'..='\u{A9}' => false,
+            _ => unicode::Cased(self),
+        }
     }
 
     /// Returns `true` if this `char` has the `Case_Ignorable` property.
@@ -1047,7 +1055,8 @@ pub fn is_case_ignorable(self) -> bool {
     pub fn is_numeric(self) -> bool {
         match self {
             '0'..='9' => true,
-            c => c > '\x7f' && unicode::N(c),
+            '\0'..='\u{B1}' => false,
+            _ => unicode::N(self),
         }
     }
 

From 249f52c1e0189479db18c61eff75b0b5926aa525 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 14 Mar 2026 23:24:23 +0000
Subject: [PATCH 0485/1059] Fix 32bit test

---
 .../invalid-patterns.32bit.stderr             | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
index df7c2a0a8629..9392a171510d 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
@@ -3,24 +3,48 @@ error[E0308]: mismatched types
    |
 LL |   get_flag::<false, 0xFF>();
    |                     ^^^^ expected `char`, found `u8`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:34
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:33:14
    |
 LL |   get_flag::<7, 'c'>();
    |              ^ expected `bool`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:13
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:35:14
    |
 LL |   get_flag::<42, 0x5ad>();
    |              ^^ expected `bool`, found integer
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:13
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:35:18
    |
 LL |   get_flag::<42, 0x5ad>();
    |                  ^^^^^ expected `char`, found `u8`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/invalid-patterns.rs:6:34
+   |
+LL | fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x1..0x4], and this operation requires initialized memory
   --> $DIR/invalid-patterns.rs:40:32

From 39631fdac191893a6eb4d000d5b258e92cae2304 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 15 Mar 2026 01:50:36 +0000
Subject: [PATCH 0486/1059] Point at unit structs on foreign crates in type
 errors when they are the pattern of a let binding

Consts and unit structs in patterns can be confusing if they are mistaken for new bindings. We already provide some context for unit structs and consts that come from the current crate, we now also point at those from foreign crates, and we properly skip cases where the pattern has type parameters which can't be confused with a new binding. Make new binding suggestion verbose.
---
 compiler/rustc_hir_typeck/src/pat.rs          | 122 +++++++--------
 tests/ui/blind/blind-item-block-middle.stderr |   6 +-
 .../const_in_pattern/arrays-and-slices.stderr |  24 ++-
 tests/ui/issues/issue-33504.stderr            |   7 +-
 tests/ui/issues/issue-5100.stderr             |   3 -
 tests/ui/match/issue-12552.stderr             |  14 +-
 .../match-const-tuple-type-mismatch.stderr    |   6 +-
 tests/ui/match/match-tag-nullary.stderr       |   3 -
 .../mismatched-types-in-match-7867.stderr     |   3 -
 .../private-unit-struct-assignment.stderr     |   3 -
 tests/ui/resolve/name-clash-nullary.stderr    |  10 ++
 .../const.stderr                              |   7 +-
 tests/ui/suggestions/field-access.stderr      |   9 --
 .../suggest-deref-in-match-issue-132784.rs    |   8 +
 ...suggest-deref-in-match-issue-132784.stderr | 140 +++++++++++++++---
 .../type/pattern_types/matching_fail.stderr   |   6 +-
 16 files changed, 260 insertions(+), 111 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 7b5f5f3f520e..314b50a12fc3 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -1636,69 +1636,75 @@ fn emit_bad_pat_path(
             span_bug!(pat_span, "unexpected resolution for path pattern: {resolved_pat:?}");
         };
 
-        if let Some(span) = self.tcx.hir_res_span(pat_res) {
+        let span = match (self.tcx.hir_res_span(pat_res), res.opt_def_id()) {
+            (Some(span), _) => span,
+            (None, Some(def_id)) => self.tcx.def_span(def_id),
+            (None, None) => {
+                e.emit();
+                return;
+            }
+        };
+        if let [hir::PathSegment { ident, args: None, .. }] = segments {
             e.span_label(span, format!("{} defined here", res.descr()));
-            if let [hir::PathSegment { ident, .. }] = segments {
-                e.span_label(
-                    pat_span,
-                    format!(
-                        "`{}` is interpreted as {} {}, not a new binding",
-                        ident,
-                        res.article(),
-                        res.descr(),
-                    ),
-                );
-                match self.tcx.parent_hir_node(hir_id) {
-                    hir::Node::PatField(..) => {
+            e.span_label(
+                pat_span,
+                format!(
+                    "`{}` is interpreted as {} {}, not a new binding",
+                    ident,
+                    res.article(),
+                    res.descr(),
+                ),
+            );
+            match self.tcx.parent_hir_node(hir_id) {
+                hir::Node::PatField(..) => {
+                    e.span_suggestion_verbose(
+                        ident.span.shrink_to_hi(),
+                        "bind the struct field to a different name instead",
+                        format!(": other_{}", ident.as_str().to_lowercase()),
+                        Applicability::HasPlaceholders,
+                    );
+                }
+                _ => {
+                    let (type_def_id, item_def_id) = match resolved_pat.ty.kind() {
+                        ty::Adt(def, _) => match res {
+                            Res::Def(DefKind::Const { .. }, def_id) => {
+                                (Some(def.did()), Some(def_id))
+                            }
+                            _ => (None, None),
+                        },
+                        _ => (None, None),
+                    };
+
+                    let is_range = matches!(
+                        type_def_id.and_then(|id| self.tcx.as_lang_item(id)),
+                        Some(
+                            LangItem::Range
+                                | LangItem::RangeFrom
+                                | LangItem::RangeTo
+                                | LangItem::RangeFull
+                                | LangItem::RangeInclusiveStruct
+                                | LangItem::RangeToInclusive,
+                        )
+                    );
+                    if is_range {
+                        if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
+                            let msg = "constants only support matching by type, \
+                                if you meant to match against a range of values, \
+                                consider using a range pattern like `min ..= max` in the match block";
+                            e.note(msg);
+                        }
+                    } else {
+                        let msg = "introduce a new binding instead";
+                        let sugg = format!("other_{}", ident.as_str().to_lowercase());
                         e.span_suggestion_verbose(
-                            ident.span.shrink_to_hi(),
-                            "bind the struct field to a different name instead",
-                            format!(": other_{}", ident.as_str().to_lowercase()),
+                            ident.span,
+                            msg,
+                            sugg,
                             Applicability::HasPlaceholders,
                         );
                     }
-                    _ => {
-                        let (type_def_id, item_def_id) = match resolved_pat.ty.kind() {
-                            ty::Adt(def, _) => match res {
-                                Res::Def(DefKind::Const { .. }, def_id) => {
-                                    (Some(def.did()), Some(def_id))
-                                }
-                                _ => (None, None),
-                            },
-                            _ => (None, None),
-                        };
-
-                        let is_range = matches!(
-                            type_def_id.and_then(|id| self.tcx.as_lang_item(id)),
-                            Some(
-                                LangItem::Range
-                                    | LangItem::RangeFrom
-                                    | LangItem::RangeTo
-                                    | LangItem::RangeFull
-                                    | LangItem::RangeInclusiveStruct
-                                    | LangItem::RangeToInclusive,
-                            )
-                        );
-                        if is_range {
-                            if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
-                                let msg = "constants only support matching by type, \
-                                    if you meant to match against a range of values, \
-                                    consider using a range pattern like `min ..= max` in the match block";
-                                e.note(msg);
-                            }
-                        } else {
-                            let msg = "introduce a new binding instead";
-                            let sugg = format!("other_{}", ident.as_str().to_lowercase());
-                            e.span_suggestion(
-                                ident.span,
-                                msg,
-                                sugg,
-                                Applicability::HasPlaceholders,
-                            );
-                        }
-                    }
-                };
-            }
+                }
+            };
         }
         e.emit();
     }
diff --git a/tests/ui/blind/blind-item-block-middle.stderr b/tests/ui/blind/blind-item-block-middle.stderr
index b2ae169013a6..5c05f31ab895 100644
--- a/tests/ui/blind/blind-item-block-middle.stderr
+++ b/tests/ui/blind/blind-item-block-middle.stderr
@@ -9,7 +9,11 @@ LL |     let bar = 5;
    |         |
    |         expected integer, found `bar`
    |         `bar` is interpreted as a unit struct, not a new binding
-   |         help: introduce a new binding instead: `other_bar`
+   |
+help: introduce a new binding instead
+   |
+LL |     let other_bar = 5;
+   |         ++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_in_pattern/arrays-and-slices.stderr b/tests/ui/consts/const_in_pattern/arrays-and-slices.stderr
index 412caf60f7d8..8aa86c8b05f5 100644
--- a/tests/ui/consts/const_in_pattern/arrays-and-slices.stderr
+++ b/tests/ui/consts/const_in_pattern/arrays-and-slices.stderr
@@ -11,10 +11,14 @@ LL |         BSTR_SIZED => {}
    |         |
    |         expected `&[u8]`, found `&[u8; 3]`
    |         `BSTR_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_bstr_sized`
    |
    = note: expected reference `&[u8]`
               found reference `&'static [u8; 3]`
+help: introduce a new binding instead
+   |
+LL -         BSTR_SIZED => {}
+LL +         other_bstr_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:23:9
@@ -29,10 +33,14 @@ LL |         STRUCT_SIZED => {}
    |         |
    |         expected `&SomeStruct<[u8]>`, found `&SomeStruct<[u8; 3]>`
    |         `STRUCT_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_struct_sized`
    |
    = note: expected reference `&SomeStruct<[u8]>`
               found reference `&'static SomeStruct<[u8; 3]>`
+help: introduce a new binding instead
+   |
+LL -         STRUCT_SIZED => {}
+LL +         other_struct_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:30:9
@@ -47,10 +55,14 @@ LL |         BSTR_SIZED => {}
    |         |
    |         expected `&[u8]`, found `&[u8; 3]`
    |         `BSTR_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_bstr_sized`
    |
    = note: expected reference `&[u8]`
               found reference `&'static [u8; 3]`
+help: introduce a new binding instead
+   |
+LL -         BSTR_SIZED => {}
+LL +         other_bstr_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:37:9
@@ -65,10 +77,14 @@ LL |         STRUCT_SIZED => {}
    |         |
    |         expected `&SomeStruct<[u8]>`, found `&SomeStruct<[u8; 3]>`
    |         `STRUCT_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_struct_sized`
    |
    = note: expected reference `&SomeStruct<[u8]>`
               found reference `&'static SomeStruct<[u8; 3]>`
+help: introduce a new binding instead
+   |
+LL -         STRUCT_SIZED => {}
+LL +         other_struct_sized => {}
+   |
 
 error: cannot use unsized non-slice type `SomeStruct<[u8]>` in constant patterns
   --> $DIR/arrays-and-slices.rs:47:9
diff --git a/tests/ui/issues/issue-33504.stderr b/tests/ui/issues/issue-33504.stderr
index f3e1ca08b6fc..e5a2eea751d0 100644
--- a/tests/ui/issues/issue-33504.stderr
+++ b/tests/ui/issues/issue-33504.stderr
@@ -9,7 +9,12 @@ LL |         let Test = 1;
    |             |
    |             expected integer, found `Test`
    |             `Test` is interpreted as a unit struct, not a new binding
-   |             help: introduce a new binding instead: `other_test`
+   |
+help: introduce a new binding instead
+   |
+LL -         let Test = 1;
+LL +         let other_test = 1;
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-5100.stderr b/tests/ui/issues/issue-5100.stderr
index 24d41a1a8afa..c545f70415c1 100644
--- a/tests/ui/issues/issue-5100.stderr
+++ b/tests/ui/issues/issue-5100.stderr
@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/issue-5100.rs:9:9
    |
-LL | enum A { B, C }
-   |          - unit variant defined here
-...
 LL |     match (true, false) {
    |           ------------- this expression has type `(bool, bool)`
 LL |         A::B => (),
diff --git a/tests/ui/match/issue-12552.stderr b/tests/ui/match/issue-12552.stderr
index 195192fbd824..397265cd540f 100644
--- a/tests/ui/match/issue-12552.stderr
+++ b/tests/ui/match/issue-12552.stderr
@@ -20,7 +20,14 @@ LL |   match t {
    |         - this expression has type `Result<_, {integer}>`
 ...
 LL |     None => ()
-   |     ^^^^ expected `Result<_, {integer}>`, found `Option<_>`
+   |     ^^^^
+   |     |
+   |     expected `Result<_, {integer}>`, found `Option<_>`
+   |     `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected enum `Result<_, {integer}>`
               found enum `Option<_>`
@@ -28,6 +35,11 @@ help: try wrapping the pattern in `Ok`
    |
 LL |     Ok(None) => ()
    |     +++    +
+help: introduce a new binding instead
+   |
+LL -     None => ()
+LL +     other_none => ()
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/match/match-const-tuple-type-mismatch.stderr b/tests/ui/match/match-const-tuple-type-mismatch.stderr
index e7dd97c4e9a6..06f65b257069 100644
--- a/tests/ui/match/match-const-tuple-type-mismatch.stderr
+++ b/tests/ui/match/match-const-tuple-type-mismatch.stderr
@@ -11,10 +11,14 @@ LL |         A => (),
    |         |
    |         expected integer, found `(isize, isize)`
    |         `A` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_a`
    |
    = note: expected type `{integer}`
              found tuple `(isize, isize)`
+help: introduce a new binding instead
+   |
+LL -         A => (),
+LL +         other_a => (),
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/match/match-tag-nullary.stderr b/tests/ui/match/match-tag-nullary.stderr
index c9446d164337..2822d715ab31 100644
--- a/tests/ui/match/match-tag-nullary.stderr
+++ b/tests/ui/match/match-tag-nullary.stderr
@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/match-tag-nullary.rs:4:40
    |
-LL | enum B { B }
-   |          - unit variant defined here
-LL |
 LL | fn main() { let x: A = A::A; match x { B::B => { } } }
    |                                    -   ^^^^ expected `A`, found `B`
    |                                    |
diff --git a/tests/ui/match/mismatched-types-in-match-7867.stderr b/tests/ui/match/mismatched-types-in-match-7867.stderr
index e41a61e42f4b..6f25175209dc 100644
--- a/tests/ui/match/mismatched-types-in-match-7867.stderr
+++ b/tests/ui/match/mismatched-types-in-match-7867.stderr
@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/mismatched-types-in-match-7867.rs:10:9
    |
-LL | enum A { B, C }
-   |          - unit variant defined here
-...
 LL |     match (true, false) {
    |           ------------- this expression has type `(bool, bool)`
 LL |         A::B => (),
diff --git a/tests/ui/privacy/private-unit-struct-assignment.stderr b/tests/ui/privacy/private-unit-struct-assignment.stderr
index 8c36a08846d8..110ee19d5ff4 100644
--- a/tests/ui/privacy/private-unit-struct-assignment.stderr
+++ b/tests/ui/privacy/private-unit-struct-assignment.stderr
@@ -13,9 +13,6 @@ LL |     struct C;
 error[E0308]: mismatched types
   --> $DIR/private-unit-struct-assignment.rs:8:5
    |
-LL |     struct C;
-   |     -------- unit struct defined here
-...
 LL |     A::C = 1;
    |     ^^^^   - this expression has type `{integer}`
    |     |
diff --git a/tests/ui/resolve/name-clash-nullary.stderr b/tests/ui/resolve/name-clash-nullary.stderr
index 08e7fe9a678a..1a3f434b6277 100644
--- a/tests/ui/resolve/name-clash-nullary.stderr
+++ b/tests/ui/resolve/name-clash-nullary.stderr
@@ -5,9 +5,19 @@ LL |   let None: isize = 42;
    |       ^^^^  ----- expected due to this
    |       |
    |       expected `isize`, found `Option<_>`
+   |       `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected type `isize`
               found enum `Option<_>`
+help: introduce a new binding instead
+   |
+LL -   let None: isize = 42;
+LL +   let other_none: isize = 42;
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
index 1c8e8d5b0a7d..12b89ba10bfd 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
@@ -11,7 +11,12 @@ LL |         FOO => {},
    |         |
    |         expected `&Foo`, found `Foo`
    |         `FOO` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_foo`
+   |
+help: introduce a new binding instead
+   |
+LL -         FOO => {},
+LL +         other_foo => {},
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/field-access.stderr b/tests/ui/suggestions/field-access.stderr
index 362dae172c78..36e126176ee9 100644
--- a/tests/ui/suggestions/field-access.stderr
+++ b/tests/ui/suggestions/field-access.stderr
@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/field-access.rs:20:12
    |
-LL |     Fst,
-   |     --- unit variant defined here
-...
 LL |     if let B::Fst = a {};
    |            ^^^^^^   - this expression has type `A`
    |            |
@@ -17,9 +14,6 @@ LL |     if let B::Fst = a.b {};
 error[E0308]: mismatched types
   --> $DIR/field-access.rs:25:9
    |
-LL |     Fst,
-   |     --- unit variant defined here
-...
 LL |     match a {
    |           - this expression has type `A`
 ...
@@ -34,9 +28,6 @@ LL |     match a.b {
 error[E0308]: mismatched types
   --> $DIR/field-access.rs:26:9
    |
-LL |     Snd,
-   |     --- unit variant defined here
-...
 LL |     match a {
    |           - this expression has type `A`
 ...
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
index 205e57f4a9ff..77074e8c3a3b 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
@@ -8,6 +8,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     match &x {
@@ -17,6 +18,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     let mut y = Box::new(Some(1));
@@ -27,6 +29,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     let mut z = Arc::new(Some(1));
@@ -37,6 +40,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     let z_const: &Arc<Option<i32>> = &z;
@@ -47,6 +51,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     // Normal reference because Arc doesn't implement DerefMut.
@@ -58,6 +63,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     // Mutable reference because Box does implement DerefMut.
@@ -69,6 +75,7 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 
     // Difficult expression.
@@ -80,5 +87,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
+        //~| HELP introduce a new binding instead
     }
 }
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
index 6092272aa8c5..a5ce44b25600 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
@@ -21,7 +21,14 @@ LL |     match x {
    |           - this expression has type `Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -29,9 +36,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match *x {
    |           +
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:16:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:17:9
    |
 LL |     match &x {
    |           -- this expression has type `&Arc<Option<{integer}>>`
@@ -47,13 +59,20 @@ LL |     match &*x {
    |            +
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:18:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:19:9
    |
 LL |     match &x {
    |           -- this expression has type `&Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -61,9 +80,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &*x {
    |            +
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:26:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:28:9
    |
 LL |     match y {
    |           - this expression has type `Box<Option<{integer}>>`
@@ -79,13 +103,20 @@ LL |     match *y {
    |           +
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:28:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:30:9
    |
 LL |     match y {
    |           - this expression has type `Box<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Box<Option<{integer}>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Box<Option<{integer}>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Box<Option<{integer}>>`
                 found enum `Option<_>`
@@ -93,9 +124,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match *y {
    |           +
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:36:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:39:9
    |
 LL |     match z as Arc<Option<i32>> {
    |           --------------------- this expression has type `Arc<Option<i32>>`
@@ -112,13 +148,20 @@ LL +     match *(z as Arc<Option<i32>>) {
    |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:38:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:41:9
    |
 LL |     match z as Arc<Option<i32>> {
    |           --------------------- this expression has type `Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<i32>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -127,9 +170,14 @@ help: consider dereferencing to access the inner value using the Deref trait
 LL -     match z as Arc<Option<i32>> {
 LL +     match *(z as Arc<Option<i32>>) {
    |
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:46:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:50:9
    |
 LL |     match z_const {
    |           ------- this expression has type `&Arc<Option<i32>>`
@@ -145,13 +193,20 @@ LL |     match &**z_const {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:48:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:52:9
    |
 LL |     match z_const {
    |           ------- this expression has type `&Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<i32>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -159,9 +214,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**z_const {
    |           +++
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:57:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:62:9
    |
 LL |     match z_mut {
    |           ----- this expression has type `&mut Arc<Option<i32>>`
@@ -177,13 +237,20 @@ LL |     match &**z_mut {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:59:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:64:9
    |
 LL |     match z_mut {
    |           ----- this expression has type `&mut Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<i32>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -191,9 +258,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**z_mut {
    |           +++
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:68:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:74:9
    |
 LL |     match y_mut {
    |           ----- this expression has type `&mut Box<Option<i32>>`
@@ -209,13 +281,20 @@ LL |     match &**y_mut {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:70:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:76:9
    |
 LL |     match y_mut {
    |           ----- this expression has type `&mut Box<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Box<Option<i32>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Box<Option<i32>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Box<Option<i32>>`
                 found enum `Option<_>`
@@ -223,9 +302,14 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**y_mut {
    |           +++
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:79:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:86:9
    |
 LL |     match (& (&difficult)  ) {
    |           ------------------ this expression has type `&&Arc<Option<{integer}>>`
@@ -242,13 +326,20 @@ LL +     match &*difficult {
    |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:81:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:88:9
    |
 LL |     match (& (&difficult)  ) {
    |           ------------------ this expression has type `&&Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         ^^^^
+   |         |
+   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
+   |         `None` is interpreted as a unit variant, not a new binding
+   |
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   |
+   = note: unit variant defined here
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -257,6 +348,11 @@ help: consider dereferencing to access the inner value using the Deref trait
 LL -     match (& (&difficult)  ) {
 LL +     match &*difficult {
    |
+help: introduce a new binding instead
+   |
+LL -         None => {}
+LL +         other_none => {}
+   |
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/type/pattern_types/matching_fail.stderr b/tests/ui/type/pattern_types/matching_fail.stderr
index 446180d80f24..495d73907878 100644
--- a/tests/ui/type/pattern_types/matching_fail.stderr
+++ b/tests/ui/type/pattern_types/matching_fail.stderr
@@ -33,10 +33,14 @@ LL |     THREE => {}
    |     |
    |     expected integer, found `(u32) is 1..`
    |     `THREE` is interpreted as a constant, not a new binding
-   |     help: introduce a new binding instead: `other_three`
    |
    = note:      expected type `{integer}`
            found pattern type `(u32) is 1..`
+help: introduce a new binding instead
+   |
+LL -     THREE => {}
+LL +     other_three => {}
+   |
 
 error: aborting due to 3 previous errors
 

From 1038ed1bbc4fac855578e2f4f8302ca6a48e3156 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 14 Mar 2026 16:36:41 +1100
Subject: [PATCH 0487/1059] Use less `#[macro_use]` in the query system

---
 compiler/rustc_macros/src/query.rs              |  3 +++
 compiler/rustc_middle/src/dep_graph/dep_node.rs |  2 +-
 compiler/rustc_middle/src/lib.rs                | 11 ++++-------
 compiler/rustc_middle/src/queries.rs            |  1 +
 compiler/rustc_middle/src/query/mod.rs          |  5 ++---
 compiler/rustc_middle/src/query/plumbing.rs     |  4 ++++
 6 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index a0c5b38d0136..bd6ccf29b1fe 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -510,6 +510,9 @@ macro_rules! rustc_with_all_queries {
                 }
             }
         }
+        // Re-export the macro as a normal item, so that other modules in `rustc_middle`
+        // can import it normally, without `#[macro_use]`.
+        pub(crate) use rustc_with_all_queries;
 
         // Add hints for rust-analyzer
         mod _analyzer_hints {
diff --git a/compiler/rustc_middle/src/dep_graph/dep_node.rs b/compiler/rustc_middle/src/dep_graph/dep_node.rs
index 6f85dba23dd4..49ad6bbf8577 100644
--- a/compiler/rustc_middle/src/dep_graph/dep_node.rs
+++ b/compiler/rustc_middle/src/dep_graph/dep_node.rs
@@ -331,7 +331,7 @@ pub mod label_strs {
 }
 
 // Create various data structures for each query, and also for a few things that aren't queries.
-rustc_with_all_queries! { define_dep_nodes! }
+crate::queries::rustc_with_all_queries! { define_dep_nodes! }
 
 // WARNING: `construct` is generic and does not know that `CompileCodegenUnit` takes `Symbol`s as keys.
 // Be very careful changing this type signature!
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 84fe59b3f711..c8702c42c47f 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -67,6 +67,8 @@
 
 #[macro_use]
 pub mod arena;
+
+pub mod dep_graph;
 pub mod error;
 pub mod hir;
 pub mod hooks;
@@ -76,18 +78,13 @@
 pub mod metadata;
 pub mod middle;
 pub mod mir;
+pub mod queries;
+pub mod query;
 pub mod thir;
 pub mod traits;
 pub mod ty;
 pub mod util;
 pub mod verify_ich;
 
-#[macro_use]
-pub mod query;
-#[macro_use]
-pub mod queries;
-#[macro_use]
-pub mod dep_graph;
-
 // Allows macros to refer to this crate as `::rustc_middle`
 extern crate self as rustc_middle;
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index ffe96c9db3da..4dd68db4f913 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -101,6 +101,7 @@
     CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions, NormalizationErrorInMono,
 };
 use crate::query::describe_as_module;
+use crate::query::plumbing::{define_callbacks, query_helper_param_ty};
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
     CanonicalMethodAutoderefStepsGoal, CanonicalPredicateGoal, CanonicalTypeOpAscribeUserTypeGoal,
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index b8fd88f2af17..e6b8a931071f 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -17,10 +17,9 @@
 pub(crate) mod inner;
 mod job;
 mod keys;
-pub mod on_disk_cache;
-#[macro_use]
-pub mod plumbing;
 pub(crate) mod modifiers;
+pub mod on_disk_cache;
+pub mod plumbing;
 mod stack;
 
 pub fn describe_as_module(def_id: impl Into<LocalDefId>, tcx: TyCtxt<'_>) -> String {
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 128350a89ecf..90491bc402fb 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -630,6 +630,10 @@ fn clone(&self) -> Self { *self }
     };
 }
 
+// Re-export `macro_rules!` macros as normal items, so that they can be imported normally.
+pub(crate) use define_callbacks;
+pub(crate) use query_helper_param_ty;
+
 mod sealed {
     use rustc_hir::def_id::{LocalModDefId, ModDefId};
 

From 77eea39d459ef5a7dd91584f8560984e3b8dd960 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Sat, 14 Mar 2026 18:58:58 -0700
Subject: [PATCH 0488/1059] rustdoc: error out on `--test` with `--emit`

These options don't behave reasonably when combined right now, and there
are no tests and no docs for how they should.

For the short term, make this a fatal error. If we decide to assign this
some semantics, then we can do that at any time.
---
 src/librustdoc/config.rs                  | 6 +++++-
 tests/rustdoc-ui/doctest/emit-test.rs     | 5 +++++
 tests/rustdoc-ui/doctest/emit-test.stderr | 2 ++
 3 files changed, 12 insertions(+), 1 deletion(-)
 create mode 100644 tests/rustdoc-ui/doctest/emit-test.rs
 create mode 100644 tests/rustdoc-ui/doctest/emit-test.stderr

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index f1fdce48181c..d721034c2d71 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -462,8 +462,13 @@ fn println_condition(condition: Condition) {
             return None;
         }
 
+        let should_test = matches.opt_present("test");
+
         let mut emit = FxIndexMap::<_, EmitType>::default();
         for list in matches.opt_strs("emit") {
+            if should_test {
+                dcx.fatal("the `--test` flag and the `--emit` flag are not supported together");
+            }
             for kind in list.split(',') {
                 match kind.parse() {
                     Ok(kind) => {
@@ -634,7 +639,6 @@ fn println_condition(condition: Condition) {
         let test_args: Vec<String> =
             test_args.iter().flat_map(|s| s.split_whitespace()).map(|s| s.to_string()).collect();
 
-        let should_test = matches.opt_present("test");
         let no_run = matches.opt_present("no-run");
 
         if !should_test && no_run {
diff --git a/tests/rustdoc-ui/doctest/emit-test.rs b/tests/rustdoc-ui/doctest/emit-test.rs
new file mode 100644
index 000000000000..4e40bde4648b
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/emit-test.rs
@@ -0,0 +1,5 @@
+//@ compile-flags:--test --emit=dep-info -Z unstable-options
+//@ check-fail
+//~? ERROR the `--test` flag and the `--emit` flag
+
+//! This example intentionally left blank.
diff --git a/tests/rustdoc-ui/doctest/emit-test.stderr b/tests/rustdoc-ui/doctest/emit-test.stderr
new file mode 100644
index 000000000000..2b1ebae5b139
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/emit-test.stderr
@@ -0,0 +1,2 @@
+error: the `--test` flag and the `--emit` flag are not supported together
+

From c5c1d94e6ca8c695cd92d5f39c1c23d3d8338790 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 14 Mar 2026 22:09:13 -0400
Subject: [PATCH 0489/1059] Add `From` impls for wrapper types

- `From<T> for ThinBox<T>`
- `From<T> for UniqueRc<T>`
- `From<T> for UniqueArc<T>`
- `From<T: UnwindSafe> for AssertUnwindSafe<T>`
- `From<T> for LazyCell<T, F>`
- `From<T> for LazyLock<T, F>`
---
 library/alloc/src/boxed/thin.rs             |  9 +++++++++
 library/alloc/src/rc.rs                     |  9 +++++++++
 library/alloc/src/sync.rs                   |  9 +++++++++
 library/core/src/cell/lazy.rs               | 10 ++++++++++
 library/core/src/panic/unwind_safe.rs       | 13 ++++++++++++
 library/std/src/backtrace/tests.rs          | 14 ++++++-------
 library/std/src/sync/lazy_lock.rs           | 22 ++++++++++++---------
 library/std/src/sync/once.rs                |  7 +++++++
 library/std/src/sys/sync/once/futex.rs      |  5 +++++
 library/std/src/sys/sync/once/no_threads.rs |  5 +++++
 library/std/src/sys/sync/once/queue.rs      |  5 +++++
 11 files changed, 91 insertions(+), 17 deletions(-)

diff --git a/library/alloc/src/boxed/thin.rs b/library/alloc/src/boxed/thin.rs
index b50810b8d923..2a34537f58e3 100644
--- a/library/alloc/src/boxed/thin.rs
+++ b/library/alloc/src/boxed/thin.rs
@@ -430,3 +430,12 @@ fn source(&self) -> Option<&(dyn Error + 'static)> {
         self.deref().source()
     }
 }
+
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "thin_box", issue = "92791")]
+impl<T> From<T> for ThinBox<T> {
+    #[inline(always)]
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index cec41524325e..8a651618ca83 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -3980,6 +3980,15 @@ fn as_mut(&mut self) -> &mut T {
 #[unstable(feature = "unique_rc_arc", issue = "112566")]
 impl<T: ?Sized, A: Allocator> Unpin for UniqueRc<T, A> {}
 
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "unique_rc_arc", issue = "112566")]
+impl<T> From<T> for UniqueRc<T> {
+    #[inline(always)]
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
+
 #[unstable(feature = "unique_rc_arc", issue = "112566")]
 impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for UniqueRc<T, A> {
     /// Equality for two `UniqueRc`s.
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index dc82357dd146..2c9fadbb8d9e 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -4424,6 +4424,15 @@ fn as_mut(&mut self) -> &mut T {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "unique_rc_arc", issue = "112566")]
+impl<T> From<T> for UniqueArc<T> {
+    #[inline(always)]
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
+
 #[unstable(feature = "unique_rc_arc", issue = "112566")]
 impl<T: ?Sized, A: Allocator> Unpin for UniqueArc<T, A> {}
 
diff --git a/library/core/src/cell/lazy.rs b/library/core/src/cell/lazy.rs
index 28a76569c1d0..ae559e599f48 100644
--- a/library/core/src/cell/lazy.rs
+++ b/library/core/src/cell/lazy.rs
@@ -366,6 +366,16 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
+#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+impl<T, F> From<T> for LazyCell<T, F> {
+    /// Constructs a `LazyCell` that starts already initialized
+    /// with the provided value.
+    #[inline]
+    fn from(value: T) -> Self {
+        Self { state: UnsafeCell::new(State::Init(value)) }
+    }
+}
+
 #[cold]
 #[inline(never)]
 const fn panic_poisoned() -> ! {
diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs
index 21dbd09f4960..ca2a4333eda5 100644
--- a/library/core/src/panic/unwind_safe.rs
+++ b/library/core/src/panic/unwind_safe.rs
@@ -313,3 +313,16 @@ fn size_hint(&self) -> (usize, Option<usize>) {
         self.0.size_hint()
     }
 }
+
+/// If a value's type is already `UnwindSafe`,
+/// wrapping it in `AssertUnwindSafe` is never incorrect.
+#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+impl<T> From<T> for AssertUnwindSafe<T>
+where
+    T: UnwindSafe,
+{
+    #[inline(always)]
+    fn from(value: T) -> Self {
+        Self(value)
+    }
+}
diff --git a/library/std/src/backtrace/tests.rs b/library/std/src/backtrace/tests.rs
index 174d62813bd5..b68b528c1866 100644
--- a/library/std/src/backtrace/tests.rs
+++ b/library/std/src/backtrace/tests.rs
@@ -44,10 +44,9 @@ fn generate_fake_frames() -> Vec<BacktraceFrame> {
 #[test]
 fn test_debug() {
     let backtrace = Backtrace {
-        inner: Inner::Captured(LazyLock::preinit(Capture {
-            actual_start: 1,
-            frames: generate_fake_frames(),
-        })),
+        inner: Inner::Captured(
+            (Capture { actual_start: 1, frames: generate_fake_frames() }).into(),
+        ),
     };
 
     #[rustfmt::skip]
@@ -66,10 +65,9 @@ fn test_debug() {
 #[test]
 fn test_frames() {
     let backtrace = Backtrace {
-        inner: Inner::Captured(LazyLock::preinit(Capture {
-            actual_start: 1,
-            frames: generate_fake_frames(),
-        })),
+        inner: Inner::Captured(
+            (Capture { actual_start: 1, frames: generate_fake_frames() }).into(),
+        ),
     };
 
     let frames = backtrace.frames();
diff --git a/library/std/src/sync/lazy_lock.rs b/library/std/src/sync/lazy_lock.rs
index 7274b5d10c75..9bdde0ae4a53 100644
--- a/library/std/src/sync/lazy_lock.rs
+++ b/library/std/src/sync/lazy_lock.rs
@@ -105,15 +105,6 @@ pub const fn new(f: F) -> LazyLock<T, F> {
         LazyLock { once: Once::new(), data: UnsafeCell::new(Data { f: ManuallyDrop::new(f) }) }
     }
 
-    /// Creates a new lazy value that is already initialized.
-    #[inline]
-    #[cfg(test)]
-    pub(crate) fn preinit(value: T) -> LazyLock<T, F> {
-        let once = Once::new();
-        once.call_once(|| {});
-        LazyLock { once, data: UnsafeCell::new(Data { value: ManuallyDrop::new(value) }) }
-    }
-
     /// Consumes this `LazyLock` returning the stored value.
     ///
     /// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise.
@@ -404,6 +395,19 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
+#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+impl<T, F> From<T> for LazyLock<T, F> {
+    /// Constructs a `LazyLock` that starts already initialized
+    /// with the provided value.
+    #[inline]
+    fn from(value: T) -> Self {
+        LazyLock {
+            once: Once::new_complete(),
+            data: UnsafeCell::new(Data { value: ManuallyDrop::new(value) }),
+        }
+    }
+}
+
 #[cold]
 #[inline(never)]
 fn panic_poisoned() -> ! {
diff --git a/library/std/src/sync/once.rs b/library/std/src/sync/once.rs
index bcfc9f581fd2..2556d1897b64 100644
--- a/library/std/src/sync/once.rs
+++ b/library/std/src/sync/once.rs
@@ -84,6 +84,13 @@ pub const fn new() -> Once {
         Once { inner: sys::Once::new() }
     }
 
+    /// Creates a new `Once` value that starts already completed.
+    #[inline]
+    #[must_use]
+    pub(crate) const fn new_complete() -> Once {
+        Once { inner: sys::Once::new_complete() }
+    }
+
     /// Performs an initialization routine once and only once. The given closure
     /// will be executed if this is the first time `call_once` has been called,
     /// and otherwise the routine will *not* be invoked.
diff --git a/library/std/src/sys/sync/once/futex.rs b/library/std/src/sys/sync/once/futex.rs
index 096f1d879ef2..236bc9ca4b7c 100644
--- a/library/std/src/sys/sync/once/futex.rs
+++ b/library/std/src/sys/sync/once/futex.rs
@@ -75,6 +75,11 @@ pub const fn new() -> Once {
         Once { state_and_queued: Futex::new(INCOMPLETE) }
     }
 
+    #[inline]
+    pub const fn new_complete() -> Once {
+        Once { state_and_queued: Futex::new(COMPLETE) }
+    }
+
     #[inline]
     pub fn is_completed(&self) -> bool {
         // Use acquire ordering to make all initialization changes visible to the
diff --git a/library/std/src/sys/sync/once/no_threads.rs b/library/std/src/sys/sync/once/no_threads.rs
index 576bbf644cbe..42fe2417307a 100644
--- a/library/std/src/sys/sync/once/no_threads.rs
+++ b/library/std/src/sys/sync/once/no_threads.rs
@@ -39,6 +39,11 @@ pub const fn new() -> Once {
         Once { state: Cell::new(State::Incomplete) }
     }
 
+    #[inline]
+    pub const fn new_complete() -> Once {
+        Once { state: Cell::new(State::Complete) }
+    }
+
     #[inline]
     pub fn is_completed(&self) -> bool {
         self.state.get() == State::Complete
diff --git a/library/std/src/sys/sync/once/queue.rs b/library/std/src/sys/sync/once/queue.rs
index d7219a7361cf..f64f6523d143 100644
--- a/library/std/src/sys/sync/once/queue.rs
+++ b/library/std/src/sys/sync/once/queue.rs
@@ -121,6 +121,11 @@ pub const fn new() -> Once {
         Once { state_and_queue: AtomicPtr::new(ptr::without_provenance_mut(INCOMPLETE)) }
     }
 
+    #[inline]
+    pub const fn new_complete() -> Once {
+        Once { state_and_queue: AtomicPtr::new(ptr::without_provenance_mut(COMPLETE)) }
+    }
+
     #[inline]
     pub fn is_completed(&self) -> bool {
         // An `Acquire` load is enough because that makes all the initialization

From 8e22bcd7a72c2a867552abf8beccc0468718b3d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 15 Mar 2026 02:17:11 +0000
Subject: [PATCH 0490/1059] [tiny] Tweak "use of `Deref`" suggestion message

Surround trait name with backticks.
---
 .../src/error_reporting/infer/mod.rs          |  2 +-
 .../2229_closure_analysis/issue-118144.stderr |  2 +-
 .../let-else/let-else-deref-coercion.stderr   |  4 +--
 ...ats-do-not-mislead-inference.stable.stderr |  4 +--
 .../pattern/deref-patterns/needs-gate.stderr  |  2 +-
 ...n-matching-mix-deref-pattern.normal.stderr | 32 +++++++++----------
 .../pattern-matching.normal.stderr            | 16 +++++-----
 .../suggest-deref-in-match-issue-132784.rs    | 32 +++++++++----------
 ...suggest-deref-in-match-issue-132784.stderr | 32 +++++++++----------
 9 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index 22342a956710..d9ea2e005789 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -392,7 +392,7 @@ fn note_error_origin(
                     {
                         err.span_suggestion_verbose(
                             span,
-                            "consider dereferencing to access the inner value using the Deref trait",
+                            "consider dereferencing to access the inner value using the `Deref` trait",
                             format!("{prefix}{peeled_snippet}"),
                             Applicability::MaybeIncorrect,
                         );
diff --git a/tests/ui/closures/2229_closure_analysis/issue-118144.stderr b/tests/ui/closures/2229_closure_analysis/issue-118144.stderr
index bfe4afc4b58c..dd17a305881e 100644
--- a/tests/ui/closures/2229_closure_analysis/issue-118144.stderr
+++ b/tests/ui/closures/2229_closure_analysis/issue-118144.stderr
@@ -6,7 +6,7 @@ LL |         V(x) = func_arg;
    |         |
    |         expected `&mut V`, found `V`
    |
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |         V(x) = &*func_arg;
    |                ++
diff --git a/tests/ui/let-else/let-else-deref-coercion.stderr b/tests/ui/let-else/let-else-deref-coercion.stderr
index 543737868c9f..ed4e32cbd659 100644
--- a/tests/ui/let-else/let-else-deref-coercion.stderr
+++ b/tests/ui/let-else/let-else-deref-coercion.stderr
@@ -6,7 +6,7 @@ LL |         let Bar::Present(z) = self else {
    |             |
    |             expected `Foo`, found `Bar`
    |
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |         let Bar::Present(z) = &**self else {
    |                               +++
@@ -19,7 +19,7 @@ LL |         let Bar(z) = x;
    |             |
    |             expected `Foo`, found `Bar`
    |
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |         let Bar(z) = &**x;
    |                      +++
diff --git a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
index 0770569e0406..74f558af4e95 100644
--- a/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
+++ b/tests/ui/pattern/deref-patterns/const-pats-do-not-mislead-inference.stable.stderr
@@ -19,7 +19,7 @@ LL |     if let "..." = &Box::new(x) {}
    |
    = note: expected reference `&Box<_>`
               found reference `&'static str`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     if let "..." = &*Box::new(x) {}
    |                     +
@@ -34,7 +34,7 @@ LL |     if let b"..." = Box::new(&x) {}
    |
    = note: expected struct `Box<&_>`
            found reference `&'static [u8; 3]`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     if let b"..." = *Box::new(&x) {}
    |                     +
diff --git a/tests/ui/pattern/deref-patterns/needs-gate.stderr b/tests/ui/pattern/deref-patterns/needs-gate.stderr
index 3d938a7e23fc..edc70048ecf2 100644
--- a/tests/ui/pattern/deref-patterns/needs-gate.stderr
+++ b/tests/ui/pattern/deref-patterns/needs-gate.stderr
@@ -18,7 +18,7 @@ LL |         0 => {}
    |
    = note: expected struct `Box<{integer}>`
                 found type `{integer}`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *Box::new(0) {
    |           +
diff --git a/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr
index 0e55a5170284..e35e22d0ec24 100644
--- a/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr
+++ b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr
@@ -8,7 +8,7 @@ LL |     let Foo { x, y } = foo.as_mut();
    |
    = note: expected struct `Pin<&mut Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Foo { x, y } = *foo.as_mut();
    |                        +
@@ -23,7 +23,7 @@ LL |         Foo { x, y } => {}
    |
    = note: expected struct `Pin<&mut Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *foo.as_mut() {
    |           +
@@ -38,7 +38,7 @@ LL |         Foo { x, y } => {}
    |
    = note: expected struct `Pin<&mut Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let _ = || match *foo.as_mut() {
    |                      +
@@ -53,7 +53,7 @@ LL |     let Foo { x, y } = foo;
    |
    = note: expected struct `Pin<&Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Foo { x, y } = *foo;
    |                        +
@@ -68,7 +68,7 @@ LL |         Foo { x, y } => {}
    |
    = note: expected struct `Pin<&Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *foo {
    |           +
@@ -83,7 +83,7 @@ LL |         Foo { x, y } => {}
    |
    = note: expected struct `Pin<&Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let _ = || match *foo {
    |                      +
@@ -98,7 +98,7 @@ LL |     let Bar(x, y) = bar.as_mut();
    |
    = note: expected struct `Pin<&mut Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Bar(x, y) = *bar.as_mut();
    |                     +
@@ -113,7 +113,7 @@ LL |         Bar(x, y) => {}
    |
    = note: expected struct `Pin<&mut Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *bar.as_mut() {
    |           +
@@ -128,7 +128,7 @@ LL |         Bar(x, y) => {}
    |
    = note: expected struct `Pin<&mut Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let _ = || match *bar.as_mut() {
    |                      +
@@ -143,7 +143,7 @@ LL |     let Bar(x, y) = bar;
    |
    = note: expected struct `Pin<&Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Bar(x, y) = *bar;
    |                     +
@@ -158,7 +158,7 @@ LL |         Bar(x, y) => {}
    |
    = note: expected struct `Pin<&Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *bar {
    |           +
@@ -173,7 +173,7 @@ LL |         Bar(x, y) => {}
    |
    = note: expected struct `Pin<&Bar<T, U>>`
               found struct `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let _ = || match *bar {
    |                      +
@@ -188,7 +188,7 @@ LL |     let NonPinProject { x } = foo;
    |
    = note: expected struct `Pin<&mut NonPinProject<T>>`
               found struct `NonPinProject<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let NonPinProject { x } = *foo;
    |                               +
@@ -203,7 +203,7 @@ LL |     let NonPinProject { x } = bar;
    |
    = note: expected struct `Pin<&NonPinProject<U>>`
               found struct `NonPinProject<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let NonPinProject { x } = *bar;
    |                               +
@@ -218,7 +218,7 @@ LL |         NonPinProject { x } => {}
    |
    = note: expected struct `Pin<&mut NonPinProject<T>>`
               found struct `NonPinProject<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *foo {
    |           +
@@ -233,7 +233,7 @@ LL |         NonPinProject { x } => {}
    |
    = note: expected struct `Pin<&NonPinProject<U>>`
               found struct `NonPinProject<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *bar {
    |           +
diff --git a/tests/ui/pin-ergonomics/pattern-matching.normal.stderr b/tests/ui/pin-ergonomics/pattern-matching.normal.stderr
index 8ec481fba9e0..409013c34024 100644
--- a/tests/ui/pin-ergonomics/pattern-matching.normal.stderr
+++ b/tests/ui/pin-ergonomics/pattern-matching.normal.stderr
@@ -28,7 +28,7 @@ LL |     let Foo { x, y } = foo_mut;
    |
    = note: expected struct `Pin<&mut Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Foo { x, y } = *foo_mut;
    |                        +
@@ -43,7 +43,7 @@ LL |     let Foo { x, y } = foo_const;
    |
    = note: expected struct `Pin<&Foo<T, U>>`
               found struct `Foo<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let Foo { x, y } = *foo_const;
    |                        +
@@ -58,7 +58,7 @@ LL |         Bar::Foo(x, y) => {
    |
    = note: expected struct `Pin<&mut Bar<T, U>>`
                 found enum `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *bar_mut {
    |           +
@@ -73,7 +73,7 @@ LL |         _ if let Bar::Bar { x, y } = bar_mut => {
    |
    = note: expected struct `Pin<&mut Bar<T, U>>`
                 found enum `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |         _ if let Bar::Bar { x, y } = *bar_mut => {
    |                                      +
@@ -88,7 +88,7 @@ LL |         Bar::Bar { x, y } => {
    |
    = note: expected struct `Pin<&Bar<T, U>>`
                 found enum `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *bar_const {
    |           +
@@ -103,7 +103,7 @@ LL |         _ if let Bar::Foo(x, y) = bar_const => {
    |
    = note: expected struct `Pin<&Bar<T, U>>`
                 found enum `Bar<_, _>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |         _ if let Bar::Foo(x, y) = *bar_const => {
    |                                   +
@@ -118,7 +118,7 @@ LL |     let (Foo { x, y },) = foo_mut;
    |
    = note: expected struct `Pin<&mut (Foo<T, U>,)>`
                found tuple `(_,)`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let (Foo { x, y },) = *foo_mut;
    |                           +
@@ -133,7 +133,7 @@ LL |     let (Foo { x, y },) = foo_const;
    |
    = note: expected struct `Pin<&(Foo<T, U>,)>`
                found tuple `(_,)`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     let (Foo { x, y },) = *foo_const;
    |                           +
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
index 205e57f4a9ff..7b9b3cf19850 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
@@ -2,8 +2,8 @@
 fn main() {
     let mut x = Arc::new(Some(1));
     match x {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -11,8 +11,8 @@ fn main() {
     }
 
     match &x {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -21,8 +21,8 @@ fn main() {
 
     let mut y = Box::new(Some(1));
     match y {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -31,8 +31,8 @@ fn main() {
 
     let mut z = Arc::new(Some(1));
     match z as Arc<Option<i32>> {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -41,8 +41,8 @@ fn main() {
 
     let z_const: &Arc<Option<i32>> = &z;
     match z_const {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -52,8 +52,8 @@ fn main() {
     // Normal reference because Arc doesn't implement DerefMut.
     let z_mut: &mut Arc<Option<i32>> = &mut z;
     match z_mut {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -63,8 +63,8 @@ fn main() {
     // Mutable reference because Box does implement DerefMut.
     let y_mut: &mut Box<Option<i32>> = &mut y;
     match y_mut {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
@@ -74,8 +74,8 @@ fn main() {
     // Difficult expression.
     let difficult = Arc::new(Some(1));
     match (& (&difficult)  ) {
-        //~^ HELP consider dereferencing to access the inner value using the Deref trait
-        //~| HELP consider dereferencing to access the inner value using the Deref trait
+        //~^ HELP consider dereferencing to access the inner value using the `Deref` trait
+        //~| HELP consider dereferencing to access the inner value using the `Deref` trait
         Some(_) => {}
         //~^ ERROR mismatched types
         None => {}
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
index 6092272aa8c5..e0a7e2c8cedf 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
@@ -9,7 +9,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *x {
    |           +
@@ -25,7 +25,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *x {
    |           +
@@ -41,7 +41,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &*x {
    |            +
@@ -57,7 +57,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &*x {
    |            +
@@ -73,7 +73,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Box<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *y {
    |           +
@@ -89,7 +89,7 @@ LL |         None => {}
    |
    = note: expected struct `Box<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match *y {
    |           +
@@ -105,7 +105,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL -     match z as Arc<Option<i32>> {
 LL +     match *(z as Arc<Option<i32>>) {
@@ -122,7 +122,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL -     match z as Arc<Option<i32>> {
 LL +     match *(z as Arc<Option<i32>>) {
@@ -139,7 +139,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**z_const {
    |           +++
@@ -155,7 +155,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**z_const {
    |           +++
@@ -171,7 +171,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**z_mut {
    |           +++
@@ -187,7 +187,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**z_mut {
    |           +++
@@ -203,7 +203,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Box<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**y_mut {
    |           +++
@@ -219,7 +219,7 @@ LL |         None => {}
    |
    = note: expected struct `Box<Option<i32>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL |     match &**y_mut {
    |           +++
@@ -235,7 +235,7 @@ LL |         Some(_) => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL -     match (& (&difficult)  ) {
 LL +     match &*difficult {
@@ -252,7 +252,7 @@ LL |         None => {}
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
-help: consider dereferencing to access the inner value using the Deref trait
+help: consider dereferencing to access the inner value using the `Deref` trait
    |
 LL -     match (& (&difficult)  ) {
 LL +     match &*difficult {

From e8ebfcaa2eaa1a5ee63328181c7b587cec2fcf78 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 15 Mar 2026 13:17:09 +1100
Subject: [PATCH 0491/1059] Declare `rustc_with_all_queries!` as macros-2.0

Unlike `macro_rules!`, macros-2.0 macros have sensible item-like namespacing
and visibility by default, which avoids the need for `#[macro_export]` and
makes it easier to import the macro.

The tradeoff is having to use `#[rustc_macro_transparency = "semiopaque"]` to
still get macro-rules hygiene, because macros-2.0 hygiene is too strict here.
---
 compiler/rustc_macros/src/query.rs                | 7 ++-----
 compiler/rustc_query_impl/src/dep_kind_vtables.rs | 2 +-
 compiler/rustc_query_impl/src/query_impl.rs       | 2 +-
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index bd6ccf29b1fe..a803d86f2771 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -498,8 +498,8 @@ fn #name(#key_ty) #return_ty
         /// Higher-order macro that invokes the specified macro with (a) a list of all query
         /// signatures (including modifiers), and (b) a list of non-query names. This allows
         /// multiple simpler macros to each have access to these lists.
-        #[macro_export]
-        macro_rules! rustc_with_all_queries {
+        #[rustc_macro_transparency = "semiopaque"] // Use `macro_rules!` hygiene.
+        pub macro rustc_with_all_queries {
             (
                 // The macro to invoke once, on all queries and non-queries.
                 $macro:ident!
@@ -510,9 +510,6 @@ macro_rules! rustc_with_all_queries {
                 }
             }
         }
-        // Re-export the macro as a normal item, so that other modules in `rustc_middle`
-        // can import it normally, without `#[macro_use]`.
-        pub(crate) use rustc_with_all_queries;
 
         // Add hints for rust-analyzer
         mod _analyzer_hints {
diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 34ef70f141b9..597c8b2a9e74 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -179,7 +179,7 @@ fn $name:ident($K:ty) -> $V:ty
 // Create an array of vtables, one for each dep kind (non-query and query).
 pub fn make_dep_kind_vtables<'tcx>(arena: &'tcx Arena<'tcx>) -> &'tcx [DepKindVTable<'tcx>] {
     let (nq_vtables, q_vtables) =
-        rustc_middle::rustc_with_all_queries! { define_dep_kind_vtables! };
+        rustc_middle::queries::rustc_with_all_queries! { define_dep_kind_vtables! };
 
     // Non-query vtables must come before query vtables, to match the order of `DepKind`.
     arena.alloc_from_iter(nq_vtables.into_iter().chain(q_vtables.into_iter()))
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index d5fb90871e76..23f678e1c9f7 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -272,4 +272,4 @@ macro_rules! for_each_query_vtable {
     }
 }
 
-rustc_middle::rustc_with_all_queries! { define_queries! }
+rustc_middle::queries::rustc_with_all_queries! { define_queries! }

From 408066f31094c0284d5c4684e9839ae3594100df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 15 Mar 2026 03:51:25 +0000
Subject: [PATCH 0492/1059] Do not suggest introducing new binding when other
 suggestions are present

---
 compiler/rustc_errors/src/lib.rs              |   8 +
 compiler/rustc_hir_typeck/src/pat.rs          |   4 +-
 .../compatible-variants-in-pat.rs             |   2 -
 .../compatible-variants-in-pat.stderr         |  28 +---
 tests/ui/match/issue-12552.stderr             |  14 +-
 .../suggest-deref-in-match-issue-132784.rs    |   8 -
 ...suggest-deref-in-match-issue-132784.stderr | 140 +++---------------
 7 files changed, 37 insertions(+), 167 deletions(-)

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 9b3dba15f55e..8c57544c54b8 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -138,6 +138,14 @@ pub fn unwrap_tag(self) -> Vec<CodeSuggestion> {
             Suggestions::Disabled => Vec::new(),
         }
     }
+
+    pub fn len(&self) -> usize {
+        match self {
+            Suggestions::Enabled(suggestions) => suggestions.len(),
+            Suggestions::Sealed(suggestions) => suggestions.len(),
+            Suggestions::Disabled => 0,
+        }
+    }
 }
 
 impl Default for Suggestions {
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 314b50a12fc3..26f7d1ccffc9 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -1644,7 +1644,9 @@ fn emit_bad_pat_path(
                 return;
             }
         };
-        if let [hir::PathSegment { ident, args: None, .. }] = segments {
+        if let [hir::PathSegment { ident, args: None, .. }] = segments
+            && e.suggestions.len() == 0
+        {
             e.span_label(span, format!("{} defined here", res.descr()));
             e.span_label(
                 pat_span,
diff --git a/tests/ui/did_you_mean/compatible-variants-in-pat.rs b/tests/ui/did_you_mean/compatible-variants-in-pat.rs
index 09e12dab2d3f..5633c28be208 100644
--- a/tests/ui/did_you_mean/compatible-variants-in-pat.rs
+++ b/tests/ui/did_you_mean/compatible-variants-in-pat.rs
@@ -21,7 +21,6 @@ fn b(s: Option<S>) {
         S => {
             //~^ ERROR mismatched types
             //~| HELP try wrapping
-            //~| HELP introduce a new binding instead
         }
         _ => {}
     }
@@ -32,7 +31,6 @@ fn c(s: Result<S, S>) {
         S => {
             //~^ ERROR mismatched types
             //~| HELP try wrapping
-            //~| HELP introduce a new binding instead
         }
         _ => {}
     }
diff --git a/tests/ui/did_you_mean/compatible-variants-in-pat.stderr b/tests/ui/did_you_mean/compatible-variants-in-pat.stderr
index 09cf094e6bd7..f18965f5d080 100644
--- a/tests/ui/did_you_mean/compatible-variants-in-pat.stderr
+++ b/tests/ui/did_you_mean/compatible-variants-in-pat.stderr
@@ -14,16 +14,10 @@ LL |         Foo::Bar(Bar { x }) => {
 error[E0308]: mismatched types
   --> $DIR/compatible-variants-in-pat.rs:21:9
    |
-LL | struct S;
-   | -------- unit struct defined here
-...
 LL |     match s {
    |           - this expression has type `Option<S>`
 LL |         S => {
-   |         ^
-   |         |
-   |         expected `Option<S>`, found `S`
-   |         `S` is interpreted as a unit struct, not a new binding
+   |         ^ expected `Option<S>`, found `S`
    |
    = note: expected enum `Option<S>`
             found struct `S`
@@ -31,25 +25,14 @@ help: try wrapping the pattern in `Some`
    |
 LL |         Some(S) => {
    |         +++++ +
-help: introduce a new binding instead
-   |
-LL -         S => {
-LL +         other_s => {
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/compatible-variants-in-pat.rs:32:9
+  --> $DIR/compatible-variants-in-pat.rs:31:9
    |
-LL | struct S;
-   | -------- unit struct defined here
-...
 LL |     match s {
    |           - this expression has type `Result<S, S>`
 LL |         S => {
-   |         ^
-   |         |
-   |         expected `Result<S, S>`, found `S`
-   |         `S` is interpreted as a unit struct, not a new binding
+   |         ^ expected `Result<S, S>`, found `S`
    |
    = note: expected enum `Result<S, S>`
             found struct `S`
@@ -59,11 +42,6 @@ LL |         Ok(S) => {
    |         +++ +
 LL |         Err(S) => {
    |         ++++ +
-help: introduce a new binding instead
-   |
-LL -         S => {
-LL +         other_s => {
-   |
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/match/issue-12552.stderr b/tests/ui/match/issue-12552.stderr
index 397265cd540f..195192fbd824 100644
--- a/tests/ui/match/issue-12552.stderr
+++ b/tests/ui/match/issue-12552.stderr
@@ -20,14 +20,7 @@ LL |   match t {
    |         - this expression has type `Result<_, {integer}>`
 ...
 LL |     None => ()
-   |     ^^^^
-   |     |
-   |     expected `Result<_, {integer}>`, found `Option<_>`
-   |     `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |     ^^^^ expected `Result<_, {integer}>`, found `Option<_>`
    |
    = note: expected enum `Result<_, {integer}>`
               found enum `Option<_>`
@@ -35,11 +28,6 @@ help: try wrapping the pattern in `Ok`
    |
 LL |     Ok(None) => ()
    |     +++    +
-help: introduce a new binding instead
-   |
-LL -     None => ()
-LL +     other_none => ()
-   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
index 77074e8c3a3b..205e57f4a9ff 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.rs
@@ -8,7 +8,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     match &x {
@@ -18,7 +17,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     let mut y = Box::new(Some(1));
@@ -29,7 +27,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     let mut z = Arc::new(Some(1));
@@ -40,7 +37,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     let z_const: &Arc<Option<i32>> = &z;
@@ -51,7 +47,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     // Normal reference because Arc doesn't implement DerefMut.
@@ -63,7 +58,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     // Mutable reference because Box does implement DerefMut.
@@ -75,7 +69,6 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 
     // Difficult expression.
@@ -87,6 +80,5 @@ fn main() {
         //~^ ERROR mismatched types
         None => {}
         //~^ ERROR mismatched types
-        //~| HELP introduce a new binding instead
     }
 }
diff --git a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
index a5ce44b25600..6092272aa8c5 100644
--- a/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
+++ b/tests/ui/suggestions/suggest-deref-in-match-issue-132784.stderr
@@ -21,14 +21,7 @@ LL |     match x {
    |           - this expression has type `Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -36,14 +29,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match *x {
    |           +
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:17:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:16:9
    |
 LL |     match &x {
    |           -- this expression has type `&Arc<Option<{integer}>>`
@@ -59,20 +47,13 @@ LL |     match &*x {
    |            +
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:19:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:18:9
    |
 LL |     match &x {
    |           -- this expression has type `&Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -80,14 +61,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &*x {
    |            +
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:28:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:26:9
    |
 LL |     match y {
    |           - this expression has type `Box<Option<{integer}>>`
@@ -103,20 +79,13 @@ LL |     match *y {
    |           +
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:30:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:28:9
    |
 LL |     match y {
    |           - this expression has type `Box<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Box<Option<{integer}>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Box<Option<{integer}>>`, found `Option<_>`
    |
    = note: expected struct `Box<Option<{integer}>>`
                 found enum `Option<_>`
@@ -124,14 +93,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match *y {
    |           +
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:39:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:36:9
    |
 LL |     match z as Arc<Option<i32>> {
    |           --------------------- this expression has type `Arc<Option<i32>>`
@@ -148,20 +112,13 @@ LL +     match *(z as Arc<Option<i32>>) {
    |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:41:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:38:9
    |
 LL |     match z as Arc<Option<i32>> {
    |           --------------------- this expression has type `Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<i32>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -170,14 +127,9 @@ help: consider dereferencing to access the inner value using the Deref trait
 LL -     match z as Arc<Option<i32>> {
 LL +     match *(z as Arc<Option<i32>>) {
    |
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:50:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:46:9
    |
 LL |     match z_const {
    |           ------- this expression has type `&Arc<Option<i32>>`
@@ -193,20 +145,13 @@ LL |     match &**z_const {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:52:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:48:9
    |
 LL |     match z_const {
    |           ------- this expression has type `&Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<i32>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -214,14 +159,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**z_const {
    |           +++
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:62:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:57:9
    |
 LL |     match z_mut {
    |           ----- this expression has type `&mut Arc<Option<i32>>`
@@ -237,20 +177,13 @@ LL |     match &**z_mut {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:64:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:59:9
    |
 LL |     match z_mut {
    |           ----- this expression has type `&mut Arc<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<i32>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<i32>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<i32>>`
                 found enum `Option<_>`
@@ -258,14 +191,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**z_mut {
    |           +++
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:74:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:68:9
    |
 LL |     match y_mut {
    |           ----- this expression has type `&mut Box<Option<i32>>`
@@ -281,20 +209,13 @@ LL |     match &**y_mut {
    |           +++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:76:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:70:9
    |
 LL |     match y_mut {
    |           ----- this expression has type `&mut Box<Option<i32>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Box<Option<i32>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Box<Option<i32>>`, found `Option<_>`
    |
    = note: expected struct `Box<Option<i32>>`
                 found enum `Option<_>`
@@ -302,14 +223,9 @@ help: consider dereferencing to access the inner value using the Deref trait
    |
 LL |     match &**y_mut {
    |           +++
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:86:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:79:9
    |
 LL |     match (& (&difficult)  ) {
    |           ------------------ this expression has type `&&Arc<Option<{integer}>>`
@@ -326,20 +242,13 @@ LL +     match &*difficult {
    |
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-deref-in-match-issue-132784.rs:88:9
+  --> $DIR/suggest-deref-in-match-issue-132784.rs:81:9
    |
 LL |     match (& (&difficult)  ) {
    |           ------------------ this expression has type `&&Arc<Option<{integer}>>`
 ...
 LL |         None => {}
-   |         ^^^^
-   |         |
-   |         expected `Arc<Option<{integer}>>`, found `Option<_>`
-   |         `None` is interpreted as a unit variant, not a new binding
-   |
-  --> $SRC_DIR/core/src/option.rs:LL:COL
-   |
-   = note: unit variant defined here
+   |         ^^^^ expected `Arc<Option<{integer}>>`, found `Option<_>`
    |
    = note: expected struct `Arc<Option<{integer}>>`
                 found enum `Option<_>`
@@ -348,11 +257,6 @@ help: consider dereferencing to access the inner value using the Deref trait
 LL -     match (& (&difficult)  ) {
 LL +     match &*difficult {
    |
-help: introduce a new binding instead
-   |
-LL -         None => {}
-LL +         other_none => {}
-   |
 
 error: aborting due to 16 previous errors
 

From 50d4943d449f608bd156968938d43952c1847cc1 Mon Sep 17 00:00:00 2001
From: Misaka_15535 <46892084+Misaka299@users.noreply.github.com>
Date: Sat, 14 Mar 2026 22:11:52 +0800
Subject: [PATCH 0493/1059] docs: remove stale reference to `check_let_chain`

The function `check_let_chain` was removed previously, but it was still
referenced in a comment in `check_match.rs`. This commit cleans it up.
---
 compiler/rustc_mir_build/src/thir/pattern/check_match.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index e844f1114d61..6a79401af24e 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -101,8 +101,7 @@ struct MatchVisitor<'p, 'tcx> {
     error: Result<(), ErrorGuaranteed>,
 }
 
-// Visitor for a thir body. This calls `check_match`, `check_let` and `check_let_chain` as
-// appropriate.
+// Visitor for a thir body. This calls `check_match` and `check_let` as appropriate.
 impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
     fn thir(&self) -> &'p Thir<'tcx> {
         self.thir

From c455f7ce52f4faf522fc6b73e714bd180fc93691 Mon Sep 17 00:00:00 2001
From: Teodoro Freund <tfreund95@gmail.com>
Date: Sun, 15 Mar 2026 09:07:25 +0000
Subject: [PATCH 0494/1059] Refactors to
 `unnecessary_{option,result}_map_or_else`:

- When checking if a function is an identity function, try to use existing functionalities.
- Some cases are no longer supported, but they were buggy
---
 clippy_lints/src/methods/mod.rs               |   7 +-
 .../src/methods/unnecessary_map_or_else.rs    |  39 +++++
 .../methods/unnecessary_option_map_or_else.rs | 111 -------------
 .../methods/unnecessary_result_map_or_else.rs |  80 ----------
 clippy_utils/src/lib.rs                       |  52 ++++++-
 tests/ui/eta.fixed                            |   3 +-
 tests/ui/eta.rs                               |   3 +-
 tests/ui/eta.stderr                           |  88 +++++------
 tests/ui/unnecessary_option_map_or_else.fixed |  38 +++--
 tests/ui/unnecessary_option_map_or_else.rs    |  64 ++++++--
 .../ui/unnecessary_option_map_or_else.stderr  | 144 ++++++++++++++---
 tests/ui/unnecessary_result_map_or_else.fixed |  27 +++-
 tests/ui/unnecessary_result_map_or_else.rs    |  49 +++++-
 .../ui/unnecessary_result_map_or_else.stderr  | 147 +++++++++++++++---
 14 files changed, 536 insertions(+), 316 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_map_or_else.rs
 delete mode 100644 clippy_lints/src/methods/unnecessary_option_map_or_else.rs
 delete mode 100644 clippy_lints/src/methods/unnecessary_result_map_or_else.rs

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 48ab42d587c8..b647dbdc8468 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -134,9 +134,8 @@
 mod unnecessary_lazy_eval;
 mod unnecessary_literal_unwrap;
 mod unnecessary_map_or;
+mod unnecessary_map_or_else;
 mod unnecessary_min_or_max;
-mod unnecessary_option_map_or_else;
-mod unnecessary_result_map_or_else;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
 mod unwrap_expect_used;
@@ -4347,6 +4346,7 @@
 }
 
 declare_clippy_lint! {
+    /// ### What it does
     /// Checks for usage of `.map_or_else()` "map closure" for `Option` type.
     ///
     /// ### Why is this bad?
@@ -5449,8 +5449,7 @@ fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                 },
                 (sym::map_or_else, [def, map]) => {
                     result_map_or_else_none::check(cx, expr, recv, def, map);
-                    unnecessary_option_map_or_else::check(cx, expr, recv, def, map);
-                    unnecessary_result_map_or_else::check(cx, expr, recv, def, map);
+                    unnecessary_map_or_else::check(cx, expr, recv, def, map, call_span);
                 },
                 (sym::next, []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
diff --git a/clippy_lints/src/methods/unnecessary_map_or_else.rs b/clippy_lints/src/methods/unnecessary_map_or_else.rs
new file mode 100644
index 000000000000..7c1c31d2bd38
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_map_or_else.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_expr_identity_function;
+use clippy_utils::res::MaybeDef;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use rustc_span::symbol::sym;
+
+use super::{UNNECESSARY_OPTION_MAP_OR_ELSE, UNNECESSARY_RESULT_MAP_OR_ELSE};
+
+/// lint use of `_.map_or_else(|err| err, |n| n)` for `Result`s and `Option`s.
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    def_arg: &Expr<'_>,
+    map_arg: &Expr<'_>,
+    call_span: Span,
+) {
+    let (symbol, lint) = match cx.typeck_results().expr_ty(recv).opt_diag_name(cx) {
+        Some(x @ sym::Result) => (x, UNNECESSARY_RESULT_MAP_OR_ELSE),
+        Some(x @ sym::Option) => (x, UNNECESSARY_OPTION_MAP_OR_ELSE),
+        _ => return,
+    };
+
+    if is_expr_identity_function(cx, map_arg) {
+        let msg = format!("unused \"map closure\" when calling `{symbol}::map_or_else` value");
+
+        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+            let mut applicability = Applicability::MachineApplicable;
+            let err_snippet = snippet_with_applicability(cx, def_arg.span, "..", &mut applicability);
+            let sugg = format!("unwrap_or_else({err_snippet})");
+
+            diag.span_suggestion_verbose(call_span, "consider using `unwrap_or_else`", sugg, applicability);
+        });
+    }
+}
diff --git a/clippy_lints/src/methods/unnecessary_option_map_or_else.rs b/clippy_lints/src/methods/unnecessary_option_map_or_else.rs
deleted file mode 100644
index 265619e26376..000000000000
--- a/clippy_lints/src/methods/unnecessary_option_map_or_else.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{expr_or_init, find_binding_init, peel_blocks};
-use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Body, BodyId, Closure, Expr, ExprKind, HirId, QPath};
-use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
-
-use super::UNNECESSARY_OPTION_MAP_OR_ELSE;
-use super::utils::get_last_chain_binding_hir_id;
-
-fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>) {
-    let msg = "unused \"map closure\" when calling `Option::map_or_else` value";
-    let mut applicability = Applicability::MachineApplicable;
-    let self_snippet = snippet_with_applicability(cx, recv.span, "_", &mut applicability);
-    let err_snippet = snippet_with_applicability(cx, def_arg.span, "..", &mut applicability);
-    span_lint_and_sugg(
-        cx,
-        UNNECESSARY_OPTION_MAP_OR_ELSE,
-        expr.span,
-        msg,
-        "consider using `unwrap_or_else`",
-        format!("{self_snippet}.unwrap_or_else({err_snippet})"),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn handle_qpath(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    recv: &Expr<'_>,
-    def_arg: &Expr<'_>,
-    expected_hir_id: HirId,
-    qpath: QPath<'_>,
-) {
-    if let QPath::Resolved(_, path) = qpath
-        && let Res::Local(hir_id) = path.res
-        && expected_hir_id == hir_id
-    {
-        emit_lint(cx, expr, recv, def_arg);
-    }
-}
-
-fn handle_closure(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>, body_id: BodyId) {
-    let body = cx.tcx.hir_body(body_id);
-    handle_fn_body(cx, expr, recv, def_arg, body);
-}
-
-fn handle_fn_body(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>, body: &Body<'_>) {
-    if let Some(first_param) = body.params.first() {
-        let body_expr = peel_blocks(body.value);
-        match body_expr.kind {
-            ExprKind::Path(qpath) => {
-                handle_qpath(cx, expr, recv, def_arg, first_param.pat.hir_id, qpath);
-            },
-            // If this is a block (that wasn't peeled off), then it means there are statements.
-            ExprKind::Block(block, _) => {
-                if let Some(block_expr) = block.expr
-                        // First we ensure that this is a "binding chain" (each statement is a binding
-                        // of the previous one) and that it is a binding of the closure argument.
-                        && let Some(last_chain_binding_id) =
-                            get_last_chain_binding_hir_id(first_param.pat.hir_id, block.stmts)
-                        && let ExprKind::Path(qpath) = block_expr.kind
-                {
-                    handle_qpath(cx, expr, recv, def_arg, last_chain_binding_id, qpath);
-                }
-            },
-            _ => {},
-        }
-    }
-}
-
-/// lint use of `_.map_or_else(|err| err, |n| n)` for `Option`s.
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>, map_arg: &Expr<'_>) {
-    // lint if the caller of `map_or_else()` is an `Option`
-    if !cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Option) {
-        return;
-    }
-    match map_arg.kind {
-        // If the second argument is a closure, we can check its body.
-        ExprKind::Closure(&Closure { body, .. }) => {
-            handle_closure(cx, expr, recv, def_arg, body);
-        },
-        ExprKind::Path(qpath) => {
-            let res = cx.qpath_res(&qpath, map_arg.hir_id);
-            match res {
-                // Case 1: Local variable (could be a closure)
-                Res::Local(hir_id) => {
-                    if let Some(init_expr) = find_binding_init(cx, hir_id) {
-                        let origin = expr_or_init(cx, init_expr);
-                        if let ExprKind::Closure(&Closure { body, .. }) = origin.kind {
-                            handle_closure(cx, expr, recv, def_arg, body);
-                        }
-                    }
-                },
-                // Case 2: Function definition
-                Res::Def(DefKind::Fn, def_id) => {
-                    if let Some(local_def_id) = def_id.as_local()
-                        && let Some(body) = cx.tcx.hir_maybe_body_owned_by(local_def_id)
-                    {
-                        handle_fn_body(cx, expr, recv, def_arg, body);
-                    }
-                },
-                _ => (),
-            }
-        },
-        _ => (),
-    }
-}
diff --git a/clippy_lints/src/methods/unnecessary_result_map_or_else.rs b/clippy_lints/src/methods/unnecessary_result_map_or_else.rs
deleted file mode 100644
index 1f6bb60414ae..000000000000
--- a/clippy_lints/src/methods/unnecessary_result_map_or_else.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::peel_blocks;
-use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::{Closure, Expr, ExprKind, HirId, QPath};
-use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
-
-use super::UNNECESSARY_RESULT_MAP_OR_ELSE;
-use super::utils::get_last_chain_binding_hir_id;
-
-fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>) {
-    let msg = "unused \"map closure\" when calling `Result::map_or_else` value";
-    let self_snippet = snippet(cx, recv.span, "..");
-    let err_snippet = snippet(cx, def_arg.span, "..");
-    span_lint_and_sugg(
-        cx,
-        UNNECESSARY_RESULT_MAP_OR_ELSE,
-        expr.span,
-        msg,
-        "consider using `unwrap_or_else`",
-        format!("{self_snippet}.unwrap_or_else({err_snippet})"),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn handle_qpath(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    recv: &Expr<'_>,
-    def_arg: &Expr<'_>,
-    expected_hir_id: HirId,
-    qpath: QPath<'_>,
-) {
-    if let QPath::Resolved(_, path) = qpath
-        && let hir::def::Res::Local(hir_id) = path.res
-        && expected_hir_id == hir_id
-    {
-        emit_lint(cx, expr, recv, def_arg);
-    }
-}
-
-/// lint use of `_.map_or_else(|err| err, |n| n)` for `Result`s.
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    recv: &'tcx Expr<'_>,
-    def_arg: &'tcx Expr<'_>,
-    map_arg: &'tcx Expr<'_>,
-) {
-    // lint if the caller of `map_or_else()` is a `Result`
-    if cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result)
-        && let ExprKind::Closure(&Closure { body, .. }) = map_arg.kind
-        && let body = cx.tcx.hir_body(body)
-        && let Some(first_param) = body.params.first()
-    {
-        let body_expr = peel_blocks(body.value);
-
-        match body_expr.kind {
-            ExprKind::Path(qpath) => {
-                handle_qpath(cx, expr, recv, def_arg, first_param.pat.hir_id, qpath);
-            },
-            // If this is a block (that wasn't peeled off), then it means there are statements.
-            ExprKind::Block(block, _) => {
-                if let Some(block_expr) = block.expr
-                    // First we ensure that this is a "binding chain" (each statement is a binding
-                    // of the previous one) and that it is a binding of the closure argument.
-                    && let Some(last_chain_binding_id) =
-                        get_last_chain_binding_hir_id(first_param.pat.hir_id, block.stmts)
-                    && let ExprKind::Path(qpath) = block_expr.kind
-                {
-                    handle_qpath(cx, expr, recv, def_arg, last_chain_binding_id, qpath);
-                }
-            },
-            _ => {},
-        }
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f502dfd6d388..310317d2c0d2 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1840,13 +1840,38 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 /// * `|[x, y]| [x, y]`
 /// * `|Foo(bar, baz)| Foo(bar, baz)`
 /// * `|Foo { bar, baz }| Foo { bar, baz }`
+/// * `|x| { let y = x; ...; let z = y; z }`
+/// * `|x| { let y = x; ...; let z = y; return z }`
 ///
 /// Consider calling [`is_expr_untyped_identity_function`] or [`is_expr_identity_function`] instead.
-fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
+fn is_body_identity_function<'hir>(cx: &LateContext<'_>, func: &Body<'hir>) -> bool {
     let [param] = func.params else {
         return false;
     };
 
+    let mut param_pat = param.pat;
+
+    // Given a sequence of `Stmt`s of the form `let p = e` where `e` is an expr identical to the
+    // current `param_pat`, advance the current `param_pat` to `p`.
+    //
+    // Note: This is similar to `clippy_utils::get_last_chain_binding_hir_id`, but it works
+    // directly over a `Pattern` rather than a `HirId`. And it checks for compatibility via
+    // `is_expr_identity_of_pat` rather than `HirId` equality
+    let mut advance_param_pat_over_stmts = |stmts: &[Stmt<'hir>]| {
+        for stmt in stmts {
+            if let StmtKind::Let(local) = stmt.kind
+                && let Some(init) = local.init
+                && is_expr_identity_of_pat(cx, param_pat, init, true)
+            {
+                param_pat = local.pat;
+            } else {
+                return false;
+            }
+        }
+
+        true
+    };
+
     let mut expr = func.value;
     loop {
         match expr.kind {
@@ -1875,7 +1900,30 @@ fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
                     return false;
                 }
             },
-            _ => return is_expr_identity_of_pat(cx, param.pat, expr, true),
+            ExprKind::Block(
+                &Block {
+                    stmts, expr: Some(e), ..
+                },
+                _,
+            ) => {
+                if !advance_param_pat_over_stmts(stmts) {
+                    return false;
+                }
+
+                expr = e;
+            },
+            ExprKind::Block(&Block { stmts, expr: None, .. }, _) => {
+                if let Some((last_stmt, stmts)) = stmts.split_last()
+                    && advance_param_pat_over_stmts(stmts)
+                    && let StmtKind::Semi(e) | StmtKind::Expr(e) = last_stmt.kind
+                    && let ExprKind::Ret(Some(ret_val)) = e.kind
+                {
+                    expr = ret_val;
+                } else {
+                    return false;
+                }
+            },
+            _ => return is_expr_identity_of_pat(cx, param_pat, expr, true),
         }
     }
 }
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 41e5bbe3cbed..36300aa56eb3 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -13,7 +13,8 @@
     clippy::uninlined_format_args,
     clippy::useless_vec,
     clippy::unnecessary_map_on_constructor,
-    clippy::needless_lifetimes
+    clippy::needless_lifetimes,
+    clippy::unnecessary_option_map_or_else
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index de0d3fb63c51..63b441851ec1 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -13,7 +13,8 @@
     clippy::uninlined_format_args,
     clippy::useless_vec,
     clippy::unnecessary_map_on_constructor,
-    clippy::needless_lifetimes
+    clippy::needless_lifetimes,
+    clippy::unnecessary_option_map_or_else
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index c19947cddafa..b57038963b7e 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> tests/ui/eta.rs:34:27
+  --> tests/ui/eta.rs:35:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -8,31 +8,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:39:40
+  --> tests/ui/eta.rs:40:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> tests/ui/eta.rs:42:35
+  --> tests/ui/eta.rs:43:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:45:26
+  --> tests/ui/eta.rs:46:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> tests/ui/eta.rs:54:27
+  --> tests/ui/eta.rs:55:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> tests/ui/eta.rs:107:51
+  --> tests/ui/eta.rs:108:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,229 +41,229 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_for_method_calls)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:109:51
+  --> tests/ui/eta.rs:110:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> tests/ui/eta.rs:112:42
+  --> tests/ui/eta.rs:113:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> tests/ui/eta.rs:117:29
+  --> tests/ui/eta.rs:118:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> tests/ui/eta.rs:119:27
+  --> tests/ui/eta.rs:120:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:122:65
+  --> tests/ui/eta.rs:123:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:139:23
+  --> tests/ui/eta.rs:140:23
    |
 LL |         let _ = x.map(|x| x.parse::<i16>());
    |                       ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `str::parse::<i16>`
 
 error: redundant closure
-  --> tests/ui/eta.rs:192:22
+  --> tests/ui/eta.rs:193:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> tests/ui/eta.rs:200:27
+  --> tests/ui/eta.rs:201:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> tests/ui/eta.rs:206:27
+  --> tests/ui/eta.rs:207:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:239:28
+  --> tests/ui/eta.rs:240:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:241:28
+  --> tests/ui/eta.rs:242:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:243:28
+  --> tests/ui/eta.rs:244:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:251:21
+  --> tests/ui/eta.rs:252:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:256:21
+  --> tests/ui/eta.rs:257:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> tests/ui/eta.rs:350:18
+  --> tests/ui/eta.rs:351:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:354:19
+  --> tests/ui/eta.rs:355:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:359:26
+  --> tests/ui/eta.rs:360:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> tests/ui/eta.rs:372:19
+  --> tests/ui/eta.rs:373:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> tests/ui/eta.rs:376:19
+  --> tests/ui/eta.rs:377:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> tests/ui/eta.rs:380:17
+  --> tests/ui/eta.rs:381:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> tests/ui/eta.rs:385:17
+  --> tests/ui/eta.rs:386:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
 error: redundant closure
-  --> tests/ui/eta.rs:446:19
+  --> tests/ui/eta.rs:447:19
    |
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:475:22
+  --> tests/ui/eta.rs:476:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:480:22
+  --> tests/ui/eta.rs:481:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `super::Outer::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:494:18
+  --> tests/ui/eta.rs:495:18
    |
 LL |         test.map(|t| t.method())
    |                  ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `test_mod::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:502:30
+  --> tests/ui/eta.rs:503:30
    |
 LL |                     test.map(|t| t.method())
    |                              ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `crate::issue_10854::d::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:522:38
+  --> tests/ui/eta.rs:523:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `&f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:527:38
+  --> tests/ui/eta.rs:528:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:545:35
+  --> tests/ui/eta.rs:546:35
    |
 LL |         let _field = bind.or_else(|| get_default()).unwrap();
    |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
 
 error: redundant closure
-  --> tests/ui/eta.rs:592:16
+  --> tests/ui/eta.rs:593:16
    |
 LL |     accepts_fn(|| f());
    |                ^^^^^^ help: replace the closure with the function itself: `**f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:596:16
+  --> tests/ui/eta.rs:597:16
    |
 LL |     accepts_fn(|| g());
    |                ^^^^^^ help: replace the closure with the function itself: `g`
 
 error: redundant closure
-  --> tests/ui/eta.rs:609:16
+  --> tests/ui/eta.rs:610:16
    |
 LL |     accepts_fn(|| b());
    |                ^^^^^^ help: replace the closure with the function itself: `***b`
 
 error: redundant closure
-  --> tests/ui/eta.rs:633:14
+  --> tests/ui/eta.rs:634:14
    |
 LL |         .map(|n| MyError::A(n))
    |              ^^^^^^^^^^^^^^^^^ help: replace the closure with the tuple variant itself: `MyError::A`
 
 error: redundant closure
-  --> tests/ui/eta.rs:630:14
+  --> tests/ui/eta.rs:631:14
    |
 LL |         .map(|n| S(n))
    |              ^^^^^^^^ help: replace the closure with the tuple struct itself: `S`
 
 error: redundant closure
-  --> tests/ui/eta.rs:627:14
+  --> tests/ui/eta.rs:628:14
    |
 LL |         .map(|n| g(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `g`
 
 error: redundant closure
-  --> tests/ui/eta.rs:624:14
+  --> tests/ui/eta.rs:625:14
    |
 LL |         .map(|n| f(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:651:31
+  --> tests/ui/eta.rs:652:31
    |
 LL |         array.iter().for_each(|item| item.method());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Self::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:661:38
+  --> tests/ui/eta.rs:662:38
    |
 LL |     (0..10).flat_map(|x| (0..10).map(|y| closure(y))).count();
    |                                      ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&*closure`
diff --git a/tests/ui/unnecessary_option_map_or_else.fixed b/tests/ui/unnecessary_option_map_or_else.fixed
index 9974ee2d08eb..8d25efbeea00 100644
--- a/tests/ui/unnecessary_option_map_or_else.fixed
+++ b/tests/ui/unnecessary_option_map_or_else.fixed
@@ -3,13 +3,10 @@
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::unnecessary_lazy_evaluations,
-    clippy::unnecessary_literal_unwrap
+    clippy::unnecessary_literal_unwrap,
+    clippy::needless_return
 )]
 
-const fn identity<T>(x: T) -> T {
-    x
-}
-
 const fn double_it(x: i32) -> i32 {
     x * 2
 }
@@ -18,31 +15,42 @@ fn main() {
     // Expected errors
     // Basic scenario
     let option = Some(());
-    option.unwrap_or_else(|| ()); //~ ERROR: unused "map closure" when calling
+    option.unwrap_or_else(|| ()); //~ unnecessary_option_map_or_else
 
     // Type ascription
     let option = Some(());
-    option.unwrap_or_else(|| ()); //~ ERROR: unused "map closure" when calling
+    option.unwrap_or_else(|| ()); //~ unnecessary_option_map_or_else
 
     // Auto-deref
     let string = String::new();
     let option = Some(&string);
-    let _: &str = option.unwrap_or_else(|| &string); //~ ERROR: unused "map closure" when calling
+    let _: &str = option.map_or_else(|| &string, |x| x);
+    // This should in theory lint with a smarter check
 
     // Temporary variable
     let option = Some(());
     option.unwrap_or_else(|| ());
 
-    // Identity
+    // Temporary variable with pattern
+    let option = Some(((), ()));
+    option.unwrap_or_else(|| ((), ()));
+
+    // std::convert::identity
     let string = String::new();
     let option = Some(&string);
-    let _: &str = option.unwrap_or_else(|| &string); //~ ERROR: unused "map closure" when calling
+    let _: &str = option.unwrap_or_else(|| &string); //~ unnecessary_option_map_or_else
 
-    // Closure bound to a variable
-    let do_nothing = |x: String| x;
-    let string = String::new();
-    let option = Some(string.clone());
-    let _: String = option.unwrap_or_else(|| string); //~ ERROR: unused "map closure" when calling
+    let x: Option<((), ())> = Some(((), ()));
+    x.unwrap_or_else(|| ((), ()));
+    //~^ unnecessary_option_map_or_else
+
+    // Returned temporary variable.
+    let x: Option<()> = Some(());
+    x.unwrap_or_else(|| ());
+
+    // Returned temporary variable with pattern
+    let x: Option<((), ())> = Some(((), ()));
+    x.unwrap_or_else(|| ((), ()));
 
     // Correct usages
     let option = Some(());
diff --git a/tests/ui/unnecessary_option_map_or_else.rs b/tests/ui/unnecessary_option_map_or_else.rs
index 9b53f3fcd521..42d4ad6ac1f8 100644
--- a/tests/ui/unnecessary_option_map_or_else.rs
+++ b/tests/ui/unnecessary_option_map_or_else.rs
@@ -3,13 +3,10 @@
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::unnecessary_lazy_evaluations,
-    clippy::unnecessary_literal_unwrap
+    clippy::unnecessary_literal_unwrap,
+    clippy::needless_return
 )]
 
-const fn identity<T>(x: T) -> T {
-    x
-}
-
 const fn double_it(x: i32) -> i32 {
     x * 2
 }
@@ -18,21 +15,22 @@ fn main() {
     // Expected errors
     // Basic scenario
     let option = Some(());
-    option.map_or_else(|| (), |x| x); //~ ERROR: unused "map closure" when calling
+    option.map_or_else(|| (), |x| x); //~ unnecessary_option_map_or_else
 
     // Type ascription
     let option = Some(());
-    option.map_or_else(|| (), |x: ()| x); //~ ERROR: unused "map closure" when calling
+    option.map_or_else(|| (), |x: ()| x); //~ unnecessary_option_map_or_else
 
     // Auto-deref
     let string = String::new();
     let option = Some(&string);
-    let _: &str = option.map_or_else(|| &string, |x| x); //~ ERROR: unused "map closure" when calling
+    let _: &str = option.map_or_else(|| &string, |x| x);
+    // This should in theory lint with a smarter check
 
     // Temporary variable
     let option = Some(());
     option.map_or_else(
-        //~^ ERROR: unused "map closure" when calling
+        //~^ unnecessary_option_map_or_else
         || (),
         |x| {
             let tmp = x;
@@ -40,16 +38,50 @@ fn main() {
         },
     );
 
-    // Identity
+    // Temporary variable with pattern
+    let option = Some(((), ()));
+    option.map_or_else(
+        //~^ unnecessary_option_map_or_else
+        || ((), ()),
+        |x| {
+            let tmp = x;
+            let (a, b) = tmp;
+            (a, b)
+        },
+    );
+
+    // std::convert::identity
     let string = String::new();
     let option = Some(&string);
-    let _: &str = option.map_or_else(|| &string, identity); //~ ERROR: unused "map closure" when calling
+    let _: &str = option.map_or_else(|| &string, std::convert::identity); //~ unnecessary_option_map_or_else
 
-    // Closure bound to a variable
-    let do_nothing = |x: String| x;
-    let string = String::new();
-    let option = Some(string.clone());
-    let _: String = option.map_or_else(|| string, do_nothing); //~ ERROR: unused "map closure" when calling
+    let x: Option<((), ())> = Some(((), ()));
+    x.map_or_else(|| ((), ()), |(a, b)| (a, b));
+    //~^ unnecessary_option_map_or_else
+
+    // Returned temporary variable.
+    let x: Option<()> = Some(());
+    x.map_or_else(
+        //~^ unnecessary_option_map_or_else
+        || (),
+        |n| {
+            let tmp = n;
+            let tmp2 = tmp;
+            return tmp2;
+        },
+    );
+
+    // Returned temporary variable with pattern
+    let x: Option<((), ())> = Some(((), ()));
+    x.map_or_else(
+        //~^ unnecessary_option_map_or_else
+        || ((), ()),
+        |n| {
+            let tmp = n;
+            let (a, b) = tmp;
+            return (a, b);
+        },
+    );
 
     // Correct usages
     let option = Some(());
diff --git a/tests/ui/unnecessary_option_map_or_else.stderr b/tests/ui/unnecessary_option_map_or_else.stderr
index d90875e4efc7..3b579ebdb289 100644
--- a/tests/ui/unnecessary_option_map_or_else.stderr
+++ b/tests/ui/unnecessary_option_map_or_else.stderr
@@ -1,26 +1,31 @@
 error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:21:5
+  --> tests/ui/unnecessary_option_map_or_else.rs:18:5
    |
 LL |     option.map_or_else(|| (), |x| x);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| ())`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unnecessary-option-map-or-else` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_option_map_or_else)]`
+help: consider using `unwrap_or_else`
+   |
+LL -     option.map_or_else(|| (), |x| x);
+LL +     option.unwrap_or_else(|| ());
+   |
 
 error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:25:5
+  --> tests/ui/unnecessary_option_map_or_else.rs:22:5
    |
 LL |     option.map_or_else(|| (), |x: ()| x);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| ())`
-
-error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:30:19
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     option.map_or_else(|| (), |x: ()| x);
+LL +     option.unwrap_or_else(|| ());
    |
-LL |     let _: &str = option.map_or_else(|| &string, |x| x);
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| &string)`
 
 error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:34:5
+  --> tests/ui/unnecessary_option_map_or_else.rs:32:5
    |
 LL | /     option.map_or_else(
 LL | |
@@ -29,19 +34,122 @@ LL | |         |x| {
 ...  |
 LL | |         },
 LL | |     );
-   | |_____^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| ())`
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     option.map_or_else(
+LL -
+LL -         || (),
+LL -         |x| {
+LL -             let tmp = x;
+LL -             tmp
+LL -         },
+LL -     );
+LL +     option.unwrap_or_else(|| ());
+   |
 
 error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:46:19
+  --> tests/ui/unnecessary_option_map_or_else.rs:43:5
+   |
+LL | /     option.map_or_else(
+LL | |
+LL | |         || ((), ()),
+LL | |         |x| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     option.map_or_else(
+LL -
+LL -         || ((), ()),
+LL -         |x| {
+LL -             let tmp = x;
+LL -             let (a, b) = tmp;
+LL -             (a, b)
+LL -         },
+LL -     );
+LL +     option.unwrap_or_else(|| ((), ()));
    |
-LL |     let _: &str = option.map_or_else(|| &string, identity);
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| &string)`
 
 error: unused "map closure" when calling `Option::map_or_else` value
-  --> tests/ui/unnecessary_option_map_or_else.rs:52:21
+  --> tests/ui/unnecessary_option_map_or_else.rs:56:19
+   |
+LL |     let _: &str = option.map_or_else(|| &string, std::convert::identity);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     let _: &str = option.map_or_else(|| &string, std::convert::identity);
+LL +     let _: &str = option.unwrap_or_else(|| &string);
    |
-LL |     let _: String = option.map_or_else(|| string, do_nothing);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `option.unwrap_or_else(|| string)`
 
-error: aborting due to 6 previous errors
+error: unused "map closure" when calling `Option::map_or_else` value
+  --> tests/ui/unnecessary_option_map_or_else.rs:59:5
+   |
+LL |     x.map_or_else(|| ((), ()), |(a, b)| (a, b));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(|| ((), ()), |(a, b)| (a, b));
+LL +     x.unwrap_or_else(|| ((), ()));
+   |
+
+error: unused "map closure" when calling `Option::map_or_else` value
+  --> tests/ui/unnecessary_option_map_or_else.rs:64:5
+   |
+LL | /     x.map_or_else(
+LL | |
+LL | |         || (),
+LL | |         |n| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         || (),
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let tmp2 = tmp;
+LL -             return tmp2;
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|| ());
+   |
+
+error: unused "map closure" when calling `Option::map_or_else` value
+  --> tests/ui/unnecessary_option_map_or_else.rs:76:5
+   |
+LL | /     x.map_or_else(
+LL | |
+LL | |         || ((), ()),
+LL | |         |n| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         || ((), ()),
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let (a, b) = tmp;
+LL -             return (a, b);
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|| ((), ()));
+   |
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/unnecessary_result_map_or_else.fixed b/tests/ui/unnecessary_result_map_or_else.fixed
index 5d7e3fa355fd..55542519bdb7 100644
--- a/tests/ui/unnecessary_result_map_or_else.fixed
+++ b/tests/ui/unnecessary_result_map_or_else.fixed
@@ -1,5 +1,10 @@
 #![warn(clippy::unnecessary_result_map_or_else)]
-#![allow(clippy::unnecessary_literal_unwrap, clippy::let_and_return, clippy::let_unit_value)]
+#![allow(
+    clippy::unnecessary_literal_unwrap,
+    clippy::let_and_return,
+    clippy::let_unit_value,
+    clippy::needless_return
+)]
 
 fn main() {
     let x: Result<(), ()> = Ok(());
@@ -14,13 +19,17 @@ fn main() {
     // Auto-deref.
     let y = String::new();
     let x: Result<&String, &String> = Ok(&y);
-    let y: &str = x.unwrap_or_else(|err| err);
-    //~^ unnecessary_result_map_or_else
+    let y: &str = x.map_or_else(|err| err, |n| n);
+    // This should lint with a smarter check
 
     // Temporary variable.
     let x: Result<(), ()> = Ok(());
     x.unwrap_or_else(|err| err);
 
+    // Temporary variable with pattern
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.unwrap_or_else(|err| err);
+
     // Should not warn.
     let x: Result<usize, usize> = Ok(0);
     x.map_or_else(|err| err, |n| n + 1);
@@ -61,4 +70,16 @@ fn main() {
             y
         },
     );
+
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.unwrap_or_else(|err| err);
+    //~^ unnecessary_result_map_or_else
+
+    // Returned temporary variable.
+    let x: Result<(), ()> = Ok(());
+    x.unwrap_or_else(|err| err);
+
+    // Returned temporary variable with pattern
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.unwrap_or_else(|err| err);
 }
diff --git a/tests/ui/unnecessary_result_map_or_else.rs b/tests/ui/unnecessary_result_map_or_else.rs
index d2bab0f9d9c1..21a4826911e5 100644
--- a/tests/ui/unnecessary_result_map_or_else.rs
+++ b/tests/ui/unnecessary_result_map_or_else.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::unnecessary_result_map_or_else)]
-#![allow(clippy::unnecessary_literal_unwrap, clippy::let_and_return, clippy::let_unit_value)]
+#![allow(
+    clippy::unnecessary_literal_unwrap,
+    clippy::let_and_return,
+    clippy::let_unit_value,
+    clippy::needless_return
+)]
 
 fn main() {
     let x: Result<(), ()> = Ok(());
@@ -15,7 +20,7 @@ fn main() {
     let y = String::new();
     let x: Result<&String, &String> = Ok(&y);
     let y: &str = x.map_or_else(|err| err, |n| n);
-    //~^ unnecessary_result_map_or_else
+    // This should lint with a smarter check
 
     // Temporary variable.
     let x: Result<(), ()> = Ok(());
@@ -29,6 +34,18 @@ fn main() {
         },
     );
 
+    // Temporary variable with pattern
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.map_or_else(
+        //~^ unnecessary_result_map_or_else
+        |err| err,
+        |n| {
+            let tmp = n;
+            let (a, b) = tmp;
+            (a, b)
+        },
+    );
+
     // Should not warn.
     let x: Result<usize, usize> = Ok(0);
     x.map_or_else(|err| err, |n| n + 1);
@@ -69,4 +86,32 @@ fn main() {
             y
         },
     );
+
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.map_or_else(|err| err, |(a, b)| (a, b));
+    //~^ unnecessary_result_map_or_else
+
+    // Returned temporary variable.
+    let x: Result<(), ()> = Ok(());
+    x.map_or_else(
+        //~^ unnecessary_result_map_or_else
+        |err| err,
+        |n| {
+            let tmp = n;
+            let tmp2 = tmp;
+            return tmp2;
+        },
+    );
+
+    // Returned temporary variable with pattern
+    let x: Result<((), ()), ((), ())> = Ok(((), ()));
+    x.map_or_else(
+        //~^ unnecessary_result_map_or_else
+        |err| err,
+        |n| {
+            let tmp = n;
+            let (a, b) = tmp;
+            return (a, b);
+        },
+    );
 }
diff --git a/tests/ui/unnecessary_result_map_or_else.stderr b/tests/ui/unnecessary_result_map_or_else.stderr
index e6afa50217cc..f76999127c64 100644
--- a/tests/ui/unnecessary_result_map_or_else.stderr
+++ b/tests/ui/unnecessary_result_map_or_else.stderr
@@ -1,26 +1,31 @@
-error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:6:5
-   |
-LL |     x.map_or_else(|err| err, |n| n);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err| err)`
-   |
-   = note: `-D clippy::unnecessary-result-map-or-else` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_result_map_or_else)]`
-
 error: unused "map closure" when calling `Result::map_or_else` value
   --> tests/ui/unnecessary_result_map_or_else.rs:11:5
    |
-LL |     x.map_or_else(|err: ()| err, |n: ()| n);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err: ()| err)`
-
-error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:17:19
+LL |     x.map_or_else(|err| err, |n| n);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-result-map-or-else` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_result_map_or_else)]`
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(|err| err, |n| n);
+LL +     x.unwrap_or_else(|err| err);
    |
-LL |     let y: &str = x.map_or_else(|err| err, |n| n);
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err| err)`
 
 error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:22:5
+  --> tests/ui/unnecessary_result_map_or_else.rs:16:5
+   |
+LL |     x.map_or_else(|err: ()| err, |n: ()| n);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(|err: ()| err, |n: ()| n);
+LL +     x.unwrap_or_else(|err: ()| err);
+   |
+
+error: unused "map closure" when calling `Result::map_or_else` value
+  --> tests/ui/unnecessary_result_map_or_else.rs:27:5
    |
 LL | /     x.map_or_else(
 LL | |
@@ -29,7 +34,111 @@ LL | |         |n| {
 ...  |
 LL | |         },
 LL | |     );
-   | |_____^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err| err)`
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         |err| err,
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let tmp2 = tmp;
+LL -             tmp2
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|err| err);
+   |
 
-error: aborting due to 4 previous errors
+error: unused "map closure" when calling `Result::map_or_else` value
+  --> tests/ui/unnecessary_result_map_or_else.rs:39:5
+   |
+LL | /     x.map_or_else(
+LL | |
+LL | |         |err| err,
+LL | |         |n| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         |err| err,
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let (a, b) = tmp;
+LL -             (a, b)
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|err| err);
+   |
+
+error: unused "map closure" when calling `Result::map_or_else` value
+  --> tests/ui/unnecessary_result_map_or_else.rs:91:5
+   |
+LL |     x.map_or_else(|err| err, |(a, b)| (a, b));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(|err| err, |(a, b)| (a, b));
+LL +     x.unwrap_or_else(|err| err);
+   |
+
+error: unused "map closure" when calling `Result::map_or_else` value
+  --> tests/ui/unnecessary_result_map_or_else.rs:96:5
+   |
+LL | /     x.map_or_else(
+LL | |
+LL | |         |err| err,
+LL | |         |n| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         |err| err,
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let tmp2 = tmp;
+LL -             return tmp2;
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|err| err);
+   |
+
+error: unused "map closure" when calling `Result::map_or_else` value
+  --> tests/ui/unnecessary_result_map_or_else.rs:108:5
+   |
+LL | /     x.map_or_else(
+LL | |
+LL | |         |err| err,
+LL | |         |n| {
+...  |
+LL | |         },
+LL | |     );
+   | |_____^
+   |
+help: consider using `unwrap_or_else`
+   |
+LL -     x.map_or_else(
+LL -
+LL -         |err| err,
+LL -         |n| {
+LL -             let tmp = n;
+LL -             let (a, b) = tmp;
+LL -             return (a, b);
+LL -         },
+LL -     );
+LL +     x.unwrap_or_else(|err| err);
+   |
+
+error: aborting due to 7 previous errors
 

From 5316bab2999f02b42acd831ac007caa77a246893 Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Sun, 15 Mar 2026 18:51:45 +0800
Subject: [PATCH 0495/1059] Avoid choosing a glob import if a single import
 could define the same with current import

---
 compiler/rustc_resolve/src/ident.rs           |  2 +-
 .../imports/inconsistent-resolution-153842.rs | 17 ++++++++++++
 .../inconsistent-resolution-153842.stderr     | 26 +++++++++++++++++++
 3 files changed, 44 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/imports/inconsistent-resolution-153842.rs
 create mode 100644 tests/ui/imports/inconsistent-resolution-153842.stderr

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 7cfd5b5f861a..fc9a82942386 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -1366,7 +1366,7 @@ fn single_import_can_define_name<'r>(
                 &single_import.parent_scope,
                 None,
                 ignore_decl,
-                ignore_import,
+                None,
             ) {
                 Err(Determined) => continue,
                 Ok(binding)
diff --git a/tests/ui/imports/inconsistent-resolution-153842.rs b/tests/ui/imports/inconsistent-resolution-153842.rs
new file mode 100644
index 000000000000..85fff361e31d
--- /dev/null
+++ b/tests/ui/imports/inconsistent-resolution-153842.rs
@@ -0,0 +1,17 @@
+mod a {
+    pub use crate::s::Trait as s;
+    //~^ ERROR cannot determine resolution for the import
+    //~| ERROR cannot determine resolution for the import
+    //~| ERROR unresolved imports `crate::s::Trait`, `a::s`
+}
+
+mod b {
+    pub mod s {
+        pub trait Trait {}
+    }
+}
+
+use a::s;
+use b::*;
+
+fn main() {}
diff --git a/tests/ui/imports/inconsistent-resolution-153842.stderr b/tests/ui/imports/inconsistent-resolution-153842.stderr
new file mode 100644
index 000000000000..2b686ff3f76e
--- /dev/null
+++ b/tests/ui/imports/inconsistent-resolution-153842.stderr
@@ -0,0 +1,26 @@
+error: cannot determine resolution for the import
+  --> $DIR/inconsistent-resolution-153842.rs:2:13
+   |
+LL |     pub use crate::s::Trait as s;
+   |             ^^^^^^^^^^^^^^^^^^^^
+
+error: cannot determine resolution for the import
+  --> $DIR/inconsistent-resolution-153842.rs:2:13
+   |
+LL |     pub use crate::s::Trait as s;
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0432]: unresolved imports `crate::s::Trait`, `a::s`
+  --> $DIR/inconsistent-resolution-153842.rs:2:13
+   |
+LL |     pub use crate::s::Trait as s;
+   |             ^^^^^^^^^^^^^^^^^^^^
+...
+LL | use a::s;
+   |     ^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0432`.

From a0c174fe8a5e57fadb021a745859ef045a849a77 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Sun, 15 Mar 2026 12:06:32 +0100
Subject: [PATCH 0496/1059] add test for param-env shadowing

---
 ...le-impls-shadowed-in-trait-def.next.stderr | 19 +++++++++++++++
 ...ble-impls-shadowed-in-trait-def.old.stderr | 19 +++++++++++++++
 ...-applicable-impls-shadowed-in-trait-def.rs | 23 +++++++++++++++++++
 3 files changed, 61 insertions(+)
 create mode 100644 tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.next.stderr
 create mode 100644 tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.old.stderr
 create mode 100644 tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.rs

diff --git a/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.next.stderr b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.next.stderr
new file mode 100644
index 000000000000..30eccc3a72d5
--- /dev/null
+++ b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.next.stderr
@@ -0,0 +1,19 @@
+error[E0277]: the trait bound `Self: Eq<<Self as Trait>::Assoc>` is not satisfied
+  --> $DIR/always-applicable-impls-shadowed-in-trait-def.rs:13:17
+   |
+LL |     fn foo() -> IsEqual<Self, Self::Assoc> {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Eq<<Self as Trait>::Assoc>` is not implemented for `Self`
+   |
+note: required by a bound in `IsEqual`
+  --> $DIR/always-applicable-impls-shadowed-in-trait-def.rs:9:19
+   |
+LL | struct IsEqual<T: Eq<U>, U>(T, U);
+   |                   ^^^^^ required by this bound in `IsEqual`
+help: consider further restricting `Self`
+   |
+LL |     fn foo() -> IsEqual<Self, Self::Assoc> where Self: Eq<<Self as Trait>::Assoc> {
+   |                                            ++++++++++++++++++++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.old.stderr b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.old.stderr
new file mode 100644
index 000000000000..30eccc3a72d5
--- /dev/null
+++ b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.old.stderr
@@ -0,0 +1,19 @@
+error[E0277]: the trait bound `Self: Eq<<Self as Trait>::Assoc>` is not satisfied
+  --> $DIR/always-applicable-impls-shadowed-in-trait-def.rs:13:17
+   |
+LL |     fn foo() -> IsEqual<Self, Self::Assoc> {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Eq<<Self as Trait>::Assoc>` is not implemented for `Self`
+   |
+note: required by a bound in `IsEqual`
+  --> $DIR/always-applicable-impls-shadowed-in-trait-def.rs:9:19
+   |
+LL | struct IsEqual<T: Eq<U>, U>(T, U);
+   |                   ^^^^^ required by this bound in `IsEqual`
+help: consider further restricting `Self`
+   |
+LL |     fn foo() -> IsEqual<Self, Self::Assoc> where Self: Eq<<Self as Trait>::Assoc> {
+   |                                            ++++++++++++++++++++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.rs b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.rs
new file mode 100644
index 000000000000..2f8abb6a70d8
--- /dev/null
+++ b/tests/ui/associated-types/always-applicable-impls-shadowed-in-trait-def.rs
@@ -0,0 +1,23 @@
+//@ revisions: old next
+//@[next] compile-flags: -Znext-solver
+
+// Testing that even if there's an always applicable blanket impl, the trait
+// definition cannot use that impl to normalize its own associated types.
+
+trait Eq<T> {}
+impl<T> Eq<T> for T {}
+struct IsEqual<T: Eq<U>, U>(T, U);
+
+trait Trait: Sized {
+    type Assoc;
+    fn foo() -> IsEqual<Self, Self::Assoc> {
+        //~^ ERROR the trait bound `Self: Eq<<Self as Trait>::Assoc>` is not satisfied
+        todo!()
+    }
+}
+
+impl<T> Trait for T {
+    type Assoc = T;
+}
+
+fn main() {}

From 7ec77fd4d5cb035b81a8477c50763c727ceb09c1 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 15 Mar 2026 20:29:39 +0900
Subject: [PATCH 0497/1059] Fix invalid suggestion on
 `for-loops-over-fallibles`

---
 .../src/for_loops_over_fallibles.rs           |  2 ++
 .../macro-iterator-next.rs                    | 21 ++++++++++++++++
 .../macro-iterator-next.stderr                | 24 +++++++++++++++++++
 3 files changed, 47 insertions(+)
 create mode 100644 tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs
 create mode 100644 tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr

diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index fe95a682c637..24220e035b1d 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -77,6 +77,8 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         };
 
         let sub = if let Some(recv) = extract_iterator_next_call(cx, arg)
+            && recv.span.can_be_used_for_suggestions()
+            && recv.span.between(arg_span.shrink_to_hi()).can_be_used_for_suggestions()
             && let Ok(recv_snip) = cx.sess().source_map().span_to_snippet(recv.span)
         {
             ForLoopsOverFalliblesLoopSub::RemoveNext {
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs b/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs
new file mode 100644
index 000000000000..0fe88734099c
--- /dev/null
+++ b/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs
@@ -0,0 +1,21 @@
+// This test ensures that the `for-loops-over-fallibles` lint doesn't suggest
+// removing `next`.
+// ref. <https://github.com/rust-lang/rust-clippy/issues/16133>
+
+#![forbid(for_loops_over_fallibles)]
+//~^ NOTE: the lint level is defined here
+
+fn main() {
+    macro_rules! mac {
+        (next $e:expr) => {
+            $e.iter().next()
+        };
+    }
+
+    for _ in mac!(next [1, 2]) {}
+    //~^ ERROR: for loop over an `Option`. This is more readably written as an `if let` statement
+    //~| NOTE: in this expansion of desugaring of `for` loop
+    //~| NOTE: in this expansion of desugaring of `for` loop
+    //~| HELP: to check pattern in a loop use `while let`
+    //~| HELP: consider using `if let` to clear intent
+}
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr b/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr
new file mode 100644
index 000000000000..36848fffa439
--- /dev/null
+++ b/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr
@@ -0,0 +1,24 @@
+error: for loop over an `Option`. This is more readably written as an `if let` statement
+  --> $DIR/macro-iterator-next.rs:15:14
+   |
+LL |     for _ in mac!(next [1, 2]) {}
+   |              ^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/macro-iterator-next.rs:5:11
+   |
+LL | #![forbid(for_loops_over_fallibles)]
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^
+help: to check pattern in a loop use `while let`
+   |
+LL -     for _ in mac!(next [1, 2]) {}
+LL +     while let Some(_) = mac!(next [1, 2]) {}
+   |
+help: consider using `if let` to clear intent
+   |
+LL -     for _ in mac!(next [1, 2]) {}
+LL +     if let Some(_) = mac!(next [1, 2]) {}
+   |
+
+error: aborting due to 1 previous error
+

From ed15a20647524f82c0f75a4666af002dfcc146d2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 15 Mar 2026 19:45:38 +0800
Subject: [PATCH 0498/1059] fix: fill match arms on last comma and empty expr

Example
---
```rust
fn foo() {
    match Some(2) {
        Some(_) => ()$0,
    }
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
fn foo() {
    match Some(2) {
        Some(_) => (),
        None => ${1:todo!()},$0
    }
}
```
---
 .../src/handlers/add_missing_match_arms.rs    | 132 ++++++++++++++++--
 1 file changed, 121 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index c0ce057d7798..8124fecff629 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -245,14 +245,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                 .arms()
                 .filter(|arm| {
                     if matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))) {
-                        let is_empty_expr = arm.expr().is_none_or(|e| match e {
-                            ast::Expr::BlockExpr(b) => {
-                                b.statements().next().is_none() && b.tail_expr().is_none()
-                            }
-                            ast::Expr::TupleExpr(t) => t.fields().next().is_none(),
-                            _ => false,
-                        });
-                        if is_empty_expr {
+                        if arm.expr().is_none_or(is_empty_expr) {
                             false
                         } else {
                             cov_mark::hit!(add_missing_match_arms_empty_expr);
@@ -347,12 +340,24 @@ fn cursor_at_trivial_match_arm_list(
     //     $0
     // }
     if let Some(last_arm) = match_arm_list.arms().last() {
-        let last_arm_range = ctx.sema.original_range_opt(last_arm.syntax())?.range;
+        let last_node = match last_arm.expr() {
+            Some(expr) => expr.syntax().clone(),
+            None => last_arm.syntax().clone(),
+        };
+        let last_node_range = ctx.sema.original_range_opt(&last_node)?.range;
         let match_expr_range = ctx.sema.original_range_opt(match_expr.syntax())?.range;
-        if last_arm_range.end() <= ctx.offset() && ctx.offset() < match_expr_range.end() {
+        if last_node_range.end() <= ctx.offset() && ctx.offset() < match_expr_range.end() {
             cov_mark::hit!(add_missing_match_arms_end_of_last_arm);
             return Some(());
         }
+
+        if ast::Expr::cast(last_node.clone()).is_some_and(is_empty_expr)
+            && last_node_range.contains(ctx.offset())
+            && !last_node.text().contains_char('\n')
+        {
+            cov_mark::hit!(add_missing_match_arms_end_of_last_empty_arm);
+            return Some(());
+        }
     }
 
     // match { _$0 => {...} }
@@ -371,6 +376,14 @@ fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
     !existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
 }
 
+fn is_empty_expr(e: ast::Expr) -> bool {
+    match e {
+        ast::Expr::BlockExpr(b) => b.statements().next().is_none() && b.tail_expr().is_none(),
+        ast::Expr::TupleExpr(t) => t.fields().next().is_none(),
+        _ => false,
+    }
+}
+
 // Fixme: this is still somewhat limited, use hir_ty::diagnostics::match_check?
 fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
     match (pat, var) {
@@ -1066,7 +1079,7 @@ fn main() {
 
     #[test]
     fn add_missing_match_arms_end_of_last_arm() {
-        cov_mark::check!(add_missing_match_arms_end_of_last_arm);
+        cov_mark::check_count!(add_missing_match_arms_end_of_last_arm, 2);
         check_assist(
             add_missing_match_arms,
             r#"
@@ -1095,6 +1108,103 @@ fn main() {
         (A::Two, B::Two) => ${3:todo!()},$0
     }
 }
+"#,
+        );
+
+        check_assist(
+            add_missing_match_arms,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => 2$0,
+    }
+}
+"#,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => 2,
+        (A::One, B::One) => ${1:todo!()},
+        (A::One, B::Two) => ${2:todo!()},
+        (A::Two, B::Two) => ${3:todo!()},$0
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn add_missing_match_arms_end_of_last_empty_arm() {
+        cov_mark::check_count!(add_missing_match_arms_end_of_last_empty_arm, 2);
+        check_assist(
+            add_missing_match_arms,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => {$0}
+    }
+}
+"#,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => {}
+        (A::One, B::One) => ${1:todo!()},
+        (A::One, B::Two) => ${2:todo!()},
+        (A::Two, B::Two) => ${3:todo!()},$0
+    }
+}
+"#,
+        );
+
+        check_assist(
+            add_missing_match_arms,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => ($0)
+    }
+}
+"#,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => (),
+        (A::One, B::One) => ${1:todo!()},
+        (A::One, B::Two) => ${2:todo!()},
+        (A::Two, B::Two) => ${3:todo!()},$0
+    }
+}
 "#,
         );
     }

From 72cdae7d7e16511faf0e5a2df87c6495a0fd796c Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Sun, 15 Mar 2026 12:54:54 +0100
Subject: [PATCH 0499/1059] add candidate preference reason

---
 .../src/solve/candidate-preference.md         | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
index 461523424b3c..22ec3162b73f 100644
--- a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
+++ b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
@@ -454,6 +454,30 @@ where
 }
 ```
 
+#### Trait definition cannot use associated types from always applicable impls
+
+The `T: Trait` assumption in the trait definition prevents it from normalizing
+`<Self as Trait>::Assoc` to `T` by using the blanket impl. This feels like a somewhat
+desirable constraint, if not incredibly so.
+
+```rust
+trait Eq<T> {}
+impl<T> Eq<T> for T {}
+struct IsEqual<T: Eq<U>, U>(T, U);
+
+trait Trait: Sized {
+    type Assoc;
+    fn foo() -> IsEqual<Self, Self::Assoc> {
+        //~^ ERROR the trait bound `Self: Eq<<Self as Trait>::Assoc>` is not satisfied
+        todo!()
+    }
+}
+
+impl<T> Trait for T {
+    type Assoc = T;
+}
+```
+
 [`Candidate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_next_trait_solver/solve/assembly/struct.Candidate.html
 [`CandidateSource`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_next_trait_solver/solve/enum.CandidateSource.html
 [`fn merge_trait_candidates`]: https://github.com/rust-lang/rust/blob/e3ee7f7aea5b45af3b42b5e4713da43876a65ac9/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs#L1342-L1424

From 823517c41c9df058612f5da8db9dafc8d46e05cc Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sun, 15 Mar 2026 21:12:28 +0800
Subject: [PATCH 0500/1059] compiletest: show rustdoc logs when `--no-capture`

---
 src/tools/compiletest/src/runtest/rustdoc_json.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/tools/compiletest/src/runtest/rustdoc_json.rs b/src/tools/compiletest/src/runtest/rustdoc_json.rs
index 89e9f3168837..d6afb77c2e8d 100644
--- a/src/tools/compiletest/src/runtest/rustdoc_json.rs
+++ b/src/tools/compiletest/src/runtest/rustdoc_json.rs
@@ -14,6 +14,11 @@ pub(super) fn run_rustdoc_json_test(&self) {
         });
 
         let proc_res = self.document(&out_dir, DocKind::Json);
+
+        if !self.config.capture {
+            writeln!(self.stdout, "{}", proc_res.format_info());
+        }
+
         if !proc_res.status.success() {
             self.fatal_proc_rec("rustdoc failed!", &proc_res);
         }

From c7220f423b335974509b603b8e1dcbb08a92184d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 3 Mar 2026 12:35:41 +0100
Subject: [PATCH 0501/1059] rename min/maxnum intrinsics to min/maximum_number
 and fix their LLVM lowering

---
 .../src/intrinsics/mod.rs                     | 16 ++--
 compiler/rustc_codegen_cranelift/src/num.rs   |  8 +-
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    | 10 ---
 compiler/rustc_codegen_llvm/src/intrinsic.rs  | 36 +++++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  1 +
 .../src/interpret/intrinsics.rs               | 50 +++++------
 .../src/interpret/intrinsics/simd.rs          | 12 +--
 .../rustc_hir_analysis/src/check/intrinsic.rs | 36 ++++----
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  7 ++
 compiler/rustc_span/src/symbol.rs             | 16 ++--
 library/core/src/intrinsics/mod.rs            | 88 +++++++++++++++++--
 library/core/src/num/f128.rs                  |  4 +-
 library/core/src/num/f16.rs                   |  4 +-
 library/core/src/num/f32.rs                   |  4 +-
 library/core/src/num/f64.rs                   |  4 +-
 library/coretests/tests/floats/mod.rs         | 53 +++++++++--
 src/tools/miri/tests/pass/float.rs            | 33 +++----
 src/tools/miri/tests/pass/float_nan.rs        |  6 ++
 .../miri/tests/pass/intrinsics/intrinsics.rs  | 19 ++--
 tests/ui/float/minmax.rs                      | 22 +++++
 tests/ui/simd/intrinsic/float-minmax-pass.rs  |  2 +
 21 files changed, 290 insertions(+), 141 deletions(-)
 create mode 100644 tests/ui/float/minmax.rs

diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index da8569dac746..063bc5db959c 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -1266,7 +1266,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             ret.write_cvalue(fx, val);
         }
 
-        sym::minnumf16 => {
+        sym::minimum_number_nsz_f16 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1275,7 +1275,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f16));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf32 => {
+        sym::minimum_number_nsz_f32 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1284,7 +1284,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f32));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf64 => {
+        sym::minimum_number_nsz_f64 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1293,7 +1293,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f64));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf128 => {
+        sym::minimum_number_nsz_f128 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1302,7 +1302,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f128));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf16 => {
+        sym::maximum_number_nsz_f16 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1311,7 +1311,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f16));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf32 => {
+        sym::maximum_number_nsz_f32 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1320,7 +1320,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f32));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf64 => {
+        sym::maximum_number_nsz_f64 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1329,7 +1329,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f64));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf128 => {
+        sym::maximum_number_nsz_f128 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
diff --git a/compiler/rustc_codegen_cranelift/src/num.rs b/compiler/rustc_codegen_cranelift/src/num.rs
index 95d44dfb6d95..0459644e16aa 100644
--- a/compiler/rustc_codegen_cranelift/src/num.rs
+++ b/compiler/rustc_codegen_cranelift/src/num.rs
@@ -498,10 +498,10 @@ fn codegen_ptr_binop<'tcx>(
     }
 }
 
-// In Rust floating point min and max don't propagate NaN. In Cranelift they do however.
-// For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for `minnumf*`
-// and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by comparing
-// a float against itself. Only in case of NaN is it not equal to itself.
+// In Rust floating point min and max don't propagate NaN (not even SNaN). In Cranelift they do
+// however. For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for
+// `minnumf*` and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by
+// comparing a float against itself. Only in case of NaN is it not equal to itself.
 pub(crate) fn codegen_float_min(fx: &mut FunctionCx<'_, '_, '_>, a: Value, b: Value) -> Value {
     // FIXME(bytecodealliance/wasmtime#8312): Replace with Cranelift `fcmp` once
     // `f16`/`f128` backend lowerings have been added to Cranelift.
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 046a08c3df0d..6d2e90807ca5 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -72,8 +72,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         sym::fmuladdf64 => "fma",  // TODO: use gcc intrinsic analogous to llvm.fmuladd.f64
         sym::fabsf32 => "fabsf",
         sym::fabsf64 => "fabs",
-        sym::minnumf32 => "fminf",
-        sym::minnumf64 => "fmin",
         sym::minimumf32 => "fminimumf",
         sym::minimumf64 => "fminimum",
         sym::minimumf128 => {
@@ -92,8 +90,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
                 false,
             ));
         }
-        sym::maxnumf32 => "fmaxf",
-        sym::maxnumf64 => "fmax",
         sym::maximumf32 => "fmaximumf",
         sym::maximumf64 => "fmaximum",
         sym::maximumf128 => {
@@ -236,8 +232,6 @@ fn get_simple_function_f128_2args<'gcc, 'tcx>(
 
     let f128_type = cx.type_f128();
     let func_name = match name {
-        sym::maxnumf128 => "fmaxf128",
-        sym::minnumf128 => "fminf128",
         sym::copysignf128 => "copysignf128",
         _ => return None,
     };
@@ -266,8 +260,6 @@ fn f16_builtin<'gcc, 'tcx>(
         sym::fabsf16 => "fabsf",
         sym::floorf16 => "__builtin_floorf",
         sym::fmaf16 => "fmaf",
-        sym::maxnumf16 => "__builtin_fmaxf",
-        sym::minnumf16 => "__builtin_fminf",
         sym::powf16 => "__builtin_powf",
         sym::powif16 => {
             let func = cx.context.get_builtin_function("__builtin_powif");
@@ -333,8 +325,6 @@ fn codegen_intrinsic_call(
             | sym::fabsf16
             | sym::floorf16
             | sym::fmaf16
-            | sym::maxnumf16
-            | sym::minnumf16
             | sym::powf16
             | sym::powif16
             | sym::roundf16
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index bd90f596eb3f..cc6ecee60b0e 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -112,11 +112,6 @@ fn call_simple_intrinsic<'ll, 'tcx>(
         sym::fabsf64 => ("llvm.fabs", &[bx.type_f64()]),
         sym::fabsf128 => ("llvm.fabs", &[bx.type_f128()]),
 
-        sym::minnumf16 => ("llvm.minnum", &[bx.type_f16()]),
-        sym::minnumf32 => ("llvm.minnum", &[bx.type_f32()]),
-        sym::minnumf64 => ("llvm.minnum", &[bx.type_f64()]),
-        sym::minnumf128 => ("llvm.minnum", &[bx.type_f128()]),
-
         // FIXME: LLVM currently mis-compile those intrinsics, re-enable them
         // when llvm/llvm-project#{139380,139381,140445} are fixed.
         //sym::minimumf16 => ("llvm.minimum", &[bx.type_f16()]),
@@ -124,11 +119,6 @@ fn call_simple_intrinsic<'ll, 'tcx>(
         //sym::minimumf64 => ("llvm.minimum", &[bx.type_f64()]),
         //sym::minimumf128 => ("llvm.minimum", &[cx.type_f128()]),
         //
-        sym::maxnumf16 => ("llvm.maxnum", &[bx.type_f16()]),
-        sym::maxnumf32 => ("llvm.maxnum", &[bx.type_f32()]),
-        sym::maxnumf64 => ("llvm.maxnum", &[bx.type_f64()]),
-        sym::maxnumf128 => ("llvm.maxnum", &[bx.type_f128()]),
-
         // FIXME: LLVM currently mis-compile those intrinsics, re-enable them
         // when llvm/llvm-project#{139380,139381,140445} are fixed.
         //sym::maximumf16 => ("llvm.maximum", &[bx.type_f16()]),
@@ -195,6 +185,32 @@ fn codegen_intrinsic_call(
         let simple = call_simple_intrinsic(self, name, args);
         let llval = match name {
             _ if simple.is_some() => simple.unwrap(),
+            sym::minimum_number_nsz_f16
+            | sym::minimum_number_nsz_f32
+            | sym::minimum_number_nsz_f64
+            | sym::minimum_number_nsz_f128
+            | sym::maximum_number_nsz_f16
+            | sym::maximum_number_nsz_f32
+            | sym::maximum_number_nsz_f64
+            | sym::maximum_number_nsz_f128
+                // Need at least LLVM 22 for `min/maximumnum` to not crash LLVM.
+                if crate::llvm_util::get_version() >= (22, 0, 0) =>
+            {
+                let intrinsic_name = if name.as_str().starts_with("min") {
+                    "llvm.minimumnum"
+                } else {
+                    "llvm.maximumnum"
+                };
+                let call = self.call_intrinsic(
+                    intrinsic_name,
+                    &[args[0].layout.immediate_llvm_type(self.cx)],
+                    &[args[0].immediate(), args[1].immediate()],
+                );
+                // `nsz` on minimumnum/maximumnum is special: its only effect is to make
+                // signed-zero ordering non-deterministic.
+                unsafe { llvm::LLVMRustSetNoSignedZeros(call) };
+                call
+            }
             sym::ptr_mask => {
                 let ptr = args[0].immediate();
                 self.call_intrinsic(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index f9af42494cad..77438472644f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2045,6 +2045,7 @@ pub(crate) fn LLVMRustAddCallSiteAttributes<'a>(
     pub(crate) fn LLVMRustSetFastMath(Instr: &Value);
     pub(crate) fn LLVMRustSetAlgebraicMath(Instr: &Value);
     pub(crate) fn LLVMRustSetAllowReassoc(Instr: &Value);
+    pub(crate) fn LLVMRustSetNoSignedZeros(Instr: &Value);
 
     // Miscellaneous instructions
     pub(crate) fn LLVMRustBuildMemCpy<'a>(
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 7f7c69adf4f8..d5f69d78ea6a 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -40,20 +40,20 @@ pub(crate) enum MinMax {
     /// In particular, `-0.0` is considered smaller than `+0.0` and
     /// if either input is NaN, the result is NaN.
     Minimum,
-    /// The IEEE-2008 `minNum` operation with the SNaN handling of the
-    /// IEEE-2019 `minimumNumber` operation - see `f32::min` etc.
+    /// The IEEE-2019 `minimumNumber` operation but with non-deterministic signed zero handling
+    /// (like in IEEE-2008 `minNum`) - see `f32::min` etc.
     /// In particular, if the inputs are `-0.0` and `+0.0`, the result is non-deterministic,
     /// and if one argument is NaN (quiet or signaling), the other one is returned.
-    MinimumNumber,
+    MinimumNumberNsz,
     /// The IEEE-2019 `maximum` operation - see `f32::maximum` etc.
     /// In particular, `-0.0` is considered smaller than `+0.0` and
     /// if either input is NaN, the result is NaN.
     Maximum,
-    /// The IEEE-2008 `maxNum` operation with the SNaN handling of the
-    /// IEEE-2019 `maximumNumber` operation - see `f32::max` etc.
+    /// The IEEE-2019 `maximumNumber` operation but with non-deterministic signed zero handling
+    /// (like in IEEE-2008 `maxNum`) - see `f32::max` etc.
     /// In particular, if the inputs are `-0.0` and `+0.0`, the result is non-deterministic,
     /// and if one argument is NaN (quiet or signaling), the other one is returned.
-    MaximumNumber,
+    MaximumNumberNsz,
 }
 
 /// Directly returns an `Allocation` containing an absolute path representation of the given type.
@@ -526,17 +526,17 @@ pub fn eval_intrinsic(
                 self.write_scalar(Scalar::from_target_usize(align.bytes(), self), dest)?;
             }
 
-            sym::minnumf16 => {
-                self.float_minmax_intrinsic::<Half>(args, MinMax::MinimumNumber, dest)?
+            sym::minimum_number_nsz_f16 => {
+                self.float_minmax_intrinsic::<Half>(args, MinMax::MinimumNumberNsz, dest)?
             }
-            sym::minnumf32 => {
-                self.float_minmax_intrinsic::<Single>(args, MinMax::MinimumNumber, dest)?
+            sym::minimum_number_nsz_f32 => {
+                self.float_minmax_intrinsic::<Single>(args, MinMax::MinimumNumberNsz, dest)?
             }
-            sym::minnumf64 => {
-                self.float_minmax_intrinsic::<Double>(args, MinMax::MinimumNumber, dest)?
+            sym::minimum_number_nsz_f64 => {
+                self.float_minmax_intrinsic::<Double>(args, MinMax::MinimumNumberNsz, dest)?
             }
-            sym::minnumf128 => {
-                self.float_minmax_intrinsic::<Quad>(args, MinMax::MinimumNumber, dest)?
+            sym::minimum_number_nsz_f128 => {
+                self.float_minmax_intrinsic::<Quad>(args, MinMax::MinimumNumberNsz, dest)?
             }
 
             sym::minimumf16 => self.float_minmax_intrinsic::<Half>(args, MinMax::Minimum, dest)?,
@@ -548,17 +548,17 @@ pub fn eval_intrinsic(
             }
             sym::minimumf128 => self.float_minmax_intrinsic::<Quad>(args, MinMax::Minimum, dest)?,
 
-            sym::maxnumf16 => {
-                self.float_minmax_intrinsic::<Half>(args, MinMax::MaximumNumber, dest)?
+            sym::maximum_number_nsz_f16 => {
+                self.float_minmax_intrinsic::<Half>(args, MinMax::MaximumNumberNsz, dest)?
             }
-            sym::maxnumf32 => {
-                self.float_minmax_intrinsic::<Single>(args, MinMax::MaximumNumber, dest)?
+            sym::maximum_number_nsz_f32 => {
+                self.float_minmax_intrinsic::<Single>(args, MinMax::MaximumNumberNsz, dest)?
             }
-            sym::maxnumf64 => {
-                self.float_minmax_intrinsic::<Double>(args, MinMax::MaximumNumber, dest)?
+            sym::maximum_number_nsz_f64 => {
+                self.float_minmax_intrinsic::<Double>(args, MinMax::MaximumNumberNsz, dest)?
             }
-            sym::maxnumf128 => {
-                self.float_minmax_intrinsic::<Quad>(args, MinMax::MaximumNumber, dest)?
+            sym::maximum_number_nsz_f128 => {
+                self.float_minmax_intrinsic::<Quad>(args, MinMax::MaximumNumberNsz, dest)?
             }
 
             sym::maximumf16 => self.float_minmax_intrinsic::<Half>(args, MinMax::Maximum, dest)?,
@@ -1031,16 +1031,16 @@ fn float_minmax<F>(
     {
         let a: F = a.to_float()?;
         let b: F = b.to_float()?;
-        let res = if matches!(op, MinMax::MinimumNumber | MinMax::MaximumNumber) && a == b {
+        let res = if matches!(op, MinMax::MinimumNumberNsz | MinMax::MaximumNumberNsz) && a == b {
             // They are definitely not NaN (those are never equal), but they could be `+0` and `-0`.
             // Let the machine decide which one to return.
             M::equal_float_min_max(self, a, b)
         } else {
             let result = match op {
                 MinMax::Minimum => a.minimum(b),
-                MinMax::MinimumNumber => a.min(b),
+                MinMax::MinimumNumberNsz => a.min(b),
                 MinMax::Maximum => a.maximum(b),
-                MinMax::MaximumNumber => a.max(b),
+                MinMax::MaximumNumberNsz => a.max(b),
             };
             self.adjust_nan(result, &[a, b])
         };
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
index dc6841bb89dd..c47c512025c0 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
@@ -211,8 +211,8 @@ enum Op {
                     sym::simd_le => Op::MirOp(BinOp::Le),
                     sym::simd_gt => Op::MirOp(BinOp::Gt),
                     sym::simd_ge => Op::MirOp(BinOp::Ge),
-                    sym::simd_fmax => Op::FMinMax(MinMax::MaximumNumber),
-                    sym::simd_fmin => Op::FMinMax(MinMax::MinimumNumber),
+                    sym::simd_fmax => Op::FMinMax(MinMax::MaximumNumberNsz),
+                    sym::simd_fmin => Op::FMinMax(MinMax::MinimumNumberNsz),
                     sym::simd_saturating_add => Op::SaturatingOp(BinOp::Add),
                     sym::simd_saturating_sub => Op::SaturatingOp(BinOp::Sub),
                     sym::simd_arith_offset => Op::WrappingOffset,
@@ -304,8 +304,8 @@ enum Op {
                     sym::simd_reduce_xor => Op::MirOp(BinOp::BitXor),
                     sym::simd_reduce_any => Op::MirOpBool(BinOp::BitOr),
                     sym::simd_reduce_all => Op::MirOpBool(BinOp::BitAnd),
-                    sym::simd_reduce_max => Op::MinMax(MinMax::MaximumNumber),
-                    sym::simd_reduce_min => Op::MinMax(MinMax::MinimumNumber),
+                    sym::simd_reduce_max => Op::MinMax(MinMax::MaximumNumberNsz),
+                    sym::simd_reduce_min => Op::MinMax(MinMax::MinimumNumberNsz),
                     _ => unreachable!(),
                 };
 
@@ -329,8 +329,8 @@ enum Op {
                             } else {
                                 // Just boring integers, no NaNs to worry about.
                                 let mirop = match mmop {
-                                    MinMax::MinimumNumber | MinMax::Minimum => BinOp::Le,
-                                    MinMax::MaximumNumber | MinMax::Maximum => BinOp::Ge,
+                                    MinMax::MinimumNumberNsz | MinMax::Minimum => BinOp::Le,
+                                    MinMax::MaximumNumberNsz | MinMax::Maximum => BinOp::Ge,
                                 };
                                 if self.binary_op(mirop, &res, &op)?.to_scalar().to_bool()? {
                                     res
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index a1c8c0150a66..47420997a509 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -147,22 +147,22 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::logf32
         | sym::logf64
         | sym::logf128
+        | sym::maximum_number_nsz_f16
+        | sym::maximum_number_nsz_f32
+        | sym::maximum_number_nsz_f64
+        | sym::maximum_number_nsz_f128
         | sym::maximumf16
         | sym::maximumf32
         | sym::maximumf64
         | sym::maximumf128
-        | sym::maxnumf16
-        | sym::maxnumf32
-        | sym::maxnumf64
-        | sym::maxnumf128
+        | sym::minimum_number_nsz_f16
+        | sym::minimum_number_nsz_f32
+        | sym::minimum_number_nsz_f64
+        | sym::minimum_number_nsz_f128
         | sym::minimumf16
         | sym::minimumf32
         | sym::minimumf64
         | sym::minimumf128
-        | sym::minnumf16
-        | sym::minnumf32
-        | sym::minnumf64
-        | sym::minnumf128
         | sym::mul_with_overflow
         | sym::needs_drop
         | sym::offload
@@ -468,20 +468,24 @@ pub(crate) fn check_intrinsic_type(
         sym::fabsf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),
         sym::fabsf128 => (0, 0, vec![tcx.types.f128], tcx.types.f128),
 
-        sym::minnumf16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
-        sym::minnumf32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
-        sym::minnumf64 => (0, 0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
-        sym::minnumf128 => (0, 0, vec![tcx.types.f128, tcx.types.f128], tcx.types.f128),
+        sym::minimum_number_nsz_f16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
+        sym::minimum_number_nsz_f32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
+        sym::minimum_number_nsz_f64 => (0, 0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
+        sym::minimum_number_nsz_f128 => {
+            (0, 0, vec![tcx.types.f128, tcx.types.f128], tcx.types.f128)
+        }
 
         sym::minimumf16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
         sym::minimumf32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
         sym::minimumf64 => (0, 0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
         sym::minimumf128 => (0, 0, vec![tcx.types.f128, tcx.types.f128], tcx.types.f128),
 
-        sym::maxnumf16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
-        sym::maxnumf32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
-        sym::maxnumf64 => (0, 0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
-        sym::maxnumf128 => (0, 0, vec![tcx.types.f128, tcx.types.f128], tcx.types.f128),
+        sym::maximum_number_nsz_f16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
+        sym::maximum_number_nsz_f32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
+        sym::maximum_number_nsz_f64 => (0, 0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
+        sym::maximum_number_nsz_f128 => {
+            (0, 0, vec![tcx.types.f128, tcx.types.f128], tcx.types.f128)
+        }
 
         sym::maximumf16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
         sym::maximumf32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 16796541d4fd..63ff0b2a0a0d 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -712,6 +712,13 @@ extern "C" void LLVMRustSetAllowReassoc(LLVMValueRef V) {
   }
 }
 
+// Enable the NSZ flag on the given instruction.
+extern "C" void LLVMRustSetNoSignedZeros(LLVMValueRef V) {
+  if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
+    I->setHasNoSignedZeros(true);
+  }
+}
+
 extern "C" uint64_t LLVMRustGetArrayNumElements(LLVMTypeRef Ty) {
   return unwrap(Ty)->getArrayNumElements();
 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cd437357456e..26ced79b822a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1209,14 +1209,14 @@
         masked,
         match_beginning_vert,
         match_default_bindings,
+        maximum_number_nsz_f16,
+        maximum_number_nsz_f32,
+        maximum_number_nsz_f64,
+        maximum_number_nsz_f128,
         maximumf16,
         maximumf32,
         maximumf64,
         maximumf128,
-        maxnumf16,
-        maxnumf32,
-        maxnumf64,
-        maxnumf128,
         may_dangle,
         may_unwind,
         maybe_dangling,
@@ -1247,14 +1247,14 @@
         min_generic_const_args,
         min_specialization,
         min_type_alias_impl_trait,
+        minimum_number_nsz_f16,
+        minimum_number_nsz_f32,
+        minimum_number_nsz_f64,
+        minimum_number_nsz_f128,
         minimumf16,
         minimumf32,
         minimumf64,
         minimumf128,
-        minnumf16,
-        minnumf32,
-        minnumf64,
-        minnumf128,
         mips,
         mips32r6,
         mips64,
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 7e9adc1e8d57..68e4f1c2aa78 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2987,6 +2987,8 @@ pub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M)
 
 /// Returns the minimum of two `f16` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 minimumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -2999,10 +3001,19 @@ pub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M)
 /// The stabilized version of this intrinsic is [`f16::min`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn minnumf16(x: f16, y: f16) -> f16;
+pub const fn minimum_number_nsz_f16(x: f16, y: f16) -> f16 {
+    if x.is_nan() || y <= x {
+        y
+    } else {
+        // Either y > x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the minimum of two `f32` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 minimumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3016,10 +3027,19 @@ pub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M)
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn minnumf32(x: f32, y: f32) -> f32;
+pub const fn minimum_number_nsz_f32(x: f32, y: f32) -> f32 {
+    if x.is_nan() || y <= x {
+        y
+    } else {
+        // Either y > x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the minimum of two `f64` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 minimumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3033,10 +3053,19 @@ pub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M)
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn minnumf64(x: f64, y: f64) -> f64;
+pub const fn minimum_number_nsz_f64(x: f64, y: f64) -> f64 {
+    if x.is_nan() || y <= x {
+        y
+    } else {
+        // Either y > x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the minimum of two `f128` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 minimumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3049,7 +3078,14 @@ pub const fn aggregate_raw_ptr<P: bounds::BuiltinDeref, D, M>(data: D, meta: M)
 /// The stabilized version of this intrinsic is [`f128::min`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn minnumf128(x: f128, y: f128) -> f128;
+pub const fn minimum_number_nsz_f128(x: f128, y: f128) -> f128 {
+    if x.is_nan() || y <= x {
+        y
+    } else {
+        // Either y > x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the minimum of two `f16` values, propagating NaN.
 ///
@@ -3153,6 +3189,8 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 
 /// Returns the maximum of two `f16` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 maximumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3165,10 +3203,19 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 /// The stabilized version of this intrinsic is [`f16::max`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn maxnumf16(x: f16, y: f16) -> f16;
+pub const fn maximum_number_nsz_f16(x: f16, y: f16) -> f16 {
+    if x.is_nan() || y >= x {
+        y
+    } else {
+        // Either y < x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the maximum of two `f32` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 maximumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3182,10 +3229,19 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn maxnumf32(x: f32, y: f32) -> f32;
+pub const fn maximum_number_nsz_f32(x: f32, y: f32) -> f32 {
+    if x.is_nan() || y >= x {
+        y
+    } else {
+        // Either y < x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the maximum of two `f64` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 maximumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3199,10 +3255,19 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn maxnumf64(x: f64, y: f64) -> f64;
+pub const fn maximum_number_nsz_f64(x: f64, y: f64) -> f64 {
+    if x.is_nan() || y >= x {
+        y
+    } else {
+        // Either y < x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the maximum of two `f128` values, ignoring NaN.
 ///
+/// This behaves like IEEE 754-2019 maximumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular:
 /// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
 /// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
 /// and `-0.0`), either input may be returned non-deterministically.
@@ -3215,7 +3280,14 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 /// The stabilized version of this intrinsic is [`f128::max`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn maxnumf128(x: f128, y: f128) -> f128;
+pub const fn maximum_number_nsz_f128(x: f128, y: f128) -> f128 {
+    if x.is_nan() || y >= x {
+        y
+    } else {
+        // Either y < x or y is a NaN.
+        x
+    }
+}
 
 /// Returns the maximum of two `f16` values, propagating NaN.
 ///
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 03bc5f20d7e9..68c87b48de94 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -790,7 +790,7 @@ pub const fn to_radians(self) -> f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     pub const fn max(self, other: f128) -> f128 {
-        intrinsics::maxnumf128(self, other)
+        intrinsics::maximum_number_nsz_f128(self, other)
     }
 
     /// Returns the minimum of the two numbers, ignoring NaN.
@@ -821,7 +821,7 @@ pub const fn max(self, other: f128) -> f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     pub const fn min(self, other: f128) -> f128 {
-        intrinsics::minnumf128(self, other)
+        intrinsics::minimum_number_nsz_f128(self, other)
     }
 
     /// Returns the maximum of the two numbers, propagating NaN.
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 1ffaf3b0ce44..3412e49c49cd 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -784,7 +784,7 @@ pub const fn to_radians(self) -> f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     pub const fn max(self, other: f16) -> f16 {
-        intrinsics::maxnumf16(self, other)
+        intrinsics::maximum_number_nsz_f16(self, other)
     }
 
     /// Returns the minimum of the two numbers, ignoring NaN.
@@ -815,7 +815,7 @@ pub const fn max(self, other: f16) -> f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     pub const fn min(self, other: f16) -> f16 {
-        intrinsics::minnumf16(self, other)
+        intrinsics::minimum_number_nsz_f16(self, other)
     }
 
     /// Returns the maximum of the two numbers, propagating NaN.
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index 4f560201196c..e33cb098e4e8 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -990,7 +990,7 @@ pub const fn to_radians(self) -> f32 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn max(self, other: f32) -> f32 {
-        intrinsics::maxnumf32(self, other)
+        intrinsics::maximum_number_nsz_f32(self, other)
     }
 
     /// Returns the minimum of the two numbers, ignoring NaN.
@@ -1017,7 +1017,7 @@ pub const fn max(self, other: f32) -> f32 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn min(self, other: f32) -> f32 {
-        intrinsics::minnumf32(self, other)
+        intrinsics::minimum_number_nsz_f32(self, other)
     }
 
     /// Returns the maximum of the two numbers, propagating NaN.
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 061a73ae5f64..872f567efafd 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1008,7 +1008,7 @@ pub const fn to_radians(self) -> f64 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn max(self, other: f64) -> f64 {
-        intrinsics::maxnumf64(self, other)
+        intrinsics::maximum_number_nsz_f64(self, other)
     }
 
     /// Returns the minimum of the two numbers, ignoring NaN.
@@ -1035,7 +1035,7 @@ pub const fn max(self, other: f64) -> f64 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn min(self, other: f64) -> f64 {
-        intrinsics::minnumf64(self, other)
+        intrinsics::minimum_number_nsz_f64(self, other)
     }
 
     /// Returns the maximum of the two numbers, propagating NaN.
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 3e39528dfbf4..c9bbff266d90 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1,3 +1,4 @@
+use std::hint::black_box;
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
@@ -32,7 +33,7 @@ trait TestableFloat: Sized {
     const LNGAMMA_APPROX_LOOSE: Self = Self::APPROX;
     const ZERO: Self;
     const ONE: Self;
-
+    const SNAN: Self;
     const MIN_POSITIVE_NORMAL: Self;
     const MAX_SUBNORMAL: Self;
     /// Smallest number
@@ -82,6 +83,9 @@ impl TestableFloat for f16 {
     const LNGAMMA_APPROX_LOOSE: Self = 1e-1;
     const ZERO: Self = 0.0;
     const ONE: Self = 1.0;
+    // We rely on NAN having an all-0 payload, so the signaling bit is the least significant
+    // non-0 bit, and that gets toggled by the "-1".
+    const SNAN: Self = Self::from_bits(Self::NAN.to_bits() - 1);
     const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
     const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
     const TINY: Self = Self::from_bits(0x1);
@@ -125,6 +129,9 @@ impl TestableFloat for f32 {
     const LNGAMMA_APPROX_LOOSE: Self = if cfg!(miri) { 1e-2 } else { 1e-4 };
     const ZERO: Self = 0.0;
     const ONE: Self = 1.0;
+    // We rely on NAN having an all-0 payload, so the signaling bit is the least significant
+    // non-0 bit, and that gets toggled by the "-1".
+    const SNAN: Self = Self::from_bits(Self::NAN.to_bits() - 1);
     const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
     const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
     const TINY: Self = Self::from_bits(0x1);
@@ -153,6 +160,9 @@ impl TestableFloat for f64 {
     const LNGAMMA_APPROX_LOOSE: Self = 1e-4;
     const ZERO: Self = 0.0;
     const ONE: Self = 1.0;
+    // We rely on NAN having an all-0 payload, so the signaling bit is the least significant
+    // non-0 bit, and that gets toggled by the "-1".
+    const SNAN: Self = Self::from_bits(Self::NAN.to_bits() - 1);
     const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
     const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
     const TINY: Self = Self::from_bits(0x1);
@@ -191,6 +201,9 @@ impl TestableFloat for f128 {
     const LNGAMMA_APPROX_LOOSE: Self = 1e-10;
     const ZERO: Self = 0.0;
     const ONE: Self = 1.0;
+    // We rely on NAN having an all-0 payload, so the signaling bit is the least significant
+    // non-0 bit, and that gets toggled by the "-1".
+    const SNAN: Self = Self::from_bits(Self::NAN.to_bits() - 1);
     const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
     const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
     const TINY: Self = Self::from_bits(0x1);
@@ -668,11 +681,22 @@ const fn flt (x: Float) -> Float { x }
         assert_biteq!(flt(9.0).min(Float::NEG_INFINITY), Float::NEG_INFINITY);
         assert_biteq!(Float::NEG_INFINITY.min(-9.0), Float::NEG_INFINITY);
         assert_biteq!(flt(-9.0).min(Float::NEG_INFINITY), Float::NEG_INFINITY);
-        assert_biteq!(Float::NAN.min(9.0), 9.0);
-        assert_biteq!(Float::NAN.min(-9.0), -9.0);
-        assert_biteq!(flt(9.0).min(Float::NAN), 9.0);
-        assert_biteq!(flt(-9.0).min(Float::NAN), -9.0);
+        // We add black_box for the NAN tests as that used to be able to trigger miscompilations.
+        assert_biteq!(Float::NAN.min(black_box(9.0)), 9.0);
+        assert_biteq!(black_box(Float::NAN).min(-9.0), -9.0);
+        assert_biteq!(flt(9.0).min(black_box(Float::NAN)), 9.0);
+        assert_biteq!(black_box(flt(-9.0)).min(Float::NAN), -9.0);
         assert!(Float::NAN.min(Float::NAN).is_nan());
+        // FIXME(llvm21): LLVM miscompiles the fallback impl on aarch64 and likely other targets
+        // (https://github.com/llvm/llvm-project/issues/176624). When we require LLVM 22,
+        // remove the ui test `tests/ui/float/minmax.rs` and unconditionally enable the test here.
+        if cfg!(miri) {
+            assert_biteq!(Float::SNAN.min(black_box(9.0)), 9.0);
+            assert_biteq!(black_box(Float::SNAN).min(-9.0), -9.0);
+            assert_biteq!(flt(9.0).min(black_box(Float::SNAN)), 9.0);
+            assert_biteq!(black_box(flt(-9.0)).min(Float::SNAN), -9.0);
+        }
+        assert!(Float::SNAN.min(Float::SNAN).is_nan());
     }
 }
 
@@ -699,11 +723,22 @@ const fn flt (x: Float) -> Float { x }
         assert_biteq!(flt(9.0).max(Float::NEG_INFINITY), 9.0);
         assert_biteq!(Float::NEG_INFINITY.max(-9.0), -9.0);
         assert_biteq!(flt(-9.0).max(Float::NEG_INFINITY), -9.0);
-        assert_biteq!(Float::NAN.max(9.0), 9.0);
-        assert_biteq!(Float::NAN.max(-9.0), -9.0);
-        assert_biteq!(flt(9.0).max(Float::NAN), 9.0);
-        assert_biteq!(flt(-9.0).max(Float::NAN), -9.0);
+        // We add black_box for the NAN tests as that used to be able to trigger miscompilations.
+        assert_biteq!(Float::NAN.max(black_box(9.0)), 9.0);
+        assert_biteq!(black_box(Float::NAN).max(-9.0), -9.0);
+        assert_biteq!(flt(9.0).max(black_box(Float::NAN)), 9.0);
+        assert_biteq!(black_box(flt(-9.0)).max(Float::NAN), -9.0);
         assert!(Float::NAN.max(Float::NAN).is_nan());
+        // FIXME(llvm21): LLVM miscompiles the fallback impl on aarch64 and likely other targets
+        // (https://github.com/llvm/llvm-project/issues/176624). When we require LLVM 22,
+        // remove the ui test `tests/ui/float/minmax.rs` and unconditionally enable the test here.
+        if cfg!(miri) {
+            assert_biteq!(Float::SNAN.max(black_box(9.0)), 9.0);
+            assert_biteq!(black_box(Float::SNAN).max(-9.0), -9.0);
+            assert_biteq!(flt(9.0).max(black_box(Float::SNAN)), 9.0);
+            assert_biteq!(black_box(flt(-9.0)).max(Float::SNAN), -9.0);
+        }
+        assert!(Float::SNAN.max(Float::SNAN).is_nan());
     }
 }
 
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 052c83d1aa31..184854774cc9 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -8,14 +8,14 @@
 #![allow(internal_features)]
 #![allow(unnecessary_transmutes)]
 
-#[path = "../utils/mod.rs"]
-mod utils;
 use std::any::type_name;
 use std::cmp::min;
 use std::fmt::{Debug, Display, LowerHex};
 use std::hint::black_box;
 use std::{f32, f64};
 
+#[path = "../utils/mod.rs"]
+mod utils;
 use utils::check_nondet;
 
 /// Compare the two floats, allowing for $ulp many ULPs of error.
@@ -70,7 +70,6 @@ fn main() {
     test_fast();
     test_algebraic();
     test_fmuladd();
-    test_min_max_nondet();
     test_non_determinism();
 }
 
@@ -1425,19 +1424,13 @@ fn test_operations_f64(a: f64, b: f64, c: f64) {
     test_operations_f64(1.1, 1.2, 1.3);
 }
 
-/// `min` and `max` on equal arguments are non-deterministic.
-fn test_min_max_nondet() {
-    check_nondet(|| f16::min(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f16::max(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f32::min(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f32::max(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f64::min(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f64::max(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f128::min(0.0, -0.0).is_sign_positive());
-    check_nondet(|| f128::max(0.0, -0.0).is_sign_positive());
-}
-
 fn test_non_determinism() {
+    if cfg!(force_intrinsic_fallback) {
+        // Skip this test when we use the fallback bodies, as that one is deterministic.
+        // (CI sets `--cfg force_intrinsic_fallback` together with `-Zmiri-force-intrinsic-fallback`.)
+        return;
+    }
+
     use std::intrinsics::{
         fadd_algebraic, fadd_fast, fdiv_algebraic, fdiv_fast, fmul_algebraic, fmul_fast,
         frem_algebraic, frem_fast, fsub_algebraic, fsub_fast,
@@ -1541,6 +1534,16 @@ fn test_operations_f128(a: f128, b: f128) {
     test_operations_f64(19., 11.);
     test_operations_f128(25., 18.);
 
+    // min/max signed zero nondet
+    check_nondet(|| f16::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f16::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f32::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f32::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f64::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f64::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f128::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f128::max(0.0, -0.0).is_sign_positive());
+
     // SNaN^0 = (1 | NaN)
     check_nondet(|| f32::powf(F32_SNAN, 0.0).is_nan());
     check_nondet(|| f64::powf(F64_SNAN, 0.0).is_nan());
diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index c07ffdf9740c..6b39c2db3587 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -541,6 +541,12 @@ fn test_simd() {
 }
 
 fn main() {
+    if cfg!(force_intrinsic_fallback) {
+        // Skip this test when we use the fallback bodies, as that one is deterministic.
+        // (CI sets `--cfg force_intrinsic_fallback` together with `-Zmiri-force-intrinsic-fallback`.)
+        return;
+    }
+
     // Check our constants against std, just to be sure.
     // We add 1 since our numbers are the number of bits stored
     // to represent the value, and std has the precision of the value,
diff --git a/src/tools/miri/tests/pass/intrinsics/intrinsics.rs b/src/tools/miri/tests/pass/intrinsics/intrinsics.rs
index 913c3cde272d..c6ccadf03188 100644
--- a/src/tools/miri/tests/pass/intrinsics/intrinsics.rs
+++ b/src/tools/miri/tests/pass/intrinsics/intrinsics.rs
@@ -5,6 +5,10 @@
 use std::intrinsics;
 use std::mem::{discriminant, size_of, size_of_val, size_of_val_raw};
 
+#[path = "../../utils/mod.rs"]
+mod utils;
+use utils::check_nondet;
+
 struct Bomb;
 
 impl Drop for Bomb {
@@ -36,20 +40,7 @@ fn main() {
     // Skip this test when we use the fallback bodies, as that one is deterministic.
     // (CI sets `--cfg force_intrinsic_fallback` together with `-Zmiri-force-intrinsic-fallback`.)
     if !cfg!(force_intrinsic_fallback) {
-        let mut saw_true = false;
-        let mut saw_false = false;
-
-        for _ in 0..50 {
-            if intrinsics::is_val_statically_known(0) {
-                saw_true = true;
-            } else {
-                saw_false = true;
-            }
-        }
-        assert!(
-            saw_true && saw_false,
-            "`is_val_statically_known` failed to return both true and false. Congrats, you won the lottery!"
-        );
+        check_nondet(|| intrinsics::is_val_statically_known(0));
     }
 
     intrinsics::forget(Bomb);
diff --git a/tests/ui/float/minmax.rs b/tests/ui/float/minmax.rs
new file mode 100644
index 000000000000..e6bac901d792
--- /dev/null
+++ b/tests/ui/float/minmax.rs
@@ -0,0 +1,22 @@
+//FIXME(llvm21) This should be a library test, but old LLVM miscompiles things so we can't just
+// test this properly everywhere. Once we require LLVM 22, remove this test and enable the
+// commented-out tests in `library/coretests/tests/floats/mod.rs` instead.
+//@ min-llvm-version: 22
+//@ run-pass
+
+use std::hint::black_box;
+
+const SNAN32: f32 = f32::from_bits(f32::NAN.to_bits() - 1);
+const SNAN64: f64 = f64::from_bits(f64::NAN.to_bits() - 1);
+
+fn main() {
+    assert_eq!(SNAN32.min(black_box(9.0)), 9.0f32);
+    assert_eq!(black_box(SNAN32).min(-9.0), -9.0f32);
+    assert_eq!((9.0f32).min(black_box(SNAN32)), 9.0f32);
+    assert_eq!(black_box(-9.0f32).min(SNAN32), -9.0f32);
+
+    assert_eq!(SNAN64.min(black_box(9.0)), 9.0f64);
+    assert_eq!(black_box(SNAN64).min(-9.0), -9.0f64);
+    assert_eq!((9.0f64).min(black_box(SNAN64)), 9.0f64);
+    assert_eq!(black_box(-9.0f64).min(SNAN64), -9.0f64);
+}
diff --git a/tests/ui/simd/intrinsic/float-minmax-pass.rs b/tests/ui/simd/intrinsic/float-minmax-pass.rs
index 4b6a35556ed5..d9dc291de63d 100644
--- a/tests/ui/simd/intrinsic/float-minmax-pass.rs
+++ b/tests/ui/simd/intrinsic/float-minmax-pass.rs
@@ -21,6 +21,8 @@ const fn minmax() {
     let nan = f32::NAN;
     // MIPS hardware except MIPS R6 treats f32::NAN as SNAN. Clear the signaling bit.
     // See https://github.com/rust-lang/rust/issues/52746.
+    // The "-1" works because we rely on `NAN` to have an all-0 payload, so the signaling
+    // bit is the least significant non-zero bit.
     #[cfg(any(target_arch = "mips", target_arch = "mips64"))]
     let nan = f32::from_bits(f32::NAN.to_bits() - 1);
 

From 5030e8119f40ea31e1f2c78719baf39b02d3dd76 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 3 Mar 2026 12:35:41 +0100
Subject: [PATCH 0502/1059] rename min/maxnum intrinsics to min/maximum_number
 and fix their LLVM lowering

---
 src/intrinsics/mod.rs | 16 ++++++++--------
 src/num.rs            |  8 ++++----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/intrinsics/mod.rs b/src/intrinsics/mod.rs
index da8569dac746..063bc5db959c 100644
--- a/src/intrinsics/mod.rs
+++ b/src/intrinsics/mod.rs
@@ -1266,7 +1266,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             ret.write_cvalue(fx, val);
         }
 
-        sym::minnumf16 => {
+        sym::minimum_number_nsz_f16 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1275,7 +1275,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f16));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf32 => {
+        sym::minimum_number_nsz_f32 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1284,7 +1284,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f32));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf64 => {
+        sym::minimum_number_nsz_f64 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1293,7 +1293,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f64));
             ret.write_cvalue(fx, val);
         }
-        sym::minnumf128 => {
+        sym::minimum_number_nsz_f128 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1302,7 +1302,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f128));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf16 => {
+        sym::maximum_number_nsz_f16 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1311,7 +1311,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f16));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf32 => {
+        sym::maximum_number_nsz_f32 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1320,7 +1320,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f32));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf64 => {
+        sym::maximum_number_nsz_f64 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
@@ -1329,7 +1329,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = CValue::by_val(val, fx.layout_of(fx.tcx.types.f64));
             ret.write_cvalue(fx, val);
         }
-        sym::maxnumf128 => {
+        sym::maximum_number_nsz_f128 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
             let b = b.load_scalar(fx);
diff --git a/src/num.rs b/src/num.rs
index 95d44dfb6d95..0459644e16aa 100644
--- a/src/num.rs
+++ b/src/num.rs
@@ -498,10 +498,10 @@ fn codegen_ptr_binop<'tcx>(
     }
 }
 
-// In Rust floating point min and max don't propagate NaN. In Cranelift they do however.
-// For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for `minnumf*`
-// and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by comparing
-// a float against itself. Only in case of NaN is it not equal to itself.
+// In Rust floating point min and max don't propagate NaN (not even SNaN). In Cranelift they do
+// however. For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for
+// `minnumf*` and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by
+// comparing a float against itself. Only in case of NaN is it not equal to itself.
 pub(crate) fn codegen_float_min(fx: &mut FunctionCx<'_, '_, '_>, a: Value, b: Value) -> Value {
     // FIXME(bytecodealliance/wasmtime#8312): Replace with Cranelift `fcmp` once
     // `f16`/`f128` backend lowerings have been added to Cranelift.

From 4831c4924b3a60590f43e117f1e303c0b242f798 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 15 Mar 2026 14:37:11 +0000
Subject: [PATCH 0503/1059] remove usages of to-be-deprecated float consts

---
 src/tools/miri/tests/pass/float.rs            | 100 +++++++++---------
 .../pass/shims/x86/intrinsics-x86-sse.rs      |   3 +-
 .../pass/shims/x86/intrinsics-x86-sse2.rs     |   3 +-
 3 files changed, 56 insertions(+), 50 deletions(-)

diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 7384c2cb0074..a051e6820669 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -7,21 +7,25 @@
 #![allow(arithmetic_overflow)]
 #![allow(internal_features)]
 #![allow(unnecessary_transmutes)]
+#![deny(deprecated_in_future)]
 
 #[path = "../utils/mod.rs"]
 mod utils;
 use std::any::type_name;
 use std::cmp::min;
+use std::f16::consts as f16_consts;
+use std::f32::consts as f32_consts;
+use std::f64::consts as f64_consts;
+use std::f128::consts as f128_consts;
 use std::fmt::{Debug, Display, LowerHex};
 use std::hint::black_box;
-use std::{f16, f32, f64, f128};
 
 use utils::check_nondet;
 
 /// Compare the two floats, allowing for $ulp many ULPs of error.
 ///
 /// ULP means "Units in the Last Place" or "Units of Least Precision".
-/// The ULP of a float `a`` is the smallest possible change at `a`, so the ULP difference represents how
+/// The ULP of a float `a` is the smallest possible change at `a`, so the ULP difference represents how
 /// many discrete floating-point steps are needed to reach the actual value from the expected value.
 ///
 /// Essentially ULP can be seen as a distance metric of floating-point numbers, but with
@@ -1019,10 +1023,10 @@ fn mul_add() {
     assert_eq!(3.0f64.mul_add(2.0f64, 5.0f64), 11.0);
     assert_eq!(3.0f128.mul_add(2.0f128, 5.0f128), 11.0);
 
-    assert_eq!(0.0f16.mul_add(-2.0f16, f16::consts::E), f16::consts::E);
-    assert_eq!(0.0f32.mul_add(-2.0f32, f32::consts::E), f32::consts::E);
-    assert_eq!(0.0f64.mul_add(-2.0f64, f64::consts::E), f64::consts::E);
-    assert_eq!(0.0f128.mul_add(-2.0f128, f128::consts::E), f128::consts::E);
+    assert_eq!(0.0f16.mul_add(-2.0f16, f16_consts::E), f16_consts::E);
+    assert_eq!(0.0f32.mul_add(-2.0f32, f32_consts::E), f32_consts::E);
+    assert_eq!(0.0f64.mul_add(-2.0f64, f64_consts::E), f64_consts::E);
+    assert_eq!(0.0f128.mul_add(-2.0f128, f128_consts::E), f128_consts::E);
 
     assert_eq!((-3.2f16).mul_add(2.4, f16::NEG_INFINITY), f16::NEG_INFINITY);
     assert_eq!((-3.2f32).mul_add(2.4, f32::NEG_INFINITY), f32::NEG_INFINITY);
@@ -1125,16 +1129,16 @@ fn ldexp(a: f64, b: i32) -> f64 {
     assert_biteq((-0f32).powi(9), -0.0, "-0^x = -0 where x is negative");
     assert_biteq((-0f64).powi(99), -0.0, "-0^x = -0 where x is negative");
 
-    assert_approx_eq!(1f16.exp(), f16::consts::E);
-    assert_approx_eq!(1f32.exp(), f32::consts::E);
-    assert_approx_eq!(1f64.exp(), f64::consts::E);
+    assert_approx_eq!(1f16.exp(), f16_consts::E);
+    assert_approx_eq!(1f32.exp(), f32_consts::E);
+    assert_approx_eq!(1f64.exp(), f64_consts::E);
     assert_eq!(0f16.exp(), 1.0);
     assert_eq!(0f32.exp(), 1.0);
     assert_eq!(0f64.exp(), 1.0);
 
-    assert_approx_eq!(1f16.exp_m1(), f16::consts::E - 1.0);
-    assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
-    assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
+    assert_approx_eq!(1f16.exp_m1(), f16_consts::E - 1.0);
+    assert_approx_eq!(1f32.exp_m1(), f32_consts::E - 1.0);
+    assert_approx_eq!(1f64.exp_m1(), f64_consts::E - 1.0);
     assert_approx_eq!(f16::NEG_INFINITY.exp_m1(), -1.0);
     assert_approx_eq!(f32::NEG_INFINITY.exp_m1(), -1.0);
     assert_approx_eq!(f64::NEG_INFINITY.exp_m1(), -1.0);
@@ -1146,9 +1150,9 @@ fn ldexp(a: f64, b: i32) -> f64 {
     assert_eq!(0f32.exp2(), 1.0);
     assert_eq!(0f64.exp2(), 1.0);
 
-    assert_approx_eq!(f16::consts::E.ln(), 1f16);
-    assert_approx_eq!(f32::consts::E.ln(), 1f32);
-    assert_approx_eq!(f64::consts::E.ln(), 1f64);
+    assert_approx_eq!(f16_consts::E.ln(), 1f16);
+    assert_approx_eq!(f32_consts::E.ln(), 1f32);
+    assert_approx_eq!(f64_consts::E.ln(), 1f64);
     assert_eq!(1f16.ln(), 0.0);
     assert_eq!(1f32.ln(), 0.0);
     assert_eq!(1f64.ln(), 0.0);
@@ -1159,11 +1163,11 @@ fn ldexp(a: f64, b: i32) -> f64 {
 
     assert_approx_eq!(10f16.log10(), 1f16);
     assert_approx_eq!(10f32.log10(), 1f32);
-    assert_approx_eq!(f64::consts::E.log10(), f64::consts::LOG10_E);
+    assert_approx_eq!(f64_consts::E.log10(), f64_consts::LOG10_E);
 
     assert_approx_eq!(8f16.log2(), 3f16);
     assert_approx_eq!(8f32.log2(), 3f32);
-    assert_approx_eq!(f64::consts::E.log2(), f64::consts::LOG2_E);
+    assert_approx_eq!(f64_consts::E.log2(), f64_consts::LOG2_E);
 
     #[allow(deprecated)]
     {
@@ -1189,13 +1193,13 @@ fn ldexp(a: f64, b: i32) -> f64 {
     assert_eq!(0f16.sin(), 0f16);
     assert_eq!(0f32.sin(), 0f32);
     assert_eq!(0f64.sin(), 0f64);
-    assert_approx_eq!(f16::consts::FRAC_PI_6.sin(), 0.5);
-    assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
-    assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
+    assert_approx_eq!(f16_consts::FRAC_PI_6.sin(), 0.5);
+    assert_approx_eq!(f32_consts::FRAC_PI_6.sin(), 0.5);
+    assert_approx_eq!(f64_consts::FRAC_PI_6.sin(), 0.5);
     // Increase error tolerance to 16ULP because of the extra operation.
-    assert_approx_eq!(f16::consts::FRAC_PI_4.sin().asin(), f16::consts::FRAC_PI_4, 16);
-    assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
-    assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f16_consts::FRAC_PI_4.sin().asin(), f16_consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f32_consts::FRAC_PI_4.sin().asin(), f32_consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f64_consts::FRAC_PI_4.sin().asin(), f64_consts::FRAC_PI_4, 16);
     assert_biteq(0.0f16.asin(), 0.0f16, "asin(+0) = +0");
     assert_biteq((-0.0f16).asin(), -0.0, "asin(-0) = -0");
     assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
@@ -1212,12 +1216,12 @@ fn ldexp(a: f64, b: i32) -> f64 {
 
     // Ensure `sin` always returns something that is a valid input for `asin`, and same for
     // `cos` and `acos`.
-    let halve_pi_f16 = std::f16::consts::FRAC_PI_2;
-    let halve_pi_f32 = std::f32::consts::FRAC_PI_2;
-    let halve_pi_f64 = std::f64::consts::FRAC_PI_2;
-    let pi_f16 = std::f16::consts::PI;
-    let pi_f32 = std::f32::consts::PI;
-    let pi_f64 = std::f64::consts::PI;
+    let halve_pi_f16 = f16_consts::FRAC_PI_2;
+    let halve_pi_f32 = f32_consts::FRAC_PI_2;
+    let halve_pi_f64 = f64_consts::FRAC_PI_2;
+    let pi_f16 = f16_consts::PI;
+    let pi_f32 = f32_consts::PI;
+    let pi_f64 = f64_consts::PI;
     for _ in 0..64 {
         // sin() should be clamped to [-1, 1] so asin() can never return NaN
         assert!(!halve_pi_f16.sin().asin().is_nan());
@@ -1232,13 +1236,13 @@ fn ldexp(a: f64, b: i32) -> f64 {
     assert_eq!(0f16.cos(), 1f16);
     assert_eq!(0f32.cos(), 1f32);
     assert_eq!(0f64.cos(), 1f64);
-    assert_approx_eq!(f16::consts::FRAC_PI_3.cos(), 0.5);
-    assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
-    assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
+    assert_approx_eq!(f16_consts::FRAC_PI_3.cos(), 0.5);
+    assert_approx_eq!(f32_consts::FRAC_PI_3.cos(), 0.5);
+    assert_approx_eq!(f64_consts::FRAC_PI_3.cos(), 0.5);
     // Increase error tolerance to 16ULP because of the extra operation.
-    assert_approx_eq!(f16::consts::FRAC_PI_4.cos().acos(), f16::consts::FRAC_PI_4, 16);
-    assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
-    assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f16_consts::FRAC_PI_4.cos().acos(), f16_consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f32_consts::FRAC_PI_4.cos().acos(), f32_consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f64_consts::FRAC_PI_4.cos().acos(), f64_consts::FRAC_PI_4, 16);
     assert_biteq(1.0f16.acos(), 0.0, "acos(1) = 0");
     assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
     assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
@@ -1314,15 +1318,15 @@ macro_rules! fixed_atan2_cases{
 
     assert_approx_eq!(
         1.0f16.tanh(),
-        (1.0 - f16::consts::E.powi(-2)) / (1.0 + f16::consts::E.powi(-2))
+        (1.0 - f16_consts::E.powi(-2)) / (1.0 + f16_consts::E.powi(-2))
     );
     assert_approx_eq!(
         1.0f32.tanh(),
-        (1.0 - f32::consts::E.powi(-2)) / (1.0 + f32::consts::E.powi(-2))
+        (1.0 - f32_consts::E.powi(-2)) / (1.0 + f32_consts::E.powi(-2))
     );
     assert_approx_eq!(
         1.0f64.tanh(),
-        (1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
+        (1.0 - f64_consts::E.powi(-2)) / (1.0 + f64_consts::E.powi(-2))
     );
     assert_eq!(f16::INFINITY.tanh(), 1.0);
     assert_eq!(f16::NEG_INFINITY.tanh(), -1.0);
@@ -1338,22 +1342,22 @@ macro_rules! fixed_atan2_cases{
     assert_approx_eq!(5.0f16.gamma(), 24.0);
     assert_approx_eq!(5.0f32.gamma(), 24.0);
     assert_approx_eq!(5.0f64.gamma(), 24.0);
-    assert_approx_eq!((-0.5f16).gamma(), (-2.0) * f16::consts::PI.sqrt());
-    assert_approx_eq!((-0.5f32).gamma(), (-2.0) * f32::consts::PI.sqrt());
-    assert_approx_eq!((-0.5f64).gamma(), (-2.0) * f64::consts::PI.sqrt());
+    assert_approx_eq!((-0.5f16).gamma(), (-2.0) * f16_consts::PI.sqrt());
+    assert_approx_eq!((-0.5f32).gamma(), (-2.0) * f32_consts::PI.sqrt());
+    assert_approx_eq!((-0.5f64).gamma(), (-2.0) * f64_consts::PI.sqrt());
 
     assert_eq!(2.0f16.ln_gamma(), (0.0, 1));
     assert_eq!(2.0f32.ln_gamma(), (0.0, 1));
     assert_eq!(2.0f64.ln_gamma(), (0.0, 1));
     // Gamma(-0.5) = -2*sqrt(π)
     let (val, sign) = (-0.5f16).ln_gamma();
-    assert_approx_eq!(val, (2.0 * f16::consts::PI.sqrt()).ln());
+    assert_approx_eq!(val, (2.0 * f16_consts::PI.sqrt()).ln());
     assert_eq!(sign, -1);
     let (val, sign) = (-0.5f32).ln_gamma();
-    assert_approx_eq!(val, (2.0 * f32::consts::PI.sqrt()).ln());
+    assert_approx_eq!(val, (2.0 * f32_consts::PI.sqrt()).ln());
     assert_eq!(sign, -1);
     let (val, sign) = (-0.5f64).ln_gamma();
-    assert_approx_eq!(val, (2.0 * f64::consts::PI.sqrt()).ln());
+    assert_approx_eq!(val, (2.0 * f64_consts::PI.sqrt()).ln());
     assert_eq!(sign, -1);
 
     assert_approx_eq!(1.0f16.erf(), 0.84270079294971486934122063508260926f16);
@@ -1558,7 +1562,7 @@ fn test_operations_f16(a: f16, b: f16) {
         check_nondet(|| a.log(b));
         check_nondet(|| a.exp());
         check_nondet(|| 10f16.exp2());
-        check_nondet(|| f16::consts::E.ln());
+        check_nondet(|| f16_consts::E.ln());
         check_nondet(|| 10f16.log10());
         check_nondet(|| 8f16.log2());
         check_nondet(|| 1f16.sin());
@@ -1594,7 +1598,7 @@ fn test_operations_f32(a: f32, b: f32) {
         check_nondet(|| a.log(b));
         check_nondet(|| a.exp());
         check_nondet(|| 10f32.exp2());
-        check_nondet(|| f32::consts::E.ln());
+        check_nondet(|| f32_consts::E.ln());
         check_nondet(|| 10f32.log10());
         check_nondet(|| 8f32.log2());
         check_nondet(|| 1f32.ln_1p());
@@ -1631,8 +1635,8 @@ fn test_operations_f64(a: f64, b: f64) {
         check_nondet(|| a.exp());
         check_nondet(|| 50f64.exp2());
         check_nondet(|| 3f64.ln());
-        check_nondet(|| f64::consts::E.log10());
-        check_nondet(|| f64::consts::E.log2());
+        check_nondet(|| f64_consts::E.log10());
+        check_nondet(|| f64_consts::E.log2());
         check_nondet(|| 1f64.ln_1p());
         check_nondet(|| 27.0f64.cbrt());
         check_nondet(|| 3.0f64.hypot(4.0f64));
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
index be3f961e10ff..9136b5eda387 100644
--- a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
@@ -6,9 +6,10 @@
 use std::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
-use std::f32::NAN;
 use std::mem::transmute;
 
+const NAN: f32 = f32::NAN;
+
 fn main() {
     assert!(is_x86_feature_detected!("sse"));
 
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
index 242aa0e89f63..570da30f0b62 100644
--- a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
@@ -6,9 +6,10 @@
 use std::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
-use std::f64::NAN;
 use std::mem::transmute;
 
+const NAN: f64 = f64::NAN;
+
 fn main() {
     assert!(is_x86_feature_detected!("sse2"));
 

From 461038f0c9fd7a403b29d3ac0e384d410ab16f07 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 15 Mar 2026 17:04:38 +0100
Subject: [PATCH 0504/1059] improve `#[track_caller]` invalid ABI error

---
 .../rustc_ast_passes/src/ast_validation.rs    | 20 ++++++++++++-
 compiler/rustc_ast_passes/src/errors.rs       | 10 +++++++
 .../rustc_codegen_ssa/src/codegen_attrs.rs    |  3 +-
 compiler/rustc_codegen_ssa/src/errors.rs      |  7 -----
 .../error-with-invalid-abi.rs                 | 27 ++++++++++++++---
 .../error-with-invalid-abi.stderr             | 26 ++++++++++++----
 .../rfc-2091-track-caller/error-with-naked.rs |  4 +--
 .../error-with-naked.stderr                   | 30 +++++++++++--------
 8 files changed, 94 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 2308502df070..bdb098131124 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1487,6 +1487,15 @@ fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {
                     ident,
                     sig,
                 );
+
+                if let Some(attr) = attr::find_by_name(fi.attrs(), sym::track_caller)
+                    && self.extern_mod_abi != Some(ExternAbi::Rust)
+                {
+                    self.dcx().emit_err(errors::RequiresRustAbi {
+                        track_caller_span: attr.span,
+                        extern_abi_span: self.current_extern_span(),
+                    });
+                }
             }
             ForeignItemKind::TyAlias(box TyAlias {
                 defaultness,
@@ -1672,10 +1681,19 @@ fn visit_fn(&mut self, fk: FnKind<'a>, attrs: &AttrVec, span: Span, id: NodeId)
         }
 
         if let FnKind::Fn(ctxt, _, fun) = fk
-            && let Extern::Explicit(str_lit, _) = fun.sig.header.ext
+            && let Extern::Explicit(str_lit, extern_abi_span) = fun.sig.header.ext
             && let Ok(abi) = ExternAbi::from_str(str_lit.symbol.as_str())
         {
             self.check_extern_fn_signature(abi, ctxt, &fun.ident, &fun.sig);
+
+            if let Some(attr) = attr::find_by_name(attrs, sym::track_caller)
+                && abi != ExternAbi::Rust
+            {
+                self.dcx().emit_err(errors::RequiresRustAbi {
+                    track_caller_span: attr.span,
+                    extern_abi_span,
+                });
+            }
         }
 
         self.check_c_variadic_type(fk, attrs);
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 4a39e22ac220..390c1556f191 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -1140,3 +1140,13 @@ pub(crate) struct ScalableVectorBadArch {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("`#[track_caller]` can only be used with the Rust ABI", code = E0737)]
+pub(crate) struct RequiresRustAbi {
+    #[primary_span]
+    #[label("using `#[track_caller]` here")]
+    pub track_caller_span: Span,
+    #[label("not using the Rust ABI because of this")]
+    pub extern_abi_span: Span,
+}
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index b8a8bb3ad419..6dd4f2d6b592 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -150,7 +150,8 @@ fn process_builtin_attrs(
                     && let Some(fn_sig) = try_fn_sig(tcx, did, *attr_span)
                     && fn_sig.skip_binder().abi() != ExternAbi::Rust
                 {
-                    tcx.dcx().emit_err(errors::RequiresRustAbi { span: *attr_span });
+                    // This error is already reported in `rustc_ast_passes/src/ast_validation.rs`.
+                    tcx.dcx().delayed_bug("`#[track_caller]` requires the Rust ABI");
                 }
                 if is_closure
                     && !tcx.features().closure_track_caller()
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 41337fc21a7b..0ec297252fce 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -111,13 +111,6 @@ pub(crate) struct NoSavedObjectFile<'a> {
     pub cgu_name: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag("`#[track_caller]` requires Rust ABI", code = E0737)]
-pub(crate) struct RequiresRustAbi {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("unable to copy {$source_file} to {$output_path}: {$error}")]
 pub(crate) struct CopyPathBuf {
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.rs b/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.rs
index 074e1ceb791c..53f99760d88f 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.rs
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.rs
@@ -1,11 +1,30 @@
 #[track_caller]
-extern "C" fn f() {}
-//~^^ ERROR `#[track_caller]` requires Rust ABI
+//~^ ERROR `#[track_caller]` can only be used with the Rust ABI
+extern "C" fn c_fn() {}
+
+#[track_caller]
+extern "Rust" fn rust_fn() {}
 
 extern "C" {
     #[track_caller]
-    fn g();
-    //~^^ ERROR `#[track_caller]` requires Rust ABI
+    //~^ ERROR `#[track_caller]` can only be used with the Rust ABI
+    fn c_extern();
+}
+
+extern "Rust" {
+    #[track_caller]
+    fn rust_extern();
+}
+
+struct S;
+
+impl S {
+    #[track_caller]
+    //~^ ERROR `#[track_caller]` can only be used with the Rust ABI
+    extern "C" fn c_method() {}
+
+    #[track_caller]
+    extern "Rust" fn rust_method() {}
 }
 
 fn main() {}
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.stderr
index bcc0c8170e65..f5cba7b8a011 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-invalid-abi.stderr
@@ -1,15 +1,29 @@
-error[E0737]: `#[track_caller]` requires Rust ABI
+error[E0737]: `#[track_caller]` can only be used with the Rust ABI
   --> $DIR/error-with-invalid-abi.rs:1:1
    |
 LL | #[track_caller]
-   | ^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^ using `#[track_caller]` here
+LL |
+LL | extern "C" fn c_fn() {}
+   | ---------- not using the Rust ABI because of this
 
-error[E0737]: `#[track_caller]` requires Rust ABI
-  --> $DIR/error-with-invalid-abi.rs:6:5
+error[E0737]: `#[track_caller]` can only be used with the Rust ABI
+  --> $DIR/error-with-invalid-abi.rs:9:5
+   |
+LL | extern "C" {
+   | ---------- not using the Rust ABI because of this
+LL |     #[track_caller]
+   |     ^^^^^^^^^^^^^^^ using `#[track_caller]` here
+
+error[E0737]: `#[track_caller]` can only be used with the Rust ABI
+  --> $DIR/error-with-invalid-abi.rs:22:5
    |
 LL |     #[track_caller]
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^ using `#[track_caller]` here
+LL |
+LL |     extern "C" fn c_method() {}
+   |     ---------- not using the Rust ABI because of this
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0737`.
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
index a4baf1fe4b97..a136c3ffeefa 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
@@ -3,7 +3,7 @@
 use std::arch::naked_asm;
 
 #[track_caller] //~ ERROR [E0736]
-//~^ ERROR `#[track_caller]` requires Rust ABI
+//~^ ERROR `#[track_caller]` can only be used with the Rust ABI
 #[unsafe(naked)]
 extern "C" fn f() {
     unsafe {
@@ -15,7 +15,7 @@ extern "C" fn f() {
 
 impl S {
     #[track_caller] //~ ERROR [E0736]
-    //~^ ERROR `#[track_caller]` requires Rust ABI
+    //~^ ERROR `#[track_caller]` can only be used with the Rust ABI
     #[unsafe(naked)]
     extern "C" fn g() {
         unsafe {
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr
index 303608061388..90ed76e8b1b9 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr
@@ -1,3 +1,21 @@
+error[E0737]: `#[track_caller]` can only be used with the Rust ABI
+  --> $DIR/error-with-naked.rs:5:1
+   |
+LL | #[track_caller]
+   | ^^^^^^^^^^^^^^^ using `#[track_caller]` here
+...
+LL | extern "C" fn f() {
+   | ---------- not using the Rust ABI because of this
+
+error[E0737]: `#[track_caller]` can only be used with the Rust ABI
+  --> $DIR/error-with-naked.rs:17:5
+   |
+LL |     #[track_caller]
+   |     ^^^^^^^^^^^^^^^ using `#[track_caller]` here
+...
+LL |     extern "C" fn g() {
+   |     ---------- not using the Rust ABI because of this
+
 error[E0736]: attribute incompatible with `#[unsafe(naked)]`
   --> $DIR/error-with-naked.rs:5:3
    |
@@ -16,18 +34,6 @@ LL |
 LL |     #[unsafe(naked)]
    |     ---------------- function marked with `#[unsafe(naked)]` here
 
-error[E0737]: `#[track_caller]` requires Rust ABI
-  --> $DIR/error-with-naked.rs:5:1
-   |
-LL | #[track_caller]
-   | ^^^^^^^^^^^^^^^
-
-error[E0737]: `#[track_caller]` requires Rust ABI
-  --> $DIR/error-with-naked.rs:17:5
-   |
-LL |     #[track_caller]
-   |     ^^^^^^^^^^^^^^^
-
 error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0736, E0737.

From 4ecc78d637204bc3690ad0cd733671ce7b7e36ea Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Sun, 15 Mar 2026 12:39:39 -0400
Subject: [PATCH 0505/1059] Suppress self-referential associated type
 constraint suggestion

---
 .../error_reporting/infer/note_and_explain.rs |  7 +++-
 ...ont-suggest-self-referential-constraint.rs | 20 +++++++++++
 ...suggest-self-referential-constraint.stderr | 33 +++++++++++++++++++
 3 files changed, 59 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/associated-types/dont-suggest-self-referential-constraint.rs
 create mode 100644 tests/ui/associated-types/dont-suggest-self-referential-constraint.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 0fde0009debe..7f53fdbc2c9f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -263,8 +263,13 @@ fn foo(&self, x: T) -> T { x }
                             cause.code(),
                         );
                     }
+                    // Don't suggest constraining a projection to something
+                    // containing itself, e.g. `Item = &<I as Iterator>::Item`.
                     (_, ty::Alias(ty::Projection | ty::Inherent, proj_ty))
-                        if !tcx.is_impl_trait_in_trait(proj_ty.def_id) =>
+                        if !tcx.is_impl_trait_in_trait(proj_ty.def_id)
+                            && !tcx
+                                .erase_and_anonymize_regions(values.expected)
+                                .contains(tcx.erase_and_anonymize_regions(values.found)) =>
                     {
                         let msg = || {
                             format!(
diff --git a/tests/ui/associated-types/dont-suggest-self-referential-constraint.rs b/tests/ui/associated-types/dont-suggest-self-referential-constraint.rs
new file mode 100644
index 000000000000..ad999a1c7735
--- /dev/null
+++ b/tests/ui/associated-types/dont-suggest-self-referential-constraint.rs
@@ -0,0 +1,20 @@
+// Regression test for #112104.
+//
+// Don't suggest `Item = &<I as Iterator>::Item` when
+// the expected type wraps the found projection.
+
+fn option_of_ref_assoc<I: Iterator>(iter: &mut I) {
+    let _: Option<&I::Item> = iter.next();
+    //~^ ERROR mismatched types
+}
+
+// Valid constraint suggestions should still fire.
+trait Foo {
+    type Assoc;
+}
+
+fn assoc_to_concrete<T: Foo>(x: T::Assoc) -> u32 {
+    x //~ ERROR mismatched types
+}
+
+fn main() {}
diff --git a/tests/ui/associated-types/dont-suggest-self-referential-constraint.stderr b/tests/ui/associated-types/dont-suggest-self-referential-constraint.stderr
new file mode 100644
index 000000000000..e6e37cdf7e51
--- /dev/null
+++ b/tests/ui/associated-types/dont-suggest-self-referential-constraint.stderr
@@ -0,0 +1,33 @@
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-self-referential-constraint.rs:7:31
+   |
+LL |     let _: Option<&I::Item> = iter.next();
+   |            ----------------   ^^^^^^^^^^^ expected `Option<&<I as Iterator>::Item>`, found `Option<<I as Iterator>::Item>`
+   |            |
+   |            expected due to this
+   |
+   = note: expected enum `Option<&_>`
+              found enum `Option<_>`
+help: try using `.as_ref()` to convert `Option<<I as Iterator>::Item>` to `Option<&<I as Iterator>::Item>`
+   |
+LL |     let _: Option<&I::Item> = iter.next().as_ref();
+   |                                          +++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/dont-suggest-self-referential-constraint.rs:17:5
+   |
+LL | fn assoc_to_concrete<T: Foo>(x: T::Assoc) -> u32 {
+   |                                              --- expected `u32` because of return type
+LL |     x
+   |     ^ expected `u32`, found associated type
+   |
+   = note:         expected type `u32`
+           found associated type `<T as Foo>::Assoc`
+help: consider constraining the associated type `<T as Foo>::Assoc` to `u32`
+   |
+LL | fn assoc_to_concrete<T: Foo<Assoc = u32>>(x: T::Assoc) -> u32 {
+   |                            +++++++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

From b258fe18ad494eed47cc871e0400ac16d54f5319 Mon Sep 17 00:00:00 2001
From: arferreira <arfs.antonio@gmail.com>
Date: Sun, 15 Mar 2026 12:54:09 -0400
Subject: [PATCH 0506/1059] Use position() instead of enumerate().find()

---
 .../src/error_reporting/infer/need_type_info.rs              | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 921fab554348..ffd278e90529 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -1260,11 +1260,10 @@ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
                 have_turbofish,
             } = args;
             let generics = tcx.generics_of(generics_def_id);
-            if let Some((argument_index, _)) = generics
+            if let Some(argument_index) = generics
                 .own_args(args)
                 .iter()
-                .enumerate()
-                .find(|&(_, &arg)| self.generic_arg_contains_target(arg))
+                .position(|&arg| self.generic_arg_contains_target(arg))
             {
                 let args = self.tecx.resolve_vars_if_possible(args);
                 let generic_args =

From 00dae097c4e0a87e468eec591ee8b00e2883c368 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Sun, 15 Mar 2026 08:27:58 +0100
Subject: [PATCH 0507/1059] Print the command and output even if it succeeds

Previously, it was quite hard to get access to this output because it
was printed to a buffer in memory and then discarded. This output is
already hidden behind libtest's output capturing, we don't need to hide
it twice.
---
 src/tools/run-make-support/src/command.rs |  8 +++++--
 src/tools/run-make-support/src/run.rs     | 28 ++++-------------------
 src/tools/run-make-support/src/targets.rs |  9 +-------
 src/tools/run-make-support/src/util.rs    | 20 ++++++++++------
 4 files changed, 25 insertions(+), 40 deletions(-)

diff --git a/src/tools/run-make-support/src/command.rs b/src/tools/run-make-support/src/command.rs
index f4a09f9faae8..0216ae7a30dd 100644
--- a/src/tools/run-make-support/src/command.rs
+++ b/src/tools/run-make-support/src/command.rs
@@ -6,7 +6,7 @@
 
 use build_helper::drop_bomb::DropBomb;
 
-use crate::util::handle_failed_output;
+use crate::util::{handle_failed_output, verbose_print_command};
 use crate::{
     assert_contains, assert_contains_regex, assert_equals, assert_not_contains,
     assert_not_contains_regex,
@@ -156,7 +156,7 @@ pub fn args<S, V>(&mut self, args: V) -> &mut Self
 
     /// Inspect what the underlying [`std::process::Command`] is up to the
     /// current construction.
-    pub fn inspect<I>(&mut self, inspector: I) -> &mut Self
+    pub fn inspect<I>(&self, inspector: I) -> &Self
     where
         I: FnOnce(&StdCommand),
     {
@@ -233,6 +233,8 @@ pub fn run(&mut self) -> CompletedProcess {
         let output = self.command_output();
         if !output.status().success() {
             handle_failed_output(&self, output, panic::Location::caller().line());
+        } else {
+            verbose_print_command(self, &output);
         }
         output
     }
@@ -245,6 +247,8 @@ pub fn run_fail(&mut self) -> CompletedProcess {
         let output = self.command_output();
         if output.status().success() {
             handle_failed_output(&self, output, panic::Location::caller().line());
+        } else {
+            verbose_print_command(self, &output);
         }
         output
     }
diff --git a/src/tools/run-make-support/src/run.rs b/src/tools/run-make-support/src/run.rs
index b95f3a5cfe5a..43f0473ddf4a 100644
--- a/src/tools/run-make-support/src/run.rs
+++ b/src/tools/run-make-support/src/run.rs
@@ -1,9 +1,8 @@
+use std::env;
 use std::ffi::{OsStr, OsString};
 use std::path::PathBuf;
-use std::{env, panic};
 
 use crate::command::{Command, CompletedProcess};
-use crate::util::handle_failed_output;
 use crate::{cwd, env_var};
 
 #[track_caller]
@@ -59,43 +58,26 @@ fn run_common(name: &str, args: Option<&[&str]>) -> Command {
     });
     cmd.env("LC_ALL", "C"); // force english locale
 
+    cmd.inspect(|std_cmd| eprintln!("running: {std_cmd:?}"));
     cmd
 }
 
 /// Run a built binary and make sure it succeeds.
 #[track_caller]
 pub fn run(name: &str) -> CompletedProcess {
-    let caller = panic::Location::caller();
-    let mut cmd = run_common(name, None);
-    let output = cmd.run();
-    if !output.status().success() {
-        handle_failed_output(&cmd, output, caller.line());
-    }
-    output
+    run_common(name, None).run()
 }
 
 /// Run a built binary with one or more argument(s) and make sure it succeeds.
 #[track_caller]
 pub fn run_with_args(name: &str, args: &[&str]) -> CompletedProcess {
-    let caller = panic::Location::caller();
-    let mut cmd = run_common(name, Some(args));
-    let output = cmd.run();
-    if !output.status().success() {
-        handle_failed_output(&cmd, output, caller.line());
-    }
-    output
+    run_common(name, Some(args)).run()
 }
 
 /// Run a built binary and make sure it fails.
 #[track_caller]
 pub fn run_fail(name: &str) -> CompletedProcess {
-    let caller = panic::Location::caller();
-    let mut cmd = run_common(name, None);
-    let output = cmd.run_fail();
-    if output.status().success() {
-        handle_failed_output(&cmd, output, caller.line());
-    }
-    output
+    run_common(name, None).run_fail()
 }
 
 /// Create a new custom [`Command`]. This should be preferred to creating [`std::process::Command`]
diff --git a/src/tools/run-make-support/src/targets.rs b/src/tools/run-make-support/src/targets.rs
index 6288f5f7c59d..bbc36889b1a4 100644
--- a/src/tools/run-make-support/src/targets.rs
+++ b/src/tools/run-make-support/src/targets.rs
@@ -2,7 +2,6 @@
 
 use crate::command::Command;
 use crate::env_var;
-use crate::util::handle_failed_output;
 
 /// `TARGET`
 #[must_use]
@@ -81,11 +80,5 @@ pub fn llvm_components_contain(component: &str) -> bool {
 #[track_caller]
 #[must_use]
 pub fn uname() -> String {
-    let caller = panic::Location::caller();
-    let mut uname = Command::new("uname");
-    let output = uname.run();
-    if !output.status().success() {
-        handle_failed_output(&uname, output, caller.line());
-    }
-    output.stdout_utf8()
+    Command::new("uname").run().stdout_utf8()
 }
diff --git a/src/tools/run-make-support/src/util.rs b/src/tools/run-make-support/src/util.rs
index 7908dc1f7b3d..f44b3861d11d 100644
--- a/src/tools/run-make-support/src/util.rs
+++ b/src/tools/run-make-support/src/util.rs
@@ -4,6 +4,18 @@
 use crate::env::env_var;
 use crate::path_helpers::cwd;
 
+pub(crate) fn verbose_print_command(cmd: &Command, output: &CompletedProcess) {
+    cmd.inspect(|std_cmd| {
+        eprintln!("{std_cmd:?}");
+    });
+    eprintln!("output status: `{}`", output.status());
+    eprintln!("=== STDOUT ===\n{}\n\n", output.stdout_utf8());
+    eprintln!("=== STDERR ===\n{}\n\n", output.stderr_utf8());
+    if !cmd.get_context().is_empty() {
+        eprintln!("Context:\n{}", cmd.get_context());
+    }
+}
+
 /// If a given [`Command`] failed (as indicated by its [`CompletedProcess`]), verbose print the
 /// executed command, failure location, output status and stdout/stderr, and abort the process with
 /// exit code `1`.
@@ -17,13 +29,7 @@ pub(crate) fn handle_failed_output(
     } else {
         eprintln!("command failed at line {caller_line_number}");
     }
-    eprintln!("{cmd:?}");
-    eprintln!("output status: `{}`", output.status());
-    eprintln!("=== STDOUT ===\n{}\n\n", output.stdout_utf8());
-    eprintln!("=== STDERR ===\n{}\n\n", output.stderr_utf8());
-    if !cmd.get_context().is_empty() {
-        eprintln!("Context:\n{}", cmd.get_context());
-    }
+    verbose_print_command(cmd, &output);
     std::process::exit(1)
 }
 

From 774f23201523e60fd729c654061f82492760adec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 15 Mar 2026 17:39:06 +0000
Subject: [PATCH 0508/1059] Provide better suggestions for inference errors on
 `.collect()?`

When encountering an inference error when calling `.collect()` followed by `?`, detect the return type of the enclosing function and suggest `.collect::<Result<_, _>>()?` instead of `.collect::<Vec<_>>()?`:

```
error[E0283]: type annotations needed
  --> $DIR/question-mark-type-infer.rs:10:21
   |
LL |     l.iter().map(f).collect()?
   |                     ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
   |
   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
note: required by a bound in `collect`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
help: consider specifying the generic argument
   |
LL |     l.iter().map(f).collect::<Result<_, _>>()?
   |                            ++++++++++++++++
```

On inference error in let binding, account for `?`:
```
error[E0282]: type annotations needed
  --> $DIR/question-mark-type-inference-in-chain.rs:31:9
   |
LL |     let mut tags = lines.iter().map(|e| parse(e)).collect()?;
   |         ^^^^^^^^
...
LL |     tags.sort();
   |     ---- type must be known at this point
   |
help: consider giving `tags` an explicit type
   |
LL |     let mut tags: Vec<_> = lines.iter().map(|e| parse(e)).collect()?;
   |                 ++++++++
```
---
 .../error_reporting/infer/need_type_info.rs   | 80 +++++++++++++++---
 .../ui/inference/question-mark-type-infer.rs  | 14 ++++
 .../inference/question-mark-type-infer.stderr | 34 +++++++-
 .../question-mark-type-inference-in-chain.rs  | 84 +++++++++++++++++++
 ...estion-mark-type-inference-in-chain.stderr | 66 +++++++++++++++
 5 files changed, 262 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/inference/question-mark-type-inference-in-chain.rs
 create mode 100644 tests/ui/inference/question-mark-type-inference-in-chain.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 629bd30d88e8..16b0e96cde0f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -555,6 +555,7 @@ pub fn emit_inference_failure_err(
                 def_id: _,
                 generic_args,
                 have_turbofish,
+                hir_id,
             } => {
                 let generics = self.tcx.generics_of(generics_def_id);
                 let is_type = term.as_type().is_some();
@@ -577,7 +578,32 @@ pub fn emit_inference_failure_err(
                 let args = if self.tcx.get_diagnostic_item(sym::iterator_collect_fn)
                     == Some(generics_def_id)
                 {
-                    "Vec<_>".to_string()
+                    if let hir::Node::Expr(expr) = self.tcx.parent_hir_node(hir_id)
+                        && let hir::ExprKind::Call(expr, _args) = expr.kind
+                        && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = expr.kind
+                        && let Res::Def(DefKind::AssocFn, def_id) = path.res
+                        && let Some(try_trait) = self.tcx.lang_items().try_trait()
+                        && try_trait == self.tcx.parent(def_id)
+                        && let DefKind::Fn | DefKind::AssocFn =
+                            self.tcx.def_kind(body_def_id.to_def_id())
+                        && let ret = self
+                            .tcx
+                            .fn_sig(body_def_id.to_def_id())
+                            .instantiate_identity()
+                            .skip_binder()
+                            .output()
+                        && let ty::Adt(adt, _args) = ret.kind()
+                        && let Some(sym::Option | sym::Result) =
+                            self.tcx.get_diagnostic_name(adt.did())
+                    {
+                        if let Some(sym::Option) = self.tcx.get_diagnostic_name(adt.did()) {
+                            "Option<_>".to_string()
+                        } else {
+                            "Result<_, _>".to_string()
+                        }
+                    } else {
+                        "Vec<_>".to_string()
+                    }
                 } else {
                     let mut p = fmt_printer(self, Namespace::TypeNS);
                     p.comma_sep(generic_args.iter().copied().map(|arg| {
@@ -710,6 +736,7 @@ enum InferSourceKind<'tcx> {
         def_id: DefId,
         generic_args: &'tcx [GenericArg<'tcx>],
         have_turbofish: bool,
+        hir_id: HirId,
     },
     FullyQualifiedMethodCall {
         receiver: &'tcx Expr<'tcx>,
@@ -1188,19 +1215,45 @@ fn visit_local(&mut self, local: &'tcx LetStmt<'tcx>) {
 
         if let Some(ty) = self.opt_node_type(local.hir_id) {
             if self.generic_arg_contains_target(ty.into()) {
-                match local.source {
-                    LocalSource::Normal if local.ty.is_none() => {
-                        self.update_infer_source(InferSource {
-                            span: local.pat.span,
-                            kind: InferSourceKind::LetBinding {
-                                insert_span: local.pat.span.shrink_to_hi(),
-                                pattern_name: local.pat.simple_ident(),
-                                ty,
-                                def_id: None,
-                            },
-                        })
+                fn get_did(
+                    typeck_results: &TypeckResults<'_>,
+                    expr: &hir::Expr<'_>,
+                ) -> Option<DefId> {
+                    match expr.kind {
+                        hir::ExprKind::Match(expr, _, hir::MatchSource::TryDesugar(_))
+                            if let hir::ExprKind::Call(_, [expr]) = expr.kind =>
+                        {
+                            get_did(typeck_results, expr)
+                        }
+                        hir::ExprKind::Call(base, _args)
+                            if let hir::ExprKind::Path(path) = base.kind
+                                && let hir::QPath::Resolved(_, path) = path
+                                && let Res::Def(_, did) = path.res =>
+                        {
+                            Some(did)
+                        }
+                        hir::ExprKind::MethodCall(..)
+                            if let Some(did) =
+                                typeck_results.type_dependent_def_id(expr.hir_id) =>
+                        {
+                            Some(did)
+                        }
+                        _ => None,
                     }
-                    _ => {}
+                }
+
+                if let LocalSource::Normal = local.source
+                    && local.ty.is_none()
+                {
+                    self.update_infer_source(InferSource {
+                        span: local.pat.span,
+                        kind: InferSourceKind::LetBinding {
+                            insert_span: local.pat.span.shrink_to_hi(),
+                            pattern_name: local.pat.simple_ident(),
+                            ty,
+                            def_id: local.init.and_then(|expr| get_did(self.typeck_results, expr)),
+                        },
+                    });
                 }
             }
         }
@@ -1285,6 +1338,7 @@ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
                         def_id,
                         generic_args,
                         have_turbofish,
+                        hir_id: expr.hir_id,
                     },
                 });
             }
diff --git a/tests/ui/inference/question-mark-type-infer.rs b/tests/ui/inference/question-mark-type-infer.rs
index 10560f85ed48..b04868c5324f 100644
--- a/tests/ui/inference/question-mark-type-infer.rs
+++ b/tests/ui/inference/question-mark-type-infer.rs
@@ -10,6 +10,20 @@ fn g() -> Result<Vec<i32>, ()> {
     l.iter().map(f).collect()?
     //~^ ERROR type annotations needed
 }
+fn h() -> Result<(), ()> {
+    let l = [1, 2, 3, 4];
+    // The resulting binding doesn't have a type, so we need to guess the `Ok` type too.
+    let x = l.iter().map(f).collect()?;
+    //~^ ERROR type annotations needed
+    Ok(())
+}
+fn i() -> Result<(), ()> {
+    let l = [1, 2, 3, 4];
+    // The resulting binding already has a type, so we don't need to specify the `Ok` type.
+    let x: Vec<i32> = l.iter().map(f).collect()?;
+    //~^ ERROR type annotations needed
+    Ok(())
+}
 
 fn main() {
     g();
diff --git a/tests/ui/inference/question-mark-type-infer.stderr b/tests/ui/inference/question-mark-type-infer.stderr
index 45303a2c87ff..9e1232cb4a6f 100644
--- a/tests/ui/inference/question-mark-type-infer.stderr
+++ b/tests/ui/inference/question-mark-type-infer.stderr
@@ -9,9 +9,37 @@ note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 help: consider specifying the generic argument
    |
-LL |     l.iter().map(f).collect::<Vec<_>>()?
-   |                            ++++++++++
+LL |     l.iter().map(f).collect::<Result<_, _>>()?
+   |                            ++++++++++++++++
 
-error: aborting due to 1 previous error
+error[E0283]: type annotations needed
+  --> $DIR/question-mark-type-infer.rs:16:29
+   |
+LL |     let x = l.iter().map(f).collect()?;
+   |                             ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
+   |
+   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
+note: required by a bound in `collect`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+help: consider specifying the generic argument
+   |
+LL |     let x = l.iter().map(f).collect::<Result<_, _>>()?;
+   |                                    ++++++++++++++++
+
+error[E0283]: type annotations needed
+  --> $DIR/question-mark-type-infer.rs:23:39
+   |
+LL |     let x: Vec<i32> = l.iter().map(f).collect()?;
+   |                                       ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
+   |
+   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
+note: required by a bound in `collect`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+help: consider specifying the generic argument
+   |
+LL |     let x: Vec<i32> = l.iter().map(f).collect::<Result<_, _>>()?;
+   |                                              ++++++++++++++++
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/question-mark-type-inference-in-chain.rs b/tests/ui/inference/question-mark-type-inference-in-chain.rs
new file mode 100644
index 000000000000..47c41e52b9ac
--- /dev/null
+++ b/tests/ui/inference/question-mark-type-inference-in-chain.rs
@@ -0,0 +1,84 @@
+// #129269
+use std::fmt::Display;
+
+#[derive(Debug)]
+struct AnotherError;
+type Result<T, E = AnotherError> = core::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct Error;
+
+impl From<AnotherError> for Error {
+    fn from(_: AnotherError) -> Self { Error }
+}
+
+impl std::error::Error for Error {}
+
+impl Display for Error {
+    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}
+
+#[derive(Ord, PartialEq, PartialOrd, Eq)]
+pub struct Version {}
+
+fn parse(_s: &str) -> std::result::Result<Version, Error> {
+    todo!()
+}
+
+pub fn error1(lines: &[&str]) -> Result<Vec<Version>> {
+    let mut tags = lines.iter().map(|e| parse(e)).collect()?;
+    //~^ ERROR: type annotations needed
+    //~| HELP: consider giving `tags` an explicit type
+
+    tags.sort(); //~ NOTE: type must be known at this point
+
+    Ok(tags)
+}
+
+pub fn error2(lines: &[&str]) -> Result<Vec<Version>> {
+    let mut tags: Vec<Version> = lines.iter().map(|e| parse(e)).collect()?;
+    //~^ ERROR: type annotations needed
+    //~| NOTE: cannot infer type of the type parameter `B`
+    //~| NOTE: cannot satisfy `_: FromIterator<std::result::Result<Version, Error>>`
+    //~| NOTE: required by a bound in `collect`
+    //~| HELP: consider specifying the generic argument
+    tags.sort();
+
+    Ok(tags)
+}
+
+pub fn error3(lines: &[&str]) -> Result<Vec<Version>> {
+    let mut tags = lines.iter().map(|e| parse(e)).collect::<Vec<_>>()?;
+    //~^ ERROR: the `?` operator can only be applied to values that implement `Try`
+    //~| NOTE: the `?` operator cannot be applied to type `Vec<std::result::Result<Version, Error>>`
+    //~| HELP: the nightly-only, unstable trait `Try` is not implemented
+    //~| NOTE: in this expansion of desugaring of operator `?`
+    //~| NOTE: in this expansion of desugaring of operator `?`
+    tags.sort();
+
+    Ok(tags)
+}
+
+pub fn error4(lines: &[&str]) -> Result<Vec<Version>> {
+    let mut tags = lines
+        //~^ NOTE: this expression has type `&[&str]`
+        .iter()
+        //~^ NOTE: `Iterator::Item` is `&&str` here
+        .map(|e| parse(e))
+        //~^ NOTE: the method call chain might not have had the expected associated types
+        //~| NOTE: `Iterator::Item` changed to `Result<Version, Error>` here
+        .collect::<Result<Vec<Version>>>()?;
+        //~^ ERROR: a value of type `std::result::Result<Vec<Version>, AnotherError>` cannot be built from an iterator over elements of type `std::result::Result<Version, Error>`
+        //~| NOTE: value of type `std::result::Result<Vec<Version>, AnotherError>` cannot be built from `std::iter::Iterator<Item=std::result::Result<Version, Error>>`
+        //~| NOTE: required by a bound introduced by this call
+        //~| HELP: the trait
+        //~| HELP: for that trait implementation, expected `AnotherError`, found `Error`
+        //~| NOTE: required by a bound in `collect`
+    tags.sort();
+
+    Ok(tags)
+}
+
+fn main() {}
diff --git a/tests/ui/inference/question-mark-type-inference-in-chain.stderr b/tests/ui/inference/question-mark-type-inference-in-chain.stderr
new file mode 100644
index 000000000000..0c11cdccd174
--- /dev/null
+++ b/tests/ui/inference/question-mark-type-inference-in-chain.stderr
@@ -0,0 +1,66 @@
+error[E0282]: type annotations needed
+  --> $DIR/question-mark-type-inference-in-chain.rs:31:9
+   |
+LL |     let mut tags = lines.iter().map(|e| parse(e)).collect()?;
+   |         ^^^^^^^^
+...
+LL |     tags.sort();
+   |     ---- type must be known at this point
+   |
+help: consider giving `tags` an explicit type
+   |
+LL |     let mut tags: Vec<_> = lines.iter().map(|e| parse(e)).collect()?;
+   |                 ++++++++
+
+error[E0283]: type annotations needed
+  --> $DIR/question-mark-type-inference-in-chain.rs:41:65
+   |
+LL |     let mut tags: Vec<Version> = lines.iter().map(|e| parse(e)).collect()?;
+   |                                                                 ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
+   |
+   = note: cannot satisfy `_: FromIterator<std::result::Result<Version, Error>>`
+note: required by a bound in `collect`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+help: consider specifying the generic argument
+   |
+LL |     let mut tags: Vec<Version> = lines.iter().map(|e| parse(e)).collect::<Result<_, _>>()?;
+   |                                                                        ++++++++++++++++
+
+error[E0277]: the `?` operator can only be applied to values that implement `Try`
+  --> $DIR/question-mark-type-inference-in-chain.rs:53:20
+   |
+LL |     let mut tags = lines.iter().map(|e| parse(e)).collect::<Vec<_>>()?;
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `?` operator cannot be applied to type `Vec<std::result::Result<Version, Error>>`
+   |
+   = help: the nightly-only, unstable trait `Try` is not implemented for `Vec<std::result::Result<Version, Error>>`
+
+error[E0277]: a value of type `std::result::Result<Vec<Version>, AnotherError>` cannot be built from an iterator over elements of type `std::result::Result<Version, Error>`
+  --> $DIR/question-mark-type-inference-in-chain.rs:72:20
+   |
+LL |         .collect::<Result<Vec<Version>>>()?;
+   |          -------   ^^^^^^^^^^^^^^^^^^^^ value of type `std::result::Result<Vec<Version>, AnotherError>` cannot be built from `std::iter::Iterator<Item=std::result::Result<Version, Error>>`
+   |          |
+   |          required by a bound introduced by this call
+   |
+help: the trait `FromIterator<std::result::Result<_, Error>>` is not implemented for `std::result::Result<Vec<Version>, AnotherError>`
+      but trait `FromIterator<std::result::Result<_, AnotherError>>` is implemented for it
+  --> $SRC_DIR/core/src/result.rs:LL:COL
+   = help: for that trait implementation, expected `AnotherError`, found `Error`
+note: the method call chain might not have had the expected associated types
+  --> $DIR/question-mark-type-inference-in-chain.rs:69:10
+   |
+LL |     let mut tags = lines
+   |                    ----- this expression has type `&[&str]`
+LL |
+LL |         .iter()
+   |          ------ `Iterator::Item` is `&&str` here
+LL |
+LL |         .map(|e| parse(e))
+   |          ^^^^^^^^^^^^^^^^^ `Iterator::Item` changed to `Result<Version, Error>` here
+note: required by a bound in `collect`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0277, E0282, E0283.
+For more information about an error, try `rustc --explain E0277`.

From 7f83c784bd14a999b48f9b7e417a2c1e9008cfe2 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sun, 15 Mar 2026 13:40:39 -0400
Subject: [PATCH 0509/1059] Allow passing `expr` metavariable as a `cfg`
 predicate

---
 .../rustc_attr_parsing/src/attributes/cfg.rs  |  1 +
 .../src/attributes/cfg_select.rs              |  1 +
 compiler/rustc_attr_parsing/src/interface.rs  |  3 +
 compiler/rustc_attr_parsing/src/parser.rs     | 87 ++++++++++++++-----
 compiler/rustc_builtin_macros/src/cfg.rs      |  1 +
 compiler/rustc_expand/src/config.rs           |  1 +
 compiler/rustc_expand/src/expand.rs           |  1 +
 library/std/src/sys/thread_local/os.rs        | 20 +----
 library/std/src/thread/local.rs               | 55 +-----------
 tests/ui/macros/attr-expr.rs                  |  9 ++
 tests/ui/macros/attr-expr.stderr              | 13 +++
 tests/ui/macros/cfg-expr.rs                   | 44 ++++++++++
 tests/ui/macros/cfg_attr-expr.rs              |  9 ++
 tests/ui/macros/cfg_attr-expr.stderr          | 17 ++++
 tests/ui/macros/cfg_select-expr.rs            | 57 ++++++++++++
 15 files changed, 227 insertions(+), 92 deletions(-)
 create mode 100644 tests/ui/macros/attr-expr.rs
 create mode 100644 tests/ui/macros/attr-expr.stderr
 create mode 100644 tests/ui/macros/cfg-expr.rs
 create mode 100644 tests/ui/macros/cfg_attr-expr.rs
 create mode 100644 tests/ui/macros/cfg_attr-expr.stderr
 create mode 100644 tests/ui/macros/cfg_select-expr.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index d2f743f6c5d8..c88dff40b2a0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -363,6 +363,7 @@ fn parse_cfg_attr_internal<'a>(
     let meta = MetaItemOrLitParser::parse_single(
         parser,
         ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
+        true,
     )?;
     let pred_span = pred_start.with_hi(parser.token.span.hi());
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
index 7377159be370..96a4437c33a7 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
@@ -94,6 +94,7 @@ pub fn parse_cfg_select(
             let meta = MetaItemOrLitParser::parse_single(
                 p,
                 ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
+                true,
             )
             .map_err(|diag| diag.emit())?;
             let cfg_span = meta.span();
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index f75f63a0e811..a9e2bd3aa184 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -139,6 +139,7 @@ pub fn parse_single<T>(
         emit_errors: ShouldEmit,
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser) -> Option<T>,
         template: &AttributeTemplate,
+        allow_expr_metavar: bool,
     ) -> Option<T> {
         let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
             panic!("parse_single called on a doc attr")
@@ -152,6 +153,7 @@ pub fn parse_single<T>(
             &parts,
             &sess.psess,
             emit_errors,
+            allow_expr_metavar,
         )?;
         Self::parse_single_args(
             sess,
@@ -333,6 +335,7 @@ pub fn parse_attribute_list(
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
+                            false,
                         ) else {
                             continue;
                         };
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 354fbab9cfcf..ee77a1a9f9cd 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -109,6 +109,7 @@ pub fn from_attr_args<'sess>(
         parts: &[Symbol],
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
+        allow_expr_metavar: bool,
     ) -> Option<Self> {
         Some(match value {
             AttrArgs::Empty => Self::NoArgs,
@@ -122,6 +123,7 @@ pub fn from_attr_args<'sess>(
                         args.dspan.entire(),
                         psess,
                         ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden },
+                        allow_expr_metavar,
                     ) {
                         Ok(p) => return Some(ArgParser::List(p)),
                         Err(e) => {
@@ -147,9 +149,15 @@ pub fn from_attr_args<'sess>(
                 }
 
                 Self::List(
-                    MetaItemListParser::new(&args.tokens, args.dspan.entire(), psess, should_emit)
-                        .map_err(|e| should_emit.emit_err(e))
-                        .ok()?,
+                    MetaItemListParser::new(
+                        &args.tokens,
+                        args.dspan.entire(),
+                        psess,
+                        should_emit,
+                        allow_expr_metavar,
+                    )
+                    .map_err(|e| should_emit.emit_err(e))
+                    .ok()?,
                 )
             }
             AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
@@ -217,8 +225,9 @@ impl MetaItemOrLitParser {
     pub fn parse_single<'sess>(
         parser: &mut Parser<'sess>,
         should_emit: ShouldEmit,
+        allow_expr_metavar: bool,
     ) -> PResult<'sess, MetaItemOrLitParser> {
-        let mut this = MetaItemListParserContext { parser, should_emit };
+        let mut this = MetaItemListParserContext { parser, should_emit, allow_expr_metavar };
         this.parse_meta_item_inner()
     }
 
@@ -407,6 +416,7 @@ fn expr_to_lit<'sess>(
 struct MetaItemListParserContext<'a, 'sess> {
     parser: &'a mut Parser<'sess>,
     should_emit: ShouldEmit,
+    allow_expr_metavar: bool,
 }
 
 impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
@@ -448,19 +458,43 @@ fn unsuffixed_meta_item_from_lit(
     }
 
     fn parse_attr_item(&mut self) -> PResult<'sess, MetaItemParser> {
-        if let Some(MetaVarKind::Meta { has_meta_form }) = self.parser.token.is_metavar_seq() {
-            return if has_meta_form {
-                let attr_item = self
-                    .parser
-                    .eat_metavar_seq(MetaVarKind::Meta { has_meta_form: true }, |this| {
-                        MetaItemListParserContext { parser: this, should_emit: self.should_emit }
+        if let Some(metavar) = self.parser.token.is_metavar_seq() {
+            match metavar {
+                kind @ MetaVarKind::Expr { .. } if self.allow_expr_metavar => {
+                    return self
+                        .parser
+                        .eat_metavar_seq(kind, |this| {
+                            MetaItemListParserContext {
+                                parser: this,
+                                should_emit: self.should_emit,
+                                allow_expr_metavar: true,
+                            }
                             .parse_attr_item()
-                    })
-                    .unwrap();
-                Ok(attr_item)
-            } else {
-                self.parser.unexpected_any()
-            };
+                        })
+                        .ok_or_else(|| {
+                            self.parser.unexpected_any::<core::convert::Infallible>().unwrap_err()
+                        });
+                }
+                MetaVarKind::Meta { has_meta_form } => {
+                    return if has_meta_form {
+                        let attr_item = self
+                            .parser
+                            .eat_metavar_seq(MetaVarKind::Meta { has_meta_form: true }, |this| {
+                                MetaItemListParserContext {
+                                    parser: this,
+                                    should_emit: self.should_emit,
+                                    allow_expr_metavar: self.allow_expr_metavar,
+                                }
+                                .parse_attr_item()
+                            })
+                            .unwrap();
+                        Ok(attr_item)
+                    } else {
+                        self.parser.unexpected_any()
+                    };
+                }
+                _ => {}
+            }
         }
 
         let path = self.parser.parse_path(PathStyle::Mod)?;
@@ -469,8 +503,12 @@ fn parse_attr_item(&mut self) -> PResult<'sess, MetaItemParser> {
         let args = if self.parser.check(exp!(OpenParen)) {
             let start = self.parser.token.span;
             let (sub_parsers, _) = self.parser.parse_paren_comma_seq(|parser| {
-                MetaItemListParserContext { parser, should_emit: self.should_emit }
-                    .parse_meta_item_inner()
+                MetaItemListParserContext {
+                    parser,
+                    should_emit: self.should_emit,
+                    allow_expr_metavar: self.allow_expr_metavar,
+                }
+                .parse_meta_item_inner()
             })?;
             let end = self.parser.prev_token.span;
             ArgParser::List(MetaItemListParser { sub_parsers, span: start.with_hi(end.hi()) })
@@ -580,13 +618,15 @@ fn parse(
         psess: &'sess ParseSess,
         span: Span,
         should_emit: ShouldEmit,
+        allow_expr_metavar: bool,
     ) -> PResult<'sess, MetaItemListParser> {
         let mut parser = Parser::new(psess, tokens, None);
         if let ShouldEmit::ErrorsAndLints { recovery } = should_emit {
             parser = parser.recovery(recovery);
         }
 
-        let mut this = MetaItemListParserContext { parser: &mut parser, should_emit };
+        let mut this =
+            MetaItemListParserContext { parser: &mut parser, should_emit, allow_expr_metavar };
 
         // Presumably, the majority of the time there will only be one attr.
         let mut sub_parsers = ThinVec::with_capacity(1);
@@ -618,8 +658,15 @@ pub(crate) fn new<'sess>(
         span: Span,
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
+        allow_expr_metavar: bool,
     ) -> Result<Self, Diag<'sess>> {
-        MetaItemListParserContext::parse(tokens.clone(), psess, span, should_emit)
+        MetaItemListParserContext::parse(
+            tokens.clone(),
+            psess,
+            span,
+            should_emit,
+            allow_expr_metavar,
+        )
     }
 
     /// Lets you pick and choose as what you want to parse each element in the list
diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs
index 3ebde949b99b..cdd556388064 100644
--- a/compiler/rustc_builtin_macros/src/cfg.rs
+++ b/compiler/rustc_builtin_macros/src/cfg.rs
@@ -44,6 +44,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
     let meta = MetaItemOrLitParser::parse_single(
         &mut parser,
         ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
+        true,
     )
     .map_err(|diag| diag.emit())?;
     let cfg = AttributeParser::parse_single_args(
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 8e4039b32d94..367fadaea757 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -402,6 +402,7 @@ pub(crate) fn cfg_true(&self, attr: &Attribute, emit_errors: ShouldEmit) -> Eval
             emit_errors,
             parse_cfg,
             &CFG_TEMPLATE,
+            true,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 76a9a6f9d03d..db08790364c6 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -2224,6 +2224,7 @@ fn expand_cfg_true(
             ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             parse_cfg,
             &CFG_TEMPLATE,
+            true,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;
diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index 3f06c9bd1d77..e1d9d80c97b6 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -62,25 +62,7 @@ fn __rust_std_internal_init_fn() -> $t { $init }
     // by translating it into a `cfg`ed block and recursing.
     // https://doc.rust-lang.org/reference/conditional-compilation.html#railroad-ConfigurationPredicate
 
-    (@align $final_align:ident, cfg_attr(true, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
-        #[cfg(true)]
-        {
-            $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
-        }
-
-        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
-    },
-
-    (@align $final_align:ident, cfg_attr(false, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
-        #[cfg(false)]
-        {
-            $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
-        }
-
-        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
-    },
-
-    (@align $final_align:ident, cfg_attr($cfg_pred:meta, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
+    (@align $final_align:ident, cfg_attr($cfg_pred:expr, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
         #[cfg($cfg_pred)]
         {
             $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 1318d8dc2780..5de001838faf 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -198,41 +198,10 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         );
     ),
 
-    // it's a nested `cfg_attr(true, ...)`; recurse into RHS
-    (
-        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
-        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr(true, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
-        $($rest:tt)*
-    ) => (
-        $crate::thread::local_impl::thread_local_process_attrs!(
-            [] [];
-            @processing_cfg_attr { pred: (true), rhs: [$($cfg_rhs)*] };
-            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
-            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
-            $($rest)*
-        );
-    ),
-
-    // it's a nested `cfg_attr(false, ...)`; recurse into RHS
-    (
-        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
-        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr(false, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
-        $($rest:tt)*
-    ) => (
-        $crate::thread::local_impl::thread_local_process_attrs!(
-            [] [];
-            @processing_cfg_attr { pred: (false), rhs: [$($cfg_rhs)*] };
-            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
-            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
-            $($rest)*
-        );
-    ),
-
-
     // it's a nested `cfg_attr(..., ...)`; recurse into RHS
     (
         [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
-        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr($cfg_lhs:meta, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr($cfg_lhs:expr, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
         $($rest:tt)*
     ) => (
         $crate::thread::local_impl::thread_local_process_attrs!(
@@ -268,28 +237,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         );
     ),
 
-    // `cfg_attr(true, ...)` attribute; parse it
-    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr(true, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
-        $crate::thread::local_impl::thread_local_process_attrs!(
-            [] [];
-            @processing_cfg_attr { pred: (true), rhs: [$($cfg_rhs)*] };
-            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
-            $($rest)*
-        );
-    ),
-
-    // `cfg_attr(false, ...)` attribute; parse it
-    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr(false, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
-        $crate::thread::local_impl::thread_local_process_attrs!(
-            [] [];
-            @processing_cfg_attr { pred: (false), rhs: [$($cfg_rhs)*] };
-            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
-            $($rest)*
-        );
-    ),
-
     // `cfg_attr(..., ...)` attribute; parse it
-    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr($cfg_pred:meta, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr($cfg_pred:expr, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
         $crate::thread::local_impl::thread_local_process_attrs!(
             [] [];
             @processing_cfg_attr { pred: ($cfg_pred), rhs: [$($cfg_rhs)*] };
diff --git a/tests/ui/macros/attr-expr.rs b/tests/ui/macros/attr-expr.rs
new file mode 100644
index 000000000000..d2f5f5d184d6
--- /dev/null
+++ b/tests/ui/macros/attr-expr.rs
@@ -0,0 +1,9 @@
+macro_rules! foo {
+    ($e:expr) => {
+        #[$e]
+        //~^ ERROR expected identifier, found metavariable
+        fn foo() {}
+    }
+}
+foo!(inline);
+fn main() {}
diff --git a/tests/ui/macros/attr-expr.stderr b/tests/ui/macros/attr-expr.stderr
new file mode 100644
index 000000000000..034f116d017d
--- /dev/null
+++ b/tests/ui/macros/attr-expr.stderr
@@ -0,0 +1,13 @@
+error: expected identifier, found metavariable
+  --> $DIR/attr-expr.rs:3:11
+   |
+LL |         #[$e]
+   |           ^^ expected identifier, found metavariable
+...
+LL | foo!(inline);
+   | ------------ in this macro invocation
+   |
+   = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/macros/cfg-expr.rs b/tests/ui/macros/cfg-expr.rs
new file mode 100644
index 000000000000..e9ca6e3d7b10
--- /dev/null
+++ b/tests/ui/macros/cfg-expr.rs
@@ -0,0 +1,44 @@
+//@ run-pass
+macro_rules! foo {
+    ($e:expr, $n:ident) => {
+        #[cfg($e)]
+        macro_rules! $n {
+            () => {}
+        }
+
+        #[cfg_attr($e, allow(non_snake_case))]
+        #[cfg($e)]
+        fn $n() {
+            #[cfg($e)]
+            $n!();
+        }
+
+        #[cfg_attr(not($e), allow(unused))]
+        #[cfg(not($e))]
+        fn $n() {
+            panic!()
+        }
+    }
+}
+foo!(true, BAR);
+foo!(any(true, unix, target_pointer_width = "64"), baz);
+foo!(target_pointer_width = "64", quux);
+foo!(false, haha);
+
+fn main() {
+    BAR();
+    BAR!();
+    baz();
+    baz!();
+    #[cfg(target_pointer_width = "64")]
+    quux();
+    #[cfg(target_pointer_width = "64")]
+    quux!();
+    #[cfg(panic = "unwind")]
+    {
+        let result = std::panic::catch_unwind(|| {
+            haha();
+        });
+        assert!(result.is_err());
+    }
+}
diff --git a/tests/ui/macros/cfg_attr-expr.rs b/tests/ui/macros/cfg_attr-expr.rs
new file mode 100644
index 000000000000..1dab2cae59fa
--- /dev/null
+++ b/tests/ui/macros/cfg_attr-expr.rs
@@ -0,0 +1,9 @@
+macro_rules! foo {
+    ($e:expr) => {
+        #[cfg_attr(true, $e)]
+        //~^ ERROR expected identifier, found metavariable
+        fn foo() {}
+    }
+}
+foo!(inline);
+fn main() {}
diff --git a/tests/ui/macros/cfg_attr-expr.stderr b/tests/ui/macros/cfg_attr-expr.stderr
new file mode 100644
index 000000000000..a46ea104b939
--- /dev/null
+++ b/tests/ui/macros/cfg_attr-expr.stderr
@@ -0,0 +1,17 @@
+error: expected identifier, found metavariable
+  --> $DIR/cfg_attr-expr.rs:3:26
+   |
+LL |         #[cfg_attr(true, $e)]
+   |         -----------------^^--
+   |         |                |
+   |         |                expected identifier, found metavariable
+   |         help: must be of the form: `#[cfg_attr(predicate, attr1, attr2, ...)]`
+...
+LL | foo!(inline);
+   | ------------ in this macro invocation
+   |
+   = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
+   = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/macros/cfg_select-expr.rs b/tests/ui/macros/cfg_select-expr.rs
new file mode 100644
index 000000000000..90e894562a16
--- /dev/null
+++ b/tests/ui/macros/cfg_select-expr.rs
@@ -0,0 +1,57 @@
+//@ run-pass
+#![allow(unreachable_cfg_select_predicates)]
+
+macro_rules! foo {
+    ($e:expr, $n:ident) => {
+        cfg_select! {
+            $e => {
+                macro_rules! $n {
+                    () => {}
+                }
+            }
+            _ => {}
+        }
+
+        cfg_select! {
+            $e => {
+                #[cfg_attr($e, allow(non_snake_case))]
+                fn $n() {
+                    cfg_select! {
+                        $e => {
+                            $n!();
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            not($e) => {
+                #[cfg_attr(not($e), allow(unused))]
+                fn $n() {
+                    panic!()
+                }
+            }
+        }
+    }
+}
+foo!(true, BAR);
+foo!(any(true, unix, target_pointer_width = "64"), baz);
+foo!(target_pointer_width = "64", quux);
+foo!(false, haha);
+
+fn main() {
+    BAR();
+    BAR!();
+    baz();
+    baz!();
+    #[cfg(target_pointer_width = "64")]
+    quux();
+    #[cfg(target_pointer_width = "64")]
+    quux!();
+    #[cfg(panic = "unwind")]
+    {
+        let result = std::panic::catch_unwind(|| {
+            haha();
+        });
+        assert!(result.is_err());
+    }
+}

From 1bc2c442870a669669880b7487d46f4ce90e71b0 Mon Sep 17 00:00:00 2001
From: Avinash Thakur <iamavinashthakur.at@gmail.com>
Date: Sun, 8 Mar 2026 20:51:00 +0530
Subject: [PATCH 0510/1059] fix: remove empty angle brackets in inline type
 alias code assist.

fixes https://github.com/rust-lang/rust-analyzer/issues/21769
---
 .../src/handlers/inline_type_alias.rs         | 110 +++++++++++++++++-
 1 file changed, 105 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
index c7a48f3261a9..f3ebe6107819 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_type_alias.rs
@@ -12,7 +12,7 @@
 use syntax::ast::syntax_factory::SyntaxFactory;
 use syntax::syntax_editor::SyntaxEditor;
 use syntax::{
-    AstNode, NodeOrToken, SyntaxNode,
+    AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T,
     ast::{self, HasGenericParams, HasName},
 };
 
@@ -322,12 +322,42 @@ fn create_replacement(
         if let Some(old_lifetime) = ast::Lifetime::cast(syntax.clone()) {
             if let Some(new_lifetime) = lifetime_map.0.get(&old_lifetime.to_string()) {
                 if new_lifetime.text() == "'_" {
-                    removals.push(NodeOrToken::Node(syntax.clone()));
+                    // Check if this lifetime is inside a LifetimeArg (in angle brackets)
+                    if let Some(lifetime_arg) =
+                        old_lifetime.syntax().parent().and_then(ast::LifetimeArg::cast)
+                    {
+                        // Remove LifetimeArg and associated comma/whitespace
+                        let lifetime_arg_syntax = lifetime_arg.syntax();
+                        removals.push(NodeOrToken::Node(lifetime_arg_syntax.clone()));
 
-                    if let Some(ws) = syntax.next_sibling_or_token() {
-                        removals.push(ws.clone());
+                        // Remove comma and whitespace (look forward then backward)
+                        let comma_and_ws: Vec<_> = lifetime_arg_syntax
+                            .siblings_with_tokens(syntax::Direction::Next)
+                            .skip(1)
+                            .take_while(|it| it.as_token().is_some())
+                            .take_while_inclusive(|it| it.kind() == T![,])
+                            .collect();
+
+                        if comma_and_ws.iter().any(|it| it.kind() == T![,]) {
+                            removals.extend(comma_and_ws);
+                        } else {
+                            // No comma after, try before
+                            let comma_and_ws: Vec<_> = lifetime_arg_syntax
+                                .siblings_with_tokens(syntax::Direction::Prev)
+                                .skip(1)
+                                .take_while(|it| it.as_token().is_some())
+                                .take_while_inclusive(|it| it.kind() == T![,])
+                                .collect();
+                            removals.extend(comma_and_ws);
+                        }
+                        continue;
+                    }
+                    removals.push(NodeOrToken::Node(syntax.clone()));
+                    if let Some(ws) = syntax.next_sibling_or_token()
+                        && ws.kind() == SyntaxKind::WHITESPACE
+                    {
+                        removals.push(ws);
                     }
-
                     continue;
                 }
 
@@ -349,6 +379,34 @@ fn create_replacement(
         }
     }
 
+    // Deduplicate removals to avoid intersecting changes
+    removals.sort_by_key(|n| n.text_range().start());
+    removals.dedup();
+
+    // Remove GenericArgList entirely if all its args are being removed (avoids empty angle brackets)
+    let generic_arg_lists_to_check: Vec<_> =
+        updated_concrete_type.descendants().filter_map(ast::GenericArgList::cast).collect();
+
+    for generic_arg_list in generic_arg_lists_to_check {
+        let will_be_empty = generic_arg_list.generic_args().all(|arg| match arg {
+            ast::GenericArg::LifetimeArg(lt_arg) => removals.iter().any(|removal| {
+                if let NodeOrToken::Node(node) = removal { node == lt_arg.syntax() } else { false }
+            }),
+            _ => false,
+        });
+
+        if will_be_empty && generic_arg_list.generic_args().next().is_some() {
+            removals.retain(|removal| {
+                if let NodeOrToken::Node(node) = removal {
+                    !node.ancestors().any(|anc| anc == *generic_arg_list.syntax())
+                } else {
+                    true
+                }
+            });
+            removals.push(NodeOrToken::Node(generic_arg_list.syntax().clone()));
+        }
+    }
+
     for (old, new) in replacements {
         editor.replace(old, new);
     }
@@ -946,6 +1004,48 @@ trait Tr {
         );
     }
 
+    #[test]
+    fn inline_types_with_lifetime() {
+        check_assist(
+            inline_type_alias_uses,
+            r#"
+struct A<'a, 'b>(pub &'a mut &'b mut ());
+
+type $0T<'a, 'b> = A<'a, 'b>;
+
+fn foo(_: T) {}
+"#,
+            r#"
+struct A<'a, 'b>(pub &'a mut &'b mut ());
+
+
+
+fn foo(_: A) {}
+"#,
+        );
+    }
+
+    #[test]
+    fn mixed_lifetime_and_type_args() {
+        check_assist(
+            inline_type_alias,
+            r#"
+type Foo<'a, T> = Bar<'a, T>;
+struct Bar<'a, T>(&'a T);
+fn main() {
+    let a: $0Foo<u32>;
+}
+"#,
+            r#"
+type Foo<'a, T> = Bar<'a, T>;
+struct Bar<'a, T>(&'a T);
+fn main() {
+    let a: Bar<u32>;
+}
+"#,
+        );
+    }
+
     mod inline_type_alias_uses {
         use crate::{handlers::inline_type_alias::inline_type_alias_uses, tests::check_assist};
 

From 6dcb85d55db58f6417aa64256db441425d552dbd Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 15 Mar 2026 20:21:47 +0000
Subject: [PATCH 0511/1059] remove several redundant tests

---
 tests/ui/binding/match-naked-record.rs | 12 --------
 tests/ui/issues/issue-4830.rs          | 10 -------
 tests/ui/issues/issue-5192.rs          | 38 --------------------------
 tests/ui/macros/unreachable.rs         |  7 -----
 tests/ui/moves/array-copy-move.rs      |  8 ------
 5 files changed, 75 deletions(-)
 delete mode 100644 tests/ui/binding/match-naked-record.rs
 delete mode 100644 tests/ui/issues/issue-4830.rs
 delete mode 100644 tests/ui/issues/issue-5192.rs
 delete mode 100644 tests/ui/macros/unreachable.rs
 delete mode 100644 tests/ui/moves/array-copy-move.rs

diff --git a/tests/ui/binding/match-naked-record.rs b/tests/ui/binding/match-naked-record.rs
deleted file mode 100644
index ce9489a00f2c..000000000000
--- a/tests/ui/binding/match-naked-record.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-struct X { x: isize }
-
-pub fn main() {
-    let _x = match 0 {
-      _ => X {
-        x: 0
-      }
-    };
-}
diff --git a/tests/ui/issues/issue-4830.rs b/tests/ui/issues/issue-4830.rs
deleted file mode 100644
index d48c13fd10b1..000000000000
--- a/tests/ui/issues/issue-4830.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ check-pass
-#![allow(dead_code)]
-
-
-pub struct Scheduler {
-    /// The event loop used to drive the scheduler and perform I/O
-    event_loop: Box<isize>
-}
-
-pub fn main() { }
diff --git a/tests/ui/issues/issue-5192.rs b/tests/ui/issues/issue-5192.rs
deleted file mode 100644
index be5d70f09b3c..000000000000
--- a/tests/ui/issues/issue-5192.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-pub trait EventLoop {
-    fn dummy(&self) { }
-}
-
-pub struct UvEventLoop {
-    uvio: isize
-}
-
-impl UvEventLoop {
-    pub fn new() -> UvEventLoop {
-        UvEventLoop {
-            uvio: 0
-        }
-    }
-}
-
-impl EventLoop for UvEventLoop {
-}
-
-pub struct Scheduler {
-    event_loop: Box<dyn EventLoop+'static>,
-}
-
-impl Scheduler {
-
-    pub fn new(event_loop: Box<dyn EventLoop+'static>) -> Scheduler {
-        Scheduler {
-            event_loop: event_loop,
-        }
-    }
-}
-
-pub fn main() {
-    let _sched = Scheduler::new(Box::new(UvEventLoop::new()) as Box<dyn EventLoop>);
-}
diff --git a/tests/ui/macros/unreachable.rs b/tests/ui/macros/unreachable.rs
deleted file mode 100644
index c5cea5551cfc..000000000000
--- a/tests/ui/macros/unreachable.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-fail
-//@ error-pattern:internal error: entered unreachable code
-//@ needs-subprocess
-
-fn main() {
-    unreachable!()
-}
diff --git a/tests/ui/moves/array-copy-move.rs b/tests/ui/moves/array-copy-move.rs
deleted file mode 100644
index ea95bc06a369..000000000000
--- a/tests/ui/moves/array-copy-move.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//! regression test for issue https://github.com/rust-lang/rust/issues/16783
-//@ run-pass
-#![allow(unused_variables)]
-
-pub fn main() {
-    let x = [1, 2, 3];
-    let y = x;
-}

From f3f4ab9205af504e9f58268645b41b743587a965 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 10 Mar 2026 11:57:05 +1100
Subject: [PATCH 0512/1059] Remove `QueryInfo`.

`CycleError` has one field containing a `(Span, QueryStackFrame<I>)` and
another field containing a `QueryInfo`, which is a struct containing
just a `Span` and a `QueryStackFrame<I>`.

We already have the `Spanned` type for adding a span to something. This
commit uses it for both fields in `CycleError`, removing the need for
`QueryInfo`. Which is good for the following reasons.
- Any type with `Info` in the name is suspect, IMO.
- `QueryInfo` can no longer be confused with the similar `QueryJobInfo`.
- The doc comment on `QueryInfo` was wrong; it didn't contain a query
  key.
---
 compiler/rustc_middle/src/query/job.rs        |  9 -----
 compiler/rustc_middle/src/query/mod.rs        |  2 +-
 compiler/rustc_middle/src/query/plumbing.rs   | 10 +++---
 .../rustc_query_impl/src/from_cycle_error.rs  | 28 ++++++++--------
 compiler/rustc_query_impl/src/job.rs          | 33 +++++++++----------
 5 files changed, 37 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index b2e5649106ce..574a671fd640 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -7,17 +7,8 @@
 use rustc_span::Span;
 
 use crate::query::plumbing::CycleError;
-use crate::query::stack::QueryStackFrame;
 use crate::ty::TyCtxt;
 
-/// Represents a span and a query key.
-#[derive(Clone, Debug)]
-pub struct QueryInfo<'tcx> {
-    /// The span corresponding to the reason for which this query was required.
-    pub span: Span,
-    pub frame: QueryStackFrame<'tcx>,
-}
-
 /// A value uniquely identifying an active query job.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct QueryJobId(pub NonZero<u64>);
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index e6b8a931071f..517999baba1e 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1,7 +1,7 @@
 use rustc_hir::def_id::LocalDefId;
 
 pub use self::caches::{DefIdCache, DefaultCache, QueryCache, SingleCache, VecCache};
-pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryWaiter};
+pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
     ActiveKeyStatus, CycleError, EnsureMode, IntoQueryParam, QueryMode, QueryState, TyCtxtAt,
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 90491bc402fb..161d975c2f51 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -8,7 +8,7 @@
 use rustc_errors::Diag;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
-use rustc_span::Span;
+use rustc_span::{Span, Spanned};
 pub use sealed::IntoQueryParam;
 
 use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
@@ -16,7 +16,7 @@
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
 use crate::query::stack::QueryStackFrame;
-use crate::query::{QueryCache, QueryInfo, QueryJob};
+use crate::query::{QueryCache, QueryJob};
 use crate::ty::TyCtxt;
 
 /// For a particular query, keeps track of "active" keys, i.e. keys whose
@@ -53,8 +53,10 @@ pub enum ActiveKeyStatus<'tcx> {
 #[derive(Clone, Debug)]
 pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
-    pub usage: Option<(Span, QueryStackFrame<'tcx>)>,
-    pub cycle: Vec<QueryInfo<'tcx>>,
+    pub usage: Option<Spanned<QueryStackFrame<'tcx>>>,
+
+    /// The span here corresponds to the reason for which this query was required.
+    pub cycle: Vec<Spanned<QueryStackFrame<'tcx>>>,
 }
 
 #[derive(Debug)]
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 2e2f23d6b866..fa508419b52f 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -76,11 +76,11 @@ fn fn_sig<'tcx>(
 fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> ! {
     let mut item_and_field_ids = Vec::new();
     let mut representable_ids = FxHashSet::default();
-    for info in &cycle_error.cycle {
-        if info.frame.dep_kind == DepKind::check_representability
-            && let Some(field_id) = info.frame.def_id
+    for frame in &cycle_error.cycle {
+        if frame.node.dep_kind == DepKind::check_representability
+            && let Some(field_id) = frame.node.def_id
             && let Some(field_id) = field_id.as_local()
-            && let Some(DefKind::Field) = info.frame.tagged_key.def_kind(tcx)
+            && let Some(DefKind::Field) = frame.node.tagged_key.def_kind(tcx)
         {
             let parent_id = tcx.parent(field_id.to_def_id());
             let item_id = match tcx.def_kind(parent_id) {
@@ -90,8 +90,8 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
             item_and_field_ids.push((item_id.expect_local(), field_id));
         }
     }
-    for info in &cycle_error.cycle {
-        if let TaggedQueryKey::check_representability_adt_ty(key) = info.frame.tagged_key
+    for frame in &cycle_error.cycle {
+        if let TaggedQueryKey::check_representability_adt_ty(key) = frame.node.tagged_key
             && let Some(adt) = key.ty_adt_def()
             && let Some(def_id) = adt.did().as_local()
             && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
@@ -109,9 +109,9 @@ fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> &'tcx
     search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
-            if let Some(info) = cycle.get(0)
-                && info.frame.dep_kind == DepKind::variances_of
-                && let Some(def_id) = info.frame.def_id
+            if let Some(frame) = cycle.get(0)
+                && frame.node.dep_kind == DepKind::variances_of
+                && let Some(def_id) = frame.node.def_id
             {
                 let n = tcx.generics_of(def_id).own_params.len();
                 ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
@@ -121,7 +121,7 @@ fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> &'tcx
         },
         || {
             span_bug!(
-                cycle_error.usage.as_ref().unwrap().0,
+                cycle_error.usage.as_ref().unwrap().span,
                 "only `variances_of` returns `&[ty::Variance]`"
             )
         },
@@ -154,7 +154,7 @@ fn layout_of<'tcx>(
     let diag = search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
-            if let TaggedQueryKey::layout_of(key) = cycle[0].frame.tagged_key
+            if let TaggedQueryKey::layout_of(key) = cycle[0].node.tagged_key
                 && let ty::Coroutine(def_id, _) = key.value.kind()
                 && let Some(def_id) = def_id.as_local()
                 && let def_kind = tcx.def_kind(def_id)
@@ -178,8 +178,8 @@ fn layout_of<'tcx>(
                     tcx.def_kind_descr_article(def_kind, def_id.to_def_id()),
                     tcx.def_kind_descr(def_kind, def_id.to_def_id()),
                 );
-                for (i, info) in cycle.iter().enumerate() {
-                    let TaggedQueryKey::layout_of(frame_key) = info.frame.tagged_key else {
+                for (i, frame) in cycle.iter().enumerate() {
+                    let TaggedQueryKey::layout_of(frame_key) = frame.node.tagged_key else {
                         continue;
                     };
                     let &ty::Coroutine(frame_def_id, _) = frame_key.value.kind() else {
@@ -189,7 +189,7 @@ fn layout_of<'tcx>(
                         continue;
                     };
                     let frame_span =
-                        info.frame.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
+                        frame.node.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
                     if frame_span.is_dummy() {
                         continue;
                     }
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 90fb1c26910a..6bd4c4af5daf 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -7,10 +7,10 @@
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
 use rustc_middle::query::{
-    CycleError, QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
+    CycleError, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
 };
 use rustc_middle::ty::TyCtxt;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, respan};
 
 use crate::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
 
@@ -64,7 +64,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
 
     while let Some(job) = current_job {
         let info = &job_map.map[&job];
-        cycle.push(QueryInfo { span: info.job.span, frame: info.frame.clone() });
+        cycle.push(respan(info.job.span, info.frame.clone()));
 
         if job == id {
             cycle.reverse();
@@ -77,7 +77,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
             // Find out why the cycle itself was used
             let usage = try {
                 let parent = info.job.parent?;
-                (info.job.span, job_map.frame_of(parent).clone())
+                respan(info.job.span, job_map.frame_of(parent).clone())
             };
             return CycleError { usage, cycle };
         }
@@ -313,14 +313,14 @@ struct EntryPoint {
 
         let usage = entry_point
             .query_waiting_on_cycle
-            .map(|(span, job)| (span, job_map.frame_of(job).clone()));
+            .map(|(span, job)| respan(span, job_map.frame_of(job).clone()));
 
         // Create the cycle error
         let error = CycleError {
             usage,
             cycle: stack
                 .iter()
-                .map(|&(span, job)| QueryInfo { span, frame: job_map.frame_of(job).clone() })
+                .map(|&(span, job)| respan(span, job_map.frame_of(job).clone()))
                 .collect(),
         };
 
@@ -454,12 +454,12 @@ pub(crate) fn report_cycle<'tcx>(
 ) -> Diag<'tcx> {
     assert!(!stack.is_empty());
 
-    let span = stack[0].frame.tagged_key.default_span(tcx, stack[1 % stack.len()].span);
+    let span = stack[0].node.tagged_key.default_span(tcx, stack[1 % stack.len()].span);
 
     let mut cycle_stack = Vec::new();
 
     use crate::error::StackCount;
-    let stack_bottom = stack[0].frame.tagged_key.description(tcx);
+    let stack_bottom = stack[0].node.tagged_key.description(tcx);
     let stack_count = if stack.len() == 1 {
         StackCount::Single { stack_bottom: stack_bottom.clone() }
     } else {
@@ -467,28 +467,27 @@ pub(crate) fn report_cycle<'tcx>(
     };
 
     for i in 1..stack.len() {
-        let frame = &stack[i].frame;
-        let span = frame.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
-        cycle_stack
-            .push(crate::error::CycleStack { span, desc: frame.tagged_key.description(tcx) });
+        let node = &stack[i].node;
+        let span = node.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
+        cycle_stack.push(crate::error::CycleStack { span, desc: node.tagged_key.description(tcx) });
     }
 
     let mut cycle_usage = None;
-    if let Some((span, ref query)) = *usage {
+    if let Some(usage) = usage {
         cycle_usage = Some(crate::error::CycleUsage {
-            span: query.tagged_key.default_span(tcx, span),
-            usage: query.tagged_key.description(tcx),
+            span: usage.node.tagged_key.default_span(tcx, usage.span),
+            usage: usage.node.tagged_key.description(tcx),
         });
     }
 
     let alias = if stack
         .iter()
-        .all(|entry| matches!(entry.frame.tagged_key.def_kind(tcx), Some(DefKind::TyAlias)))
+        .all(|entry| matches!(entry.node.tagged_key.def_kind(tcx), Some(DefKind::TyAlias)))
     {
         Some(crate::error::Alias::Ty)
     } else if stack
         .iter()
-        .all(|entry| entry.frame.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
+        .all(|entry| entry.node.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
     {
         Some(crate::error::Alias::Trait)
     } else {

From 1d43a421b5ec13e9c8f6d43c92dedad9c9c5fe0c Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 11 Mar 2026 14:22:31 +1100
Subject: [PATCH 0513/1059] Remove `Clone` impl from `CycleError`.

It's unused.
---
 compiler/rustc_middle/src/query/plumbing.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 161d975c2f51..6f18c01577da 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -50,7 +50,7 @@ pub enum ActiveKeyStatus<'tcx> {
     Poisoned,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
     pub usage: Option<Spanned<QueryStackFrame<'tcx>>>,

From a893257ceab1ea549112935c83c979daa123ebb8 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 15 Mar 2026 22:11:26 +0000
Subject: [PATCH 0514/1059] remove usages of to-be-deprecated numeric constants

---
 compiler/rustc_middle/src/dep_graph/serialized.rs |  2 +-
 library/coretests/tests/array.rs                  |  2 +-
 library/coretests/tests/num/int_macros.rs         |  3 ++-
 library/coretests/tests/num/uint_macros.rs        | 15 +++++++--------
 library/stdarch/crates/core_arch/src/mips/msa.rs  |  1 -
 src/tools/rustfmt/src/vertical.rs                 |  2 +-
 tests/ui/consts/issue-90762.rs                    |  2 +-
 7 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/serialized.rs b/compiler/rustc_middle/src/dep_graph/serialized.rs
index 8a4ac4b5e5ac..2f3d9eac7386 100644
--- a/compiler/rustc_middle/src/dep_graph/serialized.rs
+++ b/compiler/rustc_middle/src/dep_graph/serialized.rs
@@ -43,7 +43,7 @@
 use std::cmp::max;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use std::{iter, mem, u64};
+use std::{iter, mem};
 
 use rustc_data_structures::fingerprint::{Fingerprint, PackedFingerprint};
 use rustc_data_structures::fx::FxHashMap;
diff --git a/library/coretests/tests/array.rs b/library/coretests/tests/array.rs
index 2b4429092e98..5a24f02cbf3d 100644
--- a/library/coretests/tests/array.rs
+++ b/library/coretests/tests/array.rs
@@ -646,7 +646,7 @@ fn array_mixed_equality_integers() {
 
 #[test]
 fn array_mixed_equality_nans() {
-    let array3: [f32; 3] = [1.0, std::f32::NAN, 3.0];
+    let array3: [f32; 3] = [1.0, f32::NAN, 3.0];
 
     let slice3: &[f32] = &{ array3 };
     assert!(!(array3 == slice3));
diff --git a/library/coretests/tests/num/int_macros.rs b/library/coretests/tests/num/int_macros.rs
index 37336f49ef1b..2b641f595eba 100644
--- a/library/coretests/tests/num/int_macros.rs
+++ b/library/coretests/tests/num/int_macros.rs
@@ -2,7 +2,8 @@ macro_rules! int_module {
     ($T:ident, $U:ident) => {
         use core::num::ParseIntError;
         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
-        use core::$T::*;
+        const MAX: $T = $T::MAX;
+        const MIN: $T = $T::MIN;
 
         const UMAX: $U = $U::MAX;
 
diff --git a/library/coretests/tests/num/uint_macros.rs b/library/coretests/tests/num/uint_macros.rs
index 240c66fd5c71..8dfa0924bd36 100644
--- a/library/coretests/tests/num/uint_macros.rs
+++ b/library/coretests/tests/num/uint_macros.rs
@@ -2,15 +2,14 @@ macro_rules! uint_module {
     ($T:ident) => {
         use core::num::ParseIntError;
         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
-        use core::$T::*;
 
         use crate::num;
 
         #[test]
         fn test_overflows() {
-            assert!(MAX > 0);
-            assert!(MIN <= 0);
-            assert!((MIN + MAX).wrapping_add(1) == 0);
+            assert!($T::MAX > 0);
+            assert!($T::MIN <= 0);
+            assert!(($T::MIN + $T::MAX).wrapping_add(1) == 0);
         }
 
         #[test]
@@ -25,7 +24,7 @@ fn test_bitwise_operators() {
             assert!(0b0110 as $T == (0b1100 as $T).bitxor(0b1010 as $T));
             assert!(0b1110 as $T == (0b0111 as $T).shl(1));
             assert!(0b0111 as $T == (0b1110 as $T).shr(1));
-            assert!(MAX - (0b1011 as $T) == (0b1011 as $T).not());
+            assert!($T::MAX - (0b1011 as $T) == (0b1011 as $T).not());
         }
 
         const A: $T = 0b0101100;
@@ -361,7 +360,7 @@ fn test_pow() {
                     assert_eq_const_safe!($T: R.wrapping_pow(2), 1 as $T);
                     assert_eq_const_safe!(Option<$T>: R.checked_pow(2), None);
                     assert_eq_const_safe!(($T, bool): R.overflowing_pow(2), (1 as $T, true));
-                    assert_eq_const_safe!($T: R.saturating_pow(2), MAX);
+                    assert_eq_const_safe!($T: R.saturating_pow(2), $T::MAX);
                 }
             }
 
@@ -468,14 +467,14 @@ fn test_div_ceil() {
             fn test_next_multiple_of() {
                 assert_eq_const_safe!($T: (16 as $T).next_multiple_of(8), 16);
                 assert_eq_const_safe!($T: (23 as $T).next_multiple_of(8), 24);
-                assert_eq_const_safe!($T: MAX.next_multiple_of(1), MAX);
+                assert_eq_const_safe!($T: $T::MAX.next_multiple_of(1), $T::MAX);
             }
 
             fn test_checked_next_multiple_of() {
                 assert_eq_const_safe!(Option<$T>: (16 as $T).checked_next_multiple_of(8), Some(16));
                 assert_eq_const_safe!(Option<$T>: (23 as $T).checked_next_multiple_of(8), Some(24));
                 assert_eq_const_safe!(Option<$T>: (1 as $T).checked_next_multiple_of(0), None);
-                assert_eq_const_safe!(Option<$T>: MAX.checked_next_multiple_of(2), None);
+                assert_eq_const_safe!(Option<$T>: $T::MAX.checked_next_multiple_of(2), None);
             }
 
             fn test_is_next_multiple_of() {
diff --git a/library/stdarch/crates/core_arch/src/mips/msa.rs b/library/stdarch/crates/core_arch/src/mips/msa.rs
index 563e121a7bad..6246433da558 100644
--- a/library/stdarch/crates/core_arch/src/mips/msa.rs
+++ b/library/stdarch/crates/core_arch/src/mips/msa.rs
@@ -9187,7 +9187,6 @@ mod tests {
         core_arch::{mips::msa::*, simd::*},
         mem,
     };
-    use std::{f32, f64};
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "msa")]
diff --git a/src/tools/rustfmt/src/vertical.rs b/src/tools/rustfmt/src/vertical.rs
index 21e34d29710f..fd9a4a7db6a7 100644
--- a/src/tools/rustfmt/src/vertical.rs
+++ b/src/tools/rustfmt/src/vertical.rs
@@ -198,7 +198,7 @@ fn struct_field_prefix_max_min_width<T: AlignedItem>(
                 .rewrite_prefix(context, shape)
                 .map(|field_str| trimmed_last_line_width(&field_str))
         })
-        .fold_ok((0, ::std::usize::MAX), |(max_len, min_len), len| {
+        .fold_ok((0, usize::MAX), |(max_len, min_len), len| {
             (cmp::max(max_len, len), cmp::min(min_len, len))
         })
         .unwrap_or((0, 0))
diff --git a/tests/ui/consts/issue-90762.rs b/tests/ui/consts/issue-90762.rs
index db40e50d4995..cc060366b80b 100644
--- a/tests/ui/consts/issue-90762.rs
+++ b/tests/ui/consts/issue-90762.rs
@@ -27,5 +27,5 @@ fn main() {
     for (i, b) in FOO.iter().enumerate() {
         assert!(b.load(Ordering::Relaxed), "{} not set", i);
     }
-    assert_eq!(BAR.fetch_add(1, Ordering::Relaxed), usize::max_value());
+    assert_eq!(BAR.fetch_add(1, Ordering::Relaxed), usize::MAX);
 }

From 8dba85c4873f053914b4d5ea8bfafaf6e4e24561 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 08:22:05 +0530
Subject: [PATCH 0515/1059] update wrap_expr in utils ref_field_expr and update
 corresponding handler

---
 .../src/handlers/destructure_struct_binding.rs        | 11 ++++-------
 .../crates/ide-assists/src/utils/ref_field_expr.rs    |  8 ++++----
 2 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 4c4cee1d7811..0f5ef0548cf5 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -381,23 +381,20 @@ fn build_usage_edit(
         Some(field_expr) => Some({
             let field_name: SmolStr = field_expr.name_ref()?.to_string().into();
             let new_field_name = field_names.get(&field_name)?;
-            let new_expr = ast::make::expr_path(ast::make::ext::ident_path(new_field_name));
+            let new_expr = make.expr_path(make.ident_path(new_field_name));
 
             // If struct binding is a reference, we might need to deref field usages
             if data.is_ref {
                 let (replace_expr, ref_data) = determine_ref_and_parens(ctx, &field_expr);
-                (
-                    replace_expr.syntax().clone_for_update(),
-                    ref_data.wrap_expr(new_expr).syntax().clone_for_update(),
-                )
+                (replace_expr.syntax().clone(), ref_data.wrap_expr(new_expr, make).syntax().clone())
             } else {
-                (field_expr.syntax().clone(), new_expr.syntax().clone_for_update())
+                (field_expr.syntax().clone(), new_expr.syntax().clone())
             }
         }),
         None => Some((
             usage.name.syntax().as_node().unwrap().clone(),
             make.expr_macro(
-                ast::make::ext::ident_path("todo"),
+                make.ident_path("todo"),
                 make.token_tree(syntax::SyntaxKind::L_PAREN, []),
             )
             .syntax()
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils/ref_field_expr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils/ref_field_expr.rs
index df8ad4111234..fc9bf210e487 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils/ref_field_expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils/ref_field_expr.rs
@@ -5,7 +5,7 @@
 //! based on the parent of the existing expression.
 use syntax::{
     AstNode, T,
-    ast::{self, FieldExpr, MethodCallExpr, make, syntax_factory::SyntaxFactory},
+    ast::{self, FieldExpr, MethodCallExpr, syntax_factory::SyntaxFactory},
 };
 
 use crate::AssistContext;
@@ -119,13 +119,13 @@ pub(crate) struct RefData {
 
 impl RefData {
     /// Derefs `expr` and wraps it in parens if necessary
-    pub(crate) fn wrap_expr(&self, mut expr: ast::Expr) -> ast::Expr {
+    pub(crate) fn wrap_expr(&self, mut expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {
         if self.needs_deref {
-            expr = make::expr_prefix(T![*], expr).into();
+            expr = make.expr_prefix(T![*], expr).into();
         }
 
         if self.needs_parentheses {
-            expr = make::expr_paren(expr).into();
+            expr = make.expr_paren(expr).into();
         }
 
         expr

From 7f3bc0b0a825d6e06f0955436e522c1ecad75f3b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 08:22:50 +0530
Subject: [PATCH 0516/1059] update wrap_block to accept SyntaxFactory and
 correspondingly update the handler which depends on it

---
 .../crates/ide-assists/src/handlers/move_guard.rs     | 11 ++++++-----
 .../rust-analyzer/crates/ide-assists/src/utils.rs     |  4 ++--
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
index b4c347ff36a7..80587372e516 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
@@ -3,7 +3,7 @@
     SyntaxKind::WHITESPACE,
     TextRange,
     ast::{
-        AstNode, BlockExpr, ElseBranch, Expr, IfExpr, MatchArm, Pat, edit::AstNodeEdit, make,
+        AstNode, BlockExpr, ElseBranch, Expr, IfExpr, MatchArm, Pat, edit::AstNodeEdit,
         prec::ExprPrecedence, syntax_factory::SyntaxFactory,
     },
     syntax_editor::Element,
@@ -53,14 +53,15 @@ pub(crate) fn move_guard_to_arm_body(acc: &mut Assists, ctx: &AssistContext<'_>)
     let space_after_arrow = match_arm.fat_arrow_token()?.next_sibling_or_token();
 
     let arm_expr = match_arm.expr()?;
+    let make = SyntaxFactory::without_mappings();
     let if_branch = chain([&match_arm], &rest_arms)
         .rfold(None, |else_branch, arm| {
             if let Some(guard) = arm.guard() {
-                let then_branch = crate::utils::wrap_block(&arm.expr()?);
+                let then_branch = crate::utils::wrap_block(&arm.expr()?, &make);
                 let guard_condition = guard.condition()?.reset_indent();
-                Some(make::expr_if(guard_condition, then_branch, else_branch).into())
+                Some(make.expr_if(guard_condition, then_branch, else_branch).into())
             } else {
-                arm.expr().map(|it| crate::utils::wrap_block(&it).into())
+                arm.expr().map(|it| crate::utils::wrap_block(&it, &make).into())
             }
         })?
         .indent(arm_expr.indent_level());
@@ -84,7 +85,7 @@ pub(crate) fn move_guard_to_arm_body(acc: &mut Assists, ctx: &AssistContext<'_>)
             if let Some(element) = space_after_arrow
                 && element.kind() == WHITESPACE
             {
-                edit.replace(element, make::tokens::single_space());
+                edit.replace(element, make.whitespace(" "));
             }
 
             edit.delete(guard.syntax());
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index b4055e77ccf8..e46cc5cce09c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -86,14 +86,14 @@ pub fn extract_trivial_expression(block_expr: &ast::BlockExpr) -> Option<ast::Ex
     None
 }
 
-pub(crate) fn wrap_block(expr: &ast::Expr) -> ast::BlockExpr {
+pub(crate) fn wrap_block(expr: &ast::Expr, make: &SyntaxFactory) -> ast::BlockExpr {
     if let ast::Expr::BlockExpr(block) = expr
         && let Some(first) = block.syntax().first_token()
         && first.kind() == T!['{']
     {
         block.reset_indent()
     } else {
-        make::block_expr(None, Some(expr.reset_indent().indent(1.into())))
+        make.block_expr(None, Some(expr.reset_indent().indent(1.into())))
     }
 }
 

From d6b3207f279ef200e81552477348856da79569d2 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 09:06:44 +0530
Subject: [PATCH 0517/1059] convert_param_list_to_arg_list accept syntaxFactory
 and update the corresponding handlers

---
 .../src/handlers/generate_delegate_methods.rs | 69 ++++++++++---------
 .../src/handlers/generate_delegate_trait.rs   |  6 +-
 .../crates/ide-assists/src/utils.rs           |  7 +-
 .../src/ast/syntax_factory/constructors.rs    | 11 +++
 4 files changed, 55 insertions(+), 38 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
index c1eb1a74ecde..d57db7b63d2a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
@@ -4,7 +4,7 @@
     ast::{
         self, AstNode, HasGenericParams, HasName, HasVisibility as _,
         edit::{AstNodeEdit, IndentLevel},
-        make,
+        syntax_factory::SyntaxFactory,
     },
     syntax_editor::Position,
 };
@@ -100,7 +100,6 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
         let Some(impl_def) = find_struct_impl(ctx, &adt, std::slice::from_ref(&name)) else {
             continue;
         };
-        let field = make::ext::field_from_idents(["self", &field_name])?;
 
         acc.add_group(
             &GroupLabel("Generate delegate methods…".to_owned()),
@@ -108,10 +107,14 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
             format!("Generate delegate for `{field_name}.{name}()`",),
             target,
             |edit| {
+                let make = SyntaxFactory::without_mappings();
+                let field = make
+                    .field_from_idents(["self", &field_name])
+                    .expect("always be a valid expression");
                 // Create the function
                 let method_source = match ctx.sema.source(method) {
                     Some(source) => {
-                        let v = source.value.clone_for_update();
+                        let v = source.value;
                         let source_scope = ctx.sema.scope(v.syntax());
                         let target_scope = ctx.sema.scope(strukt.syntax());
                         if let (Some(s), Some(t)) = (source_scope, target_scope) {
@@ -132,42 +135,42 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                 let is_unsafe = method_source.unsafe_token().is_some();
                 let is_gen = method_source.gen_token().is_some();
 
-                let fn_name = make::name(&name);
+                let fn_name = make.name(&name);
 
                 let type_params = method_source.generic_param_list();
                 let where_clause = method_source.where_clause();
                 let params =
-                    method_source.param_list().unwrap_or_else(|| make::param_list(None, []));
+                    method_source.param_list().unwrap_or_else(|| make.param_list(None, []));
 
                 // compute the `body`
                 let arg_list = method_source
                     .param_list()
-                    .map(convert_param_list_to_arg_list)
-                    .unwrap_or_else(|| make::arg_list([]));
+                    .map(|v| convert_param_list_to_arg_list(v, &make))
+                    .unwrap_or_else(|| make.arg_list([]));
 
-                let tail_expr =
-                    make::expr_method_call(field, make::name_ref(&name), arg_list).into();
+                let tail_expr = make.expr_method_call(field, make.name_ref(&name), arg_list).into();
                 let tail_expr_finished =
-                    if is_async { make::expr_await(tail_expr) } else { tail_expr };
-                let body = make::block_expr([], Some(tail_expr_finished));
+                    if is_async { make.expr_await(tail_expr) } else { tail_expr };
+                let body = make.block_expr([], Some(tail_expr_finished));
 
                 let ret_type = method_source.ret_type();
 
-                let f = make::fn_(
-                    None,
-                    vis,
-                    fn_name,
-                    type_params,
-                    where_clause,
-                    params,
-                    body,
-                    ret_type,
-                    is_async,
-                    is_const,
-                    is_unsafe,
-                    is_gen,
-                )
-                .indent(IndentLevel(1));
+                let f = make
+                    .fn_(
+                        None,
+                        vis,
+                        fn_name,
+                        type_params,
+                        where_clause,
+                        params,
+                        body,
+                        ret_type,
+                        is_async,
+                        is_const,
+                        is_unsafe,
+                        is_gen,
+                    )
+                    .indent(IndentLevel(1));
                 let item = ast::AssocItem::Fn(f.clone());
 
                 let mut editor = edit.make_editor(strukt.syntax());
@@ -179,7 +182,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                             Some(item)
                         }
                         None => {
-                            let assoc_item_list = make::assoc_item_list(Some(vec![item]));
+                            let assoc_item_list = make.assoc_item_list(vec![item]);
                             editor.insert(
                                 Position::last_child_of(impl_def.syntax()),
                                 assoc_item_list.syntax(),
@@ -192,17 +195,16 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                         let ty_params = strukt.generic_param_list();
                         let ty_args = ty_params.as_ref().map(|it| it.to_generic_args());
                         let where_clause = strukt.where_clause();
-                        let assoc_item_list = make::assoc_item_list(Some(vec![item]));
+                        let assoc_item_list = make.assoc_item_list(vec![item]);
 
-                        let impl_def = make::impl_(
+                        let impl_def = make.impl_(
                             None,
                             ty_params,
                             ty_args,
-                            make::ty_path(make::ext::ident_path(name)),
+                            syntax::ast::Type::PathType(make.ty_path(make.ident_path(name))),
                             where_clause,
                             Some(assoc_item_list),
-                        )
-                        .clone_for_update();
+                        );
 
                         // Fixup impl_def indentation
                         let indent = strukt.indent_level();
@@ -213,7 +215,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                         editor.insert_all(
                             Position::after(strukt.syntax()),
                             vec![
-                                make::tokens::whitespace(&format!("\n\n{indent}")).into(),
+                                make.whitespace(&format!("\n\n{indent}")).into(),
                                 impl_def.syntax().clone().into(),
                             ],
                         );
@@ -227,6 +229,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                     let tabstop = edit.make_tabstop_before(cap);
                     editor.add_annotation(fn_.syntax(), tabstop);
                 }
+                editor.add_mappings(make.finish_with_mappings());
                 edit.add_file_edits(ctx.vfs_file_id(), editor);
             },
         )?;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
index 921f04f2a56b..f703e4dc4ab2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
@@ -782,7 +782,7 @@ fn func_assoc_item(
                 };
 
                 // Build argument list with self expression prepended
-                let other_args = convert_param_list_to_arg_list(l);
+                let other_args = convert_param_list_to_arg_list(l, &make);
                 let all_args: Vec<ast::Expr> =
                     std::iter::once(tail_expr_self).chain(other_args.args()).collect();
                 let args = make.arg_list(all_args);
@@ -790,13 +790,13 @@ fn func_assoc_item(
                 make.expr_call(make.expr_path(qualified_path), args).into()
             }
             None => make
-                .expr_call(make.expr_path(qualified_path), convert_param_list_to_arg_list(l))
+                .expr_call(make.expr_path(qualified_path), convert_param_list_to_arg_list(l, &make))
                 .into(),
         },
         None => make
             .expr_call(
                 make.expr_path(qualified_path),
-                convert_param_list_to_arg_list(make.param_list(None, Vec::new())),
+                convert_param_list_to_arg_list(make.param_list(None, Vec::new()), &make),
             )
             .into(),
     };
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index e46cc5cce09c..a3ee0986d574 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1095,14 +1095,17 @@ pub(crate) fn trimmed_text_range(source_file: &SourceFile, initial_range: TextRa
 
 /// Convert a list of function params to a list of arguments that can be passed
 /// into a function call.
-pub(crate) fn convert_param_list_to_arg_list(list: ast::ParamList) -> ast::ArgList {
+pub(crate) fn convert_param_list_to_arg_list(
+    list: ast::ParamList,
+    make: &SyntaxFactory,
+) -> ast::ArgList {
     let mut args = vec![];
     for param in list.params() {
         if let Some(ast::Pat::IdentPat(pat)) = param.pat()
             && let Some(name) = pat.name()
         {
             let name = name.to_string();
-            let expr = make::expr_path(make::ext::ident_path(&name));
+            let expr = make.expr_path(make.ident_path(&name));
             args.push(expr);
         }
     }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 50fe56538080..3ca163d07f1f 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1765,6 +1765,17 @@ pub fn ty_ref(&self, ty: ast::Type, is_mut: bool) -> ast::Type {
         }
         ast
     }
+
+    pub fn field_from_idents<'a>(
+        &self,
+        parts: impl std::iter::IntoIterator<Item = &'a str>,
+    ) -> Option<ast::Expr> {
+        make::ext::field_from_idents(parts)
+    }
+
+    pub fn expr_await(&self, expr: ast::Expr) -> ast::Expr {
+        make::expr_await(expr)
+    }
 }
 
 // `ext` constructors

From f2bc6245811c9724dab5a2a644ad5de2247eafa8 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 09:08:33 +0530
Subject: [PATCH 0518/1059] update convert_param_list_to_arg_list to get
 ArgList via make

---
 src/tools/rust-analyzer/crates/ide-assists/src/utils.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index a3ee0986d574..db9a7a8dfc29 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1109,7 +1109,7 @@ pub(crate) fn convert_param_list_to_arg_list(
             args.push(expr);
         }
     }
-    make::arg_list(args)
+    make.arg_list(args)
 }
 
 /// Calculate the number of hashes required for a raw string containing `s`

From cc028380180e6fac63a5bf9befe8daa2b1f76c62 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 09:16:09 +0530
Subject: [PATCH 0519/1059] add syntaxFactory to tt_from_syntax and update
 corresponding handlers

---
 .../extract_expressions_from_format_string.rs      | 14 +++++++-------
 .../rust-analyzer/crates/ide-assists/src/utils.rs  |  7 +++++--
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
index 61af2de6ec68..35e8baa18aca 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
@@ -8,7 +8,7 @@
     AstNode, AstToken, NodeOrToken,
     SyntaxKind::WHITESPACE,
     SyntaxToken, T,
-    ast::{self, TokenTree, make, syntax_factory::SyntaxFactory},
+    ast::{self, TokenTree, syntax_factory::SyntaxFactory},
 };
 
 // Assist: extract_expressions_from_format_string
@@ -57,6 +57,7 @@ pub(crate) fn extract_expressions_from_format_string(
         "Extract format expressions",
         tt.syntax().text_range(),
         |edit| {
+            let make = SyntaxFactory::without_mappings();
             // Extract existing arguments in macro
             let mut raw_tokens = tt.token_trees_and_tokens().skip(1).collect_vec();
             let format_string_index = format_str_index(&raw_tokens, &fmt_string);
@@ -94,14 +95,14 @@ pub(crate) fn extract_expressions_from_format_string(
             let mut new_tt_bits = raw_tokens;
             let mut placeholder_indexes = vec![];
 
-            new_tt_bits.push(NodeOrToken::Token(make::tokens::literal(&new_fmt)));
+            new_tt_bits.push(NodeOrToken::Token(make.expr_literal(&new_fmt).token().clone()));
 
             for arg in extracted_args {
                 if matches!(arg, Arg::Expr(_) | Arg::Placeholder) {
                     // insert ", " before each arg
                     new_tt_bits.extend_from_slice(&[
-                        NodeOrToken::Token(make::token(T![,])),
-                        NodeOrToken::Token(make::tokens::single_space()),
+                        NodeOrToken::Token(make.token(T![,])),
+                        NodeOrToken::Token(make.whitespace(" ")),
                     ]);
                 }
 
@@ -109,7 +110,7 @@ pub(crate) fn extract_expressions_from_format_string(
                     Arg::Expr(s) => {
                         // insert arg
                         let expr = ast::Expr::parse(&s, ctx.edition()).syntax_node();
-                        let mut expr_tt = utils::tt_from_syntax(expr);
+                        let mut expr_tt = utils::tt_from_syntax(expr, &make);
                         new_tt_bits.append(&mut expr_tt);
                     }
                     Arg::Placeholder => {
@@ -120,7 +121,7 @@ pub(crate) fn extract_expressions_from_format_string(
                             }
                             None => {
                                 placeholder_indexes.push(new_tt_bits.len());
-                                new_tt_bits.push(NodeOrToken::Token(make::token(T![_])));
+                                new_tt_bits.push(NodeOrToken::Token(make.token(T![_])));
                             }
                         }
                     }
@@ -129,7 +130,6 @@ pub(crate) fn extract_expressions_from_format_string(
             }
 
             // Insert new args
-            let make = SyntaxFactory::with_mappings();
             let new_tt = make.token_tree(tt_delimiter, new_tt_bits);
             let mut editor = edit.make_editor(tt.syntax());
             editor.replace(tt.syntax(), new_tt.syntax());
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index db9a7a8dfc29..85b3e6d317db 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1194,7 +1194,10 @@ pub(crate) fn replace_record_field_expr(
 
 /// Creates a token tree list from a syntax node, creating the needed delimited sub token trees.
 /// Assumes that the input syntax node is a valid syntax tree.
-pub(crate) fn tt_from_syntax(node: SyntaxNode) -> Vec<NodeOrToken<ast::TokenTree, SyntaxToken>> {
+pub(crate) fn tt_from_syntax(
+    node: SyntaxNode,
+    make: &SyntaxFactory,
+) -> Vec<NodeOrToken<ast::TokenTree, SyntaxToken>> {
     let mut tt_stack = vec![(None, vec![])];
 
     for element in node.descendants_with_tokens() {
@@ -1222,7 +1225,7 @@ pub(crate) fn tt_from_syntax(node: SyntaxNode) -> Vec<NodeOrToken<ast::TokenTree
                     "mismatched opening and closing delimiters"
                 );
 
-                let sub_tt = make::token_tree(delimiter.expect("unbalanced delimiters"), tt);
+                let sub_tt = make.token_tree(delimiter.expect("unbalanced delimiters"), tt);
                 parent_tt.push(NodeOrToken::Node(sub_tt));
             }
             _ => {

From 4e50d13d57452b81c10653e529b238c4d9091937 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 10:07:35 +0530
Subject: [PATCH 0520/1059] remove invert_boolean_expression_legacy

---
 .../src/handlers/convert_to_guarded_return.rs | 49 +++++++++-------
 .../src/handlers/convert_while_to_loop.rs     | 30 +++++-----
 .../ide-assists/src/handlers/invert_if.rs     |  7 ++-
 .../crates/ide-assists/src/utils.rs           | 57 -------------------
 .../src/ast/syntax_factory/constructors.rs    | 10 +++-
 5 files changed, 56 insertions(+), 97 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index dc51bf4b5b8c..374c7cd86992 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -10,14 +10,14 @@
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
-        make,
+        syntax_factory::SyntaxFactory,
     },
 };
 
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
-    utils::{invert_boolean_expression_legacy, is_never_block},
+    utils::{invert_boolean_expression, is_never_block},
 };
 
 // Assist: convert_to_guarded_return
@@ -69,6 +69,7 @@ fn if_expr_to_guarded_return(
     acc: &mut Assists,
     ctx: &AssistContext<'_>,
 ) -> Option<()> {
+    let make = SyntaxFactory::without_mappings();
     let else_block = match if_expr.else_branch() {
         Some(ast::ElseBranch::Block(block_expr)) if is_never_block(&ctx.sema, &block_expr) => {
             Some(block_expr)
@@ -88,7 +89,7 @@ fn if_expr_to_guarded_return(
         return None;
     }
 
-    let let_chains = flat_let_chain(cond);
+    let let_chains = flat_let_chain(cond, &make);
 
     let then_branch = if_expr.then_branch()?;
     let then_block = then_branch.stmt_list()?;
@@ -110,7 +111,8 @@ fn if_expr_to_guarded_return(
 
     let early_expression = else_block
         .or_else(|| {
-            early_expression(parent_container, &ctx.sema).map(ast::make::tail_only_block_expr)
+            early_expression(parent_container, &ctx.sema, &make)
+                .map(ast::make::tail_only_block_expr)
         })?
         .reset_indent();
 
@@ -133,6 +135,7 @@ fn if_expr_to_guarded_return(
         "Convert to guarded return",
         target,
         |edit| {
+            let make = SyntaxFactory::without_mappings();
             let if_indent_level = IndentLevel::from_node(if_expr.syntax());
             let replacement = let_chains.into_iter().map(|expr| {
                 if let ast::Expr::LetExpr(let_expr) = &expr
@@ -140,15 +143,15 @@ fn if_expr_to_guarded_return(
                 {
                     // If-let.
                     let let_else_stmt =
-                        make::let_else_stmt(pat, None, expr, early_expression.clone());
+                        make.let_else_stmt(pat, None, expr, early_expression.clone());
                     let let_else_stmt = let_else_stmt.indent(if_indent_level);
                     let_else_stmt.syntax().clone()
                 } else {
                     // If.
                     let new_expr = {
-                        let then_branch = clean_stmt_block(&early_expression);
-                        let cond = invert_boolean_expression_legacy(expr);
-                        make::expr_if(cond, then_branch, None).indent(if_indent_level)
+                        let then_branch = clean_stmt_block(&early_expression, &make);
+                        let cond = invert_boolean_expression(&make, expr);
+                        make.expr_if(cond, then_branch, None).indent(if_indent_level)
                     };
                     new_expr.syntax().clone()
                 }
@@ -159,7 +162,7 @@ fn if_expr_to_guarded_return(
                 .enumerate()
                 .flat_map(|(i, node)| {
                     (i != 0)
-                        .then(|| make::tokens::whitespace(newline).into())
+                        .then(|| make.whitespace(newline).into())
                         .into_iter()
                         .chain(node.children_with_tokens())
                 })
@@ -201,12 +204,13 @@ fn let_stmt_to_guarded_return(
     let happy_pattern = try_enum.happy_pattern(pat);
     let target = let_stmt.syntax().text_range();
 
+    let make = SyntaxFactory::without_mappings();
     let early_expression: ast::Expr = {
         let parent_block =
             let_stmt.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
         let parent_container = parent_block.syntax().parent()?;
 
-        early_expression(parent_container, &ctx.sema)?
+        early_expression(parent_container, &ctx.sema, &make)?
     };
 
     acc.add(
@@ -215,9 +219,10 @@ fn let_stmt_to_guarded_return(
         target,
         |edit| {
             let let_indent_level = IndentLevel::from_node(let_stmt.syntax());
+            let make = SyntaxFactory::without_mappings();
 
             let replacement = {
-                let let_else_stmt = make::let_else_stmt(
+                let let_else_stmt = make.let_else_stmt(
                     happy_pattern,
                     let_stmt.ty(),
                     expr.reset_indent(),
@@ -228,6 +233,7 @@ fn let_stmt_to_guarded_return(
             };
             let mut editor = edit.make_editor(let_stmt.syntax());
             editor.replace(let_stmt.syntax(), replacement);
+            editor.add_mappings(make.finish_with_mappings());
             edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -236,38 +242,39 @@ fn let_stmt_to_guarded_return(
 fn early_expression(
     parent_container: SyntaxNode,
     sema: &Semantics<'_, RootDatabase>,
+    make: &SyntaxFactory,
 ) -> Option<ast::Expr> {
     let return_none_expr = || {
-        let none_expr = make::expr_path(make::ext::ident_path("None"));
-        make::expr_return(Some(none_expr))
+        let none_expr = make.expr_path(make.ident_path("None"));
+        make.expr_return(Some(none_expr))
     };
     if let Some(fn_) = ast::Fn::cast(parent_container.clone())
         && let Some(fn_def) = sema.to_def(&fn_)
         && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &fn_def.ret_type(sema.db))
     {
-        return Some(return_none_expr());
+        return Some(return_none_expr().into());
     }
     if let Some(body) = ast::ClosureExpr::cast(parent_container.clone()).and_then(|it| it.body())
         && let Some(ret_ty) = sema.type_of_expr(&body).map(TypeInfo::original)
         && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &ret_ty)
     {
-        return Some(return_none_expr());
+        return Some(return_none_expr().into());
     }
 
     Some(match parent_container.kind() {
-        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),
-        FN | CLOSURE_EXPR => make::expr_return(None),
+        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None),
+        FN | CLOSURE_EXPR => make.expr_return(None).into(),
         _ => return None,
     })
 }
 
-fn flat_let_chain(mut expr: ast::Expr) -> Vec<ast::Expr> {
+fn flat_let_chain(mut expr: ast::Expr, make: &SyntaxFactory) -> Vec<ast::Expr> {
     let mut chains = vec![];
     let mut reduce_cond = |rhs| {
         if !matches!(rhs, ast::Expr::LetExpr(_))
             && let Some(last) = chains.pop_if(|last| !matches!(last, ast::Expr::LetExpr(_)))
         {
-            chains.push(make::expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));
+            chains.push(make.expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));
         } else {
             chains.push(rhs);
         }
@@ -286,12 +293,12 @@ fn flat_let_chain(mut expr: ast::Expr) -> Vec<ast::Expr> {
     chains
 }
 
-fn clean_stmt_block(block: &ast::BlockExpr) -> ast::BlockExpr {
+fn clean_stmt_block(block: &ast::BlockExpr, make: &SyntaxFactory) -> ast::BlockExpr {
     if block.statements().next().is_none()
         && let Some(tail_expr) = block.tail_expr()
         && block.modifier().is_none()
     {
-        make::block_expr(once(make::expr_stmt(tail_expr).into()), None)
+        make.block_expr(once(make.expr_stmt(tail_expr).into()), None)
     } else {
         block.clone()
     }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
index 9fd8b4b3159e..c06e539a4fdb 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
@@ -6,7 +6,7 @@
     ast::{
         self, HasLoopBody,
         edit::{AstNodeEdit, IndentLevel},
-        make,
+        syntax_factory::SyntaxFactory,
     },
     syntax_editor::{Element, Position},
 };
@@ -14,7 +14,7 @@
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
-    utils::invert_boolean_expression_legacy,
+    utils::invert_boolean_expression,
 };
 
 // Assist: convert_while_to_loop
@@ -52,44 +52,44 @@ pub(crate) fn convert_while_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>)
         "Convert while to loop",
         target,
         |builder| {
+            let make = SyntaxFactory::without_mappings();
             let mut edit = builder.make_editor(while_expr.syntax());
             let while_indent_level = IndentLevel::from_node(while_expr.syntax());
 
-            let break_block = make::block_expr(
-                iter::once(make::expr_stmt(make::expr_break(None, None)).into()),
-                None,
-            )
-            .indent(IndentLevel(1));
+            let break_block = make
+                .block_expr(iter::once(make.expr_stmt(make.expr_break(None, None)).into()), None)
+                .indent(IndentLevel(1));
 
             edit.replace_all(
                 while_kw.syntax_element()..=while_cond.syntax().syntax_element(),
-                vec![make::token(T![loop]).syntax_element()],
+                vec![make.token(T![loop]).syntax_element()],
             );
 
             if is_pattern_cond(while_cond.clone()) {
                 let then_branch = while_body.reset_indent().indent(IndentLevel(1));
-                let if_expr = make::expr_if(while_cond, then_branch, Some(break_block.into()));
-                let stmts = iter::once(make::expr_stmt(if_expr.into()).into());
-                let block_expr = make::block_expr(stmts, None);
+                let if_expr = make.expr_if(while_cond, then_branch, Some(break_block.into()));
+                let stmts = iter::once(make.expr_stmt(if_expr.into()).into());
+                let block_expr = make.block_expr(stmts, None);
                 edit.replace(while_body.syntax(), block_expr.indent(while_indent_level).syntax());
             } else {
-                let if_cond = invert_boolean_expression_legacy(while_cond);
-                let if_expr = make::expr_if(if_cond, break_block, None).indent(while_indent_level);
+                let if_cond = invert_boolean_expression(&make, while_cond);
+                let if_expr = make.expr_if(if_cond, break_block, None).indent(while_indent_level);
                 if !while_body.syntax().text().contains_char('\n') {
                     edit.insert(
                         Position::after(&l_curly),
-                        make::tokens::whitespace(&format!("\n{while_indent_level}")),
+                        make.whitespace(&format!("\n{while_indent_level}")),
                     );
                 }
                 edit.insert_all(
                     Position::after(&l_curly),
                     vec![
-                        make::tokens::whitespace(&format!("\n{}", while_indent_level + 1)).into(),
+                        make.whitespace(&format!("\n{}", while_indent_level + 1)).into(),
                         if_expr.syntax().syntax_element(),
                     ],
                 );
             };
 
+            edit.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), edit);
         },
     )
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
index bf82d8df9b58..c8cb7bb60f69 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
@@ -1,13 +1,13 @@
 use ide_db::syntax_helpers::node_ext::is_pattern_cond;
 use syntax::{
     T,
-    ast::{self, AstNode},
+    ast::{self, AstNode, syntax_factory::SyntaxFactory},
 };
 
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
-    utils::invert_boolean_expression_legacy,
+    utils::invert_boolean_expression,
 };
 
 // Assist: invert_if
@@ -50,7 +50,8 @@ pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
     };
 
     acc.add(AssistId::refactor_rewrite("invert_if"), "Invert if", if_range, |edit| {
-        let flip_cond = invert_boolean_expression_legacy(cond.clone());
+        let make = SyntaxFactory::without_mappings();
+        let flip_cond = invert_boolean_expression(&make, cond.clone());
         edit.replace_ast(cond, flip_cond);
 
         let else_node = else_block.syntax();
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 85b3e6d317db..db59fc29c344 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -275,11 +275,6 @@ pub(crate) fn invert_boolean_expression(make: &SyntaxFactory, expr: ast::Expr) -
     invert_special_case(make, &expr).unwrap_or_else(|| make.expr_prefix(T![!], expr).into())
 }
 
-// FIXME: Migrate usages of this function to the above function and remove this.
-pub(crate) fn invert_boolean_expression_legacy(expr: ast::Expr) -> ast::Expr {
-    invert_special_case_legacy(&expr).unwrap_or_else(|| make::expr_prefix(T![!], expr).into())
-}
-
 fn invert_special_case(make: &SyntaxFactory, expr: &ast::Expr) -> Option<ast::Expr> {
     match expr {
         ast::Expr::BinExpr(bin) => {
@@ -343,58 +338,6 @@ fn invert_special_case(make: &SyntaxFactory, expr: &ast::Expr) -> Option<ast::Ex
     }
 }
 
-fn invert_special_case_legacy(expr: &ast::Expr) -> Option<ast::Expr> {
-    match expr {
-        ast::Expr::BinExpr(bin) => {
-            let bin = bin.clone_subtree();
-            let op_token = bin.op_token()?;
-            let rev_token = match op_token.kind() {
-                T![==] => T![!=],
-                T![!=] => T![==],
-                T![<] => T![>=],
-                T![<=] => T![>],
-                T![>] => T![<=],
-                T![>=] => T![<],
-                // Parenthesize other expressions before prefixing `!`
-                _ => {
-                    return Some(
-                        make::expr_prefix(T![!], make::expr_paren(expr.clone()).into()).into(),
-                    );
-                }
-            };
-            let mut bin_editor = SyntaxEditor::new(bin.syntax().clone());
-            bin_editor.replace(op_token, make::token(rev_token));
-            ast::Expr::cast(bin_editor.finish().new_root().clone())
-        }
-        ast::Expr::MethodCallExpr(mce) => {
-            let receiver = mce.receiver()?;
-            let method = mce.name_ref()?;
-            let arg_list = mce.arg_list()?;
-
-            let method = match method.text().as_str() {
-                "is_some" => "is_none",
-                "is_none" => "is_some",
-                "is_ok" => "is_err",
-                "is_err" => "is_ok",
-                _ => return None,
-            };
-            Some(make::expr_method_call(receiver, make::name_ref(method), arg_list).into())
-        }
-        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::UnaryOp::Not => match pe.expr()? {
-            ast::Expr::ParenExpr(parexpr) => parexpr.expr(),
-            _ => pe.expr(),
-        },
-        ast::Expr::Literal(lit) => match lit.kind() {
-            ast::LiteralKind::Bool(b) => match b {
-                true => Some(ast::Expr::Literal(make::expr_literal("false"))),
-                false => Some(ast::Expr::Literal(make::expr_literal("true"))),
-            },
-            _ => None,
-        },
-        _ => None,
-    }
-}
-
 pub(crate) fn insert_attributes(
     before: impl Element,
     edit: &mut SyntaxEditor,
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 3ca163d07f1f..dd8cc8d6f2e2 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -5,7 +5,7 @@
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
     ast::{
         self, HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,
-        HasTypeBounds, HasVisibility, Param, RangeItem, make,
+        HasTypeBounds, HasVisibility, Lifetime, Param, RangeItem, make,
     },
     syntax_editor::SyntaxMappingBuilder,
 };
@@ -1806,6 +1806,14 @@ pub fn ty_result(&self, t: ast::Type, e: ast::Type) -> ast::PathType {
 
         self.ty_path(path)
     }
+
+    pub fn expr_break(&self, label: Option<Lifetime>, expr: Option<ast::Expr>) -> ast::Expr {
+        make::expr_break(label, expr)
+    }
+
+    pub fn expr_continue(&self, label: Option<Lifetime>) -> ast::Expr {
+        make::expr_continue(label)
+    }
 }
 
 // We need to collect `input` here instead of taking `impl IntoIterator + Clone`,

From f5836b5ab89fe142a64e9a195adab7c4f81c7af8 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 10:11:35 +0530
Subject: [PATCH 0521/1059] make insert_attribute accept syntaxFactory

---
 .../src/handlers/convert_for_to_while_let.rs        | 13 +++++++------
 .../rust-analyzer/crates/ide-assists/src/utils.rs   |  5 ++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
index d64e9ceda2ef..d409374c16f6 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
@@ -2,7 +2,7 @@
 use ide_db::{famous_defs::FamousDefs, syntax_helpers::suggest_name};
 use syntax::{
     AstNode,
-    ast::{self, HasAttrs, HasLoopBody, edit::IndentLevel, make, syntax_factory::SyntaxFactory},
+    ast::{self, HasAttrs, HasLoopBody, edit::IndentLevel, syntax_factory::SyntaxFactory},
     syntax_editor::Position,
 };
 
@@ -57,13 +57,13 @@ pub(crate) fn convert_for_loop_to_while_let(
             {
                 (expr, Some(make.name_ref(method.as_str())))
             } else if let ast::Expr::RefExpr(_) = iterable {
-                (make::expr_paren(iterable).into(), Some(make.name_ref("into_iter")))
+                (make.expr_paren(iterable).into(), Some(make.name_ref("into_iter")))
             } else {
                 (iterable, Some(make.name_ref("into_iter")))
             };
 
             let iterable = if let Some(method) = method {
-                make::expr_method_call(iterable, method, make::arg_list([])).into()
+                make.expr_method_call(iterable, method, make.arg_list([])).into()
             } else {
                 iterable
             };
@@ -89,17 +89,18 @@ pub(crate) fn convert_for_loop_to_while_let(
                 for_loop.syntax(),
                 &mut editor,
                 for_loop.attrs().map(|it| it.clone_for_update()),
+                &make,
             );
 
             editor.insert(
                 Position::before(for_loop.syntax()),
-                make::tokens::whitespace(format!("\n{indent}").as_str()),
+                make.whitespace(format!("\n{indent}").as_str()),
             );
             editor.insert(Position::before(for_loop.syntax()), mut_expr.syntax());
 
-            let opt_pat = make.tuple_struct_pat(make::ext::ident_path("Some"), [pat]);
+            let opt_pat = make.tuple_struct_pat(make.ident_path("Some"), [pat]);
             let iter_next_expr = make.expr_method_call(
-                make.expr_path(make::ext::ident_path(&tmp_var)),
+                make.expr_path(make.ident_path(&tmp_var)),
                 make.name_ref("next"),
                 make.arg_list([]),
             );
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index db59fc29c344..27788a70ebcf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -342,6 +342,7 @@ pub(crate) fn insert_attributes(
     before: impl Element,
     edit: &mut SyntaxEditor,
     attrs: impl IntoIterator<Item = ast::Attr>,
+    make: &SyntaxFactory,
 ) {
     let mut attrs = attrs.into_iter().peekable();
     if attrs.peek().is_none() {
@@ -353,9 +354,7 @@ pub(crate) fn insert_attributes(
     edit.insert_all(
         syntax::syntax_editor::Position::before(elem),
         attrs
-            .flat_map(|attr| {
-                [attr.syntax().clone().into(), make::tokens::whitespace(&whitespace).into()]
-            })
+            .flat_map(|attr| [attr.syntax().clone().into(), make.whitespace(&whitespace).into()])
             .collect(),
     );
 }

From 0a821cd4eb75306e7664224c01c3f6c7d966718f Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 16 Mar 2026 05:04:17 +0000
Subject: [PATCH 0522/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 1e2183119f0ee19cc26df899e26b04ad0de3475d.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index db9492636f6a..69609cc49f27 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-eda4fc7733ee89e484d7120cafbd80dcb2fce66e
+1e2183119f0ee19cc26df899e26b04ad0de3475d

From 6122db7870f08a6b5ce5338906b750941370d94f Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 16 Mar 2026 05:32:13 +0000
Subject: [PATCH 0523/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 1e2183119f0ee19cc26df899e26b04ad0de3475d.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 998ecc08a8e1..69609cc49f27 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-d1ee5e59a964a419b84b760812a35075034f4861
+1e2183119f0ee19cc26df899e26b04ad0de3475d

From b41b0c494c35b314cd8f6e9d0a84976e68415db2 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 12 Mar 2026 17:39:01 +1100
Subject: [PATCH 0524/1059] Rename all-query functions.

There are four functions that use `for_each_query_vtable!` to call an "inner"
function. They are:

- collect_active_jobs_from_all_queries -> gather_active_jobs
- alloc_self_profile_query_strings -> alloc_self_profile_query_strings_for_query_cache
- encode_all_query_results -> encode_query_results
- query_key_hash_verify_all -> query_key_hash_verify

These names are all over the place. This commit renames them as follows:

- collect_active_query_jobs{,_inner}
- alloc_self_profile_query_strings{,_inner}
- encode_query_values{,_inner}
- verify_query_key_hashes{,_inner}

This:
- puts the verb at the start
- uses "inner" for all the inners (which makes sense now that the inners are
  all next to their callers)
- uses `_query_` consistently
- avoids `all`, because the plurals are enough
- uses `values` instead of `results`
- removes the `collect`/`gather` distinction, which is no longer
  important
---
 compiler/rustc_interface/src/util.rs          |  4 ++--
 compiler/rustc_middle/src/hooks/mod.rs        |  4 ++--
 .../rustc_middle/src/query/on_disk_cache.rs   |  4 ++--
 compiler/rustc_middle/src/ty/context.rs       |  2 +-
 compiler/rustc_query_impl/src/execution.rs    | 23 +++++++------------
 compiler/rustc_query_impl/src/job.rs          |  8 +++----
 compiler/rustc_query_impl/src/lib.rs          |  6 ++---
 compiler/rustc_query_impl/src/plumbing.rs     | 18 +++++++--------
 .../rustc_query_impl/src/profiling_support.rs |  4 ++--
 9 files changed, 33 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index e81f0133e3b6..c5344ee66cd0 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -18,7 +18,7 @@
 use rustc_metadata::{DylibError, EncodedMetadata, load_symbol_from_dylib};
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::ty::{CurrentGcx, TyCtxt};
-use rustc_query_impl::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
+use rustc_query_impl::{CollectActiveJobsKind, collect_active_query_jobs};
 use rustc_session::config::{
     Cfg, CrateType, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple,
 };
@@ -255,7 +255,7 @@ pub(crate) fn run_in_thread_pool_with_globals<
                                         // Ensure there were no errors collecting all active jobs.
                                         // We need the complete map to ensure we find a cycle to
                                         // break.
-                                        collect_active_jobs_from_all_queries(
+                                        collect_active_query_jobs(
                                             tcx,
                                             CollectActiveJobsKind::FullNoContention,
                                         )
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 2ab03adf6aaf..60327be6f6f8 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -98,7 +98,7 @@ fn clone(&self) -> Self { *self }
     /// Trying to execute a query afterwards would attempt to read the result cache we just dropped.
     hook save_dep_graph() -> ();
 
-    hook query_key_hash_verify_all() -> ();
+    hook verify_query_key_hashes() -> ();
 
     /// Ensure the given scalar is valid for the given type.
     /// This checks non-recursive runtime validity.
@@ -109,7 +109,7 @@ fn clone(&self) -> Self { *self }
     /// Creates the MIR for a given `DefId`, including unreachable code.
     hook build_mir_inner_impl(def: LocalDefId) -> mir::Body<'tcx>;
 
-    hook encode_all_query_results(
+    hook encode_query_values(
         encoder: &mut CacheEncoder<'_, 'tcx>,
         query_result_index: &mut EncodedDepNodeIndex
     ) -> ();
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 8f4e4564c583..607891d4d19d 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -246,10 +246,10 @@ pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResu
             // Encode query results.
             let mut query_result_index = EncodedDepNodeIndex::new();
 
-            tcx.sess.time("encode_query_results", || {
+            tcx.sess.time("encode_query_values", || {
                 let enc = &mut encoder;
                 let qri = &mut query_result_index;
-                tcx.encode_all_query_results(enc, qri);
+                tcx.encode_query_values(enc, qri);
             });
 
             // Encode side effects.
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 91105f416c8f..04dbca23b412 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1678,7 +1678,7 @@ pub fn finish(self) {
         self.alloc_self_profile_query_strings();
 
         self.save_dep_graph();
-        self.query_key_hash_verify_all();
+        self.verify_query_key_hashes();
 
         if let Err((path, error)) = self.dep_graph.finish_encoding() {
             self.sess.dcx().emit_fatal(crate::error::FailedWritingFile { path: &path, error });
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index eae91a2b2e56..96d6ca51ec99 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -56,14 +56,14 @@ pub enum CollectActiveJobsKind {
 /// Prefer passing `false` to `require_complete` to avoid potential deadlocks,
 /// especially when called from within a deadlock handler, unless a
 /// complete map is needed and no deadlock is possible at this call site.
-pub fn collect_active_jobs_from_all_queries<'tcx>(
+pub fn collect_active_query_jobs<'tcx>(
     tcx: TyCtxt<'tcx>,
     collect_kind: CollectActiveJobsKind,
 ) -> QueryJobMap<'tcx> {
     let mut job_map = QueryJobMap::default();
 
     for_each_query_vtable!(ALL, tcx, |query| {
-        gather_active_jobs(query, collect_kind, &mut job_map);
+        collect_active_query_jobs_inner(query, collect_kind, &mut job_map);
     });
 
     job_map
@@ -71,14 +71,8 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
 
 /// Internal plumbing for collecting the set of active jobs for this query.
 ///
-/// Should only be called from `collect_active_jobs_from_all_queries`.
-///
-/// (We arbitrarily use the word "gather" when collecting the jobs for
-/// each individual query, so that we have distinct function names to
-/// grep for.)
-///
 /// Aborts if jobs can't be gathered as specified by `collect_kind`.
-fn gather_active_jobs<'tcx, C>(
+fn collect_active_query_jobs_inner<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
     collect_kind: CollectActiveJobsKind,
     job_map: &mut QueryJobMap<'tcx>,
@@ -86,7 +80,7 @@ fn gather_active_jobs<'tcx, C>(
     C: QueryCache<Key: QueryKey + DynSend + DynSync>,
     QueryVTable<'tcx, C>: DynSync,
 {
-    let mut gather_shard_jobs = |shard: &HashTable<(C::Key, ActiveKeyStatus<'tcx>)>| {
+    let mut collect_shard_jobs = |shard: &HashTable<(C::Key, ActiveKeyStatus<'tcx>)>| {
         for (key, status) in shard.iter() {
             if let ActiveKeyStatus::Started(job) = status {
                 // This function is safe to call with the shard locked because it is very simple.
@@ -99,13 +93,13 @@ fn gather_active_jobs<'tcx, C>(
     match collect_kind {
         CollectActiveJobsKind::Full => {
             for shard in query.state.active.lock_shards() {
-                gather_shard_jobs(&shard);
+                collect_shard_jobs(&shard);
             }
         }
         CollectActiveJobsKind::FullNoContention => {
             for shard in query.state.active.try_lock_shards() {
                 match shard {
-                    Some(shard) => gather_shard_jobs(&shard),
+                    Some(shard) => collect_shard_jobs(&shard),
                     None => panic!("Failed to collect active jobs for query `{}`!", query.name),
                 }
             }
@@ -113,7 +107,7 @@ fn gather_active_jobs<'tcx, C>(
         CollectActiveJobsKind::PartialAllowed => {
             for shard in query.state.active.try_lock_shards() {
                 match shard {
-                    Some(shard) => gather_shard_jobs(&shard),
+                    Some(shard) => collect_shard_jobs(&shard),
                     None => warn!("Failed to collect active jobs for query `{}`!", query.name),
                 }
             }
@@ -218,8 +212,7 @@ fn cycle_error<'tcx, C: QueryCache>(
 ) -> (C::Value, Option<DepNodeIndex>) {
     // Ensure there were no errors collecting all active jobs.
     // We need the complete map to ensure we find a cycle to break.
-    let job_map =
-        collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::FullNoContention);
+    let job_map = collect_active_query_jobs(tcx, CollectActiveJobsKind::FullNoContention);
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
     (mk_cycle(query, tcx, key, error), None)
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 90fb1c26910a..4d3dbe6621cf 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -12,10 +12,10 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_span::{DUMMY_SP, Span};
 
-use crate::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
+use crate::{CollectActiveJobsKind, collect_active_query_jobs};
 
 /// Map from query job IDs to job information collected by
-/// `collect_active_jobs_from_all_queries`.
+/// `collect_active_query_jobs`.
 #[derive(Debug, Default)]
 pub struct QueryJobMap<'tcx> {
     map: FxHashMap<QueryJobId, QueryJobInfo<'tcx>>,
@@ -24,7 +24,7 @@ pub struct QueryJobMap<'tcx> {
 impl<'tcx> QueryJobMap<'tcx> {
     /// Adds information about a job ID to the job map.
     ///
-    /// Should only be called by `gather_active_jobs`.
+    /// Should only be called by `collect_active_query_jobs_inner`.
     pub(crate) fn insert(&mut self, id: QueryJobId, info: QueryJobInfo<'tcx>) {
         self.map.insert(id, info);
     }
@@ -407,7 +407,7 @@ pub fn print_query_stack<'tcx>(
     let mut count_total = 0;
 
     // Make use of a partial query job map if we fail to take locks collecting active queries.
-    let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::PartialAllowed);
+    let job_map = collect_active_query_jobs(tcx, CollectActiveJobsKind::PartialAllowed);
 
     if let Some(ref mut file) = file {
         let _ = writeln!(file, "\n\nquery stack during panic:");
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index c62ea3e289fc..cd16071f34fa 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -17,7 +17,7 @@
 use rustc_middle::ty::TyCtxt;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
-pub use crate::execution::{CollectActiveJobsKind, collect_active_jobs_from_all_queries};
+pub use crate::execution::{CollectActiveJobsKind, collect_active_query_jobs};
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
 
 mod dep_kind_vtables;
@@ -64,6 +64,6 @@ pub fn query_system<'tcx>(
 pub fn provide(providers: &mut rustc_middle::util::Providers) {
     providers.hooks.alloc_self_profile_query_strings =
         profiling_support::alloc_self_profile_query_strings;
-    providers.hooks.query_key_hash_verify_all = plumbing::query_key_hash_verify_all;
-    providers.hooks.encode_all_query_results = plumbing::encode_all_query_results;
+    providers.hooks.verify_query_key_hashes = plumbing::verify_query_key_hashes;
+    providers.hooks.encode_query_values = plumbing::encode_query_values;
 }
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index c9cd08648b1b..f7abffb29f82 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -26,10 +26,10 @@
 use crate::execution::{all_inactive, force_query};
 use crate::job::find_dep_kind_root;
 use crate::query_impl::for_each_query_vtable;
-use crate::{CollectActiveJobsKind, GetQueryVTable, collect_active_jobs_from_all_queries};
+use crate::{CollectActiveJobsKind, GetQueryVTable, collect_active_query_jobs};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
-    let job_map = collect_active_jobs_from_all_queries(tcx, CollectActiveJobsKind::Full);
+    let job_map = collect_active_query_jobs(tcx, CollectActiveJobsKind::Full);
     let (span, desc, depth) = find_dep_kind_root(tcx, job, job_map);
 
     let suggested_limit = match tcx.recursion_limit() {
@@ -99,17 +99,17 @@ pub(crate) fn create_query_stack_frame<'tcx, C>(
     }
 }
 
-pub(crate) fn encode_all_query_results<'tcx>(
+pub(crate) fn encode_query_values<'tcx>(
     tcx: TyCtxt<'tcx>,
     encoder: &mut CacheEncoder<'_, 'tcx>,
     query_result_index: &mut EncodedDepNodeIndex,
 ) {
     for_each_query_vtable!(CACHE_ON_DISK, tcx, |query| {
-        encode_query_results(tcx, query, encoder, query_result_index)
+        encode_query_values_inner(tcx, query, encoder, query_result_index)
     });
 }
 
-fn encode_query_results<'a, 'tcx, C, V>(
+fn encode_query_values_inner<'a, 'tcx, C, V>(
     tcx: TyCtxt<'tcx>,
     query: &'tcx QueryVTable<'tcx, C>,
     encoder: &mut CacheEncoder<'a, 'tcx>,
@@ -135,17 +135,17 @@ fn encode_query_results<'a, 'tcx, C, V>(
     });
 }
 
-pub(crate) fn query_key_hash_verify_all<'tcx>(tcx: TyCtxt<'tcx>) {
+pub(crate) fn verify_query_key_hashes<'tcx>(tcx: TyCtxt<'tcx>) {
     if tcx.sess.opts.unstable_opts.incremental_verify_ich || cfg!(debug_assertions) {
-        tcx.sess.time("query_key_hash_verify_all", || {
+        tcx.sess.time("verify_query_key_hashes", || {
             for_each_query_vtable!(ALL, tcx, |query| {
-                query_key_hash_verify(query, tcx);
+                verify_query_key_hashes_inner(query, tcx);
             });
         });
     }
 }
 
-fn query_key_hash_verify<'tcx, C: QueryCache>(
+fn verify_query_key_hashes_inner<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
 ) {
diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs
index c34938cdb386..582150a7bafa 100644
--- a/compiler/rustc_query_impl/src/profiling_support.rs
+++ b/compiler/rustc_query_impl/src/profiling_support.rs
@@ -192,7 +192,7 @@ pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
     let mut string_cache = QueryKeyStringCache::new();
 
     for_each_query_vtable!(ALL, tcx, |query| {
-        alloc_self_profile_query_strings_for_query_cache(tcx, query, &mut string_cache);
+        alloc_self_profile_query_strings_inner(tcx, query, &mut string_cache);
     });
 
     tcx.sess.prof.store_query_cache_hits();
@@ -201,7 +201,7 @@ pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
 /// Allocate the self-profiling query strings for a single query cache. This
 /// method is called from `alloc_self_profile_query_strings` which knows all
 /// the queries via macro magic.
-fn alloc_self_profile_query_strings_for_query_cache<'tcx, C>(
+fn alloc_self_profile_query_strings_inner<'tcx, C>(
     tcx: TyCtxt<'tcx>,
     query: &'tcx QueryVTable<'tcx, C>,
     string_cache: &mut QueryKeyStringCache,

From a8024fc1d783fbbf8c098b23d3f66b8cfa74c9f7 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 16 Mar 2026 16:33:52 +1100
Subject: [PATCH 0525/1059] Remove an out-of-date comment.

It should have been removed in #153650. (The comments on
`CollectActiveJobsKind` suffice now.)
---
 compiler/rustc_query_impl/src/execution.rs | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 96d6ca51ec99..dc7a847003b0 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -47,15 +47,6 @@ pub enum CollectActiveJobsKind {
 }
 
 /// Returns a map of currently active query jobs, collected from all queries.
-///
-/// If `require_complete` is `true`, this function locks all shards of the
-/// query results to produce a complete map, which always returns `Ok`.
-/// Otherwise, it may return an incomplete map as an error if any shard
-/// lock cannot be acquired.
-///
-/// Prefer passing `false` to `require_complete` to avoid potential deadlocks,
-/// especially when called from within a deadlock handler, unless a
-/// complete map is needed and no deadlock is possible at this call site.
 pub fn collect_active_query_jobs<'tcx>(
     tcx: TyCtxt<'tcx>,
     collect_kind: CollectActiveJobsKind,

From aa223a022022aa050dd8e424cd241c8bb7648c0f Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 14 Mar 2026 16:19:30 +1100
Subject: [PATCH 0526/1059] Re-export `rustc_middle::query::{QuerySystem,
 QueryVTable}`

All of the other public items in `rustc_middle::query::plumbing` are
re-exported from `query`, except for these two, for no particular reason that I
can see.

Re-exporting them allows `rustc_middle::query::plumbing` to have its visibility
reduced to pub(crate).

Imports within `rustc_middle` have also been updated to consistently use the
re-exports in `crate::query`.
---
 compiler/rustc_middle/src/query/inner.rs           | 3 +--
 compiler/rustc_middle/src/query/job.rs             | 2 +-
 compiler/rustc_middle/src/query/mod.rs             | 6 +++---
 compiler/rustc_middle/src/query/plumbing.rs        | 2 +-
 compiler/rustc_middle/src/ty/context.rs            | 3 +--
 compiler/rustc_query_impl/src/execution.rs         | 3 +--
 compiler/rustc_query_impl/src/lib.rs               | 3 +--
 compiler/rustc_query_impl/src/plumbing.rs          | 5 +++--
 compiler/rustc_query_impl/src/profiling_support.rs | 3 +--
 compiler/rustc_query_impl/src/query_impl.rs        | 7 +++----
 10 files changed, 16 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
index 7395c5476dc1..c2525d26d4c6 100644
--- a/compiler/rustc_middle/src/query/inner.rs
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -6,8 +6,7 @@
 use crate::dep_graph;
 use crate::dep_graph::DepNodeKey;
 use crate::query::erase::{self, Erasable, Erased};
-use crate::query::plumbing::QueryVTable;
-use crate::query::{EnsureMode, QueryCache, QueryMode};
+use crate::query::{EnsureMode, QueryCache, QueryMode, QueryVTable};
 use crate::ty::TyCtxt;
 
 /// Checks whether there is already a value for this key in the in-memory
diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index 574a671fd640..3bf37a782ee8 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -6,7 +6,7 @@
 use parking_lot::{Condvar, Mutex};
 use rustc_span::Span;
 
-use crate::query::plumbing::CycleError;
+use crate::query::CycleError;
 use crate::ty::TyCtxt;
 
 /// A value uniquely identifying an active query job.
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 517999baba1e..1723a853ea75 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -4,8 +4,8 @@
 pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
-    ActiveKeyStatus, CycleError, EnsureMode, IntoQueryParam, QueryMode, QueryState, TyCtxtAt,
-    TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
+    ActiveKeyStatus, CycleError, EnsureMode, IntoQueryParam, QueryMode, QueryState, QuerySystem,
+    QueryVTable, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
 };
 pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
@@ -19,7 +19,7 @@
 mod keys;
 pub(crate) mod modifiers;
 pub mod on_disk_cache;
-pub mod plumbing;
+pub(crate) mod plumbing;
 mod stack;
 
 pub fn describe_as_module(def_id: impl Into<LocalDefId>, tcx: TyCtxt<'_>) -> String {
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 6f18c01577da..e88c20f02537 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -569,7 +569,7 @@ fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>) -> Option<D
         /// Holds a `QueryVTable` for each query.
         pub struct QueryVTables<'tcx> {
             $(
-                pub $name: ::rustc_middle::query::plumbing::QueryVTable<'tcx, $name::Cache<'tcx>>,
+                pub $name: crate::query::QueryVTable<'tcx, $name::Cache<'tcx>>,
             )*
         }
 
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 91105f416c8f..074ce6c246a6 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -61,8 +61,7 @@
 use crate::middle::resolve_bound_vars;
 use crate::mir::interpret::{self, Allocation, ConstAllocation};
 use crate::mir::{Body, Local, Place, PlaceElem, ProjectionKind, Promoted};
-use crate::query::plumbing::QuerySystem;
-use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
+use crate::query::{IntoQueryParam, LocalCrate, Providers, QuerySystem, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
 use crate::traits::solve::{ExternalConstraints, ExternalConstraintsData, PredefinedOpaques};
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index eae91a2b2e56..10c47fd73de1 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -7,10 +7,9 @@
 use rustc_data_structures::{outline, sharded, sync};
 use rustc_errors::FatalError;
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
-use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
     ActiveKeyStatus, CycleError, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey,
-    QueryLatch, QueryMode, QueryState,
+    QueryLatch, QueryMode, QueryState, QueryVTable,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index c62ea3e289fc..27b0a253145f 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -11,9 +11,8 @@
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::dep_graph;
 use rustc_middle::queries::{ExternProviders, Providers};
-use rustc_middle::query::QueryCache;
 use rustc_middle::query::on_disk_cache::OnDiskCache;
-use rustc_middle::query::plumbing::{QuerySystem, QueryVTable};
+use rustc_middle::query::{QueryCache, QuerySystem, QueryVTable};
 use rustc_middle::ty::TyCtxt;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index c9cd08648b1b..21910068a138 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -13,8 +13,9 @@
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
 };
-use rustc_middle::query::plumbing::QueryVTable;
-use rustc_middle::query::{QueryCache, QueryJobId, QueryKey, QueryMode, QueryStackFrame, erase};
+use rustc_middle::query::{
+    QueryCache, QueryJobId, QueryKey, QueryMode, QueryStackFrame, QueryVTable, erase,
+};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::tls::{self, ImplicitCtxt};
diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs
index c34938cdb386..53577e0a9bd1 100644
--- a/compiler/rustc_query_impl/src/profiling_support.rs
+++ b/compiler/rustc_query_impl/src/profiling_support.rs
@@ -6,8 +6,7 @@
 use rustc_data_structures::profiling::SelfProfiler;
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::DefPathData;
-use rustc_middle::query::QueryCache;
-use rustc_middle::query::plumbing::QueryVTable;
+use rustc_middle::query::{QueryCache, QueryVTable};
 use rustc_middle::ty::TyCtxt;
 
 use crate::query_impl::for_each_query_vtable;
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index 23f678e1c9f7..caf4c7dde7e6 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -1,7 +1,6 @@
 use rustc_middle::queries::TaggedQueryKey;
 use rustc_middle::query::erase::{self, Erased};
-use rustc_middle::query::plumbing::QueryVTable;
-use rustc_middle::query::{AsLocalQueryKey, QueryMode};
+use rustc_middle::query::{AsLocalQueryKey, QueryMode, QueryVTable};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 
@@ -245,7 +244,7 @@ macro_rules! for_each_query_vtable {
             (ALL, $tcx:expr, $closure:expr) => {{
                 let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
                 $(
-                    let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                    let query: &rustc_middle::query::QueryVTable<'_, _> =
                         &tcx.query_system.query_vtables.$name;
                     $closure(query);
                 )*
@@ -260,7 +259,7 @@ macro_rules! for_each_query_vtable {
                 $(
                     #[cfg($cache_on_disk)]
                     {
-                        let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
+                        let query: &rustc_middle::query::QueryVTable<'_, _> =
                             &tcx.query_system.query_vtables.$name;
                         $closure(query);
                     }

From a89211e552c617b6786e5064cc368dee4ae83b8a Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Mon, 16 Mar 2026 15:15:55 +0700
Subject: [PATCH 0527/1059] Change `?Sized` to `PointeeSized` in `UnwindSafe`
 impls for pointers

---
 library/core/src/panic/unwind_safe.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs
index 21dbd09f4960..98298aa8ef01 100644
--- a/library/core/src/panic/unwind_safe.rs
+++ b/library/core/src/panic/unwind_safe.rs
@@ -2,6 +2,7 @@
 use crate::cell::UnsafeCell;
 use crate::fmt;
 use crate::future::Future;
+use crate::marker::PointeeSized;
 use crate::ops::{Deref, DerefMut};
 use crate::pin::Pin;
 use crate::ptr::{NonNull, Unique};
@@ -178,17 +179,17 @@
 // * Our custom AssertUnwindSafe wrapper is indeed unwind safe
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T: ?Sized> !UnwindSafe for &mut T {}
+impl<T: PointeeSized> !UnwindSafe for &mut T {}
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T: RefUnwindSafe + ?Sized> UnwindSafe for &T {}
+impl<T: RefUnwindSafe + PointeeSized> UnwindSafe for &T {}
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *const T {}
+impl<T: RefUnwindSafe + PointeeSized> UnwindSafe for *const T {}
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *mut T {}
+impl<T: RefUnwindSafe + PointeeSized> UnwindSafe for *mut T {}
 #[unstable(feature = "ptr_internals", issue = "none")]
-impl<T: UnwindSafe + ?Sized> UnwindSafe for Unique<T> {}
+impl<T: UnwindSafe + PointeeSized> UnwindSafe for Unique<T> {}
 #[stable(feature = "nonnull", since = "1.25.0")]
-impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T> {}
+impl<T: RefUnwindSafe + PointeeSized> UnwindSafe for NonNull<T> {}
 #[stable(feature = "catch_unwind", since = "1.9.0")]
 impl<T> UnwindSafe for AssertUnwindSafe<T> {}
 

From 637cc71c3b059d2d624877b022d9ddb2432d9b1f Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 16 Mar 2026 11:58:13 +0200
Subject: [PATCH 0528/1059] Don't trigger GC on slow tests

It can lead to UB.
---
 .../crates/rust-analyzer/src/main_loop.rs           | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index 64decc9e0db6..eb272b5e0b37 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -303,6 +303,15 @@ fn next_event(
         .map(Some)
     }
 
+    fn trigger_garbage_collection(&mut self) {
+        if cfg!(test) {
+            // Slow tests run the main loop in multiple threads, but GC isn't thread safe.
+            return;
+        }
+
+        self.analysis_host.trigger_garbage_collection();
+    }
+
     fn handle_event(&mut self, event: Event) {
         let loop_start = Instant::now();
         let _p = tracing::info_span!("GlobalState::handle_event", event = %event).entered();
@@ -383,7 +392,7 @@ fn handle_event(&mut self, event: Event) {
                             ));
                         }
                         PrimeCachesProgress::End { cancelled } => {
-                            self.analysis_host.trigger_garbage_collection();
+                            self.trigger_garbage_collection();
                             self.prime_caches_queue.op_completed(());
                             if cancelled {
                                 self.prime_caches_queue
@@ -542,7 +551,7 @@ fn handle_event(&mut self, event: Event) {
                 && self.fmt_pool.handle.is_empty()
                 && current_revision != self.last_gc_revision
             {
-                self.analysis_host.trigger_garbage_collection();
+                self.trigger_garbage_collection();
                 self.last_gc_revision = current_revision;
             }
         }

From 93584fd50f6d629a3ea08b56c557725c4021a4cd Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 16 Mar 2026 10:21:35 +0000
Subject: [PATCH 0529/1059] dissolve `tests/ui/cross`

---
 tests/ui/README.md                                |  4 ----
 .../coercion/no-implicit-box-to-ref-coercion.rs   | 11 +++++++++++
 .../no-implicit-box-to-ref-coercion.stderr}       |  2 +-
 .../auxiliary/extern_macro_crate.rs               |  0
 .../cross-crate-macro-backtrace.rs}               |  0
 .../cross-crate-macro-backtrace.stderr}           |  2 +-
 tests/ui/cross/cross-borrow-trait.rs              | 15 ---------------
 .../main.rs => macros/cross-file-errors.rs}       |  0
 .../cross-file-errors.stderr}                     |  2 +-
 .../cross-file-errors => macros}/underscore.rs    |  0
 tests/ui/{cross => traits}/cross-fn-cache-hole.rs |  0
 .../{cross => traits}/cross-fn-cache-hole.stderr  |  0
 12 files changed, 14 insertions(+), 22 deletions(-)
 create mode 100644 tests/ui/coercion/no-implicit-box-to-ref-coercion.rs
 rename tests/ui/{cross/cross-borrow-trait.stderr => coercion/no-implicit-box-to-ref-coercion.stderr} (88%)
 rename tests/ui/{cross/cross-crate-macro-backtrace => cross-crate}/auxiliary/extern_macro_crate.rs (100%)
 rename tests/ui/{cross/cross-crate-macro-backtrace/main.rs => cross-crate/cross-crate-macro-backtrace.rs} (100%)
 rename tests/ui/{cross/cross-crate-macro-backtrace/main.stderr => cross-crate/cross-crate-macro-backtrace.stderr} (88%)
 delete mode 100644 tests/ui/cross/cross-borrow-trait.rs
 rename tests/ui/{cross/cross-file-errors/main.rs => macros/cross-file-errors.rs} (100%)
 rename tests/ui/{cross/cross-file-errors/main.stderr => macros/cross-file-errors.stderr} (92%)
 rename tests/ui/{cross/cross-file-errors => macros}/underscore.rs (100%)
 rename tests/ui/{cross => traits}/cross-fn-cache-hole.rs (100%)
 rename tests/ui/{cross => traits}/cross-fn-cache-hole.stderr (100%)

diff --git a/tests/ui/README.md b/tests/ui/README.md
index 9911353af5cd..848df58f2714 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -344,10 +344,6 @@ Tests for `#![feature(coverage_attribute)]`. See [Tracking issue for function at
 
 Tests for crate resolution and loading behavior, including `extern crate` declarations, `--extern` flags, or the `use` keyword.
 
-## `tests/ui/cross/`: Various tests related to the concept of "cross"
-
-**FIXME**: The unifying topic of these tests appears to be that their filenames begin with the word "cross". The similarities end there - one test is about "cross-borrowing" a `Box<T>` into `&T`, while another is about a global trait used "across" files. Some of this terminology is really outdated and does not match the current terminology. Additionally, "cross" is also way too generic, it's easy to confuse with cross-compile.
-
 ## `tests/ui/cross-crate/`: Cross-Crate Interaction
 
 Tests for behavior spanning multiple crates, including visibility rules, trait implementations, and type resolution across crate boundaries.
diff --git a/tests/ui/coercion/no-implicit-box-to-ref-coercion.rs b/tests/ui/coercion/no-implicit-box-to-ref-coercion.rs
new file mode 100644
index 000000000000..f061117d67ed
--- /dev/null
+++ b/tests/ui/coercion/no-implicit-box-to-ref-coercion.rs
@@ -0,0 +1,11 @@
+// Test that implicitly converting from `Box<T>` to `&T` is
+// forbidden when `T` is a trait.
+
+struct Foo;
+trait Trait { fn foo(&self) {} }
+impl Trait for Foo {}
+
+pub fn main() {
+    let x: Box<dyn Trait> = Box::new(Foo);
+    let _y: &dyn Trait = x; //~ ERROR E0308
+}
diff --git a/tests/ui/cross/cross-borrow-trait.stderr b/tests/ui/coercion/no-implicit-box-to-ref-coercion.stderr
similarity index 88%
rename from tests/ui/cross/cross-borrow-trait.stderr
rename to tests/ui/coercion/no-implicit-box-to-ref-coercion.stderr
index 5fe80b5a3eef..da0b28b0149d 100644
--- a/tests/ui/cross/cross-borrow-trait.stderr
+++ b/tests/ui/coercion/no-implicit-box-to-ref-coercion.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/cross-borrow-trait.rs:12:26
+  --> $DIR/no-implicit-box-to-ref-coercion.rs:10:26
    |
 LL |     let _y: &dyn Trait = x;
    |             ----------   ^ expected `&dyn Trait`, found `Box<dyn Trait>`
diff --git a/tests/ui/cross/cross-crate-macro-backtrace/auxiliary/extern_macro_crate.rs b/tests/ui/cross-crate/auxiliary/extern_macro_crate.rs
similarity index 100%
rename from tests/ui/cross/cross-crate-macro-backtrace/auxiliary/extern_macro_crate.rs
rename to tests/ui/cross-crate/auxiliary/extern_macro_crate.rs
diff --git a/tests/ui/cross/cross-crate-macro-backtrace/main.rs b/tests/ui/cross-crate/cross-crate-macro-backtrace.rs
similarity index 100%
rename from tests/ui/cross/cross-crate-macro-backtrace/main.rs
rename to tests/ui/cross-crate/cross-crate-macro-backtrace.rs
diff --git a/tests/ui/cross/cross-crate-macro-backtrace/main.stderr b/tests/ui/cross-crate/cross-crate-macro-backtrace.stderr
similarity index 88%
rename from tests/ui/cross/cross-crate-macro-backtrace/main.stderr
rename to tests/ui/cross-crate/cross-crate-macro-backtrace.stderr
index d6f20b1f8e9f..9d6a2fbbf002 100644
--- a/tests/ui/cross/cross-crate-macro-backtrace/main.stderr
+++ b/tests/ui/cross-crate/cross-crate-macro-backtrace.stderr
@@ -1,5 +1,5 @@
 error: 1 positional argument in format string, but no arguments were given
-  --> $DIR/main.rs:6:5
+  --> $DIR/cross-crate-macro-backtrace.rs:6:5
    |
 LL |     myprintln!("{}");
    |     ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cross/cross-borrow-trait.rs b/tests/ui/cross/cross-borrow-trait.rs
deleted file mode 100644
index 88ea78e44b3a..000000000000
--- a/tests/ui/cross/cross-borrow-trait.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Test that cross-borrowing (implicitly converting from `Box<T>` to `&T`) is
-// forbidden when `T` is a trait.
-
-//@ dont-require-annotations: NOTE
-
-struct Foo;
-trait Trait { fn foo(&self) {} }
-impl Trait for Foo {}
-
-pub fn main() {
-    let x: Box<dyn Trait> = Box::new(Foo);
-    let _y: &dyn Trait = x; //~ ERROR E0308
-                            //~| NOTE expected reference `&dyn Trait`
-                            //~| NOTE found struct `Box<dyn Trait>`
-}
diff --git a/tests/ui/cross/cross-file-errors/main.rs b/tests/ui/macros/cross-file-errors.rs
similarity index 100%
rename from tests/ui/cross/cross-file-errors/main.rs
rename to tests/ui/macros/cross-file-errors.rs
diff --git a/tests/ui/cross/cross-file-errors/main.stderr b/tests/ui/macros/cross-file-errors.stderr
similarity index 92%
rename from tests/ui/cross/cross-file-errors/main.stderr
rename to tests/ui/macros/cross-file-errors.stderr
index db7b3a84fc8b..70db7d5185ea 100644
--- a/tests/ui/cross/cross-file-errors/main.stderr
+++ b/tests/ui/macros/cross-file-errors.stderr
@@ -4,7 +4,7 @@ error: in expressions, `_` can only be used on the left-hand side of an assignme
 LL |         _
    |         ^ `_` not allowed here
    |
-  ::: $DIR/main.rs:5:5
+  ::: $DIR/cross-file-errors.rs:5:5
    |
 LL |     underscore!();
    |     ------------- in this macro invocation
diff --git a/tests/ui/cross/cross-file-errors/underscore.rs b/tests/ui/macros/underscore.rs
similarity index 100%
rename from tests/ui/cross/cross-file-errors/underscore.rs
rename to tests/ui/macros/underscore.rs
diff --git a/tests/ui/cross/cross-fn-cache-hole.rs b/tests/ui/traits/cross-fn-cache-hole.rs
similarity index 100%
rename from tests/ui/cross/cross-fn-cache-hole.rs
rename to tests/ui/traits/cross-fn-cache-hole.rs
diff --git a/tests/ui/cross/cross-fn-cache-hole.stderr b/tests/ui/traits/cross-fn-cache-hole.stderr
similarity index 100%
rename from tests/ui/cross/cross-fn-cache-hole.stderr
rename to tests/ui/traits/cross-fn-cache-hole.stderr

From d57577e03d5e7c0cac5d54d67f9f768d37c032f4 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 15 Mar 2026 14:39:44 +1100
Subject: [PATCH 0530/1059] Remove redundant fields from `QueryStackFrame`

An explicit dep-kind is redundant here. If we want to find the query name, or
check for specific queries, we can inspect the `TaggedQueryKey` instead.

Similarly, in cases where the key is some kind of `DefId`, we can extract it
directly from the `TaggedQueryKey`.
---
 compiler/rustc_middle/src/query/plumbing.rs   | 12 ++++++++++
 compiler/rustc_middle/src/query/stack.rs      | 12 ++++------
 compiler/rustc_query_impl/src/execution.rs    |  7 +++---
 .../rustc_query_impl/src/from_cycle_error.rs  | 11 ++++-----
 compiler/rustc_query_impl/src/job.rs          | 21 +++++++++--------
 compiler/rustc_query_impl/src/plumbing.rs     | 23 +------------------
 6 files changed, 38 insertions(+), 48 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index e88c20f02537..17fa9bf085eb 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -513,6 +513,18 @@ pub enum TaggedQueryKey<'tcx> {
         }
 
         impl<'tcx> TaggedQueryKey<'tcx> {
+            /// Returns the name of the query this key is tagged with.
+            ///
+            /// This is useful for error/debug output, but don't use it to check for
+            /// specific query names. Instead, match on the `TaggedQueryKey` variant.
+            pub fn query_name(&self) -> &'static str {
+                match self {
+                    $(
+                        TaggedQueryKey::$name(_) => stringify!($name),
+                    )*
+                }
+            }
+
             /// Formats a human-readable description of this query and its key, as
             /// specified by the `desc` query modifier.
             ///
diff --git a/compiler/rustc_middle/src/query/stack.rs b/compiler/rustc_middle/src/query/stack.rs
index 6599ad3c6f54..6a77ddc1eaa7 100644
--- a/compiler/rustc_middle/src/query/stack.rs
+++ b/compiler/rustc_middle/src/query/stack.rs
@@ -1,8 +1,3 @@
-use std::fmt::Debug;
-
-use rustc_span::def_id::DefId;
-
-use crate::dep_graph::DepKind;
 use crate::queries::TaggedQueryKey;
 
 /// Description of a frame in the query stack.
@@ -10,7 +5,10 @@
 /// This is mostly used in case of cycles for error reporting.
 #[derive(Clone, Debug)]
 pub struct QueryStackFrame<'tcx> {
+    /// The query and key of the query method call that this stack frame
+    /// corresponds to.
+    ///
+    /// Code that doesn't care about the specific key can still use this to
+    /// check which query it's for, or obtain the query's name.
     pub tagged_key: TaggedQueryKey<'tcx>,
-    pub dep_kind: DepKind,
-    pub def_id: Option<DefId>,
 }
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 1224ec0706cf..6c91db16967b 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -9,7 +9,7 @@
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::{
     ActiveKeyStatus, CycleError, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey,
-    QueryLatch, QueryMode, QueryState, QueryVTable,
+    QueryLatch, QueryMode, QueryStackFrame, QueryState, QueryVTable,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
@@ -73,8 +73,9 @@ fn collect_active_query_jobs_inner<'tcx, C>(
     let mut collect_shard_jobs = |shard: &HashTable<(C::Key, ActiveKeyStatus<'tcx>)>| {
         for (key, status) in shard.iter() {
             if let ActiveKeyStatus::Started(job) = status {
-                // This function is safe to call with the shard locked because it is very simple.
-                let frame = crate::plumbing::create_query_stack_frame(query, *key);
+                // It's fine to call `create_tagged_key` with the shard locked,
+                // because it's just a `TaggedQueryKey` variant constructor.
+                let frame = QueryStackFrame { tagged_key: (query.create_tagged_key)(*key) };
                 job_map.insert(job.id, QueryJobInfo { frame, job: job.clone() });
             }
         }
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index fa508419b52f..f2a2e4f82c0b 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -8,7 +8,6 @@
 use rustc_errors::{Applicability, Diag, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_middle::dep_graph::DepKind;
 use rustc_middle::queries::{QueryVTables, TaggedQueryKey};
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
@@ -77,11 +76,10 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
     let mut item_and_field_ids = Vec::new();
     let mut representable_ids = FxHashSet::default();
     for frame in &cycle_error.cycle {
-        if frame.node.dep_kind == DepKind::check_representability
-            && let Some(field_id) = frame.node.def_id
-            && let Some(field_id) = field_id.as_local()
-            && let Some(DefKind::Field) = frame.node.tagged_key.def_kind(tcx)
+        if let TaggedQueryKey::check_representability(def_id) = frame.node.tagged_key
+            && tcx.def_kind(def_id) == DefKind::Field
         {
+            let field_id: LocalDefId = def_id;
             let parent_id = tcx.parent(field_id.to_def_id());
             let item_id = match tcx.def_kind(parent_id) {
                 DefKind::Variant => tcx.parent(parent_id),
@@ -110,8 +108,7 @@ fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> &'tcx
         &cycle_error.cycle,
         |cycle| {
             if let Some(frame) = cycle.get(0)
-                && frame.node.dep_kind == DepKind::variances_of
-                && let Some(def_id) = frame.node.def_id
+                && let TaggedQueryKey::variances_of(def_id) = frame.node.tagged_key
             {
                 let n = tcx.generics_of(def_id).own_params.len();
                 ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 0b989201a2e0..2f13d103f7b4 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -1,11 +1,12 @@
 use std::io::Write;
-use std::iter;
 use std::ops::ControlFlow;
 use std::sync::Arc;
+use std::{iter, mem};
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
+use rustc_middle::queries::TaggedQueryKey;
 use rustc_middle::query::{
     CycleError, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
 };
@@ -88,8 +89,8 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
     panic!("did not find a cycle")
 }
 
-/// Finds the job closest to the root with a `DepKind` matching the `DepKind` of `id` and returns
-/// information about it.
+/// Finds the query job closest to the root that is for the same query method as `id`
+/// (but not necessarily the same query key), and returns information about it.
 #[cold]
 #[inline(never)]
 pub(crate) fn find_dep_kind_root<'tcx>(
@@ -99,12 +100,14 @@ pub(crate) fn find_dep_kind_root<'tcx>(
 ) -> (Span, String, usize) {
     let mut depth = 1;
     let mut info = &job_map.map[&id];
-    let dep_kind = info.frame.dep_kind;
+    // Two query stack frames are for the same query method if they have the same
+    // `TaggedQueryKey` discriminant.
+    let expected_query = mem::discriminant::<TaggedQueryKey<'tcx>>(&info.frame.tagged_key);
     let mut last_info = info;
 
     while let Some(id) = info.job.parent {
         info = &job_map.map[&id];
-        if info.frame.dep_kind == dep_kind {
+        if mem::discriminant(&info.frame.tagged_key) == expected_query {
             depth += 1;
             last_info = info;
         }
@@ -420,8 +423,8 @@ pub fn print_query_stack<'tcx>(
         if Some(count_printed) < limit_frames || limit_frames.is_none() {
             // Only print to stderr as many stack frames as `num_frames` when present.
             dcx.struct_failure_note(format!(
-                "#{} [{:?}] {}",
-                count_printed, query_info.frame.dep_kind, description
+                "#{count_printed} [{query_name}] {description}",
+                query_name = query_info.frame.tagged_key.query_name(),
             ))
             .with_span(query_info.job.span)
             .emit();
@@ -431,8 +434,8 @@ pub fn print_query_stack<'tcx>(
         if let Some(ref mut file) = file {
             let _ = writeln!(
                 file,
-                "#{} [{:?}] {}",
-                count_total, query_info.frame.dep_kind, description
+                "#{count_total} [{query_name}] {description}",
+                query_name = query_info.frame.tagged_key.query_name(),
             );
         }
 
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 2613b72de376..b8aa125aaf96 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -1,8 +1,6 @@
 use std::num::NonZero;
 
-use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_data_structures::unord::UnordMap;
-use rustc_hir::def_id::DefId;
 use rustc_hir::limit::Limit;
 use rustc_index::Idx;
 use rustc_middle::bug;
@@ -13,9 +11,7 @@
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
 };
-use rustc_middle::query::{
-    QueryCache, QueryJobId, QueryKey, QueryMode, QueryStackFrame, QueryVTable, erase,
-};
+use rustc_middle::query::{QueryCache, QueryJobId, QueryMode, QueryVTable, erase};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::tls::{self, ImplicitCtxt};
@@ -83,23 +79,6 @@ pub(crate) fn start_query<R>(
     })
 }
 
-pub(crate) fn create_query_stack_frame<'tcx, C>(
-    vtable: &'tcx QueryVTable<'tcx, C>,
-    key: C::Key,
-) -> QueryStackFrame<'tcx>
-where
-    C: QueryCache<Key: QueryKey + DynSend + DynSync>,
-    QueryVTable<'tcx, C>: DynSync,
-{
-    let def_id: Option<DefId> = key.key_as_def_id();
-
-    QueryStackFrame {
-        tagged_key: (vtable.create_tagged_key)(key),
-        dep_kind: vtable.dep_kind,
-        def_id,
-    }
-}
-
 pub(crate) fn encode_query_values<'tcx>(
     tcx: TyCtxt<'tcx>,
     encoder: &mut CacheEncoder<'_, 'tcx>,

From b7bc96291e12bfe60a1fc6dae9db5af3b62f7431 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Fri, 13 Mar 2026 18:34:01 +0000
Subject: [PATCH 0531/1059] fix: SCIP generation should prime caches in
 parallel

Previously load_workspace_into_db() called parallel_prime_caches()
with a worker count of 1 unconditionally. This made SCIP generation
slower than it needed to be.

Instead, pass the number of workers explicitly, and allow the SCIP
subcommand to specify the number of workers from the CLI, defaulting
to the number of physical CPUs.

On my M4 Macbook Pro this reduces the time taken to generate SCIP for
rust-analyzer from ~39 seconds to ~35 seconds.

AI disclosure: Partially written with Claude Opus 4.6.
---
 src/tools/rust-analyzer/crates/load-cargo/src/lib.rs          | 4 +++-
 .../crates/rust-analyzer/src/cli/analysis_stats.rs            | 1 +
 .../rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs | 1 +
 src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs | 4 ++++
 src/tools/rust-analyzer/crates/rust-analyzer/src/cli/lsif.rs  | 1 +
 .../crates/rust-analyzer/src/cli/prime_caches.rs              | 1 +
 .../rust-analyzer/crates/rust-analyzer/src/cli/run_tests.rs   | 1 +
 .../rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs | 1 +
 src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs  | 1 +
 src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs   | 2 ++
 .../crates/rust-analyzer/src/cli/unresolved_references.rs     | 1 +
 .../crates/rust-analyzer/src/integrated_benchmarks.rs         | 3 +++
 12 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
index 95fcfce29127..30cd87709220 100644
--- a/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/load-cargo/src/lib.rs
@@ -42,6 +42,7 @@ pub struct LoadCargoConfig {
     pub load_out_dirs_from_check: bool,
     pub with_proc_macro_server: ProcMacroServerChoice,
     pub prefill_caches: bool,
+    pub num_worker_threads: usize,
     pub proc_macro_processes: usize,
 }
 
@@ -197,7 +198,7 @@ pub fn load_workspace_into_db(
     );
 
     if load_config.prefill_caches {
-        prime_caches::parallel_prime_caches(db, 1, &|_| ());
+        prime_caches::parallel_prime_caches(db, load_config.num_worker_threads, &|_| ());
     }
 
     Ok((vfs, proc_macro_server.and_then(Result::ok)))
@@ -750,6 +751,7 @@ fn test_loading_rust_analyzer() {
             load_out_dirs_from_check: false,
             with_proc_macro_server: ProcMacroServerChoice::None,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (db, _vfs, _proc_macro) =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 82f04aa78ebb..ad1cca08cb57 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -91,6 +91,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                 }
             },
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
index 575c77f8428c..efbaad3c4936 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -41,6 +41,7 @@ fn run_(self) -> anyhow::Result<()> {
             load_out_dirs_from_check: !self.disable_build_scripts,
             with_proc_macro_server,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (db, _vfs, _proc_macro) =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
index d68f7ab5b7b2..03849938f598 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
@@ -191,6 +191,9 @@
 
             /// Exclude code from vendored libraries from the resulting index.
             optional --exclude-vendored-libraries
+
+            /// The number of worker threads for cache priming. Defaults to the number of physical cores.
+            optional --num-threads num_threads: usize
         }
     }
 }
@@ -338,6 +341,7 @@ pub struct Scip {
     pub output: Option<PathBuf>,
     pub config_path: Option<PathBuf>,
     pub exclude_vendored_libraries: bool,
+    pub num_threads: Option<usize>,
 }
 
 impl RustAnalyzer {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/lsif.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/lsif.rs
index e5e238db6361..3950a581fd77 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/lsif.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/lsif.rs
@@ -293,6 +293,7 @@ pub fn run(
             load_out_dirs_from_check: true,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let path = AbsPathBuf::assert_utf8(env::current_dir()?.join(self.path));
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/prime_caches.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/prime_caches.rs
index d5da6791797b..beedcfae4ed8 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/prime_caches.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/prime_caches.rs
@@ -38,6 +38,7 @@ pub fn run(self) -> anyhow::Result<()> {
             // we want to ensure that this command, not `load_workspace_at`,
             // is responsible for that work.
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: config.proc_macro_num_processes(),
         };
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/run_tests.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/run_tests.rs
index d4a56d773e7d..e8c88cadf6f0 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/run_tests.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/run_tests.rs
@@ -23,6 +23,7 @@ pub fn run(self) -> Result<()> {
             load_out_dirs_from_check: true,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (ref db, _vfs, _proc_macro) =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
index e8c6c5f4d4f7..49f28352b6cf 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
@@ -103,6 +103,7 @@ fn new() -> Result<Self> {
             load_out_dirs_from_check: false,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (db, _vfs, _proc_macro) =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs
index ed0476697c9c..ef6d4399e663 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs
@@ -52,6 +52,7 @@ pub fn run(self) -> anyhow::Result<()> {
             load_out_dirs_from_check: true,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: true,
+            num_worker_threads: self.num_threads.unwrap_or_else(num_cpus::get_physical),
             proc_macro_processes: config.proc_macro_num_processes(),
         };
         let cargo_config = config.cargo(None);
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
index 6bc0792daabb..7b00aebbfc4a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/ssr.rs
@@ -20,6 +20,7 @@ pub fn run(self) -> anyhow::Result<()> {
             load_out_dirs_from_check: true,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (ref db, vfs, _proc_macro) = load_workspace_at(
@@ -57,6 +58,7 @@ pub fn run(self) -> anyhow::Result<()> {
             load_out_dirs_from_check: true,
             with_proc_macro_server: ProcMacroServerChoice::Sysroot,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: 1,
         };
         let (ref db, _vfs, _proc_macro) = load_workspace_at(
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/unresolved_references.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/unresolved_references.rs
index 49c6fcb91ebf..2d9b870f4de8 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/unresolved_references.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/unresolved_references.rs
@@ -44,6 +44,7 @@ fn run_(self) -> anyhow::Result<()> {
             load_out_dirs_from_check: !self.disable_build_scripts,
             with_proc_macro_server,
             prefill_caches: false,
+            num_worker_threads: 1,
             proc_macro_processes: config.proc_macro_num_processes(),
         };
         let (db, vfs, _proc_macro) =
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
index d16ca2fb48ac..6a74b8a54deb 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/integrated_benchmarks.rs
@@ -53,6 +53,7 @@ fn integrated_highlighting_benchmark() {
         load_out_dirs_from_check: true,
         with_proc_macro_server: ProcMacroServerChoice::Sysroot,
         prefill_caches: false,
+        num_worker_threads: 1,
         proc_macro_processes: 1,
     };
 
@@ -122,6 +123,7 @@ fn integrated_completion_benchmark() {
         load_out_dirs_from_check: true,
         with_proc_macro_server: ProcMacroServerChoice::Sysroot,
         prefill_caches: true,
+        num_worker_threads: 1,
         proc_macro_processes: 1,
     };
 
@@ -324,6 +326,7 @@ fn integrated_diagnostics_benchmark() {
         load_out_dirs_from_check: true,
         with_proc_macro_server: ProcMacroServerChoice::Sysroot,
         prefill_caches: true,
+        num_worker_threads: 1,
         proc_macro_processes: 1,
     };
 

From 5fe6600b00fbbf70b7749113fd29082020b7479f Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 16 Mar 2026 19:32:27 +0530
Subject: [PATCH 0532/1059] add mappings for constructors

---
 .../src/handlers/convert_to_guarded_return.rs |  2 +-
 .../src/handlers/convert_while_to_loop.rs     |  5 +-
 .../src/handlers/generate_delegate_methods.rs |  2 +-
 .../src/ast/syntax_factory/constructors.rs    | 60 +++++++++++++++----
 4 files changed, 56 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index 374c7cd86992..db4591679220 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -262,7 +262,7 @@ fn early_expression(
     }
 
     Some(match parent_container.kind() {
-        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None),
+        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None).into(),
         FN | CLOSURE_EXPR => make.expr_return(None).into(),
         _ => return None,
     })
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
index c06e539a4fdb..f8215d6723d3 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_while_to_loop.rs
@@ -57,7 +57,10 @@ pub(crate) fn convert_while_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>)
             let while_indent_level = IndentLevel::from_node(while_expr.syntax());
 
             let break_block = make
-                .block_expr(iter::once(make.expr_stmt(make.expr_break(None, None)).into()), None)
+                .block_expr(
+                    iter::once(make.expr_stmt(make.expr_break(None, None).into()).into()),
+                    None,
+                )
                 .indent(IndentLevel(1));
 
             edit.replace_all(
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
index d57db7b63d2a..63033c7d5e39 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
@@ -150,7 +150,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
 
                 let tail_expr = make.expr_method_call(field, make.name_ref(&name), arg_list).into();
                 let tail_expr_finished =
-                    if is_async { make.expr_await(tail_expr) } else { tail_expr };
+                    if is_async { make.expr_await(tail_expr).into() } else { tail_expr };
                 let body = make.block_expr([], Some(tail_expr_finished));
 
                 let ret_type = method_source.ret_type();
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index dd8cc8d6f2e2..d0f14dafe3f0 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1773,8 +1773,56 @@ pub fn field_from_idents<'a>(
         make::ext::field_from_idents(parts)
     }
 
-    pub fn expr_await(&self, expr: ast::Expr) -> ast::Expr {
-        make::expr_await(expr)
+    pub fn expr_await(&self, expr: ast::Expr) -> ast::AwaitExpr {
+        let ast::Expr::AwaitExpr(ast) = make::expr_await(expr.clone()).clone_for_update() else {
+            unreachable!()
+        };
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast
+    }
+
+    pub fn expr_break(&self, label: Option<Lifetime>, expr: Option<ast::Expr>) -> ast::BreakExpr {
+        let ast::Expr::BreakExpr(ast) =
+            make::expr_break(label.clone(), expr.clone()).clone_for_update()
+        else {
+            unreachable!()
+        };
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            if let Some(label) = label {
+                builder.map_node(label.syntax().clone(), ast.lifetime().unwrap().syntax().clone());
+            }
+            if let Some(expr) = expr {
+                builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
+            }
+            builder.finish(&mut mapping);
+        }
+
+        ast
+    }
+
+    pub fn expr_continue(&self, label: Option<Lifetime>) -> ast::ContinueExpr {
+        let ast::Expr::ContinueExpr(ast) = make::expr_continue(label.clone()).clone_for_update()
+        else {
+            unreachable!()
+        };
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            if let Some(label) = label {
+                builder.map_node(label.syntax().clone(), ast.lifetime().unwrap().syntax().clone());
+            }
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 }
 
@@ -1806,14 +1854,6 @@ pub fn ty_result(&self, t: ast::Type, e: ast::Type) -> ast::PathType {
 
         self.ty_path(path)
     }
-
-    pub fn expr_break(&self, label: Option<Lifetime>, expr: Option<ast::Expr>) -> ast::Expr {
-        make::expr_break(label, expr)
-    }
-
-    pub fn expr_continue(&self, label: Option<Lifetime>) -> ast::Expr {
-        make::expr_continue(label)
-    }
 }
 
 // We need to collect `input` here instead of taking `impl IntoIterator + Clone`,

From 2d419b597c80c993c3731147b38c8c1fa93cf919 Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Mon, 16 Mar 2026 22:21:54 +0800
Subject: [PATCH 0533/1059] Rename `parent_module` to `parent_scope`

---
 compiler/rustc_hir/src/attrs/data_structures.rs | 10 +++++-----
 compiler/rustc_metadata/src/rmeta/decoder.rs    |  2 +-
 compiler/rustc_metadata/src/rmeta/encoder.rs    |  2 +-
 compiler/rustc_resolve/src/diagnostics.rs       | 10 +++-------
 compiler/rustc_resolve/src/lib.rs               |  6 +++---
 compiler/rustc_resolve/src/macros.rs            |  2 +-
 6 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index e8476c3d8c73..b5b9da1e8e00 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -277,15 +277,15 @@ fn default() -> Self {
 }
 
 #[derive(Debug, Clone, Encodable, Decodable, HashStable_Generic)]
-pub struct StrippedCfgItem<ModId = DefId> {
-    pub parent_module: ModId,
+pub struct StrippedCfgItem<ScopeId = DefId> {
+    pub parent_scope: ScopeId,
     pub ident: Ident,
     pub cfg: (CfgEntry, Span),
 }
 
-impl<ModId> StrippedCfgItem<ModId> {
-    pub fn map_mod_id<New>(self, f: impl FnOnce(ModId) -> New) -> StrippedCfgItem<New> {
-        StrippedCfgItem { parent_module: f(self.parent_module), ident: self.ident, cfg: self.cfg }
+impl<ScopeId> StrippedCfgItem<ScopeId> {
+    pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
+        StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
     }
 }
 
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 2fa8e19984b4..fc541f952d22 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1223,7 +1223,7 @@ fn get_stripped_cfg_items<'tcx>(
             .root
             .stripped_cfg_items
             .decode((self, tcx))
-            .map(|item| item.map_mod_id(|index| DefId { krate: cnum, index }));
+            .map(|item| item.map_scope_id(|index| DefId { krate: cnum, index }));
         tcx.arena.alloc_from_iter(item_names)
     }
 
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index fbc7232f3a27..e554da362f83 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -2145,7 +2145,7 @@ fn encode_stripped_cfg_items(&mut self) -> LazyArray<StrippedCfgItem<DefIndex>>
             self.tcx
                 .stripped_cfg_items(LOCAL_CRATE)
                 .into_iter()
-                .map(|item| item.clone().map_mod_id(|def_id| def_id.index)),
+                .map(|item| item.clone().map_scope_id(|def_id| def_id.index)),
         )
     }
 
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 12cc5649c41d..927269d74996 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -3083,12 +3083,8 @@ pub(crate) fn find_cfg_stripped(&self, err: &mut Diag<'_>, segment: &Symbol, mod
                 .stripped_cfg_items
                 .iter()
                 .filter_map(|item| {
-                    let parent_module = self.opt_local_def_id(item.parent_module)?.to_def_id();
-                    Some(StrippedCfgItem {
-                        parent_module,
-                        ident: item.ident,
-                        cfg: item.cfg.clone(),
-                    })
+                    let parent_scope = self.opt_local_def_id(item.parent_scope)?.to_def_id();
+                    Some(StrippedCfgItem { parent_scope, ident: item.ident, cfg: item.cfg.clone() })
                 })
                 .collect::<Vec<_>>();
             local_items.as_slice()
@@ -3096,7 +3092,7 @@ pub(crate) fn find_cfg_stripped(&self, err: &mut Diag<'_>, segment: &Symbol, mod
             self.tcx.stripped_cfg_items(module.krate)
         };
 
-        for &StrippedCfgItem { parent_module, ident, ref cfg } in symbols {
+        for &StrippedCfgItem { parent_scope, ident, ref cfg } in symbols {
             if ident.name != *segment {
                 continue;
             }
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index ead69473b00d..7c942191d467 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1817,9 +1817,9 @@ pub fn into_outputs(self) -> ResolverOutputs<'tcx> {
             .stripped_cfg_items
             .into_iter()
             .filter_map(|item| {
-                let parent_module =
-                    self.node_id_to_def_id.get(&item.parent_module)?.key().to_def_id();
-                Some(StrippedCfgItem { parent_module, ident: item.ident, cfg: item.cfg })
+                let parent_scope =
+                    self.node_id_to_def_id.get(&item.parent_scope)?.key().to_def_id();
+                Some(StrippedCfgItem { parent_scope, ident: item.ident, cfg: item.cfg })
             })
             .collect();
 
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 551d89ee6022..ddf305237f39 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -512,7 +512,7 @@ fn append_stripped_cfg_item(
         cfg_span: Span,
     ) {
         self.stripped_cfg_items.push(StrippedCfgItem {
-            parent_module: parent_node,
+            parent_scope: parent_node,
             ident,
             cfg: (cfg, cfg_span),
         });

From 757f224bce0cea63228034e68ca593f9ad11c5da Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Mon, 16 Mar 2026 22:22:25 +0800
Subject: [PATCH 0534/1059] Use nearest non block module as the correct parent
 module

---
 compiler/rustc_resolve/src/diagnostics.rs  |  2 ++
 tests/ui/resolve/pub-in-path-153848.rs     |  9 +++++++++
 tests/ui/resolve/pub-in-path-153848.stderr | 21 +++++++++++++++++++++
 3 files changed, 32 insertions(+)
 create mode 100644 tests/ui/resolve/pub-in-path-153848.rs
 create mode 100644 tests/ui/resolve/pub-in-path-153848.stderr

diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 927269d74996..f11468239630 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -3097,6 +3097,8 @@ pub(crate) fn find_cfg_stripped(&self, err: &mut Diag<'_>, segment: &Symbol, mod
                 continue;
             }
 
+            let parent_module = self.get_nearest_non_block_module(parent_scope).def_id();
+
             fn comes_from_same_module_for_glob(
                 r: &Resolver<'_, '_>,
                 parent_module: DefId,
diff --git a/tests/ui/resolve/pub-in-path-153848.rs b/tests/ui/resolve/pub-in-path-153848.rs
new file mode 100644
index 000000000000..40045e96987f
--- /dev/null
+++ b/tests/ui/resolve/pub-in-path-153848.rs
@@ -0,0 +1,9 @@
+//@ edition: 2015
+
+pub(in a) mod aa { //~ ERROR cannot find module or crate `a` in the crate root
+}
+mod test {
+    #[cfg(test)]
+    use super::a;
+}
+fn main() {}
diff --git a/tests/ui/resolve/pub-in-path-153848.stderr b/tests/ui/resolve/pub-in-path-153848.stderr
new file mode 100644
index 000000000000..06973a4c0bf3
--- /dev/null
+++ b/tests/ui/resolve/pub-in-path-153848.stderr
@@ -0,0 +1,21 @@
+error[E0433]: cannot find module or crate `a` in the crate root
+  --> $DIR/pub-in-path-153848.rs:3:8
+   |
+LL | pub(in a) mod aa {
+   |        ^ use of unresolved module or unlinked crate `a`
+   |
+note: found an item that was configured out
+  --> $DIR/pub-in-path-153848.rs:7:16
+   |
+LL |     #[cfg(test)]
+   |           ---- the item is gated here
+LL |     use super::a;
+   |                ^
+help: you might be missing a crate named `a`, add it to your project and import it in your code
+   |
+LL + extern crate a;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0433`.

From ccd16408934e3d590192a1e310f75647ca8437ed Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Mon, 16 Mar 2026 14:26:44 +0000
Subject: [PATCH 0535/1059] Add missing needs-sanitizer-kasan directive name

Using kasan naming instead of kernel-address to match existing use in
src/tools/compiletest/src/directives/needs.rs
---
 src/tools/compiletest/src/directives/directive_names.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 2fc5c0e8ec1e..0c55cd6fe8a7 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -176,6 +176,7 @@
     "needs-sanitizer-cfi",
     "needs-sanitizer-dataflow",
     "needs-sanitizer-hwaddress",
+    "needs-sanitizer-kasan",
     "needs-sanitizer-kcfi",
     "needs-sanitizer-leak",
     "needs-sanitizer-memory",

From 042875bb848f9a54f1b9940e336b3111af1855ef Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Mon, 16 Mar 2026 21:32:10 +0800
Subject: [PATCH 0536/1059] rustc_public: add `vtable_entries()` to `TraitRef`

---
 .../rustc_public/src/compiler_interface.rs    |  19 ++-
 compiler/rustc_public/src/ty.rs               |  27 +++-
 .../src/unstable/convert/stable/ty.rs         |  22 +++
 .../rustc_public_bridge/src/context/impls.rs  |  11 +-
 .../ui-fulldeps/rustc_public/check_vtable.rs  | 149 ++++++++++++++++++
 5 files changed, 225 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui-fulldeps/rustc_public/check_vtable.rs

diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index b0ea1e0f5b84..b5e6f2c0db8c 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -20,7 +20,8 @@
     AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, CoroutineDef, Discr, FieldDef, FnDef,
     ForeignDef, ForeignItemKind, ForeignModule, ForeignModuleDef, GenericArgs, GenericPredicates,
     Generics, ImplDef, ImplTrait, IntrinsicDef, LineInfo, MirConst, PolyFnSig, RigidTy, Span,
-    TraitDecl, TraitDef, Ty, TyConst, TyConstId, TyKind, UintTy, VariantDef, VariantIdx,
+    TraitDecl, TraitDef, TraitRef, Ty, TyConst, TyConstId, TyKind, UintTy, VariantDef, VariantIdx,
+    VtblEntry,
 };
 use crate::unstable::{RustcInternal, Stable, new_item_kind};
 use crate::{
@@ -838,6 +839,22 @@ pub(crate) fn associated_items(&self, def_id: DefId) -> AssocItems {
         let did = tables[def_id];
         cx.associated_items(did).iter().map(|assoc| assoc.stable(&mut *tables, cx)).collect()
     }
+
+    /// Get all vtable entries of a trait.
+    pub(crate) fn vtable_entries(&self, trait_ref: &TraitRef) -> Vec<VtblEntry> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.vtable_entries(trait_ref.internal(&mut *tables, cx.tcx))
+            .iter()
+            .map(|v| v.stable(&mut *tables, cx))
+            .collect()
+    }
+
+    pub(crate) fn vtable_entry(&self, trait_ref: &TraitRef, idx: usize) -> Option<VtblEntry> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.vtable_entry(trait_ref.internal(&mut *tables, cx.tcx), idx).stable(&mut *tables, cx)
+    }
 }
 
 // A thread local variable that stores a pointer to [`CompilerInterface`].
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index 8205d29c4534..fff6687bb549 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -9,7 +9,7 @@
 use crate::abi::{FnAbi, Layout};
 use crate::crate_def::{CrateDef, CrateDefType};
 use crate::mir::alloc::{AllocId, read_target_int, read_target_uint};
-use crate::mir::mono::StaticDef;
+use crate::mir::mono::{Instance, StaticDef};
 use crate::target::MachineInfo;
 use crate::{AssocItems, Filename, IndexedVal, Opaque, ThreadLocalIndex};
 
@@ -1440,6 +1440,15 @@ pub fn self_ty(&self) -> Ty {
         };
         self_ty
     }
+
+    /// Retrieve all vtable entries.
+    pub fn vtable_entries(&self) -> Vec<VtblEntry> {
+        with(|cx| cx.vtable_entries(self))
+    }
+
+    pub fn vtable_entry(&self, idx: usize) -> Option<VtblEntry> {
+        with(|cx| cx.vtable_entry(self, idx))
+    }
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
@@ -1656,3 +1665,19 @@ pub fn is_impl_trait_in_trait(&self) -> bool {
         matches!(self.kind, AssocKind::Type { data: AssocTypeData::Rpitit(_) })
     }
 }
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum VtblEntry {
+    /// destructor of this type (used in vtable header)
+    MetadataDropInPlace,
+    /// layout size of this type (used in vtable header)
+    MetadataSize,
+    /// layout align of this type (used in vtable header)
+    MetadataAlign,
+    /// non-dispatchable associated function that is excluded from trait object
+    Vacant,
+    /// dispatchable associated function
+    Method(Instance),
+    /// pointer to a separate supertrait vtable, can be used by trait upcasting coercion
+    TraitVPtr(TraitRef),
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 4bf98c4f0731..31cc6bd46959 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -1139,3 +1139,25 @@ fn stable<'cx>(
         crate::ty::Discr { val: self.val, ty: self.ty.stable(tables, cx) }
     }
 }
+
+impl<'tcx> Stable<'tcx> for rustc_middle::ty::VtblEntry<'tcx> {
+    type T = crate::ty::VtblEntry;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::VtblEntry;
+        match self {
+            ty::VtblEntry::MetadataDropInPlace => VtblEntry::MetadataDropInPlace,
+            ty::VtblEntry::MetadataSize => VtblEntry::MetadataSize,
+            ty::VtblEntry::MetadataAlign => VtblEntry::MetadataAlign,
+            ty::VtblEntry::Vacant => VtblEntry::Vacant,
+            ty::VtblEntry::Method(instance) => VtblEntry::Method(instance.stable(tables, cx)),
+            ty::VtblEntry::TraitVPtr(trait_ref) => {
+                VtblEntry::TraitVPtr(trait_ref.stable(tables, cx))
+            }
+        }
+    }
+}
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 4418d68c5c3a..932d970a14e6 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -18,7 +18,7 @@
     AdtDef, AdtKind, AssocItem, Binder, ClosureKind, CoroutineArgsExt, EarlyBinder,
     ExistentialTraitRef, FnSig, GenericArgsRef, Instance, InstanceKind, IntrinsicDef, List,
     PolyFnSig, ScalarInt, TraitDef, TraitRef, Ty, TyCtxt, TyKind, TypeVisitableExt, UintTy,
-    ValTree, VariantDef,
+    ValTree, VariantDef, VtblEntry,
 };
 use rustc_middle::{mir, ty};
 use rustc_session::cstore::ForeignModule;
@@ -757,4 +757,13 @@ pub fn associated_items(&self, def_id: DefId) -> Vec<AssocItem> {
         };
         assoc_items
     }
+
+    /// Get all vtable entries of a trait.
+    pub fn vtable_entries(&self, trait_ref: TraitRef<'tcx>) -> Vec<VtblEntry<'tcx>> {
+        self.tcx.vtable_entries(trait_ref).to_vec()
+    }
+
+    pub fn vtable_entry(&self, trait_ref: TraitRef<'tcx>, idx: usize) -> Option<VtblEntry<'tcx>> {
+        self.vtable_entries(trait_ref).get(idx).cloned()
+    }
 }
diff --git a/tests/ui-fulldeps/rustc_public/check_vtable.rs b/tests/ui-fulldeps/rustc_public/check_vtable.rs
new file mode 100644
index 000000000000..9b72eff7f6c9
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_vtable.rs
@@ -0,0 +1,149 @@
+//@ run-pass
+// Test that users are able to use rustc_public to retrieve vtable info.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+
+extern crate rustc_middle;
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::ty::VtblEntry;
+use rustc_public::CrateDef;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "vtable_test";
+
+/// This function uses the rustc_public APIs to test the `vtable_entries()`.
+fn test_vtable_entries() -> ControlFlow<()> {
+    let local_crate = rustc_public::local_crate();
+    let local_impls = local_crate.trait_impls();
+    let child_impl = local_impls
+        .iter()
+        .find(|i| i.trimmed_name() == "<Concrete as Child>")
+        .expect("Could not find <Concrete as Child>");
+
+    let child_trait_ref = child_impl.trait_impl().value;
+    let entries = child_trait_ref.vtable_entries();
+    match &entries[..] {
+        [
+            VtblEntry::MetadataDropInPlace,
+            VtblEntry::MetadataSize,
+            VtblEntry::MetadataAlign,
+            VtblEntry::Method(primary),
+            VtblEntry::Method(secondary),
+            VtblEntry::TraitVPtr(secondary_vptr),
+            VtblEntry::Method(child),
+        ] => {
+            assert!(
+                primary.name().contains("primary"),
+                "Expected primary method at index 3"
+            );
+            assert!(
+                secondary.name().contains("secondary"),
+                "Expected secondary method at index 4"
+            );
+            let vptr_str = secondary_vptr.def_id.name();
+            assert!(
+                vptr_str.contains("Secondary"),
+                "Expected Secondary VPtr at index 5"
+            );
+            assert!(
+                child.name().contains("child"),
+                "Expected child method at index 6"
+            );
+        }
+        _ => panic!(
+            "Unexpected vtable layout for <Concrete as Child>. Found: {:#?}",
+            entries
+        ),
+    }
+    let vacant_impl = local_impls
+        .iter()
+        .find(|i| i.trimmed_name() == "<Concrete as WithVacant>")
+        .expect("Could not find <Concrete as WithVacant>");
+    let vacant_trait_ref = vacant_impl.trait_impl().value;
+    let vacant_entries = vacant_trait_ref.vtable_entries();
+    match &vacant_entries[..] {
+        [
+            VtblEntry::MetadataDropInPlace,
+            VtblEntry::MetadataSize,
+            VtblEntry::MetadataAlign,
+            VtblEntry::Method(valid),
+        ] => {
+            assert!(valid.name().contains("valid"), "Expected valid method");
+        }
+        _ => panic!(
+            "Unexpected vtable layout for <Concrete as WithVacant>. Found: {:#?}",
+            vacant_entries
+        ),
+    }
+    ControlFlow::Continue(())
+}
+
+fn main() {
+    let path = "vtable_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "--crate-type=lib".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_vtable_entries).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        pub struct Concrete;
+
+        pub trait Primary {{
+            fn primary(&self);
+        }}
+
+        pub trait Secondary {{
+            fn secondary(&self);
+        }}
+
+        pub trait Child: Primary + Secondary {{
+            fn child(&self);
+        }}
+
+        impl Primary for Concrete {{
+            fn primary(&self) {{}}
+        }}
+
+        impl Secondary for Concrete {{
+            fn secondary(&self) {{}}
+        }}
+
+        impl Child for Concrete {{
+            fn child(&self) {{}}
+        }}
+
+        pub trait WithVacant {{
+            fn valid(&self);
+
+            fn excluded<T>(&self, meow: T) where Self: Sized;
+        }}
+
+        impl WithVacant for Concrete {{
+            fn valid(&self) {{}}
+            fn excluded<T>(&self, meow: T) {{}}
+        }}
+
+        fn main() {{}}
+    "#
+    )?;
+    Ok(())
+}

From 96893dcfc5418974715a66fe918ee3d5e01e73be Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Mon, 16 Mar 2026 23:14:50 +0800
Subject: [PATCH 0537/1059] rustc_public: add `vtable_entry`

---
 compiler/rustc_public/src/compiler_interface.rs   | 3 +++
 compiler/rustc_public/src/ty.rs                   | 3 +++
 compiler/rustc_public_bridge/src/context/impls.rs | 5 ++++-
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index b5e6f2c0db8c..30fbc5c5233d 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -850,6 +850,9 @@ pub(crate) fn vtable_entries(&self, trait_ref: &TraitRef) -> Vec<VtblEntry> {
             .collect()
     }
 
+    /// Returns the vtable entry at the given index.
+    ///
+    /// Returns `None` if the index is out of bounds.
     pub(crate) fn vtable_entry(&self, trait_ref: &TraitRef, idx: usize) -> Option<VtblEntry> {
         let mut tables = self.tables.borrow_mut();
         let cx = &*self.cx.borrow();
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index fff6687bb549..7ec8b688402a 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -1446,6 +1446,9 @@ pub fn vtable_entries(&self) -> Vec<VtblEntry> {
         with(|cx| cx.vtable_entries(self))
     }
 
+    /// Returns the vtable entry at the given index.
+    ///
+    /// Returns `None` if the index is out of bounds.
     pub fn vtable_entry(&self, idx: usize) -> Option<VtblEntry> {
         with(|cx| cx.vtable_entry(self, idx))
     }
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 932d970a14e6..359769d4cfe4 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -763,7 +763,10 @@ pub fn vtable_entries(&self, trait_ref: TraitRef<'tcx>) -> Vec<VtblEntry<'tcx>>
         self.tcx.vtable_entries(trait_ref).to_vec()
     }
 
+    /// Returns the vtable entry at the given index.
+    ///
+    /// Returns `None` if the index is out of bounds.
     pub fn vtable_entry(&self, trait_ref: TraitRef<'tcx>, idx: usize) -> Option<VtblEntry<'tcx>> {
-        self.vtable_entries(trait_ref).get(idx).cloned()
+        self.vtable_entries(trait_ref).get(idx).copied()
     }
 }

From 0b5b096ce8c235fb028666378e9ea8411261c552 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 16 Mar 2026 16:32:39 +0000
Subject: [PATCH 0538/1059] Update to Cranelift 0.129

---
 Cargo.lock | 124 +++++++++++++++++++++++++++++------------------------
 Cargo.toml |  26 +++++------
 2 files changed, 81 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index afc1d0d0ab95..2ceca336f094 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -43,42 +43,45 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0377b13bf002a0774fcccac4f1102a10f04893d24060cf4b7350c87e4cbb647c"
+checksum = "40630d663279bc855bff805d6f5e8a0b6a1867f9df95b010511ac6dc894e9395"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfa027979140d023b25bf7509fb7ede3a54c3d3871fb5ead4673c4b633f671a2"
+checksum = "3ee6aec5ceb55e5fdbcf7ef677d7c7195531360ff181ce39b2b31df11d57305f"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "618e4da87d9179a70b3c2f664451ca8898987aa6eb9f487d16988588b5d8cc40"
+checksum = "9a92d78cc3f087d7e7073828f08d98c7074a3a062b6b29a1b7783ce74305685e"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db53764b5dad233b37b8f5dc54d3caa9900c54579195e00f17ea21f03f71aaa7"
+checksum = "edcc73d756f2e0d7eda6144fe64a2bc69c624de893cb1be51f1442aed77881d2"
+dependencies = [
+ "wasmtime-internal-core",
+]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae927f1d8c0abddaa863acd201471d56e7fc6c3925104f4861ed4dc3e28b421"
+checksum = "683d94c2cd0d73b41369b88da1129589bc3a2d99cf49979af1d14751f35b7a1b"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -90,21 +93,22 @@ dependencies = [
  "cranelift-entity",
  "cranelift-isle",
  "gimli",
- "hashbrown",
+ "hashbrown 0.15.5",
+ "libm",
  "log",
  "regalloc2",
  "rustc-hash",
  "serde",
  "smallvec",
  "target-lexicon",
- "wasmtime-internal-math",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fcf1e3e6757834bd2584f4cbff023fcc198e9279dcb5d684b4bb27a9b19f54"
+checksum = "235da0e52ee3a0052d0e944c3470ff025b1f4234f6ec4089d3109f2d2ffa6cbd"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -114,33 +118,34 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "205dcb9e6ccf9d368b7466be675ff6ee54a63e36da6fe20e72d45169cf6fd254"
+checksum = "20c07c6c440bd1bf920ff7597a1e743ede1f68dcd400730bd6d389effa7662af"
 
 [[package]]
 name = "cranelift-control"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "108eca9fcfe86026054f931eceaf57b722c1b97464bf8265323a9b5877238817"
+checksum = "8797c022e02521901e1aee483dea3ed3c67f2bf0a26405c9dd48e8ee7a70944b"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0d96496910065d3165f84ff8e1e393916f4c086f88ac8e1b407678bc78735aa"
+checksum = "59d8e72637246edd2cba337939850caa8b201f6315925ec4c156fdd089999699"
 dependencies = [
  "cranelift-bitset",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e303983ad7e23c850f24d9c41fc3cb346e1b930f066d3966545e4c98dac5c9fb"
+checksum = "4c31db0085c3dfa131e739c3b26f9f9c84d69a9459627aac1ac4ef8355e3411b"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -150,15 +155,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b0cf8d867d891245836cac7abafb0a5b0ea040a019d720702b3b8bcba40bfa"
+checksum = "524d804c1ebd8c542e6f64e71aa36934cec17c5da4a9ae3799796220317f5d23"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf1e35da6eca2448395f483eb172ce71dd7842f7dc96f44bb8923beafe43c6d"
+checksum = "02ca12808d5c1ccf40cb02493a8f1790358f230867fe37735e9af8b76a2262cb"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -176,9 +181,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "792ba2a54100e34f8a36e3e329a5207cafd1f0918a031d34695db73c163fdcc7"
+checksum = "4d92fca47132ffc3de8783e82a577a2c8aedf85d1e12b92d08863d9af8a76bd4"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -187,9 +192,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24b641e315443e27807b69c440fe766737d7e718c68beb665a2d69259c77bf3"
+checksum = "dc9598f02540e382e1772416eba18e93c5275b746adbbf06ac1f3cf149415270"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -198,9 +203,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-object"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecba1f219a201cf946150538e631defd620c5051b62c52ecb89a0004bab263d4"
+checksum = "38fe79386c13648cf28653b300ba16b797a5be248bf11d3984201a17acbbbde5"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -213,9 +218,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.128.3"
+version = "0.129.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4e378a54e7168a689486d67ee1f818b7e5356e54ae51a1d7a53f4f13f7f8b7a"
+checksum = "d953932541249c91e3fa70a75ff1e52adc62979a2a8132145d4b9b3e6d1a9b6a"
 
 [[package]]
 name = "crc32fast"
@@ -233,10 +238,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
-name = "fallible-iterator"
-version = "0.3.0"
+name = "fnv"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
@@ -246,11 +251,12 @@ checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "gimli"
-version = "0.32.3"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+checksum = "0bf7f043f89559805f8c7cacc432749b2fa0d0a0a9ee46ce47164ed5ba7f126c"
 dependencies = [
- "fallible-iterator",
+ "fnv",
+ "hashbrown 0.16.1",
  "indexmap",
  "stable_deref_trait",
 ]
@@ -264,6 +270,12 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -272,12 +284,12 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.16.1",
 ]
 
 [[package]]
@@ -330,7 +342,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
  "crc32fast",
- "hashbrown",
+ "hashbrown 0.15.5",
  "indexmap",
  "memchr",
 ]
@@ -361,7 +373,7 @@ checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa"
 dependencies = [
  "allocator-api2",
  "bumpalo",
- "hashbrown",
+ "hashbrown 0.15.5",
  "log",
  "rustc-hash",
  "smallvec",
@@ -468,24 +480,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
-name = "wasmtime-internal-jit-icache-coherence"
-version = "41.0.3"
+name = "wasmtime-internal-core"
+version = "42.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bada5ca1cc47df7d14100e2254e187c2486b426df813cea2dd2553a7469f7674"
+checksum = "03a4a3f055a804a2f3d86e816a9df78a8fa57762212a8506164959224a40cd48"
 dependencies = [
- "anyhow",
- "cfg-if",
- "libc",
- "windows-sys 0.61.2",
+ "libm",
 ]
 
 [[package]]
-name = "wasmtime-internal-math"
-version = "41.0.3"
+name = "wasmtime-internal-jit-icache-coherence"
+version = "42.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf6f615d528eda9adc6eefb062135f831b5215c348f4c3ec3e143690c730605b"
+checksum = "c57d24e8d1334a0e5a8b600286ffefa1fc4c3e8176b110dff6fbc1f43c4a599b"
 dependencies = [
- "libm",
+ "cfg-if",
+ "libc",
+ "wasmtime-internal-core",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index a7b4664282ed..bc75092cfb90 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,14 +8,14 @@ crate-type = ["dylib"]
 
 [dependencies]
 # These have to be in sync with each other
-cranelift-codegen = { version = "0.128.3", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
-cranelift-frontend = { version = "0.128.3" }
-cranelift-module = { version = "0.128.3" }
-cranelift-native = { version = "0.128.3" }
-cranelift-jit = { version = "0.128.3", optional = true }
-cranelift-object = { version = "0.128.3" }
+cranelift-codegen = { version = "0.129.0", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
+cranelift-frontend = { version = "0.129.0" }
+cranelift-module = { version = "0.129.0" }
+cranelift-native = { version = "0.129.0" }
+cranelift-jit = { version = "0.129.0", optional = true }
+cranelift-object = { version = "0.129.0" }
 target-lexicon = "0.13"
-gimli = { version = "0.32", default-features = false, features = ["write"] }
+gimli = { version = "0.33", default-features = false, features = ["write"] }
 object = { version = "0.37.3", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
 
 indexmap = "2.0.0"
@@ -24,12 +24,12 @@ smallvec = "1.8.1"
 
 [patch.crates-io]
 # Uncomment to use an unreleased version of cranelift
-#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
-#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
-#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
-#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
-#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
-#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-41.0.0" }
+#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
 
 # Uncomment to use local checkout of cranelift
 #cranelift-codegen = { path = "../wasmtime/cranelift/codegen" }

From cd4fd289cd60a56de47372cec0a260939cc93932 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 16 Mar 2026 17:36:53 +0100
Subject: [PATCH 0539/1059] suggest valid features when target feature is
 invalid

---
 compiler/rustc_codegen_ssa/src/errors.rs      | 34 ++++++++++++-------
 .../rustc_codegen_ssa/src/target_features.rs  | 32 +++++++++++------
 tests/ui/target-feature/invalid-attribute.rs  | 13 ++++---
 .../target-feature/invalid-attribute.stderr   | 20 ++++++++---
 4 files changed, 68 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 41337fc21a7b..e0afcd51b7f4 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -8,7 +8,8 @@
 
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level, msg,
+    Diag, DiagArgValue, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, IntoDiagArg,
+    Level, msg,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::layout::LayoutError;
@@ -1249,20 +1250,29 @@ pub(crate) struct FeatureNotValid<'a> {
     #[label("`{$feature}` is not valid for this target")]
     pub span: Span,
     #[subdiagnostic]
-    pub plus_hint: Option<RemovePlusFromFeatureName<'a>>,
+    pub hint: FeatureNotValidHint<'a>,
 }
 
 #[derive(Subdiagnostic)]
-#[suggestion(
-    "consider removing the leading `+` in the feature name",
-    code = "enable = \"{stripped}\"",
-    applicability = "maybe-incorrect",
-    style = "verbose"
-)]
-pub struct RemovePlusFromFeatureName<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub stripped: &'a str,
+pub(crate) enum FeatureNotValidHint<'a> {
+    #[suggestion(
+        "consider removing the leading `+` in the feature name",
+        code = "enable = \"{stripped}\"",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    RemovePlusFromFeatureName {
+        #[primary_span]
+        span: Span,
+        stripped: &'a str,
+    },
+    #[help(
+        "valid names are: {$possibilities}{$and_more ->
+            [0] {\"\"}
+            *[other] {\" \"}and {$and_more} more
+        }"
+    )]
+    ValidFeatureNames { possibilities: DiagSymbolList<&'a str>, and_more: usize },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index 08a02831312c..8ac3f0555db2 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -9,12 +9,12 @@
 use rustc_session::Session;
 use rustc_session::lint::builtin::AARCH64_SOFTFLOAT_NEON;
 use rustc_session::parse::feature_err;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, Symbol, edit_distance, sym};
 use rustc_target::spec::Arch;
 use rustc_target::target_features::{RUSTC_SPECIFIC_FEATURES, Stability};
 use smallvec::SmallVec;
 
-use crate::errors::{FeatureNotValid, RemovePlusFromFeatureName};
+use crate::errors::{FeatureNotValid, FeatureNotValidHint};
 use crate::{errors, target_features};
 
 /// Compute the enabled target features from the `#[target_feature]` function attribute.
@@ -32,15 +32,25 @@ pub(crate) fn from_target_feature_attr(
     for &(feature, feature_span) in features {
         let feature_str = feature.as_str();
         let Some(stability) = rust_target_features.get(feature_str) else {
-            let plus_hint = feature_str
-                .strip_prefix('+')
-                .filter(|stripped| rust_target_features.contains_key(*stripped))
-                .map(|stripped| RemovePlusFromFeatureName { span: feature_span, stripped });
-            tcx.dcx().emit_err(FeatureNotValid {
-                feature: feature_str,
-                span: feature_span,
-                plus_hint,
-            });
+            let hint = if let Some(stripped) = feature_str.strip_prefix('+')
+                && rust_target_features.contains_key(stripped)
+            {
+                FeatureNotValidHint::RemovePlusFromFeatureName { span: feature_span, stripped }
+            } else {
+                // Show the 5 feature names that are most similar to the input.
+                let mut valid_names: Vec<_> =
+                    rust_target_features.keys().map(|name| name.as_str()).into_sorted_stable_ord();
+                valid_names.sort_by_key(|name| {
+                    edit_distance::edit_distance(name, feature.as_str(), 5).unwrap_or(usize::MAX)
+                });
+                valid_names.truncate(5);
+
+                FeatureNotValidHint::ValidFeatureNames {
+                    possibilities: valid_names.into(),
+                    and_more: rust_target_features.len().saturating_sub(5),
+                }
+            };
+            tcx.dcx().emit_err(FeatureNotValid { feature: feature_str, span: feature_span, hint });
             continue;
         };
 
diff --git a/tests/ui/target-feature/invalid-attribute.rs b/tests/ui/target-feature/invalid-attribute.rs
index 47068fbb25d4..1022929118bd 100644
--- a/tests/ui/target-feature/invalid-attribute.rs
+++ b/tests/ui/target-feature/invalid-attribute.rs
@@ -119,7 +119,12 @@ fn main() {
 //~| NOTE `+sse2` is not valid for this target
 unsafe fn hey() {}
 
-#[target_feature(enable = "+sse5")]
-//~^ ERROR `+sse5` is not valid for this target
-//~| NOTE `+sse5` is not valid for this target
-unsafe fn typo() {}
+#[target_feature(enable = "sse5")]
+//~^ ERROR `sse5` is not valid for this target
+//~| NOTE `sse5` is not valid for this target
+unsafe fn typo_sse() {}
+
+#[target_feature(enable = "avx512")]
+//~^ ERROR `avx512` is not valid for this target
+//~| NOTE `avx512` is not valid for this target
+unsafe fn typo_avx512() {}
diff --git a/tests/ui/target-feature/invalid-attribute.stderr b/tests/ui/target-feature/invalid-attribute.stderr
index fbc35cfdc325..8b91381a32b3 100644
--- a/tests/ui/target-feature/invalid-attribute.stderr
+++ b/tests/ui/target-feature/invalid-attribute.stderr
@@ -160,6 +160,8 @@ error: the feature named `foo` is not valid for this target
    |
 LL | #[target_feature(enable = "foo")]
    |                  ^^^^^^^^^^^^^^ `foo` is not valid for this target
+   |
+   = help: valid names are: `fma`, `xop`, `adx`, `aes`, and `avx` and 74 more
 
 error[E0046]: not all trait items implemented, missing: `foo`
   --> $DIR/invalid-attribute.rs:81:1
@@ -205,13 +207,23 @@ LL - #[target_feature(enable = "+sse2")]
 LL + #[target_feature(enable = "sse2")]
    |
 
-error: the feature named `+sse5` is not valid for this target
+error: the feature named `sse5` is not valid for this target
   --> $DIR/invalid-attribute.rs:122:18
    |
-LL | #[target_feature(enable = "+sse5")]
-   |                  ^^^^^^^^^^^^^^^^ `+sse5` is not valid for this target
+LL | #[target_feature(enable = "sse5")]
+   |                  ^^^^^^^^^^^^^^^ `sse5` is not valid for this target
+   |
+   = help: valid names are: `sse`, `sse2`, `sse3`, `sse4a`, and `ssse3` and 74 more
 
-error: aborting due to 25 previous errors
+error: the feature named `avx512` is not valid for this target
+  --> $DIR/invalid-attribute.rs:127:18
+   |
+LL | #[target_feature(enable = "avx512")]
+   |                  ^^^^^^^^^^^^^^^^^ `avx512` is not valid for this target
+   |
+   = help: valid names are: `avx512f`, `avx2`, `avx512bw`, `avx512cd`, and `avx512dq` and 74 more
+
+error: aborting due to 26 previous errors
 
 Some errors have detailed explanations: E0046, E0053, E0539, E0658.
 For more information about an error, try `rustc --explain E0046`.

From 9b1eb935bcab03b831bf2b952e49da293522c128 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 16 Mar 2026 17:47:09 +0000
Subject: [PATCH 0540/1059] Tweak wording of failed predicate in inference
 error

Special case message talking about `Predicate` that couldn't be satisfied when in inference errors so that we don't say "cannot satisfy `_: Trait`" and instead say "type must implement `Trait`".
---
 .../src/error_reporting/traits/ambiguity.rs       | 15 +++++++++++++--
 tests/ui/const-generics/issues/issue-83249.stderr |  2 +-
 .../ambig-hr-projection-issue-93340.old.stderr    |  2 +-
 .../bugs/issue-88382.stderr                       |  2 +-
 .../in-trait/not-inferred-generic.stderr          |  2 +-
 .../opaque-cast-field-access-in-future.stderr     |  2 +-
 tests/ui/impl-trait/where-allowed-2.stderr        |  2 +-
 tests/ui/impl-trait/where-allowed.stderr          |  2 +-
 tests/ui/imports/import-trait-method.stderr       |  2 +-
 .../inference/erase-type-params-in-label.stderr   |  4 ++--
 tests/ui/inference/issue-86162-1.stderr           |  2 +-
 tests/ui/inference/issue-86162-2.stderr           |  2 +-
 ...incorrect-impl-trait-in-path-suggestion.stderr |  2 +-
 .../ui/inference/question-mark-type-infer.stderr  |  6 +++---
 .../question-mark-type-inference-in-chain.rs      |  2 +-
 .../question-mark-type-inference-in-chain.stderr  |  2 +-
 .../types/into-inference-needs-type.stderr        |  2 +-
 .../argument-with-unnecessary-method-call.stderr  |  2 +-
 .../runaway-impl-candidate-selection.stderr       |  2 +-
 .../ui/traits/overflow-computing-ambiguity.stderr |  2 +-
 .../panic-with-unspecified-type.stderr            |  2 +-
 tests/ui/type-inference/sort_by_key.stderr        |  2 +-
 tests/ui/type/type-annotation-needed.rs           |  2 +-
 tests/ui/type/type-annotation-needed.stderr       |  2 +-
 24 files changed, 39 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
index 2afc1b040353..7de8891196d8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -11,6 +11,7 @@
 use rustc_infer::traits::{
     Obligation, ObligationCause, ObligationCauseCode, PolyTraitObligation, PredicateObligation,
 };
+use rustc_middle::ty::print::PrintPolyTraitPredicateExt;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitable as _, TypeVisitableExt as _};
 use rustc_session::parse::feature_err_unstable_feature_bound;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
@@ -306,8 +307,18 @@ pub(super) fn maybe_report_ambiguity(
                         err.cancel();
                         return e;
                     }
-                    let pred = self.tcx.short_string(predicate, &mut err.long_ty_path());
-                    err.note(format!("cannot satisfy `{pred}`"));
+                    if let Some(clause) = predicate.as_trait_clause()
+                        && let ty::Infer(_) = clause.self_ty().skip_binder().kind()
+                    {
+                        let tr = self.tcx.short_string(
+                            clause.print_modifiers_and_trait_path(),
+                            &mut err.long_ty_path(),
+                        );
+                        err.note(format!("the type must implement `{tr}`"));
+                    } else {
+                        let pred = self.tcx.short_string(predicate, &mut err.long_ty_path());
+                        err.note(format!("cannot satisfy `{pred}`"));
+                    }
                     let impl_candidates =
                         self.find_similar_impl_candidates(predicate.as_trait_clause().unwrap());
                     if impl_candidates.len() < 40 {
diff --git a/tests/ui/const-generics/issues/issue-83249.stderr b/tests/ui/const-generics/issues/issue-83249.stderr
index 2d561dbd6b1c..2668348613a4 100644
--- a/tests/ui/const-generics/issues/issue-83249.stderr
+++ b/tests/ui/const-generics/issues/issue-83249.stderr
@@ -6,7 +6,7 @@ LL |     let _ = foo([0; 1]);
    |             |
    |             required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: Foo`
+   = note: the type must implement `Foo`
 help: the trait `Foo` is implemented for `u8`
   --> $DIR/issue-83249.rs:8:1
    |
diff --git a/tests/ui/generic-associated-types/ambig-hr-projection-issue-93340.old.stderr b/tests/ui/generic-associated-types/ambig-hr-projection-issue-93340.old.stderr
index d913b2e91ca0..58ed71fad4a6 100644
--- a/tests/ui/generic-associated-types/ambig-hr-projection-issue-93340.old.stderr
+++ b/tests/ui/generic-associated-types/ambig-hr-projection-issue-93340.old.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     cmp_eq
    |     ^^^^^^ cannot infer type of the type parameter `A` declared on the function `cmp_eq`
    |
-   = note: cannot satisfy `_: Scalar`
+   = note: the type must implement `Scalar`
 note: required by a bound in `cmp_eq`
   --> $DIR/ambig-hr-projection-issue-93340.rs:10:22
    |
diff --git a/tests/ui/generic-associated-types/bugs/issue-88382.stderr b/tests/ui/generic-associated-types/bugs/issue-88382.stderr
index ce20a4eeac04..dcadd5ce8deb 100644
--- a/tests/ui/generic-associated-types/bugs/issue-88382.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-88382.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     do_something(SomeImplementation(), test);
    |                                        ^^^^ cannot infer type of the type parameter `I` declared on the function `test`
    |
-   = note: cannot satisfy `_: Iterable`
+   = note: the type must implement `Iterable`
 help: the trait `Iterable` is implemented for `SomeImplementation`
   --> $DIR/issue-88382.rs:13:1
    |
diff --git a/tests/ui/impl-trait/in-trait/not-inferred-generic.stderr b/tests/ui/impl-trait/in-trait/not-inferred-generic.stderr
index c08fc511500c..14baf9459857 100644
--- a/tests/ui/impl-trait/in-trait/not-inferred-generic.stderr
+++ b/tests/ui/impl-trait/in-trait/not-inferred-generic.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     ().publish_typed();
    |        ^^^^^^^^^^^^^ cannot infer type of the type parameter `F` declared on the method `publish_typed`
    |
-   = note: cannot satisfy `_: Clone`
+   = note: the type must implement `Clone`
    = note: opaque types cannot be accessed directly on a `trait`, they can only be accessed through a specific `impl`
 note: required by a bound in `TypedClient::publish_typed::{anon_assoc#0}`
   --> $DIR/not-inferred-generic.rs:4:12
diff --git a/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr b/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
index 6866f3f5350b..8abced84ab86 100644
--- a/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
+++ b/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
@@ -7,7 +7,7 @@ LL |
 LL |     loop {}
    |     ------- return type was inferred to be `!` here
    |
-   = note: cannot satisfy `_: Future`
+   = note: the type must implement `Future`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/where-allowed-2.stderr b/tests/ui/impl-trait/where-allowed-2.stderr
index 83364e6e7724..d731e5ce9e57 100644
--- a/tests/ui/impl-trait/where-allowed-2.stderr
+++ b/tests/ui/impl-trait/where-allowed-2.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL | fn in_adt_in_return() -> Vec<impl Debug> { panic!() }
    |                              ^^^^^^^^^^ cannot infer type
    |
-   = note: cannot satisfy `_: Debug`
+   = note: the type must implement `Debug`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index 2d97215de3bb..2d925165d583 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -374,7 +374,7 @@ error[E0283]: type annotations needed
 LL | fn in_dyn_Fn_return_in_return() -> &'static dyn Fn() -> impl Debug { panic!() }
    |                                                         ^^^^^^^^^^ cannot infer type
    |
-   = note: cannot satisfy `_: Debug`
+   = note: the type must implement `Debug`
 
 error[E0283]: type annotations needed
   --> $DIR/where-allowed.rs:65:46
diff --git a/tests/ui/imports/import-trait-method.stderr b/tests/ui/imports/import-trait-method.stderr
index 8fe774111b96..1cb2d734a925 100644
--- a/tests/ui/imports/import-trait-method.stderr
+++ b/tests/ui/imports/import-trait-method.stderr
@@ -14,7 +14,7 @@ error[E0283]: type annotations needed
 LL | fn main() { foo(); }
    |             ^^^^^ cannot infer type
    |
-   = note: cannot satisfy `_: Foo`
+   = note: the type must implement `Foo`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/inference/erase-type-params-in-label.stderr b/tests/ui/inference/erase-type-params-in-label.stderr
index 1ec8a33eb820..5056d6358686 100644
--- a/tests/ui/inference/erase-type-params-in-label.stderr
+++ b/tests/ui/inference/erase-type-params-in-label.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed for `Foo<i32, &str, _, _>`
 LL |     let foo = foo(1, "");
    |         ^^^   ---------- type must be known at this point
    |
-   = note: cannot satisfy `_: Default`
+   = note: the type must implement `Default`
 note: required by a bound in `foo`
   --> $DIR/erase-type-params-in-label.rs:25:17
    |
@@ -21,7 +21,7 @@ error[E0283]: type annotations needed for `Bar<i32, &str, _>`
 LL |     let bar = bar(1, "");
    |         ^^^   ---------- type must be known at this point
    |
-   = note: cannot satisfy `_: Default`
+   = note: the type must implement `Default`
 note: required by a bound in `bar`
   --> $DIR/erase-type-params-in-label.rs:14:17
    |
diff --git a/tests/ui/inference/issue-86162-1.stderr b/tests/ui/inference/issue-86162-1.stderr
index fe3cee771609..d36ea12f6f04 100644
--- a/tests/ui/inference/issue-86162-1.stderr
+++ b/tests/ui/inference/issue-86162-1.stderr
@@ -6,7 +6,7 @@ LL |     foo(gen()); //<- Do not suggest `foo::<impl Clone>()`!
    |     |
    |     required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: Clone`
+   = note: the type must implement `Clone`
 note: required by a bound in `foo`
   --> $DIR/issue-86162-1.rs:3:16
    |
diff --git a/tests/ui/inference/issue-86162-2.stderr b/tests/ui/inference/issue-86162-2.stderr
index 7b45b196629e..adbc585d4692 100644
--- a/tests/ui/inference/issue-86162-2.stderr
+++ b/tests/ui/inference/issue-86162-2.stderr
@@ -6,7 +6,7 @@ LL |     Foo::bar(gen()); //<- Do not suggest `Foo::bar::<impl Clone>()`!
    |     |
    |     required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: Clone`
+   = note: the type must implement `Clone`
 note: required by a bound in `Foo::bar`
   --> $DIR/issue-86162-2.rs:8:20
    |
diff --git a/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr b/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
index 455304524edc..bf67c10098d5 100644
--- a/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
+++ b/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
@@ -6,7 +6,7 @@ LL |     (S {}).owo(None)
    |            |
    |            required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: T`
+   = note: the type must implement `T`
 note: required by a bound in `S::owo`
   --> $DIR/issue-113264-incorrect-impl-trait-in-path-suggestion.rs:6:35
    |
diff --git a/tests/ui/inference/question-mark-type-infer.stderr b/tests/ui/inference/question-mark-type-infer.stderr
index 9e1232cb4a6f..b531d42ff93c 100644
--- a/tests/ui/inference/question-mark-type-infer.stderr
+++ b/tests/ui/inference/question-mark-type-infer.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     l.iter().map(f).collect()?
    |                     ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
    |
-   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
+   = note: the type must implement `FromIterator<Result<i32, ()>>`
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 help: consider specifying the generic argument
@@ -18,7 +18,7 @@ error[E0283]: type annotations needed
 LL |     let x = l.iter().map(f).collect()?;
    |                             ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
    |
-   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
+   = note: the type must implement `FromIterator<Result<i32, ()>>`
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 help: consider specifying the generic argument
@@ -32,7 +32,7 @@ error[E0283]: type annotations needed
 LL |     let x: Vec<i32> = l.iter().map(f).collect()?;
    |                                       ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
    |
-   = note: cannot satisfy `_: FromIterator<Result<i32, ()>>`
+   = note: the type must implement `FromIterator<Result<i32, ()>>`
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 help: consider specifying the generic argument
diff --git a/tests/ui/inference/question-mark-type-inference-in-chain.rs b/tests/ui/inference/question-mark-type-inference-in-chain.rs
index 47c41e52b9ac..f3e36b7c4016 100644
--- a/tests/ui/inference/question-mark-type-inference-in-chain.rs
+++ b/tests/ui/inference/question-mark-type-inference-in-chain.rs
@@ -41,7 +41,7 @@ pub fn error2(lines: &[&str]) -> Result<Vec<Version>> {
     let mut tags: Vec<Version> = lines.iter().map(|e| parse(e)).collect()?;
     //~^ ERROR: type annotations needed
     //~| NOTE: cannot infer type of the type parameter `B`
-    //~| NOTE: cannot satisfy `_: FromIterator<std::result::Result<Version, Error>>`
+    //~| NOTE: the type must implement `FromIterator<std::result::Result<Version, Error>>`
     //~| NOTE: required by a bound in `collect`
     //~| HELP: consider specifying the generic argument
     tags.sort();
diff --git a/tests/ui/inference/question-mark-type-inference-in-chain.stderr b/tests/ui/inference/question-mark-type-inference-in-chain.stderr
index 0c11cdccd174..af8a5c8aebad 100644
--- a/tests/ui/inference/question-mark-type-inference-in-chain.stderr
+++ b/tests/ui/inference/question-mark-type-inference-in-chain.stderr
@@ -18,7 +18,7 @@ error[E0283]: type annotations needed
 LL |     let mut tags: Vec<Version> = lines.iter().map(|e| parse(e)).collect()?;
    |                                                                 ^^^^^^^ cannot infer type of the type parameter `B` declared on the method `collect`
    |
-   = note: cannot satisfy `_: FromIterator<std::result::Result<Version, Error>>`
+   = note: the type must implement `FromIterator<std::result::Result<Version, Error>>`
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 help: consider specifying the generic argument
diff --git a/tests/ui/suggestions/types/into-inference-needs-type.stderr b/tests/ui/suggestions/types/into-inference-needs-type.stderr
index dd688f902898..5fbc28107204 100644
--- a/tests/ui/suggestions/types/into-inference-needs-type.stderr
+++ b/tests/ui/suggestions/types/into-inference-needs-type.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |         .into()?;
    |          ^^^^
    |
-   = note: cannot satisfy `_: From<FilterMap<Map<std::slice::Iter<'_, &str>, {closure@$DIR/into-inference-needs-type.rs:10:14: 10:17}>, fn(Option<&str>) -> Option<Option<&str>> {Option::<Option<&str>>::Some}>>`
+   = note: the type must implement `From<FilterMap<Map<std::slice::Iter<'_, &str>, {closure@$DIR/into-inference-needs-type.rs:10:14: 10:17}>, fn(Option<&str>) -> Option<Option<&str>> {Option::<Option<&str>>::Some}>>`
    = note: required for `FilterMap<Map<std::slice::Iter<'_, &str>, {closure@$DIR/into-inference-needs-type.rs:10:14: 10:17}>, fn(Option<&str>) -> Option<Option<&str>> {Option::<Option<&str>>::Some}>` to implement `Into<_>`
 help: try using a fully qualified path to specify the expected types
    |
diff --git a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
index f0c993125279..870a865f02dd 100644
--- a/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
+++ b/tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr
@@ -6,7 +6,7 @@ LL |     qux(Bar.into());
    |     |
    |     required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: From<Bar>`
+   = note: the type must implement `From<Bar>`
 note: required by a bound in `qux`
   --> $DIR/argument-with-unnecessary-method-call.rs:6:16
    |
diff --git a/tests/ui/traits/next-solver/assembly/runaway-impl-candidate-selection.stderr b/tests/ui/traits/next-solver/assembly/runaway-impl-candidate-selection.stderr
index 4bd55ee80c6b..ac427c8f0cba 100644
--- a/tests/ui/traits/next-solver/assembly/runaway-impl-candidate-selection.stderr
+++ b/tests/ui/traits/next-solver/assembly/runaway-impl-candidate-selection.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     println!("{:?}", iter::<_>());
    |                      ^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `iter`
    |
-   = note: cannot satisfy `_: Iterator`
+   = note: the type must implement `Iterator`
 note: required by a bound in `iter`
   --> $DIR/runaway-impl-candidate-selection.rs:8:12
    |
diff --git a/tests/ui/traits/overflow-computing-ambiguity.stderr b/tests/ui/traits/overflow-computing-ambiguity.stderr
index ab59f14cb6d0..f52f2e60757c 100644
--- a/tests/ui/traits/overflow-computing-ambiguity.stderr
+++ b/tests/ui/traits/overflow-computing-ambiguity.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     hello();
    |     ^^^^^ cannot infer type of the type parameter `T` declared on the function `hello`
    |
-   = note: cannot satisfy `_: Hello`
+   = note: the type must implement `Hello`
 help: the following types implement trait `Hello`
   --> $DIR/overflow-computing-ambiguity.rs:8:1
    |
diff --git a/tests/ui/type-inference/panic-with-unspecified-type.stderr b/tests/ui/type-inference/panic-with-unspecified-type.stderr
index cd8485f392bc..99c6e83ef322 100644
--- a/tests/ui/type-inference/panic-with-unspecified-type.stderr
+++ b/tests/ui/type-inference/panic-with-unspecified-type.stderr
@@ -7,7 +7,7 @@ LL |     panic!(std::default::Default::default());
    |     |      cannot infer type
    |     required by a bound introduced by this call
    |
-   = note: cannot satisfy `_: Any`
+   = note: the type must implement `Any`
 note: required by a bound in `std::rt::begin_panic`
   --> $SRC_DIR/std/src/panicking.rs:LL:COL
 
diff --git a/tests/ui/type-inference/sort_by_key.stderr b/tests/ui/type-inference/sort_by_key.stderr
index 3d2e0250dd21..74d89b2459f9 100644
--- a/tests/ui/type-inference/sort_by_key.stderr
+++ b/tests/ui/type-inference/sort_by_key.stderr
@@ -6,7 +6,7 @@ LL |     lst.sort_by_key(|&(v, _)| v.iter().sum());
    |         |
    |         type must be known at this point
    |
-   = note: cannot satisfy `_: Ord`
+   = note: the type must implement `Ord`
 note: required by a bound in `slice::<impl [T]>::sort_by_key`
   --> $SRC_DIR/alloc/src/slice.rs:LL:COL
 help: consider specifying the generic argument
diff --git a/tests/ui/type/type-annotation-needed.rs b/tests/ui/type/type-annotation-needed.rs
index 347887f4bcfd..a063ad77742a 100644
--- a/tests/ui/type/type-annotation-needed.rs
+++ b/tests/ui/type/type-annotation-needed.rs
@@ -6,5 +6,5 @@ fn main() {
     foo(42);
     //~^ ERROR type annotations needed
     //~| NOTE cannot infer type
-    //~| NOTE cannot satisfy
+    //~| NOTE the type must implement
 }
diff --git a/tests/ui/type/type-annotation-needed.stderr b/tests/ui/type/type-annotation-needed.stderr
index 521d25537f3b..78726643a3ab 100644
--- a/tests/ui/type/type-annotation-needed.stderr
+++ b/tests/ui/type/type-annotation-needed.stderr
@@ -4,7 +4,7 @@ error[E0283]: type annotations needed
 LL |     foo(42);
    |     ^^^ cannot infer type of the type parameter `T` declared on the function `foo`
    |
-   = note: cannot satisfy `_: Into<String>`
+   = note: the type must implement `Into<String>`
 note: required by a bound in `foo`
   --> $DIR/type-annotation-needed.rs:1:11
    |

From 60207debab17c11d6bd74f170230f2521f52b1bc Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@ferrous-systems.com>
Date: Thu, 12 Mar 2026 22:10:01 +0100
Subject: [PATCH 0541/1059] small clean-up

- extract unrelated `if` out of `matches!`
- in `include_references`:
  - add docs
  - use a while-let chain
  - add a more complex test
---
 .../crates/ide-completion/src/completions/postfix.rs   | 10 ++++++----
 .../crates/ide-completion/src/context/analysis.rs      |  8 ++++----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
index ea53aef40c2e..5ff0cdc7952b 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
@@ -402,6 +402,10 @@ fn receiver_accessor(receiver: &ast::Expr) -> ast::Expr {
         .unwrap_or_else(|| receiver.clone())
 }
 
+/// Given an `initial_element`, tries to expand it to include deref(s), and then references.
+/// Returns the expanded expressions, and the added prefix as a string
+///
+/// For example, if called with the `42` in `&&mut *42`, would return `(&&mut *42, "&&mut *")`.
 fn include_references(initial_element: &ast::Expr) -> (ast::Expr, String) {
     let mut resulting_element = initial_element.clone();
     let mut prefix = String::new();
@@ -410,11 +414,8 @@ fn include_references(initial_element: &ast::Expr) -> (ast::Expr, String) {
 
     while let Some(parent_deref_element) =
         resulting_element.syntax().parent().and_then(ast::PrefixExpr::cast)
+        && parent_deref_element.op_kind() == Some(ast::UnaryOp::Deref)
     {
-        if parent_deref_element.op_kind() != Some(ast::UnaryOp::Deref) {
-            break;
-        }
-
         found_ref_or_deref = true;
         resulting_element = ast::Expr::from(parent_deref_element);
 
@@ -1040,6 +1041,7 @@ fn main() {
     #[test]
     fn postfix_completion_for_references() {
         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
+        check_edit("dbg", r#"fn main() { &&*"hello".$0 }"#, r#"fn main() { dbg!(&&*"hello") }"#);
         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
         check_edit(
             "ifl",
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 4b0cc0c7cd98..4ab2850ece6f 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -944,10 +944,10 @@ fn classify_name_ref<'db>(
     let field_expr_handle = |receiver, node| {
         let receiver = find_opt_node_in_file(original_file, receiver);
         let receiver_is_ambiguous_float_literal = match &receiver {
-            Some(ast::Expr::Literal(l)) => matches! {
-                l.kind(),
-                ast::LiteralKind::FloatNumber { .. } if l.syntax().last_token().is_some_and(|it| it.text().ends_with('.'))
-            },
+            Some(ast::Expr::Literal(l)) => {
+                matches!(l.kind(), ast::LiteralKind::FloatNumber { .. })
+                    && l.syntax().last_token().is_some_and(|it| it.text().ends_with('.'))
+            }
             _ => false,
         };
 

From abb5228ec14d9e4571d8c1529e611e0e5c87aea4 Mon Sep 17 00:00:00 2001
From: N1ark <opale.sjostedt@gmail.com>
Date: Sun, 15 Mar 2026 22:41:07 +0000
Subject: [PATCH 0542/1059] Merge `fabsfN` into `fabs::<F>`

Add `bounds::FloatPrimitive`

Exhaustive float pattern match

Fix GCC

use span bugs
---
 .../src/intrinsics/mod.rs                     |  33 ++++--
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    | 105 ++++++++++--------
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  19 +++-
 .../src/interpret/intrinsics.rs               |  51 ++++++---
 .../rustc_hir_analysis/src/check/intrinsic.rs |  10 +-
 compiler/rustc_span/src/symbol.rs             |   5 +-
 library/core/src/intrinsics/bounds.rs         |  11 ++
 library/core/src/intrinsics/mod.rs            |  56 +++-------
 library/core/src/num/f128.rs                  |   2 +-
 library/core/src/num/f16.rs                   |   2 +-
 library/core/src/num/f32.rs                   |   2 +-
 library/core/src/num/f64.rs                   |   2 +-
 .../bad-intrinsic-monomorphization-bounds.rs  |  18 +++
 ...d-intrinsic-monomorphization-bounds.stderr |  30 +++++
 .../bad-intrinsic-monomorphization.rs         |   5 -
 .../bad-intrinsic-monomorphization.stderr     |  10 +-
 tests/ui/resolve/filter-intrinsics.rs         |   4 +-
 tests/ui/resolve/filter-intrinsics.stderr     |   8 +-
 18 files changed, 220 insertions(+), 153 deletions(-)
 create mode 100644 tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.rs
 create mode 100644 tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.stderr

diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index 8b112e695275..780550fc4cc7 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -346,10 +346,6 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::log10f32 => ("log10f", 1, fx.tcx.types.f32, types::F32),
         sym::log10f64 => ("log10", 1, fx.tcx.types.f64, types::F64),
         sym::log10f128 => ("log10f128", 1, fx.tcx.types.f128, types::F128),
-        sym::fabsf16 => ("fabsf16", 1, fx.tcx.types.f16, types::F16),
-        sym::fabsf32 => ("fabsf", 1, fx.tcx.types.f32, types::F32),
-        sym::fabsf64 => ("fabs", 1, fx.tcx.types.f64, types::F64),
-        sym::fabsf128 => ("fabsf128", 1, fx.tcx.types.f128, types::F128),
         sym::fmaf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16),
         sym::fmaf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32),
         sym::fmaf64 => ("fma", 3, fx.tcx.types.f64, types::F64),
@@ -441,11 +437,7 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::copysignf32 | sym::copysignf64 => {
             CValue::by_val(fx.bcx.ins().fcopysign(args[0], args[1]), layout)
         }
-        sym::fabsf16 => CValue::by_val(codegen_f16_f128::abs_f16(fx, args[0]), layout),
-        sym::fabsf128 => CValue::by_val(codegen_f16_f128::abs_f128(fx, args[0]), layout),
-        sym::fabsf32
-        | sym::fabsf64
-        | sym::floorf32
+        sym::floorf32
         | sym::floorf64
         | sym::ceilf32
         | sym::ceilf64
@@ -456,7 +448,6 @@ fn codegen_float_intrinsic_call<'tcx>(
         | sym::sqrtf32
         | sym::sqrtf64 => {
             let val = match intrinsic {
-                sym::fabsf32 | sym::fabsf64 => fx.bcx.ins().fabs(args[0]),
                 sym::floorf32 | sym::floorf64 => fx.bcx.ins().floor(args[0]),
                 sym::ceilf32 | sym::ceilf64 => fx.bcx.ins().ceil(args[0]),
                 sym::truncf32 | sym::truncf64 => fx.bcx.ins().trunc(args[0]),
@@ -1179,6 +1170,28 @@ fn codegen_regular_intrinsic_call<'tcx>(
             ret.write_cvalue(fx, old);
         }
 
+        sym::fabs => {
+            intrinsic_args!(fx, args => (arg); intrinsic);
+            let layout = arg.layout();
+            let ty::Float(float_ty) = layout.ty.kind() else {
+                span_bug!(
+                    source_info.span,
+                    "expected float type for fabs intrinsic: {:?}",
+                    layout.ty
+                );
+            };
+            let x = arg.load_scalar(fx);
+            let val = match float_ty {
+                FloatTy::F32 | FloatTy::F64 => fx.bcx.ins().fabs(x),
+                // FIXME(bytecodealliance/wasmtime#8312): Use `fabsf16` once Cranelift
+                // backend lowerings are implemented.
+                FloatTy::F16 => codegen_f16_f128::abs_f16(fx, x),
+                FloatTy::F128 => codegen_f16_f128::abs_f128(fx, x),
+            };
+            let val = CValue::by_val(val, layout);
+            ret.write_cvalue(fx, val);
+        }
+
         sym::minimumf16 => {
             intrinsic_args!(fx, args => (a, b); intrinsic);
             let a = a.load_scalar(fx);
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 3f1b33c73e63..83ac627d27c5 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -23,11 +23,11 @@
     IntrinsicCallBuilderMethods, LayoutTypeCodegenMethods,
 };
 use rustc_data_structures::fx::FxHashSet;
-use rustc_middle::bug;
 #[cfg(feature = "master")]
 use rustc_middle::ty::layout::FnAbiOf;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Instance, Ty};
+use rustc_middle::{bug, span_bug};
 use rustc_span::{Span, Symbol, sym};
 use rustc_target::callconv::{ArgAbi, PassMode};
 
@@ -70,8 +70,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         // FIXME: calling `fma` from libc without FMA target feature uses expensive software emulation
         sym::fmuladdf32 => "fmaf", // FIXME: use gcc intrinsic analogous to llvm.fmuladd.f32
         sym::fmuladdf64 => "fma",  // FIXME: use gcc intrinsic analogous to llvm.fmuladd.f64
-        sym::fabsf32 => "fabsf",
-        sym::fabsf64 => "fabs",
         sym::minimumf32 => "fminimumf",
         sym::minimumf64 => "fminimum",
         sym::minimumf128 => {
@@ -194,58 +192,29 @@ fn get_simple_function<'gcc, 'tcx>(
 }
 
 fn get_simple_function_f128<'gcc, 'tcx>(
+    span: Span,
     cx: &CodegenCx<'gcc, 'tcx>,
     name: Symbol,
-) -> Option<Function<'gcc>> {
-    if !cx.supports_f128_type {
-        return None;
-    }
-
+) -> Function<'gcc> {
     let f128_type = cx.type_f128();
     let func_name = match name {
         sym::ceilf128 => "ceilf128",
-        sym::fabsf128 => "fabsf128",
+        sym::fabs => "fabsf128",
         sym::floorf128 => "floorf128",
         sym::truncf128 => "truncf128",
         sym::roundf128 => "roundf128",
         sym::round_ties_even_f128 => "roundevenf128",
         sym::sqrtf128 => "sqrtf128",
-        _ => return None,
+        _ => span_bug!(span, "used get_simple_function_f128 for non-unary f128 intrinsic"),
     };
-    Some(cx.context.new_function(
+    cx.context.new_function(
         None,
         FunctionType::Extern,
         f128_type,
         &[cx.context.new_parameter(None, f128_type, "a")],
         func_name,
         false,
-    ))
-}
-
-fn get_simple_function_f128_2args<'gcc, 'tcx>(
-    cx: &CodegenCx<'gcc, 'tcx>,
-    name: Symbol,
-) -> Option<Function<'gcc>> {
-    if !cx.supports_f128_type {
-        return None;
-    }
-
-    let f128_type = cx.type_f128();
-    let func_name = match name {
-        sym::copysignf128 => "copysignf128",
-        _ => return None,
-    };
-    Some(cx.context.new_function(
-        None,
-        FunctionType::Extern,
-        f128_type,
-        &[
-            cx.context.new_parameter(None, f128_type, "a"),
-            cx.context.new_parameter(None, f128_type, "b"),
-        ],
-        func_name,
-        false,
-    ))
+    )
 }
 
 fn f16_builtin<'gcc, 'tcx>(
@@ -257,7 +226,7 @@ fn f16_builtin<'gcc, 'tcx>(
     let builtin_name = match name {
         sym::ceilf16 => "__builtin_ceilf",
         sym::copysignf16 => "__builtin_copysignf",
-        sym::fabsf16 => "fabsf",
+        sym::fabs => "fabsf",
         sym::floorf16 => "__builtin_floorf",
         sym::fmaf16 => "fmaf",
         sym::powf16 => "__builtin_powf",
@@ -297,11 +266,7 @@ fn codegen_intrinsic_call(
         let fn_args = instance.args;
 
         let simple = get_simple_intrinsic(self, name);
-        // FIXME(antoyo): Only call get_simple_function_f128 and get_simple_function_f128_2args when
-        // it is the symbols for the supported f128 builtins.
-        let simple_func = get_simple_function(self, name)
-            .or_else(|| get_simple_function_f128(self, name))
-            .or_else(|| get_simple_function_f128_2args(self, name));
+        let simple_func = get_simple_function(self, name);
 
         let value = match name {
             _ if simple.is_some() => {
@@ -322,7 +287,6 @@ fn codegen_intrinsic_call(
             }
             sym::ceilf16
             | sym::copysignf16
-            | sym::fabsf16
             | sym::floorf16
             | sym::fmaf16
             | sym::powf16
@@ -331,6 +295,40 @@ fn codegen_intrinsic_call(
             | sym::round_ties_even_f16
             | sym::sqrtf16
             | sym::truncf16 => f16_builtin(self, name, args),
+            sym::ceilf128
+            | sym::floorf128
+            | sym::truncf128
+            | sym::roundf128
+            | sym::round_ties_even_f128
+            | sym::sqrtf128
+                if self.cx.supports_f128_type =>
+            {
+                let func = get_simple_function_f128(span, self, name);
+                self.cx.context.new_call(
+                    self.location,
+                    func,
+                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
+                )
+            }
+            sym::copysignf128 if self.cx.supports_f128_type => {
+                let f128_type = self.cx.type_f128();
+                let func = self.cx.context.new_function(
+                    None,
+                    FunctionType::Extern,
+                    f128_type,
+                    &[
+                        self.cx.context.new_parameter(None, f128_type, "a"),
+                        self.cx.context.new_parameter(None, f128_type, "b"),
+                    ],
+                    "copysignf128",
+                    false,
+                );
+                self.cx.context.new_call(
+                    self.location,
+                    func,
+                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
+                )
+            }
             sym::fmaf128 => {
                 let f128_type = self.cx.type_f128();
                 let func = self.cx.context.new_function(
@@ -488,6 +486,23 @@ fn codegen_intrinsic_call(
                     }
                 }
             }
+            sym::fabs => 'fabs: {
+                let ty = args[0].layout.ty;
+                let ty::Float(float_ty) = *ty.kind() else {
+                    span_bug!(span, "expected float type for fabs intrinsic: {:?}", ty);
+                };
+                let func = match float_ty {
+                    ty::FloatTy::F16 => break 'fabs f16_builtin(self, name, args),
+                    ty::FloatTy::F32 => self.context.get_builtin_function("fabsf"),
+                    ty::FloatTy::F64 => self.context.get_builtin_function("fabs"),
+                    ty::FloatTy::F128 => get_simple_function_f128(span, self, name),
+                };
+                self.cx.context.new_call(
+                    self.location,
+                    func,
+                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
+                )
+            }
 
             sym::raw_eq => {
                 use rustc_abi::BackendRepr::*;
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index cc6ecee60b0e..a93088594fb2 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -107,11 +107,6 @@ fn call_simple_intrinsic<'ll, 'tcx>(
         sym::fmuladdf64 => ("llvm.fmuladd", &[bx.type_f64()]),
         sym::fmuladdf128 => ("llvm.fmuladd", &[bx.type_f128()]),
 
-        sym::fabsf16 => ("llvm.fabs", &[bx.type_f16()]),
-        sym::fabsf32 => ("llvm.fabs", &[bx.type_f32()]),
-        sym::fabsf64 => ("llvm.fabs", &[bx.type_f64()]),
-        sym::fabsf128 => ("llvm.fabs", &[bx.type_f128()]),
-
         // FIXME: LLVM currently mis-compile those intrinsics, re-enable them
         // when llvm/llvm-project#{139380,139381,140445} are fixed.
         //sym::minimumf16 => ("llvm.minimum", &[bx.type_f16()]),
@@ -502,6 +497,20 @@ fn codegen_intrinsic_call(
                 }
             }
 
+            sym::fabs => {
+                let ty = args[0].layout.ty;
+                let ty::Float(f) = ty.kind() else {
+                    span_bug!(span, "the `fabs` intrinsic requires a floating-point argument, got {:?}", ty);
+                };
+                let llty = self.type_float_from_ty(*f);
+                let llvm_name = "llvm.fabs";
+                self.call_intrinsic(
+                    llvm_name,
+                    &[llty],
+                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
+                )
+            }
+
             sym::raw_eq => {
                 use BackendRepr::*;
                 let tp_ty = fn_args.type_at(0);
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index d5f69d78ea6a..17311188879c 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -575,10 +575,23 @@ pub fn eval_intrinsic(
             sym::copysignf64 => self.float_copysign_intrinsic::<Double>(args, dest)?,
             sym::copysignf128 => self.float_copysign_intrinsic::<Quad>(args, dest)?,
 
-            sym::fabsf16 => self.float_abs_intrinsic::<Half>(args, dest)?,
-            sym::fabsf32 => self.float_abs_intrinsic::<Single>(args, dest)?,
-            sym::fabsf64 => self.float_abs_intrinsic::<Double>(args, dest)?,
-            sym::fabsf128 => self.float_abs_intrinsic::<Quad>(args, dest)?,
+            sym::fabs => {
+                let arg = self.read_immediate(&args[0])?;
+                let ty::Float(float_ty) = arg.layout.ty.kind() else {
+                    span_bug!(
+                        self.cur_span(),
+                        "non-float type for float intrinsic: {}",
+                        arg.layout.ty,
+                    );
+                };
+                let out_val = match float_ty {
+                    FloatTy::F16 => self.unop_float_intrinsic::<Half>(intrinsic_name, arg)?,
+                    FloatTy::F32 => self.unop_float_intrinsic::<Single>(intrinsic_name, arg)?,
+                    FloatTy::F64 => self.unop_float_intrinsic::<Double>(intrinsic_name, arg)?,
+                    FloatTy::F128 => self.unop_float_intrinsic::<Quad>(intrinsic_name, arg)?,
+                };
+                self.write_scalar(out_val, dest)?;
+            }
 
             sym::floorf16 => self.float_round_intrinsic::<Half>(
                 args,
@@ -1020,6 +1033,22 @@ pub(crate) fn raw_eq_intrinsic(
         interp_ok(Scalar::from_bool(lhs_bytes == rhs_bytes))
     }
 
+    fn unop_float_intrinsic<F>(
+        &self,
+        name: Symbol,
+        arg: ImmTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, Scalar<M::Provenance>>
+    where
+        F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
+    {
+        let x: F = arg.to_scalar().to_float()?;
+        match name {
+            // bitwise, no NaN adjustments
+            sym::fabs => interp_ok(x.abs().into()),
+            _ => bug!("not a unary float intrinsic: {}", name),
+        }
+    }
+
     fn float_minmax<F>(
         &self,
         a: Scalar<M::Provenance>,
@@ -1078,20 +1107,6 @@ fn float_copysign_intrinsic<F>(
         interp_ok(())
     }
 
-    fn float_abs_intrinsic<F>(
-        &mut self,
-        args: &[OpTy<'tcx, M::Provenance>],
-        dest: &PlaceTy<'tcx, M::Provenance>,
-    ) -> InterpResult<'tcx, ()>
-    where
-        F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
-    {
-        let x: F = self.read_scalar(&args[0])?.to_float()?;
-        // bitwise, no NaN adjustments
-        self.write_scalar(x.abs(), dest)?;
-        interp_ok(())
-    }
-
     fn float_round<F>(
         &mut self,
         x: Scalar<M::Provenance>,
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 47420997a509..e7cb6d2ba164 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -111,10 +111,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::expf32
         | sym::expf64
         | sym::expf128
-        | sym::fabsf16
-        | sym::fabsf32
-        | sym::fabsf64
-        | sym::fabsf128
+        | sym::fabs
         | sym::fadd_algebraic
         | sym::fdiv_algebraic
         | sym::field_offset
@@ -463,10 +460,7 @@ pub(crate) fn check_intrinsic_type(
             (0, 0, vec![tcx.types.f128, tcx.types.f128, tcx.types.f128], tcx.types.f128)
         }
 
-        sym::fabsf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
-        sym::fabsf32 => (0, 0, vec![tcx.types.f32], tcx.types.f32),
-        sym::fabsf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),
-        sym::fabsf128 => (0, 0, vec![tcx.types.f128], tcx.types.f128),
+        sym::fabs => (1, 0, vec![param(0)], param(0)),
 
         sym::minimum_number_nsz_f16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
         sym::minimum_number_nsz_f32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 26ced79b822a..eb95d3a0d905 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -914,10 +914,7 @@
         f64_nan,
         f128,
         f128_nan,
-        fabsf16,
-        fabsf32,
-        fabsf64,
-        fabsf128,
+        fabs,
         fadd_algebraic,
         fadd_fast,
         fake_variadic,
diff --git a/library/core/src/intrinsics/bounds.rs b/library/core/src/intrinsics/bounds.rs
index 353908598d40..21705005ed0a 100644
--- a/library/core/src/intrinsics/bounds.rs
+++ b/library/core/src/intrinsics/bounds.rs
@@ -39,3 +39,14 @@ impl<T: PointeeSized, U: PointeeSized> ChangePointee<U> for *mut T {
 impl<T: PointeeSized, U: PointeeSized> ChangePointee<U> for *const T {
     type Output = *const U;
 }
+
+/// Built-in float types (f16, f32, f64 and f128).
+///
+/// # Safety
+/// Must actually *be* such a type.
+pub unsafe trait FloatPrimitive: Sized + Copy {}
+
+unsafe impl FloatPrimitive for f16 {}
+unsafe impl FloatPrimitive for f32 {}
+unsafe impl FloatPrimitive for f64 {}
+unsafe impl FloatPrimitive for f128 {}
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 68e4f1c2aa78..a5c7cf76622d 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -1573,7 +1573,7 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fadd_fast<T: Copy>(a: T, b: T) -> T;
+pub unsafe fn fadd_fast<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float subtraction that allows optimizations based on algebraic rules.
 /// Requires that inputs and output of the operation are finite, causing UB otherwise.
@@ -1581,7 +1581,7 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fsub_fast<T: Copy>(a: T, b: T) -> T;
+pub unsafe fn fsub_fast<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float multiplication that allows optimizations based on algebraic rules.
 /// Requires that inputs and output of the operation are finite, causing UB otherwise.
@@ -1589,7 +1589,7 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmul_fast<T: Copy>(a: T, b: T) -> T;
+pub unsafe fn fmul_fast<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float division that allows optimizations based on algebraic rules.
 /// Requires that inputs and output of the operation are finite, causing UB otherwise.
@@ -1597,7 +1597,7 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fdiv_fast<T: Copy>(a: T, b: T) -> T;
+pub unsafe fn fdiv_fast<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float remainder that allows optimizations based on algebraic rules.
 /// Requires that inputs and output of the operation are finite, causing UB otherwise.
@@ -1605,7 +1605,7 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn frem_fast<T: Copy>(a: T, b: T) -> T;
+pub unsafe fn frem_fast<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range
 /// (<https://github.com/rust-lang/rust/issues/10184>)
@@ -1613,42 +1613,43 @@ pub const fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 /// Stabilized as [`f32::to_int_unchecked`] and [`f64::to_int_unchecked`].
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
+pub unsafe fn float_to_int_unchecked<Float: bounds::FloatPrimitive, Int: Copy>(value: Float)
+-> Int;
 
 /// Float addition that allows optimizations based on algebraic rules.
 ///
 /// Stabilized as [`f16::algebraic_add`], [`f32::algebraic_add`], [`f64::algebraic_add`] and [`f128::algebraic_add`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn fadd_algebraic<T: Copy>(a: T, b: T) -> T;
+pub const fn fadd_algebraic<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float subtraction that allows optimizations based on algebraic rules.
 ///
 /// Stabilized as [`f16::algebraic_sub`], [`f32::algebraic_sub`], [`f64::algebraic_sub`] and [`f128::algebraic_sub`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn fsub_algebraic<T: Copy>(a: T, b: T) -> T;
+pub const fn fsub_algebraic<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float multiplication that allows optimizations based on algebraic rules.
 ///
 /// Stabilized as [`f16::algebraic_mul`], [`f32::algebraic_mul`], [`f64::algebraic_mul`] and [`f128::algebraic_mul`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn fmul_algebraic<T: Copy>(a: T, b: T) -> T;
+pub const fn fmul_algebraic<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float division that allows optimizations based on algebraic rules.
 ///
 /// Stabilized as [`f16::algebraic_div`], [`f32::algebraic_div`], [`f64::algebraic_div`] and [`f128::algebraic_div`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn fdiv_algebraic<T: Copy>(a: T, b: T) -> T;
+pub const fn fdiv_algebraic<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Float remainder that allows optimizations based on algebraic rules.
 ///
 /// Stabilized as [`f16::algebraic_rem`], [`f32::algebraic_rem`], [`f64::algebraic_rem`] and [`f128::algebraic_rem`].
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn frem_algebraic<T: Copy>(a: T, b: T) -> T;
+pub const fn frem_algebraic<T: bounds::FloatPrimitive>(a: T, b: T) -> T;
 
 /// Returns the number of bits set in an integer type `T`
 ///
@@ -3385,39 +3386,14 @@ pub const fn maximumf128(x: f128, y: f128) -> f128 {
     }
 }
 
-/// Returns the absolute value of an `f16`.
+/// Returns the absolute value of a floating-point value.
 ///
-/// The stabilized version of this intrinsic is
-/// [`f16::abs`](../../std/primitive.f16.html#method.abs)
-#[rustc_nounwind]
-#[rustc_intrinsic]
-pub const fn fabsf16(x: f16) -> f16;
-
-/// Returns the absolute value of an `f32`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f32::abs`](../../std/primitive.f32.html#method.abs)
+/// The stabilized versions of this intrinsic are available on the float
+/// primitives via the `abs` method. For example, [`f32::abs`].
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const fn fabsf32(x: f32) -> f32;
-
-/// Returns the absolute value of an `f64`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f64::abs`](../../std/primitive.f64.html#method.abs)
-#[rustc_nounwind]
-#[rustc_intrinsic_const_stable_indirect]
-#[rustc_intrinsic]
-pub const fn fabsf64(x: f64) -> f64;
-
-/// Returns the absolute value of an `f128`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f128::abs`](../../std/primitive.f128.html#method.abs)
-#[rustc_nounwind]
-#[rustc_intrinsic]
-pub const fn fabsf128(x: f128) -> f128;
+pub const fn fabs<T: bounds::FloatPrimitive>(x: T) -> T;
 
 /// Copies the sign from `y` to `x` for `f16` values.
 ///
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 68c87b48de94..d833653fdba6 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1409,7 +1409,7 @@ pub fn clamp_magnitude(self, limit: f128) -> f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn abs(self) -> Self {
-        intrinsics::fabsf128(self)
+        intrinsics::fabs(self)
     }
 
     /// Returns a number that represents the sign of `self`.
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 3412e49c49cd..b0664abcdc73 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1393,7 +1393,7 @@ pub fn clamp_magnitude(self, limit: f16) -> f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn abs(self) -> Self {
-        intrinsics::fabsf16(self)
+        intrinsics::fabs(self)
     }
 
     /// Returns a number that represents the sign of `self`.
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index e33cb098e4e8..b85bd2b27158 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1568,7 +1568,7 @@ pub fn clamp_magnitude(self, limit: f32) -> f32 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn abs(self) -> f32 {
-        intrinsics::fabsf32(self)
+        intrinsics::fabs(self)
     }
 
     /// Returns a number that represents the sign of `self`.
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 872f567efafd..3e7c1e792ace 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1566,7 +1566,7 @@ pub fn clamp_magnitude(self, limit: f64) -> f64 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn abs(self) -> f64 {
-        intrinsics::fabsf64(self)
+        intrinsics::fabs(self)
     }
 
     /// Returns a number that represents the sign of `self`.
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.rs b/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.rs
new file mode 100644
index 000000000000..6a32cd97c50b
--- /dev/null
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.rs
@@ -0,0 +1,18 @@
+//@ check-fail
+
+#![feature(repr_simd, intrinsics, core_intrinsics)]
+#![allow(warnings)]
+#![crate_type = "rlib"]
+
+// Bad monomorphizations could previously cause LLVM asserts even though the
+// error was caught in the compiler.
+
+use std::intrinsics;
+
+#[derive(Copy, Clone)]
+pub struct Foo(i64);
+
+pub unsafe fn test_fadd_fast(a: Foo, b: Foo) -> Foo {
+    intrinsics::fadd_fast(a, b)
+    //~^ ERROR the trait bound `Foo: intrinsics::bounds::FloatPrimitive` is not satisfied
+}
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.stderr b/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.stderr
new file mode 100644
index 000000000000..db2a222c8f2c
--- /dev/null
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization-bounds.stderr
@@ -0,0 +1,30 @@
+error[E0277]: the trait bound `Foo: intrinsics::bounds::FloatPrimitive` is not satisfied
+  --> $DIR/bad-intrinsic-monomorphization-bounds.rs:16:5
+   |
+LL |     intrinsics::fadd_fast(a, b)
+   |     ^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
+   |
+help: the nightly-only, unstable trait `intrinsics::bounds::FloatPrimitive` is not implemented for `Foo`
+  --> $DIR/bad-intrinsic-monomorphization-bounds.rs:13:1
+   |
+LL | pub struct Foo(i64);
+   | ^^^^^^^^^^^^^^
+help: the following other types implement trait `intrinsics::bounds::FloatPrimitive`
+  --> $SRC_DIR/core/src/intrinsics/bounds.rs:LL:COL
+   |
+   = note: `f16`
+  ::: $SRC_DIR/core/src/intrinsics/bounds.rs:LL:COL
+   |
+   = note: `f32`
+  ::: $SRC_DIR/core/src/intrinsics/bounds.rs:LL:COL
+   |
+   = note: `f64`
+  ::: $SRC_DIR/core/src/intrinsics/bounds.rs:LL:COL
+   |
+   = note: `f128`
+note: required by a bound in `fadd_fast`
+  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs b/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
index d68cbf26ef11..8849ed2a67ad 100644
--- a/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
@@ -17,11 +17,6 @@ pub fn test_cttz(v: Foo) -> u32 {
     //~^ ERROR `cttz` intrinsic: expected basic integer type, found `Foo`
 }
 
-pub unsafe fn test_fadd_fast(a: Foo, b: Foo) -> Foo {
-    intrinsics::fadd_fast(a, b)
-    //~^ ERROR `fadd_fast` intrinsic: expected basic float type, found `Foo`
-}
-
 pub unsafe fn test_simd_add(a: Foo, b: Foo) -> Foo {
     intrinsics::simd::simd_add(a, b)
     //~^ ERROR `simd_add` intrinsic: expected SIMD input type, found non-SIMD `Foo`
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr b/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
index 51ef71c9e298..329bf214c03d 100644
--- a/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
@@ -1,21 +1,15 @@
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `Foo`
-  --> $DIR/bad-intrinsic-monomorphization.rs:26:5
+  --> $DIR/bad-intrinsic-monomorphization.rs:21:5
    |
 LL |     intrinsics::simd::simd_add(a, b)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `fadd_fast` intrinsic: expected basic float type, found `Foo`
-  --> $DIR/bad-intrinsic-monomorphization.rs:21:5
-   |
-LL |     intrinsics::fadd_fast(a, b)
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error[E0511]: invalid monomorphization of `cttz` intrinsic: expected basic integer type, found `Foo`
   --> $DIR/bad-intrinsic-monomorphization.rs:16:5
    |
 LL |     intrinsics::cttz(v)
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0511`.
diff --git a/tests/ui/resolve/filter-intrinsics.rs b/tests/ui/resolve/filter-intrinsics.rs
index 8d6d22817dc5..9998bec1ad4f 100644
--- a/tests/ui/resolve/filter-intrinsics.rs
+++ b/tests/ui/resolve/filter-intrinsics.rs
@@ -3,8 +3,8 @@ fn main() {
     let _ = transmute::<usize>();
     //~^ ERROR cannot find
 
-    // Should suggest `std::intrinsics::fabsf64`,
+    // Should suggest `std::intrinsics::fabs`,
     // since there is no non-intrinsic to suggest.
-    let _ = fabsf64(1.0);
+    let _ = fabs(1.0);
     //~^ ERROR cannot find
 }
diff --git a/tests/ui/resolve/filter-intrinsics.stderr b/tests/ui/resolve/filter-intrinsics.stderr
index 9c9e92f6d4f8..3870cfcb1080 100644
--- a/tests/ui/resolve/filter-intrinsics.stderr
+++ b/tests/ui/resolve/filter-intrinsics.stderr
@@ -9,15 +9,15 @@ help: consider importing this function
 LL + use std::mem::transmute;
    |
 
-error[E0425]: cannot find function `fabsf64` in this scope
+error[E0425]: cannot find function `fabs` in this scope
   --> $DIR/filter-intrinsics.rs:8:13
    |
-LL |     let _ = fabsf64(1.0);
-   |             ^^^^^^^ not found in this scope
+LL |     let _ = fabs(1.0);
+   |             ^^^^ not found in this scope
    |
 help: consider importing this function
    |
-LL + use std::intrinsics::fabsf64;
+LL + use std::intrinsics::fabs;
    |
 
 error: aborting due to 2 previous errors

From 11c673b4050d817afb4607f2dd79121440baba9e Mon Sep 17 00:00:00 2001
From: N1ark <opale.sjostedt@gmail.com>
Date: Sat, 14 Mar 2026 12:54:21 +0000
Subject: [PATCH 0543/1059] Remove `InvalidMonomorphization::FloatingPointType`

---
 compiler/rustc_codegen_gcc/src/intrinsic/simd.rs | 2 +-
 compiler/rustc_codegen_llvm/src/intrinsic.rs     | 2 +-
 compiler/rustc_codegen_ssa/src/errors.rs         | 8 --------
 3 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index 1263b2285a8d..1900572eee7d 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -811,7 +811,7 @@ macro_rules! return_error {
             }};
         }
         let ty::Float(ref f) = *in_elem.kind() else {
-            return_error!(InvalidMonomorphization::FloatingPointType { span, name, in_ty });
+            return_error!(InvalidMonomorphization::BasicFloatType { span, name, ty: in_ty });
         };
         let elem_ty = bx.cx.type_float_from_ty(*f);
         let (elem_ty_str, elem_ty, cast_type) = match f.bit_width() {
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index a93088594fb2..e965ef866817 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1945,7 +1945,7 @@ macro_rules! return_error {
         }
 
         let ty::Float(f) = in_elem.kind() else {
-            return_error!(InvalidMonomorphization::FloatingPointType { span, name, in_ty });
+            return_error!(InvalidMonomorphization::BasicFloatType { span, name, ty: in_ty });
         };
         let elem_ty = bx.cx.type_float_from_ty(*f);
 
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 41337fc21a7b..fad776d249e0 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -739,14 +739,6 @@ pub enum InvalidMonomorphization<'tcx> {
         in_ty: Ty<'tcx>,
     },
 
-    #[diag("invalid monomorphization of `{$name}` intrinsic: `{$in_ty}` is not a floating-point type", code = E0511)]
-    FloatingPointType {
-        #[primary_span]
-        span: Span,
-        name: Symbol,
-        in_ty: Ty<'tcx>,
-    },
-
     #[diag("invalid monomorphization of `{$name}` intrinsic: unrecognized intrinsic `{$name}`", code = E0511)]
     UnrecognizedIntrinsic {
         #[primary_span]

From 19e9ec7560a3d1a81bae2daa8dc6c2e2ad382cde Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 14 Mar 2026 20:34:28 +0100
Subject: [PATCH 0544/1059] test `classify-runtime-const` for `f16`

---
 tests/assembly-llvm/asm/aarch64-types.rs |  6 +++---
 tests/ui/float/classify-runtime-const.rs | 15 ++++++++++++++-
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/tests/assembly-llvm/asm/aarch64-types.rs b/tests/assembly-llvm/asm/aarch64-types.rs
index a304bf8688da..fde0aad94695 100644
--- a/tests/assembly-llvm/asm/aarch64-types.rs
+++ b/tests/assembly-llvm/asm/aarch64-types.rs
@@ -98,8 +98,8 @@ pub unsafe fn issue_75761() {
 
 macro_rules! check {
     ($func:ident $ty:ident $class:ident $mov:literal $modifier:literal) => {
-        // FIXME(f16_f128): Change back to `$func(x: $ty) -> $ty` once arm64ec can pass and return
-        // `f16` and `f128` without LLVM erroring.
+        // FIXME(f128): Change back to `$func(x: $ty) -> $ty` once arm64ec can pass and return
+        // `f128` without LLVM erroring.
         // LLVM issue: <https://github.com/llvm/llvm-project/issues/94434>
         #[no_mangle]
         pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
@@ -117,7 +117,7 @@ pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
 
 macro_rules! check_reg {
     ($func:ident $ty:ident $reg:tt $mov:literal) => {
-        // FIXME(f16_f128): See FIXME in `check!`
+        // FIXME(f128): See FIXME in `check!`
         #[no_mangle]
         pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
             let x = *inp;
diff --git a/tests/ui/float/classify-runtime-const.rs b/tests/ui/float/classify-runtime-const.rs
index fb7361f9cbad..5727d5d7b859 100644
--- a/tests/ui/float/classify-runtime-const.rs
+++ b/tests/ui/float/classify-runtime-const.rs
@@ -2,7 +2,11 @@
 //@ revisions: opt noopt ctfe
 //@[opt] compile-flags: -O
 //@[noopt] compile-flags: -Zmir-opt-level=0
+//@ min-llvm-version: 22
+//@ compile-flags: --check-cfg=cfg(target_has_reliable_f16)
 // ignore-tidy-linelength
+#![feature(cfg_target_has_reliable_f16_f128)]
+#![cfg_attr(target_has_reliable_f16, feature(f16))]
 
 // This tests the float classification functions, for regular runtime code and for const evaluation.
 
@@ -50,6 +54,13 @@ macro_rules! assert_test {
 
 macro_rules! suite {
     ( $tyname:ident => $( $tt:tt )* ) => {
+        #[cfg(target_has_reliable_f16)]
+        fn f16() {
+            #[allow(unused)]
+            type $tyname = f16;
+            suite_inner!(f16 => $($tt)*);
+        }
+
         fn f32() {
             #[allow(unused)]
             type $tyname = f32;
@@ -121,7 +132,9 @@ macro_rules! suite_inner {
 }
 
 fn main() {
+    #[cfg(target_has_reliable_f16)]
+    f16();
     f32();
     f64();
-    // FIXME(f16_f128): also test f16 and f128
+    // FIXME(f128): also test f128
 }

From f8bce56b3966c8784060ce875a51f65d18ac659b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 11 Mar 2026 19:39:47 +0100
Subject: [PATCH 0545/1059] Don't look for non-type-level assoc consts when
 checking trait object types

---
 .../src/hir_ty_lowering/dyn_trait.rs          |  5 ++-
 compiler/rustc_middle/src/ty/assoc.rs         |  4 +-
 compiler/rustc_middle/src/ty/sty.rs           |  2 +-
 .../cfi/typeid/itanium_cxx_abi/transform.rs   |  2 +-
 .../associated-const-in-trait.rs              |  2 +
 .../associated-const-in-trait.stderr          | 38 +++++++++++++++++--
 tests/ui/associated-item/issue-48027.stderr   |  4 +-
 .../associated-consts.stderr                  |  4 +-
 tests/ui/type-alias/lack-of-wfcheck.rs        | 27 +++++++++++++
 tests/ui/wf/issue-87495.stderr                |  9 ++++-
 10 files changed, 82 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/type-alias/lack-of-wfcheck.rs

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
index 7b8e09943df7..515cca6ac1c1 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -230,8 +230,9 @@ pub(super) fn lower_trait_object_ty(
                         ordered_associated_items.extend(
                             tcx.associated_items(pred.trait_ref.def_id)
                                 .in_definition_order()
-                                // Only associated types & consts can possibly be constrained via a binding.
-                                .filter(|item| item.is_type() || item.is_const())
+                                // Only associated types & type consts can possibly be
+                                // constrained in a trait object type via a binding.
+                                .filter(|item| item.is_type() || item.is_type_const())
                                 // Traits with RPITITs are simply not dyn compatible (for now).
                                 .filter(|item| !item.is_impl_trait_in_trait())
                                 .map(|item| (item.def_id, trait_ref)),
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 4cc255cba635..cabe8514ae4b 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -137,8 +137,8 @@ pub fn as_def_kind(&self) -> DefKind {
         self.kind.as_def_kind()
     }
 
-    pub fn is_const(&self) -> bool {
-        matches!(self.kind, ty::AssocKind::Const { .. })
+    pub fn is_type_const(&self) -> bool {
+        matches!(self.kind, ty::AssocKind::Const { is_type_const: true, .. })
     }
 
     pub fn is_fn(&self) -> bool {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index b449b8f1a406..780b57c470f3 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -753,7 +753,7 @@ pub fn new_dynamic(
                     .map(|principal| {
                         tcx.associated_items(principal.def_id())
                             .in_definition_order()
-                            .filter(|item| item.is_type() || item.is_const())
+                            .filter(|item| item.is_type() || item.is_type_const())
                             .filter(|item| !item.is_impl_trait_in_trait())
                             .filter(|item| !tcx.generics_require_sized_self(item.def_id))
                             .count()
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index 90b489258360..5691ed146927 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -239,7 +239,7 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
         .flat_map(|super_poly_trait_ref| {
             tcx.associated_items(super_poly_trait_ref.def_id())
                 .in_definition_order()
-                .filter(|item| item.is_type() || item.is_const())
+                .filter(|item| item.is_type() || item.is_type_const())
                 .filter(|item| !tcx.generics_require_sized_self(item.def_id))
                 .map(move |assoc_item| {
                     super_poly_trait_ref.map_bound(|super_trait_ref| {
diff --git a/tests/ui/associated-consts/associated-const-in-trait.rs b/tests/ui/associated-consts/associated-const-in-trait.rs
index 6b0b43feb109..da68a0fa97c8 100644
--- a/tests/ui/associated-consts/associated-const-in-trait.rs
+++ b/tests/ui/associated-consts/associated-const-in-trait.rs
@@ -7,6 +7,8 @@ trait Trait {
 impl dyn Trait {
     //~^ ERROR the trait `Trait` is not dyn compatible [E0038]
     const fn n() -> usize { Self::N }
+    //~^ ERROR the trait `Trait` is not dyn compatible [E0038]
+    //~| ERROR the trait `Trait` is not dyn compatible [E0038]
 }
 
 fn main() {}
diff --git a/tests/ui/associated-consts/associated-const-in-trait.stderr b/tests/ui/associated-consts/associated-const-in-trait.stderr
index fb4a55110b4e..4085f8c99078 100644
--- a/tests/ui/associated-consts/associated-const-in-trait.stderr
+++ b/tests/ui/associated-consts/associated-const-in-trait.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/associated-const-in-trait.rs:7:10
+  --> $DIR/associated-const-in-trait.rs:7:6
    |
 LL | impl dyn Trait {
-   |          ^^^^^ `Trait` is not dyn compatible
+   |      ^^^^^^^^^ `Trait` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
@@ -14,6 +14,38 @@ LL |     const N: usize;
    |           ^ ...because it contains associated const `N`
    = help: consider moving `N` to another trait
 
-error: aborting due to 1 previous error
+error[E0038]: the trait `Trait` is not dyn compatible
+  --> $DIR/associated-const-in-trait.rs:9:29
+   |
+LL |     const fn n() -> usize { Self::N }
+   |                             ^^^^ `Trait` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/associated-const-in-trait.rs:4:11
+   |
+LL | trait Trait {
+   |       ----- this trait is not dyn compatible...
+LL |     const N: usize;
+   |           ^ ...because it contains associated const `N`
+   = help: consider moving `N` to another trait
+
+error[E0038]: the trait `Trait` is not dyn compatible
+  --> $DIR/associated-const-in-trait.rs:9:29
+   |
+LL |     const fn n() -> usize { Self::N }
+   |                             ^^^^^^^ `Trait` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/associated-const-in-trait.rs:4:11
+   |
+LL | trait Trait {
+   |       ----- this trait is not dyn compatible...
+LL |     const N: usize;
+   |           ^ ...because it contains associated const `N`
+   = help: consider moving `N` to another trait
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/associated-item/issue-48027.stderr b/tests/ui/associated-item/issue-48027.stderr
index 7abcabc1c79d..978c377d438a 100644
--- a/tests/ui/associated-item/issue-48027.stderr
+++ b/tests/ui/associated-item/issue-48027.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/issue-48027.rs:6:10
+  --> $DIR/issue-48027.rs:6:6
    |
 LL | impl dyn Bar {}
-   |          ^^^ `Bar` is not dyn compatible
+   |      ^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
diff --git a/tests/ui/dyn-compatibility/associated-consts.stderr b/tests/ui/dyn-compatibility/associated-consts.stderr
index a92557ea7b8b..11d02dd2904c 100644
--- a/tests/ui/dyn-compatibility/associated-consts.stderr
+++ b/tests/ui/dyn-compatibility/associated-consts.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/associated-consts.rs:8:35
+  --> $DIR/associated-consts.rs:8:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
-   |                                   ^^^ `Bar` is not dyn compatible
+   |                               ^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
diff --git a/tests/ui/type-alias/lack-of-wfcheck.rs b/tests/ui/type-alias/lack-of-wfcheck.rs
new file mode 100644
index 000000000000..91fbee8d3f19
--- /dev/null
+++ b/tests/ui/type-alias/lack-of-wfcheck.rs
@@ -0,0 +1,27 @@
+// Demonstrate that we don't check the definition site of (eager) type aliases for well-formedness.
+//
+// Listed below are ill-formed type system entities which we don't reject since they appear inside
+// the definition of (eager) type aliases. These type aliases are intentionally not referenced from
+// anywhere to prevent the eagerly expanded / instantiated aliased types from getting wfchecked
+// since that's not what we're testing here.
+
+//@ check-pass
+
+type UnsatTraitBound0 = [str]; // `str: Sized` unsatisfied
+type UnsatTraitBound1<T = Vec<str>> = T; // `str: Sized` unsatisfied
+type UnsatOutlivesBound<'a> = &'static &'a (); // `'a: 'static` unsatisfied
+
+type Diverging = [(); panic!()]; // `panic!()` diverging
+
+type DynIncompat0 = dyn Sized; // `Sized` axiomatically dyn incompatible
+// issue: <https://github.com/rust-lang/rust/issues/153731>
+type DynIncompat1 = dyn HasAssocConst; // dyn incompatible due to (non-type-level) assoc const
+
+// * dyn incompatible due to GAT
+// * `'a: 'static`, `String: Copy` and `[u8]: Sized` unsatisfied, `loop {}` diverging
+type Several<'a> = dyn HasGenericAssocType<Type<'a, String, { loop {} }> = [u8]>;
+
+trait HasAssocConst { const N: usize; }
+trait HasGenericAssocType { type Type<'a: 'static, T: Copy, const N: usize>; }
+
+fn main() {}
diff --git a/tests/ui/wf/issue-87495.stderr b/tests/ui/wf/issue-87495.stderr
index 49651e8d6c05..42e3e2608d73 100644
--- a/tests/ui/wf/issue-87495.stderr
+++ b/tests/ui/wf/issue-87495.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `T` is not dyn compatible
-  --> $DIR/issue-87495.rs:4:29
+  --> $DIR/issue-87495.rs:4:25
    |
 LL |     const CONST: (bool, dyn T);
-   |                             ^ `T` is not dyn compatible
+   |                         ^^^^^ `T` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
@@ -13,6 +13,11 @@ LL | trait T {
 LL |     const CONST: (bool, dyn T);
    |           ^^^^^ ...because it contains associated const `CONST`
    = help: consider moving `CONST` to another trait
+help: you might have meant to use `Self` to refer to the implementing type
+   |
+LL -     const CONST: (bool, dyn T);
+LL +     const CONST: (bool, Self);
+   |
 
 error: aborting due to 1 previous error
 

From 8a57f3d8441a62ecda9aa3e537b2ca82e8b40e23 Mon Sep 17 00:00:00 2001
From: human9000 <human9000.2021@gmail.com>
Date: Fri, 13 Mar 2026 18:22:43 +0500
Subject: [PATCH 0546/1059] Introduce guard pattern to THIR

Co-authored-by: Max Niederman <max@maxniederman.com>
---
 compiler/rustc_middle/src/thir.rs                      |  7 +++++++
 compiler/rustc_middle/src/thir/visit.rs                | 10 ++++++++++
 .../rustc_mir_build/src/builder/matches/match_pair.rs  |  5 +++++
 compiler/rustc_mir_build/src/builder/matches/mod.rs    |  3 +++
 compiler/rustc_mir_build/src/check_unsafety.rs         |  1 +
 compiler/rustc_mir_build/src/thir/print.rs             |  8 ++++++++
 compiler/rustc_pattern_analysis/src/rustc.rs           |  3 ++-
 7 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 881165706a03..51f33691bb7d 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -866,6 +866,13 @@ pub enum PatKind<'tcx> {
         pats: Box<[Pat<'tcx>]>,
     },
 
+    /// A guard pattern, e.g. `x if guard(x)`
+    Guard {
+        subpattern: Box<Pat<'tcx>>,
+        #[type_visitable(ignore)]
+        condition: ExprId,
+    },
+
     /// A never pattern `!`.
     Never,
 
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index c17e15513cdf..aa1b6b1663bf 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -247,6 +247,12 @@ pub fn walk_pat<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
     visitor: &mut V,
     pat: &'thir Pat<'tcx>,
 ) {
+    if let PatKind::Guard { subpattern, condition } = &pat.kind {
+        visitor.visit_pat(subpattern);
+        visitor.visit_expr(&visitor.thir()[*condition]);
+        return;
+    };
+
     for_each_immediate_subpat(pat, |p| visitor.visit_pat(p));
 }
 
@@ -287,5 +293,9 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
                 callback(pat);
             }
         }
+
+        PatKind::Guard { subpattern, .. } => {
+            callback(subpattern);
+        }
     }
 }
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index 7698af4cd38b..cbe31fd7d132 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -360,6 +360,11 @@ pub(super) fn for_pattern(
                 Some(TestableCase::Deref { temp, mutability })
             }
 
+            PatKind::Guard { .. } => {
+                // FIXME(guard_patterns)
+                None
+            }
+
             PatKind::Never => Some(TestableCase::Never),
         };
 
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index d7edf82ae4af..d4f5fe84e0ff 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -944,6 +944,9 @@ fn visit_primary_bindings_special(
                     visit_subpat(self, subpattern, user_tys, f);
                 }
             }
+            PatKind::Guard { ref subpattern, .. } => {
+                visit_subpat(self, subpattern, user_tys, f);
+            }
         }
     }
 }
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index ee35539221e6..aed0c6e6085d 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -315,6 +315,7 @@ fn visit_pat(&mut self, pat: &'a Pat<'tcx>) {
                 | PatKind::Range { .. }
                 | PatKind::Slice { .. }
                 | PatKind::Array { .. }
+                | PatKind::Guard { .. }
                 // Never constitutes a witness of uninhabitedness.
                 | PatKind::Never => {
                     self.requires_unsafe(pat.span, AccessToUnionField);
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 27dec99696f5..ea34e5f4d97d 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -844,6 +844,14 @@ fn print_pat_kind(&mut self, pat_kind: &PatKind<'tcx>, depth_lvl: usize) {
                 print_indented!(self, "]", depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
+            PatKind::Guard { subpattern, condition } => {
+                print_indented!(self, "Guard pattern: {", depth_lvl + 1);
+                print_indented!(self, "subpattern: ", depth_lvl + 2);
+                self.print_pat(subpattern, depth_lvl + 3);
+                print_indented!(self, "guard: ", depth_lvl + 2);
+                self.print_expr(*condition, depth_lvl + 3);
+                print_indented!(self, "}", depth_lvl + 1);
+            }
             PatKind::Error(_) => {
                 print_indented!(self, "Error", depth_lvl + 1);
             }
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index dc38f2d8bc70..0226c54db58c 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -462,7 +462,8 @@ pub fn lower_pat(&self, pat: &'p Pat<'tcx>) -> DeconstructedPat<'p, 'tcx> {
         let arity;
         let fields: Vec<_>;
         match &pat.kind {
-            PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
+            PatKind::Binding { subpattern: Some(subpat), .. }
+            | PatKind::Guard { subpattern: subpat, .. } => return self.lower_pat(subpat),
             PatKind::Missing | PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
                 ctor = Wildcard;
                 fields = vec![];

From 0626f33aadb7a3a894bf4e871ac48c66faeae896 Mon Sep 17 00:00:00 2001
From: human9000 <human9000.2021@gmail.com>
Date: Mon, 16 Mar 2026 17:48:41 +0500
Subject: [PATCH 0547/1059] Add reference to 'ThirBuildCx' for `PatCtxt`

---
 compiler/rustc_mir_build/src/thir/cx/block.rs       |  3 ++-
 compiler/rustc_mir_build/src/thir/cx/expr.rs        |  2 +-
 compiler/rustc_mir_build/src/thir/cx/mod.rs         | 13 +++++++------
 .../src/thir/pattern/const_to_pat.rs                |  4 ++--
 compiler/rustc_mir_build/src/thir/pattern/mod.rs    | 12 ++++++++----
 5 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/cx/block.rs b/compiler/rustc_mir_build/src/thir/cx/block.rs
index b108dff5555f..ea27252ad6ce 100644
--- a/compiler/rustc_mir_build/src/thir/cx/block.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/block.rs
@@ -83,6 +83,7 @@ fn mirror_stmts(
                             }
                             Some(_) | None => local.span,
                         };
+                        let initializer = local.init.map(|init| self.mirror_expr(init));
                         let stmt = Stmt {
                             kind: StmtKind::Let {
                                 remainder_scope,
@@ -91,7 +92,7 @@ fn mirror_stmts(
                                     data: region::ScopeData::Node,
                                 },
                                 pattern,
-                                initializer: local.init.map(|init| self.mirror_expr(init)),
+                                initializer,
                                 else_block,
                                 hir_id: local.hir_id,
                                 span,
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index c646b0fc45ea..b79bda204405 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -876,7 +876,7 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
                     };
 
                 let indices = self.typeck_results.offset_of_data().get(expr.hir_id).unwrap();
-                let mut expr = None::<ExprKind<'tcx>>;
+                let mut expr = None::<ExprKind<'_>>;
 
                 for &(container, variant, field) in indices.iter() {
                     let next = mk_call(&mut self.thir, container, variant, field);
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 60cb509ee9dd..7f4b70b95614 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -13,14 +13,14 @@
 use rustc_middle::ty::{self, TyCtxt};
 
 /// Query implementation for [`TyCtxt::thir_body`].
-pub(crate) fn thir_body(
-    tcx: TyCtxt<'_>,
+pub(crate) fn thir_body<'tcx>(
+    tcx: TyCtxt<'tcx>,
     owner_def: LocalDefId,
-) -> Result<(&Steal<Thir<'_>>, ExprId), ErrorGuaranteed> {
+) -> Result<(&'tcx Steal<Thir<'tcx>>, ExprId), ErrorGuaranteed> {
     debug_assert!(!tcx.is_type_const(owner_def.to_def_id()), "thir_body queried for type_const");
 
     let body = tcx.hir_body_owned_by(owner_def);
-    let mut cx = ThirBuildCx::new(tcx, owner_def);
+    let mut cx: ThirBuildCx<'tcx> = ThirBuildCx::new(tcx, owner_def);
     if let Some(reported) = cx.typeck_results.tainted_by_errors {
         return Err(reported);
     }
@@ -50,7 +50,7 @@ pub(crate) fn thir_body(
 }
 
 /// Context for lowering HIR to THIR for a single function body (or other kind of body).
-struct ThirBuildCx<'tcx> {
+pub(crate) struct ThirBuildCx<'tcx> {
     tcx: TyCtxt<'tcx>,
     /// The THIR data that this context is building.
     thir: Thir<'tcx>,
@@ -118,6 +118,7 @@ fn pattern_from_hir_with_annotation(
         let_stmt_type: Option<&hir::Ty<'tcx>>,
     ) -> Box<Pat<'tcx>> {
         crate::thir::pattern::pat_from_hir(
+            self,
             self.tcx,
             self.typing_env,
             self.typeck_results,
@@ -201,7 +202,7 @@ fn explicit_params(
                 fn_sig.inputs()[index]
             };
 
-            let pat = self.pattern_from_hir(param.pat);
+            let pat: Box<Pat<'tcx>> = self.pattern_from_hir(param.pat);
             Param { pat: Some(pat), ty, ty_span, self_kind, hir_id: Some(param.hir_id) }
         })
     }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index ff9d456f7e70..ff4778dacc8d 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -25,7 +25,7 @@
     PointerPattern, TypeNotPartialEq, TypeNotStructural, UnionPattern, UnsizedPattern,
 };
 
-impl<'tcx> PatCtxt<'tcx> {
+impl<'tcx, 'ptcx> PatCtxt<'tcx, 'ptcx> {
     /// Converts a constant to a pattern (if possible).
     /// This means aggregate values (like structs and enums) are converted
     /// to a pattern that matches the value (as if you'd compared via structural equality).
@@ -61,7 +61,7 @@ struct ConstToPat<'tcx> {
 }
 
 impl<'tcx> ConstToPat<'tcx> {
-    fn new(pat_ctxt: &PatCtxt<'tcx>, id: hir::HirId, span: Span, c: ty::Const<'tcx>) -> Self {
+    fn new(pat_ctxt: &PatCtxt<'tcx, '_>, id: hir::HirId, span: Span, c: ty::Const<'tcx>) -> Self {
         trace!(?pat_ctxt.typeck_results.hir_owner);
         ConstToPat { tcx: pat_ctxt.tcx, typing_env: pat_ctxt.typing_env, span, id, c }
     }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 67cde0e2c886..1d305803aa69 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -30,9 +30,11 @@
 pub(crate) use self::check_match::check_match;
 use self::migration::PatMigration;
 use crate::errors::*;
+use crate::thir::cx::ThirBuildCx;
 
 /// Context for lowering HIR patterns to THIR patterns.
-struct PatCtxt<'tcx> {
+struct PatCtxt<'tcx, 'ptcx> {
+    upper: &'ptcx mut ThirBuildCx<'tcx>,
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
@@ -41,8 +43,9 @@ struct PatCtxt<'tcx> {
     rust_2024_migration: Option<PatMigration<'tcx>>,
 }
 
-#[instrument(level = "debug", skip(tcx, typing_env, typeck_results), ret)]
-pub(super) fn pat_from_hir<'tcx>(
+#[instrument(level = "debug", skip(upper, tcx, typing_env, typeck_results), ret)]
+pub(super) fn pat_from_hir<'tcx, 'ptcx>(
+    upper: &'ptcx mut ThirBuildCx<'tcx>,
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
@@ -51,6 +54,7 @@ pub(super) fn pat_from_hir<'tcx>(
     let_stmt_type: Option<&hir::Ty<'tcx>>,
 ) -> Box<Pat<'tcx>> {
     let mut pcx = PatCtxt {
+        upper,
         tcx,
         typing_env,
         typeck_results,
@@ -87,7 +91,7 @@ pub(super) fn pat_from_hir<'tcx>(
     thir_pat
 }
 
-impl<'tcx> PatCtxt<'tcx> {
+impl<'tcx, 'ptcx> PatCtxt<'tcx, 'ptcx> {
     fn lower_pattern(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
         let adjustments: &[PatAdjustment<'tcx>] =
             self.typeck_results.pat_adjustments().get(pat.hir_id).map_or(&[], |v| &**v);

From 16fc3012fba1234239b38f987c57f3ac8a51acc4 Mon Sep 17 00:00:00 2001
From: human9000 <human9000.2021@gmail.com>
Date: Mon, 16 Mar 2026 18:03:31 +0500
Subject: [PATCH 0548/1059] Lower guard pattern to THIR

---
 .../rustc_mir_build/src/thir/pattern/mod.rs   |  6 ++-
 .../name-resolution.rs                        |  1 +
 .../name-resolution.stderr                    | 53 +++++++++++--------
 3 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 1d305803aa69..7a54cd18e01f 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -447,8 +447,10 @@ fn lower_pattern_unadjusted(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tc
 
             hir::PatKind::Or(pats) => PatKind::Or { pats: self.lower_patterns(pats) },
 
-            // FIXME(guard_patterns): implement guard pattern lowering
-            hir::PatKind::Guard(pat, _) => self.lower_pattern(pat).kind,
+            hir::PatKind::Guard(pat, condition) => PatKind::Guard {
+                subpattern: self.lower_pattern(pat),
+                condition: self.upper.mirror_expr(condition),
+            },
 
             hir::PatKind::Err(guar) => PatKind::Error(guar),
         };
diff --git a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.rs b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.rs
index 83ad8c76bb1c..21edb9ceeff4 100644
--- a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.rs
+++ b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.rs
@@ -6,6 +6,7 @@
 #![expect(incomplete_features)]
 
 fn good_fn_item(((x if x) | x): bool) -> bool { x }
+//~^ ERROR: used binding `x` is possibly-uninitialized [E0381]
 
 fn bad_fn_item_1(x: bool, ((y if x) | y): bool) {}
 //~^ ERROR cannot find value `x` in this scope
diff --git a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
index 44e42f142707..a95ffdd42532 100644
--- a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
+++ b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
@@ -1,5 +1,5 @@
 error[E0408]: variable `y` is not bound in all patterns
-  --> $DIR/name-resolution.rs:37:10
+  --> $DIR/name-resolution.rs:38:10
    |
 LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |          ^^^^^^^^^^^^        - variable not in all patterns
@@ -13,7 +13,7 @@ LL +         ((Ok(x) if y) | (Err(x) if x),) => x && y,
    |
 
 error[E0408]: variable `x` is not bound in all patterns
-  --> $DIR/name-resolution.rs:37:25
+  --> $DIR/name-resolution.rs:38:25
    |
 LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |              -          ^^^^^^^^^^^^^ pattern doesn't bind `x`
@@ -27,7 +27,7 @@ LL +         ((Ok(y) if y) | (Err(y) if x),) => x && y,
    |
 
 error[E0408]: variable `x` is not bound in all patterns
-  --> $DIR/name-resolution.rs:63:28
+  --> $DIR/name-resolution.rs:64:28
    |
 LL |         Some(x if x > 0) | None => {}
    |              -             ^^^^ pattern doesn't bind `x`
@@ -35,7 +35,7 @@ LL |         Some(x if x > 0) | None => {}
    |              variable not in all patterns
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:10:34
+  --> $DIR/name-resolution.rs:11:34
    |
 LL | fn bad_fn_item_1(x: bool, ((y if x) | y): bool) {}
    |                                  ^
@@ -47,7 +47,7 @@ LL + fn bad_fn_item_1(x: bool, ((y if y) | y): bool) {}
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:12:25
+  --> $DIR/name-resolution.rs:13:25
    |
 LL | fn bad_fn_item_2(((x if y) | x): bool, y: bool) {}
    |                         ^
@@ -59,7 +59,7 @@ LL + fn bad_fn_item_2(((x if x) | x): bool, y: bool) {}
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:20:18
+  --> $DIR/name-resolution.rs:21:18
    |
 LL |         (x, y if x) => x && y,
    |                  ^
@@ -71,7 +71,7 @@ LL +         (x, y if y) => x && y,
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:22:15
+  --> $DIR/name-resolution.rs:23:15
    |
 LL |         (x if y, y) => x && y,
    |               ^
@@ -83,7 +83,7 @@ LL +         (x if x, y) => x && y,
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:29:20
+  --> $DIR/name-resolution.rs:30:20
    |
 LL |         (x @ (y if x),) => x && y,
    |                    ^
@@ -95,7 +95,7 @@ LL +         (x @ (y if y),) => x && y,
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:37:20
+  --> $DIR/name-resolution.rs:38:20
    |
 LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |                    ^
@@ -107,7 +107,7 @@ LL +         ((Ok(x) if x) | (Err(y) if x),) => x && y,
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:37:36
+  --> $DIR/name-resolution.rs:38:36
    |
 LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |                                    ^
@@ -119,13 +119,13 @@ LL +         ((Ok(x) if y) | (Err(y) if y),) => x && y,
    |
 
 error[E0425]: cannot find value `nonexistent` in this scope
-  --> $DIR/name-resolution.rs:44:15
+  --> $DIR/name-resolution.rs:45:15
    |
 LL |     let (_ if nonexistent) = true;
    |               ^^^^^^^^^^^ not found in this scope
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:46:22
+  --> $DIR/name-resolution.rs:47:22
    |
 LL |     if let ((x, y if x) | (x if y, y)) = (true, true) { x && y; }
    |                      ^
@@ -137,7 +137,7 @@ LL +     if let ((x, y if y) | (x if y, y)) = (true, true) { x && y; }
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:46:33
+  --> $DIR/name-resolution.rs:47:33
    |
 LL |     if let ((x, y if x) | (x if y, y)) = (true, true) { x && y; }
    |                                 ^
@@ -149,7 +149,7 @@ LL +     if let ((x, y if x) | (x if x, y)) = (true, true) { x && y; }
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:49:25
+  --> $DIR/name-resolution.rs:50:25
    |
 LL |     while let ((x, y if x) | (x if y, y)) = (true, true) { x && y; }
    |                         ^
@@ -161,7 +161,7 @@ LL +     while let ((x, y if y) | (x if y, y)) = (true, true) { x && y; }
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:49:36
+  --> $DIR/name-resolution.rs:50:36
    |
 LL |     while let ((x, y if x) | (x if y, y)) = (true, true) { x && y; }
    |                                    ^
@@ -173,7 +173,7 @@ LL +     while let ((x, y if x) | (x if x, y)) = (true, true) { x && y; }
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:52:19
+  --> $DIR/name-resolution.rs:53:19
    |
 LL |     for ((x, y if x) | (x if y, y)) in [(true, true)] { x && y; }
    |                   ^
@@ -185,7 +185,7 @@ LL +     for ((x, y if y) | (x if y, y)) in [(true, true)] { x && y; }
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:52:30
+  --> $DIR/name-resolution.rs:53:30
    |
 LL |     for ((x, y if x) | (x if y, y)) in [(true, true)] { x && y; }
    |                              ^
@@ -197,7 +197,7 @@ LL +     for ((x, y if x) | (x if x, y)) in [(true, true)] { x && y; }
    |
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/name-resolution.rs:57:13
+  --> $DIR/name-resolution.rs:58:13
    |
 LL |     (|(x if y), (y if x)| x && y)(true, true);
    |             ^
@@ -209,7 +209,7 @@ LL +     (|(x if x), (y if x)| x && y)(true, true);
    |
 
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/name-resolution.rs:57:23
+  --> $DIR/name-resolution.rs:58:23
    |
 LL |     (|(x if y), (y if x)| x && y)(true, true);
    |                       ^
@@ -221,7 +221,7 @@ LL +     (|(x if y), (y if y)| x && y)(true, true);
    |
 
 error[E0308]: mismatched types
-  --> $DIR/name-resolution.rs:75:18
+  --> $DIR/name-resolution.rs:76:18
    |
 LL |         local if local => 0,
    |                  ^^^^^ expected `bool`, found `({integer}, {integer})`
@@ -229,7 +229,16 @@ LL |         local if local => 0,
    = note: expected type `bool`
              found tuple `({integer}, {integer})`
 
-error: aborting due to 20 previous errors
+error[E0381]: used binding `x` is possibly-uninitialized
+  --> $DIR/name-resolution.rs:8:49
+   |
+LL | fn good_fn_item(((x if x) | x): bool) -> bool { x }
+   |                   -         -                   ^ `x` used here but it is possibly-uninitialized
+   |                   |         |
+   |                   |         binding initialized here in some conditions
+   |                   binding declared here but left uninitialized
 
-Some errors have detailed explanations: E0308, E0408, E0425.
+error: aborting due to 21 previous errors
+
+Some errors have detailed explanations: E0308, E0381, E0408, E0425.
 For more information about an error, try `rustc --explain E0308`.

From 57fe818124869d991a2635962c231dfe2639c216 Mon Sep 17 00:00:00 2001
From: lms0806 <godmlzkf1@naver.com>
Date: Tue, 17 Mar 2026 14:54:10 +0900
Subject: [PATCH 0549/1059] doc: clarify allocator invariant

---
 library/core/src/alloc/mod.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index 959407b75348..18310cf98918 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -100,6 +100,13 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 /// A memory block which is [*currently allocated*] may be passed to
 /// any method of the allocator that accepts such an argument.
 ///
+/// Additionally, any memory block returned by the allocator must
+/// satisfy the allocation invariants described in `core::ptr`.
+/// In particular, if a block has base address `p` and size `n`,
+/// then `p as usize + n <= usize::MAX` must hold.
+///
+/// This ensures that pointer arithmetic within the allocation
+/// (for example, `ptr.add(len)`) cannot overflow the address space.
 /// [*currently allocated*]: #currently-allocated-memory
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]

From 1814df18ef865e73e214fb1fed9c6ec05389044e Mon Sep 17 00:00:00 2001
From: ywxt <ywxtcwh@gmail.com>
Date: Mon, 16 Mar 2026 18:31:05 +0800
Subject: [PATCH 0550/1059] Run ui tests on the parallel frontend

---
 .../rustc-dev-guide/src/tests/compiletest.md  |  17 ++
 .../rustc-dev-guide/src/tests/directives.md   |   2 +
 src/tools/compiletest/src/common.rs           |  19 ++
 src/tools/compiletest/src/directives.rs       | 166 ++++++++++--------
 src/tools/compiletest/src/directives/cfg.rs   |   1 +
 .../src/directives/directive_names.rs         |   1 +
 src/tools/compiletest/src/lib.rs              |  26 ++-
 src/tools/compiletest/src/runtest.rs          |  44 +++--
 src/tools/compiletest/src/rustdoc_gui_test.rs |   2 +
 9 files changed, 186 insertions(+), 92 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 6ca9653c1854..a239310d124e 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -836,3 +836,20 @@ In CI, compare modes are only used in one Linux builder, and only with the follo
 Note that compare modes are separate to [revisions](#revisions).
 All revisions are tested when running `./x test tests/ui`, however compare-modes must be
 manually run individually via the `--compare-mode` flag.
+
+## Parallel frontend
+
+Compiletest can be run with the `--parallel-frontend-threads` flag to run the compiler in parallel mode.
+This can be used to check that the compiler produces the same output in parallel mode as in non-parallel mode, and to check for any issues that might arise in parallel mode.
+
+To run the tests in parallel mode, you need to pass the `--parallel-frontend-threads` CLI flag:
+
+```bash
+./x test tests/ui -- --parallel-frontend-threads=N --iteration-count=M
+```
+
+Where `N` is the number of threads to use for the parallel frontend, and `M` is the number of times to run each test in parallel mode (to increase the chances of catching any non-determinism).
+
+Also, when running with `--parallel-frontend-threads`, the `compare-output-by-lines` directive would be implied for all tests, since the output from the parallel frontend can be non-deterministic in terms of the order of lines.
+
+The parallel frontend is available in UI tests only at the moment, and is not currently supported in other test suites.
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index ac76a2e15d9a..f160f3fffc10 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -148,6 +148,7 @@ Some examples of `X` in `ignore-X` or `only-X`:
 - When [remote testing] is used: `remote`
 - When particular debuggers are being tested: `cdb`, `gdb`, `lldb`
 - When particular debugger versions are matched: `ignore-gdb-version`
+- When the [parallel frontend] is enabled: `ignore-parallel-frontend`
 - Specific [compare modes]: `compare-mode-polonius`, `compare-mode-chalk`,
   `compare-mode-split-dwarf`, `compare-mode-split-dwarf-single`
 - The two different test modes used by coverage tests:
@@ -233,6 +234,7 @@ The following directives will check LLVM support:
 See also [Debuginfo tests](compiletest.md#debuginfo-tests) for directives for ignoring debuggers.
 
 [remote testing]: running.md#running-tests-on-a-remote-machine
+[parallel frontend]: compiletest.md#parallel-frontend
 [compare modes]: ui.md#compare-modes
 [`x86_64-gnu-debug`]: https://github.com/rust-lang/rust/blob/ab3dba92db355b8d97db915a2dca161a117e959c/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile#L32
 [`aarch64-gnu-debug`]: https://github.com/rust-lang/rust/blob/20c909ff9cdd88d33768a4ddb8952927a675b0ad/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile#L32
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 54c0f2ec7430..bc94a81ba3b5 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -721,9 +721,17 @@ pub struct Config {
     ///
     /// This is forwarded from bootstrap's `jobs` configuration.
     pub jobs: u32,
+
+    /// Number of parallel threads to use for the frontend when building test artifacts.
+    pub parallel_frontend_threads: u32,
+    /// Number of times to execute each test.
+    pub iteration_count: u32,
 }
 
 impl Config {
+    pub const DEFAULT_PARALLEL_FRONTEND_THREADS: u32 = 1;
+    pub const DEFAULT_ITERATION_COUNT: u32 = 1;
+
     /// FIXME: this run scheme is... confusing.
     pub fn run_enabled(&self) -> bool {
         self.run.unwrap_or_else(|| {
@@ -834,6 +842,17 @@ pub fn has_subprocess_support(&self) -> bool {
             || self.target_cfg().os == "emscripten";
         !unsupported_target
     }
+
+    /// Whether the parallel frontend is enabled,
+    /// which is the case when `parallel_frontend_threads` is not set to `1`.
+    ///
+    /// - `0` means auto-detect: use the number of available hardware threads on the host.
+    ///   But we treat it as the parallel frontend being enabled in this case.
+    /// - `1` means single-threaded (parallel frontend disabled).
+    /// - `>1` means an explicitly configured thread count.
+    pub fn parallel_frontend_enabled(&self) -> bool {
+        self.parallel_frontend_threads != 1
+    }
 }
 
 /// Known widths of `target_has_atomic`.
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 462d9ae626b0..b6a9a5b1b9f5 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -67,7 +67,7 @@ pub(crate) fn from_file_directives(
         let mut props = EarlyProps::default();
 
         iter_directives(
-            config.mode,
+            config,
             file_directives,
             // (dummy comment to force args into vertical layout)
             &mut |ln: &DirectiveLine<'_>| {
@@ -362,7 +362,7 @@ fn load_from(&mut self, testfile: &Utf8Path, test_revision: Option<&str>, config
             let file_directives = FileDirectives::from_file_contents(testfile, &file_contents);
 
             iter_directives(
-                config.mode,
+                config,
                 &file_directives,
                 // (dummy comment to force args into vertical layout)
                 &mut |ln: &DirectiveLine<'_>| {
@@ -574,43 +574,51 @@ fn check_directive<'a>(
 }
 
 fn iter_directives(
-    mode: TestMode,
+    config: &Config,
     file_directives: &FileDirectives<'_>,
     it: &mut dyn FnMut(&DirectiveLine<'_>),
 ) {
     let testfile = file_directives.path;
 
-    // Coverage tests in coverage-run mode always have these extra directives, without needing to
-    // specify them manually in every test file.
-    //
-    // FIXME(jieyouxu): I feel like there's a better way to do this, leaving for later.
-    if mode == TestMode::CoverageRun {
-        let extra_directives: &[&str] = &[
-            "//@ needs-profiler-runtime",
-            // FIXME(pietroalbini): this test currently does not work on cross-compiled targets
-            // because remote-test is not capable of sending back the *.profraw files generated by
-            // the LLVM instrumentation.
-            "//@ ignore-cross-compile",
-        ];
-        // Process the extra implied directives, with a dummy line number of 0.
-        for directive_str in extra_directives {
-            let directive_line = line_directive(testfile, LineNumber::ZERO, directive_str)
-                .unwrap_or_else(|| panic!("bad extra-directive line: {directive_str:?}"));
-            it(&directive_line);
+    let extra_directives = match config.mode {
+        TestMode::CoverageRun => {
+            // Coverage tests in coverage-run mode always have these extra directives, without needing to
+            // specify them manually in every test file.
+            //
+            // FIXME(jieyouxu): I feel like there's a better way to do this, leaving for later.
+            vec![
+                "//@ needs-profiler-runtime",
+                // FIXME(pietroalbini): this test currently does not work on cross-compiled targets
+                // because remote-test is not capable of sending back the *.profraw files generated by
+                // the LLVM instrumentation.
+                "//@ ignore-cross-compile",
+            ]
+        }
+        TestMode::Codegen if !file_directives.has_explicit_no_std_core_attribute => {
+            // Note: affects all codegen test suites under test mode `codegen`, e.g. `codegen-llvm`.
+            //
+            // Codegen tests automatically receive implied `//@ needs-target-std`, unless
+            // `#![no_std]`/`#![no_core]` attribute was explicitly seen. The rationale is basically to avoid
+            // having to manually maintain a bunch of `//@ needs-target-std` directives esp. for targets
+            // tested/built out-of-tree.
+            vec!["//@ needs-target-std"]
+        }
+        TestMode::Ui if config.parallel_frontend_enabled() => {
+            // UI tests in parallel-frontend mode always have this extra directive, without needing to
+            // specify it manually in every test file.
+            vec!["//@ compare-output-by-lines"]
         }
-    }
 
-    // Note: affects all codegen test suites under test mode `codegen`, e.g. `codegen-llvm`.
-    //
-    // Codegen tests automatically receive implied `//@ needs-target-std`, unless
-    // `#![no_std]`/`#![no_core]` attribute was explicitly seen. The rationale is basically to avoid
-    // having to manually maintain a bunch of `//@ needs-target-std` directives esp. for targets
-    // tested/built out-of-tree.
-    if mode == TestMode::Codegen && !file_directives.has_explicit_no_std_core_attribute {
-        let implied_needs_target_std_line =
-            line_directive(testfile, LineNumber::ZERO, "//@ needs-target-std")
-                .expect("valid `needs-target-std` directive line");
-        it(&implied_needs_target_std_line);
+        _ => {
+            // No extra directives for other test modes.
+            vec![]
+        }
+    };
+
+    for directive_str in extra_directives {
+        let directive_line = line_directive(testfile, LineNumber::ZERO, directive_str)
+            .unwrap_or_else(|| panic!("bad extra-directive line: {directive_str:?}"));
+        it(&directive_line);
     }
 
     for directive_line in &file_directives.lines {
@@ -951,55 +959,52 @@ pub(crate) fn make_test_description(
     let mut should_fail = false;
 
     // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
-    iter_directives(
-        config.mode,
-        file_directives,
-        &mut |ln @ &DirectiveLine { line_number, .. }| {
-            if !ln.applies_to_test_revision(test_revision) {
-                return;
-            }
+    iter_directives(config, file_directives, &mut |ln @ &DirectiveLine { line_number, .. }| {
+        if !ln.applies_to_test_revision(test_revision) {
+            return;
+        }
 
-            // Parse `aux-*` directives, for use by up-to-date checks.
-            parse_and_update_aux(config, ln, aux_props);
+        // Parse `aux-*` directives, for use by up-to-date checks.
+        parse_and_update_aux(config, ln, aux_props);
 
-            macro_rules! decision {
-                ($e:expr) => {
-                    match $e {
-                        IgnoreDecision::Ignore { reason } => {
-                            ignore = true;
-                            ignore_message = Some(reason.into());
-                        }
-                        IgnoreDecision::Error { message } => {
-                            error!("{path}:{line_number}: {message}");
-                            *poisoned = true;
-                            return;
-                        }
-                        IgnoreDecision::Continue => {}
+        macro_rules! decision {
+            ($e:expr) => {
+                match $e {
+                    IgnoreDecision::Ignore { reason } => {
+                        ignore = true;
+                        ignore_message = Some(reason.into());
                     }
-                };
-            }
+                    IgnoreDecision::Error { message } => {
+                        error!("{path}:{line_number}: {message}");
+                        *poisoned = true;
+                        return;
+                    }
+                    IgnoreDecision::Continue => {}
+                }
+            };
+        }
 
-            decision!(cfg::handle_ignore(&cache.cfg_conditions, ln));
-            decision!(cfg::handle_only(&cache.cfg_conditions, ln));
-            decision!(needs::handle_needs(&cache.needs, config, ln));
-            decision!(ignore_llvm(config, ln));
-            decision!(ignore_backends(config, ln));
-            decision!(needs_backends(config, ln));
-            decision!(ignore_cdb(config, ln));
-            decision!(ignore_gdb(config, ln));
-            decision!(ignore_lldb(config, ln));
+        decision!(cfg::handle_ignore(&cache.cfg_conditions, ln));
+        decision!(cfg::handle_only(&cache.cfg_conditions, ln));
+        decision!(needs::handle_needs(&cache.needs, config, ln));
+        decision!(ignore_llvm(config, ln));
+        decision!(ignore_backends(config, ln));
+        decision!(needs_backends(config, ln));
+        decision!(ignore_cdb(config, ln));
+        decision!(ignore_gdb(config, ln));
+        decision!(ignore_lldb(config, ln));
+        decision!(ignore_parallel_frontend(config, ln));
 
-            if config.target == "wasm32-unknown-unknown"
-                && config.parse_name_directive(ln, directives::CHECK_RUN_RESULTS)
-            {
-                decision!(IgnoreDecision::Ignore {
-                    reason: "ignored on WASM as the run results cannot be checked there".into(),
-                });
-            }
+        if config.target == "wasm32-unknown-unknown"
+            && config.parse_name_directive(ln, directives::CHECK_RUN_RESULTS)
+        {
+            decision!(IgnoreDecision::Ignore {
+                reason: "ignored on WASM as the run results cannot be checked there".into(),
+            });
+        }
 
-            should_fail |= config.parse_name_directive(ln, "should-fail");
-        },
-    );
+        should_fail |= config.parse_name_directive(ln, "should-fail");
+    });
 
     // The `should-fail` annotation doesn't apply to pretty tests,
     // since we run the pretty printer across all tests by default.
@@ -1270,6 +1275,17 @@ fn ignore_llvm(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
     IgnoreDecision::Continue
 }
 
+fn ignore_parallel_frontend(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
+    if config.parallel_frontend_enabled()
+        && config.parse_name_directive(line, "ignore-parallel-frontend")
+    {
+        return IgnoreDecision::Ignore {
+            reason: "ignored when the parallel frontend is enabled".into(),
+        };
+    }
+    IgnoreDecision::Continue
+}
+
 enum IgnoreDecision {
     Ignore { reason: String },
     Continue,
diff --git a/src/tools/compiletest/src/directives/cfg.rs b/src/tools/compiletest/src/directives/cfg.rs
index 6431eb6b090b..2587acb7fe10 100644
--- a/src/tools/compiletest/src/directives/cfg.rs
+++ b/src/tools/compiletest/src/directives/cfg.rs
@@ -11,6 +11,7 @@
     "ignore-backends",
     "ignore-gdb-version",
     "ignore-llvm-version",
+    "ignore-parallel-frontend",
     "ignore-pass",
     // tidy-alphabetical-end
 ];
diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 2fc5c0e8ec1e..eaf91ff26158 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -101,6 +101,7 @@
     "ignore-nvptx64",
     "ignore-nvptx64-nvidia-cuda",
     "ignore-openbsd",
+    "ignore-parallel-frontend",
     "ignore-pass",
     "ignore-powerpc",
     "ignore-powerpc64",
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 82e8a0da6b60..6dae2ca0b475 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -219,7 +219,14 @@ fn parse_config(args: Vec<String>) -> Config {
             "CODEGEN BACKEND [NAME | PATH]",
         )
         .optflag("", "bypass-ignore-backends", "ignore `//@ ignore-backends` directives")
-        .reqopt("", "jobs", "number of parallel jobs bootstrap was configured with", "JOBS");
+        .reqopt("", "jobs", "number of parallel jobs bootstrap was configured with", "JOBS")
+        .optopt(
+            "",
+            "parallel-frontend-threads",
+            "number of parallel threads to use for the frontend when building test artifacts",
+            "THREADS_COUNT",
+        )
+        .optopt("", "iteration-count", "number of times to execute each test", "COUNT");
 
     let (argv0, args_) = args.split_first().unwrap();
     if args.len() == 1 || args[1] == "-h" || args[1] == "--help" {
@@ -369,6 +376,20 @@ fn opt_path(m: &getopts::Matches, nm: &str) -> Utf8PathBuf {
         None => panic!("`--jobs` is required"),
     };
 
+    let parallel_frontend_threads = match matches.opt_str("parallel-frontend-threads") {
+        Some(threads) => {
+            threads.parse::<u32>().expect("expected `--parallel-frontend-threads` to be an `u32`")
+        }
+        None => Config::DEFAULT_PARALLEL_FRONTEND_THREADS,
+    };
+    let iteration_count = match matches.opt_str("iteration-count") {
+        Some(count) => {
+            count.parse::<u32>().expect("expected `--iteration-count` to be a positive integer")
+        }
+        None => Config::DEFAULT_ITERATION_COUNT,
+    };
+    assert!(iteration_count > 0, "`--iteration-count` must be a positive integer");
+
     Config {
         bless: matches.opt_present("bless"),
         fail_fast: matches.opt_present("fail-fast")
@@ -489,6 +510,9 @@ fn opt_path(m: &getopts::Matches, nm: &str) -> Utf8PathBuf {
         bypass_ignore_backends: matches.opt_present("bypass-ignore-backends"),
 
         jobs,
+
+        parallel_frontend_threads,
+        iteration_count,
     }
 }
 
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 69a9e04afe1c..b674c6e29d42 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -272,22 +272,26 @@ fn run_revision(&self) {
         {
             self.fatal("cannot use should-ice in a test that is not cfail");
         }
-        match self.config.mode {
-            TestMode::Pretty => self.run_pretty_test(),
-            TestMode::DebugInfo => self.run_debuginfo_test(),
-            TestMode::Codegen => self.run_codegen_test(),
-            TestMode::RustdocHtml => self.run_rustdoc_html_test(),
-            TestMode::RustdocJson => self.run_rustdoc_json_test(),
-            TestMode::CodegenUnits => self.run_codegen_units_test(),
-            TestMode::Incremental => self.run_incremental_test(),
-            TestMode::RunMake => self.run_rmake_test(),
-            TestMode::Ui => self.run_ui_test(),
-            TestMode::MirOpt => self.run_mir_opt_test(),
-            TestMode::Assembly => self.run_assembly_test(),
-            TestMode::RustdocJs => self.run_rustdoc_js_test(),
-            TestMode::CoverageMap => self.run_coverage_map_test(), // see self::coverage
-            TestMode::CoverageRun => self.run_coverage_run_test(), // see self::coverage
-            TestMode::Crashes => self.run_crash_test(),
+        // Run the test multiple times if requested.
+        // This is useful for catching flaky tests under the parallel frontend.
+        for _ in 0..self.config.iteration_count {
+            match self.config.mode {
+                TestMode::Pretty => self.run_pretty_test(),
+                TestMode::DebugInfo => self.run_debuginfo_test(),
+                TestMode::Codegen => self.run_codegen_test(),
+                TestMode::RustdocHtml => self.run_rustdoc_html_test(),
+                TestMode::RustdocJson => self.run_rustdoc_json_test(),
+                TestMode::CodegenUnits => self.run_codegen_units_test(),
+                TestMode::Incremental => self.run_incremental_test(),
+                TestMode::RunMake => self.run_rmake_test(),
+                TestMode::Ui => self.run_ui_test(),
+                TestMode::MirOpt => self.run_mir_opt_test(),
+                TestMode::Assembly => self.run_assembly_test(),
+                TestMode::RustdocJs => self.run_rustdoc_js_test(),
+                TestMode::CoverageMap => self.run_coverage_map_test(), // see self::coverage
+                TestMode::CoverageRun => self.run_coverage_run_test(), // see self::coverage
+                TestMode::Crashes => self.run_crash_test(),
+            }
         }
     }
 
@@ -1752,6 +1756,14 @@ fn make_compile_args(
                 compiler.arg("-Zwrite-long-types-to-disk=no");
                 // FIXME: use this for other modes too, for perf?
                 compiler.arg("-Cstrip=debuginfo");
+
+                if self.config.parallel_frontend_enabled() {
+                    // Currently, we only use multiple threads for the UI test suite,
+                    // because UI tests can effectively verify the parallel frontend and
+                    // require minimal modification. The option will later be extended to
+                    // other test suites.
+                    compiler.arg(&format!("-Zthreads={}", self.config.parallel_frontend_threads));
+                }
             }
             TestMode::MirOpt => {
                 // We check passes under test to minimize the mir-opt test dump
diff --git a/src/tools/compiletest/src/rustdoc_gui_test.rs b/src/tools/compiletest/src/rustdoc_gui_test.rs
index f02918ae683b..c71fd714aa66 100644
--- a/src/tools/compiletest/src/rustdoc_gui_test.rs
+++ b/src/tools/compiletest/src/rustdoc_gui_test.rs
@@ -140,5 +140,7 @@ fn incomplete_config_for_rustdoc_gui_test() -> Config {
         override_codegen_backend: None,
         bypass_ignore_backends: Default::default(),
         jobs: Default::default(),
+        parallel_frontend_threads: Config::DEFAULT_PARALLEL_FRONTEND_THREADS,
+        iteration_count: Config::DEFAULT_ITERATION_COUNT,
     }
 }

From 45b5d5f9bf5c18157becbaf0374c0876fa065855 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Tue, 17 Mar 2026 12:11:13 +0300
Subject: [PATCH 0551/1059] Small report_cycle refactor

---
 compiler/rustc_query_impl/src/job.rs | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 0b989201a2e0..0fc129f26e7f 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -472,13 +472,10 @@ pub(crate) fn report_cycle<'tcx>(
         cycle_stack.push(crate::error::CycleStack { span, desc: node.tagged_key.description(tcx) });
     }
 
-    let mut cycle_usage = None;
-    if let Some(usage) = usage {
-        cycle_usage = Some(crate::error::CycleUsage {
-            span: usage.node.tagged_key.default_span(tcx, usage.span),
-            usage: usage.node.tagged_key.description(tcx),
-        });
-    }
+    let cycle_usage = usage.as_ref().map(|usage| crate::error::CycleUsage {
+        span: usage.node.tagged_key.default_span(tcx, usage.span),
+        usage: usage.node.tagged_key.description(tcx),
+    });
 
     let alias = if stack
         .iter()

From aa7d812f348da3e330cf3b99ee4a5ec373f2a38b Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 09:27:25 +0000
Subject: [PATCH 0552/1059] remove `internal_impls_macro` feature

---
 library/core/src/lib.rs    | 1 -
 library/core/src/marker.rs | 3 ---
 2 files changed, 4 deletions(-)

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index e12c43068245..60da6662de84 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -107,7 +107,6 @@
 #![feature(core_intrinsics)]
 #![feature(coverage_attribute)]
 #![feature(disjoint_bitor)]
-#![feature(internal_impls_macro)]
 #![feature(link_cfg)]
 #![feature(offset_of_enum)]
 #![feature(panic_internals)]
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index becac514284e..c79e8fc4060c 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -52,9 +52,6 @@
 ///         u32,
 /// }
 /// ```
-#[unstable(feature = "internal_impls_macro", issue = "none")]
-// Allow implementations of `UnsizedConstParamTy` even though std cannot use that feature.
-#[allow_internal_unstable(const_param_ty_trait)]
 macro marker_impls {
     ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(, $($rest:tt)*)? ) => {
         $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for $T {}

From e350a56cf9d7a013e1d1e52ab306bfc19324653a Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 24 Feb 2026 13:48:09 +0000
Subject: [PATCH 0553/1059] move features into the correct section

---
 library/core/src/lib.rs |  2 +-
 library/std/src/lib.rs  | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 60da6662de84..8a9decd33b1c 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -107,7 +107,6 @@
 #![feature(core_intrinsics)]
 #![feature(coverage_attribute)]
 #![feature(disjoint_bitor)]
-#![feature(link_cfg)]
 #![feature(offset_of_enum)]
 #![feature(panic_internals)]
 #![feature(pattern_type_macro)]
@@ -143,6 +142,7 @@
 #![feature(intra_doc_pointers)]
 #![feature(intrinsics)]
 #![feature(lang_items)]
+#![feature(link_cfg)]
 #![feature(link_llvm_intrinsics)]
 #![feature(macro_metavar_expr)]
 #![feature(macro_metavar_expr_concat)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 6fcb28edc7d8..c8c8a6c89714 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -275,9 +275,7 @@
 #![feature(cfg_sanitizer_cfi)]
 #![feature(cfg_target_thread_local)]
 #![feature(cfi_encoding)]
-#![feature(const_default)]
 #![feature(const_trait_impl)]
-#![feature(core_float_math)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]
@@ -287,16 +285,11 @@
 #![feature(f16)]
 #![feature(f128)]
 #![feature(ffi_const)]
-#![feature(formatting_options)]
-#![feature(funnel_shifts)]
 #![feature(intra_doc_pointers)]
-#![feature(iter_advance_by)]
-#![feature(iter_next_chunk)]
 #![feature(lang_items)]
 #![feature(link_cfg)]
 #![feature(linkage)]
 #![feature(macro_metavar_expr_concat)]
-#![feature(maybe_uninit_fill)]
 #![feature(min_specialization)]
 #![feature(must_not_suspend)]
 #![feature(needs_panic_runtime)]
@@ -314,7 +307,6 @@
 #![feature(try_blocks)]
 #![feature(try_trait_v2)]
 #![feature(type_alias_impl_trait)]
-#![feature(uint_carryless_mul)]
 // tidy-alphabetical-end
 //
 // Library features (core):
@@ -325,6 +317,8 @@
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(const_convert)]
+#![feature(const_default)]
+#![feature(core_float_math)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(cstr_display)]
@@ -340,13 +334,18 @@
 #![feature(float_minimum_maximum)]
 #![feature(fmt_internals)]
 #![feature(fn_ptr_trait)]
+#![feature(formatting_options)]
+#![feature(funnel_shifts)]
 #![feature(generic_atomic)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
 #![feature(hint_must_use)]
 #![feature(int_from_ascii)]
 #![feature(ip)]
+#![feature(iter_advance_by)]
+#![feature(iter_next_chunk)]
 #![feature(maybe_uninit_array_assume_init)]
+#![feature(maybe_uninit_fill)]
 #![feature(panic_can_unwind)]
 #![feature(panic_internals)]
 #![feature(pin_coerce_unsized_trait)]
@@ -364,6 +363,7 @@
 #![feature(sync_unsafe_cell)]
 #![feature(temporary_niche_types)]
 #![feature(ub_checks)]
+#![feature(uint_carryless_mul)]
 #![feature(used_with_arg)]
 // tidy-alphabetical-end
 //

From 6a0ce1665407d1a194fb389408e45854c47c9c7b Mon Sep 17 00:00:00 2001
From: ywxt <ywxtcwh@gmail.com>
Date: Tue, 17 Mar 2026 17:39:59 +0800
Subject: [PATCH 0554/1059] Ignore tests for the parallel frontend

---
 tests/ui/abi/simd-abi-checks-avx.rs                             | 2 +-
 .../ui/async-await/mutually-recursive-async-impl-trait-type.rs  | 2 +-
 tests/ui/const-generics/issues/issue-100313.rs                  | 2 +-
 tests/ui/const-generics/min_const_generics/invalid-patterns.rs  | 2 +-
 tests/ui/const-ptr/forbidden_slices.rs                          | 2 +-
 tests/ui/const-ptr/out_of_bounds_read.rs                        | 2 +-
 tests/ui/consts/chained-constants-stackoverflow.rs              | 2 +-
 tests/ui/consts/const-compare-bytes-ub.rs                       | 2 +-
 tests/ui/consts/const-err-enum-discriminant.rs                  | 2 +-
 tests/ui/consts/const-eval/c-variadic-fail.rs                   | 2 +-
 .../consts/const-eval/const-pointer-values-in-various-types.rs  | 2 +-
 tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs       | 2 +-
 tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs   | 2 +-
 tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.rs  | 2 +-
 .../const-eval/heap/dealloc_intrinsic_incorrect_layout.rs       | 2 +-
 tests/ui/consts/const-eval/heap/make-global-dangling.rs         | 2 +-
 tests/ui/consts/const-eval/heap/make-global-other.rs            | 2 +-
 tests/ui/consts/const-eval/heap/make-global-twice.rs            | 2 +-
 tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs      | 2 +-
 tests/ui/consts/const-eval/index-out-of-bounds-never-type.rs    | 2 +-
 tests/ui/consts/const-eval/issue-49296.rs                       | 2 +-
 tests/ui/consts/const-eval/issue-50814-2.rs                     | 2 +-
 tests/ui/consts/const-eval/issue-50814.rs                       | 2 +-
 tests/ui/consts/const-eval/ptr_fragments_mixed.rs               | 2 +-
 tests/ui/consts/const-eval/raw-bytes.rs                         | 2 +-
 tests/ui/consts/const-eval/raw-pointer-ub.rs                    | 2 +-
 tests/ui/consts/const-eval/read_partial_ptr.rs                  | 2 +-
 tests/ui/consts/const-eval/ub-enum-overwrite.rs                 | 2 +-
 tests/ui/consts/const-eval/ub-enum.rs                           | 2 +-
 tests/ui/consts/const-eval/ub-incorrect-vtable.rs               | 2 +-
 tests/ui/consts/const-eval/ub-nonnull.rs                        | 2 +-
 tests/ui/consts/const-eval/ub-ref-ptr.rs                        | 2 +-
 tests/ui/consts/const-eval/ub-upvars.rs                         | 2 +-
 tests/ui/consts/const-eval/ub-wide-ptr.rs                       | 2 +-
 tests/ui/consts/const-eval/union-const-eval-field.rs            | 2 +-
 tests/ui/consts/const-eval/union-ice.rs                         | 2 +-
 tests/ui/consts/const-eval/union-ub.rs                          | 2 +-
 tests/ui/consts/const-item-no-type/in-macro.rs                  | 2 +-
 tests/ui/consts/copy-intrinsic.rs                               | 2 +-
 tests/ui/consts/interior-mut-const-via-union.rs                 | 2 +-
 tests/ui/consts/issue-63952.rs                                  | 2 +-
 tests/ui/consts/issue-79690.rs                                  | 2 +-
 tests/ui/consts/miri_unleashed/static-no-inner-mut.rs           | 2 +-
 tests/ui/consts/missing_span_in_backtrace.rs                    | 2 +-
 tests/ui/consts/mono-reachable-invalid-const.rs                 | 2 +-
 tests/ui/consts/offset_ub.rs                                    | 2 +-
 tests/ui/consts/recursive-zst-static.rs                         | 2 +-
 tests/ui/consts/required-consts/collect-in-called-fn.rs         | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-closure.rs      | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-drop.rs         | 2 +-
 .../required-consts/collect-in-dead-fn-behind-assoc-type.rs     | 2 +-
 .../consts/required-consts/collect-in-dead-fn-behind-generic.rs | 2 +-
 .../required-consts/collect-in-dead-fn-behind-opaque-type.rs    | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-fn.rs           | 2 +-
 .../ui/consts/required-consts/collect-in-dead-fnptr-in-const.rs | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-fnptr.rs        | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-forget.rs       | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-move.rs         | 2 +-
 tests/ui/consts/required-consts/collect-in-dead-vtable.rs       | 2 +-
 tests/ui/consts/required-consts/collect-in-promoted-const.rs    | 2 +-
 tests/ui/consts/required-consts/interpret-in-const-called-fn.rs | 2 +-
 tests/ui/consts/required-consts/interpret-in-promoted.rs        | 2 +-
 tests/ui/consts/required-consts/interpret-in-static.rs          | 2 +-
 tests/ui/cycle-trait/cycle-trait-supertrait-indirect.rs         | 2 +-
 tests/ui/cycle-trait/issue-12511.rs                             | 2 +-
 tests/ui/delegation/unsupported.rs                              | 2 +-
 tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs              | 2 +-
 tests/ui/dep-graph/dep-graph-caller-callee.rs                   | 2 +-
 tests/ui/dep-graph/dep-graph-struct-signature.rs                | 2 +-
 .../ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs | 2 +-
 tests/ui/dep-graph/dep-graph-trait-impl.rs                      | 2 +-
 tests/ui/dep-graph/dep-graph-type-alias.rs                      | 2 +-
 tests/ui/dep-graph/dep-graph-variance-alias.rs                  | 2 +-
 tests/ui/error-emitter/multiline-removal-suggestion.rs          | 1 +
 .../ui/generic-associated-types/unknown-lifetime-ice-119827.rs  | 2 +-
 tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs       | 2 +-
 tests/ui/infinite/infinite-trait-alias-recursion.rs             | 2 +-
 tests/ui/infinite/infinite-type-alias-mutual-recursion.rs       | 2 +-
 tests/ui/inline-const/required-const.rs                         | 2 +-
 tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs               | 2 +-
 tests/ui/issues/issue-17252.rs                                  | 2 +-
 tests/ui/issues/issue-34373.rs                                  | 2 +-
 tests/ui/lint/large_assignments/copy_into_box_rc_arc.rs         | 2 +-
 tests/ui/lint/large_assignments/copy_into_fn.rs                 | 2 +-
 tests/ui/lint/large_assignments/inline_mir.rs                   | 2 +-
 tests/ui/lint/large_assignments/large_future.rs                 | 2 +-
 tests/ui/lint/large_assignments/move_into_fn.rs                 | 2 +-
 tests/ui/lint/non-snake-case/lint-uppercase-variables.rs        | 2 +-
 .../rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.rs | 2 +-
 tests/ui/liveness/liveness-unused.rs                            | 2 +-
 tests/ui/pattern/non-structural-match-types-cycle-err.rs        | 2 +-
 tests/ui/recursion/issue-23302-3.rs                             | 2 +-
 tests/ui/resolve/proc_macro_generated_packed.rs                 | 2 +-
 tests/ui/resolve/resolve-self-in-impl.rs                        | 2 +-
 .../edition-lint-infer-outlives-macro.fixed                     | 2 +-
 .../edition-lint-infer-outlives-macro.rs                        | 2 +-
 tests/ui/simd/const-err-trumps-simd-err.rs                      | 2 +-
 tests/ui/structs/default-field-values/post-mono.rs              | 2 +-
 tests/ui/traits/alias/infinite_normalization.rs                 | 2 +-
 tests/ui/type/pattern_types/validity.rs                         | 2 +-
 tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs         | 2 +-
 101 files changed, 101 insertions(+), 100 deletions(-)

diff --git a/tests/ui/abi/simd-abi-checks-avx.rs b/tests/ui/abi/simd-abi-checks-avx.rs
index 7432381d15b7..c68ba2fb5f89 100644
--- a/tests/ui/abi/simd-abi-checks-avx.rs
+++ b/tests/ui/abi/simd-abi-checks-avx.rs
@@ -1,7 +1,7 @@
 //@ only-x86_64
 //@ build-fail
 //@ compile-flags: -C target-feature=-avx
-
+//@ ignore-parallel-frontend post-monomorphization errors
 #![feature(portable_simd)]
 #![feature(simd_ffi)]
 #![allow(improper_ctypes_definitions)]
diff --git a/tests/ui/async-await/mutually-recursive-async-impl-trait-type.rs b/tests/ui/async-await/mutually-recursive-async-impl-trait-type.rs
index 645a136eeb4e..69c4777ecb44 100644
--- a/tests/ui/async-await/mutually-recursive-async-impl-trait-type.rs
+++ b/tests/ui/async-await/mutually-recursive-async-impl-trait-type.rs
@@ -1,7 +1,7 @@
 //@ edition:2018
 // Test that impl trait does not allow creating recursive types that are
 // otherwise forbidden when using `async` and `await`.
-
+//@ ignore-parallel-frontend  query cycle
 async fn rec_1() { //~ ERROR recursion in an async fn
     rec_2().await;
 }
diff --git a/tests/ui/const-generics/issues/issue-100313.rs b/tests/ui/const-generics/issues/issue-100313.rs
index 1f61356162ca..3eed2e71ae85 100644
--- a/tests/ui/const-generics/issues/issue-100313.rs
+++ b/tests/ui/const-generics/issues/issue-100313.rs
@@ -1,5 +1,5 @@
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #![allow(incomplete_features)]
 #![feature(adt_const_params, unsized_const_params)]
 
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.rs b/tests/ui/const-generics/min_const_generics/invalid-patterns.rs
index 85f019adf664..847b51abb6af 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.rs
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.rs
@@ -1,6 +1,6 @@
 //@ stderr-per-bitwidth
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 use std::mem::transmute;
 
 fn get_flag<const FlagSet: bool, const ShortName: char>() -> Option<char> {
diff --git a/tests/ui/const-ptr/forbidden_slices.rs b/tests/ui/const-ptr/forbidden_slices.rs
index fcb0dccf750e..b7c02e6735b4 100644
--- a/tests/ui/const-ptr/forbidden_slices.rs
+++ b/tests/ui/const-ptr/forbidden_slices.rs
@@ -1,7 +1,7 @@
 // Strip out raw byte dumps to make comparison platform-independent:
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
-
+//@ ignore-parallel-frontend  different alloc ids
 #![feature(
     slice_from_ptr_range,
     const_slice_from_ptr_range,
diff --git a/tests/ui/const-ptr/out_of_bounds_read.rs b/tests/ui/const-ptr/out_of_bounds_read.rs
index b09978badde5..51accc657b81 100644
--- a/tests/ui/const-ptr/out_of_bounds_read.rs
+++ b/tests/ui/const-ptr/out_of_bounds_read.rs
@@ -1,6 +1,6 @@
 fn main() {
     use std::ptr;
-
+//@ ignore-parallel-frontend different alloc ids
     const DATA: [u32; 1] = [42];
 
     const PAST_END_PTR: *const u32 = unsafe { DATA.as_ptr().add(1) };
diff --git a/tests/ui/consts/chained-constants-stackoverflow.rs b/tests/ui/consts/chained-constants-stackoverflow.rs
index 0f0ce40a1edc..0775ea56bbe0 100644
--- a/tests/ui/consts/chained-constants-stackoverflow.rs
+++ b/tests/ui/consts/chained-constants-stackoverflow.rs
@@ -1,5 +1,5 @@
 //@ run-pass
-
+//@ ignore-parallel-frontend queries overflow the depth limit
 // https://github.com/rust-lang/rust/issues/34997
 
 pub const CST_1: u32 = 0;
diff --git a/tests/ui/consts/const-compare-bytes-ub.rs b/tests/ui/consts/const-compare-bytes-ub.rs
index 7e3df92a2bf5..f30507858f20 100644
--- a/tests/ui/consts/const-compare-bytes-ub.rs
+++ b/tests/ui/consts/const-compare-bytes-ub.rs
@@ -1,5 +1,5 @@
 //@ check-fail
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(core_intrinsics, const_cmp)]
 use std::intrinsics::compare_bytes;
 use std::mem::MaybeUninit;
diff --git a/tests/ui/consts/const-err-enum-discriminant.rs b/tests/ui/consts/const-err-enum-discriminant.rs
index 556746005843..f6142707f922 100644
--- a/tests/ui/consts/const-err-enum-discriminant.rs
+++ b/tests/ui/consts/const-err-enum-discriminant.rs
@@ -1,5 +1,5 @@
 //@ stderr-per-bitwidth
-
+//@ ignore-parallel-frontend different alloc ids
 #[derive(Copy, Clone)]
 union Foo {
     a: isize,
diff --git a/tests/ui/consts/const-eval/c-variadic-fail.rs b/tests/ui/consts/const-eval/c-variadic-fail.rs
index b5a400a8bf25..2cf5d05cb248 100644
--- a/tests/ui/consts/const-eval/c-variadic-fail.rs
+++ b/tests/ui/consts/const-eval/c-variadic-fail.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(c_variadic)]
 #![feature(const_c_variadic)]
 #![feature(const_trait_impl)]
diff --git a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.rs b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.rs
index 5720d6ea91ed..c6aae902c8bd 100644
--- a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.rs
+++ b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.rs
@@ -1,7 +1,7 @@
 //@ only-x86_64
 //@ stderr-per-bitwidth
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #[repr(C)]
 union Nonsense {
     u: usize,
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
index c54115de2045..3ef18a5f4369 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
@@ -3,7 +3,7 @@
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 use std::intrinsics;
-
+//@ ignore-parallel-frontend different alloc ids
 const BAR: &i32 = unsafe { //~ ERROR: uninitialized memory
     // Make the pointer immutable to avoid errors related to mutable pointers in constants.
     &*(intrinsics::const_make_global(intrinsics::const_allocate(4, 4)) as *const i32)
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
index de9fc5d09213..a377ee35d92b 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.rs
@@ -1,6 +1,6 @@
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
-
+//@ ignore-parallel-frontend different alloc ids
 // Strip out raw byte dumps to make comparison platform-independent:
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.rs
index 5b7cd039b9ba..bc9227b31f80 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.rs
@@ -1,6 +1,6 @@
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
-
+//@ ignore-parallel-frontend different alloc ids
 use std::intrinsics;
 
 const _X: () = unsafe {
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_incorrect_layout.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_incorrect_layout.rs
index 75c3601f2166..8800188e9036 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_incorrect_layout.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_incorrect_layout.rs
@@ -1,6 +1,6 @@
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
-
+//@ ignore-parallel-frontend different alloc ids
 use std::intrinsics;
 
 const _X: () = unsafe {
diff --git a/tests/ui/consts/const-eval/heap/make-global-dangling.rs b/tests/ui/consts/const-eval/heap/make-global-dangling.rs
index f4c5929bc416..12b9ca7a6980 100644
--- a/tests/ui/consts/const-eval/heap/make-global-dangling.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-dangling.rs
@@ -1,5 +1,5 @@
 // Ensure that we can't call `const_make_global` on dangling pointers.
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/make-global-other.rs b/tests/ui/consts/const-eval/heap/make-global-other.rs
index 4e2a59de13ed..9250f7a55be4 100644
--- a/tests/ui/consts/const-eval/heap/make-global-other.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-other.rs
@@ -1,5 +1,5 @@
 // Ensure that we can't call `const_make_global` on pointers not in the current interpreter.
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/make-global-twice.rs b/tests/ui/consts/const-eval/heap/make-global-twice.rs
index 0cd617cea3e6..a4d01170812c 100644
--- a/tests/ui/consts/const-eval/heap/make-global-twice.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-twice.rs
@@ -1,5 +1,5 @@
 // Ensure that we can't call `const_make_global` twice.
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs
index bea2a5949c26..c405f7316048 100644
--- a/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs
+++ b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs
@@ -2,7 +2,7 @@
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 use std::intrinsics;
-
+//@ ignore-parallel-frontend different alloc ids
 const A: &u8 = unsafe {
     let ptr = intrinsics::const_allocate(1, 1);
     *ptr = 1;
diff --git a/tests/ui/consts/const-eval/index-out-of-bounds-never-type.rs b/tests/ui/consts/const-eval/index-out-of-bounds-never-type.rs
index 6777bee050a1..dbe507e3cd13 100644
--- a/tests/ui/consts/const-eval/index-out-of-bounds-never-type.rs
+++ b/tests/ui/consts/const-eval/index-out-of-bounds-never-type.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-
+//@ ignore-parallel-frontend post-monomorphization errors
 // Regression test for #66975
 #![warn(unconditional_panic)]
 #![feature(never_type)]
diff --git a/tests/ui/consts/const-eval/issue-49296.rs b/tests/ui/consts/const-eval/issue-49296.rs
index a427b642899a..35797fbf248b 100644
--- a/tests/ui/consts/const-eval/issue-49296.rs
+++ b/tests/ui/consts/const-eval/issue-49296.rs
@@ -1,5 +1,5 @@
 // issue-49296: Unsafe shenigans in constants can result in missing errors
-
+//@ ignore-parallel-frontend different alloc ids
 use std::mem::transmute;
 
 const fn wat(x: u64) -> &'static u64 {
diff --git a/tests/ui/consts/const-eval/issue-50814-2.rs b/tests/ui/consts/const-eval/issue-50814-2.rs
index 1b917a0916da..34a200e2887b 100644
--- a/tests/ui/consts/const-eval/issue-50814-2.rs
+++ b/tests/ui/consts/const-eval/issue-50814-2.rs
@@ -2,7 +2,7 @@
 //@ revisions: normal mir-opt
 //@ [mir-opt]compile-flags: -Zmir-opt-level=4
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend post-monomorphization errors
 trait C {
     const BOO: usize;
 }
diff --git a/tests/ui/consts/const-eval/issue-50814.rs b/tests/ui/consts/const-eval/issue-50814.rs
index 011f065ad814..3901a2c0c931 100644
--- a/tests/ui/consts/const-eval/issue-50814.rs
+++ b/tests/ui/consts/const-eval/issue-50814.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend post-monomorphization errors
 trait Unsigned {
     const MAX: u8;
 }
diff --git a/tests/ui/consts/const-eval/ptr_fragments_mixed.rs b/tests/ui/consts/const-eval/ptr_fragments_mixed.rs
index 24169eac4780..471d46405596 100644
--- a/tests/ui/consts/const-eval/ptr_fragments_mixed.rs
+++ b/tests/ui/consts/const-eval/ptr_fragments_mixed.rs
@@ -1,6 +1,6 @@
 //! This mixes fragments from different pointers, in a way that we should not accept.
 //! See <https://github.com/rust-lang/rust/issues/146291>.
-
+//@ ignore-parallel-frontend different alloc ids
 static A: u8 = 123;
 static B: u8 = 123;
 
diff --git a/tests/ui/consts/const-eval/raw-bytes.rs b/tests/ui/consts/const-eval/raw-bytes.rs
index 199f4d1ea0e1..274b1ae039fb 100644
--- a/tests/ui/consts/const-eval/raw-bytes.rs
+++ b/tests/ui/consts/const-eval/raw-bytes.rs
@@ -3,7 +3,7 @@
 // ignore-tidy-linelength
 //@ normalize-stderr: "╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼" -> "╾ALLOC_ID$1╼"
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #![allow(invalid_value, unnecessary_transmutes)]
 #![feature(never_type, rustc_attrs, ptr_metadata, slice_from_ptr_range, const_slice_from_ptr_range)]
 
diff --git a/tests/ui/consts/const-eval/raw-pointer-ub.rs b/tests/ui/consts/const-eval/raw-pointer-ub.rs
index df7bc2fe4fb1..0998617b5b71 100644
--- a/tests/ui/consts/const-eval/raw-pointer-ub.rs
+++ b/tests/ui/consts/const-eval/raw-pointer-ub.rs
@@ -4,7 +4,7 @@
     let _val = *ptr; //~NOTE: failed here
     //~^ERROR: based on pointer with alignment 1, but alignment 4 is required
 };
-
+//@ ignore-parallel-frontend different alloc ids
 const MISALIGNED_STORE: () = unsafe {
     let mut mem = [0u32; 8];
     let ptr = mem.as_mut_ptr().byte_add(1);
diff --git a/tests/ui/consts/const-eval/read_partial_ptr.rs b/tests/ui/consts/const-eval/read_partial_ptr.rs
index bccef9c0bc6c..5248f92a92db 100644
--- a/tests/ui/consts/const-eval/read_partial_ptr.rs
+++ b/tests/ui/consts/const-eval/read_partial_ptr.rs
@@ -1,5 +1,5 @@
 //! Ensure we error when trying to load from a pointer whose provenance has been messed with.
-
+//@ ignore-parallel-frontend different alloc ids
 const PARTIAL_OVERWRITE: () = {
     let mut p = &42;
     // Overwrite one byte with a no-provenance value.
diff --git a/tests/ui/consts/const-eval/ub-enum-overwrite.rs b/tests/ui/consts/const-eval/ub-enum-overwrite.rs
index 005f3c78c1d7..a1bd49f53ace 100644
--- a/tests/ui/consts/const-eval/ub-enum-overwrite.rs
+++ b/tests/ui/consts/const-eval/ub-enum-overwrite.rs
@@ -2,7 +2,7 @@ enum E {
     A(u8),
     B,
 }
-
+//@ ignore-parallel-frontend different alloc ids
 const _: u8 = {
     let mut e = E::A(1);
     let p = if let E::A(x) = &mut e { x as *mut u8 } else { unreachable!() };
diff --git a/tests/ui/consts/const-eval/ub-enum.rs b/tests/ui/consts/const-eval/ub-enum.rs
index 63029e17da22..61ab3581e347 100644
--- a/tests/ui/consts/const-eval/ub-enum.rs
+++ b/tests/ui/consts/const-eval/ub-enum.rs
@@ -4,7 +4,7 @@
 //@ normalize-stderr: "0x0+" -> "0x0"
 //@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(never_type)]
 #![allow(invalid_value, unnecessary_transmutes)]
 
diff --git a/tests/ui/consts/const-eval/ub-incorrect-vtable.rs b/tests/ui/consts/const-eval/ub-incorrect-vtable.rs
index 4185b0261b29..09129012e083 100644
--- a/tests/ui/consts/const-eval/ub-incorrect-vtable.rs
+++ b/tests/ui/consts/const-eval/ub-incorrect-vtable.rs
@@ -12,7 +12,7 @@
 
 //@ stderr-per-bitwidth
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 trait Trait {}
 
 const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
diff --git a/tests/ui/consts/const-eval/ub-nonnull.rs b/tests/ui/consts/const-eval/ub-nonnull.rs
index 851f3996cd10..daa4c40f98a9 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.rs
+++ b/tests/ui/consts/const-eval/ub-nonnull.rs
@@ -2,7 +2,7 @@
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #![allow(invalid_value)] // make sure we cannot allow away the errors tested here
 #![feature(rustc_attrs, ptr_metadata)]
 
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index a5fdde1f9a4e..f7421ee34446 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -6,7 +6,7 @@
 //@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
 #![feature(rustc_attrs)]
 #![allow(invalid_value)]
-
+//@ ignore-parallel-frontend different alloc ids
 use std::mem;
 
 #[repr(C)]
diff --git a/tests/ui/consts/const-eval/ub-upvars.rs b/tests/ui/consts/const-eval/ub-upvars.rs
index c5bf074ec462..7270d90bf792 100644
--- a/tests/ui/consts/const-eval/ub-upvars.rs
+++ b/tests/ui/consts/const-eval/ub-upvars.rs
@@ -1,7 +1,7 @@
 //@ edition:2015..2021
 //@ stderr-per-bitwidth
 #![allow(invalid_value)] // make sure we cannot allow away the errors tested here
-
+//@ ignore-parallel-frontend different alloc ids
 use std::mem;
 
 const BAD_UPVAR: &dyn FnOnce() = &{ //~ ERROR null reference
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.rs b/tests/ui/consts/const-eval/ub-wide-ptr.rs
index 0bbb104c0322..6297d2f3d3af 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.rs
@@ -3,7 +3,7 @@
 #![feature(ptr_metadata)]
 
 use std::{ptr, mem};
-
+//@ ignore-parallel-frontend different alloc ids
 // Strip out raw byte dumps to make comparison platform-independent:
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.rs b/tests/ui/consts/const-eval/union-const-eval-field.rs
index 2c9061a7a50f..92d056b3b1ef 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.rs
+++ b/tests/ui/consts/const-eval/union-const-eval-field.rs
@@ -1,7 +1,7 @@
 //@ dont-require-annotations: NOTE
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([[:xdigit:]]{2}\s){4}(__\s){4}\s+│\s+([?|\.]){4}\W{4}" -> "HEX_DUMP"
-
+//@ ignore-parallel-frontend different alloc ids
 type Field1 = i32;
 type Field2 = f32;
 type Field3 = i64;
diff --git a/tests/ui/consts/const-eval/union-ice.rs b/tests/ui/consts/const-eval/union-ice.rs
index 7a4909e8ce28..055a130cf0e8 100644
--- a/tests/ui/consts/const-eval/union-ice.rs
+++ b/tests/ui/consts/const-eval/union-ice.rs
@@ -1,5 +1,5 @@
 //@ only-x86_64
-
+//@ ignore-parallel-frontend different alloc ids
 type Field1 = i32;
 type Field3 = i64;
 
diff --git a/tests/ui/consts/const-eval/union-ub.rs b/tests/ui/consts/const-eval/union-ub.rs
index 0fa5d3128560..8de54f5749f3 100644
--- a/tests/ui/consts/const-eval/union-ub.rs
+++ b/tests/ui/consts/const-eval/union-ub.rs
@@ -1,6 +1,6 @@
 //@ stderr-per-bitwidth
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend different alloc ids
 #[repr(C)]
 union DummyUnion {
     unit: (),
diff --git a/tests/ui/consts/const-item-no-type/in-macro.rs b/tests/ui/consts/const-item-no-type/in-macro.rs
index c200a1fd0b41..49bd3862852e 100644
--- a/tests/ui/consts/const-item-no-type/in-macro.rs
+++ b/tests/ui/consts/const-item-no-type/in-macro.rs
@@ -8,7 +8,7 @@ macro_rules! suite {
         )*
     }
 }
-
+//@ ignore-parallel-frontend  different infer type: bool
 suite! {
     len;
     is_empty;
diff --git a/tests/ui/consts/copy-intrinsic.rs b/tests/ui/consts/copy-intrinsic.rs
index 480f1c5f460d..5329e5bc242e 100644
--- a/tests/ui/consts/copy-intrinsic.rs
+++ b/tests/ui/consts/copy-intrinsic.rs
@@ -1,6 +1,6 @@
 // ignore-tidy-linelength
 #![feature(core_intrinsics)]
-
+//@ ignore-parallel-frontend different alloc ids
 use std::intrinsics::{copy, copy_nonoverlapping};
 use std::mem;
 
diff --git a/tests/ui/consts/interior-mut-const-via-union.rs b/tests/ui/consts/interior-mut-const-via-union.rs
index 5e624671aee0..cba3b36bd98a 100644
--- a/tests/ui/consts/interior-mut-const-via-union.rs
+++ b/tests/ui/consts/interior-mut-const-via-union.rs
@@ -3,7 +3,7 @@
 //
 //@ build-fail
 //@ stderr-per-bitwidth
-
+//@ ignore-parallel-frontend different alloc ids
 use std::cell::Cell;
 use std::mem::ManuallyDrop;
 
diff --git a/tests/ui/consts/issue-63952.rs b/tests/ui/consts/issue-63952.rs
index fce6013b4d31..c0ee7a5dc1e7 100644
--- a/tests/ui/consts/issue-63952.rs
+++ b/tests/ui/consts/issue-63952.rs
@@ -1,6 +1,6 @@
 // Regression test for #63952, shouldn't hang.
 //@ stderr-per-bitwidth
-
+//@ ignore-parallel-frontend different alloc ids
 #[repr(C)]
 #[derive(Copy, Clone)]
 struct SliceRepr {
diff --git a/tests/ui/consts/issue-79690.rs b/tests/ui/consts/issue-79690.rs
index 24e3220155d1..5e1e65cdb8d5 100644
--- a/tests/ui/consts/issue-79690.rs
+++ b/tests/ui/consts/issue-79690.rs
@@ -1,7 +1,7 @@
 //@ ignore-32bit
 // This test gives a different error on 32-bit architectures.
 //@ stderr-per-bitwidth
-
+//@ ignore-parallel-frontend different alloc ids
 union Transmute<T: Copy, U: Copy> {
     t: T,
     u: U,
diff --git a/tests/ui/consts/miri_unleashed/static-no-inner-mut.rs b/tests/ui/consts/miri_unleashed/static-no-inner-mut.rs
index 0e87442f6a69..27eb9a6c7c34 100644
--- a/tests/ui/consts/miri_unleashed/static-no-inner-mut.rs
+++ b/tests/ui/consts/miri_unleashed/static-no-inner-mut.rs
@@ -1,6 +1,6 @@
 //@ stderr-per-bitwidth
 //@ compile-flags: -Zunleash-the-miri-inside-of-you
-
+//@ ignore-parallel-frontend different alloc ids
 // All "inner" allocations that come with a `static` are interned immutably. This means it is
 // crucial that we do not accept any form of (interior) mutability there.
 use std::sync::atomic::*;
diff --git a/tests/ui/consts/missing_span_in_backtrace.rs b/tests/ui/consts/missing_span_in_backtrace.rs
index b679493eb08e..897b37b3e65a 100644
--- a/tests/ui/consts/missing_span_in_backtrace.rs
+++ b/tests/ui/consts/missing_span_in_backtrace.rs
@@ -1,7 +1,7 @@
 //! Check what happens when the error occurs inside a std function that we can't print the span of.
 //@ ignore-backends: gcc
 //@ compile-flags: -Z ui-testing=no --diagnostic-width=80
-
+//@ ignore-parallel-frontend different alloc ids
 use std::{
     mem::{self, MaybeUninit},
     ptr,
diff --git a/tests/ui/consts/mono-reachable-invalid-const.rs b/tests/ui/consts/mono-reachable-invalid-const.rs
index aba41dabe71f..3d76e4a65a4e 100644
--- a/tests/ui/consts/mono-reachable-invalid-const.rs
+++ b/tests/ui/consts/mono-reachable-invalid-const.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Bar<const BITS: usize>;
 
 impl<const BITS: usize> Bar<BITS> {
diff --git a/tests/ui/consts/offset_ub.rs b/tests/ui/consts/offset_ub.rs
index 98a50156a948..c9c34e19e4dd 100644
--- a/tests/ui/consts/offset_ub.rs
+++ b/tests/ui/consts/offset_ub.rs
@@ -1,5 +1,5 @@
 use std::ptr;
-
+//@ ignore-parallel-frontend different alloc ids
 //@ normalize-stderr: "0xf+" -> "0xf..f"
 //@ normalize-stderr: "0x7f+" -> "0x7f..f"
 //@ normalize-stderr: "\d+ bytes" -> "$$BYTES bytes"
diff --git a/tests/ui/consts/recursive-zst-static.rs b/tests/ui/consts/recursive-zst-static.rs
index 853af6d70eb0..003707aeeab6 100644
--- a/tests/ui/consts/recursive-zst-static.rs
+++ b/tests/ui/consts/recursive-zst-static.rs
@@ -1,6 +1,6 @@
 //@ revisions: default unleash
 //@[unleash]compile-flags: -Zunleash-the-miri-inside-of-you
-
+//@ ignore-parallel-frontend  query cycle
 // This test ensures that we do not allow ZST statics to initialize themselves without ever
 // actually creating a value of that type. This is important, as the ZST may have private fields
 // that users can reasonably expect to only get initialized by their own code. Thus unsafe code
diff --git a/tests/ui/consts/required-consts/collect-in-called-fn.rs b/tests/ui/consts/required-consts/collect-in-called-fn.rs
index 2045b8266c79..d07c0927a16a 100644
--- a/tests/ui/consts/required-consts/collect-in-called-fn.rs
+++ b/tests/ui/consts/required-consts/collect-in-called-fn.rs
@@ -4,7 +4,7 @@
 //@[opt] compile-flags: -O
 //! Make sure we detect erroneous constants post-monomorphization even when they are unused. This is
 //! crucial, people rely on it for soundness. (https://github.com/rust-lang/rust/issues/112090)
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-closure.rs b/tests/ui/consts/required-consts/collect-in-dead-closure.rs
index 5f8b6bbb174c..825336e9d3ef 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-closure.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-closure.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-drop.rs b/tests/ui/consts/required-consts/collect-in-dead-drop.rs
index f7293d162df7..fa9b8730c11c 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-drop.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-drop.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.rs b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.rs
index e6be9f56cb7a..a76481b67313 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.rs
@@ -4,7 +4,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.rs b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.rs
index a86902af5267..4fe05db34d78 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.rs b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.rs
index 4cdb27413540..a6132ef1fe07 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.rs
@@ -4,7 +4,7 @@
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
 #![feature(type_alias_impl_trait)]
-
+//@ ignore-parallel-frontend post-monomorphization errors
 mod m {
     struct Fail<T>(T);
     impl<T> Fail<T> {
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn.rs b/tests/ui/consts/required-consts/collect-in-dead-fn.rs
index 0c4795801068..f4627323249d 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.rs b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.rs
index 04544cb41398..8808a4e26f0c 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Late<T>(T);
 impl<T> Late<T> {
     const FAIL: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr.rs b/tests/ui/consts/required-consts/collect-in-dead-fnptr.rs
index 4cdb50f4385a..1a9b99f9868f 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-forget.rs b/tests/ui/consts/required-consts/collect-in-dead-forget.rs
index 7586004116c3..bc717edbe73e 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-forget.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-forget.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This passes without optimizations, so it can (and should) also pass with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!();
diff --git a/tests/ui/consts/required-consts/collect-in-dead-move.rs b/tests/ui/consts/required-consts/collect-in-dead-move.rs
index 4e2d959db32c..05491136e8d5 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-move.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-move.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-dead-vtable.rs b/tests/ui/consts/required-consts/collect-in-dead-vtable.rs
index d4ad73083773..1ca52064a3fd 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-vtable.rs
+++ b/tests/ui/consts/required-consts/collect-in-dead-vtable.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! This fails without optimizations, so it should also fail with optimizations.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.rs b/tests/ui/consts/required-consts/collect-in-promoted-const.rs
index c47572093869..415f22fd05dd 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.rs
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.rs
@@ -3,7 +3,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! Make sure we error on erroneous consts even if they get promoted.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR evaluation panicked: explicit panic
diff --git a/tests/ui/consts/required-consts/interpret-in-const-called-fn.rs b/tests/ui/consts/required-consts/interpret-in-const-called-fn.rs
index 9309457e22a4..2d63c620a038 100644
--- a/tests/ui/consts/required-consts/interpret-in-const-called-fn.rs
+++ b/tests/ui/consts/required-consts/interpret-in-const-called-fn.rs
@@ -2,7 +2,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! Make sure we error on erroneous consts even if they are unused.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR explicit panic
diff --git a/tests/ui/consts/required-consts/interpret-in-promoted.rs b/tests/ui/consts/required-consts/interpret-in-promoted.rs
index b223e6d16aa1..cbb1a309006c 100644
--- a/tests/ui/consts/required-consts/interpret-in-promoted.rs
+++ b/tests/ui/consts/required-consts/interpret-in-promoted.rs
@@ -2,7 +2,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend post-monomorphization errors
 //! Make sure we evaluate const fn calls even if they get promoted and their result ignored.
 
 const unsafe fn ub() {
diff --git a/tests/ui/consts/required-consts/interpret-in-static.rs b/tests/ui/consts/required-consts/interpret-in-static.rs
index 19ad6be1c9fa..edc7b1d01fd6 100644
--- a/tests/ui/consts/required-consts/interpret-in-static.rs
+++ b/tests/ui/consts/required-consts/interpret-in-static.rs
@@ -2,7 +2,7 @@
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
 //! Make sure we error on erroneous consts even if they are unused.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 struct Fail<T>(T);
 impl<T> Fail<T> {
     const C: () = panic!(); //~ERROR explicit panic
diff --git a/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.rs b/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.rs
index 9a72b65da883..3324444d3351 100644
--- a/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.rs
+++ b/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.rs
@@ -1,6 +1,6 @@
 // Test a supertrait cycle where the first trait we find (`A`) is not
 // a direct participant in the cycle.
-
+//@ ignore-parallel-frontend query cycle
 trait A: B {
 }
 
diff --git a/tests/ui/cycle-trait/issue-12511.rs b/tests/ui/cycle-trait/issue-12511.rs
index ea83e3fd9dc2..1d33b03c57a2 100644
--- a/tests/ui/cycle-trait/issue-12511.rs
+++ b/tests/ui/cycle-trait/issue-12511.rs
@@ -1,7 +1,7 @@
 trait T1 : T2 {
 //~^ ERROR cycle detected
 }
-
+//@ ignore-parallel-frontend query cycle
 trait T2 : T1 {
 }
 
diff --git a/tests/ui/delegation/unsupported.rs b/tests/ui/delegation/unsupported.rs
index adb798aab71d..af3b87ee7c8c 100644
--- a/tests/ui/delegation/unsupported.rs
+++ b/tests/ui/delegation/unsupported.rs
@@ -2,7 +2,7 @@
 //@ ignore-compare-mode-next-solver (explicit revisions)
 //@[next] compile-flags: -Znext-solver
 //@ check-fail
-
+//@ ignore-parallel-frontend query cycle
 // Next solver revision included because of trait-system-refactor-initiative#234.
 // If we end up in a query cycle, it should be okay as long as results are the same.
 
diff --git a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
index 9a7a10529fa6..e04975f9c99b 100644
--- a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
+++ b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
@@ -1,6 +1,6 @@
 // Test that when a trait impl changes, fns whose body uses that trait
 // must also be recompiled.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/dep-graph/dep-graph-caller-callee.rs b/tests/ui/dep-graph/dep-graph-caller-callee.rs
index b1318a169d9c..df959a93c9c2 100644
--- a/tests/ui/dep-graph/dep-graph-caller-callee.rs
+++ b/tests/ui/dep-graph/dep-graph-caller-callee.rs
@@ -3,7 +3,7 @@
 
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
-
+//@ ignore-parallel-frontend dep graph
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/dep-graph/dep-graph-struct-signature.rs b/tests/ui/dep-graph/dep-graph-struct-signature.rs
index eea81b26f9f6..080a1b5c583d 100644
--- a/tests/ui/dep-graph/dep-graph-struct-signature.rs
+++ b/tests/ui/dep-graph/dep-graph-struct-signature.rs
@@ -1,6 +1,6 @@
 // Test cases where a changing struct appears in the signature of fns
 // and methods.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
index eab4c7921057..397a8c6a39d4 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
+++ b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
@@ -1,6 +1,6 @@
 // Test that adding an impl to a trait `Foo` DOES affect functions
 // that only use `Bar` if they have methods in common.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl.rs b/tests/ui/dep-graph/dep-graph-trait-impl.rs
index 5cf0d34e0070..80925ddfe0c0 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl.rs
+++ b/tests/ui/dep-graph/dep-graph-trait-impl.rs
@@ -1,6 +1,6 @@
 // Test that when a trait impl changes, fns whose body uses that trait
 // must also be recompiled.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/dep-graph/dep-graph-type-alias.rs b/tests/ui/dep-graph/dep-graph-type-alias.rs
index 30cef4b27ef0..1796ebda1fc7 100644
--- a/tests/ui/dep-graph/dep-graph-type-alias.rs
+++ b/tests/ui/dep-graph/dep-graph-type-alias.rs
@@ -1,5 +1,5 @@
 // Test that changing what a `type` points to does not go unnoticed.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/dep-graph/dep-graph-variance-alias.rs b/tests/ui/dep-graph/dep-graph-variance-alias.rs
index 8a67fe6d7271..5e86e77b24a2 100644
--- a/tests/ui/dep-graph/dep-graph-variance-alias.rs
+++ b/tests/ui/dep-graph/dep-graph-variance-alias.rs
@@ -1,6 +1,6 @@
 // Test that changing what a `type` points to does not go unnoticed
 // by the variance analysis.
-
+//@ ignore-parallel-frontend dep graph
 //@ incremental
 //@ compile-flags: -Z query-dep-graph
 
diff --git a/tests/ui/error-emitter/multiline-removal-suggestion.rs b/tests/ui/error-emitter/multiline-removal-suggestion.rs
index 72e9ea357c9e..36127ab13123 100644
--- a/tests/ui/error-emitter/multiline-removal-suggestion.rs
+++ b/tests/ui/error-emitter/multiline-removal-suggestion.rs
@@ -56,3 +56,4 @@ fn bay() -> Vec<(bool, HashSet<u8>)> {
 		.collect()
 }
 fn main() {}
+//@ ignore-parallel-frontend invalid svg(multiple threads trying to write to the same file)
diff --git a/tests/ui/generic-associated-types/unknown-lifetime-ice-119827.rs b/tests/ui/generic-associated-types/unknown-lifetime-ice-119827.rs
index f74d7cf28111..94f832f494a2 100644
--- a/tests/ui/generic-associated-types/unknown-lifetime-ice-119827.rs
+++ b/tests/ui/generic-associated-types/unknown-lifetime-ice-119827.rs
@@ -4,7 +4,7 @@ trait Foo {
     where
         Self: 'c;
 }
-
+//@ ignore-parallel-frontend query cycle
 impl Foo for Box<dyn Foo> {}
 
 fn main() {}
diff --git a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
index c2fab7d4c5f6..5f9fe0d141ff 100644
--- a/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
+++ b/tests/ui/impl-trait/auto-trait-leakage/auto-trait-leak.rs
@@ -1,6 +1,6 @@
 use std::cell::Cell;
 use std::rc::Rc;
-
+//@ ignore-parallel-frontend query cycle
 fn send<T: Send>(_: T) {}
 
 fn main() {}
diff --git a/tests/ui/infinite/infinite-trait-alias-recursion.rs b/tests/ui/infinite/infinite-trait-alias-recursion.rs
index 0bd4624de3f1..df884cca22b7 100644
--- a/tests/ui/infinite/infinite-trait-alias-recursion.rs
+++ b/tests/ui/infinite/infinite-trait-alias-recursion.rs
@@ -1,5 +1,5 @@
 #![feature(trait_alias)]
-
+//@ ignore-parallel-frontend query cycle
 trait T1 = T2;
 //~^ ERROR cycle detected when computing the implied predicates of `T1`
 
diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs b/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs
index cf9ea0db4cbe..6a43c4ac7872 100644
--- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs
+++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.rs
@@ -1,5 +1,5 @@
 //@ revisions: feature gated
-
+//@ ignore-parallel-frontend query cycle
 #![cfg_attr(feature, feature(lazy_type_alias))]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/inline-const/required-const.rs b/tests/ui/inline-const/required-const.rs
index 8f640e933d01..437652532ec5 100644
--- a/tests/ui/inline-const/required-const.rs
+++ b/tests/ui/inline-const/required-const.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ compile-flags: -Zmir-opt-level=3
-
+//@ ignore-parallel-frontend post-monomorphization errors
 fn foo<T>() {
     if false {
         const { panic!() } //~ ERROR E0080
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
index ed15f5bba962..d2e5e158b722 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
@@ -1,6 +1,6 @@
 //@ normalize-stderr: "[[:xdigit:]]{2} __ ([[:xdigit:]]{2}\s){2}" -> "HEX_DUMP"
 #![feature(core_intrinsics)]
-
+//@ ignore-parallel-frontend different alloc ids
 const RAW_EQ_PADDING: bool = unsafe {
     std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16))
 //~^ ERROR requires initialized memory
diff --git a/tests/ui/issues/issue-17252.rs b/tests/ui/issues/issue-17252.rs
index 5941e10f8b06..dd002bfd187a 100644
--- a/tests/ui/issues/issue-17252.rs
+++ b/tests/ui/issues/issue-17252.rs
@@ -1,5 +1,5 @@
 const FOO: usize = FOO; //~ ERROR E0391
-
+//@ ignore-parallel-frontend query cycle
 fn main() {
     let _x: [u8; FOO]; // caused stack overflow prior to fix
     let _y: usize = 1 + {
diff --git a/tests/ui/issues/issue-34373.rs b/tests/ui/issues/issue-34373.rs
index a9bd79f6830b..02e1048e5a33 100644
--- a/tests/ui/issues/issue-34373.rs
+++ b/tests/ui/issues/issue-34373.rs
@@ -1,5 +1,5 @@
 #![allow(warnings)]
-
+//@ ignore-parallel-frontend query cycle
 trait Trait<T> {
     fn foo(_: T) {}
 }
diff --git a/tests/ui/lint/large_assignments/copy_into_box_rc_arc.rs b/tests/ui/lint/large_assignments/copy_into_box_rc_arc.rs
index dfa0b8015d03..a8e23c0246ee 100644
--- a/tests/ui/lint/large_assignments/copy_into_box_rc_arc.rs
+++ b/tests/ui/lint/large_assignments/copy_into_box_rc_arc.rs
@@ -3,7 +3,7 @@
 #![move_size_limit = "1000"]
 //@ build-fail
 //@ only-64bit
-
+//@ ignore-parallel-frontend post-monomorphization errors
 //@ edition:2018
 //@ compile-flags: -Zmir-opt-level=1
 
diff --git a/tests/ui/lint/large_assignments/copy_into_fn.rs b/tests/ui/lint/large_assignments/copy_into_fn.rs
index 5222e833bcc8..8f8e7f0822bb 100644
--- a/tests/ui/lint/large_assignments/copy_into_fn.rs
+++ b/tests/ui/lint/large_assignments/copy_into_fn.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-
+//@ ignore-parallel-frontend post-monomorphization errors
 #![feature(large_assignments)]
 #![move_size_limit = "1000"]
 #![deny(large_assignments)]
diff --git a/tests/ui/lint/large_assignments/inline_mir.rs b/tests/ui/lint/large_assignments/inline_mir.rs
index d16aae6ab145..68c5de4902f3 100644
--- a/tests/ui/lint/large_assignments/inline_mir.rs
+++ b/tests/ui/lint/large_assignments/inline_mir.rs
@@ -13,7 +13,7 @@
 //! ```
 //!
 //! We want the diagnostics to point to the relevant user code.
-
+//@ ignore-parallel-frontend post-monomorphization errors
 //@ build-fail
 //@ compile-flags: -Zmir-opt-level=1 -Zinline-mir
 
diff --git a/tests/ui/lint/large_assignments/large_future.rs b/tests/ui/lint/large_assignments/large_future.rs
index 28c358bdbf08..1be66f16313b 100644
--- a/tests/ui/lint/large_assignments/large_future.rs
+++ b/tests/ui/lint/large_assignments/large_future.rs
@@ -5,7 +5,7 @@
 //@ only-64bit
 //@ revisions: attribute option
 //@ [option]compile-flags: -Zmove-size-limit=1000
-
+//@ ignore-parallel-frontend post-monomorphization errors
 //@ edition:2018
 //@ compile-flags: -Zmir-opt-level=0
 
diff --git a/tests/ui/lint/large_assignments/move_into_fn.rs b/tests/ui/lint/large_assignments/move_into_fn.rs
index b3b2160ca36e..1e793a082e3e 100644
--- a/tests/ui/lint/large_assignments/move_into_fn.rs
+++ b/tests/ui/lint/large_assignments/move_into_fn.rs
@@ -1,5 +1,5 @@
 //@ build-fail
-
+//@ ignore-parallel-frontend post-monomorphization errors
 #![feature(large_assignments)]
 #![move_size_limit = "1000"]
 #![deny(large_assignments)]
diff --git a/tests/ui/lint/non-snake-case/lint-uppercase-variables.rs b/tests/ui/lint/non-snake-case/lint-uppercase-variables.rs
index aefbe63606a1..be3450494aaf 100644
--- a/tests/ui/lint/non-snake-case/lint-uppercase-variables.rs
+++ b/tests/ui/lint/non-snake-case/lint-uppercase-variables.rs
@@ -1,7 +1,7 @@
 #![warn(unused)]
 #![allow(dead_code)]
 #![deny(non_snake_case)]
-
+//@ ignore-parallel-frontend `note`s on different source lines
 mod foo {
     pub enum Foo { Foo }
 }
diff --git a/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.rs b/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.rs
index ad85a777ef9a..3b8cbe99a65e 100644
--- a/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.rs
+++ b/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: --force-warn unused_variables
 //@ compile-flags: --force-warn unused_mut
 //@ check-pass
-
+//@ ignore-parallel-frontend `note`s on different source lines
 fn expect_early_pass_lint() {
     #[expect(while_true)]
     while true {
diff --git a/tests/ui/liveness/liveness-unused.rs b/tests/ui/liveness/liveness-unused.rs
index a291d2489695..95345c22b041 100644
--- a/tests/ui/liveness/liveness-unused.rs
+++ b/tests/ui/liveness/liveness-unused.rs
@@ -3,7 +3,7 @@
 #![deny(unused_assignments)]
 #![allow(dead_code, non_camel_case_types, trivial_numeric_casts, dropping_copy_types)]
 #![feature(intrinsics)]
-
+//@ ignore-parallel-frontend `note`s on different source lines
 use std::ops::AddAssign;
 
 fn f1(x: isize) {
diff --git a/tests/ui/pattern/non-structural-match-types-cycle-err.rs b/tests/ui/pattern/non-structural-match-types-cycle-err.rs
index a8e494c35b0c..3bc1964eb21f 100644
--- a/tests/ui/pattern/non-structural-match-types-cycle-err.rs
+++ b/tests/ui/pattern/non-structural-match-types-cycle-err.rs
@@ -1,5 +1,5 @@
 //@ edition:2021
-
+//@ ignore-parallel-frontend query cycle
 struct AnyOption<T>(T);
 impl<T> AnyOption<T> {
     const NONE: Option<T> = None;
diff --git a/tests/ui/recursion/issue-23302-3.rs b/tests/ui/recursion/issue-23302-3.rs
index da75f3307988..2e29433ae22d 100644
--- a/tests/ui/recursion/issue-23302-3.rs
+++ b/tests/ui/recursion/issue-23302-3.rs
@@ -1,5 +1,5 @@
 const A: i32 = B; //~ ERROR cycle detected
-
+//@ ignore-parallel-frontend query cycle
 const B: i32 = A;
 
 fn main() { }
diff --git a/tests/ui/resolve/proc_macro_generated_packed.rs b/tests/ui/resolve/proc_macro_generated_packed.rs
index a8175895af04..e35f50911663 100644
--- a/tests/ui/resolve/proc_macro_generated_packed.rs
+++ b/tests/ui/resolve/proc_macro_generated_packed.rs
@@ -1,6 +1,6 @@
 //! This test ICEs because the `repr(packed)` attribute
 //! was generated by a proc macro, so `#[derive]` didn't see it.
-
+//@ ignore-parallel-frontend failed to collect active jobs
 //@proc-macro: proc_macro_generate_packed.rs
 //@known-bug: #120873
 //@ failure-status: 101
diff --git a/tests/ui/resolve/resolve-self-in-impl.rs b/tests/ui/resolve/resolve-self-in-impl.rs
index d0872d1b76f2..c05a7146fe08 100644
--- a/tests/ui/resolve/resolve-self-in-impl.rs
+++ b/tests/ui/resolve/resolve-self-in-impl.rs
@@ -1,5 +1,5 @@
 #![feature(associated_type_defaults)]
-
+//@ ignore-parallel-frontend query cycle
 struct S<T = u8>(T);
 trait Tr<T = u8> {
     type A = ();
diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed
index 435857224ac3..e7c10f71b831 100644
--- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed
+++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed
@@ -1,7 +1,7 @@
 //@ edition:2018
 //@ aux-build:edition-lint-infer-outlives-macro.rs
 //@ run-rustfix
-
+//@ ignore-parallel-frontend `note`s on different source lines
 #![deny(explicit_outlives_requirements)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.rs b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.rs
index 6c879231a168..a39d766263e9 100644
--- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.rs
+++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.rs
@@ -1,7 +1,7 @@
 //@ edition:2018
 //@ aux-build:edition-lint-infer-outlives-macro.rs
 //@ run-rustfix
-
+//@ ignore-parallel-frontend `note`s on different source lines
 #![deny(explicit_outlives_requirements)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/simd/const-err-trumps-simd-err.rs b/tests/ui/simd/const-err-trumps-simd-err.rs
index 33f0abb06f3e..282d5dabf72f 100644
--- a/tests/ui/simd/const-err-trumps-simd-err.rs
+++ b/tests/ui/simd/const-err-trumps-simd-err.rs
@@ -1,6 +1,6 @@
 //@build-fail
 //@ dont-require-annotations: NOTE
-
+//@ ignore-parallel-frontend post-monomorphization errors
 //! Make sure that monomorphization-time const errors from `static_assert` take priority over the
 //! error from simd_extract. Basically this checks that if a const fails to evaluate in some
 //! function, we don't bother codegen'ing the function.
diff --git a/tests/ui/structs/default-field-values/post-mono.rs b/tests/ui/structs/default-field-values/post-mono.rs
index 68dfa391bb48..57092083ca10 100644
--- a/tests/ui/structs/default-field-values/post-mono.rs
+++ b/tests/ui/structs/default-field-values/post-mono.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 //@ revisions: direct indirect
-
+//@ ignore-parallel-frontend post-monomorphization errors
 #![feature(default_field_values)]
 
 struct Z<const X: usize> {
diff --git a/tests/ui/traits/alias/infinite_normalization.rs b/tests/ui/traits/alias/infinite_normalization.rs
index 848afc1efb23..9e3b7df7085b 100644
--- a/tests/ui/traits/alias/infinite_normalization.rs
+++ b/tests/ui/traits/alias/infinite_normalization.rs
@@ -2,7 +2,7 @@
 //! recursion during normalization.
 //!
 //! issue: https://github.com/rust-lang/rust/issues/133901
-
+//@ ignore-parallel-frontend query cycle
 #![feature(trait_alias)]
 fn foo<T: Baz<i32>>() {}
 trait Baz<A> = Baz<Option<A>>;
diff --git a/tests/ui/type/pattern_types/validity.rs b/tests/ui/type/pattern_types/validity.rs
index 432aacb9be3f..8323049188db 100644
--- a/tests/ui/type/pattern_types/validity.rs
+++ b/tests/ui/type/pattern_types/validity.rs
@@ -1,7 +1,7 @@
 //! Check that pattern types have their validity checked
 // Strip out raw byte dumps to make tests platform-independent:
 //@ normalize-stderr: "([[:xdigit:]]{2}\s){4,8}\s+│\s.{4,8}" -> "HEX_DUMP"
-
+//@ ignore-parallel-frontend different alloc ids
 #![feature(pattern_types, const_trait_impl, pattern_type_range_trait)]
 #![feature(pattern_type_macro)]
 
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
index f2b9f037ea5f..1948e76af7ec 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
@@ -6,7 +6,7 @@ trait Foo<const N: Bar<2>> {
     //~| ERROR cycle detected when computing type of `Foo::N`
     fn func() {}
 }
-
+//@ ignore-parallel-frontend query cycle
 trait Bar<const M: Foo<2>> {}
 //~^ WARN trait objects without an explicit `dyn` are deprecated
 //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!

From 72732f201385d5e42e66c53bb20cb75eb7e84030 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 09:57:38 +0000
Subject: [PATCH 0555/1059] move `tests/ui/invalid` tests to new folders

---
 src/tools/tidy/src/issues.txt                               | 1 -
 tests/ui/README.md                                          | 6 ------
 tests/ui/{invalid => attributes/inline}/invalid-inline.rs   | 0
 .../ui/{invalid => attributes/inline}/invalid-inline.stderr | 0
 tests/ui/{invalid => attributes}/invalid-crate-type.rs      | 0
 tests/ui/{invalid => attributes}/invalid-crate-type.stderr  | 0
 .../invalid-debugger-visualizer-option.rs                   | 0
 .../invalid-debugger-visualizer-option.stderr               | 0
 .../invalid-debugger-visualizer-target.rs                   | 0
 .../invalid-debugger-visualizer-target.stderr               | 0
 .../invalid_rustc_layout_scalar_valid_range.rs              | 0
 .../invalid_rustc_layout_scalar_valid_range.stderr          | 0
 .../ui/{invalid => const-generics}/invalid-path-in-const.rs | 0
 .../invalid-path-in-const.stderr                            | 0
 .../invalid-rustc_legacy_const_generics-arguments.rs        | 0
 .../invalid-rustc_legacy_const_generics-arguments.stderr    | 0
 .../invalid-rustc_legacy_const_generics-issue-123077.rs     | 0
 .../invalid-rustc_legacy_const_generics-issue-123077.stderr | 0
 tests/ui/invalid/foo.natvis.xml                             | 1 -
 .../layout-type-err-nested-structs-114435.rs}               | 0
 .../layout-type-err-nested-structs-114435.stderr}           | 0
 tests/ui/{invalid => macros}/invalid-macro-matcher.rs       | 0
 tests/ui/{invalid => macros}/invalid-macro-matcher.stderr   | 0
 23 files changed, 8 deletions(-)
 rename tests/ui/{invalid => attributes/inline}/invalid-inline.rs (100%)
 rename tests/ui/{invalid => attributes/inline}/invalid-inline.stderr (100%)
 rename tests/ui/{invalid => attributes}/invalid-crate-type.rs (100%)
 rename tests/ui/{invalid => attributes}/invalid-crate-type.stderr (100%)
 rename tests/ui/{invalid => attributes}/invalid-debugger-visualizer-option.rs (100%)
 rename tests/ui/{invalid => attributes}/invalid-debugger-visualizer-option.stderr (100%)
 rename tests/ui/{invalid => attributes}/invalid-debugger-visualizer-target.rs (100%)
 rename tests/ui/{invalid => attributes}/invalid-debugger-visualizer-target.stderr (100%)
 rename tests/ui/{invalid => attributes}/invalid_rustc_layout_scalar_valid_range.rs (100%)
 rename tests/ui/{invalid => attributes}/invalid_rustc_layout_scalar_valid_range.stderr (100%)
 rename tests/ui/{invalid => const-generics}/invalid-path-in-const.rs (100%)
 rename tests/ui/{invalid => const-generics}/invalid-path-in-const.stderr (100%)
 rename tests/ui/{invalid => const-generics}/invalid-rustc_legacy_const_generics-arguments.rs (100%)
 rename tests/ui/{invalid => const-generics}/invalid-rustc_legacy_const_generics-arguments.stderr (100%)
 rename tests/ui/{invalid => const-generics}/invalid-rustc_legacy_const_generics-issue-123077.rs (100%)
 rename tests/ui/{invalid => const-generics}/invalid-rustc_legacy_const_generics-issue-123077.stderr (100%)
 delete mode 100644 tests/ui/invalid/foo.natvis.xml
 rename tests/ui/{invalid/issue-114435-layout-type-err.rs => layout/layout-type-err-nested-structs-114435.rs} (100%)
 rename tests/ui/{invalid/issue-114435-layout-type-err.stderr => layout/layout-type-err-nested-structs-114435.stderr} (100%)
 rename tests/ui/{invalid => macros}/invalid-macro-matcher.rs (100%)
 rename tests/ui/{invalid => macros}/invalid-macro-matcher.stderr (100%)

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 668a8abf1d8b..112a0519016a 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1358,7 +1358,6 @@ ui/infinite/issue-41731-infinite-macro-print.rs
 ui/infinite/issue-41731-infinite-macro-println.rs
 ui/intrinsics/issue-28575.rs
 ui/intrinsics/issue-84297-reifying-copy.rs
-ui/invalid/issue-114435-layout-type-err.rs
 ui/iterators/issue-28098.rs
 ui/iterators/issue-58952-filter-type-length.rs
 ui/lang-items/issue-83471.rs
diff --git a/tests/ui/README.md b/tests/ui/README.md
index 9911353af5cd..121d2db11c2c 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -760,12 +760,6 @@ Tests for rustc-internal lints.
 
 Tests for the `{std,core}::intrinsics`, internal implementation detail.
 
-## `tests/ui/invalid/`
-
-Various tests related to rejecting invalid inputs.
-
-**FIXME**: This is rather uninformative, possibly rehome into more meaningful directories.
-
 ## `tests/ui/io-checks/`: Input Output
 
 Tests for I/O related behaviour, covering stdout/stderr handling and error propagation.
diff --git a/tests/ui/invalid/invalid-inline.rs b/tests/ui/attributes/inline/invalid-inline.rs
similarity index 100%
rename from tests/ui/invalid/invalid-inline.rs
rename to tests/ui/attributes/inline/invalid-inline.rs
diff --git a/tests/ui/invalid/invalid-inline.stderr b/tests/ui/attributes/inline/invalid-inline.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-inline.stderr
rename to tests/ui/attributes/inline/invalid-inline.stderr
diff --git a/tests/ui/invalid/invalid-crate-type.rs b/tests/ui/attributes/invalid-crate-type.rs
similarity index 100%
rename from tests/ui/invalid/invalid-crate-type.rs
rename to tests/ui/attributes/invalid-crate-type.rs
diff --git a/tests/ui/invalid/invalid-crate-type.stderr b/tests/ui/attributes/invalid-crate-type.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-crate-type.stderr
rename to tests/ui/attributes/invalid-crate-type.stderr
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-option.rs b/tests/ui/attributes/invalid-debugger-visualizer-option.rs
similarity index 100%
rename from tests/ui/invalid/invalid-debugger-visualizer-option.rs
rename to tests/ui/attributes/invalid-debugger-visualizer-option.rs
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-option.stderr b/tests/ui/attributes/invalid-debugger-visualizer-option.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-debugger-visualizer-option.stderr
rename to tests/ui/attributes/invalid-debugger-visualizer-option.stderr
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.rs b/tests/ui/attributes/invalid-debugger-visualizer-target.rs
similarity index 100%
rename from tests/ui/invalid/invalid-debugger-visualizer-target.rs
rename to tests/ui/attributes/invalid-debugger-visualizer-target.rs
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr b/tests/ui/attributes/invalid-debugger-visualizer-target.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-debugger-visualizer-target.stderr
rename to tests/ui/attributes/invalid-debugger-visualizer-target.stderr
diff --git a/tests/ui/invalid/invalid_rustc_layout_scalar_valid_range.rs b/tests/ui/attributes/invalid_rustc_layout_scalar_valid_range.rs
similarity index 100%
rename from tests/ui/invalid/invalid_rustc_layout_scalar_valid_range.rs
rename to tests/ui/attributes/invalid_rustc_layout_scalar_valid_range.rs
diff --git a/tests/ui/invalid/invalid_rustc_layout_scalar_valid_range.stderr b/tests/ui/attributes/invalid_rustc_layout_scalar_valid_range.stderr
similarity index 100%
rename from tests/ui/invalid/invalid_rustc_layout_scalar_valid_range.stderr
rename to tests/ui/attributes/invalid_rustc_layout_scalar_valid_range.stderr
diff --git a/tests/ui/invalid/invalid-path-in-const.rs b/tests/ui/const-generics/invalid-path-in-const.rs
similarity index 100%
rename from tests/ui/invalid/invalid-path-in-const.rs
rename to tests/ui/const-generics/invalid-path-in-const.rs
diff --git a/tests/ui/invalid/invalid-path-in-const.stderr b/tests/ui/const-generics/invalid-path-in-const.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-path-in-const.stderr
rename to tests/ui/const-generics/invalid-path-in-const.stderr
diff --git a/tests/ui/invalid/invalid-rustc_legacy_const_generics-arguments.rs b/tests/ui/const-generics/invalid-rustc_legacy_const_generics-arguments.rs
similarity index 100%
rename from tests/ui/invalid/invalid-rustc_legacy_const_generics-arguments.rs
rename to tests/ui/const-generics/invalid-rustc_legacy_const_generics-arguments.rs
diff --git a/tests/ui/invalid/invalid-rustc_legacy_const_generics-arguments.stderr b/tests/ui/const-generics/invalid-rustc_legacy_const_generics-arguments.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-rustc_legacy_const_generics-arguments.stderr
rename to tests/ui/const-generics/invalid-rustc_legacy_const_generics-arguments.stderr
diff --git a/tests/ui/invalid/invalid-rustc_legacy_const_generics-issue-123077.rs b/tests/ui/const-generics/invalid-rustc_legacy_const_generics-issue-123077.rs
similarity index 100%
rename from tests/ui/invalid/invalid-rustc_legacy_const_generics-issue-123077.rs
rename to tests/ui/const-generics/invalid-rustc_legacy_const_generics-issue-123077.rs
diff --git a/tests/ui/invalid/invalid-rustc_legacy_const_generics-issue-123077.stderr b/tests/ui/const-generics/invalid-rustc_legacy_const_generics-issue-123077.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-rustc_legacy_const_generics-issue-123077.stderr
rename to tests/ui/const-generics/invalid-rustc_legacy_const_generics-issue-123077.stderr
diff --git a/tests/ui/invalid/foo.natvis.xml b/tests/ui/invalid/foo.natvis.xml
deleted file mode 100644
index c341a403902b..000000000000
--- a/tests/ui/invalid/foo.natvis.xml
+++ /dev/null
@@ -1 +0,0 @@
-<!-- empty -->
diff --git a/tests/ui/invalid/issue-114435-layout-type-err.rs b/tests/ui/layout/layout-type-err-nested-structs-114435.rs
similarity index 100%
rename from tests/ui/invalid/issue-114435-layout-type-err.rs
rename to tests/ui/layout/layout-type-err-nested-structs-114435.rs
diff --git a/tests/ui/invalid/issue-114435-layout-type-err.stderr b/tests/ui/layout/layout-type-err-nested-structs-114435.stderr
similarity index 100%
rename from tests/ui/invalid/issue-114435-layout-type-err.stderr
rename to tests/ui/layout/layout-type-err-nested-structs-114435.stderr
diff --git a/tests/ui/invalid/invalid-macro-matcher.rs b/tests/ui/macros/invalid-macro-matcher.rs
similarity index 100%
rename from tests/ui/invalid/invalid-macro-matcher.rs
rename to tests/ui/macros/invalid-macro-matcher.rs
diff --git a/tests/ui/invalid/invalid-macro-matcher.stderr b/tests/ui/macros/invalid-macro-matcher.stderr
similarity index 100%
rename from tests/ui/invalid/invalid-macro-matcher.stderr
rename to tests/ui/macros/invalid-macro-matcher.stderr

From d9bd396c29b25b4af2f2e40a1d35732eff55cb49 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 17 Mar 2026 10:26:29 +0000
Subject: [PATCH 0556/1059] Workaround for incorrect target cpu rename in
 Cranelift

---
 src/lib.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index 82c2e91b4b0f..9ed882c0dc26 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -345,7 +345,8 @@ fn build_isa(sess: &Session, jit: bool) -> Arc<dyn TargetIsa + 'static> {
             if target_triple.architecture == target_lexicon::Architecture::X86_64 {
                 // Only set the target cpu on x86_64 as Cranelift is missing
                 // the target cpu list for most other targets.
-                builder.enable(sess.target.cpu.as_ref()).unwrap();
+                // FIXME remove the replace once bytecodealliance/wasmtime#12792 lands
+                builder.enable(&sess.target.cpu.replace("-", "_")).unwrap();
             }
             builder
         }

From b5e53dc790bc594b69020af262bb796fd56702cd Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Mon, 16 Mar 2026 12:29:12 +0300
Subject: [PATCH 0557/1059] Cleanup from_cycle_error::variances_of.

variances_of currently used search_for_cycle_permutation, which can fail and abort when constructed error result value does not match query input.
This commit changes variances_of to receive a def_id which means it can compute a value without using search_for_cycle_permutation, avoiding the possible abort.

Fixes #127971
---
 .../rustc_query_impl/src/from_cycle_error.rs  | 29 ++++---------------
 1 file changed, 6 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index f2a2e4f82c0b..317b2482c05c 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -8,12 +8,12 @@
 use rustc_errors::{Applicability, Diag, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
+use rustc_middle::bug;
 use rustc_middle::queries::{QueryVTables, TaggedQueryKey};
 use rustc_middle::query::CycleError;
 use rustc_middle::query::erase::erase_val;
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{ErrorGuaranteed, Span};
 
@@ -31,9 +31,9 @@ pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
     vtables.check_representability_adt_ty.value_from_cycle_error =
         |tcx, _, cycle, _err| check_representability(tcx, cycle);
 
-    vtables.variances_of.value_from_cycle_error = |tcx, _, cycle, err| {
+    vtables.variances_of.value_from_cycle_error = |tcx, key, _, err| {
         let _guar = err.delay_as_bug();
-        erase_val(variances_of(tcx, cycle))
+        erase_val(variances_of(tcx, key))
     };
 
     vtables.layout_of.value_from_cycle_error = |tcx, _, cycle, err| {
@@ -103,26 +103,9 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
     guar.raise_fatal()
 }
 
-fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> &'tcx [ty::Variance] {
-    search_for_cycle_permutation(
-        &cycle_error.cycle,
-        |cycle| {
-            if let Some(frame) = cycle.get(0)
-                && let TaggedQueryKey::variances_of(def_id) = frame.node.tagged_key
-            {
-                let n = tcx.generics_of(def_id).own_params.len();
-                ControlFlow::Break(tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n)))
-            } else {
-                ControlFlow::Continue(())
-            }
-        },
-        || {
-            span_bug!(
-                cycle_error.usage.as_ref().unwrap().span,
-                "only `variances_of` returns `&[ty::Variance]`"
-            )
-        },
-    )
+fn variances_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx [ty::Variance] {
+    let n = tcx.generics_of(def_id).own_params.len();
+    tcx.arena.alloc_from_iter(iter::repeat_n(ty::Bivariant, n))
 }
 
 // Take a cycle of `Q` and try `try_cycle` on every permutation, falling back to `otherwise`.

From 15f42e261340158db4e1d59ce7afe8d9283147b9 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Thu, 12 Mar 2026 14:51:08 +0300
Subject: [PATCH 0558/1059] Move `FromDyn` closer to `is_dyn_thread_safe`

---
 compiler/rustc_data_structures/src/marker.rs | 47 ------------------
 compiler/rustc_data_structures/src/sync.rs   | 51 +++++++++++++++++++-
 2 files changed, 50 insertions(+), 48 deletions(-)

diff --git a/compiler/rustc_data_structures/src/marker.rs b/compiler/rustc_data_structures/src/marker.rs
index e2193a97a0f4..997077ac4402 100644
--- a/compiler/rustc_data_structures/src/marker.rs
+++ b/compiler/rustc_data_structures/src/marker.rs
@@ -188,53 +188,6 @@ pub fn assert_dyn_send<T: ?Sized + PointeeSized + DynSend>() {}
 pub fn assert_dyn_send_val<T: ?Sized + PointeeSized + DynSend>(_t: &T) {}
 pub fn assert_dyn_send_sync_val<T: ?Sized + PointeeSized + DynSync + DynSend>(_t: &T) {}
 
-#[derive(Copy, Clone)]
-pub struct FromDyn<T>(T);
-
-impl<T> FromDyn<T> {
-    #[inline(always)]
-    pub fn from(val: T) -> Self {
-        // Check that `sync::is_dyn_thread_safe()` is true on creation so we can
-        // implement `Send` and `Sync` for this structure when `T`
-        // implements `DynSend` and `DynSync` respectively.
-        assert!(crate::sync::is_dyn_thread_safe());
-        FromDyn(val)
-    }
-
-    #[inline(always)]
-    pub fn derive<O>(&self, val: O) -> FromDyn<O> {
-        // We already did the check for `sync::is_dyn_thread_safe()` when creating `Self`
-        FromDyn(val)
-    }
-
-    #[inline(always)]
-    pub fn into_inner(self) -> T {
-        self.0
-    }
-}
-
-// `FromDyn` is `Send` if `T` is `DynSend`, since it ensures that sync::is_dyn_thread_safe() is true.
-unsafe impl<T: DynSend> Send for FromDyn<T> {}
-
-// `FromDyn` is `Sync` if `T` is `DynSync`, since it ensures that sync::is_dyn_thread_safe() is true.
-unsafe impl<T: DynSync> Sync for FromDyn<T> {}
-
-impl<T> std::ops::Deref for FromDyn<T> {
-    type Target = T;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<T> std::ops::DerefMut for FromDyn<T> {
-    #[inline(always)]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
 // A wrapper to convert a struct that is already a `Send` or `Sync` into
 // an instance of `DynSend` and `DynSync`, since the compiler cannot infer
 // it automatically in some cases. (e.g. Box<dyn Send / Sync>)
diff --git a/compiler/rustc_data_structures/src/sync.rs b/compiler/rustc_data_structures/src/sync.rs
index 327c28fd1389..7967b8c9a452 100644
--- a/compiler/rustc_data_structures/src/sync.rs
+++ b/compiler/rustc_data_structures/src/sync.rs
@@ -34,7 +34,7 @@
 pub use self::freeze::{FreezeLock, FreezeReadGuard, FreezeWriteGuard};
 #[doc(no_inline)]
 pub use self::lock::{Lock, LockGuard, Mode};
-pub use self::mode::{is_dyn_thread_safe, set_dyn_thread_safe_mode};
+pub use self::mode::{is_dyn_thread_safe, FromDyn, set_dyn_thread_safe_mode};
 pub use self::parallel::{
     broadcast, par_fns, par_for_each_in, par_join, par_map, parallel_guard, spawn,
     try_par_for_each_in,
@@ -64,6 +64,8 @@ mod atomic {
 mod mode {
     use std::sync::atomic::{AtomicU8, Ordering};
 
+    use crate::sync::{DynSend, DynSync};
+
     const UNINITIALIZED: u8 = 0;
     const DYN_NOT_THREAD_SAFE: u8 = 1;
     const DYN_THREAD_SAFE: u8 = 2;
@@ -99,6 +101,53 @@ pub fn set_dyn_thread_safe_mode(mode: bool) {
         // Check that the mode was either uninitialized or was already set to the requested mode.
         assert!(previous.is_ok() || previous == Err(set));
     }
+
+    #[derive(Copy, Clone)]
+    pub struct FromDyn<T>(T);
+
+    impl<T> FromDyn<T> {
+        #[inline(always)]
+        pub fn from(val: T) -> Self {
+            // Check that `sync::is_dyn_thread_safe()` is true on creation so we can
+            // implement `Send` and `Sync` for this structure when `T`
+            // implements `DynSend` and `DynSync` respectively.
+            assert!(crate::sync::is_dyn_thread_safe());
+            FromDyn(val)
+        }
+
+        #[inline(always)]
+        pub fn derive<O>(&self, val: O) -> FromDyn<O> {
+            // We already did the check for `sync::is_dyn_thread_safe()` when creating `Self`
+            FromDyn(val)
+        }
+
+        #[inline(always)]
+        pub fn into_inner(self) -> T {
+            self.0
+        }
+    }
+
+    // `FromDyn` is `Send` if `T` is `DynSend`, since it ensures that sync::is_dyn_thread_safe() is true.
+    unsafe impl<T: DynSend> Send for FromDyn<T> {}
+
+    // `FromDyn` is `Sync` if `T` is `DynSync`, since it ensures that sync::is_dyn_thread_safe() is true.
+    unsafe impl<T: DynSync> Sync for FromDyn<T> {}
+
+    impl<T> std::ops::Deref for FromDyn<T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl<T> std::ops::DerefMut for FromDyn<T> {
+        #[inline(always)]
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
 }
 
 /// This makes locks panic if they are already held.

From 3973d9f558ae2104b5f7dc75e1cd8a859447634e Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Tue, 17 Mar 2026 14:46:12 +0300
Subject: [PATCH 0559/1059] Remove FromDyn::from and add check_dyn_thread_safe

---
 compiler/rustc_data_structures/src/sync.rs    | 19 +++---
 .../src/sync/parallel.rs                      | 63 +++++++++++--------
 compiler/rustc_interface/src/util.rs          |  9 ++-
 3 files changed, 50 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_data_structures/src/sync.rs b/compiler/rustc_data_structures/src/sync.rs
index 7967b8c9a452..3d5bc8527828 100644
--- a/compiler/rustc_data_structures/src/sync.rs
+++ b/compiler/rustc_data_structures/src/sync.rs
@@ -34,7 +34,9 @@
 pub use self::freeze::{FreezeLock, FreezeReadGuard, FreezeWriteGuard};
 #[doc(no_inline)]
 pub use self::lock::{Lock, LockGuard, Mode};
-pub use self::mode::{is_dyn_thread_safe, FromDyn, set_dyn_thread_safe_mode};
+pub use self::mode::{
+    FromDyn, check_dyn_thread_safe, is_dyn_thread_safe, set_dyn_thread_safe_mode,
+};
 pub use self::parallel::{
     broadcast, par_fns, par_for_each_in, par_join, par_map, parallel_guard, spawn,
     try_par_for_each_in,
@@ -72,6 +74,12 @@ mod mode {
 
     static DYN_THREAD_SAFE_MODE: AtomicU8 = AtomicU8::new(UNINITIALIZED);
 
+    // Whether thread safety is enabled (due to running under multiple threads).
+    #[inline]
+    pub fn check_dyn_thread_safe() -> Option<FromDyn<()>> {
+        is_dyn_thread_safe().then_some(FromDyn(()))
+    }
+
     // Whether thread safety is enabled (due to running under multiple threads).
     #[inline]
     pub fn is_dyn_thread_safe() -> bool {
@@ -106,15 +114,6 @@ pub fn set_dyn_thread_safe_mode(mode: bool) {
     pub struct FromDyn<T>(T);
 
     impl<T> FromDyn<T> {
-        #[inline(always)]
-        pub fn from(val: T) -> Self {
-            // Check that `sync::is_dyn_thread_safe()` is true on creation so we can
-            // implement `Send` and `Sync` for this structure when `T`
-            // implements `DynSend` and `DynSync` respectively.
-            assert!(crate::sync::is_dyn_thread_safe());
-            FromDyn(val)
-        }
-
         #[inline(always)]
         pub fn derive<O>(&self, val: O) -> FromDyn<O> {
             // We already did the check for `sync::is_dyn_thread_safe()` when creating `Self`
diff --git a/compiler/rustc_data_structures/src/sync/parallel.rs b/compiler/rustc_data_structures/src/sync/parallel.rs
index 2ab4a7f75b6b..cbf88efea18d 100644
--- a/compiler/rustc_data_structures/src/sync/parallel.rs
+++ b/compiler/rustc_data_structures/src/sync/parallel.rs
@@ -57,8 +57,8 @@ fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
 }
 
 pub fn spawn(func: impl FnOnce() + DynSend + 'static) {
-    if mode::is_dyn_thread_safe() {
-        let func = FromDyn::from(func);
+    if let Some(proof) = mode::check_dyn_thread_safe() {
+        let func = proof.derive(func);
         rustc_thread_pool::spawn(|| {
             (func.into_inner())();
         });
@@ -73,8 +73,8 @@ pub fn spawn(func: impl FnOnce() + DynSend + 'static) {
 /// Use that for the longest running function for better scheduling.
 pub fn par_fns(funcs: &mut [&mut (dyn FnMut() + DynSend)]) {
     parallel_guard(|guard: &ParallelGuard| {
-        if mode::is_dyn_thread_safe() {
-            let funcs = FromDyn::from(funcs);
+        if let Some(proof) = mode::check_dyn_thread_safe() {
+            let funcs = proof.derive(funcs);
             rustc_thread_pool::scope(|s| {
                 let Some((first, rest)) = funcs.into_inner().split_at_mut_checked(1) else {
                     return;
@@ -84,7 +84,7 @@ pub fn par_fns(funcs: &mut [&mut (dyn FnMut() + DynSend)]) {
                 // order when using a single thread. This ensures the execution order matches
                 // that of a single threaded rustc.
                 for f in rest.iter_mut().rev() {
-                    let f = FromDyn::from(f);
+                    let f = proof.derive(f);
                     s.spawn(|_| {
                         guard.run(|| (f.into_inner())());
                     });
@@ -108,13 +108,13 @@ pub fn par_join<A, B, RA: DynSend, RB: DynSend>(oper_a: A, oper_b: B) -> (RA, RB
     A: FnOnce() -> RA + DynSend,
     B: FnOnce() -> RB + DynSend,
 {
-    if mode::is_dyn_thread_safe() {
-        let oper_a = FromDyn::from(oper_a);
-        let oper_b = FromDyn::from(oper_b);
+    if let Some(proof) = mode::check_dyn_thread_safe() {
+        let oper_a = proof.derive(oper_a);
+        let oper_b = proof.derive(oper_b);
         let (a, b) = parallel_guard(|guard| {
             rustc_thread_pool::join(
-                move || guard.run(move || FromDyn::from(oper_a.into_inner()())),
-                move || guard.run(move || FromDyn::from(oper_b.into_inner()())),
+                move || guard.run(move || proof.derive(oper_a.into_inner()())),
+                move || guard.run(move || proof.derive(oper_b.into_inner()())),
             )
         });
         (a.unwrap().into_inner(), b.unwrap().into_inner())
@@ -127,8 +127,9 @@ fn par_slice<I: DynSend>(
     items: &mut [I],
     guard: &ParallelGuard,
     for_each: impl Fn(&mut I) + DynSync + DynSend,
+    proof: FromDyn<()>,
 ) {
-    let for_each = FromDyn::from(for_each);
+    let for_each = proof.derive(for_each);
     let mut items = for_each.derive(items);
     rustc_thread_pool::scope(|s| {
         let proof = items.derive(());
@@ -150,9 +151,9 @@ pub fn par_for_each_in<I: DynSend, T: IntoIterator<Item = I>>(
     for_each: impl Fn(&I) + DynSync + DynSend,
 ) {
     parallel_guard(|guard| {
-        if mode::is_dyn_thread_safe() {
+        if let Some(proof) = mode::check_dyn_thread_safe() {
             let mut items: Vec<_> = t.into_iter().collect();
-            par_slice(&mut items, guard, |i| for_each(&*i))
+            par_slice(&mut items, guard, |i| for_each(&*i), proof)
         } else {
             t.into_iter().for_each(|i| {
                 guard.run(|| for_each(&i));
@@ -173,16 +174,21 @@ pub fn try_par_for_each_in<T: IntoIterator, E: DynSend>(
     <T as IntoIterator>::Item: DynSend,
 {
     parallel_guard(|guard| {
-        if mode::is_dyn_thread_safe() {
+        if let Some(proof) = mode::check_dyn_thread_safe() {
             let mut items: Vec<_> = t.into_iter().collect();
 
             let error = Mutex::new(None);
 
-            par_slice(&mut items, guard, |i| {
-                if let Err(err) = for_each(&*i) {
-                    *error.lock() = Some(err);
-                }
-            });
+            par_slice(
+                &mut items,
+                guard,
+                |i| {
+                    if let Err(err) = for_each(&*i) {
+                        *error.lock() = Some(err);
+                    }
+                },
+                proof,
+            );
 
             if let Some(err) = error.into_inner() { Err(err) } else { Ok(()) }
         } else {
@@ -196,15 +202,20 @@ pub fn par_map<I: DynSend, T: IntoIterator<Item = I>, R: DynSend, C: FromIterato
     map: impl Fn(I) -> R + DynSync + DynSend,
 ) -> C {
     parallel_guard(|guard| {
-        if mode::is_dyn_thread_safe() {
-            let map = FromDyn::from(map);
+        if let Some(proof) = mode::check_dyn_thread_safe() {
+            let map = proof.derive(map);
 
             let mut items: Vec<(Option<I>, Option<R>)> =
                 t.into_iter().map(|i| (Some(i), None)).collect();
 
-            par_slice(&mut items, guard, |i| {
-                i.1 = Some(map(i.0.take().unwrap()));
-            });
+            par_slice(
+                &mut items,
+                guard,
+                |i| {
+                    i.1 = Some(map(i.0.take().unwrap()));
+                },
+                proof,
+            );
 
             items.into_iter().filter_map(|i| i.1).collect()
         } else {
@@ -214,8 +225,8 @@ pub fn par_map<I: DynSend, T: IntoIterator<Item = I>, R: DynSend, C: FromIterato
 }
 
 pub fn broadcast<R: DynSend>(op: impl Fn(usize) -> R + DynSync) -> Vec<R> {
-    if mode::is_dyn_thread_safe() {
-        let op = FromDyn::from(op);
+    if let Some(proof) = mode::check_dyn_thread_safe() {
+        let op = proof.derive(op);
         let results = rustc_thread_pool::broadcast(|context| op.derive(op(context.index())));
         results.into_iter().map(|r| r.into_inner()).collect()
     } else {
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index c5344ee66cd0..0cd0275f96bb 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -183,7 +183,6 @@ pub(crate) fn run_in_thread_pool_with_globals<
     use std::process;
 
     use rustc_data_structures::defer;
-    use rustc_data_structures::sync::FromDyn;
     use rustc_middle::ty::tls;
     use rustc_query_impl::break_query_cycles;
 
@@ -191,7 +190,7 @@ pub(crate) fn run_in_thread_pool_with_globals<
 
     let registry = sync::Registry::new(std::num::NonZero::new(threads).unwrap());
 
-    if !sync::is_dyn_thread_safe() {
+    let Some(proof) = sync::check_dyn_thread_safe() else {
         return run_in_thread_with_globals(
             thread_stack_size,
             edition,
@@ -204,9 +203,9 @@ pub(crate) fn run_in_thread_pool_with_globals<
                 f(current_gcx, jobserver_proxy)
             },
         );
-    }
+    };
 
-    let current_gcx = FromDyn::from(CurrentGcx::new());
+    let current_gcx = proof.derive(CurrentGcx::new());
     let current_gcx2 = current_gcx.clone();
 
     let proxy = Proxy::new();
@@ -278,7 +277,7 @@ pub(crate) fn run_in_thread_pool_with_globals<
     // `Send` in the parallel compiler.
     rustc_span::create_session_globals_then(edition, extra_symbols, Some(sm_inputs), || {
         rustc_span::with_session_globals(|session_globals| {
-            let session_globals = FromDyn::from(session_globals);
+            let session_globals = proof.derive(session_globals);
             builder
                 .build_scoped(
                     // Initialize each new worker thread when created.

From 0d35d9cf0abdc3d9212d44b42240d6520a905d90 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:46:33 +0530
Subject: [PATCH 0560/1059] add mapping to struct_ syntax_factory constructor
 method

---
 .../src/ast/syntax_factory/constructors.rs    | 30 ++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index d0f14dafe3f0..0eadf6a5116f 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -96,7 +96,35 @@ pub fn struct_(
         generic_param_list: Option<ast::GenericParamList>,
         field_list: ast::FieldList,
     ) -> ast::Struct {
-        make::struct_(visibility, strukt_name, generic_param_list, field_list).clone_for_update()
+        let ast = make::struct_(
+            visibility.clone(),
+            strukt_name.clone(),
+            generic_param_list.clone(),
+            field_list.clone(),
+        )
+        .clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            if let Some(visibility) = visibility {
+                builder.map_node(
+                    visibility.syntax().clone(),
+                    ast.visibility().unwrap().syntax().clone(),
+                );
+            }
+            builder.map_node(strukt_name.syntax().clone(), ast.name().unwrap().syntax().clone());
+            if let Some(generic_param_list) = generic_param_list {
+                builder.map_node(
+                    generic_param_list.syntax().clone(),
+                    ast.generic_param_list().unwrap().syntax().clone(),
+                );
+            }
+            builder
+                .map_node(field_list.syntax().clone(), ast.field_list().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn enum_(

From 51aa24a8a83526e955b1edebd4989b6dede345c1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 17 Mar 2026 12:17:40 +0000
Subject: [PATCH 0561/1059] Rustup to rustc 1.96.0-nightly (3645249d7
 2026-03-16)

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 6789958e3722..aa338e8a8c75 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-10"
+channel = "nightly-2026-03-17"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 7c21a3815f96f6ff06f46c3c786d9f0d92d90162 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:48:08 +0530
Subject: [PATCH 0562/1059] add mapping to enum_ syntax_factory constructor
 method

---
 .../src/ast/syntax_factory/constructors.rs    | 43 ++++++++++++++++++-
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 0eadf6a5116f..29b3894ef3e2 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -136,8 +136,47 @@ pub fn enum_(
         where_clause: Option<ast::WhereClause>,
         variant_list: ast::VariantList,
     ) -> ast::Enum {
-        make::enum_(attrs, visibility, enum_name, generic_param_list, where_clause, variant_list)
-            .clone_for_update()
+        let (attrs, attrs_input) = iterator_input(attrs);
+        let ast = make::enum_(
+            attrs,
+            visibility.clone(),
+            enum_name.clone(),
+            generic_param_list.clone(),
+            where_clause.clone(),
+            variant_list.clone(),
+        )
+        .clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
+            if let Some(visibility) = visibility {
+                builder.map_node(
+                    visibility.syntax().clone(),
+                    ast.visibility().unwrap().syntax().clone(),
+                );
+            }
+            builder.map_node(enum_name.syntax().clone(), ast.name().unwrap().syntax().clone());
+            if let Some(generic_param_list) = generic_param_list {
+                builder.map_node(
+                    generic_param_list.syntax().clone(),
+                    ast.generic_param_list().unwrap().syntax().clone(),
+                );
+            }
+            if let Some(where_clause) = where_clause {
+                builder.map_node(
+                    where_clause.syntax().clone(),
+                    ast.where_clause().unwrap().syntax().clone(),
+                );
+            }
+            builder.map_node(
+                variant_list.syntax().clone(),
+                ast.variant_list().unwrap().syntax().clone(),
+            );
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn unnamed_param(&self, ty: ast::Type) -> ast::Param {

From ea2bebd36006ed1f913f8d076170c002729ae735 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:48:38 +0530
Subject: [PATCH 0563/1059] add mapping to unnamed_param syntax_factory
 constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs      | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 29b3894ef3e2..ae9d7e617493 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -180,7 +180,15 @@ pub fn enum_(
     }
 
     pub fn unnamed_param(&self, ty: ast::Type) -> ast::Param {
-        make::unnamed_param(ty).clone_for_update()
+        let ast = make::unnamed_param(ty.clone()).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn ty_fn_ptr<I: Iterator<Item = Param>>(

From e4625087f8e6c1897934c0223884450c4ca5e675 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 17 Mar 2026 13:19:22 +0100
Subject: [PATCH 0564/1059] update error kind mapping URLs

---
 src/tools/miri/src/shims/io_error.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/shims/io_error.rs b/src/tools/miri/src/shims/io_error.rs
index 91ae448e2165..ec3a2cfe5144 100644
--- a/src/tools/miri/src/shims/io_error.rs
+++ b/src/tools/miri/src/shims/io_error.rs
@@ -56,7 +56,7 @@ fn from(value: Scalar) -> Self {
 }
 
 // This mapping should match `decode_error_kind` in
-// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/pal/unix/mod.rs>.
+// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/io/error/unix.rs>.
 const UNIX_IO_ERROR_TABLE: &[(&str, std::io::ErrorKind)] = {
     use std::io::ErrorKind::*;
     &[
@@ -103,7 +103,7 @@ fn from(value: Scalar) -> Self {
     ]
 };
 // This mapping should match `decode_error_kind` in
-// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/pal/windows/mod.rs>.
+// <https://github.com/rust-lang/rust/blob/HEAD/library/std/src/sys/io/error/windows.rs>.
 const WINDOWS_IO_ERROR_TABLE: &[(&str, std::io::ErrorKind)] = {
     use std::io::ErrorKind::*;
     // It's common for multiple error codes to map to the same io::ErrorKind. We have all for the

From 9c6a66d2beda94bee361edc3eb0b660234df7f4b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:49:36 +0530
Subject: [PATCH 0565/1059] add mapping to ty_fn_ptr syntax_factory constructor
 method

---
 .../src/ast/syntax_factory/constructors.rs    | 22 ++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index ae9d7e617493..4570502b1bec 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -198,7 +198,27 @@ pub fn ty_fn_ptr<I: Iterator<Item = Param>>(
         params: I,
         ret_type: Option<ast::RetType>,
     ) -> ast::FnPtrType {
-        make::ty_fn_ptr(is_unsafe, abi, params, ret_type).clone_for_update()
+        let (params, params_input) = iterator_input(params);
+        let ast = make::ty_fn_ptr(is_unsafe, abi.clone(), params.into_iter(), ret_type.clone())
+            .clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            if let Some(abi) = abi {
+                builder.map_node(abi.syntax().clone(), ast.abi().unwrap().syntax().clone());
+            }
+            builder.map_children(
+                params_input,
+                ast.param_list().unwrap().params().map(|p| p.syntax().clone()),
+            );
+            if let Some(ret_type) = ret_type {
+                builder
+                    .map_node(ret_type.syntax().clone(), ast.ret_type().unwrap().syntax().clone());
+            }
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn where_pred(

From 597f11b13d0da9601328f80fec3b8c10975b3c7d Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:50:21 +0530
Subject: [PATCH 0566/1059] add mapping to where_pred syntax_factory
 constructor method

---
 .../src/ast/syntax_factory/constructors.rs    | 27 ++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 4570502b1bec..fdf5eb5f5163 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -226,7 +226,32 @@ pub fn where_pred(
         path: Either<ast::Lifetime, ast::Type>,
         bounds: impl IntoIterator<Item = ast::TypeBound>,
     ) -> ast::WherePred {
-        make::where_pred(path, bounds).clone_for_update()
+        let (bounds, bounds_input) = iterator_input(bounds);
+        let ast = make::where_pred(path.clone(), bounds).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            match &path {
+                Either::Left(lifetime) => {
+                    builder.map_node(
+                        lifetime.syntax().clone(),
+                        ast.lifetime().unwrap().syntax().clone(),
+                    );
+                }
+                Either::Right(ty) => {
+                    builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
+                }
+            }
+            if let Some(type_bound_list) = ast.type_bound_list() {
+                builder.map_children(
+                    bounds_input,
+                    type_bound_list.bounds().map(|b| b.syntax().clone()),
+                );
+            }
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn where_clause(

From 16949c559213122f3a713a7783486275f7485d36 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:50:52 +0530
Subject: [PATCH 0567/1059] add mapping to where_clause syntax_factory
 constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs     | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index fdf5eb5f5163..241148d90066 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -258,7 +258,16 @@ pub fn where_clause(
         &self,
         predicates: impl IntoIterator<Item = ast::WherePred>,
     ) -> ast::WhereClause {
-        make::where_clause(predicates).clone_for_update()
+        let (predicates, input) = iterator_input(predicates);
+        let ast = make::where_clause(predicates).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(input, ast.predicates().map(|p| p.syntax().clone()));
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn impl_trait_type(&self, bounds: ast::TypeBoundList) -> ast::ImplTraitType {

From 3e9dc4e445c4894baa5a30ee641bc4ea46c8b3ea Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:51:23 +0530
Subject: [PATCH 0568/1059] add mapping to impl_trait_type syntax_factory
 constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs     | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 241148d90066..86fc7f0fdcd9 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -271,7 +271,16 @@ pub fn where_clause(
     }
 
     pub fn impl_trait_type(&self, bounds: ast::TypeBoundList) -> ast::ImplTraitType {
-        make::impl_trait_type(bounds).clone_for_update()
+        let ast = make::impl_trait_type(bounds.clone()).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder
+                .map_node(bounds.syntax().clone(), ast.type_bound_list().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {

From f3f1448031a8e6d536579c15b4b2360980d69694 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:52:10 +0530
Subject: [PATCH 0569/1059] add mapping to generic_ty_path_segment
 syntax_factory constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 86fc7f0fdcd9..a212dd3c3472 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -478,7 +478,20 @@ pub fn generic_ty_path_segment(
         name_ref: ast::NameRef,
         generic_args: impl IntoIterator<Item = ast::GenericArg>,
     ) -> ast::PathSegment {
-        make::generic_ty_path_segment(name_ref, generic_args).clone_for_update()
+        let (generic_args, input) = iterator_input(generic_args);
+        let ast = make::generic_ty_path_segment(name_ref.clone(), generic_args).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_node(name_ref.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
+            builder.map_children(
+                input,
+                ast.generic_arg_list().unwrap().generic_args().map(|a| a.syntax().clone()),
+            );
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn tail_only_block_expr(&self, tail_expr: ast::Expr) -> ast::BlockExpr {

From 4ed8442341464702a5bf30e97ea085734cccbb3b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:53:05 +0530
Subject: [PATCH 0570/1059] add mapping to tail_only_block_expr syntax_factory
 constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs  | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index a212dd3c3472..eb022d88e26a 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -495,7 +495,19 @@ pub fn generic_ty_path_segment(
     }
 
     pub fn tail_only_block_expr(&self, tail_expr: ast::Expr) -> ast::BlockExpr {
-        make::tail_only_block_expr(tail_expr)
+        let ast = make::tail_only_block_expr(tail_expr.clone()).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let stmt_list = ast.stmt_list().unwrap();
+            let mut builder = SyntaxMappingBuilder::new(stmt_list.syntax().clone());
+            builder.map_node(
+                tail_expr.syntax().clone(),
+                stmt_list.tail_expr().unwrap().syntax().clone(),
+            );
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn expr_bin_op(&self, lhs: ast::Expr, op: ast::BinaryOp, rhs: ast::Expr) -> ast::Expr {

From 7a5d26d077c9672842857f6bbe6d952f8b2f3955 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:53:32 +0530
Subject: [PATCH 0571/1059] add mapping to expr_bin_op syntax_factory
 constructor method

---
 .../syntax/src/ast/syntax_factory/constructors.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index eb022d88e26a..eec8ea3f3f28 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -511,7 +511,20 @@ pub fn tail_only_block_expr(&self, tail_expr: ast::Expr) -> ast::BlockExpr {
     }
 
     pub fn expr_bin_op(&self, lhs: ast::Expr, op: ast::BinaryOp, rhs: ast::Expr) -> ast::Expr {
-        make::expr_bin_op(lhs, op, rhs)
+        let ast::Expr::BinExpr(ast) =
+            make::expr_bin_op(lhs.clone(), op, rhs.clone()).clone_for_update()
+        else {
+            unreachable!()
+        };
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_node(lhs.syntax().clone(), ast.lhs().unwrap().syntax().clone());
+            builder.map_node(rhs.syntax().clone(), ast.rhs().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast.into()
     }
 
     pub fn ty_placeholder(&self) -> ast::Type {

From 01716dde697304052af90917013b8826e31706f1 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:53:54 +0530
Subject: [PATCH 0572/1059] add mapping to use_ syntax_factory constructor
 method

---
 .../src/ast/syntax_factory/constructors.rs     | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index eec8ea3f3f28..e62cf10a45cd 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -561,7 +561,23 @@ pub fn use_(
         visibility: Option<ast::Visibility>,
         use_tree: ast::UseTree,
     ) -> ast::Use {
-        make::use_(attrs, visibility, use_tree).clone_for_update()
+        let (attrs, attrs_input) = iterator_input(attrs);
+        let ast = make::use_(attrs, visibility.clone(), use_tree.clone()).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
+            if let Some(visibility) = visibility {
+                builder.map_node(
+                    visibility.syntax().clone(),
+                    ast.visibility().unwrap().syntax().clone(),
+                );
+            }
+            builder.map_node(use_tree.syntax().clone(), ast.use_tree().unwrap().syntax().clone());
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn use_tree(

From ec8ab854c656e0287b1215ac8e55546bc66d220a Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 17:54:15 +0530
Subject: [PATCH 0573/1059] add mapping to use_tree  syntax_factory constructor
 method

---
 .../src/ast/syntax_factory/constructors.rs    | 20 ++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index e62cf10a45cd..a9cdcbb041a4 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -587,7 +587,25 @@ pub fn use_tree(
         alias: Option<ast::Rename>,
         add_star: bool,
     ) -> ast::UseTree {
-        make::use_tree(path, use_tree_list, alias, add_star).clone_for_update()
+        let ast = make::use_tree(path.clone(), use_tree_list.clone(), alias.clone(), add_star)
+            .clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
+            if let Some(use_tree_list) = use_tree_list {
+                builder.map_node(
+                    use_tree_list.syntax().clone(),
+                    ast.use_tree_list().unwrap().syntax().clone(),
+                );
+            }
+            if let Some(alias) = alias {
+                builder.map_node(alias.syntax().clone(), ast.rename().unwrap().syntax().clone());
+            }
+            builder.finish(&mut mapping);
+        }
+
+        ast
     }
 
     pub fn path_unqualified(&self, segment: ast::PathSegment) -> ast::Path {

From 257bcc4afb0720e00bfb12e24b53717a12ec0c9b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 17 Mar 2026 18:18:42 +0530
Subject: [PATCH 0574/1059] remove redundant enum_ constructor

---
 .../src/handlers/convert_bool_to_enum.rs      |  2 +-
 .../src/ast/syntax_factory/constructors.rs    | 52 -------------------
 2 files changed, 1 insertion(+), 53 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
index 934779810054..e88778a62e19 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
@@ -533,7 +533,7 @@ fn make_bool_enum(make_pub: bool, make: &SyntaxFactory) -> ast::Enum {
             ],
         ),
     ));
-    make.enum_(
+    make.item_enum(
         [derive_eq],
         if make_pub { Some(make.visibility_pub()) } else { None },
         make.name("Bool"),
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index a9cdcbb041a4..e8339eaeac63 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -127,58 +127,6 @@ pub fn struct_(
         ast
     }
 
-    pub fn enum_(
-        &self,
-        attrs: impl IntoIterator<Item = ast::Attr>,
-        visibility: Option<ast::Visibility>,
-        enum_name: ast::Name,
-        generic_param_list: Option<ast::GenericParamList>,
-        where_clause: Option<ast::WhereClause>,
-        variant_list: ast::VariantList,
-    ) -> ast::Enum {
-        let (attrs, attrs_input) = iterator_input(attrs);
-        let ast = make::enum_(
-            attrs,
-            visibility.clone(),
-            enum_name.clone(),
-            generic_param_list.clone(),
-            where_clause.clone(),
-            variant_list.clone(),
-        )
-        .clone_for_update();
-
-        if let Some(mut mapping) = self.mappings() {
-            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
-            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
-            if let Some(visibility) = visibility {
-                builder.map_node(
-                    visibility.syntax().clone(),
-                    ast.visibility().unwrap().syntax().clone(),
-                );
-            }
-            builder.map_node(enum_name.syntax().clone(), ast.name().unwrap().syntax().clone());
-            if let Some(generic_param_list) = generic_param_list {
-                builder.map_node(
-                    generic_param_list.syntax().clone(),
-                    ast.generic_param_list().unwrap().syntax().clone(),
-                );
-            }
-            if let Some(where_clause) = where_clause {
-                builder.map_node(
-                    where_clause.syntax().clone(),
-                    ast.where_clause().unwrap().syntax().clone(),
-                );
-            }
-            builder.map_node(
-                variant_list.syntax().clone(),
-                ast.variant_list().unwrap().syntax().clone(),
-            );
-            builder.finish(&mut mapping);
-        }
-
-        ast
-    }
-
     pub fn unnamed_param(&self, ty: ast::Type) -> ast::Param {
         let ast = make::unnamed_param(ty.clone()).clone_for_update();
 

From 15032749bc1a7e28d8ec4634427f1f1ab9143256 Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Tue, 17 Mar 2026 21:06:06 +0800
Subject: [PATCH 0575/1059] Emit ForbiddenBound fatally if meeting complex
 bound

---
 compiler/rustc_ast_passes/src/feature_gate.rs | 11 ++++-
 .../binder/bounds-on-closure-type-binders.rs  |  1 -
 .../bounds-on-closure-type-binders.stderr     |  8 +---
 .../traits/non_lifetime_binders/bad-bounds.rs | 13 ++++++
 .../non_lifetime_binders/bad-bounds.stderr    | 46 +++++++++++++++++++
 5 files changed, 69 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/traits/non_lifetime_binders/bad-bounds.rs
 create mode 100644 tests/ui/traits/non_lifetime_binders/bad-bounds.stderr

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index ea8521a83140..830eb3d6d817 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -1,5 +1,5 @@
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
-use rustc_ast::{self as ast, AttrVec, NodeId, PatKind, attr, token};
+use rustc_ast::{self as ast, AttrVec, GenericBound, NodeId, PatKind, attr, token};
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::msg;
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
@@ -149,7 +149,14 @@ fn check_late_bound_lifetime_defs(&self, params: &[ast::GenericParam]) {
         for param in params {
             if !param.bounds.is_empty() {
                 let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();
-                self.sess.dcx().emit_err(errors::ForbiddenBound { spans });
+                if param.bounds.iter().any(|bound| matches!(bound, GenericBound::Trait(_))) {
+                    // Issue #149695
+                    // Abort immediately otherwise items defined in complex bounds will be lowered into HIR,
+                    // which will cause ICEs when errors of the items visit unlowered parents.
+                    self.sess.dcx().emit_fatal(errors::ForbiddenBound { spans });
+                } else {
+                    self.sess.dcx().emit_err(errors::ForbiddenBound { spans });
+                }
             }
         }
     }
diff --git a/tests/ui/closures/binder/bounds-on-closure-type-binders.rs b/tests/ui/closures/binder/bounds-on-closure-type-binders.rs
index cf53241407fe..80f48a1e2b40 100644
--- a/tests/ui/closures/binder/bounds-on-closure-type-binders.rs
+++ b/tests/ui/closures/binder/bounds-on-closure-type-binders.rs
@@ -10,5 +10,4 @@ fn main() {
     // Regression test for issue #119067
     let _ = for<T: Trait> || -> () {};
     //~^ ERROR bounds cannot be used in this context
-    //~| ERROR late-bound type parameter not allowed on closures
 }
diff --git a/tests/ui/closures/binder/bounds-on-closure-type-binders.stderr b/tests/ui/closures/binder/bounds-on-closure-type-binders.stderr
index 9cb921f66314..50fa11ed0ed1 100644
--- a/tests/ui/closures/binder/bounds-on-closure-type-binders.stderr
+++ b/tests/ui/closures/binder/bounds-on-closure-type-binders.stderr
@@ -4,11 +4,5 @@ error: bounds cannot be used in this context
 LL |     let _ = for<T: Trait> || -> () {};
    |                    ^^^^^
 
-error: late-bound type parameter not allowed on closures
-  --> $DIR/bounds-on-closure-type-binders.rs:11:17
-   |
-LL |     let _ = for<T: Trait> || -> () {};
-   |                 ^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/bad-bounds.rs b/tests/ui/traits/non_lifetime_binders/bad-bounds.rs
new file mode 100644
index 000000000000..4fccaf1d84f3
--- /dev/null
+++ b/tests/ui/traits/non_lifetime_binders/bad-bounds.rs
@@ -0,0 +1,13 @@
+//@ edition: 2024
+
+#![feature(non_lifetime_binders)]
+#![expect(incomplete_features)]
+
+fn produce() -> for<A: A<{ //~ ERROR expected trait, found type parameter `A`
+    //~^ ERROR bounds cannot be used in this context
+    #[derive(Hash)]
+    enum A {}
+    struct A<A>; //~ ERROR the name `A` is defined multiple times
+}>> Trait {} //~ ERROR cannot find trait `Trait` in this scope
+
+fn main() {}
diff --git a/tests/ui/traits/non_lifetime_binders/bad-bounds.stderr b/tests/ui/traits/non_lifetime_binders/bad-bounds.stderr
new file mode 100644
index 000000000000..ffc238c3f343
--- /dev/null
+++ b/tests/ui/traits/non_lifetime_binders/bad-bounds.stderr
@@ -0,0 +1,46 @@
+error[E0428]: the name `A` is defined multiple times
+  --> $DIR/bad-bounds.rs:10:5
+   |
+LL |     enum A {}
+   |     ------ previous definition of the type `A` here
+LL |     struct A<A>;
+   |     ^^^^^^^^^^^^ `A` redefined here
+   |
+   = note: `A` must be defined only once in the type namespace of this block
+
+error[E0404]: expected trait, found type parameter `A`
+  --> $DIR/bad-bounds.rs:6:24
+   |
+LL |   fn produce() -> for<A: A<{
+   |  _____________________-__^
+   | |                     |
+   | |                     found this type parameter
+LL | |
+LL | |     #[derive(Hash)]
+LL | |     enum A {}
+LL | |     struct A<A>;
+LL | | }>> Trait {}
+   | |__^ not a trait
+
+error[E0405]: cannot find trait `Trait` in this scope
+  --> $DIR/bad-bounds.rs:11:5
+   |
+LL | }>> Trait {}
+   |     ^^^^^ not found in this scope
+
+error: bounds cannot be used in this context
+  --> $DIR/bad-bounds.rs:6:24
+   |
+LL |   fn produce() -> for<A: A<{
+   |  ________________________^
+LL | |
+LL | |     #[derive(Hash)]
+LL | |     enum A {}
+LL | |     struct A<A>;
+LL | | }>> Trait {}
+   | |__^
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0404, E0405, E0428.
+For more information about an error, try `rustc --explain E0404`.

From d81da4d691cf9f794a7cb6d29415f1e058357f9d Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Mon, 16 Mar 2026 15:06:56 +0000
Subject: [PATCH 0576/1059] Fix missing kernel-address from error message list

---
 compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs | 1 +
 tests/ui/sanitize-attr/invalid-sanitize.stderr              | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 4909e0d35173..a8db114129ff 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -671,6 +671,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
                         item.path().span(),
                         &[
                             sym::address,
+                            sym::kernel_address,
                             sym::cfi,
                             sym::kcfi,
                             sym::memory,
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.stderr b/tests/ui/sanitize-attr/invalid-sanitize.stderr
index 26ef31603d88..00bb7746d05f 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.stderr
+++ b/tests/ui/sanitize-attr/invalid-sanitize.stderr
@@ -4,7 +4,7 @@ error[E0539]: malformed `sanitize` attribute input
 LL | #[sanitize(brontosaurus = "off")]
    | ^^^^^^^^^^^------------^^^^^^^^^^
    |            |
-   |            valid arguments are "address", "cfi", "kcfi", "memory", "memtag", "shadow_call_stack", "thread", "hwaddress" or "realtime"
+   |            valid arguments are "address", "kernel_address", "cfi", "kcfi", "memory", "memtag", "shadow_call_stack", "thread", "hwaddress" or "realtime"
 
 error: multiple `sanitize` attributes
   --> $DIR/invalid-sanitize.rs:7:1

From 924374c75b6ec99c5d95847f6c54554d8d590716 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Tue, 17 Mar 2026 06:30:04 +0000
Subject: [PATCH 0577/1059] mGCA: Lower const generic args to infer when needed

---
 compiler/rustc_ast_lowering/src/lib.rs        | 10 +++--
 .../const-generics/mgca/braced-const-infer.rs |  9 ++++
 .../mgca/braced-const-infer.stderr            |  9 ++++
 .../mgca/macro-const-arg-infer.rs             | 20 +++++++++
 .../mgca/macro-const-arg-infer.stderr         | 44 +++++++++++++++++++
 5 files changed, 89 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/const-generics/mgca/braced-const-infer.rs
 create mode 100644 tests/ui/const-generics/mgca/braced-const-infer.stderr
 create mode 100644 tests/ui/const-generics/mgca/macro-const-arg-infer.rs
 create mode 100644 tests/ui/const-generics/mgca/macro-const-arg-infer.stderr

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index e8092b540ec8..7a0537b0e7c6 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1269,9 +1269,13 @@ fn lower_generic_arg(
                 }
                 GenericArg::Type(self.lower_ty_alloc(ty, itctx).try_as_ambig_ty().unwrap())
             }
-            ast::GenericArg::Const(ct) => GenericArg::Const(
-                self.lower_anon_const_to_const_arg_and_alloc(ct).try_as_ambig_ct().unwrap(),
-            ),
+            ast::GenericArg::Const(ct) => {
+                let ct = self.lower_anon_const_to_const_arg_and_alloc(ct);
+                match ct.try_as_ambig_ct() {
+                    Some(ct) => GenericArg::Const(ct),
+                    None => GenericArg::Infer(hir::InferArg { hir_id: ct.hir_id, span: ct.span }),
+                }
+            }
         }
     }
 
diff --git a/tests/ui/const-generics/mgca/braced-const-infer.rs b/tests/ui/const-generics/mgca/braced-const-infer.rs
new file mode 100644
index 000000000000..9b007d338d1d
--- /dev/null
+++ b/tests/ui/const-generics/mgca/braced-const-infer.rs
@@ -0,0 +1,9 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/153198
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features, rust_2021_compatibility)]
+
+trait Trait<T> {}
+
+impl dyn Trait<{_}> {} //~ ERROR: the placeholder `_` is not allowed within types on item signatures
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/braced-const-infer.stderr b/tests/ui/const-generics/mgca/braced-const-infer.stderr
new file mode 100644
index 000000000000..d8ffee4cd0e8
--- /dev/null
+++ b/tests/ui/const-generics/mgca/braced-const-infer.stderr
@@ -0,0 +1,9 @@
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for implementations
+  --> $DIR/braced-const-infer.rs:7:17
+   |
+LL | impl dyn Trait<{_}> {}
+   |                 ^ not allowed in type signatures
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/const-generics/mgca/macro-const-arg-infer.rs b/tests/ui/const-generics/mgca/macro-const-arg-infer.rs
new file mode 100644
index 000000000000..017c63d8b0db
--- /dev/null
+++ b/tests/ui/const-generics/mgca/macro-const-arg-infer.rs
@@ -0,0 +1,20 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/153198
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+macro_rules! y {
+    ( $($matcher:tt)*) => {
+        _ //~ ERROR: the placeholder `_` is not allowed within types on item signatures
+    };
+}
+
+struct A<T>; //~ ERROR: type parameter `T` is never used
+
+const y: A<
+    {
+        y! {
+            x
+        }
+    },
+> = 1; //~ ERROR: mismatched types
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/macro-const-arg-infer.stderr b/tests/ui/const-generics/mgca/macro-const-arg-infer.stderr
new file mode 100644
index 000000000000..406206c59e18
--- /dev/null
+++ b/tests/ui/const-generics/mgca/macro-const-arg-infer.stderr
@@ -0,0 +1,44 @@
+error[E0392]: type parameter `T` is never used
+  --> $DIR/macro-const-arg-infer.rs:10:10
+   |
+LL | struct A<T>;
+   |          ^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
+
+error[E0308]: mismatched types
+  --> $DIR/macro-const-arg-infer.rs:18:5
+   |
+LL |   const y: A<
+   |  __________-
+LL | |     {
+LL | |         y! {
+LL | |             x
+LL | |         }
+LL | |     },
+LL | | > = 1;
+   | | -   ^ expected `A<_>`, found integer
+   | |_|
+   |   expected because of the type of the constant
+   |
+   = note: expected struct `A<_>`
+                found type `{integer}`
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
+  --> $DIR/macro-const-arg-infer.rs:6:9
+   |
+LL |           _
+   |           ^ not allowed in type signatures
+...
+LL | /         y! {
+LL | |             x
+LL | |         }
+   | |_________- in this macro invocation
+   |
+   = note: this error originates in the macro `y` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0121, E0308, E0392.
+For more information about an error, try `rustc --explain E0121`.

From 11810b8dd9d5ea1dad36eb5f6c77fa5d95871a81 Mon Sep 17 00:00:00 2001
From: human9000 <human9000.2021@gmail.com>
Date: Sun, 8 Mar 2026 10:49:21 +0500
Subject: [PATCH 0578/1059] fix inference variables leaking into HIR const
 lowering logic

---
 .../src/hir_ty_lowering/mod.rs                |  6 ++++++
 .../mgca/infer-vars-in-const-args.rs          | 16 ++++++++++++++
 .../mgca/infer-vars-in-const-args.stderr      | 21 +++++++++++++++++++
 3 files changed, 43 insertions(+)
 create mode 100644 tests/ui/const-generics/mgca/infer-vars-in-const-args.rs
 create mode 100644 tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index bf97bfb1ebbc..00791ed194c5 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2874,6 +2874,12 @@ fn lower_const_arg_literal(
         span: Span,
     ) -> Const<'tcx> {
         let tcx = self.tcx();
+
+        if ty.has_infer() {
+            let e = self.dcx().span_err(span, "inference variables are not supported in constants");
+            return ty::Const::new_error(tcx, e);
+        }
+
         if let LitKind::Err(guar) = *kind {
             return ty::Const::new_error(tcx, guar);
         }
diff --git a/tests/ui/const-generics/mgca/infer-vars-in-const-args.rs b/tests/ui/const-generics/mgca/infer-vars-in-const-args.rs
new file mode 100644
index 000000000000..cbc59d461694
--- /dev/null
+++ b/tests/ui/const-generics/mgca/infer-vars-in-const-args.rs
@@ -0,0 +1,16 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params, min_generic_const_args, generic_const_parameter_types)]
+
+fn main() {
+    foo::<_, { 2 }>();
+    //~^ ERROR: inference variables are not supported in constants
+    let _: PC<_, { 42 }> = PC { a: 1, b: 1 };
+    //~^ ERROR: inference variables are not supported in constants
+}
+
+struct PC<T, const N: T> {
+//~^ ERROR: `T` can't be used as a const parameter type [E0741]
+    a: T,
+}
+
+fn foo<const N: usize, const A: [u8; N]>() {}
diff --git a/tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr b/tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr
new file mode 100644
index 000000000000..0f64582c1cef
--- /dev/null
+++ b/tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr
@@ -0,0 +1,21 @@
+error[E0741]: `T` can't be used as a const parameter type
+  --> $DIR/infer-vars-in-const-args.rs:11:23
+   |
+LL | struct PC<T, const N: T> {
+   |                       ^
+
+error: inference variables are not supported in constants
+  --> $DIR/infer-vars-in-const-args.rs:5:16
+   |
+LL |     foo::<_, { 2 }>();
+   |                ^
+
+error: inference variables are not supported in constants
+  --> $DIR/infer-vars-in-const-args.rs:7:20
+   |
+LL |     let _: PC<_, { 42 }> = PC { a: 1, b: 1 };
+   |                    ^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0741`.

From 5113488163ac3fdbb2adb665308b0bd3f524c44f Mon Sep 17 00:00:00 2001
From: human9000 <human9000.2021@gmail.com>
Date: Tue, 17 Mar 2026 09:36:08 +0500
Subject: [PATCH 0579/1059] Improve `ty::Infer` handling during const literal
 lowering

Co-authored-by: BoxyUwU <rust@boxyuwu.dev>
---
 .../src/hir_ty_lowering/mod.rs                | 15 +++++++------
 compiler/rustc_middle/src/ty/consts/lit.rs    |  5 ++++-
 .../src/builder/expr/as_constant.rs           |  5 ++++-
 compiler/rustc_mir_build/src/thir/constant.rs | 22 ++++++++++---------
 .../rustc_mir_build/src/thir/pattern/mod.rs   |  2 +-
 compiler/rustc_ty_utils/src/consts.rs         |  3 ++-
 ...> infer-vars-in-const-args-conflicting.rs} |  9 ++++++--
 ...fer-vars-in-const-args-conflicting.stderr} | 10 ++++-----
 .../mgca/infer-vars-in-const-args-correct.rs  | 22 +++++++++++++++++++
 9 files changed, 65 insertions(+), 28 deletions(-)
 rename tests/ui/const-generics/mgca/{infer-vars-in-const-args.rs => infer-vars-in-const-args-conflicting.rs} (52%)
 rename tests/ui/const-generics/mgca/{infer-vars-in-const-args.stderr => infer-vars-in-const-args-conflicting.stderr} (58%)
 create mode 100644 tests/ui/const-generics/mgca/infer-vars-in-const-args-correct.rs

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 00791ed194c5..9396bf6352c5 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2875,10 +2875,7 @@ fn lower_const_arg_literal(
     ) -> Const<'tcx> {
         let tcx = self.tcx();
 
-        if ty.has_infer() {
-            let e = self.dcx().span_err(span, "inference variables are not supported in constants");
-            return ty::Const::new_error(tcx, e);
-        }
+        let ty = if !ty.has_infer() { Some(ty) } else { None };
 
         if let LitKind::Err(guar) = *kind {
             return ty::Const::new_error(tcx, guar);
@@ -2911,16 +2908,20 @@ fn try_lower_anon_const_lit(
         };
 
         let lit_input = match expr.kind {
-            hir::ExprKind::Lit(lit) => Some(LitToConstInput { lit: lit.node, ty, neg: false }),
+            hir::ExprKind::Lit(lit) => {
+                Some(LitToConstInput { lit: lit.node, ty: Some(ty), neg: false })
+            }
             hir::ExprKind::Unary(hir::UnOp::Neg, expr) => match expr.kind {
-                hir::ExprKind::Lit(lit) => Some(LitToConstInput { lit: lit.node, ty, neg: true }),
+                hir::ExprKind::Lit(lit) => {
+                    Some(LitToConstInput { lit: lit.node, ty: Some(ty), neg: true })
+                }
                 _ => None,
             },
             _ => None,
         };
 
         lit_input.and_then(|l| {
-            if const_lit_matches_ty(tcx, &l.lit, l.ty, l.neg) {
+            if const_lit_matches_ty(tcx, &l.lit, ty, l.neg) {
                 tcx.at(expr.span)
                     .lit_to_const(l)
                     .map(|value| ty::Const::new_value(tcx, value.valtree, value.ty))
diff --git a/compiler/rustc_middle/src/ty/consts/lit.rs b/compiler/rustc_middle/src/ty/consts/lit.rs
index be6dfb20e043..7be225a9e921 100644
--- a/compiler/rustc_middle/src/ty/consts/lit.rs
+++ b/compiler/rustc_middle/src/ty/consts/lit.rs
@@ -10,7 +10,10 @@ pub struct LitToConstInput<'tcx> {
     /// The absolute value of the resultant constant.
     pub lit: LitKind,
     /// The type of the constant.
-    pub ty: Ty<'tcx>,
+    ///
+    /// `None` is used by const generics when the type of the constant is unknown, e.g.
+    /// if there are inference variables
+    pub ty: Option<Ty<'tcx>>,
     /// If the constant is negative.
     pub neg: bool,
 }
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
index ad6c1f7dce5b..c67d99a8eb7d 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
@@ -50,7 +50,8 @@ pub(crate) fn as_constant_inner<'tcx>(
 
     match *kind {
         ExprKind::Literal { lit, neg } => {
-            let const_ = lit_to_mir_constant(tcx, LitToConstInput { lit: lit.node, ty, neg });
+            let const_ =
+                lit_to_mir_constant(tcx, LitToConstInput { lit: lit.node, ty: Some(ty), neg });
 
             ConstOperand { span, user_ty: None, const_ }
         }
@@ -109,6 +110,8 @@ pub(crate) fn as_constant_inner<'tcx>(
 fn lit_to_mir_constant<'tcx>(tcx: TyCtxt<'tcx>, lit_input: LitToConstInput<'tcx>) -> Const<'tcx> {
     let LitToConstInput { lit, ty, neg } = lit_input;
 
+    let ty = ty.expect("type of literal must be known at this point");
+
     if let Err(guar) = ty.error_reported() {
         return Const::Ty(Ty::new_error(tcx, guar), ty::Const::new_error(tcx, guar));
     }
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
index b4eedb15033c..019af2461354 100644
--- a/compiler/rustc_mir_build/src/thir/constant.rs
+++ b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -31,25 +31,27 @@ pub(crate) fn lit_to_const<'tcx>(
             .unwrap_or_else(|| bug!("expected to create ScalarInt from uint {:?}", result))
     };
 
-    let (valtree, valtree_ty) = match (lit, expected_ty.kind()) {
+    let (valtree, valtree_ty) = match (lit, expected_ty.map(|ty| ty.kind())) {
         (ast::LitKind::Str(s, _), _) => {
             let str_bytes = s.as_str().as_bytes();
             let valtree_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_static, tcx.types.str_);
             (ty::ValTree::from_raw_bytes(tcx, str_bytes), valtree_ty)
         }
-        (ast::LitKind::ByteStr(byte_sym, _), ty::Ref(_, inner_ty, _))
+        (ast::LitKind::ByteStr(byte_sym, _), Some(ty::Ref(_, inner_ty, _)))
             if let ty::Slice(ty) | ty::Array(ty, _) = inner_ty.kind()
                 && let ty::Uint(UintTy::U8) = ty.kind() =>
         {
-            (ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str()), expected_ty)
+            (ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str()), expected_ty.unwrap())
         }
-        (ast::LitKind::ByteStr(byte_sym, _), ty::Slice(inner_ty) | ty::Array(inner_ty, _))
-            if tcx.features().deref_patterns()
-                && let ty::Uint(UintTy::U8) = inner_ty.kind() =>
+        (
+            ast::LitKind::ByteStr(byte_sym, _),
+            Some(ty::Slice(inner_ty) | ty::Array(inner_ty, _)),
+        ) if tcx.features().deref_patterns()
+            && let ty::Uint(UintTy::U8) = inner_ty.kind() =>
         {
             // Byte string literal patterns may have type `[u8]` or `[u8; N]` if `deref_patterns` is
             // enabled, in order to allow, e.g., `deref!(b"..."): Vec<u8>`.
-            (ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str()), expected_ty)
+            (ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str()), expected_ty.unwrap())
         }
         (ast::LitKind::ByteStr(byte_sym, _), _) => {
             let valtree = ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str());
@@ -79,11 +81,11 @@ pub(crate) fn lit_to_const<'tcx>(
                 trunc(if neg { u128::wrapping_neg(n.get()) } else { n.get() }, i.to_unsigned());
             (ty::ValTree::from_scalar_int(tcx, scalar_int), Ty::new_int(tcx, i))
         }
-        (ast::LitKind::Int(n, ast::LitIntType::Unsuffixed), ty::Uint(ui)) if !neg => {
+        (ast::LitKind::Int(n, ast::LitIntType::Unsuffixed), Some(ty::Uint(ui))) if !neg => {
             let scalar_int = trunc(n.get(), *ui);
             (ty::ValTree::from_scalar_int(tcx, scalar_int), Ty::new_uint(tcx, *ui))
         }
-        (ast::LitKind::Int(n, ast::LitIntType::Unsuffixed), ty::Int(i)) => {
+        (ast::LitKind::Int(n, ast::LitIntType::Unsuffixed), Some(ty::Int(i))) => {
             // Unsigned "negation" has the same bitwise effect as signed negation,
             // which gets the result we want without additional casts.
             let scalar_int =
@@ -101,7 +103,7 @@ pub(crate) fn lit_to_const<'tcx>(
             let bits = parse_float_into_scalar(n, fty, neg)?;
             (ty::ValTree::from_scalar_int(tcx, bits), Ty::new_float(tcx, fty))
         }
-        (ast::LitKind::Float(n, ast::LitFloatType::Unsuffixed), ty::Float(fty)) => {
+        (ast::LitKind::Float(n, ast::LitFloatType::Unsuffixed), Some(ty::Float(fty))) => {
             let bits = parse_float_into_scalar(n, *fty, neg)?;
             (ty::ValTree::from_scalar_int(tcx, bits), Ty::new_float(tcx, *fty))
         }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 67cde0e2c886..fec2fb9ca571 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -696,7 +696,7 @@ fn lower_pat_expr(
                 // patterns to `str`, and byte-string literal patterns to `[u8; N]` or `[u8]`.
 
                 let pat_ty = self.typeck_results.node_type(pat.hir_id);
-                let lit_input = LitToConstInput { lit: lit.node, ty: pat_ty, neg: *negated };
+                let lit_input = LitToConstInput { lit: lit.node, ty: Some(pat_ty), neg: *negated };
                 let constant = const_lit_matches_ty(self.tcx, &lit.node, pat_ty, *negated)
                     .then(|| self.tcx.at(expr.span).lit_to_const(lit_input))
                     .flatten()
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index 1d444079f896..49e0bdde3787 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -58,7 +58,8 @@ fn recurse_build<'tcx>(
         }
         &ExprKind::Literal { lit, neg } => {
             let sp = node.span;
-            match tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: node.ty, neg }) {
+            match tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: Some(node.ty), neg })
+            {
                 Some(value) => ty::Const::new_value(tcx, value.valtree, value.ty),
                 None => ty::Const::new_misc_error(tcx),
             }
diff --git a/tests/ui/const-generics/mgca/infer-vars-in-const-args.rs b/tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.rs
similarity index 52%
rename from tests/ui/const-generics/mgca/infer-vars-in-const-args.rs
rename to tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.rs
index cbc59d461694..eeb76683eedf 100644
--- a/tests/ui/const-generics/mgca/infer-vars-in-const-args.rs
+++ b/tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.rs
@@ -1,11 +1,16 @@
+//! This test ensures compilation failure when trying to pass literals
+//! without explicitly stated type as inference variables in generic arguments.
+//!
+//! See https://github.com/rust-lang/rust/pull/153557
+
 #![allow(incomplete_features)]
 #![feature(adt_const_params, min_generic_const_args, generic_const_parameter_types)]
 
 fn main() {
     foo::<_, { 2 }>();
-    //~^ ERROR: inference variables are not supported in constants
+    //~^ ERROR: type annotations needed for the literal
     let _: PC<_, { 42 }> = PC { a: 1, b: 1 };
-    //~^ ERROR: inference variables are not supported in constants
+    //~^ ERROR: type annotations needed for the literal
 }
 
 struct PC<T, const N: T> {
diff --git a/tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr b/tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.stderr
similarity index 58%
rename from tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr
rename to tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.stderr
index 0f64582c1cef..a4b13f41aef0 100644
--- a/tests/ui/const-generics/mgca/infer-vars-in-const-args.stderr
+++ b/tests/ui/const-generics/mgca/infer-vars-in-const-args-conflicting.stderr
@@ -1,17 +1,17 @@
 error[E0741]: `T` can't be used as a const parameter type
-  --> $DIR/infer-vars-in-const-args.rs:11:23
+  --> $DIR/infer-vars-in-const-args-conflicting.rs:16:23
    |
 LL | struct PC<T, const N: T> {
    |                       ^
 
-error: inference variables are not supported in constants
-  --> $DIR/infer-vars-in-const-args.rs:5:16
+error: type annotations needed for the literal
+  --> $DIR/infer-vars-in-const-args-conflicting.rs:10:16
    |
 LL |     foo::<_, { 2 }>();
    |                ^
 
-error: inference variables are not supported in constants
-  --> $DIR/infer-vars-in-const-args.rs:7:20
+error: type annotations needed for the literal
+  --> $DIR/infer-vars-in-const-args-conflicting.rs:12:20
    |
 LL |     let _: PC<_, { 42 }> = PC { a: 1, b: 1 };
    |                    ^^
diff --git a/tests/ui/const-generics/mgca/infer-vars-in-const-args-correct.rs b/tests/ui/const-generics/mgca/infer-vars-in-const-args-correct.rs
new file mode 100644
index 000000000000..f1c0e0b2b4c3
--- /dev/null
+++ b/tests/ui/const-generics/mgca/infer-vars-in-const-args-correct.rs
@@ -0,0 +1,22 @@
+//! This test ensures no errors are emitted when lowering literals with
+//! explicitly stated types and inference variables in the type of the const
+//! generic parameter.
+//!
+//! See https://github.com/rust-lang/rust/pull/153557
+
+//@check-pass
+
+#![allow(incomplete_features)]
+#![feature(adt_const_params,
+    min_generic_const_args,
+    generic_const_parameter_types,
+    unsized_const_params
+)]
+
+use std::marker::ConstParamTy_;
+
+fn main() {
+    foo::<_, 2_i32>();
+}
+
+fn foo<T: ConstParamTy_, const N: T>() {}

From 7c93774f8d5fc2aaa1ffdeff85f72f0c85d8dc25 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Tue, 10 Mar 2026 17:55:23 +0000
Subject: [PATCH 0580/1059] internal: Add codecov badge

It's tricky to find the relevant codecov page, so add a badge to the
readme showing coverage and linking to the codecov dashboard.
---
 src/tools/rust-analyzer/README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/rust-analyzer/README.md b/src/tools/rust-analyzer/README.md
index 6d2a67328685..06d63a2d23a7 100644
--- a/src/tools/rust-analyzer/README.md
+++ b/src/tools/rust-analyzer/README.md
@@ -20,6 +20,8 @@ analyzing Rust code. See
 [Architecture](https://rust-analyzer.github.io/book/contributing/architecture.html)
 in the manual.
 
+[![codecov](https://codecov.io/github/rust-lang/rust-analyzer/graph/badge.svg)](https://app.codecov.io/github/rust-lang/rust-analyzer/tree/master)
+
 ## Quick Start
 
 https://rust-analyzer.github.io/book/installation.html

From 952d7f8d237e8d397487e27c3d094f584c47e822 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 17 Mar 2026 17:29:42 +0100
Subject: [PATCH 0581/1059] Ignore `ExprKind::Err` when converting path attr
 expr to lit

---
 compiler/rustc_attr_parsing/src/parser.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 354fbab9cfcf..07f246319dec 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -390,7 +390,7 @@ fn expr_to_lit<'sess>(
             }
         }
     } else {
-        if matches!(should_emit, ShouldEmit::Nothing) {
+        if matches!(should_emit, ShouldEmit::Nothing) || matches!(expr.kind, ExprKind::Err(_)) {
             return Ok(None);
         }
 

From de48ea79afc68747f62094d052444e50ab65e671 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 17 Mar 2026 17:30:08 +0100
Subject: [PATCH 0582/1059] Update uitests

---
 tests/ui/attributes/crate-type-macro-empty.rs |   1 -
 .../attributes/crate-type-macro-empty.stderr  |  12 +-
 .../attributes/crate-type-macro-not-found.rs  |   1 -
 .../crate-type-macro-not-found.stderr         |  10 +-
 tests/ui/attributes/doc-attr-compile-error.rs |   3 +
 .../attributes/doc-attr-compile-error.stderr  |   8 +
 .../extented-attribute-macro-error.rs         |   1 -
 .../extented-attribute-macro-error.stderr     |   8 +-
 .../attributes/key-value-expansion-scope.rs   |  16 --
 .../key-value-expansion-scope.stderr          | 148 +++---------------
 .../invalid-utf8-binary-file.rs               |   1 -
 .../invalid-utf8-binary-file.stderr           |   8 +-
 tests/ui/resolve/path-attr-in-const-block.rs  |   1 -
 .../resolve/path-attr-in-const-block.stderr   |   8 +-
 14 files changed, 45 insertions(+), 181 deletions(-)
 create mode 100644 tests/ui/attributes/doc-attr-compile-error.rs
 create mode 100644 tests/ui/attributes/doc-attr-compile-error.stderr

diff --git a/tests/ui/attributes/crate-type-macro-empty.rs b/tests/ui/attributes/crate-type-macro-empty.rs
index d55074ed686c..217ff598f7a4 100644
--- a/tests/ui/attributes/crate-type-macro-empty.rs
+++ b/tests/ui/attributes/crate-type-macro-empty.rs
@@ -1,7 +1,6 @@
 // Tests for the issue in #137589
 #[crate_type = foo!()]
 //~^ ERROR cannot find macro `foo` in this scope
-//~| ERROR attribute value must be a literal
 
 macro_rules! foo {} //~ ERROR macros must contain at least one rule
 
diff --git a/tests/ui/attributes/crate-type-macro-empty.stderr b/tests/ui/attributes/crate-type-macro-empty.stderr
index 2e24a9972287..130fa454ca19 100644
--- a/tests/ui/attributes/crate-type-macro-empty.stderr
+++ b/tests/ui/attributes/crate-type-macro-empty.stderr
@@ -1,5 +1,5 @@
 error: macros must contain at least one rule
-  --> $DIR/crate-type-macro-empty.rs:6:1
+  --> $DIR/crate-type-macro-empty.rs:5:1
    |
 LL | macro_rules! foo {}
    | ^^^^^^^^^^^^^^^^^^^
@@ -11,16 +11,10 @@ LL | #[crate_type = foo!()]
    |                ^^^ consider moving the definition of `foo` before this call
    |
 note: a macro with the same name exists, but it appears later
-  --> $DIR/crate-type-macro-empty.rs:6:14
+  --> $DIR/crate-type-macro-empty.rs:5:14
    |
 LL | macro_rules! foo {}
    |              ^^^
 
-error: attribute value must be a literal
-  --> $DIR/crate-type-macro-empty.rs:2:16
-   |
-LL | #[crate_type = foo!()]
-   |                ^^^^^^
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/attributes/crate-type-macro-not-found.rs b/tests/ui/attributes/crate-type-macro-not-found.rs
index eac780944572..901ece48de0a 100644
--- a/tests/ui/attributes/crate-type-macro-not-found.rs
+++ b/tests/ui/attributes/crate-type-macro-not-found.rs
@@ -1,7 +1,6 @@
 // Tests for the issue in #137589
 #[crate_type = foo!()]
 //~^ ERROR cannot find macro `foo` in this scope
-//~| ERROR attribute value must be a literal
 
 macro_rules! foo {
     ($x:expr) => {"rlib"}
diff --git a/tests/ui/attributes/crate-type-macro-not-found.stderr b/tests/ui/attributes/crate-type-macro-not-found.stderr
index 9db7f7f6ec0b..4d4d843a5396 100644
--- a/tests/ui/attributes/crate-type-macro-not-found.stderr
+++ b/tests/ui/attributes/crate-type-macro-not-found.stderr
@@ -5,16 +5,10 @@ LL | #[crate_type = foo!()]
    |                ^^^ consider moving the definition of `foo` before this call
    |
 note: a macro with the same name exists, but it appears later
-  --> $DIR/crate-type-macro-not-found.rs:6:14
+  --> $DIR/crate-type-macro-not-found.rs:5:14
    |
 LL | macro_rules! foo {
    |              ^^^
 
-error: attribute value must be a literal
-  --> $DIR/crate-type-macro-not-found.rs:2:16
-   |
-LL | #[crate_type = foo!()]
-   |                ^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/doc-attr-compile-error.rs b/tests/ui/attributes/doc-attr-compile-error.rs
new file mode 100644
index 000000000000..f5dedf5b103a
--- /dev/null
+++ b/tests/ui/attributes/doc-attr-compile-error.rs
@@ -0,0 +1,3 @@
+#[doc = compile_error!("my error message")]
+//~^ ERROR my error message
+fn main() {}
diff --git a/tests/ui/attributes/doc-attr-compile-error.stderr b/tests/ui/attributes/doc-attr-compile-error.stderr
new file mode 100644
index 000000000000..fed7151ff4b7
--- /dev/null
+++ b/tests/ui/attributes/doc-attr-compile-error.stderr
@@ -0,0 +1,8 @@
+error: my error message
+  --> $DIR/doc-attr-compile-error.rs:1:9
+   |
+LL | #[doc = compile_error!("my error message")]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/attributes/extented-attribute-macro-error.rs b/tests/ui/attributes/extented-attribute-macro-error.rs
index f85a28ad706e..83060024dac9 100644
--- a/tests/ui/attributes/extented-attribute-macro-error.rs
+++ b/tests/ui/attributes/extented-attribute-macro-error.rs
@@ -3,6 +3,5 @@
 #![doc = include_str!("../not_existing_file.md")]
 struct Documented {}
 //~^^ ERROR couldn't read
-//~| ERROR attribute value must be a literal
 
 fn main() {}
diff --git a/tests/ui/attributes/extented-attribute-macro-error.stderr b/tests/ui/attributes/extented-attribute-macro-error.stderr
index ed46cba3d040..7b93b98f64cd 100644
--- a/tests/ui/attributes/extented-attribute-macro-error.stderr
+++ b/tests/ui/attributes/extented-attribute-macro-error.stderr
@@ -4,11 +4,5 @@ error: couldn't read the file
 LL | #![doc = include_str!("../not_existing_file.md")]
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: attribute value must be a literal
-  --> $DIR/extented-attribute-macro-error.rs:3:10
-   |
-LL | #![doc = include_str!("../not_existing_file.md")]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/key-value-expansion-scope.rs b/tests/ui/attributes/key-value-expansion-scope.rs
index b30da2eda24a..6688d698f9ea 100644
--- a/tests/ui/attributes/key-value-expansion-scope.rs
+++ b/tests/ui/attributes/key-value-expansion-scope.rs
@@ -1,29 +1,19 @@
 #![doc = in_root!()] //~ ERROR cannot find macro `in_root`
                      //~| WARN this was previously accepted by the compiler
 #![doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-                    //~| ERROR attribute value must be a literal
 #![doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape`
                            //~| WARN this was previously accepted by the compiler
 #![doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                      //~| ERROR attribute value must be a literal
 
 #[doc = in_root!()] //~ ERROR cannot find macro `in_root` in this scope
-                    //~| ERROR attribute value must be a literal
 #[doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-                   //~| ERROR attribute value must be a literal
 #[doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape` in this scope
-                          //~| ERROR attribute value must be a literal
 #[doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                     //~| ERROR attribute value must be a literal
 fn before() {
     #![doc = in_root!()] //~ ERROR cannot find macro `in_root` in this scope
-                         //~| ERROR attribute value must be a literal
     #![doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-                        //~| ERROR attribute value must be a literal
     #![doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape` in this scope
-                               //~| ERROR attribute value must be a literal
     #![doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                          //~| ERROR attribute value must be a literal
 }
 
 macro_rules! in_root { () => { "" } }
@@ -58,10 +48,8 @@ fn f() {
 }
 
 #[doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                     //~| ERROR attribute value must be a literal
 fn block() {
     #![doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                          //~| ERROR attribute value must be a literal
 
     macro_rules! in_block { () => { "" } }
 
@@ -73,17 +61,13 @@ fn f() {
 
 #[doc = in_root!()] // OK
 #[doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-                   //~| ERROR attribute value must be a literal
 #[doc = in_mod_escape!()] // OK
 #[doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                     //~| ERROR attribute value must be a literal
 fn after() {
     #![doc = in_root!()] // OK
     #![doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-                        //~| ERROR attribute value must be a literal
     #![doc = in_mod_escape!()] // OK
     #![doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
-                          //~| ERROR attribute value must be a literal
 }
 
 fn main() {}
diff --git a/tests/ui/attributes/key-value-expansion-scope.stderr b/tests/ui/attributes/key-value-expansion-scope.stderr
index 70e831729cd4..1387ffe21a37 100644
--- a/tests/ui/attributes/key-value-expansion-scope.stderr
+++ b/tests/ui/attributes/key-value-expansion-scope.stderr
@@ -7,7 +7,7 @@ LL | #![doc = in_mod!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:7:10
+  --> $DIR/key-value-expansion-scope.rs:6:10
    |
 LL | #![doc = in_block!()]
    |          ^^^^^^^^
@@ -15,7 +15,7 @@ LL | #![doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_root` in this scope
-  --> $DIR/key-value-expansion-scope.rs:10:9
+  --> $DIR/key-value-expansion-scope.rs:8:9
    |
 LL | #[doc = in_root!()]
    |         ^^^^^^^
@@ -23,7 +23,7 @@ LL | #[doc = in_root!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod` in this scope
-  --> $DIR/key-value-expansion-scope.rs:12:9
+  --> $DIR/key-value-expansion-scope.rs:9:9
    |
 LL | #[doc = in_mod!()]
    |         ^^^^^^
@@ -31,7 +31,7 @@ LL | #[doc = in_mod!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod_escape` in this scope
-  --> $DIR/key-value-expansion-scope.rs:14:9
+  --> $DIR/key-value-expansion-scope.rs:10:9
    |
 LL | #[doc = in_mod_escape!()]
    |         ^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL | #[doc = in_mod_escape!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:16:9
+  --> $DIR/key-value-expansion-scope.rs:11:9
    |
 LL | #[doc = in_block!()]
    |         ^^^^^^^^
@@ -47,7 +47,7 @@ LL | #[doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_root` in this scope
-  --> $DIR/key-value-expansion-scope.rs:19:14
+  --> $DIR/key-value-expansion-scope.rs:13:14
    |
 LL |     #![doc = in_root!()]
    |              ^^^^^^^
@@ -55,7 +55,7 @@ LL |     #![doc = in_root!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod` in this scope
-  --> $DIR/key-value-expansion-scope.rs:21:14
+  --> $DIR/key-value-expansion-scope.rs:14:14
    |
 LL |     #![doc = in_mod!()]
    |              ^^^^^^
@@ -63,7 +63,7 @@ LL |     #![doc = in_mod!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod_escape` in this scope
-  --> $DIR/key-value-expansion-scope.rs:23:14
+  --> $DIR/key-value-expansion-scope.rs:15:14
    |
 LL |     #![doc = in_mod_escape!()]
    |              ^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     #![doc = in_mod_escape!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:25:14
+  --> $DIR/key-value-expansion-scope.rs:16:14
    |
 LL |     #![doc = in_block!()]
    |              ^^^^^^^^
@@ -79,7 +79,7 @@ LL |     #![doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:60:9
+  --> $DIR/key-value-expansion-scope.rs:50:9
    |
 LL | #[doc = in_block!()]
    |         ^^^^^^^^
@@ -87,7 +87,7 @@ LL | #[doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:63:14
+  --> $DIR/key-value-expansion-scope.rs:52:14
    |
 LL |     #![doc = in_block!()]
    |              ^^^^^^^^
@@ -95,7 +95,7 @@ LL |     #![doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod` in this scope
-  --> $DIR/key-value-expansion-scope.rs:75:9
+  --> $DIR/key-value-expansion-scope.rs:63:9
    |
 LL | #[doc = in_mod!()]
    |         ^^^^^^
@@ -103,7 +103,7 @@ LL | #[doc = in_mod!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:78:9
+  --> $DIR/key-value-expansion-scope.rs:65:9
    |
 LL | #[doc = in_block!()]
    |         ^^^^^^^^
@@ -111,7 +111,7 @@ LL | #[doc = in_block!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_mod` in this scope
-  --> $DIR/key-value-expansion-scope.rs:82:14
+  --> $DIR/key-value-expansion-scope.rs:68:14
    |
 LL |     #![doc = in_mod!()]
    |              ^^^^^^
@@ -119,7 +119,7 @@ LL |     #![doc = in_mod!()]
    = help: have you added the `#[macro_use]` on the module/import?
 
 error: cannot find macro `in_block` in this scope
-  --> $DIR/key-value-expansion-scope.rs:85:14
+  --> $DIR/key-value-expansion-scope.rs:70:14
    |
 LL |     #![doc = in_block!()]
    |              ^^^^^^^^
@@ -138,7 +138,7 @@ LL | #![doc = in_root!()]
    = note: `#[deny(out_of_scope_macro_calls)]` (part of `#[deny(future_incompatible)]`) on by default
 
 error: cannot find macro `in_mod_escape` in the current scope when looking from the crate root
-  --> $DIR/key-value-expansion-scope.rs:5:10
+  --> $DIR/key-value-expansion-scope.rs:4:10
    |
 LL | #![doc = in_mod_escape!()]
    |          ^^^^^^^^^^^^^ not found from the crate root
@@ -148,7 +148,7 @@ LL | #![doc = in_mod_escape!()]
    = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
 
 error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
-  --> $DIR/key-value-expansion-scope.rs:31:9
+  --> $DIR/key-value-expansion-scope.rs:21:9
    |
 LL | #[doc = in_mod!()]
    |         ^^^^^^ not found from module `macros_stay`
@@ -158,7 +158,7 @@ LL | #[doc = in_mod!()]
    = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
 
 error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
-  --> $DIR/key-value-expansion-scope.rs:34:14
+  --> $DIR/key-value-expansion-scope.rs:24:14
    |
 LL |     #![doc = in_mod!()]
    |              ^^^^^^ not found from module `macros_stay`
@@ -168,7 +168,7 @@ LL |     #![doc = in_mod!()]
    = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
 
 error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
-  --> $DIR/key-value-expansion-scope.rs:46:9
+  --> $DIR/key-value-expansion-scope.rs:36:9
    |
 LL | #[doc = in_mod_escape!()]
    |         ^^^^^^^^^^^^^ not found from module `macros_escape`
@@ -178,7 +178,7 @@ LL | #[doc = in_mod_escape!()]
    = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
 
 error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
-  --> $DIR/key-value-expansion-scope.rs:49:14
+  --> $DIR/key-value-expansion-scope.rs:39:14
    |
 LL |     #![doc = in_mod_escape!()]
    |              ^^^^^^^^^^^^^ not found from module `macros_escape`
@@ -187,103 +187,7 @@ LL |     #![doc = in_mod_escape!()]
    = 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 #124535 <https://github.com/rust-lang/rust/issues/124535>
 
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:3:10
-   |
-LL | #![doc = in_mod!()]
-   |          ^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:7:10
-   |
-LL | #![doc = in_block!()]
-   |          ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:10:9
-   |
-LL | #[doc = in_root!()]
-   |         ^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:12:9
-   |
-LL | #[doc = in_mod!()]
-   |         ^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:14:9
-   |
-LL | #[doc = in_mod_escape!()]
-   |         ^^^^^^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:16:9
-   |
-LL | #[doc = in_block!()]
-   |         ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:19:14
-   |
-LL |     #![doc = in_root!()]
-   |              ^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:21:14
-   |
-LL |     #![doc = in_mod!()]
-   |              ^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:23:14
-   |
-LL |     #![doc = in_mod_escape!()]
-   |              ^^^^^^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:25:14
-   |
-LL |     #![doc = in_block!()]
-   |              ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:60:9
-   |
-LL | #[doc = in_block!()]
-   |         ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:63:14
-   |
-LL |     #![doc = in_block!()]
-   |              ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:75:9
-   |
-LL | #[doc = in_mod!()]
-   |         ^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:78:9
-   |
-LL | #[doc = in_block!()]
-   |         ^^^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:82:14
-   |
-LL |     #![doc = in_mod!()]
-   |              ^^^^^^^^^
-
-error: attribute value must be a literal
-  --> $DIR/key-value-expansion-scope.rs:85:14
-   |
-LL |     #![doc = in_block!()]
-   |              ^^^^^^^^^^^
-
-error: aborting due to 38 previous errors
+error: aborting due to 22 previous errors
 
 Future incompatibility report: Future breakage diagnostic:
 error: cannot find macro `in_root` in the current scope when looking from the crate root
@@ -299,7 +203,7 @@ LL | #![doc = in_root!()]
 
 Future breakage diagnostic:
 error: cannot find macro `in_mod_escape` in the current scope when looking from the crate root
-  --> $DIR/key-value-expansion-scope.rs:5:10
+  --> $DIR/key-value-expansion-scope.rs:4:10
    |
 LL | #![doc = in_mod_escape!()]
    |          ^^^^^^^^^^^^^ not found from the crate root
@@ -311,7 +215,7 @@ LL | #![doc = in_mod_escape!()]
 
 Future breakage diagnostic:
 error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
-  --> $DIR/key-value-expansion-scope.rs:31:9
+  --> $DIR/key-value-expansion-scope.rs:21:9
    |
 LL | #[doc = in_mod!()]
    |         ^^^^^^ not found from module `macros_stay`
@@ -323,7 +227,7 @@ LL | #[doc = in_mod!()]
 
 Future breakage diagnostic:
 error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
-  --> $DIR/key-value-expansion-scope.rs:34:14
+  --> $DIR/key-value-expansion-scope.rs:24:14
    |
 LL |     #![doc = in_mod!()]
    |              ^^^^^^ not found from module `macros_stay`
@@ -335,7 +239,7 @@ LL |     #![doc = in_mod!()]
 
 Future breakage diagnostic:
 error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
-  --> $DIR/key-value-expansion-scope.rs:46:9
+  --> $DIR/key-value-expansion-scope.rs:36:9
    |
 LL | #[doc = in_mod_escape!()]
    |         ^^^^^^^^^^^^^ not found from module `macros_escape`
@@ -347,7 +251,7 @@ LL | #[doc = in_mod_escape!()]
 
 Future breakage diagnostic:
 error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
-  --> $DIR/key-value-expansion-scope.rs:49:14
+  --> $DIR/key-value-expansion-scope.rs:39:14
    |
 LL |     #![doc = in_mod_escape!()]
    |              ^^^^^^^^^^^^^ not found from module `macros_escape`
diff --git a/tests/ui/include-macros/invalid-utf8-binary-file.rs b/tests/ui/include-macros/invalid-utf8-binary-file.rs
index c733f07c26f0..24d99c11c237 100644
--- a/tests/ui/include-macros/invalid-utf8-binary-file.rs
+++ b/tests/ui/include-macros/invalid-utf8-binary-file.rs
@@ -7,6 +7,5 @@
 
 #![doc = include_str!(concat!(env!("INVALID_UTF8_BIN")))]
 //~^ ERROR: wasn't a utf-8 file
-//~| ERROR: attribute value must be a literal
 
 fn main() {}
diff --git a/tests/ui/include-macros/invalid-utf8-binary-file.stderr b/tests/ui/include-macros/invalid-utf8-binary-file.stderr
index 232cb5042b72..4ac4def1b00a 100644
--- a/tests/ui/include-macros/invalid-utf8-binary-file.stderr
+++ b/tests/ui/include-macros/invalid-utf8-binary-file.stderr
@@ -6,11 +6,5 @@ LL | #![doc = include_str!(concat!(env!("INVALID_UTF8_BIN")))]
    |
    = note: invalid utf-8 at byte `$BYTE`
 
-error: attribute value must be a literal
-  --> $DIR/invalid-utf8-binary-file.rs:8:10
-   |
-LL | #![doc = include_str!(concat!(env!("INVALID_UTF8_BIN")))]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/path-attr-in-const-block.rs b/tests/ui/resolve/path-attr-in-const-block.rs
index 0ca356b1ddf0..076511d26d6d 100644
--- a/tests/ui/resolve/path-attr-in-const-block.rs
+++ b/tests/ui/resolve/path-attr-in-const-block.rs
@@ -5,6 +5,5 @@ fn main() {
     const {
         #![path = foo!()]
         //~^ ERROR: cannot find macro `foo` in this scope
-        //~| ERROR: attribute value must be a literal
     }
 }
diff --git a/tests/ui/resolve/path-attr-in-const-block.stderr b/tests/ui/resolve/path-attr-in-const-block.stderr
index 19d2745577be..8f9e58157c80 100644
--- a/tests/ui/resolve/path-attr-in-const-block.stderr
+++ b/tests/ui/resolve/path-attr-in-const-block.stderr
@@ -4,11 +4,5 @@ error: cannot find macro `foo` in this scope
 LL |         #![path = foo!()]
    |                   ^^^
 
-error: attribute value must be a literal
-  --> $DIR/path-attr-in-const-block.rs:6:19
-   |
-LL |         #![path = foo!()]
-   |                   ^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 

From b90abe64c1724f6eaac0750fcc7a4a122ca7cad9 Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Sat, 14 Mar 2026 23:25:05 +0700
Subject: [PATCH 0583/1059] constify const Fn*: Destruct

---
 .../src/solve/assembly/structural_traits.rs   | 14 ++++++++-----
 .../src/traits/effects.rs                     | 15 ++++++++-----
 library/coretests/tests/array.rs              | 15 +++++++++++++
 library/coretests/tests/lib.rs                |  1 +
 ...-indestructible-indestructible.next.stderr | 21 +++++++++++++++++++
 ...h-indestructible-indestructible.old.stderr | 21 +++++++++++++++++++
 ...sure-with-indestructible-indestructible.rs | 15 +++++++++++++
 7 files changed, 92 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.next.stderr
 create mode 100644 tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.old.stderr
 create mode 100644 tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.rs

diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index cd74e87b670f..433cad188bb6 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -797,12 +797,16 @@ pub(in crate::solve) fn const_conditions_for_destruct<I: Interner>(
         | ty::Infer(ty::InferTy::FloatVar(_) | ty::InferTy::IntVar(_))
         | ty::Error(_) => Ok(vec![]),
 
-        // Coroutines and closures could implement `[const] Drop`,
+        // Closures are [const] Destruct when all of their upvars (captures) are [const] Destruct.
+        ty::Closure(_, args) => {
+            let closure_args = args.as_closure();
+            Ok(vec![ty::TraitRef::new(cx, destruct_def_id, [closure_args.tupled_upvars_ty()])])
+        }
+        // Coroutines could implement `[const] Drop`,
         // but they don't really need to right now.
-        ty::Closure(_, _)
-        | ty::CoroutineClosure(_, _)
-        | ty::Coroutine(_, _)
-        | ty::CoroutineWitness(_, _) => Err(NoSolution),
+        ty::CoroutineClosure(_, _) | ty::Coroutine(_, _) | ty::CoroutineWitness(_, _) => {
+            Err(NoSolution)
+        }
 
         // FIXME(unsafe_binders): Unsafe binders could implement `[const] Drop`
         // if their inner type implements it.
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index 026ab3a527a1..469e24c9c248 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -472,12 +472,17 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
         | ty::Infer(ty::InferTy::FloatVar(_) | ty::InferTy::IntVar(_))
         | ty::Error(_) => thin_vec![],
 
-        // Coroutines and closures could implement `[const] Drop`,
+        // Closures are [const] Destruct when all of their upvars (captures) are [const] Destruct.
+        ty::Closure(_, args) => {
+            let closure_args = args.as_closure();
+            thin_vec![ty::TraitRef::new(tcx, destruct_def_id, [closure_args.tupled_upvars_ty()])]
+        }
+
+        // Coroutines could implement `[const] Drop`,
         // but they don't really need to right now.
-        ty::Closure(_, _)
-        | ty::CoroutineClosure(_, _)
-        | ty::Coroutine(_, _)
-        | ty::CoroutineWitness(_, _) => return Err(EvaluationFailure::NoSolution),
+        ty::CoroutineClosure(_, _) | ty::Coroutine(_, _) | ty::CoroutineWitness(_, _) => {
+            return Err(EvaluationFailure::NoSolution);
+        }
 
         // FIXME(unsafe_binders): Unsafe binders could implement `[const] Drop`
         // if their inner type implements it.
diff --git a/library/coretests/tests/array.rs b/library/coretests/tests/array.rs
index 2b4429092e98..36f88409f2d2 100644
--- a/library/coretests/tests/array.rs
+++ b/library/coretests/tests/array.rs
@@ -741,3 +741,18 @@ const fn maybe_doubler(x: usize) -> Option<usize> {
     struct Zst;
     assert_eq!([(); 10].try_map(|()| Some(Zst)), Some([const { Zst }; 10]));
 }
+
+#[test]
+const fn extra_const_array_ops() {
+    let x: [u8; 4] =
+        { std::array::from_fn(const |i| i + 4).map(const |x| x * 2).map(const |x| x as _) };
+    let y = 4;
+    struct Z(u16);
+    impl const Drop for Z {
+        fn drop(&mut self) {}
+    }
+    let w = Z(2);
+    let _x: [u8; 4] = {
+        std::array::from_fn(const |_| x[0] + y).map(const |x| x * (w.0 as u8)).map(const |x| x as _)
+    };
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 72112f8b0113..e11eaece5c3b 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -17,6 +17,7 @@
 #![feature(const_bool)]
 #![feature(const_cell_traits)]
 #![feature(const_clone)]
+#![feature(const_closures)]
 #![feature(const_cmp)]
 #![feature(const_convert)]
 #![feature(const_default)]
diff --git a/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.next.stderr b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.next.stderr
new file mode 100644
index 000000000000..8b5c4f59fbde
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.next.stderr
@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `Vec<u8>: const Destruct` is not satisfied
+  --> $DIR/const-closure-with-indestructible-indestructible.rs:10:16
+   |
+LL |           i_need(const || {
+   |  _________------_^
+   | |         |
+   | |         required by a bound introduced by this call
+LL | |
+LL | |             let y = v;
+LL | |         })
+   | |_________^
+   |
+note: required by a bound in `i_need`
+  --> $DIR/const-closure-with-indestructible-indestructible.rs:5:20
+   |
+LL | const fn i_need<F: [const] std::marker::Destruct>(x: F) {}
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `i_need`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.old.stderr b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.old.stderr
new file mode 100644
index 000000000000..8b5c4f59fbde
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.old.stderr
@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `Vec<u8>: const Destruct` is not satisfied
+  --> $DIR/const-closure-with-indestructible-indestructible.rs:10:16
+   |
+LL |           i_need(const || {
+   |  _________------_^
+   | |         |
+   | |         required by a bound introduced by this call
+LL | |
+LL | |             let y = v;
+LL | |         })
+   | |_________^
+   |
+note: required by a bound in `i_need`
+  --> $DIR/const-closure-with-indestructible-indestructible.rs:5:20
+   |
+LL | const fn i_need<F: [const] std::marker::Destruct>(x: F) {}
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `i_need`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.rs b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.rs
new file mode 100644
index 000000000000..d26260dd2d07
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-closure-with-indestructible-indestructible.rs
@@ -0,0 +1,15 @@
+//@revisions: next old
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+#![feature(const_trait_impl, const_closures, const_destruct)]
+const fn i_need<F: [const] std::marker::Destruct>(x: F) {}
+
+fn main() {
+    const {
+        let v = Vec::<u8>::new();
+        i_need(const || {
+            //~^ ERROR the trait bound
+            let y = v;
+        })
+    };
+}

From 681b48e228388e94fa603b624da78ce5d7fa6cd4 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 17 Mar 2026 18:50:39 +0100
Subject: [PATCH 0584/1059] unstable impl of `From<{i64, u64}> for f128`

---
 library/core/src/convert/num.rs               | 10 ++---
 .../feature-gate-f128.e2015.stderr            | 37 +++++++++++++++++--
 .../feature-gate-f128.e2018.stderr            | 37 +++++++++++++++++--
 tests/ui/feature-gates/feature-gate-f128.rs   |  5 +++
 4 files changed, 77 insertions(+), 12 deletions(-)

diff --git a/library/core/src/convert/num.rs b/library/core/src/convert/num.rs
index 40d61de50aaf..b80980219b1e 100644
--- a/library/core/src/convert/num.rs
+++ b/library/core/src/convert/num.rs
@@ -70,8 +70,8 @@ fn from(b: bool) -> Self {
 
 /// Implement `From<$small>` for `$large`
 macro_rules! impl_from {
-    ($small:ty => $large:ty, #[$attr:meta]) => {
-        #[$attr]
+    ($small:ty => $large:ty, $(#[$attrs:meta]),+) => {
+        $(#[$attrs])+
         #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const From<$small> for $large {
             #[doc = concat!("Converts from [`", stringify!($small), "`] to [`", stringify!($large), "`] losslessly.")]
@@ -157,8 +157,7 @@ fn from(small: $small) -> Self {
 impl_from!(i16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(i32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(i32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
-// FIXME(f128): This impl would allow using `f128` on stable before it is stabilised.
-// impl_from!(i64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
+impl_from!(i64 => f128, #[unstable(feature = "f128", issue = "116909")], #[unstable_feature_bound(f128)]);
 
 // unsigned integer -> float
 impl_from!(u8 => f16, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
@@ -170,8 +169,7 @@ fn from(small: $small) -> Self {
 impl_from!(u16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(u32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(u32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
-// FIXME(f128): This impl would allow using `f128` on stable before it is stabilised.
-// impl_from!(u64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
+impl_from!(u64 => f128, #[unstable(feature = "f128", issue = "116909")], #[unstable_feature_bound(f128)]);
 
 // float -> float
 // FIXME(f16,f128): adding additional `From<{float}>` impls to `f32` breaks inference. See
diff --git a/tests/ui/feature-gates/feature-gate-f128.e2015.stderr b/tests/ui/feature-gates/feature-gate-f128.e2015.stderr
index 7e8ea5e948dc..627010a93547 100644
--- a/tests/ui/feature-gates/feature-gate-f128.e2015.stderr
+++ b/tests/ui/feature-gates/feature-gate-f128.e2015.stderr
@@ -19,7 +19,27 @@ LL |     let a: f128 = 100.0;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the type `f128` is unstable
-  --> $DIR/feature-gate-f128.rs:16:11
+  --> $DIR/feature-gate-f128.rs:13:12
+   |
+LL |     let d: f128 = 1i64.into();
+   |            ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the type `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:16:12
+   |
+LL |     let e: f128 = 1u64.into();
+   |            ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the type `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:21:11
    |
 LL | fn foo(a: f128) {}
    |           ^^^^
@@ -29,7 +49,7 @@ LL | fn foo(a: f128) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the type `f128` is unstable
-  --> $DIR/feature-gate-f128.rs:19:8
+  --> $DIR/feature-gate-f128.rs:24:8
    |
 LL |     a: f128,
    |        ^^^^
@@ -58,6 +78,17 @@ LL |     let c = 0f128;
    = help: add `#![feature(f128)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 6 previous errors
+error[E0658]: use of unstable library feature `f128`
+  --> $DIR/feature-gate-f128.rs:13:24
+   |
+LL |     let d: f128 = 1i64.into();
+   |                        ^^^^
+   |
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: required for `f128` to implement `From<i64>`
+   = note: required for `i64` to implement `Into<f128>`
+
+error: aborting due to 9 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-f128.e2018.stderr b/tests/ui/feature-gates/feature-gate-f128.e2018.stderr
index 7e8ea5e948dc..627010a93547 100644
--- a/tests/ui/feature-gates/feature-gate-f128.e2018.stderr
+++ b/tests/ui/feature-gates/feature-gate-f128.e2018.stderr
@@ -19,7 +19,27 @@ LL |     let a: f128 = 100.0;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the type `f128` is unstable
-  --> $DIR/feature-gate-f128.rs:16:11
+  --> $DIR/feature-gate-f128.rs:13:12
+   |
+LL |     let d: f128 = 1i64.into();
+   |            ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the type `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:16:12
+   |
+LL |     let e: f128 = 1u64.into();
+   |            ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the type `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:21:11
    |
 LL | fn foo(a: f128) {}
    |           ^^^^
@@ -29,7 +49,7 @@ LL | fn foo(a: f128) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the type `f128` is unstable
-  --> $DIR/feature-gate-f128.rs:19:8
+  --> $DIR/feature-gate-f128.rs:24:8
    |
 LL |     a: f128,
    |        ^^^^
@@ -58,6 +78,17 @@ LL |     let c = 0f128;
    = help: add `#![feature(f128)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 6 previous errors
+error[E0658]: use of unstable library feature `f128`
+  --> $DIR/feature-gate-f128.rs:13:24
+   |
+LL |     let d: f128 = 1i64.into();
+   |                        ^^^^
+   |
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: required for `f128` to implement `From<i64>`
+   = note: required for `i64` to implement `Into<f128>`
+
+error: aborting due to 9 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-f128.rs b/tests/ui/feature-gates/feature-gate-f128.rs
index dcbe60e934ae..13851b72c70f 100644
--- a/tests/ui/feature-gates/feature-gate-f128.rs
+++ b/tests/ui/feature-gates/feature-gate-f128.rs
@@ -10,6 +10,11 @@ pub fn main() {
     let a: f128 = 100.0; //~ ERROR the type `f128` is unstable
     let b = 0.0f128; //~ ERROR the type `f128` is unstable
     let c = 0f128; //~ ERROR the type `f128` is unstable
+    let d: f128 = 1i64.into();
+    //~^ ERROR the type `f128` is unstable
+    //~| ERROR use of unstable library feature `f128`
+    let e: f128 = 1u64.into();
+    //~^ ERROR the type `f128` is unstable
     foo(1.23);
 }
 

From 3f08f6759a6583666cf5075e7b0ffafc20f19a50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Tue, 17 Mar 2026 17:54:01 +0000
Subject: [PATCH 0585/1059] Suggest using equality comparison instead of
 pattern matching on non-strutural constant in pattern

```
error: constant of non-structural type `partial_eq::S` in a pattern
  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:16:18
   |
LL |     struct S;
   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
...
LL |     const C: S = S;
   |     ---------- constant defined here
...
LL |             Some(C) => {}
   |                  ^ constant of non-structural type
   |
note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
   |
LL |     impl PartialEq<S> for S {
   |     ^^^^^^^^^^^^^^^^^^^^^^^
help: add a condition to the match arm checking for equality
   |
LL -             Some(C) => {}
LL +             Some(binding) if binding == C => {}
   |
```
---
 compiler/rustc_mir_build/src/errors.rs        |  84 +++++-
 .../src/thir/pattern/const_to_pat.rs          |  67 ++++-
 .../const_in_pattern/cross-crate-fail.rs      |   2 +-
 .../const_in_pattern/cross-crate-fail.stderr  |  16 +-
 .../const_in_pattern/no-eq-branch-fail.stderr |   5 +
 .../reject_non_structural.stderr              |  50 ++++
 ..._comparison_instead_of_pattern_matching.rs |  50 ++++
 ...parison_instead_of_pattern_matching.stderr | 252 ++++++++++++++++++
 tests/ui/consts/issue-89088.stderr            |   7 +-
 tests/ui/consts/match_ice.stderr              |   5 +
 .../implicit-const-deref.stderr               |   7 +-
 tests/ui/pattern/issue-115599.stderr          |   7 +-
 .../const-partial_eq-fallback-ice.stderr      |   5 +
 ...-hide-behind-direct-struct-embedded.stderr |   5 +
 ...ant-hide-behind-direct-struct-param.stderr |   5 +
 ...ide-behind-doubly-indirect-embedded.stderr |   5 +
 ...t-hide-behind-doubly-indirect-param.stderr |   5 +
 ...ide-behind-indirect-struct-embedded.stderr |   5 +
 ...t-hide-behind-indirect-struct-param.stderr |   5 +
 ...-match-ref-ref-forbidden-without-eq.stderr |  10 +
 .../match-requires-both-partialeq-and-eq.rs   |   4 +-
 ...atch-requires-both-partialeq-and-eq.stderr |   7 +-
 22 files changed, 595 insertions(+), 13 deletions(-)
 create mode 100644 tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
 create mode 100644 tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr

diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index c362badd033c..87c69f60fd31 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -1053,17 +1053,97 @@ pub(crate) struct TypeNotStructural<'tcx> {
     #[primary_span]
     #[label("constant of non-structural type")]
     pub(crate) span: Span,
-    #[label("`{$ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns")]
+    #[label(
+        "{$is_local ->
+        *[true] `{$ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+        [false] `{$ty}` is not usable in patterns
+    }"
+    )]
     pub(crate) ty_def_span: Span,
     pub(crate) ty: Ty<'tcx>,
     #[note(
-        "the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details"
+        "the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see \
+         https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details"
     )]
     pub(crate) manual_partialeq_impl_span: Option<Span>,
     #[note(
         "see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details"
     )]
     pub(crate) manual_partialeq_impl_note: bool,
+    #[subdiagnostic]
+    pub(crate) suggestion: Option<SuggestEq<'tcx>>,
+    pub(crate) is_local: bool,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum SuggestEq<'tcx> {
+    #[multipart_suggestion(
+        "{$manual_partialeq_impl ->
+            [false] if `{$ty}` manually implemented `PartialEq`, you could add
+            *[true] add
+        } a condition to the match arm checking for equality",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    AddIf {
+        #[suggestion_part(code = "binding")]
+        pat_span: Span,
+        #[suggestion_part(code = " if binding == {name}")]
+        if_span: Span,
+        name: String,
+        ty: Ty<'tcx>,
+        manual_partialeq_impl: bool,
+    },
+    #[multipart_suggestion(
+        "{$manual_partialeq_impl ->
+            [false] if `{$ty}` manually implemented `PartialEq`, you could add
+            *[true] add
+        } a check for equality to the condition of the match arm",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    AddToIf {
+        #[suggestion_part(code = "binding")]
+        pat_span: Span,
+        #[suggestion_part(code = " && binding == {name}")]
+        span: Span,
+        name: String,
+        ty: Ty<'tcx>,
+        manual_partialeq_impl: bool,
+    },
+    #[multipart_suggestion(
+        "{$manual_partialeq_impl ->
+            [false] if `{$ty}` manually implemented `PartialEq`, you could check
+            *[true] check
+        } for equality instead of pattern matching",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    AddToLetChain {
+        #[suggestion_part(code = "binding")]
+        pat_span: Span,
+        #[suggestion_part(code = " && binding == {name}")]
+        span: Span,
+        name: String,
+        ty: Ty<'tcx>,
+        manual_partialeq_impl: bool,
+    },
+    #[multipart_suggestion(
+        "{$manual_partialeq_impl ->
+            [false] if `{$ty}` manually implemented `PartialEq`, you could check
+            *[true] check
+        } for equality instead of pattern matching",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    ReplaceWithEq {
+        #[suggestion_part(code = "")]
+        removal: Span,
+        #[suggestion_part(code = " == ")]
+        eq: Span,
+        ty: Ty<'tcx>,
+        manual_partialeq_impl: bool,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index ff9d456f7e70..2b9c3403b92b 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -22,7 +22,7 @@
 use super::PatCtxt;
 use crate::errors::{
     ConstPatternDependsOnGenericParameter, CouldNotEvalConstPattern, InvalidPattern, NaNPattern,
-    PointerPattern, TypeNotPartialEq, TypeNotStructural, UnionPattern, UnsizedPattern,
+    PointerPattern, SuggestEq, TypeNotPartialEq, TypeNotStructural, UnionPattern, UnsizedPattern,
 };
 
 impl<'tcx> PatCtxt<'tcx> {
@@ -224,13 +224,78 @@ fn valtree_to_pat(&self, value: ty::Value<'tcx>) -> Box<Pat<'tcx>> {
                         }
                         _ => (None, true),
                     };
+                let manual_partialeq_impl =
+                    manual_partialeq_impl_note || manual_partialeq_impl_span.is_some();
+                let is_local = adt_def.did().is_local();
                 let ty_def_span = tcx.def_span(adt_def.did());
+                let suggestion = if let Ok(name) = tcx.sess.source_map().span_to_snippet(self.span)
+                    && (is_local || manual_partialeq_impl)
+                {
+                    let mut hir_id = self.id;
+                    while let hir::Node::Pat(pat) = tcx.parent_hir_node(hir_id) {
+                        hir_id = pat.hir_id;
+                    }
+                    match tcx.parent_hir_node(hir_id) {
+                        hir::Node::Arm(hir::Arm { pat, guard: None, .. }) => {
+                            // Add an if condition to the match arm.
+                            Some(SuggestEq::AddIf {
+                                if_span: pat.span.shrink_to_hi(),
+                                pat_span: self.span,
+                                name,
+                                ty,
+                                manual_partialeq_impl,
+                            })
+                        }
+                        hir::Node::Arm(hir::Arm { guard: Some(guard), .. }) => {
+                            // Modify the the match arm if condition and add a check for equality.
+                            Some(SuggestEq::AddToIf {
+                                span: guard.span.shrink_to_hi(),
+                                pat_span: self.span,
+                                name,
+                                ty,
+                                manual_partialeq_impl,
+                            })
+                        }
+                        hir::Node::Expr(hir::Expr {
+                            kind: hir::ExprKind::Let(let_expr),
+                            span,
+                            ..
+                        }) => {
+                            if let_expr.pat.span == self.span {
+                                // `if let CONST = expr` -> `if CONST == expr`.
+                                Some(SuggestEq::ReplaceWithEq {
+                                    removal: span.until(self.span),
+                                    eq: self.span.between(let_expr.init.span),
+                                    ty,
+                                    manual_partialeq_impl,
+                                })
+                            } else if tcx.sess.edition().at_least_rust_2024() {
+                                // `if let Some(CONST) = expr` ->
+                                // `if let Some(binding) = expr && binding == CONST`.
+                                Some(SuggestEq::AddToLetChain {
+                                    span: span.shrink_to_hi(),
+                                    pat_span: self.span,
+                                    name,
+                                    ty,
+                                    manual_partialeq_impl,
+                                })
+                            } else {
+                                None
+                            }
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
                 let err = TypeNotStructural {
                     span,
                     ty,
                     ty_def_span,
                     manual_partialeq_impl_span,
                     manual_partialeq_impl_note,
+                    is_local,
+                    suggestion,
                 };
                 return self.mk_err(tcx.dcx().create_err(err), ty);
             }
diff --git a/tests/ui/consts/const_in_pattern/cross-crate-fail.rs b/tests/ui/consts/const_in_pattern/cross-crate-fail.rs
index f02e780f30e3..59bd040e3744 100644
--- a/tests/ui/consts/const_in_pattern/cross-crate-fail.rs
+++ b/tests/ui/consts/const_in_pattern/cross-crate-fail.rs
@@ -14,7 +14,7 @@ fn main() {
     }
 
     match None {
-        <Defaulted as consts::AssocConst>::SOME  => panic!(),
+        <Defaulted as consts::AssocConst>::SOME => panic!(),
         //~^ ERROR constant of non-structural type `CustomEq` in a pattern
         _ => {}
     }
diff --git a/tests/ui/consts/const_in_pattern/cross-crate-fail.stderr b/tests/ui/consts/const_in_pattern/cross-crate-fail.stderr
index 7cada8836450..452c3ee93f35 100644
--- a/tests/ui/consts/const_in_pattern/cross-crate-fail.stderr
+++ b/tests/ui/consts/const_in_pattern/cross-crate-fail.stderr
@@ -7,28 +7,38 @@ LL |         consts::SOME => panic!(),
   ::: $DIR/auxiliary/consts.rs:1:1
    |
 LL | pub struct CustomEq;
-   | ------------------- `CustomEq` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   | ------------------- `CustomEq` is not usable in patterns
 ...
 LL | pub const SOME: Option<CustomEq> = Some(CustomEq);
    | -------------------------------- constant defined here
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         consts::SOME => panic!(),
+LL +         binding if binding == consts::SOME => panic!(),
+   |
 
 error: constant of non-structural type `CustomEq` in a pattern
   --> $DIR/cross-crate-fail.rs:17:9
    |
-LL |         <Defaulted as consts::AssocConst>::SOME  => panic!(),
+LL |         <Defaulted as consts::AssocConst>::SOME => panic!(),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constant of non-structural type
    |
   ::: $DIR/auxiliary/consts.rs:1:1
    |
 LL | pub struct CustomEq;
-   | ------------------- `CustomEq` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   | ------------------- `CustomEq` is not usable in patterns
 ...
 LL |     const SOME: Option<CustomEq> = Some(CustomEq);
    |     ---------------------------- constant defined here
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         <Defaulted as consts::AssocConst>::SOME => panic!(),
+LL +         binding if binding == <Defaulted as consts::AssocConst>::SOME => panic!(),
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr b/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
index 154c94c6d385..24bc201b636d 100644
--- a/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
+++ b/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
@@ -11,6 +11,11 @@ LL |         BAR_BAZ => panic!(),
    |         ^^^^^^^ constant of non-structural type
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         BAR_BAZ => panic!(),
+LL +         binding if binding == BAR_BAZ => panic!(),
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_in_pattern/reject_non_structural.stderr b/tests/ui/consts/const_in_pattern/reject_non_structural.stderr
index fa16d0b06a7f..402e4aa1e148 100644
--- a/tests/ui/consts/const_in_pattern/reject_non_structural.stderr
+++ b/tests/ui/consts/const_in_pattern/reject_non_structural.stderr
@@ -14,6 +14,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Derive::Some(NoDerive) { ENUM => dbg!(ENUM), _ => panic!("whoops"), };
+LL +     match Derive::Some(NoDerive) { binding if binding == ENUM => dbg!(ENUM), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:65:28
@@ -31,6 +36,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Some(NoDerive) { FIELD => dbg!(FIELD), _ => panic!("whoops"), };
+LL +     match Some(NoDerive) { binding if binding == FIELD => dbg!(FIELD), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:71:27
@@ -48,6 +58,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Some(NoDerive) {INDIRECT => dbg!(INDIRECT), _ => panic!("whoops"), };
+LL +     match Some(NoDerive) {binding if binding == INDIRECT => dbg!(INDIRECT), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:76:36
@@ -65,6 +80,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match (None, Some(NoDerive)) { TUPLE => dbg!(TUPLE), _ => panic!("whoops"), };
+LL +     match (None, Some(NoDerive)) { binding if binding == TUPLE => dbg!(TUPLE), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:81:28
@@ -82,6 +102,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Some(NoDerive) { TYPE_ASCRIPTION => dbg!(TYPE_ASCRIPTION), _ => panic!("whoops"), };
+LL +     match Some(NoDerive) { binding if binding == TYPE_ASCRIPTION => dbg!(TYPE_ASCRIPTION), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:86:36
@@ -99,6 +124,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match [None, Some(NoDerive)] { ARRAY => dbg!(ARRAY), _ => panic!("whoops"), };
+LL +     match [None, Some(NoDerive)] { binding if binding == ARRAY => dbg!(ARRAY), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:91:33
@@ -116,6 +146,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match [Some(NoDerive); 2] { REPEAT => dbg!(REPEAT), _ => panic!("whoops"), };
+LL +     match [Some(NoDerive); 2] { binding if binding == REPEAT => dbg!(REPEAT), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:97:28
@@ -134,6 +169,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Some(NoDerive) { NoDerive::ASSOC => dbg!(NoDerive::ASSOC), _ => panic!("whoops"), };
+LL +     match Some(NoDerive) { binding if binding == NoDerive::ASSOC => dbg!(NoDerive::ASSOC), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:102:28
@@ -151,6 +191,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match Some(NoDerive) { BLOCK => dbg!(BLOCK), _ => panic!("whoops"), };
+LL +     match Some(NoDerive) { binding if binding == BLOCK => dbg!(BLOCK), _ => panic!("whoops"), };
+   |
 
 error: constant of non-structural type `NoDerive` in a pattern
   --> $DIR/reject_non_structural.rs:107:29
@@ -168,6 +213,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -     match &Some(NoDerive) { ADDR_OF => dbg!(ADDR_OF), _ => panic!("whoops"), };
+LL +     match &Some(NoDerive) { binding if binding == ADDR_OF => dbg!(ADDR_OF), _ => panic!("whoops"), };
+   |
 
 error: aborting due to 10 previous errors
 
diff --git a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
new file mode 100644
index 000000000000..f8ada6914fcb
--- /dev/null
+++ b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
@@ -0,0 +1,50 @@
+//@ edition:2024
+// #42753
+mod partial_eq {
+    struct S;
+    impl PartialEq<S> for S {
+        fn eq(&self, _: &S) -> bool {
+            true
+        }
+    }
+
+    const C: S = S;
+    const V: Vec<()> = vec![];
+
+    fn foo() {
+        match Some(S) {
+            Some(C) => {} //~ ERROR: constant of non-structural type
+            Some(C) if true => {} //~ ERROR: constant of non-structural type
+            None => {}
+        }
+        if let Some(C) = Some(S) {} //~ ERROR: constant of non-structural type
+        if let Some(C) = Some(S) && let Some(1) = Some(2) {} //~ ERROR: constant of non-structural type
+        let Some(C) = Some(S) else { return; }; //~ ERROR: constant of non-structural type
+        match vec![] {
+            V => {} //~ ERROR: constant of non-structural type
+            _ => {}
+        }
+        if let V = vec![] {} //~ ERROR: constant of non-structural type
+        let V = vec![] else { return; }; //~ ERROR: constant of non-structural type
+        // ^ maybe suggest if V != vec![] { return; } ?
+    }
+}
+
+mod not_partial_eq {
+    struct S;
+
+    const C: S = S;
+
+    fn foo() {
+        match Some(S) {
+            Some(C) => {} //~ ERROR: constant of non-structural type
+            Some(C) if true => {} //~ ERROR: constant of non-structural type
+            None => {}
+        }
+        if let Some(C) = Some(S) {} //~ ERROR: constant of non-structural type
+        if let Some(C) = Some(S) && let Some(1) = Some(2) {} //~ ERROR: constant of non-structural type
+        let Some(C) = Some(S) else { return; }; //~ ERROR: constant of non-structural type
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
new file mode 100644
index 000000000000..fc3af8104e59
--- /dev/null
+++ b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
@@ -0,0 +1,252 @@
+error: constant of non-structural type `partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:16:18
+   |
+LL |     struct S;
+   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |             Some(C) => {}
+   |                  ^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
+   |
+LL |     impl PartialEq<S> for S {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -             Some(C) => {}
+LL +             Some(binding) if binding == C => {}
+   |
+
+error: constant of non-structural type `partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:17:18
+   |
+LL |     struct S;
+   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |             Some(C) if true => {}
+   |                  ^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
+   |
+LL |     impl PartialEq<S> for S {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: add a check for equality to the condition of the match arm
+   |
+LL -             Some(C) if true => {}
+LL +             Some(binding) if true && binding == C => {}
+   |
+
+error: constant of non-structural type `partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:20:21
+   |
+LL |     struct S;
+   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         if let Some(C) = Some(S) {}
+   |                     ^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
+   |
+LL |     impl PartialEq<S> for S {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: check for equality instead of pattern matching
+   |
+LL -         if let Some(C) = Some(S) {}
+LL +         if let Some(binding) = Some(S) && binding == C {}
+   |
+
+error: constant of non-structural type `partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:21:21
+   |
+LL |     struct S;
+   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         if let Some(C) = Some(S) && let Some(1) = Some(2) {}
+   |                     ^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
+   |
+LL |     impl PartialEq<S> for S {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: check for equality instead of pattern matching
+   |
+LL -         if let Some(C) = Some(S) && let Some(1) = Some(2) {}
+LL +         if let Some(binding) = Some(S) && binding == C && let Some(1) = Some(2) {}
+   |
+
+error: constant of non-structural type `partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:22:18
+   |
+LL |     struct S;
+   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         let Some(C) = Some(S) else { return; };
+   |                  ^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
+   |
+LL |     impl PartialEq<S> for S {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: constant of non-structural type `Vec<()>` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:24:13
+   |
+LL |     const V: Vec<()> = vec![];
+   |     ---------------- constant defined here
+...
+LL |             V => {}
+   |             ^ constant of non-structural type
+   |
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+   |
+   = note: `Vec<()>` is not usable in patterns
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -             V => {}
+LL +             binding if binding == V => {}
+   |
+
+error: constant of non-structural type `Vec<()>` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:27:16
+   |
+LL |     const V: Vec<()> = vec![];
+   |     ---------------- constant defined here
+...
+LL |         if let V = vec![] {}
+   |                ^ constant of non-structural type
+   |
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+   |
+   = note: `Vec<()>` is not usable in patterns
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+
+error: constant of non-structural type `Vec<()>` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:28:13
+   |
+LL |     const V: Vec<()> = vec![];
+   |     ---------------- constant defined here
+...
+LL |         let V = vec![] else { return; };
+   |             ^ constant of non-structural type
+   |
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+   |
+   = note: `Vec<()>` is not usable in patterns
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+
+error: constant of non-structural type `not_partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:40:18
+   |
+LL |     struct S;
+   |     -------- `not_partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+LL |
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |             Some(C) => {}
+   |                  ^ constant of non-structural type
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -             Some(C) => {}
+LL +             Some(binding) if binding == C => {}
+   |
+
+error: constant of non-structural type `not_partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:41:18
+   |
+LL |     struct S;
+   |     -------- `not_partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+LL |
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |             Some(C) if true => {}
+   |                  ^ constant of non-structural type
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a check for equality to the condition of the match arm
+   |
+LL -             Some(C) if true => {}
+LL +             Some(binding) if true && binding == C => {}
+   |
+
+error: constant of non-structural type `not_partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:44:21
+   |
+LL |     struct S;
+   |     -------- `not_partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+LL |
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         if let Some(C) = Some(S) {}
+   |                     ^ constant of non-structural type
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: check for equality instead of pattern matching
+   |
+LL -         if let Some(C) = Some(S) {}
+LL +         if let Some(binding) = Some(S) && binding == C {}
+   |
+
+error: constant of non-structural type `not_partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:45:21
+   |
+LL |     struct S;
+   |     -------- `not_partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+LL |
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         if let Some(C) = Some(S) && let Some(1) = Some(2) {}
+   |                     ^ constant of non-structural type
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: check for equality instead of pattern matching
+   |
+LL -         if let Some(C) = Some(S) && let Some(1) = Some(2) {}
+LL +         if let Some(binding) = Some(S) && binding == C && let Some(1) = Some(2) {}
+   |
+
+error: constant of non-structural type `not_partial_eq::S` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:46:18
+   |
+LL |     struct S;
+   |     -------- `not_partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+LL |
+LL |     const C: S = S;
+   |     ---------- constant defined here
+...
+LL |         let Some(C) = Some(S) else { return; };
+   |                  ^ constant of non-structural type
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/consts/issue-89088.stderr b/tests/ui/consts/issue-89088.stderr
index 5008a2eada8f..586158375ecc 100644
--- a/tests/ui/consts/issue-89088.stderr
+++ b/tests/ui/consts/issue-89088.stderr
@@ -9,9 +9,14 @@ LL |         FOO => todo!(),
    |
   --> $SRC_DIR/alloc/src/borrow.rs:LL:COL
    |
-   = note: `Cow<'_, str>` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   = note: `Cow<'_, str>` is not usable in patterns
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         FOO => todo!(),
+LL +         binding if binding == FOO => todo!(),
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/match_ice.stderr b/tests/ui/consts/match_ice.stderr
index 95e96bbbd677..d0742e18f6bb 100644
--- a/tests/ui/consts/match_ice.stderr
+++ b/tests/ui/consts/match_ice.stderr
@@ -11,6 +11,11 @@ LL |         C => {}
    |         ^ constant of non-structural type
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         C => {}
+LL +         binding if binding == C => {}
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
index a75542ffd4ad..7c176162ad18 100644
--- a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
+++ b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
@@ -9,9 +9,14 @@ LL |         EMPTY => {}
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
-   = note: `Vec<()>` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   = note: `Vec<()>` is not usable in patterns
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: add a condition to the match arm checking for equality
+   |
+LL -         EMPTY => {}
+LL +         binding if binding == EMPTY => {}
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/issue-115599.stderr b/tests/ui/pattern/issue-115599.stderr
index ed465ea0bbad..f776623ff75b 100644
--- a/tests/ui/pattern/issue-115599.stderr
+++ b/tests/ui/pattern/issue-115599.stderr
@@ -9,9 +9,14 @@ LL |     if let CONST_STRING = empty_str {}
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
-   = note: `Vec<u8>` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   = note: `Vec<u8>` is not usable in patterns
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: check for equality instead of pattern matching
+   |
+LL -     if let CONST_STRING = empty_str {}
+LL +     if CONST_STRING == empty_str {}
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr b/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
index f9da0430f2ef..66aa551c5884 100644
--- a/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
+++ b/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq<usize> for MyType {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: check for equality instead of pattern matching
+   |
+LL -     if let CONSTANT = &&MyType {
+LL +     if CONSTANT == &&MyType {
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
index 8787d140e17f..ebba8253e07f 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_DIRECT_INLINE => { panic!("WRAP_DIRECT_INLINE matched itself"); }
+LL +         binding if binding == WRAP_DIRECT_INLINE => { panic!("WRAP_DIRECT_INLINE matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
index ec836db02ad8..849b5cc11622 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_DIRECT_PARAM => { panic!("WRAP_DIRECT_PARAM matched itself"); }
+LL +         binding if binding == WRAP_DIRECT_PARAM => { panic!("WRAP_DIRECT_PARAM matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.stderr
index fdc16fe300c2..cb19c4131325 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_DOUBLY_INDIRECT_INLINE => { panic!("WRAP_DOUBLY_INDIRECT_INLINE matched itself"); }
+LL +         binding if binding == WRAP_DOUBLY_INDIRECT_INLINE => { panic!("WRAP_DOUBLY_INDIRECT_INLINE matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.stderr
index b46fc041f14b..8dffde7713e3 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_DOUBLY_INDIRECT_PARAM => { panic!("WRAP_DOUBLY_INDIRECT_PARAM matched itself"); }
+LL +         binding if binding == WRAP_DOUBLY_INDIRECT_PARAM => { panic!("WRAP_DOUBLY_INDIRECT_PARAM matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.stderr
index 70f39aa01d82..7b47540017a7 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_INDIRECT_INLINE => { panic!("WRAP_INDIRECT_INLINE matched itself"); }
+LL +         binding if binding == WRAP_INDIRECT_INLINE => { panic!("WRAP_INDIRECT_INLINE matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.stderr
index fceb3acb025e..958b731616f1 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         WRAP_INDIRECT_PARAM => { panic!("WRAP_INDIRECT_PARAM matched itself"); }
+LL +         binding if binding == WRAP_INDIRECT_PARAM => { panic!("WRAP_INDIRECT_PARAM matched itself"); }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.stderr
index 34fffd99c2c9..295b2a71f70f 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.stderr
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for B {
    | ^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
+LL +         binding if binding == RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
+   |
 
 error: constant of non-structural type `B` in a pattern
   --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:42:9
@@ -33,6 +38,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for B {
    | ^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
+LL +         binding if binding == RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.rs b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.rs
index 74394698fbcd..cb6ab974c5e4 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.rs
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.rs
@@ -16,8 +16,8 @@ fn eq(&self, _: &Foo) -> bool {
 fn main() {
     let y = Foo { x: 1 };
     match y {
-        FOO => { }
+        FOO => {}
         //~^ ERROR constant of non-structural type `Foo` in a pattern
-        _ => { }
+        _ => {}
     }
 }
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
index bbcab3b62d0e..1d216a668381 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
@@ -7,7 +7,7 @@ LL | struct Foo {
 LL | const FOO: Foo = Foo { x: 0 };
    | -------------- constant defined here
 ...
-LL |         FOO => { }
+LL |         FOO => {}
    |         ^^^ constant of non-structural type
    |
 note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
@@ -15,6 +15,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL | impl PartialEq for Foo {
    | ^^^^^^^^^^^^^^^^^^^^^^
+help: add a condition to the match arm checking for equality
+   |
+LL -         FOO => {}
+LL +         binding if binding == FOO => {}
+   |
 
 error: aborting due to 1 previous error
 

From 801eafd7418b732e6df24366c6f576b648f77025 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Tue, 17 Mar 2026 18:17:48 +0000
Subject: [PATCH 0586/1059] Suggest `if let PAT == expr` on `let PAT = expr
 else` with non-structural type const

```
error: constant of non-structural type `partial_eq::S` in a pattern
  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:22:18
   |
LL |     struct S;
   |     -------- `partial_eq::S` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
...
LL |     const C: S = S;
   |     ---------- constant defined here
...
LL |         let Some(C) = Some(S) else { return; };
   |                  ^ constant of non-structural type
   |
note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:5:5
   |
LL |     impl PartialEq<S> for S {
   |     ^^^^^^^^^^^^^^^^^^^^^^^
help: check for equality instead of pattern matching
   |
LL -         let Some(C) = Some(S) else { return; };
LL +         if Some(C) == Some(S) { return; };
   |
```
---
 compiler/rustc_mir_build/src/errors.rs        | 18 +++++++++++
 .../src/thir/pattern/const_to_pat.rs          | 15 +++++++++
 ..._comparison_instead_of_pattern_matching.rs |  2 +-
 ...parison_instead_of_pattern_matching.stderr | 32 ++++++++++++++++++-
 4 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 87c69f60fd31..793d9ef18eb6 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -1144,6 +1144,24 @@ pub(crate) enum SuggestEq<'tcx> {
         ty: Ty<'tcx>,
         manual_partialeq_impl: bool,
     },
+    #[multipart_suggestion(
+        "{$manual_partialeq_impl ->
+            [false] if `{$ty}` manually implemented `PartialEq`, you could check
+            *[true] check
+        } for equality instead of pattern matching",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    ReplaceLetElseWithIf {
+        #[suggestion_part(code = "if ")]
+        if_span: Span,
+        #[suggestion_part(code = " == ")]
+        eq: Span,
+        #[suggestion_part(code = " ")]
+        else_span: Span,
+        ty: Ty<'tcx>,
+        manual_partialeq_impl: bool,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 2b9c3403b92b..74d0d19c5452 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -283,6 +283,21 @@ fn valtree_to_pat(&self, value: ty::Value<'tcx>) -> Box<Pat<'tcx>> {
                                 None
                             }
                         }
+                        hir::Node::LetStmt(let_stmt)
+                            if let Some(init) = let_stmt.init
+                                && let Some(els) = let_stmt.els
+                                && init.span.ctxt().is_root()
+                                && els.span.ctxt().is_root() =>
+                        {
+                            // `let PAT = expr else {` -> `if PAT == expr {`.
+                            Some(SuggestEq::ReplaceLetElseWithIf {
+                                if_span: let_stmt.span.until(let_stmt.pat.span),
+                                eq: let_stmt.pat.span.between(init.span),
+                                else_span: init.span.between(els.span),
+                                ty,
+                                manual_partialeq_impl,
+                            })
+                        }
                         _ => None,
                     }
                 } else {
diff --git a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
index f8ada6914fcb..71a2d06adb74 100644
--- a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
+++ b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.rs
@@ -26,7 +26,7 @@ fn foo() {
         }
         if let V = vec![] {} //~ ERROR: constant of non-structural type
         let V = vec![] else { return; }; //~ ERROR: constant of non-structural type
-        // ^ maybe suggest if V != vec![] { return; } ?
+        let V = Vec::new() else { return; }; //~ ERROR: constant of non-structural type
     }
 }
 
diff --git a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
index fc3af8104e59..38440af675fe 100644
--- a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
+++ b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
@@ -107,6 +107,11 @@ note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient;
    |
 LL |     impl PartialEq<S> for S {
    |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: check for equality instead of pattern matching
+   |
+LL -         let Some(C) = Some(S) else { return; };
+LL +         if Some(C) == Some(S) { return; };
+   |
 
 error: constant of non-structural type `Vec<()>` in a pattern
   --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:24:13
@@ -158,6 +163,26 @@ LL |         let V = vec![] else { return; };
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
+error: constant of non-structural type `Vec<()>` in a pattern
+  --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:29:13
+   |
+LL |     const V: Vec<()> = vec![];
+   |     ---------------- constant defined here
+...
+LL |         let V = Vec::new() else { return; };
+   |             ^ constant of non-structural type
+   |
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+   |
+   = note: `Vec<()>` is not usable in patterns
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: check for equality instead of pattern matching
+   |
+LL -         let V = Vec::new() else { return; };
+LL +         if V == Vec::new() { return; };
+   |
+
 error: constant of non-structural type `not_partial_eq::S` in a pattern
   --> $DIR/suggest_equality_comparison_instead_of_pattern_matching.rs:40:18
    |
@@ -247,6 +272,11 @@ LL |         let Some(C) = Some(S) else { return; };
    |                  ^ constant of non-structural type
    |
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+help: check for equality instead of pattern matching
+   |
+LL -         let Some(C) = Some(S) else { return; };
+LL +         if Some(C) == Some(S) { return; };
+   |
 
-error: aborting due to 13 previous errors
+error: aborting due to 14 previous errors
 

From 82727b0c0f7973864c3990853447def2ab3059af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Sun, 8 Mar 2026 22:36:30 +0100
Subject: [PATCH 0587/1059] Refactor DllImport to better differentiate types

---
 .../src/back/link/raw_dylib.rs                | 20 +++++++++++--------
 compiler/rustc_codegen_ssa/src/common.rs      |  8 ++++----
 compiler/rustc_metadata/src/native_libs.rs    | 18 +++++++++--------
 compiler/rustc_session/src/cstore.rs          | 10 ++++++++--
 4 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
index 477c9478c360..ec1c01320562 100644
--- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -9,7 +9,7 @@
 use rustc_hashes::Hash128;
 use rustc_hir::attrs::NativeLibKind;
 use rustc_session::Session;
-use rustc_session::cstore::DllImport;
+use rustc_session::cstore::{DllImport, DllImportSymbolType};
 use rustc_span::Symbol;
 use rustc_target::spec::Arch;
 
@@ -95,14 +95,14 @@ pub(super) fn create_raw_dylib_dll_import_libs<'a>(
                                     true,
                                 )
                             }),
-                            is_data: !import.is_fn,
+                            is_data: import.symbol_type != DllImportSymbolType::Function,
                         }
                     } else {
                         ImportLibraryItem {
                             name: import.name.to_string(),
                             ordinal: import.ordinal(),
                             symbol_name: None,
-                            is_data: !import.is_fn,
+                            is_data: import.symbol_type != DllImportSymbolType::Function,
                         }
                     }
                 })
@@ -271,10 +271,10 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
                 vers.push((version_name, dynstr));
                 id
             };
-            syms.push((name, dynstr, Some(ver), symbol.is_fn));
+            syms.push((name, dynstr, Some(ver), symbol.symbol_type));
         } else {
             let dynstr = stub.add_dynamic_string(symbol_name.as_bytes());
-            syms.push((symbol_name, dynstr, None, symbol.is_fn));
+            syms.push((symbol_name, dynstr, None, symbol.symbol_type));
         }
     }
 
@@ -398,8 +398,12 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
 
     // .dynsym
     stub.write_null_dynamic_symbol();
-    for (_name, dynstr, _ver, is_fn) in syms.iter().copied() {
-        let sym_type = if is_fn { elf::STT_FUNC } else { elf::STT_NOTYPE };
+    for (_name, dynstr, _ver, symbol_type) in syms.iter().copied() {
+        let sym_type = match symbol_type {
+            DllImportSymbolType::Function => elf::STT_FUNC,
+            DllImportSymbolType::Static => elf::STT_OBJECT,
+            DllImportSymbolType::ThreadLocal => elf::STT_TLS,
+        };
         stub.write_dynamic_symbol(&write::Sym {
             name: Some(dynstr),
             st_info: (elf::STB_GLOBAL << 4) | sym_type,
@@ -418,7 +422,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
     if !vers.is_empty() {
         // .gnu_version
         stub.write_null_gnu_versym();
-        for (_name, _dynstr, ver, _is_fn) in syms.iter().copied() {
+        for (_name, _dynstr, ver, _symbol_type) in syms.iter().copied() {
             stub.write_gnu_versym(if let Some(ver) = ver {
                 assert!((2 + ver as u16) < elf::VERSYM_HIDDEN);
                 elf::VERSYM_HIDDEN | (2 + ver as u16)
diff --git a/compiler/rustc_codegen_ssa/src/common.rs b/compiler/rustc_codegen_ssa/src/common.rs
index 89a3f8061a8c..a0f46a2d4f5e 100644
--- a/compiler/rustc_codegen_ssa/src/common.rs
+++ b/compiler/rustc_codegen_ssa/src/common.rs
@@ -5,7 +5,7 @@
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Instance, TyCtxt};
 use rustc_middle::{bug, mir, span_bug};
-use rustc_session::cstore::{DllCallingConvention, DllImport};
+use rustc_session::cstore::{DllCallingConvention, DllImport, DllImportSymbolType};
 use rustc_span::Span;
 use rustc_target::spec::{Abi, Env, Os, Target};
 
@@ -199,7 +199,7 @@ pub fn i686_decorated_name(
         decorated_name.push('\x01');
     }
 
-    let prefix = if add_prefix && dll_import.is_fn {
+    let prefix = if add_prefix && dll_import.symbol_type == DllImportSymbolType::Function {
         match dll_import.calling_convention {
             DllCallingConvention::C | DllCallingConvention::Vectorcall(_) => None,
             DllCallingConvention::Stdcall(_) => (!mingw
@@ -207,7 +207,7 @@ pub fn i686_decorated_name(
             .then_some('_'),
             DllCallingConvention::Fastcall(_) => Some('@'),
         }
-    } else if !dll_import.is_fn && !mingw {
+    } else if dll_import.symbol_type != DllImportSymbolType::Function && !mingw {
         // For static variables, prefix with '_' on MSVC.
         Some('_')
     } else {
@@ -219,7 +219,7 @@ pub fn i686_decorated_name(
 
     decorated_name.push_str(name);
 
-    if add_suffix && dll_import.is_fn {
+    if add_suffix && dll_import.symbol_type == DllImportSymbolType::Function {
         use std::fmt::Write;
 
         match dll_import.calling_convention {
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 52b11615c76f..1bd6a896b4e2 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -10,7 +10,9 @@
 use rustc_middle::ty::{self, List, Ty, TyCtxt};
 use rustc_session::Session;
 use rustc_session::config::CrateType;
-use rustc_session::cstore::{DllCallingConvention, DllImport, ForeignModule, NativeLib};
+use rustc_session::cstore::{
+    DllCallingConvention, DllImport, DllImportSymbolType, ForeignModule, NativeLib,
+};
 use rustc_session::search_paths::PathKind;
 use rustc_span::Symbol;
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
@@ -451,12 +453,12 @@ fn build_dll_import(
             }
         }
 
-        DllImport {
-            name,
-            import_name_type,
-            calling_convention,
-            span,
-            is_fn: self.tcx.def_kind(item).is_fn_like(),
-        }
+        let symbol_type = if self.tcx.def_kind(item).is_fn_like() {
+            DllImportSymbolType::Function
+        } else {
+            bug!("Unexpected type for raw-dylib: {}", def_kind.descr(item));
+        };
+
+        DllImport { name, import_name_type, calling_convention, span, symbol_type }
     }
 }
diff --git a/compiler/rustc_session/src/cstore.rs b/compiler/rustc_session/src/cstore.rs
index 2f969aefda18..41e8dfbfcefb 100644
--- a/compiler/rustc_session/src/cstore.rs
+++ b/compiler/rustc_session/src/cstore.rs
@@ -97,8 +97,14 @@ pub struct DllImport {
     pub calling_convention: DllCallingConvention,
     /// Span of import's "extern" declaration; used for diagnostics.
     pub span: Span,
-    /// Is this for a function (rather than a static variable).
-    pub is_fn: bool,
+    pub symbol_type: DllImportSymbolType,
+}
+
+#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic, PartialEq)]
+pub enum DllImportSymbolType {
+    Function,
+    Static,
+    ThreadLocal,
 }
 
 impl DllImport {

From 2fad36b93d0bd964f3b99af23e9abe0f2cc0a301 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Sun, 8 Mar 2026 23:13:26 +0100
Subject: [PATCH 0588/1059] Extend raw-dylib to handle statics and TLS for ELF

---
 compiler/rustc_metadata/src/native_libs.rs | 11 ++++++++++-
 tests/run-make/raw-dylib-elf/library.c     |  3 +++
 tests/run-make/raw-dylib-elf/main.rs       | 12 ++++++++++--
 tests/run-make/raw-dylib-elf/output.txt    |  2 +-
 4 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 1bd6a896b4e2..a60c030b9c0b 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -5,7 +5,9 @@
 use rustc_attr_parsing::eval_config_entry;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::attrs::{NativeLibKind, PeImportNameType};
+use rustc_hir::def::DefKind;
 use rustc_hir::find_attr;
+use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::{self, List, Ty, TyCtxt};
 use rustc_session::Session;
@@ -453,8 +455,15 @@ fn build_dll_import(
             }
         }
 
-        let symbol_type = if self.tcx.def_kind(item).is_fn_like() {
+        let def_kind = self.tcx.def_kind(item);
+        let symbol_type = if def_kind.is_fn_like() {
             DllImportSymbolType::Function
+        } else if matches!(def_kind, DefKind::Static { .. }) {
+            if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
+                DllImportSymbolType::ThreadLocal
+            } else {
+                DllImportSymbolType::Static
+            }
         } else {
             bug!("Unexpected type for raw-dylib: {}", def_kind.descr(item));
         };
diff --git a/tests/run-make/raw-dylib-elf/library.c b/tests/run-make/raw-dylib-elf/library.c
index 2e3a95b7edec..943a1382e340 100644
--- a/tests/run-make/raw-dylib-elf/library.c
+++ b/tests/run-make/raw-dylib-elf/library.c
@@ -1,3 +1,6 @@
+int global_variable = 3;
+__thread int tls_variable = 33;
+
 int this_is_a_library_function() {
     return 42;
 }
diff --git a/tests/run-make/raw-dylib-elf/main.rs b/tests/run-make/raw-dylib-elf/main.rs
index 3be944d29514..ec8951da88f0 100644
--- a/tests/run-make/raw-dylib-elf/main.rs
+++ b/tests/run-make/raw-dylib-elf/main.rs
@@ -1,11 +1,19 @@
 #![feature(raw_dylib_elf)]
+#![feature(thread_local)]
 #![allow(incomplete_features)]
 
+use std::ffi::c_int;
+
 #[link(name = "library", kind = "raw-dylib")]
 unsafe extern "C" {
-    safe fn this_is_a_library_function() -> core::ffi::c_int;
+    safe fn this_is_a_library_function() -> c_int;
+    static mut global_variable: c_int;
+    #[thread_local]
+    static mut tls_variable: c_int;
 }
 
 fn main() {
-    println!("{}", this_is_a_library_function())
+    unsafe {
+        println!("{} {} {}", this_is_a_library_function(), global_variable, tls_variable);
+    }
 }
diff --git a/tests/run-make/raw-dylib-elf/output.txt b/tests/run-make/raw-dylib-elf/output.txt
index d81cc0710eb6..53383c3b8645 100644
--- a/tests/run-make/raw-dylib-elf/output.txt
+++ b/tests/run-make/raw-dylib-elf/output.txt
@@ -1 +1 @@
-42
+42 3 33

From f3654324e6da3fd388035418c9db1912a0d8c4cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Mon, 9 Mar 2026 18:17:07 +0100
Subject: [PATCH 0589/1059] Set symbol size in raw-dylib for ELF

---
 .../rustc_codegen_ssa/src/back/link/raw_dylib.rs | 10 +++++-----
 compiler/rustc_metadata/src/native_libs.rs       | 16 +++++++++++++++-
 compiler/rustc_session/src/cstore.rs             |  1 +
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
index ec1c01320562..3017e5fc567d 100644
--- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -271,10 +271,10 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
                 vers.push((version_name, dynstr));
                 id
             };
-            syms.push((name, dynstr, Some(ver), symbol.symbol_type));
+            syms.push((name, dynstr, Some(ver), symbol.symbol_type, symbol.size));
         } else {
             let dynstr = stub.add_dynamic_string(symbol_name.as_bytes());
-            syms.push((symbol_name, dynstr, None, symbol.symbol_type));
+            syms.push((symbol_name, dynstr, None, symbol.symbol_type, symbol.size));
         }
     }
 
@@ -398,7 +398,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
 
     // .dynsym
     stub.write_null_dynamic_symbol();
-    for (_name, dynstr, _ver, symbol_type) in syms.iter().copied() {
+    for (_name, dynstr, _ver, symbol_type, size) in syms.iter().copied() {
         let sym_type = match symbol_type {
             DllImportSymbolType::Function => elf::STT_FUNC,
             DllImportSymbolType::Static => elf::STT_OBJECT,
@@ -411,7 +411,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
             section: Some(text_section),
             st_shndx: 0, // ignored by object in favor of the `section` field
             st_value: 0,
-            st_size: 0,
+            st_size: size.bytes(),
         });
     }
 
@@ -422,7 +422,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
     if !vers.is_empty() {
         // .gnu_version
         stub.write_null_gnu_versym();
-        for (_name, _dynstr, ver, _symbol_type) in syms.iter().copied() {
+        for (_name, _dynstr, ver, _symbol_type, _size) in syms.iter().copied() {
             stub.write_gnu_versym(if let Some(ver) = ver {
                 assert!((2 + ver as u16) < elf::VERSYM_HIDDEN);
                 elf::VERSYM_HIDDEN | (2 + ver as u16)
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index a60c030b9c0b..17b16b3cfe2d 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -7,6 +7,7 @@
 use rustc_hir::attrs::{NativeLibKind, PeImportNameType};
 use rustc_hir::def::DefKind;
 use rustc_hir::find_attr;
+use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::{self, List, Ty, TyCtxt};
@@ -468,6 +469,19 @@ fn build_dll_import(
             bug!("Unexpected type for raw-dylib: {}", def_kind.descr(item));
         };
 
-        DllImport { name, import_name_type, calling_convention, span, symbol_type }
+        let size = match symbol_type {
+            // We cannot determine the size of a function at compile time, but it shouldn't matter anyway.
+            DllImportSymbolType::Function => rustc_abi::Size::ZERO,
+            DllImportSymbolType::Static | DllImportSymbolType::ThreadLocal => {
+                let ty = self.tcx.type_of(item).instantiate_identity();
+                self.tcx
+                    .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty))
+                    .ok()
+                    .map(|layout| layout.size)
+                    .unwrap_or_else(|| bug!("Non-function symbols must have a size"))
+            }
+        };
+
+        DllImport { name, import_name_type, calling_convention, span, symbol_type, size }
     }
 }
diff --git a/compiler/rustc_session/src/cstore.rs b/compiler/rustc_session/src/cstore.rs
index 41e8dfbfcefb..c186557ccaa4 100644
--- a/compiler/rustc_session/src/cstore.rs
+++ b/compiler/rustc_session/src/cstore.rs
@@ -98,6 +98,7 @@ pub struct DllImport {
     /// Span of import's "extern" declaration; used for diagnostics.
     pub span: Span,
     pub symbol_type: DllImportSymbolType,
+    pub size: rustc_abi::Size,
 }
 
 #[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic, PartialEq)]

From a197752e88d99e449caf695f9d2101ceeded24a7 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Tue, 24 Feb 2026 11:10:51 +0000
Subject: [PATCH 0590/1059] Add kernel-hwaddress sanitizer

Signed-off-by: Alice Ryhl <aliceryhl@google.com>
---
 .../src/attributes/codegen_attrs.rs           |  6 ++-
 compiler/rustc_codegen_llvm/src/attributes.rs |  3 +-
 compiler/rustc_codegen_llvm/src/back/write.rs |  4 ++
 compiler/rustc_codegen_llvm/src/base.rs       |  8 +++-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  2 +
 compiler/rustc_codegen_ssa/src/back/link.rs   |  1 +
 compiler/rustc_feature/src/builtin_attrs.rs   |  2 +-
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   | 10 +++--
 compiler/rustc_session/src/config/cfg.rs      |  4 ++
 compiler/rustc_session/src/options.rs         |  4 +-
 compiler/rustc_session/src/session.rs         |  2 +-
 compiler/rustc_span/src/symbol.rs             |  1 +
 compiler/rustc_target/src/spec/mod.rs         | 17 +++++++--
 .../aarch64_be_unknown_none_softfloat.rs      |  4 +-
 .../src/spec/targets/aarch64_unknown_none.rs  |  4 +-
 .../targets/aarch64_unknown_none_softfloat.rs |  4 +-
 .../src/spec/targets/aarch64_unknown_nuttx.rs |  4 +-
 .../spec/targets/aarch64v8r_unknown_none.rs   |  4 +-
 .../aarch64v8r_unknown_none_softfloat.rs      |  4 +-
 src/tools/compiletest/src/common.rs           |  1 +
 .../src/directives/directive_names.rs         |  1 +
 src/tools/compiletest/src/directives/needs.rs |  7 ++++
 .../sanitizer/hwasan-vs-khwasan.rs            | 29 ++++++++++++++
 .../sanitizer/hwasan-vs-khwasan.rs            | 27 +++++++++++++
 tests/codegen-llvm/sanitizer/kasan-recover.rs | 33 ++++++++++++++++
 .../sanitizer/khwasan-lifetime-markers.rs     | 21 ++++++++++
 .../codegen-llvm/sanitizer/khwasan-recover.rs | 37 ++++++++++++++++++
 .../sanitizer/sanitize-off-hwasan-khwasan.rs  | 38 +++++++++++++++++++
 .../sanitizer/sanitize-off-khwasan-hwasan.rs  | 31 +++++++++++++++
 .../sanitizer/sanitizer-recover.rs            |  2 +-
 tests/ui/check-cfg/well-known-values.stderr   |  2 +-
 .../ui/sanitize-attr/invalid-sanitize.stderr  |  2 +-
 tests/ui/sanitizer/cfg-khwasan.rs             | 22 +++++++++++
 tests/ui/sanitizer/incompatible-khwasan.rs    |  9 +++++
 .../ui/sanitizer/incompatible-khwasan.stderr  |  4 ++
 .../sanitizer/unsupported-target-khwasan.rs   |  9 +++++
 .../unsupported-target-khwasan.stderr         |  4 ++
 37 files changed, 345 insertions(+), 22 deletions(-)
 create mode 100644 tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
 create mode 100644 tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kasan-recover.rs
 create mode 100644 tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
 create mode 100644 tests/codegen-llvm/sanitizer/khwasan-recover.rs
 create mode 100644 tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
 create mode 100644 tests/codegen-llvm/sanitizer/sanitize-off-khwasan-hwasan.rs
 create mode 100644 tests/ui/sanitizer/cfg-khwasan.rs
 create mode 100644 tests/ui/sanitizer/incompatible-khwasan.rs
 create mode 100644 tests/ui/sanitizer/incompatible-khwasan.stderr
 create mode 100644 tests/ui/sanitizer/unsupported-target-khwasan.rs
 create mode 100644 tests/ui/sanitizer/unsupported-target-khwasan.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index a8db114129ff..33fb19089ba5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -587,6 +587,7 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
         r#"kernel_address = "on|off""#,
         r#"cfi = "on|off""#,
         r#"hwaddress = "on|off""#,
+        r#"kernel_hwaddress = "on|off""#,
         r#"kcfi = "on|off""#,
         r#"memory = "on|off""#,
         r#"memtag = "on|off""#,
@@ -654,7 +655,9 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
                 Some(sym::memtag) => apply(SanitizerSet::MEMTAG),
                 Some(sym::shadow_call_stack) => apply(SanitizerSet::SHADOWCALLSTACK),
                 Some(sym::thread) => apply(SanitizerSet::THREAD),
-                Some(sym::hwaddress) => apply(SanitizerSet::HWADDRESS),
+                Some(sym::hwaddress) | Some(sym::kernel_hwaddress) => {
+                    apply(SanitizerSet::HWADDRESS | SanitizerSet::KERNELHWADDRESS)
+                }
                 Some(sym::realtime) => match value.value_as_str() {
                     Some(sym::nonblocking) => rtsan = Some(RtsanSetting::Nonblocking),
                     Some(sym::blocking) => rtsan = Some(RtsanSetting::Blocking),
@@ -679,6 +682,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
                             sym::shadow_call_stack,
                             sym::thread,
                             sym::hwaddress,
+                            sym::kernel_hwaddress,
                             sym::realtime,
                         ],
                     );
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index d51adb6e13b0..f300ee5d4c99 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -120,7 +120,8 @@ pub(crate) fn sanitize_attrs<'ll, 'tcx>(
     if enabled.contains(SanitizerSet::THREAD) {
         attrs.push(llvm::AttributeKind::SanitizeThread.create_attr(cx.llcx));
     }
-    if enabled.contains(SanitizerSet::HWADDRESS) {
+    if enabled.contains(SanitizerSet::HWADDRESS) || enabled.contains(SanitizerSet::KERNELHWADDRESS)
+    {
         attrs.push(llvm::AttributeKind::SanitizeHWAddress.create_attr(cx.llcx));
     }
     if enabled.contains(SanitizerSet::SHADOWCALLSTACK) {
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index efd4e55d5a85..2125cf6383bf 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -652,6 +652,10 @@ pub(crate) unsafe fn llvm_optimize(
             sanitize_kernel_address_recover: config
                 .sanitizer_recover
                 .contains(SanitizerSet::KERNELADDRESS),
+            sanitize_kernel_hwaddress: config.sanitizer.contains(SanitizerSet::KERNELHWADDRESS),
+            sanitize_kernel_hwaddress_recover: config
+                .sanitizer_recover
+                .contains(SanitizerSet::KERNELHWADDRESS),
         })
     } else {
         None
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index d00e70638b45..227680947712 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -210,10 +210,14 @@ pub(crate) fn visibility_to_llvm(linkage: Visibility) -> llvm::Visibility {
 }
 
 pub(crate) fn set_variable_sanitizer_attrs(llval: &Value, attrs: &CodegenFnAttrs) {
-    if attrs.sanitizers.disabled.contains(SanitizerSet::ADDRESS) {
+    if attrs.sanitizers.disabled.contains(SanitizerSet::ADDRESS)
+        || attrs.sanitizers.disabled.contains(SanitizerSet::KERNELADDRESS)
+    {
         unsafe { llvm::LLVMRustSetNoSanitizeAddress(llval) };
     }
-    if attrs.sanitizers.disabled.contains(SanitizerSet::HWADDRESS) {
+    if attrs.sanitizers.disabled.contains(SanitizerSet::HWADDRESS)
+        || attrs.sanitizers.disabled.contains(SanitizerSet::KERNELHWADDRESS)
+    {
         unsafe { llvm::LLVMRustSetNoSanitizeHWAddress(llval) };
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 77438472644f..7355d1136792 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -464,6 +464,8 @@ pub(crate) struct SanitizerOptions {
     pub sanitize_hwaddress_recover: bool,
     pub sanitize_kernel_address: bool,
     pub sanitize_kernel_address_recover: bool,
+    pub sanitize_kernel_hwaddress: bool,
+    pub sanitize_kernel_hwaddress_recover: bool,
 }
 
 /// LLVMRustRelocModel
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 7a3d5a6bb224..be7da2e81add 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1341,6 +1341,7 @@ fn add_sanitizer_libraries(
     if sanitizer.contains(SanitizerSet::LEAK)
         && !sanitizer.contains(SanitizerSet::ADDRESS)
         && !sanitizer.contains(SanitizerSet::HWADDRESS)
+        && !sanitizer.contains(SanitizerSet::KERNELHWADDRESS)
     {
         link_sanitizer_runtime(sess, flavor, linker, "lsan");
     }
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 3a2f548902d1..3187876626f3 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -773,7 +773,7 @@ pub struct BuiltinAttribute {
         DuplicatesOk, EncodeCrossCrate::No, effective_target_features, experimental!(force_target_feature)
     ),
     gated!(
-        sanitize, Normal, template!(List: &[r#"address = "on|off""#, r#"kernel_address = "on|off""#, r#"cfi = "on|off""#, r#"hwaddress = "on|off""#, r#"kcfi = "on|off""#, r#"memory = "on|off""#, r#"memtag = "on|off""#, r#"shadow_call_stack = "on|off""#, r#"thread = "on|off""#]), ErrorPreceding,
+        sanitize, Normal, template!(List: &[r#"address = "on|off""#, r#"kernel_address = "on|off""#, r#"cfi = "on|off""#, r#"hwaddress = "on|off""#, r#"kernel_hwaddress = "on|off""#, r#"kcfi = "on|off""#, r#"memory = "on|off""#, r#"memtag = "on|off""#, r#"shadow_call_stack = "on|off""#, r#"thread = "on|off""#]), ErrorPreceding,
         EncodeCrossCrate::No, sanitize, experimental!(sanitize),
     ),
     gated!(
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 00d03f023924..b4f6bb4583c1 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -540,6 +540,8 @@ struct LLVMRustSanitizerOptions {
   bool SanitizeHWAddressRecover;
   bool SanitizeKernelAddress;
   bool SanitizeKernelAddressRecover;
+  bool SanitizeKernelHWAddress;
+  bool SanitizeKernelHWAddressRecover;
 };
 
 extern "C" typedef void (*registerEnzymeAndPassPipelineFn)(
@@ -767,13 +769,15 @@ extern "C" LLVMRustResult LLVMRustOptimize(
                                  !TM->getTargetTriple().isOSWindows()));
       });
     }
-    if (SanitizerOptions->SanitizeHWAddress) {
+    if (SanitizerOptions->SanitizeHWAddress ||
+        SanitizerOptions->SanitizeKernelHWAddress) {
       OptimizerLastEPCallbacks.push_back(
           [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level,
                              ThinOrFullLTOPhase phase) {
             HWAddressSanitizerOptions opts(
-                /*CompileKernel=*/false,
-                SanitizerOptions->SanitizeHWAddressRecover,
+                SanitizerOptions->SanitizeKernelHWAddress,
+                SanitizerOptions->SanitizeHWAddressRecover ||
+                    SanitizerOptions->SanitizeKernelHWAddressRecover,
                 /*DisableOptimization=*/false);
             MPM.addPass(HWAddressSanitizerPass(opts));
           });
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index ebbbe36878da..17fdba37b4bc 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -229,6 +229,10 @@ macro_rules! ins_sym {
         if s == SanitizerSet::KERNELADDRESS {
             s = SanitizerSet::ADDRESS;
         }
+        // KHWASAN is still HWASAN under the hood, so it uses the same attribute.
+        if s == SanitizerSet::KERNELHWADDRESS {
+            s = SanitizerSet::HWADDRESS;
+        }
         ins_str!(sym::sanitize, &s.to_string());
     }
 
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 0bc432a0ff06..d370f00d2198 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -106,6 +106,7 @@ pub(super) fn sanitizer(l: &TargetModifier, r: Option<&TargetModifier>) -> bool
             | SanitizerSet::SHADOWCALLSTACK
             | SanitizerSet::KCFI
             | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS
             | SanitizerSet::SAFESTACK
             | SanitizerSet::DATAFLOW;
 
@@ -810,7 +811,7 @@ mod desc {
     pub(crate) const parse_patchable_function_entry: &str = "either two comma separated integers (total_nops,prefix_nops), with prefix_nops <= total_nops, or one integer (total_nops)";
     pub(crate) const parse_opt_panic_strategy: &str = parse_panic_strategy;
     pub(crate) const parse_relro_level: &str = "one of: `full`, `partial`, or `off`";
-    pub(crate) const parse_sanitizers: &str = "comma separated list of sanitizers: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, `thread`, or 'realtime'";
+    pub(crate) const parse_sanitizers: &str = "comma separated list of sanitizers: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `kernel-hwaddress`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, `thread`, or 'realtime'";
     pub(crate) const parse_sanitizer_memory_track_origins: &str = "0, 1, or 2";
     pub(crate) const parse_cfguard: &str =
         "either a boolean (`yes`, `no`, `on`, `off`, etc), `checks`, or `nochecks`";
@@ -1252,6 +1253,7 @@ pub(crate) fn parse_sanitizers(slot: &mut SanitizerSet, v: Option<&str>) -> bool
                     "dataflow" => SanitizerSet::DATAFLOW,
                     "kcfi" => SanitizerSet::KCFI,
                     "kernel-address" => SanitizerSet::KERNELADDRESS,
+                    "kernel-hwaddress" => SanitizerSet::KERNELHWADDRESS,
                     "leak" => SanitizerSet::LEAK,
                     "memory" => SanitizerSet::MEMORY,
                     "memtag" => SanitizerSet::MEMTAG,
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 0548380331be..3da2d891e19d 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -529,7 +529,7 @@ pub fn emit_lifetime_markers(&self) -> bool {
         // AddressSanitizer and KernelAddressSanitizer uses lifetimes to detect use after scope bugs.
         // MemorySanitizer uses lifetimes to detect use of uninitialized stack variables.
         // HWAddressSanitizer will use lifetimes to detect use after scope bugs in the future.
-        || self.sanitizers().intersects(SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS | SanitizerSet::MEMORY | SanitizerSet::HWADDRESS)
+        || self.sanitizers().intersects(SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS | SanitizerSet::MEMORY | SanitizerSet::HWADDRESS | SanitizerSet::KERNELHWADDRESS)
     }
 
     pub fn diagnostic_width(&self) -> usize {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 286fea7d9050..6da8974cba64 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1115,6 +1115,7 @@
         iterator_collect_fn,
         kcfi,
         kernel_address,
+        kernel_hwaddress,
         keylocker_x86,
         keyword,
         kind,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 8683e4f51279..2b5cbd670308 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1175,9 +1175,10 @@ impl SanitizerSet: u16 {
         const SHADOWCALLSTACK = 1 << 7;
         const KCFI    = 1 << 8;
         const KERNELADDRESS = 1 << 9;
-        const SAFESTACK = 1 << 10;
-        const DATAFLOW = 1 << 11;
-        const REALTIME = 1 << 12;
+        const KERNELHWADDRESS = 1 << 10;
+        const SAFESTACK = 1 << 11;
+        const DATAFLOW = 1 << 12;
+        const REALTIME = 1 << 13;
     }
 }
 rustc_data_structures::external_bitflags_debug! { SanitizerSet }
@@ -1191,24 +1192,32 @@ impl SanitizerSet {
         (SanitizerSet::ADDRESS, SanitizerSet::HWADDRESS),
         (SanitizerSet::ADDRESS, SanitizerSet::MEMTAG),
         (SanitizerSet::ADDRESS, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::ADDRESS, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::ADDRESS, SanitizerSet::SAFESTACK),
         (SanitizerSet::LEAK, SanitizerSet::MEMORY),
         (SanitizerSet::LEAK, SanitizerSet::THREAD),
         (SanitizerSet::LEAK, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::LEAK, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::LEAK, SanitizerSet::SAFESTACK),
         (SanitizerSet::MEMORY, SanitizerSet::THREAD),
         (SanitizerSet::MEMORY, SanitizerSet::HWADDRESS),
         (SanitizerSet::MEMORY, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::MEMORY, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::MEMORY, SanitizerSet::SAFESTACK),
         (SanitizerSet::THREAD, SanitizerSet::HWADDRESS),
         (SanitizerSet::THREAD, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::THREAD, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::THREAD, SanitizerSet::SAFESTACK),
         (SanitizerSet::HWADDRESS, SanitizerSet::MEMTAG),
         (SanitizerSet::HWADDRESS, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::HWADDRESS, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::HWADDRESS, SanitizerSet::SAFESTACK),
         (SanitizerSet::CFI, SanitizerSet::KCFI),
         (SanitizerSet::MEMTAG, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::MEMTAG, SanitizerSet::KERNELHWADDRESS),
+        (SanitizerSet::KERNELADDRESS, SanitizerSet::KERNELHWADDRESS),
         (SanitizerSet::KERNELADDRESS, SanitizerSet::SAFESTACK),
+        (SanitizerSet::KERNELHWADDRESS, SanitizerSet::SAFESTACK),
     ];
 
     /// Return sanitizer's name
@@ -1221,6 +1230,7 @@ pub fn as_str(self) -> Option<&'static str> {
             SanitizerSet::DATAFLOW => "dataflow",
             SanitizerSet::KCFI => "kcfi",
             SanitizerSet::KERNELADDRESS => "kernel-address",
+            SanitizerSet::KERNELHWADDRESS => "kernel-hwaddress",
             SanitizerSet::LEAK => "leak",
             SanitizerSet::MEMORY => "memory",
             SanitizerSet::MEMTAG => "memtag",
@@ -1266,6 +1276,7 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
             "dataflow" => SanitizerSet::DATAFLOW,
             "kcfi" => SanitizerSet::KCFI,
             "kernel-address" => SanitizerSet::KERNELADDRESS,
+            "kernel-hwaddress" => SanitizerSet::KERNELHWADDRESS,
             "leak" => SanitizerSet::LEAK,
             "memory" => SanitizerSet::MEMORY,
             "memtag" => SanitizerSet::MEMTAG,
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
index e204c6466e29..aae7af82d553 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
@@ -22,7 +22,9 @@ pub(crate) fn target() -> Target {
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         stack_probes: StackProbeType::Inline,
         panic_strategy: PanicStrategy::Abort,
         endian: Endian::Big,
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs
index 1c166030d5e5..13d3b77588a0 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs
@@ -21,7 +21,9 @@ pub(crate) fn target() -> Target {
             &["--fix-cortex-a53-843419"],
         ),
         features: "+v8a,+strict-align,+neon".into(),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
index ed2e2fb6ab70..2e972f2fa2ac 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
@@ -21,7 +21,9 @@ pub(crate) fn target() -> Target {
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         stack_probes: StackProbeType::Inline,
         panic_strategy: PanicStrategy::Abort,
         default_uwtable: true,
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs
index 19b7ebe03674..1e06d3abb723 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs
@@ -21,7 +21,9 @@ pub(crate) fn target() -> Target {
             &["--fix-cortex-a53-843419"],
         ),
         features: "+v8a,+strict-align,+neon".into(),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none.rs b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none.rs
index 8f8bbb4a41ca..680d89653db8 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none.rs
@@ -8,7 +8,9 @@ pub(crate) fn target() -> Target {
         // based off the aarch64-unknown-none target at time of addition
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
index 6f11f97e3d1d..731b61d6731f 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
@@ -12,7 +12,9 @@ pub(crate) fn target() -> Target {
         relocation_model: RelocModel::Static,
         disable_redzone: true,
         max_atomic_width: Some(128),
-        supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
+        supported_sanitizers: SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::KERNELHWADDRESS,
         stack_probes: StackProbeType::Inline,
         panic_strategy: PanicStrategy::Abort,
         default_uwtable: true,
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index bc94a81ba3b5..7cac7f5c0494 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -168,6 +168,7 @@ pub enum Sanitizer {
     Dataflow,
     Kcfi,
     KernelAddress,
+    KernelHwaddress,
     Leak,
     Memory,
     Memtag,
diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 9af881b5c2f5..eaa1a39a9eee 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -179,6 +179,7 @@
     "needs-sanitizer-hwaddress",
     "needs-sanitizer-kasan",
     "needs-sanitizer-kcfi",
+    "needs-sanitizer-khwasan",
     "needs-sanitizer-leak",
     "needs-sanitizer-memory",
     "needs-sanitizer-memtag",
diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index 168d5e9eb649..e9f3d6c28d6e 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -46,6 +46,11 @@ pub(super) fn handle_needs(
             condition: cache.sanitizer_kasan,
             ignore_reason: "ignored on targets without kernel address sanitizer",
         },
+        Need {
+            name: "needs-sanitizer-khwasan",
+            condition: cache.sanitizer_khwasan,
+            ignore_reason: "ignored on targets without kernel hardware-assisted address sanitizer",
+        },
         Need {
             name: "needs-sanitizer-leak",
             condition: cache.sanitizer_leak,
@@ -332,6 +337,7 @@ pub(super) struct CachedNeedsConditions {
     sanitizer_dataflow: bool,
     sanitizer_kcfi: bool,
     sanitizer_kasan: bool,
+    sanitizer_khwasan: bool,
     sanitizer_leak: bool,
     sanitizer_memory: bool,
     sanitizer_thread: bool,
@@ -359,6 +365,7 @@ pub(super) fn load(config: &Config) -> Self {
             sanitizer_dataflow: sanitizers.contains(&Sanitizer::Dataflow),
             sanitizer_kcfi: sanitizers.contains(&Sanitizer::Kcfi),
             sanitizer_kasan: sanitizers.contains(&Sanitizer::KernelAddress),
+            sanitizer_khwasan: sanitizers.contains(&Sanitizer::KernelHwaddress),
             sanitizer_leak: sanitizers.contains(&Sanitizer::Leak),
             sanitizer_memory: sanitizers.contains(&Sanitizer::Memory),
             sanitizer_thread: sanitizers.contains(&Sanitizer::Thread),
diff --git a/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs b/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
new file mode 100644
index 000000000000..bcb2fbc613df
--- /dev/null
+++ b/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
@@ -0,0 +1,29 @@
+// Verifies that HWASAN and KHWASAN emit different assembly instrumentation on AArch64.
+//
+//@ add-minicore
+//@ assembly-output: emit-asm
+//@ revisions: hwasan khwasan
+//@[hwasan] compile-flags: --target aarch64-unknown-linux-gnu -Zsanitizer=hwaddress
+//@[khwasan] compile-flags: --target aarch64-unknown-none -Zsanitizer=kernel-hwaddress
+//@ compile-flags: -Copt-level=1
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+
+// hwasan-LABEL: test:
+// hwasan:       adrp    x{{[0-9]+}}, :gottprel:__hwasan_tls
+// hwasan:       mrs     x{{[0-9]+}}, TPIDR_EL0
+// hwasan:       bl      __hwasan_check_x0_0_short_v2
+
+// khwasan-LABEL: test:
+// khwasan-NOT:   __hwasan_tls
+// khwasan:       orr     x{{[0-9]+}}, x0, #0xff00000000000000
+// khwasan:       bl      __hwasan_check_x0_67043328_fixed_0_short_v2
+
+#[no_mangle]
+pub fn test(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
new file mode 100644
index 000000000000..fd3aacee5af2
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
@@ -0,0 +1,27 @@
+// Verifies that HWASAN and KHWASAN emit different instrumentation.
+//
+//@ add-minicore
+//@ revisions: hwasan khwasan
+//@[hwasan] compile-flags: --target aarch64-unknown-linux-gnu -Zsanitizer=hwaddress
+//@[khwasan] compile-flags: --target aarch64-unknown-none -Zsanitizer=kernel-hwaddress
+//@ compile-flags: -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, sanitize)]
+#![no_core]
+
+extern crate minicore;
+
+// hwasan-LABEL: define {{.*}} @test
+// hwasan:       @__hwasan_tls
+// hwasan:       call void @llvm.hwasan.check.memaccess.shortgranules
+// hwasan:       declare void @__hwasan_init()
+
+// khwasan-LABEL: define {{.*}} @test
+// khwasan-NOT:   @__hwasan_init
+// khwasan:       @__hwasan_tls
+// khwasan:       call void @llvm.hwasan.check.memaccess.shortgranules
+#[no_mangle]
+pub fn test(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/kasan-recover.rs b/tests/codegen-llvm/sanitizer/kasan-recover.rs
new file mode 100644
index 000000000000..8f0e6eb3a605
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kasan-recover.rs
@@ -0,0 +1,33 @@
+// Verifies that KernelAddressSanitizer recovery mode can be enabled
+// with -Zsanitizer-recover=kernel-address.
+//
+//@ add-minicore
+//@ revisions: KASAN KASAN-RECOVER
+//@ compile-flags: -Copt-level=0
+//@[KASAN]            compile-flags: -Zsanitizer=kernel-address --target x86_64-unknown-none
+//@[KASAN]            needs-llvm-components: x86
+//@[KASAN-RECOVER]    compile-flags: -Zsanitizer=kernel-address
+//@[KASAN-RECOVER]    compile-flags: -Zsanitizer-recover=kernel-address --target x86_64-unknown-none
+//@[KASAN-RECOVER]    needs-llvm-components: x86
+
+#![feature(no_core, sanitize, lang_items)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// KASAN-LABEL: define{{.*}}@penguin(
+// KASAN:         call void @__asan_report_load4(
+// KASAN:         unreachable
+// KASAN:       }
+
+// KASAN-RECOVER-LABEL: define{{.*}}@penguin(
+// KASAN-RECOVER:         call void @__asan_report_load4_noabort(
+// KASAN-RECOVER-NOT:     unreachable
+// KASAN-RECOVER:       }
+
+#[no_mangle]
+pub unsafe fn penguin(p: *mut i32) -> i32 {
+    *p
+}
diff --git a/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs b/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
new file mode 100644
index 000000000000..01b129cb6920
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
@@ -0,0 +1,21 @@
+// Verifies that `-Zsanitizer=kernel-hwaddress` enables lifetime markers.
+
+//@ add-minicore
+//@ compile-flags: -Zsanitizer=kernel-hwaddress -Copt-level=0
+//@ revisions: aarch64
+//@[aarch64] compile-flags: --target aarch64-unknown-none
+//@[aarch64] needs-llvm-components: aarch64
+
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: ; khwasan_lifetime_markers::test
+// CHECK:       call void @llvm.lifetime.start
+// CHECK:       call void @llvm.lifetime.end
+pub fn test() {
+    let _x = [0u8; 10];
+}
diff --git a/tests/codegen-llvm/sanitizer/khwasan-recover.rs b/tests/codegen-llvm/sanitizer/khwasan-recover.rs
new file mode 100644
index 000000000000..957b867a61ad
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/khwasan-recover.rs
@@ -0,0 +1,37 @@
+// Verifies that KernelHWAddressSanitizer recovery mode can be enabled
+// with -Zsanitizer-recover=kernel-hwaddress.
+//
+//@ add-minicore
+//@[KHWASAN] needs-llvm-components: aarch64
+//@[KHWASAN-RECOVER] needs-llvm-components: aarch64
+//@ revisions: KHWASAN KHWASAN-RECOVER
+//@ no-prefer-dynamic
+//@ compile-flags: -Copt-level=0
+//@[KHWASAN]            compile-flags: -Zsanitizer=kernel-hwaddress --target aarch64-unknown-none
+//@[KHWASAN-RECOVER]    compile-flags: -Zsanitizer=kernel-hwaddress
+//@[KHWASAN-RECOVER]    compile-flags: -Zsanitizer-recover=kernel-hwaddress
+//@[KHWASAN-RECOVER]    compile-flags: --target aarch64-unknown-none
+
+#![feature(no_core, sanitize, lang_items)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// KHWASAN-LABEL: define{{.*}}@penguin(
+// KHWASAN:         call void @llvm.hwasan.check.memaccess
+// KHWASAN:         ret i32
+// KHWASAN:       }
+// KHWASAN:       declare void @__hwasan_load4(i64)
+
+// KHWASAN-RECOVER-LABEL: define{{.*}}@penguin(
+// KHWASAN-RECOVER:         call void asm sideeffect "brk #2338", "{x0}"(i64 %{{[0-9]+}})
+// KHWASAN-RECOVER-NOT:     unreachable
+// KHWASAN-RECOVER:       }
+// KHWASAN-RECOVER:       declare void @__hwasan_load4_noabort(i64)
+
+#[no_mangle]
+pub unsafe fn penguin(p: *mut i32) -> i32 {
+    *p
+}
diff --git a/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs b/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
new file mode 100644
index 000000000000..c0e23f5f596b
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
@@ -0,0 +1,38 @@
+// Verifies that the `#[sanitize(hwaddress = "off")]` attribute also turns off
+// the kernel hardware-assisted address sanitizer.
+//
+//@ add-minicore
+//@ compile-flags: -Zsanitizer=kernel-hwaddress -Ctarget-feature=-crt-static -Copt-level=0
+//@ revisions: aarch64 aarch64v8r
+//@[aarch64] compile-flags: --target aarch64-unknown-none
+//@[aarch64] needs-llvm-components: aarch64
+//@[aarch64v8r] compile-flags: --target aarch64v8r-unknown-none
+//@[aarch64v8r] needs-llvm-components: aarch64
+
+#![crate_type = "rlib"]
+#![feature(no_core, sanitize, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-NOT:   sanitize_hwaddress
+// CHECK-LABEL: define {{.*}} @unsanitized
+// CHECK:       start:
+// CHECK-NOT:   call void @llvm.hwasan.check.memaccess
+// CHECK:       }
+#[sanitize(hwaddress = "off")]
+#[no_mangle]
+pub fn unsanitized(b: &mut u8) -> u8 {
+    *b
+}
+
+// CHECK:       sanitize_hwaddress
+// CHECK-LABEL: define {{.*}} @sanitized
+// CHECK:       start:
+// CHECK:       call void @llvm.hwasan.check.memaccess
+// CHECK:       }
+#[no_mangle]
+pub fn sanitized(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/sanitize-off-khwasan-hwasan.rs b/tests/codegen-llvm/sanitizer/sanitize-off-khwasan-hwasan.rs
new file mode 100644
index 000000000000..a4491eb9f785
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/sanitize-off-khwasan-hwasan.rs
@@ -0,0 +1,31 @@
+// Verifies that the `#[sanitize(kernel_hwaddress = "off")]` attribute also turns off
+// the hardware-assisted address sanitizer.
+//
+//@ needs-sanitizer-hwaddress
+//@ compile-flags: -Cunsafe-allow-abi-mismatch=sanitizer
+//@ compile-flags: -Ctarget-feature=-crt-static
+//@ compile-flags: -Zsanitizer=hwaddress -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(sanitize)]
+
+// CHECK-NOT:   sanitize_hwaddress
+// CHECK-LABEL: define {{.*}} @unsanitized
+// CHECK:       start:
+// CHECK-NOT:   call void @llvm.hwasan.check.memaccess
+// CHECK:       }
+#[sanitize(kernel_hwaddress = "off")]
+#[no_mangle]
+pub fn unsanitized(b: &mut u8) -> u8 {
+    *b
+}
+
+// CHECK:       sanitize_hwaddress
+// CHECK-LABEL: define {{.*}} @sanitized
+// CHECK:       start:
+// CHECK:       call void @llvm.hwasan.check.memaccess
+// CHECK:       }
+#[no_mangle]
+pub fn sanitized(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/sanitizer-recover.rs b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
index b8a24e31c30b..5e05b92f3b10 100644
--- a/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
+++ b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
@@ -5,7 +5,7 @@
 //@ needs-sanitizer-memory
 //@ revisions:ASAN ASAN-RECOVER MSAN MSAN-RECOVER MSAN-RECOVER-LTO
 //@ no-prefer-dynamic
-//@                   compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//@                   compile-flags: -Cunsafe-allow-abi-mismatch=sanitizer
 //@                   compile-flags: -Ctarget-feature=-crt-static
 //@[ASAN]             compile-flags: -Zsanitizer=address -Copt-level=0
 //@[ASAN-RECOVER]     compile-flags: -Zsanitizer=address -Zsanitizer-recover=address -Copt-level=0
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index efa0a7f4af9a..0ba2f0b0f209 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -120,7 +120,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     sanitize = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `sanitize` are: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `realtime`, `safestack`, `shadow-call-stack`, and `thread`
+   = note: expected values for `sanitize` are: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `kernel-hwaddress`, `leak`, `memory`, `memtag`, `realtime`, `safestack`, `shadow-call-stack`, and `thread`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.stderr b/tests/ui/sanitize-attr/invalid-sanitize.stderr
index 00bb7746d05f..b35c2f9976f0 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.stderr
+++ b/tests/ui/sanitize-attr/invalid-sanitize.stderr
@@ -4,7 +4,7 @@ error[E0539]: malformed `sanitize` attribute input
 LL | #[sanitize(brontosaurus = "off")]
    | ^^^^^^^^^^^------------^^^^^^^^^^
    |            |
-   |            valid arguments are "address", "kernel_address", "cfi", "kcfi", "memory", "memtag", "shadow_call_stack", "thread", "hwaddress" or "realtime"
+   |            valid arguments are "address", "kernel_address", "cfi", "kcfi", "memory", "memtag", "shadow_call_stack", "thread", "hwaddress", "kernel_hwaddress" or "realtime"
 
 error: multiple `sanitize` attributes
   --> $DIR/invalid-sanitize.rs:7:1
diff --git a/tests/ui/sanitizer/cfg-khwasan.rs b/tests/ui/sanitizer/cfg-khwasan.rs
new file mode 100644
index 000000000000..c2b0505a34c2
--- /dev/null
+++ b/tests/ui/sanitizer/cfg-khwasan.rs
@@ -0,0 +1,22 @@
+// Verifies that when compiling with -Zsanitizer=kernel-hwaddress,
+// the `#[cfg(sanitize = "hwaddress")]` attribute is configured.
+
+//@ add-minicore
+//@ check-pass
+//@ compile-flags: -Zsanitizer=kernel-hwaddress
+//@ revisions: aarch64
+//@[aarch64] compile-flags: --target aarch64-unknown-none
+//@[aarch64] needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+
+#![crate_type = "rlib"]
+#![feature(cfg_sanitize, no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+const _: fn() -> () = main;
+
+#[cfg(sanitize = "hwaddress")]
+fn main() {}
diff --git a/tests/ui/sanitizer/incompatible-khwasan.rs b/tests/ui/sanitizer/incompatible-khwasan.rs
new file mode 100644
index 000000000000..eb6a5d33a472
--- /dev/null
+++ b/tests/ui/sanitizer/incompatible-khwasan.rs
@@ -0,0 +1,9 @@
+//@ compile-flags: -Z sanitizer=kernel-hwaddress -Z sanitizer=kernel-address --target aarch64-unknown-none
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR `-Zsanitizer=kernel-address` is incompatible with `-Zsanitizer=kernel-hwaddress`
diff --git a/tests/ui/sanitizer/incompatible-khwasan.stderr b/tests/ui/sanitizer/incompatible-khwasan.stderr
new file mode 100644
index 000000000000..35246fb26623
--- /dev/null
+++ b/tests/ui/sanitizer/incompatible-khwasan.stderr
@@ -0,0 +1,4 @@
+error: `-Zsanitizer=kernel-address` is incompatible with `-Zsanitizer=kernel-hwaddress`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/sanitizer/unsupported-target-khwasan.rs b/tests/ui/sanitizer/unsupported-target-khwasan.rs
new file mode 100644
index 000000000000..bef6d95e57b2
--- /dev/null
+++ b/tests/ui/sanitizer/unsupported-target-khwasan.rs
@@ -0,0 +1,9 @@
+//@ compile-flags: -Z sanitizer=kernel-hwaddress --target x86_64-unknown-none
+//@ needs-llvm-components: x86
+//@ ignore-backends: gcc
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR kernel-hwaddress sanitizer is not supported for this target
diff --git a/tests/ui/sanitizer/unsupported-target-khwasan.stderr b/tests/ui/sanitizer/unsupported-target-khwasan.stderr
new file mode 100644
index 000000000000..8b122a610ee4
--- /dev/null
+++ b/tests/ui/sanitizer/unsupported-target-khwasan.stderr
@@ -0,0 +1,4 @@
+error: kernel-hwaddress sanitizer is not supported for this target
+
+error: aborting due to 1 previous error
+

From e41bbfaaa6b4bfde2130add801ec3bf392d74539 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Fri, 6 Mar 2026 17:07:14 +0000
Subject: [PATCH 0591/1059] Explain why __hwasan_tls is present in LLVM codegen

---
 tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
index fd3aacee5af2..b059f6bbefb4 100644
--- a/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
+++ b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
@@ -17,9 +17,19 @@
 // hwasan:       call void @llvm.hwasan.check.memaccess.shortgranules
 // hwasan:       declare void @__hwasan_init()
 
-// khwasan-LABEL: define {{.*}} @test
-// khwasan-NOT:   @__hwasan_init
+// The `__hwasan_tls` symbol is unconditionally declared by LLVM's `HWAddressSanitizer` pass.
+// However, in kernel mode KHWASAN does not actually use it (because shadow mapping is fixed
+// and the stack frame ring buffer is disabled). It remains an unused declaration in the LLVM IR
+// and is optimized out before the final assembly/object file is generated, so it does not end
+// up in the final binary. Thus, assert that it appears in the output, but not inside `test`.
+//
 // khwasan:       @__hwasan_tls
+// khwasan-LABEL: define {{.*}} @test
+// khwasan-NOT:   @__hwasan_tls
+//
+// Also test a few other things appear under the LABEL.
+//
+// khwasan-NOT:   @__hwasan_init
 // khwasan:       call void @llvm.hwasan.check.memaccess.shortgranules
 #[no_mangle]
 pub fn test(b: &mut u8) -> u8 {

From ec03f4ef294d3a75ed12b36662d1a40441b0a726 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Mon, 16 Mar 2026 14:23:24 +0000
Subject: [PATCH 0592/1059] Adjust lifetime markers comment

---
 compiler/rustc_session/src/session.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 3da2d891e19d..96f54481350d 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -527,8 +527,11 @@ pub fn needs_plt(&self) -> bool {
     pub fn emit_lifetime_markers(&self) -> bool {
         self.opts.optimize != config::OptLevel::No
         // AddressSanitizer and KernelAddressSanitizer uses lifetimes to detect use after scope bugs.
+        //
         // MemorySanitizer uses lifetimes to detect use of uninitialized stack variables.
-        // HWAddressSanitizer will use lifetimes to detect use after scope bugs in the future.
+        //
+        // HWAddressSanitizer and KernelHWAddressSanitizer will use lifetimes to detect use after
+        // scope bugs in the future.
         || self.sanitizers().intersects(SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS | SanitizerSet::MEMORY | SanitizerSet::HWADDRESS | SanitizerSet::KERNELHWADDRESS)
     }
 

From c679e3daf2166e2bcd56e8acc2cacfe6dc9757a8 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Tue, 17 Mar 2026 07:49:28 +0000
Subject: [PATCH 0593/1059] Simplify tests and fix test tidy issue

---
 tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs       | 2 ++
 tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs        | 2 ++
 tests/codegen-llvm/sanitizer/kasan-recover.rs            | 8 +++-----
 tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs | 5 ++---
 tests/codegen-llvm/sanitizer/khwasan-recover.rs          | 9 +++------
 .../sanitizer/sanitize-off-hwasan-khwasan.rs             | 9 +++------
 tests/ui/sanitizer/cfg-khwasan.rs                        | 6 ++----
 7 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs b/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
index bcb2fbc613df..a4362b362132 100644
--- a/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
+++ b/tests/assembly-llvm/sanitizer/hwasan-vs-khwasan.rs
@@ -4,7 +4,9 @@
 //@ assembly-output: emit-asm
 //@ revisions: hwasan khwasan
 //@[hwasan] compile-flags: --target aarch64-unknown-linux-gnu -Zsanitizer=hwaddress
+//@[hwasan] needs-llvm-components: aarch64
 //@[khwasan] compile-flags: --target aarch64-unknown-none -Zsanitizer=kernel-hwaddress
+//@[khwasan] needs-llvm-components: aarch64
 //@ compile-flags: -Copt-level=1
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
index b059f6bbefb4..93932d86582f 100644
--- a/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
+++ b/tests/codegen-llvm/sanitizer/hwasan-vs-khwasan.rs
@@ -3,7 +3,9 @@
 //@ add-minicore
 //@ revisions: hwasan khwasan
 //@[hwasan] compile-flags: --target aarch64-unknown-linux-gnu -Zsanitizer=hwaddress
+//@[hwasan] needs-llvm-components: aarch64
 //@[khwasan] compile-flags: --target aarch64-unknown-none -Zsanitizer=kernel-hwaddress
+//@[khwasan] needs-llvm-components: aarch64
 //@ compile-flags: -Copt-level=0
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/sanitizer/kasan-recover.rs b/tests/codegen-llvm/sanitizer/kasan-recover.rs
index 8f0e6eb3a605..f0f9180ae595 100644
--- a/tests/codegen-llvm/sanitizer/kasan-recover.rs
+++ b/tests/codegen-llvm/sanitizer/kasan-recover.rs
@@ -4,11 +4,9 @@
 //@ add-minicore
 //@ revisions: KASAN KASAN-RECOVER
 //@ compile-flags: -Copt-level=0
-//@[KASAN]            compile-flags: -Zsanitizer=kernel-address --target x86_64-unknown-none
-//@[KASAN]            needs-llvm-components: x86
-//@[KASAN-RECOVER]    compile-flags: -Zsanitizer=kernel-address
-//@[KASAN-RECOVER]    compile-flags: -Zsanitizer-recover=kernel-address --target x86_64-unknown-none
-//@[KASAN-RECOVER]    needs-llvm-components: x86
+//@ needs-llvm-components: x86
+//@ compile-flags: -Zsanitizer=kernel-address --target x86_64-unknown-none
+//@[KASAN-RECOVER] compile-flags: -Zsanitizer-recover=kernel-address
 
 #![feature(no_core, sanitize, lang_items)]
 #![no_core]
diff --git a/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs b/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
index 01b129cb6920..26dc7983d731 100644
--- a/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
+++ b/tests/codegen-llvm/sanitizer/khwasan-lifetime-markers.rs
@@ -2,9 +2,8 @@
 
 //@ add-minicore
 //@ compile-flags: -Zsanitizer=kernel-hwaddress -Copt-level=0
-//@ revisions: aarch64
-//@[aarch64] compile-flags: --target aarch64-unknown-none
-//@[aarch64] needs-llvm-components: aarch64
+//@ compile-flags: --target aarch64-unknown-none
+//@ needs-llvm-components: aarch64
 
 #![crate_type = "rlib"]
 #![feature(no_core, lang_items)]
diff --git a/tests/codegen-llvm/sanitizer/khwasan-recover.rs b/tests/codegen-llvm/sanitizer/khwasan-recover.rs
index 957b867a61ad..452a0f579fc7 100644
--- a/tests/codegen-llvm/sanitizer/khwasan-recover.rs
+++ b/tests/codegen-llvm/sanitizer/khwasan-recover.rs
@@ -2,15 +2,12 @@
 // with -Zsanitizer-recover=kernel-hwaddress.
 //
 //@ add-minicore
-//@[KHWASAN] needs-llvm-components: aarch64
-//@[KHWASAN-RECOVER] needs-llvm-components: aarch64
+//@ needs-llvm-components: aarch64
 //@ revisions: KHWASAN KHWASAN-RECOVER
 //@ no-prefer-dynamic
 //@ compile-flags: -Copt-level=0
-//@[KHWASAN]            compile-flags: -Zsanitizer=kernel-hwaddress --target aarch64-unknown-none
-//@[KHWASAN-RECOVER]    compile-flags: -Zsanitizer=kernel-hwaddress
-//@[KHWASAN-RECOVER]    compile-flags: -Zsanitizer-recover=kernel-hwaddress
-//@[KHWASAN-RECOVER]    compile-flags: --target aarch64-unknown-none
+//@ compile-flags: -Zsanitizer=kernel-hwaddress --target aarch64-unknown-none
+//@[KHWASAN-RECOVER] compile-flags: -Zsanitizer-recover=kernel-hwaddress
 
 #![feature(no_core, sanitize, lang_items)]
 #![no_core]
diff --git a/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs b/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
index c0e23f5f596b..313f48031e4a 100644
--- a/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
+++ b/tests/codegen-llvm/sanitizer/sanitize-off-hwasan-khwasan.rs
@@ -2,12 +2,9 @@
 // the kernel hardware-assisted address sanitizer.
 //
 //@ add-minicore
-//@ compile-flags: -Zsanitizer=kernel-hwaddress -Ctarget-feature=-crt-static -Copt-level=0
-//@ revisions: aarch64 aarch64v8r
-//@[aarch64] compile-flags: --target aarch64-unknown-none
-//@[aarch64] needs-llvm-components: aarch64
-//@[aarch64v8r] compile-flags: --target aarch64v8r-unknown-none
-//@[aarch64v8r] needs-llvm-components: aarch64
+//@ compile-flags: -Zsanitizer=kernel-hwaddress --target aarch64-unknown-none
+//@ compile-flags: -Ctarget-feature=-crt-static -Copt-level=0
+//@ needs-llvm-components: aarch64
 
 #![crate_type = "rlib"]
 #![feature(no_core, sanitize, lang_items)]
diff --git a/tests/ui/sanitizer/cfg-khwasan.rs b/tests/ui/sanitizer/cfg-khwasan.rs
index c2b0505a34c2..27a2f6030d0b 100644
--- a/tests/ui/sanitizer/cfg-khwasan.rs
+++ b/tests/ui/sanitizer/cfg-khwasan.rs
@@ -3,10 +3,8 @@
 
 //@ add-minicore
 //@ check-pass
-//@ compile-flags: -Zsanitizer=kernel-hwaddress
-//@ revisions: aarch64
-//@[aarch64] compile-flags: --target aarch64-unknown-none
-//@[aarch64] needs-llvm-components: aarch64
+//@ compile-flags: -Zsanitizer=kernel-hwaddress --target aarch64-unknown-none
+//@ needs-llvm-components: aarch64
 //@ ignore-backends: gcc
 
 #![crate_type = "rlib"]

From 36381555bb78f41f178032dbabbf9ebd602c3530 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Fri, 13 Mar 2026 18:54:40 +0100
Subject: [PATCH 0594/1059] Put statics in .data section in raw-dylib for ELF

This fixes issues with statics when using static relocation model and
linking with GNU ld. Other linkers don't work yet.
---
 .../src/back/link/raw_dylib.rs                | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
index 3017e5fc567d..06dd7e7eb2bd 100644
--- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -296,6 +296,8 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
     stub.reserve_shstrtab_section_index();
     let text_section_name = stub.add_section_name(".text".as_bytes());
     let text_section = stub.reserve_section_index();
+    let data_section_name = stub.add_section_name(".data".as_bytes());
+    let data_section = stub.reserve_section_index();
     stub.reserve_dynsym_section_index();
     stub.reserve_dynstr_section_index();
     if !vers.is_empty() {
@@ -375,7 +377,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
     // Section headers
     stub.write_null_section_header();
     stub.write_shstrtab_section_header();
-    // Create a dummy .text section for our dummy symbols.
+    // Create a dummy .text section for our dummy non-data symbols.
     stub.write_section_header(&write::SectionHeader {
         name: Some(text_section_name),
         sh_type: elf::SHT_PROGBITS,
@@ -388,6 +390,19 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
         sh_addralign: 1,
         sh_entsize: 0,
     });
+    // And also a dummy .data section for our dummy data symbols.
+    stub.write_section_header(&write::SectionHeader {
+        name: Some(data_section_name),
+        sh_type: elf::SHT_PROGBITS,
+        sh_flags: (elf::SHF_WRITE | elf::SHF_ALLOC) as u64,
+        sh_addr: 0,
+        sh_offset: 0,
+        sh_size: 0,
+        sh_link: 0,
+        sh_info: 0,
+        sh_addralign: 16,
+        sh_entsize: 0,
+    });
     stub.write_dynsym_section_header(0, 1);
     stub.write_dynstr_section_header(0);
     if !vers.is_empty() {
@@ -404,11 +419,13 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
             DllImportSymbolType::Static => elf::STT_OBJECT,
             DllImportSymbolType::ThreadLocal => elf::STT_TLS,
         };
+        let section =
+            if symbol_type == DllImportSymbolType::Static { data_section } else { text_section };
         stub.write_dynamic_symbol(&write::Sym {
             name: Some(dynstr),
             st_info: (elf::STB_GLOBAL << 4) | sym_type,
             st_other: elf::STV_DEFAULT,
-            section: Some(text_section),
+            section: Some(section),
             st_shndx: 0, // ignored by object in favor of the `section` field
             st_value: 0,
             st_size: size.bytes(),

From ed4afa598928a239725a7862589145359dbf9b9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Fri, 13 Mar 2026 19:46:32 +0100
Subject: [PATCH 0595/1059] Set symbols value in raw-dylib for ELF

With this change LLD finally produces working binaries with static
relocation model.
---
 compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
index 06dd7e7eb2bd..ddc30ee9f3ac 100644
--- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -387,7 +387,7 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
         sh_size: 0,
         sh_link: 0,
         sh_info: 0,
-        sh_addralign: 1,
+        sh_addralign: 16,
         sh_entsize: 0,
     });
     // And also a dummy .data section for our dummy data symbols.
@@ -413,6 +413,10 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
 
     // .dynsym
     stub.write_null_dynamic_symbol();
+    // Linkers like LLD require at least somewhat reasonable symbol values rather than zero,
+    // otherwise all the symbols might get put at the same address. Thus we increment the value
+    // every time we write a symbol.
+    let mut st_value = 0;
     for (_name, dynstr, _ver, symbol_type, size) in syms.iter().copied() {
         let sym_type = match symbol_type {
             DllImportSymbolType::Function => elf::STT_FUNC,
@@ -427,9 +431,10 @@ fn create_elf_raw_dylib_stub(sess: &Session, soname: &str, symbols: &[DllImport]
             st_other: elf::STV_DEFAULT,
             section: Some(section),
             st_shndx: 0, // ignored by object in favor of the `section` field
-            st_value: 0,
+            st_value,
             st_size: size.bytes(),
         });
+        st_value += 8;
     }
 
     // .dynstr

From 3531ed9c1d7e866cf2b2c238efaca7e5fc3f4b0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Mon, 9 Mar 2026 18:17:07 +0100
Subject: [PATCH 0596/1059] Extend raw-dylib test for ELF with reloc models

---
 tests/run-make/raw-dylib-elf/library.c  |  2 ++
 tests/run-make/raw-dylib-elf/main.rs    | 14 ++++++++++--
 tests/run-make/raw-dylib-elf/output.txt |  2 +-
 tests/run-make/raw-dylib-elf/rmake.rs   | 30 ++++++++++++++++---------
 4 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/tests/run-make/raw-dylib-elf/library.c b/tests/run-make/raw-dylib-elf/library.c
index 943a1382e340..060cab6ee02f 100644
--- a/tests/run-make/raw-dylib-elf/library.c
+++ b/tests/run-make/raw-dylib-elf/library.c
@@ -1,5 +1,7 @@
 int global_variable = 3;
 __thread int tls_variable = 33;
+const long const_array[] = {795, 906};
+const char *const_string = "sums of three cubes";
 
 int this_is_a_library_function() {
     return 42;
diff --git a/tests/run-make/raw-dylib-elf/main.rs b/tests/run-make/raw-dylib-elf/main.rs
index ec8951da88f0..b55cde766a37 100644
--- a/tests/run-make/raw-dylib-elf/main.rs
+++ b/tests/run-make/raw-dylib-elf/main.rs
@@ -2,7 +2,7 @@
 #![feature(thread_local)]
 #![allow(incomplete_features)]
 
-use std::ffi::c_int;
+use std::ffi::{CStr, c_char, c_int, c_long};
 
 #[link(name = "library", kind = "raw-dylib")]
 unsafe extern "C" {
@@ -10,10 +10,20 @@
     static mut global_variable: c_int;
     #[thread_local]
     static mut tls_variable: c_int;
+    safe static const_array: [c_long; 2];
+    safe static const_string: *const c_char;
 }
 
 fn main() {
     unsafe {
-        println!("{} {} {}", this_is_a_library_function(), global_variable, tls_variable);
+        println!(
+            "{} {} {} {} {} {}",
+            this_is_a_library_function(),
+            global_variable,
+            tls_variable,
+            const_array[0],
+            const_array[1],
+            CStr::from_ptr(const_string).to_str().unwrap(),
+        );
     }
 }
diff --git a/tests/run-make/raw-dylib-elf/output.txt b/tests/run-make/raw-dylib-elf/output.txt
index 53383c3b8645..6a9770dcb39b 100644
--- a/tests/run-make/raw-dylib-elf/output.txt
+++ b/tests/run-make/raw-dylib-elf/output.txt
@@ -1 +1 @@
-42 3 33
+42 3 33 795 906 sums of three cubes
diff --git a/tests/run-make/raw-dylib-elf/rmake.rs b/tests/run-make/raw-dylib-elf/rmake.rs
index 59f901ac1ed7..d8a10fcb7f83 100644
--- a/tests/run-make/raw-dylib-elf/rmake.rs
+++ b/tests/run-make/raw-dylib-elf/rmake.rs
@@ -11,19 +11,27 @@
 use run_make_support::{build_native_dynamic_lib, cwd, diff, run, rustc};
 
 fn main() {
-    // We compile the binary without having the library present.
+    // We compile the binaries without having the library present with different relocation
+    // models.
     // We also set the rpath to the current directory so we can pick up the library at runtime.
-    rustc()
-        .crate_type("bin")
-        .input("main.rs")
-        .arg(&format!("-Wl,-rpath={}", cwd().display()))
-        .run();
+    let relocation_models = ["static", "pic", "pie"];
+    for relocation_model in relocation_models {
+        rustc()
+            .crate_type("bin")
+            .input("main.rs")
+            .arg(&format!("-Wl,-rpath={}", cwd().display()))
+            .arg(&format!("-Crelocation-model={}", relocation_model))
+            .output(&format!("main-{}", relocation_model))
+            .run();
+    }
 
-    // Now, *after* building the binary, we build the library...
+    // Now, *after* building the binaries, we build the library...
     build_native_dynamic_lib("library");
 
-    // ... and run with this library, ensuring it was linked correctly at runtime.
-    let output = run("main").stdout_utf8();
-
-    diff().expected_file("output.txt").actual_text("actual", output).run();
+    for relocation_model in relocation_models {
+        // ... and run with this library, ensuring it was linked correctly at runtime.
+        // The output here should be the same regardless of the relocation model.
+        let output = run(&format!("main-{}", relocation_model)).stdout_utf8();
+        diff().expected_file("output.txt").actual_text("actual", output).run();
+    }
 }

From 69fd61e40e854ecd75e19b32ebb913d1a8c7d121 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 16:15:14 +0000
Subject: [PATCH 0597/1059] merge `kindck/send-*` tests

---
 tests/ui/kindck/kindck-send-object.rs         |  26 ----
 tests/ui/kindck/kindck-send-object.stderr     |  33 -----
 tests/ui/kindck/kindck-send-object1.rs        |  33 -----
 tests/ui/kindck/kindck-send-object1.stderr    |  41 ------
 tests/ui/kindck/kindck-send-object2.rs        |  24 ----
 tests/ui/kindck/kindck-send-object2.stderr    |  33 -----
 tests/ui/kindck/kindck-send-owned.rs          |  16 ---
 tests/ui/kindck/kindck-send-owned.stderr      |  19 ---
 tests/ui/kindck/kindck-send-unsafe.rs         |  15 ---
 tests/ui/kindck/kindck-send-unsafe.stderr     |  29 ----
 tests/ui/kindck/send-trait-objects-basic.rs   |  55 ++++++++
 .../ui/kindck/send-trait-objects-basic.stderr | 127 ++++++++++++++++++
 12 files changed, 182 insertions(+), 269 deletions(-)
 delete mode 100644 tests/ui/kindck/kindck-send-object.rs
 delete mode 100644 tests/ui/kindck/kindck-send-object.stderr
 delete mode 100644 tests/ui/kindck/kindck-send-object1.rs
 delete mode 100644 tests/ui/kindck/kindck-send-object1.stderr
 delete mode 100644 tests/ui/kindck/kindck-send-object2.rs
 delete mode 100644 tests/ui/kindck/kindck-send-object2.stderr
 delete mode 100644 tests/ui/kindck/kindck-send-owned.rs
 delete mode 100644 tests/ui/kindck/kindck-send-owned.stderr
 delete mode 100644 tests/ui/kindck/kindck-send-unsafe.rs
 delete mode 100644 tests/ui/kindck/kindck-send-unsafe.stderr
 create mode 100644 tests/ui/kindck/send-trait-objects-basic.rs
 create mode 100644 tests/ui/kindck/send-trait-objects-basic.stderr

diff --git a/tests/ui/kindck/kindck-send-object.rs b/tests/ui/kindck/kindck-send-object.rs
deleted file mode 100644
index f5d44246efe5..000000000000
--- a/tests/ui/kindck/kindck-send-object.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Test which of the builtin types are considered sendable. The tests
-// in this file all test the "kind" violates detected during kindck.
-// See all `regions-bounded-by-send.rs`
-
-fn assert_send<T:Send>() { }
-trait Dummy { }
-trait Message : Send { }
-
-// careful with object types, who knows what they close over...
-
-fn object_ref_with_static_bound_not_ok() {
-    assert_send::<&'static (dyn Dummy + 'static)>();
-    //~^ ERROR `&'static (dyn Dummy + 'static)` cannot be sent between threads safely [E0277]
-}
-
-fn box_object_with_no_bound_not_ok<'a>() {
-    assert_send::<Box<dyn Dummy>>();
-    //~^ ERROR `dyn Dummy` cannot be sent between threads safely
-}
-
-fn object_with_send_bound_ok() {
-    assert_send::<&'static (dyn Dummy + Sync)>();
-    assert_send::<Box<dyn Dummy + Send>>();
-}
-
-fn main() { }
diff --git a/tests/ui/kindck/kindck-send-object.stderr b/tests/ui/kindck/kindck-send-object.stderr
deleted file mode 100644
index b71d4029350e..000000000000
--- a/tests/ui/kindck/kindck-send-object.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
-  --> $DIR/kindck-send-object.rs:12:19
-   |
-LL |     assert_send::<&'static (dyn Dummy + 'static)>();
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
-   |
-   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`
-   = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object.rs:5:18
-   |
-LL | fn assert_send<T:Send>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error[E0277]: `dyn Dummy` cannot be sent between threads safely
-  --> $DIR/kindck-send-object.rs:17:19
-   |
-LL |     assert_send::<Box<dyn Dummy>>();
-   |                   ^^^^^^^^^^^^^^ `dyn Dummy` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `dyn Dummy`
-   = note: required for `std::ptr::Unique<dyn Dummy>` to implement `Send`
-note: required because it appears within the type `Box<dyn Dummy>`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object.rs:5:18
-   |
-LL | fn assert_send<T:Send>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-send-object1.rs b/tests/ui/kindck/kindck-send-object1.rs
deleted file mode 100644
index 76a9fc6019ab..000000000000
--- a/tests/ui/kindck/kindck-send-object1.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Test which object types are considered sendable. This test
-// is broken into two parts because some errors occur in distinct
-// phases in the compiler. See kindck-send-object2.rs as well!
-
-fn assert_send<T:Send+'static>() { }
-trait Dummy { }
-
-// careful with object types, who knows what they close over...
-fn test51<'a>() {
-    assert_send::<&'a dyn Dummy>();
-    //~^ ERROR `&'a (dyn Dummy + 'a)` cannot be sent between threads safely [E0277]
-}
-fn test52<'a>() {
-    assert_send::<&'a (dyn Dummy + Sync)>();
-    //~^ ERROR: lifetime may not live long enough
-}
-
-// ...unless they are properly bounded
-fn test60() {
-    assert_send::<&'static (dyn Dummy + Sync)>();
-}
-fn test61() {
-    assert_send::<Box<dyn Dummy + Send>>();
-}
-
-// closure and object types can have lifetime bounds which make
-// them not ok
-fn test_71<'a>() {
-    assert_send::<Box<dyn Dummy + 'a>>();
-    //~^ ERROR `(dyn Dummy + 'a)` cannot be sent between threads safely
-}
-
-fn main() { }
diff --git a/tests/ui/kindck/kindck-send-object1.stderr b/tests/ui/kindck/kindck-send-object1.stderr
deleted file mode 100644
index 2184ae704673..000000000000
--- a/tests/ui/kindck/kindck-send-object1.stderr
+++ /dev/null
@@ -1,41 +0,0 @@
-error[E0277]: `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
-  --> $DIR/kindck-send-object1.rs:10:19
-   |
-LL |     assert_send::<&'a dyn Dummy>();
-   |                   ^^^^^^^^^^^^^ `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
-   |
-   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'a)`
-   = note: required for `&'a (dyn Dummy + 'a)` to implement `Send`
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object1.rs:5:18
-   |
-LL | fn assert_send<T:Send+'static>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error[E0277]: `(dyn Dummy + 'a)` cannot be sent between threads safely
-  --> $DIR/kindck-send-object1.rs:29:19
-   |
-LL |     assert_send::<Box<dyn Dummy + 'a>>();
-   |                   ^^^^^^^^^^^^^^^^^^^ `(dyn Dummy + 'a)` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `(dyn Dummy + 'a)`
-   = note: required for `std::ptr::Unique<(dyn Dummy + 'a)>` to implement `Send`
-note: required because it appears within the type `Box<(dyn Dummy + 'a)>`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object1.rs:5:18
-   |
-LL | fn assert_send<T:Send+'static>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error: lifetime may not live long enough
-  --> $DIR/kindck-send-object1.rs:14:5
-   |
-LL | fn test52<'a>() {
-   |           -- lifetime `'a` defined here
-LL |     assert_send::<&'a (dyn Dummy + Sync)>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-send-object2.rs b/tests/ui/kindck/kindck-send-object2.rs
deleted file mode 100644
index d37074e65746..000000000000
--- a/tests/ui/kindck/kindck-send-object2.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Continue kindck-send-object1.rs.
-
-fn assert_send<T:Send>() { }
-trait Dummy { }
-
-fn test50() {
-    assert_send::<&'static dyn Dummy>();
-    //~^ ERROR `&'static (dyn Dummy + 'static)` cannot be sent between threads safely [E0277]
-}
-
-fn test53() {
-    assert_send::<Box<dyn Dummy>>();
-    //~^ ERROR `dyn Dummy` cannot be sent between threads safely
-}
-
-// ...unless they are properly bounded
-fn test60() {
-    assert_send::<&'static (dyn Dummy + Sync)>();
-}
-fn test61() {
-    assert_send::<Box<dyn Dummy + Send>>();
-}
-
-fn main() { }
diff --git a/tests/ui/kindck/kindck-send-object2.stderr b/tests/ui/kindck/kindck-send-object2.stderr
deleted file mode 100644
index 52a7055b4229..000000000000
--- a/tests/ui/kindck/kindck-send-object2.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
-  --> $DIR/kindck-send-object2.rs:7:19
-   |
-LL |     assert_send::<&'static dyn Dummy>();
-   |                   ^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
-   |
-   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`
-   = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object2.rs:3:18
-   |
-LL | fn assert_send<T:Send>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error[E0277]: `dyn Dummy` cannot be sent between threads safely
-  --> $DIR/kindck-send-object2.rs:12:19
-   |
-LL |     assert_send::<Box<dyn Dummy>>();
-   |                   ^^^^^^^^^^^^^^ `dyn Dummy` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `dyn Dummy`
-   = note: required for `std::ptr::Unique<dyn Dummy>` to implement `Send`
-note: required because it appears within the type `Box<dyn Dummy>`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-object2.rs:3:18
-   |
-LL | fn assert_send<T:Send>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-send-owned.rs b/tests/ui/kindck/kindck-send-owned.rs
deleted file mode 100644
index 65efb69041d5..000000000000
--- a/tests/ui/kindck/kindck-send-owned.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Test which of the builtin types are considered sendable.
-
-fn assert_send<T:Send>() { }
-
-// owned content are ok
-fn test30() { assert_send::<Box<isize>>(); }
-fn test31() { assert_send::<String>(); }
-fn test32() { assert_send::<Vec<isize> >(); }
-
-// but not if they own a bad thing
-fn test40() {
-    assert_send::<Box<*mut u8>>();
-    //~^ ERROR `*mut u8` cannot be sent between threads safely
-}
-
-fn main() { }
diff --git a/tests/ui/kindck/kindck-send-owned.stderr b/tests/ui/kindck/kindck-send-owned.stderr
deleted file mode 100644
index c433d80cf140..000000000000
--- a/tests/ui/kindck/kindck-send-owned.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0277]: `*mut u8` cannot be sent between threads safely
-  --> $DIR/kindck-send-owned.rs:12:19
-   |
-LL |     assert_send::<Box<*mut u8>>();
-   |                   ^^^^^^^^^^^^ `*mut u8` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `*mut u8`
-   = note: required for `std::ptr::Unique<*mut u8>` to implement `Send`
-note: required because it appears within the type `Box<*mut u8>`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-owned.rs:3:18
-   |
-LL | fn assert_send<T:Send>() { }
-   |                  ^^^^ required by this bound in `assert_send`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-send-unsafe.rs b/tests/ui/kindck/kindck-send-unsafe.rs
deleted file mode 100644
index eb1f2a549b16..000000000000
--- a/tests/ui/kindck/kindck-send-unsafe.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-extern crate core;
-
-fn assert_send<T: Send>() {}
-
-fn test70() {
-    assert_send::<*mut isize>();
-    //~^ ERROR `*mut isize` cannot be sent between threads safely
-}
-
-fn test71<'a>() {
-    assert_send::<*mut &'a isize>();
-    //~^ ERROR `*mut &'a isize` cannot be sent between threads safely
-}
-
-fn main() {}
diff --git a/tests/ui/kindck/kindck-send-unsafe.stderr b/tests/ui/kindck/kindck-send-unsafe.stderr
deleted file mode 100644
index f1a5054abbc4..000000000000
--- a/tests/ui/kindck/kindck-send-unsafe.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error[E0277]: `*mut isize` cannot be sent between threads safely
-  --> $DIR/kindck-send-unsafe.rs:6:19
-   |
-LL |     assert_send::<*mut isize>();
-   |                   ^^^^^^^^^^ `*mut isize` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `*mut isize`
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-unsafe.rs:3:19
-   |
-LL | fn assert_send<T: Send>() {}
-   |                   ^^^^ required by this bound in `assert_send`
-
-error[E0277]: `*mut &'a isize` cannot be sent between threads safely
-  --> $DIR/kindck-send-unsafe.rs:11:19
-   |
-LL |     assert_send::<*mut &'a isize>();
-   |                   ^^^^^^^^^^^^^^ `*mut &'a isize` cannot be sent between threads safely
-   |
-   = help: the trait `Send` is not implemented for `*mut &'a isize`
-note: required by a bound in `assert_send`
-  --> $DIR/kindck-send-unsafe.rs:3:19
-   |
-LL | fn assert_send<T: Send>() {}
-   |                   ^^^^ required by this bound in `assert_send`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/send-trait-objects-basic.rs b/tests/ui/kindck/send-trait-objects-basic.rs
new file mode 100644
index 000000000000..c999d4d0f695
--- /dev/null
+++ b/tests/ui/kindck/send-trait-objects-basic.rs
@@ -0,0 +1,55 @@
+// Test which trait objects and basic types are considered sendable, considering lifetimes.
+
+fn assert_send_static<T: Send + 'static>() {}
+fn assert_send<T: Send>() {}
+
+trait Dummy {}
+
+fn test1<'a>() {
+    assert_send_static::<&'a dyn Dummy>();
+    //~^ ERROR `&'a (dyn Dummy + 'a)` cannot be sent between threads safely [E0277]
+}
+
+fn test2<'a>() {
+    assert_send_static::<&'a (dyn Dummy + Sync)>();
+    //~^ ERROR: lifetime may not live long enough
+}
+
+fn test3<'a>() {
+    assert_send_static::<Box<dyn Dummy + 'a>>();
+    //~^ ERROR `(dyn Dummy + 'a)` cannot be sent between threads safely
+}
+
+fn test4<'a>() {
+    assert_send::<*mut &'a isize>();
+    //~^ ERROR `*mut &'a isize` cannot be sent between threads safely
+}
+
+fn main() {
+    assert_send_static::<&'static (dyn Dummy + Sync)>();
+    assert_send_static::<Box<dyn Dummy + Send>>();
+
+    assert_send::<&'static dyn Dummy>();
+    //~^ ERROR `&'static (dyn Dummy + 'static)` cannot be sent between threads safely [E0277]
+    assert_send::<Box<dyn Dummy>>();
+    //~^ ERROR `dyn Dummy` cannot be sent between threads safely
+    assert_send::<&'static (dyn Dummy + Sync)>();
+    assert_send::<Box<dyn Dummy + Send>>();
+
+    // owned content is ok
+    assert_send::<Box<isize>>();
+    assert_send::<String>();
+    assert_send::<Vec<isize>>();
+
+    // but not if it owns a bad thing
+    assert_send::<Box<*mut u8>>();
+    //~^ ERROR `*mut u8` cannot be sent between threads safely
+
+    assert_send::<*mut isize>();
+    //~^ ERROR `*mut isize` cannot be sent between threads safely
+}
+
+fn object_ref_with_static_bound_not_ok() {
+    assert_send::<&'static (dyn Dummy + 'static)>();
+    //~^ ERROR `&'static (dyn Dummy + 'static)` cannot be sent between threads safely [E0277]
+}
diff --git a/tests/ui/kindck/send-trait-objects-basic.stderr b/tests/ui/kindck/send-trait-objects-basic.stderr
new file mode 100644
index 000000000000..0393f7bc19df
--- /dev/null
+++ b/tests/ui/kindck/send-trait-objects-basic.stderr
@@ -0,0 +1,127 @@
+error[E0277]: `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:9:26
+   |
+LL |     assert_send_static::<&'a dyn Dummy>();
+   |                          ^^^^^^^^^^^^^ `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
+   |
+   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'a)`
+   = note: required for `&'a (dyn Dummy + 'a)` to implement `Send`
+note: required by a bound in `assert_send_static`
+  --> $DIR/send-trait-objects-basic.rs:3:26
+   |
+LL | fn assert_send_static<T: Send + 'static>() {}
+   |                          ^^^^ required by this bound in `assert_send_static`
+
+error[E0277]: `(dyn Dummy + 'a)` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:19:26
+   |
+LL |     assert_send_static::<Box<dyn Dummy + 'a>>();
+   |                          ^^^^^^^^^^^^^^^^^^^ `(dyn Dummy + 'a)` cannot be sent between threads safely
+   |
+   = help: the trait `Send` is not implemented for `(dyn Dummy + 'a)`
+   = note: required for `std::ptr::Unique<(dyn Dummy + 'a)>` to implement `Send`
+note: required because it appears within the type `Box<(dyn Dummy + 'a)>`
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+note: required by a bound in `assert_send_static`
+  --> $DIR/send-trait-objects-basic.rs:3:26
+   |
+LL | fn assert_send_static<T: Send + 'static>() {}
+   |                          ^^^^ required by this bound in `assert_send_static`
+
+error[E0277]: `*mut &'a isize` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:24:19
+   |
+LL |     assert_send::<*mut &'a isize>();
+   |                   ^^^^^^^^^^^^^^ `*mut &'a isize` cannot be sent between threads safely
+   |
+   = help: the trait `Send` is not implemented for `*mut &'a isize`
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:32:19
+   |
+LL |     assert_send::<&'static dyn Dummy>();
+   |                   ^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
+   |
+   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`
+   = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `dyn Dummy` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:34:19
+   |
+LL |     assert_send::<Box<dyn Dummy>>();
+   |                   ^^^^^^^^^^^^^^ `dyn Dummy` cannot be sent between threads safely
+   |
+   = help: the trait `Send` is not implemented for `dyn Dummy`
+   = note: required for `std::ptr::Unique<dyn Dummy>` to implement `Send`
+note: required because it appears within the type `Box<dyn Dummy>`
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `*mut u8` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:45:19
+   |
+LL |     assert_send::<Box<*mut u8>>();
+   |                   ^^^^^^^^^^^^ `*mut u8` cannot be sent between threads safely
+   |
+   = help: the trait `Send` is not implemented for `*mut u8`
+   = note: required for `std::ptr::Unique<*mut u8>` to implement `Send`
+note: required because it appears within the type `Box<*mut u8>`
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `*mut isize` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:48:19
+   |
+LL |     assert_send::<*mut isize>();
+   |                   ^^^^^^^^^^ `*mut isize` cannot be sent between threads safely
+   |
+   = help: the trait `Send` is not implemented for `*mut isize`
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
+  --> $DIR/send-trait-objects-basic.rs:53:19
+   |
+LL |     assert_send::<&'static (dyn Dummy + 'static)>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
+   |
+   = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`
+   = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
+note: required by a bound in `assert_send`
+  --> $DIR/send-trait-objects-basic.rs:4:19
+   |
+LL | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error: lifetime may not live long enough
+  --> $DIR/send-trait-objects-basic.rs:14:5
+   |
+LL | fn test2<'a>() {
+   |          -- lifetime `'a` defined here
+LL |     assert_send_static::<&'a (dyn Dummy + Sync)>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
+
+error: aborting due to 9 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

From 4845f7842228c03910b3bf5d1a4221eea4e14f5d Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Tue, 17 Mar 2026 15:59:08 -0400
Subject: [PATCH 0598/1059] Reword the incremental finalize diagnostic

Remove the confusing word "error".  The diagnostic is already prefixed
with a level when it is displayed, so this is redundant and possibly
confusing ("warning: error ...").

Add some help text summarizing the impact of what happened: the next
build won't be able to reuse work from the current run.
---
 compiler/rustc_incremental/src/errors.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_incremental/src/errors.rs b/compiler/rustc_incremental/src/errors.rs
index 3354689d0ca3..a1f4464c7659 100644
--- a/compiler/rustc_incremental/src/errors.rs
+++ b/compiler/rustc_incremental/src/errors.rs
@@ -192,7 +192,8 @@ pub(crate) struct DeleteFull<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag("error finalizing incremental compilation session directory `{$path}`: {$err}")]
+#[diag("did not finalize incremental compilation session directory `{$path}`: {$err}")]
+#[help("the next build will not be able to reuse work from this compilation")]
 pub(crate) struct Finalize<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,

From b4c1677fff43d9ea04002de85aef77915092be7d Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 15 Mar 2026 20:34:25 +0900
Subject: [PATCH 0599/1059] Do not lint `for-loops-over-fallibles` on external
 macros

---
 .../rustc_lint/src/for_loops_over_fallibles.rs     |  5 +++++
 tests/crashes/147973.rs                            | 14 --------------
 .../auxiliary/external-macro-issue-148114.rs       | 13 +++++++++++++
 .../external-macro-issue-148114.rs                 | 14 ++++++++++++++
 4 files changed, 32 insertions(+), 14 deletions(-)
 delete mode 100644 tests/crashes/147973.rs
 create mode 100644 tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs
 create mode 100644 tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs

diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index 24220e035b1d..a7c5943c250b 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -49,6 +49,11 @@ impl<'tcx> LateLintPass<'tcx> for ForLoopsOverFallibles {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let Some((pat, arg)) = extract_for_loop(expr) else { return };
 
+        // Do not put suggestions for external macros.
+        if pat.span.from_expansion() {
+            return;
+        }
+
         let arg_span = arg.span.source_callsite();
 
         let ty = cx.typeck_results().expr_ty(arg);
diff --git a/tests/crashes/147973.rs b/tests/crashes/147973.rs
deleted file mode 100644
index 7271c54846f1..000000000000
--- a/tests/crashes/147973.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// This is part of series of regression tests for some diagnostics ICEs encountered in the wild with
-// suggestions having overlapping parts under https://github.com/rust-lang/rust/pull/146121.
-// This is one MCVE from the beta crater run regressions from issue 147973.
-
-//@ needs-rustc-debug-assertions
-//@ known-bug: #147973
-
-//@ aux-build: overlapping_spans_helper.rs
-extern crate overlapping_spans_helper;
-
-fn main() {
-    let _name = Some(1);
-    overlapping_spans_helper::do_loop!(_name);
-}
diff --git a/tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs b/tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs
new file mode 100644
index 000000000000..68eff33cb3f1
--- /dev/null
+++ b/tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs
@@ -0,0 +1,13 @@
+#[macro_export]
+macro_rules! identity {
+    ($x:ident) => {
+        $x
+    };
+}
+
+#[macro_export]
+macro_rules! do_loop {
+    ($x:ident) => {
+        for $crate::identity!($x) in $x {}
+    };
+}
diff --git a/tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs b/tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs
new file mode 100644
index 000000000000..ca3ac3b9a864
--- /dev/null
+++ b/tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs
@@ -0,0 +1,14 @@
+//@ check-pass
+//@ aux-build:external-macro-issue-148114.rs
+
+// This test ensures we do not trigger the lint on external macros
+// ref. <https://github.com/rust-lang/rust/issues/148114>
+
+#![deny(for_loops_over_fallibles)]
+
+extern crate external_macro_issue_148114 as dep;
+
+fn main() {
+    let _name = Some(1);
+    dep::do_loop!(_name);
+}

From cfe18cfd37e3aefe0a9a653d3faac825c3a7868a Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 15 Mar 2026 20:35:16 +0900
Subject: [PATCH 0600/1059] Correct dir name

---
 .../auxiliary/external-macro-issue-148114.rs                      | 0
 .../external-macro-issue-148114.rs                                | 0
 .../macro-issue-140747.rs                                         | 0
 .../macro-issue-140747.stderr                                     | 0
 .../macro-iterator-next.rs                                        | 0
 .../macro-iterator-next.stderr                                    | 0
 6 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/auxiliary/external-macro-issue-148114.rs (100%)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/external-macro-issue-148114.rs (100%)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/macro-issue-140747.rs (100%)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/macro-issue-140747.stderr (100%)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/macro-iterator-next.rs (100%)
 rename tests/ui/lint/{for-loops-over-falibles => for-loops-over-fallibles}/macro-iterator-next.stderr (100%)

diff --git a/tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs b/tests/ui/lint/for-loops-over-fallibles/auxiliary/external-macro-issue-148114.rs
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/auxiliary/external-macro-issue-148114.rs
rename to tests/ui/lint/for-loops-over-fallibles/auxiliary/external-macro-issue-148114.rs
diff --git a/tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs b/tests/ui/lint/for-loops-over-fallibles/external-macro-issue-148114.rs
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/external-macro-issue-148114.rs
rename to tests/ui/lint/for-loops-over-fallibles/external-macro-issue-148114.rs
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-issue-140747.rs b/tests/ui/lint/for-loops-over-fallibles/macro-issue-140747.rs
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/macro-issue-140747.rs
rename to tests/ui/lint/for-loops-over-fallibles/macro-issue-140747.rs
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-issue-140747.stderr b/tests/ui/lint/for-loops-over-fallibles/macro-issue-140747.stderr
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/macro-issue-140747.stderr
rename to tests/ui/lint/for-loops-over-fallibles/macro-issue-140747.stderr
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs b/tests/ui/lint/for-loops-over-fallibles/macro-iterator-next.rs
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/macro-iterator-next.rs
rename to tests/ui/lint/for-loops-over-fallibles/macro-iterator-next.rs
diff --git a/tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr b/tests/ui/lint/for-loops-over-fallibles/macro-iterator-next.stderr
similarity index 100%
rename from tests/ui/lint/for-loops-over-falibles/macro-iterator-next.stderr
rename to tests/ui/lint/for-loops-over-fallibles/macro-iterator-next.stderr

From caeda1869aab15cdd25d43d2de43d43b4cfbee07 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 21:49:58 +0000
Subject: [PATCH 0601/1059] reformat and update remaining `ui/kindck` tests

---
 tests/ui/kindck/kindck-copy.rs                | 31 ++++-----
 tests/ui/kindck/kindck-copy.stderr            | 68 +++++++++----------
 tests/ui/kindck/kindck-impl-type-params-2.rs  | 15 ----
 .../kindck/kindck-impl-type-params-2.stderr   | 24 -------
 tests/ui/kindck/kindck-impl-type-params.rs    |  6 +-
 .../ui/kindck/kindck-impl-type-params.stderr  | 30 ++++----
 .../kindck-inherited-copy-bound.curr.stderr   | 56 ---------------
 .../ui/kindck/kindck-inherited-copy-bound.rs  | 10 ++-
 .../kindck/kindck-inherited-copy-bound.stderr | 26 +++----
 tests/ui/kindck/kindck-nonsendable-1.rs       |  4 +-
 tests/ui/kindck/kindck-nonsendable-1.stderr   | 18 ++---
 11 files changed, 96 insertions(+), 192 deletions(-)
 delete mode 100644 tests/ui/kindck/kindck-impl-type-params-2.rs
 delete mode 100644 tests/ui/kindck/kindck-impl-type-params-2.stderr
 delete mode 100644 tests/ui/kindck/kindck-inherited-copy-bound.curr.stderr

diff --git a/tests/ui/kindck/kindck-copy.rs b/tests/ui/kindck/kindck-copy.rs
index 36bf0d2b785f..c953b60260df 100644
--- a/tests/ui/kindck/kindck-copy.rs
+++ b/tests/ui/kindck/kindck-copy.rs
@@ -2,9 +2,9 @@
 
 use std::rc::Rc;
 
-fn assert_copy<T:Copy>() { }
+fn assert_copy<T: Copy>() {}
 
-trait Dummy { }
+trait Dummy {}
 
 #[derive(Copy, Clone)]
 struct MyStruct {
@@ -16,8 +16,8 @@ struct MyNoncopyStruct {
     x: Box<char>,
 }
 
-fn test<'a,T,U:Copy>(_: &'a isize) {
-    // lifetime pointers are ok...
+fn test<'a, T, U: Copy>(_: &'a isize) {
+    // references are ok...
     assert_copy::<&'static isize>();
     assert_copy::<&'a isize>();
     assert_copy::<&'a str>();
@@ -25,25 +25,25 @@ fn test<'a,T,U:Copy>(_: &'a isize) {
 
     // ...unless they are mutable
     assert_copy::<&'static mut isize>(); //~ ERROR : Copy` is not satisfied
-    assert_copy::<&'a mut isize>();  //~ ERROR : Copy` is not satisfied
+    assert_copy::<&'a mut isize>(); //~ ERROR : Copy` is not satisfied
 
     // boxes are not ok
-    assert_copy::<Box<isize>>();   //~ ERROR : Copy` is not satisfied
-    assert_copy::<String>();   //~ ERROR : Copy` is not satisfied
-    assert_copy::<Vec<isize> >(); //~ ERROR : Copy` is not satisfied
+    assert_copy::<Box<isize>>(); //~ ERROR : Copy` is not satisfied
+    assert_copy::<String>(); //~ ERROR : Copy` is not satisfied
+    assert_copy::<Vec<isize>>(); //~ ERROR : Copy` is not satisfied
     assert_copy::<Box<&'a mut isize>>(); //~ ERROR : Copy` is not satisfied
 
-    // borrowed object types are generally ok
+    // borrowed trait objects are generally ok
     assert_copy::<&'a dyn Dummy>();
     assert_copy::<&'a (dyn Dummy + Send)>();
     assert_copy::<&'static (dyn Dummy + Send)>();
 
-    // owned object types are not ok
+    // boxed trait objects are not ok
     assert_copy::<Box<dyn Dummy>>(); //~ ERROR : Copy` is not satisfied
     assert_copy::<Box<dyn Dummy + Send>>(); //~ ERROR : Copy` is not satisfied
 
-    // mutable object types are not ok
-    assert_copy::<&'a mut (dyn Dummy + Send)>();  //~ ERROR : Copy` is not satisfied
+    // mutable references to trait objects are not ok
+    assert_copy::<&'a mut (dyn Dummy + Send)>(); //~ ERROR : Copy` is not satisfied
 
     // raw ptrs are ok
     assert_copy::<*const isize>();
@@ -55,7 +55,7 @@ fn test<'a,T,U:Copy>(_: &'a isize) {
     assert_copy::<()>();
 
     // tuples are ok
-    assert_copy::<(isize,isize)>();
+    assert_copy::<(isize, isize)>();
 
     // structs of POD are ok
     assert_copy::<MyStruct>();
@@ -64,8 +64,7 @@ fn test<'a,T,U:Copy>(_: &'a isize) {
     assert_copy::<MyNoncopyStruct>(); //~ ERROR : Copy` is not satisfied
 
     // ref counted types are not ok
-    assert_copy::<Rc<isize>>();   //~ ERROR : Copy` is not satisfied
+    assert_copy::<Rc<isize>>(); //~ ERROR : Copy` is not satisfied
 }
 
-pub fn main() {
-}
+pub fn main() {}
diff --git a/tests/ui/kindck/kindck-copy.stderr b/tests/ui/kindck/kindck-copy.stderr
index f5623ddd4f79..01b4a5a64647 100644
--- a/tests/ui/kindck/kindck-copy.stderr
+++ b/tests/ui/kindck/kindck-copy.stderr
@@ -5,10 +5,10 @@ LL |     assert_copy::<&'static mut isize>();
    |                   ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'static mut isize`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 help: consider removing the leading `&`-reference
    |
 LL -     assert_copy::<&'static mut isize>();
@@ -22,10 +22,10 @@ LL |     assert_copy::<&'a mut isize>();
    |                   ^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut isize`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 help: consider removing the leading `&`-reference
    |
 LL -     assert_copy::<&'a mut isize>();
@@ -39,10 +39,10 @@ LL |     assert_copy::<Box<isize>>();
    |                   ^^^^^^^^^^ the trait `Copy` is not implemented for `Box<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:32:19
@@ -51,22 +51,22 @@ LL |     assert_copy::<String>();
    |                   ^^^^^^ the trait `Copy` is not implemented for `String`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Vec<isize>: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:33:19
    |
-LL |     assert_copy::<Vec<isize> >();
+LL |     assert_copy::<Vec<isize>>();
    |                   ^^^^^^^^^^ the trait `Copy` is not implemented for `Vec<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<&'a mut isize>: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:34:19
@@ -75,10 +75,10 @@ LL |     assert_copy::<Box<&'a mut isize>>();
    |                   ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<&'a mut isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<dyn Dummy>: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:42:19
@@ -87,10 +87,10 @@ LL |     assert_copy::<Box<dyn Dummy>>();
    |                   ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<dyn Dummy>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<dyn Dummy + Send>: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:43:19
@@ -99,10 +99,10 @@ LL |     assert_copy::<Box<dyn Dummy + Send>>();
    |                   ^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<dyn Dummy + Send>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `&'a mut (dyn Dummy + Send + 'a): Copy` is not satisfied
   --> $DIR/kindck-copy.rs:46:19
@@ -111,10 +111,10 @@ LL |     assert_copy::<&'a mut (dyn Dummy + Send)>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut (dyn Dummy + Send + 'a)`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `MyNoncopyStruct: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:64:19
@@ -128,10 +128,10 @@ help: the trait `Copy` is not implemented for `MyNoncopyStruct`
 LL | struct MyNoncopyStruct {
    | ^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Rc<isize>: Copy` is not satisfied
   --> $DIR/kindck-copy.rs:67:19
@@ -140,10 +140,10 @@ LL |     assert_copy::<Rc<isize>>();
    |                   ^^^^^^^^^ the trait `Copy` is not implemented for `Rc<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:18
+  --> $DIR/kindck-copy.rs:5:19
    |
-LL | fn assert_copy<T:Copy>() { }
-   |                  ^^^^ required by this bound in `assert_copy`
+LL | fn assert_copy<T: Copy>() {}
+   |                   ^^^^ required by this bound in `assert_copy`
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/kindck/kindck-impl-type-params-2.rs b/tests/ui/kindck/kindck-impl-type-params-2.rs
deleted file mode 100644
index 8b0771985dc3..000000000000
--- a/tests/ui/kindck/kindck-impl-type-params-2.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-trait Foo {
-}
-
-
-
-impl<T:Copy> Foo for T {
-}
-
-fn take_param<T:Foo>(foo: &T) { }
-
-fn main() {
-    let x: Box<_> = Box::new(3);
-    take_param(&x);
-    //~^ ERROR the trait bound `Box<{integer}>: Foo` is not satisfied
-}
diff --git a/tests/ui/kindck/kindck-impl-type-params-2.stderr b/tests/ui/kindck/kindck-impl-type-params-2.stderr
deleted file mode 100644
index 38dc94f9104d..000000000000
--- a/tests/ui/kindck/kindck-impl-type-params-2.stderr
+++ /dev/null
@@ -1,24 +0,0 @@
-error[E0277]: the trait bound `Box<{integer}>: Foo` is not satisfied
-  --> $DIR/kindck-impl-type-params-2.rs:13:16
-   |
-LL |     take_param(&x);
-   |     ---------- ^^ the trait `Copy` is not implemented for `Box<{integer}>`
-   |     |
-   |     required by a bound introduced by this call
-   |
-note: required for `Box<{integer}>` to implement `Foo`
-  --> $DIR/kindck-impl-type-params-2.rs:6:14
-   |
-LL | impl<T:Copy> Foo for T {
-   |        ----  ^^^     ^
-   |        |
-   |        unsatisfied trait bound introduced here
-note: required by a bound in `take_param`
-  --> $DIR/kindck-impl-type-params-2.rs:9:17
-   |
-LL | fn take_param<T:Foo>(foo: &T) { }
-   |                 ^^^ required by this bound in `take_param`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-impl-type-params.rs b/tests/ui/kindck/kindck-impl-type-params.rs
index 707c5dbaec30..ba54bc313c08 100644
--- a/tests/ui/kindck/kindck-impl-type-params.rs
+++ b/tests/ui/kindck/kindck-impl-type-params.rs
@@ -6,7 +6,9 @@
 struct S<T>(marker::PhantomData<T>);
 
 trait Gettable<T> {
-    fn get(&self) -> T { panic!() }
+    fn get(&self) -> T {
+        panic!()
+    }
 }
 
 impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
@@ -45,4 +47,4 @@ fn foo3<'a>() {
     //~^ ERROR : Copy` is not satisfied
 }
 
-fn main() { }
+fn main() {}
diff --git a/tests/ui/kindck/kindck-impl-type-params.stderr b/tests/ui/kindck/kindck-impl-type-params.stderr
index 0c9ab13f4774..b2e52ae57ea4 100644
--- a/tests/ui/kindck/kindck-impl-type-params.stderr
+++ b/tests/ui/kindck/kindck-impl-type-params.stderr
@@ -1,11 +1,11 @@
 error[E0277]: `T` cannot be sent between threads safely
-  --> $DIR/kindck-impl-type-params.rs:16:13
+  --> $DIR/kindck-impl-type-params.rs:18:13
    |
 LL |     let a = &t as &dyn Gettable<T>;
    |             ^^ `T` cannot be sent between threads safely
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |         ----                   ^^^^^^^^^^^     ^^^^
@@ -18,13 +18,13 @@ LL | fn f<T: std::marker::Send>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:16:13
+  --> $DIR/kindck-impl-type-params.rs:18:13
    |
 LL |     let a = &t as &dyn Gettable<T>;
    |             ^^ the trait `Copy` is not implemented for `T`
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -37,13 +37,13 @@ LL | fn f<T: std::marker::Copy>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: `T` cannot be sent between threads safely
-  --> $DIR/kindck-impl-type-params.rs:23:31
+  --> $DIR/kindck-impl-type-params.rs:25:31
    |
 LL |     let a: &dyn Gettable<T> = &t;
    |                               ^^ `T` cannot be sent between threads safely
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |         ----                   ^^^^^^^^^^^     ^^^^
@@ -56,13 +56,13 @@ LL | fn g<T: std::marker::Send>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:23:31
+  --> $DIR/kindck-impl-type-params.rs:25:31
    |
 LL |     let a: &dyn Gettable<T> = &t;
    |                               ^^ the trait `Copy` is not implemented for `T`
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -75,18 +75,18 @@ LL | fn g<T: std::marker::Copy>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:36:13
+  --> $DIR/kindck-impl-type-params.rs:38:13
    |
 LL |     let a = t as Box<dyn Gettable<String>>;
    |             ^ the trait `Copy` is not implemented for `String`
    |
 help: the trait `Gettable<T>` is implemented for `S<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:1
+  --> $DIR/kindck-impl-type-params.rs:14:1
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required for `S<String>` to implement `Gettable<String>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -95,18 +95,18 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    = note: required for the cast from `Box<S<String>>` to `Box<dyn Gettable<String>>`
 
 error[E0277]: the trait bound `Foo: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:44:37
+  --> $DIR/kindck-impl-type-params.rs:46:37
    |
 LL |     let a: Box<dyn Gettable<Foo>> = t;
    |                                     ^ the trait `Copy` is not implemented for `Foo`
    |
 help: the trait `Gettable<T>` is implemented for `S<T>`
-  --> $DIR/kindck-impl-type-params.rs:12:1
+  --> $DIR/kindck-impl-type-params.rs:14:1
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required for `S<Foo>` to implement `Gettable<Foo>`
-  --> $DIR/kindck-impl-type-params.rs:12:32
+  --> $DIR/kindck-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -120,7 +120,7 @@ LL |     struct Foo; // does not impl Copy
    |
 
 error: lifetime may not live long enough
-  --> $DIR/kindck-impl-type-params.rs:30:13
+  --> $DIR/kindck-impl-type-params.rs:32:13
    |
 LL | fn foo<'a>() {
    |        -- lifetime `'a` defined here
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.curr.stderr b/tests/ui/kindck/kindck-inherited-copy-bound.curr.stderr
deleted file mode 100644
index 95048c4454b3..000000000000
--- a/tests/ui/kindck/kindck-inherited-copy-bound.curr.stderr
+++ /dev/null
@@ -1,56 +0,0 @@
-error[E0277]: the trait bound `Box<{integer}>: Foo` is not satisfied
-  --> $DIR/kindck-inherited-copy-bound.rs:21:16
-   |
-LL |     take_param(&x);
-   |     ---------- ^^ the trait `Copy` is not implemented for `Box<{integer}>`
-   |     |
-   |     required by a bound introduced by this call
-   |
-note: required for `Box<{integer}>` to implement `Foo`
-  --> $DIR/kindck-inherited-copy-bound.rs:14:14
-   |
-LL | impl<T:Copy> Foo for T {
-   |        ----  ^^^     ^
-   |        |
-   |        unsatisfied trait bound introduced here
-note: required by a bound in `take_param`
-  --> $DIR/kindck-inherited-copy-bound.rs:17:17
-   |
-LL | fn take_param<T:Foo>(foo: &T) { }
-   |                 ^^^ required by this bound in `take_param`
-
-error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/kindck-inherited-copy-bound.rs:28:19
-   |
-LL |     let z = &x as &dyn Foo;
-   |                   ^^^^^^^^ `Foo` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/kindck-inherited-copy-bound.rs:10:13
-   |
-LL | trait Foo : Copy {
-   |       ---   ^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-
-error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/kindck-inherited-copy-bound.rs:28:13
-   |
-LL |     let z = &x as &dyn Foo;
-   |             ^^ `Foo` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/kindck-inherited-copy-bound.rs:10:13
-   |
-LL | trait Foo : Copy {
-   |       ---   ^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = note: required for the cast from `&Box<{integer}>` to `&dyn Foo`
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0038, E0277.
-For more information about an error, try `rustc --explain E0038`.
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.rs b/tests/ui/kindck/kindck-inherited-copy-bound.rs
index 92c2b273c2c1..dd9fea3dcde3 100644
--- a/tests/ui/kindck/kindck-inherited-copy-bound.rs
+++ b/tests/ui/kindck/kindck-inherited-copy-bound.rs
@@ -1,16 +1,14 @@
 // Test that Copy bounds inherited by trait are checked.
 
-
 use std::any::Any;
 
-trait Foo : Copy {
+trait Foo: Copy {
     fn foo(&self) {}
 }
 
-impl<T:Copy> Foo for T {
-}
+impl<T: Copy> Foo for T {}
 
-fn take_param<T:Foo>(foo: &T) { }
+fn take_param<T: Foo>(foo: &T) {}
 
 fn a() {
     let x: Box<_> = Box::new(3);
@@ -24,4 +22,4 @@ fn b() {
     //~^ ERROR E0038
 }
 
-fn main() { }
+fn main() {}
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.stderr b/tests/ui/kindck/kindck-inherited-copy-bound.stderr
index c15aabacddd1..d6c9cab5b57a 100644
--- a/tests/ui/kindck/kindck-inherited-copy-bound.stderr
+++ b/tests/ui/kindck/kindck-inherited-copy-bound.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `Box<{integer}>: Foo` is not satisfied
-  --> $DIR/kindck-inherited-copy-bound.rs:17:16
+  --> $DIR/kindck-inherited-copy-bound.rs:15:16
    |
 LL |     take_param(&x);
    |     ---------- ^^ the trait `Copy` is not implemented for `Box<{integer}>`
@@ -7,30 +7,30 @@ LL |     take_param(&x);
    |     required by a bound introduced by this call
    |
 note: required for `Box<{integer}>` to implement `Foo`
-  --> $DIR/kindck-inherited-copy-bound.rs:10:14
+  --> $DIR/kindck-inherited-copy-bound.rs:9:15
    |
-LL | impl<T:Copy> Foo for T {
-   |        ----  ^^^     ^
-   |        |
-   |        unsatisfied trait bound introduced here
+LL | impl<T: Copy> Foo for T {}
+   |         ----  ^^^     ^
+   |         |
+   |         unsatisfied trait bound introduced here
 note: required by a bound in `take_param`
-  --> $DIR/kindck-inherited-copy-bound.rs:13:17
+  --> $DIR/kindck-inherited-copy-bound.rs:11:18
    |
-LL | fn take_param<T:Foo>(foo: &T) { }
-   |                 ^^^ required by this bound in `take_param`
+LL | fn take_param<T: Foo>(foo: &T) {}
+   |                  ^^^ required by this bound in `take_param`
 
 error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/kindck-inherited-copy-bound.rs:23:24
+  --> $DIR/kindck-inherited-copy-bound.rs:21:24
    |
 LL |     let z = &x as &dyn Foo;
    |                        ^^^ `Foo` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/kindck-inherited-copy-bound.rs:6:13
+  --> $DIR/kindck-inherited-copy-bound.rs:5:12
    |
-LL | trait Foo : Copy {
-   |       ---   ^^^^ ...because it requires `Self: Sized`
+LL | trait Foo: Copy {
+   |       ---  ^^^^ ...because it requires `Self: Sized`
    |       |
    |       this trait is not dyn compatible...
 
diff --git a/tests/ui/kindck/kindck-nonsendable-1.rs b/tests/ui/kindck/kindck-nonsendable-1.rs
index b32fd78624b8..78ef834afabd 100644
--- a/tests/ui/kindck/kindck-nonsendable-1.rs
+++ b/tests/ui/kindck/kindck-nonsendable-1.rs
@@ -2,10 +2,10 @@
 
 fn foo(_x: Rc<usize>) {}
 
-fn bar<F:FnOnce() + Send>(_: F) { }
+fn bar<F: FnOnce() + Send>(_: F) {}
 
 fn main() {
     let x = Rc::new(3);
-    bar(move|| foo(x));
+    bar(move || foo(x));
     //~^ ERROR `Rc<usize>` cannot be sent between threads safely
 }
diff --git a/tests/ui/kindck/kindck-nonsendable-1.stderr b/tests/ui/kindck/kindck-nonsendable-1.stderr
index 8bb784d1d496..4bf8e17e3ed9 100644
--- a/tests/ui/kindck/kindck-nonsendable-1.stderr
+++ b/tests/ui/kindck/kindck-nonsendable-1.stderr
@@ -1,24 +1,24 @@
 error[E0277]: `Rc<usize>` cannot be sent between threads safely
   --> $DIR/kindck-nonsendable-1.rs:9:9
    |
-LL |     bar(move|| foo(x));
-   |     --- ------^^^^^^^
+LL |     bar(move || foo(x));
+   |     --- -------^^^^^^^
    |     |   |
    |     |   `Rc<usize>` cannot be sent between threads safely
-   |     |   within this `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:15}`
+   |     |   within this `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:16}`
    |     required by a bound introduced by this call
    |
-   = help: within `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:15}`, the trait `Send` is not implemented for `Rc<usize>`
+   = help: within `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:16}`, the trait `Send` is not implemented for `Rc<usize>`
 note: required because it's used within this closure
   --> $DIR/kindck-nonsendable-1.rs:9:9
    |
-LL |     bar(move|| foo(x));
-   |         ^^^^^^
+LL |     bar(move || foo(x));
+   |         ^^^^^^^
 note: required by a bound in `bar`
-  --> $DIR/kindck-nonsendable-1.rs:5:21
+  --> $DIR/kindck-nonsendable-1.rs:5:22
    |
-LL | fn bar<F:FnOnce() + Send>(_: F) { }
-   |                     ^^^^ required by this bound in `bar`
+LL | fn bar<F: FnOnce() + Send>(_: F) {}
+   |                      ^^^^ required by this bound in `bar`
 
 error: aborting due to 1 previous error
 

From 7d82c5dab3760142380ef4477e9885673a45f7b0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 17 Mar 2026 22:53:30 +0100
Subject: [PATCH 0602/1059] Fix invalid add of duplicated call locations for
 the rustdoc scraped examples feature

---
 src/librustdoc/scrape_examples.rs | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index cc78dec4eafa..63b869c0f2d5 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -3,7 +3,7 @@
 use std::fs;
 use std::path::PathBuf;
 
-use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::DiagCtxtHandle;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
@@ -15,7 +15,7 @@
 use rustc_session::getopts;
 use rustc_span::def_id::{CrateNum, DefPathHash, LOCAL_CRATE};
 use rustc_span::edition::Edition;
-use rustc_span::{BytePos, FileName, SourceFile};
+use rustc_span::{BytePos, FileName, SourceFile, Span};
 use tracing::{debug, trace, warn};
 
 use crate::html::render::Context;
@@ -114,6 +114,7 @@ struct FindCalls<'a, 'tcx> {
     target_crates: Vec<CrateNum>,
     calls: &'a mut AllCallLocations,
     bin_crate: bool,
+    call_ident_spans: FxHashSet<Span>,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for FindCalls<'a, 'tcx>
@@ -165,6 +166,10 @@ fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
             }
         };
 
+        if !self.call_ident_spans.insert(ident_span) {
+            return;
+        }
+
         // If this span comes from a macro expansion, then the source code may not actually show
         // a use of the given item, so it would be a poor example. Hence, we skip all uses in
         // macros.
@@ -300,7 +305,13 @@ pub(crate) fn run(
 
         // Run call-finder on all items
         let mut calls = FxIndexMap::default();
-        let mut finder = FindCalls { calls: &mut calls, cx, target_crates, bin_crate };
+        let mut finder = FindCalls {
+            calls: &mut calls,
+            cx,
+            target_crates,
+            bin_crate,
+            call_ident_spans: FxHashSet::default(),
+        };
         tcx.hir_visit_all_item_likes_in_crate(&mut finder);
 
         // The visitor might have found a type error, which we need to

From 62b9fa15e72e613c1e318e895b84bf593768f9db Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 22:02:05 +0000
Subject: [PATCH 0603/1059] move tests from `ui/kindck` to `ui/traits`

---
 tests/ui/README.md                            |  4 --
 .../basic-copyable-types.rs}                  |  0
 .../basic-copyable-types.stderr}              | 46 +++++++++----------
 .../closure-rc-not-send.rs}                   |  0
 .../closure-rc-not-send.stderr}               | 10 ++--
 .../copy-bounds-impl-type-params.rs}          |  0
 .../copy-bounds-impl-type-params.stderr}      | 30 ++++++------
 .../inherited-copy-bound.rs}                  |  0
 .../inherited-copy-bound.stderr}              | 10 ++--
 .../send-trait-objects-basic.rs               |  0
 .../send-trait-objects-basic.stderr           |  0
 11 files changed, 48 insertions(+), 52 deletions(-)
 rename tests/ui/{kindck/kindck-copy.rs => traits/basic-copyable-types.rs} (100%)
 rename tests/ui/{kindck/kindck-copy.stderr => traits/basic-copyable-types.stderr} (83%)
 rename tests/ui/{kindck/kindck-nonsendable-1.rs => traits/closure-rc-not-send.rs} (100%)
 rename tests/ui/{kindck/kindck-nonsendable-1.stderr => traits/closure-rc-not-send.stderr} (66%)
 rename tests/ui/{kindck/kindck-impl-type-params.rs => traits/copy-bounds-impl-type-params.rs} (100%)
 rename tests/ui/{kindck/kindck-impl-type-params.stderr => traits/copy-bounds-impl-type-params.stderr} (86%)
 rename tests/ui/{kindck/kindck-inherited-copy-bound.rs => traits/inherited-copy-bound.rs} (100%)
 rename tests/ui/{kindck/kindck-inherited-copy-bound.stderr => traits/inherited-copy-bound.stderr} (83%)
 rename tests/ui/{kindck => traits}/send-trait-objects-basic.rs (100%)
 rename tests/ui/{kindck => traits}/send-trait-objects-basic.stderr (100%)

diff --git a/tests/ui/README.md b/tests/ui/README.md
index 848df58f2714..845f02918de9 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -784,10 +784,6 @@ These tests revolve around the `--json` compiler flag. See [JSON Output](https:/
 
 Tests exercising keywords, such as attempting to use them as identifiers when not contextual keywords.
 
-## `tests/ui/kindck/`
-
-**FIXME**: `kindck` is no longer a thing, these tests probably need to be audited and rehomed.
-
 ## `tests/ui/label/`
 
 Exercises block and loop `'label`s.
diff --git a/tests/ui/kindck/kindck-copy.rs b/tests/ui/traits/basic-copyable-types.rs
similarity index 100%
rename from tests/ui/kindck/kindck-copy.rs
rename to tests/ui/traits/basic-copyable-types.rs
diff --git a/tests/ui/kindck/kindck-copy.stderr b/tests/ui/traits/basic-copyable-types.stderr
similarity index 83%
rename from tests/ui/kindck/kindck-copy.stderr
rename to tests/ui/traits/basic-copyable-types.stderr
index 01b4a5a64647..b4fa95753335 100644
--- a/tests/ui/kindck/kindck-copy.stderr
+++ b/tests/ui/traits/basic-copyable-types.stderr
@@ -1,11 +1,11 @@
 error[E0277]: the trait bound `&'static mut isize: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:27:19
+  --> $DIR/basic-copyable-types.rs:27:19
    |
 LL |     assert_copy::<&'static mut isize>();
    |                   ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'static mut isize`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
@@ -16,13 +16,13 @@ LL +     assert_copy::<isize>();
    |
 
 error[E0277]: the trait bound `&'a mut isize: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:28:19
+  --> $DIR/basic-copyable-types.rs:28:19
    |
 LL |     assert_copy::<&'a mut isize>();
    |                   ^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut isize`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
@@ -33,114 +33,114 @@ LL +     assert_copy::<isize>();
    |
 
 error[E0277]: the trait bound `Box<isize>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:31:19
+  --> $DIR/basic-copyable-types.rs:31:19
    |
 LL |     assert_copy::<Box<isize>>();
    |                   ^^^^^^^^^^ the trait `Copy` is not implemented for `Box<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:32:19
+  --> $DIR/basic-copyable-types.rs:32:19
    |
 LL |     assert_copy::<String>();
    |                   ^^^^^^ the trait `Copy` is not implemented for `String`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Vec<isize>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:33:19
+  --> $DIR/basic-copyable-types.rs:33:19
    |
 LL |     assert_copy::<Vec<isize>>();
    |                   ^^^^^^^^^^ the trait `Copy` is not implemented for `Vec<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<&'a mut isize>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:34:19
+  --> $DIR/basic-copyable-types.rs:34:19
    |
 LL |     assert_copy::<Box<&'a mut isize>>();
    |                   ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<&'a mut isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<dyn Dummy>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:42:19
+  --> $DIR/basic-copyable-types.rs:42:19
    |
 LL |     assert_copy::<Box<dyn Dummy>>();
    |                   ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<dyn Dummy>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Box<dyn Dummy + Send>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:43:19
+  --> $DIR/basic-copyable-types.rs:43:19
    |
 LL |     assert_copy::<Box<dyn Dummy + Send>>();
    |                   ^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Box<dyn Dummy + Send>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `&'a mut (dyn Dummy + Send + 'a): Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:46:19
+  --> $DIR/basic-copyable-types.rs:46:19
    |
 LL |     assert_copy::<&'a mut (dyn Dummy + Send)>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut (dyn Dummy + Send + 'a)`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `MyNoncopyStruct: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:64:19
+  --> $DIR/basic-copyable-types.rs:64:19
    |
 LL |     assert_copy::<MyNoncopyStruct>();
    |                   ^^^^^^^^^^^^^^^ unsatisfied trait bound
    |
 help: the trait `Copy` is not implemented for `MyNoncopyStruct`
-  --> $DIR/kindck-copy.rs:15:1
+  --> $DIR/basic-copyable-types.rs:15:1
    |
 LL | struct MyNoncopyStruct {
    | ^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
 
 error[E0277]: the trait bound `Rc<isize>: Copy` is not satisfied
-  --> $DIR/kindck-copy.rs:67:19
+  --> $DIR/basic-copyable-types.rs:67:19
    |
 LL |     assert_copy::<Rc<isize>>();
    |                   ^^^^^^^^^ the trait `Copy` is not implemented for `Rc<isize>`
    |
 note: required by a bound in `assert_copy`
-  --> $DIR/kindck-copy.rs:5:19
+  --> $DIR/basic-copyable-types.rs:5:19
    |
 LL | fn assert_copy<T: Copy>() {}
    |                   ^^^^ required by this bound in `assert_copy`
diff --git a/tests/ui/kindck/kindck-nonsendable-1.rs b/tests/ui/traits/closure-rc-not-send.rs
similarity index 100%
rename from tests/ui/kindck/kindck-nonsendable-1.rs
rename to tests/ui/traits/closure-rc-not-send.rs
diff --git a/tests/ui/kindck/kindck-nonsendable-1.stderr b/tests/ui/traits/closure-rc-not-send.stderr
similarity index 66%
rename from tests/ui/kindck/kindck-nonsendable-1.stderr
rename to tests/ui/traits/closure-rc-not-send.stderr
index 4bf8e17e3ed9..5e73f13648d5 100644
--- a/tests/ui/kindck/kindck-nonsendable-1.stderr
+++ b/tests/ui/traits/closure-rc-not-send.stderr
@@ -1,21 +1,21 @@
 error[E0277]: `Rc<usize>` cannot be sent between threads safely
-  --> $DIR/kindck-nonsendable-1.rs:9:9
+  --> $DIR/closure-rc-not-send.rs:9:9
    |
 LL |     bar(move || foo(x));
    |     --- -------^^^^^^^
    |     |   |
    |     |   `Rc<usize>` cannot be sent between threads safely
-   |     |   within this `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:16}`
+   |     |   within this `{closure@$DIR/closure-rc-not-send.rs:9:9: 9:16}`
    |     required by a bound introduced by this call
    |
-   = help: within `{closure@$DIR/kindck-nonsendable-1.rs:9:9: 9:16}`, the trait `Send` is not implemented for `Rc<usize>`
+   = help: within `{closure@$DIR/closure-rc-not-send.rs:9:9: 9:16}`, the trait `Send` is not implemented for `Rc<usize>`
 note: required because it's used within this closure
-  --> $DIR/kindck-nonsendable-1.rs:9:9
+  --> $DIR/closure-rc-not-send.rs:9:9
    |
 LL |     bar(move || foo(x));
    |         ^^^^^^^
 note: required by a bound in `bar`
-  --> $DIR/kindck-nonsendable-1.rs:5:22
+  --> $DIR/closure-rc-not-send.rs:5:22
    |
 LL | fn bar<F: FnOnce() + Send>(_: F) {}
    |                      ^^^^ required by this bound in `bar`
diff --git a/tests/ui/kindck/kindck-impl-type-params.rs b/tests/ui/traits/copy-bounds-impl-type-params.rs
similarity index 100%
rename from tests/ui/kindck/kindck-impl-type-params.rs
rename to tests/ui/traits/copy-bounds-impl-type-params.rs
diff --git a/tests/ui/kindck/kindck-impl-type-params.stderr b/tests/ui/traits/copy-bounds-impl-type-params.stderr
similarity index 86%
rename from tests/ui/kindck/kindck-impl-type-params.stderr
rename to tests/ui/traits/copy-bounds-impl-type-params.stderr
index b2e52ae57ea4..08fde8fb5df3 100644
--- a/tests/ui/kindck/kindck-impl-type-params.stderr
+++ b/tests/ui/traits/copy-bounds-impl-type-params.stderr
@@ -1,11 +1,11 @@
 error[E0277]: `T` cannot be sent between threads safely
-  --> $DIR/kindck-impl-type-params.rs:18:13
+  --> $DIR/copy-bounds-impl-type-params.rs:18:13
    |
 LL |     let a = &t as &dyn Gettable<T>;
    |             ^^ `T` cannot be sent between threads safely
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |         ----                   ^^^^^^^^^^^     ^^^^
@@ -18,13 +18,13 @@ LL | fn f<T: std::marker::Send>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:18:13
+  --> $DIR/copy-bounds-impl-type-params.rs:18:13
    |
 LL |     let a = &t as &dyn Gettable<T>;
    |             ^^ the trait `Copy` is not implemented for `T`
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -37,13 +37,13 @@ LL | fn f<T: std::marker::Copy>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: `T` cannot be sent between threads safely
-  --> $DIR/kindck-impl-type-params.rs:25:31
+  --> $DIR/copy-bounds-impl-type-params.rs:25:31
    |
 LL |     let a: &dyn Gettable<T> = &t;
    |                               ^^ `T` cannot be sent between threads safely
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |         ----                   ^^^^^^^^^^^     ^^^^
@@ -56,13 +56,13 @@ LL | fn g<T: std::marker::Send>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:25:31
+  --> $DIR/copy-bounds-impl-type-params.rs:25:31
    |
 LL |     let a: &dyn Gettable<T> = &t;
    |                               ^^ the trait `Copy` is not implemented for `T`
    |
 note: required for `S<T>` to implement `Gettable<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -75,18 +75,18 @@ LL | fn g<T: std::marker::Copy>(val: T) {
    |       +++++++++++++++++++
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:38:13
+  --> $DIR/copy-bounds-impl-type-params.rs:38:13
    |
 LL |     let a = t as Box<dyn Gettable<String>>;
    |             ^ the trait `Copy` is not implemented for `String`
    |
 help: the trait `Gettable<T>` is implemented for `S<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:1
+  --> $DIR/copy-bounds-impl-type-params.rs:14:1
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required for `S<String>` to implement `Gettable<String>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -95,18 +95,18 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    = note: required for the cast from `Box<S<String>>` to `Box<dyn Gettable<String>>`
 
 error[E0277]: the trait bound `Foo: Copy` is not satisfied
-  --> $DIR/kindck-impl-type-params.rs:46:37
+  --> $DIR/copy-bounds-impl-type-params.rs:46:37
    |
 LL |     let a: Box<dyn Gettable<Foo>> = t;
    |                                     ^ the trait `Copy` is not implemented for `Foo`
    |
 help: the trait `Gettable<T>` is implemented for `S<T>`
-  --> $DIR/kindck-impl-type-params.rs:14:1
+  --> $DIR/copy-bounds-impl-type-params.rs:14:1
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required for `S<Foo>` to implement `Gettable<Foo>`
-  --> $DIR/kindck-impl-type-params.rs:14:32
+  --> $DIR/copy-bounds-impl-type-params.rs:14:32
    |
 LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
    |                ----            ^^^^^^^^^^^     ^^^^
@@ -120,7 +120,7 @@ LL |     struct Foo; // does not impl Copy
    |
 
 error: lifetime may not live long enough
-  --> $DIR/kindck-impl-type-params.rs:32:13
+  --> $DIR/copy-bounds-impl-type-params.rs:32:13
    |
 LL | fn foo<'a>() {
    |        -- lifetime `'a` defined here
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.rs b/tests/ui/traits/inherited-copy-bound.rs
similarity index 100%
rename from tests/ui/kindck/kindck-inherited-copy-bound.rs
rename to tests/ui/traits/inherited-copy-bound.rs
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.stderr b/tests/ui/traits/inherited-copy-bound.stderr
similarity index 83%
rename from tests/ui/kindck/kindck-inherited-copy-bound.stderr
rename to tests/ui/traits/inherited-copy-bound.stderr
index d6c9cab5b57a..c251d5922446 100644
--- a/tests/ui/kindck/kindck-inherited-copy-bound.stderr
+++ b/tests/ui/traits/inherited-copy-bound.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `Box<{integer}>: Foo` is not satisfied
-  --> $DIR/kindck-inherited-copy-bound.rs:15:16
+  --> $DIR/inherited-copy-bound.rs:15:16
    |
 LL |     take_param(&x);
    |     ---------- ^^ the trait `Copy` is not implemented for `Box<{integer}>`
@@ -7,27 +7,27 @@ LL |     take_param(&x);
    |     required by a bound introduced by this call
    |
 note: required for `Box<{integer}>` to implement `Foo`
-  --> $DIR/kindck-inherited-copy-bound.rs:9:15
+  --> $DIR/inherited-copy-bound.rs:9:15
    |
 LL | impl<T: Copy> Foo for T {}
    |         ----  ^^^     ^
    |         |
    |         unsatisfied trait bound introduced here
 note: required by a bound in `take_param`
-  --> $DIR/kindck-inherited-copy-bound.rs:11:18
+  --> $DIR/inherited-copy-bound.rs:11:18
    |
 LL | fn take_param<T: Foo>(foo: &T) {}
    |                  ^^^ required by this bound in `take_param`
 
 error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/kindck-inherited-copy-bound.rs:21:24
+  --> $DIR/inherited-copy-bound.rs:21:24
    |
 LL |     let z = &x as &dyn Foo;
    |                        ^^^ `Foo` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/kindck-inherited-copy-bound.rs:5:12
+  --> $DIR/inherited-copy-bound.rs:5:12
    |
 LL | trait Foo: Copy {
    |       ---  ^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/kindck/send-trait-objects-basic.rs b/tests/ui/traits/send-trait-objects-basic.rs
similarity index 100%
rename from tests/ui/kindck/send-trait-objects-basic.rs
rename to tests/ui/traits/send-trait-objects-basic.rs
diff --git a/tests/ui/kindck/send-trait-objects-basic.stderr b/tests/ui/traits/send-trait-objects-basic.stderr
similarity index 100%
rename from tests/ui/kindck/send-trait-objects-basic.stderr
rename to tests/ui/traits/send-trait-objects-basic.stderr

From eda328c6cfce47bb99d2daba946bf938dad8f78e Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 17 Mar 2026 22:08:51 +0000
Subject: [PATCH 0604/1059] delete incorrect test

---
 .../kindck-implicit-close-over-mut-var.rs     | 49 -------------------
 1 file changed, 49 deletions(-)
 delete mode 100644 tests/ui/borrowck/kindck-implicit-close-over-mut-var.rs

diff --git a/tests/ui/borrowck/kindck-implicit-close-over-mut-var.rs b/tests/ui/borrowck/kindck-implicit-close-over-mut-var.rs
deleted file mode 100644
index 22ed8bd3beef..000000000000
--- a/tests/ui/borrowck/kindck-implicit-close-over-mut-var.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-#![allow(dead_code)]
-use std::thread;
-
-fn user(_i: isize) {}
-
-fn foo() {
-    // Here, i is *copied* into the proc (heap closure).
-    // Requires allocation.  The proc's copy is not mutable.
-    let mut i = 0;
-    let t = thread::spawn(move|| {
-        user(i);
-        println!("spawned {}", i)
-    });
-    i += 1;
-    println!("original {}", i);
-    t.join();
-}
-
-fn bar() {
-    // Here, the original i has not been moved, only copied, so is still
-    // mutable outside of the proc.
-    let mut i = 0;
-    while i < 10 {
-        let t = thread::spawn(move|| {
-            user(i);
-        });
-        i += 1;
-        t.join();
-    }
-}
-
-fn car() {
-    // Here, i must be shadowed in the proc to be mutable.
-    let mut i = 0;
-    while i < 10 {
-        let t = thread::spawn(move|| {
-            let mut i = i;
-            i += 1;
-            user(i);
-        });
-        i += 1;
-        t.join();
-    }
-}
-
-pub fn main() {}

From a9838dd1ea9252723ed3a450c8e5b5c65672e477 Mon Sep 17 00:00:00 2001
From: Aryan Dubey <aryandubey@umass.edu>
Date: Tue, 17 Mar 2026 18:16:09 -0400
Subject: [PATCH 0605/1059] Moved issue-23981 to tests/ui/macros

---
 tests/ui/{issues/issue-23891.rs => macros/macro-in-or-pattern.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/issue-23891.rs => macros/macro-in-or-pattern.rs} (100%)

diff --git a/tests/ui/issues/issue-23891.rs b/tests/ui/macros/macro-in-or-pattern.rs
similarity index 100%
rename from tests/ui/issues/issue-23891.rs
rename to tests/ui/macros/macro-in-or-pattern.rs

From fb885759e00987f4dbc9fa77edce3bfb963264aa Mon Sep 17 00:00:00 2001
From: Aryan Dubey <aryandubey@umass.edu>
Date: Tue, 17 Mar 2026 18:24:54 -0400
Subject: [PATCH 0606/1059] Added test description and a link to github page
 for the relevant issue to the test

---
 tests/ui/macros/macro-in-or-pattern.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/ui/macros/macro-in-or-pattern.rs b/tests/ui/macros/macro-in-or-pattern.rs
index 131139470f9f..c1dcd6efeaa4 100644
--- a/tests/ui/macros/macro-in-or-pattern.rs
+++ b/tests/ui/macros/macro-in-or-pattern.rs
@@ -1,3 +1,6 @@
+// Regression test for https://github.com/rust-lang/rust/issues/23891
+// Tests that a macro expanding to a pattern works correctly inside of or patterns
+
 //@ run-pass
 macro_rules! id {
     ($s: pat) => ($s);

From fbd3b6d9443a4da80db1c18277e4ce61d1da662b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 17 Mar 2026 13:39:29 +1100
Subject: [PATCH 0607/1059] Move query-stack-frame spans into `QueryStackFrame`

Code that previously used `QueryStackFrame` now uses `TaggedQueryKey` directly.

Code that previously used `Spanned<QueryStackFrame>` now uses
`QueryStackFrame`, which includes a span.
---
 compiler/rustc_middle/src/query/plumbing.rs   | 11 ++--
 compiler/rustc_middle/src/query/stack.rs      |  6 ++-
 compiler/rustc_query_impl/src/execution.rs    |  6 +--
 .../rustc_query_impl/src/from_cycle_error.rs  | 10 ++--
 compiler/rustc_query_impl/src/job.rs          | 54 ++++++++++---------
 5 files changed, 46 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 17fa9bf085eb..e8e2c8dbd224 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -8,15 +8,14 @@
 use rustc_errors::Diag;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
-use rustc_span::{Span, Spanned};
+use rustc_span::Span;
 pub use sealed::IntoQueryParam;
 
 use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
-use crate::query::stack::QueryStackFrame;
-use crate::query::{QueryCache, QueryJob};
+use crate::query::{QueryCache, QueryJob, QueryStackFrame};
 use crate::ty::TyCtxt;
 
 /// For a particular query, keeps track of "active" keys, i.e. keys whose
@@ -53,10 +52,10 @@ pub enum ActiveKeyStatus<'tcx> {
 #[derive(Debug)]
 pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
-    pub usage: Option<Spanned<QueryStackFrame<'tcx>>>,
+    pub usage: Option<QueryStackFrame<'tcx>>,
 
     /// The span here corresponds to the reason for which this query was required.
-    pub cycle: Vec<Spanned<QueryStackFrame<'tcx>>>,
+    pub cycle: Vec<QueryStackFrame<'tcx>>,
 }
 
 #[derive(Debug)]
@@ -505,7 +504,7 @@ pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
 
         /// Identifies a query by kind and key. This is in contrast to `QueryJobId` which is just a number.
         #[allow(non_camel_case_types)]
-        #[derive(Clone, Debug)]
+        #[derive(Clone, Copy, Debug)]
         pub enum TaggedQueryKey<'tcx> {
             $(
                 $name($name::Key<'tcx>),
diff --git a/compiler/rustc_middle/src/query/stack.rs b/compiler/rustc_middle/src/query/stack.rs
index 6a77ddc1eaa7..9465fc87edf0 100644
--- a/compiler/rustc_middle/src/query/stack.rs
+++ b/compiler/rustc_middle/src/query/stack.rs
@@ -1,10 +1,14 @@
+use rustc_span::Span;
+
 use crate::queries::TaggedQueryKey;
 
 /// Description of a frame in the query stack.
 ///
 /// This is mostly used in case of cycles for error reporting.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct QueryStackFrame<'tcx> {
+    pub span: Span,
+
     /// The query and key of the query method call that this stack frame
     /// corresponds to.
     ///
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 6c91db16967b..aea0bb4d3534 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -9,7 +9,7 @@
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::{
     ActiveKeyStatus, CycleError, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey,
-    QueryLatch, QueryMode, QueryStackFrame, QueryState, QueryVTable,
+    QueryLatch, QueryMode, QueryState, QueryVTable,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
@@ -75,8 +75,8 @@ fn collect_active_query_jobs_inner<'tcx, C>(
             if let ActiveKeyStatus::Started(job) = status {
                 // It's fine to call `create_tagged_key` with the shard locked,
                 // because it's just a `TaggedQueryKey` variant constructor.
-                let frame = QueryStackFrame { tagged_key: (query.create_tagged_key)(*key) };
-                job_map.insert(job.id, QueryJobInfo { frame, job: job.clone() });
+                let tagged_key = (query.create_tagged_key)(*key);
+                job_map.insert(job.id, QueryJobInfo { tagged_key, job: job.clone() });
             }
         }
     };
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/from_cycle_error.rs
index 317b2482c05c..0c6082e65f62 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/from_cycle_error.rs
@@ -76,7 +76,7 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
     let mut item_and_field_ids = Vec::new();
     let mut representable_ids = FxHashSet::default();
     for frame in &cycle_error.cycle {
-        if let TaggedQueryKey::check_representability(def_id) = frame.node.tagged_key
+        if let TaggedQueryKey::check_representability(def_id) = frame.tagged_key
             && tcx.def_kind(def_id) == DefKind::Field
         {
             let field_id: LocalDefId = def_id;
@@ -89,7 +89,7 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
         }
     }
     for frame in &cycle_error.cycle {
-        if let TaggedQueryKey::check_representability_adt_ty(key) = frame.node.tagged_key
+        if let TaggedQueryKey::check_representability_adt_ty(key) = frame.tagged_key
             && let Some(adt) = key.ty_adt_def()
             && let Some(def_id) = adt.did().as_local()
             && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
@@ -134,7 +134,7 @@ fn layout_of<'tcx>(
     let diag = search_for_cycle_permutation(
         &cycle_error.cycle,
         |cycle| {
-            if let TaggedQueryKey::layout_of(key) = cycle[0].node.tagged_key
+            if let TaggedQueryKey::layout_of(key) = cycle[0].tagged_key
                 && let ty::Coroutine(def_id, _) = key.value.kind()
                 && let Some(def_id) = def_id.as_local()
                 && let def_kind = tcx.def_kind(def_id)
@@ -159,7 +159,7 @@ fn layout_of<'tcx>(
                     tcx.def_kind_descr(def_kind, def_id.to_def_id()),
                 );
                 for (i, frame) in cycle.iter().enumerate() {
-                    let TaggedQueryKey::layout_of(frame_key) = frame.node.tagged_key else {
+                    let TaggedQueryKey::layout_of(frame_key) = frame.tagged_key else {
                         continue;
                     };
                     let &ty::Coroutine(frame_def_id, _) = frame_key.value.kind() else {
@@ -169,7 +169,7 @@ fn layout_of<'tcx>(
                         continue;
                     };
                     let frame_span =
-                        frame.node.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
+                        frame.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
                     if frame_span.is_dummy() {
                         continue;
                     }
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 9d2d6cc54d49..29877c8aac88 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -11,7 +11,7 @@
     CycleError, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
 };
 use rustc_middle::ty::TyCtxt;
-use rustc_span::{DUMMY_SP, Span, respan};
+use rustc_span::{DUMMY_SP, Span};
 
 use crate::{CollectActiveJobsKind, collect_active_query_jobs};
 
@@ -30,8 +30,8 @@ pub(crate) fn insert(&mut self, id: QueryJobId, info: QueryJobInfo<'tcx>) {
         self.map.insert(id, info);
     }
 
-    fn frame_of(&self, id: QueryJobId) -> &QueryStackFrame<'tcx> {
-        &self.map[&id].frame
+    fn tagged_key_of(&self, id: QueryJobId) -> TaggedQueryKey<'tcx> {
+        self.map[&id].tagged_key
     }
 
     fn span_of(&self, id: QueryJobId) -> Span {
@@ -49,7 +49,7 @@ fn latch_of(&self, id: QueryJobId) -> Option<&QueryLatch<'tcx>> {
 
 #[derive(Debug)]
 pub(crate) struct QueryJobInfo<'tcx> {
-    pub(crate) frame: QueryStackFrame<'tcx>,
+    pub(crate) tagged_key: TaggedQueryKey<'tcx>,
     pub(crate) job: QueryJob<'tcx>,
 }
 
@@ -65,7 +65,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
 
     while let Some(job) = current_job {
         let info = &job_map.map[&job];
-        cycle.push(respan(info.job.span, info.frame.clone()));
+        cycle.push(QueryStackFrame { span: info.job.span, tagged_key: info.tagged_key });
 
         if job == id {
             cycle.reverse();
@@ -78,7 +78,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
             // Find out why the cycle itself was used
             let usage = try {
                 let parent = info.job.parent?;
-                respan(info.job.span, job_map.frame_of(parent).clone())
+                QueryStackFrame { span: info.job.span, tagged_key: job_map.tagged_key_of(parent) }
             };
             return CycleError { usage, cycle };
         }
@@ -100,19 +100,19 @@ pub(crate) fn find_dep_kind_root<'tcx>(
 ) -> (Span, String, usize) {
     let mut depth = 1;
     let mut info = &job_map.map[&id];
-    // Two query stack frames are for the same query method if they have the same
+    // Two query jobs are for the same query method if they have the same
     // `TaggedQueryKey` discriminant.
-    let expected_query = mem::discriminant::<TaggedQueryKey<'tcx>>(&info.frame.tagged_key);
+    let expected_query = mem::discriminant::<TaggedQueryKey<'tcx>>(&info.tagged_key);
     let mut last_info = info;
 
     while let Some(id) = info.job.parent {
         info = &job_map.map[&id];
-        if mem::discriminant(&info.frame.tagged_key) == expected_query {
+        if mem::discriminant(&info.tagged_key) == expected_query {
             depth += 1;
             last_info = info;
         }
     }
-    (last_info.job.span, last_info.frame.tagged_key.description(tcx), depth)
+    (last_info.job.span, last_info.tagged_key.description(tcx), depth)
 }
 
 /// The locaton of a resumable waiter. The usize is the index into waiters in the query's latch.
@@ -316,14 +316,17 @@ struct EntryPoint {
 
         let usage = entry_point
             .query_waiting_on_cycle
-            .map(|(span, job)| respan(span, job_map.frame_of(job).clone()));
+            .map(|(span, job)| QueryStackFrame { span, tagged_key: job_map.tagged_key_of(job) });
 
         // Create the cycle error
         let error = CycleError {
             usage,
             cycle: stack
                 .iter()
-                .map(|&(span, job)| respan(span, job_map.frame_of(job).clone()))
+                .map(|&(span, job)| QueryStackFrame {
+                    span,
+                    tagged_key: job_map.tagged_key_of(job),
+                })
                 .collect(),
         };
 
@@ -419,12 +422,12 @@ pub fn print_query_stack<'tcx>(
         let Some(query_info) = job_map.map.get(&query) else {
             break;
         };
-        let description = query_info.frame.tagged_key.description(tcx);
+        let description = query_info.tagged_key.description(tcx);
         if Some(count_printed) < limit_frames || limit_frames.is_none() {
             // Only print to stderr as many stack frames as `num_frames` when present.
             dcx.struct_failure_note(format!(
                 "#{count_printed} [{query_name}] {description}",
-                query_name = query_info.frame.tagged_key.query_name(),
+                query_name = query_info.tagged_key.query_name(),
             ))
             .with_span(query_info.job.span)
             .emit();
@@ -435,7 +438,7 @@ pub fn print_query_stack<'tcx>(
             let _ = writeln!(
                 file,
                 "#{count_total} [{query_name}] {description}",
-                query_name = query_info.frame.tagged_key.query_name(),
+                query_name = query_info.tagged_key.query_name(),
             );
         }
 
@@ -457,12 +460,12 @@ pub(crate) fn report_cycle<'tcx>(
 ) -> Diag<'tcx> {
     assert!(!stack.is_empty());
 
-    let span = stack[0].node.tagged_key.default_span(tcx, stack[1 % stack.len()].span);
+    let span = stack[0].tagged_key.default_span(tcx, stack[1 % stack.len()].span);
 
     let mut cycle_stack = Vec::new();
 
     use crate::error::StackCount;
-    let stack_bottom = stack[0].node.tagged_key.description(tcx);
+    let stack_bottom = stack[0].tagged_key.description(tcx);
     let stack_count = if stack.len() == 1 {
         StackCount::Single { stack_bottom: stack_bottom.clone() }
     } else {
@@ -470,24 +473,23 @@ pub(crate) fn report_cycle<'tcx>(
     };
 
     for i in 1..stack.len() {
-        let node = &stack[i].node;
-        let span = node.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
-        cycle_stack.push(crate::error::CycleStack { span, desc: node.tagged_key.description(tcx) });
+        let frame = &stack[i];
+        let span = frame.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
+        cycle_stack
+            .push(crate::error::CycleStack { span, desc: frame.tagged_key.description(tcx) });
     }
 
     let cycle_usage = usage.as_ref().map(|usage| crate::error::CycleUsage {
-        span: usage.node.tagged_key.default_span(tcx, usage.span),
-        usage: usage.node.tagged_key.description(tcx),
+        span: usage.tagged_key.default_span(tcx, usage.span),
+        usage: usage.tagged_key.description(tcx),
     });
 
     let alias = if stack
         .iter()
-        .all(|entry| matches!(entry.node.tagged_key.def_kind(tcx), Some(DefKind::TyAlias)))
+        .all(|frame| frame.tagged_key.def_kind(tcx) == Some(DefKind::TyAlias))
     {
         Some(crate::error::Alias::Ty)
-    } else if stack
-        .iter()
-        .all(|entry| entry.node.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
+    } else if stack.iter().all(|frame| frame.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
     {
         Some(crate::error::Alias::Trait)
     } else {

From fb850aebcd39f7dd7973adabf380bdc5bb22a369 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 18 Mar 2026 10:36:19 +1100
Subject: [PATCH 0608/1059] Remove unused types `UnusedGenericParams` and
 `FiniteBitSet`

These types have been unused since polymorphization was removed in
<https://github.com/rust-lang/rust/pull/133883>.
---
 .../src/stable_hasher.rs                      |   9 --
 compiler/rustc_index/src/bit_set.rs           | 113 +-----------------
 compiler/rustc_metadata/src/rmeta/mod.rs      |   2 +-
 compiler/rustc_metadata/src/rmeta/table.rs    |  10 --
 compiler/rustc_middle/src/query/erase.rs      |   2 -
 compiler/rustc_middle/src/ty/instance.rs      |  50 +-------
 compiler/rustc_middle/src/ty/mod.rs           |   2 +-
 7 files changed, 4 insertions(+), 184 deletions(-)

diff --git a/compiler/rustc_data_structures/src/stable_hasher.rs b/compiler/rustc_data_structures/src/stable_hasher.rs
index 9fb4d4352c2f..f8e72d66d07e 100644
--- a/compiler/rustc_data_structures/src/stable_hasher.rs
+++ b/compiler/rustc_data_structures/src/stable_hasher.rs
@@ -555,15 +555,6 @@ fn hash_stable(&self, _ctx: &mut CTX, hasher: &mut StableHasher) {
     }
 }
 
-impl<T, CTX> HashStable<CTX> for bit_set::FiniteBitSet<T>
-where
-    T: HashStable<CTX> + bit_set::FiniteBitSetTy,
-{
-    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.0.hash_stable(hcx, hasher);
-    }
-}
-
 impl_stable_traits_for_trivial_type!(::std::ffi::OsStr);
 
 impl_stable_traits_for_trivial_type!(::std::path::Path);
diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 68384c73ba25..f833acf6824e 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 #[cfg(not(feature = "nightly"))]
 use std::mem;
-use std::ops::{BitAnd, BitAndAssign, BitOrAssign, Bound, Not, Range, RangeBounds, Shl};
+use std::ops::{Bound, Range, RangeBounds};
 use std::rc::Rc;
 use std::{fmt, iter, slice};
 
@@ -1736,114 +1736,3 @@ fn max_bit(word: Word) -> usize {
 fn count_ones(words: &[Word]) -> usize {
     words.iter().map(|word| word.count_ones() as usize).sum()
 }
-
-/// Integral type used to represent the bit set.
-pub trait FiniteBitSetTy:
-    BitAnd<Output = Self>
-    + BitAndAssign
-    + BitOrAssign
-    + Clone
-    + Copy
-    + Shl
-    + Not<Output = Self>
-    + PartialEq
-    + Sized
-{
-    /// Size of the domain representable by this type, e.g. 64 for `u64`.
-    const DOMAIN_SIZE: u32;
-
-    /// Value which represents the `FiniteBitSet` having every bit set.
-    const FILLED: Self;
-    /// Value which represents the `FiniteBitSet` having no bits set.
-    const EMPTY: Self;
-
-    /// Value for one as the integral type.
-    const ONE: Self;
-    /// Value for zero as the integral type.
-    const ZERO: Self;
-
-    /// Perform a checked left shift on the integral type.
-    fn checked_shl(self, rhs: u32) -> Option<Self>;
-    /// Perform a checked right shift on the integral type.
-    fn checked_shr(self, rhs: u32) -> Option<Self>;
-}
-
-impl FiniteBitSetTy for u32 {
-    const DOMAIN_SIZE: u32 = 32;
-
-    const FILLED: Self = Self::MAX;
-    const EMPTY: Self = Self::MIN;
-
-    const ONE: Self = 1u32;
-    const ZERO: Self = 0u32;
-
-    fn checked_shl(self, rhs: u32) -> Option<Self> {
-        self.checked_shl(rhs)
-    }
-
-    fn checked_shr(self, rhs: u32) -> Option<Self> {
-        self.checked_shr(rhs)
-    }
-}
-
-impl std::fmt::Debug for FiniteBitSet<u32> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:032b}", self.0)
-    }
-}
-
-/// A fixed-sized bitset type represented by an integer type. Indices outwith than the range
-/// representable by `T` are considered set.
-#[cfg_attr(feature = "nightly", derive(Decodable_NoContext, Encodable_NoContext))]
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct FiniteBitSet<T: FiniteBitSetTy>(pub T);
-
-impl<T: FiniteBitSetTy> FiniteBitSet<T> {
-    /// Creates a new, empty bitset.
-    pub fn new_empty() -> Self {
-        Self(T::EMPTY)
-    }
-
-    /// Sets the `index`th bit.
-    pub fn set(&mut self, index: u32) {
-        self.0 |= T::ONE.checked_shl(index).unwrap_or(T::ZERO);
-    }
-
-    /// Unsets the `index`th bit.
-    pub fn clear(&mut self, index: u32) {
-        self.0 &= !T::ONE.checked_shl(index).unwrap_or(T::ZERO);
-    }
-
-    /// Sets the `i`th to `j`th bits.
-    pub fn set_range(&mut self, range: Range<u32>) {
-        let bits = T::FILLED
-            .checked_shl(range.end - range.start)
-            .unwrap_or(T::ZERO)
-            .not()
-            .checked_shl(range.start)
-            .unwrap_or(T::ZERO);
-        self.0 |= bits;
-    }
-
-    /// Is the set empty?
-    pub fn is_empty(&self) -> bool {
-        self.0 == T::EMPTY
-    }
-
-    /// Returns the domain size of the bitset.
-    pub fn within_domain(&self, index: u32) -> bool {
-        index < T::DOMAIN_SIZE
-    }
-
-    /// Returns if the `index`th bit is set.
-    pub fn contains(&self, index: u32) -> Option<bool> {
-        self.within_domain(index)
-            .then(|| ((self.0.checked_shr(index).unwrap_or(T::ONE)) & T::ONE) == T::ONE)
-    }
-}
-
-impl<T: FiniteBitSetTy> Default for FiniteBitSet<T> {
-    fn default() -> Self {
-        Self::new_empty()
-    }
-}
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index 80d7ae4e9cb3..9dee913e8389 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -33,7 +33,7 @@
 use rustc_middle::mir;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::FileEncoder;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 5e256438ad95..3b0570dd373a 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -44,16 +44,6 @@ fn is_default(&self) -> bool {
     }
 }
 
-impl IsDefault for UnusedGenericParams {
-    fn is_default(&self) -> bool {
-        // UnusedGenericParams encodes the *un*usedness as a bitset.
-        // This means that 0 corresponds to all bits used, which is indeed the default.
-        let is_default = self.bits() == 0;
-        debug_assert_eq!(is_default, self.all_used());
-        is_default
-    }
-}
-
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
 ///
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index d15e0b2a122b..036aa2ed05a4 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -356,7 +356,6 @@ impl Erasable for $ty {
     rustc_hir::OwnerId,
     rustc_hir::Stability,
     rustc_hir::Upvar,
-    rustc_index::bit_set::FiniteBitSet<u32>,
     rustc_middle::middle::deduced_param_attrs::DeducedParamAttrs,
     rustc_middle::middle::dependency_format::Linkage,
     rustc_middle::middle::exported_symbols::SymbolExportInfo,
@@ -383,7 +382,6 @@ impl Erasable for $ty {
     rustc_middle::ty::Destructor,
     rustc_middle::ty::fast_reject::SimplifiedType,
     rustc_middle::ty::ImplPolarity,
-    rustc_middle::ty::UnusedGenericParams,
     rustc_middle::ty::util::AlwaysRequiresDrop,
     rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
     rustc_middle::middle::codegen_fn_attrs::SanitizerFnAttrs,
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 4cea8b62f0b6..9759e376c058 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -6,8 +6,7 @@
 use rustc_hir::def::{CtorKind, DefKind, Namespace};
 use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_hir::lang_items::LangItem;
-use rustc_index::bit_set::FiniteBitSet;
-use rustc_macros::{Decodable, Encodable, HashStable, Lift, TyDecodable, TyEncodable};
+use rustc_macros::{HashStable, Lift, TyDecodable, TyEncodable};
 use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
@@ -941,50 +940,3 @@ fn needs_fn_once_adapter_shim(
         (ty::ClosureKind::FnMut | ty::ClosureKind::FnOnce, _) => Err(()),
     }
 }
-
-// Set bits represent unused generic parameters.
-// An empty set indicates that all parameters are used.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Decodable, Encodable, HashStable)]
-pub struct UnusedGenericParams(FiniteBitSet<u32>);
-
-impl Default for UnusedGenericParams {
-    fn default() -> Self {
-        UnusedGenericParams::new_all_used()
-    }
-}
-
-impl UnusedGenericParams {
-    pub fn new_all_unused(amount: u32) -> Self {
-        let mut bitset = FiniteBitSet::new_empty();
-        bitset.set_range(0..amount);
-        Self(bitset)
-    }
-
-    pub fn new_all_used() -> Self {
-        Self(FiniteBitSet::new_empty())
-    }
-
-    pub fn mark_used(&mut self, idx: u32) {
-        self.0.clear(idx);
-    }
-
-    pub fn is_unused(&self, idx: u32) -> bool {
-        self.0.contains(idx).unwrap_or(false)
-    }
-
-    pub fn is_used(&self, idx: u32) -> bool {
-        !self.is_unused(idx)
-    }
-
-    pub fn all_used(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    pub fn bits(&self) -> u32 {
-        self.0.0
-    }
-
-    pub fn from_bits(bits: u32) -> UnusedGenericParams {
-        UnusedGenericParams(FiniteBitSet(bits))
-    }
-}
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 01c351de9319..2b02d42890aa 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -85,7 +85,7 @@
     CtxtInterners, CurrentGcx, Feed, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt, TyCtxtFeed, tls,
 };
 pub use self::fold::*;
-pub use self::instance::{Instance, InstanceKind, ReifyReason, UnusedGenericParams};
+pub use self::instance::{Instance, InstanceKind, ReifyReason};
 pub use self::list::{List, ListWithCachedTypeInfo};
 pub use self::opaque_types::OpaqueTypeKey;
 pub use self::pattern::{Pattern, PatternKind};

From 00ff819ecd89e82f358b894adebe639d1959c848 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Wed, 18 Mar 2026 00:16:25 +0000
Subject: [PATCH 0609/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 91021ccc790478a1a89c003e7d32b8d155ae6aae.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 69609cc49f27..e95d7777b87c 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-1e2183119f0ee19cc26df899e26b04ad0de3475d
+91021ccc790478a1a89c003e7d32b8d155ae6aae

From fac53a0cf82ed94246b8159a1d40e297e385bef4 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 18 Mar 2026 12:41:18 +0900
Subject: [PATCH 0610/1059] add regression test for issue 153695

---
 .../reachable/never-pattern-closure-param-array.rs  | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 tests/ui/reachable/never-pattern-closure-param-array.rs

diff --git a/tests/ui/reachable/never-pattern-closure-param-array.rs b/tests/ui/reachable/never-pattern-closure-param-array.rs
new file mode 100644
index 000000000000..83bbc4b39b77
--- /dev/null
+++ b/tests/ui/reachable/never-pattern-closure-param-array.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+//@ edition: 2024
+
+#![feature(never_patterns)]
+#![allow(incomplete_features)]
+#![allow(unreachable_code)]
+
+fn main() {
+    let _ = Some({
+        return;
+    })
+    .map(|!| [1]);
+}

From 74909ec285fb12f2a14234009354ad883b7cdabd Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 18 Mar 2026 12:41:27 +0900
Subject: [PATCH 0611/1059] fix ICE for arrays in diverging never-pattern
 closure bodies

---
 compiler/rustc_hir_typeck/src/expr.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 17c7c4b76b2d..184c0d5a53d1 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1660,14 +1660,6 @@ fn check_expr_array(
         expr: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
         let element_ty = if !args.is_empty() {
-            // This shouldn't happen unless there's another error
-            // (e.g., never patterns in inappropriate contexts).
-            if self.diverges.get() != Diverges::Maybe {
-                self.dcx()
-                    .struct_span_err(expr.span, "unexpected divergence state in checking array")
-                    .delay_as_bug();
-            }
-
             let coerce_to = expected
                 .to_option(self)
                 .and_then(|uty| {

From 8ace95963961bf2d818431fd35f933ead33aa816 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 18 Mar 2026 05:22:01 +0000
Subject: [PATCH 0612/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 91775dbec9771aa0c1b9ebe268eb5bd271e79a7a.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 69609cc49f27..9c8f107f4235 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-1e2183119f0ee19cc26df899e26b04ad0de3475d
+91775dbec9771aa0c1b9ebe268eb5bd271e79a7a

From cab72ae27878f7433c446a358981c061d75b4257 Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Wed, 18 Mar 2026 02:03:31 +0800
Subject: [PATCH 0613/1059] implement `BinaryHeap::as_mut_slice`

---
 .../alloc/src/collections/binary_heap/mod.rs  | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs
index 4ddfcde57280..d46b1972b5b0 100644
--- a/library/alloc/src/collections/binary_heap/mod.rs
+++ b/library/alloc/src/collections/binary_heap/mod.rs
@@ -1364,6 +1364,37 @@ pub fn as_slice(&self) -> &[T] {
         self.data.as_slice()
     }
 
+    /// Returns a mutable slice of all values in the underlying vector.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the slice remains a max-heap, i.e. for all indices
+    /// `0 < i < slice.len()`, `slice[(i - 1) / 2] >= slice[i]`, before the borrow ends
+    /// and the binary heap is used.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// #![feature(binary_heap_as_mut_slice)]
+    ///
+    /// use std::collections::BinaryHeap;
+    ///
+    /// let mut heap = BinaryHeap::<u32>::from([1, 2, 3, 4, 5, 6, 7]);
+    ///
+    /// unsafe {
+    ///     for value in heap.as_mut_slice() {
+    ///         *value = (*value).saturating_mul(2);
+    ///     }
+    /// }
+    /// ```
+    #[must_use]
+    #[unstable(feature = "binary_heap_as_mut_slice", issue = "154009")]
+    pub unsafe fn as_mut_slice(&mut self) -> &mut [T] {
+        self.data.as_mut_slice()
+    }
+
     /// Consumes the `BinaryHeap` and returns the underlying vector
     /// in arbitrary order.
     ///

From 55ba943a36398dbcb83df8c48fe525fcbecaa705 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 18 Mar 2026 08:30:42 +0100
Subject: [PATCH 0614/1059] clippy, and a bit of readability

---
 src/tools/miri/src/shims/x86/avx512.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/src/shims/x86/avx512.rs b/src/tools/miri/src/shims/x86/avx512.rs
index 23538f0dea96..8e1d22d723e7 100644
--- a/src/tools/miri/src/shims/x86/avx512.rs
+++ b/src/tools/miri/src/shims/x86/avx512.rs
@@ -191,9 +191,9 @@ fn vpdpbusd<'tcx>(
     // fn vpdpbusd(src: i32x16, a: u8x64, b: i8x64) -> i32x16;
     // fn vpdpbusd256(src: i32x8, a: u8x32, b: i8x32) -> i32x8;
     // fn vpdpbusd128(src: i32x4, a: u8x16, b: i8x16) -> i32x4;
-    assert_eq!(dest_len, src_len);
-    assert_eq!(dest_len * 4, a_len);
-    assert_eq!(a_len, b_len);
+    assert_eq!(src_len, dest_len);
+    assert_eq!(a_len, dest_len.strict_mul(4));
+    assert_eq!(b_len, a_len);
 
     for i in 0..dest_len {
         let src = ecx.read_scalar(&ecx.project_index(&src, i)?)?.to_i32()?;

From 38aa32217bdfab5bf585bf2b6c5bf54a053e4810 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 18 Mar 2026 08:32:52 +0100
Subject: [PATCH 0615/1059] borrowck/type_check: remove helper left-over from
 unsized locals

---
 compiler/rustc_borrowck/src/type_check/mod.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 9aa8f7a2067a..47f14dc3df62 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -374,10 +374,6 @@ fn body(&self) -> &Body<'tcx> {
         self.body
     }
 
-    fn unsized_feature_enabled(&self) -> bool {
-        self.tcx().features().unsized_fn_params()
-    }
-
     /// Equate the inferred type and the annotated type for user type annotations
     #[instrument(skip(self), level = "debug")]
     fn check_user_type_annotations(&mut self) {
@@ -660,7 +656,7 @@ fn visit_statement(&mut self, stmt: &Statement<'tcx>, location: Location) {
                     );
                 }
 
-                if !self.unsized_feature_enabled() {
+                if !self.tcx().features().unsized_fn_params() {
                     let trait_ref = ty::TraitRef::new(
                         tcx,
                         tcx.require_lang_item(LangItem::Sized, self.last_span),
@@ -936,9 +932,10 @@ fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
             }
         }
 
-        // When `unsized_fn_params` is enabled, only function calls
-        // and nullary ops are checked in `check_call_dest`.
-        if !self.unsized_feature_enabled() {
+        // When `unsized_fn_params` is enabled, this is checked in `check_call_dest`,
+        // and `hir_typeck` still forces all non-argument locals to be sized (i.e., we don't
+        // fully re-check what was already checked on HIR).
+        if !self.tcx().features().unsized_fn_params() {
             match self.body.local_kind(local) {
                 LocalKind::ReturnPointer | LocalKind::Arg => {
                     // return values of normal functions are required to be
@@ -1953,8 +1950,8 @@ fn check_call_dest(
             }
 
             // When `unsized_fn_params` is not enabled,
-            // this check is done at `check_local`.
-            if self.unsized_feature_enabled() {
+            // this check is done at `visit_local_decl`.
+            if self.tcx().features().unsized_fn_params() {
                 let span = term.source_info.span;
                 self.ensure_place_sized(dest_ty, span);
             }

From 4c16ba1a4de3516d39fa2bac96cfeb8110a365c0 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 18 Mar 2026 12:50:33 +1100
Subject: [PATCH 0616/1059] Move trait `IntoQueryParam` into its own file

Removing coherent and self-contained chunks of code from a catch-all "plumbing"
module is typically an improvement.

Giving the trait its own file also gets rid of the unhelpful `sealed` module
that it was previously in.
---
 .../rustc_middle/src/query/into_query_key.rs  | 59 +++++++++++++++++
 compiler/rustc_middle/src/query/mod.rs        |  6 +-
 compiler/rustc_middle/src/query/plumbing.rs   | 66 -------------------
 3 files changed, 63 insertions(+), 68 deletions(-)
 create mode 100644 compiler/rustc_middle/src/query/into_query_key.rs

diff --git a/compiler/rustc_middle/src/query/into_query_key.rs b/compiler/rustc_middle/src/query/into_query_key.rs
new file mode 100644
index 000000000000..00acce60c833
--- /dev/null
+++ b/compiler/rustc_middle/src/query/into_query_key.rs
@@ -0,0 +1,59 @@
+use rustc_hir::OwnerId;
+use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId, ModDefId};
+
+/// An analogue of the `Into` trait that's intended only for query parameters.
+///
+/// This exists to allow queries to accept either `DefId` or `LocalDefId` while requiring that the
+/// user call `to_def_id` to convert between them everywhere else.
+pub trait IntoQueryParam<P> {
+    fn into_query_param(self) -> P;
+}
+
+impl<P> IntoQueryParam<P> for P {
+    #[inline(always)]
+    fn into_query_param(self) -> P {
+        self
+    }
+}
+
+impl IntoQueryParam<LocalDefId> for OwnerId {
+    #[inline(always)]
+    fn into_query_param(self) -> LocalDefId {
+        self.def_id
+    }
+}
+
+impl IntoQueryParam<DefId> for LocalDefId {
+    #[inline(always)]
+    fn into_query_param(self) -> DefId {
+        self.to_def_id()
+    }
+}
+
+impl IntoQueryParam<DefId> for OwnerId {
+    #[inline(always)]
+    fn into_query_param(self) -> DefId {
+        self.to_def_id()
+    }
+}
+
+impl IntoQueryParam<DefId> for ModDefId {
+    #[inline(always)]
+    fn into_query_param(self) -> DefId {
+        self.to_def_id()
+    }
+}
+
+impl IntoQueryParam<DefId> for LocalModDefId {
+    #[inline(always)]
+    fn into_query_param(self) -> DefId {
+        self.to_def_id()
+    }
+}
+
+impl IntoQueryParam<LocalDefId> for LocalModDefId {
+    #[inline(always)]
+    fn into_query_param(self) -> LocalDefId {
+        self.into()
+    }
+}
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 1723a853ea75..1df7aed31a5a 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1,11 +1,12 @@
 use rustc_hir::def_id::LocalDefId;
 
 pub use self::caches::{DefIdCache, DefaultCache, QueryCache, SingleCache, VecCache};
+pub use self::into_query_key::IntoQueryParam;
 pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
-    ActiveKeyStatus, CycleError, EnsureMode, IntoQueryParam, QueryMode, QueryState, QuerySystem,
-    QueryVTable, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
+    ActiveKeyStatus, CycleError, EnsureMode, QueryMode, QueryState, QuerySystem, QueryVTable,
+    TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
 };
 pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
@@ -15,6 +16,7 @@
 mod caches;
 pub mod erase;
 pub(crate) mod inner;
+mod into_query_key;
 mod job;
 mod keys;
 pub(crate) mod modifiers;
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index e8e2c8dbd224..c00aae61fea8 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -6,10 +6,7 @@
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::sync::{AtomicU64, WorkerLocal};
 use rustc_errors::Diag;
-use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::hir_id::OwnerId;
 use rustc_span::Span;
-pub use sealed::IntoQueryParam;
 
 use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
@@ -647,69 +644,6 @@ fn clone(&self) -> Self { *self }
 pub(crate) use define_callbacks;
 pub(crate) use query_helper_param_ty;
 
-mod sealed {
-    use rustc_hir::def_id::{LocalModDefId, ModDefId};
-
-    use super::{DefId, LocalDefId, OwnerId};
-
-    /// An analogue of the `Into` trait that's intended only for query parameters.
-    ///
-    /// This exists to allow queries to accept either `DefId` or `LocalDefId` while requiring that the
-    /// user call `to_def_id` to convert between them everywhere else.
-    pub trait IntoQueryParam<P> {
-        fn into_query_param(self) -> P;
-    }
-
-    impl<P> IntoQueryParam<P> for P {
-        #[inline(always)]
-        fn into_query_param(self) -> P {
-            self
-        }
-    }
-
-    impl IntoQueryParam<LocalDefId> for OwnerId {
-        #[inline(always)]
-        fn into_query_param(self) -> LocalDefId {
-            self.def_id
-        }
-    }
-
-    impl IntoQueryParam<DefId> for LocalDefId {
-        #[inline(always)]
-        fn into_query_param(self) -> DefId {
-            self.to_def_id()
-        }
-    }
-
-    impl IntoQueryParam<DefId> for OwnerId {
-        #[inline(always)]
-        fn into_query_param(self) -> DefId {
-            self.to_def_id()
-        }
-    }
-
-    impl IntoQueryParam<DefId> for ModDefId {
-        #[inline(always)]
-        fn into_query_param(self) -> DefId {
-            self.to_def_id()
-        }
-    }
-
-    impl IntoQueryParam<DefId> for LocalModDefId {
-        #[inline(always)]
-        fn into_query_param(self) -> DefId {
-            self.to_def_id()
-        }
-    }
-
-    impl IntoQueryParam<LocalDefId> for LocalModDefId {
-        #[inline(always)]
-        fn into_query_param(self) -> LocalDefId {
-            self.into()
-        }
-    }
-}
-
 #[cold]
 pub(crate) fn default_query(name: &str, key: &dyn std::fmt::Debug) -> ! {
     bug!(

From 38aaeefb94e54877d30ba2d596f7916b7bd02b96 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 18 Mar 2026 13:04:36 +1100
Subject: [PATCH 0617/1059] Rename `IntoQueryParam` to `IntoQueryKey` and tweak
 some occurrences

All methods that accept `impl IntoQueryKey<_>` have been adjusted to
consistently call `into_query_key` before doing anything else.

When a function with a conversion trait calls another function with the same
conversion trait, doing the conversion eagerly can reduce the overall number of
instantiations.
---
 .../rustc_middle/src/query/into_query_key.rs  | 49 +++++++++++-------
 compiler/rustc_middle/src/query/mod.rs        |  2 +-
 compiler/rustc_middle/src/query/plumbing.rs   | 16 +++---
 compiler/rustc_middle/src/ty/context.rs       | 22 ++++----
 .../src/ty/context/impl_interner.rs           |  2 -
 compiler/rustc_middle/src/ty/mod.rs           | 50 +++++++++++--------
 compiler/rustc_middle/src/ty/print/pretty.rs  | 13 ++---
 7 files changed, 84 insertions(+), 70 deletions(-)

diff --git a/compiler/rustc_middle/src/query/into_query_key.rs b/compiler/rustc_middle/src/query/into_query_key.rs
index 00acce60c833..04bbfd5c3a8a 100644
--- a/compiler/rustc_middle/src/query/into_query_key.rs
+++ b/compiler/rustc_middle/src/query/into_query_key.rs
@@ -1,59 +1,70 @@
 use rustc_hir::OwnerId;
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId, ModDefId};
 
-/// An analogue of the `Into` trait that's intended only for query parameters.
+/// Argument-conversion trait used by some queries and other `TyCtxt` methods.
 ///
-/// This exists to allow queries to accept either `DefId` or `LocalDefId` while requiring that the
-/// user call `to_def_id` to convert between them everywhere else.
-pub trait IntoQueryParam<P> {
-    fn into_query_param(self) -> P;
+/// A function that accepts an `impl IntoQueryKey<DefId>` argument can be thought
+/// of as taking a [`DefId`], except that callers can also pass a [`LocalDefId`]
+/// or values of other narrower ID types, as long as they have a trivial conversion
+/// to `DefId`.
+///
+/// Using a dedicated trait instead of [`Into`] makes the purpose of the conversion
+/// more explicit, and makes occurrences easier to search for.
+pub trait IntoQueryKey<K> {
+    /// Argument conversion from `Self` to `K`.
+    /// This should always be a very cheap conversion, e.g. [`LocalDefId::to_def_id`].
+    fn into_query_key(self) -> K;
 }
 
-impl<P> IntoQueryParam<P> for P {
+/// Any type can be converted to itself.
+///
+/// This is useful in generic or macro-generated code where we don't know whether
+/// conversion is actually needed, so that we can do a conversion unconditionally.
+impl<K> IntoQueryKey<K> for K {
     #[inline(always)]
-    fn into_query_param(self) -> P {
+    fn into_query_key(self) -> K {
         self
     }
 }
 
-impl IntoQueryParam<LocalDefId> for OwnerId {
+impl IntoQueryKey<LocalDefId> for OwnerId {
     #[inline(always)]
-    fn into_query_param(self) -> LocalDefId {
+    fn into_query_key(self) -> LocalDefId {
         self.def_id
     }
 }
 
-impl IntoQueryParam<DefId> for LocalDefId {
+impl IntoQueryKey<DefId> for LocalDefId {
     #[inline(always)]
-    fn into_query_param(self) -> DefId {
+    fn into_query_key(self) -> DefId {
         self.to_def_id()
     }
 }
 
-impl IntoQueryParam<DefId> for OwnerId {
+impl IntoQueryKey<DefId> for OwnerId {
     #[inline(always)]
-    fn into_query_param(self) -> DefId {
+    fn into_query_key(self) -> DefId {
         self.to_def_id()
     }
 }
 
-impl IntoQueryParam<DefId> for ModDefId {
+impl IntoQueryKey<DefId> for ModDefId {
     #[inline(always)]
-    fn into_query_param(self) -> DefId {
+    fn into_query_key(self) -> DefId {
         self.to_def_id()
     }
 }
 
-impl IntoQueryParam<DefId> for LocalModDefId {
+impl IntoQueryKey<DefId> for LocalModDefId {
     #[inline(always)]
-    fn into_query_param(self) -> DefId {
+    fn into_query_key(self) -> DefId {
         self.to_def_id()
     }
 }
 
-impl IntoQueryParam<LocalDefId> for LocalModDefId {
+impl IntoQueryKey<LocalDefId> for LocalModDefId {
     #[inline(always)]
-    fn into_query_param(self) -> LocalDefId {
+    fn into_query_key(self) -> LocalDefId {
         self.into()
     }
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 1df7aed31a5a..9c012f2da4df 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1,7 +1,7 @@
 use rustc_hir::def_id::LocalDefId;
 
 pub use self::caches::{DefIdCache, DefaultCache, QueryCache, SingleCache, VecCache};
-pub use self::into_query_key::IntoQueryParam;
+pub use self::into_query_key::IntoQueryKey;
 pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index c00aae61fea8..d4e7bb52be97 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -268,8 +268,8 @@ pub fn at(self, span: Span) -> TyCtxtAt<'tcx> {
 }
 
 macro_rules! query_helper_param_ty {
-    (DefId) => { impl $crate::query::IntoQueryParam<DefId> };
-    (LocalDefId) => { impl $crate::query::IntoQueryParam<LocalDefId> };
+    (DefId) => { impl $crate::query::IntoQueryKey<DefId> };
+    (LocalDefId) => { impl $crate::query::IntoQueryKey<LocalDefId> };
     ($K:ty) => { $K };
 }
 
@@ -410,7 +410,7 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
                     crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryParam::into_query_param(key),
+                        $crate::query::IntoQueryKey::into_query_key(key),
                         $crate::query::EnsureMode::Ok,
                     )
                 }
@@ -430,7 +430,7 @@ pub fn $name(
                     crate::query::inner::query_ensure_result(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryParam::into_query_param(key),
+                        $crate::query::IntoQueryKey::into_query_key(key),
                     )
                 }
             )*
@@ -444,7 +444,7 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
                     crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryParam::into_query_param(key),
+                        $crate::query::IntoQueryKey::into_query_key(key),
                         $crate::query::EnsureMode::Done,
                     );
                 }
@@ -473,7 +473,7 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
                         self.tcx,
                         self.span,
                         &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryParam::into_query_param(key),
+                        $crate::query::IntoQueryKey::into_query_key(key),
                     ))
                 }
             )*
@@ -481,13 +481,13 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
 
         $(
             #[cfg($feedable)]
-            impl<'tcx, K: $crate::query::IntoQueryParam<$name::Key<'tcx>> + Copy>
+            impl<'tcx, K: $crate::query::IntoQueryKey<$name::Key<'tcx>> + Copy>
                 TyCtxtFeed<'tcx, K>
             {
                 $(#[$attr])*
                 #[inline(always)]
                 pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
-                    let key = self.key().into_query_param();
+                    let key = self.key().into_query_key();
                     let erased_value = $name::provided_to_erased(self.tcx, value);
                     $crate::query::inner::query_feed(
                         self.tcx,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 037ee835c382..56428780d22d 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -61,7 +61,7 @@
 use crate::middle::resolve_bound_vars;
 use crate::mir::interpret::{self, Allocation, ConstAllocation};
 use crate::mir::{Body, Local, Place, PlaceElem, ProjectionKind, Promoted};
-use crate::query::{IntoQueryParam, LocalCrate, Providers, QuerySystem, TyCtxtAt};
+use crate::query::{IntoQueryKey, LocalCrate, Providers, QuerySystem, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
 use crate::traits::solve::{ExternalConstraints, ExternalConstraintsData, PredefinedOpaques};
@@ -1111,10 +1111,9 @@ pub fn type_const_span(self, def_id: DefId) -> Option<Span> {
     }
 
     /// Check if the given `def_id` is a `type const` (mgca)
-    pub fn is_type_const<I: Copy + IntoQueryParam<DefId>>(self, def_id: I) -> bool {
-        // No need to call the query directly in this case always false.
-        let def_kind = self.def_kind(def_id.into_query_param());
-        match def_kind {
+    pub fn is_type_const(self, def_id: impl IntoQueryKey<DefId>) -> bool {
+        let def_id = def_id.into_query_key();
+        match self.def_kind(def_id) {
             DefKind::Const { is_type_const } | DefKind::AssocConst { is_type_const } => {
                 is_type_const
             }
@@ -1168,8 +1167,8 @@ pub fn features(self) -> &'tcx rustc_feature::Features {
         self.features_query(())
     }
 
-    pub fn def_key(self, id: impl IntoQueryParam<DefId>) -> rustc_hir::definitions::DefKey {
-        let id = id.into_query_param();
+    pub fn def_key(self, id: impl IntoQueryKey<DefId>) -> rustc_hir::definitions::DefKey {
+        let id = id.into_query_key();
         // Accessing the DefKey is ok, since it is part of DefPathHash.
         if let Some(id) = id.as_local() {
             self.definitions_untracked().def_key(id)
@@ -2705,7 +2704,8 @@ pub fn is_sdylib_interface_build(self) -> bool {
         self.sess.opts.unstable_opts.build_sdylib_interface
     }
 
-    pub fn intrinsic(self, def_id: impl IntoQueryParam<DefId> + Copy) -> Option<ty::IntrinsicDef> {
+    pub fn intrinsic(self, def_id: impl IntoQueryKey<DefId>) -> Option<ty::IntrinsicDef> {
+        let def_id = def_id.into_query_key();
         match self.def_kind(def_id) {
             DefKind::Fn | DefKind::AssocFn => self.intrinsic_raw(def_id),
             _ => None,
@@ -2774,10 +2774,8 @@ pub fn do_not_recommend_impl(self, def_id: DefId) -> bool {
         find_attr!(self, def_id, DoNotRecommend { .. })
     }
 
-    pub fn is_trivial_const<P>(self, def_id: P) -> bool
-    where
-        P: IntoQueryParam<DefId>,
-    {
+    pub fn is_trivial_const(self, def_id: impl IntoQueryKey<DefId>) -> bool {
+        let def_id = def_id.into_query_key();
         self.trivial_const(def_id).is_some()
     }
 
diff --git a/compiler/rustc_middle/src/ty/context/impl_interner.rs b/compiler/rustc_middle/src/ty/context/impl_interner.rs
index 5179a77d6cb6..7bbfb11698fe 100644
--- a/compiler/rustc_middle/src/ty/context/impl_interner.rs
+++ b/compiler/rustc_middle/src/ty/context/impl_interner.rs
@@ -14,7 +14,6 @@
 
 use crate::dep_graph::{DepKind, DepNodeIndex};
 use crate::infer::canonical::CanonicalVarKinds;
-use crate::query::IntoQueryParam;
 use crate::traits::cache::WithDepNode;
 use crate::traits::solve::{
     self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, QueryResult, inspect,
@@ -720,7 +719,6 @@ fn evaluate_root_goal_for_proof_tree_raw(
     }
 
     fn item_name(self, id: DefId) -> Symbol {
-        let id = id.into_query_param();
         self.opt_item_name(id).unwrap_or_else(|| {
             bug!("item_name: no name for {:?}", self.def_path(id));
         })
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 2b02d42890aa..d35b755b3193 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -117,7 +117,7 @@
 use crate::metadata::{AmbigModChild, ModChild};
 use crate::middle::privacy::EffectiveVisibilities;
 use crate::mir::{Body, CoroutineLayout, CoroutineSavedLocal, SourceInfo};
-use crate::query::{IntoQueryParam, Providers};
+use crate::query::{IntoQueryKey, Providers};
 use crate::ty;
 use crate::ty::codec::{TyDecoder, TyEncoder};
 pub use crate::ty::diagnostics::*;
@@ -1031,12 +1031,14 @@ pub fn fully_monomorphized() -> TypingEnv<'tcx> {
     /// converted to use proper canonical inputs instead.
     pub fn non_body_analysis(
         tcx: TyCtxt<'tcx>,
-        def_id: impl IntoQueryParam<DefId>,
+        def_id: impl IntoQueryKey<DefId>,
     ) -> TypingEnv<'tcx> {
+        let def_id = def_id.into_query_key();
         TypingEnv { typing_mode: TypingMode::non_body_analysis(), param_env: tcx.param_env(def_id) }
     }
 
-    pub fn post_analysis(tcx: TyCtxt<'tcx>, def_id: impl IntoQueryParam<DefId>) -> TypingEnv<'tcx> {
+    pub fn post_analysis(tcx: TyCtxt<'tcx>, def_id: impl IntoQueryKey<DefId>) -> TypingEnv<'tcx> {
+        let def_id = def_id.into_query_key();
         tcx.typing_env_normalized_for_post_analysis(def_id)
     }
 
@@ -1528,8 +1530,8 @@ pub fn repr_options_of_def(self, did: LocalDefId) -> ReprOptions {
     }
 
     /// Look up the name of a definition across crates. This does not look at HIR.
-    pub fn opt_item_name(self, def_id: impl IntoQueryParam<DefId>) -> Option<Symbol> {
-        let def_id = def_id.into_query_param();
+    pub fn opt_item_name(self, def_id: impl IntoQueryKey<DefId>) -> Option<Symbol> {
+        let def_id = def_id.into_query_key();
         if let Some(cnum) = def_id.as_crate_root() {
             Some(self.crate_name(cnum))
         } else {
@@ -1549,8 +1551,8 @@ pub fn opt_item_name(self, def_id: impl IntoQueryParam<DefId>) -> Option<Symbol>
     /// [`opt_item_name`] instead.
     ///
     /// [`opt_item_name`]: Self::opt_item_name
-    pub fn item_name(self, id: impl IntoQueryParam<DefId>) -> Symbol {
-        let id = id.into_query_param();
+    pub fn item_name(self, id: impl IntoQueryKey<DefId>) -> Symbol {
+        let id = id.into_query_key();
         self.opt_item_name(id).unwrap_or_else(|| {
             bug!("item_name: no name for {:?}", self.def_path(id));
         })
@@ -1559,8 +1561,8 @@ pub fn item_name(self, id: impl IntoQueryParam<DefId>) -> Symbol {
     /// Look up the name and span of a definition.
     ///
     /// See [`item_name`][Self::item_name] for more information.
-    pub fn opt_item_ident(self, def_id: impl IntoQueryParam<DefId>) -> Option<Ident> {
-        let def_id = def_id.into_query_param();
+    pub fn opt_item_ident(self, def_id: impl IntoQueryKey<DefId>) -> Option<Ident> {
+        let def_id = def_id.into_query_key();
         let def = self.opt_item_name(def_id)?;
         let span = self
             .def_ident_span(def_id)
@@ -1571,8 +1573,8 @@ pub fn opt_item_ident(self, def_id: impl IntoQueryParam<DefId>) -> Option<Ident>
     /// Look up the name and span of a definition.
     ///
     /// See [`item_name`][Self::item_name] for more information.
-    pub fn item_ident(self, def_id: impl IntoQueryParam<DefId>) -> Ident {
-        let def_id = def_id.into_query_param();
+    pub fn item_ident(self, def_id: impl IntoQueryKey<DefId>) -> Ident {
+        let def_id = def_id.into_query_key();
         self.opt_item_ident(def_id).unwrap_or_else(|| {
             bug!("item_ident: no name for {:?}", self.def_path(def_id));
         })
@@ -1902,8 +1904,9 @@ pub fn assoc_parent(self, def_id: DefId) -> Option<(DefId, DefKind)> {
     }
 
     /// Returns the trait item that is implemented by the given item `DefId`.
-    pub fn trait_item_of(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
-        self.opt_associated_item(def_id.into_query_param())?.trait_item_def_id()
+    pub fn trait_item_of(self, def_id: impl IntoQueryKey<DefId>) -> Option<DefId> {
+        let def_id = def_id.into_query_key();
+        self.opt_associated_item(def_id)?.trait_item_def_id()
     }
 
     /// If the given `DefId` is an associated item of a trait,
@@ -1915,8 +1918,8 @@ pub fn trait_of_assoc(self, def_id: DefId) -> Option<DefId> {
         }
     }
 
-    pub fn impl_is_of_trait(self, def_id: impl IntoQueryParam<DefId>) -> bool {
-        let def_id = def_id.into_query_param();
+    pub fn impl_is_of_trait(self, def_id: impl IntoQueryKey<DefId>) -> bool {
+        let def_id = def_id.into_query_key();
         let DefKind::Impl { of_trait } = self.def_kind(def_id) else {
             panic!("expected Impl for {def_id:?}");
         };
@@ -1950,15 +1953,17 @@ pub fn trait_impl_of_assoc(self, def_id: DefId) -> Option<DefId> {
         }
     }
 
-    pub fn impl_polarity(self, def_id: impl IntoQueryParam<DefId>) -> ty::ImplPolarity {
+    pub fn impl_polarity(self, def_id: impl IntoQueryKey<DefId>) -> ty::ImplPolarity {
+        let def_id = def_id.into_query_key();
         self.impl_trait_header(def_id).polarity
     }
 
     /// Given an `impl_id`, return the trait it implements.
     pub fn impl_trait_ref(
         self,
-        def_id: impl IntoQueryParam<DefId>,
+        def_id: impl IntoQueryKey<DefId>,
     ) -> ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>> {
+        let def_id = def_id.into_query_key();
         self.impl_trait_header(def_id).trait_ref
     }
 
@@ -1966,21 +1971,22 @@ pub fn impl_trait_ref(
     /// Returns `None` if it is an inherent impl.
     pub fn impl_opt_trait_ref(
         self,
-        def_id: impl IntoQueryParam<DefId>,
+        def_id: impl IntoQueryKey<DefId>,
     ) -> Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>> {
-        let def_id = def_id.into_query_param();
+        let def_id = def_id.into_query_key();
         self.impl_is_of_trait(def_id).then(|| self.impl_trait_ref(def_id))
     }
 
     /// Given the `DefId` of an impl, returns the `DefId` of the trait it implements.
-    pub fn impl_trait_id(self, def_id: impl IntoQueryParam<DefId>) -> DefId {
+    pub fn impl_trait_id(self, def_id: impl IntoQueryKey<DefId>) -> DefId {
+        let def_id = def_id.into_query_key();
         self.impl_trait_ref(def_id).skip_binder().def_id
     }
 
     /// Given the `DefId` of an impl, returns the `DefId` of the trait it implements.
     /// Returns `None` if it is an inherent impl.
-    pub fn impl_opt_trait_id(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
-        let def_id = def_id.into_query_param();
+    pub fn impl_opt_trait_id(self, def_id: impl IntoQueryKey<DefId>) -> Option<DefId> {
+        let def_id = def_id.into_query_key();
         self.impl_is_of_trait(def_id).then(|| self.impl_trait_id(def_id))
     }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 8b8fe522842a..2c14c37609d4 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -23,7 +23,7 @@
 // `pretty` is a separate module only for organization.
 use super::*;
 use crate::mir::interpret::{AllocRange, GlobalAlloc, Pointer, Provenance, Scalar};
-use crate::query::{IntoQueryParam, Providers};
+use crate::query::{IntoQueryKey, Providers};
 use crate::ty::{
     ConstInt, Expr, GenericArgKind, ParamConst, ScalarInt, Term, TermKind, TraitPredicate,
     TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
@@ -2180,17 +2180,18 @@ fn guess_def_namespace(tcx: TyCtxt<'_>, def_id: DefId) -> Namespace {
 impl<'t> TyCtxt<'t> {
     /// Returns a string identifying this `DefId`. This string is
     /// suitable for user output.
-    pub fn def_path_str(self, def_id: impl IntoQueryParam<DefId>) -> String {
+    pub fn def_path_str(self, def_id: impl IntoQueryKey<DefId>) -> String {
+        let def_id = def_id.into_query_key();
         self.def_path_str_with_args(def_id, &[])
     }
 
     /// For this one we determine the appropriate namespace for the `def_id`.
     pub fn def_path_str_with_args(
         self,
-        def_id: impl IntoQueryParam<DefId>,
+        def_id: impl IntoQueryKey<DefId>,
         args: &'t [GenericArg<'t>],
     ) -> String {
-        let def_id = def_id.into_query_param();
+        let def_id = def_id.into_query_key();
         let ns = guess_def_namespace(self, def_id);
         debug!("def_path_str: def_id={:?}, ns={:?}", def_id, ns);
 
@@ -2200,10 +2201,10 @@ pub fn def_path_str_with_args(
     /// For this one we always use value namespace.
     pub fn value_path_str_with_args(
         self,
-        def_id: impl IntoQueryParam<DefId>,
+        def_id: impl IntoQueryKey<DefId>,
         args: &'t [GenericArg<'t>],
     ) -> String {
-        let def_id = def_id.into_query_param();
+        let def_id = def_id.into_query_key();
         let ns = Namespace::ValueNS;
         debug!("value_path_str: def_id={:?}, ns={:?}", def_id, ns);
 

From 6b0fecf582cc6788d0f246a2d7e5a7471462c506 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Wed, 18 Mar 2026 09:37:35 +0000
Subject: [PATCH 0618/1059] merge `regions-outlives-nominal-type-*` tests into
 one file

---
 ...s-outlives-nominal-type-enum-region-rev.rs | 20 -----
 ...gions-outlives-nominal-type-enum-region.rs | 20 -----
 ...ons-outlives-nominal-type-enum-type-rev.rs | 20 -----
 ...regions-outlives-nominal-type-enum-type.rs | 20 -----
 ...outlives-nominal-type-struct-region-rev.rs | 20 -----
 ...ons-outlives-nominal-type-struct-region.rs | 20 -----
 ...s-outlives-nominal-type-struct-type-rev.rs | 20 -----
 ...gions-outlives-nominal-type-struct-type.rs | 20 -----
 .../regions/regions-outlives-nominal-type.rs  | 80 +++++++++++++++++++
 9 files changed, 80 insertions(+), 160 deletions(-)
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-enum-region-rev.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-enum-region.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-enum-type-rev.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-enum-type.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-struct-region-rev.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-struct-region.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-struct-type-rev.rs
 delete mode 100644 tests/ui/regions/regions-outlives-nominal-type-struct-type.rs
 create mode 100644 tests/ui/regions/regions-outlives-nominal-type.rs

diff --git a/tests/ui/regions/regions-outlives-nominal-type-enum-region-rev.rs b/tests/ui/regions/regions-outlives-nominal-type-enum-region-rev.rs
deleted file mode 100644
index 3d4a30507884..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-enum-region-rev.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod rev_variant_struct_region {
-    struct Foo<'a> {
-        x: fn(&'a i32),
-    }
-    enum Bar<'a,'b> {
-        V(&'a Foo<'b>)
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-enum-region.rs b/tests/ui/regions/regions-outlives-nominal-type-enum-region.rs
deleted file mode 100644
index 2e0d1b36ca59..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-enum-region.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod variant_struct_region {
-    struct Foo<'a> {
-        x: &'a i32,
-    }
-    enum Bar<'a,'b> {
-        V(&'a Foo<'b>)
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-enum-type-rev.rs b/tests/ui/regions/regions-outlives-nominal-type-enum-type-rev.rs
deleted file mode 100644
index baf7874bc1a6..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-enum-type-rev.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod variant_struct_type {
-    struct Foo<T> {
-        x: fn(T)
-    }
-    enum Bar<'a,'b> {
-        V(&'a Foo<&'b i32>)
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-enum-type.rs b/tests/ui/regions/regions-outlives-nominal-type-enum-type.rs
deleted file mode 100644
index b8392c967b10..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-enum-type.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod variant_struct_type {
-    struct Foo<T> {
-        x: T
-    }
-    enum Bar<'a,'b> {
-        V(&'a Foo<&'b i32>)
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-struct-region-rev.rs b/tests/ui/regions/regions-outlives-nominal-type-struct-region-rev.rs
deleted file mode 100644
index 6a50248cb70b..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-struct-region-rev.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod rev_variant_struct_region {
-    struct Foo<'a> {
-        x: fn(&'a i32),
-    }
-    struct Bar<'a,'b> {
-        f: &'a Foo<'b>
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-struct-region.rs b/tests/ui/regions/regions-outlives-nominal-type-struct-region.rs
deleted file mode 100644
index 17564bcbf269..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-struct-region.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod variant_struct_region {
-    struct Foo<'a> {
-        x: &'a i32,
-    }
-    struct Bar<'a,'b> {
-        f: &'a Foo<'b>
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-struct-type-rev.rs b/tests/ui/regions/regions-outlives-nominal-type-struct-type-rev.rs
deleted file mode 100644
index 33961de7d6a4..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-struct-type-rev.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod rev_variant_struct_type {
-    struct Foo<T> {
-        x: fn(T)
-    }
-    struct Bar<'a,'b> {
-        f: &'a Foo<&'b i32>
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type-struct-type.rs b/tests/ui/regions/regions-outlives-nominal-type-struct-type.rs
deleted file mode 100644
index c5238086fc05..000000000000
--- a/tests/ui/regions/regions-outlives-nominal-type-struct-type.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
-// arguments (like `'a`) outlive `'b`.
-//
-// Rule OutlivesNominalType from RFC 1214.
-
-//@ check-pass
-
-#![feature(rustc_attrs)]
-#![allow(dead_code)]
-
-mod variant_struct_type {
-    struct Foo<T> {
-        x: T
-    }
-    struct Bar<'a,'b> {
-        f: &'a Foo<&'b i32>
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/regions/regions-outlives-nominal-type.rs b/tests/ui/regions/regions-outlives-nominal-type.rs
new file mode 100644
index 000000000000..177d064042dd
--- /dev/null
+++ b/tests/ui/regions/regions-outlives-nominal-type.rs
@@ -0,0 +1,80 @@
+// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its
+// arguments (like `'a`) outlive `'b`.
+//
+// Rule OutlivesNominalType from RFC 1214.
+
+//@ check-pass
+
+mod variant_enum_region {
+    struct Foo<'a> {
+        x: &'a i32,
+    }
+    enum Bar<'a, 'b> {
+        V(&'a Foo<'b>),
+    }
+}
+
+mod rev_variant_enum_region {
+    struct Foo<'a> {
+        x: fn(&'a i32),
+    }
+    enum Bar<'a, 'b> {
+        V(&'a Foo<'b>),
+    }
+}
+
+mod variant_enum_type {
+    struct Foo<T> {
+        x: T,
+    }
+    enum Bar<'a, 'b> {
+        V(&'a Foo<&'b i32>),
+    }
+}
+
+mod rev_variant_enum_type {
+    struct Foo<T> {
+        x: fn(T),
+    }
+    enum Bar<'a, 'b> {
+        V(&'a Foo<&'b i32>),
+    }
+}
+
+mod variant_struct_region {
+    struct Foo<'a> {
+        x: &'a i32,
+    }
+    struct Bar<'a, 'b> {
+        f: &'a Foo<'b>,
+    }
+}
+
+mod rev_variant_struct_region {
+    struct Foo<'a> {
+        x: fn(&'a i32),
+    }
+    struct Bar<'a, 'b> {
+        f: &'a Foo<'b>,
+    }
+}
+
+mod variant_struct_type {
+    struct Foo<T> {
+        x: T,
+    }
+    struct Bar<'a, 'b> {
+        f: &'a Foo<&'b i32>,
+    }
+}
+
+mod rev_variant_struct_type {
+    struct Foo<T> {
+        x: fn(T),
+    }
+    struct Bar<'a, 'b> {
+        f: &'a Foo<&'b i32>,
+    }
+}
+
+fn main() {}

From c8a2c46eda3d8a8cc0dbe92002543ab5867586a3 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Mon, 16 Mar 2026 14:33:39 +0100
Subject: [PATCH 0619/1059] bootstrap: Optionally print a backtrace if a
 command fails

---
 src/bootstrap/src/utils/exec.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index b264c961b659..f9b0d2dbb209 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -7,6 +7,7 @@
 //! relevant to command execution in the bootstrap process. This includes settings such as
 //! dry-run mode, verbosity level, and failure behavior.
 
+use std::backtrace::{Backtrace, BacktraceStatus};
 use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
 use std::fmt::{Debug, Formatter};
@@ -930,6 +931,16 @@ enum FailureReason {
             if stderr.captures() {
                 writeln!(error_message, "\n--- STDERR vvv\n{}", output.stderr().trim()).unwrap();
             }
+            let backtrace = if exec_ctx.verbosity > 1 {
+                Backtrace::force_capture()
+            } else if matches!(command.failure_behavior, BehaviorOnFailure::Ignore) {
+                Backtrace::disabled()
+            } else {
+                Backtrace::capture()
+            };
+            if matches!(backtrace.status(), BacktraceStatus::Captured) {
+                writeln!(error_message, "\n--- BACKTRACE vvv\n{backtrace}").unwrap();
+            }
 
             match command.failure_behavior {
                 BehaviorOnFailure::DelayFail => {

From e9c273e3775a04c70c0743f24601475de474b64d Mon Sep 17 00:00:00 2001
From: khyperia <953151+khyperia@users.noreply.github.com>
Date: Wed, 18 Mar 2026 11:48:09 +0100
Subject: [PATCH 0620/1059] Always check `ConstArgHasType` even when otherwise
 ignoring

---
 .../rustc_hir_analysis/src/check/check.rs     |  28 +++-
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  22 ++-
 .../rustc_trait_selection/src/traits/wf.rs    |  43 ++++-
 ..._const_arg_type_in_free_alias.eager.stderr | 133 +++++++++++++++
 ...k_const_arg_type_in_free_alias.lazy.stderr | 151 ++++++++++++++++++
 .../check_const_arg_type_in_free_alias.rs     |  67 ++++++++
 .../check_const_arg_type_in_trait_object.rs   |  36 +++++
 ...heck_const_arg_type_in_trait_object.stderr |  49 ++++++
 8 files changed, 524 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/const-generics/check_const_arg_type_in_free_alias.eager.stderr
 create mode 100644 tests/ui/const-generics/check_const_arg_type_in_free_alias.lazy.stderr
 create mode 100644 tests/ui/const-generics/check_const_arg_type_in_free_alias.rs
 create mode 100644 tests/ui/const-generics/check_const_arg_type_in_trait_object.rs
 create mode 100644 tests/ui/const-generics/check_const_arg_type_in_trait_object.stderr

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 32cfa3003eeb..06ccf61a1620 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -952,10 +952,10 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             tcx.ensure_ok().type_of(def_id);
             tcx.ensure_ok().predicates_of(def_id);
             check_type_alias_type_params_are_used(tcx, def_id);
+            let ty = tcx.type_of(def_id).instantiate_identity();
+            let span = tcx.def_span(def_id);
             if tcx.type_alias_is_lazy(def_id) {
                 res = res.and(enter_wf_checking_ctxt(tcx, def_id, |wfcx| {
-                    let ty = tcx.type_of(def_id).instantiate_identity();
-                    let span = tcx.def_span(def_id);
                     let item_ty = wfcx.deeply_normalize(span, Some(WellFormedLoc::Ty(def_id)), ty);
                     wfcx.register_wf_obligation(
                         span,
@@ -966,6 +966,30 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
                     Ok(())
                 }));
                 check_variances_for_type_defn(tcx, def_id);
+            } else {
+                res = res.and(enter_wf_checking_ctxt(tcx, def_id, |wfcx| {
+                    // HACK: We sometimes incidentally check that const arguments have the correct
+                    // type as a side effect of the anon const desugaring. To make this "consistent"
+                    // for users we explicitly check `ConstArgHasType` clauses so that const args
+                    // that don't go through an anon const still have their types checked.
+                    //
+                    // We use the unnormalized type as this mirrors the behaviour that we previously
+                    // would have had when all const arguments were anon consts.
+                    //
+                    // Changing this to normalized obligations is a breaking change:
+                    // `type Bar = [(); panic!()];` would become an error
+                    if let Some(unnormalized_obligations) = wfcx.unnormalized_obligations(span, ty)
+                    {
+                        let filtered_obligations =
+                            unnormalized_obligations.into_iter().filter(|o| {
+                                matches!(o.predicate.kind().skip_binder(),
+                                    ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, _))
+                                    if matches!(ct.kind(), ty::ConstKind::Param(..)))
+                            });
+                        wfcx.ocx.register_obligations(filtered_obligations)
+                    }
+                    Ok(())
+                }));
             }
 
             // Only `Node::Item` and `Node::ForeignItem` still have HIR based
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 5656c4566d9f..18363fa50d20 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -15,6 +15,7 @@
 use rustc_hir::{AmbigArg, ItemKind, find_attr};
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{self, InferCtxt, SubregionOrigin, TyCtxtInferExt};
+use rustc_infer::traits::PredicateObligations;
 use rustc_lint_defs::builtin::SHADOWING_SUPERTRAIT_ITEMS;
 use rustc_macros::Diagnostic;
 use rustc_middle::mir::interpret::ErrorHandled;
@@ -124,6 +125,20 @@ pub(super) fn register_wf_obligation(
             ty::ClauseKind::WellFormed(term),
         ));
     }
+
+    pub(super) fn unnormalized_obligations(
+        &self,
+        span: Span,
+        ty: Ty<'tcx>,
+    ) -> Option<PredicateObligations<'tcx>> {
+        traits::wf::unnormalized_obligations(
+            self.ocx.infcx,
+            self.param_env,
+            ty.into(),
+            span,
+            self.body_def_id,
+        )
+    }
 }
 
 pub(super) fn enter_wf_checking_ctxt<'tcx, F>(
@@ -140,7 +155,12 @@ pub(super) fn enter_wf_checking_ctxt<'tcx, F>(
 
     let mut wfcx = WfCheckingCtxt { ocx, body_def_id, param_env };
 
-    if !tcx.features().trivial_bounds() {
+    // As of now, bounds are only checked on lazy type aliases, they're ignored for most type
+    // aliases. So, only check for false global bounds if we're not ignoring bounds altogether.
+    let ignore_bounds =
+        tcx.def_kind(body_def_id) == DefKind::TyAlias && !tcx.type_alias_is_lazy(body_def_id);
+
+    if !ignore_bounds && !tcx.features().trivial_bounds() {
         wfcx.check_false_global_bounds()
     }
     f(&mut wfcx)?;
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 4a0a99ea2764..b8f5336115e1 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -942,14 +942,53 @@ fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
                 // FIXME(#27579) RFC also considers adding trait
                 // obligations that don't refer to Self and
                 // checking those
-                if let Some(principal) = data.principal_def_id() {
+                if let Some(principal) = data.principal() {
+                    let principal_def_id = principal.skip_binder().def_id;
                     self.out.push(traits::Obligation::with_depth(
                         tcx,
                         self.cause(ObligationCauseCode::WellFormed(None)),
                         self.recursion_depth,
                         self.param_env,
-                        ty::Binder::dummy(ty::PredicateKind::DynCompatible(principal)),
+                        ty::Binder::dummy(ty::PredicateKind::DynCompatible(principal_def_id)),
                     ));
+
+                    // For the most part we don't add wf predicates corresponding to
+                    // the trait ref's generic arguments which allows code like this
+                    // to compile:
+                    // ```rust
+                    // trait Trait<T: Sized> {}
+                    // fn foo(_: &dyn Trait<[u32]>) {}
+                    // ```
+                    //
+                    // However, we sometimes incidentally check that const arguments
+                    // have the correct type as a side effect of the anon const
+                    // desugaring. To make this "consistent" for users we explicitly
+                    // check `ConstArgHasType` clauses so that const args that don't
+                    // go through an anon const still have their types checked.
+                    //
+                    // See also: https://rustc-dev-guide.rust-lang.org/const-generics.html
+                    let args = principal.skip_binder().with_self_ty(self.tcx(), t).args;
+                    let obligations =
+                        self.nominal_obligations(principal_def_id, args).into_iter().filter(|o| {
+                            let kind = o.predicate.kind().skip_binder();
+                            match kind {
+                                ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(
+                                    ct,
+                                    _,
+                                )) if matches!(ct.kind(), ty::ConstKind::Param(..)) => {
+                                    // ConstArgHasType clauses are not higher kinded. Assert as
+                                    // such so we can fix this up if that ever changes.
+                                    assert!(o.predicate.kind().bound_vars().is_empty());
+                                    // In stable rust, variables from the trait object binder
+                                    // cannot be referenced by a ConstArgHasType clause. However,
+                                    // under `generic_const_parameter_types`, it can. Ignore those
+                                    // predicates for now, to not have HKT-ConstArgHasTypes.
+                                    !kind.has_escaping_bound_vars()
+                                }
+                                _ => false,
+                            }
+                        });
+                    self.out.extend(obligations);
                 }
 
                 if !t.has_escaping_bound_vars() {
diff --git a/tests/ui/const-generics/check_const_arg_type_in_free_alias.eager.stderr b/tests/ui/const-generics/check_const_arg_type_in_free_alias.eager.stderr
new file mode 100644
index 000000000000..f62023bd146b
--- /dev/null
+++ b/tests/ui/const-generics/check_const_arg_type_in_free_alias.eager.stderr
@@ -0,0 +1,133 @@
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:15:1
+   |
+LL | type ArrLen<const B: bool> = [(); B];
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:19:1
+   |
+LL | type ConstArg<const B: bool> = Foo<B>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Foo`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:32:1
+   |
+LL | type Alias<const B: bool> = <() as IdentityWithUnused<B>>::This;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `IdentityWithUnused`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:24:26
+   |
+LL | trait IdentityWithUnused<const N: usize> {
+   |                          ^^^^^^^^^^^^^^ required by this const generic parameter in `IdentityWithUnused`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:38:1
+   |
+LL | type UseFree<const B: bool> = Free<B>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:58:1
+   |
+LL | type IndirectArr<const B: bool> = Wrap<Wrap<[(); B]>>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:62:1
+   |
+LL | type IndirectConstArg<const B: bool> = Wrap<Wrap<Foo<B>>>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Foo`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:17:24
+   |
+LL | type AnonArrLen = [(); true];
+   |                        ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:21:25
+   |
+LL | type AnonConstArg = Foo<true>;
+   |                         ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:34:44
+   |
+LL | type AnonAlias = <() as IdentityWithUnused<true>>::This;
+   |                                            ^^^^ expected `usize`, found `bool`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:40:25
+   |
+LL | type AnonUseFree = Free<true>;
+   |                         ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:37:11
+   |
+LL | type Free<const N: usize> = [(); N];
+   |           ^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:53:45
+   |
+LL | type AnonUseFreeIndirectlyCorrect = UseFree<1_usize>;
+   |                                             ^^^^^^^ expected `bool`, found `usize`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:38:14
+   |
+LL | type UseFree<const B: bool> = Free<B>;
+   |              ^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:60:39
+   |
+LL | type AnonIndirectArr = Wrap<Wrap<[(); true]>>;
+   |                                       ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:64:43
+   |
+LL | type AnonIndirectConstArg = Wrap<Wrap<Foo<true>>>;
+   |                                           ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^
+
+error: aborting due to 13 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/check_const_arg_type_in_free_alias.lazy.stderr b/tests/ui/const-generics/check_const_arg_type_in_free_alias.lazy.stderr
new file mode 100644
index 000000000000..b9adb4e51e1a
--- /dev/null
+++ b/tests/ui/const-generics/check_const_arg_type_in_free_alias.lazy.stderr
@@ -0,0 +1,151 @@
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:15:1
+   |
+LL | type ArrLen<const B: bool> = [(); B];
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:17:24
+   |
+LL | type AnonArrLen = [(); true];
+   |                        ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:19:1
+   |
+LL | type ConstArg<const B: bool> = Foo<B>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Foo`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:21:25
+   |
+LL | type AnonConstArg = Foo<true>;
+   |                         ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:32:1
+   |
+LL | type Alias<const B: bool> = <() as IdentityWithUnused<B>>::This;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required for `()` to implement `IdentityWithUnused<B>`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:28:25
+   |
+LL | impl<T, const N: usize> IdentityWithUnused<N> for T {
+   |         --------------  ^^^^^^^^^^^^^^^^^^^^^     ^
+   |         |
+   |         unsatisfied trait bound introduced here
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:34:44
+   |
+LL | type AnonAlias = <() as IdentityWithUnused<true>>::This;
+   |                                            ^^^^ expected `usize`, found `bool`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:38:1
+   |
+LL | type UseFree<const B: bool> = Free<B>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a bound on the type alias `Free`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:37:11
+   |
+LL | type Free<const N: usize> = [(); N];
+   |           ^^^^^^^^^^^^^^ required by this bound
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:40:25
+   |
+LL | type AnonUseFree = Free<true>;
+   |                         ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:37:11
+   |
+LL | type Free<const N: usize> = [(); N];
+   |           ^^^^^^^^^^^^^^
+
+error: the constant `N` is not of type `bool`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:51:1
+   |
+LL | type UseFreeIndirectlyCorrect<const N: usize> = UseFree<N>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `usize`
+   |
+note: required by a bound on the type alias `UseFree`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:38:14
+   |
+LL | type UseFree<const B: bool> = Free<B>;
+   |              ^^^^^^^^^^^^^ required by this bound
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:53:45
+   |
+LL | type AnonUseFreeIndirectlyCorrect = UseFree<1_usize>;
+   |                                             ^^^^^^^ expected `bool`, found `usize`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:38:14
+   |
+LL | type UseFree<const B: bool> = Free<B>;
+   |              ^^^^^^^^^^^^^
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:58:1
+   |
+LL | type IndirectArr<const B: bool> = Wrap<Wrap<[(); B]>>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:60:39
+   |
+LL | type AnonIndirectArr = Wrap<Wrap<[(); true]>>;
+   |                                       ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:62:1
+   |
+LL | type IndirectConstArg<const B: bool> = Wrap<Wrap<Foo<B>>>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Foo`
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_free_alias.rs:64:43
+   |
+LL | type AnonIndirectConstArg = Wrap<Wrap<Foo<true>>>;
+   |                                           ^^^^ expected `usize`, found `bool`
+   |
+note: expected because of the type of the const parameter
+  --> $DIR/check_const_arg_type_in_free_alias.rs:13:12
+   |
+LL | struct Foo<const N: usize>;
+   |            ^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/check_const_arg_type_in_free_alias.rs b/tests/ui/const-generics/check_const_arg_type_in_free_alias.rs
new file mode 100644
index 000000000000..12e277f0c545
--- /dev/null
+++ b/tests/ui/const-generics/check_const_arg_type_in_free_alias.rs
@@ -0,0 +1,67 @@
+//@ revisions: eager lazy
+#![cfg_attr(lazy, feature(lazy_type_alias))]
+#![cfg_attr(lazy, expect(incomplete_features))]
+
+// We currently do not check free type aliases for well formedness.
+// However, previously we desugared all const arguments to anon
+// consts which resulted in us happening to check that they were
+// of the correct type. Nowadays we don't necessarily lower to a
+// const argument, but to continue erroring on such code we special
+// case `ConstArgHasType` clauses to be checked for free type aliases
+// even though we ignore the rest of the wf requirements.
+
+struct Foo<const N: usize>;
+
+type ArrLen<const B: bool> = [(); B];
+//~^ ERROR: the constant `B` is not of type
+type AnonArrLen = [(); true];
+//~^ ERROR: mismatched types
+type ConstArg<const B: bool> = Foo<B>;
+//~^ ERROR: the constant `B` is not of type
+type AnonConstArg = Foo<true>;
+//~^ ERROR: mismatched types
+
+trait IdentityWithUnused<const N: usize> {
+    type This;
+}
+
+impl<T, const N: usize> IdentityWithUnused<N> for T {
+    type This = T;
+}
+
+type Alias<const B: bool> = <() as IdentityWithUnused<B>>::This;
+//~^ ERROR: the constant `B` is not of type
+type AnonAlias = <() as IdentityWithUnused<true>>::This;
+//~^ ERROR: mismatched types
+
+type Free<const N: usize> = [(); N];
+type UseFree<const B: bool> = Free<B>;
+//~^ ERROR: the constant `B` is not of type
+type AnonUseFree = Free<true>;
+//~^ ERROR: mismatched types
+
+// This previously emitted an error before we stopped using
+// anon consts. Now, as free aliases don't exist after ty
+// lowering, we don't emit an error because we only see `N`
+// being used as an argument to an array length.
+//
+// Free type aliases are not allowed to have unused generic
+// parameters so this shouldn't be able to cause code to
+// pass that should error.
+type UseFreeIndirectlyCorrect<const N: usize> = UseFree<N>;
+//[lazy]~^ ERROR: the constant `N` is not of type
+type AnonUseFreeIndirectlyCorrect = UseFree<1_usize>;
+//~^ ERROR: mismatched types
+
+struct Wrap<T>(T);
+
+type IndirectArr<const B: bool> = Wrap<Wrap<[(); B]>>;
+//~^ ERROR: the constant `B` is not of type
+type AnonIndirectArr = Wrap<Wrap<[(); true]>>;
+//~^ ERROR: mismatched types
+type IndirectConstArg<const B: bool> = Wrap<Wrap<Foo<B>>>;
+//~^ ERROR: the constant `B` is not of type
+type AnonIndirectConstArg = Wrap<Wrap<Foo<true>>>;
+//~^ ERROR: mismatched types
+
+fn main() {}
diff --git a/tests/ui/const-generics/check_const_arg_type_in_trait_object.rs b/tests/ui/const-generics/check_const_arg_type_in_trait_object.rs
new file mode 100644
index 000000000000..f5c5350194b7
--- /dev/null
+++ b/tests/ui/const-generics/check_const_arg_type_in_trait_object.rs
@@ -0,0 +1,36 @@
+// We currently do not check trait objects for well formedness.
+// However, previously we desugared all const arguments to anon
+// consts which resulted in us happening to check that they were
+// of the correct type. Nowadays we don't necessarily lower to a
+// const argument, but to continue erroring on such code we special
+// case `ConstArgHasType` clauses to be checked for trait objects
+// even though we ignore the rest of the wf requirements.
+
+trait Object<const N: usize> {}
+trait Object2<T> {}
+trait Object3<'a: 'static, const N: usize> {}
+
+struct Wrap<T>(T);
+
+fn arg<const B: bool, const N: usize>(
+    param: &dyn Object<B>,
+    //~^ ERROR: the constant `B` is not of type
+    anon: &dyn Object<true>,
+    //~^ ERROR: mismatched types
+) {
+}
+
+fn indirect<const B: bool, const N: usize>(
+    param: &dyn Object2<Wrap<[(); B]>>,
+    //~^ ERROR: the constant `B` is not of type
+    anon: &dyn Object2<Wrap<[(); true]>>,
+    //~^ ERROR: mismatched types
+) {
+}
+
+// the 'a: 'static bound should *not* have its error reported (at least, until we implement checking
+// all wf things for dyn objects)
+fn binder<const B: bool>(param: &dyn for<'a> Object3<'a, B>) {}
+//~^ ERROR: the constant `B` is not of type
+
+fn main() {}
diff --git a/tests/ui/const-generics/check_const_arg_type_in_trait_object.stderr b/tests/ui/const-generics/check_const_arg_type_in_trait_object.stderr
new file mode 100644
index 000000000000..4e228f65ab6d
--- /dev/null
+++ b/tests/ui/const-generics/check_const_arg_type_in_trait_object.stderr
@@ -0,0 +1,49 @@
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_trait_object.rs:18:23
+   |
+LL |     anon: &dyn Object<true>,
+   |                       ^^^^ expected `usize`, found `bool`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_trait_object.rs:16:12
+   |
+LL |     param: &dyn Object<B>,
+   |            ^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Object`
+  --> $DIR/check_const_arg_type_in_trait_object.rs:9:14
+   |
+LL | trait Object<const N: usize> {}
+   |              ^^^^^^^^^^^^^^ required by this const generic parameter in `Object`
+
+error[E0308]: mismatched types
+  --> $DIR/check_const_arg_type_in_trait_object.rs:26:34
+   |
+LL |     anon: &dyn Object2<Wrap<[(); true]>>,
+   |                                  ^^^^ expected `usize`, found `bool`
+   |
+   = note: array length can only be `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_trait_object.rs:24:12
+   |
+LL |     param: &dyn Object2<Wrap<[(); B]>>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+   = note: the length of array `[(); B]` must be type `usize`
+
+error: the constant `B` is not of type `usize`
+  --> $DIR/check_const_arg_type_in_trait_object.rs:33:33
+   |
+LL | fn binder<const B: bool>(param: &dyn for<'a> Object3<'a, B>) {}
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `Object3`
+  --> $DIR/check_const_arg_type_in_trait_object.rs:11:28
+   |
+LL | trait Object3<'a: 'static, const N: usize> {}
+   |                            ^^^^^^^^^^^^^^ required by this const generic parameter in `Object3`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

From a4d23841001ace656ed84df9792f257830f44fa3 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Wed, 18 Mar 2026 12:21:09 +0100
Subject: [PATCH 0621/1059] Move hashes into a separate json file

---
 src/bootstrap/src/core/build_steps/setup.rs   | 66 ++++---------------
 .../src/core/build_steps/setup/hashes.json    | 53 +++++++++++++++
 .../src/core/build_steps/setup/tests.rs       | 10 ++-
 3 files changed, 69 insertions(+), 60 deletions(-)
 create mode 100644 src/bootstrap/src/core/build_steps/setup/hashes.json

diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index f4e6a20ec849..1854637fc93b 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -12,7 +12,10 @@
 use std::path::{MAIN_SEPARATOR_STR, Path, PathBuf};
 use std::str::FromStr;
 use std::{fmt, fs, io};
+use std::collections::HashMap;
+use std::sync::LazyLock;
 
+use serde_derive::Deserialize;
 use sha2::Digest;
 
 use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
@@ -529,7 +532,8 @@ fn install_git_hook_maybe(builder: &Builder<'_>, config: &Config) -> io::Result<
 }
 
 /// Handles editor-specific setup differences
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Deserialize)]
+#[serde(rename_all = "lowercase")]
 enum EditorKind {
     Emacs,
     Helix,
@@ -588,59 +592,13 @@ fn prompt_user() -> io::Result<Option<EditorKind>> {
     /// New entries should be appended whenever this is updated so we can detect
     /// outdated vs. user-modified settings files.
     fn hashes(&self) -> &'static [&'static str] {
-        match self {
-            EditorKind::Emacs => &[
-                "51068d4747a13732440d1a8b8f432603badb1864fa431d83d0fd4f8fa57039e0",
-                "d29af4d949bbe2371eac928a3c31cf9496b1701aa1c45f11cd6c759865ad5c45",
-                "b5dd299b93dca3ceeb9b335f929293cb3d4bf4977866fbe7ceeac2a8a9f99088",
-                "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
-                "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
-                "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
-                "54bc48fe1996177f5eef86d7231b33978e6d8b737cb0a899e622b7e975c95308",
-                "08d30e455ceec6e01d9bcef8b9449f2ddd14d278ca8627cdad90e02d9f44e938",
-            ],
-            EditorKind::Helix => &[
-                "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
-                "6736d61409fbebba0933afd2e4c44ff2f97c1cb36cf0299a7f4a7819b8775040",
-                "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
-                "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
-                "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
-                "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
-                "cb653043852d9d5ff4a5be56407b859ff9928be055ad3f307eb309aad04765e6",
-                "e28b1930d16d3d8bbdeed7bd4a995613e648b49e08c9b6f5271880f520637fed",
-            ],
-            EditorKind::Vim | EditorKind::VsCode => &[
-                "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
-                "56e7bf011c71c5d81e0bf42e84938111847a810eee69d906bba494ea90b51922",
-                "af1b5efe196aed007577899db9dae15d6dbc923d6fa42fa0934e68617ba9bbe0",
-                "3468fea433c25fff60be6b71e8a215a732a7b1268b6a83bf10d024344e140541",
-                "47d227f424bf889b0d899b9cc992d5695e1b78c406e183cd78eafefbe5488923",
-                "b526bd58d0262dd4dda2bff5bc5515b705fb668a46235ace3e057f807963a11a",
-                "828666b021d837a33e78d870b56d34c88a5e2c85de58b693607ec574f0c27000",
-                "811fb3b063c739d261fd8590dd30242e117908f5a095d594fa04585daa18ec4d",
-                "4eecb58a2168b252077369da446c30ed0e658301efe69691979d1ef0443928f4",
-                "c394386e6133bbf29ffd32c8af0bb3d4aac354cba9ee051f29612aa9350f8f8d",
-                "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
-                "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
-                "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
-                "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
-                "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
-                "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
-                "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
-                "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd",
-            ],
-            EditorKind::Zed => &[
-                "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
-                "a5380cf5dd9328731aecc5dfb240d16dac46ed272126b9728006151ef42f5909",
-                "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
-                "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
-                "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
-                "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
-                "74420c13094b530a986b37c4f1d23cb58c0e8e2295f5858ded129fb1574e66f9",
-                "2d3b592c089b2ad2c528686a1e371af49922edad1c59accd5d5f31612a441568",
-                "0767a2398ccc253274b184adbb9e018ce931bd0ef45baad06dad19b652c52951",
-            ],
-        }
+        const ALL_HASHES: &str = include_str!("setup/hashes.json");
+        static PARSED_HASHES: LazyLock<HashMap<EditorKind, Vec<&'static str>>> = LazyLock::new(|| {
+            let mut map: HashMap<_, Vec<_>> = serde_json::from_str(ALL_HASHES).unwrap();
+            map.insert(EditorKind::Vim, map.get(&EditorKind::VsCode).unwrap().clone());
+            map
+        });
+        &*PARSED_HASHES.get(self).unwrap()
     }
 
     fn settings_path(&self, config: &Config) -> PathBuf {
diff --git a/src/bootstrap/src/core/build_steps/setup/hashes.json b/src/bootstrap/src/core/build_steps/setup/hashes.json
new file mode 100644
index 000000000000..be657b577200
--- /dev/null
+++ b/src/bootstrap/src/core/build_steps/setup/hashes.json
@@ -0,0 +1,53 @@
+{
+    "emacs": [
+        "51068d4747a13732440d1a8b8f432603badb1864fa431d83d0fd4f8fa57039e0",
+        "d29af4d949bbe2371eac928a3c31cf9496b1701aa1c45f11cd6c759865ad5c45",
+        "b5dd299b93dca3ceeb9b335f929293cb3d4bf4977866fbe7ceeac2a8a9f99088",
+        "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
+        "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
+        "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
+        "54bc48fe1996177f5eef86d7231b33978e6d8b737cb0a899e622b7e975c95308",
+        "08d30e455ceec6e01d9bcef8b9449f2ddd14d278ca8627cdad90e02d9f44e938"
+    ],
+    "helix": [
+        "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
+        "6736d61409fbebba0933afd2e4c44ff2f97c1cb36cf0299a7f4a7819b8775040",
+        "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
+        "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
+        "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
+        "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
+        "cb653043852d9d5ff4a5be56407b859ff9928be055ad3f307eb309aad04765e6",
+        "e28b1930d16d3d8bbdeed7bd4a995613e648b49e08c9b6f5271880f520637fed"
+    ],
+    "vscode": [
+        "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
+        "56e7bf011c71c5d81e0bf42e84938111847a810eee69d906bba494ea90b51922",
+        "af1b5efe196aed007577899db9dae15d6dbc923d6fa42fa0934e68617ba9bbe0",
+        "3468fea433c25fff60be6b71e8a215a732a7b1268b6a83bf10d024344e140541",
+        "47d227f424bf889b0d899b9cc992d5695e1b78c406e183cd78eafefbe5488923",
+        "b526bd58d0262dd4dda2bff5bc5515b705fb668a46235ace3e057f807963a11a",
+        "828666b021d837a33e78d870b56d34c88a5e2c85de58b693607ec574f0c27000",
+        "811fb3b063c739d261fd8590dd30242e117908f5a095d594fa04585daa18ec4d",
+        "4eecb58a2168b252077369da446c30ed0e658301efe69691979d1ef0443928f4",
+        "c394386e6133bbf29ffd32c8af0bb3d4aac354cba9ee051f29612aa9350f8f8d",
+        "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
+        "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
+        "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
+        "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
+        "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
+        "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
+        "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
+        "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd"
+    ],
+    "zed": [
+        "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
+        "a5380cf5dd9328731aecc5dfb240d16dac46ed272126b9728006151ef42f5909",
+        "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
+        "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
+        "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
+        "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
+        "74420c13094b530a986b37c4f1d23cb58c0e8e2295f5858ded129fb1574e66f9",
+        "2d3b592c089b2ad2c528686a1e371af49922edad1c59accd5d5f31612a441568",
+        "0767a2398ccc253274b184adbb9e018ce931bd0ef45baad06dad19b652c52951"
+    ]
+}
diff --git a/src/bootstrap/src/core/build_steps/setup/tests.rs b/src/bootstrap/src/core/build_steps/setup/tests.rs
index e8f83ff75e40..6eafbb40b467 100644
--- a/src/bootstrap/src/core/build_steps/setup/tests.rs
+++ b/src/bootstrap/src/core/build_steps/setup/tests.rs
@@ -8,13 +8,11 @@ fn check_matching_settings_hash() {
     for editor in EditorKind::ALL {
         let mut hasher = sha2::Sha256::new();
         hasher.update(&editor.settings_template());
-        let hash = hex_encode(hasher.finalize().as_slice());
+        let actual = hex_encode(hasher.finalize().as_slice());
+        let expected = *editor.hashes().last().unwrap();
         assert_eq!(
-            &hash,
-            editor.hashes().last().unwrap(),
-            "Update `EditorKind::hashes()` with the new hash of `{}` for `EditorKind::{:?}`",
-            editor.settings_template(),
-            editor,
+            expected, actual,
+            "Update `setup/hashes.json` with the new hash of `{actual}` for `EditorKind::{editor:?}`",
         );
     }
 }

From 9d9f68f52769edef5710ded13d80b3e2fe7a0dfe Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 18 Mar 2026 19:33:05 +0800
Subject: [PATCH 0622/1059] fix: .let no complete semicolon before semicolon

Make `.let` `.letm` `.return` `.break` not duplicate semicolons

Example
---
```rust
fn main() {
    baz.l$0;
}
```

**Before this PR**

```rust
fn main() {
    let $0 = baz;;
}
```

**After this PR**

```rust
fn main() {
    let $0 = baz;
}
```
---
 .../ide-completion/src/completions/postfix.rs | 79 ++++++++++++++-----
 1 file changed, 59 insertions(+), 20 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
index 5ff0cdc7952b..d85f23e0848d 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
@@ -66,6 +66,12 @@ pub(crate) fn complete_postfix(
         Some(it) => it,
         None => return,
     };
+    let semi =
+        if expr_ctx.in_block_expr && ctx.token.next_token().is_none_or(|it| it.kind() != T![;]) {
+            ";"
+        } else {
+            ""
+        };
 
     let cfg = ctx.config.find_path_config(ctx.is_nightly);
 
@@ -151,9 +157,9 @@ pub(crate) fn complete_postfix(
                     .add_to(acc, ctx.db);
             }
             _ if matches!(parent.kind(), STMT_LIST | EXPR_STMT) => {
-                postfix_snippet("let", "let", &format!("let $0 = {receiver_text};"))
+                postfix_snippet("let", "let", &format!("let $0 = {receiver_text}{semi}"))
                     .add_to(acc, ctx.db);
-                postfix_snippet("letm", "let mut", &format!("let mut $0 = {receiver_text};"))
+                postfix_snippet("letm", "let mut", &format!("let mut $0 = {receiver_text}{semi}"))
                     .add_to(acc, ctx.db);
             }
             _ if ast::MatchArm::can_cast(parent.kind()) => {
@@ -307,26 +313,12 @@ pub(crate) fn complete_postfix(
         add_format_like_completions(acc, ctx, &dot_receiver_including_refs, cap, &literal_text);
     }
 
-    postfix_snippet(
-        "return",
-        "return expr",
-        &format!(
-            "return {receiver_text}{semi}",
-            semi = if expr_ctx.in_block_expr { ";" } else { "" }
-        ),
-    )
-    .add_to(acc, ctx.db);
+    postfix_snippet("return", "return expr", &format!("return {receiver_text}{semi}"))
+        .add_to(acc, ctx.db);
 
     if let Some(BreakableKind::Block | BreakableKind::Loop) = expr_ctx.in_breakable {
-        postfix_snippet(
-            "break",
-            "break expr",
-            &format!(
-                "break {receiver_text}{semi}",
-                semi = if expr_ctx.in_block_expr { ";" } else { "" }
-            ),
-        )
-        .add_to(acc, ctx.db);
+        postfix_snippet("break", "break expr", &format!("break {receiver_text}{semi}"))
+            .add_to(acc, ctx.db);
     }
 }
 
@@ -664,6 +656,22 @@ fn main() {
 
     #[test]
     fn let_middle_block() {
+        check_edit(
+            "let",
+            r#"
+fn main() {
+    baz.l$0
+    res
+}
+"#,
+            r#"
+fn main() {
+    let $0 = baz;
+    res
+}
+"#,
+        );
+
         check(
             r#"
 fn main() {
@@ -720,6 +728,20 @@ fn main() {
 
     #[test]
     fn let_tail_block() {
+        check_edit(
+            "let",
+            r#"
+fn main() {
+    baz.l$0
+}
+"#,
+            r#"
+fn main() {
+    let $0 = baz;
+}
+"#,
+        );
+
         check(
             r#"
 fn main() {
@@ -773,6 +795,23 @@ fn main() {
         );
     }
 
+    #[test]
+    fn let_before_semicolon() {
+        check_edit(
+            "let",
+            r#"
+fn main() {
+    baz.l$0;
+}
+"#,
+            r#"
+fn main() {
+    let $0 = baz;
+}
+"#,
+        );
+    }
+
     #[test]
     fn option_iflet() {
         check_edit(

From 986a28064468549727952e290d4eb062b17c68d2 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 18 Mar 2026 15:04:47 +0100
Subject: [PATCH 0623/1059] simd_fmin/fmax: make semantics and name consistent
 with scalar intrinsics

---
 .../example/float-minmax-pass.rs              | 16 +++++-----
 .../src/intrinsics/simd.rs                    | 10 +++++--
 compiler/rustc_codegen_cranelift/src/num.rs   |  4 +--
 compiler/rustc_codegen_gcc/src/builder.rs     | 11 ++++---
 .../rustc_codegen_gcc/src/intrinsic/simd.rs   |  4 +--
 compiler/rustc_codegen_llvm/src/builder.rs    | 12 +++++---
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  4 +--
 .../src/interpret/intrinsics/simd.rs          |  8 ++---
 .../rustc_hir_analysis/src/check/intrinsic.rs |  4 +--
 compiler/rustc_span/src/symbol.rs             |  4 +--
 library/core/src/intrinsics/simd.rs           | 16 +++++++---
 .../crates/core_simd/src/simd/num/float.rs    |  4 +--
 .../crates/core_arch/src/nvptx/packed.rs      |  4 +--
 .../stdarch/crates/core_arch/src/x86/sse.rs   | 14 ++++-----
 src/tools/miri/tests/pass/float_nan.rs        |  4 +--
 .../tests/pass/intrinsics/portable-simd.rs    | 16 +++++-----
 .../simd-intrinsic-float-minmax.rs            | 10 +++----
 tests/ui/simd/intrinsic/float-minmax-pass.rs  | 29 +++++++++----------
 18 files changed, 95 insertions(+), 79 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs b/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
index b7491b7e522f..206c56e887c7 100644
--- a/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
+++ b/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
@@ -33,24 +33,24 @@ fn main() {
     let n = f32x4([nan, nan, nan, nan]);
 
     unsafe {
-        let min0 = simd_fmin(x, y);
-        let min1 = simd_fmin(y, x);
+        let min0 = simd_minimum_number_nsz(x, y);
+        let min1 = simd_minimum_number_nsz(y, x);
         assert_eq!(min0.into_array(), min1.into_array());
         let e = f32x4([1.0, 1.0, 3.0, 3.0]);
         assert_eq!(min0.into_array(), e.into_array());
-        let minn = simd_fmin(x, n);
+        let minn = simd_minimum_number_nsz(x, n);
         assert_eq!(minn.into_array(), x.into_array());
-        let minn = simd_fmin(y, n);
+        let minn = simd_minimum_number_nsz(y, n);
         assert_eq!(minn.into_array(), y.into_array());
 
-        let max0 = simd_fmax(x, y);
-        let max1 = simd_fmax(y, x);
+        let max0 = simd_maximum_number_nsz(x, y);
+        let max1 = simd_maximum_number_nsz(y, x);
         assert_eq!(max0.into_array(), max1.into_array());
         let e = f32x4([2.0, 2.0, 4.0, 4.0]);
         assert_eq!(max0.into_array(), e.into_array());
-        let maxn = simd_fmax(x, n);
+        let maxn = simd_maximum_number_nsz(x, n);
         assert_eq!(maxn.into_array(), x.into_array());
-        let maxn = simd_fmax(y, n);
+        let maxn = simd_maximum_number_nsz(y, n);
         assert_eq!(maxn.into_array(), y.into_array());
     }
 }
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index 200cedf0f6ae..cc2311a67b5d 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -493,7 +493,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             }
         }
 
-        sym::simd_fmin | sym::simd_fmax => {
+        sym::simd_minimum_number_nsz | sym::simd_maximum_number_nsz => {
             intrinsic_args!(fx, args => (x, y); intrinsic);
 
             if !x.layout().ty.is_simd() {
@@ -508,8 +508,12 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                     _ => unreachable!("{:?}", lane_ty),
                 }
                 match intrinsic {
-                    sym::simd_fmin => crate::num::codegen_float_min(fx, x_lane, y_lane),
-                    sym::simd_fmax => crate::num::codegen_float_max(fx, x_lane, y_lane),
+                    sym::simd_minimum_number_nsz => {
+                        crate::num::codegen_float_min(fx, x_lane, y_lane)
+                    }
+                    sym::simd_maximum_number_nsz => {
+                        crate::num::codegen_float_max(fx, x_lane, y_lane)
+                    }
                     _ => unreachable!(),
                 }
             });
diff --git a/compiler/rustc_codegen_cranelift/src/num.rs b/compiler/rustc_codegen_cranelift/src/num.rs
index 0459644e16aa..e583f3f2f754 100644
--- a/compiler/rustc_codegen_cranelift/src/num.rs
+++ b/compiler/rustc_codegen_cranelift/src/num.rs
@@ -500,8 +500,8 @@ fn codegen_ptr_binop<'tcx>(
 
 // In Rust floating point min and max don't propagate NaN (not even SNaN). In Cranelift they do
 // however. For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for
-// `minnumf*` and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by
-// comparing a float against itself. Only in case of NaN is it not equal to itself.
+// `minimum_number_nsz` and `a.is_nan() ? b : (a <= b ? b : a)` for `maximum_number_nsz`. NaN checks
+// are done by comparing a float against itself. Only in case of NaN is it not equal to itself.
 pub(crate) fn codegen_float_min(fx: &mut FunctionCx<'_, '_, '_>, a: Value, b: Value) -> Value {
     // FIXME(bytecodealliance/wasmtime#8312): Replace with Cranelift `fcmp` once
     // `f16`/`f128` backend lowerings have been added to Cranelift.
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 6add7f05c2ab..3eb0fd95284a 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -2278,6 +2278,8 @@ pub fn vector_reduce_max(&mut self, src: RValue<'gcc>) -> RValue<'gcc> {
         })
     }
 
+    /// Emits a SIMD min/max operation for floats. The semantics for each lane are: if one
+    /// side is NaN (QNaN or SNaN), the other side is returned.
     fn vector_extremum(
         &mut self,
         a: RValue<'gcc>,
@@ -2286,8 +2288,9 @@ fn vector_extremum(
     ) -> RValue<'gcc> {
         let vector_type = a.get_type();
 
-        // mask out the NaNs in b and replace them with the corresponding lane in a, so when a and
-        // b get compared & spliced together, we get the numeric values instead of NaNs.
+        // Mask out the NaNs (both QNaN and SNaN) in b and replace them with the corresponding lane
+        // in a, so when a and b get compared & spliced together, we get the numeric values instead
+        // of NaNs.
         let b_nan_mask = self.context.new_comparison(self.location, ComparisonOp::NotEquals, b, b);
         let mask_type = b_nan_mask.get_type();
         let b_nan_mask_inverted =
@@ -2309,7 +2312,7 @@ fn vector_extremum(
         self.context.new_bitcast(self.location, res, vector_type)
     }
 
-    pub fn vector_fmin(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
+    pub fn vector_minimum_number_nsz(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
         self.vector_extremum(a, b, ExtremumOperation::Min)
     }
 
@@ -2341,7 +2344,7 @@ pub fn vector_reduce_fmin(&mut self, _src: RValue<'gcc>) -> RValue<'gcc> {
         unimplemented!();
     }
 
-    pub fn vector_fmax(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
+    pub fn vector_maximum_number_nsz(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
         self.vector_extremum(a, b, ExtremumOperation::Max)
     }
 
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index 1263b2285a8d..06254fcb180b 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -1222,8 +1222,8 @@ fn non_ptr(t: Ty<'_>) -> Ty<'_> {
         simd_and: Uint, Int => and;
         simd_or: Uint, Int => or; // FIXME(antoyo): calling `or` might not work on vectors.
         simd_xor: Uint, Int => xor;
-        simd_fmin: Float => vector_fmin;
-        simd_fmax: Float => vector_fmax;
+        simd_minimum_number_nsz: Float => vector_minimum_number_nsz;
+        simd_maximum_number_nsz: Float => vector_maximum_number_nsz;
     }
 
     macro_rules! arith_unary {
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 2d91caf40f3c..f3508c10d1f6 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1605,12 +1605,16 @@ fn write_operand_repeatedly_unoptimized(
         *self = Self::build(self.cx, next_bb);
     }
 
-    pub(crate) fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        self.call_intrinsic("llvm.minnum", &[self.val_ty(lhs)], &[lhs, rhs])
+    pub(crate) fn minimum_number_nsz(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+        let call = self.call_intrinsic("llvm.minimumnum", &[self.val_ty(lhs)], &[lhs, rhs]);
+        unsafe { llvm::LLVMRustSetNoSignedZeros(call) };
+        call
     }
 
-    pub(crate) fn maxnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        self.call_intrinsic("llvm.maxnum", &[self.val_ty(lhs)], &[lhs, rhs])
+    pub(crate) fn maximum_number_nsz(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+        let call = self.call_intrinsic("llvm.maximumnum", &[self.val_ty(lhs)], &[lhs, rhs]);
+        unsafe { llvm::LLVMRustSetNoSignedZeros(call) };
+        call
     }
 
     pub(crate) fn insert_element(
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index cc6ecee60b0e..8bf2be52ce88 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -2770,8 +2770,8 @@ macro_rules! arith_binary {
         simd_and: Uint, Int => and;
         simd_or: Uint, Int => or;
         simd_xor: Uint, Int => xor;
-        simd_fmax: Float => maxnum;
-        simd_fmin: Float => minnum;
+        simd_maximum_number_nsz: Float => maximum_number_nsz;
+        simd_minimum_number_nsz: Float => minimum_number_nsz;
 
     }
     macro_rules! arith_unary {
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
index c47c512025c0..d6cfc559e0df 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
@@ -174,8 +174,8 @@ enum Op {
             | sym::simd_le
             | sym::simd_gt
             | sym::simd_ge
-            | sym::simd_fmax
-            | sym::simd_fmin
+            | sym::simd_maximum_number_nsz
+            | sym::simd_minimum_number_nsz
             | sym::simd_saturating_add
             | sym::simd_saturating_sub
             | sym::simd_arith_offset => {
@@ -211,8 +211,8 @@ enum Op {
                     sym::simd_le => Op::MirOp(BinOp::Le),
                     sym::simd_gt => Op::MirOp(BinOp::Gt),
                     sym::simd_ge => Op::MirOp(BinOp::Ge),
-                    sym::simd_fmax => Op::FMinMax(MinMax::MaximumNumberNsz),
-                    sym::simd_fmin => Op::FMinMax(MinMax::MinimumNumberNsz),
+                    sym::simd_maximum_number_nsz => Op::FMinMax(MinMax::MaximumNumberNsz),
+                    sym::simd_minimum_number_nsz => Op::FMinMax(MinMax::MinimumNumberNsz),
                     sym::simd_saturating_add => Op::SaturatingOp(BinOp::Add),
                     sym::simd_saturating_sub => Op::SaturatingOp(BinOp::Sub),
                     sym::simd_arith_offset => Op::WrappingOffset,
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 47420997a509..3f9869920874 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -726,8 +726,8 @@ pub(crate) fn check_intrinsic_type(
         | sym::simd_and
         | sym::simd_or
         | sym::simd_xor
-        | sym::simd_fmin
-        | sym::simd_fmax
+        | sym::simd_minimum_number_nsz
+        | sym::simd_maximum_number_nsz
         | sym::simd_saturating_add
         | sym::simd_saturating_sub
         | sym::simd_carryless_mul => (1, 0, vec![param(0), param(0)], param(0)),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 286fea7d9050..3b10b8bcda2d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1850,8 +1850,6 @@
         simd_flog10,
         simd_floor,
         simd_fma,
-        simd_fmax,
-        simd_fmin,
         simd_fsin,
         simd_fsqrt,
         simd_funnel_shl,
@@ -1865,6 +1863,8 @@
         simd_lt,
         simd_masked_load,
         simd_masked_store,
+        simd_maximum_number_nsz,
+        simd_minimum_number_nsz,
         simd_mul,
         simd_ne,
         simd_neg,
diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
index 5fb2102c319e..e5a53b3a25d3 100644
--- a/library/core/src/intrinsics/simd.rs
+++ b/library/core/src/intrinsics/simd.rs
@@ -250,19 +250,27 @@
 ///
 /// `T` must be a vector of floating-point primitive types.
 ///
-/// Follows IEEE-754 `minNum` semantics.
+/// This behaves like IEEE 754-2019 minimumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular, for each vector lane:
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
+/// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
+/// and `-0.0`), either input may be returned non-deterministically.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn simd_fmin<T>(x: T, y: T) -> T;
+pub const unsafe fn simd_minimum_number_nsz<T>(x: T, y: T) -> T;
 
 /// Returns the maximum of two vectors, elementwise.
 ///
 /// `T` must be a vector of floating-point primitive types.
 ///
-/// Follows IEEE-754 `maxNum` semantics.
+/// This behaves like IEEE 754-2019 maximumNumber, *except* that it does not order signed
+/// zeros deterministically. In particular, for each vector lane:
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If
+/// both arguments are NaN, returns NaN. If the inputs compare equal (such as for the case of `+0.0`
+/// and `-0.0`), either input may be returned non-deterministically.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn simd_fmax<T>(x: T, y: T) -> T;
+pub const unsafe fn simd_maximum_number_nsz<T>(x: T, y: T) -> T;
 
 /// Tests elementwise equality of two vectors.
 ///
diff --git a/library/portable-simd/crates/core_simd/src/simd/num/float.rs b/library/portable-simd/crates/core_simd/src/simd/num/float.rs
index efd7c2469512..175cbce4f58b 100644
--- a/library/portable-simd/crates/core_simd/src/simd/num/float.rs
+++ b/library/portable-simd/crates/core_simd/src/simd/num/float.rs
@@ -385,13 +385,13 @@ fn copysign(self, sign: Self) -> Self {
             #[inline]
             fn simd_min(self, other: Self) -> Self {
                 // Safety: `self` and `other` are float vectors
-                unsafe { core::intrinsics::simd::simd_fmin(self, other) }
+                unsafe { core::intrinsics::simd::simd_minimum_number_nsz(self, other) }
             }
 
             #[inline]
             fn simd_max(self, other: Self) -> Self {
                 // Safety: `self` and `other` are floating point vectors
-                unsafe { core::intrinsics::simd::simd_fmax(self, other) }
+                unsafe { core::intrinsics::simd::simd_maximum_number_nsz(self, other) }
             }
 
             #[inline]
diff --git a/library/stdarch/crates/core_arch/src/nvptx/packed.rs b/library/stdarch/crates/core_arch/src/nvptx/packed.rs
index 856aeea4b686..1c7e81268fc9 100644
--- a/library/stdarch/crates/core_arch/src/nvptx/packed.rs
+++ b/library/stdarch/crates/core_arch/src/nvptx/packed.rs
@@ -99,7 +99,7 @@ pub unsafe fn f16x2_neg(a: f16x2) -> f16x2 {
 #[cfg_attr(test, assert_instr(min.f16x2))]
 #[unstable(feature = "stdarch_nvptx", issue = "111199")]
 pub unsafe fn f16x2_min(a: f16x2, b: f16x2) -> f16x2 {
-    simd_fmin(a, b)
+    simd_minimum_number_nsz(a, b)
 }
 
 /// Find the minimum of two values, NaNs pass through.
@@ -123,7 +123,7 @@ pub unsafe fn f16x2_min_nan(a: f16x2, b: f16x2) -> f16x2 {
 #[cfg_attr(test, assert_instr(max.f16x2))]
 #[unstable(feature = "stdarch_nvptx", issue = "111199")]
 pub unsafe fn f16x2_max(a: f16x2, b: f16x2) -> f16x2 {
-    simd_fmax(a, b)
+    simd_maximum_number_nsz(a, b)
 }
 
 /// Find the maximum of two values, NaNs pass through.
diff --git a/library/stdarch/crates/core_arch/src/x86/sse.rs b/library/stdarch/crates/core_arch/src/x86/sse.rs
index 3f7781cc7dc4..9183eabd530c 100644
--- a/library/stdarch/crates/core_arch/src/x86/sse.rs
+++ b/library/stdarch/crates/core_arch/src/x86/sse.rs
@@ -208,7 +208,7 @@ pub fn _mm_min_ss(a: __m128, b: __m128) -> __m128 {
 #[cfg_attr(test, assert_instr(minps))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub fn _mm_min_ps(a: __m128, b: __m128) -> __m128 {
-    // See the `test_mm_min_ps` test why this can't be implemented using `simd_fmin`.
+    // See the `test_mm_min_ps` test why this can't be implemented using `simd_minimum_number_nsz`.
     unsafe { minps(a, b) }
 }
 
@@ -234,7 +234,7 @@ pub fn _mm_max_ss(a: __m128, b: __m128) -> __m128 {
 #[cfg_attr(test, assert_instr(maxps))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub fn _mm_max_ps(a: __m128, b: __m128) -> __m128 {
-    // See the `test_mm_min_ps` test why this can't be implemented using `simd_fmax`.
+    // See the `test_mm_min_ps` test why this can't be implemented using `simd_maximum_number_nsz`.
     unsafe { maxps(a, b) }
 }
 
@@ -2227,11 +2227,11 @@ fn test_mm_min_ps() {
         let r = _mm_min_ps(a, b);
         assert_eq_m128(r, _mm_setr_ps(-100.0, 5.0, 0.0, -10.0));
 
-        // `_mm_min_ps` can **not** be implemented using the `simd_min` rust intrinsic. `simd_min`
-        // is lowered by the llvm codegen backend to `llvm.minnum.v*` llvm intrinsic. This intrinsic
-        // doesn't specify how -0.0 is handled. Unfortunately it happens to behave different from
-        // the `minps` x86 instruction on x86. The `llvm.minnum.v*` llvm intrinsic equals
-        // `r1` to `a` and `r2` to `b`.
+        // `_mm_min_ps` can **not** be implemented using the `simd_minimum_number_nsz` rust
+        // intrinsic. That intrinsic is lowered by the llvm codegen backend to `llvm.minimumnum.v*`
+        // llvm intrinsic with the `nsz` attribute. The `nsz` attribute means -0.0 is handled
+        // non-deterministically. The `minps` x86 instruction however has a deterministic semantics
+        // for signed zeros.
         let a = _mm_setr_ps(-0.0, 0.0, 0.0, 0.0);
         let b = _mm_setr_ps(0.0, 0.0, 0.0, 0.0);
         let r1 = _mm_min_ps(a, b).as_f32x4().to_bits();
diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index 6b39c2db3587..4ec5a7e9c209 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -513,10 +513,10 @@ fn test_simd() {
         F32::from(unsafe { simd_div(f32x4::splat(0.0), f32x4::splat(0.0)) }[0])
     });
     check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
-        F32::from(unsafe { simd_fmin(f32x4::splat(nan), f32x4::splat(nan)) }[0])
+        F32::from(unsafe { simd_minimum_number_nsz(f32x4::splat(nan), f32x4::splat(nan)) }[0])
     });
     check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
-        F32::from(unsafe { simd_fmax(f32x4::splat(nan), f32x4::splat(nan)) }[0])
+        F32::from(unsafe { simd_maximum_number_nsz(f32x4::splat(nan), f32x4::splat(nan)) }[0])
     });
     check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
         F32::from(unsafe { simd_fma(f32x4::splat(nan), f32x4::splat(nan), f32x4::splat(nan)) }[0])
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index b4fd8e216533..1e86c458ac21 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -90,11 +90,11 @@ macro_rules! assert_eq {
         assert_eq!(simd_rem(a, b), f16x4::from_array([0.0, 0.0, 1.0, 2.0]));
         assert_eq!(simd_fabs(b), f16x4::from_array([1.0, 2.0, 3.0, 4.0]));
         assert_eq!(
-            simd_fmax(a, simd_mul(b, f16x4::splat(4.0))),
+            simd_maximum_number_nsz(a, simd_mul(b, f16x4::splat(4.0))),
             f16x4::from_array([10.0, 10.0, 12.0, 10.0])
         );
         assert_eq!(
-            simd_fmin(a, simd_mul(b, f16x4::splat(4.0))),
+            simd_minimum_number_nsz(a, simd_mul(b, f16x4::splat(4.0))),
             f16x4::from_array([4.0, 8.0, 10.0, -16.0])
         );
 
@@ -134,13 +134,13 @@ macro_rules! assert_eq {
         assert_eq!(simd_reduce_min(b), -4.0f16);
 
         assert_eq!(
-            simd_fmax(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            simd_maximum_number_nsz(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
             f16x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_max(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
         assert_eq!(simd_reduce_max(f16x2::from_array([f16::NAN, 0.0])), 0.0f16);
         assert_eq!(
-            simd_fmin(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            simd_minimum_number_nsz(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
             f16x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_min(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
@@ -304,11 +304,11 @@ macro_rules! assert_eq {
         assert_eq!(simd_rem(a, b), f128x4::from_array([0.0, 0.0, 1.0, 2.0]));
         assert_eq!(simd_fabs(b), f128x4::from_array([1.0, 2.0, 3.0, 4.0]));
         assert_eq!(
-            simd_fmax(a, simd_mul(b, f128x4::splat(4.0))),
+            simd_maximum_number_nsz(a, simd_mul(b, f128x4::splat(4.0))),
             f128x4::from_array([10.0, 10.0, 12.0, 10.0])
         );
         assert_eq!(
-            simd_fmin(a, simd_mul(b, f128x4::splat(4.0))),
+            simd_minimum_number_nsz(a, simd_mul(b, f128x4::splat(4.0))),
             f128x4::from_array([4.0, 8.0, 10.0, -16.0])
         );
 
@@ -348,13 +348,13 @@ macro_rules! assert_eq {
         assert_eq!(simd_reduce_min(b), -4.0f128);
 
         assert_eq!(
-            simd_fmax(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            simd_maximum_number_nsz(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
             f128x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_max(f128x2::from_array([0.0, f128::NAN])), 0.0f128);
         assert_eq!(simd_reduce_max(f128x2::from_array([f128::NAN, 0.0])), 0.0f128);
         assert_eq!(
-            simd_fmin(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            simd_minimum_number_nsz(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
             f128x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_min(f128x2::from_array([0.0, f128::NAN])), 0.0f128);
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
index 8dd464a1bffb..94f7e160f8da 100644
--- a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
@@ -8,18 +8,18 @@
 mod minisimd;
 use minisimd::*;
 
-use std::intrinsics::simd::{simd_fmax, simd_fmin};
+use std::intrinsics::simd::*;
 
 // CHECK-LABEL: @fmin
 #[no_mangle]
 pub unsafe fn fmin(a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.minnum.v4f32
-    simd_fmin(a, b)
+    // CHECK: call nsz <4 x float> @llvm.minimumnum.v4f32
+    simd_minimum_number_nsz(a, b)
 }
 
 // CHECK-LABEL: @fmax
 #[no_mangle]
 pub unsafe fn fmax(a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.maxnum.v4f32
-    simd_fmax(a, b)
+    // CHECK: call nsz <4 x float> @llvm.maximumnum.v4f32
+    simd_maximum_number_nsz(a, b)
 }
diff --git a/tests/ui/simd/intrinsic/float-minmax-pass.rs b/tests/ui/simd/intrinsic/float-minmax-pass.rs
index d9dc291de63d..8ef5d85385a4 100644
--- a/tests/ui/simd/intrinsic/float-minmax-pass.rs
+++ b/tests/ui/simd/intrinsic/float-minmax-pass.rs
@@ -1,8 +1,8 @@
 //@ run-pass
 //@ ignore-emscripten
-//@ compile-flags: --cfg minisimd_const
+//@ compile-flags: --cfg minisimd_const -O
 
-// Test that the simd_f{min,max} intrinsics produce the correct results.
+// Test that the simd_{min,max}imum_number_nsz intrinsics produce the correct results.
 
 #![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
@@ -12,41 +12,38 @@
 use minisimd::*;
 
 use std::intrinsics::simd::*;
+use std::hint::black_box;
 
 const fn minmax() {
     let x = f32x4::from_array([1.0, 2.0, 3.0, 4.0]);
     let y = f32x4::from_array([2.0, 1.0, 4.0, 3.0]);
 
-    #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
     let nan = f32::NAN;
-    // MIPS hardware except MIPS R6 treats f32::NAN as SNAN. Clear the signaling bit.
-    // See https://github.com/rust-lang/rust/issues/52746.
     // The "-1" works because we rely on `NAN` to have an all-0 payload, so the signaling
     // bit is the least significant non-zero bit.
-    #[cfg(any(target_arch = "mips", target_arch = "mips64"))]
-    let nan = f32::from_bits(f32::NAN.to_bits() - 1);
+    let snan = f32::from_bits(f32::NAN.to_bits() - 1);
 
-    let n = f32x4::from_array([nan, nan, nan, nan]);
+    let n = f32x4::from_array([nan, nan, snan, snan]);
 
     unsafe {
-        let min0 = simd_fmin(x, y);
-        let min1 = simd_fmin(y, x);
+        let min0 = simd_minimum_number_nsz(x, y);
+        let min1 = simd_minimum_number_nsz(y, black_box(x));
         assert_eq!(min0, min1);
         let e = f32x4::from_array([1.0, 1.0, 3.0, 3.0]);
         assert_eq!(min0, e);
-        let minn = simd_fmin(x, n);
+        let minn = simd_minimum_number_nsz(x, n);
         assert_eq!(minn, x);
-        let minn = simd_fmin(y, n);
+        let minn = simd_minimum_number_nsz(black_box(y), n);
         assert_eq!(minn, y);
 
-        let max0 = simd_fmax(x, y);
-        let max1 = simd_fmax(y, x);
+        let max0 = simd_maximum_number_nsz(x, y);
+        let max1 = simd_maximum_number_nsz(y, black_box(x));
         assert_eq!(max0, max1);
         let e = f32x4::from_array([2.0, 2.0, 4.0, 4.0]);
         assert_eq!(max0, e);
-        let maxn = simd_fmax(x, n);
+        let maxn = simd_maximum_number_nsz(x, n);
         assert_eq!(maxn, x);
-        let maxn = simd_fmax(y, n);
+        let maxn = simd_maximum_number_nsz(n, black_box(y));
         assert_eq!(maxn, y);
     }
 }

From abe2502e609709b0dd91a27d917ade5e00e45cb2 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 14 Mar 2026 16:46:25 +0100
Subject: [PATCH 0624/1059] Implement signature type inference

---
 .../rust-analyzer/crates/hir-def/src/db.rs    |  25 +++-
 .../crates/hir-def/src/expr_store.rs          |  51 ++++++-
 .../crates/hir-def/src/expr_store/body.rs     |   2 +-
 .../crates/hir-def/src/expr_store/lower.rs    |  77 +++++++----
 .../hir-def/src/expr_store/lower/generics.rs  |  17 ++-
 .../src/expr_store/lower/path/tests.rs        |   2 +-
 .../crates/hir-def/src/expr_store/scope.rs    |  51 ++++++-
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  73 ++++++++++-
 .../crates/hir-def/src/resolver.rs            |  44 ++++---
 .../crates/hir-def/src/signatures.rs          |  10 +-
 .../crates/hir-def/src/test_db.rs             |   2 +-
 .../crates/hir-ty/src/consteval.rs            |   5 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  10 +-
 .../crates/hir-ty/src/display.rs              |  14 +-
 .../rust-analyzer/crates/hir-ty/src/drop.rs   |   7 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 124 +++++++++++++++---
 .../hir-ty/src/infer/closure/analysis.rs      |   2 +-
 .../crates/hir-ty/src/infer/coerce.rs         |   5 +-
 .../crates/hir-ty/src/infer/pat.rs            |   2 +-
 .../rust-analyzer/crates/hir-ty/src/layout.rs |   5 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  73 +++++++++--
 .../crates/hir-ty/src/mir/borrowck.rs         |  11 +-
 .../crates/hir-ty/src/mir/eval.rs             |   8 +-
 .../crates/hir-ty/src/mir/eval/shim.rs        |   5 +-
 .../crates/hir-ty/src/mir/lower.rs            |  14 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |  17 ++-
 .../crates/hir-ty/src/next_solver/interner.rs |  52 ++++----
 .../crates/hir-ty/src/next_solver/solver.rs   |   7 +-
 .../crates/hir-ty/src/next_solver/ty.rs       |   2 +-
 .../hir-ty/src/tests/closure_captures.rs      |   7 +-
 .../crates/hir-ty/src/tests/incremental.rs    |  14 +-
 .../crates/hir/src/has_source.rs              |   5 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  26 ++--
 .../crates/hir/src/source_analyzer.rs         |   6 +-
 .../add_explicit_enum_discriminant.rs         |   6 +-
 .../ide/src/inlay_hints/discriminant.rs       |   2 +-
 .../crates/parser/src/grammar/items/adt.rs    |   4 +
 .../ok/record_field_default_values.rast       |   5 +-
 .../inline/ok/variant_discriminant.rast       |   5 +-
 .../test_data/parser/ok/0019_enums.rast       |   5 +-
 .../rust-analyzer/crates/syntax/rust.ungram   |   4 +-
 .../crates/syntax/src/ast/generated/nodes.rs  |   4 +-
 .../src/ast/syntax_factory/constructors.rs    |   6 +-
 43 files changed, 632 insertions(+), 184 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index b0b652a1509c..ba0efe0ff13a 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -8,12 +8,13 @@
 use triomphe::Arc;
 
 use crate::{
-    AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc,
-    EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc,
-    FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc,
-    MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId,
-    ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
-    TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
+    AnonConstId, AnonConstLoc, AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc,
+    DefWithBodyId, EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExpressionStoreOwner,
+    ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc,
+    GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId,
+    MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
+    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
+    UnionLoc, UseId, UseLoc, VariantId,
     attrs::AttrFlags,
     expr_store::{
         Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, scope::ExprScopes,
@@ -61,6 +62,9 @@ pub trait InternDatabase: RootQueryDb {
     #[salsa::interned]
     fn intern_static(&self, loc: StaticLoc) -> StaticId;
 
+    #[salsa::interned]
+    fn intern_anon_const(&self, loc: AnonConstLoc) -> AnonConstId;
+
     #[salsa::interned]
     fn intern_trait(&self, loc: TraitLoc) -> TraitId;
 
@@ -212,8 +216,15 @@ fn type_alias_signature_with_source_map(
     #[salsa::invoke(Body::body_query)]
     fn body(&self, def: DefWithBodyId) -> Arc<Body>;
 
+    #[salsa::invoke(ExprScopes::body_expr_scopes_query)]
+    fn body_expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
+
+    #[salsa::invoke(ExprScopes::sig_expr_scopes_query)]
+    fn sig_expr_scopes(&self, def: GenericDefId) -> Arc<ExprScopes>;
+
+    #[salsa::transparent]
     #[salsa::invoke(ExprScopes::expr_scopes_query)]
-    fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
+    fn expr_scopes(&self, def: ExpressionStoreOwner) -> Arc<ExprScopes>;
 
     #[salsa::transparent]
     #[salsa::invoke(GenericParams::new)]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
index 1ce4c881e7ea..8552c7284532 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
@@ -94,9 +94,24 @@ pub(crate) fn is_root(self) -> bool {
 pub type LifetimePtr = AstPtr<ast::Lifetime>;
 pub type LifetimeSource = InFile<LifetimePtr>;
 
+/// Describes where a const expression originated from.
+///
+/// Used by signature/body inference to determine the expected type for each
+/// const expression root.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ConstExprOrigin {
+    /// Array length expression: `[T; <expr>]` — expected type is `usize`.
+    ArrayLength,
+    /// Const parameter default value: `const N: usize = <expr>`.
+    ConstParam(crate::hir::generics::LocalTypeOrConstParamId),
+    /// Const generic argument in a path: `SomeType::<{ <expr> }>` or `some_fn::<{ <expr> }>()`.
+    /// Determining the expected type requires path resolution, so it is deferred.
+    GenericArgsPath,
+}
+
 // We split the store into types-only and expressions, because most stores (e.g. generics)
 // don't store any expressions and this saves memory. Same thing for the source map.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 struct ExpressionOnlyStore {
     exprs: Arena<Expr>,
     pats: Arena<Pat>,
@@ -113,9 +128,15 @@ struct ExpressionOnlyStore {
     /// Expressions (and destructuing patterns) that can be recorded here are single segment path, although not all single segments path refer
     /// to variables and have hygiene (some refer to items, we don't know at this stage).
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
+
+    /// Maps const expression roots to their origin.
+    ///
+    /// Populated during lowering. Used by signature inference to determine expected types,
+    /// and by `signature_const_expr_roots()` to enumerate roots for scope computation.
+    const_expr_origins: ThinVec<(ExprId, ConstExprOrigin)>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ExpressionStore {
     expr_only: Option<Box<ExpressionOnlyStore>>,
     pub types: Arena<TypeRef>,
@@ -226,6 +247,7 @@ pub struct ExpressionStoreBuilder {
     pub types: Arena<TypeRef>,
     block_scopes: Vec<BlockId>,
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
+    pub const_expr_origins: Option<ThinVec<(ExprId, ConstExprOrigin)>>,
 
     // AST expressions can create patterns in destructuring assignments. Therefore, `ExprSource` can also map
     // to `PatId`, and `PatId` can also map to `ExprSource` (the other way around is unaffected).
@@ -297,6 +319,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
             mut bindings,
             mut binding_owners,
             mut ident_hygiene,
+            const_expr_origins,
             mut types,
             mut lifetimes,
 
@@ -364,6 +387,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
                     binding_owners,
                     block_scopes: block_scopes.into_boxed_slice(),
                     ident_hygiene,
+                    const_expr_origins: const_expr_origins.unwrap_or_default(),
                 }))
             } else {
                 None
@@ -413,6 +437,29 @@ pub fn empty_singleton() -> (Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>
         EMPTY.clone()
     }
 
+    /// Returns all const expression root `ExprId`s found in this store.
+    ///
+    /// Used to compute expression scopes for signature stores.
+    pub fn signature_const_expr_roots(&self) -> impl Iterator<Item = ExprId> {
+        self.const_expr_origins().iter().map(|&(id, _)| id)
+    }
+
+    /// Like [`Self::signature_const_expr_roots`], but also returns the origin
+    /// of each const expression.
+    ///
+    /// This is used by signature inference to determine the expected type for
+    /// each root expression.
+    pub fn signature_const_expr_roots_with_origins(
+        &self,
+    ) -> impl Iterator<Item = (ExprId, ConstExprOrigin)> {
+        self.const_expr_origins().iter().map(|&(id, origin)| (id, origin))
+    }
+
+    /// Returns the map of const expression roots to their origins.
+    pub fn const_expr_origins(&self) -> &[(ExprId, ConstExprOrigin)] {
+        self.expr_only.as_ref().map_or(&[], |it| &it.const_expr_origins)
+    }
+
     /// Returns an iterator over all block expressions in this store that define inner items.
     pub fn blocks<'a>(
         &'a self,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
index c955393b9cf2..ad8fa73ad839 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
@@ -99,7 +99,7 @@ pub(crate) fn body_with_source_map_query(
                 DefWithBodyId::VariantId(v) => {
                     let s = v.lookup(db);
                     let src = s.source(db);
-                    src.map(|it| it.expr())
+                    src.map(|it| it.const_arg()?.expr())
                 }
             }
         };
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index 1cecd1976b40..67ce5eafc6d8 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -37,7 +37,7 @@
     attrs::AttrFlags,
     db::DefDatabase,
     expr_store::{
-        Body, BodySourceMap, ExprPtr, ExpressionStore, ExpressionStoreBuilder,
+        Body, BodySourceMap, ConstExprOrigin, ExprPtr, ExpressionStore, ExpressionStoreBuilder,
         ExpressionStoreDiagnostics, ExpressionStoreSourceMap, HygieneId, LabelPtr, LifetimePtr,
         PatPtr, TypePtr,
         expander::Expander,
@@ -79,7 +79,7 @@ pub(super) fn lower_body(
     let mut self_param = None;
     let mut source_map_self_param = None;
     let mut params = vec![];
-    let mut collector = ExprCollector::new(db, module, current_file_id);
+    let mut collector = ExprCollector::body(db, module, current_file_id);
 
     let skip_body = AttrFlags::query(
         db,
@@ -186,7 +186,7 @@ pub(crate) fn lower_type_ref(
     module: ModuleId,
     type_ref: InFile<Option<ast::Type>>,
 ) -> (ExpressionStore, ExpressionStoreSourceMap, TypeRefId) {
-    let mut expr_collector = ExprCollector::new(db, module, type_ref.file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, type_ref.file_id);
     let type_ref =
         expr_collector.lower_type_ref_opt(type_ref.value, &mut ExprCollector::impl_trait_allocator);
     let (store, source_map) = expr_collector.store.finish();
@@ -201,7 +201,7 @@ pub(crate) fn lower_generic_params(
     param_list: Option<ast::GenericParamList>,
     where_clause: Option<ast::WhereClause>,
 ) -> (Arc<ExpressionStore>, Arc<GenericParams>, ExpressionStoreSourceMap) {
-    let mut expr_collector = ExprCollector::new(db, module, file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, file_id);
     let mut collector = generics::GenericParamsCollector::new(def);
     collector.lower(&mut expr_collector, param_list, where_clause);
     let params = collector.finish();
@@ -215,7 +215,7 @@ pub(crate) fn lower_impl(
     impl_syntax: InFile<ast::Impl>,
     impl_id: ImplId,
 ) -> (ExpressionStore, ExpressionStoreSourceMap, TypeRefId, Option<TraitRef>, Arc<GenericParams>) {
-    let mut expr_collector = ExprCollector::new(db, module, impl_syntax.file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, impl_syntax.file_id);
     let self_ty =
         expr_collector.lower_type_ref_opt_disallow_impl_trait(impl_syntax.value.self_ty());
     let trait_ = impl_syntax.value.trait_().and_then(|it| match &it {
@@ -243,7 +243,7 @@ pub(crate) fn lower_trait(
     trait_syntax: InFile<ast::Trait>,
     trait_id: TraitId,
 ) -> (ExpressionStore, ExpressionStoreSourceMap, Arc<GenericParams>) {
-    let mut expr_collector = ExprCollector::new(db, module, trait_syntax.file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, trait_syntax.file_id);
     let mut collector = generics::GenericParamsCollector::with_self_param(
         &mut expr_collector,
         trait_id.into(),
@@ -271,7 +271,7 @@ pub(crate) fn lower_type_alias(
     Box<[TypeBound]>,
     Option<TypeRefId>,
 ) {
-    let mut expr_collector = ExprCollector::new(db, module, alias.file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, alias.file_id);
     let bounds = alias
         .value
         .type_bound_list()
@@ -313,7 +313,7 @@ pub(crate) fn lower_function(
     bool,
     bool,
 ) {
-    let mut expr_collector = ExprCollector::new(db, module, fn_.file_id);
+    let mut expr_collector = ExprCollector::signature(db, module, fn_.file_id);
     let mut collector = generics::GenericParamsCollector::new(function_id.into());
     collector.lower(&mut expr_collector, fn_.value.generic_param_list(), fn_.value.where_clause());
     let mut params = vec![];
@@ -532,7 +532,20 @@ fn check_is_used(&mut self, ec: &mut ExprCollector<'_>, id: BindingId) {
 }
 
 impl<'db> ExprCollector<'db> {
-    pub fn new(
+    /// Creates a collector for a signature store, this will populate `const_expr_origins` to any
+    /// top level const arg roots.
+    pub fn signature(
+        db: &dyn DefDatabase,
+        module: ModuleId,
+        current_file_id: HirFileId,
+    ) -> ExprCollector<'_> {
+        let mut this = Self::body(db, module, current_file_id);
+        this.store.const_expr_origins = Some(Default::default());
+        this
+    }
+
+    /// Creates a collector for a bidy store.
+    pub fn body(
         db: &dyn DefDatabase,
         module: ModuleId,
         current_file_id: HirFileId,
@@ -577,7 +590,10 @@ pub(crate) fn span_map(&self) -> SpanMapRef<'_> {
         self.expander.span_map()
     }
 
-    pub fn lower_lifetime_ref(&mut self, lifetime: ast::Lifetime) -> LifetimeRefId {
+    pub(in crate::expr_store) fn lower_lifetime_ref(
+        &mut self,
+        lifetime: ast::Lifetime,
+    ) -> LifetimeRefId {
         // FIXME: Keyword check?
         let lifetime_ref = match &*lifetime.text() {
             "" | "'" => LifetimeRef::Error,
@@ -588,7 +604,10 @@ pub fn lower_lifetime_ref(&mut self, lifetime: ast::Lifetime) -> LifetimeRefId {
         self.alloc_lifetime_ref(lifetime_ref, AstPtr::new(&lifetime))
     }
 
-    pub fn lower_lifetime_ref_opt(&mut self, lifetime: Option<ast::Lifetime>) -> LifetimeRefId {
+    pub(in crate::expr_store) fn lower_lifetime_ref_opt(
+        &mut self,
+        lifetime: Option<ast::Lifetime>,
+    ) -> LifetimeRefId {
         match lifetime {
             Some(lifetime) => self.lower_lifetime_ref(lifetime),
             None => self.alloc_lifetime_ref_desugared(LifetimeRef::Placeholder),
@@ -596,7 +615,7 @@ pub fn lower_lifetime_ref_opt(&mut self, lifetime: Option<ast::Lifetime>) -> Lif
     }
 
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub fn lower_type_ref(
+    pub(in crate::expr_store) fn lower_type_ref(
         &mut self,
         node: ast::Type,
         impl_trait_lower_fn: ImplTraitLowerFn<'_>,
@@ -621,6 +640,9 @@ pub fn lower_type_ref(
             }
             ast::Type::ArrayType(inner) => {
                 let len = self.lower_const_arg_opt(inner.const_arg());
+                if let Some(const_expr_origins) = &mut self.store.const_expr_origins {
+                    const_expr_origins.push((len.expr, ConstExprOrigin::ArrayLength));
+                }
                 TypeRef::Array(ArrayType {
                     ty: self.lower_type_ref_opt(inner.ty(), impl_trait_lower_fn),
                     len,
@@ -810,7 +832,7 @@ fn alloc_path(&mut self, path: Path, node: TypePtr) -> PathId {
 
     /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
     /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
-    pub fn lower_generic_args_from_fn_path(
+    pub(in crate::expr_store) fn lower_generic_args_from_fn_path(
         &mut self,
         args: Option<ast::ParenthesizedArgList>,
         ret_type: Option<ast::RetType>,
@@ -905,6 +927,9 @@ pub(super) fn lower_generic_args(
                 }
                 ast::GenericArg::ConstArg(arg) => {
                     let arg = self.lower_const_arg(arg);
+                    if let Some(const_expr_origins) = &mut self.store.const_expr_origins {
+                        const_expr_origins.push((arg.expr, ConstExprOrigin::GenericArgsPath));
+                    }
                     args.push(GenericArg::Const(arg))
                 }
             }
@@ -1045,17 +1070,30 @@ fn lower_type_bound(
     }
 
     fn lower_const_arg_opt(&mut self, arg: Option<ast::ConstArg>) -> ConstRef {
-        ConstRef { expr: self.collect_expr_opt(arg.and_then(|it| it.expr())) }
+        let const_expr_origins = self.store.const_expr_origins.take();
+        let r = ConstRef { expr: self.collect_expr_opt(arg.and_then(|it| it.expr())) };
+        self.store.const_expr_origins = const_expr_origins;
+        r
     }
 
-    fn lower_const_arg(&mut self, arg: ast::ConstArg) -> ConstRef {
-        ConstRef { expr: self.collect_expr_opt(arg.expr()) }
+    pub fn lower_const_arg(&mut self, arg: ast::ConstArg) -> ConstRef {
+        let const_expr_origins = self.store.const_expr_origins.take();
+        let r = ConstRef { expr: self.collect_expr_opt(arg.expr()) };
+        self.store.const_expr_origins = const_expr_origins;
+        r
     }
 
     fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
         self.maybe_collect_expr(expr).unwrap_or_else(|| self.missing_expr())
     }
 
+    pub(in crate::expr_store) fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
+        match expr {
+            Some(expr) => self.collect_expr(expr),
+            None => self.missing_expr(),
+        }
+    }
+
     /// Returns `None` if and only if the expression is `#[cfg]`d out.
     fn maybe_collect_expr(&mut self, expr: ast::Expr) -> Option<ExprId> {
         let syntax_ptr = AstPtr::new(&expr);
@@ -2065,13 +2103,6 @@ fn collect_macro_call<T, U>(
         }
     }
 
-    pub fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
-        match expr {
-            Some(expr) => self.collect_expr(expr),
-            None => self.missing_expr(),
-        }
-    }
-
     fn collect_macro_as_stmt(
         &mut self,
         statements: &mut Vec<Statement>,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
index c570df42b2f6..03de7937bad3 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
@@ -141,12 +141,17 @@ fn lower_param_list(&mut self, ec: &mut ExprCollector<'_>, params: ast::GenericP
                         const_param.ty(),
                         &mut ExprCollector::impl_trait_error_allocator,
                     );
-                    let param = ConstParamData {
-                        name,
-                        ty,
-                        default: const_param.default_val().map(|it| ec.lower_const_arg(it)),
-                    };
-                    let _idx = self.type_or_consts.alloc(param.into());
+                    let default = const_param.default_val().map(|it| ec.lower_const_arg(it));
+                    let param = ConstParamData { name, ty, default };
+                    let idx = self.type_or_consts.alloc(param.into());
+                    if let Some(default) = default
+                        && let Some(const_expr_origins) = &mut ec.store.const_expr_origins
+                    {
+                        const_expr_origins.push((
+                            default.expr,
+                            crate::expr_store::ConstExprOrigin::ConstParam(idx),
+                        ));
+                    }
                 }
                 ast::GenericParam::LifetimeParam(lifetime_param) => {
                     let lifetime = ec.lower_lifetime_ref_opt(lifetime_param.lifetime());
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/path/tests.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/path/tests.rs
index f507841a91bf..6819eb3deb57 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/path/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/path/tests.rs
@@ -21,7 +21,7 @@ fn lower_path(path: ast::Path) -> (TestDB, ExpressionStore, Option<Path>) {
     let (db, file_id) = TestDB::with_single_file("");
     let krate = db.fetch_test_crate();
     let mut ctx =
-        ExprCollector::new(&db, crate_def_map(&db, krate).root_module_id(), file_id.into());
+        ExprCollector::signature(&db, crate_def_map(&db, krate).root_module_id(), file_id.into());
     let lowered_path = ctx.lower_path(path, &mut ExprCollector::impl_trait_allocator);
     let (store, _) = ctx.store.finish();
     (db, store, lowered_path)
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
index 1952dae9d71a..43ce053836c4 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
@@ -4,7 +4,7 @@
 use triomphe::Arc;
 
 use crate::{
-    BlockId, DefWithBodyId,
+    BlockId, DefWithBodyId, ExpressionStoreOwner, GenericDefId,
     db::DefDatabase,
     expr_store::{Body, ExpressionStore, HygieneId},
     hir::{Binding, BindingId, Expr, ExprId, Item, LabelId, Pat, PatId, Statement},
@@ -51,13 +51,37 @@ pub struct ScopeData {
 }
 
 impl ExprScopes {
-    pub(crate) fn expr_scopes_query(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<ExprScopes> {
+    pub(crate) fn expr_scopes_query(
+        db: &dyn DefDatabase,
+        def: ExpressionStoreOwner,
+    ) -> Arc<ExprScopes> {
+        match def {
+            ExpressionStoreOwner::Body(def) => db.body_expr_scopes(def),
+            ExpressionStoreOwner::Signature(def) => db.sig_expr_scopes(def),
+        }
+    }
+
+    pub(crate) fn body_expr_scopes_query(
+        db: &dyn DefDatabase,
+        def: DefWithBodyId,
+    ) -> Arc<ExprScopes> {
         let body = db.body(def);
         let mut scopes = ExprScopes::new_body(&body);
         scopes.shrink_to_fit();
         Arc::new(scopes)
     }
 
+    pub(crate) fn sig_expr_scopes_query(
+        db: &dyn DefDatabase,
+        def: GenericDefId,
+    ) -> Arc<ExprScopes> {
+        let (_, store) = db.generic_params_and_store(def);
+        let roots = store.signature_const_expr_roots();
+        let mut scopes = ExprScopes::new_store(&store, roots);
+        scopes.shrink_to_fit();
+        Arc::new(scopes)
+    }
+
     pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
         &self.scope_entries[self.scopes[scope].entries.clone()]
     }
@@ -119,6 +143,22 @@ fn new_body(body: &Body) -> ExprScopes {
         scopes
     }
 
+    fn new_store(store: &ExpressionStore, roots: impl IntoIterator<Item = ExprId>) -> ExprScopes {
+        let mut scopes = ExprScopes {
+            scopes: Arena::default(),
+            scope_entries: Arena::default(),
+            scope_by_expr: ArenaMap::with_capacity(
+                store.expr_only.as_ref().map_or(0, |it| it.exprs.len()),
+            ),
+        };
+        let root = scopes.root_scope();
+        for root_expr in roots {
+            let mut scope = scopes.new_scope(root);
+            compute_expr_scopes(root_expr, store, &mut scopes, &mut scope);
+        }
+        scopes
+    }
+
     fn root_scope(&mut self) -> ScopeId {
         self.scopes.alloc(ScopeData {
             parent: None,
@@ -327,7 +367,8 @@ mod tests {
     use test_utils::{assert_eq_text, extract_offset};
 
     use crate::{
-        FunctionId, ModuleDefId, db::DefDatabase, nameres::crate_def_map, test_db::TestDB,
+        DefWithBodyId, FunctionId, ModuleDefId, db::DefDatabase, nameres::crate_def_map,
+        test_db::TestDB,
     };
 
     fn find_function(db: &TestDB, file_id: FileId) -> FunctionId {
@@ -363,7 +404,7 @@ fn do_check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected: &[&str])
         let marker: ast::PathExpr = find_node_at_offset(&file_syntax, offset).unwrap();
         let function = find_function(&db, file_id);
 
-        let scopes = db.expr_scopes(function.into());
+        let scopes = db.expr_scopes(DefWithBodyId::from(function).into());
         let (_body, source_map) = db.body_with_source_map(function.into());
 
         let expr_id = source_map
@@ -522,7 +563,7 @@ fn do_check_local_name(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected
 
         let function = find_function(&db, file_id);
 
-        let scopes = db.expr_scopes(function.into());
+        let scopes = db.expr_scopes(DefWithBodyId::from(function).into());
         let (_, source_map) = db.body_with_source_map(function.into());
 
         let expr_scope = {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index de674be05f64..ffad5fee47ff 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -86,7 +86,10 @@
     builtin_type::BuiltinType,
     db::DefDatabase,
     expr_store::ExpressionStoreSourceMap,
-    hir::generics::{GenericParams, LocalLifetimeParamId, LocalTypeOrConstParamId},
+    hir::{
+        ExprId,
+        generics::{GenericParams, LocalLifetimeParamId, LocalTypeOrConstParamId},
+    },
     nameres::{
         LocalDefMap,
         assoc::{ImplItems, TraitItems},
@@ -306,6 +309,19 @@ pub fn enum_variants_with_diagnostics(
 pub type StaticLoc = AssocItemLoc<ast::Static>;
 impl_intern!(StaticId, StaticLoc, intern_static, lookup_intern_static);
 
+/// An anonymous const expression that appears in a type position (e.g., array lengths,
+/// const generic arguments like `{ N + 1 }`). Unlike named constants, these don't have
+/// their own `Body` — their expressions live in the parent's signature `ExpressionStore`.
+#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+pub struct AnonConstLoc {
+    /// The owner store containing this expression.
+    pub owner: ExpressionStoreOwner,
+    /// The ExprId within the owner's ExpressionStore that is the root
+    /// of this anonymous const expression.
+    pub expr: ExprId,
+}
+impl_intern!(AnonConstId, AnonConstLoc, intern_anon_const, lookup_intern_anon_const);
+
 pub type TraitLoc = ItemLoc<ast::Trait>;
 impl_intern!(TraitId, TraitLoc, intern_trait, lookup_intern_trait);
 
@@ -706,15 +722,17 @@ fn from(value: DefWithBodyId) -> Self {
 pub enum GeneralConstId {
     ConstId(ConstId),
     StaticId(StaticId),
+    AnonConstId(AnonConstId),
 }
 
-impl_from!(ConstId, StaticId for GeneralConstId);
+impl_from!(ConstId, StaticId, AnonConstId for GeneralConstId);
 
 impl GeneralConstId {
-    pub fn generic_def(self, _db: &dyn DefDatabase) -> Option<GenericDefId> {
+    pub fn generic_def(self, db: &dyn DefDatabase) -> Option<GenericDefId> {
         match self {
             GeneralConstId::ConstId(it) => Some(it.into()),
             GeneralConstId::StaticId(it) => Some(it.into()),
+            GeneralConstId::AnonConstId(it) => Some(it.lookup(db).owner.generic_def(db)),
         }
     }
 
@@ -729,6 +747,7 @@ pub fn name(self, db: &dyn DefDatabase) -> String {
                     |name| name.display(db, Edition::CURRENT).to_string(),
                 )
             }
+            GeneralConstId::AnonConstId(_) => "{anon const}".to_owned(),
         }
     }
 }
@@ -814,6 +833,45 @@ pub enum GenericDefId {
     for GenericDefId
 );
 
+/// Owner of an expression store - either a body or a signature.
+/// This is used for queries that operate on expression stores generically,
+/// such as `expr_scopes`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ExpressionStoreOwner {
+    Signature(GenericDefId),
+    Body(DefWithBodyId),
+}
+
+impl ExpressionStoreOwner {
+    pub fn as_def_with_body(self) -> Option<DefWithBodyId> {
+        if let Self::Body(v) = self { Some(v) } else { None }
+    }
+
+    pub fn generic_def(self, db: &dyn DefDatabase) -> GenericDefId {
+        match self {
+            ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id,
+            ExpressionStoreOwner::Body(def_with_body_id) => match def_with_body_id {
+                DefWithBodyId::FunctionId(id) => GenericDefId::FunctionId(id),
+                DefWithBodyId::StaticId(id) => GenericDefId::StaticId(id),
+                DefWithBodyId::ConstId(id) => GenericDefId::ConstId(id),
+                DefWithBodyId::VariantId(it) => it.lookup(db).parent.into(),
+            },
+        }
+    }
+}
+
+impl From<GenericDefId> for ExpressionStoreOwner {
+    fn from(id: GenericDefId) -> Self {
+        ExpressionStoreOwner::Signature(id)
+    }
+}
+
+impl From<DefWithBodyId> for ExpressionStoreOwner {
+    fn from(id: DefWithBodyId) -> Self {
+        ExpressionStoreOwner::Body(id)
+    }
+}
+
 impl GenericDefId {
     pub fn file_id_and_params_of(
         self,
@@ -1172,6 +1230,15 @@ fn module(&self, db: &dyn DefDatabase) -> ModuleId {
     }
 }
 
+impl HasModule for ExpressionStoreOwner {
+    fn module(&self, db: &dyn DefDatabase) -> ModuleId {
+        match self {
+            ExpressionStoreOwner::Signature(def) => def.module(db),
+            ExpressionStoreOwner::Body(def) => def.module(db),
+        }
+    }
+}
+
 impl HasModule for GenericDefId {
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {
         match self {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index d32e53fc6bee..392010df8507 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -16,11 +16,11 @@
 use triomphe::Arc;
 
 use crate::{
-    AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
-    ExternCrateId, FunctionId, FxIndexMap, GenericDefId, GenericParamId, HasModule, ImplId,
-    ItemContainerId, LifetimeParamId, Lookup, Macro2Id, MacroId, MacroRulesId, ModuleDefId,
-    ModuleId, ProcMacroId, StaticId, StructId, TraitId, TypeAliasId, TypeOrConstParamId,
-    TypeParamId, UseId, VariantId,
+    AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
+    ExpressionStoreOwner, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
+    GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, Lookup, Macro2Id, MacroId,
+    MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId, TraitId, TypeAliasId,
+    TypeOrConstParamId, TypeParamId, UseId, VariantId,
     builtin_type::BuiltinType,
     db::DefDatabase,
     expr_store::{
@@ -66,7 +66,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 
 #[derive(Clone)]
 struct ExprScope {
-    owner: DefWithBodyId,
+    owner: ExpressionStoreOwner,
     expr_scopes: Arc<ExprScopes>,
     scope_id: ScopeId,
 }
@@ -738,7 +738,10 @@ pub fn all_generic_params(&self) -> impl Iterator<Item = (&GenericParams, &Gener
 
     pub fn body_owner(&self) -> Option<DefWithBodyId> {
         self.scopes().find_map(|scope| match scope {
-            Scope::ExprScope(it) => Some(it.owner),
+            Scope::ExprScope(it) => match it.owner {
+                ExpressionStoreOwner::Body(def) => Some(def),
+                ExpressionStoreOwner::Signature(_) => None,
+            },
             _ => None,
         })
     }
@@ -854,14 +857,15 @@ pub fn rename_will_conflict_with_renamed(
     pub fn update_to_inner_scope(
         &mut self,
         db: &'db dyn DefDatabase,
-        owner: DefWithBodyId,
+        owner: impl Into<ExpressionStoreOwner>,
         expr_id: ExprId,
     ) -> UpdateGuard {
+        let owner = owner.into();
         #[inline(always)]
         fn append_expr_scope<'db>(
             db: &'db dyn DefDatabase,
             resolver: &mut Resolver<'db>,
-            owner: DefWithBodyId,
+            owner: ExpressionStoreOwner,
             expr_scopes: &Arc<ExprScopes>,
             scope_id: ScopeId,
         ) {
@@ -1060,12 +1064,13 @@ fn process_names(&self, acc: &mut ScopeNames, db: &'db dyn DefDatabase) {
 
 pub fn resolver_for_scope(
     db: &dyn DefDatabase,
-    owner: DefWithBodyId,
+    owner: impl Into<ExpressionStoreOwner> + HasResolver,
     scope_id: Option<ScopeId>,
 ) -> Resolver<'_> {
-    let r = owner.resolver(db);
-    let scopes = db.expr_scopes(owner);
-    resolver_for_scope_(db, scopes, scope_id, r, owner)
+    let store_owner = owner.into();
+    let r = store_owner.resolver(db);
+    let scopes = db.expr_scopes(store_owner);
+    resolver_for_scope_(db, scopes, scope_id, r, store_owner)
 }
 
 fn resolver_for_scope_<'db>(
@@ -1073,7 +1078,7 @@ fn resolver_for_scope_<'db>(
     scopes: Arc<ExprScopes>,
     scope_id: Option<ScopeId>,
     mut r: Resolver<'db>,
-    owner: DefWithBodyId,
+    owner: ExpressionStoreOwner,
 ) -> Resolver<'db> {
     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
     r.scopes.reserve(scope_chain.len());
@@ -1124,7 +1129,7 @@ fn push_block_scope(
 
     fn push_expr_scope(
         self,
-        owner: DefWithBodyId,
+        owner: ExpressionStoreOwner,
         expr_scopes: Arc<ExprScopes>,
         scope_id: ScopeId,
     ) -> Resolver<'db> {
@@ -1409,6 +1414,15 @@ fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
     }
 }
 
+impl HasResolver for ExpressionStoreOwner {
+    fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
+        match self {
+            ExpressionStoreOwner::Signature(def) => def.resolver(db),
+            ExpressionStoreOwner::Body(def) => def.resolver(db),
+        }
+    }
+}
+
 impl HasResolver for EnumVariantId {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         self.lookup(db).parent.resolver(db)
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 37c8f762fe5d..ce76158151c3 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -32,7 +32,7 @@
     hir::{ExprId, PatId, generics::GenericParams},
     item_tree::{FieldsShape, RawVisibility, visibility_from_ast},
     src::HasSource,
-    type_ref::{TraitRef, TypeBound, TypeRefId},
+    type_ref::{ConstRef, TraitRef, TypeBound, TypeRefId},
 };
 
 #[inline]
@@ -754,7 +754,7 @@ pub struct FieldData {
     pub type_ref: TypeRefId,
     pub visibility: RawVisibility,
     pub is_unsafe: bool,
-    pub default_value: Option<ExprId>,
+    pub default_value: Option<ConstRef>,
 }
 
 pub type LocalFieldId = Idx<FieldData>;
@@ -873,7 +873,7 @@ fn lower_fields<Field: ast::HasAttrs + ast::HasVisibility>(
     override_visibility: Option<Option<ast::Visibility>>,
 ) -> Option<(Arena<FieldData>, ExpressionStore, ExpressionStoreSourceMap)> {
     let cfg_options = module.krate(db).cfg_options(db);
-    let mut col = ExprCollector::new(db, module, fields.file_id);
+    let mut col = ExprCollector::signature(db, module, fields.file_id);
     let override_visibility = override_visibility.map(|vis| {
         LazyCell::new(|| {
             let span_map = db.span_map(fields.file_id);
@@ -907,9 +907,9 @@ fn lower_fields<Field: ast::HasAttrs + ast::HasVisibility>(
 
                 // Check if field has default value (only for record fields)
                 let default_value = ast::RecordField::cast(field.syntax().clone())
-                    .and_then(|rf| rf.eq_token().is_some().then_some(rf.expr()))
+                    .and_then(|rf| rf.eq_token().is_some().then_some(rf.default_val()))
                     .flatten()
-                    .map(|expr| col.collect_expr_opt(Some(expr)));
+                    .map(|expr| col.lower_const_arg(expr));
 
                 arena.alloc(FieldData { name, type_ref, visibility, is_unsafe, default_value });
                 idx += 1;
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
index e8377fde4987..d2921db6f4fa 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
@@ -285,7 +285,7 @@ fn block_at_position(&self, def_map: &DefMap, position: FilePosition) -> Option<
         let (def_with_body, file_id) = fn_def?;
         let def_with_body = def_with_body.into();
         let source_map = self.body_with_source_map(def_with_body).1;
-        let scopes = self.expr_scopes(def_with_body);
+        let scopes = self.expr_scopes(def_with_body.into());
 
         let root_syntax_node = self.parse(file_id).syntax_node();
         let scope_iter =
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 07e9f70faea6..9ff788c2e218 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -235,6 +235,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
                 let ec = db.const_eval_static(id).ok()?;
                 try_const_usize(db, ec)
             }
+            GeneralConstId::AnonConstId(_) => None,
         },
         ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().memory, false))),
         ConstKind::Error(_) => None,
@@ -258,6 +259,7 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
                 let ec = db.const_eval_static(id).ok()?;
                 try_const_isize(db, &ec)
             }
+            GeneralConstId::AnonConstId(_) => None,
         },
         ConstKind::Value(val) => Some(i128::from_le_bytes(pad16(&val.value.inner().memory, true))),
         ConstKind::Error(_) => None,
@@ -333,7 +335,8 @@ fn has_closure(body: &Body, expr: ExprId) -> bool {
             return c;
         }
     }
-    if let Ok(mir_body) = lower_body_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr)
+    if let Some(body_owner) = ctx.owner.as_def_with_body()
+        && let Ok(mir_body) = lower_body_to_mir(ctx.db, body_owner, ctx.body, &infer, expr)
         && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None)
     {
         return result;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 70474fc46919..ca5b1b771631 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -5,9 +5,9 @@
 use either::Either;
 use hir_def::{
     AdtId, BuiltinDeriveImplId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId,
-    FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId,
-    TypeAliasId, VariantId, builtin_derive::BuiltinDeriveImplMethod, db::DefDatabase, hir::ExprId,
-    layout::TargetDataLayout,
+    ExpressionStoreOwner, FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId,
+    StaticId, TraitId, TypeAliasId, VariantId, builtin_derive::BuiltinDeriveImplMethod,
+    db::DefDatabase, hir::ExprId, layout::TargetDataLayout,
 };
 use la_arena::ArenaMap;
 use salsa::plumbing::AsId;
@@ -240,7 +240,7 @@ pub struct InternedOpaqueTyId {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct InternedClosure(pub DefWithBodyId, pub ExprId);
+pub struct InternedClosure(pub ExpressionStoreOwner, pub ExprId);
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
@@ -249,7 +249,7 @@ pub struct InternedClosureId {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct InternedCoroutine(pub DefWithBodyId, pub ExprId);
+pub struct InternedCoroutine(pub ExpressionStoreOwner, pub ExprId);
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index 4e77e8be364b..f4d0ed148492 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -1336,7 +1336,11 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 }
                 let sig = interner.signature_unclosure(substs.as_closure().sig(), Safety::Safe);
                 let sig = sig.skip_binder();
-                let InternedClosure(def, _) = db.lookup_intern_closure(id);
+                let InternedClosure(owner, _) = db.lookup_intern_closure(id);
+                let Some(def) = owner.as_def_with_body() else {
+                    write!(f, "{{closure}}")?;
+                    return Ok(());
+                };
                 let infer = InferenceResult::for_body(db, def);
                 let (_, kind) = infer.closure_info(id);
                 match f.closure_style {
@@ -1526,7 +1530,13 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 let InternedCoroutine(owner, expr_id) = coroutine_id.0.loc(db);
                 let CoroutineArgsParts { resume_ty, yield_ty, return_ty, .. } =
                     subst.split_coroutine_args();
-                let body = db.body(owner);
+                let Some(body_owner) = owner.as_def_with_body() else {
+                    write!(f, "impl Future<Output = ")?;
+                    return_ty.hir_fmt(f)?;
+                    write!(f, ">")?;
+                    return Ok(());
+                };
+                let body = db.body(body_owner);
                 let expr = &body[expr_id];
                 match expr {
                     hir_def::hir::Expr::Closure {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index 9d6869eee9b8..1303e08801bd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -132,9 +132,12 @@ fn has_drop_glue_impl<'db>(
         TyKind::Slice(ty) => has_drop_glue_impl(infcx, ty, env, visited),
         TyKind::Closure(closure_id, subst) => {
             let owner = db.lookup_intern_closure(closure_id.0).0;
-            let infer = InferenceResult::for_body(db, owner);
+            let Some(body_owner) = owner.as_def_with_body() else {
+                return DropGlue::None;
+            };
+            let infer = InferenceResult::for_body(db, body_owner);
             let (captures, _) = infer.closure_info(closure_id.0);
-            let env = db.trait_environment_for_body(owner);
+            let env = db.trait_environment_for_body(body_owner);
             captures
                 .iter()
                 .map(|capture| has_drop_glue_impl(infcx, capture.ty(db, subst), env, visited))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 991acda14bc7..a4fcded42b66 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -33,9 +33,10 @@
 use base_db::Crate;
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, ConstId, DefWithBodyId, FieldId, FunctionId, GenericDefId, GenericParamId,
-    ItemContainerId, LocalFieldId, Lookup, TraitId, TupleFieldId, TupleId, TypeAliasId, VariantId,
-    expr_store::{Body, ExpressionStore, HygieneId, path::Path},
+    AdtId, AnonConstId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner,
+    FieldId, FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup,
+    TraitId, TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
+    expr_store::{Body, ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
     layout::Integer,
@@ -105,7 +106,7 @@ pub fn infer_query_with_inspect<'db>(
     let _p = tracing::info_span!("infer_query").entered();
     let resolver = def.resolver(db);
     let body = db.body(def);
-    let mut ctx = InferenceContext::new(db, def, &body, resolver);
+    let mut ctx = InferenceContext::new(db, ExpressionStoreOwner::Body(def), &body, resolver);
 
     if let Some(inspect) = inspect {
         ctx.table.infer_ctxt.attach_obligation_inspector(inspect);
@@ -179,6 +180,68 @@ fn infer_cycle_result(db: &dyn HirDatabase, _: salsa::Id, _: DefWithBodyId) -> I
     }
 }
 
+/// Infer types for all const expressions in an item's signature.
+///
+/// This handles const expressions that appear in type positions within a generic
+/// item's signature, such as array lengths (`[T; N]`) and const generic arguments
+/// (`Foo<{ expr }>`). Each root expression is inferred independently within
+/// a shared `InferenceContext`, accumulating results into a single `InferenceResult`.
+fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
+    let _p = tracing::info_span!("infer_signature_query").entered();
+    let (_, store) = db.generic_params_and_store(def);
+    let mut roots = store.signature_const_expr_roots_with_origins().peekable();
+    let Some(&(first, _)) = roots.peek() else {
+        return InferenceResult::new(crate::next_solver::default_types(db).types.error);
+    };
+
+    let resolver = def.resolver(db);
+    let owner = ExpressionStoreOwner::Signature(def);
+
+    // Construct a synthetic `Body` to satisfy `InferenceContext`.
+    // The `body_expr` is set to the first root as a placeholder; we infer
+    // each root expression individually below rather than calling `infer_body`.
+    let body = Body {
+        // FIXME: Get rid of this clone
+        store: (*store).clone(),
+        params: Box::new([]),
+        self_param: None,
+        body_expr: first,
+    };
+
+    let mut ctx = InferenceContext::new(db, owner, &body, resolver);
+
+    for (root_expr, origin) in roots {
+        let expected = match origin {
+            // Array lengths are always `usize`.
+            ConstExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
+            // Const parameter default: look up the param's declared type.
+            ConstExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(
+                ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),
+            )),
+            // Path const generic args: determining the expected type requires
+            // path resolution.
+            // FIXME
+            ConstExprOrigin::GenericArgsPath => Expectation::None,
+        };
+        ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
+    }
+
+    ctx.type_inference_fallback();
+    ctx.table.select_obligations_where_possible();
+    ctx.resolve_all()
+}
+
+fn infer_signature_cycle_result(
+    db: &dyn HirDatabase,
+    _: salsa::Id,
+    _: GenericDefId,
+) -> InferenceResult {
+    InferenceResult {
+        has_errors: true,
+        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
+    }
+}
+
 /// Binding modes inferred for patterns.
 /// <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
@@ -555,9 +618,37 @@ impl InferenceResult {
     pub fn for_body(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
         infer_query(db, def)
     }
+
+    /// Infer types for all const expressions in an item's signature.
+    ///
+    /// Returns an `InferenceResult` containing type information for array lengths,
+    /// const generic arguments, and other const expressions appearing in type
+    /// positions within the item's signature.
+    #[salsa::tracked(returns(ref), cycle_result = infer_signature_cycle_result)]
+    pub fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
+        infer_signature_query(db, def)
+    }
 }
 
 impl InferenceResult {
+    /// Look up inference results for a specific anonymous const in a signature.
+    ///
+    /// This delegates to [`Self::for_signature`] on the anon const's owner.
+    /// The returned `InferenceResult` contains types for *all* expressions in
+    /// the owner's signature store, not just this anon const's sub-tree.
+    /// Callers should index into it with `loc.expr` to get the root expression's
+    /// type.
+    // FIXME: This function doesn't make sense in that we can't return a full inference result here
+    // as the anon const is just part of an inference result.
+    pub fn for_anon_const(db: &dyn HirDatabase, id: AnonConstId) -> &InferenceResult {
+        match id.lookup(db).owner {
+            ExpressionStoreOwner::Signature(generic_def_id) => {
+                Self::for_signature(db, generic_def_id)
+            }
+            ExpressionStoreOwner::Body(def_with_body_id) => Self::for_body(db, def_with_body_id),
+        }
+    }
+
     fn new(error_ty: Ty<'_>) -> Self {
         Self {
             method_resolutions: Default::default(),
@@ -754,7 +845,7 @@ pub fn binding_ty<'db>(&self, id: BindingId) -> Ty<'db> {
 #[derive(Clone, Debug)]
 pub(crate) struct InferenceContext<'body, 'db> {
     pub(crate) db: &'db dyn HirDatabase,
-    pub(crate) owner: DefWithBodyId,
+    pub(crate) owner: ExpressionStoreOwner,
     pub(crate) body: &'body Body,
     /// Generally you should not resolve things via this resolver. Instead create a TyLoweringContext
     /// and resolve the path via its methods. This will ensure proper error reporting.
@@ -855,12 +946,18 @@ fn find_continuable<'a, 'db>(
 impl<'body, 'db> InferenceContext<'body, 'db> {
     fn new(
         db: &'db dyn HirDatabase,
-        owner: DefWithBodyId,
+        owner: ExpressionStoreOwner,
         body: &'body Body,
         resolver: Resolver<'db>,
     ) -> Self {
-        let trait_env = db.trait_environment_for_body(owner);
-        let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
+        let trait_env = match owner {
+            ExpressionStoreOwner::Signature(generic_def_id) => db.trait_environment(generic_def_id),
+            ExpressionStoreOwner::Body(def_with_body_id) => {
+                db.trait_environment_for_body(def_with_body_id)
+            }
+        };
+        let table =
+            unify::InferenceTable::new(db, trait_env, resolver.krate(), owner.as_def_with_body());
         let types = crate::next_solver::default_types(db);
         InferenceContext {
             result: InferenceResult::new(types.types.error),
@@ -878,12 +975,7 @@ fn new(
             return_coercion: None,
             db,
             owner,
-            generic_def: match owner {
-                DefWithBodyId::FunctionId(it) => it.into(),
-                DefWithBodyId::StaticId(it) => it.into(),
-                DefWithBodyId::ConstId(it) => it.into(),
-                DefWithBodyId::VariantId(it) => it.lookup(db).parent.into(),
-            },
+            generic_def: owner.generic_def(db),
             body,
             traits_in_scope: resolver.traits_in_scope(db),
             resolver,
@@ -908,7 +1000,9 @@ fn krate(&self) -> Crate {
     fn target_features(&self) -> (&TargetFeatures<'db>, TargetFeatureIsSafeInTarget) {
         let (target_features, target_feature_is_safe) = self.target_features.get_or_init(|| {
             let target_features = match self.owner {
-                DefWithBodyId::FunctionId(id) => TargetFeatures::from_fn(self.db, id),
+                ExpressionStoreOwner::Body(DefWithBodyId::FunctionId(id)) => {
+                    TargetFeatures::from_fn(self.db, id)
+                }
                 _ => TargetFeatures::default(),
             };
             let target_feature_is_safe = match &self.krate().workspace_data(self.db).target {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
index 5a3eba1a71ae..b4cc2ab4ae5b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -866,7 +866,7 @@ fn restrict_precision_for_unsafe(&mut self) {
                     &self.table.infer_ctxt,
                     self.table.param_env,
                     ty,
-                    self.owner.module(self.db).krate(self.db),
+                    self.owner.krate(self.db),
                 );
                 if ty.is_raw_ptr() || ty.is_union() {
                     capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index e79868f4ae6b..47a70492487e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -1718,6 +1718,9 @@ fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
 
 fn is_capturing_closure(db: &dyn HirDatabase, closure: InternedClosureId) -> bool {
     let InternedClosure(owner, expr) = closure.loc(db);
-    upvars_mentioned(db, owner)
+    let Some(body_owner) = owner.as_def_with_body() else {
+        return false;
+    };
+    upvars_mentioned(db, body_owner)
         .is_some_and(|upvars| upvars.get(&expr).is_some_and(|upvars| !upvars.is_empty()))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 87fd0dace38f..9ba2d634d58a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -3,7 +3,7 @@
 use std::{cmp, iter};
 
 use hir_def::{
-    HasModule,
+    HasModule as _,
     expr_store::{Body, path::Path},
     hir::{Binding, BindingAnnotation, BindingId, Expr, ExprId, Literal, Pat, PatId},
 };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 525100439f5b..a325b2e17438 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -333,7 +333,10 @@ pub fn layout_of_ty_query(
         }
         TyKind::Closure(id, args) => {
             let def = db.lookup_intern_closure(id.0);
-            let infer = InferenceResult::for_body(db, def.0);
+            let Some(body_owner) = def.0.as_def_with_body() else {
+                return Err(LayoutError::HasErrorType);
+            };
+            let infer = InferenceResult::for_body(db, body_owner);
             let (captures, _) = infer.closure_info(id.0);
             let fields = captures
                 .iter()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 49594f34fd73..45500cfd2213 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -279,11 +279,12 @@ pub fn lower_ty(&mut self, type_ref: TypeRefId) -> Ty<'db> {
     }
 
     pub(crate) fn lower_const(&mut self, const_ref: ConstRef, const_type: Ty<'db>) -> Const<'db> {
-        let const_ref = &self.store[const_ref.expr];
-        match const_ref {
-            hir_def::hir::Expr::Path(path) => {
-                self.path_to_const(path).unwrap_or_else(|| unknown_const(const_type))
-            }
+        let expr_id = const_ref.expr;
+        let expr = &self.store[expr_id];
+        match expr {
+            hir_def::hir::Expr::Path(path) => self
+                .path_to_const(path)
+                .unwrap_or_else(|| Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))),
             hir_def::hir::Expr::Literal(literal) => {
                 intern_const_ref(self.db, literal, const_type, self.resolver.krate())
             }
@@ -300,20 +301,74 @@ pub(crate) fn lower_const(&mut self, const_ref: ConstRef, const_type: Ty<'db>) -
                                     self.resolver.krate(),
                                 )
                             } else {
-                                unknown_const(const_type)
+                                Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))
                             }
                         }
                         // For unsigned integers, chars, bools, etc., negation is not meaningful
-                        _ => unknown_const(const_type),
+                        _ => Const::new(self.interner, ConstKind::Error(ErrorGuaranteed)),
                     }
                 } else {
-                    unknown_const(const_type)
+                    // Complex negation expression (e.g. `-N` where N is a const param)
+                    self.lower_const_as_unevaluated(expr_id, const_type)
                 }
             }
-            _ => unknown_const(const_type),
+            hir_def::hir::Expr::Underscore => {
+                Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))
+            }
+            // Any other complex expression becomes an unevaluated anonymous const.
+            _ => self.lower_const_as_unevaluated(expr_id, const_type),
         }
     }
 
+    /// Lower a complex const expression to an `UnevaluatedConst` backed by an `AnonConstId`.
+    ///
+    /// The `expected_ty_ref` is `None` for array lengths (implicitly `usize`) or
+    /// `Some(type_ref_id)` for const generic arguments where the expected type comes
+    /// from the const parameter declaration.
+    fn lower_const_as_unevaluated(
+        &mut self,
+        _expr: hir_def::hir::ExprId,
+        _expected_ty: Ty<'db>,
+    ) -> Const<'db> {
+        // /// Build the identity generic args for the current generic context.
+        // ///
+        // /// This maps each generic parameter to itself (as a `ParamTy`, `ParamConst`,
+        // /// or `EarlyParamRegion`), which is the correct substitution when creating
+        // /// an `UnevaluatedConst` during type lowering — the anon const inherits the
+        // /// parent's generics and they haven't been substituted yet.
+        // fn current_generic_args(&self) -> GenericArgs<'db> {
+        //     let generics = self.generics();
+        //     let interner = self.interner;
+        //     GenericArgs::new_from_iter(
+        //         interner,
+        //         generics.iter_id().enumerate().map(|(index, id)| match id {
+        //             GenericParamId::TypeParamId(id) => {
+        //                 GenericArg::from(Ty::new_param(interner, id, index as u32))
+        //             }
+        //             GenericParamId::ConstParamId(id) => GenericArg::from(Const::new_param(
+        //                 interner,
+        //                 ParamConst { id, index: index as u32 },
+        //             )),
+        //             GenericParamId::LifetimeParamId(id) => GenericArg::from(Region::new_early_param(
+        //                 interner,
+        //                 EarlyParamRegion { id, index: index as u32 },
+        //             )),
+        //         }),
+        //     )
+        // }
+        // let loc = AnonConstLoc { owner: self.def, expr };
+        // let id = loc.intern(self.db);
+        // let args = self.current_generic_args();
+        // Const::new(
+        //     self.interner,
+        //     ConstKind::Unevaluated(UnevaluatedConst::new(
+        //         GeneralConstId::AnonConstId(id).into(),
+        //         args,
+        //     )),
+        // )
+        Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))
+    }
+
     pub(crate) fn path_to_const(&mut self, path: &Path) -> Option<Const<'db>> {
         match self.resolver.resolve_path_in_value_ns_fully(self.db, path, HygieneId::ROOT) {
             Some(ValueNs::GenericParam(p)) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
index dece61a57df5..2dcc2d1062fd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
@@ -8,7 +8,7 @@
 use hir_def::{DefWithBodyId, HasModule};
 use la_arena::ArenaMap;
 use rustc_hash::FxHashMap;
-use rustc_type_ir::inherent::GenericArgs as _;
+use rustc_type_ir::inherent::{GenericArgs as _, Ty as _};
 use stdx::never;
 use triomphe::Arc;
 
@@ -18,7 +18,7 @@
     display::DisplayTarget,
     mir::OperandKind,
     next_solver::{
-        DbInterner, GenericArgs, ParamEnv, StoredTy, Ty, TypingMode,
+        DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, StoredTy, Ty, TypingMode,
         infer::{DbInternerInferExt, InferCtxt},
     },
 };
@@ -121,11 +121,14 @@ fn make_fetch_closure_field<'db>(
     db: &'db dyn HirDatabase,
 ) -> impl FnOnce(InternedClosureId, GenericArgs<'db>, usize) -> Ty<'db> + use<'db> {
     |c: InternedClosureId, subst: GenericArgs<'db>, f: usize| {
-        let InternedClosure(def, _) = db.lookup_intern_closure(c);
+        let InternedClosure(owner, _) = db.lookup_intern_closure(c);
+        let interner = DbInterner::new_no_crate(db);
+        let Some(def) = owner.as_def_with_body() else {
+            return Ty::new_error(interner, ErrorGuaranteed);
+        };
         let infer = InferenceResult::for_body(db, def);
         let (captures, _) = infer.closure_info(c);
         let parent_subst = subst.as_closure().parent_args();
-        let interner = DbInterner::new_no_crate(db);
         captures.get(f).expect("broken closure field").ty.get().instantiate(interner, parent_subst)
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index ec0723c3f8c3..a85b3ef50aa5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -730,7 +730,10 @@ fn projected_ty(&self, ty: Ty<'db>, proj: PlaceElem) -> Ty<'db> {
             self.param_env.param_env,
             ty,
             |c, subst, f| {
-                let InternedClosure(def, _) = self.db.lookup_intern_closure(c);
+                let InternedClosure(owner, _) = self.db.lookup_intern_closure(c);
+                let Some(def) = owner.as_def_with_body() else {
+                    return Ty::new_error(self.interner(), ErrorGuaranteed);
+                };
                 let infer = InferenceResult::for_body(self.db, def);
                 let (captures, _) = infer.closure_info(c);
                 let parent_subst = subst.as_closure().parent_args();
@@ -1954,6 +1957,9 @@ fn allocate_const_in_heap(
                             MirEvalError::ConstEvalError(name, Box::new(e))
                         })?
                     }
+                    GeneralConstId::AnonConstId(_) => {
+                        not_supported!("anonymous const evaluation")
+                    }
                 };
                 if let ConstKind::Value(value) = result_owner.kind() {
                     break 'b value;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index 76c8701ea209..a0dd3b5846f4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -152,7 +152,10 @@ fn exec_clone(
                     not_supported!("wrong arg count for clone");
                 };
                 let addr = Address::from_bytes(arg.get(self)?)?;
-                let InternedClosure(closure_owner, _) = self.db.lookup_intern_closure(id.0);
+                let InternedClosure(owner, _) = self.db.lookup_intern_closure(id.0);
+                let Some(closure_owner) = owner.as_def_with_body() else {
+                    not_supported!("closure in non-body context");
+                };
                 let infer = InferenceResult::for_body(self.db, closure_owner);
                 let (captures, _) = infer.closure_info(id.0);
                 let layout = self.layout(self_ty)?;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 2e849bcf3a12..269d8729baf3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -1546,6 +1546,9 @@ fn lower_const_to_operand(
                         MirLowerError::ConstEvalError(name.into(), Box::new(e))
                     })?
                 }
+                GeneralConstId::AnonConstId(_) => {
+                    return Err(MirLowerError::IncompleteExpr);
+                }
             }
         };
         let ty = self
@@ -1553,6 +1556,7 @@ fn lower_const_to_operand(
             .value_ty(match const_id {
                 GeneralConstId::ConstId(id) => id.into(),
                 GeneralConstId::StaticId(id) => id.into(),
+                GeneralConstId::AnonConstId(_) => unreachable!("handled above"),
             })
             .unwrap()
             .instantiate(self.interner(), subst);
@@ -2106,8 +2110,10 @@ pub fn mir_body_for_closure_query<'db>(
     closure: InternedClosureId,
 ) -> Result<'db, Arc<MirBody>> {
     let InternedClosure(owner, expr) = db.lookup_intern_closure(closure);
-    let body = db.body(owner);
-    let infer = InferenceResult::for_body(db, owner);
+    let body_owner =
+        owner.as_def_with_body().expect("MIR lowering should only happen for body-owned closures");
+    let body = db.body(body_owner);
+    let infer = InferenceResult::for_body(db, body_owner);
     let Expr::Closure { args, body: root, .. } = &body[expr] else {
         implementation_error!("closure expression is not closure");
     };
@@ -2115,7 +2121,7 @@ pub fn mir_body_for_closure_query<'db>(
         implementation_error!("closure expression is not closure");
     };
     let (captures, kind) = infer.closure_info(closure);
-    let mut ctx = MirLowerCtx::new(db, owner, &body.store, infer);
+    let mut ctx = MirLowerCtx::new(db, body_owner, &body.store, infer);
     // 0 is return local
     ctx.result.locals.alloc(Local { ty: infer.expr_ty(*root).store() });
     let closure_local = ctx.result.locals.alloc(Local {
@@ -2138,7 +2144,7 @@ pub fn mir_body_for_closure_query<'db>(
     });
     ctx.result.param_locals.push(closure_local);
     let sig = ctx.interner().signature_unclosure(substs.as_closure().sig(), Safety::Safe);
-    let resolver_guard = ctx.resolver.update_to_inner_scope(db, owner, expr);
+    let resolver_guard = ctx.resolver.update_to_inner_scope(db, body_owner, expr);
     let current = ctx.lower_params_and_bindings(
         args.iter().zip(sig.skip_binder().inputs().iter()).map(|(it, y)| (*it, *y)),
         None,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index aa6caefc4a06..e76ab16fc2c7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -1,9 +1,9 @@
 //! Definition of `SolverDefId`
 
 use hir_def::{
-    AdtId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId, EnumId,
-    EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId, StaticId, StructId, TraitId,
-    TypeAliasId, UnionId,
+    AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,
+    EnumId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId, StaticId, StructId,
+    TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -26,6 +26,7 @@ pub enum SolverDefId {
     ImplId(ImplId),
     BuiltinDeriveImplId(BuiltinDeriveImplId),
     StaticId(StaticId),
+    AnonConstId(AnonConstId),
     TraitId(TraitId),
     TypeAliasId(TypeAliasId),
     InternedClosureId(InternedClosureId),
@@ -88,6 +89,7 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                     ))
                     .finish()
             }
+            SolverDefId::AnonConstId(id) => f.debug_tuple("AnonConstId").field(&id).finish(),
             SolverDefId::Ctor(Ctor::Struct(id)) => {
                 f.debug_tuple("Ctor").field(&db.struct_signature(id).name.as_str()).finish()
             }
@@ -112,6 +114,7 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     ImplId,
     BuiltinDeriveImplId,
     StaticId,
+    AnonConstId,
     TraitId,
     TypeAliasId,
     InternedClosureId,
@@ -142,6 +145,7 @@ fn from(value: GeneralConstId) -> Self {
         match value {
             GeneralConstId::ConstId(const_id) => SolverDefId::ConstId(const_id),
             GeneralConstId::StaticId(static_id) => SolverDefId::StaticId(static_id),
+            GeneralConstId::AnonConstId(anon_const_id) => SolverDefId::AnonConstId(anon_const_id),
         }
     }
 }
@@ -176,7 +180,8 @@ fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
             SolverDefId::BuiltinDeriveImplId(_)
             | SolverDefId::InternedClosureId(_)
             | SolverDefId::InternedCoroutineId(_)
-            | SolverDefId::InternedOpaqueTyId(_) => Err(()),
+            | SolverDefId::InternedOpaqueTyId(_)
+            | SolverDefId::AnonConstId(_) => Err(()),
         }
     }
 }
@@ -199,6 +204,7 @@ fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
             | SolverDefId::InternedClosureId(_)
             | SolverDefId::InternedCoroutineId(_)
             | SolverDefId::Ctor(Ctor::Struct(_))
+            | SolverDefId::AnonConstId(_)
             | SolverDefId::AdtId(_) => return Err(()),
         };
         Ok(id)
@@ -222,6 +228,7 @@ fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
             | SolverDefId::InternedOpaqueTyId(_)
             | SolverDefId::EnumVariantId(_)
             | SolverDefId::BuiltinDeriveImplId(_)
+            | SolverDefId::AnonConstId(_)
             | SolverDefId::Ctor(_) => return Err(()),
         })
     }
@@ -343,6 +350,7 @@ fn from(value: GeneralConstIdWrapper) -> SolverDefId {
         match value.0 {
             GeneralConstId::ConstId(id) => SolverDefId::ConstId(id),
             GeneralConstId::StaticId(id) => SolverDefId::StaticId(id),
+            GeneralConstId::AnonConstId(id) => SolverDefId::AnonConstId(id),
         }
     }
 }
@@ -353,6 +361,7 @@ fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
         match value {
             SolverDefId::ConstId(it) => Ok(Self(it.into())),
             SolverDefId::StaticId(it) => Ok(Self(it.into())),
+            SolverDefId::AnonConstId(it) => Ok(Self(it.into())),
             _ => Err(()),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index e17bdac68cdd..dba4e74730f1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -10,8 +10,8 @@
 
 use base_db::Crate;
 use hir_def::{
-    AdtId, CallableDefId, DefWithBodyId, EnumVariantId, HasModule, ItemContainerId, StructId,
-    UnionId, VariantId,
+    AdtId, CallableDefId, DefWithBodyId, EnumVariantId, ExpressionStoreOwner, HasModule,
+    ItemContainerId, StructId, UnionId, VariantId,
     attrs::AttrFlags,
     lang_item::LangItems,
     signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags},
@@ -1193,7 +1193,8 @@ fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf {
             | SolverDefId::ImplId(_)
             | SolverDefId::BuiltinDeriveImplId(_)
             | SolverDefId::InternedClosureId(_)
-            | SolverDefId::InternedCoroutineId(_) => {
+            | SolverDefId::InternedCoroutineId(_)
+            | SolverDefId::AnonConstId(_) => {
                 return VariancesOf::empty(self);
             }
         };
@@ -1260,7 +1261,9 @@ fn alias_term_kind(
             },
             // rustc creates an `AnonConst` for consts, and evaluates them with CTFE (normalizing projections
             // via selection, similar to ours `find_matching_impl()`, and not with the trait solver), so mimic it.
-            SolverDefId::ConstId(_) => AliasTermKind::UnevaluatedConst,
+            SolverDefId::ConstId(_) | SolverDefId::AnonConstId(_) => {
+                AliasTermKind::UnevaluatedConst
+            }
             _ => unimplemented!("Unexpected alias: {:?}", alias.def_id),
         }
     }
@@ -1308,22 +1311,10 @@ fn parent(self, def_id: Self::DefId) -> Self::DefId {
             SolverDefId::TypeAliasId(it) => it.lookup(self.db()).container,
             SolverDefId::ConstId(it) => it.lookup(self.db()).container,
             SolverDefId::InternedClosureId(it) => {
-                return self
-                    .db()
-                    .lookup_intern_closure(it)
-                    .0
-                    .as_generic_def_id(self.db())
-                    .unwrap()
-                    .into();
+                return self.db().lookup_intern_closure(it).0.generic_def(self.db()).into();
             }
             SolverDefId::InternedCoroutineId(it) => {
-                return self
-                    .db()
-                    .lookup_intern_coroutine(it)
-                    .0
-                    .as_generic_def_id(self.db())
-                    .unwrap()
-                    .into();
+                return self.db().lookup_intern_coroutine(it).0.generic_def(self.db()).into();
             }
             SolverDefId::StaticId(_)
             | SolverDefId::AdtId(_)
@@ -1332,7 +1323,8 @@ fn parent(self, def_id: Self::DefId) -> Self::DefId {
             | SolverDefId::BuiltinDeriveImplId(_)
             | SolverDefId::EnumVariantId(..)
             | SolverDefId::Ctor(..)
-            | SolverDefId::InternedOpaqueTyId(..) => panic!(),
+            | SolverDefId::InternedOpaqueTyId(..)
+            | SolverDefId::AnonConstId(_) => panic!(),
         };
 
         match container {
@@ -1361,7 +1353,10 @@ fn coroutine_movability(self, def_id: Self::CoroutineId) -> rustc_ast_ir::Movabi
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let body = self.db.body(owner);
+        let Some(body_owner) = owner.as_def_with_body() else {
+            return rustc_ast_ir::Movability::Static;
+        };
+        let body = self.db.body(body_owner);
         let expr = &body[expr_id];
         match *expr {
             hir_def::hir::Expr::Closure { closure_kind, .. } => match closure_kind {
@@ -1795,6 +1790,7 @@ fn for_each_relevant_impl(
                     | SolverDefId::InternedCoroutineId(_)
                     | SolverDefId::InternedOpaqueTyId(_)
                     | SolverDefId::EnumVariantId(_)
+                    | SolverDefId::AnonConstId(_)
                     | SolverDefId::Ctor(_) => return None,
                 };
                 module.block(self.db)
@@ -2006,7 +2002,10 @@ fn is_general_coroutine(self, def_id: Self::CoroutineId) -> bool {
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let body = self.db.body(owner);
+        let Some(body_owner) = owner.as_def_with_body() else {
+            return false;
+        };
+        let body = self.db.body(body_owner);
         matches!(
             body[expr_id],
             hir_def::hir::Expr::Closure {
@@ -2020,7 +2019,10 @@ fn coroutine_is_async(self, def_id: Self::CoroutineId) -> bool {
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let body = self.db.body(owner);
+        let Some(body_owner) = owner.as_def_with_body() else {
+            return false;
+        };
+        let body = self.db.body(body_owner);
         matches!(
             body[expr_id],
             hir_def::hir::Expr::Closure { closure_kind: hir_def::hir::ClosureKind::Async, .. }
@@ -2154,8 +2156,10 @@ fn opaque_types_and_coroutines_defined_by(self, def_id: Self::LocalDefId) -> Sel
                         ..
                     }
             ) {
-                let coroutine =
-                    InternedCoroutineId::new(self.db, InternedCoroutine(def_id, expr_id));
+                let coroutine = InternedCoroutineId::new(
+                    self.db,
+                    InternedCoroutine(ExpressionStoreOwner::Body(def_id), expr_id),
+                );
                 result.push(coroutine.into());
             }
         });
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 15d6e2e4516e..54baa8ac41ac 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -18,7 +18,7 @@
 };
 
 use super::{
-    DbInterner, ErrorGuaranteed, GenericArg, SolverDefId, Span,
+    Const, DbInterner, ErrorGuaranteed, GenericArg, SolverDefId, Span,
     infer::{DbInternerInferExt, InferCtxt, canonical::instantiate::CanonicalExt},
 };
 
@@ -256,6 +256,11 @@ fn evaluate_const(
                 let ec = self.cx().db.const_eval_static(c).ok()?;
                 Some(ec)
             }
+            // TODO: Wire up const_eval_anon query in Phase 5.
+            // For now, return an error const so normalization resolves the
+            // unevaluated const to Error (matching the old behavior where
+            // complex expressions produced ConstKind::Error directly).
+            GeneralConstId::AnonConstId(_) => Some(Const::error(self.cx())),
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 1173028a1092..09b1585866b0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -714,7 +714,7 @@ pub fn impl_trait_bounds(self, db: &'db dyn HirDatabase) -> Option<Vec<Clause<'d
             }
             TyKind::Coroutine(coroutine_id, _args) => {
                 let InternedCoroutine(owner, _) = coroutine_id.0.loc(db);
-                let krate = owner.module(db).krate(db);
+                let krate = owner.krate(db);
                 if let Some(future_trait) = hir_def::lang_item::lang_items(db, krate).Future {
                     // This is only used by type walking.
                     // Parameters will be walked outside, and projection predicate is not used.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
index f089120cd7b8..6e55641e56f2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
@@ -40,7 +40,8 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
             captures_info.extend(infer.closure_info.iter().flat_map(
                 |(closure_id, (captures, _))| {
                     let closure = db.lookup_intern_closure(*closure_id);
-                    let source_map = db.body_with_source_map(closure.0).1;
+                    let body_owner = closure.0.as_def_with_body().unwrap();
+                    let source_map = db.body_with_source_map(body_owner).1;
                     let closure_text_range = source_map
                         .expr_syntax(closure.1)
                         .expect("failed to map closure to SyntaxNode")
@@ -56,7 +57,7 @@ fn text_range<N: AstNode>(
                         }
 
                         // FIXME: Deduplicate this with hir::Local::sources().
-                        let (body, source_map) = db.body_with_source_map(closure.0);
+                        let (body, source_map) = db.body_with_source_map(body_owner);
                         let local_text_range =
                             match body.self_param.zip(source_map.self_param_syntax()) {
                                 Some((param, source)) if param == capture.local() => {
@@ -71,7 +72,7 @@ fn text_range<N: AstNode>(
                                     .map(|it| format!("{it:?}"))
                                     .join(", "),
                             };
-                        let place = capture.display_place(closure.0, db);
+                        let place = capture.display_place(body_owner, db);
                         let capture_ty = capture
                             .ty
                             .get()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index faa7b80a89c2..0fbf8acf530f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -48,7 +48,7 @@ fn foo() -> i32 {
                 "crate_lang_items",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
             ]
         "#]],
     );
@@ -136,7 +136,7 @@ fn baz() -> i32 {
                 "crate_lang_items",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
                 "InferenceResult::for_body_",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -146,7 +146,7 @@ fn baz() -> i32 {
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
                 "InferenceResult::for_body_",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -156,7 +156,7 @@ fn baz() -> i32 {
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
             ]
         "#]],
     );
@@ -204,7 +204,7 @@ fn baz() -> i32 {
                 "body_with_source_map_shim",
                 "body_shim",
                 "InferenceResult::for_body_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
                 "AttrFlags::query_",
                 "function_signature_with_source_map_shim",
                 "function_signature_shim",
@@ -600,7 +600,7 @@ fn main() {
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
                 "struct_signature_shim",
                 "struct_signature_with_source_map_shim",
                 "AttrFlags::query_",
@@ -690,7 +690,7 @@ fn main() {
                 "function_signature_with_source_map_shim",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "expr_scopes_shim",
+                "body_expr_scopes_shim",
                 "struct_signature_with_source_map_shim",
                 "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index e032a16989ff..66bb3570665a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -293,7 +293,10 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
             }
             Callee::Closure(closure, _) => {
                 let InternedClosure(owner, expr_id) = db.lookup_intern_closure(closure);
-                let (_, source_map) = db.body_with_source_map(owner);
+                let Some(body_owner) = owner.as_def_with_body() else {
+                    return None;
+                };
+                let (_, source_map) = db.body_with_source_map(body_owner);
                 let ast @ InFile { file_id, value } = source_map.expr_syntax(expr_id).ok()?;
                 let root = db.parse_or_expand(file_id);
                 match value.to_node(&root) {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 0b3515fd0498..6dfb94cbf36b 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1737,7 +1737,7 @@ pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
     }
 
     pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {
-        self.source(db)?.value.expr()
+        self.source(db)?.value.const_arg()?.expr()
     }
 
     pub fn eval(self, db: &dyn HirDatabase) -> Result<i128, ConstEvalError> {
@@ -2891,11 +2891,12 @@ pub fn as_local(&self, db: &dyn HirDatabase) -> Option<Local> {
             }
             Callee::Closure(closure, _) => {
                 let c = db.lookup_intern_closure(closure);
-                let body = db.body(c.0);
+                let body_owner = c.0.as_def_with_body()?;
+                let body = db.body(body_owner);
                 if let Expr::Closure { args, .. } = &body[c.1]
                     && let Pat::Bind { id, .. } = &body[args[self.idx]]
                 {
-                    return Some(Local { parent: c.0, binding_id: *id });
+                    return Some(Local { parent: body_owner, binding_id: *id });
                 }
                 None
             }
@@ -5012,13 +5013,16 @@ pub fn captured_items(&self, db: &'db dyn HirDatabase) -> Vec<ClosureCapture<'db
             return Vec::new();
         };
         let owner = db.lookup_intern_closure(id).0;
-        let infer = InferenceResult::for_body(db, owner);
+        let Some(body_owner) = owner.as_def_with_body() else {
+            return Vec::new();
+        };
+        let infer = InferenceResult::for_body(db, body_owner);
         let info = infer.closure_info(id);
         info.0
             .iter()
             .cloned()
             .map(|capture| ClosureCapture {
-                owner,
+                owner: body_owner,
                 closure: id,
                 capture,
                 _marker: PhantomCovariantLifetime::new(),
@@ -5032,9 +5036,12 @@ pub fn capture_types(&self, db: &'db dyn HirDatabase) -> Vec<Type<'db>> {
             return Vec::new();
         };
         let owner = db.lookup_intern_closure(id).0;
-        let infer = InferenceResult::for_body(db, owner);
+        let Some(body_owner) = owner.as_def_with_body() else {
+            return Vec::new();
+        };
+        let infer = InferenceResult::for_body(db, body_owner);
         let (captures, _) = infer.closure_info(id);
-        let env = body_param_env_from_has_crate(db, owner);
+        let env = body_param_env_from_has_crate(db, body_owner);
         captures.iter().map(|capture| Type { env, ty: capture.ty(db, self.subst) }).collect()
     }
 
@@ -5042,7 +5049,10 @@ pub fn fn_trait(&self, db: &dyn HirDatabase) -> FnTrait {
         match self.id {
             AnyClosureId::ClosureId(id) => {
                 let owner = db.lookup_intern_closure(id).0;
-                let infer = InferenceResult::for_body(db, owner);
+                let Some(body_owner) = owner.as_def_with_body() else {
+                    return FnTrait::FnOnce;
+                };
+                let infer = InferenceResult::for_body(db, body_owner);
                 let info = infer.closure_info(id);
                 info.1.into()
             }
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index c6f2d151f582..18929f82090c 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -123,7 +123,7 @@ pub(crate) fn new_for_body_(
         infer: Option<&'db InferenceResult>,
     ) -> SourceAnalyzer<'db> {
         let (body, source_map) = db.body_with_source_map(def);
-        let scopes = db.expr_scopes(def);
+        let scopes = db.expr_scopes(def.into());
         let scope = match offset {
             None => scope_for(db, &scopes, &source_map, node),
             Some(offset) => {
@@ -1045,7 +1045,7 @@ pub(crate) fn resolve_path(
         }
 
         // FIXME: collectiong here shouldnt be necessary?
-        let mut collector = ExprCollector::new(db, self.resolver.module(), self.file_id);
+        let mut collector = ExprCollector::body(db, self.resolver.module(), self.file_id);
         let hir_path =
             collector.lower_path(path.clone(), &mut ExprCollector::impl_trait_error_allocator)?;
         let parent_hir_path = path
@@ -1253,7 +1253,7 @@ pub(crate) fn resolve_hir_path_per_ns(
         db: &dyn HirDatabase,
         path: &ast::Path,
     ) -> Option<PathResolutionPerNs> {
-        let mut collector = ExprCollector::new(db, self.resolver.module(), self.file_id);
+        let mut collector = ExprCollector::body(db, self.resolver.module(), self.file_id);
         let hir_path =
             collector.lower_path(path.clone(), &mut ExprCollector::impl_trait_error_allocator)?;
         let (store, _) = collector.store.finish();
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_explicit_enum_discriminant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_explicit_enum_discriminant.rs
index 7960373e6193..75c5f84b8501 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_explicit_enum_discriminant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_explicit_enum_discriminant.rs
@@ -47,7 +47,7 @@ pub(crate) fn add_explicit_enum_discriminant(
 
     // Don't offer the assist if the enum has no variants or if all variants already have an
     // explicit discriminant.
-    if variant_list.variants().all(|variant_node| variant_node.expr().is_some()) {
+    if variant_list.variants().all(|variant_node| variant_node.const_arg().is_some()) {
         return None;
     }
 
@@ -72,7 +72,9 @@ fn add_variant_discriminant(
     variant_node: &ast::Variant,
     radix: &mut Radix,
 ) {
-    if let Some(expr) = variant_node.expr() {
+    if let Some(expr) = variant_node.const_arg()
+        && let Some(expr) = expr.expr()
+    {
         *radix = expr_radix(&expr).unwrap_or(*radix);
         return;
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/discriminant.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/discriminant.rs
index 5b9267126f8a..e845faec565f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/discriminant.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/discriminant.rs
@@ -46,7 +46,7 @@ fn variant_hints(
     enum_: &ast::Enum,
     variant: &ast::Variant,
 ) -> Option<()> {
-    if variant.expr().is_some() {
+    if variant.const_arg().is_some() {
         return None;
     }
 
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/items/adt.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/items/adt.rs
index a37569614028..cfba4c3a77b2 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/items/adt.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/items/adt.rs
@@ -96,7 +96,9 @@ fn variant(p: &mut Parser<'_>) {
             // test variant_discriminant
             // enum E { X(i32) = 10 }
             if p.eat(T![=]) {
+                let m = p.start();
                 expressions::expr(p);
+                m.complete(p, CONST_ARG);
             }
             m.complete(p, VARIANT);
         } else {
@@ -139,7 +141,9 @@ fn record_field(p: &mut Parser<'_>) {
             // test record_field_default_values
             // struct S { f: f32 = 0.0 }
             if p.eat(T![=]) {
+                let m = p.start();
                 expressions::expr(p);
+                m.complete(p, CONST_ARG);
             }
             m.complete(p, RECORD_FIELD);
         } else {
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/record_field_default_values.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/record_field_default_values.rast
index 33088f2cabf3..e53b886bbff8 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/record_field_default_values.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/record_field_default_values.rast
@@ -21,8 +21,9 @@ SOURCE_FILE
         WHITESPACE " "
         EQ "="
         WHITESPACE " "
-        LITERAL
-          FLOAT_NUMBER "0.0"
+        CONST_ARG
+          LITERAL
+            FLOAT_NUMBER "0.0"
       WHITESPACE " "
       R_CURLY "}"
   WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/variant_discriminant.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/variant_discriminant.rast
index 9f0c5a76108d..3494085e88fa 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/variant_discriminant.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/variant_discriminant.rast
@@ -23,8 +23,9 @@ SOURCE_FILE
         WHITESPACE " "
         EQ "="
         WHITESPACE " "
-        LITERAL
-          INT_NUMBER "10"
+        CONST_ARG
+          LITERAL
+            INT_NUMBER "10"
       WHITESPACE " "
       R_CURLY "}"
   WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0019_enums.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0019_enums.rast
index dd47e3aa47ad..51837e5372a7 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0019_enums.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0019_enums.rast
@@ -78,8 +78,9 @@ SOURCE_FILE
         WHITESPACE " "
         EQ "="
         WHITESPACE " "
-        LITERAL
-          INT_NUMBER "92"
+        CONST_ARG
+          LITERAL
+            INT_NUMBER "92"
       COMMA ","
       WHITESPACE "\n    "
       VARIANT
diff --git a/src/tools/rust-analyzer/crates/syntax/rust.ungram b/src/tools/rust-analyzer/crates/syntax/rust.ungram
index 544053408f73..3113fc74308b 100644
--- a/src/tools/rust-analyzer/crates/syntax/rust.ungram
+++ b/src/tools/rust-analyzer/crates/syntax/rust.ungram
@@ -245,7 +245,7 @@ RecordFieldList =
 
 RecordField =
   Attr* Visibility? 'unsafe'?
-  Name ':' Type ('=' Expr)?
+  Name ':' Type ('=' default_val:ConstArg)?
 
 TupleFieldList =
   '(' fields:(TupleField (',' TupleField)* ','?)? ')'
@@ -268,7 +268,7 @@ VariantList =
 
 Variant =
   Attr* Visibility?
-  Name FieldList? ('=' Expr)?
+  Name FieldList? ('=' ConstArg)?
 
 Union =
   Attr* Visibility?
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
index c4e72eafa793..7334de0fd96f 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
@@ -1337,7 +1337,7 @@ impl ast::HasName for RecordField {}
 impl ast::HasVisibility for RecordField {}
 impl RecordField {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }
     #[inline]
     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
     #[inline]
@@ -1896,7 +1896,7 @@ impl ast::HasName for Variant {}
 impl ast::HasVisibility for Variant {}
 impl Variant {
     #[inline]
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
     #[inline]
     pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
     #[inline]
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index d0f14dafe3f0..90a326ff9eab 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1503,8 +1503,10 @@ pub fn variant(
             }
 
             if let Some(discriminant) = discriminant {
-                builder
-                    .map_node(discriminant.syntax().clone(), ast.expr().unwrap().syntax().clone());
+                builder.map_node(
+                    discriminant.syntax().clone(),
+                    ast.const_arg().unwrap().syntax().clone(),
+                );
             }
 
             builder.finish(&mut mapping);

From 42f4417d1a073c39ad249cf88a05fd67000f92c4 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sun, 15 Mar 2026 20:15:06 +0100
Subject: [PATCH 0625/1059] Make InferenceResult take an `ExpressionStore`

---
 .../crates/hir-ty/src/consteval.rs            | 17 +++---
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 57 +++++++------------
 .../hir-ty/src/infer/closure/analysis.rs      | 26 ++++-----
 .../crates/hir-ty/src/infer/expr.rs           | 24 ++++----
 .../crates/hir-ty/src/infer/mutability.rs     | 12 ++--
 .../crates/hir-ty/src/infer/pat.rs            | 26 ++++-----
 .../crates/hir-ty/src/infer/path.rs           |  4 +-
 .../hir-ty/src/method_resolution/confirm.rs   |  2 +-
 .../rust-analyzer/crates/hir-ty/src/mir.rs    |  8 +--
 .../crates/hir/src/has_source.rs              |  4 +-
 10 files changed, 83 insertions(+), 97 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 9ff788c2e218..c294238030bd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -8,7 +8,7 @@
     ConstId, EnumVariantId, GeneralConstId, HasModule, StaticId,
     attrs::AttrFlags,
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
-    expr_store::Body,
+    expr_store::ExpressionStore,
     hir::{Expr, ExprId, Literal},
 };
 use hir_expand::Lookup;
@@ -311,23 +311,23 @@ pub(crate) fn const_eval_discriminant_variant(
 // and make this function private. See the fixme comment on `InferenceContext::resolve_all`.
 pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'_, 'db>) -> Const<'db> {
     let infer = ctx.fixme_resolve_all_clone();
-    fn has_closure(body: &Body, expr: ExprId) -> bool {
-        if matches!(body[expr], Expr::Closure { .. }) {
+    fn has_closure(store: &ExpressionStore, expr: ExprId) -> bool {
+        if matches!(store[expr], Expr::Closure { .. }) {
             return true;
         }
         let mut r = false;
-        body.walk_child_exprs(expr, |idx| r |= has_closure(body, idx));
+        store.walk_child_exprs(expr, |idx| r |= has_closure(store, idx));
         r
     }
-    if has_closure(ctx.body, expr) {
+    if has_closure(ctx.store, expr) {
         // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic.
         return Const::error(ctx.interner());
     }
-    if let Expr::Path(p) = &ctx.body[expr] {
+    if let Expr::Path(p) = &ctx.store[expr] {
         let mut ctx = TyLoweringContext::new(
             ctx.db,
             &ctx.resolver,
-            ctx.body,
+            ctx.store,
             ctx.generic_def,
             LifetimeElisionKind::Infer,
         );
@@ -336,7 +336,8 @@ fn has_closure(body: &Body, expr: ExprId) -> bool {
         }
     }
     if let Some(body_owner) = ctx.owner.as_def_with_body()
-        && let Ok(mir_body) = lower_body_to_mir(ctx.db, body_owner, ctx.body, &infer, expr)
+        && let Ok(mir_body) =
+            lower_body_to_mir(ctx.db, body_owner, &ctx.db.body(body_owner), &infer, expr)
         && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None)
     {
         return result;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index a4fcded42b66..a78d5d8a3051 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -36,7 +36,7 @@
     AdtId, AnonConstId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner,
     FieldId, FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup,
     TraitId, TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
-    expr_store::{Body, ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
+    expr_store::{ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
     layout::Integer,
@@ -106,16 +106,14 @@ pub fn infer_query_with_inspect<'db>(
     let _p = tracing::info_span!("infer_query").entered();
     let resolver = def.resolver(db);
     let body = db.body(def);
-    let mut ctx = InferenceContext::new(db, ExpressionStoreOwner::Body(def), &body, resolver);
+    let mut ctx = InferenceContext::new(db, ExpressionStoreOwner::Body(def), &body.store, resolver);
 
     if let Some(inspect) = inspect {
         ctx.table.infer_ctxt.attach_obligation_inspector(inspect);
     }
 
     match def {
-        DefWithBodyId::FunctionId(f) => {
-            ctx.collect_fn(f);
-        }
+        DefWithBodyId::FunctionId(f) => ctx.collect_fn(f, body.self_param, &body.params),
         DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
         DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
         DefWithBodyId::VariantId(v) => {
@@ -144,9 +142,9 @@ pub fn infer_query_with_inspect<'db>(
         }
     }
 
-    ctx.infer_body();
+    ctx.infer_body(body.body_expr);
 
-    ctx.infer_mut_body();
+    ctx.infer_mut_body(body.body_expr);
 
     ctx.handle_opaque_type_uses();
 
@@ -190,25 +188,14 @@ fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceRe
     let _p = tracing::info_span!("infer_signature_query").entered();
     let (_, store) = db.generic_params_and_store(def);
     let mut roots = store.signature_const_expr_roots_with_origins().peekable();
-    let Some(&(first, _)) = roots.peek() else {
+    let Some(_) = roots.peek() else {
         return InferenceResult::new(crate::next_solver::default_types(db).types.error);
     };
 
     let resolver = def.resolver(db);
     let owner = ExpressionStoreOwner::Signature(def);
 
-    // Construct a synthetic `Body` to satisfy `InferenceContext`.
-    // The `body_expr` is set to the first root as a placeholder; we infer
-    // each root expression individually below rather than calling `infer_body`.
-    let body = Body {
-        // FIXME: Get rid of this clone
-        store: (*store).clone(),
-        params: Box::new([]),
-        self_param: None,
-        body_expr: first,
-    };
-
-    let mut ctx = InferenceContext::new(db, owner, &body, resolver);
+    let mut ctx = InferenceContext::new(db, owner, &store, resolver);
 
     for (root_expr, origin) in roots {
         let expected = match origin {
@@ -846,7 +833,7 @@ pub fn binding_ty<'db>(&self, id: BindingId) -> Ty<'db> {
 pub(crate) struct InferenceContext<'body, 'db> {
     pub(crate) db: &'db dyn HirDatabase,
     pub(crate) owner: ExpressionStoreOwner,
-    pub(crate) body: &'body Body,
+    pub(crate) store: &'body ExpressionStore,
     /// Generally you should not resolve things via this resolver. Instead create a TyLoweringContext
     /// and resolve the path via its methods. This will ensure proper error reporting.
     pub(crate) resolver: Resolver<'db>,
@@ -947,7 +934,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     fn new(
         db: &'db dyn HirDatabase,
         owner: ExpressionStoreOwner,
-        body: &'body Body,
+        store: &'body ExpressionStore,
         resolver: Resolver<'db>,
     ) -> Self {
         let trait_env = match owner {
@@ -976,7 +963,7 @@ fn new(
             db,
             owner,
             generic_def: owner.generic_def(db),
-            body,
+            store,
             traits_in_scope: resolver.traits_in_scope(db),
             resolver,
             diverges: Diverges::Maybe,
@@ -1196,7 +1183,7 @@ fn collect_static(&mut self, data: &StaticSignature) {
         self.return_ty = return_ty;
     }
 
-    fn collect_fn(&mut self, func: FunctionId) {
+    fn collect_fn(&mut self, func: FunctionId, self_param: Option<BindingId>, params: &[PatId]) {
         let data = self.db.function_signature(func);
         let mut param_tys = self.with_ty_lowering(
             &data.store,
@@ -1224,13 +1211,13 @@ fn collect_fn(&mut self, func: FunctionId) {
             param_tys.push(va_list_ty);
         }
         let mut param_tys = param_tys.into_iter().chain(iter::repeat(self.table.next_ty_var()));
-        if let Some(self_param) = self.body.self_param
+        if let Some(self_param) = self_param
             && let Some(ty) = param_tys.next()
         {
             let ty = self.process_user_written_ty(ty);
             self.write_binding_ty(self_param, ty);
         }
-        for (ty, pat) in param_tys.zip(&*self.body.params) {
+        for (ty, pat) in param_tys.zip(params) {
             let ty = self.process_user_written_ty(ty);
 
             self.infer_top_pat(*pat, ty, None);
@@ -1264,12 +1251,12 @@ pub(crate) fn infcx(&self) -> &InferCtxt<'db> {
         &self.table.infer_ctxt
     }
 
-    fn infer_body(&mut self) {
+    fn infer_body(&mut self, body_expr: ExprId) {
         match self.return_coercion {
-            Some(_) => self.infer_return(self.body.body_expr),
+            Some(_) => self.infer_return(body_expr),
             None => {
                 _ = self.infer_expr_coerce(
-                    self.body.body_expr,
+                    body_expr,
                     &Expectation::has_type(self.return_ty),
                     ExprIsRead::Yes,
                 )
@@ -1376,7 +1363,7 @@ fn with_body_ty_lowering<R>(
         f: impl FnOnce(&mut TyLoweringContext<'db, '_>) -> R,
     ) -> R {
         self.with_ty_lowering(
-            self.body,
+            self.store,
             InferenceTyDiagnosticSource::Body,
             LifetimeElisionKind::Infer,
             f,
@@ -1418,7 +1405,7 @@ fn make_ty(
     pub(crate) fn make_body_ty(&mut self, type_ref: TypeRefId) -> Ty<'db> {
         self.make_ty(
             type_ref,
-            self.body,
+            self.store,
             InferenceTyDiagnosticSource::Body,
             LifetimeElisionKind::Infer,
         )
@@ -1426,7 +1413,7 @@ pub(crate) fn make_body_ty(&mut self, type_ref: TypeRefId) -> Ty<'db> {
 
     pub(crate) fn make_body_const(&mut self, const_ref: ConstRef, ty: Ty<'db>) -> Const<'db> {
         let const_ = self.with_ty_lowering(
-            self.body,
+            self.store,
             InferenceTyDiagnosticSource::Body,
             LifetimeElisionKind::Infer,
             |ctx| ctx.lower_const(const_ref, ty),
@@ -1436,7 +1423,7 @@ pub(crate) fn make_body_const(&mut self, const_ref: ConstRef, ty: Ty<'db>) -> Co
 
     pub(crate) fn make_path_as_body_const(&mut self, path: &Path, ty: Ty<'db>) -> Const<'db> {
         let const_ = self.with_ty_lowering(
-            self.body,
+            self.store,
             InferenceTyDiagnosticSource::Body,
             LifetimeElisionKind::Infer,
             |ctx| ctx.lower_path_as_const(path, ty),
@@ -1450,7 +1437,7 @@ fn err_ty(&self) -> Ty<'db> {
 
     pub(crate) fn make_body_lifetime(&mut self, lifetime_ref: LifetimeRefId) -> Region<'db> {
         let lt = self.with_ty_lowering(
-            self.body,
+            self.store,
             InferenceTyDiagnosticSource::Body,
             LifetimeElisionKind::Infer,
             |ctx| ctx.lower_lifetime(lifetime_ref),
@@ -1665,7 +1652,7 @@ fn resolve_variant(
         let mut ctx = TyLoweringContext::new(
             self.db,
             &self.resolver,
-            &self.body.store,
+            self.store,
             &self.diagnostics,
             InferenceTyDiagnosticSource::Body,
             self.generic_def,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
index b4cc2ab4ae5b..2b9d3a7f5dbb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -346,7 +346,7 @@ fn path_place(&mut self, path: &Path, id: ExprOrPatId) -> Option<HirPlace> {
         if path.type_anchor().is_some() {
             return None;
         }
-        let hygiene = self.body.expr_or_pat_path_hygiene(id);
+        let hygiene = self.store.expr_or_pat_path_hygiene(id);
         self.resolver.resolve_path_in_value_ns_fully(self.db, path, hygiene).and_then(|result| {
             match result {
                 ValueNs::LocalBinding(binding) => {
@@ -365,7 +365,7 @@ fn path_place(&mut self, path: &Path, id: ExprOrPatId) -> Option<HirPlace> {
     /// Changes `current_capture_span_stack` to contain the stack of spans for this expr.
     fn place_of_expr_without_adjust(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
         self.current_capture_span_stack.clear();
-        match &self.body[tgt_expr] {
+        match &self.store[tgt_expr] {
             Expr::Path(p) => {
                 let resolver_guard =
                     self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);
@@ -416,7 +416,7 @@ fn truncate_capture_spans(&self, capture: &mut CapturedItemWithoutTy, mut trunca
             let mut actual_truncate_to = 0;
             for &span in &*span_stack {
                 actual_truncate_to += 1;
-                if !span.is_ref_span(self.body) {
+                if !span.is_ref_span(self.store) {
                     remained -= 1;
                     if remained == 0 {
                         break;
@@ -424,7 +424,7 @@ fn truncate_capture_spans(&self, capture: &mut CapturedItemWithoutTy, mut trunca
                 }
             }
             if actual_truncate_to < span_stack.len()
-                && span_stack[actual_truncate_to].is_ref_span(self.body)
+                && span_stack[actual_truncate_to].is_ref_span(self.store)
             {
                 // Include the ref operator if there is one, we will fix it later (in `strip_captures_ref_span()`) if it's incorrect.
                 actual_truncate_to += 1;
@@ -533,7 +533,7 @@ fn walk_expr(&mut self, tgt_expr: ExprId) {
     }
 
     fn walk_expr_without_adjust(&mut self, tgt_expr: ExprId) {
-        match &self.body[tgt_expr] {
+        match &self.store[tgt_expr] {
             Expr::OffsetOf(_) => (),
             Expr::InlineAsm(e) => e.operands.iter().for_each(|(_, op)| match op {
                 AsmOperand::In { expr, .. }
@@ -733,7 +733,7 @@ fn walk_expr_without_adjust(&mut self, tgt_expr: ExprId) {
                         self.consume_with_pat(rhs_place, target);
                         self.inside_assignment = false;
                     }
-                    None => self.body.walk_pats(target, &mut |pat| match &self.body[pat] {
+                    None => self.store.walk_pats(target, &mut |pat| match &self.store[pat] {
                         Pat::Path(path) => self.mutate_path_pat(path, pat),
                         &Pat::Expr(expr) => {
                             let place = self.place_of_expr(expr);
@@ -775,7 +775,7 @@ fn walk_pat_inner(
         update_result: &mut impl FnMut(CaptureKind),
         mut for_mut: BorrowKind,
     ) {
-        match &self.body[p] {
+        match &self.store[p] {
             Pat::Ref { .. }
             | Pat::Box { .. }
             | Pat::Missing
@@ -819,13 +819,13 @@ fn walk_pat_inner(
         if self.result.pat_adjustments.get(&p).is_some_and(|it| !it.is_empty()) {
             for_mut = BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture };
         }
-        self.body.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));
+        self.store.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));
     }
 
     fn is_upvar(&self, place: &HirPlace) -> bool {
         if let Some(c) = self.current_closure {
             let InternedClosure(_, root) = self.db.lookup_intern_closure(c);
-            return self.body.is_binding_upvar(place.local, root);
+            return self.store.is_binding_upvar(place.local, root);
         }
         false
     }
@@ -938,7 +938,7 @@ fn consume_with_pat(&mut self, mut place: HirPlace, tgt_pat: PatId) {
         self.current_capture_span_stack
             .extend((0..adjustments_count).map(|_| MirSpan::PatId(tgt_pat)));
         'reset_span_stack: {
-            match &self.body[tgt_pat] {
+            match &self.store[tgt_pat] {
                 Pat::Missing | Pat::Wild => (),
                 Pat::Tuple { args, ellipsis } => {
                     let (al, ar) = args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
@@ -1089,7 +1089,7 @@ fn closure_kind(&self) -> FnTrait {
     fn analyze_closure(&mut self, closure: InternedClosureId) -> FnTrait {
         let InternedClosure(_, root) = self.db.lookup_intern_closure(closure);
         self.current_closure = Some(closure);
-        let Expr::Closure { body, capture_by, .. } = &self.body[root] else {
+        let Expr::Closure { body, capture_by, .. } = &self.store[root] else {
             unreachable!("Closure expression id is always closure");
         };
         self.consume_expr(*body);
@@ -1133,7 +1133,7 @@ fn strip_captures_ref_span(&mut self) {
         for capture in &mut captures {
             if matches!(capture.kind, CaptureKind::ByValue) {
                 for span_stack in &mut capture.span_stacks {
-                    if span_stack[span_stack.len() - 1].is_ref_span(self.body) {
+                    if span_stack[span_stack.len() - 1].is_ref_span(self.store) {
                         span_stack.truncate(span_stack.len() - 1);
                     }
                 }
@@ -1149,7 +1149,7 @@ pub(crate) fn infer_closures(&mut self) {
             let kind = self.analyze_closure(closure);
 
             for (derefed_callee, callee_ty, params, expr) in exprs {
-                if let &Expr::Call { callee, .. } = &self.body[expr] {
+                if let &Expr::Call { callee, .. } = &self.store[expr] {
                     let mut adjustments =
                         self.result.expr_adjustments.remove(&callee).unwrap_or_default().into_vec();
                     self.write_fn_trait_method_resolution(
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 45b181eff8f0..2e80bad61414 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
@@ -155,7 +155,7 @@ pub(super) fn expr_guaranteed_to_constitute_read_for_never(
     /// it is matching against. This is used to determine whether we should
     /// perform `NeverToAny` coercions.
     fn pat_guaranteed_to_constitute_read_for_never(&self, pat: PatId) -> bool {
-        match &self.body[pat] {
+        match &self.store[pat] {
             // Does not constitute a read.
             Pat::Wild => false,
 
@@ -197,25 +197,25 @@ fn pat_guaranteed_to_constitute_read_for_never(&self, pat: PatId) -> bool {
     // FIXME(tschottdorf): this is problematic as the HIR is being scraped, but
     // ref bindings are be implicit after #42640 (default match binding modes). See issue #44848.
     fn contains_explicit_ref_binding(&self, pat: PatId) -> bool {
-        if let Pat::Bind { id, .. } = self.body[pat]
-            && matches!(self.body[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
+        if let Pat::Bind { id, .. } = self.store[pat]
+            && matches!(self.store[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
         {
             return true;
         }
 
         let mut result = false;
-        self.body.walk_pats_shallow(pat, |pat| result |= self.contains_explicit_ref_binding(pat));
+        self.store.walk_pats_shallow(pat, |pat| result |= self.contains_explicit_ref_binding(pat));
         result
     }
 
     fn is_syntactic_place_expr(&self, expr: ExprId) -> bool {
-        match &self.body[expr] {
+        match &self.store[expr] {
             // Lang item paths cannot currently be local variables or statics.
             Expr::Path(Path::LangItem(_, _)) => false,
             Expr::Path(Path::Normal(path)) => path.type_anchor.is_none(),
             Expr::Path(path) => self
                 .resolver
-                .resolve_path_in_value_ns_fully(self.db, path, self.body.expr_path_hygiene(expr))
+                .resolve_path_in_value_ns_fully(self.db, path, self.store.expr_path_hygiene(expr))
                 .is_none_or(|res| matches!(res, ValueNs::LocalBinding(_) | ValueNs::StaticId(_))),
             Expr::Underscore => true,
             Expr::UnaryOp { op: UnaryOp::Deref, .. } => true,
@@ -311,7 +311,7 @@ fn infer_expr_inner(
     ) -> Ty<'db> {
         self.db.unwind_if_revision_cancelled();
 
-        let expr = &self.body[tgt_expr];
+        let expr = &self.store[tgt_expr];
         tracing::trace!(?expr);
         let ty = match expr {
             Expr::Missing => self.err_ty(),
@@ -717,7 +717,7 @@ fn infer_expr_inner(
                 // instantiations in RHS can be coerced to it. Note that this
                 // cannot happen in destructuring assignments because of how
                 // they are desugared.
-                let lhs_ty = match &self.body[target] {
+                let lhs_ty = match &self.store[target] {
                     // LHS of assignment doesn't constitute reads.
                     &Pat::Expr(expr) => {
                         Some(self.infer_expr(expr, &Expectation::none(), ExprIsRead::No))
@@ -728,7 +728,7 @@ fn infer_expr_inner(
                         let resolution = self.resolver.resolve_path_in_value_ns_fully(
                             self.db,
                             path,
-                            self.body.pat_path_hygiene(target),
+                            self.store.pat_path_hygiene(target),
                         );
                         self.resolver.reset_to_guard(resolver_guard);
 
@@ -1351,7 +1351,7 @@ fn infer_expr_array(&mut self, array: &Array, expected: &Expectation<'db>) -> Ty
                     ExprIsRead::Yes,
                 );
                 let usize = self.types.types.usize;
-                let len = match self.body[repeat] {
+                let len = match self.store[repeat] {
                     Expr::Underscore => {
                         self.write_expr_ty(repeat, usize);
                         self.table.next_const_var()
@@ -1491,7 +1491,7 @@ fn infer_block(
                                     } else {
                                         ExprIsRead::No
                                     };
-                                let ty = if contains_explicit_ref_binding(this.body, *pat) {
+                                let ty = if contains_explicit_ref_binding(this.store, *pat) {
                                     this.infer_expr(
                                         *expr,
                                         &Expectation::has_type(decl_ty),
@@ -2117,7 +2117,7 @@ pub(in super::super) fn check_call_arguments(
                 // the return value of an argument-position async block to an argument-position
                 // closure wrapped in a block.
                 // See <https://github.com/rust-lang/rust/issues/112225>.
-                let is_closure = if let Expr::Closure { closure_kind, .. } = self.body[*arg] {
+                let is_closure = if let Expr::Closure { closure_kind, .. } = self.store[*arg] {
                     !matches!(closure_kind, ClosureKind::Coroutine(_))
                 } else {
                     false
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/mutability.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/mutability.rs
index 45fa141b6d3d..bfe43fc92827 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/mutability.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/mutability.rs
@@ -14,8 +14,8 @@
 };
 
 impl<'db> InferenceContext<'_, 'db> {
-    pub(crate) fn infer_mut_body(&mut self) {
-        self.infer_mut_expr(self.body.body_expr, Mutability::Not);
+    pub(crate) fn infer_mut_body(&mut self, body_expr: ExprId) {
+        self.infer_mut_expr(body_expr, Mutability::Not);
     }
 
     fn infer_mut_expr(&mut self, tgt_expr: ExprId, mut mutability: Mutability) {
@@ -52,7 +52,7 @@ fn infer_mut_expr(&mut self, tgt_expr: ExprId, mut mutability: Mutability) {
     }
 
     fn infer_mut_expr_without_adjust(&mut self, tgt_expr: ExprId, mutability: Mutability) {
-        match &self.body[tgt_expr] {
+        match &self.store[tgt_expr] {
             Expr::Missing => (),
             Expr::InlineAsm(e) => {
                 e.operands.iter().for_each(|(_, op)| match op {
@@ -173,7 +173,7 @@ fn infer_mut_expr_without_adjust(&mut self, tgt_expr: ExprId, mutability: Mutabi
                 self.infer_mut_expr(*rhs, Mutability::Not);
             }
             &Expr::Assignment { target, value } => {
-                self.body.walk_pats(target, &mut |pat| match self.body[pat] {
+                self.store.walk_pats(target, &mut |pat| match self.store[pat] {
                     Pat::Expr(expr) => self.infer_mut_expr(expr, Mutability::Mut),
                     Pat::ConstBlock(block) => self.infer_mut_expr(block, Mutability::Not),
                     _ => {}
@@ -220,8 +220,8 @@ fn pat_iter_bound_mutability(&self, mut pat: impl Iterator<Item = PatId>) -> Mut
     /// `let (ref x0, ref x1) = *it;` we should use `Deref`.
     fn pat_bound_mutability(&self, pat: PatId) -> Mutability {
         let mut r = Mutability::Not;
-        self.body.walk_bindings_in_pat(pat, |b| {
-            if self.body[b].mode == BindingAnnotation::RefMut {
+        self.store.walk_bindings_in_pat(pat, |b| {
+            if self.store[b].mode == BindingAnnotation::RefMut {
                 r = Mutability::Mut;
             }
         });
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 9ba2d634d58a..0b6c9977f079 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -4,7 +4,7 @@
 
 use hir_def::{
     HasModule as _,
-    expr_store::{Body, path::Path},
+    expr_store::{ExpressionStore, path::Path},
     hir::{Binding, BindingAnnotation, BindingId, Expr, ExprId, Literal, Pat, PatId},
 };
 use hir_expand::name::Name;
@@ -260,14 +260,14 @@ fn infer_pat(
     ) -> Ty<'db> {
         let mut expected = self.table.structurally_resolve_type(expected);
 
-        if matches!(&self.body[pat], Pat::Ref { .. }) || self.inside_assignment {
+        if matches!(&self.store[pat], Pat::Ref { .. }) || self.inside_assignment {
             cov_mark::hit!(match_ergonomics_ref);
             // When you encounter a `&pat` pattern, reset to Move.
             // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
             // Destructuring assignments also reset the binding mode and
             // don't do match ergonomics.
             default_bm = BindingMode::Move;
-        } else if self.is_non_ref_pat(self.body, pat) {
+        } else if self.is_non_ref_pat(self.store, pat) {
             let mut pat_adjustments = Vec::new();
             while let TyKind::Ref(_lifetime, inner, mutability) = expected.kind() {
                 pat_adjustments.push(expected.store());
@@ -289,7 +289,7 @@ fn infer_pat(
         let default_bm = default_bm;
         let expected = expected;
 
-        let ty = match &self.body[pat] {
+        let ty = match &self.store[pat] {
             Pat::Tuple { args, ellipsis } => {
                 self.infer_tuple_pat_like(pat, expected, default_bm, *ellipsis, args, decl)
             }
@@ -485,7 +485,7 @@ fn infer_bind_pat(
         expected: Ty<'db>,
         decl: Option<DeclContext>,
     ) -> Ty<'db> {
-        let Binding { mode, .. } = self.body[binding];
+        let Binding { mode, .. } = self.store[binding];
         let mode = if mode == BindingAnnotation::Unannotated {
             default_bm
         } else {
@@ -569,7 +569,7 @@ fn infer_slice_pat(
 
     fn infer_lit_pat(&mut self, expr: ExprId, expected: Ty<'db>) -> Ty<'db> {
         // Like slice patterns, byte string patterns can denote both `&[u8; N]` and `&[u8]`.
-        if let Expr::Literal(Literal::ByteString(_)) = self.body[expr]
+        if let Expr::Literal(Literal::ByteString(_)) = self.store[expr]
             && let TyKind::Ref(_, inner, _) = expected.kind()
         {
             let inner = self.table.try_structurally_resolve_type(inner);
@@ -590,14 +590,14 @@ fn infer_lit_pat(&mut self, expr: ExprId, expected: Ty<'db>) -> Ty<'db> {
         self.infer_expr(expr, &Expectation::has_type(expected), ExprIsRead::Yes)
     }
 
-    fn is_non_ref_pat(&mut self, body: &hir_def::expr_store::Body, pat: PatId) -> bool {
-        match &body[pat] {
+    fn is_non_ref_pat(&mut self, store: &hir_def::expr_store::ExpressionStore, pat: PatId) -> bool {
+        match &store[pat] {
             Pat::Tuple { .. }
             | Pat::TupleStruct { .. }
             | Pat::Record { .. }
             | Pat::Range { .. }
             | Pat::Slice { .. } => true,
-            Pat::Or(pats) => pats.iter().all(|p| self.is_non_ref_pat(body, *p)),
+            Pat::Or(pats) => pats.iter().all(|p| self.is_non_ref_pat(store, *p)),
             Pat::Path(path) => {
                 // A const is a reference pattern, but other value ns things aren't (see #16131).
                 let resolved = self.resolve_value_path_inner(path, pat.into(), true);
@@ -605,7 +605,7 @@ fn is_non_ref_pat(&mut self, body: &hir_def::expr_store::Body, pat: PatId) -> bo
             }
             Pat::ConstBlock(..) => false,
             Pat::Lit(expr) => !matches!(
-                body[*expr],
+                store[*expr],
                 Expr::Literal(Literal::String(..) | Literal::CString(..) | Literal::ByteString(..))
             ),
             Pat::Wild
@@ -670,10 +670,10 @@ fn pat_is_irrefutable(&self, decl_ctxt: Option<DeclContext>) -> bool {
     }
 }
 
-pub(super) fn contains_explicit_ref_binding(body: &Body, pat_id: PatId) -> bool {
+pub(super) fn contains_explicit_ref_binding(store: &ExpressionStore, pat_id: PatId) -> bool {
     let mut res = false;
-    body.walk_pats(pat_id, &mut |pat| {
-        res |= matches!(body[pat], Pat::Bind { id, .. } if matches!(body[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut));
+    store.walk_pats(pat_id, &mut |pat| {
+        res |= matches!(store[pat], Pat::Bind { id, .. } if matches!(store[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut));
     });
     res
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 40c6fdf3cc88..17d4901123bb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -136,7 +136,7 @@ pub(super) fn resolve_value_path_inner(
         let mut ctx = TyLoweringContext::new(
             self.db,
             &self.resolver,
-            self.body,
+            self.store,
             &self.diagnostics,
             InferenceTyDiagnosticSource::Body,
             self.generic_def,
@@ -159,7 +159,7 @@ pub(super) fn resolve_value_path_inner(
             let ty = self.table.process_user_written_ty(ty);
             self.resolve_ty_assoc_item(ty, last.name, id).map(|(it, substs)| (it, Some(substs)))?
         } else {
-            let hygiene = self.body.expr_or_pat_path_hygiene(id);
+            let hygiene = self.store.expr_or_pat_path_hygiene(id);
             // FIXME: report error, unresolved first path segment
             let value_or_partial = path_ctx.resolve_path_in_value_ns(hygiene)?;
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/confirm.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/confirm.rs
index 0024ca16a594..ec589085a88d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/confirm.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/confirm.rs
@@ -456,7 +456,7 @@ fn report_missing_lifetime(&mut self, _def: GenericDefId, _expected_count: u32)
 
         substs_from_args_and_bindings(
             self.db(),
-            self.ctx.body,
+            self.ctx.store,
             generic_args,
             self.candidate.into(),
             true,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
index bf17c784682c..a8865cd54e6a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -6,7 +6,7 @@
 use either::Either;
 use hir_def::{
     DefWithBodyId, FieldId, StaticId, TupleFieldId, UnionId, VariantId,
-    expr_store::Body,
+    expr_store::ExpressionStore,
     hir::{BindingAnnotation, BindingId, Expr, ExprId, Ordering, PatId},
 };
 use la_arena::{Arena, ArenaMap, Idx, RawIdx};
@@ -1210,12 +1210,12 @@ pub enum MirSpan {
 }
 
 impl MirSpan {
-    pub fn is_ref_span(&self, body: &Body) -> bool {
+    pub fn is_ref_span(&self, store: &ExpressionStore) -> bool {
         match *self {
-            MirSpan::ExprId(expr) => matches!(body[expr], Expr::Ref { .. }),
+            MirSpan::ExprId(expr) => matches!(store[expr], Expr::Ref { .. }),
             // FIXME: Figure out if this is correct wrt. match ergonomics.
             MirSpan::BindingId(binding) => {
-                matches!(body[binding].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
+                matches!(store[binding].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
             }
             MirSpan::PatId(_) | MirSpan::SelfParam | MirSpan::Unknown => false,
         }
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index 66bb3570665a..6a1aeb64f35b 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -293,9 +293,7 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
             }
             Callee::Closure(closure, _) => {
                 let InternedClosure(owner, expr_id) = db.lookup_intern_closure(closure);
-                let Some(body_owner) = owner.as_def_with_body() else {
-                    return None;
-                };
+                let body_owner = owner.as_def_with_body()?;
                 let (_, source_map) = db.body_with_source_map(body_owner);
                 let ast @ InFile { file_id, value } = source_map.expr_syntax(expr_id).ok()?;
                 let root = db.parse_or_expand(file_id);

From 831a0a7545440538ea0164762420e047e810799c Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Tue, 17 Mar 2026 10:46:04 +0100
Subject: [PATCH 0626/1059] Add test support

---
 .../rust-analyzer/crates/hir-ty/src/tests.rs  | 97 +++++++++++++++----
 .../crates/hir-ty/src/tests/patterns.rs       |  2 +
 .../crates/hir-ty/src/tests/regression.rs     |  1 +
 .../hir-ty/src/tests/regression/new_solver.rs |  8 ++
 .../crates/hir-ty/src/tests/simple.rs         | 39 ++++++++
 .../crates/hir-ty/src/tests/traits.rs         |  6 ++
 6 files changed, 133 insertions(+), 20 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index 67ab89f5ec8f..042f0568f3d8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -16,9 +16,10 @@
 use base_db::{Crate, SourceDatabase};
 use expect_test::Expect;
 use hir_def::{
-    AssocItemId, DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId, SyntheticSyntax,
+    AssocItemId, DefWithBodyId, GenericDefId, HasModule, Lookup, ModuleDefId, ModuleId,
+    SyntheticSyntax,
     db::DefDatabase,
-    expr_store::{Body, BodySourceMap},
+    expr_store::{Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap},
     hir::{ExprId, Pat, PatId},
     item_scope::ItemScope,
     nameres::DefMap,
@@ -34,7 +35,6 @@
     ast::{self, AstNode, HasName},
 };
 use test_fixture::WithFixture;
-use triomphe::Arc;
 
 use crate::{
     InferenceResult,
@@ -321,16 +321,20 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
         let mut buf = String::new();
 
         let mut infer_def = |inference_result: &InferenceResult,
-                             body: Arc<Body>,
-                             body_source_map: Arc<BodySourceMap>,
+                             store: &ExpressionStore,
+                             source_map: &ExpressionStoreSourceMap,
+                             self_param: Option<(
+            hir_def::hir::BindingId,
+            Option<InFile<hir_def::expr_store::SelfParamPtr>>,
+        )>,
                              krate: Crate| {
             let display_target = DisplayTarget::from_crate(&db, krate);
             let mut types: Vec<(InFile<SyntaxNode>, Ty<'_>)> = Vec::new();
             let mut mismatches: Vec<(InFile<SyntaxNode>, &TypeMismatch)> = Vec::new();
 
-            if let Some(self_param) = body.self_param {
-                let ty = &inference_result.type_of_binding[self_param];
-                if let Some(syntax_ptr) = body_source_map.self_param_syntax() {
+            if let Some((binding_id, syntax_ptr)) = self_param {
+                let ty = &inference_result.type_of_binding[binding_id];
+                if let Some(syntax_ptr) = syntax_ptr {
                     let root = db.parse_or_expand(syntax_ptr.file_id);
                     let node = syntax_ptr.map(|ptr| ptr.to_node(&root).syntax().clone());
                     types.push((node, ty.as_ref()));
@@ -338,10 +342,10 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             }
 
             for (pat, mut ty) in inference_result.type_of_pat.iter() {
-                if let Pat::Bind { id, .. } = body[pat] {
+                if let Pat::Bind { id, .. } = store[pat] {
                     ty = &inference_result.type_of_binding[id];
                 }
-                let node = match body_source_map.pat_syntax(pat) {
+                let node = match source_map.pat_syntax(pat) {
                     Ok(sp) => {
                         let root = db.parse_or_expand(sp.file_id);
                         sp.map(|ptr| ptr.to_node(&root).syntax().clone())
@@ -355,7 +359,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             }
 
             for (expr, ty) in inference_result.type_of_expr.iter() {
-                let node = match body_source_map.expr_syntax(expr) {
+                let node = match source_map.expr_syntax(expr) {
                     Ok(sp) => {
                         let root = db.parse_or_expand(sp.file_id);
                         sp.map(|ptr| ptr.to_node(&root).syntax().clone())
@@ -414,16 +418,56 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
         let def_map = module.def_map(&db);
 
         let mut defs: Vec<(DefWithBodyId, Crate)> = Vec::new();
+        let mut generic_defs: Vec<(GenericDefId, Crate)> = Vec::new();
         visit_module(&db, def_map, module, &mut |it| {
-            let def = match it {
-                ModuleDefId::FunctionId(it) => it.into(),
-                ModuleDefId::EnumVariantId(it) => it.into(),
-                ModuleDefId::ConstId(it) => it.into(),
-                ModuleDefId::StaticId(it) => it.into(),
-                _ => return,
-            };
-            defs.push((def, module.krate(&db)))
+            let krate = module.krate(&db);
+            match it {
+                ModuleDefId::FunctionId(it) => {
+                    defs.push((it.into(), krate));
+                    generic_defs.push((it.into(), krate));
+                }
+                ModuleDefId::EnumVariantId(it) => {
+                    defs.push((it.into(), krate));
+                }
+                ModuleDefId::ConstId(it) => {
+                    defs.push((it.into(), krate));
+                    generic_defs.push((it.into(), krate));
+                }
+                ModuleDefId::StaticId(it) => {
+                    defs.push((it.into(), krate));
+                    generic_defs.push((it.into(), krate));
+                }
+                ModuleDefId::AdtId(it) => {
+                    generic_defs.push((it.into(), krate));
+                }
+                ModuleDefId::TraitId(it) => {
+                    generic_defs.push((it.into(), krate));
+                }
+                ModuleDefId::TypeAliasId(it) => {
+                    generic_defs.push((it.into(), krate));
+                }
+                _ => {}
+            }
         });
+        // Also collect impls
+        for impl_id in def_map[module].scope.impls() {
+            generic_defs.push((impl_id.into(), module.krate(&db)));
+            let impl_data = impl_id.impl_items(&db);
+            for &(_, item) in impl_data.items.iter() {
+                match item {
+                    AssocItemId::FunctionId(it) => {
+                        generic_defs.push((it.into(), module.krate(&db)));
+                    }
+                    AssocItemId::ConstId(it) => {
+                        generic_defs.push((it.into(), module.krate(&db)));
+                    }
+                    AssocItemId::TypeAliasId(it) => {
+                        generic_defs.push((it.into(), module.krate(&db)));
+                    }
+                }
+            }
+        }
+
         defs.sort_by_key(|(def, _)| match def {
             DefWithBodyId::FunctionId(it) => {
                 let loc = it.lookup(&db);
@@ -445,7 +489,20 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
         for (def, krate) in defs {
             let (body, source_map) = db.body_with_source_map(def);
             let infer = InferenceResult::for_body(&db, def);
-            infer_def(infer, body, source_map, krate);
+            let self_param = body.self_param.map(|id| (id, source_map.self_param_syntax()));
+            infer_def(infer, &body, &source_map, self_param, krate);
+        }
+
+        // Also infer signature const expressions (array lengths, const generic args, etc.)
+        generic_defs.dedup();
+        for (def, krate) in generic_defs {
+            let (_, store, source_map) = db.generic_params_and_store_and_source_map(def);
+            // Skip if there are no const expressions in the signature
+            if store.const_expr_origins().is_empty() {
+                continue;
+            }
+            let infer = InferenceResult::for_signature(&db, def);
+            infer_def(infer, &store, &source_map, None, krate);
         }
 
         buf.truncate(buf.trim_end().len());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
index 8c7d29f99371..42dc07430935 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
@@ -421,6 +421,8 @@ fn index(&self, index: core::ops::RangeFull) -> &Self::Output {
             254..256 '&v': &'? [u8; 3]
             255..256 'v': [u8; 3]
             257..259 '{}': ()
+            199..200 '3': usize
+            62..63 'N': usize
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index d88801a57b86..e4fc7e56c6ae 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2754,6 +2754,7 @@ fn filter(&self, filter: &Filter<T>) -> Self::Output {
             664..680 'filter...ter_fn': dyn Fn(&'? T) -> bool + 'static
             691..698 'loop {}': !
             696..698 '{}': ()
+            512..513 'N': usize
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index f47a26d429fd..e6b3244cda24 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -34,6 +34,7 @@ pub trait Space: IntoIterator {
             223..227 'iter': IntoIter<u8>
             230..231 'a': Vec<u8>
             230..243 'a.into_iter()': IntoIter<u8>
+            322..323 '1': usize
         "#]],
     );
 }
@@ -472,6 +473,8 @@ fn foo() {
             249..257 'to_bytes': fn to_bytes() -> [u8; _]
             249..259 'to_bytes()': [u8; _]
             249..268 'to_byt..._vec()': Vec<<[u8; _] as Foo>::Item>
+            205..206 '_': usize
+            156..157 'N': usize
         "#]],
     );
 }
@@ -541,6 +544,11 @@ fn test_at_most() {
             617..620 'num': Between<0, 1, char>
             623..626 ''9'': char
             623..641 ''9'.at...:<1>()': Between<0, 1, char>
+            320..335 '{ Consts::MAX }': usize
+            322..333 'Consts::MAX': usize
+            421..422 '0': i32
+            144..159 '{ Consts::MAX }': usize
+            146..157 'Consts::MAX': usize
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index dab8bdb54b69..3ea21f8265a5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -3868,6 +3868,8 @@ fn main() {
             208..209 'c': u8
             213..214 'a': A
             213..221 'a.into()': [u8; 2]
+            33..34 '2': usize
+            111..112 '3': usize
         "#]],
     );
 }
@@ -4061,6 +4063,8 @@ fn foo() {
             248..282 'LazyLo..._LOCK)': &'? [u32; _]
             264..281 '&VALUE...Y_LOCK': &'? LazyLock<[u32; _]>
             265..281 'VALUES...Y_LOCK': LazyLock<[u32; _]>
+            197..202 '{ 0 }': usize
+            199..200 '0': usize
         "#]],
     );
 }
@@ -4109,3 +4113,38 @@ fn foo() {
     "#,
     );
 }
+
+#[test]
+fn signature_inference() {
+    check_infer(
+        r#"
+trait Trait<const A: u8> {}
+struct S<T: Trait<2>, const C: f32 = 0.0>
+where
+    (): Trait<2>
+{
+    field: [(); { C as usize }],
+    field2: *mut S<T, 5.0>
+}
+
+struct S2<const C: u16>;
+
+type Alias = S2<0>;
+impl S2<0> {}
+enum E {
+    V(S2<0>) = 0,
+}
+union U {
+    field: S2<0>
+}
+    "#,
+        expect![[r#"
+            242..243 '0': isize
+            46..47 '2': i32
+            65..68 '0.0': f32
+            90..91 '2': i32
+            200..201 '0': i32
+            212..213 '0': i32
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 74e9a8dac0e7..22359d8f1f1d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -1271,6 +1271,7 @@ fn bar() {
             241..245 'R::B': fn B<(), i32>(i32) -> R<(), i32>
             241..248 'R::B(7)': R<(), i32>
             246..247 '7': i32
+            46..47 '2': usize
         "#]],
     );
 }
@@ -3781,6 +3782,8 @@ fn main() {
             371..373 'v4': usize
             376..378 'v3': [u8; 4]
             376..389 'v3.do_thing()': usize
+            86..87 '4': usize
+            192..193 '2': usize
         "#]],
     )
 }
@@ -3820,6 +3823,9 @@ fn main() {
             240..242 'v2': [u8; 2]
             245..246 'v': [u8; 2]
             245..257 'v.do_thing()': [u8; 2]
+            130..131 'L': usize
+            102..103 'L': usize
+            130..131 'L': usize
         "#]],
     )
 }

From b603d0eb80adb3cb25aad0b4c0de42ab50d53491 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Tue, 17 Mar 2026 12:43:05 +0100
Subject: [PATCH 0627/1059] Hookup semantics

---
 .../rust-analyzer/crates/hir/src/semantics.rs | 28 +++++--
 .../crates/hir/src/source_analyzer.rs         | 82 +++++++++++++------
 .../test_data/highlight_general.html          |  2 +-
 .../ide/src/syntax_highlighting/tests.rs      |  2 +-
 4 files changed, 80 insertions(+), 34 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index c816fe967c54..a231f4aff515 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -2149,7 +2149,7 @@ fn analyze_impl(
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
         // replace this, just make the inference result a `LazyCell`
-        infer_body: bool,
+        infer: bool,
     ) -> Option<SourceAnalyzer<'db>> {
         let _p = tracing::info_span!("SemanticsImpl::analyze_impl").entered();
 
@@ -2157,7 +2157,7 @@ fn analyze_impl(
 
         let resolver = match container {
             ChildContainer::DefWithBodyId(def) => {
-                return Some(if infer_body {
+                return Some(if infer {
                     SourceAnalyzer::new_for_body(self.db, def, node, offset)
                 } else {
                     SourceAnalyzer::new_for_body_no_infer(self.db, def, node, offset)
@@ -2167,16 +2167,32 @@ fn analyze_impl(
                 return Some(SourceAnalyzer::new_variant_body(self.db, def, node, offset));
             }
             ChildContainer::TraitId(it) => {
-                return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));
+                return Some(if infer {
+                    SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)
+                } else {
+                    SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)
+                });
             }
             ChildContainer::ImplId(it) => {
-                return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));
+                return Some(if infer {
+                    SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)
+                } else {
+                    SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)
+                });
             }
             ChildContainer::EnumId(it) => {
-                return Some(SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset));
+                return Some(if infer {
+                    SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)
+                } else {
+                    SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)
+                });
             }
             ChildContainer::GenericDefId(it) => {
-                return Some(SourceAnalyzer::new_generic_def(self.db, it, node, offset));
+                return Some(if infer {
+                    SourceAnalyzer::new_generic_def(self.db, it, node, offset)
+                } else {
+                    SourceAnalyzer::new_generic_def_no_infer(self.db, it, node, offset)
+                });
             }
             ChildContainer::ModuleId(it) => it.resolver(self.db),
         };
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index 18929f82090c..ad7aea391833 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -17,7 +17,7 @@
         path::Path,
         scope::{ExprScopes, ScopeId},
     },
-    hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat, PatId},
+    hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat, PatId, generics::GenericParams},
     lang_item::LangItems,
     nameres::MacroSubNs,
     resolver::{HasResolver, Resolver, TypeNs, ValueNs, resolver_for_scope},
@@ -92,7 +92,9 @@ pub(crate) enum BodyOrSig<'db> {
         def: GenericDefId,
         store: Arc<ExpressionStore>,
         source_map: Arc<ExpressionStoreSourceMap>,
-        // infer: Option<Arc<InferenceResult>>,
+        infer: Option<&'db InferenceResult>,
+        #[expect(dead_code)]
+        generics: Arc<GenericParams>,
     },
 }
 
@@ -147,14 +149,46 @@ pub(crate) fn new_for_body_(
     pub(crate) fn new_generic_def(
         db: &'db dyn HirDatabase,
         def: GenericDefId,
-        InFile { file_id, .. }: InFile<&SyntaxNode>,
-        _offset: Option<TextSize>,
+        node: InFile<&SyntaxNode>,
+        offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        let (_params, store, source_map) = db.generic_params_and_store_and_source_map(def);
-        let resolver = def.resolver(db);
+        Self::new_generic_def_(db, def, node, offset, Some(InferenceResult::for_signature(db, def)))
+    }
+
+    pub(crate) fn new_generic_def_no_infer(
+        db: &'db dyn HirDatabase,
+        def: GenericDefId,
+        node: InFile<&SyntaxNode>,
+        offset: Option<TextSize>,
+    ) -> SourceAnalyzer<'db> {
+        Self::new_generic_def_(db, def, node, offset, None)
+    }
+
+    pub(crate) fn new_generic_def_(
+        db: &'db dyn HirDatabase,
+        def: GenericDefId,
+        node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
+        offset: Option<TextSize>,
+        infer: Option<&'db InferenceResult>,
+    ) -> SourceAnalyzer<'db> {
+        let (generics, store, source_map) = db.generic_params_and_store_and_source_map(def);
+        let scopes = db.expr_scopes(def.into());
+        let scope = match offset {
+            None => scope_for(db, &scopes, &source_map, node),
+            Some(offset) => {
+                debug_assert!(
+                    node.text_range().contains_inclusive(offset),
+                    "{:?} not in {:?}",
+                    offset,
+                    node.text_range()
+                );
+                scope_for_offset(db, &scopes, &source_map, node.file_id, offset)
+            }
+        };
+        let resolver = resolver_for_scope(db, def, scope);
         SourceAnalyzer {
             resolver,
-            body_or_sig: Some(BodyOrSig::Sig { def, store, source_map }),
+            body_or_sig: Some(BodyOrSig::Sig { def, store, source_map, generics, infer }),
             file_id,
         }
     }
@@ -197,17 +231,8 @@ fn body_(&self) -> Option<(DefWithBodyId, &Body, &BodySourceMap, Option<&Inferen
 
     fn infer(&self) -> Option<&InferenceResult> {
         self.body_or_sig.as_ref().and_then(|it| match it {
-            BodyOrSig::Sig { .. } => None,
             BodyOrSig::VariantFields { .. } => None,
-            BodyOrSig::Body { infer, .. } => infer.as_deref(),
-        })
-    }
-
-    fn body(&self) -> Option<&Body> {
-        self.body_or_sig.as_ref().and_then(|it| match it {
-            BodyOrSig::Sig { .. } => None,
-            BodyOrSig::VariantFields { .. } => None,
-            BodyOrSig::Body { body, .. } => Some(&**body),
+            BodyOrSig::Sig { infer, .. } | BodyOrSig::Body { infer, .. } => infer.as_deref(),
         })
     }
 
@@ -232,11 +257,13 @@ fn param_and<'a>(&self, param_env: ParamEnv<'a>) -> ParamEnvAndCrate<'a> {
     }
 
     fn trait_environment(&self, db: &'db dyn HirDatabase) -> ParamEnvAndCrate<'db> {
-        self.param_and(
-            self.body_()
-                .map(|(def, ..)| def)
-                .map_or_else(ParamEnv::empty, |def| db.trait_environment_for_body(def)),
-        )
+        self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {
+            match *body_or_sig {
+                BodyOrSig::Body { def, .. } => db.trait_environment_for_body(def),
+                BodyOrSig::VariantFields { .. } => ParamEnv::empty(),
+                BodyOrSig::Sig { def, .. } => db.trait_environment(def),
+            }
+        }))
     }
 
     pub(crate) fn expr_id(&self, expr: ast::Expr) -> Option<ExprOrPatId> {
@@ -371,7 +398,10 @@ pub(crate) fn type_of_self(
         db: &'db dyn HirDatabase,
         _param: &ast::SelfParam,
     ) -> Option<Type<'db>> {
-        let binding = self.body()?.self_param?;
+        let binding = match self.body_or_sig.as_ref()? {
+            BodyOrSig::Sig { .. } | BodyOrSig::VariantFields { .. } => return None,
+            BodyOrSig::Body { body, .. } => body.self_param?,
+        };
         let ty = self.infer()?.binding_ty(binding);
         Some(Type::new_with_resolver(db, &self.resolver, ty))
     }
@@ -1526,7 +1556,7 @@ fn ty_of_expr(&self, expr: ast::Expr) -> Option<Ty<'db>> {
 fn scope_for(
     db: &dyn HirDatabase,
     scopes: &ExprScopes,
-    source_map: &BodySourceMap,
+    source_map: &ExpressionStoreSourceMap,
     node: InFile<&SyntaxNode>,
 ) -> Option<ScopeId> {
     node.ancestors_with_macros(db)
@@ -1545,7 +1575,7 @@ fn scope_for(
 fn scope_for_offset(
     db: &dyn HirDatabase,
     scopes: &ExprScopes,
-    source_map: &BodySourceMap,
+    source_map: &ExpressionStoreSourceMap,
     from_file: HirFileId,
     offset: TextSize,
 ) -> Option<ScopeId> {
@@ -1579,7 +1609,7 @@ fn scope_for_offset(
 fn adjust(
     db: &dyn HirDatabase,
     scopes: &ExprScopes,
-    source_map: &BodySourceMap,
+    source_map: &ExpressionStoreSourceMap,
     expr_range: TextRange,
     from_file: HirFileId,
     offset: TextSize,
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
index c6dbc435c0e8..1184739cc258 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
@@ -105,7 +105,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="keyword control">loop</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">const_param</span><span class="angle">&lt;</span><span class="keyword const">const</span> <span class="const_param const declaration">FOO</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">usize</span> <span class="brace">{</span>
+<span class="keyword">fn</span> <span class="function declaration">const_param</span><span class="angle">&lt;</span><span class="keyword const">const</span> <span class="const_param const declaration">FOO</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">usize</span> <span class="keyword">where</span> <span class="bracket">[</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span> <span class="const_param const">FOO</span><span class="bracket">]</span><span class="colon">:</span> <span class="trait default_library library">Sized</span> <span class="brace">{</span>
     <span class="function">const_param</span><span class="operator">::</span><span class="angle">&lt;</span><span class="brace">{</span> <span class="const_param const">FOO</span> <span class="brace">}</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="const_param const">FOO</span>
 <span class="brace">}</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
index c6aebd0b0cd1..aecd1d3fdb56 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
@@ -210,7 +210,7 @@ fn never() -> ! {
     loop {}
 }
 
-fn const_param<const FOO: usize>() -> usize {
+fn const_param<const FOO: usize>() -> usize where [(); FOO]: Sized {
     const_param::<{ FOO }>();
     FOO
 }

From 3656fbff06416cbc89ca4379fdc9b2e3d046b19e Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Wed, 18 Mar 2026 17:31:38 +0300
Subject: [PATCH 0628/1059] Abstract AST lowering resolver

---
 compiler/rustc_ast_lowering/src/asm.rs        |   2 +-
 compiler/rustc_ast_lowering/src/block.rs      |   4 +-
 compiler/rustc_ast_lowering/src/contract.rs   |   4 +-
 compiler/rustc_ast_lowering/src/delegation.rs |  39 +++----
 .../src/delegation/generics.rs                |  18 +--
 compiler/rustc_ast_lowering/src/expr.rs       |   7 +-
 compiler/rustc_ast_lowering/src/format.rs     |   7 +-
 compiler/rustc_ast_lowering/src/item.rs       |  18 +--
 compiler/rustc_ast_lowering/src/lib.rs        | 106 +++++++++++++-----
 compiler/rustc_ast_lowering/src/pat.rs        |   2 +-
 compiler/rustc_ast_lowering/src/path.rs       |   2 +-
 11 files changed, 129 insertions(+), 80 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index a7bf1c99a7e2..51994c2e92f9 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -23,7 +23,7 @@
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt,
 };
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(crate) fn lower_inline_asm(
         &mut self,
         sp: Span,
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index cf3f331a701b..94839485c603 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -4,9 +4,9 @@
 use rustc_span::sym;
 use smallvec::SmallVec;
 
-use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
+use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext, ResolverAstLoweringExt};
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_block(
         &mut self,
         b: &Block,
diff --git a/compiler/rustc_ast_lowering/src/contract.rs b/compiler/rustc_ast_lowering/src/contract.rs
index 6cffd8e119b7..fd05ed0c78e4 100644
--- a/compiler/rustc_ast_lowering/src/contract.rs
+++ b/compiler/rustc_ast_lowering/src/contract.rs
@@ -2,9 +2,9 @@
 
 use thin_vec::thin_vec;
 
-use crate::LoweringContext;
+use crate::{LoweringContext, ResolverAstLoweringExt};
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     /// Lowered contracts are guarded with the `contract_checks` compiler flag,
     /// i.e. the flag turns into a boolean guard in the lowered HIR. The reason
     /// for not eliminating the contract code entirely when the `contract_checks`
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 68b76f7bd3dd..269b9957dc7a 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -37,6 +37,7 @@
 //! also be emitted during HIR ty lowering.
 
 use std::iter;
+use std::marker::PhantomData;
 
 use ast::visit::Visitor;
 use hir::def::{DefKind, PartialRes, Res};
@@ -51,7 +52,7 @@
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::span_bug;
-use rustc_middle::ty::{Asyncness, DelegationAttrs, DelegationFnSigAttrs, ResolverAstLowering};
+use rustc_middle::ty::{Asyncness, DelegationAttrs, DelegationFnSigAttrs};
 use rustc_span::symbol::kw;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
 use smallvec::SmallVec;
@@ -134,16 +135,14 @@ fn delegee_id(&self) -> DefId {
     }
 }
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
             DefKind::AssocFn => match def_id.as_local() {
-                Some(local_def_id) => self
-                    .resolver
-                    .delegation_fn_sigs
-                    .get(&local_def_id)
-                    .is_some_and(|sig| sig.has_self),
+                Some(local_def_id) => {
+                    self.resolver.delegation_fn_sig(local_def_id).is_some_and(|sig| sig.has_self)
+                }
                 None => self.tcx.associated_item(def_id).is_method(),
             },
             _ => span_bug!(span, "unexpected DefKind for delegation item"),
@@ -159,7 +158,7 @@ pub(crate) fn lower_delegation(
 
         // Delegation can be unresolved in illegal places such as function bodies in extern blocks (see #151356)
         let ids = if let Some(delegation_info) =
-            self.resolver.delegation_infos.get(&self.local_def_id(item_id))
+            self.resolver.delegation_info(self.local_def_id(item_id))
         {
             self.get_delegation_ids(delegation_info.resolution_node, span)
         } else {
@@ -344,10 +343,10 @@ fn parse_local_original_attrs(&self, def_id: DefId) -> Option<Vec<hir::Attribute
 
     fn get_attrs(&self, local_id: LocalDefId) -> &DelegationAttrs {
         // local_id can correspond either to a function or other delegation
-        if let Some(fn_sig) = self.resolver.delegation_fn_sigs.get(&local_id) {
+        if let Some(fn_sig) = self.resolver.delegation_fn_sig(local_id) {
             &fn_sig.attrs
         } else {
-            &self.resolver.delegation_infos[&local_id].attrs
+            &self.resolver.delegation_info(local_id).expect("processing delegation").attrs
         }
     }
 
@@ -378,7 +377,7 @@ fn get_delegation_ids(
             // it means that we refer to another delegation as a callee, so in order to obtain
             // a signature DefId we obtain NodeId of the callee delegation and try to get signature from it.
             if let Some(local_id) = def_id.as_local()
-                && let Some(delegation_info) = self.resolver.delegation_infos.get(&local_id)
+                && let Some(delegation_info) = self.resolver.delegation_info(local_id)
             {
                 node_id = delegation_info.resolution_node;
                 if visited.contains(&node_id) {
@@ -402,7 +401,7 @@ fn get_resolution_id(&self, node_id: NodeId) -> Option<DefId> {
     // Function parameter count, including C variadic `...` if present.
     fn param_count(&self, def_id: DefId) -> (usize, bool /*c_variadic*/) {
         if let Some(local_sig_id) = def_id.as_local() {
-            match self.resolver.delegation_fn_sigs.get(&local_sig_id) {
+            match self.resolver.delegation_fn_sig(local_sig_id) {
                 Some(sig) => (sig.param_count, sig.c_variadic),
                 None => (0, false),
             }
@@ -457,7 +456,7 @@ fn lower_delegation_sig(
         span: Span,
     ) -> hir::FnSig<'hir> {
         let header = if let Some(local_sig_id) = sig_id.as_local() {
-            match self.resolver.delegation_fn_sigs.get(&local_sig_id) {
+            match self.resolver.delegation_fn_sig(local_sig_id) {
                 Some(sig) => {
                     let parent = self.tcx.parent(sig_id);
                     // HACK: we override the default safety instead of generating attributes from the ether.
@@ -573,6 +572,7 @@ fn lower_delegation_body(
                         resolver: this.resolver,
                         path_id: delegation.id,
                         self_param_id: pat_node_id,
+                        phantom: PhantomData,
                     };
                     self_resolver.visit_block(block);
                     // Target expr needs to lower `self` path.
@@ -816,25 +816,26 @@ fn mk_expr(&mut self, kind: hir::ExprKind<'hir>, span: Span) -> hir::Expr<'hir>
     }
 }
 
-struct SelfResolver<'a, 'tcx> {
-    resolver: &'a mut ResolverAstLowering<'tcx>,
+struct SelfResolver<'a, 'tcx, R> {
+    resolver: &'a mut R,
     path_id: NodeId,
     self_param_id: NodeId,
+    phantom: PhantomData<&'tcx ()>,
 }
 
-impl SelfResolver<'_, '_> {
+impl<'tcx, R: ResolverAstLoweringExt<'tcx>> SelfResolver<'_, 'tcx, R> {
     fn try_replace_id(&mut self, id: NodeId) {
-        if let Some(res) = self.resolver.partial_res_map.get(&id)
+        if let Some(res) = self.resolver.get_partial_res(id)
             && let Some(Res::Local(sig_id)) = res.full_res()
             && sig_id == self.path_id
         {
             let new_res = PartialRes::new(Res::Local(self.self_param_id));
-            self.resolver.partial_res_map.insert(id, new_res);
+            self.resolver.insert_partial_res(id, new_res);
         }
     }
 }
 
-impl<'ast, 'a> Visitor<'ast> for SelfResolver<'a, '_> {
+impl<'ast, 'a, 'tcx, R: ResolverAstLoweringExt<'tcx>> Visitor<'ast> for SelfResolver<'a, 'tcx, R> {
     fn visit_id(&mut self, id: NodeId) {
         self.try_replace_id(id);
     }
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index 9e7ec04d38fb..29ae75b30c5a 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -10,7 +10,7 @@
 use rustc_span::{DUMMY_SP, Ident, Span};
 use thin_vec::{ThinVec, thin_vec};
 
-use crate::{AstOwner, LoweringContext};
+use crate::{AstOwner, LoweringContext, ResolverAstLoweringExt};
 
 pub(super) enum DelegationGenerics<T> {
     /// User-specified args are present: `reuse foo::<String>;`.
@@ -60,7 +60,7 @@ fn is_user_specified(&self) -> bool {
 impl<'hir> HirOrAstGenerics<'hir> {
     pub(super) fn into_hir_generics(
         &mut self,
-        ctx: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
         item_id: NodeId,
         span: Span,
     ) -> &mut HirOrAstGenerics<'hir> {
@@ -100,7 +100,7 @@ fn hir_generics_or_empty(&self) -> &'hir hir::Generics<'hir> {
 
     pub(super) fn into_generic_args(
         &self,
-        ctx: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
         add_lifetimes: bool,
         span: Span,
     ) -> Option<&'hir hir::GenericArgs<'hir>> {
@@ -140,7 +140,7 @@ pub(super) fn all_params(
         &mut self,
         item_id: NodeId,
         span: Span,
-        ctx: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     ) -> impl Iterator<Item = hir::GenericParam<'hir>> {
         // Now we always call `into_hir_generics` both on child and parent,
         // however in future we would not do that, when scenarios like
@@ -182,7 +182,7 @@ pub(super) fn all_predicates(
         &mut self,
         item_id: NodeId,
         span: Span,
-        ctx: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     ) -> impl Iterator<Item = hir::WherePredicate<'hir>> {
         // Now we always call `into_hir_generics` both on child and parent,
         // however in future we would not do that, when scenarios like
@@ -207,7 +207,7 @@ pub(super) fn all_predicates(
     }
 }
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_delegation_generics(
         &mut self,
         delegation: &Delegation,
@@ -289,11 +289,11 @@ fn lower_delegation_generic_params(
 
             // Note that we use self.disambiguator here, if we will create new every time
             // we will get ICE if params have the same name.
-            self.resolver.node_id_to_def_id.insert(
+            self.resolver.insert_new_def_id(
                 p.id,
                 self.tcx
                     .create_def(
-                        self.resolver.node_id_to_def_id[&item_id],
+                        self.local_def_id(item_id),
                         Some(p.ident.name),
                         match p.kind {
                             GenericParamKind::Lifetime => DefKind::LifetimeParam,
@@ -509,7 +509,7 @@ fn map_const_kind(&mut self, p: &ty::GenericParamDef, span: Span) -> GenericPara
 
         let node_id = self.next_node_id();
 
-        self.resolver.partial_res_map.insert(node_id, hir::def::PartialRes::new(res));
+        self.resolver.insert_partial_res(node_id, hir::def::PartialRes::new(res));
 
         GenericParamKind::Const {
             ty: Box::new(Ty {
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 4a2992038003..ec243c1e77d1 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -53,7 +53,7 @@ fn visit_expr(&mut self, ex: &'v Expr) -> Self::Result {
     }
 }
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     fn lower_exprs(&mut self, exprs: &[Box<Expr>]) -> &'hir [hir::Expr<'hir>] {
         self.arena.alloc_from_iter(exprs.iter().map(|x| self.lower_expr_mut(x)))
     }
@@ -1232,7 +1232,10 @@ fn lower_expr_assign(
         whole_span: Span,
     ) -> hir::ExprKind<'hir> {
         // Return early in case of an ordinary assignment.
-        fn is_ordinary(lower_ctx: &mut LoweringContext<'_, '_>, lhs: &Expr) -> bool {
+        fn is_ordinary<'hir>(
+            lower_ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
+            lhs: &Expr,
+        ) -> bool {
             match &lhs.kind {
                 ExprKind::Array(..)
                 | ExprKind::Struct(..)
diff --git a/compiler/rustc_ast_lowering/src/format.rs b/compiler/rustc_ast_lowering/src/format.rs
index 602635af1324..1f1f86f7edfd 100644
--- a/compiler/rustc_ast_lowering/src/format.rs
+++ b/compiler/rustc_ast_lowering/src/format.rs
@@ -7,8 +7,9 @@
 use rustc_span::{ByteSymbol, DesugaringKind, Ident, Span, Symbol, sym};
 
 use super::LoweringContext;
+use crate::ResolverAstLoweringExt;
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(crate) fn lower_format_args(&mut self, sp: Span, fmt: &FormatArgs) -> hir::ExprKind<'hir> {
         // Never call the const constructor of `fmt::Arguments` if the
         // format_args!() had any arguments _before_ flattening/inlining.
@@ -230,7 +231,7 @@ enum ArgumentType {
 ///     <core::fmt::Argument>::new_…(arg)
 /// ```
 fn make_argument<'hir>(
-    ctx: &mut LoweringContext<'_, 'hir>,
+    ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     sp: Span,
     arg: &'hir hir::Expr<'hir>,
     ty: ArgumentType,
@@ -277,7 +278,7 @@ fn make_count(
 }
 
 fn expand_format_args<'hir>(
-    ctx: &mut LoweringContext<'_, 'hir>,
+    ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     macsp: Span,
     fmt: &FormatArgs,
     allow_const: bool,
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index ed78b77a704f..12e178be9858 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -10,7 +10,7 @@
 };
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::span_bug;
-use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
@@ -25,9 +25,9 @@
     RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
 };
 
-pub(super) struct ItemLowerer<'a, 'hir> {
+pub(super) struct ItemLowerer<'a, 'hir, R> {
     pub(super) tcx: TyCtxt<'hir>,
-    pub(super) resolver: &'a mut ResolverAstLowering<'hir>,
+    pub(super) resolver: &'a mut R,
     pub(super) ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
     pub(super) owners: &'a mut IndexVec<LocalDefId, hir::MaybeOwner<'hir>>,
 }
@@ -51,11 +51,11 @@ fn add_ty_alias_where_clause(
         if before.0 || !after.0 { before } else { after };
 }
 
-impl<'a, 'hir> ItemLowerer<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> ItemLowerer<'_, 'hir, R> {
     fn with_lctx(
         &mut self,
         owner: NodeId,
-        f: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::OwnerNode<'hir>,
+        f: impl FnOnce(&mut LoweringContext<'_, 'hir, R>) -> hir::OwnerNode<'hir>,
     ) {
         let mut lctx = LoweringContext::new(self.tcx, self.ast_index, self.resolver);
         lctx.with_hir_id_owner(owner, |lctx| f(lctx));
@@ -77,7 +77,7 @@ pub(super) fn lower_node(&mut self, def_id: LocalDefId) {
             match node {
                 AstOwner::NonOwner => {}
                 AstOwner::Crate(c) => {
-                    assert_eq!(self.resolver.node_id_to_def_id[&CRATE_NODE_ID], CRATE_DEF_ID);
+                    assert_eq!(self.resolver.local_def_id(CRATE_NODE_ID), CRATE_DEF_ID);
                     self.with_lctx(CRATE_NODE_ID, |lctx| {
                         let module = lctx.lower_mod(&c.items, &c.spans);
                         // FIXME(jdonszelman): is dummy span ever a problem here?
@@ -99,7 +99,7 @@ pub(super) fn lower_node(&mut self, def_id: LocalDefId) {
     }
 }
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_mod(
         &mut self,
         items: &[Box<Item>],
@@ -1475,7 +1475,7 @@ fn lower_maybe_coroutine_body(
     pub(crate) fn lower_coroutine_body_with_moved_arguments(
         &mut self,
         decl: &FnDecl,
-        lower_body: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::Expr<'hir>,
+        lower_body: impl FnOnce(&mut LoweringContext<'_, 'hir, R>) -> hir::Expr<'hir>,
         fn_decl_span: Span,
         body_span: Span,
         coroutine_kind: CoroutineKind,
@@ -1612,7 +1612,7 @@ pub(crate) fn lower_coroutine_body_with_moved_arguments(
             parameters.push(new_parameter);
         }
 
-        let mkbody = |this: &mut LoweringContext<'_, 'hir>| {
+        let mkbody = |this: &mut LoweringContext<'_, 'hir, R>| {
             // Create a block from the user's function body:
             let user_body = lower_body(this);
 
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index c3525d124670..f3d082db761b 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -58,7 +58,7 @@
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::{DelegationFnSig, DelegationInfo, ResolverAstLowering, TyCtxt};
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -87,7 +87,7 @@ macro_rules! arena_vec {
 mod path;
 pub mod stability;
 
-struct LoweringContext<'a, 'hir> {
+struct LoweringContext<'a, 'hir, R> {
     tcx: TyCtxt<'hir>,
 
     // During lowering of delegation we need to access AST of other functions
@@ -98,7 +98,7 @@ struct LoweringContext<'a, 'hir> {
     // will be in AST index.
     ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
 
-    resolver: &'a mut ResolverAstLowering<'hir>,
+    resolver: &'a mut R,
     disambiguator: DisambiguatorState,
 
     /// Used to allocate HIR nodes.
@@ -157,15 +157,14 @@ struct LoweringContext<'a, 'hir> {
     attribute_parser: AttributeParser<'hir>,
 }
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
     fn new(
         tcx: TyCtxt<'hir>,
         ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
-        resolver: &'a mut ResolverAstLowering<'hir>,
+        resolver: &'a mut R,
     ) -> Self {
         let registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
         Self {
-            // Pseudo-globals.
             tcx,
             ast_index,
             resolver,
@@ -246,9 +245,11 @@ fn lower(&self, span: Span) -> Span {
     }
 }
 
-#[extension(trait ResolverAstLoweringExt)]
-impl ResolverAstLowering<'_> {
-    fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'_>) -> Option<Vec<usize>> {
+// LoweringContext now uses this trait for #153489, if #153489 is not merged,
+// feel free to do whatever you want with this trait.
+#[extension(trait ResolverAstLoweringExt<'tcx>)]
+impl<'tcx> ResolverAstLowering<'tcx> {
+    fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'tcx>) -> Option<Vec<usize>> {
         let ExprKind::Path(None, path) = &expr.kind else {
             return None;
         };
@@ -259,7 +260,7 @@ fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'_>) -> Option<Vec<
             return None;
         }
 
-        let def_id = self.partial_res_map.get(&expr.id)?.full_res()?.opt_def_id()?;
+        let def_id = self.get_partial_res(expr.id)?.full_res()?.opt_def_id()?;
 
         // We only support cross-crate argument rewriting. Uses
         // within the same crate should be updated to use the new
@@ -302,9 +303,50 @@ fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes> {
     ///
     /// The extra lifetimes that appear from the parenthesized `Fn`-trait desugaring
     /// should appear at the enclosing `PolyTraitRef`.
-    fn extra_lifetime_params(&mut self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
+    fn extra_lifetime_params(&self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
         self.extra_lifetime_params_map.get(&id).cloned().unwrap_or_default()
     }
+
+    fn delegation_fn_sig(&self, id: LocalDefId) -> Option<&DelegationFnSig> {
+        self.delegation_fn_sigs.get(&id)
+    }
+
+    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
+        self.delegation_infos.get(&id)
+    }
+
+    fn opt_local_def_id(&self, id: NodeId) -> Option<LocalDefId> {
+        self.node_id_to_def_id.get(&id).copied()
+    }
+
+    fn local_def_id(&self, id: NodeId) -> LocalDefId {
+        self.opt_local_def_id(id).expect("must have def_id")
+    }
+
+    fn lifetime_elision_allowed(&self, id: NodeId) -> bool {
+        self.lifetime_elision_allowed.contains(&id)
+    }
+
+    fn insert_new_def_id(&mut self, node_id: NodeId, def_id: LocalDefId) {
+        self.node_id_to_def_id.insert(node_id, def_id);
+    }
+
+    fn insert_partial_res(&mut self, node_id: NodeId, res: PartialRes) {
+        self.partial_res_map.insert(node_id, res);
+    }
+
+    fn trait_candidates(&self, node_id: NodeId) -> Option<&'tcx [hir::TraitCandidate<'tcx>]> {
+        self.trait_map.get(&node_id).copied()
+    }
+
+    #[inline]
+    fn next_node_id(&mut self) -> NodeId {
+        let start = self.next_node_id;
+        let next = start.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
+        self.next_node_id = ast::NodeId::from_u32(next);
+
+        start
+    }
 }
 
 /// How relaxed bounds `?Trait` should be treated.
@@ -444,42 +486,43 @@ enum TryBlockScope {
     Heterogeneous(HirId),
 }
 
-fn index_crate<'a>(
-    node_id_to_def_id: &NodeMap<LocalDefId>,
+fn index_crate<'a, 'b>(
+    resolver: &'b impl ResolverAstLoweringExt<'a>,
     krate: &'a Crate,
 ) -> IndexVec<LocalDefId, AstOwner<'a>> {
-    let mut indexer = Indexer { node_id_to_def_id, index: IndexVec::new() };
+    let mut indexer = Indexer { resolver, index: IndexVec::new() };
     *indexer.index.ensure_contains_elem(CRATE_DEF_ID, || AstOwner::NonOwner) =
         AstOwner::Crate(krate);
     visit::walk_crate(&mut indexer, krate);
+
     return indexer.index;
 
-    struct Indexer<'s, 'a> {
-        node_id_to_def_id: &'s NodeMap<LocalDefId>,
+    struct Indexer<'a, 'b, R> {
+        resolver: &'b R,
         index: IndexVec<LocalDefId, AstOwner<'a>>,
     }
 
-    impl<'a> visit::Visitor<'a> for Indexer<'_, 'a> {
+    impl<'a, 'b, R: ResolverAstLoweringExt<'a>> visit::Visitor<'a> for Indexer<'a, 'b, R> {
         fn visit_attribute(&mut self, _: &'a Attribute) {
             // We do not want to lower expressions that appear in attributes,
             // as they are not accessible to the rest of the HIR.
         }
 
         fn visit_item(&mut self, item: &'a ast::Item) {
-            let def_id = self.node_id_to_def_id[&item.id];
+            let def_id = self.resolver.local_def_id(item.id);
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) = AstOwner::Item(item);
             visit::walk_item(self, item)
         }
 
         fn visit_assoc_item(&mut self, item: &'a ast::AssocItem, ctxt: visit::AssocCtxt) {
-            let def_id = self.node_id_to_def_id[&item.id];
+            let def_id = self.resolver.local_def_id(item.id);
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) =
                 AstOwner::AssocItem(item, ctxt);
             visit::walk_assoc_item(self, item, ctxt);
         }
 
         fn visit_foreign_item(&mut self, item: &'a ast::ForeignItem) {
-            let def_id = self.node_id_to_def_id[&item.id];
+            let def_id = self.resolver.local_def_id(item.id);
             *self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner) =
                 AstOwner::ForeignItem(item);
             visit::walk_item(self, item);
@@ -519,7 +562,7 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> hir::Crate<'_> {
     tcx.ensure_done().get_lang_items(());
     let (mut resolver, krate) = tcx.resolver_for_lowering().steal();
 
-    let ast_index = index_crate(&resolver.node_id_to_def_id, &krate);
+    let ast_index = index_crate(&resolver, &krate);
     let mut owners = IndexVec::from_fn_n(
         |_| hir::MaybeOwner::Phantom,
         tcx.definitions_untracked().def_index_count(),
@@ -531,6 +574,7 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> hir::Crate<'_> {
         ast_index: &ast_index,
         owners: &mut owners,
     };
+
     for def_id in ast_index.indices() {
         lowerer.lower_node(def_id);
     }
@@ -577,7 +621,7 @@ enum GenericArgsMode {
     Silence,
 }
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     fn create_def(
         &mut self,
         node_id: ast::NodeId,
@@ -603,22 +647,19 @@ fn create_def(
             .def_id();
 
         debug!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id, node_id);
-        self.resolver.node_id_to_def_id.insert(node_id, def_id);
+        self.resolver.insert_new_def_id(node_id, def_id);
 
         def_id
     }
 
     fn next_node_id(&mut self) -> NodeId {
-        let start = self.resolver.next_node_id;
-        let next = start.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
-        self.resolver.next_node_id = ast::NodeId::from_u32(next);
-        start
+        self.resolver.next_node_id()
     }
 
     /// Given the id of some node in the AST, finds the `LocalDefId` associated with it by the name
     /// resolver (if any).
     fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
-        self.resolver.node_id_to_def_id.get(&node).copied()
+        self.resolver.opt_local_def_id(node)
     }
 
     fn local_def_id(&self, node: NodeId) -> LocalDefId {
@@ -747,7 +788,7 @@ fn lower_node_id(&mut self, ast_node_id: NodeId) -> HirId {
             self.children.push((def_id, hir::MaybeOwner::NonOwner(hir_id)));
         }
 
-        if let Some(&traits) = self.resolver.trait_map.get(&ast_node_id) {
+        if let Some(traits) = self.resolver.trait_candidates(ast_node_id) {
             self.trait_map.insert(hir_id.local_id, traits);
         }
 
@@ -1764,7 +1805,7 @@ fn lower_fn_decl(
             inputs,
             output,
             c_variadic,
-            lifetime_elision_allowed: self.resolver.lifetime_elision_allowed.contains(&fn_node_id),
+            lifetime_elision_allowed: self.resolver.lifetime_elision_allowed(fn_node_id),
             implicit_self: decl.inputs.get(0).map_or(hir::ImplicitSelfKind::None, |arg| {
                 let is_mutable_pat = matches!(
                     arg.pat.kind,
@@ -2951,7 +2992,10 @@ fn is_empty(&self) -> bool {
             && self.parenthesized == hir::GenericArgsParentheses::No
     }
 
-    fn into_generic_args(self, this: &LoweringContext<'_, 'hir>) -> &'hir hir::GenericArgs<'hir> {
+    fn into_generic_args(
+        self,
+        this: &LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
+    ) -> &'hir hir::GenericArgs<'hir> {
         let ga = hir::GenericArgs {
             args: this.arena.alloc_from_iter(self.args),
             constraints: self.constraints,
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index e066bce95158..e73b342e964f 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -15,7 +15,7 @@
 use super::{ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt};
 use crate::{AllowReturnTypeNotation, ImplTraitPosition};
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir hir::Pat<'hir> {
         self.arena.alloc(self.lower_pat_mut(pattern))
     }
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index ec57720387c0..83cebed3a459 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -19,7 +19,7 @@
     LifetimeRes, LoweringContext, ParamMode, ResolverAstLoweringExt,
 };
 
-impl<'a, 'hir> LoweringContext<'a, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     #[instrument(level = "trace", skip(self))]
     pub(crate) fn lower_qpath(
         &mut self,

From b77739ad815abef544be28928d7631001e6bfcdc Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sat, 14 Mar 2026 22:47:42 +0900
Subject: [PATCH 0629/1059] Do not shallow resolve to root var while fudging

---
 compiler/rustc_hir_typeck/src/expr.rs         |  2 +-
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  7 +----
 compiler/rustc_infer/src/infer/mod.rs         | 30 +++++++++++++++++++
 compiler/rustc_infer/src/infer/resolve.rs     | 18 +++++++++--
 .../rustc_infer/src/infer/snapshot/fudge.rs   |  2 +-
 .../input-ty-closure-param-fn-trait-bounds.rs | 17 +++++++++++
 .../input-ty-higher-ranked-fn-trait.rs        | 21 +++++++++++++
 7 files changed, 86 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/coercion/fudge-inference/input-ty-closure-param-fn-trait-bounds.rs
 create mode 100644 tests/ui/coercion/fudge-inference/input-ty-higher-ranked-fn-trait.rs

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 17c7c4b76b2d..6b77169994a0 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1879,7 +1879,7 @@ fn check_expr_struct_fields(
                 if !ocx.try_evaluate_obligations().is_empty() {
                     return Err(TypeError::Mismatch);
                 }
-                Ok(self.resolve_vars_if_possible(adt_ty))
+                Ok(adt_ty)
             })
             .ok()
         });
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 9faa75e18480..166c1b79576c 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -276,12 +276,7 @@ pub(in super::super) fn check_argument_types(
 
                     // Record all the argument types, with the args
                     // produced from the above subtyping unification.
-                    Ok(Some(
-                        formal_input_tys
-                            .iter()
-                            .map(|&ty| self.resolve_vars_if_possible(ty))
-                            .collect(),
-                    ))
+                    Ok(Some(formal_input_tys.to_vec()))
                 })
                 .ok()
             })
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index b57306536260..10e7b1e72f44 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1250,6 +1250,36 @@ pub fn resolve_vars_if_possible<T>(&self, value: T) -> T
         value.fold_with(&mut r)
     }
 
+    /// Normally, we shallow-resolve unresolved type variables to their root
+    /// variables. This is mainly done for performance reasons, and in most
+    /// cases resolving to the root variable (instead of the variable itself)
+    /// does not affect type inference.
+    ///
+    /// However, there is an exceptional case: *fudging*. Fudging is intended
+    /// to guide inference rather than impose hard requirements. But our current
+    /// handling here is somewhat janky.
+    ///
+    /// In particular, inference variables that are considered equal within the
+    /// fudging scope may not remain equal outside of it. This makes it observable
+    /// which inference variable we resolve to. For backwards compatibility, we
+    /// avoid resolving to the root variable by using this function inside the
+    /// fudge instead of [`InferCtxt::resolve_vars_if_possible`].
+    ///
+    /// See #153869 for more details.
+    pub fn resolve_vars_if_possible_for_fudging<T>(&self, value: T) -> T
+    where
+        T: TypeFoldable<TyCtxt<'tcx>>,
+    {
+        if let Err(guar) = value.error_reported() {
+            self.set_tainted_by_errors(guar);
+        }
+        if !value.has_non_region_infer() {
+            return value;
+        }
+        let mut r = resolve::OpportunisticVarResolver::new_for_fudging(self);
+        value.fold_with(&mut r)
+    }
+
     pub fn resolve_numeric_literals_with_default<T>(&self, value: T) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
diff --git a/compiler/rustc_infer/src/infer/resolve.rs b/compiler/rustc_infer/src/infer/resolve.rs
index 13df23a39b96..917d7b6653e0 100644
--- a/compiler/rustc_infer/src/infer/resolve.rs
+++ b/compiler/rustc_infer/src/infer/resolve.rs
@@ -17,6 +17,9 @@
 /// points for correctness.
 pub struct OpportunisticVarResolver<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
+    /// If true, we don't resolve ty/const vars to their roots.
+    /// See comments on [`InferCtxt::resolve_vars_if_possible_for_fudging`]
+    for_fudging: bool,
     /// We're able to use a cache here as the folder does
     /// not have any mutable state.
     cache: DelayedMap<Ty<'tcx>, Ty<'tcx>>,
@@ -25,7 +28,12 @@ pub struct OpportunisticVarResolver<'a, 'tcx> {
 impl<'a, 'tcx> OpportunisticVarResolver<'a, 'tcx> {
     #[inline]
     pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
-        OpportunisticVarResolver { infcx, cache: Default::default() }
+        OpportunisticVarResolver { infcx, for_fudging: false, cache: Default::default() }
+    }
+
+    #[inline]
+    pub fn new_for_fudging(infcx: &'a InferCtxt<'tcx>) -> Self {
+        OpportunisticVarResolver { infcx, for_fudging: true, cache: Default::default() }
     }
 }
 
@@ -43,6 +51,7 @@ fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         } else {
             let shallow = self.infcx.shallow_resolve(t);
             let res = shallow.super_fold_with(self);
+            let res = if self.for_fudging && res.is_ty_var() { t } else { res };
             assert!(self.cache.insert(t, res));
             res
         }
@@ -52,8 +61,11 @@ fn fold_const(&mut self, ct: Const<'tcx>) -> Const<'tcx> {
         if !ct.has_non_region_infer() {
             ct // micro-optimize -- if there is nothing in this const that this fold affects...
         } else {
-            let ct = self.infcx.shallow_resolve_const(ct);
-            ct.super_fold_with(self)
+            let res = self.infcx.shallow_resolve_const(ct);
+            if self.for_fudging && res.is_ct_infer() {
+                return ct;
+            };
+            res.super_fold_with(self)
         }
     }
 
diff --git a/compiler/rustc_infer/src/infer/snapshot/fudge.rs b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
index 6709c822dc7b..56cae2c1e396 100644
--- a/compiler/rustc_infer/src/infer/snapshot/fudge.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
@@ -101,7 +101,7 @@ pub fn fudge_inference_if_ok<T, E, F>(&self, f: F) -> Result<T, E>
             // going to be popped, so we will have to
             // eliminate any references to them.
             let snapshot_vars = SnapshotVarData::new(self, variable_lengths);
-            Ok((snapshot_vars, self.resolve_vars_if_possible(value)))
+            Ok((snapshot_vars, self.resolve_vars_if_possible_for_fudging(value)))
         })?;
 
         // At this point, we need to replace any of the now-popped
diff --git a/tests/ui/coercion/fudge-inference/input-ty-closure-param-fn-trait-bounds.rs b/tests/ui/coercion/fudge-inference/input-ty-closure-param-fn-trait-bounds.rs
new file mode 100644
index 000000000000..91dc8e394563
--- /dev/null
+++ b/tests/ui/coercion/fudge-inference/input-ty-closure-param-fn-trait-bounds.rs
@@ -0,0 +1,17 @@
+//@ check-pass
+
+// Regression test for <https://github.com/rust-lang/rust/issues/153816>
+
+struct Inv<T, U>(*mut (T, U));
+
+fn pass_through<F>(_: F) -> Inv<F, F> {
+    todo!()
+}
+
+fn map(_: Inv<impl FnOnce(), impl Fn()>) {}
+
+fn traverse() {
+    map(pass_through(|| ()))
+}
+
+fn main() {}
diff --git a/tests/ui/coercion/fudge-inference/input-ty-higher-ranked-fn-trait.rs b/tests/ui/coercion/fudge-inference/input-ty-higher-ranked-fn-trait.rs
new file mode 100644
index 000000000000..241a177e4c15
--- /dev/null
+++ b/tests/ui/coercion/fudge-inference/input-ty-higher-ranked-fn-trait.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+// Regression test for <https://github.com/rust-lang/rust/issues/153849>
+
+#[expect(dead_code)]
+// Must be invariant
+pub struct Server<T>(*mut T);
+impl<T> Server<T> {
+    fn new(_: T) -> Self
+    where
+        // Must be higher-ranked
+        T: Fn(&mut i32),
+    {
+        todo!()
+    }
+}
+
+fn main() {
+    // Must have a type annotation
+    let _: Server<_> = Server::new(|_| ());
+}

From 13fc81ac2a424040f95cc8e116b1a61e3b476f12 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Thu, 19 Mar 2026 00:37:22 +0900
Subject: [PATCH 0630/1059] Add TODO checker (#1632)

---
 .github/workflows/main.yml | 12 ++++++-
 build_system/main.rs       |  9 ++++-
 build_system/todo.rs       | 70 ++++++++++++++++++++++++++++++++++++++
 build_system/usage.txt     |  1 +
 4 files changed, 90 insertions(+), 2 deletions(-)
 create mode 100644 build_system/todo.rs

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 07d9af4a9b54..8acaa42d68bf 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -19,6 +19,16 @@ env:
   RUSTFLAGS: "-Dwarnings"
 
 jobs:
+  todo_check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Check todo
+      run: ./y.sh check-todo
+
   rustfmt:
     runs-on: ubuntu-latest
     timeout-minutes: 10
@@ -232,7 +242,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     if: ${{ github.ref == 'refs/heads/main' }}
-    needs: [rustfmt, test, bench, dist]
+    needs: [todo_check, rustfmt, test, bench, dist]
 
     permissions:
       contents: write # for creating the dev tag and release
diff --git a/build_system/main.rs b/build_system/main.rs
index 6251687babc6..0720d72c6d7c 100644
--- a/build_system/main.rs
+++ b/build_system/main.rs
@@ -17,6 +17,7 @@
 mod rustc_info;
 mod shared_utils;
 mod tests;
+mod todo;
 mod utils;
 
 fn usage() {
@@ -38,6 +39,7 @@ enum Command {
     Test,
     AbiCafe,
     Bench,
+    CheckTodo,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -66,6 +68,7 @@ fn main() {
         Some("test") => Command::Test,
         Some("abi-cafe") => Command::AbiCafe,
         Some("bench") => Command::Bench,
+        Some("check-todo") => Command::CheckTodo,
         Some(flag) if flag.starts_with('-') => arg_error!("Expected command found flag {}", flag),
         Some(command) => arg_error!("Unknown command {}", command),
         None => {
@@ -139,6 +142,10 @@ fn main() {
         process::exit(0);
     }
 
+    if command == Command::CheckTodo {
+        todo::run();
+    }
+
     let rustup_toolchain_name = match (env::var("CARGO"), env::var("RUSTC"), env::var("RUSTDOC")) {
         (Ok(_), Ok(_), Ok(_)) => None,
         (_, Err(_), Err(_)) => Some(rustc_info::get_toolchain_name()),
@@ -202,7 +209,7 @@ fn main() {
         ))
     };
     match command {
-        Command::Prepare => {
+        Command::Prepare | Command::CheckTodo => {
             // Handled above
         }
         Command::Test => {
diff --git a/build_system/todo.rs b/build_system/todo.rs
new file mode 100644
index 000000000000..66b31a10a065
--- /dev/null
+++ b/build_system/todo.rs
@@ -0,0 +1,70 @@
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::{fs, process};
+
+const EXTENSIONS: &[&str] =
+    &["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "ftl", "toml", "yml", "yaml"];
+
+fn has_supported_extension(path: &Path) -> bool {
+    path.extension().is_some_and(|ext| EXTENSIONS.iter().any(|e| ext == OsStr::new(e)))
+}
+
+fn list_tracked_files() -> Result<Vec<PathBuf>, String> {
+    let output = Command::new("git")
+        .args(["ls-files", "-z"])
+        .output()
+        .map_err(|e| format!("Failed to run `git ls-files`: {e}"))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("`git ls-files` failed: {stderr}"));
+    }
+
+    let mut files = Vec::new();
+    for entry in output.stdout.split(|b| *b == 0) {
+        if entry.is_empty() {
+            continue;
+        }
+        let path = std::str::from_utf8(entry).unwrap();
+        files.push(PathBuf::from(path));
+    }
+
+    Ok(files)
+}
+
+pub(crate) fn run() -> ! {
+    let files = list_tracked_files().unwrap();
+    let mut error_count = 0;
+    // Avoid embedding the task marker in source so greps only find real occurrences.
+    let todo_marker = "todo".to_ascii_uppercase();
+
+    for file in files {
+        if !has_supported_extension(&file) {
+            continue;
+        }
+
+        let bytes = fs::read(&file).unwrap();
+        let contents = std::str::from_utf8(&bytes).unwrap();
+
+        for (i, line) in contents.split('\n').enumerate() {
+            let trimmed = line.trim();
+            if trimmed.contains(&todo_marker) {
+                eprintln!(
+                    "{}:{}: {} is used for tasks that should be done before merging a PR; if you want to leave a message in the codebase use FIXME",
+                    file.display(),
+                    i + 1,
+                    todo_marker
+                );
+                error_count += 1;
+            }
+        }
+    }
+
+    if error_count == 0 {
+        process::exit(0);
+    }
+
+    eprintln!("found {} {}(s)", error_count, todo_marker);
+    process::exit(1);
+}
diff --git a/build_system/usage.txt b/build_system/usage.txt
index 6c98087e5239..572fe7805810 100644
--- a/build_system/usage.txt
+++ b/build_system/usage.txt
@@ -6,6 +6,7 @@ USAGE:
     ./y.sh test [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen] [--skip-test TESTNAME]
     ./y.sh abi-cafe [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
     ./y.sh bench [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
+    ./y.sh check-todo
 
 OPTIONS:
     --sysroot none|clif|llvm

From 989b69c6d0ed227ec1992a0116f8aa34adc26780 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:09:59 +0100
Subject: [PATCH 0631/1059] Remove audit workflow

It is not really useful. cg_clif is meant for development only and has
relatively few dependencies. It has only ever caught an unmaintained
crate about which nothing could be done on our end as cranelift-jit
depended on it.
---
 .github/workflows/audit.yml | 18 ------------------
 1 file changed, 18 deletions(-)
 delete mode 100644 .github/workflows/audit.yml

diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
deleted file mode 100644
index 95a4dcd3266d..000000000000
--- a/.github/workflows/audit.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-name: Security audit
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 10 * * 1' # every monday at 10:00 UTC
-permissions:
-  issues: write
-  checks: write
-jobs:
-  audit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - run: |
-          sed -i 's/components.*/components = []/' rust-toolchain.toml
-      - uses: rustsec/audit-check@v2.0.0
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}

From 4366c22475fa011f9c7f4c2d275b21e1f0ee7441 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:27:11 +0100
Subject: [PATCH 0632/1059] Remove outdated entries in clean_all.sh

---
 clean_all.sh | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/clean_all.sh b/clean_all.sh
index 4dbd9dac94a8..32ed19300ac6 100755
--- a/clean_all.sh
+++ b/clean_all.sh
@@ -2,9 +2,3 @@
 set -e
 
 rm -rf target/ build_system/target download/ build/ dist/
-
-# Kept for now in case someone updates their checkout of cg_clif before running clean_all.sh
-# FIXME remove at some point in the future
-rm y.bin y.bin.dSYM y.exe y.pdb 2>/dev/null || true
-rm -rf rand/ regex/ simple-raytracer/ portable-simd/ abi-checker/ abi-cafe/
-rm -rf build_sysroot/{sysroot_src/,target/,compiler-builtins/,rustc_version}

From 74c51ce75e240c27c7a8650fdf9e0038464c7e19 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 18 Mar 2026 17:28:17 +0100
Subject: [PATCH 0633/1059] Don't emit `missing_doc_code_examples` on impl
 items

---
 src/librustdoc/passes/check_doc_test_visibility.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs
index 40dfdb890d66..a1578ab40209 100644
--- a/src/librustdoc/passes/check_doc_test_visibility.rs
+++ b/src/librustdoc/passes/check_doc_test_visibility.rs
@@ -79,8 +79,7 @@ pub(crate) fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -
                 | clean::ProvidedAssocConstItem(..)
                 | clean::ImplAssocConstItem(..)
                 | clean::RequiredAssocTypeItem(..)
-                // check for trait impl
-                | clean::ImplItem(box clean::Impl { trait_: Some(_), .. })
+                | clean::ImplItem(_)
         )
     {
         return false;

From 6d3b7809cf0dbe8395b26118247439e47a9f9e12 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 18 Mar 2026 17:28:55 +0100
Subject: [PATCH 0634/1059] Add more tests for rustdoc
 `missing_doc_code_examples` lint

---
 .../lints/lint-missing-doc-code-example.rs    |  6 +++++-
 .../lint-missing-doc-code-example.stderr      | 20 ++++++++++++++++++-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/tests/rustdoc-ui/lints/lint-missing-doc-code-example.rs b/tests/rustdoc-ui/lints/lint-missing-doc-code-example.rs
index 8e5c31d50edc..731d19bffec5 100644
--- a/tests/rustdoc-ui/lints/lint-missing-doc-code-example.rs
+++ b/tests/rustdoc-ui/lints/lint-missing-doc-code-example.rs
@@ -78,7 +78,11 @@ fn clone(&self) -> Self {
     }
 }
 
-
+impl Struct { // No doc or code example and it's fine!
+    pub fn bar() {}
+    //~^ ERROR missing code example in this documentation
+    //~| ERROR missing documentation for an associated function
+}
 
 /// doc
 ///
diff --git a/tests/rustdoc-ui/lints/lint-missing-doc-code-example.stderr b/tests/rustdoc-ui/lints/lint-missing-doc-code-example.stderr
index 22533b9816a7..6382c5926e8f 100644
--- a/tests/rustdoc-ui/lints/lint-missing-doc-code-example.stderr
+++ b/tests/rustdoc-ui/lints/lint-missing-doc-code-example.stderr
@@ -1,3 +1,15 @@
+error: missing documentation for an associated function
+  --> $DIR/lint-missing-doc-code-example.rs:82:5
+   |
+LL |     pub fn bar() {}
+   |     ^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/lint-missing-doc-code-example.rs:2:9
+   |
+LL | #![deny(missing_docs)]
+   |         ^^^^^^^^^^^^
+
 error: missing code example in this documentation
   --> $DIR/lint-missing-doc-code-example.rs:38:3
    |
@@ -28,5 +40,11 @@ error: missing code example in this documentation
 LL | /// Doc
    | ^^^^^^^
 
-error: aborting due to 4 previous errors
+error: missing code example in this documentation
+  --> $DIR/lint-missing-doc-code-example.rs:82:5
+   |
+LL |     pub fn bar() {}
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
 

From 49bb371ca74904400330e065dd847b6b9390b2a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 11 Mar 2026 16:39:03 +0000
Subject: [PATCH 0635/1059] When single impl can satisfy inference error,
 suggest type

When encountering an inference error where a return type must be known, like when calling `Iterator::sum::<T>()` without specifying `T`, look for all `T` that would satisfy `Sum<S>`. If only one, suggest it.

```
error[E0283]: type annotations needed
  --> $DIR/cannot-infer-iterator-sum-return-type.rs:4:9
   |
LL |     let sum = v
   |         ^^^
...
LL |         .sum(); // `sum::<T>` needs `T` to be specified
   |          --- type must be known at this point
   |
   = note: cannot satisfy `_: Sum<i32>`
help: the trait `Sum` is implemented for `i32`
  --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
  ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
   |
   = note: in this macro invocation
note: required by a bound in `std::iter::Iterator::sum`
  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
   = note: this error originates in the macro `integer_sum_product` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider giving `sum` an explicit type, where the type for type parameter `S` is specified
   |
LL |     let sum: i32 = v
   |            +++++
```
---
 .../error_reporting/infer/need_type_info.rs   | 64 ++++++++++++++++---
 .../src/error_reporting/traits/ambiguity.rs   | 27 +++++++-
 .../traits/fulfillment_errors.rs              | 10 +++
 .../const-generics/issues/issue-83249.stderr  |  6 +-
 ...annot-infer-iterator-sum-return-type.fixed | 13 ++++
 .../cannot-infer-iterator-sum-return-type.rs  | 13 ++++
 ...nnot-infer-iterator-sum-return-type.stderr | 26 ++++++++
 7 files changed, 145 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/inference/cannot-infer-iterator-sum-return-type.fixed
 create mode 100644 tests/ui/inference/cannot-infer-iterator-sum-return-type.rs
 create mode 100644 tests/ui/inference/cannot-infer-iterator-sum-return-type.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 5cb8922574b6..7fcaea3a629f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -158,6 +158,7 @@ fn try_get_prefix(&self) -> Option<&str> {
 
 struct ClosureEraser<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
+    depth: usize,
 }
 
 impl<'a, 'tcx> ClosureEraser<'a, 'tcx> {
@@ -172,7 +173,8 @@ fn cx(&self) -> TyCtxt<'tcx> {
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        match ty.kind() {
+        self.depth += 1;
+        let ty = match ty.kind() {
             ty::Closure(_, args) => {
                 // For a closure type, we turn it into a function pointer so that it gets rendered
                 // as `fn(args) -> Ret`.
@@ -233,9 +235,15 @@ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
                 // its type parameters.
                 ty.super_fold_with(self)
             }
-            // We don't have an unknown type parameter anywhere, replace with `_`.
+            // We are in the top-level type, not one of its type parameters. Name it with its
+            // parameters replaced.
+            _ if self.depth == 1 => ty.super_fold_with(self),
+            // We don't have an unknown type parameter anywhere, and we are in a type parameter.
+            // Replace with `_`.
             _ => self.new_infer(),
-        }
+        };
+        self.depth -= 1;
+        ty
     }
 
     fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
@@ -287,7 +295,7 @@ fn ty_to_string<'tcx>(
     let ty = infcx.resolve_vars_if_possible(ty);
     // We use `fn` ptr syntax for closures, but this only works when the closure does not capture
     // anything. We also remove all type parameters that are fully known to the type system.
-    let ty = ty.fold_with(&mut ClosureEraser { infcx });
+    let ty = ty.fold_with(&mut ClosureEraser { infcx, depth: 0 });
 
     match (ty.kind(), called_method_def_id) {
         // We don't want the regular output for `fn`s because it includes its path in
@@ -467,6 +475,25 @@ pub fn emit_inference_failure_err(
         term: Term<'tcx>,
         error_code: TypeAnnotationNeeded,
         should_label_span: bool,
+    ) -> Diag<'a> {
+        self.emit_inference_failure_err_with_type_hint(
+            body_def_id,
+            failure_span,
+            term,
+            error_code,
+            should_label_span,
+            None,
+        )
+    }
+
+    pub fn emit_inference_failure_err_with_type_hint(
+        &self,
+        body_def_id: LocalDefId,
+        failure_span: Span,
+        term: Term<'tcx>,
+        error_code: TypeAnnotationNeeded,
+        should_label_span: bool,
+        ty: Option<Ty<'tcx>>,
     ) -> Diag<'a> {
         let term = self.resolve_vars_if_possible(term);
         let arg_data = self
@@ -479,7 +506,7 @@ pub fn emit_inference_failure_err(
             return self.bad_inference_failure_err(failure_span, arg_data, error_code);
         };
 
-        let mut local_visitor = FindInferSourceVisitor::new(self, typeck_results, term);
+        let mut local_visitor = FindInferSourceVisitor::new(self, typeck_results, term, ty);
         if let Some(body) = self.tcx.hir_maybe_body_owned_by(
             self.tcx.typeck_root_def_id(body_def_id.to_def_id()).expect_local(),
         ) {
@@ -779,10 +806,20 @@ fn ty_localized_msg(&self, infcx: &InferCtxt<'tcx>) -> (&'static str, String, Op
             | InferSourceKind::ClosureReturn { ty, .. } => {
                 if ty.is_closure() {
                     ("closure", closure_as_fn_str(infcx, ty), long_ty_path)
-                } else if !ty.is_ty_or_numeric_infer() {
-                    ("normal", infcx.tcx.short_string(ty, &mut long_ty_path), long_ty_path)
-                } else {
+                } else if ty.is_ty_or_numeric_infer()
+                    || ty.is_primitive()
+                    || matches!(
+                        ty.kind(),
+                        ty::Adt(_, args)
+                        if args.types().count() == 0 && args.consts().count() == 0
+                    )
+                {
+                    // `ty` is either `_`, a primitive type like `u32` or a type with no type or
+                    // const parameters. We will not mention the type in the main inference error
+                    // message.
                     ("other", String::new(), long_ty_path)
+                } else {
+                    ("normal", infcx.tcx.short_string(ty, &mut long_ty_path), long_ty_path)
                 }
             }
             // FIXME: We should be able to add some additional info here.
@@ -815,6 +852,7 @@ struct FindInferSourceVisitor<'a, 'tcx> {
     typeck_results: &'a TypeckResults<'tcx>,
 
     target: Term<'tcx>,
+    ty: Option<Ty<'tcx>>,
 
     attempt: usize,
     infer_source_cost: usize,
@@ -826,12 +864,14 @@ fn new(
         tecx: &'a TypeErrCtxt<'a, 'tcx>,
         typeck_results: &'a TypeckResults<'tcx>,
         target: Term<'tcx>,
+        ty: Option<Ty<'tcx>>,
     ) -> Self {
         FindInferSourceVisitor {
             tecx,
             typeck_results,
 
             target,
+            ty,
 
             attempt: 0,
             infer_source_cost: usize::MAX,
@@ -1213,7 +1253,7 @@ fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
     fn visit_local(&mut self, local: &'tcx LetStmt<'tcx>) {
         intravisit::walk_local(self, local);
 
-        if let Some(ty) = self.opt_node_type(local.hir_id) {
+        if let Some(mut ty) = self.opt_node_type(local.hir_id) {
             if self.generic_arg_contains_target(ty.into()) {
                 fn get_did(
                     typeck_results: &TypeckResults<'_>,
@@ -1241,7 +1281,11 @@ fn get_did(
                         _ => None,
                     }
                 }
-
+                if let Some(t) = self.ty
+                    && ty.has_infer()
+                {
+                    ty = t;
+                }
                 if let LocalSource::Normal = local.source
                     && local.ty.is_none()
                 {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
index 7de8891196d8..7f5ed9ecb6d1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -246,12 +246,37 @@ pub(super) fn maybe_report_ambiguity(
                     .find(|s| s.has_non_region_infer());
 
                 let mut err = if let Some(term) = term {
-                    self.emit_inference_failure_err(
+                    let candidates: Vec<_> = self
+                        .tcx
+                        .all_impls(trait_pred.def_id())
+                        .filter_map(|def_id| {
+                            let imp = self.tcx.impl_trait_header(def_id);
+                            if imp.polarity != ty::ImplPolarity::Positive
+                                || !self.tcx.is_user_visible_dep(def_id.krate)
+                            {
+                                return None;
+                            }
+                            let imp = imp.trait_ref.skip_binder();
+                            if imp
+                                .with_replaced_self_ty(self.tcx, trait_pred.skip_binder().self_ty())
+                                == trait_pred.skip_binder().trait_ref
+                            {
+                                Some(imp.self_ty())
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
+                    self.emit_inference_failure_err_with_type_hint(
                         obligation.cause.body_id,
                         span,
                         term,
                         TypeAnnotationNeeded::E0283,
                         true,
+                        match &candidates[..] {
+                            [candidate] => Some(*candidate),
+                            _ => None,
+                        },
                     )
                 } else {
                     struct_span_code_err!(
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index d5383fd4d083..6bf08170bcf7 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -2251,6 +2251,16 @@ pub(super) fn report_similar_impl_candidates(
             if candidates.is_empty() {
                 return false;
             }
+            let mut specific_candidates = candidates.clone();
+            specific_candidates.retain(|(tr, _)| {
+                tr.with_replaced_self_ty(self.tcx, trait_pred.skip_binder().self_ty())
+                    == trait_pred.skip_binder().trait_ref
+            });
+            if !specific_candidates.is_empty() {
+                // We have found a subset of impls that fully satisfy the expected trait, only
+                // mention those types.
+                candidates = specific_candidates;
+            }
             if let &[(cand, def_id)] = &candidates[..] {
                 if self.tcx.is_diagnostic_item(sym::FromResidual, cand.def_id)
                     && !self.tcx.features().enabled(sym::try_trait_v2)
diff --git a/tests/ui/const-generics/issues/issue-83249.stderr b/tests/ui/const-generics/issues/issue-83249.stderr
index 2668348613a4..0f00f70700f5 100644
--- a/tests/ui/const-generics/issues/issue-83249.stderr
+++ b/tests/ui/const-generics/issues/issue-83249.stderr
@@ -17,10 +17,10 @@ note: required by a bound in `foo`
    |
 LL | fn foo<T: Foo>(_: [u8; T::N]) -> T {
    |           ^^^ required by this bound in `foo`
-help: consider giving this pattern a type
+help: consider giving this pattern a type, where the type for type parameter `T` is specified
    |
-LL |     let _: /* Type */ = foo([0; 1]);
-   |          ++++++++++++
+LL |     let _: u8 = foo([0; 1]);
+   |          ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inference/cannot-infer-iterator-sum-return-type.fixed b/tests/ui/inference/cannot-infer-iterator-sum-return-type.fixed
new file mode 100644
index 000000000000..9a494391f0e4
--- /dev/null
+++ b/tests/ui/inference/cannot-infer-iterator-sum-return-type.fixed
@@ -0,0 +1,13 @@
+//@ run-rustfix
+fn main() {
+    let v = vec![1, 2];
+    let sum: i32 = v //~ ERROR: type annotations needed
+        .iter()
+        .map(|val| *val)
+        .sum(); // `sum::<T>` needs `T` to be specified
+    // In this case any integer would fit, but we resolve to `i32` because that's what `{integer}`
+    // got coerced to. If the user needs further hinting that they can change the integer type, that
+    // can come from other suggestions. (#100802)
+    let bool = sum > 0;
+    assert_eq!(bool, true);
+}
diff --git a/tests/ui/inference/cannot-infer-iterator-sum-return-type.rs b/tests/ui/inference/cannot-infer-iterator-sum-return-type.rs
new file mode 100644
index 000000000000..013a2f914858
--- /dev/null
+++ b/tests/ui/inference/cannot-infer-iterator-sum-return-type.rs
@@ -0,0 +1,13 @@
+//@ run-rustfix
+fn main() {
+    let v = vec![1, 2];
+    let sum = v //~ ERROR: type annotations needed
+        .iter()
+        .map(|val| *val)
+        .sum(); // `sum::<T>` needs `T` to be specified
+    // In this case any integer would fit, but we resolve to `i32` because that's what `{integer}`
+    // got coerced to. If the user needs further hinting that they can change the integer type, that
+    // can come from other suggestions. (#100802)
+    let bool = sum > 0;
+    assert_eq!(bool, true);
+}
diff --git a/tests/ui/inference/cannot-infer-iterator-sum-return-type.stderr b/tests/ui/inference/cannot-infer-iterator-sum-return-type.stderr
new file mode 100644
index 000000000000..594b6f0181db
--- /dev/null
+++ b/tests/ui/inference/cannot-infer-iterator-sum-return-type.stderr
@@ -0,0 +1,26 @@
+error[E0283]: type annotations needed
+  --> $DIR/cannot-infer-iterator-sum-return-type.rs:4:9
+   |
+LL |     let sum = v
+   |         ^^^
+...
+LL |         .sum(); // `sum::<T>` needs `T` to be specified
+   |          --- type must be known at this point
+   |
+   = note: the type must implement `Sum<i32>`
+help: the trait `Sum` is implemented for `i32`
+  --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
+  ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
+   |
+   = note: in this macro invocation
+note: required by a bound in `std::iter::Iterator::sum`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+   = note: this error originates in the macro `integer_sum_product` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider giving `sum` an explicit type, where the type for type parameter `S` is specified
+   |
+LL |     let sum: i32 = v
+   |            +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0283`.

From c3994642114d5e40367f9b4ee4bf921bb72aaea8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 17 Mar 2026 22:53:48 +0100
Subject: [PATCH 0636/1059] Add regression test for #153837

---
 .../Cargo.toml                                | 10 ++++++++
 .../examples/window.rs                        | 24 +++++++++++++++++++
 .../rmake.rs                                  | 11 +++++++++
 .../src/lib.rs                                | 13 ++++++++++
 4 files changed, 58 insertions(+)
 create mode 100644 tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/Cargo.toml
 create mode 100644 tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/examples/window.rs
 create mode 100644 tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/rmake.rs
 create mode 100644 tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/src/lib.rs

diff --git a/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/Cargo.toml b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/Cargo.toml
new file mode 100644
index 000000000000..4563b630c312
--- /dev/null
+++ b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/Cargo.toml
@@ -0,0 +1,10 @@
+[workspace]
+
+[package]
+edition = "2024"
+name = "tester"
+version = "0.1.0"
+
+[[example]]
+doc-scrape-examples = true
+name = "window"
diff --git a/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/examples/window.rs b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/examples/window.rs
new file mode 100644
index 000000000000..19d9ad849788
--- /dev/null
+++ b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/examples/window.rs
@@ -0,0 +1,24 @@
+#![allow(dead_code)]
+use tester::Window;
+
+macro_rules! info {
+    ($s:literal, $x:expr) => {{
+        let _ = $x;
+    }};
+}
+
+struct WindowState {
+    window: Window,
+}
+
+impl WindowState {
+    fn takes_ref(&self) {
+        info!("{:?}", self.window.id());
+    }
+
+    fn takes_mut(&mut self) {
+        info!("{:?}", self.window.id());
+    }
+}
+
+fn main() {}
diff --git a/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/rmake.rs b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/rmake.rs
new file mode 100644
index 000000000000..67a328f815bd
--- /dev/null
+++ b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/rmake.rs
@@ -0,0 +1,11 @@
+//! This test ensures that the call locations are not duplicated when generating scraped examples.
+//! To ensure that, we check that this call doesn't fail.
+//! Regression test for <https://github.com/rust-lang/rust/issues/153837>.
+
+use run_make_support::{cargo, htmldocck};
+
+fn main() {
+    cargo().args(["rustdoc", "-Zunstable-options", "-Zrustdoc-scrape-examples"]).run();
+
+    htmldocck().arg("target/doc").arg("src/lib.rs").run();
+}
diff --git a/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/src/lib.rs b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/src/lib.rs
new file mode 100644
index 000000000000..8c86a3726ea2
--- /dev/null
+++ b/tests/run-make-cargo/rustdoc-scrape-examples-duplicated-calls/src/lib.rs
@@ -0,0 +1,13 @@
+//@has tester/struct.Window.html
+//@count - '//*[@class="docblock scraped-example-list"]//span[@class="highlight"]' 1
+//@has - '//*[@class="docblock scraped-example-list"]//span[@class="highlight"]' 'id'
+//@count - '//*[@class="docblock scraped-example-list"]//span[@class="highlight focus"]' 1
+//@has - '//*[@class="docblock scraped-example-list"]//span[@class="highlight focus"]' 'id'
+
+pub struct Window {}
+
+impl Window {
+    pub fn id(&self) -> u64 {
+        todo!()
+    }
+}

From 45b22efe06630703e20de19c589299e6a592469e Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Wed, 18 Mar 2026 21:29:45 +0100
Subject: [PATCH 0637/1059] tests: Activate must_not_suspend test for
 MutexGuard dropped before await

The test pass in `nightly-2023-09-24` but fail in `nightly-2023-09-23`:

    $ rustc +nightly-2023-09-23 --edition 2018 tests/ui/lint/must_not_suspend/mutex-guard-dropped-before-await.rs
    error: `MutexGuard` held across a suspend point, but should not be
      --> tests/ui/lint/must_not_suspend/mutex-guard-dropped-before-await.rs:13:9
       |
    13 |     let lock = foo.lock().unwrap();
       |         ^^^^
    ...
    18 |     bar().await;
       |           ----- the value is held across this suspend point
       |
---
 src/tools/tidy/src/issues.txt                               | 1 -
 .../{issue-89562.rs => mutex-guard-dropped-before-await.rs} | 6 +++++-
 2 files changed, 5 insertions(+), 2 deletions(-)
 rename tests/ui/lint/must_not_suspend/{issue-89562.rs => mutex-guard-dropped-before-await.rs} (67%)

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 668a8abf1d8b..a9dc449afa83 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1476,7 +1476,6 @@ ui/lint/issue-97094.rs
 ui/lint/issue-99387.rs
 ui/lint/let_underscore/issue-119696-err-on-fn.rs
 ui/lint/let_underscore/issue-119697-extra-let.rs
-ui/lint/must_not_suspend/issue-89562.rs
 ui/lint/unused/issue-103320-must-use-ops.rs
 ui/lint/unused/issue-104397.rs
 ui/lint/unused/issue-105061-array-lint.rs
diff --git a/tests/ui/lint/must_not_suspend/issue-89562.rs b/tests/ui/lint/must_not_suspend/mutex-guard-dropped-before-await.rs
similarity index 67%
rename from tests/ui/lint/must_not_suspend/issue-89562.rs
rename to tests/ui/lint/must_not_suspend/mutex-guard-dropped-before-await.rs
index 99a548130720..d1c48c3c5145 100644
--- a/tests/ui/lint/must_not_suspend/issue-89562.rs
+++ b/tests/ui/lint/must_not_suspend/mutex-guard-dropped-before-await.rs
@@ -1,9 +1,13 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/89562>
+
 //@ edition:2018
 //@ run-pass
 
+#![feature(must_not_suspend)]
+#![deny(must_not_suspend)]
+
 use std::sync::Mutex;
 
-// Copied from the issue. Allow-by-default for now, so run-pass
 pub async fn foo() {
     let foo = Mutex::new(1);
     let lock = foo.lock().unwrap();

From ca2139d3262232d6b15471783f503ffe125531f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 16 Mar 2026 22:38:16 +0000
Subject: [PATCH 0638/1059] Point at return type when it is the source of the
 type expectation

When calling an fn that returns a return type as a returned expression, point at the return type to explain that it affects the expected type.

```
error[E0308]: mismatched types
    --> f56.rs:5:15
     |
   3 | fn main() {
     |          - the call expression's return type is influenced by this return type
   4 |     let a = 0;
   5 |     ptr::read(&a)
     |     --------- ^^ expected `*const ()`, found `&{integer}`
     |     |
     |     arguments to this function are incorrect
     |
     = note: expected raw pointer `*const ()`
                  found reference `&{integer}`
note: function defined here
    --> library/core/src/ptr/mod.rs:1681:21
     |
1681 | pub const unsafe fn read<T>(src: *const T) -> T {
     |                     ^^^^
```
---
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    | 41 ++++++++++++++++++-
 .../expectation-from-return-type.rs           | 21 ++++++++++
 .../expectation-from-return-type.stderr       | 35 ++++++++++++++++
 ...ransforming-option-ref-issue-127545.stderr |  6 +++
 ...call-return-type-due-to-generic-arg.stderr |  3 ++
 5 files changed, 105 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/mismatched_types/expectation-from-return-type.rs
 create mode 100644 tests/ui/mismatched_types/expectation-from-return-type.stderr

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 9faa75e18480..f53259e91eec 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -11,7 +11,7 @@
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::Visitor;
-use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath, is_range_literal};
+use rustc_hir::{Expr, ExprKind, FnRetTy, HirId, LangItem, Node, QPath, is_range_literal};
 use rustc_hir_analysis::check::potentially_plural_count;
 use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, PermitVariants};
 use rustc_index::IndexVec;
@@ -1587,6 +1587,45 @@ struct MismatchedParam<'a> {
                 }
             }
             err.span_note(spans, format!("{} defined here", self.tcx.def_descr(def_id)));
+            if let DefKind::Fn | DefKind::AssocFn = self.tcx.def_kind(def_id)
+                && let ty::Param(_) =
+                    self.tcx.fn_sig(def_id).instantiate_identity().skip_binder().output().kind()
+                && let parent = self.tcx.hir_get_parent_item(call_expr.hir_id).def_id
+                && let Some((output, body_id)) = match self.tcx.hir_node_by_def_id(parent) {
+                    hir::Node::Item(hir::Item {
+                        kind: hir::ItemKind::Fn { sig, body, .. },
+                        ..
+                    })
+                    | hir::Node::TraitItem(hir::TraitItem {
+                        kind: hir::TraitItemKind::Fn(sig, hir::TraitFn::Provided(body)),
+                        ..
+                    })
+                    | hir::Node::ImplItem(hir::ImplItem {
+                        kind: hir::ImplItemKind::Fn(sig, body),
+                        ..
+                    }) => Some((sig.decl.output, body)),
+                    _ => None,
+                }
+                && let expr = self.tcx.hir_body(*body_id).value
+                && (expr.peel_blocks().span == call_expr.span
+                    || matches!(
+                        self.tcx.parent_hir_node(call_expr.hir_id),
+                        hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Ret(_), .. })
+                    ))
+            {
+                err.span_label(
+                    output.span(),
+                    match output {
+                        FnRetTy::DefaultReturn(_) => format!(
+                            "this implicit `()` return type influences the call expression's return type"
+                        ),
+                        FnRetTy::Return(_) => {
+                            "this return type influences the call expression's return type"
+                                .to_string()
+                        }
+                    },
+                );
+            }
         } else if let Some(hir::Node::Expr(e)) = self.tcx.hir_get_if_local(def_id)
             && let hir::ExprKind::Closure(hir::Closure { body, .. }) = &e.kind
         {
diff --git a/tests/ui/mismatched_types/expectation-from-return-type.rs b/tests/ui/mismatched_types/expectation-from-return-type.rs
new file mode 100644
index 000000000000..ffe3d929984d
--- /dev/null
+++ b/tests/ui/mismatched_types/expectation-from-return-type.rs
@@ -0,0 +1,21 @@
+use std::ptr;
+
+fn main() { //~ NOTE: this implicit `()` return type influences the call expression's return type
+    let a = 0;
+    ptr::read(&a)
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `*const ()`, found `&{integer}`
+    //~| NOTE: arguments to this function are incorrect
+    //~| NOTE: expected raw pointer
+    //~| NOTE: function defined here
+}
+
+fn foo() { //~ NOTE: this implicit `()` return type influences the call expression's return type
+    let a = 0;
+    return ptr::read(&a);
+    //~^ ERROR: mismatched types
+    //~| NOTE: expected `*const ()`, found `&{integer}`
+    //~| NOTE: arguments to this function are incorrect
+    //~| NOTE: expected raw pointer
+    //~| NOTE: function defined here
+}
diff --git a/tests/ui/mismatched_types/expectation-from-return-type.stderr b/tests/ui/mismatched_types/expectation-from-return-type.stderr
new file mode 100644
index 000000000000..3bd7a21f987f
--- /dev/null
+++ b/tests/ui/mismatched_types/expectation-from-return-type.stderr
@@ -0,0 +1,35 @@
+error[E0308]: mismatched types
+  --> $DIR/expectation-from-return-type.rs:5:15
+   |
+LL | fn main() {
+   |          - this implicit `()` return type influences the call expression's return type
+LL |     let a = 0;
+LL |     ptr::read(&a)
+   |     --------- ^^ expected `*const ()`, found `&{integer}`
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected raw pointer `*const ()`
+                found reference `&{integer}`
+note: function defined here
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+
+error[E0308]: mismatched types
+  --> $DIR/expectation-from-return-type.rs:15:22
+   |
+LL | fn foo() {
+   |         - this implicit `()` return type influences the call expression's return type
+LL |     let a = 0;
+LL |     return ptr::read(&a);
+   |            --------- ^^ expected `*const ()`, found `&{integer}`
+   |            |
+   |            arguments to this function are incorrect
+   |
+   = note: expected raw pointer `*const ()`
+                found reference `&{integer}`
+note: function defined here
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/transforming-option-ref-issue-127545.stderr b/tests/ui/mismatched_types/transforming-option-ref-issue-127545.stderr
index 9a18798db213..6243a9a729a2 100644
--- a/tests/ui/mismatched_types/transforming-option-ref-issue-127545.stderr
+++ b/tests/ui/mismatched_types/transforming-option-ref-issue-127545.stderr
@@ -16,6 +16,8 @@ LL |     arg.map(|v| &**v)
 error[E0308]: mismatched types
   --> $DIR/transforming-option-ref-issue-127545.rs:9:19
    |
+LL | pub fn bar(arg: Option<&Vec<i32>>) -> &[i32] {
+   |                                       ------ this return type influences the call expression's return type
 LL |     arg.unwrap_or(&[])
    |         --------- ^^^ expected `&Vec<i32>`, found `&[_; 0]`
    |         |
@@ -41,6 +43,8 @@ LL +     arg.map_or(&[], |v| v)
 error[E0308]: mismatched types
   --> $DIR/transforming-option-ref-issue-127545.rs:13:19
    |
+LL | pub fn barzz<'a>(arg: Option<&'a Vec<i32>>, v: &'a [i32]) -> &'a [i32] {
+   |                                                              --------- this return type influences the call expression's return type
 LL |     arg.unwrap_or(v)
    |         --------- ^ expected `&Vec<i32>`, found `&[i32]`
    |         |
@@ -66,6 +70,8 @@ LL +     arg.map_or(v, |v| v)
 error[E0308]: mismatched types
   --> $DIR/transforming-option-ref-issue-127545.rs:17:19
    |
+LL | pub fn convert_result(arg: Result<&Vec<i32>, ()>) -> &[i32] {
+   |                                                      ------ this return type influences the call expression's return type
 LL |     arg.unwrap_or(&[])
    |         --------- ^^^ expected `&Vec<i32>`, found `&[_; 0]`
    |         |
diff --git a/tests/ui/type/wrong-call-return-type-due-to-generic-arg.stderr b/tests/ui/type/wrong-call-return-type-due-to-generic-arg.stderr
index 53920bc9e02e..fd07d5b09aeb 100644
--- a/tests/ui/type/wrong-call-return-type-due-to-generic-arg.stderr
+++ b/tests/ui/type/wrong-call-return-type-due-to-generic-arg.stderr
@@ -112,6 +112,9 @@ LL +     let x: u16 = (S {}).method(0u16);
 error[E0308]: arguments to this function are incorrect
   --> $DIR/wrong-call-return-type-due-to-generic-arg.rs:27:5
    |
+LL | fn main() {
+   |          - this implicit `()` return type influences the call expression's return type
+...
 LL |     function(0u32, 8u8)
    |     ^^^^^^^^ ----  --- expected `bool`, found `u8`
    |              |

From 1098a9d032d96d4509f2f9c3a20a5f1959f40440 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Wed, 18 Mar 2026 13:35:58 +0100
Subject: [PATCH 0639/1059] Support `--bless`-ing editor hashes

---
 src/bootstrap/src/core/build_steps/setup.rs   |  23 ++--
 .../src/core/build_steps/setup/hashes.json    | 122 ++++++++++--------
 .../src/core/build_steps/setup/tests.rs       |  40 +++++-
 3 files changed, 119 insertions(+), 66 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 1854637fc93b..85c23ac18e76 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -5,17 +5,17 @@
 //! allows setting up things that cannot be simply captured inside the bootstrap.toml, in addition to
 //! leading people away from manually editing most of the bootstrap.toml values.
 
+use std::collections::BTreeMap;
 use std::env::consts::EXE_SUFFIX;
 use std::fmt::Write as _;
 use std::fs::File;
 use std::io::Write;
 use std::path::{MAIN_SEPARATOR_STR, Path, PathBuf};
 use std::str::FromStr;
-use std::{fmt, fs, io};
-use std::collections::HashMap;
 use std::sync::LazyLock;
+use std::{fmt, fs, io};
 
-use serde_derive::Deserialize;
+use serde_derive::{Deserialize, Serialize};
 use sha2::Digest;
 
 use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
@@ -532,7 +532,7 @@ fn install_git_hook_maybe(builder: &Builder<'_>, config: &Config) -> io::Result<
 }
 
 /// Handles editor-specific setup differences
-#[derive(Clone, Debug, Eq, PartialEq, Hash, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 enum EditorKind {
     Emacs,
@@ -542,6 +542,13 @@ enum EditorKind {
     Zed,
 }
 
+static PARSED_HASHES: LazyLock<BTreeMap<EditorKind, Vec<&'static str>>> = LazyLock::new(|| {
+    const ALL_HASHES: &str = include_str!("setup/hashes.json");
+    let mut map: BTreeMap<_, Vec<_>> = serde_json::from_str(ALL_HASHES).unwrap();
+    map.insert(EditorKind::Vim, map.get(&EditorKind::VsCode).unwrap().clone());
+    map
+});
+
 impl EditorKind {
     // Used in `./tests.rs`.
     #[cfg(test)]
@@ -592,13 +599,7 @@ fn prompt_user() -> io::Result<Option<EditorKind>> {
     /// New entries should be appended whenever this is updated so we can detect
     /// outdated vs. user-modified settings files.
     fn hashes(&self) -> &'static [&'static str] {
-        const ALL_HASHES: &str = include_str!("setup/hashes.json");
-        static PARSED_HASHES: LazyLock<HashMap<EditorKind, Vec<&'static str>>> = LazyLock::new(|| {
-            let mut map: HashMap<_, Vec<_>> = serde_json::from_str(ALL_HASHES).unwrap();
-            map.insert(EditorKind::Vim, map.get(&EditorKind::VsCode).unwrap().clone());
-            map
-        });
-        &*PARSED_HASHES.get(self).unwrap()
+        PARSED_HASHES.get(self).unwrap()
     }
 
     fn settings_path(&self, config: &Config) -> PathBuf {
diff --git a/src/bootstrap/src/core/build_steps/setup/hashes.json b/src/bootstrap/src/core/build_steps/setup/hashes.json
index be657b577200..067c8fffe0d5 100644
--- a/src/bootstrap/src/core/build_steps/setup/hashes.json
+++ b/src/bootstrap/src/core/build_steps/setup/hashes.json
@@ -1,53 +1,73 @@
 {
-    "emacs": [
-        "51068d4747a13732440d1a8b8f432603badb1864fa431d83d0fd4f8fa57039e0",
-        "d29af4d949bbe2371eac928a3c31cf9496b1701aa1c45f11cd6c759865ad5c45",
-        "b5dd299b93dca3ceeb9b335f929293cb3d4bf4977866fbe7ceeac2a8a9f99088",
-        "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
-        "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
-        "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
-        "54bc48fe1996177f5eef86d7231b33978e6d8b737cb0a899e622b7e975c95308",
-        "08d30e455ceec6e01d9bcef8b9449f2ddd14d278ca8627cdad90e02d9f44e938"
-    ],
-    "helix": [
-        "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
-        "6736d61409fbebba0933afd2e4c44ff2f97c1cb36cf0299a7f4a7819b8775040",
-        "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
-        "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
-        "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
-        "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
-        "cb653043852d9d5ff4a5be56407b859ff9928be055ad3f307eb309aad04765e6",
-        "e28b1930d16d3d8bbdeed7bd4a995613e648b49e08c9b6f5271880f520637fed"
-    ],
-    "vscode": [
-        "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
-        "56e7bf011c71c5d81e0bf42e84938111847a810eee69d906bba494ea90b51922",
-        "af1b5efe196aed007577899db9dae15d6dbc923d6fa42fa0934e68617ba9bbe0",
-        "3468fea433c25fff60be6b71e8a215a732a7b1268b6a83bf10d024344e140541",
-        "47d227f424bf889b0d899b9cc992d5695e1b78c406e183cd78eafefbe5488923",
-        "b526bd58d0262dd4dda2bff5bc5515b705fb668a46235ace3e057f807963a11a",
-        "828666b021d837a33e78d870b56d34c88a5e2c85de58b693607ec574f0c27000",
-        "811fb3b063c739d261fd8590dd30242e117908f5a095d594fa04585daa18ec4d",
-        "4eecb58a2168b252077369da446c30ed0e658301efe69691979d1ef0443928f4",
-        "c394386e6133bbf29ffd32c8af0bb3d4aac354cba9ee051f29612aa9350f8f8d",
-        "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
-        "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
-        "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
-        "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
-        "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
-        "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
-        "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
-        "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd"
-    ],
-    "zed": [
-        "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
-        "a5380cf5dd9328731aecc5dfb240d16dac46ed272126b9728006151ef42f5909",
-        "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
-        "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
-        "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
-        "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
-        "74420c13094b530a986b37c4f1d23cb58c0e8e2295f5858ded129fb1574e66f9",
-        "2d3b592c089b2ad2c528686a1e371af49922edad1c59accd5d5f31612a441568",
-        "0767a2398ccc253274b184adbb9e018ce931bd0ef45baad06dad19b652c52951"
-    ]
+  "emacs": [
+    "51068d4747a13732440d1a8b8f432603badb1864fa431d83d0fd4f8fa57039e0",
+    "d29af4d949bbe2371eac928a3c31cf9496b1701aa1c45f11cd6c759865ad5c45",
+    "b5dd299b93dca3ceeb9b335f929293cb3d4bf4977866fbe7ceeac2a8a9f99088",
+    "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
+    "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
+    "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
+    "54bc48fe1996177f5eef86d7231b33978e6d8b737cb0a899e622b7e975c95308",
+    "08d30e455ceec6e01d9bcef8b9449f2ddd14d278ca8627cdad90e02d9f44e938"
+  ],
+  "helix": [
+    "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
+    "6736d61409fbebba0933afd2e4c44ff2f97c1cb36cf0299a7f4a7819b8775040",
+    "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
+    "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
+    "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
+    "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
+    "cb653043852d9d5ff4a5be56407b859ff9928be055ad3f307eb309aad04765e6",
+    "e28b1930d16d3d8bbdeed7bd4a995613e648b49e08c9b6f5271880f520637fed"
+  ],
+  "vim": [
+    "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
+    "56e7bf011c71c5d81e0bf42e84938111847a810eee69d906bba494ea90b51922",
+    "af1b5efe196aed007577899db9dae15d6dbc923d6fa42fa0934e68617ba9bbe0",
+    "3468fea433c25fff60be6b71e8a215a732a7b1268b6a83bf10d024344e140541",
+    "47d227f424bf889b0d899b9cc992d5695e1b78c406e183cd78eafefbe5488923",
+    "b526bd58d0262dd4dda2bff5bc5515b705fb668a46235ace3e057f807963a11a",
+    "828666b021d837a33e78d870b56d34c88a5e2c85de58b693607ec574f0c27000",
+    "811fb3b063c739d261fd8590dd30242e117908f5a095d594fa04585daa18ec4d",
+    "4eecb58a2168b252077369da446c30ed0e658301efe69691979d1ef0443928f4",
+    "c394386e6133bbf29ffd32c8af0bb3d4aac354cba9ee051f29612aa9350f8f8d",
+    "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
+    "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
+    "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
+    "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
+    "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
+    "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
+    "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
+    "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd"
+  ],
+  "vscode": [
+    "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
+    "56e7bf011c71c5d81e0bf42e84938111847a810eee69d906bba494ea90b51922",
+    "af1b5efe196aed007577899db9dae15d6dbc923d6fa42fa0934e68617ba9bbe0",
+    "3468fea433c25fff60be6b71e8a215a732a7b1268b6a83bf10d024344e140541",
+    "47d227f424bf889b0d899b9cc992d5695e1b78c406e183cd78eafefbe5488923",
+    "b526bd58d0262dd4dda2bff5bc5515b705fb668a46235ace3e057f807963a11a",
+    "828666b021d837a33e78d870b56d34c88a5e2c85de58b693607ec574f0c27000",
+    "811fb3b063c739d261fd8590dd30242e117908f5a095d594fa04585daa18ec4d",
+    "4eecb58a2168b252077369da446c30ed0e658301efe69691979d1ef0443928f4",
+    "c394386e6133bbf29ffd32c8af0bb3d4aac354cba9ee051f29612aa9350f8f8d",
+    "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
+    "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
+    "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
+    "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
+    "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
+    "0aa4748848de0d1cb7ece92a0123c8897fef6de2f58aff8fda1426f098b7a798",
+    "e5e357862e5d6d0d9da335e9823c07b8a7dc42bbf18d72cc5206ad1049cd8fcc",
+    "a68fd5828e75f3e921f265e29ce1e9efa554083c3773fdb4b8e1ab3b2d9dc6cd"
+  ],
+  "zed": [
+    "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
+    "a5380cf5dd9328731aecc5dfb240d16dac46ed272126b9728006151ef42f5909",
+    "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
+    "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
+    "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
+    "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
+    "74420c13094b530a986b37c4f1d23cb58c0e8e2295f5858ded129fb1574e66f9",
+    "2d3b592c089b2ad2c528686a1e371af49922edad1c59accd5d5f31612a441568",
+    "0767a2398ccc253274b184adbb9e018ce931bd0ef45baad06dad19b652c52951"
+  ]
 }
diff --git a/src/bootstrap/src/core/build_steps/setup/tests.rs b/src/bootstrap/src/core/build_steps/setup/tests.rs
index 6eafbb40b467..57b549286661 100644
--- a/src/bootstrap/src/core/build_steps/setup/tests.rs
+++ b/src/bootstrap/src/core/build_steps/setup/tests.rs
@@ -1,3 +1,8 @@
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+
 use sha2::Digest;
 
 use super::EditorKind;
@@ -5,14 +10,41 @@
 
 #[test]
 fn check_matching_settings_hash() {
+    // Needs to be a btree so we serialize in a deterministic order.
+    let mut mismatched = BTreeMap::new();
+
     for editor in EditorKind::ALL {
         let mut hasher = sha2::Sha256::new();
         hasher.update(&editor.settings_template());
         let actual = hex_encode(hasher.finalize().as_slice());
         let expected = *editor.hashes().last().unwrap();
-        assert_eq!(
-            expected, actual,
-            "Update `setup/hashes.json` with the new hash of `{actual}` for `EditorKind::{editor:?}`",
-        );
+
+        if expected != actual {
+            mismatched.insert(editor, (expected, actual));
+        }
+    }
+
+    if mismatched.is_empty() {
+        return;
+    }
+
+    if option_env!("INSTA_UPDATE").is_some_and(|s| s != "0") {
+        let mut updated = super::PARSED_HASHES.clone();
+        for (editor, (_, actual)) in &mismatched {
+            *updated.get_mut(editor).unwrap().last_mut().unwrap() = actual;
+        }
+        let hash_path =
+            Path::new(env!("CARGO_MANIFEST_DIR")).join("src/core/build_steps/setup/hashes.json");
+        let mut hash_file = File::create(hash_path).unwrap();
+        serde_json::to_writer_pretty(&mut hash_file, &updated).unwrap();
+        hash_file.write_all(b"\n").unwrap();
+    } else {
+        for (editor, (expected, actual)) in &mismatched {
+            eprintln!("recorded hash did not match actual hash: {expected} != {actual}");
+            eprintln!(
+                "Run `x test --bless -- hash`, or manually update `setup/hashes.json` with the new hash of `{actual}` for `EditorKind::{editor:?}`"
+            );
+        }
+        panic!("mismatched hashes");
     }
 }

From ebb1f470caf9c364876618797040d6880df3fb2a Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Thu, 19 Mar 2026 01:08:01 -0400
Subject: [PATCH 0640/1059] Optimize 128-bit integer formatting

The compiler is unaware of the restricted range of the input, so it is
unable to optimize out the final division and modulus. By doing this
manually, we get a nontrivial performance gain.
---
 library/core/src/fmt/num.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/library/core/src/fmt/num.rs b/library/core/src/fmt/num.rs
index d3d6495e75a2..dfa27e32bc72 100644
--- a/library/core/src/fmt/num.rs
+++ b/library/core/src/fmt/num.rs
@@ -823,7 +823,7 @@ fn enc_16lsd<const OFFSET: usize>(buf: &mut [MaybeUninit<u8>], n: u64) {
     let mut remain = n;
 
     // Format per four digits from the lookup table.
-    for quad_index in (0..4).rev() {
+    for quad_index in (1..4).rev() {
         // pull two pairs
         let quad = remain % 1_00_00;
         remain /= 1_00_00;
@@ -834,6 +834,14 @@ fn enc_16lsd<const OFFSET: usize>(buf: &mut [MaybeUninit<u8>], n: u64) {
         buf[quad_index * 4 + OFFSET + 2].write(DECIMAL_PAIRS[pair2 * 2 + 0]);
         buf[quad_index * 4 + OFFSET + 3].write(DECIMAL_PAIRS[pair2 * 2 + 1]);
     }
+
+    // final two pairs
+    let pair1 = (remain / 100) as usize;
+    let pair2 = (remain % 100) as usize;
+    buf[OFFSET + 0].write(DECIMAL_PAIRS[pair1 * 2 + 0]);
+    buf[OFFSET + 1].write(DECIMAL_PAIRS[pair1 * 2 + 1]);
+    buf[OFFSET + 2].write(DECIMAL_PAIRS[pair2 * 2 + 0]);
+    buf[OFFSET + 3].write(DECIMAL_PAIRS[pair2 * 2 + 1]);
 }
 
 /// Euclidean division plus remainder with constant 1E16 basically consumes 16

From e5e26094202d4b53f0b273c54d904c27d8eacf3d Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 19 Mar 2026 05:19:34 +0000
Subject: [PATCH 0641/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to fd0c901b00ee1e08a250039cdb90258603497e20.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 9c8f107f4235..e281dad8ef1e 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-91775dbec9771aa0c1b9ebe268eb5bd271e79a7a
+fd0c901b00ee1e08a250039cdb90258603497e20

From f60b6499d84ccf8bf0c325bf7ff3f736e134b730 Mon Sep 17 00:00:00 2001
From: Usman Akinyemi <usmanakinyemi202@gmail.com>
Date: Fri, 20 Feb 2026 20:11:37 +0530
Subject: [PATCH 0642/1059] rustc_resolve: improve const generic errors

Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>
---
 .../rustc_resolve/src/build_reduced_graph.rs  |   3 +-
 compiler/rustc_resolve/src/errors.rs          |  15 +
 compiler/rustc_resolve/src/late.rs            |  27 +-
 .../rustc_resolve/src/late/diagnostics.rs     | 269 ++++++++++++++++--
 compiler/rustc_resolve/src/lib.rs             |   6 +-
 .../const-generics/const-generic-function.rs  |   2 +-
 .../early/invalid-const-arguments.rs          |  21 +-
 .../early/invalid-const-arguments.stderr      | 110 +++++--
 tests/ui/const-generics/invalid-enum.rs       |  26 +-
 tests/ui/const-generics/invalid-enum.stderr   |  76 ++---
 .../missing-items/missing-type-parameter2.rs  |   7 +-
 .../missing-type-parameter2.stderr            |  37 +--
 12 files changed, 465 insertions(+), 134 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 80538aebf5f6..d9d42cfefcd8 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -898,7 +898,7 @@ fn build_reduced_graph_for_item(&mut self, item: &'a Item) {
             }
 
             // These items live in both the type and value namespaces.
-            ItemKind::Struct(ident, _, ref vdata) => {
+            ItemKind::Struct(ident, ref generics, ref vdata) => {
                 self.build_reduced_graph_for_struct_variant(
                     vdata.fields(),
                     ident,
@@ -947,6 +947,7 @@ fn build_reduced_graph_for_item(&mut self, item: &'a Item) {
                         .struct_constructors
                         .insert(local_def_id, (ctor_res, ctor_vis.to_def_id(), ret_fields));
                 }
+                self.r.struct_generics.insert(local_def_id, generics.clone());
             }
 
             ItemKind::Union(ident, _, ref vdata) => {
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 5aa09657a807..a04fe5038ed4 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -883,6 +883,21 @@ pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
     pub applicability: Applicability,
 }
 
+#[derive(Subdiagnostic)]
+#[suggestion(
+    "you might have meant to introduce a const parameter `{$item_name}` on the {$item_location}",
+    code = "{snippet}",
+    applicability = "machine-applicable",
+    style = "verbose"
+)]
+pub(crate) struct UnexpectedMissingConstParameter {
+    #[primary_span]
+    pub span: Span,
+    pub snippet: String,
+    pub item_name: String,
+    pub item_location: String,
+}
+
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
     "you might have meant to write a const parameter here",
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 453fe9d7a8e0..759e6223a3e8 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -4425,7 +4425,7 @@ fn smart_resolve_path_fragment(
         let Finalize { node_id, path_span, .. } = finalize;
         let report_errors = |this: &mut Self, res: Option<Res>| {
             if this.should_report_errs() {
-                let (err, candidates) = this.smart_resolve_report_errors(
+                let (mut err, candidates) = this.smart_resolve_report_errors(
                     path,
                     None,
                     path_span,
@@ -4436,7 +4436,8 @@ fn smart_resolve_path_fragment(
 
                 let def_id = this.parent_scope.module.nearest_parent_mod();
                 let instead = res.is_some();
-                let suggestion = if let Some((start, end)) = this.diag_metadata.in_range
+                let (suggestion, const_err) = if let Some((start, end)) =
+                    this.diag_metadata.in_range
                     && path[0].ident.span.lo() == end.span.lo()
                     && !matches!(start.kind, ExprKind::Lit(_))
                 {
@@ -4448,12 +4449,15 @@ fn smart_resolve_path_fragment(
                         span = span.with_lo(span.lo() + BytePos(1));
                         sugg = "";
                     }
-                    Some((
-                        span,
-                        "you might have meant to write `.` instead of `..`",
-                        sugg.to_string(),
-                        Applicability::MaybeIncorrect,
-                    ))
+                    (
+                        Some((
+                            span,
+                            "you might have meant to write `.` instead of `..`",
+                            sugg.to_string(),
+                            Applicability::MaybeIncorrect,
+                        )),
+                        None,
+                    )
                 } else if res.is_none()
                     && let PathSource::Type
                     | PathSource::Expr(_)
@@ -4461,9 +4465,14 @@ fn smart_resolve_path_fragment(
                 {
                     this.suggest_adding_generic_parameter(path, source)
                 } else {
-                    None
+                    (None, None)
                 };
 
+                if let Some(const_err) = const_err {
+                    err.cancel();
+                    err = const_err;
+                }
+
                 let ue = UseError {
                     err,
                     candidates,
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 95a6b25d54e6..e24389e0d74d 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -6,11 +6,12 @@
 
 use rustc_ast::visit::{FnCtxt, FnKind, LifetimeCtxt, Visitor, walk_ty};
 use rustc_ast::{
-    self as ast, AssocItemKind, DUMMY_NODE_ID, Expr, ExprKind, GenericParam, GenericParamKind,
-    Item, ItemKind, MethodCall, NodeId, Path, PathSegment, Ty, TyKind,
+    self as ast, AngleBracketedArg, AssocItemKind, DUMMY_NODE_ID, Expr, ExprKind, GenericArg,
+    GenericArgs, GenericParam, GenericParamKind, Item, ItemKind, MethodCall, NodeId, Path,
+    PathSegment, Ty, TyKind,
 };
 use rustc_ast_pretty::pprust::{path_to_string, where_bound_predicate_to_string};
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, ErrorGuaranteed, MultiSpan, SuggestionStyle, pluralize,
@@ -37,8 +38,8 @@
 };
 use crate::ty::fast_reject::SimplifiedType;
 use crate::{
-    Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, PathSource, Resolver,
-    ScopeSet, Segment, errors, path_names_to_string,
+    Finalize, Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, PathSource,
+    Resolver, ScopeSet, Segment, errors, path_names_to_string,
 };
 
 type Res = def::Res<ast::NodeId>;
@@ -3277,11 +3278,203 @@ fn suggest_using_enum_variant(
         }
     }
 
-    pub(crate) fn suggest_adding_generic_parameter(
-        &self,
+    /// Detects missing const parameters in `impl` blocks and suggests adding them.
+    ///
+    /// When a const parameter is used in the self type of an `impl` but not declared
+    /// in the `impl`'s own generic parameter list, this function emits a targeted
+    /// diagnostic with a suggestion to add it at the correct position.
+    ///
+    /// Example:
+    ///
+    /// ```rust,ignore (suggested field is not completely correct, it should be a single suggestion)
+    /// struct C<const A: u8, const X: u8, const P: u32>;
+    ///
+    /// impl Foo for C<A, X, P> {}
+    /// //           ^ the struct `C` in `C<A, X, P>` is used as the self type
+    /// //             ^ ^ ^ but A, X and P are not declared on the impl
+    ///
+    /// Suggested fix:
+    ///
+    /// impl<const A: u8, const X: u8, const P: u32> Foo for C<A, X, P> {}
+    ///
+    /// Current behavior (suggestions are emitted one-by-one):
+    ///
+    /// impl<const A: u8> Foo for C<A, X, P> {}
+    /// impl<const X: u8> Foo for C<A, X, P> {}
+    /// impl<const P: u32> Foo for C<A, X, P> {}
+    ///
+    /// Ideally the suggestion should aggregate them into a single line:
+    ///
+    /// impl<const A: u8, const X: u8, const P: u32> Foo for C<A, X, P> {}
+    /// ```
+    ///
+    pub(crate) fn detect_and_suggest_const_parameter_error(
+        &mut self,
         path: &[Segment],
-        source: PathSource<'_, '_, '_>,
-    ) -> Option<(Span, &'static str, String, Applicability)> {
+        source: PathSource<'_, 'ast, 'ra>,
+    ) -> Option<Diag<'tcx>> {
+        let Some(item) = self.diag_metadata.current_item else { return None };
+        let ItemKind::Impl(impl_) = &item.kind else { return None };
+        let self_ty = &impl_.self_ty;
+
+        // Represents parameter to the struct whether `A`, `X` or `P`
+        let [current_parameter] = path else {
+            return None;
+        };
+
+        let target_ident = current_parameter.ident;
+
+        // Find the parent segment i.e `C` in `C<A, X, C>`
+        let visitor = ParentPathVisitor::new(self_ty, target_ident);
+
+        let Some(parent_segment) = visitor.parent else {
+            return None;
+        };
+
+        let Some(args) = parent_segment.args.as_ref() else {
+            return None;
+        };
+
+        let GenericArgs::AngleBracketed(angle) = args.as_ref() else {
+            return None;
+        };
+
+        // Build map: NodeId of each usage in C<A, X, C> -> its position
+        // e.g NodeId(A) -> 0, NodeId(X) -> 1, NodeId(C) -> 2
+        let usage_to_pos: FxHashMap<NodeId, usize> = angle
+            .args
+            .iter()
+            .enumerate()
+            .filter_map(|(pos, arg)| {
+                if let AngleBracketedArg::Arg(GenericArg::Type(ty)) = arg
+                    && let TyKind::Path(_, path) = &ty.kind
+                    && let [segment] = path.segments.as_slice()
+                {
+                    Some((segment.id, pos))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        // Get the position of the missing param in C<A, X, C>
+        // e.g for missing `B` in `C<A, B, C>` this gives idx=1
+        let Some(idx) = current_parameter.id.and_then(|id| usage_to_pos.get(&id).copied()) else {
+            return None;
+        };
+
+        // Now resolve the parent struct `C` to get its definition
+        let ns = source.namespace();
+        let segment = Segment::from(parent_segment);
+        let segments = [segment];
+        let finalize = Finalize::new(parent_segment.id, parent_segment.ident.span);
+
+        if let Ok(Some(resolve)) = self.resolve_qpath_anywhere(
+            &None,
+            &segments,
+            ns,
+            source.defer_to_typeck(),
+            finalize,
+            source,
+        ) && let Some(resolve) = resolve.full_res()
+            && let Res::Def(_, def_id) = resolve
+            && def_id.is_local()
+            && let Some(local_def_id) = def_id.as_local()
+            && let Some(struct_generics) = self.r.struct_generics.get(&local_def_id)
+            && let target_param = &struct_generics.params[idx]
+            && let GenericParamKind::Const { ty, .. } = &target_param.kind
+            && let TyKind::Path(_, path) = &ty.kind
+        {
+            let full_type = path
+                .segments
+                .iter()
+                .map(|seg| seg.ident.to_string())
+                .collect::<Vec<_>>()
+                .join("::");
+
+            // Find the first impl param whose position in C<A, X, C>
+            // is strictly greater than our missing param's index
+            // e.g missing B(idx=1), impl has A(pos=0) and C(pos=2)
+            // C has pos=2 > 1 so insert before C
+            let next_impl_param = impl_.generics.params.iter().find(|impl_param| {
+                angle
+                    .args
+                    .iter()
+                    .find_map(|arg| {
+                        if let AngleBracketedArg::Arg(GenericArg::Type(ty)) = arg
+                            && let TyKind::Path(_, path) = &ty.kind
+                            && let [segment] = path.segments.as_slice()
+                            && segment.ident == impl_param.ident
+                        {
+                            usage_to_pos.get(&segment.id).copied()
+                        } else {
+                            None
+                        }
+                    })
+                    .map_or(false, |pos| pos > idx)
+            });
+
+            let (insert_span, snippet) = match next_impl_param {
+                Some(next_param) => {
+                    // Insert in the middle before next_param
+                    // e.g impl<A, C> -> impl<A, const B: u8, C>
+                    (
+                        next_param.span().shrink_to_lo(),
+                        format!("const {}: {}, ", target_ident, full_type),
+                    )
+                }
+                None => match impl_.generics.params.last() {
+                    Some(last) => {
+                        // Append after last existing param
+                        // e.g impl<A, B> -> impl<A, B, const C: u8>
+                        (
+                            last.span().shrink_to_hi(),
+                            format!(", const {}: {}", target_ident, full_type),
+                        )
+                    }
+                    None => {
+                        // No generics at all on impl
+                        // e.g impl Foo for C<A> -> impl<const A: u8> Foo for C<A>
+                        (
+                            impl_.generics.span.shrink_to_hi(),
+                            format!("<const {}: {}>", target_ident, full_type),
+                        )
+                    }
+                },
+            };
+
+            let mut err = self.r.dcx().struct_span_err(
+                target_ident.span,
+                format!("cannot find const `{}` in this scope", target_ident),
+            );
+
+            err.code(E0425);
+
+            err.span_label(target_ident.span, "not found in this scope");
+
+            err.span_label(
+                target_param.span(),
+                format!("corresponding const parameter on the type defined here",),
+            );
+
+            err.subdiagnostic(errors::UnexpectedMissingConstParameter {
+                span: insert_span,
+                snippet,
+                item_name: format!("{}", target_ident),
+                item_location: String::from("impl"),
+            });
+
+            return Some(err);
+        }
+
+        None
+    }
+
+    pub(crate) fn suggest_adding_generic_parameter(
+        &mut self,
+        path: &[Segment],
+        source: PathSource<'_, 'ast, 'ra>,
+    ) -> (Option<(Span, &'static str, String, Applicability)>, Option<Diag<'tcx>>) {
         let (ident, span) = match path {
             [segment]
                 if !segment.has_generic_args
@@ -3290,13 +3483,13 @@ pub(crate) fn suggest_adding_generic_parameter(
             {
                 (segment.ident.to_string(), segment.ident.span)
             }
-            _ => return None,
+            _ => return (None, None),
         };
         let mut iter = ident.chars().map(|c| c.is_uppercase());
         let single_uppercase_char =
             matches!(iter.next(), Some(true)) && matches!(iter.next(), None);
         if !self.diag_metadata.currently_processing_generic_args && !single_uppercase_char {
-            return None;
+            return (None, None);
         }
         match (self.diag_metadata.current_item, single_uppercase_char, self.diag_metadata.currently_processing_generic_args) {
             (Some(Item { kind: ItemKind::Fn(fn_), .. }), _, _) if fn_.ident.name == sym::main => {
@@ -3326,18 +3519,21 @@ pub(crate) fn suggest_adding_generic_parameter(
                         //   |           ^- help: you might be missing a type parameter: `, A`
                         //   |           |
                         //   |           not found in this scope
-                        return None;
+                        return (None, None);
                     }
 
                     let (msg, sugg) = match source {
                         PathSource::Type | PathSource::PreciseCapturingArg(TypeNS) => {
+                            if let Some(err) = self.detect_and_suggest_const_parameter_error(path, source) {
+                                return (None, Some(err));
+                            }
                             ("you might be missing a type parameter", ident)
                         }
                         PathSource::Expr(_) | PathSource::PreciseCapturingArg(ValueNS) => (
                             "you might be missing a const parameter",
                             format!("const {ident}: /* Type */"),
                         ),
-                        _ => return None,
+                        _ => return (None, None),
                     };
                     let (span, sugg) = if let [.., param] = &generics.params[..] {
                         let span = if let [.., bound] = &param.bounds[..] {
@@ -3355,18 +3551,18 @@ pub(crate) fn suggest_adding_generic_parameter(
                     };
                     // Do not suggest if this is coming from macro expansion.
                     if span.can_be_used_for_suggestions() {
-                        return Some((
+                        return (Some((
                             span.shrink_to_hi(),
                             msg,
                             sugg,
                             Applicability::MaybeIncorrect,
-                        ));
+                        )), None);
                     }
                 }
             }
             _ => {}
         }
-        None
+        (None, None)
     }
 
     /// Given the target `label`, search the `rib_index`th label rib for similarly named labels,
@@ -4349,3 +4545,44 @@ pub(super) fn signal_label_shadowing(sess: &Session, orig: Span, shadower: Ident
         .with_span_label(shadower, format!("label `{name}` already in scope"))
         .emit();
 }
+
+struct ParentPathVisitor<'a> {
+    target: Ident,
+    parent: Option<&'a PathSegment>,
+    stack: Vec<&'a Ty>,
+}
+
+impl<'a> ParentPathVisitor<'a> {
+    fn new(self_ty: &'a Ty, target: Ident) -> Self {
+        let mut v = ParentPathVisitor { target, parent: None, stack: Vec::new() };
+
+        v.visit_ty(self_ty);
+        v
+    }
+}
+
+impl<'a> Visitor<'a> for ParentPathVisitor<'a> {
+    fn visit_ty(&mut self, ty: &'a Ty) {
+        if self.parent.is_some() {
+            return;
+        }
+
+        // push current type
+        self.stack.push(ty);
+
+        if let TyKind::Path(_, path) = &ty.kind
+            // is this just `N`?
+            && let [segment] = path.segments.as_slice()
+            && segment.ident == self.target
+            // parent is previous element in stack
+            && let [.., parent_ty, _ty] = self.stack.as_slice()
+            && let TyKind::Path(_, parent_path) = &parent_ty.kind
+        {
+            self.parent = parent_path.segments.first();
+        }
+
+        walk_ty(self, ty);
+
+        self.stack.pop();
+    }
+}
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 7c942191d467..249ff1dfa4ec 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -40,7 +40,7 @@
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::{
     self as ast, AngleBracketedArg, CRATE_NODE_ID, Crate, Expr, ExprKind, GenericArg, GenericArgs,
-    NodeId, Path, attr,
+    Generics, NodeId, Path, attr,
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet, default};
 use rustc_data_structures::intern::Interned;
@@ -1317,6 +1317,10 @@ pub struct Resolver<'ra, 'tcx> {
     /// Also includes of list of each fields visibility
     struct_constructors: LocalDefIdMap<(Res, Visibility<DefId>, Vec<Visibility<DefId>>)> = Default::default(),
 
+    /// for all the struct
+    /// it's not used during normal resolution, only for better error reporting.
+    struct_generics: LocalDefIdMap<Generics> = Default::default(),
+
     lint_buffer: LintBuffer,
 
     next_node_id: NodeId = CRATE_NODE_ID,
diff --git a/tests/ui/const-generics/const-generic-function.rs b/tests/ui/const-generics/const-generic-function.rs
index c8d2683e53f4..03c94d90d105 100644
--- a/tests/ui/const-generics/const-generic-function.rs
+++ b/tests/ui/const-generics/const-generic-function.rs
@@ -14,7 +14,7 @@ const fn baz() -> i32 {
 
 fn main() {
     foo::<baz()>(); //~ ERROR expected type, found function `baz`
-    //~| ERROR unresolved item provided when a constant was expected
+    //~^ ERROR unresolved item provided when a constant was expected
     foo::<bar(bar(1, 1), bar(1, 1))>(); //~ ERROR expected type, found `1`
     foo::<bar(1, 1)>(); //~ ERROR expected type, found `1`
     foo::<bar(FOO, 2)>(); //~ ERROR expected type, found `2`
diff --git a/tests/ui/const-generics/early/invalid-const-arguments.rs b/tests/ui/const-generics/early/invalid-const-arguments.rs
index 68e6b2ac458e..82cc948129a6 100644
--- a/tests/ui/const-generics/early/invalid-const-arguments.rs
+++ b/tests/ui/const-generics/early/invalid-const-arguments.rs
@@ -1,10 +1,10 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 
 struct A<const N: u8>;
 trait Foo {}
 impl Foo for A<N> {}
-//~^ ERROR cannot find type
-//~| ERROR unresolved item provided when a constant
+//~^ ERROR cannot find const `N` in this scope
+//~| ERROR unresolved item provided when a constant was expected
 
 struct B<const N: u8>;
 impl<N> Foo for B<N> {}
@@ -12,5 +12,16 @@ impl<N> Foo for B<N> {}
 
 struct C<const C: u8, const N: u8>;
 impl<const N: u8> Foo for C<N, T> {}
-//~^ ERROR cannot find type
-//~| ERROR unresolved item provided when a constant
+//~^ ERROR cannot find const `T` in this scope
+//~| ERROR unresolved item provided when a constant was expected
+
+struct D<const E: u8, const X: u8, const P: u32>;
+impl Foo for D<E, X, P> {}
+//~^ ERROR cannot find const `E` in this scope
+//~| ERROR unresolved item provided when a constant was expected
+//~| ERROR cannot find const `X` in this scope
+//~| ERROR cannot find const `P` in this scope
+struct R<const O: u8, const G: u8, const F: u32>;
+impl<const F: u8, const H: u32> Foo for D<F, Q, D> {}
+//~^ ERROR cannot find const `Q` in this scope
+//~| ERROR unresolved item provided when a constant was expected
diff --git a/tests/ui/const-generics/early/invalid-const-arguments.stderr b/tests/ui/const-generics/early/invalid-const-arguments.stderr
index a0a6d8cc8679..4d8ab68fd71d 100644
--- a/tests/ui/const-generics/early/invalid-const-arguments.stderr
+++ b/tests/ui/const-generics/early/invalid-const-arguments.stderr
@@ -1,40 +1,82 @@
-error[E0425]: cannot find type `N` in this scope
+error[E0425]: cannot find const `N` in this scope
   --> $DIR/invalid-const-arguments.rs:5:16
    |
 LL | struct A<const N: u8>;
-   | ---------------------- similarly named struct `A` defined here
+   |          ----------- corresponding const parameter on the type defined here
 LL | trait Foo {}
 LL | impl Foo for A<N> {}
-   |                ^
+   |                ^ not found in this scope
    |
-help: a struct with a similar name exists
+help: you might have meant to introduce a const parameter `N` on the impl
    |
-LL - impl Foo for A<N> {}
-LL + impl Foo for A<A> {}
-   |
-help: you might be missing a type parameter
-   |
-LL | impl<N> Foo for A<N> {}
-   |     +++
+LL | impl<const N: u8> Foo for A<N> {}
+   |     +++++++++++++
 
-error[E0425]: cannot find type `T` in this scope
+error[E0425]: cannot find const `T` in this scope
   --> $DIR/invalid-const-arguments.rs:14:32
    |
-LL | struct A<const N: u8>;
-   | ---------------------- similarly named struct `A` defined here
-...
+LL | struct C<const C: u8, const N: u8>;
+   |                       ----------- corresponding const parameter on the type defined here
 LL | impl<const N: u8> Foo for C<N, T> {}
-   |                                ^
+   |                                ^ not found in this scope
    |
-help: a struct with a similar name exists
+help: you might have meant to introduce a const parameter `T` on the impl
    |
-LL - impl<const N: u8> Foo for C<N, T> {}
-LL + impl<const N: u8> Foo for C<N, A> {}
+LL | impl<const N: u8, const T: u8> Foo for C<N, T> {}
+   |                 +++++++++++++
+
+error[E0425]: cannot find const `E` in this scope
+  --> $DIR/invalid-const-arguments.rs:19:16
    |
-help: you might be missing a type parameter
+LL | struct D<const E: u8, const X: u8, const P: u32>;
+   |          ----------- corresponding const parameter on the type defined here
+LL | impl Foo for D<E, X, P> {}
+   |                ^ not found in this scope
    |
-LL | impl<const N: u8, T> Foo for C<N, T> {}
-   |                 +++
+help: you might have meant to introduce a const parameter `E` on the impl
+   |
+LL | impl<const E: u8> Foo for D<E, X, P> {}
+   |     +++++++++++++
+
+error[E0425]: cannot find const `X` in this scope
+  --> $DIR/invalid-const-arguments.rs:19:19
+   |
+LL | struct D<const E: u8, const X: u8, const P: u32>;
+   |                       ----------- corresponding const parameter on the type defined here
+LL | impl Foo for D<E, X, P> {}
+   |                   ^ not found in this scope
+   |
+help: you might have meant to introduce a const parameter `X` on the impl
+   |
+LL | impl<const X: u8> Foo for D<E, X, P> {}
+   |     +++++++++++++
+
+error[E0425]: cannot find const `P` in this scope
+  --> $DIR/invalid-const-arguments.rs:19:22
+   |
+LL | struct D<const E: u8, const X: u8, const P: u32>;
+   |                                    ------------ corresponding const parameter on the type defined here
+LL | impl Foo for D<E, X, P> {}
+   |                      ^ not found in this scope
+   |
+help: you might have meant to introduce a const parameter `P` on the impl
+   |
+LL | impl<const P: u32> Foo for D<E, X, P> {}
+   |     ++++++++++++++
+
+error[E0425]: cannot find const `Q` in this scope
+  --> $DIR/invalid-const-arguments.rs:25:46
+   |
+LL | struct D<const E: u8, const X: u8, const P: u32>;
+   |                       ----------- corresponding const parameter on the type defined here
+...
+LL | impl<const F: u8, const H: u32> Foo for D<F, Q, D> {}
+   |                                              ^ not found in this scope
+   |
+help: you might have meant to introduce a const parameter `Q` on the impl
+   |
+LL | impl<const F: u8, const H: u32, const Q: u8> Foo for D<F, Q, D> {}
+   |                               +++++++++++++
 
 error[E0747]: unresolved item provided when a constant was expected
   --> $DIR/invalid-const-arguments.rs:5:16
@@ -70,7 +112,29 @@ help: if this generic argument was intended as a const parameter, surround it wi
 LL | impl<const N: u8> Foo for C<N, { T }> {}
    |                                +   +
 
-error: aborting due to 5 previous errors
+error[E0747]: unresolved item provided when a constant was expected
+  --> $DIR/invalid-const-arguments.rs:19:16
+   |
+LL | impl Foo for D<E, X, P> {}
+   |                ^
+   |
+help: if this generic argument was intended as a const parameter, surround it with braces
+   |
+LL | impl Foo for D<{ E }, X, P> {}
+   |                +   +
+
+error[E0747]: unresolved item provided when a constant was expected
+  --> $DIR/invalid-const-arguments.rs:25:46
+   |
+LL | impl<const F: u8, const H: u32> Foo for D<F, Q, D> {}
+   |                                              ^
+   |
+help: if this generic argument was intended as a const parameter, surround it with braces
+   |
+LL | impl<const F: u8, const H: u32> Foo for D<F, { Q }, D> {}
+   |                                              +   +
+
+error: aborting due to 11 previous errors
 
 Some errors have detailed explanations: E0425, E0747.
 For more information about an error, try `rustc --explain E0425`.
diff --git a/tests/ui/const-generics/invalid-enum.rs b/tests/ui/const-generics/invalid-enum.rs
index 56fac3e2eb6c..09d06e0df78d 100644
--- a/tests/ui/const-generics/invalid-enum.rs
+++ b/tests/ui/const-generics/invalid-enum.rs
@@ -12,27 +12,27 @@ enum CompileFlag {
 
 pub fn test_1<const CF: CompileFlag>() {}
 pub fn test_2<T, const CF: CompileFlag>(x: T) {}
-pub struct Example<const CF: CompileFlag, T=u32>{
+pub struct Example<const CF: CompileFlag, T = u32> {
     x: T,
 }
 
 impl<const CF: CompileFlag, T> Example<CF, T> {
-  const ASSOC_FLAG: CompileFlag = CompileFlag::A;
+    const ASSOC_FLAG: CompileFlag = CompileFlag::A;
 }
 
 pub fn main() {
-  test_1::<CompileFlag::A>();
-  //~^ ERROR: expected type, found variant
-  //~| ERROR: unresolved item provided when a constant was expected
+    test_1::<CompileFlag::A>();
+    //~^ ERROR: expected type, found variant
+    //~| ERROR: unresolved item provided when a constant was expected
 
-  test_2::<_, CompileFlag::A>(0);
-  //~^ ERROR: expected type, found variant
-  //~| ERROR: unresolved item provided when a constant was expected
+    test_2::<_, CompileFlag::A>(0);
+    //~^ ERROR: expected type, found variant
+    //~| ERROR: unresolved item provided when a constant was expected
 
-  let _: Example<CompileFlag::A, _> = Example { x: 0 };
-  //~^ ERROR: expected type, found variant
-  //~| ERROR: unresolved item provided when a constant was expected
+    let _: Example<CompileFlag::A, _> = Example { x: 0 };
+    //~^ ERROR: expected type, found variant
+    //~| ERROR: unresolved item provided when a constant was expected
 
-  let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
-  //~^ ERROR: type provided when a constant was expected
+    let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
+    //~^ ERROR: type provided when a constant was expected
 }
diff --git a/tests/ui/const-generics/invalid-enum.stderr b/tests/ui/const-generics/invalid-enum.stderr
index 911052370f43..a557927cb490 100644
--- a/tests/ui/const-generics/invalid-enum.stderr
+++ b/tests/ui/const-generics/invalid-enum.stderr
@@ -1,73 +1,73 @@
 error[E0573]: expected type, found variant `CompileFlag::A`
-  --> $DIR/invalid-enum.rs:24:12
+  --> $DIR/invalid-enum.rs:24:14
    |
-LL |   test_1::<CompileFlag::A>();
-   |            ^^^^^^^^^^^^^^
-   |            |
-   |            not a type
-   |            help: try using the variant's enum: `CompileFlag`
+LL |     test_1::<CompileFlag::A>();
+   |              ^^^^^^^^^^^^^^
+   |              |
+   |              not a type
+   |              help: try using the variant's enum: `CompileFlag`
 
 error[E0573]: expected type, found variant `CompileFlag::A`
-  --> $DIR/invalid-enum.rs:28:15
+  --> $DIR/invalid-enum.rs:28:17
    |
-LL |   test_2::<_, CompileFlag::A>(0);
-   |               ^^^^^^^^^^^^^^
-   |               |
-   |               not a type
-   |               help: try using the variant's enum: `CompileFlag`
+LL |     test_2::<_, CompileFlag::A>(0);
+   |                 ^^^^^^^^^^^^^^
+   |                 |
+   |                 not a type
+   |                 help: try using the variant's enum: `CompileFlag`
 
 error[E0573]: expected type, found variant `CompileFlag::A`
-  --> $DIR/invalid-enum.rs:32:18
+  --> $DIR/invalid-enum.rs:32:20
    |
-LL |   let _: Example<CompileFlag::A, _> = Example { x: 0 };
-   |                  ^^^^^^^^^^^^^^
-   |                  |
-   |                  not a type
-   |                  help: try using the variant's enum: `CompileFlag`
+LL |     let _: Example<CompileFlag::A, _> = Example { x: 0 };
+   |                    ^^^^^^^^^^^^^^
+   |                    |
+   |                    not a type
+   |                    help: try using the variant's enum: `CompileFlag`
 
 error[E0747]: unresolved item provided when a constant was expected
-  --> $DIR/invalid-enum.rs:24:12
+  --> $DIR/invalid-enum.rs:24:14
    |
-LL |   test_1::<CompileFlag::A>();
-   |            ^^^^^^^^^^^^^^
+LL |     test_1::<CompileFlag::A>();
+   |              ^^^^^^^^^^^^^^
    |
 help: if this generic argument was intended as a const parameter, surround it with braces
    |
-LL |   test_1::<{ CompileFlag::A }>();
-   |            +                +
+LL |     test_1::<{ CompileFlag::A }>();
+   |              +                +
 
 error[E0747]: unresolved item provided when a constant was expected
-  --> $DIR/invalid-enum.rs:28:15
+  --> $DIR/invalid-enum.rs:28:17
    |
-LL |   test_2::<_, CompileFlag::A>(0);
-   |               ^^^^^^^^^^^^^^
+LL |     test_2::<_, CompileFlag::A>(0);
+   |                 ^^^^^^^^^^^^^^
    |
 help: if this generic argument was intended as a const parameter, surround it with braces
    |
-LL |   test_2::<_, { CompileFlag::A }>(0);
-   |               +                +
+LL |     test_2::<_, { CompileFlag::A }>(0);
+   |                 +                +
 
 error[E0747]: unresolved item provided when a constant was expected
-  --> $DIR/invalid-enum.rs:32:18
+  --> $DIR/invalid-enum.rs:32:20
    |
-LL |   let _: Example<CompileFlag::A, _> = Example { x: 0 };
-   |                  ^^^^^^^^^^^^^^
+LL |     let _: Example<CompileFlag::A, _> = Example { x: 0 };
+   |                    ^^^^^^^^^^^^^^
    |
 help: if this generic argument was intended as a const parameter, surround it with braces
    |
-LL |   let _: Example<{ CompileFlag::A }, _> = Example { x: 0 };
-   |                  +                +
+LL |     let _: Example<{ CompileFlag::A }, _> = Example { x: 0 };
+   |                    +                +
 
 error[E0747]: type provided when a constant was expected
-  --> $DIR/invalid-enum.rs:36:18
+  --> $DIR/invalid-enum.rs:36:20
    |
-LL |   let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
-   |                  ^^^^^^^^^^^^^^^^^^^
+LL |     let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
+   |                    ^^^^^^^^^^^^^^^^^^^
    |
 help: if this generic argument was intended as a const parameter, surround it with braces
    |
-LL |   let _: Example<{ Example::ASSOC_FLAG }, _> = Example { x: 0 };
-   |                  +                     +
+LL |     let _: Example<{ Example::ASSOC_FLAG }, _> = Example { x: 0 };
+   |                    +                     +
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/missing/missing-items/missing-type-parameter2.rs b/tests/ui/missing/missing-items/missing-type-parameter2.rs
index 772e60b1376c..c52f3157454a 100644
--- a/tests/ui/missing/missing-items/missing-type-parameter2.rs
+++ b/tests/ui/missing/missing-items/missing-type-parameter2.rs
@@ -1,10 +1,10 @@
 struct X<const N: u8>();
 
 impl X<N> {}
-//~^ ERROR cannot find type `N` in this scope
+//~^ ERROR cannot find const `N` in this scope
 //~| ERROR unresolved item provided when a constant was expected
 impl<T, const A: u8 = 2> X<N> {}
-//~^ ERROR cannot find type `N` in this scope
+//~^ ERROR cannot find const `N` in this scope
 //~| ERROR defaults for generic parameters are not allowed here
 //~| ERROR unresolved item provided when a constant was expected
 
@@ -15,5 +15,4 @@ fn foo(_: T) where T: Send {}
 fn bar<const N: u8>(_: A) {}
 //~^ ERROR cannot find type `A` in this scope
 
-fn main() {
-}
+fn main() {}
diff --git a/tests/ui/missing/missing-items/missing-type-parameter2.stderr b/tests/ui/missing/missing-items/missing-type-parameter2.stderr
index c361ed79cc79..7c85d39ba78a 100644
--- a/tests/ui/missing/missing-items/missing-type-parameter2.stderr
+++ b/tests/ui/missing/missing-items/missing-type-parameter2.stderr
@@ -1,39 +1,30 @@
-error[E0425]: cannot find type `N` in this scope
+error[E0425]: cannot find const `N` in this scope
   --> $DIR/missing-type-parameter2.rs:3:8
    |
 LL | struct X<const N: u8>();
-   | ------------------------ similarly named struct `X` defined here
+   |          ----------- corresponding const parameter on the type defined here
 LL |
 LL | impl X<N> {}
-   |        ^
+   |        ^ not found in this scope
    |
-help: a struct with a similar name exists
+help: you might have meant to introduce a const parameter `N` on the impl
    |
-LL - impl X<N> {}
-LL + impl X<X> {}
-   |
-help: you might be missing a type parameter
-   |
-LL | impl<N> X<N> {}
-   |     +++
+LL | impl<const N: u8> X<N> {}
+   |     +++++++++++++
 
-error[E0425]: cannot find type `N` in this scope
+error[E0425]: cannot find const `N` in this scope
   --> $DIR/missing-type-parameter2.rs:6:28
    |
+LL | struct X<const N: u8>();
+   |          ----------- corresponding const parameter on the type defined here
+...
 LL | impl<T, const A: u8 = 2> X<N> {}
-   |      -                     ^
-   |      |
-   |      similarly named type parameter `T` defined here
+   |                            ^ not found in this scope
    |
-help: a type parameter with a similar name exists
+help: you might have meant to introduce a const parameter `N` on the impl
    |
-LL - impl<T, const A: u8 = 2> X<N> {}
-LL + impl<T, const A: u8 = 2> X<T> {}
-   |
-help: you might be missing a type parameter
-   |
-LL | impl<T, const A: u8 = 2, N> X<N> {}
-   |                        +++
+LL | impl<T, const A: u8 = 2, const N: u8> X<N> {}
+   |                        +++++++++++++
 
 error[E0425]: cannot find type `T` in this scope
   --> $DIR/missing-type-parameter2.rs:11:20

From b0d4f7a9ae8d8e0c43717c2fc376b27e1adab7d0 Mon Sep 17 00:00:00 2001
From: kawkoi <haruubusinesss@gmail.com>
Date: Wed, 18 Mar 2026 22:42:24 +0530
Subject: [PATCH 0643/1059] Migrate convert_from_to_tryfrom assist to
 SyntaxEditor API

Replace mutable syntax tree editing (clone_for_update + make::) with
the SyntaxFactory API, which is the preferred approach for avoiding
mutable tree operations.

Changes:
- Use SyntaxFactory::with_mappings() instead of bare make:: constructors
- Replace make::ty() + .clone_for_update() with make.ty()
- Replace make::name() + .clone_for_update() with make.name()
- Replace make::ty_alias() + .clone_for_update() with make.ty_alias()
- Update wrap_ok() helper to accept &SyntaxFactory and use make.expr_call/arg_list/expr_path
- Add editor.add_mappings(make.finish_with_mappings()) to register mappings
---
 .../src/handlers/convert_from_to_tryfrom.rs   | 48 +++++++------------
 1 file changed, 17 insertions(+), 31 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
index 6a74d214512f..66ccd2a4e409 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
@@ -1,6 +1,6 @@
 use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait};
 use syntax::ast::edit::IndentLevel;
-use syntax::ast::{self, AstNode, HasGenericArgs, HasName, make};
+use syntax::ast::{self, AstNode, HasGenericArgs, HasName, syntax_factory::SyntaxFactory};
 use syntax::syntax_editor::{Element, Position};
 
 use crate::{AssistContext, AssistId, Assists};
@@ -74,36 +74,25 @@ pub(crate) fn convert_from_to_tryfrom(acc: &mut Assists, ctx: &AssistContext<'_>
         "Convert From to TryFrom",
         impl_.syntax().text_range(),
         |builder| {
+            let make = SyntaxFactory::with_mappings();
             let mut editor = builder.make_editor(impl_.syntax());
-            editor.replace(
-                trait_ty.syntax(),
-                make::ty(&format!("TryFrom<{from_type}>")).syntax().clone_for_update(),
-            );
+
+            editor.replace(trait_ty.syntax(), make.ty(&format!("TryFrom<{from_type}>")).syntax());
             editor.replace(
                 from_fn_return_type.syntax(),
-                make::ty("Result<Self, Self::Error>").syntax().clone_for_update(),
-            );
-            editor
-                .replace(from_fn_name.syntax(), make::name("try_from").syntax().clone_for_update());
-            editor.replace(
-                tail_expr.syntax(),
-                wrap_ok(tail_expr.clone()).syntax().clone_for_update(),
+                make.ty("Result<Self, Self::Error>").syntax(),
             );
+            editor.replace(from_fn_name.syntax(), make.name("try_from").syntax());
+            editor.replace(tail_expr.syntax(), wrap_ok(&make, tail_expr.clone()).syntax());
 
             for r in return_exprs {
-                let t = r.expr().unwrap_or_else(make::ext::expr_unit);
-                editor.replace(t.syntax(), wrap_ok(t.clone()).syntax().clone_for_update());
+                let t = r.expr().unwrap_or_else(|| make.expr_unit());
+                editor.replace(t.syntax(), wrap_ok(&make, t.clone()).syntax());
             }
 
-            let error_type = ast::AssocItem::TypeAlias(make::ty_alias(
-                None,
-                "Error",
-                None,
-                None,
-                None,
-                Some((make::ty_unit(), None)),
-            ))
-            .clone_for_update();
+            let error_type_alias =
+                make.ty_alias(None, "Error", None, None, None, Some((make.ty("()"), None)));
+            let error_type = ast::AssocItem::TypeAlias(error_type_alias);
 
             if let Some(cap) = ctx.config.snippet_cap
                 && let ast::AssocItem::TypeAlias(type_alias) = &error_type
@@ -117,22 +106,19 @@ pub(crate) fn convert_from_to_tryfrom(acc: &mut Assists, ctx: &AssistContext<'_>
             editor.insert_all(
                 Position::after(associated_l_curly),
                 vec![
-                    make::tokens::whitespace(&format!("\n{indent}")).syntax_element(),
+                    make.whitespace(&format!("\n{indent}")).syntax_element(),
                     error_type.syntax().syntax_element(),
-                    make::tokens::whitespace("\n").syntax_element(),
+                    make.whitespace("\n").syntax_element(),
                 ],
             );
+            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
 
-fn wrap_ok(expr: ast::Expr) -> ast::Expr {
-    make::expr_call(
-        make::expr_path(make::ext::ident_path("Ok")),
-        make::arg_list(std::iter::once(expr)),
-    )
-    .into()
+fn wrap_ok(make: &SyntaxFactory, expr: ast::Expr) -> ast::Expr {
+    make.expr_call(make.expr_path(make.path_from_text("Ok")), make.arg_list([expr])).into()
 }
 
 #[cfg(test)]

From a3e469ea1f03936e2156b7d683aa7fc83d56a252 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 19 Mar 2026 07:48:27 +0100
Subject: [PATCH 0644/1059] fix some outdated comments in tests

---
 .../miri/tests/fail/stacked_borrows/transmute-is-no-escape.rs   | 2 +-
 src/tools/miri/tests/pass/packed-struct-dyn-trait.rs            | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.rs b/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.rs
index 233b927dfc7e..03b716cda500 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.rs
+++ b/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.rs
@@ -2,7 +2,7 @@
 // (i.e, no EscapeToRaw happened).
 // We could, in principle, do EscapeToRaw lazily to allow this code, but that
 // would no alleviate the need for EscapeToRaw (see `ref_raw_int_raw` in
-// `run-pass/stacked-borrows.rs`), and thus increase overall complexity.
+// `pass/both_borrows/int-to-ptr.rs`), and thus increase overall complexity.
 use std::mem;
 
 fn main() {
diff --git a/src/tools/miri/tests/pass/packed-struct-dyn-trait.rs b/src/tools/miri/tests/pass/packed-struct-dyn-trait.rs
index bb73c26c18a0..2e61e77a221e 100644
--- a/src/tools/miri/tests/pass/packed-struct-dyn-trait.rs
+++ b/src/tools/miri/tests/pass/packed-struct-dyn-trait.rs
@@ -1,4 +1,3 @@
-// run-pass
 use std::ptr::addr_of;
 
 // When the unsized tail is a `dyn Trait`, its alignments is only dynamically known. This means the

From b2e8177455cad2c001a58d43a4dec6d896cea0ad Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 15:59:16 +1100
Subject: [PATCH 0645/1059] Reorder `define_callbacks`.

This is nitpicky, but the lack of a sensible order has been bugging me.

- Within `mod $name`, put all the typedefs together.
- After that:
  - First, types definitions and their impls.
  - Then the `TyCtxt*` impls, in a sensible order.
    - Likewise, put `TyCtxt::at` before the similar methods.
- Also reflow some overly long lines.
---
 compiler/rustc_middle/src/query/plumbing.rs | 258 ++++++++++----------
 1 file changed, 133 insertions(+), 125 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index d4e7bb52be97..f4e1ead7c585 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -201,6 +201,13 @@ pub struct TyCtxtEnsureDone<'tcx> {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
+    /// Returns a transparent wrapper for `TyCtxt` which uses
+    /// `span` as the location of queries performed through it.
+    #[inline(always)]
+    pub fn at(self, span: Span) -> TyCtxtAt<'tcx> {
+        TyCtxtAt { tcx: self, span }
+    }
+
     /// FIXME: `ensure_ok`'s effects are subtle. Is this comment fully accurate?
     ///
     /// Wrapper that calls queries in a special "ensure OK" mode, for callers
@@ -258,13 +265,6 @@ pub fn ensure_result(self) -> TyCtxtEnsureResult<'tcx> {
     pub fn ensure_done(self) -> TyCtxtEnsureDone<'tcx> {
         TyCtxtEnsureDone { tcx: self }
     }
-
-    /// Returns a transparent wrapper for `TyCtxt` which uses
-    /// `span` as the location of queries performed through it.
-    #[inline(always)]
-    pub fn at(self, span: Span) -> TyCtxtAt<'tcx> {
-        TyCtxtAt { tcx: self, span }
-    }
 }
 
 macro_rules! query_helper_param_ty {
@@ -323,6 +323,9 @@ pub mod $name {
                 #[cfg(not($arena_cache))]
                 pub type ProvidedValue<'tcx> = Value<'tcx>;
 
+                pub type Cache<'tcx> =
+                    <Key<'tcx> as $crate::query::QueryKey>::Cache<Erased<Value<'tcx>>>;
+
                 /// This helper function takes a value returned by the query provider
                 /// (or loaded from disk, or supplied by query feeding), allocates
                 /// it in an arena if requested by the `arena_cache` modifier, and
@@ -354,9 +357,6 @@ pub fn provided_to_erased<'tcx>(
                     erase::erase_val(value)
                 }
 
-                pub type Cache<'tcx> =
-                    <Key<'tcx> as $crate::query::QueryKey>::Cache<Erased<Value<'tcx>>>;
-
                 // Ensure that keys grow no larger than 88 bytes by accident.
                 // Increase this limit if necessary, but do try to keep the size low if possible
                 #[cfg(target_pointer_width = "64")]
@@ -390,116 +390,8 @@ pub fn provided_to_erased<'tcx>(
             }
         )*
 
-        /// Holds per-query arenas for queries with the `arena_cache` modifier.
-        #[derive(Default)]
-        pub struct QueryArenas<'tcx> {
-            $(
-                // Use the `ArenaCached` helper trait to determine the arena's value type.
-                #[cfg($arena_cache)]
-                pub $name: TypedArena<
-                    <$V as $crate::query::arena_cached::ArenaCached<'tcx>>::Allocated,
-                >,
-            )*
-        }
-
-        impl<'tcx> $crate::query::TyCtxtEnsureOk<'tcx> {
-            $(
-                $(#[$attr])*
-                #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
-                    crate::query::inner::query_ensure_ok_or_done(
-                        self.tcx,
-                        &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryKey::into_query_key(key),
-                        $crate::query::EnsureMode::Ok,
-                    )
-                }
-            )*
-        }
-
-        // Only defined when the `ensure_result` modifier is present.
-        impl<'tcx> $crate::query::TyCtxtEnsureResult<'tcx> {
-            $(
-                #[cfg($returns_error_guaranteed)]
-                $(#[$attr])*
-                #[inline(always)]
-                pub fn $name(
-                    self,
-                    key: query_helper_param_ty!($($K)*),
-                ) -> Result<(), rustc_errors::ErrorGuaranteed> {
-                    crate::query::inner::query_ensure_result(
-                        self.tcx,
-                        &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryKey::into_query_key(key),
-                    )
-                }
-            )*
-        }
-
-        impl<'tcx> $crate::query::TyCtxtEnsureDone<'tcx> {
-            $(
-                $(#[$attr])*
-                #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
-                    crate::query::inner::query_ensure_ok_or_done(
-                        self.tcx,
-                        &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryKey::into_query_key(key),
-                        $crate::query::EnsureMode::Done,
-                    );
-                }
-            )*
-        }
-
-        impl<'tcx> TyCtxt<'tcx> {
-            $(
-                $(#[$attr])*
-                #[inline(always)]
-                #[must_use]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
-                    self.at(DUMMY_SP).$name(key)
-                }
-            )*
-        }
-
-        impl<'tcx> $crate::query::TyCtxtAt<'tcx> {
-            $(
-                $(#[$attr])*
-                #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
-                    use $crate::query::{erase, inner};
-
-                    erase::restore_val::<$V>(inner::query_get_at(
-                        self.tcx,
-                        self.span,
-                        &self.tcx.query_system.query_vtables.$name,
-                        $crate::query::IntoQueryKey::into_query_key(key),
-                    ))
-                }
-            )*
-        }
-
-        $(
-            #[cfg($feedable)]
-            impl<'tcx, K: $crate::query::IntoQueryKey<$name::Key<'tcx>> + Copy>
-                TyCtxtFeed<'tcx, K>
-            {
-                $(#[$attr])*
-                #[inline(always)]
-                pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
-                    let key = self.key().into_query_key();
-                    let erased_value = $name::provided_to_erased(self.tcx, value);
-                    $crate::query::inner::query_feed(
-                        self.tcx,
-                        &self.tcx.query_system.query_vtables.$name,
-                        key,
-                        erased_value,
-                    );
-                }
-            }
-        )*
-
-        /// Identifies a query by kind and key. This is in contrast to `QueryJobId` which is just a number.
+        /// Identifies a query by kind and key. This is in contrast to `QueryJobId` which is just a
+        /// number.
         #[allow(non_camel_case_types)]
         #[derive(Clone, Copy, Debug)]
         pub enum TaggedQueryKey<'tcx> {
@@ -528,7 +420,8 @@ pub fn query_name(&self) -> &'static str {
             pub fn description(&self, tcx: TyCtxt<'tcx>) -> String {
                 let (name, description) = ty::print::with_no_queries!(match self {
                     $(
-                        TaggedQueryKey::$name(key) => (stringify!($name), _description_fns::$name(tcx, *key)),
+                        TaggedQueryKey::$name(key) =>
+                            (stringify!($name), _description_fns::$name(tcx, *key)),
                     )*
                 });
                 if tcx.sess.verbose_internals() {
@@ -550,7 +443,8 @@ pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
                 }
                 match self {
                     $(
-                        TaggedQueryKey::$name(key) => crate::query::QueryKey::default_span(key, tcx),
+                        TaggedQueryKey::$name(key) =>
+                            crate::query::QueryKey::default_span(key, tcx),
                     )*
                 }
             }
@@ -558,8 +452,13 @@ pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
             pub fn def_kind(&self, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
                 // This is used to reduce code generation as it
                 // can be reused for queries with the same key type.
-                fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
-                    key.key_as_def_id().and_then(|def_id| def_id.as_local()).map(|def_id| tcx.def_kind(def_id))
+                fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>)
+                    -> Option<DefKind>
+                {
+                    key
+                        .key_as_def_id()
+                        .and_then(|def_id| def_id.as_local())
+                        .map(|def_id| tcx.def_kind(def_id))
                 }
 
                 if let TaggedQueryKey::def_kind(..) = self {
@@ -577,7 +476,19 @@ fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>) -> Option<D
         /// Holds a `QueryVTable` for each query.
         pub struct QueryVTables<'tcx> {
             $(
-                pub $name: crate::query::QueryVTable<'tcx, $name::Cache<'tcx>>,
+                pub $name: $crate::query::QueryVTable<'tcx, $name::Cache<'tcx>>,
+            )*
+        }
+
+        /// Holds per-query arenas for queries with the `arena_cache` modifier.
+        #[derive(Default)]
+        pub struct QueryArenas<'tcx> {
+            $(
+                // Use the `ArenaCached` helper trait to determine the arena's value type.
+                #[cfg($arena_cache)]
+                pub $name: TypedArena<
+                    <$V as $crate::query::arena_cached::ArenaCached<'tcx>>::Allocated,
+                >,
             )*
         }
 
@@ -637,6 +548,103 @@ impl Copy for ExternProviders {}
         impl Clone for ExternProviders {
             fn clone(&self) -> Self { *self }
         }
+
+        impl<'tcx> TyCtxt<'tcx> {
+            $(
+                $(#[$attr])*
+                #[inline(always)]
+                #[must_use]
+                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
+                    self.at(DUMMY_SP).$name(key)
+                }
+            )*
+        }
+
+        impl<'tcx> $crate::query::TyCtxtAt<'tcx> {
+            $(
+                $(#[$attr])*
+                #[inline(always)]
+                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
+                    use $crate::query::{erase, inner};
+
+                    erase::restore_val::<$V>(inner::query_get_at(
+                        self.tcx,
+                        self.span,
+                        &self.tcx.query_system.query_vtables.$name,
+                        $crate::query::IntoQueryKey::into_query_key(key),
+                    ))
+                }
+            )*
+        }
+
+        impl<'tcx> $crate::query::TyCtxtEnsureOk<'tcx> {
+            $(
+                $(#[$attr])*
+                #[inline(always)]
+                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
+                    crate::query::inner::query_ensure_ok_or_done(
+                        self.tcx,
+                        &self.tcx.query_system.query_vtables.$name,
+                        $crate::query::IntoQueryKey::into_query_key(key),
+                        $crate::query::EnsureMode::Ok,
+                    )
+                }
+            )*
+        }
+
+        // Only defined when the `ensure_result` modifier is present.
+        impl<'tcx> $crate::query::TyCtxtEnsureResult<'tcx> {
+            $(
+                #[cfg($returns_error_guaranteed)]
+                $(#[$attr])*
+                #[inline(always)]
+                pub fn $name(
+                    self,
+                    key: query_helper_param_ty!($($K)*),
+                ) -> Result<(), rustc_errors::ErrorGuaranteed> {
+                    crate::query::inner::query_ensure_result(
+                        self.tcx,
+                        &self.tcx.query_system.query_vtables.$name,
+                        $crate::query::IntoQueryKey::into_query_key(key),
+                    )
+                }
+            )*
+        }
+
+        impl<'tcx> $crate::query::TyCtxtEnsureDone<'tcx> {
+            $(
+                $(#[$attr])*
+                #[inline(always)]
+                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
+                    crate::query::inner::query_ensure_ok_or_done(
+                        self.tcx,
+                        &self.tcx.query_system.query_vtables.$name,
+                        $crate::query::IntoQueryKey::into_query_key(key),
+                        $crate::query::EnsureMode::Done,
+                    );
+                }
+            )*
+        }
+
+        $(
+            #[cfg($feedable)]
+            impl<'tcx, K: $crate::query::IntoQueryKey<$name::Key<'tcx>> + Copy>
+                TyCtxtFeed<'tcx, K>
+            {
+                $(#[$attr])*
+                #[inline(always)]
+                pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
+                    let key = self.key().into_query_key();
+                    let erased_value = $name::provided_to_erased(self.tcx, value);
+                    $crate::query::inner::query_feed(
+                        self.tcx,
+                        &self.tcx.query_system.query_vtables.$name,
+                        key,
+                        erased_value,
+                    );
+                }
+            }
+        )*
     };
 }
 

From 091d000b93fefc229775bb2905ec63e35a8c1490 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 16:23:37 +1100
Subject: [PATCH 0646/1059] Minor `define_callbacks` tweaks.

- Use `$crate` more consistently.
- Add a couple of useful comments.
- Remove some unnecessary local variables.
---
 compiler/rustc_middle/src/query/plumbing.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index f4e1ead7c585..56a8f5e974ae 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -444,7 +444,7 @@ pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
                 match self {
                     $(
                         TaggedQueryKey::$name(key) =>
-                            crate::query::QueryKey::default_span(key, tcx),
+                            $crate::query::QueryKey::default_span(key, tcx),
                     )*
                 }
             }
@@ -452,7 +452,7 @@ pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
             pub fn def_kind(&self, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
                 // This is used to reduce code generation as it
                 // can be reused for queries with the same key type.
-                fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>)
+                fn inner<'tcx>(key: &impl $crate::query::QueryKey, tcx: TyCtxt<'tcx>)
                     -> Option<DefKind>
                 {
                     key
@@ -465,6 +465,7 @@ fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>)
                     // Try to avoid infinite recursion.
                     return None
                 }
+
                 match self {
                     $(
                         TaggedQueryKey::$name(key) => inner(key, tcx),
@@ -582,7 +583,7 @@ impl<'tcx> $crate::query::TyCtxtEnsureOk<'tcx> {
                 $(#[$attr])*
                 #[inline(always)]
                 pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
-                    crate::query::inner::query_ensure_ok_or_done(
+                    $crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
                         $crate::query::IntoQueryKey::into_query_key(key),
@@ -592,7 +593,7 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
             )*
         }
 
-        // Only defined when the `ensure_result` modifier is present.
+        // Only defined when the `returns_error_guaranteed` modifier is present.
         impl<'tcx> $crate::query::TyCtxtEnsureResult<'tcx> {
             $(
                 #[cfg($returns_error_guaranteed)]
@@ -602,7 +603,7 @@ pub fn $name(
                     self,
                     key: query_helper_param_ty!($($K)*),
                 ) -> Result<(), rustc_errors::ErrorGuaranteed> {
-                    crate::query::inner::query_ensure_result(
+                    $crate::query::inner::query_ensure_result(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
                         $crate::query::IntoQueryKey::into_query_key(key),
@@ -616,7 +617,7 @@ impl<'tcx> $crate::query::TyCtxtEnsureDone<'tcx> {
                 $(#[$attr])*
                 #[inline(always)]
                 pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
-                    crate::query::inner::query_ensure_ok_or_done(
+                    $crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
                         $crate::query::IntoQueryKey::into_query_key(key),
@@ -627,6 +628,7 @@ pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
         }
 
         $(
+            // Only defined when the `feedable` modifier is present.
             #[cfg($feedable)]
             impl<'tcx, K: $crate::query::IntoQueryKey<$name::Key<'tcx>> + Copy>
                 TyCtxtFeed<'tcx, K>
@@ -634,13 +636,11 @@ impl<'tcx, K: $crate::query::IntoQueryKey<$name::Key<'tcx>> + Copy>
                 $(#[$attr])*
                 #[inline(always)]
                 pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
-                    let key = self.key().into_query_key();
-                    let erased_value = $name::provided_to_erased(self.tcx, value);
                     $crate::query::inner::query_feed(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
-                        key,
-                        erased_value,
+                        self.key().into_query_key(),
+                        $name::provided_to_erased(self.tcx, value),
                     );
                 }
             }

From 7cec833020ed1a763a849ca1cd236412e0987e4f Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 16:54:06 +1100
Subject: [PATCH 0647/1059] Rename `query_helper_param_ty`.

As `maybe_into_query_key`. Partly to use `key` instead of `param`, and
also to make the link to the trait more obvious.
---
 compiler/rustc_middle/src/queries.rs        |  2 +-
 compiler/rustc_middle/src/query/plumbing.rs | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 4dd68db4f913..b07b22086594 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -101,7 +101,7 @@
     CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions, NormalizationErrorInMono,
 };
 use crate::query::describe_as_module;
-use crate::query::plumbing::{define_callbacks, query_helper_param_ty};
+use crate::query::plumbing::{define_callbacks, maybe_into_query_key};
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
     CanonicalMethodAutoderefStepsGoal, CanonicalPredicateGoal, CanonicalTypeOpAscribeUserTypeGoal,
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 56a8f5e974ae..4ef1b0adf581 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -267,7 +267,7 @@ pub fn ensure_done(self) -> TyCtxtEnsureDone<'tcx> {
     }
 }
 
-macro_rules! query_helper_param_ty {
+macro_rules! maybe_into_query_key {
     (DefId) => { impl $crate::query::IntoQueryKey<DefId> };
     (LocalDefId) => { impl $crate::query::IntoQueryKey<LocalDefId> };
     ($K:ty) => { $K };
@@ -276,7 +276,7 @@ macro_rules! query_helper_param_ty {
 macro_rules! define_callbacks {
     (
         // You might expect the key to be `$K:ty`, but it needs to be `$($K:tt)*` so that
-        // `query_helper_param_ty!` can match on specific type names.
+        // `maybe_into_query_key!` can match on specific type names.
         queries {
             $(
                 $(#[$attr:meta])*
@@ -555,7 +555,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 $(#[$attr])*
                 #[inline(always)]
                 #[must_use]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
+                pub fn $name(self, key: maybe_into_query_key!($($K)*)) -> $V {
                     self.at(DUMMY_SP).$name(key)
                 }
             )*
@@ -565,7 +565,7 @@ impl<'tcx> $crate::query::TyCtxtAt<'tcx> {
             $(
                 $(#[$attr])*
                 #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V {
+                pub fn $name(self, key: maybe_into_query_key!($($K)*)) -> $V {
                     use $crate::query::{erase, inner};
 
                     erase::restore_val::<$V>(inner::query_get_at(
@@ -582,7 +582,7 @@ impl<'tcx> $crate::query::TyCtxtEnsureOk<'tcx> {
             $(
                 $(#[$attr])*
                 #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
+                pub fn $name(self, key: maybe_into_query_key!($($K)*)) {
                     $crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
@@ -601,7 +601,7 @@ impl<'tcx> $crate::query::TyCtxtEnsureResult<'tcx> {
                 #[inline(always)]
                 pub fn $name(
                     self,
-                    key: query_helper_param_ty!($($K)*),
+                    key: maybe_into_query_key!($($K)*),
                 ) -> Result<(), rustc_errors::ErrorGuaranteed> {
                     $crate::query::inner::query_ensure_result(
                         self.tcx,
@@ -616,7 +616,7 @@ impl<'tcx> $crate::query::TyCtxtEnsureDone<'tcx> {
             $(
                 $(#[$attr])*
                 #[inline(always)]
-                pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
+                pub fn $name(self, key: maybe_into_query_key!($($K)*)) {
                     $crate::query::inner::query_ensure_ok_or_done(
                         self.tcx,
                         &self.tcx.query_system.query_vtables.$name,
@@ -650,7 +650,7 @@ pub fn $name(self, value: $name::ProvidedValue<'tcx>) {
 
 // Re-export `macro_rules!` macros as normal items, so that they can be imported normally.
 pub(crate) use define_callbacks;
-pub(crate) use query_helper_param_ty;
+pub(crate) use maybe_into_query_key;
 
 #[cold]
 pub(crate) fn default_query(name: &str, key: &dyn std::fmt::Debug) -> ! {

From bef4b476c17685077a7f2cf680743ab8bc2cd11b Mon Sep 17 00:00:00 2001
From: Ada Bohm <ada@kreatrix.org>
Date: Thu, 19 Mar 2026 09:22:03 +0100
Subject: [PATCH 0648/1059] Updates derive_where and removes workaround

---
 Cargo.lock                           |  4 ++--
 compiler/rustc_type_ir/Cargo.toml    |  2 +-
 compiler/rustc_type_ir/src/binder.rs | 20 +++-----------------
 3 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 98567f858e9f..539f66ffb3bb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1140,9 +1140,9 @@ version = "0.1.96"
 
 [[package]]
 name = "derive-where"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef941ded77d15ca19b40374869ac6000af1c9f2a4c0f3d4c70926287e6364a8f"
+checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index 10c53c881a36..b00f9eebb826 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2024"
 # tidy-alphabetical-start
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
-derive-where = "1.2.7"
+derive-where = "1.6.1"
 ena = "0.14.4"
 indexmap = "2.0.0"
 rustc-hash = "2.0.0"
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index fc8b39f7c01f..0b0f0fd2f424 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -26,11 +26,7 @@
 /// for more details.
 ///
 /// `Decodable` and `Encodable` are implemented for `Binder<T>` using the `impl_binder_encode_decode!` macro.
-// FIXME(derive-where#136): Need to use separate `derive_where` for
-// `Copy` and `Ord` to prevent the emitted `Clone` and `PartialOrd`
-// impls from incorrectly relying on `T: Copy` and `T: Ord`.
-#[derive_where(Copy; I: Interner, T: Copy)]
-#[derive_where(Clone, Hash, PartialEq, Debug; I: Interner, T)]
+#[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner, T)]
 #[derive(GenericTypeVisitable)]
 #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
 pub struct Binder<I: Interner, T> {
@@ -365,12 +361,7 @@ fn visit_region(&mut self, r: I::Region) -> Self::Result {
 /// `instantiate`.
 ///
 /// See <https://rustc-dev-guide.rust-lang.org/ty_module/early_binder.html> for more details.
-// FIXME(derive-where#136): Need to use separate `derive_where` for
-// `Copy` and `Ord` to prevent the emitted `Clone` and `PartialOrd`
-// impls from incorrectly relying on `T: Copy` and `T: Ord`.
-#[derive_where(Ord; I: Interner, T: Ord)]
-#[derive_where(Copy; I: Interner, T: Copy)]
-#[derive_where(Clone, PartialOrd, PartialEq, Hash, Debug; I: Interner, T)]
+#[derive_where(Clone, Copy, PartialOrd, Ord, PartialEq, Hash, Debug; I: Interner, T)]
 #[derive(GenericTypeVisitable)]
 #[cfg_attr(
     feature = "nightly",
@@ -964,12 +955,7 @@ pub enum BoundVarIndexKind {
 /// The "placeholder index" fully defines a placeholder region, type, or const. Placeholders are
 /// identified by both a universe, as well as a name residing within that universe. Distinct bound
 /// regions/types/consts within the same universe simply have an unknown relationship to one
-// FIXME(derive-where#136): Need to use separate `derive_where` for
-// `Copy` and `Ord` to prevent the emitted `Clone` and `PartialOrd`
-// impls from incorrectly relying on `T: Copy` and `T: Ord`.
-#[derive_where(Ord; I: Interner, T: Ord)]
-#[derive_where(Copy; I: Interner, T: Copy)]
-#[derive_where(Clone, PartialOrd, PartialEq, Eq, Hash; I: Interner, T)]
+#[derive_where(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash; I: Interner, T)]
 #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
 #[cfg_attr(
     feature = "nightly",

From 74776c4008a668e70733e16d8cf8519f3551e388 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 11:06:21 +1100
Subject: [PATCH 0649/1059] Rewrite `query_ensure_result`.

It currently uses chaining which is concise but hard to read. There are
up to four implicit matches occurring after the call to
`execute_query_fn`.
- The first `map` on `Option<Erased<Result<T, ErrorGuaranteed>>>`.
- The second `map` on `Option<Result<T, ErrorGuaranteed>>`.
- The third `map` on `Result<T, ErrorGuaranteed>`.
- The `unwrap_or` on `Option<Result<(), ErrorGuaranteed>>`.

This commit rewrites it to use at most two matches.
- An explicit match on `Option<Erased<Result<T, ErrorGuaranteed>>>`.
- An explicit match on `Result<T, ErrorGuaranteed>`.

This is easier to read. It's also more efficient, though the code isn't
hot enough for that to matter.
---
 compiler/rustc_middle/src/query/inner.rs | 43 +++++++++++++++---------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
index c2525d26d4c6..402c448a1fa3 100644
--- a/compiler/rustc_middle/src/query/inner.rs
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -77,23 +77,34 @@ pub(crate) fn query_ensure_result<'tcx, C, T>(
     C: QueryCache<Value = Erased<Result<T, ErrorGuaranteed>>>,
     Result<T, ErrorGuaranteed>: Erasable,
 {
+    let convert = |value: Erased<Result<T, ErrorGuaranteed>>| -> Result<(), ErrorGuaranteed> {
+        match erase::restore_val(value) {
+            Ok(_) => Ok(()),
+            Err(guar) => Err(guar),
+        }
+    };
+
     match try_get_cached(tcx, &query.cache, key) {
-        Some(value) => erase::restore_val(value).map(drop),
-        None => (query.execute_query_fn)(
-            tcx,
-            DUMMY_SP,
-            key,
-            QueryMode::Ensure { ensure_mode: EnsureMode::Ok },
-        )
-        .map(erase::restore_val)
-        .map(|value| value.map(drop))
-        // Either we actually executed the query, which means we got a full `Result`,
-        // or we can just assume the query succeeded, because it was green in the
-        // incremental cache. If it is green, that means that the previous compilation
-        // that wrote to the incremental cache compiles successfully. That is only
-        // possible if the cache entry was `Ok(())`, so we emit that here, without
-        // actually encoding the `Result` in the cache or loading it from there.
-        .unwrap_or(Ok(())),
+        Some(value) => convert(value),
+        None => {
+            match (query.execute_query_fn)(
+                tcx,
+                DUMMY_SP,
+                key,
+                QueryMode::Ensure { ensure_mode: EnsureMode::Ok },
+            ) {
+                // We executed the query. Convert the successful result.
+                Some(res) => convert(res),
+
+                // Reaching here means we didn't execute the query, but we can just assume the
+                // query succeeded, because it was green in the incremental cache. If it is green,
+                // that means that the previous compilation that wrote to the incremental cache
+                // compiles successfully. That is only possible if the cache entry was `Ok(())`, so
+                // we emit that here, without actually encoding the `Result` in the cache or
+                // loading it from there.
+                None => Ok(()),
+            }
+        }
     }
 }
 

From 2c52bc599e666e3631db2cd48fc7886ec70fe5c7 Mon Sep 17 00:00:00 2001
From: aisr <china.xuhui@gmail.com>
Date: Thu, 19 Mar 2026 15:01:48 +0800
Subject: [PATCH 0650/1059] format safety doc of Rc/Arc::from_raw/from_raw_in

---
 library/alloc/src/rc.rs   | 56 ++++++++++++++++++++++-----------------
 library/alloc/src/sync.rs | 54 ++++++++++++++++++++-----------------
 2 files changed, 61 insertions(+), 49 deletions(-)

diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index 8a651618ca83..1f29b3b47d2e 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -1430,29 +1430,32 @@ impl<T: ?Sized> Rc<T> {
     /// Constructs an `Rc<T>` from a raw pointer.
     ///
     /// The raw pointer must have been previously returned by a call to
-    /// [`Rc<U>::into_raw`][into_raw] with the following requirements:
+    /// [`Rc<U>::into_raw`][into_raw] or [`Rc<U>::into_raw_with_allocator`][into_raw_with_allocator].
     ///
+    /// # Safety
+    ///
+    /// * Creating a `Rc<T>` from a pointer other than one returned from
+    ///   [`Rc<U>::into_raw`][into_raw] or [`Rc<U>::into_raw_with_allocator`][into_raw_with_allocator]
+    ///   is undefined behavior.
     /// * If `U` is sized, it must have the same size and alignment as `T`. This
     ///   is trivially true if `U` is `T`.
     /// * If `U` is unsized, its data pointer must have the same size and
     ///   alignment as `T`. This is trivially true if `Rc<U>` was constructed
     ///   through `Rc<T>` and then converted to `Rc<U>` through an [unsized
     ///   coercion].
-    ///
-    /// Note that if `U` or `U`'s data pointer is not `T` but has the same size
-    /// and alignment, this is basically like transmuting references of
-    /// different types. See [`mem::transmute`][transmute] for more information
-    /// on what restrictions apply in this case.
-    ///
-    /// The raw pointer must point to a block of memory allocated by the global allocator
-    ///
-    /// The user of `from_raw` has to make sure a specific value of `T` is only
-    /// dropped once.
+    /// * Note that if `U` or `U`'s data pointer is not `T` but has the same size
+    ///   and alignment, this is basically like transmuting references of
+    ///   different types. See [`mem::transmute`][transmute] for more information
+    ///   on what restrictions apply in this case.
+    /// * The raw pointer must point to a block of memory allocated by the global allocator
+    /// * The user of `from_raw` has to make sure a specific value of `T` is only
+    ///   dropped once.
     ///
     /// This function is unsafe because improper use may lead to memory unsafety,
     /// even if the returned `Rc<T>` is never accessed.
     ///
     /// [into_raw]: Rc::into_raw
+    /// [into_raw_with_allocator]: Rc::into_raw_with_allocator
     /// [transmute]: core::mem::transmute
     /// [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
     ///
@@ -1662,29 +1665,32 @@ pub fn as_ptr(this: &Self) -> *const T {
     /// Constructs an `Rc<T, A>` from a raw pointer in the provided allocator.
     ///
     /// The raw pointer must have been previously returned by a call to [`Rc<U,
-    /// A>::into_raw`][into_raw] with the following requirements:
+    /// A>::into_raw`][into_raw] or [`Rc<U, A>::into_raw_with_allocator`][into_raw_with_allocator].
     ///
+    /// # Safety
+    ///
+    /// * Creating a `Rc<T, A>` from a pointer other than one returned from
+    ///   [`Rc<U, A>::into_raw`][into_raw] or [`Rc<U, A>::into_raw_with_allocator`][into_raw_with_allocator]
+    ///   is undefined behavior.
     /// * If `U` is sized, it must have the same size and alignment as `T`. This
     ///   is trivially true if `U` is `T`.
     /// * If `U` is unsized, its data pointer must have the same size and
-    ///   alignment as `T`. This is trivially true if `Rc<U>` was constructed
-    ///   through `Rc<T>` and then converted to `Rc<U>` through an [unsized
+    ///   alignment as `T`. This is trivially true if `Rc<U, A>` was constructed
+    ///   through `Rc<T, A>` and then converted to `Rc<U, A>` through an [unsized
     ///   coercion].
-    ///
-    /// Note that if `U` or `U`'s data pointer is not `T` but has the same size
-    /// and alignment, this is basically like transmuting references of
-    /// different types. See [`mem::transmute`][transmute] for more information
-    /// on what restrictions apply in this case.
-    ///
-    /// The raw pointer must point to a block of memory allocated by `alloc`
-    ///
-    /// The user of `from_raw` has to make sure a specific value of `T` is only
-    /// dropped once.
+    /// * Note that if `U` or `U`'s data pointer is not `T` but has the same size
+    ///   and alignment, this is basically like transmuting references of
+    ///   different types. See [`mem::transmute`][transmute] for more information
+    ///   on what restrictions apply in this case.
+    /// * The raw pointer must point to a block of memory allocated by `alloc`
+    /// * The user of `from_raw` has to make sure a specific value of `T` is only
+    ///   dropped once.
     ///
     /// This function is unsafe because improper use may lead to memory unsafety,
-    /// even if the returned `Rc<T>` is never accessed.
+    /// even if the returned `Rc<T, A>` is never accessed.
     ///
     /// [into_raw]: Rc::into_raw
+    /// [into_raw_with_allocator]: Rc::into_raw_with_allocator
     /// [transmute]: core::mem::transmute
     /// [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
     ///
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 2c9fadbb8d9e..368afb9011f9 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -1581,29 +1581,32 @@ impl<T: ?Sized> Arc<T> {
     /// Constructs an `Arc<T>` from a raw pointer.
     ///
     /// The raw pointer must have been previously returned by a call to
-    /// [`Arc<U>::into_raw`][into_raw] with the following requirements:
+    /// [`Arc<U>::into_raw`][into_raw] or [`Arc<U>::into_raw_with_allocator`][into_raw_with_allocator].
     ///
+    /// # Safety
+    ///
+    /// * Creating a `Arc<T>` from a pointer other than one returned from
+    ///   [`Arc<U>::into_raw`][into_raw] or [`Arc<U>::into_raw_with_allocator`][into_raw_with_allocator]
+    ///   is undefined behavior.
     /// * If `U` is sized, it must have the same size and alignment as `T`. This
     ///   is trivially true if `U` is `T`.
     /// * If `U` is unsized, its data pointer must have the same size and
     ///   alignment as `T`. This is trivially true if `Arc<U>` was constructed
     ///   through `Arc<T>` and then converted to `Arc<U>` through an [unsized
     ///   coercion].
-    ///
-    /// Note that if `U` or `U`'s data pointer is not `T` but has the same size
-    /// and alignment, this is basically like transmuting references of
-    /// different types. See [`mem::transmute`][transmute] for more information
-    /// on what restrictions apply in this case.
-    ///
-    /// The raw pointer must point to a block of memory allocated by the global allocator.
-    ///
-    /// The user of `from_raw` has to make sure a specific value of `T` is only
-    /// dropped once.
+    /// * Note that if `U` or `U`'s data pointer is not `T` but has the same size
+    ///   and alignment, this is basically like transmuting references of
+    ///   different types. See [`mem::transmute`][transmute] for more information
+    ///   on what restrictions apply in this case.
+    /// * The raw pointer must point to a block of memory allocated by the global allocator.
+    /// * The user of `from_raw` has to make sure a specific value of `T` is only
+    ///   dropped once.
     ///
     /// This function is unsafe because improper use may lead to memory unsafety,
     /// even if the returned `Arc<T>` is never accessed.
     ///
     /// [into_raw]: Arc::into_raw
+    /// [into_raw_with_allocator]: Arc::into_raw_with_allocator
     /// [transmute]: core::mem::transmute
     /// [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
     ///
@@ -1819,29 +1822,32 @@ pub fn as_ptr(this: &Self) -> *const T {
     /// Constructs an `Arc<T, A>` from a raw pointer.
     ///
     /// The raw pointer must have been previously returned by a call to [`Arc<U,
-    /// A>::into_raw`][into_raw] with the following requirements:
+    /// A>::into_raw`][into_raw] or [`Arc<U, A>::into_raw_with_allocator`][into_raw_with_allocator].
     ///
+    /// # Safety
+    ///
+    /// * Creating a `Arc<T, A>` from a pointer other than one returned from
+    ///   [`Arc<U, A>::into_raw`][into_raw] or [`Arc<U, A>::into_raw_with_allocator`][into_raw_with_allocator]
+    ///   is undefined behavior.
     /// * If `U` is sized, it must have the same size and alignment as `T`. This
     ///   is trivially true if `U` is `T`.
     /// * If `U` is unsized, its data pointer must have the same size and
-    ///   alignment as `T`. This is trivially true if `Arc<U>` was constructed
-    ///   through `Arc<T>` and then converted to `Arc<U>` through an [unsized
+    ///   alignment as `T`. This is trivially true if `Arc<U, A>` was constructed
+    ///   through `Arc<T, A>` and then converted to `Arc<U, A>` through an [unsized
     ///   coercion].
-    ///
-    /// Note that if `U` or `U`'s data pointer is not `T` but has the same size
-    /// and alignment, this is basically like transmuting references of
-    /// different types. See [`mem::transmute`][transmute] for more information
-    /// on what restrictions apply in this case.
-    ///
-    /// The raw pointer must point to a block of memory allocated by `alloc`
-    ///
-    /// The user of `from_raw` has to make sure a specific value of `T` is only
-    /// dropped once.
+    /// * Note that if `U` or `U`'s data pointer is not `T` but has the same size
+    ///   and alignment, this is basically like transmuting references of
+    ///   different types. See [`mem::transmute`][transmute] for more information
+    ///   on what restrictions apply in this case.
+    /// * The raw pointer must point to a block of memory allocated by `alloc`
+    /// * The user of `from_raw` has to make sure a specific value of `T` is only
+    ///   dropped once.
     ///
     /// This function is unsafe because improper use may lead to memory unsafety,
     /// even if the returned `Arc<T>` is never accessed.
     ///
     /// [into_raw]: Arc::into_raw
+    /// [into_raw_with_allocator]: Arc::into_raw_with_allocator
     /// [transmute]: core::mem::transmute
     /// [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
     ///

From cec0a68d6a69a9c29efc4055f7215dff1c9de103 Mon Sep 17 00:00:00 2001
From: CoCo-Japan-pan <115922543+CoCo-Japan-pan@users.noreply.github.com>
Date: Thu, 19 Mar 2026 18:32:36 +0900
Subject: [PATCH 0651/1059] Resolve paths for `impl` restrictions using
 `smart_resolve_path`

---
 compiler/rustc_resolve/src/errors.rs |  4 +++
 compiler/rustc_resolve/src/late.rs   | 43 +++++++++++++++++++++++++---
 2 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 63ffdbc37f7d..a73362eb805b 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -561,6 +561,10 @@ pub(crate) struct ExpectedModuleFound {
 #[diag("cannot determine resolution for the visibility", code = E0578)]
 pub(crate) struct Indeterminate(#[primary_span] pub(crate) Span);
 
+#[derive(Diagnostic)]
+#[diag("trait implementation can only be restricted to ancestor modules")]
+pub(crate) struct RestrictionAncestorOnly(#[primary_span] pub(crate) Span);
+
 #[derive(Diagnostic)]
 #[diag("cannot use a tool module through an import")]
 pub(crate) struct ToolModuleImported {
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index c7b0cb192433..94de55c24711 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -453,6 +453,8 @@ pub(crate) enum PathSource<'a, 'ast, 'ra> {
     DefineOpaques,
     /// Resolving a macro
     Macro,
+    /// Paths for module or crate root. Used for restrictions.
+    Module,
 }
 
 impl PathSource<'_, '_, '_> {
@@ -461,7 +463,8 @@ fn namespace(self) -> Namespace {
             PathSource::Type
             | PathSource::Trait(_)
             | PathSource::Struct(_)
-            | PathSource::DefineOpaques => TypeNS,
+            | PathSource::DefineOpaques
+            | PathSource::Module => TypeNS,
             PathSource::Expr(..)
             | PathSource::Pat
             | PathSource::TupleStruct(..)
@@ -486,7 +489,8 @@ fn defer_to_typeck(self) -> bool {
             | PathSource::DefineOpaques
             | PathSource::Delegation
             | PathSource::PreciseCapturingArg(..)
-            | PathSource::Macro => false,
+            | PathSource::Macro
+            | PathSource::Module => false,
         }
     }
 
@@ -529,6 +533,7 @@ fn descr_expected(self) -> &'static str {
             PathSource::ReturnTypeNotation | PathSource::Delegation => "function",
             PathSource::PreciseCapturingArg(..) => "type or const parameter",
             PathSource::Macro => "macro",
+            PathSource::Module => "module",
         }
     }
 
@@ -627,6 +632,7 @@ pub(crate) fn is_expected(self, res: Res) -> bool {
             ),
             PathSource::PreciseCapturingArg(MacroNS) => false,
             PathSource::Macro => matches!(res, Res::Def(DefKind::Macro(_), _)),
+            PathSource::Module => matches!(res, Res::Def(DefKind::Mod, _)),
         }
     }
 
@@ -647,6 +653,12 @@ fn error_code(self, has_unexpected_resolution: bool) -> ErrCode {
             (PathSource::PreciseCapturingArg(..), true) => E0799,
             (PathSource::PreciseCapturingArg(..), false) => E0800,
             (PathSource::Macro, _) => E0425,
+            // FIXME: There is no dedicated error code for this case yet.
+            // E0577 already covers the same situation for visibilities,
+            // so we reuse it here for now. It may make sense to generalize
+            // it for restrictions in the future.
+            (PathSource::Module, true) => E0577,
+            (PathSource::Module, false) => E0433,
         }
     }
 }
@@ -2175,7 +2187,8 @@ fn resolve_elided_lifetimes_in_path(
                 | PathSource::Type
                 | PathSource::PreciseCapturingArg(..)
                 | PathSource::ReturnTypeNotation
-                | PathSource::Macro => false,
+                | PathSource::Macro
+                | PathSource::Module => false,
                 PathSource::Expr(..)
                 | PathSource::Pat
                 | PathSource::Struct(_)
@@ -2801,7 +2814,10 @@ fn resolve_item(&mut self, item: &'ast Item) {
                 self.diag_metadata.current_impl_items = None;
             }
 
-            ItemKind::Trait(box Trait { generics, bounds, items, .. }) => {
+            ItemKind::Trait(box Trait { generics, bounds, items, impl_restriction, .. }) => {
+                // resolve paths for `impl` restrictions
+                self.resolve_impl_restriction_path(impl_restriction);
+
                 // Create a new rib for the trait-wide type parameters.
                 self.with_generic_param_rib(
                     &generics.params,
@@ -4390,6 +4406,25 @@ fn try_resolve_as_non_binding(
         }
     }
 
+    fn resolve_impl_restriction_path(&mut self, restriction: &'ast ast::ImplRestriction) {
+        match &restriction.kind {
+            ast::RestrictionKind::Unrestricted => (),
+            ast::RestrictionKind::Restricted { path, id, shorthand: _ } => {
+                self.smart_resolve_path(*id, &None, path, PathSource::Module);
+                if let Some(res) = self.r.partial_res_map[&id].full_res()
+                    && let Some(def_id) = res.opt_def_id()
+                {
+                    if !self.r.is_accessible_from(
+                        Visibility::Restricted(def_id),
+                        self.parent_scope.module,
+                    ) {
+                        self.r.dcx().create_err(errors::RestrictionAncestorOnly(path.span)).emit();
+                    }
+                }
+            }
+        }
+    }
+
     // High-level and context dependent path resolution routine.
     // Resolves the path and records the resolution into definition map.
     // If resolution fails tries several techniques to find likely

From 4a60dae793e07440c32ec2d5ef71bf58cf1df7a9 Mon Sep 17 00:00:00 2001
From: CoCo-Japan-pan <115922543+CoCo-Japan-pan@users.noreply.github.com>
Date: Thu, 19 Mar 2026 18:43:32 +0900
Subject: [PATCH 0652/1059] Add UI tests for path resolution errors of `impl`
 restrictions

---
 .../restriction_resolution_errors.rs          |  85 +++++++++++
 .../restriction_resolution_errors.stderr      | 140 ++++++++++++++++++
 2 files changed, 225 insertions(+)
 create mode 100644 tests/ui/impl-restriction/restriction_resolution_errors.rs
 create mode 100644 tests/ui/impl-restriction/restriction_resolution_errors.stderr

diff --git a/tests/ui/impl-restriction/restriction_resolution_errors.rs b/tests/ui/impl-restriction/restriction_resolution_errors.rs
new file mode 100644
index 000000000000..b36f2cf9bdfb
--- /dev/null
+++ b/tests/ui/impl-restriction/restriction_resolution_errors.rs
@@ -0,0 +1,85 @@
+#![feature(impl_restriction)]
+#![expect(incomplete_features)]
+
+pub mod a {
+    pub enum E {}
+    pub mod d {}
+    pub mod b {
+        pub mod c {}
+
+        // We do not use crate-relative paths here, since we follow the
+        // "uniform paths" approach used for type/expression paths.
+        pub impl(in a::b) trait T1 {} //~ ERROR cannot find module or crate `a` in this scope [E0433]
+
+        pub impl(in ::std) trait T2 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+        pub impl(in self::c) trait T3 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+        pub impl(in super::d) trait T4 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+        pub impl(in crate::c) trait T5 {} //~ ERROR cannot find module `c` in the crate root [E0433]
+
+        pub impl(in super::E) trait T6 {} //~ ERROR expected module, found enum `super::E` [E0577]
+
+        pub impl(in super::super::super) trait T7 {} //~ ERROR too many leading `super` keywords [E0433]
+
+        // OK paths
+        pub impl(crate) trait T8 {}
+        pub impl(self) trait T9 {}
+        pub impl(super) trait T10 {}
+        pub impl(in crate::a) trait T11 {}
+        pub impl(in super::super) trait T12 {}
+
+        // Check if we can resolve paths referring to modules declared later.
+        pub impl(in self::f) trait L1 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+        pub impl(in super::G) trait L2 {} //~ ERROR expected module, found enum `super::G` [E0577]
+
+        pub impl(in super::h) trait L3 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+        pub mod f {}
+    }
+
+    pub enum G {}
+    pub mod h {}
+}
+
+pub impl(in crate::a) trait T13 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+pub impl(in crate::a::E) trait T14 {} //~ ERROR expected module, found enum `crate::a::E` [E0577]
+
+pub impl(crate) trait T15 {}
+pub impl(self) trait T16 {}
+
+pub impl(super) trait T17 {} //~ ERROR too many leading `super` keywords [E0433]
+
+// Check if we can resolve paths referring to modules declared later.
+pub impl(in crate::j) trait L4 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+
+pub impl(in crate::I) trait L5 {} //~ ERROR expected module, found enum `crate::I` [E0577]
+
+pub enum I {}
+pub mod j {}
+
+// Check if we can resolve `use`d paths.
+mod m1 {
+    pub impl(in crate::m2) trait U1 {} // OK
+}
+
+use m1 as m2;
+
+mod m3 {
+    mod m4 {
+        pub impl(in crate::m2) trait U2 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+        pub impl(in m6) trait U3 {} // OK
+        pub impl(in m6::m5) trait U4 {} //~ ERROR trait implementation can only be restricted to ancestor modules
+        pub impl(in m7) trait U5 {} //~ ERROR expected module, found enum `m7` [E0577]
+
+        use crate::m3 as m6;
+        use crate::m3::E as m7;
+    }
+    mod m5 {}
+    pub enum E {}
+}
+
+fn main() {}
diff --git a/tests/ui/impl-restriction/restriction_resolution_errors.stderr b/tests/ui/impl-restriction/restriction_resolution_errors.stderr
new file mode 100644
index 000000000000..540803285c1b
--- /dev/null
+++ b/tests/ui/impl-restriction/restriction_resolution_errors.stderr
@@ -0,0 +1,140 @@
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:14:21
+   |
+LL |         pub impl(in ::std) trait T2 {}
+   |                     ^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:16:21
+   |
+LL |         pub impl(in self::c) trait T3 {}
+   |                     ^^^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:18:21
+   |
+LL |         pub impl(in super::d) trait T4 {}
+   |                     ^^^^^^^^
+
+error[E0433]: too many leading `super` keywords
+  --> $DIR/restriction_resolution_errors.rs:24:35
+   |
+LL |         pub impl(in super::super::super) trait T7 {}
+   |                                   ^^^^^ there are too many leading `super` keywords
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:34:21
+   |
+LL |         pub impl(in self::f) trait L1 {}
+   |                     ^^^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:38:21
+   |
+LL |         pub impl(in super::h) trait L3 {}
+   |                     ^^^^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:47:13
+   |
+LL | pub impl(in crate::a) trait T13 {}
+   |             ^^^^^^^^
+
+error[E0433]: too many leading `super` keywords
+  --> $DIR/restriction_resolution_errors.rs:54:10
+   |
+LL | pub impl(super) trait T17 {}
+   |          ^^^^^ there are too many leading `super` keywords
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:57:13
+   |
+LL | pub impl(in crate::j) trait L4 {}
+   |             ^^^^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:73:21
+   |
+LL |         pub impl(in crate::m2) trait U2 {}
+   |                     ^^^^^^^^^
+
+error: trait implementation can only be restricted to ancestor modules
+  --> $DIR/restriction_resolution_errors.rs:75:21
+   |
+LL |         pub impl(in m6::m5) trait U4 {}
+   |                     ^^^^^^
+
+error[E0433]: cannot find module or crate `a` in this scope
+  --> $DIR/restriction_resolution_errors.rs:12:21
+   |
+LL |         pub impl(in a::b) trait T1 {}
+   |                     ^ use of unresolved module or unlinked crate `a`
+   |
+help: there is a crate or module with a similar name
+   |
+LL -         pub impl(in a::b) trait T1 {}
+LL +         pub impl(in c::b) trait T1 {}
+   |
+help: consider importing this module
+   |
+LL +         use a;
+   |
+
+error[E0433]: cannot find module `c` in the crate root
+  --> $DIR/restriction_resolution_errors.rs:20:28
+   |
+LL |         pub impl(in crate::c) trait T5 {}
+   |                            ^ not found in the crate root
+
+error[E0577]: expected module, found enum `super::E`
+  --> $DIR/restriction_resolution_errors.rs:22:21
+   |
+LL |         pub impl(in super::E) trait T6 {}
+   |                     ^^^^^^^^ not a module
+
+error[E0577]: expected module, found enum `super::G`
+  --> $DIR/restriction_resolution_errors.rs:36:21
+   |
+LL |         pub impl(in super::G) trait L2 {}
+   |                     ^^^^^^^^ not a module
+
+error[E0577]: expected module, found enum `crate::a::E`
+  --> $DIR/restriction_resolution_errors.rs:49:13
+   |
+LL |     pub mod b {
+   |     --------- similarly named module `b` defined here
+...
+LL | pub impl(in crate::a::E) trait T14 {}
+   |             ^^^^^^^^^^^
+   |
+help: a module with a similar name exists
+   |
+LL - pub impl(in crate::a::E) trait T14 {}
+LL + pub impl(in crate::a::b) trait T14 {}
+   |
+
+error[E0577]: expected module, found enum `crate::I`
+  --> $DIR/restriction_resolution_errors.rs:59:13
+   |
+LL | pub mod a {
+   | --------- similarly named module `a` defined here
+...
+LL | pub impl(in crate::I) trait L5 {}
+   |             ^^^^^^^^
+   |
+help: a module with a similar name exists
+   |
+LL - pub impl(in crate::I) trait L5 {}
+LL + pub impl(in crate::a) trait L5 {}
+   |
+
+error[E0577]: expected module, found enum `m7`
+  --> $DIR/restriction_resolution_errors.rs:76:21
+   |
+LL |         pub impl(in m7) trait U5 {}
+   |                     ^^ not a module
+
+error: aborting due to 18 previous errors
+
+Some errors have detailed explanations: E0433, E0577.
+For more information about an error, try `rustc --explain E0433`.

From 082cdf7c48245088b3384e8a573e60b8dda14d9d Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 10:27:40 +0000
Subject: [PATCH 0653/1059] Preserve braces around `self` in use tree pretty
 printing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The AST pretty printer strips braces from single-item `use` sub-groups,
simplifying `use foo::{Bar}` to `use foo::Bar`. However, when the single
item is `self`, this produces `use foo::self` which is not valid Rust
(E0429) — the grammar requires `use foo::{self}`.

This affects both `stringify!` and `rustc -Zunpretty=expanded`, causing
`cargo expand` output to be unparseable when a crate uses `use
path::{self}` imports (a common pattern in the ecosystem).

The fix checks whether the single nested item's path starts with `self`
before stripping braces. If so, the braces are preserved.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state/item.rs |  8 +++++++-
 tests/pretty/use-self-braces.rs                    | 10 ++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 tests/pretty/use-self-braces.rs

diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
index 3407feb3dcc3..e997fdf49820 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/item.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -881,7 +881,13 @@ fn print_use_tree(&mut self, tree: &ast::UseTree) {
                 }
                 if items.is_empty() {
                     self.word("{}");
-                } else if let [(item, _)] = items.as_slice() {
+                } else if let [(item, _)] = items.as_slice()
+                    && !item
+                        .prefix
+                        .segments
+                        .first()
+                        .is_some_and(|seg| seg.ident.name == rustc_span::symbol::kw::SelfLower)
+                {
                     self.print_use_tree(item);
                 } else {
                     let cb = self.cbox(INDENT_UNIT);
diff --git a/tests/pretty/use-self-braces.rs b/tests/pretty/use-self-braces.rs
new file mode 100644
index 000000000000..8db256894361
--- /dev/null
+++ b/tests/pretty/use-self-braces.rs
@@ -0,0 +1,10 @@
+//@ pp-exact
+//@ edition:2021
+
+#![allow(unused_imports)]
+
+// Braces around `self` must be preserved, because `use foo::self` is not valid Rust.
+use std::io::{self};
+use std::fmt::{self, Debug};
+
+fn main() {}

From e15897f6c4bd948526b8f43d3ea8874075eccab9 Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 10:27:40 +0000
Subject: [PATCH 0654/1059] Parenthesize or-patterns in prefix pattern
 positions in pretty printer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The AST pretty printer was dropping parentheses around or-patterns
when they appeared inside `@` bindings, `&` references, or `box`
patterns. For example:

- `v @ (1 | 2 | 3)` was printed as `v @ 1 | 2 | 3`
- `&(1 | 2 | 3)` was printed as `&1 | 2 | 3`
- `box (1 | 2 | 3)` was printed as `box 1 | 2 | 3`

Since `|` has the lowest precedence among pattern operators, all of
these are parsed incorrectly without parentheses — e.g. `v @ 1 | 2 | 3`
becomes `(v @ 1) | 2 | 3`, binding `v` only to the first alternative.

This caused E0408 ("variable not bound in all patterns") when the
expanded output was fed back to the compiler, affecting crates like
html5ever and wgpu-core that use macros expanding to or-patterns
after `@`.

The fix adds a `print_pat_paren_if_or` helper that wraps `PatKind::Or`
subpatterns in parentheses, and uses it in the `@`, `&`, and `box`
printing arms. This is similar in spirit to the existing `FixupContext`
parenthesization approach used for expression printing.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 23 ++++++++++--
 tests/pretty/or-pattern-paren.pp              | 27 ++++++++++++++
 tests/pretty/or-pattern-paren.rs              | 36 +++++++++++++++++++
 3 files changed, 83 insertions(+), 3 deletions(-)
 create mode 100644 tests/pretty/or-pattern-paren.pp
 create mode 100644 tests/pretty/or-pattern-paren.rs

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 4ba5dc541342..74f0f970f76d 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1749,6 +1749,23 @@ fn print_qpath(&mut self, path: &ast::Path, qself: &ast::QSelf, colons_before_pa
         }
     }
 
+    /// Print a pattern, parenthesizing it if it is an or-pattern (`A | B`).
+    ///
+    /// Or-patterns have the lowest precedence among patterns, so they need
+    /// parentheses when nested inside `@` bindings, `&` references, or `box`
+    /// patterns — otherwise `x @ A | B` parses as `(x @ A) | B`, `&A | B`
+    /// parses as `(&A) | B`, etc.
+    fn print_pat_paren_if_or(&mut self, pat: &ast::Pat) {
+        let needs_paren = matches!(pat.kind, PatKind::Or(..));
+        if needs_paren {
+            self.popen();
+        }
+        self.print_pat(pat);
+        if needs_paren {
+            self.pclose();
+        }
+    }
+
     fn print_pat(&mut self, pat: &ast::Pat) {
         self.maybe_print_comment(pat.span.lo());
         self.ann.pre(self, AnnNode::Pat(pat));
@@ -1776,7 +1793,7 @@ fn print_pat(&mut self, pat: &ast::Pat) {
                 if let Some(p) = sub {
                     self.space();
                     self.word_space("@");
-                    self.print_pat(p);
+                    self.print_pat_paren_if_or(p);
                 }
             }
             PatKind::TupleStruct(qself, path, elts) => {
@@ -1848,7 +1865,7 @@ fn print_pat(&mut self, pat: &ast::Pat) {
             }
             PatKind::Box(inner) => {
                 self.word("box ");
-                self.print_pat(inner);
+                self.print_pat_paren_if_or(inner);
             }
             PatKind::Deref(inner) => {
                 self.word("deref!");
@@ -1872,7 +1889,7 @@ fn print_pat(&mut self, pat: &ast::Pat) {
                     self.print_pat(inner);
                     self.pclose();
                 } else {
-                    self.print_pat(inner);
+                    self.print_pat_paren_if_or(inner);
                 }
             }
             PatKind::Expr(e) => self.print_expr(e, FixupContext::default()),
diff --git a/tests/pretty/or-pattern-paren.pp b/tests/pretty/or-pattern-paren.pp
new file mode 100644
index 000000000000..6ea94eb7b91f
--- /dev/null
+++ b/tests/pretty/or-pattern-paren.pp
@@ -0,0 +1,27 @@
+#![feature(prelude_import)]
+#![no_std]
+#![feature(box_patterns)]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+
+//@ pretty-compare-only
+//@ pretty-mode:expanded
+//@ pp-exact:or-pattern-paren.pp
+
+macro_rules! or_pat { ($($name:pat),+) => { $($name)|+ } }
+
+fn check_at(x: Option<i32>) {
+    match x {
+        Some(v @ (1 | 2 | 3)) =>
+
+
+            {
+            ::std::io::_print(format_args!("{0}\n", v));
+        }
+        _ => {}
+    }
+}
+fn check_ref(x: &i32) { match x { &(1 | 2 | 3) => {} _ => {} } }
+fn check_box(x: Box<i32>) { match x { box (1 | 2 | 3) => {} _ => {} } }
+fn main() { check_at(Some(2)); check_ref(&1); check_box(Box::new(1)); }
diff --git a/tests/pretty/or-pattern-paren.rs b/tests/pretty/or-pattern-paren.rs
new file mode 100644
index 000000000000..ea6a8f3de9e4
--- /dev/null
+++ b/tests/pretty/or-pattern-paren.rs
@@ -0,0 +1,36 @@
+#![feature(box_patterns)]
+
+//@ pretty-compare-only
+//@ pretty-mode:expanded
+//@ pp-exact:or-pattern-paren.pp
+
+macro_rules! or_pat {
+    ($($name:pat),+) => { $($name)|+ }
+}
+
+fn check_at(x: Option<i32>) {
+    match x {
+        Some(v @ or_pat!(1, 2, 3)) => println!("{v}"),
+        _ => {}
+    }
+}
+
+fn check_ref(x: &i32) {
+    match x {
+        &or_pat!(1, 2, 3) => {}
+        _ => {}
+    }
+}
+
+fn check_box(x: Box<i32>) {
+    match x {
+        box or_pat!(1, 2, 3) => {}
+        _ => {}
+    }
+}
+
+fn main() {
+    check_at(Some(2));
+    check_ref(&1);
+    check_box(Box::new(1));
+}

From c77768590dbc2e63acf853ab86177de3fb4e5bfb Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 10:27:40 +0000
Subject: [PATCH 0655/1059] Fix whitespace after fragment specifiers in macro
 pretty printing

When a macro-generating-macro captures fragment specifier tokens (like
`$x:ident`) as `tt` metavariables and replays them before a keyword
(like `where`), the pretty printer concatenates them into an invalid
fragment specifier (e.g. `$x:identwhere` instead of `$x:ident where`).

This happens because `tt` captures preserve the original token spacing.
When the fragment specifier name (e.g. `ident`) was originally the last
token before a closing delimiter, it retains `JointHidden` spacing. The
`print_tts` function only checks `space_between` for `Spacing::Alone`
tokens, so `JointHidden` tokens skip the space check entirely, causing
adjacent identifier-like tokens to merge.

The fix adds a check in `print_tts` to insert a space between adjacent
identifier-like tokens (identifiers and keywords) regardless of the
original spacing, preventing them from being concatenated into invalid
tokens.

This is similar to the existing `space_between` mechanism that prevents
token merging for `Spacing::Alone` tokens, extended to also handle
`Joint`/`JointHidden` cases where two identifier-like tokens would merge.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 20 ++++++++++++++++
 .../macro-fragment-specifier-whitespace.pp    | 24 +++++++++++++++++++
 .../macro-fragment-specifier-whitespace.rs    | 19 +++++++++++++++
 3 files changed, 63 insertions(+)
 create mode 100644 tests/pretty/macro-fragment-specifier-whitespace.pp
 create mode 100644 tests/pretty/macro-fragment-specifier-whitespace.rs

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 4ba5dc541342..2ff730e3331c 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -329,6 +329,19 @@ fn print_crate_inner<'a>(
 /// - #63896: `#[allow(unused,` must be printed rather than `#[allow(unused ,`
 /// - #73345: `#[allow(unused)]` must be printed rather than `# [allow(unused)]`
 ///
+/// Returns `true` if both token trees are identifier-like tokens that would
+/// merge into a single token if printed without a space between them.
+/// E.g. `ident` + `where` would merge into `identwhere`.
+fn idents_would_merge(tt1: &TokenTree, tt2: &TokenTree) -> bool {
+    fn is_ident_like(tt: &TokenTree) -> bool {
+        matches!(
+            tt,
+            TokenTree::Token(Token { kind: token::Ident(..) | token::NtIdent(..), .. }, _,)
+        )
+    }
+    is_ident_like(tt1) && is_ident_like(tt2)
+}
+
 fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
     use Delimiter::*;
     use TokenTree::{Delimited as Del, Token as Tok};
@@ -794,6 +807,13 @@ fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
             if let Some(next) = iter.peek() {
                 if spacing == Spacing::Alone && space_between(tt, next) {
                     self.space();
+                } else if spacing != Spacing::Alone && idents_would_merge(tt, next) {
+                    // When tokens from macro `tt` captures preserve their
+                    // original `Joint`/`JointHidden` spacing, adjacent
+                    // identifier-like tokens can be concatenated without a
+                    // space (e.g. `$x:identwhere`). Insert a space to
+                    // prevent this.
+                    self.space();
                 }
             }
         }
diff --git a/tests/pretty/macro-fragment-specifier-whitespace.pp b/tests/pretty/macro-fragment-specifier-whitespace.pp
new file mode 100644
index 000000000000..ee5a0f7a7c05
--- /dev/null
+++ b/tests/pretty/macro-fragment-specifier-whitespace.pp
@@ -0,0 +1,24 @@
+#![feature(prelude_import)]
+#![no_std]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+//@ pretty-mode:expanded
+//@ pp-exact:macro-fragment-specifier-whitespace.pp
+
+// Test that fragment specifier names in macro definitions are properly
+// separated from the following keyword/identifier token when pretty-printed.
+// This is a regression test for a bug where `$x:ident` followed by `where`
+// was pretty-printed as `$x:identwhere` (an invalid fragment specifier).
+
+macro_rules! outer {
+    ($d:tt $($params:tt)*) =>
+    {
+        #[macro_export] macro_rules! inner
+        { ($($params)* where $d($rest:tt)*) => {}; }
+    };
+}
+#[macro_export]
+macro_rules! inner { ($x:ident where $ ($rest : tt)*) => {}; }
+
+fn main() {}
diff --git a/tests/pretty/macro-fragment-specifier-whitespace.rs b/tests/pretty/macro-fragment-specifier-whitespace.rs
new file mode 100644
index 000000000000..54c6debd9a27
--- /dev/null
+++ b/tests/pretty/macro-fragment-specifier-whitespace.rs
@@ -0,0 +1,19 @@
+//@ pretty-mode:expanded
+//@ pp-exact:macro-fragment-specifier-whitespace.pp
+
+// Test that fragment specifier names in macro definitions are properly
+// separated from the following keyword/identifier token when pretty-printed.
+// This is a regression test for a bug where `$x:ident` followed by `where`
+// was pretty-printed as `$x:identwhere` (an invalid fragment specifier).
+
+macro_rules! outer {
+    ($d:tt $($params:tt)*) => {
+        #[macro_export]
+        macro_rules! inner {
+            ($($params)* where $d($rest:tt)*) => {};
+        }
+    };
+}
+outer!($ $x:ident);
+
+fn main() {}

From e9740a4be5cf4e89accacae0bd868557d942d247 Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 10:27:40 +0000
Subject: [PATCH 0656/1059] Insert space after float literal ending with `.` in
 pretty printer

The pretty printer was collapsing unsuffixed float literals (like `0.`)
with adjacent dot tokens, producing ambiguous or invalid output:

- `0. ..45.` (range) became `0...45.`
- `0. ..=360.` (inclusive range) became `0...=360.`
- `0. .to_string()` (method call) became `0..to_string()`

The fix inserts a space after an unsuffixed float literal ending with
`.` when it appears as the start expression of a range operator or the
receiver of a method call or field access, preventing the trailing dot
from merging with the following `.`, `..`, or `..=` token. This is
skipped when the expression is already parenthesized, since the closing
`)` naturally provides separation.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 .../rustc_ast_pretty/src/pprust/state/expr.rs | 48 ++++++++++++++-----
 tests/pretty/float-trailing-dot.rs            |  8 ++++
 2 files changed, 45 insertions(+), 11 deletions(-)
 create mode 100644 tests/pretty/float-trailing-dot.rs

diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 9b4ff2b63bd4..0c5928765bfa 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -260,12 +260,15 @@ fn print_expr_method_call(
         //
         //     loop { break x; }.method();
         //
-        self.print_expr_cond_paren(
-            receiver,
-            receiver.precedence() < ExprPrecedence::Unambiguous,
-            fixup.leftmost_subexpression_with_dot(),
-        );
+        let needs_paren = receiver.precedence() < ExprPrecedence::Unambiguous;
+        self.print_expr_cond_paren(receiver, needs_paren, fixup.leftmost_subexpression_with_dot());
 
+        // If the receiver is an unsuffixed float literal like `0.`, insert
+        // a space so the `.` of the method call doesn't merge with the
+        // trailing dot: `0. .method()` instead of `0..method()`.
+        if !needs_paren && expr_ends_with_dot(receiver) {
+            self.word(" ");
+        }
         self.word(".");
         self.print_ident(segment.ident);
         if let Some(args) = &segment.args {
@@ -658,11 +661,15 @@ pub(super) fn print_expr_outer_attr_style(
                 );
             }
             ast::ExprKind::Field(expr, ident) => {
+                let needs_paren = expr.precedence() < ExprPrecedence::Unambiguous;
                 self.print_expr_cond_paren(
                     expr,
-                    expr.precedence() < ExprPrecedence::Unambiguous,
+                    needs_paren,
                     fixup.leftmost_subexpression_with_dot(),
                 );
+                if !needs_paren && expr_ends_with_dot(expr) {
+                    self.word(" ");
+                }
                 self.word(".");
                 self.print_ident(*ident);
             }
@@ -685,11 +692,15 @@ pub(super) fn print_expr_outer_attr_style(
                 let fake_prec = ExprPrecedence::LOr;
                 if let Some(e) = start {
                     let start_fixup = fixup.leftmost_subexpression_with_operator(true);
-                    self.print_expr_cond_paren(
-                        e,
-                        start_fixup.precedence(e) < fake_prec,
-                        start_fixup,
-                    );
+                    let needs_paren = start_fixup.precedence(e) < fake_prec;
+                    self.print_expr_cond_paren(e, needs_paren, start_fixup);
+                    // If the start expression is a float literal ending with
+                    // `.`, we need a space before `..` or `..=` so that the
+                    // dots don't merge. E.g. `0. ..45.` must not become
+                    // `0...45.`.
+                    if !needs_paren && expr_ends_with_dot(e) {
+                        self.word(" ");
+                    }
                 }
                 match limits {
                     ast::RangeLimits::HalfOpen => self.word(".."),
@@ -1025,3 +1036,18 @@ fn reconstruct_format_args_template_string(pieces: &[FormatArgsPiece]) -> String
     template.push('"');
     template
 }
+
+/// Returns `true` if the printed representation of this expression ends with
+/// a `.` character — specifically, an unsuffixed float literal like `0.` or
+/// `45.`. This is used to insert whitespace before range operators (`..`,
+/// `..=`) so that the dots don't merge (e.g. `0. ..45.` instead of `0...45.`).
+fn expr_ends_with_dot(expr: &ast::Expr) -> bool {
+    match &expr.kind {
+        ast::ExprKind::Lit(token_lit) => {
+            token_lit.kind == token::Float
+                && token_lit.suffix.is_none()
+                && token_lit.symbol.as_str().ends_with('.')
+        }
+        _ => false,
+    }
+}
diff --git a/tests/pretty/float-trailing-dot.rs b/tests/pretty/float-trailing-dot.rs
new file mode 100644
index 000000000000..63934bb8eaaa
--- /dev/null
+++ b/tests/pretty/float-trailing-dot.rs
@@ -0,0 +1,8 @@
+//@ pp-exact
+
+fn main() {
+    let _ = 0. ..45.;
+    let _ = 0. ..=360.;
+    let _ = 0. ..;
+    let _ = 0. .to_string();
+}

From 9975d4760d1888a7cbd4bd9acfd26101792a3bcf Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 10:27:36 +0000
Subject: [PATCH 0657/1059] Reorder inline asm operands in pretty printer to
 satisfy grammar constraints

After macro expansion, named `asm!` operands are converted to positional
operands and the template string uses numeric indices. However, the pretty
printer previously emitted operands in their original AST order, which could
place positional (formerly named) register-class operands after explicit
register operands. This violates the `asm!` grammar rule that positional
arguments cannot follow explicit register arguments, causing the expanded
output from `rustc -Zunpretty=expanded` to fail to reparse.

When reordering is needed, the fix partitions operands into non-explicit and
explicit register groups, emits non-explicit operands first, then explicit
register operands, and remaps template placeholder indices (`{N}`) to match
the new positions. When operands are already correctly ordered, the original
code path is used unchanged.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 82 ++++++++++++++++++-
 tests/pretty/asm-operand-order.pp             | 18 ++++
 tests/pretty/asm-operand-order.rs             | 13 +++
 3 files changed, 111 insertions(+), 2 deletions(-)
 create mode 100644 tests/pretty/asm-operand-order.pp
 create mode 100644 tests/pretty/asm-operand-order.rs

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 4ba5dc541342..92767f97c28e 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1620,8 +1620,86 @@ enum AsmArg<'a> {
             Options(InlineAsmOptions),
         }
 
-        let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&asm.template))];
-        args.extend(asm.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
+        // After macro expansion, named operands become positional. The grammar
+        // requires positional operands to precede explicit register operands,
+        // so we must reorder when any non-explicit operand follows an explicit
+        // one. When no reordering is needed, we use the original template
+        // string and operand order to avoid duplicating the Display logic in
+        // InlineAsmTemplatePiece.
+        let is_explicit_reg = |op: &InlineAsmOperand| -> bool {
+            match op {
+                InlineAsmOperand::In { reg, .. }
+                | InlineAsmOperand::Out { reg, .. }
+                | InlineAsmOperand::InOut { reg, .. }
+                | InlineAsmOperand::SplitInOut { reg, .. } => {
+                    matches!(reg, InlineAsmRegOrRegClass::Reg(_))
+                }
+                InlineAsmOperand::Const { .. }
+                | InlineAsmOperand::Sym { .. }
+                | InlineAsmOperand::Label { .. } => false,
+            }
+        };
+
+        // Check whether any non-explicit operand follows an explicit one.
+        let needs_reorder = {
+            let mut seen_explicit = false;
+            asm.operands.iter().any(|(op, _)| {
+                if is_explicit_reg(op) {
+                    seen_explicit = true;
+                    false
+                } else {
+                    seen_explicit
+                }
+            })
+        };
+
+        let mut args = if needs_reorder {
+            let mut non_explicit: Vec<usize> = Vec::new();
+            let mut explicit: Vec<usize> = Vec::new();
+            for (i, (op, _)) in asm.operands.iter().enumerate() {
+                if is_explicit_reg(op) {
+                    explicit.push(i);
+                } else {
+                    non_explicit.push(i);
+                }
+            }
+
+            // Build old-index → new-index mapping for template renumbering.
+            let mut old_to_new = vec![0usize; asm.operands.len()];
+            for (new_idx, &old_idx) in non_explicit.iter().chain(explicit.iter()).enumerate() {
+                old_to_new[old_idx] = new_idx;
+            }
+
+            // Remap template placeholder indices and reuse the existing
+            // Display impl to build the template string.
+            let remapped: Vec<_> = asm
+                .template
+                .iter()
+                .map(|piece| match piece {
+                    InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span } => {
+                        InlineAsmTemplatePiece::Placeholder {
+                            operand_idx: old_to_new[*operand_idx],
+                            modifier: *modifier,
+                            span: *span,
+                        }
+                    }
+                    other => other.clone(),
+                })
+                .collect();
+
+            let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&remapped))];
+            for &idx in &non_explicit {
+                args.push(AsmArg::Operand(&asm.operands[idx].0));
+            }
+            for &idx in &explicit {
+                args.push(AsmArg::Operand(&asm.operands[idx].0));
+            }
+            args
+        } else {
+            let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&asm.template))];
+            args.extend(asm.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
+            args
+        };
         for (abi, _) in &asm.clobber_abis {
             args.push(AsmArg::ClobberAbi(*abi));
         }
diff --git a/tests/pretty/asm-operand-order.pp b/tests/pretty/asm-operand-order.pp
new file mode 100644
index 000000000000..723191412d0f
--- /dev/null
+++ b/tests/pretty/asm-operand-order.pp
@@ -0,0 +1,18 @@
+#![feature(prelude_import)]
+#![no_std]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+//@ pretty-mode:expanded
+//@ pp-exact:asm-operand-order.pp
+//@ only-x86_64
+
+use std::arch::asm;
+
+pub fn main() {
+    unsafe {
+        asm!("{0}", in(reg) 4, out("rax") _);
+        asm!("{0}", in(reg) 4, out("rax") _, options(nostack));
+        asm!("{0} {1}", in(reg) 4, in(reg) 5, out("rax") _);
+    }
+}
diff --git a/tests/pretty/asm-operand-order.rs b/tests/pretty/asm-operand-order.rs
new file mode 100644
index 000000000000..05a994e38544
--- /dev/null
+++ b/tests/pretty/asm-operand-order.rs
@@ -0,0 +1,13 @@
+//@ pretty-mode:expanded
+//@ pp-exact:asm-operand-order.pp
+//@ only-x86_64
+
+use std::arch::asm;
+
+pub fn main() {
+    unsafe {
+        asm!("{val}", out("rax") _, val = in(reg) 4);
+        asm!("{val}", out("rax") _, val = in(reg) 4, options(nostack));
+        asm!("{a} {b}", out("rax") _, a = in(reg) 4, b = in(reg) 5);
+    }
+}

From b3e4ebd9d27b1367016b1ff83e320d953383d3a5 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 19 Mar 2026 12:19:59 +0100
Subject: [PATCH 0658/1059] const validity checking: do not recurse to
 references inside MaybeDangling

---
 compiler/rustc_const_eval/src/interpret/validity.rs | 7 +++++--
 tests/ui/consts/const-eval/valid-const.rs           | 4 ++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 41a4cb2f23a1..83c684d5e7d8 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -680,8 +680,11 @@ fn check_safe_pointer(
                 format!("encountered a {ptr_kind} pointing to uninhabited type {ty}")
             )
         }
-        // Recursive checking
-        if let Some(ref_tracking) = self.ref_tracking.as_deref_mut() {
+
+        // Recursive checking (but not inside `MaybeDangling` of course).
+        if let Some(ref_tracking) = self.ref_tracking.as_deref_mut()
+            && !self.may_dangle
+        {
             // Proceed recursively even for ZST, no reason to skip them!
             // `!` is a ZST and we want to validate it.
             if let Some(ctfe_mode) = self.ctfe_mode {
diff --git a/tests/ui/consts/const-eval/valid-const.rs b/tests/ui/consts/const-eval/valid-const.rs
index 777484c6b092..6f92997c90d6 100644
--- a/tests/ui/consts/const-eval/valid-const.rs
+++ b/tests/ui/consts/const-eval/valid-const.rs
@@ -1,10 +1,12 @@
 //@ check-pass
 //
 // Some constants that *are* valid
+#![feature(maybe_dangling)]
 
 use std::mem;
 use std::ptr::NonNull;
 use std::num::NonZero;
+use std::mem::MaybeDangling;
 
 const NON_NULL_PTR1: NonNull<u8> = unsafe { mem::transmute(1usize) };
 const NON_NULL_PTR2: NonNull<u8> = unsafe { mem::transmute(&0) };
@@ -14,4 +16,6 @@
 
 const UNIT: () = ();
 
+const INVALID_INSIDE_MAYBE_DANGLING: MaybeDangling<&bool> = unsafe { std::mem::transmute(&5u8) };
+
 fn main() {}

From 1a1a0d2bb57cf7f41a02d6e5e214bad7a9080324 Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Thu, 19 Mar 2026 13:38:26 +0000
Subject: [PATCH 0659/1059] Update Clippy test expectations for or-pattern
 parenthesization
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The pretty printer now correctly parenthesizes or-patterns inside
`box` patterns, which changes the Clippy `unnested_or_patterns` lint
suggestion from `box box (0 | 2 | 4)` to `box (box (0 | 2 | 4))`.
The new output is more correct — the old suggestion was itself missing
parens and would have been parsed as `box (box 0) | 2 | 4`.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 src/tools/clippy/tests/ui/unnested_or_patterns2.fixed  | 2 +-
 src/tools/clippy/tests/ui/unnested_or_patterns2.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed b/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
index 2c794463457f..852c4ddcfd71 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
@@ -23,6 +23,6 @@ fn main() {
     //~^ unnested_or_patterns
     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
     //~^ unnested_or_patterns
-    if let box box (0 | 2 | 4) = Box::new(Box::new(0)) {}
+    if let box (box (0 | 2 | 4)) = Box::new(Box::new(0)) {}
     //~^ unnested_or_patterns
 }
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr b/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
index 3fc8fa174c93..3deef33cf258 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
@@ -93,7 +93,7 @@ LL |     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
 help: nest the patterns
    |
 LL -     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
-LL +     if let box box (0 | 2 | 4) = Box::new(Box::new(0)) {}
+LL +     if let box (box (0 | 2 | 4)) = Box::new(Box::new(0)) {}
    |
 
 error: aborting due to 8 previous errors

From b9cd5923aeec1b0d640ee2871b0a9c7cb2862531 Mon Sep 17 00:00:00 2001
From: xtqqczze <45661989+xtqqczze@users.noreply.github.com>
Date: Wed, 18 Mar 2026 03:19:41 +0000
Subject: [PATCH 0660/1059] Replace `truncate(0)` with `clear()`

---
 .../src/obligation_forest/mod.rs                   |  2 +-
 .../rustc_trait_selection/src/traits/fulfill.rs    |  2 +-
 library/std/src/io/buffered/tests.rs               | 14 +++++++-------
 library/std/src/io/tests.rs                        |  8 ++++----
 library/std/src/path.rs                            |  2 +-
 library/std/src/sys/args/uefi.rs                   |  2 +-
 library/std/src/sys/args/windows.rs                |  2 +-
 src/tools/compiletest/src/runtest/debuginfo.rs     |  2 +-
 src/tools/remote-test-server/src/main.rs           |  6 +++---
 9 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_data_structures/src/obligation_forest/mod.rs b/compiler/rustc_data_structures/src/obligation_forest/mod.rs
index 2c62034c6e87..83cfa027cc3d 100644
--- a/compiler/rustc_data_structures/src/obligation_forest/mod.rs
+++ b/compiler/rustc_data_structures/src/obligation_forest/mod.rs
@@ -702,7 +702,7 @@ fn compress(&mut self, mut outcome_cb: impl FnMut(&O)) {
             self.apply_rewrites(&node_rewrites);
         }
 
-        node_rewrites.truncate(0);
+        node_rewrites.clear();
         self.reused_node_vec = node_rewrites;
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 71a8e081146e..a575630a0503 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -349,7 +349,7 @@ fn process_obligation(
         &mut self,
         pending_obligation: &mut PendingPredicateObligation<'tcx>,
     ) -> ProcessResult<PendingPredicateObligation<'tcx>, FulfillmentErrorCode<'tcx>> {
-        pending_obligation.stalled_on.truncate(0);
+        pending_obligation.stalled_on.clear();
 
         let obligation = &mut pending_obligation.obligation;
 
diff --git a/library/std/src/io/buffered/tests.rs b/library/std/src/io/buffered/tests.rs
index 6ad4158b9290..e335d8afdc48 100644
--- a/library/std/src/io/buffered/tests.rs
+++ b/library/std/src/io/buffered/tests.rs
@@ -391,16 +391,16 @@ fn test_read_until() {
     let mut v = Vec::new();
     reader.read_until(0, &mut v).unwrap();
     assert_eq!(v, [0]);
-    v.truncate(0);
+    v.clear();
     reader.read_until(2, &mut v).unwrap();
     assert_eq!(v, [1, 2]);
-    v.truncate(0);
+    v.clear();
     reader.read_until(1, &mut v).unwrap();
     assert_eq!(v, [1]);
-    v.truncate(0);
+    v.clear();
     reader.read_until(8, &mut v).unwrap();
     assert_eq!(v, [0]);
-    v.truncate(0);
+    v.clear();
     reader.read_until(9, &mut v).unwrap();
     assert_eq!(v, []);
 }
@@ -429,13 +429,13 @@ fn test_read_line() {
     let mut s = String::new();
     reader.read_line(&mut s).unwrap();
     assert_eq!(s, "a\n");
-    s.truncate(0);
+    s.clear();
     reader.read_line(&mut s).unwrap();
     assert_eq!(s, "b\n");
-    s.truncate(0);
+    s.clear();
     reader.read_line(&mut s).unwrap();
     assert_eq!(s, "c");
-    s.truncate(0);
+    s.clear();
     reader.read_line(&mut s).unwrap();
     assert_eq!(s, "");
 }
diff --git a/library/std/src/io/tests.rs b/library/std/src/io/tests.rs
index b22988d4a8a9..a56359dae765 100644
--- a/library/std/src/io/tests.rs
+++ b/library/std/src/io/tests.rs
@@ -17,10 +17,10 @@ fn read_until() {
     let mut v = Vec::new();
     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
     assert_eq!(v, b"123");
-    v.truncate(0);
+    v.clear();
     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
     assert_eq!(v, b"3");
-    v.truncate(0);
+    v.clear();
     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
     assert_eq!(v, []);
 }
@@ -80,10 +80,10 @@ fn read_line() {
     let mut v = String::new();
     assert_eq!(buf.read_line(&mut v).unwrap(), 3);
     assert_eq!(v, "12\n");
-    v.truncate(0);
+    v.clear();
     assert_eq!(buf.read_line(&mut v).unwrap(), 1);
     assert_eq!(v, "\n");
-    v.truncate(0);
+    v.clear();
     assert_eq!(buf.read_line(&mut v).unwrap(), 0);
     assert_eq!(v, "");
 }
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 0b2b5f7e58f4..c0a77ef0b05c 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1364,7 +1364,7 @@ fn _push(&mut self, path: &Path) {
 
         // absolute `path` replaces `self`
         if need_clear {
-            self.inner.truncate(0);
+            self.inner.clear();
 
         // verbatim paths need . and .. removed
         } else if comps.prefix_verbatim() && !path.inner.is_empty() {
diff --git a/library/std/src/sys/args/uefi.rs b/library/std/src/sys/args/uefi.rs
index 02dada382eff..edf6f6873f8d 100644
--- a/library/std/src/sys/args/uefi.rs
+++ b/library/std/src/sys/args/uefi.rs
@@ -93,7 +93,7 @@ fn parse_lp_cmd_line(code_units: &[u16]) -> Option<Vec<OsString>> {
             // If not `in_quotes`, a space or tab ends the argument.
             SPACE if !in_quotes => {
                 ret_val.push(OsString::from(&cur[..]));
-                cur.truncate(0);
+                cur.clear();
 
                 // Skip whitespace.
                 while code_units_iter.next_if_eq(&Ok(SPACE)).is_some() {}
diff --git a/library/std/src/sys/args/windows.rs b/library/std/src/sys/args/windows.rs
index c1988657ff1b..ea22a98ac756 100644
--- a/library/std/src/sys/args/windows.rs
+++ b/library/std/src/sys/args/windows.rs
@@ -106,7 +106,7 @@ fn parse_lp_cmd_line<'a, F: Fn() -> OsString>(
             // If not `in_quotes`, a space or tab ends the argument.
             SPACE | TAB if !in_quotes => {
                 ret_val.push(OsString::from_wide(&cur[..]));
-                cur.truncate(0);
+                cur.clear();
 
                 // Skip whitespace.
                 code_units.advance_while(|w| w == SPACE || w == TAB);
diff --git a/src/tools/compiletest/src/runtest/debuginfo.rs b/src/tools/compiletest/src/runtest/debuginfo.rs
index 6534902e0940..8dfac2e3abb2 100644
--- a/src/tools/compiletest/src/runtest/debuginfo.rs
+++ b/src/tools/compiletest/src/runtest/debuginfo.rs
@@ -191,7 +191,7 @@ fn run_debuginfo_gdb_test(&self) {
             let mut stdout = BufReader::new(adb.stdout.take().unwrap());
             let mut line = String::new();
             loop {
-                line.truncate(0);
+                line.clear();
                 stdout.read_line(&mut line).unwrap();
                 if line.starts_with("Listening on port 5039") {
                     break;
diff --git a/src/tools/remote-test-server/src/main.rs b/src/tools/remote-test-server/src/main.rs
index b4d30289cabb..cc8edfcdac61 100644
--- a/src/tools/remote-test-server/src/main.rs
+++ b/src/tools/remote-test-server/src/main.rs
@@ -211,12 +211,12 @@ fn handle_run(socket: TcpStream, work: &Path, tmp: &Path, lock: &Mutex<()>, conf
     let mut args = Vec::new();
     while t!(reader.read_until(0, &mut arg)) > 1 {
         args.push(t!(str::from_utf8(&arg[..arg.len() - 1])).to_string());
-        arg.truncate(0);
+        arg.clear();
     }
 
     // Next we'll get a bunch of env vars in pairs delimited by 0s as well
     let mut env = Vec::new();
-    arg.truncate(0);
+    arg.clear();
     while t!(reader.read_until(0, &mut arg)) > 1 {
         let key_len = arg.len() - 1;
         let val_len = t!(reader.read_until(0, &mut arg)) - 1;
@@ -227,7 +227,7 @@ fn handle_run(socket: TcpStream, work: &Path, tmp: &Path, lock: &Mutex<()>, conf
             let val = t!(str::from_utf8(val)).to_string();
             env.push((key, val));
         }
-        arg.truncate(0);
+        arg.clear();
     }
 
     // The section of code from here down to where we drop the lock is going to

From adacd90f29c381c2e3876f356dda7575a96ffef5 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Thu, 19 Mar 2026 14:37:13 +0000
Subject: [PATCH 0661/1059] move many `ui/macros` tests from `run-` to
 `check-pass`

---
 tests/ui/macros/issue-2804.rs                                   | 2 +-
 tests/ui/macros/issue-33185.rs                                  | 2 +-
 tests/ui/macros/issue-40469.rs                                  | 2 +-
 tests/ui/macros/issue-40770.rs                                  | 2 +-
 tests/ui/macros/macro-attribute-expansion.rs                    | 2 +-
 tests/ui/macros/macro-attributes.rs                             | 2 +-
 tests/ui/macros/macro-delimiter-significance.rs                 | 2 +-
 tests/ui/macros/macro-doc-comments.rs                           | 2 +-
 tests/ui/macros/macro-doc-escapes.rs                            | 2 +-
 tests/ui/macros/macro-follow-rpass.rs                           | 2 +-
 tests/ui/macros/macro-followed-by-seq.rs                        | 2 +-
 tests/ui/macros/macro-in-fn.rs                                  | 2 +-
 .../macros/macro-invocation-in-count-expr-fixed-array-type.rs   | 2 +-
 tests/ui/macros/macro-multiple-items.rs                         | 2 +-
 tests/ui/macros/macro-named-default.rs                          | 2 +-
 tests/ui/macros/macro-nt-list.rs                                | 2 +-
 tests/ui/macros/macro-pat-follow-2018.rs                        | 2 +-
 tests/ui/macros/macro-pub-matcher.rs                            | 2 +-
 tests/ui/macros/macro-seq-followed-by-seq.rs                    | 2 +-
 tests/ui/macros/macro-use-all-and-none.rs                       | 2 +-
 tests/ui/macros/macro-use-all.rs                                | 2 +-
 tests/ui/macros/macro-use-both.rs                               | 2 +-
 tests/ui/macros/macro-use-one.rs                                | 2 +-
 tests/ui/macros/parse-complex-macro-invoc-op.rs                 | 2 +-
 tests/ui/macros/pub-item-inside-macro.rs                        | 2 +-
 tests/ui/macros/pub-method-inside-macro.rs                      | 2 +-
 tests/ui/macros/semi-after-macro-ty.rs                          | 2 +-
 tests/ui/macros/two-macro-use.rs                                | 2 +-
 tests/ui/macros/type-macros-simple.rs                           | 2 +-
 tests/ui/macros/use-macro-self.rs                               | 2 +-
 30 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/tests/ui/macros/issue-2804.rs b/tests/ui/macros/issue-2804.rs
index 0b6f9487ece2..9f45df4a3178 100644
--- a/tests/ui/macros/issue-2804.rs
+++ b/tests/ui/macros/issue-2804.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
diff --git a/tests/ui/macros/issue-33185.rs b/tests/ui/macros/issue-33185.rs
index 8d7e305f1e35..5771b40809dc 100644
--- a/tests/ui/macros/issue-33185.rs
+++ b/tests/ui/macros/issue-33185.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 #[macro_export]
diff --git a/tests/ui/macros/issue-40469.rs b/tests/ui/macros/issue-40469.rs
index faa4c6581af7..4529e44e267d 100644
--- a/tests/ui/macros/issue-40469.rs
+++ b/tests/ui/macros/issue-40469.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/macros/issue-40770.rs b/tests/ui/macros/issue-40770.rs
index d90294acd251..028bd48b1be7 100644
--- a/tests/ui/macros/issue-40770.rs
+++ b/tests/ui/macros/issue-40770.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(unused_macros)]
 macro_rules! m {
     ($e:expr) => {
diff --git a/tests/ui/macros/macro-attribute-expansion.rs b/tests/ui/macros/macro-attribute-expansion.rs
index be682b38865d..255400e2679e 100644
--- a/tests/ui/macros/macro-attribute-expansion.rs
+++ b/tests/ui/macros/macro-attribute-expansion.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 macro_rules! descriptions {
     ($name:ident is $desc:expr) => {
         // Check that we will correctly expand attributes
diff --git a/tests/ui/macros/macro-attributes.rs b/tests/ui/macros/macro-attributes.rs
index 976d2cbcccdb..a25ed2ba7ef6 100644
--- a/tests/ui/macros/macro-attributes.rs
+++ b/tests/ui/macros/macro-attributes.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 
 macro_rules! compiles_fine {
     (#[$at:meta]) => {
diff --git a/tests/ui/macros/macro-delimiter-significance.rs b/tests/ui/macros/macro-delimiter-significance.rs
index 8b532e19196b..1947ecf9b22e 100644
--- a/tests/ui/macros/macro-delimiter-significance.rs
+++ b/tests/ui/macros/macro-delimiter-significance.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 fn main() {
     vec![1_usize, 2, 3].len();
 }
diff --git a/tests/ui/macros/macro-doc-comments.rs b/tests/ui/macros/macro-doc-comments.rs
index 47740e26fb6f..4622c3710e93 100644
--- a/tests/ui/macros/macro-doc-comments.rs
+++ b/tests/ui/macros/macro-doc-comments.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(non_snake_case)]
 
 macro_rules! doc {
diff --git a/tests/ui/macros/macro-doc-escapes.rs b/tests/ui/macros/macro-doc-escapes.rs
index 81c8d3383b57..77d9a5c048fa 100644
--- a/tests/ui/macros/macro-doc-escapes.rs
+++ b/tests/ui/macros/macro-doc-escapes.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 // When expanding a macro, documentation attributes (including documentation comments) must be
 // passed "as is" without being parsed. Otherwise, some text will be incorrectly interpreted as
 // escape sequences, leading to an ICE.
diff --git a/tests/ui/macros/macro-follow-rpass.rs b/tests/ui/macros/macro-follow-rpass.rs
index 8551b1887708..dfaacefc528a 100644
--- a/tests/ui/macros/macro-follow-rpass.rs
+++ b/tests/ui/macros/macro-follow-rpass.rs
@@ -1,5 +1,5 @@
 //@ edition:2015..2021
-//@ run-pass
+//@ check-pass
 #![allow(unused_macros)]
 // Check the macro follow sets (see corresponding cfail test).
 
diff --git a/tests/ui/macros/macro-followed-by-seq.rs b/tests/ui/macros/macro-followed-by-seq.rs
index f4756d42088a..3643836fa031 100644
--- a/tests/ui/macros/macro-followed-by-seq.rs
+++ b/tests/ui/macros/macro-followed-by-seq.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(unused_macros)]
 // Regression test for issue #25436: check that things which can be
 // followed by any token also permit X* to come afterwards.
diff --git a/tests/ui/macros/macro-in-fn.rs b/tests/ui/macros/macro-in-fn.rs
index 2ffa6b2e4572..48085b8b221b 100644
--- a/tests/ui/macros/macro-in-fn.rs
+++ b/tests/ui/macros/macro-in-fn.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![feature(decl_macro)]
 
 pub fn moo() {
diff --git a/tests/ui/macros/macro-invocation-in-count-expr-fixed-array-type.rs b/tests/ui/macros/macro-invocation-in-count-expr-fixed-array-type.rs
index e80c712b03dc..ed8974c23e71 100644
--- a/tests/ui/macros/macro-invocation-in-count-expr-fixed-array-type.rs
+++ b/tests/ui/macros/macro-invocation-in-count-expr-fixed-array-type.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 
 macro_rules! four {
     () => (4)
diff --git a/tests/ui/macros/macro-multiple-items.rs b/tests/ui/macros/macro-multiple-items.rs
index c746d1bc5188..46b561af4467 100644
--- a/tests/ui/macros/macro-multiple-items.rs
+++ b/tests/ui/macros/macro-multiple-items.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 macro_rules! make_foo {
     () => (
         struct Foo;
diff --git a/tests/ui/macros/macro-named-default.rs b/tests/ui/macros/macro-named-default.rs
index bca0e005083d..c7eac831cffb 100644
--- a/tests/ui/macros/macro-named-default.rs
+++ b/tests/ui/macros/macro-named-default.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 macro_rules! default {
     ($($x:tt)*) => { $($x)* }
 }
diff --git a/tests/ui/macros/macro-nt-list.rs b/tests/ui/macros/macro-nt-list.rs
index b7b260c5398c..56ea917c3be9 100644
--- a/tests/ui/macros/macro-nt-list.rs
+++ b/tests/ui/macros/macro-nt-list.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 
 macro_rules! list {
     ( ($($id:ident),*) ) => (());
diff --git a/tests/ui/macros/macro-pat-follow-2018.rs b/tests/ui/macros/macro-pat-follow-2018.rs
index 6dcb841fec15..b2a556fce6f9 100644
--- a/tests/ui/macros/macro-pat-follow-2018.rs
+++ b/tests/ui/macros/macro-pat-follow-2018.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ edition:2018
 
 macro_rules! pat_bar {
diff --git a/tests/ui/macros/macro-pub-matcher.rs b/tests/ui/macros/macro-pub-matcher.rs
index e0b03dbbeb1b..20cacab390d5 100644
--- a/tests/ui/macros/macro-pub-matcher.rs
+++ b/tests/ui/macros/macro-pub-matcher.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code, unused_imports, unused_macro_rules)]
 
 /**
diff --git a/tests/ui/macros/macro-seq-followed-by-seq.rs b/tests/ui/macros/macro-seq-followed-by-seq.rs
index 3661744284ee..cf5a1c117031 100644
--- a/tests/ui/macros/macro-seq-followed-by-seq.rs
+++ b/tests/ui/macros/macro-seq-followed-by-seq.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 // Test of allowing two sequences repetitions in a row,
 // functionality added as byproduct of RFC amendment #1384
 //   https://github.com/rust-lang/rfcs/pull/1384
diff --git a/tests/ui/macros/macro-use-all-and-none.rs b/tests/ui/macros/macro-use-all-and-none.rs
index f1acff484038..53d450ed8d58 100644
--- a/tests/ui/macros/macro-use-all-and-none.rs
+++ b/tests/ui/macros/macro-use-all-and-none.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ aux-build:two_macros-rpass.rs
 
 #![warn(unused_attributes)]
diff --git a/tests/ui/macros/macro-use-all.rs b/tests/ui/macros/macro-use-all.rs
index a7fd3dfa5ce6..06b96da7f8b1 100644
--- a/tests/ui/macros/macro-use-all.rs
+++ b/tests/ui/macros/macro-use-all.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ aux-build:two_macros.rs
 
 #[macro_use]
diff --git a/tests/ui/macros/macro-use-both.rs b/tests/ui/macros/macro-use-both.rs
index e49f346c8e3e..c41797513f6a 100644
--- a/tests/ui/macros/macro-use-both.rs
+++ b/tests/ui/macros/macro-use-both.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ aux-build:two_macros.rs
 
 #[macro_use(macro_one, macro_two)]
diff --git a/tests/ui/macros/macro-use-one.rs b/tests/ui/macros/macro-use-one.rs
index 2b048651cccc..93f7c212e001 100644
--- a/tests/ui/macros/macro-use-one.rs
+++ b/tests/ui/macros/macro-use-one.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ aux-build:two_macros.rs
 
 #[macro_use(macro_two)]
diff --git a/tests/ui/macros/parse-complex-macro-invoc-op.rs b/tests/ui/macros/parse-complex-macro-invoc-op.rs
index 2c384bdb42ef..bbb01facc624 100644
--- a/tests/ui/macros/parse-complex-macro-invoc-op.rs
+++ b/tests/ui/macros/parse-complex-macro-invoc-op.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(unused_must_use)]
 #![allow(dead_code)]
 #![allow(unused_assignments)]
diff --git a/tests/ui/macros/pub-item-inside-macro.rs b/tests/ui/macros/pub-item-inside-macro.rs
index c37945a2d672..679987ac1f4a 100644
--- a/tests/ui/macros/pub-item-inside-macro.rs
+++ b/tests/ui/macros/pub-item-inside-macro.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 // Issue #14660
 
 
diff --git a/tests/ui/macros/pub-method-inside-macro.rs b/tests/ui/macros/pub-method-inside-macro.rs
index dd4e6fda8be9..23d8c454d697 100644
--- a/tests/ui/macros/pub-method-inside-macro.rs
+++ b/tests/ui/macros/pub-method-inside-macro.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 // Issue #17436
 
 
diff --git a/tests/ui/macros/semi-after-macro-ty.rs b/tests/ui/macros/semi-after-macro-ty.rs
index 60afc3b44506..ff026c53b1d7 100644
--- a/tests/ui/macros/semi-after-macro-ty.rs
+++ b/tests/ui/macros/semi-after-macro-ty.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 macro_rules! foo {
     ($t:ty; $p:path;) => {}
 }
diff --git a/tests/ui/macros/two-macro-use.rs b/tests/ui/macros/two-macro-use.rs
index 8bb3c9da3051..733853f8d234 100644
--- a/tests/ui/macros/two-macro-use.rs
+++ b/tests/ui/macros/two-macro-use.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 //@ aux-build:two_macros.rs
 
 #[macro_use(macro_one)]
diff --git a/tests/ui/macros/type-macros-simple.rs b/tests/ui/macros/type-macros-simple.rs
index d189b881f7dd..800a796491be 100644
--- a/tests/ui/macros/type-macros-simple.rs
+++ b/tests/ui/macros/type-macros-simple.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(unused_variables)]
 #![allow(non_local_definitions)]
diff --git a/tests/ui/macros/use-macro-self.rs b/tests/ui/macros/use-macro-self.rs
index 1d15b8386af9..cf5a410c6edf 100644
--- a/tests/ui/macros/use-macro-self.rs
+++ b/tests/ui/macros/use-macro-self.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(unused_imports)]
 //@ aux-build:use-macro-self.rs
 

From 9ce6863063006951d678d0ec8a9e037731478609 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Thu, 19 Mar 2026 14:40:33 +0000
Subject: [PATCH 0662/1059] merge `die-macro` tests into `panic-macro-basic.rs`

---
 tests/ui/macros/die-macro-2.rs                   |  7 -------
 tests/ui/macros/die-macro-pure.rs                | 11 -----------
 tests/ui/macros/die-macro.rs                     | 16 ----------------
 .../{die-macro-expr.rs => panic-macro-basic.rs}  |  9 ++++++++-
 4 files changed, 8 insertions(+), 35 deletions(-)
 delete mode 100644 tests/ui/macros/die-macro-2.rs
 delete mode 100644 tests/ui/macros/die-macro-pure.rs
 delete mode 100644 tests/ui/macros/die-macro.rs
 rename tests/ui/macros/{die-macro-expr.rs => panic-macro-basic.rs} (53%)

diff --git a/tests/ui/macros/die-macro-2.rs b/tests/ui/macros/die-macro-2.rs
deleted file mode 100644
index d802f189ce1a..000000000000
--- a/tests/ui/macros/die-macro-2.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-fail
-//@ error-pattern:test
-//@ needs-subprocess
-
-fn main() {
-    panic!("test");
-}
diff --git a/tests/ui/macros/die-macro-pure.rs b/tests/ui/macros/die-macro-pure.rs
deleted file mode 100644
index d84787705a1a..000000000000
--- a/tests/ui/macros/die-macro-pure.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-fail
-//@ error-pattern:test
-//@ needs-subprocess
-
-fn f() {
-    panic!("test");
-}
-
-fn main() {
-    f();
-}
diff --git a/tests/ui/macros/die-macro.rs b/tests/ui/macros/die-macro.rs
deleted file mode 100644
index b717eed3fb43..000000000000
--- a/tests/ui/macros/die-macro.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-// Just testing that panic!() type checks in statement or expr
-
-
-#![allow(unreachable_code)]
-
-fn f() {
-    panic!();
-
-    let _x: isize = panic!();
-}
-
-pub fn main() {
-
-}
diff --git a/tests/ui/macros/die-macro-expr.rs b/tests/ui/macros/panic-macro-basic.rs
similarity index 53%
rename from tests/ui/macros/die-macro-expr.rs
rename to tests/ui/macros/panic-macro-basic.rs
index f4fefb0ca37d..96ed4265ef6e 100644
--- a/tests/ui/macros/die-macro-expr.rs
+++ b/tests/ui/macros/panic-macro-basic.rs
@@ -1,7 +1,14 @@
 //@ run-fail
 //@ error-pattern:test
 //@ needs-subprocess
+// Just testing that panic!() type checks in statement or expr
+
+fn f() {
+    let __isize: isize = panic!("test");
+
+    panic!();
+}
 
 fn main() {
-    let __isize: isize = panic!("test");
+    f();
 }

From 05834b2d6b8c584314dcc7d91d638bd376ce267c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 19 Mar 2026 15:39:20 +0100
Subject: [PATCH 0663/1059] improve validation error messages: show surrounding
 type, and more info on dyn-downcast

---
 .../src/const_eval/eval_queries.rs            |   2 +-
 .../src/interpret/validity.rs                 |  91 +++++++++-------
 .../rustc_middle/src/mir/interpret/error.rs   |  15 ++-
 .../libc-read-and-uninit-premature-eof.stderr |   2 +-
 .../fail/branchless-select-i128-pointer.rs    |   2 +-
 .../branchless-select-i128-pointer.stderr     |   2 +-
 .../deref_dangling_box.stderr                 |   2 +-
 .../deref_dangling_ref.stderr                 |   2 +-
 .../fail/dangling_pointers/dyn_size.stderr    |   2 +-
 .../fail/dyn-upcast-nop-wrong-trait.stderr    |   2 +-
 .../typed-swap-invalid-array.stderr           |   2 +-
 .../typed-swap-invalid-scalar.left.stderr     |   2 +-
 .../typed-swap-invalid-scalar.right.stderr    |   2 +-
 .../intrinsics/uninit_uninhabited_type.stderr |   2 +-
 .../tests/fail/intrinsics/zero_fn_ptr.stderr  |   2 +-
 .../miri/tests/fail/issue-miri-1112.stderr    |   2 +-
 .../match/closures/deref-in-pattern.stderr    |   2 +-
 .../match/closures/partial-pattern.stderr     |   2 +-
 .../int_copy_looses_provenance0.stderr        |   2 +-
 .../int_copy_looses_provenance1.stderr        |   2 +-
 .../int_copy_looses_provenance2.stderr        |   2 +-
 .../tests/fail/storage-live-resets-var.stderr |   2 +-
 .../unaligned_pointers/drop_in_place.stderr   |   2 +-
 .../unaligned_pointers/dyn_alignment.stderr   |   2 +-
 .../maybe_dangling_unalighed.rs               |   2 +-
 .../maybe_dangling_unalighed.stderr           |   2 +-
 .../reference_to_packed.stderr                |   2 +-
 .../unaligned_ref_addr_of.stderr              |   2 +-
 .../uninit/padding-struct-in-union.stderr     |   2 +-
 .../tests/fail/uninit/padding-union.stderr    |   2 +-
 .../uninit-after-aggregate-assign.stderr      |   2 +-
 .../box-custom-alloc-dangling-ptr.stderr      |   2 +-
 .../box-custom-alloc-invalid-alloc.stderr     |   2 +-
 .../cast_fn_ptr_invalid_callee_arg.stderr     |   2 +-
 .../cast_fn_ptr_invalid_callee_ret.stderr     |   2 +-
 .../cast_fn_ptr_invalid_caller_arg.stderr     |   2 +-
 .../cast_fn_ptr_invalid_caller_ret.stderr     |   2 +-
 .../tests/fail/validity/dangling_ref1.stderr  |   2 +-
 .../tests/fail/validity/dangling_ref2.stderr  |   2 +-
 .../tests/fail/validity/dangling_ref3.stderr  |   2 +-
 .../dyn-transmute-inner-binder.stderr         |   2 +-
 .../tests/fail/validity/invalid_bool.stderr   |   2 +-
 .../fail/validity/invalid_bool_uninit.stderr  |   2 +-
 .../tests/fail/validity/invalid_char.stderr   |   2 +-
 .../fail/validity/invalid_char_uninit.stderr  |   2 +-
 .../tests/fail/validity/invalid_enum_tag.rs   |   2 +-
 .../fail/validity/invalid_enum_tag.stderr     |   2 +-
 .../fail/validity/invalid_fnptr_null.stderr   |   2 +-
 .../fail/validity/invalid_fnptr_uninit.stderr |   2 +-
 .../fail/validity/invalid_wide_raw.stderr     |   2 +-
 .../match_binder_checks_validity1.stderr      |   2 +-
 .../match_binder_checks_validity2.stderr      |   2 +-
 .../fail/validity/maybe_dangling_null.rs      |   2 +-
 .../fail/validity/maybe_dangling_null.stderr  |   2 +-
 .../miri/tests/fail/validity/nonzero.stderr   |   2 +-
 .../recursive-validity-box-bool.stderr        |   2 +-
 .../recursive-validity-ref-bool.stderr        |   2 +-
 .../fail/validity/ref_to_uninhabited1.stderr  |   2 +-
 .../fail/validity/ref_to_uninhabited2.stderr  |   2 +-
 .../tests/fail/validity/too-big-slice.stderr  |   2 +-
 .../fail/validity/too-big-unsized.stderr      |   2 +-
 .../fail/validity/transmute_through_ptr.rs    |   2 +-
 .../validity/transmute_through_ptr.stderr     |   2 +-
 .../fail/validity/uninhabited_variant.stderr  |   2 +-
 .../tests/fail/validity/uninit_float.stderr   |   2 +-
 .../tests/fail/validity/uninit_integer.stderr |   2 +-
 .../tests/fail/validity/uninit_raw_ptr.stderr |   2 +-
 .../wrong-dyn-trait-assoc-type.stderr         |   2 +-
 .../validity/wrong-dyn-trait-generic.stderr   |   2 +-
 .../fail/validity/wrong-dyn-trait.stderr      |   2 +-
 .../tests/native-lib/fail/invalid_retval.rs   |   2 +-
 .../native-lib/fail/invalid_retval.stderr     |   2 +-
 .../native-lib/fail/uninit_struct.stderr      |   2 +-
 .../invalid-patterns.32bit.stderr             |   4 +-
 .../invalid-patterns.64bit.stderr             |   4 +-
 tests/ui/const-ptr/forbidden_slices.stderr    |  26 ++---
 .../heap/alloc_intrinsic_uninit.32bit.stderr  |   2 +-
 .../heap/alloc_intrinsic_uninit.64bit.stderr  |   2 +-
 .../heap/dealloc_intrinsic_dangling.stderr    |   2 +-
 .../consts/const-eval/raw-bytes.32bit.stderr  | 100 +++++++++---------
 .../consts/const-eval/raw-bytes.64bit.stderr  | 100 +++++++++---------
 tests/ui/consts/const-eval/raw-bytes.rs       |   4 +-
 .../consts/const-eval/transmute-const.stderr  |   2 +-
 tests/ui/consts/const-eval/ub-enum.stderr     |  14 +--
 .../ub-incorrect-vtable.32bit.stderr          |  12 +--
 .../ub-incorrect-vtable.64bit.stderr          |  12 +--
 tests/ui/consts/const-eval/ub-int-array.rs    |   6 +-
 .../ui/consts/const-eval/ub-int-array.stderr  |   6 +-
 tests/ui/consts/const-eval/ub-nonnull.stderr  |  14 +--
 tests/ui/consts/const-eval/ub-ref-ptr.rs      |   4 +-
 tests/ui/consts/const-eval/ub-ref-ptr.stderr  |  24 ++---
 .../ui/consts/const-eval/ub-uninhabit.stderr  |   8 +-
 .../consts/const-eval/ub-upvars.32bit.stderr  |   2 +-
 .../consts/const-eval/ub-upvars.64bit.stderr  |   2 +-
 tests/ui/consts/const-eval/ub-wide-ptr.stderr |  46 ++++----
 .../consts/const-eval/union-ub.32bit.stderr   |   2 +-
 .../consts/const-eval/union-ub.64bit.stderr   |   2 +-
 .../validate_uninhabited_zsts.stderr          |   4 +-
 .../const-mut-refs/mut_ref_in_final.stderr    |  12 +--
 .../const_refs_to_static_fail_invalid.stderr  |   2 +-
 tests/ui/consts/const_transmute_type_id7.rs   |   1 +
 .../ui/consts/const_transmute_type_id7.stderr |   4 +-
 tests/ui/consts/dangling-alloc-id-ice.stderr  |   2 +-
 .../dangling-zst-ice-issue-126393.stderr      |   2 +-
 .../detect-extra-ub.with_flag.stderr          |  18 ++--
 .../interior-mut-const-via-union.32bit.stderr |   2 +-
 .../interior-mut-const-via-union.64bit.stderr |   2 +-
 tests/ui/consts/issue-63952.32bit.stderr      |   2 +-
 tests/ui/consts/issue-63952.64bit.stderr      |   2 +-
 tests/ui/consts/issue-64506.stderr            |   2 +-
 tests/ui/consts/issue-79690.64bit.stderr      |   2 +-
 .../miri_unleashed/mutable_references.stderr  |  14 +--
 .../static-no-inner-mut.32bit.stderr          |   8 +-
 .../static-no-inner-mut.64bit.stderr          |   8 +-
 tests/ui/consts/validate_never_arrays.stderr  |   6 +-
 tests/ui/statics/mutable_memory_validation.rs |   2 +-
 .../statics/mutable_memory_validation.stderr  |   2 +-
 tests/ui/statics/uninhabited-static.stderr    |   4 +-
 tests/ui/type/pattern_types/validity.rs       |  10 +-
 tests/ui/type/pattern_types/validity.stderr   |  10 +-
 120 files changed, 397 insertions(+), 372 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 2dbf2cc91058..f1a8daada043 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -425,7 +425,7 @@ fn const_validate_mplace<'tcx>(
     cid: GlobalId<'tcx>,
 ) -> Result<(), ErrorHandled> {
     let alloc_id = mplace.ptr().provenance.unwrap().alloc_id();
-    let mut ref_tracking = RefTracking::new(mplace.clone());
+    let mut ref_tracking = RefTracking::new(mplace.clone(), mplace.layout.ty);
     let mut inner = false;
     while let Some((mplace, path)) = ref_tracking.next() {
         let mode = match ecx.tcx.static_mutability(cid.instance.def_id()) {
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 41a4cb2f23a1..d29a26e4d442 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -47,9 +47,9 @@
 macro_rules! err_validation_failure {
     ($where:expr,  $msg:expr ) => {{
         let where_ = &$where;
-        let path = if !where_.is_empty() {
+        let path = if !where_.projs.is_empty() {
             let mut path = String::new();
-            write_path(&mut path, where_);
+            write_path(&mut path, &where_.projs);
             Some(path)
         } else {
             None
@@ -59,6 +59,7 @@ macro_rules! err_validation_failure {
         use ValidationErrorKind::*;
         let msg = ValidationErrorKind::from($msg);
         err_ub!(ValidationError {
+            orig_ty: where_.orig_ty,
             path,
             ptr_bytes_warning: msg.ptr_bytes_warning(),
             msg: msg.to_string(),
@@ -236,7 +237,7 @@ fn fmt_range(r: WrappingRange, max_hi: u128) -> String {
 /// So we track a `Vec<PathElem>` where `PathElem` contains all the data we
 /// need to later print something for the user.
 #[derive(Copy, Clone, Debug)]
-pub enum PathElem {
+pub enum PathElem<'tcx> {
     Field(Symbol),
     Variant(Symbol),
     CoroutineState(VariantIdx),
@@ -246,10 +247,22 @@ pub enum PathElem {
     Deref,
     EnumTag,
     CoroutineTag,
-    DynDowncast,
+    DynDowncast(Ty<'tcx>),
     Vtable,
 }
 
+#[derive(Clone, Debug)]
+pub struct Path<'tcx> {
+    orig_ty: Ty<'tcx>,
+    projs: Vec<PathElem<'tcx>>,
+}
+
+impl<'tcx> Path<'tcx> {
+    fn new(ty: Ty<'tcx>) -> Self {
+        Self { orig_ty: ty, projs: vec![] }
+    }
+}
+
 /// Extra things to check for during validation of CTFE results.
 #[derive(Copy, Clone)]
 pub enum CtfeValidationMode {
@@ -282,16 +295,10 @@ pub struct RefTracking<T, PATH = ()> {
     todo: Vec<(T, PATH)>,
 }
 
-impl<T: Clone + Eq + Hash + std::fmt::Debug, PATH: Default> RefTracking<T, PATH> {
+impl<T: Clone + Eq + Hash + std::fmt::Debug, PATH> RefTracking<T, PATH> {
     pub fn empty() -> Self {
         RefTracking { seen: FxHashSet::default(), todo: vec![] }
     }
-    pub fn new(val: T) -> Self {
-        let mut ref_tracking_for_consts =
-            RefTracking { seen: FxHashSet::default(), todo: vec![(val.clone(), PATH::default())] };
-        ref_tracking_for_consts.seen.insert(val);
-        ref_tracking_for_consts
-    }
     pub fn next(&mut self) -> Option<(T, PATH)> {
         self.todo.pop()
     }
@@ -306,8 +313,17 @@ fn track(&mut self, val: T, path: impl FnOnce() -> PATH) {
     }
 }
 
+impl<'tcx, T: Clone + Eq + Hash + std::fmt::Debug> RefTracking<T, Path<'tcx>> {
+    pub fn new(val: T, ty: Ty<'tcx>) -> Self {
+        let mut ref_tracking_for_consts =
+            RefTracking { seen: FxHashSet::default(), todo: vec![(val.clone(), Path::new(ty))] };
+        ref_tracking_for_consts.seen.insert(val);
+        ref_tracking_for_consts
+    }
+}
+
 /// Format a path
-fn write_path(out: &mut String, path: &[PathElem]) {
+fn write_path(out: &mut String, path: &[PathElem<'_>]) {
     use self::PathElem::*;
 
     for elem in path.iter() {
@@ -325,7 +341,7 @@ fn write_path(out: &mut String, path: &[PathElem]) {
             // even use the usual syntax because we are just showing the projections,
             // not the root.
             Deref => write!(out, ".<deref>"),
-            DynDowncast => write!(out, ".<dyn-downcast>"),
+            DynDowncast(ty) => write!(out, ".<dyn-downcast({ty})>"),
             Vtable => write!(out, ".<vtable>"),
         }
         .unwrap()
@@ -384,10 +400,9 @@ fn add_range(&mut self, offset: Size, size: Size) {
 
 struct ValidityVisitor<'rt, 'tcx, M: Machine<'tcx>> {
     /// The `path` may be pushed to, but the part that is present when a function
-    /// starts must not be changed!  `visit_fields` and `visit_array` rely on
-    /// this stack discipline.
-    path: Vec<PathElem>,
-    ref_tracking: Option<&'rt mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Vec<PathElem>>>,
+    /// starts must not be changed!  `with_elem` relies on this stack discipline.
+    path: Path<'tcx>,
+    ref_tracking: Option<&'rt mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Path<'tcx>>>,
     /// `None` indicates this is not validating for CTFE (but for runtime).
     ctfe_mode: Option<CtfeValidationMode>,
     ecx: &'rt mut InterpCx<'tcx, M>,
@@ -406,7 +421,12 @@ struct ValidityVisitor<'rt, 'tcx, M: Machine<'tcx>> {
 }
 
 impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
-    fn aggregate_field_path_elem(&mut self, layout: TyAndLayout<'tcx>, field: usize) -> PathElem {
+    fn aggregate_field_path_elem(
+        &mut self,
+        layout: TyAndLayout<'tcx>,
+        field: usize,
+        field_ty: Ty<'tcx>,
+    ) -> PathElem<'tcx> {
         // First, check if we are projecting to a variant.
         match layout.variants {
             Variants::Multiple { tag_field, .. } => {
@@ -476,7 +496,7 @@ fn aggregate_field_path_elem(&mut self, layout: TyAndLayout<'tcx>, field: usize)
             // dyn traits
             ty::Dynamic(..) => {
                 assert_eq!(field, 0);
-                PathElem::DynDowncast
+                PathElem::DynDowncast(field_ty)
             }
 
             // nothing else has an aggregate layout
@@ -486,17 +506,17 @@ fn aggregate_field_path_elem(&mut self, layout: TyAndLayout<'tcx>, field: usize)
 
     fn with_elem<R>(
         &mut self,
-        elem: PathElem,
+        elem: PathElem<'tcx>,
         f: impl FnOnce(&mut Self) -> InterpResult<'tcx, R>,
     ) -> InterpResult<'tcx, R> {
         // Remember the old state
-        let path_len = self.path.len();
+        let path_len = self.path.projs.len();
         // Record new element
-        self.path.push(elem);
+        self.path.projs.push(elem);
         // Perform operation
         let r = f(self)?;
         // Undo changes
-        self.path.truncate(path_len);
+        self.path.projs.truncate(path_len);
         // Done
         interp_ok(r)
     }
@@ -795,10 +815,10 @@ fn check_safe_pointer(
             ref_tracking.track(place, || {
                 // We need to clone the path anyway, make sure it gets created
                 // with enough space for the additional `Deref`.
-                let mut new_path = Vec::with_capacity(path.len() + 1);
-                new_path.extend(path);
-                new_path.push(PathElem::Deref);
-                new_path
+                let mut new_projs = Vec::with_capacity(path.projs.len() + 1);
+                new_projs.extend(&path.projs);
+                new_projs.push(PathElem::Deref);
+                Path { projs: new_projs, orig_ty: path.orig_ty }
             });
         }
         interp_ok(())
@@ -1219,7 +1239,7 @@ fn visit_field(
         field: usize,
         new_val: &PlaceTy<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx> {
-        let elem = self.aggregate_field_path_elem(old_val.layout, field);
+        let elem = self.aggregate_field_path_elem(old_val.layout, field, new_val.layout.ty);
         self.with_elem(elem, move |this| this.visit_value(new_val))
     }
 
@@ -1384,7 +1404,7 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                                 access.bad.start.bytes() / layout.size.bytes(),
                             )
                             .unwrap();
-                            self.path.push(PathElem::ArrayElem(i));
+                            self.path.projs.push(PathElem::ArrayElem(i));
 
                             if matches!(kind, Ub(InvalidUninitBytes(_))) {
                                 err_validation_failure!(self.path, Uninit { expected })
@@ -1511,8 +1531,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     fn validate_operand_internal(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
-        path: Vec<PathElem>,
-        ref_tracking: Option<&mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Vec<PathElem>>>,
+        path: Path<'tcx>,
+        ref_tracking: Option<&mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Path<'tcx>>>,
         ctfe_mode: Option<CtfeValidationMode>,
         reset_provenance_and_padding: bool,
     ) -> InterpResult<'tcx> {
@@ -1565,8 +1585,8 @@ fn validate_operand_internal(
     pub(crate) fn const_validate_operand(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
-        path: Vec<PathElem>,
-        ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Vec<PathElem>>,
+        path: Path<'tcx>,
+        ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Path<'tcx>>,
         ctfe_mode: CtfeValidationMode,
     ) -> InterpResult<'tcx> {
         self.validate_operand_internal(
@@ -1595,14 +1615,13 @@ pub fn validate_operand(
             reset_provenance_and_padding,
             ?val,
         );
-
         // Note that we *could* actually be in CTFE here with `-Zextra-const-ub-checks`, but it's
         // still correct to not use `ctfe_mode`: that mode is for validation of the final constant
         // value, it rules out things like `UnsafeCell` in awkward places.
         if !recursive {
             return self.validate_operand_internal(
                 val,
-                vec![],
+                Path::new(val.layout.ty),
                 None,
                 None,
                 reset_provenance_and_padding,
@@ -1612,7 +1631,7 @@ pub fn validate_operand(
         let mut ref_tracking = RefTracking::empty();
         self.validate_operand_internal(
             val,
-            vec![],
+            Path::new(val.layout.ty),
             Some(&mut ref_tracking),
             None,
             reset_provenance_and_padding,
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 2c3d114a0f25..6c7505a7cbbb 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -318,7 +318,12 @@ pub enum UndefinedBehaviorInfo<'tcx> {
     /// Free-form case. Only for errors that are never caught! Used by miri
     Ub(String),
     /// Validation error.
-    ValidationError { path: Option<String>, msg: String, ptr_bytes_warning: bool },
+    ValidationError {
+        orig_ty: Ty<'tcx>,
+        path: Option<String>,
+        msg: String,
+        ptr_bytes_warning: bool,
+    },
 
     /// Unreachable code was executed.
     Unreachable,
@@ -457,11 +462,11 @@ fn fmt_in_alloc_attempt(
         match self {
             Ub(msg) => write!(f, "{msg}"),
 
-            ValidationError { path: None, msg, .. } => {
-                write!(f, "constructing invalid value: {msg}")
+            ValidationError { orig_ty, path: None, msg, .. } => {
+                write!(f, "constructing invalid value of type {orig_ty}: {msg}")
             }
-            ValidationError { path: Some(path), msg, .. } => {
-                write!(f, "constructing invalid value at {path}: {msg}")
+            ValidationError { orig_ty, path: Some(path), msg, .. } => {
+                write!(f, "constructing invalid value of type {orig_ty}: at {path}, {msg}")
             }
 
             Unreachable => write!(f, "entering unreachable code"),
diff --git a/src/tools/miri/tests/fail-dep/libc/libc-read-and-uninit-premature-eof.stderr b/src/tools/miri/tests/fail-dep/libc/libc-read-and-uninit-premature-eof.stderr
index 9d5e119d1c37..214b626f4f69 100644
--- a/src/tools/miri/tests/fail-dep/libc/libc-read-and-uninit-premature-eof.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/libc-read-and-uninit-premature-eof.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [3]: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type [u8; 4]: at [3], encountered uninitialized memory, but expected an integer
   --> tests/fail-dep/libc/libc-read-and-uninit-premature-eof.rs:LL:CC
    |
 LL |         buf.assume_init();
diff --git a/src/tools/miri/tests/fail/branchless-select-i128-pointer.rs b/src/tools/miri/tests/fail/branchless-select-i128-pointer.rs
index 7147813c4b6c..b4259161df55 100644
--- a/src/tools/miri/tests/fail/branchless-select-i128-pointer.rs
+++ b/src/tools/miri/tests/fail/branchless-select-i128-pointer.rs
@@ -14,7 +14,7 @@ fn main() {
         // However, it drops provenance when transmuting to TwoPtrs, so this is UB.
         let val = unsafe {
             transmute::<_, &str>(
-                //~^ ERROR: constructing invalid value: encountered a dangling reference
+                //~^ ERROR: encountered a dangling reference
                 !mask & transmute::<_, TwoPtrs>("false !")
                     | mask & transmute::<_, TwoPtrs>("true !"),
             )
diff --git a/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr b/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
index abcaf90a1ec3..83dc2ddf2904 100644
--- a/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
+++ b/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference ($HEX[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &str: encountered a dangling reference ($HEX[noalloc] has no provenance)
   --> tests/fail/branchless-select-i128-pointer.rs:LL:CC
    |
 LL | /             transmute::<_, &str>(
diff --git a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
index 0ae38c3b326f..64671315fbec 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling box (0x18[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<i32>: encountered a dangling box (0x18[noalloc] has no provenance)
   --> tests/fail/dangling_pointers/deref_dangling_box.rs:LL:CC
    |
 LL |     let _val = unsafe { addr_of_mut!(**outer) };
diff --git a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
index c10dc19f3626..552094780ad1 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (0x18[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &mut i32: encountered a dangling reference (0x18[noalloc] has no provenance)
   --> tests/fail/dangling_pointers/deref_dangling_ref.rs:LL:CC
    |
 LL |     let _val = unsafe { addr_of_mut!(**outer) };
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr b/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
index 74102f7e1b5e..df82e089ccfb 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error: Undefined Behavior: constructing invalid value of type &SliceWithHead: encountered a dangling reference (going beyond the bounds of its allocation)
   --> tests/fail/dangling_pointers/dyn_size.rs:LL:CC
    |
 LL |     let _ptr = unsafe { &*ptr };
diff --git a/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr
index 65ad97f4911b..86a695f62fc0 100644
--- a/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr
+++ b/src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
+error: Undefined Behavior: constructing invalid value of type *const dyn std::fmt::Debug + std::marker::Send + std::marker::Sync: wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
   --> tests/fail/dyn-upcast-nop-wrong-trait.rs:LL:CC
    |
 LL |     let ptr: *const (dyn fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) };
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
index 6cdcd114d5cf..e366aa96a30a 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-array.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered 0x02, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type [bool; 100]: at [0], encountered 0x02, but expected a boolean
   --> tests/fail/intrinsics/typed-swap-invalid-array.rs:LL:CC
    |
 LL |         typed_swap_nonoverlapping(a, b);
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.left.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.left.stderr
index 223f7430b60a..58e20306ed1d 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.left.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.left.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0x02, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type bool: encountered 0x02, but expected a boolean
   --> tests/fail/intrinsics/typed-swap-invalid-scalar.rs:LL:CC
    |
 LL |         typed_swap_nonoverlapping(a, b);
diff --git a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.right.stderr b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.right.stderr
index 59e392085001..b5bf8d7256bf 100644
--- a/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.right.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/typed-swap-invalid-scalar.right.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0x03, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type bool: encountered 0x03, but expected a boolean
   --> tests/fail/intrinsics/typed-swap-invalid-scalar.rs:LL:CC
    |
 LL |         typed_swap_nonoverlapping(a, b);
diff --git a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
index d0f7cc1eacc2..47acb43ec0e9 100644
--- a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a value of the never type `!`
+error: Undefined Behavior: constructing invalid value of type !: encountered a value of the never type `!`
   --> tests/fail/intrinsics/uninit_uninhabited_type.rs:LL:CC
    |
 LL |     let _ = unsafe { std::mem::uninitialized::<!>() };
diff --git a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
index 1646721e2eba..ab6f91399af5 100644
--- a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a null function pointer
+error: Undefined Behavior: constructing invalid value of type fn(): encountered a null function pointer
   --> tests/fail/intrinsics/zero_fn_ptr.rs:LL:CC
    |
 LL |     let _ = unsafe { std::mem::zeroed::<fn()>() };
diff --git a/src/tools/miri/tests/fail/issue-miri-1112.stderr b/src/tools/miri/tests/fail/issue-miri-1112.stderr
index 0c5c6a94baf2..9873591c7d61 100644
--- a/src/tools/miri/tests/fail/issue-miri-1112.stderr
+++ b/src/tools/miri/tests/fail/issue-miri-1112.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered $HEX[ALLOC]<TAG>, but expected a vtable pointer
+error: Undefined Behavior: constructing invalid value of type *mut FunnyPointer: encountered $HEX[ALLOC]<TAG>, but expected a vtable pointer
   --> tests/fail/issue-miri-1112.rs:LL:CC
    |
 LL |         let obj = std::mem::transmute::<FatPointer, *mut FunnyPointer>(obj);
diff --git a/src/tools/miri/tests/fail/match/closures/deref-in-pattern.stderr b/src/tools/miri/tests/fail/match/closures/deref-in-pattern.stderr
index cbb74df5de77..9bbbc1b2d215 100644
--- a/src/tools/miri/tests/fail/match/closures/deref-in-pattern.stderr
+++ b/src/tools/miri/tests/fail/match/closures/deref-in-pattern.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (use-after-free)
+error: Undefined Behavior: constructing invalid value of type &u32: encountered a dangling reference (use-after-free)
   --> tests/fail/match/closures/deref-in-pattern.rs:LL:CC
    |
 LL |       let _ = || {
diff --git a/src/tools/miri/tests/fail/match/closures/partial-pattern.stderr b/src/tools/miri/tests/fail/match/closures/partial-pattern.stderr
index b8ca04559e23..ab50f9bb53c2 100644
--- a/src/tools/miri/tests/fail/match/closures/partial-pattern.stderr
+++ b/src/tools/miri/tests/fail/match/closures/partial-pattern.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (use-after-free)
+error: Undefined Behavior: constructing invalid value of type &u32: encountered a dangling reference (use-after-free)
   --> tests/fail/match/closures/partial-pattern.rs:LL:CC
    |
 LL |       let _ = || {
diff --git a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance0.stderr b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance0.stderr
index 6f097c336d2c..8a3448f048af 100644
--- a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance0.stderr
+++ b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance0.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference ($HEX[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference ($HEX[noalloc] has no provenance)
   --> tests/fail/provenance/int_copy_looses_provenance0.rs:LL:CC
    |
 LL |     let _val = unsafe { *ptr.read() };
diff --git a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance1.stderr b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance1.stderr
index f3d1d8c13dec..d4fb5b54fba3 100644
--- a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance1.stderr
+++ b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance1.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference ($HEX[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference ($HEX[noalloc] has no provenance)
   --> tests/fail/provenance/int_copy_looses_provenance1.rs:LL:CC
    |
 LL |     let _val = unsafe { *ptr.read() };
diff --git a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance2.stderr b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance2.stderr
index 837423292daa..bdeb8a4ef810 100644
--- a/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance2.stderr
+++ b/src/tools/miri/tests/fail/provenance/int_copy_looses_provenance2.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference ($HEX[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference ($HEX[noalloc] has no provenance)
   --> tests/fail/provenance/int_copy_looses_provenance2.rs:LL:CC
    |
 LL |     let _val = unsafe { *ptr.read() };
diff --git a/src/tools/miri/tests/fail/storage-live-resets-var.stderr b/src/tools/miri/tests/fail/storage-live-resets-var.stderr
index b3dd4ea0e848..418e5f5eec5b 100644
--- a/src/tools/miri/tests/fail/storage-live-resets-var.stderr
+++ b/src/tools/miri/tests/fail/storage-live-resets-var.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type i32: encountered uninitialized memory, but expected an integer
   --> tests/fail/storage-live-resets-var.rs:LL:CC
    |
 LL |             _val2 = val;
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr b/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
index 2b98a2f99cf9..ea4b495926c5 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+error: Undefined Behavior: constructing invalid value of type &mut PartialDrop: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> RUSTLIB/core/src/ptr/mod.rs:LL:CC
    |
 LL | / pub const unsafe fn drop_in_place<T: PointeeSized>(to_drop: *mut T)
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr b/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
index 0be5ef9ccf1b..7c85a3be5a26 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+error: Undefined Behavior: constructing invalid value of type &dyn std::fmt::Debug: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> tests/fail/unaligned_pointers/dyn_alignment.rs:LL:CC
    |
 LL |         let _ptr = &*ptr;
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
index 92917c88b731..38ec7a7c3f54 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
+++ b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs
@@ -10,6 +10,6 @@ fn main() {
     unsafe {
         let unaligned = MaybeDangling::new(a.as_ptr().byte_add(1));
         transmute::<MaybeDangling<*const u16>, MaybeDangling<&u16>>(unaligned)
-        //~^ ERROR: Undefined Behavior: constructing invalid value: encountered an unaligned reference
+        //~^ ERROR: encountered an unaligned reference
     };
 }
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
index 9a50a031cf96..190976c4f046 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/maybe_dangling_unalighed.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+error: Undefined Behavior: constructing invalid value of type std::mem::MaybeDangling<&u16>: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> tests/fail/unaligned_pointers/maybe_dangling_unalighed.rs:LL:CC
    |
 LL |         transmute::<MaybeDangling<*const u16>, MaybeDangling<&u16>>(unaligned)
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr b/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
index 2f3079383d12..d8252e51ae84 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> tests/fail/unaligned_pointers/reference_to_packed.rs:LL:CC
    |
 LL |     mem::transmute(x)
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
index dfd6c143dfe4..85273177b2ae 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
+error: Undefined Behavior: constructing invalid value of type &u32: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> tests/fail/unaligned_pointers/unaligned_ref_addr_of.rs:LL:CC
    |
 LL |         let _x = unsafe { &*x };
diff --git a/src/tools/miri/tests/fail/uninit/padding-struct-in-union.stderr b/src/tools/miri/tests/fail/uninit/padding-struct-in-union.stderr
index 2b0dbd38e6ed..cf22b56e40b2 100644
--- a/src/tools/miri/tests/fail/uninit/padding-struct-in-union.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-struct-in-union.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .bytes[2]: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type Bar: at .bytes[2], encountered uninitialized memory, but expected an integer
   --> tests/fail/uninit/padding-struct-in-union.rs:LL:CC
    |
 LL |     let _val = unsafe { (foobar.foo, foobar.bar) };
diff --git a/src/tools/miri/tests/fail/uninit/padding-union.stderr b/src/tools/miri/tests/fail/uninit/padding-union.stderr
index 30d0862df39a..7851bb60781d 100644
--- a/src/tools/miri/tests/fail/uninit/padding-union.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-union.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [1]: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type [u8; 4]: at [1], encountered uninitialized memory, but expected an integer
   --> tests/fail/uninit/padding-union.rs:LL:CC
    |
 LL |         let _val = *c;
diff --git a/src/tools/miri/tests/fail/uninit/uninit-after-aggregate-assign.stderr b/src/tools/miri/tests/fail/uninit/uninit-after-aggregate-assign.stderr
index e8deb5732a70..d4048bbaa176 100644
--- a/src/tools/miri/tests/fail/uninit/uninit-after-aggregate-assign.stderr
+++ b/src/tools/miri/tests/fail/uninit/uninit-after-aggregate-assign.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [1]: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type [u8; 4]: at [1], encountered uninitialized memory, but expected an integer
   --> tests/fail/uninit/uninit-after-aggregate-assign.rs:LL:CC
    |
 LL |             _val = *sptr2; // should hence be UB
diff --git a/src/tools/miri/tests/fail/validity/box-custom-alloc-dangling-ptr.stderr b/src/tools/miri/tests/fail/validity/box-custom-alloc-dangling-ptr.stderr
index b470e79232d5..3de7f6cf9913 100644
--- a/src/tools/miri/tests/fail/validity/box-custom-alloc-dangling-ptr.stderr
+++ b/src/tools/miri/tests/fail/validity/box-custom-alloc-dangling-ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling box (0x4[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<i32, MyAlloc>: encountered a dangling box (0x4[noalloc] has no provenance)
   --> tests/fail/validity/box-custom-alloc-dangling-ptr.rs:LL:CC
    |
 LL |         std::mem::transmute(b)
diff --git a/src/tools/miri/tests/fail/validity/box-custom-alloc-invalid-alloc.stderr b/src/tools/miri/tests/fail/validity/box-custom-alloc-invalid-alloc.stderr
index d7594ab53b5d..f2fa738cb6d3 100644
--- a/src/tools/miri/tests/fail/validity/box-custom-alloc-invalid-alloc.stderr
+++ b/src/tools/miri/tests/fail/validity/box-custom-alloc-invalid-alloc.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .1.my_alloc_field1: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<i32, MyAlloc>: at .1.my_alloc_field1, encountered uninitialized memory, but expected an integer
   --> tests/fail/validity/box-custom-alloc-invalid-alloc.rs:LL:CC
    |
 LL |         std::mem::transmute(b)
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
index 02e0ebe8abe6..ab65ee2ed4f4 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a null reference
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a null reference
   --> tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs:LL:CC
    |
 LL |     g(0usize as *const i32)
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
index 6fc1bc01655c..26db49e49f70 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error: Undefined Behavior: constructing invalid value of type std::num::NonZero<u32>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> tests/fail/validity/cast_fn_ptr_invalid_callee_ret.rs:LL:CC
    |
 LL |     f();
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
index 3b23a6cc4e85..cc4541bfd9ad 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error: Undefined Behavior: constructing invalid value of type std::num::NonZero<u32>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs:LL:CC
    |
 LL |             Call(_res = f(*ptr), ReturnTo(retblock), UnwindContinue())
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
index 03d6637cdb61..d92253293a9c 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a null reference
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a null reference
   --> tests/fail/validity/cast_fn_ptr_invalid_caller_ret.rs:LL:CC
    |
 LL |     let _x = g();
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref1.stderr b/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
index 05467c483f63..0020c641274e 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (0x10[noalloc] has no provenance)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference (0x10[noalloc] has no provenance)
   --> tests/fail/validity/dangling_ref1.rs:LL:CC
    |
 LL |     let _x: &i32 = unsafe { mem::transmute(16usize) };
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref2.stderr b/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
index eb1b6e2c5804..a1c8de2a2324 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference (going beyond the bounds of its allocation)
   --> tests/fail/validity/dangling_ref2.rs:LL:CC
    |
 LL |     let _x: &i32 = unsafe { mem::transmute(ptr) };
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref3.stderr b/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
index ec2238c8618f..0bf25982833f 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a dangling reference (use-after-free)
+error: Undefined Behavior: constructing invalid value of type &i32: encountered a dangling reference (use-after-free)
   --> tests/fail/validity/dangling_ref3.rs:LL:CC
    |
 LL |     let _x: &i32 = unsafe { mem::transmute(dangling()) };
diff --git a/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr
index 383c13cc2ab7..9df01f0d4d18 100644
--- a/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr
+++ b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<for<'a> fn(&'a ())>`, but encountered `Trait<fn(&())>`
+error: Undefined Behavior: constructing invalid value of type &dyn Trait<for<'a> fn(&'a ())>: wrong trait in wide pointer vtable: expected `Trait<for<'a> fn(&'a ())>`, but encountered `Trait<fn(&())>`
   --> tests/fail/validity/dyn-transmute-inner-binder.rs:LL:CC
    |
 LL |     let y: &dyn Trait<for<'a> fn(&'a ())> = unsafe { std::mem::transmute(x) };
diff --git a/src/tools/miri/tests/fail/validity/invalid_bool.stderr b/src/tools/miri/tests/fail/validity/invalid_bool.stderr
index b667449add68..a403c8dc9411 100644
--- a/src/tools/miri/tests/fail/validity/invalid_bool.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_bool.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0x02, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type bool: encountered 0x02, but expected a boolean
   --> tests/fail/validity/invalid_bool.rs:LL:CC
    |
 LL |     let _b = unsafe { std::mem::transmute::<u8, bool>(2) };
diff --git a/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
index 800bc4fc3163..86767c6eef0b 100644
--- a/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type [bool; 1]: at [0], encountered uninitialized memory, but expected a boolean
   --> tests/fail/validity/invalid_bool_uninit.rs:LL:CC
    |
 LL |     let _b = unsafe { MyUninit { init: () }.uninit };
diff --git a/src/tools/miri/tests/fail/validity/invalid_char.stderr b/src/tools/miri/tests/fail/validity/invalid_char.stderr
index 7f579882bea0..cb81038f8bd9 100644
--- a/src/tools/miri/tests/fail/validity/invalid_char.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_char.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered $HEX, but expected a valid unicode scalar value (in `0..=$HEX` but not in `$HEX..=$HEX`)
+error: Undefined Behavior: constructing invalid value of type char: encountered $HEX, but expected a valid unicode scalar value (in `0..=$HEX` but not in `$HEX..=$HEX`)
   --> tests/fail/validity/invalid_char.rs:LL:CC
    |
 LL |     let _val = match unsafe { std::mem::transmute::<i32, char>(-1) } {
diff --git a/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
index de8c1f39f248..78acda63d745 100644
--- a/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected a unicode scalar value
+error: Undefined Behavior: constructing invalid value of type [char; 1]: at [0], encountered uninitialized memory, but expected a unicode scalar value
   --> tests/fail/validity/invalid_char_uninit.rs:LL:CC
    |
 LL |     let _b = unsafe { MyUninit { init: () }.uninit };
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_tag.rs b/src/tools/miri/tests/fail/validity/invalid_enum_tag.rs
index fa115e1e78e4..9ef4a30e0d61 100644
--- a/src/tools/miri/tests/fail/validity/invalid_enum_tag.rs
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_tag.rs
@@ -7,5 +7,5 @@ pub enum Foo {
 }
 
 fn main() {
-    let _f = unsafe { std::mem::transmute::<i32, Foo>(42) }; //~ ERROR: constructing invalid value at .<enum-tag>: encountered 0x0000002a, but expected a valid enum tag
+    let _f = unsafe { std::mem::transmute::<i32, Foo>(42) }; //~ ERROR: constructing invalid value of type Foo: at .<enum-tag>, encountered 0x0000002a, but expected a valid enum tag
 }
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr b/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
index d7f299105205..bd182df5c1eb 100644
--- a/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .<enum-tag>: encountered $HEX, but expected a valid enum tag
+error: Undefined Behavior: constructing invalid value of type Foo: at .<enum-tag>, encountered $HEX, but expected a valid enum tag
   --> tests/fail/validity/invalid_enum_tag.rs:LL:CC
    |
 LL |     let _f = unsafe { std::mem::transmute::<i32, Foo>(42) };
diff --git a/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr b/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
index 20b2234e2ab2..6750dcb5b2bf 100644
--- a/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a null function pointer
+error: Undefined Behavior: constructing invalid value of type fn(): encountered a null function pointer
   --> tests/fail/validity/invalid_fnptr_null.rs:LL:CC
    |
 LL |     let _b: fn() = unsafe { std::mem::transmute(0usize) };
diff --git a/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
index 513b90b5d85e..60994e2c6d14 100644
--- a/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected a function pointer
+error: Undefined Behavior: constructing invalid value of type [fn(); 1]: at [0], encountered uninitialized memory, but expected a function pointer
   --> tests/fail/validity/invalid_fnptr_uninit.rs:LL:CC
    |
 LL |     let _b = unsafe { MyUninit { init: () }.uninit };
diff --git a/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr b/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
index a3c7815cf282..cb3c09816981 100644
--- a/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered null pointer, but expected a vtable pointer
+error: Undefined Behavior: constructing invalid value of type *mut dyn main::T: encountered null pointer, but expected a vtable pointer
   --> tests/fail/validity/invalid_wide_raw.rs:LL:CC
    |
 LL |     dbg!(S { x: unsafe { std::mem::transmute((0usize, 0usize)) } });
diff --git a/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr b/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
index 0ca8bc9f9bae..c905f3a65b62 100644
--- a/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
+++ b/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a value of uninhabited type `main::Void`
+error: Undefined Behavior: constructing invalid value of type main::Void: encountered a value of uninhabited type `main::Void`
   --> tests/fail/validity/match_binder_checks_validity1.rs:LL:CC
    |
 LL |             _x => println!("hi from the void!"),
diff --git a/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr b/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
index 281314e68d51..02caf64eae51 100644
--- a/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
+++ b/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0x03, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type bool: encountered 0x03, but expected a boolean
   --> tests/fail/validity/match_binder_checks_validity2.rs:LL:CC
    |
 LL |             _x => println!("hi from the void!"),
diff --git a/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs b/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
index 21dba864a3f1..9b3c80b97542 100644
--- a/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
+++ b/src/tools/miri/tests/fail/validity/maybe_dangling_null.rs
@@ -9,5 +9,5 @@
 fn main() {
     let null = MaybeDangling::new(null());
     unsafe { transmute::<MaybeDangling<*const u8>, MaybeDangling<&u8>>(null) };
-    //~^ ERROR: Undefined Behavior: constructing invalid value: encountered a null reference
+    //~^ ERROR: encountered a null reference
 }
diff --git a/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr b/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
index 650234777ccf..041a6b1b96e0 100644
--- a/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
+++ b/src/tools/miri/tests/fail/validity/maybe_dangling_null.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a null reference
+error: Undefined Behavior: constructing invalid value of type std::mem::MaybeDangling<&u8>: encountered a null reference
   --> tests/fail/validity/maybe_dangling_null.rs:LL:CC
    |
 LL |     unsafe { transmute::<MaybeDangling<*const u8>, MaybeDangling<&u8>>(null) };
diff --git a/src/tools/miri/tests/fail/validity/nonzero.stderr b/src/tools/miri/tests/fail/validity/nonzero.stderr
index e5fcdadb0d2c..2b352400b6e8 100644
--- a/src/tools/miri/tests/fail/validity/nonzero.stderr
+++ b/src/tools/miri/tests/fail/validity/nonzero.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error: Undefined Behavior: constructing invalid value of type NonZero<i32>: encountered 0, but expected something greater or equal to 1
   --> tests/fail/validity/nonzero.rs:LL:CC
    |
 LL |     let _x = Some(unsafe { NonZero(0) });
diff --git a/src/tools/miri/tests/fail/validity/recursive-validity-box-bool.stderr b/src/tools/miri/tests/fail/validity/recursive-validity-box-bool.stderr
index d658909efd93..9cb64307ccb1 100644
--- a/src/tools/miri/tests/fail/validity/recursive-validity-box-bool.stderr
+++ b/src/tools/miri/tests/fail/validity/recursive-validity-box-bool.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .<deref>: encountered 0x03, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<bool>: at .<deref>, encountered 0x03, but expected a boolean
   --> tests/fail/validity/recursive-validity-box-bool.rs:LL:CC
    |
 LL |     let xref_wrong_type: Box<bool> = unsafe { std::mem::transmute(xref) };
diff --git a/src/tools/miri/tests/fail/validity/recursive-validity-ref-bool.stderr b/src/tools/miri/tests/fail/validity/recursive-validity-ref-bool.stderr
index 112072679ea5..933e48a19d65 100644
--- a/src/tools/miri/tests/fail/validity/recursive-validity-ref-bool.stderr
+++ b/src/tools/miri/tests/fail/validity/recursive-validity-ref-bool.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .<deref>: encountered 0x03, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type &bool: at .<deref>, encountered 0x03, but expected a boolean
   --> tests/fail/validity/recursive-validity-ref-bool.rs:LL:CC
    |
 LL |     let xref_wrong_type: &bool = unsafe { std::mem::transmute(xref) };
diff --git a/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr b/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
index f1a059175566..645a9789207a 100644
--- a/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
+++ b/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a box pointing to uninhabited type !
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<!>: encountered a box pointing to uninhabited type !
   --> tests/fail/validity/ref_to_uninhabited1.rs:LL:CC
    |
 LL |         let x: Box<!> = transmute(&mut 42);
diff --git a/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr b/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
index 4d25de46ade8..37b265a771bc 100644
--- a/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
+++ b/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered a reference pointing to uninhabited type (i32, Void)
+error: Undefined Behavior: constructing invalid value of type &(i32, Void): encountered a reference pointing to uninhabited type (i32, Void)
   --> tests/fail/validity/ref_to_uninhabited2.rs:LL:CC
    |
 LL |         let _x: &(i32, Void) = transmute(&42);
diff --git a/src/tools/miri/tests/fail/validity/too-big-slice.stderr b/src/tools/miri/tests/fail/validity/too-big-slice.stderr
index 9d4c34748660..7377d207ffed 100644
--- a/src/tools/miri/tests/fail/validity/too-big-slice.stderr
+++ b/src/tools/miri/tests/fail/validity/too-big-slice.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error: Undefined Behavior: constructing invalid value of type &[u8]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> tests/fail/validity/too-big-slice.rs:LL:CC
    |
 LL | ...   let _x: &[u8] = mem::transmute((ptr, usize::MAX));
diff --git a/src/tools/miri/tests/fail/validity/too-big-unsized.stderr b/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
index 6c07308d08ca..0fc63395c601 100644
--- a/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
+++ b/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered invalid reference metadata: total size is bigger than largest supported object
+error: Undefined Behavior: constructing invalid value of type &MySlice: encountered invalid reference metadata: total size is bigger than largest supported object
   --> tests/fail/validity/too-big-unsized.rs:LL:CC
    |
 LL | ...   let _x: &MySlice = mem::transmute((ptr, isize::MAX as usize));
diff --git a/src/tools/miri/tests/fail/validity/transmute_through_ptr.rs b/src/tools/miri/tests/fail/validity/transmute_through_ptr.rs
index 60b3bdd6cd69..b49c7745f28e 100644
--- a/src/tools/miri/tests/fail/validity/transmute_through_ptr.rs
+++ b/src/tools/miri/tests/fail/validity/transmute_through_ptr.rs
@@ -14,6 +14,6 @@ fn main() {
     let mut x = Bool::True;
     evil(&mut x);
     let y = x; // reading this ought to be enough to trigger validation
-    //~^ ERROR: constructing invalid value at .<enum-tag>: encountered 0x0000002c, but expected a valid enum tag
+    //~^ ERROR: constructing invalid value of type Bool: at .<enum-tag>, encountered 0x0000002c, but expected a valid enum tag
     println!("{:?}", y); // make sure it is used (and not optimized away)
 }
diff --git a/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr b/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
index 998ff79d3afe..d531df63dc20 100644
--- a/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
+++ b/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .<enum-tag>: encountered $HEX, but expected a valid enum tag
+error: Undefined Behavior: constructing invalid value of type Bool: at .<enum-tag>, encountered $HEX, but expected a valid enum tag
   --> tests/fail/validity/transmute_through_ptr.rs:LL:CC
    |
 LL |     let y = x; // reading this ought to be enough to trigger validation
diff --git a/src/tools/miri/tests/fail/validity/uninhabited_variant.stderr b/src/tools/miri/tests/fail/validity/uninhabited_variant.stderr
index 76ee25009b6e..8f120cb399e4 100644
--- a/src/tools/miri/tests/fail/validity/uninhabited_variant.stderr
+++ b/src/tools/miri/tests/fail/validity/uninhabited_variant.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error: Undefined Behavior: constructing invalid value of type E: at .<enum-tag>, encountered an uninhabited enum variant
   --> tests/fail/validity/uninhabited_variant.rs:LL:CC
    |
 LL |         std::mem::transmute::<u32, E>(1);
diff --git a/src/tools/miri/tests/fail/validity/uninit_float.stderr b/src/tools/miri/tests/fail/validity/uninit_float.stderr
index 7f3c94a87874..82e0b2064d6e 100644
--- a/src/tools/miri/tests/fail/validity/uninit_float.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_float.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected a floating point number
+error: Undefined Behavior: constructing invalid value of type [f32; 1]: at [0], encountered uninitialized memory, but expected a floating point number
   --> tests/fail/validity/uninit_float.rs:LL:CC
    |
 LL |     let _val: [f32; 1] = unsafe { std::mem::uninitialized() };
diff --git a/src/tools/miri/tests/fail/validity/uninit_integer.stderr b/src/tools/miri/tests/fail/validity/uninit_integer.stderr
index a80396f7f1ce..038ffde63c45 100644
--- a/src/tools/miri/tests/fail/validity/uninit_integer.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_integer.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type [usize; 1]: at [0], encountered uninitialized memory, but expected an integer
   --> tests/fail/validity/uninit_integer.rs:LL:CC
    |
 LL |     let _val = unsafe { std::mem::MaybeUninit::<[usize; 1]>::uninit().assume_init() };
diff --git a/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr b/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
index 946d74d35484..ecfca66984cc 100644
--- a/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at [0]: encountered uninitialized memory, but expected a raw pointer
+error: Undefined Behavior: constructing invalid value of type [*const u8; 1]: at [0], encountered uninitialized memory, but expected a raw pointer
   --> tests/fail/validity/uninit_raw_ptr.rs:LL:CC
    |
 LL |     let _val = unsafe { std::mem::MaybeUninit::<[*const u8; 1]>::uninit().assume_init() };
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-assoc-type.stderr b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-assoc-type.stderr
index ea77d11f1e83..74d8a4697ca4 100644
--- a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-assoc-type.stderr
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-assoc-type.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<Assoc = bool>`, but encountered `Trait<Assoc = u8>`
+error: Undefined Behavior: constructing invalid value of type std::boxed::Box<dyn Trait<Assoc = bool>>: wrong trait in wide pointer vtable: expected `Trait<Assoc = bool>`, but encountered `Trait<Assoc = u8>`
   --> tests/fail/validity/wrong-dyn-trait-assoc-type.rs:LL:CC
    |
 LL |     let v: Box<dyn Trait<Assoc = bool>> = unsafe { std::mem::transmute(v) };
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr
index f9e2f15d98f9..9273e398a2ad 100644
--- a/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait-generic.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<u32>`, but encountered `Trait<i32>`
+error: Undefined Behavior: constructing invalid value of type *const dyn Trait<u32>: wrong trait in wide pointer vtable: expected `Trait<u32>`, but encountered `Trait<i32>`
   --> tests/fail/validity/wrong-dyn-trait-generic.rs:LL:CC
    |
 LL |     let _y: *const dyn Trait<u32> = unsafe { mem::transmute(x) };
diff --git a/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr
index 47efd0b0428c..6ca55c24c3be 100644
--- a/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr
+++ b/src/tools/miri/tests/fail/validity/wrong-dyn-trait.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `std::fmt::Debug`, but encountered `std::marker::Send`
+error: Undefined Behavior: constructing invalid value of type *const dyn std::fmt::Debug: wrong trait in wide pointer vtable: expected `std::fmt::Debug`, but encountered `std::marker::Send`
   --> tests/fail/validity/wrong-dyn-trait.rs:LL:CC
    |
 LL |     let _y: *const dyn fmt::Debug = unsafe { mem::transmute(x) };
diff --git a/src/tools/miri/tests/native-lib/fail/invalid_retval.rs b/src/tools/miri/tests/native-lib/fail/invalid_retval.rs
index 4967866b7e7f..e4bcbeb10926 100644
--- a/src/tools/miri/tests/native-lib/fail/invalid_retval.rs
+++ b/src/tools/miri/tests/native-lib/fail/invalid_retval.rs
@@ -9,6 +9,6 @@
 
 fn main() {
     unsafe {
-        u8_id(2); //~ ERROR: invalid value: encountered 0x02, but expected a boolean
+        u8_id(2); //~ ERROR: encountered 0x02, but expected a boolean
     }
 }
diff --git a/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr b/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr
index 9db29822d4f5..b3b99cc56e7b 100644
--- a/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr
+++ b/src/tools/miri/tests/native-lib/fail/invalid_retval.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value: encountered 0x02, but expected a boolean
+error: Undefined Behavior: constructing invalid value of type bool: encountered 0x02, but expected a boolean
   --> tests/native-lib/fail/invalid_retval.rs:LL:CC
    |
 LL |         u8_id(2);
diff --git a/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr b/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
index 9833b65b91b3..83e81703d8ad 100644
--- a/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
+++ b/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value at .part_1.high: encountered uninitialized memory, but expected an integer
+error: Undefined Behavior: constructing invalid value of type ComplexStruct: at .part_1.high, encountered uninitialized memory, but expected an integer
   --> tests/native-lib/fail/uninit_struct.rs:LL:CC
    |
 LL |     unsafe { pass_struct_complex(*arg.as_ptr(), 0, 0, 0) };
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
index 9392a171510d..ec39cc27efb4 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
@@ -56,7 +56,7 @@ LL |   get_flag::<false, { unsafe { char_raw.character } }>();
                ff __ __ __                                     │ .░░░
            }
 
-error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:42:14
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
@@ -67,7 +67,7 @@ LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
                42                                              │ B
            }
 
-error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:44:14
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
index 9392a171510d..ec39cc27efb4 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
@@ -56,7 +56,7 @@ LL |   get_flag::<false, { unsafe { char_raw.character } }>();
                ff __ __ __                                     │ .░░░
            }
 
-error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:42:14
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
@@ -67,7 +67,7 @@ LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
                42                                              │ B
            }
 
-error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:44:14
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
diff --git a/tests/ui/const-ptr/forbidden_slices.stderr b/tests/ui/const-ptr/forbidden_slices.stderr
index 70ae00af23f5..fb74be3bb52f 100644
--- a/tests/ui/const-ptr/forbidden_slices.stderr
+++ b/tests/ui/const-ptr/forbidden_slices.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &[u32]: encountered a null reference
   --> $DIR/forbidden_slices.rs:16:1
    |
 LL | pub static S0: &[u32] = unsafe { from_raw_parts(ptr::null(), 0) };
@@ -9,7 +9,7 @@ LL | pub static S0: &[u32] = unsafe { from_raw_parts(ptr::null(), 0) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &[()]: encountered a null reference
   --> $DIR/forbidden_slices.rs:18:1
    |
 LL | pub static S1: &[()] = unsafe { from_raw_parts(ptr::null(), 0) };
@@ -20,7 +20,7 @@ LL | pub static S1: &[()] = unsafe { from_raw_parts(ptr::null(), 0) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &[u32]: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/forbidden_slices.rs:22:1
    |
 LL | pub static S2: &[u32] = unsafe { from_raw_parts(&D0, 2) };
@@ -31,7 +31,7 @@ LL | pub static S2: &[u32] = unsafe { from_raw_parts(&D0, 2) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/forbidden_slices.rs:26:1
    |
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
@@ -42,7 +42,7 @@ LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) }
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/forbidden_slices.rs:28:1
    |
 LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, size_of::<&u32>()) };
@@ -55,7 +55,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, size
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/forbidden_slices.rs:30:1
    |
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
@@ -66,7 +66,7 @@ LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4)
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u16]: at .<deref>[1], encountered uninitialized memory, but expected an integer
   --> $DIR/forbidden_slices.rs:33:1
    |
 LL | pub static S7: &[u16] = unsafe {
@@ -77,7 +77,7 @@ LL | pub static S7: &[u16] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &[u64]: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/forbidden_slices.rs:41:1
    |
 LL | pub static S8: &[u64] = unsafe {
@@ -88,7 +88,7 @@ LL | pub static S8: &[u64] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &[u32]: encountered a null reference
   --> $DIR/forbidden_slices.rs:48:1
    |
 LL | pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
@@ -111,7 +111,7 @@ error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer
 LL |     from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
    |                         ^^^^^^^^^^ evaluation of `R2` failed here
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/forbidden_slices.rs:57:1
    |
 LL | pub static R4: &[u8] = unsafe {
@@ -122,7 +122,7 @@ LL | pub static R4: &[u8] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/forbidden_slices.rs:62:1
    |
 LL | pub static R5: &[u8] = unsafe {
@@ -135,7 +135,7 @@ LL | pub static R5: &[u8] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/forbidden_slices.rs:67:1
    |
 LL | pub static R6: &[bool] = unsafe {
@@ -146,7 +146,7 @@ LL | pub static R6: &[bool] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type &[u16]: encountered an unaligned reference (required 2 byte alignment but found 1)
   --> $DIR/forbidden_slices.rs:72:1
    |
 LL | pub static R7: &[u16] = unsafe {
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
index 239bca51fc96..f8d6cc145fca 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &i32: at .<deref>, encountered uninitialized memory, but expected an integer
   --> $DIR/alloc_intrinsic_uninit.rs:7:1
    |
 LL | const BAR: &i32 = unsafe {
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
index 3c6d66ac5b67..f7b652f7e43b 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &i32: at .<deref>, encountered uninitialized memory, but expected an integer
   --> $DIR/alloc_intrinsic_uninit.rs:7:1
    |
 LL | const BAR: &i32 = unsafe {
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
index 152eeababc51..094292446409 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a dangling reference (use-after-free)
+error[E0080]: constructing invalid value of type &u8: encountered a dangling reference (use-after-free)
   --> $DIR/dealloc_intrinsic_dangling.rs:11:1
    |
 LL | const _X: &'static u8 = unsafe {
diff --git a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
index acbf19d6ad77..65f815f80c6b 100644
--- a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x00000001, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum: at .<enum-tag>, encountered 0x00000001, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:23:1
    |
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
@@ -9,7 +9,7 @@ LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
                01 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x00000000, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum2: at .<enum-tag>, encountered 0x00000000, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:31:1
    |
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
@@ -20,7 +20,7 @@ LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/raw-bytes.rs:45:1
    |
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
@@ -31,7 +31,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                01                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered 0x03, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:47:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
@@ -42,7 +42,7 @@ LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute
                03                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
+error[E0080]: constructing invalid value of type Option<(char, char)>: at .<enum-variant(Some)>.0.1, encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
   --> $DIR/raw-bytes.rs:53:1
    |
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
@@ -53,7 +53,7 @@ LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::tran
                78 00 00 00 ff ff ff ff                         │ x.......
            }
 
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<u8>: encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:58:1
    |
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
@@ -64,7 +64,7 @@ LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<u8>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:61:1
    |
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
@@ -75,7 +75,7 @@ LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
                00                                              │ .
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<usize>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:63:1
    |
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
@@ -86,7 +86,7 @@ LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered 42, but expected something in the range 10..=30
+error[E0080]: constructing invalid value of type RestrictedRange1: encountered 42, but expected something in the range 10..=30
   --> $DIR/raw-bytes.rs:69:1
    |
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
@@ -97,7 +97,7 @@ LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
                2a 00 00 00                                     │ *...
            }
 
-error[E0080]: constructing invalid value: encountered 20, but expected something less or equal to 10, or greater or equal to 30
+error[E0080]: constructing invalid value of type RestrictedRange2: encountered 20, but expected something less or equal to 10, or greater or equal to 30
   --> $DIR/raw-bytes.rs:75:1
    |
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
@@ -108,7 +108,7 @@ LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
                14 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<dyn Send>: encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:78:1
    |
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
@@ -119,7 +119,7 @@ LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
                00 00 00 00 ╾ALLOC_ID╼                         │ ....╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type &u16: encountered an unaligned reference (required 2 byte alignment but found 1)
   --> $DIR/raw-bytes.rs:85:1
    |
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
@@ -130,7 +130,7 @@ LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type Box<u16>: encountered an unaligned box (required 2 byte alignment but found 1)
   --> $DIR/raw-bytes.rs:88:1
    |
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
@@ -141,7 +141,7 @@ LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &u16: encountered a null reference
   --> $DIR/raw-bytes.rs:91:1
    |
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
@@ -152,7 +152,7 @@ LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered a null box
+error[E0080]: constructing invalid value of type Box<u16>: encountered a null box
   --> $DIR/raw-bytes.rs:94:1
    |
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
@@ -163,7 +163,7 @@ LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type &u8: encountered a dangling reference (0x539[noalloc] has no provenance)
   --> $DIR/raw-bytes.rs:97:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
@@ -174,7 +174,7 @@ LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
                39 05 00 00                                     │ 9...
            }
 
-error[E0080]: constructing invalid value: encountered a dangling box (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type Box<u8>: encountered a dangling box (0x539[noalloc] has no provenance)
   --> $DIR/raw-bytes.rs:100:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
@@ -185,7 +185,7 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                39 05 00 00                                     │ 9...
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered null pointer, but expected a function pointer
   --> $DIR/raw-bytes.rs:103:1
    |
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
@@ -196,7 +196,7 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                00 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered 0xd[noalloc], but expected a function pointer
   --> $DIR/raw-bytes.rs:105:1
    |
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
@@ -207,7 +207,7 @@ LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
                0d 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered ALLOC3<imm>, but expected a function pointer
   --> $DIR/raw-bytes.rs:107:1
    |
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
@@ -218,7 +218,7 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type Bar
+error[E0080]: constructing invalid value of type &Bar: encountered a reference pointing to uninhabited type Bar
   --> $DIR/raw-bytes.rs:113:1
    |
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
@@ -229,7 +229,7 @@ LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
                01 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &str: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:137:1
    |
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -240,7 +240,7 @@ LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .0: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type (&str,): at .0, encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:139:1
    |
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
@@ -251,7 +251,7 @@ LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, us
                ╾ALLOC_ID╼ ff ff ff ff                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &MyStr: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:141:1
    |
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
@@ -262,7 +262,7 @@ LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize:
                ╾ALLOC_ID╼ ff ff ff ff                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &str: at .<deref>, encountered uninitialized memory, but expected a string
   --> $DIR/raw-bytes.rs:144:1
    |
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -273,7 +273,7 @@ LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit:
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &MyStr: at .<deref>.0, encountered uninitialized memory, but expected a string
   --> $DIR/raw-bytes.rs:146:1
    |
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -284,7 +284,7 @@ LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUni
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered a pointer, but expected a string
+error[E0080]: constructing invalid value of type &MyStr: at .<deref>.0, encountered a pointer, but expected a string
   --> $DIR/raw-bytes.rs:148:1
    |
 LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>(&[&()]) };
@@ -297,7 +297,7 @@ LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &[u8]: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:152:1
    |
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -308,7 +308,7 @@ LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u32]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:154:1
    |
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
@@ -319,7 +319,7 @@ LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, is
                ╾ALLOC_ID╼ ff ff ff 7f                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value: encountered a dangling box (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Box<[u8]>: encountered a dangling box (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:157:1
    |
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -330,7 +330,7 @@ LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999us
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool; 1]: at .<deref>[0], encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:160:1
    |
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
@@ -347,7 +347,7 @@ note: erroneous constant encountered
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.0, encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:164:1
    |
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
@@ -364,7 +364,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.1[0], encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:167:1
    |
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
@@ -381,7 +381,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC17<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC17<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:171:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
@@ -392,7 +392,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC19<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC19<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:174:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
@@ -403,7 +403,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered 0x4[noalloc], but expected a vtable pointer
   --> $DIR/raw-bytes.rs:177:1
    |
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
@@ -414,7 +414,7 @@ LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC22<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC22<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:179:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
@@ -425,7 +425,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::trans
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &dyn Trait: at .<deref>.<dyn-downcast(bool)>, encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:182:1
    |
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
@@ -436,7 +436,7 @@ LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_,
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered null pointer, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:185:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
@@ -447,7 +447,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute
                ╾ALLOC_ID╼ 00 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC27<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered ALLOC27<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:187:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
@@ -458,7 +458,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transm
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type [!; 1]
+error[E0080]: constructing invalid value of type &[!; 1]: encountered a reference pointing to uninhabited type [!; 1]
   --> $DIR/raw-bytes.rs:191:1
    |
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -469,7 +469,7 @@ LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
                01 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/raw-bytes.rs:192:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -480,7 +480,7 @@ LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
                01 00 00 00 01 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/raw-bytes.rs:193:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
@@ -491,7 +491,7 @@ LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
                01 00 00 00 2a 00 00 00                         │ ....*...
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:196:1
    |
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
@@ -502,7 +502,7 @@ LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) }
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/raw-bytes.rs:199:1
    |
 LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem::size_of::<&u32>()) };
@@ -515,7 +515,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem:
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/raw-bytes.rs:202:1
    |
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
@@ -526,7 +526,7 @@ LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4)
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u16]: at .<deref>[1], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:206:1
    |
 LL | pub static S7: &[u16] = unsafe {
@@ -537,7 +537,7 @@ LL | pub static S7: &[u16] = unsafe {
                ╾ALLOC_ID+0x2╼ 04 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:213:1
    |
 LL | pub static R4: &[u8] = unsafe {
@@ -548,7 +548,7 @@ LL | pub static R4: &[u8] = unsafe {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/raw-bytes.rs:218:1
    |
 LL | pub static R5: &[u8] = unsafe {
@@ -561,7 +561,7 @@ LL | pub static R5: &[u8] = unsafe {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/raw-bytes.rs:223:1
    |
 LL | pub static R6: &[bool] = unsafe {
diff --git a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
index 52d32fd3f875..d117de2f87be 100644
--- a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x0000000000000001, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum: at .<enum-tag>, encountered 0x0000000000000001, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:23:1
    |
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
@@ -9,7 +9,7 @@ LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
                01 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x0000000000000000, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum2: at .<enum-tag>, encountered 0x0000000000000000, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:31:1
    |
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
@@ -20,7 +20,7 @@ LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/raw-bytes.rs:45:1
    |
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
@@ -31,7 +31,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                01                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered 0x03, but expected a valid enum tag
   --> $DIR/raw-bytes.rs:47:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
@@ -42,7 +42,7 @@ LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute
                03                                              │ .
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
+error[E0080]: constructing invalid value of type Option<(char, char)>: at .<enum-variant(Some)>.0.1, encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
   --> $DIR/raw-bytes.rs:53:1
    |
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
@@ -53,7 +53,7 @@ LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::tran
                78 00 00 00 ff ff ff ff                         │ x.......
            }
 
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<u8>: encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:58:1
    |
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
@@ -64,7 +64,7 @@ LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<u8>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:61:1
    |
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
@@ -75,7 +75,7 @@ LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
                00                                              │ .
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<usize>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:63:1
    |
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
@@ -86,7 +86,7 @@ LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered 42, but expected something in the range 10..=30
+error[E0080]: constructing invalid value of type RestrictedRange1: encountered 42, but expected something in the range 10..=30
   --> $DIR/raw-bytes.rs:69:1
    |
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
@@ -97,7 +97,7 @@ LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
                2a 00 00 00                                     │ *...
            }
 
-error[E0080]: constructing invalid value: encountered 20, but expected something less or equal to 10, or greater or equal to 30
+error[E0080]: constructing invalid value of type RestrictedRange2: encountered 20, but expected something less or equal to 10, or greater or equal to 30
   --> $DIR/raw-bytes.rs:75:1
    |
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
@@ -108,7 +108,7 @@ LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
                14 00 00 00                                     │ ....
            }
 
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<dyn Send>: encountered 0, but expected something greater or equal to 1
   --> $DIR/raw-bytes.rs:78:1
    |
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
@@ -119,7 +119,7 @@ LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
                00 00 00 00 00 00 00 00 ╾ALLOC_ID╼ │ ........╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type &u16: encountered an unaligned reference (required 2 byte alignment but found 1)
   --> $DIR/raw-bytes.rs:85:1
    |
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
@@ -130,7 +130,7 @@ LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type Box<u16>: encountered an unaligned box (required 2 byte alignment but found 1)
   --> $DIR/raw-bytes.rs:88:1
    |
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
@@ -141,7 +141,7 @@ LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &u16: encountered a null reference
   --> $DIR/raw-bytes.rs:91:1
    |
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
@@ -152,7 +152,7 @@ LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered a null box
+error[E0080]: constructing invalid value of type Box<u16>: encountered a null box
   --> $DIR/raw-bytes.rs:94:1
    |
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
@@ -163,7 +163,7 @@ LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type &u8: encountered a dangling reference (0x539[noalloc] has no provenance)
   --> $DIR/raw-bytes.rs:97:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
@@ -174,7 +174,7 @@ LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
                39 05 00 00 00 00 00 00                         │ 9.......
            }
 
-error[E0080]: constructing invalid value: encountered a dangling box (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type Box<u8>: encountered a dangling box (0x539[noalloc] has no provenance)
   --> $DIR/raw-bytes.rs:100:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
@@ -185,7 +185,7 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                39 05 00 00 00 00 00 00                         │ 9.......
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered null pointer, but expected a function pointer
   --> $DIR/raw-bytes.rs:103:1
    |
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
@@ -196,7 +196,7 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                00 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered 0xd[noalloc], but expected a function pointer
   --> $DIR/raw-bytes.rs:105:1
    |
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
@@ -207,7 +207,7 @@ LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
                0d 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered ALLOC3<imm>, but expected a function pointer
   --> $DIR/raw-bytes.rs:107:1
    |
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
@@ -218,7 +218,7 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type Bar
+error[E0080]: constructing invalid value of type &Bar: encountered a reference pointing to uninhabited type Bar
   --> $DIR/raw-bytes.rs:113:1
    |
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
@@ -229,7 +229,7 @@ LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
                01 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &str: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:137:1
    |
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -240,7 +240,7 @@ LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .0: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type (&str,): at .0, encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:139:1
    |
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
@@ -251,7 +251,7 @@ LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, us
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &MyStr: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:141:1
    |
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
@@ -262,7 +262,7 @@ LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize:
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &str: at .<deref>, encountered uninitialized memory, but expected a string
   --> $DIR/raw-bytes.rs:144:1
    |
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -273,7 +273,7 @@ LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit:
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &MyStr: at .<deref>.0, encountered uninitialized memory, but expected a string
   --> $DIR/raw-bytes.rs:146:1
    |
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -284,7 +284,7 @@ LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUni
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered a pointer, but expected a string
+error[E0080]: constructing invalid value of type &MyStr: at .<deref>.0, encountered a pointer, but expected a string
   --> $DIR/raw-bytes.rs:148:1
    |
 LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>(&[&()]) };
@@ -297,7 +297,7 @@ LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &[u8]: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:152:1
    |
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -308,7 +308,7 @@ LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u32]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/raw-bytes.rs:154:1
    |
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
@@ -319,7 +319,7 @@ LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, is
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff 7f │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value: encountered a dangling box (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Box<[u8]>: encountered a dangling box (going beyond the bounds of its allocation)
   --> $DIR/raw-bytes.rs:157:1
    |
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -330,7 +330,7 @@ LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999us
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool; 1]: at .<deref>[0], encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:160:1
    |
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
@@ -347,7 +347,7 @@ note: erroneous constant encountered
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.0, encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:164:1
    |
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
@@ -364,7 +364,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.1[0], encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:167:1
    |
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
@@ -381,7 +381,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC17<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC17<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:171:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
@@ -392,7 +392,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC19<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC19<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:174:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
@@ -403,7 +403,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered 0x4[noalloc], but expected a vtable pointer
   --> $DIR/raw-bytes.rs:177:1
    |
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
@@ -414,7 +414,7 @@ LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u
                ╾ALLOC_ID╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC22<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC22<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:179:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
@@ -425,7 +425,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::trans
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &dyn Trait: at .<deref>.<dyn-downcast(bool)>, encountered 0x03, but expected a boolean
   --> $DIR/raw-bytes.rs:182:1
    |
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
@@ -436,7 +436,7 @@ LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_,
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered null pointer, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:185:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
@@ -447,7 +447,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute
                ╾ALLOC_ID╼ 00 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC27<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered ALLOC27<imm>, but expected a vtable pointer
   --> $DIR/raw-bytes.rs:187:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
@@ -458,7 +458,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transm
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type [!; 1]
+error[E0080]: constructing invalid value of type &[!; 1]: encountered a reference pointing to uninhabited type [!; 1]
   --> $DIR/raw-bytes.rs:191:1
    |
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -469,7 +469,7 @@ LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
                01 00 00 00 00 00 00 00                         │ ........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/raw-bytes.rs:192:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -480,7 +480,7 @@ LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
                01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/raw-bytes.rs:193:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
@@ -491,7 +491,7 @@ LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
                01 00 00 00 00 00 00 00 2a 00 00 00 00 00 00 00 │ ........*.......
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:196:1
    |
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
@@ -502,7 +502,7 @@ LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) }
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/raw-bytes.rs:199:1
    |
 LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem::size_of::<&u32>()) };
@@ -515,7 +515,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem:
                ╾ALLOC_ID╼ 08 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/raw-bytes.rs:202:1
    |
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
@@ -526,7 +526,7 @@ LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4)
                ╾ALLOC_ID╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u16]: at .<deref>[1], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:206:1
    |
 LL | pub static S7: &[u16] = unsafe {
@@ -537,7 +537,7 @@ LL | pub static S7: &[u16] = unsafe {
                ╾ALLOC_ID+0x2╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered uninitialized memory, but expected an integer
   --> $DIR/raw-bytes.rs:213:1
    |
 LL | pub static R4: &[u8] = unsafe {
@@ -548,7 +548,7 @@ LL | pub static R4: &[u8] = unsafe {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type &[u8]: at .<deref>[0], encountered a pointer, but expected an integer
   --> $DIR/raw-bytes.rs:218:1
    |
 LL | pub static R5: &[u8] = unsafe {
@@ -561,7 +561,7 @@ LL | pub static R5: &[u8] = unsafe {
                ╾ALLOC_ID╼ 08 00 00 00 00 00 00 00 │ ╾──────╼........
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool]: at .<deref>[0], encountered 0x11, but expected a boolean
   --> $DIR/raw-bytes.rs:223:1
    |
 LL | pub static R6: &[bool] = unsafe {
diff --git a/tests/ui/consts/const-eval/raw-bytes.rs b/tests/ui/consts/const-eval/raw-bytes.rs
index 274b1ae039fb..d63e1d5b062c 100644
--- a/tests/ui/consts/const-eval/raw-bytes.rs
+++ b/tests/ui/consts/const-eval/raw-bytes.rs
@@ -83,10 +83,10 @@ enum UninhDiscriminant {
 };
 
 const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
-//~^ ERROR constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+//~^ ERROR encountered an unaligned reference (required 2 byte alignment but found 1)
 
 const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
-//~^ ERROR constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
+//~^ ERROR encountered an unaligned box (required 2 byte alignment but found 1)
 
 const NULL: &u16 = unsafe { mem::transmute(0usize) };
 //~^ ERROR constructing invalid value
diff --git a/tests/ui/consts/const-eval/transmute-const.stderr b/tests/ui/consts/const-eval/transmute-const.stderr
index 53665c176a76..3b064c981f28 100644
--- a/tests/ui/consts/const-eval/transmute-const.stderr
+++ b/tests/ui/consts/const-eval/transmute-const.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x03, but expected a boolean
   --> $DIR/transmute-const.rs:4:1
    |
 LL | static FOO: bool = unsafe { mem::transmute(3u8) };
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index da63af30480e..a5ac10c7922c 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x01, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum: at .<enum-tag>, encountered 0x01, but expected a valid enum tag
   --> $DIR/ub-enum.rs:30:1
    |
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
@@ -27,7 +27,7 @@ LL | const BAD_ENUM_WRAPPED: Wrap<Enum> = unsafe { mem::transmute(&1) };
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x0, but expected a valid enum tag
+error[E0080]: constructing invalid value of type Enum2: at .<enum-tag>, encountered 0x0, but expected a valid enum tag
   --> $DIR/ub-enum.rs:48:1
    |
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
@@ -75,7 +75,7 @@ LL | const BAD_ENUM2_OPTION_PTR: Option<Enum2> = unsafe { mem::transmute(&0) };
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/ub-enum.rs:83:1
    |
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
@@ -86,7 +86,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x03, but expected a valid enum tag
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered 0x03, but expected a valid enum tag
   --> $DIR/ub-enum.rs:85:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
@@ -97,7 +97,7 @@ LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
+error[E0080]: constructing invalid value of type Option<(char, char)>: at .<enum-variant(Some)>.0.1, encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
   --> $DIR/ub-enum.rs:93:1
    |
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
@@ -108,13 +108,13 @@ LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::tran
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type Result<(i32, Never), (i32, !)>: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/ub-enum.rs:98:77
    |
 LL | const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(0u64) };
    |                                                                             ^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_UNINHABITED_WITH_DATA1` failed here
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type Result<(i32, !), (i32, Never)>: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/ub-enum.rs:100:77
    |
 LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) };
diff --git a/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr b/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
index 1e4d425d78ec..2d2d97da9787 100644
--- a/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
+++ b/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered ALLOC1<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC1<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:18:1
    |
 LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
@@ -9,7 +9,7 @@ LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
                ╾ALLOC0<imm>╼ ╾ALLOC1<imm>╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC3<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:22:1
    |
 LL | const INVALID_VTABLE_SIZE: &dyn Trait =
@@ -20,7 +20,7 @@ LL | const INVALID_VTABLE_SIZE: &dyn Trait =
                ╾ALLOC2<imm>╼ ╾ALLOC3<imm>╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC5<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC5<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:31:1
    |
 LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
@@ -31,7 +31,7 @@ LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
                ╾ALLOC4<imm>╼ ╾ALLOC5<imm>╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC7<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC7<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:35:1
    |
 LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
@@ -42,7 +42,7 @@ LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
                ╾ALLOC6<imm>╼ ╾ALLOC7<imm>╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC9<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC9<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:40:1
    |
 LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
@@ -53,7 +53,7 @@ LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
                ╾ALLOC8<imm>╼ ╾ALLOC9<imm>╼                         │ ╾──╼╾──╼
            }
 
-error[E0080]: constructing invalid value at .1: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Wide<'_>: at .1, encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/ub-incorrect-vtable.rs:86:1
    |
 LL | const G: Wide = unsafe { Transmute { t: FOO }.u };
diff --git a/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr b/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
index a068991f3242..4c8a1802317b 100644
--- a/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered ALLOC1<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC1<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:18:1
    |
 LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
@@ -9,7 +9,7 @@ LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
                ╾ALLOC0<imm>╼ ╾ALLOC1<imm>╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC3<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:22:1
    |
 LL | const INVALID_VTABLE_SIZE: &dyn Trait =
@@ -20,7 +20,7 @@ LL | const INVALID_VTABLE_SIZE: &dyn Trait =
                ╾ALLOC2<imm>╼ ╾ALLOC3<imm>╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC5<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC5<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:31:1
    |
 LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
@@ -31,7 +31,7 @@ LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
                ╾ALLOC4<imm>╼ ╾ALLOC5<imm>╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC7<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC7<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:35:1
    |
 LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
@@ -42,7 +42,7 @@ LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
                ╾ALLOC6<imm>╼ ╾ALLOC7<imm>╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC9<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC9<imm>, but expected a vtable pointer
   --> $DIR/ub-incorrect-vtable.rs:40:1
    |
 LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
@@ -53,7 +53,7 @@ LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
                ╾ALLOC8<imm>╼ ╾ALLOC9<imm>╼ │ ╾──────╼╾──────╼
            }
 
-error[E0080]: constructing invalid value at .1: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Wide<'_>: at .1, encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/ub-incorrect-vtable.rs:86:1
    |
 LL | const G: Wide = unsafe { Transmute { t: FOO }.u };
diff --git a/tests/ui/consts/const-eval/ub-int-array.rs b/tests/ui/consts/const-eval/ub-int-array.rs
index eebbccaa7c17..151019c15083 100644
--- a/tests/ui/consts/const-eval/ub-int-array.rs
+++ b/tests/ui/consts/const-eval/ub-int-array.rs
@@ -18,7 +18,7 @@ const fn new(t: T) -> Self {
 }
 
 const UNINIT_INT_0: [u32; 3] = unsafe {
-    //~^ ERROR invalid value at [0]
+    //~^ ERROR invalid value of type [u32; 3]: at [0]
     mem::transmute([
         MaybeUninit { uninit: () },
         // Constants chosen to achieve endianness-independent hex dump.
@@ -27,7 +27,7 @@ const fn new(t: T) -> Self {
     ])
 };
 const UNINIT_INT_1: [u32; 3] = unsafe {
-    //~^ ERROR invalid value at [1]
+    //~^ ERROR invalid value of type [u32; 3]: at [1]
     mem::transmute([
         MaybeUninit::new(0u8),
         MaybeUninit::new(0u8),
@@ -44,7 +44,7 @@ const fn new(t: T) -> Self {
     ])
 };
 const UNINIT_INT_2: [u32; 3] = unsafe {
-    //~^ ERROR invalid value at [2]
+    //~^ ERROR invalid value of type [u32; 3]: at [2]
     mem::transmute([
         MaybeUninit::new(0u8),
         MaybeUninit::new(0u8),
diff --git a/tests/ui/consts/const-eval/ub-int-array.stderr b/tests/ui/consts/const-eval/ub-int-array.stderr
index 065bfd2c304a..253358fc2a59 100644
--- a/tests/ui/consts/const-eval/ub-int-array.stderr
+++ b/tests/ui/consts/const-eval/ub-int-array.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at [0]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type [u32; 3]: at [0], encountered uninitialized memory, but expected an integer
   --> $DIR/ub-int-array.rs:20:1
    |
 LL | const UNINIT_INT_0: [u32; 3] = unsafe {
@@ -9,7 +9,7 @@ LL | const UNINIT_INT_0: [u32; 3] = unsafe {
                __ __ __ __ 11 11 11 11 22 22 22 22             │ ░░░░....""""
            }
 
-error[E0080]: constructing invalid value at [1]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type [u32; 3]: at [1], encountered uninitialized memory, but expected an integer
   --> $DIR/ub-int-array.rs:29:1
    |
 LL | const UNINIT_INT_1: [u32; 3] = unsafe {
@@ -20,7 +20,7 @@ LL | const UNINIT_INT_1: [u32; 3] = unsafe {
                00 00 00 00 01 __ 01 01 02 02 __ 02             │ .....░....░.
            }
 
-error[E0080]: constructing invalid value at [2]: encountered uninitialized memory, but expected an integer
+error[E0080]: constructing invalid value of type [u32; 3]: at [2], encountered uninitialized memory, but expected an integer
   --> $DIR/ub-int-array.rs:46:1
    |
 LL | const UNINIT_INT_2: [u32; 3] = unsafe {
diff --git a/tests/ui/consts/const-eval/ub-nonnull.stderr b/tests/ui/consts/const-eval/ub-nonnull.stderr
index be5c6f77a087..8f1838594407 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<u8>: encountered 0, but expected something greater or equal to 1
   --> $DIR/ub-nonnull.rs:16:1
    |
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
@@ -15,7 +15,7 @@ error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer
 LL |     let out_of_bounds_ptr = &ptr[255];
    |                             ^^^^^^^^^ evaluation of `OUT_OF_BOUNDS_PTR` failed here
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<u8>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/ub-nonnull.rs:26:1
    |
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
@@ -26,7 +26,7 @@ LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonZero<usize>: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/ub-nonnull.rs:28:1
    |
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
@@ -47,7 +47,7 @@ LL | const UNINIT: NonZero<u8> = unsafe { MaybeUninit { uninit: () }.init };
                __                                              │ ░
            }
 
-error[E0080]: constructing invalid value: encountered 42, but expected something in the range 10..=30
+error[E0080]: constructing invalid value of type RestrictedRange1: encountered 42, but expected something in the range 10..=30
   --> $DIR/ub-nonnull.rs:44:1
    |
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
@@ -58,7 +58,7 @@ LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered 20, but expected something less or equal to 10, or greater or equal to 30
+error[E0080]: constructing invalid value of type RestrictedRange2: encountered 20, but expected something less or equal to 10, or greater or equal to 30
   --> $DIR/ub-nonnull.rs:50:1
    |
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
@@ -69,7 +69,7 @@ LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type NonNull<dyn Send>: encountered 0, but expected something greater or equal to 1
   --> $DIR/ub-nonnull.rs:53:1
    |
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
@@ -80,7 +80,7 @@ LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a maybe-null pointer, but expected something that is definitely non-zero
+error[E0080]: constructing invalid value of type NonNull<()>: encountered a maybe-null pointer, but expected something that is definitely non-zero
   --> $DIR/ub-nonnull.rs:61:1
    |
 LL | const MAYBE_NULL_PTR: NonNull<()> = unsafe { mem::transmute((&raw const S).wrapping_add(4)) };
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index f7421ee34446..5cc327797a13 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -16,10 +16,10 @@ union MaybeUninit<T: Copy> {
 }
 
 const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
-//~^ ERROR constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+//~^ ERROR encountered an unaligned reference (required 2 byte alignment but found 1)
 
 const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
-//~^ ERROR constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
+//~^ ERROR encountered an unaligned box (required 2 byte alignment but found 1)
 
 const NULL: &u16 = unsafe { mem::transmute(0usize) };
 //~^ ERROR invalid value
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index 349a98f11be4..17ddea05e93f 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type &u16: encountered an unaligned reference (required 2 byte alignment but found 1)
   --> $DIR/ub-ref-ptr.rs:18:1
    |
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
@@ -9,7 +9,7 @@ LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
+error[E0080]: constructing invalid value of type Box<u16>: encountered an unaligned box (required 2 byte alignment but found 1)
   --> $DIR/ub-ref-ptr.rs:21:1
    |
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
@@ -20,7 +20,7 @@ LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a null reference
+error[E0080]: constructing invalid value of type &u16: encountered a null reference
   --> $DIR/ub-ref-ptr.rs:24:1
    |
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
@@ -31,7 +31,7 @@ LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a null box
+error[E0080]: constructing invalid value of type Box<u16>: encountered a null box
   --> $DIR/ub-ref-ptr.rs:27:1
    |
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
@@ -42,7 +42,7 @@ LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a maybe-null box
+error[E0080]: constructing invalid value of type Box<()>: encountered a maybe-null box
   --> $DIR/ub-ref-ptr.rs:30:1
    |
 LL | const MAYBE_NULL_BOX: Box<()> = unsafe { mem::transmute({
@@ -92,7 +92,7 @@ note: erroneous constant encountered
 LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
    |                                                                                     ^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value: encountered a dangling reference (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type &u8: encountered a dangling reference (0x539[noalloc] has no provenance)
   --> $DIR/ub-ref-ptr.rs:48:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
@@ -103,7 +103,7 @@ LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a dangling box (0x539[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type Box<u8>: encountered a dangling box (0x539[noalloc] has no provenance)
   --> $DIR/ub-ref-ptr.rs:51:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
@@ -124,7 +124,7 @@ LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered null pointer, but expected a function pointer
   --> $DIR/ub-ref-ptr.rs:57:1
    |
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
@@ -145,7 +145,7 @@ LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered 0xd[noalloc], but expected a function pointer
   --> $DIR/ub-ref-ptr.rs:61:1
    |
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
@@ -156,7 +156,7 @@ LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered ALLOC3<imm>, but expected a function pointer
   --> $DIR/ub-ref-ptr.rs:63:1
    |
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
@@ -167,7 +167,7 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC4+0xa, but expected a function pointer
+error[E0080]: constructing invalid value of type fn(): encountered ALLOC4+0xa, but expected a function pointer
   --> $DIR/ub-ref-ptr.rs:65:1
    |
 LL | const MAYBE_NULL_FN_PTR: fn() = unsafe { mem::transmute({
@@ -184,7 +184,7 @@ error[E0080]: accessing memory based on pointer with alignment 1, but alignment
 LL |     ptr.read();
    |     ^^^^^^^^^^ evaluation of `UNALIGNED_READ` failed here
 
-error[E0080]: constructing invalid value: encountered a pointer with unknown absolute address, but expected something that is definitely greater or equal to 1000
+error[E0080]: constructing invalid value of type High: encountered a pointer with unknown absolute address, but expected something that is definitely greater or equal to 1000
   --> $DIR/ub-ref-ptr.rs:84:1
    |
 LL | const INVALID_VALUE_PTR: High = unsafe { mem::transmute(&S) };
diff --git a/tests/ui/consts/const-eval/ub-uninhabit.stderr b/tests/ui/consts/const-eval/ub-uninhabit.stderr
index aca0b13bb907..244cb96b6923 100644
--- a/tests/ui/consts/const-eval/ub-uninhabit.stderr
+++ b/tests/ui/consts/const-eval/ub-uninhabit.stderr
@@ -1,10 +1,10 @@
-error[E0080]: constructing invalid value: encountered a value of uninhabited type `Bar`
+error[E0080]: constructing invalid value of type Bar: encountered a value of uninhabited type `Bar`
   --> $DIR/ub-uninhabit.rs:20:35
    |
 LL | const BAD_BAD_BAD: Bar = unsafe { MaybeUninit { uninit: () }.init };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_BAD_BAD` failed here
 
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type Bar
+error[E0080]: constructing invalid value of type &Bar: encountered a reference pointing to uninhabited type Bar
   --> $DIR/ub-uninhabit.rs:23:1
    |
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
@@ -15,13 +15,13 @@ LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at [0]: encountered a value of uninhabited type `Bar`
+error[E0080]: constructing invalid value of type [Bar; 1]: at [0], encountered a value of uninhabited type `Bar`
   --> $DIR/ub-uninhabit.rs:26:42
    |
 LL | const BAD_BAD_ARRAY: [Bar; 1] = unsafe { MaybeUninit { uninit: () }.init };
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_BAD_ARRAY` failed here
 
-error[E0080]: constructing invalid value: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type !: encountered a value of the never type `!`
   --> $DIR/ub-uninhabit.rs:32:16
    |
 LL |     let _val = intrinsics::read_via_copy(ptr);
diff --git a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
index 89512c03f5e8..2e5797c65b35 100644
--- a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>: encountered a null reference
+error[E0080]: constructing invalid value of type &dyn FnOnce(): at .<deref>.<dyn-downcast({closure@$DIR/ub-upvars.rs:10:5: 10:12})>.<captured-var(bad_ref)>, encountered a null reference
   --> $DIR/ub-upvars.rs:7:1
    |
 LL | const BAD_UPVAR: &dyn FnOnce() = &{
diff --git a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
index bf8de4817963..c45ad7856e6e 100644
--- a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>: encountered a null reference
+error[E0080]: constructing invalid value of type &dyn FnOnce(): at .<deref>.<dyn-downcast({closure@$DIR/ub-upvars.rs:10:5: 10:12})>.<captured-var(bad_ref)>, encountered a null reference
   --> $DIR/ub-upvars.rs:7:1
    |
 LL | const BAD_UPVAR: &dyn FnOnce() = &{
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.stderr b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
index c505e5cc8a24..9603710e4fd8 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &str: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/ub-wide-ptr.rs:40:1
    |
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -9,7 +9,7 @@ LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type (&str,): at .0, encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/ub-wide-ptr.rs:42:1
    |
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
@@ -38,7 +38,7 @@ LL | const MY_STR_LENGTH_PTR: &MyStr = unsafe { mem::transmute((&42u8, &3)) };
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &MyStr: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/ub-wide-ptr.rs:50:1
    |
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
@@ -49,7 +49,7 @@ LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize:
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &str: at .<deref>, encountered uninitialized memory, but expected a string
   --> $DIR/ub-wide-ptr.rs:54:1
    |
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -60,7 +60,7 @@ LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit:
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialized memory, but expected a string
+error[E0080]: constructing invalid value of type &MyStr: at .<deref>.0, encountered uninitialized memory, but expected a string
   --> $DIR/ub-wide-ptr.rs:57:1
    |
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
@@ -81,7 +81,7 @@ LL | const SLICE_LENGTH_UNINIT: &[u8] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type &[u8]: encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/ub-wide-ptr.rs:70:1
    |
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -92,7 +92,7 @@ LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u32]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/ub-wide-ptr.rs:73:1
    |
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
@@ -112,7 +112,7 @@ LL | const SLICE_LENGTH_PTR: &[u8] = unsafe { mem::transmute((&42u8, &3)) };
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value: encountered a dangling box (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Box<[u8]>: encountered a dangling box (going beyond the bounds of its allocation)
   --> $DIR/ub-wide-ptr.rs:79:1
    |
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
@@ -132,7 +132,7 @@ LL | const SLICE_LENGTH_PTR_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, &3)
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &[bool; 1]: at .<deref>[0], encountered 0x03, but expected a boolean
   --> $DIR/ub-wide-ptr.rs:86:1
    |
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
@@ -149,7 +149,7 @@ note: erroneous constant encountered
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.0, encountered 0x03, but expected a boolean
   --> $DIR/ub-wide-ptr.rs:92:1
    |
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
@@ -166,7 +166,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &MySlice<[bool; 1]>: at .<deref>.1[0], encountered 0x03, but expected a boolean
   --> $DIR/ub-wide-ptr.rs:95:1
    |
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
@@ -193,7 +193,7 @@ LL | const RAW_SLICE_LENGTH_UNINIT: *const [u8] = unsafe {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC12<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC12<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:110:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
@@ -204,7 +204,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC14<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC14<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:113:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
@@ -215,7 +215,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered 0x4[noalloc], but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:116:1
    |
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
@@ -226,7 +226,7 @@ LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC17<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC17<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:118:1
    |
 LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92u8, &[0u8; 128])) };
@@ -237,7 +237,7 @@ LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC19<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC19<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:120:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92u8, &[0usize; 8])) };
@@ -248,7 +248,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC21<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type &dyn Trait: encountered ALLOC21<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:122:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u8, &[1usize; 8])) };
@@ -259,7 +259,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0: encountered ALLOC23<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type W<&dyn Trait>: at .0, encountered ALLOC23<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:124:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
@@ -270,7 +270,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::trans
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type &dyn Trait: at .<deref>.<dyn-downcast(bool)>, encountered 0x03, but expected a boolean
   --> $DIR/ub-wide-ptr.rs:128:1
    |
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
@@ -281,7 +281,7 @@ LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_,
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered null pointer, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:132:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
@@ -292,7 +292,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC28<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered ALLOC28<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:134:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
@@ -303,7 +303,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transm
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered null pointer, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:141:1
    |
 LL | static mut RAW_TRAIT_OBJ_VTABLE_NULL_THROUGH_REF: *const dyn Trait = unsafe {
@@ -314,7 +314,7 @@ LL | static mut RAW_TRAIT_OBJ_VTABLE_NULL_THROUGH_REF: *const dyn Trait = unsafe
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC31<imm>, but expected a vtable pointer
+error[E0080]: constructing invalid value of type *const dyn Trait: encountered ALLOC31<imm>, but expected a vtable pointer
   --> $DIR/ub-wide-ptr.rs:145:1
    |
 LL | static mut RAW_TRAIT_OBJ_VTABLE_INVALID_THROUGH_REF: *const dyn Trait = unsafe {
diff --git a/tests/ui/consts/const-eval/union-ub.32bit.stderr b/tests/ui/consts/const-eval/union-ub.32bit.stderr
index fb2311b9921d..95960d1c77dc 100644
--- a/tests/ui/consts/const-eval/union-ub.32bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered 0x2a, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x2a, but expected a boolean
   --> $DIR/union-ub.rs:33:1
    |
 LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
diff --git a/tests/ui/consts/const-eval/union-ub.64bit.stderr b/tests/ui/consts/const-eval/union-ub.64bit.stderr
index fb2311b9921d..95960d1c77dc 100644
--- a/tests/ui/consts/const-eval/union-ub.64bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered 0x2a, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x2a, but expected a boolean
   --> $DIR/union-ub.rs:33:1
    |
 LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
diff --git a/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr b/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
index 848c65f47645..cd59e7ba55ad 100644
--- a/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
+++ b/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type !: encountered a value of the never type `!`
   --> $DIR/validate_uninhabited_zsts.rs:17:33
    |
 LL | const FOO: [empty::Empty; 3] = [foo(); 3];
@@ -10,7 +10,7 @@ note: inside `foo`
 LL |     unsafe { std::mem::transmute(()) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
-error[E0080]: constructing invalid value at .0: encountered a value of uninhabited type `Void`
+error[E0080]: constructing invalid value of type empty::Empty: at .0, encountered a value of uninhabited type `Void`
   --> $DIR/validate_uninhabited_zsts.rs:20:42
    |
 LL | const BAR: [empty::Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
index 8f54b4eda227..9b289f4306b8 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
@@ -28,7 +28,7 @@ LL | const B4: Option<&mut i32> = helper(&mut 42);
    |                              |           creates a temporary value which is freed while still in use
    |                              using this value as a constant requires that borrow lasts for `'static`
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut u16: encountered mutable reference or box pointing to read-only memory
   --> $DIR/mut_ref_in_final.rs:27:1
    |
 LL | const IMMUT_MUT_REF: &mut u16 = unsafe { mem::transmute(&13) };
@@ -39,7 +39,7 @@ LL | const IMMUT_MUT_REF: &mut u16 = unsafe { mem::transmute(&13) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut u16: encountered mutable reference or box pointing to read-only memory
   --> $DIR/mut_ref_in_final.rs:29:1
    |
 LL | static IMMUT_MUT_REF_STATIC: &mut u16 = unsafe { mem::transmute(&13) };
@@ -120,7 +120,7 @@ LL | const RAW_MUT_COERCE_C: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    = note: to avoid accidentally creating global mutable state, such temporaries must be immutable
    = help: if you really want global mutable state, try replacing the temporary by an interior mutable `static` or a `static mut`
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (0x2a[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type Option<&mut i32>: at .<enum-variant(Some)>.0, encountered a dangling reference (0x2a[noalloc] has no provenance)
   --> $DIR/mut_ref_in_final.rs:86:5
    |
 LL |     const INT2PTR: Option<&mut i32> = helper_int2ptr();
@@ -131,7 +131,7 @@ LL |     const INT2PTR: Option<&mut i32> = helper_int2ptr();
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (0x2a[noalloc] has no provenance)
+error[E0080]: constructing invalid value of type Option<&mut i32>: at .<enum-variant(Some)>.0, encountered a dangling reference (0x2a[noalloc] has no provenance)
   --> $DIR/mut_ref_in_final.rs:87:5
    |
 LL |     static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr();
@@ -142,7 +142,7 @@ LL |     static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr();
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
+error[E0080]: constructing invalid value of type Option<&mut i32>: at .<enum-variant(Some)>.0, encountered a dangling reference (use-after-free)
   --> $DIR/mut_ref_in_final.rs:93:5
    |
 LL |     const DANGLING: Option<&mut i32> = helper_dangling();
@@ -153,7 +153,7 @@ LL |     const DANGLING: Option<&mut i32> = helper_dangling();
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
+error[E0080]: constructing invalid value of type Option<&mut i32>: at .<enum-variant(Some)>.0, encountered a dangling reference (use-after-free)
   --> $DIR/mut_ref_in_final.rs:94:5
    |
 LL |     static DANGLING_STATIC: Option<&mut i32> = helper_dangling();
diff --git a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
index 226a9de285dc..b0150fc59666 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>: encountered 0x0a, but expected a boolean
+error[E0080]: constructing invalid value of type &bool: at .<deref>, encountered 0x0a, but expected a boolean
   --> $DIR/const_refs_to_static_fail_invalid.rs:10:5
    |
 LL |     const C: &bool = unsafe { std::mem::transmute(&S) };
diff --git a/tests/ui/consts/const_transmute_type_id7.rs b/tests/ui/consts/const_transmute_type_id7.rs
index 73b8187a8007..6863b88ca279 100644
--- a/tests/ui/consts/const_transmute_type_id7.rs
+++ b/tests/ui/consts/const_transmute_type_id7.rs
@@ -2,6 +2,7 @@
 //! (see <https://github.com/rust-lang/rust/issues/146748>)
 
 // Strip out raw byte dumps to make comparison platform-independent:
+//@ normalize-stderr: "\[&\(\); \d\]" -> "ARRAY"
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 
diff --git a/tests/ui/consts/const_transmute_type_id7.stderr b/tests/ui/consts/const_transmute_type_id7.stderr
index 664975831f40..a1c37f2b36fe 100644
--- a/tests/ui/consts/const_transmute_type_id7.stderr
+++ b/tests/ui/consts/const_transmute_type_id7.stderr
@@ -1,5 +1,5 @@
-error[E0080]: constructing invalid value at [0]: encountered a maybe-null reference
-  --> $DIR/const_transmute_type_id7.rs:13:1
+error[E0080]: constructing invalid value of type ARRAY: at [0], encountered a maybe-null reference
+  --> $DIR/const_transmute_type_id7.rs:14:1
    |
 LL | const A: [&(); 16 / size_of::<*const ()>()] = unsafe { transmute(TypeId::of::<i32>()) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
diff --git a/tests/ui/consts/dangling-alloc-id-ice.stderr b/tests/ui/consts/dangling-alloc-id-ice.stderr
index 4b034c81a61d..5b92bef890ac 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.stderr
+++ b/tests/ui/consts/dangling-alloc-id-ice.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a dangling reference (use-after-free)
+error[E0080]: constructing invalid value of type &(): encountered a dangling reference (use-after-free)
   --> $DIR/dangling-alloc-id-ice.rs:12:1
    |
 LL | const FOO: &() = {
diff --git a/tests/ui/consts/dangling-zst-ice-issue-126393.stderr b/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
index 248db694d525..0824afd862ad 100644
--- a/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
+++ b/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a dangling reference (use-after-free)
+error[E0080]: constructing invalid value of type &Wrapper: encountered a dangling reference (use-after-free)
   --> $DIR/dangling-zst-ice-issue-126393.rs:7:1
    |
 LL | pub static MAGIC_FFI_REF: &'static Wrapper = unsafe {
diff --git a/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr b/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
index 96c1666a2d2e..a55a90dfb89a 100644
--- a/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
+++ b/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
@@ -1,10 +1,10 @@
-error[E0080]: constructing invalid value: encountered 0x03, but expected a boolean
+error[E0080]: constructing invalid value of type bool: encountered 0x03, but expected a boolean
   --> $DIR/detect-extra-ub.rs:30:20
    |
 LL |     let _x: bool = transmute(3u8);
    |                    ^^^^^^^^^^^^^^ evaluation of `INVALID_BOOL` failed here
 
-error[E0080]: constructing invalid value: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type usize: encountered a pointer, but expected an integer
   --> $DIR/detect-extra-ub.rs:35:21
    |
 LL |     let _x: usize = transmute(&3u8);
@@ -13,7 +13,7 @@ LL |     let _x: usize = transmute(&3u8);
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type PtrSizedEnum: at .<enum-tag>, encountered a pointer, but expected an integer
   --> $DIR/detect-extra-ub.rs:40:28
    |
 LL |     let _x: PtrSizedEnum = transmute(&3u8);
@@ -22,7 +22,7 @@ LL |     let _x: PtrSizedEnum = transmute(&3u8);
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .0: encountered a pointer, but expected an integer
+error[E0080]: constructing invalid value of type (usize, usize): at .0, encountered a pointer, but expected an integer
   --> $DIR/detect-extra-ub.rs:46:30
    |
 LL |     let _x: (usize, usize) = transmute(x);
@@ -31,13 +31,13 @@ LL |     let _x: (usize, usize) = transmute(x);
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value: encountered an unaligned reference (required 4 byte alignment but found 1)
+error[E0080]: constructing invalid value of type &u32: encountered an unaligned reference (required 4 byte alignment but found 1)
   --> $DIR/detect-extra-ub.rs:51:20
    |
 LL |     let _x: &u32 = transmute(&[0u8; 4]);
    |                    ^^^^^^^^^^^^^^^^^^^^ evaluation of `UNALIGNED_PTR` failed here
 
-error[E0080]: constructing invalid value: encountered a maybe-null function pointer
+error[E0080]: constructing invalid value of type fn(): encountered a maybe-null function pointer
   --> $DIR/detect-extra-ub.rs:57:20
    |
 LL |       let _x: fn() = transmute({
@@ -49,13 +49,13 @@ LL | |         (ptr as *const u8).wrapping_add(10)
 LL | |     });
    | |______^ evaluation of `MAYBE_NULL_FN_PTR` failed here
 
-error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
+error[E0080]: constructing invalid value of type UninhDiscriminant: at .<enum-tag>, encountered an uninhabited enum variant
   --> $DIR/detect-extra-ub.rs:68:13
    |
 LL |     let v = *addr_of!(data).cast::<UninhDiscriminant>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINHABITED_VARIANT` failed here
 
-error[E0080]: constructing invalid value at [0]: encountered a partial pointer or a mix of pointers
+error[E0080]: constructing invalid value of type [*const u8; 2]: at [0], encountered a partial pointer or a mix of pointers
   --> $DIR/detect-extra-ub.rs:87:16
    |
 LL |     let _val = *(&mem as *const Align as *const [*const u8; 2]);
@@ -64,7 +64,7 @@ LL |     let _val = *(&mem as *const Align as *const [*const u8; 2]);
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u8]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/detect-extra-ub.rs:101:16
    |
 LL |     let _val = &*slice;
diff --git a/tests/ui/consts/interior-mut-const-via-union.32bit.stderr b/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
index 17b32383912a..64a178b6913d 100644
--- a/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
+++ b/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.y.<enum-variant(B)>.0: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &S: at .<deref>.y.<enum-variant(B)>.0, encountered `UnsafeCell` in read-only memory
   --> $DIR/interior-mut-const-via-union.rs:34:1
    |
 LL | fn main() {
diff --git a/tests/ui/consts/interior-mut-const-via-union.64bit.stderr b/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
index c4f78e7bf9ea..f2301560faae 100644
--- a/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
+++ b/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.y.<enum-variant(B)>.0: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &S: at .<deref>.y.<enum-variant(B)>.0, encountered `UnsafeCell` in read-only memory
   --> $DIR/interior-mut-const-via-union.rs:34:1
    |
 LL | fn main() {
diff --git a/tests/ui/consts/issue-63952.32bit.stderr b/tests/ui/consts/issue-63952.32bit.stderr
index cf97ed6e4874..eb57a2f2ab5e 100644
--- a/tests/ui/consts/issue-63952.32bit.stderr
+++ b/tests/ui/consts/issue-63952.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u8]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/issue-63952.rs:17:1
    |
 LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
diff --git a/tests/ui/consts/issue-63952.64bit.stderr b/tests/ui/consts/issue-63952.64bit.stderr
index 4cea967314c0..da1d05eb5dc5 100644
--- a/tests/ui/consts/issue-63952.64bit.stderr
+++ b/tests/ui/consts/issue-63952.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
+error[E0080]: constructing invalid value of type &[u8]: encountered invalid reference metadata: slice is bigger than largest supported object
   --> $DIR/issue-63952.rs:17:1
    |
 LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
diff --git a/tests/ui/consts/issue-64506.stderr b/tests/ui/consts/issue-64506.stderr
index 9fce07c58501..bd4f8f96a279 100644
--- a/tests/ui/consts/issue-64506.stderr
+++ b/tests/ui/consts/issue-64506.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .inner: encountered a value of uninhabited type `AnonPipe`
+error[E0080]: constructing invalid value of type ChildStdin: at .inner, encountered a value of uninhabited type `AnonPipe`
   --> $DIR/issue-64506.rs:16:22
    |
 LL |     let x = unsafe { Foo { b: () }.a };
diff --git a/tests/ui/consts/issue-79690.64bit.stderr b/tests/ui/consts/issue-79690.64bit.stderr
index 2653ff22f120..c3f89d243335 100644
--- a/tests/ui/consts/issue-79690.64bit.stderr
+++ b/tests/ui/consts/issue-79690.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .1: encountered a dangling reference (going beyond the bounds of its allocation)
+error[E0080]: constructing invalid value of type Fat<'_>: at .1, encountered a dangling reference (going beyond the bounds of its allocation)
   --> $DIR/issue-79690.rs:30:1
    |
 LL | const G: Fat = unsafe { Transmute { t: FOO }.u };
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.stderr b/tests/ui/consts/miri_unleashed/mutable_references.stderr
index 4187a9e1c2bf..68c6dd1ed600 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.stderr
+++ b/tests/ui/consts/miri_unleashed/mutable_references.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &&mut u32: at .<deref>, encountered mutable reference or box pointing to read-only memory
   --> $DIR/mutable_references.rs:13:1
    |
 LL | static FOO: &&mut u32 = &&mut 42;
@@ -9,7 +9,7 @@ LL | static FOO: &&mut u32 = &&mut 42;
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/mutable_references.rs:15:1
    |
 LL | static OH_YES: &mut i32 = &mut 42;
@@ -32,7 +32,7 @@ error: encountered mutable pointer in final value of static
 LL | static BOO: &mut Foo<()> = &mut Foo(());
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/mutable_references.rs:25:1
    |
 LL | const BLUNT: &mut i32 = &mut 42;
@@ -43,7 +43,7 @@ LL | const BLUNT: &mut i32 = &mut 42;
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type Meh: at .x.<deref>, encountered `UnsafeCell` in read-only memory
   --> $DIR/mutable_references.rs:40:1
    |
 LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
@@ -54,7 +54,7 @@ LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type Meh: at .x.<deref>, encountered `UnsafeCell` in read-only memory
   --> $DIR/mutable_references.rs:45:1
    |
 LL | const MUH: Meh = Meh {
@@ -65,7 +65,7 @@ LL | const MUH: Meh = Meh {
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.x: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &dyn Sync: at .<deref>.<dyn-downcast(Synced)>.x, encountered `UnsafeCell` in read-only memory
   --> $DIR/mutable_references.rs:56:1
    |
 LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
@@ -76,7 +76,7 @@ LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/mutable_references.rs:62:1
    |
 LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const _ as *mut _) };
diff --git a/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr b/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
index d7c668a98121..ab2169672910 100644
--- a/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
+++ b/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &Atomic<i32>: at .<deref>.v, encountered `UnsafeCell` in read-only memory
   --> $DIR/static-no-inner-mut.rs:8:1
    |
 LL | static REF: &AtomicI32 = &AtomicI32::new(42);
@@ -9,7 +9,7 @@ LL | static REF: &AtomicI32 = &AtomicI32::new(42);
                ╾ALLOC0╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/static-no-inner-mut.rs:11:1
    |
 LL | static REFMUT: &mut i32 = &mut 0;
@@ -20,7 +20,7 @@ LL | static REFMUT: &mut i32 = &mut 0;
                ╾ALLOC1╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &Atomic<i32>: at .<deref>.v, encountered `UnsafeCell` in read-only memory
   --> $DIR/static-no-inner-mut.rs:15:1
    |
 LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
@@ -31,7 +31,7 @@ LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
                ╾ALLOC2╼                                     │ ╾──╼
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/static-no-inner-mut.rs:17:1
    |
 LL | static REFMUT2: &mut i32 = {let mut x = 0; &mut {x}};
diff --git a/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr b/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
index f3bb49900b59..673c1b3c0b6e 100644
--- a/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
+++ b/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &Atomic<i32>: at .<deref>.v, encountered `UnsafeCell` in read-only memory
   --> $DIR/static-no-inner-mut.rs:8:1
    |
 LL | static REF: &AtomicI32 = &AtomicI32::new(42);
@@ -9,7 +9,7 @@ LL | static REF: &AtomicI32 = &AtomicI32::new(42);
                ╾ALLOC0╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/static-no-inner-mut.rs:11:1
    |
 LL | static REFMUT: &mut i32 = &mut 0;
@@ -20,7 +20,7 @@ LL | static REFMUT: &mut i32 = &mut 0;
                ╾ALLOC1╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type &Atomic<i32>: at .<deref>.v, encountered `UnsafeCell` in read-only memory
   --> $DIR/static-no-inner-mut.rs:15:1
    |
 LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
@@ -31,7 +31,7 @@ LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
                ╾ALLOC2╼                         │ ╾──────╼
            }
 
-error[E0080]: constructing invalid value: encountered mutable reference or box pointing to read-only memory
+error[E0080]: constructing invalid value of type &mut i32: encountered mutable reference or box pointing to read-only memory
   --> $DIR/static-no-inner-mut.rs:17:1
    |
 LL | static REFMUT2: &mut i32 = {let mut x = 0; &mut {x}};
diff --git a/tests/ui/consts/validate_never_arrays.stderr b/tests/ui/consts/validate_never_arrays.stderr
index 3c405e8d3cd0..517b632bdd7b 100644
--- a/tests/ui/consts/validate_never_arrays.stderr
+++ b/tests/ui/consts/validate_never_arrays.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered a reference pointing to uninhabited type [!; 1]
+error[E0080]: constructing invalid value of type &[!; 1]: encountered a reference pointing to uninhabited type [!; 1]
   --> $DIR/validate_never_arrays.rs:6:1
    |
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -9,7 +9,7 @@ LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/validate_never_arrays.rs:9:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
@@ -20,7 +20,7 @@ LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of the never type `!`
+error[E0080]: constructing invalid value of type &[!]: at .<deref>[0], encountered a value of the never type `!`
   --> $DIR/validate_never_arrays.rs:10:1
    |
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
diff --git a/tests/ui/statics/mutable_memory_validation.rs b/tests/ui/statics/mutable_memory_validation.rs
index 033c2bc28396..bdef949a38bb 100644
--- a/tests/ui/statics/mutable_memory_validation.rs
+++ b/tests/ui/statics/mutable_memory_validation.rs
@@ -11,7 +11,7 @@ struct Meh {
 }
 
 const MUH: Meh = Meh { x: unsafe { &mut *(&READONLY as *const _ as *mut _) } };
-//~^ ERROR: invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
+//~^ ERROR: at .x.<deref>, encountered `UnsafeCell` in read-only memory
 
 static READONLY: i32 = 0;
 
diff --git a/tests/ui/statics/mutable_memory_validation.stderr b/tests/ui/statics/mutable_memory_validation.stderr
index 1d6ba195fa28..297a96542034 100644
--- a/tests/ui/statics/mutable_memory_validation.stderr
+++ b/tests/ui/statics/mutable_memory_validation.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell` in read-only memory
+error[E0080]: constructing invalid value of type Meh: at .x.<deref>, encountered `UnsafeCell` in read-only memory
   --> $DIR/mutable_memory_validation.rs:13:1
    |
 LL | const MUH: Meh = Meh { x: unsafe { &mut *(&READONLY as *const _ as *mut _) } };
diff --git a/tests/ui/statics/uninhabited-static.stderr b/tests/ui/statics/uninhabited-static.stderr
index 4762784574dc..80871083e1c1 100644
--- a/tests/ui/statics/uninhabited-static.stderr
+++ b/tests/ui/statics/uninhabited-static.stderr
@@ -43,13 +43,13 @@ LL |     static NEVER: !;
    = 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 #74840 <https://github.com/rust-lang/rust/issues/74840>
 
-error[E0080]: constructing invalid value: encountered a value of uninhabited type `Void`
+error[E0080]: constructing invalid value of type Void: encountered a value of uninhabited type `Void`
   --> $DIR/uninhabited-static.rs:12:31
    |
 LL | static VOID2: Void = unsafe { std::mem::transmute(()) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `VOID2` failed here
 
-error[E0080]: constructing invalid value: encountered a value of uninhabited type `Void`
+error[E0080]: constructing invalid value of type Void: encountered a value of uninhabited type `Void`
   --> $DIR/uninhabited-static.rs:15:32
    |
 LL | static NEVER2: Void = unsafe { std::mem::transmute(()) };
diff --git a/tests/ui/type/pattern_types/validity.rs b/tests/ui/type/pattern_types/validity.rs
index 8323049188db..6c630fc2633b 100644
--- a/tests/ui/type/pattern_types/validity.rs
+++ b/tests/ui/type/pattern_types/validity.rs
@@ -8,7 +8,7 @@
 use std::pat::pattern_type;
 
 const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
-//~^ ERROR: constructing invalid value: encountered 0
+//~^ ERROR: encountered 0
 
 const BAD_UNINIT: pattern_type!(u32 is 1..) =
     //~^ ERROR: this operation requires initialized memory
@@ -18,22 +18,22 @@
 //~^ ERROR: unable to turn pointer into integer
 
 const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem::transmute(0) }, 0);
-//~^ ERROR: constructing invalid value at .0: encountered 0
+//~^ ERROR: at .0, encountered 0
 
 struct Foo(Bar);
 struct Bar(pattern_type!(u32 is 1..));
 
 const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) }));
-//~^ ERROR: constructing invalid value at .0.0: encountered 0
+//~^ ERROR: at .0.0, encountered 0
 
 const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') =
     //~^ ERROR: this operation requires initialized memory
     unsafe { std::mem::transmute(std::mem::MaybeUninit::<u32>::uninit()) };
 
 const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute('a') };
-//~^ ERROR: constructing invalid value: encountered 97, but expected something in the range 65..=89
+//~^ ERROR: encountered 97, but expected something in the range 65..=89
 
 const CHAR_OOB: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute(u32::MAX) };
-//~^ ERROR: constructing invalid value: encountered 0xffffffff
+//~^ ERROR: encountered 0xffffffff
 
 fn main() {}
diff --git a/tests/ui/type/pattern_types/validity.stderr b/tests/ui/type/pattern_types/validity.stderr
index e19915a58a32..a4fb46cf3ed0 100644
--- a/tests/ui/type/pattern_types/validity.stderr
+++ b/tests/ui/type/pattern_types/validity.stderr
@@ -1,4 +1,4 @@
-error[E0080]: constructing invalid value: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type (u32) is 1..: encountered 0, but expected something greater or equal to 1
   --> $DIR/validity.rs:10:1
    |
 LL | const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
@@ -28,7 +28,7 @@ LL | const BAD_PTR: pattern_type!(usize is 1..) = unsafe { std::mem::transmute(&
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error[E0080]: constructing invalid value at .0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type ((u32) is 1.., u32): at .0, encountered 0, but expected something greater or equal to 1
   --> $DIR/validity.rs:20:1
    |
 LL | const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem::transmute(0) }, 0);
@@ -39,7 +39,7 @@ LL | const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem:
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
+error[E0080]: constructing invalid value of type Foo: at .0.0, encountered 0, but expected something greater or equal to 1
   --> $DIR/validity.rs:26:1
    |
 LL | const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) }));
@@ -60,7 +60,7 @@ LL | const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') =
                __ __ __ __                                     │ ░░░░
            }
 
-error[E0080]: constructing invalid value: encountered 97, but expected something in the range 65..=89
+error[E0080]: constructing invalid value of type (char) is 'A'..='Y': encountered 97, but expected something in the range 65..=89
   --> $DIR/validity.rs:33:1
    |
 LL | const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute('a') };
@@ -71,7 +71,7 @@ LL | const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::tr
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
+error[E0080]: constructing invalid value of type (char) is 'A'..='Y': encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`)
   --> $DIR/validity.rs:36:1
    |
 LL | const CHAR_OOB: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute(u32::MAX) };

From f9c0284206b3a0cefad30f24b3ff616a9cfb10b3 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 19 Mar 2026 15:42:55 +0000
Subject: [PATCH 0664/1059] coretests: Move the `float` module under `num`

This is just a single file, so move it under `num` which already has
some float-related tests. This also closer mirrors source in `core`.
---
 library/coretests/tests/lib.rs                           | 1 -
 library/coretests/tests/{floats/mod.rs => num/floats.rs} | 4 +++-
 library/coretests/tests/num/mod.rs                       | 1 +
 3 files changed, 4 insertions(+), 2 deletions(-)
 rename library/coretests/tests/{floats/mod.rs => num/floats.rs} (99%)

diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 72112f8b0113..76229b5dae7f 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -181,7 +181,6 @@ fn $test() $block
 mod const_ptr;
 mod convert;
 mod ffi;
-mod floats;
 mod fmt;
 mod future;
 mod hash;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/num/floats.rs
similarity index 99%
rename from library/coretests/tests/floats/mod.rs
rename to library/coretests/tests/num/floats.rs
index c9bbff266d90..ca9214cfbb07 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/num/floats.rs
@@ -232,7 +232,9 @@ const fn lim_for_ty<T: TestableFloat + Copy>(_x: T) -> T {
 
 /// Verify that floats are within a tolerance of each other.
 macro_rules! assert_approx_eq {
-    ($a:expr, $b:expr $(,)?) => {{ assert_approx_eq!($a, $b, $crate::floats::lim_for_ty($a)) }};
+    ($a:expr, $b:expr $(,)?) => {{
+        assert_approx_eq!($a, $b, $crate::num::floats::lim_for_ty($a))
+    }};
     ($a:expr, $b:expr, $lim:expr) => {{
         let (a, b) = (&$a, &$b);
         let diff = (*a - *b).abs();
diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index 73b0e2333fee..b7096de51587 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -26,6 +26,7 @@
 mod const_from;
 mod dec2flt;
 mod float_iter_sum_identity;
+mod floats;
 mod flt2dec;
 mod ieee754;
 mod int_log;

From 42112342695e685b8a3cbbf3a7ae221b56e23012 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 19 Mar 2026 16:21:40 +0000
Subject: [PATCH 0665/1059] coretests: Give `ieee754.rs` a more accurate name

---
 .../tests/num/{ieee754.rs => float_ieee754_flt2dec_dec2flt.rs}  | 0
 library/coretests/tests/num/mod.rs                              | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename library/coretests/tests/num/{ieee754.rs => float_ieee754_flt2dec_dec2flt.rs} (100%)

diff --git a/library/coretests/tests/num/ieee754.rs b/library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs
similarity index 100%
rename from library/coretests/tests/num/ieee754.rs
rename to library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs
diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index b7096de51587..0e3913fab498 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -25,10 +25,10 @@
 mod carryless_mul;
 mod const_from;
 mod dec2flt;
+mod float_ieee754_flt2dec_dec2flt;
 mod float_iter_sum_identity;
 mod floats;
 mod flt2dec;
-mod ieee754;
 mod int_log;
 mod int_sqrt;
 mod midpoint;

From f9752e2074ae6cf1c1ad8bb5694fdecd7aedee1c Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Thu, 19 Mar 2026 17:58:45 +0100
Subject: [PATCH 0666/1059] bootstrap: Pass `--features=rustc` to
 rustc_transmute

This matters for `x test rustc_transmute`, where the feature won't
automatically be enabled and as a result spew a bunch of warnings.
---
 src/bootstrap/src/lib.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index f1303814f6d7..6af11d9ae0a8 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -883,6 +883,12 @@ fn rustc_features(&self, kind: Kind, target: TargetSelection, crates: &[String])
             features.push("check_only");
         }
 
+        if crates.iter().any(|c| c == "rustc_transmute") {
+            // for `x test rustc_transmute`, this feature isn't enabled automatically by a
+            // dependent crate.
+            features.push("rustc");
+        }
+
         // If debug logging is on, then we want the default for tracing:
         // https://github.com/tokio-rs/tracing/blob/3dd5c03d907afdf2c39444a29931833335171554/tracing/src/level_filters.rs#L26
         // which is everything (including debug/trace/etc.)

From 16f89853f7036668f21c499b03914240f797249c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 19 Mar 2026 16:08:00 +0000
Subject: [PATCH 0667/1059] coretests: Expand ieee754 parsing and printing
 tests to f16

Use `float_test!` to cover all types, with a note about f128 missing the
traits.
---
 .../0029-sysroot_tests-disable-f16-math.patch |   9 +-
 .../num/float_ieee754_flt2dec_dec2flt.rs      | 234 +++++++++---------
 library/coretests/tests/num/floats.rs         |  13 +-
 library/coretests/tests/num/mod.rs            |   2 +
 4 files changed, 136 insertions(+), 122 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/patches/0029-sysroot_tests-disable-f16-math.patch b/compiler/rustc_codegen_cranelift/patches/0029-sysroot_tests-disable-f16-math.patch
index 340f6cc9b0e7..2a6bfe816457 100644
--- a/compiler/rustc_codegen_cranelift/patches/0029-sysroot_tests-disable-f16-math.patch
+++ b/compiler/rustc_codegen_cranelift/patches/0029-sysroot_tests-disable-f16-math.patch
@@ -4,13 +4,13 @@ Date: Sun, 15 Feb 2026 14:06:49 +0000
 Subject: [PATCH] Disable f16 math tests for cranelift
 
 ---
- coretests/tests/floats/mod.rs | 26 +++++++++++++-------------
+ coretests/tests/num/floats.rs | 26 +++++++++++++-------------
  1 file changed, 13 insertions(+), 13 deletions(-)
 
 diff --git a/coretests/tests/floats/mod.rs b/coretests/tests/floats/mod.rs
 index c61961f8584..d7b4fa20322 100644
---- a/coretests/tests/floats/mod.rs
-+++ b/coretests/tests/floats/mod.rs
+--- a/coretests/tests/num/floats.rs
++++ b/coretests/tests/num/floats.rs
 @@ -1534,7 +1534,7 @@ fn s_nan() -> Float {
      name: powf,
      attrs: {
@@ -128,6 +128,5 @@ index c61961f8584..d7b4fa20322 100644
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
      test {
--- 
+--
 2.50.1
-
diff --git a/library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs b/library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs
index b0f6a7545aa9..2a82ae326c22 100644
--- a/library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs
+++ b/library/coretests/tests/num/float_ieee754_flt2dec_dec2flt.rs
@@ -18,8 +18,8 @@
 //! integer types.
 //!
 //! For our purposes,
-//! "interchange format"          => f32, f64
-//! "arithmetic format"           => f32, f64, and any "soft floats"
+//! "interchange format"          => f16, f32, f64, f128
+//! "arithmetic format"           => f16, f32, f64, f128, and any "soft floats"
 //! "external character sequence" => str from any float
 //! "integer format"              => {i,u}{8,16,32,64,128}
 //!
@@ -28,131 +28,139 @@
 //! Please consider this carefully when adding, removing, or reorganizing these tests. They are
 //! here so that it is clear what tests are required by the standard and what can be changed.
 
-use ::core::str::FromStr;
+use core::fmt;
+use core::str::FromStr;
 
-// IEEE 754 for many tests is applied to specific bit patterns.
-// These generally are not applicable to NaN, however.
-macro_rules! assert_biteq {
-    ($lhs:expr, $rhs:expr) => {
-        assert_eq!($lhs.to_bits(), $rhs.to_bits())
-    };
+use crate::num::{assert_biteq, float_test};
+
+/// ToString uses the default fmt::Display impl without special concerns, and bypasses other parts
+/// of the formatting infrastructure, which makes it ideal for testing here.
+#[track_caller]
+fn string_roundtrip<T>(x: T) -> T
+where
+    T: FromStr<Err: fmt::Debug> + fmt::Display,
+{
+    x.to_string().parse::<T>().unwrap()
 }
 
-// ToString uses the default fmt::Display impl without special concerns, and bypasses other parts
-// of the formatting infrastructure, which makes it ideal for testing here.
-macro_rules! roundtrip {
-    ($f:expr => $t:ty) => {
-        ($f).to_string().parse::<$t>().unwrap()
-    };
-}
-
-macro_rules! assert_floats_roundtrip {
-    ($f:ident) => {
-        assert_biteq!(f32::$f, roundtrip!(f32::$f => f32));
-        assert_biteq!(f64::$f, roundtrip!(f64::$f => f64));
-    };
-    ($f:expr) => {
-        assert_biteq!($f as f32, roundtrip!($f => f32));
-        assert_biteq!($f as f64, roundtrip!($f => f64));
-    }
-}
-
-macro_rules! assert_floats_bitne {
-    ($lhs:ident, $rhs:ident) => {
-        assert_ne!(f32::$lhs.to_bits(), f32::$rhs.to_bits());
-        assert_ne!(f64::$lhs.to_bits(), f64::$rhs.to_bits());
-    };
-    ($lhs:expr, $rhs:expr) => {
-        assert_ne!(f32::to_bits($lhs), f32::to_bits($rhs));
-        assert_ne!(f64::to_bits($lhs), f64::to_bits($rhs));
-    };
-}
+// FIXME(f128): Tests are disabled while we don't have parsing / printing
 
 // We must preserve signs on all numbers. That includes zero.
 // -0 and 0 are == normally, so test bit equality.
-#[test]
-fn preserve_signed_zero() {
-    assert_floats_roundtrip!(-0.0);
-    assert_floats_roundtrip!(0.0);
-    assert_floats_bitne!(0.0, -0.0);
+float_test! {
+    name: preserve_signed_zero,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        let neg0 = flt(-0.0);
+        let pos0 = flt(0.0);
+        assert_biteq!(neg0, string_roundtrip(neg0));
+        assert_biteq!(pos0, string_roundtrip(pos0));
+        assert_ne!(neg0.to_bits(), pos0.to_bits());
+    }
 }
 
-#[test]
-fn preserve_signed_infinity() {
-    assert_floats_roundtrip!(INFINITY);
-    assert_floats_roundtrip!(NEG_INFINITY);
-    assert_floats_bitne!(INFINITY, NEG_INFINITY);
+float_test! {
+    name: preserve_signed_infinity,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        let neg_inf = Float::NEG_INFINITY;
+        let pos_inf = Float::INFINITY;
+        assert_biteq!(neg_inf, string_roundtrip(neg_inf));
+        assert_biteq!(pos_inf, string_roundtrip(pos_inf));
+        assert_ne!(neg_inf.to_bits(), pos_inf.to_bits());
+    }
 }
 
-#[test]
-fn infinity_to_str() {
-    assert!(match f32::INFINITY.to_string().to_lowercase().as_str() {
-        "+infinity" | "infinity" => true,
-        "+inf" | "inf" => true,
-        _ => false,
-    });
-    assert!(
-        match f64::INFINITY.to_string().to_lowercase().as_str() {
-            "+infinity" | "infinity" => true,
-            "+inf" | "inf" => true,
-            _ => false,
-        },
-        "Infinity must write to a string as some casing of inf or infinity, with an optional +."
-    );
+float_test! {
+    name: infinity_to_str,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        assert!(
+            match Float::INFINITY.to_string().to_lowercase().as_str() {
+                "+infinity" | "infinity" => true,
+                "+inf" | "inf" => true,
+                _ => false,
+            },
+            "Infinity must write to a string as some casing of inf or infinity, with an optional +."
+        );
+        assert!(
+            match Float::NEG_INFINITY.to_string().to_lowercase().as_str() {
+                "-infinity" | "-inf" => true,
+                _ => false,
+            },
+            "Negative Infinity must write to a string as some casing of -inf or -infinity"
+        );
+    }
 }
 
-#[test]
-fn neg_infinity_to_str() {
-    assert!(match f32::NEG_INFINITY.to_string().to_lowercase().as_str() {
-        "-infinity" | "-inf" => true,
-        _ => false,
-    });
-    assert!(
-        match f64::NEG_INFINITY.to_string().to_lowercase().as_str() {
-            "-infinity" | "-inf" => true,
-            _ => false,
-        },
-        "Negative Infinity must write to a string as some casing of -inf or -infinity"
-    )
+float_test! {
+    name: nan_to_str,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        assert!(
+            match Float::NAN.to_string().to_lowercase().as_str() {
+                "nan" | "+nan" | "-nan" => true,
+                _ => false,
+            },
+            "NaNs must write to a string as some casing of nan."
+        )
+    }
 }
 
-#[test]
-fn nan_to_str() {
-    assert!(
-        match f32::NAN.to_string().to_lowercase().as_str() {
-            "nan" | "+nan" | "-nan" => true,
-            _ => false,
-        },
-        "NaNs must write to a string as some casing of nan."
-    )
+float_test! {
+    name: infinity_from_str,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        // "+"?("inf"|"infinity") in any case => Infinity
+        assert_biteq!(Float::INFINITY, Float::from_str("infinity").unwrap());
+        assert_biteq!(Float::INFINITY, Float::from_str("inf").unwrap());
+        assert_biteq!(Float::INFINITY, Float::from_str("+infinity").unwrap());
+        assert_biteq!(Float::INFINITY, Float::from_str("+inf").unwrap());
+        // yes! this means you are weLcOmE tO mY iNfInItElY tWiStEd MiNd
+        assert_biteq!(Float::INFINITY, Float::from_str("+iNfInItY").unwrap());
+
+        // "-inf"|"-infinity" in any case => Negative Infinity
+        assert_biteq!(Float::NEG_INFINITY, Float::from_str("-infinity").unwrap());
+        assert_biteq!(Float::NEG_INFINITY, Float::from_str("-inf").unwrap());
+        assert_biteq!(Float::NEG_INFINITY, Float::from_str("-INF").unwrap());
+        assert_biteq!(Float::NEG_INFINITY, Float::from_str("-INFinity").unwrap());
+
+    }
 }
 
-// "+"?("inf"|"infinity") in any case => Infinity
-#[test]
-fn infinity_from_str() {
-    assert_biteq!(f32::INFINITY, f32::from_str("infinity").unwrap());
-    assert_biteq!(f32::INFINITY, f32::from_str("inf").unwrap());
-    assert_biteq!(f32::INFINITY, f32::from_str("+infinity").unwrap());
-    assert_biteq!(f32::INFINITY, f32::from_str("+inf").unwrap());
-    // yes! this means you are weLcOmE tO mY iNfInItElY tWiStEd MiNd
-    assert_biteq!(f32::INFINITY, f32::from_str("+iNfInItY").unwrap());
-}
-
-// "-inf"|"-infinity" in any case => Negative Infinity
-#[test]
-fn neg_infinity_from_str() {
-    assert_biteq!(f32::NEG_INFINITY, f32::from_str("-infinity").unwrap());
-    assert_biteq!(f32::NEG_INFINITY, f32::from_str("-inf").unwrap());
-    assert_biteq!(f32::NEG_INFINITY, f32::from_str("-INF").unwrap());
-    assert_biteq!(f32::NEG_INFINITY, f32::from_str("-INFinity").unwrap());
-}
-
-// ("+"|"-"")?"s"?"nan" in any case => qNaN
-#[test]
-fn qnan_from_str() {
-    assert!("nan".parse::<f32>().unwrap().is_nan());
-    assert!("-nan".parse::<f32>().unwrap().is_nan());
-    assert!("+nan".parse::<f32>().unwrap().is_nan());
-    assert!("+NAN".parse::<f32>().unwrap().is_nan());
-    assert!("-NaN".parse::<f32>().unwrap().is_nan());
+float_test! {
+    name: qnan_from_str,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(false)],
+    },
+    test {
+        // ("+"|"-"")?"s"?"nan" in any case => qNaN
+        assert!("nan".parse::<Float>().unwrap().is_nan());
+        assert!("-nan".parse::<Float>().unwrap().is_nan());
+        assert!("+nan".parse::<Float>().unwrap().is_nan());
+        assert!("+NAN".parse::<Float>().unwrap().is_nan());
+        assert!("-NaN".parse::<Float>().unwrap().is_nan());
+    }
 }
diff --git a/library/coretests/tests/num/floats.rs b/library/coretests/tests/num/floats.rs
index ca9214cfbb07..d87f85094450 100644
--- a/library/coretests/tests/num/floats.rs
+++ b/library/coretests/tests/num/floats.rs
@@ -2,7 +2,7 @@
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
-trait TestableFloat: Sized {
+pub(crate) trait TestableFloat: Sized {
     const BITS: u32;
     /// Unsigned int with the same size, for converting to/from bits.
     type Int;
@@ -224,7 +224,7 @@ impl TestableFloat for f128 {
 }
 
 /// Determine the tolerance for values of the argument type.
-const fn lim_for_ty<T: TestableFloat + Copy>(_x: T) -> T {
+pub(crate) const fn lim_for_ty<T: TestableFloat + Copy>(_x: T) -> T {
     T::APPROX
 }
 
@@ -272,8 +272,8 @@ macro_rules! assert_biteq {
             // We rely on the `Float` type being brought in scope by the macros below.
             l: Float = l,
             r: Float = r,
-            lb: <Float as TestableFloat>::Int = l.to_bits(),
-            rb: <Float as TestableFloat>::Int = r.to_bits(),
+            lb: <Float as $crate::num::floats::TestableFloat>::Int = l.to_bits(),
+            rb: <Float as $crate::num::floats::TestableFloat>::Int = r.to_bits(),
             width: usize = ((bits / 4) + 2) as usize,
         );
     }};
@@ -314,6 +314,7 @@ macro_rules! float_test {
         test $test:block
     ) => {
         mod $name {
+            #[allow(unused_imports)]
             use super::*;
 
             #[test]
@@ -362,6 +363,7 @@ const fn flt (x: Float) -> Float { x }
 
             $( $( #[$const_meta] )+ )?
             mod const_ {
+                #[allow(unused_imports)]
                 use super::*;
 
                 #[test]
@@ -412,6 +414,9 @@ const fn flt (x: Float) -> Float { x }
     };
 }
 
+pub(crate) use assert_biteq;
+pub(crate) use float_test;
+
 float_test! {
     name: num,
     attrs: {
diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index 0e3913fab498..e0214c6ae686 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -37,6 +37,8 @@
 mod ops;
 mod wrapping;
 
+use floats::{assert_biteq, float_test};
+
 /// Adds the attribute to all items in the block.
 macro_rules! cfg_block {
     ($(#[$attr:meta]{$($it:item)*})*) => {$($(

From fe2a2fb8c67be4c3484e8d2f61a000b1fc0c3838 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 19 Mar 2026 16:08:00 +0000
Subject: [PATCH 0668/1059] coretests: Expand ieee754 parsing and printing
 tests to f16

Use `float_test!` to cover all types, with a note about f128 missing the
traits.
---
 patches/0029-sysroot_tests-disable-f16-math.patch | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/patches/0029-sysroot_tests-disable-f16-math.patch b/patches/0029-sysroot_tests-disable-f16-math.patch
index 340f6cc9b0e7..2a6bfe816457 100644
--- a/patches/0029-sysroot_tests-disable-f16-math.patch
+++ b/patches/0029-sysroot_tests-disable-f16-math.patch
@@ -4,13 +4,13 @@ Date: Sun, 15 Feb 2026 14:06:49 +0000
 Subject: [PATCH] Disable f16 math tests for cranelift
 
 ---
- coretests/tests/floats/mod.rs | 26 +++++++++++++-------------
+ coretests/tests/num/floats.rs | 26 +++++++++++++-------------
  1 file changed, 13 insertions(+), 13 deletions(-)
 
 diff --git a/coretests/tests/floats/mod.rs b/coretests/tests/floats/mod.rs
 index c61961f8584..d7b4fa20322 100644
---- a/coretests/tests/floats/mod.rs
-+++ b/coretests/tests/floats/mod.rs
+--- a/coretests/tests/num/floats.rs
++++ b/coretests/tests/num/floats.rs
 @@ -1534,7 +1534,7 @@ fn s_nan() -> Float {
      name: powf,
      attrs: {
@@ -128,6 +128,5 @@ index c61961f8584..d7b4fa20322 100644
          f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
      },
      test {
--- 
+--
 2.50.1
-

From caad6ee2404cbe49915052f342b6227437e4d2a9 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Thu, 19 Mar 2026 19:10:21 +0100
Subject: [PATCH 0669/1059] tests: Add regression test for async closures
 involving HRTBs

I suspect the original code had several issues. The last one that made
the code compile entered `nightly-2024-02-11`. The code fails to build
with `nightly-2024-02-10`:

    $ rustc +nightly-2024-02-10 --edition 2018 tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs
    error[E0277]: expected a `FnOnce(&u8)` closure, found `{coroutine-closure@tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs:31:9: 31:30}`
      --> tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs:31:9
       |
    31 |     foo(async move | f: &u8 | { *f });
       |     --- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected an `FnOnce(&u8)` closure, found `{coroutine-closure@tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs:31:9: 31:30}`
       |     |
       |     required by a bound introduced by this call
       |

(Note that you must add `#![feature(async_closure)]` to test with such
old nightlies, since they are from before stabilization of async
closures.)

This was probably fixed by 3bb384aad6e7f6.
---
 .../unifying-function-types-involving-hrtb.rs | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs

diff --git a/tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs b/tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs
new file mode 100644
index 000000000000..05505206b713
--- /dev/null
+++ b/tests/ui/async-await/async-closures/unifying-function-types-involving-hrtb.rs
@@ -0,0 +1,33 @@
+//! Regresssion test for <https://github.com/rust-lang/rust/issues/59337>.
+
+//@ edition:2018
+//@ check-pass
+
+use std::future::Future;
+
+trait Foo<'a> {
+    type Future: Future<Output = u8> + 'a;
+
+    fn start(self, f: &'a u8) -> Self::Future;
+}
+
+impl<'a, Fn, Fut> Foo<'a> for Fn
+where
+    Fn: FnOnce(&'a u8) -> Fut,
+    Fut: Future<Output = u8> + 'a,
+{
+    type Future = Fut;
+
+    fn start(self, f: &'a u8) -> Self::Future { (self)(f) }
+}
+
+fn foo<F>(f: F) where F: for<'a> Foo<'a> {
+    let bar = 5;
+    f.start(&bar);
+}
+
+fn main() {
+    foo(async move | f: &u8 | { *f });
+
+    foo({ async fn baz(f: &u8) -> u8 { *f } baz });
+}

From 191969d3eaa2a45ccc645fee8e62af3b6fb02ad1 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@ferrous-systems.com>
Date: Thu, 19 Mar 2026 19:38:25 +0100
Subject: [PATCH 0670/1059] remove outdated TODO

we decided not to implement this after all
---
 .../rust-analyzer/crates/hir/src/diagnostics.rs    | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/diagnostics.rs b/src/tools/rust-analyzer/crates/hir/src/diagnostics.rs
index 050777a4806d..7f672a697c41 100644
--- a/src/tools/rust-analyzer/crates/hir/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/diagnostics.rs
@@ -51,20 +51,6 @@ fn from(d: $diag $(<$lt>)?) -> $AnyDiagnostic<$db> {
         )*
     };
 }
-// FIXME Accept something like the following in the macro call instead
-// diagnostics![
-// pub struct BreakOutsideOfLoop {
-//     pub expr: InFile<AstPtr<ast::Expr>>,
-//     pub is_break: bool,
-//     pub bad_value_break: bool,
-// }, ...
-// or more concisely
-// BreakOutsideOfLoop {
-//     expr: InFile<AstPtr<ast::Expr>>,
-//     is_break: bool,
-//     bad_value_break: bool,
-// }, ...
-// ]
 
 diagnostics![AnyDiagnostic<'db> ->
     AwaitOutsideOfAsync,

From e72674e78c41ef332d7533324109db866f27621e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 22 Feb 2026 17:14:07 +0100
Subject: [PATCH 0671/1059] remove -Csoft-float

---
 compiler/rustc_codegen_llvm/src/back/write.rs | 12 +----
 compiler/rustc_interface/src/tests.rs         |  1 -
 compiler/rustc_session/src/errors.rs          | 11 ----
 compiler/rustc_session/src/lib.rs             |  2 +
 compiler/rustc_session/src/options.rs         | 52 ++++++++++++-------
 compiler/rustc_session/src/session.rs         | 10 ----
 6 files changed, 38 insertions(+), 50 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index efd4e55d5a85..ffa582737ca8 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -23,9 +23,7 @@
 use rustc_session::Session;
 use rustc_session::config::{self, Lto, OutputType, Passes, SplitDwarfKind, SwitchWithOptPath};
 use rustc_span::{BytePos, InnerSpan, Pos, RemapPathScopeComponents, SpanData, SyntaxContext, sym};
-use rustc_target::spec::{
-    Arch, CodeModel, FloatAbi, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel,
-};
+use rustc_target::spec::{CodeModel, FloatAbi, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel};
 use tracing::{debug, trace};
 
 use crate::back::lto::{Buffer, ModuleBuffer};
@@ -206,13 +204,7 @@ pub(crate) fn target_machine_factory(
     let reloc_model = to_llvm_relocation_model(sess.relocation_model());
 
     let (opt_level, _) = to_llvm_opt_settings(optlvl);
-    let float_abi = if sess.target.arch == Arch::Arm && sess.opts.cg.soft_float {
-        llvm::FloatAbi::Soft
-    } else {
-        // `validate_commandline_args_with_session_available` has already warned about this being
-        // ignored. Let's make sure LLVM doesn't suddenly start using this flag on more targets.
-        to_llvm_float_abi(sess.target.llvm_floatabi)
-    };
+    let float_abi = to_llvm_float_abi(sess.target.llvm_floatabi);
 
     let ffunction_sections =
         sess.opts.unstable_opts.function_sections.unwrap_or(sess.target.function_sections);
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 6c2924dfe9bd..f9d583bdf18c 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -637,7 +637,6 @@ macro_rules! tracked {
     tracked!(profile_use, Some(PathBuf::from("abc")));
     tracked!(relocation_model, Some(RelocModel::Pic));
     tracked!(relro_level, Some(RelroLevel::Full));
-    tracked!(soft_float, true);
     tracked!(split_debuginfo, Some(SplitDebuginfo::Packed));
     tracked!(symbol_mangling_version, Some(SymbolManglingVersion::V0));
     tracked!(target_cpu, Some(String::from("abc")));
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index cb3f7363957e..d1899de067b4 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -517,17 +517,6 @@ pub(crate) struct FailedToCreateProfiler {
     pub(crate) err: String,
 }
 
-#[derive(Diagnostic)]
-#[diag("`-Csoft-float` is ignored on this target; it only has an effect on *eabihf targets")]
-#[note("this may become a hard error in a future version of Rust")]
-pub(crate) struct SoftFloatIgnored;
-
-#[derive(Diagnostic)]
-#[diag("`-Csoft-float` is unsound and deprecated; use a corresponding *eabi target instead")]
-#[note("it will be removed or ignored in a future version of Rust")]
-#[note("see issue #129893 <https://github.com/rust-lang/rust/issues/129893> for more information")]
-pub(crate) struct SoftFloatDeprecated;
-
 #[derive(Diagnostic)]
 #[diag("unexpected `--cfg {$cfg}` flag")]
 #[note("config `{$cfg_name}` is only supposed to be controlled by `{$controlled_by}`")]
diff --git a/compiler/rustc_session/src/lib.rs b/compiler/rustc_session/src/lib.rs
index 98731a235d41..1741dde90f5c 100644
--- a/compiler/rustc_session/src/lib.rs
+++ b/compiler/rustc_session/src/lib.rs
@@ -1,5 +1,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![feature(const_option_ops)]
+#![feature(const_trait_impl)]
 #![feature(default_field_values)]
 #![feature(iter_intersperse)]
 #![feature(macro_derive)]
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 5db8ed823dfe..d15c1ea4ee8f 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -611,7 +611,7 @@ macro_rules! options {
         $parse:ident,
         [$dep_tracking_marker:ident $( $tmod:ident )?],
         $desc:expr
-        $(, is_deprecated_and_do_nothing: $dnn:literal )?)
+        $(, removed: $removed:ident )?)
      ),* ,) =>
 (
     #[derive(Clone)]
@@ -667,7 +667,7 @@ pub fn gather_target_modifiers(
 
     pub const $stat: OptionDescrs<$struct_name> =
         &[ $( OptionDesc{ name: stringify!($opt), setter: $optmod::$opt,
-            type_desc: desc::$parse, desc: $desc, is_deprecated_and_do_nothing: false $( || $dnn )?,
+            type_desc: desc::$parse, desc: $desc, removed: None $( .or(Some(RemovedOption::$removed)) )?,
             tmod: tmod_enum_opt!($struct_name, $tmod_enum_name, $opt, $($tmod),*) } ),* ];
 
     mod $optmod {
@@ -705,6 +705,12 @@ macro_rules! redirect_field {
 type OptionSetter<O> = fn(&mut O, v: Option<&str>) -> bool;
 type OptionDescrs<O> = &'static [OptionDesc<O>];
 
+/// Indicates whether a removed option should warn or error.
+enum RemovedOption {
+    Warn,
+    Err,
+}
+
 pub struct OptionDesc<O> {
     name: &'static str,
     setter: OptionSetter<O>,
@@ -712,7 +718,7 @@ pub struct OptionDesc<O> {
     type_desc: &'static str,
     // description for option from options table
     desc: &'static str,
-    is_deprecated_and_do_nothing: bool,
+    removed: Option<RemovedOption>,
     tmod: Option<OptionsTargetModifiers>,
 }
 
@@ -743,18 +749,18 @@ fn build_options<O: Default>(
 
         let option_to_lookup = key.replace('-', "_");
         match descrs.iter().find(|opt_desc| opt_desc.name == option_to_lookup) {
-            Some(OptionDesc {
-                name: _,
-                setter,
-                type_desc,
-                desc,
-                is_deprecated_and_do_nothing,
-                tmod,
-            }) => {
-                if *is_deprecated_and_do_nothing {
+            Some(OptionDesc { name: _, setter, type_desc, desc, removed, tmod }) => {
+                if let Some(removed) = removed {
                     // deprecation works for prefixed options only
                     assert!(!prefix.is_empty());
-                    early_dcx.early_warn(format!("`-{prefix} {key}`: {desc}"));
+                    match removed {
+                        RemovedOption::Warn => {
+                            early_dcx.early_warn(format!("`-{prefix} {key}`: {desc}"))
+                        }
+                        RemovedOption::Err => {
+                            early_dcx.early_fatal(format!("`-{prefix} {key}`: {desc}"))
+                        }
+                    }
                 }
                 if !setter(&mut op, value) {
                     match value {
@@ -783,6 +789,7 @@ fn build_options<O: Default>(
 
 #[allow(non_upper_case_globals)]
 mod desc {
+    pub(crate) const parse_ignore: &str = "<ignored>"; // should not be user-visible
     pub(crate) const parse_no_value: &str = "no value";
     pub(crate) const parse_bool: &str =
         "one of: `y`, `yes`, `on`, `true`, `n`, `no`, `off` or `false`";
@@ -889,6 +896,12 @@ pub mod parse {
     pub(crate) use super::*;
     pub(crate) const MAX_THREADS_CAP: usize = 256;
 
+    /// Ignore the value. Used for removed options where we don't actually want to store
+    /// anything in the session.
+    pub(crate) fn parse_ignore(_slot: &mut (), _v: Option<&str>) -> bool {
+        true
+    }
+
     /// This is for boolean options that don't take a value, and are true simply
     /// by existing on the command-line.
     ///
@@ -2059,7 +2072,7 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     #[rustc_lint_opt_deny_field_access("documented to do nothing")]
     ar: String = (String::new(), parse_string, [UNTRACKED],
         "this option is deprecated and does nothing",
-        is_deprecated_and_do_nothing: true),
+        removed: Warn),
     #[rustc_lint_opt_deny_field_access("use `Session::code_model` instead of this field")]
     code_model: Option<CodeModel> = (None, parse_code_model, [TRACKED],
         "choose the code model to use (`rustc --print code-models` for details)"),
@@ -2098,7 +2111,7 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     inline_threshold: Option<u32> = (None, parse_opt_number, [UNTRACKED],
         "this option is deprecated and does nothing \
         (consider using `-Cllvm-args=--inline-threshold=...`)",
-        is_deprecated_and_do_nothing: true),
+        removed: Warn),
     #[rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field")]
     instrument_coverage: InstrumentCoverage = (InstrumentCoverage::No, parse_instrument_coverage, [TRACKED],
         "instrument the generated code to support LLVM source-based code coverage reports \
@@ -2139,7 +2152,7 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     #[rustc_lint_opt_deny_field_access("documented to do nothing")]
     no_stack_check: bool = (false, parse_no_value, [UNTRACKED],
         "this option is deprecated and does nothing",
-        is_deprecated_and_do_nothing: true),
+        removed: Warn),
     no_vectorize_loops: bool = (false, parse_no_value, [TRACKED],
         "disable loop vectorization optimization passes"),
     no_vectorize_slp: bool = (false, parse_no_value, [TRACKED],
@@ -2173,8 +2186,11 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
         "set rpath values in libs/exes (default: no)"),
     save_temps: bool = (false, parse_bool, [UNTRACKED],
         "save all temporary output files during compilation (default: no)"),
-    soft_float: bool = (false, parse_bool, [TRACKED],
-        "deprecated option: use soft float ABI (*eabihf targets only) (default: no)"),
+    #[rustc_lint_opt_deny_field_access("documented to do nothing")]
+    soft_float: () = ((), parse_ignore, [UNTRACKED],
+        "this option has been removed \
+        (use a corresponding *eabi target instead)",
+        removed: Err),
     #[rustc_lint_opt_deny_field_access("use `Session::split_debuginfo` instead of this field")]
     split_debuginfo: Option<SplitDebuginfo> = (None, parse_split_debuginfo, [TRACKED],
         "how to handle split-debuginfo, a platform-specific option"),
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 8290bdf91a03..fece46dd9711 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -1360,16 +1360,6 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
             }
         }
     }
-
-    if sess.opts.cg.soft_float {
-        if sess.target.arch == Arch::Arm {
-            sess.dcx().emit_warn(errors::SoftFloatDeprecated);
-        } else {
-            // All `use_softfp` does is the equivalent of `-mfloat-abi` in GCC/clang, which only exists on ARM targets.
-            // We document this flag to only affect `*eabihf` targets, so let's show a warning for all other targets.
-            sess.dcx().emit_warn(errors::SoftFloatIgnored);
-        }
-    }
 }
 
 /// Holds data on the current incremental compilation session, if there is one.

From 359718ce103db5e46eece007c928e7d35b74786f Mon Sep 17 00:00:00 2001
From: Bourumir Wyngs <bourumir.wyngs@gmail.com>
Date: Thu, 19 Mar 2026 22:58:53 +0100
Subject: [PATCH 0672/1059] Adding serde-yaml-bw memory leak detection

---
 src/tools/miri/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 4808e53698c6..bd77d5616769 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -641,6 +641,7 @@ Definite bugs found:
 * [`winit` registering a global constructor with the wrong ABI on Windows](https://github.com/rust-windowing/winit/issues/4435)
 * [`VecDeque::splice` confusing physical and logical indices](https://github.com/rust-lang/rust/issues/151758)
 * [Data race in `oneshot` channel](https://github.com/faern/oneshot/issues/69)
+* [Memory leak is serde-yaml-bw library](https://github.com/bourumir-wyngs/serde-yaml-bw/issues/197)
 
 Violations of [Stacked Borrows] found that are likely bugs (but Stacked Borrows is currently just an experiment):
 

From 4d7a71ea9255a82d562929d4b965fa34720ef5c5 Mon Sep 17 00:00:00 2001
From: Bourumir Wyngs <bourumir.wyngs@gmail.com>
Date: Thu, 19 Mar 2026 23:16:05 +0100
Subject: [PATCH 0673/1059] Maybe to say more words what kind of the leak

---
 src/tools/miri/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index bd77d5616769..28cdc8f0a7f9 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -641,7 +641,7 @@ Definite bugs found:
 * [`winit` registering a global constructor with the wrong ABI on Windows](https://github.com/rust-windowing/winit/issues/4435)
 * [`VecDeque::splice` confusing physical and logical indices](https://github.com/rust-lang/rust/issues/151758)
 * [Data race in `oneshot` channel](https://github.com/faern/oneshot/issues/69)
-* [Memory leak is serde-yaml-bw library](https://github.com/bourumir-wyngs/serde-yaml-bw/issues/197)
+* [Memory leak in serde-yaml-bw caused by early return before libyaml event cleanup in Parser::next](https://github.com/bourumir-wyngs/serde-yaml-bw/issues/197)
 
 Violations of [Stacked Borrows] found that are likely bugs (but Stacked Borrows is currently just an experiment):
 

From 0d727e54f06e9ab3e15f78f9434b0a52c2197047 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Thu, 19 Mar 2026 22:29:49 +0000
Subject: [PATCH 0674/1059] llvm: Update `reliable_f128` configuration for
 LLVM22 on Sparc

LLVM22 should have resolved issues with the `f128` ABI, meaning we can
now set `cfg(target_has_reliable_f128)` on the platform.

Link: https://github.com/llvm/llvm-project/commit/3e16aef2a650a8c2da4ebd5c58c6a9e261361828
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 2423880ab869..45e16a735fed 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -394,8 +394,8 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         // ABI bugs <https://github.com/rust-lang/rust/issues/125109> et al. (full
         // list at <https://github.com/rust-lang/rust/issues/116909>)
         (Arch::PowerPC | Arch::PowerPC64, _) => false,
-        // ABI unsupported  <https://github.com/llvm/llvm-project/issues/41838>
-        (Arch::Sparc, _) => false,
+        // ABI unsupported  <https://github.com/llvm/llvm-project/issues/41838> (fixed in llvm22)
+        (Arch::Sparc, _) if major < 22 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
         (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
         // There are no known problems on other platforms, so the only requirement is that symbols

From 22e1148d97b791e90c53bfef2fc2810c5d6a8433 Mon Sep 17 00:00:00 2001
From: teor <teor@riseup.net>
Date: Thu, 19 Mar 2026 12:07:02 +1000
Subject: [PATCH 0675/1059] Update typos.toml allow list

---
 typos.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/typos.toml b/typos.toml
index 3c95a45d572d..82e2b98f2e49 100644
--- a/typos.toml
+++ b/typos.toml
@@ -20,6 +20,7 @@ extend-exclude = [
 # right now. Entries should look like `mipsel = "mipsel"`.
 #
 # tidy-alphabetical-start
+anser = "anser" # an ANSI parsing package used by rust-analyzer
 arange = "arange" # short for A-range
 childs = "childs"
 clonable = "clonable"
@@ -29,10 +30,12 @@ makro = "makro" # deliberate misspelling to avoid `macro` keyword
 misformed = "misformed"
 moreso = "moreso"
 numer = "numer" # short for numerator, not a typo for "number"
+old-skool = "old-skool" # variant spelling of "old-school"
 optin = "optin" # short for opt-in
 publically = "publically"
 rplace = "rplace" # short for R-place
 splitted = "splitted"
+sythetic = "sythetic" # typo in vendored LLVM sources
 taits = "taits" # lowercase for TAITs (type alias impl trait)
 targetting = "targetting"
 unparseable = "unparseable"

From 55d9f7cb6c7880dc5e2b75f013666ad01e265d1f Mon Sep 17 00:00:00 2001
From: teor <teor@riseup.net>
Date: Mon, 16 Mar 2026 17:28:48 +1000
Subject: [PATCH 0676/1059] Fix typos and outdated comments

---
 compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs | 4 ++--
 compiler/rustc_codegen_ssa/src/mir/mod.rs                   | 2 +-
 compiler/rustc_hir/src/def.rs                               | 2 +-
 compiler/rustc_hir/src/target.rs                            | 6 +-----
 src/tools/compiletest/src/runtest.rs                        | 4 ++--
 5 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index a8db114129ff..652a783de322 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -169,7 +169,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
             return None;
         };
         let Some(classname) = nv.value_as_str() else {
-            // `#[rustc_objc_class = ...]` is expected to be used as an implementatioin detail
+            // `#[rustc_objc_class = ...]` is expected to be used as an implementation detail
             // inside a standard library macro, but `cx.expected_string_literal` exposes too much.
             // Use a custom error message instead.
             cx.emit_err(ObjcClassExpectedStringLiteral { span: nv.value_span });
@@ -201,7 +201,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
             return None;
         };
         let Some(methname) = nv.value_as_str() else {
-            // `#[rustc_objc_selector = ...]` is expected to be used as an implementatioin detail
+            // `#[rustc_objc_selector = ...]` is expected to be used as an implementation detail
             // inside a standard library macro, but `cx.expected_string_literal` exposes too much.
             // Use a custom error message instead.
             cx.emit_err(ObjcSelectorExpectedStringLiteral { span: nv.value_span });
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index 1a0f66d31cca..5c14d6f2c093 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -437,7 +437,7 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 assert_eq!(
                     None,
                     num_untupled.replace(tupled_arg_tys.len()),
-                    "Replaced existing num_tupled"
+                    "Replaced existing num_untupled"
                 );
 
                 return LocalRef::Place(place);
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 3959ee7f9412..21abb5506fcc 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -192,7 +192,7 @@ pub enum DefKind {
     /// These are all represented with the same `ExprKind::Closure` in the AST and HIR,
     /// which makes it difficult to distinguish these during def collection. Therefore,
     /// we treat them all the same, and code which needs to distinguish them can match
-    /// or `hir::ClosureKind` or `type_of`.
+    /// on `hir::ClosureKind` or `type_of`.
     Closure,
     /// The definition of a synthetic coroutine body created by the lowering of a
     /// coroutine-closure, such as an async closure.
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
index dd685c44ec47..07c33eb935f2 100644
--- a/compiler/rustc_hir/src/target.rs
+++ b/compiler/rustc_hir/src/target.rs
@@ -1,8 +1,4 @@
-//! This module implements some validity checks for attributes.
-//! In particular it verifies that `#[inline]` and `#[repr]` attributes are
-//! attached to items that actually support them and if there are
-//! conflicts between multiple such attributes attached to the same
-//! item.
+//! This module lists attribute targets, with conversions from other types.
 
 use std::fmt::{self, Display};
 
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index b674c6e29d42..b584d14b0c9f 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2121,7 +2121,7 @@ fn output_base_name(&self) -> Utf8PathBuf {
     }
 
     /// Prints a message to (captured) stdout if `config.verbose` is true.
-    /// The message is also logged to `tracing::debug!` regardles of verbosity.
+    /// The message is also logged to `tracing::debug!` regardless of verbosity.
     ///
     /// Use `format_args!` as the argument to perform formatting if required.
     fn logv(&self, message: impl fmt::Display) {
@@ -2748,7 +2748,7 @@ fn compare_output(
                 return CompareOutcome::Same;
             }
             if expected_lines.is_empty() {
-                // if we have no lines to check, force a full overwite
+                // if we have no lines to check, force a full overwrite
                 ("", actual)
             } else {
                 // this prints/blesses the subset, not the actual

From 65335b65fe7611ca36a78e2a0eb6b6ee290d953e Mon Sep 17 00:00:00 2001
From: teor <teor@riseup.net>
Date: Thu, 12 Mar 2026 09:32:58 +1000
Subject: [PATCH 0677/1059] Fix markdown warnings in ui/README.md

---
 tests/ui/README.md | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/tests/ui/README.md b/tests/ui/README.md
index b6e655708892..c14cbd9b4387 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -133,7 +133,7 @@ Runtime panics and error handling generate backtraces to assist in debugging and
 
 This directory was originally meant to contain tests related to time complexity and benchmarking.
 
-However, only a single test was ever added to this category: https://github.com/rust-lang/rust/pull/32062
+However, only a single test was ever added to this category: <https://github.com/rust-lang/rust/pull/32062>
 
 **FIXME**: It is also unclear what would happen were this test to "fail" - would it cause the test suite to remain stuck on this test for a much greater duration than normal?
 
@@ -694,9 +694,7 @@ This test category revolves around trait objects with `Sized` having illegal ope
 Tests on lifetime elision in impl function signatures. See [Lifetime elision | Nomicon](https://doc.rust-lang.org/nomicon/lifetime-elision.html).
 
 ## `tests/ui/impl-restriction/`
-Tests for `#![feature(impl_restriction)]`. See [Tracking issue for restrictions #105077
-](https://github.com/rust-lang/rust/issues/105077).
-
+Tests for `#![feature(impl_restriction)]`. See [Tracking issue for restrictions #105077](https://github.com/rust-lang/rust/issues/105077).
 
 ## `tests/ui/impl-trait/`
 
@@ -796,8 +794,7 @@ See [Type Layout | Reference](https://doc.rust-lang.org/reference/type-layout.ht
 
 ## `tests/ui/lazy-type-alias/`
 
-Tests for `#![feature(lazy_type_alias)]`. See [Tracking issue for lazy type aliases #112792
-](https://github.com/rust-lang/rust/issues/112792).
+Tests for `#![feature(lazy_type_alias)]`. See [Tracking issue for lazy type aliases #112792](https://github.com/rust-lang/rust/issues/112792).
 
 ## `tests/ui/lazy-type-alias-impl-trait/`
 
@@ -852,7 +849,7 @@ See:
 
 Tests exercising analysis for unused variables, unreachable statements, functions which are supposed to return a value but do not, as well as values moved elsewhere before they could be used by a function.
 
-**FIXME**: This seems unrelated to "liveness" as defined in the rustc compiler guide. Is this misleadingly named? https://rustc-dev-guide.rust-lang.org/borrow_check/region_inference/lifetime_parameters.html#liveness-and-universal-regions
+**FIXME**: This seems unrelated to "liveness" as defined in the rustc compiler guide. Is this misleadingly named? <https://rustc-dev-guide.rust-lang.org/borrow_check/region_inference/lifetime_parameters.html#liveness-and-universal-regions>
 
 ## `tests/ui/loop-match`
 

From 0cc494621967992bd1f72415ab244832ef55a1f5 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <aleksey@lambdageek.org>
Date: Thu, 19 Mar 2026 21:18:31 -0400
Subject: [PATCH 0678/1059] add a test to make rustc_incremental
 finalize_session_directory rename fail

Use a proc macro to observe the incremental session directory and do
something platform specific so that renaming the '-working' session
directory during finalize_session_directory will fail.  On Unix,
change the permissions on the parent directory to be read-only.  On
Windows, open and leak a file inside the `-working` directory.
---
 .../run-make/incremental-finalize-fail/foo.rs |   5 +
 .../incremental-finalize-fail/poison/lib.rs   |  87 +++++++++++++++
 .../incremental-finalize-fail/rmake.rs        | 103 ++++++++++++++++++
 3 files changed, 195 insertions(+)
 create mode 100644 tests/run-make/incremental-finalize-fail/foo.rs
 create mode 100644 tests/run-make/incremental-finalize-fail/poison/lib.rs
 create mode 100644 tests/run-make/incremental-finalize-fail/rmake.rs

diff --git a/tests/run-make/incremental-finalize-fail/foo.rs b/tests/run-make/incremental-finalize-fail/foo.rs
new file mode 100644
index 000000000000..1f1e2842b465
--- /dev/null
+++ b/tests/run-make/incremental-finalize-fail/foo.rs
@@ -0,0 +1,5 @@
+poison::poison_finalize!();
+
+pub fn hello() -> i32 {
+    42
+}
diff --git a/tests/run-make/incremental-finalize-fail/poison/lib.rs b/tests/run-make/incremental-finalize-fail/poison/lib.rs
new file mode 100644
index 000000000000..e191cf7ade4c
--- /dev/null
+++ b/tests/run-make/incremental-finalize-fail/poison/lib.rs
@@ -0,0 +1,87 @@
+//! A proc macro that sabotages the incremental compilation finalize step.
+//!
+//! When invoked, it locates the `-working` session directory inside the
+//! incremental compilation directory (passed via POISON_INCR_DIR) and
+//! makes it impossible to rename:
+//!
+//!   - On Unix: removes write permission from the parent (crate) directory.
+//!   - On Windows: creates a file inside the -working directory and leaks
+//!     the file handle, preventing the directory from being renamed.
+
+extern crate proc_macro;
+
+use std::fs;
+use std::path::PathBuf;
+
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn poison_finalize(_input: TokenStream) -> TokenStream {
+    let incr_dir = std::env::var("POISON_INCR_DIR").expect("POISON_INCR_DIR must be set");
+
+    let crate_dir = find_crate_dir(&incr_dir);
+    let working_dir = find_working_dir(&crate_dir);
+
+    #[cfg(unix)]
+    poison_unix(&crate_dir);
+
+    #[cfg(windows)]
+    poison_windows(&working_dir);
+
+    TokenStream::new()
+}
+
+/// Remove write permission from the crate directory.
+/// This causes rename() to fail with EACCES
+#[cfg(unix)]
+fn poison_unix(crate_dir: &PathBuf) {
+    use std::os::unix::fs::PermissionsExt;
+    let mut perms = fs::metadata(crate_dir).unwrap().permissions();
+    perms.set_mode(0o555); // r-xr-xr-x
+    fs::set_permissions(crate_dir, perms).unwrap();
+}
+
+/// Create a file inside the -working directory and leak the
+/// handle. Windows prevents renaming a directory when any file inside it
+/// has an open handle. The handle stays open until the rustc process exits.
+#[cfg(windows)]
+fn poison_windows(working_dir: &PathBuf) {
+    let poison_file = working_dir.join("_poison_handle");
+    let f = fs::File::create(&poison_file).unwrap();
+    // Leak the handle so it stays open for the lifetime of the rustc process.
+    std::mem::forget(f);
+}
+
+/// Find the crate directory for `foo` inside the incremental compilation dir.
+///
+/// The incremental directory layout is:
+///   {incr_dir}/{crate_name}-{stable_crate_id}/
+fn find_crate_dir(incr_dir: &str) -> PathBuf {
+    let mut dirs = fs::read_dir(incr_dir).unwrap().filter_map(|e| {
+        let e = e.ok()?;
+        let name = e.file_name();
+        let name = name.to_str()?;
+        if e.file_type().ok()?.is_dir() && name.starts_with("foo-") { Some(e.path()) } else { None }
+    });
+
+    let first =
+        dirs.next().unwrap_or_else(|| panic!("no foo-* crate directory found in {incr_dir}"));
+    assert!(
+        dirs.next().is_none(),
+        "expected exactly one foo-* crate directory in {incr_dir}, found multiple"
+    );
+    first
+}
+
+/// Find the session directory ending in "-working" inside the crate directory
+fn find_working_dir(crate_dir: &PathBuf) -> PathBuf {
+    for entry in fs::read_dir(crate_dir).unwrap() {
+        let entry = entry.unwrap();
+        let name = entry.file_name();
+        let name = name.to_str().unwrap().to_string();
+        if name.starts_with("s-") && name.ends_with("-working") {
+            return entry.path();
+        }
+    }
+    panic!("no -working session directory found in {}", crate_dir.display());
+}
diff --git a/tests/run-make/incremental-finalize-fail/rmake.rs b/tests/run-make/incremental-finalize-fail/rmake.rs
new file mode 100644
index 000000000000..36ba2a48ca46
--- /dev/null
+++ b/tests/run-make/incremental-finalize-fail/rmake.rs
@@ -0,0 +1,103 @@
+//! Test that a failure to finalize the incremental compilation session directory
+//! (i.e., the rename from "-working" to the SVH-based name) results in a
+//! note, not an ICE, and that the compilation output is still produced.
+//!
+//! Strategy:
+//!   1. Build the `poison` proc-macro crate
+//!   2. Compile foo.rs with incremental compilation
+//!      The proc macro runs mid-compilation (after prepare_session_directory
+//!      but before finalize_session_directory) and sabotages the rename:
+//!        - On Unix: removes write permission from the crate directory,
+//!          so rename() fails with EACCES.
+//!        - On Windows: creates and leaks an open file handle inside the
+//!          -working directory, so rename() fails with ERROR_ACCESS_DENIED.
+//!   3. Assert that stderr contains the finalize failure messages
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use run_make_support::rustc;
+
+/// Guard that restores permissions on the incremental directory on drop,
+/// to ensure cleanup is possible
+struct IncrDirCleanup;
+
+fn main() {
+    let _cleanup = IncrDirCleanup;
+
+    // Build the poison proc-macro crate
+    rustc().input("poison/lib.rs").crate_name("poison").crate_type("proc-macro").run();
+
+    let poison_dylib = find_proc_macro_dylib("poison");
+
+    // Incremental compile with the poison macro active
+    let out = rustc()
+        .input("foo.rs")
+        .crate_type("rlib")
+        .incremental("incr")
+        .extern_("poison", &poison_dylib)
+        .env("POISON_INCR_DIR", "incr")
+        .run();
+
+    out.assert_stderr_contains("note: did not finalize incremental compilation session directory");
+    out.assert_stderr_contains(
+        "help: the next build will not be able to reuse work from this compilation",
+    );
+    out.assert_stderr_not_contains("internal compiler error");
+}
+
+impl Drop for IncrDirCleanup {
+    fn drop(&mut self) {
+        let incr = Path::new("incr");
+        if !incr.exists() {
+            return;
+        }
+
+        #[cfg(unix)]
+        restore_permissions(incr);
+    }
+}
+
+/// Recursively restore write permissions so rm -rf works after the chmod trick
+#[cfg(unix)]
+fn restore_permissions(path: &Path) {
+    use std::os::unix::fs::PermissionsExt;
+    if let Ok(entries) = fs::read_dir(path) {
+        for entry in entries.filter_map(|e| e.ok()) {
+            if entry.file_type().map_or(false, |ft| ft.is_dir()) {
+                let mut perms = match fs::metadata(entry.path()) {
+                    Ok(m) => m.permissions(),
+                    Err(_) => continue,
+                };
+                perms.set_mode(0o755);
+                let _ = fs::set_permissions(entry.path(), perms);
+            }
+        }
+    }
+}
+
+/// Locate the compiled proc-macro dylib by scanning the current directory.
+fn find_proc_macro_dylib(name: &str) -> PathBuf {
+    let prefix = if cfg!(target_os = "windows") { "" } else { "lib" };
+
+    let ext: &str = if cfg!(target_os = "macos") {
+        "dylib"
+    } else if cfg!(target_os = "windows") {
+        "dll"
+    } else {
+        "so"
+    };
+
+    let lib_name = format!("{prefix}{name}.{ext}");
+
+    for entry in fs::read_dir(".").unwrap() {
+        let entry = entry.unwrap();
+        let name = entry.file_name();
+        let name = name.to_str().unwrap();
+        if name == lib_name {
+            return entry.path();
+        }
+    }
+
+    panic!("could not find proc-macro dylib for `{name}`");
+}

From 54819a132525014ac021e90729728c1e6fdd4160 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:11:50 +0530
Subject: [PATCH 0679/1059] migrate qualify_path to use SyntaxEditor and
 SyntaxFactory

---
 .../ide-assists/src/handlers/qualify_path.rs  | 46 ++++++++++++-------
 1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
index b3cf2969650a..9ebeef90bae9 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
@@ -11,7 +11,8 @@
 use syntax::ast::HasGenericArgs;
 use syntax::{
     AstNode, ast,
-    ast::{HasArgList, make},
+    ast::{HasArgList, syntax_factory::SyntaxFactory},
+    syntax_editor::SyntaxEditor,
 };
 
 use crate::{
@@ -54,25 +55,25 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
     let qualify_candidate = match candidate {
         ImportCandidate::Path(candidate) if !candidate.qualifier.is_empty() => {
             cov_mark::hit!(qualify_path_qualifier_start);
-            let path = ast::Path::cast(syntax_under_caret)?;
+            let path = ast::Path::cast(syntax_under_caret.clone())?;
             let (prev_segment, segment) = (path.qualifier()?.segment()?, path.segment()?);
             QualifyCandidate::QualifierStart(segment, prev_segment.generic_arg_list())
         }
         ImportCandidate::Path(_) => {
             cov_mark::hit!(qualify_path_unqualified_name);
-            let path = ast::Path::cast(syntax_under_caret)?;
+            let path = ast::Path::cast(syntax_under_caret.clone())?;
             let generics = path.segment()?.generic_arg_list();
             QualifyCandidate::UnqualifiedName(generics)
         }
         ImportCandidate::TraitAssocItem(_) => {
             cov_mark::hit!(qualify_path_trait_assoc_item);
-            let path = ast::Path::cast(syntax_under_caret)?;
+            let path = ast::Path::cast(syntax_under_caret.clone())?;
             let (qualifier, segment) = (path.qualifier()?, path.segment()?);
             QualifyCandidate::TraitAssocItem(qualifier, segment)
         }
         ImportCandidate::TraitMethod(_) => {
             cov_mark::hit!(qualify_path_trait_method);
-            let mcall_expr = ast::MethodCallExpr::cast(syntax_under_caret)?;
+            let mcall_expr = ast::MethodCallExpr::cast(syntax_under_caret.clone())?;
             QualifyCandidate::TraitMethod(ctx.sema.db, mcall_expr)
         }
     };
@@ -101,12 +102,18 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
             label(ctx.db(), candidate, &import, current_edition),
             range,
             |builder| {
+                let make = SyntaxFactory::with_mappings();
+                let mut editor = builder.make_editor(&syntax_under_caret);
                 qualify_candidate.qualify(
                     |replace_with: String| builder.replace(range, replace_with),
+                    &mut editor,
+                    &make,
                     &import.import_path,
                     import.item_to_import,
                     current_edition,
-                )
+                );
+                editor.add_mappings(make.finish_with_mappings());
+                builder.add_file_edits(ctx.vfs_file_id(), editor);
             },
         );
     }
@@ -124,6 +131,8 @@ impl QualifyCandidate<'_> {
     pub(crate) fn qualify(
         &self,
         mut replacer: impl FnMut(String),
+        editor: &mut SyntaxEditor,
+        make: &SyntaxFactory,
         import: &hir::ModPath,
         item: hir::ItemInNs,
         edition: Edition,
@@ -142,10 +151,10 @@ pub(crate) fn qualify(
                 replacer(format!("<{qualifier} as {import}>::{segment}"));
             }
             QualifyCandidate::TraitMethod(db, mcall_expr) => {
-                Self::qualify_trait_method(db, mcall_expr, replacer, import, item);
+                Self::qualify_trait_method(db, mcall_expr, editor, make, import, item);
             }
             QualifyCandidate::ImplMethod(db, mcall_expr, hir_fn) => {
-                Self::qualify_fn_call(db, mcall_expr, replacer, import, hir_fn);
+                Self::qualify_fn_call(db, mcall_expr, editor, make, import, hir_fn);
             }
         }
     }
@@ -153,7 +162,8 @@ pub(crate) fn qualify(
     fn qualify_fn_call(
         db: &RootDatabase,
         mcall_expr: &ast::MethodCallExpr,
-        mut replacer: impl FnMut(String),
+        editor: &mut SyntaxEditor,
+        make: &SyntaxFactory,
         import: ast::Path,
         hir_fn: &hir::Function,
     ) -> Option<()> {
@@ -165,15 +175,18 @@ fn qualify_fn_call(
 
         if let Some(self_access) = hir_fn.self_param(db).map(|sp| sp.access(db)) {
             let receiver = match self_access {
-                hir::Access::Shared => make::expr_ref(receiver, false),
-                hir::Access::Exclusive => make::expr_ref(receiver, true),
+                hir::Access::Shared => make.expr_ref(receiver, false),
+                hir::Access::Exclusive => make.expr_ref(receiver, true),
                 hir::Access::Owned => receiver,
             };
             let arg_list = match arg_list {
-                Some(args) => make::arg_list(iter::once(receiver).chain(args)),
-                None => make::arg_list(iter::once(receiver)),
+                Some(args) => make.arg_list(iter::once(receiver).chain(args)),
+                None => make.arg_list(iter::once(receiver)),
             };
-            replacer(format!("{import}::{method_name}{generics}{arg_list}"));
+            let call_path =
+                make.path_from_text(&format!("{import}::{method_name}{generics}"));
+            let call_expr = make.expr_call(make.expr_path(call_path), arg_list);
+            editor.replace(mcall_expr.syntax(), call_expr.syntax());
         }
         Some(())
     }
@@ -181,14 +194,15 @@ fn qualify_fn_call(
     fn qualify_trait_method(
         db: &RootDatabase,
         mcall_expr: &ast::MethodCallExpr,
-        replacer: impl FnMut(String),
+        editor: &mut SyntaxEditor,
+        make: &SyntaxFactory,
         import: ast::Path,
         item: hir::ItemInNs,
     ) -> Option<()> {
         let trait_method_name = mcall_expr.name_ref()?;
         let trait_ = item_as_trait(db, item)?;
         let method = find_trait_method(db, trait_, &trait_method_name)?;
-        Self::qualify_fn_call(db, mcall_expr, replacer, import, &method)
+        Self::qualify_fn_call(db, mcall_expr, editor, make, import, &method)
     }
 }
 

From 43078250c25e7ba08037ead98fa4bd51a3b76a1c Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:12:31 +0530
Subject: [PATCH 0680/1059] remove direct make usage in add_label_to_loop via
 syntaxFactory

---
 .../ide-assists/src/handlers/add_label_to_loop.rs    | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
index b84ad24cfcef..7e9552e1fd1d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_label_to_loop.rs
@@ -3,11 +3,7 @@
 };
 use syntax::{
     SyntaxToken, T,
-    ast::{
-        self, AstNode, HasLoopBody,
-        make::{self, tokens},
-        syntax_factory::SyntaxFactory,
-    },
+    ast::{self, AstNode, HasLoopBody, syntax_factory::SyntaxFactory},
     syntax_editor::{Position, SyntaxEditor},
 };
 
@@ -52,8 +48,8 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
             let label = make.lifetime("'l");
             let elements = vec![
                 label.syntax().clone().into(),
-                make::token(T![:]).into(),
-                tokens::single_space().into(),
+                make.token(T![:]).into(),
+                make.whitespace(" ").into(),
             ];
             editor.insert_all(Position::before(&loop_kw), elements);
 
@@ -88,7 +84,7 @@ fn insert_label_after_token(
     builder: &mut SourceChangeBuilder,
 ) {
     let label = make.lifetime("'l");
-    let elements = vec![tokens::single_space().into(), label.syntax().clone().into()];
+    let elements = vec![make.whitespace(" ").into(), label.syntax().clone().into()];
     editor.insert_all(Position::after(token), elements);
 
     if let Some(cap) = ctx.config.snippet_cap {

From 61be42c90c744ffb1fee8d7d330a3013f55b1eb8 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:15:20 +0530
Subject: [PATCH 0681/1059] migrate desugar_try_expr to use syntax editor and
 syntax Factory

---
 .../src/handlers/desugar_try_expr.rs          | 48 ++++++++++---------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
index 9976e34e730c..402203015932 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
@@ -9,7 +9,6 @@
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
-        make,
         syntax_factory::SyntaxFactory,
     },
 };
@@ -68,41 +67,46 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
         AssistId::refactor_rewrite("desugar_try_expr_match"),
         "Replace try expression with match",
         target,
-        |edit| {
+        |builder| {
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(try_expr.syntax());
+
             let sad_pat = match try_enum {
-                TryEnum::Option => make::path_pat(make::ext::ident_path("None")),
-                TryEnum::Result => make::tuple_struct_pat(
-                    make::ext::ident_path("Err"),
-                    iter::once(make::path_pat(make::ext::ident_path("err"))),
-                )
-                .into(),
+                TryEnum::Option => make.path_pat(make.ident_path("None")),
+                TryEnum::Result => make
+                    .tuple_struct_pat(
+                        make.ident_path("Err"),
+                        iter::once(make.path_pat(make.ident_path("err"))),
+                    )
+                    .into(),
             };
             let sad_expr = match try_enum {
-                TryEnum::Option => {
-                    make::expr_return(Some(make::expr_path(make::ext::ident_path("None"))))
-                }
-                TryEnum::Result => make::expr_return(Some(
-                    make::expr_call(
-                        make::expr_path(make::ext::ident_path("Err")),
-                        make::arg_list(iter::once(make::expr_path(make::ext::ident_path("err")))),
+                TryEnum::Option => make.expr_return(Some(make.expr_path(make.ident_path("None")))),
+                TryEnum::Result => make.expr_return(Some(
+                    make.expr_call(
+                        make.expr_path(make.ident_path("Err")),
+                        make.arg_list(iter::once(make.expr_path(make.ident_path("err")))),
                     )
                     .into(),
                 )),
             };
 
-            let happy_arm = make::match_arm(
-                try_enum.happy_pattern(make::ident_pat(false, false, make::name("it")).into()),
+            let happy_arm = make.match_arm(
+                try_enum.happy_pattern(make.ident_pat(false, false, make.name("it")).into()),
                 None,
-                make::expr_path(make::ext::ident_path("it")),
+                make.expr_path(make.ident_path("it")),
             );
-            let sad_arm = make::match_arm(sad_pat, None, sad_expr);
+            let sad_arm = make.match_arm(sad_pat, None, sad_expr.into());
 
-            let match_arm_list = make::match_arm_list([happy_arm, sad_arm]);
+            let match_arm_list = make.match_arm_list([happy_arm, sad_arm]);
 
-            let expr_match = make::expr_match(expr.clone(), match_arm_list)
+            let expr_match = make
+                .expr_match(expr.clone(), match_arm_list)
                 .indent(IndentLevel::from_node(try_expr.syntax()));
 
-            edit.replace_ast::<ast::Expr>(try_expr.clone().into(), expr_match.into());
+            editor.replace(try_expr.syntax(), expr_match.syntax());
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     );
 

From 345a80f03cf09ca8100699523e5ae92a0f0f2c23 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:16:03 +0530
Subject: [PATCH 0682/1059] remove use make directly from extract_variable
 assist

replace use of make directly via syntaxFactory in replace_let_with_if_let assist
---
 .../ide-assists/src/handlers/extract_variable.rs     |  5 ++---
 .../src/handlers/replace_let_with_if_let.rs          | 12 +++++++-----
 .../syntax/src/ast/syntax_factory/constructors.rs    |  8 ++++++++
 3 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
index 7c6018414217..092775596239 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
@@ -9,7 +9,6 @@
     ast::{
         self, AstNode,
         edit::{AstNodeEdit, IndentLevel},
-        make,
         syntax_factory::SyntaxFactory,
     },
     syntax_editor::Position,
@@ -176,7 +175,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                 let mut editor = edit.make_editor(&expr_replace);
 
                 let pat_name = make.name(&var_name);
-                let name_expr = make.expr_path(make::ext::ident_path(&var_name));
+                let name_expr = make.expr_path(make.ident_path(&var_name));
 
                 if let Some(cap) = ctx.config.snippet_cap {
                     let tabstop = edit.make_tabstop_before(cap);
@@ -233,7 +232,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                             Position::before(place),
                             vec![
                                 new_stmt.syntax().clone().into(),
-                                make::tokens::whitespace(&trailing_ws).into(),
+                                make.whitespace(&trailing_ws).into(),
                             ],
                         );
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
index 5587f1b59c54..55e40d0fe720 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
@@ -64,8 +64,11 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext<'_>
                     }
                 }
             };
-            let init_expr =
-                if let_expr_needs_paren(&init) { make.expr_paren(init).into() } else { init };
+            let init_expr = if let_expr_needs_paren(&init, &make) {
+                make.expr_paren(init).into()
+            } else {
+                init
+            };
 
             let block = make.block_expr([], None);
             let block = block.indent(IndentLevel::from_node(let_stmt.syntax()));
@@ -85,9 +88,8 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext<'_>
     )
 }
 
-fn let_expr_needs_paren(expr: &ast::Expr) -> bool {
-    let fake_expr_let =
-        ast::make::expr_let(ast::make::tuple_pat(None).into(), ast::make::ext::expr_unit());
+fn let_expr_needs_paren(expr: &ast::Expr, make: &SyntaxFactory) -> bool {
+    let fake_expr_let = make.expr_let(make.tuple_pat(None).into(), make.expr_unit());
     let Some(fake_expr) = fake_expr_let.expr() else {
         stdx::never!();
         return false;
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index d0f14dafe3f0..d496f131652b 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -21,6 +21,14 @@ pub fn name_ref(&self, name: &str) -> ast::NameRef {
         make::name_ref(name).clone_for_update()
     }
 
+    pub fn name_ref_self_ty(&self) -> ast::NameRef {
+        make::name_ref_self_ty().clone_for_update()
+    }
+
+    pub fn expr_todo(&self) -> ast::Expr {
+        make::ext::expr_todo().clone_for_update()
+    }
+
     pub fn lifetime(&self, text: &str) -> ast::Lifetime {
         make::lifetime(text).clone_for_update()
     }

From 6c8246976c57ddaaf53cbde09af4da2d8cb08131 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:21:25 +0530
Subject: [PATCH 0683/1059] migrate qualify_method_call to use syntaxEditor and
 SyntaxFactory

---
 .../src/handlers/qualify_method_call.rs            | 14 ++++++++++----
 .../ide-assists/src/handlers/qualify_path.rs       |  3 +--
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
index 495a84d62b07..8b9e6570e917 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
@@ -1,6 +1,6 @@
 use hir::{AsAssocItem, AssocItem, AssocItemContainer, ItemInNs, ModuleDef, db::HirDatabase};
 use ide_db::assists::AssistId;
-use syntax::{AstNode, ast};
+use syntax::{AstNode, ast, ast::syntax_factory::SyntaxFactory};
 
 use crate::{
     assist_context::{AssistContext, Assists},
@@ -52,19 +52,25 @@ pub(crate) fn qualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         cfg,
     )?;
 
-    let qualify_candidate = QualifyCandidate::ImplMethod(ctx.sema.db, call, resolved_call);
+    let qualify_candidate = QualifyCandidate::ImplMethod(ctx.sema.db, call.clone(), resolved_call);
 
     acc.add(
         AssistId::refactor_rewrite("qualify_method_call"),
         format!("Qualify `{ident}` method call"),
         range,
         |builder| {
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(call.syntax());
             qualify_candidate.qualify(
-                |replace_with: String| builder.replace(range, replace_with),
+                |_| {},
+                &mut editor,
+                &make,
                 &receiver_path,
                 item_in_ns,
                 current_edition,
-            )
+            );
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     );
     Some(())
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
index 9ebeef90bae9..c059f758c47e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs
@@ -183,8 +183,7 @@ fn qualify_fn_call(
                 Some(args) => make.arg_list(iter::once(receiver).chain(args)),
                 None => make.arg_list(iter::once(receiver)),
             };
-            let call_path =
-                make.path_from_text(&format!("{import}::{method_name}{generics}"));
+            let call_path = make.path_from_text(&format!("{import}::{method_name}{generics}"));
             let call_expr = make.expr_call(make.expr_path(call_path), arg_list);
             editor.replace(mcall_expr.syntax(), call_expr.syntax());
         }

From eabc0199bebd995f11482db7309afa3b771cdff9 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 20 Mar 2026 10:47:54 +0530
Subject: [PATCH 0684/1059] remove mapping for expr underscore in syntax
 factory constructor

---
 .../crates/syntax/src/ast/syntax_factory/constructors.rs      | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index d0f14dafe3f0..c94277f8cf05 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -896,10 +896,6 @@ pub fn expr_underscore(&self) -> ast::UnderscoreExpr {
             unreachable!()
         };
 
-        if let Some(mut mapping) = self.mappings() {
-            SyntaxMappingBuilder::new(ast.syntax().clone()).finish(&mut mapping);
-        }
-
         ast
     }
 

From 4a439b640fdc6d09437b5131a3809efbaddabbfa Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 20 Mar 2026 17:09:07 +1100
Subject: [PATCH 0685/1059] Inline and remove
 `DepGraphData::try_mark_parent_green`.

It has a single call site. And also remove all the `debug!` calls that
clutter up the code. The end result is much easier to read, with
`try_mark_previous_green` now recursively calling itself directly,
instead of indirectly via `try_mark_parent_green`.
---
 compiler/rustc_middle/src/dep_graph/graph.rs | 145 ++++++-------------
 1 file changed, 47 insertions(+), 98 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index d410d9a48cd1..23ec0eaccdeb 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -18,7 +18,7 @@
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
 use rustc_session::Session;
 use rustc_span::Symbol;
-use tracing::{debug, instrument};
+use tracing::instrument;
 #[cfg(debug_assertions)]
 use {super::debug::EdgeFilter, std::env};
 
@@ -918,94 +918,6 @@ pub fn try_mark_green<'tcx>(
         }
     }
 
-    #[instrument(skip(self, tcx, parent_dep_node_index, frame), level = "debug")]
-    fn try_mark_parent_green<'tcx>(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        parent_dep_node_index: SerializedDepNodeIndex,
-        frame: &MarkFrame<'_>,
-    ) -> Option<()> {
-        let get_dep_dep_node = || self.previous.index_to_node(parent_dep_node_index);
-
-        match self.colors.get(parent_dep_node_index) {
-            DepNodeColor::Green(_) => {
-                // This dependency has been marked as green before, we are
-                // still fine and can continue with checking the other
-                // dependencies.
-                //
-                // This path is extremely hot. We don't want to get the
-                // `dep_dep_node` unless it's necessary. Hence the
-                // `get_dep_dep_node` closure.
-                debug!("dependency {:?} was immediately green", get_dep_dep_node());
-                return Some(());
-            }
-            DepNodeColor::Red => {
-                // We found a dependency the value of which has changed
-                // compared to the previous compilation session. We cannot
-                // mark the DepNode as green and also don't need to bother
-                // with checking any of the other dependencies.
-                debug!("dependency {:?} was immediately red", get_dep_dep_node());
-                return None;
-            }
-            DepNodeColor::Unknown => {}
-        }
-
-        let dep_dep_node = get_dep_dep_node();
-
-        // We don't know the state of this dependency. If it isn't
-        // an eval_always node, let's try to mark it green recursively.
-        if !tcx.is_eval_always(dep_dep_node.kind) {
-            debug!(
-                "state of dependency {:?} ({}) is unknown, trying to mark it green",
-                dep_dep_node, dep_dep_node.key_fingerprint,
-            );
-
-            let node_index = self.try_mark_previous_green(tcx, parent_dep_node_index, Some(frame));
-
-            if node_index.is_some() {
-                debug!("managed to MARK dependency {dep_dep_node:?} as green");
-                return Some(());
-            }
-        }
-
-        // We failed to mark it green, so we try to force the query.
-        debug!("trying to force dependency {dep_dep_node:?}");
-        if !tcx.try_force_from_dep_node(*dep_dep_node, parent_dep_node_index, frame) {
-            // The DepNode could not be forced.
-            debug!("dependency {dep_dep_node:?} could not be forced");
-            return None;
-        }
-
-        match self.colors.get(parent_dep_node_index) {
-            DepNodeColor::Green(_) => {
-                debug!("managed to FORCE dependency {dep_dep_node:?} to green");
-                return Some(());
-            }
-            DepNodeColor::Red => {
-                debug!("dependency {dep_dep_node:?} was red after forcing");
-                return None;
-            }
-            DepNodeColor::Unknown => {}
-        }
-
-        if let None = tcx.dcx().has_errors_or_delayed_bugs() {
-            panic!("try_mark_previous_green() - Forcing the DepNode should have set its color")
-        }
-
-        // If the query we just forced has resulted in
-        // some kind of compilation error, we cannot rely on
-        // the dep-node color having been properly updated.
-        // This means that the query system has reached an
-        // invalid state. We let the compiler continue (by
-        // returning `None`) so it can emit error messages
-        // and wind down, but rely on the fact that this
-        // invalid state will not be persisted to the
-        // incremental compilation cache because of
-        // compilation errors being present.
-        debug!("dependency {dep_dep_node:?} resulted in compilation error");
-        return None;
-    }
-
     /// Try to mark a dep-node which existed in the previous compilation session as green.
     #[instrument(skip(self, tcx, prev_dep_node_index, frame), level = "debug")]
     fn try_mark_previous_green<'tcx>(
@@ -1019,17 +931,58 @@ fn try_mark_previous_green<'tcx>(
         // We never try to mark eval_always nodes as green
         debug_assert!(!tcx.is_eval_always(self.previous.index_to_node(prev_dep_node_index).kind));
 
-        let prev_deps = self.previous.edge_targets_from(prev_dep_node_index);
+        for parent_dep_node_index in self.previous.edge_targets_from(prev_dep_node_index) {
+            match self.colors.get(parent_dep_node_index) {
+                // This dependency has been marked as green before, we are still ok and can
+                // continue checking the remaining dependencies.
+                DepNodeColor::Green(_) => continue,
 
-        for dep_dep_node_index in prev_deps {
-            self.try_mark_parent_green(tcx, dep_dep_node_index, &frame)?;
+                // This dependency's result is different to the previous compilation session. We
+                // cannot mark this dep_node as green, so stop checking.
+                DepNodeColor::Red => return None,
+
+                // We still need to determine this dependency's colour.
+                DepNodeColor::Unknown => {}
+            }
+
+            let parent_dep_node = self.previous.index_to_node(parent_dep_node_index);
+
+            // If this dependency isn't eval_always, try to mark it green recursively.
+            if !tcx.is_eval_always(parent_dep_node.kind)
+                && self.try_mark_previous_green(tcx, parent_dep_node_index, Some(&frame)).is_some()
+            {
+                continue;
+            }
+
+            // We failed to mark it green, so we try to force the query.
+            if !tcx.try_force_from_dep_node(*parent_dep_node, parent_dep_node_index, &frame) {
+                return None;
+            }
+
+            match self.colors.get(parent_dep_node_index) {
+                DepNodeColor::Green(_) => continue,
+                DepNodeColor::Red => return None,
+                DepNodeColor::Unknown => {}
+            }
+
+            if tcx.dcx().has_errors_or_delayed_bugs().is_none() {
+                panic!("try_mark_previous_green() - forcing failed to set a color");
+            }
+
+            // If the query we just forced has resulted in some kind of compilation error, we
+            // cannot rely on the dep-node color having been properly updated. This means that the
+            // query system has reached an invalid state. We let the compiler continue (by
+            // returning `None`) so it can emit error messages and wind down, but rely on the fact
+            // that this invalid state will not be persisted to the incremental compilation cache
+            // because of compilation errors being present.
+            return None;
         }
 
         // If we got here without hitting a `return` that means that all
         // dependencies of this DepNode could be marked as green. Therefore we
         // can also mark this DepNode as green.
 
-        // There may be multiple threads trying to mark the same dep node green concurrently
+        // There may be multiple threads trying to mark the same dep node green concurrently.
 
         // We allocating an entry for the node in the current dependency graph and
         // adding all the appropriate edges imported from the previous graph.
@@ -1038,12 +991,8 @@ fn try_mark_previous_green<'tcx>(
         let dep_node_index = self.promote_node_and_deps_to_current(prev_dep_node_index)?;
 
         // ... and finally storing a "Green" entry in the color map.
-        // Multiple threads can all write the same color here
+        // Multiple threads can all write the same color here.
 
-        debug!(
-            "successfully marked {:?} as green",
-            self.previous.index_to_node(prev_dep_node_index)
-        );
         Some(dep_node_index)
     }
 }

From ad79aa764b28a1d8b57a431326f00a7061cc760f Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 20 Mar 2026 09:04:03 +0000
Subject: [PATCH 0686/1059] merge many repetitive `classes-*` tests

---
 tests/ui/structs-enums/auxiliary/cci_class.rs |  14 ---
 .../ui/structs-enums/auxiliary/cci_class_2.rs |  19 ---
 .../ui/structs-enums/auxiliary/cci_class_3.rs |  19 ---
 .../ui/structs-enums/auxiliary/cci_class_4.rs |  21 ++++
 .../structs-enums/auxiliary/cci_class_cast.rs |  50 --------
 .../auxiliary/cci_class_trait.rs              |   5 -
 .../class-cast-to-trait-cross-crate-2.rs      |  17 ---
 .../class-cast-to-trait-multiple-types.rs     |  94 ---------------
 tests/ui/structs-enums/class-cast-to-trait.rs |  60 ----------
 tests/ui/structs-enums/class-exports.rs       |  31 -----
 .../class-implement-trait-cross-crate.rs      |  59 ----------
 .../structs-enums/class-implement-traits.rs   |  64 ----------
 .../structs-enums/class-method-cross-crate.rs |  13 ---
 .../class-methods-cross-crate.rs              |  14 ---
 tests/ui/structs-enums/class-methods.rs       |  30 -----
 tests/ui/structs-enums/class-separate-impl.rs |  63 ----------
 tests/ui/structs-enums/class-str-field.rs     |  20 ----
 tests/ui/structs-enums/classes-cross-crate.rs | 109 +++++++++++++++++-
 .../classes-simple-cross-crate.rs             |  12 --
 .../ui/structs-enums/classes-simple-method.rs |  28 -----
 tests/ui/structs-enums/classes-simple.rs      |  23 ----
 tests/ui/structs-enums/classes.rs             |  51 --------
 22 files changed, 128 insertions(+), 688 deletions(-)
 delete mode 100644 tests/ui/structs-enums/auxiliary/cci_class.rs
 delete mode 100644 tests/ui/structs-enums/auxiliary/cci_class_2.rs
 delete mode 100644 tests/ui/structs-enums/auxiliary/cci_class_3.rs
 delete mode 100644 tests/ui/structs-enums/auxiliary/cci_class_cast.rs
 delete mode 100644 tests/ui/structs-enums/auxiliary/cci_class_trait.rs
 delete mode 100644 tests/ui/structs-enums/class-cast-to-trait-cross-crate-2.rs
 delete mode 100644 tests/ui/structs-enums/class-cast-to-trait-multiple-types.rs
 delete mode 100644 tests/ui/structs-enums/class-cast-to-trait.rs
 delete mode 100644 tests/ui/structs-enums/class-exports.rs
 delete mode 100644 tests/ui/structs-enums/class-implement-trait-cross-crate.rs
 delete mode 100644 tests/ui/structs-enums/class-implement-traits.rs
 delete mode 100644 tests/ui/structs-enums/class-method-cross-crate.rs
 delete mode 100644 tests/ui/structs-enums/class-methods-cross-crate.rs
 delete mode 100644 tests/ui/structs-enums/class-methods.rs
 delete mode 100644 tests/ui/structs-enums/class-separate-impl.rs
 delete mode 100644 tests/ui/structs-enums/class-str-field.rs
 delete mode 100644 tests/ui/structs-enums/classes-simple-cross-crate.rs
 delete mode 100644 tests/ui/structs-enums/classes-simple-method.rs
 delete mode 100644 tests/ui/structs-enums/classes-simple.rs
 delete mode 100644 tests/ui/structs-enums/classes.rs

diff --git a/tests/ui/structs-enums/auxiliary/cci_class.rs b/tests/ui/structs-enums/auxiliary/cci_class.rs
deleted file mode 100644
index de2945d74604..000000000000
--- a/tests/ui/structs-enums/auxiliary/cci_class.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-pub mod kitties {
-    pub struct cat {
-      meows : usize,
-
-      pub how_hungry : isize,
-    }
-
-    pub fn cat(in_x : usize, in_y : isize) -> cat  {
-        cat {
-            meows: in_x,
-            how_hungry: in_y
-        }
-    }
-}
diff --git a/tests/ui/structs-enums/auxiliary/cci_class_2.rs b/tests/ui/structs-enums/auxiliary/cci_class_2.rs
deleted file mode 100644
index c3de3150e697..000000000000
--- a/tests/ui/structs-enums/auxiliary/cci_class_2.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-pub mod kitties {
-    pub struct cat {
-      meows : usize,
-
-      pub how_hungry : isize,
-
-    }
-
-    impl cat {
-        pub fn speak(&self) {}
-    }
-
-    pub fn cat(in_x : usize, in_y : isize) -> cat {
-        cat {
-            meows: in_x,
-            how_hungry: in_y
-        }
-    }
-}
diff --git a/tests/ui/structs-enums/auxiliary/cci_class_3.rs b/tests/ui/structs-enums/auxiliary/cci_class_3.rs
deleted file mode 100644
index fb7fad0b5a2e..000000000000
--- a/tests/ui/structs-enums/auxiliary/cci_class_3.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-pub mod kitties {
-    pub struct cat {
-        meows : usize,
-
-        pub how_hungry : isize,
-    }
-
-    impl cat {
-        pub fn speak(&mut self) { self.meows += 1; }
-        pub fn meow_count(&mut self) -> usize { self.meows }
-    }
-
-    pub fn cat(in_x : usize, in_y : isize) -> cat {
-        cat {
-            meows: in_x,
-            how_hungry: in_y
-        }
-    }
-}
diff --git a/tests/ui/structs-enums/auxiliary/cci_class_4.rs b/tests/ui/structs-enums/auxiliary/cci_class_4.rs
index 85aa3bc8c0df..f8c243c9f395 100644
--- a/tests/ui/structs-enums/auxiliary/cci_class_4.rs
+++ b/tests/ui/structs-enums/auxiliary/cci_class_4.rs
@@ -1,4 +1,6 @@
 pub mod kitties {
+    use std::fmt;
+    #[derive(Clone)]
     pub struct cat {
         meows : usize,
 
@@ -19,6 +21,8 @@ pub fn eat(&mut self) -> bool {
                 return false;
             }
         }
+
+        pub fn noop(&self) {}
     }
 
     impl cat {
@@ -29,6 +33,9 @@ pub fn meow(&mut self) {
                 self.how_hungry += 1;
             }
         }
+        pub fn meow_count(&self) -> usize {
+            self.meows
+        }
     }
 
     pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
@@ -38,4 +45,18 @@ pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
             name: in_name
         }
     }
+    pub fn cat_unnamed(in_x : usize, in_y : isize) -> cat {
+        cat {
+            meows: in_x,
+            how_hungry: in_y,
+            name: String::new(),
+        }
+    }
+
+    impl fmt::Display for cat {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "{}", self.name)
+        }
+    }
+
 }
diff --git a/tests/ui/structs-enums/auxiliary/cci_class_cast.rs b/tests/ui/structs-enums/auxiliary/cci_class_cast.rs
deleted file mode 100644
index dfc3c56ddee7..000000000000
--- a/tests/ui/structs-enums/auxiliary/cci_class_cast.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-pub mod kitty {
-    use std::fmt;
-
-    pub struct cat {
-      meows : usize,
-      pub how_hungry : isize,
-      pub name : String,
-    }
-
-    impl fmt::Display for cat {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "{}", self.name)
-        }
-    }
-
-    impl cat {
-        fn meow(&mut self) {
-            println!("Meow");
-            self.meows += 1;
-            if self.meows % 5 == 0 {
-                self.how_hungry += 1;
-            }
-        }
-
-    }
-
-    impl cat {
-        pub fn speak(&mut self) { self.meow(); }
-
-        pub fn eat(&mut self) -> bool {
-            if self.how_hungry > 0 {
-                println!("OM NOM NOM");
-                self.how_hungry -= 2;
-                return true;
-            }
-            else {
-                println!("Not hungry!");
-                return false;
-            }
-        }
-    }
-
-    pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-        cat {
-            meows: in_x,
-            how_hungry: in_y,
-            name: in_name
-        }
-    }
-}
diff --git a/tests/ui/structs-enums/auxiliary/cci_class_trait.rs b/tests/ui/structs-enums/auxiliary/cci_class_trait.rs
deleted file mode 100644
index 2d02b591c555..000000000000
--- a/tests/ui/structs-enums/auxiliary/cci_class_trait.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub mod animals {
-    pub trait noisy {
-        fn speak(&mut self);
-    }
-}
diff --git a/tests/ui/structs-enums/class-cast-to-trait-cross-crate-2.rs b/tests/ui/structs-enums/class-cast-to-trait-cross-crate-2.rs
deleted file mode 100644
index d4caa19135e8..000000000000
--- a/tests/ui/structs-enums/class-cast-to-trait-cross-crate-2.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-//@ aux-build:cci_class_cast.rs
-
-extern crate cci_class_cast;
-
-use cci_class_cast::kitty::cat;
-
-fn print_out(thing: Box<dyn ToString>, expected: String) {
-  let actual = (*thing).to_string();
-  println!("{}", actual);
-  assert_eq!(actual.to_string(), expected);
-}
-
-pub fn main() {
-  let nyan: Box<dyn ToString> = Box::new(cat(0, 2, "nyan".to_string())) as Box<dyn ToString>;
-  print_out(nyan, "nyan".to_string());
-}
diff --git a/tests/ui/structs-enums/class-cast-to-trait-multiple-types.rs b/tests/ui/structs-enums/class-cast-to-trait-multiple-types.rs
deleted file mode 100644
index 658e9d2117dc..000000000000
--- a/tests/ui/structs-enums/class-cast-to-trait-multiple-types.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//@ run-pass
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-
-trait noisy {
-  fn speak(&mut self) -> isize;
-}
-
-struct dog {
-  barks: usize,
-
-  volume: isize,
-}
-
-impl dog {
-    fn bark(&mut self) -> isize {
-      println!("Woof {} {}", self.barks, self.volume);
-      self.barks += 1_usize;
-      if self.barks % 3_usize == 0_usize {
-          self.volume += 1;
-      }
-      if self.barks % 10_usize == 0_usize {
-          self.volume -= 2;
-      }
-      println!("Grrr {} {}", self.barks, self.volume);
-      self.volume
-    }
-}
-
-impl noisy for dog {
-    fn speak(&mut self) -> isize {
-        self.bark()
-    }
-}
-
-fn dog() -> dog {
-    dog {
-        volume: 0,
-        barks: 0_usize
-    }
-}
-
-#[derive(Clone)]
-struct cat {
-  meows: usize,
-
-  how_hungry: isize,
-  name: String,
-}
-
-impl noisy for cat {
-    fn speak(&mut self) -> isize {
-        self.meow() as isize
-    }
-}
-
-impl cat {
-    pub fn meow_count(&self) -> usize {
-        self.meows
-    }
-}
-
-impl cat {
-    fn meow(&mut self) -> usize {
-        println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
-            self.how_hungry += 1;
-        }
-        self.meows
-    }
-}
-
-fn cat(in_x: usize, in_y: isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name
-    }
-}
-
-
-fn annoy_neighbors(critter: &mut dyn noisy) {
-    for _i in 0_usize..10 { critter.speak(); }
-}
-
-pub fn main() {
-  let mut nyan: cat = cat(0_usize, 2, "nyan".to_string());
-  let mut whitefang: dog = dog();
-  annoy_neighbors(&mut nyan);
-  annoy_neighbors(&mut whitefang);
-  assert_eq!(nyan.meow_count(), 10_usize);
-  assert_eq!(whitefang.volume, 1);
-}
diff --git a/tests/ui/structs-enums/class-cast-to-trait.rs b/tests/ui/structs-enums/class-cast-to-trait.rs
deleted file mode 100644
index bbbde34ec096..000000000000
--- a/tests/ui/structs-enums/class-cast-to-trait.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(unused_mut)]
-#![allow(non_camel_case_types)]
-
-//@ ignore-freebsd FIXME fails on BSD
-
-
-trait noisy {
-  fn speak(&mut self);
-}
-
-struct cat {
-  meows: usize,
-  how_hungry: isize,
-  name: String,
-}
-
-impl noisy for cat {
-  fn speak(&mut self) { self.meow(); }
-}
-
-impl cat {
-  pub fn eat(&mut self) -> bool {
-    if self.how_hungry > 0 {
-        println!("OM NOM NOM");
-        self.how_hungry -= 2;
-        return true;
-    }
-    else {
-        println!("Not hungry!");
-        return false;
-    }
-  }
-}
-
-impl cat {
-    fn meow(&mut self) {
-      println!("Meow");
-      self.meows += 1;
-      if self.meows % 5 == 0 {
-          self.how_hungry += 1;
-      }
-    }
-}
-
-fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name
-    }
-}
-
-
-pub fn main() {
-    let mut nyan = cat(0, 2, "nyan".to_string());
-    let mut nyan: &mut dyn noisy = &mut nyan;
-    nyan.speak();
-}
diff --git a/tests/ui/structs-enums/class-exports.rs b/tests/ui/structs-enums/class-exports.rs
deleted file mode 100644
index 53d0e3db6f5f..000000000000
--- a/tests/ui/structs-enums/class-exports.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-/* Test that exporting a class also exports its
-   public fields and methods */
-
-use kitty::cat;
-
-mod kitty {
-    pub struct cat {
-        meows: usize,
-        name: String,
-    }
-
-    impl cat {
-        pub fn get_name(&self) -> String { self.name.clone() }
-    }
-
-    pub fn cat(in_name: String) -> cat {
-        cat {
-            name: in_name,
-            meows: 0
-        }
-    }
-}
-
-pub fn main() {
-  assert_eq!(cat("Spreckles".to_string()).get_name(),
-                 "Spreckles".to_string());
-}
diff --git a/tests/ui/structs-enums/class-implement-trait-cross-crate.rs b/tests/ui/structs-enums/class-implement-trait-cross-crate.rs
deleted file mode 100644
index 781ac6ad10d2..000000000000
--- a/tests/ui/structs-enums/class-implement-trait-cross-crate.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-//@ aux-build:cci_class_trait.rs
-extern crate cci_class_trait;
-use cci_class_trait::animals::noisy;
-
-struct cat {
-  meows: usize,
-
-  how_hungry : isize,
-  name : String,
-}
-
-impl cat {
-    pub fn eat(&mut self) -> bool {
-        if self.how_hungry > 0 {
-            println!("OM NOM NOM");
-            self.how_hungry -= 2;
-            return true;
-        }
-        else {
-            println!("Not hungry!");
-            return false;
-        }
-    }
-}
-
-impl noisy for cat {
-    fn speak(&mut self) { self.meow(); }
-}
-
-impl cat {
-    fn meow(&mut self) {
-        println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
-            self.how_hungry += 1;
-        }
-    }
-}
-
-fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name
-    }
-}
-
-
-pub fn main() {
-  let mut nyan = cat(0_usize, 2, "nyan".to_string());
-  nyan.eat();
-  assert!(!nyan.eat());
-  for _ in 1_usize..10_usize { nyan.speak(); };
-  assert!(nyan.eat());
-}
diff --git a/tests/ui/structs-enums/class-implement-traits.rs b/tests/ui/structs-enums/class-implement-traits.rs
deleted file mode 100644
index 3a514ff9d758..000000000000
--- a/tests/ui/structs-enums/class-implement-traits.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-//@ run-pass
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-
-trait noisy {
-    fn speak(&mut self);
-}
-
-#[derive(Clone)]
-struct cat {
-    meows : usize,
-
-    how_hungry : isize,
-    name : String,
-}
-
-impl cat {
-    fn meow(&mut self) {
-        println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
-            self.how_hungry += 1;
-        }
-    }
-}
-
-impl cat {
-    pub fn eat(&mut self) -> bool {
-        if self.how_hungry > 0 {
-            println!("OM NOM NOM");
-            self.how_hungry -= 2;
-            return true;
-        } else {
-            println!("Not hungry!");
-            return false;
-        }
-    }
-}
-
-impl noisy for cat {
-    fn speak(&mut self) { self.meow(); }
-}
-
-fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name.clone()
-    }
-}
-
-
-fn make_speak<C:noisy>(mut c: C) {
-    c.speak();
-}
-
-pub fn main() {
-    let mut nyan = cat(0_usize, 2, "nyan".to_string());
-    nyan.eat();
-    assert!(!nyan.eat());
-    for _ in 1_usize..10_usize {
-        make_speak(nyan.clone());
-    }
-}
diff --git a/tests/ui/structs-enums/class-method-cross-crate.rs b/tests/ui/structs-enums/class-method-cross-crate.rs
deleted file mode 100644
index f73999a24501..000000000000
--- a/tests/ui/structs-enums/class-method-cross-crate.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-//@ aux-build:cci_class_2.rs
-
-extern crate cci_class_2;
-use cci_class_2::kitties::cat;
-
-pub fn main() {
-  let nyan : cat = cat(52, 99);
-  let kitty = cat(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-  nyan.speak();
-}
diff --git a/tests/ui/structs-enums/class-methods-cross-crate.rs b/tests/ui/structs-enums/class-methods-cross-crate.rs
deleted file mode 100644
index b2c48248a671..000000000000
--- a/tests/ui/structs-enums/class-methods-cross-crate.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-//@ aux-build:cci_class_3.rs
-
-extern crate cci_class_3;
-use cci_class_3::kitties::cat;
-
-pub fn main() {
-    let mut nyan : cat = cat(52, 99);
-    let kitty = cat(1000, 2);
-    assert_eq!(nyan.how_hungry, 99);
-    assert_eq!(kitty.how_hungry, 2);
-    nyan.speak();
-    assert_eq!(nyan.meow_count(), 53);
-}
diff --git a/tests/ui/structs-enums/class-methods.rs b/tests/ui/structs-enums/class-methods.rs
deleted file mode 100644
index b0dbbbec5224..000000000000
--- a/tests/ui/structs-enums/class-methods.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ run-pass
-#![allow(non_camel_case_types)]
-
-
-struct cat {
-  meows : usize,
-
-  how_hungry : isize,
-}
-
-impl cat {
-    pub fn speak(&mut self) { self.meows += 1; }
-    pub fn meow_count(&mut self) -> usize { self.meows }
-}
-
-fn cat(in_x: usize, in_y: isize) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y
-    }
-}
-
-pub fn main() {
-  let mut nyan: cat = cat(52, 99);
-  let kitty = cat(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-  nyan.speak();
-  assert_eq!(nyan.meow_count(), 53);
-}
diff --git a/tests/ui/structs-enums/class-separate-impl.rs b/tests/ui/structs-enums/class-separate-impl.rs
deleted file mode 100644
index 2768e284c173..000000000000
--- a/tests/ui/structs-enums/class-separate-impl.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-use std::fmt;
-
-struct cat {
-    meows : usize,
-
-    how_hungry : isize,
-    name : String,
-}
-
-impl cat {
-    pub fn speak(&mut self) { self.meow(); }
-
-    pub fn eat(&mut self) -> bool {
-        if self.how_hungry > 0 {
-            println!("OM NOM NOM");
-            self.how_hungry -= 2;
-            return true;
-        }
-        else {
-            println!("Not hungry!");
-            return false;
-        }
-    }
-}
-
-impl cat {
-    fn meow(&mut self) {
-        println!("Meow");
-        self.meows += 1;
-        if self.meows % 5 == 0 {
-            self.how_hungry += 1;
-        }
-    }
-}
-
-fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name
-    }
-}
-
-impl fmt::Display for cat {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.name)
-    }
-}
-
-fn print_out(thing: Box<dyn ToString>, expected: String) {
-  let actual = (*thing).to_string();
-  println!("{}", actual);
-  assert_eq!(actual.to_string(), expected);
-}
-
-pub fn main() {
-  let nyan: Box<dyn ToString> = Box::new(cat(0, 2, "nyan".to_string())) as Box<dyn ToString>;
-  print_out(nyan, "nyan".to_string());
-}
diff --git a/tests/ui/structs-enums/class-str-field.rs b/tests/ui/structs-enums/class-str-field.rs
deleted file mode 100644
index 24f648afc90b..000000000000
--- a/tests/ui/structs-enums/class-str-field.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-
-struct cat {
-
-  name : String,
-
-}
-
-fn cat(in_name: String) -> cat {
-    cat {
-        name: in_name
-    }
-}
-
-pub fn main() {
-  let _nyan = cat("nyan".to_string());
-}
diff --git a/tests/ui/structs-enums/classes-cross-crate.rs b/tests/ui/structs-enums/classes-cross-crate.rs
index 6fb5f2e3cc9d..d859cbdc76da 100644
--- a/tests/ui/structs-enums/classes-cross-crate.rs
+++ b/tests/ui/structs-enums/classes-cross-crate.rs
@@ -1,13 +1,118 @@
 //@ run-pass
 //@ aux-build:cci_class_4.rs
+#![allow(non_camel_case_types)]
 
 extern crate cci_class_4;
-use cci_class_4::kitties::cat;
+use cci_class_4::kitties::{cat, cat_unnamed};
 
-pub fn main() {
+fn simple_cross_crate() {
+  let nyan : cat = cat_unnamed(52, 99);
+  let kitty = cat_unnamed(1000, 2);
+  assert_eq!(nyan.how_hungry, 99);
+  assert_eq!(kitty.how_hungry, 2);
+  nyan.noop();
+}
+
+fn cross_crate() {
     let mut nyan = cat(0_usize, 2, "nyan".to_string());
     nyan.eat();
     assert!(!nyan.eat());
     for _ in 1_usize..10_usize { nyan.speak(); };
     assert!(nyan.eat());
 }
+
+
+fn print_out(thing: Box<dyn ToString>, expected: String) {
+  let actual = (*thing).to_string();
+  println!("{}", actual);
+  assert_eq!(actual.to_string(), expected);
+}
+
+fn separate_impl() {
+  let nyan: Box<dyn ToString> = Box::new(cat(0, 2, "nyan".to_string())) as Box<dyn ToString>;
+  print_out(nyan, "nyan".to_string());
+}
+
+trait noisy {
+    fn speak(&mut self) -> isize;
+}
+
+impl noisy for cat {
+    fn speak(&mut self) -> isize { self.meow(); 0 }
+}
+
+fn make_speak<C:noisy>(mut c: C) {
+    c.speak();
+}
+
+fn implement_traits() {
+    let mut nyan = cat(0_usize, 2, "nyan".to_string());
+    nyan.eat();
+    assert!(!nyan.eat());
+    for _ in 1_usize..10_usize {
+        make_speak(nyan.clone());
+    }
+}
+
+
+struct dog {
+  barks: usize,
+
+  volume: isize,
+}
+
+impl dog {
+    fn bark(&mut self) -> isize {
+      println!("Woof {} {}", self.barks, self.volume);
+      self.barks += 1_usize;
+      if self.barks % 3_usize == 0_usize {
+          self.volume += 1;
+      }
+      if self.barks % 10_usize == 0_usize {
+          self.volume -= 2;
+      }
+      println!("Grrr {} {}", self.barks, self.volume);
+      self.volume
+    }
+}
+
+impl noisy for dog {
+    fn speak(&mut self) -> isize {
+        self.bark()
+    }
+}
+
+fn dog() -> dog {
+    dog {
+        volume: 0,
+        barks: 0_usize
+    }
+}
+
+fn annoy_neighbors(critter: &mut dyn noisy) {
+    for _i in 0_usize..10 { critter.speak(); }
+}
+
+fn multiple_types() {
+    let mut nyan: cat = cat(0_usize, 2, "nyan".to_string());
+    let mut whitefang: dog = dog();
+    annoy_neighbors(&mut nyan);
+    annoy_neighbors(&mut whitefang);
+    assert_eq!(nyan.meow_count(), 10_usize);
+    assert_eq!(whitefang.volume, 1);
+}
+
+fn cast_to_trait() {
+    let mut nyan = cat(0, 2, "nyan".to_string());
+    let nyan: &mut dyn noisy = &mut nyan;
+    nyan.speak();
+}
+
+fn main() {
+    simple_cross_crate();
+    cross_crate();
+    separate_impl();
+    implement_traits();
+    multiple_types();
+    cast_to_trait();
+}
diff --git a/tests/ui/structs-enums/classes-simple-cross-crate.rs b/tests/ui/structs-enums/classes-simple-cross-crate.rs
deleted file mode 100644
index 1548f768b6f3..000000000000
--- a/tests/ui/structs-enums/classes-simple-cross-crate.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-//@ aux-build:cci_class.rs
-
-extern crate cci_class;
-use cci_class::kitties::cat;
-
-pub fn main() {
-  let nyan : cat = cat(52, 99);
-  let kitty = cat(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-}
diff --git a/tests/ui/structs-enums/classes-simple-method.rs b/tests/ui/structs-enums/classes-simple-method.rs
deleted file mode 100644
index 562fd5909815..000000000000
--- a/tests/ui/structs-enums/classes-simple-method.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-struct cat {
-    meows : usize,
-
-    how_hungry : isize,
-}
-
-impl cat {
-    pub fn speak(&mut self) {}
-}
-
-fn cat(in_x : usize, in_y : isize) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y
-    }
-}
-
-pub fn main() {
-  let mut nyan : cat = cat(52, 99);
-  let kitty = cat(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-  nyan.speak();
-}
diff --git a/tests/ui/structs-enums/classes-simple.rs b/tests/ui/structs-enums/classes-simple.rs
deleted file mode 100644
index d870a3101f1a..000000000000
--- a/tests/ui/structs-enums/classes-simple.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-struct cat {
-    meows : usize,
-
-    how_hungry : isize,
-}
-
-fn cat(in_x : usize, in_y : isize) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y
-    }
-}
-
-pub fn main() {
-  let nyan : cat = cat(52, 99);
-  let kitty = cat(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-}
diff --git a/tests/ui/structs-enums/classes.rs b/tests/ui/structs-enums/classes.rs
deleted file mode 100644
index 05976f6a759a..000000000000
--- a/tests/ui/structs-enums/classes.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-struct cat {
-    meows : usize,
-
-    how_hungry : isize,
-    name : String,
-}
-
-impl cat {
-    pub fn speak(&mut self) { self.meow(); }
-
-    pub fn eat(&mut self) -> bool {
-        if self.how_hungry > 0 {
-            println!("OM NOM NOM");
-            self.how_hungry -= 2;
-            return true;
-        } else {
-            println!("Not hungry!");
-            return false;
-        }
-    }
-}
-
-impl cat {
-    fn meow(&mut self) {
-        println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
-            self.how_hungry += 1;
-        }
-    }
-}
-
-fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-    cat {
-        meows: in_x,
-        how_hungry: in_y,
-        name: in_name
-    }
-}
-
-pub fn main() {
-  let mut nyan = cat(0_usize, 2, "nyan".to_string());
-  nyan.eat();
-  assert!(!nyan.eat());
-  for _ in 1_usize..10_usize { nyan.speak(); };
-  assert!(nyan.eat());
-}

From 0941e187ef276a707025f01ce513cf594611e834 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 20 Mar 2026 09:17:48 +0000
Subject: [PATCH 0687/1059] reformat merged files

---
 .../ui/structs-enums/auxiliary/cci_class_4.rs | 110 ++++++++----------
 tests/ui/structs-enums/classes-cross-crate.rs |  91 ++++++++-------
 2 files changed, 97 insertions(+), 104 deletions(-)

diff --git a/tests/ui/structs-enums/auxiliary/cci_class_4.rs b/tests/ui/structs-enums/auxiliary/cci_class_4.rs
index f8c243c9f395..fff7b7809571 100644
--- a/tests/ui/structs-enums/auxiliary/cci_class_4.rs
+++ b/tests/ui/structs-enums/auxiliary/cci_class_4.rs
@@ -1,62 +1,54 @@
-pub mod kitties {
-    use std::fmt;
-    #[derive(Clone)]
-    pub struct cat {
-        meows : usize,
+use std::fmt;
 
-        pub how_hungry : isize,
-        pub name : String,
-    }
-
-    impl cat {
-        pub fn speak(&mut self) { self.meow(); }
-
-        pub fn eat(&mut self) -> bool {
-            if self.how_hungry > 0 {
-                println!("OM NOM NOM");
-                self.how_hungry -= 2;
-                return true;
-            } else {
-                println!("Not hungry!");
-                return false;
-            }
-        }
-
-        pub fn noop(&self) {}
-    }
-
-    impl cat {
-        pub fn meow(&mut self) {
-            println!("Meow");
-            self.meows += 1;
-            if self.meows % 5 == 0 {
-                self.how_hungry += 1;
-            }
-        }
-        pub fn meow_count(&self) -> usize {
-            self.meows
-        }
-    }
-
-    pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
-        cat {
-            meows: in_x,
-            how_hungry: in_y,
-            name: in_name
-        }
-    }
-    pub fn cat_unnamed(in_x : usize, in_y : isize) -> cat {
-        cat {
-            meows: in_x,
-            how_hungry: in_y,
-            name: String::new(),
-        }
-    }
-
-    impl fmt::Display for cat {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "{}", self.name)
-        }
-    }
+#[derive(Clone)]
+pub struct Cat {
+    meows: usize,
 
+    pub how_hungry: isize,
+    pub name: String,
+}
+
+impl Cat {
+    pub fn speak(&mut self) {
+        self.meow();
+    }
+
+    pub fn eat(&mut self) -> bool {
+        if self.how_hungry > 0 {
+            println!("OM NOM NOM");
+            self.how_hungry -= 2;
+            return true;
+        } else {
+            println!("Not hungry!");
+            return false;
+        }
+    }
+
+    pub fn noop(&self) {}
+}
+
+impl Cat {
+    pub fn meow(&mut self) {
+        println!("Meow");
+        self.meows += 1;
+        if self.meows % 5 == 0 {
+            self.how_hungry += 1;
+        }
+    }
+    pub fn meow_count(&self) -> usize {
+        self.meows
+    }
+}
+
+pub fn cat(in_x: usize, in_y: isize, in_name: String) -> Cat {
+    Cat { meows: in_x, how_hungry: in_y, name: in_name }
+}
+pub fn cat_unnamed(in_x: usize, in_y: isize) -> Cat {
+    Cat { meows: in_x, how_hungry: in_y, name: String::new() }
+}
+
+impl fmt::Display for Cat {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.name)
+    }
 }
diff --git a/tests/ui/structs-enums/classes-cross-crate.rs b/tests/ui/structs-enums/classes-cross-crate.rs
index d859cbdc76da..85454bb15a7b 100644
--- a/tests/ui/structs-enums/classes-cross-crate.rs
+++ b/tests/ui/structs-enums/classes-cross-crate.rs
@@ -1,47 +1,50 @@
 //@ run-pass
 //@ aux-build:cci_class_4.rs
-#![allow(non_camel_case_types)]
 
 extern crate cci_class_4;
-use cci_class_4::kitties::{cat, cat_unnamed};
+use cci_class_4::*;
 
 fn simple_cross_crate() {
-  let nyan : cat = cat_unnamed(52, 99);
-  let kitty = cat_unnamed(1000, 2);
-  assert_eq!(nyan.how_hungry, 99);
-  assert_eq!(kitty.how_hungry, 2);
-  nyan.noop();
+    let nyan: Cat = cat_unnamed(52, 99);
+    let kitty = cat_unnamed(1000, 2);
+    assert_eq!(nyan.how_hungry, 99);
+    assert_eq!(kitty.how_hungry, 2);
+    nyan.noop();
 }
 
 fn cross_crate() {
     let mut nyan = cat(0_usize, 2, "nyan".to_string());
     nyan.eat();
     assert!(!nyan.eat());
-    for _ in 1_usize..10_usize { nyan.speak(); };
+    for _ in 1_usize..10_usize {
+        nyan.speak();
+    }
     assert!(nyan.eat());
 }
 
-
 fn print_out(thing: Box<dyn ToString>, expected: String) {
-  let actual = (*thing).to_string();
-  println!("{}", actual);
-  assert_eq!(actual.to_string(), expected);
+    let actual = (*thing).to_string();
+    println!("{}", actual);
+    assert_eq!(actual.to_string(), expected);
 }
 
 fn separate_impl() {
-  let nyan: Box<dyn ToString> = Box::new(cat(0, 2, "nyan".to_string())) as Box<dyn ToString>;
-  print_out(nyan, "nyan".to_string());
+    let nyan: Box<dyn ToString> = Box::new(cat(0, 2, "nyan".to_string())) as Box<dyn ToString>;
+    print_out(nyan, "nyan".to_string());
 }
 
-trait noisy {
+trait Noisy {
     fn speak(&mut self) -> isize;
 }
 
-impl noisy for cat {
-    fn speak(&mut self) -> isize { self.meow(); 0 }
+impl Noisy for Cat {
+    fn speak(&mut self) -> isize {
+        self.meow();
+        0
+    }
 }
 
-fn make_speak<C:noisy>(mut c: C) {
+fn make_speak<C: Noisy>(mut c: C) {
     c.speak();
 }
 
@@ -54,48 +57,46 @@ fn implement_traits() {
     }
 }
 
+struct Dog {
+    barks: usize,
 
-struct dog {
-  barks: usize,
-
-  volume: isize,
+    volume: isize,
 }
 
-impl dog {
+impl Dog {
     fn bark(&mut self) -> isize {
-      println!("Woof {} {}", self.barks, self.volume);
-      self.barks += 1_usize;
-      if self.barks % 3_usize == 0_usize {
-          self.volume += 1;
-      }
-      if self.barks % 10_usize == 0_usize {
-          self.volume -= 2;
-      }
-      println!("Grrr {} {}", self.barks, self.volume);
-      self.volume
+        println!("Woof {} {}", self.barks, self.volume);
+        self.barks += 1_usize;
+        if self.barks % 3_usize == 0_usize {
+            self.volume += 1;
+        }
+        if self.barks % 10_usize == 0_usize {
+            self.volume -= 2;
+        }
+        println!("Grrr {} {}", self.barks, self.volume);
+        self.volume
     }
 }
 
-impl noisy for dog {
+impl Noisy for Dog {
     fn speak(&mut self) -> isize {
         self.bark()
     }
 }
 
-fn dog() -> dog {
-    dog {
-        volume: 0,
-        barks: 0_usize
+fn dog() -> Dog {
+    Dog { volume: 0, barks: 0_usize }
+}
+
+fn annoy_neighbors(critter: &mut dyn Noisy) {
+    for _i in 0_usize..10 {
+        critter.speak();
     }
 }
 
-fn annoy_neighbors(critter: &mut dyn noisy) {
-    for _i in 0_usize..10 { critter.speak(); }
-}
-
 fn multiple_types() {
-    let mut nyan: cat = cat(0_usize, 2, "nyan".to_string());
-    let mut whitefang: dog = dog();
+    let mut nyan: Cat = cat(0_usize, 2, "nyan".to_string());
+    let mut whitefang: Dog = dog();
     annoy_neighbors(&mut nyan);
     annoy_neighbors(&mut whitefang);
     assert_eq!(nyan.meow_count(), 10_usize);
@@ -104,7 +105,7 @@ fn multiple_types() {
 
 fn cast_to_trait() {
     let mut nyan = cat(0, 2, "nyan".to_string());
-    let nyan: &mut dyn noisy = &mut nyan;
+    let nyan: &mut dyn Noisy = &mut nyan;
     nyan.speak();
 }
 

From 7f7a3bd6c025fd77f3b3255a80e99a25f87e9203 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 20 Mar 2026 10:23:32 +0100
Subject: [PATCH 0688/1059] tweak wording

---
 src/tools/miri/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 28cdc8f0a7f9..97f385ad755b 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -641,7 +641,7 @@ Definite bugs found:
 * [`winit` registering a global constructor with the wrong ABI on Windows](https://github.com/rust-windowing/winit/issues/4435)
 * [`VecDeque::splice` confusing physical and logical indices](https://github.com/rust-lang/rust/issues/151758)
 * [Data race in `oneshot` channel](https://github.com/faern/oneshot/issues/69)
-* [Memory leak in serde-yaml-bw caused by early return before libyaml event cleanup in Parser::next](https://github.com/bourumir-wyngs/serde-yaml-bw/issues/197)
+* [Memory leak in serde-yaml-bw](https://github.com/bourumir-wyngs/serde-yaml-bw/issues/197)
 
 Violations of [Stacked Borrows] found that are likely bugs (but Stacked Borrows is currently just an experiment):
 

From 5c441e6ce6453863e082ae26508958ffc1966e40 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Fri, 20 Mar 2026 12:31:48 +0300
Subject: [PATCH 0689/1059] ty-aware delayed AST -> HIR lowering

---
 compiler/rustc_ast_lowering/src/delegation.rs | 244 ++++--------------
 .../src/delegation/generics.rs                |  77 ++----
 compiler/rustc_ast_lowering/src/item.rs       |  29 ++-
 compiler/rustc_ast_lowering/src/lib.rs        | 171 +++++++++---
 compiler/rustc_hir/src/hir.rs                 |  13 -
 compiler/rustc_hir/src/stable_hash_impls.rs   |   9 +-
 compiler/rustc_interface/src/passes.rs        |   6 +-
 compiler/rustc_middle/src/hir/map.rs          |  20 +-
 compiler/rustc_middle/src/hir/mod.rs          |  80 +++++-
 compiler/rustc_middle/src/queries.rs          |  13 +-
 compiler/rustc_middle/src/ty/context.rs       |   7 +-
 compiler/rustc_middle/src/ty/mod.rs           |  29 ---
 compiler/rustc_resolve/src/late.rs            |  76 ++----
 compiler/rustc_resolve/src/lib.rs             |  10 +-
 tests/pretty/delegation-inherit-attributes.pp |   2 +-
 .../delegation/generics/free-fn-to-free-fn.rs |   2 +-
 .../generics/free-fn-to-free-fn.stderr        |  19 +-
 .../generics/free-fn-to-trait-infer.stderr    |   1 -
 .../generics/generics-gen-args-errors.stderr  |  12 +-
 .../trait-impl-wrong-args-count.stderr        |  16 +-
 tests/ui/pin-ergonomics/pin_v2-attr.stderr    |  16 +-
 21 files changed, 398 insertions(+), 454 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index f2589ed198ad..0044913721f1 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -45,16 +45,15 @@
 use rustc_abi::ExternAbi;
 use rustc_ast as ast;
 use rustc_ast::*;
-use rustc_attr_parsing::{AttributeParser, ShouldEmit};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir as hir;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{Asyncness, DelegationAttrs, DelegationFnSigAttrs};
+use rustc_middle::ty::Asyncness;
 use rustc_span::symbol::kw;
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Symbol};
 use smallvec::SmallVec;
 
 use crate::delegation::generics::{GenericsGenerationResult, GenericsGenerationResults};
@@ -80,7 +79,7 @@ struct AttrAdditionInfo {
 
 enum AttrAdditionKind {
     Default { factory: fn(Span) -> hir::Attribute },
-    Inherit { flag: DelegationFnSigAttrs, factory: fn(Span, &hir::Attribute) -> hir::Attribute },
+    Inherit { factory: fn(Span, &hir::Attribute) -> hir::Attribute },
 }
 
 const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
@@ -97,7 +96,6 @@ enum AttrAdditionKind {
 
                 hir::Attribute::Parsed(AttributeKind::MustUse { span, reason })
             },
-            flag: DelegationFnSigAttrs::MUST_USE,
         },
     },
     AttrAdditionInfo {
@@ -108,43 +106,11 @@ enum AttrAdditionKind {
     },
 ];
 
-type DelegationIdsVec = SmallVec<[DefId; 1]>;
-
-// As delegations can now refer to another delegation, we have a delegation path
-// of the following type: reuse (current delegation) <- reuse (delegee_id) <- ... <- reuse <- function (root_function_id).
-// In its most basic and widely used form: reuse (current delegation) <- function (delegee_id, root_function_id)
-struct DelegationIds {
-    path: DelegationIdsVec,
-}
-
-impl DelegationIds {
-    fn new(path: DelegationIdsVec) -> Self {
-        assert!(!path.is_empty());
-        Self { path }
-    }
-
-    // Id of the first function in (non)local crate that is being reused
-    fn root_function_id(&self) -> DefId {
-        *self.path.last().expect("Ids vector can't be empty")
-    }
-
-    // Id of the first definition which is being reused,
-    // can be either function, in this case `root_id == delegee_id`, or other delegation
-    fn delegee_id(&self) -> DefId {
-        *self.path.first().expect("Ids vector can't be empty")
-    }
-}
-
 impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
-            DefKind::AssocFn => match def_id.as_local() {
-                Some(local_def_id) => {
-                    self.resolver.delegation_fn_sig(local_def_id).is_some_and(|sig| sig.has_self)
-                }
-                None => self.tcx.associated_item(def_id).is_method(),
-            },
+            DefKind::AssocFn => self.tcx.associated_item(def_id).is_method(),
             _ => span_bug!(span, "unexpected DefKind for delegation item"),
         }
     }
@@ -157,10 +123,10 @@ pub(crate) fn lower_delegation(
         let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span);
 
         // Delegation can be unresolved in illegal places such as function bodies in extern blocks (see #151356)
-        let ids = if let Some(delegation_info) =
+        let sig_id = if let Some(delegation_info) =
             self.resolver.delegation_info(self.local_def_id(item_id))
         {
-            self.get_delegation_ids(delegation_info.resolution_node, span)
+            self.get_sig_id(delegation_info.resolution_node, span)
         } else {
             return self.generate_delegation_error(
                 self.dcx().span_delayed_bug(
@@ -172,28 +138,16 @@ pub(crate) fn lower_delegation(
             );
         };
 
-        match ids {
-            Ok(ids) => {
-                self.add_attrs_if_needed(span, &ids);
+        match sig_id {
+            Ok(sig_id) => {
+                self.add_attrs_if_needed(span, sig_id);
 
-                let delegee_id = ids.delegee_id();
-                let root_function_id = ids.root_function_id();
+                let is_method = self.is_method(sig_id, span);
 
-                // `is_method` is used to choose the name of the first parameter (`self` or `arg0`),
-                // if the original function is not a method (without `self`), then it can not be added
-                // during chain of reuses, so we use `root_function_id` here
-                let is_method = self.is_method(root_function_id, span);
+                let (param_count, c_variadic) = self.param_count(sig_id);
 
-                // Here we use `root_function_id` as we can not get params information out of potential delegation reuse,
-                // we need a function to extract this information
-                let (param_count, c_variadic) = self.param_count(root_function_id);
-
-                let mut generics = self.lower_delegation_generics(
-                    delegation,
-                    ids.root_function_id(),
-                    item_id,
-                    span,
-                );
+                let mut generics =
+                    self.lower_delegation_generics(delegation, sig_id, item_id, span);
 
                 let body_id = self.lower_delegation_body(
                     delegation,
@@ -204,20 +158,10 @@ pub(crate) fn lower_delegation(
                     span,
                 );
 
-                // Here we use `delegee_id`, as this id will then be used to calculate parent for generics
-                // inheritance, and we want this id to point on a delegee, not on the original
-                // function (see https://github.com/rust-lang/rust/issues/150152#issuecomment-3674834654)
-                let decl = self.lower_delegation_decl(
-                    delegee_id,
-                    param_count,
-                    c_variadic,
-                    span,
-                    &generics,
-                );
+                let decl =
+                    self.lower_delegation_decl(sig_id, param_count, c_variadic, span, &generics);
 
-                // Here we pass `root_function_id` as we want to inherit signature (including consts, async)
-                // from the root function that started delegation
-                let sig = self.lower_delegation_sig(root_function_id, decl, span);
+                let sig = self.lower_delegation_sig(sig_id, decl, span);
                 let ident = self.lower_ident(delegation.ident);
 
                 let generics = self.arena.alloc(hir::Generics {
@@ -236,9 +180,9 @@ pub(crate) fn lower_delegation(
         }
     }
 
-    fn add_attrs_if_needed(&mut self, span: Span, ids: &DelegationIds) {
+    fn add_attrs_if_needed(&mut self, span: Span, sig_id: DefId) {
         let new_attrs =
-            self.create_new_attrs(ATTRS_ADDITIONS, span, ids, self.attrs.get(&PARENT_ID));
+            self.create_new_attrs(ATTRS_ADDITIONS, span, sig_id, self.attrs.get(&PARENT_ID));
 
         if new_attrs.is_empty() {
             return;
@@ -258,15 +202,9 @@ fn create_new_attrs(
         &self,
         candidate_additions: &[AttrAdditionInfo],
         span: Span,
-        ids: &DelegationIds,
+        sig_id: DefId,
         existing_attrs: Option<&&[hir::Attribute]>,
     ) -> Vec<hir::Attribute> {
-        let defs_orig_attrs = ids
-            .path
-            .iter()
-            .map(|def_id| (*def_id, self.parse_local_original_attrs(*def_id)))
-            .collect::<Vec<_>>();
-
         candidate_additions
             .iter()
             .filter_map(|addition_info| {
@@ -280,83 +218,22 @@ fn create_new_attrs(
 
                 match addition_info.kind {
                     AttrAdditionKind::Default { factory } => Some(factory(span)),
-                    AttrAdditionKind::Inherit { flag, factory } => {
-                        for (def_id, orig_attrs) in &defs_orig_attrs {
-                            let original_attr = match def_id.as_local() {
-                                Some(local_id) => self
-                                    .get_attrs(local_id)
-                                    .flags
-                                    .contains(flag)
-                                    .then(|| {
-                                        orig_attrs
-                                            .as_ref()
-                                            .map(|attrs| {
-                                                attrs.iter().find(|base_attr| {
-                                                    (addition_info.equals)(base_attr)
-                                                })
-                                            })
-                                            .flatten()
-                                    })
-                                    .flatten(),
-                                None =>
-                                {
-                                    #[allow(deprecated)]
-                                    self.tcx
-                                        .get_all_attrs(*def_id)
-                                        .iter()
-                                        .find(|base_attr| (addition_info.equals)(base_attr))
-                                }
-                            };
-
-                            if let Some(original_attr) = original_attr {
-                                return Some(factory(span, original_attr));
-                            }
-                        }
-
-                        None
+                    AttrAdditionKind::Inherit { factory, .. } =>
+                    {
+                        #[allow(deprecated)]
+                        self.tcx
+                            .get_all_attrs(sig_id)
+                            .iter()
+                            .find_map(|a| (addition_info.equals)(a).then(|| factory(span, a)))
                     }
                 }
             })
             .collect::<Vec<_>>()
     }
 
-    fn parse_local_original_attrs(&self, def_id: DefId) -> Option<Vec<hir::Attribute>> {
-        if let Some(local_id) = def_id.as_local() {
-            let attrs = &self.get_attrs(local_id).to_inherit;
-
-            if !attrs.is_empty() {
-                return Some(AttributeParser::parse_limited_all(
-                    self.tcx.sess,
-                    attrs,
-                    None,
-                    hir::Target::Fn,
-                    DUMMY_SP,
-                    DUMMY_NODE_ID,
-                    Some(self.tcx.features()),
-                    ShouldEmit::Nothing,
-                ));
-            }
-        }
-
-        None
-    }
-
-    fn get_attrs(&self, local_id: LocalDefId) -> &DelegationAttrs {
-        // local_id can correspond either to a function or other delegation
-        if let Some(fn_sig) = self.resolver.delegation_fn_sig(local_id) {
-            &fn_sig.attrs
-        } else {
-            &self.resolver.delegation_info(local_id).expect("processing delegation").attrs
-        }
-    }
-
-    fn get_delegation_ids(
-        &self,
-        mut node_id: NodeId,
-        span: Span,
-    ) -> Result<DelegationIds, ErrorGuaranteed> {
+    fn get_sig_id(&self, mut node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
         let mut visited: FxHashSet<NodeId> = Default::default();
-        let mut path: DelegationIdsVec = Default::default();
+        let mut path: SmallVec<[DefId; 1]> = Default::default();
 
         loop {
             visited.insert(node_id);
@@ -389,7 +266,7 @@ fn get_delegation_ids(
                     });
                 }
             } else {
-                return Ok(DelegationIds::new(path));
+                return Ok(path[0]);
             }
         }
     }
@@ -400,15 +277,8 @@ fn get_resolution_id(&self, node_id: NodeId) -> Option<DefId> {
 
     // Function parameter count, including C variadic `...` if present.
     fn param_count(&self, def_id: DefId) -> (usize, bool /*c_variadic*/) {
-        if let Some(local_sig_id) = def_id.as_local() {
-            match self.resolver.delegation_fn_sig(local_sig_id) {
-                Some(sig) => (sig.param_count, sig.c_variadic),
-                None => (0, false),
-            }
-        } else {
-            let sig = self.tcx.fn_sig(def_id).skip_binder().skip_binder();
-            (sig.inputs().len() + usize::from(sig.c_variadic), sig.c_variadic)
-        }
+        let sig = self.tcx.fn_sig(def_id).skip_binder().skip_binder();
+        (sig.inputs().len() + usize::from(sig.c_variadic), sig.c_variadic)
     }
 
     fn lower_delegation_decl(
@@ -455,41 +325,21 @@ fn lower_delegation_sig(
         decl: &'hir hir::FnDecl<'hir>,
         span: Span,
     ) -> hir::FnSig<'hir> {
-        let header = if let Some(local_sig_id) = sig_id.as_local() {
-            match self.resolver.delegation_fn_sig(local_sig_id) {
-                Some(sig) => {
-                    let parent = self.tcx.parent(sig_id);
-                    // HACK: we override the default safety instead of generating attributes from the ether.
-                    // We are not forwarding the attributes, as the delegation fn sigs are collected on the ast,
-                    // and here we need the hir attributes.
-                    let default_safety =
-                        if sig.attrs.flags.contains(DelegationFnSigAttrs::TARGET_FEATURE)
-                            || self.tcx.def_kind(parent) == DefKind::ForeignMod
-                        {
-                            hir::Safety::Unsafe
-                        } else {
-                            hir::Safety::Safe
-                        };
-                    self.lower_fn_header(sig.header, default_safety, &[])
-                }
-                None => self.generate_header_error(),
-            }
-        } else {
-            let sig = self.tcx.fn_sig(sig_id).skip_binder().skip_binder();
-            let asyncness = match self.tcx.asyncness(sig_id) {
-                Asyncness::Yes => hir::IsAsync::Async(span),
-                Asyncness::No => hir::IsAsync::NotAsync,
-            };
-            hir::FnHeader {
-                safety: if self.tcx.codegen_fn_attrs(sig_id).safe_target_features {
-                    hir::HeaderSafety::SafeTargetFeatures
-                } else {
-                    hir::HeaderSafety::Normal(sig.safety)
-                },
-                constness: self.tcx.constness(sig_id),
-                asyncness,
-                abi: sig.abi,
-            }
+        let sig = self.tcx.fn_sig(sig_id).skip_binder().skip_binder();
+        let asyncness = match self.tcx.asyncness(sig_id) {
+            Asyncness::Yes => hir::IsAsync::Async(span),
+            Asyncness::No => hir::IsAsync::NotAsync,
+        };
+
+        let header = hir::FnHeader {
+            safety: if self.tcx.codegen_fn_attrs(sig_id).safe_target_features {
+                hir::HeaderSafety::SafeTargetFeatures
+            } else {
+                hir::HeaderSafety::Normal(sig.safety)
+            },
+            constness: self.tcx.constness(sig_id),
+            asyncness,
+            abi: sig.abi,
         };
 
         hir::FnSig { decl, header, span }
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index b4564cc81dfc..d6d8819d8c47 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -7,10 +7,10 @@
 use rustc_middle::{bug, ty};
 use rustc_span::sym::{self};
 use rustc_span::symbol::kw;
-use rustc_span::{DUMMY_SP, Ident, Span};
+use rustc_span::{Ident, Span};
 use thin_vec::{ThinVec, thin_vec};
 
-use crate::{AstOwner, LoweringContext, ResolverAstLoweringExt};
+use crate::{LoweringContext, ResolverAstLoweringExt};
 
 pub(super) enum DelegationGenerics<T> {
     /// User-specified args are present: `reuse foo::<String>;`.
@@ -240,7 +240,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_delegation_generics(
         &mut self,
         delegation: &Delegation,
-        root_fn_id: DefId,
+        sig_id: DefId,
         item_id: NodeId,
         span: Span,
     ) -> GenericsGenerationResults<'hir> {
@@ -258,7 +258,7 @@ pub(super) fn lower_delegation_generics(
             // we will take those args that are in trait impl header trait ref.
             let parent = GenericsGenerationResult::new(DelegationGenerics::Default(None));
 
-            let generics = self.get_fn_like_generics(root_fn_id, span);
+            let generics = self.get_external_generics(sig_id, false, span);
             let child = DelegationGenerics::TraitImpl(generics, child_user_specified);
             let child = GenericsGenerationResult::new(child);
 
@@ -269,17 +269,12 @@ pub(super) fn lower_delegation_generics(
             !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
         let root_function_in_trait =
-            matches!(self.tcx.def_kind(self.tcx.parent(root_fn_id)), DefKind::Trait);
+            matches!(self.tcx.def_kind(self.tcx.parent(sig_id)), DefKind::Trait);
 
         let generate_self = delegation_in_free_ctx && root_function_in_trait;
 
         let parent_generics_factory = |this: &mut Self, user_specified: bool| {
-            this.get_parent_generics(
-                this.tcx.parent(root_fn_id),
-                generate_self,
-                user_specified,
-                span,
-            )
+            this.get_parent_generics(this.tcx.parent(sig_id), generate_self, user_specified, span)
         };
 
         let can_add_generics_to_parent = len >= 2
@@ -304,7 +299,7 @@ pub(super) fn lower_delegation_generics(
         let child_generics = if child_user_specified {
             DelegationGenerics::UserSpecified
         } else {
-            DelegationGenerics::Default(self.get_fn_like_generics(root_fn_id, span))
+            DelegationGenerics::Default(self.get_external_generics(sig_id, false, span))
         };
 
         GenericsGenerationResults {
@@ -363,11 +358,9 @@ fn lower_delegation_generic_params(
         // FIXME(fn_delegation): proper support for late bound lifetimes.
         self.arena.alloc(hir::Generics {
             params,
-            predicates: self.arena.alloc_from_iter(
-                params
-                    .iter()
-                    .filter_map(|p| p.is_lifetime().then(|| self.generate_lifetime_predicate(p))),
-            ),
+            predicates: self.arena.alloc_from_iter(params.iter().filter_map(|p| {
+                p.is_lifetime().then(|| self.generate_lifetime_predicate(p, span))
+            })),
             has_where_clause_predicates: false,
             where_clause_span: span,
             span,
@@ -377,6 +370,7 @@ fn lower_delegation_generic_params(
     fn generate_lifetime_predicate(
         &mut self,
         p: &hir::GenericParam<'hir>,
+        span: Span,
     ) -> hir::WherePredicate<'hir> {
         let create_lifetime = |this: &mut Self| -> &'hir hir::Lifetime {
             this.arena.alloc(hir::Lifetime {
@@ -392,7 +386,7 @@ fn generate_lifetime_predicate(
 
         hir::WherePredicate {
             hir_id: self.next_id(),
-            span: DUMMY_SP,
+            span,
             kind: self.arena.alloc(hir::WherePredicateKind::RegionPredicate(
                 hir::WhereRegionPredicate {
                     in_where_clause: true,
@@ -479,22 +473,6 @@ fn create_generics_args_from_params(
         })
     }
 
-    fn get_fn_like_generics(&mut self, id: DefId, span: Span) -> Option<Generics> {
-        if let Some(local_id) = id.as_local() {
-            match self.ast_index.get(local_id) {
-                Some(AstOwner::Item(item)) if let ItemKind::Fn(f) = &item.kind => {
-                    Some(f.generics.clone())
-                }
-                Some(AstOwner::AssocItem(item, _)) if let AssocItemKind::Fn(f) = &item.kind => {
-                    Some(f.generics.clone())
-                }
-                _ => None,
-            }
-        } else {
-            self.get_external_generics(id, false, span)
-        }
-    }
-
     fn get_external_generics(
         &mut self,
         id: DefId,
@@ -519,7 +497,7 @@ fn get_external_generics(
                     bounds: Default::default(),
                     colon_span: None,
                     id: self.next_node_id(),
-                    ident: Ident::with_dummy_span(p.name),
+                    ident: Ident::new(p.name, span),
                     is_placeholder: false,
                     kind: match p.kind {
                         GenericParamDefKind::Lifetime => GenericParamKind::Lifetime,
@@ -531,7 +509,7 @@ fn get_external_generics(
                 })
                 .collect(),
             where_clause: Default::default(),
-            span: DUMMY_SP,
+            span,
         })
     }
 
@@ -563,18 +541,18 @@ fn map_const_kind(&mut self, p: &ty::GenericParamDef, span: Span) -> GenericPara
                     None,
                     Path {
                         segments: thin_vec![PathSegment {
-                            ident: Ident::with_dummy_span(type_symbol),
+                            ident: Ident::new(type_symbol, span),
                             id: self.next_node_id(),
                             args: None
                         }],
-                        span: DUMMY_SP,
+                        span,
                         tokens: None,
                     },
                 ),
-                span: DUMMY_SP,
+                span,
                 tokens: None,
             }),
-            span: DUMMY_SP,
+            span,
             default: None,
         }
     }
@@ -587,28 +565,15 @@ fn get_parent_generics(
         span: Span,
     ) -> Option<Generics> {
         // If args are user-specified we still maybe need to add self.
-        let mut generics = if user_specified {
-            None
-        } else {
-            if let Some(local_id) = id.as_local() {
-                if let Some(AstOwner::Item(item)) = self.ast_index.get(local_id)
-                    && matches!(item.kind, ItemKind::Trait(..))
-                {
-                    item.opt_generics().cloned()
-                } else {
-                    None
-                }
-            } else {
-                self.get_external_generics(id, true, span)
-            }
-        };
+        let mut generics =
+            if user_specified { None } else { self.get_external_generics(id, true, span) };
 
         if add_self {
             generics.get_or_insert_default().params.insert(
                 0,
                 GenericParam {
                     id: self.next_node_id(),
-                    ident: Ident::new(kw::SelfUpper, DUMMY_SP),
+                    ident: Ident::new(kw::SelfUpper, span),
                     attrs: Default::default(),
                     bounds: vec![],
                     is_placeholder: false,
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 87d2483bf473..fa103099e643 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -3,6 +3,7 @@
 use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::attrs::{AttributeKind, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
@@ -27,11 +28,31 @@
     RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
 };
 
+/// Wraps either IndexVec (during `hir_crate`), which acts like a primary
+/// storage for most of the MaybeOwners, or FxIndexMap during delayed AST -> HIR
+/// lowering of delegations (`lower_delayed_owner`),
+/// in this case we can not modify already created IndexVec, so we use other map.
+pub(super) enum Owners<'a, 'hir> {
+    IndexVec(&'a mut IndexVec<LocalDefId, hir::MaybeOwner<'hir>>),
+    Map(&'a mut FxIndexMap<LocalDefId, hir::MaybeOwner<'hir>>),
+}
+
+impl<'hir> Owners<'_, 'hir> {
+    fn get_or_insert_mut(&mut self, def_id: LocalDefId) -> &mut hir::MaybeOwner<'hir> {
+        match self {
+            Owners::IndexVec(index_vec) => {
+                index_vec.ensure_contains_elem(def_id, || hir::MaybeOwner::Phantom)
+            }
+            Owners::Map(map) => map.entry(def_id).or_insert(hir::MaybeOwner::Phantom),
+        }
+    }
+}
+
 pub(super) struct ItemLowerer<'a, 'hir, R> {
     pub(super) tcx: TyCtxt<'hir>,
     pub(super) resolver: &'a mut R,
     pub(super) ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
-    pub(super) owners: &'a mut IndexVec<LocalDefId, hir::MaybeOwner<'hir>>,
+    pub(super) owners: Owners<'a, 'hir>,
 }
 
 /// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set the span
@@ -59,11 +80,11 @@ fn with_lctx(
         owner: NodeId,
         f: impl FnOnce(&mut LoweringContext<'_, 'hir, R>) -> hir::OwnerNode<'hir>,
     ) {
-        let mut lctx = LoweringContext::new(self.tcx, self.ast_index, self.resolver);
+        let mut lctx = LoweringContext::new(self.tcx, self.resolver);
         lctx.with_hir_id_owner(owner, |lctx| f(lctx));
 
         for (def_id, info) in lctx.children {
-            let owner = self.owners.ensure_contains_elem(def_id, || hir::MaybeOwner::Phantom);
+            let owner = self.owners.get_or_insert_mut(def_id);
             assert!(
                 matches!(owner, hir::MaybeOwner::Phantom),
                 "duplicate copy of {def_id:?} in lctx.children"
@@ -73,7 +94,7 @@ fn with_lctx(
     }
 
     pub(super) fn lower_node(&mut self, def_id: LocalDefId) {
-        let owner = self.owners.ensure_contains_elem(def_id, || hir::MaybeOwner::Phantom);
+        let owner = self.owners.get_or_insert_mut(def_id);
         if let hir::MaybeOwner::Phantom = owner {
             let node = self.ast_index[def_id];
             match node {
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index eafa30b4e86c..a073b81a0dcb 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -42,9 +42,10 @@
 use rustc_ast::{self as ast, *};
 use rustc_attr_parsing::{AttributeParser, Late, OmitDoc};
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::sync::spawn;
+use rustc_data_structures::steal::Steal;
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle};
 use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
@@ -57,8 +58,9 @@
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
+use rustc_middle::hir::{self as mid_hir};
 use rustc_middle::span_bug;
-use rustc_middle::ty::{DelegationFnSig, DelegationInfo, ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::{DelegationInfo, ResolverAstLowering, TyCtxt};
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -67,6 +69,7 @@
 use tracing::{debug, instrument, trace};
 
 use crate::errors::{AssocTyParentheses, AssocTyParenthesesSub, MisplacedImplTrait};
+use crate::item::Owners;
 
 macro_rules! arena_vec {
     ($this:expr; $($x:expr),*) => (
@@ -89,15 +92,6 @@ macro_rules! arena_vec {
 
 struct LoweringContext<'a, 'hir, R> {
     tcx: TyCtxt<'hir>,
-
-    // During lowering of delegation we need to access AST of other functions
-    // in order to properly propagate generics, we could have done it at resolve
-    // stage, however it will require either to firstly identify functions that
-    // are being reused and store their generics, or to store generics of all functions
-    // in resolver. This approach helps with those problems, as functions that are reused
-    // will be in AST index.
-    ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
-
     resolver: &'a mut R,
     disambiguator: DisambiguatorState,
 
@@ -159,15 +153,10 @@ struct LoweringContext<'a, 'hir, R> {
 }
 
 impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
-    fn new(
-        tcx: TyCtxt<'hir>,
-        ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
-        resolver: &'a mut R,
-    ) -> Self {
+    fn new(tcx: TyCtxt<'hir>, resolver: &'a mut R) -> Self {
         let registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
         Self {
             tcx,
-            ast_index,
             resolver,
             disambiguator: DisambiguatorState::new(),
             arena: tcx.hir_arena,
@@ -247,8 +236,81 @@ fn lower(&self, span: Span) -> Span {
     }
 }
 
-// LoweringContext now uses this trait for #153489, if #153489 is not merged,
-// feel free to do whatever you want with this trait.
+struct ResolverDelayedAstLowering<'a, 'tcx> {
+    node_id_to_def_id: NodeMap<LocalDefId>,
+    partial_res_map: NodeMap<PartialRes>,
+    next_node_id: NodeId,
+    base: &'a ResolverAstLowering<'tcx>,
+}
+
+// FIXME(fn_delegation): delegate this trait impl to `self.base`
+impl<'a, 'tcx> ResolverAstLoweringExt<'tcx> for ResolverDelayedAstLowering<'a, 'tcx> {
+    fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'tcx>) -> Option<Vec<usize>> {
+        self.base.legacy_const_generic_args(expr, tcx)
+    }
+
+    fn get_partial_res(&self, id: NodeId) -> Option<PartialRes> {
+        self.partial_res_map.get(&id).copied().or_else(|| self.base.get_partial_res(id))
+    }
+
+    fn get_import_res(&self, id: NodeId) -> PerNS<Option<Res<NodeId>>> {
+        self.base.get_import_res(id)
+    }
+
+    fn get_label_res(&self, id: NodeId) -> Option<NodeId> {
+        self.base.get_label_res(id)
+    }
+
+    fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes> {
+        self.base.get_lifetime_res(id)
+    }
+
+    fn extra_lifetime_params(&self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
+        self.base.extra_lifetime_params(id)
+    }
+
+    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
+        self.base.delegation_info(id)
+    }
+
+    fn opt_local_def_id(&self, id: NodeId) -> Option<LocalDefId> {
+        self.node_id_to_def_id.get(&id).copied().or_else(|| self.base.opt_local_def_id(id))
+    }
+
+    fn local_def_id(&self, id: NodeId) -> LocalDefId {
+        self.opt_local_def_id(id).expect("must have def_id")
+    }
+
+    fn lifetime_elision_allowed(&self, id: NodeId) -> bool {
+        self.base.lifetime_elision_allowed(id)
+    }
+
+    fn insert_new_def_id(&mut self, node_id: NodeId, def_id: LocalDefId) {
+        self.node_id_to_def_id.insert(node_id, def_id);
+    }
+
+    fn insert_partial_res(&mut self, node_id: NodeId, res: PartialRes) {
+        self.partial_res_map.insert(node_id, res);
+    }
+
+    fn trait_candidates(&self, node_id: NodeId) -> Option<&'tcx [hir::TraitCandidate<'tcx>]> {
+        self.base.trait_candidates(node_id)
+    }
+
+    #[inline]
+    fn next_node_id(&mut self) -> NodeId {
+        next_node_id(&mut self.next_node_id)
+    }
+}
+
+fn next_node_id(current_id: &mut NodeId) -> NodeId {
+    let start = *current_id;
+    let next = start.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
+    *current_id = ast::NodeId::from_u32(next);
+
+    start
+}
+
 #[extension(trait ResolverAstLoweringExt<'tcx>)]
 impl<'tcx> ResolverAstLowering<'tcx> {
     fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'tcx>) -> Option<Vec<usize>> {
@@ -309,10 +371,6 @@ fn extra_lifetime_params(&self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)>
         self.extra_lifetime_params_map.get(&id).cloned().unwrap_or_default()
     }
 
-    fn delegation_fn_sig(&self, id: LocalDefId) -> Option<&DelegationFnSig> {
-        self.delegation_fn_sigs.get(&id)
-    }
-
     fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
         self.delegation_infos.get(&id)
     }
@@ -343,11 +401,7 @@ fn trait_candidates(&self, node_id: NodeId) -> Option<&'tcx [hir::TraitCandidate
 
     #[inline]
     fn next_node_id(&mut self) -> NodeId {
-        let start = self.next_node_id;
-        let next = start.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
-        self.next_node_id = ast::NodeId::from_u32(next);
-
-        start
+        next_node_id(&mut self.next_node_id)
     }
 }
 
@@ -555,8 +609,7 @@ fn compute_hir_hash(
     })
 }
 
-pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> hir::Crate<'_> {
-    let sess = tcx.sess;
+pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> mid_hir::Crate<'_> {
     // Queries that borrow `resolver_for_lowering`.
     tcx.ensure_done().output_filenames(());
     tcx.ensure_done().early_lint_checks(());
@@ -574,26 +627,60 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> hir::Crate<'_> {
         tcx,
         resolver: &mut resolver,
         ast_index: &ast_index,
-        owners: &mut owners,
+        owners: Owners::IndexVec(&mut owners),
     };
 
+    let mut delayed_ids: FxIndexSet<LocalDefId> = Default::default();
+
     for def_id in ast_index.indices() {
-        lowerer.lower_node(def_id);
+        match &ast_index[def_id] {
+            AstOwner::Item(Item { kind: ItemKind::Delegation { .. }, .. })
+            | AstOwner::AssocItem(Item { kind: AssocItemKind::Delegation { .. }, .. }, _) => {
+                delayed_ids.insert(def_id);
+            }
+            _ => lowerer.lower_node(def_id),
+        };
     }
 
-    drop(ast_index);
-
-    // Drop AST to free memory. It can be expensive so try to drop it on a separate thread.
-    let prof = sess.prof.clone();
-    spawn(move || {
-        let _timer = prof.verbose_generic_activity("drop_ast");
-        drop(krate);
-    });
-
     // Don't hash unless necessary, because it's expensive.
     let opt_hir_hash =
         if tcx.needs_crate_hash() { Some(compute_hir_hash(tcx, &owners)) } else { None };
-    hir::Crate { owners, opt_hir_hash }
+
+    let delayed_resolver = Steal::new((resolver, krate));
+    mid_hir::Crate::new(owners, delayed_ids, delayed_resolver, opt_hir_hash)
+}
+
+/// Lowers an AST owner corresponding to `def_id`, now only delegations are lowered this way.
+pub fn lower_delayed_owner(tcx: TyCtxt<'_>, def_id: LocalDefId) {
+    let krate = tcx.hir_crate(());
+
+    let (resolver, krate) = &*krate.delayed_resolver.borrow();
+
+    // FIXME!!!(fn_delegation): make ast index lifetime same as resolver,
+    // as it is too bad to reindex whole crate on each delegation lowering.
+    let ast_index = index_crate(resolver, krate);
+
+    let mut resolver = ResolverDelayedAstLowering {
+        next_node_id: resolver.next_node_id,
+        partial_res_map: Default::default(),
+        node_id_to_def_id: Default::default(),
+        base: resolver,
+    };
+
+    let mut map = Default::default();
+
+    let mut lowerer = item::ItemLowerer {
+        tcx,
+        resolver: &mut resolver,
+        ast_index: &ast_index,
+        owners: Owners::Map(&mut map),
+    };
+
+    lowerer.lower_node(def_id);
+
+    for (&child_def_id, &owner) in &map {
+        tcx.feed_delayed_owner(child_def_id, owner);
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 7cce0eda4dda..9526143fcace 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1667,19 +1667,6 @@ pub fn unwrap(self) -> &'tcx OwnerInfo<'tcx> {
     }
 }
 
-/// The top-level data structure that stores the entire contents of
-/// the crate currently being compiled.
-///
-/// For more details, see the [rustc dev guide].
-///
-/// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
-#[derive(Debug)]
-pub struct Crate<'hir> {
-    pub owners: IndexVec<LocalDefId, MaybeOwner<'hir>>,
-    // Only present when incr. comp. is enabled.
-    pub opt_hir_hash: Option<Fingerprint>,
-}
-
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct Closure<'hir> {
     pub def_id: LocalDefId,
diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs
index a3f4415ec343..58649a694880 100644
--- a/compiler/rustc_hir/src/stable_hash_impls.rs
+++ b/compiler/rustc_hir/src/stable_hash_impls.rs
@@ -3,7 +3,7 @@
 
 use crate::HashIgnoredAttrId;
 use crate::hir::{
-    AttributeMap, BodyId, Crate, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
+    AttributeMap, BodyId, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
 };
 use crate::hir_id::ItemLocalId;
 use crate::lints::DelayedLints;
@@ -94,13 +94,6 @@ fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
     }
 }
 
-impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Crate<'_> {
-    fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
-        let Crate { owners: _, opt_hir_hash } = self;
-        opt_hir_hash.unwrap().hash_stable(hcx, hasher)
-    }
-}
-
 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for HashIgnoredAttrId {
     fn hash_stable(&self, _hcx: &mut HirCtx, _hasher: &mut StableHasher) {
         /* we don't hash HashIgnoredAttrId, we ignore them */
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index cf62d4223211..6b7f31521d44 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -21,7 +21,7 @@
 use rustc_hir::def_id::{LOCAL_CRATE, StableCrateId, StableCrateIdMap};
 use rustc_hir::definitions::Definitions;
 use rustc_hir::limit::Limit;
-use rustc_hir::{Attribute, find_attr};
+use rustc_hir::{Attribute, MaybeOwner, find_attr};
 use rustc_incremental::setup_dep_graph;
 use rustc_lint::{BufferedEarlyLint, EarlyCheckNode, LintStore, unerased_lint_store};
 use rustc_metadata::EncodedMetadata;
@@ -878,6 +878,10 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
     let providers = &mut Providers::default();
     providers.queries.analysis = analysis;
     providers.queries.hir_crate = rustc_ast_lowering::lower_to_hir;
+    providers.queries.lower_delayed_owner = rustc_ast_lowering::lower_delayed_owner;
+    // `delayed_owner` is fed during `lower_delayed_owner`, by default it returns phantom,
+    // as if this query was not fed it means that `MaybeOwner` does not exist for provided LocalDefId.
+    providers.queries.delayed_owner = |_, _| MaybeOwner::Phantom;
     providers.queries.resolver_for_lowering_raw = resolver_for_lowering_raw;
     providers.queries.stripped_cfg_items = |tcx, _| &tcx.resolutions(()).stripped_cfg_items[..];
     providers.queries.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index fc2a7fbd4fa9..499c6dae060b 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -7,7 +7,7 @@
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::svh::Svh;
-use rustc_data_structures::sync::{DynSend, DynSync, par_for_each_in, try_par_for_each_in};
+use rustc_data_structures::sync::{DynSend, DynSync, par_for_each_in, spawn, try_par_for_each_in};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
@@ -1245,7 +1245,25 @@ pub(super) fn hir_module_items(tcx: TyCtxt<'_>, module_id: LocalModDefId) -> Mod
     }
 }
 
+fn force_delayed_owners_lowering(tcx: TyCtxt<'_>) {
+    let krate = tcx.hir_crate(());
+    for &id in &krate.delayed_ids {
+        tcx.ensure_done().lower_delayed_owner(id);
+    }
+
+    let (_, krate) = krate.delayed_resolver.steal();
+    let prof = tcx.sess.prof.clone();
+
+    // Drop AST to free memory. It can be expensive so try to drop it on a separate thread.
+    spawn(move || {
+        let _timer = prof.verbose_generic_activity("drop_ast");
+        drop(krate);
+    });
+}
+
 pub(crate) fn hir_crate_items(tcx: TyCtxt<'_>, _: ()) -> ModuleItems {
+    force_delayed_owners_lowering(tcx);
+
     let mut collector = ItemCollector::new(tcx, true);
 
     // A "crate collector" and "module collector" start at a
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index 82f8eb4bbc4a..ad56e462d293 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -6,19 +6,83 @@
 pub mod nested_filter;
 pub mod place;
 
+use std::sync::Arc;
+
+use rustc_ast::{self as ast};
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::steal::Steal;
 use rustc_data_structures::sync::{DynSend, DynSync, try_par_for_each_in};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::*;
+use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_span::{ErrorGuaranteed, ExpnId, Span};
 
 use crate::query::Providers;
-use crate::ty::TyCtxt;
+use crate::ty::{ResolverAstLowering, TyCtxt};
+
+/// The top-level data structure that stores the entire contents of
+/// the crate currently being compiled.
+///
+/// For more details, see the [rustc dev guide].
+///
+/// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
+#[derive(Debug)]
+pub struct Crate<'hir> {
+    // This field is private by intention, access it through `owner` method.
+    owners: IndexVec<LocalDefId, MaybeOwner<'hir>>,
+    // Ids of delayed AST owners which are lowered through `lower_delayed_owner` query.
+    pub delayed_ids: FxIndexSet<LocalDefId>,
+    // The resolver and AST crate which are set in the end of the `hir_crate` query
+    // and then stolen and dropped in `force_delayed_owners_lowering`.
+    pub delayed_resolver: Steal<(ResolverAstLowering<'hir>, Arc<ast::Crate>)>,
+    // Only present when incr. comp. is enabled.
+    pub opt_hir_hash: Option<Fingerprint>,
+}
+
+impl<'hir> Crate<'hir> {
+    pub fn new(
+        owners: IndexVec<LocalDefId, MaybeOwner<'hir>>,
+        delayed_ids: FxIndexSet<LocalDefId>,
+        delayed_resolver: Steal<(ResolverAstLowering<'hir>, Arc<ast::Crate>)>,
+        opt_hir_hash: Option<Fingerprint>,
+    ) -> Crate<'hir> {
+        Crate { owners, delayed_ids, delayed_resolver, opt_hir_hash }
+    }
+
+    /// Serves as an entry point for getting `MaybeOwner`. As owner can either be in
+    /// `owners` of `hir_crate` or it can be delayed AST owner (i.e., delegations)
+    /// we need to firstly check in `hir_crate` and then delayed AST owners.
+    /// This method can be invoked when not all delayed AST owners are lowered.
+    pub fn owner(&self, tcx: TyCtxt<'hir>, def_id: LocalDefId) -> MaybeOwner<'hir> {
+        // Delayed LocalDefId can be in `self.owners` if there exists non-delayed LocalDefId
+        // which is greater than delayed LocalDefId, we use IndexVec for owners,
+        // so we will call ensure_contains_elem which will grow it.
+        if let Some(owner) = self.owners.get(def_id)
+            && (self.delayed_ids.is_empty() || !matches!(owner, MaybeOwner::Phantom))
+        {
+            return *owner;
+        }
+
+        if self.delayed_ids.contains(&def_id) {
+            tcx.ensure_done().lower_delayed_owner(def_id);
+        }
+
+        tcx.delayed_owner(def_id)
+    }
+}
+
+impl<HirCtx: HashStableContext> HashStable<HirCtx> for Crate<'_> {
+    fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
+        let Crate { opt_hir_hash, .. } = self;
+        opt_hir_hash.unwrap().hash_stable(hcx, hasher)
+    }
+}
 
 /// Gather the LocalDefId for each item-like within a module, including items contained within
 /// bodies. The Ids are in visitor order. This is used to partition a pass between modules.
@@ -372,7 +436,9 @@ fn hir_owner_parent_impl(self, owner_id: OwnerId) -> HirId {
             let parent_owner_id = self.local_def_id_to_hir_id(parent_def_id).owner;
             HirId {
                 owner: parent_owner_id,
-                local_id: self.hir_crate(()).owners[parent_owner_id.def_id]
+                local_id: self
+                    .hir_crate(())
+                    .owner(self, parent_owner_id.def_id)
                     .unwrap()
                     .parenting
                     .get(&owner_id.def_id)
@@ -406,19 +472,19 @@ pub fn provide(providers: &mut Providers) {
     providers.hir_crate_items = map::hir_crate_items;
     providers.crate_hash = map::crate_hash;
     providers.hir_module_items = map::hir_module_items;
-    providers.local_def_id_to_hir_id = |tcx, def_id| match tcx.hir_crate(()).owners[def_id] {
+    providers.local_def_id_to_hir_id = |tcx, def_id| match tcx.hir_crate(()).owner(tcx, def_id) {
         MaybeOwner::Owner(_) => HirId::make_owner(def_id),
         MaybeOwner::NonOwner(hir_id) => hir_id,
         MaybeOwner::Phantom => bug!("No HirId for {:?}", def_id),
     };
     providers.opt_hir_owner_nodes =
-        |tcx, id| tcx.hir_crate(()).owners.get(id)?.as_owner().map(|i| &i.nodes);
+        |tcx, id| tcx.hir_crate(()).owner(tcx, id).as_owner().map(|i| &i.nodes);
     providers.hir_owner_parent_q = |tcx, owner_id| tcx.hir_owner_parent_impl(owner_id);
     providers.hir_attr_map = |tcx, id| {
-        tcx.hir_crate(()).owners[id.def_id].as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
+        tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
     };
     providers.opt_ast_lowering_delayed_lints =
-        |tcx, id| tcx.hir_crate(()).owners[id.def_id].as_owner().map(|o| &o.delayed_lints);
+        |tcx, id| tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map(|o| &o.delayed_lints);
     providers.def_span = |tcx, def_id| tcx.hir_span(tcx.local_def_id_to_hir_id(def_id));
     providers.def_ident_span = |tcx, def_id| {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
@@ -459,6 +525,6 @@ pub fn provide(providers: &mut Providers) {
     providers.expn_that_defined =
         |tcx, id| tcx.resolutions(()).expn_that_defined.get(&id).copied().unwrap_or(ExpnId::root());
     providers.in_scope_traits_map = |tcx, id| {
-        tcx.hir_crate(()).owners[id.def_id].as_owner().map(|owner_info| &owner_info.trait_map)
+        tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map(|owner_info| &owner_info.trait_map)
     };
 }
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 4dd68db4f913..255adf509c69 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -68,7 +68,7 @@
     CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
 };
 use rustc_hir::lang_items::{LangItem, LanguageItems};
-use rustc_hir::{Crate, ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
+use rustc_hir::{ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
 use rustc_index::IndexVec;
 use rustc_lint_defs::LintId;
 use rustc_macros::rustc_queries;
@@ -82,6 +82,7 @@
 use rustc_span::{DUMMY_SP, LocalExpnId, Span, Spanned, Symbol};
 use rustc_target::spec::PanicStrategy;
 
+use crate::hir::Crate;
 use crate::infer::canonical::{self, Canonical};
 use crate::lint::LintExpectation;
 use crate::metadata::ModChild;
@@ -210,6 +211,16 @@
         desc { "getting the crate HIR" }
     }
 
+    query lower_delayed_owner(def_id: LocalDefId) {
+        eval_always
+        desc { "lowering the delayed AST owner `{}`", tcx.def_path_str(def_id) }
+    }
+
+    query delayed_owner(def_id: LocalDefId) -> hir::MaybeOwner<'tcx>  {
+        feedable
+        desc { "getting child of lowered delayed AST owner `{}`", tcx.def_path_str(def_id) }
+    }
+
     /// All items in the crate.
     query hir_crate_items(_: ()) -> &'tcx rustc_middle::hir::ModuleItems {
         arena_cache
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 56428780d22d..58a2edca8ece 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -36,7 +36,7 @@
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
-use rustc_hir::{self as hir, CRATE_HIR_ID, HirId, Node, TraitCandidate, find_attr};
+use rustc_hir::{self as hir, CRATE_HIR_ID, HirId, MaybeOwner, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
 use rustc_macros::Diagnostic;
 use rustc_session::Session;
@@ -657,6 +657,11 @@ pub fn feed_anon_const_type(self, key: LocalDefId, value: ty::EarlyBinder<'tcx,
         debug_assert_eq!(self.def_kind(key), DefKind::AnonConst);
         TyCtxtFeed { tcx: self, key }.type_of(value)
     }
+
+    /// Feeds the HIR delayed owner during AST -> HIR delayed lowering.
+    pub fn feed_delayed_owner(self, key: LocalDefId, owner: MaybeOwner<'tcx>) {
+        TyCtxtFeed { tcx: self, key }.delayed_owner(owner);
+    }
 }
 
 impl<'tcx, KEY: Copy> TyCtxtFeed<'tcx, KEY> {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index d35b755b3193..f072b26e2691 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -27,7 +27,6 @@
     Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, ScalableElt, VariantIdx,
 };
 use rustc_ast as ast;
-use rustc_ast::AttrVec;
 use rustc_ast::expand::typetree::{FncTree, Kind, Type, TypeTree};
 use rustc_ast::node_id::NodeMap;
 pub use rustc_ast_ir::{Movability, Mutability, try_visit};
@@ -221,43 +220,15 @@ pub struct ResolverAstLowering<'tcx> {
     /// Lints that were emitted by the resolver and early lints.
     pub lint_buffer: Steal<LintBuffer>,
 
-    /// Information about functions signatures for delegation items expansion
-    pub delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
     // Information about delegations which is used when handling recursive delegations
     pub delegation_infos: LocalDefIdMap<DelegationInfo>,
 }
 
-bitflags::bitflags! {
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-    pub struct DelegationFnSigAttrs: u8 {
-        const TARGET_FEATURE = 1 << 0;
-        const MUST_USE = 1 << 1;
-    }
-}
-
-pub const DELEGATION_INHERIT_ATTRS_START: DelegationFnSigAttrs = DelegationFnSigAttrs::MUST_USE;
-
 #[derive(Debug)]
 pub struct DelegationInfo {
     // NodeId (either delegation.id or item_id in case of a trait impl) for signature resolution,
     // for details see https://github.com/rust-lang/rust/issues/118212#issuecomment-2160686914
     pub resolution_node: ast::NodeId,
-    pub attrs: DelegationAttrs,
-}
-
-#[derive(Debug)]
-pub struct DelegationAttrs {
-    pub flags: DelegationFnSigAttrs,
-    pub to_inherit: AttrVec,
-}
-
-#[derive(Debug)]
-pub struct DelegationFnSig {
-    pub header: ast::FnHeader,
-    pub param_count: usize,
-    pub has_self: bool,
-    pub c_variadic: bool,
-    pub attrs: DelegationAttrs,
 }
 
 #[derive(Clone, Copy, Debug, HashStable)]
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 453fe9d7a8e0..02412394d657 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -29,10 +29,7 @@
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{MissingLifetimeKind, PrimTy, TraitCandidate};
 use rustc_middle::middle::resolve_bound_vars::Set1;
-use rustc_middle::ty::{
-    AssocTag, DELEGATION_INHERIT_ATTRS_START, DelegationAttrs, DelegationFnSig,
-    DelegationFnSigAttrs, DelegationInfo, Visibility,
-};
+use rustc_middle::ty::{AssocTag, DelegationInfo, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
@@ -43,9 +40,9 @@
 use tracing::{debug, instrument, trace};
 
 use crate::{
-    BindingError, BindingKey, Decl, Finalize, IdentKey, LateDecl, Module, ModuleOrUniformRoot,
-    ParentScope, PathResult, ResolutionError, Resolver, Segment, Stage, TyCtxt, UseError, Used,
-    errors, path_names_to_string, rustdoc,
+    BindingError, BindingKey, Decl, DelegationFnSig, Finalize, IdentKey, LateDecl, Module,
+    ModuleOrUniformRoot, ParentScope, PathResult, ResolutionError, Resolver, Segment, Stage,
+    TyCtxt, UseError, Used, errors, path_names_to_string, rustdoc,
 };
 
 mod diagnostics;
@@ -2989,7 +2986,7 @@ fn resolve_item(&mut self, item: &'ast Item) {
                     item.id,
                     LifetimeBinderKind::Function,
                     span,
-                    |this| this.resolve_delegation(delegation, item.id, false, &item.attrs),
+                    |this| this.resolve_delegation(delegation, item.id, false),
                 );
             }
 
@@ -3335,7 +3332,7 @@ fn resolve_trait_items(&mut self, trait_items: &'ast [Box<AssocItem>]) {
                         item.id,
                         LifetimeBinderKind::Function,
                         delegation.path.segments.last().unwrap().ident.span,
-                        |this| this.resolve_delegation(delegation, item.id, false, &item.attrs),
+                        |this| this.resolve_delegation(delegation, item.id, false),
                     );
                 }
                 AssocItemKind::Type(box TyAlias { generics, .. }) => self
@@ -3649,7 +3646,7 @@ fn resolve_impl_item(
 
                         // Here we don't use `trait_id`, as we can process unresolved trait, however
                         // in this case we are still in a trait impl, https://github.com/rust-lang/rust/issues/150152
-                        this.resolve_delegation(delegation, item.id, is_in_trait_impl, &item.attrs);
+                        this.resolve_delegation(delegation, item.id, is_in_trait_impl);
                     },
                 );
             }
@@ -3804,7 +3801,6 @@ fn resolve_delegation(
         delegation: &'ast Delegation,
         item_id: NodeId,
         is_in_trait_impl: bool,
-        attrs: &[Attribute],
     ) {
         self.smart_resolve_path(
             delegation.id,
@@ -3822,7 +3818,6 @@ fn resolve_delegation(
         self.r.delegation_infos.insert(
             self.r.local_def_id(item_id),
             DelegationInfo {
-                attrs: create_delegation_attrs(attrs),
                 resolution_node: if is_in_trait_impl { item_id } else { delegation.id },
             },
         );
@@ -5433,52 +5428,13 @@ struct ItemInfoCollector<'a, 'ra, 'tcx> {
 }
 
 impl ItemInfoCollector<'_, '_, '_> {
-    fn collect_fn_info(
-        &mut self,
-        header: FnHeader,
-        decl: &FnDecl,
-        id: NodeId,
-        attrs: &[Attribute],
-    ) {
-        self.r.delegation_fn_sigs.insert(
-            self.r.local_def_id(id),
-            DelegationFnSig {
-                header,
-                param_count: decl.inputs.len(),
-                has_self: decl.has_self(),
-                c_variadic: decl.c_variadic(),
-                attrs: create_delegation_attrs(attrs),
-            },
-        );
+    fn collect_fn_info(&mut self, decl: &FnDecl, id: NodeId) {
+        self.r
+            .delegation_fn_sigs
+            .insert(self.r.local_def_id(id), DelegationFnSig { has_self: decl.has_self() });
     }
 }
 
-fn create_delegation_attrs(attrs: &[Attribute]) -> DelegationAttrs {
-    static NAMES_TO_FLAGS: &[(Symbol, DelegationFnSigAttrs)] = &[
-        (sym::target_feature, DelegationFnSigAttrs::TARGET_FEATURE),
-        (sym::must_use, DelegationFnSigAttrs::MUST_USE),
-    ];
-
-    let mut to_inherit_attrs = AttrVec::new();
-    let mut flags = DelegationFnSigAttrs::empty();
-
-    'attrs_loop: for attr in attrs {
-        for &(name, flag) in NAMES_TO_FLAGS {
-            if attr.has_name(name) {
-                flags.set(flag, true);
-
-                if flag.bits() >= DELEGATION_INHERIT_ATTRS_START.bits() {
-                    to_inherit_attrs.push(attr.clone());
-                }
-
-                continue 'attrs_loop;
-            }
-        }
-    }
-
-    DelegationAttrs { flags, to_inherit: to_inherit_attrs }
-}
-
 fn required_generic_args_suggestion(generics: &ast::Generics) -> Option<String> {
     let required = generics
         .params
@@ -5518,7 +5474,7 @@ fn visit_item(&mut self, item: &'ast Item) {
             | ItemKind::Trait(box Trait { generics, .. })
             | ItemKind::TraitAlias(box TraitAlias { generics, .. }) => {
                 if let ItemKind::Fn(box Fn { sig, .. }) = &item.kind {
-                    self.collect_fn_info(sig.header, &sig.decl, item.id, &item.attrs);
+                    self.collect_fn_info(&sig.decl, item.id);
                 }
 
                 let def_id = self.r.local_def_id(item.id);
@@ -5530,12 +5486,10 @@ fn visit_item(&mut self, item: &'ast Item) {
                 self.r.item_generics_num_lifetimes.insert(def_id, count);
             }
 
-            ItemKind::ForeignMod(ForeignMod { extern_span, safety: _, abi, items }) => {
+            ItemKind::ForeignMod(ForeignMod { items, .. }) => {
                 for foreign_item in items {
                     if let ForeignItemKind::Fn(box Fn { sig, .. }) = &foreign_item.kind {
-                        let new_header =
-                            FnHeader { ext: Extern::from_abi(*abi, *extern_span), ..sig.header };
-                        self.collect_fn_info(new_header, &sig.decl, foreign_item.id, &item.attrs);
+                        self.collect_fn_info(&sig.decl, foreign_item.id);
                     }
                 }
             }
@@ -5561,7 +5515,7 @@ fn visit_item(&mut self, item: &'ast Item) {
 
     fn visit_assoc_item(&mut self, item: &'ast AssocItem, ctxt: AssocCtxt) {
         if let AssocItemKind::Fn(box Fn { sig, .. }) = &item.kind {
-            self.collect_fn_info(sig.header, &sig.decl, item.id, &item.attrs);
+            self.collect_fn_info(&sig.decl, item.id);
         }
 
         if let AssocItemKind::Type(box ast::TyAlias { generics, .. }) = &item.kind {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 7c942191d467..c18dfb3e56fe 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -65,8 +65,8 @@
 use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{
-    self, DelegationFnSig, DelegationInfo, Feed, MainDefinition, RegisteredTools,
-    ResolverAstLowering, ResolverGlobalCtxt, TyCtxt, TyCtxtFeed, Visibility,
+    self, DelegationInfo, Feed, MainDefinition, RegisteredTools, ResolverAstLowering,
+    ResolverGlobalCtxt, TyCtxt, TyCtxtFeed, Visibility,
 };
 use rustc_session::config::CrateType;
 use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
@@ -1157,6 +1157,11 @@ pub struct ResolverOutputs<'tcx> {
     pub ast_lowering: ResolverAstLowering<'tcx>,
 }
 
+#[derive(Debug)]
+struct DelegationFnSig {
+    pub has_self: bool,
+}
+
 /// The main resolver class.
 ///
 /// This is the visitor that walks the whole crate.
@@ -1856,7 +1861,6 @@ pub fn into_outputs(self) -> ResolverOutputs<'tcx> {
             trait_map: self.trait_map,
             lifetime_elision_allowed: self.lifetime_elision_allowed,
             lint_buffer: Steal::new(self.lint_buffer),
-            delegation_fn_sigs: self.delegation_fn_sigs,
             delegation_infos: self.delegation_infos,
         };
         ResolverOutputs { global_ctxt, ast_lowering }
diff --git a/tests/pretty/delegation-inherit-attributes.pp b/tests/pretty/delegation-inherit-attributes.pp
index 2525d308553b..242e7161aa84 100644
--- a/tests/pretty/delegation-inherit-attributes.pp
+++ b/tests/pretty/delegation-inherit-attributes.pp
@@ -117,7 +117,7 @@ mod recursive {
         fn foo<Self>(self: _, arg1: _) -> _ { <X as T>::foo(self + 1, arg1) }
         #[attr = MustUse {reason: "some reason"}]
         #[attr = Inline(Hint)]
-        fn bar(self: _, arg1: _) -> _ { foo(self + 1, arg1) }
+        fn bar<Self>(arg0: _, arg1: _) -> _ { foo(self + 1, arg1) }
     }
 }
 
diff --git a/tests/ui/delegation/generics/free-fn-to-free-fn.rs b/tests/ui/delegation/generics/free-fn-to-free-fn.rs
index 285059e63a75..67f7a12d710d 100644
--- a/tests/ui/delegation/generics/free-fn-to-free-fn.rs
+++ b/tests/ui/delegation/generics/free-fn-to-free-fn.rs
@@ -16,8 +16,8 @@ pub fn bounds<T: Clone>(_: T) {}
 reuse to_reuse::bounds;
 
 fn main() {
-    // FIXME(fn_delegation): proper support for late bound lifetimes.
     late::<'static>(&0u8);
+    //~^ ERROR: function takes 0 lifetime arguments but 1 lifetime argument was supplied
 
     struct S;
     bounds(S);
diff --git a/tests/ui/delegation/generics/free-fn-to-free-fn.stderr b/tests/ui/delegation/generics/free-fn-to-free-fn.stderr
index 6b6acfc3afff..db88b8d4f8b7 100644
--- a/tests/ui/delegation/generics/free-fn-to-free-fn.stderr
+++ b/tests/ui/delegation/generics/free-fn-to-free-fn.stderr
@@ -1,3 +1,17 @@
+error[E0107]: function takes 0 lifetime arguments but 1 lifetime argument was supplied
+  --> $DIR/free-fn-to-free-fn.rs:19:5
+   |
+LL |     late::<'static>(&0u8);
+   |     ^^^^----------- help: remove the unnecessary generics
+   |     |
+   |     expected 0 lifetime arguments
+   |
+note: function defined here, with 0 lifetime parameters
+  --> $DIR/free-fn-to-free-fn.rs:15:17
+   |
+LL | reuse to_reuse::late;
+   |                 ^^^^
+
 error[E0277]: the trait bound `S: Clone` is not satisfied
   --> $DIR/free-fn-to-free-fn.rs:23:12
    |
@@ -20,6 +34,7 @@ LL +     #[derive(Clone)]
 LL |     struct S;
    |
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0107, E0277.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/delegation/generics/free-fn-to-trait-infer.stderr b/tests/ui/delegation/generics/free-fn-to-trait-infer.stderr
index ead3c30a6886..a20b28c16402 100644
--- a/tests/ui/delegation/generics/free-fn-to-trait-infer.stderr
+++ b/tests/ui/delegation/generics/free-fn-to-trait-infer.stderr
@@ -23,7 +23,6 @@ LL | reuse <u8 as Trait<_>>::foo as generic_arguments2;
    |                         ^^^
    |                         |
    |                         expected `&u8`, found `&Self`
-   |                         found this type parameter
    |                         arguments to this function are incorrect
    |
    = note: expected reference `&u8`
diff --git a/tests/ui/delegation/generics/generics-gen-args-errors.stderr b/tests/ui/delegation/generics/generics-gen-args-errors.stderr
index 78aefbc6604c..6c57c3bc8d51 100644
--- a/tests/ui/delegation/generics/generics-gen-args-errors.stderr
+++ b/tests/ui/delegation/generics/generics-gen-args-errors.stderr
@@ -537,10 +537,8 @@ LL |         bar::<1, 2, 3, 4, 5, 6>();
 note: function defined here, with 3 generic parameters: `T`, `U`, `N`
   --> $DIR/generics-gen-args-errors.rs:8:18
    |
-LL |     fn foo<'a: 'a, 'b: 'b, T: Clone, U: Clone, const N: usize>() {}
-   |                            -         -         --------------
 LL |     reuse foo as bar;
-   |                  ^^^
+   |           ---    ^^^
 
 error[E0107]: function takes 2 lifetime arguments but 5 lifetime arguments were supplied
   --> $DIR/generics-gen-args-errors.rs:17:9
@@ -553,10 +551,8 @@ LL |         bar::<'static, 'static, 'static, 'static, 'static>();
 note: function defined here, with 2 lifetime parameters: `'a`, `'b`
   --> $DIR/generics-gen-args-errors.rs:8:18
    |
-LL |     fn foo<'a: 'a, 'b: 'b, T: Clone, U: Clone, const N: usize>() {}
-   |            --      --
 LL |     reuse foo as bar;
-   |                  ^^^
+   |           ---    ^^^
 
 error[E0747]: constant provided when a type was expected
   --> $DIR/generics-gen-args-errors.rs:20:23
@@ -575,10 +571,8 @@ LL |         bar::<_, _, _, _, _>();
 note: function defined here, with 3 generic parameters: `T`, `U`, `N`
   --> $DIR/generics-gen-args-errors.rs:8:18
    |
-LL |     fn foo<'a: 'a, 'b: 'b, T: Clone, U: Clone, const N: usize>() {}
-   |                            -         -         --------------
 LL |     reuse foo as bar;
-   |                  ^^^
+   |           ---    ^^^
 
 error[E0747]: unresolved item provided when a constant was expected
   --> $DIR/generics-gen-args-errors.rs:28:25
diff --git a/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr b/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr
index 00dfedef47b5..9234771ca11f 100644
--- a/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr
+++ b/tests/ui/delegation/generics/trait-impl-wrong-args-count.stderr
@@ -1,11 +1,11 @@
 error[E0107]: function takes at most 2 generic arguments but 3 generic arguments were supplied
   --> $DIR/trait-impl-wrong-args-count.rs:25:25
    |
-LL |         fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
-   |                                      ----------------- help: remove the unnecessary generic argument
-...
 LL |         reuse to_reuse::bar;
-   |                         ^^^ expected at most 2 generic arguments
+   |                         ^^^
+   |                         |
+   |                         expected at most 2 generic arguments
+   |                         help: remove the unnecessary generic argument
    |
 note: function defined here, with at most 2 generic parameters: `A`, `B`
   --> $DIR/trait-impl-wrong-args-count.rs:7:16
@@ -138,11 +138,11 @@ LL |         reuse <X as Trait1::<(), ()>>::foo as bar2;
 error[E0107]: associated function takes at most 2 generic arguments but 3 generic arguments were supplied
   --> $DIR/trait-impl-wrong-args-count.rs:105:40
    |
-LL |         fn bar3<X, Y, Z>() {}
-   |                     --- help: remove the unnecessary generic argument
-...
 LL |         reuse <X as Trait1::<(), ()>>::foo as bar3;
-   |                                        ^^^ expected at most 2 generic arguments
+   |                                        ^^^
+   |                                        |
+   |                                        expected at most 2 generic arguments
+   |                                        help: remove the unnecessary generic argument
    |
 note: associated function defined here, with at most 2 generic parameters: `X`, `Y`
   --> $DIR/trait-impl-wrong-args-count.rs:88:12
diff --git a/tests/ui/pin-ergonomics/pin_v2-attr.stderr b/tests/ui/pin-ergonomics/pin_v2-attr.stderr
index 8f8a9f3b3a19..5c8a455114c4 100644
--- a/tests/ui/pin-ergonomics/pin_v2-attr.stderr
+++ b/tests/ui/pin-ergonomics/pin_v2-attr.stderr
@@ -116,14 +116,6 @@ LL | #[pin_v2]
    |
    = help: `#[pin_v2]` can only be applied to data types
 
-error: `#[pin_v2]` attribute cannot be used on delegations
-  --> $DIR/pin_v2-attr.rs:58:5
-   |
-LL |     #[pin_v2]
-   |     ^^^^^^^^^
-   |
-   = help: `#[pin_v2]` can only be applied to data types
-
 error: `#[pin_v2]` attribute cannot be used on inherent methods
   --> $DIR/pin_v2-attr.rs:61:5
    |
@@ -308,5 +300,13 @@ LL | #[pin_v2]
    |
    = help: `#[pin_v2]` can only be applied to data types
 
+error: `#[pin_v2]` attribute cannot be used on delegations
+  --> $DIR/pin_v2-attr.rs:58:5
+   |
+LL |     #[pin_v2]
+   |     ^^^^^^^^^
+   |
+   = help: `#[pin_v2]` can only be applied to data types
+
 error: aborting due to 39 previous errors
 

From 0486281b303d838694f97d8b35531a20ed0ee1c9 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 20 Mar 2026 09:48:54 +0000
Subject: [PATCH 0690/1059] delete some tests that lost their meaning

---
 tests/ui/structs-enums/export-abstract-tag.rs      | 14 --------------
 tests/ui/structs-enums/export-tag-variant.rs       |  8 --------
 tests/ui/structs-enums/rec-auto.rs                 | 14 --------------
 .../tag-variant-disr-type-mismatch.rs              | 11 -----------
 tests/ui/structs-enums/tuple-struct-trivial.rs     |  7 -------
 5 files changed, 54 deletions(-)
 delete mode 100644 tests/ui/structs-enums/export-abstract-tag.rs
 delete mode 100644 tests/ui/structs-enums/export-tag-variant.rs
 delete mode 100644 tests/ui/structs-enums/rec-auto.rs
 delete mode 100644 tests/ui/structs-enums/tag-variant-disr-type-mismatch.rs
 delete mode 100644 tests/ui/structs-enums/tuple-struct-trivial.rs

diff --git a/tests/ui/structs-enums/export-abstract-tag.rs b/tests/ui/structs-enums/export-abstract-tag.rs
deleted file mode 100644
index e6d359803856..000000000000
--- a/tests/ui/structs-enums/export-abstract-tag.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-#![allow(non_camel_case_types)]
-
-// We can export tags without exporting the variants to create a simple
-// sort of ADT.
-
-
-mod foo {
-    pub enum t { t1, }
-
-    pub fn f() -> t { return t::t1; }
-}
-
-pub fn main() { let _v: foo::t = foo::f(); }
diff --git a/tests/ui/structs-enums/export-tag-variant.rs b/tests/ui/structs-enums/export-tag-variant.rs
deleted file mode 100644
index c6216d1b567b..000000000000
--- a/tests/ui/structs-enums/export-tag-variant.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ run-pass
-#![allow(non_camel_case_types)]
-
-mod foo {
-    pub enum t { t1, }
-}
-
-pub fn main() { let _v = foo::t::t1; }
diff --git a/tests/ui/structs-enums/rec-auto.rs b/tests/ui/structs-enums/rec-auto.rs
deleted file mode 100644
index bf2e37a189bc..000000000000
--- a/tests/ui/structs-enums/rec-auto.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-
-
-
-
-// Issue #50.
-
-struct X { foo: String, bar: String }
-
-pub fn main() {
-    let x = X {foo: "hello".to_string(), bar: "world".to_string()};
-    println!("{}", x.foo.clone());
-    println!("{}", x.bar.clone());
-}
diff --git a/tests/ui/structs-enums/tag-variant-disr-type-mismatch.rs b/tests/ui/structs-enums/tag-variant-disr-type-mismatch.rs
deleted file mode 100644
index f4c202d91a7c..000000000000
--- a/tests/ui/structs-enums/tag-variant-disr-type-mismatch.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
-
-enum color {
-    red = 1,
-    blue = 2,
-}
-
-pub fn main() {}
diff --git a/tests/ui/structs-enums/tuple-struct-trivial.rs b/tests/ui/structs-enums/tuple-struct-trivial.rs
deleted file mode 100644
index e2395036551e..000000000000
--- a/tests/ui/structs-enums/tuple-struct-trivial.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-struct Foo(isize, isize, isize);
-
-pub fn main() {
-}

From 98a14412777fc337178fc4ee6d4b4bb7c9acd85d Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 20 Mar 2026 09:55:22 +0000
Subject: [PATCH 0691/1059] merge several `tuple-struct-*` tests

---
 tests/ui/structs-enums/tuple-struct-construct.rs    |  9 ---------
 .../ui/structs-enums/tuple-struct-destructuring.rs  | 13 +++++++++++++
 tests/ui/structs-enums/tuple-struct-matching.rs     | 13 -------------
 3 files changed, 13 insertions(+), 22 deletions(-)
 delete mode 100644 tests/ui/structs-enums/tuple-struct-construct.rs
 delete mode 100644 tests/ui/structs-enums/tuple-struct-matching.rs

diff --git a/tests/ui/structs-enums/tuple-struct-construct.rs b/tests/ui/structs-enums/tuple-struct-construct.rs
deleted file mode 100644
index 4243bccb4eb7..000000000000
--- a/tests/ui/structs-enums/tuple-struct-construct.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ run-pass
-#[allow(dead_code)]
-#[derive(Debug)]
-struct Foo(isize, isize);
-
-pub fn main() {
-    let x = Foo(1, 2);
-    println!("{:?}", x);
-}
diff --git a/tests/ui/structs-enums/tuple-struct-destructuring.rs b/tests/ui/structs-enums/tuple-struct-destructuring.rs
index 5213052dd7a4..36a36605ba80 100644
--- a/tests/ui/structs-enums/tuple-struct-destructuring.rs
+++ b/tests/ui/structs-enums/tuple-struct-destructuring.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+#[derive(Debug)]
 struct Foo(isize, isize);
 
 pub fn main() {
@@ -7,4 +8,16 @@ pub fn main() {
     println!("{} {}", y, z);
     assert_eq!(y, 1);
     assert_eq!(z, 2);
+
+    let x = Foo(1, 2);
+    match x {
+        Foo(a, b) => {
+            assert_eq!(a, 1);
+            assert_eq!(b, 2);
+            println!("{} {}", a, b);
+        }
+    }
+
+    let x = Foo(1, 2);
+    assert_eq!(format!("{x:?}"), "Foo(1, 2)");
 }
diff --git a/tests/ui/structs-enums/tuple-struct-matching.rs b/tests/ui/structs-enums/tuple-struct-matching.rs
deleted file mode 100644
index a5436624c658..000000000000
--- a/tests/ui/structs-enums/tuple-struct-matching.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-struct Foo(isize, isize);
-
-pub fn main() {
-    let x = Foo(1, 2);
-    match x {
-        Foo(a, b) => {
-            assert_eq!(a, 1);
-            assert_eq!(b, 2);
-            println!("{} {}", a, b);
-        }
-    }
-}

From ff524fdb979cdc916136ed4c98605218cb56cc82 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Fri, 20 Mar 2026 09:59:26 +0000
Subject: [PATCH 0692/1059] move many tests from `run-pass` to `check-pass`

---
 tests/ui/structs-enums/class-dtor.rs                      | 2 +-
 tests/ui/structs-enums/classes-self-referential.rs        | 2 +-
 tests/ui/structs-enums/enum-discrim-range-overflow.rs     | 2 +-
 tests/ui/structs-enums/foreign-struct.rs                  | 2 +-
 tests/ui/structs-enums/namespaced-enum-emulate-flat.rs    | 2 +-
 tests/ui/structs-enums/namespaced-enum-glob-import.rs     | 2 +-
 tests/ui/structs-enums/namespaced-enums.rs                | 2 +-
 tests/ui/structs-enums/nested-enum-same-names.rs          | 2 +-
 tests/ui/structs-enums/newtype-struct-with-dtor.rs        | 2 +-
 tests/ui/structs-enums/simple-generic-tag.rs              | 2 +-
 tests/ui/structs-enums/struct-variant-field-visibility.rs | 2 +-
 tests/ui/structs-enums/tag-in-block.rs                    | 2 +-
 tests/ui/structs-enums/uninstantiable-struct.rs           | 2 +-
 tests/ui/structs-enums/variant-structs-trivial.rs         | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/tests/ui/structs-enums/class-dtor.rs b/tests/ui/structs-enums/class-dtor.rs
index a08f0f0b0a47..b7911823ef1b 100644
--- a/tests/ui/structs-enums/class-dtor.rs
+++ b/tests/ui/structs-enums/class-dtor.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
diff --git a/tests/ui/structs-enums/classes-self-referential.rs b/tests/ui/structs-enums/classes-self-referential.rs
index f819e558aa2e..40c51a1573cd 100644
--- a/tests/ui/structs-enums/classes-self-referential.rs
+++ b/tests/ui/structs-enums/classes-self-referential.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
diff --git a/tests/ui/structs-enums/enum-discrim-range-overflow.rs b/tests/ui/structs-enums/enum-discrim-range-overflow.rs
index 91be8014ebda..641e5566bee3 100644
--- a/tests/ui/structs-enums/enum-discrim-range-overflow.rs
+++ b/tests/ui/structs-enums/enum-discrim-range-overflow.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(overflowing_literals)]
 
 
diff --git a/tests/ui/structs-enums/foreign-struct.rs b/tests/ui/structs-enums/foreign-struct.rs
index f339c191ae80..b710d83350ab 100644
--- a/tests/ui/structs-enums/foreign-struct.rs
+++ b/tests/ui/structs-enums/foreign-struct.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
diff --git a/tests/ui/structs-enums/namespaced-enum-emulate-flat.rs b/tests/ui/structs-enums/namespaced-enum-emulate-flat.rs
index 774cfa1a3808..2bc23d94b4d9 100644
--- a/tests/ui/structs-enums/namespaced-enum-emulate-flat.rs
+++ b/tests/ui/structs-enums/namespaced-enum-emulate-flat.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 pub use Foo::*;
diff --git a/tests/ui/structs-enums/namespaced-enum-glob-import.rs b/tests/ui/structs-enums/namespaced-enum-glob-import.rs
index 82742a934c41..52bfa9d4ab72 100644
--- a/tests/ui/structs-enums/namespaced-enum-glob-import.rs
+++ b/tests/ui/structs-enums/namespaced-enum-glob-import.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 mod m2 {
diff --git a/tests/ui/structs-enums/namespaced-enums.rs b/tests/ui/structs-enums/namespaced-enums.rs
index 3e2e0b5ffa8f..f3f1a3bd44e5 100644
--- a/tests/ui/structs-enums/namespaced-enums.rs
+++ b/tests/ui/structs-enums/namespaced-enums.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 enum Foo {
diff --git a/tests/ui/structs-enums/nested-enum-same-names.rs b/tests/ui/structs-enums/nested-enum-same-names.rs
index 5ff730aff441..1d3fab4e722c 100644
--- a/tests/ui/structs-enums/nested-enum-same-names.rs
+++ b/tests/ui/structs-enums/nested-enum-same-names.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 /*
diff --git a/tests/ui/structs-enums/newtype-struct-with-dtor.rs b/tests/ui/structs-enums/newtype-struct-with-dtor.rs
index 35476c5ed2d6..c0d04932c464 100644
--- a/tests/ui/structs-enums/newtype-struct-with-dtor.rs
+++ b/tests/ui/structs-enums/newtype-struct-with-dtor.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(unused_unsafe)]
 #![allow(unused_variables)]
 
diff --git a/tests/ui/structs-enums/simple-generic-tag.rs b/tests/ui/structs-enums/simple-generic-tag.rs
index b78505edd1f2..dbb5d707b52f 100644
--- a/tests/ui/structs-enums/simple-generic-tag.rs
+++ b/tests/ui/structs-enums/simple-generic-tag.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
diff --git a/tests/ui/structs-enums/struct-variant-field-visibility.rs b/tests/ui/structs-enums/struct-variant-field-visibility.rs
index a6528f9a2b17..40acea956aea 100644
--- a/tests/ui/structs-enums/struct-variant-field-visibility.rs
+++ b/tests/ui/structs-enums/struct-variant-field-visibility.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 mod foo {
diff --git a/tests/ui/structs-enums/tag-in-block.rs b/tests/ui/structs-enums/tag-in-block.rs
index 27b48aae51f6..75691f02dd82 100644
--- a/tests/ui/structs-enums/tag-in-block.rs
+++ b/tests/ui/structs-enums/tag-in-block.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
diff --git a/tests/ui/structs-enums/uninstantiable-struct.rs b/tests/ui/structs-enums/uninstantiable-struct.rs
index 97bc7d8414e7..def0fa00e17c 100644
--- a/tests/ui/structs-enums/uninstantiable-struct.rs
+++ b/tests/ui/structs-enums/uninstantiable-struct.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 pub struct Z(#[allow(dead_code)] &'static Z);
 
 pub fn main() {}
diff --git a/tests/ui/structs-enums/variant-structs-trivial.rs b/tests/ui/structs-enums/variant-structs-trivial.rs
index a7b057511843..c1403b79c8aa 100644
--- a/tests/ui/structs-enums/variant-structs-trivial.rs
+++ b/tests/ui/structs-enums/variant-structs-trivial.rs
@@ -1,4 +1,4 @@
-//@ run-pass
+//@ check-pass
 #![allow(dead_code)]
 
 enum Foo {

From 1111eb599e6ce93acfd854961749bebb3b0664e5 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 09:59:58 +0000
Subject: [PATCH 0693/1059] Update to Cranelift 0.130

---
 Cargo.lock | 100 +++++++++++++++++++++++++++--------------------------
 Cargo.toml |  26 +++++++-------
 src/lib.rs |   3 +-
 3 files changed, 65 insertions(+), 64 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2ceca336f094..2d84d2c57fc6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -28,9 +28,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bumpalo"
-version = "3.19.1"
+version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 dependencies = [
  "allocator-api2",
 ]
@@ -43,45 +43,46 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40630d663279bc855bff805d6f5e8a0b6a1867f9df95b010511ac6dc894e9395"
+checksum = "4f248321c6a7d4de5dcf2939368e96a397ad3f53b6a076e38d0104d1da326d37"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee6aec5ceb55e5fdbcf7ef677d7c7195531360ff181ce39b2b31df11d57305f"
+checksum = "ab6d78ff1f7d9bf8b7e1afbedbf78ba49e38e9da479d4c8a2db094e22f64e2bc"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a92d78cc3f087d7e7073828f08d98c7074a3a062b6b29a1b7783ce74305685e"
+checksum = "6b6005ba640213a5b95382aeaf6b82bf028309581c8d7349778d66f27dc1180b"
 dependencies = [
  "cranelift-entity",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edcc73d756f2e0d7eda6144fe64a2bc69c624de893cb1be51f1442aed77881d2"
+checksum = "81fb5b134a12b559ff0c0f5af0fcd755ad380723b5016c4e0d36f74d39485340"
 dependencies = [
  "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d94c2cd0d73b41369b88da1129589bc3a2d99cf49979af1d14751f35b7a1b"
+checksum = "85837de8be7f17a4034a6b08816f05a3144345d2091937b39d415990daca28f4"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -93,7 +94,7 @@ dependencies = [
  "cranelift-entity",
  "cranelift-isle",
  "gimli",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.1",
  "libm",
  "log",
  "regalloc2",
@@ -106,9 +107,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "235da0e52ee3a0052d0e944c3470ff025b1f4234f6ec4089d3109f2d2ffa6cbd"
+checksum = "e433faa87d38e5b8ff469e44a26fea4f93e58abd7a7c10bad9810056139700c9"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -118,24 +119,24 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20c07c6c440bd1bf920ff7597a1e743ede1f68dcd400730bd6d389effa7662af"
+checksum = "5397ba61976e13944ca71230775db13ee1cb62849701ed35b753f4761ed0a9b7"
 
 [[package]]
 name = "cranelift-control"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8797c022e02521901e1aee483dea3ed3c67f2bf0a26405c9dd48e8ee7a70944b"
+checksum = "cc81c88765580720eb30f4fc2c1bfdb75fcbf3094f87b3cd69cecca79d77a245"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59d8e72637246edd2cba337939850caa8b201f6315925ec4c156fdd089999699"
+checksum = "463feed5d46cf8763f3ba3045284cf706dd161496e20ec9c14afbb4ba09b9e66"
 dependencies = [
  "cranelift-bitset",
  "wasmtime-internal-core",
@@ -143,9 +144,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c31db0085c3dfa131e739c3b26f9f9c84d69a9459627aac1ac4ef8355e3411b"
+checksum = "a4c5eca7696c1c04ab4c7ed8d18eadbb47d6cc9f14ec86fe0881bf1d7e97e261"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -155,15 +156,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524d804c1ebd8c542e6f64e71aa36934cec17c5da4a9ae3799796220317f5d23"
+checksum = "f1153844610cc9c6da8cf10ce205e45da1a585b7688ed558aa808bbe2e4e6d77"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02ca12808d5c1ccf40cb02493a8f1790358f230867fe37735e9af8b76a2262cb"
+checksum = "41836de8321b303d3d4188e58cc09c30c7645337342acfcfb363732695cae098"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -181,9 +182,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d92fca47132ffc3de8783e82a577a2c8aedf85d1e12b92d08863d9af8a76bd4"
+checksum = "b731f66cb1b69b60a74216e632968ebdbb95c488d26aa1448ec226ae0ffec33e"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -192,9 +193,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc9598f02540e382e1772416eba18e93c5275b746adbbf06ac1f3cf149415270"
+checksum = "a97b583fe9a60f06b0464cee6be5a17f623fd91b217aaac99b51b339d19911af"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -203,9 +204,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-object"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38fe79386c13648cf28653b300ba16b797a5be248bf11d3984201a17acbbbde5"
+checksum = "9809d2d419cd18f17377f4ce64a7ad22eeda0d042c08833d3796657f1ddebc82"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -218,9 +219,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.129.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d953932541249c91e3fa70a75ff1e52adc62979a2a8132145d4b9b3e6d1a9b6a"
+checksum = "8594dc6bb4860fa8292f1814c76459dbfb933e1978d8222de6380efce45c7cee"
 
 [[package]]
 name = "crc32fast"
@@ -245,9 +246,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
-version = "0.1.5"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
 name = "gimli"
@@ -266,15 +267,15 @@ name = "hashbrown"
 version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
-dependencies = [
- "foldhash",
-]
 
 [[package]]
 name = "hashbrown"
 version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash",
+]
 
 [[package]]
 name = "heck"
@@ -337,12 +338,12 @@ checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "object"
-version = "0.37.3"
+version = "0.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+checksum = "271638cd5fa9cca89c4c304675ca658efc4e64a66c716b7cfe1afb4b9611dbbc"
 dependencies = [
  "crc32fast",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.1",
  "indexmap",
  "memchr",
 ]
@@ -367,9 +368,9 @@ dependencies = [
 
 [[package]]
 name = "regalloc2"
-version = "0.13.5"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa"
+checksum = "952ddbfc6f9f64d006c3efd8c9851a6ba2f2b944ba94730db255d55006e0ffda"
 dependencies = [
  "allocator-api2",
  "bumpalo",
@@ -481,18 +482,19 @@ checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "wasmtime-internal-core"
-version = "42.0.1"
+version = "43.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03a4a3f055a804a2f3d86e816a9df78a8fa57762212a8506164959224a40cd48"
+checksum = "e671917bb6856ae360cb59d7aaf26f1cfd042c7b924319dd06fd380739fc0b2e"
 dependencies = [
+ "hashbrown 0.16.1",
  "libm",
 ]
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "42.0.1"
+version = "43.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c57d24e8d1334a0e5a8b600286ffefa1fc4c3e8176b110dff6fbc1f43c4a599b"
+checksum = "9b3112806515fac8495883885eb8dbdde849988ae91fe6beb544c0d7c0f4c9aa"
 dependencies = [
  "cfg-if",
  "libc",
diff --git a/Cargo.toml b/Cargo.toml
index bc75092cfb90..6707557f06f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,15 +8,15 @@ crate-type = ["dylib"]
 
 [dependencies]
 # These have to be in sync with each other
-cranelift-codegen = { version = "0.129.0", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
-cranelift-frontend = { version = "0.129.0" }
-cranelift-module = { version = "0.129.0" }
-cranelift-native = { version = "0.129.0" }
-cranelift-jit = { version = "0.129.0", optional = true }
-cranelift-object = { version = "0.129.0" }
+cranelift-codegen = { version = "0.130.0", default-features = false, features = ["std", "timing", "unwind", "all-native-arch"] }
+cranelift-frontend = { version = "0.130.0" }
+cranelift-module = { version = "0.130.0" }
+cranelift-native = { version = "0.130.0" }
+cranelift-jit = { version = "0.130.0", optional = true }
+cranelift-object = { version = "0.130.0" }
 target-lexicon = "0.13"
 gimli = { version = "0.33", default-features = false, features = ["write"] }
-object = { version = "0.37.3", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
+object = { version = "0.38.0", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
 
 indexmap = "2.0.0"
 libloading = { version = "0.9.0", optional = true }
@@ -24,12 +24,12 @@ smallvec = "1.8.1"
 
 [patch.crates-io]
 # Uncomment to use an unreleased version of cranelift
-#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
-#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
-#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
-#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
-#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
-#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-42.0.0" }
+#cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
+#cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
+#cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
+#cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
+#cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
+#cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime.git", branch = "release-43.0.0" }
 
 # Uncomment to use local checkout of cranelift
 #cranelift-codegen = { path = "../wasmtime/cranelift/codegen" }
diff --git a/src/lib.rs b/src/lib.rs
index 9ed882c0dc26..82c2e91b4b0f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -345,8 +345,7 @@ fn build_isa(sess: &Session, jit: bool) -> Arc<dyn TargetIsa + 'static> {
             if target_triple.architecture == target_lexicon::Architecture::X86_64 {
                 // Only set the target cpu on x86_64 as Cranelift is missing
                 // the target cpu list for most other targets.
-                // FIXME remove the replace once bytecodealliance/wasmtime#12792 lands
-                builder.enable(&sess.target.cpu.replace("-", "_")).unwrap();
+                builder.enable(sess.target.cpu.as_ref()).unwrap();
             }
             builder
         }

From 0b69ff5074d87ea671f3c1718f960174e1b03c0b Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:48:36 +0100
Subject: [PATCH 0694/1059] Defer codegen for the VaList Drop impl to actual
 uses

This allows compiling libcore with codegen backends that don't actually
implement VaList like cg_clif.
---
 ...esn-t-get-emitted-unless-VaList-is-a.patch | 25 -------------------
 library/core/src/ffi/va_list.rs               |  1 +
 2 files changed, 1 insertion(+), 25 deletions(-)
 delete mode 100644 compiler/rustc_codegen_cranelift/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch

diff --git a/compiler/rustc_codegen_cranelift/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch b/compiler/rustc_codegen_cranelift/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
deleted file mode 100644
index 2aa93164674f..000000000000
--- a/compiler/rustc_codegen_cranelift/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-From 116abc64add4d617104993a7a3011f20bcf31ef2 Mon Sep 17 00:00:00 2001
-From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
-Date: Mon, 26 Jan 2026 16:20:58 +0000
-Subject: [PATCH] Ensure va_end doesn't get emitted unless VaList is actually
- used
-
----
- library/core/src/ffi/va_list.rs | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
-index d0f1553..75129af 100644
---- a/library/core/src/ffi/va_list.rs
-+++ b/library/core/src/ffi/va_list.rs
-@@ -217,6 +217,7 @@ impl Clone for VaList<'_> {
-
- #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
- impl<'f> const Drop for VaList<'f> {
-+    #[inline]
-     fn drop(&mut self) {
-         // SAFETY: this variable argument list is being dropped, so won't be read from again.
-         unsafe { va_end(self) }
--- 
-2.43.0
-
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index b6dfe3a54184..772b25d02be2 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -256,6 +256,7 @@ fn clone(&self) -> Self {
 
 #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
 impl<'f> const Drop for VaList<'f> {
+    #[inline]
     fn drop(&mut self) {
         // SAFETY: this variable argument list is being dropped, so won't be read from again.
         unsafe { va_end(self) }

From a043e3657488386febb4ef815398ee63d339e5de Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:48:36 +0100
Subject: [PATCH 0695/1059] Defer codegen for the VaList Drop impl to actual
 uses

This allows compiling libcore with codegen backends that don't actually
implement VaList like cg_clif.
---
 ...esn-t-get-emitted-unless-VaList-is-a.patch | 25 -------------------
 1 file changed, 25 deletions(-)
 delete mode 100644 patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch

diff --git a/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch b/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
deleted file mode 100644
index 2aa93164674f..000000000000
--- a/patches/0028-stdlib-Ensure-va_end-doesn-t-get-emitted-unless-VaList-is-a.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-From 116abc64add4d617104993a7a3011f20bcf31ef2 Mon Sep 17 00:00:00 2001
-From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
-Date: Mon, 26 Jan 2026 16:20:58 +0000
-Subject: [PATCH] Ensure va_end doesn't get emitted unless VaList is actually
- used
-
----
- library/core/src/ffi/va_list.rs | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
-index d0f1553..75129af 100644
---- a/library/core/src/ffi/va_list.rs
-+++ b/library/core/src/ffi/va_list.rs
-@@ -217,6 +217,7 @@ impl Clone for VaList<'_> {
-
- #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
- impl<'f> const Drop for VaList<'f> {
-+    #[inline]
-     fn drop(&mut self) {
-         // SAFETY: this variable argument list is being dropped, so won't be read from again.
-         unsafe { va_end(self) }
--- 
-2.43.0
-

From ca1fc35595fa6db04fe84e7c1b44bc0c83465254 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 8 Aug 2025 19:15:14 +0800
Subject: [PATCH 0696/1059] Remove doc comments for generate_trait_from_impl

**Input**:

```rust
struct Foo(f64);

impl F$0oo {
    /// Add `x`
    ///
    /// # Examples
    fn add(&mut self, x: f64) {
        self.0 += x;
    }
}
```

**This PR**:

```rust
struct Foo(f64);

trait NewTrait {
    /// Add `x`
    ///
    /// # Examples
    fn add(&mut self, x: f64);
}

impl NewTrait for Foo {
    fn add(&mut self, x: f64) {
        self.0 += x;
    }
}
```

**Old**:

```rust
struct Foo(f64);

trait NewTrait {
    /// Add `x`
    ///
    /// # Examples
    fn add(&mut self, x: f64);
}

impl NewTrait for Foo {
    /// Add `x`
    ///
    /// # Examples
    fn add(&mut self, x: f64) {
        self.0 += x;
    }
}
```
---
 .../src/handlers/generate_trait_from_impl.rs  | 54 ++++++++++++++++++-
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
index 8bc4d50cf6af..7e858cdc8725 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
@@ -1,8 +1,10 @@
 use crate::assist_context::{AssistContext, Assists};
 use ide_db::assists::AssistId;
 use syntax::{
-    AstNode, SyntaxKind, T,
-    ast::{self, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make},
+    AstNode, AstToken, SyntaxKind, T,
+    ast::{
+        self, HasDocComments, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make,
+    },
     syntax_editor::{Position, SyntaxEditor},
 };
 
@@ -133,6 +135,7 @@ pub(crate) fn generate_trait_from_impl(acc: &mut Assists, ctx: &AssistContext<'_
             let mut editor = builder.make_editor(impl_ast.syntax());
             impl_assoc_items.assoc_items().for_each(|item| {
                 remove_items_visibility(&mut editor, &item);
+                remove_doc_comments(&mut editor, &item);
             });
 
             editor.insert_all(Position::before(impl_name.syntax()), elements);
@@ -175,6 +178,17 @@ fn remove_items_visibility(editor: &mut SyntaxEditor, item: &ast::AssocItem) {
     }
 }
 
+fn remove_doc_comments(editor: &mut SyntaxEditor, item: &ast::AssocItem) {
+    for doc in item.doc_comments() {
+        if let Some(next) = doc.syntax().next_token()
+            && next.kind() == SyntaxKind::WHITESPACE
+        {
+            editor.delete(next);
+        }
+        editor.delete(doc.syntax());
+    }
+}
+
 fn strip_body(editor: &mut SyntaxEditor, item: &ast::AssocItem) {
     if let ast::AssocItem::Fn(f) = item
         && let Some(body) = f.body()
@@ -238,6 +252,42 @@ fn add(&mut self, x: f64) {
         )
     }
 
+    #[test]
+    fn test_remove_doc_comments() {
+        check_assist_no_snippet_cap(
+            generate_trait_from_impl,
+            r#"
+struct Foo(f64);
+
+impl F$0oo {
+    /// Add `x`
+    ///
+    /// # Examples
+    #[cfg(true)]
+    fn add(&mut self, x: f64) {
+        self.0 += x;
+    }
+}"#,
+            r#"
+struct Foo(f64);
+
+trait NewTrait {
+    /// Add `x`
+    ///
+    /// # Examples
+    #[cfg(true)]
+    fn add(&mut self, x: f64);
+}
+
+impl NewTrait for Foo {
+    #[cfg(true)]
+    fn add(&mut self, x: f64) {
+        self.0 += x;
+    }
+}"#,
+        )
+    }
+
     #[test]
     fn test_assoc_item_macro() {
         check_assist_no_snippet_cap(

From 5ef93c12b66c046c629b5d26d2ea666b6d78dc2b Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:43:46 +0100
Subject: [PATCH 0697/1059] Add missing num_internals feature gate to
 coretests/benches

---
 library/coretests/benches/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/coretests/benches/lib.rs b/library/coretests/benches/lib.rs
index 6b65ecaf4edc..e8dc815a7dd0 100644
--- a/library/coretests/benches/lib.rs
+++ b/library/coretests/benches/lib.rs
@@ -8,7 +8,9 @@
 #![feature(iter_array_chunks)]
 #![feature(iter_next_chunk)]
 #![feature(iter_advance_by)]
+#![feature(num_internals)]
 #![feature(uint_gather_scatter_bits)]
+#![allow(internal_features)]
 
 extern crate test;
 

From 5aeb2a6c457d21558317612cde19c81396672287 Mon Sep 17 00:00:00 2001
From: JayanAXHF <sunil.chdry@gmail.com>
Date: Fri, 20 Mar 2026 10:24:53 +0530
Subject: [PATCH 0698/1059] refactor(attribute parser): move check_custom_mir
 to attribute parser

---
 .../src/attributes/prototype.rs               | 50 +++++++++++++++++++
 .../src/session_diagnostics.rs                | 23 +++++++++
 compiler/rustc_passes/src/check_attr.rs       | 48 +-----------------
 compiler/rustc_passes/src/errors.rs           | 23 ---------
 4 files changed, 75 insertions(+), 69 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/prototype.rs b/compiler/rustc_attr_parsing/src/attributes/prototype.rs
index ac50fe33839d..8eb902be34e2 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prototype.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prototype.rs
@@ -9,6 +9,7 @@
 use crate::attributes::SingleAttributeParser;
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
+use crate::session_diagnostics;
 use crate::target_checking::AllowedTargets;
 use crate::target_checking::Policy::Allow;
 
@@ -57,6 +58,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
         let dialect = parse_dialect(cx, dialect, &mut failed);
         let phase = parse_phase(cx, phase, &mut failed);
+        check_custom_mir(cx, dialect, phase, &mut failed);
 
         if failed {
             return None;
@@ -138,3 +140,51 @@ fn parse_phase<S: Stage>(
 
     Some((phase, span))
 }
+
+fn check_custom_mir<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    dialect: Option<(MirDialect, Span)>,
+    phase: Option<(MirPhase, Span)>,
+    failed: &mut bool,
+) {
+    let attr_span = cx.attr_span;
+    let Some((dialect, dialect_span)) = dialect else {
+        if let Some((_, phase_span)) = phase {
+            *failed = true;
+            cx.emit_err(session_diagnostics::CustomMirPhaseRequiresDialect {
+                attr_span,
+                phase_span,
+            });
+        }
+        return;
+    };
+
+    match dialect {
+        MirDialect::Analysis => {
+            if let Some((MirPhase::Optimized, phase_span)) = phase {
+                *failed = true;
+                cx.emit_err(session_diagnostics::CustomMirIncompatibleDialectAndPhase {
+                    dialect,
+                    phase: MirPhase::Optimized,
+                    attr_span,
+                    dialect_span,
+                    phase_span,
+                });
+            }
+        }
+
+        MirDialect::Built => {
+            if let Some((phase, phase_span)) = phase {
+                *failed = true;
+                cx.emit_err(session_diagnostics::CustomMirIncompatibleDialectAndPhase {
+                    dialect,
+                    phase,
+                    attr_span,
+                    dialect_span,
+                    phase_span,
+                });
+            }
+        }
+        MirDialect::Runtime => {}
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 751b8f8646ab..069488948868 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -7,6 +7,7 @@
 };
 use rustc_feature::AttributeTemplate;
 use rustc_hir::AttrPath;
+use rustc_hir::attrs::{MirDialect, MirPhase};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 use rustc_target::spec::TargetTuple;
@@ -1023,3 +1024,25 @@ pub(crate) struct UnsupportedInstructionSet<'a> {
     pub instruction_set: Symbol,
     pub current_target: &'a TargetTuple,
 }
+
+#[derive(Diagnostic)]
+#[diag("`dialect` key required")]
+pub(crate) struct CustomMirPhaseRequiresDialect {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label("`phase` argument requires a `dialect` argument")]
+    pub phase_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("the {$dialect} dialect is not compatible with the {$phase} phase")]
+pub(crate) struct CustomMirIncompatibleDialectAndPhase {
+    pub dialect: MirDialect,
+    pub phase: MirPhase,
+    #[primary_span]
+    pub attr_span: Span,
+    #[label("this dialect...")]
+    pub dialect_span: Span,
+    #[label("... is not compatible with this phase")]
+    pub phase_span: Span,
+}
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index bec6ab7e8355..a69ff252945c 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -23,7 +23,7 @@
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_hir::attrs::{
     AttributeKind, DocAttribute, DocInline, EiiDecl, EiiImpl, EiiImplResolution, InlineAttr,
-    MirDialect, MirPhase, ReprAttr, SanitizerSet,
+    ReprAttr, SanitizerSet,
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
@@ -208,9 +208,6 @@ fn check_attributes(
                 Attribute::Parsed(AttributeKind::MayDangle(attr_span)) => {
                     self.check_may_dangle(hir_id, *attr_span)
                 }
-                &Attribute::Parsed(AttributeKind::CustomMir(dialect, phase, attr_span)) => {
-                    self.check_custom_mir(dialect, phase, attr_span)
-                }
                 &Attribute::Parsed(AttributeKind::Sanitize { on_set, off_set, rtsan: _, span: attr_span}) => {
                     self.check_sanitize(attr_span, on_set | off_set, span, target);
                 },
@@ -247,6 +244,7 @@ fn check_attributes(
                     | AttributeKind::Coverage (..)
                     | AttributeKind::CrateName { .. }
                     | AttributeKind::CrateType(..)
+                    | AttributeKind::CustomMir(..)
                     | AttributeKind::DebuggerVisualizer(..)
                     | AttributeKind::DefaultLibAllocator
                     // `#[doc]` is actually a lot more than just doc comments, so is checked below
@@ -1856,48 +1854,6 @@ fn check_const_continue(&self, hir_id: HirId, attr_span: Span, target: Target) {
             self.dcx().emit_err(errors::ConstContinueAttr { attr_span, node_span });
         };
     }
-
-    fn check_custom_mir(
-        &self,
-        dialect: Option<(MirDialect, Span)>,
-        phase: Option<(MirPhase, Span)>,
-        attr_span: Span,
-    ) {
-        let Some((dialect, dialect_span)) = dialect else {
-            if let Some((_, phase_span)) = phase {
-                self.dcx()
-                    .emit_err(errors::CustomMirPhaseRequiresDialect { attr_span, phase_span });
-            }
-            return;
-        };
-
-        match dialect {
-            MirDialect::Analysis => {
-                if let Some((MirPhase::Optimized, phase_span)) = phase {
-                    self.dcx().emit_err(errors::CustomMirIncompatibleDialectAndPhase {
-                        dialect,
-                        phase: MirPhase::Optimized,
-                        attr_span,
-                        dialect_span,
-                        phase_span,
-                    });
-                }
-            }
-
-            MirDialect::Built => {
-                if let Some((phase, phase_span)) = phase {
-                    self.dcx().emit_err(errors::CustomMirIncompatibleDialectAndPhase {
-                        dialect,
-                        phase,
-                        attr_span,
-                        dialect_span,
-                        phase_span,
-                    });
-                }
-            }
-            MirDialect::Runtime => {}
-        }
-    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 228f21c81b94..b581c65de74a 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -7,7 +7,6 @@
     MultiSpan, msg,
 };
 use rustc_hir::Target;
-use rustc_hir::attrs::{MirDialect, MirPhase};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::{MainDefinition, Ty};
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
@@ -1274,28 +1273,6 @@ pub(crate) struct ReprAlignShouldBeAlignStatic {
     pub item: &'static str,
 }
 
-#[derive(Diagnostic)]
-#[diag("`dialect` key required")]
-pub(crate) struct CustomMirPhaseRequiresDialect {
-    #[primary_span]
-    pub attr_span: Span,
-    #[label("`phase` argument requires a `dialect` argument")]
-    pub phase_span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag("the {$dialect} dialect is not compatible with the {$phase} phase")]
-pub(crate) struct CustomMirIncompatibleDialectAndPhase {
-    pub dialect: MirDialect,
-    pub phase: MirPhase,
-    #[primary_span]
-    pub attr_span: Span,
-    #[label("this dialect...")]
-    pub dialect_span: Span,
-    #[label("... is not compatible with this phase")]
-    pub phase_span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("`eii_macro_for` is only valid on functions")]
 pub(crate) struct EiiImplNotFunction {

From c01af5a28553dac98e31104567e7852fe2de1a33 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 22:27:56 +0800
Subject: [PATCH 0699/1059] Add `ops::AddAssign` implement for IndentLevel

---
 .../crates/ide-assists/src/handlers/unwrap_tuple.rs         | 2 +-
 .../ide-diagnostics/src/handlers/remove_unnecessary_else.rs | 2 +-
 src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs       | 6 ++++++
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
index 2345075a52be..e03274bbb3c9 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_tuple.rs
@@ -33,7 +33,7 @@ pub(crate) fn unwrap_tuple(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
     let (ty, init, prefix, suffix) = match &let_stmt {
         Either::Left(let_stmt) => (let_stmt.ty(), let_stmt.initializer()?, "", ";"),
         Either::Right(let_expr) => {
-            indent_level = indent_level + 1;
+            indent_level += 1;
             (None, let_expr.expr()?, "&& ", "")
         }
     };
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/remove_unnecessary_else.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/remove_unnecessary_else.rs
index 7dc5b5b45e5f..04f48ae3db17 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/remove_unnecessary_else.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/remove_unnecessary_else.rs
@@ -48,7 +48,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &RemoveUnnecessaryElse) -> Option<Vec<
     let mut indent = IndentLevel::from_node(if_expr.syntax());
     let has_parent_if_expr = if_expr.syntax().parent().and_then(ast::IfExpr::cast).is_some();
     if has_parent_if_expr {
-        indent = indent + 1;
+        indent += 1;
     }
     let else_replacement = match if_expr.else_branch()? {
         ast::ElseBranch::Block(block) => block
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
index 9b30642fe4b0..194d06900a48 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
@@ -43,6 +43,12 @@ fn add(self, rhs: u8) -> IndentLevel {
     }
 }
 
+impl ops::AddAssign<u8> for IndentLevel {
+    fn add_assign(&mut self, rhs: u8) {
+        self.0 += rhs;
+    }
+}
+
 impl IndentLevel {
     pub fn single() -> IndentLevel {
         IndentLevel(0)

From 43eb70ac97ade51b755ccb524c5a77a20116b9e1 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 20 Mar 2026 12:30:02 +0100
Subject: [PATCH 0700/1059] vec::Drain::fill: avoid reference to uninitialized
 memory

---
 library/alloc/src/vec/splice.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs
index 3eb8ca44a9d1..99ebcb4ada29 100644
--- a/library/alloc/src/vec/splice.rs
+++ b/library/alloc/src/vec/splice.rs
@@ -1,4 +1,4 @@
-use core::{ptr, slice};
+use core::ptr;
 
 use super::{Drain, Vec};
 use crate::alloc::{Allocator, Global};
@@ -107,15 +107,13 @@ unsafe fn fill<I: Iterator<Item = T>>(&mut self, replace_with: &mut I) -> bool {
         let vec = unsafe { self.vec.as_mut() };
         let range_start = vec.len;
         let range_end = self.tail_start;
-        let range_slice = unsafe {
-            slice::from_raw_parts_mut(vec.as_mut_ptr().add(range_start), range_end - range_start)
-        };
+        // The elements in this range are not initialized so we avoid creating a slice.
 
-        for place in range_slice {
+        for idx in range_start..range_end {
             let Some(new_item) = replace_with.next() else {
                 return false;
             };
-            unsafe { ptr::write(place, new_item) };
+            unsafe { vec.as_mut_ptr().add(idx).write(new_item) };
             vec.len += 1;
         }
         true

From 910d0d7a7779ee7e620ec420f0a324b99f0d3c7a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:37:33 +0100
Subject: [PATCH 0701/1059] Fix calling custom call conv functions from inline
 asm

---
 example/std_example.rs | 18 ++++++++++++++++++
 src/inline_asm.rs      | 39 +++++++++++++++++++++++++--------------
 2 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/example/std_example.rs b/example/std_example.rs
index 360fb76a6224..f0e38ae0610c 100644
--- a/example/std_example.rs
+++ b/example/std_example.rs
@@ -167,6 +167,9 @@ enum Never {}
 
     rust_call_abi();
 
+    // #[cfg(target_arch = "x86_64")]
+    // inline_asm_call_custom_abi();
+
     const fn no_str() -> Option<Box<str>> {
         None
     }
@@ -678,3 +681,18 @@ fn map(a: Option<(u8, Box<Instruction>)>) -> Option<Box<Instruction>> {
         Some((_, instr)) => Some(instr),
     }
 }
+
+// FIXME enable once inline asm sym references are stabilized in cg_clif
+// #[cfg(target_arch = "x86_64")]
+// fn inline_asm_call_custom_abi() {
+//     use std::arch::{asm, naked_asm};
+//
+//     #[unsafe(naked)]
+//     unsafe extern "custom" fn double() {
+//         naked_asm!("add rax, rax", "ret");
+//     }
+//
+//     let mut x: u64 = 21;
+//     unsafe { asm!("call {}", sym double, inout("rax") x) };
+//     assert_eq!(x, 42);
+// }
diff --git a/src/inline_asm.rs b/src/inline_asm.rs
index 044243f2c716..8100d565b397 100644
--- a/src/inline_asm.rs
+++ b/src/inline_asm.rs
@@ -3,8 +3,10 @@
 use std::fmt::Write;
 
 use cranelift_codegen::isa::CallConv;
+use rustc_abi::CanonAbi;
 use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_hir::LangItem;
+use rustc_middle::ty::layout::FnAbiOf;
 use rustc_span::sym;
 use rustc_target::asm::*;
 use rustc_target::spec::Arch;
@@ -120,21 +122,30 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
                     .unwrap();
                     let symbol = fx.tcx.symbol_name(instance);
 
-                    // Pass a wrapper rather than the function itself as the function itself may not
-                    // be exported from the main codegen unit and may thus be unreachable from the
-                    // object file created by an external assembler.
-                    let wrapper_name = format!(
-                        "{}__inline_asm_{}_wrapper_n{}",
-                        fx.symbol_name,
-                        fx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
-                        fx.inline_asm_index,
-                    );
-                    fx.inline_asm_index += 1;
-                    let sig =
-                        get_function_sig(fx.tcx, fx.target_config.default_call_conv, instance);
-                    create_wrapper_function(fx.module, sig, &wrapper_name, symbol.name);
+                    if FullyMonomorphizedLayoutCx(fx.tcx)
+                        .fn_abi_of_instance(instance, ty::List::empty())
+                        .conv
+                        == CanonAbi::Custom
+                    {
+                        // We can't create a wrapper for custom ABI functions.
+                        CInlineAsmOperand::Symbol { symbol: symbol.name.to_owned() }
+                    } else {
+                        // Pass a wrapper rather than the function itself as the function itself may not
+                        // be exported from the main codegen unit and may thus be unreachable from the
+                        // object file created by an external assembler.
+                        let wrapper_name = format!(
+                            "{}__inline_asm_{}_wrapper_n{}",
+                            fx.symbol_name,
+                            fx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
+                            fx.inline_asm_index,
+                        );
+                        fx.inline_asm_index += 1;
+                        let sig =
+                            get_function_sig(fx.tcx, fx.target_config.default_call_conv, instance);
+                        create_wrapper_function(fx.module, sig, &wrapper_name, symbol.name);
 
-                    CInlineAsmOperand::Symbol { symbol: wrapper_name }
+                        CInlineAsmOperand::Symbol { symbol: wrapper_name }
+                    }
                 } else {
                     span_bug!(span, "invalid type for asm sym (fn)");
                 }

From d665c0b3718dc582189a85dc1d49e641d22e9e21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 9 Feb 2026 12:44:14 +0100
Subject: [PATCH 0702/1059] address review

---
 .../src/infer/relate/generalize.rs            | 72 ++++++++++++++-----
 compiler/rustc_middle/src/hooks/mod.rs        |  7 +-
 compiler/rustc_trait_selection/src/solve.rs   |  6 +-
 tests/ui/impl-trait/unsized_coercion.rs       |  3 +-
 4 files changed, 65 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index f3843c371e2c..b2d591327fea 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -355,13 +355,51 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
     }
 }
 
+/// This state determines how generalization treats aliases.
+///
+/// Based on which state we're in, we treat them either as rigid or normalizable,
+/// which might change depending on what types the generalization visitor encounters.
+/// See `handle_alias_ty` for the logic of how we change states.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 enum GeneralizerState {
     /// Treat aliases as potentially normalizable.
+    ///
+    /// This is the default state that generalization starts in, unless we're
+    /// treating aliases as rigid. It also means we're not currently inside an
+    /// alias, since then we change the state to `IncompletelyRelateAliasArgs`.
     Default,
-    IncompletelyRelateHigherRankedAlias,
-    /// Only one layer
+    /// We enter this state when we're generalizing the arguments of a
+    /// potentially normalizeable alias.
+    ///
+    /// The behavior here is different between the old and the new solver:
+    ///
+    /// In the old solver, the difference between this and `Default` is needed to
+    /// correctly handle `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. That
+    /// equality can hold by either normalizing the outer or the inner
+    /// associated type. In the old solver, we always structurally relate
+    /// aliases. If we we encounter an occurs check failure, we propagate the
+    /// failure to the outermost alias, for which we then emit a `Projection`
+    /// goal instead.
+    ///
+    /// In the new solver, we rarely get into this state.
+    /// When we encounter aliases we instead attempt to normalize them, and treat
+    /// them as rigid using `ShallowStructurallyRelate`. Only when an alias has
+    /// escaping bound variables do we continue with similar logic to the old
+    /// solver, except now we also explicitly relate the type and consts in the
+    /// arguments of aliases while in this mode.
+    ///
+    /// FIXME: Because we relate the type and consts in the arguments of aliases
+    ///        while in this mode, this is incomplete.
+    IncompletelyRelateAliasArgs,
+    /// During generalization, when we encounter aliases, we will first attempt
+    /// to normalize them when we're using the next trait solver. We can now
+    /// treat the normalized alias as rigid, but only for "one layer", hence
+    /// shallow. New aliases encountered inside the arguments of the outer alias
+    /// should once again be related as normal.
     ShallowStructurallyRelateAliases,
+    /// Treat aliases as rigid when relating them.
+    ///
+    /// This corresponds to `relation.structurally_relate_aliases()`.
     StructurallyRelateAliases,
 }
 
@@ -400,11 +438,10 @@ struct Generalizer<'me, 'tcx> {
     /// some other type. What will be the variance at this point?
     ambient_variance: ty::Variance,
 
-    /// This is set once we're generalizing the arguments of an alias.
+    /// This field keeps track of how we treat aliases during generalization.
     ///
-    /// This is necessary to correctly handle
-    /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
-    /// hold by either normalizing the outer or the inner associated type.
+    /// Refer to [`GeneralizerState`]'s docs for more information about the
+    /// all the possible values this can have, and when we use which.
     state: GeneralizerState,
 
     cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizerState), Ty<'tcx>>,
@@ -483,11 +520,11 @@ fn handle_alias_ty(
 
                 return res;
             }
-            GeneralizerState::Default | GeneralizerState::IncompletelyRelateHigherRankedAlias => {}
+            GeneralizerState::Default | GeneralizerState::IncompletelyRelateAliasArgs => {}
         }
 
         let previous_state =
-            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateHigherRankedAlias);
+            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateAliasArgs);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
             Err(e) => match previous_state {
@@ -504,7 +541,7 @@ fn handle_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-                GeneralizerState::IncompletelyRelateHigherRankedAlias => return Err(e),
+                GeneralizerState::IncompletelyRelateAliasArgs => return Err(e),
 
                 // Early return.
                 GeneralizerState::ShallowStructurallyRelateAliases
@@ -613,6 +650,7 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                             // of each other. This is currently only used for diagnostics.
                             // To see why, see the docs in the `type_variables` module.
                             inner.type_variables().sub_unify(vid, new_var_id);
+
                             // If we're in the new solver and create a new inference
                             // variable inside of an alias we eagerly constrain that
                             // inference variable to prevent unexpected ambiguity errors.
@@ -632,13 +670,13 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    GeneralizerState::IncompletelyRelateAliasArgs => {
                                         inner.type_variables().equate(vid, new_var_id);
                                     }
+                                    GeneralizerState::Default
+                                    | GeneralizerState::ShallowStructurallyRelateAliases
+                                    | GeneralizerState::StructurallyRelateAliases => {}
                                 }
-                                GeneralizerState::Default
-                                | GeneralizerState::ShallowStructurallyRelateAliases
-                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
 
                             debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
@@ -765,13 +803,13 @@ fn consts(
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    GeneralizerState::IncompletelyRelateAliasArgs => {
                                         variable_table.union(vid, new_var_id);
                                     }
+                                    GeneralizerState::Default
+                                    | GeneralizerState::ShallowStructurallyRelateAliases
+                                    | GeneralizerState::StructurallyRelateAliases => {}
                                 }
-                                GeneralizerState::Default
-                                | GeneralizerState::ShallowStructurallyRelateAliases
-                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
                             Ok(ty::Const::new_var(self.cx(), new_var_id))
                         }
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index c09d9fc2d468..044a9c3ef165 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -132,7 +132,12 @@ fn clone(&self) -> Self { *self }
     ) -> Ty<'tcx>;
 }
 
-// `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
+/// The `try_eagerly_normalize_alias` hook passes an `Infcx` from where it's called (in `rustc_infer`)
+/// to where it's provided (in `rustc_trait_selection`).
+/// Both of those crates have that type available, but `rustc_middle` does not.
+/// Instead we pass this type-erased `Infcx` and transmute on both sides.
+///
+/// Has to be `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
 #[repr(transparent)]
 pub struct TypeErasedInfcx<'a, 'tcx> {
     _infcx: *const (),
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index 118bd8c81b1e..c7699f31a0f9 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -56,8 +56,7 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     let cause = ObligationCause::dummy_with_span(span);
     let obligation = Obligation::new(
         tcx,
-        // we ignore the error anyway
-        ObligationCause::dummy_with_span(span),
+        cause,
         param_env,
         ty::PredicateKind::AliasRelate(
             alias.to_ty(tcx).into(),
@@ -68,7 +67,8 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
 
     ocx.register_obligation(obligation);
 
-    // This only tries to eagerly resolve, if it errors we don't care.
+    // We only use this to constrain inference variables.
+    // We don't care if it errors.
     let _ = ocx.try_evaluate_obligations();
 
     infcx.resolve_vars_if_possible(infer_term)
diff --git a/tests/ui/impl-trait/unsized_coercion.rs b/tests/ui/impl-trait/unsized_coercion.rs
index 6a9a53903fed..f77f2198be0e 100644
--- a/tests/ui/impl-trait/unsized_coercion.rs
+++ b/tests/ui/impl-trait/unsized_coercion.rs
@@ -3,8 +3,7 @@
 
 //@ revisions: next old
 //@[next] compile-flags: -Znext-solver
-//@[old] check-pass
-//@[next] check-pass
+//@ check-pass
 
 trait Trait {}
 

From 18a28f04f26b186ad7868bd7c734685211e3cb0c Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 14:13:31 +0100
Subject: [PATCH 0703/1059] Update to actions/checkout@v6

---
 .github/workflows/abi-cafe.yml |  2 +-
 .github/workflows/main.yml     | 14 +++++++-------
 .github/workflows/rustc.yml    |  4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/abi-cafe.yml b/.github/workflows/abi-cafe.yml
index 3367562f2683..0abc0c6677da 100644
--- a/.github/workflows/abi-cafe.yml
+++ b/.github/workflows/abi-cafe.yml
@@ -43,7 +43,7 @@ jobs:
           #    TARGET_TRIPLE: x86_64-pc-windows-gnu
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       if: matrix.os == 'ubuntu-latest'
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 8acaa42d68bf..b62e3b76db35 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -24,7 +24,7 @@ jobs:
     timeout-minutes: 10
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Check todo
       run: ./y.sh check-todo
@@ -34,7 +34,7 @@ jobs:
     timeout-minutes: 10
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Avoid installing rustc-dev
       run: |
@@ -88,7 +88,7 @@ jobs:
               TARGET_TRIPLE: x86_64-pc-windows-gnu
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       if: matrix.os == 'ubuntu-latest'
@@ -137,7 +137,7 @@ jobs:
     timeout-minutes: 60
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       run: cat /proc/cpuinfo
@@ -159,7 +159,7 @@ jobs:
     timeout-minutes: 60
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       run: cat /proc/cpuinfo
@@ -211,7 +211,7 @@ jobs:
               TARGET_TRIPLE: x86_64-pc-windows-gnu
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Cache cargo target dir
       uses: actions/cache@v4
@@ -252,7 +252,7 @@ jobs:
       cancel-in-progress: true
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Download all built artifacts
         uses: actions/download-artifact@v4
diff --git a/.github/workflows/rustc.yml b/.github/workflows/rustc.yml
index b22725fdc9d4..bb5851d522f0 100644
--- a/.github/workflows/rustc.yml
+++ b/.github/workflows/rustc.yml
@@ -11,7 +11,7 @@ jobs:
     timeout-minutes: 60
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       run: cat /proc/cpuinfo
@@ -31,7 +31,7 @@ jobs:
     timeout-minutes: 60
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: CPU features
       run: cat /proc/cpuinfo

From 4ff5ba2393058003fe589c288a7ab14713460f8c Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 14:15:49 +0100
Subject: [PATCH 0704/1059] Update to actions/cache@v5 and
 actions/upload-artifact@v6

---
 .github/workflows/abi-cafe.yml | 2 +-
 .github/workflows/main.yml     | 8 ++++----
 .github/workflows/rustc.yml    | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/abi-cafe.yml b/.github/workflows/abi-cafe.yml
index 0abc0c6677da..c11fc5921ef1 100644
--- a/.github/workflows/abi-cafe.yml
+++ b/.github/workflows/abi-cafe.yml
@@ -56,7 +56,7 @@ jobs:
       run: .github/scripts/free-disk-space.sh
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-${{ matrix.env.TARGET_TRIPLE }}-cargo-build-target-${{ hashFiles('rust-toolchain', '**/Cargo.lock') }}
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b62e3b76db35..7f9fd0cc7c5e 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -95,7 +95,7 @@ jobs:
       run: cat /proc/cpuinfo
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-${{ matrix.env.TARGET_TRIPLE }}-cargo-build-target-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}
@@ -165,7 +165,7 @@ jobs:
       run: cat /proc/cpuinfo
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-x86_64-unknown-linux-gnu-cargo-build-target-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}
@@ -214,7 +214,7 @@ jobs:
     - uses: actions/checkout@v6
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-${{ matrix.env.TARGET_TRIPLE }}-dist-cargo-build-target-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}
@@ -233,7 +233,7 @@ jobs:
       run: tar cvfJ cg_clif.tar.xz dist
 
     - name: Upload prebuilt cg_clif
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cg_clif-${{ matrix.env.TARGET_TRIPLE }}
         path: cg_clif.tar.xz
diff --git a/.github/workflows/rustc.yml b/.github/workflows/rustc.yml
index bb5851d522f0..0f91bc11753e 100644
--- a/.github/workflows/rustc.yml
+++ b/.github/workflows/rustc.yml
@@ -17,7 +17,7 @@ jobs:
       run: cat /proc/cpuinfo
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-rustc-test-cargo-build-target-${{ hashFiles('rust-toolchain.toml', 'Cargo.lock') }}
@@ -37,7 +37,7 @@ jobs:
       run: cat /proc/cpuinfo
 
     - name: Cache cargo target dir
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: build/cg_clif
         key: ${{ runner.os }}-rustc-test-cargo-build-target-${{ hashFiles('rust-toolchain.toml', 'Cargo.lock') }}

From eee8bddebebf8058557b4417e065220fcc5c651b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 24 Jul 2025 15:36:53 +0800
Subject: [PATCH 0705/1059] Add auto trait name for generate_trait_from_impl

Auto generate trait name from first method.

Input:

```rust
impl S$0 {
    fn foo() {}
}
```

Old output:

```rust
trait NewTrait {
    fn foo();
}

impl NewTrait for S {
    fn foo() {}
}
```

This PR output:

```rust
trait Foo {
    fn foo();
}

impl Foo for S {
    fn foo() {}
}
```
---
 .../src/handlers/generate_trait_from_impl.rs  | 30 ++++++++++++-------
 .../crates/ide-assists/src/tests/generated.rs |  4 +--
 2 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
index 7e858cdc8725..9a8f3c6d8879 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
@@ -47,7 +47,7 @@
 //     };
 // }
 //
-// trait ${0:NewTrait}<const N: usize> {
+// trait ${0:Create}<const N: usize> {
 //     // Used as an associated constant.
 //     const CONST_ASSOC: usize = N * 4;
 //
@@ -56,7 +56,7 @@
 //     const_maker! {i32, 7}
 // }
 //
-// impl<const N: usize> ${0:NewTrait}<N> for Foo<N> {
+// impl<const N: usize> ${0:Create}<N> for Foo<N> {
 //     // Used as an associated constant.
 //     const CONST_ASSOC: usize = N * 4;
 //
@@ -109,7 +109,7 @@ pub(crate) fn generate_trait_from_impl(acc: &mut Assists, ctx: &AssistContext<'_
             };
             let trait_ast = make::trait_(
                 false,
-                "NewTrait",
+                &trait_name(&impl_assoc_items).text(),
                 impl_ast.generic_param_list(),
                 impl_ast.where_clause(),
                 trait_items,
@@ -163,6 +163,14 @@ pub(crate) fn generate_trait_from_impl(acc: &mut Assists, ctx: &AssistContext<'_
     Some(())
 }
 
+fn trait_name(items: &ast::AssocItemList) -> ast::Name {
+    items
+        .assoc_items()
+        .find_map(|x| if let ast::AssocItem::Fn(f) = x { f.name() } else { None })
+        .map(|name| make::name(&stdx::to_camel_case(&name.text())))
+        .unwrap_or_else(|| make::name("NewTrait"))
+}
+
 /// `E0449` Trait items always share the visibility of their trait
 fn remove_items_visibility(editor: &mut SyntaxEditor, item: &ast::AssocItem) {
     if let Some(has_vis) = ast::AnyHasVisibility::cast(item.syntax().clone()) {
@@ -240,11 +248,11 @@ fn add(&mut self, x: f64) {
             r#"
 struct Foo(f64);
 
-trait NewTrait {
+trait Add {
     fn add(&mut self, x: f64);
 }
 
-impl NewTrait for Foo {
+impl Add for Foo {
     fn add(&mut self, x: f64) {
         self.0 += x;
     }
@@ -271,7 +279,7 @@ fn add(&mut self, x: f64) {
             r#"
 struct Foo(f64);
 
-trait NewTrait {
+trait Add {
     /// Add `x`
     ///
     /// # Examples
@@ -279,7 +287,7 @@ trait NewTrait {
     fn add(&mut self, x: f64);
 }
 
-impl NewTrait for Foo {
+impl Add for Foo {
     #[cfg(true)]
     fn add(&mut self, x: f64) {
         self.0 += x;
@@ -389,11 +397,11 @@ pub fn a_func() -> Option<()> {
             r#"
 struct Foo;
 
-trait NewTrait {
+trait AFunc {
     fn a_func() -> Option<()>;
 }
 
-impl NewTrait for Foo {
+impl AFunc for Foo {
     fn a_func() -> Option<()> {
         Some(())
     }
@@ -423,11 +431,11 @@ fn foo() {}
 }"#,
             r#"
 mod a {
-    trait NewTrait {
+    trait Foo {
         fn foo();
     }
 
-    impl NewTrait for S {
+    impl Foo for S {
         fn foo() {}
     }
 }"#,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
index 30405090002a..8ba46799d5ab 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
@@ -2282,7 +2282,7 @@ macro_rules! const_maker {
     };
 }
 
-trait ${0:NewTrait}<const N: usize> {
+trait ${0:Create}<const N: usize> {
     // Used as an associated constant.
     const CONST_ASSOC: usize = N * 4;
 
@@ -2291,7 +2291,7 @@ trait ${0:NewTrait}<const N: usize> {
     const_maker! {i32, 7}
 }
 
-impl<const N: usize> ${0:NewTrait}<N> for Foo<N> {
+impl<const N: usize> ${0:Create}<N> for Foo<N> {
     // Used as an associated constant.
     const CONST_ASSOC: usize = N * 4;
 

From a307600f53ce040052b6c1162092be8c98c21798 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 20 Mar 2026 21:15:05 +0800
Subject: [PATCH 0706/1059] Do not suggest trait name on multi fn

---
 .../src/handlers/generate_trait_from_impl.rs  | 32 +++++++++++++++++--
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
index 9a8f3c6d8879..1286abe3565e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
@@ -164,10 +164,14 @@ pub(crate) fn generate_trait_from_impl(acc: &mut Assists, ctx: &AssistContext<'_
 }
 
 fn trait_name(items: &ast::AssocItemList) -> ast::Name {
-    items
+    let mut fn_names = items
         .assoc_items()
-        .find_map(|x| if let ast::AssocItem::Fn(f) = x { f.name() } else { None })
-        .map(|name| make::name(&stdx::to_camel_case(&name.text())))
+        .filter_map(|x| if let ast::AssocItem::Fn(f) = x { f.name() } else { None });
+    fn_names
+        .next()
+        .and_then(|name| {
+            fn_names.next().is_none().then(|| make::name(&stdx::to_camel_case(&name.text())))
+        })
         .unwrap_or_else(|| make::name("NewTrait"))
 }
 
@@ -442,6 +446,28 @@ fn foo() {}
         )
     }
 
+    #[test]
+    fn test_multi_fn_impl_not_suggest_trait_name() {
+        check_assist_no_snippet_cap(
+            generate_trait_from_impl,
+            r#"
+impl S$0 {
+    fn foo() {}
+    fn bar() {}
+}"#,
+            r#"
+trait NewTrait {
+    fn foo();
+    fn bar();
+}
+
+impl NewTrait for S {
+    fn foo() {}
+    fn bar() {}
+}"#,
+        )
+    }
+
     #[test]
     fn test_snippet_cap_is_some() {
         check_assist(

From 8ad9f06106a80ef6249e4f7b2990544bdf829e1d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 20 Mar 2026 14:55:26 +0100
Subject: [PATCH 0707/1059] Rustup to rustc 1.96.0-nightly (bcf3d36c9
 2026-03-19)

---
 ...0-sysroot_tests-Add-missing-feature-gate.patch | 15 +--------------
 rust-toolchain.toml                               |  2 +-
 2 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/patches/0030-sysroot_tests-Add-missing-feature-gate.patch b/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
index f2985f4f83d9..e4f1b0474afe 100644
--- a/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
+++ b/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
@@ -5,8 +5,7 @@ Subject: [PATCH] Add missing feature gate
 
 ---
  coretests/benches/lib.rs | 1 +
- coretests/tests/lib.rs   | 1 +
- 2 file changed, 2 insertion(+)
+ 1 file changed, 1 insertion(+)
 
 diff --git a/coretests/benches/lib.rs b/coretests/benches/lib.rs
 index 150b9b3..281aa75 100644
@@ -20,18 +19,6 @@ index 150b9b3..281aa75 100644
  #![feature(uint_gather_scatter_bits)]
  
  extern crate test;
-diff --git a/coretests/tests/lib.rs b/coretests/tests/lib.rs
-index ecdb687..ab2cf77 100644
---- a/coretests/tests/lib.rs
-+++ b/coretests/tests/lib.rs
-@@ -88,6 +88,7 @@
- #![feature(non_exhaustive_omitted_patterns_lint)]
- #![feature(nonzero_from_str_radix)]
- #![feature(numfmt)]
-+#![feature(num_internals)]
- #![feature(one_sided_range)]
- #![feature(panic_internals)]
- #![feature(pattern)]
 -- 
 2.43.0
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index aa338e8a8c75..a531c60a45a5 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-17"
+channel = "nightly-2026-03-20"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 9dfdb6b4bc42e5f1ddd2d94108a8ea6fdf07d416 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 20 Mar 2026 15:53:58 +0100
Subject: [PATCH 0708/1059] test copy_specializes_from_vecdeque: reduce
 iteration count for Miri

---
 library/std/src/io/copy/tests.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/library/std/src/io/copy/tests.rs b/library/std/src/io/copy/tests.rs
index 25b1ece2745b..7bdba3a04416 100644
--- a/library/std/src/io/copy/tests.rs
+++ b/library/std/src/io/copy/tests.rs
@@ -97,16 +97,17 @@ fn copy_specializes_to_vec() {
 
 #[test]
 fn copy_specializes_from_vecdeque() {
-    let mut source = VecDeque::with_capacity(100 * 1024);
-    for _ in 0..20 * 1024 {
+    let num: usize = if cfg!(miri) { 512 } else { 20 * 1024 };
+    let mut source = VecDeque::with_capacity(4 * num);
+    for _ in 0..num {
         source.push_front(0);
     }
-    for _ in 0..20 * 1024 {
+    for _ in 0..num {
         source.push_back(0);
     }
     let mut sink = WriteObserver { observed_buffer: 0 };
-    assert_eq!(40 * 1024u64, io::copy(&mut source, &mut sink).unwrap());
-    assert_eq!(20 * 1024, sink.observed_buffer);
+    assert_eq!(2 * num as u64, io::copy(&mut source, &mut sink).unwrap());
+    assert_eq!(num, sink.observed_buffer);
 }
 
 #[test]

From 9c591c65086679d22639504d7d0c0623564cfd7a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 20 Mar 2026 00:40:47 +0100
Subject: [PATCH 0709/1059] Start migrating `DecorateDiagCompat::Builtin` items
 to `DecorateDiagCompat::Dynamic`

---
 compiler/rustc_errors/src/decorate_diag.rs   | 21 ++++++++++++++++++++
 compiler/rustc_errors/src/lib.rs             |  2 +-
 compiler/rustc_lint/src/early/diagnostics.rs |  7 -------
 compiler/rustc_lint/src/lints.rs             | 18 -----------------
 compiler/rustc_lint_defs/src/lib.rs          |  1 -
 compiler/rustc_parse/src/errors.rs           | 18 +++++++++++++++++
 compiler/rustc_parse/src/parser/expr.rs      | 14 ++++++++++---
 7 files changed, 51 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_errors/src/decorate_diag.rs b/compiler/rustc_errors/src/decorate_diag.rs
index a11082e29663..bfdebafeaf5c 100644
--- a/compiler/rustc_errors/src/decorate_diag.rs
+++ b/compiler/rustc_errors/src/decorate_diag.rs
@@ -14,6 +14,18 @@ pub enum DecorateDiagCompat {
     Builtin(BuiltinLintDiag),
 }
 
+pub struct DynamicDiag<
+    F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
+>(Box<F>);
+
+impl<F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static>
+    DynamicDiag<F>
+{
+    pub fn new(f: F) -> Self {
+        Self(Box::new(f))
+    }
+}
+
 impl std::fmt::Debug for DecorateDiagCompat {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DecorateDiagCompat").finish()
@@ -34,6 +46,15 @@ fn from(b: BuiltinLintDiag) -> Self {
     }
 }
 
+impl<F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static>
+    From<DynamicDiag<F>> for DecorateDiagCompat
+{
+    #[inline]
+    fn from(d: DynamicDiag<F>) -> Self {
+        Self::Dynamic(d.0)
+    }
+}
+
 /// Lints that are buffered up early on in the `Session` before the
 /// `LintLevels` is calculated.
 #[derive(Debug)]
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 8c57544c54b8..45cab3802a7e 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -34,7 +34,7 @@
     Ansi256Color, AnsiColor, Color, EffectIter, Effects, Reset, RgbColor, Style as Anstyle,
 };
 pub use codes::*;
-pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, LintBuffer};
+pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, DynamicDiag, LintBuffer};
 pub use diagnostic::{
     BugAbort, Diag, DiagDecorator, DiagInner, DiagLocation, DiagStyledString, Diagnostic,
     EmissionGuarantee, FatalAbort, StringPart, Subdiag, Subdiagnostic,
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index c282eb34cf4d..54e18dd32207 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -170,13 +170,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                     lints::ReservedMultihash { suggestion }.into_diag(dcx, level)
                 }
             }
-            BuiltinLintDiag::BreakWithLabelAndLoop(sugg_span) => lints::BreakWithLabelAndLoop {
-                sub: lints::BreakWithLabelAndLoopSub {
-                    left: sugg_span.shrink_to_lo(),
-                    right: sugg_span.shrink_to_hi(),
-                },
-            }
-            .into_diag(dcx, level),
             BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
                 let suggestion = match sugg {
                     Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 02448035216e..2d1a8fae1d40 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3220,24 +3220,6 @@ pub(crate) struct RawPrefix {
     pub suggestion: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(
-    "this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression"
-)]
-pub(crate) struct BreakWithLabelAndLoop {
-    #[subdiagnostic]
-    pub sub: BreakWithLabelAndLoopSub,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion("wrap this expression in parentheses", applicability = "machine-applicable")]
-pub(crate) struct BreakWithLabelAndLoopSub {
-    #[suggestion_part(code = "(")]
-    pub left: Span,
-    #[suggestion_part(code = ")")]
-    pub right: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("where clause not allowed here")]
 #[note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information")]
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index ef7067b25baa..2ac75f9dd94c 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -686,7 +686,6 @@ pub enum BuiltinLintDiag {
         is_string: bool,
         suggestion: Span,
     },
-    BreakWithLabelAndLoop(Span),
     UnicodeTextFlow(Span, String),
     DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
     SingleUseLifetime {
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index f4f718292205..45dc29d059ba 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -4499,3 +4499,21 @@ pub(super) fn from_token(token: &Token) -> Option<Self> {
         }
     }
 }
+
+#[derive(Diagnostic)]
+#[diag(
+    "this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression"
+)]
+pub(crate) struct BreakWithLabelAndLoop {
+    #[subdiagnostic]
+    pub sub: BreakWithLabelAndLoopSub,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion("wrap this expression in parentheses", applicability = "machine-applicable")]
+pub(crate) struct BreakWithLabelAndLoopSub {
+    #[suggestion_part(code = "(")]
+    pub left: Span,
+    #[suggestion_part(code = ")")]
+    pub right: Span,
+}
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index adfc68f4bb22..923effc239d2 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -19,10 +19,9 @@
     StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_errors::{Applicability, Diag, PResult, StashKey, Subdiagnostic};
+use rustc_errors::{Applicability, Diag, Diagnostic, PResult, StashKey, Subdiagnostic};
 use rustc_literal_escaper::unescape_char;
 use rustc_session::errors::{ExprParenthesesNeeded, report_lit_error};
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP;
 use rustc_span::edition::Edition;
 use rustc_span::{BytePos, ErrorGuaranteed, Ident, Pos, Span, Spanned, Symbol, kw, respan, sym};
@@ -1921,11 +1920,20 @@ fn parse_expr_break(&mut self) -> PResult<'a, Box<Expr>> {
                         _ => false,
                     }
                 {
+                    let span = expr.span;
                     self.psess.buffer_lint(
                         BREAK_WITH_LABEL_AND_LOOP,
                         lo.to(expr.span),
                         ast::CRATE_NODE_ID,
-                        BuiltinLintDiag::BreakWithLabelAndLoop(expr.span),
+                        rustc_errors::DynamicDiag::new(move |dcx, level| {
+                            errors::BreakWithLabelAndLoop {
+                                sub: errors::BreakWithLabelAndLoopSub {
+                                    left: span.shrink_to_lo(),
+                                    right: span.shrink_to_hi(),
+                                },
+                            }
+                            .into_diag(dcx, level)
+                        }),
                     );
                 }
 

From bb689c41aa2cae4fe204757ec33b31c923fb8402 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 20 Mar 2026 14:58:15 +0100
Subject: [PATCH 0710/1059] Create new `ParseSess::dyn_buffer_lint` method

---
 compiler/rustc_errors/src/decorate_diag.rs | 21 ---------------------
 compiler/rustc_errors/src/lib.rs           |  2 +-
 compiler/rustc_parse/src/parser/expr.rs    |  6 +++---
 compiler/rustc_session/src/parse.rs        | 21 +++++++++++++++++++--
 4 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_errors/src/decorate_diag.rs b/compiler/rustc_errors/src/decorate_diag.rs
index bfdebafeaf5c..a11082e29663 100644
--- a/compiler/rustc_errors/src/decorate_diag.rs
+++ b/compiler/rustc_errors/src/decorate_diag.rs
@@ -14,18 +14,6 @@ pub enum DecorateDiagCompat {
     Builtin(BuiltinLintDiag),
 }
 
-pub struct DynamicDiag<
-    F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
->(Box<F>);
-
-impl<F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static>
-    DynamicDiag<F>
-{
-    pub fn new(f: F) -> Self {
-        Self(Box::new(f))
-    }
-}
-
 impl std::fmt::Debug for DecorateDiagCompat {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DecorateDiagCompat").finish()
@@ -46,15 +34,6 @@ fn from(b: BuiltinLintDiag) -> Self {
     }
 }
 
-impl<F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static>
-    From<DynamicDiag<F>> for DecorateDiagCompat
-{
-    #[inline]
-    fn from(d: DynamicDiag<F>) -> Self {
-        Self::Dynamic(d.0)
-    }
-}
-
 /// Lints that are buffered up early on in the `Session` before the
 /// `LintLevels` is calculated.
 #[derive(Debug)]
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 45cab3802a7e..8c57544c54b8 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -34,7 +34,7 @@
     Ansi256Color, AnsiColor, Color, EffectIter, Effects, Reset, RgbColor, Style as Anstyle,
 };
 pub use codes::*;
-pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, DynamicDiag, LintBuffer};
+pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, LintBuffer};
 pub use diagnostic::{
     BugAbort, Diag, DiagDecorator, DiagInner, DiagLocation, DiagStyledString, Diagnostic,
     EmissionGuarantee, FatalAbort, StringPart, Subdiag, Subdiagnostic,
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 923effc239d2..f1d9b9e7212d 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1921,11 +1921,11 @@ fn parse_expr_break(&mut self) -> PResult<'a, Box<Expr>> {
                     }
                 {
                     let span = expr.span;
-                    self.psess.buffer_lint(
+                    self.psess.dyn_buffer_lint(
                         BREAK_WITH_LABEL_AND_LOOP,
                         lo.to(expr.span),
                         ast::CRATE_NODE_ID,
-                        rustc_errors::DynamicDiag::new(move |dcx, level| {
+                        move |dcx, level| {
                             errors::BreakWithLabelAndLoop {
                                 sub: errors::BreakWithLabelAndLoopSub {
                                     left: span.shrink_to_lo(),
@@ -1933,7 +1933,7 @@ fn parse_expr_break(&mut self) -> PResult<'a, Box<Expr>> {
                                 },
                             }
                             .into_diag(dcx, level)
-                        }),
+                        },
                     );
                 }
 
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index 2b1520274fb6..a8210f2315f1 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -7,12 +7,12 @@
 use rustc_ast::attr::AttrIdGenerator;
 use rustc_ast::node_id::NodeId;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
-use rustc_data_structures::sync::{AppendOnlyVec, Lock};
+use rustc_data_structures::sync::{AppendOnlyVec, DynSend, Lock};
 use rustc_errors::annotate_snippet_emitter_writer::AnnotateSnippetEmitter;
 use rustc_errors::emitter::{EmitterWithNote, stderr_destination};
 use rustc_errors::{
     BufferedEarlyLint, ColorConfig, DecorateDiagCompat, Diag, DiagCtxt, DiagCtxtHandle,
-    DiagMessage, EmissionGuarantee, MultiSpan, StashKey,
+    DiagMessage, EmissionGuarantee, Level, MultiSpan, StashKey,
 };
 use rustc_feature::{GateIssue, UnstableFeatures, find_feature_issue};
 use rustc_span::edition::Edition;
@@ -331,6 +331,23 @@ pub fn buffer_lint(
         self.opt_span_buffer_lint(lint, Some(span.into()), node_id, diagnostic.into())
     }
 
+    pub fn dyn_buffer_lint<
+        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
+    >(
+        &self,
+        lint: &'static Lint,
+        span: impl Into<MultiSpan>,
+        node_id: NodeId,
+        callback: F,
+    ) {
+        self.opt_span_buffer_lint(
+            lint,
+            Some(span.into()),
+            node_id,
+            DecorateDiagCompat::Dynamic(Box::new(callback)),
+        )
+    }
+
     pub(crate) fn opt_span_buffer_lint(
         &self,
         lint: &'static Lint,

From 0e3e647e2ed9528b64acf5ff7895d50d984a20d0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 20 Mar 2026 17:24:42 +0100
Subject: [PATCH 0711/1059] Remove `BuiltinDiag` usage in `rustc_parse`

---
 compiler/rustc_lint/src/early/diagnostics.rs | 45 ----------
 compiler/rustc_lint/src/lints.rs             | 90 --------------------
 compiler/rustc_lint_defs/src/lib.rs          |  8 --
 compiler/rustc_parse/src/errors.rs           | 90 ++++++++++++++++++++
 compiler/rustc_parse/src/lexer/mod.rs        | 59 +++++++++++--
 compiler/rustc_parse/src/parser/expr.rs      | 17 ++--
 6 files changed, 148 insertions(+), 161 deletions(-)

diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 54e18dd32207..d5cd26dd75e3 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 
-use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, Level,
     elided_lifetime_in_path_suggestion,
@@ -10,7 +9,6 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::lint::BuiltinLintDiag;
-use rustc_span::BytePos;
 use tracing::debug;
 
 use crate::lints;
@@ -28,32 +26,6 @@ pub struct DecorateBuiltinLint<'sess, 'tcx> {
 impl<'a> Diagnostic<'a, ()> for DecorateBuiltinLint<'_, '_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         match self.diagnostic {
-            BuiltinLintDiag::UnicodeTextFlow(comment_span, content) => {
-                let spans: Vec<_> = content
-                    .char_indices()
-                    .filter_map(|(i, c)| {
-                        TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
-                            let lo = comment_span.lo() + BytePos(2 + i as u32);
-                            (c, comment_span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
-                        })
-                    })
-                    .collect();
-                let characters = spans
-                    .iter()
-                    .map(|&(c, span)| lints::UnicodeCharNoteSub { span, c_debug: format!("{c:?}") })
-                    .collect();
-                let suggestions = (!spans.is_empty()).then_some(lints::UnicodeTextFlowSuggestion {
-                    spans: spans.iter().map(|(_c, span)| *span).collect(),
-                });
-
-                lints::UnicodeTextFlow {
-                    comment_span,
-                    characters,
-                    suggestions,
-                    num_codepoints: spans.len(),
-                }
-                .into_diag(dcx, level)
-            }
             BuiltinLintDiag::AbsPathWithModule(mod_span) => {
                 let (replacement, applicability) =
                     match self.sess.source_map().span_to_snippet(mod_span) {
@@ -153,23 +125,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 }
                 .into_diag(dcx, level)
             }
-            BuiltinLintDiag::ReservedPrefix(label_span, prefix) => lints::ReservedPrefix {
-                label: label_span,
-                suggestion: label_span.shrink_to_hi(),
-                prefix,
-            }
-            .into_diag(dcx, level),
-            BuiltinLintDiag::RawPrefix(label_span) => {
-                lints::RawPrefix { label: label_span, suggestion: label_span.shrink_to_hi() }
-                    .into_diag(dcx, level)
-            }
-            BuiltinLintDiag::ReservedString { is_string, suggestion } => {
-                if is_string {
-                    lints::ReservedString { suggestion }.into_diag(dcx, level)
-                } else {
-                    lints::ReservedMultihash { suggestion }.into_diag(dcx, level)
-                }
-            }
             BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
                 let suggestion = match sugg {
                     Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 2d1a8fae1d40..d5b5a50d281a 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3019,46 +3019,6 @@ pub(crate) struct IllFormedAttributeInput {
     pub docs: &'static str,
 }
 
-#[derive(Diagnostic)]
-#[diag("unicode codepoint changing visible direction of text present in comment")]
-#[note(
-    "these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen"
-)]
-pub(crate) struct UnicodeTextFlow {
-    #[label(
-        "{$num_codepoints ->
-            [1] this comment contains an invisible unicode text flow control codepoint
-            *[other] this comment contains invisible unicode text flow control codepoints
-        }"
-    )]
-    pub comment_span: Span,
-    #[subdiagnostic]
-    pub characters: Vec<UnicodeCharNoteSub>,
-    #[subdiagnostic]
-    pub suggestions: Option<UnicodeTextFlowSuggestion>,
-
-    pub num_codepoints: usize,
-}
-
-#[derive(Subdiagnostic)]
-#[label("{$c_debug}")]
-pub(crate) struct UnicodeCharNoteSub {
-    #[primary_span]
-    pub span: Span,
-    pub c_debug: String,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    "if their presence wasn't intentional, you can remove them",
-    applicability = "machine-applicable",
-    style = "hidden"
-)]
-pub(crate) struct UnicodeTextFlowSuggestion {
-    #[suggestion_part(code = "")]
-    pub spans: Vec<Span>,
-}
-
 #[derive(Diagnostic)]
 #[diag(
     "absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition"
@@ -3192,34 +3152,6 @@ pub(crate) struct PatternsInFnsWithoutBodySub {
     pub ident: Ident,
 }
 
-#[derive(Diagnostic)]
-#[diag("prefix `{$prefix}` is unknown")]
-pub(crate) struct ReservedPrefix {
-    #[label("unknown prefix")]
-    pub label: Span,
-    #[suggestion(
-        "insert whitespace here to avoid this being parsed as a prefix in Rust 2021",
-        code = " ",
-        applicability = "machine-applicable"
-    )]
-    pub suggestion: Span,
-
-    pub prefix: String,
-}
-
-#[derive(Diagnostic)]
-#[diag("prefix `'r` is reserved")]
-pub(crate) struct RawPrefix {
-    #[label("reserved prefix")]
-    pub label: Span,
-    #[suggestion(
-        "insert whitespace here to avoid this being parsed as a prefix in Rust 2021",
-        code = " ",
-        applicability = "machine-applicable"
-    )]
-    pub suggestion: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("where clause not allowed here")]
 #[note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information")]
@@ -3405,28 +3337,6 @@ pub(crate) enum MutRefSugg {
 #[diag("`use` of a local item without leading `self::`, `super::`, or `crate::`")]
 pub(crate) struct UnqualifiedLocalImportsDiag;
 
-#[derive(Diagnostic)]
-#[diag("will be parsed as a guarded string in Rust 2024")]
-pub(crate) struct ReservedString {
-    #[suggestion(
-        "insert whitespace here to avoid this being parsed as a guarded string in Rust 2024",
-        code = " ",
-        applicability = "machine-applicable"
-    )]
-    pub suggestion: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag("reserved token in Rust 2024")]
-pub(crate) struct ReservedMultihash {
-    #[suggestion(
-        "insert whitespace here to avoid this being parsed as a forbidden token in Rust 2024",
-        code = " ",
-        applicability = "machine-applicable"
-    )]
-    pub suggestion: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("direct cast of function item into an integer")]
 pub(crate) struct FunctionCastsAsIntegerDiag<'tcx> {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 2ac75f9dd94c..e2e4ffc64bea 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -678,15 +678,7 @@ pub enum BuiltinLintDiag {
         ident: Ident,
         is_foreign: bool,
     },
-    ReservedPrefix(Span, String),
-    /// `'r#` in edition < 2021.
-    RawPrefix(Span),
     /// `##` or `#"` in edition < 2024.
-    ReservedString {
-        is_string: bool,
-        suggestion: Span,
-    },
-    UnicodeTextFlow(Span, String),
     DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
     SingleUseLifetime {
         /// Span of the parameter which declares this lifetime.
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 45dc29d059ba..0e852d2abda0 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -4517,3 +4517,93 @@ pub(crate) struct BreakWithLabelAndLoopSub {
     #[suggestion_part(code = ")")]
     pub right: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("prefix `'r` is reserved")]
+pub(crate) struct RawPrefix {
+    #[label("reserved prefix")]
+    pub label: Span,
+    #[suggestion(
+        "insert whitespace here to avoid this being parsed as a prefix in Rust 2021",
+        code = " ",
+        applicability = "machine-applicable"
+    )]
+    pub suggestion: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("unicode codepoint changing visible direction of text present in comment")]
+#[note(
+    "these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen"
+)]
+pub(crate) struct UnicodeTextFlow {
+    #[label(
+        "{$num_codepoints ->
+            [1] this comment contains an invisible unicode text flow control codepoint
+            *[other] this comment contains invisible unicode text flow control codepoints
+        }"
+    )]
+    pub comment_span: Span,
+    #[subdiagnostic]
+    pub characters: Vec<UnicodeCharNoteSub>,
+    #[subdiagnostic]
+    pub suggestions: Option<UnicodeTextFlowSuggestion>,
+
+    pub num_codepoints: usize,
+}
+
+#[derive(Subdiagnostic)]
+#[label("{$c_debug}")]
+pub(crate) struct UnicodeCharNoteSub {
+    #[primary_span]
+    pub span: Span,
+    pub c_debug: String,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    "if their presence wasn't intentional, you can remove them",
+    applicability = "machine-applicable",
+    style = "hidden"
+)]
+pub(crate) struct UnicodeTextFlowSuggestion {
+    #[suggestion_part(code = "")]
+    pub spans: Vec<Span>,
+}
+
+#[derive(Diagnostic)]
+#[diag("prefix `{$prefix}` is unknown")]
+pub(crate) struct ReservedPrefix {
+    #[label("unknown prefix")]
+    pub label: Span,
+    #[suggestion(
+        "insert whitespace here to avoid this being parsed as a prefix in Rust 2021",
+        code = " ",
+        applicability = "machine-applicable"
+    )]
+    pub suggestion: Span,
+
+    pub prefix: String,
+}
+
+#[derive(Diagnostic)]
+#[diag("will be parsed as a guarded string in Rust 2024")]
+pub(crate) struct ReservedStringLint {
+    #[suggestion(
+        "insert whitespace here to avoid this being parsed as a guarded string in Rust 2024",
+        code = " ",
+        applicability = "machine-applicable"
+    )]
+    pub suggestion: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("reserved token in Rust 2024")]
+pub(crate) struct ReservedMultihashLint {
+    #[suggestion(
+        "insert whitespace here to avoid this being parsed as a forbidden token in Rust 2024",
+        code = " ",
+        applicability = "machine-applicable"
+    )]
+    pub suggestion: Span,
+}
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index cd90655125b2..2223e6a26575 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -4,12 +4,11 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::util::unicode::{TEXT_FLOW_CONTROL_CHARS, contains_text_flow_control_chars};
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, Diag, DiagCtxtHandle, StashKey};
+use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, StashKey};
 use rustc_lexer::{
     Base, Cursor, DocStyle, FrontmatterAllowed, LiteralKind, RawStrError, is_horizontal_whitespace,
 };
 use rustc_literal_escaper::{EscapeError, Mode, check_for_errors};
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX, RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
     TEXT_DIRECTION_CODEPOINT_IN_COMMENT, TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
@@ -388,7 +387,10 @@ fn next_token_from_cursor(&mut self) -> (Token, bool) {
                             RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
                             prefix_span,
                             ast::CRATE_NODE_ID,
-                            BuiltinLintDiag::RawPrefix(prefix_span),
+                            errors::RawPrefix {
+                                label: prefix_span,
+                                suggestion: prefix_span.shrink_to_hi()
+                            },
                         );
 
                         // Reset the state so we just lex the `'r`.
@@ -498,11 +500,41 @@ fn lint_unicode_text_flow(&self, start: BytePos) {
         let content = self.str_from(content_start);
         if contains_text_flow_control_chars(content) {
             let span = self.mk_sp(start, self.pos);
-            self.psess.buffer_lint(
+            let content = content.to_string();
+            self.psess.dyn_buffer_lint(
                 TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
                 span,
                 ast::CRATE_NODE_ID,
-                BuiltinLintDiag::UnicodeTextFlow(span, content.to_string()),
+                move |dcx, level| {
+                    let spans: Vec<_> = content
+                        .char_indices()
+                        .filter_map(|(i, c)| {
+                            TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
+                                let lo = span.lo() + BytePos(2 + i as u32);
+                                (c, span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
+                            })
+                        })
+                        .collect();
+                    let characters = spans
+                        .iter()
+                        .map(|&(c, span)| errors::UnicodeCharNoteSub {
+                            span,
+                            c_debug: format!("{c:?}"),
+                        })
+                        .collect();
+                    let suggestions =
+                        (!spans.is_empty()).then_some(errors::UnicodeTextFlowSuggestion {
+                            spans: spans.iter().map(|(_c, span)| *span).collect(),
+                        });
+
+                    errors::UnicodeTextFlow {
+                        comment_span: span,
+                        characters,
+                        suggestions,
+                        num_codepoints: spans.len(),
+                    }
+                    .into_diag(dcx, level)
+                },
             );
         }
     }
@@ -1038,7 +1070,11 @@ fn report_unknown_prefix(&self, start: BytePos) {
                 RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
                 prefix_span,
                 ast::CRATE_NODE_ID,
-                BuiltinLintDiag::ReservedPrefix(prefix_span, prefix.to_string()),
+                errors::ReservedPrefix {
+                    label: prefix_span,
+                    suggestion: prefix_span.shrink_to_hi(),
+                    prefix: prefix.to_string(),
+                },
             );
         }
     }
@@ -1112,11 +1148,18 @@ fn maybe_report_guarded_str(&mut self, start: BytePos, str_before: &'src str) ->
             })
         } else {
             // Before Rust 2024, only emit a lint for migration.
-            self.psess.buffer_lint(
+            self.psess.dyn_buffer_lint(
                 RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
                 span,
                 ast::CRATE_NODE_ID,
-                BuiltinLintDiag::ReservedString { is_string, suggestion: space_span },
+                move |dcx, level| {
+                    if is_string {
+                        errors::ReservedStringLint { suggestion: space_span }.into_diag(dcx, level)
+                    } else {
+                        errors::ReservedMultihashLint { suggestion: space_span }
+                            .into_diag(dcx, level)
+                    }
+                },
             );
 
             // For backwards compatibility, roll back to after just the first `#`
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index f1d9b9e7212d..7d1a0661aaab 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -19,7 +19,7 @@
     StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_errors::{Applicability, Diag, Diagnostic, PResult, StashKey, Subdiagnostic};
+use rustc_errors::{Applicability, Diag, PResult, StashKey, Subdiagnostic};
 use rustc_literal_escaper::unescape_char;
 use rustc_session::errors::{ExprParenthesesNeeded, report_lit_error};
 use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP;
@@ -1921,18 +1921,15 @@ fn parse_expr_break(&mut self) -> PResult<'a, Box<Expr>> {
                     }
                 {
                     let span = expr.span;
-                    self.psess.dyn_buffer_lint(
+                    self.psess.buffer_lint(
                         BREAK_WITH_LABEL_AND_LOOP,
                         lo.to(expr.span),
                         ast::CRATE_NODE_ID,
-                        move |dcx, level| {
-                            errors::BreakWithLabelAndLoop {
-                                sub: errors::BreakWithLabelAndLoopSub {
-                                    left: span.shrink_to_lo(),
-                                    right: span.shrink_to_hi(),
-                                },
-                            }
-                            .into_diag(dcx, level)
+                        errors::BreakWithLabelAndLoop {
+                            sub: errors::BreakWithLabelAndLoopSub {
+                                left: span.shrink_to_lo(),
+                                right: span.shrink_to_hi(),
+                            },
                         },
                     );
                 }

From ed6a6fddb440f2b19d55530a07df0c7c94391ad8 Mon Sep 17 00:00:00 2001
From: Jose <Jose.Torres6@aexp.com>
Date: Fri, 13 Mar 2026 14:43:44 -0400
Subject: [PATCH 0712/1059] refactoring stability check

---
 .../src/attributes/stability.rs               | 11 ++++++++
 compiler/rustc_passes/src/check_attr.rs       | 25 ++-----------------
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 6ddd9f2c1fb5..f9e3f41a46fe 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -1,6 +1,7 @@
 use std::num::NonZero;
 
 use rustc_errors::ErrorGuaranteed;
+use rustc_feature::ACCEPTED_LANG_FEATURES;
 use rustc_hir::target::GenericParamKind;
 use rustc_hir::{
     DefaultBodyStability, MethodKind, PartialConstStability, Stability, StabilityLevel,
@@ -451,6 +452,16 @@ pub(crate) fn parse_unstability<S: Stage>(
 
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
+            // Validate that unstable attributes don't use already-stable language features
+            
+            if ACCEPTED_LANG_FEATURES.iter().any(|f| f.name == feature) {
+                cx.emit_err(session_diagnostics::UnstableAttrForAlreadyStableFeature {
+                    attr_span: cx.attr_span,
+                    item_span: cx.target_span,
+                });
+                return None;
+            }
+            
             let level = StabilityLevel::Unstable {
                 reason: UnstableReason::from_opt_reason(reason),
                 issue: issue_num,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9945802d70c1..9ab780e88439 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -17,8 +17,7 @@
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey, msg};
 use rustc_feature::{
-    ACCEPTED_LANG_FEATURES, AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP,
-    BuiltinAttribute,
+    AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute,
 };
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_hir::attrs::{
@@ -165,7 +164,7 @@ fn check_attributes(
                         span: attr_span,
                         stability: PartialConstStability { level, feature, .. },
                     },
-                ) => self.check_stability(*attr_span, span, level, *feature),
+                ) => {}
                 Attribute::Parsed(AttributeKind::Inline(InlineAttr::Force { .. }, ..)) => {} // handled separately below
                 Attribute::Parsed(AttributeKind::Inline(kind, attr_span)) => {
                     self.check_inline(hir_id, *attr_span, kind, target)
@@ -1551,8 +1550,6 @@ fn check_macro_only_attr(
         }
     }
 
-    /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
-    /// (Allows proc_macro functions)
     fn check_rustc_allow_const_fn_unstable(
         &self,
         hir_id: HirId,
@@ -1570,24 +1567,6 @@ fn check_rustc_allow_const_fn_unstable(
         }
     }
 
-    fn check_stability(
-        &self,
-        attr_span: Span,
-        item_span: Span,
-        level: &StabilityLevel,
-        feature: Symbol,
-    ) {
-        // Stable *language* features shouldn't be used as unstable library features.
-        // (Not doing this for stable library features is checked by tidy.)
-        if level.is_unstable()
-            && ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some()
-        {
-            self.tcx
-                .dcx()
-                .emit_err(errors::UnstableAttrForAlreadyStableFeature { attr_span, item_span });
-        }
-    }
-
     fn check_deprecated(&self, hir_id: HirId, attr_span: Span, target: Target) {
         match target {
             Target::AssocConst | Target::Method(..) | Target::AssocTy

From c614e3d216b26052d0badfeb5c33f095b4ced1f3 Mon Sep 17 00:00:00 2001
From: Jose <Jose.Torres6@aexp.com>
Date: Fri, 13 Mar 2026 16:38:15 -0400
Subject: [PATCH 0713/1059] linting, moving error to session diagnostics

---
 .../src/attributes/stability.rs                 |  4 +---
 .../src/session_diagnostics.rs                  | 11 +++++++++++
 compiler/rustc_passes/src/check_attr.rs         | 17 ++++-------------
 compiler/rustc_passes/src/errors.rs             | 11 -----------
 4 files changed, 16 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index f9e3f41a46fe..8aa013ec4108 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -452,8 +452,6 @@ pub(crate) fn parse_unstability<S: Stage>(
 
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
-            // Validate that unstable attributes don't use already-stable language features
-            
             if ACCEPTED_LANG_FEATURES.iter().any(|f| f.name == feature) {
                 cx.emit_err(session_diagnostics::UnstableAttrForAlreadyStableFeature {
                     attr_span: cx.attr_span,
@@ -461,7 +459,7 @@ pub(crate) fn parse_unstability<S: Stage>(
                 });
                 return None;
             }
-            
+
             let level = StabilityLevel::Unstable {
                 reason: UnstableReason::from_opt_reason(reason),
                 issue: issue_num,
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 069488948868..bab830098f1a 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -1046,3 +1046,14 @@ pub(crate) struct CustomMirIncompatibleDialectAndPhase {
     #[label("... is not compatible with this phase")]
     pub phase_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("can't mark as unstable using an already stable feature")]
+pub(crate) struct UnstableAttrForAlreadyStableFeature {
+    #[primary_span]
+    #[label("this feature is already stable")]
+    #[help("consider removing the attribute")]
+    pub attr_span: Span,
+    #[label("the stability attribute annotates this item")]
+    pub item_span: Span,
+}
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9ab780e88439..4f11215aaa31 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -16,9 +16,7 @@
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey, msg};
-use rustc_feature::{
-    AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute,
-};
+use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_hir::attrs::{
     AttributeKind, DocAttribute, DocInline, EiiDecl, EiiImpl, EiiImplResolution, InlineAttr,
@@ -29,8 +27,7 @@
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{
     self as hir, Attribute, CRATE_HIR_ID, Constness, FnSig, ForeignItem, GenericParamKind, HirId,
-    Item, ItemKind, MethodKind, Node, ParamName, PartialConstStability, Safety, Stability,
-    StabilityLevel, Target, TraitItem, find_attr,
+    Item, ItemKind, MethodKind, Node, ParamName, Safety, Target, TraitItem, find_attr,
 };
 use rustc_macros::Diagnostic;
 use rustc_middle::hir::nested_filter;
@@ -156,14 +153,8 @@ fn check_attributes(
                     self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
                 }
                 Attribute::Parsed(
-                    AttributeKind::Stability {
-                        span: attr_span,
-                        stability: Stability { level, feature },
-                    }
-                    | AttributeKind::RustcConstStability {
-                        span: attr_span,
-                        stability: PartialConstStability { level, feature, .. },
-                    },
+                    AttributeKind::Stability { .. }
+                    | AttributeKind::RustcConstStability { .. },
                 ) => {}
                 Attribute::Parsed(AttributeKind::Inline(InlineAttr::Force { .. }, ..)) => {} // handled separately below
                 Attribute::Parsed(AttributeKind::Inline(kind, attr_span)) => {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 6efbcd7bf85b..5e84122fcb10 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -871,17 +871,6 @@ pub(crate) struct CannotStabilizeDeprecated {
     pub item_sp: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("can't mark as unstable using an already stable feature")]
-pub(crate) struct UnstableAttrForAlreadyStableFeature {
-    #[primary_span]
-    #[label("this feature is already stable")]
-    #[help("consider removing the attribute")]
-    pub attr_span: Span,
-    #[label("the stability attribute annotates this item")]
-    pub item_span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("{$descr} has missing stability attribute")]
 pub(crate) struct MissingStabilityAttr<'a> {

From 4e446d55a40cae05284fc4118b18373e7dd71f02 Mon Sep 17 00:00:00 2001
From: Jose <Jose.Torres6@aexp.com>
Date: Tue, 17 Mar 2026 16:53:54 -0400
Subject: [PATCH 0714/1059] restore code comment

---
 compiler/rustc_attr_parsing/src/attributes/stability.rs | 2 ++
 compiler/rustc_passes/src/check_attr.rs                 | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 8aa013ec4108..a5e9a070c562 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -452,6 +452,8 @@ pub(crate) fn parse_unstability<S: Stage>(
 
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
+            // Stable *language* features shouldn't be used as unstable library features.
+            // (Not doing this for stable library features is checked by tidy.)
             if ACCEPTED_LANG_FEATURES.iter().any(|f| f.name == feature) {
                 cx.emit_err(session_diagnostics::UnstableAttrForAlreadyStableFeature {
                     attr_span: cx.attr_span,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 4f11215aaa31..3433eaca3e1d 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1541,6 +1541,8 @@ fn check_macro_only_attr(
         }
     }
 
+    /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
+    /// (Allows proc_macro functions)
     fn check_rustc_allow_const_fn_unstable(
         &self,
         hir_id: HirId,

From 3ea7d1ece76c0d207f3c7754140b07c2b7f5e549 Mon Sep 17 00:00:00 2001
From: Jose Torres <josetorrs7@gmail.com>
Date: Fri, 20 Mar 2026 12:14:41 -0400
Subject: [PATCH 0715/1059] fixing seperate empty arm and doc comment

---
 compiler/rustc_attr_parsing/src/attributes/stability.rs | 2 +-
 compiler/rustc_passes/src/check_attr.rs                 | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index a5e9a070c562..25b295c162aa 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -367,7 +367,7 @@ pub(crate) fn parse_stability<S: Stage>(
     }
 }
 
-// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
+/// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
 /// attribute, and return the feature name and its stability information.
 pub(crate) fn parse_unstability<S: Stage>(
     cx: &AcceptContext<'_, '_, S>,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 3433eaca3e1d..a8ca8011b571 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -152,10 +152,6 @@ fn check_attributes(
                 Attribute::Parsed(AttributeKind::ProcMacroDerive { .. }) => {
                     self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
                 }
-                Attribute::Parsed(
-                    AttributeKind::Stability { .. }
-                    | AttributeKind::RustcConstStability { .. },
-                ) => {}
                 Attribute::Parsed(AttributeKind::Inline(InlineAttr::Force { .. }, ..)) => {} // handled separately below
                 Attribute::Parsed(AttributeKind::Inline(kind, attr_span)) => {
                     self.check_inline(hir_id, *attr_span, kind, target)
@@ -302,6 +298,7 @@ fn check_attributes(
                     | AttributeKind::RustcCoherenceIsCore(..)
                     | AttributeKind::RustcCoinductive(..)
                     | AttributeKind::RustcConfusables { .. }
+                    | AttributeKind::RustcConstStability { .. }
                     | AttributeKind::RustcConstStableIndirect
                     | AttributeKind::RustcConversionSuggestion
                     | AttributeKind::RustcDeallocator
@@ -374,6 +371,7 @@ fn check_attributes(
                     | AttributeKind::RustcTrivialFieldReads
                     | AttributeKind::RustcUnsafeSpecializationMarker(..)
                     | AttributeKind::ShouldPanic { .. }
+                    | AttributeKind::Stability { .. }
                     | AttributeKind::TestRunner(..)
                     | AttributeKind::ThreadLocal
                     | AttributeKind::TypeLengthLimit { .. }

From d54cf8f40a87034f0e8d6d404ec4b7e82887bbe5 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 20 Mar 2026 18:23:12 +0000
Subject: [PATCH 0716/1059] core: Implement `unchecked_funnel_{shl,shr}`

These methods are just wrappers around the intrinsics.
---
 library/core/src/num/uint_macros.rs | 58 ++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index ae8324c13f0c..27dbe6d3f1d8 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -447,7 +447,7 @@ pub const fn rotate_right(self, n: u32) -> Self {
         pub const fn funnel_shl(self, rhs: Self, n: u32) -> Self {
             assert!(n < Self::BITS, "attempt to funnel shift left with overflow");
             // SAFETY: just checked that `shift` is in-range
-            unsafe { intrinsics::unchecked_funnel_shl(self, rhs, n) }
+            unsafe { self.unchecked_funnel_shl(rhs, n) }
         }
 
         /// Performs a right funnel shift (concatenates `self` and `rhs`, with `self`
@@ -482,7 +482,61 @@ pub const fn funnel_shl(self, rhs: Self, n: u32) -> Self {
         pub const fn funnel_shr(self, rhs: Self, n: u32) -> Self {
             assert!(n < Self::BITS, "attempt to funnel shift right with overflow");
             // SAFETY: just checked that `shift` is in-range
-            unsafe { intrinsics::unchecked_funnel_shr(self, rhs, n) }
+            unsafe { self.unchecked_funnel_shr(rhs, n) }
+        }
+
+        /// Unchecked funnel shift left.
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior if `n` is greater than or equal to
+        #[doc = concat!("`", stringify!($SelfT) , "::BITS`,")]
+        /// i.e. when [`funnel_shl`](Self::funnel_shl) would panic.
+        ///
+        #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+        #[unstable(feature = "funnel_shifts", issue = "145686")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline(always)]
+        #[track_caller]
+        pub const unsafe fn unchecked_funnel_shl(self, low: Self, n: u32) -> Self {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_funnel_shl cannot overflow"),
+                (n: u32 = n) => n < <$ActualT>::BITS,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller.
+            unsafe {
+                intrinsics::unchecked_funnel_shl(self, low, n)
+            }
+        }
+
+        /// Unchecked funnel shift right.
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior if `n` is greater than or equal to
+        #[doc = concat!("`", stringify!($SelfT) , "::BITS`,")]
+        /// i.e. when [`funnel_shr`](Self::funnel_shr) would panic.
+        ///
+        #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+        #[unstable(feature = "funnel_shifts", issue = "145686")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline(always)]
+        #[track_caller]
+        pub const unsafe fn unchecked_funnel_shr(self, low: Self, n: u32) -> Self {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_funnel_shr cannot overflow"),
+                (n: u32 = n) => n < <$ActualT>::BITS,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller.
+            unsafe {
+                intrinsics::unchecked_funnel_shr(self, low, n)
+            }
         }
 
         /// Performs a carry-less multiplication, returning the lower bits.

From 244322f0be1296f5ac4d6fc0dcc603b5ccab2832 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 20 Mar 2026 18:44:08 +0000
Subject: [PATCH 0717/1059] Make `:` -> `=` typo suggestion verbose

---
 compiler/rustc_parse/src/parser/stmt.rs                |  4 ++--
 compiler/rustc_resolve/src/late/diagnostics.rs         |  2 +-
 tests/ui/parser/recover/array-type-no-semi.stderr      |  7 ++++++-
 .../recover-colon-instead-of-eq-in-local.stderr        |  7 ++++++-
 .../ui/suggestions/let-binding-init-expr-as-ty.stderr  | 10 +++++++---
 .../type/type-ascription-instead-of-initializer.stderr |  7 ++++++-
 6 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 3b2102484bdf..44886de52312 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -362,7 +362,7 @@ fn parse_local(&mut self, super_: Option<Span>, attrs: AttrVec) -> PResult<'a, B
                 // init parsed, ty error
                 // Could parse the type as if it were the initializer, it is likely there was a
                 // typo in the code: `:` instead of `=`. Add suggestion and emit the error.
-                err.span_suggestion_short(
+                err.span_suggestion_verbose(
                     colon_sp,
                     "use `=` if you meant to assign",
                     " =",
@@ -1134,7 +1134,7 @@ pub fn parse_full_stmt(
                                     false
                                 };
                                 if suggest_eq {
-                                    e.span_suggestion_short(
+                                    e.span_suggestion_verbose(
                                         colon_sp,
                                         "use `=` if you meant to assign",
                                         "=",
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 95a6b25d54e6..80e7a957c4d2 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1271,7 +1271,7 @@ fn suggest_typo(
                 Some((pat_sp, Some(ty_sp), None))
                     if ty_sp.contains(base_error.span) && base_error.could_be_expr =>
                 {
-                    err.span_suggestion_short(
+                    err.span_suggestion_verbose(
                         pat_sp.between(ty_sp),
                         "use `=` if you meant to assign",
                         " = ",
diff --git a/tests/ui/parser/recover/array-type-no-semi.stderr b/tests/ui/parser/recover/array-type-no-semi.stderr
index 45f39fefe5e3..56c78b01ea39 100644
--- a/tests/ui/parser/recover/array-type-no-semi.stderr
+++ b/tests/ui/parser/recover/array-type-no-semi.stderr
@@ -17,7 +17,12 @@ LL |     let a: [i32, ];
    |          -     ^ expected `;` or `]`
    |          |
    |          while parsing the type for `a`
-   |          help: use `=` if you meant to assign
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let a: [i32, ];
+LL +     let a = [i32, ];
+   |
 
 error: expected `;` or `]`, found `,`
   --> $DIR/array-type-no-semi.rs:12:16
diff --git a/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr b/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
index 15c27bb9451b..8c238c1dd307 100644
--- a/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
+++ b/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
@@ -13,7 +13,12 @@ LL |     let _: std::env::temp_dir().join("foo");
    |          -                     ^ expected one of `!`, `+`, `->`, `::`, `;`, or `=`
    |          |
    |          while parsing the type for `_`
-   |          help: use `=` if you meant to assign
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let _: std::env::temp_dir().join("foo");
+LL +     let _= std::env::temp_dir().join("foo");
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
index 19a0e4b17d02..f0887f85d6ef 100644
--- a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
+++ b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
@@ -2,9 +2,13 @@ error[E0573]: expected type, found local variable `num`
   --> $DIR/let-binding-init-expr-as-ty.rs:2:27
    |
 LL |     let foo: i32::from_be(num);
-   |            --             ^^^ not a type
-   |            |
-   |            help: use `=` if you meant to assign
+   |                           ^^^ not a type
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let foo: i32::from_be(num);
+LL +     let foo = i32::from_be(num);
+   |
 
 error: argument types not allowed with return type notation
   --> $DIR/let-binding-init-expr-as-ty.rs:2:26
diff --git a/tests/ui/type/type-ascription-instead-of-initializer.stderr b/tests/ui/type/type-ascription-instead-of-initializer.stderr
index 630e82d254ee..edc38b0ca7b9 100644
--- a/tests/ui/type/type-ascription-instead-of-initializer.stderr
+++ b/tests/ui/type/type-ascription-instead-of-initializer.stderr
@@ -5,7 +5,12 @@ LL |     let x: Vec::with_capacity(10, 20);
    |          -                    ^^ expected type
    |          |
    |          while parsing the type for `x`
-   |          help: use `=` if you meant to assign
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: Vec::with_capacity(10, 20);
+LL +     let x = Vec::with_capacity(10, 20);
+   |
 
 error[E0061]: this function takes 1 argument but 2 arguments were supplied
   --> $DIR/type-ascription-instead-of-initializer.rs:2:12

From d48e699b6cdcf76590a141ccf9fde84adb297176 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 20 Mar 2026 19:33:05 +0000
Subject: [PATCH 0718/1059] Emit fewer errors for incorrect rtn and `=` -> `:`
 typos in bindings

Stash parse errors when pasing rtn that doesn't use `(..)`.
Emit single error on `Foo::bar(qux)` that looks like rtn in incorrect position and suggest `Foo::bar(..)`.
```
error: return type notation not allowed in this position yet
  --> $DIR/let-binding-init-expr-as-ty.rs:18:10
   |
LL | struct K(S::new(()));
   |          ^^^^^^^^^^
   |
help: furthermore, argument types not allowed with return type notation
   |
LL - struct K(S::new(()));
LL + struct K(S::new(..));
   |
```
On incorrect rtn in let binding type for an existing inherent associated function, suggest `:` -> `=` to turn the "type" into a call expression.
```
error: expected type, found associated function call
  --> $DIR/let-binding-init-expr-as-ty.rs:29:12
   |
LL |     let x: S::new(());
   |            ^^^^^^^^^^
   |
help: use `=` if you meant to assign
   |
LL -     let x: S::new(());
LL +     let x = S::new(());
   |
```
---
 compiler/rustc_ast_lowering/src/path.rs       |   3 +-
 compiler/rustc_errors/src/lib.rs              |   1 +
 compiler/rustc_hir_analysis/src/errors.rs     |   7 +
 .../src/hir_ty_lowering/mod.rs                |  93 ++++++++++-
 .../let-binding-init-expr-as-ty.rs            |  36 ++++-
 .../let-binding-init-expr-as-ty.stderr        | 149 ++++++++++++++++--
 6 files changed, 268 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index ec57720387c0..fe85302c2177 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use rustc_ast::{self as ast, *};
+use rustc_errors::StashKey;
 use rustc_hir::def::{DefKind, PartialRes, PerNS, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, GenericArg};
@@ -298,7 +299,7 @@ pub(crate) fn lower_path_segment(
                                 sym::return_type_notation,
                             );
                         }
-                        err.emit();
+                        err.stash(path_span, StashKey::ReturnTypeNotation);
                         (
                             GenericArgsCtor {
                                 args: Default::default(),
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 8c57544c54b8..d17a4d6de42f 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -386,6 +386,7 @@ pub enum StashKey {
     /// it's a method call without parens. If later on in `hir_typeck` we find out that this is
     /// the case we suppress this message and we give a better suggestion.
     GenericInFieldExpr,
+    ReturnTypeNotation,
 }
 
 fn default_track_diagnostic<R>(diag: DiagInner, f: &mut dyn FnMut(DiagInner) -> R) -> R {
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 1c999f1ffc93..fcd4cb938bf7 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1807,6 +1807,13 @@ pub(crate) struct CmseImplTrait {
 pub(crate) struct BadReturnTypeNotation {
     #[primary_span]
     pub span: Span,
+    #[suggestion(
+        "furthermore, argument types not allowed with return type notation",
+        applicability = "maybe-incorrect",
+        code = "(..)",
+        style = "verbose"
+    )]
+    pub suggestion: Option<Span>,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index bf97bfb1ebbc..2bba1b723353 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -26,7 +26,7 @@
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, DiagCtxtHandle, Diagnostic, ErrorGuaranteed, FatalError, Level,
+    Applicability, Diag, DiagCtxtHandle, Diagnostic, ErrorGuaranteed, FatalError, Level, StashKey,
     struct_span_code_err,
 };
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -3008,7 +3008,9 @@ pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
                     matches!(args.parenthesized, hir::GenericArgsParentheses::ReturnTypeNotation)
                 }) =>
             {
-                let guar = self.dcx().emit_err(BadReturnTypeNotation { span: hir_ty.span });
+                let guar = self
+                    .dcx()
+                    .emit_err(BadReturnTypeNotation { span: hir_ty.span, suggestion: None });
                 Ty::new_error(tcx, guar)
             }
             hir::TyKind::Path(hir::QPath::Resolved(maybe_qself, path)) => {
@@ -3070,12 +3072,95 @@ pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
             // If we encounter a type relative path with RTN generics, then it must have
             // *not* gone through `lower_ty_maybe_return_type_notation`, and therefore
             // it's certainly in an illegal position.
-            hir::TyKind::Path(hir::QPath::TypeRelative(_, segment))
+            hir::TyKind::Path(hir::QPath::TypeRelative(hir_self_ty, segment))
                 if segment.args.is_some_and(|args| {
                     matches!(args.parenthesized, hir::GenericArgsParentheses::ReturnTypeNotation)
                 }) =>
             {
-                let guar = self.dcx().emit_err(BadReturnTypeNotation { span: hir_ty.span });
+                let guar = if let hir::Node::LetStmt(stmt) = tcx.parent_hir_node(hir_ty.hir_id)
+                    && let None = stmt.init
+                    && let hir::TyKind::Path(hir::QPath::Resolved(_, self_ty_path)) =
+                        hir_self_ty.kind
+                    && let Res::Def(DefKind::Enum | DefKind::Struct | DefKind::Union, def_id) =
+                        self_ty_path.res
+                    && let Some(_) = tcx
+                        .inherent_impls(def_id)
+                        .iter()
+                        .flat_map(|imp| {
+                            tcx.associated_items(*imp).filter_by_name_unhygienic(segment.ident.name)
+                        })
+                        .filter(|assoc| {
+                            matches!(assoc.kind, ty::AssocKind::Fn { has_self: false, .. })
+                        })
+                        .next()
+                {
+                    // `let x: S::new(valid_in_ty_ctxt);` -> `let x = S::new(valid_in_ty_ctxt);`
+                    let err = tcx
+                        .dcx()
+                        .struct_span_err(
+                            hir_ty.span,
+                            "expected type, found associated function call",
+                        )
+                        .with_span_suggestion_verbose(
+                            stmt.pat.span.between(hir_ty.span),
+                            "use `=` if you meant to assign",
+                            " = ".to_string(),
+                            Applicability::MaybeIncorrect,
+                        );
+                    self.dcx().try_steal_replace_and_emit_err(
+                        hir_ty.span,
+                        StashKey::ReturnTypeNotation,
+                        err,
+                    )
+                } else if let hir::Node::LetStmt(stmt) = tcx.parent_hir_node(hir_ty.hir_id)
+                    && let None = stmt.init
+                    && let hir::TyKind::Path(hir::QPath::Resolved(_, self_ty_path)) =
+                        hir_self_ty.kind
+                    && let Res::PrimTy(_) = self_ty_path.res
+                    && self.dcx().has_stashed_diagnostic(hir_ty.span, StashKey::ReturnTypeNotation)
+                {
+                    // `let x: i32::something(valid_in_ty_ctxt);` -> `let x = i32::something(valid_in_ty_ctxt);`
+                    // FIXME: Check that `something` is a valid function in `i32`.
+                    let err = tcx
+                        .dcx()
+                        .struct_span_err(
+                            hir_ty.span,
+                            "expected type, found associated function call",
+                        )
+                        .with_span_suggestion_verbose(
+                            stmt.pat.span.between(hir_ty.span),
+                            "use `=` if you meant to assign",
+                            " = ".to_string(),
+                            Applicability::MaybeIncorrect,
+                        );
+                    self.dcx().try_steal_replace_and_emit_err(
+                        hir_ty.span,
+                        StashKey::ReturnTypeNotation,
+                        err,
+                    )
+                } else {
+                    let suggestion = if self
+                        .dcx()
+                        .has_stashed_diagnostic(hir_ty.span, StashKey::ReturnTypeNotation)
+                    {
+                        // We already created a diagnostic complaining that `foo(bar)` is wrong and
+                        // should have been `foo(..)`. Instead, emit only the current error and
+                        // include that prior suggestion. Changes are that the problems go further,
+                        // but keep the suggestion just in case. Either way, we want a single error
+                        // instead of two.
+                        Some(segment.ident.span.shrink_to_hi().with_hi(hir_ty.span.hi()))
+                    } else {
+                        None
+                    };
+                    let err = self
+                        .dcx()
+                        .create_err(BadReturnTypeNotation { span: hir_ty.span, suggestion });
+                    self.dcx().try_steal_replace_and_emit_err(
+                        hir_ty.span,
+                        StashKey::ReturnTypeNotation,
+                        err,
+                    )
+                };
                 Ty::new_error(tcx, guar)
             }
             hir::TyKind::Path(hir::QPath::TypeRelative(hir_self_ty, segment)) => {
diff --git a/tests/ui/suggestions/let-binding-init-expr-as-ty.rs b/tests/ui/suggestions/let-binding-init-expr-as-ty.rs
index 71e5a0c728d6..c108b567b18b 100644
--- a/tests/ui/suggestions/let-binding-init-expr-as-ty.rs
+++ b/tests/ui/suggestions/let-binding-init-expr-as-ty.rs
@@ -1,11 +1,41 @@
-pub fn foo(num: i32) -> i32 {
+fn foo(num: i32) -> i32 {
+    // FIXME: This case doesn't really check that `from_be` is a valid function in `i32`.
     let foo: i32::from_be(num);
     //~^ ERROR expected type, found local variable `num`
-    //~| ERROR argument types not allowed with return type notation
-    //~| ERROR return type notation not allowed in this position yet
+    //~| ERROR expected type, found associated function call
     foo
 }
 
+struct S;
+
+impl S {
+    fn new(_: ()) -> S {
+        S
+    }
+}
+
+// We should still mention that it should be `S::new(..)`, even though rtn is not allowed there:
+struct K(S::new(())); //~ ERROR return type notation not allowed in this position yet
+
+fn bar() {}
+
 fn main() {
     let _ = foo(42);
+    // Associated functions (#134087)
+    let x: Vec::new(); //~ ERROR expected type, found associated function call
+    let x: Vec<()>::new(); //~ ERROR expected type, found associated function call
+    let x: S::new(..); //~ ERROR expected type, found associated function call
+    //~^ ERROR return type notation is experimental
+    let x: S::new(()); //~ ERROR expected type, found associated function call
+
+    // Literals
+    let x: 42; //~ ERROR expected type, found `42`
+    let x: ""; //~ ERROR expected type, found `""`
+
+    // Functions
+    let x: bar(); //~ ERROR expected type, found function `bar`
+    let x: bar; //~ ERROR expected type, found function `bar`
+
+    // Locals
+    let x: x; //~ ERROR expected type, found local variable `x`
 }
diff --git a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
index f0887f85d6ef..354d11976911 100644
--- a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
+++ b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
@@ -1,5 +1,33 @@
+error: expected type, found `42`
+  --> $DIR/let-binding-init-expr-as-ty.rs:32:12
+   |
+LL |     let x: 42;
+   |          - ^^ expected type
+   |          |
+   |          while parsing the type for `x`
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: 42;
+LL +     let x = 42;
+   |
+
+error: expected type, found `""`
+  --> $DIR/let-binding-init-expr-as-ty.rs:33:12
+   |
+LL |     let x: "";
+   |          - ^^ expected type
+   |          |
+   |          while parsing the type for `x`
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: "";
+LL +     let x = "";
+   |
+
 error[E0573]: expected type, found local variable `num`
-  --> $DIR/let-binding-init-expr-as-ty.rs:2:27
+  --> $DIR/let-binding-init-expr-as-ty.rs:3:27
    |
 LL |     let foo: i32::from_be(num);
    |                           ^^^ not a type
@@ -10,27 +38,122 @@ LL -     let foo: i32::from_be(num);
 LL +     let foo = i32::from_be(num);
    |
 
-error: argument types not allowed with return type notation
-  --> $DIR/let-binding-init-expr-as-ty.rs:2:26
+error[E0573]: expected type, found function `bar`
+  --> $DIR/let-binding-init-expr-as-ty.rs:36:12
    |
-LL |     let foo: i32::from_be(num);
-   |                          ^^^^^
+LL |     let x: bar();
+   |            ^^^^^ not a type
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: bar();
+LL +     let x = bar();
+   |
+
+error[E0573]: expected type, found function `bar`
+  --> $DIR/let-binding-init-expr-as-ty.rs:37:12
+   |
+LL |     let x: bar;
+   |            ^^^ not a type
+
+error[E0573]: expected type, found local variable `x`
+  --> $DIR/let-binding-init-expr-as-ty.rs:40:12
+   |
+LL | struct K(S::new(()));
+   | --------------------- similarly named struct `K` defined here
+...
+LL |     let x: x;
+   |            ^
+   |
+help: a struct with a similar name exists
+   |
+LL -     let x: x;
+LL +     let x: K;
+   |
+
+error[E0658]: return type notation is experimental
+  --> $DIR/let-binding-init-expr-as-ty.rs:27:18
+   |
+LL |     let x: S::new(..);
+   |                  ^^^^
    |
    = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
    = help: add `#![feature(return_type_notation)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-help: remove the input types
-   |
-LL -     let foo: i32::from_be(num);
-LL +     let foo: i32::from_be(..);
-   |
 
 error: return type notation not allowed in this position yet
-  --> $DIR/let-binding-init-expr-as-ty.rs:2:14
+  --> $DIR/let-binding-init-expr-as-ty.rs:18:10
+   |
+LL | struct K(S::new(()));
+   |          ^^^^^^^^^^
+   |
+help: furthermore, argument types not allowed with return type notation
+   |
+LL - struct K(S::new(()));
+LL + struct K(S::new(..));
+   |
+
+error: expected type, found associated function call
+  --> $DIR/let-binding-init-expr-as-ty.rs:3:14
    |
 LL |     let foo: i32::from_be(num);
    |              ^^^^^^^^^^^^^^^^^
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let foo: i32::from_be(num);
+LL +     let foo = i32::from_be(num);
+   |
 
-error: aborting due to 3 previous errors
+error: expected type, found associated function call
+  --> $DIR/let-binding-init-expr-as-ty.rs:25:12
+   |
+LL |     let x: Vec::new();
+   |            ^^^^^^^^^^
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: Vec::new();
+LL +     let x = Vec::new();
+   |
 
-For more information about this error, try `rustc --explain E0573`.
+error: expected type, found associated function call
+  --> $DIR/let-binding-init-expr-as-ty.rs:26:12
+   |
+LL |     let x: Vec<()>::new();
+   |            ^^^^^^^^^^^^^^
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: Vec<()>::new();
+LL +     let x = Vec<()>::new();
+   |
+
+error: expected type, found associated function call
+  --> $DIR/let-binding-init-expr-as-ty.rs:27:12
+   |
+LL |     let x: S::new(..);
+   |            ^^^^^^^^^^
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: S::new(..);
+LL +     let x = S::new(..);
+   |
+
+error: expected type, found associated function call
+  --> $DIR/let-binding-init-expr-as-ty.rs:29:12
+   |
+LL |     let x: S::new(());
+   |            ^^^^^^^^^^
+   |
+help: use `=` if you meant to assign
+   |
+LL -     let x: S::new(());
+LL +     let x = S::new(());
+   |
+
+error: aborting due to 13 previous errors
+
+Some errors have detailed explanations: E0573, E0658.
+For more information about an error, try `rustc --explain E0573`.

From 3b27a3660185f7644e1fbf1582637947e36036fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 20 Mar 2026 19:45:29 +0000
Subject: [PATCH 0719/1059] Suggest appropriate spaces around `=` in `let`
 binding parse error

---
 compiler/rustc_parse/src/parser/stmt.rs                     | 6 +++---
 .../recover/recover-colon-instead-of-eq-in-local.stderr     | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 44886de52312..5bd2ca313922 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -1133,11 +1133,11 @@ pub fn parse_full_stmt(
                                 } else {
                                     false
                                 };
-                                if suggest_eq {
+                                if suggest_eq && let Some(ty) = &local.ty {
                                     e.span_suggestion_verbose(
-                                        colon_sp,
+                                        local.pat.span.between(ty.span),
                                         "use `=` if you meant to assign",
-                                        "=",
+                                        " = ",
                                         Applicability::MaybeIncorrect,
                                     );
                                 }
diff --git a/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr b/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
index 8c238c1dd307..94e5d44064f8 100644
--- a/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
+++ b/tests/ui/parser/recover/recover-colon-instead-of-eq-in-local.stderr
@@ -17,7 +17,7 @@ LL |     let _: std::env::temp_dir().join("foo");
 help: use `=` if you meant to assign
    |
 LL -     let _: std::env::temp_dir().join("foo");
-LL +     let _= std::env::temp_dir().join("foo");
+LL +     let _ = std::env::temp_dir().join("foo");
    |
 
 error: aborting due to 2 previous errors

From ee041a376851cf346a53a03c6cee2ceb870bd43b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sat, 21 Mar 2026 01:16:49 +0530
Subject: [PATCH 0720/1059] add without_mappings variant in
 let_expr_needs_paren

---
 .../src/handlers/replace_let_with_if_let.rs            | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
index 55e40d0fe720..6ff5f0bbd30c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_let_with_if_let.rs
@@ -64,11 +64,8 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext<'_>
                     }
                 }
             };
-            let init_expr = if let_expr_needs_paren(&init, &make) {
-                make.expr_paren(init).into()
-            } else {
-                init
-            };
+            let init_expr =
+                if let_expr_needs_paren(&init) { make.expr_paren(init).into() } else { init };
 
             let block = make.block_expr([], None);
             let block = block.indent(IndentLevel::from_node(let_stmt.syntax()));
@@ -88,7 +85,8 @@ pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext<'_>
     )
 }
 
-fn let_expr_needs_paren(expr: &ast::Expr, make: &SyntaxFactory) -> bool {
+fn let_expr_needs_paren(expr: &ast::Expr) -> bool {
+    let make = SyntaxFactory::without_mappings();
     let fake_expr_let = make.expr_let(make.tuple_pat(None).into(), make.expr_unit());
     let Some(fake_expr) = fake_expr_let.expr() else {
         stdx::never!();

From 577dba9093034117b63e4c29147d29ceae1c32c6 Mon Sep 17 00:00:00 2001
From: Daniel Tang <danielzgtg.opensource@gmail.com>
Date: Sun, 15 Mar 2026 22:00:52 -0400
Subject: [PATCH 0721/1059] Skip stack_start_aligned for immediate-abort

This improves startup performance by 16%, shown by an optimized
hello-world program. glibc's `pthread_getattr_np` performs expensive
syscalls when reading `/proc/self/maps`. That is all wasted with
`panic = immediate-abort` active because `init()` immediately discards
the return value from `install_main_guard()`. A similar improvement can
be seen in environments that don't have `/proc`. This change is safe
because the immediately succeeding comment says that we rely on Linux's
"own stack-guard mechanism".
---
 library/std/src/sys/pal/unix/stack_overflow.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 632f619655b3..5d53de7fb7e2 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -429,6 +429,11 @@ unsafe fn install_main_guard() -> Option<Range<usize>> {
 
     #[forbid(unsafe_op_in_unsafe_fn)]
     unsafe fn install_main_guard_linux(page_size: usize) -> Option<Range<usize>> {
+        // See the corresponding conditional in init().
+        // Avoid stack_start_aligned, which makes slow syscalls to read /proc/self/maps
+        if cfg!(panic = "immediate-abort") {
+            return None;
+        }
         // Linux doesn't allocate the whole stack right away, and
         // the kernel has its own stack-guard mechanism to fault
         // when growing too close to an existing mapping. If we map
@@ -456,6 +461,10 @@ unsafe fn install_main_guard_linux_musl(_page_size: usize) -> Option<Range<usize
     #[forbid(unsafe_op_in_unsafe_fn)]
     #[cfg(target_os = "freebsd")]
     unsafe fn install_main_guard_freebsd(page_size: usize) -> Option<Range<usize>> {
+        // See the corresponding conditional in install_main_guard_linux().
+        if cfg!(panic = "immediate-abort") {
+            return None;
+        }
         // FreeBSD's stack autogrows, and optionally includes a guard page
         // at the bottom. If we try to remap the bottom of the stack
         // ourselves, FreeBSD's guard page moves upwards. So we'll just use
@@ -489,6 +498,10 @@ unsafe fn install_main_guard_freebsd(page_size: usize) -> Option<Range<usize>> {
 
     #[forbid(unsafe_op_in_unsafe_fn)]
     unsafe fn install_main_guard_bsds(page_size: usize) -> Option<Range<usize>> {
+        // See the corresponding conditional in install_main_guard_linux().
+        if cfg!(panic = "immediate-abort") {
+            return None;
+        }
         // OpenBSD stack already includes a guard page, and stack is
         // immutable.
         // NetBSD stack includes the guard page.

From e897b4ea51835a9fae8bb12766363e7b55b41838 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Fri, 20 Mar 2026 20:56:17 +0100
Subject: [PATCH 0722/1059] tests/ui/async-await/drop-option-future.rs: New
 regression test

The test began compiling with `nightly-2022-11-25`, and more
specifically 9f36f988ad873f5. The test fails to compile with
`nightly-2022-11-24`:

    $ rustc +nightly-2022-11-24 --edition 2018 tests/ui/async-await/drop-option-future.rs
    error[E0597]: `value` does not live long enough
      --> tests/ui/async-await/drop-option-future.rs:12:22
       |
    12 |     f = Some(async { value });
       |                    --^^^^^--
       |                    | |
       |                    | borrowed value does not live long enough
       |                    value captured here by generator
    13 |     core::mem::drop(f);
    14 | }
       | -
       | |
       | `value` dropped here while still borrowed
       | borrow might be used here, when `f` is dropped and runs the destructor for type `Option<impl Future<Output = i32>>`

The fix 9f36f988ad873f5 does not appear to affect or include a
regression test for our issue, so let's add that test.
---
 tests/ui/async-await/drop-option-future.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 tests/ui/async-await/drop-option-future.rs

diff --git a/tests/ui/async-await/drop-option-future.rs b/tests/ui/async-await/drop-option-future.rs
new file mode 100644
index 000000000000..155b1d76e44a
--- /dev/null
+++ b/tests/ui/async-await/drop-option-future.rs
@@ -0,0 +1,16 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/98077>.
+
+//@ edition:2018
+//@ check-pass
+
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+
+async fn foo() {
+    let mut f = None;
+    let value = 0;
+    f = Some(async { value });
+    core::mem::drop(f);
+}
+
+fn main() { }

From a3409fecfa70ece02f00e6f9796b9a0820b2121a Mon Sep 17 00:00:00 2001
From: Aryan Dubey <aryandubey@umass.edu>
Date: Fri, 20 Mar 2026 16:49:33 -0400
Subject: [PATCH 0723/1059] Move issue-52049 to tests/ui/borrowck

---
 .../issue-52049.rs => borrowck/non-promotable-static-ref.rs}    | 0
 .../non-promotable-static-ref.stderr}                           | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename tests/ui/{issues/issue-52049.rs => borrowck/non-promotable-static-ref.rs} (100%)
 rename tests/ui/{issues/issue-52049.stderr => borrowck/non-promotable-static-ref.stderr} (90%)

diff --git a/tests/ui/issues/issue-52049.rs b/tests/ui/borrowck/non-promotable-static-ref.rs
similarity index 100%
rename from tests/ui/issues/issue-52049.rs
rename to tests/ui/borrowck/non-promotable-static-ref.rs
diff --git a/tests/ui/issues/issue-52049.stderr b/tests/ui/borrowck/non-promotable-static-ref.stderr
similarity index 90%
rename from tests/ui/issues/issue-52049.stderr
rename to tests/ui/borrowck/non-promotable-static-ref.stderr
index 1d8e136f217b..586e8fb314ea 100644
--- a/tests/ui/issues/issue-52049.stderr
+++ b/tests/ui/borrowck/non-promotable-static-ref.stderr
@@ -1,5 +1,5 @@
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/issue-52049.rs:6:10
+  --> $DIR/non-promotable-static-ref.rs:6:10
    |
 LL |     foo(&unpromotable(5u32));
    |     -----^^^^^^^^^^^^^^^^^^-- temporary value is freed at the end of this statement

From 1eeba934aef84cf5fe94df9b3c1ead8e19f18ff9 Mon Sep 17 00:00:00 2001
From: Aryan Dubey <aryandubey@umass.edu>
Date: Fri, 20 Mar 2026 16:55:28 -0400
Subject: [PATCH 0724/1059] Added the  issue link and a test description for
 non-promotable-static-ref.rs

---
 tests/ui/borrowck/non-promotable-static-ref.rs     | 2 ++
 tests/ui/borrowck/non-promotable-static-ref.stderr | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/ui/borrowck/non-promotable-static-ref.rs b/tests/ui/borrowck/non-promotable-static-ref.rs
index efdcc4493056..44733493ec06 100644
--- a/tests/ui/borrowck/non-promotable-static-ref.rs
+++ b/tests/ui/borrowck/non-promotable-static-ref.rs
@@ -1,3 +1,5 @@
+//Test for https://github.com/rust-lang/rust/issues/52049
+//Tests that a non-promotable temp variable cannot be used as a static reference.
 fn foo(_: &'static u32) {}
 
 fn unpromotable<T>(t: T) -> T { t }
diff --git a/tests/ui/borrowck/non-promotable-static-ref.stderr b/tests/ui/borrowck/non-promotable-static-ref.stderr
index 586e8fb314ea..979b349b7c00 100644
--- a/tests/ui/borrowck/non-promotable-static-ref.stderr
+++ b/tests/ui/borrowck/non-promotable-static-ref.stderr
@@ -1,5 +1,5 @@
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/non-promotable-static-ref.rs:6:10
+  --> $DIR/non-promotable-static-ref.rs:8:10
    |
 LL |     foo(&unpromotable(5u32));
    |     -----^^^^^^^^^^^^^^^^^^-- temporary value is freed at the end of this statement

From 27212bb09d48f5a0f181064a6d646efa93845f4a Mon Sep 17 00:00:00 2001
From: malezjaa <poreba.kris@gmail.com>
Date: Thu, 19 Mar 2026 22:57:59 +0100
Subject: [PATCH 0725/1059] Don't suggest non-deriveable traits for unions.

Don't suggest non-deriveable traits for unions. This also adds enum, struct and union markers to rustc_on_unimplemented
---
 .../src/attributes/diagnostic/mod.rs          |   7 +-
 .../rustc_hir_typeck/src/method/suggest.rs    |   4 +-
 .../traits/on_unimplemented.rs                |   7 +-
 .../src/error_reporting/traits/suggestions.rs |   5 +-
 library/core/src/fmt/mod.rs                   |   3 +-
 ...options_of_the_internal_rustc_attribute.rs |   7 +-
 ...ons_of_the_internal_rustc_attribute.stderr |  64 ++++++----
 tests/ui/on-unimplemented/self-types.rs       |  30 +++++
 tests/ui/on-unimplemented/self-types.stderr   |  69 +++++++++++
 tests/ui/union/union-no-derive-suggestion.rs  |  37 ++++++
 .../union/union-no-derive-suggestion.stderr   | 109 ++++++++++++++++++
 11 files changed, 310 insertions(+), 32 deletions(-)
 create mode 100644 tests/ui/on-unimplemented/self-types.rs
 create mode 100644 tests/ui/on-unimplemented/self-types.stderr
 create mode 100644 tests/ui/union/union-no-derive-suggestion.rs
 create mode 100644 tests/ui/union/union-no-derive-suggestion.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
index 8f114b328448..cd2174561c8b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs
@@ -460,11 +460,12 @@ fn parse_filter(input: Symbol) -> FilterFormatString {
                 // if the integer type has been resolved, to allow targeting all integers.
                 // `"{integer}"` and `"{float}"` come from numerics that haven't been inferred yet,
                 // from the `Display` impl of `InferTy` to be precise.
+                // `"{union|enum|struct}"` is used as a special selector for ADTs.
                 //
                 // Don't try to format these later!
-                Position::ArgumentNamed(arg @ ("integer" | "integral" | "float")) => {
-                    LitOrArg::Lit(Symbol::intern(&format!("{{{arg}}}")))
-                }
+                Position::ArgumentNamed(
+                    arg @ ("integer" | "integral" | "float" | "union" | "enum" | "struct"),
+                ) => LitOrArg::Lit(Symbol::intern(&format!("{{{arg}}}"))),
 
                 Position::ArgumentNamed(arg) => LitOrArg::Arg(Symbol::intern(arg)),
                 Position::ArgumentImplicitlyIs(_) => LitOrArg::Lit(sym::empty_braces),
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 9d496c66f968..893cd025a089 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3460,13 +3460,13 @@ fn consider_suggesting_derives_for_ty(
         let diagnostic_name = self.tcx.get_diagnostic_name(trait_pred.def_id())?;
 
         let can_derive = match diagnostic_name {
+            sym::Copy | sym::Clone => true,
+            _ if adt.is_union() => false,
             sym::Default
             | sym::Eq
             | sym::PartialEq
             | sym::Ord
             | sym::PartialOrd
-            | sym::Clone
-            | sym::Copy
             | sym::Hash
             | sym::Debug => true,
             _ => false,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
index d08e0fa3521b..4ae6584fc2d1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
@@ -124,8 +124,11 @@ pub(crate) fn on_unimplemented_components(
                 }
             }
 
-            if let Some(true) = self_ty.ty_adt_def().map(|def| def.did().is_local()) {
-                crate_local = true;
+            if let Some(adt) = self_ty.ty_adt_def() {
+                if adt.did().is_local() {
+                    crate_local = true;
+                }
+                self_types.push(format!("{{{}}}", adt.descr()))
             }
 
             // Allow targeting all integers using `{integral}`, even if the exact type was resolved
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index ee2f8d9783cf..4a6d5eb48f8f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4037,12 +4037,13 @@ pub fn can_suggest_derive(
             _ => return false,
         };
         let is_derivable_trait = match diagnostic_name {
-            sym::Default => !adt.is_enum(),
+            sym::Copy | sym::Clone => true,
+            _ if adt.is_union() => false,
             sym::PartialEq | sym::PartialOrd => {
                 let rhs_ty = trait_pred.skip_binder().trait_ref.args.type_at(1);
                 trait_pred.skip_binder().self_ty() == rhs_ty
             }
-            sym::Eq | sym::Ord | sym::Clone | sym::Copy | sym::Hash | sym::Debug => true,
+            sym::Eq | sym::Ord | sym::Hash | sym::Debug | sym::Default => true,
             _ => false,
         };
         is_derivable_trait &&
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 05d8e0d84f05..ecd1e34078e2 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -1037,9 +1037,10 @@ fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_on_unimplemented(
     on(
-        crate_local,
+        all(crate_local, not(Self = "{union}")),
         note = "add `#[derive(Debug)]` to `{Self}` or manually `impl {This} for {Self}`"
     ),
+    on(all(crate_local, Self = "{union}"), note = "manually `impl {This} for {Self}`"),
     on(
         from_desugaring = "FormatLiteral",
         label = "`{Self}` cannot be formatted using `{{:?}}` because it doesn't implement `{This}`"
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.rs b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.rs
index e64e60f30c0c..09c2a05cd009 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.rs
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.rs
@@ -26,12 +26,15 @@ impl Bar for i32 {}
 // cannot use special rustc_on_unimplement symbols
 // in the format string
 #[diagnostic::on_unimplemented(
-    message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+    message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
     //~^WARN there is no parameter `from_desugaring` on trait `Baz`
     //~|WARN there is no parameter `direct` on trait `Baz`
     //~|WARN there is no parameter `cause` on trait `Baz`
     //~|WARN there is no parameter `integral` on trait `Baz`
     //~|WARN there is no parameter `integer` on trait `Baz`
+    //~|WARN there is no parameter `r#struct` on trait `Baz`
+    //~|WARN there is no parameter `r#enum` on trait `Baz`
+    //~|WARN there is no parameter `union` on trait `Baz`
     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
     //~^WARN there is no parameter `float` on trait `Baz`
     //~|WARN there is no parameter `_Self` on trait `Baz`
@@ -52,5 +55,5 @@ fn main() {
     takes_bar(());
     //~^ERROR the trait bound `(): Bar` is not satisfied
     takes_baz(());
-    //~^ERROR {from_desugaring}{direct}{cause}{integral}{integer}
+    //~^ERROR {from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}
 }
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.stderr
index 862f805e15ba..58d2bdbfc4d6 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.stderr
@@ -9,7 +9,7 @@ LL | #[diagnostic::on_unimplemented(message = "Not allowed to apply it on a impl
 warning: there is no parameter `from_desugaring` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:17
    |
-LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
    |                 ^^^^^^^^^^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
@@ -18,7 +18,7 @@ LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
 warning: there is no parameter `direct` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:34
    |
-LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
    |                                  ^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
@@ -26,7 +26,7 @@ LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
 warning: there is no parameter `cause` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:42
    |
-LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
    |                                          ^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
@@ -34,7 +34,7 @@ LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
 warning: there is no parameter `integral` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:49
    |
-LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
    |                                                 ^^^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
@@ -42,13 +42,37 @@ LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
 warning: there is no parameter `integer` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:59
    |
-LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
    |                                                           ^^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
 
+warning: there is no parameter `r#struct` on trait `Baz`
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:68
+   |
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
+   |                                                                    ^^^^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+
+warning: there is no parameter `r#enum` on trait `Baz`
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:76
+   |
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
+   |                                                                            ^^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+
+warning: there is no parameter `union` on trait `Baz`
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:29:82
+   |
+LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}",
+   |                                                                                  ^^^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+
 warning: there is no parameter `float` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:15
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:15
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |               ^^^^^
@@ -56,7 +80,7 @@ LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    = help: expect either a generic argument name or `{Self}` as format argument
 
 warning: there is no parameter `_Self` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:22
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:22
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |                      ^^^^^
@@ -64,7 +88,7 @@ LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    = help: expect either a generic argument name or `{Self}` as format argument
 
 warning: there is no parameter `crate_local` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:29
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:29
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |                             ^^^^^^^^^^^
@@ -72,7 +96,7 @@ LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    = help: expect either a generic argument name or `{Self}` as format argument
 
 warning: there is no parameter `Trait` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:42
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:42
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |                                          ^^^^^
@@ -80,7 +104,7 @@ LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    = help: expect either a generic argument name or `{Self}` as format argument
 
 warning: there is no parameter `ItemContext` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:49
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:49
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |                                                 ^^^^^^^^^^^
@@ -88,7 +112,7 @@ LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    = help: expect either a generic argument name or `{Self}` as format argument
 
 warning: there is no parameter `This` on trait `Baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:35:62
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:38:62
    |
 LL |     label = "{float}{_Self}{crate_local}{Trait}{ItemContext}{This}"
    |                                                              ^^^^
@@ -129,7 +153,7 @@ LL | #[diagnostic::on_unimplemented = "Message"]
    = help: only `message`, `note` and `label` are allowed as options
 
 error[E0277]: trait has `()` and `i32` as params
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:50:15
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:53:15
    |
 LL |     takes_foo(());
    |     --------- ^^ trait has `()` and `i32` as params
@@ -144,13 +168,13 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo<T> {}
    | ^^^^^^^^^^^^
 note: required by a bound in `takes_foo`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:45:22
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:48:22
    |
 LL | fn takes_foo(_: impl Foo<i32>) {}
    |                      ^^^^^^^^ required by this bound in `takes_foo`
 
 error[E0277]: the trait bound `(): Bar` is not satisfied
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:52:15
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:55:15
    |
 LL |     takes_bar(());
    |     --------- ^^ the trait `Bar` is not implemented for `()`
@@ -163,13 +187,13 @@ help: the trait `Bar` is implemented for `i32`
 LL | impl Bar for i32 {}
    | ^^^^^^^^^^^^^^^^
 note: required by a bound in `takes_bar`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:46:22
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:49:22
    |
 LL | fn takes_bar(_: impl Bar) {}
    |                      ^^^ required by this bound in `takes_bar`
 
-error[E0277]: {from_desugaring}{direct}{cause}{integral}{integer}
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:54:15
+error[E0277]: {from_desugaring}{direct}{cause}{integral}{integer}{struct}{enum}{union}
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:57:15
    |
 LL |     takes_baz(());
    |     --------- ^^ {float}{_Self}{crate_local}{Trait}{ItemContext}{This}
@@ -178,16 +202,16 @@ LL |     takes_baz(());
    |
    = help: the trait `Baz` is not implemented for `()`
 help: this trait has no implementations, consider adding one
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:43:1
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:46:1
    |
 LL | trait Baz {}
    | ^^^^^^^^^
 note: required by a bound in `takes_baz`
-  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:47:22
+  --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:50:22
    |
 LL | fn takes_baz(_: impl Baz) {}
    |                      ^^^ required by this bound in `takes_baz`
 
-error: aborting due to 3 previous errors; 16 warnings emitted
+error: aborting due to 3 previous errors; 19 warnings emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/on-unimplemented/self-types.rs b/tests/ui/on-unimplemented/self-types.rs
new file mode 100644
index 000000000000..736d3baf60c7
--- /dev/null
+++ b/tests/ui/on-unimplemented/self-types.rs
@@ -0,0 +1,30 @@
+#![feature(rustc_attrs)]
+
+#[rustc_on_unimplemented(
+    on(Self = "{union}", message = "union self type"),
+    on(Self = "{enum}", message = "enum self type"),
+    on(Self = "{struct}", message = "struct self type"),
+    message = "fallback self type `{Self}`"
+)]
+trait Trait {}
+
+union Union {
+    value: u8,
+}
+
+enum Enum {
+    Variant,
+}
+
+struct Struct;
+
+fn needs_trait<T: Trait>() {}
+
+fn main() {
+    needs_trait::<Union>();
+    //~^ ERROR union self type
+    needs_trait::<Enum>();
+    //~^ ERROR enum self type
+    needs_trait::<Struct>();
+    //~^ ERROR struct self type
+}
diff --git a/tests/ui/on-unimplemented/self-types.stderr b/tests/ui/on-unimplemented/self-types.stderr
new file mode 100644
index 000000000000..ea40ac566bb9
--- /dev/null
+++ b/tests/ui/on-unimplemented/self-types.stderr
@@ -0,0 +1,69 @@
+error[E0277]: union self type
+  --> $DIR/self-types.rs:24:19
+   |
+LL |     needs_trait::<Union>();
+   |                   ^^^^^ unsatisfied trait bound
+   |
+help: the trait `Trait` is not implemented for `Union`
+  --> $DIR/self-types.rs:11:1
+   |
+LL | union Union {
+   | ^^^^^^^^^^^
+help: this trait has no implementations, consider adding one
+  --> $DIR/self-types.rs:9:1
+   |
+LL | trait Trait {}
+   | ^^^^^^^^^^^
+note: required by a bound in `needs_trait`
+  --> $DIR/self-types.rs:21:19
+   |
+LL | fn needs_trait<T: Trait>() {}
+   |                   ^^^^^ required by this bound in `needs_trait`
+
+error[E0277]: enum self type
+  --> $DIR/self-types.rs:26:19
+   |
+LL |     needs_trait::<Enum>();
+   |                   ^^^^ unsatisfied trait bound
+   |
+help: the trait `Trait` is not implemented for `Enum`
+  --> $DIR/self-types.rs:15:1
+   |
+LL | enum Enum {
+   | ^^^^^^^^^
+help: this trait has no implementations, consider adding one
+  --> $DIR/self-types.rs:9:1
+   |
+LL | trait Trait {}
+   | ^^^^^^^^^^^
+note: required by a bound in `needs_trait`
+  --> $DIR/self-types.rs:21:19
+   |
+LL | fn needs_trait<T: Trait>() {}
+   |                   ^^^^^ required by this bound in `needs_trait`
+
+error[E0277]: struct self type
+  --> $DIR/self-types.rs:28:19
+   |
+LL |     needs_trait::<Struct>();
+   |                   ^^^^^^ unsatisfied trait bound
+   |
+help: the trait `Trait` is not implemented for `Struct`
+  --> $DIR/self-types.rs:19:1
+   |
+LL | struct Struct;
+   | ^^^^^^^^^^^^^
+help: this trait has no implementations, consider adding one
+  --> $DIR/self-types.rs:9:1
+   |
+LL | trait Trait {}
+   | ^^^^^^^^^^^
+note: required by a bound in `needs_trait`
+  --> $DIR/self-types.rs:21:19
+   |
+LL | fn needs_trait<T: Trait>() {}
+   |                   ^^^^^ required by this bound in `needs_trait`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/union/union-no-derive-suggestion.rs b/tests/ui/union/union-no-derive-suggestion.rs
new file mode 100644
index 000000000000..0ccbac3167f2
--- /dev/null
+++ b/tests/ui/union/union-no-derive-suggestion.rs
@@ -0,0 +1,37 @@
+//! Check that we do not suggest using `#[derive(...)]` for unions,
+//! as some traits cannot be autoderived for them.
+//@ dont-require-annotations: NOTE
+
+union U { //~ HELP consider annotating `U` with `#[derive(Clone)]`
+         //~| HELP consider annotating `U` with `#[derive(Copy)]`
+         //~| HELP the trait `Debug` is not implemented for `U`
+         //~| HELP the trait `Default` is not implemented for `U`
+         //~| HELP the trait `Hash` is not implemented for `U`
+    a: u8,
+}
+
+fn x<T: Clone>() {}
+fn y<T: Copy>() {}
+
+fn main() {
+    let u = U { a: 0 };
+    // Debug
+    println!("{u:?}"); //~ ERROR `U` doesn't implement `Debug`
+                       //~| NOTE manually `impl Debug for U`
+    // PartialEq
+    let _ = u == U { a: 0 }; //~ ERROR binary operation `==` cannot be applied to type `U`
+                              //~| NOTE the trait `PartialEq` must be implemented
+    // PartialOrd
+    let _ = u < U { a: 1 }; //~ ERROR binary operation `<` cannot be applied to type `U`
+                             //~| NOTE the trait `PartialOrd` must be implemented
+    // Default
+    let _: U = Default::default(); //~ ERROR the trait bound `U: Default` is not satisfied
+    // Hash
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    std::hash::Hash::hash(&u, &mut h); //~ ERROR the trait bound `U: Hash` is not satisfied
+
+    // Clone
+    x::<U>(); //~ ERROR the trait bound `U: Clone` is not satisfied
+    // Copy
+    y::<U>(); //~ ERROR the trait bound `U: Copy` is not satisfied
+}
diff --git a/tests/ui/union/union-no-derive-suggestion.stderr b/tests/ui/union/union-no-derive-suggestion.stderr
new file mode 100644
index 000000000000..7a42b871b80d
--- /dev/null
+++ b/tests/ui/union/union-no-derive-suggestion.stderr
@@ -0,0 +1,109 @@
+error[E0277]: `U` doesn't implement `Debug`
+  --> $DIR/union-no-derive-suggestion.rs:19:15
+   |
+LL |     println!("{u:?}");
+   |               ^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `Debug`
+   |
+help: the trait `Debug` is not implemented for `U`
+  --> $DIR/union-no-derive-suggestion.rs:5:1
+   |
+LL | union U {
+   | ^^^^^^^
+   = note: manually `impl Debug for U`
+
+error[E0369]: binary operation `==` cannot be applied to type `U`
+  --> $DIR/union-no-derive-suggestion.rs:22:15
+   |
+LL |     let _ = u == U { a: 0 };
+   |             - ^^ ---------- U
+   |             |
+   |             U
+   |
+note: an implementation of `PartialEq` might be missing for `U`
+  --> $DIR/union-no-derive-suggestion.rs:5:1
+   |
+LL | union U {
+   | ^^^^^^^ must implement `PartialEq`
+note: the trait `PartialEq` must be implemented
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+
+error[E0369]: binary operation `<` cannot be applied to type `U`
+  --> $DIR/union-no-derive-suggestion.rs:25:15
+   |
+LL |     let _ = u < U { a: 1 };
+   |             - ^ ---------- U
+   |             |
+   |             U
+   |
+note: an implementation of `PartialOrd` might be missing for `U`
+  --> $DIR/union-no-derive-suggestion.rs:5:1
+   |
+LL | union U {
+   | ^^^^^^^ must implement `PartialOrd`
+note: the trait `PartialOrd` must be implemented
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+
+error[E0277]: the trait bound `U: Default` is not satisfied
+  --> $DIR/union-no-derive-suggestion.rs:28:16
+   |
+LL |     let _: U = Default::default();
+   |                ^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
+   |
+help: the trait `Default` is not implemented for `U`
+  --> $DIR/union-no-derive-suggestion.rs:5:1
+   |
+LL | union U {
+   | ^^^^^^^
+
+error[E0277]: the trait bound `U: Hash` is not satisfied
+  --> $DIR/union-no-derive-suggestion.rs:31:27
+   |
+LL |     std::hash::Hash::hash(&u, &mut h);
+   |     --------------------- ^^ unsatisfied trait bound
+   |     |
+   |     required by a bound introduced by this call
+   |
+help: the trait `Hash` is not implemented for `U`
+  --> $DIR/union-no-derive-suggestion.rs:5:1
+   |
+LL | union U {
+   | ^^^^^^^
+
+error[E0277]: the trait bound `U: Clone` is not satisfied
+  --> $DIR/union-no-derive-suggestion.rs:34:9
+   |
+LL |     x::<U>();
+   |         ^ the trait `Clone` is not implemented for `U`
+   |
+note: required by a bound in `x`
+  --> $DIR/union-no-derive-suggestion.rs:13:9
+   |
+LL | fn x<T: Clone>() {}
+   |         ^^^^^ required by this bound in `x`
+help: consider annotating `U` with `#[derive(Clone)]`
+   |
+LL + #[derive(Clone)]
+LL | union U {
+   |
+
+error[E0277]: the trait bound `U: Copy` is not satisfied
+  --> $DIR/union-no-derive-suggestion.rs:36:9
+   |
+LL |     y::<U>();
+   |         ^ the trait `Copy` is not implemented for `U`
+   |
+note: required by a bound in `y`
+  --> $DIR/union-no-derive-suggestion.rs:14:9
+   |
+LL | fn y<T: Copy>() {}
+   |         ^^^^ required by this bound in `y`
+help: consider annotating `U` with `#[derive(Copy)]`
+   |
+LL + #[derive(Copy)]
+LL | union U {
+   |
+
+error: aborting due to 7 previous errors
+
+Some errors have detailed explanations: E0277, E0369.
+For more information about an error, try `rustc --explain E0277`.

From ab36d506d21287dfe1b8d3f1c70024b6e6af18cf Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 20 Mar 2026 18:48:38 -0400
Subject: [PATCH 0726/1059] Address review comments

---
 .../rustc_attr_parsing/src/attributes/cfg.rs  |  6 ++--
 .../src/attributes/cfg_select.rs              |  4 +--
 compiler/rustc_attr_parsing/src/interface.rs  |  6 ++--
 compiler/rustc_attr_parsing/src/parser.rs     | 35 ++++++++++++-------
 compiler/rustc_builtin_macros/src/cfg.rs      |  7 ++--
 compiler/rustc_expand/src/config.rs           |  7 ++--
 compiler/rustc_expand/src/expand.rs           |  3 +-
 tests/ui/macros/attr-expr.rs                  | 12 ++++++-
 tests/ui/macros/attr-expr.stderr              | 13 ++++++-
 9 files changed, 63 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index c88dff40b2a0..badf696606e9 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -20,7 +20,9 @@
 use thin_vec::ThinVec;
 
 use crate::context::{AcceptContext, ShouldEmit, Stage};
-use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
+use crate::parser::{
+    AllowExprMetavar, ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser,
+};
 use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, CfgAttrBadDelim, MetaBadDelimSugg,
     ParsedDescription,
@@ -363,7 +365,7 @@ fn parse_cfg_attr_internal<'a>(
     let meta = MetaItemOrLitParser::parse_single(
         parser,
         ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
-        true,
+        AllowExprMetavar::Yes,
     )?;
     let pred_span = pred_start.with_hi(parser.token.span.hi());
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
index 96a4437c33a7..f3612afe69e5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
@@ -12,7 +12,7 @@
 use rustc_session::lint::builtin::UNREACHABLE_CFG_SELECT_PREDICATES;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
-use crate::parser::MetaItemOrLitParser;
+use crate::parser::{AllowExprMetavar, MetaItemOrLitParser};
 use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
 
 #[derive(Clone)]
@@ -94,7 +94,7 @@ pub fn parse_cfg_select(
             let meta = MetaItemOrLitParser::parse_single(
                 p,
                 ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
-                true,
+                AllowExprMetavar::Yes,
             )
             .map_err(|diag| diag.emit())?;
             let cfg_span = meta.span();
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index a9e2bd3aa184..fa66dec6a156 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -14,7 +14,7 @@
 
 use crate::context::{AcceptContext, FinalizeContext, FinalizeFn, SharedContext, Stage};
 use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
-use crate::parser::{ArgParser, PathParser, RefPathParser};
+use crate::parser::{AllowExprMetavar, ArgParser, PathParser, RefPathParser};
 use crate::session_diagnostics::ParsedDescription;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
 
@@ -139,7 +139,7 @@ pub fn parse_single<T>(
         emit_errors: ShouldEmit,
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser) -> Option<T>,
         template: &AttributeTemplate,
-        allow_expr_metavar: bool,
+        allow_expr_metavar: AllowExprMetavar,
     ) -> Option<T> {
         let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
             panic!("parse_single called on a doc attr")
@@ -335,7 +335,7 @@ pub fn parse_attribute_list(
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
-                            false,
+                            AllowExprMetavar::No,
                         ) else {
                             continue;
                         };
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index ee77a1a9f9cd..79cb98916ed6 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -109,7 +109,7 @@ pub fn from_attr_args<'sess>(
         parts: &[Symbol],
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
-        allow_expr_metavar: bool,
+        allow_expr_metavar: AllowExprMetavar,
     ) -> Option<Self> {
         Some(match value {
             AttrArgs::Empty => Self::NoArgs,
@@ -225,7 +225,7 @@ impl MetaItemOrLitParser {
     pub fn parse_single<'sess>(
         parser: &mut Parser<'sess>,
         should_emit: ShouldEmit,
-        allow_expr_metavar: bool,
+        allow_expr_metavar: AllowExprMetavar,
     ) -> PResult<'sess, MetaItemOrLitParser> {
         let mut this = MetaItemListParserContext { parser, should_emit, allow_expr_metavar };
         this.parse_meta_item_inner()
@@ -413,10 +413,19 @@ fn expr_to_lit<'sess>(
     }
 }
 
+/// Whether expansions of `expr` metavariables from decrarative macros
+/// are permitted. Used when parsing meta items; currently, only `cfg` predicates
+/// enable this option
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum AllowExprMetavar {
+    No,
+    Yes,
+}
+
 struct MetaItemListParserContext<'a, 'sess> {
     parser: &'a mut Parser<'sess>,
     should_emit: ShouldEmit,
-    allow_expr_metavar: bool,
+    allow_expr_metavar: AllowExprMetavar,
 }
 
 impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
@@ -457,25 +466,25 @@ fn unsuffixed_meta_item_from_lit(
         Ok(lit)
     }
 
-    fn parse_attr_item(&mut self) -> PResult<'sess, MetaItemParser> {
+    fn parse_meta_item(&mut self) -> PResult<'sess, MetaItemParser> {
         if let Some(metavar) = self.parser.token.is_metavar_seq() {
-            match metavar {
-                kind @ MetaVarKind::Expr { .. } if self.allow_expr_metavar => {
+            match (metavar, self.allow_expr_metavar) {
+                (kind @ MetaVarKind::Expr { .. }, AllowExprMetavar::Yes) => {
                     return self
                         .parser
                         .eat_metavar_seq(kind, |this| {
                             MetaItemListParserContext {
                                 parser: this,
                                 should_emit: self.should_emit,
-                                allow_expr_metavar: true,
+                                allow_expr_metavar: AllowExprMetavar::Yes,
                             }
-                            .parse_attr_item()
+                            .parse_meta_item()
                         })
                         .ok_or_else(|| {
                             self.parser.unexpected_any::<core::convert::Infallible>().unwrap_err()
                         });
                 }
-                MetaVarKind::Meta { has_meta_form } => {
+                (MetaVarKind::Meta { has_meta_form }, _) => {
                     return if has_meta_form {
                         let attr_item = self
                             .parser
@@ -485,7 +494,7 @@ fn parse_attr_item(&mut self) -> PResult<'sess, MetaItemParser> {
                                     should_emit: self.should_emit,
                                     allow_expr_metavar: self.allow_expr_metavar,
                                 }
-                                .parse_attr_item()
+                                .parse_meta_item()
                             })
                             .unwrap();
                         Ok(attr_item)
@@ -530,7 +539,7 @@ fn parse_meta_item_inner(&mut self) -> PResult<'sess, MetaItemOrLitParser> {
             Ok(MetaItemOrLitParser::Lit(self.unsuffixed_meta_item_from_lit(token_lit)?))
         } else {
             let prev_pros = self.parser.approx_token_stream_pos();
-            match self.parse_attr_item() {
+            match self.parse_meta_item() {
                 Ok(item) => Ok(MetaItemOrLitParser::MetaItemParser(item)),
                 Err(err) => {
                     // If `parse_attr_item` made any progress, it likely has a more precise error we should prefer
@@ -618,7 +627,7 @@ fn parse(
         psess: &'sess ParseSess,
         span: Span,
         should_emit: ShouldEmit,
-        allow_expr_metavar: bool,
+        allow_expr_metavar: AllowExprMetavar,
     ) -> PResult<'sess, MetaItemListParser> {
         let mut parser = Parser::new(psess, tokens, None);
         if let ShouldEmit::ErrorsAndLints { recovery } = should_emit {
@@ -658,7 +667,7 @@ pub(crate) fn new<'sess>(
         span: Span,
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
-        allow_expr_metavar: bool,
+        allow_expr_metavar: AllowExprMetavar,
     ) -> Result<Self, Diag<'sess>> {
         MetaItemListParserContext::parse(
             tokens.clone(),
diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs
index cdd556388064..c4a458089f2d 100644
--- a/compiler/rustc_builtin_macros/src/cfg.rs
+++ b/compiler/rustc_builtin_macros/src/cfg.rs
@@ -4,10 +4,9 @@
 
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrStyle, token};
-use rustc_attr_parsing as attr;
-use rustc_attr_parsing::parser::MetaItemOrLitParser;
+use rustc_attr_parsing::parser::{AllowExprMetavar, MetaItemOrLitParser};
 use rustc_attr_parsing::{
-    AttributeParser, CFG_TEMPLATE, ParsedDescription, ShouldEmit, parse_cfg_entry,
+    self as attr, AttributeParser, CFG_TEMPLATE, ParsedDescription, ShouldEmit, parse_cfg_entry,
 };
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_hir::attrs::CfgEntry;
@@ -44,7 +43,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
     let meta = MetaItemOrLitParser::parse_single(
         &mut parser,
         ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
-        true,
+        AllowExprMetavar::Yes,
     )
     .map_err(|diag| diag.emit())?;
     let cfg = AttributeParser::parse_single_args(
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 367fadaea757..ec5951e50e3a 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -10,9 +10,10 @@
     self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, DUMMY_NODE_ID, EarlyParsedAttribute,
     HasAttrs, HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
 };
-use rustc_attr_parsing as attr;
+use rustc_attr_parsing::parser::AllowExprMetavar;
 use rustc_attr_parsing::{
-    AttributeParser, CFG_TEMPLATE, EvalConfigResult, ShouldEmit, eval_config_entry, parse_cfg,
+    self as attr, AttributeParser, CFG_TEMPLATE, EvalConfigResult, ShouldEmit, eval_config_entry,
+    parse_cfg,
 };
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_errors::msg;
@@ -402,7 +403,7 @@ pub(crate) fn cfg_true(&self, attr: &Attribute, emit_errors: ShouldEmit) -> Eval
             emit_errors,
             parse_cfg,
             &CFG_TEMPLATE,
-            true,
+            AllowExprMetavar::Yes,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index db08790364c6..640d0746fe1a 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -13,6 +13,7 @@
     TyKind, token,
 };
 use rustc_ast_pretty::pprust;
+use rustc_attr_parsing::parser::AllowExprMetavar;
 use rustc_attr_parsing::{
     AttributeParser, CFG_TEMPLATE, Early, EvalConfigResult, ShouldEmit, eval_config_entry,
     parse_cfg, validate_attr,
@@ -2224,7 +2225,7 @@ fn expand_cfg_true(
             ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             parse_cfg,
             &CFG_TEMPLATE,
-            true,
+            AllowExprMetavar::Yes,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;
diff --git a/tests/ui/macros/attr-expr.rs b/tests/ui/macros/attr-expr.rs
index d2f5f5d184d6..a2bee8728ac5 100644
--- a/tests/ui/macros/attr-expr.rs
+++ b/tests/ui/macros/attr-expr.rs
@@ -3,7 +3,17 @@ macro_rules! foo {
         #[$e]
         //~^ ERROR expected identifier, found metavariable
         fn foo() {}
-    }
+    };
 }
 foo!(inline);
+
+macro_rules! bar {
+    ($e:expr) => {
+        #[inline($e)]
+        //~^ ERROR expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found `expr` metavariable
+        fn bar() {}
+    };
+}
+bar!(always);
+
 fn main() {}
diff --git a/tests/ui/macros/attr-expr.stderr b/tests/ui/macros/attr-expr.stderr
index 034f116d017d..eaad41c44fb9 100644
--- a/tests/ui/macros/attr-expr.stderr
+++ b/tests/ui/macros/attr-expr.stderr
@@ -9,5 +9,16 @@ LL | foo!(inline);
    |
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 1 previous error
+error: expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found `expr` metavariable
+  --> $DIR/attr-expr.rs:12:18
+   |
+LL |         #[inline($e)]
+   |                  ^^
+...
+LL | bar!(always);
+   | ------------ in this macro invocation
+   |
+   = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
 

From 3ad92c9f23253aaae65174c84b2edae341762e8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 21 Mar 2026 02:24:36 +0000
Subject: [PATCH 0727/1059] On E0277 tweak help when single type impls traits

When encountering an unmet predicate, when we point at the trait impls that do exist, if they are all for the same self type, tweak the wording to make it less verbose.
---
 .../traits/fulfillment_errors.rs              | 48 ++++++++++++++++---
 .../multiple-dep-versions.stderr              |  6 +--
 .../ui/const-generics/exhaustive-value.stderr | 18 +++----
 ...e-21659-show-relevant-trait-impls-1.stderr |  6 +--
 ...e-21659-show-relevant-trait-impls-2.stderr | 14 +++---
 .../issue-39802-show-5-trait-impls.stderr     | 36 +++++++-------
 tests/ui/indexing/index-help.stderr           |  6 +--
 .../indexing/indexing-integral-types.stderr   | 48 +++++++++----------
 .../indexing/indexing-requires-a-uint.stderr  |  6 +--
 .../invalid-iterator-chain-fixable.stderr     | 18 +++----
 ...valid-iterator-chain-with-int-infer.stderr |  6 +--
 .../iterators/invalid-iterator-chain.stderr   | 30 ++++++------
 .../trailing-where-clause.stderr              | 14 +++---
 tests/ui/on-unimplemented/slice-index.stderr  | 14 +++---
 .../suggest_tuple_wrap_root_obligation.rs     |  2 +-
 .../suggest_tuple_wrap_root_obligation.stderr |  8 ++--
 tests/ui/on-unimplemented/sum.stderr          | 12 ++---
 tests/ui/str/str-idx.stderr                   | 18 +++----
 tests/ui/str/str-mut-idx.stderr               | 18 +++----
 ...t-suggest-borrowing-existing-borrow.stderr | 14 +++---
 tests/ui/suggestions/into-str.stderr          | 14 +++---
 .../partialeq_suggest_swap_on_e0277.stderr    | 18 +++----
 ...stion-when-stmt-and-expr-span-equal.stderr | 18 +++----
 .../suggest-dereferencing-index.stderr        |  6 +--
 tests/ui/traits/explicit-reference-cast.rs    |  2 +-
 .../ui/traits/explicit-reference-cast.stderr  |  6 +--
 .../repeated-supertrait-ambig.stderr          | 18 +++----
 ...rced_ambiguity-use-head-maybe-cause.stderr |  2 +-
 .../cycles/inductive-cycle-but-err.stderr     |  2 +-
 ...valuated-const-impl-trait-ref.fails.stderr |  6 +--
 .../question-mark-result-err-mismatch.rs      |  2 +-
 .../question-mark-result-err-mismatch.stderr  | 14 +++---
 .../traits/question-mark-span-144304.stderr   | 24 +++++-----
 tests/ui/try-trait/bad-interconversion.stderr |  6 +--
 .../constrain_in_projection2.current.stderr   | 12 ++---
 .../nested-tait-inference2.current.stderr     |  6 +--
 tests/ui/typeck/issue-90101.stderr            | 12 ++---
 37 files changed, 272 insertions(+), 238 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 6bf08170bcf7..eeccf1eb0ecf 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -2299,6 +2299,11 @@ pub(super) fn report_similar_impl_candidates(
             // FIXME: this could use a better heuristic, like just checking
             // that args[1..] is the same.
             let all_traits_equal = traits.len() == 1;
+            let mut types: Vec<_> =
+                candidates.iter().map(|(c, _)| c.self_ty().to_string()).collect();
+            types.sort();
+            types.dedup();
+            let all_types_equal = types.len() == 1;
 
             let end = if candidates.len() <= 9 || self.tcx.sess.opts.verbose {
                 candidates.len()
@@ -2312,6 +2317,11 @@ pub(super) fn report_similar_impl_candidates(
                 for (c, def_id) in &candidates {
                     let msg = if all_traits_equal {
                         format!("`{}`", self.tcx.short_string(c.self_ty(), err.long_ty_path()))
+                    } else if all_types_equal {
+                        format!(
+                            "`{}`",
+                            self.tcx.short_string(c.print_only_trait_path(), err.long_ty_path())
+                        )
                     } else {
                         format!(
                             "`{}` implements `{}`",
@@ -2321,13 +2331,19 @@ pub(super) fn report_similar_impl_candidates(
                     };
                     span.push_span_label(self.tcx.def_span(*def_id), msg);
                 }
-                err.span_help(
-                    span,
+                let msg = if all_types_equal {
+                    format!(
+                        "`{}` implements trait `{}`",
+                        self.tcx.short_string(candidates[0].0.self_ty(), err.long_ty_path()),
+                        self.tcx.short_string(trait_ref.print_trait_sugared(), err.long_ty_path()),
+                    )
+                } else {
                     format!(
                         "the following {other}types implement trait `{}`",
-                        trait_ref.print_trait_sugared(),
-                    ),
-                );
+                        self.tcx.short_string(trait_ref.print_trait_sugared(), err.long_ty_path()),
+                    )
+                };
+                err.span_help(span, msg);
             } else {
                 let candidate_names: Vec<String> = candidates
                     .iter()
@@ -2337,6 +2353,12 @@ pub(super) fn report_similar_impl_candidates(
                                 "\n  {}",
                                 self.tcx.short_string(c.self_ty(), err.long_ty_path())
                             )
+                        } else if all_types_equal {
+                            format!(
+                                "\n  {}",
+                                self.tcx
+                                    .short_string(c.print_only_trait_path(), err.long_ty_path())
+                            )
                         } else {
                             format!(
                                 "\n  `{}` implements `{}`",
@@ -2347,9 +2369,21 @@ pub(super) fn report_similar_impl_candidates(
                         }
                     })
                     .collect();
+                let msg = if all_types_equal {
+                    format!(
+                        "`{}` implements trait `{}`",
+                        self.tcx.short_string(candidates[0].0.self_ty(), err.long_ty_path()),
+                        self.tcx.short_string(trait_ref.print_trait_sugared(), err.long_ty_path()),
+                    )
+                } else {
+                    format!(
+                        "the following {other}types implement trait `{}`",
+                        self.tcx.short_string(trait_ref.print_trait_sugared(), err.long_ty_path()),
+                    )
+                };
+
                 err.help(format!(
-                    "the following {other}types implement trait `{}`:{}{}",
-                    trait_ref.print_trait_sugared(),
+                    "{msg}:{}{}",
                     candidate_names[..end].join(""),
                     if candidates.len() > 9 && !self.tcx.sess.opts.verbose {
                         format!("\nand {} others", candidates.len() - 8)
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.stderr b/tests/run-make/crate-loading/multiple-dep-versions.stderr
index ef7fb7082266..a683fdd389c6 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.stderr
+++ b/tests/run-make/crate-loading/multiple-dep-versions.stderr
@@ -177,14 +177,14 @@ LL |     Err(Error2)?;
    |     this can't be annotated with `?` because it has type `Result<_, Error2>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-help: the following other types implement trait `From<T>`
+help: `dependency::OtherError` implements trait `From<T>`
   --> replaced
    |
 LL | impl From<()> for OtherError {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dependency::OtherError` implements `From<()>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<()>`
 ...
 LL | impl From<i32> for OtherError {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dependency::OtherError` implements `From<i32>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<i32>`
    = note: there are multiple different versions of crate `dependency` in the dependency graph
    = help: you can use `cargo tree` to explore your dependency tree
 
diff --git a/tests/ui/const-generics/exhaustive-value.stderr b/tests/ui/const-generics/exhaustive-value.stderr
index 791bb19ffe86..3377f4cc4e11 100644
--- a/tests/ui/const-generics/exhaustive-value.stderr
+++ b/tests/ui/const-generics/exhaustive-value.stderr
@@ -4,15 +4,15 @@ error[E0277]: the trait bound `(): Foo<N>` is not satisfied
 LL |     <() as Foo<N>>::test()
    |      ^^ the trait `Foo<N>` is not implemented for `()`
    |
-   = help: the following other types implement trait `Foo<N>`:
-             `()` implements `Foo<0>`
-             `()` implements `Foo<100>`
-             `()` implements `Foo<101>`
-             `()` implements `Foo<102>`
-             `()` implements `Foo<103>`
-             `()` implements `Foo<104>`
-             `()` implements `Foo<105>`
-             `()` implements `Foo<106>`
+   = help: `()` implements trait `Foo<N>`:
+             Foo<0>
+             Foo<100>
+             Foo<101>
+             Foo<102>
+             Foo<103>
+             Foo<104>
+             Foo<105>
+             Foo<106>
            and 248 others
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
index 4a38546e2a88..0c07e5afb671 100644
--- a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
+++ b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
@@ -11,14 +11,14 @@ help: the trait `Foo<usize>` is not implemented for `Bar`
    |
 LL | struct Bar;
    | ^^^^^^^^^^
-help: the following other types implement trait `Foo<A>`
+help: `Bar` implements trait `Foo<A>`
   --> $DIR/issue-21659-show-relevant-trait-impls-1.rs:15:1
    |
 LL | impl Foo<i32> for Bar {}
-   | ^^^^^^^^^^^^^^^^^^^^^ `Bar` implements `Foo<i32>`
+   | ^^^^^^^^^^^^^^^^^^^^^ `Foo<i32>`
 LL |
 LL | impl Foo<u8> for Bar {}
-   | ^^^^^^^^^^^^^^^^^^^^ `Bar` implements `Foo<u8>`
+   | ^^^^^^^^^^^^^^^^^^^^ `Foo<u8>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
index 8d1c05e7b544..cb4ca9082b44 100644
--- a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
+++ b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
@@ -11,13 +11,13 @@ help: the trait `Foo<usize>` is not implemented for `Bar`
    |
 LL | struct Bar;
    | ^^^^^^^^^^
-   = help: the following other types implement trait `Foo<A>`:
-             `Bar` implements `Foo<i16>`
-             `Bar` implements `Foo<i32>`
-             `Bar` implements `Foo<i8>`
-             `Bar` implements `Foo<u16>`
-             `Bar` implements `Foo<u32>`
-             `Bar` implements `Foo<u8>`
+   = help: `Bar` implements trait `Foo<A>`:
+             Foo<i16>
+             Foo<i32>
+             Foo<i8>
+             Foo<u16>
+             Foo<u32>
+             Foo<u8>
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/issue-39802-show-5-trait-impls.stderr b/tests/ui/did_you_mean/issue-39802-show-5-trait-impls.stderr
index 8bacae9e96a7..4bb816bdb80e 100644
--- a/tests/ui/did_you_mean/issue-39802-show-5-trait-impls.stderr
+++ b/tests/ui/did_you_mean/issue-39802-show-5-trait-impls.stderr
@@ -6,12 +6,12 @@ LL |     Foo::<i32>::bar(&1i8);
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the following other types implement trait `Foo<B>`:
-             `i8` implements `Foo<bool>`
-             `i8` implements `Foo<u16>`
-             `i8` implements `Foo<u32>`
-             `i8` implements `Foo<u64>`
-             `i8` implements `Foo<u8>`
+   = help: `i8` implements trait `Foo<B>`:
+             Foo<bool>
+             Foo<u16>
+             Foo<u32>
+             Foo<u64>
+             Foo<u8>
 
 error[E0277]: the trait bound `u8: Foo<i32>` is not satisfied
   --> $DIR/issue-39802-show-5-trait-impls.rs:25:21
@@ -21,17 +21,17 @@ LL |     Foo::<i32>::bar(&1u8);
    |     |
    |     required by a bound introduced by this call
    |
-help: the following other types implement trait `Foo<B>`
+help: `u8` implements trait `Foo<B>`
   --> $DIR/issue-39802-show-5-trait-impls.rs:11:1
    |
 LL | impl Foo<u16> for u8 {}
-   | ^^^^^^^^^^^^^^^^^^^^ `u8` implements `Foo<u16>`
+   | ^^^^^^^^^^^^^^^^^^^^ `Foo<u16>`
 LL | impl Foo<u32> for u8 {}
-   | ^^^^^^^^^^^^^^^^^^^^ `u8` implements `Foo<u32>`
+   | ^^^^^^^^^^^^^^^^^^^^ `Foo<u32>`
 LL | impl Foo<u64> for u8 {}
-   | ^^^^^^^^^^^^^^^^^^^^ `u8` implements `Foo<u64>`
+   | ^^^^^^^^^^^^^^^^^^^^ `Foo<u64>`
 LL | impl Foo<bool> for u8 {}
-   | ^^^^^^^^^^^^^^^^^^^^^ `u8` implements `Foo<bool>`
+   | ^^^^^^^^^^^^^^^^^^^^^ `Foo<bool>`
 
 error[E0277]: the trait bound `bool: Foo<i32>` is not satisfied
   --> $DIR/issue-39802-show-5-trait-impls.rs:26:21
@@ -41,13 +41,13 @@ LL |     Foo::<i32>::bar(&true);
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the following other types implement trait `Foo<B>`:
-             `bool` implements `Foo<bool>`
-             `bool` implements `Foo<i8>`
-             `bool` implements `Foo<u16>`
-             `bool` implements `Foo<u32>`
-             `bool` implements `Foo<u64>`
-             `bool` implements `Foo<u8>`
+   = help: `bool` implements trait `Foo<B>`:
+             Foo<bool>
+             Foo<i8>
+             Foo<u16>
+             Foo<u32>
+             Foo<u64>
+             Foo<u8>
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/indexing/index-help.stderr b/tests/ui/indexing/index-help.stderr
index 8fc91c1bf395..65faaec41258 100644
--- a/tests/ui/indexing/index-help.stderr
+++ b/tests/ui/indexing/index-help.stderr
@@ -5,13 +5,13 @@ LL |     x[0i32];
    |       ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[{integer}]>` is not implemented for `i32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `Vec<{integer}>` to implement `Index<i32>`
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/indexing/indexing-integral-types.stderr b/tests/ui/indexing/indexing-integral-types.stderr
index 3dfc5f5e26e0..604161325afc 100644
--- a/tests/ui/indexing/indexing-integral-types.stderr
+++ b/tests/ui/indexing/indexing-integral-types.stderr
@@ -5,13 +5,13 @@ LL |     v[3u8];
    |       ^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[isize]>` is not implemented for `u8`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `Vec<isize>` to implement `Index<u8>`
 
 error[E0277]: the type `[isize]` cannot be indexed by `i8`
@@ -21,13 +21,13 @@ LL |     v[3i8];
    |       ^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[isize]>` is not implemented for `i8`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `Vec<isize>` to implement `Index<i8>`
 
 error[E0277]: the type `[isize]` cannot be indexed by `u32`
@@ -37,13 +37,13 @@ LL |     v[3u32];
    |       ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[isize]>` is not implemented for `u32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `Vec<isize>` to implement `Index<u32>`
 
 error[E0277]: the type `[isize]` cannot be indexed by `i32`
@@ -53,13 +53,13 @@ LL |     v[3i32];
    |       ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[isize]>` is not implemented for `i32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `Vec<isize>` to implement `Index<i32>`
 
 error[E0277]: the type `[u8]` cannot be indexed by `u8`
@@ -69,13 +69,13 @@ LL |     s.as_bytes()[3u8];
    |                  ^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[u8]>` is not implemented for `u8`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[u8]` to implement `Index<u8>`
 
 error[E0277]: the type `[u8]` cannot be indexed by `i8`
@@ -85,13 +85,13 @@ LL |     s.as_bytes()[3i8];
    |                  ^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[u8]>` is not implemented for `i8`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[u8]` to implement `Index<i8>`
 
 error[E0277]: the type `[u8]` cannot be indexed by `u32`
@@ -101,13 +101,13 @@ LL |     s.as_bytes()[3u32];
    |                  ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[u8]>` is not implemented for `u32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[u8]` to implement `Index<u32>`
 
 error[E0277]: the type `[u8]` cannot be indexed by `i32`
@@ -117,13 +117,13 @@ LL |     s.as_bytes()[3i32];
    |                  ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[u8]>` is not implemented for `i32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[u8]` to implement `Index<i32>`
 
 error: aborting due to 8 previous errors
diff --git a/tests/ui/indexing/indexing-requires-a-uint.stderr b/tests/ui/indexing/indexing-requires-a-uint.stderr
index e5f9f7854f7b..9e974c8c9bbc 100644
--- a/tests/ui/indexing/indexing-requires-a-uint.stderr
+++ b/tests/ui/indexing/indexing-requires-a-uint.stderr
@@ -5,13 +5,13 @@ LL |     [0][0u8];
    |         ^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[{integer}]>` is not implemented for `u8`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[{integer}]` to implement `Index<u8>`
 
 error[E0308]: mismatched types
diff --git a/tests/ui/iterators/invalid-iterator-chain-fixable.stderr b/tests/ui/iterators/invalid-iterator-chain-fixable.stderr
index 99bff6b450b5..f22fc2143edf 100644
--- a/tests/ui/iterators/invalid-iterator-chain-fixable.stderr
+++ b/tests/ui/iterators/invalid-iterator-chain-fixable.stderr
@@ -33,13 +33,13 @@ LL |     println!("{}", scores.sum::<i32>());
    |                           required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -74,13 +74,13 @@ LL |             .sum::<i32>(),
    |              required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -115,13 +115,13 @@ LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
    |                                                      required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
diff --git a/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr b/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
index c94b716e3131..82269f6253a3 100644
--- a/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
+++ b/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
@@ -7,13 +7,13 @@ LL |     let x = Some(()).iter().map(|()| 1).sum::<f32>();
    |                                         required by a bound introduced by this call
    |
    = help: the trait `Sum<{integer}>` is not implemented for `f32`
-help: the following other types implement trait `Sum<A>`
+help: `f32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `f32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `f32` implements `Sum<&f32>`
+   = note: `Sum<&f32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
diff --git a/tests/ui/iterators/invalid-iterator-chain.stderr b/tests/ui/iterators/invalid-iterator-chain.stderr
index 7f0c154e255a..d58fe438a627 100644
--- a/tests/ui/iterators/invalid-iterator-chain.stderr
+++ b/tests/ui/iterators/invalid-iterator-chain.stderr
@@ -33,13 +33,13 @@ LL |     println!("{}", scores.sum::<i32>());
    |                           required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -73,13 +73,13 @@ LL |             .sum::<i32>(),
    |              required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -120,13 +120,13 @@ LL |             .sum::<i32>(),
    |              required by a bound introduced by this call
    |
    = help: the trait `Sum<f64>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -158,13 +158,13 @@ LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
    |                                                      required by a bound introduced by this call
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -194,13 +194,13 @@ LL |     println!("{}", vec![(), ()].iter().sum::<i32>());
    |                                        required by a bound introduced by this call
    |
    = help: the trait `Sum<&()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
diff --git a/tests/ui/lazy-type-alias/trailing-where-clause.stderr b/tests/ui/lazy-type-alias/trailing-where-clause.stderr
index 93cd3145928b..170bc3bca78d 100644
--- a/tests/ui/lazy-type-alias/trailing-where-clause.stderr
+++ b/tests/ui/lazy-type-alias/trailing-where-clause.stderr
@@ -4,13 +4,13 @@ error[E0277]: the trait bound `String: From<()>` is not satisfied
 LL |     let _: Alias<()>;
    |                  ^^ the trait `From<()>` is not implemented for `String`
    |
-   = help: the following other types implement trait `From<T>`:
-             `String` implements `From<&String>`
-             `String` implements `From<&mut str>`
-             `String` implements `From<&str>`
-             `String` implements `From<Box<str>>`
-             `String` implements `From<Cow<'_, str>>`
-             `String` implements `From<char>`
+   = help: `String` implements trait `From<T>`:
+             From<&String>
+             From<&mut str>
+             From<&str>
+             From<Box<str>>
+             From<Cow<'_, str>>
+             From<char>
 note: required by a bound in `Alias`
   --> $DIR/trailing-where-clause.rs:8:13
    |
diff --git a/tests/ui/on-unimplemented/slice-index.stderr b/tests/ui/on-unimplemented/slice-index.stderr
index 67b72bd038d8..61d4866f5618 100644
--- a/tests/ui/on-unimplemented/slice-index.stderr
+++ b/tests/ui/on-unimplemented/slice-index.stderr
@@ -5,13 +5,13 @@ LL |     x[1i32];
    |       ^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[i32]>` is not implemented for `i32`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[i32]` to implement `Index<i32>`
 
 error[E0277]: the type `[i32]` cannot be indexed by `RangeTo<i32>`
@@ -21,19 +21,19 @@ LL |     x[..1i32];
    |       ^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[i32]>` is not implemented for `RangeTo<i32>`
-help: the following other types implement trait `SliceIndex<T>`
+help: `RangeTo<usize>` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `RangeTo<usize>` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `RangeTo<usize>` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
   ::: $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
    = note: in this macro invocation
   --> $SRC_DIR/core/src/str/traits.rs:LL:COL
    |
-   = note: `RangeTo<usize>` implements `SliceIndex<str>`
+   = note: `SliceIndex<str>`
    = note: required for `[i32]` to implement `Index<RangeTo<i32>>`
    = note: this error originates in the macro `impl_slice_index` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.rs b/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.rs
index aaaf4d3b2e11..2c898633b5e4 100644
--- a/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.rs
+++ b/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.rs
@@ -5,7 +5,7 @@ fn from(_: (u8,)) -> Self {
         todo!()
     }
 }
-impl From<(u8, u8)> for Tuple { //~ HELP the following other types implement trait `From<T>`
+impl From<(u8, u8)> for Tuple { //~ HELP `Tuple` implements trait `From<T>`
     fn from(_: (u8, u8)) -> Self {
         todo!()
     }
diff --git a/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.stderr b/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.stderr
index cf15ac1f279b..f07db05abad6 100644
--- a/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.stderr
+++ b/tests/ui/on-unimplemented/suggest_tuple_wrap_root_obligation.stderr
@@ -11,17 +11,17 @@ help: the trait `From<u8>` is not implemented for `Tuple`
    |
 LL | struct Tuple;
    | ^^^^^^^^^^^^
-help: the following other types implement trait `From<T>`
+help: `Tuple` implements trait `From<T>`
   --> $DIR/suggest_tuple_wrap_root_obligation.rs:3:1
    |
 LL | impl From<(u8,)> for Tuple {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `Tuple` implements `From<(u8,)>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<(u8,)>`
 ...
 LL | impl From<(u8, u8)> for Tuple {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Tuple` implements `From<(u8, u8)>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<(u8, u8)>`
 ...
 LL | impl From<(u8, u8, u8)> for Tuple {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Tuple` implements `From<(u8, u8, u8)>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<(u8, u8, u8)>`
    = note: required for `u8` to implement `Into<Tuple>`
 note: required by a bound in `convert_into_tuple`
   --> $DIR/suggest_tuple_wrap_root_obligation.rs:19:32
diff --git a/tests/ui/on-unimplemented/sum.stderr b/tests/ui/on-unimplemented/sum.stderr
index 5e82948352f7..56257079bd31 100644
--- a/tests/ui/on-unimplemented/sum.stderr
+++ b/tests/ui/on-unimplemented/sum.stderr
@@ -7,13 +7,13 @@ LL |     vec![(), ()].iter().sum::<i32>();
    |                         required by a bound introduced by this call
    |
    = help: the trait `Sum<&()>` is not implemented for `i32`
-help: the following other types implement trait `Sum<A>`
+help: `i32` implements trait `Sum<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum`
+   = note: `Sum`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Sum<&i32>`
+   = note: `Sum<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
@@ -37,13 +37,13 @@ LL |     vec![(), ()].iter().product::<i32>();
    |                         required by a bound introduced by this call
    |
    = help: the trait `Product<&()>` is not implemented for `i32`
-help: the following other types implement trait `Product<A>`
+help: `i32` implements trait `Product<A>`
   --> $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Product`
+   = note: `Product`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
-   = note: `i32` implements `Product<&i32>`
+   = note: `Product<&i32>`
   ::: $SRC_DIR/core/src/iter/traits/accum.rs:LL:COL
    |
    = note: in this macro invocation
diff --git a/tests/ui/str/str-idx.stderr b/tests/ui/str/str-idx.stderr
index 97a083ba8ba8..84f698a6e662 100644
--- a/tests/ui/str/str-idx.stderr
+++ b/tests/ui/str/str-idx.stderr
@@ -7,13 +7,13 @@ LL |     let _: u8 = s[4];
    = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `str` to implement `Index<{integer}>`
 
 error[E0277]: the type `str` cannot be indexed by `{integer}`
@@ -27,13 +27,13 @@ LL |     let _ = s.get(4);
    = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
 note: required by a bound in `core::str::<impl str>::get`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
 
@@ -48,13 +48,13 @@ LL |     let _ = s.get_unchecked(4);
    = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
 note: required by a bound in `core::str::<impl str>::get_unchecked`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
 
diff --git a/tests/ui/str/str-mut-idx.stderr b/tests/ui/str/str-mut-idx.stderr
index c9bd66dfbc8a..87b78915075d 100644
--- a/tests/ui/str/str-mut-idx.stderr
+++ b/tests/ui/str/str-mut-idx.stderr
@@ -31,13 +31,13 @@ LL |     s[1usize] = bot();
    |       ^^^^^^ string indices are ranges of `usize`
    |
    = help: the trait `SliceIndex<str>` is not implemented for `usize`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `str` to implement `Index<usize>`
 
 error[E0277]: the type `str` cannot be indexed by `{integer}`
@@ -51,13 +51,13 @@ LL |     s.get_mut(1);
    = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
 note: required by a bound in `core::str::<impl str>::get_mut`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
 
@@ -72,13 +72,13 @@ LL |     s.get_unchecked_mut(1);
    = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
 note: required by a bound in `core::str::<impl str>::get_unchecked_mut`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
 
diff --git a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
index 5eb64c45f9d7..836d31f81541 100644
--- a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
+++ b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
@@ -4,13 +4,13 @@ error[E0277]: the trait bound `str: From<_>` is not satisfied
 LL |     let _ = &str::from("value");
    |              ^^^ the trait `From<_>` is not implemented for `str`
    |
-   = help: the following other types implement trait `From<T>`:
-             `String` implements `From<&String>`
-             `String` implements `From<&mut str>`
-             `String` implements `From<&str>`
-             `String` implements `From<Box<str>>`
-             `String` implements `From<Cow<'_, str>>`
-             `String` implements `From<char>`
+   = help: `String` implements trait `From<T>`:
+             From<&String>
+             From<&mut str>
+             From<&str>
+             From<Box<str>>
+             From<Cow<'_, str>>
+             From<char>
 help: you likely meant to call the associated function `from` for type `&str`, but the code as written calls associated function `from` on type `str`
    |
 LL |     let _ = <&str>::from("value");
diff --git a/tests/ui/suggestions/into-str.stderr b/tests/ui/suggestions/into-str.stderr
index d02d31860829..cfb8f33bfcef 100644
--- a/tests/ui/suggestions/into-str.stderr
+++ b/tests/ui/suggestions/into-str.stderr
@@ -7,13 +7,13 @@ LL |     foo(String::new());
    |     required by a bound introduced by this call
    |
    = note: to coerce a `String` into a `&str`, use `&*` as a prefix
-   = help: the following other types implement trait `From<T>`:
-             `String` implements `From<&String>`
-             `String` implements `From<&mut str>`
-             `String` implements `From<&str>`
-             `String` implements `From<Box<str>>`
-             `String` implements `From<Cow<'_, str>>`
-             `String` implements `From<char>`
+   = help: `String` implements trait `From<T>`:
+             From<&String>
+             From<&mut str>
+             From<&str>
+             From<Box<str>>
+             From<Cow<'_, str>>
+             From<char>
    = note: required for `String` to implement `Into<&str>`
 note: required by a bound in `foo`
   --> $DIR/into-str.rs:1:31
diff --git a/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr
index c5984f53f68b..29e1c6b8a0a3 100644
--- a/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr
+++ b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr
@@ -5,15 +5,15 @@ LL |     String::from("Girls Band Cry") == T(String::from("Girls Band Cry"));
    |                                    ^^ no implementation for `String == T`
    |
    = help: the trait `PartialEq<T>` is not implemented for `String`
-   = help: the following other types implement trait `PartialEq<Rhs>`:
-             `String` implements `PartialEq<&str>`
-             `String` implements `PartialEq<ByteStr>`
-             `String` implements `PartialEq<ByteString>`
-             `String` implements `PartialEq<Cow<'_, str>>`
-             `String` implements `PartialEq<Path>`
-             `String` implements `PartialEq<PathBuf>`
-             `String` implements `PartialEq<str>`
-             `String` implements `PartialEq`
+   = help: `String` implements trait `PartialEq<Rhs>`:
+             PartialEq<&str>
+             PartialEq<ByteStr>
+             PartialEq<ByteString>
+             PartialEq<Cow<'_, str>>
+             PartialEq<Path>
+             PartialEq<PathBuf>
+             PartialEq<str>
+             PartialEq
    = note: `T` implements `PartialEq<String>`
 help: consider swapping the equality
    |
diff --git a/tests/ui/suggestions/semi-suggestion-when-stmt-and-expr-span-equal.stderr b/tests/ui/suggestions/semi-suggestion-when-stmt-and-expr-span-equal.stderr
index 9f34d2747881..6dd4b1e5d511 100644
--- a/tests/ui/suggestions/semi-suggestion-when-stmt-and-expr-span-equal.stderr
+++ b/tests/ui/suggestions/semi-suggestion-when-stmt-and-expr-span-equal.stderr
@@ -20,15 +20,15 @@ LL |         .collect::<String>();
    |          required by a bound introduced by this call
    |
    = help: the trait `FromIterator<()>` is not implemented for `String`
-   = help: the following other types implement trait `FromIterator<A>`:
-             `String` implements `FromIterator<&char>`
-             `String` implements `FromIterator<&std::ascii::Char>`
-             `String` implements `FromIterator<&str>`
-             `String` implements `FromIterator<Box<str, A>>`
-             `String` implements `FromIterator<Cow<'_, str>>`
-             `String` implements `FromIterator<String>`
-             `String` implements `FromIterator<char>`
-             `String` implements `FromIterator<std::ascii::Char>`
+   = help: `String` implements trait `FromIterator<A>`:
+             FromIterator<&char>
+             FromIterator<&std::ascii::Char>
+             FromIterator<&str>
+             FromIterator<Box<str, A>>
+             FromIterator<Cow<'_, str>>
+             FromIterator<String>
+             FromIterator<char>
+             FromIterator<std::ascii::Char>
 note: the method call chain might not have had the expected associated types
   --> $DIR/semi-suggestion-when-stmt-and-expr-span-equal.rs:20:10
    |
diff --git a/tests/ui/suggestions/suggest-dereferencing-index.stderr b/tests/ui/suggestions/suggest-dereferencing-index.stderr
index 541c625ebb10..cee5ffcb2ae8 100644
--- a/tests/ui/suggestions/suggest-dereferencing-index.stderr
+++ b/tests/ui/suggestions/suggest-dereferencing-index.stderr
@@ -5,13 +5,13 @@ LL |     let one_item_please: i32 = [1, 2, 3][i];
    |                                          ^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `SliceIndex<[{integer}]>` is not implemented for `&usize`
-help: the following other types implement trait `SliceIndex<T>`
+help: `usize` implements trait `SliceIndex<T>`
   --> $SRC_DIR/core/src/slice/index.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<[T]>`
+   = note: `SliceIndex<[T]>`
   --> $SRC_DIR/core/src/bstr/traits.rs:LL:COL
    |
-   = note: `usize` implements `SliceIndex<ByteStr>`
+   = note: `SliceIndex<ByteStr>`
    = note: required for `[{integer}]` to implement `Index<&usize>`
 help: dereference this index
    |
diff --git a/tests/ui/traits/explicit-reference-cast.rs b/tests/ui/traits/explicit-reference-cast.rs
index efb4f10bea67..b9ccc1827a55 100644
--- a/tests/ui/traits/explicit-reference-cast.rs
+++ b/tests/ui/traits/explicit-reference-cast.rs
@@ -7,7 +7,7 @@
 //~^ HELP the trait `From<&PathBuf>` is not implemented for `ToolA`
 
 impl From<&Path> for ToolA {
-    //~^ HELP the following other types implement trait `From<T>`
+    //~^ HELP `ToolA` implements trait `From<T>`
     fn from(p: &Path) -> ToolA {
         ToolA(p.to_path_buf())
     }
diff --git a/tests/ui/traits/explicit-reference-cast.stderr b/tests/ui/traits/explicit-reference-cast.stderr
index 924de3d5bbe3..78eb25b0243d 100644
--- a/tests/ui/traits/explicit-reference-cast.stderr
+++ b/tests/ui/traits/explicit-reference-cast.stderr
@@ -10,14 +10,14 @@ help: the trait `From<&PathBuf>` is not implemented for `ToolA`
    |
 LL | pub struct ToolA(PathBuf);
    | ^^^^^^^^^^^^^^^^
-help: the following other types implement trait `From<T>`
+help: `ToolA` implements trait `From<T>`
   --> $DIR/explicit-reference-cast.rs:9:1
    |
 LL | impl From<&Path> for ToolA {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `ToolA` implements `From<&Path>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `From<&Path>`
 ...
 LL | impl From<&str> for ToolA {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^ `ToolA` implements `From<&str>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ `From<&str>`
 
 error[E0277]: the trait bound `ToolB: TryFrom<&PathBuf>` is not satisfied
   --> $DIR/explicit-reference-cast.rs:43:13
diff --git a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
index e58f5c3fe90f..9b27491f5046 100644
--- a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
+++ b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
@@ -6,14 +6,14 @@ LL |     c.same_as(22)
    |       |
    |       required by a bound introduced by this call
    |
-help: the following other types implement trait `CompareTo<T>`
+help: `i64` implements trait `CompareTo<T>`
   --> $DIR/repeated-supertrait-ambig.rs:15:1
    |
 LL | impl CompareTo<i64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<i64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<i64>`
 ...
 LL | impl CompareTo<u64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<u64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<u64>`
 
 error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied
   --> $DIR/repeated-supertrait-ambig.rs:30:15
@@ -34,14 +34,14 @@ error[E0277]: the trait bound `dyn CompareToInts: CompareTo<i32>` is not satisfi
 LL |     <dyn CompareToInts>::same_as(c, 22)
    |      ^^^^^^^^^^^^^^^^^ the trait `CompareTo<i32>` is not implemented for `dyn CompareToInts`
    |
-help: the following other types implement trait `CompareTo<T>`
+help: `i64` implements trait `CompareTo<T>`
   --> $DIR/repeated-supertrait-ambig.rs:15:1
    |
 LL | impl CompareTo<i64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<i64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<i64>`
 ...
 LL | impl CompareTo<u64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<u64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<u64>`
 
 error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied
   --> $DIR/repeated-supertrait-ambig.rs:38:24
@@ -64,14 +64,14 @@ LL |     assert_eq!(22_i64.same_as(22), true);
    |                       |
    |                       required by a bound introduced by this call
    |
-help: the following other types implement trait `CompareTo<T>`
+help: `i64` implements trait `CompareTo<T>`
   --> $DIR/repeated-supertrait-ambig.rs:15:1
    |
 LL | impl CompareTo<i64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<i64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<i64>`
 ...
 LL | impl CompareTo<u64> for i64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i64` implements `CompareTo<u64>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CompareTo<u64>`
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/traits/next-solver/cycles/forced_ambiguity-use-head-maybe-cause.stderr b/tests/ui/traits/next-solver/cycles/forced_ambiguity-use-head-maybe-cause.stderr
index 42b76a8f7ff6..04a4c70c6d7b 100644
--- a/tests/ui/traits/next-solver/cycles/forced_ambiguity-use-head-maybe-cause.stderr
+++ b/tests/ui/traits/next-solver/cycles/forced_ambiguity-use-head-maybe-cause.stderr
@@ -5,7 +5,7 @@ LL |     impls_trait::<Root<_>>()
    |                   ^^^^^^^ cannot infer type for struct `Head<_>`
    |
    = note: cannot satisfy `Head<_>: Trait`
-help: the following types implement trait `Trait`
+help: `Head<T>` implements trait `Trait`
   --> $DIR/forced_ambiguity-use-head-maybe-cause.rs:23:1
    |
 LL | / impl<T> Trait for Head<T>
diff --git a/tests/ui/traits/next-solver/cycles/inductive-cycle-but-err.stderr b/tests/ui/traits/next-solver/cycles/inductive-cycle-but-err.stderr
index 8b24e682c769..cea95eb365e6 100644
--- a/tests/ui/traits/next-solver/cycles/inductive-cycle-but-err.stderr
+++ b/tests/ui/traits/next-solver/cycles/inductive-cycle-but-err.stderr
@@ -21,7 +21,7 @@ help: the trait `Trait` is not implemented for `MultipleCandidates`
    |
 LL | struct MultipleCandidates;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
-help: the following other types implement trait `Trait`
+help: `MultipleCandidates` implements trait `Trait`
   --> $DIR/inductive-cycle-but-err.rs:26:1
    |
 LL | / impl Trait for MultipleCandidates
diff --git a/tests/ui/traits/next-solver/unevaluated-const-impl-trait-ref.fails.stderr b/tests/ui/traits/next-solver/unevaluated-const-impl-trait-ref.fails.stderr
index 8202b6ecb5d6..ce68c2f435fa 100644
--- a/tests/ui/traits/next-solver/unevaluated-const-impl-trait-ref.fails.stderr
+++ b/tests/ui/traits/next-solver/unevaluated-const-impl-trait-ref.fails.stderr
@@ -4,13 +4,13 @@ error[E0277]: the trait bound `(): Trait<1>` is not satisfied
 LL |     needs::<1>();
    |             ^ the trait `Trait<1>` is not implemented for `()`
    |
-help: the following other types implement trait `Trait<N>`
+help: `()` implements trait `Trait<N>`
   --> $DIR/unevaluated-const-impl-trait-ref.rs:7:1
    |
 LL | impl Trait<{ 1 - 1 }> for () {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `()` implements `Trait<0>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Trait<0>`
 LL | impl Trait<{ 1 + 1 }> for () {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `()` implements `Trait<2>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Trait<2>`
 note: required by a bound in `needs`
   --> $DIR/unevaluated-const-impl-trait-ref.rs:10:38
    |
diff --git a/tests/ui/traits/question-mark-result-err-mismatch.rs b/tests/ui/traits/question-mark-result-err-mismatch.rs
index dfea4b93f46d..f9ca6e0ab448 100644
--- a/tests/ui/traits/question-mark-result-err-mismatch.rs
+++ b/tests/ui/traits/question-mark-result-err-mismatch.rs
@@ -35,7 +35,7 @@ fn bar() -> Result<(), String> { //~ NOTE expected `String` because of this
     //~| NOTE the trait `From<()>` is not implemented for `String`
     //~| NOTE the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
     //~| NOTE required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>`
-    //~| HELP the following other types implement trait `From<T>`:
+    //~| HELP `String` implements trait `From<T>`:
     Ok(one)
 }
 
diff --git a/tests/ui/traits/question-mark-result-err-mismatch.stderr b/tests/ui/traits/question-mark-result-err-mismatch.stderr
index be3f17cfc527..3739b508a868 100644
--- a/tests/ui/traits/question-mark-result-err-mismatch.stderr
+++ b/tests/ui/traits/question-mark-result-err-mismatch.stderr
@@ -30,13 +30,13 @@ LL |         .map_err(|_| ())?;
    |          this can't be annotated with `?` because it has type `Result<_, ()>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-   = help: the following other types implement trait `From<T>`:
-             `String` implements `From<&String>`
-             `String` implements `From<&mut str>`
-             `String` implements `From<&str>`
-             `String` implements `From<Box<str>>`
-             `String` implements `From<Cow<'_, str>>`
-             `String` implements `From<char>`
+   = help: `String` implements trait `From<T>`:
+             From<&String>
+             From<&mut str>
+             From<&str>
+             From<Box<str>>
+             From<Cow<'_, str>>
+             From<char>
    = note: required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>`
 
 error[E0277]: `?` couldn't convert the error to `String`
diff --git a/tests/ui/traits/question-mark-span-144304.stderr b/tests/ui/traits/question-mark-span-144304.stderr
index a412da0d235d..37452cda8a6d 100644
--- a/tests/ui/traits/question-mark-span-144304.stderr
+++ b/tests/ui/traits/question-mark-span-144304.stderr
@@ -9,12 +9,12 @@ LL |     Err("str").map_err(|e| e)?;
    |     this has type `Result<_, &str>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-   = help: the following other types implement trait `From<T>`:
-             `i32` implements `From<bool>`
-             `i32` implements `From<i16>`
-             `i32` implements `From<i8>`
-             `i32` implements `From<u16>`
-             `i32` implements `From<u8>`
+   = help: `i32` implements trait `From<T>`:
+             From<bool>
+             From<i16>
+             From<i8>
+             From<u16>
+             From<u8>
 
 error[E0277]: `?` couldn't convert the error to `i32`
   --> $DIR/question-mark-span-144304.rs:4:42
@@ -29,12 +29,12 @@ LL |     Err("str").map_err(|e| e.to_string())?;
    |     this has type `Result<_, &str>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-   = help: the following other types implement trait `From<T>`:
-             `i32` implements `From<bool>`
-             `i32` implements `From<i16>`
-             `i32` implements `From<i8>`
-             `i32` implements `From<u16>`
-             `i32` implements `From<u8>`
+   = help: `i32` implements trait `From<T>`:
+             From<bool>
+             From<i16>
+             From<i8>
+             From<u16>
+             From<u8>
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/try-trait/bad-interconversion.stderr b/tests/ui/try-trait/bad-interconversion.stderr
index a566800da53e..e1cc7a45e5de 100644
--- a/tests/ui/try-trait/bad-interconversion.stderr
+++ b/tests/ui/try-trait/bad-interconversion.stderr
@@ -9,16 +9,16 @@ LL |     Ok(Err(123_i32)?)
    |        this can't be annotated with `?` because it has type `Result<_, i32>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-help: the following other types implement trait `From<T>`
+help: `u8` implements trait `From<T>`
   --> $SRC_DIR/core/src/convert/num.rs:LL:COL
    |
-   = note: `u8` implements `From<bool>`
+   = note: `From<bool>`
   ::: $SRC_DIR/core/src/convert/num.rs:LL:COL
    |
    = note: in this macro invocation
   --> $SRC_DIR/core/src/ascii/ascii_char.rs:LL:COL
    |
-   = note: `u8` implements `From<std::ascii::Char>`
+   = note: `From<std::ascii::Char>`
   ::: $SRC_DIR/core/src/ascii/ascii_char.rs:LL:COL
    |
    = note: in this macro invocation
diff --git a/tests/ui/type-alias-impl-trait/constrain_in_projection2.current.stderr b/tests/ui/type-alias-impl-trait/constrain_in_projection2.current.stderr
index d17a82194353..fc6bf3f18902 100644
--- a/tests/ui/type-alias-impl-trait/constrain_in_projection2.current.stderr
+++ b/tests/ui/type-alias-impl-trait/constrain_in_projection2.current.stderr
@@ -9,14 +9,14 @@ help: the trait `Trait<Bar>` is not implemented for `Foo`
    |
 LL | struct Foo;
    | ^^^^^^^^^^
-help: the following other types implement trait `Trait<T>`
+help: `Foo` implements trait `Trait<T>`
   --> $DIR/constrain_in_projection2.rs:18:1
    |
 LL | impl Trait<()> for Foo {
-   | ^^^^^^^^^^^^^^^^^^^^^^ `Foo` implements `Trait<()>`
+   | ^^^^^^^^^^^^^^^^^^^^^^ `Trait<()>`
 ...
 LL | impl Trait<u32> for Foo {
-   | ^^^^^^^^^^^^^^^^^^^^^^^ `Foo` implements `Trait<u32>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^ `Trait<u32>`
 
 error[E0277]: the trait bound `Foo: Trait<Bar>` is not satisfied
   --> $DIR/constrain_in_projection2.rs:28:13
@@ -29,14 +29,14 @@ help: the trait `Trait<Bar>` is not implemented for `Foo`
    |
 LL | struct Foo;
    | ^^^^^^^^^^
-help: the following other types implement trait `Trait<T>`
+help: `Foo` implements trait `Trait<T>`
   --> $DIR/constrain_in_projection2.rs:18:1
    |
 LL | impl Trait<()> for Foo {
-   | ^^^^^^^^^^^^^^^^^^^^^^ `Foo` implements `Trait<()>`
+   | ^^^^^^^^^^^^^^^^^^^^^^ `Trait<()>`
 ...
 LL | impl Trait<u32> for Foo {
-   | ^^^^^^^^^^^^^^^^^^^^^^^ `Foo` implements `Trait<u32>`
+   | ^^^^^^^^^^^^^^^^^^^^^^^ `Trait<u32>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/type-alias-impl-trait/nested-tait-inference2.current.stderr b/tests/ui/type-alias-impl-trait/nested-tait-inference2.current.stderr
index 4cc69daffe62..674442784ae7 100644
--- a/tests/ui/type-alias-impl-trait/nested-tait-inference2.current.stderr
+++ b/tests/ui/type-alias-impl-trait/nested-tait-inference2.current.stderr
@@ -7,13 +7,13 @@ LL |
 LL |     ()
    |     -- return type was inferred to be `()` here
    |
-help: the following other types implement trait `Foo<A>`
+help: `()` implements trait `Foo<A>`
   --> $DIR/nested-tait-inference2.rs:14:1
    |
 LL | impl Foo<()> for () {}
-   | ^^^^^^^^^^^^^^^^^^^ `()` implements `Foo<()>`
+   | ^^^^^^^^^^^^^^^^^^^ `Foo<()>`
 LL | impl Foo<u32> for () {}
-   | ^^^^^^^^^^^^^^^^^^^^ `()` implements `Foo<u32>`
+   | ^^^^^^^^^^^^^^^^^^^^ `Foo<u32>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-90101.stderr b/tests/ui/typeck/issue-90101.stderr
index 2e140461c1d9..fe9af5a5f4f5 100644
--- a/tests/ui/typeck/issue-90101.stderr
+++ b/tests/ui/typeck/issue-90101.stderr
@@ -6,12 +6,12 @@ LL |     func(Path::new("hello").to_path_buf().to_string_lossy(), "world")
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the following other types implement trait `From<T>`:
-             `PathBuf` implements `From<&T>`
-             `PathBuf` implements `From<Box<Path>>`
-             `PathBuf` implements `From<Cow<'_, Path>>`
-             `PathBuf` implements `From<OsString>`
-             `PathBuf` implements `From<String>`
+   = help: `PathBuf` implements trait `From<T>`:
+             From<&T>
+             From<Box<Path>>
+             From<Cow<'_, Path>>
+             From<OsString>
+             From<String>
    = note: required for `Cow<'_, str>` to implement `Into<PathBuf>`
 note: required by a bound in `func`
   --> $DIR/issue-90101.rs:3:20

From 01ea06bfd36ffcaf72f9adf94511eaa6856e56d1 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 20 Mar 2026 11:47:55 -0400
Subject: [PATCH 0728/1059] Update cargo submodule

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index cbb9bb8bd0fb..e84cb639edfe 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit cbb9bb8bd0fb272b1be0d63a010701ecb3d1d6d3
+Subproject commit e84cb639edfea2c42efd563b72a9be0cc5de6523

From 193309e1c31cc0c6fd4cb79e0e9c3bbb45c3bb29 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 21 Mar 2026 14:11:24 +1100
Subject: [PATCH 0729/1059] Sort query modifier names in `doc_link!`

---
 compiler/rustc_macros/src/query.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index a803d86f2771..1c33c77b8681 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -387,13 +387,15 @@ macro_rules! doc_link {
     }
 
     doc_link!(
-        arena_cache,
-        no_hash,
+        // tidy-alphabetical-start
         anon,
-        eval_always,
+        arena_cache,
         depth_limit,
-        separate_provide_extern,
+        eval_always,
         feedable,
+        no_hash,
+        separate_provide_extern,
+        // tidy-alphabetical-end
     );
 
     let name = &query.name;

From dbdbf0958615ce31bef278433a0d0ee8f9c90ac0 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 17 Mar 2026 21:16:00 +1100
Subject: [PATCH 0730/1059] Use a new `no_force` query modifier for
 `check_representability`

These queries appear to have been using `anon` for its side-effect of making
them ineligible for forcing.

According to their comments and also `tests/incremental/issue-61323.rs`, these
queries want to avoid forcing so that if a cycle does occur, the whole cycle
will be on the query stack for the cycle handler to find.
---
 compiler/rustc_macros/src/query.rs                     |  9 +++++++++
 compiler/rustc_middle/src/queries.rs                   |  4 ++--
 compiler/rustc_middle/src/query/modifiers.rs           | 10 ++++++++++
 compiler/rustc_middle/src/query/plumbing.rs            |  1 +
 compiler/rustc_query_impl/src/dep_kind_vtables.rs      |  6 +++++-
 compiler/rustc_query_impl/src/query_impl.rs            |  1 +
 .../src/queries/incremental-compilation-in-detail.md   | 10 ++++++++++
 7 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index 1c33c77b8681..fa505373e078 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -147,6 +147,7 @@ struct QueryModifiers {
     desc: Desc,
     eval_always: Option<Ident>,
     feedable: Option<Ident>,
+    no_force: Option<Ident>,
     no_hash: Option<Ident>,
     separate_provide_extern: Option<Ident>,
     // tidy-alphabetical-end
@@ -156,6 +157,7 @@ fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModifiers> {
     let mut arena_cache = None;
     let mut cache_on_disk_if = None;
     let mut desc = None;
+    let mut no_force = None;
     let mut no_hash = None;
     let mut anon = None;
     let mut eval_always = None;
@@ -189,6 +191,8 @@ macro_rules! try_insert {
             try_insert!(cache_on_disk_if = CacheOnDiskIf { modifier, block });
         } else if modifier == "arena_cache" {
             try_insert!(arena_cache = modifier);
+        } else if modifier == "no_force" {
+            try_insert!(no_force = modifier);
         } else if modifier == "no_hash" {
             try_insert!(no_hash = modifier);
         } else if modifier == "anon" {
@@ -212,6 +216,7 @@ macro_rules! try_insert {
         arena_cache,
         cache_on_disk_if,
         desc,
+        no_force,
         no_hash,
         anon,
         eval_always,
@@ -250,6 +255,7 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         desc: _,
         eval_always,
         feedable,
+        no_force,
         no_hash,
         separate_provide_extern,
         // tidy-alphabetical-end
@@ -261,6 +267,7 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
     let depth_limit = depth_limit.is_some();
     let eval_always = eval_always.is_some();
     let feedable = feedable.is_some();
+    let no_force = no_force.is_some();
     let no_hash = no_hash.is_some();
     let returns_error_guaranteed = returns_error_guaranteed(&query.return_ty);
     let separate_provide_extern = separate_provide_extern.is_some();
@@ -279,6 +286,7 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         depth_limit: #depth_limit,
         eval_always: #eval_always,
         feedable: #feedable,
+        no_force: #no_force,
         no_hash: #no_hash,
         returns_error_guaranteed: #returns_error_guaranteed,
         separate_provide_extern: #separate_provide_extern,
@@ -393,6 +401,7 @@ macro_rules! doc_link {
         depth_limit,
         eval_always,
         feedable,
+        no_force,
         no_hash,
         separate_provide_extern,
         // tidy-alphabetical-end
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index d5185a05d507..335ddfec1adf 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -587,14 +587,14 @@
         // incremental compilation because, if a cycle occurs, we need the
         // entire cycle to be in memory for diagnostics. This means we can't
         // use `ensure_ok()` with this query.
-        anon
+        no_force
     }
 
     /// An implementation detail for the `check_representability` query. See that query for more
     /// details, particularly on the modifiers.
     query check_representability_adt_ty(key: Ty<'tcx>) {
         desc { "checking if `{}` is representable", key }
-        anon
+        no_force
     }
 
     /// Set of param indexes for type params that are in the type's representation
diff --git a/compiler/rustc_middle/src/query/modifiers.rs b/compiler/rustc_middle/src/query/modifiers.rs
index ad9b9de119d5..a1f8ec2e9af0 100644
--- a/compiler/rustc_middle/src/query/modifiers.rs
+++ b/compiler/rustc_middle/src/query/modifiers.rs
@@ -59,6 +59,16 @@
 /// Generate a `feed` method to set the query's value from another query.
 pub(crate) struct feedable;
 
+/// # `no_force` query modifier
+///
+/// Dep nodes of queries with this modifier will never be "forced" when trying
+/// to mark their dependents green, even if their key is recoverable from the
+/// key fingerprint.
+///
+/// Used by some queries with custom cycle-handlers to ensure that if a cycle
+/// occurs, all of the relevant query calls will be on the query stack.
+pub(crate) struct no_force;
+
 /// # `no_hash` query modifier
 ///
 /// Do not hash the query's return value for incremental compilation. If the value needs to be
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 4ef1b0adf581..ed094790b59b 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -289,6 +289,7 @@ fn $name:ident($($K:tt)*) -> $V:ty
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
+                    no_force: $no_force:literal,
                     no_hash: $no_hash:literal,
                     returns_error_guaranteed: $returns_error_guaranteed:literal,
                     separate_provide_extern: $separate_provide_extern:literal,
diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 597c8b2a9e74..65ab207b04e6 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -99,6 +99,7 @@ pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
     is_anon: bool,
     is_cache_on_disk: bool,
     is_eval_always: bool,
+    is_no_force: bool,
 ) -> DepKindVTable<'tcx>
 where
     Q: GetQueryVTable<'tcx>,
@@ -119,7 +120,8 @@ pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
     DepKindVTable {
         is_eval_always,
         key_fingerprint_style,
-        force_from_dep_node_fn: can_recover.then_some(force_from_dep_node_inner::<Q>),
+        force_from_dep_node_fn: (can_recover && !is_no_force)
+            .then_some(force_from_dep_node_inner::<Q>),
         promote_from_disk_fn: (can_recover && is_cache_on_disk)
             .then_some(promote_from_disk_inner::<Q>),
     }
@@ -139,6 +141,7 @@ fn $name:ident($K:ty) -> $V:ty
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
+                    no_force: $no_force:literal,
                     no_hash: $no_hash:literal,
                     returns_error_guaranteed: $returns_error_guaranteed:literal,
                     separate_provide_extern: $separate_provide_extern:literal,
@@ -168,6 +171,7 @@ fn $name:ident($K:ty) -> $V:ty
                     $anon,
                     $cache_on_disk,
                     $eval_always,
+                    $no_force,
                 )
             ),*
         ];
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index caf4c7dde7e6..4eccabbb4245 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -22,6 +22,7 @@ fn $name:ident($K:ty) -> $V:ty
                     depth_limit: $depth_limit:literal,
                     eval_always: $eval_always:literal,
                     feedable: $feedable:literal,
+                    no_force: $no_force:literal,
                     no_hash: $no_hash:literal,
                     returns_error_guaranteed: $returns_error_guaranteed:literal,
                     separate_provide_extern: $separate_provide_extern:literal,
diff --git a/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
index 988284620d5c..a1af9c4e561b 100644
--- a/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
+++ b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
@@ -418,6 +418,13 @@ deal with all of the above but so far that seemed like more trouble than it woul
 
 ## Query modifiers
 
+> FIXME: Make [`rustc_middle::query::modifiers`] the home for query modifier documentation,
+> and migrate all other useful modifier docs there after verifying that they are still accurate.
+
+[`rustc_middle::query::modifiers`]:
+    https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/query/modifiers/index.html
+
+
 The query system allows for applying [modifiers][mod] to queries.
 These modifiers affect certain aspects of how the system treats the query with
 respect to incremental compilation:
@@ -437,6 +444,9 @@ respect to incremental compilation:
       as an optimization because the system can skip recording dependencies in
       the first place.
 
+ - `no_force` - Never "force" the dep nodes for this query, even if the query's
+   key type is recoverable.
+
  - `no_hash` - Applying `no_hash` to a query tells the system to not compute
    the fingerprint of the query's result.
    This has two consequences:

From 70f3e092257613f8b43ab1f749638a3660c1cfd9 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 17 Mar 2026 21:19:18 +1100
Subject: [PATCH 0731/1059] Always call `check_representability` with
 `tcx.ensure_ok()`

This was previously not possible because `check_representability` was `anon`.
---
 compiler/rustc_hir_analysis/src/check/wfcheck.rs  | 2 +-
 compiler/rustc_middle/src/queries.rs              | 3 +--
 compiler/rustc_middle/src/ty/inhabitedness/mod.rs | 2 +-
 compiler/rustc_ty_utils/src/representability.rs   | 6 +++---
 compiler/rustc_ty_utils/src/ty.rs                 | 2 +-
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 5656c4566d9f..f050fe2978ce 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -998,7 +998,7 @@ fn check_type_defn<'tcx>(
     item: &hir::Item<'tcx>,
     all_sized: bool,
 ) -> Result<(), ErrorGuaranteed> {
-    let _ = tcx.check_representability(item.owner_id.def_id);
+    tcx.ensure_ok().check_representability(item.owner_id.def_id);
     let adt_def = tcx.adt_def(item.owner_id);
 
     enter_wf_checking_ctxt(tcx, item.owner_id.def_id, |wfcx| {
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 335ddfec1adf..2906f45b11ec 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -585,8 +585,7 @@
         desc { "checking if `{}` is representable", tcx.def_path_str(key) }
         // We don't want recursive representability calls to be forced with
         // incremental compilation because, if a cycle occurs, we need the
-        // entire cycle to be in memory for diagnostics. This means we can't
-        // use `ensure_ok()` with this query.
+        // entire cycle to be in memory for diagnostics.
         no_force
     }
 
diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
index b454689e243d..5bb11c917502 100644
--- a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
+++ b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
@@ -61,7 +61,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 /// requires calling [`InhabitedPredicate::instantiate`]
 fn inhabited_predicate_adt(tcx: TyCtxt<'_>, def_id: DefId) -> InhabitedPredicate<'_> {
     if let Some(def_id) = def_id.as_local() {
-        let _ = tcx.check_representability(def_id);
+        tcx.ensure_ok().check_representability(def_id);
     }
 
     let adt = tcx.adt_def(def_id);
diff --git a/compiler/rustc_ty_utils/src/representability.rs b/compiler/rustc_ty_utils/src/representability.rs
index cef964ab139a..9fb16af75aaf 100644
--- a/compiler/rustc_ty_utils/src/representability.rs
+++ b/compiler/rustc_ty_utils/src/representability.rs
@@ -19,7 +19,7 @@ fn check_representability(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         DefKind::Struct | DefKind::Union | DefKind::Enum => {
             for variant in tcx.adt_def(def_id).variants() {
                 for field in variant.fields.iter() {
-                    let _ = tcx.check_representability(field.did.expect_local());
+                    tcx.ensure_ok().check_representability(field.did.expect_local());
                 }
             }
         }
@@ -35,7 +35,7 @@ fn check_representability_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
         // This one must be a query rather than a vanilla `check_representability_adt_ty` call. See
         // the comment on `check_representability_adt_ty` below for why.
         ty::Adt(..) => {
-            let _ = tcx.check_representability_adt_ty(ty);
+            tcx.ensure_ok().check_representability_adt_ty(ty);
         }
         // FIXME(#11924) allow zero-length arrays?
         ty::Array(ty, _) => {
@@ -69,7 +69,7 @@ fn check_representability_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
 fn check_representability_adt_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
     let ty::Adt(adt, args) = ty.kind() else { bug!("expected adt") };
     if let Some(def_id) = adt.did().as_local() {
-        let _ = tcx.check_representability(def_id);
+        tcx.ensure_ok().check_representability(def_id);
     }
     // At this point, we know that the item of the ADT type is representable;
     // but the type parameters may cause a cycle with an upstream type
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 78f3a1922887..7a84a87a789a 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -117,7 +117,7 @@ fn adt_sizedness_constraint<'tcx>(
     (def_id, sizedness): (DefId, SizedTraitKind),
 ) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
     if let Some(def_id) = def_id.as_local() {
-        let _ = tcx.check_representability(def_id);
+        tcx.ensure_ok().check_representability(def_id);
     }
 
     let def = tcx.adt_def(def_id);

From 0dfce4d26817ab3a6f138208eb0cf3a1bf560219 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 20 Mar 2026 13:46:07 +1100
Subject: [PATCH 0732/1059] Don't use `anon` for query
 `erase_and_anonymize_regions_ty`

According to its comment, this query was only using `anon` to save a little bit
of work for a dep graph node that is expected to have no dependencies.

Benchmarks indicate that the perf loss, if any, is small enough to be justified
by the fact that we can now remove support for `anon` queries.

Adding `no_hash` appears to give marginally better perf results.
---
 compiler/rustc_middle/src/queries.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 2906f45b11ec..c5dab806fa19 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -767,14 +767,10 @@
     /// Normally you would just use `tcx.erase_and_anonymize_regions(value)`,
     /// however, which uses this query as a kind of cache.
     query erase_and_anonymize_regions_ty(ty: Ty<'tcx>) -> Ty<'tcx> {
-        // This query is not expected to have input -- as a result, it
-        // is not a good candidates for "replay" because it is essentially a
-        // pure function of its input (and hence the expectation is that
-        // no caller would be green **apart** from just these
-        // queries). Making it anonymous avoids hashing the result, which
-        // may save a bit of time.
-        anon
         desc { "erasing regions from `{}`", ty }
+        // Not hashing the return value appears to give marginally better perf for this query,
+        // which should always be marked green for having no dependencies anyway.
+        no_hash
     }
 
     query wasm_import_module_map(_: CrateNum) -> &'tcx DefIdMap<String> {

From 3a62e89822c21fa437c870e197966f60ecc3c416 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 20 Mar 2026 13:56:42 +1100
Subject: [PATCH 0733/1059] Remove the `anon` query modifier

We still have some anon-task machinery for `DepKind::TraitSelect` tasks, but
there are no longer any queries that use the `anon` modifier.
---
 compiler/rustc_macros/src/query.rs                 | 14 --------------
 compiler/rustc_middle/src/dep_graph/dep_node.rs    | 10 +++++++---
 compiler/rustc_middle/src/dep_graph/graph.rs       |  5 ++---
 compiler/rustc_middle/src/query/modifiers.rs       |  5 -----
 compiler/rustc_middle/src/query/plumbing.rs        |  3 ---
 compiler/rustc_query_impl/src/dep_kind_vtables.rs  | 13 +------------
 compiler/rustc_query_impl/src/execution.rs         | 14 +-------------
 compiler/rustc_query_impl/src/query_impl.rs        |  2 --
 .../queries/incremental-compilation-in-detail.md   |  7 -------
 9 files changed, 11 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index fa505373e078..b75236b35230 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -140,7 +140,6 @@ struct CacheOnDiskIf {
 /// See `rustc_middle::query::modifiers` for documentation of each query modifier.
 struct QueryModifiers {
     // tidy-alphabetical-start
-    anon: Option<Ident>,
     arena_cache: Option<Ident>,
     cache_on_disk_if: Option<CacheOnDiskIf>,
     depth_limit: Option<Ident>,
@@ -159,7 +158,6 @@ fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModifiers> {
     let mut desc = None;
     let mut no_force = None;
     let mut no_hash = None;
-    let mut anon = None;
     let mut eval_always = None;
     let mut depth_limit = None;
     let mut separate_provide_extern = None;
@@ -195,8 +193,6 @@ macro_rules! try_insert {
             try_insert!(no_force = modifier);
         } else if modifier == "no_hash" {
             try_insert!(no_hash = modifier);
-        } else if modifier == "anon" {
-            try_insert!(anon = modifier);
         } else if modifier == "eval_always" {
             try_insert!(eval_always = modifier);
         } else if modifier == "depth_limit" {
@@ -218,7 +214,6 @@ macro_rules! try_insert {
         desc,
         no_force,
         no_hash,
-        anon,
         eval_always,
         depth_limit,
         separate_provide_extern,
@@ -248,7 +243,6 @@ fn returns_error_guaranteed(ret_ty: &ReturnType) -> bool {
 fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
     let QueryModifiers {
         // tidy-alphabetical-start
-        anon,
         arena_cache,
         cache_on_disk_if,
         depth_limit,
@@ -261,7 +255,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         // tidy-alphabetical-end
     } = &query.modifiers;
 
-    let anon = anon.is_some();
     let arena_cache = arena_cache.is_some();
     let cache_on_disk = cache_on_disk_if.is_some();
     let depth_limit = depth_limit.is_some();
@@ -280,7 +273,6 @@ fn make_modifiers_stream(query: &Query) -> proc_macro2::TokenStream {
         query_name_span =>
         // Search for (QMODLIST) to find all occurrences of this query modifier list.
         // tidy-alphabetical-start
-        anon: #anon,
         arena_cache: #arena_cache,
         cache_on_disk: #cache_on_disk,
         depth_limit: #depth_limit,
@@ -396,7 +388,6 @@ macro_rules! doc_link {
 
     doc_link!(
         // tidy-alphabetical-start
-        anon,
         arena_cache,
         depth_limit,
         eval_always,
@@ -487,11 +478,6 @@ fn #name(#key_ty) #return_ty
         });
 
         if let Some(feedable) = &modifiers.feedable {
-            assert!(
-                modifiers.anon.is_none(),
-                feedable.span(),
-                "Query {name} cannot be both `feedable` and `anon`."
-            );
             assert!(
                 modifiers.eval_always.is_none(),
                 feedable.span(),
diff --git a/compiler/rustc_middle/src/dep_graph/dep_node.rs b/compiler/rustc_middle/src/dep_graph/dep_node.rs
index 49ad6bbf8577..81f30411b25a 100644
--- a/compiler/rustc_middle/src/dep_graph/dep_node.rs
+++ b/compiler/rustc_middle/src/dep_graph/dep_node.rs
@@ -94,10 +94,14 @@ pub const fn as_usize(&self) -> usize {
 pub struct DepNode {
     pub kind: DepKind,
 
-    /// This is _typically_ a hash of the query key, but sometimes not.
+    /// If `kind` is a query method, then its "key fingerprint" is always a
+    /// stable hash of the query key.
     ///
-    /// For example, `anon` nodes have a fingerprint that is derived from their
-    /// dependencies instead of a key.
+    /// For non-query nodes, the content of this field varies:
+    /// - Some dep kinds always use a dummy `ZERO` fingerprint.
+    /// - Some dep kinds use the stable hash of some relevant key-like value.
+    /// - Some dep kinds use the `with_anon_task` mechanism, and set their key
+    ///   fingerprint to a hash derived from the task's dependencies.
     ///
     /// In some cases the key value can be reconstructed from this fingerprint;
     /// see [`KeyFingerprintStyle`].
diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index d410d9a48cd1..d0d7d581b439 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -375,9 +375,8 @@ pub fn with_task<'tcx, A: Debug, R>(
     /// incorrectly marked green.
     ///
     /// FIXME: This could perhaps return a `WithDepNode` to ensure that the
-    /// user of this function actually performs the read; we'll have to see
-    /// how to make that work with `anon` in `execute_job_incr`, though.
-    pub fn with_anon_task_inner<'tcx, OP, R>(
+    /// user of this function actually performs the read.
+    fn with_anon_task_inner<'tcx, OP, R>(
         &self,
         tcx: TyCtxt<'tcx>,
         dep_kind: DepKind,
diff --git a/compiler/rustc_middle/src/query/modifiers.rs b/compiler/rustc_middle/src/query/modifiers.rs
index a1f8ec2e9af0..50c9136ac6e9 100644
--- a/compiler/rustc_middle/src/query/modifiers.rs
+++ b/compiler/rustc_middle/src/query/modifiers.rs
@@ -7,11 +7,6 @@
 
 // tidy-alphabetical-start
 //
-/// # `anon` query modifier
-///
-/// Generate a dep node based not on the query key, but on the query's dependencies.
-pub(crate) struct anon;
-
 /// # `arena_cache` query modifier
 ///
 /// Query return values must impl `Copy` and be small, but some queries must return values that
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index ed094790b59b..dcf7a952fb97 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -77,8 +77,6 @@ pub enum EnsureMode {
 pub struct QueryVTable<'tcx, C: QueryCache> {
     pub name: &'static str,
 
-    /// True if this query has the `anon` modifier.
-    pub anon: bool,
     /// True if this query has the `eval_always` modifier.
     pub eval_always: bool,
     /// True if this query has the `depth_limit` modifier.
@@ -283,7 +281,6 @@ macro_rules! define_callbacks {
                 fn $name:ident($($K:tt)*) -> $V:ty
                 {
                     // Search for (QMODLIST) to find all occurrences of this query modifier list.
-                    anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
                     depth_limit: $depth_limit:literal,
diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 65ab207b04e6..44b92dc727ab 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -96,7 +96,6 @@ pub(crate) fn Metadata<'tcx>() -> DepKindVTable<'tcx> {
 /// Shared implementation of the [`DepKindVTable`] constructor for queries.
 /// Called from macro-generated code for each query.
 pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
-    is_anon: bool,
     is_cache_on_disk: bool,
     is_eval_always: bool,
     is_no_force: bool,
@@ -104,18 +103,10 @@ pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
 where
     Q: GetQueryVTable<'tcx>,
 {
-    let key_fingerprint_style = if is_anon {
-        KeyFingerprintStyle::Opaque
-    } else {
-        <Q::Cache as QueryCache>::Key::key_fingerprint_style()
-    };
-
     // A query dep-node can only be forced or promoted if it can recover a key
     // from its key fingerprint.
+    let key_fingerprint_style = <Q::Cache as QueryCache>::Key::key_fingerprint_style();
     let can_recover = key_fingerprint_style.is_maybe_recoverable();
-    if is_anon {
-        assert!(!can_recover);
-    }
 
     DepKindVTable {
         is_eval_always,
@@ -135,7 +126,6 @@ macro_rules! define_dep_kind_vtables {
                 fn $name:ident($K:ty) -> $V:ty
                 {
                     // Search for (QMODLIST) to find all occurrences of this query modifier list.
-                    anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
                     depth_limit: $depth_limit:literal,
@@ -168,7 +158,6 @@ fn $name:ident($K:ty) -> $V:ty
                 $crate::dep_kind_vtables::make_dep_kind_vtable_for_query::<
                     $crate::query_impl::$name::VTableGetter,
                 >(
-                    $anon,
                     $cache_on_disk,
                     $eval_always,
                     $no_force,
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index aea0bb4d3534..bbd55e9ead11 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -424,7 +424,7 @@ fn execute_job_incr<'tcx, C: QueryCache>(
     let dep_graph_data =
         tcx.dep_graph.data().expect("should always be present in incremental mode");
 
-    if !query.anon && !query.eval_always {
+    if !query.eval_always {
         // `to_dep_node` is expensive for some `DepKind`s.
         let dep_node =
             dep_node_opt.get_or_insert_with(|| DepNode::construct(tcx, query.dep_kind, &key));
@@ -451,13 +451,6 @@ fn execute_job_incr<'tcx, C: QueryCache>(
     let prof_timer = tcx.prof.query_provider();
 
     let (result, dep_node_index) = start_query(job_id, query.depth_limit, || {
-        if query.anon {
-            // Call the query provider inside an anon task.
-            return dep_graph_data.with_anon_task_inner(tcx, query.dep_kind, || {
-                (query.invoke_provider_fn)(tcx, key)
-            });
-        }
-
         // `to_dep_node` is expensive for some `DepKind`s.
         let dep_node =
             dep_node_opt.unwrap_or_else(|| DepNode::construct(tcx, query.dep_kind, &key));
@@ -601,9 +594,6 @@ fn check_if_ensure_can_skip_execution<'tcx, C: QueryCache>(
         return EnsureCanSkip { skip_execution: false, dep_node: None };
     }
 
-    // Ensuring an anonymous query makes no sense
-    assert!(!query.anon);
-
     let dep_node = DepNode::construct(tcx, query.dep_kind, &key);
 
     let serialized_dep_node_index = match tcx.dep_graph.try_mark_green(tcx, &dep_node) {
@@ -703,8 +693,6 @@ pub(crate) fn force_query<'tcx, C: QueryCache>(
         return;
     }
 
-    debug_assert!(!query.anon);
-
     ensure_sufficient_stack(|| {
         try_execute_query::<C, true>(query, tcx, DUMMY_SP, key, Some(dep_node))
     });
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index 4eccabbb4245..56b7534da9ed 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -16,7 +16,6 @@ macro_rules! define_queries {
                 fn $name:ident($K:ty) -> $V:ty
                 {
                     // Search for (QMODLIST) to find all occurrences of this query modifier list.
-                    anon: $anon:literal,
                     arena_cache: $arena_cache:literal,
                     cache_on_disk: $cache_on_disk:literal,
                     depth_limit: $depth_limit:literal,
@@ -133,7 +132,6 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
 
                     QueryVTable {
                         name: stringify!($name),
-                        anon: $anon,
                         eval_always: $eval_always,
                         depth_limit: $depth_limit,
                         feedable: $feedable,
diff --git a/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
index a1af9c4e561b..014d1a08af78 100644
--- a/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
+++ b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
@@ -485,13 +485,6 @@ respect to incremental compilation:
    For example, it makes no sense to store values from upstream
    crates in the cache because they are already available in the upstream crate's metadata.
 
- - `anon` - This attribute makes the system use "anonymous" dep-nodes for the given query.
-   An anonymous dep-node is not identified by the corresponding query key.
-   Instead, its ID is computed from the IDs of its dependencies.
-   This allows the red-green system to do its change detection even if there is no
-   query key available for a given dep-node -- something which is needed for
-   handling trait selection because it is not based on queries.
-
 [mod]: ../query.html#adding-a-new-kind-of-query
 
 

From 50c564e6790e0b8ec271e2354a3f74a60a7dfc58 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Thu, 12 Mar 2026 13:25:40 +0300
Subject: [PATCH 0734/1059] Make par_slice consistent with single-threaded
 execution

---
 .../src/sync/parallel.rs                      | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_data_structures/src/sync/parallel.rs b/compiler/rustc_data_structures/src/sync/parallel.rs
index cbf88efea18d..b112ecc2fbad 100644
--- a/compiler/rustc_data_structures/src/sync/parallel.rs
+++ b/compiler/rustc_data_structures/src/sync/parallel.rs
@@ -129,12 +129,28 @@ fn par_slice<I: DynSend>(
     for_each: impl Fn(&mut I) + DynSync + DynSend,
     proof: FromDyn<()>,
 ) {
+    match items {
+        [] => return,
+        [item] => {
+            guard.run(|| for_each(item));
+            return;
+        }
+        _ => (),
+    }
+
     let for_each = proof.derive(for_each);
     let mut items = for_each.derive(items);
     rustc_thread_pool::scope(|s| {
         let proof = items.derive(());
-        let group_size = std::cmp::max(items.len() / 128, 1);
-        for group in items.chunks_mut(group_size) {
+
+        const MAX_GROUP_COUNT: usize = 128;
+        let group_size = items.len().div_ceil(MAX_GROUP_COUNT);
+        let groups = items.chunks_mut(group_size);
+
+        // Reverse the order of the later functions since Rayon executes them in reverse
+        // order when using a single thread. This ensures the execution order matches
+        // that of a single threaded rustc.
+        for group in groups.rev() {
             let group = proof.derive(group);
             s.spawn(|_| {
                 let mut group = group;

From fe363d0f43c1a9c0b6ec8e54b3d69a6b7cb5c360 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sat, 21 Mar 2026 02:11:21 -0400
Subject: [PATCH 0735/1059] enzyme submodule update

---
 src/tools/enzyme | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/enzyme b/src/tools/enzyme
index 0b86a6759e5f..324402444ac4 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit 0b86a6759e5f250d6691a94a4a779a44d846e25b
+Subproject commit 324402444ac48874d8ebd3ac767330bdc7cb1c06

From c1a24b4a9cccde386bad58b88aa7d8449cf6a5d7 Mon Sep 17 00:00:00 2001
From: Amit Singhmar <abhay.singhmar2@gmail.com>
Date: Sat, 21 Mar 2026 16:24:18 +0800
Subject: [PATCH 0736/1059] ide-assists: add tests for const, static in
 add_braces

---
 .../ide-assists/src/handlers/add_braces.rs    | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
index 99ee50fa5848..7c340d91027f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
@@ -178,6 +178,36 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn suggest_add_braces_for_const_initializer() {
+        check_assist(
+            add_braces,
+            r#"
+const X: i32 =$0 1 + 2;
+"#,
+            r#"
+const X: i32 = {
+    1 + 2
+};
+"#,
+        );
+    }
+
+    #[test]
+    fn suggest_add_braces_for_static_initializer() {
+        check_assist(
+            add_braces,
+            r#"
+static X: i32 $0= 1 + 2;
+"#,
+            r#"
+static X: i32 = {
+    1 + 2
+};
+"#,
+        );
+    }
+
     #[test]
     fn no_assist_for_closures_with_braces() {
         check_assist_not_applicable(

From 9bff35bd8015f31bef46aec598d12ce6b9a21444 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 21 Mar 2026 16:16:03 +0800
Subject: [PATCH 0737/1059] add tests for let-expr in add_braces

---
 .../ide-assists/src/handlers/add_braces.rs     | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
index 7c340d91027f..35ee1e5a7816 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
@@ -174,6 +174,24 @@ fn foo() {
         n + 100
     };
 }
+"#,
+        );
+
+        check_assist(
+            add_braces,
+            r#"
+fn foo() {
+    let x;
+    x =$0 n + 100;
+}
+"#,
+            r#"
+fn foo() {
+    let x;
+    x = {
+        n + 100
+    };
+}
 "#,
         );
     }

From dc8d64dbd4541fa1886aa54537baa1bb98722674 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 21 Mar 2026 16:16:03 +0800
Subject: [PATCH 0738/1059] feat: offer 'add_braces' on bin-expr assignment

Example
---
```rust
fn foo() {
    let x;
    x =$0 n + 100;
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
fn foo() {
    let x;
    x = {
        n + 100
    };
}
```
---
 .../ide-assists/src/handlers/add_braces.rs      | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
index 35ee1e5a7816..da1322de4b64 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
@@ -84,6 +84,7 @@ fn get_replacement_node(ctx: &AssistContext<'_>) -> Option<(ParentType, ast::Exp
             match parent {
                 ast::LetStmt(it) => it.initializer()?,
                 ast::LetExpr(it) => it.expr()?,
+                ast::BinExpr(it) => it.rhs()?,
                 ast::Static(it) => it.body()?,
                 ast::Const(it) => it.body()?,
                 _ => return None,
@@ -192,6 +193,22 @@ fn foo() {
         n + 100
     };
 }
+"#,
+        );
+
+        check_assist(
+            add_braces,
+            r#"
+fn foo() {
+    if let x =$0 n + 100 {}
+}
+"#,
+            r#"
+fn foo() {
+    if let x = {
+        n + 100
+    } {}
+}
 "#,
         );
     }

From 1a05c119c2407be1364e5266e5add44cda009e0a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 21 Mar 2026 10:29:56 +0000
Subject: [PATCH 0739/1059] Bump flatted from 3.3.3 to 3.4.2 in /editors/code

Bumps [flatted](https://github.com/WebReflection/flatted) from 3.3.3 to 3.4.2.
- [Commits](https://github.com/WebReflection/flatted/compare/v3.3.3...v3.4.2)

---
updated-dependencies:
- dependency-name: flatted
  dependency-version: 3.4.2
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/rust-analyzer/editors/code/package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 4bddc28c1ef7..047dbba11fcf 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -3697,9 +3697,9 @@
             }
         },
         "node_modules/flatted": {
-            "version": "3.3.3",
-            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-            "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+            "version": "3.4.2",
+            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+            "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
             "dev": true,
             "license": "ISC"
         },

From 125cefc89ae8e55d8b1a2635ab4d5c653490f9d9 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Sat, 21 Mar 2026 06:45:55 +0000
Subject: [PATCH 0740/1059] freebsd sync: fix _umtx_time flags check to use
 bitwise operation.

The `_umtx_time` flags check in `read_umtx_time` used equality (`flags == abs_time`) instead of bitwise AND (`flags & abs_time != 0`) to detect `UMTX_ABSTIME`. While functionally equivalent for current valid inputs (0 or `UMTX_ABSTIME` alone), the equality check would silently treat an absolute timeout as relative if `flags` had `UMTX_ABSTIME` set alongside other bits. Additionally, unknown flags were silently accepted, whereas the FreeBSD kernel (`umtx_copyin_umtx_time()` in `kern_umtx.c`) rejects them with `EINVAL`.

The fix adds validation that rejects unsupported flags and switches to the standard bitwise AND pattern used elsewhere in the codebase (e.g. `O_APPEND`/`O_TRUNC` checks in `fs.rs`).
---
 src/tools/miri/src/shims/unix/freebsd/sync.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/freebsd/sync.rs b/src/tools/miri/src/shims/unix/freebsd/sync.rs
index 8cf446438963..8c585c7ec264 100644
--- a/src/tools/miri/src/shims/unix/freebsd/sync.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/sync.rs
@@ -216,7 +216,12 @@ fn read_umtx_time(&mut self, ut: &MPlaceTy<'tcx>) -> InterpResult<'tcx, Option<U
 
         let flags_place = this.project_field(ut, FieldIdx::from_u32(1))?;
         let flags = this.read_scalar(&flags_place)?.to_u32()?;
-        let abs_time_flag = flags == abs_time;
+
+        if flags & !abs_time != 0 {
+            throw_unsup_format!("unsupported `_umtx_time` flags: {:#x}", flags);
+        }
+
+        let abs_time_flag = flags & abs_time != 0;
 
         let clock_id_place = this.project_field(ut, FieldIdx::from_u32(2))?;
         let clock_id = this.read_scalar(&clock_id_place)?;

From e844c24122d10c6a4a944ffb1a85c8f36d20a41e Mon Sep 17 00:00:00 2001
From: b-naber <b_naber@gmx.de>
Date: Tue, 3 Feb 2026 15:29:55 +0000
Subject: [PATCH 0741/1059] resolve namespaced crates with open modules

---
 compiler/rustc_hir/src/def.rs                 |  19 ++-
 .../src/hir_ty_lowering/mod.rs                |   1 +
 compiler/rustc_passes/src/dead.rs             |   2 +-
 .../rustc_resolve/src/build_reduced_graph.rs  |   1 +
 compiler/rustc_resolve/src/diagnostics.rs     |   8 +-
 compiler/rustc_resolve/src/ident.rs           |  16 +-
 compiler/rustc_resolve/src/imports.rs         |   2 +-
 compiler/rustc_resolve/src/lib.rs             | 144 ++++++++++++------
 compiler/rustc_session/src/config/externs.rs  |   7 +
 .../resolve/auxiliary/open-ns-mod-my_api.rs   |   9 ++
 tests/ui/resolve/auxiliary/open-ns-my_api.rs  |   3 +
 .../resolve/auxiliary/open-ns-my_api_core.rs  |  15 ++
 .../resolve/auxiliary/open-ns-my_api_utils.rs |  13 ++
 tests/ui/resolve/open-ns-1.rs                 |  19 +++
 tests/ui/resolve/open-ns-1.stderr             |  22 +++
 tests/ui/resolve/open-ns-10.rs                |   8 +
 tests/ui/resolve/open-ns-10.stderr            |   2 +
 tests/ui/resolve/open-ns-11.rs                |  12 ++
 tests/ui/resolve/open-ns-11.stderr            |   9 ++
 tests/ui/resolve/open-ns-2.rs                 |  18 +++
 tests/ui/resolve/open-ns-2.stderr             |  15 ++
 tests/ui/resolve/open-ns-3.rs                 |  14 ++
 tests/ui/resolve/open-ns-3.stderr             |  19 +++
 tests/ui/resolve/open-ns-4.rs                 |  12 ++
 tests/ui/resolve/open-ns-4.stderr             |   9 ++
 tests/ui/resolve/open-ns-5.rs                 |  18 +++
 tests/ui/resolve/open-ns-6.rs                 |  13 ++
 tests/ui/resolve/open-ns-7.rs                 |  14 ++
 tests/ui/resolve/open-ns-7.stderr             |  16 ++
 tests/ui/resolve/open-ns-8.rs                 |  23 +++
 tests/ui/resolve/open-ns-9.rs                 |  25 +++
 tests/ui/resolve/open-ns-9.stderr             |  27 ++++
 32 files changed, 481 insertions(+), 54 deletions(-)
 create mode 100644 tests/ui/resolve/auxiliary/open-ns-mod-my_api.rs
 create mode 100644 tests/ui/resolve/auxiliary/open-ns-my_api.rs
 create mode 100644 tests/ui/resolve/auxiliary/open-ns-my_api_core.rs
 create mode 100644 tests/ui/resolve/auxiliary/open-ns-my_api_utils.rs
 create mode 100644 tests/ui/resolve/open-ns-1.rs
 create mode 100644 tests/ui/resolve/open-ns-1.stderr
 create mode 100644 tests/ui/resolve/open-ns-10.rs
 create mode 100644 tests/ui/resolve/open-ns-10.stderr
 create mode 100644 tests/ui/resolve/open-ns-11.rs
 create mode 100644 tests/ui/resolve/open-ns-11.stderr
 create mode 100644 tests/ui/resolve/open-ns-2.rs
 create mode 100644 tests/ui/resolve/open-ns-2.stderr
 create mode 100644 tests/ui/resolve/open-ns-3.rs
 create mode 100644 tests/ui/resolve/open-ns-3.stderr
 create mode 100644 tests/ui/resolve/open-ns-4.rs
 create mode 100644 tests/ui/resolve/open-ns-4.stderr
 create mode 100644 tests/ui/resolve/open-ns-5.rs
 create mode 100644 tests/ui/resolve/open-ns-6.rs
 create mode 100644 tests/ui/resolve/open-ns-7.rs
 create mode 100644 tests/ui/resolve/open-ns-7.stderr
 create mode 100644 tests/ui/resolve/open-ns-8.rs
 create mode 100644 tests/ui/resolve/open-ns-9.rs
 create mode 100644 tests/ui/resolve/open-ns-9.stderr

diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 3959ee7f9412..76bab70e5c0d 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -590,6 +590,13 @@ pub enum Res<Id = hir::HirId> {
     /// **Belongs to the type namespace.**
     ToolMod,
 
+    /// The resolution for an open module in a namespaced crate. E.g. `my_api`
+    /// in the namespaced crate `my_api::utils` when `my_api` isn't part of the
+    /// extern prelude.
+    ///
+    /// **Belongs to the type namespace.**
+    OpenMod(Symbol),
+
     // Macro namespace
     /// An attribute that is *not* implemented via macro.
     /// E.g., `#[inline]` and `#[rustfmt::skip]`, which are essentially directives,
@@ -838,6 +845,7 @@ pub fn opt_def_id(&self) -> Option<DefId> {
             | Res::SelfTyAlias { .. }
             | Res::SelfCtor(..)
             | Res::ToolMod
+            | Res::OpenMod(..)
             | Res::NonMacroAttr(..)
             | Res::Err => None,
         }
@@ -869,6 +877,7 @@ pub fn descr(&self) -> &'static str {
             Res::Local(..) => "local variable",
             Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => "self type",
             Res::ToolMod => "tool module",
+            Res::OpenMod(..) => "namespaced crate",
             Res::NonMacroAttr(attr_kind) => attr_kind.descr(),
             Res::Err => "unresolved item",
         }
@@ -895,6 +904,7 @@ pub fn map_id<R>(self, mut map: impl FnMut(Id) -> R) -> Res<R> {
                 Res::SelfTyAlias { alias_to, is_trait_impl }
             }
             Res::ToolMod => Res::ToolMod,
+            Res::OpenMod(sym) => Res::OpenMod(sym),
             Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind),
             Res::Err => Res::Err,
         }
@@ -911,6 +921,7 @@ pub fn apply_id<R, E>(self, mut map: impl FnMut(Id) -> Result<R, E>) -> Result<R
                 Res::SelfTyAlias { alias_to, is_trait_impl }
             }
             Res::ToolMod => Res::ToolMod,
+            Res::OpenMod(sym) => Res::OpenMod(sym),
             Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind),
             Res::Err => Res::Err,
         })
@@ -936,9 +947,11 @@ pub fn macro_kinds(self) -> Option<MacroKinds> {
     pub fn ns(&self) -> Option<Namespace> {
         match self {
             Res::Def(kind, ..) => kind.ns(),
-            Res::PrimTy(..) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::ToolMod => {
-                Some(Namespace::TypeNS)
-            }
+            Res::PrimTy(..)
+            | Res::SelfTyParam { .. }
+            | Res::SelfTyAlias { .. }
+            | Res::ToolMod
+            | Res::OpenMod(..) => Some(Namespace::TypeNS),
             Res::SelfCtor(..) | Res::Local(..) => Some(Namespace::ValueNS),
             Res::NonMacroAttr(..) => Some(Namespace::MacroNS),
             Res::Err => None,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 8b1dad9a6547..c6829a941bbe 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2786,6 +2786,7 @@ fn lower_resolved_const_path(
             | Res::SelfCtor(_)
             | Res::Local(_)
             | Res::ToolMod
+            | Res::OpenMod(..)
             | Res::NonMacroAttr(_)
             | Res::Err) => Const::new_error_with_message(
                 tcx,
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 15c91deef247..30634c800e81 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -157,7 +157,7 @@ fn handle_res(&mut self, res: Res) {
             Res::Def(_, def_id) => self.check_def_id(def_id),
             Res::SelfTyParam { trait_: t } => self.check_def_id(t),
             Res::SelfTyAlias { alias_to: i, .. } => self.check_def_id(i),
-            Res::ToolMod | Res::NonMacroAttr(..) | Res::Err => {}
+            Res::ToolMod | Res::NonMacroAttr(..) | Res::OpenMod(..) | Res::Err => {}
         }
     }
 
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index a280acc0d51d..af9680ac8888 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -357,6 +357,7 @@ fn build_reduced_graph_for_external_crate_res(
             | Res::SelfTyParam { .. }
             | Res::SelfTyAlias { .. }
             | Res::SelfCtor(..)
+            | Res::OpenMod(..)
             | Res::Err => bug!("unexpected resolution: {:?}", res),
         }
     }
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index c776020c2127..fd5bf2da5fc6 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1,3 +1,4 @@
+// ignore-tidy-filelength
 use std::ops::ControlFlow;
 
 use itertools::Itertools as _;
@@ -1735,8 +1736,8 @@ pub(crate) fn unresolved_macro_suggestions(
                 Res::Def(DefKind::Macro(kinds), _) => {
                     format!("{} {}", kinds.article(), kinds.descr())
                 }
-                Res::ToolMod => {
-                    // Don't confuse the user with tool modules.
+                Res::ToolMod | Res::OpenMod(..) => {
+                    // Don't confuse the user with tool modules or open modules.
                     continue;
                 }
                 Res::Def(DefKind::Trait, _) if macro_kind == MacroKind::Derive => {
@@ -1973,7 +1974,8 @@ fn decl_description(&self, b: Decl<'_>, ident: Ident, scope: Scope<'_>) -> Strin
             let (built_in, from) = match scope {
                 Scope::StdLibPrelude | Scope::MacroUsePrelude => ("", " from prelude"),
                 Scope::ExternPreludeFlags
-                    if self.tcx.sess.opts.externs.get(ident.as_str()).is_some() =>
+                    if self.tcx.sess.opts.externs.get(ident.as_str()).is_some()
+                        || matches!(res, Res::OpenMod(..)) =>
                 {
                     ("", " passed with `--extern`")
                 }
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 7cfd5b5f861a..cd3f63304f02 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -26,7 +26,7 @@
     AmbiguityError, AmbiguityKind, AmbiguityWarning, BindingKey, CmResolver, Decl, DeclKind,
     Determinacy, Finalize, IdentKey, ImportKind, LateDecl, Module, ModuleKind, ModuleOrUniformRoot,
     ParentScope, PathResult, PrivacyError, Res, ResolutionError, Resolver, Scope, ScopeSet,
-    Segment, Stage, Used, errors,
+    Segment, Stage, Symbol, Used, errors,
 };
 
 #[derive(Copy, Clone)]
@@ -386,7 +386,6 @@ pub(crate) fn resolve_ident_in_lexical_scope(
     }
 
     /// Resolve an identifier in the specified set of scopes.
-    #[instrument(level = "debug", skip(self))]
     pub(crate) fn resolve_ident_in_scope_set<'r>(
         self: CmResolver<'r, 'ra, 'tcx>,
         orig_ident: Ident,
@@ -976,6 +975,14 @@ pub(crate) fn resolve_ident_in_module<'r>(
                     ignore_import,
                 )
             }
+            ModuleOrUniformRoot::OpenModule(sym) => {
+                let open_ns_name = format!("{}::{}", sym.as_str(), ident.name);
+                let ns_ident = IdentKey::with_root_ctxt(Symbol::intern(&open_ns_name));
+                match self.extern_prelude_get_flag(ns_ident, ident.span, finalize.is_some()) {
+                    Some(decl) => Ok(decl),
+                    None => Err(Determinacy::Determined),
+                }
+            }
             ModuleOrUniformRoot::ModuleAndExternPrelude(module) => self.resolve_ident_in_scope_set(
                 ident,
                 ScopeSet::ModuleAndExternPrelude(ns, module),
@@ -1962,7 +1969,10 @@ fn record_segment_res<'r, 'ra, 'tcx>(
                     }
 
                     let maybe_assoc = opt_ns != Some(MacroNS) && PathSource::Type.is_expected(res);
-                    if let Some(def_id) = binding.res().module_like_def_id() {
+                    if let Res::OpenMod(sym) = binding.res() {
+                        module = Some(ModuleOrUniformRoot::OpenModule(sym));
+                        record_segment_res(self.reborrow(), finalize, res, id);
+                    } else if let Some(def_id) = binding.res().module_like_def_id() {
                         if self.mods_with_parse_errors.contains(&def_id) {
                             module_had_parse_errors = true;
                         }
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 7696b4b220d6..8f534de0f76d 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -41,7 +41,7 @@
 
 /// A potential import declaration in the process of being planted into a module.
 /// Also used for lazily planting names from `--extern` flags to extern prelude.
-#[derive(Clone, Copy, Default, PartialEq)]
+#[derive(Clone, Copy, Default, PartialEq, Debug)]
 pub(crate) enum PendingDecl<'ra> {
     Ready(Option<Decl<'ra>>),
     #[default]
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 6b3b5e2ec45f..9aa96ce27e08 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -64,6 +64,7 @@
 use rustc_hir::{PrimTy, TraitCandidate, find_attr};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_metadata::creader::CStore;
+use rustc_middle::bug;
 use rustc_middle::metadata::{AmbigModChild, ModChild, Reexport};
 use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::query::Providers;
@@ -448,6 +449,11 @@ enum ModuleOrUniformRoot<'ra> {
     /// Used only for resolving single-segment imports. The reason it exists is that import paths
     /// are always split into two parts, the first of which should be some kind of module.
     CurrentScope,
+
+    /// Virtual module for the resolution of base names of namespaced crates,
+    /// where the base name doesn't correspond to a module in the extern prelude.
+    /// E.g. `my_api::utils` is in the prelude, but `my_api` is not.
+    OpenModule(Symbol),
 }
 
 #[derive(Debug)]
@@ -1108,13 +1114,20 @@ fn determined(&self) -> bool {
     }
 }
 
+#[derive(Debug)]
 struct ExternPreludeEntry<'ra> {
     /// Name declaration from an `extern crate` item.
     /// The boolean flag is true is `item_decl` is non-redundant, happens either when
     /// `flag_decl` is `None`, or when `extern crate` introducing `item_decl` used renaming.
     item_decl: Option<(Decl<'ra>, Span, /* introduced by item */ bool)>,
     /// Name declaration from an `--extern` flag, lazily populated on first use.
-    flag_decl: Option<CacheCell<(PendingDecl<'ra>, /* finalized */ bool)>>,
+    flag_decl: Option<
+        CacheCell<(
+            PendingDecl<'ra>,
+            /* finalized */ bool,
+            /* open flag (namespaced crate) */ bool,
+        )>,
+    >,
 }
 
 impl ExternPreludeEntry<'_> {
@@ -1125,7 +1138,14 @@ fn introduced_by_item(&self) -> bool {
     fn flag() -> Self {
         ExternPreludeEntry {
             item_decl: None,
-            flag_decl: Some(CacheCell::new((PendingDecl::Pending, false))),
+            flag_decl: Some(CacheCell::new((PendingDecl::Pending, false, false))),
+        }
+    }
+
+    fn open_flag() -> Self {
+        ExternPreludeEntry {
+            item_decl: None,
+            flag_decl: Some(CacheCell::new((PendingDecl::Pending, false, true))),
         }
     }
 
@@ -1637,35 +1657,7 @@ pub fn new(
         let mut invocation_parents = FxHashMap::default();
         invocation_parents.insert(LocalExpnId::ROOT, InvocationParent::ROOT);
 
-        let mut extern_prelude: FxIndexMap<_, _> = tcx
-            .sess
-            .opts
-            .externs
-            .iter()
-            .filter_map(|(name, entry)| {
-                // Make sure `self`, `super`, `_` etc do not get into extern prelude.
-                // FIXME: reject `--extern self` and similar in option parsing instead.
-                if entry.add_prelude
-                    && let name = Symbol::intern(name)
-                    && name.can_be_raw()
-                {
-                    let ident = IdentKey::with_root_ctxt(name);
-                    Some((ident, ExternPreludeEntry::flag()))
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        if !attr::contains_name(attrs, sym::no_core) {
-            let ident = IdentKey::with_root_ctxt(sym::core);
-            extern_prelude.insert(ident, ExternPreludeEntry::flag());
-            if !attr::contains_name(attrs, sym::no_std) {
-                let ident = IdentKey::with_root_ctxt(sym::std);
-                extern_prelude.insert(ident, ExternPreludeEntry::flag());
-            }
-        }
-
+        let extern_prelude = build_extern_prelude(tcx, attrs);
         let registered_tools = tcx.registered_tools(());
         let edition = tcx.sess.edition();
 
@@ -2320,10 +2312,10 @@ fn extern_prelude_get_flag(
     ) -> Option<Decl<'ra>> {
         let entry = self.extern_prelude.get(&ident);
         entry.and_then(|entry| entry.flag_decl.as_ref()).and_then(|flag_decl| {
-            let (pending_decl, finalized) = flag_decl.get();
+            let (pending_decl, finalized, is_open) = flag_decl.get();
             let decl = match pending_decl {
                 PendingDecl::Ready(decl) => {
-                    if finalize && !finalized {
+                    if finalize && !finalized && !is_open {
                         self.cstore_mut().process_path_extern(
                             self.tcx,
                             ident.name,
@@ -2334,18 +2326,28 @@ fn extern_prelude_get_flag(
                 }
                 PendingDecl::Pending => {
                     debug_assert!(!finalized);
-                    let crate_id = if finalize {
-                        self.cstore_mut().process_path_extern(self.tcx, ident.name, orig_ident_span)
+                    if is_open {
+                        let res = Res::OpenMod(ident.name);
+                        Some(self.arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT))
                     } else {
-                        self.cstore_mut().maybe_process_path_extern(self.tcx, ident.name)
-                    };
-                    crate_id.map(|crate_id| {
-                        let res = Res::Def(DefKind::Mod, crate_id.as_def_id());
-                        self.arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT)
-                    })
+                        let crate_id = if finalize {
+                            self.cstore_mut().process_path_extern(
+                                self.tcx,
+                                ident.name,
+                                orig_ident_span,
+                            )
+                        } else {
+                            self.cstore_mut().maybe_process_path_extern(self.tcx, ident.name)
+                        };
+                        crate_id.map(|crate_id| {
+                            let def_id = crate_id.as_def_id();
+                            let res = Res::Def(DefKind::Mod, def_id);
+                            self.arenas.new_pub_def_decl(res, DUMMY_SP, LocalExpnId::ROOT)
+                        })
+                    }
                 }
             };
-            flag_decl.set((PendingDecl::Ready(decl), finalize || finalized));
+            flag_decl.set((PendingDecl::Ready(decl), finalize || finalized, is_open));
             decl.or_else(|| finalize.then_some(self.dummy_decl))
         })
     }
@@ -2387,7 +2389,9 @@ fn resolve_rustdoc_path(
             PathResult::Module(ModuleOrUniformRoot::ExternPrelude) | PathResult::Failed { .. } => {
                 None
             }
-            PathResult::Module(..) | PathResult::Indeterminate => unreachable!(),
+            path_result @ (PathResult::Module(..) | PathResult::Indeterminate) => {
+                bug!("got invalid path_result: {path_result:?}")
+            }
         }
     }
 
@@ -2505,6 +2509,60 @@ fn resolve_main(&mut self) {
     }
 }
 
+fn build_extern_prelude<'tcx, 'ra>(
+    tcx: TyCtxt<'tcx>,
+    attrs: &[ast::Attribute],
+) -> FxIndexMap<IdentKey, ExternPreludeEntry<'ra>> {
+    let mut extern_prelude: FxIndexMap<IdentKey, ExternPreludeEntry<'ra>> = tcx
+        .sess
+        .opts
+        .externs
+        .iter()
+        .filter_map(|(name, entry)| {
+            // Make sure `self`, `super`, `_` etc do not get into extern prelude.
+            // FIXME: reject `--extern self` and similar in option parsing instead.
+            if entry.add_prelude
+                && let sym = Symbol::intern(name)
+                && sym.can_be_raw()
+            {
+                Some((IdentKey::with_root_ctxt(sym), ExternPreludeEntry::flag()))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Add open base entries for namespaced crates whose base segment
+    // is missing from the prelude (e.g. `foo::bar` without `foo`).
+    // These are necessary in order to resolve the open modules, whereas
+    // the namespaced names are necessary in `extern_prelude` for actually
+    // resolving the namespaced crates.
+    let missing_open_bases: Vec<IdentKey> = extern_prelude
+        .keys()
+        .filter_map(|ident| {
+            let (base, _) = ident.name.as_str().split_once("::")?;
+            let base_sym = Symbol::intern(base);
+            base_sym.can_be_raw().then(|| IdentKey::with_root_ctxt(base_sym))
+        })
+        .filter(|base_ident| !extern_prelude.contains_key(base_ident))
+        .collect();
+
+    extern_prelude.extend(
+        missing_open_bases.into_iter().map(|ident| (ident, ExternPreludeEntry::open_flag())),
+    );
+
+    // Inject `core` / `std` unless suppressed by attributes.
+    if !attr::contains_name(attrs, sym::no_core) {
+        extern_prelude.insert(IdentKey::with_root_ctxt(sym::core), ExternPreludeEntry::flag());
+
+        if !attr::contains_name(attrs, sym::no_std) {
+            extern_prelude.insert(IdentKey::with_root_ctxt(sym::std), ExternPreludeEntry::flag());
+        }
+    }
+
+    extern_prelude
+}
+
 fn names_to_string(names: impl Iterator<Item = Symbol>) -> String {
     let mut result = String::new();
     for (i, name) in names.enumerate().filter(|(_, name)| *name != kw::PathRoot) {
diff --git a/compiler/rustc_session/src/config/externs.rs b/compiler/rustc_session/src/config/externs.rs
index d668d8b4203d..ff76eaaeaf4f 100644
--- a/compiler/rustc_session/src/config/externs.rs
+++ b/compiler/rustc_session/src/config/externs.rs
@@ -43,6 +43,13 @@ pub(crate) fn split_extern_opt<'a>(
         }
     };
 
+    // Reject paths with more than two segments.
+    if unstable_opts.namespaced_crates && crate_name.split("::").count() > 2 {
+        return Err(early_dcx.early_struct_fatal(format!(
+            "crate name `{crate_name}` passed to `--extern` can have at most two segments."
+        )));
+    }
+
     if !valid_crate_name(&crate_name, unstable_opts) {
         let mut error = early_dcx.early_struct_fatal(format!(
             "crate name `{crate_name}` passed to `--extern` is not a valid ASCII identifier"
diff --git a/tests/ui/resolve/auxiliary/open-ns-mod-my_api.rs b/tests/ui/resolve/auxiliary/open-ns-mod-my_api.rs
new file mode 100644
index 000000000000..dc8b5720c0c1
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/open-ns-mod-my_api.rs
@@ -0,0 +1,9 @@
+pub mod utils {
+    pub fn root_helper() {
+        println!("root_helper");
+    }
+}
+
+pub fn root_function() -> String {
+    "my_api root!".to_string()
+}
diff --git a/tests/ui/resolve/auxiliary/open-ns-my_api.rs b/tests/ui/resolve/auxiliary/open-ns-my_api.rs
new file mode 100644
index 000000000000..be4bf31f0fbc
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/open-ns-my_api.rs
@@ -0,0 +1,3 @@
+pub fn root_function() -> String {
+    "my_api root!".to_string()
+}
diff --git a/tests/ui/resolve/auxiliary/open-ns-my_api_core.rs b/tests/ui/resolve/auxiliary/open-ns-my_api_core.rs
new file mode 100644
index 000000000000..41418f1516f6
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/open-ns-my_api_core.rs
@@ -0,0 +1,15 @@
+// #![crate_name = "my_api::core"]
+
+pub mod util {
+    pub fn core_mod_fn() -> String {
+        format!("core_fn from my_api::core::util",)
+    }
+}
+
+pub fn core_fn() -> String {
+    format!("core_fn from my_api::core!",)
+}
+
+pub fn core_fn2() -> String {
+    format!("core_fn2 from my_api::core!",)
+}
diff --git a/tests/ui/resolve/auxiliary/open-ns-my_api_utils.rs b/tests/ui/resolve/auxiliary/open-ns-my_api_utils.rs
new file mode 100644
index 000000000000..d2af20728bd5
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/open-ns-my_api_utils.rs
@@ -0,0 +1,13 @@
+pub mod util {
+    pub fn util_mod_helper() -> String {
+        format!("Helper from my_api::utils::util",)
+    }
+}
+
+pub fn utils_helper() -> String {
+    format!("Helper from my_api::utils!",)
+}
+
+pub fn get_u32() -> u32 {
+    1
+}
diff --git a/tests/ui/resolve/open-ns-1.rs b/tests/ui/resolve/open-ns-1.rs
new file mode 100644
index 000000000000..e77ddbe58122
--- /dev/null
+++ b/tests/ui/resolve/open-ns-1.rs
@@ -0,0 +1,19 @@
+//@ aux-crate:my_api=open-ns-my_api.rs
+//@ aux-crate:my_api::utils=open-ns-my_api_utils.rs
+//@ aux-crate:my_api::core=open-ns-my_api_core.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+use my_api::root_function;
+use my_api::utils::util;
+//~^ ERROR unresolved import `my_api::utils`
+
+fn main() {
+    let _ = root_function();
+    let _ = my_api::root_function();
+    let _ = my_api::utils::utils_helper();
+    //~^ ERROR cannot find `utils` in `my_api` [E0433]
+    let _ = util::util_mod_helper();
+    let _ = my_api::core::core_fn();
+    //~^ ERROR cannot find `core` in `my_api` [E0433]
+}
diff --git a/tests/ui/resolve/open-ns-1.stderr b/tests/ui/resolve/open-ns-1.stderr
new file mode 100644
index 000000000000..65b9c6a355ce
--- /dev/null
+++ b/tests/ui/resolve/open-ns-1.stderr
@@ -0,0 +1,22 @@
+error[E0432]: unresolved import `my_api::utils`
+  --> $DIR/open-ns-1.rs:8:13
+   |
+LL | use my_api::utils::util;
+   |             ^^^^^ could not find `utils` in `my_api`
+
+error[E0433]: cannot find `utils` in `my_api`
+  --> $DIR/open-ns-1.rs:14:21
+   |
+LL |     let _ = my_api::utils::utils_helper();
+   |                     ^^^^^ could not find `utils` in `my_api`
+
+error[E0433]: cannot find `core` in `my_api`
+  --> $DIR/open-ns-1.rs:17:21
+   |
+LL |     let _ = my_api::core::core_fn();
+   |                     ^^^^ could not find `core` in `my_api`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0432, E0433.
+For more information about an error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/open-ns-10.rs b/tests/ui/resolve/open-ns-10.rs
new file mode 100644
index 000000000000..b05a0ab270df
--- /dev/null
+++ b/tests/ui/resolve/open-ns-10.rs
@@ -0,0 +1,8 @@
+// Tests that namespaced crate names are limited to two segments
+
+//@ aux-crate: nscrate::three::segments=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+//~? ERROR crate name `nscrate::three::segments` passed to `--extern` can have at most two segments.
+
+fn main() {}
diff --git a/tests/ui/resolve/open-ns-10.stderr b/tests/ui/resolve/open-ns-10.stderr
new file mode 100644
index 000000000000..fdef748c6fa7
--- /dev/null
+++ b/tests/ui/resolve/open-ns-10.stderr
@@ -0,0 +1,2 @@
+error: crate name `nscrate::three::segments` passed to `--extern` can have at most two segments.
+
diff --git a/tests/ui/resolve/open-ns-11.rs b/tests/ui/resolve/open-ns-11.rs
new file mode 100644
index 000000000000..90e85a9ffc04
--- /dev/null
+++ b/tests/ui/resolve/open-ns-11.rs
@@ -0,0 +1,12 @@
+// Tests that std has higher precedence than an open module with the same name.
+
+//@ aux-crate: std::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+use std::utils::get_u32;
+//~^ ERROR unresolved import `std::utils`
+
+fn main() {
+    let _ = get_u32();
+}
diff --git a/tests/ui/resolve/open-ns-11.stderr b/tests/ui/resolve/open-ns-11.stderr
new file mode 100644
index 000000000000..cb073bc985a9
--- /dev/null
+++ b/tests/ui/resolve/open-ns-11.stderr
@@ -0,0 +1,9 @@
+error[E0432]: unresolved import `std::utils`
+  --> $DIR/open-ns-11.rs:7:10
+   |
+LL | use std::utils::get_u32;
+   |          ^^^^^ could not find `utils` in `std`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/open-ns-2.rs b/tests/ui/resolve/open-ns-2.rs
new file mode 100644
index 000000000000..6165a4102be0
--- /dev/null
+++ b/tests/ui/resolve/open-ns-2.rs
@@ -0,0 +1,18 @@
+//@ aux-crate: my_api=open-ns-my_api.rs
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ aux-crate: my_api::core=open-ns-my_api_core.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+use my_api::core::{core_fn, core_fn2};
+//~^ ERROR unresolved import `my_api::core` [E0432]
+use my_api::utils::*;
+//~^ ERROR unresolved import `my_api::utils` [E0432]
+use my_api::*;
+
+fn main() {
+    let _ = root_function();
+    let _ = utils_helper();
+    let _ = core_fn();
+    let _ = core_fn2();
+}
diff --git a/tests/ui/resolve/open-ns-2.stderr b/tests/ui/resolve/open-ns-2.stderr
new file mode 100644
index 000000000000..0e221234c517
--- /dev/null
+++ b/tests/ui/resolve/open-ns-2.stderr
@@ -0,0 +1,15 @@
+error[E0432]: unresolved import `my_api::core`
+  --> $DIR/open-ns-2.rs:7:13
+   |
+LL | use my_api::core::{core_fn, core_fn2};
+   |             ^^^^ could not find `core` in `my_api`
+
+error[E0432]: unresolved import `my_api::utils`
+  --> $DIR/open-ns-2.rs:9:13
+   |
+LL | use my_api::utils::*;
+   |             ^^^^^ could not find `utils` in `my_api`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/open-ns-3.rs b/tests/ui/resolve/open-ns-3.rs
new file mode 100644
index 000000000000..9c78999fe368
--- /dev/null
+++ b/tests/ui/resolve/open-ns-3.rs
@@ -0,0 +1,14 @@
+// This test should fail with `utils_helper` being unresolvable in `my_api::utils`.
+// If a crate contains a module that overlaps with a namespaced crate name, then
+// the namespaced crate will not be used in name resolution.
+
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ aux-crate: my_api=open-ns-mod-my_api.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+fn main() {
+    let _ = my_api::utils::root_helper();
+    let _ = my_api::utils::utils_helper();
+    //~^ ERROR cannot find function `utils_helper` in module `my_api::utils` [E0425]
+}
diff --git a/tests/ui/resolve/open-ns-3.stderr b/tests/ui/resolve/open-ns-3.stderr
new file mode 100644
index 000000000000..8ae261af0142
--- /dev/null
+++ b/tests/ui/resolve/open-ns-3.stderr
@@ -0,0 +1,19 @@
+error[E0425]: cannot find function `utils_helper` in module `my_api::utils`
+  --> $DIR/open-ns-3.rs:12:28
+   |
+LL |     let _ = my_api::utils::utils_helper();
+   |                            ^^^^^^^^^^^^ not found in `my_api::utils`
+   |
+help: consider importing this function
+   |
+LL + use my_api::utils::utils_helper;
+   |
+help: if you import `utils_helper`, refer to it directly
+   |
+LL -     let _ = my_api::utils::utils_helper();
+LL +     let _ = utils_helper();
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/open-ns-4.rs b/tests/ui/resolve/open-ns-4.rs
new file mode 100644
index 000000000000..4db3ad4c80a1
--- /dev/null
+++ b/tests/ui/resolve/open-ns-4.rs
@@ -0,0 +1,12 @@
+// This tests that namespaced crates are shadowed.
+
+//@ aux-crate: my_api=open-ns-my_api.rs
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+fn main() {
+    let _ = my_api::root_function();
+    let _ = my_api::utils::utils_helper();
+    //~^ ERROR cannot find `utils` in `my_api` [E0433]
+}
diff --git a/tests/ui/resolve/open-ns-4.stderr b/tests/ui/resolve/open-ns-4.stderr
new file mode 100644
index 000000000000..2e6872c57986
--- /dev/null
+++ b/tests/ui/resolve/open-ns-4.stderr
@@ -0,0 +1,9 @@
+error[E0433]: cannot find `utils` in `my_api`
+  --> $DIR/open-ns-4.rs:10:21
+   |
+LL |     let _ = my_api::utils::utils_helper();
+   |                     ^^^^^ could not find `utils` in `my_api`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/open-ns-5.rs b/tests/ui/resolve/open-ns-5.rs
new file mode 100644
index 000000000000..8776da3106cf
--- /dev/null
+++ b/tests/ui/resolve/open-ns-5.rs
@@ -0,0 +1,18 @@
+// Tests that namespaced crate names work inside macros.
+
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+//@ check-pass
+
+macro_rules! import_and_call {
+    ($import_path:path, $fn_name:ident) => {{
+        use $import_path;
+        $fn_name();
+    }};
+}
+
+fn main() {
+    import_and_call!(my_api::utils::utils_helper, utils_helper);
+    let _x = 4 + 5;
+}
diff --git a/tests/ui/resolve/open-ns-6.rs b/tests/ui/resolve/open-ns-6.rs
new file mode 100644
index 000000000000..856858aac43a
--- /dev/null
+++ b/tests/ui/resolve/open-ns-6.rs
@@ -0,0 +1,13 @@
+// Tests that open modules are resolvable.
+
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+//@ check-pass
+
+use my_api;
+use my_api::utils::utils_helper;
+
+fn main() {
+    let _ = utils_helper();
+}
diff --git a/tests/ui/resolve/open-ns-7.rs b/tests/ui/resolve/open-ns-7.rs
new file mode 100644
index 000000000000..cf16c594fa40
--- /dev/null
+++ b/tests/ui/resolve/open-ns-7.rs
@@ -0,0 +1,14 @@
+// Tests that namespaced crates cannot be resolved if shadowed.
+
+//@ aux-crate: my_api=open-ns-my_api.rs
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+use my_api::utils::utils_helper;
+//~^ ERROR unresolved import `my_api::utils` [E0432]
+
+fn main() {
+    let _ = my_api::utils::utils_helper();
+    //~^ ERROR cannot find `utils` in `my_api` [E0433]
+}
diff --git a/tests/ui/resolve/open-ns-7.stderr b/tests/ui/resolve/open-ns-7.stderr
new file mode 100644
index 000000000000..b00854753983
--- /dev/null
+++ b/tests/ui/resolve/open-ns-7.stderr
@@ -0,0 +1,16 @@
+error[E0432]: unresolved import `my_api::utils`
+  --> $DIR/open-ns-7.rs:8:13
+   |
+LL | use my_api::utils::utils_helper;
+   |             ^^^^^ could not find `utils` in `my_api`
+
+error[E0433]: cannot find `utils` in `my_api`
+  --> $DIR/open-ns-7.rs:12:21
+   |
+LL |     let _ = my_api::utils::utils_helper();
+   |                     ^^^^^ could not find `utils` in `my_api`
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0432, E0433.
+For more information about an error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/open-ns-8.rs b/tests/ui/resolve/open-ns-8.rs
new file mode 100644
index 000000000000..46aafb66e63a
--- /dev/null
+++ b/tests/ui/resolve/open-ns-8.rs
@@ -0,0 +1,23 @@
+// Tests that a macro-generated item has higher precendence than a namespaced crate
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+//@ check-pass
+
+macro_rules! define {
+    () => {
+        pub mod my_api {
+            pub mod utils {
+                pub fn get_u32() -> u32 {
+                    2
+                }
+            }
+        }
+    };
+}
+
+fn main() {
+    define!();
+    let res = my_api::utils::get_u32();
+    assert_eq!(res, 2);
+}
diff --git a/tests/ui/resolve/open-ns-9.rs b/tests/ui/resolve/open-ns-9.rs
new file mode 100644
index 000000000000..7ded0b383d8d
--- /dev/null
+++ b/tests/ui/resolve/open-ns-9.rs
@@ -0,0 +1,25 @@
+//@ aux-crate: my_api::utils=open-ns-my_api_utils.rs
+//@ compile-flags: -Z namespaced-crates
+//@ edition: 2024
+
+use my_api::utils::get_u32;
+//~^ ERROR `my_api` is ambiguous [E0659]
+
+macro_rules! define {
+    () => {
+        pub mod my_api {
+            pub mod utils {
+                pub fn get_u32() -> u32 {
+                    2
+                }
+            }
+        }
+    };
+}
+
+define!();
+
+fn main() {
+    let val = get_u32();
+    assert_eq!(val, 2);
+}
diff --git a/tests/ui/resolve/open-ns-9.stderr b/tests/ui/resolve/open-ns-9.stderr
new file mode 100644
index 000000000000..675f487823e5
--- /dev/null
+++ b/tests/ui/resolve/open-ns-9.stderr
@@ -0,0 +1,27 @@
+error[E0659]: `my_api` is ambiguous
+  --> $DIR/open-ns-9.rs:5:5
+   |
+LL | use my_api::utils::get_u32;
+   |     ^^^^^^ ambiguous name
+   |
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
+   = note: `my_api` could refer to a namespaced crate passed with `--extern`
+note: `my_api` could also refer to the module defined here
+  --> $DIR/open-ns-9.rs:10:9
+   |
+LL | /         pub mod my_api {
+LL | |             pub mod utils {
+LL | |                 pub fn get_u32() -> u32 {
+LL | |                     2
+...  |
+LL | |         }
+   | |_________^
+...
+LL |   define!();
+   |   --------- in this macro invocation
+   = help: use `crate::my_api` to refer to this module unambiguously
+   = note: this error originates in the macro `define` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0659`.

From e191c9429eb24662261226eb9e2f7f1ad89beda3 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Sat, 21 Mar 2026 13:40:35 +0100
Subject: [PATCH 0742/1059] Bump nightly version -> 2026-03-21

---
 clippy_utils/README.md | 2 +-
 rust-toolchain.toml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index d7e40130380d..b5e2e0fbf6c5 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2026-03-05
+nightly-2026-03-21
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index c9bb94cededb..1f8bcdea8251 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2026-03-05"
+channel = "nightly-2026-03-21"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"

From 9a4b38c916ca758e05a020a550048d4ef47f6a74 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Sat, 21 Mar 2026 14:13:00 +0100
Subject: [PATCH 0743/1059] Add new alias for Guillaume Gomez email address

---
 .mailmap | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.mailmap b/.mailmap
index c0333b49f53b..17232083679c 100644
--- a/.mailmap
+++ b/.mailmap
@@ -262,6 +262,7 @@ Guillaume Gomez <guillaume1.gomez@gmail.com>
 Guillaume Gomez <guillaume1.gomez@gmail.com> ggomez <ggomez@ggo.ifr.lan>
 Guillaume Gomez <guillaume1.gomez@gmail.com> Guillaume Gomez <ggomez@ggo.ifr.lan>
 Guillaume Gomez <guillaume1.gomez@gmail.com> Guillaume Gomez <guillaume.gomez@huawei.com>
+Guillaume Gomez <guillaume1.gomez@gmail.com> Guillaume Gomez <contact@guillaume-gomez.fr>
 gnzlbg <gonzalobg88@gmail.com> <gnzlbg@users.noreply.github.com>
 hamidreza kalbasi <hamidrezakalbasi@protonmail.com>
 Hanna Kruppe <hanna.kruppe@gmail.com> <robin.kruppe@gmail.com>

From aed54f219eccbd4f3cb3ecd89acdc0d9eeb2bceb Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 21 Mar 2026 16:00:51 +0100
Subject: [PATCH 0744/1059] tests/ui/async-await/gat-is-send-across-await.rs:
 New regression test

The test began passing in `nightly-2025-10-16`. Probably by c50aebba787
because it fixed two "does not live long enough" errors. The test fails
to compile with `nightly-2025-10-15` with such an error:

    $ rustc +nightly-2025-10-15 --edition 2018 tests/ui/async-await/gat-is-send-across-await.rs
    error: `impl G` does not live long enough
      --> tests/ui/async-await/gat-is-send-across-await.rs:16:24
       |
    16 |       let _: &dyn Send = &async move {
       |  ________________________^
    17 | |         let _gat = g.as_gat();
    18 | |         async{}.await
    19 | |     };
       | |_____^
---
 .../async-await/gat-is-send-across-await.rs   | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 tests/ui/async-await/gat-is-send-across-await.rs

diff --git a/tests/ui/async-await/gat-is-send-across-await.rs b/tests/ui/async-await/gat-is-send-across-await.rs
new file mode 100644
index 000000000000..43b777449edd
--- /dev/null
+++ b/tests/ui/async-await/gat-is-send-across-await.rs
@@ -0,0 +1,23 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/111852>.
+
+//@ edition:2018
+//@ check-pass
+
+#![allow(unused)]
+
+trait G: Send {
+    type Gat<'l>: Send
+    where
+        Self: 'l;
+
+    fn as_gat(&self) -> Self::Gat<'_>;
+}
+
+fn a(g: impl G) {
+    let _: &dyn Send = &async move {
+        let _gat = g.as_gat();
+        async{}.await
+    };
+}
+
+fn main() { }

From a22e9e0e026bd1d2da24041b40a4227a0b7d6616 Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Wed, 18 Mar 2026 21:56:01 -0400
Subject: [PATCH 0745/1059] docs: autogenerate compiler flag stubs by parsing
 options! macro

---
 src/tools/unstable-book-gen/src/main.rs | 611 +++++++++++++++++++++++-
 1 file changed, 609 insertions(+), 2 deletions(-)

diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index 16550f83003d..4238d7afa341 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -6,10 +6,12 @@
 use std::path::Path;
 
 use tidy::diagnostics::RunningCheck;
-use tidy::features::{Features, collect_env_vars, collect_lang_features, collect_lib_features};
+use tidy::features::{
+    Feature, Features, Status, collect_env_vars, collect_lang_features, collect_lib_features,
+};
 use tidy::t;
 use tidy::unstable_book::{
-    ENV_VARS_DIR, LANG_FEATURES_DIR, LIB_FEATURES_DIR, PATH_STR,
+    COMPILER_FLAGS_DIR, ENV_VARS_DIR, LANG_FEATURES_DIR, LIB_FEATURES_DIR, PATH_STR,
     collect_unstable_book_section_file_names, collect_unstable_feature_names,
 };
 
@@ -113,6 +115,510 @@ fn copy_recursive(from: &Path, to: &Path) {
     }
 }
 
+fn collect_compiler_flags(compiler_path: &Path) -> Features {
+    let options_path = compiler_path.join("rustc_session/src/options.rs");
+    let options_rs = t!(fs::read_to_string(&options_path), options_path);
+    parse_compiler_flags(&options_rs, &options_path)
+}
+
+const DESCRIPTION_FIELD: usize = 3;
+const REQUIRED_FIELDS: usize = 4;
+const OPTIONAL_FIELDS: usize = 5;
+
+struct SourceBlock<'a> {
+    content: &'a str,
+    offset: usize,
+}
+
+struct ParsedOptionEntry<'a> {
+    name: &'a str,
+    name_start: usize,
+    description: Option<String>,
+    next_idx: usize,
+}
+
+fn parse_compiler_flags(options_rs: &str, options_path: &Path) -> Features {
+    let options_block = find_options_block(options_rs, "UnstableOptions");
+    let alphabetical_section = find_tidy_alphabetical_section(options_block);
+    let section_line_offset = line_number(options_rs, alphabetical_section.offset) - 1;
+
+    let mut features = Features::new();
+    let mut idx = 0;
+
+    while idx < alphabetical_section.content.len() {
+        skip_ws_comments_and_attrs(alphabetical_section.content, &mut idx);
+        if idx >= alphabetical_section.content.len() {
+            break;
+        }
+
+        let entry = parse_one_entry(alphabetical_section.content, idx);
+        idx = entry.next_idx;
+
+        if entry.name == "help" {
+            continue;
+        }
+
+        features.insert(
+            entry.name.to_owned(),
+            Feature {
+                level: Status::Unstable,
+                since: None,
+                has_gate_test: false,
+                tracking_issue: None,
+                file: options_path.to_path_buf(),
+                line: section_line_offset
+                    + line_number(alphabetical_section.content, entry.name_start),
+                description: entry.description,
+            },
+        );
+    }
+
+    features
+}
+
+fn parse_one_entry(source: &str, start_idx: usize) -> ParsedOptionEntry<'_> {
+    let name_start = start_idx;
+    let name_end =
+        parse_ident_end(source, name_start).expect("expected an option name in UnstableOptions");
+    let name = &source[name_start..name_end];
+    let mut idx = name_end;
+
+    skip_ws_comments(source, &mut idx);
+    expect_byte(source, idx, b':', &format!("expected `:` after option name `{name}`"));
+    idx += 1;
+
+    idx =
+        find_char_outside_nested(source, idx, b'=').expect("expected `=` in UnstableOptions entry");
+    idx += 1;
+
+    skip_ws_comments(source, &mut idx);
+    expect_byte(source, idx, b'(', &format!("expected tuple payload for option `{name}`"));
+
+    let tuple_start = idx;
+    let tuple_end = find_matching_delimiter(source, tuple_start, b'(', b')')
+        .expect("UnstableOptions tuple should be balanced");
+    let next_idx = skip_past_entry_delimiter(source, tuple_end + 1, name);
+
+    let description = if name == "help" {
+        None
+    } else {
+        let fields = split_top_level_fields(&source[tuple_start + 1..tuple_end]);
+        validate_option_fields(&fields, name);
+        // The `options!` macro layout is `(init, parse, [dep_tracking...], desc, ...)`.
+        Some(parse_string_literal(
+            fields.get(DESCRIPTION_FIELD).expect("option description should be present"),
+        ))
+    };
+
+    ParsedOptionEntry { name, name_start, description, next_idx }
+}
+
+fn find_options_block<'a>(source: &'a str, struct_name: &str) -> SourceBlock<'a> {
+    let mut search_from = 0;
+
+    while let Some(relative_start) = source[search_from..].find("options!") {
+        let macro_start = search_from + relative_start;
+        let open_brace = source[macro_start..]
+            .find('{')
+            .map(|relative| macro_start + relative)
+            .expect("options! invocation should contain `{`");
+        let close_brace = find_matching_delimiter(source, open_brace, b'{', b'}')
+            .expect("options! invocation should have a matching `}`");
+        let block = &source[open_brace + 1..close_brace];
+
+        if block.trim_start().starts_with(struct_name) {
+            return SourceBlock { content: block, offset: open_brace + 1 };
+        }
+
+        search_from = close_brace + 1;
+    }
+
+    panic!("could not find `{struct_name}` options! block");
+}
+
+fn find_tidy_alphabetical_section(block: SourceBlock<'_>) -> SourceBlock<'_> {
+    let start_marker = "// tidy-alphabetical-start";
+    let end_marker = "// tidy-alphabetical-end";
+
+    let section_start = block
+        .content
+        .find(start_marker)
+        .map(|start| start + start_marker.len())
+        .expect("options! block should contain `// tidy-alphabetical-start`");
+    let section_end = block.content[section_start..]
+        .find(end_marker)
+        .map(|end| section_start + end)
+        .expect("options! block should contain `// tidy-alphabetical-end`");
+
+    SourceBlock {
+        content: &block.content[section_start..section_end],
+        offset: block.offset + section_start,
+    }
+}
+
+fn line_number(source: &str, offset: usize) -> usize {
+    source[..offset].bytes().filter(|&byte| byte == b'\n').count() + 1
+}
+
+fn expect_byte(source: &str, idx: usize, expected: u8, context: &str) {
+    assert_eq!(source.as_bytes().get(idx).copied(), Some(expected), "{context}");
+}
+
+fn skip_ws_comments_and_attrs(source: &str, idx: &mut usize) {
+    loop {
+        skip_ws_comments(source, idx);
+
+        if source[*idx..].starts_with("#[") {
+            let attr_start = *idx + 1;
+            let attr_end = find_matching_delimiter(source, attr_start, b'[', b']')
+                .expect("attribute should have matching `]`");
+            *idx = attr_end + 1;
+            continue;
+        }
+
+        break;
+    }
+}
+
+fn skip_ws_comments(source: &str, idx: &mut usize) {
+    loop {
+        while let Some(byte) = source.as_bytes().get(*idx) {
+            if byte.is_ascii_whitespace() {
+                *idx += 1;
+            } else {
+                break;
+            }
+        }
+
+        if source[*idx..].starts_with("//") {
+            *idx = source[*idx..].find('\n').map_or(source.len(), |end| *idx + end + 1);
+            continue;
+        }
+
+        if source[*idx..].starts_with("/*") {
+            *idx = skip_block_comment(source, *idx);
+            continue;
+        }
+
+        break;
+    }
+}
+
+fn skip_block_comment(source: &str, mut idx: usize) -> usize {
+    let mut depth = 1;
+    idx += 2;
+
+    while idx < source.len() {
+        match source.as_bytes().get(idx..idx + 2) {
+            Some(b"/*") => {
+                depth += 1;
+                idx += 2;
+            }
+            Some(b"*/") => {
+                depth -= 1;
+                idx += 2;
+                if depth == 0 {
+                    return idx;
+                }
+            }
+            _ => idx += 1,
+        }
+    }
+
+    panic!("unterminated block comment");
+}
+
+fn parse_ident_end(source: &str, start: usize) -> Option<usize> {
+    let bytes = source.as_bytes();
+    let first = *bytes.get(start)?;
+    if !(first == b'_' || first.is_ascii_alphabetic()) {
+        return None;
+    }
+
+    let mut idx = start + 1;
+    while let Some(byte) = bytes.get(idx) {
+        if *byte == b'_' || byte.is_ascii_alphanumeric() {
+            idx += 1;
+        } else {
+            break;
+        }
+    }
+
+    Some(idx)
+}
+
+fn find_char_outside_nested(source: &str, start: usize, needle: u8) -> Option<usize> {
+    let mut idx = start;
+    let mut paren_depth = 0;
+    let mut bracket_depth = 0;
+    let mut brace_depth = 0;
+
+    while idx < source.len() {
+        match source.as_bytes()[idx] {
+            b'/' if source[idx..].starts_with("//") => {
+                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
+            }
+            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
+            b'"' => idx = skip_string_literal(source, idx),
+            b'(' => {
+                paren_depth += 1;
+                idx += 1;
+            }
+            b')' => {
+                paren_depth -= 1;
+                idx += 1;
+            }
+            b'[' => {
+                bracket_depth += 1;
+                idx += 1;
+            }
+            b']' => {
+                bracket_depth -= 1;
+                idx += 1;
+            }
+            b'{' => {
+                brace_depth += 1;
+                idx += 1;
+            }
+            b'}' => {
+                brace_depth -= 1;
+                idx += 1;
+            }
+            byte if byte == needle
+                && paren_depth == 0
+                && bracket_depth == 0
+                && brace_depth == 0 =>
+            {
+                return Some(idx);
+            }
+            _ => idx += 1,
+        }
+    }
+
+    None
+}
+
+fn find_matching_delimiter(source: &str, start: usize, open: u8, close: u8) -> Option<usize> {
+    let mut idx = start;
+    let mut depth = 0;
+
+    while idx < source.len() {
+        match source.as_bytes()[idx] {
+            b'/' if source[idx..].starts_with("//") => {
+                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
+            }
+            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
+            b'"' => idx = skip_string_literal(source, idx),
+            byte if byte == open => {
+                depth += 1;
+                idx += 1;
+            }
+            byte if byte == close => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(idx);
+                }
+                idx += 1;
+            }
+            _ => idx += 1,
+        }
+    }
+
+    None
+}
+
+fn split_top_level_fields(source: &str) -> Vec<&str> {
+    let mut fields = Vec::new();
+    let mut field_start = 0;
+    let mut idx = 0;
+    let mut paren_depth = 0;
+    let mut bracket_depth = 0;
+    let mut brace_depth = 0;
+
+    while idx < source.len() {
+        match source.as_bytes()[idx] {
+            b'/' if source[idx..].starts_with("//") => {
+                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
+            }
+            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
+            b'"' => idx = skip_string_literal(source, idx),
+            b'(' => {
+                paren_depth += 1;
+                idx += 1;
+            }
+            b')' => {
+                paren_depth -= 1;
+                idx += 1;
+            }
+            b'[' => {
+                bracket_depth += 1;
+                idx += 1;
+            }
+            b']' => {
+                bracket_depth -= 1;
+                idx += 1;
+            }
+            b'{' => {
+                brace_depth += 1;
+                idx += 1;
+            }
+            b'}' => {
+                brace_depth -= 1;
+                idx += 1;
+            }
+            b',' if paren_depth == 0 && bracket_depth == 0 && brace_depth == 0 => {
+                fields.push(source[field_start..idx].trim());
+                idx += 1;
+                field_start = idx;
+            }
+            _ => idx += 1,
+        }
+    }
+
+    fields.push(source[field_start..].trim());
+    fields
+}
+
+fn validate_option_fields(fields: &[&str], name: &str) {
+    assert!(
+        matches!(fields.len(), REQUIRED_FIELDS | OPTIONAL_FIELDS),
+        "unexpected field count for option `{name}`: expected 4 or 5 fields, found {}",
+        fields.len()
+    );
+    assert!(
+        fields[2].starts_with('[') && fields[2].ends_with(']'),
+        "expected dep-tracking field in option `{name}`, found `{}`",
+        fields[2]
+    );
+    assert!(
+        looks_like_string_literal(fields[DESCRIPTION_FIELD]),
+        "expected description string literal in option `{name}`, found `{}`",
+        fields[DESCRIPTION_FIELD]
+    );
+
+    if let Some(extra_field) = fields.get(REQUIRED_FIELDS) {
+        assert!(
+            extra_field.trim_start().starts_with("is_deprecated_and_do_nothing:"),
+            "unexpected trailing field in option `{name}`: `{extra_field}`",
+        );
+    }
+}
+
+fn looks_like_string_literal(field: &str) -> bool {
+    let field = field.trim();
+    (field.starts_with('"') && field.ends_with('"')) || parse_raw_string_literal(field).is_some()
+}
+
+fn skip_past_entry_delimiter(source: &str, start: usize, name: &str) -> usize {
+    let mut idx = start;
+    skip_ws_comments(source, &mut idx);
+
+    match source.as_bytes().get(idx).copied() {
+        Some(b',') => idx + 1,
+        None => idx,
+        Some(byte) => {
+            panic!("expected `,` after option entry `{name}`, found {:?}", char::from(byte))
+        }
+    }
+}
+
+fn skip_string_literal(source: &str, mut idx: usize) -> usize {
+    idx += 1;
+
+    while idx < source.len() {
+        match source.as_bytes()[idx] {
+            b'\\' => {
+                idx += 1;
+                if idx < source.len() {
+                    idx += 1;
+                }
+            }
+            b'"' => return idx + 1,
+            _ => idx += 1,
+        }
+    }
+
+    panic!("unterminated string literal");
+}
+
+fn parse_string_literal(literal: &str) -> String {
+    let literal = literal.trim();
+
+    if let Some(raw_literal) = parse_raw_string_literal(literal) {
+        return raw_literal;
+    }
+
+    let inner = literal
+        .strip_prefix('"')
+        .and_then(|value| value.strip_suffix('"'))
+        .expect("expected a string literal");
+    let mut output = String::new();
+    let mut chars = inner.chars().peekable();
+
+    while let Some(ch) = chars.next() {
+        if ch != '\\' {
+            output.push(ch);
+            continue;
+        }
+
+        let escaped = chars.next().expect("unterminated string escape");
+        match escaped {
+            '\n' => while chars.next_if(|ch| ch.is_whitespace()).is_some() {},
+            '\r' => {
+                let _ = chars.next_if_eq(&'\n');
+                while chars.next_if(|ch| ch.is_whitespace()).is_some() {}
+            }
+            '"' => output.push('"'),
+            '\'' => output.push('\''),
+            '\\' => output.push('\\'),
+            'n' => output.push('\n'),
+            'r' => output.push('\r'),
+            't' => output.push('\t'),
+            '0' => output.push('\0'),
+            'x' => {
+                let hi = chars.next().expect("missing first hex digit in escape");
+                let lo = chars.next().expect("missing second hex digit in escape");
+                let byte = u8::from_str_radix(&format!("{hi}{lo}"), 16)
+                    .expect("invalid hex escape in string literal");
+                output.push(char::from(byte));
+            }
+            'u' => {
+                assert_eq!(chars.next(), Some('{'), "expected `{{` after `\\u`");
+                let mut digits = String::new();
+                for ch in chars.by_ref() {
+                    if ch == '}' {
+                        break;
+                    }
+                    digits.push(ch);
+                }
+                let scalar =
+                    u32::from_str_radix(&digits, 16).expect("invalid unicode escape in string");
+                output.push(char::from_u32(scalar).expect("unicode escape should be valid"));
+            }
+            _ => panic!("unsupported escape in string literal"),
+        }
+    }
+
+    output
+}
+
+fn parse_raw_string_literal(literal: &str) -> Option<String> {
+    let rest = literal.strip_prefix('r')?;
+    let hashes = rest.bytes().take_while(|&byte| byte == b'#').count();
+    let quote_idx = 1 + hashes;
+
+    if literal.as_bytes().get(quote_idx) != Some(&b'"') {
+        return None;
+    }
+
+    let suffix = format!("\"{}", "#".repeat(hashes));
+    let content = literal[quote_idx + 1..]
+        .strip_suffix(&suffix)
+        .expect("raw string literal should have a matching terminator");
+
+    Some(content.to_owned())
+}
+
 fn main() {
     let library_path_str = env::args_os().nth(1).expect("library/ path required");
     let compiler_path_str = env::args_os().nth(2).expect("compiler/ path required");
@@ -129,6 +635,7 @@ fn main() {
         .filter(|&(ref name, _)| !lang_features.contains_key(name))
         .collect();
     let env_vars = collect_env_vars(compiler_path);
+    let compiler_flags = collect_compiler_flags(compiler_path);
 
     let doc_src_path = src_path.join(PATH_STR);
 
@@ -144,9 +651,109 @@ fn main() {
         &dest_path.join(LIB_FEATURES_DIR),
         &lib_features,
     );
+    generate_feature_files(
+        &doc_src_path.join(COMPILER_FLAGS_DIR),
+        &dest_path.join(COMPILER_FLAGS_DIR),
+        &compiler_flags,
+    );
     generate_env_files(&doc_src_path.join(ENV_VARS_DIR), &dest_path.join(ENV_VARS_DIR), &env_vars);
 
     copy_recursive(&doc_src_path, &dest_path);
 
     generate_summary(&dest_path, &lang_features, &lib_features);
 }
+
+#[cfg(test)]
+mod tests {
+    use std::path::{Path, PathBuf};
+
+    use super::{parse_compiler_flags, parse_one_entry, skip_ws_comments_and_attrs};
+
+    #[test]
+    fn parses_unstable_options_entries() {
+        let options_rs = r#"
+options! {
+    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
+
+    // tidy-alphabetical-start
+    #[rustc_lint_opt_deny_field_access("test attr")]
+    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
+        "only allow the listed language features to be enabled in code (comma separated)"),
+    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "dump MIR state to file.
+        `val` is used to select which passes and functions to dump."),
+    join_lines: bool = (false, parse_bool, [TRACKED],
+        "join \
+         continued lines"),
+    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
+    // tidy-alphabetical-end
+}
+"#;
+
+        let features = parse_compiler_flags(options_rs, Path::new("options.rs"));
+
+        assert!(features.contains_key("allow_features"));
+        assert!(features.contains_key("dump_mir"));
+        assert!(features.contains_key("join_lines"));
+        assert!(!features.contains_key("help"));
+
+        assert_eq!(
+            features["dump_mir"].description.as_deref(),
+            Some(
+                "dump MIR state to file.\n        `val` is used to select which passes and functions to dump."
+            ),
+        );
+        assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"),);
+        assert_eq!(features["allow_features"].file, PathBuf::from("options.rs"));
+        assert_eq!(features["allow_features"].line, 7);
+    }
+
+    #[test]
+    fn parse_one_entry_skips_help_description_and_advances() {
+        let section = r#"
+help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
+join_lines: bool = (false, parse_bool, [TRACKED], "join \
+    continued lines"),
+"#;
+        let section = section.trim_start();
+
+        let help_entry = parse_one_entry(section, 0);
+        assert_eq!(help_entry.name, "help");
+        assert!(help_entry.description.is_none());
+
+        let mut next_idx = help_entry.next_idx;
+        skip_ws_comments_and_attrs(section, &mut next_idx);
+        let next_entry = parse_one_entry(section, next_idx);
+
+        assert_eq!(next_entry.name, "join_lines");
+        assert_eq!(next_entry.description.as_deref(), Some("join continued lines"),);
+    }
+
+    #[test]
+    fn parse_one_entry_accepts_optional_trailing_metadata() {
+        let entry = r#"
+deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], "deprecated flag",
+    is_deprecated_and_do_nothing: true),
+"#;
+        let entry = entry.trim_start();
+
+        let parsed = parse_one_entry(entry, 0);
+        assert_eq!(parsed.name, "deprecated_flag");
+        assert_eq!(parsed.description.as_deref(), Some("deprecated flag"));
+    }
+
+    #[test]
+    fn parses_real_unstable_options_file() {
+        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options.rs");
+        let options_rs = std::fs::read_to_string(&options_path).unwrap();
+        let features = parse_compiler_flags(&options_rs, &options_path);
+
+        assert!(features.contains_key("allow_features"));
+        assert!(features.contains_key("dump_mir"));
+        assert!(features.contains_key("unstable_options"));
+        assert!(!features.contains_key("help"));
+        assert!(features["dump_mir"].line > 0);
+        assert!(features["dump_mir"].description.as_deref().unwrap().starts_with("dump MIR state"));
+    }
+}

From 83a21a5e7129b62e4c1944affb906c0751a6cfaf Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Wed, 18 Mar 2026 21:59:48 -0400
Subject: [PATCH 0746/1059] fix: move tests to separate file and avoid tidy
 markers in strings

---
 src/tools/unstable-book-gen/src/main.rs  | 94 +-----------------------
 src/tools/unstable-book-gen/src/tests.rs | 90 +++++++++++++++++++++++
 2 files changed, 91 insertions(+), 93 deletions(-)
 create mode 100644 src/tools/unstable-book-gen/src/tests.rs

diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index 4238d7afa341..12b35a11c0d6 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -664,96 +664,4 @@ fn main() {
 }
 
 #[cfg(test)]
-mod tests {
-    use std::path::{Path, PathBuf};
-
-    use super::{parse_compiler_flags, parse_one_entry, skip_ws_comments_and_attrs};
-
-    #[test]
-    fn parses_unstable_options_entries() {
-        let options_rs = r#"
-options! {
-    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
-
-    // tidy-alphabetical-start
-    #[rustc_lint_opt_deny_field_access("test attr")]
-    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
-        "only allow the listed language features to be enabled in code (comma separated)"),
-    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "dump MIR state to file.
-        `val` is used to select which passes and functions to dump."),
-    join_lines: bool = (false, parse_bool, [TRACKED],
-        "join \
-         continued lines"),
-    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
-    // tidy-alphabetical-end
-}
-"#;
-
-        let features = parse_compiler_flags(options_rs, Path::new("options.rs"));
-
-        assert!(features.contains_key("allow_features"));
-        assert!(features.contains_key("dump_mir"));
-        assert!(features.contains_key("join_lines"));
-        assert!(!features.contains_key("help"));
-
-        assert_eq!(
-            features["dump_mir"].description.as_deref(),
-            Some(
-                "dump MIR state to file.\n        `val` is used to select which passes and functions to dump."
-            ),
-        );
-        assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"),);
-        assert_eq!(features["allow_features"].file, PathBuf::from("options.rs"));
-        assert_eq!(features["allow_features"].line, 7);
-    }
-
-    #[test]
-    fn parse_one_entry_skips_help_description_and_advances() {
-        let section = r#"
-help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
-join_lines: bool = (false, parse_bool, [TRACKED], "join \
-    continued lines"),
-"#;
-        let section = section.trim_start();
-
-        let help_entry = parse_one_entry(section, 0);
-        assert_eq!(help_entry.name, "help");
-        assert!(help_entry.description.is_none());
-
-        let mut next_idx = help_entry.next_idx;
-        skip_ws_comments_and_attrs(section, &mut next_idx);
-        let next_entry = parse_one_entry(section, next_idx);
-
-        assert_eq!(next_entry.name, "join_lines");
-        assert_eq!(next_entry.description.as_deref(), Some("join continued lines"),);
-    }
-
-    #[test]
-    fn parse_one_entry_accepts_optional_trailing_metadata() {
-        let entry = r#"
-deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], "deprecated flag",
-    is_deprecated_and_do_nothing: true),
-"#;
-        let entry = entry.trim_start();
-
-        let parsed = parse_one_entry(entry, 0);
-        assert_eq!(parsed.name, "deprecated_flag");
-        assert_eq!(parsed.description.as_deref(), Some("deprecated flag"));
-    }
-
-    #[test]
-    fn parses_real_unstable_options_file() {
-        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-        let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options.rs");
-        let options_rs = std::fs::read_to_string(&options_path).unwrap();
-        let features = parse_compiler_flags(&options_rs, &options_path);
-
-        assert!(features.contains_key("allow_features"));
-        assert!(features.contains_key("dump_mir"));
-        assert!(features.contains_key("unstable_options"));
-        assert!(!features.contains_key("help"));
-        assert!(features["dump_mir"].line > 0);
-        assert!(features["dump_mir"].description.as_deref().unwrap().starts_with("dump MIR state"));
-    }
-}
+mod tests;
diff --git a/src/tools/unstable-book-gen/src/tests.rs b/src/tools/unstable-book-gen/src/tests.rs
new file mode 100644
index 000000000000..98008a45be62
--- /dev/null
+++ b/src/tools/unstable-book-gen/src/tests.rs
@@ -0,0 +1,90 @@
+use std::path::{Path, PathBuf};
+
+use super::{parse_compiler_flags, parse_one_entry, skip_ws_comments_and_attrs};
+
+#[test]
+fn parses_unstable_options_entries() {
+    let tidy_start = "// tidy-alphabetical-start";
+    let tidy_end = "// tidy-alphabetical-end";
+    let options_rs = format!(
+        "\n\
+        options! {{\n\
+        \x20   UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, \"Z\", \"unstable\",\n\
+        \n\
+        \x20   {tidy_start}\n\
+        \x20   #[rustc_lint_opt_deny_field_access(\"test attr\")]\n\
+        \x20   allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],\n\
+        \x20       \"only allow the listed language features to be enabled in code (comma separated)\"),\n\
+        \x20   dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],\n\
+        \x20       \"dump MIR state to file.\n\
+        \x20       `val` is used to select which passes and functions to dump.\"),\n\
+        \x20   join_lines: bool = (false, parse_bool, [TRACKED],\n\
+        \x20       \"join \\\n\
+        \x20        continued lines\"),\n\
+        \x20   help: bool = (false, parse_no_value, [UNTRACKED], \"Print unstable compiler options\"),\n\
+        \x20   {tidy_end}\n\
+        }}\n"
+    );
+
+    let features = parse_compiler_flags(&options_rs, Path::new("options.rs"));
+
+    assert!(features.contains_key("allow_features"));
+    assert!(features.contains_key("dump_mir"));
+    assert!(features.contains_key("join_lines"));
+    assert!(!features.contains_key("help"));
+
+    assert_eq!(
+        features["dump_mir"].description.as_deref(),
+        Some(
+            "dump MIR state to file.\n        `val` is used to select which passes and functions to dump."
+        ),
+    );
+    assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"),);
+    assert_eq!(features["allow_features"].file, PathBuf::from("options.rs"));
+    assert_eq!(features["allow_features"].line, 7);
+}
+
+#[test]
+fn parse_one_entry_skips_help_description_and_advances() {
+    let section = "\
+help: bool = (false, parse_no_value, [UNTRACKED], \"Print unstable compiler options\"),\n\
+join_lines: bool = (false, parse_bool, [TRACKED], \"join \\\n\
+    continued lines\"),\n";
+
+    let help_entry = parse_one_entry(section, 0);
+    assert_eq!(help_entry.name, "help");
+    assert!(help_entry.description.is_none());
+
+    let mut next_idx = help_entry.next_idx;
+    skip_ws_comments_and_attrs(section, &mut next_idx);
+    let next_entry = parse_one_entry(section, next_idx);
+
+    assert_eq!(next_entry.name, "join_lines");
+    assert_eq!(next_entry.description.as_deref(), Some("join continued lines"),);
+}
+
+#[test]
+fn parse_one_entry_accepts_optional_trailing_metadata() {
+    let entry = "\
+deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], \"deprecated flag\",\n\
+    is_deprecated_and_do_nothing: true),\n";
+
+    let parsed = parse_one_entry(entry, 0);
+    assert_eq!(parsed.name, "deprecated_flag");
+    assert_eq!(parsed.description.as_deref(), Some("deprecated flag"));
+}
+
+#[test]
+fn parses_real_unstable_options_file() {
+    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options.rs");
+    let options_rs = std::fs::read_to_string(&options_path).unwrap();
+    let features = parse_compiler_flags(&options_rs, &options_path);
+
+    assert!(features.contains_key("allow_features"));
+    assert!(features.contains_key("dump_mir"));
+    assert!(features.contains_key("unstable_options"));
+    assert!(!features.contains_key("help"));
+    assert!(features["dump_mir"].line > 0);
+    assert!(features["dump_mir"].description.as_deref().unwrap().starts_with("dump MIR state"));
+}

From b4f2c8a08e8752f016978b96d09d473bc7bc1a7b Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Sat, 21 Mar 2026 11:31:41 -0400
Subject: [PATCH 0747/1059] docs: parse unstable options with syn

---
 Cargo.lock                                    |   2 +
 compiler/rustc_session/src/options.rs         | 586 +-----------------
 .../rustc_session/src/options/unstable.rs     | 585 +++++++++++++++++
 src/tools/unstable-book-gen/Cargo.toml        |   2 +
 src/tools/unstable-book-gen/src/main.rs       | 579 ++++-------------
 src/tools/unstable-book-gen/src/tests.rs      | 100 ++-
 6 files changed, 763 insertions(+), 1091 deletions(-)
 create mode 100644 compiler/rustc_session/src/options/unstable.rs

diff --git a/Cargo.lock b/Cargo.lock
index 539f66ffb3bb..1be93aac6e08 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6088,6 +6088,8 @@ name = "unstable-book-gen"
 version = "0.1.0"
 dependencies = [
  "num-traits",
+ "proc-macro2",
+ "syn 2.0.110",
  "tidy",
 ]
 
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index fb1b3c867948..836f7d1cb456 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2213,588 +2213,4 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     // - src/doc/rustc/src/codegen-options/index.md
 }
 
-options! {
-    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
-
-    // If you add a new option, please update:
-    // - compiler/rustc_interface/src/tests.rs
-    // - src/doc/unstable-book/src/compiler-flags
-
-    // tidy-alphabetical-start
-    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
-        "only allow the listed language features to be enabled in code (comma separated)"),
-    always_encode_mir: bool = (false, parse_bool, [TRACKED],
-        "encode MIR of all functions into the crate metadata (default: no)"),
-    annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED],
-        "emit debug info for compiler-generated move and copy operations \
-        to make them visible in profilers. Can be a boolean or a size limit in bytes (default: disabled)"),
-    assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "assert that the incremental cache is in given state: \
-         either `loaded` or `not-loaded`."),
-    assume_incomplete_release: bool = (false, parse_bool, [TRACKED],
-        "make cfg(version) treat the current version as incomplete (default: no)"),
-    autodiff: Vec<crate::config::AutoDiff> = (Vec::new(), parse_autodiff, [TRACKED],
-        "a list of autodiff flags to enable
-        Mandatory setting:
-        `=Enable`
-        Optional extra settings:
-        `=PrintTA`
-        `=PrintAA`
-        `=PrintPerf`
-        `=PrintSteps`
-        `=PrintModBefore`
-        `=PrintModAfter`
-        `=PrintModFinal`
-        `=PrintPasses`,
-        `=NoPostopt`
-        `=LooseTypes`
-        `=Inline`
-        Multiple options can be combined with commas."),
-    #[rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field")]
-    binary_dep_depinfo: bool = (false, parse_bool, [TRACKED],
-        "include artifacts (sysroot, crate dependencies) used during compilation in dep-info \
-        (default: no)"),
-    box_noalias: bool = (true, parse_bool, [TRACKED],
-        "emit noalias metadata for box (default: yes)"),
-    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED TARGET_MODIFIER],
-        "set options for branch target identification and pointer authentication on AArch64"),
-    build_sdylib_interface: bool = (false, parse_bool, [UNTRACKED],
-        "whether the stable interface is being built"),
-    cache_proc_macros: bool = (false, parse_bool, [TRACKED],
-        "cache the results of derive proc macro invocations (potentially unsound!) (default: no"),
-    cf_protection: CFProtection = (CFProtection::None, parse_cfprotection, [TRACKED],
-        "instrument control-flow architecture protection"),
-    check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],
-        "show all expected values in check-cfg diagnostics (default: no)"),
-    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_cargo_src_file_hash, [TRACKED],
-        "hash algorithm of source files used to check freshness in cargo (`blake3` or `sha256`)"),
-    codegen_backend: Option<String> = (None, parse_opt_string, [TRACKED],
-        "the backend to use"),
-    codegen_source_order: bool = (false, parse_bool, [UNTRACKED],
-        "emit mono items in the order of spans in source files (default: no)"),
-    contract_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "emit runtime checks for contract pre- and post-conditions (default: no)"),
-    coverage_options: CoverageOptions = (CoverageOptions::default(), parse_coverage_options, [TRACKED],
-        "control details of coverage instrumentation"),
-    crate_attr: Vec<String> = (Vec::new(), parse_string_push, [TRACKED],
-        "inject the given attribute in the crate"),
-    cross_crate_inline_threshold: InliningThreshold = (InliningThreshold::Sometimes(100), parse_inlining_threshold, [TRACKED],
-        "threshold to allow cross crate inlining of functions"),
-    debug_info_for_profiling: bool = (false, parse_bool, [TRACKED],
-        "emit discriminators and other data necessary for AutoFDO"),
-    debug_info_type_line_numbers: bool = (false, parse_bool, [TRACKED],
-        "emit type and line information for additional data types (default: no)"),
-    debuginfo_compression: DebugInfoCompression = (DebugInfoCompression::None, parse_debuginfo_compression, [TRACKED],
-        "compress debug info sections (none, zlib, zstd, default: none)"),
-    deduplicate_diagnostics: bool = (true, parse_bool, [UNTRACKED],
-        "deduplicate identical diagnostics (default: yes)"),
-    default_visibility: Option<SymbolVisibility> = (None, parse_opt_symbol_visibility, [TRACKED],
-        "overrides the `default_visibility` setting of the target"),
-    dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
-        "in dep-info output, omit targets for tracking dependencies of the dep-info files \
-        themselves (default: no)"),
-    direct_access_external_data: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "Direct or use GOT indirect to reference external data symbols"),
-    dual_proc_macros: bool = (false, parse_bool, [TRACKED],
-        "load proc macros for both target and host, but only link to the target (default: no)"),
-    dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
-        "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv) \
-        (default: no)"),
-    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "dump MIR state to file.
-        `val` is used to select which passes and functions to dump. For example:
-        `all` matches all passes and functions,
-        `foo` matches all passes for functions whose name contains 'foo',
-        `foo & ConstProp` only the 'ConstProp' pass for function names containing 'foo',
-        `foo | bar` all passes for function names containing 'foo' or 'bar'."),
-    dump_mir_dataflow: bool = (false, parse_bool, [UNTRACKED],
-        "in addition to `.mir` files, create graphviz `.dot` files with dataflow results \
-        (default: no)"),
-    dump_mir_dir: String = ("mir_dump".to_string(), parse_string, [UNTRACKED],
-        "the directory the MIR is dumped into (default: `mir_dump`)"),
-    dump_mir_exclude_alloc_bytes: bool = (false, parse_bool, [UNTRACKED],
-        "exclude the raw bytes of allocations when dumping MIR (used in tests) (default: no)"),
-    dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
-        "exclude the pass number when dumping MIR (used in tests) (default: no)"),
-    dump_mir_graphviz: bool = (false, parse_bool, [UNTRACKED],
-        "in addition to `.mir` files, create graphviz `.dot` files (default: no)"),
-    dump_mono_stats: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
-        parse_switch_with_opt_path, [UNTRACKED],
-        "output statistics about monomorphization collection"),
-    dump_mono_stats_format: DumpMonoStatsFormat = (DumpMonoStatsFormat::Markdown, parse_dump_mono_stats, [UNTRACKED],
-        "the format to use for -Z dump-mono-stats (`markdown` (default) or `json`)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
-    dwarf_version: Option<u32> = (None, parse_opt_number, [TRACKED],
-        "version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),
-    dylib_lto: bool = (false, parse_bool, [UNTRACKED],
-        "enables LTO for dylib crate type"),
-    eagerly_emit_delayed_bugs: bool = (false, parse_bool, [UNTRACKED],
-        "emit delayed bugs eagerly as errors instead of stashing them and emitting \
-        them only if an error has not been emitted"),
-    ehcont_guard: bool = (false, parse_bool, [TRACKED],
-        "generate Windows EHCont Guard tables"),
-    embed_metadata: bool = (true, parse_bool, [TRACKED],
-        "embed metadata in rlibs and dylibs (default: yes)"),
-    embed_source: bool = (false, parse_bool, [TRACKED],
-        "embed source text in DWARF debug sections (default: no)"),
-    emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
-        "emit a section containing stack size metadata (default: no)"),
-    emscripten_wasm_eh: bool = (true, parse_bool, [TRACKED],
-        "Use WebAssembly error handling for wasm32-unknown-emscripten"),
-    enforce_type_length_limit: bool = (false, parse_bool, [TRACKED],
-        "enforce the type length limit when monomorphizing instances in codegen"),
-    experimental_default_bounds: bool = (false, parse_bool, [TRACKED],
-        "enable default bounds for experimental group of auto traits"),
-    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
-        "export symbols from executables, as if they were dynamic libraries"),
-    external_clangrt: bool = (false, parse_bool, [UNTRACKED],
-        "rely on user specified linker commands to find clangrt"),
-    extra_const_ub_checks: bool = (false, parse_bool, [TRACKED],
-        "turns on more checks to detect const UB, which can be slow (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field")]
-    fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
-        (default: no)"),
-    fixed_x18: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "make the x18 register reserved on AArch64 (default: no)"),
-    flatten_format_args: bool = (true, parse_bool, [TRACKED],
-        "flatten nested format_args!() and literals into a simplified format_args!() call \
-        (default: yes)"),
-    fmt_debug: FmtDebug = (FmtDebug::Full, parse_fmt_debug, [TRACKED],
-        "how detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
-        `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
-    force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
-        "force all crates to be `rustc_private` unstable (default: no)"),
-    function_return: FunctionReturn = (FunctionReturn::default(), parse_function_return, [TRACKED],
-        "replace returns with jumps to `__x86_return_thunk` (default: `keep`)"),
-    function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether each function should go in its own section"),
-    future_incompat_test: bool = (false, parse_bool, [UNTRACKED],
-        "forces all lints to be future incompatible, used for internal testing (default: no)"),
-    graphviz_dark_mode: bool = (false, parse_bool, [UNTRACKED],
-        "use dark-themed colors in graphviz output (default: no)"),
-    graphviz_font: String = ("Courier, monospace".to_string(), parse_string, [UNTRACKED],
-        "use the given `fontname` in graphviz output; can be overridden by setting \
-        environment variable `RUSTC_GRAPHVIZ_FONT` (default: `Courier, monospace`)"),
-    has_thread_local: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "explicitly enable the `cfg(target_thread_local)` directive"),
-    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
-    higher_ranked_assumptions: bool = (false, parse_bool, [TRACKED],
-        "allow deducing higher-ranked outlives assumptions from coroutines when proving auto traits"),
-    hint_mostly_unused: bool = (false, parse_bool, [TRACKED],
-        "hint that most of this crate will go unused, to minimize work for uncalled functions"),
-    human_readable_cgu_names: bool = (false, parse_bool, [TRACKED],
-        "generate human-readable, predictable names for codegen units (default: no)"),
-    identify_regions: bool = (false, parse_bool, [UNTRACKED],
-        "display unnamed regions as `'<id>`, using a non-ident unique id (default: no)"),
-    ignore_directory_in_diagnostics_source_blocks: Vec<String> = (Vec::new(), parse_string_push, [UNTRACKED],
-        "do not display the source code block in diagnostics for files in the directory"),
-    incremental_ignore_spans: bool = (false, parse_bool, [TRACKED],
-        "ignore spans during ICH computation -- used for testing (default: no)"),
-    incremental_info: bool = (false, parse_bool, [UNTRACKED],
-        "print high-level information about incremental reuse (or the lack thereof) \
-        (default: no)"),
-    incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
-        "verify extended properties for incr. comp. (default: no):
-        - hashes of green query instances
-        - hash collisions of query keys
-        - hash collisions when creating dep-nodes"),
-    indirect_branch_cs_prefix: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "add `cs` prefix to `call` and `jmp` to indirect thunks (default: no)"),
-    inline_llvm: bool = (true, parse_bool, [TRACKED],
-        "enable LLVM inlining (default: yes)"),
-    inline_mir: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable MIR inlining (default: no)"),
-    inline_mir_forwarder_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "inlining threshold when the caller is a simple forwarding function (default: 30)"),
-    inline_mir_hint_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "inlining threshold for functions with inline hint (default: 100)"),
-    inline_mir_preserve_debug: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "when MIR inlining, whether to preserve debug info for callee variables \
-        (default: preserve for debuginfo != None, otherwise remove)"),
-    inline_mir_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "a default MIR inlining threshold (default: 50)"),
-    input_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print some statistics about AST and HIR (default: no)"),
-    instrument_mcount: bool = (false, parse_bool, [TRACKED],
-        "insert function instrument code for mcount-based tracing (default: no)"),
-    instrument_xray: Option<InstrumentXRay> = (None, parse_instrument_xray, [TRACKED],
-        "insert function instrument code for XRay-based tracing (default: no)
-         Optional extra settings:
-         `=always`
-         `=never`
-         `=ignore-loops`
-         `=instruction-threshold=N`
-         `=skip-entry`
-         `=skip-exit`
-         Multiple options can be combined with commas."),
-    large_data_threshold: Option<u64> = (None, parse_opt_number, [TRACKED],
-        "set the threshold for objects to be stored in a \"large data\" section \
-         (only effective with -Ccode-model=medium, default: 65536)"),
-    layout_seed: Option<u64> = (None, parse_opt_number, [TRACKED],
-        "seed layout randomization"),
-    link_directives: bool = (true, parse_bool, [TRACKED],
-        "honor #[link] directives in the compiled crate (default: yes)"),
-    link_native_libraries: bool = (true, parse_bool, [UNTRACKED],
-        "link native libraries in the linker invocation (default: yes)"),
-    link_only: bool = (false, parse_bool, [TRACKED],
-        "link the `.rlink` file generated by `-Z no-link` (default: no)"),
-    lint_llvm_ir: bool = (false, parse_bool, [TRACKED],
-        "lint LLVM IR (default: no)"),
-    lint_mir: bool = (false, parse_bool, [UNTRACKED],
-        "lint MIR before and after each transformation"),
-    llvm_module_flag: Vec<(String, u32, String)> = (Vec::new(), parse_llvm_module_flag, [TRACKED],
-        "a list of module flags to pass to LLVM (space separated)"),
-    llvm_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
-        "a list LLVM plugins to enable (space separated)"),
-    llvm_time_trace: bool = (false, parse_bool, [UNTRACKED],
-        "generate JSON tracing data file from LLVM data (default: no)"),
-    location_detail: LocationDetail = (LocationDetail::all(), parse_location_detail, [TRACKED],
-        "what location details should be tracked when using caller_location, either \
-        `none`, or a comma separated list of location details, for which \
-        valid options are `file`, `line`, and `column` (default: `file,line,column`)"),
-    ls: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
-        "decode and print various parts of the crate metadata for a library crate \
-        (space separated)"),
-    macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
-        "show macro backtraces (default: no)"),
-    macro_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print some statistics about macro expansions (default: no)"),
-    maximal_hir_to_mir_coverage: bool = (false, parse_bool, [TRACKED],
-        "save as much information as possible about the correspondence between MIR and HIR \
-        as source scopes (default: no)"),
-    merge_functions: Option<MergeFunctions> = (None, parse_merge_functions, [TRACKED],
-        "control the operation of the MergeFunctions LLVM pass, taking \
-        the same values as the target option of the same name"),
-    meta_stats: bool = (false, parse_bool, [UNTRACKED],
-        "gather metadata statistics (default: no)"),
-    metrics_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
-        "the directory metrics emitted by rustc are dumped into (implicitly enables default set of metrics)"),
-    min_function_alignment: Option<Align> = (None, parse_align, [TRACKED],
-        "align all functions to at least this many bytes. Must be a power of 2"),
-    min_recursion_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "set a minimum recursion limit (final limit = max(this, recursion_limit_from_crate))"),
-    mir_emit_retag: bool = (false, parse_bool, [TRACKED],
-        "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
-        (default: no)"),
-    mir_enable_passes: Vec<(String, bool)> = (Vec::new(), parse_list_with_polarity, [TRACKED],
-        "use like `-Zmir-enable-passes=+DestinationPropagation,-InstSimplify`. Forces the \
-        specified passes to be enabled, overriding all other checks. In particular, this will \
-        enable unsound (known-buggy and hence usually disabled) passes without further warning! \
-        Passes that are not specified are enabled or disabled by other flags as usual."),
-    mir_include_spans: MirIncludeSpans = (MirIncludeSpans::default(), parse_mir_include_spans, [UNTRACKED],
-        "include extra comments in mir pretty printing, like line numbers and statement indices, \
-         details about types, etc. (boolean for all passes, 'nll' to enable in NLL MIR only, default: 'nll')"),
-    mir_opt_bisect_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "limit the number of MIR optimization pass executions (global across all bodies). \
-        Pass executions after this limit are skipped and reported. (default: no limit)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field")]
-    mir_opt_level: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "MIR optimization level (0-4; default: 1 in non optimized builds and 2 in optimized builds)"),
-    mir_preserve_ub: bool = (false, parse_bool, [TRACKED],
-        "keep place mention statements and reads in trivial SwitchInt terminators, which are interpreted \
-        e.g., by miri; implies -Zmir-opt-level=0 (default: no)"),
-    mir_strip_debuginfo: MirStripDebugInfo = (MirStripDebugInfo::None, parse_mir_strip_debuginfo, [TRACKED],
-        "Whether to remove some of the MIR debug info from methods.  Default: None"),
-    move_size_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "the size at which the `large_assignments` lint starts to be emitted"),
-    mutable_noalias: bool = (true, parse_bool, [TRACKED],
-        "emit noalias metadata for mutable references (default: yes)"),
-    namespaced_crates: bool = (false, parse_bool, [TRACKED],
-        "allow crates to be namespaced by other crates (default: no)"),
-    next_solver: NextSolverConfig = (NextSolverConfig::default(), parse_next_solver_config, [TRACKED],
-        "enable and configure the next generation trait solver used by rustc"),
-    nll_facts: bool = (false, parse_bool, [UNTRACKED],
-        "dump facts from NLL analysis into side files (default: no)"),
-    nll_facts_dir: String = ("nll-facts".to_string(), parse_string, [UNTRACKED],
-        "the directory the NLL facts are dumped into (default: `nll-facts`)"),
-    no_analysis: bool = (false, parse_no_value, [UNTRACKED],
-        "parse and expand the source, but run no analysis"),
-    no_codegen: bool = (false, parse_no_value, [TRACKED_NO_CRATE_HASH],
-        "run all passes except codegen; no output"),
-    no_generate_arange_section: bool = (false, parse_no_value, [TRACKED],
-        "omit DWARF address ranges that give faster lookups"),
-    no_implied_bounds_compat: bool = (false, parse_bool, [TRACKED],
-        "disable the compatibility version of the `implied_bounds_ty` query"),
-    no_leak_check: bool = (false, parse_no_value, [UNTRACKED],
-        "disable the 'leak check' for subtyping; unsound, but useful for tests"),
-    no_link: bool = (false, parse_no_value, [TRACKED],
-        "compile without linking"),
-    no_parallel_backend: bool = (false, parse_no_value, [UNTRACKED],
-        "run LLVM in non-parallel mode (while keeping codegen-units and ThinLTO)"),
-    no_profiler_runtime: bool = (false, parse_no_value, [TRACKED],
-        "prevent automatic injection of the profiler_builtins crate"),
-    no_steal_thir: bool = (false, parse_bool, [UNTRACKED],
-        "don't steal the THIR when we're done with it; useful for rustc drivers (default: no)"),
-    no_trait_vptr: bool = (false, parse_no_value, [TRACKED],
-        "disable generation of trait vptr in vtable for upcasting"),
-    no_unique_section_names: bool = (false, parse_bool, [TRACKED],
-        "do not use unique names for text and data sections when -Z function-sections is used"),
-    normalize_docs: bool = (false, parse_bool, [TRACKED],
-        "normalize associated items in rustdoc when generating documentation"),
-    offload: Vec<crate::config::Offload> = (Vec::new(), parse_offload, [TRACKED],
-        "a list of offload flags to enable
-        Mandatory setting:
-        `=Enable`
-        Currently the only option available"),
-    on_broken_pipe: OnBrokenPipe = (OnBrokenPipe::Default, parse_on_broken_pipe, [TRACKED],
-        "behavior of std::io::ErrorKind::BrokenPipe (SIGPIPE)"),
-    osx_rpath_install_name: bool = (false, parse_bool, [TRACKED],
-        "pass `-install_name @rpath/...` to the macOS linker (default: no)"),
-    packed_bundled_libs: bool = (false, parse_bool, [TRACKED],
-        "change rlib format to store native libraries as archives"),
-    panic_abort_tests: bool = (false, parse_bool, [TRACKED],
-        "support compiling tests with panic=abort (default: no)"),
-    panic_in_drop: PanicStrategy = (PanicStrategy::Unwind, parse_panic_strategy, [TRACKED],
-        "panic strategy for panics in drops"),
-    parse_crate_root_only: bool = (false, parse_bool, [UNTRACKED],
-        "parse the crate root file only; do not parse other files, compile, assemble, or link \
-        (default: no)"),
-    patchable_function_entry: PatchableFunctionEntry = (PatchableFunctionEntry::default(), parse_patchable_function_entry, [TRACKED],
-        "nop padding at function entry"),
-    plt: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether to use the PLT when calling into shared libraries;
-        only has effect for PIC code on systems with ELF binaries
-        (default: PLT is disabled if full relro is enabled on x86_64)"),
-    polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
-        "enable polonius-based borrow-checker (default: no)"),
-    pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
-        "a single extra argument to prepend the linker invocation (can be used several times)"),
-    pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
-        "extra arguments to prepend to the linker invocation (space separated)"),
-    precise_enum_drop_elaboration: bool = (true, parse_bool, [TRACKED],
-        "use a more precise version of drop elaboration for matches on enums (default: yes). \
-        This results in better codegen, but has caused miscompilations on some tier 2 platforms. \
-        See #77382 and #74551."),
-    #[rustc_lint_opt_deny_field_access("use `Session::print_codegen_stats` instead of this field")]
-    print_codegen_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print codegen statistics (default: no)"),
-    print_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
-        "print the LLVM optimization passes being run (default: no)"),
-    print_mono_items: bool = (false, parse_bool, [UNTRACKED],
-        "print the result of the monomorphization collection pass (default: no)"),
-    print_type_sizes: bool = (false, parse_bool, [UNTRACKED],
-        "print layout information for each type encountered (default: no)"),
-    proc_macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
-         "show backtraces for panics during proc-macro execution (default: no)"),
-    proc_macro_execution_strategy: ProcMacroExecutionStrategy = (ProcMacroExecutionStrategy::SameThread,
-        parse_proc_macro_execution_strategy, [UNTRACKED],
-        "how to run proc-macro code (default: same-thread)"),
-    profile_closures: bool = (false, parse_no_value, [UNTRACKED],
-        "profile size of closures"),
-    profile_sample_use: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "use the given `.prof` file for sampled profile-guided optimization (also known as AutoFDO)"),
-    profiler_runtime: String = (String::from("profiler_builtins"), parse_string, [TRACKED],
-        "name of the profiler runtime crate to automatically inject (default: `profiler_builtins`)"),
-    query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
-        "enable queries of the dependency graph for regression testing (default: no)"),
-    randomize_layout: bool = (false, parse_bool, [TRACKED],
-        "randomize the layout of types (default: no)"),
-    reg_struct_return: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "On x86-32 targets, it overrides the default ABI to return small structs in registers.
-        It is UNSOUND to link together crates that use different values for this flag!"),
-    regparm: Option<u32> = (None, parse_opt_number, [TRACKED TARGET_MODIFIER],
-        "On x86-32 targets, setting this to N causes the compiler to pass N arguments \
-        in registers EAX, EDX, and ECX instead of on the stack for\
-        \"C\", \"cdecl\", and \"stdcall\" fn.\
-        It is UNSOUND to link together crates that use different values for this flag!"),
-    relax_elf_relocations: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether ELF relocations can be relaxed"),
-    remap_cwd_prefix: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "remap paths under the current working directory to this path prefix"),
-    remark_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
-        "directory into which to write optimization remarks (if not specified, they will be \
-written to standard error output)"),
-    retpoline: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "enables retpoline-indirect-branches and retpoline-indirect-calls target features (default: no)"),
-    retpoline_external_thunk: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "enables retpoline-external-thunk, retpoline-indirect-branches and retpoline-indirect-calls \
-        target features (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::sanitizers()` instead of this field")]
-    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED TARGET_MODIFIER],
-        "use a sanitizer"),
-    sanitizer_cfi_canonical_jump_tables: Option<bool> = (Some(true), parse_opt_bool, [TRACKED],
-        "enable canonical jump tables (default: yes)"),
-    sanitizer_cfi_generalize_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable generalizing pointer types (default: no)"),
-    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED TARGET_MODIFIER],
-        "enable normalizing integer types (default: no)"),
-    sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
-        "additional ABI list files that control how shadow parameters are passed (comma separated)"),
-    sanitizer_kcfi_arity: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable KCFI arity indicator (default: no)"),
-    sanitizer_memory_track_origins: usize = (0, parse_sanitizer_memory_track_origins, [TRACKED],
-        "enable origins tracking in MemorySanitizer"),
-    sanitizer_recover: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED],
-        "enable recovery for selected sanitizers"),
-    saturating_float_casts: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "make float->int casts UB-free: numbers outside the integer type's range are clipped to \
-        the max/min integer respectively, and NaN is mapped to 0 (default: yes)"),
-    self_profile: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
-        parse_switch_with_opt_path, [UNTRACKED],
-        "run the self profiler and output the raw event data"),
-    self_profile_counter: String = ("wall-time".to_string(), parse_string, [UNTRACKED],
-        "counter used by the self profiler (default: `wall-time`), one of:
-        `wall-time` (monotonic clock, i.e. `std::time::Instant`)
-        `instructions:u` (retired instructions, userspace-only)
-        `instructions-minus-irqs:u` (subtracting hardware interrupt counts for extra accuracy)"
-    ),
-    /// keep this in sync with the event filter names in librustc_data_structures/profiling.rs
-    self_profile_events: Option<Vec<String>> = (None, parse_opt_comma_list, [UNTRACKED],
-        "specify the events recorded by the self profiler;
-        for example: `-Z self-profile-events=default,query-keys`
-        all options: none, all, default, generic-activity, query-provider, query-cache-hit
-                     query-blocked, incr-cache-load, incr-result-hashing, query-keys, function-args, args, llvm, artifact-sizes"),
-    share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "make the current crate share its generic instantiations"),
-    shell_argfiles: bool = (false, parse_bool, [UNTRACKED],
-        "allow argument files to be specified with POSIX \"shell-style\" argument quoting"),
-    simulate_remapped_rust_src_base: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "simulate the effect of remap-debuginfo = true at bootstrapping by remapping path \
-        to rust's source base directory. only meant for testing purposes"),
-    small_data_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "Set the threshold for objects to be stored in a \"small data\" section"),
-    span_debug: bool = (false, parse_bool, [UNTRACKED],
-        "forward proc_macro::Span's `Debug` impl to `Span`"),
-    /// o/w tests have closure@path
-    span_free_formats: bool = (false, parse_bool, [UNTRACKED],
-        "exclude spans when debug-printing compiler state (default: no)"),
-    split_dwarf_inlining: bool = (false, parse_bool, [TRACKED],
-        "provide minimal debug info in the object/executable to facilitate online \
-         symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF"),
-    split_dwarf_kind: SplitDwarfKind = (SplitDwarfKind::Split, parse_split_dwarf_kind, [TRACKED],
-        "split dwarf variant (only if -Csplit-debuginfo is enabled and on relevant platform)
-        (default: `split`)
-
-        `split`: sections which do not require relocation are written into a DWARF object (`.dwo`)
-                 file which is ignored by the linker
-        `single`: sections which do not require relocation are written into object file but ignored
-                  by the linker"),
-    split_dwarf_out_dir : Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "location for writing split DWARF objects (`.dwo`) if enabled"),
-    split_lto_unit: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable LTO unit splitting (default: no)"),
-    src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
-        "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")]
-    stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED],
-        "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"),
-    staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED],
-        "allow staticlibs to have rust dylib dependencies"),
-    staticlib_prefer_dynamic: bool = (false, parse_bool, [TRACKED],
-        "prefer dynamic linking to static linking for staticlibs (default: no)"),
-    strict_init_checks: bool = (false, parse_bool, [TRACKED],
-        "control if mem::uninitialized and mem::zeroed panic on more UB"),
-    #[rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field")]
-    teach: bool = (false, parse_bool, [TRACKED],
-        "show extended diagnostic help (default: no)"),
-    temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "the directory the intermediate files are written to"),
-    terminal_urls: TerminalUrl = (TerminalUrl::No, parse_terminal_url, [UNTRACKED],
-        "use the OSC 8 hyperlink terminal specification to print hyperlinks in the compiler output"),
-    #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")]
-    thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable ThinLTO when possible"),
-    /// We default to 1 here since we want to behave like
-    /// a sequential compiler for now. This'll likely be adjusted
-    /// in the future. Note that -Zthreads=0 is the way to get
-    /// the num_cpus behavior.
-    #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")]
-    threads: usize = (1, parse_threads, [UNTRACKED],
-        "use a thread pool with N threads"),
-    time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
-        "measure time of each LLVM pass (default: no)"),
-    time_passes: bool = (false, parse_bool, [UNTRACKED],
-        "measure time of each rustc pass (default: no)"),
-    time_passes_format: TimePassesFormat = (TimePassesFormat::Text, parse_time_passes_format, [UNTRACKED],
-        "the format to use for -Z time-passes (`text` (default) or `json`)"),
-    tiny_const_eval_limit: bool = (false, parse_bool, [TRACKED],
-        "sets a tiny, non-configurable limit for const eval; useful for compiler tests"),
-    #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")]
-    tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED],
-        "choose the TLS model to use (`rustc --print tls-models` for details)"),
-    trace_macros: bool = (false, parse_bool, [UNTRACKED],
-        "for every macro invocation, print its name and arguments (default: no)"),
-    track_diagnostics: bool = (false, parse_bool, [UNTRACKED],
-        "tracks where in rustc a diagnostic was emitted"),
-    translate_remapped_path_to_local_path: bool = (true, parse_bool, [TRACKED],
-        "translate remapped paths into local paths when possible (default: yes)"),
-    trap_unreachable: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "generate trap instructions for unreachable intrinsics (default: use target setting, usually yes)"),
-    treat_err_as_bug: Option<NonZero<usize>> = (None, parse_treat_err_as_bug, [TRACKED],
-        "treat the `val`th error that occurs as bug (default if not specified: 0 - don't treat errors as bugs. \
-        default if specified without a value: 1 - treat the first error as bug)"),
-    trim_diagnostic_paths: bool = (true, parse_bool, [UNTRACKED],
-        "in diagnostics, use heuristics to shorten paths referring to items"),
-    tune_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
-        "select processor to schedule for (`rustc --print target-cpus` for details)"),
-    #[rustc_lint_opt_deny_field_access("use `TyCtxt::use_typing_mode_borrowck` instead of this field")]
-    typing_mode_borrowck: bool = (false, parse_bool, [TRACKED],
-        "enable `TypingMode::Borrowck`, changing the way opaque types are handled during MIR borrowck"),
-    #[rustc_lint_opt_deny_field_access("use `Session::ub_checks` instead of this field")]
-    ub_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "emit runtime checks for Undefined Behavior (default: -Cdebug-assertions)"),
-    ui_testing: bool = (false, parse_bool, [UNTRACKED],
-        "emit compiler diagnostics in a form suitable for UI testing (default: no)"),
-    uninit_const_chunk_threshold: usize = (16, parse_number, [TRACKED],
-        "allow generating const initializers with mixed init/uninit chunks, \
-        and set the maximum number of chunks for which this is allowed (default: 16)"),
-    unleash_the_miri_inside_of_you: bool = (false, parse_bool, [TRACKED],
-        "take the brakes off const evaluation. NOTE: this is unsound (default: no)"),
-    unpretty: Option<String> = (None, parse_unpretty, [UNTRACKED],
-        "present the input source, unstable (and less-pretty) variants;
-        `normal`, `identified`,
-        `expanded`, `expanded,identified`,
-        `expanded,hygiene` (with internal representations),
-        `ast-tree` (raw AST before expansion),
-        `ast-tree,expanded` (raw AST after expansion),
-        `hir` (the HIR), `hir,identified`,
-        `hir,typed` (HIR with types for each node),
-        `hir-tree` (dump the raw HIR),
-        `thir-tree`, `thir-flat`,
-        `mir` (the MIR), or `mir-cfg` (graphviz formatted MIR)"),
-    unsound_mir_opts: bool = (false, parse_bool, [TRACKED],
-        "enable unsound and buggy MIR optimizations (default: no)"),
-    /// This name is kind of confusing: Most unstable options enable something themselves, while
-    /// this just allows "normal" options to be feature-gated.
-    ///
-    /// The main check for `-Zunstable-options` takes place separately from the
-    /// usual parsing of `-Z` options (see [`crate::config::nightly_options`]),
-    /// so this boolean value is mostly used for enabling unstable _values_ of
-    /// stable options. That separate check doesn't handle boolean values, so
-    /// to avoid an inconsistent state we also forbid them here.
-    #[rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field")]
-    unstable_options: bool = (false, parse_no_value, [UNTRACKED],
-        "adds unstable command line options to rustc interface (default: no)"),
-    use_ctors_section: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "use legacy .ctors section for initializers rather than .init_array"),
-    use_sync_unwind: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "Generate sync unwind tables instead of async unwind tables (default: no)"),
-    validate_mir: bool = (false, parse_bool, [UNTRACKED],
-        "validate MIR after each transformation"),
-    verbose_asm: bool = (false, parse_bool, [TRACKED],
-        "add descriptive comments from LLVM to the assembly (may change behavior) (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::verbose_internals` instead of this field")]
-    verbose_internals: bool = (false, parse_bool, [TRACKED_NO_CRATE_HASH],
-        "in general, enable more debug printouts (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field")]
-    verify_llvm_ir: bool = (false, parse_bool, [TRACKED],
-        "verify LLVM IR (default: no)"),
-    virtual_function_elimination: bool = (false, parse_bool, [TRACKED],
-        "enables dead virtual function elimination optimization. \
-        Requires `-Clto[=[fat,yes]]`"),
-    wasi_exec_model: Option<WasiExecModel> = (None, parse_wasi_exec_model, [TRACKED],
-        "whether to build a wasi command or reactor"),
-    // This option only still exists to provide a more gradual transition path for people who need
-    // the spec-complaint C ABI to be used.
-    // FIXME remove this after a couple releases
-    wasm_c_abi: () = ((), parse_wasm_c_abi, [TRACKED],
-        "use spec-compliant C ABI for `wasm32-unknown-unknown` (deprecated, always enabled)"),
-    write_long_types_to_disk: bool = (true, parse_bool, [UNTRACKED],
-        "whether long type names should be written to files instead of being printed in errors"),
-    // tidy-alphabetical-end
-
-    // If you add a new option, please update:
-    // - compiler/rustc_interface/src/tests.rs
-    // - src/doc/unstable-book/src/compiler-flags
-}
+include!("options/unstable.rs");
diff --git a/compiler/rustc_session/src/options/unstable.rs b/compiler/rustc_session/src/options/unstable.rs
new file mode 100644
index 000000000000..dc00bd8a223a
--- /dev/null
+++ b/compiler/rustc_session/src/options/unstable.rs
@@ -0,0 +1,585 @@
+options! {
+    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
+
+    // If you add a new option, please update:
+    // - compiler/rustc_interface/src/tests.rs
+    // - src/doc/unstable-book/src/compiler-flags
+
+    // tidy-alphabetical-start
+    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
+        "only allow the listed language features to be enabled in code (comma separated)"),
+    always_encode_mir: bool = (false, parse_bool, [TRACKED],
+        "encode MIR of all functions into the crate metadata (default: no)"),
+    annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED],
+        "emit debug info for compiler-generated move and copy operations \
+        to make them visible in profilers. Can be a boolean or a size limit in bytes (default: disabled)"),
+    assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "assert that the incremental cache is in given state: \
+         either `loaded` or `not-loaded`."),
+    assume_incomplete_release: bool = (false, parse_bool, [TRACKED],
+        "make cfg(version) treat the current version as incomplete (default: no)"),
+    autodiff: Vec<crate::config::AutoDiff> = (Vec::new(), parse_autodiff, [TRACKED],
+        "a list of autodiff flags to enable
+        Mandatory setting:
+        `=Enable`
+        Optional extra settings:
+        `=PrintTA`
+        `=PrintAA`
+        `=PrintPerf`
+        `=PrintSteps`
+        `=PrintModBefore`
+        `=PrintModAfter`
+        `=PrintModFinal`
+        `=PrintPasses`,
+        `=NoPostopt`
+        `=LooseTypes`
+        `=Inline`
+        Multiple options can be combined with commas."),
+    #[rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field")]
+    binary_dep_depinfo: bool = (false, parse_bool, [TRACKED],
+        "include artifacts (sysroot, crate dependencies) used during compilation in dep-info \
+        (default: no)"),
+    box_noalias: bool = (true, parse_bool, [TRACKED],
+        "emit noalias metadata for box (default: yes)"),
+    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED TARGET_MODIFIER],
+        "set options for branch target identification and pointer authentication on AArch64"),
+    build_sdylib_interface: bool = (false, parse_bool, [UNTRACKED],
+        "whether the stable interface is being built"),
+    cache_proc_macros: bool = (false, parse_bool, [TRACKED],
+        "cache the results of derive proc macro invocations (potentially unsound!) (default: no"),
+    cf_protection: CFProtection = (CFProtection::None, parse_cfprotection, [TRACKED],
+        "instrument control-flow architecture protection"),
+    check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],
+        "show all expected values in check-cfg diagnostics (default: no)"),
+    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_cargo_src_file_hash, [TRACKED],
+        "hash algorithm of source files used to check freshness in cargo (`blake3` or `sha256`)"),
+    codegen_backend: Option<String> = (None, parse_opt_string, [TRACKED],
+        "the backend to use"),
+    codegen_source_order: bool = (false, parse_bool, [UNTRACKED],
+        "emit mono items in the order of spans in source files (default: no)"),
+    contract_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "emit runtime checks for contract pre- and post-conditions (default: no)"),
+    coverage_options: CoverageOptions = (CoverageOptions::default(), parse_coverage_options, [TRACKED],
+        "control details of coverage instrumentation"),
+    crate_attr: Vec<String> = (Vec::new(), parse_string_push, [TRACKED],
+        "inject the given attribute in the crate"),
+    cross_crate_inline_threshold: InliningThreshold = (InliningThreshold::Sometimes(100), parse_inlining_threshold, [TRACKED],
+        "threshold to allow cross crate inlining of functions"),
+    debug_info_for_profiling: bool = (false, parse_bool, [TRACKED],
+        "emit discriminators and other data necessary for AutoFDO"),
+    debug_info_type_line_numbers: bool = (false, parse_bool, [TRACKED],
+        "emit type and line information for additional data types (default: no)"),
+    debuginfo_compression: DebugInfoCompression = (DebugInfoCompression::None, parse_debuginfo_compression, [TRACKED],
+        "compress debug info sections (none, zlib, zstd, default: none)"),
+    deduplicate_diagnostics: bool = (true, parse_bool, [UNTRACKED],
+        "deduplicate identical diagnostics (default: yes)"),
+    default_visibility: Option<SymbolVisibility> = (None, parse_opt_symbol_visibility, [TRACKED],
+        "overrides the `default_visibility` setting of the target"),
+    dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
+        "in dep-info output, omit targets for tracking dependencies of the dep-info files \
+        themselves (default: no)"),
+    direct_access_external_data: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "Direct or use GOT indirect to reference external data symbols"),
+    dual_proc_macros: bool = (false, parse_bool, [TRACKED],
+        "load proc macros for both target and host, but only link to the target (default: no)"),
+    dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
+        "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv) \
+        (default: no)"),
+    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "dump MIR state to file.
+        `val` is used to select which passes and functions to dump. For example:
+        `all` matches all passes and functions,
+        `foo` matches all passes for functions whose name contains 'foo',
+        `foo & ConstProp` only the 'ConstProp' pass for function names containing 'foo',
+        `foo | bar` all passes for function names containing 'foo' or 'bar'."),
+    dump_mir_dataflow: bool = (false, parse_bool, [UNTRACKED],
+        "in addition to `.mir` files, create graphviz `.dot` files with dataflow results \
+        (default: no)"),
+    dump_mir_dir: String = ("mir_dump".to_string(), parse_string, [UNTRACKED],
+        "the directory the MIR is dumped into (default: `mir_dump`)"),
+    dump_mir_exclude_alloc_bytes: bool = (false, parse_bool, [UNTRACKED],
+        "exclude the raw bytes of allocations when dumping MIR (used in tests) (default: no)"),
+    dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
+        "exclude the pass number when dumping MIR (used in tests) (default: no)"),
+    dump_mir_graphviz: bool = (false, parse_bool, [UNTRACKED],
+        "in addition to `.mir` files, create graphviz `.dot` files (default: no)"),
+    dump_mono_stats: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
+        parse_switch_with_opt_path, [UNTRACKED],
+        "output statistics about monomorphization collection"),
+    dump_mono_stats_format: DumpMonoStatsFormat = (DumpMonoStatsFormat::Markdown, parse_dump_mono_stats, [UNTRACKED],
+        "the format to use for -Z dump-mono-stats (`markdown` (default) or `json`)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
+    dwarf_version: Option<u32> = (None, parse_opt_number, [TRACKED],
+        "version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),
+    dylib_lto: bool = (false, parse_bool, [UNTRACKED],
+        "enables LTO for dylib crate type"),
+    eagerly_emit_delayed_bugs: bool = (false, parse_bool, [UNTRACKED],
+        "emit delayed bugs eagerly as errors instead of stashing them and emitting \
+        them only if an error has not been emitted"),
+    ehcont_guard: bool = (false, parse_bool, [TRACKED],
+        "generate Windows EHCont Guard tables"),
+    embed_metadata: bool = (true, parse_bool, [TRACKED],
+        "embed metadata in rlibs and dylibs (default: yes)"),
+    embed_source: bool = (false, parse_bool, [TRACKED],
+        "embed source text in DWARF debug sections (default: no)"),
+    emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
+        "emit a section containing stack size metadata (default: no)"),
+    emscripten_wasm_eh: bool = (true, parse_bool, [TRACKED],
+        "Use WebAssembly error handling for wasm32-unknown-emscripten"),
+    enforce_type_length_limit: bool = (false, parse_bool, [TRACKED],
+        "enforce the type length limit when monomorphizing instances in codegen"),
+    experimental_default_bounds: bool = (false, parse_bool, [TRACKED],
+        "enable default bounds for experimental group of auto traits"),
+    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
+        "export symbols from executables, as if they were dynamic libraries"),
+    external_clangrt: bool = (false, parse_bool, [UNTRACKED],
+        "rely on user specified linker commands to find clangrt"),
+    extra_const_ub_checks: bool = (false, parse_bool, [TRACKED],
+        "turns on more checks to detect const UB, which can be slow (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field")]
+    fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
+        (default: no)"),
+    fixed_x18: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "make the x18 register reserved on AArch64 (default: no)"),
+    flatten_format_args: bool = (true, parse_bool, [TRACKED],
+        "flatten nested format_args!() and literals into a simplified format_args!() call \
+        (default: yes)"),
+    fmt_debug: FmtDebug = (FmtDebug::Full, parse_fmt_debug, [TRACKED],
+        "how detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
+        `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
+    force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
+        "force all crates to be `rustc_private` unstable (default: no)"),
+    function_return: FunctionReturn = (FunctionReturn::default(), parse_function_return, [TRACKED],
+        "replace returns with jumps to `__x86_return_thunk` (default: `keep`)"),
+    function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether each function should go in its own section"),
+    future_incompat_test: bool = (false, parse_bool, [UNTRACKED],
+        "forces all lints to be future incompatible, used for internal testing (default: no)"),
+    graphviz_dark_mode: bool = (false, parse_bool, [UNTRACKED],
+        "use dark-themed colors in graphviz output (default: no)"),
+    graphviz_font: String = ("Courier, monospace".to_string(), parse_string, [UNTRACKED],
+        "use the given `fontname` in graphviz output; can be overridden by setting \
+        environment variable `RUSTC_GRAPHVIZ_FONT` (default: `Courier, monospace`)"),
+    has_thread_local: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "explicitly enable the `cfg(target_thread_local)` directive"),
+    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
+    higher_ranked_assumptions: bool = (false, parse_bool, [TRACKED],
+        "allow deducing higher-ranked outlives assumptions from coroutines when proving auto traits"),
+    hint_mostly_unused: bool = (false, parse_bool, [TRACKED],
+        "hint that most of this crate will go unused, to minimize work for uncalled functions"),
+    human_readable_cgu_names: bool = (false, parse_bool, [TRACKED],
+        "generate human-readable, predictable names for codegen units (default: no)"),
+    identify_regions: bool = (false, parse_bool, [UNTRACKED],
+        "display unnamed regions as `'<id>`, using a non-ident unique id (default: no)"),
+    ignore_directory_in_diagnostics_source_blocks: Vec<String> = (Vec::new(), parse_string_push, [UNTRACKED],
+        "do not display the source code block in diagnostics for files in the directory"),
+    incremental_ignore_spans: bool = (false, parse_bool, [TRACKED],
+        "ignore spans during ICH computation -- used for testing (default: no)"),
+    incremental_info: bool = (false, parse_bool, [UNTRACKED],
+        "print high-level information about incremental reuse (or the lack thereof) \
+        (default: no)"),
+    incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
+        "verify extended properties for incr. comp. (default: no):
+        - hashes of green query instances
+        - hash collisions of query keys
+        - hash collisions when creating dep-nodes"),
+    indirect_branch_cs_prefix: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "add `cs` prefix to `call` and `jmp` to indirect thunks (default: no)"),
+    inline_llvm: bool = (true, parse_bool, [TRACKED],
+        "enable LLVM inlining (default: yes)"),
+    inline_mir: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable MIR inlining (default: no)"),
+    inline_mir_forwarder_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "inlining threshold when the caller is a simple forwarding function (default: 30)"),
+    inline_mir_hint_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "inlining threshold for functions with inline hint (default: 100)"),
+    inline_mir_preserve_debug: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "when MIR inlining, whether to preserve debug info for callee variables \
+        (default: preserve for debuginfo != None, otherwise remove)"),
+    inline_mir_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "a default MIR inlining threshold (default: 50)"),
+    input_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print some statistics about AST and HIR (default: no)"),
+    instrument_mcount: bool = (false, parse_bool, [TRACKED],
+        "insert function instrument code for mcount-based tracing (default: no)"),
+    instrument_xray: Option<InstrumentXRay> = (None, parse_instrument_xray, [TRACKED],
+        "insert function instrument code for XRay-based tracing (default: no)
+         Optional extra settings:
+         `=always`
+         `=never`
+         `=ignore-loops`
+         `=instruction-threshold=N`
+         `=skip-entry`
+         `=skip-exit`
+         Multiple options can be combined with commas."),
+    large_data_threshold: Option<u64> = (None, parse_opt_number, [TRACKED],
+        "set the threshold for objects to be stored in a \"large data\" section \
+         (only effective with -Ccode-model=medium, default: 65536)"),
+    layout_seed: Option<u64> = (None, parse_opt_number, [TRACKED],
+        "seed layout randomization"),
+    link_directives: bool = (true, parse_bool, [TRACKED],
+        "honor #[link] directives in the compiled crate (default: yes)"),
+    link_native_libraries: bool = (true, parse_bool, [UNTRACKED],
+        "link native libraries in the linker invocation (default: yes)"),
+    link_only: bool = (false, parse_bool, [TRACKED],
+        "link the `.rlink` file generated by `-Z no-link` (default: no)"),
+    lint_llvm_ir: bool = (false, parse_bool, [TRACKED],
+        "lint LLVM IR (default: no)"),
+    lint_mir: bool = (false, parse_bool, [UNTRACKED],
+        "lint MIR before and after each transformation"),
+    llvm_module_flag: Vec<(String, u32, String)> = (Vec::new(), parse_llvm_module_flag, [TRACKED],
+        "a list of module flags to pass to LLVM (space separated)"),
+    llvm_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
+        "a list LLVM plugins to enable (space separated)"),
+    llvm_time_trace: bool = (false, parse_bool, [UNTRACKED],
+        "generate JSON tracing data file from LLVM data (default: no)"),
+    location_detail: LocationDetail = (LocationDetail::all(), parse_location_detail, [TRACKED],
+        "what location details should be tracked when using caller_location, either \
+        `none`, or a comma separated list of location details, for which \
+        valid options are `file`, `line`, and `column` (default: `file,line,column`)"),
+    ls: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
+        "decode and print various parts of the crate metadata for a library crate \
+        (space separated)"),
+    macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
+        "show macro backtraces (default: no)"),
+    macro_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print some statistics about macro expansions (default: no)"),
+    maximal_hir_to_mir_coverage: bool = (false, parse_bool, [TRACKED],
+        "save as much information as possible about the correspondence between MIR and HIR \
+        as source scopes (default: no)"),
+    merge_functions: Option<MergeFunctions> = (None, parse_merge_functions, [TRACKED],
+        "control the operation of the MergeFunctions LLVM pass, taking \
+        the same values as the target option of the same name"),
+    meta_stats: bool = (false, parse_bool, [UNTRACKED],
+        "gather metadata statistics (default: no)"),
+    metrics_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
+        "the directory metrics emitted by rustc are dumped into (implicitly enables default set of metrics)"),
+    min_function_alignment: Option<Align> = (None, parse_align, [TRACKED],
+        "align all functions to at least this many bytes. Must be a power of 2"),
+    min_recursion_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "set a minimum recursion limit (final limit = max(this, recursion_limit_from_crate))"),
+    mir_emit_retag: bool = (false, parse_bool, [TRACKED],
+        "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
+        (default: no)"),
+    mir_enable_passes: Vec<(String, bool)> = (Vec::new(), parse_list_with_polarity, [TRACKED],
+        "use like `-Zmir-enable-passes=+DestinationPropagation,-InstSimplify`. Forces the \
+        specified passes to be enabled, overriding all other checks. In particular, this will \
+        enable unsound (known-buggy and hence usually disabled) passes without further warning! \
+        Passes that are not specified are enabled or disabled by other flags as usual."),
+    mir_include_spans: MirIncludeSpans = (MirIncludeSpans::default(), parse_mir_include_spans, [UNTRACKED],
+        "include extra comments in mir pretty printing, like line numbers and statement indices, \
+         details about types, etc. (boolean for all passes, 'nll' to enable in NLL MIR only, default: 'nll')"),
+    mir_opt_bisect_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "limit the number of MIR optimization pass executions (global across all bodies). \
+        Pass executions after this limit are skipped and reported. (default: no limit)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field")]
+    mir_opt_level: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "MIR optimization level (0-4; default: 1 in non optimized builds and 2 in optimized builds)"),
+    mir_preserve_ub: bool = (false, parse_bool, [TRACKED],
+        "keep place mention statements and reads in trivial SwitchInt terminators, which are interpreted \
+        e.g., by miri; implies -Zmir-opt-level=0 (default: no)"),
+    mir_strip_debuginfo: MirStripDebugInfo = (MirStripDebugInfo::None, parse_mir_strip_debuginfo, [TRACKED],
+        "Whether to remove some of the MIR debug info from methods.  Default: None"),
+    move_size_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "the size at which the `large_assignments` lint starts to be emitted"),
+    mutable_noalias: bool = (true, parse_bool, [TRACKED],
+        "emit noalias metadata for mutable references (default: yes)"),
+    namespaced_crates: bool = (false, parse_bool, [TRACKED],
+        "allow crates to be namespaced by other crates (default: no)"),
+    next_solver: NextSolverConfig = (NextSolverConfig::default(), parse_next_solver_config, [TRACKED],
+        "enable and configure the next generation trait solver used by rustc"),
+    nll_facts: bool = (false, parse_bool, [UNTRACKED],
+        "dump facts from NLL analysis into side files (default: no)"),
+    nll_facts_dir: String = ("nll-facts".to_string(), parse_string, [UNTRACKED],
+        "the directory the NLL facts are dumped into (default: `nll-facts`)"),
+    no_analysis: bool = (false, parse_no_value, [UNTRACKED],
+        "parse and expand the source, but run no analysis"),
+    no_codegen: bool = (false, parse_no_value, [TRACKED_NO_CRATE_HASH],
+        "run all passes except codegen; no output"),
+    no_generate_arange_section: bool = (false, parse_no_value, [TRACKED],
+        "omit DWARF address ranges that give faster lookups"),
+    no_implied_bounds_compat: bool = (false, parse_bool, [TRACKED],
+        "disable the compatibility version of the `implied_bounds_ty` query"),
+    no_leak_check: bool = (false, parse_no_value, [UNTRACKED],
+        "disable the 'leak check' for subtyping; unsound, but useful for tests"),
+    no_link: bool = (false, parse_no_value, [TRACKED],
+        "compile without linking"),
+    no_parallel_backend: bool = (false, parse_no_value, [UNTRACKED],
+        "run LLVM in non-parallel mode (while keeping codegen-units and ThinLTO)"),
+    no_profiler_runtime: bool = (false, parse_no_value, [TRACKED],
+        "prevent automatic injection of the profiler_builtins crate"),
+    no_steal_thir: bool = (false, parse_bool, [UNTRACKED],
+        "don't steal the THIR when we're done with it; useful for rustc drivers (default: no)"),
+    no_trait_vptr: bool = (false, parse_no_value, [TRACKED],
+        "disable generation of trait vptr in vtable for upcasting"),
+    no_unique_section_names: bool = (false, parse_bool, [TRACKED],
+        "do not use unique names for text and data sections when -Z function-sections is used"),
+    normalize_docs: bool = (false, parse_bool, [TRACKED],
+        "normalize associated items in rustdoc when generating documentation"),
+    offload: Vec<crate::config::Offload> = (Vec::new(), parse_offload, [TRACKED],
+        "a list of offload flags to enable
+        Mandatory setting:
+        `=Enable`
+        Currently the only option available"),
+    on_broken_pipe: OnBrokenPipe = (OnBrokenPipe::Default, parse_on_broken_pipe, [TRACKED],
+        "behavior of std::io::ErrorKind::BrokenPipe (SIGPIPE)"),
+    osx_rpath_install_name: bool = (false, parse_bool, [TRACKED],
+        "pass `-install_name @rpath/...` to the macOS linker (default: no)"),
+    packed_bundled_libs: bool = (false, parse_bool, [TRACKED],
+        "change rlib format to store native libraries as archives"),
+    panic_abort_tests: bool = (false, parse_bool, [TRACKED],
+        "support compiling tests with panic=abort (default: no)"),
+    panic_in_drop: PanicStrategy = (PanicStrategy::Unwind, parse_panic_strategy, [TRACKED],
+        "panic strategy for panics in drops"),
+    parse_crate_root_only: bool = (false, parse_bool, [UNTRACKED],
+        "parse the crate root file only; do not parse other files, compile, assemble, or link \
+        (default: no)"),
+    patchable_function_entry: PatchableFunctionEntry = (PatchableFunctionEntry::default(), parse_patchable_function_entry, [TRACKED],
+        "nop padding at function entry"),
+    plt: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether to use the PLT when calling into shared libraries;
+        only has effect for PIC code on systems with ELF binaries
+        (default: PLT is disabled if full relro is enabled on x86_64)"),
+    polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
+        "enable polonius-based borrow-checker (default: no)"),
+    pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
+        "a single extra argument to prepend the linker invocation (can be used several times)"),
+    pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
+        "extra arguments to prepend to the linker invocation (space separated)"),
+    precise_enum_drop_elaboration: bool = (true, parse_bool, [TRACKED],
+        "use a more precise version of drop elaboration for matches on enums (default: yes). \
+        This results in better codegen, but has caused miscompilations on some tier 2 platforms. \
+        See #77382 and #74551."),
+    #[rustc_lint_opt_deny_field_access("use `Session::print_codegen_stats` instead of this field")]
+    print_codegen_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print codegen statistics (default: no)"),
+    print_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
+        "print the LLVM optimization passes being run (default: no)"),
+    print_mono_items: bool = (false, parse_bool, [UNTRACKED],
+        "print the result of the monomorphization collection pass (default: no)"),
+    print_type_sizes: bool = (false, parse_bool, [UNTRACKED],
+        "print layout information for each type encountered (default: no)"),
+    proc_macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
+         "show backtraces for panics during proc-macro execution (default: no)"),
+    proc_macro_execution_strategy: ProcMacroExecutionStrategy = (ProcMacroExecutionStrategy::SameThread,
+        parse_proc_macro_execution_strategy, [UNTRACKED],
+        "how to run proc-macro code (default: same-thread)"),
+    profile_closures: bool = (false, parse_no_value, [UNTRACKED],
+        "profile size of closures"),
+    profile_sample_use: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "use the given `.prof` file for sampled profile-guided optimization (also known as AutoFDO)"),
+    profiler_runtime: String = (String::from("profiler_builtins"), parse_string, [TRACKED],
+        "name of the profiler runtime crate to automatically inject (default: `profiler_builtins`)"),
+    query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
+        "enable queries of the dependency graph for regression testing (default: no)"),
+    randomize_layout: bool = (false, parse_bool, [TRACKED],
+        "randomize the layout of types (default: no)"),
+    reg_struct_return: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "On x86-32 targets, it overrides the default ABI to return small structs in registers.
+        It is UNSOUND to link together crates that use different values for this flag!"),
+    regparm: Option<u32> = (None, parse_opt_number, [TRACKED TARGET_MODIFIER],
+        "On x86-32 targets, setting this to N causes the compiler to pass N arguments \
+        in registers EAX, EDX, and ECX instead of on the stack for\
+        \"C\", \"cdecl\", and \"stdcall\" fn.\
+        It is UNSOUND to link together crates that use different values for this flag!"),
+    relax_elf_relocations: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether ELF relocations can be relaxed"),
+    remap_cwd_prefix: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "remap paths under the current working directory to this path prefix"),
+    remark_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
+        "directory into which to write optimization remarks (if not specified, they will be \
+written to standard error output)"),
+    retpoline: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "enables retpoline-indirect-branches and retpoline-indirect-calls target features (default: no)"),
+    retpoline_external_thunk: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "enables retpoline-external-thunk, retpoline-indirect-branches and retpoline-indirect-calls \
+        target features (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::sanitizers()` instead of this field")]
+    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED TARGET_MODIFIER],
+        "use a sanitizer"),
+    sanitizer_cfi_canonical_jump_tables: Option<bool> = (Some(true), parse_opt_bool, [TRACKED],
+        "enable canonical jump tables (default: yes)"),
+    sanitizer_cfi_generalize_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable generalizing pointer types (default: no)"),
+    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED TARGET_MODIFIER],
+        "enable normalizing integer types (default: no)"),
+    sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
+        "additional ABI list files that control how shadow parameters are passed (comma separated)"),
+    sanitizer_kcfi_arity: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable KCFI arity indicator (default: no)"),
+    sanitizer_memory_track_origins: usize = (0, parse_sanitizer_memory_track_origins, [TRACKED],
+        "enable origins tracking in MemorySanitizer"),
+    sanitizer_recover: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED],
+        "enable recovery for selected sanitizers"),
+    saturating_float_casts: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "make float->int casts UB-free: numbers outside the integer type's range are clipped to \
+        the max/min integer respectively, and NaN is mapped to 0 (default: yes)"),
+    self_profile: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
+        parse_switch_with_opt_path, [UNTRACKED],
+        "run the self profiler and output the raw event data"),
+    self_profile_counter: String = ("wall-time".to_string(), parse_string, [UNTRACKED],
+        "counter used by the self profiler (default: `wall-time`), one of:
+        `wall-time` (monotonic clock, i.e. `std::time::Instant`)
+        `instructions:u` (retired instructions, userspace-only)
+        `instructions-minus-irqs:u` (subtracting hardware interrupt counts for extra accuracy)"
+    ),
+    /// keep this in sync with the event filter names in librustc_data_structures/profiling.rs
+    self_profile_events: Option<Vec<String>> = (None, parse_opt_comma_list, [UNTRACKED],
+        "specify the events recorded by the self profiler;
+        for example: `-Z self-profile-events=default,query-keys`
+        all options: none, all, default, generic-activity, query-provider, query-cache-hit
+                     query-blocked, incr-cache-load, incr-result-hashing, query-keys, function-args, args, llvm, artifact-sizes"),
+    share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "make the current crate share its generic instantiations"),
+    shell_argfiles: bool = (false, parse_bool, [UNTRACKED],
+        "allow argument files to be specified with POSIX \"shell-style\" argument quoting"),
+    simulate_remapped_rust_src_base: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "simulate the effect of remap-debuginfo = true at bootstrapping by remapping path \
+        to rust's source base directory. only meant for testing purposes"),
+    small_data_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "Set the threshold for objects to be stored in a \"small data\" section"),
+    span_debug: bool = (false, parse_bool, [UNTRACKED],
+        "forward proc_macro::Span's `Debug` impl to `Span`"),
+    /// o/w tests have closure@path
+    span_free_formats: bool = (false, parse_bool, [UNTRACKED],
+        "exclude spans when debug-printing compiler state (default: no)"),
+    split_dwarf_inlining: bool = (false, parse_bool, [TRACKED],
+        "provide minimal debug info in the object/executable to facilitate online \
+         symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF"),
+    split_dwarf_kind: SplitDwarfKind = (SplitDwarfKind::Split, parse_split_dwarf_kind, [TRACKED],
+        "split dwarf variant (only if -Csplit-debuginfo is enabled and on relevant platform)
+        (default: `split`)
+
+        `split`: sections which do not require relocation are written into a DWARF object (`.dwo`)
+                 file which is ignored by the linker
+        `single`: sections which do not require relocation are written into object file but ignored
+                  by the linker"),
+    split_dwarf_out_dir : Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "location for writing split DWARF objects (`.dwo`) if enabled"),
+    split_lto_unit: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable LTO unit splitting (default: no)"),
+    src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
+        "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")]
+    stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED],
+        "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"),
+    staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED],
+        "allow staticlibs to have rust dylib dependencies"),
+    staticlib_prefer_dynamic: bool = (false, parse_bool, [TRACKED],
+        "prefer dynamic linking to static linking for staticlibs (default: no)"),
+    strict_init_checks: bool = (false, parse_bool, [TRACKED],
+        "control if mem::uninitialized and mem::zeroed panic on more UB"),
+    #[rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field")]
+    teach: bool = (false, parse_bool, [TRACKED],
+        "show extended diagnostic help (default: no)"),
+    temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "the directory the intermediate files are written to"),
+    terminal_urls: TerminalUrl = (TerminalUrl::No, parse_terminal_url, [UNTRACKED],
+        "use the OSC 8 hyperlink terminal specification to print hyperlinks in the compiler output"),
+    #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")]
+    thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable ThinLTO when possible"),
+    /// We default to 1 here since we want to behave like
+    /// a sequential compiler for now. This'll likely be adjusted
+    /// in the future. Note that -Zthreads=0 is the way to get
+    /// the num_cpus behavior.
+    #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")]
+    threads: usize = (1, parse_threads, [UNTRACKED],
+        "use a thread pool with N threads"),
+    time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
+        "measure time of each LLVM pass (default: no)"),
+    time_passes: bool = (false, parse_bool, [UNTRACKED],
+        "measure time of each rustc pass (default: no)"),
+    time_passes_format: TimePassesFormat = (TimePassesFormat::Text, parse_time_passes_format, [UNTRACKED],
+        "the format to use for -Z time-passes (`text` (default) or `json`)"),
+    tiny_const_eval_limit: bool = (false, parse_bool, [TRACKED],
+        "sets a tiny, non-configurable limit for const eval; useful for compiler tests"),
+    #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")]
+    tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED],
+        "choose the TLS model to use (`rustc --print tls-models` for details)"),
+    trace_macros: bool = (false, parse_bool, [UNTRACKED],
+        "for every macro invocation, print its name and arguments (default: no)"),
+    track_diagnostics: bool = (false, parse_bool, [UNTRACKED],
+        "tracks where in rustc a diagnostic was emitted"),
+    translate_remapped_path_to_local_path: bool = (true, parse_bool, [TRACKED],
+        "translate remapped paths into local paths when possible (default: yes)"),
+    trap_unreachable: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "generate trap instructions for unreachable intrinsics (default: use target setting, usually yes)"),
+    treat_err_as_bug: Option<NonZero<usize>> = (None, parse_treat_err_as_bug, [TRACKED],
+        "treat the `val`th error that occurs as bug (default if not specified: 0 - don't treat errors as bugs. \
+        default if specified without a value: 1 - treat the first error as bug)"),
+    trim_diagnostic_paths: bool = (true, parse_bool, [UNTRACKED],
+        "in diagnostics, use heuristics to shorten paths referring to items"),
+    tune_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
+        "select processor to schedule for (`rustc --print target-cpus` for details)"),
+    #[rustc_lint_opt_deny_field_access("use `TyCtxt::use_typing_mode_borrowck` instead of this field")]
+    typing_mode_borrowck: bool = (false, parse_bool, [TRACKED],
+        "enable `TypingMode::Borrowck`, changing the way opaque types are handled during MIR borrowck"),
+    #[rustc_lint_opt_deny_field_access("use `Session::ub_checks` instead of this field")]
+    ub_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "emit runtime checks for Undefined Behavior (default: -Cdebug-assertions)"),
+    ui_testing: bool = (false, parse_bool, [UNTRACKED],
+        "emit compiler diagnostics in a form suitable for UI testing (default: no)"),
+    uninit_const_chunk_threshold: usize = (16, parse_number, [TRACKED],
+        "allow generating const initializers with mixed init/uninit chunks, \
+        and set the maximum number of chunks for which this is allowed (default: 16)"),
+    unleash_the_miri_inside_of_you: bool = (false, parse_bool, [TRACKED],
+        "take the brakes off const evaluation. NOTE: this is unsound (default: no)"),
+    unpretty: Option<String> = (None, parse_unpretty, [UNTRACKED],
+        "present the input source, unstable (and less-pretty) variants;
+        `normal`, `identified`,
+        `expanded`, `expanded,identified`,
+        `expanded,hygiene` (with internal representations),
+        `ast-tree` (raw AST before expansion),
+        `ast-tree,expanded` (raw AST after expansion),
+        `hir` (the HIR), `hir,identified`,
+        `hir,typed` (HIR with types for each node),
+        `hir-tree` (dump the raw HIR),
+        `thir-tree`, `thir-flat`,
+        `mir` (the MIR), or `mir-cfg` (graphviz formatted MIR)"),
+    unsound_mir_opts: bool = (false, parse_bool, [TRACKED],
+        "enable unsound and buggy MIR optimizations (default: no)"),
+    /// This name is kind of confusing: Most unstable options enable something themselves, while
+    /// this just allows "normal" options to be feature-gated.
+    ///
+    /// The main check for `-Zunstable-options` takes place separately from the
+    /// usual parsing of `-Z` options (see [`crate::config::nightly_options`]),
+    /// so this boolean value is mostly used for enabling unstable _values_ of
+    /// stable options. That separate check doesn't handle boolean values, so
+    /// to avoid an inconsistent state we also forbid them here.
+    #[rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field")]
+    unstable_options: bool = (false, parse_no_value, [UNTRACKED],
+        "adds unstable command line options to rustc interface (default: no)"),
+    use_ctors_section: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "use legacy .ctors section for initializers rather than .init_array"),
+    use_sync_unwind: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "Generate sync unwind tables instead of async unwind tables (default: no)"),
+    validate_mir: bool = (false, parse_bool, [UNTRACKED],
+        "validate MIR after each transformation"),
+    verbose_asm: bool = (false, parse_bool, [TRACKED],
+        "add descriptive comments from LLVM to the assembly (may change behavior) (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::verbose_internals` instead of this field")]
+    verbose_internals: bool = (false, parse_bool, [TRACKED_NO_CRATE_HASH],
+        "in general, enable more debug printouts (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field")]
+    verify_llvm_ir: bool = (false, parse_bool, [TRACKED],
+        "verify LLVM IR (default: no)"),
+    virtual_function_elimination: bool = (false, parse_bool, [TRACKED],
+        "enables dead virtual function elimination optimization. \
+        Requires `-Clto[=[fat,yes]]`"),
+    wasi_exec_model: Option<WasiExecModel> = (None, parse_wasi_exec_model, [TRACKED],
+        "whether to build a wasi command or reactor"),
+    // This option only still exists to provide a more gradual transition path for people who need
+    // the spec-complaint C ABI to be used.
+    // FIXME remove this after a couple releases
+    wasm_c_abi: () = ((), parse_wasm_c_abi, [TRACKED],
+        "use spec-compliant C ABI for `wasm32-unknown-unknown` (deprecated, always enabled)"),
+    write_long_types_to_disk: bool = (true, parse_bool, [UNTRACKED],
+        "whether long type names should be written to files instead of being printed in errors"),
+    // tidy-alphabetical-end
+
+    // If you add a new option, please update:
+    // - compiler/rustc_interface/src/tests.rs
+    // - src/doc/unstable-book/src/compiler-flags
+}
diff --git a/src/tools/unstable-book-gen/Cargo.toml b/src/tools/unstable-book-gen/Cargo.toml
index 73e5a91bec70..12dd2eda3d9e 100644
--- a/src/tools/unstable-book-gen/Cargo.toml
+++ b/src/tools/unstable-book-gen/Cargo.toml
@@ -6,6 +6,8 @@ edition = "2021"
 
 [dependencies]
 tidy = { path = "../tidy" }
+proc-macro2 = { version = "1.0", features = ["span-locations"] }
+syn = { version = "2.0", features = ["full", "parsing"] }
 
 # not actually needed but required for now to unify the feature selection of
 # `num-traits` between this and `rustbook`
diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index 12b35a11c0d6..8985072cbd27 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -5,6 +5,9 @@
 use std::fs::{self, write};
 use std::path::Path;
 
+use proc_macro2::{Span, TokenStream, TokenTree};
+use syn::parse::{Parse, ParseStream};
+use syn::{Attribute, Ident, Item, LitStr, Token, parenthesized};
 use tidy::diagnostics::RunningCheck;
 use tidy::features::{
     Feature, Features, Status, collect_env_vars, collect_lang_features, collect_lib_features,
@@ -116,7 +119,7 @@ fn copy_recursive(from: &Path, to: &Path) {
 }
 
 fn collect_compiler_flags(compiler_path: &Path) -> Features {
-    let options_path = compiler_path.join("rustc_session/src/options.rs");
+    let options_path = compiler_path.join("rustc_session/src/options/unstable.rs");
     let options_rs = t!(fs::read_to_string(&options_path), options_path);
     parse_compiler_flags(&options_rs, &options_path)
 }
@@ -125,50 +128,103 @@ fn collect_compiler_flags(compiler_path: &Path) -> Features {
 const REQUIRED_FIELDS: usize = 4;
 const OPTIONAL_FIELDS: usize = 5;
 
-struct SourceBlock<'a> {
-    content: &'a str,
-    offset: usize,
+struct ParsedOptionEntry {
+    name: String,
+    line: usize,
+    description: String,
 }
 
-struct ParsedOptionEntry<'a> {
-    name: &'a str,
-    name_start: usize,
-    description: Option<String>,
-    next_idx: usize,
+struct UnstableOptionsInput {
+    struct_name: Ident,
+    entries: Vec<ParsedOptionEntry>,
+}
+
+impl Parse for ParsedOptionEntry {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let _attrs = input.call(Attribute::parse_outer)?;
+
+        let name: Ident = input.parse()?;
+        let line = name.span().start().line;
+        input.parse::<Token![:]>()?;
+        let _ty: syn::Type = input.parse()?;
+        input.parse::<Token![=]>()?;
+
+        let tuple_content;
+        parenthesized!(tuple_content in input);
+        let tuple_tokens: TokenStream = tuple_content.parse()?;
+        let tuple_fields = split_tuple_fields(tuple_tokens);
+
+        if !matches!(tuple_fields.len(), REQUIRED_FIELDS | OPTIONAL_FIELDS) {
+            return Err(syn::Error::new(
+                name.span(),
+                format!(
+                    "unexpected field count for option `{name}`: expected 4 or 5, found {}",
+                    tuple_fields.len()
+                ),
+            ));
+        }
+
+        if tuple_fields.len() == OPTIONAL_FIELDS
+            && !is_deprecated_marker_field(&tuple_fields[REQUIRED_FIELDS])
+        {
+            return Err(syn::Error::new(
+                name.span(),
+                format!(
+                    "unexpected trailing field in option `{name}`: expected `is_deprecated_and_do_nothing: ...`"
+                ),
+            ));
+        }
+
+        let description = parse_description_field(&tuple_fields[DESCRIPTION_FIELD], &name)?;
+        Ok(Self { name: name.to_string(), line, description })
+    }
+}
+
+impl Parse for UnstableOptionsInput {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let struct_name: Ident = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let _tmod_enum_name: Ident = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let _stat_name: Ident = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let _opt_module_name: Ident = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let _prefix: LitStr = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let _output_name: LitStr = input.parse()?;
+        input.parse::<Token![,]>()?;
+
+        let entries =
+            syn::punctuated::Punctuated::<ParsedOptionEntry, Token![,]>::parse_terminated(input)?
+                .into_iter()
+                .collect();
+
+        Ok(Self { struct_name, entries })
+    }
 }
 
 fn parse_compiler_flags(options_rs: &str, options_path: &Path) -> Features {
-    let options_block = find_options_block(options_rs, "UnstableOptions");
-    let alphabetical_section = find_tidy_alphabetical_section(options_block);
-    let section_line_offset = line_number(options_rs, alphabetical_section.offset) - 1;
+    let options_input = parse_unstable_options_macro(options_rs).unwrap_or_else(|error| {
+        panic!("failed to parse unstable options from `{}`: {error}", options_path.display())
+    });
 
     let mut features = Features::new();
-    let mut idx = 0;
-
-    while idx < alphabetical_section.content.len() {
-        skip_ws_comments_and_attrs(alphabetical_section.content, &mut idx);
-        if idx >= alphabetical_section.content.len() {
-            break;
-        }
-
-        let entry = parse_one_entry(alphabetical_section.content, idx);
-        idx = entry.next_idx;
-
+    for entry in options_input.entries {
         if entry.name == "help" {
             continue;
         }
 
         features.insert(
-            entry.name.to_owned(),
+            entry.name,
             Feature {
                 level: Status::Unstable,
                 since: None,
                 has_gate_test: false,
                 tracking_issue: None,
                 file: options_path.to_path_buf(),
-                line: section_line_offset
-                    + line_number(alphabetical_section.content, entry.name_start),
-                description: entry.description,
+                line: entry.line,
+                description: Some(entry.description),
             },
         );
     }
@@ -176,447 +232,72 @@ fn parse_compiler_flags(options_rs: &str, options_path: &Path) -> Features {
     features
 }
 
-fn parse_one_entry(source: &str, start_idx: usize) -> ParsedOptionEntry<'_> {
-    let name_start = start_idx;
-    let name_end =
-        parse_ident_end(source, name_start).expect("expected an option name in UnstableOptions");
-    let name = &source[name_start..name_end];
-    let mut idx = name_end;
+fn parse_unstable_options_macro(source: &str) -> syn::Result<UnstableOptionsInput> {
+    let ast = syn::parse_file(source)?;
 
-    skip_ws_comments(source, &mut idx);
-    expect_byte(source, idx, b':', &format!("expected `:` after option name `{name}`"));
-    idx += 1;
+    for item in ast.items {
+        let Item::Macro(item_macro) = item else {
+            continue;
+        };
 
-    idx =
-        find_char_outside_nested(source, idx, b'=').expect("expected `=` in UnstableOptions entry");
-    idx += 1;
-
-    skip_ws_comments(source, &mut idx);
-    expect_byte(source, idx, b'(', &format!("expected tuple payload for option `{name}`"));
-
-    let tuple_start = idx;
-    let tuple_end = find_matching_delimiter(source, tuple_start, b'(', b')')
-        .expect("UnstableOptions tuple should be balanced");
-    let next_idx = skip_past_entry_delimiter(source, tuple_end + 1, name);
-
-    let description = if name == "help" {
-        None
-    } else {
-        let fields = split_top_level_fields(&source[tuple_start + 1..tuple_end]);
-        validate_option_fields(&fields, name);
-        // The `options!` macro layout is `(init, parse, [dep_tracking...], desc, ...)`.
-        Some(parse_string_literal(
-            fields.get(DESCRIPTION_FIELD).expect("option description should be present"),
-        ))
-    };
-
-    ParsedOptionEntry { name, name_start, description, next_idx }
-}
-
-fn find_options_block<'a>(source: &'a str, struct_name: &str) -> SourceBlock<'a> {
-    let mut search_from = 0;
-
-    while let Some(relative_start) = source[search_from..].find("options!") {
-        let macro_start = search_from + relative_start;
-        let open_brace = source[macro_start..]
-            .find('{')
-            .map(|relative| macro_start + relative)
-            .expect("options! invocation should contain `{`");
-        let close_brace = find_matching_delimiter(source, open_brace, b'{', b'}')
-            .expect("options! invocation should have a matching `}`");
-        let block = &source[open_brace + 1..close_brace];
-
-        if block.trim_start().starts_with(struct_name) {
-            return SourceBlock { content: block, offset: open_brace + 1 };
-        }
-
-        search_from = close_brace + 1;
-    }
-
-    panic!("could not find `{struct_name}` options! block");
-}
-
-fn find_tidy_alphabetical_section(block: SourceBlock<'_>) -> SourceBlock<'_> {
-    let start_marker = "// tidy-alphabetical-start";
-    let end_marker = "// tidy-alphabetical-end";
-
-    let section_start = block
-        .content
-        .find(start_marker)
-        .map(|start| start + start_marker.len())
-        .expect("options! block should contain `// tidy-alphabetical-start`");
-    let section_end = block.content[section_start..]
-        .find(end_marker)
-        .map(|end| section_start + end)
-        .expect("options! block should contain `// tidy-alphabetical-end`");
-
-    SourceBlock {
-        content: &block.content[section_start..section_end],
-        offset: block.offset + section_start,
-    }
-}
-
-fn line_number(source: &str, offset: usize) -> usize {
-    source[..offset].bytes().filter(|&byte| byte == b'\n').count() + 1
-}
-
-fn expect_byte(source: &str, idx: usize, expected: u8, context: &str) {
-    assert_eq!(source.as_bytes().get(idx).copied(), Some(expected), "{context}");
-}
-
-fn skip_ws_comments_and_attrs(source: &str, idx: &mut usize) {
-    loop {
-        skip_ws_comments(source, idx);
-
-        if source[*idx..].starts_with("#[") {
-            let attr_start = *idx + 1;
-            let attr_end = find_matching_delimiter(source, attr_start, b'[', b']')
-                .expect("attribute should have matching `]`");
-            *idx = attr_end + 1;
+        if !item_macro.mac.path.is_ident("options") {
             continue;
         }
 
-        break;
+        let parsed = syn::parse2::<UnstableOptionsInput>(item_macro.mac.tokens)?;
+        if parsed.struct_name == "UnstableOptions" {
+            return Ok(parsed);
+        }
     }
+
+    Err(syn::Error::new(
+        Span::call_site(),
+        "could not find `options!` invocation for `UnstableOptions`",
+    ))
 }
 
-fn skip_ws_comments(source: &str, idx: &mut usize) {
-    loop {
-        while let Some(byte) = source.as_bytes().get(*idx) {
-            if byte.is_ascii_whitespace() {
-                *idx += 1;
-            } else {
-                break;
-            }
-        }
-
-        if source[*idx..].starts_with("//") {
-            *idx = source[*idx..].find('\n').map_or(source.len(), |end| *idx + end + 1);
-            continue;
-        }
-
-        if source[*idx..].starts_with("/*") {
-            *idx = skip_block_comment(source, *idx);
-            continue;
-        }
-
-        break;
-    }
+fn parse_description_field(field: &TokenStream, option_name: &Ident) -> syn::Result<String> {
+    let lit = syn::parse2::<LitStr>(field.clone()).map_err(|_| {
+        syn::Error::new_spanned(
+            field.clone(),
+            format!("expected description string literal in option `{option_name}`"),
+        )
+    })?;
+    Ok(lit.value())
 }
 
-fn skip_block_comment(source: &str, mut idx: usize) -> usize {
-    let mut depth = 1;
-    idx += 2;
-
-    while idx < source.len() {
-        match source.as_bytes().get(idx..idx + 2) {
-            Some(b"/*") => {
-                depth += 1;
-                idx += 2;
-            }
-            Some(b"*/") => {
-                depth -= 1;
-                idx += 2;
-                if depth == 0 {
-                    return idx;
-                }
-            }
-            _ => idx += 1,
-        }
-    }
-
-    panic!("unterminated block comment");
-}
-
-fn parse_ident_end(source: &str, start: usize) -> Option<usize> {
-    let bytes = source.as_bytes();
-    let first = *bytes.get(start)?;
-    if !(first == b'_' || first.is_ascii_alphabetic()) {
-        return None;
-    }
-
-    let mut idx = start + 1;
-    while let Some(byte) = bytes.get(idx) {
-        if *byte == b'_' || byte.is_ascii_alphanumeric() {
-            idx += 1;
-        } else {
-            break;
-        }
-    }
-
-    Some(idx)
-}
-
-fn find_char_outside_nested(source: &str, start: usize, needle: u8) -> Option<usize> {
-    let mut idx = start;
-    let mut paren_depth = 0;
-    let mut bracket_depth = 0;
-    let mut brace_depth = 0;
-
-    while idx < source.len() {
-        match source.as_bytes()[idx] {
-            b'/' if source[idx..].starts_with("//") => {
-                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
-            }
-            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
-            b'"' => idx = skip_string_literal(source, idx),
-            b'(' => {
-                paren_depth += 1;
-                idx += 1;
-            }
-            b')' => {
-                paren_depth -= 1;
-                idx += 1;
-            }
-            b'[' => {
-                bracket_depth += 1;
-                idx += 1;
-            }
-            b']' => {
-                bracket_depth -= 1;
-                idx += 1;
-            }
-            b'{' => {
-                brace_depth += 1;
-                idx += 1;
-            }
-            b'}' => {
-                brace_depth -= 1;
-                idx += 1;
-            }
-            byte if byte == needle
-                && paren_depth == 0
-                && bracket_depth == 0
-                && brace_depth == 0 =>
-            {
-                return Some(idx);
-            }
-            _ => idx += 1,
-        }
-    }
-
-    None
-}
-
-fn find_matching_delimiter(source: &str, start: usize, open: u8, close: u8) -> Option<usize> {
-    let mut idx = start;
-    let mut depth = 0;
-
-    while idx < source.len() {
-        match source.as_bytes()[idx] {
-            b'/' if source[idx..].starts_with("//") => {
-                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
-            }
-            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
-            b'"' => idx = skip_string_literal(source, idx),
-            byte if byte == open => {
-                depth += 1;
-                idx += 1;
-            }
-            byte if byte == close => {
-                depth -= 1;
-                if depth == 0 {
-                    return Some(idx);
-                }
-                idx += 1;
-            }
-            _ => idx += 1,
-        }
-    }
-
-    None
-}
-
-fn split_top_level_fields(source: &str) -> Vec<&str> {
+fn split_tuple_fields(tuple_tokens: TokenStream) -> Vec<TokenStream> {
     let mut fields = Vec::new();
-    let mut field_start = 0;
-    let mut idx = 0;
-    let mut paren_depth = 0;
-    let mut bracket_depth = 0;
-    let mut brace_depth = 0;
+    let mut current = TokenStream::new();
 
-    while idx < source.len() {
-        match source.as_bytes()[idx] {
-            b'/' if source[idx..].starts_with("//") => {
-                idx = source[idx..].find('\n').map_or(source.len(), |end| idx + end + 1);
+    for token in tuple_tokens {
+        if let TokenTree::Punct(punct) = &token {
+            if punct.as_char() == ',' {
+                fields.push(current);
+                current = TokenStream::new();
+                continue;
             }
-            b'/' if source[idx..].starts_with("/*") => idx = skip_block_comment(source, idx),
-            b'"' => idx = skip_string_literal(source, idx),
-            b'(' => {
-                paren_depth += 1;
-                idx += 1;
-            }
-            b')' => {
-                paren_depth -= 1;
-                idx += 1;
-            }
-            b'[' => {
-                bracket_depth += 1;
-                idx += 1;
-            }
-            b']' => {
-                bracket_depth -= 1;
-                idx += 1;
-            }
-            b'{' => {
-                brace_depth += 1;
-                idx += 1;
-            }
-            b'}' => {
-                brace_depth -= 1;
-                idx += 1;
-            }
-            b',' if paren_depth == 0 && bracket_depth == 0 && brace_depth == 0 => {
-                fields.push(source[field_start..idx].trim());
-                idx += 1;
-                field_start = idx;
-            }
-            _ => idx += 1,
         }
+        current.extend([token]);
+    }
+    fields.push(current);
+
+    while matches!(fields.last(), Some(field) if field.is_empty()) {
+        fields.pop();
     }
 
-    fields.push(source[field_start..].trim());
     fields
 }
 
-fn validate_option_fields(fields: &[&str], name: &str) {
-    assert!(
-        matches!(fields.len(), REQUIRED_FIELDS | OPTIONAL_FIELDS),
-        "unexpected field count for option `{name}`: expected 4 or 5 fields, found {}",
-        fields.len()
-    );
-    assert!(
-        fields[2].starts_with('[') && fields[2].ends_with(']'),
-        "expected dep-tracking field in option `{name}`, found `{}`",
-        fields[2]
-    );
-    assert!(
-        looks_like_string_literal(fields[DESCRIPTION_FIELD]),
-        "expected description string literal in option `{name}`, found `{}`",
-        fields[DESCRIPTION_FIELD]
-    );
-
-    if let Some(extra_field) = fields.get(REQUIRED_FIELDS) {
-        assert!(
-            extra_field.trim_start().starts_with("is_deprecated_and_do_nothing:"),
-            "unexpected trailing field in option `{name}`: `{extra_field}`",
-        );
-    }
-}
-
-fn looks_like_string_literal(field: &str) -> bool {
-    let field = field.trim();
-    (field.starts_with('"') && field.ends_with('"')) || parse_raw_string_literal(field).is_some()
-}
-
-fn skip_past_entry_delimiter(source: &str, start: usize, name: &str) -> usize {
-    let mut idx = start;
-    skip_ws_comments(source, &mut idx);
-
-    match source.as_bytes().get(idx).copied() {
-        Some(b',') => idx + 1,
-        None => idx,
-        Some(byte) => {
-            panic!("expected `,` after option entry `{name}`, found {:?}", char::from(byte))
-        }
-    }
-}
-
-fn skip_string_literal(source: &str, mut idx: usize) -> usize {
-    idx += 1;
-
-    while idx < source.len() {
-        match source.as_bytes()[idx] {
-            b'\\' => {
-                idx += 1;
-                if idx < source.len() {
-                    idx += 1;
-                }
-            }
-            b'"' => return idx + 1,
-            _ => idx += 1,
-        }
-    }
-
-    panic!("unterminated string literal");
-}
-
-fn parse_string_literal(literal: &str) -> String {
-    let literal = literal.trim();
-
-    if let Some(raw_literal) = parse_raw_string_literal(literal) {
-        return raw_literal;
-    }
-
-    let inner = literal
-        .strip_prefix('"')
-        .and_then(|value| value.strip_suffix('"'))
-        .expect("expected a string literal");
-    let mut output = String::new();
-    let mut chars = inner.chars().peekable();
-
-    while let Some(ch) = chars.next() {
-        if ch != '\\' {
-            output.push(ch);
-            continue;
-        }
-
-        let escaped = chars.next().expect("unterminated string escape");
-        match escaped {
-            '\n' => while chars.next_if(|ch| ch.is_whitespace()).is_some() {},
-            '\r' => {
-                let _ = chars.next_if_eq(&'\n');
-                while chars.next_if(|ch| ch.is_whitespace()).is_some() {}
-            }
-            '"' => output.push('"'),
-            '\'' => output.push('\''),
-            '\\' => output.push('\\'),
-            'n' => output.push('\n'),
-            'r' => output.push('\r'),
-            't' => output.push('\t'),
-            '0' => output.push('\0'),
-            'x' => {
-                let hi = chars.next().expect("missing first hex digit in escape");
-                let lo = chars.next().expect("missing second hex digit in escape");
-                let byte = u8::from_str_radix(&format!("{hi}{lo}"), 16)
-                    .expect("invalid hex escape in string literal");
-                output.push(char::from(byte));
-            }
-            'u' => {
-                assert_eq!(chars.next(), Some('{'), "expected `{{` after `\\u`");
-                let mut digits = String::new();
-                for ch in chars.by_ref() {
-                    if ch == '}' {
-                        break;
-                    }
-                    digits.push(ch);
-                }
-                let scalar =
-                    u32::from_str_radix(&digits, 16).expect("invalid unicode escape in string");
-                output.push(char::from_u32(scalar).expect("unicode escape should be valid"));
-            }
-            _ => panic!("unsupported escape in string literal"),
-        }
-    }
-
-    output
-}
-
-fn parse_raw_string_literal(literal: &str) -> Option<String> {
-    let rest = literal.strip_prefix('r')?;
-    let hashes = rest.bytes().take_while(|&byte| byte == b'#').count();
-    let quote_idx = 1 + hashes;
-
-    if literal.as_bytes().get(quote_idx) != Some(&b'"') {
-        return None;
-    }
-
-    let suffix = format!("\"{}", "#".repeat(hashes));
-    let content = literal[quote_idx + 1..]
-        .strip_suffix(&suffix)
-        .expect("raw string literal should have a matching terminator");
-
-    Some(content.to_owned())
+fn is_deprecated_marker_field(field: &TokenStream) -> bool {
+    let mut tokens = field.clone().into_iter();
+    let Some(TokenTree::Ident(name)) = tokens.next() else {
+        return false;
+    };
+    let Some(TokenTree::Punct(colon)) = tokens.next() else {
+        return false;
+    };
+    name == "is_deprecated_and_do_nothing" && colon.as_char() == ':'
 }
 
 fn main() {
diff --git a/src/tools/unstable-book-gen/src/tests.rs b/src/tools/unstable-book-gen/src/tests.rs
index 98008a45be62..9e57f032f737 100644
--- a/src/tools/unstable-book-gen/src/tests.rs
+++ b/src/tools/unstable-book-gen/src/tests.rs
@@ -1,83 +1,69 @@
 use std::path::{Path, PathBuf};
 
-use super::{parse_compiler_flags, parse_one_entry, skip_ws_comments_and_attrs};
+use super::parse_compiler_flags;
 
 #[test]
 fn parses_unstable_options_entries() {
-    let tidy_start = "// tidy-alphabetical-start";
-    let tidy_end = "// tidy-alphabetical-end";
-    let options_rs = format!(
-        "\n\
-        options! {{\n\
-        \x20   UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, \"Z\", \"unstable\",\n\
-        \n\
-        \x20   {tidy_start}\n\
-        \x20   #[rustc_lint_opt_deny_field_access(\"test attr\")]\n\
-        \x20   allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],\n\
-        \x20       \"only allow the listed language features to be enabled in code (comma separated)\"),\n\
-        \x20   dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],\n\
-        \x20       \"dump MIR state to file.\n\
-        \x20       `val` is used to select which passes and functions to dump.\"),\n\
-        \x20   join_lines: bool = (false, parse_bool, [TRACKED],\n\
-        \x20       \"join \\\n\
-        \x20        continued lines\"),\n\
-        \x20   help: bool = (false, parse_no_value, [UNTRACKED], \"Print unstable compiler options\"),\n\
-        \x20   {tidy_end}\n\
-        }}\n"
-    );
+    let options_rs = r#"options! {
+    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
 
-    let features = parse_compiler_flags(&options_rs, Path::new("options.rs"));
+    #[rustc_lint_opt_deny_field_access("test attr")]
+    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
+        "only allow the listed language features to be enabled in code (comma separated)"),
+    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "dump MIR state to file.\n\
+        `val` is used to select which passes and functions to dump."),
+    join_lines: bool = (false, parse_bool, [TRACKED],
+        "join \
+         continued lines"),
+    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
+}"#;
+
+    let features = parse_compiler_flags(options_rs, Path::new("options/unstable.rs"));
 
     assert!(features.contains_key("allow_features"));
     assert!(features.contains_key("dump_mir"));
     assert!(features.contains_key("join_lines"));
     assert!(!features.contains_key("help"));
 
-    assert_eq!(
-        features["dump_mir"].description.as_deref(),
-        Some(
-            "dump MIR state to file.\n        `val` is used to select which passes and functions to dump."
-        ),
+    assert!(
+        features["dump_mir"]
+            .description
+            .as_deref()
+            .expect("dump_mir description should exist")
+            .starts_with("dump MIR state to file.\n"),
     );
-    assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"),);
-    assert_eq!(features["allow_features"].file, PathBuf::from("options.rs"));
-    assert_eq!(features["allow_features"].line, 7);
+    assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"));
+    assert_eq!(
+        features["allow_features"].description.as_deref(),
+        Some("only allow the listed language features to be enabled in code (comma separated)"),
+    );
+    assert_eq!(features["allow_features"].file, PathBuf::from("options/unstable.rs"));
+    assert_eq!(features["allow_features"].line, 5);
 }
 
 #[test]
-fn parse_one_entry_skips_help_description_and_advances() {
-    let section = "\
-help: bool = (false, parse_no_value, [UNTRACKED], \"Print unstable compiler options\"),\n\
-join_lines: bool = (false, parse_bool, [TRACKED], \"join \\\n\
-    continued lines\"),\n";
+fn parser_accepts_optional_trailing_metadata() {
+    let options_rs = r##"options! {
+    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
 
-    let help_entry = parse_one_entry(section, 0);
-    assert_eq!(help_entry.name, "help");
-    assert!(help_entry.description.is_none());
+    deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], "deprecated flag",
+        is_deprecated_and_do_nothing: true),
+    raw_description: bool = (false, parse_no_value, [UNTRACKED], r#"raw "quoted" text"#),
+}"##;
 
-    let mut next_idx = help_entry.next_idx;
-    skip_ws_comments_and_attrs(section, &mut next_idx);
-    let next_entry = parse_one_entry(section, next_idx);
-
-    assert_eq!(next_entry.name, "join_lines");
-    assert_eq!(next_entry.description.as_deref(), Some("join continued lines"),);
-}
-
-#[test]
-fn parse_one_entry_accepts_optional_trailing_metadata() {
-    let entry = "\
-deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], \"deprecated flag\",\n\
-    is_deprecated_and_do_nothing: true),\n";
-
-    let parsed = parse_one_entry(entry, 0);
-    assert_eq!(parsed.name, "deprecated_flag");
-    assert_eq!(parsed.description.as_deref(), Some("deprecated flag"));
+    let features = parse_compiler_flags(options_rs, Path::new("options/unstable.rs"));
+    assert_eq!(features["deprecated_flag"].description.as_deref(), Some("deprecated flag"));
+    assert_eq!(
+        features["raw_description"].description.as_deref(),
+        Some("raw \"quoted\" text"),
+    );
 }
 
 #[test]
 fn parses_real_unstable_options_file() {
     let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options.rs");
+    let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options/unstable.rs");
     let options_rs = std::fs::read_to_string(&options_path).unwrap();
     let features = parse_compiler_flags(&options_rs, &options_path);
 

From deeb45a5debda9f607753d444bb8e3cd4c6b799e Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Sat, 21 Mar 2026 11:57:31 -0400
Subject: [PATCH 0748/1059] style: fix rustfmt

---
 src/tools/unstable-book-gen/src/tests.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/tools/unstable-book-gen/src/tests.rs b/src/tools/unstable-book-gen/src/tests.rs
index 9e57f032f737..000cfaebdac3 100644
--- a/src/tools/unstable-book-gen/src/tests.rs
+++ b/src/tools/unstable-book-gen/src/tests.rs
@@ -54,10 +54,7 @@ fn parser_accepts_optional_trailing_metadata() {
 
     let features = parse_compiler_flags(options_rs, Path::new("options/unstable.rs"));
     assert_eq!(features["deprecated_flag"].description.as_deref(), Some("deprecated flag"));
-    assert_eq!(
-        features["raw_description"].description.as_deref(),
-        Some("raw \"quoted\" text"),
-    );
+    assert_eq!(features["raw_description"].description.as_deref(), Some("raw \"quoted\" text"),);
 }
 
 #[test]

From b31dc4ab495c0297c4f09324094e9c8e62d52977 Mon Sep 17 00:00:00 2001
From: Usman Akinyemi <usmanakinyemi202@gmail.com>
Date: Sat, 21 Mar 2026 21:45:57 +0530
Subject: [PATCH 0749/1059] diagnostics: avoid ICE for undeclared generic
 parameter in impl

Avoid an ICE for:

    struct A;
    impl A<B> {}

The compiler no longer panics and can proceed to emit existing diagnostics.

Adds `tests/ui/missing/undeclared-generic-parameter.rs`.

Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>
---
 .../rustc_resolve/src/late/diagnostics.rs     |  2 +-
 .../missing/undeclared-generic-parameter.rs   |  5 +++
 .../undeclared-generic-parameter.stderr       | 36 +++++++++++++++++++
 3 files changed, 42 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/missing/undeclared-generic-parameter.rs
 create mode 100644 tests/ui/missing/undeclared-generic-parameter.stderr

diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index e24389e0d74d..713d6eb74bcb 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -3381,7 +3381,7 @@ pub(crate) fn detect_and_suggest_const_parameter_error(
             && def_id.is_local()
             && let Some(local_def_id) = def_id.as_local()
             && let Some(struct_generics) = self.r.struct_generics.get(&local_def_id)
-            && let target_param = &struct_generics.params[idx]
+            && let Some(target_param) = &struct_generics.params.get(idx)
             && let GenericParamKind::Const { ty, .. } = &target_param.kind
             && let TyKind::Path(_, path) = &ty.kind
         {
diff --git a/tests/ui/missing/undeclared-generic-parameter.rs b/tests/ui/missing/undeclared-generic-parameter.rs
new file mode 100644
index 000000000000..eebae215c881
--- /dev/null
+++ b/tests/ui/missing/undeclared-generic-parameter.rs
@@ -0,0 +1,5 @@
+struct A;
+impl A<B> {}
+//~^ ERROR cannot find type `B` in this scope
+//~| ERROR struct takes 0 generic arguments but 1 generic argument was supplied
+fn main() {}
diff --git a/tests/ui/missing/undeclared-generic-parameter.stderr b/tests/ui/missing/undeclared-generic-parameter.stderr
new file mode 100644
index 000000000000..101a5790ed4e
--- /dev/null
+++ b/tests/ui/missing/undeclared-generic-parameter.stderr
@@ -0,0 +1,36 @@
+error[E0425]: cannot find type `B` in this scope
+  --> $DIR/undeclared-generic-parameter.rs:2:8
+   |
+LL | struct A;
+   | --------- similarly named struct `A` defined here
+LL | impl A<B> {}
+   |        ^
+   |
+help: a struct with a similar name exists
+   |
+LL - impl A<B> {}
+LL + impl A<A> {}
+   |
+help: you might be missing a type parameter
+   |
+LL | impl<B> A<B> {}
+   |     +++
+
+error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/undeclared-generic-parameter.rs:2:6
+   |
+LL | impl A<B> {}
+   |      ^--- help: remove the unnecessary generics
+   |      |
+   |      expected 0 generic arguments
+   |
+note: struct defined here, with 0 generic parameters
+  --> $DIR/undeclared-generic-parameter.rs:1:8
+   |
+LL | struct A;
+   |        ^
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0107, E0425.
+For more information about an error, try `rustc --explain E0107`.

From b25a2d573ac9e7594b5235c81c9f4bc002c7727f Mon Sep 17 00:00:00 2001
From: Mahdi Ali-Raihan <asder8215@gmail.com>
Date: Sat, 21 Mar 2026 13:43:22 -0400
Subject: [PATCH 0750/1059] Prevent no_threads RwLock's write() impl from
 setting mode to -1 when it is locked for reading

---
 library/std/src/sys/sync/rwlock/no_threads.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/sync/rwlock/no_threads.rs b/library/std/src/sys/sync/rwlock/no_threads.rs
index 573d0d602dbd..6b919bde80bb 100644
--- a/library/std/src/sys/sync/rwlock/no_threads.rs
+++ b/library/std/src/sys/sync/rwlock/no_threads.rs
@@ -37,8 +37,10 @@ pub fn try_read(&self) -> bool {
 
     #[inline]
     pub fn write(&self) {
-        if self.mode.replace(-1) != 0 {
-            rtabort!("rwlock locked for reading")
+        if self.mode.get() == 0 {
+            self.mode.set(-1);
+        } else {
+            rtabort!("rwlock locked for reading");
         }
     }
 

From e0aed9c5f665ff7ee4881e8db68382b454fb994a Mon Sep 17 00:00:00 2001
From: Romain Perier <romain.perier@gmail.com>
Date: Sat, 21 Mar 2026 19:18:20 +0100
Subject: [PATCH 0751/1059] Point to the tracking issue for
 #[diagnostic::on_move]

Now that the tracking issue has been opened, point to it.
---
 compiler/rustc_feature/src/unstable.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index e8ca20d7f5f4..a559211e5d46 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -473,7 +473,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
     (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
     /// Allows giving on-move borrowck custom diagnostic messages for a type
-    (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(150935)),
+    (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(154181)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.

From 8d072616a5d0c484e9761b0958ece68e8d235fe3 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 16 Mar 2024 15:56:18 -0400
Subject: [PATCH 0752/1059] Add APIs for dealing with titlecase

- `char::is_cased`
- `char::is_titlecase`
- `char::case`
- `char::to_titlecase`
---
 library/alloc/src/lib.rs                      |   1 +
 library/core/src/char/methods.rs              | 240 ++++++++++++++++--
 library/core/src/char/mod.rs                  |  87 +++++--
 library/core/src/unicode/mod.rs               |   4 +-
 library/core/src/unicode/unicode_data.rs      |  82 +++++-
 library/coretests/tests/char.rs               |  57 ++++-
 library/coretests/tests/lib.rs                |   1 +
 library/coretests/tests/unicode.rs            |  34 ++-
 library/coretests/tests/unicode/test_data.rs  |  78 ++++++
 .../src/case_mapping.rs                       |  45 +++-
 src/tools/unicode-table-generator/src/main.rs |  58 +++--
 11 files changed, 583 insertions(+), 104 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 7ac9cdc3833d..bcd9e092a310 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -148,6 +148,7 @@
 #![feature(slice_range)]
 #![feature(std_internals)]
 #![feature(temporary_niche_types)]
+#![feature(titlecase)]
 #![feature(transmutability)]
 #![feature(trivial_clone)]
 #![feature(trusted_fused)]
diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index 284a3eeb75df..e9c3b040dc50 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -777,12 +777,76 @@ pub const fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] {
     #[inline]
     pub fn is_alphabetic(self) -> bool {
         match self {
-            'A'..='Z' | 'a'..='z' => true,
+            'a'..='z' | 'A'..='Z' => true,
             '\0'..='\u{A9}' => false,
             _ => unicode::Alphabetic(self),
         }
     }
 
+    /// Returns `true` if this `char` has the `Cased` property.
+    /// A character is cased if and only if it is uppercase, lowercase, or titlecase.
+    ///
+    /// `Cased` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
+    /// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
+    ///
+    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
+    /// [ucd]: https://www.unicode.org/reports/tr44/
+    /// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// assert!('A'.is_cased());
+    /// assert!('a'.is_cased());
+    /// assert!(!'京'.is_cased());
+    /// ```
+    #[must_use]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[inline]
+    pub fn is_cased(self) -> bool {
+        match self {
+            'a'..='z' | 'A'..='Z' => true,
+            '\0'..='\u{A9}' => false,
+            _ => unicode::Cased(self),
+        }
+    }
+
+    /// Returns the case of this character:
+    /// [`Some(CharCase::Upper)`][`CharCase::Upper`] if [`self.is_uppercase()`][`char::is_uppercase`],
+    /// [`Some(CharCase::Lower)`][`CharCase::Lower`] if [`self.is_lowercase()`][`char::is_lowercase`],
+    /// [`Some(CharCase::Title)`][`CharCase::Title`] if [`self.is_titlecase()`][`char::is_titlecase`], and
+    /// `None` if [`!self.is_cased()`][`char::is_cased`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// use core::char::CharCase;
+    /// assert_eq!('a'.case(), Some(CharCase::Lower));
+    /// assert_eq!('δ'.case(), Some(CharCase::Lower));
+    /// assert_eq!('A'.case(), Some(CharCase::Upper));
+    /// assert_eq!('Δ'.case(), Some(CharCase::Upper));
+    /// assert_eq!('Dž'.case(), Some(CharCase::Title));
+    /// assert_eq!('中'.case(), None);
+    /// ```
+    #[must_use]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[inline]
+    pub fn case(self) -> Option<CharCase> {
+        match self {
+            'a'..='z' => Some(CharCase::Lower),
+            'A'..='Z' => Some(CharCase::Upper),
+            '\0'..='\u{A9}' => None,
+            _ if !unicode::Cased(self) => None,
+            _ if unicode::Lowercase(self) => Some(CharCase::Lower),
+            _ if unicode::Uppercase(self) => Some(CharCase::Upper),
+            _ => Some(CharCase::Title),
+        }
+    }
+
     /// Returns `true` if this `char` has the `Lowercase` property.
     ///
     /// `Lowercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
@@ -825,6 +889,40 @@ pub const fn is_lowercase(self) -> bool {
         }
     }
 
+    /// Returns `true` if this `char` has the general category for titlecase letters.
+    /// Conceptually, these characters consist of an uppercase portion followed by a lowercase portion.
+    ///
+    /// Titlecase letters (code points with the general category of `Lt`) are described in Chapter 4
+    /// (Character Properties) of the [Unicode Standard] and specified in the [Unicode Character
+    /// Database][ucd] [`UnicodeData.txt`].
+    ///
+    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
+    /// [ucd]: https://www.unicode.org/reports/tr44/
+    /// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// assert!('Dž'.is_titlecase());
+    /// assert!('ῼ'.is_titlecase());
+    /// assert!(!'D'.is_titlecase());
+    /// assert!(!'z'.is_titlecase());
+    /// assert!(!'中'.is_titlecase());
+    /// assert!(!' '.is_titlecase());
+    /// ```
+    #[must_use]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[inline]
+    pub fn is_titlecase(self) -> bool {
+        match self {
+            '\0'..='\u{01C4}' => false,
+            _ => self.is_cased() && !self.is_lowercase() && !self.is_uppercase(),
+        }
+    }
+
     /// Returns `true` if this `char` has the `Uppercase` property.
     ///
     /// `Uppercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
@@ -925,7 +1023,7 @@ pub const fn is_whitespace(self) -> bool {
     #[inline]
     pub fn is_alphanumeric(self) -> bool {
         match self {
-            '0'..='9' | 'A'..='Z' | 'a'..='z' => true,
+            'a'..='z' | 'A'..='Z' | '0'..='9' => true,
             '\0'..='\u{A9}' => false,
             _ => unicode::Alphabetic(self) || unicode::N(self),
         }
@@ -976,26 +1074,6 @@ pub(crate) fn is_grapheme_extended(self) -> bool {
         self > '\u{02FF}' && unicode::Grapheme_Extend(self)
     }
 
-    /// Returns `true` if this `char` has the `Cased` property.
-    ///
-    /// `Cased` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
-    /// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
-    ///
-    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
-    /// [ucd]: https://www.unicode.org/reports/tr44/
-    /// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
-    #[must_use]
-    #[inline]
-    #[doc(hidden)]
-    #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
-    pub fn is_cased(self) -> bool {
-        match self {
-            'A'..='Z' | 'a'..='z' => true,
-            '\0'..='\u{A9}' => false,
-            _ => unicode::Cased(self),
-        }
-    }
-
     /// Returns `true` if this `char` has the `Case_Ignorable` property.
     ///
     /// `Case_Ignorable` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
@@ -1119,7 +1197,7 @@ pub fn is_numeric(self) -> bool {
     /// // convert into themselves.
     /// assert_eq!('山'.to_lowercase().to_string(), "山");
     /// ```
-    #[must_use = "this returns the lowercase character as a new iterator, \
+    #[must_use = "this returns the lowercased character as a new iterator, \
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -1127,9 +1205,115 @@ pub fn to_lowercase(self) -> ToLowercase {
         ToLowercase(CaseMappingIter::new(conversions::to_lower(self)))
     }
 
+    /// Returns an iterator that yields the titlecase mapping of this `char` as one or more
+    /// `char`s.
+    ///
+    /// This is usually, but not always, equivalent to the uppercase mapping
+    /// returned by [`Self::to_uppercase`]. Prefer this method when seeking to capitalize
+    /// Only The First Letter of a word, but use [`Self::to_uppercase`] for ALL CAPS.
+    ///
+    /// If this `char` does not have an titlecase mapping, the iterator yields the same `char`.
+    ///
+    /// If this `char` has a one-to-one titlecase mapping given by the [Unicode Character
+    /// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`.
+    ///
+    /// [ucd]: https://www.unicode.org/reports/tr44/
+    /// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
+    ///
+    /// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
+    /// the `char`(s) given by [`SpecialCasing.txt`].
+    ///
+    /// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
+    ///
+    /// This operation performs an unconditional mapping without tailoring. That is, the conversion
+    /// is independent of context and language.
+    ///
+    /// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
+    /// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
+    ///
+    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
+    ///
+    /// # Examples
+    ///
+    /// As an iterator:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// for c in 'ß'.to_titlecase() {
+    ///     print!("{c}");
+    /// }
+    /// println!();
+    /// ```
+    ///
+    /// Using `println!` directly:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// println!("{}", 'ß'.to_titlecase());
+    /// ```
+    ///
+    /// Both are equivalent to:
+    ///
+    /// ```
+    /// println!("Ss");
+    /// ```
+    ///
+    /// Using [`to_string`](../std/string/trait.ToString.html#tymethod.to_string):
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// assert_eq!('c'.to_titlecase().to_string(), "C");
+    /// assert_eq!('dž'.to_titlecase().to_string(), "Dž");
+    /// assert_eq!('ῼ'.to_titlecase().to_string(), "ῼ");
+    ///
+    /// // Sometimes the result is more than one character:
+    /// assert_eq!('ß'.to_titlecase().to_string(), "Ss");
+    ///
+    /// // Characters that do not have separate cased forms
+    /// // convert into themselves.
+    /// assert_eq!('山'.to_titlecase().to_string(), "山");
+    /// ```
+    ///
+    /// # Note on locale
+    ///
+    /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
+    ///
+    /// * 'Dotless': I / ı, sometimes written ï
+    /// * 'Dotted': İ / i
+    ///
+    /// Note that the lowercase dotted 'i' is the same as the Latin. Therefore:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// let upper_i = 'i'.to_titlecase().to_string();
+    /// ```
+    ///
+    /// The value of `upper_i` here relies on the language of the text: if we're
+    /// in `en-US`, it should be `"I"`, but if we're in `tr-TR` or `az-AZ`, it should
+    /// be `"İ"`. `to_titlecase()` does not take this into account, and so:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// let upper_i = 'i'.to_titlecase().to_string();
+    ///
+    /// assert_eq!(upper_i, "I");
+    /// ```
+    ///
+    /// holds across languages.
+    #[must_use = "this returns the titlecased character as a new iterator, \
+                  without modifying the original"]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[inline]
+    pub fn to_titlecase(self) -> ToTitlecase {
+        ToTitlecase(CaseMappingIter::new(conversions::to_title(self)))
+    }
+
     /// Returns an iterator that yields the uppercase mapping of this `char` as one or more
     /// `char`s.
     ///
+    /// Prefer this method when converting a word into ALL CAPS, but consider [`Self::to_titlecase`]
+    /// instead if you seek to capitalize Only The First Letter.
+    ///
     /// If this `char` does not have an uppercase mapping, the iterator yields the same `char`.
     ///
     /// If this `char` has a one-to-one uppercase mapping given by the [Unicode Character
@@ -1179,9 +1363,11 @@ pub fn to_lowercase(self) -> ToLowercase {
     ///
     /// ```
     /// assert_eq!('c'.to_uppercase().to_string(), "C");
+    /// assert_eq!('dž'.to_uppercase().to_string(), "DŽ");
     ///
     /// // Sometimes the result is more than one character:
     /// assert_eq!('ſt'.to_uppercase().to_string(), "ST");
+    /// assert_eq!('ῼ'.to_uppercase().to_string(), "ΩΙ");
     ///
     /// // Characters that do not have both uppercase and lowercase
     /// // convert into themselves.
@@ -1190,7 +1376,7 @@ pub fn to_lowercase(self) -> ToLowercase {
     ///
     /// # Note on locale
     ///
-    /// In Turkish, the equivalent of 'i' in Latin has five forms instead of two:
+    /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
     ///
     /// * 'Dotless': I / ı, sometimes written ï
     /// * 'Dotted': İ / i
@@ -1202,7 +1388,7 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// ```
     ///
     /// The value of `upper_i` here relies on the language of the text: if we're
-    /// in `en-US`, it should be `"I"`, but if we're in `tr_TR`, it should
+    /// in `en-US`, it should be `"I"`, but if we're in `tr-TR` or `az-AZ`, it should
     /// be `"İ"`. `to_uppercase()` does not take this into account, and so:
     ///
     /// ```
@@ -1212,7 +1398,7 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// ```
     ///
     /// holds across languages.
-    #[must_use = "this returns the uppercase character as a new iterator, \
+    #[must_use = "this returns the uppercased character as a new iterator, \
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -1455,7 +1641,7 @@ pub const fn make_ascii_lowercase(&mut self) {
     #[rustc_const_stable(feature = "const_ascii_ctype_on_intrinsics", since = "1.47.0")]
     #[inline]
     pub const fn is_ascii_alphabetic(&self) -> bool {
-        matches!(*self, 'A'..='Z' | 'a'..='z')
+        matches!(*self, 'a'..='z' | 'A'..='Z')
     }
 
     /// Checks if the value is an ASCII uppercase character:
diff --git a/library/core/src/char/mod.rs b/library/core/src/char/mod.rs
index 82a3f6f916be..3231c4193064 100644
--- a/library/core/src/char/mod.rs
+++ b/library/core/src/char/mod.rs
@@ -363,13 +363,21 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 }
 
 macro_rules! casemappingiter_impls {
-    ($(#[$attr:meta])* $ITER_NAME:ident) => {
+    (
+        #[$stab:meta]
+        #[$dendstab:meta]
+        #[$fusedstab:meta]
+        #[$exactstab:meta]
+        #[$displaystab:meta]
+        $(#[$attr:meta])*
+        $ITER_NAME:ident
+    ) => {
         $(#[$attr])*
-        #[stable(feature = "rust1", since = "1.0.0")]
+        #[$stab]
         #[derive(Debug, Clone)]
         pub struct $ITER_NAME(CaseMappingIter);
 
-        #[stable(feature = "rust1", since = "1.0.0")]
+        #[$stab]
         impl Iterator for $ITER_NAME {
             type Item = char;
             fn next(&mut self) -> Option<char> {
@@ -405,7 +413,7 @@ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
             }
         }
 
-        #[stable(feature = "case_mapping_double_ended", since = "1.59.0")]
+        #[$dendstab]
         impl DoubleEndedIterator for $ITER_NAME {
             fn next_back(&mut self) -> Option<char> {
                 self.0.next_back()
@@ -423,10 +431,10 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
             }
         }
 
-        #[stable(feature = "fused", since = "1.26.0")]
+        #[$fusedstab]
         impl FusedIterator for $ITER_NAME {}
 
-        #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
+        #[$exactstab]
         impl ExactSizeIterator for $ITER_NAME {
             fn len(&self) -> usize {
                 self.0.len()
@@ -453,7 +461,7 @@ unsafe impl TrustedRandomAccessNoCoerce for $ITER_NAME {
         #[unstable(feature = "std_internals", issue = "none")]
         unsafe impl TrustedRandomAccess for $ITER_NAME {}
 
-        #[stable(feature = "char_struct_display", since = "1.16.0")]
+        #[$displaystab]
         impl fmt::Display for $ITER_NAME {
             #[inline]
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -464,16 +472,11 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 }
 
 casemappingiter_impls! {
-    /// Returns an iterator that yields the lowercase equivalent of a `char`.
-    ///
-    /// This `struct` is created by the [`to_lowercase`] method on [`char`]. See
-    /// its documentation for more.
-    ///
-    /// [`to_lowercase`]: char::to_lowercase
-    ToLowercase
-}
-
-casemappingiter_impls! {
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[stable(feature = "case_mapping_double_ended", since = "1.59.0")]
+    #[stable(feature = "fused", since = "1.26.0")]
+    #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
+    #[stable(feature = "char_struct_display", since = "1.16.0")]
     /// Returns an iterator that yields the uppercase equivalent of a `char`.
     ///
     /// This `struct` is created by the [`to_uppercase`] method on [`char`]. See
@@ -483,6 +486,36 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     ToUppercase
 }
 
+casemappingiter_impls! {
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    #[unstable(feature = "titlecase", issue = "153892")]
+    /// Returns an iterator that yields the titlecase equivalent of a `char`.
+    ///
+    /// This `struct` is created by the [`to_titlecase`] method on [`char`]. See
+    /// its documentation for more.
+    ///
+    /// [`to_titlecase`]: char::to_titlecase
+    ToTitlecase
+}
+
+casemappingiter_impls! {
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[stable(feature = "case_mapping_double_ended", since = "1.59.0")]
+    #[stable(feature = "fused", since = "1.26.0")]
+    #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
+    #[stable(feature = "char_struct_display", since = "1.16.0")]
+    /// Returns an iterator that yields the lowercase equivalent of a `char`.
+    ///
+    /// This `struct` is created by the [`to_lowercase`] method on [`char`]. See
+    /// its documentation for more.
+    ///
+    /// [`to_lowercase`]: char::to_lowercase
+    ToLowercase
+}
+
 #[derive(Debug, Clone)]
 struct CaseMappingIter(core::array::IntoIter<char, 3>);
 
@@ -603,3 +636,23 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 
 #[stable(feature = "u8_from_char", since = "1.59.0")]
 impl Error for TryFromCharError {}
+
+/// The case of a cased character,
+/// as returned by [`char::case`].
+///
+/// Titlecase characters conceptually are composed of an uppercase portion
+/// followed by a lowercase portion.
+/// The variant discriminants represent this:
+/// the most significant bit represents whether the case
+/// conceptually starts as uppercase, while the least significant bit
+/// represents whether it conceptually ends as uppercase.
+#[unstable(feature = "titlecase", issue = "153892")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum CharCase {
+    /// Lowercase. Corresponds to the `Lowercase` Unicode property.
+    Lower = 0b00,
+    /// Titlecase. Corresponds to the `Titlecase_Letter` Unicode general category.
+    Title = 0b10,
+    /// Uppercase. Corresponds to the `Uppercase` Unicode property.
+    Upper = 0b11,
+}
diff --git a/library/core/src/unicode/mod.rs b/library/core/src/unicode/mod.rs
index 4c220e3ea012..22a1166fdf16 100644
--- a/library/core/src/unicode/mod.rs
+++ b/library/core/src/unicode/mod.rs
@@ -4,12 +4,12 @@
 
 // for use in alloc, not re-exported in std.
 #[rustfmt::skip]
-pub use unicode_data::case_ignorable::lookup as Case_Ignorable;
-pub use unicode_data::cased::lookup as Cased;
 pub use unicode_data::conversions;
 
 #[rustfmt::skip]
 pub(crate) use unicode_data::alphabetic::lookup as Alphabetic;
+pub(crate) use unicode_data::case_ignorable::lookup as Case_Ignorable;
+pub(crate) use unicode_data::cased::lookup as Cased;
 pub(crate) use unicode_data::grapheme_extend::lookup as Grapheme_Extend;
 pub(crate) use unicode_data::lowercase::lookup as Lowercase;
 pub(crate) use unicode_data::n::lookup as N;
diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index dd3712669e50..f602cd5c5b6b 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -9,7 +9,8 @@
 // White_Space     :   256 bytes,     19 codepoints in   8 ranges (U+000085 - U+003001) using cascading
 // to_lower        :  1112 bytes,   1462 codepoints in 185 ranges (U+0000C0 - U+01E921) using 2-level LUT
 // to_upper        :  1998 bytes,   1554 codepoints in 299 ranges (U+0000B5 - U+01E943) using 2-level LUT
-// Total           :  9657 bytes
+// to_title        :   340 bytes,    135 codepoints in  49 ranges (U+0000DF - U+00FB17) using 2-level LUT
+// Total           :  9997 bytes
 
 #[inline(always)]
 const fn bitset_search<
@@ -823,14 +824,10 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
         unsafe { char::from_u32_unchecked(((plane as u32) << 16) | (low as u32)) }
     }
 
-    fn lookup(input: char, ascii: char, l1_lut: &L1Lut) -> [char; 3] {
-        if input.is_ascii() {
-            return [ascii, '\0', '\0'];
-        }
-
+    fn lookup(input: char, l1_lut: &L1Lut) -> Option<[char; 3]> {
         let (input_high, input_low) = deconstruct(input);
         let Some(l2_lut) = l1_lut.l2_luts.get(input_high as usize) else {
-            return [input, '\0', '\0'];
+            return None;
         };
 
         let idx = l2_lut.singles.binary_search_by(|(range, _)| {
@@ -844,6 +841,7 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
                 Ordering::Equal
             }
         });
+
         if let Ok(idx) = idx {
             // SAFETY: binary search guarantees that the index is in bounds.
             let &(range, output_delta) = unsafe { l2_lut.singles.get_unchecked(idx) };
@@ -852,7 +850,7 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
                 let output_low = input_low.wrapping_add_signed(output_delta);
                 // SAFETY: Table data are guaranteed to be valid Unicode.
                 let output = unsafe { reconstruct(input_high, output_low) };
-                return [output, '\0', '\0'];
+                return Some([output, '\0', '\0']);
             }
         };
 
@@ -861,18 +859,37 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
             let &(_, output_lows) = unsafe { l2_lut.multis.get_unchecked(idx) };
             // SAFETY: Table data are guaranteed to be valid Unicode.
             let output = output_lows.map(|output_low| unsafe { reconstruct(input_high, output_low) });
-            return output;
+            return Some(output);
         };
 
-        [input, '\0', '\0']
+        None
     }
 
     pub fn to_lower(c: char) -> [char; 3] {
-        lookup(c, c.to_ascii_lowercase(), &LOWERCASE_LUT)
+        // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Lowercased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+        if c < '\u{C0}' {
+            return [c.to_ascii_lowercase(), '\0', '\0'];
+        }
+
+        lookup(c, &LOWERCASE_LUT).unwrap_or([c, '\0', '\0'])
     }
 
     pub fn to_upper(c: char) -> [char; 3] {
-        lookup(c, c.to_ascii_uppercase(), &UPPERCASE_LUT)
+        // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Uppercased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+        if c < '\u{B5}' {
+            return [c.to_ascii_uppercase(), '\0', '\0'];
+        }
+
+        lookup(c, &UPPERCASE_LUT).unwrap_or([c, '\0', '\0'])
+    }
+
+    pub fn to_title(c: char) -> [char; 3] {
+        // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Titlecased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+        if c < '\u{B5}' {
+            return [c.to_ascii_uppercase(), '\0', '\0'];
+        }
+
+        lookup(c, &TITLECASE_LUT).or_else(|| lookup(c, &UPPERCASE_LUT)).unwrap_or([c, '\0', '\0'])
     }
 
     static LOWERCASE_LUT: L1Lut = L1Lut {
@@ -1150,4 +1167,45 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
             },
         ],
     };
+
+    static TITLECASE_LUT: L1Lut = L1Lut {
+        l2_luts: [
+            L2Lut {
+                singles: &[ // 26 entries, 156 bytes
+                    (Range::singleton(0x01c4), 1), (Range::singleton(0x01c5), 0),
+                    (Range::singleton(0x01c6), -1), (Range::singleton(0x01c7), 1),
+                    (Range::singleton(0x01c8), 0), (Range::singleton(0x01c9), -1),
+                    (Range::singleton(0x01ca), 1), (Range::singleton(0x01cb), 0),
+                    (Range::singleton(0x01cc), -1), (Range::singleton(0x01f1), 1),
+                    (Range::singleton(0x01f2), 0), (Range::singleton(0x01f3), -1),
+                    (Range::step_by_1(0x10d0..=0x10fa), 0), (Range::step_by_1(0x10fd..=0x10ff), 0),
+                    (Range::step_by_1(0x1f80..=0x1f87), 8), (Range::step_by_1(0x1f88..=0x1f8f), 0),
+                    (Range::step_by_1(0x1f90..=0x1f97), 8), (Range::step_by_1(0x1f98..=0x1f9f), 0),
+                    (Range::step_by_1(0x1fa0..=0x1fa7), 8), (Range::step_by_1(0x1fa8..=0x1faf), 0),
+                    (Range::singleton(0x1fb3), 9), (Range::singleton(0x1fbc), 0), (Range::singleton(0x1fc3), 9),
+                    (Range::singleton(0x1fcc), 0), (Range::singleton(0x1ff3), 9), (Range::singleton(0x1ffc), 0),
+                ],
+                multis: &[ // 23 entries, 184 bytes
+                    (0x00df, [0x0053, 0x0073, 0x0000]), (0x0587, [0x0535, 0x0582, 0x0000]),
+                    (0x1fb2, [0x1fba, 0x0345, 0x0000]), (0x1fb4, [0x0386, 0x0345, 0x0000]),
+                    (0x1fb7, [0x0391, 0x0342, 0x0345]), (0x1fc2, [0x1fca, 0x0345, 0x0000]),
+                    (0x1fc4, [0x0389, 0x0345, 0x0000]), (0x1fc7, [0x0397, 0x0342, 0x0345]),
+                    (0x1ff2, [0x1ffa, 0x0345, 0x0000]), (0x1ff4, [0x038f, 0x0345, 0x0000]),
+                    (0x1ff7, [0x03a9, 0x0342, 0x0345]), (0xfb00, [0x0046, 0x0066, 0x0000]),
+                    (0xfb01, [0x0046, 0x0069, 0x0000]), (0xfb02, [0x0046, 0x006c, 0x0000]),
+                    (0xfb03, [0x0046, 0x0066, 0x0069]), (0xfb04, [0x0046, 0x0066, 0x006c]),
+                    (0xfb05, [0x0053, 0x0074, 0x0000]), (0xfb06, [0x0053, 0x0074, 0x0000]),
+                    (0xfb13, [0x0544, 0x0576, 0x0000]), (0xfb14, [0x0544, 0x0565, 0x0000]),
+                    (0xfb15, [0x0544, 0x056b, 0x0000]), (0xfb16, [0x054e, 0x0576, 0x0000]),
+                    (0xfb17, [0x0544, 0x056d, 0x0000]),
+                ],
+            },
+            L2Lut {
+                singles: &[ // 0 entries, 0 bytes
+                ],
+                multis: &[ // 0 entries, 0 bytes
+                ],
+            },
+        ],
+    };
 }
diff --git a/library/coretests/tests/char.rs b/library/coretests/tests/char.rs
index f0f6a2442928..aa20585953b7 100644
--- a/library/coretests/tests/char.rs
+++ b/library/coretests/tests/char.rs
@@ -1,5 +1,6 @@
+use std::char::{self, CharCase};
+use std::str;
 use std::str::FromStr;
-use std::{char, str};
 
 #[test]
 fn test_convert() {
@@ -39,6 +40,29 @@ fn test_from_str() {
     assert!(char::from_str("abc").is_err());
 }
 
+#[test]
+fn test_is_cased() {
+    assert!('a'.is_cased());
+    assert!('ö'.is_cased());
+    assert!('ß'.is_cased());
+    assert!('Ü'.is_cased());
+    assert!('P'.is_cased());
+    assert!('ª'.is_cased());
+    assert!(!'攂'.is_cased());
+}
+
+#[test]
+fn test_char_case() {
+    for c in '\0'..='\u{10FFFF}' {
+        match c.case() {
+            None => assert!(!c.is_cased()),
+            Some(CharCase::Lower) => assert!(c.is_lowercase()),
+            Some(CharCase::Upper) => assert!(c.is_uppercase()),
+            Some(CharCase::Title) => assert!(c.is_titlecase()),
+        }
+    }
+}
+
 #[test]
 fn test_is_lowercase() {
     assert!('a'.is_lowercase());
@@ -48,6 +72,17 @@ fn test_is_lowercase() {
     assert!(!'P'.is_lowercase());
 }
 
+#[test]
+fn test_is_titlecase() {
+    assert!('Dž'.is_titlecase());
+    assert!('ᾨ'.is_titlecase());
+    assert!(!'h'.is_titlecase());
+    assert!(!'ä'.is_titlecase());
+    assert!(!'ß'.is_titlecase());
+    assert!(!'Ö'.is_titlecase());
+    assert!(!'T'.is_titlecase());
+}
+
 #[test]
 fn test_is_uppercase() {
     assert!(!'h'.is_uppercase());
@@ -57,6 +92,26 @@ fn test_is_uppercase() {
     assert!('T'.is_uppercase());
 }
 
+#[test]
+fn titlecase_fast_path() {
+    for c in '\0'..='\u{01C4}' {
+        assert!(!(c.is_cased() && !c.is_lowercase() && !c.is_uppercase()))
+    }
+}
+
+#[test]
+fn at_most_one_case() {
+    for c in '\0'..='\u{10FFFF}' {
+        assert_eq!(
+            !c.is_cased() as u8
+                + c.is_lowercase() as u8
+                + c.is_uppercase() as u8
+                + c.is_titlecase() as u8,
+            1
+        );
+    }
+}
+
 #[test]
 fn test_is_whitespace() {
     assert!(' '.is_whitespace());
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 72112f8b0113..5f7039641dae 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -111,6 +111,7 @@
 #![feature(step_trait)]
 #![feature(str_internals)]
 #![feature(strict_provenance_lints)]
+#![feature(titlecase)]
 #![feature(trusted_len)]
 #![feature(trusted_random_access)]
 #![feature(try_blocks)]
diff --git a/library/coretests/tests/unicode.rs b/library/coretests/tests/unicode.rs
index 1fae74f0f11e..a8a221db8f95 100644
--- a/library/coretests/tests/unicode.rs
+++ b/library/coretests/tests/unicode.rs
@@ -27,17 +27,21 @@ fn test_boolean_property(ranges: &[RangeInclusive<char>], lookup: fn(char) -> bo
 }
 
 #[track_caller]
-fn test_case_mapping(ranges: &[(char, [char; 3])], lookup: fn(char) -> [char; 3]) {
+fn test_case_mapping(
+    ranges: &[(char, [char; 3])],
+    lookup: fn(char) -> [char; 3],
+    fallback: fn(char) -> [char; 3],
+) {
     let mut start = '\u{80}';
     for &(key, val) in ranges {
         for c in start..key {
-            assert_eq!(lookup(c), [c, '\0', '\0'], "{c:?}");
+            assert_eq!(lookup(c), fallback(c), "{c:?}");
         }
         assert_eq!(lookup(key), val, "{key:?}");
         start = char::from_u32(key as u32 + 1).unwrap();
     }
     for c in start..=char::MAX {
-        assert_eq!(lookup(c), [c, '\0', '\0'], "{c:?}");
+        assert_eq!(lookup(c), fallback(c), "{c:?}");
     }
 }
 
@@ -45,6 +49,7 @@ fn test_boolean_property(ranges: &[RangeInclusive<char>], lookup: fn(char) -> bo
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn alphabetic() {
     test_boolean_property(test_data::ALPHABETIC, unicode_data::alphabetic::lookup);
+    test_boolean_property(test_data::ALPHABETIC, char::is_alphabetic);
 }
 
 #[test]
@@ -57,6 +62,7 @@ fn case_ignorable() {
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn cased() {
     test_boolean_property(test_data::CASED, unicode_data::cased::lookup);
+    test_boolean_property(test_data::CASED, char::is_cased);
 }
 
 #[test]
@@ -69,34 +75,52 @@ fn grapheme_extend() {
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn lowercase() {
     test_boolean_property(test_data::LOWERCASE, unicode_data::lowercase::lookup);
+    test_boolean_property(test_data::LOWERCASE, char::is_lowercase);
 }
 
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn n() {
     test_boolean_property(test_data::N, unicode_data::n::lookup);
+    test_boolean_property(test_data::N, char::is_numeric);
 }
 
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn uppercase() {
     test_boolean_property(test_data::UPPERCASE, unicode_data::uppercase::lookup);
+    test_boolean_property(test_data::UPPERCASE, char::is_uppercase);
 }
 
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn white_space() {
     test_boolean_property(test_data::WHITE_SPACE, unicode_data::white_space::lookup);
+    test_boolean_property(test_data::WHITE_SPACE, char::is_whitespace);
 }
 
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn to_lowercase() {
-    test_case_mapping(test_data::TO_LOWER, unicode_data::conversions::to_lower);
+    test_case_mapping(test_data::TO_LOWER, unicode_data::conversions::to_lower, |c| {
+        [c, '\0', '\0']
+    });
 }
 
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn to_uppercase() {
-    test_case_mapping(test_data::TO_UPPER, unicode_data::conversions::to_upper);
+    test_case_mapping(test_data::TO_UPPER, unicode_data::conversions::to_upper, |c| {
+        [c, '\0', '\0']
+    });
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
+fn to_titlecase() {
+    test_case_mapping(
+        test_data::TO_TITLE,
+        unicode_data::conversions::to_title,
+        unicode_data::conversions::to_upper,
+    );
 }
diff --git a/library/coretests/tests/unicode/test_data.rs b/library/coretests/tests/unicode/test_data.rs
index cfc695475b1f..3071aedcae07 100644
--- a/library/coretests/tests/unicode/test_data.rs
+++ b/library/coretests/tests/unicode/test_data.rs
@@ -2900,3 +2900,81 @@
     ('\u{1e942}', ['\u{1e920}', '\u{0}', '\u{0}']),
     ('\u{1e943}', ['\u{1e921}', '\u{0}', '\u{0}']),
 ];
+
+#[rustfmt::skip]
+pub(super) static TO_TITLE: &[(char, [char; 3]); 135] = &[
+    ('\u{df}', ['S', 's', '\u{0}']), ('\u{1c4}', ['\u{1c5}', '\u{0}', '\u{0}']),
+    ('\u{1c5}', ['\u{1c5}', '\u{0}', '\u{0}']), ('\u{1c6}', ['\u{1c5}', '\u{0}', '\u{0}']),
+    ('\u{1c7}', ['\u{1c8}', '\u{0}', '\u{0}']), ('\u{1c8}', ['\u{1c8}', '\u{0}', '\u{0}']),
+    ('\u{1c9}', ['\u{1c8}', '\u{0}', '\u{0}']), ('\u{1ca}', ['\u{1cb}', '\u{0}', '\u{0}']),
+    ('\u{1cb}', ['\u{1cb}', '\u{0}', '\u{0}']), ('\u{1cc}', ['\u{1cb}', '\u{0}', '\u{0}']),
+    ('\u{1f1}', ['\u{1f2}', '\u{0}', '\u{0}']), ('\u{1f2}', ['\u{1f2}', '\u{0}', '\u{0}']),
+    ('\u{1f3}', ['\u{1f2}', '\u{0}', '\u{0}']), ('\u{587}', ['\u{535}', '\u{582}', '\u{0}']),
+    ('\u{10d0}', ['\u{10d0}', '\u{0}', '\u{0}']), ('\u{10d1}', ['\u{10d1}', '\u{0}', '\u{0}']),
+    ('\u{10d2}', ['\u{10d2}', '\u{0}', '\u{0}']), ('\u{10d3}', ['\u{10d3}', '\u{0}', '\u{0}']),
+    ('\u{10d4}', ['\u{10d4}', '\u{0}', '\u{0}']), ('\u{10d5}', ['\u{10d5}', '\u{0}', '\u{0}']),
+    ('\u{10d6}', ['\u{10d6}', '\u{0}', '\u{0}']), ('\u{10d7}', ['\u{10d7}', '\u{0}', '\u{0}']),
+    ('\u{10d8}', ['\u{10d8}', '\u{0}', '\u{0}']), ('\u{10d9}', ['\u{10d9}', '\u{0}', '\u{0}']),
+    ('\u{10da}', ['\u{10da}', '\u{0}', '\u{0}']), ('\u{10db}', ['\u{10db}', '\u{0}', '\u{0}']),
+    ('\u{10dc}', ['\u{10dc}', '\u{0}', '\u{0}']), ('\u{10dd}', ['\u{10dd}', '\u{0}', '\u{0}']),
+    ('\u{10de}', ['\u{10de}', '\u{0}', '\u{0}']), ('\u{10df}', ['\u{10df}', '\u{0}', '\u{0}']),
+    ('\u{10e0}', ['\u{10e0}', '\u{0}', '\u{0}']), ('\u{10e1}', ['\u{10e1}', '\u{0}', '\u{0}']),
+    ('\u{10e2}', ['\u{10e2}', '\u{0}', '\u{0}']), ('\u{10e3}', ['\u{10e3}', '\u{0}', '\u{0}']),
+    ('\u{10e4}', ['\u{10e4}', '\u{0}', '\u{0}']), ('\u{10e5}', ['\u{10e5}', '\u{0}', '\u{0}']),
+    ('\u{10e6}', ['\u{10e6}', '\u{0}', '\u{0}']), ('\u{10e7}', ['\u{10e7}', '\u{0}', '\u{0}']),
+    ('\u{10e8}', ['\u{10e8}', '\u{0}', '\u{0}']), ('\u{10e9}', ['\u{10e9}', '\u{0}', '\u{0}']),
+    ('\u{10ea}', ['\u{10ea}', '\u{0}', '\u{0}']), ('\u{10eb}', ['\u{10eb}', '\u{0}', '\u{0}']),
+    ('\u{10ec}', ['\u{10ec}', '\u{0}', '\u{0}']), ('\u{10ed}', ['\u{10ed}', '\u{0}', '\u{0}']),
+    ('\u{10ee}', ['\u{10ee}', '\u{0}', '\u{0}']), ('\u{10ef}', ['\u{10ef}', '\u{0}', '\u{0}']),
+    ('\u{10f0}', ['\u{10f0}', '\u{0}', '\u{0}']), ('\u{10f1}', ['\u{10f1}', '\u{0}', '\u{0}']),
+    ('\u{10f2}', ['\u{10f2}', '\u{0}', '\u{0}']), ('\u{10f3}', ['\u{10f3}', '\u{0}', '\u{0}']),
+    ('\u{10f4}', ['\u{10f4}', '\u{0}', '\u{0}']), ('\u{10f5}', ['\u{10f5}', '\u{0}', '\u{0}']),
+    ('\u{10f6}', ['\u{10f6}', '\u{0}', '\u{0}']), ('\u{10f7}', ['\u{10f7}', '\u{0}', '\u{0}']),
+    ('\u{10f8}', ['\u{10f8}', '\u{0}', '\u{0}']), ('\u{10f9}', ['\u{10f9}', '\u{0}', '\u{0}']),
+    ('\u{10fa}', ['\u{10fa}', '\u{0}', '\u{0}']), ('\u{10fd}', ['\u{10fd}', '\u{0}', '\u{0}']),
+    ('\u{10fe}', ['\u{10fe}', '\u{0}', '\u{0}']), ('\u{10ff}', ['\u{10ff}', '\u{0}', '\u{0}']),
+    ('\u{1f80}', ['\u{1f88}', '\u{0}', '\u{0}']), ('\u{1f81}', ['\u{1f89}', '\u{0}', '\u{0}']),
+    ('\u{1f82}', ['\u{1f8a}', '\u{0}', '\u{0}']), ('\u{1f83}', ['\u{1f8b}', '\u{0}', '\u{0}']),
+    ('\u{1f84}', ['\u{1f8c}', '\u{0}', '\u{0}']), ('\u{1f85}', ['\u{1f8d}', '\u{0}', '\u{0}']),
+    ('\u{1f86}', ['\u{1f8e}', '\u{0}', '\u{0}']), ('\u{1f87}', ['\u{1f8f}', '\u{0}', '\u{0}']),
+    ('\u{1f88}', ['\u{1f88}', '\u{0}', '\u{0}']), ('\u{1f89}', ['\u{1f89}', '\u{0}', '\u{0}']),
+    ('\u{1f8a}', ['\u{1f8a}', '\u{0}', '\u{0}']), ('\u{1f8b}', ['\u{1f8b}', '\u{0}', '\u{0}']),
+    ('\u{1f8c}', ['\u{1f8c}', '\u{0}', '\u{0}']), ('\u{1f8d}', ['\u{1f8d}', '\u{0}', '\u{0}']),
+    ('\u{1f8e}', ['\u{1f8e}', '\u{0}', '\u{0}']), ('\u{1f8f}', ['\u{1f8f}', '\u{0}', '\u{0}']),
+    ('\u{1f90}', ['\u{1f98}', '\u{0}', '\u{0}']), ('\u{1f91}', ['\u{1f99}', '\u{0}', '\u{0}']),
+    ('\u{1f92}', ['\u{1f9a}', '\u{0}', '\u{0}']), ('\u{1f93}', ['\u{1f9b}', '\u{0}', '\u{0}']),
+    ('\u{1f94}', ['\u{1f9c}', '\u{0}', '\u{0}']), ('\u{1f95}', ['\u{1f9d}', '\u{0}', '\u{0}']),
+    ('\u{1f96}', ['\u{1f9e}', '\u{0}', '\u{0}']), ('\u{1f97}', ['\u{1f9f}', '\u{0}', '\u{0}']),
+    ('\u{1f98}', ['\u{1f98}', '\u{0}', '\u{0}']), ('\u{1f99}', ['\u{1f99}', '\u{0}', '\u{0}']),
+    ('\u{1f9a}', ['\u{1f9a}', '\u{0}', '\u{0}']), ('\u{1f9b}', ['\u{1f9b}', '\u{0}', '\u{0}']),
+    ('\u{1f9c}', ['\u{1f9c}', '\u{0}', '\u{0}']), ('\u{1f9d}', ['\u{1f9d}', '\u{0}', '\u{0}']),
+    ('\u{1f9e}', ['\u{1f9e}', '\u{0}', '\u{0}']), ('\u{1f9f}', ['\u{1f9f}', '\u{0}', '\u{0}']),
+    ('\u{1fa0}', ['\u{1fa8}', '\u{0}', '\u{0}']), ('\u{1fa1}', ['\u{1fa9}', '\u{0}', '\u{0}']),
+    ('\u{1fa2}', ['\u{1faa}', '\u{0}', '\u{0}']), ('\u{1fa3}', ['\u{1fab}', '\u{0}', '\u{0}']),
+    ('\u{1fa4}', ['\u{1fac}', '\u{0}', '\u{0}']), ('\u{1fa5}', ['\u{1fad}', '\u{0}', '\u{0}']),
+    ('\u{1fa6}', ['\u{1fae}', '\u{0}', '\u{0}']), ('\u{1fa7}', ['\u{1faf}', '\u{0}', '\u{0}']),
+    ('\u{1fa8}', ['\u{1fa8}', '\u{0}', '\u{0}']), ('\u{1fa9}', ['\u{1fa9}', '\u{0}', '\u{0}']),
+    ('\u{1faa}', ['\u{1faa}', '\u{0}', '\u{0}']), ('\u{1fab}', ['\u{1fab}', '\u{0}', '\u{0}']),
+    ('\u{1fac}', ['\u{1fac}', '\u{0}', '\u{0}']), ('\u{1fad}', ['\u{1fad}', '\u{0}', '\u{0}']),
+    ('\u{1fae}', ['\u{1fae}', '\u{0}', '\u{0}']), ('\u{1faf}', ['\u{1faf}', '\u{0}', '\u{0}']),
+    ('\u{1fb2}', ['\u{1fba}', '\u{345}', '\u{0}']),
+    ('\u{1fb3}', ['\u{1fbc}', '\u{0}', '\u{0}']), ('\u{1fb4}', ['\u{386}', '\u{345}', '\u{0}']),
+    ('\u{1fb7}', ['\u{391}', '\u{342}', '\u{345}']),
+    ('\u{1fbc}', ['\u{1fbc}', '\u{0}', '\u{0}']),
+    ('\u{1fc2}', ['\u{1fca}', '\u{345}', '\u{0}']),
+    ('\u{1fc3}', ['\u{1fcc}', '\u{0}', '\u{0}']), ('\u{1fc4}', ['\u{389}', '\u{345}', '\u{0}']),
+    ('\u{1fc7}', ['\u{397}', '\u{342}', '\u{345}']),
+    ('\u{1fcc}', ['\u{1fcc}', '\u{0}', '\u{0}']),
+    ('\u{1ff2}', ['\u{1ffa}', '\u{345}', '\u{0}']),
+    ('\u{1ff3}', ['\u{1ffc}', '\u{0}', '\u{0}']), ('\u{1ff4}', ['\u{38f}', '\u{345}', '\u{0}']),
+    ('\u{1ff7}', ['\u{3a9}', '\u{342}', '\u{345}']),
+    ('\u{1ffc}', ['\u{1ffc}', '\u{0}', '\u{0}']), ('\u{fb00}', ['F', 'f', '\u{0}']),
+    ('\u{fb01}', ['F', 'i', '\u{0}']), ('\u{fb02}', ['F', 'l', '\u{0}']),
+    ('\u{fb03}', ['F', 'f', 'i']), ('\u{fb04}', ['F', 'f', 'l']),
+    ('\u{fb05}', ['S', 't', '\u{0}']), ('\u{fb06}', ['S', 't', '\u{0}']),
+    ('\u{fb13}', ['\u{544}', '\u{576}', '\u{0}']),
+    ('\u{fb14}', ['\u{544}', '\u{565}', '\u{0}']),
+    ('\u{fb15}', ['\u{544}', '\u{56b}', '\u{0}']),
+    ('\u{fb16}', ['\u{54e}', '\u{576}', '\u{0}']),
+    ('\u{fb17}', ['\u{544}', '\u{56d}', '\u{0}']),
+];
diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index 6345cb8ef253..b7b385542ef5 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -48,7 +48,7 @@
 use crate::fmt_helpers::Hex;
 use crate::{UnicodeData, fmt_list};
 
-pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [(String, usize); 2]) {
+pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [(String, usize); 3]) {
     let mut file = String::new();
 
     file.push_str("\n\n");
@@ -59,7 +59,10 @@
     file.push_str("\n\n");
     let (upper_tables, upper_desc, upper_size) = generate_tables("UPPER", &data.to_upper);
     file.push_str(&upper_tables);
-    (file, [(lower_desc, lower_size), (upper_desc, upper_size)])
+    file.push_str("\n\n");
+    let (title_tables, title_desc, title_size) = generate_tables("TITLE", &data.to_title);
+    file.push_str(&title_tables);
+    (file, [(lower_desc, lower_size), (upper_desc, upper_size), (title_desc, title_size)])
 }
 
 // So far, only planes 0 and 1 (Basic Multilingual Plane and Supplementary
@@ -336,14 +339,10 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
     unsafe { char::from_u32_unchecked(((plane as u32) << 16) | (low as u32)) }
 }
 
-fn lookup(input: char, ascii: char, l1_lut: &L1Lut) -> [char; 3] {
-    if input.is_ascii() {
-        return [ascii, '\0', '\0'];
-    }
-
+fn lookup(input: char, l1_lut: &L1Lut) -> Option<[char; 3]> {
     let (input_high, input_low) = deconstruct(input);
     let Some(l2_lut) = l1_lut.l2_luts.get(input_high as usize) else {
-        return [input, '\0', '\0'];
+        return None;
     };
 
     let idx = l2_lut.singles.binary_search_by(|(range, _)| {
@@ -357,6 +356,7 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
             Ordering::Equal
         }
     });
+
     if let Ok(idx) = idx {
         // SAFETY: binary search guarantees that the index is in bounds.
         let &(range, output_delta) = unsafe { l2_lut.singles.get_unchecked(idx) };
@@ -365,7 +365,7 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
             let output_low = input_low.wrapping_add_signed(output_delta);
             // SAFETY: Table data are guaranteed to be valid Unicode.
             let output = unsafe { reconstruct(input_high, output_low) };
-            return [output, '\0', '\0'];
+            return Some([output, '\0', '\0']);
         }
     };
 
@@ -374,17 +374,36 @@ unsafe fn reconstruct(plane: u16, low: u16) -> char {
         let &(_, output_lows) = unsafe { l2_lut.multis.get_unchecked(idx) };
         // SAFETY: Table data are guaranteed to be valid Unicode.
         let output = output_lows.map(|output_low| unsafe { reconstruct(input_high, output_low) });
-        return output;
+        return Some(output);
     };
 
-    [input, '\0', '\0']
+    None
 }
 
 pub fn to_lower(c: char) -> [char; 3] {
-    lookup(c, c.to_ascii_lowercase(), &LOWERCASE_LUT)
+    // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Lowercased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+    if c < '\u{C0}' {
+        return [c.to_ascii_lowercase(), '\0', '\0'];
+    }
+
+    lookup(c, &LOWERCASE_LUT).unwrap_or([c, '\0', '\0'])
 }
 
 pub fn to_upper(c: char) -> [char; 3] {
-    lookup(c, c.to_ascii_uppercase(), &UPPERCASE_LUT)
+    // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Uppercased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+    if c < '\u{B5}' {
+        return [c.to_ascii_uppercase(), '\0', '\0'];
+    }
+
+    lookup(c, &UPPERCASE_LUT).unwrap_or([c, '\0', '\0'])
+}
+
+pub fn to_title(c: char) -> [char; 3] {
+    // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%253AChanges_When_Titlecased%253A%5D-%5B%253AASCII%253A%5D&abb=on
+    if c < '\u{B5}' {
+        return [c.to_ascii_uppercase(), '\0', '\0'];
+    }
+
+    lookup(c, &TITLECASE_LUT).or_else(|| lookup(c, &UPPERCASE_LUT)).unwrap_or([c, '\0', '\0'])
 }
 ";
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index 4e7c40efc123..cdd137ff56a5 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -100,32 +100,25 @@
 
 struct UnicodeData {
     ranges: Vec<(&'static str, Vec<Range<u32>>)>,
+    /// Only stores mappings that are not to self
     to_upper: BTreeMap<u32, [u32; 3]>,
+    /// Only stores mappings that differ from `to_upper`
+    to_title: BTreeMap<u32, [u32; 3]>,
+    /// Only stores mappings that are not to self
     to_lower: BTreeMap<u32, [u32; 3]>,
 }
 
-fn to_mapping(origin: u32, codepoints: Vec<ucd_parse::Codepoint>) -> Option<[u32; 3]> {
-    let mut a = None;
-    let mut b = None;
-    let mut c = None;
-
-    for codepoint in codepoints {
-        if origin == codepoint.value() {
-            return None;
-        }
-
-        if a.is_none() {
-            a = Some(codepoint.value());
-        } else if b.is_none() {
-            b = Some(codepoint.value());
-        } else if c.is_none() {
-            c = Some(codepoint.value());
-        } else {
-            panic!("more than 3 mapped codepoints")
-        }
+fn to_mapping(
+    if_different_from: &[ucd_parse::Codepoint],
+    codepoints: &[ucd_parse::Codepoint],
+) -> Option<[u32; 3]> {
+    if codepoints == if_different_from {
+        return None;
     }
 
-    Some([a.unwrap(), b.unwrap_or(0), c.unwrap_or(0)])
+    let mut ret = [ucd_parse::Codepoint::default(); 3];
+    ret[0..codepoints.len()].copy_from_slice(codepoints);
+    Some(ret.map(ucd_parse::Codepoint::value))
 }
 
 static UNICODE_DIRECTORY: &str = "unicode-downloads";
@@ -145,8 +138,7 @@ fn load_data() -> UnicodeData {
         }
     }
 
-    let mut to_lower = BTreeMap::new();
-    let mut to_upper = BTreeMap::new();
+    let [mut to_lower, mut to_upper, mut to_title] = [const { BTreeMap::new() }; 3];
     for row in ucd_parse::UnicodeDataExpander::new(
         ucd_parse::parse::<_, ucd_parse::UnicodeData>(&UNICODE_DIRECTORY).unwrap(),
     ) {
@@ -172,6 +164,11 @@ fn load_data() -> UnicodeData {
         {
             to_upper.insert(row.codepoint.value(), [mapped.value(), 0, 0]);
         }
+        if let Some(mapped) = row.simple_titlecase_mapping
+            && Some(mapped) != row.simple_uppercase_mapping
+        {
+            to_title.insert(row.codepoint.value(), [mapped.value(), 0, 0]);
+        }
     }
 
     for row in ucd_parse::parse::<_, ucd_parse::SpecialCaseMapping>(&UNICODE_DIRECTORY).unwrap() {
@@ -181,12 +178,15 @@ fn load_data() -> UnicodeData {
         }
 
         let key = row.codepoint.value();
-        if let Some(lower) = to_mapping(key, row.lowercase) {
+        if let Some(lower) = to_mapping(&[row.codepoint], &row.lowercase) {
             to_lower.insert(key, lower);
         }
-        if let Some(upper) = to_mapping(key, row.uppercase) {
+        if let Some(upper) = to_mapping(&[row.codepoint], &row.uppercase) {
             to_upper.insert(key, upper);
         }
+        if let Some(title) = to_mapping(&row.uppercase, &row.titlecase) {
+            to_title.insert(key, title);
+        }
     }
 
     // Filter out ASCII codepoints.
@@ -207,7 +207,7 @@ fn load_data() -> UnicodeData {
         .collect();
 
     properties.sort_by_key(|p| p.0);
-    UnicodeData { ranges: properties, to_lower, to_upper }
+    UnicodeData { ranges: properties, to_lower, to_title, to_upper }
 }
 
 fn main() {
@@ -259,7 +259,7 @@ fn main() {
         total_bytes += emitter.bytes_used;
     }
     let (conversions, sizes) = case_mapping::generate_case_mapping(&unicode_data);
-    for (name, (desc, size)) in ["to_lower", "to_upper"].iter().zip(sizes) {
+    for (name, (desc, size)) in ["to_lower", "to_upper", "to_title"].iter().zip(sizes) {
         table_file.push_str(&format!("// {:16}: {:5} bytes, {desc}\n", name, size,));
         total_bytes += size;
     }
@@ -369,7 +369,11 @@ fn generate_tests(data: &UnicodeData) -> String {
         .unwrap();
     }
 
-    for (name, lut) in ["TO_LOWER", "TO_UPPER"].iter().zip([&data.to_lower, &data.to_upper]) {
+    for (name, lut) in ["TO_LOWER", "TO_UPPER", "TO_TITLE"].iter().zip([
+        &data.to_lower,
+        &data.to_upper,
+        &data.to_title,
+    ]) {
         let lut = lut
             .iter()
             .map(|(key, values)| {

From 9b7dff982eb2f2084e2e1ceee2d1c6d832963e7a Mon Sep 17 00:00:00 2001
From: ujjwalVishwakarma2006 <2023ucs0116@iitjammu.ac.in>
Date: Sun, 22 Mar 2026 00:06:06 +0530
Subject: [PATCH 0753/1059] Move and rename LTO-specific test files from
 tests/ui/issues/ to tests/ui/lto/

---
 tests/ui/{issues/issue-44056.rs => lto/lto-avx-target-feature.rs} | 0
 .../ui/{issues/issue-51947.rs => lto/lto-weak-merge-functions.rs} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/issue-44056.rs => lto/lto-avx-target-feature.rs} (100%)
 rename tests/ui/{issues/issue-51947.rs => lto/lto-weak-merge-functions.rs} (100%)

diff --git a/tests/ui/issues/issue-44056.rs b/tests/ui/lto/lto-avx-target-feature.rs
similarity index 100%
rename from tests/ui/issues/issue-44056.rs
rename to tests/ui/lto/lto-avx-target-feature.rs
diff --git a/tests/ui/issues/issue-51947.rs b/tests/ui/lto/lto-weak-merge-functions.rs
similarity index 100%
rename from tests/ui/issues/issue-51947.rs
rename to tests/ui/lto/lto-weak-merge-functions.rs

From 9b0be7857af8e355523b1db8b9e24acfd9be7db1 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sat, 21 Mar 2026 12:38:32 +0000
Subject: [PATCH 0754/1059] allow `incomplete_features` in most UI tests

---
 src/tools/compiletest/src/runtest.rs          |   9 +-
 .../type-const-in-array-len-wrong-type.rs     |   3 -
 .../type-const-in-array-len-wrong-type.stderr |  29 +----
 .../type-const-in-array-len.rs                |   2 -
 .../type-const-in-array-len.stderr            |  19 ---
 .../hr-do-not-blame-outlives-static-ice.rs    |   1 -
 ...hr-do-not-blame-outlives-static-ice.stderr |  17 +--
 .../variance-computation-requires-equality.rs |   1 -
 ...iance-computation-requires-equality.stderr |  11 --
 .../defaults-specialization.rs                |   1 -
 .../defaults-specialization.stderr            |  42 +++----
 .../async-drop/foreign-fundamental.rs         |   1 -
 .../async-drop/foreign-fundamental.stderr     |  15 +--
 .../dyn/mut-is-pointer-like.stderr            |  11 +-
 tests/ui/async-await/dyn/works.stderr         |  11 +-
 tests/ui/async-await/dyn/wrong-size.stderr    |  11 +-
 .../ui/borrowck/generic_const_early_param.rs  |   1 -
 .../borrowck/generic_const_early_param.stderr |  17 +--
 tests/ui/closures/binder/const-bound.rs       |   1 -
 tests/ui/closures/binder/const-bound.stderr   |  15 +--
 tests/ui/closures/binder/type-bound-2.rs      |   1 -
 tests/ui/closures/binder/type-bound-2.stderr  |  13 +-
 tests/ui/closures/binder/type-bound.rs        |   1 -
 tests/ui/closures/binder/type-bound.stderr    |  13 +-
 .../freeze-on-polymorphic-projection.rs       |   1 -
 .../freeze-on-polymorphic-projection.stderr   |  12 --
 .../coherence-doesnt-use-infcx-evaluate.rs    |   1 -
 ...coherence-doesnt-use-infcx-evaluate.stderr |  12 --
 .../coherence-inherited-assoc-ty-cycle-err.rs |   1 -
 ...erence-inherited-assoc-ty-cycle-err.stderr |  16 +--
 .../regions-in-canonical.rs                   |   1 -
 .../regions-in-canonical.stderr               |  11 --
 tests/ui/consts/escaping-bound-var.rs         |   1 -
 tests/ui/consts/escaping-bound-var.stderr     |  15 +--
 tests/ui/consts/issue-104396.rs               |   1 -
 tests/ui/consts/issue-104396.stderr           |  11 --
 .../consts/refs_check_const_eq-issue-88384.rs |   1 -
 .../refs_check_const_eq-issue-88384.stderr    |  15 +--
 .../generic-associated-const.rs               |   1 -
 .../generic-associated-const.stderr           |  17 +--
 tests/ui/consts/trait_specialization.rs       |   2 +-
 tests/ui/consts/trait_specialization.stderr   |  12 --
 tests/ui/contracts/incomplete-feature.rs      |   1 +
 tests/ui/contracts/incomplete-feature.stderr  |   8 +-
 tests/ui/error-codes/E0520.rs                 |   1 -
 tests/ui/error-codes/E0520.stderr             |  14 +--
 tests/ui/error-codes/E0771.rs                 |   1 -
 tests/ui/error-codes/E0771.stderr             |  13 +-
 ...e-effective-target-features.default.stderr |   8 +-
 ...e-effective-target-features.feature.stderr |  14 ++-
 .../feature-gate-effective-target-features.rs |   1 +
 .../feature-gate-unsafe_fields.rs             |   2 +-
 ...eature-gate-unsafe_fields.with_gate.stderr |   6 +-
 .../issue-87429-specialization.rs             |   1 -
 .../issue-87429-specialization.stderr         |  16 +--
 .../recover-incorrect-impl-restriction.rs     |   1 +
 ...ncorrect-impl-restriction.with_gate.stderr |  20 +--
 ...rrect-impl-restriction.without_gate.stderr |  24 ++--
 .../trait-alias-cannot-be-impl-restricted.rs  |   1 +
 ...cannot-be-impl-restricted.with_gate.stderr |  32 ++---
 ...not-be-impl-restricted.without_gate.stderr |  38 +++---
 tests/ui/impl-trait/equality-rpass.rs         |   2 +-
 tests/ui/impl-trait/equality-rpass.stderr     |  12 --
 tests/ui/impl-trait/equality.rs               |   2 +-
 tests/ui/impl-trait/equality.stderr           |  12 +-
 tests/ui/impl-trait/equality2.rs              |   2 +-
 tests/ui/impl-trait/equality2.stderr          |  12 +-
 .../in-trait/alias-bounds-when-not-wf.rs      |   1 -
 .../in-trait/alias-bounds-when-not-wf.stderr  |  25 ++--
 .../ui/layout/gce-rigid-const-in-array-len.rs |   2 +-
 .../gce-rigid-const-in-array-len.stderr       |  11 +-
 .../ui/lazy-type-alias/bad-lazy-type-alias.rs |   1 -
 .../bad-lazy-type-alias.stderr                |  15 +--
 .../coerce-behind-lazy.current.stderr         |  11 --
 .../coerce-behind-lazy.next.stderr            |  11 --
 .../ui/lazy-type-alias/coerce-behind-lazy.rs  |   1 -
 tests/ui/lazy-type-alias/enum-variant.rs      |   1 -
 tests/ui/lazy-type-alias/enum-variant.stderr  |  11 --
 ...lap-doesnt-conflict-with-specialization.rs |   2 +-
 ...doesnt-conflict-with-specialization.stderr |  12 --
 .../assoc/assoc-static-semantic-fail.rs       |   1 -
 .../assoc/assoc-static-semantic-fail.stderr   |  60 ++++-----
 tests/ui/parser/default.rs                    |   1 -
 tests/ui/parser/default.stderr                |  20 +--
 ...efaultness-invalid-places-fail-semantic.rs |   2 +-
 ...ltness-invalid-places-fail-semantic.stderr |  12 +-
 .../empty-types.exhaustive_patterns.stderr    | 118 +++++++++---------
 .../usefulness/empty-types.never_pats.stderr  |  97 +++++++-------
 .../usefulness/empty-types.normal.stderr      |  86 ++++++-------
 tests/ui/pattern/usefulness/empty-types.rs    |   1 -
 .../pin-ergonomics/coerce-non-pointer-pin.rs  |   1 -
 .../coerce-non-pointer-pin.stderr             |  11 --
 .../never-pattern-is-a-read.rs                |   1 -
 .../never-pattern-is-a-read.stderr            |  13 +-
 .../dont-assume-err-is-yes-issue-126377.rs    |   1 -
 ...dont-assume-err-is-yes-issue-126377.stderr |  17 +--
 .../non_scalar_alignment_value.rs             |   1 -
 .../non_scalar_alignment_value.stderr         |  19 +--
 tests/ui/unsafe-binders/binder-sized-crit.rs  |   1 -
 .../unsafe-binders/binder-sized-crit.stderr   |  11 --
 tests/ui/unsafe-binders/expr.rs               |   1 -
 tests/ui/unsafe-binders/expr.stderr           |  11 --
 .../ui/unsafe-binders/lifetime-resolution.rs  |   1 -
 .../unsafe-binders/lifetime-resolution.stderr |  15 +--
 tests/ui/unsafe-binders/mismatch.rs           |   1 -
 tests/ui/unsafe-binders/mismatch.stderr       |  21 +---
 tests/ui/unsafe-binders/moves.rs              |   1 -
 tests/ui/unsafe-binders/moves.stderr          |  19 +--
 tests/ui/unsafe-binders/simple.rs             |   1 -
 tests/ui/unsafe-binders/simple.stderr         |  11 --
 tests/ui/unsafe-binders/type-mismatch.rs      |   1 -
 tests/ui/unsafe-binders/type-mismatch.stderr  |  15 +--
 .../unsafe-binders-debuginfo.rs               |   1 -
 .../unsafe-binders-debuginfo.stderr           |  11 --
 114 files changed, 383 insertions(+), 926 deletions(-)
 delete mode 100644 tests/ui/associated-consts/type-const-in-array-len.stderr
 delete mode 100644 tests/ui/associated-inherent-types/variance-computation-requires-equality.stderr
 delete mode 100644 tests/ui/codegen/freeze-on-polymorphic-projection.stderr
 delete mode 100644 tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.stderr
 delete mode 100644 tests/ui/coherence/negative-coherence/regions-in-canonical.stderr
 delete mode 100644 tests/ui/consts/issue-104396.stderr
 delete mode 100644 tests/ui/consts/trait_specialization.stderr
 delete mode 100644 tests/ui/impl-trait/equality-rpass.stderr
 delete mode 100644 tests/ui/lazy-type-alias/coerce-behind-lazy.current.stderr
 delete mode 100644 tests/ui/lazy-type-alias/coerce-behind-lazy.next.stderr
 delete mode 100644 tests/ui/lazy-type-alias/enum-variant.stderr
 delete mode 100644 tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.stderr
 delete mode 100644 tests/ui/pin-ergonomics/coerce-non-pointer-pin.stderr
 delete mode 100644 tests/ui/unsafe-binders/binder-sized-crit.stderr
 delete mode 100644 tests/ui/unsafe-binders/expr.stderr
 delete mode 100644 tests/ui/unsafe-binders/simple.stderr
 delete mode 100644 tests/ui/unsafe-binders/unsafe-binders-debuginfo.stderr

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index b584d14b0c9f..40e6c4e593b1 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1919,8 +1919,15 @@ fn make_compile_args(
             compiler.args(&["-A", "unused", "-W", "unused_attributes"]);
         }
 
-        // Allow tests to use internal features.
+        // Allow tests to use internal and incomplete features.
         compiler.args(&["-A", "internal_features"]);
+        // FIXME(#154168); temporarily exclude some directories to make the transition easier
+        if !input_file
+            .iter()
+            .any(|p| p == "traits" || p == "specialization" || p == "const-generics")
+        {
+            compiler.args(&["-A", "incomplete_features"]);
+        }
 
         // Allow tests to have unused parens and braces.
         // Add #![deny(unused_parens, unused_braces)] to the test file if you want to
diff --git a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs
index cb0b8a102eb4..c260ab1ee584 100644
--- a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs
+++ b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs
@@ -1,9 +1,6 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 #![feature(min_generic_const_args)]
-//~^ WARN the feature `min_generic_const_args` is incomplete
 #![feature(inherent_associated_types)]
-//~^ WARN the feature `inherent_associated_types` is incomplete
 
 struct OnDiskDirEntry<'a>(&'a ());
 
diff --git a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr
index b69a1b7fd7de..a90b1f666067 100644
--- a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr
+++ b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr
@@ -1,35 +1,10 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-const-in-array-len-wrong-type.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-const-in-array-len-wrong-type.rs:3:12
-   |
-LL | #![feature(min_generic_const_args)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-
-warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-const-in-array-len-wrong-type.rs:5:12
-   |
-LL | #![feature(inherent_associated_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
-
 error: the constant `2` is not of type `usize`
-  --> $DIR/type-const-in-array-len-wrong-type.rs:13:26
+  --> $DIR/type-const-in-array-len-wrong-type.rs:10:26
    |
 LL |     fn lfn_contents() -> [char; Self::LFN_FRAGMENT_LEN] {
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `i64`
    |
    = note: the length of array `[char; 2]` must be type `usize`
 
-error: aborting due to 1 previous error; 3 warnings emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-consts/type-const-in-array-len.rs b/tests/ui/associated-consts/type-const-in-array-len.rs
index d33eacaade2d..7a809cefe9f7 100644
--- a/tests/ui/associated-consts/type-const-in-array-len.rs
+++ b/tests/ui/associated-consts/type-const-in-array-len.rs
@@ -1,9 +1,7 @@
 //@ check-pass
 
 #![feature(min_generic_const_args)]
-//~^ WARN the feature `min_generic_const_args` is incomplete
 #![feature(inherent_associated_types)]
-//~^ WARN the feature `inherent_associated_types` is incomplete
 
 // Test case from #138226: generic impl with multiple type parameters
 struct Foo<A, B>(A, B);
diff --git a/tests/ui/associated-consts/type-const-in-array-len.stderr b/tests/ui/associated-consts/type-const-in-array-len.stderr
deleted file mode 100644
index 546995d13a0a..000000000000
--- a/tests/ui/associated-consts/type-const-in-array-len.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-const-in-array-len.rs:3:12
-   |
-LL | #![feature(min_generic_const_args)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-const-in-array-len.rs:5:12
-   |
-LL | #![feature(inherent_associated_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
-
-warning: 2 warnings emitted
-
diff --git a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
index e5c1f47b9e02..27b3b93f071d 100644
--- a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
+++ b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
@@ -2,7 +2,6 @@
 
 // Regression test for #146467.
 #![feature(inherent_associated_types)]
-//~^ WARN the feature `inherent_associated_types` is incomplete
 
 struct Foo<T>(T);
 
diff --git a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
index 4c0726d4ddca..b06add2f5db5 100644
--- a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
+++ b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
@@ -1,20 +1,11 @@
-warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:4:12
-   |
-LL | #![feature(inherent_associated_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:9:6
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:8:6
    |
 LL | impl<'a> Foo<fn(&())> {
    |      ^^ unconstrained lifetime parameter
 
 error[E0308]: mismatched types
-  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:14:11
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:13:11
    |
 LL | fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
@@ -23,12 +14,12 @@ LL | fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
               found struct `Foo<for<'a> fn(&'a ())>`
 
 error: higher-ranked subtype error
-  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:14:1
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:13:1
    |
 LL | fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0207, E0308.
 For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/associated-inherent-types/variance-computation-requires-equality.rs b/tests/ui/associated-inherent-types/variance-computation-requires-equality.rs
index 3f726792b4a1..b7f8586e31e8 100644
--- a/tests/ui/associated-inherent-types/variance-computation-requires-equality.rs
+++ b/tests/ui/associated-inherent-types/variance-computation-requires-equality.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(inherent_associated_types)]
-//~^ WARN the feature `inherent_associated_types` is incomplete
 
 struct D<T> {
   a: T
diff --git a/tests/ui/associated-inherent-types/variance-computation-requires-equality.stderr b/tests/ui/associated-inherent-types/variance-computation-requires-equality.stderr
deleted file mode 100644
index 93064f551abd..000000000000
--- a/tests/ui/associated-inherent-types/variance-computation-requires-equality.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/variance-computation-requires-equality.rs:3:12
-   |
-LL | #![feature(inherent_associated_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/associated-types/defaults-specialization.rs b/tests/ui/associated-types/defaults-specialization.rs
index 553705b2a4fa..d0ed718b8392 100644
--- a/tests/ui/associated-types/defaults-specialization.rs
+++ b/tests/ui/associated-types/defaults-specialization.rs
@@ -1,7 +1,6 @@
 //! Tests the interaction of associated type defaults and specialization.
 
 #![feature(associated_type_defaults, specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Tr {
     type Ty = u8;
diff --git a/tests/ui/associated-types/defaults-specialization.stderr b/tests/ui/associated-types/defaults-specialization.stderr
index d22d9ce659a7..2e880a7d50ad 100644
--- a/tests/ui/associated-types/defaults-specialization.stderr
+++ b/tests/ui/associated-types/defaults-specialization.stderr
@@ -1,21 +1,11 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/defaults-specialization.rs:3:38
-   |
-LL | #![feature(associated_type_defaults, specialization)]
-   |                                      ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0053]: method `make` has an incompatible type for trait
-  --> $DIR/defaults-specialization.rs:19:18
+  --> $DIR/defaults-specialization.rs:18:18
    |
 LL |     fn make() -> u8 { 0 }
    |                  ^^ expected associated type, found `u8`
    |
 note: type in trait
-  --> $DIR/defaults-specialization.rs:9:18
+  --> $DIR/defaults-specialization.rs:8:18
    |
 LL |     fn make() -> Self::Ty {
    |                  ^^^^^^^^
@@ -28,7 +18,7 @@ LL +     fn make() -> <A<T> as Tr>::Ty { 0 }
    |
 
 error[E0053]: method `make` has an incompatible type for trait
-  --> $DIR/defaults-specialization.rs:35:18
+  --> $DIR/defaults-specialization.rs:34:18
    |
 LL |     default type Ty = bool;
    |     --------------- associated type is `default` and may be overridden
@@ -37,7 +27,7 @@ LL |     fn make() -> bool { true }
    |                  ^^^^ expected associated type, found `bool`
    |
 note: type in trait
-  --> $DIR/defaults-specialization.rs:9:18
+  --> $DIR/defaults-specialization.rs:8:18
    |
 LL |     fn make() -> Self::Ty {
    |                  ^^^^^^^^
@@ -50,7 +40,7 @@ LL +     fn make() -> <B<T> as Tr>::Ty { true }
    |
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:10:9
+  --> $DIR/defaults-specialization.rs:9:9
    |
 LL |     type Ty = u8;
    |     ------- associated type defaults can't be assumed inside the trait defining them
@@ -64,7 +54,7 @@ LL |         0u8
                          found type `u8`
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:26:29
+  --> $DIR/defaults-specialization.rs:25:29
    |
 LL |     fn make() -> Self::Ty { 0u8 }
    |                  --------   ^^^ expected associated type, found `u8`
@@ -79,7 +69,7 @@ LL |     fn make() -> Self::Ty { 0u8 }
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:44:29
+  --> $DIR/defaults-specialization.rs:43:29
    |
 LL |     default type Ty = bool;
    |     --------------- associated type is `default` and may be overridden
@@ -95,7 +85,7 @@ LL |     fn make() -> Self::Ty { true }
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:87:32
+  --> $DIR/defaults-specialization.rs:86:32
    |
 LL |     let _: <B<()> as Tr>::Ty = 0u8;
    |            -----------------   ^^^ expected associated type, found `u8`
@@ -105,13 +95,13 @@ LL |     let _: <B<()> as Tr>::Ty = 0u8;
    = note: expected associated type `<B<()> as Tr>::Ty`
                          found type `u8`
 help: a method is available that returns `<B<()> as Tr>::Ty`
-  --> $DIR/defaults-specialization.rs:9:5
+  --> $DIR/defaults-specialization.rs:8:5
    |
 LL |     fn make() -> Self::Ty {
    |     ^^^^^^^^^^^^^^^^^^^^^ consider calling `Tr::make`
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:88:32
+  --> $DIR/defaults-specialization.rs:87:32
    |
 LL |     let _: <B<()> as Tr>::Ty = true;
    |            -----------------   ^^^^ expected associated type, found `bool`
@@ -121,7 +111,7 @@ LL |     let _: <B<()> as Tr>::Ty = true;
    = note: expected associated type `<B<()> as Tr>::Ty`
                          found type `bool`
 help: a method is available that returns `<B<()> as Tr>::Ty`
-  --> $DIR/defaults-specialization.rs:9:5
+  --> $DIR/defaults-specialization.rs:8:5
    |
 LL |     fn make() -> Self::Ty {
    |     ^^^^^^^^^^^^^^^^^^^^^ consider calling `Tr::make`
@@ -129,7 +119,7 @@ LL |     fn make() -> Self::Ty {
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:89:33
+  --> $DIR/defaults-specialization.rs:88:33
    |
 LL |     let _: <B2<()> as Tr>::Ty = 0u8;
    |            ------------------   ^^^ expected associated type, found `u8`
@@ -139,13 +129,13 @@ LL |     let _: <B2<()> as Tr>::Ty = 0u8;
    = note: expected associated type `<B2<()> as Tr>::Ty`
                          found type `u8`
 help: a method is available that returns `<B2<()> as Tr>::Ty`
-  --> $DIR/defaults-specialization.rs:9:5
+  --> $DIR/defaults-specialization.rs:8:5
    |
 LL |     fn make() -> Self::Ty {
    |     ^^^^^^^^^^^^^^^^^^^^^ consider calling `Tr::make`
 
 error[E0308]: mismatched types
-  --> $DIR/defaults-specialization.rs:90:33
+  --> $DIR/defaults-specialization.rs:89:33
    |
 LL |     let _: <B2<()> as Tr>::Ty = true;
    |            ------------------   ^^^^ expected associated type, found `bool`
@@ -155,14 +145,14 @@ LL |     let _: <B2<()> as Tr>::Ty = true;
    = note: expected associated type `<B2<()> as Tr>::Ty`
                          found type `bool`
 help: a method is available that returns `<B2<()> as Tr>::Ty`
-  --> $DIR/defaults-specialization.rs:9:5
+  --> $DIR/defaults-specialization.rs:8:5
    |
 LL |     fn make() -> Self::Ty {
    |     ^^^^^^^^^^^^^^^^^^^^^ consider calling `Tr::make`
    = note: the associated type `<B2<()> as Tr>::Ty` is defined as `bool` in the implementation, but the where-bound `B2<()>` shadows this definition
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
-error: aborting due to 9 previous errors; 1 warning emitted
+error: aborting due to 9 previous errors
 
 Some errors have detailed explanations: E0053, E0308.
 For more information about an error, try `rustc --explain E0053`.
diff --git a/tests/ui/async-await/async-drop/foreign-fundamental.rs b/tests/ui/async-await/async-drop/foreign-fundamental.rs
index 1c192fccd9f0..44be20449469 100644
--- a/tests/ui/async-await/async-drop/foreign-fundamental.rs
+++ b/tests/ui/async-await/async-drop/foreign-fundamental.rs
@@ -1,7 +1,6 @@
 //@ edition: 2018
 
 #![feature(async_drop)]
-//~^ WARN the feature `async_drop` is incomplete
 
 use std::future::AsyncDrop;
 use std::pin::Pin;
diff --git a/tests/ui/async-await/async-drop/foreign-fundamental.stderr b/tests/ui/async-await/async-drop/foreign-fundamental.stderr
index 7b52329ac99d..78bfdf66901a 100644
--- a/tests/ui/async-await/async-drop/foreign-fundamental.stderr
+++ b/tests/ui/async-await/async-drop/foreign-fundamental.stderr
@@ -1,24 +1,15 @@
-warning: the feature `async_drop` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/foreign-fundamental.rs:3:12
-   |
-LL | #![feature(async_drop)]
-   |            ^^^^^^^^^^
-   |
-   = note: see issue #126482 <https://github.com/rust-lang/rust/issues/126482> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0120]: the `AsyncDrop` trait may only be implemented for local structs, enums, and unions
-  --> $DIR/foreign-fundamental.rs:11:20
+  --> $DIR/foreign-fundamental.rs:10:20
    |
 LL | impl AsyncDrop for &Foo {
    |                    ^^^^ must be a struct, enum, or union in the current crate
 
 error[E0120]: the `AsyncDrop` trait may only be implemented for local structs, enums, and unions
-  --> $DIR/foreign-fundamental.rs:16:20
+  --> $DIR/foreign-fundamental.rs:15:20
    |
 LL | impl AsyncDrop for Pin<Foo> {
    |                    ^^^^^^^^ must be a struct, enum, or union in the current crate
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0120`.
diff --git a/tests/ui/async-await/dyn/mut-is-pointer-like.stderr b/tests/ui/async-await/dyn/mut-is-pointer-like.stderr
index 6689539ff453..0f390522620e 100644
--- a/tests/ui/async-await/dyn/mut-is-pointer-like.stderr
+++ b/tests/ui/async-await/dyn/mut-is-pointer-like.stderr
@@ -1,12 +1,3 @@
-warning: the feature `async_fn_in_dyn_trait` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/mut-is-pointer-like.rs:6:12
-   |
-LL | #![feature(async_fn_in_dyn_trait)]
-   |            ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #133119 <https://github.com/rust-lang/rust/issues/133119> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0038]: the trait `AsyncTrait` is not dyn compatible
   --> $DIR/mut-is-pointer-like.rs:35:29
    |
@@ -24,6 +15,6 @@ LL |     async fn async_dispatch(self: Pin<&mut Self>) -> Self::Output;
    |              ^^^^^^^^^^^^^^ ...because method `async_dispatch` is `async`
    = help: consider moving `async_dispatch` to another trait
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/async-await/dyn/works.stderr b/tests/ui/async-await/dyn/works.stderr
index 338479d8b70a..c7d0d14d70e7 100644
--- a/tests/ui/async-await/dyn/works.stderr
+++ b/tests/ui/async-await/dyn/works.stderr
@@ -1,12 +1,3 @@
-warning: the feature `async_fn_in_dyn_trait` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/works.rs:6:12
-   |
-LL | #![feature(async_fn_in_dyn_trait)]
-   |            ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #133119 <https://github.com/rust-lang/rust/issues/133119> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0038]: the trait `AsyncTrait` is not dyn compatible
   --> $DIR/works.rs:27:21
    |
@@ -24,6 +15,6 @@ LL |     async fn async_dispatch(&self);
    = help: consider moving `async_dispatch` to another trait
    = help: only type `&'static str` implements `AsyncTrait`; consider using it directly instead.
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/async-await/dyn/wrong-size.stderr b/tests/ui/async-await/dyn/wrong-size.stderr
index a465f91f62af..4835c173f0d7 100644
--- a/tests/ui/async-await/dyn/wrong-size.stderr
+++ b/tests/ui/async-await/dyn/wrong-size.stderr
@@ -1,12 +1,3 @@
-warning: the feature `async_fn_in_dyn_trait` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/wrong-size.rs:4:12
-   |
-LL | #![feature(async_fn_in_dyn_trait)]
-   |            ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #133119 <https://github.com/rust-lang/rust/issues/133119> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0038]: the trait `AsyncTrait` is not dyn compatible
   --> $DIR/wrong-size.rs:21:17
    |
@@ -24,6 +15,6 @@ LL |     async fn async_dispatch(&self);
    = help: consider moving `async_dispatch` to another trait
    = help: only type `&'static str` implements `AsyncTrait`; consider using it directly instead.
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/borrowck/generic_const_early_param.rs b/tests/ui/borrowck/generic_const_early_param.rs
index 0d07b6869f12..e5fab5919793 100644
--- a/tests/ui/borrowck/generic_const_early_param.rs
+++ b/tests/ui/borrowck/generic_const_early_param.rs
@@ -1,5 +1,4 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 struct DataWrapper<'static> {
     //~^ ERROR invalid lifetime parameter name: `'static`
diff --git a/tests/ui/borrowck/generic_const_early_param.stderr b/tests/ui/borrowck/generic_const_early_param.stderr
index 6447f92aba85..a9ee43838814 100644
--- a/tests/ui/borrowck/generic_const_early_param.stderr
+++ b/tests/ui/borrowck/generic_const_early_param.stderr
@@ -1,11 +1,11 @@
 error[E0262]: invalid lifetime parameter name: `'static`
-  --> $DIR/generic_const_early_param.rs:4:20
+  --> $DIR/generic_const_early_param.rs:3:20
    |
 LL | struct DataWrapper<'static> {
    |                    ^^^^^^^ 'static is a reserved lifetime name
 
 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/generic_const_early_param.rs:6:12
+  --> $DIR/generic_const_early_param.rs:5:12
    |
 LL |     data: &'a [u8; Self::SIZE],
    |            ^^ undeclared lifetime
@@ -16,7 +16,7 @@ LL | struct DataWrapper<'a, 'static> {
    |                    +++
 
 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/generic_const_early_param.rs:10:18
+  --> $DIR/generic_const_early_param.rs:9:18
    |
 LL | impl DataWrapper<'a> {
    |                  ^^ undeclared lifetime
@@ -26,16 +26,7 @@ help: consider introducing lifetime `'a` here
 LL | impl<'a> DataWrapper<'a> {
    |     ++++
 
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/generic_const_early_param.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0261, E0262.
 For more information about an error, try `rustc --explain E0261`.
diff --git a/tests/ui/closures/binder/const-bound.rs b/tests/ui/closures/binder/const-bound.rs
index 10d869fcc851..e6984ed6d559 100644
--- a/tests/ui/closures/binder/const-bound.rs
+++ b/tests/ui/closures/binder/const-bound.rs
@@ -1,5 +1,4 @@
 #![feature(closure_lifetime_binder, non_lifetime_binders)]
-//~^ WARN  is incomplete and may not be safe to use
 
 fn main()  {
     for<const N: i32> || -> () {};
diff --git a/tests/ui/closures/binder/const-bound.stderr b/tests/ui/closures/binder/const-bound.stderr
index b805879f7fab..a57788072b0b 100644
--- a/tests/ui/closures/binder/const-bound.stderr
+++ b/tests/ui/closures/binder/const-bound.stderr
@@ -1,23 +1,14 @@
 error: late-bound const parameters cannot be used currently
-  --> $DIR/const-bound.rs:5:15
+  --> $DIR/const-bound.rs:4:15
    |
 LL |     for<const N: i32> || -> () {};
    |               ^
 
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/const-bound.rs:1:37
-   |
-LL | #![feature(closure_lifetime_binder, non_lifetime_binders)]
-   |                                     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: late-bound const parameter not allowed on closures
-  --> $DIR/const-bound.rs:5:9
+  --> $DIR/const-bound.rs:4:9
    |
 LL |     for<const N: i32> || -> () {};
    |         ^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/closures/binder/type-bound-2.rs b/tests/ui/closures/binder/type-bound-2.rs
index f4edcdaa9ca9..064fbf975d45 100644
--- a/tests/ui/closures/binder/type-bound-2.rs
+++ b/tests/ui/closures/binder/type-bound-2.rs
@@ -1,5 +1,4 @@
 #![feature(closure_lifetime_binder, non_lifetime_binders)]
-//~^ WARN  is incomplete and may not be safe to use
 
 fn main() {
     for<T> || -> () {};
diff --git a/tests/ui/closures/binder/type-bound-2.stderr b/tests/ui/closures/binder/type-bound-2.stderr
index 6609b326f19a..6fd7d576dd70 100644
--- a/tests/ui/closures/binder/type-bound-2.stderr
+++ b/tests/ui/closures/binder/type-bound-2.stderr
@@ -1,17 +1,8 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-bound-2.rs:1:37
-   |
-LL | #![feature(closure_lifetime_binder, non_lifetime_binders)]
-   |                                     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: late-bound type parameter not allowed on closures
-  --> $DIR/type-bound-2.rs:5:9
+  --> $DIR/type-bound-2.rs:4:9
    |
 LL |     for<T> || -> () {};
    |         ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/binder/type-bound.rs b/tests/ui/closures/binder/type-bound.rs
index 59a3353f4965..9fc60b30167b 100644
--- a/tests/ui/closures/binder/type-bound.rs
+++ b/tests/ui/closures/binder/type-bound.rs
@@ -1,5 +1,4 @@
 #![feature(closure_lifetime_binder, non_lifetime_binders)]
-//~^ WARN  is incomplete and may not be safe to use
 
 fn main()  {
     for<T> || -> T {};
diff --git a/tests/ui/closures/binder/type-bound.stderr b/tests/ui/closures/binder/type-bound.stderr
index 22431130a5d4..11dc3288fe87 100644
--- a/tests/ui/closures/binder/type-bound.stderr
+++ b/tests/ui/closures/binder/type-bound.stderr
@@ -1,17 +1,8 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-bound.rs:1:37
-   |
-LL | #![feature(closure_lifetime_binder, non_lifetime_binders)]
-   |                                     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: late-bound type parameter not allowed on closures
-  --> $DIR/type-bound.rs:5:9
+  --> $DIR/type-bound.rs:4:9
    |
 LL |     for<T> || -> T {};
    |         ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/codegen/freeze-on-polymorphic-projection.rs b/tests/ui/codegen/freeze-on-polymorphic-projection.rs
index f382a3780fcf..4744fa580b37 100644
--- a/tests/ui/codegen/freeze-on-polymorphic-projection.rs
+++ b/tests/ui/codegen/freeze-on-polymorphic-projection.rs
@@ -2,7 +2,6 @@
 //@ compile-flags: -Copt-level=1 --crate-type=lib
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 pub unsafe trait Storage {
     type Handle;
diff --git a/tests/ui/codegen/freeze-on-polymorphic-projection.stderr b/tests/ui/codegen/freeze-on-polymorphic-projection.stderr
deleted file mode 100644
index 903cb2ff6aa9..000000000000
--- a/tests/ui/codegen/freeze-on-polymorphic-projection.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/freeze-on-polymorphic-projection.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.rs b/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.rs
index 7e53695f987e..a3dc9b5628fc 100644
--- a/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.rs
+++ b/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.rs
@@ -5,7 +5,6 @@
 // since they are using a different infcx which doesn't preserve the intercrate flag.
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Assoc {
     type Output;
diff --git a/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.stderr b/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.stderr
deleted file mode 100644
index 56eb21cd20f2..000000000000
--- a/tests/ui/coherence/coherence-doesnt-use-infcx-evaluate.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/coherence-doesnt-use-infcx-evaluate.rs:7:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.rs b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.rs
index d74d3a2a5235..7f0e5472c3c2 100644
--- a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.rs
+++ b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.rs
@@ -4,7 +4,6 @@
 //
 // No we expect to run into a more user-friendly cycle error instead.
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Trait<T> { type Assoc; }
 //~^ ERROR E0391
diff --git a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
index 9f813d6d5716..3d4d19197baf 100644
--- a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
+++ b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
@@ -1,27 +1,17 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/coherence-inherited-assoc-ty-cycle-err.rs:6:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0391]: cycle detected when building specialization graph of trait `Trait`
-  --> $DIR/coherence-inherited-assoc-ty-cycle-err.rs:9:1
+  --> $DIR/coherence-inherited-assoc-ty-cycle-err.rs:8:1
    |
 LL | trait Trait<T> { type Assoc; }
    | ^^^^^^^^^^^^^^
    |
    = note: ...which immediately requires building specialization graph of trait `Trait` again
 note: cycle used when coherence checking all impls of trait `Trait`
-  --> $DIR/coherence-inherited-assoc-ty-cycle-err.rs:9:1
+  --> $DIR/coherence-inherited-assoc-ty-cycle-err.rs:8:1
    |
 LL | trait Trait<T> { type Assoc; }
    | ^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/coherence/negative-coherence/regions-in-canonical.rs b/tests/ui/coherence/negative-coherence/regions-in-canonical.rs
index f0424e724344..ff3999f83f6d 100644
--- a/tests/ui/coherence/negative-coherence/regions-in-canonical.rs
+++ b/tests/ui/coherence/negative-coherence/regions-in-canonical.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(adt_const_params, unsized_const_params)]
-//~^ WARN the feature `unsized_const_params` is incomplete
 #![feature(with_negative_coherence, negative_impls)]
 
 pub trait A<const K: &'static str> {}
diff --git a/tests/ui/coherence/negative-coherence/regions-in-canonical.stderr b/tests/ui/coherence/negative-coherence/regions-in-canonical.stderr
deleted file mode 100644
index 720449152945..000000000000
--- a/tests/ui/coherence/negative-coherence/regions-in-canonical.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/regions-in-canonical.rs:3:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/consts/escaping-bound-var.rs b/tests/ui/consts/escaping-bound-var.rs
index a538d607d6ca..03162c74882d 100644
--- a/tests/ui/consts/escaping-bound-var.rs
+++ b/tests/ui/consts/escaping-bound-var.rs
@@ -1,5 +1,4 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 fn test<'a>(
     _: &'a (),
diff --git a/tests/ui/consts/escaping-bound-var.stderr b/tests/ui/consts/escaping-bound-var.stderr
index bb0d285f4d06..046c58bd23b3 100644
--- a/tests/ui/consts/escaping-bound-var.stderr
+++ b/tests/ui/consts/escaping-bound-var.stderr
@@ -1,14 +1,5 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/escaping-bound-var.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: cannot capture late-bound lifetime in constant
-  --> $DIR/escaping-bound-var.rs:7:13
+  --> $DIR/escaping-bound-var.rs:6:13
    |
 LL | fn test<'a>(
    |         -- lifetime defined here
@@ -17,7 +8,7 @@ LL |     let x: &'a ();
    |             ^^
 
 error[E0308]: mismatched types
-  --> $DIR/escaping-bound-var.rs:6:6
+  --> $DIR/escaping-bound-var.rs:5:6
    |
 LL |   fn test<'a>(
    |      ---- implicitly returns `()` as its body has no tail or `return` expression
@@ -33,6 +24,6 @@ LL | | }] {
     1
 }]`, found `()`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/issue-104396.rs b/tests/ui/consts/issue-104396.rs
index f44abc359d67..dc0789eaf655 100644
--- a/tests/ui/consts/issue-104396.rs
+++ b/tests/ui/consts/issue-104396.rs
@@ -2,7 +2,6 @@
 //@ check-pass
 
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 #[inline(always)]
 fn from_fn_1<const N: usize, F: FnMut(usize) -> f32>(mut f: F) -> [f32; N] {
diff --git a/tests/ui/consts/issue-104396.stderr b/tests/ui/consts/issue-104396.stderr
deleted file mode 100644
index 5856bee09a3f..000000000000
--- a/tests/ui/consts/issue-104396.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-104396.rs:4:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/consts/refs_check_const_eq-issue-88384.rs b/tests/ui/consts/refs_check_const_eq-issue-88384.rs
index 46cb62751717..506bec349eba 100644
--- a/tests/ui/consts/refs_check_const_eq-issue-88384.rs
+++ b/tests/ui/consts/refs_check_const_eq-issue-88384.rs
@@ -1,6 +1,5 @@
 #![feature(fn_traits)]
 #![feature(adt_const_params, unsized_const_params)]
-//~^ WARNING the feature `unsized_const_params` is incomplete
 
 #[derive(PartialEq, Eq)]
 struct CompileTimeSettings {
diff --git a/tests/ui/consts/refs_check_const_eq-issue-88384.stderr b/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
index 62c5c5276411..ac4cb059ea19 100644
--- a/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
+++ b/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
@@ -1,14 +1,5 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/refs_check_const_eq-issue-88384.rs:2:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0741]: `CompileTimeSettings` must implement `ConstParamTy` to be used as the type of a const generic parameter
-  --> $DIR/refs_check_const_eq-issue-88384.rs:10:21
+  --> $DIR/refs_check_const_eq-issue-88384.rs:9:21
    |
 LL | struct Foo<const T: CompileTimeSettings>;
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -20,7 +11,7 @@ LL | struct CompileTimeSettings {
    |
 
 error[E0741]: `CompileTimeSettings` must implement `ConstParamTy` to be used as the type of a const generic parameter
-  --> $DIR/refs_check_const_eq-issue-88384.rs:13:15
+  --> $DIR/refs_check_const_eq-issue-88384.rs:12:15
    |
 LL | impl<const T: CompileTimeSettings> Foo<T> {
    |               ^^^^^^^^^^^^^^^^^^^
@@ -31,6 +22,6 @@ LL + #[derive(ConstParamTy)]
 LL | struct CompileTimeSettings {
    |
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/consts/static-default-lifetime/generic-associated-const.rs b/tests/ui/consts/static-default-lifetime/generic-associated-const.rs
index 721920bd810c..8fabaa43f5a2 100644
--- a/tests/ui/consts/static-default-lifetime/generic-associated-const.rs
+++ b/tests/ui/consts/static-default-lifetime/generic-associated-const.rs
@@ -1,6 +1,5 @@
 #![deny(elided_lifetimes_in_associated_constant)]
 #![feature(generic_const_items)]
-//~^ WARN the feature `generic_const_items` is incomplete
 
 struct A;
 impl A {
diff --git a/tests/ui/consts/static-default-lifetime/generic-associated-const.stderr b/tests/ui/consts/static-default-lifetime/generic-associated-const.stderr
index 3680ef61e0c4..fe858d685f7f 100644
--- a/tests/ui/consts/static-default-lifetime/generic-associated-const.stderr
+++ b/tests/ui/consts/static-default-lifetime/generic-associated-const.stderr
@@ -1,5 +1,5 @@
 error[E0106]: missing lifetime specifier
-  --> $DIR/generic-associated-const.rs:15:29
+  --> $DIR/generic-associated-const.rs:14:29
    |
 LL |     const GAC_LIFETIME<'a>: &str = "";
    |                             ^ expected named lifetime parameter
@@ -9,23 +9,14 @@ help: consider using the `'a` lifetime
 LL |     const GAC_LIFETIME<'a>: &'a str = "";
    |                              ++
 
-warning: the feature `generic_const_items` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/generic-associated-const.rs:2:12
-   |
-LL | #![feature(generic_const_items)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #113521 <https://github.com/rust-lang/rust/issues/113521> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: `&` without an explicit lifetime name cannot be used here
-  --> $DIR/generic-associated-const.rs:8:29
+  --> $DIR/generic-associated-const.rs:7:29
    |
 LL |     const GAC_LIFETIME<'a>: &str = "";
    |                             ^
    |
 note: cannot automatically infer `'static` because of other lifetimes in scope
-  --> $DIR/generic-associated-const.rs:8:24
+  --> $DIR/generic-associated-const.rs:7:24
    |
 LL |     const GAC_LIFETIME<'a>: &str = "";
    |                        ^^
@@ -41,6 +32,6 @@ help: use the `'static` lifetime
 LL |     const GAC_LIFETIME<'a>: &'static str = "";
    |                              +++++++
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/consts/trait_specialization.rs b/tests/ui/consts/trait_specialization.rs
index 1360fabd1fe1..1ea56b5a4453 100644
--- a/tests/ui/consts/trait_specialization.rs
+++ b/tests/ui/consts/trait_specialization.rs
@@ -4,7 +4,7 @@
 // Tests that specialization does not cause optimizations running on polymorphic MIR to resolve
 // to a `default` implementation.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Marker {}
 
diff --git a/tests/ui/consts/trait_specialization.stderr b/tests/ui/consts/trait_specialization.stderr
deleted file mode 100644
index ce52cf17b89e..000000000000
--- a/tests/ui/consts/trait_specialization.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/trait_specialization.rs:7:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/contracts/incomplete-feature.rs b/tests/ui/contracts/incomplete-feature.rs
index f1351e2f87e3..c10774b251ab 100644
--- a/tests/ui/contracts/incomplete-feature.rs
+++ b/tests/ui/contracts/incomplete-feature.rs
@@ -4,6 +4,7 @@
 // This test specifically checks that the [incomplete_features] warning is
 // emitted when the `contracts` feature gate is enabled, so that it can be
 // marked as `expect`ed in other tests in order to reduce duplication.
+#![warn(incomplete_features)]
 #![feature(contracts)]
 //~^ WARN the feature `contracts` is incomplete and may not be safe to use and/or cause compiler crashes [incomplete_features]
 extern crate core;
diff --git a/tests/ui/contracts/incomplete-feature.stderr b/tests/ui/contracts/incomplete-feature.stderr
index 7683926df073..137b13fb834f 100644
--- a/tests/ui/contracts/incomplete-feature.stderr
+++ b/tests/ui/contracts/incomplete-feature.stderr
@@ -1,11 +1,15 @@
 warning: the feature `contracts` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/incomplete-feature.rs:7:12
+  --> $DIR/incomplete-feature.rs:8:12
    |
 LL | #![feature(contracts)]
    |            ^^^^^^^^^
    |
    = note: see issue #128044 <https://github.com/rust-lang/rust/issues/128044> for more information
-   = note: `#[warn(incomplete_features)]` on by default
+note: the lint level is defined here
+  --> $DIR/incomplete-feature.rs:7:9
+   |
+LL | #![warn(incomplete_features)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 warning: 1 warning emitted
 
diff --git a/tests/ui/error-codes/E0520.rs b/tests/ui/error-codes/E0520.rs
index ead78b7ffa2c..b746ca63590e 100644
--- a/tests/ui/error-codes/E0520.rs
+++ b/tests/ui/error-codes/E0520.rs
@@ -1,5 +1,4 @@
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait SpaceLlama {
     fn fly(&self);
diff --git a/tests/ui/error-codes/E0520.stderr b/tests/ui/error-codes/E0520.stderr
index 83319203023f..c47b3e77c77a 100644
--- a/tests/ui/error-codes/E0520.stderr
+++ b/tests/ui/error-codes/E0520.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/E0520.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0520]: `fly` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/E0520.rs:17:5
+  --> $DIR/E0520.rs:16:5
    |
 LL | impl<T: Clone> SpaceLlama for T {
    | ------------------------------- parent `impl` is here
@@ -19,6 +9,6 @@ LL |     default fn fly(&self) {}
    |
    = note: to specialize, `fly` in the parent `impl` must be marked `default`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/error-codes/E0771.rs b/tests/ui/error-codes/E0771.rs
index a932c5ef9815..6d86d4a54e78 100644
--- a/tests/ui/error-codes/E0771.rs
+++ b/tests/ui/error-codes/E0771.rs
@@ -1,5 +1,4 @@
 #![feature(adt_const_params, unsized_const_params)]
-//~^ WARN the feature `unsized_const_params` is incomplete
 
 fn function_with_str<'a, const STRING: &'a str>() {} //~ ERROR E0770
 
diff --git a/tests/ui/error-codes/E0771.stderr b/tests/ui/error-codes/E0771.stderr
index dfeaa347941c..93782079d06f 100644
--- a/tests/ui/error-codes/E0771.stderr
+++ b/tests/ui/error-codes/E0771.stderr
@@ -1,18 +1,9 @@
 error[E0770]: the type of const parameters must not depend on other generic parameters
-  --> $DIR/E0771.rs:4:41
+  --> $DIR/E0771.rs:3:41
    |
 LL | fn function_with_str<'a, const STRING: &'a str>() {}
    |                                         ^^ the type must not depend on the parameter `'a`
 
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/E0771.rs:1:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/feature-gates/feature-gate-effective-target-features.default.stderr b/tests/ui/feature-gates/feature-gate-effective-target-features.default.stderr
index 34a56fe342e2..e699c5d77b42 100644
--- a/tests/ui/feature-gates/feature-gate-effective-target-features.default.stderr
+++ b/tests/ui/feature-gates/feature-gate-effective-target-features.default.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the `#[force_target_feature]` attribute is an experimental feature
-  --> $DIR/feature-gate-effective-target-features.rs:13:5
+  --> $DIR/feature-gate-effective-target-features.rs:14:5
    |
 LL |     #[unsafe(force_target_feature(enable = "avx2"))]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     #[unsafe(force_target_feature(enable = "avx2"))]
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: `#[target_feature(..)]` cannot be applied to safe trait method
-  --> $DIR/feature-gate-effective-target-features.rs:21:5
+  --> $DIR/feature-gate-effective-target-features.rs:22:5
    |
 LL |     #[target_feature(enable = "avx2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be applied to safe trait method
@@ -18,13 +18,13 @@ LL |     fn foo(&self) {}
    |     ------------- not an `unsafe` function
 
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/feature-gate-effective-target-features.rs:23:5
+  --> $DIR/feature-gate-effective-target-features.rs:24:5
    |
 LL |     fn foo(&self) {}
    |     ^^^^^^^^^^^^^ expected safe fn, found unsafe fn
    |
 note: type in trait
-  --> $DIR/feature-gate-effective-target-features.rs:7:5
+  --> $DIR/feature-gate-effective-target-features.rs:8:5
    |
 LL |     fn foo(&self);
    |     ^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-effective-target-features.feature.stderr b/tests/ui/feature-gates/feature-gate-effective-target-features.feature.stderr
index d51956fa4d2b..bf9f5d73e057 100644
--- a/tests/ui/feature-gates/feature-gate-effective-target-features.feature.stderr
+++ b/tests/ui/feature-gates/feature-gate-effective-target-features.feature.stderr
@@ -1,14 +1,18 @@
 warning: the feature `effective_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/feature-gate-effective-target-features.rs:3:30
+  --> $DIR/feature-gate-effective-target-features.rs:4:30
    |
 LL | #![cfg_attr(feature, feature(effective_target_features))]
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #143352 <https://github.com/rust-lang/rust/issues/143352> for more information
-   = note: `#[warn(incomplete_features)]` on by default
+note: the lint level is defined here
+  --> $DIR/feature-gate-effective-target-features.rs:3:9
+   |
+LL | #![warn(incomplete_features)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: `#[target_feature(..)]` cannot be applied to safe trait method
-  --> $DIR/feature-gate-effective-target-features.rs:21:5
+  --> $DIR/feature-gate-effective-target-features.rs:22:5
    |
 LL |     #[target_feature(enable = "avx2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be applied to safe trait method
@@ -17,13 +21,13 @@ LL |     fn foo(&self) {}
    |     ------------- not an `unsafe` function
 
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/feature-gate-effective-target-features.rs:23:5
+  --> $DIR/feature-gate-effective-target-features.rs:24:5
    |
 LL |     fn foo(&self) {}
    |     ^^^^^^^^^^^^^ expected safe fn, found unsafe fn
    |
 note: type in trait
-  --> $DIR/feature-gate-effective-target-features.rs:7:5
+  --> $DIR/feature-gate-effective-target-features.rs:8:5
    |
 LL |     fn foo(&self);
    |     ^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-effective-target-features.rs b/tests/ui/feature-gates/feature-gate-effective-target-features.rs
index d383897e4382..a8be61167aa2 100644
--- a/tests/ui/feature-gates/feature-gate-effective-target-features.rs
+++ b/tests/ui/feature-gates/feature-gate-effective-target-features.rs
@@ -1,5 +1,6 @@
 //@ revisions: default feature
 //@ only-x86_64
+#![warn(incomplete_features)]
 #![cfg_attr(feature, feature(effective_target_features))]
 //[feature]~^ WARN the feature `effective_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
 
diff --git a/tests/ui/feature-gates/feature-gate-unsafe_fields.rs b/tests/ui/feature-gates/feature-gate-unsafe_fields.rs
index 2b0bbaa08357..27e8b5126f80 100644
--- a/tests/ui/feature-gates/feature-gate-unsafe_fields.rs
+++ b/tests/ui/feature-gates/feature-gate-unsafe_fields.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: --crate-type=lib
 //@ revisions: with_gate without_gate
 //@ [with_gate] check-pass
-
+#![warn(incomplete_features)]
 #![cfg_attr(with_gate, feature(unsafe_fields))] //[with_gate]~ WARNING
 
 #[cfg(false)]
diff --git a/tests/ui/feature-gates/feature-gate-unsafe_fields.with_gate.stderr b/tests/ui/feature-gates/feature-gate-unsafe_fields.with_gate.stderr
index a7deeb057d86..4220930d4668 100644
--- a/tests/ui/feature-gates/feature-gate-unsafe_fields.with_gate.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsafe_fields.with_gate.stderr
@@ -5,7 +5,11 @@ LL | #![cfg_attr(with_gate, feature(unsafe_fields))]
    |                                ^^^^^^^^^^^^^
    |
    = note: see issue #132922 <https://github.com/rust-lang/rust/issues/132922> for more information
-   = note: `#[warn(incomplete_features)]` on by default
+note: the lint level is defined here
+  --> $DIR/feature-gate-unsafe_fields.rs:4:9
+   |
+LL | #![warn(incomplete_features)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 warning: 1 warning emitted
 
diff --git a/tests/ui/generic-associated-types/issue-87429-specialization.rs b/tests/ui/generic-associated-types/issue-87429-specialization.rs
index 87e91162a863..4a1e6aa6b332 100644
--- a/tests/ui/generic-associated-types/issue-87429-specialization.rs
+++ b/tests/ui/generic-associated-types/issue-87429-specialization.rs
@@ -1,7 +1,6 @@
 //@ check-fail
 
 #![feature(specialization)]
-//~^ WARN incomplete
 
 trait Family {
     type Member<'a>: for<'b> PartialEq<Self::Member<'b>>;
diff --git a/tests/ui/generic-associated-types/issue-87429-specialization.stderr b/tests/ui/generic-associated-types/issue-87429-specialization.stderr
index 44f871e71c57..dbe97bdb7431 100644
--- a/tests/ui/generic-associated-types/issue-87429-specialization.stderr
+++ b/tests/ui/generic-associated-types/issue-87429-specialization.stderr
@@ -1,22 +1,12 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-87429-specialization.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: can't compare `Foo` with `Foo`
-  --> $DIR/issue-87429-specialization.rs:20:31
+  --> $DIR/issue-87429-specialization.rs:19:31
    |
 LL |     default type Member<'a> = Foo;
    |                               ^^^ no implementation for `Foo == Foo`
    |
    = help: the trait `PartialEq` is not implemented for `Foo`
 note: required by a bound in `Family::Member`
-  --> $DIR/issue-87429-specialization.rs:7:22
+  --> $DIR/issue-87429-specialization.rs:6:22
    |
 LL |     type Member<'a>: for<'b> PartialEq<Self::Member<'b>>;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Family::Member`
@@ -26,6 +16,6 @@ LL + #[derive(PartialEq)]
 LL | struct Foo;
    |
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.rs b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.rs
index d6490d5b4f97..dc47eba2b3c6 100644
--- a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.rs
+++ b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.rs
@@ -1,5 +1,6 @@
 //@ compile-flags: --crate-type=lib
 //@ revisions: with_gate without_gate
+#![warn(incomplete_features)]
 #![cfg_attr(with_gate, feature(impl_restriction))]
 //[with_gate]~^ WARN the feature `impl_restriction` is incomplete and may not be safe to use and/or cause compiler crashes
 #![feature(auto_traits, const_trait_impl)]
diff --git a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.with_gate.stderr b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.with_gate.stderr
index ad183b23e013..834cc99f0755 100644
--- a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.with_gate.stderr
+++ b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.with_gate.stderr
@@ -1,5 +1,5 @@
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:8:14
+  --> $DIR/recover-incorrect-impl-restriction.rs:9:14
    |
 LL |     pub impl(crate::foo) trait Baz {}
    |              ^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |     pub impl(in crate::foo) trait Baz {}
    |              ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:10:21
+  --> $DIR/recover-incorrect-impl-restriction.rs:11:21
    |
 LL |     pub unsafe impl(crate::foo) trait BazUnsafe {}
    |                     ^^^^^^^^^^
@@ -31,7 +31,7 @@ LL |     pub unsafe impl(in crate::foo) trait BazUnsafe {}
    |                     ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:12:19
+  --> $DIR/recover-incorrect-impl-restriction.rs:13:19
    |
 LL |     pub auto impl(crate::foo) trait BazAuto {}
    |                   ^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |     pub auto impl(in crate::foo) trait BazAuto {}
    |                   ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:14:20
+  --> $DIR/recover-incorrect-impl-restriction.rs:15:20
    |
 LL |     pub const impl(crate::foo) trait BazConst {}
    |                    ^^^^^^^^^^
@@ -63,7 +63,7 @@ LL |     pub const impl(in crate::foo) trait BazConst {}
    |                    ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:16:27
+  --> $DIR/recover-incorrect-impl-restriction.rs:17:27
    |
 LL |     pub const unsafe impl(crate::foo) trait BazConstUnsafe {}
    |                           ^^^^^^^^^^
@@ -79,7 +79,7 @@ LL |     pub const unsafe impl(in crate::foo) trait BazConstUnsafe {}
    |                           ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:18:26
+  --> $DIR/recover-incorrect-impl-restriction.rs:19:26
    |
 LL |     pub unsafe auto impl(crate::foo) trait BazUnsafeAuto {}
    |                          ^^^^^^^^^^
@@ -95,13 +95,17 @@ LL |     pub unsafe auto impl(in crate::foo) trait BazUnsafeAuto {}
    |                          ++
 
 warning: the feature `impl_restriction` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/recover-incorrect-impl-restriction.rs:3:32
+  --> $DIR/recover-incorrect-impl-restriction.rs:4:32
    |
 LL | #![cfg_attr(with_gate, feature(impl_restriction))]
    |                                ^^^^^^^^^^^^^^^^
    |
    = note: see issue #105077 <https://github.com/rust-lang/rust/issues/105077> for more information
-   = note: `#[warn(incomplete_features)]` on by default
+note: the lint level is defined here
+  --> $DIR/recover-incorrect-impl-restriction.rs:3:9
+   |
+LL | #![warn(incomplete_features)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 6 previous errors; 1 warning emitted
 
diff --git a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.without_gate.stderr b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.without_gate.stderr
index d949172ffb45..223a7cd47cfb 100644
--- a/tests/ui/impl-restriction/recover-incorrect-impl-restriction.without_gate.stderr
+++ b/tests/ui/impl-restriction/recover-incorrect-impl-restriction.without_gate.stderr
@@ -1,5 +1,5 @@
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:8:14
+  --> $DIR/recover-incorrect-impl-restriction.rs:9:14
    |
 LL |     pub impl(crate::foo) trait Baz {}
    |              ^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |     pub impl(in crate::foo) trait Baz {}
    |              ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:10:21
+  --> $DIR/recover-incorrect-impl-restriction.rs:11:21
    |
 LL |     pub unsafe impl(crate::foo) trait BazUnsafe {}
    |                     ^^^^^^^^^^
@@ -31,7 +31,7 @@ LL |     pub unsafe impl(in crate::foo) trait BazUnsafe {}
    |                     ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:12:19
+  --> $DIR/recover-incorrect-impl-restriction.rs:13:19
    |
 LL |     pub auto impl(crate::foo) trait BazAuto {}
    |                   ^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |     pub auto impl(in crate::foo) trait BazAuto {}
    |                   ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:14:20
+  --> $DIR/recover-incorrect-impl-restriction.rs:15:20
    |
 LL |     pub const impl(crate::foo) trait BazConst {}
    |                    ^^^^^^^^^^
@@ -63,7 +63,7 @@ LL |     pub const impl(in crate::foo) trait BazConst {}
    |                    ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:16:27
+  --> $DIR/recover-incorrect-impl-restriction.rs:17:27
    |
 LL |     pub const unsafe impl(crate::foo) trait BazConstUnsafe {}
    |                           ^^^^^^^^^^
@@ -79,7 +79,7 @@ LL |     pub const unsafe impl(in crate::foo) trait BazConstUnsafe {}
    |                           ++
 
 error: incorrect `impl` restriction
-  --> $DIR/recover-incorrect-impl-restriction.rs:18:26
+  --> $DIR/recover-incorrect-impl-restriction.rs:19:26
    |
 LL |     pub unsafe auto impl(crate::foo) trait BazUnsafeAuto {}
    |                          ^^^^^^^^^^
@@ -95,7 +95,7 @@ LL |     pub unsafe auto impl(in crate::foo) trait BazUnsafeAuto {}
    |                          ++
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:8:9
+  --> $DIR/recover-incorrect-impl-restriction.rs:9:9
    |
 LL |     pub impl(crate::foo) trait Baz {}
    |         ^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     pub impl(crate::foo) trait Baz {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:10:16
+  --> $DIR/recover-incorrect-impl-restriction.rs:11:16
    |
 LL |     pub unsafe impl(crate::foo) trait BazUnsafe {}
    |                ^^^^^^^^^^^^^^^^
@@ -115,7 +115,7 @@ LL |     pub unsafe impl(crate::foo) trait BazUnsafe {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:12:14
+  --> $DIR/recover-incorrect-impl-restriction.rs:13:14
    |
 LL |     pub auto impl(crate::foo) trait BazAuto {}
    |              ^^^^^^^^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     pub auto impl(crate::foo) trait BazAuto {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:14:15
+  --> $DIR/recover-incorrect-impl-restriction.rs:15:15
    |
 LL |     pub const impl(crate::foo) trait BazConst {}
    |               ^^^^^^^^^^^^^^^^
@@ -135,7 +135,7 @@ LL |     pub const impl(crate::foo) trait BazConst {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:16:22
+  --> $DIR/recover-incorrect-impl-restriction.rs:17:22
    |
 LL |     pub const unsafe impl(crate::foo) trait BazConstUnsafe {}
    |                      ^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     pub const unsafe impl(crate::foo) trait BazConstUnsafe {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/recover-incorrect-impl-restriction.rs:18:21
+  --> $DIR/recover-incorrect-impl-restriction.rs:19:21
    |
 LL |     pub unsafe auto impl(crate::foo) trait BazUnsafeAuto {}
    |                     ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.rs b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.rs
index 62622e1d5586..ce36a49b145b 100644
--- a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.rs
+++ b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.rs
@@ -1,5 +1,6 @@
 //@ compile-flags: --crate-type=lib
 //@ revisions: with_gate without_gate
+#![warn(incomplete_features)]
 #![cfg_attr(with_gate, feature(impl_restriction))]
 //[with_gate]~^ WARN the feature `impl_restriction` is incomplete and may not be safe to use and/or cause compiler crashes
 #![feature(auto_traits, const_trait_impl, trait_alias)]
diff --git a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.with_gate.stderr b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.with_gate.stderr
index 70287aca42aa..7be030052df5 100644
--- a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.with_gate.stderr
+++ b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.with_gate.stderr
@@ -1,83 +1,87 @@
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:7:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:8:1
    |
 LL | impl(crate) trait Alias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `auto`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:9:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:10:1
    |
 LL | auto impl(in crate) trait AutoAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `auto`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:9:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:10:1
    |
 LL | auto impl(in crate) trait AutoAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:12:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:13:1
    |
 LL | unsafe impl(self) trait UnsafeAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:12:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:13:1
    |
 LL | unsafe impl(self) trait UnsafeAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:15:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:16:1
    |
 LL | const impl(in self) trait ConstAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:19:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:20:5
    |
 LL |     impl(super) trait InnerAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:21:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:22:5
    |
 LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:21:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:22:5
    |
 LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `auto`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `auto`
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 warning: the feature `impl_restriction` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:3:32
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:4:32
    |
 LL | #![cfg_attr(with_gate, feature(impl_restriction))]
    |                                ^^^^^^^^^^^^^^^^
    |
    = note: see issue #105077 <https://github.com/rust-lang/rust/issues/105077> for more information
-   = note: `#[warn(incomplete_features)]` on by default
+note: the lint level is defined here
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:3:9
+   |
+LL | #![warn(incomplete_features)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 12 previous errors; 1 warning emitted
 
diff --git a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.without_gate.stderr b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.without_gate.stderr
index 7bff90396708..c99bfce5da2c 100644
--- a/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.without_gate.stderr
+++ b/tests/ui/impl-restriction/trait-alias-cannot-be-impl-restricted.without_gate.stderr
@@ -1,77 +1,77 @@
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:7:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:8:1
    |
 LL | impl(crate) trait Alias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `auto`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:9:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:10:1
    |
 LL | auto impl(in crate) trait AutoAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `auto`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:9:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:10:1
    |
 LL | auto impl(in crate) trait AutoAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:12:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:13:1
    |
 LL | unsafe impl(self) trait UnsafeAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:12:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:13:1
    |
 LL | unsafe impl(self) trait UnsafeAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:15:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:16:1
    |
 LL | const impl(in self) trait ConstAlias = Copy;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:19:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:20:5
    |
 LL |     impl(super) trait InnerAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:21:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:22:5
    |
 LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:21:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:22:5
    |
 LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error: trait aliases cannot be `auto`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `auto`
 
 error: trait aliases cannot be `unsafe`
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `unsafe`
 
 error: trait aliases cannot be `impl`-restricted
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:5
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait aliases cannot be `impl`-restricted
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:7:1
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:8:1
    |
 LL | impl(crate) trait Alias = Copy;
    | ^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL | impl(crate) trait Alias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:9:6
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:10:6
    |
 LL | auto impl(in crate) trait AutoAlias = Copy;
    |      ^^^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL | auto impl(in crate) trait AutoAlias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:12:8
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:13:8
    |
 LL | unsafe impl(self) trait UnsafeAlias = Copy;
    |        ^^^^^^^^^^
@@ -101,7 +101,7 @@ LL | unsafe impl(self) trait UnsafeAlias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:15:7
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:16:7
    |
 LL | const impl(in self) trait ConstAlias = Copy;
    |       ^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL | const impl(in self) trait ConstAlias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:19:5
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:20:5
    |
 LL |     impl(super) trait InnerAlias = Copy;
    |     ^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     impl(super) trait InnerAlias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:21:18
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:22:18
    |
 LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    |                  ^^^^^^^^^^^^^^^^^^^
@@ -131,7 +131,7 @@ LL |     const unsafe impl(in crate::foo) trait InnerConstUnsafeAlias = Copy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `impl` restrictions are experimental
-  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:24:17
+  --> $DIR/trait-alias-cannot-be-impl-restricted.rs:25:17
    |
 LL |     unsafe auto impl(in crate::foo) trait InnerUnsafeAutoAlias = Copy;
    |                 ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/impl-trait/equality-rpass.rs b/tests/ui/impl-trait/equality-rpass.rs
index da750f4ef1ba..d5cac80a08d7 100644
--- a/tests/ui/impl-trait/equality-rpass.rs
+++ b/tests/ui/impl-trait/equality-rpass.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo: std::fmt::Debug + Eq {}
 
diff --git a/tests/ui/impl-trait/equality-rpass.stderr b/tests/ui/impl-trait/equality-rpass.stderr
deleted file mode 100644
index bde8362fdf81..000000000000
--- a/tests/ui/impl-trait/equality-rpass.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/equality-rpass.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/impl-trait/equality.rs b/tests/ui/impl-trait/equality.rs
index 07fc4a5d41ac..4a315639bde9 100644
--- a/tests/ui/impl-trait/equality.rs
+++ b/tests/ui/impl-trait/equality.rs
@@ -1,6 +1,6 @@
 //@ dont-require-annotations: NOTE
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo: Copy + ToString {}
 
diff --git a/tests/ui/impl-trait/equality.stderr b/tests/ui/impl-trait/equality.stderr
index 7f965b9609a9..3c765da66bdc 100644
--- a/tests/ui/impl-trait/equality.stderr
+++ b/tests/ui/impl-trait/equality.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/equality.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/equality.rs:17:5
    |
@@ -48,7 +38,7 @@ help: the following other types implement trait `Add<Rhs>`
    = note: `&u32` implements `Add`
    = note: this error originates in the macro `add_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0277, E0308.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/equality2.rs b/tests/ui/impl-trait/equality2.rs
index 808c600ecb7b..44d356e0e262 100644
--- a/tests/ui/impl-trait/equality2.rs
+++ b/tests/ui/impl-trait/equality2.rs
@@ -1,6 +1,6 @@
 //@ dont-require-annotations: NOTE
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo: Copy + ToString {}
 
diff --git a/tests/ui/impl-trait/equality2.stderr b/tests/ui/impl-trait/equality2.stderr
index 2fa7eb288ff8..ce0ccea20afb 100644
--- a/tests/ui/impl-trait/equality2.stderr
+++ b/tests/ui/impl-trait/equality2.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/equality2.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/equality2.rs:27:18
    |
@@ -72,6 +62,6 @@ LL |          x.0);
               found opaque type `impl Foo` (`u32`)
    = note: distinct uses of `impl Trait` result in different opaque types
 
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.rs b/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.rs
index 351cdad4ee11..ba6dfd4dfa8f 100644
--- a/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.rs
+++ b/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -Znext-solver
 
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete
 
 trait Foo {}
 
diff --git a/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.stderr b/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.stderr
index a95670ced867..03c5d7a56769 100644
--- a/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.stderr
+++ b/tests/ui/impl-trait/in-trait/alias-bounds-when-not-wf.stderr
@@ -1,53 +1,44 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/alias-bounds-when-not-wf.rs:3:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `usize: Foo` is not satisfied
-  --> $DIR/alias-bounds-when-not-wf.rs:16:15
+  --> $DIR/alias-bounds-when-not-wf.rs:15:15
    |
 LL | fn hello(_: W<A<usize>>) {}
    |               ^^^^^^^^ the trait `Foo` is not implemented for `usize`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/alias-bounds-when-not-wf.rs:6:1
+  --> $DIR/alias-bounds-when-not-wf.rs:5:1
    |
 LL | trait Foo {}
    | ^^^^^^^^^
 note: required by a bound in `A`
-  --> $DIR/alias-bounds-when-not-wf.rs:8:11
+  --> $DIR/alias-bounds-when-not-wf.rs:7:11
    |
 LL | type A<T: Foo> = T;
    |           ^^^ required by this bound in `A`
 
 error[E0277]: the trait bound `usize: Foo` is not satisfied
-  --> $DIR/alias-bounds-when-not-wf.rs:16:10
+  --> $DIR/alias-bounds-when-not-wf.rs:15:10
    |
 LL | fn hello(_: W<A<usize>>) {}
    |          ^ the trait `Foo` is not implemented for `usize`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/alias-bounds-when-not-wf.rs:6:1
+  --> $DIR/alias-bounds-when-not-wf.rs:5:1
    |
 LL | trait Foo {}
    | ^^^^^^^^^
 
 error[E0277]: the trait bound `usize: Foo` is not satisfied
-  --> $DIR/alias-bounds-when-not-wf.rs:16:1
+  --> $DIR/alias-bounds-when-not-wf.rs:15:1
    |
 LL | fn hello(_: W<A<usize>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `usize`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/alias-bounds-when-not-wf.rs:6:1
+  --> $DIR/alias-bounds-when-not-wf.rs:5:1
    |
 LL | trait Foo {}
    | ^^^^^^^^^
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/layout/gce-rigid-const-in-array-len.rs b/tests/ui/layout/gce-rigid-const-in-array-len.rs
index 8e57907a2c5e..d8cc415ba1c2 100644
--- a/tests/ui/layout/gce-rigid-const-in-array-len.rs
+++ b/tests/ui/layout/gce-rigid-const-in-array-len.rs
@@ -12,7 +12,7 @@
 //! constant.
 
 #![feature(rustc_attrs)]
-#![feature(generic_const_exprs)] //~ WARNING: the feature `generic_const_exprs` is incomplete
+#![feature(generic_const_exprs)]
 #![feature(trivial_bounds)]
 
 #![crate_type = "lib"]
diff --git a/tests/ui/layout/gce-rigid-const-in-array-len.stderr b/tests/ui/layout/gce-rigid-const-in-array-len.stderr
index 6149debdfe88..903856315978 100644
--- a/tests/ui/layout/gce-rigid-const-in-array-len.stderr
+++ b/tests/ui/layout/gce-rigid-const-in-array-len.stderr
@@ -1,17 +1,8 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/gce-rigid-const-in-array-len.rs:15:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: the type `[u8; <u8 as A>::B]` has an unknown layout
   --> $DIR/gce-rigid-const-in-array-len.rs:25:1
    |
 LL | struct S([u8; <u8 as A>::B])
    | ^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lazy-type-alias/bad-lazy-type-alias.rs b/tests/ui/lazy-type-alias/bad-lazy-type-alias.rs
index 6ded9118700c..e9e7de84a7a4 100644
--- a/tests/ui/lazy-type-alias/bad-lazy-type-alias.rs
+++ b/tests/ui/lazy-type-alias/bad-lazy-type-alias.rs
@@ -1,7 +1,6 @@
 // regression test for #127351
 
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete
 
 type ExplicitTypeOutlives<T> = T;
 
diff --git a/tests/ui/lazy-type-alias/bad-lazy-type-alias.stderr b/tests/ui/lazy-type-alias/bad-lazy-type-alias.stderr
index 3a5ded60241b..7aa34a22f736 100644
--- a/tests/ui/lazy-type-alias/bad-lazy-type-alias.stderr
+++ b/tests/ui/lazy-type-alias/bad-lazy-type-alias.stderr
@@ -1,20 +1,11 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/bad-lazy-type-alias.rs:3:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0107]: missing generics for type alias `ExplicitTypeOutlives`
-  --> $DIR/bad-lazy-type-alias.rs:9:24
+  --> $DIR/bad-lazy-type-alias.rs:8:24
    |
 LL |     _significant_drop: ExplicitTypeOutlives,
    |                        ^^^^^^^^^^^^^^^^^^^^ expected 1 generic argument
    |
 note: type alias defined here, with 1 generic parameter: `T`
-  --> $DIR/bad-lazy-type-alias.rs:6:6
+  --> $DIR/bad-lazy-type-alias.rs:5:6
    |
 LL | type ExplicitTypeOutlives<T> = T;
    |      ^^^^^^^^^^^^^^^^^^^^ -
@@ -23,6 +14,6 @@ help: add missing generic argument
 LL |     _significant_drop: ExplicitTypeOutlives<T>,
    |                                            +++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/lazy-type-alias/coerce-behind-lazy.current.stderr b/tests/ui/lazy-type-alias/coerce-behind-lazy.current.stderr
deleted file mode 100644
index 78dd05b78af1..000000000000
--- a/tests/ui/lazy-type-alias/coerce-behind-lazy.current.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/coerce-behind-lazy.rs:6:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/lazy-type-alias/coerce-behind-lazy.next.stderr b/tests/ui/lazy-type-alias/coerce-behind-lazy.next.stderr
deleted file mode 100644
index 78dd05b78af1..000000000000
--- a/tests/ui/lazy-type-alias/coerce-behind-lazy.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/coerce-behind-lazy.rs:6:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/lazy-type-alias/coerce-behind-lazy.rs b/tests/ui/lazy-type-alias/coerce-behind-lazy.rs
index 7873ff46b66f..a69e39b02b32 100644
--- a/tests/ui/lazy-type-alias/coerce-behind-lazy.rs
+++ b/tests/ui/lazy-type-alias/coerce-behind-lazy.rs
@@ -4,7 +4,6 @@
 //@[next] compile-flags: -Znext-solver
 
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete
 
 use std::any::Any;
 
diff --git a/tests/ui/lazy-type-alias/enum-variant.rs b/tests/ui/lazy-type-alias/enum-variant.rs
index d9b7dff26647..236e1933a8a9 100644
--- a/tests/ui/lazy-type-alias/enum-variant.rs
+++ b/tests/ui/lazy-type-alias/enum-variant.rs
@@ -2,7 +2,6 @@
 //@ check-pass
 
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete and may not be safe to use
 
 enum Enum {
     Unit,
diff --git a/tests/ui/lazy-type-alias/enum-variant.stderr b/tests/ui/lazy-type-alias/enum-variant.stderr
deleted file mode 100644
index 4360db917783..000000000000
--- a/tests/ui/lazy-type-alias/enum-variant.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/enum-variant.rs:4:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.rs b/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.rs
index a9f0cdae1f6c..cd2eaa5337e8 100644
--- a/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.rs
+++ b/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.rs
@@ -1,7 +1,7 @@
 //@ run-pass
 
 #![feature(marker_trait_attr)]
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 #[marker]
 trait MyMarker {}
diff --git a/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.stderr b/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.stderr
deleted file mode 100644
index 649e58915d0a..000000000000
--- a/tests/ui/marker_trait_attr/overlap-doesnt-conflict-with-specialization.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-doesnt-conflict-with-specialization.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/parser/assoc/assoc-static-semantic-fail.rs b/tests/ui/parser/assoc/assoc-static-semantic-fail.rs
index 403160f1253a..de0cee6ff996 100644
--- a/tests/ui/parser/assoc/assoc-static-semantic-fail.rs
+++ b/tests/ui/parser/assoc/assoc-static-semantic-fail.rs
@@ -1,7 +1,6 @@
 // Semantically, we do not allow e.g., `static X: u8 = 0;` as an associated item.
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 fn main() {}
 
diff --git a/tests/ui/parser/assoc/assoc-static-semantic-fail.stderr b/tests/ui/parser/assoc/assoc-static-semantic-fail.stderr
index cc21df77353f..4ac3528a6d42 100644
--- a/tests/ui/parser/assoc/assoc-static-semantic-fail.stderr
+++ b/tests/ui/parser/assoc/assoc-static-semantic-fail.stderr
@@ -1,17 +1,17 @@
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:10:5
+  --> $DIR/assoc-static-semantic-fail.rs:9:5
    |
 LL |     static IA: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:12:5
+  --> $DIR/assoc-static-semantic-fail.rs:11:5
    |
 LL |     static IB: u8;
    |     ^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:15:5
+  --> $DIR/assoc-static-semantic-fail.rs:14:5
    |
 LL |     default static IC: u8 = 0;
    |     ^^^^^^^ `default` because of this
@@ -19,13 +19,13 @@ LL |     default static IC: u8 = 0;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:15:5
+  --> $DIR/assoc-static-semantic-fail.rs:14:5
    |
 LL |     default static IC: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:18:16
+  --> $DIR/assoc-static-semantic-fail.rs:17:16
    |
 LL |     pub(crate) default static ID: u8;
    |                ^^^^^^^ `default` because of this
@@ -33,25 +33,25 @@ LL |     pub(crate) default static ID: u8;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:18:5
+  --> $DIR/assoc-static-semantic-fail.rs:17:5
    |
 LL |     pub(crate) default static ID: u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:25:5
+  --> $DIR/assoc-static-semantic-fail.rs:24:5
    |
 LL |     static TA: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:27:5
+  --> $DIR/assoc-static-semantic-fail.rs:26:5
    |
 LL |     static TB: u8;
    |     ^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:29:5
+  --> $DIR/assoc-static-semantic-fail.rs:28:5
    |
 LL |     default static TC: u8 = 0;
    |     ^^^^^^^ `default` because of this
@@ -59,13 +59,13 @@ LL |     default static TC: u8 = 0;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:29:5
+  --> $DIR/assoc-static-semantic-fail.rs:28:5
    |
 LL |     default static TC: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:32:16
+  --> $DIR/assoc-static-semantic-fail.rs:31:16
    |
 LL |     pub(crate) default static TD: u8;
    |                ^^^^^^^ `default` because of this
@@ -73,25 +73,25 @@ LL |     pub(crate) default static TD: u8;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:32:5
+  --> $DIR/assoc-static-semantic-fail.rs:31:5
    |
 LL |     pub(crate) default static TD: u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:39:5
+  --> $DIR/assoc-static-semantic-fail.rs:38:5
    |
 LL |     static TA: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:41:5
+  --> $DIR/assoc-static-semantic-fail.rs:40:5
    |
 LL |     static TB: u8;
    |     ^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:44:5
+  --> $DIR/assoc-static-semantic-fail.rs:43:5
    |
 LL |     default static TC: u8 = 0;
    |     ^^^^^^^ `default` because of this
@@ -99,13 +99,13 @@ LL |     default static TC: u8 = 0;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:44:5
+  --> $DIR/assoc-static-semantic-fail.rs:43:5
    |
 LL |     default static TC: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a static item cannot be `default`
-  --> $DIR/assoc-static-semantic-fail.rs:47:9
+  --> $DIR/assoc-static-semantic-fail.rs:46:9
    |
 LL |     pub default static TD: u8;
    |         ^^^^^^^ `default` because of this
@@ -113,13 +113,13 @@ LL |     pub default static TD: u8;
    = note: only associated `fn`, `const`, and `type` items can be `default`
 
 error: associated `static` items are not allowed
-  --> $DIR/assoc-static-semantic-fail.rs:47:5
+  --> $DIR/assoc-static-semantic-fail.rs:46:5
    |
 LL |     pub default static TD: u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: associated constant in `impl` without body
-  --> $DIR/assoc-static-semantic-fail.rs:12:5
+  --> $DIR/assoc-static-semantic-fail.rs:11:5
    |
 LL |     static IB: u8;
    |     ^^^^^^^^^^^^^-
@@ -127,7 +127,7 @@ LL |     static IB: u8;
    |                  help: provide a definition for the constant: `= <expr>;`
 
 error: associated constant in `impl` without body
-  --> $DIR/assoc-static-semantic-fail.rs:18:5
+  --> $DIR/assoc-static-semantic-fail.rs:17:5
    |
 LL |     pub(crate) default static ID: u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -135,7 +135,7 @@ LL |     pub(crate) default static ID: u8;
    |                                     help: provide a definition for the constant: `= <expr>;`
 
 error[E0449]: visibility qualifiers are not permitted here
-  --> $DIR/assoc-static-semantic-fail.rs:32:5
+  --> $DIR/assoc-static-semantic-fail.rs:31:5
    |
 LL |     pub(crate) default static TD: u8;
    |     ^^^^^^^^^^ help: remove the qualifier
@@ -143,7 +143,7 @@ LL |     pub(crate) default static TD: u8;
    = note: trait items always share the visibility of their trait
 
 error: associated constant in `impl` without body
-  --> $DIR/assoc-static-semantic-fail.rs:41:5
+  --> $DIR/assoc-static-semantic-fail.rs:40:5
    |
 LL |     static TB: u8;
    |     ^^^^^^^^^^^^^-
@@ -151,7 +151,7 @@ LL |     static TB: u8;
    |                  help: provide a definition for the constant: `= <expr>;`
 
 error: associated constant in `impl` without body
-  --> $DIR/assoc-static-semantic-fail.rs:47:5
+  --> $DIR/assoc-static-semantic-fail.rs:46:5
    |
 LL |     pub default static TD: u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -159,23 +159,13 @@ LL |     pub default static TD: u8;
    |                              help: provide a definition for the constant: `= <expr>;`
 
 error[E0449]: visibility qualifiers are not permitted here
-  --> $DIR/assoc-static-semantic-fail.rs:47:5
+  --> $DIR/assoc-static-semantic-fail.rs:46:5
    |
 LL |     pub default static TD: u8;
    |     ^^^ help: remove the qualifier
    |
    = note: trait items always share the visibility of their trait
 
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/assoc-static-semantic-fail.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 24 previous errors; 1 warning emitted
+error: aborting due to 24 previous errors
 
 For more information about this error, try `rustc --explain E0449`.
diff --git a/tests/ui/parser/default.rs b/tests/ui/parser/default.rs
index d1058ceb2a1c..81821ce23877 100644
--- a/tests/ui/parser/default.rs
+++ b/tests/ui/parser/default.rs
@@ -1,7 +1,6 @@
 // Test successful and unsuccessful parsing of the `default` contextual keyword
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Foo {
     fn foo<T: Default>() -> T;
diff --git a/tests/ui/parser/default.stderr b/tests/ui/parser/default.stderr
index c420e5a774d2..1f2312d0c6e8 100644
--- a/tests/ui/parser/default.stderr
+++ b/tests/ui/parser/default.stderr
@@ -1,5 +1,5 @@
 error: `default` is not followed by an item
-  --> $DIR/default.rs:23:5
+  --> $DIR/default.rs:22:5
    |
 LL |     default pub fn foo<T: Default>() -> T { T::default() }
    |     ^^^^^^^ the `default` qualifier
@@ -7,7 +7,7 @@ LL |     default pub fn foo<T: Default>() -> T { T::default() }
    = note: only `fn`, `const`, `type`, or `impl` items may be prefixed by `default`
 
 error: non-item in item list
-  --> $DIR/default.rs:23:13
+  --> $DIR/default.rs:22:13
    |
 LL | impl Foo for u32 {
    |                  - item list starts here
@@ -18,25 +18,15 @@ LL | }
    | - item list ends here
 
 error[E0449]: visibility qualifiers are not permitted here
-  --> $DIR/default.rs:17:5
+  --> $DIR/default.rs:16:5
    |
 LL |     pub default fn foo<T: Default>() -> T {
    |     ^^^ help: remove the qualifier
    |
    = note: trait items always share the visibility of their trait
 
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0046]: not all trait items implemented, missing: `foo`
-  --> $DIR/default.rs:22:1
+  --> $DIR/default.rs:21:1
    |
 LL |     fn foo<T: Default>() -> T;
    |     -------------------------- `foo` from trait
@@ -44,7 +34,7 @@ LL |     fn foo<T: Default>() -> T;
 LL | impl Foo for u32 {
    | ^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0046, E0449.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/parser/defaultness-invalid-places-fail-semantic.rs b/tests/ui/parser/defaultness-invalid-places-fail-semantic.rs
index bff53f66e19d..f27404008313 100644
--- a/tests/ui/parser/defaultness-invalid-places-fail-semantic.rs
+++ b/tests/ui/parser/defaultness-invalid-places-fail-semantic.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 fn main() {}
 
diff --git a/tests/ui/parser/defaultness-invalid-places-fail-semantic.stderr b/tests/ui/parser/defaultness-invalid-places-fail-semantic.stderr
index 41fad3a5de34..4adb0ab25c6f 100644
--- a/tests/ui/parser/defaultness-invalid-places-fail-semantic.stderr
+++ b/tests/ui/parser/defaultness-invalid-places-fail-semantic.stderr
@@ -70,15 +70,5 @@ LL | default fn h() {}
    | |
    | `default` because of this
 
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/defaultness-invalid-places-fail-semantic.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 9 previous errors; 1 warning emitted
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
index d26ba93e7211..75a633cd49a3 100644
--- a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
@@ -1,5 +1,5 @@
 error: unreachable pattern
-  --> $DIR/empty-types.rs:48:9
+  --> $DIR/empty-types.rs:47:9
    |
 LL |         _ => {}
    |         ^------
@@ -9,13 +9,13 @@ LL |         _ => {}
    |
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
-  --> $DIR/empty-types.rs:14:9
+  --> $DIR/empty-types.rs:13:9
    |
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:51:9
+  --> $DIR/empty-types.rs:50:9
    |
 LL |         _x => {}
    |         ^^------
@@ -26,7 +26,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
-  --> $DIR/empty-types.rs:55:11
+  --> $DIR/empty-types.rs:54:11
    |
 LL |     match ref_never {}
    |           ^^^^^^^^^
@@ -41,7 +41,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:69:9
+  --> $DIR/empty-types.rs:68:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^------
@@ -52,7 +52,7 @@ LL |         (_, _) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:75:9
+  --> $DIR/empty-types.rs:74:9
    |
 LL |         _ => {}
    |         ^------
@@ -63,7 +63,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:78:9
+  --> $DIR/empty-types.rs:77:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^------
@@ -74,7 +74,7 @@ LL |         (_, _) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:82:9
+  --> $DIR/empty-types.rs:81:9
    |
 LL |         _ => {}
    |         ^------
@@ -85,7 +85,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
-  --> $DIR/empty-types.rs:86:11
+  --> $DIR/empty-types.rs:85:11
    |
 LL |     match res_u32_never {}
    |           ^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@@ -104,7 +104,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:93:9
+  --> $DIR/empty-types.rs:92:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^------
@@ -115,7 +115,7 @@ LL |         Err(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:98:9
+  --> $DIR/empty-types.rs:97:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^------
@@ -126,7 +126,7 @@ LL |         Err(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
-  --> $DIR/empty-types.rs:95:11
+  --> $DIR/empty-types.rs:94:11
    |
 LL |     match res_u32_never {
    |           ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@@ -144,7 +144,7 @@ LL ~         Ok(1_u32..=u32::MAX) => todo!()
    |
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:101:9
+  --> $DIR/empty-types.rs:100:9
    |
 LL |     let Ok(_x) = res_u32_never.as_ref();
    |         ^^^^^^ pattern `Err(_)` not covered
@@ -158,7 +158,7 @@ LL |     let Ok(_x) = res_u32_never.as_ref() else { todo!() };
    |                                         ++++++++++++++++
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:111:9
+  --> $DIR/empty-types.rs:110:9
    |
 LL |         _ => {}
    |         ^------
@@ -169,7 +169,18 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:114:9
+  --> $DIR/empty-types.rs:113:9
+   |
+LL |         Ok(_) => {}
+   |         ^^^^^------
+   |         |
+   |         matches no values because `Result<!, !>` is uninhabited
+   |         help: remove the match arm
+   |
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
+
+error: unreachable pattern
+  --> $DIR/empty-types.rs:116:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^------
@@ -182,17 +193,6 @@ LL |         Ok(_) => {}
 error: unreachable pattern
   --> $DIR/empty-types.rs:117:9
    |
-LL |         Ok(_) => {}
-   |         ^^^^^------
-   |         |
-   |         matches no values because `Result<!, !>` is uninhabited
-   |         help: remove the match arm
-   |
-   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
-
-error: unreachable pattern
-  --> $DIR/empty-types.rs:118:9
-   |
 LL |         _ => {}
    |         ^------
    |         |
@@ -202,7 +202,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:121:9
+  --> $DIR/empty-types.rs:120:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^------
@@ -213,7 +213,7 @@ LL |         Ok(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:122:9
+  --> $DIR/empty-types.rs:121:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^------
@@ -224,7 +224,7 @@ LL |         Err(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:131:13
+  --> $DIR/empty-types.rs:130:13
    |
 LL |             _ => {}
    |             ^------
@@ -235,7 +235,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:134:13
+  --> $DIR/empty-types.rs:133:13
    |
 LL |             _ if false => {}
    |             ^---------------
@@ -246,7 +246,7 @@ LL |             _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:142:13
+  --> $DIR/empty-types.rs:141:13
    |
 LL |             Some(_) => {}
    |             ^^^^^^^------
@@ -257,7 +257,7 @@ LL |             Some(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:146:13
+  --> $DIR/empty-types.rs:145:13
    |
 LL |             None => {}
    |             ---- matches all the relevant values
@@ -265,7 +265,7 @@ LL |             _ => {}
    |             ^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:198:13
+  --> $DIR/empty-types.rs:197:13
    |
 LL |             _ => {}
    |             ^------
@@ -276,7 +276,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:203:13
+  --> $DIR/empty-types.rs:202:13
    |
 LL |             _ => {}
    |             ^------
@@ -287,7 +287,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:208:13
+  --> $DIR/empty-types.rs:207:13
    |
 LL |             _ => {}
    |             ^------
@@ -298,7 +298,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:213:13
+  --> $DIR/empty-types.rs:212:13
    |
 LL |             _ => {}
    |             ^------
@@ -309,7 +309,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:219:13
+  --> $DIR/empty-types.rs:218:13
    |
 LL |             _ => {}
    |             ^------
@@ -320,7 +320,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:280:9
+  --> $DIR/empty-types.rs:279:9
    |
 LL |         _ => {}
    |         ^------
@@ -331,7 +331,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:283:9
+  --> $DIR/empty-types.rs:282:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^------
@@ -342,7 +342,7 @@ LL |         (_, _) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:286:9
+  --> $DIR/empty-types.rs:285:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^------
@@ -353,7 +353,7 @@ LL |         Ok(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:287:9
+  --> $DIR/empty-types.rs:286:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^------
@@ -364,7 +364,7 @@ LL |         Err(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:326:11
+  --> $DIR/empty-types.rs:325:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -378,7 +378,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` not covered
-  --> $DIR/empty-types.rs:337:11
+  --> $DIR/empty-types.rs:336:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[]` not covered
@@ -391,7 +391,7 @@ LL +         &[] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` not covered
-  --> $DIR/empty-types.rs:351:11
+  --> $DIR/empty-types.rs:350:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[]` not covered
@@ -405,7 +405,7 @@ LL +         &[] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:358:11
+  --> $DIR/empty-types.rs:357:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -419,7 +419,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:367:9
+  --> $DIR/empty-types.rs:366:9
    |
 LL |         _ => {}
    |         ^------
@@ -430,7 +430,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:370:9
+  --> $DIR/empty-types.rs:369:9
    |
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^------
@@ -441,7 +441,7 @@ LL |         [_, _, _] => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:373:9
+  --> $DIR/empty-types.rs:372:9
    |
 LL |         [_, ..] => {}
    |         ^^^^^^^------
@@ -452,7 +452,7 @@ LL |         [_, ..] => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:387:11
+  --> $DIR/empty-types.rs:386:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -466,7 +466,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:394:9
+  --> $DIR/empty-types.rs:393:9
    |
 LL |         [] => {}
    |         -- matches all the relevant values
@@ -474,7 +474,7 @@ LL |         _ => {}
    |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:396:11
+  --> $DIR/empty-types.rs:395:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -488,7 +488,7 @@ LL +         [] => todo!()
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:415:9
+  --> $DIR/empty-types.rs:414:9
    |
 LL |         Some(_) => {}
    |         ^^^^^^^------
@@ -499,7 +499,7 @@ LL |         Some(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:420:9
+  --> $DIR/empty-types.rs:419:9
    |
 LL |         Some(_a) => {}
    |         ^^^^^^^^------
@@ -510,7 +510,7 @@ LL |         Some(_a) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:425:9
+  --> $DIR/empty-types.rs:424:9
    |
 LL |         None => {}
    |         ---- matches all the relevant values
@@ -519,7 +519,7 @@ LL |         _ => {}
    |         ^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:430:9
+  --> $DIR/empty-types.rs:429:9
    |
 LL |         None => {}
    |         ---- matches all the relevant values
@@ -528,7 +528,7 @@ LL |         _a => {}
    |         ^^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:602:9
+  --> $DIR/empty-types.rs:601:9
    |
 LL |         _ => {}
    |         ^------
@@ -539,7 +539,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:605:9
+  --> $DIR/empty-types.rs:604:9
    |
 LL |         _x => {}
    |         ^^------
@@ -550,7 +550,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:608:9
+  --> $DIR/empty-types.rs:607:9
    |
 LL |         _ if false => {}
    |         ^---------------
@@ -561,7 +561,7 @@ LL |         _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:611:9
+  --> $DIR/empty-types.rs:610:9
    |
 LL |         _x if false => {}
    |         ^^---------------
diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index 55d6eb82a346..046c0d5f6588 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -1,14 +1,5 @@
-warning: the feature `never_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/empty-types.rs:11:33
-   |
-LL | #![cfg_attr(never_pats, feature(never_patterns))]
-   |                                 ^^^^^^^^^^^^^^
-   |
-   = note: see issue #118155 <https://github.com/rust-lang/rust/issues/118155> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: unreachable pattern
-  --> $DIR/empty-types.rs:48:9
+  --> $DIR/empty-types.rs:47:9
    |
 LL |         _ => {}
    |         ^------
@@ -18,13 +9,13 @@ LL |         _ => {}
    |
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
-  --> $DIR/empty-types.rs:14:9
+  --> $DIR/empty-types.rs:13:9
    |
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:51:9
+  --> $DIR/empty-types.rs:50:9
    |
 LL |         _x => {}
    |         ^^------
@@ -35,7 +26,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
-  --> $DIR/empty-types.rs:55:11
+  --> $DIR/empty-types.rs:54:11
    |
 LL |     match ref_never {}
    |           ^^^^^^^^^
@@ -50,7 +41,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:82:9
+  --> $DIR/empty-types.rs:81:9
    |
 LL |         _ => {}
    |         ^------
@@ -61,7 +52,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
-  --> $DIR/empty-types.rs:86:11
+  --> $DIR/empty-types.rs:85:11
    |
 LL |     match res_u32_never {}
    |           ^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@@ -80,7 +71,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
-  --> $DIR/empty-types.rs:95:11
+  --> $DIR/empty-types.rs:94:11
    |
 LL |     match res_u32_never {
    |           ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@@ -98,7 +89,7 @@ LL ~         Ok(1_u32..=u32::MAX) => todo!()
    |
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:101:9
+  --> $DIR/empty-types.rs:100:9
    |
 LL |     let Ok(_x) = res_u32_never.as_ref();
    |         ^^^^^^ pattern `Err(_)` not covered
@@ -112,7 +103,7 @@ LL |     let Ok(_x) = res_u32_never.as_ref() else { todo!() };
    |                                         ++++++++++++++++
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:105:9
+  --> $DIR/empty-types.rs:104:9
    |
 LL |     let Ok(_x) = &res_u32_never;
    |         ^^^^^^ pattern `&Err(!)` not covered
@@ -126,7 +117,7 @@ LL |     let Ok(_x) = &res_u32_never else { todo!() };
    |                                 ++++++++++++++++
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:131:13
+  --> $DIR/empty-types.rs:130:13
    |
 LL |             _ => {}
    |             ^------
@@ -137,7 +128,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:134:13
+  --> $DIR/empty-types.rs:133:13
    |
 LL |             _ if false => {}
    |             ^---------------
@@ -148,7 +139,7 @@ LL |             _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
-  --> $DIR/empty-types.rs:155:15
+  --> $DIR/empty-types.rs:154:15
    |
 LL |         match *ref_opt_void {
    |               ^^^^^^^^^^^^^ pattern `Some(!)` not covered
@@ -167,7 +158,7 @@ LL +             Some(!)
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:198:13
+  --> $DIR/empty-types.rs:197:13
    |
 LL |             _ => {}
    |             ^------
@@ -178,7 +169,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:203:13
+  --> $DIR/empty-types.rs:202:13
    |
 LL |             _ => {}
    |             ^------
@@ -189,7 +180,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:208:13
+  --> $DIR/empty-types.rs:207:13
    |
 LL |             _ => {}
    |             ^------
@@ -200,7 +191,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:213:13
+  --> $DIR/empty-types.rs:212:13
    |
 LL |             _ => {}
    |             ^------
@@ -211,7 +202,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:219:13
+  --> $DIR/empty-types.rs:218:13
    |
 LL |             _ => {}
    |             ^------
@@ -222,7 +213,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:280:9
+  --> $DIR/empty-types.rs:279:9
    |
 LL |         _ => {}
    |         ^------
@@ -233,7 +224,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:296:13
+  --> $DIR/empty-types.rs:295:13
    |
 LL |         let Ok(_) = *ptr_result_never_err;
    |             ^^^^^ pattern `Err(!)` not covered
@@ -247,7 +238,7 @@ LL |         if let Ok(_) = *ptr_result_never_err { todo!() };
    |         ++                                   +++++++++++
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:315:11
+  --> $DIR/empty-types.rs:314:11
    |
 LL |     match *x {}
    |           ^^
@@ -261,7 +252,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
-  --> $DIR/empty-types.rs:317:11
+  --> $DIR/empty-types.rs:316:11
    |
 LL |     match *x {}
    |           ^^
@@ -275,7 +266,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(!)` and `Err(!)` not covered
-  --> $DIR/empty-types.rs:319:11
+  --> $DIR/empty-types.rs:318:11
    |
 LL |     match *x {}
    |           ^^ patterns `Ok(!)` and `Err(!)` not covered
@@ -297,7 +288,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
-  --> $DIR/empty-types.rs:321:11
+  --> $DIR/empty-types.rs:320:11
    |
 LL |     match *x {}
    |           ^^
@@ -311,7 +302,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:326:11
+  --> $DIR/empty-types.rs:325:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -325,7 +316,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[!, ..]` not covered
-  --> $DIR/empty-types.rs:328:11
+  --> $DIR/empty-types.rs:327:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[!, ..]` not covered
@@ -339,7 +330,7 @@ LL +         &[!, ..]
    |
 
 error[E0004]: non-exhaustive patterns: `&[]`, `&[!]` and `&[!, !]` not covered
-  --> $DIR/empty-types.rs:337:11
+  --> $DIR/empty-types.rs:336:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]`, `&[!]` and `&[!, !]` not covered
@@ -352,7 +343,7 @@ LL +         &[] | &[!] | &[!, !] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` and `&[!, ..]` not covered
-  --> $DIR/empty-types.rs:351:11
+  --> $DIR/empty-types.rs:350:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]` and `&[!, ..]` not covered
@@ -366,7 +357,7 @@ LL +         &[] | &[!, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:358:11
+  --> $DIR/empty-types.rs:357:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -380,7 +371,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:387:11
+  --> $DIR/empty-types.rs:386:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -394,7 +385,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:394:9
+  --> $DIR/empty-types.rs:393:9
    |
 LL |         [] => {}
    |         -- matches all the relevant values
@@ -402,7 +393,7 @@ LL |         _ => {}
    |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:396:11
+  --> $DIR/empty-types.rs:395:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -416,7 +407,7 @@ LL +         [] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&Some(!)` not covered
-  --> $DIR/empty-types.rs:450:11
+  --> $DIR/empty-types.rs:449:11
    |
 LL |     match ref_opt_never {
    |           ^^^^^^^^^^^^^ pattern `&Some(!)` not covered
@@ -435,7 +426,7 @@ LL +         &Some(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
-  --> $DIR/empty-types.rs:491:11
+  --> $DIR/empty-types.rs:490:11
    |
 LL |     match *ref_opt_never {
    |           ^^^^^^^^^^^^^^ pattern `Some(!)` not covered
@@ -454,7 +445,7 @@ LL +         Some(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Err(!)` not covered
-  --> $DIR/empty-types.rs:539:11
+  --> $DIR/empty-types.rs:538:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
@@ -473,7 +464,7 @@ LL +         Err(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Err(!)` not covered
-  --> $DIR/empty-types.rs:550:11
+  --> $DIR/empty-types.rs:549:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
@@ -492,7 +483,7 @@ LL +         Err(!)
    |
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:569:11
+  --> $DIR/empty-types.rs:568:11
    |
 LL |     match *ref_tuple_half_never {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -506,7 +497,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:602:9
+  --> $DIR/empty-types.rs:601:9
    |
 LL |         _ => {}
    |         ^------
@@ -517,7 +508,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:605:9
+  --> $DIR/empty-types.rs:604:9
    |
 LL |         _x => {}
    |         ^^------
@@ -528,7 +519,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:608:9
+  --> $DIR/empty-types.rs:607:9
    |
 LL |         _ if false => {}
    |         ^---------------
@@ -539,7 +530,7 @@ LL |         _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:611:9
+  --> $DIR/empty-types.rs:610:9
    |
 LL |         _x if false => {}
    |         ^^---------------
@@ -550,7 +541,7 @@ LL |         _x if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&!` not covered
-  --> $DIR/empty-types.rs:636:11
+  --> $DIR/empty-types.rs:635:11
    |
 LL |     match ref_never {
    |           ^^^^^^^^^ pattern `&!` not covered
@@ -566,7 +557,7 @@ LL +         &!
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(!)` not covered
-  --> $DIR/empty-types.rs:652:11
+  --> $DIR/empty-types.rs:651:11
    |
 LL |     match *ref_result_never {
    |           ^^^^^^^^^^^^^^^^^ pattern `Ok(!)` not covered
@@ -585,7 +576,7 @@ LL +         Ok(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
-  --> $DIR/empty-types.rs:672:11
+  --> $DIR/empty-types.rs:671:11
    |
 LL |     match *x {
    |           ^^ pattern `Some(!)` not covered
@@ -603,7 +594,7 @@ LL ~         None => {},
 LL +         Some(!)
    |
 
-error: aborting due to 42 previous errors; 1 warning emitted
+error: aborting due to 42 previous errors
 
 Some errors have detailed explanations: E0004, E0005.
 For more information about an error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/empty-types.normal.stderr b/tests/ui/pattern/usefulness/empty-types.normal.stderr
index 0ed8c2119967..ba158c1176b3 100644
--- a/tests/ui/pattern/usefulness/empty-types.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.normal.stderr
@@ -1,5 +1,5 @@
 error: unreachable pattern
-  --> $DIR/empty-types.rs:48:9
+  --> $DIR/empty-types.rs:47:9
    |
 LL |         _ => {}
    |         ^------
@@ -9,13 +9,13 @@ LL |         _ => {}
    |
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
-  --> $DIR/empty-types.rs:14:9
+  --> $DIR/empty-types.rs:13:9
    |
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:51:9
+  --> $DIR/empty-types.rs:50:9
    |
 LL |         _x => {}
    |         ^^------
@@ -26,7 +26,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
-  --> $DIR/empty-types.rs:55:11
+  --> $DIR/empty-types.rs:54:11
    |
 LL |     match ref_never {}
    |           ^^^^^^^^^
@@ -41,7 +41,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:82:9
+  --> $DIR/empty-types.rs:81:9
    |
 LL |         _ => {}
    |         ^------
@@ -52,7 +52,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
-  --> $DIR/empty-types.rs:86:11
+  --> $DIR/empty-types.rs:85:11
    |
 LL |     match res_u32_never {}
    |           ^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@@ -71,7 +71,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
-  --> $DIR/empty-types.rs:95:11
+  --> $DIR/empty-types.rs:94:11
    |
 LL |     match res_u32_never {
    |           ^^^^^^^^^^^^^ pattern `Ok(1_u32..=u32::MAX)` not covered
@@ -89,7 +89,7 @@ LL ~         Ok(1_u32..=u32::MAX) => todo!()
    |
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:101:9
+  --> $DIR/empty-types.rs:100:9
    |
 LL |     let Ok(_x) = res_u32_never.as_ref();
    |         ^^^^^^ pattern `Err(_)` not covered
@@ -103,7 +103,7 @@ LL |     let Ok(_x) = res_u32_never.as_ref() else { todo!() };
    |                                         ++++++++++++++++
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:105:9
+  --> $DIR/empty-types.rs:104:9
    |
 LL |     let Ok(_x) = &res_u32_never;
    |         ^^^^^^ pattern `&Err(_)` not covered
@@ -117,7 +117,7 @@ LL |     let Ok(_x) = &res_u32_never else { todo!() };
    |                                 ++++++++++++++++
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:131:13
+  --> $DIR/empty-types.rs:130:13
    |
 LL |             _ => {}
    |             ^------
@@ -128,7 +128,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:134:13
+  --> $DIR/empty-types.rs:133:13
    |
 LL |             _ if false => {}
    |             ^---------------
@@ -139,7 +139,7 @@ LL |             _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:155:15
+  --> $DIR/empty-types.rs:154:15
    |
 LL |         match *ref_opt_void {
    |               ^^^^^^^^^^^^^ pattern `Some(_)` not covered
@@ -158,7 +158,7 @@ LL +             Some(_) => todo!()
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:198:13
+  --> $DIR/empty-types.rs:197:13
    |
 LL |             _ => {}
    |             ^------
@@ -169,7 +169,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:203:13
+  --> $DIR/empty-types.rs:202:13
    |
 LL |             _ => {}
    |             ^------
@@ -180,7 +180,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:208:13
+  --> $DIR/empty-types.rs:207:13
    |
 LL |             _ => {}
    |             ^------
@@ -191,7 +191,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:213:13
+  --> $DIR/empty-types.rs:212:13
    |
 LL |             _ => {}
    |             ^------
@@ -202,7 +202,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:219:13
+  --> $DIR/empty-types.rs:218:13
    |
 LL |             _ => {}
    |             ^------
@@ -213,7 +213,7 @@ LL |             _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:280:9
+  --> $DIR/empty-types.rs:279:9
    |
 LL |         _ => {}
    |         ^------
@@ -224,7 +224,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-types.rs:296:13
+  --> $DIR/empty-types.rs:295:13
    |
 LL |         let Ok(_) = *ptr_result_never_err;
    |             ^^^^^ pattern `Err(_)` not covered
@@ -238,7 +238,7 @@ LL |         if let Ok(_) = *ptr_result_never_err { todo!() };
    |         ++                                   +++++++++++
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:315:11
+  --> $DIR/empty-types.rs:314:11
    |
 LL |     match *x {}
    |           ^^
@@ -252,7 +252,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
-  --> $DIR/empty-types.rs:317:11
+  --> $DIR/empty-types.rs:316:11
    |
 LL |     match *x {}
    |           ^^
@@ -266,7 +266,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
-  --> $DIR/empty-types.rs:319:11
+  --> $DIR/empty-types.rs:318:11
    |
 LL |     match *x {}
    |           ^^ patterns `Ok(_)` and `Err(_)` not covered
@@ -288,7 +288,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
-  --> $DIR/empty-types.rs:321:11
+  --> $DIR/empty-types.rs:320:11
    |
 LL |     match *x {}
    |           ^^
@@ -302,7 +302,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:326:11
+  --> $DIR/empty-types.rs:325:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -316,7 +316,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
-  --> $DIR/empty-types.rs:328:11
+  --> $DIR/empty-types.rs:327:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[_, ..]` not covered
@@ -330,7 +330,7 @@ LL +         &[_, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]`, `&[_]` and `&[_, _]` not covered
-  --> $DIR/empty-types.rs:337:11
+  --> $DIR/empty-types.rs:336:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]`, `&[_]` and `&[_, _]` not covered
@@ -343,7 +343,7 @@ LL +         &[] | &[_] | &[_, _] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` and `&[_, ..]` not covered
-  --> $DIR/empty-types.rs:351:11
+  --> $DIR/empty-types.rs:350:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]` and `&[_, ..]` not covered
@@ -357,7 +357,7 @@ LL +         &[] | &[_, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:358:11
+  --> $DIR/empty-types.rs:357:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -371,7 +371,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:387:11
+  --> $DIR/empty-types.rs:386:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -385,7 +385,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:394:9
+  --> $DIR/empty-types.rs:393:9
    |
 LL |         [] => {}
    |         -- matches all the relevant values
@@ -393,7 +393,7 @@ LL |         _ => {}
    |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:396:11
+  --> $DIR/empty-types.rs:395:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -407,7 +407,7 @@ LL +         [] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
-  --> $DIR/empty-types.rs:450:11
+  --> $DIR/empty-types.rs:449:11
    |
 LL |     match ref_opt_never {
    |           ^^^^^^^^^^^^^ pattern `&Some(_)` not covered
@@ -426,7 +426,7 @@ LL +         &Some(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:491:11
+  --> $DIR/empty-types.rs:490:11
    |
 LL |     match *ref_opt_never {
    |           ^^^^^^^^^^^^^^ pattern `Some(_)` not covered
@@ -445,7 +445,7 @@ LL +         Some(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Err(_)` not covered
-  --> $DIR/empty-types.rs:539:11
+  --> $DIR/empty-types.rs:538:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@@ -464,7 +464,7 @@ LL +         Err(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Err(_)` not covered
-  --> $DIR/empty-types.rs:550:11
+  --> $DIR/empty-types.rs:549:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@@ -483,7 +483,7 @@ LL +         Err(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:569:11
+  --> $DIR/empty-types.rs:568:11
    |
 LL |     match *ref_tuple_half_never {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -497,7 +497,7 @@ LL ~     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:602:9
+  --> $DIR/empty-types.rs:601:9
    |
 LL |         _ => {}
    |         ^------
@@ -508,7 +508,7 @@ LL |         _ => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:605:9
+  --> $DIR/empty-types.rs:604:9
    |
 LL |         _x => {}
    |         ^^------
@@ -519,7 +519,7 @@ LL |         _x => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:608:9
+  --> $DIR/empty-types.rs:607:9
    |
 LL |         _ if false => {}
    |         ^---------------
@@ -530,7 +530,7 @@ LL |         _ if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:611:9
+  --> $DIR/empty-types.rs:610:9
    |
 LL |         _x if false => {}
    |         ^^---------------
@@ -541,7 +541,7 @@ LL |         _x if false => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&_` not covered
-  --> $DIR/empty-types.rs:636:11
+  --> $DIR/empty-types.rs:635:11
    |
 LL |     match ref_never {
    |           ^^^^^^^^^ pattern `&_` not covered
@@ -557,7 +557,7 @@ LL +         &_ => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
-  --> $DIR/empty-types.rs:652:11
+  --> $DIR/empty-types.rs:651:11
    |
 LL |     match *ref_result_never {
    |           ^^^^^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@@ -576,7 +576,7 @@ LL +         Ok(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:672:11
+  --> $DIR/empty-types.rs:671:11
    |
 LL |     match *x {
    |           ^^ pattern `Some(_)` not covered
diff --git a/tests/ui/pattern/usefulness/empty-types.rs b/tests/ui/pattern/usefulness/empty-types.rs
index a503295fc874..d4fdb7c1dd46 100644
--- a/tests/ui/pattern/usefulness/empty-types.rs
+++ b/tests/ui/pattern/usefulness/empty-types.rs
@@ -9,7 +9,6 @@
 #![feature(never_type)]
 #![cfg_attr(exhaustive_patterns, feature(exhaustive_patterns))]
 #![cfg_attr(never_pats, feature(never_patterns))]
-//[never_pats]~^ WARN the feature `never_patterns` is incomplete
 #![allow(dead_code, unreachable_code)]
 #![deny(unreachable_patterns)]
 
diff --git a/tests/ui/pin-ergonomics/coerce-non-pointer-pin.rs b/tests/ui/pin-ergonomics/coerce-non-pointer-pin.rs
index a95665f126d1..b5a0c6e4404e 100644
--- a/tests/ui/pin-ergonomics/coerce-non-pointer-pin.rs
+++ b/tests/ui/pin-ergonomics/coerce-non-pointer-pin.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(pin_ergonomics)]
-//~^ WARN the feature `pin_ergonomics` is incomplete
 
 use std::pin::Pin;
 
diff --git a/tests/ui/pin-ergonomics/coerce-non-pointer-pin.stderr b/tests/ui/pin-ergonomics/coerce-non-pointer-pin.stderr
deleted file mode 100644
index 2deb5b09884c..000000000000
--- a/tests/ui/pin-ergonomics/coerce-non-pointer-pin.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `pin_ergonomics` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/coerce-non-pointer-pin.rs:3:12
-   |
-LL | #![feature(pin_ergonomics)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130494 <https://github.com/rust-lang/rust/issues/130494> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.rs b/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.rs
index a66c44644177..8dff48de60aa 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.rs
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.rs
@@ -1,7 +1,6 @@
 // Make sure we consider `!` to be a union read.
 
 #![feature(never_type, never_patterns)]
-//~^ WARN the feature `never_patterns` is incomplete
 
 union U {
     a: !,
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.stderr
index d7dc7a47e728..c415e26f6e27 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/never-pattern-is-a-read.stderr
@@ -1,20 +1,11 @@
-warning: the feature `never_patterns` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/never-pattern-is-a-read.rs:3:24
-   |
-LL | #![feature(never_type, never_patterns)]
-   |                        ^^^^^^^^^^^^^^
-   |
-   = note: see issue #118155 <https://github.com/rust-lang/rust/issues/118155> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/never-pattern-is-a-read.rs:12:16
+  --> $DIR/never-pattern-is-a-read.rs:11:16
    |
 LL |     let U { a: ! } = u;
    |                ^ access to union field
    |
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.rs b/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.rs
index eeb0777c8566..67e5760fb242 100644
--- a/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.rs
+++ b/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.rs
@@ -1,6 +1,5 @@
 #![feature(transmutability)]
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 use std::mem::{Assume, TransmuteFrom};
 
diff --git a/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.stderr b/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.stderr
index 6f7e9e1bfa33..5c59fb9e175e 100644
--- a/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.stderr
+++ b/tests/ui/transmutability/dont-assume-err-is-yes-issue-126377.stderr
@@ -1,26 +1,17 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:2:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
-  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:14:23
+  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:13:23
    |
 LL |     is_transmutable::<{}>();
    |                       ^^ expected `bool`, found `()`
 
 error[E0277]: the trait bound `(): TransmuteFrom<(), { Assume::SAFETY }>` is not satisfied
-  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:14:23
+  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:13:23
    |
 LL |     is_transmutable::<{}>();
    |                       ^^ the nightly-only, unstable trait `TransmuteFrom<(), { Assume::SAFETY }>` is not implemented for `()`
    |
 note: required by a bound in `is_transmutable`
-  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:9:9
+  --> $DIR/dont-assume-err-is-yes-issue-126377.rs:8:9
    |
 LL | pub fn is_transmutable<const ASSUME_ALIGNMENT: bool>()
    |        --------------- required by a bound in this function
@@ -28,7 +19,7 @@ LL | where
 LL |     (): TransmuteFrom<(), { Assume::SAFETY }>,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0277, E0308.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/non_scalar_alignment_value.rs b/tests/ui/transmutability/non_scalar_alignment_value.rs
index 45c9e61fcfe2..3b21cdd1c84c 100644
--- a/tests/ui/transmutability/non_scalar_alignment_value.rs
+++ b/tests/ui/transmutability/non_scalar_alignment_value.rs
@@ -1,5 +1,4 @@
 #![feature(min_generic_const_args)]
-//~^ WARN the feature `min_generic_const_args` is incomplete
 
 #![feature(transmutability)]
 
diff --git a/tests/ui/transmutability/non_scalar_alignment_value.stderr b/tests/ui/transmutability/non_scalar_alignment_value.stderr
index d22c6d0b27e8..99d1852b7790 100644
--- a/tests/ui/transmutability/non_scalar_alignment_value.stderr
+++ b/tests/ui/transmutability/non_scalar_alignment_value.stderr
@@ -1,35 +1,26 @@
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/non_scalar_alignment_value.rs:1:12
-   |
-LL | #![feature(min_generic_const_args)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: struct expression with missing field initialiser for `alignment`
-  --> $DIR/non_scalar_alignment_value.rs:15:32
+  --> $DIR/non_scalar_alignment_value.rs:14:32
    |
 LL |                     alignment: Assume {},
    |                                ^^^^^^^^^
 
 error: struct expression with missing field initialiser for `lifetimes`
-  --> $DIR/non_scalar_alignment_value.rs:15:32
+  --> $DIR/non_scalar_alignment_value.rs:14:32
    |
 LL |                     alignment: Assume {},
    |                                ^^^^^^^^^
 
 error: struct expression with missing field initialiser for `safety`
-  --> $DIR/non_scalar_alignment_value.rs:15:32
+  --> $DIR/non_scalar_alignment_value.rs:14:32
    |
 LL |                     alignment: Assume {},
    |                                ^^^^^^^^^
 
 error: struct expression with missing field initialiser for `validity`
-  --> $DIR/non_scalar_alignment_value.rs:15:32
+  --> $DIR/non_scalar_alignment_value.rs:14:32
    |
 LL |                     alignment: Assume {},
    |                                ^^^^^^^^^
 
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/unsafe-binders/binder-sized-crit.rs b/tests/ui/unsafe-binders/binder-sized-crit.rs
index 37677c0ef69b..cda807119ef9 100644
--- a/tests/ui/unsafe-binders/binder-sized-crit.rs
+++ b/tests/ui/unsafe-binders/binder-sized-crit.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 use std::unsafe_binder::wrap_binder;
 
diff --git a/tests/ui/unsafe-binders/binder-sized-crit.stderr b/tests/ui/unsafe-binders/binder-sized-crit.stderr
deleted file mode 100644
index 3ba6cf2ef8c1..000000000000
--- a/tests/ui/unsafe-binders/binder-sized-crit.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/binder-sized-crit.rs:3:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/unsafe-binders/expr.rs b/tests/ui/unsafe-binders/expr.rs
index d437d8f8ac07..9feb29439187 100644
--- a/tests/ui/unsafe-binders/expr.rs
+++ b/tests/ui/unsafe-binders/expr.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 use std::unsafe_binder::{wrap_binder, unwrap_binder};
 
diff --git a/tests/ui/unsafe-binders/expr.stderr b/tests/ui/unsafe-binders/expr.stderr
deleted file mode 100644
index 07026e18e125..000000000000
--- a/tests/ui/unsafe-binders/expr.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/expr.rs:3:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/unsafe-binders/lifetime-resolution.rs b/tests/ui/unsafe-binders/lifetime-resolution.rs
index d24315401194..9935edffaa53 100644
--- a/tests/ui/unsafe-binders/lifetime-resolution.rs
+++ b/tests/ui/unsafe-binders/lifetime-resolution.rs
@@ -1,5 +1,4 @@
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 fn foo<'a>() {
     let good: unsafe<'b> &'a &'b ();
diff --git a/tests/ui/unsafe-binders/lifetime-resolution.stderr b/tests/ui/unsafe-binders/lifetime-resolution.stderr
index 69660c271bfc..2f445e9a02b4 100644
--- a/tests/ui/unsafe-binders/lifetime-resolution.stderr
+++ b/tests/ui/unsafe-binders/lifetime-resolution.stderr
@@ -1,5 +1,5 @@
 error[E0261]: use of undeclared lifetime name `'missing`
-  --> $DIR/lifetime-resolution.rs:7:28
+  --> $DIR/lifetime-resolution.rs:6:28
    |
 LL |     let missing: unsafe<> &'missing ();
    |                            ^^^^^^^^ undeclared lifetime
@@ -15,7 +15,7 @@ LL | fn foo<'missing, 'a>() {
    |        +++++++++
 
 error[E0401]: can't use generic parameters from outer item
-  --> $DIR/lifetime-resolution.rs:11:30
+  --> $DIR/lifetime-resolution.rs:10:30
    |
 LL | fn foo<'a>() {
    |        -- lifetime parameter from outer item
@@ -32,16 +32,7 @@ help: consider introducing lifetime `'a` here
 LL |     fn inner<'a, 'b>() {
    |              +++
 
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/lifetime-resolution.rs:1:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0261, E0401.
 For more information about an error, try `rustc --explain E0261`.
diff --git a/tests/ui/unsafe-binders/mismatch.rs b/tests/ui/unsafe-binders/mismatch.rs
index 840d938cbe98..8da94ccebb73 100644
--- a/tests/ui/unsafe-binders/mismatch.rs
+++ b/tests/ui/unsafe-binders/mismatch.rs
@@ -1,5 +1,4 @@
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 use std::unsafe_binder::{wrap_binder, unwrap_binder};
 
diff --git a/tests/ui/unsafe-binders/mismatch.stderr b/tests/ui/unsafe-binders/mismatch.stderr
index f64db92eb655..5e0720feddf0 100644
--- a/tests/ui/unsafe-binders/mismatch.stderr
+++ b/tests/ui/unsafe-binders/mismatch.stderr
@@ -1,14 +1,5 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/mismatch.rs:1:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
-  --> $DIR/mismatch.rs:7:46
+  --> $DIR/mismatch.rs:6:46
    |
 LL |     let _: unsafe<'a> &'a i32 = wrap_binder!(&());
    |                                              ^^^ expected `&i32`, found `&()`
@@ -17,7 +8,7 @@ LL |     let _: unsafe<'a> &'a i32 = wrap_binder!(&());
               found reference `&()`
 
 error: `wrap_binder!()` can only wrap into unsafe binder, not `i32`
-  --> $DIR/mismatch.rs:12:18
+  --> $DIR/mismatch.rs:11:18
    |
 LL |     let _: i32 = wrap_binder!(&());
    |                  ^^^^^^^^^^^^^^^^^
@@ -26,7 +17,7 @@ LL |     let _: i32 = wrap_binder!(&());
    = note: this error originates in the macro `wrap_binder` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected unsafe binder, found integer as input of `unwrap_binder!()`
-  --> $DIR/mismatch.rs:18:20
+  --> $DIR/mismatch.rs:17:20
    |
 LL |     unwrap_binder!(y);
    |                    ^
@@ -34,7 +25,7 @@ LL |     unwrap_binder!(y);
    = note: only an unsafe binder type can be unwrapped
 
 error[E0282]: type annotations needed
-  --> $DIR/mismatch.rs:23:9
+  --> $DIR/mismatch.rs:22:9
    |
 LL |     let unknown = Default::default();
    |         ^^^^^^^
@@ -48,12 +39,12 @@ LL |     let unknown: /* Type */ = Default::default();
    |                ++++++++++++
 
 error[E0282]: type annotations needed
-  --> $DIR/mismatch.rs:29:26
+  --> $DIR/mismatch.rs:28:26
    |
 LL |     let x = wrap_binder!(&42);
    |                          ^^^ cannot infer type
 
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0282, E0308.
 For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/unsafe-binders/moves.rs b/tests/ui/unsafe-binders/moves.rs
index 9397c2bc20f9..df2cb2265e66 100644
--- a/tests/ui/unsafe-binders/moves.rs
+++ b/tests/ui/unsafe-binders/moves.rs
@@ -1,5 +1,4 @@
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 use std::mem::{ManuallyDrop, drop};
 use std::unsafe_binder::{unwrap_binder, wrap_binder};
diff --git a/tests/ui/unsafe-binders/moves.stderr b/tests/ui/unsafe-binders/moves.stderr
index bd4801570778..a6d6380a0c52 100644
--- a/tests/ui/unsafe-binders/moves.stderr
+++ b/tests/ui/unsafe-binders/moves.stderr
@@ -1,14 +1,5 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/moves.rs:1:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0382]: use of moved value: `base`
-  --> $DIR/moves.rs:15:14
+  --> $DIR/moves.rs:14:14
    |
 LL |         let base = NotCopy::default();
    |             ---- move occurs because `base` has type `ManuallyDrop<NotCopyInner>`, which does not implement the `Copy` trait
@@ -18,7 +9,7 @@ LL |         drop(base);
    |              ^^^^ value used here after move
    |
 note: if `NotCopyInner` implemented `Clone`, you could clone the value
-  --> $DIR/moves.rs:8:1
+  --> $DIR/moves.rs:7:1
    |
 LL | struct NotCopyInner;
    | ^^^^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
@@ -27,7 +18,7 @@ LL |         let binder: unsafe<> NotCopy = wrap_binder!(base);
    |                                                     ---- you could clone this value
 
 error[E0382]: use of moved value: `binder`
-  --> $DIR/moves.rs:24:14
+  --> $DIR/moves.rs:23:14
    |
 LL |         drop(unwrap_binder!(binder));
    |              ---------------------- value moved here
@@ -38,7 +29,7 @@ LL |         drop(unwrap_binder!(binder));
    = note: this error originates in the macro `unwrap_binder` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0382]: use of moved value: `binder.0`
-  --> $DIR/moves.rs:36:14
+  --> $DIR/moves.rs:35:14
    |
 LL |         drop(unwrap_binder!(binder).0);
    |              ------------------------ value moved here
@@ -48,6 +39,6 @@ LL |         drop(unwrap_binder!(binder).0);
    |
    = note: move occurs because `binder.0` has type `ManuallyDrop<NotCopyInner>`, which does not implement the `Copy` trait
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/unsafe-binders/simple.rs b/tests/ui/unsafe-binders/simple.rs
index 6172a9e1e7bb..99f20d6b2ec9 100644
--- a/tests/ui/unsafe-binders/simple.rs
+++ b/tests/ui/unsafe-binders/simple.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 fn main() {
     let x: unsafe<'a> &'a ();
diff --git a/tests/ui/unsafe-binders/simple.stderr b/tests/ui/unsafe-binders/simple.stderr
deleted file mode 100644
index e4b82c12b066..000000000000
--- a/tests/ui/unsafe-binders/simple.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/simple.rs:3:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/unsafe-binders/type-mismatch.rs b/tests/ui/unsafe-binders/type-mismatch.rs
index 9ac4e817c28b..22937bb09e82 100644
--- a/tests/ui/unsafe-binders/type-mismatch.rs
+++ b/tests/ui/unsafe-binders/type-mismatch.rs
@@ -1,5 +1,4 @@
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 fn main() {
     let x: unsafe<> i32 = 0;
diff --git a/tests/ui/unsafe-binders/type-mismatch.stderr b/tests/ui/unsafe-binders/type-mismatch.stderr
index e694b5d464d8..6262620ff6b0 100644
--- a/tests/ui/unsafe-binders/type-mismatch.stderr
+++ b/tests/ui/unsafe-binders/type-mismatch.stderr
@@ -1,14 +1,5 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-mismatch.rs:1:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
-  --> $DIR/type-mismatch.rs:5:27
+  --> $DIR/type-mismatch.rs:4:27
    |
 LL |     let x: unsafe<> i32 = 0;
    |            ------------   ^ expected `unsafe<> i32`, found integer
@@ -19,7 +10,7 @@ LL |     let x: unsafe<> i32 = 0;
                        found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/type-mismatch.rs:7:33
+  --> $DIR/type-mismatch.rs:6:33
    |
 LL |     let x: unsafe<'a> &'a i32 = &0;
    |            ------------------   ^^ expected `unsafe<'a> &i32`, found `&{integer}`
@@ -29,6 +20,6 @@ LL |     let x: unsafe<'a> &'a i32 = &0;
    = note: expected unsafe binder `unsafe<'a> &'a i32`
                   found reference `&{integer}`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsafe-binders/unsafe-binders-debuginfo.rs b/tests/ui/unsafe-binders/unsafe-binders-debuginfo.rs
index 15245d9ba4f2..21f8fe7fdf8f 100644
--- a/tests/ui/unsafe-binders/unsafe-binders-debuginfo.rs
+++ b/tests/ui/unsafe-binders/unsafe-binders-debuginfo.rs
@@ -3,7 +3,6 @@
 //@ compile-flags: -Cdebuginfo=2
 //@ ignore-backends: gcc
 #![feature(unsafe_binders)]
-//~^ WARN the feature `unsafe_binders` is incomplete
 
 use std::unsafe_binder::wrap_binder;
 fn main() {
diff --git a/tests/ui/unsafe-binders/unsafe-binders-debuginfo.stderr b/tests/ui/unsafe-binders/unsafe-binders-debuginfo.stderr
deleted file mode 100644
index 283b8b9c04f6..000000000000
--- a/tests/ui/unsafe-binders/unsafe-binders-debuginfo.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unsafe-binders-debuginfo.rs:5:12
-   |
-LL | #![feature(unsafe_binders)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-

From 0a49163be73fa01b01c18c28983c9ee6374c02e4 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 21 Mar 2026 18:16:51 -0400
Subject: [PATCH 0755/1059] Don't fuse in `MapWindows`

---
 library/core/src/iter/adapters/map_windows.rs | 23 ++++---------
 library/core/src/iter/traits/iterator.rs      | 34 +++++++++----------
 .../tests/iter/adapters/map_windows.rs        | 26 ++++++++++++++
 3 files changed, 49 insertions(+), 34 deletions(-)

diff --git a/library/core/src/iter/adapters/map_windows.rs b/library/core/src/iter/adapters/map_windows.rs
index cef556319143..9398fbbe8a1c 100644
--- a/library/core/src/iter/adapters/map_windows.rs
+++ b/library/core/src/iter/adapters/map_windows.rs
@@ -14,10 +14,7 @@ pub struct MapWindows<I: Iterator, F, const N: usize> {
 }
 
 struct MapWindowsInner<I: Iterator, const N: usize> {
-    // We fuse the inner iterator because there shouldn't be "holes" in
-    // the sliding window. Once the iterator returns a `None`, we make
-    // our `MapWindows` iterator return `None` forever.
-    iter: Option<I>,
+    iter: I,
     // Since iterators are assumed lazy, i.e. it only yields an item when
     // `Iterator::next()` is called, and `MapWindows` is not an exception.
     //
@@ -26,7 +23,7 @@ struct MapWindowsInner<I: Iterator, const N: usize> {
     // we collect the first `N` items yielded from the inner iterator and
     // put it into the buffer.
     //
-    // When the inner iterator has returned a `None` (i.e. fused), we take
+    // When the inner iterator has returned a `None`, we take
     // away this `buffer` and leave it `None` to reclaim its resources.
     //
     // FIXME: should we shrink the size of `buffer` using niche optimization?
@@ -64,19 +61,16 @@ pub(in crate::iter) fn new(iter: I, f: F) -> Self {
 impl<I: Iterator, const N: usize> MapWindowsInner<I, N> {
     #[inline]
     fn new(iter: I) -> Self {
-        Self { iter: Some(iter), buffer: None }
+        Self { iter, buffer: None }
     }
 
     fn next_window(&mut self) -> Option<&[I::Item; N]> {
-        let iter = self.iter.as_mut()?;
         match self.buffer {
             // It is the first time to advance. We collect
             // the first `N` items from `self.iter` to initialize `self.buffer`.
-            None => self.buffer = Buffer::try_from_iter(iter),
-            Some(ref mut buffer) => match iter.next() {
+            None => self.buffer = Buffer::try_from_iter(&mut self.iter),
+            Some(ref mut buffer) => match self.iter.next() {
                 None => {
-                    // Fuse the inner iterator since it yields a `None`.
-                    self.iter.take();
                     self.buffer.take();
                 }
                 // Advance the iterator. We first call `next` before changing our buffer
@@ -89,8 +83,7 @@ fn new(iter: I) -> Self {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let Some(ref iter) = self.iter else { return (0, Some(0)) };
-        let (lo, hi) = iter.size_hint();
+        let (lo, hi) = self.iter.size_hint();
         if self.buffer.is_some() {
             // If the first `N` items are already yielded by the inner iterator,
             // the size hint is then equal to the that of the inner iterator's.
@@ -253,12 +246,10 @@ fn size_hint(&self) -> (usize, Option<usize>) {
     }
 }
 
-// Note that even if the inner iterator not fused, the `MapWindows` is still fused,
-// because we don't allow "holes" in the mapping window.
 #[unstable(feature = "iter_map_windows", issue = "87155")]
 impl<I, F, R, const N: usize> FusedIterator for MapWindows<I, F, N>
 where
-    I: Iterator,
+    I: FusedIterator,
     F: FnMut(&[I::Item; N]) -> R,
 {
 }
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index 2e82f4577182..2fcfa0ea6892 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -1631,11 +1631,6 @@ fn flatten(self) -> Flatten<Self>
     /// items yielded by `self`). If 𝑘 is less than `N`, this method yields an
     /// empty iterator.
     ///
-    /// The returned iterator implements [`FusedIterator`], because once `self`
-    /// returns `None`, even if it returns a `Some(T)` again in the next iterations,
-    /// we cannot put it into a contiguous array buffer, and thus the returned iterator
-    /// should be fused.
-    ///
     /// [`slice::windows()`]: slice::windows
     /// [`FusedIterator`]: crate::iter::FusedIterator
     ///
@@ -1696,7 +1691,7 @@ fn flatten(self) -> Flatten<Self>
     /// assert_eq!(it.next(), None);
     /// ```
     ///
-    /// For non-fused iterators, they are fused after `map_windows`.
+    /// For non-fused iterators, the window is reset after `None` is yielded.
     ///
     /// ```
     /// #![feature(iter_map_windows)]
@@ -1713,11 +1708,11 @@ fn flatten(self) -> Flatten<Self>
     ///         let val = self.state;
     ///         self.state = self.state + 1;
     ///
-    ///         // yields `0..5` first, then only even numbers since `6..`.
-    ///         if val < 5 || val % 2 == 0 {
-    ///             Some(val)
-    ///         } else {
+    ///         // Skip every 5th number
+    ///         if (val + 1) % 5 == 0 {
     ///             None
+    ///         } else {
+    ///             Some(val)
     ///         }
     ///     }
     /// }
@@ -1725,32 +1720,35 @@ fn flatten(self) -> Flatten<Self>
     ///
     /// let mut iter = NonFusedIterator::default();
     ///
-    /// // yields 0..5 first.
     /// assert_eq!(iter.next(), Some(0));
     /// assert_eq!(iter.next(), Some(1));
     /// assert_eq!(iter.next(), Some(2));
     /// assert_eq!(iter.next(), Some(3));
-    /// assert_eq!(iter.next(), Some(4));
-    /// // then we can see our iterator going back and forth
     /// assert_eq!(iter.next(), None);
+    /// assert_eq!(iter.next(), Some(5));
     /// assert_eq!(iter.next(), Some(6));
-    /// assert_eq!(iter.next(), None);
+    /// assert_eq!(iter.next(), Some(7));
     /// assert_eq!(iter.next(), Some(8));
     /// assert_eq!(iter.next(), None);
+    /// assert_eq!(iter.next(), Some(10));
+    /// assert_eq!(iter.next(), Some(11));
     ///
-    /// // however, with `.map_windows()`, it is fused.
     /// let mut iter = NonFusedIterator::default()
     ///     .map_windows(|arr: &[_; 2]| *arr);
     ///
     /// assert_eq!(iter.next(), Some([0, 1]));
     /// assert_eq!(iter.next(), Some([1, 2]));
     /// assert_eq!(iter.next(), Some([2, 3]));
-    /// assert_eq!(iter.next(), Some([3, 4]));
     /// assert_eq!(iter.next(), None);
     ///
-    /// // it will always return `None` after the first time.
-    /// assert_eq!(iter.next(), None);
+    /// assert_eq!(iter.next(), Some([5, 6]));
+    /// assert_eq!(iter.next(), Some([6, 7]));
+    /// assert_eq!(iter.next(), Some([7, 8]));
     /// assert_eq!(iter.next(), None);
+    ///
+    /// assert_eq!(iter.next(), Some([10, 11]));
+    /// assert_eq!(iter.next(), Some([11, 12]));
+    /// assert_eq!(iter.next(), Some([12, 13]));
     /// assert_eq!(iter.next(), None);
     /// ```
     #[inline]
diff --git a/library/coretests/tests/iter/adapters/map_windows.rs b/library/coretests/tests/iter/adapters/map_windows.rs
index 01cebc9b27fd..994ec087e5e8 100644
--- a/library/coretests/tests/iter/adapters/map_windows.rs
+++ b/library/coretests/tests/iter/adapters/map_windows.rs
@@ -284,3 +284,29 @@ fn check_size_hint<const N: usize>(
     check_size_hint::<5>((5, Some(5)), (1, Some(1)));
     check_size_hint::<5>((5, Some(10)), (1, Some(6)));
 }
+
+#[test]
+fn test_unfused() {
+    #[derive(Default)]
+    struct UnfusedIter(usize);
+    impl Iterator for UnfusedIter {
+        type Item = usize;
+
+        fn next(&mut self) -> Option<usize> {
+            let curr = self.0;
+            self.0 += 1;
+            if curr % 7 == 0 { None } else { Some(curr) }
+        }
+    }
+
+    let mut iter = UnfusedIter(1).map_windows(|a: &[_; 3]| *a);
+    assert_eq!(iter.by_ref().collect::<Vec<_>>(), vec![[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]);
+    assert_eq!(
+        iter.by_ref().collect::<Vec<_>>(),
+        vec![[8, 9, 10], [9, 10, 11], [10, 11, 12], [11, 12, 13]]
+    );
+    assert_eq!(
+        iter.by_ref().collect::<Vec<_>>(),
+        vec![[15, 16, 17], [16, 17, 18], [17, 18, 19], [18, 19, 20]]
+    );
+}

From e2a870fd9ed3d3a0d70f2945c5a91ff9d60d011b Mon Sep 17 00:00:00 2001
From: Mahdi Ali-Raihan <asder8215@gmail.com>
Date: Wed, 25 Feb 2026 15:06:45 -0500
Subject: [PATCH 0756/1059] Use BTreeMap::merge underneath the hood to
 deduplicate code

---
 library/alloc/src/collections/btree/append.rs | 51 -------------------
 library/alloc/src/collections/btree/map.rs    | 22 +-------
 .../alloc/src/collections/btree/map/tests.rs  |  2 +-
 3 files changed, 3 insertions(+), 72 deletions(-)

diff --git a/library/alloc/src/collections/btree/append.rs b/library/alloc/src/collections/btree/append.rs
index 66ea22e75247..cc8d793e98e4 100644
--- a/library/alloc/src/collections/btree/append.rs
+++ b/library/alloc/src/collections/btree/append.rs
@@ -1,38 +1,8 @@
 use core::alloc::Allocator;
-use core::iter::FusedIterator;
 
-use super::merge_iter::MergeIterInner;
 use super::node::{self, Root};
 
 impl<K, V> Root<K, V> {
-    /// Appends all key-value pairs from the union of two ascending iterators,
-    /// incrementing a `length` variable along the way. The latter makes it
-    /// easier for the caller to avoid a leak when a drop handler panicks.
-    ///
-    /// If both iterators produce the same key, this method drops the pair from
-    /// the left iterator and appends the pair from the right iterator.
-    ///
-    /// If you want the tree to end up in a strictly ascending order, like for
-    /// a `BTreeMap`, both iterators should produce keys in strictly ascending
-    /// order, each greater than all keys in the tree, including any keys
-    /// already in the tree upon entry.
-    pub(super) fn append_from_sorted_iters<I, A: Allocator + Clone>(
-        &mut self,
-        left: I,
-        right: I,
-        length: &mut usize,
-        alloc: A,
-    ) where
-        K: Ord,
-        I: Iterator<Item = (K, V)> + FusedIterator,
-    {
-        // We prepare to merge `left` and `right` into a sorted sequence in linear time.
-        let iter = MergeIter(MergeIterInner::new(left, right));
-
-        // Meanwhile, we build a tree from the sorted sequence in linear time.
-        self.bulk_push(iter, length, alloc)
-    }
-
     /// Pushes all key-value pairs to the end of the tree, incrementing a
     /// `length` variable along the way. The latter makes it easier for the
     /// caller to avoid a leak when the iterator panicks.
@@ -94,24 +64,3 @@ pub(super) fn bulk_push<I, A: Allocator + Clone>(
         self.fix_right_border_of_plentiful();
     }
 }
-
-// An iterator for merging two sorted sequences into one
-struct MergeIter<K, V, I: Iterator<Item = (K, V)>>(MergeIterInner<I>);
-
-impl<K: Ord, V, I> Iterator for MergeIter<K, V, I>
-where
-    I: Iterator<Item = (K, V)> + FusedIterator,
-{
-    type Item = (K, V);
-
-    /// If two keys are equal, returns the key from the left and the value from the right.
-    fn next(&mut self) -> Option<(K, V)> {
-        let (a_next, b_next) = self.0.nexts(|a: &(K, V), b: &(K, V)| K::cmp(&a.0, &b.0));
-        match (a_next, b_next) {
-            (Some((a_k, _)), Some((_, b_v))) => Some((a_k, b_v)),
-            (Some(a), None) => Some(a),
-            (None, Some(b)) => Some(b),
-            (None, None) => None,
-        }
-    }
-}
diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index d69dad70a44e..9cce9ed4d9b7 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -1218,26 +1218,8 @@ pub fn append(&mut self, other: &mut Self)
         K: Ord,
         A: Clone,
     {
-        // Do we have to append anything at all?
-        if other.is_empty() {
-            return;
-        }
-
-        // We can just swap `self` and `other` if `self` is empty.
-        if self.is_empty() {
-            mem::swap(self, other);
-            return;
-        }
-
-        let self_iter = mem::replace(self, Self::new_in((*self.alloc).clone())).into_iter();
-        let other_iter = mem::replace(other, Self::new_in((*self.alloc).clone())).into_iter();
-        let root = self.root.get_or_insert_with(|| Root::new((*self.alloc).clone()));
-        root.append_from_sorted_iters(
-            self_iter,
-            other_iter,
-            &mut self.length,
-            (*self.alloc).clone(),
-        )
+        let other = mem::replace(other, Self::new_in((*self.alloc).clone()));
+        self.merge(other, |_key, _self_val, other_val| other_val);
     }
 
     /// Moves all elements from `other` into `self`, leaving `other` empty.
diff --git a/library/alloc/src/collections/btree/map/tests.rs b/library/alloc/src/collections/btree/map/tests.rs
index 73546caa05ea..64348745aa07 100644
--- a/library/alloc/src/collections/btree/map/tests.rs
+++ b/library/alloc/src/collections/btree/map/tests.rs
@@ -2224,7 +2224,7 @@ fn test_append_drop_leak() {
 
     catch_unwind(move || left.append(&mut right)).unwrap_err();
     assert_eq!(a.dropped(), 1);
-    assert_eq!(b.dropped(), 1); // should be 2 were it not for Rust issue #47949
+    assert_eq!(b.dropped(), 2);
     assert_eq!(c.dropped(), 2);
 }
 

From 5841fa86500defa98a92c99d3998989da89ff1a7 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sun, 22 Mar 2026 14:32:43 +1100
Subject: [PATCH 0757/1059] Inline and remove
 `QueryVTable::is_loadable_from_disk_fn`.

It's very small and only has two call sites. The tiny loss of DRY is
worth it to shrink `QueryVTable`.
---
 compiler/rustc_middle/src/query/plumbing.rs | 3 ---
 compiler/rustc_query_impl/src/execution.rs  | 7 ++++---
 compiler/rustc_query_impl/src/query_impl.rs | 8 --------
 3 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index dcf7a952fb97..7d94d60523fb 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -104,9 +104,6 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
         index: DepNodeIndex,
     ) -> Option<C::Value>,
 
-    pub is_loadable_from_disk_fn:
-        fn(tcx: TyCtxt<'tcx>, key: C::Key, index: SerializedDepNodeIndex) -> bool,
-
     /// Function pointer that hashes this query's result values.
     ///
     /// For `no_hash` queries, this function pointer is None.
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index bbd55e9ead11..8fc6c851c3da 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -18,7 +18,7 @@
 
 use crate::dep_graph::{DepNode, DepNodeIndex};
 use crate::job::{QueryJobInfo, QueryJobMap, find_cycle_in_stack, report_cycle};
-use crate::plumbing::{current_query_job, next_job_id, start_query};
+use crate::plumbing::{current_query_job, loadable_from_disk, next_job_id, start_query};
 use crate::query_impl::for_each_query_vtable;
 
 #[inline]
@@ -531,7 +531,7 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
     // Sanity check for the logic in `ensure`: if the node is green and the result loadable,
     // we should actually be able to load it.
     debug_assert!(
-        !(query.is_loadable_from_disk_fn)(tcx, key, prev_index),
+        !((query.will_cache_on_disk_for_key_fn)(tcx, key) && loadable_from_disk(tcx, prev_index)),
         "missing on-disk cache entry for loadable {dep_node:?}"
     );
 
@@ -624,7 +624,8 @@ fn check_if_ensure_can_skip_execution<'tcx, C: QueryCache>(
             // In ensure-done mode, we can only skip execution for this key if
             // there's a disk-cached value available to load later if needed,
             // which guarantees the query provider will never run for this key.
-            let is_loadable = (query.is_loadable_from_disk_fn)(tcx, key, serialized_dep_node_index);
+            let is_loadable = (query.will_cache_on_disk_for_key_fn)(tcx, key)
+                && loadable_from_disk(tcx, serialized_dep_node_index);
             EnsureCanSkip { skip_execution: is_loadable, dep_node: Some(dep_node) }
         }
     }
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index 56b7534da9ed..1a8ed053e347 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -165,14 +165,6 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                         #[cfg(not($cache_on_disk))]
                         try_load_from_disk_fn: |_tcx, _key, _prev_index, _index| None,
 
-                        #[cfg($cache_on_disk)]
-                        is_loadable_from_disk_fn: |tcx, key, index| -> bool {
-                            rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, key) &&
-                                $crate::plumbing::loadable_from_disk(tcx, index)
-                        },
-                        #[cfg(not($cache_on_disk))]
-                        is_loadable_from_disk_fn: |_tcx, _key, _index| false,
-
                         // The default just emits `err` and then aborts.
                         // `from_cycle_error::specialize_query_vtables` overwrites this default for
                         // certain queries.

From 69e6a47449df5f937fc2523afcc38eafa2bda560 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 22 Mar 2026 11:02:16 +0800
Subject: [PATCH 0758/1059] internal: extract default_fill_expr to utils

---
 .../src/handlers/add_missing_match_arms.rs    | 19 +-----
 .../src/handlers/desugar_try_expr.rs          | 64 +++++--------------
 .../handlers/generate_blanket_trait_impl.rs   | 17 ++---
 .../src/handlers/generate_function.rs         | 21 ++----
 .../crates/ide-assists/src/utils.rs           | 21 +++---
 5 files changed, 36 insertions(+), 106 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 8124fecff629..95712707589e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -3,7 +3,6 @@
 use either::Either;
 use hir::{Adt, AsAssocItem, Crate, FindPathConfig, HasAttrs, ModuleDef, Semantics};
 use ide_db::RootDatabase;
-use ide_db::assists::ExprFillDefaultMode;
 use ide_db::syntax_helpers::suggest_name;
 use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast};
 use itertools::Itertools;
@@ -229,17 +228,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                     // filter out hidden patterns because they're handled by the catch-all arm
                     !hidden
                 })
-                .map(|(pat, _)| {
-                    make.match_arm(
-                        pat,
-                        None,
-                        match ctx.config.expr_fill_default {
-                            ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-                            ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-                            ExprFillDefaultMode::Default => make::ext::expr_todo(),
-                        },
-                    )
-                });
+                .map(|(pat, _)| make.match_arm(pat, None, utils::expr_fill_default(ctx.config)));
 
             let mut arms: Vec<_> = match_arm_list
                 .arms()
@@ -266,11 +255,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                 let arm = make.match_arm(
                     make.wildcard_pat().into(),
                     None,
-                    match ctx.config.expr_fill_default {
-                        ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-                        ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-                        ExprFillDefaultMode::Default => make::ext::expr_todo(),
-                    },
+                    utils::expr_fill_default(ctx.config),
                 );
                 arms.push(arm);
             }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
index 402203015932..02879837dc2f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
@@ -1,9 +1,6 @@
 use std::iter;
 
-use ide_db::{
-    assists::{AssistId, ExprFillDefaultMode},
-    ty_filter::TryEnum,
-};
+use ide_db::{assists::AssistId, ty_filter::TryEnum};
 use syntax::{
     AstNode, T,
     ast::{
@@ -80,16 +77,9 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                     )
                     .into(),
             };
-            let sad_expr = match try_enum {
-                TryEnum::Option => make.expr_return(Some(make.expr_path(make.ident_path("None")))),
-                TryEnum::Result => make.expr_return(Some(
-                    make.expr_call(
-                        make.expr_path(make.ident_path("Err")),
-                        make.arg_list(iter::once(make.expr_path(make.ident_path("err")))),
-                    )
-                    .into(),
-                )),
-            };
+            let sad_expr = make.expr_return(Some(sad_expr(try_enum, &make, || {
+                make.expr_path(make.ident_path("err"))
+            })));
 
             let happy_arm = make.match_arm(
                 try_enum.happy_pattern(make.ident_pat(false, false, make.name("it")).into()),
@@ -123,6 +113,7 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                 let mut editor = builder.make_editor(let_stmt.syntax());
 
                 let indent_level = IndentLevel::from_node(let_stmt.syntax());
+                let fill_expr = || crate::utils::expr_fill_default(ctx.config);
                 let new_let_stmt = make.let_else_stmt(
                     try_enum.happy_pattern(pat),
                     let_stmt.ty(),
@@ -130,41 +121,7 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                     make.block_expr(
                         iter::once(
                             make.expr_stmt(
-                                make.expr_return(Some(match try_enum {
-                                    TryEnum::Option => make.expr_path(make.ident_path("None")),
-                                    TryEnum::Result => make
-                                        .expr_call(
-                                            make.expr_path(make.ident_path("Err")),
-                                            make.arg_list(iter::once(
-                                                match ctx.config.expr_fill_default {
-                                                    ExprFillDefaultMode::Todo => make
-                                                        .expr_macro(
-                                                            make.ident_path("todo"),
-                                                            make.token_tree(
-                                                                syntax::SyntaxKind::L_PAREN,
-                                                                [],
-                                                            ),
-                                                        )
-                                                        .into(),
-                                                    ExprFillDefaultMode::Underscore => {
-                                                        make.expr_underscore().into()
-                                                    }
-                                                    ExprFillDefaultMode::Default => make
-                                                        .expr_macro(
-                                                            make.ident_path("todo"),
-                                                            make.token_tree(
-                                                                syntax::SyntaxKind::L_PAREN,
-                                                                [],
-                                                            ),
-                                                        )
-                                                        .into(),
-                                                },
-                                            )),
-                                        )
-                                        .into(),
-                                }))
-                                .indent(indent_level + 1)
-                                .into(),
+                                make.expr_return(Some(sad_expr(try_enum, &make, fill_expr))).into(),
                             )
                             .into(),
                         ),
@@ -181,6 +138,15 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
     Some(())
 }
 
+fn sad_expr(try_enum: TryEnum, make: &SyntaxFactory, err: impl Fn() -> ast::Expr) -> ast::Expr {
+    match try_enum {
+        TryEnum::Option => make.expr_path(make.ident_path("None")),
+        TryEnum::Result => make
+            .expr_call(make.expr_path(make.ident_path("Err")), make.arg_list(iter::once(err())))
+            .into(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs
index b0fa9e6b3ebb..e022a27e519a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs
@@ -5,15 +5,15 @@
 use hir::{HasCrate, Semantics};
 use ide_db::{
     RootDatabase,
-    assists::{AssistId, AssistKind, ExprFillDefaultMode},
+    assists::{AssistId, AssistKind},
     famous_defs::FamousDefs,
     syntax_helpers::suggest_name,
 };
 use syntax::{
     AstNode,
     ast::{
-        self, AssocItem, BlockExpr, GenericParam, HasAttrs, HasGenericParams, HasName,
-        HasTypeBounds, HasVisibility, edit::AstNodeEdit, make,
+        self, AssocItem, GenericParam, HasAttrs, HasGenericParams, HasName, HasTypeBounds,
+        HasVisibility, edit::AstNodeEdit, make,
     },
     syntax_editor::Position,
 };
@@ -269,7 +269,7 @@ fn todo_fn(f: &ast::Fn, config: &AssistConfig) -> ast::Fn {
         f.generic_param_list(),
         f.where_clause(),
         params,
-        default_block(config),
+        make::block_expr(None, Some(crate::utils::expr_fill_default(config))),
         f.ret_type(),
         f.async_token().is_some(),
         f.const_token().is_some(),
@@ -278,15 +278,6 @@ fn todo_fn(f: &ast::Fn, config: &AssistConfig) -> ast::Fn {
     )
 }
 
-fn default_block(config: &AssistConfig) -> BlockExpr {
-    let expr = match config.expr_fill_default {
-        ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-        ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-        ExprFillDefaultMode::Default => make::ext::expr_todo(),
-    };
-    make::block_expr(None, Some(expr))
-}
-
 fn cfg_attrs(node: &impl HasAttrs) -> impl Iterator<Item = ast::Attr> {
     node.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"))
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
index f62eccaf1952..fbf6241e43a3 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
@@ -4,7 +4,6 @@
 };
 use ide_db::{
     FileId, FxHashMap, FxHashSet, RootDatabase, SnippetCap,
-    assists::ExprFillDefaultMode,
     defs::{Definition, NameRefClass},
     famous_defs::FamousDefs,
     helpers::is_editable_crate,
@@ -24,7 +23,7 @@
 
 use crate::{
     AssistContext, AssistId, Assists,
-    utils::{convert_reference_type, find_struct_impl},
+    utils::{convert_reference_type, expr_fill_default, find_struct_impl},
 };
 
 // Assist: generate_function
@@ -286,11 +285,7 @@ fn from_call(
                 target_module,
                 &mut necessary_generic_params,
             );
-            let placeholder_expr = match ctx.config.expr_fill_default {
-                ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-                ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-                ExprFillDefaultMode::Default => make::ext::expr_todo(),
-            };
+            let placeholder_expr = expr_fill_default(ctx.config);
             fn_body = make::block_expr(vec![], Some(placeholder_expr));
         };
 
@@ -345,11 +340,7 @@ fn from_method_call(
         let (generic_param_list, where_clause) =
             fn_generic_params(ctx, necessary_generic_params, &target)?;
 
-        let placeholder_expr = match ctx.config.expr_fill_default {
-            ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-            ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-            ExprFillDefaultMode::Default => make::ext::expr_todo(),
-        };
+        let placeholder_expr = expr_fill_default(ctx.config);
         let fn_body = make::block_expr(vec![], Some(placeholder_expr));
 
         Some(Self {
@@ -465,11 +456,7 @@ fn make_fn_body_as_new_function(
     let adt_info = adt_info.as_ref()?;
 
     let path_self = make::ext::ident_path("Self");
-    let placeholder_expr = match ctx.config.expr_fill_default {
-        ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-        ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-        ExprFillDefaultMode::Default => make::ext::expr_todo(),
-    };
+    let placeholder_expr = expr_fill_default(ctx.config);
     let tail_expr = if let Some(strukt) = adt_info.adt.as_struct() {
         match strukt.kind(ctx.db()) {
             StructKind::Record => {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 0657e7243af0..0f28a202253c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -248,17 +248,9 @@ pub fn add_trait_assoc_items_to_impl(
         .filter_map(|item| match item {
             ast::AssocItem::Fn(fn_) if fn_.body().is_none() => {
                 let fn_ = fn_.clone_subtree();
-                let new_body = &make::block_expr(
-                    None,
-                    Some(match config.expr_fill_default {
-                        ExprFillDefaultMode::Todo => make::ext::expr_todo(),
-                        ExprFillDefaultMode::Underscore => make::ext::expr_underscore(),
-                        ExprFillDefaultMode::Default => make::ext::expr_todo(),
-                    }),
-                );
-                let new_body = AstNodeEdit::indent(new_body, IndentLevel::single());
+                let new_body = make::block_expr(None, Some(expr_fill_default(config)));
                 let mut fn_editor = SyntaxEditor::new(fn_.syntax().clone());
-                fn_.replace_or_insert_body(&mut fn_editor, new_body);
+                fn_.replace_or_insert_body(&mut fn_editor, new_body.clone_for_update());
                 let new_fn_ = fn_editor.finish().new_root().clone();
                 ast::AssocItem::cast(new_fn_)
             }
@@ -465,6 +457,15 @@ fn check_pat_variant_nested_or_literal_with_depth(
     }
 }
 
+pub(crate) fn expr_fill_default(config: &AssistConfig) -> ast::Expr {
+    let make = SyntaxFactory::without_mappings();
+    match config.expr_fill_default {
+        ExprFillDefaultMode::Todo => make.expr_todo(),
+        ExprFillDefaultMode::Underscore => make.expr_underscore().into(),
+        ExprFillDefaultMode::Default => make.expr_todo(),
+    }
+}
+
 // Uses a syntax-driven approach to find any impl blocks for the struct that
 // exist within the module/file
 //

From e19ad08c6dff5116ae99dd1bed43f151757640f8 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 20 Mar 2026 20:39:28 +1100
Subject: [PATCH 0759/1059] Use enums to clarify `DepNodeColorMap` color
 marking

When a function's documentation has to explain the meaning of nested results
and options, then it is often a good candidate for using a custom result enum
instead.

This commit also renames `DepNodeColorMap::try_mark` to `try_set_color`, to
make it more distinct from the similarly-named `DepGraph::try_mark_green`.

The difference is that `try_mark_green` is a higher-level operation that tries
to determine whether a node _can_ be marked green, whereas `try_set_color` is a
lower-level operation that actually records a color for the node.
---
 compiler/rustc_middle/src/dep_graph/graph.rs  | 51 ++++++++++++++-----
 .../rustc_middle/src/dep_graph/serialized.rs  | 25 +++++----
 typos.toml                                    |  1 +
 3 files changed, 52 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index d0d7d581b439..7823e9d62f1f 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -1415,28 +1415,29 @@ pub(super) fn current(&self, index: SerializedDepNodeIndex) -> Option<DepNodeInd
         if value <= DepNodeIndex::MAX_AS_U32 { Some(DepNodeIndex::from_u32(value)) } else { None }
     }
 
-    /// This tries to atomically mark a node green and assign `index` as the new
-    /// index if `green` is true, otherwise it will try to atomicaly mark it red.
+    /// Atomically sets the color of a previous-session dep node to either green
+    /// or red, if it has not already been colored.
     ///
-    /// This returns `Ok` if `index` gets assigned or the node is marked red, otherwise it returns
-    /// the already allocated index in `Err` if it is green already. If it was already
-    /// red, `Err(None)` is returned.
+    /// If the node already has a color, the new color is ignored, and the
+    /// return value indicates the existing color.
     #[inline(always)]
-    pub(super) fn try_mark(
+    pub(super) fn try_set_color(
         &self,
         prev_index: SerializedDepNodeIndex,
-        index: DepNodeIndex,
-        green: bool,
-    ) -> Result<(), Option<DepNodeIndex>> {
-        let value = &self.values[prev_index];
-        match value.compare_exchange(
+        color: DesiredColor,
+    ) -> TrySetColorResult {
+        match self.values[prev_index].compare_exchange(
             COMPRESSED_UNKNOWN,
-            if green { index.as_u32() } else { COMPRESSED_RED },
+            match color {
+                DesiredColor::Red => COMPRESSED_RED,
+                DesiredColor::Green { index } => index.as_u32(),
+            },
             Ordering::Relaxed,
             Ordering::Relaxed,
         ) {
-            Ok(_) => Ok(()),
-            Err(v) => Err(if v == COMPRESSED_RED { None } else { Some(DepNodeIndex::from_u32(v)) }),
+            Ok(_) => TrySetColorResult::Success,
+            Err(COMPRESSED_RED) => TrySetColorResult::AlreadyRed,
+            Err(index) => TrySetColorResult::AlreadyGreen { index: DepNodeIndex::from_u32(index) },
         }
     }
 
@@ -1463,6 +1464,28 @@ pub(super) fn insert_red(&self, index: SerializedDepNodeIndex) {
     }
 }
 
+/// The color that [`DepNodeColorMap::try_set_color`] should try to apply to a node.
+#[derive(Clone, Copy, Debug)]
+pub(super) enum DesiredColor {
+    /// Try to mark the node red.
+    Red,
+    /// Try to mark the node green, associating it with a current-session node index.
+    Green { index: DepNodeIndex },
+}
+
+/// Return value of [`DepNodeColorMap::try_set_color`], indicating success or failure,
+/// and (on failure) what the existing color is.
+#[derive(Clone, Copy, Debug)]
+pub(super) enum TrySetColorResult {
+    /// The [`DesiredColor`] was freshly applied to the node.
+    Success,
+    /// Coloring failed because the node was already marked red.
+    AlreadyRed,
+    /// Coloring failed because the node was already marked green,
+    /// and corresponds to node `index` in the current-session dep graph.
+    AlreadyGreen { index: DepNodeIndex },
+}
+
 #[inline(never)]
 #[cold]
 pub(crate) fn print_markframe_trace(graph: &DepGraph, frame: &MarkFrame<'_>) {
diff --git a/compiler/rustc_middle/src/dep_graph/serialized.rs b/compiler/rustc_middle/src/dep_graph/serialized.rs
index 8a4ac4b5e5ac..7a8d25d36744 100644
--- a/compiler/rustc_middle/src/dep_graph/serialized.rs
+++ b/compiler/rustc_middle/src/dep_graph/serialized.rs
@@ -58,7 +58,7 @@
 use rustc_session::Session;
 use tracing::{debug, instrument};
 
-use super::graph::{CurrentDepGraph, DepNodeColorMap};
+use super::graph::{CurrentDepGraph, DepNodeColorMap, DesiredColor, TrySetColorResult};
 use super::retained::RetainedDepGraph;
 use super::{DepKind, DepNode, DepNodeIndex};
 use crate::dep_graph::edges::EdgesVec;
@@ -905,13 +905,14 @@ pub(crate) fn send_and_color(
         let mut local = self.status.local.borrow_mut();
 
         let index = self.status.next_index(&mut *local);
+        let color = if is_green { DesiredColor::Green { index } } else { DesiredColor::Red };
 
-        // Use `try_mark` to avoid racing when `send_promoted` is called concurrently
+        // Use `try_set_color` to avoid racing when `send_promoted` is called concurrently
         // on the same index.
-        match colors.try_mark(prev_index, index, is_green) {
-            Ok(()) => (),
-            Err(None) => panic!("dep node {:?} is unexpectedly red", prev_index),
-            Err(Some(dep_node_index)) => return dep_node_index,
+        match colors.try_set_color(prev_index, color) {
+            TrySetColorResult::Success => {}
+            TrySetColorResult::AlreadyRed => panic!("dep node {prev_index:?} is unexpectedly red"),
+            TrySetColorResult::AlreadyGreen { index } => return index,
         }
 
         self.status.bump_index(&mut *local);
@@ -923,7 +924,8 @@ pub(crate) fn send_and_color(
     /// from the previous dep graph and expects all edges to already have a new dep node index
     /// assigned.
     ///
-    /// This will also ensure the dep node is marked green if `Some` is returned.
+    /// Tries to mark the dep node green, and returns Some if it is now green,
+    /// or None if had already been concurrently marked red.
     #[inline]
     pub(crate) fn send_promoted(
         &self,
@@ -935,10 +937,10 @@ pub(crate) fn send_promoted(
         let mut local = self.status.local.borrow_mut();
         let index = self.status.next_index(&mut *local);
 
-        // Use `try_mark_green` to avoid racing when `send_promoted` or `send_and_color`
+        // Use `try_set_color` to avoid racing when `send_promoted` or `send_and_color`
         // is called concurrently on the same index.
-        match colors.try_mark(prev_index, index, true) {
-            Ok(()) => {
+        match colors.try_set_color(prev_index, DesiredColor::Green { index }) {
+            TrySetColorResult::Success => {
                 self.status.bump_index(&mut *local);
                 self.status.encode_promoted_node(
                     index,
@@ -949,7 +951,8 @@ pub(crate) fn send_promoted(
                 );
                 Some(index)
             }
-            Err(dep_node_index) => dep_node_index,
+            TrySetColorResult::AlreadyRed => None,
+            TrySetColorResult::AlreadyGreen { index } => Some(index),
         }
     }
 
diff --git a/typos.toml b/typos.toml
index 82e2b98f2e49..8e14ce58dcb4 100644
--- a/typos.toml
+++ b/typos.toml
@@ -48,6 +48,7 @@ unstalled = "unstalled" # short for un-stalled
 # the non-empty form can be automatically fixed by `--bless`.
 #
 # tidy-alphabetical-start
+atomicaly = "atomically"
 definitinon = "definition"
 dependy = ""
 similarlty = "similarity"

From 1fec51c446893ab97a04ba04ea896d29c88e421d Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 22 Mar 2026 15:10:46 +1100
Subject: [PATCH 0760/1059] Remove `DepNodeColorMap::insert_red`

This method is only used to initialize the always-red node, which can be done
with `try_set_color` instead.
---
 compiler/rustc_middle/src/dep_graph/graph.rs | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index 7823e9d62f1f..0f50abb827de 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -164,9 +164,10 @@ pub fn new(
         );
         assert_eq!(red_node_index, DepNodeIndex::FOREVER_RED_NODE);
         if prev_graph_node_count > 0 {
-            colors.insert_red(SerializedDepNodeIndex::from_u32(
-                DepNodeIndex::FOREVER_RED_NODE.as_u32(),
-            ));
+            let prev_index =
+                const { SerializedDepNodeIndex::from_u32(DepNodeIndex::FOREVER_RED_NODE.as_u32()) };
+            let result = colors.try_set_color(prev_index, DesiredColor::Red);
+            assert_matches!(result, TrySetColorResult::Success);
         }
 
         DepGraph {
@@ -1455,13 +1456,6 @@ pub(super) fn get(&self, index: SerializedDepNodeIndex) -> DepNodeColor {
             DepNodeColor::Unknown
         }
     }
-
-    #[inline]
-    pub(super) fn insert_red(&self, index: SerializedDepNodeIndex) {
-        let value = self.values[index].swap(COMPRESSED_RED, Ordering::Release);
-        // Sanity check for duplicate nodes
-        assert_eq!(value, COMPRESSED_UNKNOWN, "tried to color an already colored node as red");
-    }
 }
 
 /// The color that [`DepNodeColorMap::try_set_color`] should try to apply to a node.

From e7c268f8837b2e67d1f90a75357a4c58f697dc59 Mon Sep 17 00:00:00 2001
From: sgasho <SuganoShota1999@gmail.com>
Date: Thu, 12 Feb 2026 23:23:31 +0900
Subject: [PATCH 0761/1059] Link LLVM dynamically on aarch64-apple-darwin

---
 compiler/rustc_llvm/build.rs               | 10 ++++++++++
 compiler/rustc_metadata/src/native_libs.rs | 10 +++++++---
 src/ci/github-actions/jobs.yml             |  1 +
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index 38c16fb1cd6d..66b3e266a22f 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -402,6 +402,16 @@ fn main() {
             continue;
         }
 
+        // On apple-darwin, llvm-config reports the versioned shared library name such as LLVM-22-..., but
+        // the distributed toolchain ships libLLVM.dylib. Normalize the link name here.
+        let name =
+            if target.contains("apple-darwin") && llvm_kind == "dylib" && name.starts_with("LLVM-")
+            {
+                "LLVM"
+            } else {
+                name
+            };
+
         let kind = if name.starts_with("LLVM") {
             llvm_kind
         } else if is_static {
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 17b16b3cfe2d..82eab6e354c4 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -62,12 +62,15 @@ pub fn walk_native_lib_search_dirs<R>(
         f(&sess.target_tlib_path.dir.join("self-contained"), false)?;
     }
 
+    let has_shared_llvm_apple_darwin =
+        sess.target.is_like_darwin && sess.target_tlib_path.dir.join("libLLVM.dylib").exists();
+
     // Toolchains for some targets may ship `libunwind.a`, but place it into the main sysroot
     // library directory instead of the self-contained directories.
     // Sanitizer libraries have the same issue and are also linked by name on Apple targets.
     // The targets here should be in sync with `copy_third_party_objects` in bootstrap.
-    // Finally there is shared LLVM library, which unlike compiler libraries, is linked by the name,
-    // therefore requiring the search path for the linker.
+    // On Apple targets, shared LLVM is linked by name, so when `libLLVM.dylib` is
+    // present in the target libdir, add that directory to the linker search path.
     // FIXME: implement `-Clink-self-contained=+/-unwind,+/-sanitizers`, move the shipped libunwind
     // and sanitizers to self-contained directory, and stop adding this search path.
     // FIXME: On AIX this also has the side-effect of making the list of library search paths
@@ -77,7 +80,8 @@ pub fn walk_native_lib_search_dirs<R>(
         || sess.target.os == Os::Linux
         || sess.target.os == Os::Fuchsia
         || sess.target.is_like_aix
-        || sess.target.is_like_darwin && !sess.sanitizers().is_empty()
+        || sess.target.is_like_darwin
+            && (!sess.sanitizers().is_empty() || has_shared_llvm_apple_darwin)
         || sess.target.os == Os::Windows
             && sess.target.env == Env::Gnu
             && sess.target.abi == Abi::Llvm
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 7c0f1d3f2930..bff0046c97cb 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -518,6 +518,7 @@ auto:
         --enable-sanitizers
         --enable-profiler
         --set rust.jemalloc
+        --set llvm.link-shared=true
         --set rust.lto=thin
         --set rust.codegen-units=1
       # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else

From 5491c3529b59fabce7df1e0581b63bc5548c3e79 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Fri, 27 Feb 2026 15:32:44 +0000
Subject: [PATCH 0762/1059] check earlier for misused crate-level attributes

---
 compiler/rustc_attr_parsing/src/errors.rs     |  26 +++++
 compiler/rustc_attr_parsing/src/interface.rs  |  16 ++-
 compiler/rustc_attr_parsing/src/lib.rs        |   2 +
 .../rustc_attr_parsing/src/target_checking.rs | 107 +++++++++++++++++-
 compiler/rustc_passes/src/check_attr.rs       |  63 +----------
 compiler/rustc_passes/src/errors.rs           |  41 +------
 tests/ui/attributes/malformed-reprs.stderr    |  14 +--
 tests/ui/derives/issue-36617.stderr           |  10 +-
 .../issue-43106-gating-of-bench.stderr        |   2 +-
 ...sue-43106-gating-of-builtin-attrs-error.rs |   2 +-
 ...43106-gating-of-builtin-attrs-error.stderr |  30 ++---
 .../issue-43106-gating-of-test.stderr         |   2 +-
 tests/ui/lowering/issue-121108.stderr         |   2 +-
 ...st-fix-invalid-top-level-macro-attr.stderr |   2 +-
 .../ui/span/issue-43927-non-ADT-derive.stderr |   2 +-
 15 files changed, 180 insertions(+), 141 deletions(-)
 create mode 100644 compiler/rustc_attr_parsing/src/errors.rs

diff --git a/compiler/rustc_attr_parsing/src/errors.rs b/compiler/rustc_attr_parsing/src/errors.rs
new file mode 100644
index 000000000000..f45b613c06e8
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/errors.rs
@@ -0,0 +1,26 @@
+use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_span::{Span, Symbol};
+
+#[derive(Diagnostic)]
+#[diag("`{$name}` attribute cannot be used at crate level")]
+pub(crate) struct InvalidAttrAtCrateLevel {
+    #[primary_span]
+    pub span: Span,
+    #[suggestion(
+        "perhaps you meant to use an outer attribute",
+        code = "#[",
+        applicability = "machine-applicable",
+        style = "verbose"
+    )]
+    pub pound_to_opening_bracket: Span,
+    pub name: Symbol,
+    #[subdiagnostic]
+    pub item: Option<ItemFollowingInnerAttr>,
+}
+
+#[derive(Clone, Copy, Subdiagnostic)]
+#[label("the inner attribute doesn't annotate this item")]
+pub(crate) struct ItemFollowingInnerAttr {
+    #[primary_span]
+    pub span: Span,
+}
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index fa66dec6a156..ddfe5953b852 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -304,7 +304,7 @@ pub fn parse_attribute_list(
                         kind: DocFragmentKind::Sugared(*comment_kind),
                         span: attr_span,
                         comment: *symbol,
-                    }))
+                    }));
                 }
                 ast::AttrKind::Normal(n) => {
                     attr_paths.push(PathParser(&n.item.path));
@@ -408,15 +408,23 @@ pub fn parse_attribute_list(
                         //     "attribute {path} wasn't parsed and isn't a know tool attribute",
                         // );
 
-                        attributes.push(Attribute::Unparsed(Box::new(AttrItem {
+                        let attr = AttrItem {
                             path: attr_path.clone(),
                             args: self
                                 .lower_attr_args(n.item.args.unparsed_ref().unwrap(), lower_span),
                             id: HashIgnoredAttrId { attr_id: attr.id },
                             style: attr.style,
                             span: attr_span,
-                        })));
-                    }
+                        };
+
+                        if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
+                            && target == Target::Crate
+                        {
+                            self.check_invalid_crate_level_attr_item(&attr, n.item.span());
+                        }
+
+                        attributes.push(Attribute::Unparsed(Box::new(attr)));
+                    };
                 }
             }
         }
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
index db09572cc56b..93eb5a0c3ab7 100644
--- a/compiler/rustc_attr_parsing/src/lib.rs
+++ b/compiler/rustc_attr_parsing/src/lib.rs
@@ -79,6 +79,7 @@
 // tidy-alphabetical-start
 #![feature(decl_macro)]
 #![feature(iter_intersperse)]
+#![feature(try_blocks)]
 #![recursion_limit = "256"]
 // tidy-alphabetical-end
 
@@ -99,6 +100,7 @@
 pub mod parser;
 
 mod early_parsed;
+mod errors;
 mod safety;
 mod session_diagnostics;
 mod target_checking;
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index fb005477f0fa..a874278ed1c5 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -1,14 +1,15 @@
 use std::borrow::Cow;
 
 use rustc_ast::AttrStyle;
-use rustc_errors::DiagArgValue;
+use rustc_errors::{DiagArgValue, StashKey};
 use rustc_feature::Features;
 use rustc_hir::lints::AttributeLintKind;
-use rustc_hir::{MethodKind, Target};
-use rustc_span::sym;
+use rustc_hir::{AttrItem, MethodKind, Target};
+use rustc_span::{BytePos, Span, Symbol, sym};
 
 use crate::AttributeParser;
 use crate::context::{AcceptContext, Stage};
+use crate::errors::{InvalidAttrAtCrateLevel, ItemFollowingInnerAttr};
 use crate::session_diagnostics::InvalidTarget;
 use crate::target_checking::Policy::Allow;
 
@@ -96,6 +97,25 @@ pub(crate) fn check_target(
             return;
         }
 
+        if matches!(cx.attr_path.segments.as_ref(), [sym::repr]) && target == Target::Crate {
+            // The allowed targets of `repr` depend on its arguments. They can't be checked using
+            // the `AttributeParser` code.
+            let span = cx.attr_span;
+            let item =
+                cx.cx.first_line_of_next_item(span).map(|span| ItemFollowingInnerAttr { span });
+
+            let pound_to_opening_bracket = cx.attr_span.until(cx.inner_span);
+
+            cx.dcx()
+                .create_err(InvalidAttrAtCrateLevel {
+                    span,
+                    pound_to_opening_bracket,
+                    name: sym::repr,
+                    item,
+                })
+                .emit();
+        }
+
         match allowed_targets.is_allowed(target) {
             AllowedResult::Allowed => {}
             AllowedResult::Warn => {
@@ -163,6 +183,87 @@ pub(crate) fn check_crate_level(target: Target, cx: &mut AcceptContext<'_, 'sess
 
         cx.emit_lint(rustc_session::lint::builtin::UNUSED_ATTRIBUTES, kind, attr_span);
     }
+
+    // FIXME: Fix "Cannot determine resolution" error and remove built-in macros
+    // from this check.
+    pub(crate) fn check_invalid_crate_level_attr_item(&self, attr: &AttrItem, inner_span: Span) {
+        // Check for builtin attributes at the crate level
+        // which were unsuccessfully resolved due to cannot determine
+        // resolution for the attribute macro error.
+        const ATTRS_TO_CHECK: &[Symbol] =
+            &[sym::derive, sym::test, sym::test_case, sym::global_allocator, sym::bench];
+
+        // FIXME(jdonszelmann): all attrs should be combined here cleaning this up some day.
+        if let Some(name) = ATTRS_TO_CHECK.iter().find(|attr_to_check| matches!(attr.path.segments.as_ref(), [segment] if segment == *attr_to_check)) {
+            let span = attr.span;
+            let name = *name;
+
+            let item = self.first_line_of_next_item(span).map(|span| ItemFollowingInnerAttr { span });
+
+            let err = self.dcx().create_err(InvalidAttrAtCrateLevel {
+                span,
+                pound_to_opening_bracket: span.until(inner_span),
+                name,
+                item,
+            });
+
+            self.dcx().try_steal_replace_and_emit_err(
+                attr.path.span,
+                StashKey::UndeterminedMacroResolution,
+                err,
+            );
+        }
+    }
+
+    fn first_line_of_next_item(&self, span: Span) -> Option<Span> {
+        // We can't exactly call `tcx.hir_free_items()` here because it's too early and querying
+        // this would create a circular dependency. Instead, we resort to getting the original
+        // source code that follows `span` and find the next item from here.
+
+        self.sess()
+            .source_map()
+            .span_to_source(span, |content, _, span_end| {
+                let mut source = &content[span_end..];
+                let initial_source_len = source.len();
+                let span = try {
+                    loop {
+                        let first = source.chars().next()?;
+
+                        if first.is_whitespace() {
+                            let split_idx = source.find(|c: char| !c.is_whitespace())?;
+                            source = &source[split_idx..];
+                        } else if source.starts_with("//") {
+                            let line_idx = source.find('\n')?;
+                            source = &source[line_idx + '\n'.len_utf8()..];
+                        } else if source.starts_with("/*") {
+                            // FIXME: support nested comments.
+                            let close_idx = source.find("*/")?;
+                            source = &source[close_idx + "*/".len()..];
+                        } else if first == '#' {
+                            // FIXME: properly find the end of the attributes in order to accurately
+                            // skip them. This version just consumes the source code until the next
+                            // `]`.
+                            let close_idx = source.find(']')?;
+                            source = &source[close_idx + ']'.len_utf8()..];
+                        } else {
+                            let lo = span_end + initial_source_len - source.len();
+                            let last_line = source.split('\n').next().map(|s| s.trim_end())?;
+
+                            let hi = lo + last_line.len();
+                            let lo = BytePos(lo as u32);
+                            let hi = BytePos(hi as u32);
+                            let next_item_span = Span::new(lo, hi, span.ctxt(), None);
+
+                            break next_item_span;
+                        }
+                    }
+                };
+
+                Ok(span)
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 /// Takes a list of `allowed_targets` for an attribute, and the `target` the attribute was applied to.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index a8ca8011b571..508bcb03731d 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -15,7 +15,7 @@
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_data_structures::unord::UnordMap;
-use rustc_errors::{DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey, msg};
+use rustc_errors::{DiagCtxtHandle, IntoDiagArg, MultiSpan, msg};
 use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_hir::attrs::{
@@ -45,7 +45,7 @@
 };
 use rustc_session::parse::feature_err;
 use rustc_span::edition::Edition;
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::{TyCtxtInferExt, ValuePairs};
 use rustc_trait_selection::traits::ObligationCtxt;
@@ -2025,64 +2025,6 @@ fn is_c_like_enum(item: &Item<'_>) -> bool {
     }
 }
 
-// FIXME: Fix "Cannot determine resolution" error and remove built-in macros
-// from this check.
-fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
-    // Check for builtin attributes at the crate level
-    // which were unsuccessfully resolved due to cannot determine
-    // resolution for the attribute macro error.
-    const ATTRS_TO_CHECK: &[Symbol] =
-        &[sym::derive, sym::test, sym::test_case, sym::global_allocator, sym::bench];
-
-    for attr in attrs {
-        // FIXME(jdonszelmann): all attrs should be combined here cleaning this up some day.
-        let (span, name) = if let Some(a) =
-            ATTRS_TO_CHECK.iter().find(|attr_to_check| attr.has_name(**attr_to_check))
-        {
-            (attr.span(), *a)
-        } else if let Attribute::Parsed(AttributeKind::Repr {
-            reprs: _,
-            first_span: first_attr_span,
-        }) = attr
-        {
-            (*first_attr_span, sym::repr)
-        } else {
-            continue;
-        };
-
-        let item = tcx
-            .hir_free_items()
-            .map(|id| tcx.hir_item(id))
-            .find(|item| !item.span.is_dummy()) // Skip prelude `use`s
-            .map(|item| errors::ItemFollowingInnerAttr {
-                span: if let Some(ident) = item.kind.ident() { ident.span } else { item.span },
-                kind: tcx.def_descr(item.owner_id.to_def_id()),
-            });
-        let err = tcx.dcx().create_err(errors::InvalidAttrAtCrateLevel {
-            span,
-            sugg_span: tcx
-                .sess
-                .source_map()
-                .span_to_snippet(span)
-                .ok()
-                .filter(|src| src.starts_with("#!["))
-                .map(|_| span.with_lo(span.lo() + BytePos(1)).with_hi(span.lo() + BytePos(2))),
-            name,
-            item,
-        });
-
-        if let Attribute::Unparsed(p) = attr {
-            tcx.dcx().try_steal_replace_and_emit_err(
-                p.path.span,
-                StashKey::UndeterminedMacroResolution,
-                err,
-            );
-        } else {
-            err.emit();
-        }
-    }
-}
-
 fn check_non_exported_macro_for_invalid_attrs(tcx: TyCtxt<'_>, item: &Item<'_>) {
     let attrs = tcx.hir_attrs(item.hir_id());
 
@@ -2098,7 +2040,6 @@ fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
     tcx.hir_visit_item_likes_in_module(module_def_id, check_attr_visitor);
     if module_def_id.to_local_def_id().is_top_level_module() {
         check_attr_visitor.check_attributes(CRATE_HIR_ID, DUMMY_SP, Target::Mod, None);
-        check_invalid_crate_level_attr(tcx, tcx.hir_krate_attrs());
     }
     if check_attr_visitor.abort.get() {
         tcx.dcx().abort_if_errors()
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 5e84122fcb10..7560ddede895 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -3,8 +3,7 @@
 
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, Level,
-    MultiSpan, msg,
+    Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, Level, MultiSpan, msg,
 };
 use rustc_hir::Target;
 use rustc_macros::{Diagnostic, Subdiagnostic};
@@ -447,44 +446,6 @@ pub(crate) struct LangItemOnIncorrectTarget {
     pub actual_target: Target,
 }
 
-pub(crate) struct InvalidAttrAtCrateLevel {
-    pub span: Span,
-    pub sugg_span: Option<Span>,
-    pub name: Symbol,
-    pub item: Option<ItemFollowingInnerAttr>,
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct ItemFollowingInnerAttr {
-    pub span: Span,
-    pub kind: &'static str,
-}
-
-impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidAttrAtCrateLevel {
-    #[track_caller]
-    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
-        let mut diag =
-            Diag::new(dcx, level, msg!("`{$name}` attribute cannot be used at crate level"));
-        diag.span(self.span);
-        diag.arg("name", self.name);
-        // Only emit an error with a suggestion if we can create a string out
-        // of the attribute span
-        if let Some(span) = self.sugg_span {
-            diag.span_suggestion_verbose(
-                span,
-                msg!("perhaps you meant to use an outer attribute"),
-                String::new(),
-                Applicability::MachineApplicable,
-            );
-        }
-        if let Some(item) = self.item {
-            diag.arg("kind", item.kind);
-            diag.span_label(item.span, msg!("the inner attribute doesn't annotate this {$kind}"));
-        }
-        diag
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag("duplicate diagnostic item in crate `{$crate_name}`: `{$name}`")]
 pub(crate) struct DuplicateDiagnosticItemInCrate {
diff --git a/tests/ui/attributes/malformed-reprs.stderr b/tests/ui/attributes/malformed-reprs.stderr
index 504ba91aac5f..6e77c6e4b9a9 100644
--- a/tests/ui/attributes/malformed-reprs.stderr
+++ b/tests/ui/attributes/malformed-reprs.stderr
@@ -6,12 +6,6 @@ LL | #![repr]
    |
    = note: for more information, visit <https://doc.rust-lang.org/reference/type-layout.html#representations>
 
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/malformed-reprs.rs:9:14
-   |
-LL | #[repr(align(0))]
-   |              ^
-
 error: `repr` attribute cannot be used at crate level
   --> $DIR/malformed-reprs.rs:4:1
    |
@@ -19,7 +13,7 @@ LL | #![repr]
    | ^^^^^^^^
 ...
 LL | enum Foo {}
-   |      --- the inner attribute doesn't annotate this enum
+   | ----------- the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
@@ -27,6 +21,12 @@ LL - #![repr]
 LL + #[repr]
    |
 
+error[E0589]: invalid `repr(align)` attribute: not a power of two
+  --> $DIR/malformed-reprs.rs:9:14
+   |
+LL | #[repr(align(0))]
+   |              ^
+
 error[E0084]: unsupported representation for zero-variant enum
   --> $DIR/malformed-reprs.rs:9:1
    |
diff --git a/tests/ui/derives/issue-36617.stderr b/tests/ui/derives/issue-36617.stderr
index 3de1d87c5046..f76c5dfc7e06 100644
--- a/tests/ui/derives/issue-36617.stderr
+++ b/tests/ui/derives/issue-36617.stderr
@@ -5,7 +5,7 @@ LL | #![derive(Copy)]
    | ^^^^^^^^^^^^^^^^
 ...
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
@@ -20,7 +20,7 @@ LL | #![test]
    | ^^^^^^^^
 ...
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
@@ -35,7 +35,7 @@ LL | #![test_case]
    | ^^^^^^^^^^^^^
 ...
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
@@ -50,7 +50,7 @@ LL | #![bench]
    | ^^^^^^^^^
 ...
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
@@ -65,7 +65,7 @@ LL | #![global_allocator]
    | ^^^^^^^^^^^^^^^^^^^^
 ...
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-bench.stderr b/tests/ui/feature-gates/issue-43106-gating-of-bench.stderr
index 912c2746f383..c51d615846f5 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-bench.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-bench.stderr
@@ -5,7 +5,7 @@ LL | #![bench                   = "4100"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
index 1560f2b5f4a7..66d36d9a5d6d 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
@@ -37,7 +37,7 @@
 #[inline]
 //~^ ERROR attribute cannot be used on
 mod inline {
-    //~^ NOTE the inner attribute doesn't annotate this module
+    //~^ NOTE the inner attribute doesn't annotate this item
 
     mod inner { #![inline] }
     //~^ ERROR attribute cannot be used on
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
index 662776e58026..db56f22acfba 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
@@ -24,6 +24,21 @@ LL | #![rustc_main]
    |
    = help: `#[rustc_main]` can only be applied to functions
 
+error: `repr` attribute cannot be used at crate level
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:16:1
+   |
+LL | #![repr()]
+   | ^^^^^^^^^^
+...
+LL | mod inline {
+   | ------------ the inner attribute doesn't annotate this item
+   |
+help: perhaps you meant to use an outer attribute
+   |
+LL - #![repr()]
+LL + #[repr()]
+   |
+
 error: `#[path]` attribute cannot be used on crates
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:20:1
    |
@@ -243,21 +258,6 @@ help: remove the `#[no_mangle]` attribute
 LL - #![no_mangle]
    |
 
-error: `repr` attribute cannot be used at crate level
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:16:1
-   |
-LL | #![repr()]
-   | ^^^^^^^^^^
-...
-LL | mod inline {
-   |     ------ the inner attribute doesn't annotate this module
-   |
-help: perhaps you meant to use an outer attribute
-   |
-LL - #![repr()]
-LL + #[repr()]
-   |
-
 error[E0517]: attribute should be applied to a struct, enum, or union
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:127:25
    |
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-test.stderr b/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
index 6e706b151b72..8af140bc93d9 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-test.stderr
@@ -5,7 +5,7 @@ LL | #![test                    = "4200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | fn main() {}
-   |    ---- the inner attribute doesn't annotate this function
+   | ------------ the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
diff --git a/tests/ui/lowering/issue-121108.stderr b/tests/ui/lowering/issue-121108.stderr
index f68655a70021..e1aa153eede6 100644
--- a/tests/ui/lowering/issue-121108.stderr
+++ b/tests/ui/lowering/issue-121108.stderr
@@ -5,7 +5,7 @@ LL | #![derive(Clone, Copy)]
    | ^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | use std::ptr::addr_of;
-   |               ------- the inner attribute doesn't annotate this import
+   | ---------------------- the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
diff --git a/tests/ui/proc-macro/issue-89566-suggest-fix-invalid-top-level-macro-attr.stderr b/tests/ui/proc-macro/issue-89566-suggest-fix-invalid-top-level-macro-attr.stderr
index 09908160542d..1d7b5ab8c6af 100644
--- a/tests/ui/proc-macro/issue-89566-suggest-fix-invalid-top-level-macro-attr.stderr
+++ b/tests/ui/proc-macro/issue-89566-suggest-fix-invalid-top-level-macro-attr.stderr
@@ -5,7 +5,7 @@ LL | #![derive(Debug)]
    | ^^^^^^^^^^^^^^^^^
 LL | #[allow(dead_code)]
 LL | struct Test {}
-   |        ---- the inner attribute doesn't annotate this struct
+   | -------------- the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |
diff --git a/tests/ui/span/issue-43927-non-ADT-derive.stderr b/tests/ui/span/issue-43927-non-ADT-derive.stderr
index 27ed561f5be8..8742f34c45c6 100644
--- a/tests/ui/span/issue-43927-non-ADT-derive.stderr
+++ b/tests/ui/span/issue-43927-non-ADT-derive.stderr
@@ -5,7 +5,7 @@ LL | #![derive(Debug, PartialEq, Eq)] // should be an outer attribute!
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | struct DerivedOn;
-   |        --------- the inner attribute doesn't annotate this struct
+   | ----------------- the inner attribute doesn't annotate this item
    |
 help: perhaps you meant to use an outer attribute
    |

From 1c6a8feef8db897e0ab956eeb0a450cf3d24f798 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Wed, 4 Mar 2026 00:26:38 +0000
Subject: [PATCH 0763/1059] check earlier for attributes that are placed in
 `where` predicate

---
 compiler/rustc_attr_parsing/src/errors.rs     |   9 +
 compiler/rustc_attr_parsing/src/interface.rs  |   6 +
 .../rustc_attr_parsing/src/target_checking.rs |  35 +++-
 compiler/rustc_passes/src/check_attr.rs       |  21 ---
 compiler/rustc_passes/src/errors.rs           |   8 -
 tests/ui/where-clauses/cfg_attribute.a.stderr | 160 +++++++++---------
 tests/ui/where-clauses/cfg_attribute.b.stderr | 160 +++++++++---------
 .../unsupported_attribute.stderr              |  64 +++----
 8 files changed, 239 insertions(+), 224 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/errors.rs b/compiler/rustc_attr_parsing/src/errors.rs
index f45b613c06e8..4eb9425b34bb 100644
--- a/compiler/rustc_attr_parsing/src/errors.rs
+++ b/compiler/rustc_attr_parsing/src/errors.rs
@@ -1,3 +1,4 @@
+use rustc_errors::MultiSpan;
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 
@@ -24,3 +25,11 @@ pub(crate) struct ItemFollowingInnerAttr {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("most attributes are not supported in `where` clauses")]
+#[help("only `#[cfg]` and `#[cfg_attr]` are supported")]
+pub(crate) struct UnsupportedAttributesInWhere {
+    #[primary_span]
+    pub span: MultiSpan,
+}
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index ddfe5953b852..4d4537aaa5f6 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -439,6 +439,12 @@ pub fn parse_attribute_list(
             }
         }
 
+        if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
+            && target == Target::WherePredicate
+        {
+            self.check_invalid_where_predicate_attrs(attributes.iter());
+        }
+
         attributes
     }
 
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index a874278ed1c5..253a089e49f1 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -1,15 +1,18 @@
 use std::borrow::Cow;
 
 use rustc_ast::AttrStyle;
-use rustc_errors::{DiagArgValue, StashKey};
+use rustc_errors::{DiagArgValue, MultiSpan, StashKey};
 use rustc_feature::Features;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::AttributeLintKind;
-use rustc_hir::{AttrItem, MethodKind, Target};
+use rustc_hir::{AttrItem, Attribute, MethodKind, Target};
 use rustc_span::{BytePos, Span, Symbol, sym};
 
 use crate::AttributeParser;
 use crate::context::{AcceptContext, Stage};
-use crate::errors::{InvalidAttrAtCrateLevel, ItemFollowingInnerAttr};
+use crate::errors::{
+    InvalidAttrAtCrateLevel, ItemFollowingInnerAttr, UnsupportedAttributesInWhere,
+};
 use crate::session_diagnostics::InvalidTarget;
 use crate::target_checking::Policy::Allow;
 
@@ -264,6 +267,32 @@ fn first_line_of_next_item(&self, span: Span) -> Option<Span> {
             .ok()
             .flatten()
     }
+
+    pub(crate) fn check_invalid_where_predicate_attrs<'attr>(
+        &self,
+        attrs: impl IntoIterator<Item = &'attr Attribute>,
+    ) {
+        // FIXME(where_clause_attrs): Currently, as the following check shows,
+        // only `#[cfg]` and `#[cfg_attr]` are allowed, but it should be removed
+        // if we allow more attributes (e.g., tool attributes and `allow/deny/warn`)
+        // in where clauses. After that, this function would become useless.
+        let spans = attrs
+            .into_iter()
+            // FIXME: We shouldn't need to special-case `doc`!
+            .filter(|attr| {
+                matches!(
+                    attr,
+                    Attribute::Parsed(AttributeKind::DocComment { .. } | AttributeKind::Doc(_))
+                        | Attribute::Unparsed(_)
+                )
+            })
+            .map(|attr| attr.span())
+            .collect::<Vec<_>>();
+        if !spans.is_empty() {
+            self.dcx()
+                .emit_err(UnsupportedAttributesInWhere { span: MultiSpan::from_spans(spans) });
+        }
+    }
 }
 
 /// Takes a list of `allowed_targets` for an attribute, and the `target` the attribute was applied to.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 508bcb03731d..26ba2b0e8f42 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1907,27 +1907,6 @@ fn visit_item(&mut self, item: &'tcx Item<'tcx>) {
     }
 
     fn visit_where_predicate(&mut self, where_predicate: &'tcx hir::WherePredicate<'tcx>) {
-        // FIXME(where_clause_attrs): Currently, as the following check shows,
-        // only `#[cfg]` and `#[cfg_attr]` are allowed, but it should be removed
-        // if we allow more attributes (e.g., tool attributes and `allow/deny/warn`)
-        // in where clauses. After that, only `self.check_attributes` should be enough.
-        let spans = self
-            .tcx
-            .hir_attrs(where_predicate.hir_id)
-            .iter()
-            // FIXME: We shouldn't need to special-case `doc`!
-            .filter(|attr| {
-                matches!(
-                    attr,
-                    Attribute::Parsed(AttributeKind::DocComment { .. } | AttributeKind::Doc(_))
-                        | Attribute::Unparsed(_)
-                )
-            })
-            .map(|attr| attr.span())
-            .collect::<Vec<_>>();
-        if !spans.is_empty() {
-            self.tcx.dcx().emit_err(errors::UnsupportedAttributesInWhere { span: spans.into() });
-        }
         self.check_attributes(
             where_predicate.hir_id,
             where_predicate.span,
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 7560ddede895..f9dc696f320e 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1150,14 +1150,6 @@ pub(crate) struct RustcConstStableIndirectPairing {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("most attributes are not supported in `where` clauses")]
-#[help("only `#[cfg]` and `#[cfg_attr]` are supported")]
-pub(crate) struct UnsupportedAttributesInWhere {
-    #[primary_span]
-    pub span: MultiSpan,
-}
-
 #[derive(Diagnostic)]
 pub(crate) enum UnexportableItem<'a> {
     #[diag("{$descr}'s are not exportable")]
diff --git a/tests/ui/where-clauses/cfg_attribute.a.stderr b/tests/ui/where-clauses/cfg_attribute.a.stderr
index ee81072e7006..5bfa65df6032 100644
--- a/tests/ui/where-clauses/cfg_attribute.a.stderr
+++ b/tests/ui/where-clauses/cfg_attribute.a.stderr
@@ -92,6 +92,38 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:42:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:45:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:53:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:56:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:65:5
    |
@@ -108,6 +140,38 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:75:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:78:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:86:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:89:9
+   |
+LL |         #[rustfmt::skip] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:99:5
    |
@@ -188,86 +252,6 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:177:5
-   |
-LL |     #[derive(Clone)] ():,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:180:5
-   |
-LL |     #[rustfmt::skip] ():,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:42:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:45:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:53:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:56:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:75:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:78:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:86:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:89:9
-   |
-LL |         #[rustfmt::skip] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:164:9
    |
@@ -284,5 +268,21 @@ LL |         #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:177:5
+   |
+LL |     #[derive(Clone)] ():,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:180:5
+   |
+LL |     #[rustfmt::skip] ():,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: aborting due to 39 previous errors
 
diff --git a/tests/ui/where-clauses/cfg_attribute.b.stderr b/tests/ui/where-clauses/cfg_attribute.b.stderr
index ee81072e7006..5bfa65df6032 100644
--- a/tests/ui/where-clauses/cfg_attribute.b.stderr
+++ b/tests/ui/where-clauses/cfg_attribute.b.stderr
@@ -92,6 +92,38 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:42:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:45:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:53:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:56:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:65:5
    |
@@ -108,6 +140,38 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:75:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:78:9
+   |
+LL |         #[rustfmt::skip] ():;
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:86:9
+   |
+LL |         #[derive(Clone)] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:89:9
+   |
+LL |         #[rustfmt::skip] ():,
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:99:5
    |
@@ -188,86 +252,6 @@ LL |     #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:177:5
-   |
-LL |     #[derive(Clone)] ():,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:180:5
-   |
-LL |     #[rustfmt::skip] ():,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:42:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:45:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:53:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:56:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:75:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:78:9
-   |
-LL |         #[rustfmt::skip] ():;
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:86:9
-   |
-LL |         #[derive(Clone)] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/cfg_attribute.rs:89:9
-   |
-LL |         #[rustfmt::skip] ():,
-   |         ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
 error: most attributes are not supported in `where` clauses
   --> $DIR/cfg_attribute.rs:164:9
    |
@@ -284,5 +268,21 @@ LL |         #[rustfmt::skip] ():,
    |
    = help: only `#[cfg]` and `#[cfg_attr]` are supported
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:177:5
+   |
+LL |     #[derive(Clone)] ():,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/cfg_attribute.rs:180:5
+   |
+LL |     #[rustfmt::skip] ():,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: aborting due to 39 previous errors
 
diff --git a/tests/ui/where-clauses/unsupported_attribute.stderr b/tests/ui/where-clauses/unsupported_attribute.stderr
index e55a7c380c2b..11f13ffa4d00 100644
--- a/tests/ui/where-clauses/unsupported_attribute.stderr
+++ b/tests/ui/where-clauses/unsupported_attribute.stderr
@@ -10,6 +10,22 @@ error: expected non-macro attribute, found attribute macro `derive`
 LL |     #[derive(Clone)] 'a: 'static,
    |       ^^^^^^ not a non-macro attribute
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/unsupported_attribute.rs:13:5
+   |
+LL |     #[doc = "doc"] T: Trait,
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/unsupported_attribute.rs:14:5
+   |
+LL |     #[doc = "doc"] 'a: 'static,
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: `#[ignore]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:15:5
    |
@@ -58,6 +74,22 @@ LL |     #[macro_use] 'a: 'static,
    |
    = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
+error: most attributes are not supported in `where` clauses
+  --> $DIR/unsupported_attribute.rs:21:5
+   |
+LL |     #[allow(unused)] T: Trait,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
+error: most attributes are not supported in `where` clauses
+  --> $DIR/unsupported_attribute.rs:22:5
+   |
+LL |     #[allow(unused)] 'a: 'static,
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: only `#[cfg]` and `#[cfg_attr]` are supported
+
 error: `#[deprecated]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:23:5
    |
@@ -90,38 +122,6 @@ LL |     #[automatically_derived] 'a: 'static,
    |
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
-error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:13:5
-   |
-LL |     #[doc = "doc"] T: Trait,
-   |     ^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:14:5
-   |
-LL |     #[doc = "doc"] 'a: 'static,
-   |     ^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:21:5
-   |
-LL |     #[allow(unused)] T: Trait,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
-error: most attributes are not supported in `where` clauses
-  --> $DIR/unsupported_attribute.rs:22:5
-   |
-LL |     #[allow(unused)] 'a: 'static,
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = help: only `#[cfg]` and `#[cfg_attr]` are supported
-
 error: most attributes are not supported in `where` clauses
   --> $DIR/unsupported_attribute.rs:27:5
    |

From 29e9273185bd6d67145524733bbf4af4c4cc65c8 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Fri, 27 Feb 2026 15:32:44 +0000
Subject: [PATCH 0764/1059] drop derive helpers during ast lowering

---
 compiler/rustc_attr_parsing/src/interface.rs | 37 ++++++++++----------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index 4d4537aaa5f6..7305c4b7c2fa 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -269,6 +269,11 @@ pub fn parse_attribute_list(
         mut emit_lint: impl FnMut(LintId, Span, AttributeLintKind),
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
+        // We store the attributes we intend to discard at the end of this function in order to
+        // check they are applied to the right target and error out if necessary. In practice, we
+        // end up dropping only derive attributes and derive helpers, both being fully processed
+        // at macro expansion.
+        let mut dropped_attributes = Vec::new();
         let mut attr_paths: Vec<RefPathParser<'_>> = Vec::new();
         let mut early_parsed_state = EarlyParsedState::default();
 
@@ -393,21 +398,6 @@ pub fn parse_attribute_list(
                             Self::check_target(&accept.allowed_targets, target, &mut cx);
                         }
                     } else {
-                        // If we're here, we must be compiling a tool attribute... Or someone
-                        // forgot to parse their fancy new attribute. Let's warn them in any case.
-                        // If you are that person, and you really think your attribute should
-                        // remain unparsed, carefully read the documentation in this module and if
-                        // you still think so you can add an exception to this assertion.
-
-                        // FIXME(jdonszelmann): convert other attributes, and check with this that
-                        // we caught em all
-                        // const FIXME_TEMPORARY_ATTR_ALLOWLIST: &[Symbol] = &[sym::cfg];
-                        // assert!(
-                        //     self.tools.contains(&parts[0]) || true,
-                        //     // || FIXME_TEMPORARY_ATTR_ALLOWLIST.contains(&parts[0]),
-                        //     "attribute {path} wasn't parsed and isn't a know tool attribute",
-                        // );
-
                         let attr = AttrItem {
                             path: attr_path.clone(),
                             args: self
@@ -423,8 +413,19 @@ pub fn parse_attribute_list(
                             self.check_invalid_crate_level_attr_item(&attr, n.item.span());
                         }
 
-                        attributes.push(Attribute::Unparsed(Box::new(attr)));
-                    };
+                        let attr = Attribute::Unparsed(Box::new(attr));
+
+                        if self.tools.contains(&parts[0])
+                            // FIXME: this can be removed once #152369 has been merged.
+                            // https://github.com/rust-lang/rust/pull/152369
+                            || [sym::allow, sym::deny, sym::expect, sym::forbid, sym::warn]
+                                .contains(&parts[0])
+                        {
+                            attributes.push(attr);
+                        } else {
+                            dropped_attributes.push(attr);
+                        }
+                    }
                 }
             }
         }
@@ -442,7 +443,7 @@ pub fn parse_attribute_list(
         if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
             && target == Target::WherePredicate
         {
-            self.check_invalid_where_predicate_attrs(attributes.iter());
+            self.check_invalid_where_predicate_attrs(attributes.iter().chain(&dropped_attributes));
         }
 
         attributes

From 40ebcc031da647d6a76deaf05c471b7a1d4aa228 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 12 Mar 2026 09:54:41 +0100
Subject: [PATCH 0765/1059] target specs: rename abi to cfg_abi

---
 compiler/rustc_codegen_cranelift/src/lib.rs   |   4 +-
 compiler/rustc_codegen_llvm/src/context.rs    |   4 +-
 compiler/rustc_codegen_llvm/src/llvm_util.rs  |  12 +-
 compiler/rustc_codegen_ssa/src/back/link.rs   |   4 +-
 compiler/rustc_codegen_ssa/src/back/linker.rs |   6 +-
 .../rustc_codegen_ssa/src/back/metadata.rs    |   4 +-
 compiler/rustc_codegen_ssa/src/common.rs      |   4 +-
 compiler/rustc_metadata/src/native_libs.rs    |   6 +-
 compiler/rustc_session/src/config/cfg.rs      |   4 +-
 compiler/rustc_target/src/asm/mod.rs          |   4 +-
 compiler/rustc_target/src/asm/powerpc.rs      |  14 +-
 compiler/rustc_target/src/spec/base/aix.rs    |   6 +-
 .../rustc_target/src/spec/base/apple/mod.rs   |  12 +-
 .../rustc_target/src/spec/base/apple/tests.rs |   4 +-
 .../src/spec/base/windows_gnullvm.rs          |   4 +-
 .../src/spec/base/windows_uwp_gnu.rs          |   4 +-
 .../src/spec/base/windows_uwp_msvc.rs         |   4 +-
 compiler/rustc_target/src/spec/json.rs        |  10 +-
 compiler/rustc_target/src/spec/mod.rs         | 201 ++++++++++--------
 .../aarch64_be_unknown_linux_gnu_ilp32.rs     |   4 +-
 .../aarch64_be_unknown_none_softfloat.rs      |   4 +-
 .../aarch64_unknown_linux_gnu_ilp32.rs        |   4 +-
 .../targets/aarch64_unknown_none_softfloat.rs |   4 +-
 .../aarch64v8r_unknown_none_softfloat.rs      |   4 +-
 .../src/spec/targets/arm_linux_androideabi.rs |   6 +-
 .../spec/targets/arm_unknown_linux_gnueabi.rs |   4 +-
 .../targets/arm_unknown_linux_gnueabihf.rs    |   4 +-
 .../targets/arm_unknown_linux_musleabi.rs     |   4 +-
 .../targets/arm_unknown_linux_musleabihf.rs   |   4 +-
 .../targets/armeb_unknown_linux_gnueabi.rs    |   4 +-
 .../src/spec/targets/armebv7r_none_eabi.rs    |   6 +-
 .../src/spec/targets/armebv7r_none_eabihf.rs  |   6 +-
 .../src/spec/targets/armv4t_none_eabi.rs      |   4 +-
 .../targets/armv4t_unknown_linux_gnueabi.rs   |   4 +-
 .../src/spec/targets/armv5te_none_eabi.rs     |   4 +-
 .../targets/armv5te_unknown_linux_gnueabi.rs  |   4 +-
 .../targets/armv5te_unknown_linux_musleabi.rs |   4 +-
 .../armv5te_unknown_linux_uclibceabi.rs       |   4 +-
 .../src/spec/targets/armv6_none_eabi.rs       |   4 +-
 .../src/spec/targets/armv6_none_eabihf.rs     |   4 +-
 .../src/spec/targets/armv6_unknown_freebsd.rs |   4 +-
 .../targets/armv6_unknown_netbsd_eabihf.rs    |   4 +-
 .../src/spec/targets/armv6k_nintendo_3ds.rs   |   4 +-
 .../spec/targets/armv7_linux_androideabi.rs   |   4 +-
 .../src/spec/targets/armv7_rtems_eabihf.rs    |   4 +-
 .../targets/armv7_sony_vita_newlibeabihf.rs   |   4 +-
 .../src/spec/targets/armv7_unknown_freebsd.rs |   4 +-
 .../targets/armv7_unknown_linux_gnueabi.rs    |   4 +-
 .../targets/armv7_unknown_linux_gnueabihf.rs  |   4 +-
 .../targets/armv7_unknown_linux_musleabi.rs   |   4 +-
 .../targets/armv7_unknown_linux_musleabihf.rs |   4 +-
 .../spec/targets/armv7_unknown_linux_ohos.rs  |   4 +-
 .../targets/armv7_unknown_linux_uclibceabi.rs |   4 +-
 .../armv7_unknown_linux_uclibceabihf.rs       |   4 +-
 .../targets/armv7_unknown_netbsd_eabihf.rs    |   4 +-
 .../src/spec/targets/armv7_unknown_trusty.rs  |   4 +-
 .../spec/targets/armv7_wrs_vxworks_eabihf.rs  |   4 +-
 .../targets/armv7a_kmc_solid_asp3_eabi.rs     |   6 +-
 .../targets/armv7a_kmc_solid_asp3_eabihf.rs   |   6 +-
 .../src/spec/targets/armv7a_none_eabi.rs      |   4 +-
 .../src/spec/targets/armv7a_none_eabihf.rs    |   4 +-
 .../src/spec/targets/armv7a_nuttx_eabi.rs     |   4 +-
 .../src/spec/targets/armv7a_nuttx_eabihf.rs   |   4 +-
 .../src/spec/targets/armv7a_vex_v5.rs         |   4 +-
 .../src/spec/targets/armv7r_none_eabi.rs      |   4 +-
 .../src/spec/targets/armv7r_none_eabihf.rs    |   4 +-
 .../src/spec/targets/armv8r_none_eabihf.rs    |   4 +-
 .../targets/csky_unknown_linux_gnuabiv2.rs    |   6 +-
 .../targets/csky_unknown_linux_gnuabiv2hf.rs  |   6 +-
 .../loongarch32_unknown_none_softfloat.rs     |   4 +-
 .../loongarch64_unknown_none_softfloat.rs     |   6 +-
 .../spec/targets/mips64_openwrt_linux_musl.rs |   4 +-
 .../targets/mips64_unknown_linux_gnuabi64.rs  |   4 +-
 .../targets/mips64_unknown_linux_muslabi64.rs |   4 +-
 .../mips64el_unknown_linux_gnuabi64.rs        |   4 +-
 .../mips64el_unknown_linux_muslabi64.rs       |   4 +-
 .../mipsisa64r6_unknown_linux_gnuabi64.rs     |   4 +-
 .../mipsisa64r6el_unknown_linux_gnuabi64.rs   |   4 +-
 .../spec/targets/powerpc64_unknown_freebsd.rs |   5 +-
 .../targets/powerpc64_unknown_linux_gnu.rs    |   5 +-
 .../targets/powerpc64_unknown_linux_musl.rs   |   5 +-
 .../spec/targets/powerpc64_unknown_openbsd.rs |   5 +-
 .../src/spec/targets/powerpc64_wrs_vxworks.rs |   5 +-
 .../targets/powerpc64le_unknown_freebsd.rs    |   5 +-
 .../targets/powerpc64le_unknown_linux_gnu.rs  |   5 +-
 .../targets/powerpc64le_unknown_linux_musl.rs |   5 +-
 .../targets/powerpc_unknown_linux_gnuspe.rs   |   5 +-
 .../targets/powerpc_unknown_linux_muslspe.rs  |   5 +-
 .../spec/targets/powerpc_wrs_vxworks_spe.rs   |   5 +-
 .../spec/targets/riscv32e_unknown_none_elf.rs |   4 +-
 .../targets/riscv32em_unknown_none_elf.rs     |   4 +-
 .../targets/riscv32emc_unknown_none_elf.rs    |   4 +-
 .../targets/s390x_unknown_none_softfloat.rs   |   4 +-
 .../src/spec/targets/thumbv4t_none_eabi.rs    |   4 +-
 .../src/spec/targets/thumbv5te_none_eabi.rs   |   4 +-
 .../src/spec/targets/thumbv6_none_eabi.rs     |   4 +-
 .../src/spec/targets/thumbv6m_none_eabi.rs    |   4 +-
 .../src/spec/targets/thumbv6m_nuttx_eabi.rs   |   4 +-
 .../src/spec/targets/thumbv7a_none_eabi.rs    |   4 +-
 .../src/spec/targets/thumbv7a_none_eabihf.rs  |   4 +-
 .../src/spec/targets/thumbv7a_nuttx_eabi.rs   |   4 +-
 .../src/spec/targets/thumbv7a_nuttx_eabihf.rs |   4 +-
 .../src/spec/targets/thumbv7em_none_eabi.rs   |   4 +-
 .../src/spec/targets/thumbv7em_none_eabihf.rs |   4 +-
 .../src/spec/targets/thumbv7em_nuttx_eabi.rs  |   4 +-
 .../spec/targets/thumbv7em_nuttx_eabihf.rs    |   4 +-
 .../src/spec/targets/thumbv7m_none_eabi.rs    |   4 +-
 .../src/spec/targets/thumbv7m_nuttx_eabi.rs   |   4 +-
 .../targets/thumbv7neon_linux_androideabi.rs  |   4 +-
 .../thumbv7neon_unknown_linux_gnueabihf.rs    |   4 +-
 .../thumbv7neon_unknown_linux_musleabihf.rs   |   4 +-
 .../src/spec/targets/thumbv7r_none_eabi.rs    |   4 +-
 .../src/spec/targets/thumbv7r_none_eabihf.rs  |   4 +-
 .../spec/targets/thumbv8m_base_none_eabi.rs   |   4 +-
 .../spec/targets/thumbv8m_base_nuttx_eabi.rs  |   4 +-
 .../spec/targets/thumbv8m_main_none_eabi.rs   |   4 +-
 .../spec/targets/thumbv8m_main_none_eabihf.rs |   4 +-
 .../spec/targets/thumbv8m_main_nuttx_eabi.rs  |   4 +-
 .../targets/thumbv8m_main_nuttx_eabihf.rs     |   4 +-
 .../src/spec/targets/thumbv8r_none_eabihf.rs  |   4 +-
 .../targets/x86_64_fortanix_unknown_sgx.rs    |   4 +-
 .../targets/x86_64_unknown_linux_gnux32.rs    |   6 +-
 122 files changed, 400 insertions(+), 352 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 82c2e91b4b0f..cbbb0ccbbc21 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -46,7 +46,7 @@
 use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
 use rustc_span::{Symbol, sym};
-use rustc_target::spec::{Abi, Arch, Env, Os};
+use rustc_target::spec::{Arch, CfgAbi, Env, Os};
 
 pub use crate::config::*;
 use crate::prelude::*;
@@ -178,7 +178,7 @@ fn target_config(&self, sess: &Session) -> TargetConfig {
         let has_reliable_f16_f128 = !(sess.target.arch == Arch::X86_64
             && sess.target.os == Os::Windows
             && sess.target.env == Env::Gnu
-            && sess.target.abi != Abi::Llvm);
+            && sess.target.cfg_abi != CfgAbi::Llvm);
 
         // FIXME(f128): f128 math operations need f128 math symbols, which currently aren't always
         // filled in by compiler-builtins. The only libc that provides these currently is glibc.
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index cc4c5e2c9291..2ad79e9147e0 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -28,7 +28,7 @@
 use rustc_span::{DUMMY_SP, Span, Spanned, Symbol};
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{
-    Abi, Arch, Env, HasTargetSpec, Os, RelocModel, SmallDataThresholdSupport, Target, TlsModel,
+    Arch, CfgAbi, Env, HasTargetSpec, Os, RelocModel, SmallDataThresholdSupport, Target, TlsModel,
 };
 use smallvec::SmallVec;
 
@@ -344,7 +344,7 @@ pub(crate) unsafe fn create_module<'ll>(
     if sess.target.is_like_msvc
         || (sess.target.options.os == Os::Windows
             && sess.target.options.env == Env::Gnu
-            && sess.target.options.abi == Abi::Llvm)
+            && sess.target.options.cfg_abi == CfgAbi::Llvm)
     {
         match sess.opts.cg.control_flow_guard {
             CFGuard::Disabled => {}
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 2423880ab869..5b86ce4f2c64 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -16,7 +16,7 @@
 use rustc_session::Session;
 use rustc_session::config::{PrintKind, PrintRequest};
 use rustc_target::spec::{
-    Abi, Arch, Env, MergeFunctions, Os, PanicStrategy, SmallDataThresholdSupport,
+    Arch, CfgAbi, Env, MergeFunctions, Os, PanicStrategy, SmallDataThresholdSupport,
 };
 use smallvec::{SmallVec, smallvec};
 
@@ -362,7 +362,7 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
     let target_arch = &sess.target.arch;
     let target_os = &sess.target.options.os;
     let target_env = &sess.target.options.env;
-    let target_abi = &sess.target.options.abi;
+    let target_abi = &sess.target.options.cfg_abi;
     let target_pointer_width = sess.target.pointer_width;
     let version = get_version();
     let (major, _, _) = version;
@@ -371,7 +371,9 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         // Unsupported <https://github.com/llvm/llvm-project/issues/94434> (fixed in llvm22)
         (Arch::Arm64EC, _) if major < 22 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
-        (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
+        (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != CfgAbi::Llvm => {
+            false
+        }
         // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
         (Arch::CSky, _) if major < 22 => false, // (fixed in llvm22)
         (Arch::PowerPC | Arch::PowerPC64, _) if major < 22 => false, // (fixed in llvm22)
@@ -397,7 +399,9 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         // ABI unsupported  <https://github.com/llvm/llvm-project/issues/41838>
         (Arch::Sparc, _) => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
-        (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false,
+        (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != CfgAbi::Llvm => {
+            false
+        }
         // There are no known problems on other platforms, so the only requirement is that symbols
         // are available. `compiler-builtins` provides all symbols required for core `f128`
         // support, so this should work for everything else.
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 7a3d5a6bb224..2943672c79f9 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -47,7 +47,7 @@
 use rustc_span::Symbol;
 use rustc_target::spec::crt_objects::CrtObjects;
 use rustc_target::spec::{
-    Abi, BinaryFormat, Cc, Env, LinkOutputKind, LinkSelfContainedComponents,
+    BinaryFormat, Cc, CfgAbi, Env, LinkOutputKind, LinkSelfContainedComponents,
     LinkSelfContainedDefault, LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, Os, RelocModel,
     RelroLevel, SanitizerSet, SplitDebuginfo,
 };
@@ -1917,7 +1917,7 @@ fn self_contained_components(
                 LinkSelfContainedDefault::InferredForMusl => sess.crt_static(Some(crate_type)),
                 LinkSelfContainedDefault::InferredForMingw => {
                     sess.host == sess.target
-                        && sess.target.abi != Abi::Uwp
+                        && sess.target.cfg_abi != CfgAbi::Uwp
                         && detect_self_contained_mingw(sess, linker)
                 }
             }
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 3ace1a8c266c..323fa7fb91b8 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -18,7 +18,7 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
-use rustc_target::spec::{Abi, Arch, Cc, LinkOutputKind, LinkerFlavor, Lld, Os};
+use rustc_target::spec::{Arch, Cc, CfgAbi, LinkOutputKind, LinkerFlavor, Lld, Os};
 use tracing::{debug, warn};
 
 use super::command::Command;
@@ -84,7 +84,7 @@ pub(crate) fn get_linker<'a>(
     // To comply with the Windows App Certification Kit,
     // MSVC needs to link with the Store versions of the runtime libraries (vcruntime, msvcrt, etc).
     let t = &sess.target;
-    if matches!(flavor, LinkerFlavor::Msvc(..)) && t.abi == Abi::Uwp {
+    if matches!(flavor, LinkerFlavor::Msvc(..)) && t.cfg_abi == CfgAbi::Uwp {
         if let Some(ref tool) = msvc_tool {
             let original_path = tool.path();
             if let Some(root_lib_path) = original_path.ancestors().nth(4) {
@@ -135,7 +135,7 @@ pub(crate) fn get_linker<'a>(
 
     // FIXME: Move `/LIBPATH` addition for uwp targets from the linker construction
     // to the linker args construction.
-    assert!(cmd.get_args().is_empty() || sess.target.abi == Abi::Uwp);
+    assert!(cmd.get_args().is_empty() || sess.target.cfg_abi == CfgAbi::Uwp);
     match flavor {
         LinkerFlavor::Unix(Cc::No) if sess.target.os == Os::L4Re => {
             Box::new(L4Bender::new(cmd, sess)) as Box<dyn Linker>
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 240267c362f6..27504e6e2145 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -20,7 +20,7 @@
 use rustc_middle::bug;
 use rustc_session::Session;
 use rustc_span::sym;
-use rustc_target::spec::{Abi, Os, RelocModel, Target, ef_avr_arch};
+use rustc_target::spec::{CfgAbi, Os, RelocModel, Target, ef_avr_arch};
 use tracing::debug;
 
 use super::apple;
@@ -372,7 +372,7 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
             }
         }
         Architecture::Csky => {
-            if matches!(sess.target.options.abi, Abi::AbiV2) {
+            if matches!(sess.target.options.cfg_abi, CfgAbi::AbiV2) {
                 elf::EF_CSKY_ABIV2
             } else {
                 elf::EF_CSKY_ABIV1
diff --git a/compiler/rustc_codegen_ssa/src/common.rs b/compiler/rustc_codegen_ssa/src/common.rs
index 89a3f8061a8c..f6f4a21b7bde 100644
--- a/compiler/rustc_codegen_ssa/src/common.rs
+++ b/compiler/rustc_codegen_ssa/src/common.rs
@@ -7,7 +7,7 @@
 use rustc_middle::{bug, mir, span_bug};
 use rustc_session::cstore::{DllCallingConvention, DllImport};
 use rustc_span::Span;
-use rustc_target::spec::{Abi, Env, Os, Target};
+use rustc_target::spec::{CfgAbi, Env, Os, Target};
 
 use crate::traits::*;
 
@@ -171,7 +171,7 @@ pub fn asm_const_to_str<'tcx>(
 }
 
 pub fn is_mingw_gnu_toolchain(target: &Target) -> bool {
-    target.os == Os::Windows && target.env == Env::Gnu && target.abi == Abi::Unspecified
+    target.os == Os::Windows && target.env == Env::Gnu && target.cfg_abi == CfgAbi::Unspecified
 }
 
 pub fn i686_decorated_name(
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 52b11615c76f..fb34edb5a322 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -14,7 +14,7 @@
 use rustc_session::search_paths::PathKind;
 use rustc_span::Symbol;
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
-use rustc_target::spec::{Abi, Arch, BinaryFormat, Env, LinkSelfContainedComponents, Os};
+use rustc_target::spec::{Arch, BinaryFormat, CfgAbi, Env, LinkSelfContainedComponents, Os};
 
 use crate::errors;
 
@@ -68,14 +68,14 @@ pub fn walk_native_lib_search_dirs<R>(
     // FIXME: On AIX this also has the side-effect of making the list of library search paths
     // non-empty, which is needed or the linker may decide to record the LIBPATH env, if
     // defined, as the search path instead of appending the default search paths.
-    if sess.target.abi == Abi::Fortanix
+    if sess.target.cfg_abi == CfgAbi::Fortanix
         || sess.target.os == Os::Linux
         || sess.target.os == Os::Fuchsia
         || sess.target.is_like_aix
         || sess.target.is_like_darwin && !sess.sanitizers().is_empty()
         || sess.target.os == Os::Windows
             && sess.target.env == Env::Gnu
-            && sess.target.abi == Abi::Llvm
+            && sess.target.cfg_abi == CfgAbi::Llvm
     {
         f(&sess.target_tlib_path.dir, false)?;
     }
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index ebbbe36878da..da134a4c7f05 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -239,7 +239,7 @@ macro_rules! ins_sym {
         ins_none!(sym::sanitizer_cfi_normalize_integers);
     }
 
-    ins_sym!(sym::target_abi, sess.target.abi.desc_symbol());
+    ins_sym!(sym::target_abi, sess.target.cfg_abi.desc_symbol());
     ins_sym!(sym::target_arch, sess.target.arch.desc_symbol());
     ins_str!(sym::target_endian, sess.target.endian.as_str());
     ins_sym!(sym::target_env, sess.target.env.desc_symbol());
@@ -447,7 +447,7 @@ macro_rules! ins {
                 };
 
                 for target in Target::builtins().chain(iter::once(current_target.clone())) {
-                    values_target_abi.insert(target.options.abi.desc_symbol());
+                    values_target_abi.insert(target.options.cfg_abi.desc_symbol());
                     values_target_arch.insert(target.arch.desc_symbol());
                     values_target_endian.insert(Symbol::intern(target.options.endian.as_str()));
                     values_target_env.insert(target.options.env.desc_symbol());
diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs
index 27dd0b764f3b..643eeaa00ce7 100644
--- a/compiler/rustc_target/src/asm/mod.rs
+++ b/compiler/rustc_target/src/asm/mod.rs
@@ -5,7 +5,7 @@
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::Symbol;
 
-use crate::spec::{Abi, Arch, RelocModel, Target};
+use crate::spec::{Arch, CfgAbi, RelocModel, Target};
 
 pub struct ModifierInfo {
     pub modifier: char,
@@ -1001,7 +1001,7 @@ pub fn parse(
                 _ => Err(&["C", "system", "efiapi"]),
             },
             InlineAsmArch::PowerPC | InlineAsmArch::PowerPC64 => match name {
-                "C" | "system" => Ok(if target.abi == Abi::Spe {
+                "C" | "system" => Ok(if target.cfg_abi == CfgAbi::Spe {
                     InlineAsmClobberAbi::PowerPCSPE
                 } else {
                     InlineAsmClobberAbi::PowerPC
diff --git a/compiler/rustc_target/src/asm/powerpc.rs b/compiler/rustc_target/src/asm/powerpc.rs
index fd0e118fcc87..a09b93c64e0e 100644
--- a/compiler/rustc_target/src/asm/powerpc.rs
+++ b/compiler/rustc_target/src/asm/powerpc.rs
@@ -4,7 +4,7 @@
 use rustc_span::Symbol;
 
 use super::{InlineAsmArch, InlineAsmType, ModifierInfo};
-use crate::spec::{Abi, RelocModel, Target};
+use crate::spec::{CfgAbi, RelocModel, Target};
 
 def_reg_class! {
     PowerPC PowerPCInlineAsmRegClass {
@@ -105,9 +105,9 @@ fn reserved_v20to31(
     _is_clobber: bool,
 ) -> Result<(), &'static str> {
     if target.is_like_aix {
-        match &target.options.abi {
-            Abi::VecDefault => Err("v20-v31 (vs52-vs63) are reserved on vec-default ABI"),
-            Abi::VecExtAbi => Ok(()),
+        match &target.options.cfg_abi {
+            CfgAbi::VecDefault => Err("v20-v31 (vs52-vs63) are reserved on vec-default ABI"),
+            CfgAbi::VecExtAbi => Ok(()),
             abi => unreachable!("unrecognized AIX ABI: {abi}"),
         }
     } else {
@@ -122,7 +122,11 @@ fn spe_acc_target_check(
     target: &Target,
     _is_clobber: bool,
 ) -> Result<(), &'static str> {
-    if target.abi == Abi::Spe { Ok(()) } else { Err("spe_acc is only available on spe targets") }
+    if target.cfg_abi == CfgAbi::Spe {
+        Ok(())
+    } else {
+        Err("spe_acc is only available on spe targets")
+    }
 }
 
 def_regs! {
diff --git a/compiler/rustc_target/src/spec/base/aix.rs b/compiler/rustc_target/src/spec/base/aix.rs
index 76e8fb763e58..41cf3e001fdf 100644
--- a/compiler/rustc_target/src/spec/base/aix.rs
+++ b/compiler/rustc_target/src/spec/base/aix.rs
@@ -1,13 +1,13 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, BinaryFormat, Cc, CodeModel, LinkOutputKind, LinkerFlavor, Os, TargetOptions, crt_objects,
-    cvs,
+    BinaryFormat, Cc, CfgAbi, CodeModel, LinkOutputKind, LinkerFlavor, Os, TargetOptions,
+    crt_objects, cvs,
 };
 
 pub(crate) fn opts() -> TargetOptions {
     TargetOptions {
-        abi: Abi::VecExtAbi,
+        cfg_abi: CfgAbi::VecExtAbi,
         code_model: Some(CodeModel::Large),
         cpu: "pwr7".into(),
         os: Os::Aix,
diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index 18b41d10062b..d1d91cbd3788 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -4,7 +4,7 @@
 use std::str::FromStr;
 
 use crate::spec::{
-    Abi, BinaryFormat, Cc, DebuginfoKind, Env, FloatAbi, FramePointer, LinkerFlavor, Lld, Os,
+    BinaryFormat, Cc, CfgAbi, DebuginfoKind, Env, FloatAbi, FramePointer, LinkerFlavor, Lld, Os,
     RustcAbi, SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs,
 };
 
@@ -108,11 +108,11 @@ fn target_env(self) -> Env {
     //
     // But let's continue setting them for backwards compatibility.
     // FIXME(madsmtm): Warn about using these in the future.
-    fn target_abi(self) -> Abi {
+    fn target_abi(self) -> CfgAbi {
         match self {
-            Self::Normal => Abi::Unspecified,
-            Self::MacCatalyst => Abi::MacAbi,
-            Self::Simulator => Abi::Sim,
+            Self::Normal => CfgAbi::Unspecified,
+            Self::MacCatalyst => CfgAbi::MacAbi,
+            Self::Simulator => CfgAbi::Sim,
         }
     }
 }
@@ -135,7 +135,7 @@ pub(crate) fn base(
         },
         os,
         env: env.target_env(),
-        abi: env.target_abi(),
+        cfg_abi: env.target_abi(),
         cpu: arch.target_cpu(env).into(),
         link_env_remove,
         vendor: "apple".into(),
diff --git a/compiler/rustc_target/src/spec/base/apple/tests.rs b/compiler/rustc_target/src/spec/base/apple/tests.rs
index fd3fd6da9116..f178698afb49 100644
--- a/compiler/rustc_target/src/spec/base/apple/tests.rs
+++ b/compiler/rustc_target/src/spec/base/apple/tests.rs
@@ -4,7 +4,7 @@
     aarch64_apple_watchos_sim, i686_apple_darwin, x86_64_apple_darwin, x86_64_apple_ios,
     x86_64_apple_tvos, x86_64_apple_watchos_sim,
 };
-use crate::spec::{Abi, Env};
+use crate::spec::{CfgAbi, Env};
 
 #[test]
 fn simulator_targets_set_env() {
@@ -21,7 +21,7 @@ fn simulator_targets_set_env() {
     for target in &all_sim_targets {
         assert_eq!(target.env, Env::Sim);
         // Ensure backwards compat
-        assert_eq!(target.abi, Abi::Sim);
+        assert_eq!(target.cfg_abi, CfgAbi::Sim);
     }
 }
 
diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
index 3bd8ebd0ed3d..1a69c8ef65f9 100644
--- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
+++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs
@@ -2,7 +2,7 @@
 
 use crate::spec::crt_objects::pre_mingw_self_contained;
 use crate::spec::{
-    Abi, BinaryFormat, Cc, DebuginfoKind, Env, LinkSelfContainedDefault, LinkerFlavor, Lld, Os,
+    BinaryFormat, Cc, CfgAbi, DebuginfoKind, Env, LinkSelfContainedDefault, LinkerFlavor, Lld, Os,
     SplitDebuginfo, TargetOptions, add_link_args, cvs,
 };
 
@@ -26,7 +26,7 @@ pub(crate) fn opts() -> TargetOptions {
         os: Os::Windows,
         env: Env::Gnu,
         vendor: "pc".into(),
-        abi: Abi::Llvm,
+        cfg_abi: CfgAbi::Llvm,
         linker: Some("clang".into()),
         dynamic_linking: true,
         dll_tls_export: false,
diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs
index 0f009fffae8d..d1adc891ad21 100644
--- a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs
+++ b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Cc, LinkArgs, LinkerFlavor, Lld, TargetOptions, add_link_args, base};
+use crate::spec::{Cc, CfgAbi, LinkArgs, LinkerFlavor, Lld, TargetOptions, add_link_args, base};
 
 pub(crate) fn opts() -> TargetOptions {
     let base = base::windows_gnu::opts();
@@ -23,7 +23,7 @@ pub(crate) fn opts() -> TargetOptions {
     let late_link_args_static = LinkArgs::new();
 
     TargetOptions {
-        abi: Abi::Uwp,
+        cfg_abi: CfgAbi::Uwp,
         vendor: "uwp".into(),
         limit_rdylib_exports: false,
         late_link_args,
diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs
index 15832989f085..b9b2f4248e6c 100644
--- a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs
+++ b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs
@@ -1,8 +1,8 @@
-use crate::spec::{Abi, LinkerFlavor, Lld, TargetOptions, base};
+use crate::spec::{CfgAbi, LinkerFlavor, Lld, TargetOptions, base};
 
 pub(crate) fn opts() -> TargetOptions {
     let mut opts =
-        TargetOptions { abi: Abi::Uwp, vendor: "uwp".into(), ..base::windows_msvc::opts() };
+        TargetOptions { cfg_abi: CfgAbi::Uwp, vendor: "uwp".into(), ..base::windows_msvc::opts() };
 
     opts.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["/APPCONTAINER", "mincore.lib"]);
 
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index d8ef2484a95c..22186552f695 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -5,7 +5,7 @@
 
 use super::crt_objects::CrtObjects;
 use super::{
-    Abi, Arch, BinaryFormat, CodeModel, DebuginfoKind, Env, FloatAbi, FramePointer, LinkArgsCli,
+    Arch, BinaryFormat, CfgAbi, CodeModel, DebuginfoKind, Env, FloatAbi, FramePointer, LinkArgsCli,
     LinkSelfContainedComponents, LinkSelfContainedDefault, LinkerFlavorCli, LldFlavor,
     MergeFunctions, Os, PanicStrategy, RelocModel, RelroLevel, RustcAbi, SanitizerSet,
     SmallDataThresholdSupport, SplitDebuginfo, StackProbeType, StaticCow, SymbolVisibility, Target,
@@ -69,7 +69,9 @@ macro_rules! forward_opt {
         forward_opt!(c_enum_min_bits); // if None, matches c_int_width
         forward!(os);
         forward!(env);
-        forward!(abi);
+        if let Some(abi) = json.abi {
+            base.cfg_abi = abi;
+        }
         forward!(vendor);
         forward_opt!(linker);
         forward!(linker_flavor_json);
@@ -297,7 +299,7 @@ macro_rules! target_option_val {
         target_option_val!(c_int_width, "target-c-int-width");
         target_option_val!(os);
         target_option_val!(env);
-        target_option_val!(abi);
+        target_option_val!(cfg_abi, "abi");
         target_option_val!(vendor);
         target_option_val!(linker);
         target_option_val!(linker_flavor_json, "linker-flavor");
@@ -505,7 +507,7 @@ struct TargetSpecJson {
     c_enum_min_bits: Option<u64>,
     os: Option<Os>,
     env: Option<Env>,
-    abi: Option<Abi>,
+    abi: Option<CfgAbi>,
     vendor: Option<StaticCow<str>>,
     linker: Option<StaticCow<str>>,
     #[serde(rename = "linker-flavor")]
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 8683e4f51279..1cbd0374ab17 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2065,7 +2065,10 @@ pub fn desc_symbol(&self) -> Symbol {
 }
 
 crate::target_spec_enum! {
-    pub enum Abi {
+    /// An enum representing possible values for `cfg(target_abi)`.
+    /// This field is not forwarded to LLVM so it does not by itself affect codegen.
+    /// See the `cfg_abi` field of [`TargetOptions`] for more details.
+    pub enum CfgAbi {
         Abi64 = "abi64",
         AbiV2 = "abiv2",
         AbiV2Hf = "abiv2hf",
@@ -2090,7 +2093,7 @@ pub enum Abi {
     other_variant = Other;
 }
 
-impl Abi {
+impl CfgAbi {
     pub fn desc_symbol(&self) -> Symbol {
         Symbol::intern(self.desc())
     }
@@ -2221,13 +2224,18 @@ pub struct TargetOptions {
     pub os: Os,
     /// Environment name to use for conditional compilation (`target_env`). Defaults to [`Env::Unspecified`].
     pub env: Env,
-    /// ABI name to distinguish multiple ABIs on the same OS and architecture. For instance, `"eabi"`
-    /// or `"eabihf"`. Defaults to [`Abi::Unspecified`].
-    /// This field is *not* forwarded directly to LLVM and therefore does not control which ABI (in
-    /// the sense of function calling convention) is actually used; its primary purpose is
-    /// `cfg(target_abi)`. The actual calling convention is controlled by `llvm_abiname`,
-    /// `llvm_floatabi`, and `rustc_abi`.
-    pub abi: Abi,
+    /// ABI name to distinguish multiple ABIs on the same OS and architecture. For instance,
+    /// `"eabi"` or `"eabihf"`. Defaults to [`CfgAbi::Unspecified`].
+    /// The only purpose of this field is to control `cfg(target_abi)`. This does not control the
+    /// calling convention used by this target! The actual calling convention is controlled by
+    /// `llvm_abiname`, `llvm_floatabi`, and `rustc_abi`.
+    ///
+    /// In a target spec, this field generally *informs* the user about what the ABI is, but you
+    /// have to also set up other parts of the target spec to ensure that this information is
+    /// correct. In the rest of the compiler, do not check this field if what you actually need to
+    /// know about is the calling convention. Most targets have an open-ended set of values for this
+    /// field.
+    pub cfg_abi: CfgAbi,
     /// Vendor name to use for conditional compilation (`target_vendor`). Defaults to "unknown".
     #[rustc_lint_opt_deny_field_access(
         "use `Target::is_like_*` instead of this field; see https://github.com/rust-lang/rust/issues/100343 for rationale"
@@ -2550,7 +2558,6 @@ pub struct TargetOptions {
     /// Picks a specific ABI for this target. This is *not* just for "Rust" ABI functions,
     /// it can also affect "C" ABI functions; the point is that this flag is interpreted by
     /// rustc and not forwarded to LLVM.
-    /// So far, this is only used on x86.
     pub rustc_abi: Option<RustcAbi>,
 
     /// Whether or not RelaxElfRelocation flag will be passed to the linker
@@ -2739,7 +2746,7 @@ fn default() -> TargetOptions {
             c_int_width: 32,
             os: Os::None,
             env: Env::Unspecified,
-            abi: Abi::Unspecified,
+            cfg_abi: CfgAbi::Unspecified,
             vendor: "unknown".into(),
             linker: option_env!("CFG_DEFAULT_LINKER").map(|s| s.into()),
             linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No),
@@ -3191,19 +3198,25 @@ macro_rules! check_matches {
                 check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on x86-32");
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on x86-32");
                 check_matches!(
-                    (&self.rustc_abi, &self.abi),
+                    (&self.rustc_abi, &self.cfg_abi),
                     // FIXME: we do not currently set a target_abi for softfloat targets here,
                     // but we probably should, so we already allow it.
-                    (Some(RustcAbi::Softfloat), Abi::SoftFloat | Abi::Unspecified | Abi::Other(_))
-                        | (
-                            Some(RustcAbi::X86Sse2) | None,
-                            Abi::Uwp | Abi::Llvm | Abi::Sim | Abi::Unspecified | Abi::Other(_)
-                        ),
+                    (
+                        Some(RustcAbi::Softfloat),
+                        CfgAbi::SoftFloat | CfgAbi::Unspecified | CfgAbi::Other(_)
+                    ) | (
+                        Some(RustcAbi::X86Sse2) | None,
+                        CfgAbi::Uwp
+                            | CfgAbi::Llvm
+                            | CfgAbi::Sim
+                            | CfgAbi::Unspecified
+                            | CfgAbi::Other(_)
+                    ),
                     "invalid x86-32 Rust-specific ABI and `cfg(target_abi)` combination:\n\
                     Rust-specific ABI: {:?}\n\
                     cfg(target_abi): {}",
                     self.rustc_abi,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::X86_64 => {
@@ -3214,40 +3227,42 @@ macro_rules! check_matches {
                 // FIXME: Ensure that target_abi = "x32" correlates with actually using that ABI.
                 // Do any of the others need a similar check?
                 check_matches!(
-                    (&self.rustc_abi, &self.abi),
-                    (Some(RustcAbi::Softfloat), Abi::SoftFloat | Abi::Unspecified | Abi::Other(_))
-                        | (
-                            None,
-                            Abi::X32
-                                | Abi::Llvm
-                                | Abi::Fortanix
-                                | Abi::Uwp
-                                | Abi::MacAbi
-                                | Abi::Sim
-                                | Abi::Unspecified
-                                | Abi::Other(_)
-                        ),
+                    (&self.rustc_abi, &self.cfg_abi),
+                    (
+                        Some(RustcAbi::Softfloat),
+                        CfgAbi::SoftFloat | CfgAbi::Unspecified | CfgAbi::Other(_)
+                    ) | (
+                        None,
+                        CfgAbi::X32
+                            | CfgAbi::Llvm
+                            | CfgAbi::Fortanix
+                            | CfgAbi::Uwp
+                            | CfgAbi::MacAbi
+                            | CfgAbi::Sim
+                            | CfgAbi::Unspecified
+                            | CfgAbi::Other(_)
+                    ),
                     "invalid x86-64 Rust-specific ABI and `cfg(target_abi)` combination:\n\
                     Rust-specific ABI: {:?}\n\
                     cfg(target_abi): {}",
                     self.rustc_abi,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::RiscV32 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
-                    ("ilp32", Abi::Unspecified | Abi::Other(_))
-                        | ("ilp32f", Abi::Unspecified | Abi::Other(_))
-                        | ("ilp32d", Abi::Unspecified | Abi::Other(_))
-                        | ("ilp32e", Abi::Ilp32e),
+                    (&*self.llvm_abiname, &self.cfg_abi),
+                    ("ilp32", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("ilp32f", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("ilp32d", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("ilp32e", CfgAbi::Ilp32e),
                     "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::RiscV64 => {
@@ -3255,32 +3270,32 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
-                    ("lp64", Abi::Unspecified | Abi::Other(_))
-                        | ("lp64f", Abi::Unspecified | Abi::Other(_))
-                        | ("lp64d", Abi::Unspecified | Abi::Other(_))
-                        | ("lp64e", Abi::Unspecified | Abi::Other(_)),
+                    (&*self.llvm_abiname, &self.cfg_abi),
+                    ("lp64", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("lp64f", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("lp64d", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("lp64e", CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::Arm => {
                 check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on ARM");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on ARM");
                 check_matches!(
-                    (&self.llvm_floatabi, &self.abi),
+                    (&self.llvm_floatabi, &self.cfg_abi),
                     (
                         Some(FloatAbi::Hard),
-                        Abi::EabiHf | Abi::Uwp | Abi::Unspecified | Abi::Other(_)
-                    ) | (Some(FloatAbi::Soft), Abi::Eabi),
+                        CfgAbi::EabiHf | CfgAbi::Uwp | CfgAbi::Unspecified | CfgAbi::Other(_)
+                    ) | (Some(FloatAbi::Soft), CfgAbi::Eabi),
                     "Invalid combination of float ABI and `cfg(target_abi)` for ARM target\n\
                      float ABI: {:?}\n\
                      cfg(target_abi): {}",
                     self.llvm_floatabi,
-                    self.abi,
+                    self.cfg_abi,
                 )
             }
             Arch::AArch64 => {
@@ -3289,23 +3304,23 @@ macro_rules! check_matches {
                 // FIXME: Ensure that target_abi = "ilp32" correlates with actually using that ABI.
                 // Do any of the others need a similar check?
                 check_matches!(
-                    (&self.rustc_abi, &self.abi),
-                    (Some(RustcAbi::Softfloat), Abi::SoftFloat)
+                    (&self.rustc_abi, &self.cfg_abi),
+                    (Some(RustcAbi::Softfloat), CfgAbi::SoftFloat)
                         | (
                             None,
-                            Abi::Ilp32
-                                | Abi::Llvm
-                                | Abi::MacAbi
-                                | Abi::Sim
-                                | Abi::Uwp
-                                | Abi::Unspecified
-                                | Abi::Other(_)
+                            CfgAbi::Ilp32
+                                | CfgAbi::Llvm
+                                | CfgAbi::MacAbi
+                                | CfgAbi::Sim
+                                | CfgAbi::Uwp
+                                | CfgAbi::Unspecified
+                                | CfgAbi::Other(_)
                         ),
                     "invalid aarch64 Rust-specific ABI and `cfg(target_abi)` combination:\n\
                     Rust-specific ABI: {:?}\n\
                     cfg(target_abi): {}",
                     self.rustc_abi,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::PowerPC => {
@@ -3315,8 +3330,8 @@ macro_rules! check_matches {
                 // FIXME: Check that `target_abi` matches the actually configured ABI (with or
                 // without SPE).
                 check_matches!(
-                    self.abi,
-                    Abi::Spe | Abi::Unspecified | Abi::Other(_),
+                    self.cfg_abi,
+                    CfgAbi::Spe | CfgAbi::Unspecified | CfgAbi::Other(_),
                     "invalid `target_abi` for PowerPC"
                 );
             }
@@ -3328,33 +3343,33 @@ macro_rules! check_matches {
                     // FIXME: Check that `target_abi` matches the actually configured ABI
                     // (vec-default vs vec-ext).
                     check_matches!(
-                        (&*self.llvm_abiname, &self.abi),
-                        ("", Abi::VecDefault | Abi::VecExtAbi),
+                        (&*self.llvm_abiname, &self.cfg_abi),
+                        ("", CfgAbi::VecDefault | CfgAbi::VecExtAbi),
                         "invalid PowerPC64 AIX ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
                         self.llvm_abiname,
-                        self.abi,
+                        self.cfg_abi,
                     );
                 } else if self.endian == Endian::Big {
                     check_matches!(
-                        (&*self.llvm_abiname, &self.abi),
-                        ("elfv1", Abi::ElfV1) | ("elfv2", Abi::ElfV2),
+                        (&*self.llvm_abiname, &self.cfg_abi),
+                        ("elfv1", CfgAbi::ElfV1) | ("elfv2", CfgAbi::ElfV2),
                         "invalid PowerPC64 big-endian ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
                         self.llvm_abiname,
-                        self.abi,
+                        self.cfg_abi,
                     );
                 } else {
                     check_matches!(
-                        (&*self.llvm_abiname, &self.abi),
-                        ("elfv2", Abi::ElfV2),
+                        (&*self.llvm_abiname, &self.cfg_abi),
+                        ("elfv2", CfgAbi::ElfV2),
                         "invalid PowerPC64 little-endian ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
                         self.llvm_abiname,
-                        self.abi,
+                        self.cfg_abi,
                     );
                 }
             }
@@ -3362,72 +3377,72 @@ macro_rules! check_matches {
                 check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on s390x");
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on s390x");
                 check_matches!(
-                    (&self.rustc_abi, &self.abi),
-                    (Some(RustcAbi::Softfloat), Abi::SoftFloat)
-                        | (None, Abi::Unspecified | Abi::Other(_)),
+                    (&self.rustc_abi, &self.cfg_abi),
+                    (Some(RustcAbi::Softfloat), CfgAbi::SoftFloat)
+                        | (None, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid s390x Rust-specific ABI and `cfg(target_abi)` combination:\n\
                     Rust-specific ABI: {:?}\n\
                     cfg(target_abi): {}",
                     self.rustc_abi,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::LoongArch32 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
-                    ("ilp32s", Abi::SoftFloat)
-                        | ("ilp32f", Abi::Unspecified | Abi::Other(_))
-                        | ("ilp32d", Abi::Unspecified | Abi::Other(_)),
+                    (&*self.llvm_abiname, &self.cfg_abi),
+                    ("ilp32s", CfgAbi::SoftFloat)
+                        | ("ilp32f", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("ilp32d", CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::LoongArch64 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
-                    ("lp64s", Abi::SoftFloat)
-                        | ("lp64f", Abi::Unspecified | Abi::Other(_))
-                        | ("lp64d", Abi::Unspecified | Abi::Other(_)),
+                    (&*self.llvm_abiname, &self.cfg_abi),
+                    ("lp64s", CfgAbi::SoftFloat)
+                        | ("lp64f", CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | ("lp64d", CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::Mips | Arch::Mips32r6 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
-                    ("o32", Abi::Unspecified | Abi::Other(_)),
+                    (&*self.llvm_abiname, &self.cfg_abi),
+                    ("o32", CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::Mips64 | Arch::Mips64r6 => {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.abi),
+                    (&*self.llvm_abiname, &self.cfg_abi),
                     // No in-tree targets use "n32" but at least for now we let out-of-tree targets
                     // experiment with that.
-                    ("n64", Abi::Abi64) | ("n32", Abi::Unspecified | Abi::Other(_)),
+                    ("n64", CfgAbi::Abi64) | ("n32", CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
                     self.llvm_abiname,
-                    self.abi,
+                    self.cfg_abi,
                 );
             }
             Arch::CSky => {
@@ -3436,8 +3451,8 @@ macro_rules! check_matches {
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on CSky");
                 // FIXME: Check that `target_abi` matches the actually configured ABI (v2 vs v2hf).
                 check_matches!(
-                    self.abi,
-                    Abi::AbiV2 | Abi::AbiV2Hf,
+                    self.cfg_abi,
+                    CfgAbi::AbiV2 | CfgAbi::AbiV2Hf,
                     "invalid `target_abi` for CSky"
                 );
             }
@@ -3449,8 +3464,8 @@ macro_rules! check_matches {
                     check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on {arch}");
                     check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on {arch}");
                     check_matches!(
-                        self.abi,
-                        Abi::Unspecified | Abi::Other(_),
+                        self.cfg_abi,
+                        CfgAbi::Unspecified | CfgAbi::Other(_),
                         "`target_abi` is unused on {arch}"
                     );
                 }
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs
index 4abd5553eb97..8a432ca2c2d2 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs
@@ -1,7 +1,7 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, CfgAbi, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
         arch: Arch::AArch64,
         options: TargetOptions {
-            abi: Abi::Ilp32,
+            cfg_abi: CfgAbi::Ilp32,
             features: "+v8a,+outline-atomics".into(),
             // the AAPCS64 expects use of non-leaf frame pointers per
             // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
index e204c6466e29..c2d5449105be 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs
@@ -8,13 +8,13 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
     StackProbeType, Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::SoftFloat,
+        cfg_abi: CfgAbi::SoftFloat,
         rustc_abi: Some(RustcAbi::Softfloat),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs
index 22f2717b56b4..e8e7b847cc84 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, CfgAbi, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
         arch: Arch::AArch64,
         options: TargetOptions {
-            abi: Abi::Ilp32,
+            cfg_abi: CfgAbi::Ilp32,
             features: "+v8a,+outline-atomics".into(),
             // the AAPCS64 expects use of non-leaf frame pointers per
             // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
index ed2e2fb6ab70..4e42176cef72 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
@@ -7,13 +7,13 @@
 // For example, `-C target-cpu=cortex-a53`.
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
     StackProbeType, Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::SoftFloat,
+        cfg_abi: CfgAbi::SoftFloat,
         rustc_abi: Some(RustcAbi::Softfloat),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
index 6f11f97e3d1d..dbfdb4c0784a 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64v8r_unknown_none_softfloat.rs
@@ -1,11 +1,11 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
     StackProbeType, Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::SoftFloat,
+        cfg_abi: CfgAbi::SoftFloat,
         rustc_abi: Some(RustcAbi::Softfloat),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
diff --git a/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs
index 7dc6509fc823..5b0951ba9de7 100644
--- a/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Abi, Arch, FloatAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CfgAbi, FloatAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // https://developer.android.com/ndk/guides/abis.html#armeabi
             features: "+strict-align,+v5te".into(),
diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs
index cc63ffa2e2a5..5275113de23a 100644
--- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+strict-align,+v6".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
index 1cae42c14559..7dd36d6e82c4 100644
--- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+strict-align,+v6,+vfp2".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs
index 25ef767c4b10..5dce42042876 100644
--- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // Most of these settings are copied from the arm_unknown_linux_gnueabi
             // target.
diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs
index 99995e27af0d..5b1d1e2a5a48 100644
--- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Most of these settings are copied from the arm_unknown_linux_gnueabihf
             // target.
diff --git a/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs
index 73374bcdf0b1..df9ecd6fb94a 100644
--- a/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+strict-align,+v8,+crc".into(),
             endian: Endian::Big,
diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
index 7a62464aea4b..a4608522e68f 100644
--- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
@@ -3,8 +3,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             endian: Endian::Big,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
index 33147c5f1b09..4452b3ba3314 100644
--- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
@@ -3,8 +3,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             endian: Endian::Big,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
diff --git a/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs
index c917531932f6..176bdecca831 100644
--- a/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs
@@ -9,7 +9,7 @@
 //! The default link script is very likely wrong, so you should use
 //! `-Clink-arg=-Tmy_script.ld` to override that with a correct linker script.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv4t", "-mlittle-endian",],
             features: "+soft-float,+strict-align".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs
index 8c386011f89a..9d95a2bde2ca 100644
--- a/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
diff --git a/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs
index b8ae881f3dae..17065c8e86ca 100644
--- a/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs
@@ -1,6 +1,6 @@
 //! Targets the ARMv5TE architecture, with `a32` code by default.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv5te", "-mlittle-endian",],
             features: "+soft-float,+strict-align".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs
index d1fded203671..17ad14cb7763 100644
--- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs
index 2daf2ab4d8fe..b5a31a9821e2 100644
--- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
index b05df3a77a43..ac07c87bda76 100644
--- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
diff --git a/compiler/rustc_target/src/spec/targets/armv6_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv6_none_eabi.rs
index 48a196b231b0..c2c6ec4774e9 100644
--- a/compiler/rustc_target/src/spec/targets/armv6_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv6_none_eabi.rs
@@ -1,6 +1,6 @@
 //! Targets the ARMv6K architecture, with `a32` code by default.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv6", "-mlittle-endian",],
             features: "+soft-float,+strict-align,+v6k".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv6_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv6_none_eabihf.rs
index 8bc6b06ecee3..d4886ee16e91 100644
--- a/compiler/rustc_target/src/spec/targets/armv6_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv6_none_eabihf.rs
@@ -1,6 +1,6 @@
 //! Targets the ARMv6K architecture, with `a32` code by default, and hard-float ABI
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             asm_args: cvs!["-mthumb-interwork", "-march=armv6", "-mlittle-endian",],
             features: "+strict-align,+v6k,+vfp2,-d32".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs
index 6d6dfeed96b0..bd71c839e0b5 100644
--- a/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v6,+vfp2".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs
index cb931e6c0e33..5e5468d467d3 100644
--- a/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v6,+vfp2".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs
index ed2ab47c0e24..d2bdf747b8f1 100644
--- a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs
+++ b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -29,7 +29,7 @@ pub(crate) fn target() -> Target {
             env: Env::Newlib,
             vendor: "nintendo".into(),
             cpu: "mpcore".into(),
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             families: cvs!["unix"],
             linker: Some("arm-none-eabi-gcc".into()),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs
index 3ccb99c9ab0f..99adc85947ab 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, SanitizerSet, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, SanitizerSet, Target, TargetMetadata,
     TargetOptions, base,
 };
 
@@ -26,7 +26,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb-mode,+thumb2,+vfp3d16,-neon".into(),
             supported_sanitizers: SanitizerSet::ADDRESS,
diff --git a/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs
index 382658a87b54..90daac16bcc7 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
+    Arch, Cc, CfgAbi, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
     TargetMetadata, TargetOptions, cvs,
 };
 
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             os: Os::Rtems,
             families: cvs!["unix"],
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No),
             linker: None,
diff --git a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs
index 20e5c0acca96..56d129d7b523 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs
@@ -1,7 +1,7 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -34,7 +34,7 @@ pub(crate) fn target() -> Target {
             c_int_width: 32,
             env: Env::Newlib,
             vendor: "sony".into(),
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No),
             no_default_libraries: false,
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs
index c358b530f742..cd6d8b76f1a9 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs
index 8fad2ce19632..88f9b9e848d8 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for glibc Linux on ARMv7 without thumb-mode, NEON or
 // hardfloat.
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs
index 639a9d225729..a1f90b307c3c 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for glibc Linux on ARMv7 without NEON or
 // thumb-mode. See the thumbv7neon variant for enabling both.
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs
index 9bf0b4fd7e4c..66e1eb1115e5 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for musl Linux on ARMv7 without thumb-mode, NEON or
 // hardfloat.
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs
index fb7bd1226a37..6ce45de909a8 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for musl Linux on ARMv7 without thumb-mode or NEON.
 
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         // Most of these settings are copied from the armv7_unknown_linux_gnueabihf
         // target.
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs
index 318170fe0f8d..1709bef36f88 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for OpenHarmony on ARMv7 Linux with thumb-mode, but no NEON or
 // hardfloat.
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs
index 37a70da09c51..979a02bcb1c7 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for uclibc Linux on ARMv7 without NEON,
 // thumb-mode or hardfloat.
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb2,+soft-float,-neon".into(),
             cpu: "generic".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs
index 8fb38d315bf6..63845a1a555c 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for uclibc Linux on ARMv7 without NEON or
 // thumb-mode. See the thumbv7neon variant for enabling both.
@@ -23,7 +23,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic".into(),
             max_atomic_width: Some(64),
             mcount: "_mcount".into(),
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             ..base
         },
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs
index 8869210ce002..4000e395c5bc 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
index fb3954abb286..e561af2bbf30 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, FloatAbi, LinkSelfContainedDefault, Os, PanicStrategy, RelroLevel, Target,
+    Arch, CfgAbi, FloatAbi, LinkSelfContainedDefault, Os, PanicStrategy, RelroLevel, Target,
     TargetMetadata, TargetOptions,
 };
 
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs
index 27e81c5834f2..63f82a0d7e68 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs
index bd18d6d8ae90..8723dc0f1d29 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Abi, Arch, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CfgAbi, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     let base = base::solid::opts();
@@ -14,7 +16,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             linker: Some("arm-kmc-eabi-gcc".into()),
             features: "+v7,+soft-float,+thumb2,-neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs
index cb652e6a1e1b..b59ce32b48e0 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Abi, Arch, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CfgAbi, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     let base = base::solid::opts();
@@ -14,7 +16,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             linker: Some("arm-kmc-eabi-gcc".into()),
             features: "+v7,+vfp3d16,+thumb2,-neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
index e8c5c16d8eb5..01d55ce979e8 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,-neon,+strict-align".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
index 32a79e346adc..cbeb409110ff 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+vfp3d16,-neon,+strict-align".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs
index 5ab74e0533ba..9af6bacbf8e8 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs
@@ -5,13 +5,13 @@
 // configuration without hardware floating point support.
 
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
     TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::Eabi,
+        cfg_abi: CfgAbi::Eabi,
         llvm_floatabi: Some(FloatAbi::Soft),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs
index 4ac07e24a48b..5008f38d52e4 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs
@@ -5,13 +5,13 @@
 // configuration with hardware floating point support.
 
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
     TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::EabiHf,
+        cfg_abi: CfgAbi::EabiHf,
         llvm_floatabi: Some(FloatAbi::Hard),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
index b83d7b090689..cf4ea3ce9502 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
+    Arch, Cc, CfgAbi, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target,
     TargetMetadata, TargetOptions,
 };
 
@@ -11,7 +11,7 @@ pub(crate) fn target() -> Target {
         env: Env::V5,
         os: Os::VexOs,
         cpu: "cortex-a9".into(),
-        abi: Abi::EabiHf,
+        cfg_abi: CfgAbi::EabiHf,
         is_like_vexos: true,
         llvm_floatabi: Some(FloatAbi::Hard),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
index 114b079f360b..382f862e99ff 100644
--- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(64),
             has_thumb_interworking: true,
diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
index 1c6114f9fc83..b8d0ea226710 100644
--- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+vfp3d16".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
index 16006e4c52cf..a488637f885d 100644
--- a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R52 processor (ARMv8-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Armv8-R requires a minimum set of floating-point features equivalent to:
             // fp-armv8, SP-only, with 16 DP (32 SP) registers
diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs
index 176b853493ef..72193fc7bc24 100644
--- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs
+++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Abi, Arch, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base,
+};
 
 // This target is for glibc Linux on Csky
 
@@ -16,7 +18,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32-v128:32:32-a:0:32-Fi32-n32".into(),
         arch: Arch::CSky,
         options: TargetOptions {
-            abi: Abi::AbiV2,
+            cfg_abi: CfgAbi::AbiV2,
             features: "+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(),
             late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a"]),
             max_atomic_width: Some(32),
diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs
index 5af54493063d..cf4493249542 100644
--- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs
+++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Abi, Arch, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base,
+};
 
 // This target is for glibc Linux on Csky
 
@@ -16,7 +18,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32-v128:32:32-a:0:32-Fi32-n32".into(),
         arch: Arch::CSky,
         options: TargetOptions {
-            abi: Abi::AbiV2Hf,
+            cfg_abi: CfgAbi::AbiV2Hf,
             cpu: "ck860fv".into(),
             features: "+hard-float,+hard-float-abi,+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(),
             late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a", "-mhard-float"]),
diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
index 896cf0f59d58..22f55975f18c 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "generic".into(),
             features: "-f,-d".into(),
-            abi: Abi::SoftFloat,
+            cfg_abi: CfgAbi::SoftFloat,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             llvm_abiname: "ilp32s".into(),
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
index efeb864de1a7..948b9cf1e1f2 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Abi, Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "generic".into(),
             features: "-f,-d".into(),
-            abi: Abi::SoftFloat,
+            cfg_abi: CfgAbi::SoftFloat,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             llvm_abiname: "lp64s".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
index f90e689912e1..52ce49193d51 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
@@ -2,7 +2,7 @@
 
 use rustc_abi::Endian;
 
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Mips64,
         options: TargetOptions {
             vendor: "openwrt".into(),
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             mcount: "_mcount".into(),
             llvm_abiname: "n64".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
index ecb66b43712c..87a7ef539e90 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             // NOTE(mips64r2) matches C toolchain
             cpu: "mips64r2".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
index ccb13fee37a1..574dd77b93d1 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             mcount: "_mcount".into(),
             llvm_abiname: "n64".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
index 2457bd838c57..e8e689b7c0c7 100644
--- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             // NOTE(mips64r2) matches C toolchain
             cpu: "mips64r2".into(),
             features: "+mips64r2,+xgot".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
index 41353729df8f..9564a6bbd099 100644
--- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             mcount: "_mcount".into(),
             llvm_abiname: "n64".into(),
             ..base
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
index fb97a2e65eab..24c91d7b023a 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64r6,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             // NOTE(mips64r6) matches C toolchain
             cpu: "mips64r6".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
index 556962458fa5..fb5ff0cfc14a 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
         arch: Arch::Mips64r6,
         options: TargetOptions {
-            abi: Abi::Abi64,
+            cfg_abi: CfgAbi::Abi64,
             // NOTE(mips64r6) matches C toolchain
             cpu: "mips64r6".into(),
             features: "+mips64r6".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
index f5d5698713c2..bfb32d359fa7 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
index e2dada235271..ac2ad608f11d 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV1;
+    base.cfg_abi = CfgAbi::ElfV1;
     base.llvm_abiname = "elfv1".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
index 130bcacfc8cc..793bf0a8c5be 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
index 082358e82be1..b0a722861736 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
index f576d2372bfa..2244a01de944 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV1;
+    base.cfg_abi = CfgAbi::ElfV1;
     base.llvm_abiname = "elfv1".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
index b2713af3bd56..7b6f9417a36e 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -8,7 +9,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
index 550ad563e6f2..3a84e1c77dd1 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -8,7 +9,7 @@ pub(crate) fn target() -> Target {
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
index 38e3d09c2c35..d55164652c68 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +11,7 @@ pub(crate) fn target() -> Target {
     base.stack_probes = StackProbeType::Inline;
     // FIXME(compiler-team#422): musl targets should be dynamically linked by default.
     base.crt_static_default = true;
-    base.abi = Abi::ElfV2;
+    base.cfg_abi = CfgAbi::ElfV2;
     base.llvm_abiname = "elfv2".into();
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs
index 49620305e0e8..88655c9b22a6 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),
         arch: Arch::PowerPC,
         options: TargetOptions {
-            abi: Abi::Spe,
+            cfg_abi: CfgAbi::Spe,
             endian: Endian::Big,
             features: "+secure-plt,+msync".into(),
             mcount: "_mcount".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
index 210a80fe422e..c61ceab6bd39 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),
         arch: Arch::PowerPC,
         options: TargetOptions {
-            abi: Abi::Spe,
+            cfg_abi: CfgAbi::Spe,
             endian: Endian::Big,
             features: "+msync".into(),
             mcount: "_mcount".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs
index 041580f2bdaf..8f7aaa025bcc 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
         data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),
         arch: Arch::PowerPC,
         options: TargetOptions {
-            abi: Abi::Spe,
+            cfg_abi: CfgAbi::Spe,
             endian: Endian::Big,
             // feature msync would disable instruction 'fsync' which is not supported by fsl_p1p2
             features: "+secure-plt,+msync".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
index 65dbd391db74..b3fc52f816d3 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::RiscV32,
 
         options: TargetOptions {
-            abi: Abi::Ilp32e,
+            cfg_abi: CfgAbi::Ilp32e,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
index 0826326a2b4b..ee9c99482ebb 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::RiscV32,
 
         options: TargetOptions {
-            abi: Abi::Ilp32e,
+            cfg_abi: CfgAbi::Ilp32e,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
index e37a44e1edc4..ab462afabc0d 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::RiscV32,
 
         options: TargetOptions {
-            abi: Abi::Ilp32e,
+            cfg_abi: CfgAbi::Ilp32e,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
diff --git a/compiler/rustc_target/src/spec/targets/s390x_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/s390x_unknown_none_softfloat.rs
index 7d42c1fd9244..8c411091ff50 100644
--- a/compiler/rustc_target/src/spec/targets/s390x_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/s390x_unknown_none_softfloat.rs
@@ -1,13 +1,13 @@
 use rustc_abi::{Align, Endian};
 
 use crate::spec::{
-    Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
     StackProbeType, Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
     let opts = TargetOptions {
-        abi: Abi::SoftFloat,
+        cfg_abi: CfgAbi::SoftFloat,
         cpu: "z10".into(),
         endian: Endian::Big,
         features: "+soft-float,-vector".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs
index dfb8ccb06bc2..83bbfff1063f 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs
@@ -9,7 +9,7 @@
 //! The default link script is very likely wrong, so you should use
 //! `-Clink-arg=-Tmy_script.ld` to override that with a correct linker script.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv4t", "-mlittle-endian",],
             features: "+soft-float,+strict-align".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs
index 3b41208b69f4..7d2f910a22e4 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs
@@ -1,6 +1,6 @@
 //! Targets the ARMv5TE architecture, with `t32` code by default.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv5te", "-mlittle-endian",],
             features: "+soft-float,+strict-align".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv6_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv6_none_eabi.rs
index 077f02818085..45a122164a14 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv6_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv6_none_eabi.rs
@@ -1,6 +1,6 @@
 //! Targets the ARMv6K architecture, with `t32` code by default.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             asm_args: cvs!["-mthumb-interwork", "-march=armv6", "-mlittle-endian",],
             features: "+soft-float,+strict-align,+v6k".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs
index cc81cb92be6b..19b59197b81a 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // The ARMv6-M architecture doesn't support unaligned loads/stores so we disable them
             // with +strict-align.
diff --git a/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs
index 8b58d2e16eec..2536152cbb78 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture)
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // The ARMv6-M architecture doesn't support unaligned loads/stores so we disable them
             // with +strict-align.
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
index ce11e3f0875c..011307a50c34 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+soft-float,-neon,+strict-align".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
index 12210e9c2b01..4baa73c3cdb8 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+vfp3d16,-neon,+strict-align".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs
index 17d25a67acbd..8eaebe7befd9 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs
@@ -4,7 +4,7 @@
 // and will use software floating point operations. This matches the NuttX EABI
 // configuration without hardware floating point support.
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // Cortex-A7/A8/A9 with software floating point
             features: "+soft-float,-neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs
index a4e17004e7bf..ea070f093090 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs
@@ -7,7 +7,7 @@
 // This target uses the "hard" floating convention (ABI) where floating point values
 // are passed to/from subroutines via FPU registers (S0, S1, D0, D1, etc.).
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -25,7 +25,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Cortex-A7/A8/A9 support VFPv3-D32/VFPv4-D32 with optional double-precision
             // and NEON SIMD instructions
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs
index 6e6975c01f81..a9d766080ffb 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs
@@ -9,7 +9,7 @@
 // To opt-in to hardware accelerated floating point operations, you can use, for example,
 // `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -25,7 +25,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs
index 6a7fe14a26df..6af82f89b277 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs
@@ -8,7 +8,7 @@
 //
 // To opt into double precision hardware support, use the `-C target-feature=+fp64` flag.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // vfp4 is the lowest common denominator between the Cortex-M4F (vfp4) and the
             // Cortex-M7 (vfp5).
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs
index 10173273b5d8..3166a01ae888 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs
@@ -9,7 +9,7 @@
 // To opt-in to hardware accelerated floating point operations, you can use, for example,
 // `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`.
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -27,7 +27,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs
index 1f24155a7dab..3e5e7dad4f66 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs
@@ -8,7 +8,7 @@
 //
 // To opt into double precision hardware support, use the `-C target-feature=+fp64` flag.
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -26,7 +26,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // vfp4 is the lowest common denominator between the Cortex-M4F (vfp4) and the
             // Cortex-M7 (vfp5).
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs
index 8851f7b63437..d38d2aca0f57 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M3 processor (ARMv7-M)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs
index 9f0261c69b3f..7e42c91cb714 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M3 processor (ARMv7-M)
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs
index 3ffa30129298..56c581b3a6cf 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base,
+    Arch, Cc, CfgAbi, FloatAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base,
 };
 
 // This target if is for the Android v7a ABI in thumb mode with
@@ -25,7 +25,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             features: "+v7,+thumb-mode,+thumb2,+vfp3,+neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs
index 36b99516d377..5829d37cf826 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for glibc Linux on ARMv7 with thumb mode enabled
 // (for consistency with Android and Debian-based distributions)
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
             features: "+v7,+thumb-mode,+thumb2,+vfp3,+neon".into(),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs
index 41c4bc91f701..dc4f8987d5d2 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 // This target is for musl Linux on ARMv7 with thumb mode enabled
 // (for consistency with Android and Debian-based distributions)
@@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
         // Most of these settings are copied from the thumbv7neon_unknown_linux_gnueabihf
         // target.
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+v7,+thumb-mode,+thumb2,+vfp3,+neon".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
index bf71d31a06ec..da66a5343200 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(64),
             has_thumb_interworking: true,
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
index 88b5e6764403..d591db8faf6a 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             features: "+vfp3d16".into(),
             max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs
index 7426eb9bd5e2..b9193a246cde 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M23 processor (Baseline ARMv8-M)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // ARMv8-M baseline doesn't support unaligned loads/stores so we disable them
             // with +strict-align.
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs
index a74719ba2f0c..1e786a4ee60f 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs
@@ -1,6 +1,6 @@
 // Targets the Cortex-M23 processor (Baseline ARMv8-M)
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             // ARMv8-M baseline doesn't support unaligned loads/stores so we disable them
             // with +strict-align.
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs
index 540d4bdee07c..a3a8da45b413 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs
@@ -1,7 +1,7 @@
 // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
 // without the Floating Point extension.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs
index 2287cce395aa..d8058ba0074c 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs
@@ -1,7 +1,7 @@
 // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
 // with the Floating Point extension.
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // If the Floating Point extension is implemented in the Cortex-M33
             // processor, the Cortex-M33 Technical Reference Manual states that
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs
index ec107292d529..e1320666053c 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs
@@ -1,7 +1,7 @@
 // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
 // without the Floating Point extension.
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::Eabi,
+            cfg_abi: CfgAbi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
             max_atomic_width: Some(32),
             ..base::arm_none::opts()
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs
index 9ff924b6386b..e3ba784bfb89 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs
@@ -1,7 +1,7 @@
 // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
 // with the Floating Point extension.
 
-use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             families: cvs!["unix"],
             os: Os::NuttX,
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // If the Floating Point extension is implemented in the Cortex-M33
             // processor, the Cortex-M33 Technical Reference Manual states that
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs
index 87434cd7353c..459dff9c1aa9 100644
--- a/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs
@@ -1,6 +1,6 @@
 // Targets the Little-endian Cortex-R52 processor (ARMv8-R)
 
-use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Arm,
 
         options: TargetOptions {
-            abi: Abi::EabiHf,
+            cfg_abi: CfgAbi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
             // Armv8-R requires a minimum set of floating-point features equivalent to:
             // fp-armv8, SP-only, with 16 DP (32 SP) registers
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs
index cd074a468fd6..1204719c923f 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use crate::spec::{
-    Abi, Arch, Cc, Env, LinkerFlavor, Lld, Os, Target, TargetMetadata, TargetOptions, cvs,
+    Arch, Cc, CfgAbi, Env, LinkerFlavor, Lld, Os, Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -60,7 +60,7 @@ pub(crate) fn target() -> Target {
         os: Os::Unknown,
         env: Env::Sgx,
         vendor: "fortanix".into(),
-        abi: Abi::Fortanix,
+        cfg_abi: CfgAbi::Fortanix,
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         linker: Some("rust-lld".into()),
         max_atomic_width: Some(64),
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs
index 7e06a718e480..793d235aa77d 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs
@@ -1,9 +1,11 @@
-use crate::spec::{Abi, Arch, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base};
+use crate::spec::{
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base,
+};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_gnu::opts();
     base.cpu = "x86-64".into();
-    base.abi = Abi::X32;
+    base.cfg_abi = CfgAbi::X32;
     base.max_atomic_width = Some(64);
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mx32"]);
     base.stack_probes = StackProbeType::Inline;

From 6b1487698cda66825960f84b48c1d6a0ccaed253 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 14 Mar 2026 10:26:22 +0100
Subject: [PATCH 0766/1059] enum-ify llvm_abiname

---
 compiler/rustc_codegen_llvm/src/back/write.rs |   2 +-
 compiler/rustc_codegen_llvm/src/context.rs    |   5 +-
 compiler/rustc_codegen_llvm/src/va_arg.rs     |   4 +-
 .../rustc_codegen_ssa/src/back/metadata.rs    |  38 ++---
 .../rustc_target/src/callconv/loongarch.rs    |   8 +-
 .../rustc_target/src/callconv/powerpc64.rs    |   6 +-
 compiler/rustc_target/src/callconv/riscv.rs   |   8 +-
 compiler/rustc_target/src/spec/json.rs        |   4 +-
 compiler/rustc_target/src/spec/mod.rs         | 131 ++++++++++++------
 .../spec/targets/loongarch32_unknown_none.rs  |   5 +-
 .../loongarch32_unknown_none_softfloat.rs     |   6 +-
 .../targets/loongarch64_unknown_linux_gnu.rs  |   6 +-
 .../targets/loongarch64_unknown_linux_musl.rs |   6 +-
 .../targets/loongarch64_unknown_linux_ohos.rs |   6 +-
 .../spec/targets/loongarch64_unknown_none.rs  |   6 +-
 .../loongarch64_unknown_none_softfloat.rs     |   4 +-
 .../spec/targets/mips64_openwrt_linux_musl.rs |   4 +-
 .../targets/mips64_unknown_linux_gnuabi64.rs  |   4 +-
 .../targets/mips64_unknown_linux_muslabi64.rs |   4 +-
 .../mips64el_unknown_linux_gnuabi64.rs        |   4 +-
 .../mips64el_unknown_linux_muslabi64.rs       |   4 +-
 .../src/spec/targets/mips_mti_none_elf.rs     |   5 +-
 .../spec/targets/mips_unknown_linux_gnu.rs    |   4 +-
 .../spec/targets/mips_unknown_linux_musl.rs   |   4 +-
 .../spec/targets/mips_unknown_linux_uclibc.rs |   4 +-
 .../src/spec/targets/mipsel_mti_none_elf.rs   |   5 +-
 .../src/spec/targets/mipsel_sony_psp.rs       |   5 +-
 .../src/spec/targets/mipsel_sony_psx.rs       |   4 +-
 .../spec/targets/mipsel_unknown_linux_gnu.rs  |   4 +-
 .../spec/targets/mipsel_unknown_linux_musl.rs |   4 +-
 .../targets/mipsel_unknown_linux_uclibc.rs    |   4 +-
 .../src/spec/targets/mipsel_unknown_netbsd.rs |   4 +-
 .../src/spec/targets/mipsel_unknown_none.rs   |   5 +-
 .../targets/mipsisa32r6_unknown_linux_gnu.rs  |   4 +-
 .../mipsisa32r6el_unknown_linux_gnu.rs        |   4 +-
 .../mipsisa64r6_unknown_linux_gnuabi64.rs     |   4 +-
 .../mipsisa64r6el_unknown_linux_gnuabi64.rs   |   4 +-
 .../spec/targets/powerpc64_unknown_freebsd.rs |   6 +-
 .../targets/powerpc64_unknown_linux_gnu.rs    |   6 +-
 .../targets/powerpc64_unknown_linux_musl.rs   |   6 +-
 .../spec/targets/powerpc64_unknown_openbsd.rs |   6 +-
 .../src/spec/targets/powerpc64_wrs_vxworks.rs |   6 +-
 .../targets/powerpc64le_unknown_freebsd.rs    |   6 +-
 .../targets/powerpc64le_unknown_linux_gnu.rs  |   6 +-
 .../targets/powerpc64le_unknown_linux_musl.rs |   6 +-
 .../src/spec/targets/riscv32_wrs_vxworks.rs   |   4 +-
 .../spec/targets/riscv32e_unknown_none_elf.rs |   6 +-
 .../targets/riscv32em_unknown_none_elf.rs     |   6 +-
 .../targets/riscv32emc_unknown_none_elf.rs    |   6 +-
 .../targets/riscv32gc_unknown_linux_gnu.rs    |   6 +-
 .../targets/riscv32gc_unknown_linux_musl.rs   |   6 +-
 .../spec/targets/riscv32i_unknown_none_elf.rs |   5 +-
 .../spec/targets/riscv32im_risc0_zkvm_elf.rs  |   4 +-
 .../targets/riscv32im_unknown_none_elf.rs     |   5 +-
 .../targets/riscv32ima_unknown_none_elf.rs    |   5 +-
 .../spec/targets/riscv32imac_esp_espidf.rs    |   4 +-
 .../targets/riscv32imac_unknown_none_elf.rs   |   5 +-
 .../targets/riscv32imac_unknown_nuttx_elf.rs  |   4 +-
 .../targets/riscv32imac_unknown_xous_elf.rs   |   4 +-
 .../spec/targets/riscv32imafc_esp_espidf.rs   |   4 +-
 .../targets/riscv32imafc_unknown_none_elf.rs  |   5 +-
 .../targets/riscv32imafc_unknown_nuttx_elf.rs |   4 +-
 .../src/spec/targets/riscv32imc_esp_espidf.rs |   4 +-
 .../targets/riscv32imc_unknown_none_elf.rs    |   5 +-
 .../targets/riscv32imc_unknown_nuttx_elf.rs   |   4 +-
 .../src/spec/targets/riscv64_linux_android.rs |   5 +-
 .../src/spec/targets/riscv64_wrs_vxworks.rs   |   4 +-
 .../targets/riscv64a23_unknown_linux_gnu.rs   |   6 +-
 .../spec/targets/riscv64gc_unknown_freebsd.rs |   4 +-
 .../spec/targets/riscv64gc_unknown_fuchsia.rs |   6 +-
 .../spec/targets/riscv64gc_unknown_hermit.rs  |   4 +-
 .../targets/riscv64gc_unknown_linux_gnu.rs    |   6 +-
 .../targets/riscv64gc_unknown_linux_musl.rs   |   6 +-
 .../riscv64gc_unknown_managarm_mlibc.rs       |   4 +-
 .../spec/targets/riscv64gc_unknown_netbsd.rs  |   4 +-
 .../targets/riscv64gc_unknown_none_elf.rs     |   6 +-
 .../targets/riscv64gc_unknown_nuttx_elf.rs    |   6 +-
 .../spec/targets/riscv64gc_unknown_openbsd.rs |   4 +-
 .../spec/targets/riscv64gc_unknown_redox.rs   |   4 +-
 .../targets/riscv64im_unknown_none_elf.rs     |   6 +-
 .../targets/riscv64imac_unknown_none_elf.rs   |   6 +-
 .../targets/riscv64imac_unknown_nuttx_elf.rs  |   6 +-
 compiler/rustc_target/src/target_features.rs  |  22 +--
 83 files changed, 334 insertions(+), 252 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index efd4e55d5a85..90e31880840d 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -233,7 +233,7 @@ pub(crate) fn target_machine_factory(
     let triple = SmallCStr::new(&versioned_llvm_target(sess));
     let cpu = SmallCStr::new(llvm_util::target_cpu(sess));
     let features = CString::new(target_features.join(",")).unwrap();
-    let abi = SmallCStr::new(&sess.target.llvm_abiname);
+    let abi = SmallCStr::new(sess.target.llvm_abiname.desc());
     let trap_unreachable =
         sess.opts.unstable_opts.trap_unreachable.unwrap_or(sess.target.trap_unreachable);
     let emit_stack_size_section = sess.opts.unstable_opts.emit_stack_sizes;
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 2ad79e9147e0..e02c4ae6ea69 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -509,14 +509,13 @@ pub(crate) unsafe fn create_module<'ll>(
     // to workaround lld as the LTO plugin not
     // correctly setting target-abi for the LTO object
     // FIXME: https://github.com/llvm/llvm-project/issues/50591
-    // If llvm_abiname is empty, emit nothing.
     let llvm_abiname = &sess.target.options.llvm_abiname;
-    if matches!(sess.target.arch, Arch::RiscV32 | Arch::RiscV64) && !llvm_abiname.is_empty() {
+    if matches!(sess.target.arch, Arch::RiscV32 | Arch::RiscV64) {
         llvm::add_module_flag_str(
             llmod,
             llvm::ModuleFlagMergeBehavior::Error,
             "target-abi",
-            llvm_abiname,
+            llvm_abiname.desc(),
         );
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index 98d2c3f131b0..fbe9cb813fc5 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -8,7 +8,7 @@
 use rustc_middle::bug;
 use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
-use rustc_target::spec::{Arch, Env, RustcAbi};
+use rustc_target::spec::{Arch, Env, LlvmAbi, RustcAbi};
 
 use crate::builder::Builder;
 use crate::llvm::{Type, Value};
@@ -1077,7 +1077,7 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             AllowHigherAlign::Yes,
             ForceRightAdjust::Yes,
         ),
-        Arch::RiscV32 if target.llvm_abiname == "ilp32e" => {
+        Arch::RiscV32 if target.llvm_abiname == LlvmAbi::Ilp32e => {
             // FIXME: clang manually adjusts the alignment for this ABI. It notes:
             //
             // > To be compatible with GCC's behaviors, we force arguments with
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 27504e6e2145..f6544c035145 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -20,7 +20,7 @@
 use rustc_middle::bug;
 use rustc_session::Session;
 use rustc_span::sym;
-use rustc_target::spec::{CfgAbi, Os, RelocModel, Target, ef_avr_arch};
+use rustc_target::spec::{CfgAbi, LlvmAbi, Os, RelocModel, Target, ef_avr_arch};
 use tracing::debug;
 
 use super::apple;
@@ -295,10 +295,10 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
             };
 
             // Use the explicitly given ABI.
-            match sess.target.options.llvm_abiname.as_ref() {
-                "o32" if is_32bit => e_flags |= elf::EF_MIPS_ABI_O32,
-                "n32" if !is_32bit => e_flags |= elf::EF_MIPS_ABI2,
-                "n64" if !is_32bit => {}
+            match &sess.target.options.llvm_abiname {
+                LlvmAbi::O32 if is_32bit => e_flags |= elf::EF_MIPS_ABI_O32,
+                LlvmAbi::N32 if !is_32bit => e_flags |= elf::EF_MIPS_ABI2,
+                LlvmAbi::N64 if !is_32bit => {}
                 // The rest is invalid (which is already ensured by the target spec check).
                 s => bug!("invalid LLVM ABI `{}` for MIPS target", s),
             };
@@ -336,12 +336,12 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
 
             // Set the appropriate flag based on ABI
             // This needs to match LLVM `RISCVELFStreamer.cpp`
-            match &*sess.target.llvm_abiname {
-                "ilp32" | "lp64" => (),
-                "ilp32f" | "lp64f" => e_flags |= elf::EF_RISCV_FLOAT_ABI_SINGLE,
-                "ilp32d" | "lp64d" => e_flags |= elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+            match &sess.target.llvm_abiname {
+                LlvmAbi::Ilp32 | LlvmAbi::Lp64 => (),
+                LlvmAbi::Ilp32f | LlvmAbi::Lp64f => e_flags |= elf::EF_RISCV_FLOAT_ABI_SINGLE,
+                LlvmAbi::Ilp32d | LlvmAbi::Lp64d => e_flags |= elf::EF_RISCV_FLOAT_ABI_DOUBLE,
                 // Note that the `lp64e` is still unstable as it's not (yet) part of the ELF psABI.
-                "ilp32e" | "lp64e" => e_flags |= elf::EF_RISCV_RVE,
+                LlvmAbi::Ilp32e | LlvmAbi::Lp64e => e_flags |= elf::EF_RISCV_RVE,
                 _ => bug!("unknown RISC-V ABI name"),
             }
 
@@ -353,10 +353,10 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
 
             // Set the appropriate flag based on ABI
             // This needs to match LLVM `LoongArchELFStreamer.cpp`
-            match &*sess.target.llvm_abiname {
-                "ilp32s" | "lp64s" => e_flags |= elf::EF_LARCH_ABI_SOFT_FLOAT,
-                "ilp32f" | "lp64f" => e_flags |= elf::EF_LARCH_ABI_SINGLE_FLOAT,
-                "ilp32d" | "lp64d" => e_flags |= elf::EF_LARCH_ABI_DOUBLE_FLOAT,
+            match &sess.target.llvm_abiname {
+                LlvmAbi::Ilp32s | LlvmAbi::Lp64s => e_flags |= elf::EF_LARCH_ABI_SOFT_FLOAT,
+                LlvmAbi::Ilp32f | LlvmAbi::Lp64f => e_flags |= elf::EF_LARCH_ABI_SINGLE_FLOAT,
+                LlvmAbi::Ilp32d | LlvmAbi::Lp64d => e_flags |= elf::EF_LARCH_ABI_DOUBLE_FLOAT,
                 _ => bug!("unknown LoongArch ABI name"),
             }
 
@@ -383,14 +383,14 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {
             const EF_PPC64_ABI_ELF_V1: u32 = 1;
             const EF_PPC64_ABI_ELF_V2: u32 = 2;
 
-            match sess.target.options.llvm_abiname.as_ref() {
+            match sess.target.options.llvm_abiname {
                 // If the flags do not correctly indicate the ABI,
                 // linkers such as ld.lld assume that the ppc64 object files are always ELFv2
                 // which leads to broken binaries if ELFv1 is used for the object files.
-                "elfv1" => EF_PPC64_ABI_ELF_V1,
-                "elfv2" => EF_PPC64_ABI_ELF_V2,
-                "" if sess.target.options.binary_format.to_object() == BinaryFormat::Elf => {
-                    bug!("No ABI specified for this PPC64 ELF target");
+                LlvmAbi::ElfV1 => EF_PPC64_ABI_ELF_V1,
+                LlvmAbi::ElfV2 => EF_PPC64_ABI_ELF_V2,
+                _ if sess.target.options.binary_format.to_object() == BinaryFormat::Elf => {
+                    bug!("invalid ABI specified for this PPC64 ELF target");
                 }
                 // Fall back
                 _ => EF_PPC64_ABI_UNKNOWN,
diff --git a/compiler/rustc_target/src/callconv/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
index 054e9a00ea6f..6d3826abf27a 100644
--- a/compiler/rustc_target/src/callconv/loongarch.rs
+++ b/compiler/rustc_target/src/callconv/loongarch.rs
@@ -4,7 +4,7 @@
 };
 
 use crate::callconv::{ArgAbi, ArgExtension, CastTarget, FnAbi, PassMode, Uniform};
-use crate::spec::HasTargetSpec;
+use crate::spec::{HasTargetSpec, LlvmAbi};
 
 #[derive(Copy, Clone)]
 enum RegPassKind {
@@ -415,9 +415,9 @@ pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
     C: HasDataLayout + HasTargetSpec,
 {
     let xlen = cx.data_layout().pointer_size().bits();
-    let flen = match &cx.target_spec().llvm_abiname[..] {
-        "ilp32f" | "lp64f" => 32,
-        "ilp32d" | "lp64d" => 64,
+    let flen = match &cx.target_spec().llvm_abiname {
+        LlvmAbi::Ilp32f | LlvmAbi::Lp64f => 32,
+        LlvmAbi::Ilp32d | LlvmAbi::Lp64d => 64,
         _ => 0,
     };
 
diff --git a/compiler/rustc_target/src/callconv/powerpc64.rs b/compiler/rustc_target/src/callconv/powerpc64.rs
index 683b615eec83..d807617491d1 100644
--- a/compiler/rustc_target/src/callconv/powerpc64.rs
+++ b/compiler/rustc_target/src/callconv/powerpc64.rs
@@ -5,7 +5,7 @@
 use rustc_abi::{Endian, HasDataLayout, TyAbiInterface};
 
 use crate::callconv::{Align, ArgAbi, FnAbi, Reg, RegKind, Uniform};
-use crate::spec::{HasTargetSpec, Os};
+use crate::spec::{HasTargetSpec, LlvmAbi, Os};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum ABI {
@@ -106,9 +106,9 @@ pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
     Ty: TyAbiInterface<'a, C> + Copy,
     C: HasDataLayout + HasTargetSpec,
 {
-    let abi = if cx.target_spec().options.llvm_abiname == "elfv2" {
+    let abi = if cx.target_spec().options.llvm_abiname == LlvmAbi::ElfV2 {
         ELFv2
-    } else if cx.target_spec().options.llvm_abiname == "elfv1" {
+    } else if cx.target_spec().options.llvm_abiname == LlvmAbi::ElfV1 {
         ELFv1
     } else if cx.target_spec().os == Os::Aix {
         AIX
diff --git a/compiler/rustc_target/src/callconv/riscv.rs b/compiler/rustc_target/src/callconv/riscv.rs
index 18efdc5804fb..bc81ec95c86e 100644
--- a/compiler/rustc_target/src/callconv/riscv.rs
+++ b/compiler/rustc_target/src/callconv/riscv.rs
@@ -10,7 +10,7 @@
 };
 
 use crate::callconv::{ArgAbi, ArgExtension, CastTarget, FnAbi, PassMode, Uniform};
-use crate::spec::HasTargetSpec;
+use crate::spec::{HasTargetSpec, LlvmAbi};
 
 #[derive(Copy, Clone)]
 enum RegPassKind {
@@ -419,9 +419,9 @@ pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
     Ty: TyAbiInterface<'a, C> + Copy,
     C: HasDataLayout + HasTargetSpec,
 {
-    let flen = match &cx.target_spec().llvm_abiname[..] {
-        "ilp32f" | "lp64f" => 32,
-        "ilp32d" | "lp64d" => 64,
+    let flen = match &cx.target_spec().llvm_abiname {
+        LlvmAbi::Ilp32f | LlvmAbi::Lp64f => 32,
+        LlvmAbi::Ilp32d | LlvmAbi::Lp64d => 64,
         _ => 0,
     };
     let xlen = cx.data_layout().pointer_size().bits();
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index 22186552f695..5507af086675 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -12,7 +12,7 @@
     TargetKind, TargetOptions, TargetWarnings, TlsModel,
 };
 use crate::json::{Json, ToJson};
-use crate::spec::AbiMap;
+use crate::spec::{AbiMap, LlvmAbi};
 
 impl Target {
     /// Loads a target descriptor from a JSON object.
@@ -611,7 +611,7 @@ struct TargetSpecJson {
     #[serde(rename = "target-mcount")]
     mcount: Option<StaticCow<str>>,
     llvm_mcount_intrinsic: Option<StaticCow<str>>,
-    llvm_abiname: Option<StaticCow<str>>,
+    llvm_abiname: Option<LlvmAbi>,
     llvm_floatabi: Option<FloatAbi>,
     rustc_abi: Option<RustcAbi>,
     relax_elf_relocations: Option<bool>,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 1cbd0374ab17..b04c4889be23 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2099,6 +2099,34 @@ pub fn desc_symbol(&self) -> Symbol {
     }
 }
 
+crate::target_spec_enum! {
+    /// An enum representing possible values for the `llvm_abiname` field of [`TargetOptions`].
+    /// This field is used by LLVM on some targets to control which ABI to use.
+    pub enum LlvmAbi {
+        // RISC-V and LoongArch
+        Ilp32 = "ilp32",
+        Ilp32f = "ilp32f",
+        Ilp32d = "ilp32d",
+        Ilp32e = "ilp32e",
+        Ilp32s = "ilp32s",
+        Lp64 = "lp64",
+        Lp64f = "lp64f",
+        Lp64d = "lp64d",
+        Lp64e = "lp64e",
+        Lp64s = "lp64s",
+        // MIPS
+        O32 = "o32",
+        N32 = "n32",
+        N64 = "n64",
+        // PowerPC
+        ElfV1 = "elfv1",
+        ElfV2 = "elfv2",
+
+        Unspecified = "",
+    }
+    other_variant = Other;
+}
+
 /// Everything `rustc` knows about how to compile for a specific target.
 ///
 /// Every field here must be specified, and has no default value.
@@ -2545,7 +2573,7 @@ pub struct TargetOptions {
 
     /// LLVM ABI name, corresponds to the '-mabi' parameter available in multilib C compilers
     /// and the `-target-abi` flag in llc. In the LLVM API this is `MCOptions.ABIName`.
-    pub llvm_abiname: StaticCow<str>,
+    pub llvm_abiname: LlvmAbi,
 
     /// Control the float ABI to use, for architectures that support it. The only architecture we
     /// currently use this for is ARM. Corresponds to the `-float-abi` flag in llc. In the LLVM API
@@ -2842,7 +2870,7 @@ fn default() -> TargetOptions {
             merge_functions: MergeFunctions::Aliases,
             mcount: "mcount".into(),
             llvm_mcount_intrinsic: None,
-            llvm_abiname: "".into(),
+            llvm_abiname: LlvmAbi::Unspecified,
             llvm_floatabi: None,
             rustc_abi: None,
             relax_elf_relocations: false,
@@ -3195,7 +3223,10 @@ macro_rules! check_matches {
         // new cases.
         match self.arch {
             Arch::X86 => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on x86-32");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on x86-32"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on x86-32");
                 check_matches!(
                     (&self.rustc_abi, &self.cfg_abi),
@@ -3220,7 +3251,10 @@ macro_rules! check_matches {
                 );
             }
             Arch::X86_64 => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on x86-64");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on x86-64"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on x86-64");
                 // FIXME: we do not currently set a target_abi for softfloat targets here, but we
                 // probably should, so we already allow it.
@@ -3253,11 +3287,11 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
-                    ("ilp32", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("ilp32f", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("ilp32d", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("ilp32e", CfgAbi::Ilp32e),
+                    (&self.llvm_abiname, &self.cfg_abi),
+                    (LlvmAbi::Ilp32, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Ilp32f, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Ilp32d, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Ilp32e, CfgAbi::Ilp32e),
                     "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3270,11 +3304,11 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on RISC-V");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on RISC-V");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
-                    ("lp64", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("lp64f", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("lp64d", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("lp64e", CfgAbi::Unspecified | CfgAbi::Other(_)),
+                    (&self.llvm_abiname, &self.cfg_abi),
+                    (LlvmAbi::Lp64, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Lp64f, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Lp64d, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Lp64e, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid RISC-V ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3283,7 +3317,10 @@ macro_rules! check_matches {
                 );
             }
             Arch::Arm => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on ARM");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on ARM"
+                );
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on ARM");
                 check_matches!(
                     (&self.llvm_floatabi, &self.cfg_abi),
@@ -3299,7 +3336,10 @@ macro_rules! check_matches {
                 )
             }
             Arch::AArch64 => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on aarch64");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on aarch64"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on aarch64");
                 // FIXME: Ensure that target_abi = "ilp32" correlates with actually using that ABI.
                 // Do any of the others need a similar check?
@@ -3324,7 +3364,10 @@ macro_rules! check_matches {
                 );
             }
             Arch::PowerPC => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on PowerPC");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on PowerPC"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on PowerPC");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on PowerPC");
                 // FIXME: Check that `target_abi` matches the actually configured ABI (with or
@@ -3343,8 +3386,8 @@ macro_rules! check_matches {
                     // FIXME: Check that `target_abi` matches the actually configured ABI
                     // (vec-default vs vec-ext).
                     check_matches!(
-                        (&*self.llvm_abiname, &self.cfg_abi),
-                        ("", CfgAbi::VecDefault | CfgAbi::VecExtAbi),
+                        (&self.llvm_abiname, &self.cfg_abi),
+                        (LlvmAbi::Unspecified, CfgAbi::VecDefault | CfgAbi::VecExtAbi),
                         "invalid PowerPC64 AIX ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
@@ -3353,8 +3396,8 @@ macro_rules! check_matches {
                     );
                 } else if self.endian == Endian::Big {
                     check_matches!(
-                        (&*self.llvm_abiname, &self.cfg_abi),
-                        ("elfv1", CfgAbi::ElfV1) | ("elfv2", CfgAbi::ElfV2),
+                        (&self.llvm_abiname, &self.cfg_abi),
+                        (LlvmAbi::ElfV1, CfgAbi::ElfV1) | (LlvmAbi::ElfV2, CfgAbi::ElfV2),
                         "invalid PowerPC64 big-endian ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
@@ -3363,8 +3406,8 @@ macro_rules! check_matches {
                     );
                 } else {
                     check_matches!(
-                        (&*self.llvm_abiname, &self.cfg_abi),
-                        ("elfv2", CfgAbi::ElfV2),
+                        (&self.llvm_abiname, &self.cfg_abi),
+                        (LlvmAbi::ElfV2, CfgAbi::ElfV2),
                         "invalid PowerPC64 little-endian ABI name and `cfg(target_abi)` combination:\n\
                         ABI name: {}\n\
                         cfg(target_abi): {}",
@@ -3374,7 +3417,10 @@ macro_rules! check_matches {
                 }
             }
             Arch::S390x => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on s390x");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on s390x"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on s390x");
                 check_matches!(
                     (&self.rustc_abi, &self.cfg_abi),
@@ -3391,10 +3437,10 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
-                    ("ilp32s", CfgAbi::SoftFloat)
-                        | ("ilp32f", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("ilp32d", CfgAbi::Unspecified | CfgAbi::Other(_)),
+                    (&self.llvm_abiname, &self.cfg_abi),
+                    (LlvmAbi::Ilp32s, CfgAbi::SoftFloat)
+                        | (LlvmAbi::Ilp32f, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Ilp32d, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3406,10 +3452,10 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on LoongArch");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on LoongArch");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
-                    ("lp64s", CfgAbi::SoftFloat)
-                        | ("lp64f", CfgAbi::Unspecified | CfgAbi::Other(_))
-                        | ("lp64d", CfgAbi::Unspecified | CfgAbi::Other(_)),
+                    (&self.llvm_abiname, &self.cfg_abi),
+                    (LlvmAbi::Lp64s, CfgAbi::SoftFloat)
+                        | (LlvmAbi::Lp64f, CfgAbi::Unspecified | CfgAbi::Other(_))
+                        | (LlvmAbi::Lp64d, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid LoongArch ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3421,8 +3467,8 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
-                    ("o32", CfgAbi::Unspecified | CfgAbi::Other(_)),
+                    (&self.llvm_abiname, &self.cfg_abi),
+                    (LlvmAbi::O32, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3434,10 +3480,11 @@ macro_rules! check_matches {
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on MIPS");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on MIPS");
                 check_matches!(
-                    (&*self.llvm_abiname, &self.cfg_abi),
+                    (&self.llvm_abiname, &self.cfg_abi),
                     // No in-tree targets use "n32" but at least for now we let out-of-tree targets
                     // experiment with that.
-                    ("n64", CfgAbi::Abi64) | ("n32", CfgAbi::Unspecified | CfgAbi::Other(_)),
+                    (LlvmAbi::N64, CfgAbi::Abi64)
+                        | (LlvmAbi::N32, CfgAbi::Unspecified | CfgAbi::Other(_)),
                     "invalid MIPS ABI name and `cfg(target_abi)` combination:\n\
                      ABI name: {}\n\
                      cfg(target_abi): {}",
@@ -3446,7 +3493,10 @@ macro_rules! check_matches {
                 );
             }
             Arch::CSky => {
-                check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on CSky");
+                check!(
+                    self.llvm_abiname == LlvmAbi::Unspecified,
+                    "`llvm_abiname` is unused on CSky"
+                );
                 check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on CSky");
                 check!(self.rustc_abi.is_none(), "`rustc_abi` is unused on CSky");
                 // FIXME: Check that `target_abi` matches the actually configured ABI (v2 vs v2hf).
@@ -3461,7 +3511,10 @@ macro_rules! check_matches {
                 // Ensure consistency among built-in targets, but give JSON targets the opportunity
                 // to experiment with these.
                 if kind == TargetKind::Builtin {
-                    check!(self.llvm_abiname.is_empty(), "`llvm_abiname` is unused on {arch}");
+                    check!(
+                        self.llvm_abiname == LlvmAbi::Unspecified,
+                        "`llvm_abiname` is unused on {arch}"
+                    );
                     check!(self.llvm_floatabi.is_none(), "`llvm_floatabi` is unused on {arch}");
                     check_matches!(
                         self.cfg_abi,
@@ -3680,7 +3733,7 @@ pub fn object_architecture(
                 // it using a custom target specification. N32
                 // is an ILP32 ABI like the Aarch64_Ilp32
                 // and X86_64_X32 cases above and below this one.
-                if self.options.llvm_abiname.as_ref() == "n32" {
+                if self.options.llvm_abiname == LlvmAbi::N32 {
                     Architecture::Mips64_N32
                 } else {
                     Architecture::Mips64
diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
index d9a4708a9c2d..2a53d4256b76 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -19,7 +20,7 @@ pub(crate) fn target() -> Target {
             features: "+f,+d".into(),
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "ilp32d".into(),
+            llvm_abiname: LlvmAbi::Ilp32d,
             max_atomic_width: Some(32),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
index 22f55975f18c..e9a9260db8ea 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
             cfg_abi: CfgAbi::SoftFloat,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "ilp32s".into(),
+            llvm_abiname: LlvmAbi::Ilp32s,
             max_atomic_width: Some(32),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
index 5936ea5e3c63..180d064570ab 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Arch, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +18,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
             features: "+f,+d,+lsx,+relax".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
index 2951b34ca966..246e28a243af 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Arch, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +18,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
             features: "+f,+d,+lsx,+relax".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             crt_static_default: false,
             supported_sanitizers: SanitizerSet::ADDRESS
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
index 1dab4febb90f..461a7bd26268 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Arch, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +18,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic".into(),
             features: "+f,+d,+lsx,+relax".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
index d8b509582017..2a9f0dcfd2ef 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
             features: "+f,+d,-lsx".into(),
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
index 948b9cf1e1f2..efed9778caab 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target,
+    Arch, Cc, CfgAbi, CodeModel, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
     TargetMetadata, TargetOptions,
 };
 
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
             cfg_abi: CfgAbi::SoftFloat,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "lp64s".into(),
+            llvm_abiname: LlvmAbi::Lp64s,
             max_atomic_width: Some(64),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
index 52ce49193d51..8b02e1235e60 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
@@ -2,7 +2,7 @@
 
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -27,7 +27,7 @@ pub(crate) fn target() -> Target {
             cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
             ..base
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
index 87a7ef539e90..14942885c6b9 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
             features: "+mips64r2,+xgot".into(),
             max_atomic_width: Some(64),
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
 
             ..base::linux_gnu::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
index 574dd77b93d1..c5336fd58fc9 100644
--- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -23,7 +23,7 @@ pub(crate) fn target() -> Target {
             cfg_abi: CfgAbi::Abi64,
             endian: Endian::Big,
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
             ..base
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
index e8e689b7c0c7..665cf1d4362d 100644
--- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
             features: "+mips64r2,+xgot".into(),
             max_atomic_width: Some(64),
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
 
             ..base::linux_gnu::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
index 9564a6bbd099..bd237eaedc66 100644
--- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cfg_abi: CfgAbi::Abi64,
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
             ..base
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
index ed024c6f9cd4..32440cdd92e9 100644
--- a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +25,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
 
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
 
             features: "+mips32r2,+soft-float,+noabicalls".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
index 9eb3173d64bc..8bfa8ecf6022 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
             features: "+mips32r2,+fpxx,+nooddspreg".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
index 5737e42f9919..316e59dea88b 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Mips,
         options: TargetOptions {
             endian: Endian::Big,
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             mcount: "_mcount".into(),
             ..base
         },
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
index d9bfa12169c3..b03dec5b5b6e 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
index 767c57e3e860..ce50cedef99f 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs
@@ -1,7 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +25,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Little,
             cpu: "mips32r2".into(),
 
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
 
             features: "+mips32r2,+soft-float,+noabicalls".into(),
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
index bc8f29c1bf1e..2fde3e9b24b7 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, RelocModel, Target, TargetMetadata, TargetOptions,
+    cvs,
 };
 
 // The PSP has custom linker requirements.
@@ -36,7 +37,7 @@ pub(crate) fn target() -> Target {
 
             // PSP does not support trap-on-condition instructions.
             llvm_args: cvs!["-mno-check-zero-division"],
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             pre_link_args,
             link_script: Some(LINKER_SCRIPT.into()),
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs
index 06631fdefb4a..cb88c7161f54 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -41,7 +41,7 @@ pub(crate) fn target() -> Target {
 
             // PSX does not support trap-on-condition instructions.
             llvm_args: cvs!["-mno-check-zero-division"],
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             panic_strategy: PanicStrategy::Abort,
             ..Default::default()
         },
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
index 752de4623e91..0541e0e9b2c5 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r2".into(),
             features: "+mips32r2,+fpxx,+nooddspreg".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
index fb3375285d50..5d0136a6699a 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
@@ -16,6 +16,6 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),
         arch: Arch::Mips,
-        options: TargetOptions { llvm_abiname: "o32".into(), mcount: "_mcount".into(), ..base },
+        options: TargetOptions { llvm_abiname: LlvmAbi::O32, mcount: "_mcount".into(), ..base },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
index 830cdd1238db..0add21bfc9c6 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
index 262062940030..5395c15ad581 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::netbsd::opts();
@@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::Mips,
         options: TargetOptions {
             features: "+soft-float".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             mcount: "__mcount".into(),
             endian: Endian::Little,
             ..base
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
index b66be0bef216..0e184c834801 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs
@@ -3,7 +3,8 @@
 //! Can be used for MIPS M4K core (e.g. on PIC32MX devices)
 
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -23,7 +24,7 @@ pub(crate) fn target() -> Target {
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             cpu: "mips32r2".into(),
             features: "+mips32r2,+soft-float,+noabicalls".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             linker: Some("rust-lld".into()),
             panic_strategy: PanicStrategy::Abort,
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
index 9b063365b8d5..80916500a431 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +18,7 @@ pub(crate) fn target() -> Target {
             endian: Endian::Big,
             cpu: "mips32r6".into(),
             features: "+mips32r6".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
index a5a05d56a492..87db5a282872 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             cpu: "mips32r6".into(),
             features: "+mips32r6".into(),
-            llvm_abiname: "o32".into(),
+            llvm_abiname: LlvmAbi::O32,
             max_atomic_width: Some(32),
             mcount: "_mcount".into(),
 
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
index 24c91d7b023a..8e66407470a2 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
@@ -1,6 +1,6 @@
 use rustc_abi::Endian;
 
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
             features: "+mips64r6".into(),
             max_atomic_width: Some(64),
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
 
             ..base::linux_gnu::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
index fb5ff0cfc14a..5523f4470bd5 100644
--- a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CfgAbi, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CfgAbi, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
             features: "+mips64r6".into(),
             max_atomic_width: Some(64),
             mcount: "_mcount".into(),
-            llvm_abiname: "n64".into(),
+            llvm_abiname: LlvmAbi::N64,
 
             ..base::linux_gnu::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
index bfb32d359fa7..537b21c54b7c 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs
@@ -1,8 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64-unknown-freebsd".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
index ac2ad608f11d..df7f115e99b0 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs
@@ -1,8 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV1;
-    base.llvm_abiname = "elfv1".into();
+    base.llvm_abiname = LlvmAbi::ElfV1;
 
     Target {
         llvm_target: "powerpc64-unknown-linux-gnu".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
index 793bf0a8c5be..474d20d2f054 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
@@ -1,8 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64-unknown-linux-musl".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
index b0a722861736..052dbf55724b 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs
@@ -1,8 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64-unknown-openbsd".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
index 2244a01de944..4a684fe97bb9 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs
@@ -1,8 +1,8 @@
 use rustc_abi::Endian;
 
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV1;
-    base.llvm_abiname = "elfv1".into();
+    base.llvm_abiname = LlvmAbi::ElfV1;
 
     Target {
         llvm_target: "powerpc64-unknown-linux-gnu".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
index 7b6f9417a36e..35c477d2bdaf 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +10,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64le-unknown-freebsd".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
index 3a84e1c77dd1..ae2c8714224b 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -10,7 +10,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64le-unknown-linux-gnu".into(),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
index d55164652c68..0060a41d79d0 100644
--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions,
-    base,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
     // FIXME(compiler-team#422): musl targets should be dynamically linked by default.
     base.crt_static_default = true;
     base.cfg_abi = CfgAbi::ElfV2;
-    base.llvm_abiname = "elfv2".into();
+    base.llvm_abiname = LlvmAbi::ElfV2;
 
     Target {
         llvm_target: "powerpc64le-unknown-linux-musl".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs
index 3ec8891c95ee..2e0a13f7bf39 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, StackProbeType, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, StackProbeType, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::RiscV32,
         options: TargetOptions {
             cpu: "generic-rv32".into(),
-            llvm_abiname: "ilp32d".into(),
+            llvm_abiname: LlvmAbi::Ilp32d,
             max_atomic_width: Some(32),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
             stack_probes: StackProbeType::Inline,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
index b3fc52f816d3..90dcf177c19a 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
             // The ilp32e ABI specifies the `data_layout`
-            llvm_abiname: "ilp32e".into(),
+            llvm_abiname: LlvmAbi::Ilp32e,
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+e,+forced-atomics".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
index ee9c99482ebb..cba18095725b 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
             // The ilp32e ABI specifies the `data_layout`
-            llvm_abiname: "ilp32e".into(),
+            llvm_abiname: LlvmAbi::Ilp32e,
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+e,+m,+forced-atomics".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
index ab462afabc0d..9de6ef9fab96 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CfgAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CfgAbi, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
             // The ilp32e ABI specifies the `data_layout`
-            llvm_abiname: "ilp32e".into(),
+            llvm_abiname: LlvmAbi::Ilp32e,
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+e,+m,+c,+forced-atomics".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs
index 29b0f35a205f..c11edf7c618c 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs
@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-use crate::spec::{Arch, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +20,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv32".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "ilp32d".into(),
+            llvm_abiname: LlvmAbi::Ilp32d,
             max_atomic_width: Some(32),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             ..base::linux_gnu::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs
index 28116052151e..e5618ea6b20d 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs
@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-use crate::spec::{Arch, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +20,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv32".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "ilp32d".into(),
+            llvm_abiname: LlvmAbi::Ilp32d,
             max_atomic_width: Some(32),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             ..base::linux_musl::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs
index bd6375fef163..2e4d83b564bd 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+forced-atomics".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs
index af25334a2e53..82cc02aacd1a 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -32,7 +32,7 @@ pub(crate) fn target() -> Target {
             atomic_cas: true,
 
             features: "+m".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             executables: true,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs
index 5aef58b153d1..f47102cb585f 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+m,+forced-atomics".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs
index c455f654b400..a96367473c3c 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -21,7 +22,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
             features: "+m,+a".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs
index 11a5626c5641..889152752043 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
+    Arch, Env, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -29,7 +29,7 @@ pub(crate) fn target() -> Target {
             atomic_cas: true,
 
             features: "+m,+a,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs
index deca348b9e1b..c27e7aab1a93 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -21,7 +22,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
             features: "+m,+a,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs
index 7205fb61de74..3a5a9424311d 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
             features: "+m,+a,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Unwind,
             relocation_model: RelocModel::Static,
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs
index 363e465e2ef4..6d8bf3095d98 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions,
 };
 
@@ -23,7 +23,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
             features: "+m,+a,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Unwind,
             relocation_model: RelocModel::Static,
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs
index b3a3ab9b7543..614d81f1e2b7 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
+    Arch, Env, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -26,7 +26,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(32),
             atomic_cas: true,
 
-            llvm_abiname: "ilp32f".into(),
+            llvm_abiname: LlvmAbi::Ilp32f,
             features: "+m,+a,+c,+f".into(),
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs
index 21f683516f7c..bf519fbe223a 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +21,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
-            llvm_abiname: "ilp32f".into(),
+            llvm_abiname: LlvmAbi::Ilp32f,
             features: "+m,+a,+c,+f".into(),
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs
index 0bba2e47dc85..045845acda06 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -23,7 +23,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
-            llvm_abiname: "ilp32f".into(),
+            llvm_abiname: LlvmAbi::Ilp32f,
             features: "+m,+a,+c,+f".into(),
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs
index f903bbdb04bf..cfec1b539eb2 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
+    Arch, Env, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -32,7 +32,7 @@ pub(crate) fn target() -> Target {
             atomic_cas: true,
 
             features: "+m,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs
index 0b8e44744206..1010039a6cb0 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs
@@ -1,5 +1,6 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target, TargetMetadata,
+    TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +23,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(32),
             atomic_cas: false,
             features: "+m,+c,+forced-atomics".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             emit_debug_gdb_scripts: false,
diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs
index d1d73842703e..6143080f485c 100644
--- a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
+    Arch, Cc, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, Target, TargetMetadata,
     TargetOptions, cvs,
 };
 
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv32".into(),
             max_atomic_width: Some(32),
             features: "+m,+c".into(),
-            llvm_abiname: "ilp32".into(),
+            llvm_abiname: LlvmAbi::Ilp32,
             panic_strategy: PanicStrategy::Unwind,
             relocation_model: RelocModel::Static,
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs b/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs
index 404f4143c5be..9842b9f82432 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs
@@ -1,7 +1,8 @@
 use std::borrow::Cow;
 
 use crate::spec::{
-    Arch, CodeModel, SanitizerSet, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+    Arch, CodeModel, LlvmAbi, SanitizerSet, SplitDebuginfo, Target, TargetMetadata, TargetOptions,
+    base,
 };
 
 pub(crate) fn target() -> Target {
@@ -20,7 +21,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+b,+v,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             supported_sanitizers: SanitizerSet::ADDRESS,
             max_atomic_width: Some(64),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
diff --git a/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs
index c6fffc251529..f3389b8eca98 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, StackProbeType, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, LlvmAbi, StackProbeType, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
         arch: Arch::RiscV64,
         options: TargetOptions {
             cpu: "generic-rv64".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
             stack_probes: StackProbeType::Inline,
diff --git a/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs
index bbcf31f89bad..f9a7d307c74a 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs
@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-use crate::spec::{Arch, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +20,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+rva23u64".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             ..base::linux_gnu::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs
index dbcfbc38ece6..d59d02641344 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CodeModel, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CodeModel, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             ..base::freebsd::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs
index 212704832e55..3944c4cd59c7 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs
@@ -1,11 +1,13 @@
-use crate::spec::{Arch, CodeModel, SanitizerSet, StackProbeType, Target, TargetMetadata, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SanitizerSet, StackProbeType, Target, TargetMetadata, base,
+};
 
 pub(crate) fn target() -> Target {
     let mut base = base::fuchsia::opts();
     base.code_model = Some(CodeModel::Medium);
     base.cpu = "generic-rv64".into();
     base.features = "+m,+a,+f,+d,+c,+zicsr,+zifencei".into();
-    base.llvm_abiname = "lp64d".into();
+    base.llvm_abiname = LlvmAbi::Lp64d;
     base.max_atomic_width = Some(64);
     base.stack_probes = StackProbeType::Inline;
     base.supported_sanitizers = SanitizerSet::SHADOWCALLSTACK;
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs
index 68f69044bb25..516610db1d80 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs
@@ -1,5 +1,5 @@
 use crate::spec::{
-    Arch, CodeModel, RelocModel, Target, TargetMetadata, TargetOptions, TlsModel, base,
+    Arch, CodeModel, LlvmAbi, RelocModel, Target, TargetMetadata, TargetOptions, TlsModel, base,
 };
 
 pub(crate) fn target() -> Target {
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             tls_model: TlsModel::LocalExec,
             max_atomic_width: Some(64),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             ..base::hermit::opts()
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs
index 333a63a25158..76c9ad65700c 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs
@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-use crate::spec::{Arch, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +20,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             ..base::linux_gnu::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs
index 6eba0994deb4..8ed4e09adbbf 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs
@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-use crate::spec::{Arch, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{
+    Arch, CodeModel, LlvmAbi, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base,
+};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -18,7 +20,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
             ..base::linux_musl::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs
index a9ecf27e9134..f837daf4ea9d 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CodeModel, Target, TargetOptions, base};
+use crate::spec::{Arch, CodeModel, LlvmAbi, Target, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             ..base::managarm_mlibc::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs
index bc929a07f9c0..564d9b2a6802 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CodeModel, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CodeModel, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             mcount: "__mcount".into(),
             ..base::netbsd::opts()
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs
index b06727efc9ee..f79cd50cf4c3 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target,
-    TargetMetadata, TargetOptions,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, SanitizerSet,
+    Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             cpu: "generic-rv64".into(),
             max_atomic_width: Some(64),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs
index 7850cc8105d9..9fde109c57f6 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, SanitizerSet, Target,
-    TargetMetadata, TargetOptions, cvs,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, SanitizerSet,
+    Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
             os: Os::NuttX,
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             cpu: "generic-rv64".into(),
             max_atomic_width: Some(64),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs
index fb7b077c963d..b93700704bf5 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs
@@ -1,4 +1,4 @@
-use crate::spec::{Arch, CodeModel, Target, TargetMetadata, TargetOptions, base};
+use crate::spec::{Arch, CodeModel, LlvmAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
             code_model: Some(CodeModel::Medium),
             cpu: "generic-rv64".into(),
             features: "+m,+a,+f,+d,+c,+zicsr,+zifencei".into(),
-            llvm_abiname: "lp64d".into(),
+            llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
             ..base::openbsd::opts()
         },
diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_redox.rs
index b6e88646d4e2..42132216576b 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_redox.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_redox.rs
@@ -1,11 +1,11 @@
-use crate::spec::{Arch, CodeModel, Target, TargetMetadata, base};
+use crate::spec::{Arch, CodeModel, LlvmAbi, Target, TargetMetadata, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::redox::opts();
     base.code_model = Some(CodeModel::Medium);
     base.cpu = "generic-rv64".into();
     base.features = "+m,+a,+f,+d,+c".into();
-    base.llvm_abiname = "lp64d".into();
+    base.llvm_abiname = LlvmAbi::Lp64d;
     base.plt_by_default = false;
     base.max_atomic_width = Some(64);
 
diff --git a/compiler/rustc_target/src/spec/targets/riscv64im_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64im_unknown_none_elf.rs
index 6aae40a3f90d..fb36efbc9069 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64im_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64im_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, Target,
+    TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -23,7 +23,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(64),
             atomic_cas: false,
             features: "+m,+forced-atomics".into(),
-            llvm_abiname: "lp64".into(),
+            llvm_abiname: LlvmAbi::Lp64,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             code_model: Some(CodeModel::Medium),
diff --git a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs
index 60ee41b47dfd..65c3f1a8d79f 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target,
-    TargetMetadata, TargetOptions,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, PanicStrategy, RelocModel, SanitizerSet,
+    Target, TargetMetadata, TargetOptions,
 };
 
 pub(crate) fn target() -> Target {
@@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv64".into(),
             max_atomic_width: Some(64),
             features: "+m,+a,+c".into(),
-            llvm_abiname: "lp64".into(),
+            llvm_abiname: LlvmAbi::Lp64,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             code_model: Some(CodeModel::Medium),
diff --git a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs
index b1a1817bbe1f..469c0d15abd8 100644
--- a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs
+++ b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs
@@ -1,6 +1,6 @@
 use crate::spec::{
-    Arch, Cc, CodeModel, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, SanitizerSet, Target,
-    TargetMetadata, TargetOptions, cvs,
+    Arch, Cc, CodeModel, LinkerFlavor, Lld, LlvmAbi, Os, PanicStrategy, RelocModel, SanitizerSet,
+    Target, TargetMetadata, TargetOptions, cvs,
 };
 
 pub(crate) fn target() -> Target {
@@ -24,7 +24,7 @@ pub(crate) fn target() -> Target {
             cpu: "generic-rv64".into(),
             max_atomic_width: Some(64),
             features: "+m,+a,+c".into(),
-            llvm_abiname: "lp64".into(),
+            llvm_abiname: LlvmAbi::Lp64,
             panic_strategy: PanicStrategy::Abort,
             relocation_model: RelocModel::Static,
             code_model: Some(CodeModel::Medium),
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 80674ab4cf8a..6a8540ca333e 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -5,7 +5,7 @@
 use rustc_macros::HashStable_Generic;
 use rustc_span::{Symbol, sym};
 
-use crate::spec::{Arch, FloatAbi, RustcAbi, Target};
+use crate::spec::{Arch, FloatAbi, LlvmAbi, RustcAbi, Target};
 
 /// Features that control behaviour of rustc, rather than the codegen.
 /// These exist globally and are not in the target-specific lists below.
@@ -1174,20 +1174,20 @@ pub fn abi_required_features(&self) -> FeatureConstraints {
             Arch::RiscV32 | Arch::RiscV64 => {
                 // RISC-V handles ABI in a very sane way, being fully explicit via `llvm_abiname`
                 // about what the intended ABI is.
-                match &*self.llvm_abiname {
-                    "ilp32d" | "lp64d" => {
+                match &self.llvm_abiname {
+                    LlvmAbi::Ilp32d | LlvmAbi::Lp64d => {
                         // Requires d (which implies f), incompatible with e and zfinx.
                         FeatureConstraints { required: &["d"], incompatible: &["e", "zfinx"] }
                     }
-                    "ilp32f" | "lp64f" => {
+                    LlvmAbi::Ilp32f | LlvmAbi::Lp64f => {
                         // Requires f, incompatible with e and zfinx.
                         FeatureConstraints { required: &["f"], incompatible: &["e", "zfinx"] }
                     }
-                    "ilp32" | "lp64" => {
+                    LlvmAbi::Ilp32 | LlvmAbi::Lp64 => {
                         // Requires nothing, incompatible with e.
                         FeatureConstraints { required: &[], incompatible: &["e"] }
                     }
-                    "ilp32e" => {
+                    LlvmAbi::Ilp32e => {
                         // ilp32e is documented to be incompatible with features that need aligned
                         // load/stores > 32 bits, like `d`. (One could also just generate more
                         // complicated code to align the stack when needed, but the RISCV
@@ -1198,7 +1198,7 @@ pub fn abi_required_features(&self) -> FeatureConstraints {
                         // a program while the rest doesn't know they even exist.
                         FeatureConstraints { required: &[], incompatible: &["d"] }
                     }
-                    "lp64e" => {
+                    LlvmAbi::Lp64e => {
                         // As above, `e` is not required.
                         NOTHING
                     }
@@ -1208,16 +1208,16 @@ pub fn abi_required_features(&self) -> FeatureConstraints {
             Arch::LoongArch32 | Arch::LoongArch64 => {
                 // LoongArch handles ABI in a very sane way, being fully explicit via `llvm_abiname`
                 // about what the intended ABI is.
-                match &*self.llvm_abiname {
-                    "ilp32d" | "lp64d" => {
+                match &self.llvm_abiname {
+                    LlvmAbi::Ilp32d | LlvmAbi::Lp64d => {
                         // Requires d (which implies f), incompatible with nothing.
                         FeatureConstraints { required: &["d"], incompatible: &[] }
                     }
-                    "ilp32f" | "lp64f" => {
+                    LlvmAbi::Ilp32f | LlvmAbi::Lp64f => {
                         // Requires f, incompatible with nothing.
                         FeatureConstraints { required: &["f"], incompatible: &[] }
                     }
-                    "ilp32s" | "lp64s" => {
+                    LlvmAbi::Ilp32s | LlvmAbi::Lp64s => {
                         // The soft-float ABI does not require any features and is also not
                         // incompatible with any features. Rust targets explicitly specify the
                         // LLVM ABI names, which allows for enabling hard-float support even on

From 70488173b7a7864f2d24f09399f40b7d7075c8e0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 12 Mar 2026 09:54:41 +0100
Subject: [PATCH 0767/1059] target specs: rename abi to cfg_abi

---
 src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 82c2e91b4b0f..cbbb0ccbbc21 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -46,7 +46,7 @@
 use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
 use rustc_span::{Symbol, sym};
-use rustc_target::spec::{Abi, Arch, Env, Os};
+use rustc_target::spec::{Arch, CfgAbi, Env, Os};
 
 pub use crate::config::*;
 use crate::prelude::*;
@@ -178,7 +178,7 @@ fn target_config(&self, sess: &Session) -> TargetConfig {
         let has_reliable_f16_f128 = !(sess.target.arch == Arch::X86_64
             && sess.target.os == Os::Windows
             && sess.target.env == Env::Gnu
-            && sess.target.abi != Abi::Llvm);
+            && sess.target.cfg_abi != CfgAbi::Llvm);
 
         // FIXME(f128): f128 math operations need f128 math symbols, which currently aren't always
         // filled in by compiler-builtins. The only libc that provides these currently is glibc.

From 4a0b26453d187ff2ef497628dd12cf1ef51a4641 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 22 Mar 2026 10:38:25 +0100
Subject: [PATCH 0768/1059] ensure Other variants are only used by JSON targets

---
 compiler/rustc_target/src/spec/mod.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index b04c4889be23..c4e44007b7f1 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -3218,6 +3218,27 @@ macro_rules! check_matches {
             );
         }
 
+        // Ensure built-in targets don't use the `Other` variants.
+        if kind == TargetKind::Builtin {
+            check!(
+                !matches!(self.arch, Arch::Other(_)),
+                "`Arch::Other` is only meant for JSON targets"
+            );
+            check!(!matches!(self.os, Os::Other(_)), "`Os::Other` is only meant for JSON targets");
+            check!(
+                !matches!(self.env, Env::Other(_)),
+                "`Env::Other` is only meant for JSON targets"
+            );
+            check!(
+                !matches!(self.cfg_abi, CfgAbi::Other(_)),
+                "`CfgAbi::Other` is only meant for JSON targets"
+            );
+            check!(
+                !matches!(self.llvm_abiname, LlvmAbi::Other(_)),
+                "`LlvmAbi::Other` is only meant for JSON targets"
+            );
+        }
+
         // Check ABI flag consistency, for the architectures where we have proper ABI treatment.
         // To ensure targets are trated consistently, please consult with the team before allowing
         // new cases.

From d52943a72612839518bd35e18bec606ab7b6d94e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sun, 22 Mar 2026 20:11:53 +1100
Subject: [PATCH 0769/1059] Remove assertion in
 `load_from_disk_or_invoke_provider_green`.

We can only reach this point if `try_load_from_disk_fn` fails, and the
condition of this assertion is basically just the inverse of what
`try_load_from_disk_fn` does. Basically it's like this:
```
fn foo() -> bool { a && b }

fn bar() {
    if foo() {
        return;
    }
    assert!(!a || !b);
}
```
The assertion is just confusing and provides little value.
---
 compiler/rustc_query_impl/src/execution.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 8fc6c851c3da..2dae7c129a08 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -528,13 +528,6 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
         "missing on-disk cache entry for {dep_node:?}"
     );
 
-    // Sanity check for the logic in `ensure`: if the node is green and the result loadable,
-    // we should actually be able to load it.
-    debug_assert!(
-        !((query.will_cache_on_disk_for_key_fn)(tcx, key) && loadable_from_disk(tcx, prev_index)),
-        "missing on-disk cache entry for loadable {dep_node:?}"
-    );
-
     // We could not load a result from the on-disk cache, so
     // recompute.
     let prof_timer = tcx.prof.query_provider();

From dd2b2084c9914fdb123d8b8e3b77e5c751c42ef8 Mon Sep 17 00:00:00 2001
From: ujjwalVishwakarma2006 <2023ucs0116@iitjammu.ac.in>
Date: Sun, 22 Mar 2026 15:18:42 +0530
Subject: [PATCH 0770/1059] Add comment at the top in two test files
 referencing the issue they originate from

---
 tests/ui/lto/lto-avx-target-feature.rs   | 1 +
 tests/ui/lto/lto-weak-merge-functions.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tests/ui/lto/lto-avx-target-feature.rs b/tests/ui/lto/lto-avx-target-feature.rs
index 37d7b00cf7f0..37a8ce67dcfc 100644
--- a/tests/ui/lto/lto-avx-target-feature.rs
+++ b/tests/ui/lto/lto-avx-target-feature.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/44056>
 //@ build-pass (FIXME(55996): should be run on targets supporting avx)
 //@ only-x86_64
 //@ no-prefer-dynamic
diff --git a/tests/ui/lto/lto-weak-merge-functions.rs b/tests/ui/lto/lto-weak-merge-functions.rs
index eda48aa5cf47..bf16fbc83435 100644
--- a/tests/ui/lto/lto-weak-merge-functions.rs
+++ b/tests/ui/lto/lto-weak-merge-functions.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/51947>
 //@ build-pass
 
 #![crate_type = "lib"]

From ce94a4b92e4354851125912353ca116ae3960f98 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Wed, 18 Mar 2026 14:45:45 +0100
Subject: [PATCH 0771/1059] Hookup analysis_stats

---
 .../crates/hir-def/src/expr_store.rs          |   5 +-
 .../crates/hir-def/src/resolver.rs            |  10 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  35 +---
 .../crates/hir-ty/src/infer/unify.rs          |   4 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |  18 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  39 +++++
 .../crates/hir/src/source_analyzer.rs         |  11 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   | 165 ++++++++++++++----
 8 files changed, 214 insertions(+), 73 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
index 8552c7284532..b5436f3ba338 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
@@ -319,7 +319,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
             mut bindings,
             mut binding_owners,
             mut ident_hygiene,
-            const_expr_origins,
+            mut const_expr_origins,
             mut types,
             mut lifetimes,
 
@@ -379,6 +379,9 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
 
         let store = {
             let expr_only = if has_exprs {
+                if let Some(const_expr_origins) = &mut const_expr_origins {
+                    const_expr_origins.shrink_to_fit();
+                }
                 Some(Box::new(ExpressionOnlyStore {
                     exprs,
                     pats,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 392010df8507..38b461770cbf 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -860,7 +860,15 @@ pub fn update_to_inner_scope(
         owner: impl Into<ExpressionStoreOwner>,
         expr_id: ExprId,
     ) -> UpdateGuard {
-        let owner = owner.into();
+        self.update_to_inner_scope_(db, owner.into(), expr_id)
+    }
+
+    fn update_to_inner_scope_(
+        &mut self,
+        db: &'db dyn DefDatabase,
+        owner: ExpressionStoreOwner,
+        expr_id: ExprId,
+    ) -> UpdateGuard {
         #[inline(always)]
         fn append_expr_scope<'db>(
             db: &'db dyn DefDatabase,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index a78d5d8a3051..9d78f5de9e05 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -33,9 +33,9 @@
 use base_db::Crate;
 use either::Either;
 use hir_def::{
-    AdtId, AnonConstId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner,
-    FieldId, FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup,
-    TraitId, TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
+    AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner, FieldId,
+    FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup, TraitId,
+    TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
     expr_store::{ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
@@ -146,6 +146,10 @@ pub fn infer_query_with_inspect<'db>(
 
     ctx.infer_mut_body(body.body_expr);
 
+    finalize_infer(ctx)
+}
+
+fn finalize_infer(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
     ctx.handle_opaque_type_uses();
 
     ctx.type_inference_fallback();
@@ -213,9 +217,7 @@ fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceRe
         ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
     }
 
-    ctx.type_inference_fallback();
-    ctx.table.select_obligations_where_possible();
-    ctx.resolve_all()
+    finalize_infer(ctx)
 }
 
 fn infer_signature_cycle_result(
@@ -618,24 +620,6 @@ pub fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult
 }
 
 impl InferenceResult {
-    /// Look up inference results for a specific anonymous const in a signature.
-    ///
-    /// This delegates to [`Self::for_signature`] on the anon const's owner.
-    /// The returned `InferenceResult` contains types for *all* expressions in
-    /// the owner's signature store, not just this anon const's sub-tree.
-    /// Callers should index into it with `loc.expr` to get the root expression's
-    /// type.
-    // FIXME: This function doesn't make sense in that we can't return a full inference result here
-    // as the anon const is just part of an inference result.
-    pub fn for_anon_const(db: &dyn HirDatabase, id: AnonConstId) -> &InferenceResult {
-        match id.lookup(db).owner {
-            ExpressionStoreOwner::Signature(generic_def_id) => {
-                Self::for_signature(db, generic_def_id)
-            }
-            ExpressionStoreOwner::Body(def_with_body_id) => Self::for_body(db, def_with_body_id),
-        }
-    }
-
     fn new(error_ty: Ty<'_>) -> Self {
         Self {
             method_resolutions: Default::default(),
@@ -943,8 +927,7 @@ fn new(
                 db.trait_environment_for_body(def_with_body_id)
             }
         };
-        let table =
-            unify::InferenceTable::new(db, trait_env, resolver.krate(), owner.as_def_with_body());
+        let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
         let types = crate::next_solver::default_types(db);
         InferenceContext {
             result: InferenceResult::new(types.types.error),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 2057159c46d2..77f76c97b8e6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -3,7 +3,7 @@
 use std::fmt;
 
 use base_db::Crate;
-use hir_def::{AdtId, DefWithBodyId, GenericParamId};
+use hir_def::{AdtId, ExpressionStoreOwner, GenericParamId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::FxHashSet;
@@ -147,7 +147,7 @@ pub(crate) fn new(
         db: &'db dyn HirDatabase,
         trait_env: ParamEnv<'db>,
         krate: Crate,
-        owner: Option<DefWithBodyId>,
+        owner: Option<ExpressionStoreOwner>,
     ) -> Self {
         let interner = DbInterner::new_with(db, krate);
         let typing_mode = match owner {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index e76ab16fc2c7..f725af320db7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -2,8 +2,8 @@
 
 use hir_def::{
     AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,
-    EnumId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId, StaticId, StructId,
-    TraitId, TypeAliasId, UnionId,
+    EnumId, EnumVariantId, ExpressionStoreOwner, FunctionId, GeneralConstId, GenericDefId, ImplId,
+    StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -12,13 +12,13 @@
 
 use super::DbInterner;
 
-#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Ctor {
     Struct(StructId),
     Enum(EnumVariantId),
 }
 
-#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum SolverDefId {
     AdtId(AdtId),
     ConstId(ConstId),
@@ -33,7 +33,6 @@ pub enum SolverDefId {
     InternedCoroutineId(InternedCoroutineId),
     InternedOpaqueTyId(InternedOpaqueTyId),
     EnumVariantId(EnumVariantId),
-    // FIXME(next-solver): Do we need the separation of `Ctor`? It duplicates some variants.
     Ctor(Ctor),
 }
 
@@ -139,6 +138,15 @@ fn from(value: GenericDefId) -> Self {
     }
 }
 
+impl From<ExpressionStoreOwner> for SolverDefId {
+    fn from(value: ExpressionStoreOwner) -> Self {
+        match value {
+            ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id.into(),
+            ExpressionStoreOwner::Body(def_with_body_id) => def_with_body_id.into(),
+        }
+    }
+}
+
 impl From<GeneralConstId> for SolverDefId {
     #[inline]
     fn from(value: GeneralConstId) -> Self {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 6dfb94cbf36b..34372a4a95a2 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -508,6 +508,21 @@ pub fn as_self_generic_def(self) -> Option<GenericDef> {
         }
     }
 
+    pub fn as_generic_def(self) -> Option<GenericDef> {
+        match self {
+            ModuleDef::Function(it) => Some(it.into()),
+            ModuleDef::Adt(it) => Some(it.into()),
+            ModuleDef::Trait(it) => Some(it.into()),
+            ModuleDef::TypeAlias(it) => Some(it.into()),
+            ModuleDef::Static(it) => Some(it.into()),
+            ModuleDef::Const(it) => Some(it.into()),
+            ModuleDef::Variant(_)
+            | ModuleDef::Module(_)
+            | ModuleDef::BuiltinType(_)
+            | ModuleDef::Macro(_) => None,
+        }
+    }
+
     pub fn attrs(&self, db: &dyn HirDatabase) -> Option<AttrsWithOwner> {
         Some(match self {
             ModuleDef::Module(it) => it.attrs(db),
@@ -3972,6 +3987,30 @@ pub enum GenericDef {
 );
 
 impl GenericDef {
+    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        match self {
+            GenericDef::Function(it) => Some(it.name(db)),
+            GenericDef::Adt(it) => Some(it.name(db)),
+            GenericDef::Trait(it) => Some(it.name(db)),
+            GenericDef::TypeAlias(it) => Some(it.name(db)),
+            GenericDef::Impl(_) => None,
+            GenericDef::Const(it) => it.name(db),
+            GenericDef::Static(it) => Some(it.name(db)),
+        }
+    }
+
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            GenericDef::Function(it) => it.module(db),
+            GenericDef::Adt(it) => it.module(db),
+            GenericDef::Trait(it) => it.module(db),
+            GenericDef::TypeAlias(it) => it.module(db),
+            GenericDef::Impl(it) => it.module(db),
+            GenericDef::Const(it) => it.module(db),
+            GenericDef::Static(it) => it.module(db),
+        }
+    }
+
     pub fn params(self, db: &dyn HirDatabase) -> Vec<GenericParam> {
         let Ok(id) = self.try_into() else {
             // Let's pretend builtin derive impls don't have generic parameters.
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index ad7aea391833..1d3cfc748e95 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -152,7 +152,7 @@ pub(crate) fn new_generic_def(
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        Self::new_generic_def_(db, def, node, offset, Some(InferenceResult::for_signature(db, def)))
+        Self::new_generic_def_(db, def, node, offset, true)
     }
 
     pub(crate) fn new_generic_def_no_infer(
@@ -161,7 +161,7 @@ pub(crate) fn new_generic_def_no_infer(
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        Self::new_generic_def_(db, def, node, offset, None)
+        Self::new_generic_def_(db, def, node, offset, false)
     }
 
     pub(crate) fn new_generic_def_(
@@ -169,7 +169,7 @@ pub(crate) fn new_generic_def_(
         def: GenericDefId,
         node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
-        infer: Option<&'db InferenceResult>,
+        infer: bool,
     ) -> SourceAnalyzer<'db> {
         let (generics, store, source_map) = db.generic_params_and_store_and_source_map(def);
         let scopes = db.expr_scopes(def.into());
@@ -186,6 +186,11 @@ pub(crate) fn new_generic_def_(
             }
         };
         let resolver = resolver_for_scope(db, def, scope);
+        let infer = if infer && !Arc::ptr_eq(&store, &ExpressionStore::empty_singleton().0) {
+            Some(InferenceResult::for_signature(db, def))
+        } else {
+            None
+        };
         SourceAnalyzer {
             resolver,
             body_or_sig: Some(BodyOrSig::Sig { def, store, source_map, generics, infer }),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index ad1cca08cb57..3ee379765461 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -10,8 +10,8 @@
 
 use cfg::{CfgAtom, CfgDiff};
 use hir::{
-    Adt, AssocItem, Crate, DefWithBody, FindPathConfig, HasCrate, HasSource, HirDisplay, ModuleDef,
-    Name, crate_lang_items,
+    Adt, AssocItem, Crate, DefWithBody, FindPathConfig, GenericDef, HasCrate, HasSource,
+    HirDisplay, ModuleDef, Name, crate_lang_items,
     db::{DefDatabase, ExpandDatabase, HirDatabase},
     next_solver::{DbInterner, GenericArgs},
 };
@@ -229,6 +229,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
         eprint!("    crates: {num_crates}");
         let mut num_decls = 0;
         let mut bodies = Vec::new();
+        let mut signatures = Vec::new();
         let mut adts = Vec::new();
         let mut file_ids = Vec::new();
 
@@ -267,24 +268,32 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                         },
                         _ => (),
                     };
+                    if let Some(g) = decl.as_generic_def() {
+                        signatures.push(g);
+                    }
                 }
 
                 for impl_def in module.impl_defs(db) {
+                    signatures.push(impl_def.into());
                     for item in impl_def.items(db) {
                         num_decls += 1;
                         match item {
-                            AssocItem::Function(f) => bodies.push(DefWithBody::from(f)),
+                            AssocItem::Function(f) => {
+                                bodies.push(DefWithBody::from(f));
+                                signatures.push(f.into())
+                            }
                             AssocItem::Const(c) => {
                                 bodies.push(DefWithBody::from(c));
+                                signatures.push(c.into());
                             }
-                            _ => (),
+                            AssocItem::TypeAlias(t) => signatures.push(t.into()),
                         }
                     }
                 }
             }
         }
         eprintln!(
-            ", mods: {}, decls: {num_decls}, bodies: {}, adts: {}, consts: {}",
+            ", mods: {}, decls: {num_decls}, bodies: {}, adts: {}, consts: {}, signatures: {}",
             visited_modules.len(),
             bodies.len(),
             adts.len(),
@@ -292,6 +301,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                 .iter()
                 .filter(|it| matches!(it, DefWithBody::Const(_) | DefWithBody::Static(_)))
                 .count(),
+            signatures.len(),
         );
 
         eprintln!("  Workspace:");
@@ -327,15 +337,15 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             }
 
             if !self.skip_lowering {
-                self.run_body_lowering(db, &vfs, &bodies, verbosity);
+                self.run_body_lowering(db, &vfs, &bodies, &signatures, verbosity);
             }
 
             if !self.skip_inference {
-                self.run_inference(db, &vfs, &bodies, verbosity);
+                self.run_inference(db, &vfs, &bodies, &signatures, verbosity);
             }
 
             if !self.skip_mir_stats {
-                self.run_mir_lowering(db, &bodies, verbosity);
+                self.run_mir_lowering(db, &bodies, &signatures, verbosity);
             }
 
             if !self.skip_data_layout {
@@ -343,7 +353,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             }
 
             if !self.skip_const_eval {
-                self.run_const_eval(db, &bodies, verbosity);
+                self.run_const_eval(db, &bodies, &signatures, verbosity);
             }
         });
 
@@ -416,7 +426,13 @@ fn run_data_layout(&self, db: &RootDatabase, adts: &[hir::Adt], verbosity: Verbo
         report_metric("data layout time", data_layout_time.time.as_millis() as u64, "ms");
     }
 
-    fn run_const_eval(&self, db: &RootDatabase, bodies: &[DefWithBody], verbosity: Verbosity) {
+    fn run_const_eval(
+        &self,
+        db: &RootDatabase,
+        bodies: &[DefWithBody],
+        _signatures: &[GenericDef],
+        verbosity: Verbosity,
+    ) {
         let len = bodies
             .iter()
             .filter(|body| matches!(body, DefWithBody::Const(_) | DefWithBody::Static(_)))
@@ -431,7 +447,9 @@ fn run_const_eval(&self, db: &RootDatabase, bodies: &[DefWithBody], verbosity: V
         let mut all = 0;
         let mut fail = 0;
         for &b in bodies {
-            bar.set_message(move || format!("const eval: {}", full_name(db, b, b.module(db))));
+            bar.set_message(move || {
+                format!("const eval: {}", full_name(db, || b.name(db), b.module(db)))
+            });
             let res = match b {
                 DefWithBody::Const(c) => c.eval(db),
                 DefWithBody::Static(s) => s.eval(db),
@@ -687,7 +705,13 @@ fn trim(s: &str) -> String {
         bar.finish_and_clear();
     }
 
-    fn run_mir_lowering(&self, db: &RootDatabase, bodies: &[DefWithBody], verbosity: Verbosity) {
+    fn run_mir_lowering(
+        &self,
+        db: &RootDatabase,
+        bodies: &[DefWithBody],
+        _signatures: &[GenericDef],
+        verbosity: Verbosity,
+    ) {
         let mut bar = match verbosity {
             Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
             _ if self.parallel || self.output.is_some() => ProgressReport::hidden(),
@@ -698,14 +722,14 @@ fn run_mir_lowering(&self, db: &RootDatabase, bodies: &[DefWithBody], verbosity:
         let mut fail = 0;
         for &body in bodies {
             bar.set_message(move || {
-                format!("mir lowering: {}", full_name(db, body, body.module(db)))
+                format!("mir lowering: {}", full_name(db, || body.name(db), body.module(db)))
             });
             bar.inc(1);
             if matches!(body, DefWithBody::Variant(_)) {
                 continue;
             }
             let module = body.module(db);
-            if !self.should_process(db, body, module) {
+            if !self.should_process(db, || body.name(db), module) {
                 continue;
             }
 
@@ -743,6 +767,7 @@ fn run_inference(
         db: &RootDatabase,
         vfs: &Vfs,
         bodies: &[DefWithBody],
+        signatures: &[GenericDef],
         verbosity: Verbosity,
     ) {
         let mut bar = match verbosity {
@@ -757,10 +782,19 @@ fn run_inference(
             bodies
                 .par_iter()
                 .map_with(db.clone(), |snap, &body| {
-                    snap.body(body);
                     InferenceResult::for_body(snap, body);
                 })
                 .count();
+            let signatures = signatures
+                .iter()
+                .filter_map(|&signatures| signatures.try_into().ok())
+                .collect::<Vec<_>>();
+            signatures
+                .par_iter()
+                .map_with(db.clone(), |snap, &signatures| {
+                    InferenceResult::for_signature(snap, signatures);
+                })
+                .count();
             eprintln!("{:<20} {}", "Parallel Inference:", inference_sw.elapsed());
         }
 
@@ -782,7 +816,7 @@ fn run_inference(
             let display_target = module.krate(db).to_display_target(db);
             if let Some(only_name) = self.only.as_deref()
                 && name.display(db, Edition::LATEST).to_string() != only_name
-                && full_name(db, body_id, module) != only_name
+                && full_name(db, || body_id.name(db), module) != only_name
             {
                 continue;
             }
@@ -800,15 +834,15 @@ fn run_inference(
                         let syntax_range = src.text_range();
                         format!(
                             "processing: {} ({} {:?})",
-                            full_name(db, body_id, module),
+                            full_name(db, || body_id.name(db), module),
                             path,
                             syntax_range
                         )
                     } else {
-                        format!("processing: {}", full_name(db, body_id, module))
+                        format!("processing: {}", full_name(db, || body_id.name(db), module))
                     }
                 } else {
-                    format!("processing: {}", full_name(db, body_id, module))
+                    format!("processing: {}", full_name(db, || body_id.name(db), module))
                 }
             };
             if verbosity.is_spammy() {
@@ -822,11 +856,22 @@ fn run_inference(
                 Ok(inference_result) => inference_result,
                 Err(p) => {
                     if let Some(s) = p.downcast_ref::<&str>() {
-                        eprintln!("infer panicked for {}: {}", full_name(db, body_id, module), s);
+                        eprintln!(
+                            "infer panicked for {}: {}",
+                            full_name(db, || body_id.name(db), module),
+                            s
+                        );
                     } else if let Some(s) = p.downcast_ref::<String>() {
-                        eprintln!("infer panicked for {}: {}", full_name(db, body_id, module), s);
+                        eprintln!(
+                            "infer panicked for {}: {}",
+                            full_name(db, || body_id.name(db), module),
+                            s
+                        );
                     } else {
-                        eprintln!("infer panicked for {}", full_name(db, body_id, module));
+                        eprintln!(
+                            "infer panicked for {}",
+                            full_name(db, || body_id.name(db), module)
+                        );
                     }
                     panics += 1;
                     bar.inc(1);
@@ -932,7 +977,7 @@ fn run_inference(
             if verbosity.is_spammy() {
                 bar.println(format!(
                     "In {}: {} exprs, {} unknown, {} partial",
-                    full_name(db, body_id, module),
+                    full_name(db, || body_id.name(db), module),
                     num_exprs - previous_exprs,
                     num_exprs_unknown - previous_unknown,
                     num_exprs_partially_unknown - previous_partially_unknown
@@ -1034,7 +1079,7 @@ fn run_inference(
             if verbosity.is_spammy() {
                 bar.println(format!(
                     "In {}: {} pats, {} unknown, {} partial",
-                    full_name(db, body_id, module),
+                    full_name(db, || body_id.name(db), module),
                     num_pats - previous_pats,
                     num_pats_unknown - previous_unknown,
                     num_pats_partially_unknown - previous_partially_unknown
@@ -1078,20 +1123,65 @@ fn run_body_lowering(
         db: &RootDatabase,
         vfs: &Vfs,
         bodies: &[DefWithBody],
+        signatures: &[GenericDef],
         verbosity: Verbosity,
     ) {
         let mut bar = match verbosity {
             Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
             _ if self.output.is_some() => ProgressReport::hidden(),
-            _ => ProgressReport::new(bodies.len()),
+            _ => ProgressReport::new(bodies.len() + signatures.len()),
         };
 
         let mut sw = self.stop_watch();
         bar.tick();
+        for &signature in signatures {
+            let Ok(signature_id) = signature.try_into() else { continue };
+            let module = signature.module(db);
+            if !self.should_process(db, || signature.name(db), module) {
+                continue;
+            }
+            let msg = move || {
+                if verbosity.is_verbose() {
+                    let source = match signature {
+                        GenericDef::Function(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        GenericDef::Static(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        GenericDef::Const(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        GenericDef::Adt(adt) => adt.source(db).map(|it| it.syntax().cloned()),
+                        GenericDef::Trait(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        GenericDef::TypeAlias(type_alias) => {
+                            type_alias.source(db).map(|it| it.syntax().cloned())
+                        }
+                        GenericDef::Impl(it) => it.source(db).map(|it| it.syntax().cloned()),
+                    };
+                    if let Some(src) = source {
+                        let original_file = src.file_id.original_file(db);
+                        let path = vfs.file_path(original_file.file_id(db));
+                        let syntax_range = src.text_range();
+                        format!(
+                            "processing: {} ({} {:?})",
+                            full_name(db, || signature.name(db), module),
+                            path,
+                            syntax_range
+                        )
+                    } else {
+                        format!("processing: {}", full_name(db, || signature.name(db), module))
+                    }
+                } else {
+                    format!("processing: {}", full_name(db, || signature.name(db), module))
+                }
+            };
+            if verbosity.is_spammy() {
+                bar.println(msg());
+            }
+            bar.set_message(msg);
+            db.generic_params_and_store(signature_id);
+            bar.inc(1);
+        }
+
         for &body_id in bodies {
             let Ok(body_def_id) = body_id.try_into() else { continue };
             let module = body_id.module(db);
-            if !self.should_process(db, body_id, module) {
+            if !self.should_process(db, || body_id.name(db), module) {
                 continue;
             }
             let msg = move || {
@@ -1108,15 +1198,15 @@ fn run_body_lowering(
                         let syntax_range = src.text_range();
                         format!(
                             "processing: {} ({} {:?})",
-                            full_name(db, body_id, module),
+                            full_name(db, || body_id.name(db), module),
                             path,
                             syntax_range
                         )
                     } else {
-                        format!("processing: {}", full_name(db, body_id, module))
+                        format!("processing: {}", full_name(db, || body_id.name(db), module))
                     }
                 } else {
-                    format!("processing: {}", full_name(db, body_id, module))
+                    format!("processing: {}", full_name(db, || body_id.name(db), module))
                 }
             };
             if verbosity.is_spammy() {
@@ -1129,7 +1219,7 @@ fn run_body_lowering(
 
         bar.finish_and_clear();
         let body_lowering_time = sw.elapsed();
-        eprintln!("{:<20} {}", "Body lowering:", body_lowering_time);
+        eprintln!("{:<20} {}", "Expression Store Lowering:", body_lowering_time);
         report_metric("body lowering time", body_lowering_time.time.as_millis() as u64, "ms");
     }
 
@@ -1283,12 +1373,17 @@ fn run_ide_things(
         eprintln!("{:<20} {} ({} files)", "IDE:", ide_time, file_ids.len());
     }
 
-    fn should_process(&self, db: &RootDatabase, body_id: DefWithBody, module: hir::Module) -> bool {
+    fn should_process(
+        &self,
+        db: &RootDatabase,
+        name_fn: impl Fn() -> Option<Name>,
+        module: hir::Module,
+    ) -> bool {
         if let Some(only_name) = self.only.as_deref() {
-            let name = body_id.name(db).unwrap_or_else(Name::missing);
+            let name = name_fn().unwrap_or_else(Name::missing);
 
             if name.display(db, Edition::LATEST).to_string() != only_name
-                && full_name(db, body_id, module) != only_name
+                && full_name(db, name_fn, module) != only_name
             {
                 return false;
             }
@@ -1301,7 +1396,7 @@ fn stop_watch(&self) -> StopWatch {
     }
 }
 
-fn full_name(db: &RootDatabase, body_id: DefWithBody, module: hir::Module) -> String {
+fn full_name(db: &RootDatabase, name: impl Fn() -> Option<Name>, module: hir::Module) -> String {
     module
         .krate(db)
         .display_name(db)
@@ -1313,7 +1408,7 @@ fn full_name(db: &RootDatabase, body_id: DefWithBody, module: hir::Module) -> St
                 .into_iter()
                 .filter_map(|it| it.name(db))
                 .rev()
-                .chain(Some(body_id.name(db).unwrap_or_else(Name::missing)))
+                .chain(Some(name().unwrap_or_else(Name::missing)))
                 .map(|it| it.display(db, Edition::LATEST).to_string()),
         )
         .join("::")

From 9a021da8db29d77e56eb70f9d8635fb13f4673c2 Mon Sep 17 00:00:00 2001
From: Thomas de Zeeuw <thomasdezeeuw@gmail.com>
Date: Mon, 22 Dec 2025 18:42:42 +0100
Subject: [PATCH 0772/1059] Add a shim for uname systemcall

---
 src/tools/miri/src/shims/unix/env.rs          | 38 +++++++++++++++++++
 .../miri/src/shims/unix/foreign_items.rs      | 10 +++++
 .../src/shims/unix/freebsd/foreign_items.rs   | 17 +++++++++
 .../miri/tests/pass-dep/libc/libc-uname.rs    | 38 +++++++++++++++++++
 4 files changed, 103 insertions(+)
 create mode 100644 src/tools/miri/tests/pass-dep/libc/libc-uname.rs

diff --git a/src/tools/miri/src/shims/unix/env.rs b/src/tools/miri/src/shims/unix/env.rs
index 41bf70c34634..97d093ab3f1f 100644
--- a/src/tools/miri/src/shims/unix/env.rs
+++ b/src/tools/miri/src/shims/unix/env.rs
@@ -272,6 +272,44 @@ fn unix_gettid(&mut self, link_name: &str) -> InterpResult<'tcx, Scalar> {
         interp_ok(Scalar::from_u32(this.get_current_tid()))
     }
 
+    fn uname(&mut self, uname: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+        this.assert_target_os_is_unix("uname");
+
+        let uname_ptr = this.read_pointer(uname)?;
+        if this.ptr_is_null(uname_ptr)? {
+            return this.set_last_error_and_return_i32(LibcError("EFAULT"));
+        }
+
+        let uname = this.deref_pointer_as(uname, this.libc_ty_layout("utsname"))?;
+        let arch = this.machine.tcx.sess.target.arch.desc_symbol();
+        // Values required by POSIX.
+        let values = [
+            ("sysname", "Miri"),
+            ("nodename", "Miri"),
+            ("release", env!("CARGO_PKG_VERSION")),
+            ("version", concat!("Miri ", env!("CARGO_PKG_VERSION"))),
+            ("machine", arch.as_str()),
+        ];
+        for (name, value) in values {
+            let field = this.project_field_named(&uname, name)?;
+            let size = field.layout().layout.size().bytes();
+            let (written, _) = this.write_c_str(value.as_bytes(), field.ptr(), size)?;
+            assert!(written); // All values should fit.
+        }
+        // The following fields are not defined on all OS/libc implementations,
+        // so only write them if they are defined.
+        let optional_values = [("domainname", "(none)")];
+        for (name, value) in optional_values {
+            if let Some(field) = this.try_project_field_named(&uname, name)? {
+                let size = field.layout().layout.size().bytes();
+                let (written, _) = this.write_c_str(value.as_bytes(), field.ptr(), size)?;
+                assert!(written); // All values should fit.
+            }
+        }
+        interp_ok(Scalar::from_i32(0))
+    }
+
     /// The Apple-specific `int pthread_threadid_np(pthread_t thread, uint64_t *thread_id)`, which
     /// allows querying the ID for arbitrary threads, identified by their pthread_t.
     ///
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 9a24cbc5048a..23345ccbcc19 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -174,6 +174,16 @@ fn emulate_foreign_item_inner(
                 let result = this.getpid()?;
                 this.write_scalar(result, dest)?;
             }
+            "uname" if !matches!(&this.tcx.sess.target.os, Os::FreeBsd) => {
+                let [uname] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(*mut _) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.uname(uname)?;
+                this.write_scalar(result, dest)?;
+            }
             "sysconf" => {
                 let [val] = this.check_shim_sig(
                     shim_sig!(extern "C" fn(i32) -> isize),
diff --git a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
index f64ee3b16220..6cd4e6a939b4 100644
--- a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
@@ -165,6 +165,23 @@ fn emulate_foreign_item_inner(
                 let errno_place = this.last_error_place()?;
                 this.write_scalar(errno_place.to_ref(this).to_scalar(), dest)?;
             }
+            "__xuname" => {
+                // FreeBSD uses __xuname under the hood to implement uname, see:
+                // https://github.com/freebsd/freebsd-src/blob/3542d60fb8042474f66fbf2d779ed8c5a80d0f78/sys/sys/utsname.h#L64
+                // https://github.com/freebsd/freebsd-src/blob/3542d60fb8042474f66fbf2d779ed8c5a80d0f78/lib/libc/gen/uname.c#L44
+                let [size, uname] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                // The size determines the length of each field in the utsname
+                // structure. We don't really care about this, all we do check
+                // that the argument is an i32.
+                let _size = this.read_scalar(size)?.to_i32()?;
+                let result = this.uname(uname)?;
+                this.write_scalar(result, dest)?;
+            }
 
             // Incomplete shims that we "stub out" just to get pre-main initialization code to work.
             // These shims are enabled only when the caller is in the standard library.
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-uname.rs b/src/tools/miri/tests/pass-dep/libc/libc-uname.rs
new file mode 100644
index 000000000000..3c72ef300379
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/libc/libc-uname.rs
@@ -0,0 +1,38 @@
+//@ignore-target: windows # No libc
+
+use std::ffi::CStr;
+use std::{io, ptr};
+
+fn main() {
+    test_ok();
+    test_null_ptr();
+}
+
+fn test_ok() {
+    // SAFETY: all zeros for `utsname` is valid.
+    let mut uname: libc::utsname = unsafe { std::mem::zeroed() };
+    let result = unsafe { libc::uname(&mut uname) };
+    if result != 0 {
+        panic!("failed to call uname");
+    }
+
+    assert_eq!(unsafe { CStr::from_ptr(&uname.sysname as *const _) }, c"Miri");
+    assert_eq!(unsafe { CStr::from_ptr(&uname.nodename as *const _) }, c"Miri");
+    assert_eq!(
+        unsafe { CStr::from_ptr(&uname.release as *const _) }.to_str().unwrap(),
+        env!("CARGO_PKG_VERSION")
+    );
+    assert_eq!(unsafe { CStr::from_ptr(&uname.version as *const _) }, c"Miri 0.1.0");
+    assert_eq!(
+        unsafe { CStr::from_ptr(&uname.machine as *const _) }.to_str().unwrap(),
+        std::env::consts::ARCH
+    );
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    assert_eq!(unsafe { CStr::from_ptr(&uname.domainname as *const _) }, c"(none)");
+}
+
+fn test_null_ptr() {
+    let result = unsafe { libc::uname(ptr::null_mut()) };
+    assert_eq!(result, -1);
+    assert_eq!(io::Error::last_os_error().raw_os_error(), Some(libc::EFAULT));
+}

From 067558dc5c4453cd9f807affb0ccf99be2a642b4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 22 Mar 2026 11:27:36 +0100
Subject: [PATCH 0773/1059] check size field on freebsd and other tweaks

---
 src/tools/miri/src/shims/unix/env.rs          | 33 ++++++++++++-------
 .../miri/src/shims/unix/foreign_items.rs      |  9 +++--
 .../src/shims/unix/freebsd/foreign_items.rs   |  6 +---
 .../miri/tests/pass-dep/libc/libc-time.rs     |  1 +
 .../miri/tests/pass-dep/libc/libc-uname.rs    | 14 ++++----
 5 files changed, 38 insertions(+), 25 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/env.rs b/src/tools/miri/src/shims/unix/env.rs
index 97d093ab3f1f..488d82f2109a 100644
--- a/src/tools/miri/src/shims/unix/env.rs
+++ b/src/tools/miri/src/shims/unix/env.rs
@@ -272,11 +272,21 @@ fn unix_gettid(&mut self, link_name: &str) -> InterpResult<'tcx, Scalar> {
         interp_ok(Scalar::from_u32(this.get_current_tid()))
     }
 
-    fn uname(&mut self, uname: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
+    /// `fields_size`, if present, says how large each field of the struct is.
+    fn uname(
+        &mut self,
+        uname: &OpTy<'tcx>,
+        fields_size: Option<&OpTy<'tcx>>,
+    ) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
         this.assert_target_os_is_unix("uname");
 
         let uname_ptr = this.read_pointer(uname)?;
+        let fields_size = match fields_size {
+            None => None,
+            Some(size) => Some(this.read_scalar(size)?.to_i32()?),
+        };
+
         if this.ptr_is_null(uname_ptr)? {
             return this.set_last_error_and_return_i32(LibcError("EFAULT"));
         }
@@ -284,29 +294,28 @@ fn uname(&mut self, uname: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let uname = this.deref_pointer_as(uname, this.libc_ty_layout("utsname"))?;
         let arch = this.machine.tcx.sess.target.arch.desc_symbol();
         // Values required by POSIX.
-        let values = [
+        let mut values = vec![
             ("sysname", "Miri"),
             ("nodename", "Miri"),
             ("release", env!("CARGO_PKG_VERSION")),
             ("version", concat!("Miri ", env!("CARGO_PKG_VERSION"))),
             ("machine", arch.as_str()),
         ];
+        if matches!(this.machine.tcx.sess.target.os, Os::Linux | Os::Android) {
+            values.push(("domainname", "(none)"));
+        }
+
         for (name, value) in values {
             let field = this.project_field_named(&uname, name)?;
             let size = field.layout().layout.size().bytes();
+            if fields_size.is_some_and(|fields_size| u64::try_from(fields_size) != Ok(size)) {
+                throw_unsup_format!(
+                    "the fields size passed to `uname` does not match the type in the libc crate"
+                );
+            }
             let (written, _) = this.write_c_str(value.as_bytes(), field.ptr(), size)?;
             assert!(written); // All values should fit.
         }
-        // The following fields are not defined on all OS/libc implementations,
-        // so only write them if they are defined.
-        let optional_values = [("domainname", "(none)")];
-        for (name, value) in optional_values {
-            if let Some(field) = this.try_project_field_named(&uname, name)? {
-                let size = field.layout().layout.size().bytes();
-                let (written, _) = this.write_c_str(value.as_bytes(), field.ptr(), size)?;
-                assert!(written); // All values should fit.
-            }
-        }
         interp_ok(Scalar::from_i32(0))
     }
 
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 23345ccbcc19..bf9482a6264b 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -174,14 +174,19 @@ fn emulate_foreign_item_inner(
                 let result = this.getpid()?;
                 this.write_scalar(result, dest)?;
             }
-            "uname" if !matches!(&this.tcx.sess.target.os, Os::FreeBsd) => {
+            "uname" => {
+                // Not all Unixes have the `uname` symbol, e.g. FreeBSD does not.
+                this.check_target_os(
+                    &[Os::Linux, Os::Android, Os::MacOs, Os::Solaris, Os::Illumos],
+                    link_name,
+                )?;
                 let [uname] = this.check_shim_sig(
                     shim_sig!(extern "C" fn(*mut _) -> i32),
                     link_name,
                     abi,
                     args,
                 )?;
-                let result = this.uname(uname)?;
+                let result = this.uname(uname, None)?;
                 this.write_scalar(result, dest)?;
             }
             "sysconf" => {
diff --git a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
index 6cd4e6a939b4..de08f4c6afe4 100644
--- a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
@@ -175,11 +175,7 @@ fn emulate_foreign_item_inner(
                     abi,
                     args,
                 )?;
-                // The size determines the length of each field in the utsname
-                // structure. We don't really care about this, all we do check
-                // that the argument is an i32.
-                let _size = this.read_scalar(size)?.to_i32()?;
-                let result = this.uname(uname)?;
+                let result = this.uname(uname, Some(size))?;
                 this.write_scalar(result, dest)?;
             }
 
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-time.rs b/src/tools/miri/tests/pass-dep/libc/libc-time.rs
index b80fb0025530..141e0009101a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-time.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-time.rs
@@ -3,6 +3,7 @@
 
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
+
 use std::time::{Duration, Instant};
 use std::{env, mem, ptr};
 
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-uname.rs b/src/tools/miri/tests/pass-dep/libc/libc-uname.rs
index 3c72ef300379..b071e0522582 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-uname.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-uname.rs
@@ -1,8 +1,13 @@
 //@ignore-target: windows # No libc
 
+#[path = "../../utils/libc.rs"]
+mod libc_utils;
+
 use std::ffi::CStr;
 use std::{io, ptr};
 
+use libc_utils::*;
+
 fn main() {
     test_ok();
     test_null_ptr();
@@ -11,10 +16,7 @@ fn main() {
 fn test_ok() {
     // SAFETY: all zeros for `utsname` is valid.
     let mut uname: libc::utsname = unsafe { std::mem::zeroed() };
-    let result = unsafe { libc::uname(&mut uname) };
-    if result != 0 {
-        panic!("failed to call uname");
-    }
+    errno_check(unsafe { libc::uname(&mut uname) });
 
     assert_eq!(unsafe { CStr::from_ptr(&uname.sysname as *const _) }, c"Miri");
     assert_eq!(unsafe { CStr::from_ptr(&uname.nodename as *const _) }, c"Miri");
@@ -32,7 +34,7 @@ fn test_ok() {
 }
 
 fn test_null_ptr() {
-    let result = unsafe { libc::uname(ptr::null_mut()) };
-    assert_eq!(result, -1);
+    let err = errno_result(unsafe { libc::uname(ptr::null_mut()) }).unwrap_err();
+    assert_eq!(err.raw_os_error(), Some(libc::EFAULT));
     assert_eq!(io::Error::last_os_error().raw_os_error(), Some(libc::EFAULT));
 }

From f1c710b4ce46dba3fe204a4edcbd9c23911f0324 Mon Sep 17 00:00:00 2001
From: Amit5601 <abhay.singhmar2@gmail.com>
Date: Sun, 22 Mar 2026 16:24:02 +0530
Subject: [PATCH 0774/1059] internal: Remove clone_for_update from
 apply_demorgan.rs

---
 .../crates/ide-assists/src/handlers/apply_demorgan.rs           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
index 80d0a6da1243..4ee49702489d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
@@ -197,7 +197,7 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
     let (name, arg_expr) = validate_method_call_expr(ctx, &method_call)?;
 
     let ast::Expr::ClosureExpr(closure_expr) = arg_expr else { return None };
-    let closure_body = closure_expr.body()?.clone_for_update();
+    let closure_body = closure_expr.body()?;
 
     let op_range = method_call.syntax().text_range();
     let label = format!("Apply De Morgan's law to `Iterator::{}`", name.text().as_str());

From d7706e59a8b30d0dd40000ac639d0983b0816897 Mon Sep 17 00:00:00 2001
From: WhySoBad <49595640+WhySoBad@users.noreply.github.com>
Date: Thu, 5 Mar 2026 00:40:38 +0100
Subject: [PATCH 0775/1059] Add blocking I/O manager, socket `accept` and
 `connect` shims

Integrates mio into the scheduler to block threads for external I/O
events (like blocking socket operations)
---
 src/tools/miri/Cargo.lock                     |  10 +-
 src/tools/miri/Cargo.toml                     |   1 +
 src/tools/miri/src/concurrency/blocking_io.rs | 148 +++++++
 src/tools/miri/src/concurrency/mod.rs         |   1 +
 src/tools/miri/src/concurrency/thread.rs      |  92 +++-
 src/tools/miri/src/diagnostics.rs             |  14 -
 src/tools/miri/src/lib.rs                     |   2 +
 src/tools/miri/src/machine.rs                 |   7 +
 src/tools/miri/src/provenance_gc.rs           |   2 +-
 src/tools/miri/src/shims/io_error.rs          |   1 +
 .../miri/src/shims/unix/foreign_items.rs      |  27 ++
 .../miri/src/shims/unix/linux_like/syscall.rs |   8 +
 src/tools/miri/src/shims/unix/socket.rs       | 413 ++++++++++++++++--
 .../src/shims/unix/solarish/foreign_items.rs  |   9 +
 .../miri/tests/pass-dep/libc/libc-socket.rs   | 138 ++++--
 .../libc/socket-unsupported-listen-backlog.rs |  27 --
 .../socket-unsupported-listen-backlog.stderr  |   8 -
 src/tools/miri/tests/pass-dep/shims/socket.rs |  17 -
 src/tools/miri/tests/pass/shims/socket.rs     |  36 ++
 19 files changed, 806 insertions(+), 155 deletions(-)
 create mode 100644 src/tools/miri/src/concurrency/blocking_io.rs
 delete mode 100644 src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
 delete mode 100644 src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
 delete mode 100644 src/tools/miri/tests/pass-dep/shims/socket.rs
 create mode 100644 src/tools/miri/tests/pass/shims/socket.rs

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index 2d332ae98dda..630a4b5e3e0f 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -779,9 +779,9 @@ checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
 [[package]]
 name = "libffi"
@@ -923,11 +923,12 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
+ "log",
  "wasi",
  "windows-sys 0.61.2",
 ]
@@ -950,6 +951,7 @@ dependencies = [
  "libffi",
  "libloading",
  "measureme",
+ "mio",
  "nix",
  "rand",
  "regex",
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 62387848868d..3255885d95be 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -28,6 +28,7 @@ chrono-tz = "0.10"
 directories = "6"
 bitflags = "2.6"
 serde_json = { version = "1.0", optional = true }
+mio = { version = "1.1.1", features = ["os-poll", "net"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
diff --git a/src/tools/miri/src/concurrency/blocking_io.rs b/src/tools/miri/src/concurrency/blocking_io.rs
new file mode 100644
index 000000000000..221d0495cd16
--- /dev/null
+++ b/src/tools/miri/src/concurrency/blocking_io.rs
@@ -0,0 +1,148 @@
+use std::io;
+use std::time::Duration;
+
+use mio::event::Source;
+use mio::{Events, Interest, Poll, Token};
+use rustc_data_structures::fx::FxHashMap;
+
+use crate::*;
+
+/// Capacity of the event queue which can be polled at a time.
+/// Since we don't expect many simultaneous blocking I/O events
+/// this value can be set rather low.
+const IO_EVENT_CAPACITY: usize = 16;
+
+/// Trait for values that contain a mio [`Source`].
+pub trait WithSource {
+    /// Invoke `f` on the source inside `self`.
+    fn with_source(&self, f: &mut dyn FnMut(&mut dyn Source) -> io::Result<()>) -> io::Result<()>;
+}
+
+/// Manager for managing blocking host I/O in a non-blocking manner.
+/// We use [`Poll`] to poll for new I/O events from the OS for sources
+/// registered using this manager.
+///
+/// Since blocking host I/O is inherently non-deterministic, no method on this
+/// manager should be called when isolation is enabled. The only exception is
+/// the [`BlockingIoManager::new`] function to create the manager. Everywhere else,
+/// we assert that isolation is disabled!
+pub struct BlockingIoManager {
+    /// Poll instance to monitor I/O events from the OS.
+    /// This is only [`None`] when Miri is run with isolation enabled.
+    poll: Option<Poll>,
+    /// Buffer used to store the ready I/O events when calling [`Poll::poll`].
+    /// This is not part of the state and only stored to avoid allocating a
+    /// new buffer for every poll.
+    events: Events,
+    /// Map between threads which are currently blocked and the
+    /// underlying I/O source.
+    sources: FxHashMap<ThreadId, Box<dyn WithSource>>,
+}
+
+impl BlockingIoManager {
+    /// Create a new blocking I/O manager instance based on the availability
+    /// of communication with the host.
+    pub fn new(communicate: bool) -> Result<Self, io::Error> {
+        let manager = Self {
+            poll: communicate.then_some(Poll::new()?),
+            events: Events::with_capacity(IO_EVENT_CAPACITY),
+            sources: FxHashMap::default(),
+        };
+        Ok(manager)
+    }
+
+    /// Poll for new I/O events from the OS or wait until the timeout expired.
+    ///
+    /// - If the timeout is [`Some`] and contains [`Duration::ZERO`], the poll doesn't block and just
+    ///   reads all events since the last poll.
+    /// - If the timeout is [`Some`] and contains a non-zero duration, it blocks at most for the
+    ///   specified duration.
+    /// - If the timeout is [`None`] the poll blocks indefinitely until an event occurs.
+    ///
+    /// Returns all threads that are ready because they received an I/O event.
+    pub fn poll(&mut self, timeout: Option<Duration>) -> Result<Vec<ThreadId>, io::Error> {
+        let poll =
+            self.poll.as_mut().expect("Blocking I/O should not be called with isolation enabled");
+
+        // Poll for new I/O events from OS and store them in the events buffer.
+        poll.poll(&mut self.events, timeout)?;
+
+        let ready = self
+            .events
+            .iter()
+            .map(|event| {
+                let token = event.token();
+                ThreadId::new_unchecked(token.0.try_into().unwrap())
+            })
+            .collect::<Vec<_>>();
+
+        // Deregister all ready sources as we only want to receive one event per thread.
+        ready.iter().for_each(|thread_id| self.deregister(*thread_id));
+
+        Ok(ready)
+    }
+
+    /// Register a blocking I/O source for a thread together with it's poll interests.
+    ///
+    /// The source will be deregistered automatically once an event for it is received.
+    ///
+    /// As the OS can always produce spurious wake-ups, it's the callers responsibility to
+    /// verify the requested I/O interests are really ready and to register again if they're not.
+    pub fn register(&mut self, source: Box<dyn WithSource>, thread: ThreadId, interests: Interest) {
+        let poll =
+            self.poll.as_ref().expect("Blocking I/O should not be called with isolation enabled");
+
+        let token = Token(thread.to_u32().to_usize());
+
+        // Treat errors from registering as fatal. On UNIX hosts this can only
+        // fail due to system resource errors (e.g. ENOMEM or ENOSPC).
+        source
+            .with_source(&mut |source| source.register(poll.registry(), token, interests))
+            .unwrap();
+        self.sources
+            .try_insert(thread, source)
+            .unwrap_or_else(|_| panic!("A thread cannot be registered twice at the same time"));
+    }
+
+    /// Deregister the event source for a thread. Returns the kind of I/O the thread was
+    /// blocked on.
+    fn deregister(&mut self, thread: ThreadId) {
+        let poll =
+            self.poll.as_ref().expect("Blocking I/O should not be called with isolation enabled");
+
+        let Some(source) = self.sources.remove(&thread) else {
+            panic!("Attempt to deregister a token which isn't registered")
+        };
+
+        // Treat errors from deregistering as fatal. On UNIX hosts this can only
+        // fail due to system resource errors (e.g. ENOMEM or ENOSPC).
+        source.with_source(&mut |source| source.deregister(poll.registry())).unwrap();
+    }
+}
+
+impl<'tcx> EvalContextExt<'tcx> for MiriInterpCx<'tcx> {}
+pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
+    /// Block the current thread until some interests on an I/O source
+    /// are fulfilled or the optional timeout exceeded.
+    /// The callback will be invoked when the thread gets unblocked.
+    ///
+    /// There can be spurious wake-ups by the OS and thus it's the callers
+    /// responsibility to verify that the requested I/O interests are
+    /// really ready and to block again if they're not.
+    #[inline]
+    fn block_thread_for_io(
+        &mut self,
+        source: impl WithSource + 'static,
+        interests: Interest,
+        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
+        callback: DynUnblockCallback<'tcx>,
+    ) {
+        let this = self.eval_context_mut();
+        this.machine.blocking_io.register(
+            Box::new(source),
+            this.machine.threads.active_thread(),
+            interests,
+        );
+        this.block_thread(BlockReason::IO, timeout, callback);
+    }
+}
diff --git a/src/tools/miri/src/concurrency/mod.rs b/src/tools/miri/src/concurrency/mod.rs
index 421f24329df0..815ce914db57 100644
--- a/src/tools/miri/src/concurrency/mod.rs
+++ b/src/tools/miri/src/concurrency/mod.rs
@@ -1,3 +1,4 @@
+pub mod blocking_io;
 pub mod cpu_affinity;
 pub mod data_race;
 mod data_race_handler;
diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index 9d829bf69e5e..d6d6449df32b 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -1,9 +1,9 @@
 //! Implements threads.
 
-use std::mem;
 use std::sync::atomic::Ordering::Relaxed;
 use std::task::Poll;
 use std::time::{Duration, SystemTime};
+use std::{io, mem};
 
 use rand::seq::IteratorRandom;
 use rustc_abi::ExternAbi;
@@ -25,10 +25,11 @@
 enum SchedulingAction {
     /// Execute step on the active thread.
     ExecuteStep,
-    /// Execute a timeout callback.
-    ExecuteTimeoutCallback,
-    /// Wait for a bit, until there is a timeout to be called.
-    Sleep(Duration),
+    /// Wait for a bit, but at most as long as the duration specified.
+    /// We wake up early if an I/O event happened.
+    /// If the duration is [`None`], we sleep indefinitely. This is
+    /// only allowed when isolation is disabled and there are threads waiting for I/O!
+    SleepAndWaitForIo(Option<Duration>),
 }
 
 /// What to do with TLS allocations from terminated threads
@@ -111,6 +112,8 @@ pub enum BlockReason {
     Eventfd,
     /// Blocked on unnamed_socket.
     UnnamedSocket,
+    /// Blocked on an IO operation.
+    IO,
     /// Blocked for any reason related to GenMC, such as `assume` statements (GenMC mode only).
     /// Will be implicitly unblocked when GenMC schedules this thread again.
     Genmc,
@@ -765,9 +768,7 @@ fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
         }
 
         // We are not in GenMC mode, so we control the scheduling.
-        let thread_manager = &mut this.machine.threads;
-        let clock = &this.machine.monotonic_clock;
-        let rng = this.machine.rng.get_mut();
+        let thread_manager = &this.machine.threads;
         // This thread and the program can keep going.
         if thread_manager.threads[thread_manager.active_thread].state.is_enabled()
             && !thread_manager.yield_active_thread
@@ -775,16 +776,37 @@ fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
             // The currently active thread is still enabled, just continue with it.
             return interp_ok(SchedulingAction::ExecuteStep);
         }
-        // The active thread yielded or got terminated. Let's see if there are any timeouts to take
-        // care of. We do this *before* running any other thread, to ensure that timeouts "in the
-        // past" fire before any other thread can take an action. This ensures that for
+
+        // The active thread yielded or got terminated. Let's see if there are any I/O events
+        // or timeouts to take care of.
+
+        if this.machine.communicate() {
+            // When isolation is disabled we need to check for events for
+            // threads which are blocked on host I/O.
+            // We do this before running any other threads such that the threads
+            // which received events are available for scheduling afterwards.
+
+            // Perform a non-blocking poll for newly available I/O events from the OS.
+            this.poll_and_unblock(Some(Duration::ZERO))?;
+        }
+
+        let thread_manager = &this.machine.threads;
+        let clock = &this.machine.monotonic_clock;
+
+        // We also check timeouts before running any other thread, to ensure that timeouts
+        // "in the past" fire before any other thread can take an action. This ensures that for
         // `pthread_cond_timedwait`, "an error is returned if [...] the absolute time specified by
         // abstime has already been passed at the time of the call".
         // <https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cond_timedwait.html>
         let potential_sleep_time = thread_manager.next_callback_wait_time(clock);
         if potential_sleep_time == Some(Duration::ZERO) {
-            return interp_ok(SchedulingAction::ExecuteTimeoutCallback);
+            // The timeout exceeded for some thread so we unblock the thread and execute its timeout callback.
+            this.run_timeout_callback()?;
         }
+
+        let thread_manager = &mut this.machine.threads;
+        let rng = this.machine.rng.get_mut();
+
         // No callbacks immediately scheduled, pick a regular thread to execute.
         // The active thread blocked or yielded. So we go search for another enabled thread.
         // We build the list of threads by starting with the threads after the current one, followed by
@@ -832,7 +854,16 @@ fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
             // All threads are currently blocked, but we have unexecuted
             // timeout_callbacks, which may unblock some of the threads. Hence,
             // sleep until the first callback.
-            interp_ok(SchedulingAction::Sleep(sleep_time))
+            interp_ok(SchedulingAction::SleepAndWaitForIo(Some(sleep_time)))
+        } else if thread_manager
+            .threads
+            .iter()
+            .any(|thread| thread.state.is_blocked_on(BlockReason::IO))
+        {
+            // At least one thread is blocked on host I/O but doesn't
+            // have a timeout set. Hence, we sleep indefinitely in the
+            // hope that eventually an I/O event for this thread happens.
+            interp_ok(SchedulingAction::SleepAndWaitForIo(None))
         } else {
             throw_machine_stop!(TerminationInfo::GlobalDeadlock);
         }
@@ -1300,13 +1331,38 @@ fn run_threads(&mut self) -> InterpResult<'tcx, !> {
                         }
                     }
                 }
-                SchedulingAction::ExecuteTimeoutCallback => {
-                    this.run_timeout_callback()?;
-                }
-                SchedulingAction::Sleep(duration) => {
-                    this.machine.monotonic_clock.sleep(duration);
+                SchedulingAction::SleepAndWaitForIo(duration) => {
+                    if this.machine.communicate() {
+                        // When we're running with isolation disabled, instead of
+                        // strictly sleeping the duration we allow waking up
+                        // early for I/O events from the OS.
+
+                        this.poll_and_unblock(duration)?;
+                    } else {
+                        let duration = duration.expect(
+                            "Infinite sleep should not be triggered when isolation is enabled",
+                        );
+                        this.machine.monotonic_clock.sleep(duration);
+                    }
                 }
             }
         }
     }
+
+    /// Poll for I/O events until either an I/O event happened or the timeout expired.
+    /// The different timeout values are described in [`BlockingIoManager::poll`].
+    fn poll_and_unblock(&mut self, timeout: Option<Duration>) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let ready = match this.machine.blocking_io.poll(timeout) {
+            Ok(ready) => ready,
+            // We can ignore errors originating from interrupts; that's just a spurious wakeup.
+            Err(e) if e.kind() == io::ErrorKind::Interrupted => return interp_ok(()),
+            // For other errors we panic. On Linux and BSD hosts this should only be
+            // reachable when a system resource error (e.g. ENOMEM or ENOSPC) occurred.
+            Err(e) => panic!("{e}"),
+        };
+
+        ready.into_iter().try_for_each(|thread_id| this.unblock_thread(thread_id, BlockReason::IO))
+    }
 }
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 787a71091ae6..9d93edcaa344 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -141,13 +141,6 @@ pub enum NonHaltingDiagnostic {
         effective_failure_ordering: AtomicReadOrd,
     },
     FileInProcOpened,
-    SocketListenUnsupportedBacklog {
-        details: bool,
-        /// Unsupported backlog value provided the by the program.
-        provided: i32,
-        /// Supported backlog value by Miri.
-        supported: i32,
-    },
 }
 
 /// Level of Miri specific diagnostics
@@ -650,8 +643,6 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
             | WeakMemoryOutdatedLoad { .. } =>
                 ("tracking was triggered here".to_string(), DiagLevel::Note),
             FileInProcOpened => ("open a file in `/proc`".to_string(), DiagLevel::Warning),
-            SocketListenUnsupportedBacklog { .. } =>
-                ("call to `listen` with unsupported backlog value".to_string(), DiagLevel::Warning),
         };
 
         let title = match &e {
@@ -700,17 +691,12 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
                 format!("GenMC currently does not model the failure ordering for `compare_exchange`. {was_upgraded_msg}. Miri with GenMC might miss bugs related to this memory access.")
             }
             FileInProcOpened => format!("files in `/proc` can bypass the Abstract Machine and might not work properly in Miri"),
-            SocketListenUnsupportedBacklog { provided, supported, .. } => format!("called `listen` on socket with backlog value of {provided} but only {supported} is supported"),
         };
 
         let notes = match &e {
             ProgressReport { block_count } => {
                 vec![note!("so far, {block_count} basic blocks have been executed")]
             }
-            SocketListenUnsupportedBacklog { details: true, supported, .. } =>
-                vec![note!(
-                    "the given value will be ignored and a backlog of {supported} will be used instead"
-                )],
             _ => vec![],
         };
 
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 2f6c80772635..f41e3c20a7d5 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -16,6 +16,7 @@
 #![feature(never_type)]
 #![feature(try_blocks)]
 #![feature(io_error_more)]
+#![feature(io_error_inprogress)]
 #![feature(variant_count)]
 #![feature(yeet_expr)]
 #![feature(pointer_is_aligned_to)]
@@ -132,6 +133,7 @@ pub mod native_lib {
     BorTag, BorrowTrackerMethod, EvalContextExt as _, TreeBorrowsParams,
 };
 pub use crate::clock::{Instant, MonotonicClock};
+pub use crate::concurrency::blocking_io::{BlockingIoManager, EvalContextExt as _, WithSource};
 pub use crate::concurrency::cpu_affinity::MAX_CPUS;
 pub use crate::concurrency::data_race::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, EvalContextExt as _,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index ab38828c2108..d8224f1878f0 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -537,6 +537,9 @@ pub struct MiriMachine<'tcx> {
     /// The set of threads.
     pub(crate) threads: ThreadManager<'tcx>,
 
+    /// Handles blocking I/O and polling for completion.
+    pub(crate) blocking_io: BlockingIoManager,
+
     /// Stores which thread is eligible to run on which CPUs.
     /// This has no effect at all, it is just tracked to produce the correct result
     /// in `sched_getaffinity`
@@ -732,6 +735,8 @@ pub(crate) fn new(
             thread_cpu_affinity
                 .insert(threads.active_thread(), CpuAffinityMask::new(&layout_cx, config.num_cpus));
         }
+        let blocking_io = BlockingIoManager::new(config.isolated_op == IsolatedOp::Allow)
+            .expect("Couldn't create poll instance");
         let alloc_addresses =
             RefCell::new(alloc_addresses::GlobalStateInner::new(config, stack_addr, tcx));
         MiriMachine {
@@ -754,6 +759,7 @@ pub(crate) fn new(
             layouts,
             threads,
             thread_cpu_affinity,
+            blocking_io,
             static_roots: Vec::new(),
             profiler,
             string_cache: Default::default(),
@@ -1010,6 +1016,7 @@ fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
             data_race,
             alloc_addresses,
             fds,
+            blocking_io:_,
             epoll_interests:_,
             tcx: _,
             isolated_op: _,
diff --git a/src/tools/miri/src/provenance_gc.rs b/src/tools/miri/src/provenance_gc.rs
index 66b0adb3c4eb..f2c750a7577f 100644
--- a/src/tools/miri/src/provenance_gc.rs
+++ b/src/tools/miri/src/provenance_gc.rs
@@ -19,7 +19,7 @@ fn visit_provenance(&self, _visit: &mut VisitWith<'_>) {}
         )+
     }
 }
-no_provenance!(i8 i16 i32 i64 isize u8 u16 u32 u64 usize ThreadId);
+no_provenance!(i8 i16 i32 i64 isize u8 u16 u32 u64 usize bool ThreadId);
 
 impl<T: VisitProvenance> VisitProvenance for Option<T> {
     fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
diff --git a/src/tools/miri/src/shims/io_error.rs b/src/tools/miri/src/shims/io_error.rs
index 91ae448e2165..59a121be0155 100644
--- a/src/tools/miri/src/shims/io_error.rs
+++ b/src/tools/miri/src/shims/io_error.rs
@@ -94,6 +94,7 @@ fn from(value: Scalar) -> Self {
         ("ETIMEDOUT", TimedOut),
         ("ETXTBSY", ExecutableFileBusy),
         ("EXDEV", CrossesDevices),
+        ("EINPROGRESS", InProgress),
         // The following have two valid options. We have both for the forwards mapping; only the
         // first one will be used for the backwards mapping.
         ("EPERM", PermissionDenied),
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 9a24cbc5048a..a6620b5d977f 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -570,6 +570,33 @@ fn emulate_foreign_item_inner(
                 let result = this.listen(socket, backlog)?;
                 this.write_scalar(result, dest)?;
             }
+            "accept" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, *mut _) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                this.accept4(socket, address, address_len, /* flags */ None, dest)?;
+            }
+            "accept4" => {
+                let [socket, address, address_len, flags] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, *mut _, i32) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                this.accept4(socket, address, address_len, Some(flags), dest)?;
+            }
+            "connect" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *const _, libc::socklen_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                this.connect(socket, address, address_len, dest)?;
+            }
             "setsockopt" => {
                 let [socket, level, option_name, option_value, option_len] = this.check_shim_sig(
                     shim_sig!(extern "C" fn(i32, i32, i32, *const _, libc::socklen_t) -> i32),
diff --git a/src/tools/miri/src/shims/unix/linux_like/syscall.rs b/src/tools/miri/src/shims/unix/linux_like/syscall.rs
index 106e6c448d06..875fd0942838 100644
--- a/src/tools/miri/src/shims/unix/linux_like/syscall.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/syscall.rs
@@ -7,6 +7,7 @@
 use crate::shims::unix::env::EvalContextExt;
 use crate::shims::unix::linux_like::eventfd::EvalContextExt as _;
 use crate::shims::unix::linux_like::sync::futex;
+use crate::shims::unix::socket::EvalContextExt as _;
 use crate::*;
 
 pub fn syscall<'tcx>(
@@ -26,6 +27,7 @@ pub fn syscall<'tcx>(
     let sys_futex = ecx.eval_libc("SYS_futex").to_target_usize(ecx)?;
     let sys_eventfd2 = ecx.eval_libc("SYS_eventfd2").to_target_usize(ecx)?;
     let sys_gettid = ecx.eval_libc("SYS_gettid").to_target_usize(ecx)?;
+    let sys_accept4 = ecx.eval_libc("SYS_accept4").to_target_usize(ecx)?;
 
     match ecx.read_target_usize(op)? {
         // `libc::syscall(NR_GETRANDOM, buf.as_mut_ptr(), buf.len(), GRND_NONBLOCK)`
@@ -59,6 +61,12 @@ pub fn syscall<'tcx>(
             let result = ecx.unix_gettid("SYS_gettid")?;
             ecx.write_int(result.to_u32()?, dest)?;
         }
+        num if num == sys_accept4 => {
+            // Used on Android.
+            let [socket, address, address_len, flags] =
+                check_min_vararg_count("syscall(SYS_accept4, ...)", varargs)?;
+            ecx.accept4(socket, address, address_len, Some(flags), dest)?;
+        }
         num => {
             throw_unsup_format!("syscall: unsupported syscall number {num}");
         }
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index af645f88a4c4..f9b3ca479b79 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -1,19 +1,18 @@
 use std::cell::{Cell, RefCell};
-use std::iter;
-use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, TcpListener};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+use std::{io, iter};
 
+use mio::Interest;
+use mio::event::Source;
+use mio::net::{TcpListener, TcpStream};
 use rustc_abi::Size;
 use rustc_const_eval::interpret::{InterpResult, interp_ok};
 use rustc_middle::throw_unsup_format;
 use rustc_target::spec::Os;
 
-use crate::diagnostics::SpanDedupDiagnostic;
-use crate::shims::files::{FdId, FileDescription};
+use crate::shims::files::{FdId, FileDescription, FileDescriptionRef};
 use crate::{OpTy, Scalar, *};
 
-/// Backlog value passed to the `listen` syscall by the standard library
-const SUPPORTED_LISTEN_BACKLOG: i32 = 128;
-
 #[derive(Debug, PartialEq)]
 enum SocketFamily {
     // IPv4 internet protocols
@@ -22,6 +21,22 @@ enum SocketFamily {
     IPv6,
 }
 
+enum SocketIoError {
+    /// The socket is not yet ready. Either EINPROGRESS or ENOTCONNECTED occurred.
+    NotReady,
+    /// Any other kind of I/O error.
+    Other(io::Error),
+}
+
+impl From<io::Error> for SocketIoError {
+    fn from(value: io::Error) -> Self {
+        match value.kind() {
+            io::ErrorKind::InProgress | io::ErrorKind::NotConnected => Self::NotReady,
+            _ => Self::Other(value),
+        }
+    }
+}
+
 #[derive(Debug)]
 enum SocketState {
     /// No syscall after `socket` has been made.
@@ -32,6 +47,69 @@ enum SocketState {
     /// The `listen` syscall has been called on the socket.
     /// This is only reachable from the [`SocketState::Bound`] state.
     Listening(TcpListener),
+    /// The `connect` syscall has been called and we weren't yet able
+    /// to ensure the connection is established. This is only reachable
+    /// from the [`SocketState::Initial`] state.
+    Connecting(TcpStream),
+    /// The `connect` syscall has been called on the socket and
+    /// we ensured that the connection is established, or
+    /// the socket was created by the `accept` syscall.
+    /// For a socket created using the `connect` syscall, this is
+    /// only reachable from the [`SocketState::Connecting`] state.
+    Connected(TcpStream),
+}
+
+impl SocketState {
+    /// If the socket is currently in [`SocketState::Connecting`], try to ensure
+    /// that the connection is established by first checking that [`TcpStream::take_error`]
+    /// doesn't return an error and then by checking that [`TcpStream::peer_addr`]
+    /// returns the address of the connected peer.
+    ///
+    /// If the connection is established or the socket is in any other state,
+    /// [`Ok`] is returned.
+    ///
+    /// **Important**: On Windows hosts this function can only be used to ensure a socket is connected
+    /// _after_ a [`Interest::WRITABLE`] event was received.
+    pub fn try_set_connected(&mut self) -> Result<(), SocketIoError> {
+        // Further explanation of the limitation on Windows hosts:
+        // Windows treats sockets which are connecting as connected until either the connection timeout hits
+        // or an error occurs. Thus, the [`TcpStream::peer_addr`] method returns [`Ok`] with the provided peer
+        // address even when the connection might not yet be established.
+
+        let SocketState::Connecting(stream) = self else { return Ok(()) };
+
+        if let Ok(Some(e)) = stream.take_error() {
+            // There was an error whilst connecting.
+            let e = SocketIoError::from(e);
+            // We won't get EINPROGRESS or ENOTCONNECTED here
+            // so we need to reset the state.
+            assert!(matches!(e, SocketIoError::Other(_)));
+            // Go back to initial state as the only way of getting into the
+            // `Connecting` state is from the `Initial` state.
+            *self = SocketState::Initial;
+            return Err(e);
+        }
+
+        if let Err(e) = stream.peer_addr() {
+            let e = SocketIoError::from(e);
+            if let SocketIoError::Other(_) = &e {
+                // All other errors are fatal for a socket and thus the state needs to be reset.
+                *self = SocketState::Initial;
+            }
+            return Err(e);
+        };
+
+        // We just read the peer address without an error so we can be
+        // sure that the connection is established.
+
+        // Temporarily use dummy state to take ownership of the stream.
+        let SocketState::Connecting(stream) = std::mem::replace(self, SocketState::Initial) else {
+            // At the start of the function we ensured that we're currently connecting.
+            unreachable!()
+        };
+        *self = SocketState::Connected(stream);
+        Ok(())
+    }
 }
 
 #[derive(Debug)]
@@ -132,7 +210,7 @@ fn socket(
         } else {
             throw_unsup_format!(
                 "socket: domain {:#x} is unsupported, only AF_INET and \
-                                AF_INET6 are allowed.",
+                AF_INET6 are allowed.",
                 domain
             );
         };
@@ -140,14 +218,14 @@ fn socket(
         if flags != this.eval_libc_i32("SOCK_STREAM") {
             throw_unsup_format!(
                 "socket: type {:#x} is unsupported, only SOCK_STREAM, \
-                                SOCK_CLOEXEC and SOCK_NONBLOCK are allowed",
+                SOCK_CLOEXEC and SOCK_NONBLOCK are allowed",
                 flags
             );
         }
         if protocol != 0 {
             throw_unsup_format!(
                 "socket: socket protocol {protocol} is unsupported, \
-                                only 0 is allowed"
+                only 0 is allowed"
             );
         }
 
@@ -177,12 +255,12 @@ fn bind(
 
         // Get the file handle
         let Some(fd) = this.machine.fds.get(socket) else {
-            return interp_ok(this.eval_libc("EBADF"));
+            return this.set_last_error_and_return_i32(LibcError("EBADF"));
         };
 
         let Some(socket) = fd.downcast::<Socket>() else {
             // Man page specifies to return ENOTSOCK if `fd` is not a socket.
-            return interp_ok(this.eval_libc("ENOTSOCK"));
+            return this.set_last_error_and_return_i32(LibcError("ENOTSOCK"));
         };
 
         assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
@@ -200,7 +278,7 @@ fn bind(
                     // Attempted to bind an address from a family that doesn't match
                     // the family of the socket.
                     let err = if matches!(this.tcx.sess.target.os, Os::Linux | Os::Android) {
-                        // Linux man page states that `EINVAL` is used when there is an addres family mismatch.
+                        // Linux man page states that `EINVAL` is used when there is an address family mismatch.
                         // See <https://man7.org/linux/man-pages/man2/bind.2.html>
                         LibcError("EINVAL")
                     } else {
@@ -214,10 +292,15 @@ fn bind(
 
                 *state = SocketState::Bound(address);
             }
+            SocketState::Connecting(_) | SocketState::Connected(_) =>
+                throw_unsup_format!(
+                    "bind: socket is already connected and binding a
+                    connected socket is unsupported"
+                ),
             SocketState::Bound(_) | SocketState::Listening(_) =>
                 throw_unsup_format!(
                     "bind: socket is already bound and binding a socket \
-                                    multiple times is unsupported"
+                    multiple times is unsupported"
                 ),
         }
 
@@ -228,37 +311,24 @@ fn listen(&mut self, socket: &OpTy<'tcx>, backlog: &OpTy<'tcx>) -> InterpResult<
         let this = self.eval_context_mut();
 
         let socket = this.read_scalar(socket)?.to_i32()?;
-        let backlog = this.read_scalar(backlog)?.to_i32()?;
+        // Since the backlog value is just a performance hint we can ignore it.
+        let _backlog = this.read_scalar(backlog)?.to_i32()?;
 
         // Get the file handle
         let Some(fd) = this.machine.fds.get(socket) else {
-            return interp_ok(this.eval_libc("EBADF"));
+            return this.set_last_error_and_return_i32(LibcError("EBADF"));
         };
 
         let Some(socket) = fd.downcast::<Socket>() else {
             // Man page specifies to return ENOTSOCK if `fd` is not a socket.
-            return interp_ok(this.eval_libc("ENOTSOCK"));
+            return this.set_last_error_and_return_i32(LibcError("ENOTSOCK"));
         };
 
         assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
 
-        // Only allow the same backlog value as the standard library uses since the standard library
-        // doesn't provide a way to set a custom value.
-        if backlog != SUPPORTED_LISTEN_BACKLOG {
-            // The first time this happens at a particular location, print a warning.
-            static DEDUP: SpanDedupDiagnostic = SpanDedupDiagnostic::new();
-            this.dedup_diagnostic(&DEDUP, |first| {
-                NonHaltingDiagnostic::SocketListenUnsupportedBacklog {
-                    details: first,
-                    provided: backlog,
-                    supported: SUPPORTED_LISTEN_BACKLOG,
-                }
-            });
-        }
-
         let mut state = socket.state.borrow_mut();
 
-        match &*state {
+        match *state {
             SocketState::Bound(socket_addr) =>
                 match TcpListener::bind(socket_addr) {
                     Ok(listener) => *state = SocketState::Listening(listener),
@@ -272,11 +342,160 @@ fn listen(&mut self, socket: &OpTy<'tcx>, backlog: &OpTy<'tcx>) -> InterpResult<
             SocketState::Listening(_) => {
                 throw_unsup_format!("listen: listening on a socket multiple times is unsupported")
             }
+            SocketState::Connecting(_) | SocketState::Connected(_) => {
+                throw_unsup_format!("listen: listening on a connected socket is unsupported")
+            }
         }
 
         interp_ok(Scalar::from_i32(0))
     }
 
+    /// For more information on the arguments see the accept manpage:
+    /// <https://linux.die.net/man/2/accept4>
+    fn accept4(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+        flags: Option<&OpTy<'tcx>>,
+        // Location where the output scalar is written to.
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let address_ptr = this.read_pointer(address)?;
+        let address_len_ptr = this.read_pointer(address_len)?;
+        let mut flags =
+            if let Some(flags) = flags { this.read_scalar(flags)?.to_i32()? } else { 0 };
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return this.set_last_error_and_return(LibcError("EBADF"), dest);
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return this.set_last_error_and_return(LibcError("ENOTSOCK"), dest);
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        if !matches!(*socket.state.borrow(), SocketState::Listening(_)) {
+            throw_unsup_format!(
+                "accept4: accepting incoming connections is only allowed when socket is listening"
+            )
+        };
+
+        let mut is_client_sock_nonblock = false;
+
+        // Interpret the flag. Every flag we recognize is "subtracted" from `flags`, so
+        // if there is anything left at the end, that's an unsupported flag.
+        if matches!(
+            this.tcx.sess.target.os,
+            Os::Linux | Os::Android | Os::FreeBsd | Os::Solaris | Os::Illumos
+        ) {
+            // SOCK_NONBLOCK and SOCK_CLOEXEC only exist on Linux, Android, FreeBSD,
+            // Solaris, and Illumos targets
+            let sock_nonblock = this.eval_libc_i32("SOCK_NONBLOCK");
+            let sock_cloexec = this.eval_libc_i32("SOCK_CLOEXEC");
+            if flags & sock_nonblock == sock_nonblock {
+                is_client_sock_nonblock = true;
+                flags &= !sock_nonblock;
+            }
+            if flags & sock_cloexec == sock_cloexec {
+                // We don't support `exec` so we can ignore this.
+                flags &= !sock_cloexec;
+            }
+        }
+
+        if flags != 0 {
+            throw_unsup_format!(
+                "accept4: flag {flags:#x} is unsupported, only SOCK_CLOEXEC \
+                and SOCK_NONBLOCK are allowed",
+            );
+        }
+
+        if socket.is_non_block.get() {
+            throw_unsup_format!("accept4: non-blocking accept is unsupported")
+        }
+
+        // The socket is in blocking mode and thus the accept call should block
+        // until an incoming connection is ready.
+        this.block_for_accept(
+            address_ptr,
+            address_len_ptr,
+            is_client_sock_nonblock,
+            socket,
+            dest.clone(),
+        );
+        interp_ok(())
+    }
+
+    fn connect(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+        // Location where the output scalar is written to.
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let address = match this.socket_address(address, address_len, "connect")? {
+            Ok(address) => address,
+            Err(e) => return this.set_last_error_and_return(e, dest),
+        };
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return this.set_last_error_and_return(LibcError("EBADF"), dest);
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket
+            return this.set_last_error_and_return(LibcError("ENOTSOCK"), dest);
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        match &*socket.state.borrow() {
+            SocketState::Initial => { /* fall-through to below */ }
+            // The socket is already in a connecting state.
+            SocketState::Connecting(_) =>
+                return this.set_last_error_and_return(LibcError("EALREADY"), dest),
+            // We don't return EISCONN for already connected sockets, for which we're
+            // sure that the connection is established, since TCP sockets are usually
+            // allowed to be connected multiple times.
+            _ =>
+                throw_unsup_format!(
+                    "connect: connecting is only supported for sockets which are neither \
+                    bound, listening nor already connected"
+                ),
+        }
+
+        // Mio returns a potentially unconnected stream.
+        // We can be ensured that the connection is established when
+        // [`TcpStream::take_err`] and [`TcpStream::peer_addr`] both
+        // don't return errors.
+        // For non-blocking sockets we need to check that for every
+        // [`Interest::WRITEABLE`] event on the stream.
+        match TcpStream::connect(address) {
+            Ok(stream) => *socket.state.borrow_mut() = SocketState::Connecting(stream),
+            Err(e) => return this.set_last_error_and_return(e, dest),
+        };
+
+        if socket.is_non_block.get() {
+            throw_unsup_format!("connect: non-blocking connect is unsupported");
+        }
+
+        // The socket is in blocking mode and thus the connect call should block
+        // until the connection with the server is established.
+        this.block_for_connect(socket, dest.clone());
+        interp_ok(())
+    }
+
     fn setsockopt(
         &mut self,
         socket: &OpTy<'tcx>,
@@ -295,12 +514,12 @@ fn setsockopt(
 
         // Get the file handle
         let Some(fd) = this.machine.fds.get(socket) else {
-            return interp_ok(this.eval_libc("EBADF"));
+            return this.set_last_error_and_return_i32(LibcError("EBADF"));
         };
 
         let Some(_socket) = fd.downcast::<Socket>() else {
             // Man page specifies to return ENOTSOCK if `fd` is not a socket.
-            return interp_ok(this.eval_libc("ENOTSOCK"));
+            return this.set_last_error_and_return_i32(LibcError("ENOTSOCK"));
         };
 
         if level == this.eval_libc_i32("SOL_SOCKET") {
@@ -380,7 +599,7 @@ fn getsockname(
                     // random port will be and thus this is unsupported.
                     throw_unsup_format!(
                         "getsockname: when the port is 0, getting the socket address before \
-                                        calling `listen` or `connect` is unsupported"
+                        calling `listen` or `connect` is unsupported"
                     )
                 }
 
@@ -511,7 +730,7 @@ fn socket_address(
             // thus also no address family of another type should be supported.
             throw_unsup_format!(
                 "{foreign_name}: address family {family:#x} is unsupported, \
-                                only AF_INET and AF_INET6 are allowed"
+                only AF_INET and AF_INET6 are allowed"
             );
         };
 
@@ -672,4 +891,126 @@ fn write_socket_address(
 
         interp_ok(Ok(()))
     }
+
+    /// Block the thread until there's an incoming connection or an error occurred.
+    ///
+    /// This recursively calls itself should the operation still block for some reason.
+    fn block_for_accept(
+        &mut self,
+        address_ptr: Pointer,
+        address_len_ptr: Pointer,
+        is_client_sock_nonblock: bool,
+        socket: FileDescriptionRef<Socket>,
+        dest: MPlaceTy<'tcx>,
+    ) {
+        let this = self.eval_context_mut();
+        this.block_thread_for_io(
+            socket.clone(),
+            Interest::READABLE,
+            None,
+            callback!(@capture<'tcx> {
+                address_ptr: Pointer,
+                address_len_ptr: Pointer,
+                is_client_sock_nonblock: bool,
+                socket: FileDescriptionRef<Socket>,
+                dest: MPlaceTy<'tcx>,
+            } |this, kind: UnblockKind| {
+                assert_eq!(kind, UnblockKind::Ready);
+
+                let state = socket.state.borrow();
+
+                let SocketState::Listening(listener) = &*state else {
+                    // We checked that the socket is in listening state before blocking
+                    // and since there is no outgoing transition from that state this
+                    // should be unreachable.
+                    unreachable!()
+                };
+
+                let (stream, addr) = match listener.accept() {
+                    Ok(peer) => peer,
+                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
+                        // We need to block the thread again as it would still block.
+                        drop(state);
+                        this.block_for_accept(address_ptr, address_len_ptr, is_client_sock_nonblock, socket, dest);
+                        return interp_ok(())
+                    },
+                    Err(e) => return this.set_last_error_and_return(e, &dest),
+                };
+
+                let family = match addr {
+                    SocketAddr::V4(_) => SocketFamily::IPv4,
+                    SocketAddr::V6(_) => SocketFamily::IPv6,
+                };
+
+                if address_ptr != Pointer::null() {
+                    // We only attempt a write if the address pointer is not a null pointer.
+                    // If the address pointer is a null pointer the user isn't interested in the
+                    // address and we don't need to write anything.
+                    if let Err(e) = this.write_socket_address(&addr, address_ptr, address_len_ptr, "accept4")? {
+                      return this.set_last_error_and_return(e, &dest);
+                    };
+                }
+
+                let fd = this.machine.fds.new_ref(Socket {
+                    family,
+                    state: RefCell::new(SocketState::Connected(stream)),
+                    is_non_block: Cell::new(is_client_sock_nonblock),
+                });
+                let sockfd = this.machine.fds.insert(fd);
+                // We need to create the scalar using the destination size since
+                // `syscall(SYS_accept4, ...)` returns a long which doesn't match
+                // the int returned from the `accept`/`accept4` syscalls.
+                // See <https://man7.org/linux/man-pages/man2/syscall.2.html>.
+                this.write_scalar(Scalar::from_int(sockfd, dest.layout.size), &dest)
+            }),
+        );
+    }
+
+    /// Block the thread until the stream is connected or an error occurred.
+    fn block_for_connect(&mut self, socket: FileDescriptionRef<Socket>, dest: MPlaceTy<'tcx>) {
+        let this = self.eval_context_mut();
+        this.block_thread_for_io(
+            socket.clone(),
+            Interest::WRITABLE,
+            None,
+            callback!(@capture<'tcx> {
+                socket: FileDescriptionRef<Socket>,
+                dest: MPlaceTy<'tcx>,
+            } |this, kind: UnblockKind| {
+                assert_eq!(kind, UnblockKind::Ready);
+
+                let mut state = socket.state.borrow_mut();
+
+                // We received a "writable" event so `try_set_connected` is safe to call.
+                match state.try_set_connected() {
+                    Ok(_) => this.write_scalar(Scalar::from_i32(0), &dest),
+                     Err(SocketIoError::NotReady) => {
+                        // We need to block the thread again as the connection is still not yet ready.
+                        drop(state);
+                        this.block_for_connect(socket, dest);
+                        return interp_ok(())
+                    },
+                    Err(SocketIoError::Other(e)) => return this.set_last_error_and_return(e, &dest)
+                }
+            }),
+        );
+    }
+}
+
+impl VisitProvenance for FileDescriptionRef<Socket> {
+    // A socket doesn't contain any references to machine memory
+    // and thus we don't need to propagate the visit.
+    fn visit_provenance(&self, _visit: &mut VisitWith<'_>) {}
+}
+
+impl WithSource for FileDescriptionRef<Socket> {
+    fn with_source(&self, f: &mut dyn FnMut(&mut dyn Source) -> io::Result<()>) -> io::Result<()> {
+        let mut state = self.state.borrow_mut();
+        match &mut *state {
+            SocketState::Listening(listener) => f(listener),
+            SocketState::Connecting(stream) | SocketState::Connected(stream) => f(stream),
+            // We never try adding a socket which is not backed by a real socket to the poll registry.
+            _ => unreachable!(),
+        }
+    }
 }
diff --git a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
index 9dbfc6d21712..d4ebdeab86f1 100644
--- a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
@@ -133,6 +133,15 @@ fn emulate_foreign_item_inner(
                 let result = this.bind(socket, address, address_len)?;
                 this.write_scalar(result, dest)?;
             }
+            "__xnet_connect" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *const _, libc::socklen_t) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                this.connect(socket, address, address_len, dest)?;
+            }
 
             // Miscellaneous
             "___errno" => {
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
index 0a5f8c226af4..e3c14e60b25e 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
@@ -1,10 +1,14 @@
 //@ignore-target: windows # No libc socket on Windows
 //@compile-flags: -Zmiri-disable-isolation
 
+#![feature(io_error_inprogress)]
+
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
 use std::io::{self, ErrorKind};
-use std::mem::MaybeUninit;
+use std::time::Duration;
+#[allow(unused)]
+use std::{mem::MaybeUninit, thread};
 
 use libc_utils::*;
 
@@ -28,6 +32,8 @@ fn main() {
 
     test_listen();
 
+    test_accept_connect();
+
     test_getsockname_ipv4();
     test_getsockname_ipv4_random_port();
     test_getsockname_ipv4_unbound();
@@ -117,7 +123,7 @@ fn test_set_nosigpipe_invalid_len() {
     // By providing a u64 of size 8 bytes we trigger an invalid length error.
     let err = setsockopt(sockfd, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1u64).unwrap_err();
     assert_eq!(err.kind(), ErrorKind::InvalidInput);
-    // check that it is the right kind of `InvalidInput`
+    // Check that it is the right kind of `InvalidInput`.
     assert_eq!(err.raw_os_error(), Some(libc::EINVAL));
 }
 
@@ -137,7 +143,7 @@ fn test_bind_ipv4_invalid_addr_len() {
         .unwrap_err()
     };
     assert_eq!(err.kind(), ErrorKind::InvalidInput);
-    // check that it is the right kind of `InvalidInput`
+    // Check that it is the right kind of `InvalidInput`.
     assert_eq!(err.raw_os_error(), Some(libc::EINVAL));
 }
 
@@ -166,12 +172,86 @@ fn test_listen() {
         ));
     }
 
-    // Use the supported backlog value to avoid the warning.
-    let backlog = 128;
+    unsafe {
+        errno_check(libc::listen(sockfd, 16));
+    }
+}
+
+/// Test accepting connections by running a server in a separate thread and connecting clients
+/// from the main thread.
+/// This function tests both
+/// - Connecting when the server is already accepting
+/// - Accepting when there is already an incoming connection
+fn test_accept_connect() {
+    // Create a new non-blocking server socket.
+    let server_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let client_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
+    unsafe {
+        errno_check(libc::bind(
+            server_sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
 
     unsafe {
-        errno_check(libc::listen(sockfd, backlog));
+        errno_check(libc::listen(server_sockfd, 16));
     }
+
+    // Retrieve actual listener address because we used a randomized port.
+    let (_, server_addr) =
+        sockname(|storage, len| unsafe { libc::getsockname(server_sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V4(addr) = server_addr else {
+        // We bound an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+
+    // Spawn the server thread.
+    let server_thread = thread::spawn(move || {
+        let (_peerfd, _peer_addr) =
+            sockname(|storage, len| unsafe { libc::accept(server_sockfd, storage, len) }).unwrap();
+
+        // Yield back to the client thread to test whether calling `connect` first also
+        // works.
+        thread::sleep(Duration::from_millis(10));
+
+        let (_peerfd, _peer_addr) =
+            sockname(|storage, len| unsafe { libc::accept(server_sockfd, storage, len) }).unwrap();
+    });
+
+    // Yield to server thread to ensure `accept` is called before we try
+    // to connect.
+    thread::sleep(Duration::from_millis(10));
+
+    // Test connecting to an already accepting server.
+    unsafe {
+        errno_check(libc::connect(
+            client_sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    // Server thread should now be in its `sleep`.
+    // Test connecting when there is no actively ongoing `accept`.
+    // We need a new client socket since we cannot connect a socket multiple times.
+    let client_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+
+    unsafe {
+        errno_check(libc::connect(
+            client_sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    server_thread.join().unwrap();
 }
 
 /// Test the `getsockname` syscall on an IPv4 socket which is bound.
@@ -188,17 +268,15 @@ fn test_getsockname_ipv4() {
             size_of::<libc::sockaddr_in>() as libc::socklen_t,
         ));
     }
-    // Use the supported backlog value to avoid the warning.
-    let backlog = 128;
 
     unsafe {
-        errno_check(libc::listen(sockfd, backlog));
+        errno_check(libc::listen(sockfd, 16));
     }
 
-    let sockname =
+    let (_, sock_addr) =
         sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
 
-    let LibcSocketAddr::V4(sock_addr) = sockname else {
+    let LibcSocketAddr::V4(sock_addr) = sock_addr else {
         // We bound an IPv4 address so we also expect
         // an IPv4 address to be returned.
         panic!()
@@ -225,17 +303,15 @@ fn test_getsockname_ipv4_random_port() {
             size_of::<libc::sockaddr_in>() as libc::socklen_t,
         ));
     }
-    // Use the supported backlog value to avoid the warning.
-    let backlog = 128;
 
     unsafe {
-        errno_check(libc::listen(sockfd, backlog));
+        errno_check(libc::listen(sockfd, 16));
     }
 
-    let sockname =
+    let (_, sock_addr) =
         sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
 
-    let LibcSocketAddr::V4(sock_addr) = sockname else {
+    let LibcSocketAddr::V4(sock_addr) = sock_addr else {
         // We bound an IPv4 address so we also expect
         // an IPv4 address to be returned.
         panic!()
@@ -252,12 +328,12 @@ fn test_getsockname_ipv4_unbound() {
     let sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
 
-    let sockname =
+    let (_, sock_addr) =
         sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
 
     // Libc representation of an unspecified IPv4 address with zero port.
     let addr = net::ipv4_sock_addr([0, 0, 0, 0], 0);
-    let LibcSocketAddr::V4(sock_addr) = sockname else {
+    let LibcSocketAddr::V4(sock_addr) = sock_addr else {
         // We bound an IPv4 address so we also expect
         // an IPv4 address to be returned.
         panic!()
@@ -282,17 +358,15 @@ fn test_getsockname_ipv6() {
             size_of::<libc::sockaddr_in6>() as libc::socklen_t,
         ));
     }
-    // Use the supported backlog value to avoid the warning.
-    let backlog = 128;
 
     unsafe {
-        errno_check(libc::listen(sockfd, backlog));
+        errno_check(libc::listen(sockfd, 16));
     }
 
-    let sockname =
+    let (_, sock_addr) =
         sockname(|storage, len| unsafe { libc::getsockname(sockfd, storage, len) }).unwrap();
 
-    let LibcSocketAddr::V6(sock_addr) = sockname else {
+    let LibcSocketAddr::V6(sock_addr) = sock_addr else {
         // We bound an IPv6 address so we also expect
         // an IPv6 address to be returned.
         panic!()
@@ -338,27 +412,31 @@ enum LibcSocketAddr {
 /// Wraps a call to a platform function that returns a socket address.
 /// This is very much the same as the function with the same name in the
 /// standard library implementation.
-fn sockname<F>(f: F) -> io::Result<LibcSocketAddr>
+/// Returns a tuple containing the actual return value of the performed
+/// syscall and the written address of it.
+fn sockname<F>(f: F) -> io::Result<(libc::c_int, LibcSocketAddr)>
 where
     F: FnOnce(*mut libc::sockaddr, *mut libc::socklen_t) -> libc::c_int,
 {
     let mut storage = MaybeUninit::<libc::sockaddr_storage>::zeroed();
     let mut len = size_of::<libc::sockaddr_storage>() as libc::socklen_t;
-    errno_result(f(storage.as_mut_ptr().cast(), &mut len))?;
+    let value = errno_result(f(storage.as_mut_ptr().cast(), &mut len))?;
     // SAFETY:
     // The caller guarantees that the storage has been successfully initialized
     // and its size written to `len` if `f` returns a success.
-    unsafe {
+    let address = unsafe {
         match (*storage.as_ptr()).ss_family as libc::c_int {
             libc::AF_INET => {
                 assert!(len as usize >= size_of::<libc::sockaddr_in>());
-                Ok(LibcSocketAddr::V4(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in)))
+                LibcSocketAddr::V4(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in))
             }
             libc::AF_INET6 => {
                 assert!(len as usize >= size_of::<libc::sockaddr_in6>());
-                Ok(LibcSocketAddr::V6(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in6)))
+                LibcSocketAddr::V6(*(storage.as_ptr() as *const _ as *const libc::sockaddr_in6))
             }
-            _ => Err(io::Error::new(ErrorKind::InvalidInput, "invalid argument")),
+            _ => return Err(io::Error::new(ErrorKind::InvalidInput, "invalid argument")),
         }
-    }
+    };
+
+    Ok((value, address))
 }
diff --git a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
deleted file mode 100644
index 193a6c693801..000000000000
--- a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ignore-target: windows # No libc socket on Windows
-//@compile-flags: -Zmiri-disable-isolation
-
-#[path = "../../utils/libc.rs"]
-mod libc_utils;
-use libc_utils::*;
-
-fn main() {
-    let sockfd =
-        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
-    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 2345);
-    unsafe {
-        errno_check(libc::bind(
-            sockfd,
-            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
-            size_of::<libc::sockaddr_in>() as libc::socklen_t,
-        ));
-    }
-
-    // Only supported value is 128, thus we use 127 to trigger the warning.
-    let backlog = 127;
-
-    unsafe {
-        let errno = libc::listen(sockfd, backlog);
-        errno_check(errno);
-    }
-}
diff --git a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr b/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
deleted file mode 100644
index 94582af4a6e2..000000000000
--- a/src/tools/miri/tests/pass-dep/libc/socket-unsupported-listen-backlog.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-warning: called `listen` on socket with backlog value of 127 but only 128 is supported
-  --> tests/pass-dep/libc/socket-unsupported-listen-backlog.rs:LL:CC
-   |
-LL |         let errno = libc::listen(sockfd, backlog);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to `listen` with unsupported backlog value
-   |
-   = note: the given value will be ignored and a backlog of 128 will be used instead
-
diff --git a/src/tools/miri/tests/pass-dep/shims/socket.rs b/src/tools/miri/tests/pass-dep/shims/socket.rs
deleted file mode 100644
index 787dd5e27399..000000000000
--- a/src/tools/miri/tests/pass-dep/shims/socket.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ignore-target: windows # No libc socket on Windows
-//@compile-flags: -Zmiri-disable-isolation
-
-use std::net::TcpListener;
-
-fn main() {
-    create_ipv4_listener();
-    create_ipv6_listener();
-}
-
-fn create_ipv4_listener() {
-    let _listener_ipv4 = TcpListener::bind("127.0.0.1:0").unwrap();
-}
-
-fn create_ipv6_listener() {
-    let _listener_ipv6 = TcpListener::bind("[::1]:0").unwrap();
-}
diff --git a/src/tools/miri/tests/pass/shims/socket.rs b/src/tools/miri/tests/pass/shims/socket.rs
new file mode 100644
index 000000000000..2e63e00c67d9
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/socket.rs
@@ -0,0 +1,36 @@
+//@ignore-target: windows # No libc socket on Windows
+//@compile-flags: -Zmiri-disable-isolation
+
+use std::net::{TcpListener, TcpStream};
+use std::thread;
+
+fn main() {
+    test_create_ipv4_listener();
+    test_create_ipv6_listener();
+    test_accept_and_connect();
+}
+
+fn test_create_ipv4_listener() {
+    let _listener_ipv4 = TcpListener::bind("127.0.0.1:0").unwrap();
+}
+
+fn test_create_ipv6_listener() {
+    let _listener_ipv6 = TcpListener::bind("[::1]:0").unwrap();
+}
+
+/// Try to connect to a TCP listener running in a separate thread and
+/// accepting connections.
+fn test_accept_and_connect() {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    // Get local address with randomized port to know where
+    // we need to connect to.
+    let address = listener.local_addr().unwrap();
+
+    let handle = thread::spawn(move || {
+        let (_stream, _addr) = listener.accept().unwrap();
+    });
+
+    let _stream = TcpStream::connect(address).unwrap();
+
+    handle.join().unwrap();
+}

From 6458ca5349136c740dcb1fd99ec7e4f1eb2dbd99 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Fri, 2 Jan 2026 17:28:27 -0500
Subject: [PATCH 0776/1059] Unknown -> Unsupported compression algorithm

Both zstd and zlib are *known* compression algorithms, they just may not
be supported by the backend. We shouldn't mislead users into e.g.
thinking they made a typo.
---
 compiler/rustc_codegen_llvm/src/back/write.rs | 6 +++---
 compiler/rustc_codegen_llvm/src/errors.rs     | 4 ++--
 tests/run-make/compressed-debuginfo/rmake.rs  | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index ffa582737ca8..faa14a6c573e 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -36,7 +36,7 @@
 use crate::common::AsCCharPtr;
 use crate::errors::{
     CopyBitcode, FromLlvmDiag, FromLlvmOptimizationDiag, LlvmError, ParseTargetMachineConfig,
-    UnknownCompression, WithLlvmError, WriteBytecode,
+    UnsupportedCompression, WithLlvmError, WriteBytecode,
 };
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 use crate::llvm::{self, DiagnosticInfo};
@@ -248,7 +248,7 @@ pub(crate) fn target_machine_factory(
             if llvm::LLVMRustLLVMHasZlibCompression() {
                 llvm::CompressionKind::Zlib
             } else {
-                sess.dcx().emit_warn(UnknownCompression { algorithm: "zlib" });
+                sess.dcx().emit_warn(UnsupportedCompression { algorithm: "zlib" });
                 llvm::CompressionKind::None
             }
         }
@@ -256,7 +256,7 @@ pub(crate) fn target_machine_factory(
             if llvm::LLVMRustLLVMHasZstdCompression() {
                 llvm::CompressionKind::Zstd
             } else {
-                sess.dcx().emit_warn(UnknownCompression { algorithm: "zstd" });
+                sess.dcx().emit_warn(UnsupportedCompression { algorithm: "zstd" });
                 llvm::CompressionKind::None
             }
         }
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index 9fb406516f66..880abb3fbc24 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -182,9 +182,9 @@ pub(crate) struct CopyBitcode {
 
 #[derive(Diagnostic)]
 #[diag(
-    "unknown debuginfo compression algorithm {$algorithm} - will fall back to uncompressed debuginfo"
+    "unsupported debuginfo compression algorithm {$algorithm} - will fall back to uncompressed debuginfo"
 )]
-pub(crate) struct UnknownCompression {
+pub(crate) struct UnsupportedCompression {
     pub algorithm: &'static str,
 }
 
diff --git a/tests/run-make/compressed-debuginfo/rmake.rs b/tests/run-make/compressed-debuginfo/rmake.rs
index 5ba1a1852d51..c8bde9cfa221 100644
--- a/tests/run-make/compressed-debuginfo/rmake.rs
+++ b/tests/run-make/compressed-debuginfo/rmake.rs
@@ -23,7 +23,7 @@ fn check_compression(compression: &str, to_find: &str) {
         } else {
             assert_contains(
                 stderr,
-                format!("unknown debuginfo compression algorithm {compression}"),
+                format!("unsupported debuginfo compression algorithm {compression}"),
             );
         }
     });

From 9677d7a5872c5c98c73f04afa028e147b983c6f6 Mon Sep 17 00:00:00 2001
From: Scott Young <scottyoung@gmail.com>
Date: Fri, 20 Mar 2026 17:20:06 -0400
Subject: [PATCH 0777/1059] debuginfo: emit DW_TAG_call_site entries

---
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   |  7 +++++--
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  1 +
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  3 ++-
 tests/codegen-llvm/debuginfo-callsite-flag.rs | 20 +++++++++++++++++++
 4 files changed, 28 insertions(+), 3 deletions(-)
 create mode 100644 tests/codegen-llvm/debuginfo-callsite-flag.rs

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index c3fa86f8a2ad..a667877e8e51 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -471,7 +471,7 @@ fn dbg_scope_fn(
         // FIXME(eddyb) does this need to be separate from `loc.line` for some reason?
         let scope_line = loc.line;
 
-        let mut flags = DIFlags::FlagPrototyped;
+        let mut flags = DIFlags::FlagPrototyped | DIFlags::FlagAllCallsDescribed;
 
         if fn_abi.ret.layout.is_uninhabited() {
             flags |= DIFlags::FlagNoReturn;
@@ -494,6 +494,9 @@ fn dbg_scope_fn(
         // LLVM LTO can't unify type definitions when a child DIE is a full subprogram definition.
         // When we use this `decl` below, the subprogram definition gets created at the CU level
         // with a DW_AT_specification pointing back to the type's declaration.
+        // FlagAllCallsDescribed cannot appear on the method declaration DIE
+        // because it has no body, which LLVM's verifier rejects.
+        let decl_flags = flags & !DIFlags::FlagAllCallsDescribed;
         let decl = is_method.then(|| unsafe {
             llvm::LLVMRustDIBuilderCreateMethod(
                 DIB(self),
@@ -505,7 +508,7 @@ fn dbg_scope_fn(
                 file_metadata,
                 loc.line,
                 function_type_metadata,
-                flags,
+                decl_flags,
                 spflags & !DISPFlags::SPFlagDefinition,
                 template_parameters,
             )
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 77438472644f..813897d7d327 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -779,6 +779,7 @@ pub(crate) struct DIFlags: u32 {
             const FlagNonTrivial          = (1 << 26);
             const FlagBigEndian           = (1 << 27);
             const FlagLittleEndian        = (1 << 28);
+            const FlagAllCallsDescribed   = (1 << 29);
         }
     }
 
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 63ff0b2a0a0d..392cd0601391 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -779,6 +779,7 @@ ASSERT_DIFLAG_VALUE(FlagThunk, 1 << 25);
 ASSERT_DIFLAG_VALUE(FlagNonTrivial, 1 << 26);
 ASSERT_DIFLAG_VALUE(FlagBigEndian, 1 << 27);
 ASSERT_DIFLAG_VALUE(FlagLittleEndian, 1 << 28);
+static_assert(DINode::DIFlags::FlagAllCallsDescribed == (1 << 29));
 ASSERT_DIFLAG_VALUE(FlagIndirectVirtualBase, (1 << 2) | (1 << 5));
 #undef ASSERT_DIFLAG_VALUE
 
@@ -791,7 +792,7 @@ ASSERT_DIFLAG_VALUE(FlagIndirectVirtualBase, (1 << 2) | (1 << 5));
 // to copying each bit/subvalue.
 static DINode::DIFlags fromRust(LLVMDIFlags Flags) {
   // Check that all set bits are covered by the static assertions above.
-  const unsigned UNKNOWN_BITS = (1 << 31) | (1 << 30) | (1 << 29) | (1 << 21);
+  const unsigned UNKNOWN_BITS = (1 << 31) | (1 << 30) | (1 << 21);
   if (Flags & UNKNOWN_BITS) {
     report_fatal_error("bad LLVMDIFlags");
   }
diff --git a/tests/codegen-llvm/debuginfo-callsite-flag.rs b/tests/codegen-llvm/debuginfo-callsite-flag.rs
new file mode 100644
index 000000000000..f86adfcc3626
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-callsite-flag.rs
@@ -0,0 +1,20 @@
+// Check that DIFlagAllCallsDescribed is set on subprogram definitions.
+
+//@ ignore-msvc (CodeView does not use DIFlagAllCallsDescribed)
+//@ compile-flags: -C debuginfo=2 -C opt-level=1 -C no-prepopulate-passes
+
+// CHECK: {{.*}}DISubprogram{{.*}}name: "foo"{{.*}}DIFlagAllCallsDescribed{{.*}}
+
+#[no_mangle]
+#[inline(never)]
+pub fn foo(x: i32) -> i32 {
+    bar(x + 1)
+}
+
+#[no_mangle]
+#[inline(never)]
+pub fn bar(x: i32) -> i32 {
+    x * 2
+}
+
+fn main() {}

From 1223441926fa226e55520f72ee0307ab32c783d9 Mon Sep 17 00:00:00 2001
From: Tayfun Bocek <tayfunbocek@live.ca>
Date: Sun, 22 Mar 2026 17:18:47 +0300
Subject: [PATCH 0778/1059] Constify `NonNull::with_exposed_provenance`

---
 library/core/src/ptr/non_null.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 8be7d3a9ae92..7399ee569eb3 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -139,8 +139,9 @@ pub const fn dangling() -> Self {
     ///
     /// This is an [Exposed Provenance][crate::ptr#exposed-provenance] API.
     #[stable(feature = "nonnull_provenance", since = "1.89.0")]
+    #[rustc_const_unstable(feature = "const_nonnull_with_exposed_provenance", issue = "154215")]
     #[inline]
-    pub fn with_exposed_provenance(addr: NonZero<usize>) -> Self {
+    pub const fn with_exposed_provenance(addr: NonZero<usize>) -> Self {
         // SAFETY: we know `addr` is non-zero.
         unsafe {
             let ptr = crate::ptr::with_exposed_provenance_mut(addr.get());

From b584d4d6680b5032198a26a658d9aee6b82cdfd8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 22 Mar 2026 17:17:56 +0100
Subject: [PATCH 0779/1059] update lockfile

---
 Cargo.lock | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 98567f858e9f..f8ce74b9e2b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2175,9 +2175,9 @@ checksum = "9fa0e2a1fcbe2f6be6c42e342259976206b383122fc152e872795338b5a3f3a7"
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
 [[package]]
 name = "libdbus-sys"
@@ -2454,11 +2454,12 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
+ "log",
  "wasi 0.11.1+wasi-snapshot-preview1",
  "windows-sys 0.61.2",
 ]
@@ -2490,6 +2491,7 @@ dependencies = [
  "libffi",
  "libloading 0.9.0",
  "measureme",
+ "mio",
  "nix",
  "rand 0.9.2",
  "regex",

From be8dee11410ade2cd2f2f0ced7b9885aeebaa4c1 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 22 Mar 2026 17:36:39 +0100
Subject: [PATCH 0780/1059] interpret/validity: remove unreachable error kind

---
 compiler/rustc_const_eval/src/interpret/validity.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 41a4cb2f23a1..6466d533421b 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -128,7 +128,6 @@ enum ExpectedKind {
     Reference,
     Box,
     RawPtr,
-    InitScalar,
     Bool,
     Char,
     Float,
@@ -143,7 +142,6 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             ExpectedKind::Reference => "expected a reference",
             ExpectedKind::Box => "expected a box",
             ExpectedKind::RawPtr => "expected a raw pointer",
-            ExpectedKind::InitScalar => "expected initialized scalar value",
             ExpectedKind::Bool => "expected a boolean",
             ExpectedKind::Char => "expected a unicode scalar value",
             ExpectedKind::Float => "expected a floating point number",
@@ -1478,7 +1476,9 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
             BackendRepr::Scalar(scalar_layout) => {
                 if !scalar_layout.is_uninit_valid() {
                     // There is something to check here.
-                    let scalar = self.read_scalar(val, ExpectedKind::InitScalar)?;
+                    // We read directly via `ecx` since the read cannot fail -- we already read
+                    // this field above when recursing into the field.
+                    let scalar = self.ecx.read_scalar(val)?;
                     self.visit_scalar(scalar, scalar_layout)?;
                 }
             }
@@ -1487,8 +1487,9 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
                 // FIXME: find a way to also check ScalarPair when one side can be uninit but
                 // the other must be init.
                 if !a_layout.is_uninit_valid() && !b_layout.is_uninit_valid() {
-                    let (a, b) =
-                        self.read_immediate(val, ExpectedKind::InitScalar)?.to_scalar_pair();
+                    // We read directly via `ecx` since the read cannot fail -- we already read
+                    // this field above when recursing into the field.
+                    let (a, b) = self.ecx.read_immediate(val)?.to_scalar_pair();
                     self.visit_scalar(a, a_layout)?;
                     self.visit_scalar(b, b_layout)?;
                 }

From faddfb500118d3f1ad5bd8a87a26613aff490261 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Sun, 22 Mar 2026 18:34:43 +0100
Subject: [PATCH 0781/1059] Add new `LintBuffer::dyn_buffer_lint` method

---
 compiler/rustc_errors/src/decorate_diag.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/compiler/rustc_errors/src/decorate_diag.rs b/compiler/rustc_errors/src/decorate_diag.rs
index a11082e29663..c7e0d508c173 100644
--- a/compiler/rustc_errors/src/decorate_diag.rs
+++ b/compiler/rustc_errors/src/decorate_diag.rs
@@ -81,4 +81,21 @@ pub fn buffer_lint(
             diagnostic: decorate.into(),
         });
     }
+
+    pub fn dyn_buffer_lint<
+        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
+    >(
+        &mut self,
+        lint: &'static Lint,
+        node_id: NodeId,
+        span: impl Into<MultiSpan>,
+        callback: F,
+    ) {
+        self.add_early_lint(BufferedEarlyLint {
+            lint_id: LintId::of(lint),
+            node_id,
+            span: Some(span.into()),
+            diagnostic: DecorateDiagCompat::Dynamic(Box::new(callback)),
+        });
+    }
 }

From 33fbecc394c54faa8a5fcdd72603ddfe6eb5f1f8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Sun, 22 Mar 2026 18:35:02 +0100
Subject: [PATCH 0782/1059] Remove `BuiltinLintDiag` usage in
 `rustc_ast_passes`

---
 .../rustc_ast_passes/src/ast_validation.rs    | 39 ++++++++---
 compiler/rustc_ast_passes/src/errors.rs       | 69 +++++++++++++++++++
 compiler/rustc_lint/src/early/diagnostics.rs  | 23 -------
 compiler/rustc_lint/src/lints.rs              | 69 -------------------
 compiler/rustc_lint_defs/src/lib.rs           |  8 ---
 5 files changed, 98 insertions(+), 110 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index bdb098131124..dd14e9143569 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -27,10 +27,9 @@
 use rustc_ast_pretty::pprust::{self, State};
 use rustc_attr_parsing::validate_attr;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_errors::{DiagCtxtHandle, LintBuffer};
+use rustc_errors::{DiagCtxtHandle, Diagnostic, LintBuffer};
 use rustc_feature::Features;
 use rustc_session::Session;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     DEPRECATED_WHERE_CLAUSE_LOCATION, MISSING_ABI, MISSING_UNSAFE_ON_EXTERN,
     PATTERNS_IN_FNS_WITHOUT_BODY, UNUSED_VISIBILITIES,
@@ -1424,7 +1423,7 @@ fn visit_item(&mut self, item: &'a Item) {
                         UNUSED_VISIBILITIES,
                         item.id,
                         item.vis.span,
-                        BuiltinLintDiag::UnusedVisibility(item.vis.span),
+                        errors::UnusedVisibility { span: item.vis.span },
                     )
                 }
 
@@ -1731,14 +1730,19 @@ fn visit_fn(&mut self, fk: FnKind<'a>, attrs: &AttrVec, span: Span, id: NodeId)
             Self::check_decl_no_pat(&sig.decl, |span, ident, mut_ident| {
                 if mut_ident && matches!(ctxt, FnCtxt::Assoc(_)) {
                     if let Some(ident) = ident {
-                        self.lint_buffer.buffer_lint(
+                        let is_foreign = matches!(ctxt, FnCtxt::Foreign);
+                        self.lint_buffer.dyn_buffer_lint(
                             PATTERNS_IN_FNS_WITHOUT_BODY,
                             id,
                             span,
-                            BuiltinLintDiag::PatternsInFnsWithoutBody {
-                                span,
-                                ident,
-                                is_foreign: matches!(ctxt, FnCtxt::Foreign),
+                            move |dcx, level| {
+                                let sub = errors::PatternsInFnsWithoutBodySub { ident, span };
+                                if is_foreign {
+                                    errors::PatternsInFnsWithoutBody::Foreign { sub }
+                                } else {
+                                    errors::PatternsInFnsWithoutBody::Bodiless { sub }
+                                }
+                                .into_diag(dcx, level)
                             },
                         )
                     }
@@ -1828,11 +1832,26 @@ fn visit_assoc_item(&mut self, item: &'a AssocItem, ctxt: AssocCtxt) {
                     Some((right, snippet))
                 }
             };
-            self.lint_buffer.buffer_lint(
+            let left_sp = err.span;
+            self.lint_buffer.dyn_buffer_lint(
                 DEPRECATED_WHERE_CLAUSE_LOCATION,
                 item.id,
                 err.span,
-                BuiltinLintDiag::DeprecatedWhereclauseLocation(err.span, sugg),
+                move |dcx, level| {
+                    let suggestion = match sugg {
+                        Some((right_sp, sugg)) => {
+                            errors::DeprecatedWhereClauseLocationSugg::MoveToEnd {
+                                left: left_sp,
+                                right: right_sp,
+                                sugg,
+                            }
+                        }
+                        None => {
+                            errors::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp }
+                        }
+                    };
+                    errors::DeprecatedWhereClauseLocation { suggestion }.into_diag(dcx, level)
+                },
             );
         }
 
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 390c1556f191..b3a22c0c9954 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -1150,3 +1150,72 @@ pub(crate) struct RequiresRustAbi {
     #[label("not using the Rust ABI because of this")]
     pub extern_abi_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("visibility qualifiers have no effect on `const _` declarations")]
+#[note("`const _` does not declare a name, so there is nothing for the qualifier to apply to")]
+pub(crate) struct UnusedVisibility {
+    #[suggestion(
+        "remove the qualifier",
+        style = "short",
+        code = "",
+        applicability = "machine-applicable"
+    )]
+    pub span: Span,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    "remove `mut` from the parameter",
+    code = "{ident}",
+    applicability = "machine-applicable"
+)]
+pub(crate) struct PatternsInFnsWithoutBodySub {
+    #[primary_span]
+    pub span: Span,
+
+    pub ident: Ident,
+}
+
+#[derive(Diagnostic)]
+pub(crate) enum PatternsInFnsWithoutBody {
+    #[diag("patterns aren't allowed in foreign function declarations")]
+    Foreign {
+        #[subdiagnostic]
+        sub: PatternsInFnsWithoutBodySub,
+    },
+    #[diag("patterns aren't allowed in functions without bodies")]
+    Bodiless {
+        #[subdiagnostic]
+        sub: PatternsInFnsWithoutBodySub,
+    },
+}
+
+#[derive(Diagnostic)]
+#[diag("where clause not allowed here")]
+#[note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information")]
+pub(crate) struct DeprecatedWhereClauseLocation {
+    #[subdiagnostic]
+    pub suggestion: DeprecatedWhereClauseLocationSugg,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum DeprecatedWhereClauseLocationSugg {
+    #[multipart_suggestion(
+        "move it to the end of the type declaration",
+        applicability = "machine-applicable"
+    )]
+    MoveToEnd {
+        #[suggestion_part(code = "")]
+        left: Span,
+        #[suggestion_part(code = "{sugg}")]
+        right: Span,
+
+        sugg: String,
+    },
+    #[suggestion("remove this `where`", code = "", applicability = "machine-applicable")]
+    RemoveWhere {
+        #[primary_span]
+        span: Span,
+    },
+}
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index d5cd26dd75e3..c61bb7307f60 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -116,26 +116,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
                     .into_diag(dcx, level)
             }
-            BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
-                let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };
-                if is_foreign {
-                    lints::PatternsInFnsWithoutBody::Foreign { sub }
-                } else {
-                    lints::PatternsInFnsWithoutBody::Bodiless { sub }
-                }
-                .into_diag(dcx, level)
-            }
-            BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
-                let suggestion = match sugg {
-                    Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
-                        left: left_sp,
-                        right: right_sp,
-                        sugg,
-                    },
-                    None => lints::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp },
-                };
-                lints::DeprecatedWhereClauseLocation { suggestion }.into_diag(dcx, level)
-            }
             BuiltinLintDiag::SingleUseLifetime {
                 param_span,
                 use_span: Some((use_span, elide)),
@@ -257,9 +237,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
                 lints::UnusedCrateDependency { extern_crate, local_crate }.into_diag(dcx, level)
             }
-            BuiltinLintDiag::UnusedVisibility(span) => {
-                lints::UnusedVisibility { span }.into_diag(dcx, level)
-            }
             BuiltinLintDiag::AttributeLint(kind) => {
                 DecorateAttrLint { sess: self.sess, tcx: self.tcx, diagnostic: &kind }
                     .into_diag(dcx, level)
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index d5b5a50d281a..c66654afc9d1 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3125,62 +3125,6 @@ pub(crate) enum RedundantImportSub {
     },
 }
 
-#[derive(Diagnostic)]
-pub(crate) enum PatternsInFnsWithoutBody {
-    #[diag("patterns aren't allowed in foreign function declarations")]
-    Foreign {
-        #[subdiagnostic]
-        sub: PatternsInFnsWithoutBodySub,
-    },
-    #[diag("patterns aren't allowed in functions without bodies")]
-    Bodiless {
-        #[subdiagnostic]
-        sub: PatternsInFnsWithoutBodySub,
-    },
-}
-
-#[derive(Subdiagnostic)]
-#[suggestion(
-    "remove `mut` from the parameter",
-    code = "{ident}",
-    applicability = "machine-applicable"
-)]
-pub(crate) struct PatternsInFnsWithoutBodySub {
-    #[primary_span]
-    pub span: Span,
-
-    pub ident: Ident,
-}
-
-#[derive(Diagnostic)]
-#[diag("where clause not allowed here")]
-#[note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information")]
-pub(crate) struct DeprecatedWhereClauseLocation {
-    #[subdiagnostic]
-    pub suggestion: DeprecatedWhereClauseLocationSugg,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum DeprecatedWhereClauseLocationSugg {
-    #[multipart_suggestion(
-        "move it to the end of the type declaration",
-        applicability = "machine-applicable"
-    )]
-    MoveToEnd {
-        #[suggestion_part(code = "")]
-        left: Span,
-        #[suggestion_part(code = "{sugg}")]
-        right: Span,
-
-        sugg: String,
-    },
-    #[suggestion("remove this `where`", code = "", applicability = "machine-applicable")]
-    RemoveWhere {
-        #[primary_span]
-        span: Span,
-    },
-}
-
 #[derive(Diagnostic)]
 #[diag("lifetime parameter `{$ident}` only used once")]
 pub(crate) struct SingleUseLifetime {
@@ -3644,19 +3588,6 @@ pub(crate) struct UnsafeAttrOutsideUnsafeSuggestion {
     pub right: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("visibility qualifiers have no effect on `const _` declarations")]
-#[note("`const _` does not declare a name, so there is nothing for the qualifier to apply to")]
-pub(crate) struct UnusedVisibility {
-    #[suggestion(
-        "remove the qualifier",
-        style = "short",
-        code = "",
-        applicability = "machine-applicable"
-    )]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("doc alias is duplicated")]
 pub(crate) struct DocAliasDuplicated {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index e2e4ffc64bea..f3317017daab 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -673,13 +673,6 @@ pub enum BuiltinLintDiag {
         path: String,
         since_kind: DeprecatedSinceKind,
     },
-    PatternsInFnsWithoutBody {
-        span: Span,
-        ident: Ident,
-        is_foreign: bool,
-    },
-    /// `##` or `#"` in edition < 2024.
-    DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
     SingleUseLifetime {
         /// Span of the parameter which declares this lifetime.
         param_span: Span,
@@ -737,7 +730,6 @@ pub enum BuiltinLintDiag {
         extern_crate: Symbol,
         local_crate: Symbol,
     },
-    UnusedVisibility(Span),
     AttributeLint(AttributeLintKind),
     UnreachableCfg {
         span: Span,

From 35f9cb6eeec95cd94c57c4b0403c227d8673835d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Thu, 19 Mar 2026 14:38:09 +0100
Subject: [PATCH 0783/1059] add neon load/store assembly test

---
 .../src/directives/directive_names.rs         |  1 +
 tests/assembly-llvm/aarch64-arm-load-store.rs | 78 +++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 tests/assembly-llvm/aarch64-arm-load-store.rs

diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 9af881b5c2f5..77c826fa0b9c 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -213,6 +213,7 @@
     "only-apple",
     "only-arm",
     "only-arm64ec",
+    "only-armv7-unknown-linux-gnueabihf",
     "only-avr",
     "only-beta",
     "only-bpf",
diff --git a/tests/assembly-llvm/aarch64-arm-load-store.rs b/tests/assembly-llvm/aarch64-arm-load-store.rs
new file mode 100644
index 000000000000..8296194100d9
--- /dev/null
+++ b/tests/assembly-llvm/aarch64-arm-load-store.rs
@@ -0,0 +1,78 @@
+//@ assembly-output: emit-asm
+//
+//@ revisions: AARCH64
+//@[AARCH64] compile-flags: -Copt-level=3
+//@[AARCH64] only-aarch64-unknown-linux-gnu
+//
+//@ revisions: ARMV7
+//@[ARMV7] compile-flags: -Copt-level=3
+//@[ARMV7] only-armv7-unknown-linux-gnueabihf
+//@[ARMV7] ignore-thumb
+//@[ARMV7] ignore-android
+#![crate_type = "lib"]
+#![cfg_attr(target_arch = "arm", feature(arm_target_feature, stdarch_arm_neon_intrinsics))]
+
+#[cfg(target_arch = "aarch64")]
+use std::arch::aarch64::*;
+#[cfg(target_arch = "arm")]
+use std::arch::arm::*;
+
+// Loads of 3 are error-prone because a `repr(simd)` type's size is always rounded up to the next
+// power of 2. Hence, using `read_unaligned` and `write_unaligned` on such types is invalid, it
+// would go out of bounds.
+#[unsafe(no_mangle)]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon,v7"))]
+fn test_vld3q_f32(ptr: *const f32) -> float32x4x3_t {
+    // AARCH64-LABEL: test_vld3q_f32
+    // AARCH64: ld3 { v0.4s, v1.4s, v2.4s }, [x0]
+    // AARCH64: stp q0, q1, [x8]
+    // AARCH64: str q2, [x8, #32]
+    // AARCH64: ret
+    //
+    // ARMV7-LABEL: test_vld3q_f32
+    // ARMV7: vld3.32 {d16, d18, d20}, [r1]!
+    // ARMV7: vld3.32 {d17, d19, d21}, [r1]
+    // ARMV7: vst1.32 {d16, d17}, [r0]!
+    // ARMV7: vst1.32 {d18, d19}, [r0]!
+    // ARMV7: vst1.64 {d20, d21}, [r0]
+    // ARMV7: bx lr
+    unsafe { vld3q_f32(ptr) }
+}
+
+#[unsafe(no_mangle)]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon,v7"))]
+fn test_vld3q_s32(ptr: *const i32) -> int32x4x3_t {
+    // AARCH64-LABEL: test_vld3q_s32
+    // AARCH64: ld3 { v0.4s, v1.4s, v2.4s }, [x0]
+    // AARCH64: stp q0, q1, [x8]
+    // AARCH64: str q2, [x8, #32]
+    // AARCH64: ret
+    //
+    // ARMV7-LABEL: test_vld3q_s32
+    // ARMV7: vld3.32 {d16, d18, d20}, [r1]!
+    // ARMV7: vld3.32 {d17, d19, d21}, [r1]
+    // ARMV7: vst1.32 {d16, d17}, [r0]!
+    // ARMV7: vst1.32 {d18, d19}, [r0]!
+    // ARMV7: vst1.64 {d20, d21}, [r0]
+    // ARMV7: bx lr
+    unsafe { vld3q_s32(ptr) }
+}
+
+#[unsafe(no_mangle)]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon,v7"))]
+fn test_vld3q_u32(ptr: *const u32) -> uint32x4x3_t {
+    // AARCH64-LABEL: test_vld3q_u32
+    // AARCH64: ld3 { v0.4s, v1.4s, v2.4s }, [x0]
+    // AARCH64: stp q0, q1, [x8]
+    // AARCH64: str q2, [x8, #32]
+    // AARCH64: ret
+    //
+    // ARMV7-LABEL: test_vld3q_u32
+    // ARMV7: vld3.32 {d16, d18, d20}, [r1]!
+    // ARMV7: vld3.32 {d17, d19, d21}, [r1]
+    // ARMV7: vst1.32 {d16, d17}, [r0]!
+    // ARMV7: vst1.32 {d18, d19}, [r0]!
+    // ARMV7: vst1.64 {d20, d21}, [r0]
+    // ARMV7: bx lr
+    unsafe { vld3q_u32(ptr) }
+}

From a677f461cb9c37025d5860efa4c483ec5a5f87b9 Mon Sep 17 00:00:00 2001
From: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Date: Sun, 22 Mar 2026 12:11:35 -0700
Subject: [PATCH 0784/1059] `vec::as_mut_slice()`: use lowercase "isize" in
 safety comment

To match other references to that type
---
 library/alloc/src/vec/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 7796f3b8b2fb..a2fe730c1acc 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1853,7 +1853,7 @@ pub const fn as_mut_slice(&mut self) -> &mut [T] {
         // SAFETY: `slice::from_raw_parts_mut` requires pointee is a contiguous, aligned buffer of
         // size `len` containing properly-initialized `T`s. Data must not be accessed through any
         // other pointer for the returned lifetime. Further, `len * size_of::<T>` <=
-        // `ISIZE::MAX` and allocation does not "wrap" through overflowing memory addresses.
+        // `isize::MAX` and allocation does not "wrap" through overflowing memory addresses.
         //
         // * Vec API guarantees that self.buf:
         //      * contains only properly-initialized items within 0..len

From 8befc9d082de5184353b04d7ca5ca2d31078538b Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Sat, 21 Mar 2026 17:15:29 -0600
Subject: [PATCH 0785/1059] refactor RangeFromIter overflow-checks impl

Crates with different overflow-checks settings accessing the same RangeFromIter resulted in incorrect values being yielded
---
 library/core/src/range/iter.rs                | 69 ++++++++++++-------
 .../fromrangeiter-overflow-checks.rs          | 31 +++++----
 .../rangefrom-overflow-2crates-ocno.rs        | 10 +++
 .../rangefrom-overflow-2crates-ocyes.rs       | 10 +++
 .../iterators/rangefrom-overflow-2crates.rs   | 40 +++++++++++
 5 files changed, 124 insertions(+), 36 deletions(-)
 create mode 100644 tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
 create mode 100644 tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
 create mode 100644 tests/ui/iterators/rangefrom-overflow-2crates.rs

diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs
index c1d4fbbd23ad..23ace6e1ba25 100644
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -298,9 +298,9 @@ impl ExactSizeIterator for RangeInclusiveIter<$t> { }
 #[derive(Debug, Clone)]
 pub struct RangeFromIter<A> {
     start: A,
-    /// Whether the first element of the iterator has yielded.
+    /// Whether the maximum value of the iterator has yielded.
     /// Only used when overflow checks are enabled.
-    first: bool,
+    exhausted: bool,
 }
 
 impl<A: Step> RangeFromIter<A> {
@@ -309,10 +309,12 @@ impl<A: Step> RangeFromIter<A> {
     #[rustc_inherit_overflow_checks]
     #[unstable(feature = "new_range_api", issue = "125687")]
     pub fn remainder(self) -> RangeFrom<A> {
-        if intrinsics::overflow_checks() {
-            if !self.first {
-                return RangeFrom { start: Step::forward(self.start, 1) };
-            }
+        // Need to handle this case even if overflow-checks are disabled,
+        // because a `RangeFromIter` could be exhausted in a crate with
+        // overflow-checks enabled, but then passed to a crate with them
+        // disabled before this is called.
+        if self.exhausted {
+            return RangeFrom { start: Step::forward(self.start, 1) };
         }
 
         RangeFrom { start: self.start }
@@ -326,14 +328,29 @@ impl<A: Step> Iterator for RangeFromIter<A> {
     #[inline]
     #[rustc_inherit_overflow_checks]
     fn next(&mut self) -> Option<A> {
-        if intrinsics::overflow_checks() {
-            if self.first {
-                self.first = false;
-                return Some(self.start.clone());
-            }
-
+        if self.exhausted {
+            // This should panic if overflow checks are enabled, since
+            // `forward_checked` returned `None` in prior iteration.
             self.start = Step::forward(self.start.clone(), 1);
-            return Some(self.start.clone());
+
+            // If we get here, if means this iterator was exhausted by a crate
+            // with overflow-checks enabled, but now we're iterating in a crate with
+            // overflow-checks disabled. Since we successfully incremented `self.start`
+            // above (in many cases this will wrap around to MIN), we now unset
+            // the flag so we don't repeat this process in the next iteration.
+            //
+            // This could also happen if `forward_checked` returned None but
+            // (for whatever reason, not applicable to any std implementors)
+            // `forward` doesn't panic when overflow-checks are enabled. In that
+            // case, this is also the correct behavior.
+            self.exhausted = false;
+        }
+        if intrinsics::overflow_checks() {
+            let Some(n) = Step::forward_checked(self.start.clone(), 1) else {
+                self.exhausted = true;
+                return Some(self.start.clone());
+            };
+            return Some(mem::replace(&mut self.start, n));
         }
 
         let n = Step::forward(self.start.clone(), 1);
@@ -348,18 +365,22 @@ fn size_hint(&self) -> (usize, Option<usize>) {
     #[inline]
     #[rustc_inherit_overflow_checks]
     fn nth(&mut self, n: usize) -> Option<A> {
+        // Typically `forward` will cause an overflow-check panic here,
+        // but unset the exhausted flag to handle the uncommon cases.
+        // See the comments in `next` for more details.
+        if self.exhausted {
+            self.start = Step::forward(self.start.clone(), 1);
+            self.exhausted = false;
+        }
         if intrinsics::overflow_checks() {
-            if self.first {
-                self.first = false;
-
-                let plus_n = Step::forward(self.start.clone(), n);
-                self.start = plus_n.clone();
-                return Some(plus_n);
-            }
-
             let plus_n = Step::forward(self.start.clone(), n);
-            self.start = Step::forward(plus_n.clone(), 1);
-            return Some(self.start.clone());
+            if let Some(plus_n1) = Step::forward_checked(plus_n.clone(), 1) {
+                self.start = plus_n1;
+            } else {
+                self.start = plus_n.clone();
+                self.exhausted = true;
+            }
+            return Some(plus_n);
         }
 
         let plus_n = Step::forward(self.start.clone(), n);
@@ -380,6 +401,6 @@ impl<A: Step> IntoIterator for RangeFrom<A> {
     type IntoIter = RangeFromIter<A>;
 
     fn into_iter(self) -> Self::IntoIter {
-        RangeFromIter { start: self.start, first: true }
+        RangeFromIter { start: self.start, exhausted: false }
     }
 }
diff --git a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
index 4d27f118ddd3..455c81c63340 100644
--- a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
+++ b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
@@ -2,7 +2,7 @@
 // runtime check that panics after yielding the maximum value of the range bound type. That is
 // tested for by tests/ui/iterators/rangefrom-overflow-overflow-checks.rs
 //
-// This test ensures that such a runtime check is *not* emitted when debug-assertions are
+// This test ensures such runtime checks are optimized out when debug-assertions are
 // enabled, but overflow-checks are explicitly disabled.
 
 //@ revisions: DEBUG NOCHECKS
@@ -11,17 +11,24 @@
 
 #![crate_type = "lib"]
 #![feature(new_range_api)]
-use std::range::{RangeFrom, RangeFromIter};
+use std::range::RangeFrom;
 
-// CHECK-LABEL: @iterrangefrom_remainder(
+// CHECK-LABEL: @rangefrom_increments(
 #[no_mangle]
-pub unsafe fn iterrangefrom_remainder(x: RangeFromIter<i32>) -> RangeFrom<i32> {
-    //        DEBUG: i32 noundef %x
-    //     NOCHECKS: i32 noundef returned %x
-    //        DEBUG: br i1
-    //        DEBUG: call core::panicking::panic_const::panic_const_add_overflow
-    //        DEBUG: unreachable
-    // NOCHECKS-NOT: unreachable
-    //     NOCHECKS: ret i32 %x
-    x.remainder()
+pub unsafe fn rangefrom_increments(range: RangeFrom<i32>) -> RangeFrom<i32> {
+    // Iterator is contained entirely within this function, so the optimizer should
+    // be able to see that `exhausted` is never set and optimize out any branches.
+
+    //         CHECK: i32 noundef %range
+    //         DEBUG: switch i32 %range
+    //         DEBUG: call core::panicking::panic_const::panic_const_add_overflow
+    //         DEBUG: unreachable
+    //  NOCHECKS-NOT: unreachable
+    //      NOCHECKS: [[REM:%[a-z_0-9.]+]] = add i32 %range, 2
+    // NOCHECKS-NEXT: ret i32 [[REM]]
+
+    let mut iter = range.into_iter();
+    let _ = iter.next();
+    let _ = iter.next();
+    iter.remainder()
 }
diff --git a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
new file mode 100644
index 000000000000..ebba4ae92c47
--- /dev/null
+++ b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C overflow-checks=no
+
+#![crate_type = "lib"]
+#![feature(new_range_api)]
+
+use std::range::RangeFromIter;
+
+pub fn next(iter: &mut RangeFromIter<u8>) -> u8 {
+    iter.next().unwrap()
+}
diff --git a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
new file mode 100644
index 000000000000..8eb5392c7bac
--- /dev/null
+++ b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C overflow-checks=yes
+
+#![crate_type = "lib"]
+#![feature(new_range_api)]
+
+use std::range::RangeFromIter;
+
+pub fn next(iter: &mut RangeFromIter<u8>) -> u8 {
+    iter.next().unwrap()
+}
diff --git a/tests/ui/iterators/rangefrom-overflow-2crates.rs b/tests/ui/iterators/rangefrom-overflow-2crates.rs
new file mode 100644
index 000000000000..c35c96f99322
--- /dev/null
+++ b/tests/ui/iterators/rangefrom-overflow-2crates.rs
@@ -0,0 +1,40 @@
+//@ run-pass
+//@ needs-unwind
+//@ aux-build:rangefrom-overflow-2crates-ocno.rs
+//@ aux-build:rangefrom-overflow-2crates-ocyes.rs
+
+// For #154124
+// Test that two crates with different overflow-checks have the same results,
+// even when the iterator is passed between them.
+
+#![feature(new_range_api)]
+
+extern crate rangefrom_overflow_2crates_ocno;
+extern crate rangefrom_overflow_2crates_ocyes;
+
+use rangefrom_overflow_2crates_ocno::next as next_ocno;
+use rangefrom_overflow_2crates_ocyes::next as next_ocyes;
+
+fn main() {
+    let mut iter_ocyes = std::range::RangeFrom::from(0_u8..).into_iter();
+    let mut iter_ocno = iter_ocyes.clone();
+
+    for n in 0_u8..=255 {
+        assert_eq!(n, next_ocno(&mut iter_ocyes.clone()));
+        assert_eq!(n, next_ocyes(&mut iter_ocyes));
+        assert_eq!(n, next_ocyes(&mut iter_ocno.clone()));
+        assert_eq!(n, next_ocno(&mut iter_ocno));
+    }
+
+    // `iter_ocno` should have wrapped
+    assert_eq!(0, next_ocyes(&mut iter_ocno.clone()));
+    assert_eq!(0, next_ocno(&mut iter_ocno));
+    // `iter_ocyes` should be exhausted,
+    // which will wrap when called without overflow-checks
+    assert_eq!(0, next_ocno(&mut iter_ocyes.clone()));
+    // and panic when called with overflow-checks
+    let r = std::panic::catch_unwind(move || {
+        let _ = next_ocyes(&mut iter_ocyes);
+    });
+    assert!(r.is_err());
+}

From 2fcd8a71f70a64efaf071fbf4f3932899fdb7920 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Sun, 22 Mar 2026 20:32:22 +0100
Subject: [PATCH 0786/1059] Remove more `BuiltinLintDiag` in `rustc_resolve`

---
 compiler/rustc_lint/src/early/diagnostics.rs   |  8 +++-----
 compiler/rustc_lint/src/lints.rs               |  9 ---------
 compiler/rustc_lint_defs/src/lib.rs            |  3 ++-
 compiler/rustc_resolve/src/errors.rs           |  9 +++++++++
 compiler/rustc_resolve/src/late/diagnostics.rs | 10 +++-------
 5 files changed, 17 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index c61bb7307f60..43bb3971d7ac 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -118,13 +118,14 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             }
             BuiltinLintDiag::SingleUseLifetime {
                 param_span,
-                use_span: Some((use_span, elide)),
+                use_span,
+                elidable,
                 deletion_span,
                 ident,
             } => {
                 debug!(?param_span, ?use_span, ?deletion_span);
                 let suggestion = if let Some(deletion_span) = deletion_span {
-                    let (use_span, replace_lt) = if elide {
+                    let (use_span, replace_lt) = if elidable {
                         let use_span =
                             self.sess.source_map().span_extend_while_whitespace(use_span);
                         (use_span, String::new())
@@ -145,9 +146,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 lints::SingleUseLifetime { suggestion, param_span, use_span, ident }
                     .into_diag(dcx, level)
             }
-            BuiltinLintDiag::SingleUseLifetime { use_span: None, deletion_span, ident, .. } => {
-                lints::UnusedLifetime { deletion_span, ident }.into_diag(dcx, level)
-            }
             BuiltinLintDiag::NamedArgumentUsedPositionally {
                 position_sp_to_replace,
                 position_sp_for_msg,
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index c66654afc9d1..c7c92356c378 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3149,15 +3149,6 @@ pub(crate) struct SingleUseLifetimeSugg {
     pub replace_lt: String,
 }
 
-#[derive(Diagnostic)]
-#[diag("lifetime parameter `{$ident}` never used")]
-pub(crate) struct UnusedLifetime {
-    #[suggestion("elide the unused lifetime", code = "", applicability = "machine-applicable")]
-    pub deletion_span: Option<Span>,
-
-    pub ident: Ident,
-}
-
 #[derive(Diagnostic)]
 #[diag("named argument `{$named_arg_name}` is not used by name")]
 pub(crate) struct NamedArgumentUsedPositionally {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index f3317017daab..0faa50442961 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -681,7 +681,8 @@ pub enum BuiltinLintDiag {
         deletion_span: Option<Span>,
         /// Span of the single use, or None if the lifetime is never used.
         /// If true, the lifetime will be fully elided.
-        use_span: Option<(Span, bool)>,
+        use_span: Span,
+        elidable: bool,
         ident: Ident,
     },
     NamedArgumentUsedPositionally {
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 24c923de6794..25c7c625ff93 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1583,3 +1583,12 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         diag
     }
 }
+
+#[derive(Diagnostic)]
+#[diag("lifetime parameter `{$ident}` never used")]
+pub(crate) struct UnusedLifetime {
+    #[suggestion("elide the unused lifetime", code = "", applicability = "machine-applicable")]
+    pub deletion_span: Option<Span>,
+
+    pub ident: Ident,
+}
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index a8ca4faf5ab0..3bc40604ac04 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -3653,7 +3653,8 @@ pub(crate) fn maybe_report_lifetime_uses(
                         param.ident.span,
                         lint::BuiltinLintDiag::SingleUseLifetime {
                             param_span: param.ident.span,
-                            use_span: Some((use_span, elidable)),
+                            use_span,
+                            elidable,
                             deletion_span,
                             ident: param.ident,
                         },
@@ -3669,12 +3670,7 @@ pub(crate) fn maybe_report_lifetime_uses(
                             lint::builtin::UNUSED_LIFETIMES,
                             param.id,
                             param.ident.span,
-                            lint::BuiltinLintDiag::SingleUseLifetime {
-                                param_span: param.ident.span,
-                                use_span: None,
-                                deletion_span,
-                                ident: param.ident,
-                            },
+                            errors::UnusedLifetime { deletion_span, ident: param.ident },
                         );
                     }
                 }

From 7cd70e3f97195472dac162bfe0f948255e91092c Mon Sep 17 00:00:00 2001
From: kartikohlan <kartik7ohlan@gmail.com>
Date: Sun, 22 Mar 2026 15:54:45 -0400
Subject: [PATCH 0787/1059] updated the llvm 21 and 22 links

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index 617a7a940f10..0b6bb0d0f206 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -1,6 +1,5 @@
 # Updating LLVM
 
-<!-- date-check: March 2026 -->
 Rust supports building against multiple LLVM versions:
 
 * Tip-of-tree for the current LLVM development branch is usually supported within a few days.
@@ -91,7 +90,6 @@ An example PR: [#59089](https://github.com/rust-lang/rust/pull/59089)
 
 ## New LLVM Release Updates
 
-<!-- date-check: March 2026 -->
 
 Unlike bugfixes,
 updating to a new release of LLVM typically requires a lot more work.
@@ -178,6 +176,8 @@ so let's go through each in detail.
    > - [LLVM 18](https://github.com/rust-lang/rust/pull/120055)
    > - [LLVM 19](https://github.com/rust-lang/rust/pull/127513)
    > - [LLVM 20](https://github.com/rust-lang/rust/pull/135763)
+   > - [LLVM 21](https://github.com/rust-lang/rust/pull/143684)
+   > - [LLVM 22](https://github.com/rust-lang/rust/pull/150722)
 
    Note that sometimes it's easiest to land [`llvm-wrapper`] compatibility as a PR
    before actually updating `src/llvm-project`.

From fa3e85a7e8dbe96f32b69cd978c3e345c76d2fa0 Mon Sep 17 00:00:00 2001
From: Usman Akinyemi <usmanakinyemi202@gmail.com>
Date: Mon, 23 Mar 2026 01:24:23 +0530
Subject: [PATCH 0788/1059] diagnostics: avoid ICE in confusable_method_name
 for associated functions

Avoid unconditionally slicing `inputs()[1..]`, which assumes a `self`
parameter. Use `is_method()` to conditionally skip the receiver,
preventing out-of-bounds access and fixing suggestions for associated
functions.

Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>
---
 .../rustc_hir_typeck/src/method/suggest.rs    |  5 ++-
 .../attributes/rustc_confusables_assoc_fn.rs  | 22 +++++++++++++
 .../rustc_confusables_assoc_fn.stderr         | 33 +++++++++++++++++++
 3 files changed, 59 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/attributes/rustc_confusables_assoc_fn.rs
 create mode 100644 tests/ui/attributes/rustc_confusables_assoc_fn.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 9d496c66f968..c86cfe00abbc 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -2291,8 +2291,11 @@ pub(crate) fn confusable_method_name(
                             fn_sig,
                         );
                         let name = inherent_method.name();
+                        let inputs = fn_sig.inputs();
+                        let expected_inputs =
+                            if inherent_method.is_method() { &inputs[1..] } else { inputs };
                         if let Some(ref args) = call_args
-                            && fn_sig.inputs()[1..]
+                            && expected_inputs
                                 .iter()
                                 .eq_by(args, |expected, found| self.may_coerce(*expected, *found))
                         {
diff --git a/tests/ui/attributes/rustc_confusables_assoc_fn.rs b/tests/ui/attributes/rustc_confusables_assoc_fn.rs
new file mode 100644
index 000000000000..5612ece0a8d9
--- /dev/null
+++ b/tests/ui/attributes/rustc_confusables_assoc_fn.rs
@@ -0,0 +1,22 @@
+#![feature(rustc_attrs)]
+
+struct S;
+
+impl S {
+    #[rustc_confusables("bar")]
+    fn foo() {}
+
+    #[rustc_confusables("baz")]
+    fn qux(&self, x: i32) {}
+}
+
+fn main() {
+    S::bar();
+    //~^ ERROR no function or associated item named `bar`
+    //~| HELP you might have meant to use `foo`
+
+    let s = S;
+    s.baz(10);
+    //~^ ERROR no method named `baz`
+    //~| HELP you might have meant to use `qux`
+}
diff --git a/tests/ui/attributes/rustc_confusables_assoc_fn.stderr b/tests/ui/attributes/rustc_confusables_assoc_fn.stderr
new file mode 100644
index 000000000000..657ca8098b80
--- /dev/null
+++ b/tests/ui/attributes/rustc_confusables_assoc_fn.stderr
@@ -0,0 +1,33 @@
+error[E0599]: no function or associated item named `bar` found for struct `S` in the current scope
+  --> $DIR/rustc_confusables_assoc_fn.rs:14:8
+   |
+LL | struct S;
+   | -------- function or associated item `bar` not found for this struct
+...
+LL |     S::bar();
+   |        ^^^ function or associated item not found in `S`
+   |
+help: you might have meant to use `foo`
+   |
+LL -     S::bar();
+LL +     S::foo();
+   |
+
+error[E0599]: no method named `baz` found for struct `S` in the current scope
+  --> $DIR/rustc_confusables_assoc_fn.rs:19:7
+   |
+LL | struct S;
+   | -------- method `baz` not found for this struct
+...
+LL |     s.baz(10);
+   |       ^^^ method not found in `S`
+   |
+help: you might have meant to use `qux`
+   |
+LL -     s.baz(10);
+LL +     s.qux(10);
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0599`.

From cde59f09044e35ddc62ace83b91319490118b43f Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 23 Mar 2026 09:10:59 +1100
Subject: [PATCH 0789/1059] Remove another assertion in
 `load_from_disk_or_invoke_provider_green`.

This one just irritates me, and I don't think it adds much value.
---
 compiler/rustc_query_impl/src/execution.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 2dae7c129a08..39dba1f199c1 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -520,14 +520,6 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
         return value;
     }
 
-    // We always expect to find a cached result for things that
-    // can be forced from `DepNode`.
-    debug_assert!(
-        !(query.will_cache_on_disk_for_key_fn)(tcx, key)
-            || !tcx.key_fingerprint_style(dep_node.kind).is_maybe_recoverable(),
-        "missing on-disk cache entry for {dep_node:?}"
-    );
-
     // We could not load a result from the on-disk cache, so
     // recompute.
     let prof_timer = tcx.prof.query_provider();

From 6f084377888d0c22a791c65d363a9b34cc12280e Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 22 Mar 2026 22:12:20 +0100
Subject: [PATCH 0790/1059] improve inline assembly error messages

by

- using `DiagSymbolList` to get nicely formatted lists
- mentioning the `modifier` when an invalid modifier is used. This is useful in case the span cannot be resolved (which I ran into).
---
 compiler/rustc_ast_lowering/src/asm.rs        | 33 ++++-------
 compiler/rustc_ast_lowering/src/errors.rs     | 13 +++--
 tests/ui/asm/aarch64/bad-options.stderr       |  2 +-
 tests/ui/asm/aarch64/bad-reg.rs               | 13 +++--
 tests/ui/asm/aarch64/bad-reg.stderr           | 58 +++++++++----------
 tests/ui/asm/x86_64/bad-clobber-abi.stderr    |  8 +--
 tests/ui/asm/x86_64/bad-options.stderr        |  2 +-
 .../x86_64/bad-reg.experimental_reg.stderr    | 10 ++--
 tests/ui/asm/x86_64/bad-reg.rs                |  4 +-
 tests/ui/asm/x86_64/bad-reg.stable.stderr     | 10 ++--
 tests/ui/asm/x86_64/issue-82869.stderr        |  4 +-
 11 files changed, 76 insertions(+), 81 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 51994c2e92f9..3a27962feca3 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -1,5 +1,4 @@
 use std::collections::hash_map::Entry;
-use std::fmt::Write;
 
 use rustc_ast::*;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
@@ -124,13 +123,9 @@ pub(crate) fn lower_inline_asm(
                         self.dcx().emit_err(ClobberAbiNotSupported { abi_span: *abi_span });
                     }
                     Err(supported_abis) => {
-                        let mut abis = format!("`{}`", supported_abis[0]);
-                        for m in &supported_abis[1..] {
-                            let _ = write!(abis, ", `{m}`");
-                        }
                         self.dcx().emit_err(InvalidAbiClobberAbi {
                             abi_span: *abi_span,
-                            supported_abis: abis,
+                            supported_abis: supported_abis.to_vec().into(),
                         });
                     }
                 }
@@ -164,15 +159,12 @@ pub(crate) fn lower_inline_asm(
                         asm::InlineAsmRegOrRegClass::RegClass(if let Some(asm_arch) = asm_arch {
                             asm::InlineAsmRegClass::parse(asm_arch, reg_class).unwrap_or_else(
                                 |supported_register_classes| {
-                                    let mut register_classes =
-                                        format!("`{}`", supported_register_classes[0]);
-                                    for m in &supported_register_classes[1..] {
-                                        let _ = write!(register_classes, ", `{m}`");
-                                    }
                                     self.dcx().emit_err(InvalidRegisterClass {
                                         op_span: *op_sp,
                                         reg_class,
-                                        supported_register_classes: register_classes,
+                                        supported_register_classes: supported_register_classes
+                                            .to_vec()
+                                            .into(),
                                     });
                                     asm::InlineAsmRegClass::Err
                                 },
@@ -272,23 +264,20 @@ pub(crate) fn lower_inline_asm(
                         }
                         let valid_modifiers = class.valid_modifiers(asm_arch.unwrap());
                         if !valid_modifiers.contains(&modifier) {
-                            let sub = if !valid_modifiers.is_empty() {
-                                let mut mods = format!("`{}`", valid_modifiers[0]);
-                                for m in &valid_modifiers[1..] {
-                                    let _ = write!(mods, ", `{m}`");
-                                }
-                                InvalidAsmTemplateModifierRegClassSub::SupportModifier {
-                                    class_name: class.name(),
-                                    modifiers: mods,
-                                }
-                            } else {
+                            let sub = if valid_modifiers.is_empty() {
                                 InvalidAsmTemplateModifierRegClassSub::DoesNotSupportModifier {
                                     class_name: class.name(),
                                 }
+                            } else {
+                                InvalidAsmTemplateModifierRegClassSub::SupportModifier {
+                                    class_name: class.name(),
+                                    modifiers: valid_modifiers.to_vec().into(),
+                                }
                             };
                             self.dcx().emit_err(InvalidAsmTemplateModifierRegClass {
                                 placeholder_span,
                                 op_span: op_sp,
+                                modifier: modifier.to_string(),
                                 sub,
                             });
                         }
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index 1eb72727df66..95b8bb48c6a9 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -1,5 +1,5 @@
-use rustc_errors::DiagArgFromDisplay;
 use rustc_errors::codes::*;
+use rustc_errors::{DiagArgFromDisplay, DiagSymbolList};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
@@ -191,10 +191,10 @@ pub(crate) struct ClobberAbiNotSupported {
 #[derive(Diagnostic)]
 #[note("the following ABIs are supported on this target: {$supported_abis}")]
 #[diag("invalid ABI for `clobber_abi`")]
-pub(crate) struct InvalidAbiClobberAbi {
+pub(crate) struct InvalidAbiClobberAbi<'a> {
     #[primary_span]
     pub abi_span: Span,
-    pub supported_abis: String,
+    pub supported_abis: DiagSymbolList<&'a str>,
 }
 
 #[derive(Diagnostic)]
@@ -215,17 +215,18 @@ pub(crate) struct InvalidRegisterClass {
     #[primary_span]
     pub op_span: Span,
     pub reg_class: Symbol,
-    pub supported_register_classes: String,
+    pub supported_register_classes: DiagSymbolList<Symbol>,
 }
 
 #[derive(Diagnostic)]
-#[diag("invalid asm template modifier for this register class")]
+#[diag("invalid asm template modifier `{$modifier}` for this register class")]
 pub(crate) struct InvalidAsmTemplateModifierRegClass {
     #[primary_span]
     #[label("template modifier")]
     pub placeholder_span: Span,
     #[label("argument")]
     pub op_span: Span,
+    pub modifier: String,
     #[subdiagnostic]
     pub sub: InvalidAsmTemplateModifierRegClassSub,
 }
@@ -235,7 +236,7 @@ pub(crate) enum InvalidAsmTemplateModifierRegClassSub {
     #[note(
         "the `{$class_name}` register class supports the following template modifiers: {$modifiers}"
     )]
-    SupportModifier { class_name: Symbol, modifiers: String },
+    SupportModifier { class_name: Symbol, modifiers: DiagSymbolList<char> },
     #[note("the `{$class_name}` register class does not support template modifiers")]
     DoesNotSupportModifier { class_name: Symbol },
 }
diff --git a/tests/ui/asm/aarch64/bad-options.stderr b/tests/ui/asm/aarch64/bad-options.stderr
index 54ab7cafa49f..f7252d0ad374 100644
--- a/tests/ui/asm/aarch64/bad-options.stderr
+++ b/tests/ui/asm/aarch64/bad-options.stderr
@@ -78,7 +78,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`
+   = note: the following ABIs are supported on this target: `C`, `system`, and `efiapi`
 
 error: aborting due to 13 previous errors
 
diff --git a/tests/ui/asm/aarch64/bad-reg.rs b/tests/ui/asm/aarch64/bad-reg.rs
index b99e5fe4b9e3..676d736e15d7 100644
--- a/tests/ui/asm/aarch64/bad-reg.rs
+++ b/tests/ui/asm/aarch64/bad-reg.rs
@@ -1,7 +1,12 @@
+//@ add-minicore
 //@ only-aarch64
 //@ compile-flags: -C target-feature=+neon
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     let mut foo = 0;
@@ -14,11 +19,11 @@ fn main() {
         asm!("", in("foo") foo);
         //~^ ERROR invalid register `foo`: unknown register
         asm!("{:z}", in(reg) foo);
-        //~^ ERROR invalid asm template modifier for this register class
+        //~^ ERROR invalid asm template modifier `z` for this register class
         asm!("{:r}", in(vreg) foo);
-        //~^ ERROR invalid asm template modifier for this register class
+        //~^ ERROR invalid asm template modifier `r` for this register class
         asm!("{:r}", in(vreg_low16) foo);
-        //~^ ERROR invalid asm template modifier for this register class
+        //~^ ERROR invalid asm template modifier `r` for this register class
         asm!("{:a}", const 0);
         //~^ ERROR asm template modifiers are not allowed for `const` arguments
         asm!("{:a}", sym main);
diff --git a/tests/ui/asm/aarch64/bad-reg.stderr b/tests/ui/asm/aarch64/bad-reg.stderr
index c76722f32a74..62f66cf3424f 100644
--- a/tests/ui/asm/aarch64/bad-reg.stderr
+++ b/tests/ui/asm/aarch64/bad-reg.stderr
@@ -1,49 +1,49 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:12:20
+  --> $DIR/bad-reg.rs:17:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
    |
-   = note: the following register classes are supported on this target: `reg`, `vreg`, `vreg_low16`, `preg`
+   = note: the following register classes are supported on this target: `reg`, `vreg`, `vreg_low16`, and `preg`
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:14:18
+  --> $DIR/bad-reg.rs:19:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
-error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:16:15
+error: invalid asm template modifier `z` for this register class
+  --> $DIR/bad-reg.rs:21:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
    |               |
    |               template modifier
    |
-   = note: the `reg` register class supports the following template modifiers: `w`, `x`
+   = note: the `reg` register class supports the following template modifiers: `w` and `x`
 
-error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:18:15
+error: invalid asm template modifier `r` for this register class
+  --> $DIR/bad-reg.rs:23:15
    |
 LL |         asm!("{:r}", in(vreg) foo);
    |               ^^^^   ------------ argument
    |               |
    |               template modifier
    |
-   = note: the `vreg` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
+   = note: the `vreg` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, and `v`
 
-error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:20:15
+error: invalid asm template modifier `r` for this register class
+  --> $DIR/bad-reg.rs:25:15
    |
 LL |         asm!("{:r}", in(vreg_low16) foo);
    |               ^^^^   ------------------ argument
    |               |
    |               template modifier
    |
-   = note: the `vreg_low16` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
+   = note: the `vreg_low16` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, and `v`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:22:15
+  --> $DIR/bad-reg.rs:27:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -51,7 +51,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:24:15
+  --> $DIR/bad-reg.rs:29:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -59,49 +59,49 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `x29`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:26:18
+  --> $DIR/bad-reg.rs:31:18
    |
 LL |         asm!("", in("x29") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:28:18
+  --> $DIR/bad-reg.rs:33:18
    |
 LL |         asm!("", in("sp") foo);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `xzr`: the zero register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:30:18
+  --> $DIR/bad-reg.rs:35:18
    |
 LL |         asm!("", in("xzr") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `x19`: x19 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:32:18
+  --> $DIR/bad-reg.rs:37:18
    |
 LL |         asm!("", in("x19") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:40:18
    |
 LL |         asm!("", in("p0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:39:20
+  --> $DIR/bad-reg.rs:44:20
    |
 LL |         asm!("{}", in(preg) foo);
    |                    ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:42:20
+  --> $DIR/bad-reg.rs:47:20
    |
 LL |         asm!("{}", out(preg) _);
    |                    ^^^^^^^^^^^
 
 error: register `w0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:48:32
+  --> $DIR/bad-reg.rs:53:32
    |
 LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `w0`
@@ -109,7 +109,7 @@ LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  register `x0`
 
 error: register `x0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:50:32
+  --> $DIR/bad-reg.rs:55:32
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `x0`
@@ -117,13 +117,13 @@ LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  register `x0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:50:18
+  --> $DIR/bad-reg.rs:55:18
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ^^^^^^^^^^^^
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:53:32
+  --> $DIR/bad-reg.rs:58:32
    |
 LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `q0`
@@ -131,7 +131,7 @@ LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  register `v0`
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:55:32
+  --> $DIR/bad-reg.rs:60:32
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `q0`
@@ -139,13 +139,13 @@ LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  register `v0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:55:18
+  --> $DIR/bad-reg.rs:60:18
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:35:27
+  --> $DIR/bad-reg.rs:40:27
    |
 LL |         asm!("", in("p0") foo);
    |                           ^^^
@@ -153,7 +153,7 @@ LL |         asm!("", in("p0") foo);
    = note: register class `preg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:39:29
+  --> $DIR/bad-reg.rs:44:29
    |
 LL |         asm!("{}", in(preg) foo);
    |                             ^^^
diff --git a/tests/ui/asm/x86_64/bad-clobber-abi.stderr b/tests/ui/asm/x86_64/bad-clobber-abi.stderr
index 46e91a3951fb..ec0d85f727fc 100644
--- a/tests/ui/asm/x86_64/bad-clobber-abi.stderr
+++ b/tests/ui/asm/x86_64/bad-clobber-abi.stderr
@@ -4,7 +4,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, `sysv64`
+   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: invalid ABI for `clobber_abi`
   --> $DIR/bad-clobber-abi.rs:13:35
@@ -12,7 +12,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("C", "foo"));
    |                                   ^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, `sysv64`
+   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
   --> $DIR/bad-clobber-abi.rs:15:35
@@ -38,7 +38,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("C", "foo", "C"));
    |                                   ^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, `sysv64`
+   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
   --> $DIR/bad-clobber-abi.rs:20:42
@@ -54,7 +54,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("win64", "foo", "efiapi"));
    |                                       ^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, `sysv64`
+   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `win64` ABI specified multiple times
   --> $DIR/bad-clobber-abi.rs:23:46
diff --git a/tests/ui/asm/x86_64/bad-options.stderr b/tests/ui/asm/x86_64/bad-options.stderr
index 366eb7cb90f3..a09f02e68ea9 100644
--- a/tests/ui/asm/x86_64/bad-options.stderr
+++ b/tests/ui/asm/x86_64/bad-options.stderr
@@ -93,7 +93,7 @@ error: invalid ABI for `clobber_abi`
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
    |
-   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, `sysv64`
+   = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
   --> $DIR/bad-options.rs:28:52
diff --git a/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr b/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
index 133921b894dd..fe2a53aec5d4 100644
--- a/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
+++ b/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
@@ -4,7 +4,7 @@ error: invalid register class `foo`: unknown register class
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
    |
-   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, `tmm_reg`
+   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `foo`: unknown register
   --> $DIR/bad-reg.rs:22:18
@@ -12,7 +12,7 @@ error: invalid register `foo`: unknown register
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
-error: invalid asm template modifier for this register class
+error: invalid asm template modifier `z` for this register class
   --> $DIR/bad-reg.rs:24:15
    |
 LL |         asm!("{:z}", in(reg) foo);
@@ -20,9 +20,9 @@ LL |         asm!("{:z}", in(reg) foo);
    |               |
    |               template modifier
    |
-   = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, `r`
+   = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, and `r`
 
-error: invalid asm template modifier for this register class
+error: invalid asm template modifier `r` for this register class
   --> $DIR/bad-reg.rs:26:15
    |
 LL |         asm!("{:r}", in(xmm_reg) foo);
@@ -30,7 +30,7 @@ LL |         asm!("{:r}", in(xmm_reg) foo);
    |               |
    |               template modifier
    |
-   = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, `z`
+   = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, and `z`
 
 error: asm template modifiers are not allowed for `const` arguments
   --> $DIR/bad-reg.rs:28:15
diff --git a/tests/ui/asm/x86_64/bad-reg.rs b/tests/ui/asm/x86_64/bad-reg.rs
index 4b3005d5675b..d5b5cd39bf77 100644
--- a/tests/ui/asm/x86_64/bad-reg.rs
+++ b/tests/ui/asm/x86_64/bad-reg.rs
@@ -22,9 +22,9 @@ fn main() {
         asm!("", in("foo") foo);
         //~^ ERROR invalid register `foo`: unknown register
         asm!("{:z}", in(reg) foo);
-        //~^ ERROR invalid asm template modifier for this register class
+        //~^ ERROR invalid asm template modifier `z` for this register class
         asm!("{:r}", in(xmm_reg) foo);
-        //~^ ERROR invalid asm template modifier for this register class
+        //~^ ERROR invalid asm template modifier `r` for this register class
         asm!("{:a}", const 0);
         //~^ ERROR asm template modifiers are not allowed for `const` arguments
         asm!("{:a}", sym main);
diff --git a/tests/ui/asm/x86_64/bad-reg.stable.stderr b/tests/ui/asm/x86_64/bad-reg.stable.stderr
index a1c2792a5b1f..d8a37933065e 100644
--- a/tests/ui/asm/x86_64/bad-reg.stable.stderr
+++ b/tests/ui/asm/x86_64/bad-reg.stable.stderr
@@ -4,7 +4,7 @@ error: invalid register class `foo`: unknown register class
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
    |
-   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, `tmm_reg`
+   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `foo`: unknown register
   --> $DIR/bad-reg.rs:22:18
@@ -12,7 +12,7 @@ error: invalid register `foo`: unknown register
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
-error: invalid asm template modifier for this register class
+error: invalid asm template modifier `z` for this register class
   --> $DIR/bad-reg.rs:24:15
    |
 LL |         asm!("{:z}", in(reg) foo);
@@ -20,9 +20,9 @@ LL |         asm!("{:z}", in(reg) foo);
    |               |
    |               template modifier
    |
-   = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, `r`
+   = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, and `r`
 
-error: invalid asm template modifier for this register class
+error: invalid asm template modifier `r` for this register class
   --> $DIR/bad-reg.rs:26:15
    |
 LL |         asm!("{:r}", in(xmm_reg) foo);
@@ -30,7 +30,7 @@ LL |         asm!("{:r}", in(xmm_reg) foo);
    |               |
    |               template modifier
    |
-   = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, `z`
+   = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, and `z`
 
 error: asm template modifiers are not allowed for `const` arguments
   --> $DIR/bad-reg.rs:28:15
diff --git a/tests/ui/asm/x86_64/issue-82869.stderr b/tests/ui/asm/x86_64/issue-82869.stderr
index 56e490995691..5cb7e6e27efa 100644
--- a/tests/ui/asm/x86_64/issue-82869.stderr
+++ b/tests/ui/asm/x86_64/issue-82869.stderr
@@ -4,7 +4,7 @@ error: invalid register class `vreg`: unknown register class
 LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    |                                ^^^^^^^^^^^
    |
-   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, `tmm_reg`
+   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register class `vreg`: unknown register class
   --> $DIR/issue-82869.rs:11:45
@@ -12,7 +12,7 @@ error: invalid register class `vreg`: unknown register class
 LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    |                                             ^^^^^^^^^^
    |
-   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, `tmm_reg`
+   = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `d0`: unknown register
   --> $DIR/issue-82869.rs:11:57

From 327216d31ab48fe7a2521143b2ae3421b67cce32 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 23 Mar 2026 09:11:31 +1100
Subject: [PATCH 0791/1059] Refactor `load_from_disk_or_invoke_provider_green`.

By removing the early return and using a `match` instead.
- The two paths are of similar conceptual weight, and `match` reflects
  that.
- This lets the `incremental_verify_ich` call be factored out.
---
 compiler/rustc_query_impl/src/execution.rs | 105 ++++++++++-----------
 1 file changed, 49 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 39dba1f199c1..78ead0cf14f1 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -488,66 +488,59 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
 
     debug_assert!(dep_graph_data.is_index_green(prev_index));
 
-    // First we try to load the result from the on-disk cache.
-    // Some things are never cached on disk.
-    if let Some(value) = (query.try_load_from_disk_fn)(tcx, key, prev_index, dep_node_index) {
-        if std::intrinsics::unlikely(tcx.sess.opts.unstable_opts.query_dep_graph) {
-            dep_graph_data.mark_debug_loaded_from_disk(*dep_node)
-        }
+    // First try to load the result from the on-disk cache. Some things are never cached on disk.
+    let value;
+    let verify;
+    match (query.try_load_from_disk_fn)(tcx, key, prev_index, dep_node_index) {
+        Some(loaded_value) => {
+            if std::intrinsics::unlikely(tcx.sess.opts.unstable_opts.query_dep_graph) {
+                dep_graph_data.mark_debug_loaded_from_disk(*dep_node)
+            }
 
-        let prev_fingerprint = dep_graph_data.prev_value_fingerprint_of(prev_index);
-        // If `-Zincremental-verify-ich` is specified, re-hash results from
-        // the cache and make sure that they have the expected fingerprint.
+            value = loaded_value;
+
+            let prev_fingerprint = dep_graph_data.prev_value_fingerprint_of(prev_index);
+            // If `-Zincremental-verify-ich` is specified, re-hash results from
+            // the cache and make sure that they have the expected fingerprint.
+            //
+            // If not, we still seek to verify a subset of fingerprints loaded
+            // from disk. Re-hashing results is fairly expensive, so we can't
+            // currently afford to verify every hash. This subset should still
+            // give us some coverage of potential bugs.
+            verify = prev_fingerprint.split().1.as_u64().is_multiple_of(32)
+                || tcx.sess.opts.unstable_opts.incremental_verify_ich;
+        }
+        None => {
+            // We could not load a result from the on-disk cache, so recompute. The dep-graph for
+            // this computation is already in-place, so we can just call the query provider.
+            let prof_timer = tcx.prof.query_provider();
+            value = tcx.dep_graph.with_ignore(|| (query.invoke_provider_fn)(tcx, key));
+            prof_timer.finish_with_query_invocation_id(dep_node_index.into());
+
+            verify = true;
+        }
+    };
+
+    if verify {
+        // Verify that re-running the query produced a result with the expected hash.
+        // This catches bugs in query implementations, turning them into ICEs.
+        // For example, a query might sort its result by `DefId` - since `DefId`s are
+        // not stable across compilation sessions, the result could get up getting sorted
+        // in a different order when the query is re-run, even though all of the inputs
+        // (e.g. `DefPathHash` values) were green.
         //
-        // If not, we still seek to verify a subset of fingerprints loaded
-        // from disk. Re-hashing results is fairly expensive, so we can't
-        // currently afford to verify every hash. This subset should still
-        // give us some coverage of potential bugs though.
-        let try_verify = prev_fingerprint.split().1.as_u64().is_multiple_of(32);
-        if std::intrinsics::unlikely(
-            try_verify || tcx.sess.opts.unstable_opts.incremental_verify_ich,
-        ) {
-            incremental_verify_ich(
-                tcx,
-                dep_graph_data,
-                &value,
-                prev_index,
-                query.hash_value_fn,
-                query.format_value,
-            );
-        }
-
-        return value;
+        // See issue #82920 for an example of a miscompilation that would get turned into
+        // an ICE by this check
+        incremental_verify_ich(
+            tcx,
+            dep_graph_data,
+            &value,
+            prev_index,
+            query.hash_value_fn,
+            query.format_value,
+        );
     }
 
-    // We could not load a result from the on-disk cache, so
-    // recompute.
-    let prof_timer = tcx.prof.query_provider();
-
-    // The dep-graph for this computation is already in-place.
-    // Call the query provider.
-    let value = tcx.dep_graph.with_ignore(|| (query.invoke_provider_fn)(tcx, key));
-
-    prof_timer.finish_with_query_invocation_id(dep_node_index.into());
-
-    // Verify that re-running the query produced a result with the expected hash
-    // This catches bugs in query implementations, turning them into ICEs.
-    // For example, a query might sort its result by `DefId` - since `DefId`s are
-    // not stable across compilation sessions, the result could get up getting sorted
-    // in a different order when the query is re-run, even though all of the inputs
-    // (e.g. `DefPathHash` values) were green.
-    //
-    // See issue #82920 for an example of a miscompilation that would get turned into
-    // an ICE by this check
-    incremental_verify_ich(
-        tcx,
-        dep_graph_data,
-        &value,
-        prev_index,
-        query.hash_value_fn,
-        query.format_value,
-    );
-
     value
 }
 

From 8dcb2578e2a982ecfc96f572198704fd70e52e63 Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Mon, 23 Mar 2026 10:55:10 +0700
Subject: [PATCH 0792/1059] Document consteval behavior of ub_checks &
 overflow_checks.

---
 library/core/src/intrinsics/mod.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 68e4f1c2aa78..d26a65c00c97 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2590,6 +2590,12 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 /// assertions are enabled whenever the *user crate* has UB checks enabled. However, if the
 /// user has UB checks disabled, the checks will still get optimized out. This intrinsic is
 /// primarily used by [`crate::ub_checks::assert_unsafe_precondition`].
+///
+/// # Consteval
+///
+/// In consteval, this function currently returns `true`. This is because the value of the `ub_checks`
+/// configuration can differ across crates, but we need this function to always return the same
+/// value in consteval in order to avoid unsoundness.
 #[rustc_intrinsic_const_stable_indirect] // just for UB checks
 #[inline(always)]
 #[rustc_intrinsic]
@@ -2609,6 +2615,12 @@ pub const fn ub_checks() -> bool {
 /// `#[inline]`), gating assertions on `overflow_checks()` rather than `cfg!(overflow_checks)` means that
 /// assertions are enabled whenever the *user crate* has overflow checks enabled. However if the
 /// user has overflow checks disabled, the checks will still get optimized out.
+///
+/// # Consteval
+///
+/// In consteval, this function currently returns `true`. This is because the value of the `overflow_checks`
+/// configuration can differ across crates, but we need this function to always return the same
+/// value in consteval in order to avoid unsoundness.
 #[inline(always)]
 #[rustc_intrinsic]
 pub const fn overflow_checks() -> bool {

From 338deef451efc6b6751db5e48ae983aab5cb1601 Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Mon, 23 Mar 2026 10:56:33 +0700
Subject: [PATCH 0793/1059] Remove outdated consteval docs for
 is_val_statically_known.

We've already stabilized float operations in const,
which means we've already accepted that a `const fn`
might behave differently in consteval vs at run time.
---
 library/core/src/intrinsics/mod.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index d26a65c00c97..128df654e078 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2502,14 +2502,6 @@ const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
 /// particular value, ever. However, the compiler will generally make it
 /// return `true` only if the value of the argument is actually known.
 ///
-/// # Stability concerns
-///
-/// While it is safe to call, this intrinsic may behave differently in
-/// a `const` context than otherwise. See the [`const_eval_select()`]
-/// documentation for an explanation of the issues this can cause. Unlike
-/// `const_eval_select`, this intrinsic isn't guaranteed to behave
-/// deterministically even in a `const` context.
-///
 /// # Type Requirements
 ///
 /// `T` must be either a `bool`, a `char`, a primitive numeric type (e.g. `f32`,

From 8059f91723209e39bb5417d9ed5aefb893be6cd6 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 23 Mar 2026 04:51:12 +0000
Subject: [PATCH 0794/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 562dee4820c458d823175268e41601d4c060588a.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index e95d7777b87c..a51e46f6191a 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-91021ccc790478a1a89c003e7d32b8d155ae6aae
+562dee4820c458d823175268e41601d4c060588a

From f0e33aee2bea59b49a662899a74c779b7b481f5e Mon Sep 17 00:00:00 2001
From: kartikohlan <kartik7ohlan@gmail.com>
Date: Mon, 23 Mar 2026 04:22:50 -0400
Subject: [PATCH 0795/1059] removed date-check

---
 src/doc/rustc-dev-guide/src/diagnostics/lintstore.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
index 301a1e055425..90b62b3509a7 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -21,7 +21,6 @@ which boils down to a static with type [`&rustc_lint_defs::Lint`]
 as the macro is somewhat unwieldy to add new fields to,
 like all macros).
 
-As of <!-- date-check --> March 2026,
 we lint against direct declarations without the use of the macro.
 
 Lint declarations don't carry any "state" - they are merely global identifiers

From 23411ce1661a5496821419e3c685e3abd4493e1f Mon Sep 17 00:00:00 2001
From: "Andrew V. Teylu" <andrew.teylu@vector.com>
Date: Mon, 23 Mar 2026 08:47:54 +0000
Subject: [PATCH 0796/1059] Refactor asm pretty-print operand reordering and
 broaden regression coverage

Extract the inline asm operand reorder/remap logic into a dedicated helper so
`print_inline_asm` stays focused on assembling the printed argument list.
This keeps the reordered-template logic local to the AST pretty printer while
making the main printing path easier to read.

Also extend the pretty regression test with a `const` operand case. That checks
that non-register operands other than `in(reg)` are also moved ahead of explicit
register operands and that the remapped template indices still match the new
operand order.

Signed-off-by: Andrew V. Teylu <andrew.teylu@vector.com>
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 120 +++++++++---------
 tests/pretty/asm-operand-order.pp             |   1 +
 tests/pretty/asm-operand-order.rs             |   1 +
 3 files changed, 63 insertions(+), 59 deletions(-)

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 92767f97c28e..4823189f7be3 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1612,21 +1612,10 @@ fn print_mac(&mut self, m: &ast::MacCall) {
         );
     }
 
-    fn print_inline_asm(&mut self, asm: &ast::InlineAsm) {
-        enum AsmArg<'a> {
-            Template(String),
-            Operand(&'a InlineAsmOperand),
-            ClobberAbi(Symbol),
-            Options(InlineAsmOptions),
-        }
-
-        // After macro expansion, named operands become positional. The grammar
-        // requires positional operands to precede explicit register operands,
-        // so we must reorder when any non-explicit operand follows an explicit
-        // one. When no reordering is needed, we use the original template
-        // string and operand order to avoid duplicating the Display logic in
-        // InlineAsmTemplatePiece.
-        let is_explicit_reg = |op: &InlineAsmOperand| -> bool {
+    fn inline_asm_template_and_operands<'asm>(
+        asm: &'asm ast::InlineAsm,
+    ) -> (String, Vec<&'asm InlineAsmOperand>) {
+        fn is_explicit_reg(op: &InlineAsmOperand) -> bool {
             match op {
                 InlineAsmOperand::In { reg, .. }
                 | InlineAsmOperand::Out { reg, .. }
@@ -1638,9 +1627,14 @@ enum AsmArg<'a> {
                 | InlineAsmOperand::Sym { .. }
                 | InlineAsmOperand::Label { .. } => false,
             }
-        };
+        }
 
-        // Check whether any non-explicit operand follows an explicit one.
+        // After macro expansion, named operands become positional. The grammar
+        // requires positional operands to precede explicit register operands,
+        // so we must reorder when any non-explicit operand follows an explicit
+        // one. When no reordering is needed, we use the original template
+        // string and operand order to avoid duplicating the Display logic in
+        // InlineAsmTemplatePiece.
         let needs_reorder = {
             let mut seen_explicit = false;
             asm.operands.iter().any(|(op, _)| {
@@ -1653,53 +1647,61 @@ enum AsmArg<'a> {
             })
         };
 
-        let mut args = if needs_reorder {
-            let mut non_explicit: Vec<usize> = Vec::new();
-            let mut explicit: Vec<usize> = Vec::new();
-            for (i, (op, _)) in asm.operands.iter().enumerate() {
-                if is_explicit_reg(op) {
-                    explicit.push(i);
-                } else {
-                    non_explicit.push(i);
-                }
-            }
+        if !needs_reorder {
+            let template = InlineAsmTemplatePiece::to_string(&asm.template);
+            let operands = asm.operands.iter().map(|(op, _)| op).collect();
+            return (template, operands);
+        }
 
-            // Build old-index → new-index mapping for template renumbering.
-            let mut old_to_new = vec![0usize; asm.operands.len()];
-            for (new_idx, &old_idx) in non_explicit.iter().chain(explicit.iter()).enumerate() {
-                old_to_new[old_idx] = new_idx;
+        let mut non_explicit = Vec::new();
+        let mut explicit = Vec::new();
+        for (i, (op, _)) in asm.operands.iter().enumerate() {
+            if is_explicit_reg(op) {
+                explicit.push(i);
+            } else {
+                non_explicit.push(i);
             }
+        }
+        let order = non_explicit.into_iter().chain(explicit).collect::<Vec<_>>();
 
-            // Remap template placeholder indices and reuse the existing
-            // Display impl to build the template string.
-            let remapped: Vec<_> = asm
-                .template
-                .iter()
-                .map(|piece| match piece {
-                    InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span } => {
-                        InlineAsmTemplatePiece::Placeholder {
-                            operand_idx: old_to_new[*operand_idx],
-                            modifier: *modifier,
-                            span: *span,
-                        }
+        // Build old-index -> new-index mapping for template renumbering.
+        let mut old_to_new = vec![0usize; asm.operands.len()];
+        for (new_idx, old_idx) in order.iter().copied().enumerate() {
+            old_to_new[old_idx] = new_idx;
+        }
+
+        // Remap template placeholder indices and reuse the existing Display
+        // impl to build the template string.
+        let remapped = asm
+            .template
+            .iter()
+            .map(|piece| match piece {
+                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span } => {
+                    InlineAsmTemplatePiece::Placeholder {
+                        operand_idx: old_to_new[*operand_idx],
+                        modifier: *modifier,
+                        span: *span,
                     }
-                    other => other.clone(),
-                })
-                .collect();
+                }
+                other => other.clone(),
+            })
+            .collect::<Vec<_>>();
+        let template = InlineAsmTemplatePiece::to_string(&remapped);
+        let operands = order.iter().map(|&idx| &asm.operands[idx].0).collect();
+        (template, operands)
+    }
 
-            let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&remapped))];
-            for &idx in &non_explicit {
-                args.push(AsmArg::Operand(&asm.operands[idx].0));
-            }
-            for &idx in &explicit {
-                args.push(AsmArg::Operand(&asm.operands[idx].0));
-            }
-            args
-        } else {
-            let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&asm.template))];
-            args.extend(asm.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
-            args
-        };
+    fn print_inline_asm(&mut self, asm: &ast::InlineAsm) {
+        enum AsmArg<'a> {
+            Template(String),
+            Operand(&'a InlineAsmOperand),
+            ClobberAbi(Symbol),
+            Options(InlineAsmOptions),
+        }
+
+        let (template, operands) = Self::inline_asm_template_and_operands(asm);
+        let mut args = vec![AsmArg::Template(template)];
+        args.extend(operands.into_iter().map(AsmArg::Operand));
         for (abi, _) in &asm.clobber_abis {
             args.push(AsmArg::ClobberAbi(*abi));
         }
diff --git a/tests/pretty/asm-operand-order.pp b/tests/pretty/asm-operand-order.pp
index 723191412d0f..949c18c6723a 100644
--- a/tests/pretty/asm-operand-order.pp
+++ b/tests/pretty/asm-operand-order.pp
@@ -14,5 +14,6 @@ pub fn main() {
         asm!("{0}", in(reg) 4, out("rax") _);
         asm!("{0}", in(reg) 4, out("rax") _, options(nostack));
         asm!("{0} {1}", in(reg) 4, in(reg) 5, out("rax") _);
+        asm!("{0}", const 5, out("rax") _);
     }
 }
diff --git a/tests/pretty/asm-operand-order.rs b/tests/pretty/asm-operand-order.rs
index 05a994e38544..b0bdabd94678 100644
--- a/tests/pretty/asm-operand-order.rs
+++ b/tests/pretty/asm-operand-order.rs
@@ -9,5 +9,6 @@ pub fn main() {
         asm!("{val}", out("rax") _, val = in(reg) 4);
         asm!("{val}", out("rax") _, val = in(reg) 4, options(nostack));
         asm!("{a} {b}", out("rax") _, a = in(reg) 4, b = in(reg) 5);
+        asm!("{val}", out("rax") _, val = const 5);
     }
 }

From 2e30fefde60a9086ddb2d9600c87b87797da56cb Mon Sep 17 00:00:00 2001
From: danieljofficial <joenah004@gmail.com>
Date: Mon, 23 Mar 2026 10:25:45 +0100
Subject: [PATCH 0797/1059] move statics test files  out of tests/ui/issues

---
 .../static-cannot-use-local-variable.fixed}                       | 0
 .../static-cannot-use-local-variable.rs}                          | 0
 .../static-cannot-use-local-variable.stderr}                      | 0
 .../static-in-fn-cannot-use-param.fixed}                          | 0
 .../issue-3668-2.rs => statics/static-in-fn-cannot-use-param.rs}  | 0
 .../static-in-fn-cannot-use-param.stderr}                         | 0
 .../issue-3668.rs => statics/static-in-method-cannot-use-self.rs} | 0
 .../static-in-method-cannot-use-self.stderr}                      | 0
 .../issue-39367.rs => statics/static-lazy-init-with-arena-set.rs} | 0
 .../static-lazy-init-with-arena-set.stderr}                       | 0
 .../issue-46604.rs => statics/static-mut-borrow-of-temporary.rs}  | 0
 .../static-mut-borrow-of-temporary.stderr}                        | 0
 .../static-mut-with-assoc-type-field.rs}                          | 0
 .../static-ref-deref-non-const-trait.rs}                          | 0
 .../static-ref-deref-non-const-trait.stderr}                      | 0
 15 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/issue-3521-2.fixed => statics/static-cannot-use-local-variable.fixed} (100%)
 rename tests/ui/{issues/issue-3521-2.rs => statics/static-cannot-use-local-variable.rs} (100%)
 rename tests/ui/{issues/issue-3521-2.stderr => statics/static-cannot-use-local-variable.stderr} (100%)
 rename tests/ui/{issues/issue-3668-non-constant-value-in-constant/issue-3668-2.fixed => statics/static-in-fn-cannot-use-param.fixed} (100%)
 rename tests/ui/{issues/issue-3668-non-constant-value-in-constant/issue-3668-2.rs => statics/static-in-fn-cannot-use-param.rs} (100%)
 rename tests/ui/{issues/issue-3668-non-constant-value-in-constant/issue-3668-2.stderr => statics/static-in-fn-cannot-use-param.stderr} (100%)
 rename tests/ui/{issues/issue-3668-non-constant-value-in-constant/issue-3668.rs => statics/static-in-method-cannot-use-self.rs} (100%)
 rename tests/ui/{issues/issue-3668-non-constant-value-in-constant/issue-3668.stderr => statics/static-in-method-cannot-use-self.stderr} (100%)
 rename tests/ui/{issues/issue-39367.rs => statics/static-lazy-init-with-arena-set.rs} (100%)
 rename tests/ui/{issues/issue-39367.stderr => statics/static-lazy-init-with-arena-set.stderr} (100%)
 rename tests/ui/{issues/issue-46604.rs => statics/static-mut-borrow-of-temporary.rs} (100%)
 rename tests/ui/{issues/issue-46604.stderr => statics/static-mut-borrow-of-temporary.stderr} (100%)
 rename tests/ui/{issues/issue-29821.rs => statics/static-mut-with-assoc-type-field.rs} (100%)
 rename tests/ui/{issues/issue-25901.rs => statics/static-ref-deref-non-const-trait.rs} (100%)
 rename tests/ui/{issues/issue-25901.stderr => statics/static-ref-deref-non-const-trait.stderr} (100%)

diff --git a/tests/ui/issues/issue-3521-2.fixed b/tests/ui/statics/static-cannot-use-local-variable.fixed
similarity index 100%
rename from tests/ui/issues/issue-3521-2.fixed
rename to tests/ui/statics/static-cannot-use-local-variable.fixed
diff --git a/tests/ui/issues/issue-3521-2.rs b/tests/ui/statics/static-cannot-use-local-variable.rs
similarity index 100%
rename from tests/ui/issues/issue-3521-2.rs
rename to tests/ui/statics/static-cannot-use-local-variable.rs
diff --git a/tests/ui/issues/issue-3521-2.stderr b/tests/ui/statics/static-cannot-use-local-variable.stderr
similarity index 100%
rename from tests/ui/issues/issue-3521-2.stderr
rename to tests/ui/statics/static-cannot-use-local-variable.stderr
diff --git a/tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.fixed b/tests/ui/statics/static-in-fn-cannot-use-param.fixed
similarity index 100%
rename from tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.fixed
rename to tests/ui/statics/static-in-fn-cannot-use-param.fixed
diff --git a/tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.rs b/tests/ui/statics/static-in-fn-cannot-use-param.rs
similarity index 100%
rename from tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.rs
rename to tests/ui/statics/static-in-fn-cannot-use-param.rs
diff --git a/tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.stderr b/tests/ui/statics/static-in-fn-cannot-use-param.stderr
similarity index 100%
rename from tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668-2.stderr
rename to tests/ui/statics/static-in-fn-cannot-use-param.stderr
diff --git a/tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668.rs b/tests/ui/statics/static-in-method-cannot-use-self.rs
similarity index 100%
rename from tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668.rs
rename to tests/ui/statics/static-in-method-cannot-use-self.rs
diff --git a/tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668.stderr b/tests/ui/statics/static-in-method-cannot-use-self.stderr
similarity index 100%
rename from tests/ui/issues/issue-3668-non-constant-value-in-constant/issue-3668.stderr
rename to tests/ui/statics/static-in-method-cannot-use-self.stderr
diff --git a/tests/ui/issues/issue-39367.rs b/tests/ui/statics/static-lazy-init-with-arena-set.rs
similarity index 100%
rename from tests/ui/issues/issue-39367.rs
rename to tests/ui/statics/static-lazy-init-with-arena-set.rs
diff --git a/tests/ui/issues/issue-39367.stderr b/tests/ui/statics/static-lazy-init-with-arena-set.stderr
similarity index 100%
rename from tests/ui/issues/issue-39367.stderr
rename to tests/ui/statics/static-lazy-init-with-arena-set.stderr
diff --git a/tests/ui/issues/issue-46604.rs b/tests/ui/statics/static-mut-borrow-of-temporary.rs
similarity index 100%
rename from tests/ui/issues/issue-46604.rs
rename to tests/ui/statics/static-mut-borrow-of-temporary.rs
diff --git a/tests/ui/issues/issue-46604.stderr b/tests/ui/statics/static-mut-borrow-of-temporary.stderr
similarity index 100%
rename from tests/ui/issues/issue-46604.stderr
rename to tests/ui/statics/static-mut-borrow-of-temporary.stderr
diff --git a/tests/ui/issues/issue-29821.rs b/tests/ui/statics/static-mut-with-assoc-type-field.rs
similarity index 100%
rename from tests/ui/issues/issue-29821.rs
rename to tests/ui/statics/static-mut-with-assoc-type-field.rs
diff --git a/tests/ui/issues/issue-25901.rs b/tests/ui/statics/static-ref-deref-non-const-trait.rs
similarity index 100%
rename from tests/ui/issues/issue-25901.rs
rename to tests/ui/statics/static-ref-deref-non-const-trait.rs
diff --git a/tests/ui/issues/issue-25901.stderr b/tests/ui/statics/static-ref-deref-non-const-trait.stderr
similarity index 100%
rename from tests/ui/issues/issue-25901.stderr
rename to tests/ui/statics/static-ref-deref-non-const-trait.stderr

From ff7589498710bc7ac971d1a19cc128a08cb17b9c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:20:09 +1100
Subject: [PATCH 0798/1059] Remove an unhelpful assertion from
 `force_from_dep_node_inner`

This assertion and its comment are much visually heavier than the part of the
function that actually performs important work.

This assertion is also useless, because the `codegen_unit` query does not have
a `force_from_dep_node_fn` in its DepKindVTable, so the assertion would never
be reached even in the situation it is trying to guard against.

This assertion is also redundant, because we have plenty of incremental tests
that fail if the corresponding calls to `tcx.ensure_ok().codegen_unit(..)` are
removed.
---
 compiler/rustc_query_impl/src/plumbing.rs | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index b8aa125aaf96..f4a80a62cc68 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -6,7 +6,7 @@
 use rustc_middle::bug;
 #[expect(unused_imports, reason = "used by doc comments")]
 use rustc_middle::dep_graph::DepKindVTable;
-use rustc_middle::dep_graph::{DepKind, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex};
+use rustc_middle::dep_graph::{DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::erase::{Erasable, Erased};
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
@@ -230,24 +230,6 @@ pub(crate) fn force_from_dep_node_inner<'tcx, Q: GetQueryVTable<'tcx>>(
 ) -> bool {
     let query = Q::query_vtable(tcx);
 
-    // We must avoid ever having to call `force_from_dep_node()` for a
-    // `DepNode::codegen_unit`:
-    // Since we cannot reconstruct the query key of a `DepNode::codegen_unit`, we
-    // would always end up having to evaluate the first caller of the
-    // `codegen_unit` query that *is* reconstructible. This might very well be
-    // the `compile_codegen_unit` query, thus re-codegenning the whole CGU just
-    // to re-trigger calling the `codegen_unit` query with the right key. At
-    // that point we would already have re-done all the work we are trying to
-    // avoid doing in the first place.
-    // The solution is simple: Just explicitly call the `codegen_unit` query for
-    // each CGU, right after partitioning. This way `try_mark_green` will always
-    // hit the cache instead of having to go through `force_from_dep_node`.
-    // This assertion makes sure, we actually keep applying the solution above.
-    debug_assert!(
-        dep_node.kind != DepKind::codegen_unit,
-        "calling force_from_dep_node() on dep_kinds::codegen_unit"
-    );
-
     if let Some(key) = <Q::Cache as QueryCache>::Key::try_recover_key(tcx, &dep_node) {
         force_query(query, tcx, key, dep_node);
         true

From b29d6df04f6c7e7eaadaa9c858f6877aab999f57 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:20:09 +1100
Subject: [PATCH 0799/1059] Remove a redundant query cache lookup while forcing

In the serial compiler, we should never be trying to force a query node that
has a cached value, because we would have already marked the node red or green
when putting its value in cache.

In the parallel compiler, we immediately re-check the cache while holding the
state shard lock anyway, and trying to avoid that lock doesn't seem worthwhile.
---
 compiler/rustc_query_impl/src/execution.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index bbd55e9ead11..1d998cabc909 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -686,13 +686,6 @@ pub(crate) fn force_query<'tcx, C: QueryCache>(
     key: C::Key,
     dep_node: DepNode,
 ) {
-    // We may be concurrently trying both execute and force a query.
-    // Ensure that only one of them runs the query.
-    if let Some((_, index)) = query.cache.lookup(&key) {
-        tcx.prof.query_cache_hit(index.into());
-        return;
-    }
-
     ensure_sufficient_stack(|| {
         try_execute_query::<C, true>(query, tcx, DUMMY_SP, key, Some(dep_node))
     });

From 4b52951832d9921bca16713db0c66683a1d0e750 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:20:09 +1100
Subject: [PATCH 0800/1059] Combine `force_from_dep_node_inner` and
 `force_query`

The different parts of this function used to be split across different crates,
but nowadays they are both in `rustc_query_impl`, so they can be combined.

This commit also hoists the vtable lookup to a closure in
`make_dep_kind_vtable_for_query`, to reduce the amount of code that deals with
`GetQueryVTable`, and to make the inner function more consistent with other
functions in `execution`.
---
 .../rustc_query_impl/src/dep_kind_vtables.rs  | 10 ++++++---
 compiler/rustc_query_impl/src/execution.rs    | 21 +++++++++++++++----
 compiler/rustc_query_impl/src/plumbing.rs     | 19 +----------------
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 44b92dc727ab..4346e29f4754 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -4,7 +4,7 @@
 use rustc_middle::query::QueryCache;
 
 use crate::GetQueryVTable;
-use crate::plumbing::{force_from_dep_node_inner, promote_from_disk_inner};
+use crate::plumbing::promote_from_disk_inner;
 
 /// [`DepKindVTable`] constructors for special dep kinds that aren't queries.
 #[expect(non_snake_case, reason = "use non-snake case to avoid collision with query names")]
@@ -111,8 +111,12 @@ pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
     DepKindVTable {
         is_eval_always,
         key_fingerprint_style,
-        force_from_dep_node_fn: (can_recover && !is_no_force)
-            .then_some(force_from_dep_node_inner::<Q>),
+        force_from_dep_node_fn: (can_recover && !is_no_force).then_some(
+            |tcx, dep_node, _prev_index| {
+                let query = Q::query_vtable(tcx);
+                crate::execution::force_query_dep_node(tcx, query, dep_node)
+            },
+        ),
         promote_from_disk_fn: (can_recover && is_cache_on_disk)
             .then_some(promote_from_disk_inner::<Q>),
     }
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 1d998cabc909..b503a914618e 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -680,13 +680,26 @@ pub(super) fn execute_query_incr_inner<'tcx, C: QueryCache>(
     Some(result)
 }
 
-pub(crate) fn force_query<'tcx, C: QueryCache>(
-    query: &'tcx QueryVTable<'tcx, C>,
+/// Inner implementation of [`DepKindVTable::force_from_dep_node_fn`][force_fn]
+/// for query nodes.
+///
+/// [force_fn]: rustc_middle::dep_graph::DepKindVTable::force_from_dep_node_fn
+pub(crate) fn force_query_dep_node<'tcx, C: QueryCache>(
     tcx: TyCtxt<'tcx>,
-    key: C::Key,
+    query: &'tcx QueryVTable<'tcx, C>,
     dep_node: DepNode,
-) {
+) -> bool {
+    let Some(key) = C::Key::try_recover_key(tcx, &dep_node) else {
+        // We couldn't recover a key from the node's key fingerprint.
+        // Tell the caller that we couldn't force the node.
+        return false;
+    };
+
     ensure_sufficient_stack(|| {
         try_execute_query::<C, true>(query, tcx, DUMMY_SP, key, Some(dep_node))
     });
+
+    // We did manage to recover a key and force the node, though it's up to
+    // the caller to check whether the node ended up marked red or green.
+    true
 }
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index f4a80a62cc68..12dda5029429 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -20,7 +20,7 @@
 use rustc_span::def_id::LOCAL_CRATE;
 
 use crate::error::{QueryOverflow, QueryOverflowNote};
-use crate::execution::{all_inactive, force_query};
+use crate::execution::all_inactive;
 use crate::job::find_dep_kind_root;
 use crate::query_impl::for_each_query_vtable;
 use crate::{CollectActiveJobsKind, GetQueryVTable, collect_active_query_jobs};
@@ -220,20 +220,3 @@ pub(crate) fn try_load_from_disk<'tcx, V>(
 
     value
 }
-
-/// Implementation of [`DepKindVTable::force_from_dep_node_fn`] for queries.
-pub(crate) fn force_from_dep_node_inner<'tcx, Q: GetQueryVTable<'tcx>>(
-    tcx: TyCtxt<'tcx>,
-    dep_node: DepNode,
-    // Needed by the vtable function signature, but not used when forcing queries.
-    _prev_index: SerializedDepNodeIndex,
-) -> bool {
-    let query = Q::query_vtable(tcx);
-
-    if let Some(key) = <Q::Cache as QueryCache>::Key::try_recover_key(tcx, &dep_node) {
-        force_query(query, tcx, key, dep_node);
-        true
-    } else {
-        false
-    }
-}

From 97b1c314892ef4497c0ce5656daa3a54c4e052d3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 17:50:39 +1100
Subject: [PATCH 0801/1059] Also restore the wrapper closure for
 `promote_from_disk_fn`

This effectively reverses <https://github.com/rust-lang/rust/commit/4284edc>.

At that time, I thought GetQueryVTable might be useful for other kinds of
static lookup in the future, but after various other simplifications and
cleanups that now seems less likely, and this style is more consistent with
other vtable-related functions.
---
 compiler/rustc_query_impl/src/dep_kind_vtables.rs |  6 ++++--
 compiler/rustc_query_impl/src/plumbing.rs         | 10 +++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
index 4346e29f4754..b70fe3008cb1 100644
--- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs
+++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -117,8 +117,10 @@ pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q>(
                 crate::execution::force_query_dep_node(tcx, query, dep_node)
             },
         ),
-        promote_from_disk_fn: (can_recover && is_cache_on_disk)
-            .then_some(promote_from_disk_inner::<Q>),
+        promote_from_disk_fn: (can_recover && is_cache_on_disk).then_some(|tcx, dep_node| {
+            let query = Q::query_vtable(tcx);
+            promote_from_disk_inner(tcx, query, dep_node)
+        }),
     }
 }
 
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 12dda5029429..0ea272a2c192 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -23,7 +23,7 @@
 use crate::execution::all_inactive;
 use crate::job::find_dep_kind_root;
 use crate::query_impl::for_each_query_vtable;
-use crate::{CollectActiveJobsKind, GetQueryVTable, collect_active_query_jobs};
+use crate::{CollectActiveJobsKind, collect_active_query_jobs};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
     let job_map = collect_active_query_jobs(tcx, CollectActiveJobsKind::Full);
@@ -151,15 +151,15 @@ fn verify_query_key_hashes_inner<'tcx, C: QueryCache>(
     });
 }
 
-/// Implementation of [`DepKindVTable::promote_from_disk_fn`] for queries.
-pub(crate) fn promote_from_disk_inner<'tcx, Q: GetQueryVTable<'tcx>>(
+/// Inner implementation of [`DepKindVTable::promote_from_disk_fn`] for queries.
+pub(crate) fn promote_from_disk_inner<'tcx, C: QueryCache>(
     tcx: TyCtxt<'tcx>,
+    query: &'tcx QueryVTable<'tcx, C>,
     dep_node: DepNode,
 ) {
-    let query = Q::query_vtable(tcx);
     debug_assert!(tcx.dep_graph.is_green(&dep_node));
 
-    let key = <Q::Cache as QueryCache>::Key::try_recover_key(tcx, &dep_node).unwrap_or_else(|| {
+    let key = C::Key::try_recover_key(tcx, &dep_node).unwrap_or_else(|| {
         panic!(
             "Failed to recover key for {dep_node:?} with key fingerprint {}",
             dep_node.key_fingerprint

From 26c9f7255a0e12e48132ac3dbf0f8519ed3243dc Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Mon, 23 Mar 2026 11:27:06 +0100
Subject: [PATCH 0802/1059] Allow applying autodiff macros to trait functions.
 It will use enzyme to generate a default derivative implementation, which can
 be overwritten by the user.

---
 .../src/attributes/autodiff.rs                |  1 +
 compiler/rustc_builtin_macros/src/autodiff.rs | 30 +++++++------
 compiler/rustc_expand/src/base.rs             |  4 +-
 tests/pretty/autodiff/trait.pp                | 43 +++++++++++++++++++
 tests/pretty/autodiff/trait.rs                | 32 ++++++++++++++
 5 files changed, 94 insertions(+), 16 deletions(-)
 create mode 100644 tests/pretty/autodiff/trait.pp
 create mode 100644 tests/pretty/autodiff/trait.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/autodiff.rs b/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
index 118a4103b1a9..c72ff224a150 100644
--- a/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
@@ -24,6 +24,7 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
         Allow(Target::Method(MethodKind::TraitImpl)),
     ]);
     const TEMPLATE: AttributeTemplate = template!(
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 30391e74480f..afa393a545cd 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -224,16 +224,18 @@ pub(crate) fn expand_with_mode(
                 }
                 _ => None,
             },
-            Annotatable::AssocItem(assoc_item, Impl { of_trait: _ }) => match &assoc_item.kind {
-                ast::AssocItemKind::Fn(box ast::Fn { sig, ident, generics, .. }) => Some((
-                    assoc_item.vis.clone(),
-                    sig.clone(),
-                    ident.clone(),
-                    generics.clone(),
-                    true,
-                )),
-                _ => None,
-            },
+            Annotatable::AssocItem(assoc_item, _ctxt @ (Impl { of_trait: _ } | Trait)) => {
+                match &assoc_item.kind {
+                    ast::AssocItemKind::Fn(box ast::Fn { sig, ident, generics, .. }) => Some((
+                        assoc_item.vis.clone(),
+                        sig.clone(),
+                        ident.clone(),
+                        generics.clone(),
+                        true,
+                    )),
+                    _ => None,
+                }
+            }
             _ => None,
         }) else {
             dcx.emit_err(errors::AutoDiffInvalidApplication { span: item.span() });
@@ -393,14 +395,14 @@ fn same_attribute(attr: &ast::AttrKind, item: &ast::AttrKind) -> bool {
                 }
                 Annotatable::Item(iitem.clone())
             }
-            Annotatable::AssocItem(ref mut assoc_item, i @ Impl { .. }) => {
+            Annotatable::AssocItem(ref mut assoc_item, ctxt @ (Impl { .. } | Trait)) => {
                 if !assoc_item.attrs.iter().any(|a| same_attribute(&a.kind, &attr.kind)) {
                     assoc_item.attrs.push(attr);
                 }
                 if assoc_item.attrs.iter().any(|a| same_attribute(&a.kind, &inline_never.kind)) {
                     has_inline_never = true;
                 }
-                Annotatable::AssocItem(assoc_item.clone(), i)
+                Annotatable::AssocItem(assoc_item.clone(), ctxt)
             }
             Annotatable::Stmt(ref mut stmt) => {
                 match stmt.kind {
@@ -441,7 +443,7 @@ fn same_attribute(attr: &ast::AttrKind, item: &ast::AttrKind) -> bool {
         }
 
         let d_annotatable = match &item {
-            Annotatable::AssocItem(_, _) => {
+            Annotatable::AssocItem(_, ctxt) => {
                 let assoc_item: AssocItemKind = ast::AssocItemKind::Fn(d_fn);
                 let d_fn = Box::new(ast::AssocItem {
                     attrs: d_attrs,
@@ -451,7 +453,7 @@ fn same_attribute(attr: &ast::AttrKind, item: &ast::AttrKind) -> bool {
                     kind: assoc_item,
                     tokens: None,
                 });
-                Annotatable::AssocItem(d_fn, Impl { of_trait: false })
+                Annotatable::AssocItem(d_fn, *ctxt)
             }
             Annotatable::Item(_) => {
                 let mut d_fn = ecx.item(span, d_attrs, ItemKind::Fn(d_fn));
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 225906dfba2d..44f148f9c15a 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -149,14 +149,14 @@ pub fn expect_item(self) -> Box<ast::Item> {
     pub fn expect_trait_item(self) -> Box<ast::AssocItem> {
         match self {
             Annotatable::AssocItem(i, AssocCtxt::Trait) => i,
-            _ => panic!("expected Item"),
+            _ => panic!("expected trait item"),
         }
     }
 
     pub fn expect_impl_item(self) -> Box<ast::AssocItem> {
         match self {
             Annotatable::AssocItem(i, AssocCtxt::Impl { .. }) => i,
-            _ => panic!("expected Item"),
+            _ => panic!("expected impl item"),
         }
     }
 
diff --git a/tests/pretty/autodiff/trait.pp b/tests/pretty/autodiff/trait.pp
new file mode 100644
index 000000000000..cb2fe0c4a4ef
--- /dev/null
+++ b/tests/pretty/autodiff/trait.pp
@@ -0,0 +1,43 @@
+//@ compile-flags: -Zautodiff=Enable -Zautodiff=NoPostopt -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// Just check it does not crash for now
+// CHECK: ;
+#![feature(autodiff)]
+#![feature(core_intrinsics)]
+#![feature(rustc_attrs)]
+
+use std::autodiff::autodiff_reverse;
+
+struct Foo {
+    a: f64,
+}
+
+trait MyTrait {
+    #[rustc_autodiff]
+    fn f(&self, x: f64) -> f64;
+    #[rustc_autodiff(Reverse, 1, Const, Active, Active)]
+    fn df(&self, x: f64, seed: f64) -> (f64, f64) {
+        std::hint::black_box(seed);
+        std::hint::black_box(x);
+        ::std::intrinsics::autodiff(
+            Self::f as for<'a> fn(&'a Self, _: f64) -> f64,
+            Self::df,
+            (self, x, seed),
+        )
+
+    }
+}
+
+impl MyTrait for Foo {
+    fn f(&self, x: f64) -> f64 {
+        x.sin()
+    }
+}
+
+fn main() {
+    let foo = Foo { a: 3.0f64 };
+    dbg!(foo.df(2.0, 1.0));
+    dbg!(2.0_f64.cos());
+}
diff --git a/tests/pretty/autodiff/trait.rs b/tests/pretty/autodiff/trait.rs
new file mode 100644
index 000000000000..a308cf3fb2ad
--- /dev/null
+++ b/tests/pretty/autodiff/trait.rs
@@ -0,0 +1,32 @@
+//@ compile-flags: -Zautodiff=Enable -Zautodiff=NoPostopt -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// Just check it does not crash for now
+// CHECK: ;
+#![feature(autodiff)]
+#![feature(core_intrinsics)]
+#![feature(rustc_attrs)]
+
+use std::autodiff::autodiff_reverse;
+
+struct Foo {
+    a: f64,
+}
+
+trait MyTrait {
+    #[autodiff_reverse(df, Const, Active, Active)]
+    fn f(&self, x: f64) -> f64;
+}
+
+impl MyTrait for Foo {
+    fn f(&self, x: f64) -> f64 {
+        x.sin()
+    }
+}
+
+fn main() {
+    let foo = Foo { a: 3.0f64 };
+    dbg!(foo.df(2.0, 1.0));
+    dbg!(2.0_f64.cos());
+}

From 1fa1611e9fa6315254c9202ab2874e67b65f68b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0803/1059] Revert "address review"

This reverts commit d665c0b3718dc582189a85dc1d49e641d22e9e21.
---
 .../src/infer/relate/generalize.rs            | 72 +++++--------------
 compiler/rustc_middle/src/hooks/mod.rs        |  7 +-
 compiler/rustc_trait_selection/src/solve.rs   |  6 +-
 tests/ui/impl-trait/unsized_coercion.rs       |  3 +-
 4 files changed, 23 insertions(+), 65 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index b2d591327fea..f3843c371e2c 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -355,51 +355,13 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
     }
 }
 
-/// This state determines how generalization treats aliases.
-///
-/// Based on which state we're in, we treat them either as rigid or normalizable,
-/// which might change depending on what types the generalization visitor encounters.
-/// See `handle_alias_ty` for the logic of how we change states.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 enum GeneralizerState {
     /// Treat aliases as potentially normalizable.
-    ///
-    /// This is the default state that generalization starts in, unless we're
-    /// treating aliases as rigid. It also means we're not currently inside an
-    /// alias, since then we change the state to `IncompletelyRelateAliasArgs`.
     Default,
-    /// We enter this state when we're generalizing the arguments of a
-    /// potentially normalizeable alias.
-    ///
-    /// The behavior here is different between the old and the new solver:
-    ///
-    /// In the old solver, the difference between this and `Default` is needed to
-    /// correctly handle `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. That
-    /// equality can hold by either normalizing the outer or the inner
-    /// associated type. In the old solver, we always structurally relate
-    /// aliases. If we we encounter an occurs check failure, we propagate the
-    /// failure to the outermost alias, for which we then emit a `Projection`
-    /// goal instead.
-    ///
-    /// In the new solver, we rarely get into this state.
-    /// When we encounter aliases we instead attempt to normalize them, and treat
-    /// them as rigid using `ShallowStructurallyRelate`. Only when an alias has
-    /// escaping bound variables do we continue with similar logic to the old
-    /// solver, except now we also explicitly relate the type and consts in the
-    /// arguments of aliases while in this mode.
-    ///
-    /// FIXME: Because we relate the type and consts in the arguments of aliases
-    ///        while in this mode, this is incomplete.
-    IncompletelyRelateAliasArgs,
-    /// During generalization, when we encounter aliases, we will first attempt
-    /// to normalize them when we're using the next trait solver. We can now
-    /// treat the normalized alias as rigid, but only for "one layer", hence
-    /// shallow. New aliases encountered inside the arguments of the outer alias
-    /// should once again be related as normal.
+    IncompletelyRelateHigherRankedAlias,
+    /// Only one layer
     ShallowStructurallyRelateAliases,
-    /// Treat aliases as rigid when relating them.
-    ///
-    /// This corresponds to `relation.structurally_relate_aliases()`.
     StructurallyRelateAliases,
 }
 
@@ -438,10 +400,11 @@ struct Generalizer<'me, 'tcx> {
     /// some other type. What will be the variance at this point?
     ambient_variance: ty::Variance,
 
-    /// This field keeps track of how we treat aliases during generalization.
+    /// This is set once we're generalizing the arguments of an alias.
     ///
-    /// Refer to [`GeneralizerState`]'s docs for more information about the
-    /// all the possible values this can have, and when we use which.
+    /// This is necessary to correctly handle
+    /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
+    /// hold by either normalizing the outer or the inner associated type.
     state: GeneralizerState,
 
     cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizerState), Ty<'tcx>>,
@@ -520,11 +483,11 @@ fn handle_alias_ty(
 
                 return res;
             }
-            GeneralizerState::Default | GeneralizerState::IncompletelyRelateAliasArgs => {}
+            GeneralizerState::Default | GeneralizerState::IncompletelyRelateHigherRankedAlias => {}
         }
 
         let previous_state =
-            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateAliasArgs);
+            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateHigherRankedAlias);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
             Err(e) => match previous_state {
@@ -541,7 +504,7 @@ fn handle_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-                GeneralizerState::IncompletelyRelateAliasArgs => return Err(e),
+                GeneralizerState::IncompletelyRelateHigherRankedAlias => return Err(e),
 
                 // Early return.
                 GeneralizerState::ShallowStructurallyRelateAliases
@@ -650,7 +613,6 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                             // of each other. This is currently only used for diagnostics.
                             // To see why, see the docs in the `type_variables` module.
                             inner.type_variables().sub_unify(vid, new_var_id);
-
                             // If we're in the new solver and create a new inference
                             // variable inside of an alias we eagerly constrain that
                             // inference variable to prevent unexpected ambiguity errors.
@@ -670,13 +632,13 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateAliasArgs => {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
                                         inner.type_variables().equate(vid, new_var_id);
                                     }
-                                    GeneralizerState::Default
-                                    | GeneralizerState::ShallowStructurallyRelateAliases
-                                    | GeneralizerState::StructurallyRelateAliases => {}
                                 }
+                                GeneralizerState::Default
+                                | GeneralizerState::ShallowStructurallyRelateAliases
+                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
 
                             debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
@@ -803,13 +765,13 @@ fn consts(
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateAliasArgs => {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
                                         variable_table.union(vid, new_var_id);
                                     }
-                                    GeneralizerState::Default
-                                    | GeneralizerState::ShallowStructurallyRelateAliases
-                                    | GeneralizerState::StructurallyRelateAliases => {}
                                 }
+                                GeneralizerState::Default
+                                | GeneralizerState::ShallowStructurallyRelateAliases
+                                | GeneralizerState::StructurallyRelateAliases => {}
                             }
                             Ok(ty::Const::new_var(self.cx(), new_var_id))
                         }
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 1f339ea0cabf..0caa8dcbc9c6 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -130,12 +130,7 @@ fn clone(&self) -> Self { *self }
     ) -> Ty<'tcx>;
 }
 
-/// The `try_eagerly_normalize_alias` hook passes an `Infcx` from where it's called (in `rustc_infer`)
-/// to where it's provided (in `rustc_trait_selection`).
-/// Both of those crates have that type available, but `rustc_middle` does not.
-/// Instead we pass this type-erased `Infcx` and transmute on both sides.
-///
-/// Has to be `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
+// `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
 #[repr(transparent)]
 pub struct TypeErasedInfcx<'a, 'tcx> {
     _infcx: *const (),
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index c7699f31a0f9..118bd8c81b1e 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -56,7 +56,8 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     let cause = ObligationCause::dummy_with_span(span);
     let obligation = Obligation::new(
         tcx,
-        cause,
+        // we ignore the error anyway
+        ObligationCause::dummy_with_span(span),
         param_env,
         ty::PredicateKind::AliasRelate(
             alias.to_ty(tcx).into(),
@@ -67,8 +68,7 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
 
     ocx.register_obligation(obligation);
 
-    // We only use this to constrain inference variables.
-    // We don't care if it errors.
+    // This only tries to eagerly resolve, if it errors we don't care.
     let _ = ocx.try_evaluate_obligations();
 
     infcx.resolve_vars_if_possible(infer_term)
diff --git a/tests/ui/impl-trait/unsized_coercion.rs b/tests/ui/impl-trait/unsized_coercion.rs
index f77f2198be0e..6a9a53903fed 100644
--- a/tests/ui/impl-trait/unsized_coercion.rs
+++ b/tests/ui/impl-trait/unsized_coercion.rs
@@ -3,7 +3,8 @@
 
 //@ revisions: next old
 //@[next] compile-flags: -Znext-solver
-//@ check-pass
+//@[old] check-pass
+//@[next] check-pass
 
 trait Trait {}
 

From bd781549f2583d6ae7e141cc6adeff443ec9b02d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0804/1059] Revert "inline into"

This reverts commit 9aa065bc49e5c9a0e07dbfc4bb0823821e5f130d.
---
 .../src/infer/relate/generalize.rs            | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index f3843c371e2c..e1d3f4e6bd48 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -99,10 +99,7 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
             // `?1 <: ?3`.
             let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
                 relation.span(),
-                match relation.structurally_relate_aliases() {
-                    StructurallyRelateAliases::No => GeneralizerState::Default,
-                    StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-                },
+                relation.structurally_relate_aliases().into(),
                 target_vid,
                 instantiation_variance,
                 source_ty,
@@ -239,10 +236,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
         // constants and generic expressions are not yet handled correctly.
         let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
             relation.span(),
-            match relation.structurally_relate_aliases() {
-                StructurallyRelateAliases::No => GeneralizerState::Default,
-                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-            },
+            relation.structurally_relate_aliases().into(),
             target_vid,
             ty::Invariant,
             source_ct,
@@ -365,6 +359,15 @@ enum GeneralizerState {
     StructurallyRelateAliases,
 }
 
+impl From<StructurallyRelateAliases> for GeneralizerState {
+    fn from(structurally_relate_aliases: StructurallyRelateAliases) -> Self {
+        match structurally_relate_aliases {
+            StructurallyRelateAliases::No => GeneralizerState::Default,
+            StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+        }
+    }
+}
+
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to

From e613b82e4eaed11edddfc90024a5e51c807ece42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0805/1059] Revert "bless some tests"

This reverts commit 6edf58fab80d713b5e017d98a57c4075c12b833e.
---
 .../impl-trait/unsized_coercion.next.stderr   | 11 ++++++
 tests/ui/impl-trait/unsized_coercion.rs       |  2 +-
 .../impl-trait/unsized_coercion3.next.stderr  | 36 ++-----------------
 .../impl-trait/unsized_coercion3.old.stderr   |  2 +-
 tests/ui/impl-trait/unsized_coercion3.rs      |  2 --
 ...id-alias-bound-is-not-inherent.next.stderr |  2 +-
 ...rg-type-mismatch-issue-45727.current.fixed |  3 +-
 ...-arg-type-mismatch-issue-45727.next.stderr | 11 ++++--
 .../closure-arg-type-mismatch-issue-45727.rs  |  3 +-
 9 files changed, 30 insertions(+), 42 deletions(-)
 create mode 100644 tests/ui/impl-trait/unsized_coercion.next.stderr

diff --git a/tests/ui/impl-trait/unsized_coercion.next.stderr b/tests/ui/impl-trait/unsized_coercion.next.stderr
new file mode 100644
index 000000000000..bea5ddb0aefc
--- /dev/null
+++ b/tests/ui/impl-trait/unsized_coercion.next.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
+  --> $DIR/unsized_coercion.rs:14:17
+   |
+LL |         let x = hello();
+   |                 ^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `dyn Trait`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/unsized_coercion.rs b/tests/ui/impl-trait/unsized_coercion.rs
index 6a9a53903fed..2cbf0d25d7ec 100644
--- a/tests/ui/impl-trait/unsized_coercion.rs
+++ b/tests/ui/impl-trait/unsized_coercion.rs
@@ -4,7 +4,6 @@
 //@ revisions: next old
 //@[next] compile-flags: -Znext-solver
 //@[old] check-pass
-//@[next] check-pass
 
 trait Trait {}
 
@@ -13,6 +12,7 @@ impl Trait for u32 {}
 fn hello() -> Box<impl Trait> {
     if true {
         let x = hello();
+        //[next]~^ ERROR: the size for values of type `dyn Trait` cannot be known at compilation time
         let y: Box<dyn Trait> = x;
     }
     Box::new(1u32)
diff --git a/tests/ui/impl-trait/unsized_coercion3.next.stderr b/tests/ui/impl-trait/unsized_coercion3.next.stderr
index db758761d795..a480a69a3864 100644
--- a/tests/ui/impl-trait/unsized_coercion3.next.stderr
+++ b/tests/ui/impl-trait/unsized_coercion3.next.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `dyn Send: Trait` is not satisfied
-  --> $DIR/unsized_coercion3.rs:14:17
+  --> $DIR/unsized_coercion3.rs:13:17
    |
 LL |         let x = hello();
    |                 ^^^^^^^ the trait `Trait` is not implemented for `dyn Send`
@@ -9,37 +9,7 @@ help: the trait `Trait` is implemented for `u32`
    |
 LL | impl Trait for u32 {}
    | ^^^^^^^^^^^^^^^^^^
-note: required by a bound in `Box`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
-error[E0308]: mismatched types
-  --> $DIR/unsized_coercion3.rs:19:5
-   |
-LL | fn hello() -> Box<impl Trait + ?Sized> {
-   |               ------------------------
-   |               |   |
-   |               |   the expected opaque type
-   |               expected `Box<impl Trait + ?Sized>` because of return type
-...
-LL |     Box::new(1u32)
-   |     ^^^^^^^^^^^^^^ types differ
-   |
-   = note: expected struct `Box<impl Trait + ?Sized>`
-              found struct `Box<u32>`
+error: aborting due to 1 previous error
 
-error[E0277]: the trait bound `dyn Send: Trait` is not satisfied
-  --> $DIR/unsized_coercion3.rs:11:1
-   |
-LL | fn hello() -> Box<impl Trait + ?Sized> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `dyn Send`
-   |
-help: the trait `Trait` is implemented for `u32`
-  --> $DIR/unsized_coercion3.rs:9:1
-   |
-LL | impl Trait for u32 {}
-   | ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0277, E0308.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/unsized_coercion3.old.stderr b/tests/ui/impl-trait/unsized_coercion3.old.stderr
index 3bb9f9c20951..52a72b84a8dd 100644
--- a/tests/ui/impl-trait/unsized_coercion3.old.stderr
+++ b/tests/ui/impl-trait/unsized_coercion3.old.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the size for values of type `impl Trait + ?Sized` cannot be known at compilation time
-  --> $DIR/unsized_coercion3.rs:16:32
+  --> $DIR/unsized_coercion3.rs:15:32
    |
 LL |         let y: Box<dyn Send> = x;
    |                                ^ doesn't have a size known at compile-time
diff --git a/tests/ui/impl-trait/unsized_coercion3.rs b/tests/ui/impl-trait/unsized_coercion3.rs
index c1dd5350e229..ebfbb2955de5 100644
--- a/tests/ui/impl-trait/unsized_coercion3.rs
+++ b/tests/ui/impl-trait/unsized_coercion3.rs
@@ -9,7 +9,6 @@ trait Trait {}
 impl Trait for u32 {}
 
 fn hello() -> Box<impl Trait + ?Sized> {
-    //[next]~^ ERROR: the trait bound `dyn Send: Trait` is not satisfied
     if true {
         let x = hello();
         //[next]~^ ERROR: the trait bound `dyn Send: Trait` is not satisfied
@@ -17,7 +16,6 @@ fn hello() -> Box<impl Trait + ?Sized> {
         //[old]~^ ERROR: the size for values of type `impl Trait + ?Sized` cannot be know
     }
     Box::new(1u32)
-    //[next]~^ ERROR: mismatched types
 }
 
 fn main() {}
diff --git a/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr b/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
index 4652bf5e3c58..afacb3a7d521 100644
--- a/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
+++ b/tests/ui/methods/rigid-alias-bound-is-not-inherent.next.stderr
@@ -9,7 +9,7 @@ note: candidate #1 is defined in the trait `Trait1`
    |
 LL |     fn method(&self) {
    |     ^^^^^^^^^^^^^^^^
-note: candidate #2 is defined in an impl of the trait `Trait2` for the type `T`
+note: candidate #2 is defined in the trait `Trait2`
   --> $DIR/rigid-alias-bound-is-not-inherent.rs:27:5
    |
 LL |     fn method(&self) {
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
index 1c45a2c0adb3..ba46a447802c 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed
@@ -8,5 +8,6 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
+    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
index 36e49c20c433..7912ed4d7071 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr
@@ -12,6 +12,12 @@ LL |     let _ = (-10..=10).find(|x: i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
+error[E0271]: expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
+  --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:24
+   |
+LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
+   |                        ^^^^ expected `&&i32`, found integer
+
 error[E0277]: expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found `{closure@$DIR/closure-arg-type-mismatch-issue-45727.rs:9:29: 9:40}`
   --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:29
    |
@@ -26,6 +32,7 @@ LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0271, E0277.
+For more information about an error, try `rustc --explain E0271`.
diff --git a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
index 20d6fed3b35b..0fd56707763e 100644
--- a/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
+++ b/tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs
@@ -8,5 +8,6 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
+    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }

From 304a197ba5d18bf837f822f8f9d7a7a3f3e3c897 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0806/1059] Revert "fixup span in obligation cause"

This reverts commit 2d411a0faad447b5bfc968b954fd3e9c10596325.
---
 compiler/rustc_trait_selection/src/solve.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index 118bd8c81b1e..cb0288513903 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -57,7 +57,7 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     let obligation = Obligation::new(
         tcx,
         // we ignore the error anyway
-        ObligationCause::dummy_with_span(span),
+        ObligationCause::dummy(),
         param_env,
         ty::PredicateKind::AliasRelate(
             alias.to_ty(tcx).into(),

From 38cb40091c08bf821745151ab65b3d51e02609b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0807/1059] Revert "try generalizing if normalization isn't a
 tyvar"

This reverts commit e8e3544a71f23606c85e8586e37bd98389bc1ebe.
---
 .../src/infer/relate/generalize.rs            | 113 +++++++++---------
 1 file changed, 55 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index e1d3f4e6bd48..1d4dab001616 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -38,6 +38,31 @@ fn from(value: ty::ConstVid) -> Self {
 }
 
 impl<'tcx> InferCtxt<'tcx> {
+    fn check_generalized_alias_normalizes_to_tyvar<R: PredicateEmittingRelation<Self>>(
+        &self,
+        relation: &mut R,
+        source_ty: Ty<'tcx>,
+    ) -> Option<Ty<'tcx>> {
+        if !self.next_trait_solver()
+            || matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::Yes)
+        {
+            return None;
+        }
+
+        // If we get an alias
+        let ty::Alias(_, alias) = source_ty.kind() else {
+            return None;
+        };
+
+        if alias.has_escaping_bound_vars() {
+            return None;
+        }
+
+        let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
+
+        normalized_alias.is_ty_var().then_some(normalized_alias)
+    }
+
     /// The idea is that we should ensure that the type variable `target_vid`
     /// is equal to, a subtype of, or a supertype of `source_ty`.
     ///
@@ -61,53 +86,31 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
     ) -> RelateResult<'tcx, ()> {
         debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
 
-        let generalized_ty = if self.next_trait_solver()
-            && matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::No)
-            && let ty::Alias(_, alias) = source_ty.kind()
-        {
-            let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
+        let generalized_ty =
+            match self.check_generalized_alias_normalizes_to_tyvar(relation, source_ty) {
+                Some(tyvar) => tyvar,
+                None => {
+                    // Generalize `source_ty` depending on the current variance. As an example, assume
+                    // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+                    // variable.
+                    //
+                    // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+                    // region/type inference variables.
+                    //
+                    // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+                    // `?1 <: ?3`.
+                    let generalizer = self.generalize(
+                        relation.span(),
+                        relation.structurally_relate_aliases(),
+                        target_vid,
+                        instantiation_variance,
+                        source_ty,
+                        &mut |alias| relation.try_eagerly_normalize_alias(alias),
+                    )?;
 
-            if normalized_alias.is_ty_var() {
-                normalized_alias
-            } else {
-                let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
-                    relation.span(),
-                    GeneralizerState::ShallowStructurallyRelateAliases,
-                    target_vid,
-                    instantiation_variance,
-                    normalized_alias,
-                    &mut |alias| relation.try_eagerly_normalize_alias(alias),
-                )?;
-
-                // The only way to get a tyvar back is if the outermost type is an alias.
-                // However, here, though we know it *is* an alias, we initialize the generalizer
-                // with `ShallowStructurallyRelateAliases` so we treat the outermost alias as rigid,
-                // ensuring this is never a tyvar.
-                assert!(!generalized_ty.is_ty_var());
-
-                generalized_ty
-            }
-        } else {
-            // Generalize `source_ty` depending on the current variance. As an example, assume
-            // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
-            // variable.
-            //
-            // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
-            // region/type inference variables.
-            //
-            // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
-            // `?1 <: ?3`.
-            let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
-                relation.span(),
-                relation.structurally_relate_aliases().into(),
-                target_vid,
-                instantiation_variance,
-                source_ty,
-                &mut |alias| relation.try_eagerly_normalize_alias(alias),
-            )?;
-
-            generalized_ty
-        };
+                    generalizer.value_may_be_infer
+                }
+            };
 
         // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
         //
@@ -236,7 +239,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
         // constants and generic expressions are not yet handled correctly.
         let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
             relation.span(),
-            relation.structurally_relate_aliases().into(),
+            relation.structurally_relate_aliases(),
             target_vid,
             ty::Invariant,
             source_ct,
@@ -276,7 +279,7 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
     fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         &self,
         span: Span,
-        initial_state: GeneralizerState,
+        structurally_relate_aliases: StructurallyRelateAliases,
         target_vid: impl Into<TermVid>,
         ambient_variance: ty::Variance,
         source_term: T,
@@ -300,7 +303,10 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            state: initial_state,
+            state: match structurally_relate_aliases {
+                StructurallyRelateAliases::No => GeneralizerState::Default,
+                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+            },
             cache: Default::default(),
             normalize,
         };
@@ -359,15 +365,6 @@ enum GeneralizerState {
     StructurallyRelateAliases,
 }
 
-impl From<StructurallyRelateAliases> for GeneralizerState {
-    fn from(structurally_relate_aliases: StructurallyRelateAliases) -> Self {
-        match structurally_relate_aliases {
-            StructurallyRelateAliases::No => GeneralizerState::Default,
-            StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-        }
-    }
-}
-
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to

From c838deca23cca696e00dd999beca5dedccd41180 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0808/1059] Revert "normalize at the start of generalize if we
 can"

This reverts commit f50591fc1059d98ba57c79094f6e2d46db4b25b6.
---
 .../src/infer/relate/generalize.rs            | 82 ++++++-------------
 .../src/canonical/canonicalizer.rs            |  6 +-
 2 files changed, 26 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 1d4dab001616..d5c0726ed9a8 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -38,31 +38,6 @@ fn from(value: ty::ConstVid) -> Self {
 }
 
 impl<'tcx> InferCtxt<'tcx> {
-    fn check_generalized_alias_normalizes_to_tyvar<R: PredicateEmittingRelation<Self>>(
-        &self,
-        relation: &mut R,
-        source_ty: Ty<'tcx>,
-    ) -> Option<Ty<'tcx>> {
-        if !self.next_trait_solver()
-            || matches!(relation.structurally_relate_aliases(), StructurallyRelateAliases::Yes)
-        {
-            return None;
-        }
-
-        // If we get an alias
-        let ty::Alias(_, alias) = source_ty.kind() else {
-            return None;
-        };
-
-        if alias.has_escaping_bound_vars() {
-            return None;
-        }
-
-        let normalized_alias = relation.try_eagerly_normalize_alias(*alias);
-
-        normalized_alias.is_ty_var().then_some(normalized_alias)
-    }
-
     /// The idea is that we should ensure that the type variable `target_vid`
     /// is equal to, a subtype of, or a supertype of `source_ty`.
     ///
@@ -76,7 +51,7 @@ fn check_generalized_alias_normalizes_to_tyvar<R: PredicateEmittingRelation<Self
     /// `TypeRelation`. Do not use this, and instead please use `At::eq`, for all
     /// other usecases (i.e. setting the value of a type var).
     #[instrument(level = "debug", skip(self, relation))]
-    pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
+    pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
         &self,
         relation: &mut R,
         target_is_expected: bool,
@@ -86,31 +61,30 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
     ) -> RelateResult<'tcx, ()> {
         debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
 
-        let generalized_ty =
-            match self.check_generalized_alias_normalizes_to_tyvar(relation, source_ty) {
-                Some(tyvar) => tyvar,
-                None => {
-                    // Generalize `source_ty` depending on the current variance. As an example, assume
-                    // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
-                    // variable.
-                    //
-                    // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
-                    // region/type inference variables.
-                    //
-                    // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
-                    // `?1 <: ?3`.
-                    let generalizer = self.generalize(
-                        relation.span(),
-                        relation.structurally_relate_aliases(),
-                        target_vid,
-                        instantiation_variance,
-                        source_ty,
-                        &mut |alias| relation.try_eagerly_normalize_alias(alias),
-                    )?;
+        // Generalize `source_ty` depending on the current variance. As an example, assume
+        // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+        // variable.
+        //
+        // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+        // region/type inference variables.
+        //
+        // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+        // `?1 <: ?3`.
+        let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
+            relation.span(),
+            relation.structurally_relate_aliases(),
+            target_vid,
+            instantiation_variance,
+            source_ty,
+            &mut |alias| relation.try_eagerly_normalize_alias(alias),
+        )?;
 
-                    generalizer.value_may_be_infer
-                }
-            };
+        // Constrain `b_vid` to the generalized type `generalized_ty`.
+        if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
+            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
+        } else {
+            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
+        }
 
         // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
         //
@@ -118,10 +92,7 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
         // relations wind up attributed to the same spans. We need
         // to associate causes/spans with each of the relations in
         // the stack to get this right.
-        if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
-            // Constrain `b_vid` to the generalized type variable.
-            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
-
+        if generalized_ty.is_ty_var() {
             // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
             // We can't instantiate `?0` here as that would result in a
             // cyclic type. We instead delay the unification in case
@@ -162,9 +133,6 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<Self>>(
                 }
             }
         } else {
-            // Constrain `b_vid` to the generalized type `generalized_ty`.
-            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
-
             // NOTE: The `instantiation_variance` is not the same variance as
             // used by the relation. When instantiating `b`, `target_is_expected`
             // is flipped and the `instantiation_variance` is also flipped. To
diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
index e469451da993..ce2be24adc58 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
@@ -177,11 +177,7 @@ fn canonicalize_param_env(
                 cache: Default::default(),
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
-            debug_assert!(
-                env_canonicalizer.sub_root_lookup_table.is_empty(),
-                "{:?}",
-                env_canonicalizer.sub_root_lookup_table
-            );
+            debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
             (
                 param_env,
                 env_canonicalizer.variables,

From df0f627bfc983e79a491ea6bf25d138eed668906 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0809/1059] Revert "explicitly provide type in transmute"

This reverts commit 7a123e87b21cd95fef62b80571ee6c644ac3a1c3.
---
 compiler/rustc_infer/src/infer/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index e7082f961d0b..26b094ff8ecc 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1535,8 +1535,7 @@ pub fn try_eagerly_normalize_alias<'a>(
         span: Span,
         alias: ty::AliasTy<'tcx>,
     ) -> Ty<'tcx> {
-        let erased =
-            unsafe { mem::transmute::<&'a InferCtxt<'tcx>, TypeErasedInfcx<'a, 'tcx>>(self) };
+        let erased = unsafe { mem::transmute::<_, TypeErasedInfcx<'a, 'tcx>>(self) };
         self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
     }
 

From e190973e4fae59ad8a851f022be45dcf3a72cce3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0810/1059] Revert "merge generalizer state and structurally
 relate aliases"

This reverts commit 917713b4db3c627f2a35174c09d3ca715dd814b2.
---
 .../src/infer/relate/generalize.rs            | 117 ++++++++++--------
 1 file changed, 64 insertions(+), 53 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index d5c0726ed9a8..34fd32c45bd2 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -267,14 +267,12 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         let mut generalizer = Generalizer {
             infcx: self,
             span,
+            structurally_relate_aliases,
             root_vid,
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            state: match structurally_relate_aliases {
-                StructurallyRelateAliases::No => GeneralizerState::Default,
-                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
-            },
+            state: GeneralizationState::Default,
             cache: Default::default(),
             normalize,
         };
@@ -324,13 +322,10 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-enum GeneralizerState {
-    /// Treat aliases as potentially normalizable.
+enum GeneralizationState {
     Default,
-    IncompletelyRelateHigherRankedAlias,
-    /// Only one layer
-    ShallowStructurallyRelateAliases,
-    StructurallyRelateAliases,
+    InAlias,
+    InNormalizedAlias,
 }
 
 /// The "generalizer" is used when handling inference variables.
@@ -351,6 +346,10 @@ struct Generalizer<'me, 'tcx> {
 
     span: Span,
 
+    /// Whether aliases should be related structurally. If not, we have to
+    /// be careful when generalizing aliases.
+    structurally_relate_aliases: StructurallyRelateAliases,
+
     /// The vid of the type variable that is in the process of being
     /// instantiated. If we find this within the value we are folding,
     /// that means we would have created a cyclic value.
@@ -373,9 +372,10 @@ struct Generalizer<'me, 'tcx> {
     /// This is necessary to correctly handle
     /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
     /// hold by either normalizing the outer or the inner associated type.
-    state: GeneralizerState,
+    // TODO: update doc comment
+    state: GeneralizationState,
 
-    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizerState), Ty<'tcx>>,
+    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizationState), Ty<'tcx>>,
 
     /// Normalize an alias in the trait solver.
     /// If normalization fails, a fresh infer var is returned.
@@ -415,51 +415,44 @@ fn next_ty_var_for_alias(&self) -> Ty<'tcx> {
     ///   continue generalizing the alias. This ends up pulling down the universe of the
     ///   inference variable and is incomplete in case the alias would normalize to a type
     ///   which does not mention that inference variable.
-    fn handle_alias_ty(
+    fn generalize_alias_ty(
         &mut self,
-        alias_ty: Ty<'tcx>,
         alias: ty::AliasTy<'tcx>,
     ) -> Result<Ty<'tcx>, TypeError<'tcx>> {
-        match self.state {
-            GeneralizerState::ShallowStructurallyRelateAliases => {
-                // We can switch back to default, we've treated one layer as rigid by doing this operation.
-                self.state = GeneralizerState::Default;
-                let res = relate::structurally_relate_tys(self, alias_ty, alias_ty);
-                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
-                return res;
+        // We do not eagerly replace aliases with inference variables if they have
+        // escaping bound vars, see the method comment for details. However, when we
+        // are inside of an alias with escaping bound vars replacing nested aliases
+        // with inference variables can cause incorrect ambiguity.
+        //
+        // cc trait-system-refactor-initiative#110
+        if self.infcx.next_trait_solver()
+            && !alias.has_escaping_bound_vars()
+            && match self.state {
+                GeneralizationState::Default => true,
+                GeneralizationState::InAlias => false,
+                // When generalizing an alias after normalizing,
+                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
+                // If we recursively find more aliases, the state should have been set back to InAlias.
+                GeneralizationState::InNormalizedAlias => unreachable!(),
             }
-            GeneralizerState::StructurallyRelateAliases => {
-                return relate::structurally_relate_tys(self, alias_ty, alias_ty);
-            }
-            GeneralizerState::Default
-                if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() =>
-            {
-                // We do not eagerly replace aliases with inference variables if they have
-                // escaping bound vars, see the method comment for details. However, when we
-                // are inside of an alias with escaping bound vars replacing nested aliases
-                // with inference variables can cause incorrect ambiguity.
-                //
-                // cc trait-system-refactor-initiative#110
-                let normalized_alias = (self.normalize)(alias);
+        {
+            let normalized_alias = (self.normalize)(alias);
 
-                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
-                // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
-                let res = self.relate(normalized_alias, normalized_alias);
+            self.state = GeneralizationState::InNormalizedAlias;
+            // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
+            let res = self.relate(normalized_alias, normalized_alias);
 
-                // only one way to get here
-                self.state = GeneralizerState::Default;
+            // only one way to get here
+            self.state = GeneralizationState::Default;
 
-                return res;
-            }
-            GeneralizerState::Default | GeneralizerState::IncompletelyRelateHigherRankedAlias => {}
+            return res;
         }
 
-        let previous_state =
-            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateHigherRankedAlias);
+        let previous_state = mem::replace(&mut self.state, GeneralizationState::InAlias);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
             Err(e) => match previous_state {
-                GeneralizerState::Default => {
+                GeneralizationState::Default => {
                     let mut visitor = MaxUniverse::new();
                     alias.visit_with(&mut visitor);
                     let infer_replacement_is_complete =
@@ -472,11 +465,11 @@ fn handle_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-                GeneralizerState::IncompletelyRelateHigherRankedAlias => return Err(e),
-
-                // Early return.
-                GeneralizerState::ShallowStructurallyRelateAliases
-                | GeneralizerState::StructurallyRelateAliases => unreachable!(),
+                GeneralizationState::InAlias => return Err(e),
+                // When generalizing an alias after normalizing,
+                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
+                // If we recursively find more aliases, the state should have been set back to InAlias.
+                GeneralizationState::InNormalizedAlias => unreachable!(),
             },
         };
         self.state = previous_state;
@@ -600,9 +593,11 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    GeneralizationState::InAlias => {
                                         inner.type_variables().equate(vid, new_var_id);
                                     }
+                                    GeneralizationState::Default
+                                    | GeneralizationState::InNormalizedAlias => {}
                                 }
                                 GeneralizerState::Default
                                 | GeneralizerState::ShallowStructurallyRelateAliases
@@ -635,7 +630,21 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                 }
             }
 
-            ty::Alias(_, data) => self.handle_alias_ty(t, data),
+            ty::Alias(_, data) => match self.structurally_relate_aliases {
+                StructurallyRelateAliases::No => match self.state {
+                    GeneralizationState::Default | GeneralizationState::InAlias => {
+                        self.generalize_alias_ty(data)
+                    }
+                    GeneralizationState::InNormalizedAlias => {
+                        // We can switch back to default, we've treated one layer as rigid by doing this operation.
+                        self.state = GeneralizationState::Default;
+                        let res = relate::structurally_relate_tys(self, t, t);
+                        self.state = GeneralizationState::InNormalizedAlias;
+                        res
+                    }
+                },
+                StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
+            },
 
             _ => relate::structurally_relate_tys(self, t, t),
         }?;
@@ -733,9 +742,11 @@ fn consts(
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
                             {
                                 match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    GeneralizationState::InAlias => {
                                         variable_table.union(vid, new_var_id);
                                     }
+                                    GeneralizationState::Default
+                                    | GeneralizationState::InNormalizedAlias => {}
                                 }
                                 GeneralizerState::Default
                                 | GeneralizerState::ShallowStructurallyRelateAliases

From 4af62bdbac8e27f03c217175aefdd38c1d424e13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0811/1059] Revert "implement eager normalization in a fresh
 context during typeck"

This reverts commit 04f2c0191ebe7a1018e00cf6db5f8394352c2da6.
---
 compiler/rustc_infer/src/infer/at.rs          | 15 +++---
 compiler/rustc_infer/src/infer/mod.rs         | 13 +----
 .../rustc_infer/src/infer/relate/lattice.rs   |  5 +-
 compiler/rustc_interface/src/passes.rs        |  2 +-
 compiler/rustc_middle/src/hooks/mod.rs        | 24 +--------
 compiler/rustc_trait_selection/src/solve.rs   | 54 ++-----------------
 6 files changed, 16 insertions(+), 97 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
index 3487286d5883..84ad05fa8ea2 100644
--- a/compiler/rustc_infer/src/infer/at.rs
+++ b/compiler/rustc_infer/src/infer/at.rs
@@ -140,9 +140,8 @@ pub fn sup<T>(
                 ty::Contravariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -176,9 +175,8 @@ pub fn sub<T>(
                 ty::Covariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -231,9 +229,8 @@ pub fn eq_trace<T>(
                 ty::Invariant,
                 actual,
                 self.cause.span,
-                &mut |alias| {
-                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
-                },
+                // TODO: should normalize
+                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 26b094ff8ecc..10e7b1e72f44 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1,5 +1,5 @@
 use std::cell::{Cell, RefCell};
-use std::{fmt, mem};
+use std::fmt;
 
 pub use at::DefineOpaqueTypes;
 use free_regions::RegionRelations;
@@ -21,7 +21,6 @@
 use rustc_macros::extension;
 pub use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::bug;
-use rustc_middle::hooks::TypeErasedInfcx;
 use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::select;
@@ -1529,16 +1528,6 @@ pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> boo
         }
     }
 
-    pub fn try_eagerly_normalize_alias<'a>(
-        &'a self,
-        param_env: ty::ParamEnv<'tcx>,
-        span: Span,
-        alias: ty::AliasTy<'tcx>,
-    ) -> Ty<'tcx> {
-        let erased = unsafe { mem::transmute::<_, TypeErasedInfcx<'a, 'tcx>>(self) };
-        self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
-    }
-
     /// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
     pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
         debug_assert!(
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index 7e480df7dda6..2cb256b1c63c 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -300,7 +300,8 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
         ))]);
     }
 
-    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        self.infcx.try_eagerly_normalize_alias(self.param_env(), self.span(), alias)
+    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        // TODO: this should actually normalize
+        self.infcx.next_ty_var(self.span())
     }
 }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 28f51095966d..6b7f31521d44 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -904,7 +904,7 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
     rustc_hir_typeck::provide(&mut providers.queries);
     ty::provide(&mut providers.queries);
     traits::provide(&mut providers.queries);
-    solve::provide(providers);
+    solve::provide(&mut providers.queries);
     rustc_passes::provide(&mut providers.queries);
     rustc_traits::provide(&mut providers.queries);
     rustc_ty_utils::provide(&mut providers.queries);
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 0caa8dcbc9c6..691096f4e47c 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -3,16 +3,14 @@
 //! similar to queries, but queries come with a lot of machinery for caching and incremental
 //! compilation, whereas hooks are just plain function pointers without any of the query magic.
 
-use std::marker::PhantomData;
-
 use rustc_hir::def_id::{DefId, DefPathHash};
 use rustc_session::StableCrateId;
 use rustc_span::def_id::{CrateNum, LocalDefId};
-use rustc_span::{ExpnHash, ExpnId, Span};
+use rustc_span::{ExpnHash, ExpnId};
 
+use crate::mir;
 use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex};
 use crate::ty::{Ty, TyCtxt};
-use crate::{mir, ty};
 
 macro_rules! declare_hooks {
     ($($(#[$attr:meta])*hook $name:ident($($arg:ident: $K:ty),*) -> $V:ty;)*) => {
@@ -117,24 +115,6 @@ fn clone(&self) -> Self { *self }
         encoder: &mut CacheEncoder<'_, 'tcx>,
         query_result_index: &mut EncodedDepNodeIndex
     ) -> ();
-
-    /// Tries to normalize an alias, ignoring any errors.
-    ///
-    /// Generalization with the new trait solver calls into this,
-    /// when generalizing outside of the trait solver in `hir_typeck`.
-    hook try_eagerly_normalize_alias(
-        type_erased_infcx: TypeErasedInfcx<'_, 'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
-        span: Span,
-        alias: ty::AliasTy<'tcx>
-    ) -> Ty<'tcx>;
-}
-
-// `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
-#[repr(transparent)]
-pub struct TypeErasedInfcx<'a, 'tcx> {
-    _infcx: *const (),
-    phantom: PhantomData<&'a mut &'tcx ()>,
 }
 
 #[cold]
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index cb0288513903..5d200c4d340b 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -1,8 +1,3 @@
-use std::mem;
-
-use rustc_infer::infer::InferCtxt;
-use rustc_infer::traits::{Obligation, ObligationCause};
-use rustc_middle::hooks::TypeErasedInfcx;
 pub use rustc_next_trait_solver::solve::*;
 
 mod delegate;
@@ -18,13 +13,10 @@
     deeply_normalize, deeply_normalize_with_skipped_universes,
     deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,
 };
-use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_middle::util::Providers;
-use rustc_span::Span;
+use rustc_middle::query::Providers;
+use rustc_middle::ty::TyCtxt;
 pub use select::InferCtxtSelectExt;
 
-use crate::traits::ObligationCtxt;
-
 fn evaluate_root_goal_for_proof_tree_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     canonical_input: CanonicalInput<TyCtxt<'tcx>>,
@@ -35,46 +27,6 @@ fn evaluate_root_goal_for_proof_tree_raw<'tcx>(
     )
 }
 
-fn try_eagerly_normalize_alias<'a, 'tcx>(
-    tcx: TyCtxt<'tcx>,
-    type_erased_infcx: TypeErasedInfcx<'a, 'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    span: Span,
-    alias: ty::AliasTy<'tcx>,
-) -> Ty<'tcx> {
-    let infcx = unsafe {
-        mem::transmute::<TypeErasedInfcx<'a, 'tcx>, &'a InferCtxt<'tcx>>(type_erased_infcx)
-    };
-
-    let ocx = ObligationCtxt::new(infcx);
-
-    let infer_term = infcx.next_ty_var(span);
-
-    // Dummy because we ignore the error anyway.
-    // We do provide a span, because this span is used when registering opaque types.
-    // For example, if we don't provide a span here, some diagnostics talking about TAIT will refer to a dummy span.
-    let cause = ObligationCause::dummy_with_span(span);
-    let obligation = Obligation::new(
-        tcx,
-        // we ignore the error anyway
-        ObligationCause::dummy(),
-        param_env,
-        ty::PredicateKind::AliasRelate(
-            alias.to_ty(tcx).into(),
-            infer_term.into(),
-            ty::AliasRelationDirection::Equate,
-        ),
-    );
-
-    ocx.register_obligation(obligation);
-
-    // This only tries to eagerly resolve, if it errors we don't care.
-    let _ = ocx.try_evaluate_obligations();
-
-    infcx.resolve_vars_if_possible(infer_term)
-}
-
 pub fn provide(providers: &mut Providers) {
-    providers.hooks.try_eagerly_normalize_alias = try_eagerly_normalize_alias;
-    providers.queries.evaluate_root_goal_for_proof_tree_raw = evaluate_root_goal_for_proof_tree_raw;
+    *providers = Providers { evaluate_root_goal_for_proof_tree_raw, ..*providers };
 }

From 632ed108384bff71b7a59883891f39b90aa7d5a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0812/1059] Revert "eagerly normalize during generalization"

This reverts commit 5d0863b147c0a0084dfb15e6435004909363865f.
---
 .../src/type_check/relate_tys.rs              |   5 -
 compiler/rustc_infer/src/infer/at.rs          |   6 -
 .../src/infer/relate/generalize.rs            | 103 ++++--------------
 .../rustc_infer/src/infer/relate/lattice.rs   |   5 -
 .../src/infer/relate/type_relating.rs         |   9 --
 .../src/solve/assembly/structural_traits.rs   |   7 +-
 .../src/solve/eval_ctxt/mod.rs                |  35 +-----
 compiler/rustc_type_ir/src/relate/combine.rs  |   2 -
 .../src/relate/solver_relating.rs             |  49 +++------
 9 files changed, 42 insertions(+), 179 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
index 152a7674490c..e2d684e12a81 100644
--- a/compiler/rustc_borrowck/src/type_check/relate_tys.rs
+++ b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -616,9 +616,4 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             }
         })]);
     }
-
-    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        // Past hir typeck, so we don't have to worry about type inference anymore.
-        self.type_checker.infcx.next_ty_var(self.span())
-    }
 }
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
index 84ad05fa8ea2..70e3d7dc9fef 100644
--- a/compiler/rustc_infer/src/infer/at.rs
+++ b/compiler/rustc_infer/src/infer/at.rs
@@ -140,8 +140,6 @@ pub fn sup<T>(
                 ty::Contravariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -175,8 +173,6 @@ pub fn sub<T>(
                 ty::Covariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -229,8 +225,6 @@ pub fn eq_trace<T>(
                 ty::Invariant,
                 actual,
                 self.cause.span,
-                // TODO: should normalize
-                &mut |_alias| self.infcx.next_ty_var(self.cause.span),
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 34fd32c45bd2..69c090b662e5 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -76,7 +76,6 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
             target_vid,
             instantiation_variance,
             source_ty,
-            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         // Constrain `b_vid` to the generalized type `generalized_ty`.
@@ -211,7 +210,6 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
             target_vid,
             ty::Invariant,
             source_ct,
-            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         debug_assert!(!generalized_ct.is_ct_infer());
@@ -251,7 +249,6 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
         target_vid: impl Into<TermVid>,
         ambient_variance: ty::Variance,
         source_term: T,
-        normalize: &mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
     ) -> RelateResult<'tcx, Generalization<T>> {
         assert!(!source_term.has_escaping_bound_vars());
         let (for_universe, root_vid) = match target_vid.into() {
@@ -272,9 +269,8 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            state: GeneralizationState::Default,
+            in_alias: false,
             cache: Default::default(),
-            normalize,
         };
 
         let value_may_be_infer = generalizer.relate(source_term, source_term)?;
@@ -321,13 +317,6 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-enum GeneralizationState {
-    Default,
-    InAlias,
-    InNormalizedAlias,
-}
-
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to
@@ -372,14 +361,9 @@ struct Generalizer<'me, 'tcx> {
     /// This is necessary to correctly handle
     /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
     /// hold by either normalizing the outer or the inner associated type.
-    // TODO: update doc comment
-    state: GeneralizationState,
+    in_alias: bool,
 
-    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizationState), Ty<'tcx>>,
-
-    /// Normalize an alias in the trait solver.
-    /// If normalization fails, a fresh infer var is returned.
-    normalize: &'me mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
+    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, bool), Ty<'tcx>>,
 }
 
 impl<'tcx> Generalizer<'_, 'tcx> {
@@ -425,34 +409,17 @@ fn generalize_alias_ty(
         // with inference variables can cause incorrect ambiguity.
         //
         // cc trait-system-refactor-initiative#110
-        if self.infcx.next_trait_solver()
-            && !alias.has_escaping_bound_vars()
-            && match self.state {
-                GeneralizationState::Default => true,
-                GeneralizationState::InAlias => false,
-                // When generalizing an alias after normalizing,
-                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
-                // If we recursively find more aliases, the state should have been set back to InAlias.
-                GeneralizationState::InNormalizedAlias => unreachable!(),
-            }
-        {
-            let normalized_alias = (self.normalize)(alias);
-
-            self.state = GeneralizationState::InNormalizedAlias;
-            // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
-            let res = self.relate(normalized_alias, normalized_alias);
-
-            // only one way to get here
-            self.state = GeneralizationState::Default;
-
-            return res;
+        if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
+            return Ok(self.next_ty_var_for_alias());
         }
 
-        let previous_state = mem::replace(&mut self.state, GeneralizationState::InAlias);
+        let is_nested_alias = mem::replace(&mut self.in_alias, true);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
-            Err(e) => match previous_state {
-                GeneralizationState::Default => {
+            Err(e) => {
+                if is_nested_alias {
+                    return Err(e);
+                } else {
                     let mut visitor = MaxUniverse::new();
                     alias.visit_with(&mut visitor);
                     let infer_replacement_is_complete =
@@ -465,14 +432,9 @@ fn generalize_alias_ty(
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-                GeneralizationState::InAlias => return Err(e),
-                // When generalizing an alias after normalizing,
-                // the outer alias should be treated as rigid and we shouldn't try generalizing it again.
-                // If we recursively find more aliases, the state should have been set back to InAlias.
-                GeneralizationState::InNormalizedAlias => unreachable!(),
-            },
+            }
         };
-        self.state = previous_state;
+        self.in_alias = is_nested_alias;
         result
     }
 }
@@ -526,7 +488,7 @@ fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
     fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
         assert_eq!(t, t2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
 
-        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.state)) {
+        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.in_alias)) {
             return Ok(result);
         }
 
@@ -591,17 +553,9 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
                             // cc trait-system-refactor-initiative#108
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
+                                && self.in_alias
                             {
-                                match self.state {
-                                    GeneralizationState::InAlias => {
-                                        inner.type_variables().equate(vid, new_var_id);
-                                    }
-                                    GeneralizationState::Default
-                                    | GeneralizationState::InNormalizedAlias => {}
-                                }
-                                GeneralizerState::Default
-                                | GeneralizerState::ShallowStructurallyRelateAliases
-                                | GeneralizerState::StructurallyRelateAliases => {}
+                                inner.type_variables().equate(vid, new_var_id);
                             }
 
                             debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
@@ -631,25 +585,14 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
             }
 
             ty::Alias(_, data) => match self.structurally_relate_aliases {
-                StructurallyRelateAliases::No => match self.state {
-                    GeneralizationState::Default | GeneralizationState::InAlias => {
-                        self.generalize_alias_ty(data)
-                    }
-                    GeneralizationState::InNormalizedAlias => {
-                        // We can switch back to default, we've treated one layer as rigid by doing this operation.
-                        self.state = GeneralizationState::Default;
-                        let res = relate::structurally_relate_tys(self, t, t);
-                        self.state = GeneralizationState::InNormalizedAlias;
-                        res
-                    }
-                },
+                StructurallyRelateAliases::No => self.generalize_alias_ty(data),
                 StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
             },
 
             _ => relate::structurally_relate_tys(self, t, t),
         }?;
 
-        self.cache.insert((t, self.ambient_variance, self.state), g);
+        self.cache.insert((t, self.ambient_variance, self.in_alias), g);
         Ok(g)
     }
 
@@ -740,17 +683,9 @@ fn consts(
                             // for more details.
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
+                                && self.in_alias
                             {
-                                match self.state {
-                                    GeneralizationState::InAlias => {
-                                        variable_table.union(vid, new_var_id);
-                                    }
-                                    GeneralizationState::Default
-                                    | GeneralizationState::InNormalizedAlias => {}
-                                }
-                                GeneralizerState::Default
-                                | GeneralizerState::ShallowStructurallyRelateAliases
-                                | GeneralizerState::StructurallyRelateAliases => {}
+                                variable_table.union(vid, new_var_id);
                             }
                             Ok(ty::Const::new_var(self.cx(), new_var_id))
                         }
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index 2cb256b1c63c..a05e2d40e829 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -299,9 +299,4 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             ty::AliasRelationDirection::Equate,
         ))]);
     }
-
-    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
-        // TODO: this should actually normalize
-        self.infcx.next_ty_var(self.span())
-    }
 }
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs
index 67f9dc69a4a6..96a0375f5fba 100644
--- a/compiler/rustc_infer/src/infer/relate/type_relating.rs
+++ b/compiler/rustc_infer/src/infer/relate/type_relating.rs
@@ -396,13 +396,4 @@ fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
             }
         })]);
     }
-
-    fn try_eagerly_normalize_alias(
-        &mut self,
-        _alias: rustc_type_ir::AliasTy<<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner>,
-    ) -> <<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner as rustc_type_ir::Interner>::Ty
-    {
-        // We only try to eagerly normalize aliases if we're using the new solver.
-        unreachable!()
-    }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 456fe5246d80..cd74e87b670f 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -987,12 +987,7 @@ fn try_eagerly_replace_alias(
         let replacement = self.ecx.instantiate_binder_with_infer(*replacement);
         self.nested.extend(
             self.ecx
-                .relate_and_get_goals(
-                    self.param_env,
-                    alias_term,
-                    ty::Invariant,
-                    replacement.projection_term,
-                )
+                .eq_and_get_goals(self.param_env, alias_term, replacement.projection_term)
                 .expect("expected to be able to unify goal projection with dyn's projection"),
         );
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index fedb6390d958..6841fe1c5124 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -408,7 +408,7 @@ pub(super) fn ignore_candidate_head_usages(&mut self, usages: CandidateHeadUsage
 
     /// Recursively evaluates `goal`, returning whether any inference vars have
     /// been constrained and the certainty of the result.
-    pub(super) fn evaluate_goal(
+    fn evaluate_goal(
         &mut self,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
@@ -1018,8 +1018,7 @@ pub(super) fn relate<T: Relate<I>>(
         variance: ty::Variance,
         rhs: T,
     ) -> Result<(), NoSolution> {
-        let goals = self.relate_and_get_goals(param_env, lhs, variance, rhs)?;
-
+        let goals = self.delegate.relate(param_env, lhs, variance, rhs, self.origin_span)?;
         for &goal in goals.iter() {
             let source = match goal.predicate.kind().skip_binder() {
                 ty::PredicateKind::Subtype { .. } | ty::PredicateKind::AliasRelate(..) => {
@@ -1040,37 +1039,13 @@ pub(super) fn relate<T: Relate<I>>(
     /// If possible, try using `eq` instead which automatically handles nested
     /// goals correctly.
     #[instrument(level = "trace", skip(self, param_env), ret)]
-    pub(super) fn relate_and_get_goals<T: Relate<I>>(
-        &mut self,
+    pub(super) fn eq_and_get_goals<T: Relate<I>>(
+        &self,
         param_env: I::ParamEnv,
         lhs: T,
-        variance: ty::Variance,
         rhs: T,
     ) -> Result<Vec<Goal<I, I::Predicate>>, NoSolution> {
-        let cx = self.cx();
-        let delegate = self.delegate;
-        let origin_span = self.origin_span;
-
-        let mut normalize = |alias: ty::AliasTy<I>| {
-            let inference_var = self.next_ty_infer();
-
-            let goal = Goal::new(
-                cx,
-                param_env,
-                ty::PredicateKind::AliasRelate(
-                    alias.to_ty(cx).into(),
-                    inference_var.into(),
-                    ty::AliasRelationDirection::Equate,
-                ),
-            );
-
-            // Ignore the result. If we can't eagerly normalize, returning the inference variable is enough.
-            let _ = self.evaluate_goal(GoalSource::TypeRelating, goal, None);
-
-            self.resolve_vars_if_possible(inference_var)
-        };
-
-        Ok(delegate.relate(param_env, lhs, variance, rhs, origin_span, &mut normalize)?)
+        Ok(self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs, self.origin_span)?)
     }
 
     pub(super) fn instantiate_binder_with_infer<T: TypeFoldable<I> + Copy>(
diff --git a/compiler/rustc_type_ir/src/relate/combine.rs b/compiler/rustc_type_ir/src/relate/combine.rs
index 72d54c23733e..64b87fac77f9 100644
--- a/compiler/rustc_type_ir/src/relate/combine.rs
+++ b/compiler/rustc_type_ir/src/relate/combine.rs
@@ -40,8 +40,6 @@ fn register_predicates(
 
     /// Register `AliasRelate` obligation(s) that both types must be related to each other.
     fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty);
-
-    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<I>) -> I::Ty;
 }
 
 pub fn super_combine_tys<Infcx, I, R>(
diff --git a/compiler/rustc_type_ir/src/relate/solver_relating.rs b/compiler/rustc_type_ir/src/relate/solver_relating.rs
index 541b2531fe74..82ee4f75fcb0 100644
--- a/compiler/rustc_type_ir/src/relate/solver_relating.rs
+++ b/compiler/rustc_type_ir/src/relate/solver_relating.rs
@@ -15,7 +15,6 @@ fn relate<T: Relate<Self::Interner>>(
         variance: ty::Variance,
         rhs: T,
         span: <Self::Interner as Interner>::Span,
-        normalize: &mut dyn FnMut(ty::AliasTy<Self::Interner>) -> <Self::Interner as Interner>::Ty,
     ) -> Result<
         Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
         TypeError<Self::Interner>,
@@ -33,46 +32,40 @@ fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
     >;
 }
 
-impl<I: Interner, Infcx: InferCtxtLike<Interner = I>> RelateExt for Infcx {
-    fn relate<T: Relate<I>>(
+impl<Infcx: InferCtxtLike> RelateExt for Infcx {
+    fn relate<T: Relate<Self::Interner>>(
         &self,
-        param_env: I::ParamEnv,
+        param_env: <Self::Interner as Interner>::ParamEnv,
         lhs: T,
         variance: ty::Variance,
         rhs: T,
-        span: I::Span,
-        normalize: &mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
-    ) -> Result<Vec<Goal<I, I::Predicate>>, TypeError<I>> {
-        let mut relate = SolverRelating::new(
-            self,
-            StructurallyRelateAliases::No,
-            variance,
-            param_env,
-            span,
-            normalize,
-        );
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+        TypeError<Self::Interner>,
+    > {
+        let mut relate =
+            SolverRelating::new(self, StructurallyRelateAliases::No, variance, param_env, span);
         relate.relate(lhs, rhs)?;
         Ok(relate.goals)
     }
 
-    fn eq_structurally_relating_aliases<T: Relate<I>>(
+    fn eq_structurally_relating_aliases<T: Relate<Self::Interner>>(
         &self,
-        param_env: I::ParamEnv,
+        param_env: <Self::Interner as Interner>::ParamEnv,
         lhs: T,
         rhs: T,
-        span: I::Span,
-    ) -> Result<Vec<Goal<I, I::Predicate>>, TypeError<I>> {
-        // Structurally relating, we treat aliases as rigid,
-        // so we shouldn't ever try to normalize them.
-        let mut normalize_unreachable = |_alias| unreachable!();
-
+        span: <Self::Interner as Interner>::Span,
+    ) -> Result<
+        Vec<Goal<Self::Interner, <Self::Interner as Interner>::Predicate>>,
+        TypeError<Self::Interner>,
+    > {
         let mut relate = SolverRelating::new(
             self,
             StructurallyRelateAliases::Yes,
             ty::Invariant,
             param_env,
             span,
-            &mut normalize_unreachable,
         );
         relate.relate(lhs, rhs)?;
         Ok(relate.goals)
@@ -82,14 +75,12 @@ fn eq_structurally_relating_aliases<T: Relate<I>>(
 /// Enforce that `a` is equal to or a subtype of `b`.
 pub struct SolverRelating<'infcx, Infcx, I: Interner> {
     infcx: &'infcx Infcx,
-
     // Immutable fields.
     structurally_relate_aliases: StructurallyRelateAliases,
     param_env: I::ParamEnv,
     span: I::Span,
     // Mutable fields.
     ambient_variance: ty::Variance,
-    normalize: &'infcx mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
     goals: Vec<Goal<I, I::Predicate>>,
     /// The cache only tracks the `ambient_variance` as it's the
     /// only field which is mutable and which meaningfully changes
@@ -127,14 +118,12 @@ pub fn new(
         ambient_variance: ty::Variance,
         param_env: I::ParamEnv,
         span: I::Span,
-        normalize: &'infcx mut dyn FnMut(ty::AliasTy<I>) -> I::Ty,
     ) -> Self {
         SolverRelating {
             infcx,
             structurally_relate_aliases,
             span,
             ambient_variance,
-            normalize,
             param_env,
             goals: vec![],
             cache: Default::default(),
@@ -417,8 +406,4 @@ fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty) {
             }
         })]);
     }
-
-    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<I>) -> I::Ty {
-        (self.normalize)(alias)
-    }
 }

From 34a876657558c348388bc20066d32b40a393bc8e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:09:34 +0100
Subject: [PATCH 0813/1059] Revert "Regression test for
 trait-system-refactor#262"

This reverts commit 244b6d5ca8fd6257df414c8b8d48c9c8d26269de.
---
 .../generalize/eagely-normalizing-aliases.rs  | 26 -------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs

diff --git a/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs b/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs
deleted file mode 100644
index 463fe49e5531..000000000000
--- a/tests/ui/traits/next-solver/generalize/eagely-normalizing-aliases.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ revisions: old next
-//@[next] compile-flags: -Znext-solver
-//@ ignore-compare-mode-next-solver (explicit revisions)
-//@ check-pass
-// Regression test for trait-system-refactor-initiative#262
-
-trait View {}
-trait HasAssoc {
-    type Assoc;
-}
-
-struct StableVec<T>(T);
-impl<T> View for StableVec<T> {}
-
-fn assert_view<F: View>(f: F) -> F { f }
-
-
-fn store<T>(x: StableVec<T::Assoc>)
-where
-    T: HasAssoc,
-    StableVec<T>: View,
-{
-    let _: StableVec<T::Assoc> = assert_view(x);
-}
-
-fn main() {}

From e28b48565fcccc43eb6abdf93da1af449815c48f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 23 Mar 2026 12:11:08 +0100
Subject: [PATCH 0814/1059] add regression test

---
 .../constrain-inference-during-normalize.rs   | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 tests/ui/traits/next-solver/generalize/constrain-inference-during-normalize.rs

diff --git a/tests/ui/traits/next-solver/generalize/constrain-inference-during-normalize.rs b/tests/ui/traits/next-solver/generalize/constrain-inference-during-normalize.rs
new file mode 100644
index 000000000000..c3942b008ccb
--- /dev/null
+++ b/tests/ui/traits/next-solver/generalize/constrain-inference-during-normalize.rs
@@ -0,0 +1,25 @@
+// revisions: next old
+//[next] compile-flags: -Znext-solver
+//@ check-pass
+// Regression test for https://github.com/rust-lang/rust/issues/154173.
+// The ICE there was caused by a (flawed) attempt to eagerly normalize during generalization.
+// The normalize would constrain other inference variables, which we couldn't deal with.
+
+trait Trait<T> {
+    type Assoc;
+}
+
+impl Trait<u32> for () {
+    type Assoc = u32;
+}
+
+trait Eq {}
+impl<C: Trait<T>, T> Eq for (C, T, <C as Trait<T>>::Assoc) {}
+fn foo<A>()
+where
+    ((), A, A): Eq
+{}
+
+fn main() {
+    foo::<_>();
+}

From 69fcf2675911b70b969441856c04a3439a419c00 Mon Sep 17 00:00:00 2001
From: WhySoBad <49595640+WhySoBad@users.noreply.github.com>
Date: Sun, 22 Mar 2026 22:11:07 +0100
Subject: [PATCH 0815/1059] Unblock all threads with expired timeouts in single
 scheduler run

---
 src/tools/miri/src/concurrency/thread.rs | 145 +++++++++++------------
 1 file changed, 66 insertions(+), 79 deletions(-)

diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index d6d6449df32b..ee74e0681594 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -656,64 +656,10 @@ fn yield_active_thread(&mut self) {
         // We should only switch stacks between steps.
         self.yield_active_thread = true;
     }
-
-    /// Get the wait time for the next timeout, or `None` if no timeout is pending.
-    fn next_callback_wait_time(&self, clock: &MonotonicClock) -> Option<Duration> {
-        self.threads
-            .iter()
-            .filter_map(|t| {
-                match &t.state {
-                    ThreadState::Blocked { timeout: Some(timeout), .. } =>
-                        Some(timeout.get_wait_time(clock)),
-                    _ => None,
-                }
-            })
-            .min()
-    }
 }
 
 impl<'tcx> EvalContextPrivExt<'tcx> for MiriInterpCx<'tcx> {}
 trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
-    /// Execute a timeout callback on the callback's thread.
-    #[inline]
-    fn run_timeout_callback(&mut self) -> InterpResult<'tcx> {
-        let this = self.eval_context_mut();
-        let mut found_callback = None;
-        // Find a blocked thread that has timed out.
-        for (id, thread) in this.machine.threads.threads.iter_enumerated_mut() {
-            match &thread.state {
-                ThreadState::Blocked { timeout: Some(timeout), .. }
-                    if timeout.get_wait_time(&this.machine.monotonic_clock) == Duration::ZERO =>
-                {
-                    let old_state = mem::replace(&mut thread.state, ThreadState::Enabled);
-                    let ThreadState::Blocked { callback, .. } = old_state else { unreachable!() };
-                    found_callback = Some((id, callback));
-                    // Run the fallback (after the loop because borrow-checking).
-                    break;
-                }
-                _ => {}
-            }
-        }
-        if let Some((thread, callback)) = found_callback {
-            // This back-and-forth with `set_active_thread` is here because of two
-            // design decisions:
-            // 1. Make the caller and not the callback responsible for changing
-            //    thread.
-            // 2. Make the scheduler the only place that can change the active
-            //    thread.
-            let old_thread = this.machine.threads.set_active_thread_id(thread);
-            callback.call(this, UnblockKind::TimedOut)?;
-            this.machine.threads.set_active_thread_id(old_thread);
-        }
-        // found_callback can remain None if the computer's clock
-        // was shifted after calling the scheduler and before the call
-        // to get_ready_callback (see issue
-        // https://github.com/rust-lang/miri/issues/1763). In this case,
-        // just do nothing, which effectively just returns to the
-        // scheduler.
-        interp_ok(())
-    }
-
     #[inline]
     fn run_on_stack_empty(&mut self) -> InterpResult<'tcx, Poll<()>> {
         let this = self.eval_context_mut();
@@ -790,19 +736,12 @@ fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
             this.poll_and_unblock(Some(Duration::ZERO))?;
         }
 
-        let thread_manager = &this.machine.threads;
-        let clock = &this.machine.monotonic_clock;
-
         // We also check timeouts before running any other thread, to ensure that timeouts
         // "in the past" fire before any other thread can take an action. This ensures that for
         // `pthread_cond_timedwait`, "an error is returned if [...] the absolute time specified by
         // abstime has already been passed at the time of the call".
         // <https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cond_timedwait.html>
-        let potential_sleep_time = thread_manager.next_callback_wait_time(clock);
-        if potential_sleep_time == Some(Duration::ZERO) {
-            // The timeout exceeded for some thread so we unblock the thread and execute its timeout callback.
-            this.run_timeout_callback()?;
-        }
+        let potential_sleep_time = this.unblock_expired_timeouts()?;
 
         let thread_manager = &mut this.machine.threads;
         let rng = this.machine.rng.get_mut();
@@ -868,6 +807,71 @@ fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
             throw_machine_stop!(TerminationInfo::GlobalDeadlock);
         }
     }
+
+    /// Poll for I/O events until either an I/O event happened or the timeout expired.
+    /// The different timeout values are described in [`BlockingIoManager::poll`].
+    fn poll_and_unblock(&mut self, timeout: Option<Duration>) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let ready = match this.machine.blocking_io.poll(timeout) {
+            Ok(ready) => ready,
+            // We can ignore errors originating from interrupts; that's just a spurious wakeup.
+            Err(e) if e.kind() == io::ErrorKind::Interrupted => return interp_ok(()),
+            // For other errors we panic. On Linux and BSD hosts this should only be
+            // reachable when a system resource error (e.g. ENOMEM or ENOSPC) occurred.
+            Err(e) => panic!("unexpected error while polling: {e}"),
+        };
+
+        ready.into_iter().try_for_each(|thread_id| this.unblock_thread(thread_id, BlockReason::IO))
+    }
+
+    /// Find all threads with expired timeouts, unblock them and execute their timeout callbacks.
+    ///
+    /// This method returns the minimum duration until the next thread timeout expires.
+    /// If all ready threads have no timeout set, [`None`] is returned.
+    fn unblock_expired_timeouts(&mut self) -> InterpResult<'tcx, Option<Duration>> {
+        let this = self.eval_context_mut();
+        let clock = &this.machine.monotonic_clock;
+
+        let mut min_wait_time = Option::<Duration>::None;
+        let mut callbacks = Vec::new();
+
+        for (id, thread) in this.machine.threads.threads.iter_enumerated_mut() {
+            match &thread.state {
+                ThreadState::Blocked { timeout: Some(timeout), .. } => {
+                    let wait_time = timeout.get_wait_time(clock);
+                    if wait_time.is_zero() {
+                        // The timeout expired for this thread.
+                        let old_state = mem::replace(&mut thread.state, ThreadState::Enabled);
+                        let ThreadState::Blocked { callback, .. } = old_state else {
+                            unreachable!()
+                        };
+                        // Add callback to list to be run after this loop because of borrow-checking.
+                        callbacks.push((id, callback));
+                    } else {
+                        // Update `min_wait_time` to contain the smallest duration until
+                        // the next timeout expires.
+                        min_wait_time = Some(wait_time.min(min_wait_time.unwrap_or(Duration::MAX)));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        for (thread, callback) in callbacks {
+            // This back-and-forth with `set_active_thread` is here because of two
+            // design decisions:
+            // 1. Make the caller and not the callback responsible for changing
+            //    thread.
+            // 2. Make the scheduler the only place that can change the active
+            //    thread.
+            let old_thread = this.machine.threads.set_active_thread_id(thread);
+            callback.call(this, UnblockKind::TimedOut)?;
+            this.machine.threads.set_active_thread_id(old_thread);
+        }
+
+        interp_ok(min_wait_time)
+    }
 }
 
 // Public interface to thread management.
@@ -1348,21 +1352,4 @@ fn run_threads(&mut self) -> InterpResult<'tcx, !> {
             }
         }
     }
-
-    /// Poll for I/O events until either an I/O event happened or the timeout expired.
-    /// The different timeout values are described in [`BlockingIoManager::poll`].
-    fn poll_and_unblock(&mut self, timeout: Option<Duration>) -> InterpResult<'tcx> {
-        let this = self.eval_context_mut();
-
-        let ready = match this.machine.blocking_io.poll(timeout) {
-            Ok(ready) => ready,
-            // We can ignore errors originating from interrupts; that's just a spurious wakeup.
-            Err(e) if e.kind() == io::ErrorKind::Interrupted => return interp_ok(()),
-            // For other errors we panic. On Linux and BSD hosts this should only be
-            // reachable when a system resource error (e.g. ENOMEM or ENOSPC) occurred.
-            Err(e) => panic!("{e}"),
-        };
-
-        ready.into_iter().try_for_each(|thread_id| this.unblock_thread(thread_id, BlockReason::IO))
-    }
 }

From e1e903c7b73b3cd7304ab3ae0e34dbb22bbb75e9 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Mon, 23 Mar 2026 08:14:09 -0400
Subject: [PATCH 0816/1059] Exclude slow tests from miri

---
 library/coretests/tests/char.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/coretests/tests/char.rs b/library/coretests/tests/char.rs
index aa20585953b7..877017f682c9 100644
--- a/library/coretests/tests/char.rs
+++ b/library/coretests/tests/char.rs
@@ -52,6 +52,7 @@ fn test_is_cased() {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
 fn test_char_case() {
     for c in '\0'..='\u{10FFFF}' {
         match c.case() {
@@ -100,6 +101,7 @@ fn titlecase_fast_path() {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
 fn at_most_one_case() {
     for c in '\0'..='\u{10FFFF}' {
         assert_eq!(

From e66f61fe070e741cadba7dc7bb9cbb8548c8e9cd Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 15 Sep 2025 15:27:19 +0800
Subject: [PATCH 0817/1059] Fix indent for trait_impl_redundant_assoc_item

Example
---
```rust
trait Foo {
}
impl Foo for () {
    $0fn foo<T: Copy>(&self);
}
```

**Before this PR**:

```rust
trait Foo {
    fn foo<T>(&self)
where
    T: Copy,;
}
impl Foo for () {
    fn foo<T: Copy>(&self);
}
```

**After this PR**:

```rust
trait Foo {
    fn foo<T>(&self)
    where
        T: Copy,;
}
impl Foo for () {
    fn foo<T: Copy>(&self);
}
```
---
 .../trait_impl_redundant_assoc_item.rs        | 97 +++++++++++++++++--
 .../rust-analyzer/crates/stdx/src/lib.rs      | 19 ++++
 2 files changed, 109 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
index cb3aac3717f8..f4054610f2bd 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/trait_impl_redundant_assoc_item.rs
@@ -6,6 +6,7 @@
     source_change::SourceChangeBuilder,
 };
 use syntax::ToSmolStr;
+use syntax::ast::edit::AstNodeEdit;
 
 use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
 
@@ -23,6 +24,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
 
     let default_range = d.impl_.syntax_node_ptr().text_range();
     let trait_name = d.trait_.name(db).display_no_db(ctx.edition).to_smolstr();
+    let indent_level = d.trait_.source(db).map_or(0, |it| it.value.indent_level().0) + 1;
 
     let (redundant_item_name, diagnostic_range, redundant_item_def) = match assoc_item {
         hir::AssocItem::Function(id) => {
@@ -30,7 +32,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
             (
                 format!("`fn {redundant_assoc_item_name}`"),
                 function.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range),
-                format!("\n    {};", function.display(db, ctx.display_target)),
+                format!("\n{};", function.display(db, ctx.display_target)),
             )
         }
         hir::AssocItem::Const(id) => {
@@ -38,7 +40,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
             (
                 format!("`const {redundant_assoc_item_name}`"),
                 constant.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range),
-                format!("\n    {};", constant.display(db, ctx.display_target)),
+                format!("\n{};", constant.display(db, ctx.display_target)),
             )
         }
         hir::AssocItem::TypeAlias(id) => {
@@ -46,10 +48,8 @@ pub(crate) fn trait_impl_redundant_assoc_item(
             (
                 format!("`type {redundant_assoc_item_name}`"),
                 type_alias.source(db).map(|it| it.syntax().text_range()).unwrap_or(default_range),
-                format!(
-                    "\n    type {};",
-                    type_alias.name(ctx.sema.db).display_no_db(ctx.edition).to_smolstr()
-                ),
+                // FIXME cannot generate generic parameter and bounds
+                format!("\ntype {};", type_alias.name(ctx.sema.db).display_no_db(ctx.edition)),
             )
         }
     };
@@ -65,7 +65,7 @@ pub(crate) fn trait_impl_redundant_assoc_item(
     .with_fixes(quickfix_for_redundant_assoc_item(
         ctx,
         d,
-        redundant_item_def,
+        stdx::indent_string(&redundant_item_def, indent_level),
         diagnostic_range,
     ))
 }
@@ -191,6 +191,89 @@ impl Marker for Foo {
         )
     }
 
+    #[test]
+    fn quickfix_indentations() {
+        check_fix(
+            r#"
+mod indent {
+    trait Marker {
+        fn boo();
+    }
+    struct Foo;
+    impl Marker for Foo {
+        fn$0 bar<T: Copy>(_a: i32, _b: T) -> String {}
+        fn boo() {}
+    }
+}
+            "#,
+            r#"
+mod indent {
+    trait Marker {
+        fn bar<T>(_a: i32, _b: T) -> String
+        where
+            T: Copy,;
+        fn boo();
+    }
+    struct Foo;
+    impl Marker for Foo {
+        fn bar<T: Copy>(_a: i32, _b: T) -> String {}
+        fn boo() {}
+    }
+}
+            "#,
+        );
+
+        check_fix(
+            r#"
+mod indent {
+    trait Marker {
+        fn foo () {}
+    }
+    struct Foo;
+    impl Marker for Foo {
+        const FLAG: bool$0 = false;
+    }
+}
+            "#,
+            r#"
+mod indent {
+    trait Marker {
+        const FLAG: bool;
+        fn foo () {}
+    }
+    struct Foo;
+    impl Marker for Foo {
+        const FLAG: bool = false;
+    }
+}
+            "#,
+        );
+
+        check_fix(
+            r#"
+mod indent {
+    trait Marker {
+    }
+    struct Foo;
+    impl Marker for Foo {
+        type T = i32;$0
+    }
+}
+            "#,
+            r#"
+mod indent {
+    trait Marker {
+        type T;
+    }
+    struct Foo;
+    impl Marker for Foo {
+        type T = i32;
+    }
+}
+            "#,
+        );
+    }
+
     #[test]
     fn quickfix_dont_work() {
         check_no_fix(
diff --git a/src/tools/rust-analyzer/crates/stdx/src/lib.rs b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
index a1af4cc6be5c..275e0e5ac8db 100644
--- a/src/tools/rust-analyzer/crates/stdx/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
@@ -1,5 +1,6 @@
 //! Missing batteries for standard libraries.
 
+use std::borrow::Cow;
 use std::io as sio;
 use std::process::Command;
 use std::{cmp::Ordering, ops, time::Instant};
@@ -250,6 +251,24 @@ pub fn dedent_by(spaces: usize, text: &str) -> String {
         .collect()
 }
 
+/// Indent non empty lines, including the first line
+#[must_use]
+pub fn indent_string(s: &str, indent_level: u8) -> String {
+    if indent_level == 0 || s.is_empty() {
+        return s.to_owned();
+    }
+    let indent_str = "    ".repeat(indent_level as usize);
+    s.split_inclusive("\n")
+        .map(|line| {
+            if line.trim_end().is_empty() {
+                Cow::Borrowed(line)
+            } else {
+                format!("{indent_str}{line}").into()
+            }
+        })
+        .collect()
+}
+
 pub fn equal_range_by<T, F>(slice: &[T], mut key: F) -> ops::Range<usize>
 where
     F: FnMut(&T) -> Ordering,

From 34ef9a6146a26d3c3cfef42202b0f1d6dd2fe053 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 24 Feb 2026 09:08:12 +0100
Subject: [PATCH 0818/1059] Remove `ATTRIBUTE_ORDER`

---
 .../src/attributes/autodiff.rs                |  3 +-
 .../src/attributes/cfi_encoding.rs            |  1 -
 .../src/attributes/codegen_attrs.rs           |  7 ---
 .../src/attributes/crate_level.rs             |  6 ---
 .../src/attributes/deprecation.rs             |  1 -
 .../attributes/diagnostic/do_not_recommend.rs |  3 +-
 .../src/attributes/dummy.rs                   |  3 +-
 .../src/attributes/inline.rs                  |  2 -
 .../src/attributes/instruction_set.rs         |  1 -
 .../src/attributes/link_attrs.rs              |  5 --
 .../src/attributes/macro_attrs.rs             |  2 -
 .../rustc_attr_parsing/src/attributes/mod.rs  | 54 ++-----------------
 .../src/attributes/must_not_suspend.rs        |  1 -
 .../src/attributes/must_use.rs                |  1 -
 .../rustc_attr_parsing/src/attributes/path.rs |  1 -
 .../src/attributes/prelude.rs                 |  4 +-
 .../src/attributes/proc_macro_attrs.rs        |  2 -
 .../src/attributes/prototype.rs               |  4 +-
 .../src/attributes/rustc_allocator.rs         |  1 -
 .../src/attributes/rustc_internal.rs          | 17 ------
 .../src/attributes/test_attrs.rs              |  6 ---
 .../src/attributes/traits.rs                  |  5 +-
 .../src/attributes/transparency.rs            |  1 -
 tests/ui/coverage-attr/bad-syntax.rs          |  6 +--
 tests/ui/coverage-attr/bad-syntax.stderr      | 18 +++----
 tests/ui/lint/unused/unused-attr-duplicate.rs | 12 ++---
 .../lint/unused/unused-attr-duplicate.stderr  | 42 +++++++--------
 tests/ui/sanitize-attr/invalid-sanitize.rs    |  6 +--
 .../ui/sanitize-attr/invalid-sanitize.stderr  | 18 +++----
 29 files changed, 63 insertions(+), 170 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/autodiff.rs b/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
index 118a4103b1a9..c512250a83fa 100644
--- a/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/autodiff.rs
@@ -9,7 +9,7 @@
 use thin_vec::ThinVec;
 
 use crate::attributes::prelude::Allow;
-use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::attributes::{OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::{ArgParser, MetaItemOrLitParser};
 use crate::target_checking::AllowedTargets;
@@ -18,7 +18,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
     const PATH: &[Symbol] = &[sym::rustc_autodiff];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs b/compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs
index df1e569743c0..339697649164 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs
@@ -8,7 +8,6 @@ impl<S: Stage> SingleAttributeParser<S> for CfiEncodingParser {
         Allow(Target::Enum),
         Allow(Target::Union),
     ]);
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "encoding");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 652a783de322..7a748d7627cb 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -12,7 +12,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for OptimizeParser {
     const PATH: &[Symbol] = &[sym::optimize];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
@@ -68,7 +67,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for ColdParser {
 
 impl<S: Stage> SingleAttributeParser<S> for CoverageParser {
     const PATH: &[Symbol] = &[sym::coverage];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
@@ -119,7 +117,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     const PATH: &[rustc_span::Symbol] = &[sym::export_name];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Static),
@@ -157,7 +154,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcObjcClassParser {
     const PATH: &[rustc_span::Symbol] = &[sym::rustc_objc_class];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowList(&[Allow(Target::ForeignStatic)]);
@@ -189,7 +185,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcObjcSelectorParser {
     const PATH: &[rustc_span::Symbol] = &[sym::rustc_objc_selector];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowList(&[Allow(Target::ForeignStatic)]);
@@ -595,7 +590,6 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
         r#"realtime = "nonblocking|blocking|caller""#,
     ]);
 
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
@@ -724,7 +718,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcEiiForeignItemParser {
 impl<S: Stage> SingleAttributeParser<S> for PatchableFunctionEntryParser {
     const PATH: &[Symbol] = &[sym::patchable_function_entry];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
     const TEMPLATE: AttributeTemplate = template!(List: &["prefix_nops = m, entry_nops = n"]);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 2d2994c02cd6..72a0945a4199 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -10,7 +10,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     const PATH: &[Symbol] = &[sym::crate_name];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
@@ -84,7 +83,6 @@ fn extend(
 
 impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
     const PATH: &[Symbol] = &[sym::recursion_limit];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
@@ -107,7 +105,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
     const PATH: &[Symbol] = &[sym::move_size_limit];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
@@ -130,7 +127,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
     const PATH: &[Symbol] = &[sym::type_length_limit];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
@@ -153,7 +149,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
     const PATH: &[Symbol] = &[sym::pattern_complexity_limit];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
@@ -213,7 +208,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcCoherenceIsCoreParser {
 impl<S: Stage> SingleAttributeParser<S> for WindowsSubsystemParser {
     const PATH: &[Symbol] = &[sym::windows_subsystem];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: ["windows", "console"], "https://doc.rust-lang.org/reference/runtime.html#the-windows_subsystem-attribute");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
index a2c7e459e0df..804b54e9ee25 100644
--- a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
@@ -34,7 +34,6 @@ fn get<S: Stage>(
 pub(crate) struct DeprecatedParser;
 impl<S: Stage> SingleAttributeParser<S> for DeprecatedParser {
     const PATH: &[Symbol] = &[sym::deprecated];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::Fn),
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/do_not_recommend.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/do_not_recommend.rs
index 4a89cf6515ce..9f3d1e29b4de 100644
--- a/compiler/rustc_attr_parsing/src/attributes/diagnostic/do_not_recommend.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/diagnostic/do_not_recommend.rs
@@ -4,7 +4,7 @@
 use rustc_session::lint::builtin::MALFORMED_DIAGNOSTIC_ATTRIBUTES;
 use rustc_span::{Symbol, sym};
 
-use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::attributes::{OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 use crate::target_checking::{ALL_TARGETS, AllowedTargets};
@@ -12,7 +12,6 @@
 pub(crate) struct DoNotRecommendParser;
 impl<S: Stage> SingleAttributeParser<S> for DoNotRecommendParser {
     const PATH: &[Symbol] = &[sym::diagnostic, sym::do_not_recommend];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); // Checked in check_attr.
     const TEMPLATE: AttributeTemplate = template!(Word /*doesn't matter */);
diff --git a/compiler/rustc_attr_parsing/src/attributes/dummy.rs b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
index 71d10b23a37f..ee5c507b6292 100644
--- a/compiler/rustc_attr_parsing/src/attributes/dummy.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
@@ -2,7 +2,7 @@
 use rustc_hir::attrs::AttributeKind;
 use rustc_span::{Symbol, sym};
 
-use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::attributes::{OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 use crate::target_checking::{ALL_TARGETS, AllowedTargets};
@@ -10,7 +10,6 @@
 pub(crate) struct RustcDummyParser;
 impl<S: Stage> SingleAttributeParser<S> for RustcDummyParser {
     const PATH: &[Symbol] = &[sym::rustc_dummy];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
     const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really
diff --git a/compiler/rustc_attr_parsing/src/attributes/inline.rs b/compiler/rustc_attr_parsing/src/attributes/inline.rs
index 767200bfa9bf..82cec25c997c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/inline.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/inline.rs
@@ -11,7 +11,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for InlineParser {
     const PATH: &[Symbol] = &[sym::inline];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
@@ -68,7 +67,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcForceInlineParser {
     const PATH: &[Symbol] = &[sym::rustc_force_inline];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
diff --git a/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs b/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs
index 3be9b9ded9c1..5f6108108a77 100644
--- a/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs
@@ -16,7 +16,6 @@ impl<S: Stage> SingleAttributeParser<S> for InstructionSetParser {
     ]);
     const TEMPLATE: AttributeTemplate = template!(List: &["set"], "https://doc.rust-lang.org/reference/attributes/codegen.html#the-instruction_set-attribute");
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         const POSSIBLE_SYMBOLS: &[Symbol] = &[sym::arm_a32, sym::arm_t32];
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index c4a483157a19..52ab4ac8a449 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -22,7 +22,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for LinkNameParser {
     const PATH: &[Symbol] = &[sym::link_name];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::ForeignFn),
@@ -466,7 +465,6 @@ fn parse_link_import_name_type<S: Stage>(
 
 impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::Static),
@@ -541,7 +539,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcStdInternalSymbolParser {
 
 impl<S: Stage> SingleAttributeParser<S> for LinkOrdinalParser {
     const PATH: &[Symbol] = &[sym::link_ordinal];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::ForeignFn),
@@ -583,8 +580,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 impl<S: Stage> SingleAttributeParser<S> for LinkageParser {
     const PATH: &[Symbol] = &[sym::linkage];
 
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
-
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
diff --git a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
index 00d40687fc85..86dde5b108ff 100644
--- a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
@@ -130,7 +130,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for AllowInternalUnsafeParser {
 
 impl<S: Stage> SingleAttributeParser<S> for MacroExportParser {
     const PATH: &[Symbol] = &[sym::macro_export];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["local_inner_macros"]);
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
@@ -168,7 +167,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for CollapseDebugInfoParser {
     const PATH: &[Symbol] = &[sym::collapse_debuginfo];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(
         List: &["no", "external", "yes"],
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index 223c88972d75..67147642921c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -124,14 +124,8 @@ pub(crate) trait SingleAttributeParser<S: Stage>: 'static {
     /// If you need the parser to accept more than one path, use [`AttributeParser`] instead
     const PATH: &[Symbol];
 
-    /// Configures the precedence of attributes with the same `PATH` on a syntax node.
-    const ATTRIBUTE_ORDER: AttributeOrder;
-
     /// Configures what to do when when the same attribute is
     /// applied more than once on the same syntax node.
-    ///
-    /// [`ATTRIBUTE_ORDER`](Self::ATTRIBUTE_ORDER) specified which one is assumed to be correct,
-    /// and this specified whether to, for example, warn or error on the other one.
     const ON_DUPLICATE: OnDuplicate<S>;
 
     const ALLOWED_TARGETS: AllowedTargets;
@@ -162,21 +156,8 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
         <T as SingleAttributeParser<S>>::TEMPLATE,
         |group: &mut Single<T, S>, cx, args| {
             if let Some(pa) = T::convert(cx, args) {
-                match T::ATTRIBUTE_ORDER {
-                    // keep the first and report immediately. ignore this attribute
-                    AttributeOrder::KeepInnermost => {
-                        if let Some((_, unused)) = group.1 {
-                            T::ON_DUPLICATE.exec::<T>(cx, cx.attr_span, unused);
-                            return;
-                        }
-                    }
-                    // keep the new one and warn about the previous,
-                    // then replace
-                    AttributeOrder::KeepOutermost => {
-                        if let Some((_, used)) = group.1 {
-                            T::ON_DUPLICATE.exec::<T>(cx, used, cx.attr_span);
-                        }
-                    }
+                if let Some((_, used)) = group.1 {
+                    T::ON_DUPLICATE.exec::<T>(cx, used, cx.attr_span);
                 }
 
                 group.1 = Some((pa, cx.attr_span));
@@ -206,7 +187,7 @@ pub(crate) enum OnDuplicate<S: Stage> {
     /// Custom function called when a duplicate attribute is found.
     ///
     /// - `unused` is the span of the attribute that was unused or bad because of some
-    ///   duplicate reason (see [`AttributeOrder`])
+    ///   duplicate reason
     /// - `used` is the span of the attribute that was used in favor of the unused attribute
     Custom(fn(cx: &AcceptContext<'_, '_, S>, used: Span, unused: Span)),
 }
@@ -223,8 +204,8 @@ fn exec<P: SingleAttributeParser<S>>(
             OnDuplicate::WarnButFutureError => cx.warn_unused_duplicate_future_error(used, unused),
             OnDuplicate::Error => {
                 cx.emit_err(UnusedMultiple {
-                    this: used,
-                    other: unused,
+                    this: unused,
+                    other: used,
                     name: Symbol::intern(
                         &P::PATH.into_iter().map(|i| i.to_string()).collect::<Vec<_>>().join(".."),
                     ),
@@ -236,30 +217,6 @@ fn exec<P: SingleAttributeParser<S>>(
     }
 }
 
-pub(crate) enum AttributeOrder {
-    /// Duplicates after the innermost instance of the attribute will be an error/warning.
-    /// Only keep the lowest attribute.
-    ///
-    /// Attributes are processed from bottom to top, so this raises a warning/error on all the attributes
-    /// further above the lowest one:
-    /// ```
-    /// #[stable(since="1.0")] //~ WARNING duplicated attribute
-    /// #[stable(since="2.0")]
-    /// ```
-    KeepInnermost,
-
-    /// Duplicates before the outermost instance of the attribute will be an error/warning.
-    /// Only keep the highest attribute.
-    ///
-    /// Attributes are processed from bottom to top, so this raises a warning/error on all the attributes
-    /// below the highest one:
-    /// ```
-    /// #[path="foo.rs"]
-    /// #[path="bar.rs"] //~ WARNING duplicated attribute
-    /// ```
-    KeepOutermost,
-}
-
 /// An even simpler version of [`SingleAttributeParser`]:
 /// now automatically check that there are no arguments provided to the attribute.
 ///
@@ -284,7 +241,6 @@ fn default() -> Self {
 
 impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for WithoutArgs<T, S> {
     const PATH: &[Symbol] = T::PATH;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = T::ON_DUPLICATE;
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
     const TEMPLATE: AttributeTemplate = template!(Word);
diff --git a/compiler/rustc_attr_parsing/src/attributes/must_not_suspend.rs b/compiler/rustc_attr_parsing/src/attributes/must_not_suspend.rs
index 8456ce797758..7f37210b8c8a 100644
--- a/compiler/rustc_attr_parsing/src/attributes/must_not_suspend.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/must_not_suspend.rs
@@ -4,7 +4,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for MustNotSuspendParser {
     const PATH: &[rustc_span::Symbol] = &[sym::must_not_suspend];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Struct),
diff --git a/compiler/rustc_attr_parsing/src/attributes/must_use.rs b/compiler/rustc_attr_parsing/src/attributes/must_use.rs
index 673e2c902da0..f1ce810f4eae 100644
--- a/compiler/rustc_attr_parsing/src/attributes/must_use.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/must_use.rs
@@ -4,7 +4,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for MustUseParser {
     const PATH: &[Symbol] = &[sym::must_use];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::Fn),
diff --git a/compiler/rustc_attr_parsing/src/attributes/path.rs b/compiler/rustc_attr_parsing/src/attributes/path.rs
index b60f8e315e5e..6b5eee7f31bb 100644
--- a/compiler/rustc_attr_parsing/src/attributes/path.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/path.rs
@@ -4,7 +4,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for PathParser {
     const PATH: &[Symbol] = &[sym::path];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowListWarnRest(&[Allow(Target::Mod), Error(Target::Crate)]);
diff --git a/compiler/rustc_attr_parsing/src/attributes/prelude.rs b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
index 65c408fa6358..53adf7e31eb7 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prelude.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
@@ -12,8 +12,8 @@
 
 #[doc(hidden)]
 pub(super) use crate::attributes::{
-    AcceptMapping, AttributeOrder, AttributeParser, CombineAttributeParser, ConvertFn,
-    NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
+    AcceptMapping, AttributeParser, CombineAttributeParser, ConvertFn, NoArgsAttributeParser,
+    OnDuplicate, SingleAttributeParser,
 };
 // contexts
 #[doc(hidden)]
diff --git a/compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs
index f9ace7e25d1b..aca0e94cff06 100644
--- a/compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs
@@ -25,7 +25,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroAttributeParser {
 pub(crate) struct ProcMacroDeriveParser;
 impl<S: Stage> SingleAttributeParser<S> for ProcMacroDeriveParser {
     const PATH: &[Symbol] = &[sym::proc_macro_derive];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = PROC_MACRO_ALLOWED_TARGETS;
     const TEMPLATE: AttributeTemplate = template!(
@@ -46,7 +45,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 pub(crate) struct RustcBuiltinMacroParser;
 impl<S: Stage> SingleAttributeParser<S> for RustcBuiltinMacroParser {
     const PATH: &[Symbol] = &[sym::rustc_builtin_macro];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::MacroDef)]);
     const TEMPLATE: AttributeTemplate =
diff --git a/compiler/rustc_attr_parsing/src/attributes/prototype.rs b/compiler/rustc_attr_parsing/src/attributes/prototype.rs
index 8eb902be34e2..15d9d3453738 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prototype.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prototype.rs
@@ -5,7 +5,7 @@
 use rustc_hir::attrs::{AttributeKind, MirDialect, MirPhase};
 use rustc_span::{Span, Symbol, sym};
 
-use super::{AttributeOrder, OnDuplicate};
+use super::OnDuplicate;
 use crate::attributes::SingleAttributeParser;
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
@@ -18,8 +18,6 @@
 impl<S: Stage> SingleAttributeParser<S> for CustomMirParser {
     const PATH: &[rustc_span::Symbol] = &[sym::custom_mir];
 
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
-
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
 
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_allocator.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_allocator.rs
index 5782f9473a99..e809ad9ed83b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_allocator.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_allocator.rs
@@ -28,7 +28,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAllocatorZeroedVariantParser {
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowList(&[Allow(Target::Fn), Allow(Target::ForeignFn)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "function");
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(name) = args.name_value().and_then(NameValueParser::value_as_str) else {
             cx.expected_name_value(cx.attr_span, None);
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
index e8b4cb343794..15772d874507 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -31,7 +31,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcMustImplementOneOfParser {
     const PATH: &[Symbol] = &[sym::rustc_must_implement_one_of];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Trait)]);
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const TEMPLATE: AttributeTemplate = template!(List: &["function1, function2, ..."]);
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(list) = args.list() else {
@@ -105,7 +104,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcNoImplicitAutorefsParser {
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStartParser {
     const PATH: &[Symbol] = &[sym::rustc_layout_scalar_valid_range_start];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const TEMPLATE: AttributeTemplate = template!(List: &["start"]);
@@ -120,7 +118,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEndParser {
     const PATH: &[Symbol] = &[sym::rustc_layout_scalar_valid_range_end];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const TEMPLATE: AttributeTemplate = template!(List: &["end"]);
@@ -135,7 +132,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLegacyConstGenericsParser {
     const PATH: &[Symbol] = &[sym::rustc_legacy_const_generics];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
     const TEMPLATE: AttributeTemplate = template!(List: &["N"]);
@@ -193,7 +189,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcInheritOverflowChecksParser {
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLintOptDenyFieldAccessParser {
     const PATH: &[Symbol] = &[sym::rustc_lint_opt_deny_field_access];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Field)]);
     const TEMPLATE: AttributeTemplate = template!(Word);
@@ -373,7 +368,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcDeprecatedSafe2024Parser {
         Allow(Target::Method(MethodKind::Trait { body: true })),
         Allow(Target::Method(MethodKind::TraitImpl)),
     ]);
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const TEMPLATE: AttributeTemplate = template!(List: &[r#"audit_that = "...""#]);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
@@ -441,7 +435,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcNeverTypeOptionsParser {
     const PATH: &[Symbol] = &[sym::rustc_never_type_options];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const TEMPLATE: AttributeTemplate = template!(List: &[
         r#"fallback = "unit", "never", "no""#,
         r#"diverging_block_default = "unit", "never""#,
@@ -592,7 +585,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcLintUntrackedQueryInformationPa
 
 impl<S: Stage> SingleAttributeParser<S> for RustcSimdMonomorphizeLaneLimitParser {
     const PATH: &[Symbol] = &[sym::rustc_simd_monomorphize_lane_limit];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
@@ -610,7 +602,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcScalableVectorParser {
     const PATH: &[Symbol] = &[sym::rustc_scalable_vector];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["count"]);
@@ -636,7 +627,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for LangParser {
     const PATH: &[Symbol] = &[sym::lang];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); // Targets are checked per lang item in `rustc_passes`
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
@@ -981,8 +971,6 @@ fn extend(
 impl<S: Stage> SingleAttributeParser<S> for RustcIfThisChangedParser {
     const PATH: &[Symbol] = &[sym::rustc_if_this_changed];
 
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
-
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
 
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
@@ -1147,7 +1135,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcEffectiveVisibilityParser {
 
 impl<S: Stage> SingleAttributeParser<S> for RustcDiagnosticItemParser {
     const PATH: &[Symbol] = &[sym::rustc_diagnostic_item];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Trait),
@@ -1220,7 +1207,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcSymbolNameParser {
         Allow(Target::Impl { of_trait: false }),
     ]);
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const TEMPLATE: AttributeTemplate = template!(Word);
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         if let Err(span) = args.no_args() {
@@ -1245,7 +1231,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcDefPathParser {
         Allow(Target::Impl { of_trait: false }),
     ]);
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const TEMPLATE: AttributeTemplate = template!(Word);
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         if let Err(span) = args.no_args() {
@@ -1275,7 +1260,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcStrictCoherenceParser {
 
 impl<S: Stage> SingleAttributeParser<S> for RustcReservationImplParser {
     const PATH: &[Symbol] = &[sym::rustc_reservation_impl];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowList(&[Allow(Target::Impl { of_trait: true })]);
@@ -1311,7 +1295,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for PreludeImportParser {
 impl<S: Stage> SingleAttributeParser<S> for RustcDocPrimitiveParser {
     const PATH: &[Symbol] = &[sym::rustc_doc_primitive];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Mod)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "primitive name");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
index 2775eab1b5d9..db0350f23246 100644
--- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
@@ -7,7 +7,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for IgnoreParser {
     const PATH: &[Symbol] = &[sym::ignore];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowListWarnRest(&[Allow(Target::Fn), Error(Target::WherePredicate)]);
@@ -41,7 +40,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for ShouldPanicParser {
     const PATH: &[Symbol] = &[sym::should_panic];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const ALLOWED_TARGETS: AllowedTargets =
         AllowedTargets::AllowListWarnRest(&[Allow(Target::Fn), Error(Target::WherePredicate)]);
@@ -98,7 +96,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 impl<S: Stage> SingleAttributeParser<S> for ReexportTestHarnessMainParser {
     const PATH: &[Symbol] = &[sym::reexport_test_harness_main];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
@@ -126,7 +123,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAbiParser {
     const PATH: &[Symbol] = &[sym::rustc_abi];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const TEMPLATE: AttributeTemplate = template!(OneOf: &[sym::debug, sym::assert_eq]);
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::TyAlias),
         Allow(Target::Fn),
@@ -197,7 +193,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcEvaluateWhereClausesParser {
 
 impl<S: Stage> SingleAttributeParser<S> for TestRunnerParser {
     const PATH: &[Symbol] = &[sym::test_runner];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const TEMPLATE: AttributeTemplate = template!(List: &["path"]);
@@ -226,7 +221,6 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 
 impl<S: Stage> SingleAttributeParser<S> for RustcTestMarkerParser {
     const PATH: &[Symbol] = &[sym::rustc_test_marker];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Const),
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index c09e151fc70c..c418d1d032c4 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -1,9 +1,7 @@
 use std::mem;
 
 use super::prelude::*;
-use crate::attributes::{
-    AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
-};
+use crate::attributes::{NoArgsAttributeParser, OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 use crate::target_checking::Policy::{Allow, Warn};
@@ -12,7 +10,6 @@
 pub(crate) struct RustcSkipDuringMethodDispatchParser;
 impl<S: Stage> SingleAttributeParser<S> for RustcSkipDuringMethodDispatchParser {
     const PATH: &[Symbol] = &[sym::rustc_skip_during_method_dispatch];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Trait)]);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/transparency.rs b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
index 58b4a0b2fb1a..c3817406c980 100644
--- a/compiler/rustc_attr_parsing/src/attributes/transparency.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
@@ -6,7 +6,6 @@
 
 impl<S: Stage> SingleAttributeParser<S> for RustcMacroTransparencyParser {
     const PATH: &[Symbol] = &[sym::rustc_macro_transparency];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Custom(|cx, used, unused| {
         cx.dcx().span_err(vec![used, unused], "multiple macro transparency attributes");
     });
diff --git a/tests/ui/coverage-attr/bad-syntax.rs b/tests/ui/coverage-attr/bad-syntax.rs
index 062e82ee4b61..ef7b41db3440 100644
--- a/tests/ui/coverage-attr/bad-syntax.rs
+++ b/tests/ui/coverage-attr/bad-syntax.rs
@@ -6,12 +6,12 @@
 // Tests the error messages produced (or not produced) by various unusual
 // uses of the `#[coverage(..)]` attribute.
 
-#[coverage(off)] //~ ERROR multiple `coverage` attributes
 #[coverage(off)]
+#[coverage(off)] //~ ERROR multiple `coverage` attributes
 fn multiple_consistent() {}
 
-#[coverage(off)] //~ ERROR multiple `coverage` attributes
-#[coverage(on)]
+#[coverage(off)]
+#[coverage(on)] //~ ERROR multiple `coverage` attributes
 fn multiple_inconsistent() {}
 
 #[coverage] //~ ERROR malformed `coverage` attribute input
diff --git a/tests/ui/coverage-attr/bad-syntax.stderr b/tests/ui/coverage-attr/bad-syntax.stderr
index ecf3ed83bca7..4a356221ff60 100644
--- a/tests/ui/coverage-attr/bad-syntax.stderr
+++ b/tests/ui/coverage-attr/bad-syntax.stderr
@@ -1,26 +1,26 @@
 error: multiple `coverage` attributes
-  --> $DIR/bad-syntax.rs:9:1
+  --> $DIR/bad-syntax.rs:10:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/bad-syntax.rs:10:1
+  --> $DIR/bad-syntax.rs:9:1
    |
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
 
 error: multiple `coverage` attributes
-  --> $DIR/bad-syntax.rs:13:1
-   |
-LL | #[coverage(off)]
-   | ^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
   --> $DIR/bad-syntax.rs:14:1
    |
 LL | #[coverage(on)]
-   | ^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/bad-syntax.rs:13:1
+   |
+LL | #[coverage(off)]
+   | ^^^^^^^^^^^^^^^^
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:17:1
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.rs b/tests/ui/lint/unused/unused-attr-duplicate.rs
index a334c49788cb..2b29fde128e4 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.rs
+++ b/tests/ui/lint/unused/unused-attr-duplicate.rs
@@ -61,7 +61,7 @@ macro_rules! foo {
 fn t1() {}
 
 #[must_use]
-#[must_use = "some message"] //~ ERROR unused attribute
+#[must_use = "some message"]  //~ ERROR unused attribute
 //~^ WARN this was previously accepted
 // No warnings for #[repr], would require more logic.
 #[repr(C)]
@@ -89,15 +89,15 @@ pub fn xyz() {}
 #[link(name = "rust_test_helpers", kind = "static")]
 #[link(name = "rust_test_helpers", kind = "static")]
 extern "C" {
-    #[link_name = "this_does_not_exist"] //~ ERROR unused attribute
+    #[link_name = "this_does_not_exist"]
+    #[link_name = "rust_dbg_extern_identity_u32"] //~ ERROR unused attribute
     //~^ WARN this was previously accepted
-    #[link_name = "rust_dbg_extern_identity_u32"]
     pub fn name_in_rust(v: u32) -> u32;
 }
 
-#[export_name = "exported_symbol_name"] //~ ERROR unused attribute
+#[export_name = "exported_symbol_name"]
+#[export_name = "exported_symbol_name2"]  //~ ERROR unused attribute
 //~^ WARN this was previously accepted
-#[export_name = "exported_symbol_name2"]
 pub fn export_test() {}
 
 #[no_mangle]
@@ -109,9 +109,9 @@ pub fn no_mangle_test() {}
 static FOO: u32 = 0;
 
 #[link_section = ".text"]
+#[link_section = ".bss"]
 //~^ ERROR unused attribute
 //~| WARN this was previously accepted
-#[link_section = ".bss"]
 pub extern "C" fn example() {}
 
 fn main() {}
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 351645f4a783..1942249d1f8e 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -165,29 +165,29 @@ 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"]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:94:5
-   |
-LL |     #[link_name = "rust_dbg_extern_identity_u32"]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = 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
+   |
+LL | #[export_name = "exported_symbol_name2"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
   --> $DIR/unused-attr-duplicate.rs:98:1
    |
 LL | #[export_name = "exported_symbol_name"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:100:1
-   |
-LL | #[export_name = "exported_symbol_name2"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = 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
@@ -215,16 +215,16 @@ LL | #[used]
    | ^^^^^^^
 
 error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:112:1
+   |
+LL | #[link_section = ".bss"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
   --> $DIR/unused-attr-duplicate.rs:111:1
    |
 LL | #[link_section = ".text"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:114:1
-   |
-LL | #[link_section = ".bss"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
    = 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
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.rs b/tests/ui/sanitize-attr/invalid-sanitize.rs
index 6846b6ff228b..5574661fcf5d 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.rs
+++ b/tests/ui/sanitize-attr/invalid-sanitize.rs
@@ -4,12 +4,12 @@
 #[sanitize(brontosaurus = "off")] //~ ERROR malformed `sanitize` attribute input
 fn main() {}
 
-#[sanitize(address = "off")] //~ ERROR multiple `sanitize` attributes
 #[sanitize(address = "off")]
+#[sanitize(address = "off")] //~ ERROR multiple `sanitize` attributes
 fn multiple_consistent() {}
 
-#[sanitize(address = "on")] //~ ERROR multiple `sanitize` attributes
-#[sanitize(address = "off")]
+#[sanitize(address = "on")]
+#[sanitize(address = "off")] //~ ERROR multiple `sanitize` attributes
 fn multiple_inconsistent() {}
 
 #[sanitize(address = "bogus")] //~ ERROR malformed `sanitize` attribute input
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.stderr b/tests/ui/sanitize-attr/invalid-sanitize.stderr
index 00bb7746d05f..259627a35505 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.stderr
+++ b/tests/ui/sanitize-attr/invalid-sanitize.stderr
@@ -7,28 +7,28 @@ LL | #[sanitize(brontosaurus = "off")]
    |            valid arguments are "address", "kernel_address", "cfi", "kcfi", "memory", "memtag", "shadow_call_stack", "thread", "hwaddress" or "realtime"
 
 error: multiple `sanitize` attributes
-  --> $DIR/invalid-sanitize.rs:7:1
+  --> $DIR/invalid-sanitize.rs:8:1
    |
 LL | #[sanitize(address = "off")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/invalid-sanitize.rs:8:1
+  --> $DIR/invalid-sanitize.rs:7:1
    |
 LL | #[sanitize(address = "off")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: multiple `sanitize` attributes
-  --> $DIR/invalid-sanitize.rs:11:1
-   |
-LL | #[sanitize(address = "on")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
   --> $DIR/invalid-sanitize.rs:12:1
    |
 LL | #[sanitize(address = "off")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/invalid-sanitize.rs:11:1
+   |
+LL | #[sanitize(address = "on")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0539]: malformed `sanitize` attribute input
   --> $DIR/invalid-sanitize.rs:15:1

From 0e4a7595012bc71ccbb28a117e2fcf35e833cedb Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 23 Mar 2026 14:00:22 +0100
Subject: [PATCH 0819/1059] Fix `link_ordinal` test

---
 .../windows/link-ordinal-multiple.rs          |  8 +++----
 .../windows/link-ordinal-multiple.stderr      | 24 +++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.rs b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.rs
index f5fb1649cdc4..d9251f6950df 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.rs
@@ -1,11 +1,11 @@
 //@ only-windows
 #[link(name = "foo", kind = "raw-dylib")]
 extern "C" {
-    #[link_ordinal(1)] //~ ERROR multiple `link_ordinal` attributes
-    #[link_ordinal(2)]
+    #[link_ordinal(1)]
+    #[link_ordinal(2)] //~ ERROR multiple `link_ordinal` attributes
     fn foo();
-    #[link_ordinal(1)] //~ ERROR multiple `link_ordinal` attributes
-    #[link_ordinal(2)]
+    #[link_ordinal(1)]
+    #[link_ordinal(2)] //~ ERROR multiple `link_ordinal` attributes
     static mut imported_variable: i32;
 }
 
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.stderr b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.stderr
index 2e6cf3761c2f..26d735154fcc 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-multiple.stderr
@@ -1,25 +1,25 @@
 error: multiple `link_ordinal` attributes
-  --> $DIR/link-ordinal-multiple.rs:4:5
-   |
-LL |     #[link_ordinal(1)]
-   |     ^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
   --> $DIR/link-ordinal-multiple.rs:5:5
    |
 LL |     #[link_ordinal(2)]
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: multiple `link_ordinal` attributes
-  --> $DIR/link-ordinal-multiple.rs:7:5
-   |
-LL |     #[link_ordinal(1)]
    |     ^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
+  --> $DIR/link-ordinal-multiple.rs:4:5
+   |
+LL |     #[link_ordinal(1)]
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: multiple `link_ordinal` attributes
   --> $DIR/link-ordinal-multiple.rs:8:5
    |
 LL |     #[link_ordinal(2)]
+   |     ^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/link-ordinal-multiple.rs:7:5
+   |
+LL |     #[link_ordinal(1)]
    |     ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors

From 0543e4f919140be7e7da31249f9419b4f14b4d85 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 6 Nov 2025 19:07:12 +0800
Subject: [PATCH 0820/1059] Improve tmp iterator variable name for
 convert_for_to_while_let

Example
---
```rust
fn main() {
    let x = vec![1, 2, 3];
    for$0 v in x {
        let y = v * 2;
    };
}
```

**Before this PR**

```rust
fn main() {
    let x = vec![1, 2, 3];
    let mut tmp = x.into_iter();
    while let Some(v) = tmp.next() {
        let y = v * 2;
    };
}
```

**After this PR**

```rust
fn main() {
    let x = vec![1, 2, 3];
    let mut iter = x.into_iter();
    while let Some(v) = iter.next() {
        let y = v * 2;
    };
}
```
---
 .../src/handlers/convert_for_to_while_let.rs  | 46 +++++++++----------
 .../crates/ide-assists/src/tests/generated.rs |  4 +-
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
index d409374c16f6..15f324eff329 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_for_to_while_let.rs
@@ -24,8 +24,8 @@
 // ```
 // fn main() {
 //     let x = vec![1, 2, 3];
-//     let mut tmp = x.into_iter();
-//     while let Some(v) = tmp.next() {
+//     let mut iter = x.into_iter();
+//     while let Some(v) = iter.next() {
 //         let y = v * 2;
 //     };
 // }
@@ -71,7 +71,7 @@ pub(crate) fn convert_for_loop_to_while_let(
             let mut new_name = suggest_name::NameGenerator::new_from_scope_locals(
                 ctx.sema.scope(for_loop.syntax()),
             );
-            let tmp_var = new_name.suggest_name("tmp");
+            let tmp_var = new_name.suggest_name("iter");
 
             let mut_expr = make.let_stmt(
                 make.ident_pat(false, true, make.name(&tmp_var)).into(),
@@ -188,8 +188,8 @@ fn main() {
             r"
 fn main() {
     let mut x = vec![1, 2, 3];
-    let mut tmp = x.into_iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = x.into_iter();
+    while let Some(v) = iter.next() {
         v *= 2;
     };
 }",
@@ -211,8 +211,8 @@ fn main() {
             r"
 fn main() {
     let mut x = vec![1, 2, 3];
-    let mut tmp = x.into_iter();
-    'a: while let Some(v) = tmp.next() {
+    let mut iter = x.into_iter();
+    'a: while let Some(v) = iter.next() {
         v *= 2;
         break 'a;
     };
@@ -236,10 +236,10 @@ fn main() {
             r"
 fn main() {
     let mut x = vec![1, 2, 3];
-    let mut tmp = x.into_iter();
+    let mut iter = x.into_iter();
     #[allow(unused)]
     #[deny(unsafe_code)]
-    while let Some(v) = tmp.next() {
+    while let Some(v) = iter.next() {
         v *= 2;
     };
 }",
@@ -275,8 +275,8 @@ fn next(&mut self) -> Option<Self::Item> {
 }
 
 fn main() {
-    let mut tmp = 0..92;
-    while let Some(x) = tmp.next() {
+    let mut iter = 0..92;
+    while let Some(x) = iter.next() {
         print!("{}", x);
     }
 }"#,
@@ -330,8 +330,8 @@ fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
 
 fn main() {
     let x = S;
-    let mut tmp = x.iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = x.iter();
+    while let Some(v) = iter.next() {
         let a = v * 2;
     }
 }
@@ -356,8 +356,8 @@ fn main() {
 struct NoIterMethod;
 fn main() {
     let x = NoIterMethod;
-    let mut tmp = (&x).into_iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = (&x).into_iter();
+    while let Some(v) = iter.next() {
         let a = v * 2;
     }
 }
@@ -382,8 +382,8 @@ fn main() {
 struct NoIterMethod;
 fn main() {
     let x = NoIterMethod;
-    let mut tmp = (&mut x).into_iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = (&mut x).into_iter();
+    while let Some(v) = iter.next() {
         let a = v * 2;
     }
 }
@@ -423,8 +423,8 @@ fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
 
 fn main() {
     let x = S;
-    let mut tmp = x.iter_mut();
-    while let Some(v) = tmp.next() {
+    let mut iter = x.iter_mut();
+    while let Some(v) = iter.next() {
         let a = v * 2;
     }
 }
@@ -448,8 +448,8 @@ fn main() {
 fn main() {
     let mut x = vec![1, 2, 3];
     let y = &mut x;
-    let mut tmp = y.into_iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = y.into_iter();
+    while let Some(v) = iter.next() {
         *v *= 2;
     }
 }",
@@ -471,8 +471,8 @@ fn main() {
 "#,
             r#"
 fn main() {
-    let mut tmp = core::iter::repeat(92).take(1);
-    while let Some(a) = tmp.next() {
+    let mut iter = core::iter::repeat(92).take(1);
+    while let Some(a) = iter.next() {
         println!("{}", a);
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
index 8ba46799d5ab..66d5cf834f17 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
@@ -507,8 +507,8 @@ fn main() {
         r#####"
 fn main() {
     let x = vec![1, 2, 3];
-    let mut tmp = x.into_iter();
-    while let Some(v) = tmp.next() {
+    let mut iter = x.into_iter();
+    while let Some(v) = iter.next() {
         let y = v * 2;
     };
 }

From 151ce088757143cf18a6c92263944b88ccb2b351 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:18:14 +0100
Subject: [PATCH 0821/1059] Rustup to rustc 1.96.0-nightly (562dee482
 2026-03-21)

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index a531c60a45a5..80a698809720 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-20"
+channel = "nightly-2026-03-23"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From 2258432bf638deb84075fafd40f18fb389d5b98c Mon Sep 17 00:00:00 2001
From: railgun-0402 <april-life.f-441-2011@docomo.ne.jp>
Date: Mon, 23 Mar 2026 23:19:47 +0900
Subject: [PATCH 0822/1059] fix: Accept parenthesized paths in asm `sym`
 operand parser

---
 .../src/handlers/typed_hole.rs                | 26 ++++++++++
 .../parser/src/grammar/expressions/atom.rs    | 12 ++++-
 .../parser/test_data/generated/runner.rs      |  2 +
 .../parser/inline/ok/asm_sym_paren.rast       | 49 +++++++++++++++++++
 .../parser/inline/ok/asm_sym_paren.rs         |  3 ++
 5 files changed, 91 insertions(+), 1 deletion(-)
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rast
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rs

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
index 577c582a2080..fd1674e2a47b 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
@@ -442,4 +442,30 @@ fn rdtscp() -> u64 {
 }"#,
         );
     }
+
+    #[test]
+    fn asm_sym_with_macro_expr_fragment() {
+        // Regression test for issue #21582
+        // When `$e:expr` captures a path and is used in `sym $e`, the path gets
+        // wrapped in parentheses during macro expansion due to invisible delimiters.
+        // This should not cause false positive typed-hole errors.
+        check_diagnostics(
+            r#"
+//- minicore: asm
+macro_rules! m {
+    ($e:expr) => {
+        core::arch::asm!("/*{f}*/", f = sym $e, out("ax") _)
+    };
+}
+
+fn generic<T>() {}
+
+fn main() {
+    unsafe {
+        m!(generic::<i32>);
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/expressions/atom.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/expressions/atom.rs
index b75474ee2b86..3214fd90f29a 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/expressions/atom.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/expressions/atom.rs
@@ -407,8 +407,18 @@ pub(crate) fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedM
             op.complete(p, ASM_CONST);
             op_n.complete(p, ASM_OPERAND_NAMED);
         } else if p.eat_contextual_kw(T![sym]) {
+            // test asm_sym_paren
+            // fn foo() {
+            //     builtin#asm("", f = sym (foo::bar));
+            // }
             dir_spec.abandon(p);
-            paths::type_path(p);
+            if p.at(T!['(']) {
+                p.bump(T!['(']);
+                paths::type_path(p);
+                p.expect(T![')']);
+            } else {
+                paths::type_path(p);
+            }
             op.complete(p, ASM_SYM);
             op_n.complete(p, ASM_OPERAND_NAMED);
         } else if allow_templates {
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs b/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
index 9f919f6cea42..4c001104fe52 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
+++ b/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
@@ -25,6 +25,8 @@ fn arb_self_types() {
     #[test]
     fn asm_label() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_label.rs"); }
     #[test]
+    fn asm_sym_paren() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_sym_paren.rs"); }
+    #[test]
     fn assoc_const_eq() {
         run_and_expect_no_errors("test_data/parser/inline/ok/assoc_const_eq.rs");
     }
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rast
new file mode 100644
index 000000000000..d189f63f2afc
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rast
@@ -0,0 +1,49 @@
+SOURCE_FILE
+  FN
+    FN_KW "fn"
+    WHITESPACE " "
+    NAME
+      IDENT "foo"
+    PARAM_LIST
+      L_PAREN "("
+      R_PAREN ")"
+    WHITESPACE " "
+    BLOCK_EXPR
+      STMT_LIST
+        L_CURLY "{"
+        WHITESPACE "\n    "
+        EXPR_STMT
+          ASM_EXPR
+            BUILTIN_KW "builtin"
+            POUND "#"
+            ASM_KW "asm"
+            L_PAREN "("
+            LITERAL
+              STRING "\"\""
+            COMMA ","
+            WHITESPACE " "
+            ASM_OPERAND_NAMED
+              NAME
+                IDENT "f"
+              WHITESPACE " "
+              EQ "="
+              WHITESPACE " "
+              ASM_SYM
+                SYM_KW "sym"
+                WHITESPACE " "
+                L_PAREN "("
+                PATH
+                  PATH
+                    PATH_SEGMENT
+                      NAME_REF
+                        IDENT "foo"
+                  COLON2 "::"
+                  PATH_SEGMENT
+                    NAME_REF
+                      IDENT "bar"
+                R_PAREN ")"
+            R_PAREN ")"
+          SEMICOLON ";"
+        WHITESPACE "\n"
+        R_CURLY "}"
+  WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rs
new file mode 100644
index 000000000000..7b2f80704c85
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_sym_paren.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    builtin#asm("", f = sym (foo::bar));
+}

From 0cd7f8488e6e37f6c8b6e5363d1d7da2d734a0c2 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 23 Mar 2026 20:04:30 +0530
Subject: [PATCH 0823/1059] add type_bound, type_bound_list and
 assoc_item_list_empty in syntaxfactory constructor

---
 .../src/ast/syntax_factory/constructors.rs    | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 55c80ed16707..24bf9ed3d296 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -59,6 +59,26 @@ pub fn ty_path(&self, path: ast::Path) -> ast::PathType {
         ast
     }
 
+    pub fn type_bound(&self, bound: ast::Type) -> ast::TypeBound {
+        make::type_bound(bound).clone_for_update()
+    }
+
+    pub fn type_bound_list(
+        &self,
+        bounds: impl IntoIterator<Item = ast::TypeBound>,
+    ) -> Option<ast::TypeBoundList> {
+        let (bounds, input) = iterator_input(bounds);
+        let ast = make::type_bound_list(bounds)?.clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(input, ast.bounds().map(|b| b.syntax().clone()));
+            builder.finish(&mut mapping);
+        }
+
+        Some(ast)
+    }
+
     pub fn type_param(
         &self,
         name: ast::Name,
@@ -1759,6 +1779,10 @@ pub fn assoc_item_list(
         ast
     }
 
+    pub fn assoc_item_list_empty(&self) -> ast::AssocItemList {
+        make::assoc_item_list(None).clone_for_update()
+    }
+
     pub fn attr_outer(&self, meta: ast::Meta) -> ast::Attr {
         let ast = make::attr_outer(meta.clone()).clone_for_update();
 

From 772782a11489d3ca0d1e06d5d99ef9dd35427546 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 23 Mar 2026 20:05:50 +0530
Subject: [PATCH 0824/1059] introduce utils methods syntaxFactory variant and
 comment those methods as legacy

---
 .../crates/ide-assists/src/utils.rs           | 201 +++++++++++++++++-
 1 file changed, 199 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 0657e7243af0..dc117c6381c0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -203,6 +203,9 @@ fn has_def_name(item: &InFile<ast::AssocItem>) -> bool {
 /// [`filter_assoc_items()`]), clones each item for update and applies path transformation to it,
 /// then inserts into `impl_`. Returns the modified `impl_` and the first associated item that got
 /// inserted.
+///
+/// Legacy: prefer [`add_trait_assoc_items_to_impl_with_factory`] when a [`SyntaxFactory`] is
+/// available.
 #[must_use]
 pub fn add_trait_assoc_items_to_impl(
     sema: &Semantics<'_, RootDatabase>,
@@ -279,6 +282,79 @@ pub fn add_trait_assoc_items_to_impl(
         .collect()
 }
 
+/// [`SyntaxFactory`]-based variant of [`add_trait_assoc_items_to_impl`].
+#[must_use]
+pub fn add_trait_assoc_items_to_impl_with_factory(
+    make: &SyntaxFactory,
+    sema: &Semantics<'_, RootDatabase>,
+    config: &AssistConfig,
+    original_items: &[InFile<ast::AssocItem>],
+    trait_: hir::Trait,
+    impl_: &ast::Impl,
+    target_scope: &hir::SemanticsScope<'_>,
+) -> Vec<ast::AssocItem> {
+    let new_indent_level = IndentLevel::from_node(impl_.syntax()) + 1;
+    original_items
+        .iter()
+        .map(|InFile { file_id, value: original_item }| {
+            let mut cloned_item = {
+                if let Some(macro_file) = file_id.macro_file() {
+                    let span_map = sema.db.expansion_span_map(macro_file);
+                    let item_prettified = prettify_macro_expansion(
+                        sema.db,
+                        original_item.syntax().clone(),
+                        &span_map,
+                        target_scope.krate().into(),
+                    );
+                    if let Some(formatted) = ast::AssocItem::cast(item_prettified) {
+                        return formatted;
+                    } else {
+                        stdx::never!("formatted `AssocItem` could not be cast back to `AssocItem`");
+                    }
+                }
+                original_item
+            }
+            .reset_indent();
+
+            if let Some(source_scope) = sema.scope(original_item.syntax()) {
+                let transform =
+                    PathTransform::trait_impl(target_scope, &source_scope, trait_, impl_.clone());
+                cloned_item = ast::AssocItem::cast(transform.apply(cloned_item.syntax())).unwrap();
+            }
+            cloned_item.remove_attrs_and_docs();
+            cloned_item
+        })
+        .filter_map(|item| match item {
+            ast::AssocItem::Fn(fn_) if fn_.body().is_none() => {
+                let fn_ = fn_.clone_subtree();
+                let fill_expr: ast::Expr = match config.expr_fill_default {
+                    ExprFillDefaultMode::Todo | ExprFillDefaultMode::Default => make.expr_todo(),
+                    ExprFillDefaultMode::Underscore => make.expr_underscore().into(),
+                };
+                let new_body = make.block_expr(None::<ast::Stmt>, Some(fill_expr));
+                let new_body = AstNodeEdit::indent(&new_body, IndentLevel::single());
+                let mut fn_editor = SyntaxEditor::new(fn_.syntax().clone());
+                fn_.replace_or_insert_body(&mut fn_editor, new_body);
+                let new_fn_ = fn_editor.finish().new_root().clone();
+                ast::AssocItem::cast(new_fn_)
+            }
+            ast::AssocItem::TypeAlias(type_alias) => {
+                let type_alias = type_alias.clone_subtree();
+                if let Some(type_bound_list) = type_alias.type_bound_list() {
+                    let mut type_alias_editor = SyntaxEditor::new(type_alias.syntax().clone());
+                    type_bound_list.remove(&mut type_alias_editor);
+                    let type_alias = type_alias_editor.finish().new_root().clone();
+                    ast::AssocItem::cast(type_alias)
+                } else {
+                    Some(ast::AssocItem::TypeAlias(type_alias))
+                }
+            }
+            item => Some(item),
+        })
+        .map(|item| AstNodeEdit::indent(&item, new_indent_level))
+        .collect()
+}
+
 pub(crate) fn vis_offset(node: &SyntaxNode) -> TextSize {
     node.children_with_tokens()
         .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))
@@ -670,8 +746,13 @@ pub(crate) fn generate_impl(adt: &ast::Adt) -> ast::Impl {
 /// and lifetime parameters, with `<trait>` appended to `impl`'s generic parameters' bounds.
 ///
 /// This is useful for traits like `PartialEq`, since `impl<T> PartialEq for U<T>` often requires `T: PartialEq`.
-pub(crate) fn generate_trait_impl(is_unsafe: bool, adt: &ast::Adt, trait_: ast::Type) -> ast::Impl {
-    generate_impl_inner(is_unsafe, adt, Some(trait_), true, None)
+pub(crate) fn generate_trait_impl(
+    make: &SyntaxFactory,
+    is_unsafe: bool,
+    adt: &ast::Adt,
+    trait_: ast::Type,
+) -> ast::Impl {
+    generate_impl_inner_with_factory(make, is_unsafe, adt, Some(trait_), true, None)
 }
 
 /// Generates the corresponding `impl <trait> for Type {}` including type
@@ -752,6 +833,76 @@ fn generate_impl_inner(
     .clone_for_update()
 }
 
+fn generate_impl_inner_with_factory(
+    make: &SyntaxFactory,
+    is_unsafe: bool,
+    adt: &ast::Adt,
+    trait_: Option<ast::Type>,
+    trait_is_transitive: bool,
+    body: Option<ast::AssocItemList>,
+) -> ast::Impl {
+    // Ensure lifetime params are before type & const params
+    let generic_params = adt.generic_param_list().map(|generic_params| {
+        let lifetime_params =
+            generic_params.lifetime_params().map(ast::GenericParam::LifetimeParam);
+        let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {
+            let param = match param {
+                ast::TypeOrConstParam::Type(param) => {
+                    // remove defaults since they can't be specified in impls
+                    let mut bounds =
+                        param.type_bound_list().map_or_else(Vec::new, |it| it.bounds().collect());
+                    if let Some(trait_) = &trait_ {
+                        // Add the current trait to `bounds` if the trait is transitive,
+                        // meaning `impl<T> Trait for U<T>` requires `T: Trait`.
+                        if trait_is_transitive {
+                            bounds.push(make.type_bound(trait_.clone()));
+                        }
+                    };
+                    // `{ty_param}: {bounds}`
+                    let param = make.type_param(param.name()?, make.type_bound_list(bounds));
+                    ast::GenericParam::TypeParam(param)
+                }
+                ast::TypeOrConstParam::Const(param) => {
+                    // remove defaults since they can't be specified in impls
+                    let param = make.const_param(param.name()?, param.ty()?);
+                    ast::GenericParam::ConstParam(param)
+                }
+            };
+            Some(param)
+        });
+
+        make.generic_param_list(itertools::chain(lifetime_params, ty_or_const_params))
+    });
+    let generic_args =
+        generic_params.as_ref().map(|params| params.to_generic_args().clone_for_update());
+    let adt_assoc_bounds =
+        trait_.as_ref().zip(generic_params.as_ref()).and_then(|(trait_, params)| {
+            generic_param_associated_bounds_with_factory(make, adt, trait_, params)
+        });
+
+    let ty: ast::Type = make.ty_path(make.ident_path(&adt.name().unwrap().text())).into();
+
+    let cfg_attrs =
+        adt.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));
+    match trait_ {
+        Some(trait_) => make.impl_trait(
+            cfg_attrs,
+            is_unsafe,
+            None,
+            None,
+            generic_params,
+            generic_args,
+            false,
+            trait_,
+            ty,
+            adt_assoc_bounds,
+            adt.where_clause(),
+            body,
+        ),
+        None => make.impl_(cfg_attrs, generic_params, generic_args, ty, adt.where_clause(), body),
+    }
+}
+
 fn generic_param_associated_bounds(
     adt: &ast::Adt,
     trait_: &ast::Type,
@@ -797,6 +948,52 @@ fn generic_param_associated_bounds(
     trait_where_clause.peek().is_some().then(|| make::where_clause(trait_where_clause))
 }
 
+fn generic_param_associated_bounds_with_factory(
+    make: &SyntaxFactory,
+    adt: &ast::Adt,
+    trait_: &ast::Type,
+    generic_params: &ast::GenericParamList,
+) -> Option<ast::WhereClause> {
+    let in_type_params = |name: &ast::NameRef| {
+        generic_params
+            .generic_params()
+            .filter_map(|param| match param {
+                ast::GenericParam::TypeParam(type_param) => type_param.name(),
+                _ => None,
+            })
+            .any(|param| param.text() == name.text())
+    };
+    let adt_body = match adt {
+        ast::Adt::Enum(e) => e.variant_list().map(|it| it.syntax().clone()),
+        ast::Adt::Struct(s) => s.field_list().map(|it| it.syntax().clone()),
+        ast::Adt::Union(u) => u.record_field_list().map(|it| it.syntax().clone()),
+    };
+    let mut trait_where_clause = adt_body
+        .into_iter()
+        .flat_map(|it| it.descendants())
+        .filter_map(ast::Path::cast)
+        .filter_map(|path| {
+            let qualifier = path.qualifier()?.as_single_segment()?;
+            let qualifier = qualifier
+                .name_ref()
+                .or_else(|| match qualifier.type_anchor()?.ty()? {
+                    ast::Type::PathType(path_type) => path_type.path()?.as_single_name_ref(),
+                    _ => None,
+                })
+                .filter(in_type_params)?;
+            Some((qualifier, path.segment()?.name_ref()?))
+        })
+        .map(|(qualifier, assoc_name)| {
+            let segments = [qualifier, assoc_name].map(|nr| make.path_segment(nr));
+            let path = make.path_from_segments(segments, false);
+            let bounds = [make.type_bound(trait_.clone())];
+            make.where_pred(either::Either::Right(make.ty_path(path).into()), bounds)
+        })
+        .unique_by(|it| it.syntax().to_string())
+        .peekable();
+    trait_where_clause.peek().is_some().then(|| make.where_clause(trait_where_clause))
+}
+
 pub(crate) fn add_method_to_adt(
     builder: &mut SourceChangeBuilder,
     adt: &ast::Adt,

From ba063f2ba70c18471f25dec9d4aaa720fc4aac3a Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 23 Mar 2026 20:06:45 +0530
Subject: [PATCH 0825/1059] migrate replace_derive_with_manual to use syntax
 factory instead of make

---
 .../replace_derive_with_manual_impl.rs        | 43 ++++++++++++-------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
index 7c024263b4a8..f54f7a02d2b3 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -4,7 +4,7 @@
 use syntax::{
     SyntaxKind::WHITESPACE,
     T,
-    ast::{self, AstNode, HasName, make},
+    ast::{self, AstNode, HasName, syntax_factory::SyntaxFactory},
     syntax_editor::{Position, SyntaxEditor},
 };
 
@@ -12,8 +12,8 @@
     AssistConfig, AssistId,
     assist_context::{AssistContext, Assists},
     utils::{
-        DefaultMethods, IgnoreAssocItems, add_trait_assoc_items_to_impl, filter_assoc_items,
-        gen_trait_fn_body, generate_trait_impl,
+        DefaultMethods, IgnoreAssocItems, add_trait_assoc_items_to_impl_with_factory,
+        filter_assoc_items, gen_trait_fn_body, generate_trait_impl,
     },
 };
 
@@ -127,6 +127,7 @@ fn add_assist(
     let label = format!("Convert to manual `impl {replace_trait_path} for {annotated_name}`");
 
     acc.add(AssistId::refactor("replace_derive_with_manual_impl"), label, target, |builder| {
+        let make = SyntaxFactory::without_mappings();
         let insert_after = Position::after(adt.syntax());
         let impl_is_unsafe = trait_.map(|s| s.is_unsafe(ctx.db())).unwrap_or(false);
         let impl_def = impl_def_from_trait(
@@ -142,7 +143,7 @@ fn add_assist(
         let mut editor = builder.make_editor(attr.syntax());
         update_attribute(&mut editor, old_derives, old_tree, old_trait_path, attr);
 
-        let trait_path = make::ty_path(replace_trait_path.clone());
+        let trait_path = make.ty_path(replace_trait_path.clone()).into();
 
         let (impl_def, first_assoc_item) = if let Some(impl_def) = impl_def {
             (
@@ -150,7 +151,7 @@ fn add_assist(
                 impl_def.assoc_item_list().and_then(|list| list.assoc_items().next()),
             )
         } else {
-            (generate_trait_impl(impl_is_unsafe, adt, trait_path), None)
+            (generate_trait_impl(&make, impl_is_unsafe, adt, trait_path), None)
         };
 
         if let Some(cap) = ctx.config.snippet_cap {
@@ -174,7 +175,7 @@ fn add_assist(
 
         editor.insert_all(
             insert_after,
-            vec![make::tokens::blank_line().into(), impl_def.syntax().clone().into()],
+            vec![make.whitespace("\n\n").into(), impl_def.syntax().clone().into()],
         );
         builder.add_file_edits(ctx.vfs_file_id(), editor);
     })
@@ -205,10 +206,19 @@ fn impl_def_from_trait(
     if trait_items.is_empty() {
         return None;
     }
-    let impl_def = generate_trait_impl(impl_is_unsafe, adt, make::ty_path(trait_path.clone()));
+    let make = SyntaxFactory::without_mappings();
+    let trait_ty = make.ty_path(trait_path.clone()).into();
+    let impl_def = generate_trait_impl(&make, impl_is_unsafe, adt, trait_ty);
 
-    let assoc_items =
-        add_trait_assoc_items_to_impl(sema, config, &trait_items, trait_, &impl_def, &target_scope);
+    let assoc_items = add_trait_assoc_items_to_impl_with_factory(
+        &make,
+        sema,
+        config,
+        &trait_items,
+        trait_,
+        &impl_def,
+        &target_scope,
+    );
     let assoc_item_list = if let Some((first, other)) =
         assoc_items.split_first().map(|(first, other)| (first.clone_subtree(), other))
     {
@@ -222,12 +232,12 @@ fn impl_def_from_trait(
         } else {
             Some(first.clone())
         };
-        let items = first_item.into_iter().chain(other.iter().cloned()).collect();
-        make::assoc_item_list(Some(items))
+        let items: Vec<ast::AssocItem> =
+            first_item.into_iter().chain(other.iter().cloned()).collect();
+        make.assoc_item_list(items)
     } else {
-        make::assoc_item_list(None)
-    }
-    .clone_for_update();
+        make.assoc_item_list_empty()
+    };
 
     let impl_def = impl_def.clone_subtree();
     let mut editor = SyntaxEditor::new(impl_def.syntax().clone());
@@ -243,6 +253,7 @@ fn update_attribute(
     old_trait_path: &ast::Path,
     attr: &ast::Attr,
 ) {
+    let make = SyntaxFactory::without_mappings();
     let new_derives = old_derives
         .iter()
         .filter(|t| t.to_string() != old_trait_path.to_string())
@@ -257,13 +268,13 @@ fn update_attribute(
                 .collect::<Vec<_>>()
         });
         // ...which are interspersed with ", "
-        let tt = Itertools::intersperse(tt, vec![make::token(T![,]), make::tokens::single_space()]);
+        let tt = Itertools::intersperse(tt, vec![make.token(T![,]), make.whitespace(" ")]);
         // ...wrap them into the appropriate `NodeOrToken` variant
         let tt = tt.flatten().map(syntax::NodeOrToken::Token);
         // ...and make them into a flat list of tokens
         let tt = tt.collect::<Vec<_>>();
 
-        let new_tree = make::token_tree(T!['('], tt).clone_for_update();
+        let new_tree = make.token_tree(T!['('], tt);
         editor.replace(old_tree.syntax(), new_tree.syntax());
     } else {
         // Remove the attr and any trailing whitespace

From 6772c82eb3654e68717166bd0e87a878b5280dfd Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 23 Mar 2026 18:01:33 +0100
Subject: [PATCH 0826/1059] Update books

---
 src/doc/embedded-book | 2 +-
 src/doc/reference     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index e88aa4403b4b..2463edeb8003 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit e88aa4403b4bf2071c8df9509160477e40179099
+Subproject commit 2463edeb8003c5743918b3739a9f6870b86396f5
diff --git a/src/doc/reference b/src/doc/reference
index c49e89cc8c7c..7446bf9697c9 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit c49e89cc8c7c2c43ca625a8d5b7ad9a53a9ce978
+Subproject commit 7446bf9697c95d155eef33c6a9d91fbd29a5e359

From c0e6c763a94e440b247f4f23d3c2be289f313f21 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 23 Mar 2026 17:43:12 +0100
Subject: [PATCH 0827/1059] interpret: when passing an argument fails, point at
 that argument

---
 .../src/const_eval/eval_queries.rs            |   2 +-
 .../rustc_const_eval/src/interpret/call.rs    | 286 +++++++++---------
 .../rustc_const_eval/src/interpret/stack.rs   |  15 +-
 compiler/rustc_const_eval/src/lib.rs          |   1 -
 .../libc_pthread_create_too_few_args.rs       |   2 +-
 .../libc_pthread_create_too_few_args.stderr   |  11 +-
 .../libc_pthread_create_too_many_args.rs      |   2 +-
 .../libc_pthread_create_too_many_args.stderr  |  11 +-
 .../arg_inplace_locals_alias.rs               |   4 +-
 .../arg_inplace_locals_alias.stack.stderr     |  13 +-
 .../arg_inplace_locals_alias.tree.stderr      |  17 +-
 .../arg_inplace_locals_alias_ret.rs           |   4 +-
 .../arg_inplace_locals_alias_ret.stack.stderr |  13 +-
 .../arg_inplace_locals_alias_ret.tree.stderr  |  17 +-
 .../arg_inplace_mutate.stack.stderr           |   4 +-
 .../arg_inplace_mutate.tree.stderr            |   8 +-
 .../arg_inplace_observe_during.stack.stderr   |   4 +-
 .../arg_inplace_observe_during.tree.stderr    |   8 +-
 .../exported_symbol_wrong_arguments.rs        |   4 +-
 .../exported_symbol_wrong_arguments.stderr    |   9 +-
 .../return_pointer_aliasing_read.stack.stderr |   4 +-
 .../return_pointer_aliasing_read.tree.stderr  |   8 +-
 ...return_pointer_aliasing_write.stack.stderr |   4 +-
 .../return_pointer_aliasing_write.tree.stderr |   8 +-
 ...nter_aliasing_write_tail_call.stack.stderr |   4 +-
 ...inter_aliasing_write_tail_call.tree.stderr |   8 +-
 .../abi_mismatch_array_vs_struct.rs           |   4 +-
 .../abi_mismatch_array_vs_struct.stderr       |   9 +-
 .../abi_mismatch_int_vs_float.rs              |   4 +-
 .../abi_mismatch_int_vs_float.stderr          |   9 +-
 .../abi_mismatch_raw_pointer.rs               |   4 +-
 .../abi_mismatch_raw_pointer.stderr           |   9 +-
 .../function_pointers/abi_mismatch_repr_C.rs  |   2 +-
 .../abi_mismatch_repr_C.stderr                |   9 +-
 .../abi_mismatch_return_type.rs               |   4 +-
 .../abi_mismatch_return_type.stderr           |   9 +-
 .../function_pointers/abi_mismatch_simple.rs  |   4 +-
 .../abi_mismatch_simple.stderr                |   9 +-
 .../abi_mismatch_too_few_args.rs              |   4 +-
 .../abi_mismatch_too_few_args.stderr          |   9 +-
 .../abi_mismatch_too_many_args.rs             |   4 +-
 .../abi_mismatch_too_many_args.stderr         |   9 +-
 .../function_pointers/abi_mismatch_vector.rs  |   4 +-
 .../abi_mismatch_vector.stderr                |   9 +-
 .../tests/fail/shims/ctor_wrong_ret_type.rs   |   2 +-
 .../fail/shims/ctor_wrong_ret_type.stderr     |  17 +-
 .../fail/tail_calls/signature-mismatch-arg.rs |   8 +-
 .../tail_calls/signature-mismatch-arg.stderr  |   9 +-
 .../cast_fn_ptr_invalid_callee_arg.rs         |   2 +-
 .../cast_fn_ptr_invalid_callee_arg.stderr     |   9 +-
 .../cast_fn_ptr_invalid_caller_arg.rs         |   4 +-
 .../cast_fn_ptr_invalid_caller_arg.stderr     |  10 +-
 52 files changed, 366 insertions(+), 281 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 2dbf2cc91058..d799e376e8bd 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -88,7 +88,7 @@ fn eval_body_using_ecx<'tcx, R: InterpretationResult<'tcx>>(
         &ret.clone().into(),
         ReturnContinuation::Stop { cleanup: false },
     )?;
-    ecx.storage_live_for_always_live_locals()?;
+    ecx.push_stack_frame_done()?;
 
     // The main interpreter loop.
     while ecx.step()? {
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 0381571ef6da..802aa9ef4645 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -404,166 +404,158 @@ pub fn init_stack_frame(
 
         // Push the "raw" frame -- this leaves locals uninitialized.
         self.push_stack_frame_raw(instance, body, destination, cont)?;
+        let preamble_span = self.frame().loc.unwrap_right(); // the span used for preamble errors
 
-        // If an error is raised here, pop the frame again to get an accurate backtrace.
-        // To this end, we wrap it all in a `try` block.
-        let res: InterpResult<'tcx> = try {
-            trace!(
-                "caller ABI: {:#?}, args: {:#?}",
-                caller_fn_abi,
-                args.iter()
-                    .map(|arg| (
-                        arg.layout().ty,
-                        match arg {
-                            FnArg::Copy(op) => format!("copy({op:?})"),
-                            FnArg::InPlace(mplace) => format!("in-place({mplace:?})"),
-                        }
-                    ))
-                    .collect::<Vec<_>>()
-            );
-            trace!(
-                "spread_arg: {:?}, locals: {:#?}",
-                body.spread_arg,
-                body.args_iter()
-                    .map(|local| (
-                        local,
-                        self.layout_of_local(self.frame(), local, None).unwrap().ty,
-                    ))
-                    .collect::<Vec<_>>()
-            );
-
-            // In principle, we have two iterators: Where the arguments come from, and where
-            // they go to.
-
-            // The "where they come from" part is easy, we expect the caller to do any special handling
-            // that might be required here (e.g. for untupling).
-            // If `with_caller_location` is set we pretend there is an extra argument (that
-            // we will not pass; our `caller_location` intrinsic implementation walks the stack instead).
-            assert_eq!(
-                args.len() + if with_caller_location { 1 } else { 0 },
-                caller_fn_abi.args.len(),
-                "mismatch between caller ABI and caller arguments",
-            );
-            let mut caller_args = args
-                .iter()
-                .zip(caller_fn_abi.args.iter())
-                .filter(|arg_and_abi| !arg_and_abi.1.is_ignore());
-
-            // Now we have to spread them out across the callee's locals,
-            // taking into account the `spread_arg`. If we could write
-            // this is a single iterator (that handles `spread_arg`), then
-            // `pass_argument` would be the loop body. It takes care to
-            // not advance `caller_iter` for ignored arguments.
-            let mut callee_args_abis = callee_fn_abi.args.iter().enumerate();
-            // Determine whether there is a special VaList argument. This is always the
-            // last argument, and since arguments start at index 1 that's `arg_count`.
-            let va_list_arg =
-                callee_fn_abi.c_variadic.then(|| mir::Local::from_usize(body.arg_count));
-            for local in body.args_iter() {
-                // Construct the destination place for this argument. At this point all
-                // locals are still dead, so we cannot construct a `PlaceTy`.
-                let dest = mir::Place::from(local);
-                // `layout_of_local` does more than just the instantiation we need to get the
-                // type, but the result gets cached so this avoids calling the instantiation
-                // query *again* the next time this local is accessed.
-                let ty = self.layout_of_local(self.frame(), local, None)?.ty;
-                if Some(local) == va_list_arg {
-                    // This is the last callee-side argument of a variadic function.
-                    // This argument is a VaList holding the remaining caller-side arguments.
-                    self.storage_live(local)?;
-
-                    let place = self.eval_place(dest)?;
-                    let mplace = self.force_allocation(&place)?;
-
-                    // Consume the remaining arguments by putting them into the variable argument
-                    // list.
-                    let varargs = self.allocate_varargs(
-                        &mut caller_args,
-                        // "Ignored" arguments aren't actually passed, so the callee should also
-                        // ignore them. (`pass_argument` does this for regular arguments.)
-                        (&mut callee_args_abis).filter(|(_, abi)| !abi.is_ignore()),
-                    )?;
-                    // When the frame is dropped, these variable arguments are deallocated.
-                    self.frame_mut().va_list = varargs.clone();
-                    let key = self.va_list_ptr(varargs.into());
-
-                    // Zero the VaList, so it is fully initialized.
-                    self.write_bytes_ptr(
-                        mplace.ptr(),
-                        (0..mplace.layout.size.bytes()).map(|_| 0u8),
-                    )?;
-
-                    // Store the "key" pointer in the right field.
-                    let key_mplace = self.va_list_key_field(&mplace)?;
-                    self.write_pointer(key, &key_mplace)?;
-                } else if Some(local) == body.spread_arg {
-                    // Make the local live once, then fill in the value field by field.
-                    self.storage_live(local)?;
-                    // Must be a tuple
-                    let ty::Tuple(fields) = ty.kind() else {
-                        span_bug!(self.cur_span(), "non-tuple type for `spread_arg`: {ty}")
-                    };
-                    for (i, field_ty) in fields.iter().enumerate() {
-                        let dest = dest.project_deeper(
-                            &[mir::ProjectionElem::Field(FieldIdx::from_usize(i), field_ty)],
-                            *self.tcx,
-                        );
-                        let (idx, callee_abi) = callee_args_abis.next().unwrap();
-                        self.pass_argument(
-                            &mut caller_args,
-                            callee_abi,
-                            idx,
-                            &dest,
-                            field_ty,
-                            /* already_live */ true,
-                        )?;
+        trace!(
+            "caller ABI: {:#?}, args: {:#?}",
+            caller_fn_abi,
+            args.iter()
+                .map(|arg| (
+                    arg.layout().ty,
+                    match arg {
+                        FnArg::Copy(op) => format!("copy({op:?})"),
+                        FnArg::InPlace(mplace) => format!("in-place({mplace:?})"),
                     }
-                } else {
-                    // Normal argument. Cannot mark it as live yet, it might be unsized!
+                ))
+                .collect::<Vec<_>>()
+        );
+        trace!(
+            "spread_arg: {:?}, locals: {:#?}",
+            body.spread_arg,
+            body.args_iter()
+                .map(|local| (local, self.layout_of_local(self.frame(), local, None).unwrap().ty,))
+                .collect::<Vec<_>>()
+        );
+
+        // In principle, we have two iterators: Where the arguments come from, and where
+        // they go to.
+
+        // The "where they come from" part is easy, we expect the caller to do any special handling
+        // that might be required here (e.g. for untupling).
+        // If `with_caller_location` is set we pretend there is an extra argument (that
+        // we will not pass; our `caller_location` intrinsic implementation walks the stack instead).
+        assert_eq!(
+            args.len() + if with_caller_location { 1 } else { 0 },
+            caller_fn_abi.args.len(),
+            "mismatch between caller ABI and caller arguments",
+        );
+        let mut caller_args = args
+            .iter()
+            .zip(caller_fn_abi.args.iter())
+            .filter(|arg_and_abi| !arg_and_abi.1.is_ignore());
+
+        // Now we have to spread them out across the callee's locals,
+        // taking into account the `spread_arg`. If we could write
+        // this is a single iterator (that handles `spread_arg`), then
+        // `pass_argument` would be the loop body. It takes care to
+        // not advance `caller_iter` for ignored arguments.
+        let mut callee_args_abis = callee_fn_abi.args.iter().enumerate();
+        // Determine whether there is a special VaList argument. This is always the
+        // last argument, and since arguments start at index 1 that's `arg_count`.
+        let va_list_arg = callee_fn_abi.c_variadic.then(|| mir::Local::from_usize(body.arg_count));
+        for local in body.args_iter() {
+            // Update the span that we show in case of an error to point to this argument.
+            self.frame_mut().loc = Right(body.local_decls[local].source_info.span);
+            // Construct the destination place for this argument. At this point all
+            // locals are still dead, so we cannot construct a `PlaceTy`.
+            let dest = mir::Place::from(local);
+            // `layout_of_local` does more than just the instantiation we need to get the
+            // type, but the result gets cached so this avoids calling the instantiation
+            // query *again* the next time this local is accessed.
+            let ty = self.layout_of_local(self.frame(), local, None)?.ty;
+            if Some(local) == va_list_arg {
+                // This is the last callee-side argument of a variadic function.
+                // This argument is a VaList holding the remaining caller-side arguments.
+                self.storage_live(local)?;
+
+                let place = self.eval_place(dest)?;
+                let mplace = self.force_allocation(&place)?;
+
+                // Consume the remaining arguments by putting them into the variable argument
+                // list.
+                let varargs = self.allocate_varargs(
+                    &mut caller_args,
+                    // "Ignored" arguments aren't actually passed, so the callee should also
+                    // ignore them. (`pass_argument` does this for regular arguments.)
+                    (&mut callee_args_abis).filter(|(_, abi)| !abi.is_ignore()),
+                )?;
+                // When the frame is dropped, these variable arguments are deallocated.
+                self.frame_mut().va_list = varargs.clone();
+                let key = self.va_list_ptr(varargs.into());
+
+                // Zero the VaList, so it is fully initialized.
+                self.write_bytes_ptr(mplace.ptr(), (0..mplace.layout.size.bytes()).map(|_| 0u8))?;
+
+                // Store the "key" pointer in the right field.
+                let key_mplace = self.va_list_key_field(&mplace)?;
+                self.write_pointer(key, &key_mplace)?;
+            } else if Some(local) == body.spread_arg {
+                // Make the local live once, then fill in the value field by field.
+                self.storage_live(local)?;
+                // Must be a tuple
+                let ty::Tuple(fields) = ty.kind() else {
+                    span_bug!(self.cur_span(), "non-tuple type for `spread_arg`: {ty}")
+                };
+                for (i, field_ty) in fields.iter().enumerate() {
+                    let dest = dest.project_deeper(
+                        &[mir::ProjectionElem::Field(FieldIdx::from_usize(i), field_ty)],
+                        *self.tcx,
+                    );
                     let (idx, callee_abi) = callee_args_abis.next().unwrap();
                     self.pass_argument(
                         &mut caller_args,
                         callee_abi,
                         idx,
                         &dest,
-                        ty,
-                        /* already_live */ false,
+                        field_ty,
+                        /* already_live */ true,
                     )?;
                 }
+            } else {
+                // Normal argument. Cannot mark it as live yet, it might be unsized!
+                let (idx, callee_abi) = callee_args_abis.next().unwrap();
+                self.pass_argument(
+                    &mut caller_args,
+                    callee_abi,
+                    idx,
+                    &dest,
+                    ty,
+                    /* already_live */ false,
+                )?;
             }
-            // If the callee needs a caller location, pretend we consume one more argument from the ABI.
-            if instance.def.requires_caller_location(*self.tcx) {
-                callee_args_abis.next().unwrap();
-            }
-            // Now we should have no more caller args or callee arg ABIs.
-            assert!(
-                callee_args_abis.next().is_none(),
-                "mismatch between callee ABI and callee body arguments"
-            );
-            if caller_args.next().is_some() {
-                throw_ub_format!("calling a function with more arguments than it expected");
-            }
-            // Don't forget to check the return type!
-            if !self.check_argument_compat(&caller_fn_abi.ret, &callee_fn_abi.ret)? {
-                throw_ub!(AbiMismatchReturn {
-                    caller_ty: caller_fn_abi.ret.layout.ty,
-                    callee_ty: callee_fn_abi.ret.layout.ty
-                });
-            }
+        }
 
-            // Protect return place for in-place return value passing.
-            // We only need to protect anything if this is actually an in-memory place.
-            if let Some(mplace) = destination_mplace {
-                M::protect_in_place_function_argument(self, &mplace)?;
-            }
+        // Don't forget to check the return type!
+        self.frame_mut().loc = Right(body.local_decls[mir::RETURN_PLACE].source_info.span);
+        if !self.check_argument_compat(&caller_fn_abi.ret, &callee_fn_abi.ret)? {
+            throw_ub!(AbiMismatchReturn {
+                caller_ty: caller_fn_abi.ret.layout.ty,
+                callee_ty: callee_fn_abi.ret.layout.ty
+            });
+        }
+        // Protect return place for in-place return value passing.
+        // We only need to protect anything if this is actually an in-memory place.
+        if let Some(mplace) = destination_mplace {
+            M::protect_in_place_function_argument(self, &mplace)?;
+        }
 
-            // Don't forget to mark "initially live" locals as live.
-            self.storage_live_for_always_live_locals()?;
-        };
-        res.inspect_err_kind(|_| {
-            // Don't show the incomplete stack frame in the error stacktrace.
-            self.stack_mut().pop();
-        })
+        // For the final checks, use same span as preamble since it is unclear what else to do.
+        self.frame_mut().loc = Right(preamble_span);
+        // If the callee needs a caller location, pretend we consume one more argument from the ABI.
+        if instance.def.requires_caller_location(*self.tcx) {
+            callee_args_abis.next().unwrap();
+        }
+        // Now we should have no more caller args or callee arg ABIs.
+        assert!(
+            callee_args_abis.next().is_none(),
+            "mismatch between callee ABI and callee body arguments"
+        );
+        if caller_args.next().is_some() {
+            throw_ub_format!("calling a function with more arguments than it expected");
+        }
+
+        // Done!
+        self.push_stack_frame_done()
     }
 
     /// Initiate a call to this function -- pushing the stack frame and initializing the arguments.
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index b0f34264ad84..a73767264dab 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -381,7 +381,7 @@ pub(crate) fn push_stack_frame_raw(
         let locals = IndexVec::from_elem(dead_local, &body.local_decls);
         let pre_frame = Frame {
             body,
-            loc: Right(body.span), // Span used for errors caused during preamble.
+            loc: Right(self.tcx.def_span(body.source.def_id())), // Span used for errors caused during preamble.
             return_cont,
             return_place: return_place.clone(),
             locals,
@@ -408,7 +408,6 @@ pub(crate) fn push_stack_frame_raw(
 
         // Finish things up.
         M::after_stack_push(self)?;
-        self.frame_mut().loc = Left(mir::Location::START);
         // `tracing_separate_thread` is used to instruct the tracing_chrome [tracing::Layer] in Miri
         // to put the "frame" span on a separate trace thread/line than other spans, to make the
         // visualization in <https://ui.perfetto.dev> easier to interpret. It is set to a value of
@@ -466,9 +465,11 @@ pub(super) fn cleanup_stack_frame(
         }
     }
 
-    /// In the current stack frame, mark all locals as live that are not arguments and don't have
-    /// `Storage*` annotations (this includes the return place).
-    pub(crate) fn storage_live_for_always_live_locals(&mut self) -> InterpResult<'tcx> {
+    /// Call this after `push_stack_frame_raw` and when all the other setup that needs to be done
+    /// is completed.
+    pub(crate) fn push_stack_frame_done(&mut self) -> InterpResult<'tcx> {
+        // Mark all locals as live that are not arguments and don't have `Storage*` annotations
+        // (this includes the return place, but not the arguments).
         self.storage_live(mir::RETURN_PLACE)?;
 
         let body = self.body();
@@ -478,6 +479,10 @@ pub(crate) fn storage_live_for_always_live_locals(&mut self) -> InterpResult<'tc
                 self.storage_live(local)?;
             }
         }
+
+        // Get ready to execute the first instruction in the stack frame.
+        self.frame_mut().loc = Left(mir::Location::START);
+
         interp_ok(())
     }
 
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index a9fff6d59326..33da1c5ecf73 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -5,7 +5,6 @@
 #![feature(never_type)]
 #![feature(slice_ptr_get)]
 #![feature(trait_alias)]
-#![feature(try_blocks)]
 #![feature(unqualified_local_imports)]
 #![feature(yeet_expr)]
 #![warn(unqualified_local_imports)]
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs
index 6fec6500cc96..024537633383 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs
@@ -5,6 +5,7 @@
 use std::{mem, ptr};
 
 extern "C" fn thread_start() -> *mut libc::c_void {
+    //~^ERROR: calling a function with more arguments than it expected
     panic!()
 }
 
@@ -16,7 +17,6 @@ fn main() {
             mem::transmute(thread_start);
         assert_eq!(
             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
-            //~^ERROR: calling a function with more arguments than it expected
             0
         );
         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
index 979a1a8337b5..e3509a2a6ee8 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
@@ -1,14 +1,17 @@
 error: Undefined Behavior: calling a function with more arguments than it expected
   --> tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs:LL:CC
    |
-LL |             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred due to this code
+LL | extern "C" fn thread_start() -> *mut libc::c_void {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: this is on thread `unnamed-ID`
-   = note: this error occurred while pushing a call frame onto an empty stack
-   = note: the span indicates which code caused the function to be called, but may not be the literal call site
+note: the current function got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_create_too_few_args.rs:LL:CC
+   |
+LL |             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs
index cb55b0f92ee6..28fdb1d01384 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs
@@ -5,6 +5,7 @@
 use std::{mem, ptr};
 
 extern "C" fn thread_start(_null: *mut libc::c_void, _x: i32) -> *mut libc::c_void {
+    //~^ERROR: calling a function with fewer arguments than it requires
     panic!()
 }
 
@@ -16,7 +17,6 @@ fn main() {
             mem::transmute(thread_start);
         assert_eq!(
             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
-            //~^ERROR: calling a function with fewer arguments than it requires
             0
         );
         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
index e8ad65a74ac8..d6504f6b9787 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
@@ -1,14 +1,17 @@
 error: Undefined Behavior: calling a function with fewer arguments than it requires
   --> tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs:LL:CC
    |
-LL |             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred due to this code
+LL | extern "C" fn thread_start(_null: *mut libc::c_void, _x: i32) -> *mut libc::c_void {
+   |                                                      ^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: this is on thread `unnamed-ID`
-   = note: this error occurred while pushing a call frame onto an empty stack
-   = note: the span indicates which code caused the function to be called, but may not be the literal call site
+note: the current function got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_create_too_many_args.rs:LL:CC
+   |
+LL |             libc::pthread_create(&mut native, ptr::null(), thread_start, ptr::null_mut()),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
index b6cda6007536..1fb597fdc02a 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
@@ -21,8 +21,6 @@ fn main() {
             // This specifically uses a type with scalar representation to tempt Miri to use the
             // efficient way of storing local variables (outside adressable memory).
             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(after_call), UnwindContinue())
-            //~[stack]^ ERROR: not granting access
-            //~[tree]| ERROR: /read access .* forbidden/
         }
         after_call = {
             Return()
@@ -32,6 +30,8 @@ fn main() {
 
 #[expect(unused_variables, unused_assignments)]
 fn callee(x: S, mut y: S) {
+    //~[stack]^ ERROR: not granting access
+    //~[tree]| ERROR: /read access .* forbidden/
     // With the setup above, if `x` and `y` are both moved,
     // then writing to `y` will change the value stored in `x`!
     y.0 = 0;
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.stack.stderr
index a86c68cebd23..14df4ebd11f5 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.stack.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
-LL |             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn callee(x: S, mut y: S) {
+   |                 ^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
@@ -14,8 +14,13 @@ LL |             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(a
 help: <TAG> is this argument
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
-LL |     y.0 = 0;
-   |     ^^^^^^^
+LL | fn callee(x: S, mut y: S) {
+   |           ^
+   = note: stack backtrace:
+           0: callee
+               at tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
+           1: main
+               at tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
index d62adeeb8420..7012c4f8aead 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: read access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
-LL |             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn callee(x: S, mut y: S) {
+   |                 ^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
@@ -17,14 +17,19 @@ LL |             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(a
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
-LL |     y.0 = 0;
-   |     ^^^^^^^
+LL | fn callee(x: S, mut y: S) {
+   |           ^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
-LL |     y.0 = 0;
-   |     ^^^^^^^
+LL | fn callee(x: S, mut y: S) {
+   |           ^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
+   = note: stack backtrace:
+           0: callee
+               at tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
+           1: main
+               at tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.rs b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.rs
index 3cb8ee2b407c..b3d43ca63cb0 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.rs
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.rs
@@ -20,8 +20,6 @@ fn main() {
             // This specifically uses a type with scalar representation to tempt Miri to use the
             // efficient way of storing local variables (outside adressable memory).
             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call), UnwindContinue())
-            //~[stack]^ ERROR: not granting access
-            //~[tree]| ERROR: /reborrow .* forbidden/
         }
         after_call = {
             Return()
@@ -30,5 +28,7 @@ fn main() {
 }
 
 fn callee(x: S) -> S {
+    //~[stack]^ ERROR: not granting access
+    //~[tree]| ERROR: /reborrow .* forbidden/
     x
 }
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.stack.stderr
index 491d01cf4284..21fcfb96fd17 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.stack.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
-LL |             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn callee(x: S) -> S {
+   |                    ^ Undefined Behavior occurred here
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
@@ -14,8 +14,13 @@ LL |             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call),
 help: <TAG> is this argument
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
-LL |     x
-   |     ^
+LL | fn callee(x: S) -> S {
+   |           ^
+   = note: stack backtrace:
+           0: callee
+               at tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
+           1: main
+               at tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
index 3c1038d364bb..e4d4e87625a9 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: reborrow through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
-LL |             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn callee(x: S) -> S {
+   |                    ^ Undefined Behavior occurred here
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
@@ -17,14 +17,19 @@ LL |             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call),
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
-LL |     x
-   |     ^
+LL | fn callee(x: S) -> S {
+   |           ^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
-LL |     x
-   |     ^
+LL | fn callee(x: S) -> S {
+   |           ^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
+   = note: stack backtrace:
+           0: callee
+               at tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
+           1: main
+               at tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
index 952f2272f3bf..c754acdd5ea1 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
@@ -19,8 +19,8 @@ LL | |     }
 help: <TAG> is this argument
   --> tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
    |
-LL |     unsafe { ptr.write(S(0)) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn callee(x: S, ptr: *mut S) {
+   |           ^
    = note: stack backtrace:
            0: callee
                at tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
index 095dc7e1a1fb..c210d5c00524 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
@@ -22,13 +22,13 @@ LL | |     }
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
    |
-LL |     unsafe { ptr.write(S(0)) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn callee(x: S, ptr: *mut S) {
+   |           ^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
    |
-LL |     unsafe { ptr.write(S(0)) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn callee(x: S, ptr: *mut S) {
+   |           ^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: stack backtrace:
            0: callee
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
index d625d1d1d034..b7eb3c5e9cab 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
@@ -19,8 +19,8 @@ LL | |     }
 help: <TAG> is this argument
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
    |
-LL |     x.0 = 0;
-   |     ^^^^^^^
+LL | fn change_arg(mut x: S, ptr: *mut S) {
+   |               ^^^^^
    = note: stack backtrace:
            0: change_arg
                at tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
index a01c040fe6f8..e79cf08b15bf 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
@@ -22,13 +22,13 @@ LL | |     }
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
    |
-LL |     x.0 = 0;
-   |     ^^^^^^^
+LL | fn change_arg(mut x: S, ptr: *mut S) {
+   |               ^^^^^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
    |
-LL |     x.0 = 0;
-   |     ^^^^^^^
+LL | fn change_arg(mut x: S, ptr: *mut S) {
+   |               ^^^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: stack backtrace:
            0: change_arg
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.rs b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.rs
index a108944c5e43..81fa672d5229 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.rs
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.rs
@@ -1,9 +1,9 @@
 #[no_mangle]
-fn foo() {}
+fn foo() {} //~ ERROR: calling a function with more arguments than it expected
 
 fn main() {
     extern "Rust" {
         fn foo(_: i32);
     }
-    unsafe { foo(1) } //~ ERROR: calling a function with more arguments than it expected
+    unsafe { foo(1) }
 }
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
index 75c060ea51d4..4c481e8d3cb9 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
@@ -1,11 +1,16 @@
 error: Undefined Behavior: calling a function with more arguments than it expected
   --> tests/fail/function_calls/exported_symbol_wrong_arguments.rs:LL:CC
    |
-LL |     unsafe { foo(1) }
-   |              ^^^^^^ Undefined Behavior occurred here
+LL | fn foo() {}
+   | ^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: stack backtrace:
+           0: foo
+               at tests/fail/function_calls/exported_symbol_wrong_arguments.rs:LL:CC
+           1: main
+               at tests/fail/function_calls/exported_symbol_wrong_arguments.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
index 73c562c94e95..5cf0fd40b58c 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
@@ -19,8 +19,8 @@ LL | |     }
 help: <TAG> was later invalidated at offsets [0x0..0x4] by a Unique in-place function argument/return passing protection
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
    |
-LL |     unsafe { ptr.read() };
-   |     ^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
    = note: stack backtrace:
            0: myfun
                at tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
index 0dc137843c91..cc5f4a812eeb 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
@@ -22,13 +22,13 @@ LL | |     }
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
    |
-LL |     unsafe { ptr.read() };
-   |     ^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
    |
-LL |     unsafe { ptr.read() };
-   |     ^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: stack backtrace:
            0: myfun
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
index 6654ddc12c29..133aa8ca35a1 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
@@ -19,8 +19,8 @@ LL | |     }
 help: <TAG> was later invalidated at offsets [0x0..0x4] by a Unique in-place function argument/return passing protection
   --> tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
    |
-LL |     unsafe { ptr.write(0) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
    = note: stack backtrace:
            0: myfun
                at tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
index 6472dfd4f995..fb87eea63102 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
@@ -22,13 +22,13 @@ LL | |     }
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
    |
-LL |     unsafe { ptr.write(0) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
    |
-LL |     unsafe { ptr.write(0) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: stack backtrace:
            0: myfun
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
index 79f4d2c69f3c..07ed6d128215 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
@@ -19,8 +19,8 @@ LL | |     }
 help: <TAG> was later invalidated at offsets [0x0..0x4] by a Unique in-place function argument/return passing protection
   --> tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
    |
-LL |     become myfun2(ptr)
-   |     ^^^^^^^^^^^^^^^^^^
+LL | fn myfun(ptr: *mut i32) -> i32 {
+   |                            ^^^
    = note: stack backtrace:
            0: myfun2
                at tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr
index 82b898df45b2..e3c5d6baf89f 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr
@@ -22,13 +22,13 @@ LL | |     }
 help: the protected tag <TAG> was created here, in the initial state Reserved
   --> tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
    |
-LL |     unsafe { ptr.write(0) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun2(ptr: *mut i32) -> i32 {
+   |                             ^^^
 help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
    |
-LL |     unsafe { ptr.write(0) };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn myfun2(ptr: *mut i32) -> i32 {
+   |                             ^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: stack backtrace:
            0: myfun2
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs
index 26f2e73dd752..beb0f726568f 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs
@@ -12,10 +12,10 @@ struct S(
 type A = [i32; 4];
 
 fn main() {
-    fn f(_: S) {}
+    fn f(_: S) {} //~ ERROR: type S passing argument of type [i32; 4]
 
     // These two types have the same size but are still not compatible.
     let g = unsafe { std::mem::transmute::<fn(S), fn(A)>(f) };
 
-    g(Default::default()) //~ ERROR: type S passing argument of type [i32; 4]
+    g(Default::default())
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
index 56e69e846696..62ba807d7a95 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type S passing argument of type [i32; 4]
   --> tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs:LL:CC
    |
-LL |     g(Default::default())
-   |     ^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |     fn f(_: S) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs
index 0cca4a132333..a40e5b44660d 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs
@@ -1,7 +1,7 @@
 fn main() {
-    fn f(_: f32) {}
+    fn f(_: f32) {} //~ ERROR: type f32 passing argument of type i32
 
     let g = unsafe { std::mem::transmute::<fn(f32), fn(i32)>(f) };
 
-    g(42) //~ ERROR: type f32 passing argument of type i32
+    g(42)
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
index cbef9d27cdf9..8147d009ff85 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type f32 passing argument of type i32
   --> tests/fail/function_pointers/abi_mismatch_int_vs_float.rs:LL:CC
    |
-LL |     g(42)
-   |     ^^^^^ Undefined Behavior occurred here
+LL |     fn f(_: f32) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_int_vs_float.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_int_vs_float.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.rs
index 053a4a5f2845..8c2d0648cbf1 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.rs
@@ -1,7 +1,7 @@
 fn main() {
-    fn f(_: *const [i32]) {}
+    fn f(_: *const [i32]) {} //~ ERROR: type *const [i32] passing argument of type *const i32
 
     let g = unsafe { std::mem::transmute::<fn(*const [i32]), fn(*const i32)>(f) };
 
-    g(&42 as *const i32) //~ ERROR: type *const [i32] passing argument of type *const i32
+    g(&42 as *const i32)
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
index cd14ea156a47..f9195a869798 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type *const [i32] passing argument of type *const i32
   --> tests/fail/function_pointers/abi_mismatch_raw_pointer.rs:LL:CC
    |
-LL |     g(&42 as *const i32)
-   |     ^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |     fn f(_: *const [i32]) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_raw_pointer.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_raw_pointer.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
index f3dffcc4e867..79485a27ee13 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
@@ -7,10 +7,10 @@
 struct S2(i32);
 
 fn callee(_s: S2) {}
+//~^ ERROR: type S2 passing argument of type S1
 
 fn main() {
     let fnptr: fn(S2) = callee;
     let fnptr: fn(S1) = unsafe { std::mem::transmute(fnptr) };
     fnptr(S1(NonZero::new(1).unwrap()));
-    //~^ ERROR: type S2 passing argument of type S1
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.stderr
index 0e52dc02884c..3e4be1e39fd9 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type S2 passing argument of type S1
   --> tests/fail/function_pointers/abi_mismatch_repr_C.rs:LL:CC
    |
-LL |     fnptr(S1(NonZero::new(1).unwrap()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn callee(_s: S2) {}
+   |           ^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: callee
+               at tests/fail/function_pointers/abi_mismatch_repr_C.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_repr_C.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
index 05b645cf75af..8bf46af71e82 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
@@ -1,9 +1,9 @@
 fn main() {
-    fn f() -> u32 {
+    fn f() -> u32 { //~ ERROR: type u32 passing return place of type ()
         42
     }
 
     let g = unsafe { std::mem::transmute::<fn() -> u32, fn()>(f) };
 
-    g() //~ ERROR: type u32 passing return place of type ()
+    g()
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
index ba940902c8ce..9f206189b6e0 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function with return type u32 passing return place of type ()
   --> tests/fail/function_pointers/abi_mismatch_return_type.rs:LL:CC
    |
-LL |     g()
-   |     ^^^ Undefined Behavior occurred here
+LL |     fn f() -> u32 {
+   |               ^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_return_type.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_return_type.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.rs
index ca43c06008fd..0b06496b2bfd 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.rs
@@ -1,7 +1,7 @@
 fn main() {
-    fn f(_: (i32, i32)) {}
+    fn f(_: (i32, i32)) {} //~ ERROR: type (i32, i32) passing argument of type i32
 
     let g = unsafe { std::mem::transmute::<fn((i32, i32)), fn(i32)>(f) };
 
-    g(42) //~ ERROR: type (i32, i32) passing argument of type i32
+    g(42)
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
index ab9c0e720304..b85ac39faa8f 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type (i32, i32) passing argument of type i32
   --> tests/fail/function_pointers/abi_mismatch_simple.rs:LL:CC
    |
-LL |     g(42)
-   |     ^^^^^ Undefined Behavior occurred here
+LL |     fn f(_: (i32, i32)) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_simple.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_simple.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.rs
index 920fb51abb64..fc9a107f0c73 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.rs
@@ -1,7 +1,7 @@
 fn main() {
-    fn f(_: (i32, i32)) {}
+    fn f(_: (i32, i32)) {} //~ ERROR: calling a function with fewer arguments than it requires
 
     let g = unsafe { std::mem::transmute::<fn((i32, i32)), fn()>(f) };
 
-    g() //~ ERROR: calling a function with fewer arguments than it requires
+    g()
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
index 06e6ccbd7bf2..271ec64475ee 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
@@ -1,11 +1,16 @@
 error: Undefined Behavior: calling a function with fewer arguments than it requires
   --> tests/fail/function_pointers/abi_mismatch_too_few_args.rs:LL:CC
    |
-LL |     g()
-   |     ^^^ Undefined Behavior occurred here
+LL |     fn f(_: (i32, i32)) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_too_few_args.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_too_few_args.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.rs
index c0e96a43cc52..744c5289e018 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.rs
@@ -1,7 +1,7 @@
 fn main() {
-    fn f() {}
+    fn f() {} //~ ERROR: calling a function with more arguments than it expected
 
     let g = unsafe { std::mem::transmute::<fn(), fn(i32)>(f) };
 
-    g(42) //~ ERROR: calling a function with more arguments than it expected
+    g(42)
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
index d343eb8f2599..1721f0f9428c 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
@@ -1,11 +1,16 @@
 error: Undefined Behavior: calling a function with more arguments than it expected
   --> tests/fail/function_pointers/abi_mismatch_too_many_args.rs:LL:CC
    |
-LL |     g(42)
-   |     ^^^^^ Undefined Behavior occurred here
+LL |     fn f() {}
+   |     ^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_too_many_args.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_too_many_args.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.rs
index dedcaac61427..ed5b4696dd0f 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.rs
@@ -2,10 +2,10 @@
 use std::simd;
 
 fn main() {
-    fn f(_: simd::u32x8) {}
+    fn f(_: simd::u32x8) {} //~ ERROR: type std::simd::Simd<u32, 8> passing argument of type std::simd::Simd<u64, 4>
 
     // These two vector types have the same size but are still not compatible.
     let g = unsafe { std::mem::transmute::<fn(simd::u32x8), fn(simd::u64x4)>(f) };
 
-    g(Default::default()) //~ ERROR: type std::simd::Simd<u32, 8> passing argument of type std::simd::Simd<u64, 4>
+    g(Default::default())
 }
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
index 1176589a5f4a..59823fad522b 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type std::simd::Simd<u32, 8> passing argument of type std::simd::Simd<u64, 4>
   --> tests/fail/function_pointers/abi_mismatch_vector.rs:LL:CC
    |
-LL |     g(Default::default())
-   |     ^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |     fn f(_: simd::u32x8) {}
+   |          ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/function_pointers/abi_mismatch_vector.rs:LL:CC
+           1: main
+               at tests/fail/function_pointers/abi_mismatch_vector.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.rs b/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.rs
index 3629e4387e7f..1e10f682e71e 100644
--- a/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.rs
+++ b/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.rs
@@ -1,4 +1,5 @@
 unsafe extern "C" fn ctor() -> i32 {
+    //~^ERROR: calling a function with return type i32 passing return place of type ()
     0
 }
 
@@ -30,7 +31,6 @@ macro_rules! ctor {
         )]
         #[used]
         static $ident: unsafe extern "C" fn() -> i32 = $ctor;
-        //~^ERROR: calling a function with return type i32 passing return place of type ()
     };
 }
 
diff --git a/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.stderr b/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.stderr
index 1b4cd23e41a8..4e474dbadcb6 100644
--- a/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.stderr
+++ b/src/tools/miri/tests/fail/shims/ctor_wrong_ret_type.stderr
@@ -1,18 +1,21 @@
 error: Undefined Behavior: calling a function with return type i32 passing return place of type ()
   --> tests/fail/shims/ctor_wrong_ret_type.rs:LL:CC
    |
-LL |         static $ident: unsafe extern "C" fn() -> i32 = $ctor;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred due to this code
-...
-LL | ctor! { CTOR = ctor }
-   | --------------------- in this macro invocation
+LL | unsafe extern "C" fn ctor() -> i32 {
+   |                                ^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
-   = note: this error occurred while pushing a call frame onto an empty stack
-   = note: the span indicates which code caused the function to be called, but may not be the literal call site
+note: the current function got called indirectly due to this code
+  --> tests/fail/shims/ctor_wrong_ret_type.rs:LL:CC
+   |
+LL |         static $ident: unsafe extern "C" fn() -> i32 = $ctor;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | ctor! { CTOR = ctor }
+   | --------------------- in this macro invocation
    = note: this error originates in the macro `ctor` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.rs b/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.rs
index 36bd1e99cfbc..e747bfdbf520 100644
--- a/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.rs
+++ b/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.rs
@@ -2,16 +2,14 @@
 #![allow(incomplete_features)]
 
 fn main() {
-    // FIXME(explicit_tail_calls):
-    //   the error should point to `become g(x)`,
-    //   but tail calls mess up the backtrace it seems like...
     f(0);
-    //~^ error: type i32 passing argument of type u32
 }
 
 fn f(x: u32) {
     let g = unsafe { std::mem::transmute::<fn(i32), fn(u32)>(g) };
-    become g(x);
+    become g(x); // FIXME ideally this should also be involved in the error somehow,
+    // but by the time we pass the argument, `f`'s stackframe has already been popped.
 }
 
 fn g(_: i32) {}
+//~^ error: type i32 passing argument of type u32
diff --git a/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.stderr b/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.stderr
index f5eccaeba666..9c10db8e5fe4 100644
--- a/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.stderr
+++ b/src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.stderr
@@ -1,13 +1,18 @@
 error: Undefined Behavior: calling a function whose parameter #1 has type i32 passing argument of type u32
   --> tests/fail/tail_calls/signature-mismatch-arg.rs:LL:CC
    |
-LL |     f(0);
-   |     ^^^^ Undefined Behavior occurred here
+LL | fn g(_: i32) {}
+   |      ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
    = help: if you think this code should be accepted anyway, please report an issue with Miri
+   = note: stack backtrace:
+           0: g
+               at tests/fail/tail_calls/signature-mismatch-arg.rs:LL:CC
+           1: main
+               at tests/fail/tail_calls/signature-mismatch-arg.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs
index 6ab73569c634..8657e3ad679d 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs
@@ -5,9 +5,9 @@ fn main() {
     // from raw ptr to reference. This is ABI-compatible, so it's not the call that
     // should fail, but validation should.
     fn f(_x: &i32) {}
+    //~^ ERROR: encountered a null reference
 
     let g: fn(*const i32) = unsafe { std::mem::transmute(f as fn(&i32)) };
 
     g(0usize as *const i32)
-    //~^ ERROR: encountered a null reference
 }
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
index 02e0ebe8abe6..aa797f64ce20 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
@@ -1,11 +1,16 @@
 error: Undefined Behavior: constructing invalid value: encountered a null reference
   --> tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs:LL:CC
    |
-LL |     g(0usize as *const i32)
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |     fn f(_x: &i32) {}
+   |          ^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: stack backtrace:
+           0: main::f
+               at tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs:LL:CC
+           1: main
+               at tests/fail/validity/cast_fn_ptr_invalid_callee_arg.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
index 7ca26bffc14f..7bc26237576a 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
@@ -5,7 +5,7 @@
 use std::num::NonZero;
 use std::ptr;
 
-fn f(c: u32) {
+fn f(c: u32) { //~ERROR: expected something greater or equal to 1
     println!("{c}");
 }
 
@@ -20,7 +20,7 @@ fn call(f: fn(NonZero<u32>)) {
             let tmp = ptr::addr_of!(c);
             let ptr = tmp as *const NonZero<u32>;
             // The call site now is a `NonZero<u32>` to `u32` transmute.
-            Call(_res = f(*ptr), ReturnTo(retblock), UnwindContinue()) //~ERROR: expected something greater or equal to 1
+            Call(_res = f(*ptr), ReturnTo(retblock), UnwindContinue())
         }
         retblock = {
             Return()
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
index 3b23a6cc4e85..e54210981e08 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
@@ -1,15 +1,17 @@
 error: Undefined Behavior: constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
   --> tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs:LL:CC
    |
-LL |             Call(_res = f(*ptr), ReturnTo(retblock), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | fn f(c: u32) {
+   |      ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: stack backtrace:
-           0: call
+           0: f
                at tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs:LL:CC
-           1: main
+           1: call
+               at tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs:LL:CC
+           2: main
                at tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace

From 178882d54c16460059431fa303d2597ad4f5d132 Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@gmail.com>
Date: Mon, 23 Mar 2026 17:41:19 +0000
Subject: [PATCH 0828/1059] Use common Timestamp impl in Hermit (attempt 2)

---
 library/std/src/sys/fs/hermit.rs       |   6 +-
 library/std/src/sys/pal/hermit/mod.rs  |   1 +
 library/std/src/sys/pal/hermit/time.rs | 110 -------------------------
 library/std/src/sys/pal/unix/time.rs   |   3 +-
 library/std/src/sys/time/hermit.rs     |  22 ++---
 5 files changed, 17 insertions(+), 125 deletions(-)
 delete mode 100644 library/std/src/sys/pal/hermit/time.rs

diff --git a/library/std/src/sys/fs/hermit.rs b/library/std/src/sys/fs/hermit.rs
index 1e281eb0d9d1..5992766b5a42 100644
--- a/library/std/src/sys/fs/hermit.rs
+++ b/library/std/src/sys/fs/hermit.rs
@@ -109,15 +109,15 @@ pub struct DirBuilder {
 
 impl FileAttr {
     pub fn modified(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::new(self.stat_val.st_mtim.tv_sec, self.stat_val.st_mtim.tv_nsec))
+        SystemTime::new(self.stat_val.st_mtim.tv_sec, self.stat_val.st_mtim.tv_nsec.into())
     }
 
     pub fn accessed(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::new(self.stat_val.st_atim.tv_sec, self.stat_val.st_atim.tv_nsec))
+        SystemTime::new(self.stat_val.st_atim.tv_sec, self.stat_val.st_atim.tv_nsec.into())
     }
 
     pub fn created(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::new(self.stat_val.st_ctim.tv_sec, self.stat_val.st_ctim.tv_nsec))
+        SystemTime::new(self.stat_val.st_ctim.tv_sec, self.stat_val.st_ctim.tv_nsec.into())
     }
 
     pub fn size(&self) -> u64 {
diff --git a/library/std/src/sys/pal/hermit/mod.rs b/library/std/src/sys/pal/hermit/mod.rs
index b18dc5b103b5..53f6ddd7065d 100644
--- a/library/std/src/sys/pal/hermit/mod.rs
+++ b/library/std/src/sys/pal/hermit/mod.rs
@@ -22,6 +22,7 @@
 use crate::sys::env;
 
 pub mod futex;
+#[path = "../unix/time.rs"]
 pub mod time;
 
 pub fn unsupported<T>() -> io::Result<T> {
diff --git a/library/std/src/sys/pal/hermit/time.rs b/library/std/src/sys/pal/hermit/time.rs
deleted file mode 100644
index b9851eb6754d..000000000000
--- a/library/std/src/sys/pal/hermit/time.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use hermit_abi::{self, timespec};
-
-use crate::cmp::Ordering;
-use crate::hash::{Hash, Hasher};
-use crate::time::Duration;
-
-const NSEC_PER_SEC: i32 = 1_000_000_000;
-
-#[derive(Copy, Clone, Debug)]
-pub struct Timespec {
-    pub t: timespec,
-}
-
-impl Timespec {
-    pub const MAX: Timespec = Self::new(i64::MAX, 1_000_000_000 - 1);
-
-    pub const MIN: Timespec = Self::new(i64::MIN, 0);
-
-    pub const fn zero() -> Timespec {
-        Timespec { t: timespec { tv_sec: 0, tv_nsec: 0 } }
-    }
-
-    pub const fn new(tv_sec: i64, tv_nsec: i32) -> Timespec {
-        assert!(tv_nsec >= 0 && tv_nsec < NSEC_PER_SEC);
-        // SAFETY: The assert above checks tv_nsec is within the valid range
-        Timespec { t: timespec { tv_sec, tv_nsec } }
-    }
-
-    pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
-        fn sub_ge_to_unsigned(a: i64, b: i64) -> u64 {
-            debug_assert!(a >= b);
-            a.wrapping_sub(b).cast_unsigned()
-        }
-
-        if self >= other {
-            // Logic here is identical to Unix version of `Timestamp::sub_timespec`,
-            // check comments there why operations do not overflow.
-            Ok(if self.t.tv_nsec >= other.t.tv_nsec {
-                Duration::new(
-                    sub_ge_to_unsigned(self.t.tv_sec, other.t.tv_sec),
-                    (self.t.tv_nsec - other.t.tv_nsec) as u32,
-                )
-            } else {
-                Duration::new(
-                    sub_ge_to_unsigned(self.t.tv_sec - 1, other.t.tv_sec),
-                    (self.t.tv_nsec + NSEC_PER_SEC - other.t.tv_nsec) as u32,
-                )
-            })
-        } else {
-            match other.sub_timespec(self) {
-                Ok(d) => Err(d),
-                Err(d) => Ok(d),
-            }
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
-        let mut secs = self.t.tv_sec.checked_add_unsigned(other.as_secs())?;
-
-        // Nano calculations can't overflow because nanos are <1B which fit
-        // in a u32.
-        let mut nsec = other.subsec_nanos() + u32::try_from(self.t.tv_nsec).unwrap();
-        if nsec >= NSEC_PER_SEC.try_into().unwrap() {
-            nsec -= u32::try_from(NSEC_PER_SEC).unwrap();
-            secs = secs.checked_add(1)?;
-        }
-        Some(Timespec { t: timespec { tv_sec: secs, tv_nsec: nsec as _ } })
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
-        let mut secs = self.t.tv_sec.checked_sub_unsigned(other.as_secs())?;
-
-        // Similar to above, nanos can't overflow.
-        let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;
-        if nsec < 0 {
-            nsec += NSEC_PER_SEC as i32;
-            secs = secs.checked_sub(1)?;
-        }
-        Some(Timespec { t: timespec { tv_sec: secs, tv_nsec: nsec as _ } })
-    }
-}
-
-impl PartialEq for Timespec {
-    fn eq(&self, other: &Timespec) -> bool {
-        self.t.tv_sec == other.t.tv_sec && self.t.tv_nsec == other.t.tv_nsec
-    }
-}
-
-impl Eq for Timespec {}
-
-impl PartialOrd for Timespec {
-    fn partial_cmp(&self, other: &Timespec) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Timespec {
-    fn cmp(&self, other: &Timespec) -> Ordering {
-        let me = (self.t.tv_sec, self.t.tv_nsec);
-        let other = (other.t.tv_sec, other.t.tv_nsec);
-        me.cmp(&other)
-    }
-}
-
-impl Hash for Timespec {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.t.tv_sec.hash(state);
-        self.t.tv_nsec.hash(state);
-    }
-}
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index fbea94ec84e7..9acc7786b2ed 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -17,7 +17,7 @@
     tv_nsec: (u64::MAX % NSEC_PER_SEC) as i64,
 };
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub(crate) struct Timespec {
     pub tv_sec: i64,
     pub tv_nsec: Nanoseconds,
@@ -66,6 +66,7 @@ pub const fn new(tv_sec: i64, tv_nsec: i64) -> Result<Timespec, io::Error> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn now(clock: libc::clockid_t) -> Timespec {
         use crate::mem::MaybeUninit;
         use crate::sys::cvt;
diff --git a/library/std/src/sys/time/hermit.rs b/library/std/src/sys/time/hermit.rs
index 18ece2e3010d..8e8a656ab61e 100644
--- a/library/std/src/sys/time/hermit.rs
+++ b/library/std/src/sys/time/hermit.rs
@@ -1,18 +1,21 @@
 use hermit_abi::{self, CLOCK_MONOTONIC, CLOCK_REALTIME};
 
-use crate::hash::Hash;
+use crate::io;
 use crate::sys::pal::time::Timespec;
 use crate::time::Duration;
 
+fn clock_gettime(clock: hermit_abi::clockid_t) -> Timespec {
+    let mut t = hermit_abi::timespec { tv_sec: 0, tv_nsec: 0 };
+    let _ = unsafe { hermit_abi::clock_gettime(clock, &raw mut t) };
+    Timespec::new(t.tv_sec, t.tv_nsec.into()).unwrap()
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct Instant(Timespec);
 
 impl Instant {
     pub fn now() -> Instant {
-        let mut time: Timespec = Timespec::zero();
-        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_MONOTONIC, &raw mut time.t) };
-
-        Instant(time)
+        Instant(clock_gettime(CLOCK_MONOTONIC))
     }
 
     pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
@@ -38,15 +41,12 @@ impl SystemTime {
 
     pub const MIN: SystemTime = SystemTime(Timespec::MIN);
 
-    pub fn new(tv_sec: i64, tv_nsec: i32) -> SystemTime {
-        SystemTime(Timespec::new(tv_sec, tv_nsec))
+    pub fn new(tv_sec: i64, tv_nsec: i64) -> Result<SystemTime, io::Error> {
+        Ok(SystemTime(Timespec::new(tv_sec, tv_nsec)?))
     }
 
     pub fn now() -> SystemTime {
-        let mut time: Timespec = Timespec::zero();
-        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_REALTIME, &raw mut time.t) };
-
-        SystemTime(time)
+        SystemTime(clock_gettime(CLOCK_REALTIME))
     }
 
     pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {

From 7df43d309c2722afdcf336a901f86eae18a19072 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 23 Mar 2026 20:08:24 +0000
Subject: [PATCH 0829/1059] allow `incomplete_features` in more tests

---
 src/tools/compiletest/src/runtest.rs          |  5 +---
 .../alias_const_param_ty-1.rs                 |  1 -
 .../alias_const_param_ty-1.stderr             | 11 -------
 .../unsized-anon-const-err-2.rs               |  1 -
 .../unsized-anon-const-err-2.stderr           | 23 +++++----------
 .../defaults/concrete-const-param-type.rs     |  2 --
 .../defaults/concrete-const-param-type.stderr | 21 ++------------
 .../cannot-convert-refree-ice-114463.rs       |  2 +-
 .../cannot-convert-refree-ice-114463.stderr   | 11 +------
 .../const-block-is-poly.rs                    |  1 -
 .../const-block-is-poly.stderr                | 13 ++-------
 .../double-opaque-parent-predicates.rs        |  1 -
 .../double-opaque-parent-predicates.stderr    | 11 -------
 .../generic_const_exprs/eval-try-unify.rs     |  1 -
 .../generic_const_exprs/eval-try-unify.stderr | 11 -------
 .../generic_const_exprs/issue-97047-ice-1.rs  |  2 --
 .../issue-97047-ice-1.stderr                  | 19 ------------
 .../generic_const_exprs/issue-97047-ice-2.rs  |  2 --
 .../issue-97047-ice-2.stderr                  | 19 ------------
 .../mismatched-gat-subst-kind.rs              |  1 -
 .../mismatched-gat-subst-kind.stderr          | 13 ++-------
 .../post-analysis-user-facing-param-env.rs    |  1 -
 ...post-analysis-user-facing-param-env.stderr | 17 +++--------
 .../specialization-fuzzing-ice-133639.rs      |  1 -
 .../specialization-fuzzing-ice-133639.stderr  | 11 -------
 .../check-type-in-mir.rs                      |  2 --
 .../check-type-in-mir.stderr                  | 21 ++------------
 .../references-parent-generics.feat.stderr    | 15 ++--------
 .../references-parent-generics.nofeat.stderr  |  2 +-
 .../references-parent-generics.rs             |  1 -
 .../mgca/struct-ctor-in-array-len.rs          |  1 -
 .../mgca/struct-ctor-in-array-len.stderr      | 13 ++-------
 .../mgca/unexpected-fn-item-in-array.rs       |  1 -
 .../mgca/unexpected-fn-item-in-array.stderr   | 13 ++-------
 .../occurs-check/unify-fixpoint.rs            |  3 +-
 .../occurs-check/unify-fixpoint.stderr        | 11 -------
 .../const-traits/mismatched_generic_args.rs   |  1 -
 .../mismatched_generic_args.stderr            | 21 ++++----------
 ...verlap-const-with-nonconst.min_spec.stderr |  2 +-
 .../overlap-const-with-nonconst.rs            |  1 -
 .../overlap-const-with-nonconst.spec.stderr   | 14 ++-------
 .../negative-impls/negative-default-impls.rs  |  1 -
 .../negative-default-impls.stderr             | 14 ++-------
 .../negative-specializes-negative.rs          |  2 +-
 .../negative-specializes-negative.stderr      | 12 --------
 .../negative-specializes-positive-item.rs     |  2 +-
 .../negative-specializes-positive-item.stderr | 12 +-------
 .../negative-specializes-positive.rs          |  2 +-
 .../negative-specializes-positive.stderr      | 12 +-------
 .../positive-specializes-negative.rs          |  2 +-
 .../positive-specializes-negative.stderr      | 12 +-------
 .../coherence/negative-coherence-bounds.rs    |  1 -
 .../negative-coherence-bounds.stderr          | 12 --------
 .../next-solver/issue-118950-root-region.rs   |  1 -
 .../issue-118950-root-region.stderr           | 17 +++--------
 ...-type-constrains-trait-args.current.stderr | 11 -------
 ...elf-type-constrains-trait-args.next.stderr | 11 -------
 ...rmalize-self-type-constrains-trait-args.rs |  1 -
 .../next-solver/specialization-transmute.rs   |  1 -
 .../specialization-transmute.stderr           | 18 +++---------
 .../specialization-unconstrained.rs           |  1 -
 .../specialization-unconstrained.stderr       | 16 ++--------
 ...on-lifetime-via-dyn-builtin.current.stderr | 11 -------
 .../non-lifetime-via-dyn-builtin.next.stderr  | 11 -------
 .../ui/traits/non-lifetime-via-dyn-builtin.rs |  1 -
 .../non_lifetime_binders/bad-copy-cond.rs     |  1 -
 .../non_lifetime_binders/bad-copy-cond.stderr | 15 ++--------
 .../non_lifetime_binders/bad-sized-cond.rs    |  1 -
 .../bad-sized-cond.stderr                     | 23 +++++----------
 .../bad-suggestion-on-missing-assoc.rs        |  2 --
 .../bad-suggestion-on-missing-assoc.stderr    | 25 +++-------------
 tests/ui/traits/non_lifetime_binders/basic.rs |  1 -
 .../traits/non_lifetime_binders/basic.stderr  | 11 -------
 .../binder-defaults-112547.rs                 |  1 -
 .../binder-defaults-112547.stderr             | 17 +++--------
 .../binder-defaults-119489.rs                 |  2 --
 .../binder-defaults-119489.stderr             | 25 +++-------------
 .../diagnostic-hir-wf-check.rs                |  1 -
 .../diagnostic-hir-wf-check.stderr            | 29 +++++++------------
 .../drop-impl-pred.no.stderr                  | 15 ++--------
 .../non_lifetime_binders/drop-impl-pred.rs    |  1 -
 .../drop-impl-pred.yes.stderr                 | 11 -------
 tests/ui/traits/non_lifetime_binders/fail.rs  |  1 -
 .../traits/non_lifetime_binders/fail.stderr   | 21 ++++----------
 .../foreach-partial-eq.rs                     |  1 -
 .../foreach-partial-eq.stderr                 | 15 ++--------
 .../late-bound-in-anon-ct.rs                  |  2 --
 .../late-bound-in-anon-ct.stderr              | 21 ++------------
 .../late-const-param-wf.rs                    |  1 -
 .../late-const-param-wf.stderr                | 13 ++-------
 .../non_lifetime_binders/method-probe.rs      |  1 -
 .../non_lifetime_binders/method-probe.stderr  | 11 -------
 .../missing-assoc-item.rs                     |  1 -
 .../missing-assoc-item.stderr                 | 13 ++-------
 .../nested-apit-mentioning-outer-bound-var.rs |  1 -
 ...ted-apit-mentioning-outer-bound-var.stderr | 13 ++-------
 .../object-lifetime-default-for-late.rs       |  1 -
 .../object-lifetime-default-for-late.stderr   | 11 -------
 .../ui/traits/non_lifetime_binders/on-dyn.rs  |  1 -
 .../traits/non_lifetime_binders/on-dyn.stderr | 13 ++-------
 .../ui/traits/non_lifetime_binders/on-ptr.rs  |  1 -
 .../traits/non_lifetime_binders/on-ptr.stderr | 13 ++-------
 .../ui/traits/non_lifetime_binders/on-rpit.rs |  1 -
 .../non_lifetime_binders/on-rpit.stderr       | 11 -------
 ...laceholders-dont-outlive-static.bad.stderr | 13 ++-------
 ...aceholders-dont-outlive-static.good.stderr | 13 ++-------
 .../placeholders-dont-outlive-static.rs       |  1 -
 .../traits/non_lifetime_binders/shadowed.rs   |  1 -
 .../non_lifetime_binders/shadowed.stderr      | 19 ++++--------
 .../sized-late-bound-issue-114872.rs          |  1 -
 .../sized-late-bound-issue-114872.stderr      | 11 -------
 .../supertrait-dyn-compatibility.rs           |  1 -
 .../supertrait-dyn-compatibility.stderr       | 15 ++--------
 .../type-match-with-late-bound.stderr         | 11 +------
 ...holders-in-query-response-2.current.stderr | 11 -------
 ...aceholders-in-query-response-2.next.stderr | 11 -------
 ...ifying-placeholders-in-query-response-2.rs |  1 -
 ...ceholders-in-query-response.current.stderr | 11 -------
 ...placeholders-in-query-response.next.stderr | 11 -------
 ...unifying-placeholders-in-query-response.rs |  1 -
 .../non_lifetime_binders/universe-error1.rs   |  1 -
 .../universe-error1.stderr                    | 15 ++--------
 122 files changed, 132 insertions(+), 871 deletions(-)
 delete mode 100644 tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.stderr
 delete mode 100644 tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.stderr
 delete mode 100644 tests/ui/const-generics/generic_const_exprs/eval-try-unify.stderr
 delete mode 100644 tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.stderr
 delete mode 100644 tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.stderr
 delete mode 100644 tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.stderr
 delete mode 100644 tests/ui/const-generics/occurs-check/unify-fixpoint.stderr
 delete mode 100644 tests/ui/traits/negative-impls/negative-specializes-negative.stderr
 delete mode 100644 tests/ui/traits/next-solver/coherence/negative-coherence-bounds.stderr
 delete mode 100644 tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.current.stderr
 delete mode 100644 tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.next.stderr
 delete mode 100644 tests/ui/traits/non-lifetime-via-dyn-builtin.current.stderr
 delete mode 100644 tests/ui/traits/non-lifetime-via-dyn-builtin.next.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/basic.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/drop-impl-pred.yes.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/method-probe.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/on-rpit.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.current.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.next.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.current.stderr
 delete mode 100644 tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.next.stderr

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 40e6c4e593b1..d7b47b38a943 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1922,10 +1922,7 @@ fn make_compile_args(
         // Allow tests to use internal and incomplete features.
         compiler.args(&["-A", "internal_features"]);
         // FIXME(#154168); temporarily exclude some directories to make the transition easier
-        if !input_file
-            .iter()
-            .any(|p| p == "traits" || p == "specialization" || p == "const-generics")
-        {
+        if !input_file.iter().any(|p| p == "specialization") {
             compiler.args(&["-A", "incomplete_features"]);
         }
 
diff --git a/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.rs b/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.rs
index e90426ec0c76..8825d5384ab9 100644
--- a/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.rs
+++ b/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(adt_const_params, lazy_type_alias)]
-//~^ WARN: the feature `lazy_type_alias` is incomplete
 
 pub type Matrix = [usize; 1];
 const EMPTY_MATRIX: Matrix = [0; 1];
diff --git a/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.stderr b/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.stderr
deleted file mode 100644
index 4f5133474c60..000000000000
--- a/tests/ui/const-generics/adt_const_params/alias_const_param_ty-1.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/alias_const_param_ty-1.rs:2:30
-   |
-LL | #![feature(adt_const_params, lazy_type_alias)]
-   |                              ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.rs b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.rs
index 81b1ec6a7719..9e2212bc8097 100644
--- a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.rs
+++ b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.rs
@@ -2,7 +2,6 @@
 
 #![feature(adt_const_params)]
 #![feature(unsized_const_params)]
-//~^ WARN the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
 
 #[derive(Clone)]
 struct S<const L: [u8]>;
diff --git a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.stderr b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.stderr
index d538bb0af09a..8112613f3bf8 100644
--- a/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized-anon-const-err-2.stderr
@@ -1,22 +1,13 @@
 error: free constant item without body
-  --> $DIR/unsized-anon-const-err-2.rs:10:1
+  --> $DIR/unsized-anon-const-err-2.rs:9:1
    |
 LL | const A: [u8];
    | ^^^^^^^^^^^^^-
    |              |
    |              help: provide a definition for the constant: `= <expr>;`
 
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unsized-anon-const-err-2.rs:4:12
-   |
-LL | #![feature(unsized_const_params)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/unsized-anon-const-err-2.rs:10:10
+  --> $DIR/unsized-anon-const-err-2.rs:9:10
    |
 LL | const A: [u8];
    |          ^^^^ doesn't have a size known at compile-time
@@ -25,7 +16,7 @@ LL | const A: [u8];
    = note: statics and constants must have a statically known size
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/unsized-anon-const-err-2.rs:14:31
+  --> $DIR/unsized-anon-const-err-2.rs:13:31
    |
 LL | impl<const N: i32> Copy for S<A> {}
    |                               ^ doesn't have a size known at compile-time
@@ -34,7 +25,7 @@ LL | impl<const N: i32> Copy for S<A> {}
    = note: statics and constants must have a statically known size
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
-  --> $DIR/unsized-anon-const-err-2.rs:17:33
+  --> $DIR/unsized-anon-const-err-2.rs:16:33
    |
 LL | impl<const M: usize> Copy for S<A> {}
    |                                 ^ doesn't have a size known at compile-time
@@ -43,7 +34,7 @@ LL | impl<const M: usize> Copy for S<A> {}
    = note: statics and constants must have a statically known size
 
 error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/unsized-anon-const-err-2.rs:14:6
+  --> $DIR/unsized-anon-const-err-2.rs:13:6
    |
 LL | impl<const N: i32> Copy for S<A> {}
    |      ^^^^^^^^^^^^ unconstrained const parameter
@@ -52,7 +43,7 @@ LL | impl<const N: i32> Copy for S<A> {}
    = note: proving the result of expressions other than the parameter are unique is not supported
 
 error[E0207]: the const parameter `M` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/unsized-anon-const-err-2.rs:17:6
+  --> $DIR/unsized-anon-const-err-2.rs:16:6
    |
 LL | impl<const M: usize> Copy for S<A> {}
    |      ^^^^^^^^^^^^^^ unconstrained const parameter
@@ -60,7 +51,7 @@ LL | impl<const M: usize> Copy for S<A> {}
    = note: expressions using a const parameter must map each value to a distinct output value
    = note: proving the result of expressions other than the parameter are unique is not supported
 
-error: aborting due to 6 previous errors; 1 warning emitted
+error: aborting due to 6 previous errors
 
 Some errors have detailed explanations: E0207, E0277.
 For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/const-generics/defaults/concrete-const-param-type.rs b/tests/ui/const-generics/defaults/concrete-const-param-type.rs
index c411f81192bd..a2eb37b535eb 100644
--- a/tests/ui/const-generics/defaults/concrete-const-param-type.rs
+++ b/tests/ui/const-generics/defaults/concrete-const-param-type.rs
@@ -1,6 +1,4 @@
 #![feature(generic_const_parameter_types, unsized_const_params, adt_const_params)]
-//~^ WARN the feature `generic_const_parameter_types` is incomplete
-//~| WARN the feature `unsized_const_params` is incomplete
 // Make sure that we test the const param type of default const parameters
 // if both the type of the default and the type of the parameter are concrete.
 
diff --git a/tests/ui/const-generics/defaults/concrete-const-param-type.stderr b/tests/ui/const-generics/defaults/concrete-const-param-type.stderr
index ad077f87e5df..805d5a1e91fb 100644
--- a/tests/ui/const-generics/defaults/concrete-const-param-type.stderr
+++ b/tests/ui/const-generics/defaults/concrete-const-param-type.stderr
@@ -1,25 +1,8 @@
-warning: the feature `generic_const_parameter_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/concrete-const-param-type.rs:1:12
-   |
-LL | #![feature(generic_const_parameter_types, unsized_const_params, adt_const_params)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #137626 <https://github.com/rust-lang/rust/issues/137626> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/concrete-const-param-type.rs:1:43
-   |
-LL | #![feature(generic_const_parameter_types, unsized_const_params, adt_const_params)]
-   |                                           ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-
 error: the constant `N` is not of type `u64`
-  --> $DIR/concrete-const-param-type.rs:9:26
+  --> $DIR/concrete-const-param-type.rs:7:26
    |
 LL | struct Foo<const N: u32, const M: u64 = N>;
    |                          ^^^^^^^^^^^^^^^^ expected `u64`, found `u32`
 
-error: aborting due to 1 previous error; 2 warnings emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.rs b/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.rs
index 2ce998e9fd9c..500817996978 100644
--- a/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.rs
+++ b/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.rs
@@ -1,7 +1,7 @@
 // issue: rust-lang/rust#114463
 // ICE cannot convert `ReFree ..` to a region vid
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
+
 fn bug<'a>() {
     [(); (|_: &'a u8| (), 0).1];
     //~^ ERROR cannot capture late-bound lifetime in constant
diff --git a/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.stderr b/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.stderr
index e4845405ec81..a468ba6183ea 100644
--- a/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/cannot-convert-refree-ice-114463.stderr
@@ -1,12 +1,3 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/cannot-convert-refree-ice-114463.rs:3:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: cannot capture late-bound lifetime in constant
   --> $DIR/cannot-convert-refree-ice-114463.rs:6:16
    |
@@ -15,5 +6,5 @@ LL | fn bug<'a>() {
 LL |     [(); (|_: &'a u8| (), 0).1];
    |                ^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
index a6988a492f61..679f6b74bd1d 100644
--- a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
+++ b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.rs
@@ -1,5 +1,4 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 fn foo<T>() {
     let _ = [0u8; { const { std::mem::size_of::<T>() } }];
diff --git a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
index db547e6a2481..78d1540f25ce 100644
--- a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
@@ -1,14 +1,5 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/const-block-is-poly.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: overly complex generic constant
-  --> $DIR/const-block-is-poly.rs:5:19
+  --> $DIR/const-block-is-poly.rs:4:19
    |
 LL |     let _ = [0u8; { const { std::mem::size_of::<T>() } }];
    |                   ^^----------------------------------^^
@@ -18,5 +9,5 @@ LL |     let _ = [0u8; { const { std::mem::size_of::<T>() } }];
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.rs b/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.rs
index e48d559aa327..c5f4bbbf4513 100644
--- a/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.rs
+++ b/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete and may not be safe to use
 
 pub fn y<'a, U: 'a>() -> impl IntoIterator<Item = impl IntoIterator<Item = [u8; { 1 + 2 }]> + 'a> {
     [[[1, 2, 3]]]
diff --git a/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.stderr b/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.stderr
deleted file mode 100644
index faaede13e6b6..000000000000
--- a/tests/ui/const-generics/generic_const_exprs/double-opaque-parent-predicates.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/double-opaque-parent-predicates.rs:3:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/const-generics/generic_const_exprs/eval-try-unify.rs b/tests/ui/const-generics/generic_const_exprs/eval-try-unify.rs
index b61d2dc1945a..d2b8d94c0544 100644
--- a/tests/ui/const-generics/generic_const_exprs/eval-try-unify.rs
+++ b/tests/ui/const-generics/generic_const_exprs/eval-try-unify.rs
@@ -1,7 +1,6 @@
 //@ build-pass
 
 #![feature(generic_const_exprs)]
-//~^ WARNING the feature `generic_const_exprs` is incomplete
 
 trait Generic {
     const ASSOC: usize;
diff --git a/tests/ui/const-generics/generic_const_exprs/eval-try-unify.stderr b/tests/ui/const-generics/generic_const_exprs/eval-try-unify.stderr
deleted file mode 100644
index 8eb1fccc5f88..000000000000
--- a/tests/ui/const-generics/generic_const_exprs/eval-try-unify.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/eval-try-unify.rs:3:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.rs b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.rs
index 443d0a2fe87a..965e07499e18 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.rs
@@ -1,8 +1,6 @@
 //@ check-pass
 
 #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-//~^ WARN the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes [incomplete_features]
-//~^^ WARN the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes [incomplete_features]
 
 pub struct Changes<const CHANGES: &'static [&'static str]>
 where
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.stderr b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.stderr
deleted file mode 100644
index b6b297593a25..000000000000
--- a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-1.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-97047-ice-1.rs:3:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-97047-ice-1.rs:3:52
-   |
-LL | #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-   |                                                    ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-
-warning: 2 warnings emitted
-
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.rs b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.rs
index 6a91b5225672..728d132d4bb1 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.rs
@@ -1,8 +1,6 @@
 //@ check-pass
 
 #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-//~^ WARN the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes [incomplete_features]
-//~^^ WARN the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes [incomplete_features]
 
 pub struct Changes<const CHANGES: &'static [&'static str]>
 where
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.stderr b/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.stderr
deleted file mode 100644
index c0c7dcc79dc4..000000000000
--- a/tests/ui/const-generics/generic_const_exprs/issue-97047-ice-2.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-97047-ice-2.rs:3:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-97047-ice-2.rs:3:52
-   |
-LL | #![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
-   |                                                    ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-
-warning: 2 warnings emitted
-
diff --git a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.rs b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.rs
index 734a37862940..85af36ebe9a6 100644
--- a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.rs
+++ b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.rs
@@ -1,5 +1,4 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 trait B {
     type U<T>;
diff --git a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
index 1036b7261f26..b11eb1059952 100644
--- a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
@@ -1,18 +1,9 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/mismatched-gat-subst-kind.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0747]: constant provided when a type was expected
-  --> $DIR/mismatched-gat-subst-kind.rs:8:13
+  --> $DIR/mismatched-gat-subst-kind.rs:7:13
    |
 LL | fn f<T: B<U<1i32> = ()>>() {}
    |             ^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
index 9af351ec59f0..6e382de436f4 100644
--- a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
+++ b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
@@ -1,6 +1,5 @@
 // Regression test for #133271.
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 
 struct Foo;
 impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
diff --git a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
index 37eb895f9a8d..d58bc6723275 100644
--- a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
@@ -1,5 +1,5 @@
 error[E0407]: method `unimplemented` is not a member of trait `std::ops::Add`
-  --> $DIR/post-analysis-user-facing-param-env.rs:12:5
+  --> $DIR/post-analysis-user-facing-param-env.rs:11:5
    |
 LL | /     fn unimplemented(self, _: &Foo) -> Self::Output {
 LL | |
@@ -7,17 +7,8 @@ LL | |         loop {}
 LL | |     }
    | |_____^ not a member of trait `std::ops::Add`
 
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/post-analysis-user-facing-param-env.rs:2:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0046]: not all trait items implemented, missing: `Output`, `add`
-  --> $DIR/post-analysis-user-facing-param-env.rs:6:1
+  --> $DIR/post-analysis-user-facing-param-env.rs:5:1
    |
 LL | / impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
 LL | |
@@ -30,7 +21,7 @@ LL | |     [(); 1 + 0]: Sized,
    = help: implement the missing item: `fn add(self, _: &'a Foo) -> <Self as Add<&'a Foo>>::Output { todo!() }`
 
 error[E0207]: the const parameter `NUM` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/post-analysis-user-facing-param-env.rs:6:10
+  --> $DIR/post-analysis-user-facing-param-env.rs:5:10
    |
 LL | impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
    |          ^^^^^^^^^^^^^^^^ unconstrained const parameter
@@ -38,7 +29,7 @@ LL | impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
    = note: expressions using a const parameter must map each value to a distinct output value
    = note: proving the result of expressions other than the parameter are unique is not supported
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0046, E0207, E0407.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.rs b/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.rs
index d3ae863bee96..d605c83239b2 100644
--- a/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.rs
+++ b/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.rs
@@ -5,7 +5,6 @@
 #![feature(with_negative_coherence)]
 #![feature(min_specialization)]
 #![feature(generic_const_exprs)]
-//~^ WARNING the feature `generic_const_exprs` is incomplete
 
 #![crate_type = "lib"]
 trait Trait {}
diff --git a/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.stderr b/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.stderr
deleted file mode 100644
index f17b248d856d..000000000000
--- a/tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-fuzzing-ice-133639.rs:7:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.rs b/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.rs
index d3bc544ed6c5..4de1616cdee5 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.rs
@@ -1,8 +1,6 @@
 // Ensure that we actually treat `N`'s type as `&'a u32` in MIR typeck.
 
 #![feature(unsized_const_params, adt_const_params, generic_const_parameter_types)]
-//~^ WARN the feature `unsized_const_params` is incomplete
-//~| WARN the feature `generic_const_parameter_types` is incomplete
 
 fn foo<'a, const N: &'a u32>() {
     let b: &'static u32 = N;
diff --git a/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.stderr b/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.stderr
index 3dc7ce438fa9..0b7a43a391f0 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.stderr
+++ b/tests/ui/const-generics/generic_const_parameter_types/check-type-in-mir.stderr
@@ -1,27 +1,10 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/check-type-in-mir.rs:3:12
-   |
-LL | #![feature(unsized_const_params, adt_const_params, generic_const_parameter_types)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `generic_const_parameter_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/check-type-in-mir.rs:3:52
-   |
-LL | #![feature(unsized_const_params, adt_const_params, generic_const_parameter_types)]
-   |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #137626 <https://github.com/rust-lang/rust/issues/137626> for more information
-
 error: lifetime may not live long enough
-  --> $DIR/check-type-in-mir.rs:8:12
+  --> $DIR/check-type-in-mir.rs:6:12
    |
 LL | fn foo<'a, const N: &'a u32>() {
    |        -- lifetime `'a` defined here
 LL |     let b: &'static u32 = N;
    |            ^^^^^^^^^^^^ type annotation requires that `'a` must outlive `'static`
 
-error: aborting due to 1 previous error; 2 warnings emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
index 2d47797aef28..7e61566aabdd 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
@@ -1,14 +1,5 @@
-warning: the feature `generic_const_parameter_types` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/references-parent-generics.rs:3:27
-   |
-LL | #![cfg_attr(feat, feature(generic_const_parameter_types))]
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #137626 <https://github.com/rust-lang/rust/issues/137626> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: `Self` is forbidden as the type of a const generic parameter
-  --> $DIR/references-parent-generics.rs:7:25
+  --> $DIR/references-parent-generics.rs:6:25
    |
 LL |     type Assoc<const N: Self>;
    |                         ^^^^
@@ -16,10 +7,10 @@ LL |     type Assoc<const N: Self>;
    = note: the only supported types are integers, `bool`, and `char`
 
 error: anonymous constants referencing generics are not yet supported
-  --> $DIR/references-parent-generics.rs:15:21
+  --> $DIR/references-parent-generics.rs:14:21
    |
 LL |     let x: T::Assoc<3>;
    |                     ^
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
index 68ce17317f69..ac25a4eae625 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
@@ -1,5 +1,5 @@
 error[E0770]: the type of const parameters must not depend on other generic parameters
-  --> $DIR/references-parent-generics.rs:7:25
+  --> $DIR/references-parent-generics.rs:6:25
    |
 LL |     type Assoc<const N: Self>;
    |                         ^^^^ the type must not depend on the parameter `Self`
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
index b91050d540c9..6eadb605f97f 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
@@ -1,7 +1,6 @@
 //@ revisions: feat nofeat
 
 #![cfg_attr(feat, feature(generic_const_parameter_types))]
-//[feat]~^ WARN the feature `generic_const_parameter_types` is incomplete
 
 trait Foo {
     type Assoc<const N: Self>;
diff --git a/tests/ui/const-generics/mgca/struct-ctor-in-array-len.rs b/tests/ui/const-generics/mgca/struct-ctor-in-array-len.rs
index 715caef38a9a..c8288431c7ed 100644
--- a/tests/ui/const-generics/mgca/struct-ctor-in-array-len.rs
+++ b/tests/ui/const-generics/mgca/struct-ctor-in-array-len.rs
@@ -6,7 +6,6 @@
 // It should now produce a proper type error.
 
 #![feature(min_generic_const_args)]
-//~^ WARN the feature `min_generic_const_args` is incomplete
 
 struct S;
 
diff --git a/tests/ui/const-generics/mgca/struct-ctor-in-array-len.stderr b/tests/ui/const-generics/mgca/struct-ctor-in-array-len.stderr
index baf587a856bc..fcf02621ca9d 100644
--- a/tests/ui/const-generics/mgca/struct-ctor-in-array-len.stderr
+++ b/tests/ui/const-generics/mgca/struct-ctor-in-array-len.stderr
@@ -1,19 +1,10 @@
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/struct-ctor-in-array-len.rs:8:12
-   |
-LL | #![feature(min_generic_const_args)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: the constant `S` is not of type `usize`
-  --> $DIR/struct-ctor-in-array-len.rs:14:14
+  --> $DIR/struct-ctor-in-array-len.rs:13:14
    |
 LL |     let _b = [0; S];
    |              ^^^^^^ expected `usize`, found `S`
    |
    = note: the length of array `[{integer}; S]` must be type `usize`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.rs b/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.rs
index 1c3274f6a376..4d96d236cf7f 100644
--- a/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.rs
+++ b/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.rs
@@ -1,7 +1,6 @@
 // Make sure we don't ICE when encountering an fn item during lowering in mGCA.
 
 #![feature(min_generic_const_args)]
-//~^ WARN the feature `min_generic_const_args` is incomplete
 
 trait A<T> {}
 
diff --git a/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.stderr b/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.stderr
index 89fc8270e3e7..de64bf7b74c0 100644
--- a/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.stderr
+++ b/tests/ui/const-generics/mgca/unexpected-fn-item-in-array.stderr
@@ -1,19 +1,10 @@
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unexpected-fn-item-in-array.rs:3:12
-   |
-LL | #![feature(min_generic_const_args)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: the constant `fn_item` is not of type `usize`
-  --> $DIR/unexpected-fn-item-in-array.rs:8:6
+  --> $DIR/unexpected-fn-item-in-array.rs:7:6
    |
 LL | impl A<[usize; fn_item]> for () {}
    |      ^^^^^^^^^^^^^^^^^^^ expected `usize`, found fn item
    |
    = note: the length of array `[usize; fn_item]` must be type `usize`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/occurs-check/unify-fixpoint.rs b/tests/ui/const-generics/occurs-check/unify-fixpoint.rs
index 02bc90988e2c..950757efbd42 100644
--- a/tests/ui/const-generics/occurs-check/unify-fixpoint.rs
+++ b/tests/ui/const-generics/occurs-check/unify-fixpoint.rs
@@ -4,8 +4,7 @@
 
 //@ compile-flags: -Zunstable-options
 //@ check-pass
-#![feature(generic_const_exprs)] //~ WARN the feature `generic_const_exprs` is incomplete
-
+#![feature(generic_const_exprs)]
 
 fn bind<const N: usize>(value: [u8; N + 2]) -> [u8; N * 2] {
     todo!()
diff --git a/tests/ui/const-generics/occurs-check/unify-fixpoint.stderr b/tests/ui/const-generics/occurs-check/unify-fixpoint.stderr
deleted file mode 100644
index 8b63e8c55d5c..000000000000
--- a/tests/ui/const-generics/occurs-check/unify-fixpoint.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unify-fixpoint.rs:7:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/const-traits/mismatched_generic_args.rs b/tests/ui/traits/const-traits/mismatched_generic_args.rs
index 21e91c731b36..409a70445680 100644
--- a/tests/ui/traits/const-traits/mismatched_generic_args.rs
+++ b/tests/ui/traits/const-traits/mismatched_generic_args.rs
@@ -1,5 +1,4 @@
 #![feature(generic_const_exprs)]
-//~^ WARN: the feature `generic_const_exprs` is incomplete
 
 // Regression test for #125770 which would ICE under the old effects desugaring that
 // created a const generic parameter for constness on `Add`.
diff --git a/tests/ui/traits/const-traits/mismatched_generic_args.stderr b/tests/ui/traits/const-traits/mismatched_generic_args.stderr
index e8103313dc4f..3094cb501330 100644
--- a/tests/ui/traits/const-traits/mismatched_generic_args.stderr
+++ b/tests/ui/traits/const-traits/mismatched_generic_args.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/mismatched_generic_args.rs:20:9
+  --> $DIR/mismatched_generic_args.rs:19:9
    |
 LL | pub fn add<const U: Dimension>(x: Quantity<f32, U>) -> Quantity<f32, U> {
    |                  - similarly named const parameter `U` defined here
@@ -13,17 +13,8 @@ LL -     x + y
 LL +     x + U
    |
 
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/mismatched_generic_args.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: `Dimension` is forbidden as the type of a const generic parameter
-  --> $DIR/mismatched_generic_args.rs:11:33
+  --> $DIR/mismatched_generic_args.rs:10:33
    |
 LL | pub struct Quantity<S, const D: Dimension>(S);
    |                                 ^^^^^^^^^
@@ -35,13 +26,13 @@ LL + #![feature(adt_const_params)]
    |
 
 error[E0107]: trait takes at most 1 generic argument but 2 generic arguments were supplied
-  --> $DIR/mismatched_generic_args.rs:14:36
+  --> $DIR/mismatched_generic_args.rs:13:36
    |
 LL | impl<const D: Dimension, LHS, RHS> Add<LHS, D> for Quantity<LHS, { Dimension }> {}
    |                                    ^^^ expected at most 1 generic argument
 
 error: `Dimension` is forbidden as the type of a const generic parameter
-  --> $DIR/mismatched_generic_args.rs:14:15
+  --> $DIR/mismatched_generic_args.rs:13:15
    |
 LL | impl<const D: Dimension, LHS, RHS> Add<LHS, D> for Quantity<LHS, { Dimension }> {}
    |               ^^^^^^^^^
@@ -53,7 +44,7 @@ LL + #![feature(adt_const_params)]
    |
 
 error: `Dimension` is forbidden as the type of a const generic parameter
-  --> $DIR/mismatched_generic_args.rs:18:21
+  --> $DIR/mismatched_generic_args.rs:17:21
    |
 LL | pub fn add<const U: Dimension>(x: Quantity<f32, U>) -> Quantity<f32, U> {
    |                     ^^^^^^^^^
@@ -64,7 +55,7 @@ help: add `#![feature(adt_const_params)]` to the crate attributes to enable more
 LL + #![feature(adt_const_params)]
    |
 
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0107, E0425.
 For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/traits/const-traits/overlap-const-with-nonconst.min_spec.stderr b/tests/ui/traits/const-traits/overlap-const-with-nonconst.min_spec.stderr
index a6bd8615d36d..57bb5569c8eb 100644
--- a/tests/ui/traits/const-traits/overlap-const-with-nonconst.min_spec.stderr
+++ b/tests/ui/traits/const-traits/overlap-const-with-nonconst.min_spec.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `Foo` for type `(_,)`
-  --> $DIR/overlap-const-with-nonconst.rs:21:1
+  --> $DIR/overlap-const-with-nonconst.rs:20:1
    |
 LL | / impl<T> const Foo for T
 LL | | where
diff --git a/tests/ui/traits/const-traits/overlap-const-with-nonconst.rs b/tests/ui/traits/const-traits/overlap-const-with-nonconst.rs
index 10dfb200c643..0e21d31a426a 100644
--- a/tests/ui/traits/const-traits/overlap-const-with-nonconst.rs
+++ b/tests/ui/traits/const-traits/overlap-const-with-nonconst.rs
@@ -2,7 +2,6 @@
 
 #![feature(const_trait_impl)]
 #![cfg_attr(spec, feature(specialization))]
-//[spec]~^ WARN the feature `specialization` is incomplete
 #![cfg_attr(min_spec, feature(min_specialization))]
 
 const trait Bar {}
diff --git a/tests/ui/traits/const-traits/overlap-const-with-nonconst.spec.stderr b/tests/ui/traits/const-traits/overlap-const-with-nonconst.spec.stderr
index 91628f65fdcd..57bb5569c8eb 100644
--- a/tests/ui/traits/const-traits/overlap-const-with-nonconst.spec.stderr
+++ b/tests/ui/traits/const-traits/overlap-const-with-nonconst.spec.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-const-with-nonconst.rs:4:27
-   |
-LL | #![cfg_attr(spec, feature(specialization))]
-   |                           ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `Foo` for type `(_,)`
-  --> $DIR/overlap-const-with-nonconst.rs:21:1
+  --> $DIR/overlap-const-with-nonconst.rs:20:1
    |
 LL | / impl<T> const Foo for T
 LL | | where
@@ -19,6 +9,6 @@ LL | |     T: [const] Bar,
 LL |   impl<T> Foo for (T,) {
    |   ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(_,)`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/negative-impls/negative-default-impls.rs b/tests/ui/traits/negative-impls/negative-default-impls.rs
index c68bca432fa8..2d50bc83ec30 100644
--- a/tests/ui/traits/negative-impls/negative-default-impls.rs
+++ b/tests/ui/traits/negative-impls/negative-default-impls.rs
@@ -1,6 +1,5 @@
 #![feature(negative_impls)]
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait MyTrait {
     type Foo;
diff --git a/tests/ui/traits/negative-impls/negative-default-impls.stderr b/tests/ui/traits/negative-impls/negative-default-impls.stderr
index 328e744a1e39..b321898907d5 100644
--- a/tests/ui/traits/negative-impls/negative-default-impls.stderr
+++ b/tests/ui/traits/negative-impls/negative-default-impls.stderr
@@ -1,19 +1,9 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/negative-default-impls.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0750]: negative impls cannot be default impls
-  --> $DIR/negative-default-impls.rs:9:1
+  --> $DIR/negative-default-impls.rs:8:1
    |
 LL | default impl !MyTrait for u32 {}
    | ^^^^^^^      ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0750`.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-negative.rs b/tests/ui/traits/negative-impls/negative-specializes-negative.rs
index bb2856ae7e7c..fe5165a12d1b 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-negative.rs
+++ b/tests/ui/traits/negative-impls/negative-specializes-negative.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 #![feature(negative_impls)]
 
 // Test a negative impl that "specializes" another negative impl.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-negative.stderr b/tests/ui/traits/negative-impls/negative-specializes-negative.stderr
deleted file mode 100644
index 751e29c3b236..000000000000
--- a/tests/ui/traits/negative-impls/negative-specializes-negative.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/negative-specializes-negative.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive-item.rs b/tests/ui/traits/negative-impls/negative-specializes-positive-item.rs
index 4281eedaf631..da22e43377f5 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive-item.rs
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive-item.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 #![feature(negative_impls)]
 
 // Negative impl for u32 cannot "specialize" the base impl.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr b/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
index 97727da76f26..e281969ac2e0 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/negative-specializes-positive-item.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0751]: found both positive and negative implementation of trait `MyTrait` for type `u32`:
   --> $DIR/negative-specializes-positive-item.rs:11:1
    |
@@ -17,6 +7,6 @@ LL | impl<T> MyTrait for T {
 LL | impl !MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^^ negative implementation here
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive.rs b/tests/ui/traits/negative-impls/negative-specializes-positive.rs
index 0e227691e040..1939a098b50e 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive.rs
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 #![feature(negative_impls)]
 
 // Negative impl for u32 cannot "specialize" the base impl.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive.stderr b/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
index 100f97aba93c..6eab4aaf20a5 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/negative-specializes-positive.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0751]: found both positive and negative implementation of trait `MyTrait` for type `u32`:
   --> $DIR/negative-specializes-positive.rs:7:1
    |
@@ -16,6 +6,6 @@ LL | impl<T> MyTrait for T {}
 LL | impl !MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^^ negative implementation here
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/positive-specializes-negative.rs b/tests/ui/traits/negative-impls/positive-specializes-negative.rs
index a06b35765406..f2c5f507a4eb 100644
--- a/tests/ui/traits/negative-impls/positive-specializes-negative.rs
+++ b/tests/ui/traits/negative-impls/positive-specializes-negative.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 #![feature(negative_impls)]
 
 trait MyTrait {}
diff --git a/tests/ui/traits/negative-impls/positive-specializes-negative.stderr b/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
index 1655cb05019c..7c3f5f6ef5c8 100644
--- a/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
+++ b/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/positive-specializes-negative.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0751]: found both positive and negative implementation of trait `MyTrait` for type `u32`:
   --> $DIR/positive-specializes-negative.rs:7:1
    |
@@ -16,6 +6,6 @@ LL | impl<T> !MyTrait for T {}
 LL | impl MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^ positive implementation here
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.rs b/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.rs
index d98cd1147efe..327f731d7e91 100644
--- a/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.rs
+++ b/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.rs
@@ -10,7 +10,6 @@
 // which is provided by the first impl that it is specializing.
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 #![feature(with_negative_coherence)]
 
 trait BoxIter {
diff --git a/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.stderr b/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.stderr
deleted file mode 100644
index 4127f51f56da..000000000000
--- a/tests/ui/traits/next-solver/coherence/negative-coherence-bounds.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/negative-coherence-bounds.rs:12:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/next-solver/issue-118950-root-region.rs b/tests/ui/traits/next-solver/issue-118950-root-region.rs
index 84e2f4c94386..7a4cd2aaa1f1 100644
--- a/tests/ui/traits/next-solver/issue-118950-root-region.rs
+++ b/tests/ui/traits/next-solver/issue-118950-root-region.rs
@@ -3,7 +3,6 @@
 // This is a gnarly test but I don't know how to minimize it, frankly.
 
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete
 
 trait ToUnit<'a> {
     type Unit;
diff --git a/tests/ui/traits/next-solver/issue-118950-root-region.stderr b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
index 74cbb5be02b3..5516f1e36089 100644
--- a/tests/ui/traits/next-solver/issue-118950-root-region.stderr
+++ b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
@@ -1,32 +1,23 @@
 error[E0425]: cannot find type `Missing` in this scope
-  --> $DIR/issue-118950-root-region.rs:19:55
+  --> $DIR/issue-118950-root-region.rs:18:55
    |
 LL | impl<T> Overlap<for<'a> fn(Assoc<'a, T>)> for T where Missing: Overlap<T> {}
    |                                                       ^^^^^^^ not found in this scope
 
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-118950-root-region.rs:5:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `*const T: ToUnit<'a>` is not satisfied
-  --> $DIR/issue-118950-root-region.rs:14:1
+  --> $DIR/issue-118950-root-region.rs:13:1
    |
 LL | type Assoc<'a, T> = <*const T as ToUnit<'a>>::Unit;
    | ^^^^^^^^^^^^^^^^^ the trait `ToUnit<'a>` is not implemented for `*const T`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/issue-118950-root-region.rs:8:1
+  --> $DIR/issue-118950-root-region.rs:7:1
    |
 LL | trait ToUnit<'a> {
    | ^^^^^^^^^^^^^^^^
 
  WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a)), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0277, E0425.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.current.stderr b/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.current.stderr
deleted file mode 100644
index ef636811fd57..000000000000
--- a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.current.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/normalize-self-type-constrains-trait-args.rs:8:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.next.stderr b/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.next.stderr
deleted file mode 100644
index ef636811fd57..000000000000
--- a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/normalize-self-type-constrains-trait-args.rs:8:12
-   |
-LL | #![feature(lazy_type_alias)]
-   |            ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.rs b/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.rs
index c2a016713463..921d753fe2a1 100644
--- a/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.rs
+++ b/tests/ui/traits/next-solver/normalize/normalize-self-type-constrains-trait-args.rs
@@ -6,7 +6,6 @@
 // This goal is also possible w/ a GAT, but lazy_type_alias
 // makes the behavior a bit more readable.
 #![feature(lazy_type_alias)]
-//~^ WARN the feature `lazy_type_alias` is incomplete
 
 struct Wr<T>(T);
 trait Foo {}
diff --git a/tests/ui/traits/next-solver/specialization-transmute.rs b/tests/ui/traits/next-solver/specialization-transmute.rs
index f1447cd6a9e2..ba8b49c9c4c2 100644
--- a/tests/ui/traits/next-solver/specialization-transmute.rs
+++ b/tests/ui/traits/next-solver/specialization-transmute.rs
@@ -1,6 +1,5 @@
 //@ compile-flags: -Znext-solver
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Default {
     type Id;
diff --git a/tests/ui/traits/next-solver/specialization-transmute.stderr b/tests/ui/traits/next-solver/specialization-transmute.stderr
index 8bd290ea1970..bdc03e5e1bf9 100644
--- a/tests/ui/traits/next-solver/specialization-transmute.stderr
+++ b/tests/ui/traits/next-solver/specialization-transmute.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-transmute.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
-  --> $DIR/specialization-transmute.rs:14:9
+  --> $DIR/specialization-transmute.rs:13:9
    |
 LL |     fn intu(&self) -> &Self::Id {
    |                       --------- expected `&<T as Default>::Id` because of return type
@@ -20,7 +10,7 @@ LL |         self
               found reference `&T`
 
 error[E0271]: type mismatch resolving `<u8 as Default>::Id == Option<NonZero<u8>>`
-  --> $DIR/specialization-transmute.rs:25:50
+  --> $DIR/specialization-transmute.rs:24:50
    |
 LL |     let s = transmute::<u8, Option<NonZero<u8>>>(0);
    |             ------------------------------------ ^ types differ
@@ -28,12 +18,12 @@ LL |     let s = transmute::<u8, Option<NonZero<u8>>>(0);
    |             required by a bound introduced by this call
    |
 note: required by a bound in `transmute`
-  --> $DIR/specialization-transmute.rs:18:25
+  --> $DIR/specialization-transmute.rs:17:25
    |
 LL | fn transmute<T: Default<Id = U>, U: Copy>(t: T) -> U {
    |                         ^^^^^^ required by this bound in `transmute`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0271, E0308.
 For more information about an error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/next-solver/specialization-unconstrained.rs b/tests/ui/traits/next-solver/specialization-unconstrained.rs
index 6835c0764d6c..27f6d00111a9 100644
--- a/tests/ui/traits/next-solver/specialization-unconstrained.rs
+++ b/tests/ui/traits/next-solver/specialization-unconstrained.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -Znext-solver
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 // Do not treat the RHS of a projection-goal as an unconstrained `Certainty::Yes` response
 // if the impl is still further specializable.
diff --git a/tests/ui/traits/next-solver/specialization-unconstrained.stderr b/tests/ui/traits/next-solver/specialization-unconstrained.stderr
index 1bcf5eddb5bc..3e3638143873 100644
--- a/tests/ui/traits/next-solver/specialization-unconstrained.stderr
+++ b/tests/ui/traits/next-solver/specialization-unconstrained.stderr
@@ -1,25 +1,15 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-unconstrained.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0271]: type mismatch resolving `<u32 as Default>::Id == ()`
-  --> $DIR/specialization-unconstrained.rs:20:12
+  --> $DIR/specialization-unconstrained.rs:19:12
    |
 LL |     test::<u32, ()>();
    |            ^^^ types differ
    |
 note: required by a bound in `test`
-  --> $DIR/specialization-unconstrained.rs:17:20
+  --> $DIR/specialization-unconstrained.rs:16:20
    |
 LL | fn test<T: Default<Id = U>, U>() {}
    |                    ^^^^^^ required by this bound in `test`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/non-lifetime-via-dyn-builtin.current.stderr b/tests/ui/traits/non-lifetime-via-dyn-builtin.current.stderr
deleted file mode 100644
index 5393db6b1054..000000000000
--- a/tests/ui/traits/non-lifetime-via-dyn-builtin.current.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/non-lifetime-via-dyn-builtin.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non-lifetime-via-dyn-builtin.next.stderr b/tests/ui/traits/non-lifetime-via-dyn-builtin.next.stderr
deleted file mode 100644
index 5393db6b1054..000000000000
--- a/tests/ui/traits/non-lifetime-via-dyn-builtin.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/non-lifetime-via-dyn-builtin.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non-lifetime-via-dyn-builtin.rs b/tests/ui/traits/non-lifetime-via-dyn-builtin.rs
index ac61f8b614c4..00bf23725eb2 100644
--- a/tests/ui/traits/non-lifetime-via-dyn-builtin.rs
+++ b/tests/ui/traits/non-lifetime-via-dyn-builtin.rs
@@ -4,7 +4,6 @@
 //@ check-pass
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete and may not be safe
 
 fn trivial<A>()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.rs b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.rs
index 506cad25f630..9d792ad575e4 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.rs
+++ b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn foo() where for<T> T: Copy {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
index 4694e7da500f..f77d562dbcf2 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
+++ b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
@@ -1,24 +1,15 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/bad-copy-cond.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `T: Copy` is not satisfied
-  --> $DIR/bad-copy-cond.rs:7:5
+  --> $DIR/bad-copy-cond.rs:6:5
    |
 LL |     foo();
    |     ^^^^^ the trait `Copy` is not implemented for `T`
    |
 note: required by a bound in `foo`
-  --> $DIR/bad-copy-cond.rs:4:26
+  --> $DIR/bad-copy-cond.rs:3:26
    |
 LL | fn foo() where for<T> T: Copy {}
    |                          ^^^^ required by this bound in `foo`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/bad-sized-cond.rs b/tests/ui/traits/non_lifetime_binders/bad-sized-cond.rs
index dfc800c8e7e1..244ac2f9c005 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-sized-cond.rs
+++ b/tests/ui/traits/non_lifetime_binders/bad-sized-cond.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN is incomplete and may not be safe
 
 pub fn foo()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/bad-sized-cond.stderr b/tests/ui/traits/non_lifetime_binders/bad-sized-cond.stderr
index f4deb169516c..0b3aa5c904f9 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-sized-cond.stderr
+++ b/tests/ui/traits/non_lifetime_binders/bad-sized-cond.stderr
@@ -1,21 +1,12 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/bad-sized-cond.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the size for values of type `V` cannot be known at compilation time
-  --> $DIR/bad-sized-cond.rs:17:5
+  --> $DIR/bad-sized-cond.rs:16:5
    |
 LL |     foo();
    |     ^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `V`
 note: required by a bound in `foo`
-  --> $DIR/bad-sized-cond.rs:6:15
+  --> $DIR/bad-sized-cond.rs:5:15
    |
 LL | pub fn foo()
    |        --- required by a bound in this function
@@ -24,7 +15,7 @@ LL |     for<V> V: Sized,
    |               ^^^^^ required by this bound in `foo`
 
 error[E0277]: `V` is not an iterator
-  --> $DIR/bad-sized-cond.rs:20:5
+  --> $DIR/bad-sized-cond.rs:19:5
    |
 LL |     bar();
    |     ^^^^^ `V` is not an iterator
@@ -32,7 +23,7 @@ LL |     bar();
    = help: the trait `Iterator` is not implemented for `V`
    = note: required for `V` to implement `IntoIterator`
 note: required by a bound in `bar`
-  --> $DIR/bad-sized-cond.rs:12:15
+  --> $DIR/bad-sized-cond.rs:11:15
    |
 LL | pub fn bar()
    |        --- required by a bound in this function
@@ -41,7 +32,7 @@ LL |     for<V> V: IntoIterator,
    |               ^^^^^^^^^^^^ required by this bound in `bar`
 
 error[E0277]: the size for values of type `V` cannot be known at compilation time
-  --> $DIR/bad-sized-cond.rs:20:5
+  --> $DIR/bad-sized-cond.rs:19:5
    |
 LL |     bar();
    |     ^^^^^ doesn't have a size known at compile-time
@@ -49,7 +40,7 @@ LL |     bar();
    = help: the trait `Sized` is not implemented for `V`
    = note: required for `V` to implement `IntoIterator`
 note: required by a bound in `bar`
-  --> $DIR/bad-sized-cond.rs:12:15
+  --> $DIR/bad-sized-cond.rs:11:15
    |
 LL | pub fn bar()
    |        --- required by a bound in this function
@@ -57,6 +48,6 @@ LL | where
 LL |     for<V> V: IntoIterator,
    |               ^^^^^^^^^^^^ required by this bound in `bar`
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.rs b/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.rs
index b61a21eab419..8ad2ecf8271a 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.rs
+++ b/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.rs
@@ -1,7 +1,5 @@
 #![feature(generic_const_exprs)]
-//~^ WARN the feature `generic_const_exprs` is incomplete
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 // Test for <https://github.com/rust-lang/rust/issues/115497>,
 // which originally relied on associated_type_bounds, but was
diff --git a/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.stderr b/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.stderr
index e891df3f0c09..0f0d2af50ba8 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.stderr
+++ b/tests/ui/traits/non_lifetime_binders/bad-suggestion-on-missing-assoc.stderr
@@ -1,40 +1,23 @@
 error: late-bound const parameters cannot be used currently
-  --> $DIR/bad-suggestion-on-missing-assoc.rs:20:15
+  --> $DIR/bad-suggestion-on-missing-assoc.rs:18:15
    |
 LL |     for<const N: u8 = { T::A }> T: TraitA<AsA = impl TraitB<AsB = impl TraitC>>,
    |               ^
 
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/bad-suggestion-on-missing-assoc.rs:1:12
-   |
-LL | #![feature(generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/bad-suggestion-on-missing-assoc.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-
 error: defaults for generic parameters are not allowed in `for<...>` binders
-  --> $DIR/bad-suggestion-on-missing-assoc.rs:20:9
+  --> $DIR/bad-suggestion-on-missing-assoc.rs:18:9
    |
 LL |     for<const N: u8 = { T::A }> T: TraitA<AsA = impl TraitB<AsB = impl TraitC>>,
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0562]: `impl Trait` is not allowed in bounds
-  --> $DIR/bad-suggestion-on-missing-assoc.rs:20:49
+  --> $DIR/bad-suggestion-on-missing-assoc.rs:18:49
    |
 LL |     for<const N: u8 = { T::A }> T: TraitA<AsA = impl TraitB<AsB = impl TraitC>>,
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
-error: aborting due to 3 previous errors; 2 warnings emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/traits/non_lifetime_binders/basic.rs b/tests/ui/traits/non_lifetime_binders/basic.rs
index 09c0244ec954..893bfd87715f 100644
--- a/tests/ui/traits/non_lifetime_binders/basic.rs
+++ b/tests/ui/traits/non_lifetime_binders/basic.rs
@@ -3,7 +3,6 @@
 
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/basic.stderr b/tests/ui/traits/non_lifetime_binders/basic.stderr
deleted file mode 100644
index 9f2df2238d15..000000000000
--- a/tests/ui/traits/non_lifetime_binders/basic.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/basic.rs:5:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.rs b/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.rs
index 13f9f196970c..894f11ce5faf 100644
--- a/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.rs
+++ b/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 pub fn bar()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.stderr b/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.stderr
index 608e8136d2a8..7383a554bcf3 100644
--- a/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.stderr
+++ b/tests/ui/traits/non_lifetime_binders/binder-defaults-112547.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find type `V` in this scope
-  --> $DIR/binder-defaults-112547.rs:10:4
+  --> $DIR/binder-defaults-112547.rs:9:4
    |
 LL | }> V: IntoIterator
    |    ^ not found in this scope
@@ -10,22 +10,13 @@ LL | pub fn bar<V>()
    |           +++
 
 error: late-bound const parameters cannot be used currently
-  --> $DIR/binder-defaults-112547.rs:6:15
+  --> $DIR/binder-defaults-112547.rs:5:15
    |
 LL |     for<const N: usize = {
    |               ^
 
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/binder-defaults-112547.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: defaults for generic parameters are not allowed in `for<...>` binders
-  --> $DIR/binder-defaults-112547.rs:6:9
+  --> $DIR/binder-defaults-112547.rs:5:9
    |
 LL |       for<const N: usize = {
    |  _________^
@@ -35,6 +26,6 @@ LL | |     (||1usize)()
 LL | | }> V: IntoIterator
    | |_^
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.rs b/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.rs
index bdfe41ca11b0..509bdfc0821b 100644
--- a/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.rs
+++ b/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.rs
@@ -1,6 +1,4 @@
 #![feature(non_lifetime_binders, generic_const_exprs)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
-//~| WARN the feature `generic_const_exprs` is incomplete
 
 fn fun()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.stderr b/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.stderr
index 947dd3a73bf1..4fb7c26fc266 100644
--- a/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.stderr
+++ b/tests/ui/traits/non_lifetime_binders/binder-defaults-119489.stderr
@@ -1,37 +1,20 @@
 error: late-bound const parameters cannot be used currently
-  --> $DIR/binder-defaults-119489.rs:7:23
+  --> $DIR/binder-defaults-119489.rs:5:23
    |
 LL |     for<T = (), const N: usize = 1> ():,
    |                       ^
 
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/binder-defaults-119489.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders, generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/binder-defaults-119489.rs:1:34
-   |
-LL | #![feature(non_lifetime_binders, generic_const_exprs)]
-   |                                  ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-
 error: defaults for generic parameters are not allowed in `for<...>` binders
-  --> $DIR/binder-defaults-119489.rs:7:9
+  --> $DIR/binder-defaults-119489.rs:5:9
    |
 LL |     for<T = (), const N: usize = 1> ():,
    |         ^^^^^^
 
 error: defaults for generic parameters are not allowed in `for<...>` binders
-  --> $DIR/binder-defaults-119489.rs:7:17
+  --> $DIR/binder-defaults-119489.rs:5:17
    |
 LL |     for<T = (), const N: usize = 1> ():,
    |                 ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors; 2 warnings emitted
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.rs b/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.rs
index 22044c2e6627..a2a926e2c27d 100644
--- a/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.rs
+++ b/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.rs
@@ -3,7 +3,6 @@
 
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.stderr b/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.stderr
index 8270fbeef0f6..0277abf52d35 100644
--- a/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.stderr
+++ b/tests/ui/traits/non_lifetime_binders/diagnostic-hir-wf-check.stderr
@@ -1,31 +1,22 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/diagnostic-hir-wf-check.rs:5:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `(): B` is not satisfied
-  --> $DIR/diagnostic-hir-wf-check.rs:16:12
+  --> $DIR/diagnostic-hir-wf-check.rs:15:12
    |
 LL | fn b() -> (W<()>, impl for<C> A<C>) { (W(()), ()) }
    |            ^^^^^ the trait `B` is not implemented for `()`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/diagnostic-hir-wf-check.rs:13:1
+  --> $DIR/diagnostic-hir-wf-check.rs:12:1
    |
 LL | trait B {}
    | ^^^^^^^
 note: required by a bound in `W`
-  --> $DIR/diagnostic-hir-wf-check.rs:14:13
+  --> $DIR/diagnostic-hir-wf-check.rs:13:13
    |
 LL | struct W<T: B>(T);
    |             ^ required by this bound in `W`
 
 error[E0277]: the trait bound `(): B` is not satisfied
-  --> $DIR/diagnostic-hir-wf-check.rs:16:42
+  --> $DIR/diagnostic-hir-wf-check.rs:15:42
    |
 LL | fn b() -> (W<()>, impl for<C> A<C>) { (W(()), ()) }
    |                                        - ^^ the trait `B` is not implemented for `()`
@@ -33,33 +24,33 @@ LL | fn b() -> (W<()>, impl for<C> A<C>) { (W(()), ()) }
    |                                        required by a bound introduced by this call
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/diagnostic-hir-wf-check.rs:13:1
+  --> $DIR/diagnostic-hir-wf-check.rs:12:1
    |
 LL | trait B {}
    | ^^^^^^^
 note: required by a bound in `W`
-  --> $DIR/diagnostic-hir-wf-check.rs:14:13
+  --> $DIR/diagnostic-hir-wf-check.rs:13:13
    |
 LL | struct W<T: B>(T);
    |             ^ required by this bound in `W`
 
 error[E0277]: the trait bound `(): B` is not satisfied
-  --> $DIR/diagnostic-hir-wf-check.rs:16:40
+  --> $DIR/diagnostic-hir-wf-check.rs:15:40
    |
 LL | fn b() -> (W<()>, impl for<C> A<C>) { (W(()), ()) }
    |                                        ^^^^^ the trait `B` is not implemented for `()`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/diagnostic-hir-wf-check.rs:13:1
+  --> $DIR/diagnostic-hir-wf-check.rs:12:1
    |
 LL | trait B {}
    | ^^^^^^^
 note: required by a bound in `W`
-  --> $DIR/diagnostic-hir-wf-check.rs:14:13
+  --> $DIR/diagnostic-hir-wf-check.rs:13:13
    |
 LL | struct W<T: B>(T);
    |             ^ required by this bound in `W`
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
index 1f13207e33ca..9a4d36a02f31 100644
--- a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
+++ b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
@@ -1,24 +1,15 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/drop-impl-pred.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0367]: `Drop` impl requires `H: Foo` but the struct it is implemented for does not
-  --> $DIR/drop-impl-pred.rs:19:15
+  --> $DIR/drop-impl-pred.rs:18:15
    |
 LL |     for<H> H: Foo,
    |               ^^^
    |
 note: the implementor must specify the same requirement
-  --> $DIR/drop-impl-pred.rs:12:1
+  --> $DIR/drop-impl-pred.rs:11:1
    |
 LL | struct Bar<T>(T) where T: Foo;
    | ^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.rs b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.rs
index db8f3de2149d..3444f1067283 100644
--- a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.rs
+++ b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.rs
@@ -4,7 +4,6 @@
 // Issue 110557
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 pub trait Foo {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.yes.stderr b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.yes.stderr
deleted file mode 100644
index 165cf2ee13da..000000000000
--- a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.yes.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/drop-impl-pred.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/fail.rs b/tests/ui/traits/non_lifetime_binders/fail.rs
index 460f68907e88..7d916c422756 100644
--- a/tests/ui/traits/non_lifetime_binders/fail.rs
+++ b/tests/ui/traits/non_lifetime_binders/fail.rs
@@ -1,7 +1,6 @@
 // Error reporting for where `for<T> T: Trait` doesn't hold
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 trait Trait {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/fail.stderr b/tests/ui/traits/non_lifetime_binders/fail.stderr
index 9a324c952931..38a0eabddd3b 100644
--- a/tests/ui/traits/non_lifetime_binders/fail.stderr
+++ b/tests/ui/traits/non_lifetime_binders/fail.stderr
@@ -1,25 +1,16 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/fail.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `T: Trait` is not satisfied
-  --> $DIR/fail.rs:19:5
+  --> $DIR/fail.rs:18:5
    |
 LL |     fail();
    |     ^^^^^^ the trait `Trait` is not implemented for `T`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/fail.rs:6:1
+  --> $DIR/fail.rs:5:1
    |
 LL | trait Trait {}
    | ^^^^^^^^^^^
 note: required by a bound in `fail`
-  --> $DIR/fail.rs:10:15
+  --> $DIR/fail.rs:9:15
    |
 LL | fn fail()
    |    ---- required by a bound in this function
@@ -28,14 +19,14 @@ LL |     for<T> T: Trait,
    |               ^^^^^ required by this bound in `fail`
 
 error[E0277]: `T` cannot be sent between threads safely
-  --> $DIR/fail.rs:21:5
+  --> $DIR/fail.rs:20:5
    |
 LL |     auto_trait();
    |     ^^^^^^^^^^^^ `T` cannot be sent between threads safely
    |
    = help: the trait `Send` is not implemented for `T`
 note: required by a bound in `auto_trait`
-  --> $DIR/fail.rs:15:15
+  --> $DIR/fail.rs:14:15
    |
 LL | fn auto_trait()
    |    ---------- required by a bound in this function
@@ -43,6 +34,6 @@ LL | where
 LL |     for<T> T: Send,
    |               ^^^^ required by this bound in `auto_trait`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.rs b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.rs
index 96a7424f0dc9..0c4347b2e4b3 100644
--- a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.rs
+++ b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn auto_trait()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
index abbdecf2fe1d..b621f5c612de 100644
--- a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
+++ b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
@@ -1,21 +1,12 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/foreach-partial-eq.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: can't compare `T` with `T`
-  --> $DIR/foreach-partial-eq.rs:10:5
+  --> $DIR/foreach-partial-eq.rs:9:5
    |
 LL |     auto_trait();
    |     ^^^^^^^^^^^^ no implementation for `T < T` and `T > T`
    |
    = help: the trait `PartialOrd` is not implemented for `T`
 note: required by a bound in `auto_trait`
-  --> $DIR/foreach-partial-eq.rs:6:27
+  --> $DIR/foreach-partial-eq.rs:5:27
    |
 LL | fn auto_trait()
    |    ---------- required by a bound in this function
@@ -23,6 +14,6 @@ LL | where
 LL |     for<T> T: PartialEq + PartialOrd,
    |                           ^^^^^^^^^^ required by this bound in `auto_trait`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.rs b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.rs
index 94733f88c2da..e8b7139e82ea 100644
--- a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.rs
+++ b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.rs
@@ -1,6 +1,4 @@
 #![feature(non_lifetime_binders, generic_const_exprs)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
-//~| WARN the feature `generic_const_exprs` is incomplete
 
 fn foo() -> usize
 where
diff --git a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
index cc482887c814..cd8bc33ec313 100644
--- a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
+++ b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
@@ -1,27 +1,10 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/late-bound-in-anon-ct.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders, generic_const_exprs)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/late-bound-in-anon-ct.rs:1:34
-   |
-LL | #![feature(non_lifetime_binders, generic_const_exprs)]
-   |                                  ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-
 error: cannot capture late-bound type parameter in constant
-  --> $DIR/late-bound-in-anon-ct.rs:7:27
+  --> $DIR/late-bound-in-anon-ct.rs:5:27
    |
 LL |     for<T> [i32; { let _: T = todo!(); 0 }]:,
    |         -                 ^
    |         |
    |         parameter defined here
 
-error: aborting due to 1 previous error; 2 warnings emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/late-const-param-wf.rs b/tests/ui/traits/non_lifetime_binders/late-const-param-wf.rs
index 2d44388f875f..75117e10bc98 100644
--- a/tests/ui/traits/non_lifetime_binders/late-const-param-wf.rs
+++ b/tests/ui/traits/non_lifetime_binders/late-const-param-wf.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn b()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/late-const-param-wf.stderr b/tests/ui/traits/non_lifetime_binders/late-const-param-wf.stderr
index 136d533a03c4..98558dc74dc2 100644
--- a/tests/ui/traits/non_lifetime_binders/late-const-param-wf.stderr
+++ b/tests/ui/traits/non_lifetime_binders/late-const-param-wf.stderr
@@ -1,17 +1,8 @@
 error: late-bound const parameters cannot be used currently
-  --> $DIR/late-const-param-wf.rs:6:15
+  --> $DIR/late-const-param-wf.rs:5:15
    |
 LL |     for<const C: usize> [(); C]: Copy,
    |               ^
 
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/late-const-param-wf.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/method-probe.rs b/tests/ui/traits/non_lifetime_binders/method-probe.rs
index 5f8e31446f52..3d162524e950 100644
--- a/tests/ui/traits/non_lifetime_binders/method-probe.rs
+++ b/tests/ui/traits/non_lifetime_binders/method-probe.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 trait Foo: for<T> Bar<T> {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/method-probe.stderr b/tests/ui/traits/non_lifetime_binders/method-probe.stderr
deleted file mode 100644
index 8f61792e6ce7..000000000000
--- a/tests/ui/traits/non_lifetime_binders/method-probe.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/method-probe.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.rs b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.rs
index 50f0152e904f..1e645f3e32d2 100644
--- a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.rs
+++ b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn f()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
index 02295307cb22..4de30e77d46b 100644
--- a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
+++ b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
@@ -1,14 +1,5 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/missing-assoc-item.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0223]: ambiguous associated type
-  --> $DIR/missing-assoc-item.rs:6:12
+  --> $DIR/missing-assoc-item.rs:5:12
    |
 LL |     for<B> B::Item: Send,
    |            ^^^^^^^
@@ -19,6 +10,6 @@ LL -     for<B> B::Item: Send,
 LL +     for<B> <B as Example>::Item: Send,
    |
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.rs b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.rs
index e9ae00df7a09..e5ab8d6bc638 100644
--- a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.rs
+++ b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 trait Trait<Input> {
     type Assoc;
diff --git a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
index 830446915091..12eb6c3406c3 100644
--- a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
+++ b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
@@ -1,17 +1,8 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/nested-apit-mentioning-outer-bound-var.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: `impl Trait` can only mention type parameters from an fn or impl
-  --> $DIR/nested-apit-mentioning-outer-bound-var.rs:8:52
+  --> $DIR/nested-apit-mentioning-outer-bound-var.rs:7:52
    |
 LL | fn uwu(_: impl for<T> Trait<(), Assoc = impl Trait<T>>) {}
    |                    - type parameter declared here  ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.rs b/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.rs
index e776d5f2f21a..4ccf4dbd20f8 100644
--- a/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.rs
+++ b/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.rs
@@ -2,6 +2,5 @@
 //@ compile-flags: --crate-type=lib
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 pub fn f<T>() where for<U> (T, U): Copy {}
diff --git a/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.stderr b/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.stderr
deleted file mode 100644
index 667575b72d4c..000000000000
--- a/tests/ui/traits/non_lifetime_binders/object-lifetime-default-for-late.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/object-lifetime-default-for-late.rs:4:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/on-dyn.rs b/tests/ui/traits/non_lifetime_binders/on-dyn.rs
index 8fb7dd27605f..a081974ca8e6 100644
--- a/tests/ui/traits/non_lifetime_binders/on-dyn.rs
+++ b/tests/ui/traits/non_lifetime_binders/on-dyn.rs
@@ -1,7 +1,6 @@
 // Tests to make sure that we reject polymorphic dyn trait.
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 trait Test<T> {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-dyn.stderr b/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
index 2d330f6b1433..8d7cb51c034c 100644
--- a/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
+++ b/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
@@ -1,17 +1,8 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/on-dyn.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: late-bound type parameter not allowed on trait object types
-  --> $DIR/on-dyn.rs:8:30
+  --> $DIR/on-dyn.rs:7:30
    |
 LL | fn foo() -> &'static dyn for<T> Test<T> {
    |                              ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-ptr.rs b/tests/ui/traits/non_lifetime_binders/on-ptr.rs
index 0aaff52b6d8c..96c155a13f3b 100644
--- a/tests/ui/traits/non_lifetime_binders/on-ptr.rs
+++ b/tests/ui/traits/non_lifetime_binders/on-ptr.rs
@@ -1,7 +1,6 @@
 // Tests to make sure that we reject polymorphic fn ptrs.
 
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn foo() -> for<T> fn(T) {
     //~^ ERROR late-bound type parameter not allowed on function pointer types
diff --git a/tests/ui/traits/non_lifetime_binders/on-ptr.stderr b/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
index fbd723a1ba6b..680df6ddd0ae 100644
--- a/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
+++ b/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
@@ -1,17 +1,8 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/on-ptr.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error: late-bound type parameter not allowed on function pointer types
-  --> $DIR/on-ptr.rs:6:17
+  --> $DIR/on-ptr.rs:5:17
    |
 LL | fn foo() -> for<T> fn(T) {
    |                 ^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-rpit.rs b/tests/ui/traits/non_lifetime_binders/on-rpit.rs
index 1364f63a3733..092f838945ae 100644
--- a/tests/ui/traits/non_lifetime_binders/on-rpit.rs
+++ b/tests/ui/traits/non_lifetime_binders/on-rpit.rs
@@ -2,7 +2,6 @@
 
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-rpit.stderr b/tests/ui/traits/non_lifetime_binders/on-rpit.stderr
deleted file mode 100644
index c8396c385484..000000000000
--- a/tests/ui/traits/non_lifetime_binders/on-rpit.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/on-rpit.rs:4:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
index d51927aaa342..f8de7c7d9ebe 100644
--- a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
+++ b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
@@ -1,14 +1,5 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/placeholders-dont-outlive-static.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0310]: the placeholder type `T` may not live long enough
-  --> $DIR/placeholders-dont-outlive-static.rs:13:5
+  --> $DIR/placeholders-dont-outlive-static.rs:12:5
    |
 LL |     foo();
    |     ^^^^^
@@ -21,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn bad() where T: 'static {
    |          ++++++++++++++++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
index bc1a19923997..cc76a8ea0c5c 100644
--- a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
+++ b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
@@ -1,14 +1,5 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/placeholders-dont-outlive-static.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0310]: the placeholder type `T` may not live long enough
-  --> $DIR/placeholders-dont-outlive-static.rs:19:5
+  --> $DIR/placeholders-dont-outlive-static.rs:18:5
    |
 LL |     foo();
    |     ^^^^^
@@ -21,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn good() where for<T> T: 'static, T: 'static {
    |                                  ++++++++++++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.rs b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.rs
index 3133d6aeedce..ca39eb66ed26 100644
--- a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.rs
+++ b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.rs
@@ -4,7 +4,6 @@
 // `for<T> T: 'static` doesn't imply itself when processing outlives obligations
 
 #![feature(non_lifetime_binders)]
-//[bad]~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn foo() where for<T> T: 'static {}
 
diff --git a/tests/ui/traits/non_lifetime_binders/shadowed.rs b/tests/ui/traits/non_lifetime_binders/shadowed.rs
index 1c480e3940b8..ff8d3f7ebb2f 100644
--- a/tests/ui/traits/non_lifetime_binders/shadowed.rs
+++ b/tests/ui/traits/non_lifetime_binders/shadowed.rs
@@ -1,5 +1,4 @@
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 fn function<T>() where for<T> (): Sized {}
 //~^ ERROR the name `T` is already used for a generic parameter
diff --git a/tests/ui/traits/non_lifetime_binders/shadowed.stderr b/tests/ui/traits/non_lifetime_binders/shadowed.stderr
index 59a073aefc96..982bd93f5cf1 100644
--- a/tests/ui/traits/non_lifetime_binders/shadowed.stderr
+++ b/tests/ui/traits/non_lifetime_binders/shadowed.stderr
@@ -1,5 +1,5 @@
 error[E0403]: the name `T` is already used for a generic parameter in this item's generic parameters
-  --> $DIR/shadowed.rs:4:28
+  --> $DIR/shadowed.rs:3:28
    |
 LL | fn function<T>() where for<T> (): Sized {}
    |             -              ^ already used
@@ -7,7 +7,7 @@ LL | fn function<T>() where for<T> (): Sized {}
    |             first use of `T`
 
 error[E0403]: the name `T` is already used for a generic parameter in this item's generic parameters
-  --> $DIR/shadowed.rs:7:31
+  --> $DIR/shadowed.rs:6:31
    |
 LL | struct Struct<T>(T) where for<T> (): Sized;
    |               -               ^ already used
@@ -15,7 +15,7 @@ LL | struct Struct<T>(T) where for<T> (): Sized;
    |               first use of `T`
 
 error[E0403]: the name `T` is already used for a generic parameter in this item's generic parameters
-  --> $DIR/shadowed.rs:11:27
+  --> $DIR/shadowed.rs:10:27
    |
 LL | impl<T> Struct<T> {
    |      - first use of `T`
@@ -23,22 +23,13 @@ LL |     fn method() where for<T> (): Sized {}
    |                           ^ already used
 
 error[E0403]: the name `T` is already used for a generic parameter in this item's generic parameters
-  --> $DIR/shadowed.rs:15:28
+  --> $DIR/shadowed.rs:14:28
    |
 LL | fn repeated() where for<T, T> (): Sized {}
    |                         -  ^ already used
    |                         |
    |                         first use of `T`
 
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/shadowed.rs:1:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.rs b/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.rs
index e4c3b4d2c788..981edc722ea5 100644
--- a/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.rs
+++ b/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.rs
@@ -1,7 +1,6 @@
 //@ check-pass
 
 #![feature(non_lifetime_binders)]
-//~^ WARN is incomplete and may not be safe
 
 pub fn foo()
 where
diff --git a/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.stderr b/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.stderr
deleted file mode 100644
index e75d81270529..000000000000
--- a/tests/ui/traits/non_lifetime_binders/sized-late-bound-issue-114872.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/sized-late-bound-issue-114872.rs:3:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs
index aab5479334e4..3ef1201b523f 100644
--- a/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs
+++ b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs
@@ -1,6 +1,5 @@
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
index b32915ff549f..f1182788a6fd 100644
--- a/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
+++ b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
@@ -1,21 +1,12 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/supertrait-dyn-compatibility.rs:2:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/supertrait-dyn-compatibility.rs:22:17
+  --> $DIR/supertrait-dyn-compatibility.rs:21:17
    |
 LL |     let x: &dyn Foo = &();
    |                 ^^^ `Foo` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/supertrait-dyn-compatibility.rs:7:12
+  --> $DIR/supertrait-dyn-compatibility.rs:6:12
    |
 LL | trait Foo: for<T> Bar<T> {}
    |       ---  ^^^^^^^^^^^^^ ...because where clause cannot reference non-lifetime `for<...>` variables
@@ -23,6 +14,6 @@ LL | trait Foo: for<T> Bar<T> {}
    |       this trait is not dyn compatible...
    = help: only type `()` implements `Foo`; consider using it directly instead.
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr b/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
index c325718b3033..e70ff4a89107 100644
--- a/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
+++ b/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
@@ -1,12 +1,3 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/type-match-with-late-bound.rs:6:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0309]: the placeholder type `F` may not live long enough
   --> $DIR/type-match-with-late-bound.rs:8:32
    |
@@ -54,6 +45,6 @@ help: consider adding an explicit lifetime bound
 LL |     for<F> F: 'a, F: 'a
    |                   +++++
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.current.stderr b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.current.stderr
deleted file mode 100644
index 6551253d2e9e..000000000000
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.current.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unifying-placeholders-in-query-response-2.rs:7:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.next.stderr b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.next.stderr
deleted file mode 100644
index 6551253d2e9e..000000000000
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unifying-placeholders-in-query-response-2.rs:7:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.rs b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.rs
index d900bd429e6e..2962a5b4f4ba 100644
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.rs
+++ b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response-2.rs
@@ -5,7 +5,6 @@
 
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.current.stderr b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.current.stderr
deleted file mode 100644
index fecdc860f8e7..000000000000
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.current.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unifying-placeholders-in-query-response.rs:7:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.next.stderr b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.next.stderr
deleted file mode 100644
index fecdc860f8e7..000000000000
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.next.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unifying-placeholders-in-query-response.rs:7:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.rs b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.rs
index 04e34531f4d7..caad8bf65a90 100644
--- a/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.rs
+++ b/tests/ui/traits/non_lifetime_binders/unifying-placeholders-in-query-response.rs
@@ -5,7 +5,6 @@
 
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/universe-error1.rs b/tests/ui/traits/non_lifetime_binders/universe-error1.rs
index b4e8e3a8aada..1c99794b6a64 100644
--- a/tests/ui/traits/non_lifetime_binders/universe-error1.rs
+++ b/tests/ui/traits/non_lifetime_binders/universe-error1.rs
@@ -1,6 +1,5 @@
 #![feature(sized_hierarchy)]
 #![feature(non_lifetime_binders)]
-//~^ WARN the feature `non_lifetime_binders` is incomplete
 
 use std::marker::PointeeSized;
 
diff --git a/tests/ui/traits/non_lifetime_binders/universe-error1.stderr b/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
index b997e7379e25..899378b2bce4 100644
--- a/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
+++ b/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
@@ -1,20 +1,11 @@
-warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/universe-error1.rs:2:12
-   |
-LL | #![feature(non_lifetime_binders)]
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `T: Other<_>` is not satisfied
-  --> $DIR/universe-error1.rs:17:11
+  --> $DIR/universe-error1.rs:16:11
    |
 LL |     foo::<_>();
    |           ^ the trait `Other<_>` is not implemented for `T`
    |
 note: required by a bound in `foo`
-  --> $DIR/universe-error1.rs:14:15
+  --> $DIR/universe-error1.rs:13:15
    |
 LL | fn foo<U: PointeeSized>()
    |    --- required by a bound in this function
@@ -22,6 +13,6 @@ LL | where
 LL |     for<T> T: Other<U> {}
    |               ^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.

From 953210cfb257a6fc5d2e2b1563935a4a2de3daeb Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 16 Mar 2026 17:14:23 +0100
Subject: [PATCH 0830/1059] Fix `doc_cfg` not working as expected on trait
 impls

---
 src/librustdoc/clean/mod.rs                  | 23 +++++++++++++--
 src/librustdoc/clean/types.rs                |  6 +++-
 src/librustdoc/fold.rs                       |  3 +-
 src/librustdoc/formats/cache.rs              |  2 ++
 src/librustdoc/formats/item_type.rs          |  2 +-
 src/librustdoc/json/conversions.rs           |  1 +
 src/librustdoc/passes/propagate_doc_cfg.rs   | 27 ++++++++++++++++--
 src/librustdoc/passes/propagate_stability.rs |  3 +-
 src/librustdoc/passes/stripper.rs            |  3 ++
 src/librustdoc/visit.rs                      |  3 +-
 src/librustdoc/visit_ast.rs                  | 30 ++++++++++++++------
 11 files changed, 84 insertions(+), 19 deletions(-)

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 13a9c789e895..2c4f85947244 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2776,7 +2776,9 @@ fn get_name(
         // These kinds of item either don't need a `name` or accept a `None` one so we handle them
         // before.
         match item.kind {
-            ItemKind::Impl(ref impl_) => return clean_impl(impl_, item.owner_id.def_id, cx),
+            ItemKind::Impl(ref impl_) => {
+                return clean_impl(impl_, item.owner_id.def_id, cx, renamed);
+            }
             ItemKind::Use(path, kind) => {
                 return clean_use_statement(
                     item,
@@ -2909,10 +2911,27 @@ fn clean_impl<'tcx>(
     impl_: &hir::Impl<'tcx>,
     def_id: LocalDefId,
     cx: &mut DocContext<'tcx>,
+    // If `renamed` is some, then this is an inlined impl and it will be handled later on in the
+    // code. In here, we will generate a placeholder for it in order to be able to compute its
+    // `doc_cfg` info.
+    renamed: Option<Symbol>,
 ) -> Vec<Item> {
     let tcx = cx.tcx;
     let mut ret = Vec::new();
-    let trait_ = impl_.of_trait.map(|t| clean_trait_ref(&t.trait_ref, cx));
+    let trait_ = match impl_.of_trait {
+        Some(t) => {
+            if renamed.is_some() {
+                return vec![Item::from_def_id_and_parts(
+                    def_id.to_def_id(),
+                    None,
+                    PlaceholderImplItem,
+                    cx,
+                )];
+            }
+            Some(clean_trait_ref(&t.trait_ref, cx))
+        }
+        None => None,
+    };
     let items = impl_
         .items
         .iter()
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 431e9ff476f5..ad70fc109669 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -885,6 +885,9 @@ pub(crate) enum ItemKind {
     TraitItem(Box<Trait>),
     TraitAliasItem(TraitAlias),
     ImplItem(Box<Impl>),
+    /// This variant is used only as a placeholder for trait impls in order to correctly compute
+    /// `doc_cfg` as trait impls are added to `clean::Crate` after we went through the whole tree.
+    PlaceholderImplItem,
     /// A required method in a trait declaration meaning it's only a function signature.
     RequiredMethodItem(Box<Function>, Defaultness),
     /// A method in a trait impl or a provided method in a trait declaration.
@@ -964,7 +967,8 @@ pub(crate) fn inner_items(&self) -> impl Iterator<Item = &Item> {
             | AssocTypeItem(..)
             | StrippedItem(_)
             | KeywordItem
-            | AttributeItem => [].iter(),
+            | AttributeItem
+            | PlaceholderImplItem => [].iter(),
         }
     }
 }
diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index c970fdbbc93a..8b9db4638e47 100644
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -97,7 +97,8 @@ fn fold_inner_recur(&mut self, kind: ItemKind) -> ItemKind {
             | RequiredAssocTypeItem(..)
             | AssocTypeItem(..)
             | KeywordItem
-            | AttributeItem => kind,
+            | AttributeItem
+            | PlaceholderImplItem => kind,
         }
     }
 
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index 5a97d8e5b5f4..35071f47a182 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -389,6 +389,8 @@ fn is_from_private_dep(tcx: TyCtxt<'_>, cache: &Cache, def_id: DefId) -> bool {
                 // So would rather leave them to an expert,
                 // as at least the list is better than `_ => {}`.
             }
+
+            clean::PlaceholderImplItem => return None,
         }
 
         // Maintain the parent stack.
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index 6830c1ec6560..eb3492e4625b 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -122,7 +122,7 @@ fn from(item: &'a clean::Item) -> ItemType {
             clean::StaticItem(..) => ItemType::Static,
             clean::ConstantItem(..) => ItemType::Constant,
             clean::TraitItem(..) => ItemType::Trait,
-            clean::ImplItem(..) => ItemType::Impl,
+            clean::ImplItem(..) | clean::PlaceholderImplItem => ItemType::Impl,
             clean::RequiredMethodItem(..) => ItemType::TyMethod,
             clean::MethodItem(..) => ItemType::Method,
             clean::StructFieldItem(..) => ItemType::StructField,
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index bc9ad1606b8a..740fccca9e88 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -353,6 +353,7 @@ fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> ItemEnum
             name: name.as_ref().unwrap().to_string(),
             rename: src.map(|x| x.to_string()),
         },
+        PlaceholderImplItem => unreachable!(),
     }
 }
 
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 54da158d4d39..1430feae6c45 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -1,10 +1,11 @@
 //! Propagates [`#[doc(cfg(...))]`](https://github.com/rust-lang/rust/issues/43781) to child items.
 
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::Attribute;
 use rustc_hir::attrs::{AttributeKind, DocAttribute};
 
 use crate::clean::inline::{load_attrs, merge_attrs};
-use crate::clean::{CfgInfo, Crate, Item, ItemKind};
+use crate::clean::{CfgInfo, Crate, Item, ItemId, ItemKind};
 use crate::core::DocContext;
 use crate::fold::DocFolder;
 use crate::passes::Pass;
@@ -17,7 +18,8 @@
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
     if cx.tcx.features().doc_cfg() {
-        CfgPropagator { cx, cfg_info: CfgInfo::default() }.fold_crate(cr)
+        CfgPropagator { cx, cfg_info: CfgInfo::default(), impl_cfg_info: FxHashMap::default() }
+            .fold_crate(cr)
     } else {
         cr
     }
@@ -26,6 +28,10 @@ pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
 struct CfgPropagator<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,
     cfg_info: CfgInfo,
+
+    /// To ensure the `doc_cfg` feature works with how `rustdoc` handles impl, we need to store
+    /// the `cfg` info of `impl`s placeholder to use them later on the "real" impl item.
+    impl_cfg_info: FxHashMap<ItemId, CfgInfo>,
 }
 
 /// This function goes through the attributes list (`new_attrs`) and extract the `cfg` tokens from
@@ -78,7 +84,22 @@ impl DocFolder for CfgPropagator<'_, '_> {
     fn fold_item(&mut self, mut item: Item) -> Option<Item> {
         let old_cfg_info = self.cfg_info.clone();
 
-        self.merge_with_parent_attributes(&mut item);
+        // If we have an impl, we check if it has an associated `cfg` "context", and if so we will
+        // use this context instead of the actual (wrong) one.
+        if let ItemKind::ImplItem(_) = item.kind
+            && let Some(cfg_info) = self.impl_cfg_info.remove(&item.item_id)
+        {
+            self.cfg_info = cfg_info;
+        }
+
+        if let ItemKind::PlaceholderImplItem = item.kind {
+            // If we have a placeholder impl, we store the current `cfg` "context" to be used
+            // on the actual impl later on (the impls are generated after we go through the whole
+            // AST so they're stored in the `krate` object at the end).
+            self.impl_cfg_info.insert(item.item_id, self.cfg_info.clone());
+        } else {
+            self.merge_with_parent_attributes(&mut item);
+        }
 
         let result = self.fold_item_recur(item);
         self.cfg_info = old_cfg_info;
diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs
index 5139ca301dd3..c8691fd012bf 100644
--- a/src/librustdoc/passes/propagate_stability.rs
+++ b/src/librustdoc/passes/propagate_stability.rs
@@ -107,7 +107,8 @@ fn fold_item(&mut self, mut item: Item) -> Option<Item> {
                     | ItemKind::AssocTypeItem(..)
                     | ItemKind::PrimitiveItem(..)
                     | ItemKind::KeywordItem
-                    | ItemKind::AttributeItem => own_stability,
+                    | ItemKind::AttributeItem
+                    | ItemKind::PlaceholderImplItem => own_stability,
 
                     ItemKind::StrippedItem(..) => unreachable!(),
                 }
diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs
index 99d22526f85b..e348c6b5fc3f 100644
--- a/src/librustdoc/passes/stripper.rs
+++ b/src/librustdoc/passes/stripper.rs
@@ -120,6 +120,9 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
 
             clean::ImplItem(..) => {}
 
+            // They have no use anymore, so always remove them.
+            clean::PlaceholderImplItem => return None,
+
             // tymethods etc. have no control over privacy
             clean::RequiredMethodItem(..)
             | clean::RequiredAssocConstItem(..)
diff --git a/src/librustdoc/visit.rs b/src/librustdoc/visit.rs
index 9f6bf009a054..9cf7d6b29b10 100644
--- a/src/librustdoc/visit.rs
+++ b/src/librustdoc/visit.rs
@@ -50,7 +50,8 @@ fn visit_inner_recur(&mut self, kind: &'a ItemKind) {
             | RequiredAssocTypeItem(..)
             | AssocTypeItem(..)
             | KeywordItem
-            | AttributeItem => {}
+            | AttributeItem
+            | PlaceholderImplItem => {}
         }
     }
 
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index fd6ea21847c1..0ec14e80b215 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -426,12 +426,16 @@ fn visit_item_inner(
             // }
             // Bar::bar();
             // ```
-            if let hir::ItemKind::Impl(impl_) = item.kind &&
-                // Don't duplicate impls when inlining or if it's implementing a trait, we'll pick
-                // them up regardless of where they're located.
-                impl_.of_trait.is_none()
-            {
-                self.add_to_current_mod(item, None, None);
+            if let hir::ItemKind::Impl(impl_) = item.kind {
+                self.add_to_current_mod(
+                    item,
+                    if impl_.of_trait.is_none() {
+                        None
+                    } else {
+                        Some(rustc_span::symbol::kw::Impl)
+                    },
+                    None,
+                );
             }
             return;
         }
@@ -530,10 +534,18 @@ fn visit_item_inner(
                 }
             }
             hir::ItemKind::Impl(impl_) => {
-                // Don't duplicate impls when inlining or if it's implementing a trait, we'll pick
+                // Don't duplicate impls when inlining, we'll pick
                 // them up regardless of where they're located.
-                if !self.inlining && impl_.of_trait.is_none() {
-                    self.add_to_current_mod(item, None, None);
+                if !self.inlining {
+                    self.add_to_current_mod(
+                        item,
+                        if impl_.of_trait.is_none() {
+                            None
+                        } else {
+                            Some(rustc_span::symbol::kw::Impl)
+                        },
+                        None,
+                    );
                 }
             }
         }

From 73fe4c5a3bad04459d53e4364f9facb7583fa63d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 16 Mar 2026 17:14:39 +0100
Subject: [PATCH 0831/1059] Add regression test for #153655

---
 .../doc-cfg/trait-impls-manual.rs             | 92 +++++++++++++++++++
 tests/rustdoc-html/doc-cfg/trait-impls.rs     | 92 +++++++++++++++++++
 2 files changed, 184 insertions(+)
 create mode 100644 tests/rustdoc-html/doc-cfg/trait-impls-manual.rs
 create mode 100644 tests/rustdoc-html/doc-cfg/trait-impls.rs

diff --git a/tests/rustdoc-html/doc-cfg/trait-impls-manual.rs b/tests/rustdoc-html/doc-cfg/trait-impls-manual.rs
new file mode 100644
index 000000000000..fbd96cc46d80
--- /dev/null
+++ b/tests/rustdoc-html/doc-cfg/trait-impls-manual.rs
@@ -0,0 +1,92 @@
+// This test ensures that `doc_cfg` feature is working as expected on trait impls.
+// Regression test for <https://github.com/rust-lang/rust/issues/153655>.
+
+#![feature(doc_cfg)]
+#![doc(auto_cfg(hide(
+    target_pointer_width = "64",
+)))]
+
+#![crate_name = "foo"]
+
+pub trait Trait {
+    fn f(&self) {}
+}
+
+pub trait Bob {
+    fn bob(&self) {}
+}
+
+pub trait Foo {
+    fn foo(&self) {}
+}
+
+pub struct X;
+
+//@has 'foo/struct.X.html'
+//@count - '//*[@id="impl-Bob-for-X"]' 1
+//@count - '//*[@id="impl-Bob-for-X"]/*[@class="item-info"]' 0
+//@count - '//*[@id="impl-Trait-for-X"]' 1
+//@count - '//*[@id="impl-Trait-for-X"]/*[@class="item-info"]' 0
+
+// If you need to update this XPath, in particular `item-info`, update all
+// the others in this file.
+//@count - '//*[@id="impl-Foo-for-X"]/*[@class="item-info"]' 1
+
+//@has 'foo/trait.Trait.html'
+//@count - '//*[@id="impl-Trait-for-X"]' 1
+//@count - '//*[@id="impl-Trait-for-X"]/*[@class="item-info"]' 0
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+#[doc(auto_cfg(hide(target_arch = "wasm32")))]
+mod imp {
+    impl super::Trait for super::X { fn f(&self) {} }
+}
+
+//@has 'foo/trait.Bob.html'
+//@count - '//*[@id="impl-Bob-for-X"]' 1
+//@count - '//*[@id="impl-Bob-for-X"]/*[@class="item-info"]' 0
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+#[doc(auto_cfg = false)]
+mod imp2 {
+    impl super::Bob for super::X { fn bob(&self) {} }
+}
+
+//@has 'foo/trait.Foo.html'
+//@count - '//*[@id="impl-Foo-for-X"]/*[@class="item-info"]' 1
+// We use this to force xpath tests to be updated if `item-info` class is changed.
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+mod imp3 {
+    impl super::Foo for super::X { fn foo(&self) {} }
+}
+
+pub struct Y;
+
+//@has 'foo/struct.Y.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 0
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+#[doc(auto_cfg(hide(target_arch = "wasm32")))]
+mod imp4 {
+    impl super::Y { pub fn plain_auto() {} }
+}
+
+pub struct Z;
+
+//@has 'foo/struct.Z.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 0
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+#[doc(auto_cfg = false)]
+mod imp5 {
+    impl super::Z { pub fn plain_auto() {} }
+}
+
+// The "witness" which has the item info.
+pub struct W;
+
+//@has 'foo/struct.W.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 1
+#[doc(cfg(any(target_pointer_width = "64", target_arch = "wasm32")))]
+mod imp6 {
+    impl super::W { pub fn plain_auto() {} }
+}
diff --git a/tests/rustdoc-html/doc-cfg/trait-impls.rs b/tests/rustdoc-html/doc-cfg/trait-impls.rs
new file mode 100644
index 000000000000..581d171123d0
--- /dev/null
+++ b/tests/rustdoc-html/doc-cfg/trait-impls.rs
@@ -0,0 +1,92 @@
+// This test ensures that `doc_cfg` feature is working as expected on trait impls.
+// Regression test for <https://github.com/rust-lang/rust/issues/153655>.
+
+#![feature(doc_cfg)]
+#![doc(auto_cfg(hide(
+    target_pointer_width = "64",
+)))]
+
+#![crate_name = "foo"]
+
+pub trait Trait {
+    fn f(&self) {}
+}
+
+pub trait Bob {
+    fn bob(&self) {}
+}
+
+pub trait Foo {
+    fn foo(&self) {}
+}
+
+pub struct X;
+
+//@has 'foo/struct.X.html'
+//@count - '//*[@id="impl-Bob-for-X"]' 1
+//@count - '//*[@id="impl-Bob-for-X"]/*[@class="item-info"]' 0
+//@count - '//*[@id="impl-Trait-for-X"]' 1
+//@count - '//*[@id="impl-Trait-for-X"]/*[@class="item-info"]' 0
+
+// If you need to update this XPath, in particular `item-info`, update all
+// the others in this file.
+//@count - '//*[@id="impl-Foo-for-X"]/*[@class="item-info"]' 1
+
+//@has 'foo/trait.Trait.html'
+//@count - '//*[@id="impl-Trait-for-X"]' 1
+//@count - '//*[@id="impl-Trait-for-X"]/*[@class="item-info"]' 0
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+#[doc(auto_cfg(hide(target_arch = "wasm32")))]
+mod imp {
+    impl super::Trait for super::X { fn f(&self) {} }
+}
+
+//@has 'foo/trait.Bob.html'
+//@count - '//*[@id="impl-Bob-for-X"]' 1
+//@count - '//*[@id="impl-Bob-for-X"]/*[@class="item-info"]' 0
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+#[doc(auto_cfg = false)]
+mod imp2 {
+    impl super::Bob for super::X { fn bob(&self) {} }
+}
+
+//@has 'foo/trait.Foo.html'
+//@count - '//*[@id="impl-Foo-for-X"]/*[@class="item-info"]' 1
+// We use this to force xpath tests to be updated if `item-info` class is changed.
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+mod imp3 {
+    impl super::Foo for super::X { fn foo(&self) {} }
+}
+
+pub struct Y;
+
+//@has 'foo/struct.Y.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 0
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+#[doc(auto_cfg(hide(target_arch = "wasm32")))]
+mod imp4 {
+    impl super::Y { pub fn plain_auto() {} }
+}
+
+pub struct Z;
+
+//@has 'foo/struct.Z.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 0
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+#[doc(auto_cfg = false)]
+mod imp5 {
+    impl super::Z { pub fn plain_auto() {} }
+}
+
+// The "witness" which has the item info.
+pub struct W;
+
+//@has 'foo/struct.W.html'
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]' 1
+//@count - '//*[@id="implementations-list"]/*[@class="impl-items"]/*[@class="item-info"]' 1
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+mod imp6 {
+    impl super::W { pub fn plain_auto() {} }
+}

From 6fcd01151ecb79a00b1f5fb59b791aa0f5cb1be1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 16 Mar 2026 20:15:57 +0100
Subject: [PATCH 0832/1059] Correctly handle rustdoc `PlaceholderImplItem` in
 lints

---
 src/librustdoc/passes/calculate_doc_coverage.rs    | 2 +-
 src/librustdoc/passes/check_doc_test_visibility.rs | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
index 77b3a2e9c9f2..fcaf665a1fda 100644
--- a/src/librustdoc/passes/calculate_doc_coverage.rs
+++ b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -199,7 +199,7 @@ fn visit_item(&mut self, i: &clean::Item) {
         }
 
         match i.kind {
-            clean::StrippedItem(..) => {
+            clean::StrippedItem(..) | clean::PlaceholderImplItem => {
                 // don't count items in stripped modules
                 return;
             }
diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs
index a1578ab40209..ff7535fea41c 100644
--- a/src/librustdoc/passes/check_doc_test_visibility.rs
+++ b/src/librustdoc/passes/check_doc_test_visibility.rs
@@ -80,6 +80,7 @@ pub(crate) fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -
                 | clean::ImplAssocConstItem(..)
                 | clean::RequiredAssocTypeItem(..)
                 | clean::ImplItem(_)
+                | clean::PlaceholderImplItem
         )
     {
         return false;

From 24e40f002cff39fe916a534c960067859c75515f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 17 Mar 2026 11:32:53 +0100
Subject: [PATCH 0833/1059] Add more comments to explain code

---
 src/librustdoc/clean/mod.rs                     | 5 ++++-
 src/librustdoc/json/conversions.rs              | 1 +
 src/librustdoc/passes/calculate_doc_coverage.rs | 6 +++++-
 src/librustdoc/passes/stripper.rs               | 3 ++-
 src/librustdoc/visit_ast.rs                     | 8 ++++++++
 5 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 2c4f85947244..47da69110f09 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2777,6 +2777,9 @@ fn get_name(
         // before.
         match item.kind {
             ItemKind::Impl(ref impl_) => {
+                // `renamed` is passed down to `clean_impl` because we use it as a marker to
+                // indicate that this is an inlined impl and that we should generate an impl
+                // placeholder and not a "real" impl item.
                 return clean_impl(impl_, item.owner_id.def_id, cx, renamed);
             }
             ItemKind::Use(path, kind) => {
@@ -2911,7 +2914,7 @@ fn clean_impl<'tcx>(
     impl_: &hir::Impl<'tcx>,
     def_id: LocalDefId,
     cx: &mut DocContext<'tcx>,
-    // If `renamed` is some, then this is an inlined impl and it will be handled later on in the
+    // If `renamed` is some, then `impl_` is an inlined impl and it will be handled later on in the
     // code. In here, we will generate a placeholder for it in order to be able to compute its
     // `doc_cfg` info.
     renamed: Option<Symbol>,
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 740fccca9e88..5d1f4778f1c5 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -353,6 +353,7 @@ fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> ItemEnum
             name: name.as_ref().unwrap().to_string(),
             rename: src.map(|x| x.to_string()),
         },
+        // All placeholder impl items should have been removed in the stripper passes.
         PlaceholderImplItem => unreachable!(),
     }
 }
diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
index fcaf665a1fda..ac5e7805005e 100644
--- a/src/librustdoc/passes/calculate_doc_coverage.rs
+++ b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -199,10 +199,14 @@ fn visit_item(&mut self, i: &clean::Item) {
         }
 
         match i.kind {
-            clean::StrippedItem(..) | clean::PlaceholderImplItem => {
+            clean::StrippedItem(..) => {
                 // don't count items in stripped modules
                 return;
             }
+            clean::PlaceholderImplItem => {
+                // The "real" impl items are handled below.
+                return;
+            }
             // docs on `use` and `extern crate` statements are not displayed, so they're not
             // worth counting
             clean::ImportItem(..) | clean::ExternCrateItem { .. } => {}
diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs
index e348c6b5fc3f..bf4e842ceec3 100644
--- a/src/librustdoc/passes/stripper.rs
+++ b/src/librustdoc/passes/stripper.rs
@@ -120,7 +120,8 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
 
             clean::ImplItem(..) => {}
 
-            // They have no use anymore, so always remove them.
+            // Since the `doc_cfg` propagation was handled before the current pass, we can (and
+            // should) remove all placeholder impl items.
             clean::PlaceholderImplItem => return None,
 
             // tymethods etc. have no control over privacy
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 0ec14e80b215..8425ed2d63c1 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -429,6 +429,10 @@ fn visit_item_inner(
             if let hir::ItemKind::Impl(impl_) = item.kind {
                 self.add_to_current_mod(
                     item,
+                    // The symbol here is used as a "sentinel" value and has no meaning in
+                    // itself. It just tells that this is an inlined impl and that it should not
+                    // be cleaned as a normal `ImplItem` but instead as a `PlaceholderImplItem`.
+                    // It's to ensure that `doc_cfg` inheritance works as expected.
                     if impl_.of_trait.is_none() {
                         None
                     } else {
@@ -539,6 +543,10 @@ fn visit_item_inner(
                 if !self.inlining {
                     self.add_to_current_mod(
                         item,
+                        // The symbol here is used as a "sentinel" value and has no meaning in
+                        // itself. It just tells that this is an inlined impl and that it should not
+                        // be cleaned as a normal `ImplItem` but instead as a `PlaceholderImplItem`.
+                        // It's to ensure that `doc_cfg` inheritance works as expected.
                         if impl_.of_trait.is_none() {
                             None
                         } else {

From 19876d196fb27db7d8208ba7e84d51007ef28524 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Mon, 23 Mar 2026 21:47:29 +0100
Subject: [PATCH 0834/1059] Simplify code and improve code comments

---
 src/librustdoc/clean/mod.rs                | 16 ++++-----
 src/librustdoc/passes/propagate_doc_cfg.rs |  4 +--
 src/librustdoc/visit_ast.rs                | 41 ++++++++--------------
 3 files changed, 25 insertions(+), 36 deletions(-)

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 47da69110f09..f54339429fa5 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2777,10 +2777,10 @@ fn get_name(
         // before.
         match item.kind {
             ItemKind::Impl(ref impl_) => {
-                // `renamed` is passed down to `clean_impl` because we use it as a marker to
-                // indicate that this is an inlined impl and that we should generate an impl
-                // placeholder and not a "real" impl item.
-                return clean_impl(impl_, item.owner_id.def_id, cx, renamed);
+                // If `renamed` is `Some()` for an `impl`, it means it's been inlined because we use
+                // it as a marker to indicate that this is an inlined impl and that we should
+                // generate an impl placeholder and not a "real" impl item.
+                return clean_impl(impl_, item.owner_id.def_id, cx, renamed.is_some());
             }
             ItemKind::Use(path, kind) => {
                 return clean_use_statement(
@@ -2914,16 +2914,16 @@ fn clean_impl<'tcx>(
     impl_: &hir::Impl<'tcx>,
     def_id: LocalDefId,
     cx: &mut DocContext<'tcx>,
-    // If `renamed` is some, then `impl_` is an inlined impl and it will be handled later on in the
-    // code. In here, we will generate a placeholder for it in order to be able to compute its
+    // If true, this is an inlined impl and it will be handled later on in the code.
+    // In here, we will generate a placeholder for it in order to be able to compute its
     // `doc_cfg` info.
-    renamed: Option<Symbol>,
+    is_inlined: bool,
 ) -> Vec<Item> {
     let tcx = cx.tcx;
     let mut ret = Vec::new();
     let trait_ = match impl_.of_trait {
         Some(t) => {
-            if renamed.is_some() {
+            if is_inlined {
                 return vec![Item::from_def_id_and_parts(
                     def_id.to_def_id(),
                     None,
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 1430feae6c45..f73db253af06 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -29,7 +29,7 @@ struct CfgPropagator<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,
     cfg_info: CfgInfo,
 
-    /// To ensure the `doc_cfg` feature works with how `rustdoc` handles impl, we need to store
+    /// To ensure the `doc_cfg` feature works with how `rustdoc` handles impls, we need to store
     /// the `cfg` info of `impl`s placeholder to use them later on the "real" impl item.
     impl_cfg_info: FxHashMap<ItemId, CfgInfo>,
 }
@@ -85,7 +85,7 @@ fn fold_item(&mut self, mut item: Item) -> Option<Item> {
         let old_cfg_info = self.cfg_info.clone();
 
         // If we have an impl, we check if it has an associated `cfg` "context", and if so we will
-        // use this context instead of the actual (wrong) one.
+        // use that context instead of the actual (wrong) one.
         if let ItemKind::ImplItem(_) = item.kind
             && let Some(cfg_info) = self.impl_cfg_info.remove(&item.item_id)
         {
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 8425ed2d63c1..906289ba755e 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -372,6 +372,19 @@ fn reexport_public_and_not_hidden(
             && !inherits_doc_hidden(tcx, item_def_id, None)
     }
 
+    #[inline]
+    fn add_impl_to_current_mod(&mut self, item: &'tcx hir::Item<'_>, impl_: hir::Impl<'_>) {
+        self.add_to_current_mod(
+            item,
+            // The symbol here is used as a "sentinel" value and has no meaning in
+            // itself. It just tells that this is an inlined impl and that it should not
+            // be cleaned as a normal `ImplItem` but instead as a `PlaceholderImplItem`.
+            // It's to ensure that `doc_cfg` inheritance works as expected.
+            if impl_.of_trait.is_none() { None } else { Some(rustc_span::symbol::kw::Impl) },
+            None,
+        );
+    }
+
     #[inline]
     fn add_to_current_mod(
         &mut self,
@@ -427,19 +440,7 @@ fn visit_item_inner(
             // Bar::bar();
             // ```
             if let hir::ItemKind::Impl(impl_) = item.kind {
-                self.add_to_current_mod(
-                    item,
-                    // The symbol here is used as a "sentinel" value and has no meaning in
-                    // itself. It just tells that this is an inlined impl and that it should not
-                    // be cleaned as a normal `ImplItem` but instead as a `PlaceholderImplItem`.
-                    // It's to ensure that `doc_cfg` inheritance works as expected.
-                    if impl_.of_trait.is_none() {
-                        None
-                    } else {
-                        Some(rustc_span::symbol::kw::Impl)
-                    },
-                    None,
-                );
+                self.add_impl_to_current_mod(item, impl_);
             }
             return;
         }
@@ -541,19 +542,7 @@ fn visit_item_inner(
                 // Don't duplicate impls when inlining, we'll pick
                 // them up regardless of where they're located.
                 if !self.inlining {
-                    self.add_to_current_mod(
-                        item,
-                        // The symbol here is used as a "sentinel" value and has no meaning in
-                        // itself. It just tells that this is an inlined impl and that it should not
-                        // be cleaned as a normal `ImplItem` but instead as a `PlaceholderImplItem`.
-                        // It's to ensure that `doc_cfg` inheritance works as expected.
-                        if impl_.of_trait.is_none() {
-                            None
-                        } else {
-                            Some(rustc_span::symbol::kw::Impl)
-                        },
-                        None,
-                    );
+                    self.add_impl_to_current_mod(item, impl_);
                 }
             }
         }

From ae3d87c2a80170371a776a54472bf3d30be871e9 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Mon, 23 Mar 2026 14:28:42 -0700
Subject: [PATCH 0835/1059] Update shebang reference names

This updates the rule names for shebang which were changed in
https://github.com/rust-lang/reference/pull/2192 and
https://github.com/rust-lang/reference/pull/2199.
---
 tests/ui/parser/shebang/multiline-attrib.rs    | 2 +-
 tests/ui/parser/shebang/regular-attrib.rs      | 2 +-
 tests/ui/parser/shebang/shebang-and-attrib.rs  | 2 +-
 tests/ui/parser/shebang/shebang-doc-comment.rs | 2 +-
 tests/ui/parser/shebang/sneaky-attrib.rs       | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/ui/parser/shebang/multiline-attrib.rs b/tests/ui/parser/shebang/multiline-attrib.rs
index 2d2e02986386..d67ba5facd9f 100644
--- a/tests/ui/parser/shebang/multiline-attrib.rs
+++ b/tests/ui/parser/shebang/multiline-attrib.rs
@@ -1,7 +1,7 @@
 #!
 [allow(unused_variables)]
 //@ check-pass
-//@ reference: input.shebang.inner-attribute
+//@ reference: shebang.syntax-description
 
 fn main() {
     let x = 5;
diff --git a/tests/ui/parser/shebang/regular-attrib.rs b/tests/ui/parser/shebang/regular-attrib.rs
index c2ac25661ef0..f711b81c72fe 100644
--- a/tests/ui/parser/shebang/regular-attrib.rs
+++ b/tests/ui/parser/shebang/regular-attrib.rs
@@ -1,6 +1,6 @@
 #![allow(unused_variables)]
 //@ check-pass
-//@ reference: input.shebang.inner-attribute
+//@ reference: shebang.syntax-description
 fn main() {
     let x = 5;
 }
diff --git a/tests/ui/parser/shebang/shebang-and-attrib.rs b/tests/ui/parser/shebang/shebang-and-attrib.rs
index d73db6b22f05..e3e52b5c7504 100644
--- a/tests/ui/parser/shebang/shebang-and-attrib.rs
+++ b/tests/ui/parser/shebang/shebang-and-attrib.rs
@@ -1,7 +1,7 @@
 #!/usr/bin/env run-cargo-script
 
 //@ check-pass
-//@ reference: input.shebang.inner-attribute
+//@ reference: shebang.syntax-description
 #![allow(unused_variables)]
 
 
diff --git a/tests/ui/parser/shebang/shebang-doc-comment.rs b/tests/ui/parser/shebang/shebang-doc-comment.rs
index 4992c758325a..976a2b390712 100644
--- a/tests/ui/parser/shebang/shebang-doc-comment.rs
+++ b/tests/ui/parser/shebang/shebang-doc-comment.rs
@@ -2,4 +2,4 @@
 [allow(unused_variables)]
 //~^ ERROR expected item, found `[`
 
-//@ reference: input.shebang.inner-attribute
+//@ reference: shebang.syntax-description
diff --git a/tests/ui/parser/shebang/sneaky-attrib.rs b/tests/ui/parser/shebang/sneaky-attrib.rs
index e22c45cc39f5..b9c4adbe2bb2 100644
--- a/tests/ui/parser/shebang/sneaky-attrib.rs
+++ b/tests/ui/parser/shebang/sneaky-attrib.rs
@@ -11,7 +11,7 @@
 [allow(unused_variables)]
 
 //@ check-pass
-//@ reference: input.shebang.inner-attribute
+//@ reference: shebang.syntax-description
 fn main() {
     let x = 5;
 }

From 6df99d652364f3ab702eb73f700cca40fe99bf15 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 23 Mar 2026 20:56:05 +0100
Subject: [PATCH 0836/1059] asm: use `minicore` more in aarch64/x86_64 asm
 tests

---
 tests/auxiliary/minicore.rs                   |  2 +
 tests/ui/asm/aarch64/aarch64-sve.rs           | 14 ++-
 tests/ui/asm/aarch64/bad-options.rs           | 11 ++-
 tests/ui/asm/aarch64/bad-options.stderr       | 26 ++---
 tests/ui/asm/aarch64/bad-reg.rs               |  5 +-
 tests/ui/asm/aarch64/bad-reg.stderr           | 44 ++++-----
 tests/ui/asm/aarch64/duplicate-options.fixed  | 12 ++-
 tests/ui/asm/aarch64/duplicate-options.rs     | 12 ++-
 tests/ui/asm/aarch64/duplicate-options.stderr | 18 ++--
 tests/ui/asm/aarch64/interpolated-idents.rs   | 13 ++-
 .../ui/asm/aarch64/interpolated-idents.stderr |  6 +-
 tests/ui/asm/aarch64/parse-error.rs           | 11 ++-
 tests/ui/asm/aarch64/parse-error.stderr       | 10 +-
 tests/ui/asm/aarch64/srcloc.rs                | 15 ++-
 tests/ui/asm/aarch64/srcloc.stderr            | 94 +++++++++---------
 tests/ui/asm/aarch64/ttbr0_el2.rs             | 12 ++-
 tests/ui/asm/x86_64/bad-clobber-abi.rs        | 11 ++-
 tests/ui/asm/x86_64/bad-clobber-abi.stderr    | 20 ++--
 tests/ui/asm/x86_64/bad-options.rs            | 11 ++-
 tests/ui/asm/x86_64/bad-options.stderr        | 32 +++----
 tests/ui/asm/x86_64/bad-reg.rs                |  4 +-
 tests/ui/asm/x86_64/goto-block-safe.rs        | 14 ++-
 tests/ui/asm/x86_64/goto-block-safe.stderr    |  8 +-
 tests/ui/asm/x86_64/interpolated-idents.rs    | 10 +-
 .../ui/asm/x86_64/interpolated-idents.stderr  |  6 +-
 tests/ui/asm/x86_64/issue-82869.rs            | 14 ++-
 tests/ui/asm/x86_64/issue-82869.stderr        |  6 +-
 tests/ui/asm/x86_64/issue-89875.rs            | 13 ++-
 tests/ui/asm/x86_64/issue-96797.rs            | 16 ++--
 tests/ui/asm/x86_64/srcloc.rs                 | 13 ++-
 tests/ui/asm/x86_64/srcloc.stderr             | 96 +++++++++----------
 tests/ui/asm/x86_64/target-feature-attr.rs    | 15 ++-
 .../ui/asm/x86_64/target-feature-attr.stderr  |  8 +-
 tests/ui/asm/x86_64/x86_64_parse_error.rs     | 12 ++-
 tests/ui/asm/x86_64/x86_64_parse_error.stderr | 10 +-
 35 files changed, 366 insertions(+), 258 deletions(-)

diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 3b43a0de9db0..d84357edd042 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -238,6 +238,8 @@ pub trait Sync {}
 
 impl Sync for () {}
 
+impl<T, const N: usize> Sync for [T; N] {}
+
 #[lang = "drop_in_place"]
 fn drop_in_place<T>(_: *mut T) {}
 
diff --git a/tests/ui/asm/aarch64/aarch64-sve.rs b/tests/ui/asm/aarch64/aarch64-sve.rs
index 81c82d5ad006..a146d7334555 100644
--- a/tests/ui/asm/aarch64/aarch64-sve.rs
+++ b/tests/ui/asm/aarch64/aarch64-sve.rs
@@ -1,13 +1,17 @@
-//@ only-aarch64
 //@ build-pass
-//@ needs-asm-support
-
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
 #![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
 
 // AArch64 test corresponding to arm64ec-sve.rs.
 
-use std::arch::asm;
-
 fn f(x: f64) {
     unsafe {
         asm!("", out("p0") _);
diff --git a/tests/ui/asm/aarch64/bad-options.rs b/tests/ui/asm/aarch64/bad-options.rs
index 9e721d55b2d7..ebba9255d324 100644
--- a/tests/ui/asm/aarch64/bad-options.rs
+++ b/tests/ui/asm/aarch64/bad-options.rs
@@ -1,6 +1,13 @@
-//@ only-aarch64
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::{asm, global_asm};
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     let mut foo = 0;
diff --git a/tests/ui/asm/aarch64/bad-options.stderr b/tests/ui/asm/aarch64/bad-options.stderr
index f7252d0ad374..8f3e464a7200 100644
--- a/tests/ui/asm/aarch64/bad-options.stderr
+++ b/tests/ui/asm/aarch64/bad-options.stderr
@@ -1,35 +1,35 @@
 error: the `nomem` and `readonly` options are mutually exclusive
-  --> $DIR/bad-options.rs:8:18
+  --> $DIR/bad-options.rs:15:18
    |
 LL |         asm!("", options(nomem, readonly));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the `pure` and `noreturn` options are mutually exclusive
-  --> $DIR/bad-options.rs:10:18
+  --> $DIR/bad-options.rs:17:18
    |
 LL |         asm!("", options(pure, nomem, noreturn));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: asm with the `pure` option must have at least one output
-  --> $DIR/bad-options.rs:10:18
+  --> $DIR/bad-options.rs:17:18
    |
 LL |         asm!("", options(pure, nomem, noreturn));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: asm with the `pure` option must have at least one output
-  --> $DIR/bad-options.rs:13:33
+  --> $DIR/bad-options.rs:20:33
    |
 LL |         asm!("{}", in(reg) foo, options(pure, nomem));
    |                                 ^^^^^^^^^^^^^^^^^^^^
 
 error: asm outputs are not allowed with the `noreturn` option
-  --> $DIR/bad-options.rs:15:20
+  --> $DIR/bad-options.rs:22:20
    |
 LL |         asm!("{}", out(reg) foo, options(noreturn));
    |                    ^^^^^^^^^^^^
 
 error: asm with `clobber_abi` must specify explicit registers for outputs
-  --> $DIR/bad-options.rs:22:20
+  --> $DIR/bad-options.rs:29:20
    |
 LL |         asm!("{}", out(reg) foo, clobber_abi("C"));
    |                    ^^^^^^^^^^^^  ---------------- clobber_abi
@@ -37,43 +37,43 @@ LL |         asm!("{}", out(reg) foo, clobber_abi("C"));
    |                    generic outputs
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:28:25
+  --> $DIR/bad-options.rs:35:25
    |
 LL | global_asm!("", options(nomem));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: the `readonly` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:30:25
+  --> $DIR/bad-options.rs:37:25
    |
 LL | global_asm!("", options(readonly));
    |                         ^^^^^^^^ the `readonly` option is not meaningful for global-scoped inline assembly
 
 error: the `noreturn` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:32:25
+  --> $DIR/bad-options.rs:39:25
    |
 LL | global_asm!("", options(noreturn));
    |                         ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly
 
 error: the `pure` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:34:25
+  --> $DIR/bad-options.rs:41:25
    |
 LL | global_asm!("", options(pure));
    |                         ^^^^ the `pure` option is not meaningful for global-scoped inline assembly
 
 error: the `nostack` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:36:25
+  --> $DIR/bad-options.rs:43:25
    |
 LL | global_asm!("", options(nostack));
    |                         ^^^^^^^ the `nostack` option is not meaningful for global-scoped inline assembly
 
 error: the `preserves_flags` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:38:25
+  --> $DIR/bad-options.rs:45:25
    |
 LL | global_asm!("", options(preserves_flags));
    |                         ^^^^^^^^^^^^^^^ the `preserves_flags` option is not meaningful for global-scoped inline assembly
 
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-options.rs:20:18
+  --> $DIR/bad-options.rs:27:18
    |
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/aarch64/bad-reg.rs b/tests/ui/asm/aarch64/bad-reg.rs
index 676d736e15d7..39a3e386bb6e 100644
--- a/tests/ui/asm/aarch64/bad-reg.rs
+++ b/tests/ui/asm/aarch64/bad-reg.rs
@@ -1,6 +1,7 @@
 //@ add-minicore
-//@ only-aarch64
-//@ compile-flags: -C target-feature=+neon
+//@ compile-flags: --target aarch64-unknown-linux-gnu -C target-feature=+neon
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
 #![crate_type = "lib"]
 #![feature(no_core)]
 #![no_core]
diff --git a/tests/ui/asm/aarch64/bad-reg.stderr b/tests/ui/asm/aarch64/bad-reg.stderr
index 62f66cf3424f..9f3d54eb4666 100644
--- a/tests/ui/asm/aarch64/bad-reg.stderr
+++ b/tests/ui/asm/aarch64/bad-reg.stderr
@@ -1,5 +1,5 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:17:20
+  --> $DIR/bad-reg.rs:18:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |         asm!("{}", in(foo) foo);
    = note: the following register classes are supported on this target: `reg`, `vreg`, `vreg_low16`, and `preg`
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:19:18
+  --> $DIR/bad-reg.rs:20:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid asm template modifier `z` for this register class
-  --> $DIR/bad-reg.rs:21:15
+  --> $DIR/bad-reg.rs:22:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
@@ -23,7 +23,7 @@ LL |         asm!("{:z}", in(reg) foo);
    = note: the `reg` register class supports the following template modifiers: `w` and `x`
 
 error: invalid asm template modifier `r` for this register class
-  --> $DIR/bad-reg.rs:23:15
+  --> $DIR/bad-reg.rs:24:15
    |
 LL |         asm!("{:r}", in(vreg) foo);
    |               ^^^^   ------------ argument
@@ -33,7 +33,7 @@ LL |         asm!("{:r}", in(vreg) foo);
    = note: the `vreg` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, and `v`
 
 error: invalid asm template modifier `r` for this register class
-  --> $DIR/bad-reg.rs:25:15
+  --> $DIR/bad-reg.rs:26:15
    |
 LL |         asm!("{:r}", in(vreg_low16) foo);
    |               ^^^^   ------------------ argument
@@ -43,7 +43,7 @@ LL |         asm!("{:r}", in(vreg_low16) foo);
    = note: the `vreg_low16` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, and `v`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:27:15
+  --> $DIR/bad-reg.rs:28:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -51,7 +51,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:29:15
+  --> $DIR/bad-reg.rs:30:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -59,49 +59,49 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `x29`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:31:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", in("x29") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", in("sp") foo);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `xzr`: the zero register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:36:18
    |
 LL |         asm!("", in("xzr") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `x19`: x19 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:38:18
    |
 LL |         asm!("", in("x19") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:40:18
+  --> $DIR/bad-reg.rs:41:18
    |
 LL |         asm!("", in("p0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:44:20
+  --> $DIR/bad-reg.rs:45:20
    |
 LL |         asm!("{}", in(preg) foo);
    |                    ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:47:20
+  --> $DIR/bad-reg.rs:48:20
    |
 LL |         asm!("{}", out(preg) _);
    |                    ^^^^^^^^^^^
 
 error: register `w0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:53:32
+  --> $DIR/bad-reg.rs:54:32
    |
 LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `w0`
@@ -109,7 +109,7 @@ LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  register `x0`
 
 error: register `x0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:55:32
+  --> $DIR/bad-reg.rs:56:32
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `x0`
@@ -117,13 +117,13 @@ LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  register `x0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:55:18
+  --> $DIR/bad-reg.rs:56:18
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ^^^^^^^^^^^^
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:58:32
+  --> $DIR/bad-reg.rs:59:32
    |
 LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `q0`
@@ -131,7 +131,7 @@ LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  register `v0`
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:60:32
+  --> $DIR/bad-reg.rs:61:32
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `q0`
@@ -139,13 +139,13 @@ LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  register `v0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:60:18
+  --> $DIR/bad-reg.rs:61:18
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:40:27
+  --> $DIR/bad-reg.rs:41:27
    |
 LL |         asm!("", in("p0") foo);
    |                           ^^^
@@ -153,7 +153,7 @@ LL |         asm!("", in("p0") foo);
    = note: register class `preg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:44:29
+  --> $DIR/bad-reg.rs:45:29
    |
 LL |         asm!("{}", in(preg) foo);
    |                             ^^^
diff --git a/tests/ui/asm/aarch64/duplicate-options.fixed b/tests/ui/asm/aarch64/duplicate-options.fixed
index b221c7c78bc7..efddf9570e31 100644
--- a/tests/ui/asm/aarch64/duplicate-options.fixed
+++ b/tests/ui/asm/aarch64/duplicate-options.fixed
@@ -1,8 +1,14 @@
-//@ only-aarch64
-//@ needs-asm-support
 //@ run-rustfix
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ needs-asm-support
+//@ ignore-backends: gcc
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     unsafe {
diff --git a/tests/ui/asm/aarch64/duplicate-options.rs b/tests/ui/asm/aarch64/duplicate-options.rs
index 44a45187d2d5..ee45e7b322d0 100644
--- a/tests/ui/asm/aarch64/duplicate-options.rs
+++ b/tests/ui/asm/aarch64/duplicate-options.rs
@@ -1,8 +1,14 @@
-//@ only-aarch64
-//@ needs-asm-support
 //@ run-rustfix
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ needs-asm-support
+//@ ignore-backends: gcc
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     unsafe {
diff --git a/tests/ui/asm/aarch64/duplicate-options.stderr b/tests/ui/asm/aarch64/duplicate-options.stderr
index feb3838f4f79..06bd9ea6baf9 100644
--- a/tests/ui/asm/aarch64/duplicate-options.stderr
+++ b/tests/ui/asm/aarch64/duplicate-options.stderr
@@ -1,53 +1,53 @@
 error: the `nomem` option was already provided
-  --> $DIR/duplicate-options.rs:9:33
+  --> $DIR/duplicate-options.rs:15:33
    |
 LL |         asm!("", options(nomem, nomem));
    |                                 ^^^^^ this option was already provided
 
 error: the `preserves_flags` option was already provided
-  --> $DIR/duplicate-options.rs:11:43
+  --> $DIR/duplicate-options.rs:17:43
    |
 LL |         asm!("", options(preserves_flags, preserves_flags));
    |                                           ^^^^^^^^^^^^^^^ this option was already provided
 
 error: the `nostack` option was already provided
-  --> $DIR/duplicate-options.rs:13:61
+  --> $DIR/duplicate-options.rs:19:61
    |
 LL |         asm!("", options(nostack, preserves_flags), options(nostack));
    |                                                             ^^^^^^^ this option was already provided
 
 error: the `nostack` option was already provided
-  --> $DIR/duplicate-options.rs:15:35
+  --> $DIR/duplicate-options.rs:21:35
    |
 LL |         asm!("", options(nostack, nostack), options(nostack), options(nostack));
    |                                   ^^^^^^^ this option was already provided
 
 error: the `nostack` option was already provided
-  --> $DIR/duplicate-options.rs:15:53
+  --> $DIR/duplicate-options.rs:21:53
    |
 LL |         asm!("", options(nostack, nostack), options(nostack), options(nostack));
    |                                                     ^^^^^^^ this option was already provided
 
 error: the `nostack` option was already provided
-  --> $DIR/duplicate-options.rs:15:71
+  --> $DIR/duplicate-options.rs:21:71
    |
 LL |         asm!("", options(nostack, nostack), options(nostack), options(nostack));
    |                                                                       ^^^^^^^ this option was already provided
 
 error: the `noreturn` option was already provided
-  --> $DIR/duplicate-options.rs:22:38
+  --> $DIR/duplicate-options.rs:28:38
    |
 LL |             options(preserves_flags, noreturn),
    |                                      ^^^^^^^^ this option was already provided
 
 error: the `nomem` option was already provided
-  --> $DIR/duplicate-options.rs:23:21
+  --> $DIR/duplicate-options.rs:29:21
    |
 LL |             options(nomem, nostack),
    |                     ^^^^^ this option was already provided
 
 error: the `noreturn` option was already provided
-  --> $DIR/duplicate-options.rs:24:21
+  --> $DIR/duplicate-options.rs:30:21
    |
 LL |             options(noreturn),
    |                     ^^^^^^^^ this option was already provided
diff --git a/tests/ui/asm/aarch64/interpolated-idents.rs b/tests/ui/asm/aarch64/interpolated-idents.rs
index 3d9cf763e4d7..d51fdbc6add2 100644
--- a/tests/ui/asm/aarch64/interpolated-idents.rs
+++ b/tests/ui/asm/aarch64/interpolated-idents.rs
@@ -1,6 +1,13 @@
-//@ only-aarch64
-//@ needs-asm-support
-use std::arch::asm;
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
 
 macro_rules! m {
     ($in:ident $out:ident $lateout:ident $inout:ident $inlateout:ident $const:ident $sym:ident
diff --git a/tests/ui/asm/aarch64/interpolated-idents.stderr b/tests/ui/asm/aarch64/interpolated-idents.stderr
index 74cb992f2adb..8537a5ebf46b 100644
--- a/tests/ui/asm/aarch64/interpolated-idents.stderr
+++ b/tests/ui/asm/aarch64/interpolated-idents.stderr
@@ -1,5 +1,5 @@
 error: the `nomem` and `readonly` options are mutually exclusive
-  --> $DIR/interpolated-idents.rs:13:13
+  --> $DIR/interpolated-idents.rs:20:13
    |
 LL |               $options($pure, $nomem, $readonly, $preserves_flags, $noreturn, $nostack));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | |        noreturn nostack options);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: the `pure` and `noreturn` options are mutually exclusive
-  --> $DIR/interpolated-idents.rs:13:13
+  --> $DIR/interpolated-idents.rs:20:13
    |
 LL |               $options($pure, $nomem, $readonly, $preserves_flags, $noreturn, $nostack));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | |        noreturn nostack options);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm outputs are not allowed with the `noreturn` option
-  --> $DIR/interpolated-idents.rs:10:32
+  --> $DIR/interpolated-idents.rs:17:32
    |
 LL |               asm!("", $in(x) x, $out(x) x, $lateout(x) x, $inout(x) x, $inlateout(x) x,
    |                                  ^^^^^^^^^  ^^^^^^^^^^^^^  ^^^^^^^^^^^  ^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/aarch64/parse-error.rs b/tests/ui/asm/aarch64/parse-error.rs
index 622f99aa1b1e..f9ee9a1802b1 100644
--- a/tests/ui/asm/aarch64/parse-error.rs
+++ b/tests/ui/asm/aarch64/parse-error.rs
@@ -1,6 +1,13 @@
-//@ only-aarch64
+//@ add-minicore
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     let mut foo = 0;
diff --git a/tests/ui/asm/aarch64/parse-error.stderr b/tests/ui/asm/aarch64/parse-error.stderr
index ca21311f87f9..630f2a4f2241 100644
--- a/tests/ui/asm/aarch64/parse-error.stderr
+++ b/tests/ui/asm/aarch64/parse-error.stderr
@@ -1,11 +1,11 @@
 error: explicit register arguments cannot have names
-  --> $DIR/parse-error.rs:9:18
+  --> $DIR/parse-error.rs:16:18
    |
 LL |         asm!("", a = in("x0") foo);
    |                  ^^^^^^^^^^^^^^^^
 
 error: positional arguments cannot follow named arguments or explicit register arguments
-  --> $DIR/parse-error.rs:15:35
+  --> $DIR/parse-error.rs:22:35
    |
 LL |         asm!("{1}", in("x0") foo, const bar);
    |                     ------------  ^^^^^^^^^ positional argument
@@ -13,7 +13,7 @@ LL |         asm!("{1}", in("x0") foo, const bar);
    |                     explicit register argument
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:11:45
+  --> $DIR/parse-error.rs:18:45
    |
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
@@ -25,7 +25,7 @@ LL +     const bar: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:13:45
+  --> $DIR/parse-error.rs:20:45
    |
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
@@ -37,7 +37,7 @@ LL +     const bar: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:15:41
+  --> $DIR/parse-error.rs:22:41
    |
 LL |         asm!("{1}", in("x0") foo, const bar);
    |                                         ^^^ non-constant value
diff --git a/tests/ui/asm/aarch64/srcloc.rs b/tests/ui/asm/aarch64/srcloc.rs
index c635fa6ba700..91a2ef3514ae 100644
--- a/tests/ui/asm/aarch64/srcloc.rs
+++ b/tests/ui/asm/aarch64/srcloc.rs
@@ -1,12 +1,19 @@
-//@ only-aarch64
+//@ add-minicore
 //@ build-fail
 //@ needs-asm-support
-//@ compile-flags: -Ccodegen-units=1
+//@ compile-flags: --target aarch64-unknown-linux-gnu -Ccodegen-units=1
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 // Checks that inline asm errors are mapped to the correct line in the source code.
-
+#[unsafe(no_mangle)]
+#[rustfmt::skip]
 fn main() {
     unsafe {
         asm!("invalid_instruction");
diff --git a/tests/ui/asm/aarch64/srcloc.stderr b/tests/ui/asm/aarch64/srcloc.stderr
index b47f19bea614..44ee44fa4f5e 100644
--- a/tests/ui/asm/aarch64/srcloc.stderr
+++ b/tests/ui/asm/aarch64/srcloc.stderr
@@ -1,5 +1,5 @@
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:12:15
+  --> $DIR/srcloc.rs:19:15
    |
 LL |         asm!("invalid_instruction");
    |               ^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     invalid_instruction
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:16:13
+  --> $DIR/srcloc.rs:23:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |             invalid_instruction
    |             ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:21:13
+  --> $DIR/srcloc.rs:28:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -34,18 +34,6 @@ note: instantiated into assembly here
 LL |             invalid_instruction
    |             ^
 
-error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:27:13
-   |
-LL |             invalid_instruction
-   |             ^^^^^^^^^^^^^^^^^^^
-   |
-note: instantiated into assembly here
-  --> <inline asm>:3:13
-   |
-LL |             invalid_instruction
-   |             ^
-
 error: unrecognized instruction mnemonic
   --> $DIR/srcloc.rs:34:13
    |
@@ -59,7 +47,19 @@ LL |             invalid_instruction
    |             ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:39:14
+  --> $DIR/srcloc.rs:41:13
+   |
+LL |             invalid_instruction
+   |             ^^^^^^^^^^^^^^^^^^^
+   |
+note: instantiated into assembly here
+  --> <inline asm>:3:13
+   |
+LL |             invalid_instruction
+   |             ^
+
+error: unrecognized instruction mnemonic
+  --> $DIR/srcloc.rs:46:14
    |
 LL |         asm!(concat!("invalid", "_", "instruction"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     invalid_instruction
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:43:14
+  --> $DIR/srcloc.rs:50:14
    |
 LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
@@ -82,18 +82,6 @@ note: instantiated into assembly here
 LL |     invalid_instruction
    |     ^
 
-error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:49:14
-   |
-LL |             "invalid_instruction",
-   |              ^^^^^^^^^^^^^^^^^^^
-   |
-note: instantiated into assembly here
-  --> <inline asm>:2:1
-   |
-LL | invalid_instruction
-   | ^
-
 error: unrecognized instruction mnemonic
   --> $DIR/srcloc.rs:56:14
    |
@@ -101,19 +89,19 @@ LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
    |
 note: instantiated into assembly here
-  --> <inline asm>:3:1
+  --> <inline asm>:2:1
    |
 LL | invalid_instruction
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:63:13
+  --> $DIR/srcloc.rs:63:14
    |
-LL |             concat!("invalid", "_", "instruction"),
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             "invalid_instruction",
+   |              ^^^^^^^^^^^^^^^^^^^
    |
 note: instantiated into assembly here
-  --> <inline asm>:2:1
+  --> <inline asm>:3:1
    |
 LL | invalid_instruction
    | ^
@@ -131,7 +119,19 @@ LL | invalid_instruction
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:77:14
+  --> $DIR/srcloc.rs:77:13
+   |
+LL |             concat!("invalid", "_", "instruction"),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: instantiated into assembly here
+  --> <inline asm>:2:1
+   |
+LL | invalid_instruction
+   | ^
+
+error: unrecognized instruction mnemonic
+  --> $DIR/srcloc.rs:84:14
    |
 LL |             "invalid_instruction1",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -143,7 +143,7 @@ LL |     invalid_instruction1
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:78:14
+  --> $DIR/srcloc.rs:85:14
    |
 LL |             "invalid_instruction2",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -155,7 +155,7 @@ LL | invalid_instruction2
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:84:13
+  --> $DIR/srcloc.rs:91:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -170,7 +170,7 @@ LL |     invalid_instruction1
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:84:13
+  --> $DIR/srcloc.rs:91:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -185,7 +185,7 @@ LL | invalid_instruction2
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:93:13
+  --> $DIR/srcloc.rs:100:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -200,7 +200,7 @@ LL |     invalid_instruction1
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:93:13
+  --> $DIR/srcloc.rs:100:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -215,7 +215,7 @@ LL | invalid_instruction2
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:97:13
+  --> $DIR/srcloc.rs:104:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -230,7 +230,7 @@ LL | invalid_instruction3
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:97:13
+  --> $DIR/srcloc.rs:104:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -245,7 +245,7 @@ LL | invalid_instruction4
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:108:13
+  --> $DIR/srcloc.rs:115:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -260,7 +260,7 @@ LL |     invalid_instruction1
    |     ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:108:13
+  --> $DIR/srcloc.rs:115:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -275,7 +275,7 @@ LL | invalid_instruction2
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:112:13
+  --> $DIR/srcloc.rs:119:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -290,7 +290,7 @@ LL | invalid_instruction3
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:112:13
+  --> $DIR/srcloc.rs:119:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -305,7 +305,7 @@ LL | invalid_instruction4
    | ^
 
 error: unrecognized instruction mnemonic
-  --> $DIR/srcloc.rs:125:14
+  --> $DIR/srcloc.rs:132:14
    |
 LL |             "invalid_instruction"
    |              ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/aarch64/ttbr0_el2.rs b/tests/ui/asm/aarch64/ttbr0_el2.rs
index a283d75c8fff..4032c70ed03c 100644
--- a/tests/ui/asm/aarch64/ttbr0_el2.rs
+++ b/tests/ui/asm/aarch64/ttbr0_el2.rs
@@ -1,7 +1,15 @@
 //! Regression test for #97724, recognising ttbr0_el2 as a valid armv8 system register
-//@ only-aarch64
+//@ add-minicore
 //@ build-pass
-use std::arch::asm;
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
 
 static PT: [u64; 512] = [0; 512];
 fn main() {
diff --git a/tests/ui/asm/x86_64/bad-clobber-abi.rs b/tests/ui/asm/x86_64/bad-clobber-abi.rs
index 5205a084162b..1b27c427b4df 100644
--- a/tests/ui/asm/x86_64/bad-clobber-abi.rs
+++ b/tests/ui/asm/x86_64/bad-clobber-abi.rs
@@ -1,7 +1,12 @@
-//@ needs-asm-support
-//@ only-x86_64
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 // checks various modes of failure for the `clobber_abi` argument (after parsing)
 
diff --git a/tests/ui/asm/x86_64/bad-clobber-abi.stderr b/tests/ui/asm/x86_64/bad-clobber-abi.stderr
index ec0d85f727fc..a79506a2101d 100644
--- a/tests/ui/asm/x86_64/bad-clobber-abi.stderr
+++ b/tests/ui/asm/x86_64/bad-clobber-abi.stderr
@@ -1,5 +1,5 @@
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-clobber-abi.rs:11:18
+  --> $DIR/bad-clobber-abi.rs:16:18
    |
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |         asm!("", clobber_abi("foo"));
    = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-clobber-abi.rs:13:35
+  --> $DIR/bad-clobber-abi.rs:18:35
    |
 LL |         asm!("", clobber_abi("C", "foo"));
    |                                   ^^^^^
@@ -15,7 +15,7 @@ LL |         asm!("", clobber_abi("C", "foo"));
    = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:15:35
+  --> $DIR/bad-clobber-abi.rs:20:35
    |
 LL |         asm!("", clobber_abi("C", "C"));
    |                              ---  ^^^
@@ -23,7 +23,7 @@ LL |         asm!("", clobber_abi("C", "C"));
    |                              previously specified here
 
 error: `win64` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:18:39
+  --> $DIR/bad-clobber-abi.rs:23:39
    |
 LL |         asm!("", clobber_abi("win64", "efiapi"));
    |                              -------  ^^^^^^^^
@@ -33,7 +33,7 @@ LL |         asm!("", clobber_abi("win64", "efiapi"));
    = note: these ABIs are equivalent on the current target
 
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-clobber-abi.rs:20:35
+  --> $DIR/bad-clobber-abi.rs:25:35
    |
 LL |         asm!("", clobber_abi("C", "foo", "C"));
    |                                   ^^^^^
@@ -41,7 +41,7 @@ LL |         asm!("", clobber_abi("C", "foo", "C"));
    = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:20:42
+  --> $DIR/bad-clobber-abi.rs:25:42
    |
 LL |         asm!("", clobber_abi("C", "foo", "C"));
    |                              ---         ^^^
@@ -49,7 +49,7 @@ LL |         asm!("", clobber_abi("C", "foo", "C"));
    |                              previously specified here
 
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-clobber-abi.rs:23:39
+  --> $DIR/bad-clobber-abi.rs:28:39
    |
 LL |         asm!("", clobber_abi("win64", "foo", "efiapi"));
    |                                       ^^^^^
@@ -57,7 +57,7 @@ LL |         asm!("", clobber_abi("win64", "foo", "efiapi"));
    = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `win64` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:23:46
+  --> $DIR/bad-clobber-abi.rs:28:46
    |
 LL |         asm!("", clobber_abi("win64", "foo", "efiapi"));
    |                              -------         ^^^^^^^^
@@ -67,7 +67,7 @@ LL |         asm!("", clobber_abi("win64", "foo", "efiapi"));
    = note: these ABIs are equivalent on the current target
 
 error: `C` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:26:36
+  --> $DIR/bad-clobber-abi.rs:31:36
    |
 LL |         asm!("", clobber_abi("C"), clobber_abi("C"));
    |                  ----------------  ^^^^^^^^^^^^^^^^
@@ -75,7 +75,7 @@ LL |         asm!("", clobber_abi("C"), clobber_abi("C"));
    |                  previously specified here
 
 error: `win64` ABI specified multiple times
-  --> $DIR/bad-clobber-abi.rs:29:40
+  --> $DIR/bad-clobber-abi.rs:34:40
    |
 LL |         asm!("", clobber_abi("win64"), clobber_abi("efiapi"));
    |                  --------------------  ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/bad-options.rs b/tests/ui/asm/x86_64/bad-options.rs
index 123febc06fc9..594ee6016541 100644
--- a/tests/ui/asm/x86_64/bad-options.rs
+++ b/tests/ui/asm/x86_64/bad-options.rs
@@ -1,8 +1,13 @@
-//@ only-x86_64
-
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 #![feature(asm_unwind)]
 
-use std::arch::{asm, global_asm};
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     let mut foo = 0;
diff --git a/tests/ui/asm/x86_64/bad-options.stderr b/tests/ui/asm/x86_64/bad-options.stderr
index a09f02e68ea9..576d5a1b7fd1 100644
--- a/tests/ui/asm/x86_64/bad-options.stderr
+++ b/tests/ui/asm/x86_64/bad-options.stderr
@@ -1,41 +1,41 @@
 error: the `nomem` and `readonly` options are mutually exclusive
-  --> $DIR/bad-options.rs:10:18
+  --> $DIR/bad-options.rs:15:18
    |
 LL |         asm!("", options(nomem, readonly));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the `pure` and `noreturn` options are mutually exclusive
-  --> $DIR/bad-options.rs:12:18
+  --> $DIR/bad-options.rs:17:18
    |
 LL |         asm!("", options(pure, nomem, noreturn));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: asm with the `pure` option must have at least one output
-  --> $DIR/bad-options.rs:12:18
+  --> $DIR/bad-options.rs:17:18
    |
 LL |         asm!("", options(pure, nomem, noreturn));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: asm with the `pure` option must have at least one output
-  --> $DIR/bad-options.rs:15:33
+  --> $DIR/bad-options.rs:20:33
    |
 LL |         asm!("{}", in(reg) foo, options(pure, nomem));
    |                                 ^^^^^^^^^^^^^^^^^^^^
 
 error: asm outputs are not allowed with the `noreturn` option
-  --> $DIR/bad-options.rs:17:20
+  --> $DIR/bad-options.rs:22:20
    |
 LL |         asm!("{}", out(reg) foo, options(noreturn));
    |                    ^^^^^^^^^^^^
 
 error: asm labels are not allowed with the `may_unwind` option
-  --> $DIR/bad-options.rs:19:20
+  --> $DIR/bad-options.rs:24:20
    |
 LL |         asm!("{}", label {}, options(may_unwind));
    |                    ^^^^^^^^
 
 error: asm with `clobber_abi` must specify explicit registers for outputs
-  --> $DIR/bad-options.rs:26:20
+  --> $DIR/bad-options.rs:31:20
    |
 LL |         asm!("{}", out(reg) foo, clobber_abi("C"));
    |                    ^^^^^^^^^^^^  ---------------- clobber_abi
@@ -43,7 +43,7 @@ LL |         asm!("{}", out(reg) foo, clobber_abi("C"));
    |                    generic outputs
 
 error: asm with `clobber_abi` must specify explicit registers for outputs
-  --> $DIR/bad-options.rs:28:20
+  --> $DIR/bad-options.rs:33:20
    |
 LL |         asm!("{}", out(reg) foo, clobber_abi("C"), clobber_abi("C"));
    |                    ^^^^^^^^^^^^  ----------------  ---------------- clobber_abi
@@ -52,43 +52,43 @@ LL |         asm!("{}", out(reg) foo, clobber_abi("C"), clobber_abi("C"));
    |                    generic outputs
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:35:25
+  --> $DIR/bad-options.rs:40:25
    |
 LL | global_asm!("", options(nomem));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: the `readonly` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:37:25
+  --> $DIR/bad-options.rs:42:25
    |
 LL | global_asm!("", options(readonly));
    |                         ^^^^^^^^ the `readonly` option is not meaningful for global-scoped inline assembly
 
 error: the `noreturn` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:39:25
+  --> $DIR/bad-options.rs:44:25
    |
 LL | global_asm!("", options(noreturn));
    |                         ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly
 
 error: the `pure` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:41:25
+  --> $DIR/bad-options.rs:46:25
    |
 LL | global_asm!("", options(pure));
    |                         ^^^^ the `pure` option is not meaningful for global-scoped inline assembly
 
 error: the `nostack` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:43:25
+  --> $DIR/bad-options.rs:48:25
    |
 LL | global_asm!("", options(nostack));
    |                         ^^^^^^^ the `nostack` option is not meaningful for global-scoped inline assembly
 
 error: the `preserves_flags` option cannot be used with `global_asm!`
-  --> $DIR/bad-options.rs:45:25
+  --> $DIR/bad-options.rs:50:25
    |
 LL | global_asm!("", options(preserves_flags));
    |                         ^^^^^^^^^^^^^^^ the `preserves_flags` option is not meaningful for global-scoped inline assembly
 
 error: invalid ABI for `clobber_abi`
-  --> $DIR/bad-options.rs:24:18
+  --> $DIR/bad-options.rs:29:18
    |
 LL |         asm!("", clobber_abi("foo"));
    |                  ^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |         asm!("", clobber_abi("foo"));
    = note: the following ABIs are supported on this target: `C`, `system`, `efiapi`, `win64`, and `sysv64`
 
 error: `C` ABI specified multiple times
-  --> $DIR/bad-options.rs:28:52
+  --> $DIR/bad-options.rs:33:52
    |
 LL |         asm!("{}", out(reg) foo, clobber_abi("C"), clobber_abi("C"));
    |                                  ----------------  ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/bad-reg.rs b/tests/ui/asm/x86_64/bad-reg.rs
index d5b5cd39bf77..cc3def95508f 100644
--- a/tests/ui/asm/x86_64/bad-reg.rs
+++ b/tests/ui/asm/x86_64/bad-reg.rs
@@ -1,7 +1,7 @@
 //@ add-minicore
-//@ only-x86_64
 //@ revisions: stable experimental_reg
-//@ compile-flags: -C target-feature=+avx2,+avx512f
+//@ compile-flags: --target x86_64-unknown-linux-gnu -C target-feature=+avx2,+avx512f
+//@ needs-llvm-components: x86
 #![cfg_attr(experimental_reg, feature(asm_experimental_reg))]
 
 #![crate_type = "lib"]
diff --git a/tests/ui/asm/x86_64/goto-block-safe.rs b/tests/ui/asm/x86_64/goto-block-safe.rs
index b739e9f9ced8..1364425b07ac 100644
--- a/tests/ui/asm/x86_64/goto-block-safe.rs
+++ b/tests/ui/asm/x86_64/goto-block-safe.rs
@@ -1,16 +1,22 @@
-//@ only-x86_64
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
 //@ needs-asm-support
-
+#![feature(no_core)]
+#![no_core]
 #![deny(unreachable_code)]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
+
+unsafe fn such_unsafe() {}
 
 fn goto_fallthough() {
     unsafe {
         asm!(
             "/* {} */",
             label {
-                core::hint::unreachable_unchecked();
+                such_unsafe()
                 //~^ ERROR [E0133]
             }
         )
diff --git a/tests/ui/asm/x86_64/goto-block-safe.stderr b/tests/ui/asm/x86_64/goto-block-safe.stderr
index ee7313bc8be3..3f9afdd6fc70 100644
--- a/tests/ui/asm/x86_64/goto-block-safe.stderr
+++ b/tests/ui/asm/x86_64/goto-block-safe.stderr
@@ -1,11 +1,11 @@
-error[E0133]: call to unsafe function `unreachable_unchecked` is unsafe and requires unsafe function or block
-  --> $DIR/goto-block-safe.rs:13:17
+error[E0133]: call to unsafe function `such_unsafe` is unsafe and requires unsafe function or block
+  --> $DIR/goto-block-safe.rs:19:17
    |
 LL |     unsafe {
    |     ------ items do not inherit unsafety from separate enclosing items
 ...
-LL |                 core::hint::unreachable_unchecked();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+LL |                 such_unsafe()
+   |                 ^^^^^^^^^^^^^ call to unsafe function
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
diff --git a/tests/ui/asm/x86_64/interpolated-idents.rs b/tests/ui/asm/x86_64/interpolated-idents.rs
index 4f349c5b2134..9790802679a1 100644
--- a/tests/ui/asm/x86_64/interpolated-idents.rs
+++ b/tests/ui/asm/x86_64/interpolated-idents.rs
@@ -1,6 +1,12 @@
-//@ only-x86_64
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 macro_rules! m {
     ($in:ident $out:ident $lateout:ident $inout:ident $inlateout:ident $const:ident $sym:ident
diff --git a/tests/ui/asm/x86_64/interpolated-idents.stderr b/tests/ui/asm/x86_64/interpolated-idents.stderr
index a91bc768fc4d..1fb817ec8de0 100644
--- a/tests/ui/asm/x86_64/interpolated-idents.stderr
+++ b/tests/ui/asm/x86_64/interpolated-idents.stderr
@@ -1,5 +1,5 @@
 error: the `nomem` and `readonly` options are mutually exclusive
-  --> $DIR/interpolated-idents.rs:13:13
+  --> $DIR/interpolated-idents.rs:19:13
    |
 LL |               $options($pure, $nomem, $readonly, $preserves_flags, $noreturn, $nostack, $att_syntax));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | |        noreturn nostack att_syntax options);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: the `pure` and `noreturn` options are mutually exclusive
-  --> $DIR/interpolated-idents.rs:13:13
+  --> $DIR/interpolated-idents.rs:19:13
    |
 LL |               $options($pure, $nomem, $readonly, $preserves_flags, $noreturn, $nostack, $att_syntax));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | |        noreturn nostack att_syntax options);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm outputs are not allowed with the `noreturn` option
-  --> $DIR/interpolated-idents.rs:10:32
+  --> $DIR/interpolated-idents.rs:16:32
    |
 LL |               asm!("", $in(x) x, $out(x) x, $lateout(x) x, $inout(x) x, $inlateout(x) x,
    |                                  ^^^^^^^^^  ^^^^^^^^^^^^^  ^^^^^^^^^^^  ^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/issue-82869.rs b/tests/ui/asm/x86_64/issue-82869.rs
index 448ebd9c99f4..4af09cb0d63a 100644
--- a/tests/ui/asm/x86_64/issue-82869.rs
+++ b/tests/ui/asm/x86_64/issue-82869.rs
@@ -1,10 +1,14 @@
-//@ needs-asm-support
-//@ only-x86_64
-// Make sure rustc doesn't ICE on asm! for a foreign architecture.
-
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
 #![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
+
+// Make sure rustc doesn't ICE on asm! for a foreign architecture.
 
 pub unsafe fn aarch64(a: f64, b: f64) -> f64 {
     let c;
diff --git a/tests/ui/asm/x86_64/issue-82869.stderr b/tests/ui/asm/x86_64/issue-82869.stderr
index 5cb7e6e27efa..56699ac9850b 100644
--- a/tests/ui/asm/x86_64/issue-82869.stderr
+++ b/tests/ui/asm/x86_64/issue-82869.stderr
@@ -1,5 +1,5 @@
 error: invalid register class `vreg`: unknown register class
-  --> $DIR/issue-82869.rs:11:32
+  --> $DIR/issue-82869.rs:15:32
    |
 LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    |                                ^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register class `vreg`: unknown register class
-  --> $DIR/issue-82869.rs:11:45
+  --> $DIR/issue-82869.rs:15:45
    |
 LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    |                                             ^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |     asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `d0`: unknown register
-  --> $DIR/issue-82869.rs:11:57
+  --> $DIR/issue-82869.rs:15:57
    |
 LL |       asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") {
    |  _________________________________________________________^
diff --git a/tests/ui/asm/x86_64/issue-89875.rs b/tests/ui/asm/x86_64/issue-89875.rs
index 0252859cff0a..a45ef1b2d17e 100644
--- a/tests/ui/asm/x86_64/issue-89875.rs
+++ b/tests/ui/asm/x86_64/issue-89875.rs
@@ -1,9 +1,16 @@
 //@ build-pass
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
 //@ needs-asm-support
-//@ only-x86_64
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
+#[unsafe(no_mangle)]
 #[target_feature(enable = "avx")]
 fn foo() {
     unsafe {
@@ -13,5 +20,3 @@ fn foo() {
         );
     }
 }
-
-fn main() {}
diff --git a/tests/ui/asm/x86_64/issue-96797.rs b/tests/ui/asm/x86_64/issue-96797.rs
index 531e16795dd8..9978a4856a81 100644
--- a/tests/ui/asm/x86_64/issue-96797.rs
+++ b/tests/ui/asm/x86_64/issue-96797.rs
@@ -1,13 +1,17 @@
+//@ add-minicore
 //@ build-pass
-//@ compile-flags: -O
-//@ needs-asm-support
-//@ only-x86_64
-//@ only-linux
+//@ compile-flags: --target x86_64-unknown-linux-gnu -O
+//@ needs-llvm-components: x86
+//@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
 
 // regression test for #96797
 
-use std::arch::global_asm;
-
 #[no_mangle]
 fn my_func() {}
 
diff --git a/tests/ui/asm/x86_64/srcloc.rs b/tests/ui/asm/x86_64/srcloc.rs
index f4ffa8c5c3b2..e73854acf152 100644
--- a/tests/ui/asm/x86_64/srcloc.rs
+++ b/tests/ui/asm/x86_64/srcloc.rs
@@ -1,12 +1,19 @@
-//@ only-x86_64
+//@ add-minicore
 //@ build-fail
-//@ compile-flags: -Ccodegen-units=1
+//@ compile-flags: --target x86_64-unknown-linux-gnu -Ccodegen-units=1
+//@ needs-llvm-components: x86
 //@ ignore-backends: gcc
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 // Checks that inline asm errors are mapped to the correct line in the source code.
 
+#[unsafe(no_mangle)]
+#[rustfmt::skip]
 fn main() {
     unsafe {
         asm!("invalid_instruction");
diff --git a/tests/ui/asm/x86_64/srcloc.stderr b/tests/ui/asm/x86_64/srcloc.stderr
index b2079120ec06..d2ab93f56b49 100644
--- a/tests/ui/asm/x86_64/srcloc.stderr
+++ b/tests/ui/asm/x86_64/srcloc.stderr
@@ -1,5 +1,5 @@
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:12:15
+  --> $DIR/srcloc.rs:19:15
    |
 LL |         asm!("invalid_instruction");
    |               ^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:16:13
+  --> $DIR/srcloc.rs:23:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:21:13
+  --> $DIR/srcloc.rs:28:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -34,18 +34,6 @@ note: instantiated into assembly here
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
-error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:27:13
-   |
-LL |             invalid_instruction
-   |             ^^^^^^^^^^^^^^^^^^^
-   |
-note: instantiated into assembly here
-  --> <inline asm>:4:13
-   |
-LL |             invalid_instruction
-   |             ^^^^^^^^^^^^^^^^^^^
-
 error: invalid instruction mnemonic 'invalid_instruction'
   --> $DIR/srcloc.rs:34:13
    |
@@ -59,7 +47,19 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:39:14
+  --> $DIR/srcloc.rs:41:13
+   |
+LL |             invalid_instruction
+   |             ^^^^^^^^^^^^^^^^^^^
+   |
+note: instantiated into assembly here
+  --> <inline asm>:4:13
+   |
+LL |             invalid_instruction
+   |             ^^^^^^^^^^^^^^^^^^^
+
+error: invalid instruction mnemonic 'invalid_instruction'
+  --> $DIR/srcloc.rs:46:14
    |
 LL |         asm!(concat!("invalid", "_", "instruction"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
 warning: scale factor without index register is ignored
-  --> $DIR/srcloc.rs:42:15
+  --> $DIR/srcloc.rs:49:15
    |
 LL |         asm!("movaps %xmm3, (%esi, 2)", options(att_syntax));
    |               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |     movaps %xmm3, (%esi, 2)
    |                          ^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:46:14
+  --> $DIR/srcloc.rs:53:14
    |
 LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
@@ -94,18 +94,6 @@ note: instantiated into assembly here
 LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:52:14
-   |
-LL |             "invalid_instruction",
-   |              ^^^^^^^^^^^^^^^^^^^
-   |
-note: instantiated into assembly here
-  --> <inline asm>:3:1
-   |
-LL | invalid_instruction
-   | ^^^^^^^^^^^^^^^^^^^
-
 error: invalid instruction mnemonic 'invalid_instruction'
   --> $DIR/srcloc.rs:59:14
    |
@@ -113,19 +101,19 @@ LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
    |
 note: instantiated into assembly here
-  --> <inline asm>:4:1
+  --> <inline asm>:3:1
    |
 LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:66:13
+  --> $DIR/srcloc.rs:66:14
    |
-LL |             concat!("invalid", "_", "instruction"),
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             "invalid_instruction",
+   |              ^^^^^^^^^^^^^^^^^^^
    |
 note: instantiated into assembly here
-  --> <inline asm>:3:1
+  --> <inline asm>:4:1
    |
 LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
@@ -142,8 +130,20 @@ note: instantiated into assembly here
 LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
+error: invalid instruction mnemonic 'invalid_instruction'
+  --> $DIR/srcloc.rs:80:13
+   |
+LL |             concat!("invalid", "_", "instruction"),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: instantiated into assembly here
+  --> <inline asm>:3:1
+   |
+LL | invalid_instruction
+   | ^^^^^^^^^^^^^^^^^^^
+
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:80:14
+  --> $DIR/srcloc.rs:87:14
    |
 LL |             "invalid_instruction1",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -155,7 +155,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:81:14
+  --> $DIR/srcloc.rs:88:14
    |
 LL |             "invalid_instruction2",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -167,7 +167,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:87:13
+  --> $DIR/srcloc.rs:94:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -182,7 +182,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:87:13
+  --> $DIR/srcloc.rs:94:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -197,7 +197,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:96:13
+  --> $DIR/srcloc.rs:103:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -212,7 +212,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:96:13
+  --> $DIR/srcloc.rs:103:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -227,7 +227,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction3'
-  --> $DIR/srcloc.rs:100:13
+  --> $DIR/srcloc.rs:107:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -242,7 +242,7 @@ LL | invalid_instruction3
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction4'
-  --> $DIR/srcloc.rs:100:13
+  --> $DIR/srcloc.rs:107:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -257,7 +257,7 @@ LL | invalid_instruction4
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:111:13
+  --> $DIR/srcloc.rs:118:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -272,7 +272,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:111:13
+  --> $DIR/srcloc.rs:118:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -287,7 +287,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction3'
-  --> $DIR/srcloc.rs:115:13
+  --> $DIR/srcloc.rs:122:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -302,7 +302,7 @@ LL | invalid_instruction3
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction4'
-  --> $DIR/srcloc.rs:115:13
+  --> $DIR/srcloc.rs:122:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -317,7 +317,7 @@ LL | invalid_instruction4
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:128:14
+  --> $DIR/srcloc.rs:135:14
    |
 LL |             "invalid_instruction"
    |              ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/target-feature-attr.rs b/tests/ui/asm/x86_64/target-feature-attr.rs
index 2193117caeb6..ada5fecd797e 100644
--- a/tests/ui/asm/x86_64/target-feature-attr.rs
+++ b/tests/ui/asm/x86_64/target-feature-attr.rs
@@ -1,15 +1,20 @@
-//@ only-x86_64
+//@ add-minicore
 // Set the base cpu explicitly, in case the default has been changed.
-//@ compile-flags: -C target-cpu=x86-64
+//@ compile-flags: --target x86_64-unknown-linux-gnu -C target-cpu=x86-64
+//@ needs-llvm-components: x86
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 #[target_feature(enable = "avx")]
 unsafe fn foo() {
     let mut x = 1;
     let y = 2;
     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
-    assert_eq!(x, 3);
+    let _ = x;
 }
 
 unsafe fn bar() {
@@ -19,7 +24,7 @@ unsafe fn bar() {
     //~^ ERROR: register class `ymm_reg` requires the `avx` target feature
     //~| ERROR: register class `ymm_reg` requires the `avx` target feature
     //~| ERROR: register class `ymm_reg` requires the `avx` target feature
-    assert_eq!(x, 3);
+    let _ = x;
 }
 
 #[target_feature(enable = "avx512bw")]
diff --git a/tests/ui/asm/x86_64/target-feature-attr.stderr b/tests/ui/asm/x86_64/target-feature-attr.stderr
index c852726ee7ff..625f10416735 100644
--- a/tests/ui/asm/x86_64/target-feature-attr.stderr
+++ b/tests/ui/asm/x86_64/target-feature-attr.stderr
@@ -1,23 +1,23 @@
 error: register class `ymm_reg` requires the `avx` target feature
-  --> $DIR/target-feature-attr.rs:18:40
+  --> $DIR/target-feature-attr.rs:23:40
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                        ^^^^^^^^^^^^^
 
 error: register class `ymm_reg` requires the `avx` target feature
-  --> $DIR/target-feature-attr.rs:18:55
+  --> $DIR/target-feature-attr.rs:23:55
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                                       ^^^^^^^^^^^^^
 
 error: register class `ymm_reg` requires the `avx` target feature
-  --> $DIR/target-feature-attr.rs:18:70
+  --> $DIR/target-feature-attr.rs:23:70
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                                                      ^^^^^^^^^^^^^^^^^^
 
 error: register class `kreg` requires at least one of the following target features: avx512bw, avx512f
-  --> $DIR/target-feature-attr.rs:33:23
+  --> $DIR/target-feature-attr.rs:38:23
    |
 LL |     asm!("/* {0} */", in(kreg) x);
    |                       ^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/x86_64_parse_error.rs b/tests/ui/asm/x86_64/x86_64_parse_error.rs
index 3df0febf6b07..3d011416c6f5 100644
--- a/tests/ui/asm/x86_64/x86_64_parse_error.rs
+++ b/tests/ui/asm/x86_64/x86_64_parse_error.rs
@@ -1,6 +1,12 @@
-//@ only-x86_64
+//@ add-minicore
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
 
-use std::arch::asm;
+extern crate minicore;
+use minicore::*;
 
 fn main() {
     let mut foo = 0;
@@ -14,6 +20,6 @@ fn main() {
         //~^ ERROR attempt to use a non-constant value in a constant
         asm!("{1}", in("eax") foo, const bar);
         //~^ ERROR positional arguments cannot follow named arguments or explicit register arguments
-        //~^^ ERROR attempt to use a non-constant value in a constant
+        //~| ERROR attempt to use a non-constant value in a constant
     }
 }
diff --git a/tests/ui/asm/x86_64/x86_64_parse_error.stderr b/tests/ui/asm/x86_64/x86_64_parse_error.stderr
index dfa3e1d0ef20..30d2c57c70a4 100644
--- a/tests/ui/asm/x86_64/x86_64_parse_error.stderr
+++ b/tests/ui/asm/x86_64/x86_64_parse_error.stderr
@@ -1,11 +1,11 @@
 error: explicit register arguments cannot have names
-  --> $DIR/x86_64_parse_error.rs:9:18
+  --> $DIR/x86_64_parse_error.rs:15:18
    |
 LL |         asm!("", a = in("eax") foo);
    |                  ^^^^^^^^^^^^^^^^^
 
 error: positional arguments cannot follow named arguments or explicit register arguments
-  --> $DIR/x86_64_parse_error.rs:15:36
+  --> $DIR/x86_64_parse_error.rs:21:36
    |
 LL |         asm!("{1}", in("eax") foo, const bar);
    |                     -------------  ^^^^^^^^^ positional argument
@@ -13,7 +13,7 @@ LL |         asm!("{1}", in("eax") foo, const bar);
    |                     explicit register argument
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:11:46
+  --> $DIR/x86_64_parse_error.rs:17:46
    |
 LL |         asm!("{a}", in("eax") foo, a = const bar);
    |                                              ^^^ non-constant value
@@ -25,7 +25,7 @@ LL +     const bar: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:13:46
+  --> $DIR/x86_64_parse_error.rs:19:46
    |
 LL |         asm!("{a}", in("eax") foo, a = const bar);
    |                                              ^^^ non-constant value
@@ -37,7 +37,7 @@ LL +     const bar: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:15:42
+  --> $DIR/x86_64_parse_error.rs:21:42
    |
 LL |         asm!("{1}", in("eax") foo, const bar);
    |                                          ^^^ non-constant value

From ebb91f735be18880ffdc16e1287fd85a70a5aa6b Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 21 Mar 2026 21:53:15 -0400
Subject: [PATCH 0837/1059] Make `Ipv6Addr::multicast_scope()` exhaustive

And make `Ipv6MulticastScope` exhaustive,
with `repr(u8)` and the proper discriminant values.
The variants for the two reserved scopes
are gated behind a perma-unstable feature,
in order to avoid committing to names for them.

[IETF RFC 4291](https://datatracker.ietf.org/doc/html/rfc4291#section-2.7)
and [IETF RFC 7346](https://datatracker.ietf.org/doc/html/rfc7346#section-2)
define the list of multicast scopes.
The former document says:

> scopes labeled "(unassigned)" are available for administrators
> to define additional multicast regions.
---
 library/core/src/net/ip_addr.rs | 102 +++++++++++++++++++++++++-------
 1 file changed, 79 insertions(+), 23 deletions(-)

diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index a1bfd774710d..6e16184ca4f6 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -177,15 +177,17 @@ fn hash<H: Hasher>(&self, state: &mut H) {
     }
 }
 
-/// Scope of an [IPv6 multicast address] as defined in [IETF RFC 7346 section 2].
+/// Scope of an [IPv6 multicast address] as defined in [IETF RFC 7346 section 2],
+/// which updates [IETF RFC 4291 section 2.7].
 ///
 /// # Stability Guarantees
 ///
-/// Not all possible values for a multicast scope have been assigned.
-/// Future RFCs may introduce new scopes, which will be added as variants to this enum;
-/// because of this the enum is marked as `#[non_exhaustive]`.
+/// Scopes 0 and F are currently reserved by IETF, and may be assigned in the future.
+/// For this reason, the enum variants for those two scopes are not currently nameable.
+/// You can still check for them in your code using `as` casts.
 ///
 /// # Examples
+///
 /// ```
 /// #![feature(ip)]
 ///
@@ -204,32 +206,77 @@ fn hash<H: Hasher>(&self, state: &mut H) {
 ///     Some(SiteLocal) => println!("Site-Local scope"),
 ///     Some(OrganizationLocal) => println!("Organization-Local scope"),
 ///     Some(Global) => println!("Global scope"),
-///     Some(_) => println!("Unknown scope"),
+///     Some(s) => {
+///         let snum = s as u8;
+///         if matches!(0x0 | 0xF, snum) {
+///             println!("Reserved scope {snum:X}")
+///         } else {
+///             println!("Unassigned scope {snum:X}")
+///         }
+///     }
 ///     None => println!("Not a multicast address!")
 /// }
-///
 /// ```
 ///
 /// [IPv6 multicast address]: Ipv6Addr
 /// [IETF RFC 7346 section 2]: https://tools.ietf.org/html/rfc7346#section-2
-#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+/// [IETF RFC 4291 section 2.7]: https://datatracker.ietf.org/doc/html/rfc4291#section-2.7
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[unstable(feature = "ip", issue = "27709")]
-#[non_exhaustive]
+#[repr(u8)]
 pub enum Ipv6MulticastScope {
+    /// Reserved by IETF.
+    #[doc(hidden)]
+    #[unstable(
+        feature = "ip_multicast_reserved",
+        reason = "not yet assigned by IETF",
+        issue = "none"
+    )]
+    Reserved0 = 0x0,
     /// Interface-Local scope.
-    InterfaceLocal,
+    InterfaceLocal = 0x1,
     /// Link-Local scope.
-    LinkLocal,
+    LinkLocal = 0x2,
     /// Realm-Local scope.
-    RealmLocal,
+    RealmLocal = 0x3,
     /// Admin-Local scope.
-    AdminLocal,
+    AdminLocal = 0x4,
     /// Site-Local scope.
-    SiteLocal,
+    SiteLocal = 0x5,
+
+    /// Scope 6. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    Unassigned6 = 0x6,
+    /// Scope 7. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    Unassigned7 = 0x7,
     /// Organization-Local scope.
-    OrganizationLocal,
+    OrganizationLocal = 0x8,
+    /// Scope 9. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    Unassigned9 = 0x9,
+    /// Scope A. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    UnassignedA = 0xA,
+    /// Scope B. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    UnassignedB = 0xB,
+    /// Scope C. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    UnassignedC = 0xC,
+    /// Scope D. Unassigned, available for administrators
+    /// to define additional multicast regions.
+    UnassignedD = 0xD,
     /// Global scope.
-    Global,
+    Global = 0xE,
+    /// Reserved by IETF.
+    #[doc(hidden)]
+    #[unstable(
+        feature = "ip_multicast_reserved",
+        reason = "not yet assigned by IETF",
+        issue = "none"
+    )]
+    ReservedF = 0xF,
 }
 
 impl IpAddr {
@@ -1848,14 +1895,23 @@ pub const fn is_unicast_global(&self) -> bool {
     pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
         if self.is_multicast() {
             match self.segments()[0] & 0x000f {
-                1 => Some(Ipv6MulticastScope::InterfaceLocal),
-                2 => Some(Ipv6MulticastScope::LinkLocal),
-                3 => Some(Ipv6MulticastScope::RealmLocal),
-                4 => Some(Ipv6MulticastScope::AdminLocal),
-                5 => Some(Ipv6MulticastScope::SiteLocal),
-                8 => Some(Ipv6MulticastScope::OrganizationLocal),
-                14 => Some(Ipv6MulticastScope::Global),
-                _ => None,
+                0x0 => Some(Ipv6MulticastScope::Reserved0),
+                0x1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                0x2 => Some(Ipv6MulticastScope::LinkLocal),
+                0x3 => Some(Ipv6MulticastScope::RealmLocal),
+                0x4 => Some(Ipv6MulticastScope::AdminLocal),
+                0x5 => Some(Ipv6MulticastScope::SiteLocal),
+                0x6 => Some(Ipv6MulticastScope::Unassigned6),
+                0x7 => Some(Ipv6MulticastScope::Unassigned7),
+                0x8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                0x9 => Some(Ipv6MulticastScope::Unassigned9),
+                0xA => Some(Ipv6MulticastScope::UnassignedA),
+                0xB => Some(Ipv6MulticastScope::UnassignedB),
+                0xC => Some(Ipv6MulticastScope::UnassignedC),
+                0xD => Some(Ipv6MulticastScope::UnassignedD),
+                0xE => Some(Ipv6MulticastScope::Global),
+                0xF => Some(Ipv6MulticastScope::ReservedF),
+                _ => unreachable!(),
             }
         } else {
             None

From 90ea993083f841698a5dcccc5069c5e8375df50b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 17 Mar 2026 11:43:53 +1100
Subject: [PATCH 0838/1059] Rename various query cycle things.

The existing names have bugged me for a while. Changes:

- `CycleError` -> `Cycle`. Because we normally use "error" for a `Diag`
  with `Level::Error`, and this type is just a precursor to that. Also,
  many existing locals of this type are already named `cycle`.

- `CycleError::cycle` -> `Cycle::frames`. Because it is a sequence of
  frames, and we want to avoid `Cycle::cycle` (and `cycle.cycle`).

- `cycle_error` -> `find_and_handle_cycle`. Because that's what it does.
  The existing name is just a non-descript noun phrase.

- `mk_cycle` -> `handle_cycle`. Because it doesn't make the cycle; the
  cycle is already made. It handles the cycle, which involves (a)
  creating the error, and (b) handling the error.

- `report_cycle` -> `create_cycle_error`. Because that's what it does:
  creates the cycle error (i.e. the `Diag`).

- `value_from_cycle_error` -> `handle_cycle_error_fn`. Because most
  cases don't produce a value, they just emit an error and quit.
  And the `_fn` suffix is for consistency with other vtable fns.

- `from_cycle_error` -> `handle_cycle_error`. A similar story for this
  module.
---
 compiler/rustc_middle/src/queries.rs          |  8 +--
 compiler/rustc_middle/src/query/job.rs        |  6 +--
 compiler/rustc_middle/src/query/mod.rs        |  4 +-
 compiler/rustc_middle/src/query/plumbing.rs   | 15 +++---
 compiler/rustc_query_impl/src/execution.rs    | 24 ++++-----
 ...m_cycle_error.rs => handle_cycle_error.rs} | 37 ++++++-------
 compiler/rustc_query_impl/src/job.rs          | 53 +++++++++----------
 compiler/rustc_query_impl/src/lib.rs          |  4 +-
 compiler/rustc_query_impl/src/query_impl.rs   |  8 +--
 .../rustc_ty_utils/src/representability.rs    |  2 +-
 10 files changed, 76 insertions(+), 85 deletions(-)
 rename compiler/rustc_query_impl/src/{from_cycle_error.rs => handle_cycle_error.rs} (92%)

diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index c5dab806fa19..ff96f5044dc1 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -131,10 +131,10 @@
 // `Providers` that the driver creates (using several `rustc_*` crates).
 //
 // The result type of each query must implement `Clone`. Additionally
-// `ty::query::from_cycle_error::FromCycleError` can be implemented which produces an appropriate
+// `QueryVTable::handle_cycle_error_fn` can be used to produce an appropriate
 // placeholder (error) value if the query resulted in a query cycle.
-// Queries without a `FromCycleError` implementation will raise a fatal error on query
-// cycles instead.
+// Queries without a custom `handle_cycle_error_fn` implementation will raise a
+// fatal error on query cycles instead.
 rustc_queries! {
     /// Caches the expansion of a derive proc macro, e.g. `#[derive(Serialize)]`.
     /// The key is:
@@ -577,7 +577,7 @@
 
     /// Checks whether a type is representable or infinitely sized
     //
-    // Infinitely sized types will cause a cycle. The `value_from_cycle_error` impl will print
+    // Infinitely sized types will cause a cycle. The query's `handle_cycle_error_fn` will print
     // a custom error about the infinite size and then abort compilation. (In the past we
     // recovered and continued, but in practice that leads to confusing subsequent error
     // messages about cycles that then abort.)
diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs
index 3bf37a782ee8..24c4daf9855d 100644
--- a/compiler/rustc_middle/src/query/job.rs
+++ b/compiler/rustc_middle/src/query/job.rs
@@ -6,7 +6,7 @@
 use parking_lot::{Condvar, Mutex};
 use rustc_span::Span;
 
-use crate::query::CycleError;
+use crate::query::Cycle;
 use crate::ty::TyCtxt;
 
 /// A value uniquely identifying an active query job.
@@ -59,7 +59,7 @@ pub struct QueryWaiter<'tcx> {
     pub parent: Option<QueryJobId>,
     pub condvar: Condvar,
     pub span: Span,
-    pub cycle: Mutex<Option<CycleError<'tcx>>>,
+    pub cycle: Mutex<Option<Cycle<'tcx>>>,
 }
 
 #[derive(Clone, Debug)]
@@ -79,7 +79,7 @@ pub fn wait_on(
         tcx: TyCtxt<'tcx>,
         query: Option<QueryJobId>,
         span: Span,
-    ) -> Result<(), CycleError<'tcx>> {
+    ) -> Result<(), Cycle<'tcx>> {
         let mut waiters_guard = self.waiters.lock();
         let Some(waiters) = &mut *waiters_guard else {
             return Ok(()); // already complete
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 9c012f2da4df..b7e5e9bcb5e3 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -5,8 +5,8 @@
 pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
-    ActiveKeyStatus, CycleError, EnsureMode, QueryMode, QueryState, QuerySystem, QueryVTable,
-    TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
+    ActiveKeyStatus, Cycle, EnsureMode, QueryMode, QueryState, QuerySystem, QueryVTable, TyCtxtAt,
+    TyCtxtEnsureDone, TyCtxtEnsureOk, TyCtxtEnsureResult,
 };
 pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 7d94d60523fb..3890f2fc0843 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -47,12 +47,12 @@ pub enum ActiveKeyStatus<'tcx> {
 }
 
 #[derive(Debug)]
-pub struct CycleError<'tcx> {
+pub struct Cycle<'tcx> {
     /// The query and related span that uses the cycle.
     pub usage: Option<QueryStackFrame<'tcx>>,
 
     /// The span here corresponds to the reason for which this query was required.
-    pub cycle: Vec<QueryStackFrame<'tcx>>,
+    pub frames: Vec<QueryStackFrame<'tcx>>,
 }
 
 #[derive(Debug)]
@@ -111,13 +111,10 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
 
     /// Function pointer that handles a cycle error. `error` must be consumed, e.g. with `emit` (if
     /// it should be emitted) or `delay_as_bug` (if it need not be emitted because an alternative
-    /// error is created and emitted).
-    pub value_from_cycle_error: fn(
-        tcx: TyCtxt<'tcx>,
-        key: C::Key,
-        cycle_error: CycleError<'tcx>,
-        error: Diag<'_>,
-    ) -> C::Value,
+    /// error is created and emitted). A value may be returned, or (more commonly) the function may
+    /// just abort after emitting the error.
+    pub handle_cycle_error_fn:
+        fn(tcx: TyCtxt<'tcx>, key: C::Key, cycle: Cycle<'tcx>, error: Diag<'_>) -> C::Value,
 
     pub format_value: fn(&C::Value) -> String,
 
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 78ead0cf14f1..d518b6dd0012 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -8,8 +8,8 @@
 use rustc_errors::FatalError;
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::{
-    ActiveKeyStatus, CycleError, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey,
-    QueryLatch, QueryMode, QueryState, QueryVTable,
+    ActiveKeyStatus, Cycle, EnsureMode, QueryCache, QueryJob, QueryJobId, QueryKey, QueryLatch,
+    QueryMode, QueryState, QueryVTable,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::verify_ich::incremental_verify_ich;
@@ -17,7 +17,7 @@
 use tracing::warn;
 
 use crate::dep_graph::{DepNode, DepNodeIndex};
-use crate::job::{QueryJobInfo, QueryJobMap, find_cycle_in_stack, report_cycle};
+use crate::job::{QueryJobInfo, QueryJobMap, create_cycle_error, find_cycle_in_stack};
 use crate::plumbing::{current_query_job, loadable_from_disk, next_job_id, start_query};
 use crate::query_impl::for_each_query_vtable;
 
@@ -108,14 +108,14 @@ fn collect_active_query_jobs_inner<'tcx, C>(
 
 #[cold]
 #[inline(never)]
-fn mk_cycle<'tcx, C: QueryCache>(
+fn handle_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     key: C::Key,
-    cycle_error: CycleError<'tcx>,
+    cycle: Cycle<'tcx>,
 ) -> C::Value {
-    let error = report_cycle(tcx, &cycle_error);
-    (query.value_from_cycle_error)(tcx, key, cycle_error, error)
+    let error = create_cycle_error(tcx, &cycle);
+    (query.handle_cycle_error_fn)(tcx, key, cycle, error)
 }
 
 /// Guard object representing the responsibility to execute a query job and
@@ -194,7 +194,7 @@ fn drop(&mut self) {
 
 #[cold]
 #[inline(never)]
-fn cycle_error<'tcx, C: QueryCache>(
+fn find_and_handle_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     key: C::Key,
@@ -205,8 +205,8 @@ fn cycle_error<'tcx, C: QueryCache>(
     // We need the complete map to ensure we find a cycle to break.
     let job_map = collect_active_query_jobs(tcx, CollectActiveJobsKind::FullNoContention);
 
-    let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
-    (mk_cycle(query, tcx, key, error), None)
+    let cycle = find_cycle_in_stack(try_execute, job_map, &current_query_job(), span);
+    (handle_cycle(query, tcx, key, cycle), None)
 }
 
 #[inline(always)]
@@ -250,7 +250,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
 
             (v, Some(index))
         }
-        Err(cycle) => (mk_cycle(query, tcx, key, cycle), None),
+        Err(cycle) => (handle_cycle(query, tcx, key, cycle), None),
     }
 }
 
@@ -334,7 +334,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
                         // If we are single-threaded we know that we have cycle error,
                         // so we just return the error.
-                        cycle_error(query, tcx, key, id, span)
+                        find_and_handle_cycle(query, tcx, key, id, span)
                     }
                 }
                 ActiveKeyStatus::Poisoned => FatalError.raise(),
diff --git a/compiler/rustc_query_impl/src/from_cycle_error.rs b/compiler/rustc_query_impl/src/handle_cycle_error.rs
similarity index 92%
rename from compiler/rustc_query_impl/src/from_cycle_error.rs
rename to compiler/rustc_query_impl/src/handle_cycle_error.rs
index 0c6082e65f62..5676669bf1c0 100644
--- a/compiler/rustc_query_impl/src/from_cycle_error.rs
+++ b/compiler/rustc_query_impl/src/handle_cycle_error.rs
@@ -10,33 +10,33 @@
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::bug;
 use rustc_middle::queries::{QueryVTables, TaggedQueryKey};
-use rustc_middle::query::CycleError;
+use rustc_middle::query::Cycle;
 use rustc_middle::query::erase::erase_val;
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{ErrorGuaranteed, Span};
 
-use crate::job::report_cycle;
+use crate::job::create_cycle_error;
 
 pub(crate) fn specialize_query_vtables<'tcx>(vtables: &mut QueryVTables<'tcx>) {
-    vtables.fn_sig.value_from_cycle_error = |tcx, key, _, err| {
+    vtables.fn_sig.handle_cycle_error_fn = |tcx, key, _, err| {
         let guar = err.delay_as_bug();
         erase_val(fn_sig(tcx, key, guar))
     };
 
-    vtables.check_representability.value_from_cycle_error =
+    vtables.check_representability.handle_cycle_error_fn =
         |tcx, _, cycle, _err| check_representability(tcx, cycle);
 
-    vtables.check_representability_adt_ty.value_from_cycle_error =
+    vtables.check_representability_adt_ty.handle_cycle_error_fn =
         |tcx, _, cycle, _err| check_representability(tcx, cycle);
 
-    vtables.variances_of.value_from_cycle_error = |tcx, key, _, err| {
+    vtables.variances_of.handle_cycle_error_fn = |tcx, key, _, err| {
         let _guar = err.delay_as_bug();
         erase_val(variances_of(tcx, key))
     };
 
-    vtables.layout_of.value_from_cycle_error = |tcx, _, cycle, err| {
+    vtables.layout_of.handle_cycle_error_fn = |tcx, _, cycle, err| {
         let _guar = err.delay_as_bug();
         erase_val(Err(layout_of(tcx, cycle)))
     }
@@ -72,10 +72,10 @@ fn fn_sig<'tcx>(
     )))
 }
 
-fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>) -> ! {
+fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle: Cycle<'tcx>) -> ! {
     let mut item_and_field_ids = Vec::new();
     let mut representable_ids = FxHashSet::default();
-    for frame in &cycle_error.cycle {
+    for frame in &cycle.frames {
         if let TaggedQueryKey::check_representability(def_id) = frame.tagged_key
             && tcx.def_kind(def_id) == DefKind::Field
         {
@@ -88,7 +88,7 @@ fn check_representability<'tcx>(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>
             item_and_field_ids.push((item_id.expect_local(), field_id));
         }
     }
-    for frame in &cycle_error.cycle {
+    for frame in &cycle.frames {
         if let TaggedQueryKey::check_representability_adt_ty(key) = frame.tagged_key
             && let Some(adt) = key.ty_adt_def()
             && let Some(def_id) = adt.did().as_local()
@@ -127,14 +127,11 @@ fn search_for_cycle_permutation<Q, T>(
     otherwise()
 }
 
-fn layout_of<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError<'tcx>,
-) -> &'tcx ty::layout::LayoutError<'tcx> {
+fn layout_of<'tcx>(tcx: TyCtxt<'tcx>, cycle: Cycle<'tcx>) -> &'tcx ty::layout::LayoutError<'tcx> {
     let diag = search_for_cycle_permutation(
-        &cycle_error.cycle,
-        |cycle| {
-            if let TaggedQueryKey::layout_of(key) = cycle[0].tagged_key
+        &cycle.frames,
+        |frames| {
+            if let TaggedQueryKey::layout_of(key) = frames[0].tagged_key
                 && let ty::Coroutine(def_id, _) = key.value.kind()
                 && let Some(def_id) = def_id.as_local()
                 && let def_kind = tcx.def_kind(def_id)
@@ -158,7 +155,7 @@ fn layout_of<'tcx>(
                     tcx.def_kind_descr_article(def_kind, def_id.to_def_id()),
                     tcx.def_kind_descr(def_kind, def_id.to_def_id()),
                 );
-                for (i, frame) in cycle.iter().enumerate() {
+                for (i, frame) in frames.iter().enumerate() {
                     let TaggedQueryKey::layout_of(frame_key) = frame.tagged_key else {
                         continue;
                     };
@@ -169,7 +166,7 @@ fn layout_of<'tcx>(
                         continue;
                     };
                     let frame_span =
-                        frame.tagged_key.default_span(tcx, cycle[(i + 1) % cycle.len()].span);
+                        frame.tagged_key.default_span(tcx, frames[(i + 1) % frames.len()].span);
                     if frame_span.is_dummy() {
                         continue;
                     }
@@ -203,7 +200,7 @@ fn layout_of<'tcx>(
                 ControlFlow::Continue(())
             }
         },
-        || report_cycle(tcx, &cycle_error),
+        || create_cycle_error(tcx, &cycle),
     );
 
     let guar = diag.emit();
diff --git a/compiler/rustc_query_impl/src/job.rs b/compiler/rustc_query_impl/src/job.rs
index 213fc79a6843..a27a6f4ea322 100644
--- a/compiler/rustc_query_impl/src/job.rs
+++ b/compiler/rustc_query_impl/src/job.rs
@@ -7,9 +7,7 @@
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
 use rustc_middle::queries::TaggedQueryKey;
-use rustc_middle::query::{
-    CycleError, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter,
-};
+use rustc_middle::query::{Cycle, QueryJob, QueryJobId, QueryLatch, QueryStackFrame, QueryWaiter};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::{DUMMY_SP, Span};
 
@@ -58,29 +56,28 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
     job_map: QueryJobMap<'tcx>,
     current_job: &Option<QueryJobId>,
     span: Span,
-) -> CycleError<'tcx> {
-    // Find the waitee amongst `current_job` parents
-    let mut cycle = Vec::new();
+) -> Cycle<'tcx> {
+    // Find the waitee amongst `current_job` parents.
+    let mut frames = Vec::new();
     let mut current_job = Option::clone(current_job);
 
     while let Some(job) = current_job {
         let info = &job_map.map[&job];
-        cycle.push(QueryStackFrame { span: info.job.span, tagged_key: info.tagged_key });
+        frames.push(QueryStackFrame { span: info.job.span, tagged_key: info.tagged_key });
 
         if job == id {
-            cycle.reverse();
+            frames.reverse();
 
-            // This is the end of the cycle
-            // The span entry we included was for the usage
-            // of the cycle itself, and not part of the cycle
-            // Replace it with the span which caused the cycle to form
-            cycle[0].span = span;
-            // Find out why the cycle itself was used
+            // This is the end of the cycle. The span entry we included was for
+            // the usage of the cycle itself, and not part of the cycle.
+            // Replace it with the span which caused the cycle to form.
+            frames[0].span = span;
+            // Find out why the cycle itself was used.
             let usage = try {
                 let parent = info.job.parent?;
                 QueryStackFrame { span: info.job.span, tagged_key: job_map.tagged_key_of(parent) }
             };
-            return CycleError { usage, cycle };
+            return Cycle { usage, frames };
         }
 
         current_job = info.job.parent;
@@ -319,9 +316,9 @@ struct EntryPoint {
             .map(|(span, job)| QueryStackFrame { span, tagged_key: job_map.tagged_key_of(job) });
 
         // Create the cycle error
-        let error = CycleError {
+        let error = Cycle {
             usage,
-            cycle: stack
+            frames: stack
                 .iter()
                 .map(|&(span, job)| QueryStackFrame {
                     span,
@@ -454,27 +451,27 @@ pub fn print_query_stack<'tcx>(
 
 #[inline(never)]
 #[cold]
-pub(crate) fn report_cycle<'tcx>(
+pub(crate) fn create_cycle_error<'tcx>(
     tcx: TyCtxt<'tcx>,
-    CycleError { usage, cycle: stack }: &CycleError<'tcx>,
+    Cycle { usage, frames }: &Cycle<'tcx>,
 ) -> Diag<'tcx> {
-    assert!(!stack.is_empty());
+    assert!(!frames.is_empty());
 
-    let span = stack[0].tagged_key.default_span(tcx, stack[1 % stack.len()].span);
+    let span = frames[0].tagged_key.default_span(tcx, frames[1 % frames.len()].span);
 
     let mut cycle_stack = Vec::new();
 
     use crate::error::StackCount;
-    let stack_bottom = stack[0].tagged_key.description(tcx);
-    let stack_count = if stack.len() == 1 {
+    let stack_bottom = frames[0].tagged_key.description(tcx);
+    let stack_count = if frames.len() == 1 {
         StackCount::Single { stack_bottom: stack_bottom.clone() }
     } else {
         StackCount::Multiple { stack_bottom: stack_bottom.clone() }
     };
 
-    for i in 1..stack.len() {
-        let frame = &stack[i];
-        let span = frame.tagged_key.default_span(tcx, stack[(i + 1) % stack.len()].span);
+    for i in 1..frames.len() {
+        let frame = &frames[i];
+        let span = frame.tagged_key.default_span(tcx, frames[(i + 1) % frames.len()].span);
         cycle_stack
             .push(crate::error::CycleStack { span, desc: frame.tagged_key.description(tcx) });
     }
@@ -484,12 +481,12 @@ pub(crate) fn report_cycle<'tcx>(
         usage: usage.tagged_key.description(tcx),
     });
 
-    let alias = if stack
+    let alias = if frames
         .iter()
         .all(|frame| frame.tagged_key.def_kind(tcx) == Some(DefKind::TyAlias))
     {
         Some(crate::error::Alias::Ty)
-    } else if stack.iter().all(|frame| frame.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
+    } else if frames.iter().all(|frame| frame.tagged_key.def_kind(tcx) == Some(DefKind::TraitAlias))
     {
         Some(crate::error::Alias::Trait)
     } else {
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 2f69082db66e..173a7b111f0a 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -22,7 +22,7 @@
 mod dep_kind_vtables;
 mod error;
 mod execution;
-mod from_cycle_error;
+mod handle_cycle_error;
 mod job;
 mod plumbing;
 mod profiling_support;
@@ -49,7 +49,7 @@ pub fn query_system<'tcx>(
     incremental: bool,
 ) -> QuerySystem<'tcx> {
     let mut query_vtables = query_impl::make_query_vtables(incremental);
-    from_cycle_error::specialize_query_vtables(&mut query_vtables);
+    handle_cycle_error::specialize_query_vtables(&mut query_vtables);
     QuerySystem {
         arenas: Default::default(),
         query_vtables,
diff --git a/compiler/rustc_query_impl/src/query_impl.rs b/compiler/rustc_query_impl/src/query_impl.rs
index 1a8ed053e347..60ddf3e4ad38 100644
--- a/compiler/rustc_query_impl/src/query_impl.rs
+++ b/compiler/rustc_query_impl/src/query_impl.rs
@@ -166,10 +166,10 @@ pub(crate) fn make_query_vtable<'tcx>(incremental: bool)
                         try_load_from_disk_fn: |_tcx, _key, _prev_index, _index| None,
 
                         // The default just emits `err` and then aborts.
-                        // `from_cycle_error::specialize_query_vtables` overwrites this default for
-                        // certain queries.
-                        value_from_cycle_error: |_tcx, _key, _cycle, err| {
-                            $crate::from_cycle_error::default(err)
+                        // `handle_cycle_error::specialize_query_vtables` overwrites this default
+                        // for certain queries.
+                        handle_cycle_error_fn: |_tcx, _key, _cycle, err| {
+                            $crate::handle_cycle_error::default(err)
                         },
 
                         #[cfg($no_hash)]
diff --git a/compiler/rustc_ty_utils/src/representability.rs b/compiler/rustc_ty_utils/src/representability.rs
index 9fb16af75aaf..c83e0bb77fcf 100644
--- a/compiler/rustc_ty_utils/src/representability.rs
+++ b/compiler/rustc_ty_utils/src/representability.rs
@@ -58,7 +58,7 @@ fn check_representability_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) {
 //     -> check_representability_adt_ty(Bar<Foo>)
 //     -> check_representability(Foo)
 //
-// For the diagnostic output (in `Value::from_cycle_error`), we want to detect
+// For the diagnostic output (in `check_representability`), we want to detect
 // that the `Foo` in the *second* field of the struct is culpable. This
 // requires traversing the HIR of the struct and calling `params_in_repr(Bar)`.
 // But we can't call params_in_repr for a given type unless it is known to be

From 1e4b45367097b94e43f3111166bb2602019d8a6a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 15:26:21 +1100
Subject: [PATCH 0839/1059] Remove some dep-graph assertions.

The call chain for a non-incremental query includes the following
functions:

- execute_query_non_incr_inner (assert!)
- try_execute_query (assert!)
- execute_job_non_incr (assert!)

And likewise for an incremental query:

- execute_query_incr_inner (assert!)
- try_execute_query (assert!)
- execute_job_incr (expect)

That is five distinct functions. Every one of them has an `assert!` or
`expect` call that checks that the dep-graph is/is not enabled as
expected. Three cheers for defensive programming but this feels like
overkill, particularly when `execute_job{,_non_incr,_incr}` each have a
single call site.

This commit removes the assertions in `execute_query_*` and
`try_execute_query`, leaving a check in each of the `execute_job_*`
functions.
---
 compiler/rustc_query_impl/src/execution.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 78ead0cf14f1..783ae617b75b 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -298,8 +298,6 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
             // panic occurs while executing the query (or any intermediate plumbing).
             let job_guard = ActiveJobGuard { state: &query.state, key, key_hash };
 
-            debug_assert_eq!(tcx.dep_graph.is_fully_enabled(), INCR);
-
             // Delegate to another function to actually execute the query job.
             let (value, dep_node_index) = if INCR {
                 execute_job_incr(query, tcx, key, dep_node, id)
@@ -618,8 +616,6 @@ pub(super) fn execute_query_non_incr_inner<'tcx, C: QueryCache>(
     span: Span,
     key: C::Key,
 ) -> C::Value {
-    debug_assert!(!tcx.dep_graph.is_fully_enabled());
-
     ensure_sufficient_stack(|| try_execute_query::<C, false>(query, tcx, span, key, None).0)
 }
 
@@ -633,8 +629,6 @@ pub(super) fn execute_query_incr_inner<'tcx, C: QueryCache>(
     key: C::Key,
     mode: QueryMode,
 ) -> Option<C::Value> {
-    debug_assert!(tcx.dep_graph.is_fully_enabled());
-
     // Check if query execution can be skipped, for `ensure_ok` or `ensure_done`.
     // This might have the side-effect of creating a suitable DepNode, which
     // we should reuse for execution instead of creating a new one.

From 3c7ee983eb53bd286173ffe46f0c4db07e88f4fe Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 19 Mar 2026 10:26:16 +1100
Subject: [PATCH 0840/1059] Compute `DepNode` for incremental queries.

Prior to #154122 it wasn't used on all paths, so we only computed it
when necessary -- sometimes in `check_if_ensure_can_skip_execution`,
sometimes in one of two places in `execute_job_incr` -- and pass around
`Option<DepNode>` to allow this.

But now it's always used, so this commit makes us compute it earlier,
which simplifies things.
- `check_if_ensure_can_skip_execution` can be made simpler, returning a
  bool and eliminating the need for `EnsureCanSkip`.
- `execute_job_incr` no longer uses two slightly different methods to
  create a `DepNode` (`get_or_insert_with` vs `unwrap_or_else`).
---
 compiler/rustc_query_impl/src/execution.rs | 103 ++++++++-------------
 1 file changed, 37 insertions(+), 66 deletions(-)

diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index 783ae617b75b..42d5a78d24c4 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -261,9 +261,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
     tcx: TyCtxt<'tcx>,
     span: Span,
     key: C::Key,
-    // If present, some previous step has already created a `DepNode` for this
-    // query+key, which we should reuse instead of creating a new one.
-    dep_node: Option<DepNode>,
+    dep_node: Option<DepNode>, // `None` for non-incremental, `Some` for incremental
 ) -> (C::Value, Option<DepNodeIndex>) {
     let key_hash = sharded::make_hash(&key);
     let mut state_lock = query.state.active.lock_shard_by_hash(key_hash);
@@ -300,7 +298,7 @@ fn try_execute_query<'tcx, C: QueryCache, const INCR: bool>(
 
             // Delegate to another function to actually execute the query job.
             let (value, dep_node_index) = if INCR {
-                execute_job_incr(query, tcx, key, dep_node, id)
+                execute_job_incr(query, tcx, key, dep_node.unwrap(), id)
             } else {
                 execute_job_non_incr(query, tcx, key, id)
             };
@@ -416,27 +414,23 @@ fn execute_job_incr<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     key: C::Key,
-    mut dep_node_opt: Option<DepNode>,
+    dep_node: DepNode,
     job_id: QueryJobId,
 ) -> (C::Value, DepNodeIndex) {
     let dep_graph_data =
         tcx.dep_graph.data().expect("should always be present in incremental mode");
 
     if !query.eval_always {
-        // `to_dep_node` is expensive for some `DepKind`s.
-        let dep_node =
-            dep_node_opt.get_or_insert_with(|| DepNode::construct(tcx, query.dep_kind, &key));
-
         // The diagnostics for this query will be promoted to the current session during
         // `try_mark_green()`, so we can ignore them here.
         if let Some(ret) = start_query(job_id, false, || try {
-            let (prev_index, dep_node_index) = dep_graph_data.try_mark_green(tcx, dep_node)?;
+            let (prev_index, dep_node_index) = dep_graph_data.try_mark_green(tcx, &dep_node)?;
             let value = load_from_disk_or_invoke_provider_green(
                 tcx,
                 dep_graph_data,
                 query,
                 key,
-                dep_node,
+                &dep_node,
                 prev_index,
                 dep_node_index,
             );
@@ -449,10 +443,6 @@ fn execute_job_incr<'tcx, C: QueryCache>(
     let prof_timer = tcx.prof.query_provider();
 
     let (result, dep_node_index) = start_query(job_id, query.depth_limit, || {
-        // `to_dep_node` is expensive for some `DepKind`s.
-        let dep_node =
-            dep_node_opt.unwrap_or_else(|| DepNode::construct(tcx, query.dep_kind, &key));
-
         // Call the query provider.
         dep_graph_data.with_task(
             dep_node,
@@ -542,16 +532,6 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
     value
 }
 
-/// Return value struct for [`check_if_ensure_can_skip_execution`].
-struct EnsureCanSkip {
-    /// If true, the current `tcx.ensure_ok()` or `tcx.ensure_done()` query
-    /// can return early without actually trying to execute.
-    skip_execution: bool,
-    /// A dep node that was prepared while checking whether execution can be
-    /// skipped, to be reused by execution itself if _not_ skipped.
-    dep_node: Option<DepNode>,
-}
-
 /// Checks whether a `tcx.ensure_ok()` or `tcx.ensure_done()` query call can
 /// return early without actually trying to execute.
 ///
@@ -559,20 +539,19 @@ struct EnsureCanSkip {
 /// on having the dependency graph (and in some cases a disk-cached value)
 /// from the previous incr-comp session.
 #[inline(never)]
-fn check_if_ensure_can_skip_execution<'tcx, C: QueryCache>(
+fn ensure_can_skip_execution<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
     key: C::Key,
+    dep_node: DepNode,
     ensure_mode: EnsureMode,
-) -> EnsureCanSkip {
+) -> bool {
     // Queries with `eval_always` should never skip execution.
     if query.eval_always {
-        return EnsureCanSkip { skip_execution: false, dep_node: None };
+        return false;
     }
 
-    let dep_node = DepNode::construct(tcx, query.dep_kind, &key);
-
-    let serialized_dep_node_index = match tcx.dep_graph.try_mark_green(tcx, &dep_node) {
+    match tcx.dep_graph.try_mark_green(tcx, &dep_node) {
         None => {
             // A None return from `try_mark_green` means that this is either
             // a new dep node or that the dep node has already been marked red.
@@ -580,29 +559,27 @@ fn check_if_ensure_can_skip_execution<'tcx, C: QueryCache>(
             // DepNodeIndex. We must invoke the query itself. The performance cost
             // this introduces should be negligible as we'll immediately hit the
             // in-memory cache, or another query down the line will.
-            return EnsureCanSkip { skip_execution: false, dep_node: Some(dep_node) };
+            false
         }
         Some((serialized_dep_node_index, dep_node_index)) => {
             tcx.dep_graph.read_index(dep_node_index);
             tcx.prof.query_cache_hit(dep_node_index.into());
-            serialized_dep_node_index
-        }
-    };
+            match ensure_mode {
+                // In ensure-ok mode, we can skip execution for this key if the
+                // node is green. It must have succeeded in the previous
+                // session, and therefore would succeed in the current session
+                // if executed.
+                EnsureMode::Ok => true,
 
-    match ensure_mode {
-        EnsureMode::Ok => {
-            // In ensure-ok mode, we can skip execution for this key if the node
-            // is green. It must have succeeded in the previous session, and
-            // therefore would succeed in the current session if executed.
-            EnsureCanSkip { skip_execution: true, dep_node: None }
-        }
-        EnsureMode::Done => {
-            // In ensure-done mode, we can only skip execution for this key if
-            // there's a disk-cached value available to load later if needed,
-            // which guarantees the query provider will never run for this key.
-            let is_loadable = (query.will_cache_on_disk_for_key_fn)(tcx, key)
-                && loadable_from_disk(tcx, serialized_dep_node_index);
-            EnsureCanSkip { skip_execution: is_loadable, dep_node: Some(dep_node) }
+                // In ensure-done mode, we can only skip execution for this key
+                // if there's a disk-cached value available to load later if
+                // needed, which guarantees the query provider will never run
+                // for this key.
+                EnsureMode::Done => {
+                    (query.will_cache_on_disk_for_key_fn)(tcx, key)
+                        && loadable_from_disk(tcx, serialized_dep_node_index)
+                }
+            }
         }
     }
 }
@@ -629,24 +606,18 @@ pub(super) fn execute_query_incr_inner<'tcx, C: QueryCache>(
     key: C::Key,
     mode: QueryMode,
 ) -> Option<C::Value> {
-    // Check if query execution can be skipped, for `ensure_ok` or `ensure_done`.
-    // This might have the side-effect of creating a suitable DepNode, which
-    // we should reuse for execution instead of creating a new one.
-    let dep_node: Option<DepNode> = match mode {
-        QueryMode::Ensure { ensure_mode } => {
-            let EnsureCanSkip { skip_execution, dep_node } =
-                check_if_ensure_can_skip_execution(query, tcx, key, ensure_mode);
-            if skip_execution {
-                // Return early to skip execution.
-                return None;
-            }
-            dep_node
-        }
-        QueryMode::Get => None,
-    };
+    let dep_node = DepNode::construct(tcx, query.dep_kind, &key);
 
-    let (result, dep_node_index) =
-        ensure_sufficient_stack(|| try_execute_query::<C, true>(query, tcx, span, key, dep_node));
+    // Check if query execution can be skipped, for `ensure_ok` or `ensure_done`.
+    if let QueryMode::Ensure { ensure_mode } = mode
+        && ensure_can_skip_execution(query, tcx, key, dep_node, ensure_mode)
+    {
+        return None;
+    }
+
+    let (result, dep_node_index) = ensure_sufficient_stack(|| {
+        try_execute_query::<C, true>(query, tcx, span, key, Some(dep_node))
+    });
     if let Some(dep_node_index) = dep_node_index {
         tcx.dep_graph.read_index(dep_node_index)
     }

From da645bd0f45bbd729d6419af0c2e6339b4ee77ff Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 22:58:53 +0100
Subject: [PATCH 0841/1059] sembr src/diagnostics/lintstore.md

---
 .../src/diagnostics/lintstore.md              | 66 +++++++++----------
 1 file changed, 31 insertions(+), 35 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
index 90b62b3509a7..cda975a9a15e 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -3,15 +3,14 @@
 This page documents some of the machinery around lint registration and how we
 run lints in the compiler.
 
-The [`LintStore`] is the central piece of infrastructure, around which
-everything rotates. The `LintStore` is held as part of the [`Session`], and it
+The [`LintStore`] is the central piece of infrastructure, around which everything rotates.
+The `LintStore` is held as part of the [`Session`], and it
 gets populated with the list of lints shortly after the `Session` is created.
 
 ## Lints vs. lint passes
 
-There are two parts to the linting mechanism within the compiler: lints and
-lint passes. Unfortunately, a lot of the documentation we have refers to both
-of these as just "lints."
+There are two parts to the linting mechanism within the compiler: lints and lint passes.
+Unfortunately, a lot of the documentation we have refers to both of these as just "lints."
 
 First, we have the lint declarations themselves,
 and this is where the name and default lint level and other metadata come from.
@@ -24,10 +23,11 @@ like all macros).
 we lint against direct declarations without the use of the macro.
 
 Lint declarations don't carry any "state" - they are merely global identifiers
-and descriptions of lints. We assert at runtime that they are not registered
-twice (by lint name).
+and descriptions of lints.
+We assert at runtime that they are not registered twice (by lint name).
 
-Lint passes are the meat of any lint. Notably, there is not a one-to-one
+Lint passes are the meat of any lint.
+Notably, there is not a one-to-one
 relationship between lints and lint passes; a lint might not have any lint pass
 that emits it, it could have many, or just one -- the compiler doesn't track
 whether a pass is in any way associated with a particular lint, and frequently
@@ -44,36 +44,33 @@ and all lints are registered.
 There are three 'sources' of lints:
 
 * internal lints: lints only used by the rustc codebase
-* builtin lints: lints built into the compiler and not provided by some outside
-  source
-* `rustc_interface::Config`[`register_lints`]: lints passed into the compiler
-  during construction
+* builtin lints: lints built into the compiler and not provided by some outside source
+* `rustc_interface::Config`[`register_lints`]: lints passed into the compiler during construction
 
-Lints are registered via the [`LintStore::register_lint`] function. This should
-happen just once for any lint, or an ICE will occur.
+Lints are registered via the [`LintStore::register_lint`] function.
+This should happen just once for any lint, or an ICE will occur.
 
-Once the registration is complete, we "freeze" the lint store by placing it in
-an `Arc`.
+Once the registration is complete, we "freeze" the lint store by placing it in an `Arc`.
 
 Lint passes are registered separately into one of the categories
-(pre-expansion, early, late, late module). Passes are registered as a closure
+(pre-expansion, early, late, late module).
+Passes are registered as a closure
 -- i.e., `impl Fn() -> Box<dyn X>`, where `dyn X` is either an early or late
-lint pass trait object. When we run the lint passes, we run the closure and
-then invoke the lint pass methods. The lint pass methods take `&mut self` so
-they can keep track of state internally.
+lint pass trait object.
+When we run the lint passes, we run the closure and then invoke the lint pass methods.
+The lint pass methods take `&mut self` so they can keep track of state internally.
 
 #### Internal lints
 
-These are lints used just by the compiler or drivers like `clippy`. They can be
-found in [`rustc_lint::internal`].
+These are lints used just by the compiler or drivers like `clippy`.
+They can be found in [`rustc_lint::internal`].
 
 An example of such a lint is the check that lint passes are implemented using
-the `declare_lint_pass!` macro and not by hand. This is accomplished with the
-`LINT_PASS_IMPL_WITHOUT_MACRO` lint.
+the `declare_lint_pass!` macro and not by hand.
+This is accomplished with the `LINT_PASS_IMPL_WITHOUT_MACRO` lint.
 
 Registration of these lints happens in the [`rustc_lint::register_internals`]
-function which is called when constructing a new lint store inside
-[`rustc_lint::new_lint_store`].
+function which is called when constructing a new lint store inside [`rustc_lint::new_lint_store`].
 
 #### Builtin Lints
 
@@ -83,19 +80,18 @@ Often the first provides the definitions for the lints themselves,
 and the latter provides the lint pass definitions (and implementations),
 but this is not always true.
 
-The builtin lint registration happens in
-the [`rustc_lint::register_builtins`] function.
+The builtin lint registration happens in the [`rustc_lint::register_builtins`] function.
 Just like with internal lints,
 this happens inside of [`rustc_lint::new_lint_store`].
 
 #### Driver lints
 
 These are the lints provided by drivers via the `rustc_interface::Config`
-[`register_lints`] field, which is a callback. Drivers should, if finding it
-already set, call the function currently set within the callback they add. The
-best way for drivers to get access to this is by overriding the
-`Callbacks::config` function which gives them direct access to the `Config`
-structure.
+[`register_lints`] field, which is a callback.
+Drivers should, if finding it
+already set, call the function currently set within the callback they add.
+The best way for drivers to get access to this is by overriding the
+`Callbacks::config` function which gives them direct access to the `Config` structure.
 
 ## Compiler lint passes are combined into one pass
 
@@ -105,8 +101,8 @@ of lint passes. Instead, we have a single lint pass of each variety (e.g.,
 individual lint passes; this is because then we get the benefits of static over
 dynamic dispatch for each of the (often empty) trait methods.
 
-Ideally, we'd not have to do this, since it adds to the complexity of
-understanding the code. However, with the current type-erased lint store
+Ideally, we'd not have to do this, since it adds to the complexity of understanding the code.
+However, with the current type-erased lint store
 approach, it is beneficial to do so for performance reasons.
 
 [`LintStore`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html

From 0c3435c3e1125e8f876fd6d653783a3cf39fcfb9 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:05:39 +0100
Subject: [PATCH 0842/1059] use the more standard column length

---
 src/doc/rustc-dev-guide/ci/sembr/src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/ci/sembr/src/main.rs b/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
index 4038f112d59f..a9b4d182bd40 100644
--- a/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
+++ b/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
@@ -15,7 +15,7 @@ struct Cli {
     /// Modify files that do not comply
     overwrite: bool,
     /// Applies to lines that are to be split
-    #[arg(long, default_value_t = 100)]
+    #[arg(long, default_value_t = 80)]
     line_length_limit: usize,
 }
 

From b638ac4c3b723f01966a45c9fe95d8d2f0d414f4 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:07:32 +0100
Subject: [PATCH 0843/1059] sembr src/solve/candidate-preference.md

---
 .../src/solve/candidate-preference.md         | 58 +++++++++++++------
 1 file changed, 40 insertions(+), 18 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
index 22ec3162b73f..56fc865020a4 100644
--- a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
+++ b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
@@ -1,16 +1,23 @@
 # Candidate preference
 
-There are multiple ways to prove `Trait` and `NormalizesTo` goals. Each such option is called a [`Candidate`]. If there are multiple applicable candidates, we prefer some candidates over others. We store the relevant information in their [`CandidateSource`].
+There are multiple ways to prove `Trait` and `NormalizesTo` goals.
+Each such option is called a [`Candidate`].
+If there are multiple applicable candidates, we prefer some candidates over others.
+We store the relevant information in their [`CandidateSource`].
 
-This preference may result in incorrect inference or region constraints and would therefore be unsound during coherence. Because of this, we simply try to merge all candidates in coherence.
+This preference may result in incorrect inference or region constraints and would therefore be unsound during coherence.
+Because of this, we simply try to merge all candidates in coherence.
 
 ## `Trait` goals
 
-Trait goals merge their applicable candidates in [`fn merge_trait_candidates`]. This document provides additional details and references to explain *why* we've got the current preference rules.
+Trait goals merge their applicable candidates in [`fn merge_trait_candidates`].
+This document provides additional details and references to explain *why* we've got the current preference rules.
 
 ### `CandidateSource::BuiltinImpl(BuiltinImplSource::Trivial))`
 
-Trivial builtin impls are builtin impls which are known to be always applicable for well-formed types. This means that if one exists, using another candidate should never have fewer constraints. We currently only consider `Sized` - and `MetaSized` - impls to be trivial.
+Trivial builtin impls are builtin impls which are known to be always applicable for well-formed types.
+This means that if one exists, using another candidate should never have fewer constraints.
+We currently only consider `Sized` - and `MetaSized` - impls to be trivial.
 
 This is necessary to prevent a lifetime error for the following pattern
 
@@ -50,7 +57,8 @@ where
 ### `CandidateSource::ParamEnv`
 
 Once there's at least one *non-global* `ParamEnv` candidate, we prefer *all* `ParamEnv` candidates over other candidate kinds.
-A where-bound is global if it is not higher-ranked and doesn't contain any generic parameters. It may contain `'static`.
+A where-bound is global if it is not higher-ranked and doesn't contain any generic parameters.
+It may contain `'static`.
 
 We try to apply where-bounds over other candidates as users tends to have the most control over them, so they can most easily
 adjust them in case our candidate preference is incorrect.
@@ -68,7 +76,8 @@ fn foo<'a, T: Trait<'a>>() {
 }
 ```
 
-We also need this as shadowed impls can result in currently ambiguous solver cycles: [trait-system-refactor-initiative#76]. Without preference we'd be forced to fail with ambiguity
+We also need this as shadowed impls can result in currently ambiguous solver cycles: [trait-system-refactor-initiative#76].
+Without preference we'd be forced to fail with ambiguity
 errors if the where-bound results in region constraints to avoid incompleteness.
 ```rust
 trait Super {
@@ -94,7 +103,9 @@ fn overflow<T: Trait>() {
 }
 ```
 
-This preference causes a lot of issues. See [#24066]. Most of the
+This preference causes a lot of issues.
+See [#24066].
+Most of the
 issues are caused by preferring where-bounds over impls even if the where-bound guides type inference:
 ```rust
 trait Trait<T> {
@@ -167,7 +178,10 @@ where
 
 #### Why no preference for global where-bounds
 
-Global where-bounds are either fully implied by an impl or unsatisfiable. If they are unsatisfiable, we don't really care what happens. If a where-bound is fully implied then using the impl to prove the trait goal cannot result in additional constraints. For trait goals this is only useful for where-bounds which use `'static`:
+Global where-bounds are either fully implied by an impl or unsatisfiable.
+If they are unsatisfiable, we don't really care what happens.
+If a where-bound is fully implied then using the impl to prove the trait goal cannot result in additional constraints.
+For trait goals this is only useful for where-bounds which use `'static`:
 
 ```rust
 trait A {
@@ -181,13 +195,15 @@ where
     x.test();
 }
 ```
-More importantly, by using impls here we prevent global where-bounds from shadowing impls when normalizing associated types. There are no known issues from preferring impls over global where-bounds.
+More importantly, by using impls here we prevent global where-bounds from shadowing impls when normalizing associated types.
+There are no known issues from preferring impls over global where-bounds.
 
 #### Why still consider global where-bounds
 
 Given that we just use impls even if there exists a global where-bounds, you may ask why we don't just ignore these global where-bounds entirely: we use them to weaken the inference guidance from non-global where-bounds.
 
-Without a global where-bound, we currently prefer non-global where bounds even though there would be an applicable impl as well. By adding a non-global where-bound, this unnecessary inference guidance is disabled, allowing the following to compile:
+Without a global where-bound, we currently prefer non-global where bounds even though there would be an applicable impl as well.
+By adding a non-global where-bound, this unnecessary inference guidance is disabled, allowing the following to compile:
 ```rust
 fn check<Color>(color: Color)
 where
@@ -209,7 +225,9 @@ impl From<Vec> for f32 {
 
 ### `CandidateSource::AliasBound`
 
-We prefer alias-bound candidates over impls. We currently use this preference to guide type inference, causing the following to compile. I personally don't think this preference is desirable 🤷
+We prefer alias-bound candidates over impls.
+We currently use this preference to guide type inference, causing the following to compile.
+I personally don't think this preference is desirable 🤷
 ```rust
 pub trait Dyn {
     type Word: Into<u64>;
@@ -254,7 +272,9 @@ fn foo<'a, T: Trait<'a>>() {
 
 ### `CandidateSource::BuiltinImpl(BuiltinImplSource::Object(_))`
 
-We prefer builtin trait object impls over user-written impls. This is **unsound** and should be remoed in the future. See [#57893](https://github.com/rust-lang/rust/issues/57893) and [#141347](https://github.com/rust-lang/rust/pull/141347) for more details.
+We prefer builtin trait object impls over user-written impls.
+This is **unsound** and should be remoed in the future.
+See [#57893](https://github.com/rust-lang/rust/issues/57893) and [#141347](https://github.com/rust-lang/rust/pull/141347) for more details.
 
 ## `NormalizesTo` goals
 
@@ -336,7 +356,7 @@ Even if the trait goal was proven via an impl, we still prefer `ParamEnv` candid
 #### We prefer "orphaned" where-bounds
 
 We add "orphaned" `Projection` clauses into the `ParamEnv` when normalizing item bounds of GATs and RPITIT in `fn check_type_bounds`.
-We need to prefer these `ParamEnv` candidates over impls and other where-bounds. 
+We need to prefer these `ParamEnv` candidates over impls and other where-bounds.
 ```rust
 #![feature(associated_type_defaults)]
 trait Foo {
@@ -355,7 +375,8 @@ I don't fully understand the cases where this preference is actually necessary a
 
 #### We prefer global where-bounds over impls
 
-This is necessary for the following to compile. I don't know whether anything relies on it in practice 🤷
+This is necessary for the following to compile.
+I don't know whether anything relies on it in practice 🤷
 ```rust
 trait Id {
     type This;
@@ -423,7 +444,8 @@ where
 
 #### RPITIT `type_of` cycles
 
-We currently have to avoid impl candidates if there are where-bounds to avoid query cycles for RPITIT, see [#139762]. It feels desirable to me to stop relying on auto-trait leakage of during RPITIT computation to remove this issue, see [#139788].
+We currently have to avoid impl candidates if there are where-bounds to avoid query cycles for RPITIT, see [#139762].
+It feels desirable to me to stop relying on auto-trait leakage of during RPITIT computation to remove this issue, see [#139788].
 
 ```rust
 use std::future::Future;
@@ -457,8 +479,8 @@ where
 #### Trait definition cannot use associated types from always applicable impls
 
 The `T: Trait` assumption in the trait definition prevents it from normalizing
-`<Self as Trait>::Assoc` to `T` by using the blanket impl. This feels like a somewhat
-desirable constraint, if not incredibly so.
+`<Self as Trait>::Assoc` to `T` by using the blanket impl.
+This feels like a somewhat desirable constraint, if not incredibly so.
 
 ```rust
 trait Eq<T> {}
@@ -486,4 +508,4 @@ impl<T> Trait for T {
 [#24066]: https://github.com/rust-lang/rust/issues/24066
 [#133044]: https://github.com/rust-lang/rust/issues/133044
 [#139762]: https://github.com/rust-lang/rust/pull/139762
-[#139788]: https://github.com/rust-lang/rust/issues/139788
\ No newline at end of file
+[#139788]: https://github.com/rust-lang/rust/issues/139788

From 320d0895787c626977f456b0de25e0cec062df38 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:20:20 +0100
Subject: [PATCH 0844/1059] improve solve/candidate-preference.md

---
 .../src/solve/candidate-preference.md              | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
index 56fc865020a4..86ff3c84e101 100644
--- a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
+++ b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
@@ -32,7 +32,7 @@ where
 {
     // Elaborating the `&'a str: Trait<T>` where-bound results in a
     // `&'a str: Sized` where-bound. We do not want to prefer this
-    // over the builtin impl. 
+    // over the builtin impl.
     is_sized(x);
 }
 ```
@@ -77,7 +77,7 @@ fn foo<'a, T: Trait<'a>>() {
 ```
 
 We also need this as shadowed impls can result in currently ambiguous solver cycles: [trait-system-refactor-initiative#76].
-Without preference we'd be forced to fail with ambiguity
+Without preference, we'd be forced to fail with ambiguity
 errors if the where-bound results in region constraints to avoid incompleteness.
 ```rust
 trait Super {
@@ -98,7 +98,7 @@ where
 fn overflow<T: Trait>() {
     // We can use the elaborated `Super<SuperAssoc = Self::TraitAssoc>` where-bound
     // to prove the where-bound of the `T: Trait` implementation. This currently results in
-    // overflow. 
+    // overflow.
     let x: <T as Trait>::TraitAssoc;
 }
 ```
@@ -106,7 +106,7 @@ fn overflow<T: Trait>() {
 This preference causes a lot of issues.
 See [#24066].
 Most of the
-issues are caused by preferring where-bounds over impls even if the where-bound guides type inference:
+issues are caused by preferring where-bounds over impls even, if the where-bound guides type inference:
 ```rust
 trait Trait<T> {
     fn call_me(&self, x: T) {}
@@ -180,8 +180,8 @@ where
 
 Global where-bounds are either fully implied by an impl or unsatisfiable.
 If they are unsatisfiable, we don't really care what happens.
-If a where-bound is fully implied then using the impl to prove the trait goal cannot result in additional constraints.
-For trait goals this is only useful for where-bounds which use `'static`:
+If a where-bound is fully implied, then using the impl to prove the trait goal cannot result in additional constraints.
+For trait goals, this is only useful for where-bounds which use `'static`:
 
 ```rust
 trait A {
@@ -195,7 +195,7 @@ where
     x.test();
 }
 ```
-More importantly, by using impls here we prevent global where-bounds from shadowing impls when normalizing associated types.
+More importantly, by using impls here, we prevent global where-bounds from shadowing impls when normalizing associated types.
 There are no known issues from preferring impls over global where-bounds.
 
 #### Why still consider global where-bounds

From 3b82679be0ada13691c8b6eb5c3dc53a5980051f Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:23:31 +0100
Subject: [PATCH 0845/1059] avoid inline external links

---
 src/doc/rustc-dev-guide/src/solve/candidate-preference.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
index 86ff3c84e101..944c8316b06f 100644
--- a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
+++ b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
@@ -274,7 +274,7 @@ fn foo<'a, T: Trait<'a>>() {
 
 We prefer builtin trait object impls over user-written impls.
 This is **unsound** and should be remoed in the future.
-See [#57893](https://github.com/rust-lang/rust/issues/57893) and [#141347](https://github.com/rust-lang/rust/pull/141347) for more details.
+See [#57893] and [#141347] for more details.
 
 ## `NormalizesTo` goals
 
@@ -509,3 +509,5 @@ impl<T> Trait for T {
 [#133044]: https://github.com/rust-lang/rust/issues/133044
 [#139762]: https://github.com/rust-lang/rust/pull/139762
 [#139788]: https://github.com/rust-lang/rust/issues/139788
+[#57893]: https://github.com/rust-lang/rust/issues/57893
+[#141347]: https://github.com/rust-lang/rust/pull/141347

From d029d74b1c5915df057145353a66856337008452 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:26:53 +0100
Subject: [PATCH 0846/1059] add date-check marker to recent section

---
 src/doc/rustc-dev-guide/src/solve/candidate-preference.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
index 944c8316b06f..7fc39269d116 100644
--- a/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
+++ b/src/doc/rustc-dev-guide/src/solve/candidate-preference.md
@@ -476,6 +476,7 @@ where
 }
 ```
 
+<!-- date-check: Mar 2026 -->
 #### Trait definition cannot use associated types from always applicable impls
 
 The `T: Trait` assumption in the trait definition prevents it from normalizing

From 3ac4ceb5b87f845ab092b4b209f7456de7eda97a Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:27:31 +0100
Subject: [PATCH 0847/1059] sembr
 src/borrow-check/region-inference/member-constraints.md

---
 .../region-inference/member-constraints.md    | 128 ++++++++++--------
 1 file changed, 72 insertions(+), 56 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
index 2fe0a7b5808d..75891b419e1c 100644
--- a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
+++ b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
@@ -1,17 +1,18 @@
 # Member constraints
 
 A member constraint `'m member of ['c_1..'c_N]` expresses that the
-region `'m` must be *equal* to some **choice regions** `'c_i` (for
-some `i`). These constraints cannot be expressed by users, but they
-arise from `impl Trait` due to its lifetime capture rules. Consider a
-function such as the following:
+region `'m` must be *equal* to some **choice regions** `'c_i` (for some `i`).
+These constraints cannot be expressed by users, but they
+arise from `impl Trait` due to its lifetime capture rules.
+Consider a function such as the following:
 
 ```rust,ignore
 fn make(a: &'a u32, b: &'b u32) -> impl Trait<'a, 'b> { .. }
 ```
 
 Here, the true return type (often called the "hidden type") is only
-permitted to capture the lifetimes `'a` or `'b`. You can kind of see
+permitted to capture the lifetimes `'a` or `'b`.
+You can kind of see
 this more clearly by desugaring that `impl Trait` return type into its
 more explicit form:
 
@@ -23,7 +24,8 @@ fn make(a: &'a u32, b: &'b u32) -> MakeReturn<'a, 'b> { .. }
 Here, the idea is that the hidden type must be some type that could
 have been written in place of the `impl Trait<'x, 'y>` -- but clearly
 such a type can only reference the regions `'x` or `'y` (or
-`'static`!), as those are the only names in scope. This limitation is
+`'static`!), as those are the only names in scope.
+This limitation is
 then translated into a restriction to only access `'a` or `'b` because
 we are returning `MakeReturn<'a, 'b>`, where `'x` and `'y` have been
 replaced with `'a` and `'b` respectively.
@@ -31,8 +33,8 @@ replaced with `'a` and `'b` respectively.
 ## Detailed example
 
 To help us explain member constraints in more detail, let's spell out
-the `make` example in a bit more detail. First off, let's assume that
-you have some dummy trait:
+the `make` example in a bit more detail.
+First off, let's assume that you have some dummy trait:
 
 ```rust,ignore
 trait Trait<'a, 'b> { }
@@ -49,8 +51,8 @@ fn make(a: &'a u32, b: &'b u32) -> MakeReturn<'a, 'b> {
 ```
 
 What happens in this case is that the return type will be `(&'0 u32, &'1 u32)`,
-where `'0` and `'1` are fresh region variables. We will have the following
-region constraints:
+where `'0` and `'1` are fresh region variables.
+We will have the following region constraints:
 
 ```txt
 '0 live at {L}
@@ -67,11 +69,11 @@ return tuple is constructed to where it is returned (in fact, `'0` and
 `'1` might have slightly different liveness sets, but that's not very
 interesting to the point we are illustrating here).
 
-The `'a: '0` and `'b: '1` constraints arise from subtyping. When we
-construct the `(a, b)` value, it will be assigned type `(&'0 u32, &'1
+The `'a: '0` and `'b: '1` constraints arise from subtyping.
+When we construct the `(a, b)` value, it will be assigned type `(&'0 u32, &'1
 u32)` -- the region variables reflect that the lifetimes of these
-references could be made smaller. For this value to be created from
-`a` and `b`, however, we do require that:
+references could be made smaller.
+For this value to be created from `a` and `b`, however, we do require that:
 
 ```txt
 (&'a u32, &'b u32) <: (&'0 u32, &'1 u32)
@@ -82,35 +84,39 @@ which means in turn that `&'a u32 <: &'0 u32` and hence that `'a: '0`
 
 Note that if we ignore member constraints, the value of `'0` would be
 inferred to some subset of the function body (from the liveness
-constraints, which we did not write explicitly). It would never become
+constraints, which we did not write explicitly).
+It would never become
 `'a`, because there is no need for it too -- we have a constraint that
-`'a: '0`, but that just puts a "cap" on how *large* `'0` can grow to
-become. Since we compute the *minimal* value that we can, we are happy
-to leave `'0` as being just equal to the liveness set. This is where
-member constraints come in.
+`'a: '0`, but that just puts a "cap" on how *large* `'0` can grow to become.
+Since we compute the *minimal* value that we can, we are happy
+to leave `'0` as being just equal to the liveness set.
+This is where member constraints come in.
 
 ## Choices are always lifetime parameters
 
 At present, the "choice" regions from a member constraint are always lifetime
 parameters from the current function. As of <!-- date-check --> March 2026,
 this falls out from the placement of impl Trait, though in the future it may not
-be the case. We take some advantage of this fact, as it simplifies the current
-code. In particular, we don't have to consider a case like `'0 member of ['1,
+be the case.
+We take some advantage of this fact, as it simplifies the current code.
+In particular, we don't have to consider a case like `'0 member of ['1,
 'static]`, in which the value of both `'0` and `'1` are being inferred and hence
-changing. See [rust-lang/rust#61773][#61773] for more information.
+changing.
+See [rust-lang/rust#61773][#61773] for more information.
 
 [#61773]: https://github.com/rust-lang/rust/issues/61773
 
 ## Applying member constraints
 
-Member constraints are a bit more complex than other forms of
-constraints. This is because they have a "or" quality to them -- that
+Member constraints are a bit more complex than other forms of constraints.
+This is because they have a "or" quality to them -- that
 is, they describe multiple choices that we must select from. E.g., in
 our example constraint `'0 member of ['a, 'b, 'static]`, it might be
-that `'0` is equal to `'a`, `'b`, *or* `'static`. How can we pick the
-correct one?  What we currently do is to look for a *minimal choice*
--- if we find one, then we will grow `'0` to be equal to that minimal
-choice. To find that minimal choice, we take two factors into
+that `'0` is equal to `'a`, `'b`, *or* `'static`.
+How can we pick the correct one?
+ What we currently do is to look for a *minimal choice*
+-- if we find one, then we will grow `'0` to be equal to that minimal choice.
+To find that minimal choice, we take two factors into
 consideration: lower and upper bounds.
 
 ### Lower bounds
@@ -121,30 +127,34 @@ apply member constraints, we've already *computed* the lower bounds of
 `'0` because we computed its minimal value (or at least, the lower
 bounds considering everything but member constraints).
 
-Let `LB` be the current value of `'0`. We know then that `'0: LB` must
-hold, whatever the final value of `'0` is. Therefore, we can rule out
+Let `LB` be the current value of `'0`.
+We know then that `'0: LB` must hold, whatever the final value of `'0` is.
+Therefore, we can rule out
 any choice `'choice` where `'choice: LB` does not hold.
 
-Unfortunately, in our example, this is not very helpful. The lower
-bound for `'0` will just be the liveness set `{L}`, and we know that
-all the lifetime parameters outlive that set. So we are left with the
-same set of choices here. (But in other examples, particularly those
+Unfortunately, in our example, this is not very helpful.
+The lower bound for `'0` will just be the liveness set `{L}`, and we know that
+all the lifetime parameters outlive that set.
+So we are left with the same set of choices here.
+(But in other examples, particularly those
 with different variance, lower bound constraints may be relevant.)
 
 ### Upper bounds
 
 The *upper bounds* are those lifetimes that *must outlive* `'0` --
 i.e., that `'0` must be *smaller* than. In our example, this would be
-`'a`, because we have the constraint that `'a: '0`. In more complex
-examples, the chain may be more indirect.
+`'a`, because we have the constraint that `'a: '0`.
+In more complex examples, the chain may be more indirect.
 
 We can use upper bounds to rule out members in a very similar way to
-lower bounds. If UB is some upper bound, then we know that `UB:
+lower bounds.
+If UB is some upper bound, then we know that `UB:
 '0` must hold, so we can rule out any choice `'choice` where `UB:
 'choice` does not hold.
 
 In our example, we would be able to reduce our choice set from `['a,
-'b, 'static]` to just `['a]`. This is because `'0` has an upper bound
+'b, 'static]` to just `['a]`.
+This is because `'0` has an upper bound
 of `'a`, and neither `'a: 'b` nor `'a: 'static` is known to hold.
 
 (For notes on how we collect upper bounds in the implementation, see
@@ -153,39 +163,45 @@ of `'a`, and neither `'a: 'b` nor `'a: 'static` is known to hold.
 ### Minimal choice
 
 After applying lower and upper bounds, we can still sometimes have
-multiple possibilities. For example, imagine a variant of our example
-using types with the opposite variance. In that case, we would have
-the constraint `'0: 'a` instead of `'a: '0`. Hence the current value
-of `'0` would be `{L, 'a}`. Using this as a lower bound, we would be
+multiple possibilities.
+For example, imagine a variant of our example
+using types with the opposite variance.
+In that case, we would have the constraint `'0: 'a` instead of `'a: '0`.
+Hence the current value of `'0` would be `{L, 'a}`.
+Using this as a lower bound, we would be
 able to narrow down the member choices to `['a, 'static]` because `'b:
-'a` is not known to hold (but `'a: 'a` and `'static: 'a` do hold). We
-would not have any upper bounds, so that would be our final set of choices.
+'a` is not known to hold (but `'a: 'a` and `'static: 'a` do hold).
+We would not have any upper bounds, so that would be our final set of choices.
 
 In that case, we apply the **minimal choice** rule -- basically, if
-one of our choices if smaller than the others, we can use that. In
-this case, we would opt for `'a` (and not `'static`).
+one of our choices if smaller than the others, we can use that.
+In this case, we would opt for `'a` (and not `'static`).
 
 This choice is consistent with the general 'flow' of region
 propagation, which always aims to compute a minimal value for the
-region being inferred. However, it is somewhat arbitrary.
+region being inferred.
+However, it is somewhat arbitrary.
 
 <a id="collecting"></a>
 
 ### Collecting upper bounds in the implementation
 
 In practice, computing upper bounds is a bit inconvenient, because our
-data structures are setup for the opposite. What we do is to compute
+data structures are setup for the opposite.
+What we do is to compute
 the **reverse SCC graph** (we do this lazily and cache the result) --
-that is, a graph where `'a: 'b` induces an edge `SCC('b) ->
-SCC('a)`. Like the normal SCC graph, this is a DAG. We can then do a
-depth-first search starting from `SCC('0)` in this graph. This will
-take us to all the SCCs that must outlive `'0`.
+that is, a graph where `'a: 'b` induces an edge `SCC('b) -> SCC('a)`.
+Like the normal SCC graph, this is a DAG.
+We can then do a depth-first search starting from `SCC('0)` in this graph.
+This will take us to all the SCCs that must outlive `'0`.
 
 One wrinkle is that, as we walk the "upper bound" SCCs, their values
-will not yet have been fully computed. However, we **have** already
+will not yet have been fully computed.
+However, we **have** already
 applied their liveness constraints, so we have some information about
-their value. In particular, for any regions representing lifetime
+their value.
+In particular, for any regions representing lifetime
 parameters, their value will contain themselves (i.e., the initial
-value for `'a` includes `'a` and the value for `'b` contains `'b`). So
-we can collect all of the lifetime parameters that are reachable,
+value for `'a` includes `'a` and the value for `'b` contains `'b`).
+So we can collect all of the lifetime parameters that are reachable,
 which is precisely what we are interested in.

From c47c07e4f70cf9fbd888f7863ba0296a1c4c99a7 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:35:04 +0100
Subject: [PATCH 0848/1059] whitespace

---
 .../src/borrow-check/region-inference/member-constraints.md     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
index 75891b419e1c..21a56da9b707 100644
--- a/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
+++ b/src/doc/rustc-dev-guide/src/borrow-check/region-inference/member-constraints.md
@@ -114,7 +114,7 @@ is, they describe multiple choices that we must select from. E.g., in
 our example constraint `'0 member of ['a, 'b, 'static]`, it might be
 that `'0` is equal to `'a`, `'b`, *or* `'static`.
 How can we pick the correct one?
- What we currently do is to look for a *minimal choice*
+What we currently do is to look for a *minimal choice*
 -- if we find one, then we will grow `'0` to be equal to that minimal choice.
 To find that minimal choice, we take two factors into
 consideration: lower and upper bounds.

From a1e853f285d585f82f63247e86921cd100b7dceb Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:36:09 +0100
Subject: [PATCH 0849/1059] sembr src/early-late-parameters.md

---
 .../src/early-late-parameters.md              | 70 +++++++++++++------
 1 file changed, 47 insertions(+), 23 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/early-late-parameters.md b/src/doc/rustc-dev-guide/src/early-late-parameters.md
index 7651dee4ae23..f1e6a79d73f9 100644
--- a/src/doc/rustc-dev-guide/src/early-late-parameters.md
+++ b/src/doc/rustc-dev-guide/src/early-late-parameters.md
@@ -11,7 +11,8 @@ introduced: [Intermingled parameter lists] and [Intermingled parameter lists, ta
 
 ## What does it mean to be "early" bound or "late" bound
 
-Every function definition has a corresponding ZST that implements the `Fn*` traits known as a [function item type][function_item_type]. This part of the chapter will talk a little bit about the "desugaring" of function item types as it is useful context for explaining the difference between early bound and late bound generic parameters.
+Every function definition has a corresponding ZST that implements the `Fn*` traits known as a [function item type][function_item_type].
+This part of the chapter will talk a little bit about the "desugaring" of function item types as it is useful context for explaining the difference between early bound and late bound generic parameters.
 
 Let's start with a very trivial example involving no generic parameters:
 
@@ -51,7 +52,8 @@ impl<T: Sized> Fn<(T,)> for FooFnItem<T> {
 }
 ```
 
-Note that the function item type `FooFnItem` is generic over some type parameter `T` as defined on the function `foo`. However, not all generic parameters defined on functions are also defined on the function item type as demonstrated here:
+Note that the function item type `FooFnItem` is generic over some type parameter `T` as defined on the function `foo`.
+However, not all generic parameters defined on functions are also defined on the function item type as demonstrated here:
 ```rust
 fn foo<'a, T: Sized>(a: &'a T) -> &'a T {
     # a
@@ -74,9 +76,10 @@ Generic parameters not all being defined on the function item type means that th
 1. Naming the function (e.g. `let a = foo;`) the arguments for `FooFnItem` are provided. 
 2. Calling the function (e.g. `a(&10);`) any parameters defined on the builtin impl are provided.
 
-This two-step system is where the early vs late naming scheme comes from, early bound parameters are provided in the *earliest* step (naming the function), whereas late bound parameters are provided in the *latest* step (calling the function). 
+This two-step system is where the early vs late naming scheme comes from, early bound parameters are provided in the *earliest* step (naming the function), whereas late bound parameters are provided in the *latest* step (calling the function).
 
-Looking at the desugaring from the previous example we can tell that `T` is an early bound type parameter and `'a` is a late bound lifetime parameter as `T` is present on the function item type but `'a` is not. See this example of calling `foo` annotated with where each generic parameter has an argument provided:
+Looking at the desugaring from the previous example we can tell that `T` is an early bound type parameter and `'a` is a late bound lifetime parameter as `T` is present on the function item type but `'a` is not.
+See this example of calling `foo` annotated with where each generic parameter has an argument provided:
 ```rust
 fn foo<'a, T: Sized>(a: &'a T) -> &'a T {
     # a
@@ -98,13 +101,15 @@ my_func(&String::new());
 
 ### Higher ranked function pointers and trait bounds 
 
-A generic parameter being late bound allows for more flexible usage of the function item. For example if we have some function `foo` with an early bound lifetime parameter and some function `bar` with a late bound lifetime parameter `'a` we would have the following builtin `Fn` impls:
+A generic parameter being late bound allows for more flexible usage of the function item.
+For example if we have some function `foo` with an early bound lifetime parameter and some function `bar` with a late bound lifetime parameter `'a` we would have the following builtin `Fn` impls:
 ```rust,ignore
 impl<'a> Fn<(&'a String,)> for FooFnItem<'a> { /* ... */ }
 impl<'a> Fn<(&'a String,)> for BarFnItem { /* ... */ }
 ```
 
-The `bar` function has a strictly more flexible signature as the function item type can be called with a borrow with *any* lifetime, whereas the `foo` function item type would only be callable with a borrow with the same lifetime on the function item type. We can show this by simply trying to call `foo`'s function item type multiple times with different lifetimes:
+The `bar` function has a strictly more flexible signature as the function item type can be called with a borrow with *any* lifetime, whereas the `foo` function item type would only be callable with a borrow with the same lifetime on the function item type.
+We can show this by simply trying to call `foo`'s function item type multiple times with different lifetimes:
 
 ```rust
 // The `'a: 'a` bound forces this lifetime to be early bound.
@@ -125,9 +130,12 @@ f(&String::new());
 f(&String::new());
 ```
 
-In this example we call `foo`'s function item type twice, each time with a borrow of a temporary. These two borrows could not possible have lifetimes that overlap as the temporaries are only alive during the function call, not after. The lifetime parameter on `foo` being early bound requires all callers of `f` to provide a borrow with the same lifetime, as this is not possible the borrow checker errors.
+In this example we call `foo`'s function item type twice, each time with a borrow of a temporary.
+These two borrows could not possible have lifetimes that overlap as the temporaries are only alive during the function call, not after.
+The lifetime parameter on `foo` being early bound requires all callers of `f` to provide a borrow with the same lifetime, as this is not possible the borrow checker errors.
 
-If the lifetime parameter on `foo` was late bound this would be able to compile as each caller could provide a different lifetime argument for its borrow. See the following example which demonstrates this using the `bar` function defined above:
+If the lifetime parameter on `foo` was late bound this would be able to compile as each caller could provide a different lifetime argument for its borrow.
+See the following example which demonstrates this using the `bar` function defined above:
 
 ```rust
 # fn foo<'a: 'a>(b: &'a String) -> &'a String { b }
@@ -143,7 +151,8 @@ b(&String::new());
 b(&String::new());
 ```
 
-This is reflected in the ability to coerce function item types to higher ranked function pointers and prove higher ranked `Fn` trait bounds. We can demonstrate this with the following example:
+This is reflected in the ability to coerce function item types to higher ranked function pointers and prove higher ranked `Fn` trait bounds.
+We can demonstrate this with the following example:
 ```rust
 // The `'a: 'a` bound forces this lifetime to be early bound.
 fn foo<'a: 'a>(b: &'a String) -> &'a String { b }
@@ -170,7 +179,8 @@ fn higher_ranked_fn_ptr() {
 }
 ```
 
-In both of these cases the borrow checker errors as it does not consider `foo_fn_item` to be callable with a borrow of any lifetime. This is due to the fact that the lifetime parameter on `foo` is early bound, causing `foo_fn_item` to have a type of `FooFnItem<'_>` which (as demonstrated by the desugared `Fn` impl) is only callable with a borrow of the same lifetime `'_`.
+In both of these cases the borrow checker errors as it does not consider `foo_fn_item` to be callable with a borrow of any lifetime.
+This is due to the fact that the lifetime parameter on `foo` is early bound, causing `foo_fn_item` to have a type of `FooFnItem<'_>` which (as demonstrated by the desugared `Fn` impl) is only callable with a borrow of the same lifetime `'_`.
 
 ### Turbofishing in the presence of late bound parameters
 
@@ -188,14 +198,16 @@ fn foo<'a>(b: &'a u32) -> &'a u32 { b }
 let f /* : FooFnItem<????> */ = foo::<'static>;
 ```
 
-The above example errors as the lifetime parameter `'a` is late bound and so cannot be instantiated as part of the "naming a function" step. If we make the lifetime parameter early bound we will see this code start to compile:
+The above example errors as the lifetime parameter `'a` is late bound and so cannot be instantiated as part of the "naming a function" step.
+If we make the lifetime parameter early bound we will see this code start to compile:
 ```rust
 fn foo<'a: 'a>(b: &'a u32) -> &'a u32 { b }
 
 let f /* : FooFnItem<'static> */ = foo::<'static>;
 ```
 
-What the current implementation of the compiler aims to do is error when specifying lifetime arguments to a function that has both early *and* late bound lifetime parameters. In practice, due to excessive breakage, some cases are actually only future compatibility warnings ([#42868](https://github.com/rust-lang/rust/issues/42868)):
+What the current implementation of the compiler aims to do is error when specifying lifetime arguments to a function that has both early *and* late bound lifetime parameters.
+In practice, due to excessive breakage, some cases are actually only future compatibility warnings ([#42868](https://github.com/rust-lang/rust/issues/42868)):
 - When the amount of lifetime arguments is the same as the number of early bound lifetime parameters a FCW is emitted instead of an error
 - An error is always downgraded to a FCW when using method call syntax
 
@@ -287,7 +299,8 @@ Foo::inherent_function::<'static, 'static, 'static>(&(), &());
 free_function::<'static, 'static, 'static>(&(), &());
 ```
 
-Even when specifying enough lifetime arguments for both the late and early bound lifetime parameter, these arguments are not actually used to annotate the lifetime provided to late bound parameters. We can demonstrate this by turbofishing `'static` to a function while providing a non-static borrow:
+Even when specifying enough lifetime arguments for both the late and early bound lifetime parameter, these arguments are not actually used to annotate the lifetime provided to late bound parameters.
+We can demonstrate this by turbofishing `'static` to a function while providing a non-static borrow:
 ```rust
 struct Foo;
 
@@ -302,7 +315,8 @@ This compiles even though the `&String::new()` function argument does not have a
 
 ### Liveness of types with late bound parameters
 
-When checking type outlives bounds involving function item types we take into account early bound parameters. For example:
+When checking type outlives bounds involving function item types we take into account early bound parameters.
+For example:
 
 ```rust
 fn foo<T>(_: T) {}
@@ -315,9 +329,11 @@ fn bar<T>() {
 }
 ```
 
-As the type parameter `T` is early bound, the desugaring of the function item type for `foo` would look something like `struct FooFnItem<T>`. Then in order for `FooFnItem<T>: 'static` to hold we must also require `T: 'static` to hold as otherwise we would wind up with soundness bugs.
+As the type parameter `T` is early bound, the desugaring of the function item type for `foo` would look something like `struct FooFnItem<T>`.
+Then in order for `FooFnItem<T>: 'static` to hold we must also require `T: 'static` to hold as otherwise we would wind up with soundness bugs.
 
-Unfortunately, due to bugs in the compiler, we do not take into account early bound *lifetimes*, which is the cause of the open soundness bug [#84366](https://github.com/rust-lang/rust/issues/84366). This means that it's impossible to demonstrate a "difference" between early/late bound parameters for liveness/type outlives bounds as the only kind of generic parameters that are able to be late bound are lifetimes which are handled incorrectly.
+Unfortunately, due to bugs in the compiler, we do not take into account early bound *lifetimes*, which is the cause of the open soundness bug [#84366](https://github.com/rust-lang/rust/issues/84366).
+This means that it's impossible to demonstrate a "difference" between early/late bound parameters for liveness/type outlives bounds as the only kind of generic parameters that are able to be late bound are lifetimes which are handled incorrectly.
 
 Regardless, in theory the code example below *should* demonstrate such a difference once [#84366](https://github.com/rust-lang/rust/issues/84366) is fixed:
 ```rust
@@ -341,17 +357,20 @@ fn bar<'b>() {
 
 ### Must be a lifetime parameter
 
-Type and Const parameters are not able to be late bound as we do not have a way to support types such as `dyn for<T> Fn(Box<T>)` or `for<T> fn(Box<T>)`. Calling such types requires being able to monomorphize the underlying function which is not possible with indirection through dynamic dispatch.
+Type and Const parameters are not able to be late bound as we do not have a way to support types such as `dyn for<T> Fn(Box<T>)` or `for<T> fn(Box<T>)`.
+Calling such types requires being able to monomorphize the underlying function which is not possible with indirection through dynamic dispatch.
 
 ### Must not be used in a where clause
 
-Currently when a generic parameter is used in a where clause it must be early bound. For example:
+Currently when a generic parameter is used in a where clause it must be early bound.
+For example:
 ```rust
 # trait Trait<'a> {}
 fn foo<'a, T: Trait<'a>>(_: &'a String, _: T) {}
 ```
 
-In this example the lifetime parameter `'a` is considered to be early bound as it appears in the where clause `T: Trait<'a>`. This is true even for "trivial" where clauses such as `'a: 'a` or those implied by wellformedness of function arguments, for example:
+In this example the lifetime parameter `'a` is considered to be early bound as it appears in the where clause `T: Trait<'a>`.
+This is true even for "trivial" where clauses such as `'a: 'a` or those implied by wellformedness of function arguments, for example:
 ```rust
 fn foo<'a: 'a>(_: &'a String) {}
 fn bar<'a, T: 'a>(_: &'a T) {}
@@ -375,9 +394,12 @@ f(&String::new());
 
 At *some point* during type checking an error should be emitted for this code as `String` does not implement `Trait` for any lifetime.
 
-If the lifetime `'a` were late bound then this becomes difficult to check. When naming `foo` we do not know what lifetime should be used as part of the `T: Trait<'a>` trait bound as it has not yet been instantiated. When coercing the function item type to a function pointer we have no way of tracking the `String: Trait<'a>` trait bound that must be proven when calling the function. 
+If the lifetime `'a` were late bound then this becomes difficult to check.
+When naming `foo` we do not know what lifetime should be used as part of the `T: Trait<'a>` trait bound as it has not yet been instantiated.
+When coercing the function item type to a function pointer we have no way of tracking the `String: Trait<'a>` trait bound that must be proven when calling the function.
 
-If the lifetime `'a` is early bound (which it is in the current implementation in rustc), then the trait bound can be checked when naming the function `foo`. Requiring parameters used in where clauses to be early bound gives a natural place to check where clauses defined on the function.
+If the lifetime `'a` is early bound (which it is in the current implementation in rustc), then the trait bound can be checked when naming the function `foo`.
+Requiring parameters used in where clauses to be early bound gives a natural place to check where clauses defined on the function.
 
 Finally, we do not require lifetimes to be early bound if they are used in *implied bounds*, for example:
 ```rust
@@ -388,11 +410,13 @@ f(&String::new());
 f(&String::new());
 ```
 
-This code compiles, demonstrating that the lifetime parameter is late bound, even though `'a` is used in the type `&'a T` which implicitly requires `T: 'a` to hold. Implied bounds can be treated specially as any types introducing implied bounds are in the signature of the function pointer type, which means that when calling the function we know to prove `T: 'a`.
+This code compiles, demonstrating that the lifetime parameter is late bound, even though `'a` is used in the type `&'a T` which implicitly requires `T: 'a` to hold.
+Implied bounds can be treated specially as any types introducing implied bounds are in the signature of the function pointer type, which means that when calling the function we know to prove `T: 'a`.
 
 ### Must be constrained by argument types
 
-It is important that builtin impls on function item types do not wind up with unconstrained generic parameters as this can lead to unsoundness. This is the same kind of restriction as applies to user written impls, for example the following code results in an error:
+It is important that builtin impls on function item types do not wind up with unconstrained generic parameters as this can lead to unsoundness.
+This is the same kind of restriction as applies to user written impls, for example the following code results in an error:
 ```rust
 trait Trait {
     type Assoc;

From 85e8310c0895428b9fd660583208d056002e9fb3 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 23 Mar 2026 23:51:11 +0100
Subject: [PATCH 0850/1059] improve early-late-parameters.md

---
 .../src/early-late-parameters.md              | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/early-late-parameters.md b/src/doc/rustc-dev-guide/src/early-late-parameters.md
index f1e6a79d73f9..d78d5331baac 100644
--- a/src/doc/rustc-dev-guide/src/early-late-parameters.md
+++ b/src/doc/rustc-dev-guide/src/early-late-parameters.md
@@ -37,7 +37,7 @@ The builtin impls for the `FnMut`/`FnOnce` traits as well as the impls for `Copy
 
 A slightly more complicated example would involve introducing generic parameters to the function:
 ```rust
-fn foo<T: Sized>(a: T) -> T { 
+fn foo<T: Sized>(a: T) -> T {
     # a
     /* snip */
 }
@@ -73,7 +73,7 @@ impl<'a, T: Sized> Fn<(&'a T,)> for FooFnItem<T> {
 The lifetime parameter `'a` from the function `foo` is not present on the function item type `FooFnItem` and is instead introduced on the builtin impl solely for use in representing the argument types.
 
 Generic parameters not all being defined on the function item type means that there are two steps where generic arguments are provided when calling a function.
-1. Naming the function (e.g. `let a = foo;`) the arguments for `FooFnItem` are provided. 
+1. Naming the function (e.g. `let a = foo;`) the arguments for `FooFnItem` are provided.
 2. Calling the function (e.g. `a(&10);`) any parameters defined on the builtin impl are provided.
 
 This two-step system is where the early vs late naming scheme comes from, early bound parameters are provided in the *earliest* step (naming the function), whereas late bound parameters are provided in the *latest* step (calling the function).
@@ -99,10 +99,10 @@ my_func(&String::new());
 
 ## Differences between early and late bound parameters
 
-### Higher ranked function pointers and trait bounds 
+### Higher ranked function pointers and trait bounds
 
 A generic parameter being late bound allows for more flexible usage of the function item.
-For example if we have some function `foo` with an early bound lifetime parameter and some function `bar` with a late bound lifetime parameter `'a` we would have the following builtin `Fn` impls:
+For example, if we have some function `foo` with an early bound lifetime parameter and some function `bar` with a late bound lifetime parameter `'a`, we would have the following builtin `Fn` impls:
 ```rust,ignore
 impl<'a> Fn<(&'a String,)> for FooFnItem<'a> { /* ... */ }
 impl<'a> Fn<(&'a String,)> for BarFnItem { /* ... */ }
@@ -130,12 +130,12 @@ f(&String::new());
 f(&String::new());
 ```
 
-In this example we call `foo`'s function item type twice, each time with a borrow of a temporary.
-These two borrows could not possible have lifetimes that overlap as the temporaries are only alive during the function call, not after.
+In this example, we call `foo`'s function item type twice, each time with a borrow of a temporary.
+These two borrows could not possibly have lifetimes that overlap as the temporaries are only alive during the function call, not after.
 The lifetime parameter on `foo` being early bound requires all callers of `f` to provide a borrow with the same lifetime, as this is not possible the borrow checker errors.
 
-If the lifetime parameter on `foo` was late bound this would be able to compile as each caller could provide a different lifetime argument for its borrow.
-See the following example which demonstrates this using the `bar` function defined above:
+If the lifetime parameter on `foo` was late bound, this would be able to compile as each caller could provide a different lifetime argument for its borrow.
+See the following example, which demonstrates this using the `bar` function defined above:
 
 ```rust
 # fn foo<'a: 'a>(b: &'a String) -> &'a String { b }
@@ -172,14 +172,14 @@ fn higher_ranked_trait_bound() {
 fn higher_ranked_fn_ptr() {
     let bar_fn_item = bar;
     let fn_ptr: for<'a> fn(&'a String) -> &'a String = bar_fn_item;
-    
+
     let foo_fn_item = foo::<'_>;
     // errors
     let fn_ptr: for<'a> fn(&'a String) -> &'a String = foo_fn_item;
 }
 ```
 
-In both of these cases the borrow checker errors as it does not consider `foo_fn_item` to be callable with a borrow of any lifetime.
+In both of these cases, the borrow checker errors as it does not consider `foo_fn_item` to be callable with a borrow of any lifetime.
 This is due to the fact that the lifetime parameter on `foo` is early bound, causing `foo_fn_item` to have a type of `FooFnItem<'_>` which (as demonstrated by the desugared `Fn` impl) is only callable with a borrow of the same lifetime `'_`.
 
 ### Turbofishing in the presence of late bound parameters
@@ -208,7 +208,7 @@ let f /* : FooFnItem<'static> */ = foo::<'static>;
 
 What the current implementation of the compiler aims to do is error when specifying lifetime arguments to a function that has both early *and* late bound lifetime parameters.
 In practice, due to excessive breakage, some cases are actually only future compatibility warnings ([#42868](https://github.com/rust-lang/rust/issues/42868)):
-- When the amount of lifetime arguments is the same as the number of early bound lifetime parameters a FCW is emitted instead of an error
+- When the amount of lifetime arguments is the same as the number of early bound lifetime parameters, a FCW is emitted instead of an error
 - An error is always downgraded to a FCW when using method call syntax
 
 To demonstrate this we can write out the different kinds of functions and give them both a late and early bound lifetime:
@@ -330,7 +330,7 @@ fn bar<T>() {
 ```
 
 As the type parameter `T` is early bound, the desugaring of the function item type for `foo` would look something like `struct FooFnItem<T>`.
-Then in order for `FooFnItem<T>: 'static` to hold we must also require `T: 'static` to hold as otherwise we would wind up with soundness bugs.
+Then, in order for `FooFnItem<T>: 'static` to hold, we must also require `T: 'static` to hold as otherwise we would wind up with soundness bugs.
 
 Unfortunately, due to bugs in the compiler, we do not take into account early bound *lifetimes*, which is the cause of the open soundness bug [#84366](https://github.com/rust-lang/rust/issues/84366).
 This means that it's impossible to demonstrate a "difference" between early/late bound parameters for liveness/type outlives bounds as the only kind of generic parameters that are able to be late bound are lifetimes which are handled incorrectly.

From 0ad2ede9b46a989799358f86d6e7f3eb979f7379 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Tue, 24 Mar 2026 00:03:31 +0100
Subject: [PATCH 0851/1059] sembr src/parallel-rustc.md

---
 src/doc/rustc-dev-guide/src/parallel-rustc.md | 42 ++++++++++++-------
 1 file changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index f83aaa639ecc..2fa266338778 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -11,7 +11,8 @@ Tracking issue: <https://github.com/rust-lang/rust/issues/113349>
 As of <!-- date-check --> November 2024, most of the rust compiler is now
 parallelized.
 
-- The codegen part is executed concurrently by default. You can use the `-C
+- The codegen part is executed concurrently by default.
+  You can use the `-C
   codegen-units=n` option to control the number of concurrent tasks.
 - The parts after HIR lowering to codegen such as type checking, borrowing
   checking, and mir optimization are parallelized in the nightly version.
@@ -31,17 +32,19 @@ The following sections are kept for now but are quite outdated.
 ## Code generation
 
 During monomorphization the compiler splits up all the code to
-be generated into smaller chunks called _codegen units_. These are then generated by
-independent instances of LLVM running in parallel. At the end, the linker
-is run to combine all the codegen units together into one binary. This process
-occurs in the [`rustc_codegen_ssa::base`] module.
+be generated into smaller chunks called _codegen units_.
+These are then generated by independent instances of LLVM running in parallel.
+At the end, the linker
+is run to combine all the codegen units together into one binary.
+This process occurs in the [`rustc_codegen_ssa::base`] module.
 
 [`rustc_codegen_ssa::base`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/index.html
 
 ## Data structures
 
 The underlying thread-safe data-structures used in the parallel compiler
-can be found in the [`rustc_data_structures::sync`] module. These data structures 
+can be found in the [`rustc_data_structures::sync`] module.
+These data structures
 are implemented differently depending on whether `parallel-compiler` is true.
 
 | data structure                   | parallel                                            | non-parallel |
@@ -68,14 +71,18 @@ are implemented differently depending on whether `parallel-compiler` is true.
 
 ### WorkerLocal
 
-[`WorkerLocal`] is a special data structure implemented for parallel compilers. It
-holds worker-locals values for each thread in a thread pool. You can only
+[`WorkerLocal`] is a special data structure implemented for parallel compilers.
+It holds worker-locals values for each thread in a thread pool.
+You can only
 access the worker local value through the `Deref` `impl` on the thread pool it
-was constructed on. It panics otherwise. 
+was constructed on.
+It panics otherwise.
 
 `WorkerLocal` is used to implement the `Arena` allocator in the parallel
-environment, which is critical in parallel queries. Its implementation is
-located in the [`rustc_data_structures::sync::worker_local`] module. However,
+environment, which is critical in parallel queries.
+Its implementation is
+located in the [`rustc_data_structures::sync::worker_local`] module.
+However,
 in the non-parallel compiler, it is implemented as `(OneThread<T>)`, whose `T`
 can be accessed directly through `Deref::deref`.
 
@@ -85,7 +92,8 @@ can be accessed directly through `Deref::deref`.
 ## Parallel iterator
 
 The parallel iterators provided by the [`rayon`] crate are easy ways to
-implement parallelism. In the current implementation of the parallel compiler
+implement parallelism.
+In the current implementation of the parallel compiler
 we use a custom [fork][rustc-rayon] of `rayon` to run tasks in parallel.
 
 Some iterator functions are implemented to run loops in parallel 
@@ -142,15 +150,17 @@ When a query `foo` is evaluated, the cache table for `foo` is locked.
   start evaluating.
 - If there *is* another query invocation for the same key in progress, we
   release the lock, and just block the thread until the other invocation has
-  computed the result we are waiting for. **Cycle error detection** in the parallel 
-  compiler requires more complex logic than in single-threaded mode. When 
+  computed the result we are waiting for.
+  **Cycle error detection** in the parallel
+  compiler requires more complex logic than in single-threaded mode.
+  When
   worker threads in parallel queries stop making progress due to interdependence, 
   the compiler uses an extra thread *(named deadlock handler)* to detect, remove and 
   report the cycle error.
 
 The parallel query feature still has implementation to do, most of which is
-related to the previous `Data Structures` and `Parallel Iterators`. See [this
-open feature tracking issue][tracking].
+related to the previous `Data Structures` and `Parallel Iterators`.
+See [this open feature tracking issue][tracking].
 
 ## Rustdoc
 

From 7a18ffb7c4b6796b289393184b1fce4b7c908b20 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Tue, 24 Mar 2026 00:06:00 +0100
Subject: [PATCH 0852/1059] improve parallel-rustc.md

---
 src/doc/rustc-dev-guide/src/parallel-rustc.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index 2fa266338778..68be36a0c2f8 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -64,7 +64,7 @@ are implemented differently depending on whether `parallel-compiler` is true.
   or the authoring of persistent documentation covering the specific of the
   invariants, the atomicity, and the lock orderings.
 
-- On the other hand, we still need to figure out what other invariants 
+- On the other hand, we still need to figure out what other invariants
   during compilation might not hold in parallel compilation.
 
 [`rustc_data_structures::sync`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/sync/index.html
@@ -93,10 +93,10 @@ can be accessed directly through `Deref::deref`.
 
 The parallel iterators provided by the [`rayon`] crate are easy ways to
 implement parallelism.
-In the current implementation of the parallel compiler
+In the current implementation of the parallel compiler,
 we use a custom [fork][rustc-rayon] of `rayon` to run tasks in parallel.
 
-Some iterator functions are implemented to run loops in parallel 
+Some iterator functions are implemented to run loops in parallel
 when `parallel-compiler` is true.
 
 | Function(Omit `Send` and `Sync`)                             | Introduction                                                 | Owning Module              |
@@ -154,8 +154,8 @@ When a query `foo` is evaluated, the cache table for `foo` is locked.
   **Cycle error detection** in the parallel
   compiler requires more complex logic than in single-threaded mode.
   When
-  worker threads in parallel queries stop making progress due to interdependence, 
-  the compiler uses an extra thread *(named deadlock handler)* to detect, remove and 
+  worker threads in parallel queries stop making progress due to interdependence,
+  the compiler uses an extra thread *(named deadlock handler)* to detect, remove and
   report the cycle error.
 
 The parallel query feature still has implementation to do, most of which is

From d8d68baf4f8d21e96cb868ce8acd8d056ef46070 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Tue, 24 Mar 2026 00:09:52 +0100
Subject: [PATCH 0853/1059] sembr src/tests/ci.md

---
 src/doc/rustc-dev-guide/src/tests/ci.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index 5161194492e6..5581b7eb9d8d 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -109,11 +109,13 @@ The live results can be seen on [the GitHub Actions workflows page].
 At any given time, at most a single `auto` build is being executed.
 Find out more in [Merging PRs serially with bors](#merging-prs-serially-with-bors).
 
-Normally, when an auto job fails, the whole CI workflow immediately ends. However, it can be useful to
+Normally, when an auto job fails, the whole CI workflow immediately ends.
+However, it can be useful to
 create auto jobs that are "non-blocking", or optional, to test them on CI for some time before blocking
-merges on them. This can be useful if those jobs can be flaky.
+merges on them.
+This can be useful if those jobs can be flaky.
 
-To do that, prefix such a job with `optional-`, and set `continue_on_error: true` for it in [`jobs.yml`]. 
+To do that, prefix such a job with `optional-`, and set `continue_on_error: true` for it in [`jobs.yml`].
 
 [platform tiers]: https://forge.rust-lang.org/release/platform-support.html#rust-platform-support
 [auto]: https://github.com/rust-lang/rust/tree/automation/bors/auto

From 61d960f1356eea18689d05921411488df0365fc0 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Tue, 24 Mar 2026 00:14:20 +0100
Subject: [PATCH 0854/1059] more area to click

---
 src/doc/rustc-dev-guide/src/parallel-rustc.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index 68be36a0c2f8..c4e0663068e6 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -94,7 +94,7 @@ can be accessed directly through `Deref::deref`.
 The parallel iterators provided by the [`rayon`] crate are easy ways to
 implement parallelism.
 In the current implementation of the parallel compiler,
-we use a custom [fork][rustc-rayon] of `rayon` to run tasks in parallel.
+we use [a custom fork of `rayon`][rustc-rayon] to run tasks in parallel.
 
 Some iterator functions are implemented to run loops in parallel
 when `parallel-compiler` is true.

From 3f67327de6db63c863b205a6fc8c58f41ade656a Mon Sep 17 00:00:00 2001
From: Alexander Zaitsev <zamazan4ik@tut.by>
Date: Tue, 24 Mar 2026 02:07:07 +0100
Subject: [PATCH 0855/1059] doc: update list of Rustc and Clang LTO
 compatibility

---
 src/doc/rustc/src/linker-plugin-lto.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/linker-plugin-lto.md b/src/doc/rustc/src/linker-plugin-lto.md
index 1502e694bba5..1e5822d9c357 100644
--- a/src/doc/rustc/src/linker-plugin-lto.md
+++ b/src/doc/rustc/src/linker-plugin-lto.md
@@ -194,7 +194,7 @@ def minor_version(version):
 INSTALL_TOOLCHAIN = ["rustup", "toolchain", "install", "--profile", "minimal"]
 subprocess.run(INSTALL_TOOLCHAIN + ["nightly"])
 
-LOWER_BOUND = 87
+LOWER_BOUND = 91
 NIGHTLY_VERSION = minor_version(subprocess.run(
     ["rustc", "+nightly", "--version"],
     capture_output=True,
@@ -256,6 +256,6 @@ The following table shows known good combinations of toolchain versions.
 | 1.78 - 1.81  |      18       |
 | 1.82 - 1.86  |      19       |
 | 1.87 - 1.90  |      20       |
-| 1.91 - 1.93  |      21       |
+| 1.91 - 1.94  |      21       |
 
 Note that the compatibility policy for this feature might change in the future.

From de15ab0065f512908225603bd429cafe0054b424 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 22 Mar 2026 18:37:59 +1100
Subject: [PATCH 0856/1059] Store value/side-effect index lists inside
 `CacheEncoder`

These lists can be considered part of the encoder state, and bundling them
inside the encoder is certainly more convenient than passing them around
separately.
---
 Cargo.lock                                    |  1 -
 .../rustc_middle/src/dep_graph/serialized.rs  |  9 ++
 compiler/rustc_middle/src/hooks/mod.rs        |  8 +-
 .../rustc_middle/src/query/on_disk_cache.rs   | 89 ++++++++++---------
 compiler/rustc_query_impl/Cargo.toml          |  1 -
 compiler/rustc_query_impl/src/plumbing.rs     | 26 ++----
 6 files changed, 64 insertions(+), 70 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1f2b417b2430..85997e1886f1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4573,7 +4573,6 @@ dependencies = [
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hir",
- "rustc_index",
  "rustc_macros",
  "rustc_middle",
  "rustc_serialize",
diff --git a/compiler/rustc_middle/src/dep_graph/serialized.rs b/compiler/rustc_middle/src/dep_graph/serialized.rs
index e84d117db2ae..ef5e3d9268ad 100644
--- a/compiler/rustc_middle/src/dep_graph/serialized.rs
+++ b/compiler/rustc_middle/src/dep_graph/serialized.rs
@@ -72,6 +72,15 @@
     pub struct SerializedDepNodeIndex {}
 }
 
+impl SerializedDepNodeIndex {
+    /// Converts a current-session dep node index to a "serialized" index,
+    /// for the purpose of serializing data to be loaded by future sessions.
+    #[inline(always)]
+    pub fn from_curr_for_serialization(index: DepNodeIndex) -> Self {
+        SerializedDepNodeIndex::from_u32(index.as_u32())
+    }
+}
+
 const DEP_NODE_SIZE: usize = size_of::<SerializedDepNodeIndex>();
 /// Amount of padding we need to add to the edge list data so that we can retrieve every
 /// SerializedDepNodeIndex with a fixed-size read then mask.
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 691096f4e47c..c70ceef1d47e 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -9,7 +9,7 @@
 use rustc_span::{ExpnHash, ExpnId};
 
 use crate::mir;
-use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex};
+use crate::query::on_disk_cache::CacheEncoder;
 use crate::ty::{Ty, TyCtxt};
 
 macro_rules! declare_hooks {
@@ -111,10 +111,8 @@ fn clone(&self) -> Self { *self }
     /// Creates the MIR for a given `DefId`, including unreachable code.
     hook build_mir_inner_impl(def: LocalDefId) -> mir::Body<'tcx>;
 
-    hook encode_query_values(
-        encoder: &mut CacheEncoder<'_, 'tcx>,
-        query_result_index: &mut EncodedDepNodeIndex
-    ) -> ();
+    /// Serializes all eligible query return values into the on-disk cache.
+    hook encode_query_values(encoder: &mut CacheEncoder<'_, 'tcx>) -> ();
 }
 
 #[cold]
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 607891d4d19d..b6409c1ea171 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -9,7 +9,7 @@
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, LocalDefId, StableCrateId};
 use rustc_hir::definitions::DefPathHash;
-use rustc_index::{Idx, IndexVec};
+use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable};
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder, IntEncodedWithFixedSize, MemDecoder};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
@@ -62,13 +62,13 @@ pub struct OnDiskCache {
     // Caches that are populated lazily during decoding.
     file_index_to_file: Lock<FxHashMap<SourceFileIndex, Arc<SourceFile>>>,
 
-    // A map from dep-node to the position of the cached query result in
-    // `serialized_data`.
-    query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
+    /// For query dep nodes that have a disk-cached return value, maps the node
+    /// index to the position of its serialized value in `serialized_data`.
+    query_values_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
 
-    // A map from dep-node to the position of any associated `QuerySideEffect` in
-    // `serialized_data`.
-    prev_side_effects_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
+    /// For `DepKind::SideEffect` dep nodes, maps the node index to the position
+    /// of its serialized [`QuerySideEffect`] in `serialized_data`.
+    side_effects_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
 
     alloc_decoding_state: AllocDecodingState,
 
@@ -101,8 +101,8 @@ pub struct OnDiskCache {
 #[derive(Encodable, Decodable)]
 struct Footer {
     file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>,
-    query_result_index: EncodedDepNodeIndex,
-    side_effects_index: EncodedDepNodeIndex,
+    query_values_index: Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>,
+    side_effects_index: Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>,
     // The location of all allocations.
     // Most uses only need values up to u32::MAX, but benchmarking indicates that we can use a u64
     // without measurable overhead. This permits larger const allocations without ICEing.
@@ -114,8 +114,6 @@ struct Footer {
     foreign_expn_data: UnhashMap<ExpnHash, u32>,
 }
 
-pub type EncodedDepNodeIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)]
 struct SourceFileIndex(u32);
 
@@ -175,8 +173,8 @@ pub fn new(sess: &Session, data: Mmap, start_pos: usize) -> Result<Self, ()> {
             file_index_to_stable_id: footer.file_index_to_stable_id,
             file_index_to_file: Default::default(),
             current_side_effects: Default::default(),
-            query_result_index: footer.query_result_index.into_iter().collect(),
-            prev_side_effects_index: footer.side_effects_index.into_iter().collect(),
+            query_values_index: footer.query_values_index.into_iter().collect(),
+            side_effects_index: footer.side_effects_index.into_iter().collect(),
             alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
             syntax_contexts: footer.syntax_contexts,
             expn_data: footer.expn_data,
@@ -191,8 +189,8 @@ pub fn new_empty() -> Self {
             file_index_to_stable_id: Default::default(),
             file_index_to_file: Default::default(),
             current_side_effects: Default::default(),
-            query_result_index: Default::default(),
-            prev_side_effects_index: Default::default(),
+            query_values_index: Default::default(),
+            side_effects_index: Default::default(),
             alloc_decoding_state: AllocDecodingState::new(Vec::new()),
             syntax_contexts: FxHashMap::default(),
             expn_data: UnhashMap::default(),
@@ -241,30 +239,19 @@ pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResu
                 file_to_file_index,
                 hygiene_context: &hygiene_encode_context,
                 symbol_index_table: Default::default(),
+                query_values_index: Default::default(),
+                side_effects_index: Default::default(),
             };
 
-            // Encode query results.
-            let mut query_result_index = EncodedDepNodeIndex::new();
-
+            // Encode query return values.
             tcx.sess.time("encode_query_values", || {
-                let enc = &mut encoder;
-                let qri = &mut query_result_index;
-                tcx.encode_query_values(enc, qri);
+                tcx.encode_query_values(&mut encoder);
             });
 
             // Encode side effects.
-            let side_effects_index: EncodedDepNodeIndex = self
-                .current_side_effects
-                .borrow()
-                .iter()
-                .map(|(dep_node_index, side_effect)| {
-                    let pos = AbsoluteBytePos::new(encoder.position());
-                    let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index());
-                    encoder.encode_tagged(dep_node_index, side_effect);
-
-                    (dep_node_index, pos)
-                })
-                .collect();
+            for (&dep_node_index, side_effect) in self.current_side_effects.borrow().iter() {
+                encoder.encode_side_effect(dep_node_index, side_effect);
+            }
 
             let interpret_alloc_index = {
                 let mut interpret_alloc_index = Vec::new();
@@ -315,11 +302,13 @@ pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResu
 
             // Encode the file footer.
             let footer_pos = encoder.position() as u64;
+            let query_values_index = mem::take(&mut encoder.query_values_index);
+            let side_effects_index = mem::take(&mut encoder.side_effects_index);
             encoder.encode_tagged(
                 TAG_FILE_FOOTER,
                 &Footer {
                     file_index_to_stable_id,
-                    query_result_index,
+                    query_values_index,
                     side_effects_index,
                     interpret_alloc_index,
                     syntax_contexts,
@@ -346,7 +335,7 @@ pub fn load_side_effect(
         dep_node_index: SerializedDepNodeIndex,
     ) -> Option<QuerySideEffect> {
         let side_effect: Option<QuerySideEffect> =
-            self.load_indexed(tcx, dep_node_index, &self.prev_side_effects_index);
+            self.load_indexed(tcx, dep_node_index, &self.side_effects_index);
         side_effect
     }
 
@@ -359,16 +348,15 @@ pub fn store_side_effect(&self, dep_node_index: DepNodeIndex, side_effect: Query
         debug_assert!(prev.is_none());
     }
 
-    /// Return whether the cached query result can be decoded.
+    /// Returns true if there is a disk-cached query return value for the given node.
     #[inline]
     pub fn loadable_from_disk(&self, dep_node_index: SerializedDepNodeIndex) -> bool {
-        self.query_result_index.contains_key(&dep_node_index)
+        self.query_values_index.contains_key(&dep_node_index)
         // with_decoder is infallible, so we can stop here
     }
 
-    /// Returns the cached query result if there is something in the cache for
-    /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
-    pub fn try_load_query_result<'tcx, T>(
+    /// Returns the disk-cached query return value for the given node, if there is one.
+    pub fn try_load_query_value<'tcx, T>(
         &self,
         tcx: TyCtxt<'tcx>,
         dep_node_index: SerializedDepNodeIndex,
@@ -376,7 +364,7 @@ pub fn try_load_query_result<'tcx, T>(
     where
         T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
     {
-        let opt_value = self.load_indexed(tcx, dep_node_index, &self.query_result_index);
+        let opt_value = self.load_indexed(tcx, dep_node_index, &self.query_values_index);
         debug_assert_eq!(opt_value.is_some(), self.loadable_from_disk(dep_node_index));
         opt_value
     }
@@ -815,6 +803,9 @@ pub struct CacheEncoder<'a, 'tcx> {
     hygiene_context: &'a HygieneEncodeContext,
     // Used for both `Symbol`s and `ByteSymbol`s.
     symbol_index_table: FxHashMap<u32, usize>,
+
+    query_values_index: Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>,
+    side_effects_index: Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>,
 }
 
 impl<'a, 'tcx> fmt::Debug for CacheEncoder<'a, 'tcx> {
@@ -835,7 +826,7 @@ fn source_file_index(&mut self, source_file: Arc<SourceFile>) -> SourceFileIndex
     /// encode the specified tag, then the given value, then the number of
     /// bytes taken up by tag and value. On decoding, we can then verify that
     /// we get the expected tag and read the expected number of bytes.
-    pub fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>(&mut self, tag: T, value: &V) {
+    fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>(&mut self, tag: T, value: &V) {
         let start_pos = self.position();
 
         tag.encode(self);
@@ -845,6 +836,20 @@ pub fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>(&mut self, tag: T,
         ((end_pos - start_pos) as u64).encode(self);
     }
 
+    pub fn encode_query_value<V: Encodable<Self>>(&mut self, index: DepNodeIndex, value: &V) {
+        let index = SerializedDepNodeIndex::from_curr_for_serialization(index);
+
+        self.query_values_index.push((index, AbsoluteBytePos::new(self.position())));
+        self.encode_tagged(index, value);
+    }
+
+    fn encode_side_effect(&mut self, index: DepNodeIndex, side_effect: &QuerySideEffect) {
+        let index = SerializedDepNodeIndex::from_curr_for_serialization(index);
+
+        self.side_effects_index.push((index, AbsoluteBytePos::new(self.position())));
+        self.encode_tagged(index, side_effect);
+    }
+
     // copy&paste impl from rustc_metadata
     fn encode_symbol_or_byte_symbol(
         &mut self,
diff --git a/compiler/rustc_query_impl/Cargo.toml b/compiler/rustc_query_impl/Cargo.toml
index 1c3f0f98ae17..02d3b0110cb8 100644
--- a/compiler/rustc_query_impl/Cargo.toml
+++ b/compiler/rustc_query_impl/Cargo.toml
@@ -10,7 +10,6 @@ rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_hir = { path = "../rustc_hir" }
-rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_serialize = { path = "../rustc_serialize" }
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index b8aa125aaf96..75da964c66c9 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -2,18 +2,14 @@
 
 use rustc_data_structures::unord::UnordMap;
 use rustc_hir::limit::Limit;
-use rustc_index::Idx;
 use rustc_middle::bug;
 #[expect(unused_imports, reason = "used by doc comments")]
 use rustc_middle::dep_graph::DepKindVTable;
 use rustc_middle::dep_graph::{DepKind, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex};
 use rustc_middle::query::erase::{Erasable, Erased};
-use rustc_middle::query::on_disk_cache::{
-    AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
-};
+use rustc_middle::query::on_disk_cache::{CacheDecoder, CacheEncoder};
 use rustc_middle::query::{QueryCache, QueryJobId, QueryMode, QueryVTable, erase};
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::tls::{self, ImplicitCtxt};
 use rustc_serialize::{Decodable, Encodable};
 use rustc_span::DUMMY_SP;
@@ -79,13 +75,9 @@ pub(crate) fn start_query<R>(
     })
 }
 
-pub(crate) fn encode_query_values<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    encoder: &mut CacheEncoder<'_, 'tcx>,
-    query_result_index: &mut EncodedDepNodeIndex,
-) {
+pub(crate) fn encode_query_values<'tcx>(tcx: TyCtxt<'tcx>, encoder: &mut CacheEncoder<'_, 'tcx>) {
     for_each_query_vtable!(CACHE_ON_DISK, tcx, |query| {
-        encode_query_values_inner(tcx, query, encoder, query_result_index)
+        encode_query_values_inner(tcx, query, encoder)
     });
 }
 
@@ -93,7 +85,6 @@ fn encode_query_values_inner<'a, 'tcx, C, V>(
     tcx: TyCtxt<'tcx>,
     query: &'tcx QueryVTable<'tcx, C>,
     encoder: &mut CacheEncoder<'a, 'tcx>,
-    query_result_index: &mut EncodedDepNodeIndex,
 ) where
     C: QueryCache<Value = Erased<V>>,
     V: Erasable + Encodable<CacheEncoder<'a, 'tcx>>,
@@ -103,14 +94,7 @@ fn encode_query_values_inner<'a, 'tcx, C, V>(
     assert!(all_inactive(&query.state));
     query.cache.for_each(&mut |key, value, dep_node| {
         if (query.will_cache_on_disk_for_key_fn)(tcx, *key) {
-            let dep_node = SerializedDepNodeIndex::new(dep_node.index());
-
-            // Record position of the cache entry.
-            query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.position())));
-
-            // Encode the type check tables with the `SerializedDepNodeIndex`
-            // as tag.
-            encoder.encode_tagged(dep_node, &erase::restore_val::<V>(*value));
+            encoder.encode_query_value::<V>(dep_node, &erase::restore_val::<V>(*value));
         }
     });
 }
@@ -214,7 +198,7 @@ pub(crate) fn try_load_from_disk<'tcx, V>(
     // details.
     let value = tcx
         .dep_graph
-        .with_query_deserialization(|| on_disk_cache.try_load_query_result(tcx, prev_index));
+        .with_query_deserialization(|| on_disk_cache.try_load_query_value(tcx, prev_index));
 
     prof_timer.finish_with_query_invocation_id(index.into());
 

From afffa7d6e3f969a58157e86732a25fe0bf8dc19c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 17 Mar 2026 15:27:00 +1100
Subject: [PATCH 0857/1059] Don't store current-session side effects in
 `OnDiskCache`

Every other part of `OnDiskCache` deals with loading information from the
_previous_ session, except for this one field.

Moving it out to `QuerySystem` makes more sense, because that's also where
query return values are stored (inside the caches in their vtables).
---
 .../rustc_incremental/src/persist/save.rs     |  3 ++-
 compiler/rustc_middle/src/dep_graph/graph.rs  | 12 ++--------
 .../rustc_middle/src/query/on_disk_cache.rs   | 23 ++++---------------
 compiler/rustc_middle/src/query/plumbing.rs   | 12 ++++++++--
 compiler/rustc_query_impl/src/lib.rs          |  1 +
 5 files changed, 20 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_incremental/src/persist/save.rs b/compiler/rustc_incremental/src/persist/save.rs
index 1de64bb6734d..dc14a8c5e2ec 100644
--- a/compiler/rustc_incremental/src/persist/save.rs
+++ b/compiler/rustc_incremental/src/persist/save.rs
@@ -6,6 +6,7 @@
 use rustc_middle::dep_graph::{
     DepGraph, SerializedDepGraph, WorkProduct, WorkProductId, WorkProductMap,
 };
+use rustc_middle::query::on_disk_cache;
 use rustc_middle::ty::TyCtxt;
 use rustc_serialize::Encodable as RustcEncodable;
 use rustc_serialize::opaque::FileEncoder;
@@ -82,7 +83,7 @@ pub(crate) fn save_dep_graph(tcx: TyCtxt<'_>) {
 
                     file_format::save_in(sess, query_cache_path, "query cache", |encoder| {
                         tcx.sess.time("incr_comp_serialize_result_cache", || {
-                            on_disk_cache.serialize(tcx, encoder)
+                            on_disk_cache::OnDiskCache::serialize(tcx, encoder)
                         })
                     });
                 });
diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index 0f50abb827de..fac79742657d 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -709,7 +709,7 @@ fn encode_side_effect<'tcx>(
             // side effect.
             std::iter::once(DepNodeIndex::FOREVER_RED_NODE).collect(),
         );
-        tcx.store_side_effect(dep_node_index, side_effect);
+        tcx.query_system.side_effects.borrow_mut().insert(dep_node_index, side_effect);
         dep_node_index
     }
 
@@ -745,7 +745,7 @@ fn force_side_effect<'tcx>(&self, tcx: TyCtxt<'tcx>, prev_index: SerializedDepNo
             }
 
             // This will just overwrite the same value for concurrent calls.
-            tcx.store_side_effect(dep_node_index, side_effect);
+            tcx.query_system.side_effects.borrow_mut().insert(dep_node_index, side_effect);
         })
     }
 
@@ -1560,12 +1560,4 @@ fn load_side_effect(
             .as_ref()
             .and_then(|c| c.load_side_effect(self, prev_dep_node_index))
     }
-
-    #[inline(never)]
-    #[cold]
-    fn store_side_effect(self, dep_node_index: DepNodeIndex, side_effect: QuerySideEffect) {
-        if let Some(c) = self.query_system.on_disk_cache.as_ref() {
-            c.store_side_effect(dep_node_index, side_effect)
-        }
-    }
 }
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index b6409c1ea171..9f7c5e1e7172 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -2,7 +2,7 @@
 use std::sync::Arc;
 use std::{fmt, mem};
 
-use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::sync::{HashMapExt, Lock, RwLock};
 use rustc_data_structures::unhash::UnhashMap;
@@ -53,10 +53,6 @@ pub struct OnDiskCache {
     // The complete cache data in serialized form.
     serialized_data: RwLock<Option<Mmap>>,
 
-    // Collects all `QuerySideEffect` created during the current compilation
-    // session.
-    current_side_effects: Lock<FxIndexMap<DepNodeIndex, QuerySideEffect>>,
-
     file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>,
 
     // Caches that are populated lazily during decoding.
@@ -172,7 +168,6 @@ pub fn new(sess: &Session, data: Mmap, start_pos: usize) -> Result<Self, ()> {
             serialized_data: RwLock::new(Some(data)),
             file_index_to_stable_id: footer.file_index_to_stable_id,
             file_index_to_file: Default::default(),
-            current_side_effects: Default::default(),
             query_values_index: footer.query_values_index.into_iter().collect(),
             side_effects_index: footer.side_effects_index.into_iter().collect(),
             alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
@@ -188,7 +183,6 @@ pub fn new_empty() -> Self {
             serialized_data: RwLock::new(None),
             file_index_to_stable_id: Default::default(),
             file_index_to_file: Default::default(),
-            current_side_effects: Default::default(),
             query_values_index: Default::default(),
             side_effects_index: Default::default(),
             alloc_decoding_state: AllocDecodingState::new(Vec::new()),
@@ -205,7 +199,9 @@ pub fn close_serialized_data_mmap(&self) {
         *self.serialized_data.write() = None;
     }
 
-    pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResult {
+    /// Serialize the current-session data that will be loaded by [`OnDiskCache`]
+    /// in a subsequent incremental compilation session.
+    pub fn serialize(tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResult {
         // Serializing the `DepGraph` should not modify it.
         tcx.dep_graph.with_ignore(|| {
             // Allocate `SourceFileIndex`es.
@@ -249,7 +245,7 @@ pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResu
             });
 
             // Encode side effects.
-            for (&dep_node_index, side_effect) in self.current_side_effects.borrow().iter() {
+            for (&dep_node_index, side_effect) in tcx.query_system.side_effects.borrow().iter() {
                 encoder.encode_side_effect(dep_node_index, side_effect);
             }
 
@@ -339,15 +335,6 @@ pub fn load_side_effect(
         side_effect
     }
 
-    /// Stores a `QuerySideEffect` emitted during the current compilation session.
-    /// Anything stored like this will be available via `load_side_effect` in
-    /// the next compilation session.
-    pub fn store_side_effect(&self, dep_node_index: DepNodeIndex, side_effect: QuerySideEffect) {
-        let mut current_side_effects = self.current_side_effects.borrow_mut();
-        let prev = current_side_effects.insert(dep_node_index, side_effect);
-        debug_assert!(prev.is_none());
-    }
-
     /// Returns true if there is a disk-cached query return value for the given node.
     #[inline]
     pub fn loadable_from_disk(&self, dep_node_index: SerializedDepNodeIndex) -> bool {
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 7d94d60523fb..0977e56fce70 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -2,13 +2,14 @@
 use std::ops::Deref;
 
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::hash_table::HashTable;
 use rustc_data_structures::sharded::Sharded;
-use rustc_data_structures::sync::{AtomicU64, WorkerLocal};
+use rustc_data_structures::sync::{AtomicU64, Lock, WorkerLocal};
 use rustc_errors::Diag;
 use rustc_span::Span;
 
-use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
+use crate::dep_graph::{DepKind, DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
@@ -151,6 +152,13 @@ pub struct QuerySystem<'tcx> {
     pub arenas: WorkerLocal<QueryArenas<'tcx>>,
     pub query_vtables: QueryVTables<'tcx>,
 
+    /// Side-effect associated with each [`DepKind::SideEffect`] node in the
+    /// current incremental-compilation session. Side effects will be written
+    /// to disk, and loaded by [`OnDiskCache`] in the next session.
+    ///
+    /// Always empty if incremental compilation is off.
+    pub side_effects: Lock<FxIndexMap<DepNodeIndex, QuerySideEffect>>,
+
     /// This provides access to the incremental compilation on-disk cache for query results.
     /// Do not access this directly. It is only meant to be used by
     /// `DepGraph::try_mark_green()` and the query infrastructure.
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 2f69082db66e..3a77d83cfd3e 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -53,6 +53,7 @@ pub fn query_system<'tcx>(
     QuerySystem {
         arenas: Default::default(),
         query_vtables,
+        side_effects: Default::default(),
         on_disk_cache,
         local_providers,
         extern_providers,

From db19c0c3ee2584ba8ac353862ab204b0b066ece2 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:59:45 +1100
Subject: [PATCH 0858/1059] Inline `TyCtxt::load_side_effect` into its only
 caller

---
 compiler/rustc_middle/src/dep_graph/graph.rs  | 19 +++++++------------
 .../rustc_middle/src/query/on_disk_cache.rs   |  2 +-
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index fac79742657d..444d02521148 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -718,7 +718,13 @@ fn encode_side_effect<'tcx>(
     #[inline]
     fn force_side_effect<'tcx>(&self, tcx: TyCtxt<'tcx>, prev_index: SerializedDepNodeIndex) {
         with_deps(TaskDepsRef::Ignore, || {
-            let side_effect = tcx.load_side_effect(prev_index).unwrap();
+            let side_effect = tcx
+                .query_system
+                .on_disk_cache
+                .as_ref()
+                .unwrap()
+                .load_side_effect(tcx, prev_index)
+                .unwrap();
 
             // Use `send_and_color` as `promote_node_and_deps_to_current` expects all
             // green dependencies. `send_and_color` will also prevent multiple nodes
@@ -1549,15 +1555,4 @@ impl<'tcx> TyCtxt<'tcx> {
     fn is_eval_always(self, kind: DepKind) -> bool {
         self.dep_kind_vtable(kind).is_eval_always
     }
-
-    // Interactions with on_disk_cache
-    fn load_side_effect(
-        self,
-        prev_dep_node_index: SerializedDepNodeIndex,
-    ) -> Option<QuerySideEffect> {
-        self.query_system
-            .on_disk_cache
-            .as_ref()
-            .and_then(|c| c.load_side_effect(self, prev_dep_node_index))
-    }
 }
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 9f7c5e1e7172..466142ad6d59 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -325,7 +325,7 @@ pub fn serialize(tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResult {
     }
 
     /// Loads a `QuerySideEffect` created during the previous compilation session.
-    pub fn load_side_effect(
+    pub(crate) fn load_side_effect(
         &self,
         tcx: TyCtxt<'_>,
         dep_node_index: SerializedDepNodeIndex,

From ee151548176c71e29424de3cc3aec5f864968ef2 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 23 Mar 2026 21:38:52 +1100
Subject: [PATCH 0859/1059] Remove an unhelpful assertion from
 `try_load_query_value`

This assertion makes the method body a lot messier, and seems very unlikely to
ever usefully fail.
---
 compiler/rustc_middle/src/query/on_disk_cache.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 466142ad6d59..b6fd30647f85 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -351,9 +351,7 @@ pub fn try_load_query_value<'tcx, T>(
     where
         T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
     {
-        let opt_value = self.load_indexed(tcx, dep_node_index, &self.query_values_index);
-        debug_assert_eq!(opt_value.is_some(), self.loadable_from_disk(dep_node_index));
-        opt_value
+        self.load_indexed(tcx, dep_node_index, &self.query_values_index)
     }
 
     fn load_indexed<'tcx, T>(

From 3df450f5aeb6d5244ed658a6aa8f679019045b8c Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Mon, 23 Mar 2026 22:05:53 -0400
Subject: [PATCH 0860/1059] Cherry-pick 1.94.1 release notes

This also fixes the Cargo rendering bug noted in the pre-release thread.
---
 RELEASES.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/RELEASES.md b/RELEASES.md
index f180d740a3d1..c396cd8069d6 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3 +1,17 @@
+Version 1.94.1 (2026-03-26)
+===========================
+
+<a id="1.94.1"></a>
+
+* [Fix `std::thread::spawn` on wasm32-wasip1-threads](https://github.com/rust-lang/rust/pull/153634)
+* [Remove new methods added to `std::os::windows::fs::OpenOptionsExt`](https://github.com/rust-lang/rust/pull/153491)
+  The new methods were unstable, but the trait itself is not sealed and so
+  cannot be extended with non-default methods.
+* [Clippy: fix ICE in `match_same_arms`](https://github.com/rust-lang/rust-clippy/pull/16685)
+* [Cargo: update tar to 0.4.45](https://github.com/rust-lang/cargo/pull/16769)
+  This resolves CVE-2026-33055 and CVE-2026-33056. Users of crates.io are not affected.
+  See [blog](https://blog.rust-lang.org/2026/03/21/cve-2026-33056/) for more details.
+
 Version 1.94.0 (2026-03-05)
 ==========================
 

From af6324a90f502d18cebcf5d10fe90ae613007a42 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Mon, 23 Mar 2026 22:25:09 -0400
Subject: [PATCH 0861/1059] Fix typo in doc comment for `char::to_titlecase`

---
 library/core/src/char/methods.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index e9c3b040dc50..46d48afbf5a1 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -1212,7 +1212,7 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// returned by [`Self::to_uppercase`]. Prefer this method when seeking to capitalize
     /// Only The First Letter of a word, but use [`Self::to_uppercase`] for ALL CAPS.
     ///
-    /// If this `char` does not have an titlecase mapping, the iterator yields the same `char`.
+    /// If this `char` does not have a titlecase mapping, the iterator yields the same `char`.
     ///
     /// If this `char` has a one-to-one titlecase mapping given by the [Unicode Character
     /// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`.

From ed4a1f8b807b1150af97362f834b5ee918c39381 Mon Sep 17 00:00:00 2001
From: Usman Akinyemi <usmanakinyemi202@gmail.com>
Date: Mon, 16 Feb 2026 01:43:17 +0530
Subject: [PATCH 0862/1059] rustc_expand: improve diagnostics for
 non-repeatable metavars
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Esteban Küber <esteban@kuber.com.ar>
Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>
---
 compiler/rustc_expand/src/base.rs             | 11 +--
 compiler/rustc_expand/src/expand.rs           |  4 +-
 compiler/rustc_expand/src/mbe/diagnostics.rs  | 67 ++++++++++++++++++-
 compiler/rustc_expand/src/mbe/macro_rules.rs  | 43 ++++++++----
 tests/ui/macros/issue-6596-1.stderr           |  6 +-
 tests/ui/macros/typo-in-norepeat-expr-2.rs    | 42 ++++++++++++
 .../ui/macros/typo-in-norepeat-expr-2.stderr  | 46 +++++++++++++
 tests/ui/macros/typo-in-norepeat-expr.fixed   | 12 ++++
 tests/ui/macros/typo-in-norepeat-expr.rs      | 12 ++++
 tests/ui/macros/typo-in-norepeat-expr.stderr  | 18 +++++
 10 files changed, 240 insertions(+), 21 deletions(-)
 create mode 100644 tests/ui/macros/typo-in-norepeat-expr-2.rs
 create mode 100644 tests/ui/macros/typo-in-norepeat-expr-2.stderr
 create mode 100644 tests/ui/macros/typo-in-norepeat-expr.fixed
 create mode 100644 tests/ui/macros/typo-in-norepeat-expr.rs
 create mode 100644 tests/ui/macros/typo-in-norepeat-expr.stderr

diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 225906dfba2d..b4dbdc93d3e3 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -277,7 +277,8 @@ pub fn from_tts(
         // Emit the SEMICOLON_IN_EXPRESSIONS_FROM_MACROS deprecation lint.
         let is_local = true;
 
-        let parser = ParserAnyMacro::from_tts(cx, tts, site_span, arm_span, is_local, macro_ident);
+        let parser =
+            ParserAnyMacro::from_tts(cx, tts, site_span, arm_span, is_local, macro_ident, &[], &[]);
         ExpandResult::Ready(Box::new(parser))
     }
 }
@@ -377,8 +378,8 @@ fn expand<'cx>(
 
 /// Represents a thing that maps token trees to Macro Results
 pub trait TTMacroExpander: Any {
-    fn expand<'cx>(
-        &self,
+    fn expand<'cx, 'a: 'cx>(
+        &'a self,
         ecx: &'cx mut ExtCtxt<'_>,
         span: Span,
         input: TokenStream,
@@ -394,8 +395,8 @@ impl<F: 'static> TTMacroExpander for F
 where
     F: for<'cx> Fn(&'cx mut ExtCtxt<'_>, Span, TokenStream) -> MacroExpanderResult<'cx>,
 {
-    fn expand<'cx>(
-        &self,
+    fn expand<'cx, 'a: 'cx>(
+        &'a self,
         ecx: &'cx mut ExtCtxt<'_>,
         span: Span,
         input: TokenStream,
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 76a9a6f9d03d..6c3cd675d054 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -182,8 +182,8 @@ pub(crate) fn to_string(&self) -> String {
             }
         }
 
-        impl<'a> MacResult for crate::mbe::macro_rules::ParserAnyMacro<'a> {
-            $(fn $make_ast(self: Box<crate::mbe::macro_rules::ParserAnyMacro<'a>>)
+        impl<'a, 'b> MacResult for crate::mbe::macro_rules::ParserAnyMacro<'a, 'b> {
+            $(fn $make_ast(self: Box<crate::mbe::macro_rules::ParserAnyMacro<'a, 'b>>)
                            -> Option<$AstTy> {
                 Some(self.make(AstFragmentKind::$Kind).$make_ast())
             })*
diff --git a/compiler/rustc_expand/src/mbe/diagnostics.rs b/compiler/rustc_expand/src/mbe/diagnostics.rs
index df6903dc4937..fd2e4e3ec39f 100644
--- a/compiler/rustc_expand/src/mbe/diagnostics.rs
+++ b/compiler/rustc_expand/src/mbe/diagnostics.rs
@@ -222,11 +222,13 @@ fn new(dcx: DiagCtxtHandle<'dcx>, root_span: Span) -> Self {
 
 pub(super) fn emit_frag_parse_err(
     mut e: Diag<'_>,
-    parser: &Parser<'_>,
+    parser: &mut Parser<'_>,
     orig_parser: &mut Parser<'_>,
     site_span: Span,
     arm_span: Span,
     kind: AstFragmentKind,
+    bindings: &[MacroRule],
+    matched_rule_bindings: &[MatcherLoc],
 ) -> ErrorGuaranteed {
     // FIXME(davidtwco): avoid depending on the error message text
     if parser.token == token::Eof
@@ -285,6 +287,69 @@ pub(super) fn emit_frag_parse_err(
         },
         _ => annotate_err_with_kind(&mut e, kind, site_span),
     };
+
+    let mut bindings_rules = vec![];
+    for rule in bindings {
+        let MacroRule::Func { lhs, .. } = rule else { continue };
+        for param in lhs {
+            let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
+            bindings_rules.push(*bind);
+        }
+    }
+
+    let mut matched_rule_bindings_rules = vec![];
+    for param in matched_rule_bindings {
+        let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
+        matched_rule_bindings_rules.push(*bind);
+    }
+
+    let matched_rule_bindings_names: Vec<_> =
+        matched_rule_bindings_rules.iter().map(|bind| bind.name).collect();
+    let bindings_name: Vec<_> = bindings_rules.iter().map(|bind| bind.name).collect();
+    if parser.token.kind == token::Dollar {
+        parser.bump();
+        if let token::Ident(name, _) = parser.token.kind {
+            if let Some(matched_name) = rustc_span::edit_distance::find_best_match_for_name(
+                &matched_rule_bindings_names[..],
+                name,
+                None,
+            ) {
+                e.span_suggestion_verbose(
+                    parser.token.span,
+                    "there is a macro metavariable with similar name",
+                    format!("{matched_name}"),
+                    Applicability::MaybeIncorrect,
+                );
+            } else if bindings_name.contains(&name) {
+                e.span_label(
+                    parser.token.span,
+                    format!(
+                        "there is an macro metavariable with this name in another macro matcher"
+                    ),
+                );
+            } else if let Some(matched_name) =
+                rustc_span::edit_distance::find_best_match_for_name(&bindings_name[..], name, None)
+            {
+                e.span_suggestion_verbose(
+                    parser.token.span,
+                    "there is a macro metavariable with a similar name in another macro matcher",
+                    format!("{matched_name}"),
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                let msg = matched_rule_bindings_names
+                    .iter()
+                    .map(|sym| format!("${}", sym))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                e.span_label(parser.token.span, format!("macro metavariable not found"));
+                if !matched_rule_bindings_names.is_empty() {
+                    e.note(format!("available metavariable names are: {msg}"));
+                }
+            }
+        }
+    }
     e.emit()
 }
 
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 7ff49e040f6f..154610b6d9b6 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -43,7 +43,7 @@
 use crate::mbe::transcribe::transcribe;
 use crate::mbe::{self, KleeneOp};
 
-pub(crate) struct ParserAnyMacro<'a> {
+pub(crate) struct ParserAnyMacro<'a, 'b> {
     parser: Parser<'a>,
 
     /// Span of the expansion site of the macro this parser is for
@@ -55,10 +55,15 @@ pub(crate) struct ParserAnyMacro<'a> {
     arm_span: Span,
     /// Whether or not this macro is defined in the current crate
     is_local: bool,
+    bindings: &'b [MacroRule],
+    matched_rule_bindings: &'b [MatcherLoc],
 }
 
-impl<'a> ParserAnyMacro<'a> {
-    pub(crate) fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
+impl<'a, 'b> ParserAnyMacro<'a, 'b> {
+    pub(crate) fn make(
+        mut self: Box<ParserAnyMacro<'a, 'b>>,
+        kind: AstFragmentKind,
+    ) -> AstFragment {
         let ParserAnyMacro {
             site_span,
             macro_ident,
@@ -67,13 +72,22 @@ pub(crate) fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) ->
             arm_span,
             is_trailing_mac,
             is_local,
+            bindings,
+            matched_rule_bindings,
         } = *self;
         let snapshot = &mut parser.create_snapshot_for_diagnostic();
         let fragment = match parse_ast_fragment(parser, kind) {
             Ok(f) => f,
             Err(err) => {
                 let guar = diagnostics::emit_frag_parse_err(
-                    err, parser, snapshot, site_span, arm_span, kind,
+                    err,
+                    parser,
+                    snapshot,
+                    site_span,
+                    arm_span,
+                    kind,
+                    bindings,
+                    matched_rule_bindings,
                 );
                 return kind.dummy(site_span, guar);
             }
@@ -100,7 +114,7 @@ pub(crate) fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) ->
         fragment
     }
 
-    #[instrument(skip(cx, tts))]
+    #[instrument(skip(cx, tts, bindings, matched_rule_bindings))]
     pub(crate) fn from_tts<'cx>(
         cx: &'cx mut ExtCtxt<'a>,
         tts: TokenStream,
@@ -108,6 +122,9 @@ pub(crate) fn from_tts<'cx>(
         arm_span: Span,
         is_local: bool,
         macro_ident: Ident,
+        // bindings and lhs is for diagnostics
+        bindings: &'b [MacroRule],
+        matched_rule_bindings: &'b [MatcherLoc],
     ) -> Self {
         Self {
             parser: Parser::new(&cx.sess.psess, tts, None),
@@ -121,11 +138,13 @@ pub(crate) fn from_tts<'cx>(
             is_trailing_mac: cx.current_expansion.is_trailing_mac,
             arm_span,
             is_local,
+            bindings,
+            matched_rule_bindings,
         }
     }
 }
 
-pub(super) enum MacroRule {
+pub(crate) enum MacroRule {
     /// A function-style rule, for use with `m!()`
     Func { lhs: Vec<MatcherLoc>, lhs_span: Span, rhs: mbe::TokenTree },
     /// An attr rule, for use with `#[m]`
@@ -226,8 +245,8 @@ pub fn expand_derive(
 }
 
 impl TTMacroExpander for MacroRulesMacroExpander {
-    fn expand<'cx>(
-        &self,
+    fn expand<'cx, 'a: 'cx>(
+        &'a self,
         cx: &'cx mut ExtCtxt<'_>,
         sp: Span,
         input: TokenStream,
@@ -337,7 +356,7 @@ fn description() -> &'static str {
 
 /// Expands the rules based macro defined by `rules` for a given input `arg`.
 #[instrument(skip(cx, transparency, arg, rules))]
-fn expand_macro<'cx>(
+fn expand_macro<'cx, 'a: 'cx>(
     cx: &'cx mut ExtCtxt<'_>,
     sp: Span,
     def_span: Span,
@@ -345,7 +364,7 @@ fn expand_macro<'cx>(
     name: Ident,
     transparency: Transparency,
     arg: TokenStream,
-    rules: &[MacroRule],
+    rules: &'a [MacroRule],
 ) -> Box<dyn MacResult + 'cx> {
     let psess = &cx.sess.psess;
 
@@ -359,7 +378,7 @@ fn expand_macro<'cx>(
 
     match try_success_result {
         Ok((rule_index, rule, named_matches)) => {
-            let MacroRule::Func { rhs, .. } = rule else {
+            let MacroRule::Func { lhs, rhs, .. } = rule else {
                 panic!("try_match_macro returned non-func rule");
             };
             let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
@@ -388,7 +407,7 @@ fn expand_macro<'cx>(
             }
 
             // Let the context choose how to interpret the result. Weird, but useful for X-macros.
-            Box::new(ParserAnyMacro::from_tts(cx, tts, sp, arm_span, is_local, name))
+            Box::new(ParserAnyMacro::from_tts(cx, tts, sp, arm_span, is_local, name, rules, lhs))
         }
         Err(CanRetry::No(guar)) => {
             debug!("Will not retry matching as an error was emitted already");
diff --git a/tests/ui/macros/issue-6596-1.stderr b/tests/ui/macros/issue-6596-1.stderr
index f20d67329dbe..cb66dcc6ea89 100644
--- a/tests/ui/macros/issue-6596-1.stderr
+++ b/tests/ui/macros/issue-6596-1.stderr
@@ -2,11 +2,15 @@ error: expected expression, found `$`
   --> $DIR/issue-6596-1.rs:3:9
    |
 LL |         $nonexistent
-   |         ^^^^^^^^^^^^ expected expression
+   |         ^-----------
+   |         ||
+   |         |macro metavariable not found
+   |         expected expression
 ...
 LL |     e!(foo);
    |     ------- in this macro invocation
    |
+   = note: available metavariable names are: $inp
    = note: this error originates in the macro `e` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/macros/typo-in-norepeat-expr-2.rs b/tests/ui/macros/typo-in-norepeat-expr-2.rs
new file mode 100644
index 000000000000..48b64c248d63
--- /dev/null
+++ b/tests/ui/macros/typo-in-norepeat-expr-2.rs
@@ -0,0 +1,42 @@
+macro_rules! err {
+    (begin $follow:ident end $arg:expr) => {
+        [$arg]
+    };
+    (begin1 $arg1:ident end $agr2:expr) => {
+        [$follow] //~ ERROR: expected expression, found `$`
+        //~^ NOTE: there is an macro metavariable with this name in another macro matcher
+        //~| NOTE: expected expression
+    };
+}
+
+macro_rules! err1 {
+    (begin $follow:ident end $arg:expr) => {
+        [$arg]
+    };
+    (begin1 $arg1:ident end) => {
+        [$follo] //~ ERROR: expected expression, found `$`
+        //~| NOTE: expected expression
+        //~| HELP: there is a macro metavariable with a similar name in another macro matcher
+    };
+}
+
+macro_rules! err2 {
+    (begin $follow:ident end $arg:expr) => {
+        [$arg]
+    };
+    (begin1 $arg1:ident end) => {
+        [$xyz] //~ ERROR: expected expression, found `$`
+        //~^ NOTE: expected expression
+        //~| NOTE available metavariable names are: $arg1
+        //~| NOTE: macro metavariable not found
+    };
+}
+
+fn main () {
+    let _ = err![begin1 x  end ig]; //~ NOTE: in this expansion of err!
+    let _ = err1![begin1 x  end]; //~ NOTE: in this expansion of err1!
+            //~| NOTE: in this expansion of err1!
+
+    let _ = err2![begin1 x  end]; //~ NOTE: in this expansion of err2!
+            //~| NOTE in this expansion of err2!
+}
diff --git a/tests/ui/macros/typo-in-norepeat-expr-2.stderr b/tests/ui/macros/typo-in-norepeat-expr-2.stderr
new file mode 100644
index 000000000000..20390cccc9a7
--- /dev/null
+++ b/tests/ui/macros/typo-in-norepeat-expr-2.stderr
@@ -0,0 +1,46 @@
+error: expected expression, found `$`
+  --> $DIR/typo-in-norepeat-expr-2.rs:6:10
+   |
+LL |         [$follow]
+   |          ^------
+   |          ||
+   |          |there is an macro metavariable with this name in another macro matcher
+   |          expected expression
+...
+LL |     let _ = err![begin1 x  end ig];
+   |             ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `err` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected expression, found `$`
+  --> $DIR/typo-in-norepeat-expr-2.rs:17:10
+   |
+LL |         [$follo]
+   |          ^^^^^^ expected expression
+...
+LL |     let _ = err1![begin1 x  end];
+   |             -------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `err1` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: there is a macro metavariable with a similar name in another macro matcher
+   |
+LL |         [$follow]
+   |                +
+
+error: expected expression, found `$`
+  --> $DIR/typo-in-norepeat-expr-2.rs:28:10
+   |
+LL |         [$xyz]
+   |          ^---
+   |          ||
+   |          |macro metavariable not found
+   |          expected expression
+...
+LL |     let _ = err2![begin1 x  end];
+   |             -------------------- in this macro invocation
+   |
+   = note: available metavariable names are: $arg1
+   = note: this error originates in the macro `err2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/macros/typo-in-norepeat-expr.fixed b/tests/ui/macros/typo-in-norepeat-expr.fixed
new file mode 100644
index 000000000000..a59f461e6312
--- /dev/null
+++ b/tests/ui/macros/typo-in-norepeat-expr.fixed
@@ -0,0 +1,12 @@
+//@ run-rustfix
+macro_rules! m {
+    (begin $ard:ident end) => {
+        [$ard] //~ ERROR: expected expression, found `$`
+        //~^ HELP: there is a macro metavariable with similar name
+    };
+}
+
+fn main() {
+    let x = 1;
+    let _ = m![begin x end];
+}
diff --git a/tests/ui/macros/typo-in-norepeat-expr.rs b/tests/ui/macros/typo-in-norepeat-expr.rs
new file mode 100644
index 000000000000..fe554f07e755
--- /dev/null
+++ b/tests/ui/macros/typo-in-norepeat-expr.rs
@@ -0,0 +1,12 @@
+//@ run-rustfix
+macro_rules! m {
+    (begin $ard:ident end) => {
+        [$arg] //~ ERROR: expected expression, found `$`
+        //~^ HELP: there is a macro metavariable with similar name
+    };
+}
+
+fn main() {
+    let x = 1;
+    let _ = m![begin x end];
+}
diff --git a/tests/ui/macros/typo-in-norepeat-expr.stderr b/tests/ui/macros/typo-in-norepeat-expr.stderr
new file mode 100644
index 000000000000..8f37957ea98e
--- /dev/null
+++ b/tests/ui/macros/typo-in-norepeat-expr.stderr
@@ -0,0 +1,18 @@
+error: expected expression, found `$`
+  --> $DIR/typo-in-norepeat-expr.rs:4:10
+   |
+LL |         [$arg]
+   |          ^^^^ expected expression
+...
+LL |     let _ = m![begin x end];
+   |             --------------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: there is a macro metavariable with similar name
+   |
+LL -         [$arg]
+LL +         [$ard]
+   |
+
+error: aborting due to 1 previous error
+

From fd3b22a836fe86934af8d077403d16779e321af7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 4 Mar 2026 14:06:10 +1100
Subject: [PATCH 0863/1059] Use a safe `BucketIndex` abstraction in `VecCache`

The current code for indexing into bucket arrays is quite tricky and unsafe,
partly because it has to keep manually assuring the compiler that a bucket
index is always less than 21.

By encapsulating that knowledge in a 21-value enum, we can make the code
clearer and safer, without giving up performance.

Having a dedicated `BucketIndex` type could also help with further cleanups of
`VecCache` indexing.
---
 .../rustc_data_structures/src/vec_cache.rs    | 231 ++++++++++++++----
 .../src/vec_cache/tests.rs                    |  52 +++-
 2 files changed, 227 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_data_structures/src/vec_cache.rs b/compiler/rustc_data_structures/src/vec_cache.rs
index aea5924b8802..6d026bb2c7f7 100644
--- a/compiler/rustc_data_structures/src/vec_cache.rs
+++ b/compiler/rustc_data_structures/src/vec_cache.rs
@@ -6,12 +6,16 @@
 //!
 //! This is currently used for query caching.
 
-use std::fmt::Debug;
+use std::fmt::{self, Debug};
 use std::marker::PhantomData;
+use std::ops::{Index, IndexMut};
 use std::sync::atomic::{AtomicPtr, AtomicU32, AtomicUsize, Ordering};
 
 use rustc_index::Idx;
 
+#[cfg(test)]
+mod tests;
+
 struct Slot<V> {
     // We never construct &Slot<V> so it's fine for this to not be in an UnsafeCell.
     value: V,
@@ -28,7 +32,7 @@ struct Slot<V> {
 #[derive(Copy, Clone, Debug)]
 struct SlotIndex {
     // the index of the bucket in VecCache (0 to 20)
-    bucket_idx: usize,
+    bucket_idx: BucketIndex,
     // the index of the slot within the bucket
     index_in_bucket: usize,
 }
@@ -42,7 +46,7 @@ struct SlotIndex {
     let mut key = 0;
     loop {
         let si = SlotIndex::from_index(key);
-        entries[si.bucket_idx] = si.entries();
+        entries[si.bucket_idx.to_usize()] = si.bucket_idx.capacity();
         if key == 0 {
             key = 1;
         } else if key == (1 << 31) {
@@ -57,48 +61,24 @@ struct SlotIndex {
 const BUCKETS: usize = 21;
 
 impl SlotIndex {
-    /// The total possible number of entries in the bucket
-    const fn entries(&self) -> usize {
-        if self.bucket_idx == 0 { 1 << 12 } else { 1 << (self.bucket_idx + 11) }
-    }
-
-    // This unpacks a flat u32 index into identifying which bucket it belongs to and the offset
-    // within that bucket. As noted in the VecCache docs, buckets double in size with each index.
-    // Typically that would mean 31 buckets (2^0 + 2^1 ... + 2^31 = u32::MAX - 1), but to reduce
-    // the size of the VecCache struct and avoid uselessly small allocations, we instead have the
-    // first bucket have 2**12 entries. To simplify the math, the second bucket also 2**12 entries,
-    // and buckets double from there.
-    //
-    // We assert that [0, 2**32 - 1] uniquely map through this function to individual, consecutive
-    // slots (see `slot_index_exhaustive` in tests).
+    /// Unpacks a flat 32-bit index into a [`BucketIndex`] and a slot offset within that bucket.
     #[inline]
     const fn from_index(idx: u32) -> Self {
-        const FIRST_BUCKET_SHIFT: usize = 12;
-        if idx < (1 << FIRST_BUCKET_SHIFT) {
-            return SlotIndex { bucket_idx: 0, index_in_bucket: idx as usize };
-        }
-        // We already ruled out idx 0, so this `ilog2` never panics (and the check optimizes away)
-        let bucket = idx.ilog2() as usize;
-        let entries = 1 << bucket;
-        SlotIndex {
-            bucket_idx: bucket - FIRST_BUCKET_SHIFT + 1,
-            index_in_bucket: idx as usize - entries,
-        }
+        let (bucket_idx, index_in_bucket) = BucketIndex::from_flat_index(idx as usize);
+        SlotIndex { bucket_idx, index_in_bucket }
     }
 
     // SAFETY: Buckets must be managed solely by functions here (i.e., get/put on SlotIndex) and
     // `self` comes from SlotIndex::from_index
     #[inline]
     unsafe fn get<V: Copy>(&self, buckets: &[AtomicPtr<Slot<V>>; 21]) -> Option<(V, u32)> {
-        // SAFETY: `bucket_idx` is ilog2(u32).saturating_sub(11), which is at most 21, i.e.,
-        // in-bounds of buckets. See `from_index` for computation.
-        let bucket = unsafe { buckets.get_unchecked(self.bucket_idx) };
+        let bucket = &buckets[self.bucket_idx];
         let ptr = bucket.load(Ordering::Acquire);
         // Bucket is not yet initialized: then we obviously won't find this entry in that bucket.
         if ptr.is_null() {
             return None;
         }
-        debug_assert!(self.index_in_bucket < self.entries());
+        debug_assert!(self.index_in_bucket < self.bucket_idx.capacity());
         // SAFETY: `bucket` was allocated (so <= isize in total bytes) to hold `entries`, so this
         // must be inbounds.
         let slot = unsafe { ptr.add(self.index_in_bucket) };
@@ -131,7 +111,7 @@ fn bucket_ptr<V>(&self, bucket: &AtomicPtr<Slot<V>>) -> *mut Slot<V> {
 
     #[cold]
     #[inline(never)]
-    fn initialize_bucket<V>(bucket: &AtomicPtr<Slot<V>>, bucket_idx: usize) -> *mut Slot<V> {
+    fn initialize_bucket<V>(bucket: &AtomicPtr<Slot<V>>, bucket_idx: BucketIndex) -> *mut Slot<V> {
         static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
         // If we are initializing the bucket, then acquire a global lock.
@@ -145,8 +125,8 @@ fn initialize_bucket<V>(bucket: &AtomicPtr<Slot<V>>, bucket_idx: usize) -> *mut
         // OK, now under the allocator lock, if we're still null then it's definitely us that will
         // initialize this bucket.
         if ptr.is_null() {
-            let bucket_len = SlotIndex { bucket_idx, index_in_bucket: 0 }.entries();
-            let bucket_layout = std::alloc::Layout::array::<Slot<V>>(bucket_len).unwrap();
+            let bucket_layout =
+                std::alloc::Layout::array::<Slot<V>>(bucket_idx.capacity()).unwrap();
             // This is more of a sanity check -- this code is very cold, so it's safe to pay a
             // little extra cost here.
             assert!(bucket_layout.size() > 0);
@@ -167,12 +147,10 @@ fn initialize_bucket<V>(bucket: &AtomicPtr<Slot<V>>, bucket_idx: usize) -> *mut
     /// Returns true if this successfully put into the map.
     #[inline]
     fn put<V>(&self, buckets: &[AtomicPtr<Slot<V>>; 21], value: V, extra: u32) -> bool {
-        // SAFETY: `bucket_idx` is ilog2(u32).saturating_sub(11), which is at most 21, i.e.,
-        // in-bounds of buckets.
-        let bucket = unsafe { buckets.get_unchecked(self.bucket_idx) };
+        let bucket = &buckets[self.bucket_idx];
         let ptr = self.bucket_ptr(bucket);
 
-        debug_assert!(self.index_in_bucket < self.entries());
+        debug_assert!(self.index_in_bucket < self.bucket_idx.capacity());
         // SAFETY: `bucket` was allocated (so <= isize in total bytes) to hold `entries`, so this
         // must be inbounds.
         let slot = unsafe { ptr.add(self.index_in_bucket) };
@@ -209,12 +187,10 @@ fn initialize_bucket<V>(bucket: &AtomicPtr<Slot<V>>, bucket_idx: usize) -> *mut
     /// Inserts into the map, given that the slot is unique, so it won't race with other threads.
     #[inline]
     unsafe fn put_unique<V>(&self, buckets: &[AtomicPtr<Slot<V>>; 21], value: V, extra: u32) {
-        // SAFETY: `bucket_idx` is ilog2(u32).saturating_sub(11), which is at most 21, i.e.,
-        // in-bounds of buckets.
-        let bucket = unsafe { buckets.get_unchecked(self.bucket_idx) };
+        let bucket = &buckets[self.bucket_idx];
         let ptr = self.bucket_ptr(bucket);
 
-        debug_assert!(self.index_in_bucket < self.entries());
+        debug_assert!(self.index_in_bucket < self.bucket_idx.capacity());
         // SAFETY: `bucket` was allocated (so <= isize in total bytes) to hold `entries`, so this
         // must be inbounds.
         let slot = unsafe { ptr.add(self.index_in_bucket) };
@@ -254,7 +230,7 @@ pub struct VecCache<K: Idx, V, I> {
     // ...
     // Bucket 19: 1073741824
     // Bucket 20: 2147483648
-    // The total number of entries if all buckets are initialized is u32::MAX-1.
+    // The total number of entries if all buckets are initialized is 2^32.
     buckets: [AtomicPtr<Slot<V>>; BUCKETS],
 
     // In the compiler's current usage these are only *read* during incremental and self-profiling.
@@ -289,7 +265,7 @@ fn drop(&mut self) {
         assert!(!std::mem::needs_drop::<K>());
         assert!(!std::mem::needs_drop::<V>());
 
-        for (idx, bucket) in self.buckets.iter().enumerate() {
+        for (idx, bucket) in BucketIndex::enumerate_buckets(&self.buckets) {
             let bucket = bucket.load(Ordering::Acquire);
             if !bucket.is_null() {
                 let layout = std::alloc::Layout::array::<Slot<V>>(ENTRIES_BY_BUCKET[idx]).unwrap();
@@ -299,7 +275,7 @@ fn drop(&mut self) {
             }
         }
 
-        for (idx, bucket) in self.present.iter().enumerate() {
+        for (idx, bucket) in BucketIndex::enumerate_buckets(&self.present) {
             let bucket = bucket.load(Ordering::Acquire);
             if !bucket.is_null() {
                 let layout = std::alloc::Layout::array::<Slot<()>>(ENTRIES_BY_BUCKET[idx]).unwrap();
@@ -365,5 +341,164 @@ pub fn len(&self) -> usize {
     }
 }
 
-#[cfg(test)]
-mod tests;
+/// Index into an array of buckets.
+///
+/// Using an enum lets us tell the compiler that values range from 0 to 20,
+/// allowing array bounds checks to be optimized away,
+/// without having to resort to pattern types or other unstable features.
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[repr(usize)]
+enum BucketIndex {
+    // tidy-alphabetical-start
+    Bucket00,
+    Bucket01,
+    Bucket02,
+    Bucket03,
+    Bucket04,
+    Bucket05,
+    Bucket06,
+    Bucket07,
+    Bucket08,
+    Bucket09,
+    Bucket10,
+    Bucket11,
+    Bucket12,
+    Bucket13,
+    Bucket14,
+    Bucket15,
+    Bucket16,
+    Bucket17,
+    Bucket18,
+    Bucket19,
+    Bucket20,
+    // tidy-alphabetical-end
+}
+
+impl Debug for BucketIndex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Debug::fmt(&self.to_usize(), f)
+    }
+}
+
+impl BucketIndex {
+    /// Capacity of bucket 0 (and also of bucket 1).
+    const BUCKET_0_CAPACITY: usize = 1 << (Self::NONZERO_BUCKET_SHIFT_ADJUST + 1);
+    /// Adjustment factor from the highest-set-bit-position of a flat index,
+    /// to its corresponding bucket number.
+    ///
+    /// For example, the first flat-index in bucket 2 is 8192.
+    /// Its highest-set-bit-position is `(8192).ilog2() == 13`, and subtracting
+    /// the adjustment factor of 11 gives the bucket number of 2.
+    const NONZERO_BUCKET_SHIFT_ADJUST: usize = 11;
+
+    #[inline(always)]
+    const fn to_usize(self) -> usize {
+        self as usize
+    }
+
+    #[inline(always)]
+    const fn from_raw(raw: usize) -> Self {
+        match raw {
+            // tidy-alphabetical-start
+            00 => Self::Bucket00,
+            01 => Self::Bucket01,
+            02 => Self::Bucket02,
+            03 => Self::Bucket03,
+            04 => Self::Bucket04,
+            05 => Self::Bucket05,
+            06 => Self::Bucket06,
+            07 => Self::Bucket07,
+            08 => Self::Bucket08,
+            09 => Self::Bucket09,
+            10 => Self::Bucket10,
+            11 => Self::Bucket11,
+            12 => Self::Bucket12,
+            13 => Self::Bucket13,
+            14 => Self::Bucket14,
+            15 => Self::Bucket15,
+            16 => Self::Bucket16,
+            17 => Self::Bucket17,
+            18 => Self::Bucket18,
+            19 => Self::Bucket19,
+            20 => Self::Bucket20,
+            // tidy-alphabetical-end
+            _ => panic!("bucket index out of range"),
+        }
+    }
+
+    /// Total number of slots in this bucket.
+    #[inline(always)]
+    const fn capacity(self) -> usize {
+        match self {
+            Self::Bucket00 => Self::BUCKET_0_CAPACITY,
+            // Bucket 1 has a capacity of `1 << (1 + 11) == pow(2, 12) == 4096`.
+            // Bucket 2 has a capacity of `1 << (2 + 11) == pow(2, 13) == 8192`.
+            _ => 1 << (self.to_usize() + Self::NONZERO_BUCKET_SHIFT_ADJUST),
+        }
+    }
+
+    /// Converts a flat index in the range `0..=u32::MAX` into a bucket index,
+    /// and a slot offset within that bucket.
+    ///
+    /// Panics if `flat > u32::MAX`.
+    #[inline(always)]
+    const fn from_flat_index(flat: usize) -> (Self, usize) {
+        if flat > u32::MAX as usize {
+            panic!();
+        }
+
+        // If the index is in bucket 0, the conversion is trivial.
+        // This also avoids calling `ilog2` when `flat == 0`.
+        if flat < Self::BUCKET_0_CAPACITY {
+            return (Self::Bucket00, flat);
+        }
+
+        // General-case conversion for a non-zero bucket index.
+        //
+        //              | bucket |   slot
+        // flat | ilog2 |  index | offset
+        // ------------------------------
+        // 4096 |    12 |      1 |      0
+        // 4097 |    12 |      1 |      1
+        // ...
+        // 8191 |    12 |      1 |   4095
+        // 8192 |    13 |      2 |      0
+        let highest_bit_pos = flat.ilog2() as usize;
+        let bucket_index =
+            BucketIndex::from_raw(highest_bit_pos - Self::NONZERO_BUCKET_SHIFT_ADJUST);
+
+        // Clear the highest-set bit (which selects the bucket) to get the
+        // slot offset within this bucket.
+        let slot_offset = flat - (1 << highest_bit_pos);
+
+        (bucket_index, slot_offset)
+    }
+
+    #[inline(always)]
+    fn iter_all() -> impl ExactSizeIterator<Item = Self> {
+        (0usize..BUCKETS).map(BucketIndex::from_raw)
+    }
+
+    #[inline(always)]
+    fn enumerate_buckets<T>(buckets: &[T; BUCKETS]) -> impl ExactSizeIterator<Item = (Self, &T)> {
+        BucketIndex::iter_all().zip(buckets)
+    }
+}
+
+impl<T> Index<BucketIndex> for [T; BUCKETS] {
+    type Output = T;
+
+    #[inline(always)]
+    fn index(&self, index: BucketIndex) -> &Self::Output {
+        // The optimizer should be able to see that see that a bucket index is
+        // always in-bounds, and omit the runtime bounds check.
+        &self[index.to_usize()]
+    }
+}
+
+impl<T> IndexMut<BucketIndex> for [T; BUCKETS] {
+    #[inline(always)]
+    fn index_mut(&mut self, index: BucketIndex) -> &mut Self::Output {
+        &mut self[index.to_usize()]
+    }
+}
diff --git a/compiler/rustc_data_structures/src/vec_cache/tests.rs b/compiler/rustc_data_structures/src/vec_cache/tests.rs
index f588442eee62..f12937ad565d 100644
--- a/compiler/rustc_data_structures/src/vec_cache/tests.rs
+++ b/compiler/rustc_data_structures/src/vec_cache/tests.rs
@@ -1,10 +1,46 @@
 use super::*;
 
+#[test]
+#[should_panic(expected = "bucket index out of range")]
+fn bucket_index_n_buckets() {
+    BucketIndex::from_raw(BUCKETS);
+}
+
+#[test]
+fn bucket_index_round_trip() {
+    for i in 0..BUCKETS {
+        assert_eq!(BucketIndex::from_raw(i).to_usize(), i);
+    }
+}
+
+#[test]
+fn bucket_index_iter_all_len() {
+    let len = BucketIndex::iter_all().len();
+    assert_eq!(len, BUCKETS);
+
+    let len = BucketIndex::iter_all().collect::<Vec<_>>().len();
+    assert_eq!(len, BUCKETS);
+
+    let len = BucketIndex::enumerate_buckets(&[(); BUCKETS]).len();
+    assert_eq!(len, BUCKETS);
+}
+
+#[test]
+fn bucket_index_capacity() {
+    // Check that the combined capacity of all buckets is 2^32 slots.
+    // That's 1 larger than `u32::MAX`, so store the total as a `u64`.
+    let mut total = 0u64;
+    for i in BucketIndex::iter_all() {
+        total += u64::try_from(i.capacity()).unwrap();
+    }
+    assert_eq!(total, 1 << 32);
+}
+
 #[test]
 #[cfg(not(miri))]
-fn vec_cache_empty() {
+fn vec_cache_empty_exhaustive() {
     let cache: VecCache<u32, u32, u32> = VecCache::default();
-    for key in 0..u32::MAX {
+    for key in 0..=u32::MAX {
         assert!(cache.lookup(&key).is_none());
     }
 }
@@ -70,8 +106,8 @@ fn slot_entries_table() {
 
 #[test]
 fn bucket_entries_matches() {
-    for i in 0..BUCKETS {
-        assert_eq!(SlotIndex { bucket_idx: i, index_in_bucket: 0 }.entries(), ENTRIES_BY_BUCKET[i]);
+    for i in BucketIndex::iter_all() {
+        assert_eq!(i.capacity(), ENTRIES_BY_BUCKET[i]);
     }
 }
 
@@ -84,13 +120,13 @@ fn slot_index_exhaustive() {
     }
     let slot_idx = SlotIndex::from_index(0);
     assert_eq!(slot_idx.index_in_bucket, 0);
-    assert_eq!(slot_idx.bucket_idx, 0);
+    assert_eq!(slot_idx.bucket_idx, BucketIndex::Bucket00);
     let mut prev = slot_idx;
     for idx in 1..=u32::MAX {
         let slot_idx = SlotIndex::from_index(idx);
 
         // SAFETY: Ensure indices don't go out of bounds of buckets.
-        assert!(slot_idx.index_in_bucket < slot_idx.entries());
+        assert!(slot_idx.index_in_bucket < slot_idx.bucket_idx.capacity());
 
         if prev.bucket_idx == slot_idx.bucket_idx {
             assert_eq!(prev.index_in_bucket + 1, slot_idx.index_in_bucket);
@@ -98,8 +134,8 @@ fn slot_index_exhaustive() {
             assert_eq!(slot_idx.index_in_bucket, 0);
         }
 
-        assert_eq!(buckets[slot_idx.bucket_idx], slot_idx.entries() as u32);
-        assert_eq!(ENTRIES_BY_BUCKET[slot_idx.bucket_idx], slot_idx.entries(), "{}", idx);
+        assert_eq!(buckets[slot_idx.bucket_idx], slot_idx.bucket_idx.capacity() as u32);
+        assert_eq!(ENTRIES_BY_BUCKET[slot_idx.bucket_idx], slot_idx.bucket_idx.capacity(), "{idx}",);
 
         prev = slot_idx;
     }

From 5f680443579ae914c005cc40485a1c029cbe4cdc Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 23 Mar 2026 18:37:52 +0100
Subject: [PATCH 0864/1059] miri recursive checking: only check one layer deep

---
 .../rustc_const_eval/src/interpret/validity.rs     | 14 +++++++++++---
 src/tools/miri/README.md                           |  5 +++--
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 62ee653000dc..9310cda8450b 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -1512,6 +1512,7 @@ fn visit_value(&mut self, val: &PlaceTy<'tcx, M::Provenance>) -> InterpResult<'t
 }
 
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
+    /// The internal core entry point for all validation operations.
     fn validate_operand_internal(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
@@ -1519,6 +1520,7 @@ fn validate_operand_internal(
         ref_tracking: Option<&mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Vec<PathElem>>>,
         ctfe_mode: Option<CtfeValidationMode>,
         reset_provenance_and_padding: bool,
+        start_in_may_dangle: bool,
     ) -> InterpResult<'tcx> {
         trace!("validate_operand_internal: {:?}, {:?}", *val, val.layout.ty);
 
@@ -1536,7 +1538,7 @@ fn validate_operand_internal(
                 ecx,
                 reset_provenance_and_padding,
                 data_bytes: reset_padding.then_some(RangeSet(Vec::new())),
-                may_dangle: false,
+                may_dangle: start_in_may_dangle,
             };
             v.visit_value(val)?;
             v.reset_padding(val)?;
@@ -1579,6 +1581,7 @@ pub(crate) fn const_validate_operand(
             Some(ref_tracking),
             Some(ctfe_mode),
             /*reset_provenance*/ false,
+            /*start_in_may_dangle*/ false,
         )
     }
 
@@ -1610,6 +1613,7 @@ pub fn validate_operand(
                 None,
                 None,
                 reset_provenance_and_padding,
+                /*start_in_may_dangle*/ false,
             );
         }
         // Do a recursive check.
@@ -1620,15 +1624,19 @@ pub fn validate_operand(
             Some(&mut ref_tracking),
             None,
             reset_provenance_and_padding,
+            /*start_in_may_dangle*/ false,
         )?;
         while let Some((mplace, path)) = ref_tracking.todo.pop() {
-            // Things behind reference do *not* have the provenance reset.
+            // Things behind reference do *not* have the provenance reset. In fact
+            // we treat the entire thing as being inside MaybeDangling, i.e., references
+            // do not have to be dereferenceable.
             self.validate_operand_internal(
                 &mplace.into(),
                 path,
-                Some(&mut ref_tracking),
+                None, // no further recursion
                 None,
                 /*reset_provenance_and_padding*/ false,
+                /*start_in_may_dangle*/ true,
             )?;
         }
         interp_ok(())
diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 97f385ad755b..f51cd96486b4 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -476,8 +476,9 @@ to Miri failing to detect cases of undefined behavior in a program.
   but reports to the program that it did actually write. This is useful when you
   are not interested in the actual program's output, but only want to see Miri's
   errors and warnings.
-* `-Zmiri-recursive-validation` is a *highly experimental* flag that makes validity checking
-  recurse below references.
+* `-Zmiri-recursive-validation` is a *highly experimental* flag that makes validity checking recurse
+  *one level* below references. The in-memory value is treated as-if it was inside a
+  `MaybeDangling`, i.e., nested references do not even have to be dereferenceable.
 * `-Zmiri-preemption-rate` configures the probability that at the end of a basic block, the active
   thread will be preempted. The default is `0.01` (i.e., 1%). Setting this to `0` disables
   preemption. Note that even without preemption, the schedule is still non-deterministic:

From 365d2bc033731cd8d56a006a3ff1c8c81e4b7577 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 08:08:38 +0100
Subject: [PATCH 0865/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 212b0d480f337082bbe1132d2b62be20e7e61f8a.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index e281dad8ef1e..78136929d445 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-fd0c901b00ee1e08a250039cdb90258603497e20
+212b0d480f337082bbe1132d2b62be20e7e61f8a

From bd16cd4fb54a1f54317d2cb9a7b623c32d081ce3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 08:12:17 +0100
Subject: [PATCH 0866/1059] CopyProp: fix outdated comment

---
 compiler/rustc_mir_transform/src/copy_prop.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs
index 89ee96317ac9..e04cb26e8990 100644
--- a/compiler/rustc_mir_transform/src/copy_prop.rs
+++ b/compiler/rustc_mir_transform/src/copy_prop.rs
@@ -58,7 +58,8 @@ fn is_required(&self) -> bool {
     }
 }
 
-/// Utility to help performing substitution of `*pattern` by `target`.
+/// Utility to help performing substitution: for all key-value pairs in `copy_classes`,
+/// all occurrences of the key get replaced by the value.
 struct Replacer<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     unified: DenseBitSet<Local>,

From 65f28d1e9e32e4884b9808a8353d459e6740d1f9 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 08:35:37 +0100
Subject: [PATCH 0867/1059] support looking up extern statics via dlsym

---
 src/tools/miri/src/machine.rs                   |  2 +-
 src/tools/miri/src/shims/unix/foreign_items.rs  |  9 ++++++---
 src/tools/miri/tests/pass-dep/libc/libc-misc.rs | 11 +++++++++--
 3 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index d8224f1878f0..566a775b9010 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -569,7 +569,7 @@ pub struct MiriMachine<'tcx> {
     pub(crate) user_relevant_crates: Vec<CrateNum>,
 
     /// Mapping extern static names to their pointer.
-    extern_statics: FxHashMap<Symbol, StrictPointer>,
+    pub(crate) extern_statics: FxHashMap<Symbol, StrictPointer>,
 
     /// The random number generator used for resolving non-determinism.
     /// Needs to be queried by ptr_to_int, hence needs interior mutability.
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index f2e16e75892e..bce091537f58 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -727,11 +727,14 @@ fn emulate_foreign_item_inner(
                 this.read_target_usize(handle)?;
                 let symbol = this.read_pointer(symbol)?;
                 let name = this.read_c_str(symbol)?;
-                if let Ok(name) = str::from_utf8(name)
-                    && is_dyn_sym(name, &this.tcx.sess.target.os)
-                {
+                let Ok(name) = str::from_utf8(name) else {
+                    throw_unsup_format!("dlsym: non UTF-8 symbol name not supported")
+                };
+                if is_dyn_sym(name, &this.tcx.sess.target.os) {
                     let ptr = this.fn_ptr(FnVal::Other(DynSym::from_str(name)));
                     this.write_pointer(ptr, dest)?;
+                } else if let Some(&ptr) = this.machine.extern_statics.get(&Symbol::intern(name)) {
+                    this.write_pointer(ptr, dest)?;
                 } else {
                     this.write_null(dest)?;
                 }
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
index d1c0085b024a..36ed470b353f 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
@@ -63,15 +63,22 @@ fn test_sigrt() {
 }
 
 fn test_dlsym() {
-    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, b"notasymbol\0".as_ptr().cast()) };
+    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, c"notasymbol".as_ptr()) };
     assert!(addr as usize == 0);
 
-    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, b"isatty\0".as_ptr().cast()) };
+    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, c"isatty".as_ptr()) };
     assert!(addr as usize != 0);
     let isatty: extern "C" fn(i32) -> i32 = unsafe { transmute(addr) };
     assert_eq!(isatty(999), 0);
     let errno = std::io::Error::last_os_error().raw_os_error().unwrap();
     assert_eq!(errno, libc::EBADF);
+
+    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, c"environ".as_ptr()) };
+    assert!(addr as usize != 0);
+    extern "C" {
+        static mut environ: *const *const u8;
+    }
+    assert!(addr as usize == &raw const environ as usize);
 }
 
 fn test_getuid() {

From fb2b0031d0503e77a33d551ddef409b6834afb05 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 08:59:29 +0100
Subject: [PATCH 0868/1059] GVN: add clarifying example to reference comment

---
 compiler/rustc_mir_transform/src/gvn.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 245ee6ec1cb7..e9a20aa01655 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -48,8 +48,15 @@
 //! # Handling of references
 //!
 //! We handle references by assigning a different "provenance" index to each Ref/RawPtr rvalue.
-//! This ensure that we do not spuriously merge borrows that should not be merged. Meanwhile, we
-//! consider all the derefs of an immutable reference to a freeze type to give the same value:
+//! This ensure that we do not spuriously merge borrows that should not be merged. For instance:
+//! ```ignore (MIR)
+//! _x = &_a;
+//! _a = 0;
+//! _y = &_a; // cannot be turned into `_y = _x`!
+//! ```
+//!
+//! On top of that, we consider all the derefs of an immutable reference to a freeze type to give
+//! the same value:
 //! ```ignore (MIR)
 //! _a = *_b // _b is &Freeze
 //! _c = *_b // replaced by _c = _a

From fd9670b7af5ef3af0c8d9d0f42000ca46cd99036 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 08:50:21 +0100
Subject: [PATCH 0869/1059] make better use of CStr/CString

---
 .../fail-dep/libc/env-set_var-data-race.rs    |  2 +-
 .../libc/env-set_var-data-race.stderr         |  6 ++--
 .../fail-dep/libc/fs/mkstemp_immutable_arg.rs |  2 +-
 .../fs/unix_open_missing_required_mode.rs     |  5 ++-
 .../fs/unix_open_missing_required_mode.stderr |  4 +--
 .../concurrency/env-cleanup-data-race.rs      |  2 +-
 .../miri/tests/pass-dep/extra_fn_ptr_gc.rs    |  4 +--
 src/tools/miri/tests/pass-dep/libc/libc-fs.rs | 34 +++++++------------
 8 files changed, 24 insertions(+), 35 deletions(-)

diff --git a/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.rs b/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.rs
index 5c80f6425eaa..b1929e3f27ed 100644
--- a/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.rs
+++ b/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.rs
@@ -7,7 +7,7 @@ fn main() {
     let t = thread::spawn(|| unsafe {
         // Access the environment in another thread without taking the env lock.
         // This represents some C code that queries the environment.
-        libc::getenv(b"TZ\0".as_ptr().cast()); //~ERROR: Data race detected
+        libc::getenv(c"TZ".as_ptr()); //~ERROR: Data race detected
     });
     // Meanwhile, the main thread uses the "safe" Rust env accessor.
     env::set_var("MY_RUST_VAR", "Ferris");
diff --git a/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.stderr b/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.stderr
index 635091cc0173..b4cd31b4ddab 100644
--- a/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/env-set_var-data-race.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic write on thread `main` and (2) non-atomic read on thread `unnamed-ID` at ALLOC
   --> tests/fail-dep/libc/env-set_var-data-race.rs:LL:CC
    |
-LL |         libc::getenv(b"TZ/0".as_ptr().cast());
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (2) just happened here
+LL |         libc::getenv(c"TZ".as_ptr());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail-dep/libc/env-set_var-data-race.rs:LL:CC
@@ -19,7 +19,7 @@ LL |       let t = thread::spawn(|| unsafe {
    |  _____________^
 LL | |         // Access the environment in another thread without taking the env lock.
 LL | |         // This represents some C code that queries the environment.
-LL | |         libc::getenv(b"TZ/0".as_ptr().cast());
+LL | |         libc::getenv(c"TZ".as_ptr());
 LL | |     });
    | |______^
 
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/mkstemp_immutable_arg.rs b/src/tools/miri/tests/fail-dep/libc/fs/mkstemp_immutable_arg.rs
index 2c676f12b4f0..abdafe2b0fb3 100644
--- a/src/tools/miri/tests/fail-dep/libc/fs/mkstemp_immutable_arg.rs
+++ b/src/tools/miri/tests/fail-dep/libc/fs/mkstemp_immutable_arg.rs
@@ -6,6 +6,6 @@ fn main() {
 }
 
 fn test_mkstemp_immutable_arg() {
-    let s: *mut libc::c_char = b"fooXXXXXX\0" as *const _ as *mut _;
+    let s: *mut libc::c_char = c"fooXXXXXX".as_ptr().cast_mut();
     let _fd = unsafe { libc::mkstemp(s) }; //~ ERROR: Undefined Behavior: writing to alloc1 which is read-only
 }
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.rs b/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.rs
index 457f32e55446..29548c17443a 100644
--- a/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.rs
+++ b/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.rs
@@ -6,7 +6,6 @@ fn main() {
 }
 
 fn test_file_open_missing_needed_mode() {
-    let name = b"missing_arg.txt\0";
-    let name_ptr = name.as_ptr().cast::<libc::c_char>();
-    let _fd = unsafe { libc::open(name_ptr, libc::O_CREAT) }; //~ ERROR: Undefined Behavior: not enough variadic arguments
+    let name = c"missing_arg.txt".as_ptr();
+    let _fd = unsafe { libc::open(name, libc::O_CREAT) }; //~ ERROR: Undefined Behavior: not enough variadic arguments
 }
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.stderr b/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.stderr
index a85fae9c7dd2..186ca4ccdd40 100644
--- a/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/fs/unix_open_missing_required_mode.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: not enough variadic arguments for `open(pathname, O_CREAT, ...)`: got 0, expected at least 1
   --> tests/fail-dep/libc/fs/unix_open_missing_required_mode.rs:LL:CC
    |
-LL |     let _fd = unsafe { libc::open(name_ptr, libc::O_CREAT) };
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |     let _fd = unsafe { libc::open(name, libc::O_CREAT) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/pass-dep/concurrency/env-cleanup-data-race.rs b/src/tools/miri/tests/pass-dep/concurrency/env-cleanup-data-race.rs
index 91cf24a944ad..44e969578989 100644
--- a/src/tools/miri/tests/pass-dep/concurrency/env-cleanup-data-race.rs
+++ b/src/tools/miri/tests/pass-dep/concurrency/env-cleanup-data-race.rs
@@ -8,7 +8,7 @@ fn main() {
     unsafe {
         thread::spawn(|| {
             // Access the environment in another thread without taking the env lock
-            let s = libc::getenv("MIRI_ENV_VAR_TEST\0".as_ptr().cast());
+            let s = libc::getenv(c"MIRI_ENV_VAR_TEST".as_ptr());
             if s.is_null() {
                 panic!("null");
             }
diff --git a/src/tools/miri/tests/pass-dep/extra_fn_ptr_gc.rs b/src/tools/miri/tests/pass-dep/extra_fn_ptr_gc.rs
index 9e5627c75a97..70fa6c183c84 100644
--- a/src/tools/miri/tests/pass-dep/extra_fn_ptr_gc.rs
+++ b/src/tools/miri/tests/pass-dep/extra_fn_ptr_gc.rs
@@ -7,8 +7,8 @@
 type GetEntropyFn = unsafe extern "C" fn(*mut u8, libc::size_t) -> libc::c_int;
 
 fn main() {
-    let name = "getentropy\0";
-    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr() as *const _) as usize };
+    let name = c"getentropy";
+    let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) as usize };
     // If the GC does not account for the extra_fn_ptr entry that this dlsym just added, this GC
     // run will delete our entry for the base addr of the function pointer we will transmute to,
     // and the call through the function pointer will report UB.
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
index f5e9a56d7d03..9dc1af1be299 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
@@ -54,29 +54,23 @@ fn main() {
 
 fn test_file_open_unix_allow_two_args() {
     let path = utils::prepare_with_content("test_file_open_unix_allow_two_args.txt", &[]);
+    let name = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
 
-    let mut name = path.into_os_string();
-    name.push("\0");
-    let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
-    let _fd = unsafe { libc::open(name_ptr, libc::O_RDONLY) };
+    let _fd = unsafe { libc::open(name.as_ptr(), libc::O_RDONLY) };
 }
 
 fn test_file_open_unix_needs_three_args() {
     let path = utils::prepare_with_content("test_file_open_unix_needs_three_args.txt", &[]);
+    let name = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
 
-    let mut name = path.into_os_string();
-    name.push("\0");
-    let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
-    let _fd = unsafe { libc::open(name_ptr, libc::O_CREAT, 0o666) };
+    let _fd = unsafe { libc::open(name.as_ptr(), libc::O_CREAT, 0o666) };
 }
 
 fn test_file_open_unix_extra_third_arg() {
     let path = utils::prepare_with_content("test_file_open_unix_extra_third_arg.txt", &[]);
+    let name = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
 
-    let mut name = path.into_os_string();
-    name.push("\0");
-    let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
-    let _fd = unsafe { libc::open(name_ptr, libc::O_RDONLY, 42) };
+    let _fd = unsafe { libc::open(name.as_ptr(), libc::O_RDONLY, 42) };
 }
 
 fn test_dup_stdout_stderr() {
@@ -92,12 +86,10 @@ fn test_dup_stdout_stderr() {
 fn test_dup() {
     let bytes = b"dup and dup2";
     let path = utils::prepare_with_content("miri_test_libc_dup.txt", bytes);
+    let name = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
 
-    let mut name = path.into_os_string();
-    name.push("\0");
-    let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
     unsafe {
-        let fd = libc::open(name_ptr, libc::O_RDONLY);
+        let fd = libc::open(name.as_ptr(), libc::O_RDONLY);
         let new_fd = libc::dup(fd);
         let new_fd2 = libc::dup2(fd, 8);
 
@@ -519,7 +511,7 @@ fn test_read_and_uninit() {
     {
         // We test that libc::read initializes its buffer.
         let path = utils::prepare_with_content("pass-libc-read-and-uninit.txt", &[1u8, 2, 3]);
-        let cpath = CString::new(path.clone().into_os_string().into_encoded_bytes()).unwrap();
+        let cpath = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
         unsafe {
             let fd = libc::open(cpath.as_ptr(), libc::O_RDONLY);
             assert_ne!(fd, -1);
@@ -528,8 +520,8 @@ fn test_read_and_uninit() {
             let buf = buf.assume_init();
             assert_eq!(buf, 1);
             assert_eq!(libc::close(fd), 0);
+            assert_eq!(libc::unlink(cpath.as_ptr()), 0);
         }
-        remove_file(&path).unwrap();
     }
     {
         // We test that if we requested to read 4 bytes, but actually read 3 bytes, then
@@ -567,17 +559,15 @@ fn test_nofollow_not_symlink() {
 #[cfg(target_os = "macos")]
 fn test_ioctl() {
     let path = utils::prepare_with_content("miri_test_libc_ioctl.txt", &[]);
+    let name = CString::new(path.into_os_string().into_encoded_bytes()).unwrap();
 
-    let mut name = path.into_os_string();
-    name.push("\0");
-    let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
     unsafe {
         // 100 surely is an invalid FD.
         assert_eq!(libc::ioctl(100, libc::FIOCLEX), -1);
         let errno = std::io::Error::last_os_error().raw_os_error().unwrap();
         assert_eq!(errno, libc::EBADF);
 
-        let fd = libc::open(name_ptr, libc::O_RDONLY);
+        let fd = libc::open(name.as_ptr(), libc::O_RDONLY);
         assert_eq!(libc::ioctl(fd, libc::FIOCLEX), 0);
     }
 }

From c87cd68568726d335c9ec8800372bb22c4cb9af5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 24 Mar 2026 09:29:12 +0100
Subject: [PATCH 0870/1059] document some functions on AttributeExt

---
 compiler/rustc_ast/src/attr/mod.rs | 8 ++++++++
 compiler/rustc_hir/src/hir.rs      | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 72e7b27a1f97..369fe12539fa 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -876,11 +876,15 @@ pub trait AttributeExt: Debug {
     /// a doc comment) will return `false`.
     fn is_doc_comment(&self) -> Option<Span>;
 
+    /// Returns true if the attribute's first *and only* path segment is equal to the passed-in
+    /// symbol.
     #[inline]
     fn has_name(&self, name: Symbol) -> bool {
         self.name().map(|x| x == name).unwrap_or(false)
     }
 
+    /// Returns true if the attribute's first *and only* path segment is any of the passed-in
+    /// symbols.
     #[inline]
     fn has_any_name(&self, names: &[Symbol]) -> bool {
         names.iter().any(|&name| self.has_name(name))
@@ -889,6 +893,7 @@ fn has_any_name(&self, names: &[Symbol]) -> bool {
     /// get the span of the entire attribute
     fn span(&self) -> Span;
 
+    /// Returns whether the attribute is a path, without any arguments.
     fn is_word(&self) -> bool;
 
     fn path(&self) -> SmallVec<[Symbol; 1]> {
@@ -911,11 +916,14 @@ fn has_any_name(&self, names: &[Symbol]) -> bool {
     /// * `#[deprecated(note = "note", ...)]` returns `Some("note")`.
     fn deprecation_note(&self) -> Option<Ident>;
 
+    /// Returns whether this attribute is any of the proc macro attributes.
+    /// i.e. `proc_macro`, `proc_macro_attribute` or `proc_macro_derive`.
     fn is_proc_macro_attr(&self) -> bool {
         [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
             .iter()
             .any(|kind| self.has_name(*kind))
     }
+    /// Returns true if this attribute is `#[automatically_deived]`.
     fn is_automatically_derived_attr(&self) -> bool;
 
     /// Returns the documentation and its kind if this is a doc comment or a sugared doc comment.
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 9526143fcace..71424f7275c9 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1264,6 +1264,8 @@ pub struct HashIgnoredAttrId {
     pub attr_id: AttrId,
 }
 
+/// Many functions on this type have their documentation in the [`AttributeExt`] trait,
+/// since they defer their implementation directly to that trait.
 #[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic)]
 pub enum Attribute {
     /// A parsed built-in attribute.

From 366cf883c7ad65663d0b75bc40de12a93df7fe0d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 23 Mar 2026 12:31:12 +0100
Subject: [PATCH 0871/1059] Add comments

---
 library/core/src/ffi/va_list.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 772b25d02be2..f0f58a0f8343 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -244,7 +244,7 @@ pub(crate) const fn duplicate(&self) -> Self {
 
 #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
 impl<'f> const Clone for VaList<'f> {
-    #[inline]
+    #[inline] // Avoid codegen when not used to help backends that don't support VaList.
     fn clone(&self) -> Self {
         // We only implement Clone and not Copy because some future target might not be able to
         // implement Copy (e.g. because it allocates). For the same reason we use an intrinsic
@@ -256,7 +256,7 @@ fn clone(&self) -> Self {
 
 #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
 impl<'f> const Drop for VaList<'f> {
-    #[inline]
+    #[inline] // Avoid codegen when not used to help backends that don't support VaList.
     fn drop(&mut self) {
         // SAFETY: this variable argument list is being dropped, so won't be read from again.
         unsafe { va_end(self) }
@@ -327,7 +327,7 @@ impl<'f> VaList<'f> {
     ///
     /// Calling this function with an incompatible type, an invalid value, or when there
     /// are no more variable arguments, is unsound.
-    #[inline]
+    #[inline] // Avoid codegen when not used to help backends that don't support VaList.
     #[rustc_const_unstable(feature = "const_c_variadic", issue = "151787")]
     pub const unsafe fn arg<T: VaArgSafe>(&mut self) -> T {
         // SAFETY: the caller must uphold the safety contract for `va_arg`.

From 4e1fd93ab735a64c824e58fb76052b1b6194da18 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 6 Jan 2026 17:46:00 +0800
Subject: [PATCH 0872/1059] Fix not applicable on ambiguous ident pat for
 merge_match_arms

Example
---
```rust
enum X {
    A,
    B,
    C,
}
use X::*;
fn main() {
    match A {
        $0A => todo!(),
        B => todo!(),
        C => todo!(),
    }
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
enum X {
    A,
    B,
    C,
}
use X::*;
fn main() {
    match A {
        A | B => todo!(),
        C => todo!(),
    }
}
```
---
 .../src/handlers/merge_match_arms.rs          | 39 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_match_arms.rs
index 08170f81b283..6e84af5f9129 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_match_arms.rs
@@ -160,8 +160,11 @@ fn recurse<'db>(
                     }
                 }
                 ast::Pat::IdentPat(ident_pat) => {
-                    if let Some(name) = ident_pat.name() {
+                    if let Some(name) = ident_pat.name()
+                        && ctx.sema.to_def(ident_pat).is_some()
+                    {
                         let pat_type = ctx.sema.type_of_binding_in_pat(ident_pat);
+
                         map.insert(name.text().to_string(), pat_type);
                     }
                 }
@@ -212,6 +215,40 @@ fn main() {
         );
     }
 
+    #[test]
+    fn merge_match_arms_ambiguous_ident_patterns() {
+        check_assist(
+            merge_match_arms,
+            r#"
+#[derive(Debug)]
+enum X { A, B, C }
+use X::*;
+
+fn main() {
+    let x = A;
+    let y = match x {
+        A => { 1i32$0 }
+        B => { 1i32 }
+        C => { 2i32 }
+    }
+}
+"#,
+            r#"
+#[derive(Debug)]
+enum X { A, B, C }
+use X::*;
+
+fn main() {
+    let x = A;
+    let y = match x {
+        A | B => { 1i32 },
+        C => { 2i32 }
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn merge_match_arms_multiple_patterns() {
         check_assist(

From bb0bc8567ffa39c767650f6603a965001cba94c0 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 24 Mar 2026 17:53:31 +0800
Subject: [PATCH 0873/1059] fix: wrap `Option<>` for desugar_try_expr_let_else

Example
---
```rust
fn test() {
    let pat: bool = Some(true)$0?;
}
```

**Before this PR**

```rust
fn test() {
    let Some(pat): bool = Some(true) else {
        return None;
    };
}
```

**After this PR**

```rust
fn test() {
    let Some(pat): Option<bool> = Some(true) else {
        return None;
    };
}
```
---
 .../src/handlers/desugar_try_expr.rs          | 23 ++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
index 02879837dc2f..e43cf0bc8aae 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
@@ -116,7 +116,7 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                 let fill_expr = || crate::utils::expr_fill_default(ctx.config);
                 let new_let_stmt = make.let_else_stmt(
                     try_enum.happy_pattern(pat),
-                    let_stmt.ty(),
+                    let_stmt.ty().map(|ty| make.ty_option(ty).into()),
                     expr,
                     make.block_expr(
                         iter::once(
@@ -243,6 +243,27 @@ fn test() {
     let Ok(pat) = Ok(true) else {
         return Err(todo!());
     };
+}
+            "#,
+            "Replace try expression with let else",
+        );
+    }
+
+    #[test]
+    fn test_desugar_try_expr_option_let_else_with_type() {
+        check_assist_by_label(
+            desugar_try_expr,
+            r#"
+//- minicore: try, option
+fn test() {
+    let pat: bool = Some(true)$0?;
+}
+            "#,
+            r#"
+fn test() {
+    let Some(pat): Option<bool> = Some(true) else {
+        return None;
+    };
 }
             "#,
             "Replace try expression with let else",

From e20616882af110507162e48b113456eaf5aadac1 Mon Sep 17 00:00:00 2001
From: albab-hasan <albabhasan276@gmail.com>
Date: Tue, 24 Mar 2026 14:58:24 +0600
Subject: [PATCH 0874/1059] fix: upmap macro-expanded usages in destructure
 struct/tuple binding
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

when a local binding is used inside a macro call (e.g. write!(s, "{}", x.field)
or write!(s, "{}", t.0)), the usage's name node lives in the macro expansion
tree while the syntax editor is rooted at the source file tree. passing the
expansion node to editor.replace() causes apply_edits to panic when it resolves
the SyntaxNodePtr against the wrong tree.

instead of skipping macro-expanded usages, map them back to the original source
via sema.original_range_opt() and replace the text at the mapped range. this
follows the established pattern of upmapping macro code to source code rather
than ignoring it.

for destructure_struct_binding, macro field accesses like x.y are replaced with
the destructured field name y directly in the source. for
destructure_tuple_binding, a new TextReplace variant on EditTupleUsage handles
text-based replacements for macro-expanded tuple index accesses like x.0 → _0.

when original_range_opt cannot map back (e.g. the index originates from the
macro body rather than the call site), the code falls back to NoIndex (wrapping
in block comments) or skipping, matching previous behavior.

this also replaces the MacroStmts ancestor check in destructure_tuple_binding,
which only covered macros expanding to multiple statements and missed
single-expression macros (MacroExpr).

fixes rust-lang/rust-analyzer#20716
---
 .../handlers/destructure_struct_binding.rs    | 36 +++++++-
 .../src/handlers/destructure_tuple_binding.rs | 88 +++++++++++--------
 2 files changed, 86 insertions(+), 38 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 0f5ef0548cf5..3f42696fa39f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -17,7 +17,7 @@
 
 use crate::{
     assist_context::{AssistContext, Assists, SourceChangeBuilder},
-    utils::ref_field_expr::determine_ref_and_parens,
+    utils::{cover_edit_range, ref_field_expr::determine_ref_and_parens},
 };
 
 // Assist: destructure_struct_binding
@@ -358,6 +358,7 @@ fn update_usages(
     data: &StructEditData,
     field_names: &FxHashMap<SmolStr, SmolStr>,
 ) {
+    let source = ctx.source_file();
     let make = SyntaxFactory::with_mappings();
     let edits = data
         .usages
@@ -366,7 +367,9 @@ fn update_usages(
         .collect_vec();
     editor.add_mappings(make.finish_with_mappings());
     for (old, new) in edits {
-        editor.replace(old, new);
+        if let Some(range) = ctx.sema.original_range_opt(&old) {
+            editor.replace_all(cover_edit_range(source, range.range), vec![new.into()]);
+        }
     }
 }
 
@@ -1006,4 +1009,33 @@ fn main($0foo: dep::Foo) {}
             "#,
         )
     }
+
+    #[test]
+    fn record_struct_usage_in_macro_call() {
+        // exact repro from #20716: struct field access inside write! must not panic
+        check_assist(
+            destructure_struct_binding,
+            r#"
+//- minicore: write, fmt
+use core::fmt::Write;
+struct Foo { y: i8 }
+
+fn main() {
+    let mut s = String::new();
+    let $0x = Foo { y: 8 };
+    write!(s, "{}", x.y).unwrap();
+}
+"#,
+            r#"
+use core::fmt::Write;
+struct Foo { y: i8 }
+
+fn main() {
+    let mut s = String::new();
+    let Foo { y } = Foo { y: 8 };
+    write!(s, "{}", y).unwrap();
+}
+"#,
+        )
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
index d51a3a26a3c7..583ba42bf5b8 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
@@ -14,7 +14,7 @@
 
 use crate::{
     assist_context::{AssistContext, Assists, SourceChangeBuilder},
-    utils::ref_field_expr::determine_ref_and_parens,
+    utils::{cover_edit_range, ref_field_expr::determine_ref_and_parens},
 };
 
 // Assist: destructure_tuple_binding
@@ -98,7 +98,9 @@ fn destructure_tuple_edit_impl(
 
     assignment_edit.apply(&mut syntax_editor, &syntax_factory);
     if let Some(usages_edit) = current_file_usages_edit {
-        usages_edit.into_iter().for_each(|usage_edit| usage_edit.apply(edit, &mut syntax_editor))
+        usages_edit
+            .into_iter()
+            .for_each(|usage_edit| usage_edit.apply(ctx, edit, &mut syntax_editor))
     }
 
     syntax_editor.add_mappings(syntax_factory.finish_with_mappings());
@@ -311,14 +313,25 @@ enum EditTupleUsage {
 }
 
 impl EditTupleUsage {
-    fn apply(self, edit: &mut SourceChangeBuilder, syntax_editor: &mut SyntaxEditor) {
+    fn apply(
+        self,
+        ctx: &AssistContext<'_>,
+        edit: &mut SourceChangeBuilder,
+        syntax_editor: &mut SyntaxEditor,
+    ) {
         match self {
             EditTupleUsage::NoIndex(range) => {
                 edit.insert(range.start(), "/*");
                 edit.insert(range.end(), "*/");
             }
             EditTupleUsage::ReplaceExpr(target_expr, replace_with) => {
-                syntax_editor.replace(target_expr.syntax(), replace_with.syntax())
+                if let Some(range) = ctx.sema.original_range_opt(target_expr.syntax()) {
+                    let source = ctx.source_file();
+                    syntax_editor.replace_all(
+                        cover_edit_range(source, range.range),
+                        vec![replace_with.syntax().clone().into()],
+                    );
+                }
             }
         }
     }
@@ -349,24 +362,6 @@ fn detect_tuple_index(usage: &FileReference, data: &TupleData) -> Option<TupleIn
     if let Some(field_expr) = ast::FieldExpr::cast(node) {
         let idx = field_expr.name_ref()?.as_tuple_field()?;
         if idx < data.field_names.len() {
-            // special case: in macro call -> range of `field_expr` in applied macro, NOT range in actual file!
-            if field_expr.syntax().ancestors().any(|a| ast::MacroStmts::can_cast(a.kind())) {
-                cov_mark::hit!(destructure_tuple_macro_call);
-
-                // issue: cannot differentiate between tuple index passed into macro or tuple index as result of macro:
-                // ```rust
-                // macro_rules! m {
-                //     ($t1:expr, $t2:expr) => { $t1; $t2.0 }
-                // }
-                // let t = (1,2);
-                // m!(t.0, t)
-                // ```
-                // -> 2 tuple index usages detected!
-                //
-                // -> only handle `t`
-                return None;
-            }
-
             Some(TupleIndex { index: idx, field_expr })
         } else {
             // tuple index out of range
@@ -1437,7 +1432,6 @@ mod in_macro_call {
 
         #[test]
         fn detect_macro_call() {
-            cov_mark::check!(destructure_tuple_macro_call);
             check_in_place_assist(
                 r#"
 macro_rules! m {
@@ -1456,7 +1450,7 @@ macro_rules! m {
 
 fn main() {
     let ($0_0, _1) = (1,2);
-    m!(/*t*/.0);
+    m!(_0);
 }
                 "#,
             )
@@ -1548,7 +1542,6 @@ fn main() {
     m!(t.0);
 }
                 "#,
-                // FIXME: replace `t.0` with `_0` (cannot detect range of tuple index in macro call)
                 r#"
 macro_rules! m {
     ($e:expr) => { "foo"; $e };
@@ -1556,10 +1549,9 @@ macro_rules! m {
 
 fn main() {
     let ($0_0, _1) = (1,2);
-    m!(/*t*/.0);
+    m!(_0);
 }
                 "#,
-                // FIXME: replace `t.0` with `_0`
                 r#"
 macro_rules! m {
     ($e:expr) => { "foo"; $e };
@@ -1567,7 +1559,7 @@ macro_rules! m {
 
 fn main() {
     let t @ ($0_0, _1) = (1,2);
-    m!(t.0);
+    m!(_0);
 }
                 "#,
             )
@@ -1586,7 +1578,6 @@ fn main() {
     m!((t).0);
 }
                 "#,
-                // FIXME: replace `(t).0` with `_0`
                 r#"
 macro_rules! m {
     ($e:expr) => { "foo"; $e };
@@ -1594,10 +1585,9 @@ macro_rules! m {
 
 fn main() {
     let ($0_0, _1) = (1,2);
-    m!((/*t*/).0);
+    m!(_0);
 }
                 "#,
-                // FIXME: replace `(t).0` with `_0`
                 r#"
 macro_rules! m {
     ($e:expr) => { "foo"; $e };
@@ -1605,7 +1595,7 @@ macro_rules! m {
 
 fn main() {
     let t @ ($0_0, _1) = (1,2);
-    m!((t).0);
+    m!(_0);
 }
                 "#,
             )
@@ -1653,7 +1643,6 @@ fn main() {
     m!(t, t.0);
 }
                 "#,
-                // FIXME: replace `t.0` in macro call (not IN macro) with `_0`
                 r#"
 macro_rules! m {
     ($t:expr, $i:expr) => { $t.0 + $i };
@@ -1661,10 +1650,9 @@ macro_rules! m {
 
 fn main() {
     let ($0_0, _1) = (1,2);
-    m!(/*t*/, /*t*/.0);
+    m!(t, _0);
 }
                 "#,
-                // FIXME: replace `t.0` in macro call with `_0`
                 r#"
 macro_rules! m {
     ($t:expr, $i:expr) => { $t.0 + $i };
@@ -1672,13 +1660,41 @@ macro_rules! m {
 
 fn main() {
     let t @ ($0_0, _1) = (1,2);
-    m!(t, t.0);
+    m!(t, _0);
 }
                 "#,
             )
         }
     }
 
+    mod in_macro_expr {
+        use super::assist::*;
+
+        // exact repro from #20716: tuple index inside write! must not panic
+        #[test]
+        fn tuple_index_in_write_macro() {
+            check_in_place_assist(
+                r#"
+//- minicore: write, fmt
+use core::fmt::Write;
+fn main() {
+    let mut s = String::new();
+    let $0x = (2i32, 3i32);
+    write!(s, "{}", x.0).unwrap();
+}
+"#,
+                r#"
+use core::fmt::Write;
+fn main() {
+    let mut s = String::new();
+    let ($0_0, _1) = (2i32, 3i32);
+    write!(s, "{}", _0).unwrap();
+}
+"#,
+            )
+        }
+    }
+
     mod refs {
         use super::assist::*;
 

From eba0efd9aaef79149de08d1affe969c5213c0fe7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Mon, 23 Mar 2026 12:11:17 +0100
Subject: [PATCH 0875/1059] Remove more `BuiltinLintDiag` in
 `rustc_attr_parsing`

---
 .../src/attributes/cfg_select.rs                | 14 ++++++++++----
 compiler/rustc_attr_parsing/src/errors.rs       | 17 +++++++++++++++++
 compiler/rustc_lint/src/early/diagnostics.rs    |  7 -------
 compiler/rustc_lint/src/lints.rs                | 17 -----------------
 compiler/rustc_lint_defs/src/lib.rs             |  4 ----
 5 files changed, 27 insertions(+), 32 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
index f3612afe69e5..4ff224006ca8 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
@@ -2,18 +2,18 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrStyle, NodeId, token};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Diagnostic;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath, Target};
 use rustc_parse::exp;
 use rustc_parse::parser::{Parser, Recovery};
 use rustc_session::Session;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::UNREACHABLE_CFG_SELECT_PREDICATES;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::parser::{AllowExprMetavar, MetaItemOrLitParser};
-use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
+use crate::{AttributeParser, ParsedDescription, ShouldEmit, errors, parse_cfg_entry};
 
 #[derive(Clone)]
 pub enum CfgSelectPredicate {
@@ -153,11 +153,17 @@ fn lint_unreachable(
 
     let branch_is_unreachable = |predicate: CfgSelectPredicate, wildcard_span| {
         let span = predicate.span();
-        p.psess.buffer_lint(
+        p.psess.dyn_buffer_lint(
             UNREACHABLE_CFG_SELECT_PREDICATES,
             span,
             lint_node_id,
-            BuiltinLintDiag::UnreachableCfg { span, wildcard_span },
+            move |dcx, level| match wildcard_span {
+                Some(wildcard_span) => {
+                    errors::UnreachableCfgSelectPredicateWildcard { span, wildcard_span }
+                        .into_diag(dcx, level)
+                }
+                None => errors::UnreachableCfgSelectPredicate { span }.into_diag(dcx, level),
+            },
         );
     };
 
diff --git a/compiler/rustc_attr_parsing/src/errors.rs b/compiler/rustc_attr_parsing/src/errors.rs
index 4eb9425b34bb..d4236416dd6a 100644
--- a/compiler/rustc_attr_parsing/src/errors.rs
+++ b/compiler/rustc_attr_parsing/src/errors.rs
@@ -26,6 +26,13 @@ pub(crate) struct ItemFollowingInnerAttr {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("unreachable configuration predicate")]
+pub(crate) struct UnreachableCfgSelectPredicate {
+    #[label("this configuration predicate is never reached")]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("most attributes are not supported in `where` clauses")]
 #[help("only `#[cfg]` and `#[cfg_attr]` are supported")]
@@ -33,3 +40,13 @@ pub(crate) struct UnsupportedAttributesInWhere {
     #[primary_span]
     pub span: MultiSpan,
 }
+
+#[derive(Diagnostic)]
+#[diag("unreachable configuration predicate")]
+pub(crate) struct UnreachableCfgSelectPredicateWildcard {
+    #[label("this configuration predicate is never reached")]
+    pub span: Span,
+
+    #[label("always matches")]
+    pub wildcard_span: Span,
+}
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 43bb3971d7ac..a6d7f0a11e32 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -224,13 +224,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 }
                 .into_diag(dcx, level)
             }
-            BuiltinLintDiag::UnreachableCfg { span, wildcard_span } => match wildcard_span {
-                Some(wildcard_span) => {
-                    lints::UnreachableCfgSelectPredicateWildcard { span, wildcard_span }
-                        .into_diag(dcx, level)
-                }
-                None => lints::UnreachableCfgSelectPredicate { span }.into_diag(dcx, level),
-            },
 
             BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
                 lints::UnusedCrateDependency { extern_crate, local_crate }.into_diag(dcx, level)
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index c7c92356c378..f9cc259bdf4f 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3709,23 +3709,6 @@ pub(crate) struct UnknownCrateTypesSuggestion {
     pub snippet: Symbol,
 }
 
-#[derive(Diagnostic)]
-#[diag("unreachable configuration predicate")]
-pub(crate) struct UnreachableCfgSelectPredicate {
-    #[label("this configuration predicate is never reached")]
-    pub span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag("unreachable configuration predicate")]
-pub(crate) struct UnreachableCfgSelectPredicateWildcard {
-    #[label("this configuration predicate is never reached")]
-    pub span: Span,
-
-    #[label("always matches")]
-    pub wildcard_span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("positional format arguments are not allowed here")]
 #[help(
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 0faa50442961..6314add5f1ae 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -732,10 +732,6 @@ pub enum BuiltinLintDiag {
         local_crate: Symbol,
     },
     AttributeLint(AttributeLintKind),
-    UnreachableCfg {
-        span: Span,
-        wildcard_span: Option<Span>,
-    },
 }
 
 #[derive(Debug, HashStable_Generic)]

From 45027f1788fb36818c3e93c759e4b6ffcdb2a6c8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Mon, 23 Mar 2026 19:00:34 +0100
Subject: [PATCH 0876/1059] Remove more `BuiltinLintDiag` in `rustc_middle`

---
 compiler/rustc_lint/src/early/diagnostics.rs  | 17 ----------
 compiler/rustc_lint_defs/src/lib.rs           |  7 ----
 compiler/rustc_middle/src/middle/stability.rs | 34 ++++++++++++-------
 3 files changed, 22 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index a6d7f0a11e32..6b145740d5f5 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -5,7 +5,6 @@
     elided_lifetime_in_path_suggestion,
 };
 use rustc_hir::lints::{AttributeLintKind, FormatWarning};
-use rustc_middle::middle::stability;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::lint::BuiltinLintDiag;
@@ -100,22 +99,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                     .collect();
                 lints::RedundantImport { subs, ident }.into_diag(dcx, level)
             }
-            BuiltinLintDiag::DeprecatedMacro {
-                suggestion,
-                suggestion_span,
-                note,
-                path,
-                since_kind,
-            } => {
-                let sub = suggestion.map(|suggestion| stability::DeprecationSuggestion {
-                    span: suggestion_span,
-                    kind: "macro".to_owned(),
-                    suggestion,
-                });
-
-                stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
-                    .into_diag(dcx, level)
-            }
             BuiltinLintDiag::SingleUseLifetime {
                 param_span,
                 use_span,
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 6314add5f1ae..f3014ef73366 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -666,13 +666,6 @@ pub enum BuiltinLintDiag {
         span_snippets: Vec<String>,
     },
     RedundantImport(Vec<(Span, bool)>, Ident),
-    DeprecatedMacro {
-        suggestion: Option<Symbol>,
-        suggestion_span: Span,
-        note: Option<Symbol>,
-        path: String,
-        since_kind: DeprecatedSinceKind,
-    },
     SingleUseLifetime {
         /// Span of the parameter which declares this lifetime.
         param_span: Span,
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index e76c9a8c0b5a..f9821c92df36 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -4,7 +4,7 @@
 use std::num::NonZero;
 
 use rustc_ast::NodeId;
-use rustc_errors::{Applicability, Diag, EmissionGuarantee, LintBuffer, msg};
+use rustc_errors::{Applicability, Diag, Diagnostic, EmissionGuarantee, LintBuffer, msg};
 use rustc_feature::GateIssue;
 use rustc_hir::attrs::{DeprecatedSince, Deprecation};
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -12,7 +12,7 @@
 use rustc_macros::{Decodable, Encodable, HashStable, Subdiagnostic};
 use rustc_session::Session;
 use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE};
-use rustc_session::lint::{BuiltinLintDiag, DeprecatedSinceKind, Level, Lint};
+use rustc_session::lint::{DeprecatedSinceKind, Level, Lint};
 use rustc_session::parse::feature_err_issue;
 use rustc_span::{Span, Symbol, sym};
 use tracing::debug;
@@ -187,23 +187,33 @@ fn deprecated_since_kind(is_in_effect: bool, since: DeprecatedSince) -> Deprecat
 pub fn early_report_macro_deprecation(
     lint_buffer: &mut LintBuffer,
     depr: &Deprecation,
-    span: Span,
+    suggestion_span: Span,
     node_id: NodeId,
     path: String,
 ) {
-    if span.in_derive_expansion() {
+    if suggestion_span.in_derive_expansion() {
         return;
     }
 
     let is_in_effect = depr.is_in_effect();
-    let diag = BuiltinLintDiag::DeprecatedMacro {
-        suggestion: depr.suggestion,
-        suggestion_span: span,
-        note: depr.note.map(|ident| ident.name),
-        path,
-        since_kind: deprecated_since_kind(is_in_effect, depr.since),
-    };
-    lint_buffer.buffer_lint(deprecation_lint(is_in_effect), node_id, span, diag);
+    let suggestion = depr.suggestion;
+    let note = depr.note.map(|ident| ident.name);
+    let since_kind = deprecated_since_kind(is_in_effect, depr.since);
+    lint_buffer.dyn_buffer_lint(
+        deprecation_lint(is_in_effect),
+        node_id,
+        suggestion_span,
+        move |dcx, level| {
+            let sub = suggestion.map(|suggestion| DeprecationSuggestion {
+                span: suggestion_span,
+                kind: "macro".to_owned(),
+                suggestion,
+            });
+
+            Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
+                .into_diag(dcx, level)
+        },
+    );
 }
 
 fn late_report_deprecation(

From 5d7f89417cf410f4da50ccba3c5a568a760a3cbd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Mon, 23 Mar 2026 21:14:54 +0100
Subject: [PATCH 0877/1059] Remove more `BuiltinLintDiag` in `rustc_resolve`

---
 compiler/rustc_lint/src/early/diagnostics.rs | 55 -----------
 compiler/rustc_lint/src/lints.rs             | 99 +-------------------
 compiler/rustc_lint_defs/src/lib.rs          | 32 +------
 compiler/rustc_resolve/src/check_unused.rs   |  4 +-
 compiler/rustc_resolve/src/errors.rs         | 96 +++++++++++++++++++
 compiler/rustc_resolve/src/imports.rs        | 46 ++++++---
 compiler/rustc_resolve/src/late.rs           | 12 ++-
 7 files changed, 143 insertions(+), 201 deletions(-)

diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 6b145740d5f5..9aefef1733b1 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -87,18 +87,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 }
                 .into_diag(dcx, level)
             }
-            BuiltinLintDiag::RedundantImport(spans, ident) => {
-                let subs = spans
-                    .into_iter()
-                    .map(|(span, is_imported)| match (span.is_dummy(), is_imported) {
-                        (false, true) => lints::RedundantImportSub::ImportedHere { span, ident },
-                        (false, false) => lints::RedundantImportSub::DefinedHere { span, ident },
-                        (true, true) => lints::RedundantImportSub::ImportedPrelude { span, ident },
-                        (true, false) => lints::RedundantImportSub::DefinedPrelude { span, ident },
-                    })
-                    .collect();
-                lints::RedundantImport { subs, ident }.into_diag(dcx, level)
-            }
             BuiltinLintDiag::SingleUseLifetime {
                 param_span,
                 use_span,
@@ -164,49 +152,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 }
                 .into_diag(dcx, level)
             }
-            BuiltinLintDiag::AmbiguousGlobReexports {
-                name,
-                namespace,
-                first_reexport_span,
-                duplicate_reexport_span,
-            } => lints::AmbiguousGlobReexports {
-                first_reexport: first_reexport_span,
-                duplicate_reexport: duplicate_reexport_span,
-                name,
-                namespace,
-            }
-            .into_diag(dcx, level),
-            BuiltinLintDiag::HiddenGlobReexports {
-                name,
-                namespace,
-                glob_reexport_span,
-                private_item_span,
-            } => lints::HiddenGlobReexports {
-                glob_reexport: glob_reexport_span,
-                private_item: private_item_span,
-
-                name,
-                namespace,
-            }
-            .into_diag(dcx, level),
-            BuiltinLintDiag::UnusedQualifications { removal_span } => {
-                lints::UnusedQualifications { removal_span }.into_diag(dcx, level)
-            }
-            BuiltinLintDiag::AssociatedConstElidedLifetime {
-                elided,
-                span: lt_span,
-                lifetimes_in_scope,
-            } => {
-                let lt_span = if elided { lt_span.shrink_to_hi() } else { lt_span };
-                let code = if elided { "'static " } else { "'static" };
-                lints::AssociatedConstElidedLifetime {
-                    span: lt_span,
-                    code,
-                    elided,
-                    lifetimes_in_scope,
-                }
-                .into_diag(dcx, level)
-            }
 
             BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
                 lints::UnusedCrateDependency { extern_crate, local_crate }.into_diag(dcx, level)
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index f9cc259bdf4f..b40dcb70d780 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -6,8 +6,7 @@
 use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, DiagMessage, DiagStyledString, Diagnostic,
-    ElidedLifetimeInPathSubdiag, EmissionGuarantee, Level, MultiSpan, Subdiagnostic,
-    SuggestionStyle, msg,
+    ElidedLifetimeInPathSubdiag, EmissionGuarantee, Level, Subdiagnostic, SuggestionStyle, msg,
 };
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
@@ -3089,42 +3088,6 @@ pub(crate) enum UnusedImportsSugg {
     },
 }
 
-#[derive(Diagnostic)]
-#[diag("the item `{$ident}` is imported redundantly")]
-pub(crate) struct RedundantImport {
-    #[subdiagnostic]
-    pub subs: Vec<RedundantImportSub>,
-    pub ident: Ident,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum RedundantImportSub {
-    #[label("the item `{$ident}` is already imported here")]
-    ImportedHere {
-        #[primary_span]
-        span: Span,
-        ident: Ident,
-    },
-    #[label("the item `{$ident}` is already defined here")]
-    DefinedHere {
-        #[primary_span]
-        span: Span,
-        ident: Ident,
-    },
-    #[label("the item `{$ident}` is already imported by the extern prelude")]
-    ImportedPrelude {
-        #[primary_span]
-        span: Span,
-        ident: Ident,
-    },
-    #[label("the item `{$ident}` is already defined by the extern prelude")]
-    DefinedPrelude {
-        #[primary_span]
-        span: Span,
-        ident: Ident,
-    },
-}
-
 #[derive(Diagnostic)]
 #[diag("lifetime parameter `{$ident}` only used once")]
 pub(crate) struct SingleUseLifetime {
@@ -3168,66 +3131,6 @@ pub(crate) struct NamedArgumentUsedPositionally {
     pub named_arg_name: String,
 }
 
-#[derive(Diagnostic)]
-#[diag("ambiguous glob re-exports")]
-pub(crate) struct AmbiguousGlobReexports {
-    #[label("the name `{$name}` in the {$namespace} namespace is first re-exported here")]
-    pub first_reexport: Span,
-    #[label("but the name `{$name}` in the {$namespace} namespace is also re-exported here")]
-    pub duplicate_reexport: Span,
-
-    pub name: String,
-    pub namespace: String,
-}
-
-#[derive(Diagnostic)]
-#[diag("private item shadows public glob re-export")]
-pub(crate) struct HiddenGlobReexports {
-    #[note(
-        "the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here"
-    )]
-    pub glob_reexport: Span,
-    #[note("but the private item here shadows it")]
-    pub private_item: Span,
-
-    pub name: String,
-    pub namespace: String,
-}
-
-#[derive(Diagnostic)]
-#[diag("unnecessary qualification")]
-pub(crate) struct UnusedQualifications {
-    #[suggestion(
-        "remove the unnecessary path segments",
-        style = "verbose",
-        code = "",
-        applicability = "machine-applicable"
-    )]
-    pub removal_span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(
-    "{$elided ->
-        [true] `&` without an explicit lifetime name cannot be used here
-        *[false] `'_` cannot be used here
-    }"
-)]
-pub(crate) struct AssociatedConstElidedLifetime {
-    #[suggestion(
-        "use the `'static` lifetime",
-        style = "verbose",
-        code = "{code}",
-        applicability = "machine-applicable"
-    )]
-    pub span: Span,
-
-    pub code: &'static str,
-    pub elided: bool,
-    #[note("cannot automatically infer `'static` because of other lifetimes in scope")]
-    pub lifetimes_in_scope: MultiSpan,
-}
-
 #[derive(Diagnostic)]
 #[diag("creating a {$shared_label}reference to mutable static")]
 pub(crate) struct RefOfMutStatic<'a> {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index f3014ef73366..2cd0498f0994 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -7,7 +7,7 @@
 use rustc_data_structures::stable_hasher::{
     HashStable, StableCompare, StableHasher, ToStableHashKey,
 };
-use rustc_error_messages::{DiagArgValue, IntoDiagArg, MultiSpan};
+use rustc_error_messages::{DiagArgValue, IntoDiagArg};
 use rustc_hir_id::{HashStableContext, HirId, ItemLocalId};
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::def_id::DefPathHash;
@@ -665,7 +665,6 @@ pub enum BuiltinLintDiag {
         test_module_span: Option<Span>,
         span_snippets: Vec<String>,
     },
-    RedundantImport(Vec<(Span, bool)>, Ident),
     SingleUseLifetime {
         /// Span of the parameter which declares this lifetime.
         param_span: Span,
@@ -691,35 +690,6 @@ pub enum BuiltinLintDiag {
         /// Indicates if the named argument is used as a width/precision for formatting
         is_formatting_arg: bool,
     },
-    AmbiguousGlobReexports {
-        /// The name for which collision(s) have occurred.
-        name: String,
-        /// The name space for which the collision(s) occurred in.
-        namespace: String,
-        /// Span where the name is first re-exported.
-        first_reexport_span: Span,
-        /// Span where the same name is also re-exported.
-        duplicate_reexport_span: Span,
-    },
-    HiddenGlobReexports {
-        /// The name of the local binding which shadows the glob re-export.
-        name: String,
-        /// The namespace for which the shadowing occurred in.
-        namespace: String,
-        /// The glob reexport that is shadowed by the local binding.
-        glob_reexport_span: Span,
-        /// The local binding that shadows the glob reexport.
-        private_item_span: Span,
-    },
-    UnusedQualifications {
-        /// The span of the unnecessarily-qualified path to remove.
-        removal_span: Span,
-    },
-    AssociatedConstElidedLifetime {
-        elided: bool,
-        span: Span,
-        lifetimes_in_scope: MultiSpan,
-    },
     UnusedCrateDependency {
         extern_crate: Symbol,
         local_crate: Symbol,
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 45fdea82d47b..8e150b7f3a5d 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -36,7 +36,7 @@
 use rustc_span::{DUMMY_SP, Ident, Span, kw};
 
 use crate::imports::{Import, ImportKind};
-use crate::{DeclKind, IdentKey, LateDecl, Resolver, module_to_string};
+use crate::{DeclKind, IdentKey, LateDecl, Resolver, errors, module_to_string};
 
 struct UnusedImport {
     use_tree: ast::UseTree,
@@ -554,7 +554,7 @@ pub(crate) fn check_unused(&mut self, krate: &ast::Crate) {
                 UNUSED_QUALIFICATIONS,
                 unn_qua.node_id,
                 unn_qua.path_span,
-                BuiltinLintDiag::UnusedQualifications { removal_span: unn_qua.removal_span },
+                errors::UnusedQualifications { removal_span: unn_qua.removal_span },
             );
         }
 
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 25c7c625ff93..c9dad4dcd4a7 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1592,3 +1592,99 @@ pub(crate) struct UnusedLifetime {
 
     pub ident: Ident,
 }
+
+#[derive(Diagnostic)]
+#[diag("ambiguous glob re-exports")]
+pub(crate) struct AmbiguousGlobReexports {
+    #[label("the name `{$name}` in the {$namespace} namespace is first re-exported here")]
+    pub first_reexport: Span,
+    #[label("but the name `{$name}` in the {$namespace} namespace is also re-exported here")]
+    pub duplicate_reexport: Span,
+
+    pub name: String,
+    pub namespace: String,
+}
+
+#[derive(Diagnostic)]
+#[diag("private item shadows public glob re-export")]
+pub(crate) struct HiddenGlobReexports {
+    #[note(
+        "the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here"
+    )]
+    pub glob_reexport: Span,
+    #[note("but the private item here shadows it")]
+    pub private_item: Span,
+
+    pub name: String,
+    pub namespace: String,
+}
+
+#[derive(Diagnostic)]
+#[diag("the item `{$ident}` is imported redundantly")]
+pub(crate) struct RedundantImport {
+    #[subdiagnostic]
+    pub subs: Vec<RedundantImportSub>,
+    pub ident: Ident,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum RedundantImportSub {
+    #[label("the item `{$ident}` is already imported here")]
+    ImportedHere {
+        #[primary_span]
+        span: Span,
+        ident: Ident,
+    },
+    #[label("the item `{$ident}` is already defined here")]
+    DefinedHere {
+        #[primary_span]
+        span: Span,
+        ident: Ident,
+    },
+    #[label("the item `{$ident}` is already imported by the extern prelude")]
+    ImportedPrelude {
+        #[primary_span]
+        span: Span,
+        ident: Ident,
+    },
+    #[label("the item `{$ident}` is already defined by the extern prelude")]
+    DefinedPrelude {
+        #[primary_span]
+        span: Span,
+        ident: Ident,
+    },
+}
+
+#[derive(Diagnostic)]
+#[diag("unnecessary qualification")]
+pub(crate) struct UnusedQualifications {
+    #[suggestion(
+        "remove the unnecessary path segments",
+        style = "verbose",
+        code = "",
+        applicability = "machine-applicable"
+    )]
+    pub removal_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(
+    "{$elided ->
+        [true] `&` without an explicit lifetime name cannot be used here
+        *[false] `'_` cannot be used here
+    }"
+)]
+pub(crate) struct AssociatedConstElidedLifetime {
+    #[suggestion(
+        "use the `'static` lifetime",
+        style = "verbose",
+        code = "{code}",
+        applicability = "machine-applicable"
+    )]
+    pub span: Span,
+
+    pub code: &'static str,
+    pub elided: bool,
+    #[note("cannot automatically infer `'static` because of other lifetimes in scope")]
+    pub lifetimes_in_scope: MultiSpan,
+}
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 8f534de0f76d..6507ee347737 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -6,13 +6,12 @@
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
+use rustc_errors::{Applicability, Diagnostic, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir::def::{self, DefKind, PartialRes};
 use rustc_hir::def_id::{DefId, LocalDefIdMap};
 use rustc_middle::metadata::{AmbigModChild, ModChild, Reexport};
 use rustc_middle::span_bug;
 use rustc_middle::ty::Visibility;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     AMBIGUOUS_GLOB_REEXPORTS, EXPORTED_PRIVATE_DEPENDENCIES, HIDDEN_GLOB_REEXPORTS,
     PUB_USE_OF_PRIVATE_EXTERN_CRATE, REDUNDANT_IMPORTS, UNUSED_IMPORTS,
@@ -26,9 +25,10 @@
 use crate::Namespace::{self, *};
 use crate::diagnostics::{DiagMode, Suggestion, import_candidates};
 use crate::errors::{
-    CannotBeReexportedCratePublic, CannotBeReexportedCratePublicNS, CannotBeReexportedPrivate,
-    CannotBeReexportedPrivateNS, CannotDetermineImportResolution, CannotGlobImportAllCrates,
-    ConsiderAddingMacroExport, ConsiderMarkingAsPub, ConsiderMarkingAsPubCrate,
+    self, CannotBeReexportedCratePublic, CannotBeReexportedCratePublicNS,
+    CannotBeReexportedPrivate, CannotBeReexportedPrivateNS, CannotDetermineImportResolution,
+    CannotGlobImportAllCrates, ConsiderAddingMacroExport, ConsiderMarkingAsPub,
+    ConsiderMarkingAsPubCrate,
 };
 use crate::ref_mut::CmCell;
 use crate::{
@@ -721,11 +721,11 @@ pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<Decl<'ra
                         AMBIGUOUS_GLOB_REEXPORTS,
                         import.root_id,
                         import.root_span,
-                        BuiltinLintDiag::AmbiguousGlobReexports {
+                        errors::AmbiguousGlobReexports {
                             name: key.ident.name.to_string(),
                             namespace: key.ns.descr().to_string(),
-                            first_reexport_span: import.root_span,
-                            duplicate_reexport_span: amb_binding.span,
+                            first_reexport: import.root_span,
+                            duplicate_reexport: amb_binding.span,
                         },
                     );
                 }
@@ -753,11 +753,11 @@ pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<Decl<'ra
                                 HIDDEN_GLOB_REEXPORTS,
                                 binding_id,
                                 binding.span,
-                                BuiltinLintDiag::HiddenGlobReexports {
+                                errors::HiddenGlobReexports {
                                     name: key.ident.name.to_string(),
                                     namespace: key.ns.descr().to_owned(),
-                                    glob_reexport_span: glob_decl.span,
-                                    private_item_span: binding.span,
+                                    glob_reexport: glob_decl.span,
+                                    private_item: binding.span,
                                 },
                             );
                         }
@@ -1535,11 +1535,31 @@ pub(crate) fn check_for_redundant_imports(&mut self, import: Import<'ra>) -> boo
             let mut redundant_spans: Vec<_> = redundant_span.present_items().collect();
             redundant_spans.sort();
             redundant_spans.dedup();
-            self.lint_buffer.buffer_lint(
+            self.lint_buffer.dyn_buffer_lint(
                 REDUNDANT_IMPORTS,
                 id,
                 import.span,
-                BuiltinLintDiag::RedundantImport(redundant_spans, source),
+                move |dcx, level| {
+                    let ident = source;
+                    let subs = redundant_spans
+                        .into_iter()
+                        .map(|(span, is_imported)| match (span.is_dummy(), is_imported) {
+                            (false, true) => {
+                                errors::RedundantImportSub::ImportedHere { span, ident }
+                            }
+                            (false, false) => {
+                                errors::RedundantImportSub::DefinedHere { span, ident }
+                            }
+                            (true, true) => {
+                                errors::RedundantImportSub::ImportedPrelude { span, ident }
+                            }
+                            (true, false) => {
+                                errors::RedundantImportSub::DefinedPrelude { span, ident }
+                            }
+                        })
+                        .collect();
+                    errors::RedundantImport { subs, ident }.into_diag(dcx, level)
+                },
             );
             return true;
         }
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index a484a5136db5..c908b6a007aa 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -1882,13 +1882,21 @@ fn resolve_anonymous_lifetime(
                         );
                         return;
                     } else if emit_lint {
+                        let lt_span = if elided {
+                            lifetime.ident.span.shrink_to_hi()
+                        } else {
+                            lifetime.ident.span
+                        };
+                        let code = if elided { "'static " } else { "'static" };
+
                         self.r.lint_buffer.buffer_lint(
                             lint::builtin::ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
                             node_id,
                             lifetime.ident.span,
-                            lint::BuiltinLintDiag::AssociatedConstElidedLifetime {
+                            crate::errors::AssociatedConstElidedLifetime {
                                 elided,
-                                span: lifetime.ident.span,
+                                code,
+                                span: lt_span,
                                 lifetimes_in_scope: lifetimes_in_scope.into(),
                             },
                         );

From 2db5d1ffdb6d7efdfa722221c0b5dd6093e1881d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 23 Mar 2026 22:59:16 +0800
Subject: [PATCH 0878/1059] cover_edit_range uses SyntaxNode instead AstNode

---
 .../src/handlers/convert_named_struct_to_tuple_struct.rs  | 6 +++---
 .../src/handlers/convert_tuple_struct_to_named_struct.rs  | 8 ++++----
 .../src/handlers/destructure_struct_binding.rs            | 2 +-
 .../ide-assists/src/handlers/destructure_tuple_binding.rs | 2 +-
 src/tools/rust-analyzer/crates/ide-assists/src/utils.rs   | 4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
index 42fceb85336b..4dd2036c024c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
@@ -242,7 +242,7 @@ fn record_to_tuple_struct_like<T, I>(
 {
     let make = SyntaxFactory::without_mappings();
     let orig = ctx.sema.original_range_opt(field_list.syntax())?;
-    let list_range = cover_edit_range(source, orig.range);
+    let list_range = cover_edit_range(source.syntax(), orig.range);
 
     let l_curly = match list_range.start() {
         NodeOrToken::Node(node) => node.first_token()?,
@@ -265,7 +265,7 @@ fn record_to_tuple_struct_like<T, I>(
 
     for name_ref in fields(&field_list) {
         let Some(orig) = ctx.sema.original_range_opt(name_ref.syntax()) else { continue };
-        let name_range = cover_edit_range(source, orig.range);
+        let name_range = cover_edit_range(source.syntax(), orig.range);
 
         if let Some(colon) = next_non_trivia_token(name_range.end().clone())
             && colon.kind() == T![:]
@@ -306,7 +306,7 @@ fn edit_field_references(
                     // Only edit the field reference if it's part of a `.field` access
                     if name_ref.syntax().parent().and_then(ast::FieldExpr::cast).is_some() {
                         edit.replace_all(
-                            cover_edit_range(&source, r.range),
+                            cover_edit_range(source.syntax(), r.range),
                             vec![make.name_ref(&index.to_string()).syntax().clone().into()],
                         );
                     }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
index f1eae8386637..270467b14f0c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -191,7 +191,7 @@ fn process_struct_name_reference(
                     full_path,
                     generate_record_pat_list(&tuple_struct_pat, names),
                 );
-                editor.replace_all(cover_edit_range(source, range), vec![new.syntax().clone().into()]);
+                editor.replace_all(cover_edit_range(source.syntax(), range), vec![new.syntax().clone().into()]);
             },
             ast::PathExpr(path_expr) => {
                 let call_expr = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
@@ -207,7 +207,7 @@ fn process_struct_name_reference(
                 let mut first_insert = vec![];
                 for (expr, name) in arg_list.args().zip(names) {
                     let range = ctx.sema.original_range_opt(expr.syntax())?.range;
-                    let place = cover_edit_range(source, range);
+                    let place = cover_edit_range(source.syntax(), range);
                     let elements = vec![
                         make.name_ref(&name.text()).syntax().clone().into(),
                         make.token(T![:]).into(),
@@ -236,7 +236,7 @@ fn process_delimiter(
     first_insert: Vec<syntax::SyntaxElement>,
 ) {
     let Some(range) = ctx.sema.original_range_opt(list.syntax()) else { return };
-    let place = cover_edit_range(source, range.range);
+    let place = cover_edit_range(source.syntax(), range.range);
 
     let l_paren = match place.start() {
         syntax::NodeOrToken::Node(node) => node.first_token(),
@@ -290,7 +290,7 @@ fn edit_field_references(
                     && let Some(original) = ctx.sema.original_range_opt(name_ref.syntax())
                 {
                     editor.replace_all(
-                        cover_edit_range(&source, original.range),
+                        cover_edit_range(source.syntax(), original.range),
                         vec![name.syntax().clone().into()],
                     );
                 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 3f42696fa39f..ec4a83b642c0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -358,7 +358,7 @@ fn update_usages(
     data: &StructEditData,
     field_names: &FxHashMap<SmolStr, SmolStr>,
 ) {
-    let source = ctx.source_file();
+    let source = ctx.source_file().syntax();
     let make = SyntaxFactory::with_mappings();
     let edits = data
         .usages
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
index 583ba42bf5b8..23c11b258c1a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_tuple_binding.rs
@@ -326,7 +326,7 @@ fn apply(
             }
             EditTupleUsage::ReplaceExpr(target_expr, replace_with) => {
                 if let Some(range) = ctx.sema.original_range_opt(target_expr.syntax()) {
-                    let source = ctx.source_file();
+                    let source = ctx.source_file().syntax();
                     syntax_editor.replace_all(
                         cover_edit_range(source, range.range),
                         vec![replace_with.syntax().clone().into()],
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 0f28a202253c..2f40f889fcce 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1219,10 +1219,10 @@ pub(crate) fn cover_let_chain(mut expr: ast::Expr, range: TextRange) -> Option<a
 }
 
 pub(crate) fn cover_edit_range(
-    source: &impl AstNode,
+    source: &SyntaxNode,
     range: TextRange,
 ) -> std::ops::RangeInclusive<syntax::SyntaxElement> {
-    let node = match source.syntax().covering_element(range) {
+    let node = match source.covering_element(range) {
         NodeOrToken::Node(node) => node,
         NodeOrToken::Token(t) => t.parent().unwrap(),
     };

From bf8178627c7140f86387eb94b942d39577642161 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 4 Mar 2026 12:02:07 +0800
Subject: [PATCH 0879/1059] fix: keep comments for 'Fill match arms'

Example
---
```rust
enum E { A, B, C }

fn foo(t: E) -> i32 {
    match $0t {
        // variant a
        E::A => 2
        // comment on end
    }
}
```

**Before this PR**

```rust
enum E { A, B, C }

fn foo(t: E) -> i32 {
    match t {
        E::A => 2,
        E::B => ${1:todo!()},
        E::C => ${2:todo!()},$0
    }
}
```

**After this PR**

```rust
enum E { A, B, C }

fn foo(t: E) -> i32 {
    match t {
        // variant a
        E::A => 2,
        // comment on end
        E::B => ${1:todo!()},
        E::C => ${2:todo!()},$0
    }
}
```
---
 .../src/handlers/add_missing_match_arms.rs    | 173 ++++++++++++++----
 1 file changed, 137 insertions(+), 36 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 95712707589e..947766624234 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -6,10 +6,11 @@
 use ide_db::syntax_helpers::suggest_name;
 use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast};
 use itertools::Itertools;
-use syntax::ToSmolStr;
-use syntax::ast::edit::{AstNodeEdit, IndentLevel};
+use syntax::ast::edit::IndentLevel;
 use syntax::ast::syntax_factory::SyntaxFactory;
 use syntax::ast::{self, AstNode, MatchArmList, MatchExpr, Pat, make};
+use syntax::syntax_editor::{Position, SyntaxEditor};
+use syntax::{SyntaxKind, SyntaxNode, ToSmolStr};
 
 use crate::{AssistContext, AssistId, Assists, utils};
 
@@ -223,32 +224,13 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             // having any hidden variants means that we need a catch-all arm
             needs_catch_all_arm |= has_hidden_variants;
 
-            let missing_arms = missing_pats
+            let mut missing_arms = missing_pats
                 .filter(|(_, hidden)| {
                     // filter out hidden patterns because they're handled by the catch-all arm
                     !hidden
                 })
-                .map(|(pat, _)| make.match_arm(pat, None, utils::expr_fill_default(ctx.config)));
-
-            let mut arms: Vec<_> = match_arm_list
-                .arms()
-                .filter(|arm| {
-                    if matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))) {
-                        if arm.expr().is_none_or(is_empty_expr) {
-                            false
-                        } else {
-                            cov_mark::hit!(add_missing_match_arms_empty_expr);
-                            true
-                        }
-                    } else {
-                        true
-                    }
-                })
-                .map(|arm| arm.reset_indent().indent(IndentLevel(1)))
-                .collect();
-
-            let first_new_arm_idx = arms.len();
-            arms.extend(missing_arms);
+                .map(|(pat, _)| make.match_arm(pat, None, utils::expr_fill_default(ctx.config)))
+                .collect::<Vec<_>>();
 
             if needs_catch_all_arm && !has_catch_all_arm {
                 cov_mark::hit!(added_wildcard_pattern);
@@ -257,13 +239,11 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                     None,
                     utils::expr_fill_default(ctx.config),
                 );
-                arms.push(arm);
+                missing_arms.push(arm);
             }
 
-            let new_match_arm_list = make.match_arm_list(arms);
-
             // FIXME: Hack for syntax trees not having great support for macros
-            // Just replace the element that the original range came from
+            // Just edit the element that the original range came from
             let old_place = {
                 // Find the original element
                 let file = ctx.sema.parse(arm_list_range.file_id);
@@ -280,25 +260,27 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             };
 
             let mut editor = builder.make_editor(&old_place);
-            let new_match_arm_list = new_match_arm_list.indent(IndentLevel::from_node(&old_place));
-            editor.replace(old_place, new_match_arm_list.syntax());
+            let mut arms_edit = ArmsEdit { match_arm_list, place: old_place, last_arm: None };
+
+            arms_edit.remove_wildcard_arms(ctx, &mut editor);
+            arms_edit.add_comma_after_last_arm(ctx, &mut editor);
+            arms_edit.append_arms(&missing_arms, &mut editor);
 
             if let Some(cap) = ctx.config.snippet_cap {
-                if let Some(it) = new_match_arm_list
-                    .arms()
-                    .nth(first_new_arm_idx)
+                if let Some(it) = missing_arms
+                    .first()
                     .and_then(|arm| arm.syntax().descendants().find_map(ast::WildcardPat::cast))
                 {
                     editor.add_annotation(it.syntax(), builder.make_placeholder_snippet(cap));
                 }
 
-                for arm in new_match_arm_list.arms().skip(first_new_arm_idx) {
+                for arm in &missing_arms {
                     if let Some(expr) = arm.expr() {
                         editor.add_annotation(expr.syntax(), builder.make_placeholder_snippet(cap));
                     }
                 }
 
-                if let Some(arm) = new_match_arm_list.arms().skip(first_new_arm_idx).last() {
+                if let Some(arm) = missing_arms.last() {
                     editor.add_annotation(arm.syntax(), builder.make_tabstop_after(cap));
                 }
             }
@@ -357,6 +339,96 @@ fn cursor_at_trivial_match_arm_list(
     None
 }
 
+struct ArmsEdit {
+    match_arm_list: MatchArmList,
+    place: SyntaxNode,
+    last_arm: Option<ast::MatchArm>,
+}
+
+impl ArmsEdit {
+    fn remove_wildcard_arms(&mut self, ctx: &AssistContext<'_>, editor: &mut SyntaxEditor) {
+        for arm in self.match_arm_list.arms() {
+            if !matches!(arm.pat(), Some(Pat::WildcardPat(_))) {
+                self.last_arm = Some(arm);
+                continue;
+            }
+            if !arm.expr().is_none_or(is_empty_expr) {
+                cov_mark::hit!(add_missing_match_arms_empty_expr);
+                self.last_arm = Some(arm);
+                continue;
+            }
+            let Some(range) = self.cover_edit_range(ctx, &arm) else { continue };
+
+            let prev = match range.start() {
+                syntax::NodeOrToken::Node(node) => {
+                    node.first_token().and_then(|it| it.prev_token())
+                }
+                syntax::NodeOrToken::Token(tok) => tok.prev_token(),
+            };
+            if let Some(prev) = prev
+                && prev.kind() == SyntaxKind::WHITESPACE
+            {
+                editor.delete(prev);
+            }
+
+            editor.delete_all(range);
+        }
+    }
+
+    fn append_arms(&self, arms: &[ast::MatchArm], editor: &mut SyntaxEditor) {
+        let Some(mut before) = self.place.last_token() else {
+            stdx::never!("match arm list not contain any token");
+            return;
+        };
+        if let Some(prev) = before.prev_token()
+            && prev.kind() == SyntaxKind::WHITESPACE
+        {
+            before = prev;
+        }
+        let open_curly =
+            !self.place.text().contains_char('\n') || before.kind() == SyntaxKind::WHITESPACE;
+        let indent = IndentLevel::from_node(&self.place);
+        let arm_indent = indent + 1;
+        let indent = make::tokens::whitespace(&format!("\n{indent}"));
+        let arm_indent = make::tokens::whitespace(&format!("\n{arm_indent}"));
+        let elements = arms
+            .iter()
+            .flat_map(|arm| [arm_indent.clone().into(), arm.syntax().clone().into()])
+            .chain(open_curly.then(|| indent.clone().into()))
+            .collect();
+
+        if before.kind() == SyntaxKind::WHITESPACE {
+            editor.replace_with_many(before, elements);
+        } else {
+            editor.insert_all(Position::before(before), elements);
+        }
+    }
+
+    fn add_comma_after_last_arm(&self, ctx: &AssistContext<'_>, editor: &mut SyntaxEditor) {
+        if let Some(last_arm) = &self.last_arm
+            && last_arm.comma_token().is_none()
+            && last_arm.expr().is_none_or(|it| !it.is_block_like())
+            && let Some(range) = self.cover_edit_range(ctx, last_arm)
+        {
+            editor.insert(Position::after(range.end()), make::token(syntax::T![,]));
+        }
+    }
+
+    fn cover_edit_range(
+        &self,
+        ctx: &AssistContext<'_>,
+        node: &impl AstNode,
+    ) -> Option<std::ops::RangeInclusive<syntax::SyntaxElement>> {
+        let range = ctx.sema.original_range_opt(node.syntax())?;
+
+        if !self.place.text_range().contains_range(range.range) {
+            return None;
+        }
+
+        Some(utils::cover_edit_range(&self.place, range.range))
+    }
+}
+
 fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
     !existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
 }
@@ -1734,7 +1806,7 @@ enum Test {
 
 fn foo(t: Test) {
     m!(match t {
-        Test::A=>(),
+        Test::A => (),
         Test::B => ${1:todo!()},
         Test::C => ${2:todo!()},$0
     });
@@ -2172,6 +2244,35 @@ fn foo(t: E) {
         );
     }
 
+    #[test]
+    fn keep_comments() {
+        check_assist(
+            add_missing_match_arms,
+            r#"
+enum E { A, B, C }
+
+fn foo(t: E) -> i32 {
+    match $0t {
+        // variant a
+        E::A => 2
+        // comment on end
+    }
+}"#,
+            r#"
+enum E { A, B, C }
+
+fn foo(t: E) -> i32 {
+    match t {
+        // variant a
+        E::A => 2,
+        // comment on end
+        E::B => ${1:todo!()},
+        E::C => ${2:todo!()},$0
+    }
+}"#,
+        );
+    }
+
     #[test]
     fn not_applicable_when_match_arm_list_cannot_be_upmapped() {
         check_assist_not_applicable(

From 86062ebeb0031e892ab006f9af73f83baae31d7f Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 23 Mar 2026 23:07:43 +0800
Subject: [PATCH 0880/1059] Uses SyntaxFactory to edit arms

---
 .../src/handlers/add_missing_match_arms.rs    | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 947766624234..1749db1e61b4 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -263,8 +263,8 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             let mut arms_edit = ArmsEdit { match_arm_list, place: old_place, last_arm: None };
 
             arms_edit.remove_wildcard_arms(ctx, &mut editor);
-            arms_edit.add_comma_after_last_arm(ctx, &mut editor);
-            arms_edit.append_arms(&missing_arms, &mut editor);
+            arms_edit.add_comma_after_last_arm(ctx, &make, &mut editor);
+            arms_edit.append_arms(&missing_arms, &make, &mut editor);
 
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(it) = missing_arms
@@ -375,7 +375,7 @@ fn remove_wildcard_arms(&mut self, ctx: &AssistContext<'_>, editor: &mut SyntaxE
         }
     }
 
-    fn append_arms(&self, arms: &[ast::MatchArm], editor: &mut SyntaxEditor) {
+    fn append_arms(&self, arms: &[ast::MatchArm], make: &SyntaxFactory, editor: &mut SyntaxEditor) {
         let Some(mut before) = self.place.last_token() else {
             stdx::never!("match arm list not contain any token");
             return;
@@ -389,8 +389,8 @@ fn append_arms(&self, arms: &[ast::MatchArm], editor: &mut SyntaxEditor) {
             !self.place.text().contains_char('\n') || before.kind() == SyntaxKind::WHITESPACE;
         let indent = IndentLevel::from_node(&self.place);
         let arm_indent = indent + 1;
-        let indent = make::tokens::whitespace(&format!("\n{indent}"));
-        let arm_indent = make::tokens::whitespace(&format!("\n{arm_indent}"));
+        let indent = make.whitespace(&format!("\n{indent}"));
+        let arm_indent = make.whitespace(&format!("\n{arm_indent}"));
         let elements = arms
             .iter()
             .flat_map(|arm| [arm_indent.clone().into(), arm.syntax().clone().into()])
@@ -404,13 +404,18 @@ fn append_arms(&self, arms: &[ast::MatchArm], editor: &mut SyntaxEditor) {
         }
     }
 
-    fn add_comma_after_last_arm(&self, ctx: &AssistContext<'_>, editor: &mut SyntaxEditor) {
+    fn add_comma_after_last_arm(
+        &self,
+        ctx: &AssistContext<'_>,
+        make: &SyntaxFactory,
+        editor: &mut SyntaxEditor,
+    ) {
         if let Some(last_arm) = &self.last_arm
             && last_arm.comma_token().is_none()
             && last_arm.expr().is_none_or(|it| !it.is_block_like())
             && let Some(range) = self.cover_edit_range(ctx, last_arm)
         {
-            editor.insert(Position::after(range.end()), make::token(syntax::T![,]));
+            editor.insert(Position::after(range.end()), make.token(syntax::T![,]));
         }
     }
 

From 1d325ce4367f5a3c0bfd68859af8752e9ea61885 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Tue, 24 Mar 2026 14:16:36 +0300
Subject: [PATCH 0881/1059] Eliminate usage of AST from generics creation

---
 compiler/rustc_ast_lowering/src/delegation.rs |  50 +--
 .../src/delegation/generics.rs                | 390 ++++++------------
 compiler/rustc_ast_lowering/src/lib.rs        |   4 +-
 compiler/rustc_hir/src/hir.rs                 |  40 +-
 .../src/collect/resolve_bound_vars.rs         |   2 +-
 .../src/hir_ty_lowering/mod.rs                |  19 +-
 .../generics/const-type-ice-153433.rs         |   8 +
 .../generics/const-type-ice-153433.stderr     |   9 +
 .../generics/const-type-ice-153499.rs         |  13 +
 .../generics/const-type-ice-153499.stderr     |  30 ++
 10 files changed, 249 insertions(+), 316 deletions(-)
 create mode 100644 tests/ui/delegation/generics/const-type-ice-153433.rs
 create mode 100644 tests/ui/delegation/generics/const-type-ice-153433.stderr
 create mode 100644 tests/ui/delegation/generics/const-type-ice-153499.rs
 create mode 100644 tests/ui/delegation/generics/const-type-ice-153499.stderr

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 0044913721f1..03acf40ef5fe 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -146,12 +146,10 @@ pub(crate) fn lower_delegation(
 
                 let (param_count, c_variadic) = self.param_count(sig_id);
 
-                let mut generics =
-                    self.lower_delegation_generics(delegation, sig_id, item_id, span);
+                let mut generics = self.uplift_delegation_generics(delegation, sig_id, item_id);
 
                 let body_id = self.lower_delegation_body(
                     delegation,
-                    item_id,
                     is_method,
                     param_count,
                     &mut generics,
@@ -166,10 +164,8 @@ pub(crate) fn lower_delegation(
 
                 let generics = self.arena.alloc(hir::Generics {
                     has_where_clause_predicates: false,
-                    params: self.arena.alloc_from_iter(generics.all_params(item_id, span, self)),
-                    predicates: self
-                        .arena
-                        .alloc_from_iter(generics.all_predicates(item_id, span, self)),
+                    params: self.arena.alloc_from_iter(generics.all_params(span, self)),
+                    predicates: self.arena.alloc_from_iter(generics.all_predicates(span, self)),
                     span,
                     where_clause_span: span,
                 });
@@ -294,19 +290,22 @@ fn lower_delegation_decl(
         let decl_param_count = param_count - c_variadic as usize;
         let inputs = self.arena.alloc_from_iter((0..decl_param_count).map(|arg| hir::Ty {
             hir_id: self.next_id(),
-            kind: hir::TyKind::InferDelegation(sig_id, hir::InferDelegationKind::Input(arg)),
+            kind: hir::TyKind::InferDelegation(hir::InferDelegation::Sig(
+                sig_id,
+                hir::InferDelegationSig::Input(arg),
+            )),
             span,
         }));
 
         let output = self.arena.alloc(hir::Ty {
             hir_id: self.next_id(),
-            kind: hir::TyKind::InferDelegation(
+            kind: hir::TyKind::InferDelegation(hir::InferDelegation::Sig(
                 sig_id,
-                hir::InferDelegationKind::Output(self.arena.alloc(hir::DelegationGenerics {
+                hir::InferDelegationSig::Output(self.arena.alloc(hir::DelegationGenerics {
                     child_args_segment_id: generics.child.args_segment_id,
                     parent_args_segment_id: generics.parent.args_segment_id,
                 })),
-            ),
+            )),
             span,
         });
 
@@ -399,7 +398,6 @@ fn generate_arg(
     fn lower_delegation_body(
         &mut self,
         delegation: &Delegation,
-        item_id: NodeId,
         is_method: bool,
         param_count: usize,
         generics: &mut GenericsGenerationResults<'hir>,
@@ -434,7 +432,7 @@ fn lower_delegation_body(
                 args.push(arg);
             }
 
-            let final_expr = this.finalize_body_lowering(delegation, item_id, args, generics, span);
+            let final_expr = this.finalize_body_lowering(delegation, args, generics, span);
 
             (this.arena.alloc_from_iter(parameters), final_expr)
         })
@@ -471,7 +469,6 @@ fn lower_target_expr(&mut self, block: &Block) -> hir::Expr<'hir> {
     fn finalize_body_lowering(
         &mut self,
         delegation: &Delegation,
-        item_id: NodeId,
         args: Vec<hir::Expr<'hir>>,
         generics: &mut GenericsGenerationResults<'hir>,
         span: Span,
@@ -501,7 +498,7 @@ fn finalize_body_lowering(
 
             // FIXME(fn_delegation): proper support for parent generics propagation
             // in method call scenario.
-            let segment = self.process_segment(item_id, span, &segment, &mut generics.child, false);
+            let segment = self.process_segment(span, &segment, &mut generics.child, false);
             let segment = self.arena.alloc(segment);
 
             self.arena.alloc(hir::Expr {
@@ -528,7 +525,7 @@ fn finalize_body_lowering(
                     new_path.segments = self.arena.alloc_from_iter(
                         new_path.segments.iter().enumerate().map(|(idx, segment)| {
                             let mut process_segment = |result, add_lifetimes| {
-                                self.process_segment(item_id, span, segment, result, add_lifetimes)
+                                self.process_segment(span, segment, result, add_lifetimes)
                             };
 
                             if idx + 2 == len {
@@ -544,8 +541,7 @@ fn finalize_body_lowering(
                     hir::QPath::Resolved(ty, self.arena.alloc(new_path))
                 }
                 hir::QPath::TypeRelative(ty, segment) => {
-                    let segment =
-                        self.process_segment(item_id, span, segment, &mut generics.child, false);
+                    let segment = self.process_segment(span, segment, &mut generics.child, false);
 
                     hir::QPath::TypeRelative(ty, self.arena.alloc(segment))
                 }
@@ -569,7 +565,6 @@ fn finalize_body_lowering(
 
     fn process_segment(
         &mut self,
-        item_id: NodeId,
         span: Span,
         segment: &hir::PathSegment<'hir>,
         result: &mut GenericsGenerationResult<'hir>,
@@ -577,15 +572,14 @@ fn process_segment(
     ) -> hir::PathSegment<'hir> {
         let details = result.generics.args_propagation_details();
 
-        // The first condition is needed when there is SelfAndUserSpecified case,
-        // we don't want to propagate generics params in this situation.
-        let segment = if details.should_propagate
-            && let Some(args) = result
-                .generics
-                .into_hir_generics(self, item_id, span)
-                .into_generic_args(self, add_lifetimes, span)
-        {
-            hir::PathSegment { args: Some(args), ..segment.clone() }
+        let segment = if details.should_propagate {
+            let generics = result.generics.into_hir_generics(self, span);
+            let args = generics.into_generic_args(self, add_lifetimes, span);
+
+            // Needed for better error messages (`trait-impl-wrong-args-count.rs` test).
+            let args = if args.is_empty() { None } else { Some(args) };
+
+            hir::PathSegment { args, ..segment.clone() }
         } else {
             segment.clone()
         };
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index d6d8819d8c47..ee1ac9aa5cd8 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -5,10 +5,8 @@
 use rustc_hir::def_id::DefId;
 use rustc_middle::ty::GenericParamDefKind;
 use rustc_middle::{bug, ty};
-use rustc_span::sym::{self};
 use rustc_span::symbol::kw;
 use rustc_span::{Ident, Span};
-use thin_vec::{ThinVec, thin_vec};
 
 use crate::{LoweringContext, ResolverAstLoweringExt};
 
@@ -16,34 +14,33 @@ pub(super) enum DelegationGenerics<T> {
     /// User-specified args are present: `reuse foo::<String>;`.
     UserSpecified,
     /// The default case when no user-specified args are present: `reuse Trait::foo;`.
-    Default(Option<T>),
+    Default(T),
     /// In free-to-trait reuse, when user specified args for trait `reuse Trait::<i32>::foo;`
     /// in this case we need to both generate `Self` and process user args.
-    SelfAndUserSpecified(Option<T>),
+    SelfAndUserSpecified(T),
     /// In delegations from trait impl to other entities like free functions or trait functions,
     /// we want to generate a function whose generics matches generics of signature function
     /// in trait.
-    TraitImpl(Option<T>, bool /* Has user-specified args */),
+    TraitImpl(T, bool /* Has user-specified args */),
 }
 
-/// Used for storing either AST generics or their lowered HIR version. Firstly we obtain
-/// AST generics either from local function from AST index or from external function
-/// through `tcx`. Next, at some point of generics processing we need to lower those
-/// generics to HIR, for this purpose we use `into_hir_generics` that lowers AST generics
-/// and replaces Ast variant with Hir. Such approach is useful as we can call this method
-/// at any time knowing that lowering will occur at most only once. Then, in order to obtain generic
+/// Used for storing either ty generics or their uplifted HIR version. First we obtain
+/// ty generics. Next, at some point of generics processing we need to uplift those
+/// generics to HIR, for this purpose we use `into_hir_generics` that uplifts ty generics
+/// and replaces Ty variant with Hir. Such approach is useful as we can call this method
+/// at any time knowing that uplifting will occur at most only once. Then, in order to obtain generic
 /// params or args we use `hir_generics_or_empty` or `into_generic_args` functions.
-/// There also may be situations when we obtained AST generics but never lowered them to HIR,
+/// There also may be situations when we obtained ty generics but never uplifted them to HIR,
 /// meaning we did not propagate them and thus we do not need to generate generic params
 /// (i.e., method call scenarios), in such a case this approach helps
-/// a lot as if `into_hir_generics` will not be called then lowering will not happen.
-pub(super) enum HirOrAstGenerics<'hir> {
-    Ast(DelegationGenerics<Generics>),
+/// a lot as if `into_hir_generics` will not be called then uplifting will not happen.
+pub(super) enum HirOrTyGenerics<'hir> {
+    Ty(DelegationGenerics<&'hir [ty::GenericParamDef]>),
     Hir(DelegationGenerics<&'hir hir::Generics<'hir>>),
 }
 
 pub(super) struct GenericsGenerationResult<'hir> {
-    pub(super) generics: HirOrAstGenerics<'hir>,
+    pub(super) generics: HirOrTyGenerics<'hir>,
     pub(super) args_segment_id: Option<HirId>,
 }
 
@@ -78,35 +75,31 @@ fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
     }
 }
 
-impl<'hir> HirOrAstGenerics<'hir> {
+impl<'hir> HirOrTyGenerics<'hir> {
     pub(super) fn into_hir_generics(
         &mut self,
         ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
-        item_id: NodeId,
         span: Span,
-    ) -> &mut HirOrAstGenerics<'hir> {
-        if let HirOrAstGenerics::Ast(generics) = self {
-            let process_params = |generics: &mut Generics| {
-                ctx.lower_delegation_generic_params(item_id, span, &mut generics.params)
+    ) -> &mut HirOrTyGenerics<'hir> {
+        if let HirOrTyGenerics::Ty(params) = self {
+            let mut uplift_params = |generics: &'hir [ty::GenericParamDef]| {
+                ctx.uplift_delegation_generic_params(span, generics)
             };
 
-            let hir_generics = match generics {
+            let hir_generics = match params {
                 DelegationGenerics::UserSpecified => DelegationGenerics::UserSpecified,
-                DelegationGenerics::Default(generics) => {
-                    DelegationGenerics::Default(generics.as_mut().map(process_params))
+                DelegationGenerics::Default(params) => {
+                    DelegationGenerics::Default(uplift_params(params))
                 }
-                DelegationGenerics::SelfAndUserSpecified(generics) => {
-                    DelegationGenerics::SelfAndUserSpecified(generics.as_mut().map(process_params))
+                DelegationGenerics::SelfAndUserSpecified(params) => {
+                    DelegationGenerics::SelfAndUserSpecified(uplift_params(params))
                 }
-                DelegationGenerics::TraitImpl(generics, user_specified) => {
-                    DelegationGenerics::TraitImpl(
-                        generics.as_mut().map(process_params),
-                        *user_specified,
-                    )
+                DelegationGenerics::TraitImpl(params, user_specified) => {
+                    DelegationGenerics::TraitImpl(uplift_params(params), *user_specified)
                 }
             };
 
-            *self = HirOrAstGenerics::Hir(hir_generics);
+            *self = HirOrTyGenerics::Hir(hir_generics);
         }
 
         self
@@ -114,14 +107,12 @@ pub(super) fn into_hir_generics(
 
     fn hir_generics_or_empty(&self) -> &'hir hir::Generics<'hir> {
         match self {
-            HirOrAstGenerics::Ast(_) => hir::Generics::empty(),
-            HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
+            HirOrTyGenerics::Ty(_) => hir::Generics::empty(),
+            HirOrTyGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => hir::Generics::empty(),
                 DelegationGenerics::Default(generics)
                 | DelegationGenerics::SelfAndUserSpecified(generics)
-                | DelegationGenerics::TraitImpl(generics, _) => {
-                    generics.unwrap_or(hir::Generics::empty())
-                }
+                | DelegationGenerics::TraitImpl(generics, _) => generics,
             },
         }
     }
@@ -131,43 +122,41 @@ pub(super) fn into_generic_args(
         ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
         add_lifetimes: bool,
         span: Span,
-    ) -> Option<&'hir hir::GenericArgs<'hir>> {
+    ) -> &'hir hir::GenericArgs<'hir> {
         match self {
-            HirOrAstGenerics::Ast(_) => {
-                bug!("Attempting to get generic args before lowering to HIR")
+            HirOrTyGenerics::Ty(_) => {
+                bug!("Attempting to get generic args before uplifting to HIR")
             }
-            HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
-                DelegationGenerics::UserSpecified => None,
+            HirOrTyGenerics::Hir(hir_generics) => match hir_generics {
+                DelegationGenerics::UserSpecified => hir::GenericArgs::NONE,
                 DelegationGenerics::Default(generics)
                 | DelegationGenerics::SelfAndUserSpecified(generics)
-                | DelegationGenerics::TraitImpl(generics, _) => generics.map(|generics| {
+                | DelegationGenerics::TraitImpl(generics, _) => {
                     ctx.create_generics_args_from_params(generics.params, add_lifetimes, span)
-                }),
+                }
             },
         }
     }
 
     pub(super) fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
         match self {
-            HirOrAstGenerics::Ast(ast_generics) => ast_generics.args_propagation_details(),
-            HirOrAstGenerics::Hir(hir_generics) => hir_generics.args_propagation_details(),
+            HirOrTyGenerics::Ty(ty_generics) => ty_generics.args_propagation_details(),
+            HirOrTyGenerics::Hir(hir_generics) => hir_generics.args_propagation_details(),
         }
     }
 }
 
-impl<'a> GenericsGenerationResult<'a> {
-    fn new(generics: DelegationGenerics<Generics>) -> GenericsGenerationResult<'a> {
-        GenericsGenerationResult {
-            generics: HirOrAstGenerics::Ast(generics),
-            args_segment_id: None,
-        }
+impl<'hir> GenericsGenerationResult<'hir> {
+    fn new(
+        generics: DelegationGenerics<&'hir [ty::GenericParamDef]>,
+    ) -> GenericsGenerationResult<'hir> {
+        GenericsGenerationResult { generics: HirOrTyGenerics::Ty(generics), args_segment_id: None }
     }
 }
 
 impl<'hir> GenericsGenerationResults<'hir> {
     pub(super) fn all_params(
         &mut self,
-        item_id: NodeId,
         span: Span,
         ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     ) -> impl Iterator<Item = hir::GenericParam<'hir>> {
@@ -176,21 +165,14 @@ pub(super) fn all_params(
         // method call will be supported (if HIR generics were not obtained
         // then it means that we did not propagated them, thus we do not need
         // to generate params).
-        let parent = self
-            .parent
-            .generics
-            .into_hir_generics(ctx, item_id, span)
-            .hir_generics_or_empty()
-            .params;
+        let mut create_params = |result: &mut GenericsGenerationResult<'hir>| {
+            result.generics.into_hir_generics(ctx, span).hir_generics_or_empty().params
+        };
 
-        let child = self
-            .child
-            .generics
-            .into_hir_generics(ctx, item_id, span)
-            .hir_generics_or_empty()
-            .params;
+        let parent = create_params(&mut self.parent);
+        let child = create_params(&mut self.child);
 
-        // Order generics, firstly we have parent and child lifetimes,
+        // Order generics, first we have parent and child lifetimes,
         // then parent and child types and consts.
         // `generics_of` in `rustc_hir_analysis` will order them anyway,
         // however we want the order to be consistent in HIR too.
@@ -203,13 +185,12 @@ pub(super) fn all_params(
             .copied()
     }
 
-    /// As we add hack predicates(`'a: 'a`) for all lifetimes (see `lower_delegation_generic_params`
+    /// As we add hack predicates(`'a: 'a`) for all lifetimes (see `uplift_delegation_generic_params`
     /// and `generate_lifetime_predicate` functions) we need to add them to delegation generics.
     /// Those predicates will not affect resulting predicate inheritance and folding
     /// in `rustc_hir_analysis`, as we inherit all predicates from delegation signature.
     pub(super) fn all_predicates(
         &mut self,
-        item_id: NodeId,
         span: Span,
         ctx: &mut LoweringContext<'_, 'hir, impl ResolverAstLoweringExt<'hir>>,
     ) -> impl Iterator<Item = hir::WherePredicate<'hir>> {
@@ -218,31 +199,23 @@ pub(super) fn all_predicates(
         // method call will be supported (if HIR generics were not obtained
         // then it means that we did not propagated them, thus we do not need
         // to generate predicates).
-        self.parent
-            .generics
-            .into_hir_generics(ctx, item_id, span)
-            .hir_generics_or_empty()
-            .predicates
-            .into_iter()
-            .chain(
-                self.child
-                    .generics
-                    .into_hir_generics(ctx, item_id, span)
-                    .hir_generics_or_empty()
-                    .predicates
-                    .into_iter(),
-            )
-            .copied()
+        let mut create_predicates = |result: &mut GenericsGenerationResult<'hir>| {
+            result.generics.into_hir_generics(ctx, span).hir_generics_or_empty().predicates
+        };
+
+        let parent = create_predicates(&mut self.parent);
+        let child = create_predicates(&mut self.child);
+
+        parent.into_iter().chain(child).copied()
     }
 }
 
 impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
-    pub(super) fn lower_delegation_generics(
+    pub(super) fn uplift_delegation_generics(
         &mut self,
         delegation: &Delegation,
         sig_id: DefId,
         item_id: NodeId,
-        span: Span,
     ) -> GenericsGenerationResults<'hir> {
         let delegation_parent_kind =
             self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id)));
@@ -251,15 +224,16 @@ pub(super) fn lower_delegation_generics(
         let len = segments.len();
         let child_user_specified = segments[len - 1].args.is_some();
 
+        let sig_params = &self.tcx.generics_of(sig_id).own_params[..];
+
         // If we are in trait impl always generate function whose generics matches
         // those that are defined in trait.
         if matches!(delegation_parent_kind, DefKind::Impl { of_trait: true }) {
             // Considering parent generics, during signature inheritance
             // we will take those args that are in trait impl header trait ref.
-            let parent = GenericsGenerationResult::new(DelegationGenerics::Default(None));
+            let parent = GenericsGenerationResult::new(DelegationGenerics::TraitImpl(&[], true));
 
-            let generics = self.get_external_generics(sig_id, false, span);
-            let child = DelegationGenerics::TraitImpl(generics, child_user_specified);
+            let child = DelegationGenerics::TraitImpl(sig_params, child_user_specified);
             let child = GenericsGenerationResult::new(child);
 
             return GenericsGenerationResults { parent, child };
@@ -268,38 +242,37 @@ pub(super) fn lower_delegation_generics(
         let delegation_in_free_ctx =
             !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
-        let root_function_in_trait =
-            matches!(self.tcx.def_kind(self.tcx.parent(sig_id)), DefKind::Trait);
-
-        let generate_self = delegation_in_free_ctx && root_function_in_trait;
-
-        let parent_generics_factory = |this: &mut Self, user_specified: bool| {
-            this.get_parent_generics(this.tcx.parent(sig_id), generate_self, user_specified, span)
-        };
+        let sig_parent = self.tcx.parent(sig_id);
+        let sig_in_trait = matches!(self.tcx.def_kind(sig_parent), DefKind::Trait);
 
         let can_add_generics_to_parent = len >= 2
             && self.get_resolution_id(segments[len - 2].id).is_some_and(|def_id| {
                 matches!(self.tcx.def_kind(def_id), DefKind::Trait | DefKind::TraitAlias)
             });
 
+        let generate_self = delegation_in_free_ctx && sig_in_trait;
         let parent_generics = if can_add_generics_to_parent {
+            let sig_parent_params = &self.tcx.generics_of(sig_parent).own_params[..];
+
             if segments[len - 2].args.is_some() {
                 if generate_self {
-                    DelegationGenerics::SelfAndUserSpecified(parent_generics_factory(self, true))
+                    // Take only first Self parameter, it is trait so Self must be present.
+                    DelegationGenerics::SelfAndUserSpecified(&sig_parent_params[..1])
                 } else {
                     DelegationGenerics::UserSpecified
                 }
             } else {
-                DelegationGenerics::Default(parent_generics_factory(self, false))
+                let skip_self = usize::from(!generate_self);
+                DelegationGenerics::Default(&sig_parent_params[skip_self..])
             }
         } else {
-            DelegationGenerics::Default(None)
+            DelegationGenerics::<&'hir [ty::GenericParamDef]>::Default(&[])
         };
 
         let child_generics = if child_user_specified {
             DelegationGenerics::UserSpecified
         } else {
-            DelegationGenerics::Default(self.get_external_generics(sig_id, false, span))
+            DelegationGenerics::Default(sig_params)
         };
 
         GenericsGenerationResults {
@@ -308,59 +281,71 @@ pub(super) fn lower_delegation_generics(
         }
     }
 
-    fn lower_delegation_generic_params(
+    fn uplift_delegation_generic_params(
         &mut self,
-        item_id: NodeId,
         span: Span,
-        params: &mut ThinVec<GenericParam>,
+        params: &'hir [ty::GenericParamDef],
     ) -> &'hir hir::Generics<'hir> {
-        for p in params.iter_mut() {
-            // We want to create completely new params, so we generate
-            // a new id, otherwise assertions will be triggered.
-            p.id = self.next_node_id();
+        let params = self.arena.alloc_from_iter(params.iter().map(|p| {
+            let def_kind = match p.kind {
+                GenericParamDefKind::Lifetime => DefKind::LifetimeParam,
+                GenericParamDefKind::Type { .. } => DefKind::TyParam,
+                GenericParamDefKind::Const { .. } => DefKind::ConstParam,
+            };
 
-            // Remove default params, as they are not supported on functions
-            // and there will duplicate DefId  when we try to lower them later.
-            match &mut p.kind {
-                GenericParamKind::Lifetime => {}
-                GenericParamKind::Type { default } => *default = None,
-                GenericParamKind::Const { default, .. } => *default = None,
+            let param_ident = Ident::new(p.name, span);
+            let def_name = Some(param_ident.name);
+            let path_data = def_kind.def_path_data(def_name);
+            let node_id = self.next_node_id();
+
+            let def_id = self.create_def(node_id, def_name, def_kind, path_data, span);
+
+            let kind = match p.kind {
+                GenericParamDefKind::Lifetime => {
+                    hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }
+                }
+                GenericParamDefKind::Type { synthetic, .. } => {
+                    hir::GenericParamKind::Type { default: None, synthetic }
+                }
+                GenericParamDefKind::Const { .. } => {
+                    let hir_id = self.next_id();
+                    let kind = hir::TyKind::InferDelegation(hir::InferDelegation::DefId(p.def_id));
+
+                    hir::GenericParamKind::Const {
+                        ty: self.arena.alloc(hir::Ty { kind, hir_id, span }),
+                        default: None,
+                    }
+                }
+            };
+
+            // Important: we don't use `self.next_id()` as we want to execute
+            // `lower_node_id` routine so param's id is added to `self.children`.
+            let hir_id = self.lower_node_id(node_id);
+
+            hir::GenericParam {
+                hir_id,
+                colon_span: Some(span),
+                def_id,
+                kind,
+                name: hir::ParamName::Plain(param_ident),
+                pure_wrt_drop: p.pure_wrt_drop,
+                source: hir::GenericParamSource::Generics,
+                span,
             }
-
-            // Note that we use self.disambiguator here, if we will create new every time
-            // we will get ICE if params have the same name.
-            self.resolver.insert_new_def_id(
-                p.id,
-                self.tcx
-                    .create_def(
-                        self.local_def_id(item_id),
-                        Some(p.ident.name),
-                        match p.kind {
-                            GenericParamKind::Lifetime => DefKind::LifetimeParam,
-                            GenericParamKind::Type { .. } => DefKind::TyParam,
-                            GenericParamKind::Const { .. } => DefKind::ConstParam,
-                        },
-                        None,
-                        &mut self.disambiguator,
-                    )
-                    .def_id(),
-            );
-        }
-
-        // Fallback to default generic param lowering, we modified them in the loop above.
-        let params = self.arena.alloc_from_iter(
-            params.iter().map(|p| self.lower_generic_param(p, hir::GenericParamSource::Generics)),
-        );
+        }));
 
         // HACK: for now we generate predicates such that all lifetimes are early bound,
         // we can not not generate early-bound lifetimes, but we can't know which of them
         // are late-bound at this level of compilation.
         // FIXME(fn_delegation): proper support for late bound lifetimes.
+        let predicates =
+            self.arena.alloc_from_iter(params.iter().filter_map(|p| {
+                p.is_lifetime().then(|| self.generate_lifetime_predicate(p, span))
+            }));
+
         self.arena.alloc(hir::Generics {
             params,
-            predicates: self.arena.alloc_from_iter(params.iter().filter_map(|p| {
-                p.is_lifetime().then(|| self.generate_lifetime_predicate(p, span))
-            })),
+            predicates,
             has_where_clause_predicates: false,
             where_clause_span: span,
             span,
@@ -376,11 +361,9 @@ fn generate_lifetime_predicate(
             this.arena.alloc(hir::Lifetime {
                 hir_id: this.next_id(),
                 ident: p.name.ident(),
-                kind: rustc_hir::LifetimeKind::Param(p.def_id),
-                source: rustc_hir::LifetimeSource::Path {
-                    angle_brackets: rustc_hir::AngleBrackets::Full,
-                },
-                syntax: rustc_hir::LifetimeSyntax::ExplicitBound,
+                kind: hir::LifetimeKind::Param(p.def_id),
+                source: hir::LifetimeSource::Path { angle_brackets: hir::AngleBrackets::Full },
+                syntax: hir::LifetimeSyntax::ExplicitBound,
             })
         };
 
@@ -472,117 +455,4 @@ fn create_generics_args_from_params(
             span_ext: span,
         })
     }
-
-    fn get_external_generics(
-        &mut self,
-        id: DefId,
-        processing_parent: bool,
-        span: Span,
-    ) -> Option<Generics> {
-        let generics = self.tcx.generics_of(id);
-        if generics.own_params.is_empty() {
-            return None;
-        }
-
-        // Skip first Self parameter if we are in trait, it will be added later.
-        let to_skip = (processing_parent && generics.has_self) as usize;
-
-        Some(Generics {
-            params: generics
-                .own_params
-                .iter()
-                .skip(to_skip)
-                .map(|p| GenericParam {
-                    attrs: Default::default(),
-                    bounds: Default::default(),
-                    colon_span: None,
-                    id: self.next_node_id(),
-                    ident: Ident::new(p.name, span),
-                    is_placeholder: false,
-                    kind: match p.kind {
-                        GenericParamDefKind::Lifetime => GenericParamKind::Lifetime,
-                        GenericParamDefKind::Type { .. } => {
-                            GenericParamKind::Type { default: None }
-                        }
-                        GenericParamDefKind::Const { .. } => self.map_const_kind(p, span),
-                    },
-                })
-                .collect(),
-            where_clause: Default::default(),
-            span,
-        })
-    }
-
-    fn map_const_kind(&mut self, p: &ty::GenericParamDef, span: Span) -> GenericParamKind {
-        let const_type = self.tcx.type_of(p.def_id).instantiate_identity();
-
-        let (type_symbol, res) = match const_type.kind() {
-            ty::Bool => (sym::bool, Res::PrimTy(hir::PrimTy::Bool)),
-            ty::Uint(uint) => (uint.name(), Res::PrimTy(hir::PrimTy::Uint(*uint))),
-            ty::Int(int) => (int.name(), Res::PrimTy(hir::PrimTy::Int(*int))),
-            ty::Char => (sym::char, Res::PrimTy(hir::PrimTy::Char)),
-            _ => {
-                self.tcx
-                    .dcx()
-                    .span_delayed_bug(span, format!("Unexpected const type: {}", const_type));
-
-                (sym::dummy, Res::Err)
-            }
-        };
-
-        let node_id = self.next_node_id();
-
-        self.resolver.insert_partial_res(node_id, hir::def::PartialRes::new(res));
-
-        GenericParamKind::Const {
-            ty: Box::new(Ty {
-                id: node_id,
-                kind: TyKind::Path(
-                    None,
-                    Path {
-                        segments: thin_vec![PathSegment {
-                            ident: Ident::new(type_symbol, span),
-                            id: self.next_node_id(),
-                            args: None
-                        }],
-                        span,
-                        tokens: None,
-                    },
-                ),
-                span,
-                tokens: None,
-            }),
-            span,
-            default: None,
-        }
-    }
-
-    fn get_parent_generics(
-        &mut self,
-        id: DefId,
-        add_self: bool,
-        user_specified: bool,
-        span: Span,
-    ) -> Option<Generics> {
-        // If args are user-specified we still maybe need to add self.
-        let mut generics =
-            if user_specified { None } else { self.get_external_generics(id, true, span) };
-
-        if add_self {
-            generics.get_or_insert_default().params.insert(
-                0,
-                GenericParam {
-                    id: self.next_node_id(),
-                    ident: Ident::new(kw::SelfUpper, span),
-                    attrs: Default::default(),
-                    bounds: vec![],
-                    is_placeholder: false,
-                    kind: GenericParamKind::Type { default: None },
-                    colon_span: None,
-                },
-            );
-        }
-
-        generics
-    }
 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index a2be51cfa31b..5fcc8f016119 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -678,7 +678,7 @@ pub fn lower_delayed_owner(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
     lowerer.lower_node(def_id);
 
-    for (&child_def_id, &owner) in &map {
+    for (child_def_id, owner) in map {
         tcx.feed_delayed_owner(child_def_id, owner);
     }
 }
@@ -1265,7 +1265,7 @@ fn lower_assoc_item_constraint(
             };
             gen_args_ctor.into_generic_args(self)
         } else {
-            self.arena.alloc(hir::GenericArgs::none())
+            hir::GenericArgs::NONE
         };
         let kind = match &constraint.kind {
             AssocItemConstraintKind::Equality { term } => {
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 9526143fcace..a5cb65404362 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -397,12 +397,7 @@ pub fn invalid() -> Self {
     }
 
     pub fn args(&self) -> &GenericArgs<'hir> {
-        if let Some(ref args) = self.args {
-            args
-        } else {
-            const DUMMY: &GenericArgs<'_> = &GenericArgs::none();
-            DUMMY
-        }
+        if let Some(ref args) = self.args { args } else { GenericArgs::NONE }
     }
 }
 
@@ -643,14 +638,12 @@ pub struct GenericArgs<'hir> {
 }
 
 impl<'hir> GenericArgs<'hir> {
-    pub const fn none() -> Self {
-        Self {
-            args: &[],
-            constraints: &[],
-            parenthesized: GenericArgsParentheses::No,
-            span_ext: DUMMY_SP,
-        }
-    }
+    pub const NONE: &'hir GenericArgs<'hir> = &GenericArgs {
+        args: &[],
+        constraints: &[],
+        parenthesized: GenericArgsParentheses::No,
+        span_ext: DUMMY_SP,
+    };
 
     /// Obtain the list of input types and the output type if the generic arguments are parenthesized.
     ///
@@ -3765,12 +3758,21 @@ pub struct DelegationGenerics {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, HashStable_Generic)]
-pub enum InferDelegationKind<'hir> {
+pub enum InferDelegationSig<'hir> {
     Input(usize),
     // Place generics info here, as we always specify output type for delegations.
     Output(&'hir DelegationGenerics),
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, HashStable_Generic)]
+pub enum InferDelegation<'hir> {
+    /// Infer the type of this `DefId` through `tcx.type_of(def_id).instantiate_identity()`,
+    /// used for const types propagation.
+    DefId(DefId),
+    /// Used during signature inheritance, `DefId` corresponds to the signature function.
+    Sig(DefId, InferDelegationSig<'hir>),
+}
+
 /// The various kinds of types recognized by the compiler.
 ///
 /// For an explanation of the `Unambig` generic parameter see the dev-guide:
@@ -3780,7 +3782,7 @@ pub enum InferDelegationKind<'hir> {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum TyKind<'hir, Unambig = ()> {
     /// Actual type should be inherited from `DefId` signature
-    InferDelegation(DefId, InferDelegationKind<'hir>),
+    InferDelegation(InferDelegation<'hir>),
     /// A variable length slice (i.e., `[T]`).
     Slice(&'hir Ty<'hir>),
     /// A fixed length array (i.e., `[T; n]`).
@@ -3931,7 +3933,7 @@ pub struct FnDecl<'hir> {
 impl<'hir> FnDecl<'hir> {
     pub fn opt_delegation_sig_id(&self) -> Option<DefId> {
         if let FnRetTy::Return(ty) = self.output
-            && let TyKind::InferDelegation(sig_id, _) = ty.kind
+            && let TyKind::InferDelegation(InferDelegation::Sig(sig_id, _)) = ty.kind
         {
             return Some(sig_id);
         }
@@ -3940,8 +3942,8 @@ pub fn opt_delegation_sig_id(&self) -> Option<DefId> {
 
     pub fn opt_delegation_generics(&self) -> Option<&'hir DelegationGenerics> {
         if let FnRetTy::Return(ty) = self.output
-            && let TyKind::InferDelegation(_, kind) = ty.kind
-            && let InferDelegationKind::Output(generics) = kind
+            && let TyKind::InferDelegation(InferDelegation::Sig(_, kind)) = ty.kind
+            && let InferDelegationSig::Output(generics) = kind
         {
             return Some(generics);
         }
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index 18244d62f2ae..5bb4166bf6cb 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -925,7 +925,7 @@ fn visit_fn(
             hir::FnRetTy::Return(ty) => Some(ty),
         };
         if let Some(ty) = output
-            && let hir::TyKind::InferDelegation(sig_id, _) = ty.kind
+            && let hir::TyKind::InferDelegation(hir::InferDelegation::Sig(sig_id, _)) = ty.kind
         {
             let bound_vars: Vec<_> =
                 self.tcx.fn_sig(sig_id).skip_binder().bound_vars().iter().collect();
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 9396bf6352c5..1200f6e9e47e 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2959,12 +2959,19 @@ fn require_type_const_attribute(
         }
     }
 
-    fn lower_delegation_ty(&self, idx: hir::InferDelegationKind<'tcx>) -> Ty<'tcx> {
-        let delegation_sig = self.tcx().inherit_sig_for_delegation_item(self.item_def_id());
+    fn lower_delegation_ty(&self, infer: hir::InferDelegation<'tcx>) -> Ty<'tcx> {
+        match infer {
+            hir::InferDelegation::DefId(def_id) => {
+                self.tcx().type_of(def_id).instantiate_identity()
+            }
+            rustc_hir::InferDelegation::Sig(_, idx) => {
+                let delegation_sig = self.tcx().inherit_sig_for_delegation_item(self.item_def_id());
 
-        match idx {
-            hir::InferDelegationKind::Input(idx) => delegation_sig[idx],
-            hir::InferDelegationKind::Output { .. } => *delegation_sig.last().unwrap(),
+                match idx {
+                    hir::InferDelegationSig::Input(idx) => delegation_sig[idx],
+                    hir::InferDelegationSig::Output { .. } => *delegation_sig.last().unwrap(),
+                }
+            }
         }
     }
 
@@ -2974,7 +2981,7 @@ pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
         let tcx = self.tcx();
 
         let result_ty = match &hir_ty.kind {
-            hir::TyKind::InferDelegation(_, idx) => self.lower_delegation_ty(*idx),
+            hir::TyKind::InferDelegation(infer) => self.lower_delegation_ty(*infer),
             hir::TyKind::Slice(ty) => Ty::new_slice(tcx, self.lower_ty(ty)),
             hir::TyKind::Ptr(mt) => Ty::new_ptr(tcx, self.lower_ty(mt.ty), mt.mutbl),
             hir::TyKind::Ref(region, mt) => {
diff --git a/tests/ui/delegation/generics/const-type-ice-153433.rs b/tests/ui/delegation/generics/const-type-ice-153433.rs
new file mode 100644
index 000000000000..edd6d0542a99
--- /dev/null
+++ b/tests/ui/delegation/generics/const-type-ice-153433.rs
@@ -0,0 +1,8 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+fn main() {
+    fn foo<const N: dyn for<'a> Foo>() {}
+    //~^ ERROR: cannot find trait `Foo` in this scope
+    reuse foo as bar;
+}
diff --git a/tests/ui/delegation/generics/const-type-ice-153433.stderr b/tests/ui/delegation/generics/const-type-ice-153433.stderr
new file mode 100644
index 000000000000..3b537e2f8988
--- /dev/null
+++ b/tests/ui/delegation/generics/const-type-ice-153433.stderr
@@ -0,0 +1,9 @@
+error[E0405]: cannot find trait `Foo` in this scope
+  --> $DIR/const-type-ice-153433.rs:5:33
+   |
+LL |     fn foo<const N: dyn for<'a> Foo>() {}
+   |                                 ^^^ not found in this scope
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/delegation/generics/const-type-ice-153499.rs b/tests/ui/delegation/generics/const-type-ice-153499.rs
new file mode 100644
index 000000000000..debda0d04a18
--- /dev/null
+++ b/tests/ui/delegation/generics/const-type-ice-153499.rs
@@ -0,0 +1,13 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait<'a, T, const F: fn(&CStr) -> usize> {
+    //~^ ERROR: cannot find type `CStr` in this scope
+    //~| ERROR: using function pointers as const generic parameters is forbidden
+    fn foo<'x: 'x, A, B>(&self) {}
+}
+
+reuse Trait::foo;
+//~^ ERROR: using function pointers as const generic parameters is forbidden
+
+fn main() {}
diff --git a/tests/ui/delegation/generics/const-type-ice-153499.stderr b/tests/ui/delegation/generics/const-type-ice-153499.stderr
new file mode 100644
index 000000000000..02fd7197dcdc
--- /dev/null
+++ b/tests/ui/delegation/generics/const-type-ice-153499.stderr
@@ -0,0 +1,30 @@
+error[E0425]: cannot find type `CStr` in this scope
+  --> $DIR/const-type-ice-153499.rs:4:33
+   |
+LL | trait Trait<'a, T, const F: fn(&CStr) -> usize> {
+   |                                 ^^^^ not found in this scope
+   |
+help: consider importing this struct
+   |
+LL + use std::ffi::CStr;
+   |
+
+error: using function pointers as const generic parameters is forbidden
+  --> $DIR/const-type-ice-153499.rs:4:29
+   |
+LL | trait Trait<'a, T, const F: fn(&CStr) -> usize> {
+   |                             ^^^^^^^^^^^^^^^^^^
+   |
+   = note: the only supported types are integers, `bool`, and `char`
+
+error: using function pointers as const generic parameters is forbidden
+  --> $DIR/const-type-ice-153499.rs:10:14
+   |
+LL | reuse Trait::foo;
+   |              ^^^
+   |
+   = note: the only supported types are integers, `bool`, and `char`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0425`.

From 36c22f7cf7a7070c9c6b478406f9b2ba831560c6 Mon Sep 17 00:00:00 2001
From: jumpiix <david@unterguggenberger.ch>
Date: Mon, 23 Mar 2026 13:08:12 +0100
Subject: [PATCH 0882/1059] Add test for dead code warnings in const _

Tests that dead code warnings work correctly inside const _ blocks.
Issue was already fixed, adding regression test as requested.
---
 .../const-underscore-issue-101532.rs          | 14 ++++++++
 .../const-underscore-issue-101532.stderr      | 32 +++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 tests/ui/lint/dead-code/const-underscore-issue-101532.rs
 create mode 100644 tests/ui/lint/dead-code/const-underscore-issue-101532.stderr

diff --git a/tests/ui/lint/dead-code/const-underscore-issue-101532.rs b/tests/ui/lint/dead-code/const-underscore-issue-101532.rs
new file mode 100644
index 000000000000..4dc25fbbecea
--- /dev/null
+++ b/tests/ui/lint/dead-code/const-underscore-issue-101532.rs
@@ -0,0 +1,14 @@
+//@ check-pass
+// Test for issue #101532 - dead code warnings should work inside const _
+
+#![warn(dead_code)]
+
+const _: () = {
+    let a: ();
+    struct B {} //~ WARN struct `B` is never constructed
+    enum C {}   //~ WARN enum `C` is never used
+    fn d() {}   //~ WARN function `d` is never used
+    const E: () = {}; //~ WARN constant `E` is never used
+};
+
+fn main() {}
diff --git a/tests/ui/lint/dead-code/const-underscore-issue-101532.stderr b/tests/ui/lint/dead-code/const-underscore-issue-101532.stderr
new file mode 100644
index 000000000000..d330b9e9f40a
--- /dev/null
+++ b/tests/ui/lint/dead-code/const-underscore-issue-101532.stderr
@@ -0,0 +1,32 @@
+warning: struct `B` is never constructed
+  --> $DIR/const-underscore-issue-101532.rs:8:12
+   |
+LL |     struct B {}
+   |            ^
+   |
+note: the lint level is defined here
+  --> $DIR/const-underscore-issue-101532.rs:4:9
+   |
+LL | #![warn(dead_code)]
+   |         ^^^^^^^^^
+
+warning: enum `C` is never used
+  --> $DIR/const-underscore-issue-101532.rs:9:10
+   |
+LL |     enum C {}
+   |          ^
+
+warning: function `d` is never used
+  --> $DIR/const-underscore-issue-101532.rs:10:8
+   |
+LL |     fn d() {}
+   |        ^
+
+warning: constant `E` is never used
+  --> $DIR/const-underscore-issue-101532.rs:11:11
+   |
+LL |     const E: () = {};
+   |           ^
+
+warning: 4 warnings emitted
+

From 24295bf7ae03f28fc09c30de7dd73f05c0641ac8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Tue, 24 Mar 2026 14:23:41 +0100
Subject: [PATCH 0883/1059] Disable `doc(auto_cfg)` for integers trait impls

---
 library/core/src/fmt/num.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/core/src/fmt/num.rs b/library/core/src/fmt/num.rs
index dfa27e32bc72..e9302a6127f5 100644
--- a/library/core/src/fmt/num.rs
+++ b/library/core/src/fmt/num.rs
@@ -594,6 +594,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 // Include wasm32 in here since it doesn't reflect the native pointer size, and
 // often cares strongly about getting a smaller code size.
 #[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+#[doc(auto_cfg = false)]
 mod imp {
     use super::*;
     impl_Display!(i8, u8, i16, u16, i32, u32, i64, u64, isize, usize; as u64 into display_u64);
@@ -601,6 +602,7 @@ mod imp {
 }
 
 #[cfg(not(any(target_pointer_width = "64", target_arch = "wasm32")))]
+#[doc(auto_cfg = false)]
 mod imp {
     use super::*;
     impl_Display!(i8, u8, i16, u16, i32, u32, isize, usize; as u32 into display_u32);

From e03983878f36f6568acccd09778ddbb917cf3b20 Mon Sep 17 00:00:00 2001
From: Redddy <rust@redddy.com>
Date: Tue, 24 Mar 2026 06:40:47 +0000
Subject: [PATCH 0884/1059] Use verbose span suggestion for type const

---
 .../src/hir_ty_lowering/mod.rs                   |  2 +-
 .../mgca/assoc-const-without-type_const.stderr   | 16 ++++++++++------
 .../mgca/unmarked-free-const.stderr              |  8 +++++---
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 338cba725272..90e1f34a275a 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2947,7 +2947,7 @@ fn require_type_const_attribute(
             );
             if def_id.is_local() {
                 let name = tcx.def_path_str(def_id);
-                err.span_suggestion(
+                err.span_suggestion_verbose(
                     tcx.def_span(def_id).shrink_to_lo(),
                     format!("add `type` before `const` for `{name}`"),
                     format!("type "),
diff --git a/tests/ui/const-generics/mgca/assoc-const-without-type_const.stderr b/tests/ui/const-generics/mgca/assoc-const-without-type_const.stderr
index 759a40cc0675..1a5f77ba33e1 100644
--- a/tests/ui/const-generics/mgca/assoc-const-without-type_const.stderr
+++ b/tests/ui/const-generics/mgca/assoc-const-without-type_const.stderr
@@ -1,20 +1,24 @@
 error: use of `const` in the type system not defined as `type const`
   --> $DIR/assoc-const-without-type_const.rs:8:35
    |
-LL |     const SIZE: usize;
-   |     - help: add `type` before `const` for `Tr::SIZE`: `type`
-...
 LL | fn mk_array<T: Tr>(_x: T) -> [(); T::SIZE] {
    |                                   ^^^^^^^
+   |
+help: add `type` before `const` for `Tr::SIZE`
+   |
+LL |     type const SIZE: usize;
+   |     ++++
 
 error: use of `const` in the type system not defined as `type const`
   --> $DIR/assoc-const-without-type_const.rs:10:10
    |
-LL |     const SIZE: usize;
-   |     - help: add `type` before `const` for `Tr::SIZE`: `type`
-...
 LL |     [(); T::SIZE]
    |          ^^^^^^^
+   |
+help: add `type` before `const` for `Tr::SIZE`
+   |
+LL |     type const SIZE: usize;
+   |     ++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/mgca/unmarked-free-const.stderr b/tests/ui/const-generics/mgca/unmarked-free-const.stderr
index 76875d8db0ef..dd33de4ce022 100644
--- a/tests/ui/const-generics/mgca/unmarked-free-const.stderr
+++ b/tests/ui/const-generics/mgca/unmarked-free-const.stderr
@@ -1,11 +1,13 @@
 error: use of `const` in the type system not defined as `type const`
   --> $DIR/unmarked-free-const.rs:9:18
    |
-LL | const N: usize = 4;
-   | - help: add `type` before `const` for `N`: `type`
-...
 LL |     let x = [(); N];
    |                  ^
+   |
+help: add `type` before `const` for `N`
+   |
+LL | type const N: usize = 4;
+   | ++++
 
 error: aborting due to 1 previous error
 

From 2e657348a9522c1d54570e4914fbf6d44f0a7be3 Mon Sep 17 00:00:00 2001
From: may <m4rch3n1ng@gmail.com>
Date: Tue, 24 Mar 2026 16:23:09 +0100
Subject: [PATCH 0885/1059] feat: reimplement `hash_map!` macro

Co-authored-by: stifskere <esteve@memw.es>
---
 library/std/src/lib.rs    |  2 ++
 library/std/src/macros.rs | 76 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index c8c8a6c89714..3f4ac35674f6 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -337,6 +337,8 @@
 #![feature(formatting_options)]
 #![feature(funnel_shifts)]
 #![feature(generic_atomic)]
+#![feature(hash_map_internals)]
+#![feature(hash_map_macro)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
 #![feature(hint_must_use)]
diff --git a/library/std/src/macros.rs b/library/std/src/macros.rs
index 0bb14552432d..cc000274ea8d 100644
--- a/library/std/src/macros.rs
+++ b/library/std/src/macros.rs
@@ -414,3 +414,79 @@ macro_rules! dbg {
         }
     },
 }
+
+#[doc(hidden)]
+#[macro_export]
+#[allow_internal_unstable(hash_map_internals)]
+#[unstable(feature = "hash_map_internals", issue = "none")]
+macro_rules! repetition_utils {
+    (@count $($tokens:tt),*) => {{
+        [$($crate::repetition_utils!(@replace $tokens => ())),*].len()
+    }};
+
+    (@replace $x:tt => $y:tt) => { $y }
+}
+
+/// Creates a [`HashMap`] containing the arguments.
+///
+/// `hash_map!` allows specifying the entries that make
+/// up the [`HashMap`] where the key and value are separated by a `=>`.
+///
+/// The entries are separated by commas with a trailing comma being allowed.
+///
+/// It is semantically equivalent to using repeated [`HashMap::insert`]
+/// on a newly created hashmap.
+///
+/// `hash_map!` will attempt to avoid repeated reallocations by
+/// using [`HashMap::with_capacity`].
+///
+/// # Examples
+///
+/// ```rust
+/// #![feature(hash_map_macro)]
+/// use std::hash_map;
+///
+/// let map = hash_map! {
+///     "key" => "value",
+///     "key1" => "value1"
+/// };
+///
+/// assert_eq!(map.get("key"), Some(&"value"));
+/// assert_eq!(map.get("key1"), Some(&"value1"));
+/// assert!(map.get("brrrrrrooooommm").is_none());
+/// ```
+///
+/// And with a trailing comma
+///
+///```rust
+/// #![feature(hash_map_macro)]
+/// use std::hash_map;
+///
+/// let map = hash_map! {
+///     "key" => "value", // notice the ,
+/// };
+///
+/// assert_eq!(map.get("key"), Some(&"value"));
+/// ```
+///
+/// The key and value are moved into the HashMap.
+///
+/// [`HashMap`]: crate::collections::HashMap
+/// [`HashMap::insert`]: crate::collections::HashMap::insert
+/// [`HashMap::with_capacity`]: crate::collections::HashMap::with_capacity
+#[macro_export]
+#[allow_internal_unstable(hash_map_internals)]
+#[unstable(feature = "hash_map_macro", issue = "144032")]
+macro_rules! hash_map {
+    () => {{
+        $crate::collections::HashMap::new()
+    }};
+
+    ( $( $key:expr => $value:expr ),* $(,)? ) => {{
+        let mut map = $crate::collections::HashMap::with_capacity(
+            const { $crate::repetition_utils!(@count $($key),*) }
+        );
+        $( map.insert($key, $value); )*
+        map
+    }}
+}

From cc65ec1892b2aa593bc5421996a655fbfce64050 Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Tue, 24 Mar 2026 23:07:22 +0700
Subject: [PATCH 0886/1059] trim prefix/suffix for paths

---
 library/std/src/path.rs | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 0b2b5f7e58f4..6e8620cf4724 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2725,6 +2725,41 @@ pub fn strip_prefix<P>(&self, base: P) -> Result<&Path, StripPrefixError>
         self._strip_prefix(base.as_ref())
     }
 
+    /// Returns a path with the optional prefix removed.
+    ///
+    /// If `base` is not a prefix of `self` (i.e., [`starts_with`] returns `false`), returns the original path (`self`)
+    ///
+    /// [`starts_with`]: Path::starts_with
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(trim_prefix_suffix)]
+    /// use std::path::Path;
+    ///
+    /// let path = Path::new("/test/haha/foo.txt");
+    ///
+    /// // Prefix present - remove it
+    /// assert_eq!(path.trim_prefix("/"), Path::new("test/haha/foo.txt"));
+    /// assert_eq!(path.trim_prefix("/test"), Path::new("haha/foo.txt"));
+    /// assert_eq!(path.trim_prefix("/test/"), Path::new("haha/foo.txt"));
+    /// assert_eq!(path.trim_prefix("/test/haha/foo.txt"), Path::new(""));
+    /// assert_eq!(path.trim_prefix("/test/haha/foo.txt/"), Path::new(""));
+    ///
+    /// // Prefix absent - return original
+    /// assert_eq!(path.trim_prefix("test"), path);
+    /// assert_eq!(path.trim_prefix("/te"), path);
+    /// assert_eq!(path.trim_prefix("/haha"), path);
+    /// ```
+    #[must_use = "this returns the remaining path as a new path, without modifying the original"]
+    #[unstable(feature = "trim_prefix_suffix", issue = "142312")]
+    pub fn trim_prefix<P>(&self, base: P) -> &Path
+    where
+        P: AsRef<Path>,
+    {
+        self._strip_prefix(base.as_ref()).unwrap_or(self)
+    }
+
     fn _strip_prefix(&self, base: &Path) -> Result<&Path, StripPrefixError> {
         iter_after(self.components(), base.components())
             .map(|c| c.as_path())

From b32f9cbda1a4a0af2f4502225e882d3dd5f6f381 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 17:27:47 +0100
Subject: [PATCH 0887/1059] CONTRIBUTING: explain how to build miri against a
 locally built rustc

---
 src/tools/miri/CONTRIBUTING.md | 31 +++++++++++++++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index 852ea26ab89e..ad8b2b09b6ba 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -171,8 +171,8 @@ MIRI_LOG=rustc_mir::interpret=info,miri::stacked_borrows ./miri run tests/pass/v
 ```
 
 Note that you will only get `info`, `warn` or `error` messages if you use a prebuilt compiler.
-In order to get `debug` and `trace` level messages, you need to build miri with a locally built
-compiler that has `debug=true` set in `bootstrap.toml`.
+In order to get `debug` and `trace` level messages, you need to build miri with a [locally built
+compiler](#advanced-topic-building-miri-against-a-locally-compiled-rustc) that has `debug=true` set in `bootstrap.toml`.
 
 #### Debugging error messages
 
@@ -320,6 +320,33 @@ You can also directly run Miri on a Rust source file:
 ./x.py run miri --stage 1 --args src/tools/miri/tests/pass/hello.rs
 ```
 
+## Advanced topic: Building Miri against a locally compiled rustc
+
+Very rarely, it can be necessary to work with an out-of-tree Miri but build it against a rustc that
+was locally compiled. (Usually, you should instead work on the Miri that's in the Rust tree, as
+described in the previous subsection.)
+
+This requires a fully bootstrapped build:
+
+```sh
+# Build rustc, then build rustc with that rustc. This can take a while.
+./x build library --stage 3
+```
+
+You also need to set up a linked toolchain with rustup:
+
+```sh
+rustup toolchain link stage2 build/host/stage2
+```
+
+Then in the Miri folder, you can set this as the current toolchain and build against it:
+
+```sh
+rustup override set stage2
+# Prevent `./miri` from reseting the toolchain.
+export MIRI_AUTO_OPS=no
+```
+
 ## Advanced topic: Syncing with the rustc repo
 
 We use the [`josh-sync`](https://github.com/rust-lang/josh-sync) tool to transmit changes between the

From 55309b01ef27bee22bdadee0d3d09542ddc5ff8b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 24 Mar 2026 18:52:16 +0200
Subject: [PATCH 0888/1059] Don't trigger GC on slow tests, take 2

Hopefully it really works this time.
---
 src/tools/rust-analyzer/Cargo.lock                  |  1 +
 src/tools/rust-analyzer/crates/intern/Cargo.toml    |  3 +++
 src/tools/rust-analyzer/crates/intern/src/gc.rs     |  4 ++++
 .../rust-analyzer/crates/rust-analyzer/Cargo.toml   |  2 ++
 .../crates/rust-analyzer/src/main_loop.rs           | 13 ++-----------
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index f31dda4a107b..5370127ddc8e 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -2315,6 +2315,7 @@ dependencies = [
  "ide-db",
  "ide-ssr",
  "indexmap",
+ "intern",
  "itertools 0.14.0",
  "load-cargo",
  "lsp-server 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/src/tools/rust-analyzer/crates/intern/Cargo.toml b/src/tools/rust-analyzer/crates/intern/Cargo.toml
index ad73c191c047..39320ebd1cfe 100644
--- a/src/tools/rust-analyzer/crates/intern/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/intern/Cargo.toml
@@ -22,3 +22,6 @@ rayon.workspace = true
 
 [lints]
 workspace = true
+
+[features]
+prevent-gc = []
diff --git a/src/tools/rust-analyzer/crates/intern/src/gc.rs b/src/tools/rust-analyzer/crates/intern/src/gc.rs
index 937de26831e2..f4e8f75e7194 100644
--- a/src/tools/rust-analyzer/crates/intern/src/gc.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/gc.rs
@@ -110,6 +110,10 @@ pub fn add_slice_storage<T: SliceInternable + GcInternedSliceVisit>(&mut self) {
     ///    the added storages must form a DAG.
     ///  - [`GcInternedVisit`] and [`GcInternedSliceVisit`] must mark all values reachable from the node.
     pub unsafe fn collect(mut self) {
+        if cfg!(feature = "prevent-gc") {
+            return;
+        }
+
         let total_nodes = self.storages.iter().map(|storage| storage.len()).sum();
         self.alive.clear();
         self.alive.reserve(total_nodes);
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/crates/rust-analyzer/Cargo.toml
index d1283ca59e8c..beb83a8173a0 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/Cargo.toml
@@ -94,6 +94,8 @@ test-utils.workspace = true
 test-fixture.workspace = true
 syntax-bridge.workspace = true
 
+intern = { path = "../intern", features = ["prevent-gc"] }
+
 [features]
 jemalloc = ["jemallocator", "profile/jemalloc"]
 force-always-assert = ["stdx/force-always-assert"]
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index 83edbc722bd5..dad321137fa6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -303,15 +303,6 @@ fn next_event(
         .map(Some)
     }
 
-    fn trigger_garbage_collection(&mut self) {
-        if cfg!(test) {
-            // Slow tests run the main loop in multiple threads, but GC isn't thread safe.
-            return;
-        }
-
-        self.analysis_host.trigger_garbage_collection();
-    }
-
     fn handle_event(&mut self, event: Event) {
         let loop_start = Instant::now();
         let _p = tracing::info_span!("GlobalState::handle_event", event = %event).entered();
@@ -392,7 +383,7 @@ fn handle_event(&mut self, event: Event) {
                             ));
                         }
                         PrimeCachesProgress::End { cancelled } => {
-                            self.trigger_garbage_collection();
+                            self.analysis_host.trigger_garbage_collection();
                             self.prime_caches_queue.op_completed(());
                             if cancelled {
                                 self.prime_caches_queue
@@ -551,7 +542,7 @@ fn handle_event(&mut self, event: Event) {
                 && self.fmt_pool.handle.is_empty()
                 && current_revision != self.last_gc_revision
             {
-                self.trigger_garbage_collection();
+                self.analysis_host.trigger_garbage_collection();
                 self.last_gc_revision = current_revision;
             }
         }

From 422906d57e99eaf8a27c0aa2696cac3286c2594f Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Tue, 24 Mar 2026 17:39:46 +0000
Subject: [PATCH 0889/1059] Do not check for LEAK & KERNELHWADDRESS because
 they are incompatible

---
 compiler/rustc_codegen_ssa/src/back/link.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index be7da2e81add..7a3d5a6bb224 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1341,7 +1341,6 @@ fn add_sanitizer_libraries(
     if sanitizer.contains(SanitizerSet::LEAK)
         && !sanitizer.contains(SanitizerSet::ADDRESS)
         && !sanitizer.contains(SanitizerSet::HWADDRESS)
-        && !sanitizer.contains(SanitizerSet::KERNELHWADDRESS)
     {
         link_sanitizer_runtime(sess, flavor, linker, "lsan");
     }

From 4d86840bf153fa62e92db3065e7b02b117823a52 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Tue, 24 Mar 2026 17:46:20 +0000
Subject: [PATCH 0890/1059] Document kernel-hwaddress in Unstable Book

---
 .../unstable-book/src/compiler-flags/sanitizer.md    | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/doc/unstable-book/src/compiler-flags/sanitizer.md b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
index 1771d1382f07..eb070c22dc28 100644
--- a/src/doc/unstable-book/src/compiler-flags/sanitizer.md
+++ b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
@@ -22,6 +22,8 @@ This feature allows for use of one of following sanitizers:
   * [AddressSanitizer](#addresssanitizer) a fast memory error detector.
   * [HWAddressSanitizer](#hwaddresssanitizer) a memory error detector similar to
     AddressSanitizer, but based on partial hardware assistance.
+  * [KernelHWAddressSanitizer](#kernelhwaddresssanitizer) variant of
+    HWAddressSanitizer that is designed for bare metal environments.
   * [LeakSanitizer](#leaksanitizer) a run-time memory leak detector.
   * [MemorySanitizer](#memorysanitizer) a detector of uninitialized reads.
   * [RealtimeSanitizer](#realtimesanitizer) a detector of calls to function with
@@ -622,6 +624,16 @@ Registers where the failure occurred (pc 0xaaaae0ae4a98):
 SUMMARY: HWAddressSanitizer: tag-mismatch (/.../main+0x54a94)
 ```
 
+# KernelHWAddressSanitizer
+
+KernelHWAddressSanitizer is the kernel version of [HWAddressSanitizer](#hwaddresssanitizer),
+which achieves the same purpose but is designed for bare-metal environments.
+
+HWAddressSanitizer is supported on the `aarch64*-unknown-none` and
+`aarch64*-unknown-none-softfloat` targets.
+
+See the [Clang HWAddressSanitizer documentation][clang-hwasan] for more details.
+
 # KernelControlFlowIntegrity
 
 The LLVM Kernel Control Flow Integrity (CFI) support to the Rust compiler

From c17dec615d68dad01384465929225c3d1bed9eb1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <contact@guillaume-gomez.fr>
Date: Tue, 24 Mar 2026 19:45:17 +0100
Subject: [PATCH 0891/1059] Remove `BuiltinLintDiag` usage in `rustc_metadata`

---
 compiler/rustc_lint/src/early/diagnostics.rs | 3 ---
 compiler/rustc_lint/src/lints.rs             | 8 --------
 compiler/rustc_lint_defs/src/lib.rs          | 4 ----
 compiler/rustc_metadata/src/creader.rs       | 5 ++---
 compiler/rustc_metadata/src/errors.rs        | 8 ++++++++
 5 files changed, 10 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 9aefef1733b1..1cb0f906f730 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -153,9 +153,6 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
                 .into_diag(dcx, level)
             }
 
-            BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
-                lints::UnusedCrateDependency { extern_crate, local_crate }.into_diag(dcx, level)
-            }
             BuiltinLintDiag::AttributeLint(kind) => {
                 DecorateAttrLint { sess: self.sess, tcx: self.tcx, diagnostic: &kind }
                     .into_diag(dcx, level)
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index b40dcb70d780..f111f8134499 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2994,14 +2994,6 @@ pub(crate) enum CargoHelp {
     }
 }
 
-#[derive(Diagnostic)]
-#[diag("extern crate `{$extern_crate}` is unused in crate `{$local_crate}`")]
-#[help("remove the dependency or add `use {$extern_crate} as _;` to the crate root")]
-pub(crate) struct UnusedCrateDependency {
-    pub extern_crate: Symbol,
-    pub local_crate: Symbol,
-}
-
 // FIXME(jdonszelmann): duplicated in rustc_attr_parsing, should be moved there completely.
 #[derive(Diagnostic)]
 #[diag(
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 2cd0498f0994..0528a0d69324 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -690,10 +690,6 @@ pub enum BuiltinLintDiag {
         /// Indicates if the named argument is used as a width/precision for formatting
         is_formatting_arg: bool,
     },
-    UnusedCrateDependency {
-        extern_crate: Symbol,
-        local_crate: Symbol,
-    },
     AttributeLint(AttributeLintKind),
 }
 
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index 4000f12459a9..345ee185156c 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -23,15 +23,14 @@
 use rustc_middle::ty::data_structures::IndexSet;
 use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
 use rustc_proc_macro::bridge::client::ProcMacro;
-use rustc_session::Session;
 use rustc_session::config::{
     CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
     TargetModifier,
 };
 use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
-use rustc_session::lint::{self, BuiltinLintDiag};
 use rustc_session::output::validate_crate_name;
 use rustc_session::search_paths::PathKind;
+use rustc_session::{Session, lint};
 use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
@@ -1211,7 +1210,7 @@ fn report_unused_deps_in_crate(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
                 lint::builtin::UNUSED_CRATE_DEPENDENCIES,
                 span,
                 ast::CRATE_NODE_ID,
-                BuiltinLintDiag::UnusedCrateDependency {
+                errors::UnusedCrateDependency {
                     extern_crate: name_interned,
                     local_crate: tcx.crate_name(LOCAL_CRATE),
                 },
diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs
index d4c61441bcea..8b2895d70004 100644
--- a/compiler/rustc_metadata/src/errors.rs
+++ b/compiler/rustc_metadata/src/errors.rs
@@ -688,3 +688,11 @@ pub struct RawDylibMalformed {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag("extern crate `{$extern_crate}` is unused in crate `{$local_crate}`")]
+#[help("remove the dependency or add `use {$extern_crate} as _;` to the crate root")]
+pub(crate) struct UnusedCrateDependency {
+    pub extern_crate: Symbol,
+    pub local_crate: Symbol,
+}

From 97e84d5a562ed6bbbf1ce7221e80a0f5326f65ab Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 24 Mar 2026 20:00:26 +0000
Subject: [PATCH 0892/1059] allow `incomplete_features` in all ui tests

---
 src/tools/compiletest/src/runtest.rs          |  5 +---
 .../ui/specialization/assoc-ty-graph-cycle.rs |  2 +-
 .../assoc-ty-graph-cycle.stderr               | 12 ----------
 .../default-impl-normalization-ambig-2.rs     |  2 +-
 .../default-impl-normalization-ambig-2.stderr | 12 +---------
 .../default-item-normalization-ambig-1.rs     |  2 +-
 .../default-item-normalization-ambig-1.stderr | 12 +---------
 .../ui/specialization/cross-crate-defaults.rs |  2 +-
 .../cross-crate-defaults.stderr               | 12 ----------
 .../ctfe/default-assoc-const.rs               |  1 -
 .../ctfe/default-assoc-const.stderr           | 12 ----------
 .../specialization/ctfe/default-assoc-type.rs |  1 -
 .../ctfe/default-assoc-type.stderr            | 12 ----------
 .../default-associated-type-bound-1.rs        |  1 -
 .../default-associated-type-bound-1.stderr    | 16 +++----------
 .../default-associated-type-bound-2.rs        |  1 -
 .../default-associated-type-bound-2.stderr    | 16 +++----------
 .../default-generic-associated-type-bound.rs  |  1 -
 ...fault-generic-associated-type-bound.stderr | 16 +++----------
 .../defaultimpl/allowed-cross-crate.rs        |  2 +-
 .../defaultimpl/allowed-cross-crate.stderr    | 12 ----------
 .../defaultimpl/out-of-order.rs               |  2 +-
 .../defaultimpl/out-of-order.stderr           | 12 ----------
 .../defaultimpl/overlap-projection.rs         |  2 +-
 .../defaultimpl/overlap-projection.stderr     | 12 ----------
 .../specialization/defaultimpl/projection.rs  |  2 +-
 .../defaultimpl/projection.stderr             | 12 ----------
 .../defaultimpl/specialization-no-default.rs  |  2 +-
 .../specialization-no-default.stderr          | 12 +---------
 ...zation-trait-item-not-implemented-rpass.rs |  2 +-
 ...on-trait-item-not-implemented-rpass.stderr | 12 ----------
 ...ecialization-trait-item-not-implemented.rs |  2 +-
 ...lization-trait-item-not-implemented.stderr | 12 +---------
 .../specialization-trait-not-implemented.rs   |  2 +-
 ...pecialization-trait-not-implemented.stderr | 12 +---------
 .../defaultimpl/specialization-wfcheck.rs     |  2 +-
 .../defaultimpl/specialization-wfcheck.stderr | 12 +---------
 .../specialization/defaultimpl/validation.rs  |  2 +-
 .../defaultimpl/validation.stderr             | 12 +---------
 .../fuzzed/fuzzing-ice-134905.rs              |  2 +-
 .../fuzzed/fuzzing-ice-134905.stderr          | 12 +---------
 tests/ui/specialization/issue-35376.rs        |  1 -
 tests/ui/specialization/issue-35376.stderr    | 12 ----------
 tests/ui/specialization/issue-36804.rs        |  2 +-
 tests/ui/specialization/issue-36804.stderr    | 12 ----------
 tests/ui/specialization/issue-38091-2.rs      |  1 -
 tests/ui/specialization/issue-38091-2.stderr  | 14 ++---------
 tests/ui/specialization/issue-38091.rs        |  1 -
 tests/ui/specialization/issue-38091.stderr    | 18 ++++----------
 tests/ui/specialization/issue-39448.rs        |  2 +-
 tests/ui/specialization/issue-39448.stderr    | 12 +---------
 tests/ui/specialization/issue-39618.rs        |  2 +-
 tests/ui/specialization/issue-39618.stderr    | 12 +---------
 tests/ui/specialization/issue-50452-fail.rs   |  1 -
 .../ui/specialization/issue-50452-fail.stderr | 14 ++---------
 tests/ui/specialization/issue-50452.rs        |  2 +-
 tests/ui/specialization/issue-50452.stderr    | 12 ----------
 tests/ui/specialization/issue-52050.rs        |  2 +-
 tests/ui/specialization/issue-52050.stderr    | 12 +---------
 .../specialization/issue-63716-parse-async.rs |  2 +-
 .../issue-63716-parse-async.stderr            | 12 ----------
 tests/ui/specialization/issue-70442.rs        |  2 +-
 tests/ui/specialization/issue-70442.stderr    | 12 ----------
 .../specialization/non-defaulted-item-fail.rs |  1 -
 .../non-defaulted-item-fail.stderr            | 24 ++++++-------------
 .../overlap-due-to-unsatisfied-const-bound.rs |  2 --
 ...rlap-due-to-unsatisfied-const-bound.stderr | 22 ++---------------
 ...cializing-impl-over-default.current.stderr | 12 ----------
 ...specializing-impl-over-default.next.stderr | 12 ----------
 .../prefer-specializing-impl-over-default.rs  |  1 -
 ...-constraining-predicates-ambig.next.stderr | 12 ----------
 ...-requires-constraining-predicates-ambig.rs |  1 -
 ...res-constraining-predicates.current.stderr | 12 ----------
 ...quires-constraining-predicates.next.stderr | 12 ----------
 ...e-impl-requires-constraining-predicates.rs |  1 -
 .../specialization-allowed-cross-crate.rs     |  2 +-
 .../specialization-allowed-cross-crate.stderr | 12 ----------
 .../specialization-assoc-fns.rs               |  2 +-
 .../specialization-assoc-fns.stderr           | 12 ----------
 .../specialization/specialization-basics.rs   |  2 +-
 .../specialization-basics.stderr              | 12 ----------
 .../specialization-cross-crate.rs             |  2 +-
 .../specialization-cross-crate.stderr         | 12 ----------
 .../specialization-default-methods.rs         |  2 +-
 .../specialization-default-methods.stderr     | 12 ----------
 ...lization-default-projection.current.stderr | 12 +---------
 ...cialization-default-projection.next.stderr | 12 +---------
 .../specialization-default-projection.rs      |  2 +-
 ...pecialization-default-types.current.stderr | 12 +---------
 .../specialization-default-types.next.stderr  | 12 +---------
 .../specialization-default-types.rs           |  2 +-
 .../specialization-no-default.rs              |  2 +-
 .../specialization-no-default.stderr          | 12 +---------
 .../specialization-on-projection.rs           |  2 +-
 .../specialization-on-projection.stderr       | 12 ----------
 .../specialization-out-of-order.rs            |  2 +-
 .../specialization-out-of-order.stderr        | 12 ----------
 .../specialization-overlap-negative.rs        |  2 +-
 .../specialization-overlap-negative.stderr    | 12 +---------
 .../specialization-overlap-projection.rs      |  1 -
 .../specialization-overlap-projection.stderr  | 16 +++----------
 .../specialization/specialization-overlap.rs  |  2 +-
 .../specialization-overlap.stderr             | 12 +---------
 .../specialization/specialization-polarity.rs |  2 +-
 .../specialization-polarity.stderr            | 12 +---------
 .../specialization-projection-alias.rs        |  2 +-
 .../specialization-projection-alias.stderr    | 12 ----------
 .../specialization-projection.rs              |  2 +-
 .../specialization-projection.stderr          | 12 ----------
 .../specialization-supertraits.rs             |  2 +-
 .../specialization-supertraits.stderr         | 12 ----------
 ...on-translate-projections-with-lifetimes.rs |  2 +-
 ...ranslate-projections-with-lifetimes.stderr | 12 ----------
 ...ation-translate-projections-with-params.rs |  2 +-
 ...n-translate-projections-with-params.stderr | 12 ----------
 .../specialization-translate-projections.rs   |  3 +--
 ...pecialization-translate-projections.stderr | 12 ----------
 ...it-specialization-default-methods-55380.rs |  1 -
 ...pecialization-default-methods-55380.stderr | 12 ----------
 .../transmute-specialization.rs               |  2 +-
 .../transmute-specialization.stderr           | 12 ----------
 ...non-const-specialized-impl.min_spec.stderr |  2 +-
 ...default-impl-non-const-specialized-impl.rs |  1 -
 ...mpl-non-const-specialized-impl.spec.stderr | 14 ++---------
 124 files changed, 94 insertions(+), 822 deletions(-)
 delete mode 100644 tests/ui/specialization/assoc-ty-graph-cycle.stderr
 delete mode 100644 tests/ui/specialization/cross-crate-defaults.stderr
 delete mode 100644 tests/ui/specialization/ctfe/default-assoc-const.stderr
 delete mode 100644 tests/ui/specialization/ctfe/default-assoc-type.stderr
 delete mode 100644 tests/ui/specialization/defaultimpl/allowed-cross-crate.stderr
 delete mode 100644 tests/ui/specialization/defaultimpl/out-of-order.stderr
 delete mode 100644 tests/ui/specialization/defaultimpl/overlap-projection.stderr
 delete mode 100644 tests/ui/specialization/defaultimpl/projection.stderr
 delete mode 100644 tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.stderr
 delete mode 100644 tests/ui/specialization/issue-35376.stderr
 delete mode 100644 tests/ui/specialization/issue-36804.stderr
 delete mode 100644 tests/ui/specialization/issue-50452.stderr
 delete mode 100644 tests/ui/specialization/issue-63716-parse-async.stderr
 delete mode 100644 tests/ui/specialization/issue-70442.stderr
 delete mode 100644 tests/ui/specialization/prefer-specializing-impl-over-default.current.stderr
 delete mode 100644 tests/ui/specialization/prefer-specializing-impl-over-default.next.stderr
 delete mode 100644 tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.next.stderr
 delete mode 100644 tests/ui/specialization/source-impl-requires-constraining-predicates.current.stderr
 delete mode 100644 tests/ui/specialization/source-impl-requires-constraining-predicates.next.stderr
 delete mode 100644 tests/ui/specialization/specialization-allowed-cross-crate.stderr
 delete mode 100644 tests/ui/specialization/specialization-assoc-fns.stderr
 delete mode 100644 tests/ui/specialization/specialization-basics.stderr
 delete mode 100644 tests/ui/specialization/specialization-cross-crate.stderr
 delete mode 100644 tests/ui/specialization/specialization-default-methods.stderr
 delete mode 100644 tests/ui/specialization/specialization-on-projection.stderr
 delete mode 100644 tests/ui/specialization/specialization-out-of-order.stderr
 delete mode 100644 tests/ui/specialization/specialization-projection-alias.stderr
 delete mode 100644 tests/ui/specialization/specialization-projection.stderr
 delete mode 100644 tests/ui/specialization/specialization-supertraits.stderr
 delete mode 100644 tests/ui/specialization/specialization-translate-projections-with-lifetimes.stderr
 delete mode 100644 tests/ui/specialization/specialization-translate-projections-with-params.stderr
 delete mode 100644 tests/ui/specialization/specialization-translate-projections.stderr
 delete mode 100644 tests/ui/specialization/trait-specialization-default-methods-55380.stderr
 delete mode 100644 tests/ui/specialization/transmute-specialization.stderr

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index d7b47b38a943..da4ec440bb44 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1921,10 +1921,7 @@ fn make_compile_args(
 
         // Allow tests to use internal and incomplete features.
         compiler.args(&["-A", "internal_features"]);
-        // FIXME(#154168); temporarily exclude some directories to make the transition easier
-        if !input_file.iter().any(|p| p == "specialization") {
-            compiler.args(&["-A", "incomplete_features"]);
-        }
+        compiler.args(&["-A", "incomplete_features"]);
 
         // Allow tests to have unused parens and braces.
         // Add #![deny(unused_parens, unused_braces)] to the test file if you want to
diff --git a/tests/ui/specialization/assoc-ty-graph-cycle.rs b/tests/ui/specialization/assoc-ty-graph-cycle.rs
index 083b03028f08..16be58e27098 100644
--- a/tests/ui/specialization/assoc-ty-graph-cycle.rs
+++ b/tests/ui/specialization/assoc-ty-graph-cycle.rs
@@ -2,7 +2,7 @@
 
 // Make sure we don't crash with a cycle error during coherence.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Trait<T> {
     type Assoc;
diff --git a/tests/ui/specialization/assoc-ty-graph-cycle.stderr b/tests/ui/specialization/assoc-ty-graph-cycle.stderr
deleted file mode 100644
index f5529c24d3e8..000000000000
--- a/tests/ui/specialization/assoc-ty-graph-cycle.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/assoc-ty-graph-cycle.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.rs b/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.rs
index 1691530fa0a5..a0073d518689 100644
--- a/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.rs
+++ b/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.rs
@@ -1,5 +1,5 @@
 // regression test for #118987
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Assoc {
     type Output;
diff --git a/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.stderr b/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.stderr
index e950268fa1b3..8ccf0c23dbd9 100644
--- a/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.stderr
+++ b/tests/ui/specialization/coherence/default-impl-normalization-ambig-2.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-impl-normalization-ambig-2.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `u16: Assoc` is not satisfied
   --> $DIR/default-impl-normalization-ambig-2.rs:17:14
    |
@@ -20,6 +10,6 @@ help: the trait `Assoc` is implemented for `u8`
 LL | impl Assoc for u8 {}
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/coherence/default-item-normalization-ambig-1.rs b/tests/ui/specialization/coherence/default-item-normalization-ambig-1.rs
index af7cf332d5f4..24142a472fde 100644
--- a/tests/ui/specialization/coherence/default-item-normalization-ambig-1.rs
+++ b/tests/ui/specialization/coherence/default-item-normalization-ambig-1.rs
@@ -1,5 +1,5 @@
 // regression test for #73299.
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait X {
     type U;
diff --git a/tests/ui/specialization/coherence/default-item-normalization-ambig-1.stderr b/tests/ui/specialization/coherence/default-item-normalization-ambig-1.stderr
index a15151cc9c41..f45c4e55572b 100644
--- a/tests/ui/specialization/coherence/default-item-normalization-ambig-1.stderr
+++ b/tests/ui/specialization/coherence/default-item-normalization-ambig-1.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-item-normalization-ambig-1.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `Y` for type `<() as X>::U`
   --> $DIR/default-item-normalization-ambig-1.rs:20:1
    |
@@ -16,6 +6,6 @@ LL | impl Y for <() as X>::U {}
 LL | impl Y for <i32 as X>::U {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `<() as X>::U`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/cross-crate-defaults.rs b/tests/ui/specialization/cross-crate-defaults.rs
index c9204461e206..0a2d6e973dc1 100644
--- a/tests/ui/specialization/cross-crate-defaults.rs
+++ b/tests/ui/specialization/cross-crate-defaults.rs
@@ -2,7 +2,7 @@
 
 //@ aux-build:cross_crates_defaults.rs
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 extern crate cross_crates_defaults;
 
diff --git a/tests/ui/specialization/cross-crate-defaults.stderr b/tests/ui/specialization/cross-crate-defaults.stderr
deleted file mode 100644
index ee5c77a76be4..000000000000
--- a/tests/ui/specialization/cross-crate-defaults.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/cross-crate-defaults.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/ctfe/default-assoc-const.rs b/tests/ui/specialization/ctfe/default-assoc-const.rs
index 083aedece51a..644e56f5ccc5 100644
--- a/tests/ui/specialization/ctfe/default-assoc-const.rs
+++ b/tests/ui/specialization/ctfe/default-assoc-const.rs
@@ -1,7 +1,6 @@
 //! Regression test for revealing associated types through specialization during const eval.
 //@ check-pass
 #![feature(specialization)]
-//~^ WARNING the feature `specialization` is incomplete and may not be safe to use
 
 trait Foo {
     const ASSOC: usize;
diff --git a/tests/ui/specialization/ctfe/default-assoc-const.stderr b/tests/ui/specialization/ctfe/default-assoc-const.stderr
deleted file mode 100644
index 933b6dcf8f99..000000000000
--- a/tests/ui/specialization/ctfe/default-assoc-const.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-assoc-const.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/ctfe/default-assoc-type.rs b/tests/ui/specialization/ctfe/default-assoc-type.rs
index 0ceba2dc4977..0415cd3da5c1 100644
--- a/tests/ui/specialization/ctfe/default-assoc-type.rs
+++ b/tests/ui/specialization/ctfe/default-assoc-type.rs
@@ -2,7 +2,6 @@
 //! even if they rely on specialization.
 //@ check-pass
 #![feature(specialization)]
-//~^ WARNING the feature `specialization` is incomplete and may not be safe to use
 
 trait Foo {
     type Assoc: Trait;
diff --git a/tests/ui/specialization/ctfe/default-assoc-type.stderr b/tests/ui/specialization/ctfe/default-assoc-type.stderr
deleted file mode 100644
index 23fa213caffb..000000000000
--- a/tests/ui/specialization/ctfe/default-assoc-type.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-assoc-type.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/default-associated-type-bound-1.rs b/tests/ui/specialization/default-associated-type-bound-1.rs
index c043114b565c..8e889a61f158 100644
--- a/tests/ui/specialization/default-associated-type-bound-1.rs
+++ b/tests/ui/specialization/default-associated-type-bound-1.rs
@@ -2,7 +2,6 @@
 // bounds on them.
 
 #![feature(specialization)]
-//~^ WARNING `specialization` is incomplete
 
 trait X {
     type U: Clone;
diff --git a/tests/ui/specialization/default-associated-type-bound-1.stderr b/tests/ui/specialization/default-associated-type-bound-1.stderr
index aa6f69578aaf..70408145e803 100644
--- a/tests/ui/specialization/default-associated-type-bound-1.stderr
+++ b/tests/ui/specialization/default-associated-type-bound-1.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-associated-type-bound-1.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `str: Clone` is not satisfied
-  --> $DIR/default-associated-type-bound-1.rs:18:22
+  --> $DIR/default-associated-type-bound-1.rs:17:22
    |
 LL |     default type U = str;
    |                      ^^^ the trait `Clone` is not implemented for `str`
@@ -17,11 +7,11 @@ LL |     default type U = str;
 help: the trait `Clone` is implemented for `String`
   --> $SRC_DIR/alloc/src/string.rs:LL:COL
 note: required by a bound in `X::U`
-  --> $DIR/default-associated-type-bound-1.rs:8:13
+  --> $DIR/default-associated-type-bound-1.rs:7:13
    |
 LL |     type U: Clone;
    |             ^^^^^ required by this bound in `X::U`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-associated-type-bound-2.rs b/tests/ui/specialization/default-associated-type-bound-2.rs
index 0a21b1f09106..9ea31f34c5cb 100644
--- a/tests/ui/specialization/default-associated-type-bound-2.rs
+++ b/tests/ui/specialization/default-associated-type-bound-2.rs
@@ -1,6 +1,5 @@
 // Check that generic predicates are also checked for default associated types.
 #![feature(specialization)]
-//~^ WARNING `specialization` is incomplete
 
 trait X<T> {
     type U: PartialEq<T>;
diff --git a/tests/ui/specialization/default-associated-type-bound-2.stderr b/tests/ui/specialization/default-associated-type-bound-2.stderr
index e02a945d9a9b..3d3fdbad2640 100644
--- a/tests/ui/specialization/default-associated-type-bound-2.stderr
+++ b/tests/ui/specialization/default-associated-type-bound-2.stderr
@@ -1,22 +1,12 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-associated-type-bound-2.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: can't compare `&'static B` with `B`
-  --> $DIR/default-associated-type-bound-2.rs:16:22
+  --> $DIR/default-associated-type-bound-2.rs:15:22
    |
 LL |     default type U = &'static B;
    |                      ^^^^^^^^^^ no implementation for `&'static B == B`
    |
    = help: the trait `PartialEq<B>` is not implemented for `&'static B`
 note: required by a bound in `X::U`
-  --> $DIR/default-associated-type-bound-2.rs:6:13
+  --> $DIR/default-associated-type-bound-2.rs:5:13
    |
 LL |     type U: PartialEq<T>;
    |             ^^^^^^^^^^^^ required by this bound in `X::U`
@@ -25,6 +15,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | impl<B: 'static, T> X<B> for T where &'static B: PartialEq<B> {
    |                                ++++++++++++++++++++++++++++++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.rs b/tests/ui/specialization/default-generic-associated-type-bound.rs
index 31a0685d004b..7cdb6c2052cf 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.rs
+++ b/tests/ui/specialization/default-generic-associated-type-bound.rs
@@ -1,7 +1,6 @@
 // Check that default generics associated types are validated.
 
 #![feature(specialization)]
-//~^ WARNING `specialization` is incomplete
 
 trait X {
     type U<'a>: PartialEq<&'a Self> where Self: 'a;
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.stderr b/tests/ui/specialization/default-generic-associated-type-bound.stderr
index 57d67ac526ac..7c2bde84a367 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.stderr
+++ b/tests/ui/specialization/default-generic-associated-type-bound.stderr
@@ -1,22 +1,12 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/default-generic-associated-type-bound.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: can't compare `T` with `T`
-  --> $DIR/default-generic-associated-type-bound.rs:17:26
+  --> $DIR/default-generic-associated-type-bound.rs:16:26
    |
 LL |     default type U<'a> = &'a T;
    |                          ^^^^^ no implementation for `T == T`
    |
    = note: required for `&'a T` to implement `PartialEq`
 note: required by a bound in `X::U`
-  --> $DIR/default-generic-associated-type-bound.rs:7:17
+  --> $DIR/default-generic-associated-type-bound.rs:6:17
    |
 LL |     type U<'a>: PartialEq<&'a Self> where Self: 'a;
    |                 ^^^^^^^^^^^^^^^^^^^ required by this bound in `X::U`
@@ -25,6 +15,6 @@ help: consider further restricting type parameter `T` with trait `PartialEq`
 LL | impl<T: 'static + std::cmp::PartialEq> X for T {
    |                 +++++++++++++++++++++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/defaultimpl/allowed-cross-crate.rs b/tests/ui/specialization/defaultimpl/allowed-cross-crate.rs
index 697a62ca547f..1a6c3832b16d 100644
--- a/tests/ui/specialization/defaultimpl/allowed-cross-crate.rs
+++ b/tests/ui/specialization/defaultimpl/allowed-cross-crate.rs
@@ -5,7 +5,7 @@
 
 //@ aux-build:go_trait.rs
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 extern crate go_trait;
 
diff --git a/tests/ui/specialization/defaultimpl/allowed-cross-crate.stderr b/tests/ui/specialization/defaultimpl/allowed-cross-crate.stderr
deleted file mode 100644
index 02f13d461c3c..000000000000
--- a/tests/ui/specialization/defaultimpl/allowed-cross-crate.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/allowed-cross-crate.rs:8:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/defaultimpl/out-of-order.rs b/tests/ui/specialization/defaultimpl/out-of-order.rs
index 2274946df697..bd3bfe2b8659 100644
--- a/tests/ui/specialization/defaultimpl/out-of-order.rs
+++ b/tests/ui/specialization/defaultimpl/out-of-order.rs
@@ -2,7 +2,7 @@
 
 // Test that you can list the more specific impl before the more general one.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     type Out;
diff --git a/tests/ui/specialization/defaultimpl/out-of-order.stderr b/tests/ui/specialization/defaultimpl/out-of-order.stderr
deleted file mode 100644
index 2cf1ac90959e..000000000000
--- a/tests/ui/specialization/defaultimpl/out-of-order.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/out-of-order.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/defaultimpl/overlap-projection.rs b/tests/ui/specialization/defaultimpl/overlap-projection.rs
index da466e6671c9..1af10400e5fa 100644
--- a/tests/ui/specialization/defaultimpl/overlap-projection.rs
+++ b/tests/ui/specialization/defaultimpl/overlap-projection.rs
@@ -4,7 +4,7 @@
 // projections involve specialization, so long as the associated type is
 // provided by the most specialized impl.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Assoc {
     type Output;
diff --git a/tests/ui/specialization/defaultimpl/overlap-projection.stderr b/tests/ui/specialization/defaultimpl/overlap-projection.stderr
deleted file mode 100644
index 75fdfafd9d1a..000000000000
--- a/tests/ui/specialization/defaultimpl/overlap-projection.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-projection.rs:7:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/defaultimpl/projection.rs b/tests/ui/specialization/defaultimpl/projection.rs
index 7a77c76a5ac5..9a2fc8d8f526 100644
--- a/tests/ui/specialization/defaultimpl/projection.rs
+++ b/tests/ui/specialization/defaultimpl/projection.rs
@@ -1,7 +1,7 @@
 //@ run-pass
 #![allow(dead_code)]
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Make sure we *can* project non-defaulted associated types
 // cf ui/specialization/specialization-default-projection.rs
diff --git a/tests/ui/specialization/defaultimpl/projection.stderr b/tests/ui/specialization/defaultimpl/projection.stderr
deleted file mode 100644
index cc3fe8237a74..000000000000
--- a/tests/ui/specialization/defaultimpl/projection.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/projection.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/defaultimpl/specialization-no-default.rs b/tests/ui/specialization/defaultimpl/specialization-no-default.rs
index ddc32337306f..a3b1d09680ac 100644
--- a/tests/ui/specialization/defaultimpl/specialization-no-default.rs
+++ b/tests/ui/specialization/defaultimpl/specialization-no-default.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Check a number of scenarios in which one impl tries to override another,
 // without correctly using `default`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-no-default.stderr b/tests/ui/specialization/defaultimpl/specialization-no-default.stderr
index f9e62a99baee..60c489d287ca 100644
--- a/tests/ui/specialization/defaultimpl/specialization-no-default.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-no-default.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-no-default.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default`
   --> $DIR/specialization-no-default.rs:20:5
    |
@@ -63,6 +53,6 @@ LL |     fn redundant(&self) {}
    |
    = note: to specialize, `redundant` in the parent `impl` must be marked `default`
 
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.rs b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.rs
index eb4ecf24a300..b88bf5251062 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.rs
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.rs
@@ -3,7 +3,7 @@
 // Tests that we can combine a default impl that supplies one method with a
 // full impl that supplies the other, and they can invoke one another.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     fn foo_one(&self) -> &'static str;
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.stderr b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.stderr
deleted file mode 100644
index 407c1ab77200..000000000000
--- a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented-rpass.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-trait-item-not-implemented-rpass.rs:6:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.rs b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.rs
index 3c5414469fac..2a121e61aaa9 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.rs
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.rs
@@ -1,6 +1,6 @@
 // Tests that default impls do not have to supply all items but regular impls do.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     fn foo_one(&self) -> &'static str;
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
index d3441b0e8b92..ae336da5d4a8 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-trait-item-not-implemented.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0046]: not all trait items implemented, missing: `foo_two`
   --> $DIR/specialization-trait-item-not-implemented.rs:18:1
    |
@@ -17,6 +7,6 @@ LL |     fn foo_two(&self) -> &'static str;
 LL | impl Foo for MyStruct {}
    | ^^^^^^^^^^^^^^^^^^^^^ missing `foo_two` in implementation
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.rs b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.rs
index 344dd7bb288e..2867a00e6bb5 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.rs
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.rs
@@ -2,7 +2,7 @@
 // - default impls do not have to supply all items and
 // - a default impl does not count as an impl (in this case, an incomplete default impl).
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     fn foo_one(&self) -> &'static str;
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
index 74f81bb023ef..7cec84b1af6d 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-trait-not-implemented.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0599]: no method named `foo_one` found for struct `MyStruct` in the current scope
   --> $DIR/specialization-trait-not-implemented.rs:22:29
    |
@@ -24,6 +14,6 @@ note: `Foo` defines an item `foo_one`, perhaps you need to implement it
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-wfcheck.rs b/tests/ui/specialization/defaultimpl/specialization-wfcheck.rs
index eb18d6eaac45..51b63f034808 100644
--- a/tests/ui/specialization/defaultimpl/specialization-wfcheck.rs
+++ b/tests/ui/specialization/defaultimpl/specialization-wfcheck.rs
@@ -1,6 +1,6 @@
 // Tests that a default impl still has to have a WF trait ref.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo<'a, T: Eq + 'a> { }
 
diff --git a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
index 4a51a7dfa47f..aaf020450d39 100644
--- a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-wfcheck.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `U: Eq` is not satisfied
   --> $DIR/specialization-wfcheck.rs:7:17
    |
@@ -24,6 +14,6 @@ help: consider restricting type parameter `U` with trait `Eq`
 LL | default impl<U: std::cmp::Eq> Foo<'static, U> for () {}
    |               ++++++++++++++
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/defaultimpl/validation.rs b/tests/ui/specialization/defaultimpl/validation.rs
index 78f6099c3dd9..3504d3ef28ae 100644
--- a/tests/ui/specialization/defaultimpl/validation.rs
+++ b/tests/ui/specialization/defaultimpl/validation.rs
@@ -1,5 +1,5 @@
 #![feature(negative_impls)]
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 struct S;
 struct Z;
diff --git a/tests/ui/specialization/defaultimpl/validation.stderr b/tests/ui/specialization/defaultimpl/validation.stderr
index a8dfef2dcfb1..99ae6def93bb 100644
--- a/tests/ui/specialization/defaultimpl/validation.stderr
+++ b/tests/ui/specialization/defaultimpl/validation.stderr
@@ -8,16 +8,6 @@ LL | default impl S {}
    |
    = note: only trait implementations may be annotated with `default`
 
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/validation.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0367]: `!Send` impl requires `Z: Send` but the struct it is implemented for does not
   --> $DIR/validation.rs:12:1
    |
@@ -58,7 +48,7 @@ error[E0750]: negative impls cannot be default impls
 LL | default impl !Tr for S {}
    | ^^^^^^^      ^
 
-error: aborting due to 6 previous errors; 1 warning emitted
+error: aborting due to 6 previous errors
 
 Some errors have detailed explanations: E0367, E0750.
 For more information about an error, try `rustc --explain E0367`.
diff --git a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
index 559c23455275..f0a40efde19e 100644
--- a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
+++ b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
@@ -1,7 +1,7 @@
 // This test previously tried to use a tainted `EvalCtxt` when emitting
 // an error during coherence.
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
+
 trait Iterate<'a> {
     type Ty: Valid;
 }
diff --git a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
index 611fef1df66b..5db98e73af60 100644
--- a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
+++ b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/fuzzing-ice-134905.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `(): Valid` is not satisfied
   --> $DIR/fuzzing-ice-134905.rs:12:23
    |
@@ -34,7 +24,7 @@ LL | impl<'a, T> Eq for T where <T as Iterate<'a>>::Ty: Valid {}
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0210, E0277.
 For more information about an error, try `rustc --explain E0210`.
diff --git a/tests/ui/specialization/issue-35376.rs b/tests/ui/specialization/issue-35376.rs
index 786f22967ebd..df4361bc9391 100644
--- a/tests/ui/specialization/issue-35376.rs
+++ b/tests/ui/specialization/issue-35376.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 fn main() {}
 
diff --git a/tests/ui/specialization/issue-35376.stderr b/tests/ui/specialization/issue-35376.stderr
deleted file mode 100644
index 6c4167f3f9fa..000000000000
--- a/tests/ui/specialization/issue-35376.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-35376.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/issue-36804.rs b/tests/ui/specialization/issue-36804.rs
index 5ed0c1aaf20d..c0c188ff6926 100644
--- a/tests/ui/specialization/issue-36804.rs
+++ b/tests/ui/specialization/issue-36804.rs
@@ -1,5 +1,5 @@
 //@ check-pass
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 pub struct Cloned<I>(I);
 
diff --git a/tests/ui/specialization/issue-36804.stderr b/tests/ui/specialization/issue-36804.stderr
deleted file mode 100644
index c2113b25f193..000000000000
--- a/tests/ui/specialization/issue-36804.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-36804.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/issue-38091-2.rs b/tests/ui/specialization/issue-38091-2.rs
index da276031378d..bd62a0835e4e 100644
--- a/tests/ui/specialization/issue-38091-2.rs
+++ b/tests/ui/specialization/issue-38091-2.rs
@@ -2,7 +2,6 @@
 //~^ ERROR overflow evaluating the requirement `i32: Check`
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Iterate<'a> {
     type Ty: Valid;
diff --git a/tests/ui/specialization/issue-38091-2.stderr b/tests/ui/specialization/issue-38091-2.stderr
index 828a8e933994..d0a15e609753 100644
--- a/tests/ui/specialization/issue-38091-2.stderr
+++ b/tests/ui/specialization/issue-38091-2.stderr
@@ -1,17 +1,7 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-38091-2.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0275]: overflow evaluating the requirement `i32: Check`
    |
 note: required for `i32` to implement `Iterate<'_>`
-  --> $DIR/issue-38091-2.rs:11:13
+  --> $DIR/issue-38091-2.rs:10:13
    |
 LL | impl<'a, T> Iterate<'a> for T
    |             ^^^^^^^^^^^     ^
@@ -19,6 +9,6 @@ LL | where
 LL |     T: Check,
    |        ----- unsatisfied trait bound introduced here
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/specialization/issue-38091.rs b/tests/ui/specialization/issue-38091.rs
index 5b398368a673..06236aa76c7b 100644
--- a/tests/ui/specialization/issue-38091.rs
+++ b/tests/ui/specialization/issue-38091.rs
@@ -1,5 +1,4 @@
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Iterate<'a> {
     type Ty: Valid;
diff --git a/tests/ui/specialization/issue-38091.stderr b/tests/ui/specialization/issue-38091.stderr
index eb64383e18bb..91ea3db70311 100644
--- a/tests/ui/specialization/issue-38091.stderr
+++ b/tests/ui/specialization/issue-38091.stderr
@@ -1,30 +1,20 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-38091.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0277]: the trait bound `(): Valid` is not satisfied
-  --> $DIR/issue-38091.rs:12:23
+  --> $DIR/issue-38091.rs:11:23
    |
 LL |     default type Ty = ();
    |                       ^^ the trait `Valid` is not implemented for `()`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/issue-38091.rs:20:1
+  --> $DIR/issue-38091.rs:19:1
    |
 LL | trait Valid {}
    | ^^^^^^^^^^^
 note: required by a bound in `Iterate::Ty`
-  --> $DIR/issue-38091.rs:5:14
+  --> $DIR/issue-38091.rs:4:14
    |
 LL |     type Ty: Valid;
    |              ^^^^^ required by this bound in `Iterate::Ty`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-39448.rs b/tests/ui/specialization/issue-39448.rs
index 1c8843d983a4..4d07b11f6bfc 100644
--- a/tests/ui/specialization/issue-39448.rs
+++ b/tests/ui/specialization/issue-39448.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Regression test for a specialization-related ICE (#39448).
 
diff --git a/tests/ui/specialization/issue-39448.stderr b/tests/ui/specialization/issue-39448.stderr
index e2c5f8c48468..09f2cede808b 100644
--- a/tests/ui/specialization/issue-39448.stderr
+++ b/tests/ui/specialization/issue-39448.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-39448.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0391]: cycle detected when computing whether impls specialize one another
   --> $DIR/issue-39448.rs:24:1
    |
@@ -23,6 +13,6 @@ LL | trait FromA<T> {
    | ^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/specialization/issue-39618.rs b/tests/ui/specialization/issue-39618.rs
index 14a6fcf572ea..d6346a92495a 100644
--- a/tests/ui/specialization/issue-39618.rs
+++ b/tests/ui/specialization/issue-39618.rs
@@ -2,7 +2,7 @@
 // FIXME(JohnTitor): Centril pointed out this looks suspicions, we should revisit here.
 // More context: https://github.com/rust-lang/rust/pull/69192#discussion_r379846796
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     fn foo(&self);
diff --git a/tests/ui/specialization/issue-39618.stderr b/tests/ui/specialization/issue-39618.stderr
index 756162ce92c3..ca3c250fefe9 100644
--- a/tests/ui/specialization/issue-39618.stderr
+++ b/tests/ui/specialization/issue-39618.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-39618.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0391]: cycle detected when computing whether impls specialize one another
   --> $DIR/issue-39618.rs:19:1
    |
@@ -23,6 +13,6 @@ LL | trait Foo {
    | ^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/specialization/issue-50452-fail.rs b/tests/ui/specialization/issue-50452-fail.rs
index fe21e9b6ede5..3096ac38da96 100644
--- a/tests/ui/specialization/issue-50452-fail.rs
+++ b/tests/ui/specialization/issue-50452-fail.rs
@@ -1,5 +1,4 @@
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 pub trait Foo {
     fn foo();
diff --git a/tests/ui/specialization/issue-50452-fail.stderr b/tests/ui/specialization/issue-50452-fail.stderr
index 7ac4b39993cd..5bca4cc7f13f 100644
--- a/tests/ui/specialization/issue-50452-fail.stderr
+++ b/tests/ui/specialization/issue-50452-fail.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-50452-fail.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/issue-50452-fail.rs:10:5
+  --> $DIR/issue-50452-fail.rs:9:5
    |
 LL |     fn foo() {}
    |     ^^^^^^^^ cannot specialize default item `foo`
@@ -19,6 +9,6 @@ LL | impl<T> Foo for T {
    |
    = note: to specialize, `foo` in the parent `impl` must be marked `default`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/issue-50452.rs b/tests/ui/specialization/issue-50452.rs
index c379825feda9..629ae80f6a64 100644
--- a/tests/ui/specialization/issue-50452.rs
+++ b/tests/ui/specialization/issue-50452.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 pub trait Foo {
     fn foo();
diff --git a/tests/ui/specialization/issue-50452.stderr b/tests/ui/specialization/issue-50452.stderr
deleted file mode 100644
index 48cab9dcdb7a..000000000000
--- a/tests/ui/specialization/issue-50452.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-50452.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/issue-52050.rs b/tests/ui/specialization/issue-52050.rs
index 804658702066..1e1bfe9cf075 100644
--- a/tests/ui/specialization/issue-52050.rs
+++ b/tests/ui/specialization/issue-52050.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Regression test for #52050: when inserting the blanket impl `I`
 // into the tree, we had to replace the child node for `Foo`, which
diff --git a/tests/ui/specialization/issue-52050.stderr b/tests/ui/specialization/issue-52050.stderr
index 3b0cac514643..b8368c6312de 100644
--- a/tests/ui/specialization/issue-52050.stderr
+++ b/tests/ui/specialization/issue-52050.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-52050.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `IntoPyDictPointer` for type `()`
   --> $DIR/issue-52050.rs:28:1
    |
@@ -21,6 +11,6 @@ LL |   impl IntoPyDictPointer for ()
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `()` in future versions
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/issue-63716-parse-async.rs b/tests/ui/specialization/issue-63716-parse-async.rs
index 00c0b291a1ad..26fd84bbf31f 100644
--- a/tests/ui/specialization/issue-63716-parse-async.rs
+++ b/tests/ui/specialization/issue-63716-parse-async.rs
@@ -4,7 +4,7 @@
 //@ check-pass
 //@ edition:2018
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 fn main() {}
 
diff --git a/tests/ui/specialization/issue-63716-parse-async.stderr b/tests/ui/specialization/issue-63716-parse-async.stderr
deleted file mode 100644
index a00572da8f54..000000000000
--- a/tests/ui/specialization/issue-63716-parse-async.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-63716-parse-async.rs:7:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/issue-70442.rs b/tests/ui/specialization/issue-70442.rs
index fb82b0db09b5..c2168b30ba52 100644
--- a/tests/ui/specialization/issue-70442.rs
+++ b/tests/ui/specialization/issue-70442.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 //@ check-pass
 
diff --git a/tests/ui/specialization/issue-70442.stderr b/tests/ui/specialization/issue-70442.stderr
deleted file mode 100644
index aa72c32866a2..000000000000
--- a/tests/ui/specialization/issue-70442.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/issue-70442.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/non-defaulted-item-fail.rs b/tests/ui/specialization/non-defaulted-item-fail.rs
index b7d6ac829dd1..403f718d7dd9 100644
--- a/tests/ui/specialization/non-defaulted-item-fail.rs
+++ b/tests/ui/specialization/non-defaulted-item-fail.rs
@@ -1,5 +1,4 @@
 #![feature(specialization, associated_type_defaults)]
-//~^ WARN the feature `specialization` is incomplete
 
 // Test that attempting to override a non-default method or one not in the
 // parent impl causes an error.
diff --git a/tests/ui/specialization/non-defaulted-item-fail.stderr b/tests/ui/specialization/non-defaulted-item-fail.stderr
index 9d62a353da72..739f1711ec44 100644
--- a/tests/ui/specialization/non-defaulted-item-fail.stderr
+++ b/tests/ui/specialization/non-defaulted-item-fail.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/non-defaulted-item-fail.rs:1:12
-   |
-LL | #![feature(specialization, associated_type_defaults)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0520]: `Ty` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:30:5
+  --> $DIR/non-defaulted-item-fail.rs:29:5
    |
 LL | impl<T> Foo for Box<T> {
    | ---------------------- parent `impl` is here
@@ -20,7 +10,7 @@ LL |     type Ty = Vec<()>;
    = note: to specialize, `Ty` in the parent `impl` must be marked `default`
 
 error[E0520]: `CONST` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:32:5
+  --> $DIR/non-defaulted-item-fail.rs:31:5
    |
 LL | impl<T> Foo for Box<T> {
    | ---------------------- parent `impl` is here
@@ -31,7 +21,7 @@ LL |     const CONST: u8 = 42;
    = note: to specialize, `CONST` in the parent `impl` must be marked `default`
 
 error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:34:5
+  --> $DIR/non-defaulted-item-fail.rs:33:5
    |
 LL | impl<T> Foo for Box<T> {
    | ---------------------- parent `impl` is here
@@ -42,7 +32,7 @@ LL |     fn foo(&self) -> bool { true }
    = note: to specialize, `foo` in the parent `impl` must be marked `default`
 
 error[E0520]: `Ty` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:46:5
+  --> $DIR/non-defaulted-item-fail.rs:45:5
    |
 LL | impl<T> Foo for Vec<T> {}
    | ---------------------- parent `impl` is here
@@ -53,7 +43,7 @@ LL |     type Ty = Vec<()>;
    = note: to specialize, `Ty` in the parent `impl` must be marked `default`
 
 error[E0520]: `CONST` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:48:5
+  --> $DIR/non-defaulted-item-fail.rs:47:5
    |
 LL | impl<T> Foo for Vec<T> {}
    | ---------------------- parent `impl` is here
@@ -64,7 +54,7 @@ LL |     const CONST: u8 = 42;
    = note: to specialize, `CONST` in the parent `impl` must be marked `default`
 
 error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/non-defaulted-item-fail.rs:50:5
+  --> $DIR/non-defaulted-item-fail.rs:49:5
    |
 LL | impl<T> Foo for Vec<T> {}
    | ---------------------- parent `impl` is here
@@ -74,6 +64,6 @@ LL |     fn foo(&self) -> bool { true }
    |
    = note: to specialize, `foo` in the parent `impl` must be marked `default`
 
-error: aborting due to 6 previous errors; 1 warning emitted
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
index 578a46c67400..0cf609289127 100644
--- a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
+++ b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.rs
@@ -1,8 +1,6 @@
 // Regression test for #140571. The compiler used to ICE
 
 #![feature(min_generic_const_args, specialization)]
-//~^ WARN the feature `specialization` is incomplete
-//~| WARN the feature `min_generic_const_args` is incomplete
 
 pub trait IsVoid {
 
diff --git a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
index 9361f7d6222f..3ec3e83cc1d4 100644
--- a/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
+++ b/tests/ui/specialization/overlap-due-to-unsatisfied-const-bound.stderr
@@ -1,29 +1,11 @@
-warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:12
-   |
-LL | #![feature(min_generic_const_args, specialization)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:3:36
-   |
-LL | #![feature(min_generic_const_args, specialization)]
-   |                                    ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-
 error[E0119]: conflicting implementations of trait `Maybe<()>` for type `()`
-  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:20:1
+  --> $DIR/overlap-due-to-unsatisfied-const-bound.rs:18:1
    |
 LL | impl<T> Maybe<T> for T {}
    | ---------------------- first implementation here
 LL | impl<T> Maybe<T> for () where T: NotVoid + ?Sized {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `()`
 
-error: aborting due to 1 previous error; 2 warnings emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/prefer-specializing-impl-over-default.current.stderr b/tests/ui/specialization/prefer-specializing-impl-over-default.current.stderr
deleted file mode 100644
index 7e3df0c83f9f..000000000000
--- a/tests/ui/specialization/prefer-specializing-impl-over-default.current.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/prefer-specializing-impl-over-default.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/prefer-specializing-impl-over-default.next.stderr b/tests/ui/specialization/prefer-specializing-impl-over-default.next.stderr
deleted file mode 100644
index 7e3df0c83f9f..000000000000
--- a/tests/ui/specialization/prefer-specializing-impl-over-default.next.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/prefer-specializing-impl-over-default.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/prefer-specializing-impl-over-default.rs b/tests/ui/specialization/prefer-specializing-impl-over-default.rs
index af6837b30caf..4fa5b3e86c87 100644
--- a/tests/ui/specialization/prefer-specializing-impl-over-default.rs
+++ b/tests/ui/specialization/prefer-specializing-impl-over-default.rs
@@ -3,7 +3,6 @@
 //@[next] compile-flags: -Znext-solver
 //@ check-pass
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait WithAssoc: 'static {
     type Assoc;
diff --git a/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.next.stderr b/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.next.stderr
deleted file mode 100644
index 17918a77821d..000000000000
--- a/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.next.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/source-impl-requires-constraining-predicates-ambig.rs:14:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.rs b/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.rs
index 2296cd8a9375..ff56965a94c8 100644
--- a/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.rs
+++ b/tests/ui/specialization/source-impl-requires-constraining-predicates-ambig.rs
@@ -12,7 +12,6 @@
 // is ambiguous.
 
 #![feature(specialization)]
-//[next]~^ WARN the feature `specialization` is incomplete
 
 trait Spec {
     type Assoc;
diff --git a/tests/ui/specialization/source-impl-requires-constraining-predicates.current.stderr b/tests/ui/specialization/source-impl-requires-constraining-predicates.current.stderr
deleted file mode 100644
index 3442e5b5ca61..000000000000
--- a/tests/ui/specialization/source-impl-requires-constraining-predicates.current.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/source-impl-requires-constraining-predicates.rs:9:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/source-impl-requires-constraining-predicates.next.stderr b/tests/ui/specialization/source-impl-requires-constraining-predicates.next.stderr
deleted file mode 100644
index 3442e5b5ca61..000000000000
--- a/tests/ui/specialization/source-impl-requires-constraining-predicates.next.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/source-impl-requires-constraining-predicates.rs:9:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/source-impl-requires-constraining-predicates.rs b/tests/ui/specialization/source-impl-requires-constraining-predicates.rs
index 532fc3676406..690649de0239 100644
--- a/tests/ui/specialization/source-impl-requires-constraining-predicates.rs
+++ b/tests/ui/specialization/source-impl-requires-constraining-predicates.rs
@@ -7,7 +7,6 @@
 // `[u32; 0]: IntoIterator<Item = ?U>` predicate to constrain the `?U` impl arg.
 
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 trait Spec {
     type Assoc;
diff --git a/tests/ui/specialization/specialization-allowed-cross-crate.rs b/tests/ui/specialization/specialization-allowed-cross-crate.rs
index 697a62ca547f..1a6c3832b16d 100644
--- a/tests/ui/specialization/specialization-allowed-cross-crate.rs
+++ b/tests/ui/specialization/specialization-allowed-cross-crate.rs
@@ -5,7 +5,7 @@
 
 //@ aux-build:go_trait.rs
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 extern crate go_trait;
 
diff --git a/tests/ui/specialization/specialization-allowed-cross-crate.stderr b/tests/ui/specialization/specialization-allowed-cross-crate.stderr
deleted file mode 100644
index 3eea4a53bf5f..000000000000
--- a/tests/ui/specialization/specialization-allowed-cross-crate.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-allowed-cross-crate.rs:8:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-assoc-fns.rs b/tests/ui/specialization/specialization-assoc-fns.rs
index 75f0b0d24850..596b1c925962 100644
--- a/tests/ui/specialization/specialization-assoc-fns.rs
+++ b/tests/ui/specialization/specialization-assoc-fns.rs
@@ -2,7 +2,7 @@
 
 // Test that non-method associated functions can be specialized
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     fn mk() -> Self;
diff --git a/tests/ui/specialization/specialization-assoc-fns.stderr b/tests/ui/specialization/specialization-assoc-fns.stderr
deleted file mode 100644
index 69f7cece79de..000000000000
--- a/tests/ui/specialization/specialization-assoc-fns.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-assoc-fns.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-basics.rs b/tests/ui/specialization/specialization-basics.rs
index dc320b2b91fc..76cba35c7fd5 100644
--- a/tests/ui/specialization/specialization-basics.rs
+++ b/tests/ui/specialization/specialization-basics.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Tests a variety of basic specialization scenarios and method
 // dispatch for them.
diff --git a/tests/ui/specialization/specialization-basics.stderr b/tests/ui/specialization/specialization-basics.stderr
deleted file mode 100644
index 7714d4af4c63..000000000000
--- a/tests/ui/specialization/specialization-basics.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-basics.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-cross-crate.rs b/tests/ui/specialization/specialization-cross-crate.rs
index 6daf48b6d9b5..39001819ed95 100644
--- a/tests/ui/specialization/specialization-cross-crate.rs
+++ b/tests/ui/specialization/specialization-cross-crate.rs
@@ -2,7 +2,7 @@
 
 //@ aux-build:specialization_cross_crate.rs
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 extern crate specialization_cross_crate;
 
diff --git a/tests/ui/specialization/specialization-cross-crate.stderr b/tests/ui/specialization/specialization-cross-crate.stderr
deleted file mode 100644
index 06818bb5627d..000000000000
--- a/tests/ui/specialization/specialization-cross-crate.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-cross-crate.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-default-methods.rs b/tests/ui/specialization/specialization-default-methods.rs
index 7058c039e465..1699fad2a9c7 100644
--- a/tests/ui/specialization/specialization-default-methods.rs
+++ b/tests/ui/specialization/specialization-default-methods.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Test that default methods are cascaded correctly
 
diff --git a/tests/ui/specialization/specialization-default-methods.stderr b/tests/ui/specialization/specialization-default-methods.stderr
deleted file mode 100644
index d78d30bd802f..000000000000
--- a/tests/ui/specialization/specialization-default-methods.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-default-methods.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-default-projection.current.stderr b/tests/ui/specialization/specialization-default-projection.current.stderr
index b88c1a94baf9..859f83e2314e 100644
--- a/tests/ui/specialization/specialization-default-projection.current.stderr
+++ b/tests/ui/specialization/specialization-default-projection.current.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-default-projection.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/specialization-default-projection.rs:25:5
    |
@@ -42,6 +32,6 @@ LL |     generic::<()>()
    = note: the associated type `<() as Foo>::Assoc` is defined as `()` in the implementation, but the where-bound `()` shadows this definition
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/specialization-default-projection.next.stderr b/tests/ui/specialization/specialization-default-projection.next.stderr
index a385b16a2d8b..1a5869f2d0a5 100644
--- a/tests/ui/specialization/specialization-default-projection.next.stderr
+++ b/tests/ui/specialization/specialization-default-projection.next.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-default-projection.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/specialization-default-projection.rs:25:5
    |
@@ -42,6 +32,6 @@ LL |     generic::<()>()
    = note: the associated type `<() as Foo>::Assoc` is defined as `()` in the implementation, but the where-bound `()` shadows this definition
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/specialization-default-projection.rs b/tests/ui/specialization/specialization-default-projection.rs
index 4f69ccb59746..36f20b63eff0 100644
--- a/tests/ui/specialization/specialization-default-projection.rs
+++ b/tests/ui/specialization/specialization-default-projection.rs
@@ -2,7 +2,7 @@
 //@ ignore-compare-mode-next-solver (explicit revisions)
 //@[next] compile-flags: -Znext-solver
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Make sure we can't project defaulted associated types
 
diff --git a/tests/ui/specialization/specialization-default-types.current.stderr b/tests/ui/specialization/specialization-default-types.current.stderr
index 8df170cbb767..2447669a8398 100644
--- a/tests/ui/specialization/specialization-default-types.current.stderr
+++ b/tests/ui/specialization/specialization-default-types.current.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-default-types.rs:9:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/specialization-default-types.rs:19:9
    |
@@ -38,6 +28,6 @@ LL |     Example::generate(t)
    = note: the associated type `<T as Example>::Output` is defined as `Box<T>` in the implementation, but the where-bound `T` shadows this definition
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/specialization-default-types.next.stderr b/tests/ui/specialization/specialization-default-types.next.stderr
index 4ea9b996c86a..b6f61b40ccb2 100644
--- a/tests/ui/specialization/specialization-default-types.next.stderr
+++ b/tests/ui/specialization/specialization-default-types.next.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-default-types.rs:9:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0308]: mismatched types
   --> $DIR/specialization-default-types.rs:19:9
    |
@@ -38,6 +28,6 @@ LL |     Example::generate(t)
    = note: the associated type `<T as Example>::Output` is defined as `Box<T>` in the implementation, but the where-bound `T` shadows this definition
            see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/specialization-default-types.rs b/tests/ui/specialization/specialization-default-types.rs
index 77817abea127..ffbe8568b97d 100644
--- a/tests/ui/specialization/specialization-default-types.rs
+++ b/tests/ui/specialization/specialization-default-types.rs
@@ -6,7 +6,7 @@
 // associated type in the impl defining it -- otherwise, what happens
 // if it's overridden?
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Example {
     type Output;
diff --git a/tests/ui/specialization/specialization-no-default.rs b/tests/ui/specialization/specialization-no-default.rs
index ae739b2358d5..57346b26d24e 100644
--- a/tests/ui/specialization/specialization-no-default.rs
+++ b/tests/ui/specialization/specialization-no-default.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Check a number of scenarios in which one impl tries to override another,
 // without correctly using `default`.
diff --git a/tests/ui/specialization/specialization-no-default.stderr b/tests/ui/specialization/specialization-no-default.stderr
index 695a3f6cc45d..07c352995842 100644
--- a/tests/ui/specialization/specialization-no-default.stderr
+++ b/tests/ui/specialization/specialization-no-default.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-no-default.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0520]: `foo` specializes an item from a parent `impl`, but that item is not marked `default`
   --> $DIR/specialization-no-default.rs:20:5
    |
@@ -63,6 +53,6 @@ LL |     default fn redundant(&self) {}
    |
    = note: to specialize, `redundant` in the parent `impl` must be marked `default`
 
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/specialization-on-projection.rs b/tests/ui/specialization/specialization-on-projection.rs
index 876439ca0a7d..f5fc13185a76 100644
--- a/tests/ui/specialization/specialization-on-projection.rs
+++ b/tests/ui/specialization/specialization-on-projection.rs
@@ -1,7 +1,7 @@
 //@ run-pass
 #![allow(dead_code)]
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Ensure that specialization works for impls defined directly on a projection
 
diff --git a/tests/ui/specialization/specialization-on-projection.stderr b/tests/ui/specialization/specialization-on-projection.stderr
deleted file mode 100644
index 00fc7ffc5471..000000000000
--- a/tests/ui/specialization/specialization-on-projection.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-on-projection.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-out-of-order.rs b/tests/ui/specialization/specialization-out-of-order.rs
index 4f4d40f43d4b..72b2856999ab 100644
--- a/tests/ui/specialization/specialization-out-of-order.rs
+++ b/tests/ui/specialization/specialization-out-of-order.rs
@@ -2,7 +2,7 @@
 
 // Test that you can list the more specific impl before the more general one.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo {
     type Out;
diff --git a/tests/ui/specialization/specialization-out-of-order.stderr b/tests/ui/specialization/specialization-out-of-order.stderr
deleted file mode 100644
index b524e00f01c8..000000000000
--- a/tests/ui/specialization/specialization-out-of-order.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-out-of-order.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-overlap-negative.rs b/tests/ui/specialization/specialization-overlap-negative.rs
index 244f21c7ba90..d5cf51ef98f6 100644
--- a/tests/ui/specialization/specialization-overlap-negative.rs
+++ b/tests/ui/specialization/specialization-overlap-negative.rs
@@ -1,5 +1,5 @@
 #![feature(negative_impls)]
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait MyTrait {}
 
diff --git a/tests/ui/specialization/specialization-overlap-negative.stderr b/tests/ui/specialization/specialization-overlap-negative.stderr
index 4874e897726f..3e1cf4006a65 100644
--- a/tests/ui/specialization/specialization-overlap-negative.stderr
+++ b/tests/ui/specialization/specialization-overlap-negative.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-overlap-negative.rs:2:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0751]: found both positive and negative implementation of trait `Send` for type `TestType<_>`:
   --> $DIR/specialization-overlap-negative.rs:9:1
    |
@@ -28,7 +18,7 @@ note: the implementor must specify the same requirement
 LL | struct TestType<T>(::std::marker::PhantomData<T>);
    | ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0367, E0751.
 For more information about an error, try `rustc --explain E0367`.
diff --git a/tests/ui/specialization/specialization-overlap-projection.rs b/tests/ui/specialization/specialization-overlap-projection.rs
index f7a2a7922432..504e5d1c57f8 100644
--- a/tests/ui/specialization/specialization-overlap-projection.rs
+++ b/tests/ui/specialization/specialization-overlap-projection.rs
@@ -2,7 +2,6 @@
 // projections involve specialization, so long as the associated type is
 // provided by the most specialized impl.
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
 
 trait Assoc {
     type Output;
diff --git a/tests/ui/specialization/specialization-overlap-projection.stderr b/tests/ui/specialization/specialization-overlap-projection.stderr
index 5f3cd9c66cfe..270a498e5c7d 100644
--- a/tests/ui/specialization/specialization-overlap-projection.stderr
+++ b/tests/ui/specialization/specialization-overlap-projection.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-overlap-projection.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `Foo` for type `u32`
-  --> $DIR/specialization-overlap-projection.rs:20:1
+  --> $DIR/specialization-overlap-projection.rs:19:1
    |
 LL | impl Foo for u32 {}
    | ---------------- first implementation here
@@ -17,7 +7,7 @@ LL | impl Foo for <u8 as Assoc>::Output {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u32`
 
 error[E0119]: conflicting implementations of trait `Foo` for type `u32`
-  --> $DIR/specialization-overlap-projection.rs:22:1
+  --> $DIR/specialization-overlap-projection.rs:21:1
    |
 LL | impl Foo for u32 {}
    | ---------------- first implementation here
@@ -25,6 +15,6 @@ LL | impl Foo for u32 {}
 LL | impl Foo for <u16 as Assoc>::Output {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u32`
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/specialization-overlap.rs b/tests/ui/specialization/specialization-overlap.rs
index 6bee22ceb8b6..c8ef8d61c1e8 100644
--- a/tests/ui/specialization/specialization-overlap.rs
+++ b/tests/ui/specialization/specialization-overlap.rs
@@ -1,4 +1,4 @@
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Foo { fn foo() {} }
 impl<T: Clone> Foo for T {}
diff --git a/tests/ui/specialization/specialization-overlap.stderr b/tests/ui/specialization/specialization-overlap.stderr
index 098bf4a70ab4..ca32c173a32c 100644
--- a/tests/ui/specialization/specialization-overlap.stderr
+++ b/tests/ui/specialization/specialization-overlap.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-overlap.rs:1:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `Foo` for type `Vec<_>`
   --> $DIR/specialization-overlap.rs:5:1
    |
@@ -40,6 +30,6 @@ LL | impl<T: Clone> Qux for T {}
 LL | impl<T: Eq> Qux for T {}
    | ^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/specialization-polarity.rs b/tests/ui/specialization/specialization-polarity.rs
index b3cd8255bb9b..7427246eb467 100644
--- a/tests/ui/specialization/specialization-polarity.rs
+++ b/tests/ui/specialization/specialization-polarity.rs
@@ -2,7 +2,7 @@
 
 #![feature(auto_traits)]
 #![feature(negative_impls)]
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 auto trait Foo {}
 
diff --git a/tests/ui/specialization/specialization-polarity.stderr b/tests/ui/specialization/specialization-polarity.stderr
index f287018ba7f7..44e60cad67aa 100644
--- a/tests/ui/specialization/specialization-polarity.stderr
+++ b/tests/ui/specialization/specialization-polarity.stderr
@@ -1,13 +1,3 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-polarity.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0751]: found both positive and negative implementation of trait `Foo` for type `u8`:
   --> $DIR/specialization-polarity.rs:10:1
    |
@@ -24,6 +14,6 @@ LL | impl<T> !Bar for T {}
 LL | impl Bar for u8 {}
    | ^^^^^^^^^^^^^^^ positive implementation here
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/specialization/specialization-projection-alias.rs b/tests/ui/specialization/specialization-projection-alias.rs
index 73d6115af00b..92368b17b98b 100644
--- a/tests/ui/specialization/specialization-projection-alias.rs
+++ b/tests/ui/specialization/specialization-projection-alias.rs
@@ -2,7 +2,7 @@
 #![allow(dead_code)]
 #![allow(unused_variables)]
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Regression test for ICE when combining specialized associated types and type
 // aliases
diff --git a/tests/ui/specialization/specialization-projection-alias.stderr b/tests/ui/specialization/specialization-projection-alias.stderr
deleted file mode 100644
index c94d9ed07b19..000000000000
--- a/tests/ui/specialization/specialization-projection-alias.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-projection-alias.rs:5:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-projection.rs b/tests/ui/specialization/specialization-projection.rs
index b3efa6f39ddd..20105fb9fdb1 100644
--- a/tests/ui/specialization/specialization-projection.rs
+++ b/tests/ui/specialization/specialization-projection.rs
@@ -1,7 +1,7 @@
 //@ run-pass
 #![allow(dead_code)]
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Make sure we *can* project non-defaulted associated types
 // cf ui/specialization/specialization-default-projection.rs
diff --git a/tests/ui/specialization/specialization-projection.stderr b/tests/ui/specialization/specialization-projection.stderr
deleted file mode 100644
index bfc4e0a0f5d7..000000000000
--- a/tests/ui/specialization/specialization-projection.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-projection.rs:4:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-supertraits.rs b/tests/ui/specialization/specialization-supertraits.rs
index cb4cfef4bdd1..ffb20fe6d1a2 100644
--- a/tests/ui/specialization/specialization-supertraits.rs
+++ b/tests/ui/specialization/specialization-supertraits.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 // Test that you can specialize via an explicit trait hierarchy
 
diff --git a/tests/ui/specialization/specialization-supertraits.stderr b/tests/ui/specialization/specialization-supertraits.stderr
deleted file mode 100644
index e716bc21596b..000000000000
--- a/tests/ui/specialization/specialization-supertraits.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-supertraits.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-translate-projections-with-lifetimes.rs b/tests/ui/specialization/specialization-translate-projections-with-lifetimes.rs
index 75d9a0d8ad05..06f7cdd3398a 100644
--- a/tests/ui/specialization/specialization-translate-projections-with-lifetimes.rs
+++ b/tests/ui/specialization/specialization-translate-projections-with-lifetimes.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Iterator {
     fn next(&self);
diff --git a/tests/ui/specialization/specialization-translate-projections-with-lifetimes.stderr b/tests/ui/specialization/specialization-translate-projections-with-lifetimes.stderr
deleted file mode 100644
index c7aad3c0fee1..000000000000
--- a/tests/ui/specialization/specialization-translate-projections-with-lifetimes.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-translate-projections-with-lifetimes.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-translate-projections-with-params.rs b/tests/ui/specialization/specialization-translate-projections-with-params.rs
index 330f51877aba..3b2f2c6a3418 100644
--- a/tests/ui/specialization/specialization-translate-projections-with-params.rs
+++ b/tests/ui/specialization/specialization-translate-projections-with-params.rs
@@ -4,7 +4,7 @@
 // type parameters *and* rely on projections, and the type parameters are input
 // types on the trait.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Trait<T> {
     fn convert(&self) -> T;
diff --git a/tests/ui/specialization/specialization-translate-projections-with-params.stderr b/tests/ui/specialization/specialization-translate-projections-with-params.stderr
deleted file mode 100644
index 1c4fd9325a68..000000000000
--- a/tests/ui/specialization/specialization-translate-projections-with-params.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-translate-projections-with-params.rs:7:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/specialization-translate-projections.rs b/tests/ui/specialization/specialization-translate-projections.rs
index 01c7619b065c..c718f9329eae 100644
--- a/tests/ui/specialization/specialization-translate-projections.rs
+++ b/tests/ui/specialization/specialization-translate-projections.rs
@@ -3,8 +3,7 @@
 // Ensure that provided items are inherited properly even when impls vary in
 // type parameters *and* rely on projections.
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
-
+#![feature(specialization)]
 
 trait Trait {
     fn to_u8(&self) -> u8;
diff --git a/tests/ui/specialization/specialization-translate-projections.stderr b/tests/ui/specialization/specialization-translate-projections.stderr
deleted file mode 100644
index 22bbb12a09b5..000000000000
--- a/tests/ui/specialization/specialization-translate-projections.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/specialization-translate-projections.rs:6:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/trait-specialization-default-methods-55380.rs b/tests/ui/specialization/trait-specialization-default-methods-55380.rs
index b3d79fb5ffb6..eeafcc16cd69 100644
--- a/tests/ui/specialization/trait-specialization-default-methods-55380.rs
+++ b/tests/ui/specialization/trait-specialization-default-methods-55380.rs
@@ -1,7 +1,6 @@
 // https://github.com/rust-lang/rust/issues/55380
 //@ run-pass
 #![feature(specialization)]
-//~^ WARN the feature `specialization` is incomplete
 
 pub trait Foo {
     fn abc() -> u32;
diff --git a/tests/ui/specialization/trait-specialization-default-methods-55380.stderr b/tests/ui/specialization/trait-specialization-default-methods-55380.stderr
deleted file mode 100644
index f7c1903da629..000000000000
--- a/tests/ui/specialization/trait-specialization-default-methods-55380.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/trait-specialization-default-methods-55380.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/specialization/transmute-specialization.rs b/tests/ui/specialization/transmute-specialization.rs
index a896c14e6370..da0f12cf7169 100644
--- a/tests/ui/specialization/transmute-specialization.rs
+++ b/tests/ui/specialization/transmute-specialization.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+#![feature(specialization)]
 
 trait Specializable { type Output; }
 
diff --git a/tests/ui/specialization/transmute-specialization.stderr b/tests/ui/specialization/transmute-specialization.stderr
deleted file mode 100644
index b1c26d7dacc6..000000000000
--- a/tests/ui/specialization/transmute-specialization.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/transmute-specialization.rs:3:12
-   |
-LL | #![feature(specialization)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.min_spec.stderr b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.min_spec.stderr
index 520a6833f5a5..ad3c177862ae 100644
--- a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.min_spec.stderr
+++ b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.min_spec.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `Value` for type `FortyTwo`
-  --> $DIR/const-default-impl-non-const-specialized-impl.rs:21:1
+  --> $DIR/const-default-impl-non-const-specialized-impl.rs:20:1
    |
 LL | impl<T> const Value for T {
    | ------------------------- first implementation here
diff --git a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.rs b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.rs
index f7cd4599561c..b26e65590169 100644
--- a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.rs
+++ b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.rs
@@ -3,7 +3,6 @@
 
 #![feature(const_trait_impl)]
 #![cfg_attr(spec, feature(specialization))]
-//[spec]~^ WARN the feature `specialization` is incomplete
 #![cfg_attr(min_spec, feature(min_specialization))]
 
 const trait Value {
diff --git a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.spec.stderr b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.spec.stderr
index 397d67855945..ad3c177862ae 100644
--- a/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.spec.stderr
+++ b/tests/ui/traits/const-traits/specialization/const-default-impl-non-const-specialized-impl.spec.stderr
@@ -1,15 +1,5 @@
-warning: the feature `specialization` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/const-default-impl-non-const-specialized-impl.rs:5:27
-   |
-LL | #![cfg_attr(spec, feature(specialization))]
-   |                           ^^^^^^^^^^^^^^
-   |
-   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
-   = help: consider using `min_specialization` instead, which is more stable and complete
-   = note: `#[warn(incomplete_features)]` on by default
-
 error[E0119]: conflicting implementations of trait `Value` for type `FortyTwo`
-  --> $DIR/const-default-impl-non-const-specialized-impl.rs:21:1
+  --> $DIR/const-default-impl-non-const-specialized-impl.rs:20:1
    |
 LL | impl<T> const Value for T {
    | ------------------------- first implementation here
@@ -17,6 +7,6 @@ LL | impl<T> const Value for T {
 LL | impl Value for FortyTwo {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `FortyTwo`
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.

From 63a2011abb695a45df4002a66a585a8947b7a16a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 24 Mar 2026 22:19:21 +0100
Subject: [PATCH 0893/1059] test miri_start with and without std

---
 .../pass/{no_std_miri_start.rs => miri_start_no_std.rs}   | 0
 ...{no_std_miri_start.stdout => miri_start_no_std.stdout} | 0
 src/tools/miri/tests/pass/miri_start_with_std.rs          | 8 ++++++++
 src/tools/miri/tests/pass/miri_start_with_std.stdout      | 1 +
 4 files changed, 9 insertions(+)
 rename src/tools/miri/tests/pass/{no_std_miri_start.rs => miri_start_no_std.rs} (100%)
 rename src/tools/miri/tests/pass/{no_std_miri_start.stdout => miri_start_no_std.stdout} (100%)
 create mode 100644 src/tools/miri/tests/pass/miri_start_with_std.rs
 create mode 100644 src/tools/miri/tests/pass/miri_start_with_std.stdout

diff --git a/src/tools/miri/tests/pass/no_std_miri_start.rs b/src/tools/miri/tests/pass/miri_start_no_std.rs
similarity index 100%
rename from src/tools/miri/tests/pass/no_std_miri_start.rs
rename to src/tools/miri/tests/pass/miri_start_no_std.rs
diff --git a/src/tools/miri/tests/pass/no_std_miri_start.stdout b/src/tools/miri/tests/pass/miri_start_no_std.stdout
similarity index 100%
rename from src/tools/miri/tests/pass/no_std_miri_start.stdout
rename to src/tools/miri/tests/pass/miri_start_no_std.stdout
diff --git a/src/tools/miri/tests/pass/miri_start_with_std.rs b/src/tools/miri/tests/pass/miri_start_with_std.rs
new file mode 100644
index 000000000000..510b9d419622
--- /dev/null
+++ b/src/tools/miri/tests/pass/miri_start_with_std.rs
@@ -0,0 +1,8 @@
+#![no_main]
+
+#[no_mangle]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    let _b = Box::new(0);
+    println!("hello, world!");
+    0
+}
diff --git a/src/tools/miri/tests/pass/miri_start_with_std.stdout b/src/tools/miri/tests/pass/miri_start_with_std.stdout
new file mode 100644
index 000000000000..270c611ee72c
--- /dev/null
+++ b/src/tools/miri/tests/pass/miri_start_with_std.stdout
@@ -0,0 +1 @@
+hello, world!

From 283d705b314d8b393134f694ce005b5b5959ad60 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Wed, 25 Mar 2026 07:32:01 +0800
Subject: [PATCH 0894/1059] Update LLVM to 22.1.2

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 41f177ed26a5..05918363362b 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 41f177ed26a5252a30ea6090a4da66ce0a96bf44
+Subproject commit 05918363362b439b9b0bced3daa14badd75da790

From 62ba3c1022f2070125f070dadeb6d6dae694b3a0 Mon Sep 17 00:00:00 2001
From: kyleecodes <kyleecodes@gmail.com>
Date: Wed, 25 Mar 2026 00:35:04 +0000
Subject: [PATCH 0895/1059] Move ui/issues tests to relevant subdirectories

* tests(ui): migrate issues/issue-17546 to ui/resolve
* tests(ui): add gh issue link
* tests(ui/issues): move tests to variants dir
---
 .../variant-result-noresult-used-as-type.rs}              | 1 +
 .../variant-result-noresult-used-as-type.stderr}          | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)
 rename tests/ui/{issues/issue-17546.rs => variants/variant-result-noresult-used-as-type.rs} (94%)
 rename tests/ui/{issues/issue-17546.stderr => variants/variant-result-noresult-used-as-type.stderr} (89%)

diff --git a/tests/ui/issues/issue-17546.rs b/tests/ui/variants/variant-result-noresult-used-as-type.rs
similarity index 94%
rename from tests/ui/issues/issue-17546.rs
rename to tests/ui/variants/variant-result-noresult-used-as-type.rs
index 1f0afc368a2e..14433c1460eb 100644
--- a/tests/ui/issues/issue-17546.rs
+++ b/tests/ui/variants/variant-result-noresult-used-as-type.rs
@@ -1,5 +1,6 @@
 //@ edition:2015
 //@ ignore-sgx std::os::fortanix_sgx::usercalls::raw::Result changes compiler suggestions
+// https://github.com/rust-lang/rust/issues/17546
 
 use foo::MyEnum::Result;
 use foo::NoResult; // Through a re-export
diff --git a/tests/ui/issues/issue-17546.stderr b/tests/ui/variants/variant-result-noresult-used-as-type.stderr
similarity index 89%
rename from tests/ui/issues/issue-17546.stderr
rename to tests/ui/variants/variant-result-noresult-used-as-type.stderr
index d4aa354491fe..511cb3562f94 100644
--- a/tests/ui/issues/issue-17546.stderr
+++ b/tests/ui/variants/variant-result-noresult-used-as-type.stderr
@@ -1,5 +1,5 @@
 error[E0573]: expected type, found variant `NoResult`
-  --> $DIR/issue-17546.rs:15:17
+  --> $DIR/variant-result-noresult-used-as-type.rs:16:17
    |
 LL |     fn new() -> NoResult<MyEnum, String> {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL +     fn new() -> Result<MyEnum, String> {
    |
 
 error[E0573]: expected type, found variant `Result`
-  --> $DIR/issue-17546.rs:25:17
+  --> $DIR/variant-result-noresult-used-as-type.rs:26:17
    |
 LL |     fn new() -> Result<foo::MyEnum, String> {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a type
@@ -36,7 +36,7 @@ LL +     use std::thread::Result;
    |
 
 error[E0573]: expected type, found variant `Result`
-  --> $DIR/issue-17546.rs:31:13
+  --> $DIR/variant-result-noresult-used-as-type.rs:32:13
    |
 LL | fn new() -> Result<foo::MyEnum, String> {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a type
@@ -53,7 +53,7 @@ LL + use std::thread::Result;
    |
 
 error[E0573]: expected type, found variant `NoResult`
-  --> $DIR/issue-17546.rs:36:15
+  --> $DIR/variant-result-noresult-used-as-type.rs:37:15
    |
 LL | fn newer() -> NoResult<foo::MyEnum, String> {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

From 75bd926afd3a6dc272f4c6c9835fcaff807cc870 Mon Sep 17 00:00:00 2001
From: randomicon00 <20146907+randomicon00@users.noreply.github.com>
Date: Tue, 24 Mar 2026 21:46:19 -0400
Subject: [PATCH 0896/1059] address PR review feedback for unstable-book-gen

---
 compiler/rustc_session/src/options.rs   | 4 ++++
 src/tools/unstable-book-gen/src/main.rs | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 836f7d1cb456..e8681237a03d 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -604,6 +604,10 @@ pub fn is_target_modifier(flag_name: &str) -> bool {
 /// necessary code. The main gotcha of this macro is the `cgsetters` module which is a bunch of
 /// generated code to parse an option into its respective field in the struct. There are a few
 /// hand-written parsers for parsing specific types of values in this module.
+///
+/// Note: this macro's invocation is also parsed by a `syn`-based parser in
+/// `src/tools/unstable-book-gen/src/main.rs` to extract unstable option names and descriptions.
+/// If the format of this macro changes, that parser may need to be updated as well.
 macro_rules! options {
     ($struct_name:ident, $tmod_enum_name:ident, $stat:ident, $optmod:ident, $prefix:expr, $outputname:expr,
      $($( #[$attr:meta] )* $opt:ident : $t:ty = (
diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index 8985072cbd27..21d4da46bef5 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -158,7 +158,7 @@ fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
             return Err(syn::Error::new(
                 name.span(),
                 format!(
-                    "unexpected field count for option `{name}`: expected 4 or 5, found {}",
+                    "unexpected field count for option `{name}`: expected {REQUIRED_FIELDS} or {OPTIONAL_FIELDS}, found {}",
                     tuple_fields.len()
                 ),
             ));

From 8ab0c4cbf39916f4860b2bae376d0d4ca18e2112 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 13:53:53 +1100
Subject: [PATCH 0897/1059] Remove unused `Erasable` impls.

There are many!
---
 compiler/rustc_middle/src/query/erase.rs | 115 +----------------------
 1 file changed, 1 insertion(+), 114 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 036aa2ed05a4..a28e8f23e045 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -108,10 +108,6 @@ impl<T> Erasable for &'_ [T] {
     type Storage = [u8; size_of::<&'static [()]>()];
 }
 
-impl Erasable for &'_ OsStr {
-    type Storage = [u8; size_of::<&'static OsStr>()];
-}
-
 impl<T> Erasable for &'_ ty::List<T> {
     type Storage = [u8; size_of::<&'static ty::List<()>>()];
 }
@@ -120,26 +116,14 @@ impl<T> Erasable for &'_ ty::ListWithCachedTypeInfo<T> {
     type Storage = [u8; size_of::<&'static ty::ListWithCachedTypeInfo<()>>()];
 }
 
-impl<I: rustc_index::Idx, T> Erasable for &'_ rustc_index::IndexSlice<I, T> {
-    type Storage = [u8; size_of::<&'static rustc_index::IndexSlice<u32, ()>>()];
-}
-
 impl<T> Erasable for Result<&'_ T, traits::query::NoSolution> {
     type Storage = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
 }
 
-impl<T> Erasable for Result<&'_ [T], traits::query::NoSolution> {
-    type Storage = [u8; size_of::<Result<&'static [()], traits::query::NoSolution>>()];
-}
-
 impl<T> Erasable for Result<&'_ T, rustc_errors::ErrorGuaranteed> {
     type Storage = [u8; size_of::<Result<&'static (), rustc_errors::ErrorGuaranteed>>()];
 }
 
-impl<T> Erasable for Result<&'_ [T], rustc_errors::ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<&'static [()], rustc_errors::ErrorGuaranteed>>()];
-}
-
 impl<T> Erasable for Result<&'_ T, traits::CodegenObligationError> {
     type Storage = [u8; size_of::<Result<&'static (), traits::CodegenObligationError>>()];
 }
@@ -229,10 +213,6 @@ impl Erasable for Option<&'_ OsStr> {
     type Storage = [u8; size_of::<Option<&'static OsStr>>()];
 }
 
-impl Erasable for Option<mir::DestructuredConstant<'_>> {
-    type Storage = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()];
-}
-
 impl Erasable for ty::ImplTraitHeader<'_> {
     type Storage = [u8; size_of::<ty::ImplTraitHeader<'static>>()];
 }
@@ -262,10 +242,6 @@ impl Erasable for ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>> {
         [u8; size_of::<ty::Binder<'static, ty::CoroutineWitnessTypes<TyCtxt<'static>>>>()];
 }
 
-impl Erasable for ty::Binder<'_, &'_ ty::List<Ty<'_>>> {
-    type Storage = [u8; size_of::<ty::Binder<'static, &'static ty::List<Ty<'static>>>>()];
-}
-
 impl<T0, T1> Erasable for (&'_ T0, &'_ T1) {
     type Storage = [u8; size_of::<(&'static (), &'static ())>()];
 }
@@ -274,14 +250,6 @@ impl<T0> Erasable for (solve::QueryResult<'_>, &'_ T0) {
     type Storage = [u8; size_of::<(solve::QueryResult<'static>, &'static ())>()];
 }
 
-impl<T0, T1> Erasable for (&'_ T0, &'_ [T1]) {
-    type Storage = [u8; size_of::<(&'static (), &'static [()])>()];
-}
-
-impl<T0, T1> Erasable for (&'_ [T0], &'_ [T1]) {
-    type Storage = [u8; size_of::<(&'static [()], &'static [()])>()];
-}
-
 impl<T0> Erasable for (&'_ T0, Result<(), ErrorGuaranteed>) {
     type Storage = [u8; size_of::<(&'static (), Result<(), ErrorGuaranteed>)>()];
 }
@@ -308,109 +276,54 @@ impl Erasable for $ty {
     Option<rustc_hir::DefaultBodyStability>,
     Option<rustc_hir::Stability>,
     Option<rustc_data_structures::svh::Svh>,
-    Option<rustc_hir::def::DefKind>,
     Option<rustc_hir::CoroutineKind>,
-    Option<rustc_hir::HirId>,
     Option<rustc_middle::middle::stability::DeprecationEntry>,
     Option<rustc_middle::ty::AsyncDestructor>,
     Option<rustc_middle::ty::Destructor>,
-    Option<rustc_middle::ty::ImplTraitInTraitData>,
     Option<rustc_middle::ty::ScalarInt>,
     Option<rustc_span::def_id::CrateNum>,
     Option<rustc_span::def_id::DefId>,
     Option<rustc_span::def_id::LocalDefId>,
     Option<rustc_span::Span>,
-    Option<rustc_abi::FieldIdx>,
     Option<rustc_target::spec::PanicStrategy>,
     Option<usize>,
     Option<rustc_middle::ty::IntrinsicDef>,
     Option<rustc_abi::Align>,
     Result<(), rustc_errors::ErrorGuaranteed>,
-    Result<(), rustc_middle::traits::query::NoSolution>,
     Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
     Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>,
     Result<mir::ConstValue, mir::interpret::ErrorHandled>,
-    rustc_abi::ReprOptions,
-    rustc_ast::expand::allocator::AllocatorKind,
-    rustc_hir::DefaultBodyStability,
-    rustc_hir::attrs::Deprecation,
-    rustc_hir::attrs::EiiDecl,
-    rustc_hir::attrs::EiiImpl,
     rustc_data_structures::svh::Svh,
-    rustc_errors::ErrorGuaranteed,
     rustc_hir::Constness,
-    rustc_hir::ConstStability,
     rustc_hir::def_id::DefId,
-    rustc_hir::def_id::DefIndex,
-    rustc_hir::def_id::LocalDefId,
-    rustc_hir::def_id::LocalModDefId,
     rustc_hir::def::DefKind,
     rustc_hir::Defaultness,
-    rustc_hir::definitions::DefKey,
-    rustc_hir::CoroutineKind,
     rustc_hir::HirId,
-    rustc_hir::IsAsync,
-    rustc_hir::ItemLocalId,
-    rustc_hir::LangItem,
     rustc_hir::OpaqueTyOrigin<rustc_hir::def_id::DefId>,
-    rustc_hir::OwnerId,
-    rustc_hir::Stability,
-    rustc_hir::Upvar,
-    rustc_middle::middle::deduced_param_attrs::DeducedParamAttrs,
-    rustc_middle::middle::dependency_format::Linkage,
-    rustc_middle::middle::exported_symbols::SymbolExportInfo,
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
-    rustc_middle::middle::resolve_bound_vars::ResolvedArg,
-    rustc_middle::middle::stability::DeprecationEntry,
     rustc_middle::mir::ConstQualifs,
     rustc_middle::mir::ConstValue,
     rustc_middle::mir::interpret::AllocId,
-    rustc_middle::mir::interpret::CtfeProvenance,
-    rustc_middle::mir::interpret::ErrorHandled,
-    rustc_middle::thir::ExprId,
-    rustc_middle::traits::CodegenObligationError,
-    rustc_middle::traits::EvaluationResult,
-    rustc_middle::traits::OverflowError,
-    rustc_middle::traits::query::NoSolution,
-    rustc_middle::traits::WellFormedLoc,
-    rustc_middle::ty::adjustment::CoerceUnsizedInfo,
     rustc_middle::ty::AssocItem,
-    rustc_middle::ty::AssocContainer,
     rustc_middle::ty::Asyncness,
-    rustc_middle::ty::AsyncDestructor,
     rustc_middle::ty::AnonConstKind,
-    rustc_middle::ty::Destructor,
-    rustc_middle::ty::fast_reject::SimplifiedType,
-    rustc_middle::ty::ImplPolarity,
-    rustc_middle::ty::util::AlwaysRequiresDrop,
     rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
     rustc_middle::middle::codegen_fn_attrs::SanitizerFnAttrs,
-    rustc_session::config::CrateType,
-    rustc_session::config::EntryFnType,
     rustc_session::config::OptLevel,
     rustc_session::config::SymbolManglingVersion,
     rustc_session::cstore::CrateDepKind,
-    rustc_session::cstore::ExternCrate,
-    rustc_session::cstore::LinkagePreference,
     rustc_session::Limits,
-    rustc_session::lint::LintExpectationId,
-    rustc_span::def_id::CrateNum,
-    rustc_span::def_id::DefPathHash,
-    rustc_span::ExpnHash,
     rustc_span::ExpnId,
     rustc_span::Span,
     rustc_span::Symbol,
-    rustc_span::Ident,
     rustc_target::spec::PanicStrategy,
-    rustc_type_ir::Variance,
-    u32,
     usize,
 }
 
 macro_rules! impl_erasable_for_single_lifetime_types {
     ($($($fake_path:ident)::+),+ $(,)?) => {
         $(
-            impl<'tcx> Erasable for $($fake_path)::+<'tcx> {
+            impl Erasable for $($fake_path)::+<'_> {
                 type Storage = [u8; size_of::<$($fake_path)::+<'static>>()];
             }
         )*
@@ -424,43 +337,17 @@ impl<'tcx> Erasable for $($fake_path)::+<'tcx> {
 // lifetime can probably be migrated here.
 impl_erasable_for_single_lifetime_types! {
     // FIXME(#151565): Add `tidy-alphabetical-{start,end}` and sort this.
-    rustc_middle::middle::exported_symbols::ExportedSymbol,
-    rustc_middle::mir::Const,
-    rustc_middle::mir::DestructuredConstant,
-    rustc_middle::mir::ConstAlloc,
-    rustc_middle::mir::interpret::GlobalId,
     rustc_middle::mir::interpret::EvalStaticInitializerRawResult,
     rustc_middle::mir::mono::MonoItemPartitions,
     rustc_middle::traits::query::MethodAutoderefStepsResult,
-    rustc_middle::traits::query::type_op::AscribeUserType,
-    rustc_middle::traits::query::type_op::Eq,
-    rustc_middle::traits::query::type_op::ProvePredicate,
-    rustc_middle::traits::query::type_op::Subtype,
     rustc_middle::ty::AdtDef,
-    rustc_middle::ty::AliasTy,
-    rustc_middle::ty::ClauseKind,
     rustc_middle::ty::ClosureTypeInfo,
     rustc_middle::ty::Const,
-    rustc_middle::ty::DestructuredAdtConst,
-    rustc_middle::ty::ExistentialTraitRef,
-    rustc_middle::ty::FnSig,
-    rustc_middle::ty::GenericArg,
     rustc_middle::ty::GenericPredicates,
     rustc_middle::ty::ConstConditions,
     rustc_middle::ty::inhabitedness::InhabitedPredicate,
-    rustc_middle::ty::Instance,
-    rustc_middle::ty::BoundVariableKind,
-    rustc_middle::ty::InstanceKind,
-    rustc_middle::ty::layout::FnAbiError,
-    rustc_middle::ty::layout::LayoutError,
-    rustc_middle::ty::LitToConstInput,
     rustc_middle::ty::ParamEnv,
     rustc_middle::ty::TypingEnv,
-    rustc_middle::ty::Predicate,
     rustc_middle::ty::SymbolName,
-    rustc_middle::ty::TraitRef,
     rustc_middle::ty::Ty,
-    rustc_middle::ty::UnevaluatedConst,
-    rustc_middle::ty::ValTree,
-    rustc_middle::ty::VtblEntry,
 }

From 833bf3c375b2931826f65a8bad31658aa9b5ac5f Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 14:16:33 +1100
Subject: [PATCH 0898/1059] Sort `impl_erasable_*` macro calls.

---
 compiler/rustc_middle/src/query/erase.rs | 36 +++++++++++++-----------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index a28e8f23e045..66b0f01196d4 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -267,57 +267,58 @@ impl Erasable for $ty {
 // For concrete types with no lifetimes, the erased storage for `Foo` is
 // `[u8; size_of::<Foo>()]`.
 impl_erasable_for_simple_types! {
-    // FIXME(#151565): Add `tidy-alphabetical-{start,end}` and sort this.
+    // tidy-alphabetical-start
     (),
-    bool,
     Option<(rustc_span::def_id::DefId, rustc_session::config::EntryFnType)>,
+    Option<rustc_abi::Align>,
     Option<rustc_ast::expand::allocator::AllocatorKind>,
+    Option<rustc_data_structures::svh::Svh>,
     Option<rustc_hir::ConstStability>,
+    Option<rustc_hir::CoroutineKind>,
     Option<rustc_hir::DefaultBodyStability>,
     Option<rustc_hir::Stability>,
-    Option<rustc_data_structures::svh::Svh>,
-    Option<rustc_hir::CoroutineKind>,
     Option<rustc_middle::middle::stability::DeprecationEntry>,
     Option<rustc_middle::ty::AsyncDestructor>,
     Option<rustc_middle::ty::Destructor>,
+    Option<rustc_middle::ty::IntrinsicDef>,
     Option<rustc_middle::ty::ScalarInt>,
+    Option<rustc_span::Span>,
     Option<rustc_span::def_id::CrateNum>,
     Option<rustc_span::def_id::DefId>,
     Option<rustc_span::def_id::LocalDefId>,
-    Option<rustc_span::Span>,
     Option<rustc_target::spec::PanicStrategy>,
     Option<usize>,
-    Option<rustc_middle::ty::IntrinsicDef>,
-    Option<rustc_abi::Align>,
     Result<(), rustc_errors::ErrorGuaranteed>,
+    Result<mir::ConstValue, mir::interpret::ErrorHandled>,
     Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
     Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>,
-    Result<mir::ConstValue, mir::interpret::ErrorHandled>,
+    bool,
     rustc_data_structures::svh::Svh,
     rustc_hir::Constness,
-    rustc_hir::def_id::DefId,
-    rustc_hir::def::DefKind,
     rustc_hir::Defaultness,
     rustc_hir::HirId,
     rustc_hir::OpaqueTyOrigin<rustc_hir::def_id::DefId>,
+    rustc_hir::def::DefKind,
+    rustc_hir::def_id::DefId,
+    rustc_middle::middle::codegen_fn_attrs::SanitizerFnAttrs,
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
     rustc_middle::mir::ConstQualifs,
     rustc_middle::mir::ConstValue,
     rustc_middle::mir::interpret::AllocId,
+    rustc_middle::ty::AnonConstKind,
     rustc_middle::ty::AssocItem,
     rustc_middle::ty::Asyncness,
-    rustc_middle::ty::AnonConstKind,
     rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
-    rustc_middle::middle::codegen_fn_attrs::SanitizerFnAttrs,
+    rustc_session::Limits,
     rustc_session::config::OptLevel,
     rustc_session::config::SymbolManglingVersion,
     rustc_session::cstore::CrateDepKind,
-    rustc_session::Limits,
     rustc_span::ExpnId,
     rustc_span::Span,
     rustc_span::Symbol,
     rustc_target::spec::PanicStrategy,
     usize,
+    // tidy-alphabetical-end
 }
 
 macro_rules! impl_erasable_for_single_lifetime_types {
@@ -336,18 +337,19 @@ impl Erasable for $($fake_path)::+<'_> {
 // FIXME(#151565): Some of the hand-written impls above that only use one
 // lifetime can probably be migrated here.
 impl_erasable_for_single_lifetime_types! {
-    // FIXME(#151565): Add `tidy-alphabetical-{start,end}` and sort this.
+    // tidy-alphabetical-start
     rustc_middle::mir::interpret::EvalStaticInitializerRawResult,
     rustc_middle::mir::mono::MonoItemPartitions,
     rustc_middle::traits::query::MethodAutoderefStepsResult,
     rustc_middle::ty::AdtDef,
     rustc_middle::ty::ClosureTypeInfo,
     rustc_middle::ty::Const,
-    rustc_middle::ty::GenericPredicates,
     rustc_middle::ty::ConstConditions,
-    rustc_middle::ty::inhabitedness::InhabitedPredicate,
+    rustc_middle::ty::GenericPredicates,
     rustc_middle::ty::ParamEnv,
-    rustc_middle::ty::TypingEnv,
     rustc_middle::ty::SymbolName,
     rustc_middle::ty::Ty,
+    rustc_middle::ty::TypingEnv,
+    rustc_middle::ty::inhabitedness::InhabitedPredicate,
+    // tidy-alphabetical-end
 }

From 289932194af47f75359e3db05b910d9c9b9e9856 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 14:19:37 +1100
Subject: [PATCH 0899/1059] Avoid unnecessary qualification of
 `ErrorGuaranteed`.

It's imported and can be used directly within this file, and already is
in a few places.
---
 compiler/rustc_middle/src/query/erase.rs | 25 ++++++++++--------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 66b0f01196d4..fce9943d105b 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -120,8 +120,8 @@ impl<T> Erasable for Result<&'_ T, traits::query::NoSolution> {
     type Storage = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
 }
 
-impl<T> Erasable for Result<&'_ T, rustc_errors::ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<&'static (), rustc_errors::ErrorGuaranteed>>()];
+impl<T> Erasable for Result<&'_ T, ErrorGuaranteed> {
+    type Storage = [u8; size_of::<Result<&'static (), ErrorGuaranteed>>()];
 }
 
 impl<T> Erasable for Result<&'_ T, traits::CodegenObligationError> {
@@ -132,22 +132,17 @@ impl<T> Erasable for Result<&'_ T, &'_ ty::layout::FnAbiError<'_>> {
     type Storage = [u8; size_of::<Result<&'static (), &'static ty::layout::FnAbiError<'static>>>()];
 }
 
-impl<T> Erasable for Result<(&'_ T, crate::thir::ExprId), rustc_errors::ErrorGuaranteed> {
-    type Storage = [u8; size_of::<
-        Result<(&'static (), crate::thir::ExprId), rustc_errors::ErrorGuaranteed>,
-    >()];
+impl<T> Erasable for Result<(&'_ T, crate::thir::ExprId), ErrorGuaranteed> {
+    type Storage = [u8; size_of::<Result<(&'static (), crate::thir::ExprId), ErrorGuaranteed>>()];
 }
 
-impl Erasable for Result<Option<ty::Instance<'_>>, rustc_errors::ErrorGuaranteed> {
-    type Storage =
-        [u8; size_of::<Result<Option<ty::Instance<'static>>, rustc_errors::ErrorGuaranteed>>()];
+impl Erasable for Result<Option<ty::Instance<'_>>, ErrorGuaranteed> {
+    type Storage = [u8; size_of::<Result<Option<ty::Instance<'static>>, ErrorGuaranteed>>()];
 }
 
-impl Erasable
-    for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, rustc_errors::ErrorGuaranteed>
-{
+impl Erasable for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed> {
     type Storage = [u8; size_of::<
-        Result<Option<ty::EarlyBinder<'static, ty::Const<'static>>>, rustc_errors::ErrorGuaranteed>,
+        Result<Option<ty::EarlyBinder<'static, ty::Const<'static>>>, ErrorGuaranteed>,
     >()];
 }
 
@@ -288,10 +283,10 @@ impl Erasable for $ty {
     Option<rustc_span::def_id::LocalDefId>,
     Option<rustc_target::spec::PanicStrategy>,
     Option<usize>,
-    Result<(), rustc_errors::ErrorGuaranteed>,
+    Result<(), ErrorGuaranteed>,
     Result<mir::ConstValue, mir::interpret::ErrorHandled>,
     Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
-    Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>,
+    Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, ErrorGuaranteed>,
     bool,
     rustc_data_structures::svh::Svh,
     rustc_hir::Constness,

From 2fde4f4210b0e300e70613238769089a2cede7fd Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 14:24:45 +1100
Subject: [PATCH 0900/1059] Adjust some `Erasable` impls.

A few can be done with the `impl_erasable_for_single_lifetime_types!`
macro instead of being hand-written.
---
 compiler/rustc_middle/src/query/erase.rs | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index fce9943d105b..865cdecf6d80 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -12,7 +12,6 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_span::{ErrorGuaranteed, Spanned};
 
-use crate::mir::interpret::EvalToValTreeResult;
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
 use crate::traits::solve;
 use crate::ty::{self, Ty, TyCtxt};
@@ -172,10 +171,6 @@ impl Erasable for Option<(mir::ConstValue, Ty<'_>)> {
     type Storage = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
 }
 
-impl Erasable for EvalToValTreeResult<'_> {
-    type Storage = [u8; size_of::<EvalToValTreeResult<'static>>()];
-}
-
 impl Erasable for Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop> {
     type Storage =
         [u8; size_of::<Result<&'static ty::List<Ty<'static>>, ty::util::AlwaysRequiresDrop>>()];
@@ -208,10 +203,6 @@ impl Erasable for Option<&'_ OsStr> {
     type Storage = [u8; size_of::<Option<&'static OsStr>>()];
 }
 
-impl Erasable for ty::ImplTraitHeader<'_> {
-    type Storage = [u8; size_of::<ty::ImplTraitHeader<'static>>()];
-}
-
 impl Erasable for Option<ty::EarlyBinder<'_, Ty<'_>>> {
     type Storage = [u8; size_of::<Option<ty::EarlyBinder<'static, Ty<'static>>>>()];
 }
@@ -220,10 +211,6 @@ impl Erasable for Option<ty::Value<'_>> {
     type Storage = [u8; size_of::<Option<ty::Value<'static>>>()];
 }
 
-impl Erasable for rustc_hir::MaybeOwner<'_> {
-    type Storage = [u8; size_of::<rustc_hir::MaybeOwner<'static>>()];
-}
-
 impl<T: Erasable> Erasable for ty::EarlyBinder<'_, T> {
     type Storage = T::Storage;
 }
@@ -328,12 +315,11 @@ impl Erasable for $($fake_path)::+<'_> {
 
 // For types containing a single lifetime and no other generics, e.g.
 // `Foo<'tcx>`, the erased storage is `[u8; size_of::<Foo<'static>>()]`.
-//
-// FIXME(#151565): Some of the hand-written impls above that only use one
-// lifetime can probably be migrated here.
 impl_erasable_for_single_lifetime_types! {
     // tidy-alphabetical-start
+    rustc_hir::MaybeOwner,
     rustc_middle::mir::interpret::EvalStaticInitializerRawResult,
+    rustc_middle::mir::interpret::EvalToValTreeResult,
     rustc_middle::mir::mono::MonoItemPartitions,
     rustc_middle::traits::query::MethodAutoderefStepsResult,
     rustc_middle::ty::AdtDef,
@@ -341,6 +327,7 @@ impl Erasable for $($fake_path)::+<'_> {
     rustc_middle::ty::Const,
     rustc_middle::ty::ConstConditions,
     rustc_middle::ty::GenericPredicates,
+    rustc_middle::ty::ImplTraitHeader,
     rustc_middle::ty::ParamEnv,
     rustc_middle::ty::SymbolName,
     rustc_middle::ty::Ty,

From efd36a4897b643882ad037c77fc6ddd84fff4f4b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 14:29:10 +1100
Subject: [PATCH 0901/1059] Avoid 'static in `Erasable` impls.

Using '_ removes unnecessary differences between the impl type and the
associated `Storage` type.
---
 compiler/rustc_middle/src/query/erase.rs | 62 ++++++++++++------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 865cdecf6d80..59853e8cc464 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -100,71 +100,71 @@ pub fn restore_val<T: Erasable>(erased_value: Erased<T>) -> T {
 // FIXME(#151565): Using `T: ?Sized` here should let us remove the separate
 // impls for fat reference types.
 impl<T> Erasable for &'_ T {
-    type Storage = [u8; size_of::<&'static ()>()];
+    type Storage = [u8; size_of::<&'_ ()>()];
 }
 
 impl<T> Erasable for &'_ [T] {
-    type Storage = [u8; size_of::<&'static [()]>()];
+    type Storage = [u8; size_of::<&'_ [()]>()];
 }
 
 impl<T> Erasable for &'_ ty::List<T> {
-    type Storage = [u8; size_of::<&'static ty::List<()>>()];
+    type Storage = [u8; size_of::<&'_ ty::List<()>>()];
 }
 
 impl<T> Erasable for &'_ ty::ListWithCachedTypeInfo<T> {
-    type Storage = [u8; size_of::<&'static ty::ListWithCachedTypeInfo<()>>()];
+    type Storage = [u8; size_of::<&'_ ty::ListWithCachedTypeInfo<()>>()];
 }
 
 impl<T> Erasable for Result<&'_ T, traits::query::NoSolution> {
-    type Storage = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
+    type Storage = [u8; size_of::<Result<&'_ (), traits::query::NoSolution>>()];
 }
 
 impl<T> Erasable for Result<&'_ T, ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<&'static (), ErrorGuaranteed>>()];
+    type Storage = [u8; size_of::<Result<&'_ (), ErrorGuaranteed>>()];
 }
 
 impl<T> Erasable for Result<&'_ T, traits::CodegenObligationError> {
-    type Storage = [u8; size_of::<Result<&'static (), traits::CodegenObligationError>>()];
+    type Storage = [u8; size_of::<Result<&'_ (), traits::CodegenObligationError>>()];
 }
 
 impl<T> Erasable for Result<&'_ T, &'_ ty::layout::FnAbiError<'_>> {
-    type Storage = [u8; size_of::<Result<&'static (), &'static ty::layout::FnAbiError<'static>>>()];
+    type Storage = [u8; size_of::<Result<&'_ (), &'_ ty::layout::FnAbiError<'_>>>()];
 }
 
 impl<T> Erasable for Result<(&'_ T, crate::thir::ExprId), ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<(&'static (), crate::thir::ExprId), ErrorGuaranteed>>()];
+    type Storage = [u8; size_of::<Result<(&'_ (), crate::thir::ExprId), ErrorGuaranteed>>()];
 }
 
 impl Erasable for Result<Option<ty::Instance<'_>>, ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<Option<ty::Instance<'static>>, ErrorGuaranteed>>()];
+    type Storage = [u8; size_of::<Result<Option<ty::Instance<'_>>, ErrorGuaranteed>>()];
 }
 
 impl Erasable for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed> {
     type Storage = [u8; size_of::<
-        Result<Option<ty::EarlyBinder<'static, ty::Const<'static>>>, ErrorGuaranteed>,
+        Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed>,
     >()];
 }
 
 impl Erasable for Result<ty::GenericArg<'_>, traits::query::NoSolution> {
-    type Storage = [u8; size_of::<Result<ty::GenericArg<'static>, traits::query::NoSolution>>()];
+    type Storage = [u8; size_of::<Result<ty::GenericArg<'_>, traits::query::NoSolution>>()];
 }
 
 impl Erasable for Result<bool, &ty::layout::LayoutError<'_>> {
-    type Storage = [u8; size_of::<Result<bool, &'static ty::layout::LayoutError<'static>>>()];
+    type Storage = [u8; size_of::<Result<bool, &'_ ty::layout::LayoutError<'_>>>()];
 }
 
 impl Erasable for Result<rustc_abi::TyAndLayout<'_, Ty<'_>>, &ty::layout::LayoutError<'_>> {
     type Storage = [u8; size_of::<
         Result<
-            rustc_abi::TyAndLayout<'static, Ty<'static>>,
-            &'static ty::layout::LayoutError<'static>,
+            rustc_abi::TyAndLayout<'_, Ty<'_>>,
+            &'_ ty::layout::LayoutError<'_>,
         >,
     >()];
 }
 
 impl Erasable for Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled> {
     type Storage =
-        [u8; size_of::<Result<mir::ConstAlloc<'static>, mir::interpret::ErrorHandled>>()];
+        [u8; size_of::<Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled>>()];
 }
 
 impl Erasable for Option<(mir::ConstValue, Ty<'_>)> {
@@ -173,7 +173,7 @@ impl Erasable for Option<(mir::ConstValue, Ty<'_>)> {
 
 impl Erasable for Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop> {
     type Storage =
-        [u8; size_of::<Result<&'static ty::List<Ty<'static>>, ty::util::AlwaysRequiresDrop>>()];
+        [u8; size_of::<Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop>>()];
 }
 
 impl Erasable
@@ -181,34 +181,34 @@ impl Erasable
 {
     type Storage = [u8; size_of::<
         Result<
-            (&'static [Spanned<MonoItem<'static>>], &'static [Spanned<MonoItem<'static>>]),
+            (&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]),
             NormalizationErrorInMono,
         >,
     >()];
 }
 
 impl Erasable for Result<&'_ TokenStream, ()> {
-    type Storage = [u8; size_of::<Result<&'static TokenStream, ()>>()];
+    type Storage = [u8; size_of::<Result<&'_ TokenStream, ()>>()];
 }
 
 impl<T> Erasable for Option<&'_ T> {
-    type Storage = [u8; size_of::<Option<&'static ()>>()];
+    type Storage = [u8; size_of::<Option<&'_ ()>>()];
 }
 
 impl<T> Erasable for Option<&'_ [T]> {
-    type Storage = [u8; size_of::<Option<&'static [()]>>()];
+    type Storage = [u8; size_of::<Option<&'_ [()]>>()];
 }
 
 impl Erasable for Option<&'_ OsStr> {
-    type Storage = [u8; size_of::<Option<&'static OsStr>>()];
+    type Storage = [u8; size_of::<Option<&'_ OsStr>>()];
 }
 
 impl Erasable for Option<ty::EarlyBinder<'_, Ty<'_>>> {
-    type Storage = [u8; size_of::<Option<ty::EarlyBinder<'static, Ty<'static>>>>()];
+    type Storage = [u8; size_of::<Option<ty::EarlyBinder<'_, Ty<'_>>>>()];
 }
 
 impl Erasable for Option<ty::Value<'_>> {
-    type Storage = [u8; size_of::<Option<ty::Value<'static>>>()];
+    type Storage = [u8; size_of::<Option<ty::Value<'_>>>()];
 }
 
 impl<T: Erasable> Erasable for ty::EarlyBinder<'_, T> {
@@ -216,24 +216,24 @@ impl<T: Erasable> Erasable for ty::EarlyBinder<'_, T> {
 }
 
 impl Erasable for ty::Binder<'_, ty::FnSig<'_>> {
-    type Storage = [u8; size_of::<ty::Binder<'static, ty::FnSig<'static>>>()];
+    type Storage = [u8; size_of::<ty::Binder<'_, ty::FnSig<'_>>>()];
 }
 
 impl Erasable for ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>> {
     type Storage =
-        [u8; size_of::<ty::Binder<'static, ty::CoroutineWitnessTypes<TyCtxt<'static>>>>()];
+        [u8; size_of::<ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>>>()];
 }
 
 impl<T0, T1> Erasable for (&'_ T0, &'_ T1) {
-    type Storage = [u8; size_of::<(&'static (), &'static ())>()];
+    type Storage = [u8; size_of::<(&'_ (), &'_ ())>()];
 }
 
 impl<T0> Erasable for (solve::QueryResult<'_>, &'_ T0) {
-    type Storage = [u8; size_of::<(solve::QueryResult<'static>, &'static ())>()];
+    type Storage = [u8; size_of::<(solve::QueryResult<'_>, &'_ ())>()];
 }
 
 impl<T0> Erasable for (&'_ T0, Result<(), ErrorGuaranteed>) {
-    type Storage = [u8; size_of::<(&'static (), Result<(), ErrorGuaranteed>)>()];
+    type Storage = [u8; size_of::<(&'_ (), Result<(), ErrorGuaranteed>)>()];
 }
 
 macro_rules! impl_erasable_for_simple_types {
@@ -307,14 +307,14 @@ macro_rules! impl_erasable_for_single_lifetime_types {
     ($($($fake_path:ident)::+),+ $(,)?) => {
         $(
             impl Erasable for $($fake_path)::+<'_> {
-                type Storage = [u8; size_of::<$($fake_path)::+<'static>>()];
+                type Storage = [u8; size_of::<$($fake_path)::+<'_>>()];
             }
         )*
     }
 }
 
 // For types containing a single lifetime and no other generics, e.g.
-// `Foo<'tcx>`, the erased storage is `[u8; size_of::<Foo<'static>>()]`.
+// `Foo<'tcx>`, the erased storage is `[u8; size_of::<Foo<'_>>()]`.
 impl_erasable_for_single_lifetime_types! {
     // tidy-alphabetical-start
     rustc_hir::MaybeOwner,

From 1e4c1d6f75937e27c9df81519634cd9f01d8d982 Mon Sep 17 00:00:00 2001
From: Theemathas Chirananthavat <theemathas@gmail.com>
Date: Sat, 22 Nov 2025 22:58:39 +0700
Subject: [PATCH 0902/1059] Make PinCoerceUnsized require Deref

Also, delete impls on non-Deref types.

Pin doesn't do anything useful for non-Deref types, so PinCoerceUnsized
on such types makes no sense.

This is a breaking change, since stable code can observe the deleted
`PinCoerceUnsized` impls by uselessly coercing between such types
inside a `Pin`.

There is still some strange behavior, such as `Pin<&mut i32>` being
able to coerce to `Pin<&dyn Send>`, but not being able to coerce to
`Pin<&i32>`. However, I don't think it's possible to fix this.

Fixes https://github.com/rust-lang/rust/issues/145081
---
 library/alloc/src/rc.rs                       |  3 ---
 library/alloc/src/sync.rs                     |  3 ---
 library/core/src/cell.rs                      | 12 ---------
 library/core/src/pin.rs                       |  8 +-----
 library/core/src/ptr/non_null.rs              |  4 ---
 library/core/src/ptr/unique.rs                |  4 ---
 library/coretests/tests/pin.rs                | 25 -------------------
 .../src/sys/pal/sgx/abi/usercalls/alloc.rs    |  4 ---
 8 files changed, 1 insertion(+), 62 deletions(-)

diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index 8a651618ca83..3f313870e334 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -2424,9 +2424,6 @@ unsafe impl<T: ?Sized, A: Allocator> PinCoerceUnsized for Rc<T, A> {}
 #[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
 unsafe impl<T: ?Sized, A: Allocator> PinCoerceUnsized for UniqueRc<T, A> {}
 
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized, A: Allocator> PinCoerceUnsized for Weak<T, A> {}
-
 #[unstable(feature = "deref_pure_trait", issue = "87121")]
 unsafe impl<T: ?Sized, A: Allocator> DerefPure for Rc<T, A> {}
 
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 2c9fadbb8d9e..8a5f095b3871 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -2426,9 +2426,6 @@ fn deref(&self) -> &T {
 #[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
 unsafe impl<T: ?Sized, A: Allocator> PinCoerceUnsized for Arc<T, A> {}
 
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized, A: Allocator> PinCoerceUnsized for Weak<T, A> {}
-
 #[unstable(feature = "deref_pure_trait", issue = "87121")]
 unsafe impl<T: ?Sized, A: Allocator> DerefPure for Arc<T, A> {}
 
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index f31cadb546c9..d67693f9d0fc 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -2718,18 +2718,6 @@ fn assert_coerce_unsized(
     let _: RefCell<&dyn Send> = d;
 }
 
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for UnsafeCell<T> {}
-
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for SyncUnsafeCell<T> {}
-
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for Cell<T> {}
-
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for RefCell<T> {}
-
 #[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
 unsafe impl<'b, T: ?Sized> PinCoerceUnsized for Ref<'b, T> {}
 
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index eb92e62aaeb3..9102e17d8739 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1842,7 +1842,7 @@ impl<Ptr, U> DispatchFromDyn<Pin<U>> for Pin<Ptr>
 /// to. The concrete type of a slice is an array of the same element type and
 /// the length specified in the metadata. The concrete type of a sized type
 /// is the type itself.
-pub unsafe trait PinCoerceUnsized {}
+pub unsafe trait PinCoerceUnsized: Deref {}
 
 #[stable(feature = "pin", since = "1.33.0")]
 unsafe impl<'a, T: ?Sized> PinCoerceUnsized for &'a T {}
@@ -1853,12 +1853,6 @@ unsafe impl<'a, T: ?Sized> PinCoerceUnsized for &'a mut T {}
 #[stable(feature = "pin", since = "1.33.0")]
 unsafe impl<T: PinCoerceUnsized> PinCoerceUnsized for Pin<T> {}
 
-#[stable(feature = "pin", since = "1.33.0")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for *const T {}
-
-#[stable(feature = "pin", since = "1.33.0")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for *mut T {}
-
 /// Constructs a <code>[Pin]<[&mut] T></code>, by pinning a `value: T` locally.
 ///
 /// Unlike [`Box::pin`], this does not create a new heap allocation. As explained
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 8be7d3a9ae92..38cadad2626c 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -4,7 +4,6 @@
 use crate::mem::{MaybeUninit, SizedTypeProperties, transmute};
 use crate::num::NonZero;
 use crate::ops::{CoerceUnsized, DispatchFromDyn};
-use crate::pin::PinCoerceUnsized;
 use crate::ptr::Unique;
 use crate::slice::{self, SliceIndex};
 use crate::ub_checks::assert_unsafe_precondition;
@@ -1692,9 +1691,6 @@ impl<T: PointeeSized, U: PointeeSized> CoerceUnsized<NonNull<U>> for NonNull<T>
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: PointeeSized, U: PointeeSized> DispatchFromDyn<NonNull<U>> for NonNull<T> where T: Unsize<U> {}
 
-#[stable(feature = "pin", since = "1.33.0")]
-unsafe impl<T: PointeeSized> PinCoerceUnsized for NonNull<T> {}
-
 #[stable(feature = "nonnull", since = "1.25.0")]
 impl<T: PointeeSized> fmt::Debug for NonNull<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/library/core/src/ptr/unique.rs b/library/core/src/ptr/unique.rs
index 3160c9de4b7e..6e55f0e71bec 100644
--- a/library/core/src/ptr/unique.rs
+++ b/library/core/src/ptr/unique.rs
@@ -2,7 +2,6 @@
 use crate::fmt;
 use crate::marker::{PhantomData, PointeeSized, Unsize};
 use crate::ops::{CoerceUnsized, DispatchFromDyn};
-use crate::pin::PinCoerceUnsized;
 use crate::ptr::NonNull;
 
 /// A wrapper around a raw non-null `*mut T` that indicates that the possessor
@@ -176,9 +175,6 @@ impl<T: PointeeSized, U: PointeeSized> CoerceUnsized<Unique<U>> for Unique<T> wh
 #[unstable(feature = "ptr_internals", issue = "none")]
 impl<T: PointeeSized, U: PointeeSized> DispatchFromDyn<Unique<U>> for Unique<T> where T: Unsize<U> {}
 
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: PointeeSized> PinCoerceUnsized for Unique<T> {}
-
 #[unstable(feature = "ptr_internals", issue = "none")]
 impl<T: PointeeSized> fmt::Debug for Unique<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/library/coretests/tests/pin.rs b/library/coretests/tests/pin.rs
index b3fb06e710d4..37a729ae4f1c 100644
--- a/library/coretests/tests/pin.rs
+++ b/library/coretests/tests/pin.rs
@@ -45,22 +45,6 @@ mod pin_coerce_unsized {
     pub trait MyTrait {}
     impl MyTrait for String {}
 
-    // These Pins should continue to compile.
-    // Do note that these instances of Pin types cannot be used
-    // meaningfully because all methods require a Deref/DerefMut
-    // bounds on the pointer type and Cell, RefCell and UnsafeCell
-    // do not implement Deref/DerefMut.
-
-    pub fn cell(arg: Pin<Cell<Box<String>>>) -> Pin<Cell<Box<dyn MyTrait>>> {
-        arg
-    }
-    pub fn ref_cell(arg: Pin<RefCell<Box<String>>>) -> Pin<RefCell<Box<dyn MyTrait>>> {
-        arg
-    }
-    pub fn unsafe_cell(arg: Pin<UnsafeCell<Box<String>>>) -> Pin<UnsafeCell<Box<dyn MyTrait>>> {
-        arg
-    }
-
     // These sensible Pin coercions are possible.
     pub fn pin_mut_ref(arg: Pin<&mut String>) -> Pin<&mut dyn MyTrait> {
         arg
@@ -68,15 +52,6 @@ pub fn pin_mut_ref(arg: Pin<&mut String>) -> Pin<&mut dyn MyTrait> {
     pub fn pin_ref(arg: Pin<&String>) -> Pin<&dyn MyTrait> {
         arg
     }
-    pub fn pin_ptr(arg: Pin<*const String>) -> Pin<*const dyn MyTrait> {
-        arg
-    }
-    pub fn pin_ptr_mut(arg: Pin<*mut String>) -> Pin<*mut dyn MyTrait> {
-        arg
-    }
-    pub fn pin_non_null(arg: Pin<NonNull<String>>) -> Pin<NonNull<dyn MyTrait>> {
-        arg
-    }
     pub fn nesting_pins(arg: Pin<Pin<&String>>) -> Pin<Pin<&dyn MyTrait>> {
         arg
     }
diff --git a/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs b/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs
index aaf380d1bef4..c2694316249a 100644
--- a/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs
+++ b/library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs
@@ -8,7 +8,6 @@
 use crate::convert::TryInto;
 use crate::mem::{self, ManuallyDrop, MaybeUninit};
 use crate::ops::{CoerceUnsized, Deref, DerefMut, Index, IndexMut};
-use crate::pin::PinCoerceUnsized;
 use crate::ptr::{self, NonNull};
 use crate::slice::SliceIndex;
 use crate::{cmp, intrinsics, slice};
@@ -773,9 +772,6 @@ fn drop(&mut self) {
 #[unstable(feature = "sgx_platform", issue = "56975")]
 impl<T: CoerceUnsized<U>, U> CoerceUnsized<UserRef<U>> for UserRef<T> {}
 
-#[unstable(feature = "pin_coerce_unsized_trait", issue = "150112")]
-unsafe impl<T: ?Sized> PinCoerceUnsized for UserRef<T> {}
-
 #[unstable(feature = "sgx_platform", issue = "56975")]
 impl<T, I> Index<I> for UserRef<[T]>
 where

From f55c8cca4c3da4ebdeabbe157b693c526ce2f433 Mon Sep 17 00:00:00 2001
From: Theemathas Chirananthavat <theemathas@gmail.com>
Date: Wed, 3 Dec 2025 21:40:43 +0700
Subject: [PATCH 0903/1059] Rewrite safety comment for PinCoerceUnsized

---
 library/core/src/pin.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 9102e17d8739..ffdcd9fad49a 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1829,9 +1829,10 @@ impl<Ptr, U> DispatchFromDyn<Pin<U>> for Pin<Ptr>
 ///
 /// # Safety
 ///
-/// If this type implements `Deref`, then the concrete type returned by `deref`
-/// and `deref_mut` must not change without a modification. The following
-/// operations are not considered modifications:
+/// Given a pointer of this type, the concrete type returned by its
+/// `deref` method and (if it implements `DerefMut`) its `deref_mut` method
+/// must be the same type and must not change without a modification.
+/// The following operations are not considered modifications:
 ///
 /// * Moving the pointer.
 /// * Performing unsizing coercions on the pointer.

From dce180559976fc3ce4d90a67541dcc724109e9ba Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 14:40:46 +1100
Subject: [PATCH 0904/1059] Use `impl_erasable_for_simple_types!` more, and
 rename it.

Now that 'static lifetimes aren't used, a lot of the hand-written
`Erasable` impls can now be done with the macro. (The only ones that
can't are those with a generic type parameter, because `size_of`
doesn't work in that case.)

Also, `impl_erasable_for_single_lifetime_types!` isn't needed at all.
---
 compiler/rustc_middle/src/query/erase.rs | 149 ++++++-----------------
 1 file changed, 35 insertions(+), 114 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 59853e8cc464..54fe858e4809 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -135,62 +135,6 @@ impl<T> Erasable for Result<(&'_ T, crate::thir::ExprId), ErrorGuaranteed> {
     type Storage = [u8; size_of::<Result<(&'_ (), crate::thir::ExprId), ErrorGuaranteed>>()];
 }
 
-impl Erasable for Result<Option<ty::Instance<'_>>, ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<Option<ty::Instance<'_>>, ErrorGuaranteed>>()];
-}
-
-impl Erasable for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed> {
-    type Storage = [u8; size_of::<
-        Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed>,
-    >()];
-}
-
-impl Erasable for Result<ty::GenericArg<'_>, traits::query::NoSolution> {
-    type Storage = [u8; size_of::<Result<ty::GenericArg<'_>, traits::query::NoSolution>>()];
-}
-
-impl Erasable for Result<bool, &ty::layout::LayoutError<'_>> {
-    type Storage = [u8; size_of::<Result<bool, &'_ ty::layout::LayoutError<'_>>>()];
-}
-
-impl Erasable for Result<rustc_abi::TyAndLayout<'_, Ty<'_>>, &ty::layout::LayoutError<'_>> {
-    type Storage = [u8; size_of::<
-        Result<
-            rustc_abi::TyAndLayout<'_, Ty<'_>>,
-            &'_ ty::layout::LayoutError<'_>,
-        >,
-    >()];
-}
-
-impl Erasable for Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled> {
-    type Storage =
-        [u8; size_of::<Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled>>()];
-}
-
-impl Erasable for Option<(mir::ConstValue, Ty<'_>)> {
-    type Storage = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
-}
-
-impl Erasable for Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop> {
-    type Storage =
-        [u8; size_of::<Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop>>()];
-}
-
-impl Erasable
-    for Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>
-{
-    type Storage = [u8; size_of::<
-        Result<
-            (&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]),
-            NormalizationErrorInMono,
-        >,
-    >()];
-}
-
-impl Erasable for Result<&'_ TokenStream, ()> {
-    type Storage = [u8; size_of::<Result<&'_ TokenStream, ()>>()];
-}
-
 impl<T> Erasable for Option<&'_ T> {
     type Storage = [u8; size_of::<Option<&'_ ()>>()];
 }
@@ -199,31 +143,10 @@ impl<T> Erasable for Option<&'_ [T]> {
     type Storage = [u8; size_of::<Option<&'_ [()]>>()];
 }
 
-impl Erasable for Option<&'_ OsStr> {
-    type Storage = [u8; size_of::<Option<&'_ OsStr>>()];
-}
-
-impl Erasable for Option<ty::EarlyBinder<'_, Ty<'_>>> {
-    type Storage = [u8; size_of::<Option<ty::EarlyBinder<'_, Ty<'_>>>>()];
-}
-
-impl Erasable for Option<ty::Value<'_>> {
-    type Storage = [u8; size_of::<Option<ty::Value<'_>>>()];
-}
-
 impl<T: Erasable> Erasable for ty::EarlyBinder<'_, T> {
     type Storage = T::Storage;
 }
 
-impl Erasable for ty::Binder<'_, ty::FnSig<'_>> {
-    type Storage = [u8; size_of::<ty::Binder<'_, ty::FnSig<'_>>>()];
-}
-
-impl Erasable for ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>> {
-    type Storage =
-        [u8; size_of::<ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>>>()];
-}
-
 impl<T0, T1> Erasable for (&'_ T0, &'_ T1) {
     type Storage = [u8; size_of::<(&'_ (), &'_ ())>()];
 }
@@ -236,7 +159,7 @@ impl<T0> Erasable for (&'_ T0, Result<(), ErrorGuaranteed>) {
     type Storage = [u8; size_of::<(&'_ (), Result<(), ErrorGuaranteed>)>()];
 }
 
-macro_rules! impl_erasable_for_simple_types {
+macro_rules! impl_erasable_for_types_with_no_type_params {
     ($($ty:ty),+ $(,)?) => {
         $(
             impl Erasable for $ty {
@@ -246,11 +169,13 @@ impl Erasable for $ty {
     }
 }
 
-// For concrete types with no lifetimes, the erased storage for `Foo` is
-// `[u8; size_of::<Foo>()]`.
-impl_erasable_for_simple_types! {
+// For types with no type parameters the erased storage for `Foo` is
+// `[u8; size_of::<Foo>()]`. ('_ lifetimes are allowed.)
+impl_erasable_for_types_with_no_type_params! {
     // tidy-alphabetical-start
     (),
+    Option<&'_ OsStr>,
+    Option<(mir::ConstValue, Ty<'_>)>,
     Option<(rustc_span::def_id::DefId, rustc_session::config::EntryFnType)>,
     Option<rustc_abi::Align>,
     Option<rustc_ast::expand::allocator::AllocatorKind>,
@@ -269,16 +194,29 @@ impl Erasable for $ty {
     Option<rustc_span::def_id::DefId>,
     Option<rustc_span::def_id::LocalDefId>,
     Option<rustc_target::spec::PanicStrategy>,
+    Option<ty::EarlyBinder<'_, Ty<'_>>>,
+    Option<ty::Value<'_>>,
     Option<usize>,
+    Result<&'_ TokenStream, ()>,
+    Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop>,
+    Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>,
     Result<(), ErrorGuaranteed>,
+    Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed>,
+    Result<Option<ty::Instance<'_>>, ErrorGuaranteed>,
+    Result<bool, &ty::layout::LayoutError<'_>>,
+    Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled>,
     Result<mir::ConstValue, mir::interpret::ErrorHandled>,
+    Result<rustc_abi::TyAndLayout<'_, Ty<'_>>, &ty::layout::LayoutError<'_>>,
     Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
     Result<rustc_middle::ty::adjustment::CoerceUnsizedInfo, ErrorGuaranteed>,
+    Result<ty::GenericArg<'_>, traits::query::NoSolution>,
+    Ty<'_>,
     bool,
     rustc_data_structures::svh::Svh,
     rustc_hir::Constness,
     rustc_hir::Defaultness,
     rustc_hir::HirId,
+    rustc_hir::MaybeOwner<'_>,
     rustc_hir::OpaqueTyOrigin<rustc_hir::def_id::DefId>,
     rustc_hir::def::DefKind,
     rustc_hir::def_id::DefId,
@@ -287,10 +225,26 @@ impl Erasable for $ty {
     rustc_middle::mir::ConstQualifs,
     rustc_middle::mir::ConstValue,
     rustc_middle::mir::interpret::AllocId,
+    rustc_middle::mir::interpret::EvalStaticInitializerRawResult<'_>,
+    rustc_middle::mir::interpret::EvalToValTreeResult<'_>,
+    rustc_middle::mir::mono::MonoItemPartitions<'_>,
+    rustc_middle::traits::query::MethodAutoderefStepsResult<'_>,
+    rustc_middle::ty::AdtDef<'_>,
     rustc_middle::ty::AnonConstKind,
     rustc_middle::ty::AssocItem,
     rustc_middle::ty::Asyncness,
+    rustc_middle::ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>>,
+    rustc_middle::ty::Binder<'_, ty::FnSig<'_>>,
+    rustc_middle::ty::ClosureTypeInfo<'_>,
+    rustc_middle::ty::Const<'_>,
+    rustc_middle::ty::ConstConditions<'_>,
+    rustc_middle::ty::GenericPredicates<'_>,
+    rustc_middle::ty::ImplTraitHeader<'_>,
+    rustc_middle::ty::ParamEnv<'_>,
+    rustc_middle::ty::SymbolName<'_>,
+    rustc_middle::ty::TypingEnv<'_>,
     rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
+    rustc_middle::ty::inhabitedness::InhabitedPredicate<'_>,
     rustc_session::Limits,
     rustc_session::config::OptLevel,
     rustc_session::config::SymbolManglingVersion,
@@ -302,36 +256,3 @@ impl Erasable for $ty {
     usize,
     // tidy-alphabetical-end
 }
-
-macro_rules! impl_erasable_for_single_lifetime_types {
-    ($($($fake_path:ident)::+),+ $(,)?) => {
-        $(
-            impl Erasable for $($fake_path)::+<'_> {
-                type Storage = [u8; size_of::<$($fake_path)::+<'_>>()];
-            }
-        )*
-    }
-}
-
-// For types containing a single lifetime and no other generics, e.g.
-// `Foo<'tcx>`, the erased storage is `[u8; size_of::<Foo<'_>>()]`.
-impl_erasable_for_single_lifetime_types! {
-    // tidy-alphabetical-start
-    rustc_hir::MaybeOwner,
-    rustc_middle::mir::interpret::EvalStaticInitializerRawResult,
-    rustc_middle::mir::interpret::EvalToValTreeResult,
-    rustc_middle::mir::mono::MonoItemPartitions,
-    rustc_middle::traits::query::MethodAutoderefStepsResult,
-    rustc_middle::ty::AdtDef,
-    rustc_middle::ty::ClosureTypeInfo,
-    rustc_middle::ty::Const,
-    rustc_middle::ty::ConstConditions,
-    rustc_middle::ty::GenericPredicates,
-    rustc_middle::ty::ImplTraitHeader,
-    rustc_middle::ty::ParamEnv,
-    rustc_middle::ty::SymbolName,
-    rustc_middle::ty::Ty,
-    rustc_middle::ty::TypingEnv,
-    rustc_middle::ty::inhabitedness::InhabitedPredicate,
-    // tidy-alphabetical-end
-}

From 4f03262c8ac4b977cc3dd716bf2a6ffaf8864c49 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 15:30:34 +1100
Subject: [PATCH 0905/1059] Use `impl_erasable_for_types_with_no_type_params!`
 even more.

Some of the hand-written `Erasable` impls only match a single type in
practice. It's easier to just list the concrete types in
`impl_erasable_for_types_with_no_type_params!`.
---
 compiler/rustc_middle/src/query/erase.rs | 34 ++++++------------------
 1 file changed, 8 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 54fe858e4809..53ec0584ae59 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -10,12 +10,12 @@
 use std::mem::MaybeUninit;
 
 use rustc_ast::tokenstream::TokenStream;
+use rustc_data_structures::steal::Steal;
 use rustc_span::{ErrorGuaranteed, Spanned};
 
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
-use crate::traits::solve;
 use crate::ty::{self, Ty, TyCtxt};
-use crate::{mir, traits};
+use crate::{mir, thir, traits};
 
 /// Internal implementation detail of [`Erased`].
 #[derive(Copy, Clone)]
@@ -123,26 +123,10 @@ impl<T> Erasable for Result<&'_ T, ErrorGuaranteed> {
     type Storage = [u8; size_of::<Result<&'_ (), ErrorGuaranteed>>()];
 }
 
-impl<T> Erasable for Result<&'_ T, traits::CodegenObligationError> {
-    type Storage = [u8; size_of::<Result<&'_ (), traits::CodegenObligationError>>()];
-}
-
-impl<T> Erasable for Result<&'_ T, &'_ ty::layout::FnAbiError<'_>> {
-    type Storage = [u8; size_of::<Result<&'_ (), &'_ ty::layout::FnAbiError<'_>>>()];
-}
-
-impl<T> Erasable for Result<(&'_ T, crate::thir::ExprId), ErrorGuaranteed> {
-    type Storage = [u8; size_of::<Result<(&'_ (), crate::thir::ExprId), ErrorGuaranteed>>()];
-}
-
 impl<T> Erasable for Option<&'_ T> {
     type Storage = [u8; size_of::<Option<&'_ ()>>()];
 }
 
-impl<T> Erasable for Option<&'_ [T]> {
-    type Storage = [u8; size_of::<Option<&'_ [()]>>()];
-}
-
 impl<T: Erasable> Erasable for ty::EarlyBinder<'_, T> {
     type Storage = T::Storage;
 }
@@ -151,14 +135,6 @@ impl<T0, T1> Erasable for (&'_ T0, &'_ T1) {
     type Storage = [u8; size_of::<(&'_ (), &'_ ())>()];
 }
 
-impl<T0> Erasable for (solve::QueryResult<'_>, &'_ T0) {
-    type Storage = [u8; size_of::<(solve::QueryResult<'_>, &'_ ())>()];
-}
-
-impl<T0> Erasable for (&'_ T0, Result<(), ErrorGuaranteed>) {
-    type Storage = [u8; size_of::<(&'_ (), Result<(), ErrorGuaranteed>)>()];
-}
-
 macro_rules! impl_erasable_for_types_with_no_type_params {
     ($($ty:ty),+ $(,)?) => {
         $(
@@ -173,8 +149,11 @@ impl Erasable for $ty {
 // `[u8; size_of::<Foo>()]`. ('_ lifetimes are allowed.)
 impl_erasable_for_types_with_no_type_params! {
     // tidy-alphabetical-start
+    (&'_ ty::CrateInherentImpls, Result<(), ErrorGuaranteed>),
     (),
+    (traits::solve::QueryResult<'_>, &'_ traits::solve::inspect::Probe<TyCtxt<'_>>),
     Option<&'_ OsStr>,
+    Option<&'_ [rustc_hir::PreciseCapturingArgKind<rustc_span::Symbol, rustc_span::Symbol>]>,
     Option<(mir::ConstValue, Ty<'_>)>,
     Option<(rustc_span::def_id::DefId, rustc_session::config::EntryFnType)>,
     Option<rustc_abi::Align>,
@@ -198,7 +177,10 @@ impl Erasable for $ty {
     Option<ty::Value<'_>>,
     Option<usize>,
     Result<&'_ TokenStream, ()>,
+    Result<&'_ rustc_target::callconv::FnAbi<'_, Ty<'_>>, &'_ ty::layout::FnAbiError<'_>>,
+    Result<&'_ traits::ImplSource<'_, ()>, traits::CodegenObligationError>,
     Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop>,
+    Result<(&'_ Steal<thir::Thir<'_>>, thir::ExprId), ErrorGuaranteed>,
     Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>,
     Result<(), ErrorGuaranteed>,
     Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, ErrorGuaranteed>,

From a2856a7f700c0880e963062f04d48ef04160f948 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 25 Mar 2026 05:20:05 +0000
Subject: [PATCH 0906/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 8a703520e80d87d4423c01f9d4fbc9e5f6533a02.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 78136929d445..effc9080877a 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-212b0d480f337082bbe1132d2b62be20e7e61f8a
+8a703520e80d87d4423c01f9d4fbc9e5f6533a02

From c466d3d6516d053196eeccc269f9ee350e2c6568 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 11:02:37 +0530
Subject: [PATCH 0907/1059] add record_expr_field_list constructor method

---
 .../src/ast/syntax_factory/constructors.rs       | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 3e5591d37af2..e99060b683e9 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1470,6 +1470,22 @@ pub fn record_expr(
         ast
     }
 
+    pub fn record_expr_field_list(
+        &self,
+        fields: impl IntoIterator<Item = ast::RecordExprField>,
+    ) -> ast::RecordExprFieldList {
+        let (fields, input) = iterator_input(fields);
+        let ast = make::record_expr_field_list(fields).clone_for_update();
+
+        if let Some(mut mapping) = self.mappings() {
+            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(input, ast.fields().map(|f| f.syntax().clone()));
+            builder.finish(&mut mapping);
+        }
+
+        ast
+    }
+
     pub fn record_expr_field(
         &self,
         name: ast::NameRef,

From ffe74d68abe7d779b934cfef2cd517ceb389bca4 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 24 Mar 2026 17:53:31 +0800
Subject: [PATCH 0908/1059] fix: wrap `Result<>` for desugar_try_expr_let_else

Example
---
```rust
fn test() {
    let pat: bool = Ok(true)$0?;
}
```

**Before this PR**

```rust
fn test() {
    let Ok(pat): Option<bool> = Ok(true) else {
        return Err(todo!());
    };
}
```

**After this PR**

```rust
fn test() {
    let Ok(pat): Result<bool, _> = Ok(true) else {
        return Err(todo!());
    };
}
```
---
 .../src/handlers/desugar_try_expr.rs          | 26 ++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
index e43cf0bc8aae..865dc862215f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/desugar_try_expr.rs
@@ -116,7 +116,10 @@ pub(crate) fn desugar_try_expr(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                 let fill_expr = || crate::utils::expr_fill_default(ctx.config);
                 let new_let_stmt = make.let_else_stmt(
                     try_enum.happy_pattern(pat),
-                    let_stmt.ty().map(|ty| make.ty_option(ty).into()),
+                    let_stmt.ty().map(|ty| match try_enum {
+                        TryEnum::Option => make.ty_option(ty).into(),
+                        TryEnum::Result => make.ty_result(ty, make.ty_infer().into()).into(),
+                    }),
                     expr,
                     make.block_expr(
                         iter::once(
@@ -264,6 +267,27 @@ fn test() {
     let Some(pat): Option<bool> = Some(true) else {
         return None;
     };
+}
+            "#,
+            "Replace try expression with let else",
+        );
+    }
+
+    #[test]
+    fn test_desugar_try_expr_result_let_else_with_type() {
+        check_assist_by_label(
+            desugar_try_expr,
+            r#"
+//- minicore: try, result
+fn test() {
+    let pat: bool = Ok(true)$0?;
+}
+            "#,
+            r#"
+fn test() {
+    let Ok(pat): Result<bool, _> = Ok(true) else {
+        return Err(todo!());
+    };
 }
             "#,
             "Replace try expression with let else",

From 7553d6c7792e44b91101dd55203098331cb92f50 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 11:34:55 +0530
Subject: [PATCH 0909/1059] fix record_expr_field

---
 .../syntax/src/ast/syntax_factory/constructors.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index e99060b683e9..fa81dfad1f7f 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -1496,7 +1496,20 @@ pub fn record_expr_field(
         if let Some(mut mapping) = self.mappings() {
             let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
 
-            builder.map_node(name.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
+            if let Some(ast_name_ref) = ast.name_ref() {
+                // NameRef is a direct child
+                builder.map_node(name.syntax().clone(), ast_name_ref.syntax().clone());
+            } else {
+                // NameRef is nested inside PathExpr > Path > PathSegment.
+                // map_node requires the output to be a direct child of the builder's parent, so
+                // we need a separate builder scoped to PathSegment.
+                let ast::Expr::PathExpr(path_expr) = ast.expr().unwrap() else { unreachable!() };
+                let path_segment = path_expr.path().unwrap().segment().unwrap();
+                let inner_name_ref = path_segment.name_ref().unwrap();
+                let mut inner_builder = SyntaxMappingBuilder::new(path_segment.syntax().clone());
+                inner_builder.map_node(name.syntax().clone(), inner_name_ref.syntax().clone());
+                inner_builder.finish(&mut mapping);
+            }
             if let Some(expr) = expr {
                 builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
             }

From 735c3e457e54f3c152c46047af2d9aff676ec4f8 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Wed, 25 Mar 2026 09:27:46 +0300
Subject: [PATCH 0910/1059] Add const type ICE test

---
 tests/ui/delegation/generics/const-type-ice-154334.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 tests/ui/delegation/generics/const-type-ice-154334.rs

diff --git a/tests/ui/delegation/generics/const-type-ice-154334.rs b/tests/ui/delegation/generics/const-type-ice-154334.rs
new file mode 100644
index 000000000000..91cf1d3a0a63
--- /dev/null
+++ b/tests/ui/delegation/generics/const-type-ice-154334.rs
@@ -0,0 +1,11 @@
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+
+#![feature(min_generic_const_args)]
+#![feature(fn_delegation)]
+#![feature(adt_const_params)]
+#![feature(unsized_const_params)]
+trait Trait<'a, T, const N: str> {
+    fn foo<'v, A, B>(&self) {}
+}
+reuse Trait::foo;

From bd398d3e110022e2d915511f718eb85606e4a6ef Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 11:35:22 +0530
Subject: [PATCH 0911/1059] migrate generate new to use SyntaxFactory

---
 .../ide-assists/src/handlers/generate_new.rs  | 84 ++++++++++---------
 .../crates/ide-assists/src/utils.rs           |  3 +-
 2 files changed, 46 insertions(+), 41 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
index 793211a27b47..301d13c09584 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
@@ -3,7 +3,10 @@
     use_trivial_constructor::use_trivial_constructor,
 };
 use syntax::{
-    ast::{self, AstNode, HasName, HasVisibility, StructKind, edit::AstNodeEdit, make},
+    ast::{
+        self, AstNode, HasName, HasVisibility, StructKind, edit::AstNodeEdit,
+        syntax_factory::SyntaxFactory,
+    },
     syntax_editor::Position,
 };
 
@@ -36,6 +39,7 @@
 pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
 
+    let make = SyntaxFactory::without_mappings();
     let field_list = match strukt.kind() {
         StructKind::Record(named) => {
             named.fields().filter_map(|f| Some((f.name()?, f.ty()?))).collect::<Vec<_>>()
@@ -55,7 +59,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                         Some(name) => name,
                         None => name_generator.suggest_name(&format!("_{i}")),
                     };
-                    Some((make::name(name.as_str()), f.ty()?))
+                    Some((make.name(name.as_str()), f.ty()?))
                 })
                 .collect::<Vec<_>>()
         }
@@ -70,6 +74,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
 
     let target = strukt.syntax().text_range();
     acc.add(AssistId::generate("generate_new"), "Generate `new`", target, |builder| {
+        let make = SyntaxFactory::with_mappings();
         let trivial_constructors = field_list
             .iter()
             .map(|(name, ty)| {
@@ -95,63 +100,63 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                     edition,
                 )?;
 
-                Some((make::name_ref(&name.text()), Some(expr)))
+                Some((make.name_ref(&name.text()), Some(expr)))
             })
             .collect::<Vec<_>>();
 
         let params = field_list.iter().enumerate().filter_map(|(i, (name, ty))| {
             if trivial_constructors[i].is_none() {
-                Some(make::param(make::ident_pat(false, false, name.clone()).into(), ty.clone()))
+                Some(make.param(make.ident_pat(false, false, name.clone()).into(), ty.clone()))
             } else {
                 None
             }
         });
-        let params = make::param_list(None, params);
+        let params = make.param_list(None, params);
 
         let fields = field_list.iter().enumerate().map(|(i, (name, _))| {
             if let Some(constructor) = trivial_constructors[i].clone() {
                 constructor
             } else {
-                (make::name_ref(&name.text()), None)
+                (make.name_ref(&name.text()), None)
             }
         });
 
         let tail_expr: ast::Expr = match strukt.kind() {
             StructKind::Record(_) => {
-                let fields = fields.map(|(name, expr)| make::record_expr_field(name, expr));
-                let fields = make::record_expr_field_list(fields);
-                make::record_expr(make::ext::ident_path("Self"), fields).into()
+                let fields = fields.map(|(name, expr)| make.record_expr_field(name, expr));
+                let fields = make.record_expr_field_list(fields);
+                make.record_expr(make.ident_path("Self"), fields).into()
             }
             StructKind::Tuple(_) => {
                 let args = fields.map(|(arg, expr)| {
-                    let arg = || make::expr_path(make::path_unqualified(make::path_segment(arg)));
+                    let arg = || make.expr_path(make.path_unqualified(make.path_segment(arg)));
                     expr.unwrap_or_else(arg)
                 });
-                let arg_list = make::arg_list(args);
-                make::expr_call(make::expr_path(make::ext::ident_path("Self")), arg_list).into()
+                let arg_list = make.arg_list(args);
+                make.expr_call(make.expr_path(make.ident_path("Self")), arg_list).into()
             }
             StructKind::Unit => unreachable!(),
         };
-        let body = make::block_expr(None, tail_expr.into());
+        let body = make.block_expr(None, tail_expr.into());
 
-        let ret_type = make::ret_type(make::ty_path(make::ext::ident_path("Self")));
+        let ret_type = make.ret_type(make.ty_path(make.ident_path("Self")).into());
 
-        let fn_ = make::fn_(
-            None,
-            strukt.visibility(),
-            make::name("new"),
-            None,
-            None,
-            params,
-            body,
-            Some(ret_type),
-            false,
-            false,
-            false,
-            false,
-        )
-        .clone_for_update()
-        .indent(1.into());
+        let fn_ = make
+            .fn_(
+                [],
+                strukt.visibility(),
+                make.name("new"),
+                None,
+                None,
+                params,
+                body,
+                Some(ret_type),
+                false,
+                false,
+                false,
+                false,
+            )
+            .indent(1.into());
 
         let mut editor = builder.make_editor(strukt.syntax());
 
@@ -164,32 +169,30 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                 editor.insert_all(
                     Position::after(l_curly),
                     vec![
-                        make::tokens::whitespace(&format!("\n{}", impl_def.indent_level() + 1))
-                            .into(),
+                        make.whitespace(&format!("\n{}", impl_def.indent_level() + 1)).into(),
                         fn_.syntax().clone().into(),
-                        make::tokens::whitespace("\n").into(),
+                        make.whitespace("\n").into(),
                     ],
                 );
                 fn_.syntax().clone()
             } else {
-                let items = vec![ast::AssocItem::Fn(fn_)];
-                let list = make::assoc_item_list(Some(items));
+                let list = make.assoc_item_list([ast::AssocItem::Fn(fn_)]);
                 editor.insert(Position::after(impl_def.syntax()), list.syntax());
                 list.syntax().clone()
             }
         } else {
             // Generate a new impl to add the method to
             let indent_level = strukt.indent_level();
-            let body = vec![ast::AssocItem::Fn(fn_)];
-            let list = make::assoc_item_list(Some(body));
-            let impl_def = generate_impl_with_item(&ast::Adt::Struct(strukt.clone()), Some(list))
-                .indent(strukt.indent_level());
+            let list = make.assoc_item_list([ast::AssocItem::Fn(fn_)]);
+            let impl_def =
+                generate_impl_with_item(&make, &ast::Adt::Struct(strukt.clone()), Some(list))
+                    .indent(strukt.indent_level());
 
             // Insert it after the adt
             editor.insert_all(
                 Position::after(strukt.syntax()),
                 vec![
-                    make::tokens::whitespace(&format!("\n\n{indent_level}")).into(),
+                    make.whitespace(&format!("\n\n{indent_level}")).into(),
                     impl_def.syntax().clone().into(),
                 ],
             );
@@ -233,6 +236,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
             }
         }
 
+        editor.add_mappings(make.finish_with_mappings());
         builder.add_file_edits(ctx.vfs_file_id(), editor);
     })
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index a85a89efb4a2..4c454fe224c3 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -733,10 +733,11 @@ fn generate_impl_text_inner(
 /// Generates the corresponding `impl Type {}` including type and lifetime
 /// parameters.
 pub(crate) fn generate_impl_with_item(
+    make: &SyntaxFactory,
     adt: &ast::Adt,
     body: Option<ast::AssocItemList>,
 ) -> ast::Impl {
-    generate_impl_inner(false, adt, None, true, body)
+    generate_impl_inner_with_factory(make, false, adt, None, true, body)
 }
 
 pub(crate) fn generate_impl(adt: &ast::Adt) -> ast::Impl {

From 86aac98cfcc709b989d1355e48d6210dac5b2b08 Mon Sep 17 00:00:00 2001
From: Havard Eidnes <he@NetBSD.org>
Date: Wed, 25 Mar 2026 07:30:12 +0000
Subject: [PATCH 0912/1059] install-template.sh: Optimize by using Bourne shell
 builtins.

This replaces forking separate processes and using "cut" with Bourne
shell builtin operations for "remove largest suffix pattern" and
"remove smallest prefix pattern" operations.
---
 src/tools/rust-installer/install-template.sh | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-installer/install-template.sh b/src/tools/rust-installer/install-template.sh
index c4f0c618a52d..7079e29eefff 100644
--- a/src/tools/rust-installer/install-template.sh
+++ b/src/tools/rust-installer/install-template.sh
@@ -433,8 +433,8 @@ uninstall_components() {
             local _directive
             while read _directive; do
 
-            local _command=`echo $_directive | cut -f1 -d:`
-            local _file=`echo $_directive | cut -f2 -d:`
+            local _command="${_directive%%:*}"
+            local _file="${_directive#*:}"
 
             # Sanity checks
             if [ ! -n "$_command" ]; then critical_err "malformed installation directive"; fi
@@ -541,8 +541,8 @@ install_components() {
     local _directive
     while read _directive; do
 
-        local _command=`echo $_directive | cut -f1 -d:`
-        local _file=`echo $_directive | cut -f2 -d:`
+        local _command="${_directive%%:*}"
+        local _file="${_directive#*:}"
 
         # Sanity checks
         if [ ! -n "$_command" ]; then critical_err "malformed installation directive"; fi

From 3271d4cadfd3e8e69be8e9ee6a561187959791f3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Mar 2026 08:33:35 +0100
Subject: [PATCH 0913/1059] uefi: extend comment for TcpStream Send impl

---
 library/std/src/sys/net/connection/uefi/tcp.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/net/connection/uefi/tcp.rs b/library/std/src/sys/net/connection/uefi/tcp.rs
index 1e58db0d7046..9522ba69ed31 100644
--- a/library/std/src/sys/net/connection/uefi/tcp.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp.rs
@@ -9,7 +9,9 @@ pub(crate) enum Tcp {
     V4(tcp4::Tcp4),
 }
 
-// SAFETY: UEFI has no threads.
+// SAFETY: UEFI has no regular threads. It does have interrupt handlers and can run code
+// on other CPU cores, but those are constrained execution environments that `std` does
+// not support, so they are not considered to be relevant for `Send` of `std` types.
 unsafe impl Send for Tcp {}
 
 impl Tcp {

From 26421f2802eb425393c7cb0521236f75629fd9b9 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 13:17:03 +0530
Subject: [PATCH 0914/1059] migrate generate_impl to use SyntaxFactory instead
 of make

---
 .../ide-assists/src/handlers/generate_impl.rs | 41 ++++++++++++-------
 .../crates/ide-assists/src/utils.rs           | 12 +++++-
 2 files changed, 36 insertions(+), 17 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
index bbd42481ef0f..2d1235792dcf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
@@ -1,15 +1,21 @@
 use syntax::{
-    ast::{self, AstNode, HasGenericParams, HasName, edit::AstNodeEdit, make},
+    ast::{
+        self, AstNode, HasGenericParams, HasName, edit::AstNodeEdit, syntax_factory::SyntaxFactory,
+    },
     syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{
     AssistContext, AssistId, Assists,
-    utils::{self, DefaultMethods, IgnoreAssocItems},
+    utils::{
+        self, DefaultMethods, IgnoreAssocItems, generate_impl_with_factory,
+        generate_trait_impl_intransitive,
+    },
 };
 
 fn insert_impl(
     editor: &mut SyntaxEditor,
+    make: &SyntaxFactory,
     impl_: &ast::Impl,
     nominal: &impl AstNodeEdit,
 ) -> ast::Impl {
@@ -20,7 +26,7 @@ fn insert_impl(
         Position::after(nominal.syntax()),
         vec![
             // Add a blank line after the ADT, and indentation for the impl to match the ADT
-            make::tokens::whitespace(&format!("\n\n{indent}")).into(),
+            make.whitespace(&format!("\n\n{indent}")).into(),
             impl_.syntax().clone().into(),
         ],
     );
@@ -59,12 +65,13 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext<'_>) -> Optio
         format!("Generate impl for `{name}`"),
         target,
         |edit| {
+            let make = SyntaxFactory::with_mappings();
             // Generate the impl
-            let impl_ = utils::generate_impl(&nominal);
+            let impl_ = generate_impl_with_factory(&make, &nominal);
 
             let mut editor = edit.make_editor(nominal.syntax());
 
-            let impl_ = insert_impl(&mut editor, &impl_, &nominal);
+            let impl_ = insert_impl(&mut editor, &make, &impl_, &nominal);
             // Add a tabstop after the left curly brace
             if let Some(cap) = ctx.config.snippet_cap
                 && let Some(l_curly) = impl_.assoc_item_list().and_then(|it| it.l_curly_token())
@@ -73,6 +80,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext<'_>) -> Optio
                 editor.add_annotation(l_curly, tabstop);
             }
 
+            editor.add_mappings(make.finish_with_mappings());
             edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -109,12 +117,13 @@ pub(crate) fn generate_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         format!("Generate trait impl for `{name}`"),
         target,
         |edit| {
+            let make = SyntaxFactory::with_mappings();
             // Generate the impl
-            let impl_ = utils::generate_trait_impl_intransitive(&nominal, make::ty_placeholder());
+            let impl_ = generate_trait_impl_intransitive(&make, &nominal, make.ty_placeholder());
 
             let mut editor = edit.make_editor(nominal.syntax());
 
-            let impl_ = insert_impl(&mut editor, &impl_, &nominal);
+            let impl_ = insert_impl(&mut editor, &make, &impl_, &nominal);
             // Make the trait type a placeholder snippet
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(trait_) = impl_.trait_() {
@@ -128,6 +137,7 @@ pub(crate) fn generate_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>) ->
                 }
             }
 
+            editor.add_mappings(make.finish_with_mappings());
             edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -166,9 +176,10 @@ pub(crate) fn generate_impl_trait(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         format!("Generate `{name}` impl for type"),
         target,
         |edit| {
+            let make = SyntaxFactory::with_mappings();
             let mut editor = edit.make_editor(trait_.syntax());
 
-            let holder_arg = ast::GenericArg::TypeArg(make::type_arg(make::ty_placeholder()));
+            let holder_arg = ast::GenericArg::TypeArg(make.type_arg(make.ty_placeholder()));
             let missing_items = utils::filter_assoc_items(
                 &ctx.sema,
                 &hir_trait.items(ctx.db()),
@@ -177,11 +188,11 @@ pub(crate) fn generate_impl_trait(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             );
 
             let trait_gen_args = trait_.generic_param_list().map(|list| {
-                make::generic_arg_list(list.generic_params().map(|_| holder_arg.clone()))
+                make.generic_arg_list(list.generic_params().map(|_| holder_arg.clone()), false)
             });
 
             let make_impl_ = |body| {
-                make::impl_trait(
+                make.impl_trait(
                     None,
                     trait_.unsafe_token().is_some(),
                     None,
@@ -189,13 +200,12 @@ pub(crate) fn generate_impl_trait(acc: &mut Assists, ctx: &AssistContext<'_>) ->
                     None,
                     None,
                     false,
-                    make::ty(&name.text()),
-                    make::ty_placeholder(),
+                    make.ty(&name.text()),
+                    make.ty_placeholder(),
                     None,
                     None,
                     body,
                 )
-                .clone_for_update()
             };
 
             let impl_ = if missing_items.is_empty() {
@@ -210,11 +220,12 @@ pub(crate) fn generate_impl_trait(acc: &mut Assists, ctx: &AssistContext<'_>) ->
                     &impl_,
                     &target_scope,
                 );
-                let assoc_item_list = make::assoc_item_list(Some(assoc_items));
+                let assoc_item_list = make.assoc_item_list(assoc_items);
                 make_impl_(Some(assoc_item_list))
             };
 
-            let impl_ = insert_impl(&mut editor, &impl_, &trait_);
+            let impl_ = insert_impl(&mut editor, &make, &impl_, &trait_);
+            editor.add_mappings(make.finish_with_mappings());
 
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(generics) = impl_.trait_().and_then(|it| it.generic_arg_list()) {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index a85a89efb4a2..7eec38af7987 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -739,6 +739,10 @@ pub(crate) fn generate_impl_with_item(
     generate_impl_inner(false, adt, None, true, body)
 }
 
+pub(crate) fn generate_impl_with_factory(make: &SyntaxFactory, adt: &ast::Adt) -> ast::Impl {
+    generate_impl_inner_with_factory(make, false, adt, None, true, None)
+}
+
 pub(crate) fn generate_impl(adt: &ast::Adt) -> ast::Impl {
     generate_impl_inner(false, adt, None, true, None)
 }
@@ -760,8 +764,12 @@ pub(crate) fn generate_trait_impl(
 /// and lifetime parameters, with `impl`'s generic parameters' bounds kept as-is.
 ///
 /// This is useful for traits like `From<T>`, since `impl<T> From<T> for U<T>` doesn't require `T: From<T>`.
-pub(crate) fn generate_trait_impl_intransitive(adt: &ast::Adt, trait_: ast::Type) -> ast::Impl {
-    generate_impl_inner(false, adt, Some(trait_), false, None)
+pub(crate) fn generate_trait_impl_intransitive(
+    make: &SyntaxFactory,
+    adt: &ast::Adt,
+    trait_: ast::Type,
+) -> ast::Impl {
+    generate_impl_inner_with_factory(make, false, adt, Some(trait_), false, None)
 }
 
 fn generate_impl_inner(

From c516070954696b0d731823164ac3053a98d1c7ee Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 13:32:11 +0530
Subject: [PATCH 0915/1059] migrate needs_parens_in_call to use SyntaxFactory

---
 src/tools/rust-analyzer/crates/ide-assists/src/utils.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 7eec38af7987..cfbb5a17eb17 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -103,11 +103,11 @@ pub(crate) fn wrap_paren(expr: ast::Expr, make: &SyntaxFactory, prec: ExprPreced
 }
 
 pub(crate) fn wrap_paren_in_call(expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {
-    if needs_parens_in_call(&expr) { make.expr_paren(expr).into() } else { expr }
+    if needs_parens_in_call(make, &expr) { make.expr_paren(expr).into() } else { expr }
 }
 
-fn needs_parens_in_call(param: &ast::Expr) -> bool {
-    let call = make::expr_call(make::ext::expr_unit(), make::arg_list(Vec::new()));
+fn needs_parens_in_call(make: &SyntaxFactory, param: &ast::Expr) -> bool {
+    let call = make.expr_call(make.expr_unit(), make.arg_list(Vec::new()));
     let callable = call.expr().expect("invalid make call");
     param.needs_parens_in_place_of(call.syntax(), callable.syntax())
 }

From 08e064a9cb46008d72236dd83737f160afd67e99 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 25 Mar 2026 16:48:57 +0900
Subject: [PATCH 0916/1059] add regression test for 154189

fix ci errors
---
 .../generalize-associated-type-alias.rs       | 22 +++++++++++++++
 .../generalize-associated-type-alias.stderr   | 28 +++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 tests/ui/coherence/generalize-associated-type-alias.rs
 create mode 100644 tests/ui/coherence/generalize-associated-type-alias.stderr

diff --git a/tests/ui/coherence/generalize-associated-type-alias.rs b/tests/ui/coherence/generalize-associated-type-alias.rs
new file mode 100644
index 000000000000..f333a0d8ae85
--- /dev/null
+++ b/tests/ui/coherence/generalize-associated-type-alias.rs
@@ -0,0 +1,22 @@
+// Regression test for https://github.com/rust-lang/rust/issues/154189.
+#![feature(unboxed_closures)]
+
+trait ToUnit<'a> {
+    type Unit;
+}
+
+impl ToUnit<'_> for *const u32 {
+    type Unit = ();
+}
+
+trait Overlap<T> {}
+
+type Assoc<'a, T> = <*const T as ToUnit<'a>>::Unit;
+
+impl<T> Overlap<T> for T {}
+
+impl<'a, T> Overlap<(&'a (), Assoc<'a, T>)> for T {}
+//~^ ERROR the trait bound `*const T: ToUnit<'a>` is not satisfied
+//~| ERROR the trait bound `T: Overlap<(&'a (), _)>` is not satisfied
+
+fn main() {}
diff --git a/tests/ui/coherence/generalize-associated-type-alias.stderr b/tests/ui/coherence/generalize-associated-type-alias.stderr
new file mode 100644
index 000000000000..e65205dbccbd
--- /dev/null
+++ b/tests/ui/coherence/generalize-associated-type-alias.stderr
@@ -0,0 +1,28 @@
+error[E0277]: the trait bound `*const T: ToUnit<'a>` is not satisfied
+  --> $DIR/generalize-associated-type-alias.rs:18:13
+   |
+LL | impl<'a, T> Overlap<(&'a (), Assoc<'a, T>)> for T {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ToUnit<'a>` is not implemented for `*const T`
+   |
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
+   |
+LL | impl<'a, T> Overlap<(&'a (), Assoc<'a, T>)> for T where *const T: ToUnit<'a> {}
+   |                                                   ++++++++++++++++++++++++++
+
+error[E0277]: the trait bound `T: Overlap<(&'a (), _)>` is not satisfied
+  --> $DIR/generalize-associated-type-alias.rs:18:49
+   |
+LL | impl<'a, T> Overlap<(&'a (), Assoc<'a, T>)> for T {}
+   |                                                 ^ the trait `Overlap<(&'a (), _)>` is not implemented for `T`
+   |
+help: the trait `Overlap<(&'a (), _)>` is not implemented for `T`
+      but trait `Overlap<(&(), ())>` is implemented for `u32`
+  --> $DIR/generalize-associated-type-alias.rs:18:1
+   |
+LL | impl<'a, T> Overlap<(&'a (), Assoc<'a, T>)> for T {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: for that trait implementation, expected `u32`, found `T`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

From 7cb28c980dc5893c33a51be816f625cf695e4755 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 25 Mar 2026 16:59:43 +0800
Subject: [PATCH 0917/1059] fromrangeiter-overflow-checks: accept optional
 `signext` for argument

On some targets such as LoongArch64 and RISCV64, the ABI requires
sign-extension for 32-bit integer arguments, so LLVM may emit the
`signext` attribute for the `%range` parameter. The existing CHECK
pattern required the argument to be exactly `i32 noundef %range`,
causing the test to fail on those targets.

Allow an optional `signext` attribute in the CHECK pattern so the test
passes consistently across architectures without affecting the intended
codegen validation.
---
 tests/codegen-llvm/fromrangeiter-overflow-checks.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
index 455c81c63340..e1e521103b57 100644
--- a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
+++ b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
@@ -19,7 +19,7 @@ pub unsafe fn rangefrom_increments(range: RangeFrom<i32>) -> RangeFrom<i32> {
     // Iterator is contained entirely within this function, so the optimizer should
     // be able to see that `exhausted` is never set and optimize out any branches.
 
-    //         CHECK: i32 noundef %range
+    //         CHECK: i32 noundef {{(signext )?}}%range
     //         DEBUG: switch i32 %range
     //         DEBUG: call core::panicking::panic_const::panic_const_add_overflow
     //         DEBUG: unreachable

From 11a338deb6884f72f3d3558d810e9b025de23167 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Wed, 25 Mar 2026 12:08:31 +0300
Subject: [PATCH 0918/1059] Fix nested zero-args delegation ICE

---
 compiler/rustc_ast_lowering/src/delegation.rs | 11 +++++
 tests/ui/delegation/explicit-paths-pass.rs    |  4 --
 tests/ui/delegation/inner-attr.rs             |  1 +
 tests/ui/delegation/inner-attr.stderr         | 22 +++++++++-
 .../zero-args-delegations-ice-154332.rs       | 30 +++++++++++++
 .../zero-args-delegations-ice-154332.stderr   | 43 +++++++++++++++++++
 6 files changed, 105 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/delegation/zero-args-delegations-ice-154332.rs
 create mode 100644 tests/ui/delegation/zero-args-delegations-ice-154332.stderr

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 03acf40ef5fe..022f9e3c83f1 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -432,6 +432,17 @@ fn lower_delegation_body(
                 args.push(arg);
             }
 
+            // If we have no params in signature function but user still wrote some code in
+            // delegation body, then add this code as first arg, eventually an error will be shown,
+            // also nested delegations may need to access information about this code (#154332),
+            // so it is better to leave this code as opposed to bodies of extern functions,
+            // which are completely erased from existence.
+            if param_count == 0
+                && let Some(block) = block
+            {
+                args.push(this.lower_target_expr(&block));
+            }
+
             let final_expr = this.finalize_body_lowering(delegation, args, generics, span);
 
             (this.arena.alloc_from_iter(parameters), final_expr)
diff --git a/tests/ui/delegation/explicit-paths-pass.rs b/tests/ui/delegation/explicit-paths-pass.rs
index dd0ee2c732f5..7efbb3795185 100644
--- a/tests/ui/delegation/explicit-paths-pass.rs
+++ b/tests/ui/delegation/explicit-paths-pass.rs
@@ -17,11 +17,8 @@ impl Trait for F {}
 
 mod to_reuse {
     pub fn foo(x: i32) -> i32 { x + 1 }
-    pub fn zero_args() -> i32 { 15 }
 }
 
-reuse to_reuse::zero_args { self }
-
 struct S(F);
 impl Trait for S {
     reuse Trait::bar { self.0 }
@@ -49,5 +46,4 @@ fn main() {
     #[inline]
     reuse to_reuse::foo;
     assert_eq!(43, foo(42));
-    assert_eq!(15, zero_args());
 }
diff --git a/tests/ui/delegation/inner-attr.rs b/tests/ui/delegation/inner-attr.rs
index 6c996807d6ba..501118713d12 100644
--- a/tests/ui/delegation/inner-attr.rs
+++ b/tests/ui/delegation/inner-attr.rs
@@ -4,5 +4,6 @@
 fn a() {}
 
 reuse a as b { #![rustc_dummy] self } //~ ERROR an inner attribute is not permitted in this context
+//~^ ERROR: this function takes 0 arguments but 1 argument was supplied
 
 fn main() {}
diff --git a/tests/ui/delegation/inner-attr.stderr b/tests/ui/delegation/inner-attr.stderr
index 257ab760ffc1..226a48ecf9a4 100644
--- a/tests/ui/delegation/inner-attr.stderr
+++ b/tests/ui/delegation/inner-attr.stderr
@@ -3,11 +3,29 @@ error: an inner attribute is not permitted in this context
    |
 LL | reuse a as b { #![rustc_dummy] self }
    |                ^^^^^^^^^^^^^^^
-LL |
+...
 LL | fn main() {}
    | ------------ the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
 
-error: aborting due to 1 previous error
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/inner-attr.rs:6:7
+   |
+LL | reuse a as b { #![rustc_dummy] self }
+   |       ^                        ---- unexpected argument
+   |
+note: function defined here
+  --> $DIR/inner-attr.rs:4:4
+   |
+LL | fn a() {}
+   |    ^
+help: remove the extra argument
+   |
+LL - reuse a as b { #![rustc_dummy] self }
+LL + reuse self }
+   |
 
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/delegation/zero-args-delegations-ice-154332.rs b/tests/ui/delegation/zero-args-delegations-ice-154332.rs
new file mode 100644
index 000000000000..c684803014ad
--- /dev/null
+++ b/tests/ui/delegation/zero-args-delegations-ice-154332.rs
@@ -0,0 +1,30 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod test_ice {
+    fn a() {}
+
+    reuse a as b { //~ ERROR: this function takes 0 arguments but 1 argument was supplied
+        let closure = || {
+            fn foo<'a, 'b, T: Clone, const N: usize, U: Clone>(_t: &'a T, _u: &'b U) {}
+
+            reuse foo::<String, 1, String> as bar;
+            bar(&"".to_string(), &"".to_string());
+        };
+
+        closure();
+    }
+}
+
+mod test_2 {
+    mod to_reuse {
+        pub fn zero_args() -> i32 {
+            15
+        }
+    }
+
+    reuse to_reuse::zero_args { self }
+    //~^ ERROR: this function takes 0 arguments but 1 argument was supplied
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/zero-args-delegations-ice-154332.stderr b/tests/ui/delegation/zero-args-delegations-ice-154332.stderr
new file mode 100644
index 000000000000..dcac56e0b2ba
--- /dev/null
+++ b/tests/ui/delegation/zero-args-delegations-ice-154332.stderr
@@ -0,0 +1,43 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/zero-args-delegations-ice-154332.rs:7:11
+   |
+LL |       reuse a as b {
+   |  ___________^______-
+LL | |         let closure = || {
+LL | |             fn foo<'a, 'b, T: Clone, const N: usize, U: Clone>(_t: &'a T, _u: &'b U) {}
+...  |
+LL | |         closure();
+LL | |     }
+   | |_____- unexpected argument of type `()`
+   |
+note: function defined here
+  --> $DIR/zero-args-delegations-ice-154332.rs:5:8
+   |
+LL |     fn a() {}
+   |        ^
+help: remove the extra argument
+   |
+LL -     reuse a as b {
+LL +     reuse {
+   |
+
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/zero-args-delegations-ice-154332.rs:26:21
+   |
+LL |     reuse to_reuse::zero_args { self }
+   |                     ^^^^^^^^^   ---- unexpected argument
+   |
+note: function defined here
+  --> $DIR/zero-args-delegations-ice-154332.rs:21:16
+   |
+LL |         pub fn zero_args() -> i32 {
+   |                ^^^^^^^^^
+help: remove the extra argument
+   |
+LL -     reuse to_reuse::zero_args { self }
+LL +     reuse to_reuse::zero_argself }
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0061`.

From bca30d482866d6f1471f7585fe2875b29a6e4f64 Mon Sep 17 00:00:00 2001
From: danieljofficial <joenah004@gmail.com>
Date: Mon, 23 Mar 2026 10:46:50 +0100
Subject: [PATCH 0919/1059] add issue link comments and bless

---
 .../static-cannot-use-local-variable.fixed    |  2 ++
 .../static-cannot-use-local-variable.rs       |  2 ++
 .../static-cannot-use-local-variable.stderr   |  2 +-
 .../static-in-fn-cannot-use-param.fixed       |  4 +++-
 .../statics/static-in-fn-cannot-use-param.rs  |  4 +++-
 .../static-in-fn-cannot-use-param.stderr      |  2 +-
 .../static-in-method-cannot-use-self.rs       | 18 +++++++++-------
 .../static-in-method-cannot-use-self.stderr   | 10 ++++-----
 .../static-lazy-init-with-arena-set.rs        | 21 ++++++++++++-------
 .../static-lazy-init-with-arena-set.stderr    |  8 +++----
 .../statics/static-mut-borrow-of-temporary.rs |  2 ++
 .../static-mut-borrow-of-temporary.stderr     |  4 ++--
 .../static-mut-with-assoc-type-field.rs       |  4 +++-
 .../static-ref-deref-non-const-trait.rs       |  9 ++++++--
 .../static-ref-deref-non-const-trait.stderr   |  2 +-
 15 files changed, 60 insertions(+), 34 deletions(-)

diff --git a/tests/ui/statics/static-cannot-use-local-variable.fixed b/tests/ui/statics/static-cannot-use-local-variable.fixed
index 2a6e0829bc0f..df9dfb7a3317 100644
--- a/tests/ui/statics/static-cannot-use-local-variable.fixed
+++ b/tests/ui/statics/static-cannot-use-local-variable.fixed
@@ -1,3 +1,5 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/3521
+//!
 //@ run-rustfix
 fn main() {
     let foo = 100;
diff --git a/tests/ui/statics/static-cannot-use-local-variable.rs b/tests/ui/statics/static-cannot-use-local-variable.rs
index bd8220200654..0269f9e6e896 100644
--- a/tests/ui/statics/static-cannot-use-local-variable.rs
+++ b/tests/ui/statics/static-cannot-use-local-variable.rs
@@ -1,3 +1,5 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/3521
+//!
 //@ run-rustfix
 fn main() {
     let foo = 100;
diff --git a/tests/ui/statics/static-cannot-use-local-variable.stderr b/tests/ui/statics/static-cannot-use-local-variable.stderr
index ecf1ad0403d3..350c38480ed7 100644
--- a/tests/ui/statics/static-cannot-use-local-variable.stderr
+++ b/tests/ui/statics/static-cannot-use-local-variable.stderr
@@ -1,5 +1,5 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/issue-3521-2.rs:5:23
+  --> $DIR/static-cannot-use-local-variable.rs:7:23
    |
 LL |     static y: isize = foo + 1;
    |                       ^^^ non-constant value
diff --git a/tests/ui/statics/static-in-fn-cannot-use-param.fixed b/tests/ui/statics/static-in-fn-cannot-use-param.fixed
index bf100755b906..bf6df45a2579 100644
--- a/tests/ui/statics/static-in-fn-cannot-use-param.fixed
+++ b/tests/ui/statics/static-in-fn-cannot-use-param.fixed
@@ -1,6 +1,8 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/3668
+//!
 //@ run-rustfix
 #![allow(unused_variables, dead_code)]
-fn f(x:isize) {
+fn f(x: isize) {
     let child: isize = x + 1;
     //~^ ERROR attempt to use a non-constant value in a constant
 }
diff --git a/tests/ui/statics/static-in-fn-cannot-use-param.rs b/tests/ui/statics/static-in-fn-cannot-use-param.rs
index 375178172bb0..bd121a7045dd 100644
--- a/tests/ui/statics/static-in-fn-cannot-use-param.rs
+++ b/tests/ui/statics/static-in-fn-cannot-use-param.rs
@@ -1,6 +1,8 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/3668
+//!
 //@ run-rustfix
 #![allow(unused_variables, dead_code)]
-fn f(x:isize) {
+fn f(x: isize) {
     static child: isize = x + 1;
     //~^ ERROR attempt to use a non-constant value in a constant
 }
diff --git a/tests/ui/statics/static-in-fn-cannot-use-param.stderr b/tests/ui/statics/static-in-fn-cannot-use-param.stderr
index f87514ba83b0..67890de71af6 100644
--- a/tests/ui/statics/static-in-fn-cannot-use-param.stderr
+++ b/tests/ui/statics/static-in-fn-cannot-use-param.stderr
@@ -1,5 +1,5 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/issue-3668-2.rs:4:27
+  --> $DIR/static-in-fn-cannot-use-param.rs:6:27
    |
 LL |     static child: isize = x + 1;
    |                           ^ non-constant value
diff --git a/tests/ui/statics/static-in-method-cannot-use-self.rs b/tests/ui/statics/static-in-method-cannot-use-self.rs
index 0e1f19a75bae..a5d6feae7e91 100644
--- a/tests/ui/statics/static-in-method-cannot-use-self.rs
+++ b/tests/ui/statics/static-in-method-cannot-use-self.rs
@@ -1,14 +1,18 @@
-struct P { child: Option<Box<P>> }
+//! Regression test for https://github.com/rust-lang/rust/issues/3668
+//!
+struct P {
+    child: Option<Box<P>>,
+}
 trait PTrait {
-   fn getChildOption(&self) -> Option<Box<P>>;
+    fn getChildOption(&self) -> Option<Box<P>>;
 }
 
 impl PTrait for P {
-   fn getChildOption(&self) -> Option<Box<P>> {
-       static childVal: Box<P> = self.child.get();
-       //~^ ERROR attempt to use a non-constant value in a constant
-       panic!();
-   }
+    fn getChildOption(&self) -> Option<Box<P>> {
+        static childVal: Box<P> = self.child.get();
+        //~^ ERROR attempt to use a non-constant value in a constant
+        panic!();
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/statics/static-in-method-cannot-use-self.stderr b/tests/ui/statics/static-in-method-cannot-use-self.stderr
index 06e0192d9574..d5db956cf16f 100644
--- a/tests/ui/statics/static-in-method-cannot-use-self.stderr
+++ b/tests/ui/statics/static-in-method-cannot-use-self.stderr
@@ -1,13 +1,13 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/issue-3668.rs:8:34
+  --> $DIR/static-in-method-cannot-use-self.rs:12:35
    |
-LL |        static childVal: Box<P> = self.child.get();
-   |                                  ^^^^ non-constant value
+LL |         static childVal: Box<P> = self.child.get();
+   |                                   ^^^^ non-constant value
    |
 help: consider using `let` instead of `static`
    |
-LL -        static childVal: Box<P> = self.child.get();
-LL +        let childVal: Box<P> = self.child.get();
+LL -         static childVal: Box<P> = self.child.get();
+LL +         let childVal: Box<P> = self.child.get();
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/statics/static-lazy-init-with-arena-set.rs b/tests/ui/statics/static-lazy-init-with-arena-set.rs
index 68b4d28aae3b..009d1d939360 100644
--- a/tests/ui/statics/static-lazy-init-with-arena-set.rs
+++ b/tests/ui/statics/static-lazy-init-with-arena-set.rs
@@ -1,11 +1,16 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/39367
+//!
+//! Tests that lazy static initialization using `Once` and `transmute`
+//! works correctly with a struct that has a default type parameter.
 //@ run-pass
 
 use std::ops::Deref;
 
-struct ArenaSet<U: Deref, V=<U as Deref>::Target>(U, &'static V)
-    where V: 'static + ?Sized;
+struct ArenaSet<U: Deref, V = <U as Deref>::Target>(U, &'static V)
+where
+    V: 'static + ?Sized;
 
-static Z: [u8; 4] = [1,2,3,4];
+static Z: [u8; 4] = [1, 2, 3, 4];
 
 fn arena() -> &'static ArenaSet<Vec<u8>> {
     fn __static_ref_initialize() -> ArenaSet<Vec<u8>> {
@@ -13,17 +18,17 @@ fn __static_ref_initialize() -> ArenaSet<Vec<u8>> {
     }
     unsafe {
         use std::sync::Once;
-        fn require_sync<T: Sync>(_: &T) { }
+        fn require_sync<T: Sync>(_: &T) {}
         unsafe fn __stability() -> &'static ArenaSet<Vec<u8>> {
             use std::mem::transmute;
             static mut DATA: *const ArenaSet<Vec<u8>> = std::ptr::null_mut();
 
             static mut ONCE: Once = Once::new();
             ONCE.call_once(|| {
-            //~^ WARN creating a shared reference to mutable static [static_mut_refs]
-                DATA = transmute
-                    ::<Box<ArenaSet<Vec<u8>>>, *const ArenaSet<Vec<u8>>>
-                    (Box::new(__static_ref_initialize()));
+                //~^ WARN creating a shared reference to mutable static [static_mut_refs]
+                DATA = transmute::<Box<ArenaSet<Vec<u8>>>, *const ArenaSet<Vec<u8>>>(Box::new(
+                    __static_ref_initialize(),
+                ));
             });
 
             &*DATA
diff --git a/tests/ui/statics/static-lazy-init-with-arena-set.stderr b/tests/ui/statics/static-lazy-init-with-arena-set.stderr
index e94c961f431d..134129f814aa 100644
--- a/tests/ui/statics/static-lazy-init-with-arena-set.stderr
+++ b/tests/ui/statics/static-lazy-init-with-arena-set.stderr
@@ -1,11 +1,11 @@
 warning: creating a shared reference to mutable static
-  --> $DIR/issue-39367.rs:22:13
+  --> $DIR/static-lazy-init-with-arena-set.rs:27:13
    |
 LL | /             ONCE.call_once(|| {
 LL | |
-LL | |                 DATA = transmute
-LL | |                     ::<Box<ArenaSet<Vec<u8>>>, *const ArenaSet<Vec<u8>>>
-LL | |                     (Box::new(__static_ref_initialize()));
+LL | |                 DATA = transmute::<Box<ArenaSet<Vec<u8>>>, *const ArenaSet<Vec<u8>>>(Box::new(
+LL | |                     __static_ref_initialize(),
+LL | |                 ));
 LL | |             });
    | |______________^ shared reference to mutable static
    |
diff --git a/tests/ui/statics/static-mut-borrow-of-temporary.rs b/tests/ui/statics/static-mut-borrow-of-temporary.rs
index e15f0b52da2f..8f679d27059a 100644
--- a/tests/ui/statics/static-mut-borrow-of-temporary.rs
+++ b/tests/ui/statics/static-mut-borrow-of-temporary.rs
@@ -1,3 +1,5 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/46604
+//!
 static buf: &mut [u8] = &mut [1u8,2,3,4,5,7];   //~ ERROR mutable borrows of temporaries
 fn write<T: AsRef<[u8]>>(buffer: T) { }
 
diff --git a/tests/ui/statics/static-mut-borrow-of-temporary.stderr b/tests/ui/statics/static-mut-borrow-of-temporary.stderr
index 21abc498de12..a3d06011bbfb 100644
--- a/tests/ui/statics/static-mut-borrow-of-temporary.stderr
+++ b/tests/ui/statics/static-mut-borrow-of-temporary.stderr
@@ -1,5 +1,5 @@
 error[E0764]: mutable borrows of temporaries that have their lifetime extended until the end of the program are not allowed
-  --> $DIR/issue-46604.rs:1:25
+  --> $DIR/static-mut-borrow-of-temporary.rs:3:25
    |
 LL | static buf: &mut [u8] = &mut [1u8,2,3,4,5,7];
    |                         ^^^^^^^^^^^^^^^^^^^^ this mutable borrow refers to such a temporary
@@ -9,7 +9,7 @@ LL | static buf: &mut [u8] = &mut [1u8,2,3,4,5,7];
    = help: if you really want global mutable state, try replacing the temporary by an interior mutable `static` or a `static mut`
 
 error[E0594]: cannot assign to `buf[_]`, as `buf` is an immutable static item
-  --> $DIR/issue-46604.rs:6:5
+  --> $DIR/static-mut-borrow-of-temporary.rs:8:5
    |
 LL | static buf: &mut [u8] = &mut [1u8,2,3,4,5,7];
    | --------------------- this `static` cannot be written to
diff --git a/tests/ui/statics/static-mut-with-assoc-type-field.rs b/tests/ui/statics/static-mut-with-assoc-type-field.rs
index 508009337a5a..347c50e1e3b6 100644
--- a/tests/ui/statics/static-mut-with-assoc-type-field.rs
+++ b/tests/ui/statics/static-mut-with-assoc-type-field.rs
@@ -1,3 +1,5 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/29821
+//!
 //@ build-pass
 
 pub trait Foo {
@@ -5,7 +7,7 @@ pub trait Foo {
 }
 
 pub struct Bar<F: Foo> {
-    id: F::FooAssoc
+    id: F::FooAssoc,
 }
 
 pub struct Baz;
diff --git a/tests/ui/statics/static-ref-deref-non-const-trait.rs b/tests/ui/statics/static-ref-deref-non-const-trait.rs
index d40b869cd0cd..6d7b375ecb10 100644
--- a/tests/ui/statics/static-ref-deref-non-const-trait.rs
+++ b/tests/ui/statics/static-ref-deref-non-const-trait.rs
@@ -1,3 +1,5 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/25901
+//!
 struct A;
 struct B;
 
@@ -8,7 +10,10 @@
 
 impl Deref for A {
     type Target = B;
-    fn deref(&self)->&B { static B_: B = B; &B_ }
+    fn deref(&self) -> &B {
+        static B_: B = B;
+        &B_
+    }
 }
 
-fn main(){}
+fn main() {}
diff --git a/tests/ui/statics/static-ref-deref-non-const-trait.stderr b/tests/ui/statics/static-ref-deref-non-const-trait.stderr
index 9b65366b969a..88ddffecc928 100644
--- a/tests/ui/statics/static-ref-deref-non-const-trait.stderr
+++ b/tests/ui/statics/static-ref-deref-non-const-trait.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `A: const Deref` is not satisfied
-  --> $DIR/issue-25901.rs:4:24
+  --> $DIR/static-ref-deref-non-const-trait.rs:6:24
    |
 LL | static S: &'static B = &A;
    |                        ^^

From c2383b53a26fe3f0108d20c94dd171c1faf4cfd2 Mon Sep 17 00:00:00 2001
From: aerooneqq <aerooneq@yandex.ru>
Date: Wed, 25 Mar 2026 13:04:03 +0300
Subject: [PATCH 0920/1059] Don't propagate synthetic params, remove lifetime
 hacks

---
 .../src/delegation/generics.rs                |  3 +--
 compiler/rustc_hir_analysis/src/delegation.rs | 10 +------
 .../generics/mapping/free-to-free-pass.rs     | 22 +++++++--------
 .../generics/synth-params-ice-143498.rs       | 27 +++++++++++++++++++
 .../generics/synth-params-ice-143498.stderr   | 27 +++++++++++++++++++
 5 files changed, 66 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/delegation/generics/synth-params-ice-143498.rs
 create mode 100644 tests/ui/delegation/generics/synth-params-ice-143498.stderr

diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index ee1ac9aa5cd8..4e960e3b9290 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -337,7 +337,6 @@ fn uplift_delegation_generic_params(
         // HACK: for now we generate predicates such that all lifetimes are early bound,
         // we can not not generate early-bound lifetimes, but we can't know which of them
         // are late-bound at this level of compilation.
-        // FIXME(fn_delegation): proper support for late bound lifetimes.
         let predicates =
             self.arena.alloc_from_iter(params.iter().filter_map(|p| {
                 p.is_lifetime().then(|| self.generate_lifetime_predicate(p, span))
@@ -391,7 +390,7 @@ fn create_generics_args_from_params(
         self.arena.alloc(hir::GenericArgs {
             args: self.arena.alloc_from_iter(params.iter().filter_map(|p| {
                 // Skip self generic arg, we do not need to propagate it.
-                if p.name.ident().name == kw::SelfUpper {
+                if p.name.ident().name == kw::SelfUpper || p.is_impl_trait() {
                     return None;
                 }
 
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index 0b142c0b7686..730288574e76 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -138,7 +138,6 @@ fn create_mapping<'tcx>(
     tcx: TyCtxt<'tcx>,
     sig_id: DefId,
     def_id: LocalDefId,
-    args: &[ty::GenericArg<'tcx>],
 ) -> FxHashMap<u32, u32> {
     let mut mapping: FxHashMap<u32, u32> = Default::default();
 
@@ -176,13 +175,6 @@ fn create_mapping<'tcx>(
         }
     }
 
-    // If there are still unmapped lifetimes left and we are to map types and maybe self
-    // then skip them, now it is the case when we generated more lifetimes then needed.
-    // FIXME(fn_delegation): proper support for late bound lifetimes.
-    while args_index < args.len() && args[args_index].as_region().is_some() {
-        args_index += 1;
-    }
-
     // If self after lifetimes insert mapping, relying that self is at 0 in sig parent.
     if matches!(self_pos_kind, SelfPositionKind::AfterLifetimes) {
         mapping.insert(0, args_index as u32);
@@ -511,7 +503,7 @@ fn create_folder_and_args<'tcx>(
     child_args: &'tcx [ty::GenericArg<'tcx>],
 ) -> (ParamIndexRemapper<'tcx>, Vec<ty::GenericArg<'tcx>>) {
     let args = create_generic_args(tcx, sig_id, def_id, parent_args, child_args);
-    let remap_table = create_mapping(tcx, sig_id, def_id, &args);
+    let remap_table = create_mapping(tcx, sig_id, def_id);
 
     (ParamIndexRemapper { tcx, remap_table }, args)
 }
diff --git a/tests/ui/delegation/generics/mapping/free-to-free-pass.rs b/tests/ui/delegation/generics/mapping/free-to-free-pass.rs
index aafdd5617d02..c67e4c02a1b7 100644
--- a/tests/ui/delegation/generics/mapping/free-to-free-pass.rs
+++ b/tests/ui/delegation/generics/mapping/free-to-free-pass.rs
@@ -78,18 +78,16 @@ pub fn check<T: Clone, U: Clone>() {
     }
 }
 
-// FIXME(fn_delegation): Uncomment this test when impl Traits in function params are supported
+mod test_7 {
+    fn foo<T, U>(t: T, u: U, f: impl FnOnce(T, U) -> U) -> U {
+        f(t, u)
+    }
 
-// mod test_7 {
-//     fn foo<T, U>(t: T, u: U, f: impl FnOnce(T, U) -> U) -> U {
-//         f(t, u)
-//     }
-
-//     pub fn check() {
-//         reuse foo as bar;
-//         assert_eq!(bar::<i32, i32>(1, 2, |x, y| y), 2);
-//     }
-// }
+    pub fn check() {
+        reuse foo as bar;
+        assert_eq!(bar::<i32, i32>(1, 2, |_, y| y), 2);
+    }
+}
 
 // Testing reuse of local fn with delegation parent generic params specified,
 // late-bound lifetimes + types + consts, reusing with user args,
@@ -126,7 +124,7 @@ pub fn main() {
     test_4::check::<i32, String>();
     test_5::check::<i32, String>();
     test_6::check::<i32, String>();
-    // test_7::check();
+    test_7::check();
     test_8::check::<i32, String>();
     test_9::check::<String, i32>();
 }
diff --git a/tests/ui/delegation/generics/synth-params-ice-143498.rs b/tests/ui/delegation/generics/synth-params-ice-143498.rs
new file mode 100644
index 000000000000..652059b37ec6
--- /dev/null
+++ b/tests/ui/delegation/generics/synth-params-ice-143498.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Z deduplicate-diagnostics=yes
+//@ edition:2024
+
+#![feature(fn_delegation)]
+#![feature(iter_advance_by)]
+#![feature(iter_array_chunks)]
+#![feature(iterator_try_collect)]
+#![feature(iterator_try_reduce)]
+#![feature(iter_collect_into)]
+#![feature(iter_intersperse)]
+#![feature(iter_is_partitioned)]
+#![feature(iter_map_windows)]
+#![feature(iter_next_chunk)]
+#![feature(iter_order_by)]
+#![feature(iter_partition_in_place)]
+#![feature(trusted_random_access)]
+#![feature(try_find)]
+#![allow(incomplete_features)]
+
+impl X {
+//~^ ERROR: cannot find type `X` in this scope
+    reuse< std::fmt::Debug as Iterator >::*;
+    //~^ ERROR: expected method or associated constant, found associated type `Iterator::Item`
+    //~| ERROR: expected a type, found a trait
+}
+
+pub fn main() {}
diff --git a/tests/ui/delegation/generics/synth-params-ice-143498.stderr b/tests/ui/delegation/generics/synth-params-ice-143498.stderr
new file mode 100644
index 000000000000..14b03991d9e6
--- /dev/null
+++ b/tests/ui/delegation/generics/synth-params-ice-143498.stderr
@@ -0,0 +1,27 @@
+error[E0425]: cannot find type `X` in this scope
+  --> $DIR/synth-params-ice-143498.rs:20:6
+   |
+LL | impl X {
+   |      ^ not found in this scope
+
+error[E0575]: expected method or associated constant, found associated type `Iterator::Item`
+  --> $DIR/synth-params-ice-143498.rs:22:10
+   |
+LL |     reuse< std::fmt::Debug as Iterator >::*;
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a method or associated constant
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/synth-params-ice-143498.rs:22:12
+   |
+LL |     reuse< std::fmt::Debug as Iterator >::*;
+   |            ^^^^^^^^^^^^^^^
+   |
+help: you can add the `dyn` keyword if you want a trait object
+   |
+LL |     reuse< dyn std::fmt::Debug as Iterator >::*;
+   |            +++
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0425, E0575, E0782.
+For more information about an error, try `rustc --explain E0425`.

From 2a543acbaf7739b547ca95c1d8d49758cfd510f4 Mon Sep 17 00:00:00 2001
From: Aryan Dubey <aryandubey@umass.edu>
Date: Wed, 25 Mar 2026 10:13:13 +0000
Subject: [PATCH 0921/1059] Moved and rename issue-50411 to
 tests/ui/mir/inliner-double-elaborate

* Move issue-50411 to tests/ui/mir/inliner-double-elaborate
* Addded the link for the issue to inliner-double-elaborate.rs
* Fix tidy issues
* Renamed to inliner-double-elaborate.rs
---
 .../{issues/issue-50411.rs => mir/inliner-double-elaborate.rs}  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename tests/ui/{issues/issue-50411.rs => mir/inliner-double-elaborate.rs} (73%)

diff --git a/tests/ui/issues/issue-50411.rs b/tests/ui/mir/inliner-double-elaborate.rs
similarity index 73%
rename from tests/ui/issues/issue-50411.rs
rename to tests/ui/mir/inliner-double-elaborate.rs
index 7fbbadac1e2b..c6af573a5869 100644
--- a/tests/ui/issues/issue-50411.rs
+++ b/tests/ui/mir/inliner-double-elaborate.rs
@@ -1,4 +1,4 @@
-// Regression test for #50411: the MIR inliner was causing problems
+// Regression test for https://github.com/rust-lang/rust/issues/50411: the MIR inliner was causing problems
 // here because it would inline promoted code (which had already had
 // elaborate-drops invoked on it) and then try to elaboate drops a
 // second time. Uncool.

From 493d427c7d3423f085f05179e36a35b4943b1379 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:18:17 +0100
Subject: [PATCH 0922/1059] Rustup to rustc 1.96.0-nightly (362211dc2
 2026-03-24)

---
 ...sroot_tests-Add-missing-feature-gate.patch | 24 -------------------
 rust-toolchain.toml                           |  2 +-
 2 files changed, 1 insertion(+), 25 deletions(-)
 delete mode 100644 patches/0030-sysroot_tests-Add-missing-feature-gate.patch

diff --git a/patches/0030-sysroot_tests-Add-missing-feature-gate.patch b/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
deleted file mode 100644
index e4f1b0474afe..000000000000
--- a/patches/0030-sysroot_tests-Add-missing-feature-gate.patch
+++ /dev/null
@@ -1,24 +0,0 @@
-From baa9c656ba61633f2e5785fc47bc8f88ed2f738e Mon Sep 17 00:00:00 2001
-From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
-Date: Wed, 11 Mar 2026 12:34:47 +0000
-Subject: [PATCH] Add missing feature gate
-
----
- coretests/benches/lib.rs | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/coretests/benches/lib.rs b/coretests/benches/lib.rs
-index 150b9b3..281aa75 100644
---- a/coretests/benches/lib.rs
-+++ b/coretests/benches/lib.rs
-@@ -8,6 +8,7 @@
- #![feature(iter_array_chunks)]
- #![feature(iter_next_chunk)]
- #![feature(iter_advance_by)]
-+#![feature(num_internals)]
- #![feature(uint_gather_scatter_bits)]
- 
- extern crate test;
--- 
-2.43.0
-
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 80a698809720..d4bb9bea82bb 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-03-23"
+channel = "nightly-2026-03-25"
 components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]
 profile = "minimal"

From d7f7241eb2f72a74b062234bb0d83e5e1faf67a8 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:48:54 +0100
Subject: [PATCH 0923/1059] Update tidy allowed deps list

---
 src/tools/tidy/src/deps.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 9e9d463acdb3..c6624b1b3697 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -582,7 +582,7 @@ pub(crate) struct WorkspaceInfo<'a> {
     "cranelift-srcgen",
     "crc32fast",
     "equivalent",
-    "fallible-iterator",
+    "fnv",
     "foldhash",
     "gimli",
     "hashbrown",
@@ -608,8 +608,8 @@ pub(crate) struct WorkspaceInfo<'a> {
     "syn",
     "target-lexicon",
     "unicode-ident",
+    "wasmtime-internal-core",
     "wasmtime-internal-jit-icache-coherence",
-    "wasmtime-internal-math",
     "windows-link",
     "windows-sys",
     "windows-targets",

From f0c2bb026172ce0e98dac2f9d6c4ee7d1a7fc5fb Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Mar 2026 12:18:54 +0100
Subject: [PATCH 0924/1059] ./miri toolchain: support overwriting the
 to-be-installed commit

---
 src/tools/miri/miri-script/src/commands.rs | 11 +++++++----
 src/tools/miri/miri-script/src/main.rs     |  7 +++++--
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index 86f6253d4558..d469502c243f 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -80,7 +80,7 @@ fn auto_actions() -> Result<()> {
 
         // `toolchain` goes first as it could affect the others
         if auto_toolchain {
-            Self::toolchain(vec![])?;
+            Self::toolchain(None, vec![])?;
         }
         if auto_fmt {
             Self::fmt(vec![])?;
@@ -121,15 +121,18 @@ pub fn exec(self) -> Result<()> {
             Command::Clippy { features, flags } => Self::clippy(features, flags),
             Command::Bench { target, no_install, save_baseline, load_baseline, benches } =>
                 Self::bench(target, no_install, save_baseline, load_baseline, benches),
-            Command::Toolchain { flags } => Self::toolchain(flags),
+            Command::Toolchain { commit, flags } => Self::toolchain(commit, flags),
             Command::Squash => Self::squash(),
         }
     }
 
-    fn toolchain(flags: Vec<String>) -> Result<()> {
+    fn toolchain(new_commit: Option<String>, flags: Vec<String>) -> Result<()> {
         let sh = Shell::new()?;
         sh.change_dir(miri_dir()?);
-        let new_commit = sh.read_file("rust-version")?.trim().to_owned();
+        let new_commit = match new_commit {
+            Some(c) => c,
+            None => sh.read_file("rust-version")?.trim().to_owned(),
+        };
         let current_commit = {
             let rustc_info = cmd!(sh, "rustc +miri --version -v").read();
             if let Ok(rustc_info) = rustc_info {
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index e30701449688..419c128e5b72 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -138,6 +138,9 @@ pub enum Command {
     /// The `rust-version` file is used to determine the commit that will be intsalled.
     /// `rustup-toolchain-install-master` must be installed for this to work.
     Toolchain {
+        /// Overwrite the commit to install.
+        #[arg(long)]
+        commit: Option<String>,
         /// Flags that are passed through to `rustup-toolchain-install-master`.
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         flags: Vec<String>,
@@ -157,8 +160,8 @@ fn add_remainder(&mut self, remainder: Vec<String>) -> Result<()> {
             | Self::Build { flags, .. }
             | Self::Check { flags, .. }
             | Self::Doc { flags, .. }
-            | Self::Fmt { flags }
-            | Self::Toolchain { flags }
+            | Self::Fmt { flags, .. }
+            | Self::Toolchain { flags, .. }
             | Self::Clippy { flags, .. }
             | Self::Run { flags, .. }
             | Self::Test { flags, .. } => {

From 988633d72cedaf3d56bb9a77589fc08bb15b62b3 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 25 Mar 2026 12:37:03 +0100
Subject: [PATCH 0925/1059] re-enable enzyme/autodiff builds on
 dist-aarch64-apple

---
 src/ci/github-actions/jobs.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index bff0046c97cb..5909f29d52c1 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -509,7 +509,7 @@ auto:
   - name: dist-aarch64-apple
     env:
       SCRIPT: >-
-        ./x.py dist bootstrap
+        ./x.py dist bootstrap enzyme
         --include-default-paths
         --host=aarch64-apple-darwin
         --target=aarch64-apple-darwin

From 307d7152bc524539b465f9b337a2e036454102df Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 17:16:37 +0530
Subject: [PATCH 0926/1059] replace
 remove-generate-trail-impl-text-intransitive with
 generate_trait_impl_intransitive_with_item

---
 .../crates/ide-assists/src/utils.rs           | 32 ++++++-------------
 1 file changed, 9 insertions(+), 23 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index cf1c66ab5e74..96e1bbdc7ea9 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -630,29 +630,6 @@ pub(crate) fn generate_impl_text(adt: &ast::Adt, code: &str) -> String {
     generate_impl_text_inner(adt, None, true, code)
 }
 
-/// Generates the surrounding `impl <trait> for Type { <code> }` including type
-/// and lifetime parameters, with `<trait>` appended to `impl`'s generic parameters' bounds.
-///
-/// This is useful for traits like `PartialEq`, since `impl<T> PartialEq for U<T>` often requires `T: PartialEq`.
-// FIXME: migrate remaining uses to `generate_trait_impl`
-#[allow(dead_code)]
-pub(crate) fn generate_trait_impl_text(adt: &ast::Adt, trait_text: &str, code: &str) -> String {
-    generate_impl_text_inner(adt, Some(trait_text), true, code)
-}
-
-/// Generates the surrounding `impl <trait> for Type { <code> }` including type
-/// and lifetime parameters, with `impl`'s generic parameters' bounds kept as-is.
-///
-/// This is useful for traits like `From<T>`, since `impl<T> From<T> for U<T>` doesn't require `T: From<T>`.
-// FIXME: migrate remaining uses to `generate_trait_impl_intransitive`
-pub(crate) fn generate_trait_impl_text_intransitive(
-    adt: &ast::Adt,
-    trait_text: &str,
-    code: &str,
-) -> String {
-    generate_impl_text_inner(adt, Some(trait_text), false, code)
-}
-
 fn generate_impl_text_inner(
     adt: &ast::Adt,
     trait_text: Option<&str>,
@@ -773,6 +750,15 @@ pub(crate) fn generate_trait_impl_intransitive(
     generate_impl_inner_with_factory(make, false, adt, Some(trait_), false, None)
 }
 
+pub(crate) fn generate_trait_impl_intransitive_with_item(
+    make: &SyntaxFactory,
+    adt: &ast::Adt,
+    trait_: ast::Type,
+    body: ast::AssocItemList,
+) -> ast::Impl {
+    generate_impl_inner_with_factory(make, false, adt, Some(trait_), false, Some(body))
+}
+
 fn generate_impl_inner(
     is_unsafe: bool,
     adt: &ast::Adt,

From 4b978017b75c550c3a8113380e16516f4146c439 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 17:17:30 +0530
Subject: [PATCH 0927/1059] migrate generate_deref to SyntaxEditor and
 SyntaxFactory and remove usage of
 remove-generate-trail-impl-text-intransitive

---
 .../src/handlers/generate_deref.rs            | 124 +++++++++++++-----
 1 file changed, 93 insertions(+), 31 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
index 494c87e6d136..f8974e1e7eca 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
@@ -1,16 +1,15 @@
-use std::fmt::Display;
-
 use hir::{ModPath, ModuleDef};
-use ide_db::{RootDatabase, famous_defs::FamousDefs};
+use ide_db::{FileId, RootDatabase, famous_defs::FamousDefs};
 use syntax::{
-    AstNode, Edition, SyntaxNode,
-    ast::{self, HasName},
+    Edition,
+    ast::{self, AstNode, HasName, edit::AstNodeEdit, syntax_factory::SyntaxFactory},
+    syntax_editor::Position,
 };
 
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists, SourceChangeBuilder},
-    utils::generate_trait_impl_text_intransitive,
+    utils::generate_trait_impl_intransitive_with_item,
 };
 
 // Assist: generate_deref
@@ -64,6 +63,7 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
     let field_type = field.ty()?;
     let field_name = field.name()?;
     let target = field.syntax().text_range();
+    let file_id = ctx.vfs_file_id();
     acc.add(
         AssistId::generate("generate_deref"),
         format!("Generate `{deref_type_to_generate:?}` impl using `{field_name}`"),
@@ -72,9 +72,10 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
             generate_edit(
                 ctx.db(),
                 edit,
+                file_id,
                 strukt,
-                field_type.syntax(),
-                field_name.syntax(),
+                field_type,
+                &field_name.to_string(),
                 deref_type_to_generate,
                 trait_path,
                 module.krate(ctx.db()).edition(ctx.db()),
@@ -105,6 +106,7 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
 
     let field_type = field.ty()?;
     let target = field.syntax().text_range();
+    let file_id = ctx.vfs_file_id();
     acc.add(
         AssistId::generate("generate_deref"),
         format!("Generate `{deref_type_to_generate:?}` impl using `{field}`"),
@@ -113,9 +115,10 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
             generate_edit(
                 ctx.db(),
                 edit,
+                file_id,
                 strukt,
-                field_type.syntax(),
-                field_list_index,
+                field_type,
+                &field_list_index.to_string(),
                 deref_type_to_generate,
                 trait_path,
                 module.krate(ctx.db()).edition(ctx.db()),
@@ -127,35 +130,94 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
 fn generate_edit(
     db: &RootDatabase,
     edit: &mut SourceChangeBuilder,
+    file_id: FileId,
     strukt: ast::Struct,
-    field_type_syntax: &SyntaxNode,
-    field_name: impl Display,
+    field_type: ast::Type,
+    field_name: &str,
     deref_type: DerefType,
     trait_path: ModPath,
     edition: Edition,
 ) {
-    let start_offset = strukt.syntax().text_range().end();
-    let impl_code = match deref_type {
-        DerefType::Deref => format!(
-            r#"    type Target = {field_type_syntax};
+    let make = SyntaxFactory::with_mappings();
+    let strukt_adt = ast::Adt::Struct(strukt.clone());
+    let trait_ty = make.ty(&trait_path.display(db, edition).to_string());
 
-    fn deref(&self) -> &Self::Target {{
-        &self.{field_name}
-    }}"#,
-        ),
-        DerefType::DerefMut => format!(
-            r#"    fn deref_mut(&mut self) -> &mut Self::Target {{
-        &mut self.{field_name}
-    }}"#,
-        ),
+    let assoc_items: Vec<ast::AssocItem> = match deref_type {
+        DerefType::Deref => {
+            let target_alias = make.ty_alias(
+                [],
+                "Target",
+                None,
+                None,
+                None,
+                Some((field_type, None)),
+            );
+            let ret_ty =
+                make.ty_ref(make.ty_path(make.path_from_text("Self::Target")).into(), false);
+            let field_expr =
+                make.expr_field(make.expr_path(make.ident_path("self")), field_name);
+            let body =
+                make.block_expr([], Some(make.expr_ref(field_expr.into(), false)));
+            let fn_ = make
+                .fn_(
+                    [],
+                    None,
+                    make.name("deref"),
+                    None,
+                    None,
+                    make.param_list(Some(make.self_param()), []),
+                    body,
+                    Some(make.ret_type(ret_ty)),
+                    false,
+                    false,
+                    false,
+                    false,
+                )
+                .indent(1.into());
+            vec![
+                ast::AssocItem::TypeAlias(target_alias),
+                ast::AssocItem::Fn(fn_),
+            ]
+        }
+        DerefType::DerefMut => {
+            let ret_ty =
+                make.ty_ref(make.ty_path(make.path_from_text("Self::Target")).into(), true);
+            let field_expr =
+                make.expr_field(make.expr_path(make.ident_path("self")), field_name);
+            let body =
+                make.block_expr([], Some(make.expr_ref(field_expr.into(), true)));
+            let fn_ = make
+                .fn_(
+                    [],
+                    None,
+                    make.name("deref_mut"),
+                    None,
+                    None,
+                    make.param_list(Some(make.mut_self_param()), []),
+                    body,
+                    Some(make.ret_type(ret_ty)),
+                    false,
+                    false,
+                    false,
+                    false,
+                )
+                .indent(1.into());
+            vec![ast::AssocItem::Fn(fn_)]
+        }
     };
-    let strukt_adt = ast::Adt::Struct(strukt);
-    let deref_impl = generate_trait_impl_text_intransitive(
-        &strukt_adt,
-        &trait_path.display(db, edition).to_string(),
-        &impl_code,
+
+    let body = make.assoc_item_list(assoc_items);
+    let indent = strukt.indent_level();
+    let impl_ = generate_trait_impl_intransitive_with_item(&make, &strukt_adt, trait_ty, body)
+        .indent(indent);
+
+    let mut editor = edit.make_editor(strukt.syntax());
+    editor.insert_all(
+        Position::after(strukt.syntax()),
+        vec![make.whitespace(&format!("\n\n{indent}")).into(), impl_.syntax().clone().into()],
     );
-    edit.insert(start_offset, deref_impl);
+    editor.add_mappings(make.finish_with_mappings());
+    edit.add_file_edits(file_id, editor);
 }
 
 fn existing_deref_impl(

From 37153280f07ccc1df9ba109bbfaf948897578b19 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 25 Mar 2026 17:17:57 +0530
Subject: [PATCH 0928/1059] migrate generate_from_impl_for_enum to SyntaxEditor
 and SyntaxFactory and remove usage of
 remove-generate-trail-impl-text-intransitive

---
 .../src/handlers/generate_deref.rs            | 27 ++----
 .../handlers/generate_from_impl_for_enum.rs   | 82 +++++++++++++------
 2 files changed, 65 insertions(+), 44 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
index f8974e1e7eca..5534dc1cd304 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
@@ -144,20 +144,12 @@ fn generate_edit(
 
     let assoc_items: Vec<ast::AssocItem> = match deref_type {
         DerefType::Deref => {
-            let target_alias = make.ty_alias(
-                [],
-                "Target",
-                None,
-                None,
-                None,
-                Some((field_type, None)),
-            );
+            let target_alias =
+                make.ty_alias([], "Target", None, None, None, Some((field_type, None)));
             let ret_ty =
                 make.ty_ref(make.ty_path(make.path_from_text("Self::Target")).into(), false);
-            let field_expr =
-                make.expr_field(make.expr_path(make.ident_path("self")), field_name);
-            let body =
-                make.block_expr([], Some(make.expr_ref(field_expr.into(), false)));
+            let field_expr = make.expr_field(make.expr_path(make.ident_path("self")), field_name);
+            let body = make.block_expr([], Some(make.expr_ref(field_expr.into(), false)));
             let fn_ = make
                 .fn_(
                     [],
@@ -174,18 +166,13 @@ fn generate_edit(
                     false,
                 )
                 .indent(1.into());
-            vec![
-                ast::AssocItem::TypeAlias(target_alias),
-                ast::AssocItem::Fn(fn_),
-            ]
+            vec![ast::AssocItem::TypeAlias(target_alias), ast::AssocItem::Fn(fn_)]
         }
         DerefType::DerefMut => {
             let ret_ty =
                 make.ty_ref(make.ty_path(make.path_from_text("Self::Target")).into(), true);
-            let field_expr =
-                make.expr_field(make.expr_path(make.ident_path("self")), field_name);
-            let body =
-                make.block_expr([], Some(make.expr_ref(field_expr.into(), true)));
+            let field_expr = make.expr_field(make.expr_path(make.ident_path("self")), field_name);
+            let body = make.block_expr([], Some(make.expr_ref(field_expr.into(), true)));
             let fn_ = make
                 .fn_(
                     [],
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
index 24f271ded80b..1adb3f4fe49a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,10 +1,11 @@
 use hir::next_solver::{DbInterner, TypingMode};
 use ide_db::{RootDatabase, famous_defs::FamousDefs};
-use syntax::ast::{self, AstNode, HasName};
+use syntax::ast::{self, AstNode, HasName, edit::AstNodeEdit, syntax_factory::SyntaxFactory};
+use syntax::syntax_editor::Position;
 
 use crate::{
     AssistContext, AssistId, Assists,
-    utils::{generate_trait_impl_text_intransitive, is_selected},
+    utils::{generate_trait_impl_intransitive_with_item, is_selected},
 };
 
 // Assist: generate_from_impl_for_enum
@@ -33,39 +34,72 @@ pub(crate) fn generate_from_impl_for_enum(
     let variants = selected_variants(ctx, &variant)?;
 
     let target = variant.syntax().text_range();
+    let file_id = ctx.vfs_file_id();
     acc.add(
         AssistId::generate("generate_from_impl_for_enum"),
         "Generate `From` impl for this enum variant(s)",
         target,
         |edit| {
-            let start_offset = variant.parent_enum().syntax().text_range().end();
-            let from_impl = variants
-                .into_iter()
-                .map(|variant_info| {
-                    let from_trait = format!("From<{}>", variant_info.ty);
-                    let impl_code = generate_impl_code(variant_info);
-                    generate_trait_impl_text_intransitive(&adt, &from_trait, &impl_code)
-                })
-                .collect::<String>();
-            edit.insert(start_offset, from_impl);
+            let make = SyntaxFactory::with_mappings();
+            let indent = adt.indent_level();
+            let mut elements = Vec::new();
+
+            for variant_info in variants {
+                let impl_ = build_from_impl(&make, &adt, variant_info).indent(indent);
+                elements.push(make.whitespace(&format!("\n\n{indent}")).into());
+                elements.push(impl_.syntax().clone().into());
+            }
+
+            let mut editor = edit.make_editor(adt.syntax());
+            editor.insert_all(Position::after(adt.syntax()), elements);
+            editor.add_mappings(make.finish_with_mappings());
+            edit.add_file_edits(file_id, editor);
         },
     )
 }
 
-fn generate_impl_code(VariantInfo { name, field_name, ty }: VariantInfo) -> String {
-    if let Some(field) = field_name {
-        format!(
-            r#"    fn from({field}: {ty}) -> Self {{
-        Self::{name} {{ {field} }}
-    }}"#
-        )
+fn build_from_impl(make: &SyntaxFactory, adt: &ast::Adt, variant_info: VariantInfo) -> ast::Impl {
+    let VariantInfo { name, field_name, ty } = variant_info;
+    let trait_ty = make.ty(&format!("From<{ty}>"));
+    let ret_ty = make.ret_type(make.ty_path(make.ident_path("Self")).into());
+
+    let (params, body_expr) = if let Some(field) = field_name {
+        let field_str = field.to_string();
+        let param = make.param(make.ident_pat(false, false, make.name(&field_str)).into(), ty);
+        let field_item = make.record_expr_field(make.name_ref(&field_str), None);
+        let record = make.record_expr(
+            make.path_from_text(&format!("Self::{name}")),
+            make.record_expr_field_list([field_item]),
+        );
+        (make.param_list(None, [param]), ast::Expr::from(record))
     } else {
-        format!(
-            r#"    fn from(v: {ty}) -> Self {{
-        Self::{name}(v)
-    }}"#
+        let param = make.param(make.ident_pat(false, false, make.name("v")).into(), ty);
+        let call = make.expr_call(
+            make.expr_path(make.path_from_text(&format!("Self::{name}"))),
+            make.arg_list([make.expr_path(make.ident_path("v"))]),
+        );
+        (make.param_list(None, [param]), ast::Expr::from(call))
+    };
+
+    let from_fn = make
+        .fn_(
+            [],
+            None,
+            make.name("from"),
+            None,
+            None,
+            params,
+            make.block_expr([], Some(body_expr)),
+            Some(ret_ty),
+            false,
+            false,
+            false,
+            false,
         )
-    }
+        .indent(1.into());
+
+    let body = make.assoc_item_list([ast::AssocItem::Fn(from_fn)]);
+    generate_trait_impl_intransitive_with_item(make, adt, trait_ty, body)
 }
 
 struct VariantInfo {

From f8d658ab816f64cbf97b0d1e3c89fe3ee094cc1e Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 1 Mar 2026 15:42:59 +0300
Subject: [PATCH 0929/1059] core: move `Alignment` from `ptr` to `mem`

---
 .../rustc_builtin_macros/src/global_allocator.rs   |  2 +-
 compiler/rustc_data_structures/src/aligned.rs      |  3 +++
 compiler/rustc_middle/src/ty/list.rs               |  3 +++
 compiler/rustc_span/src/symbol.rs                  |  1 +
 library/alloc/src/alloc.rs                         |  3 ++-
 library/alloc/src/raw_vec/mod.rs                   |  4 ++--
 library/alloc/src/rc.rs                            |  4 ++--
 library/alloc/src/sync.rs                          |  4 ++--
 library/core/src/alloc/layout.rs                   |  4 ++--
 library/core/src/{ptr => mem}/alignment.rs         | 14 +++++++-------
 library/core/src/mem/mod.rs                        |  5 ++++-
 library/core/src/ptr/mod.rs                        |  5 +++--
 library/core/src/ptr/non_null.rs                   |  2 +-
 ...e.main.DataflowConstProp.32bit.panic-abort.diff |  4 ++--
 ....main.DataflowConstProp.32bit.panic-unwind.diff |  4 ++--
 ...e.main.DataflowConstProp.64bit.panic-abort.diff |  4 ++--
 ....main.DataflowConstProp.64bit.panic-unwind.diff |  4 ++--
 ...ult_boxed_slice.main.GVN.32bit.panic-abort.diff |  4 ++--
 ...lt_boxed_slice.main.GVN.32bit.panic-unwind.diff |  4 ++--
 ...ult_boxed_slice.main.GVN.64bit.panic-abort.diff |  4 ++--
 ...lt_boxed_slice.main.GVN.64bit.panic-unwind.diff |  4 ++--
 ...pdating_operand.test.GVN.32bit.panic-abort.diff |  2 +-
 ...pdating_operand.test.GVN.64bit.panic-abort.diff |  2 +-
 .../mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff |  8 ++++----
 ...zed.drop_bytes.PreCodegen.after.panic-abort.mir |  6 +++---
 ...ed.drop_bytes.PreCodegen.after.panic-unwind.mir |  6 +++---
 ...d.drop_generic.PreCodegen.after.panic-abort.mir |  8 ++++----
 ....drop_generic.PreCodegen.after.panic-unwind.mir |  8 ++++----
 tests/mir-opt/pre-codegen/drop_box_of_sized.rs     |  2 +-
 ...in_place.PreCodegen.after.32bit.panic-abort.mir |  8 ++++----
 ...n_place.PreCodegen.after.32bit.panic-unwind.mir |  8 ++++----
 ...in_place.PreCodegen.after.64bit.panic-abort.mir |  8 ++++----
 ...n_place.PreCodegen.after.64bit.panic-unwind.mir |  8 ++++----
 tests/mir-opt/pre-codegen/drop_boxed_slice.rs      |  2 +-
 ...nvalid_constant.main.GVN.32bit.panic-abort.diff |  6 +++---
 ...valid_constant.main.GVN.32bit.panic-unwind.diff |  6 +++---
 ...nvalid_constant.main.GVN.64bit.panic-abort.diff |  6 +++---
 ...valid_constant.main.GVN.64bit.panic-unwind.diff |  6 +++---
 tests/ui/precondition-checks/alignment.rs          |  2 +-
 tests/ui/traits/const-traits/const-traits-core.rs  |  4 ++--
 40 files changed, 102 insertions(+), 90 deletions(-)
 rename library/core/src/{ptr => mem}/alignment.rs (98%)

diff --git a/compiler/rustc_builtin_macros/src/global_allocator.rs b/compiler/rustc_builtin_macros/src/global_allocator.rs
index 1bce3c03743a..85ad8a63a54f 100644
--- a/compiler/rustc_builtin_macros/src/global_allocator.rs
+++ b/compiler/rustc_builtin_macros/src/global_allocator.rs
@@ -180,7 +180,7 @@ fn usize(&self) -> Box<Ty> {
     }
 
     fn ptr_alignment(&self) -> Box<Ty> {
-        let path = self.cx.std_path(&[sym::ptr, sym::Alignment]);
+        let path = self.cx.std_path(&[sym::mem, sym::Alignment]);
         let path = self.cx.path(self.span, path);
         self.cx.ty_path(path)
     }
diff --git a/compiler/rustc_data_structures/src/aligned.rs b/compiler/rustc_data_structures/src/aligned.rs
index bfc7556faf68..d653847f1c60 100644
--- a/compiler/rustc_data_structures/src/aligned.rs
+++ b/compiler/rustc_data_structures/src/aligned.rs
@@ -1,4 +1,7 @@
 use std::marker::PointeeSized;
+#[cfg(not(bootstrap))]
+use std::mem::Alignment;
+#[cfg(bootstrap)]
 use std::ptr::Alignment;
 
 /// Returns the ABI-required minimum alignment of a type in bytes.
diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs
index 0cf5820959ee..82c23abefce4 100644
--- a/compiler/rustc_middle/src/ty/list.rs
+++ b/compiler/rustc_middle/src/ty/list.rs
@@ -264,7 +264,10 @@ unsafe impl<H: DynSync, T: DynSync> DynSync for RawList<H, T> {}
 // Layouts of `ListSkeleton<H, T>` and `RawList<H, T>` are the same, modulo opaque tail,
 // thus aligns of `ListSkeleton<H, T>` and `RawList<H, T>` must be the same.
 unsafe impl<H, T> Aligned for RawList<H, T> {
+    #[cfg(bootstrap)]
     const ALIGN: ptr::Alignment = align_of::<ListSkeleton<H, T>>();
+    #[cfg(not(bootstrap))]
+    const ALIGN: mem::Alignment = align_of::<ListSkeleton<H, T>>();
 }
 
 /// A [`List`] that additionally stores type information inline to speed up
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 738c9b975fd0..e242a8ad35a9 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1224,6 +1224,7 @@
         maybe_uninit,
         maybe_uninit_uninit,
         maybe_uninit_zeroed,
+        mem,
         mem_align_const,
         mem_discriminant,
         mem_drop,
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index 7e09a88156a0..52f099e77255 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -5,7 +5,8 @@
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
 pub use core::alloc::*;
-use core::ptr::{self, Alignment, NonNull};
+use core::mem::Alignment;
+use core::ptr::{self, NonNull};
 use core::{cmp, hint};
 
 unsafe extern "Rust" {
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 09150259ce43..6dd4a3543a43 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -5,8 +5,8 @@
 // run the tests. See the comment there for an explanation why this is the case.
 
 use core::marker::{Destruct, PhantomData};
-use core::mem::{ManuallyDrop, MaybeUninit, SizedTypeProperties};
-use core::ptr::{self, Alignment, NonNull, Unique};
+use core::mem::{Alignment, ManuallyDrop, MaybeUninit, SizedTypeProperties};
+use core::ptr::{self, NonNull, Unique};
 use core::{cmp, hint};
 
 #[cfg(not(no_global_oom_handling))]
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index 8a651618ca83..74e48ac81c5a 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -252,7 +252,7 @@
 #[cfg(not(no_global_oom_handling))]
 use core::iter;
 use core::marker::{PhantomData, Unsize};
-use core::mem::{self, ManuallyDrop};
+use core::mem::{self, Alignment, ManuallyDrop};
 use core::num::NonZeroUsize;
 use core::ops::{CoerceUnsized, Deref, DerefMut, DerefPure, DispatchFromDyn, LegacyReceiver};
 #[cfg(not(no_global_oom_handling))]
@@ -261,7 +261,7 @@
 #[cfg(not(no_global_oom_handling))]
 use core::pin::Pin;
 use core::pin::PinCoerceUnsized;
-use core::ptr::{self, Alignment, NonNull, drop_in_place};
+use core::ptr::{self, NonNull, drop_in_place};
 #[cfg(not(no_global_oom_handling))]
 use core::slice::from_raw_parts_mut;
 use core::{borrow, fmt, hint};
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 2c9fadbb8d9e..dca881ec7f10 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -19,14 +19,14 @@
 #[cfg(not(no_global_oom_handling))]
 use core::iter;
 use core::marker::{PhantomData, Unsize};
-use core::mem::{self, ManuallyDrop};
+use core::mem::{self, Alignment, ManuallyDrop};
 use core::num::NonZeroUsize;
 use core::ops::{CoerceUnsized, Deref, DerefMut, DerefPure, DispatchFromDyn, LegacyReceiver};
 #[cfg(not(no_global_oom_handling))]
 use core::ops::{Residual, Try};
 use core::panic::{RefUnwindSafe, UnwindSafe};
 use core::pin::{Pin, PinCoerceUnsized};
-use core::ptr::{self, Alignment, NonNull};
+use core::ptr::{self, NonNull};
 #[cfg(not(no_global_oom_handling))]
 use core::slice::from_raw_parts_mut;
 use core::sync::atomic::Ordering::{Acquire, Relaxed, Release};
diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index 011a90348226..c294ac1647dc 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -6,8 +6,8 @@
 
 use crate::error::Error;
 use crate::intrinsics::{unchecked_add, unchecked_mul, unchecked_sub};
-use crate::mem::SizedTypeProperties;
-use crate::ptr::{Alignment, NonNull};
+use crate::mem::{Alignment, SizedTypeProperties};
+use crate::ptr::NonNull;
 use crate::{assert_unsafe_precondition, fmt, mem};
 
 /// Layout of a block of memory.
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/mem/alignment.rs
similarity index 98%
rename from library/core/src/ptr/alignment.rs
rename to library/core/src/mem/alignment.rs
index b106314f14d1..dd1be6f4991b 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/mem/alignment.rs
@@ -37,7 +37,7 @@ impl Alignment {
     ///
     /// ```
     /// #![feature(ptr_alignment_type)]
-    /// use std::ptr::Alignment;
+    /// use std::mem::Alignment;
     ///
     /// assert_eq!(Alignment::MIN.as_usize(), 1);
     /// ```
@@ -65,7 +65,7 @@ pub const fn of<T>() -> Self {
     ///
     /// ```
     /// #![feature(ptr_alignment_type)]
-    /// use std::ptr::Alignment;
+    /// use std::mem::Alignment;
     ///
     /// assert_eq!(Alignment::of_val(&5i32).as_usize(), 4);
     /// ```
@@ -112,14 +112,13 @@ pub const fn of_val<T: MetaSized>(val: &T) -> Self {
     ///
     /// ```
     /// #![feature(ptr_alignment_type)]
-    /// use std::ptr::Alignment;
+    /// use std::mem::Alignment;
     ///
     /// assert_eq!(unsafe { Alignment::of_val_raw(&5i32) }.as_usize(), 4);
     /// ```
     #[inline]
     #[must_use]
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-    // #[unstable(feature = "layout_for_ptr", issue = "69835")]
     pub const unsafe fn of_val_raw<T: MetaSized>(val: *const T) -> Self {
         // SAFETY: precondition propagated to the caller
         let align = unsafe { mem::align_of_val_raw(val) };
@@ -214,9 +213,10 @@ pub const fn log2(self) -> u32 {
     /// # Examples
     ///
     /// ```
-    /// #![feature(ptr_alignment_type)]
     /// #![feature(ptr_mask)]
-    /// use std::ptr::{Alignment, NonNull};
+    /// #![feature(ptr_alignment_type)]
+    /// use std::mem::Alignment;
+    /// use std::ptr::NonNull;
     ///
     /// #[repr(align(1))] struct Align1(u8);
     /// #[repr(align(2))] struct Align2(u16);
@@ -294,7 +294,7 @@ fn from(align: Alignment) -> usize {
 impl cmp::Ord for Alignment {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.as_nonzero().get().cmp(&other.as_nonzero().get())
+        self.as_nonzero().cmp(&other.as_nonzero())
     }
 }
 
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index b321908fd9e7..a987970c9bcc 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -34,9 +34,12 @@
 use crate::clone::TrivialClone;
 use crate::marker::{Destruct, DiscriminantKind};
 use crate::panic::const_assert;
-use crate::ptr::Alignment;
 use crate::{clone, cmp, fmt, hash, intrinsics, ptr};
 
+mod alignment;
+#[unstable(feature = "ptr_alignment_type", issue = "102070")]
+pub use alignment::Alignment;
+
 mod manually_drop;
 #[stable(feature = "manually_drop", since = "1.20.0")]
 pub use manually_drop::ManuallyDrop;
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 48e1e206a313..ddeb1ccc72af 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -412,9 +412,10 @@
 use crate::num::NonZero;
 use crate::{fmt, hash, intrinsics, ub_checks};
 
-mod alignment;
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-pub use alignment::Alignment;
+#[deprecated(since = "CURRENT_RUSTC_VERSION", note = "moved from `ptr` to `mem`")]
+/// Deprecated re-export of [mem::Alignment].
+pub type Alignment = mem::Alignment;
 
 mod metadata;
 #[unstable(feature = "ptr_metadata", issue = "81513")]
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 8be7d3a9ae92..10c80fe13572 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -128,7 +128,7 @@ pub const fn without_provenance(addr: NonZero<usize>) -> Self {
     #[must_use]
     #[inline]
     pub const fn dangling() -> Self {
-        let align = crate::ptr::Alignment::of::<T>();
+        let align = crate::mem::Alignment::of::<T>();
         NonNull::without_provenance(align.as_nonzero())
     }
 
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
index 91a275ee53f5..fdf44f8f7447 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
index 68b2dcc78dc8..c25899906077 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
index 3fc9369800a7..e7439c0f6ef8 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
index 0d59a279ef1c..04421123efb2 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
index 743cd95e4646..d5a4c2f4b9f5 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
index fa6a636d63cf..a7d5021915b0 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
index 556453f873f6..691ca59d1691 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
index 9a025eb85e05..a3dc08ef1802 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
@@ -17,12 +17,12 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
                   }
-                  scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                  scope 7 (inlined std::mem::Alignment::of::<[bool; 0]>) {
                   }
               }
           }
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
index 25f323061c6e..b89141623cf8 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
@@ -51,7 +51,7 @@
           StorageLive(_12);
           StorageLive(_13);
 -         _13 = boxed::box_new_uninit(const <() as std::mem::SizedTypeProperties>::LAYOUT) -> [return: bb2, unwind unreachable];
-+         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::ptr::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
++         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::mem::Alignment {{ _inner_repr_trick: mem::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
index 32fe7e2fdeb6..88fb27386218 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
@@ -51,7 +51,7 @@
           StorageLive(_12);
           StorageLive(_13);
 -         _13 = boxed::box_new_uninit(const <() as std::mem::SizedTypeProperties>::LAYOUT) -> [return: bb2, unwind unreachable];
-+         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::ptr::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
++         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::mem::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
index 86d48e6dca64..77216e7700ef 100644
--- a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
+++ b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
@@ -7,14 +7,14 @@
       let mut _2: *mut u8;
       scope 1 (inlined dangling_mut::<u8>) {
           scope 2 (inlined NonNull::<u8>::dangling) {
-              let _3: std::ptr::Alignment;
+              let _3: std::mem::Alignment;
               scope 3 {
-                  scope 5 (inlined std::ptr::Alignment::as_nonzero) {
+                  scope 5 (inlined std::mem::Alignment::as_nonzero) {
                   }
                   scope 6 (inlined NonNull::<u8>::without_provenance) {
                   }
               }
-              scope 4 (inlined std::ptr::Alignment::of::<u8>) {
+              scope 4 (inlined std::mem::Alignment::of::<u8>) {
               }
           }
           scope 7 (inlined NonNull::<u8>::as_ptr) {
@@ -34,7 +34,7 @@
           StorageLive(_3);
 -         _3 = const <u8 as std::mem::SizedTypeProperties>::ALIGNMENT;
 -         _2 = copy _3 as *mut u8 (Transmute);
-+         _3 = const std::ptr::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }};
++         _3 = const std::mem::Alignment {{ _inner_repr_trick: mem::alignment::AlignmentEnum::_Align1Shl0 }};
 +         _2 = const {0x1 as *mut u8};
           StorageDead(_3);
           StorageLive(_4);
diff --git a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-abort.mir
index 1190f7812c11..0cd241b4968e 100644
--- a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-abort.mir
@@ -48,9 +48,9 @@ fn drop_bytes(_1: *mut Box<[u8; 1024]>) -> () {
                     }
                     scope 9 (inlined size_of_val_raw::<[u8; 1024]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[u8; 1024]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[u8; 1024]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -69,7 +69,7 @@ fn drop_bytes(_1: *mut Box<[u8; 1024]>) -> () {
         StorageLive(_3);
         _2 = copy (((*_1).0: std::ptr::Unique<[u8; 1024]>).0: std::ptr::NonNull<[u8; 1024]>);
         _3 = copy _2 as std::ptr::NonNull<u8> (Transmute);
-        _4 = alloc::alloc::__rust_dealloc(move _3, const 1024_usize, const std::ptr::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }}) -> [return: bb1, unwind unreachable];
+        _4 = alloc::alloc::__rust_dealloc(move _3, const 1024_usize, const std::mem::Alignment {{ _inner_repr_trick: mem::alignment::AlignmentEnum::_Align1Shl0 }}) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
diff --git a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-unwind.mir
index 1190f7812c11..0cd241b4968e 100644
--- a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_bytes.PreCodegen.after.panic-unwind.mir
@@ -48,9 +48,9 @@ fn drop_bytes(_1: *mut Box<[u8; 1024]>) -> () {
                     }
                     scope 9 (inlined size_of_val_raw::<[u8; 1024]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[u8; 1024]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[u8; 1024]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -69,7 +69,7 @@ fn drop_bytes(_1: *mut Box<[u8; 1024]>) -> () {
         StorageLive(_3);
         _2 = copy (((*_1).0: std::ptr::Unique<[u8; 1024]>).0: std::ptr::NonNull<[u8; 1024]>);
         _3 = copy _2 as std::ptr::NonNull<u8> (Transmute);
-        _4 = alloc::alloc::__rust_dealloc(move _3, const 1024_usize, const std::ptr::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }}) -> [return: bb1, unwind unreachable];
+        _4 = alloc::alloc::__rust_dealloc(move _3, const 1024_usize, const std::mem::Alignment {{ _inner_repr_trick: mem::alignment::AlignmentEnum::_Align1Shl0 }}) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
diff --git a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-abort.mir
index b5c25035bdc4..2b7c334394e0 100644
--- a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-abort.mir
@@ -42,16 +42,16 @@ fn drop_generic(_1: *mut Box<T>) -> () {
                     }
                 }
                 scope 7 (inlined Layout::for_value_raw::<T>) {
-                    let mut _3: std::ptr::Alignment;
+                    let mut _3: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<T>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<T>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<T>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -69,7 +69,7 @@ fn drop_generic(_1: *mut Box<T>) -> () {
     bb0: {
         StorageLive(_4);
         _2 = copy (((*_1).0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>);
-        _3 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _3 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         switchInt(const <T as std::mem::SizedTypeProperties>::SIZE) -> [0: bb3, otherwise: bb1];
     }
 
diff --git a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-unwind.mir
index b5c25035bdc4..2b7c334394e0 100644
--- a/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_box_of_sized.drop_generic.PreCodegen.after.panic-unwind.mir
@@ -42,16 +42,16 @@ fn drop_generic(_1: *mut Box<T>) -> () {
                     }
                 }
                 scope 7 (inlined Layout::for_value_raw::<T>) {
-                    let mut _3: std::ptr::Alignment;
+                    let mut _3: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<T>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<T>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<T>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -69,7 +69,7 @@ fn drop_generic(_1: *mut Box<T>) -> () {
     bb0: {
         StorageLive(_4);
         _2 = copy (((*_1).0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>);
-        _3 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _3 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         switchInt(const <T as std::mem::SizedTypeProperties>::SIZE) -> [0: bb3, otherwise: bb1];
     }
 
diff --git a/tests/mir-opt/pre-codegen/drop_box_of_sized.rs b/tests/mir-opt/pre-codegen/drop_box_of_sized.rs
index 088339b15c87..3d340eb103a7 100644
--- a/tests/mir-opt/pre-codegen/drop_box_of_sized.rs
+++ b/tests/mir-opt/pre-codegen/drop_box_of_sized.rs
@@ -6,7 +6,7 @@
 // EMIT_MIR drop_box_of_sized.drop_generic.PreCodegen.after.mir
 pub unsafe fn drop_generic<T: Copy>(x: *mut Box<T>) {
     // CHECK-LABEL: fn drop_generic
-    // CHECK: [[ALIGNMENT:_.+]] = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute)
+    // CHECK: [[ALIGNMENT:_.+]] = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute)
     // CHECK: alloc::alloc::__rust_dealloc({{.+}}, const <T as std::mem::SizedTypeProperties>::SIZE, move [[ALIGNMENT]])
     std::ptr::drop_in_place(x)
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
index 3bff170fff5d..cb6a7743d578 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
@@ -46,16 +46,16 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
                     let mut _5: usize;
-                    let mut _6: std::ptr::Alignment;
+                    let mut _6: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<[T]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[T]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -82,7 +82,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb1: {
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         StorageDead(_4);
         switchInt(copy _5) -> [0: bb3, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
index 3bff170fff5d..cb6a7743d578 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
@@ -46,16 +46,16 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
                     let mut _5: usize;
-                    let mut _6: std::ptr::Alignment;
+                    let mut _6: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<[T]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[T]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -82,7 +82,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb1: {
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         StorageDead(_4);
         switchInt(copy _5) -> [0: bb3, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
index 3bff170fff5d..cb6a7743d578 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
@@ -46,16 +46,16 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
                     let mut _5: usize;
-                    let mut _6: std::ptr::Alignment;
+                    let mut _6: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<[T]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[T]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -82,7 +82,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb1: {
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         StorageDead(_4);
         switchInt(copy _5) -> [0: bb3, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
index 3bff170fff5d..cb6a7743d578 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
@@ -46,16 +46,16 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
                     let mut _5: usize;
-                    let mut _6: std::ptr::Alignment;
+                    let mut _6: std::mem::Alignment;
                     scope 8 {
                         scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
                         }
                     }
                     scope 9 (inlined size_of_val_raw::<[T]>) {
                     }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
+                    scope 10 (inlined std::mem::Alignment::of_val_raw::<[T]>) {
                         scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
+                            scope 13 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
                                 scope 14 (inlined core::ub_checks::check_language_ub) {
                                     scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
                                     }
@@ -82,7 +82,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb1: {
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
         StorageDead(_4);
         switchInt(copy _5) -> [0: bb3, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
index 9e56b310e818..8f28bc712b4b 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
@@ -9,7 +9,7 @@ pub unsafe fn generic_in_place<T: Copy>(ptr: *mut Box<[T]>) {
     // CHECK-LABEL: fn generic_in_place(_1: *mut Box<[T]>)
     // CHECK: (inlined <Box<[T]> as Drop>::drop)
     // CHECK: [[SIZE:_.+]] = std::intrinsics::size_of_val::<[T]>
-    // CHECK: [[ALIGN:_.+]] = const <T as std::mem::SizedTypeProperties>::ALIGN as std::ptr::Alignment (Transmute);
+    // CHECK: [[ALIGN:_.+]] = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
     // CHECK: = alloc::alloc::__rust_dealloc({{.+}}, move [[SIZE]], move [[ALIGN]]) ->
     std::ptr::drop_in_place(ptr)
 }
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
index b48e6fc56f43..babdc70ec0fd 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
@@ -63,7 +63,7 @@
   
       bb3: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
-+         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }};
++         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }};
           StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
@@ -73,8 +73,8 @@
           StorageLive(_7);
 -         _7 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable];
-+         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }};
-+         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
index d0e59c06ff99..2f535c61fc5a 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
@@ -64,7 +64,7 @@
   
       bb4: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
-+         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }};
++         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }};
           StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
@@ -74,8 +74,8 @@
           StorageLive(_7);
 -         _7 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb5, unwind continue];
-+         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }};
-+         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x00000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb5, unwind continue];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x00000000): mem::alignment::AlignmentEnum }} }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index 18fc4ac0d87f..139cf2116fc4 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
@@ -63,7 +63,7 @@
   
       bb3: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
-+         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
++         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
           StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
@@ -73,8 +73,8 @@
           StorageLive(_7);
 -         _7 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable];
-+         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
-+         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
index c109fe735e89..f3f671b7735d 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
@@ -64,7 +64,7 @@
   
       bb4: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
-+         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
++         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }};
           StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
@@ -74,8 +74,8 @@
           StorageLive(_7);
 -         _7 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb5, unwind continue];
-+         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
-+         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb5, unwind continue];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
diff --git a/tests/ui/precondition-checks/alignment.rs b/tests/ui/precondition-checks/alignment.rs
index 038a625bed7e..3f0eae47a157 100644
--- a/tests/ui/precondition-checks/alignment.rs
+++ b/tests/ui/precondition-checks/alignment.rs
@@ -6,6 +6,6 @@
 
 fn main() {
     unsafe {
-        std::ptr::Alignment::new_unchecked(0);
+        std::mem::Alignment::new_unchecked(0);
     }
 }
diff --git a/tests/ui/traits/const-traits/const-traits-core.rs b/tests/ui/traits/const-traits/const-traits-core.rs
index 2cafde4f5bd0..ed244c230006 100644
--- a/tests/ui/traits/const-traits/const-traits-core.rs
+++ b/tests/ui/traits/const-traits/const-traits-core.rs
@@ -36,8 +36,8 @@
 const OPT: Option<i32> = Default::default();
 // core::iter::sources::empty
 const EMPTY: std::iter::Empty<()> = Default::default();
-// core::ptr::alignment
-const ALIGNMENT: std::ptr::Alignment = Default::default();
+// core::mem::alignment
+const ALIGNMENT: std::mem::Alignment = Default::default();
 // core::slice
 const SLICE: &[()] = Default::default();
 const MUT_SLICE: &mut [()] = Default::default();

From ba1e06a7229a78425e6f8fa054c052a47d94c379 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 1 Mar 2026 15:42:59 +0300
Subject: [PATCH 0930/1059] `core::mem::Alignemnt`: rename `as_nonzero` to
 `as_nonzero_usize`

---
 .../rustc_data_structures/src/tagged_ptr.rs   |  7 ++++-
 library/alloc/src/raw_vec/mod.rs              |  2 +-
 library/core/src/alloc/layout.rs              |  2 +-
 library/core/src/mem/alignment.rs             | 28 +++++++++++++------
 library/core/src/ptr/non_null.rs              |  2 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff |  2 +-
 ....DataflowConstProp.32bit.panic-unwind.diff |  2 +-
 ...n.DataflowConstProp.64bit.panic-abort.diff |  2 +-
 ....DataflowConstProp.64bit.panic-unwind.diff |  2 +-
 ...oxed_slice.main.GVN.32bit.panic-abort.diff |  2 +-
 ...xed_slice.main.GVN.32bit.panic-unwind.diff |  2 +-
 ...oxed_slice.main.GVN.64bit.panic-abort.diff |  2 +-
 ...xed_slice.main.GVN.64bit.panic-unwind.diff |  2 +-
 .../gvn_ptr_eq_with_constant.main.GVN.diff    |  2 +-
 14 files changed, 38 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_data_structures/src/tagged_ptr.rs b/compiler/rustc_data_structures/src/tagged_ptr.rs
index 94db421f77e8..71e5e0b412e8 100644
--- a/compiler/rustc_data_structures/src/tagged_ptr.rs
+++ b/compiler/rustc_data_structures/src/tagged_ptr.rs
@@ -55,7 +55,12 @@ pub unsafe trait Tag: Copy {
 /// Returns the number of bits available for use for tags in a pointer to `T`
 /// (this is based on `T`'s alignment).
 pub const fn bits_for<T: ?Sized + Aligned>() -> u32 {
-    crate::aligned::align_of::<T>().as_nonzero().trailing_zeros()
+    let alignment = crate::aligned::align_of::<T>();
+    #[cfg(bootstrap)]
+    let alignment = alignment.as_nonzero();
+    #[cfg(not(bootstrap))]
+    let alignment = alignment.as_nonzero_usize();
+    alignment.trailing_zeros()
 }
 
 /// Returns the correct [`Tag::BITS`] constant for a set of tag values.
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 6dd4a3543a43..cabf6accf3b5 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -570,7 +570,7 @@ unsafe fn finish_grow(
 impl<A: Allocator> RawVecInner<A> {
     #[inline]
     const fn new_in(alloc: A, align: Alignment) -> Self {
-        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero()));
+        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero_usize()));
         // `cap: 0` means "unallocated". zero-sized types are ignored.
         Self { ptr, cap: ZERO_CAP, alloc }
     }
diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index c294ac1647dc..66f5310db831 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -268,7 +268,7 @@ pub const fn for_value<T: ?Sized>(t: &T) -> Self {
     #[must_use]
     #[inline]
     pub const fn dangling_ptr(&self) -> NonNull<u8> {
-        NonNull::without_provenance(self.align.as_nonzero())
+        NonNull::without_provenance(self.align.as_nonzero_usize())
     }
 
     /// Creates a layout describing the record that can hold a value
diff --git a/library/core/src/mem/alignment.rs b/library/core/src/mem/alignment.rs
index dd1be6f4991b..69a5f66ff5d2 100644
--- a/library/core/src/mem/alignment.rs
+++ b/library/core/src/mem/alignment.rs
@@ -168,16 +168,28 @@ pub const fn new(align: usize) -> Option<Self> {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     pub const fn as_usize(self) -> usize {
-        // Going through `as_nonzero` helps this be more clearly the inverse of
+        // Going through `as_nonzero_usize` helps this be more clearly the inverse of
         // `new_unchecked`, letting MIR optimizations fold it away.
 
-        self.as_nonzero().get()
+        self.as_nonzero_usize().get()
+    }
+
+    /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
+    #[unstable(feature = "ptr_alignment_type", issue = "102070")]
+    #[deprecated(
+        since = "CURRENT_RUSTC_VERSION",
+        note = "renamed to `as_nonzero_usize`",
+        suggestion = "as_nonzero_usize"
+    )]
+    #[inline]
+    pub const fn as_nonzero(self) -> NonZero<usize> {
+        self.as_nonzero_usize()
     }
 
     /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
-    pub const fn as_nonzero(self) -> NonZero<usize> {
+    pub const fn as_nonzero_usize(self) -> NonZero<usize> {
         // This transmutes directly to avoid the UbCheck in `NonZero::new_unchecked`
         // since there's no way for the user to trip that check anyway -- the
         // validity invariant of the type would have to have been broken earlier --
@@ -203,7 +215,7 @@ pub const fn as_nonzero(self) -> NonZero<usize> {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     pub const fn log2(self) -> u32 {
-        self.as_nonzero().trailing_zeros()
+        self.as_nonzero_usize().trailing_zeros()
     }
 
     /// Returns a bit mask that can be used to match this alignment.
@@ -246,7 +258,7 @@ pub(crate) const fn max(a: Self, b: Self) -> Self {
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
 impl fmt::Debug for Alignment {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?} (1 << {:?})", self.as_nonzero(), self.log2())
+        write!(f, "{:?} (1 << {:?})", self.as_nonzero_usize(), self.log2())
     }
 }
 
@@ -277,7 +289,7 @@ fn try_from(align: usize) -> Result<Alignment, Self::Error> {
 impl const From<Alignment> for NonZero<usize> {
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
-        align.as_nonzero()
+        align.as_nonzero_usize()
     }
 }
 
@@ -294,7 +306,7 @@ fn from(align: Alignment) -> usize {
 impl cmp::Ord for Alignment {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.as_nonzero().cmp(&other.as_nonzero())
+        self.as_nonzero_usize().cmp(&other.as_nonzero_usize())
     }
 }
 
@@ -310,7 +322,7 @@ fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
 impl hash::Hash for Alignment {
     #[inline]
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.as_nonzero().hash(state)
+        self.as_nonzero_usize().hash(state)
     }
 }
 
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 10c80fe13572..d4d19aa25108 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -129,7 +129,7 @@ pub const fn without_provenance(addr: NonZero<usize>) -> Self {
     #[inline]
     pub const fn dangling() -> Self {
         let align = crate::mem::Alignment::of::<T>();
-        NonNull::without_provenance(align.as_nonzero())
+        NonNull::without_provenance(align.as_nonzero_usize())
     }
 
     /// Converts an address back to a mutable pointer, picking up some previously 'exposed'
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
index fdf44f8f7447..9ac720a8912c 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
index c25899906077..4b77c9108eae 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
index e7439c0f6ef8..8e9e15eb32d7 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
index 04421123efb2..915a5bed4cb4 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
index d5a4c2f4b9f5..273fe412f80e 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
index a7d5021915b0..30beb0c9371b 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
index 691ca59d1691..b41d129c7359 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
index a3dc08ef1802..cd515b5b7cdb 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }
diff --git a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
index 77216e7700ef..d72f62fc69af 100644
--- a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
+++ b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
@@ -9,7 +9,7 @@
           scope 2 (inlined NonNull::<u8>::dangling) {
               let _3: std::mem::Alignment;
               scope 3 {
-                  scope 5 (inlined std::mem::Alignment::as_nonzero) {
+                  scope 5 (inlined std::mem::Alignment::as_nonzero_usize) {
                   }
                   scope 6 (inlined NonNull::<u8>::without_provenance) {
                   }

From 01795c3eabbeca6e2a80c02385867ec055e3b7c7 Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Tue, 24 Mar 2026 20:07:23 +0800
Subject: [PATCH 0931/1059] Init self_decl with a correct vis

---
 compiler/rustc_resolve/src/lib.rs            | 33 +++++++++++----
 tests/ui/use/pub-use-self-super-crate.rs     | 24 +++++++++++
 tests/ui/use/pub-use-self-super-crate.stderr | 43 ++++++++++++++++++++
 tests/ui/use/use-path-segment-kw.rs          |  2 +-
 4 files changed, 92 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/use/pub-use-self-super-crate.rs
 create mode 100644 tests/ui/use/pub-use-self-super-crate.stderr

diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 10aa1b4019b3..72d5cdcf1f3b 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -547,6 +547,13 @@ fn name(&self) -> Option<Symbol> {
             ModuleKind::Def(.., name) => name,
         }
     }
+
+    fn opt_def_id(&self) -> Option<DefId> {
+        match self {
+            ModuleKind::Def(_, def_id, _) => Some(*def_id),
+            _ => None,
+        }
+    }
 }
 
 /// Combination of a symbol and its macros 2.0 normalized hygiene context.
@@ -784,10 +791,7 @@ fn def_id(self) -> DefId {
     }
 
     fn opt_def_id(self) -> Option<DefId> {
-        match self.kind {
-            ModuleKind::Def(_, def_id, _) => Some(def_id),
-            _ => None,
-        }
+        self.kind.opt_def_id()
     }
 
     // `self` resolves to the first module ancestor that `is_normal`.
@@ -1450,14 +1454,19 @@ fn new_module(
         &'ra self,
         parent: Option<Module<'ra>>,
         kind: ModuleKind,
+        vis: Visibility<DefId>,
         expn_id: ExpnId,
         span: Span,
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
         let self_decl = match kind {
-            ModuleKind::Def(def_kind, def_id, _) => {
-                Some(self.new_pub_def_decl(Res::Def(def_kind, def_id), span, LocalExpnId::ROOT))
-            }
+            ModuleKind::Def(def_kind, def_id, _) => Some(self.new_def_decl(
+                Res::Def(def_kind, def_id),
+                vis,
+                span,
+                LocalExpnId::ROOT,
+                None,
+            )),
             ModuleKind::Block => None,
         };
         Module(Interned::new_unchecked(self.modules.alloc(ModuleData::new(
@@ -1639,6 +1648,7 @@ pub fn new(
         let graph_root = arenas.new_module(
             None,
             ModuleKind::Def(DefKind::Mod, root_def_id, None),
+            Visibility::Public,
             ExpnId::root(),
             crate_span,
             attr::contains_name(attrs, sym::no_implicit_prelude),
@@ -1648,6 +1658,7 @@ pub fn new(
         let empty_module = arenas.new_module(
             None,
             ModuleKind::Def(DefKind::Mod, root_def_id, None),
+            Visibility::Public,
             ExpnId::root(),
             DUMMY_SP,
             true,
@@ -1749,7 +1760,9 @@ fn new_local_module(
         span: Span,
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
-        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        let vis =
+            kind.opt_def_id().map_or(Visibility::Public, |def_id| self.tcx.visibility(def_id));
+        let module = self.arenas.new_module(parent, kind, vis, expn_id, span, no_implicit_prelude);
         self.local_modules.push(module);
         if let Some(def_id) = module.opt_def_id() {
             self.local_module_map.insert(def_id.expect_local(), module);
@@ -1765,7 +1778,9 @@ fn new_extern_module(
         span: Span,
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
-        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        let vis =
+            kind.opt_def_id().map_or(Visibility::Public, |def_id| self.tcx.visibility(def_id));
+        let module = self.arenas.new_module(parent, kind, vis, expn_id, span, no_implicit_prelude);
         self.extern_module_map.borrow_mut().insert(module.def_id(), module);
         module
     }
diff --git a/tests/ui/use/pub-use-self-super-crate.rs b/tests/ui/use/pub-use-self-super-crate.rs
new file mode 100644
index 000000000000..1a799acb50fb
--- /dev/null
+++ b/tests/ui/use/pub-use-self-super-crate.rs
@@ -0,0 +1,24 @@
+mod foo {
+    pub use self as this;
+    //~^ ERROR `self` is only public within the crate, and cannot be re-exported outside
+
+    pub mod bar {
+        pub use super as parent;
+        //~^ ERROR `super` is only public within the crate, and cannot be re-exported outside
+        pub use self::super as parent2;
+        //~^ ERROR `super` is only public within the crate, and cannot be re-exported outside
+        pub use super::{self as parent3};
+        //~^ ERROR `super` is only public within the crate, and cannot be re-exported outside
+        pub use self::{super as parent4};
+        //~^ ERROR `super` is only public within the crate, and cannot be re-exported outside
+
+        pub use crate as root;
+        pub use crate::{self as root2};
+        pub use super::super as root3;
+    }
+}
+
+pub use foo::*;
+pub use foo::bar::*;
+
+pub fn main() {}
diff --git a/tests/ui/use/pub-use-self-super-crate.stderr b/tests/ui/use/pub-use-self-super-crate.stderr
new file mode 100644
index 000000000000..3b336800a180
--- /dev/null
+++ b/tests/ui/use/pub-use-self-super-crate.stderr
@@ -0,0 +1,43 @@
+error[E0365]: `self` is only public within the crate, and cannot be re-exported outside
+  --> $DIR/pub-use-self-super-crate.rs:2:13
+   |
+LL |     pub use self as this;
+   |             ^^^^^^^^^^^^ re-export of crate public `self`
+   |
+   = note: consider declaring type or module `self` with `pub`
+
+error[E0365]: `super` is only public within the crate, and cannot be re-exported outside
+  --> $DIR/pub-use-self-super-crate.rs:6:17
+   |
+LL |         pub use super as parent;
+   |                 ^^^^^^^^^^^^^^^ re-export of crate public `super`
+   |
+   = note: consider declaring type or module `super` with `pub`
+
+error[E0365]: `super` is only public within the crate, and cannot be re-exported outside
+  --> $DIR/pub-use-self-super-crate.rs:8:17
+   |
+LL |         pub use self::super as parent2;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `super`
+   |
+   = note: consider declaring type or module `super` with `pub`
+
+error[E0365]: `super` is only public within the crate, and cannot be re-exported outside
+  --> $DIR/pub-use-self-super-crate.rs:10:25
+   |
+LL |         pub use super::{self as parent3};
+   |                         ^^^^^^^^^^^^^^^ re-export of crate public `super`
+   |
+   = note: consider declaring type or module `super` with `pub`
+
+error[E0365]: `super` is only public within the crate, and cannot be re-exported outside
+  --> $DIR/pub-use-self-super-crate.rs:12:24
+   |
+LL |         pub use self::{super as parent4};
+   |                        ^^^^^^^^^^^^^^^^ re-export of crate public `super`
+   |
+   = note: consider declaring type or module `super` with `pub`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0365`.
diff --git a/tests/ui/use/use-path-segment-kw.rs b/tests/ui/use/use-path-segment-kw.rs
index be64f239b9fc..164f645dc5c5 100644
--- a/tests/ui/use/use-path-segment-kw.rs
+++ b/tests/ui/use/use-path-segment-kw.rs
@@ -70,7 +70,7 @@ macro_rules! macro_dollar_crate {
 
 fn outer() {}
 
-mod foo {
+pub mod foo {
     pub mod bar {
         pub mod foobar {
             pub mod qux {

From c03b20d198b910394b653f950618cb283fce08bc Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sat, 24 Jan 2026 01:03:27 +0900
Subject: [PATCH 0932/1059] fix: Turn back `TyLoweringContext.store` to self
 after lowering parent defaults

---
 .../rust-analyzer/crates/hir-ty/src/lower.rs     |  4 +++-
 .../src/handlers/missing_lifetime.rs             | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 45500cfd2213..c0bd8975711f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -2411,10 +2411,11 @@ pub(crate) fn generic_defaults_with_diagnostics_query(
     }
     let resolver = def.resolver(db);
 
+    let store_for_self = generic_params.store();
     let mut ctx = TyLoweringContext::new(
         db,
         &resolver,
-        generic_params.store(),
+        store_for_self,
         def,
         LifetimeElisionKind::AnonymousReportError,
     )
@@ -2432,6 +2433,7 @@ pub(crate) fn generic_defaults_with_diagnostics_query(
         })
         .collect::<Vec<_>>();
     ctx.diagnostics.clear(); // Don't include diagnostics from the parent.
+    ctx.store = store_for_self;
     defaults.extend(generic_params.iter_self().map(|(_id, p)| {
         let (result, has_default) = handle_generic_param(&mut ctx, idx, p);
         has_any_default |= has_default;
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
index 5cb710b66b5f..b10cdaa14ee6 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
@@ -115,4 +115,20 @@ struct A<'a, T> {
         "#,
         );
     }
+
+    // FIXME: Ideally, should emit generic default forbidden as well
+    #[test]
+    fn regression_16280() {
+        check_diagnostics(
+            r#"
+trait Traitor<'a, const M: Traitor = Traitor> {
+    fn crash<const Traitor: Traitor = Traitor, const M: Traitor = Traitor>(&self) -> Traitor {
+                         // ^^^^^^^ error: missing lifetime specifier
+                                                     // ^^^^^^^ error: missing lifetime specifier
+        Traitor
+    }
+}
+"#,
+        );
+    }
 }

From ed974ae96d068c6a5be39bd2aba378b320736160 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 25 Mar 2026 22:39:42 +0800
Subject: [PATCH 0933/1059] internal: rename IndentLevel::single to zero

---
 .../src/handlers/extract_struct_from_enum_variant.rs          | 2 +-
 src/tools/rust-analyzer/crates/ide-assists/src/utils.rs       | 2 +-
 src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs         | 2 +-
 .../rust-analyzer/crates/syntax/src/ast/edit_in_place.rs      | 2 +-
 .../rust-analyzer/crates/syntax/src/syntax_editor/edits.rs    | 4 ++--
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index 386652a42292..e00a2949f2b8 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -290,7 +290,7 @@ fn create_struct_def(
             field_list.clone().into()
         }
     };
-    let field_list = field_list.indent(IndentLevel::single());
+    let field_list = field_list.indent(IndentLevel::zero());
 
     let strukt = make::struct_(enum_vis, name, generics, field_list).clone_for_update();
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index a85a89efb4a2..b976a172277d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -324,7 +324,7 @@ pub fn add_trait_assoc_items_to_impl_with_factory(
                     ExprFillDefaultMode::Underscore => make.expr_underscore().into(),
                 };
                 let new_body = make.block_expr(None::<ast::Stmt>, Some(fill_expr));
-                let new_body = AstNodeEdit::indent(&new_body, IndentLevel::single());
+                let new_body = AstNodeEdit::indent(&new_body, IndentLevel::zero());
                 let mut fn_editor = SyntaxEditor::new(fn_.syntax().clone());
                 fn_.replace_or_insert_body(&mut fn_editor, new_body);
                 let new_fn_ = fn_editor.finish().new_root().clone();
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
index 194d06900a48..b706d7f722f4 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit.rs
@@ -50,7 +50,7 @@ fn add_assign(&mut self, rhs: u8) {
 }
 
 impl IndentLevel {
-    pub fn single() -> IndentLevel {
+    pub fn zero() -> IndentLevel {
         IndentLevel(0)
     }
     pub fn is_zero(&self) -> bool {
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
index 2b7dc5cd76ab..7f59ae421382 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
@@ -591,7 +591,7 @@ pub fn add_item(&self, item: ast::AssocItem) {
                     normalize_ws_between_braces(self.syntax());
                     (IndentLevel::from_token(&l_curly) + 1, ted::Position::after(&l_curly), "\n")
                 }
-                None => (IndentLevel::single(), ted::Position::last_child_of(self.syntax()), "\n"),
+                None => (IndentLevel::zero(), ted::Position::last_child_of(self.syntax()), "\n"),
             },
         };
         let elements: Vec<SyntaxElement> = vec![
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
index ad08928923be..44f0a8038eca 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs
@@ -210,7 +210,7 @@ pub fn add_items(&self, editor: &mut SyntaxEditor, items: Vec<ast::AssocItem>) {
                     normalize_ws_between_braces(editor, self.syntax());
                     (IndentLevel::from_token(&l_curly) + 1, Position::after(&l_curly), "\n")
                 }
-                None => (IndentLevel::single(), Position::last_child_of(self.syntax()), "\n"),
+                None => (IndentLevel::zero(), Position::last_child_of(self.syntax()), "\n"),
             },
         };
 
@@ -242,7 +242,7 @@ pub fn add_variant(&self, editor: &mut SyntaxEditor, variant: &ast::Variant) {
                     normalize_ws_between_braces(editor, self.syntax());
                     (IndentLevel::from_token(&l_curly) + 1, Position::after(&l_curly))
                 }
-                None => (IndentLevel::single(), Position::last_child_of(self.syntax())),
+                None => (IndentLevel::zero(), Position::last_child_of(self.syntax())),
             },
         };
         let elements: Vec<SyntaxElement> = vec![

From 082f46a5fc305d26d1f2b03b9433abf899e1b010 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 25 Mar 2026 22:42:15 +0800
Subject: [PATCH 0934/1059] Remove redundant zero indent

---
 .../src/handlers/extract_struct_from_enum_variant.rs         | 5 +----
 src/tools/rust-analyzer/crates/ide-assists/src/utils.rs      | 1 -
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index e00a2949f2b8..cbf4e0ec28af 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -16,9 +16,7 @@
     SyntaxKind::*,
     SyntaxNode, T,
     ast::{
-        self, AstNode, HasAttrs, HasGenericParams, HasName, HasVisibility,
-        edit::{AstNodeEdit, IndentLevel},
-        make,
+        self, AstNode, HasAttrs, HasGenericParams, HasName, HasVisibility, edit::AstNodeEdit, make,
     },
     match_ast, ted,
 };
@@ -290,7 +288,6 @@ fn create_struct_def(
             field_list.clone().into()
         }
     };
-    let field_list = field_list.indent(IndentLevel::zero());
 
     let strukt = make::struct_(enum_vis, name, generics, field_list).clone_for_update();
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index b976a172277d..a6c9004ece8b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -324,7 +324,6 @@ pub fn add_trait_assoc_items_to_impl_with_factory(
                     ExprFillDefaultMode::Underscore => make.expr_underscore().into(),
                 };
                 let new_body = make.block_expr(None::<ast::Stmt>, Some(fill_expr));
-                let new_body = AstNodeEdit::indent(&new_body, IndentLevel::zero());
                 let mut fn_editor = SyntaxEditor::new(fn_.syntax().clone());
                 fn_.replace_or_insert_body(&mut fn_editor, new_body);
                 let new_fn_ = fn_editor.finish().new_root().clone();

From d0db8c29b1abc29314524ed9a412a9c1fb46f9db Mon Sep 17 00:00:00 2001
From: WhySoBad <49595640+WhySoBad@users.noreply.github.com>
Date: Mon, 23 Mar 2026 00:00:47 +0100
Subject: [PATCH 0935/1059] Add socket `getpeername` shim

---
 .../miri/src/shims/unix/foreign_items.rs      |  10 ++
 src/tools/miri/src/shims/unix/socket.rs       |  42 ++++++
 .../miri/tests/pass-dep/libc/libc-socket.rs   | 130 +++++++++++++++++-
 src/tools/miri/tests/pass/shims/socket.rs     |  20 +++
 4 files changed, 201 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index f2e16e75892e..471a91515d85 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -633,6 +633,16 @@ fn emulate_foreign_item_inner(
                 let result = this.getsockname(socket, address, address_len)?;
                 this.write_scalar(result, dest)?;
             }
+            "getpeername" => {
+                let [socket, address, address_len] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, *mut _) -> i32),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let result = this.getpeername(socket, address, address_len)?;
+                this.write_scalar(result, dest)?;
+            }
 
             // Time
             "gettimeofday" => {
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index f9b3ca479b79..8f2ab69261ce 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -620,6 +620,48 @@ fn getsockname(
             Err(e) => this.set_last_error_and_return_i32(e),
         }
     }
+
+    fn getpeername(
+        &mut self,
+        socket: &OpTy<'tcx>,
+        address: &OpTy<'tcx>,
+        address_len: &OpTy<'tcx>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let socket = this.read_scalar(socket)?.to_i32()?;
+        let address_ptr = this.read_pointer(address)?;
+        let address_len_ptr = this.read_pointer(address_len)?;
+
+        // Get the file handle
+        let Some(fd) = this.machine.fds.get(socket) else {
+            return this.set_last_error_and_return_i32(LibcError("EBADF"));
+        };
+
+        let Some(socket) = fd.downcast::<Socket>() else {
+            // Man page specifies to return ENOTSOCK if `fd` is not a socket.
+            return this.set_last_error_and_return_i32(LibcError("ENOTSOCK"));
+        };
+
+        assert!(this.machine.communicate(), "cannot have `Socket` with isolation enabled!");
+
+        let state = socket.state.borrow();
+
+        let SocketState::Connected(stream) = &*state else {
+            // We can only read the peer address of connected sockets.
+            return this.set_last_error_and_return_i32(LibcError("ENOTCONN"));
+        };
+
+        let address = match stream.peer_addr() {
+            Ok(address) => address,
+            Err(e) => return this.set_last_error_and_return_i32(e),
+        };
+
+        match this.write_socket_address(&address, address_ptr, address_len_ptr, "getpeername")? {
+            Ok(_) => interp_ok(Scalar::from_i32(0)),
+            Err(e) => this.set_last_error_and_return_i32(e),
+        }
+    }
 }
 
 impl<'tcx> EvalContextPrivExt<'tcx> for crate::MiriInterpCx<'tcx> {}
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
index e3c14e60b25e..8dd00e60200a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socket.rs
@@ -38,6 +38,9 @@ fn main() {
     test_getsockname_ipv4_random_port();
     test_getsockname_ipv4_unbound();
     test_getsockname_ipv6();
+
+    test_getpeername_ipv4();
+    test_getpeername_ipv6();
 }
 
 fn test_socket_close() {
@@ -183,7 +186,6 @@ fn test_listen() {
 /// - Connecting when the server is already accepting
 /// - Accepting when there is already an incoming connection
 fn test_accept_connect() {
-    // Create a new non-blocking server socket.
     let server_sockfd =
         unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
     let client_sockfd =
@@ -379,6 +381,132 @@ fn test_getsockname_ipv6() {
     assert_eq!(addr.sin6_addr.s6_addr, sock_addr.sin6_addr.s6_addr);
 }
 
+/// Test the `getpeername` syscall on an IPv4 socket.
+/// For a connected socket, the `getpeername` syscall should
+/// return the same address as the socket was connected to.
+fn test_getpeername_ipv4() {
+    let server_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let client_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv4_sock_addr(net::IPV4_LOCALHOST, 0);
+    unsafe {
+        errno_check(libc::bind(
+            server_sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    unsafe {
+        errno_check(libc::listen(server_sockfd, 16));
+    }
+
+    // Retrieve actual listener address because we used a randomized port.
+    let (_, server_addr) =
+        sockname(|storage, len| unsafe { libc::getsockname(server_sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V4(addr) = server_addr else {
+        // We bound an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+
+    // Spawn the server thread.
+    let server_thread = thread::spawn(move || {
+        let (_peerfd, _peer_addr) =
+            sockname(|storage, len| unsafe { libc::accept(server_sockfd, storage, len) }).unwrap();
+    });
+
+    // Test connecting to an already accepting server.
+    unsafe {
+        errno_check(libc::connect(
+            client_sockfd,
+            (&addr as *const libc::sockaddr_in).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in>() as libc::socklen_t,
+        ));
+    }
+
+    let (_, peer_addr) =
+        sockname(|storage, len| unsafe { libc::getpeername(client_sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V4(peer_addr) = peer_addr else {
+        // We connected to an IPv4 address so we also expect
+        // an IPv4 address to be returned.
+        panic!()
+    };
+
+    assert_eq!(addr.sin_family, peer_addr.sin_family);
+    assert_eq!(addr.sin_port, peer_addr.sin_port);
+    assert_eq!(addr.sin_addr.s_addr, peer_addr.sin_addr.s_addr);
+
+    server_thread.join().unwrap();
+}
+
+/// Test the `getpeername` syscall on an IPv6 socket.
+/// For a connected socket, the `getpeername` syscall should
+/// return the same address as the socket was connected to.
+fn test_getpeername_ipv6() {
+    let server_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET6, libc::SOCK_STREAM, 0)).unwrap() };
+    let client_sockfd =
+        unsafe { errno_result(libc::socket(libc::AF_INET6, libc::SOCK_STREAM, 0)).unwrap() };
+    let addr = net::ipv6_sock_addr(net::IPV6_LOCALHOST, 0);
+    unsafe {
+        errno_check(libc::bind(
+            server_sockfd,
+            (&addr as *const libc::sockaddr_in6).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in6>() as libc::socklen_t,
+        ));
+    }
+
+    unsafe {
+        errno_check(libc::listen(server_sockfd, 16));
+    }
+
+    // Retrieve actual listener address because we used a randomized port.
+    let (_, server_addr) =
+        sockname(|storage, len| unsafe { libc::getsockname(server_sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V6(addr) = server_addr else {
+        // We bound an IPv6 address so we also expect
+        // an IPv6 address to be returned.
+        panic!()
+    };
+
+    // Spawn the server thread.
+    let server_thread = thread::spawn(move || {
+        let (_peerfd, _peer_addr) =
+            sockname(|storage, len| unsafe { libc::accept(server_sockfd, storage, len) }).unwrap();
+    });
+
+    // Test connecting to an already accepting server.
+    unsafe {
+        errno_check(libc::connect(
+            client_sockfd,
+            (&addr as *const libc::sockaddr_in6).cast::<libc::sockaddr>(),
+            size_of::<libc::sockaddr_in6>() as libc::socklen_t,
+        ));
+    }
+
+    let (_, peer_addr) =
+        sockname(|storage, len| unsafe { libc::getpeername(client_sockfd, storage, len) }).unwrap();
+
+    let LibcSocketAddr::V6(peer_addr) = peer_addr else {
+        // We connected to an IPv6 address so we also expect
+        // an IPv6 address to be returned.
+        panic!()
+    };
+
+    assert_eq!(addr.sin6_family, peer_addr.sin6_family);
+    assert_eq!(addr.sin6_port, peer_addr.sin6_port);
+    assert_eq!(addr.sin6_flowinfo, peer_addr.sin6_flowinfo);
+    assert_eq!(addr.sin6_scope_id, peer_addr.sin6_scope_id);
+    assert_eq!(addr.sin6_addr.s6_addr, peer_addr.sin6_addr.s6_addr);
+
+    server_thread.join().unwrap();
+}
+
 /// Set a socket option. It's the caller's responsibility to ensure that `T` is
 /// associated with the given socket option.
 ///
diff --git a/src/tools/miri/tests/pass/shims/socket.rs b/src/tools/miri/tests/pass/shims/socket.rs
index 2e63e00c67d9..852397a35691 100644
--- a/src/tools/miri/tests/pass/shims/socket.rs
+++ b/src/tools/miri/tests/pass/shims/socket.rs
@@ -8,6 +8,7 @@ fn main() {
     test_create_ipv4_listener();
     test_create_ipv6_listener();
     test_accept_and_connect();
+    test_peer_addr();
 }
 
 fn test_create_ipv4_listener() {
@@ -34,3 +35,22 @@ fn test_accept_and_connect() {
 
     handle.join().unwrap();
 }
+
+/// Test whether the [`TcpStream::peer_addr`] of a connected socket
+/// is the same address as the one the stream was connected to.
+fn test_peer_addr() {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    // Get local address with randomized port to know where
+    // we need to connect to.
+    let address = listener.local_addr().unwrap();
+
+    let handle = thread::spawn(move || {
+        let (_stream, _addr) = listener.accept().unwrap();
+    });
+
+    let stream = TcpStream::connect(address).unwrap();
+    let peer_addr = stream.peer_addr().unwrap();
+    assert_eq!(address, peer_addr);
+
+    handle.join().unwrap();
+}

From f7b3e88947e8d24272622a15b0ea690ef918c3d7 Mon Sep 17 00:00:00 2001
From: ujjwalVishwakarma2006 <2023ucs0116@iitjammu.ac.in>
Date: Thu, 26 Mar 2026 01:50:12 +0530
Subject: [PATCH 0936/1059] Rename two test files

---
 tests/ui/{issues/issue-17734.rs => codegen/box-str-drop-glue.rs}  | 0
 .../issue-4735.rs => drop/drop-noncopyable-raw-pointer.rs}        | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/issue-17734.rs => codegen/box-str-drop-glue.rs} (100%)
 rename tests/ui/{issues/issue-4735.rs => drop/drop-noncopyable-raw-pointer.rs} (100%)

diff --git a/tests/ui/issues/issue-17734.rs b/tests/ui/codegen/box-str-drop-glue.rs
similarity index 100%
rename from tests/ui/issues/issue-17734.rs
rename to tests/ui/codegen/box-str-drop-glue.rs
diff --git a/tests/ui/issues/issue-4735.rs b/tests/ui/drop/drop-noncopyable-raw-pointer.rs
similarity index 100%
rename from tests/ui/issues/issue-4735.rs
rename to tests/ui/drop/drop-noncopyable-raw-pointer.rs

From ff29b410544eb6c56cf9ae0fa36125417aa77407 Mon Sep 17 00:00:00 2001
From: ujjwalVishwakarma2006 <2023ucs0116@iitjammu.ac.in>
Date: Thu, 26 Mar 2026 03:12:06 +0530
Subject: [PATCH 0937/1059] Add issue link at the top in files
 tests/ui/codegen/box-str-drop-glue.rs and
 tests/ui/drop/drop-noncopyable-raw-pointer.rs

---
 tests/ui/codegen/box-str-drop-glue.rs         | 1 +
 tests/ui/drop/drop-noncopyable-raw-pointer.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tests/ui/codegen/box-str-drop-glue.rs b/tests/ui/codegen/box-str-drop-glue.rs
index 984adeece6de..6a25db722af7 100644
--- a/tests/ui/codegen/box-str-drop-glue.rs
+++ b/tests/ui/codegen/box-str-drop-glue.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/17734>
 //@ run-pass
 // Test that generating drop glue for Box<str> doesn't ICE
 
diff --git a/tests/ui/drop/drop-noncopyable-raw-pointer.rs b/tests/ui/drop/drop-noncopyable-raw-pointer.rs
index 1ca145bae420..8e980a23c904 100644
--- a/tests/ui/drop/drop-noncopyable-raw-pointer.rs
+++ b/tests/ui/drop/drop-noncopyable-raw-pointer.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/4735>
 //@ run-pass
 
 use std::mem::transmute;

From 39fd61e2260abcded8a1c92eeab3130e4ca6143e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 25 Mar 2026 21:46:53 +0000
Subject: [PATCH 0938/1059] Bump picomatch in /editors/code

Bumps  and [picomatch](https://github.com/micromatch/picomatch). These dependencies needed to be updated together.

Updates `picomatch` from 2.3.1 to 2.3.2
- [Release notes](https://github.com/micromatch/picomatch/releases)
- [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md)
- [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2)

Updates `picomatch` from 4.0.2 to 4.0.4
- [Release notes](https://github.com/micromatch/picomatch/releases)
- [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md)
- [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2)

---
updated-dependencies:
- dependency-name: picomatch
  dependency-version: 2.3.2
  dependency-type: indirect
- dependency-name: picomatch
  dependency-version: 4.0.4
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .../rust-analyzer/editors/code/package-lock.json     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 047dbba11fcf..06bc64789b6d 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -4822,9 +4822,9 @@
             }
         },
         "node_modules/micromatch/node_modules/picomatch": {
-            "version": "2.3.1",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-            "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+            "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
             "dev": true,
             "license": "MIT",
             "engines": {
@@ -5463,9 +5463,9 @@
             "license": "ISC"
         },
         "node_modules/picomatch": {
-            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-            "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+            "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
             "dev": true,
             "license": "MIT",
             "engines": {

From f5aa518a770538aa0fe14b6788aa63c6f511c626 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Sun, 22 Mar 2026 22:40:04 +0100
Subject: [PATCH 0939/1059] Ensure `ErasedData` only implements appropriate
 auto traits

---
 compiler/rustc_errors/src/decorate_diag.rs | 15 ++++++++++----
 compiler/rustc_errors/src/diagnostic.rs    |  6 ++++--
 compiler/rustc_middle/src/query/erase.rs   | 24 ++++++++++++++++------
 compiler/rustc_session/src/parse.rs        |  4 ++--
 4 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_errors/src/decorate_diag.rs b/compiler/rustc_errors/src/decorate_diag.rs
index c7e0d508c173..61dd8f0493f9 100644
--- a/compiler/rustc_errors/src/decorate_diag.rs
+++ b/compiler/rustc_errors/src/decorate_diag.rs
@@ -1,7 +1,7 @@
 /// This module provides types and traits for buffering lints until later in compilation.
 use rustc_ast::node_id::NodeId;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::sync::DynSend;
+use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_error_messages::MultiSpan;
 use rustc_lint_defs::{BuiltinLintDiag, Lint, LintId};
 
@@ -10,7 +10,14 @@
 /// We can't implement `Diagnostic` for `BuiltinLintDiag`, because decorating some of its
 /// variants requires types we don't have yet. So, handle that case separately.
 pub enum DecorateDiagCompat {
-    Dynamic(Box<dyn for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static>),
+    Dynamic(
+        Box<
+            dyn for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()>
+                + DynSync
+                + DynSend
+                + 'static,
+        >,
+    ),
     Builtin(BuiltinLintDiag),
 }
 
@@ -20,7 +27,7 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     }
 }
 
-impl<D: for<'a> Diagnostic<'a, ()> + DynSend + 'static> From<D> for DecorateDiagCompat {
+impl<D: for<'a> Diagnostic<'a, ()> + DynSync + DynSend + 'static> From<D> for DecorateDiagCompat {
     #[inline]
     fn from(d: D) -> Self {
         Self::Dynamic(Box::new(|dcx, level| d.into_diag(dcx, level)))
@@ -83,7 +90,7 @@ pub fn buffer_lint(
     }
 
     pub fn dyn_buffer_lint<
-        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
+        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSync + DynSend + 'static,
     >(
         &mut self,
         lint: &'static Lint,
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index ceb76254e03f..9525a45d55f1 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -7,7 +7,7 @@
 use std::path::PathBuf;
 use std::thread::panicking;
 
-use rustc_data_structures::sync::DynSend;
+use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_error_messages::{DiagArgMap, DiagArgName, DiagArgValue, IntoDiagArg};
 use rustc_lint_defs::{Applicability, LintExpectationId};
 use rustc_macros::{Decodable, Encodable};
@@ -120,7 +120,9 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
 }
 
 impl<'a> Diagnostic<'a, ()>
-    for Box<dyn for<'b> FnOnce(DiagCtxtHandle<'b>, Level) -> Diag<'b, ()> + DynSend + 'static>
+    for Box<
+        dyn for<'b> FnOnce(DiagCtxtHandle<'b>, Level) -> Diag<'b, ()> + DynSync + DynSend + 'static,
+    >
 {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         self(dcx, level)
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 53ec0584ae59..81c3c7baa07a 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -7,24 +7,37 @@
 
 use std::ffi::OsStr;
 use std::intrinsics::transmute_unchecked;
+use std::marker::PhantomData;
 use std::mem::MaybeUninit;
 
 use rustc_ast::tokenstream::TokenStream;
 use rustc_data_structures::steal::Steal;
+use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_span::{ErrorGuaranteed, Spanned};
 
 use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
 use crate::ty::{self, Ty, TyCtxt};
 use crate::{mir, thir, traits};
 
+unsafe extern "C" {
+    type NoAutoTraits;
+}
+
 /// Internal implementation detail of [`Erased`].
 #[derive(Copy, Clone)]
 pub struct ErasedData<Storage: Copy> {
     /// We use `MaybeUninit` here to make sure it's legal to store a transmuted
     /// value that isn't actually of type `Storage`.
     data: MaybeUninit<Storage>,
+    /// `Storage` is an erased type, so we use an external type here to opt-out of auto traits
+    /// as those would be incorrect.
+    no_auto_traits: PhantomData<NoAutoTraits>,
 }
 
+// SAFETY: The bounds on `erase_val` ensure the types we erase are `DynSync` and `DynSend`
+unsafe impl<Storage: Copy> DynSync for ErasedData<Storage> {}
+unsafe impl<Storage: Copy> DynSend for ErasedData<Storage> {}
+
 /// Trait for types that can be erased into [`Erased<Self>`].
 ///
 /// Erasing and unerasing values is performed by [`erase_val`] and [`restore_val`].
@@ -54,13 +67,11 @@ pub trait Erasable: Copy {
 ///
 /// `Erased<T>` and `Erased<U>` are type-checked as distinct types, but codegen
 /// can see whether they actually have the same storage type.
-///
-/// FIXME: This might have soundness issues with erasable types that don't
-/// implement the same auto-traits as `[u8; _]`; see
-/// <https://github.com/rust-lang/rust/pull/151715#discussion_r2740113250>
 #[inline(always)]
 #[define_opaque(Erased)]
-pub fn erase_val<T: Erasable>(value: T) -> Erased<T> {
+// The `DynSend` and `DynSync` bounds on `T` are used to
+// justify the safety of the implementations of these traits for `ErasedData`.
+pub fn erase_val<T: Erasable + DynSend + DynSync>(value: T) -> Erased<T> {
     // Ensure the sizes match
     const {
         if size_of::<T>() != size_of::<T::Storage>() {
@@ -78,6 +89,7 @@ pub fn erase_val<T: Erasable>(value: T) -> Erased<T> {
         //
         // SAFETY: It is safe to transmute to MaybeUninit for types with the same sizes.
         data: unsafe { transmute_unchecked::<T, MaybeUninit<T::Storage>>(value) },
+        no_auto_traits: PhantomData,
     }
 }
 
@@ -88,7 +100,7 @@ pub fn erase_val<T: Erasable>(value: T) -> Erased<T> {
 #[inline(always)]
 #[define_opaque(Erased)]
 pub fn restore_val<T: Erasable>(erased_value: Erased<T>) -> T {
-    let ErasedData { data }: ErasedData<<T as Erasable>::Storage> = erased_value;
+    let ErasedData { data, .. }: ErasedData<<T as Erasable>::Storage> = erased_value;
     // See comment in `erase_val` for why we use `transmute_unchecked`.
     //
     // SAFETY: Due to the use of impl Trait in `Erased` the only way to safely create an instance
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index a8210f2315f1..65a15dba4287 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -7,7 +7,7 @@
 use rustc_ast::attr::AttrIdGenerator;
 use rustc_ast::node_id::NodeId;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
-use rustc_data_structures::sync::{AppendOnlyVec, DynSend, Lock};
+use rustc_data_structures::sync::{AppendOnlyVec, DynSend, DynSync, Lock};
 use rustc_errors::annotate_snippet_emitter_writer::AnnotateSnippetEmitter;
 use rustc_errors::emitter::{EmitterWithNote, stderr_destination};
 use rustc_errors::{
@@ -332,7 +332,7 @@ pub fn buffer_lint(
     }
 
     pub fn dyn_buffer_lint<
-        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + 'static,
+        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSync + DynSend + 'static,
     >(
         &self,
         lint: &'static Lint,

From bf5fe9fdd37268f78c6ded7c00ac51d1e8d41f03 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 26 Mar 2026 07:42:31 +0800
Subject: [PATCH 0940/1059] Add slice default implement in minicore

---
 .../rust-analyzer/crates/test-utils/src/minicore.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index c34475bbdf01..86fb08073253 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -1503,6 +1503,19 @@ pub fn len(&self) -> usize {
             loop {}
         }
     }
+
+    // region:default
+    impl<T> const Default for &[T] {
+        fn default() -> Self {
+            &[]
+        }
+    }
+    impl<T> const Default for &mut [T] {
+        fn default() -> Self {
+            &mut []
+        }
+    }
+    // endregion:default
 }
 // endregion:slice
 

From ecdb237fd5423452c80f926d32311fc6afda829d Mon Sep 17 00:00:00 2001
From: Weixie Cui <cuiweixie@gmail.com>
Date: Thu, 26 Mar 2026 09:56:37 +0800
Subject: [PATCH 0941/1059] fix: Correct type_or_const param index bound in
 debug_assert

local_id is used as an index into type/const params; valid indices are
0..len_type_or_consts(). The previous <= check incorrectly allowed idx == len.

Assisted by an AI coding tool (see CONTRIBUTING.md).
---
 src/tools/rust-analyzer/crates/hir-ty/src/generics.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index b1500bcdb756..b3c888da8e95 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -185,7 +185,7 @@ fn find_type_or_const_param(&self, param: TypeOrConstParamId) -> Option<usize> {
         if param.parent == self.def {
             let idx = param.local_id.into_raw().into_u32() as usize;
             debug_assert!(
-                idx <= self.params.len_type_or_consts(),
+                idx < self.params.len_type_or_consts(),
                 "idx: {} len: {}",
                 idx,
                 self.params.len_type_or_consts()

From 99e378390fd7b3f5f20af8d1dbdc55a1914a0aa1 Mon Sep 17 00:00:00 2001
From: Weixie Cui <cuiweixie@gmail.com>
Date: Thu, 26 Mar 2026 09:58:04 +0800
Subject: [PATCH 0942/1059] fix: Correct internal error message for
 ptr_guaranteed_cmp shim

The missing-args branch reused the wrapping_add error string.

Assisted by an AI coding tool (see CONTRIBUTING.md).
---
 src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index a0dd3b5846f4..86d951060140 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -843,7 +843,7 @@ fn exec_intrinsic(
                 // cases.
                 let [lhs, rhs] = args else {
                     return Err(MirEvalError::InternalError(
-                        "wrapping_add args are not provided".into(),
+                        "ptr_guaranteed_cmp args are not provided".into(),
                     ));
                 };
                 let ans = lhs.get(self)? == rhs.get(self)?;

From a7331929804d44db4ec13206477f3a2df558b891 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 25 Mar 2026 06:58:13 +1100
Subject: [PATCH 0943/1059] Make `rustc_hir_analysis` not depend on
 `rustc_lint`.

`rustc_hir_analysis` depends on `rustc_lint` in just a single function:
`emit_delayed_lint`, which is used by the
"emit_ast_lowering_delayed_lints" checking section within
`rustc_hir_analysis::check_crate`.

This commit moves that function and section to out of
`rustc_hir_analysis::check_crate`, into `rustc_interface`, eliminating
the dependency. This seems reasonable because the delayed lint errors
aren't really related to HIR analysis. They were in there just because
HIR analysis follows AST lowering.

This means `rustc_hir_analysis` and `rustc_lint` can both start
compiling as soon as `rustc_trait_selection` finishes. This also changes
the error order in one test, which doesn't matter.

The commit also changes `emit_delayed_lint` to `emit_delayed_lints`,
factoring out some code duplicated in rustdoc.
---
 Cargo.lock                                    |  1 -
 compiler/rustc_hir_analysis/Cargo.toml        |  1 -
 compiler/rustc_hir_analysis/src/lib.rs        | 55 -------------------
 compiler/rustc_interface/src/passes.rs        | 54 +++++++++++++++++-
 src/librustdoc/lib.rs                         |  8 +--
 .../inline-trait-and-foreign-items.stderr     | 16 +++---
 6 files changed, 62 insertions(+), 73 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 85997e1886f1..91daa229a95e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4021,7 +4021,6 @@ dependencies = [
  "rustc_hir",
  "rustc_index",
  "rustc_infer",
- "rustc_lint",
  "rustc_lint_defs",
  "rustc_macros",
  "rustc_middle",
diff --git a/compiler/rustc_hir_analysis/Cargo.toml b/compiler/rustc_hir_analysis/Cargo.toml
index 0ce93561ddd4..0dbd4333ed3c 100644
--- a/compiler/rustc_hir_analysis/Cargo.toml
+++ b/compiler/rustc_hir_analysis/Cargo.toml
@@ -19,7 +19,6 @@ rustc_feature = { path = "../rustc_feature" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }
-rustc_lint = { path = "../rustc_lint" }
 rustc_lint_defs = { path = "../rustc_lint_defs" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 0e8bc9ad5822..937bcee01161 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -85,8 +85,6 @@
 use rustc_abi::{CVariadicStatus, ExternAbi};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
-use rustc_hir::lints::DelayedLint;
-use rustc_lint::DecorateAttrLint;
 use rustc_middle::mir::interpret::GlobalId;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{Const, Ty, TyCtxt};
@@ -147,23 +145,6 @@ pub fn provide(providers: &mut Providers) {
     };
 }
 
-pub fn emit_delayed_lint(lint: &DelayedLint, tcx: TyCtxt<'_>) {
-    match lint {
-        DelayedLint::AttributeParsing(attribute_lint) => {
-            tcx.emit_node_span_lint(
-                attribute_lint.lint_id.lint,
-                attribute_lint.id,
-                attribute_lint.span,
-                DecorateAttrLint {
-                    sess: tcx.sess,
-                    tcx: Some(tcx),
-                    diagnostic: &attribute_lint.kind,
-                },
-            );
-        }
-    }
-}
-
 pub fn check_crate(tcx: TyCtxt<'_>) {
     let _prof_timer = tcx.sess.timer("type_check_crate");
 
@@ -182,42 +163,6 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
         let _: R = tcx.ensure_result().crate_inherent_impls_overlap_check(());
     });
 
-    tcx.sess.time("emit_ast_lowering_delayed_lints", || {
-        // sanity check in debug mode that all lints are really noticed
-        // and we really will emit them all in the loop right below.
-        //
-        // during ast lowering, when creating items, foreign items, trait items and impl items
-        // we store in them whether they have any lints in their owner node that should be
-        // picked up by `hir_crate_items`. However, theoretically code can run between that
-        // boolean being inserted into the item and the owner node being created.
-        // We don't want any new lints to be emitted there
-        // (though honestly, you have to really try to manage to do that but still),
-        // but this check is there to catch that.
-        #[cfg(debug_assertions)]
-        {
-            // iterate over all owners
-            for owner_id in tcx.hir_crate_items(()).owners() {
-                // if it has delayed lints
-                if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
-                    if !delayed_lints.lints.is_empty() {
-                        // assert that delayed_lint_items also picked up this item to have lints
-                        assert!(
-                            tcx.hir_crate_items(()).delayed_lint_items().any(|i| i == owner_id)
-                        );
-                    }
-                }
-            }
-        }
-
-        for owner_id in tcx.hir_crate_items(()).delayed_lint_items() {
-            if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
-                for lint in &delayed_lints.lints {
-                    emit_delayed_lint(lint, tcx);
-                }
-            }
-        }
-    });
-
     tcx.par_hir_body_owners(|item_def_id| {
         let def_kind = tcx.def_kind(item_def_id);
         // Make sure we evaluate all static and (non-associated) const items, even if unused.
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 6b7f31521d44..d7d4f00578d1 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -21,9 +21,12 @@
 use rustc_hir::def_id::{LOCAL_CRATE, StableCrateId, StableCrateIdMap};
 use rustc_hir::definitions::Definitions;
 use rustc_hir::limit::Limit;
+use rustc_hir::lints::DelayedLint;
 use rustc_hir::{Attribute, MaybeOwner, find_attr};
 use rustc_incremental::setup_dep_graph;
-use rustc_lint::{BufferedEarlyLint, EarlyCheckNode, LintStore, unerased_lint_store};
+use rustc_lint::{
+    BufferedEarlyLint, DecorateAttrLint, EarlyCheckNode, LintStore, unerased_lint_store,
+};
 use rustc_metadata::EncodedMetadata;
 use rustc_metadata::creader::CStore;
 use rustc_middle::arena::Arena;
@@ -1025,6 +1028,29 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
     )
 }
 
+pub fn emit_delayed_lints(tcx: TyCtxt<'_>) {
+    for owner_id in tcx.hir_crate_items(()).delayed_lint_items() {
+        if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
+            for lint in &delayed_lints.lints {
+                match lint {
+                    DelayedLint::AttributeParsing(attribute_lint) => {
+                        tcx.emit_node_span_lint(
+                            attribute_lint.lint_id.lint,
+                            attribute_lint.id,
+                            attribute_lint.span,
+                            DecorateAttrLint {
+                                sess: tcx.sess,
+                                tcx: Some(tcx),
+                                diagnostic: &attribute_lint.kind,
+                            },
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// Runs all analyses that we guarantee to run, even if errors were reported in earlier analyses.
 /// This function never fails.
 fn run_required_analyses(tcx: TyCtxt<'_>) {
@@ -1074,6 +1100,32 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
         ]);
     });
 
+    sess.time("emit_ast_lowering_delayed_lints", || {
+        // Sanity check in debug mode that all lints are really noticed and we really will emit
+        // them all in the loop right below.
+        //
+        // During ast lowering, when creating items, foreign items, trait items and impl items,
+        // we store in them whether they have any lints in their owner node that should be
+        // picked up by `hir_crate_items`. However, theoretically code can run between that
+        // boolean being inserted into the item and the owner node being created. We don't want
+        // any new lints to be emitted there (you have to really try to manage that but still),
+        // but this check is there to catch that.
+        #[cfg(debug_assertions)]
+        {
+            let hir_items = tcx.hir_crate_items(());
+            for owner_id in hir_items.owners() {
+                if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
+                    if !delayed_lints.lints.is_empty() {
+                        // Assert that delayed_lint_items also picked up this item to have lints.
+                        assert!(hir_items.delayed_lint_items().any(|i| i == owner_id));
+                    }
+                }
+            }
+        }
+
+        emit_delayed_lints(tcx);
+    });
+
     rustc_hir_analysis::check_crate(tcx);
     // Freeze definitions as we don't add new ones at this point.
     // We need to wait until now since we synthesize a by-move body
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 6718505bdefd..751db71ceff0 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -904,13 +904,7 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
                 return;
             }
 
-            for owner_id in tcx.hir_crate_items(()).delayed_lint_items() {
-                if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
-                    for lint in &delayed_lints.lints {
-                        rustc_hir_analysis::emit_delayed_lint(lint, tcx);
-                    }
-                }
-            }
+            rustc_interface::passes::emit_delayed_lints(tcx);
 
             if render_opts.dep_info().is_some() {
                 rustc_interface::passes::write_dep_info(tcx);
diff --git a/tests/ui/lint/inline-trait-and-foreign-items.stderr b/tests/ui/lint/inline-trait-and-foreign-items.stderr
index 4bde4bc590aa..b12fa4d9c47f 100644
--- a/tests/ui/lint/inline-trait-and-foreign-items.stderr
+++ b/tests/ui/lint/inline-trait-and-foreign-items.stderr
@@ -38,14 +38,6 @@ LL |     #[inline]
    |
    = help: `#[inline]` can only be applied to functions
 
-error: unconstrained opaque type
-  --> $DIR/inline-trait-and-foreign-items.rs:26:14
-   |
-LL |     type U = impl Trait;
-   |              ^^^^^^^^^^
-   |
-   = note: `U` must be used in combination with a concrete type within the same impl
-
 warning: `#[inline]` attribute cannot be used on associated consts
   --> $DIR/inline-trait-and-foreign-items.rs:7:5
    |
@@ -69,5 +61,13 @@ LL |     #[inline]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[inline]` can only be applied to functions
 
+error: unconstrained opaque type
+  --> $DIR/inline-trait-and-foreign-items.rs:26:14
+   |
+LL |     type U = impl Trait;
+   |              ^^^^^^^^^^
+   |
+   = note: `U` must be used in combination with a concrete type within the same impl
+
 error: aborting due to 6 previous errors; 2 warnings emitted
 

From 16b9fddf001a7f024f300e2bffa43203ff271318 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 26 Mar 2026 11:42:38 +0800
Subject: [PATCH 0944/1059] Improve doc comment unicode guidance

---
 compiler/rustc_parse/src/errors.rs                  | 10 +++++++---
 compiler/rustc_parse/src/lexer/mod.rs               |  5 ++++-
 .../macro/unicode-control-codepoints-macros.stderr  | 10 +++++-----
 tests/ui/parser/unicode-control-codepoints.stderr   |  4 ++--
 .../unicode-control-doc-comment-issue-153096.rs     |  8 ++++++++
 .../unicode-control-doc-comment-issue-153096.stderr | 13 +++++++++++++
 6 files changed, 39 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/parser/unicode-control-doc-comment-issue-153096.rs
 create mode 100644 tests/ui/parser/unicode-control-doc-comment-issue-153096.stderr

diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 0e852d2abda0..6faaafcc0100 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -4344,7 +4344,7 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
 
 pub(crate) enum HiddenUnicodeCodepointsDiagSub {
     Escape { spans: Vec<(char, Span)> },
-    NoEscape { spans: Vec<(char, Span)> },
+    NoEscape { spans: Vec<(char, Span)>, is_doc_comment: bool },
 }
 
 // Used because of multiple multipart_suggestion and note
@@ -4370,7 +4370,7 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
                     Applicability::MachineApplicable,
                 );
             }
-            HiddenUnicodeCodepointsDiagSub::NoEscape { spans } => {
+            HiddenUnicodeCodepointsDiagSub::NoEscape { spans, is_doc_comment } => {
                 // FIXME: in other suggestions we've reversed the inner spans of doc comments. We
                 // should do the same here to provide the same good suggestions as we do for
                 // literals above.
@@ -4383,7 +4383,11 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
                         .join(", "),
                 );
                 diag.note(msg!("if their presence wasn't intentional, you can remove them"));
-                diag.note(msg!("if you want to keep them but make them visible in your source code, you can escape them: {$escaped}"));
+                if is_doc_comment {
+                    diag.note(msg!(r#"if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as {$escaped}"#));
+                } else {
+                    diag.note(msg!("if you want to keep them but make them visible in your source code, you can escape them: {$escaped}"));
+                }
             }
         }
     }
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index 2223e6a26575..5766d25bc86c 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -546,6 +546,7 @@ fn lint_doc_comment_unicode_text_flow(&mut self, start: BytePos, content: &str)
                 self.mk_sp(start, self.pos),
                 0,
                 false,
+                true,
                 "doc comment",
             );
         }
@@ -580,6 +581,7 @@ fn lint_literal_unicode_text_flow(
             span,
             padding,
             point_at_inner_spans,
+            false,
             label,
         );
     }
@@ -590,6 +592,7 @@ fn report_text_direction_codepoint(
         span: Span,
         padding: u32,
         point_at_inner_spans: bool,
+        is_doc_comment: bool,
         label: &str,
     ) {
         // Obtain the `Span`s for each of the forbidden chars.
@@ -610,7 +613,7 @@ fn report_text_direction_codepoint(
         let sub = if point_at_inner_spans && !spans.is_empty() {
             errors::HiddenUnicodeCodepointsDiagSub::Escape { spans }
         } else {
-            errors::HiddenUnicodeCodepointsDiagSub::NoEscape { spans }
+            errors::HiddenUnicodeCodepointsDiagSub::NoEscape { spans, is_doc_comment }
         };
 
         self.psess.buffer_lint(
diff --git a/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr b/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
index 22fb1b945c65..b1d9c9d01874 100644
--- a/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
+++ b/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
@@ -6,7 +6,7 @@ LL |         /// �test� RTL in doc in vec
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}', '\u{2066}'
    = note: `#[deny(text_direction_codepoint_in_literal)]` on by default
 
 error: unicode codepoint changing visible direction of text present in doc comment
@@ -19,7 +19,7 @@ LL | |          */
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
   --> $DIR/unicode-control-codepoints-macros.rs:33:9
@@ -31,7 +31,7 @@ LL | |          */
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
   --> $DIR/unicode-control-codepoints-macros.rs:41:9
@@ -41,7 +41,7 @@ LL |         /// �test� RTL in doc in proc macro
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
   --> $DIR/unicode-control-codepoints-macros.rs:46:9
@@ -51,7 +51,7 @@ LL |         /// �test� RTL in doc in proc macro
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}', '\u{2066}'
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/parser/unicode-control-codepoints.stderr b/tests/ui/parser/unicode-control-codepoints.stderr
index 7978c1435f60..3b273f8212fa 100644
--- a/tests/ui/parser/unicode-control-codepoints.stderr
+++ b/tests/ui/parser/unicode-control-codepoints.stderr
@@ -232,7 +232,7 @@ LL | /**  '�'); */fn foo() {}
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
   --> $DIR/unicode-control-codepoints.rs:46:1
@@ -244,7 +244,7 @@ LL | |  *  '�'); */fn bar() {}
    |
    = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
    = note: if their presence wasn't intentional, you can remove them
-   = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}'
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{202e}'
 
 error: aborting due to 20 previous errors
 
diff --git a/tests/ui/parser/unicode-control-doc-comment-issue-153096.rs b/tests/ui/parser/unicode-control-doc-comment-issue-153096.rs
new file mode 100644
index 000000000000..a7998daa72fd
--- /dev/null
+++ b/tests/ui/parser/unicode-control-doc-comment-issue-153096.rs
@@ -0,0 +1,8 @@
+//@ edition: 2024
+
+#[allow(unused)]
+/// ⁨א⁩, ⁨ב⁩, ⁨ג⁩, ⁨ד⁩, ⁨ה⁩
+//~^ ERROR unicode codepoint changing visible direction of text present in doc comment
+fn foo() {}
+
+fn main() {}
diff --git a/tests/ui/parser/unicode-control-doc-comment-issue-153096.stderr b/tests/ui/parser/unicode-control-doc-comment-issue-153096.stderr
new file mode 100644
index 000000000000..668a7844da63
--- /dev/null
+++ b/tests/ui/parser/unicode-control-doc-comment-issue-153096.stderr
@@ -0,0 +1,13 @@
+error: unicode codepoint changing visible direction of text present in doc comment
+  --> $DIR/unicode-control-doc-comment-issue-153096.rs:4:1
+   |
+LL | /// �א�, �ב�, �ג�, �ד�, �ה�
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this doc comment contains invisible unicode text flow control codepoints
+   |
+   = note: these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
+   = note: if their presence wasn't intentional, you can remove them
+   = note: if you need to keep them and make them explicit in source, rewrite this doc comment as a `#[doc = "..."]` attribute and use Unicode escapes such as '\u{2068}', '\u{2069}', '\u{2068}', '\u{2069}', '\u{2068}', '\u{2069}', '\u{2068}', '\u{2069}', '\u{2068}', '\u{2069}'
+   = note: `#[deny(text_direction_codepoint_in_literal)]` on by default
+
+error: aborting due to 1 previous error
+

From 4a01e40c24625e55b360b9384f22c45ccee929a9 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Thu, 26 Mar 2026 04:50:46 +0000
Subject: [PATCH 0945/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 1174f784096deb8e4ba93f7e4b5ccb7bb4ba2c55.
---
 src/tools/rust-analyzer/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index db9492636f6a..68f38716dbb0 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-eda4fc7733ee89e484d7120cafbd80dcb2fce66e
+1174f784096deb8e4ba93f7e4b5ccb7bb4ba2c55

From 3f155fe96d95655e373c1f809c9674db92de9381 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 26 Mar 2026 10:35:18 +0530
Subject: [PATCH 0946/1059] migrate getter make variant to SyntaxFactory

---
 .../crates/ide-assists/src/utils.rs           | 29 ++++++++++++++-----
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 96e1bbdc7ea9..5c4bfd79af56 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -1036,8 +1036,8 @@ enum ReferenceConversionType {
 }
 
 impl<'db> ReferenceConversion<'db> {
-    pub(crate) fn convert_type(&self, db: &'db dyn HirDatabase, module: hir::Module) -> ast::Type {
-        let ty = match self.conversion {
+    fn type_to_string(&self, db: &'db dyn HirDatabase, module: hir::Module) -> String {
+        match self.conversion {
             ReferenceConversionType::Copy => self
                 .ty
                 .display_source_code(db, module.into(), true)
@@ -1087,25 +1087,38 @@ pub(crate) fn convert_type(&self, db: &'db dyn HirDatabase, module: hir::Module)
                     .unwrap_or_else(|_| "_".to_owned());
                 format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>")
             }
-        };
+        }
+    }
 
+    pub(crate) fn convert_type(&self, db: &'db dyn HirDatabase, module: hir::Module) -> ast::Type {
+        let ty = self.type_to_string(db, module);
         make::ty(&ty)
     }
 
-    pub(crate) fn getter(&self, field_name: String) -> ast::Expr {
-        let expr = make::expr_field(make::ext::expr_self(), &field_name);
+    pub(crate) fn convert_type_with_factory(
+        &self,
+        make: &SyntaxFactory,
+        db: &'db dyn HirDatabase,
+        module: hir::Module,
+    ) -> ast::Type {
+        let ty = self.type_to_string(db, module);
+        make.ty(&ty)
+    }
+
+    pub(crate) fn getter(&self, make: &SyntaxFactory, field_name: String) -> ast::Expr {
+        let expr = make.expr_field(make.expr_self(), &field_name);
 
         match self.conversion {
-            ReferenceConversionType::Copy => expr,
+            ReferenceConversionType::Copy => expr.into(),
             ReferenceConversionType::AsRefStr
             | ReferenceConversionType::AsRefSlice
             | ReferenceConversionType::Dereferenced
             | ReferenceConversionType::Option
             | ReferenceConversionType::Result => {
                 if self.impls_deref {
-                    make::expr_ref(expr, false)
+                    make.expr_ref(expr.into(), false)
                 } else {
-                    make::expr_method_call(expr, make::name_ref("as_ref"), make::arg_list([]))
+                    make.expr_method_call(expr.into(), make.name_ref("as_ref"), make.arg_list([]))
                         .into()
                 }
             }

From 78b1309d3d7506b7bb3e9c94483096a659117da7 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 26 Mar 2026 10:35:40 +0530
Subject: [PATCH 0947/1059] add expr_self in syntax factory constructor

---
 .../crates/syntax/src/ast/syntax_factory/constructors.rs      | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index fa81dfad1f7f..44114a780295 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -29,6 +29,10 @@ pub fn expr_todo(&self) -> ast::Expr {
         make::ext::expr_todo().clone_for_update()
     }
 
+    pub fn expr_self(&self) -> ast::Expr {
+        make::ext::expr_self().clone_for_update()
+    }
+
     pub fn lifetime(&self, text: &str) -> ast::Lifetime {
         make::lifetime(text).clone_for_update()
     }

From b5f884fada6ffef23374db7bbc18865418fdcd7f Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 26 Mar 2026 10:36:18 +0530
Subject: [PATCH 0948/1059] remove usage of make variant getter from
 generate_getter_or_setter

---
 .../src/handlers/generate_getter_or_setter.rs | 68 +++++++++----------
 1 file changed, 32 insertions(+), 36 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
index 92a654743b58..62ffd3d9656b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
@@ -218,14 +218,14 @@ fn generate_getter_from_info(
     ctx: &AssistContext<'_>,
     info: &AssistInfo,
     record_field_info: &RecordFieldInfo,
-    syntax_factory: &SyntaxFactory,
+    make: &SyntaxFactory,
 ) -> ast::Fn {
     let (ty, body) = if matches!(info.assist_type, AssistType::MutGet) {
-        let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));
+        let self_expr = make.expr_path(make.ident_path("self"));
         (
-            syntax_factory.ty_ref(record_field_info.field_ty.clone(), true),
-            syntax_factory.expr_ref(
-                syntax_factory.expr_field(self_expr, &record_field_info.field_name.text()).into(),
+            make.ty_ref(record_field_info.field_ty.clone(), true),
+            make.expr_ref(
+                make.expr_field(self_expr, &record_field_info.field_name.text()).into(),
                 true,
             ),
         )
@@ -239,21 +239,20 @@ fn generate_getter_from_info(
                 .map(|conversion| {
                     cov_mark::hit!(convert_reference_type);
                     (
-                        conversion.convert_type(ctx.db(), module),
-                        conversion.getter(record_field_info.field_name.to_string()),
+                        conversion.convert_type_with_factory(make, ctx.db(), module),
+                        conversion.getter(make, record_field_info.field_name.to_string()),
                     )
                 })
         })()
         .unwrap_or_else(|| {
             (
-                syntax_factory.ty_ref(record_field_info.field_ty.clone(), false),
-                syntax_factory.expr_ref(
-                    syntax_factory
-                        .expr_field(
-                            syntax_factory.expr_path(syntax_factory.ident_path("self")),
-                            &record_field_info.field_name.text(),
-                        )
-                        .into(),
+                make.ty_ref(record_field_info.field_ty.clone(), false),
+                make.expr_ref(
+                    make.expr_field(
+                        make.expr_path(make.ident_path("self")),
+                        &record_field_info.field_name.text(),
+                    )
+                    .into(),
                     false,
                 ),
             )
@@ -261,18 +260,18 @@ fn generate_getter_from_info(
     };
 
     let self_param = if matches!(info.assist_type, AssistType::MutGet) {
-        syntax_factory.mut_self_param()
+        make.mut_self_param()
     } else {
-        syntax_factory.self_param()
+        make.self_param()
     };
 
     let strukt = &info.strukt;
-    let fn_name = syntax_factory.name(&record_field_info.fn_name);
-    let params = syntax_factory.param_list(Some(self_param), []);
-    let ret_type = Some(syntax_factory.ret_type(ty));
-    let body = syntax_factory.block_expr([], Some(body));
+    let fn_name = make.name(&record_field_info.fn_name);
+    let params = make.param_list(Some(self_param), []);
+    let ret_type = Some(make.ret_type(ty));
+    let body = make.block_expr([], Some(body));
 
-    syntax_factory.fn_(
+    make.fn_(
         None,
         strukt.visibility(),
         fn_name,
@@ -291,32 +290,29 @@ fn generate_getter_from_info(
 fn generate_setter_from_info(
     info: &AssistInfo,
     record_field_info: &RecordFieldInfo,
-    syntax_factory: &SyntaxFactory,
+    make: &SyntaxFactory,
 ) -> ast::Fn {
     let strukt = &info.strukt;
     let field_name = &record_field_info.fn_name;
-    let fn_name = syntax_factory.name(&format!("set_{field_name}"));
+    let fn_name = make.name(&format!("set_{field_name}"));
     let field_ty = &record_field_info.field_ty;
 
     // Make the param list
     // `(&mut self, $field_name: $field_ty)`
-    let field_param = syntax_factory.param(
-        syntax_factory.ident_pat(false, false, syntax_factory.name(field_name)).into(),
-        field_ty.clone(),
-    );
-    let params = syntax_factory.param_list(Some(syntax_factory.mut_self_param()), [field_param]);
+    let field_param =
+        make.param(make.ident_pat(false, false, make.name(field_name)).into(), field_ty.clone());
+    let params = make.param_list(Some(make.mut_self_param()), [field_param]);
 
     // Make the assignment body
     // `self.$field_name = $field_name`
-    let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));
-    let lhs = syntax_factory.expr_field(self_expr, field_name);
-    let rhs = syntax_factory.expr_path(syntax_factory.ident_path(field_name));
-    let assign_stmt =
-        syntax_factory.expr_stmt(syntax_factory.expr_assignment(lhs.into(), rhs).into());
-    let body = syntax_factory.block_expr([assign_stmt.into()], None);
+    let self_expr = make.expr_path(make.ident_path("self"));
+    let lhs = make.expr_field(self_expr, field_name);
+    let rhs = make.expr_path(make.ident_path(field_name));
+    let assign_stmt = make.expr_stmt(make.expr_assignment(lhs.into(), rhs).into());
+    let body = make.block_expr([assign_stmt.into()], None);
 
     // Make the setter fn
-    syntax_factory.fn_(
+    make.fn_(
         None,
         strukt.visibility(),
         fn_name,

From 91e4524bfe66a33d1a572750504cd5ac006d9b5e Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Thu, 26 Mar 2026 11:33:33 +0700
Subject: [PATCH 0949/1059] Link from `assert_matches` to
 `debug_assert_matches`

This resolves a FIXME which was added in
https://github.com/rust-lang/rust/pull/151423.
---
 library/core/src/macros/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index 49e1acd0b90f..7f35e94d3df3 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -124,8 +124,6 @@ macro_rules! assert_ne {
     };
 }
 
-// FIXME add back debug_assert_matches doc link after bootstrap.
-
 /// Asserts that an expression matches the provided pattern.
 ///
 /// This macro is generally preferable to `assert!(matches!(value, pattern))`, because it can print
@@ -137,9 +135,11 @@ macro_rules! assert_ne {
 /// otherwise this macro will panic.
 ///
 /// Assertions are always checked in both debug and release builds, and cannot
-/// be disabled. See `debug_assert_matches!` for assertions that are disabled in
+/// be disabled. See [`debug_assert_matches!`] for assertions that are disabled in
 /// release builds by default.
 ///
+/// [`debug_assert_matches!`]: crate::debug_assert_matches
+///
 /// On panic, this macro will print the value of the expression with its debug representation.
 ///
 /// Like [`assert!`], this macro has a second form, where a custom panic message can be provided.

From c9f2a6ef226d622d2ba4cb8a100fb2c1c53289ae Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 26 Mar 2026 05:27:36 +0000
Subject: [PATCH 0950/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 1174f784096deb8e4ba93f7e4b5ccb7bb4ba2c55.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index effc9080877a..68f38716dbb0 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-8a703520e80d87d4423c01f9d4fbc9e5f6533a02
+1174f784096deb8e4ba93f7e4b5ccb7bb4ba2c55

From 4a31988c75832e23d22ae62ec47a91c450c94615 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Wed, 25 Mar 2026 23:02:24 -0700
Subject: [PATCH 0951/1059] Update `try_blocks` to a new tracking issue number

---
 compiler/rustc_feature/src/unstable.rs                    | 2 +-
 src/doc/unstable-book/src/language-features/try-blocks.md | 8 ++++----
 .../rust-analyzer/crates/ide-db/src/generated/lints.rs    | 8 ++++----
 tests/ui/README.md                                        | 2 +-
 tests/ui/feature-gates/feature-gate-try_blocks.stderr     | 2 +-
 .../try-block/try-block-homogeneous-pre-expansion.stderr  | 2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index f36102fdc73f..e6e706d4819a 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -673,7 +673,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows inconsistent bounds in where clauses.
     (unstable, trivial_bounds, "1.28.0", Some(48214)),
     /// Allows using `try {...}` expressions.
-    (unstable, try_blocks, "1.29.0", Some(31436)),
+    (unstable, try_blocks, "1.29.0", Some(154391)),
     /// Allows using `try bikeshed TargetType {...}` expressions.
     (unstable, try_blocks_heterogeneous, "1.94.0", Some(149488)),
     /// Allows `impl Trait` to be used inside type aliases (RFC 2515).
diff --git a/src/doc/unstable-book/src/language-features/try-blocks.md b/src/doc/unstable-book/src/language-features/try-blocks.md
index e342c260a739..f72467f06476 100644
--- a/src/doc/unstable-book/src/language-features/try-blocks.md
+++ b/src/doc/unstable-book/src/language-features/try-blocks.md
@@ -1,8 +1,8 @@
 # `try_blocks`
 
-The tracking issue for this feature is: [#31436]
+The tracking issue for this feature is: [#154391]
 
-[#31436]: https://github.com/rust-lang/rust/issues/31436
+[#154391]: https://github.com/rust-lang/rust/issues/154391
 
 ------------------------
 
@@ -14,14 +14,14 @@ block creates a new scope one can use the `?` operator in.
 
 use std::num::ParseIntError;
 
-let result: Result<i32, ParseIntError> = try {
+let result = try {
     "1".parse::<i32>()?
         + "2".parse::<i32>()?
         + "3".parse::<i32>()?
 };
 assert_eq!(result, Ok(6));
 
-let result: Result<i32, ParseIntError> = try {
+let result = try {
     "1".parse::<i32>()?
         + "foo".parse::<i32>()?
         + "3".parse::<i32>()?
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
index dedc12aa653f..9e6d58600888 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
@@ -11576,9 +11576,9 @@ pub union GenericUnion<T: Copy> { // Unions with non-`Copy` fields are unstable.
         label: "try_blocks",
         description: r##"# `try_blocks`
 
-The tracking issue for this feature is: [#31436]
+The tracking issue for this feature is: [#154391]
 
-[#31436]: https://github.com/rust-lang/rust/issues/31436
+[#154391]: https://github.com/rust-lang/rust/issues/154391
 
 ------------------------
 
@@ -11590,14 +11590,14 @@ pub union GenericUnion<T: Copy> { // Unions with non-`Copy` fields are unstable.
 
 use std::num::ParseIntError;
 
-let result: Result<i32, ParseIntError> = try {
+let result = try {
     "1".parse::<i32>()?
         + "2".parse::<i32>()?
         + "3".parse::<i32>()?
 };
 assert_eq!(result, Ok(6));
 
-let result: Result<i32, ParseIntError> = try {
+let result = try {
     "1".parse::<i32>()?
         + "foo".parse::<i32>()?
         + "3".parse::<i32>()?
diff --git a/tests/ui/README.md b/tests/ui/README.md
index 3ebbe4918a2d..47bfdeab53dc 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -1462,7 +1462,7 @@ Tests for the `#[doc(hidden)]` items.
 
 ## `tests/ui/try-block/`
 
-`#![feature(try_blocks)]`. See [Tracking issue for `?` operator and `try` blocks (RFC 243, `question_mark` & `try_blocks` features)](https://github.com/rust-lang/rust/issues/31436).
+`#![feature(try_blocks)]` & `#![feature(try_blocks_heterogeneous)]`. See [Tracking Issue for homogeneous `try_blocks`](https://github.com/rust-lang/rust/issues/154391) & [Experimental Tracking Issue for Heterogeneous Try Blocks](https://github.com/rust-lang/rust/issues/149488).
 
 ## `tests/ui/try-trait/`
 
diff --git a/tests/ui/feature-gates/feature-gate-try_blocks.stderr b/tests/ui/feature-gates/feature-gate-try_blocks.stderr
index dbef7fbe9d25..0a7580df61c0 100644
--- a/tests/ui/feature-gates/feature-gate-try_blocks.stderr
+++ b/tests/ui/feature-gates/feature-gate-try_blocks.stderr
@@ -8,7 +8,7 @@ LL | |         x
 LL | |     };
    | |_____^
    |
-   = note: see issue #31436 <https://github.com/rust-lang/rust/issues/31436> for more information
+   = note: see issue #154391 <https://github.com/rust-lang/rust/issues/154391> for more information
    = help: add `#![feature(try_blocks)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
diff --git a/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr b/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr
index dc92d7e64aff..67cbcb42fb47 100644
--- a/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr
+++ b/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr
@@ -4,7 +4,7 @@ warning: `try` blocks are unstable
 LL |     try {}
    |     ^^^^^^
    |
-   = note: see issue #31436 <https://github.com/rust-lang/rust/issues/31436> for more information
+   = note: see issue #154391 <https://github.com/rust-lang/rust/issues/154391> for more information
    = help: add `#![feature(try_blocks)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = warning: unstable syntax can change at any point in the future, causing a hard error!

From e56d8665eada851af8c11854b16c8ca11c16b186 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 26 Mar 2026 05:36:48 +0000
Subject: [PATCH 0952/1059] fmt

---
 .../tests/fail/function_pointers/abi_mismatch_return_type.rs   | 3 ++-
 .../miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
index 8bf46af71e82..3f9c42a78223 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
@@ -1,5 +1,6 @@
 fn main() {
-    fn f() -> u32 { //~ ERROR: type u32 passing return place of type ()
+    fn f() -> u32 {
+        //~^ERROR: type u32 passing return place of type ()
         42
     }
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
index 7bc26237576a..0635fdd14920 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
@@ -5,7 +5,8 @@
 use std::num::NonZero;
 use std::ptr;
 
-fn f(c: u32) { //~ERROR: expected something greater or equal to 1
+fn f(c: u32) {
+    //~^ERROR: expected something greater or equal to 1
     println!("{c}");
 }
 

From 298c251f9178dc39768356a9a90f4853134a7dde Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Mar 2026 16:33:59 +0100
Subject: [PATCH 0953/1059] large_enums mir pass: fix is_enabled logic

---
 compiler/rustc_mir_transform/src/large_enums.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
index 89bd91e7013d..b9a620645267 100644
--- a/compiler/rustc_mir_transform/src/large_enums.rs
+++ b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -32,8 +32,8 @@ impl<'tcx> crate::MirPass<'tcx> for EnumSizeOpt {
     fn is_enabled(&self, sess: &Session) -> bool {
         // There are some differences in behavior on wasm and ARM that are not properly
         // understood, so we conservatively treat this optimization as unsound:
-        // https://github.com/rust-lang/rust/pull/85158#issuecomment-1101836457
-        sess.opts.unstable_opts.unsound_mir_opts || sess.mir_opt_level() >= 3
+        // https://github.com/rust-lang/rust/issues/154413
+        sess.opts.unstable_opts.unsound_mir_opts && sess.mir_opt_level() >= 3
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {

From 224eda09e6def37e6452e058f0a91ed9a1bcef9b Mon Sep 17 00:00:00 2001
From: ywxt <ywxtcwh@gmail.com>
Date: Thu, 26 Mar 2026 16:08:34 +0800
Subject: [PATCH 0954/1059] Add more  tests for the parallel frontend

---
 .../assert-found_cycle-issue-115223.rs        |  31 ++
 ...default-trait-shadow-cycle-issue-151358.rs |  12 +
 ...ult-trait-shadow-cycle-issue-151358.stderr |   9 +
 ...neric-const-exprs-deadlock-issue-120757.rs | 127 ++++++
 ...c-const-exprs-deadlock-issue-120757.stderr | 166 ++++++++
 ...neric-const-exprs-deadlock-issue-134978.rs |  20 +
 ...c-const-exprs-deadlock-issue-134978.stderr |  29 ++
 .../infer-unwrap-none-issue-120786.rs         |  82 ++++
 .../infer-unwrap-none-issue-120786.stderr     | 256 ++++++++++++
 .../nested-type-alias-cycle-issue-129911.rs   |  89 ++++
 ...ested-type-alias-cycle-issue-129911.stderr | 391 ++++++++++++++++++
 ...ursive-impl-trait-deadlock-issue-129912.rs |  97 +++++
 ...ve-impl-trait-deadlock-issue-129912.stderr | 137 ++++++
 .../recursive-struct-oncelock-issue-151226.rs |   9 +
 ...ursive-struct-oncelock-issue-151226.stderr |  14 +
 .../recursive-trait-fn-sig-issue-142064.rs    |  18 +
 ...recursive-trait-fn-sig-issue-142064.stderr | 114 +++++
 ...-type-with-transmutability-issue-120759.rs |  26 ++
 ...e-with-transmutability-issue-120759.stderr |  35 ++
 19 files changed, 1662 insertions(+)
 create mode 100644 tests/ui/parallel-rustc/assert-found_cycle-issue-115223.rs
 create mode 100644 tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.rs
 create mode 100644 tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.stderr
 create mode 100644 tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.rs
 create mode 100644 tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.stderr
 create mode 100644 tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.rs
 create mode 100644 tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.stderr
 create mode 100644 tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.rs
 create mode 100644 tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.stderr
 create mode 100644 tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.rs
 create mode 100644 tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.stderr
 create mode 100644 tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.rs
 create mode 100644 tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.stderr
 create mode 100644 tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.rs
 create mode 100644 tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.stderr
 create mode 100644 tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.rs
 create mode 100644 tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.stderr
 create mode 100644 tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.rs
 create mode 100644 tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.stderr

diff --git a/tests/ui/parallel-rustc/assert-found_cycle-issue-115223.rs b/tests/ui/parallel-rustc/assert-found_cycle-issue-115223.rs
new file mode 100644
index 000000000000..96a11720abdf
--- /dev/null
+++ b/tests/ui/parallel-rustc/assert-found_cycle-issue-115223.rs
@@ -0,0 +1,31 @@
+// Test for #115223, which causes a deadlock bug without finding the cycle
+//@ build-pass
+#![crate_name = "foo"]
+
+use std::ops;
+
+pub struct Foo;
+
+impl Foo {
+    pub fn foo(&mut self) {}
+}
+
+pub struct Bar {
+    foo: Foo,
+}
+
+impl ops::Deref for Bar {
+    type Target = Foo;
+
+    fn deref(&self) -> &Foo {
+        &self.foo
+    }
+}
+
+impl ops::DerefMut for Bar {
+    fn deref_mut(&mut self) -> &mut Foo {
+        &mut self.foo
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.rs b/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.rs
new file mode 100644
index 000000000000..8bc11ce31d19
--- /dev/null
+++ b/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.rs
@@ -0,0 +1,12 @@
+// Test for #151358, assertion failed: !worker_thread.is_null()
+//~^ ERROR cycle detected when looking up span for `Default`
+//
+//@ compile-flags: -Z threads=2
+//@ compare-output-by-lines
+
+trait Default {}
+use std::num::NonZero;
+fn main() {
+    NonZero();
+    todo!();
+}
diff --git a/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.stderr b/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.stderr
new file mode 100644
index 000000000000..9c1d7b1de33a
--- /dev/null
+++ b/tests/ui/parallel-rustc/default-trait-shadow-cycle-issue-151358.stderr
@@ -0,0 +1,9 @@
+error[E0391]: cycle detected when looking up span for `Default`
+   |
+   = note: ...which immediately requires looking up span for `Default` again
+   = note: cycle used when perform lints prior to AST lowering
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.rs b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.rs
new file mode 100644
index 000000000000..ef484c38ccad
--- /dev/null
+++ b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.rs
@@ -0,0 +1,127 @@
+// Test for #120757, deadlock due to query cycle
+
+#![feature(generic_const_exprs)]
+
+trait TensorDimension {
+    const DIM: usize;
+    const ISSCALAR: bool = Self::DIM == 0;
+    fn is_scalar(&self) -> bool {
+        Self::ISSCALAR
+    }
+}
+
+trait TensorSize: TensorDimension {
+    fn size(&self) -> [usize; Self::DIM];
+    fn inbounds(&self, index: [usize; Self::DIM]) -> bool {
+        index.iter().zip(self.size().iter()).all(|(i, s)| i < s)
+    }
+}
+
+trait Broadcastable: TensorSize + Sized {
+    type Element;
+    fn bget(&self, index: [usize; Self::DIM]) -> Option<Self::Element>;
+    fn lazy_updim<const NEWDIM: usize>(
+        &self,
+        size: [usize; NEWDIM],
+    ) -> LazyUpdim<Self, { Self::DIM }, NEWDIM> {
+        assert!(
+            NEWDIM >= Self::DIM,
+            "Updimmed tensor cannot have fewer indices than the initial one."
+        );
+        LazyUpdim { size, reference: &self }
+    }
+    fn bmap<T, F: Fn(Self::Element) -> T>(&self, foo: F) -> BMap<T, Self, F, { Self::DIM }> {
+        BMap { reference: self, closure: foo }
+    }
+}
+
+struct LazyUpdim<'a, T: Broadcastable, const OLDDIM: usize, const DIM: usize> {
+    size: [usize; DIM],
+    reference: &'a T,
+}
+
+impl<'a, T: Broadcastable, const DIM: usize> TensorDimension for LazyUpdim<'a, T, { T::DIM }, DIM> {
+    const DIM: usize = DIM;
+}
+impl<'a, T: Broadcastable, const DIM: usize> TensorSize for LazyUpdim<'a, T, { T::DIM }, DIM> {
+    fn size(&self) -> [usize; DIM] {
+    //~^ ERROR method not compatible with trait
+        self.size
+    }
+}
+impl<'a, T: Broadcastable, const DIM: usize> Broadcastable for LazyUpdim<'a, T, { T::DIM }, DIM> {
+    type Element = T::Element;
+    fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
+    //~^ ERROR method not compatible with trait
+        assert!(DIM >= T::DIM);
+        if !self.inbounds(index) {
+        //~^ ERROR unconstrained generic constant
+        //~| ERROR mismatched types
+            return None;
+        }
+        let size = self.size();
+        //~^ ERROR unconstrained generic constant
+
+        let newindex: [usize; T::DIM] = Default::default();
+        //~^ ERROR the trait bound `[usize; T::DIM]: Default` is not satisfied
+        self.reference.bget(newindex)
+    }
+}
+
+struct BMap<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> {
+    reference: &'a T,
+    closure: F,
+}
+
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> TensorDimension
+    for BMap<'a, R, T, F, DIM>
+{
+    const DIM: usize = DIM;
+}
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> TensorSize
+    for BMap<'a, R, T, F, DIM>
+{
+    fn size(&self) -> [usize; DIM] {
+    //~^ ERROR method not compatible with trait
+        self.reference.size()
+        //~^ ERROR unconstrained generic constant
+        //~| ERROR mismatched types
+    }
+}
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> Broadcastable
+    for BMap<'a, R, T, F, DIM>
+{
+    type Element = R;
+    fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
+    //~^ ERROR method not compatible with trait
+        self.reference.bget(index).map(ns_window)
+        //~^ ERROR unconstrained generic constant
+        //~| ERROR mismatched types
+        //~| ERROR cannot find value `ns_window` in this scope
+    }
+}
+
+impl<T> TensorDimension for Vec<T> {
+    const DIM: usize = 1;
+}
+impl<T> TensorSize for Vec<T> {
+    fn size(&self) -> [usize; 1] {
+    //~^ ERROR method not compatible with trait
+        [self.len()]
+    }
+}
+impl<T: Clone> Broadcastable for Vec<T> {
+    type Element = T;
+    fn bget(&self, index: [usize; 1]) -> Option<T> {
+    //~^ ERROR method not compatible with trait
+        self.get(index[0]).cloned()
+    }
+}
+
+fn main() {
+    let v = vec![1, 2, 3];
+    let bv = v.lazy_updim([3, 4]);
+    let bbv = bv.bmap(|x| x * x);
+
+    println!("The size of v is {:?}", bbv.bget([0, 2]).expect("Out of bounds."));
+}
diff --git a/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.stderr b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.stderr
new file mode 100644
index 000000000000..4e8cbdb31951
--- /dev/null
+++ b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-120757.stderr
@@ -0,0 +1,166 @@
+error[E0425]: cannot find value `ns_window` in this scope
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:97:40
+   |
+LL |         self.reference.bget(index).map(ns_window)
+   |                                        ^^^^^^^^^ not found in this scope
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:47:5
+   |
+LL |     fn size(&self) -> [usize; DIM] {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:54:5
+   |
+LL |     fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:84:5
+   |
+LL |     fn size(&self) -> [usize; DIM] {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:95:5
+   |
+LL |     fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:108:5
+   |
+LL |     fn size(&self) -> [usize; 1] {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `1`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `1`
+
+error[E0308]: method not compatible with trait
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:115:5
+   |
+LL |     fn bget(&self, index: [usize; 1]) -> Option<T> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Self::DIM`, found `1`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `1`
+
+error: unconstrained generic constant
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:57:13
+   |
+LL |         if !self.inbounds(index) {
+   |             ^^^^
+   |
+note: required by a bound in `TensorSize::inbounds`
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:15:39
+   |
+LL |     fn inbounds(&self, index: [usize; Self::DIM]) -> bool {
+   |                                       ^^^^^^^^^ required by this bound in `TensorSize::inbounds`
+help: try adding a `where` bound
+   |
+LL |     fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> where [(); Self::DIM]: {
+   |                                                                  ++++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:57:27
+   |
+LL |         if !self.inbounds(index) {
+   |                           ^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error: unconstrained generic constant
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:62:25
+   |
+LL |         let size = self.size();
+   |                         ^^^^
+   |
+note: required by a bound in `TensorSize::size`
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:14:31
+   |
+LL |     fn size(&self) -> [usize; Self::DIM];
+   |                               ^^^^^^^^^ required by this bound in `TensorSize::size`
+help: try adding a `where` bound
+   |
+LL |     fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> where [(); Self::DIM]: {
+   |                                                                  ++++++++++++++++++++++
+
+error[E0277]: the trait bound `[usize; T::DIM]: Default` is not satisfied
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:65:41
+   |
+LL |         let newindex: [usize; T::DIM] = Default::default();
+   |                                         ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `[usize; T::DIM]`
+   |
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
+   |
+LL | impl<'a, T: Broadcastable, const DIM: usize> Broadcastable for LazyUpdim<'a, T, { T::DIM }, DIM> where [usize; T::DIM]: Default {
+   |                                                                                                  ++++++++++++++++++++++++++++++
+
+error: unconstrained generic constant
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:86:24
+   |
+LL |         self.reference.size()
+   |                        ^^^^
+   |
+note: required by a bound in `TensorSize::size`
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:14:31
+   |
+LL |     fn size(&self) -> [usize; Self::DIM];
+   |                               ^^^^^^^^^ required by this bound in `TensorSize::size`
+help: try adding a `where` bound
+   |
+LL |     fn size(&self) -> [usize; DIM] where [(); Self::DIM]: {
+   |                                    ++++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:86:9
+   |
+LL |         self.reference.size()
+   |         ^^^^^^^^^^^^^^^^^^^^^ expected `DIM`, found `Self::DIM`
+   |
+   = note: expected constant `DIM`
+              found constant `Self::DIM`
+
+error: unconstrained generic constant
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:97:9
+   |
+LL |         self.reference.bget(index).map(ns_window)
+   |         ^^^^^^^^^^^^^^
+   |
+note: required by a bound in `Broadcastable::bget`
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:22:35
+   |
+LL |     fn bget(&self, index: [usize; Self::DIM]) -> Option<Self::Element>;
+   |                                   ^^^^^^^^^ required by this bound in `Broadcastable::bget`
+help: try adding a `where` bound
+   |
+LL |     fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> where [(); Self::DIM]: {
+   |                                                                  ++++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/generic-const-exprs-deadlock-issue-120757.rs:97:29
+   |
+LL |         self.reference.bget(index).map(ns_window)
+   |                             ^^^^^ expected `Self::DIM`, found `DIM`
+   |
+   = note: expected constant `Self::DIM`
+              found constant `DIM`
+
+error: aborting due to 15 previous errors
+
+Some errors have detailed explanations: E0277, E0308, E0425.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.rs b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.rs
new file mode 100644
index 000000000000..ccc03a44cf70
--- /dev/null
+++ b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.rs
@@ -0,0 +1,20 @@
+// Test for #134978, deadlock detected as we're unable to find a query cycle to break
+
+#![feature(generic_const_exprs)]
+
+pub struct Struct<const N: usize>;
+
+impl<const N: usize> Struct<N> {
+    pub const OK: usize = 0;
+}
+
+fn main() {
+    function::<0>();
+}
+
+fn function<const NUM_CARDS: usize>()
+where
+    [(); Struct::<{ NUM_CARDS + 0 }>::OK]:,
+    //~^ ERROR cycle detected when building an abstract representation
+{
+}
diff --git a/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.stderr b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.stderr
new file mode 100644
index 000000000000..a27c1079bd81
--- /dev/null
+++ b/tests/ui/parallel-rustc/generic-const-exprs-deadlock-issue-134978.stderr
@@ -0,0 +1,29 @@
+error[E0391]: cycle detected when building an abstract representation for `function::{constant#0}`
+  --> $DIR/generic-const-exprs-deadlock-issue-134978.rs:17:10
+   |
+LL |     [(); Struct::<{ NUM_CARDS + 0 }>::OK]:,
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: ...which requires building THIR for `function::{constant#0}`...
+  --> $DIR/generic-const-exprs-deadlock-issue-134978.rs:17:10
+   |
+LL |     [(); Struct::<{ NUM_CARDS + 0 }>::OK]:,
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires type-checking `function::{constant#0}`...
+  --> $DIR/generic-const-exprs-deadlock-issue-134978.rs:17:10
+   |
+LL |     [(); Struct::<{ NUM_CARDS + 0 }>::OK]:,
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: ...which again requires building an abstract representation for `function::{constant#0}`, completing the cycle
+note: cycle used when checking that `function` is well-formed
+  --> $DIR/generic-const-exprs-deadlock-issue-134978.rs:15:1
+   |
+LL | / fn function<const NUM_CARDS: usize>()
+LL | | where
+LL | |     [(); Struct::<{ NUM_CARDS + 0 }>::OK]:,
+   | |___________________________________________^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.rs b/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.rs
new file mode 100644
index 000000000000..f617e20804a2
--- /dev/null
+++ b/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.rs
@@ -0,0 +1,82 @@
+// Test for #120786, which causes an ice bug: infer: `None`
+
+fn no_err() {
+    |x: u32, y| x;
+    //~^ ERROR type annotations needed
+    let _ = String::from("x");
+}
+
+fn err() {
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+}
+
+fn arg_pat_closure_err() {
+    |x| String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+}
+
+fn local_pat_closure_err() {
+    let _ = "x".as_ref();
+    //~^ ERROR type annotations needed
+}
+
+fn err_first_arg_pat() {
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+    |x: String| x;
+}
+
+fn err_second_arg_pat() {
+    |x: String| x;
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+}
+
+fn err_mid_arg_pat() {
+    |x: String| x;
+    |x: String| x;
+    |x: String| x;
+    |x: String| x;
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+    |x: String| x;
+    |x: String| x;
+    |x: String| x;
+    |x: String| x;
+}
+
+fn err_first_local_pat() {
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+    let _ = String::from("x");
+}
+
+fn err_second_local_pat() {
+    let _ = String::from("x");
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+}
+
+fn err_mid_local_pat() {
+    let _ = String::from("x");
+    let _ = String::from("x");
+    let _ = String::from("x");
+    let _ = String::from("x");
+    String::from("x".as_ref());
+    //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
+    let _ = String::from("x");
+    let _ = String::from("x");
+    let _ = String::from("x");
+    let _ = String::from("x");
+}
+
+fn main() {}
diff --git a/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.stderr b/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.stderr
new file mode 100644
index 000000000000..3be18fc59e73
--- /dev/null
+++ b/tests/ui/parallel-rustc/infer-unwrap-none-issue-120786.stderr
@@ -0,0 +1,256 @@
+error[E0282]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:4:14
+   |
+LL |     |x: u32, y| x;
+   |              ^
+   |
+help: consider giving this closure parameter an explicit type
+   |
+LL |     |x: u32, y: /* Type */| x;
+   |               ++++++++++++
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:10:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:10:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:16:9
+   |
+LL |     |x| String::from("x".as_ref());
+   |         ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:16:26
+   |
+LL |     |x| String::from("x".as_ref());
+   |                          ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     |x| String::from("x".as_ref());
+LL +     |x| String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed for `&_`
+  --> $DIR/infer-unwrap-none-issue-120786.rs:22:9
+   |
+LL |     let _ = "x".as_ref();
+   |         ^       ------ type must be known at this point
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: consider giving this pattern a type, where the type for type parameter `T` is specified
+   |
+LL |     let _: &T = "x".as_ref();
+   |          ++++
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:27:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:27:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:35:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:35:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:45:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:45:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:55:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:55:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:63:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:63:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:73:5
+   |
+LL |     String::from("x".as_ref());
+   |     ^^^^^^ cannot infer type for reference `&_`
+   |
+   = note: multiple `impl`s satisfying `String: From<&_>` found in the `alloc` crate:
+           - impl From<&String> for String;
+           - impl From<&str> for String;
+
+error[E0283]: type annotations needed
+  --> $DIR/infer-unwrap-none-issue-120786.rs:73:22
+   |
+LL |     String::from("x".as_ref());
+   |                      ^^^^^^
+   |
+   = note: multiple `impl`s satisfying `str: AsRef<_>` found in the following crates: `core`, `std`:
+           - impl AsRef<ByteStr> for str;
+           - impl AsRef<OsStr> for str;
+           - impl AsRef<Path> for str;
+           - impl AsRef<[u8]> for str;
+           - impl AsRef<str> for str;
+help: try using a fully qualified path to specify the expected types
+   |
+LL -     String::from("x".as_ref());
+LL +     String::from(<str as AsRef<T>>::as_ref("x"));
+   |
+
+error: aborting due to 18 previous errors
+
+Some errors have detailed explanations: E0282, E0283.
+For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.rs b/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.rs
new file mode 100644
index 000000000000..1fd058db29d4
--- /dev/null
+++ b/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.rs
@@ -0,0 +1,89 @@
+// Test for #129911, deadlock detected as we're unable to find a query cycle to break
+
+fn main() {
+    type KooArc = Frc<
+    //~^ ERROR cannot find type `Frc` in this scope
+        {
+            {
+                {
+                    {};
+                }
+                type Frc = Frc<{}>::Arc;;
+                //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                //~| ERROR cycle detected when expanding type alias
+            }
+            type Frc = Frc<
+            //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+            //~| ERROR cycle detected when expanding type alias
+                {
+                    {
+                        {
+                            {};
+                        }
+                        type Frc = Frc<{}>::Arc;;
+                        //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                        //~| ERROR cycle detected when expanding type alias
+                    }
+                    type Frc = Frc<
+                    //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                    //~| ERROR cycle detected when expanding type alias
+                        {
+                            {
+                                {
+                                    {};
+                                }
+                                type Frc = Frc<{}>::Arc;;
+                                //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                //~| ERROR cycle detected when expanding type alias
+                            }
+                            type Frc = Frc<
+                            //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                            //~| ERROR cycle detected when expanding type alias
+                                {
+                                    {
+                                        {
+                                            {};
+                                        }
+                                        type Frc = Frc<{}>::Arc;;
+                                        //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                        //~| ERROR cycle detected when expanding type alias
+                                    }
+                                    type Frc = Frc<
+                                    //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                    //~| ERROR cycle detected when expanding type alias
+                                        {
+                                            {
+                                                {
+                                                    {
+                                                        {};
+                                                    }
+                                                    type Frc = Frc<{}>::Arc;;
+                                                    //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                                    //~| ERROR cycle detected when expanding type alias
+                                                };
+                                            }
+                                            type Frc = Frc<
+                                            //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                            //~| ERROR cycle detected when expanding type alias
+                                                {
+                                                    {
+                                                        {
+                                                            {};
+                                                        };
+                                                    }
+                                                    type Frc = Frc<{}>::Arc;;
+                                                    //~^ ERROR type alias takes 0 generic arguments but 1 generic argument was supplied
+                                                    //~| ERROR cycle detected when expanding type alias
+                                                },
+                                            >::Arc;;
+                                        },
+                                    >::Arc;;
+                                },
+                            >::Arc;;
+                        },
+                    >::Arc;;
+                },
+            >::Arc;;
+        },
+    >::Arc;
+}
diff --git a/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.stderr b/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.stderr
new file mode 100644
index 000000000000..b1ece1747989
--- /dev/null
+++ b/tests/ui/parallel-rustc/nested-type-alias-cycle-issue-129911.stderr
@@ -0,0 +1,391 @@
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:11:28
+   |
+LL |                 type Frc = Frc<{}>::Arc;;
+   |                            ^^^---- help: remove the unnecessary generics
+   |                            |
+   |                            expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:11:22
+   |
+LL |                 type Frc = Frc<{}>::Arc;;
+   |                      ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:11:28
+   |
+LL |                 type Frc = Frc<{}>::Arc;;
+   |                            ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:11:17
+   |
+LL |                 type Frc = Frc<{}>::Arc;;
+   |                 ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:15:24
+   |
+LL |               type Frc = Frc<
+   |  ________________________^^^-
+   | |                        |
+   | |                        expected 0 generic arguments
+...  |
+LL | |                 },
+LL | |             >::Arc;;
+   | |_____________- help: remove the unnecessary generics
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:15:18
+   |
+LL |             type Frc = Frc<
+   |                  ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:15:24
+   |
+LL |               type Frc = Frc<
+   |  ________________________^
+...  |
+LL | |                 },
+LL | |             >::Arc;;
+   | |_____________^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:15:13
+   |
+LL |             type Frc = Frc<
+   |             ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:23:36
+   |
+LL |                         type Frc = Frc<{}>::Arc;;
+   |                                    ^^^---- help: remove the unnecessary generics
+   |                                    |
+   |                                    expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:23:30
+   |
+LL |                         type Frc = Frc<{}>::Arc;;
+   |                              ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:23:36
+   |
+LL |                         type Frc = Frc<{}>::Arc;;
+   |                                    ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:23:25
+   |
+LL |                         type Frc = Frc<{}>::Arc;;
+   |                         ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:27:32
+   |
+LL |                       type Frc = Frc<
+   |  ________________________________^^^-
+   | |                                |
+   | |                                expected 0 generic arguments
+...  |
+LL | |                         },
+LL | |                     >::Arc;;
+   | |_____________________- help: remove the unnecessary generics
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:27:26
+   |
+LL |                     type Frc = Frc<
+   |                          ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:27:32
+   |
+LL |                       type Frc = Frc<
+   |  ________________________________^
+...  |
+LL | |                         },
+LL | |                     >::Arc;;
+   | |_____________________^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:27:21
+   |
+LL |                     type Frc = Frc<
+   |                     ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:35:44
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^---- help: remove the unnecessary generics
+   |                                  |
+   |                                  expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:35:38
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:35:44
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:35:33
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:39:40
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^^^-
+   | |                                  |
+   | |                                  expected 0 generic arguments
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________- help: remove the unnecessary generics
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:39:34
+   |
+LL | ...                   type Frc = Frc<
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:39:40
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:39:29
+   |
+LL | ...                   type Frc = Frc<
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:47:52
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^---- help: remove the unnecessary generics
+   |                                  |
+   |                                  expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:47:46
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:47:52
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:47:41
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:51:48
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^^^-
+   | |                                  |
+   | |                                  expected 0 generic arguments
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________- help: remove the unnecessary generics
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:51:42
+   |
+LL | ...                   type Frc = Frc<
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:51:48
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:51:37
+   |
+LL | ...                   type Frc = Frc<
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:60:64
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^---- help: remove the unnecessary generics
+   |                                  |
+   |                                  expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:60:58
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:60:64
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:60:53
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:65:56
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^^^-
+   | |                                  |
+   | |                                  expected 0 generic arguments
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________- help: remove the unnecessary generics
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:65:50
+   |
+LL | ...                   type Frc = Frc<
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:65:56
+   |
+LL |   ...                   type Frc = Frc<
+   |  __________________________________^
+...  |
+LL | | ...                       },
+LL | | ...                   >::Arc;;
+   | |_______________________^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:65:45
+   |
+LL | ...                   type Frc = Frc<
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0107]: type alias takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:74:64
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^---- help: remove the unnecessary generics
+   |                                  |
+   |                                  expected 0 generic arguments
+   |
+note: type alias defined here, with 0 generic parameters
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:74:58
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                            ^^^
+
+error[E0391]: cycle detected when expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc`
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:74:64
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                                  ^^^^^^^
+   |
+   = note: ...which immediately requires expanding type alias `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` again
+   = note: type aliases cannot be recursive
+   = help: consider using a struct, enum, or union instead to break the cycle
+   = help: see <https://doc.rust-lang.org/reference/types.html#recursive-types> for more information
+note: cycle used when checking that `main::KooArc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc::{constant#0}::Frc` is well-formed
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:74:53
+   |
+LL | ...                   type Frc = Frc<{}>::Arc;;
+   |                       ^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error[E0433]: cannot find type `Frc` in this scope
+  --> $DIR/nested-type-alias-cycle-issue-129911.rs:4:19
+   |
+LL |     type KooArc = Frc<
+   |                   ^^^ use of undeclared type `Frc`
+
+error: aborting due to 23 previous errors
+
+Some errors have detailed explanations: E0107, E0391, E0433.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.rs b/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.rs
new file mode 100644
index 000000000000..5b0bd19fff0b
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.rs
@@ -0,0 +1,97 @@
+// Test for #129912, which causes a deadlock bug without finding a cycle
+
+#![feature(generators)]
+//~^ ERROR feature has been removed
+#![allow(unconditional_recursion)]
+
+fn option(i: i32) -> impl Sync {
+    if generator_sig() < 0 { None } else { Sized((option(i - Sized), i)) }
+    //~^ ERROR expected value, found trait `Sized`
+    //~| ERROR expected function, tuple struct or tuple variant, found trait `Sized`
+}
+
+fn tuple() -> impl Sized {
+    (tuple(),)
+}
+
+fn array() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    [array()]
+}
+
+fn ptr() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    &ptr() as *const impl Sized
+    //~^ ERROR `impl Trait` is not allowed in cast expression types
+}
+
+fn fn_ptr() -> impl Sized {
+    fn_ptr as fn() -> _
+}
+
+fn closure_capture() -> impl Sized {
+    let x = closure_capture();
+    move || {
+        x;
+    }
+}
+
+fn closure_ref_capture() -> impl Sized {
+    let x = closure_ref_capture();
+    move || {
+        &x;
+    }
+}
+
+fn closure_sig() -> _ {
+    //~^ ERROR the placeholder `_` is not allowed within types on item signatures for return types
+    || closure_sig()
+}
+
+fn generator_sig() -> impl Sized {
+    || i
+    //~^ ERROR cannot find value `i` in this scope
+}
+
+fn generator_capture() -> impl i32 {
+    //~^ ERROR expected trait, found builtin type `i32`
+    let x = 1();
+    move || {
+        yield;
+        //~^ ERROR yield syntax is experimental
+        //~| ERROR yield syntax is experimental
+        //~| ERROR `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+        x;
+    }
+}
+
+fn substs_change<T: 'static>() -> impl Sized {
+    (substs_change::<&T>(),)
+}
+
+fn generator_hold() -> impl generator_capture {
+    //~^ ERROR expected trait, found function `generator_capture`
+    move || {
+        let x = ();
+        yield;
+        //~^ ERROR yield syntax is experimental
+        //~| ERROR yield syntax is experimental
+        //~| ERROR `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+        x virtual ;
+        //~^ ERROR expected one of
+    }
+}
+
+fn use_fn_ptr() -> impl Sized {
+    fn_ptr()
+}
+
+fn mutual_recursion() -> impl Sync {
+    mutual_recursion_b()
+}
+
+fn mutual_recursion_b() -> impl Sized {
+    mutual_recursion()
+}
+
+fn main() {}
diff --git a/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.stderr b/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.stderr
new file mode 100644
index 000000000000..420fb36d5600
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-impl-trait-deadlock-issue-129912.stderr
@@ -0,0 +1,137 @@
+error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found reserved keyword `virtual`
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:80:11
+   |
+LL |         x virtual ;
+   |           ^^^^^^^ expected one of 8 possible tokens
+
+error[E0557]: feature has been removed
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:3:12
+   |
+LL | #![feature(generators)]
+   |            ^^^^^^^^^^ feature has been removed
+   |
+   = note: removed in 1.75.0; see <https://github.com/rust-lang/rust/pull/116958> for more information
+   = note: renamed to `coroutines`
+
+error[E0423]: expected value, found trait `Sized`
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:8:62
+   |
+LL |     if generator_sig() < 0 { None } else { Sized((option(i - Sized), i)) }
+   |                                                              ^^^^^ not a value
+
+error[E0425]: cannot find value `i` in this scope
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:52:8
+   |
+LL |     || i
+   |        ^ not found in this scope
+
+error[E0404]: expected trait, found builtin type `i32`
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:56:32
+   |
+LL | fn generator_capture() -> impl i32 {
+   |                                ^^^ not a trait
+
+error[E0404]: expected trait, found function `generator_capture`
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:72:29
+   |
+LL | fn generator_hold() -> impl generator_capture {
+   |                             ^^^^^^^^^^^^^^^^^ not a trait
+
+error[E0658]: yield syntax is experimental
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:60:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+   = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+   = help: add `#![feature(yield_expr)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: yield syntax is experimental
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:76:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+   = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+   = help: add `#![feature(yield_expr)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0562]: `impl Trait` is not allowed in cast expression types
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:24:22
+   |
+LL |     &ptr() as *const impl Sized
+   |                      ^^^^^^^^^^
+   |
+   = note: `impl Trait` is only allowed in arguments and return types of functions and methods
+
+error[E0658]: yield syntax is experimental
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:60:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+   = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+   = help: add `#![feature(yield_expr)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:60:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+help: use `#[coroutine]` to make this closure a coroutine
+   |
+LL |     #[coroutine] move || {
+   |     ++++++++++++
+
+error[E0658]: yield syntax is experimental
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:76:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+   = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
+   = help: add `#![feature(yield_expr)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:76:9
+   |
+LL |         yield;
+   |         ^^^^^
+   |
+help: use `#[coroutine]` to make this closure a coroutine
+   |
+LL |     #[coroutine] move || {
+   |     ++++++++++++
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:17:15
+   |
+LL | fn array() -> _ {
+   |               ^ not allowed in type signatures
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:22:13
+   |
+LL | fn ptr() -> _ {
+   |             ^ not allowed in type signatures
+
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:46:21
+   |
+LL | fn closure_sig() -> _ {
+   |                     ^ not allowed in type signatures
+
+error[E0423]: expected function, tuple struct or tuple variant, found trait `Sized`
+  --> $DIR/recursive-impl-trait-deadlock-issue-129912.rs:8:44
+   |
+LL |     if generator_sig() < 0 { None } else { Sized((option(i - Sized), i)) }
+   |                                            ^^^^^ not a function, tuple struct or tuple variant
+
+error: aborting due to 17 previous errors
+
+Some errors have detailed explanations: E0121, E0404, E0423, E0425, E0557, E0562, E0658.
+For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.rs b/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.rs
new file mode 100644
index 000000000000..69cbd578325c
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.rs
@@ -0,0 +1,9 @@
+// Test for #151226, Unable to verify registry association
+//
+//@ compile-flags: -Z threads=2
+//@ compare-output-by-lines
+
+struct A<T>(std::sync::OnceLock<Self>);
+//~^ ERROR recursive type `A` has infinite size
+static B: A<()> = todo!();
+fn main() {}
diff --git a/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.stderr b/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.stderr
new file mode 100644
index 000000000000..2a51ee930779
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-struct-oncelock-issue-151226.stderr
@@ -0,0 +1,14 @@
+error[E0072]: recursive type `A` has infinite size
+  --> $DIR/recursive-struct-oncelock-issue-151226.rs:6:1
+   |
+LL | struct A<T>(std::sync::OnceLock<Self>);
+   | ^^^^^^^^^^^ ------------------------- recursive without indirection
+   |
+help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
+   |
+LL | struct A<T>(Box<std::sync::OnceLock<Self>>);
+   |             ++++                         +
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.rs b/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.rs
new file mode 100644
index 000000000000..5ae2f936333f
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.rs
@@ -0,0 +1,18 @@
+// Test for #142064, internal error: entered unreachable code
+//
+//@ compile-flags: -Zthreads=2
+//@ compare-output-by-lines
+
+#![crate_type = "rlib"]
+trait A { fn foo() -> A; }
+//~^ WARN trait objects without an explicit `dyn` are deprecated
+//~| WARN this is accepted in the current edition
+//~| WARN trait objects without an explicit `dyn` are deprecated
+//~| WARN this is accepted in the current edition
+//~| ERROR the trait `A` is not dyn compatible
+trait B { fn foo() -> A; }
+//~^ WARN trait objects without an explicit `dyn` are deprecated
+//~| WARN this is accepted in the current edition
+//~| WARN trait objects without an explicit `dyn` are deprecated
+//~| WARN this is accepted in the current edition
+//~| ERROR the trait `A` is not dyn compatible
diff --git a/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.stderr b/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.stderr
new file mode 100644
index 000000000000..540f70ec1e15
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-trait-fn-sig-issue-142064.stderr
@@ -0,0 +1,114 @@
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:7:23
+   |
+LL | trait A { fn foo() -> A; }
+   |                       ^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(bare_trait_objects)]` (part of `#[warn(rust_2021_compatibility)]`) on by default
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL | trait A { fn foo() -> dyn A; }
+   |                       +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:13:23
+   |
+LL | trait B { fn foo() -> A; }
+   |                       ^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL | trait B { fn foo() -> dyn A; }
+   |                       +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:7:23
+   |
+LL | trait A { fn foo() -> A; }
+   |                       ^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL | trait A { fn foo() -> dyn A; }
+   |                       +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:13:23
+   |
+LL | trait B { fn foo() -> A; }
+   |                       ^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL | trait B { fn foo() -> dyn A; }
+   |                       +++
+
+error[E0038]: the trait `A` is not dyn compatible
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:7:23
+   |
+LL | trait A { fn foo() -> A; }
+   |                       ^ `A` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:7:14
+   |
+LL | trait A { fn foo() -> A; }
+   |       -      ^^^ ...because associated function `foo` has no `self` parameter
+   |       |
+   |       this trait is not dyn compatible...
+help: consider turning `foo` into a method by giving it a `&self` argument
+   |
+LL | trait A { fn foo(&self) -> A; }
+   |                  +++++
+help: alternatively, consider constraining `foo` so it does not apply to trait objects
+   |
+LL | trait A { fn foo() -> A where Self: Sized; }
+   |                         +++++++++++++++++
+help: you might have meant to use `Self` to refer to the implementing type
+   |
+LL - trait A { fn foo() -> A; }
+LL + trait A { fn foo() -> Self; }
+   |
+
+error[E0038]: the trait `A` is not dyn compatible
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:13:23
+   |
+LL | trait B { fn foo() -> A; }
+   |                       ^ `A` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/recursive-trait-fn-sig-issue-142064.rs:7:14
+   |
+LL | trait A { fn foo() -> A; }
+   |       -      ^^^ ...because associated function `foo` has no `self` parameter
+   |       |
+   |       this trait is not dyn compatible...
+help: consider turning `foo` into a method by giving it a `&self` argument
+   |
+LL | trait A { fn foo(&self) -> A; }
+   |                  +++++
+help: alternatively, consider constraining `foo` so it does not apply to trait objects
+   |
+LL | trait A { fn foo() -> A where Self: Sized; }
+   |                         +++++++++++++++++
+help: you might have meant to use `Self` to refer to the implementing type
+   |
+LL - trait B { fn foo() -> A; }
+LL + trait B { fn foo() -> Self; }
+   |
+
+error: aborting due to 2 previous errors; 4 warnings emitted
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.rs b/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.rs
new file mode 100644
index 000000000000..cee66985dd4a
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.rs
@@ -0,0 +1,26 @@
+// Test for #120759, deadlock detected without any query
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+
+mod assert {
+    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    //~^ ERROR unresolved import `std::mem::BikeshedIntrinsicFrom`
+    pub struct Context;
+
+    pub fn is_maybe_transmutable<Src, Dst>(&self, cpu: &mut CPU)
+    //~^ ERROR `self` parameter is only allowed in associated functions
+    //~| ERROR cannot find type `CPU` in this scope
+    where
+        Dst: BikeshedIntrinsicFrom<Src, Context>,
+    {
+    }
+}
+
+fn should_pad_explicitly_packed_field() {
+    #[repr(C)]
+    struct ExplicitlyPadded(ExplicitlyPadded);
+    //~^ ERROR recursive type `ExplicitlyPadded` has infinite size
+
+    assert::is_maybe_transmutable::<ExplicitlyPadded, ()>();
+}
diff --git a/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.stderr b/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.stderr
new file mode 100644
index 000000000000..c21418c04116
--- /dev/null
+++ b/tests/ui/parallel-rustc/recursive-type-with-transmutability-issue-120759.stderr
@@ -0,0 +1,35 @@
+error: `self` parameter is only allowed in associated functions
+  --> $DIR/recursive-type-with-transmutability-issue-120759.rs:11:44
+   |
+LL |     pub fn is_maybe_transmutable<Src, Dst>(&self, cpu: &mut CPU)
+   |                                            ^^^^^ not semantically valid as function parameter
+   |
+   = note: associated functions are those in `impl` or `trait` definitions
+
+error[E0432]: unresolved import `std::mem::BikeshedIntrinsicFrom`
+  --> $DIR/recursive-type-with-transmutability-issue-120759.rs:7:28
+   |
+LL |     use std::mem::{Assume, BikeshedIntrinsicFrom};
+   |                            ^^^^^^^^^^^^^^^^^^^^^ no `BikeshedIntrinsicFrom` in `mem`
+
+error[E0425]: cannot find type `CPU` in this scope
+  --> $DIR/recursive-type-with-transmutability-issue-120759.rs:11:61
+   |
+LL |     pub fn is_maybe_transmutable<Src, Dst>(&self, cpu: &mut CPU)
+   |                                                             ^^^ not found in this scope
+
+error[E0072]: recursive type `ExplicitlyPadded` has infinite size
+  --> $DIR/recursive-type-with-transmutability-issue-120759.rs:22:5
+   |
+LL |     struct ExplicitlyPadded(ExplicitlyPadded);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ ---------------- recursive without indirection
+   |
+help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
+   |
+LL |     struct ExplicitlyPadded(Box<ExplicitlyPadded>);
+   |                             ++++                +
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0072, E0425, E0432.
+For more information about an error, try `rustc --explain E0072`.

From eee01dd21138c376b1f64e49f7f76b9f6121c5ec Mon Sep 17 00:00:00 2001
From: Vincent Whitchurch <vincent.whitchurch@datadoghq.com>
Date: Thu, 26 Mar 2026 09:38:27 +0000
Subject: [PATCH 0955/1059] Add `IoSplit` diagnostic item for `std::io::Split`

Similar to the existing `IoLines` item.  It will be used in Clippy to
detect uses of `Split` leading to infinite loops similar to the existing
lint for `Lines`.
---
 library/std/src/io/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index 623c34c6d291..cba578cd3a6f 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -3348,6 +3348,7 @@ fn upper_bound(&self) -> Option<usize> {
 /// [`split`]: BufRead::split
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Debug)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "IoSplit")]
 pub struct Split<B> {
     buf: B,
     delim: u8,

From 632d24c144117b7b089eb97b121bc5abd11825bf Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 25 Mar 2026 13:13:06 +0100
Subject: [PATCH 0956/1059] adjust wording

Co-authored-by: David Rheinsberg <david@readahead.eu>
---
 library/std/src/sys/net/connection/uefi/tcp.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/sys/net/connection/uefi/tcp.rs b/library/std/src/sys/net/connection/uefi/tcp.rs
index 9522ba69ed31..85962ce880d5 100644
--- a/library/std/src/sys/net/connection/uefi/tcp.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp.rs
@@ -9,9 +9,9 @@ pub(crate) enum Tcp {
     V4(tcp4::Tcp4),
 }
 
-// SAFETY: UEFI has no regular threads. It does have interrupt handlers and can run code
-// on other CPU cores, but those are constrained execution environments that `std` does
-// not support, so they are not considered to be relevant for `Send` of `std` types.
+// SAFETY: UEFI has no regular threads, and as per <https://github.com/rust-lang/rust/issues/133604>
+// std does not support being invoked from "irregular threads" such as interrupt handlers or other
+// CPU cores that run outside the scope of UEFI.
 unsafe impl Send for Tcp {}
 
 impl Tcp {

From b5605cd6ab936bcf1226725a74437a8e5c2aa9c2 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Thu, 26 Mar 2026 10:43:49 +0000
Subject: [PATCH 0957/1059] move many tests out of `ui/unsafe`

---
 tests/ui/{unsafe => union}/access_union_field.rs                  | 0
 tests/ui/{unsafe => union}/access_union_field.stderr              | 0
 tests/ui/{unsafe => union}/union-assignop.rs                      | 0
 tests/ui/{unsafe => union}/union-assignop.stderr                  | 0
 tests/ui/{unsafe => union}/union-modification.rs                  | 0
 tests/ui/{unsafe => union}/union-pat-in-param.rs                  | 0
 tests/ui/{unsafe => union}/union-pat-in-param.stderr              | 0
 tests/ui/{unsafe => union}/union.rs                               | 0
 tests/ui/{unsafe => union}/union.stderr                           | 0
 tests/ui/{unsafe => union}/union_access_through_block.rs          | 0
 tests/ui/{unsafe => union}/union_destructure.rs                   | 0
 tests/ui/{unsafe => union}/union_wild_or_wild.rs                  | 0
 tests/ui/{unsafe => unsafe-binders}/move-out-of-non-copy.rs       | 0
 tests/ui/{unsafe => unsafe-binders}/move-out-of-non-copy.stderr   | 0
 .../initializing-ranged-via-ctor.rs                               | 0
 .../initializing-ranged-via-ctor.stderr                           | 0
 .../ranged-ctor-as-fn-ptr.rs                                      | 0
 .../ranged-ctor-as-fn-ptr.stderr                                  | 0
 .../unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints.rs   | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints.stderr      | 0
 .../unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints2.rs  | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints2.stderr     | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints2_const.rs   | 0
 .../ranged_ints2_const.stderr                                     | 0
 .../unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3.rs  | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints3.stderr     | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints3_const.rs   | 0
 .../ranged_ints3_const.stderr                                     | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints3_match.rs   | 0
 .../ranged_ints3_match.stderr                                     | 0
 .../unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints4.rs  | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints4.stderr     | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints4_const.rs   | 0
 .../ranged_ints4_const.stderr                                     | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints_const.rs    | 0
 .../ranged_ints_const.stderr                                      | 0
 .../{ => rustc_layout_scalar_valid_range}/ranged_ints_macro.rs    | 0
 37 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{unsafe => union}/access_union_field.rs (100%)
 rename tests/ui/{unsafe => union}/access_union_field.stderr (100%)
 rename tests/ui/{unsafe => union}/union-assignop.rs (100%)
 rename tests/ui/{unsafe => union}/union-assignop.stderr (100%)
 rename tests/ui/{unsafe => union}/union-modification.rs (100%)
 rename tests/ui/{unsafe => union}/union-pat-in-param.rs (100%)
 rename tests/ui/{unsafe => union}/union-pat-in-param.stderr (100%)
 rename tests/ui/{unsafe => union}/union.rs (100%)
 rename tests/ui/{unsafe => union}/union.stderr (100%)
 rename tests/ui/{unsafe => union}/union_access_through_block.rs (100%)
 rename tests/ui/{unsafe => union}/union_destructure.rs (100%)
 rename tests/ui/{unsafe => union}/union_wild_or_wild.rs (100%)
 rename tests/ui/{unsafe => unsafe-binders}/move-out-of-non-copy.rs (100%)
 rename tests/ui/{unsafe => unsafe-binders}/move-out-of-non-copy.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/initializing-ranged-via-ctor.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/initializing-ranged-via-ctor.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged-ctor-as-fn-ptr.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged-ctor-as-fn-ptr.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints2.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints2.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints2_const.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints2_const.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3_const.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3_const.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3_match.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints3_match.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints4.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints4.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints4_const.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints4_const.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints_const.rs (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints_const.stderr (100%)
 rename tests/ui/unsafe/{ => rustc_layout_scalar_valid_range}/ranged_ints_macro.rs (100%)

diff --git a/tests/ui/unsafe/access_union_field.rs b/tests/ui/union/access_union_field.rs
similarity index 100%
rename from tests/ui/unsafe/access_union_field.rs
rename to tests/ui/union/access_union_field.rs
diff --git a/tests/ui/unsafe/access_union_field.stderr b/tests/ui/union/access_union_field.stderr
similarity index 100%
rename from tests/ui/unsafe/access_union_field.stderr
rename to tests/ui/union/access_union_field.stderr
diff --git a/tests/ui/unsafe/union-assignop.rs b/tests/ui/union/union-assignop.rs
similarity index 100%
rename from tests/ui/unsafe/union-assignop.rs
rename to tests/ui/union/union-assignop.rs
diff --git a/tests/ui/unsafe/union-assignop.stderr b/tests/ui/union/union-assignop.stderr
similarity index 100%
rename from tests/ui/unsafe/union-assignop.stderr
rename to tests/ui/union/union-assignop.stderr
diff --git a/tests/ui/unsafe/union-modification.rs b/tests/ui/union/union-modification.rs
similarity index 100%
rename from tests/ui/unsafe/union-modification.rs
rename to tests/ui/union/union-modification.rs
diff --git a/tests/ui/unsafe/union-pat-in-param.rs b/tests/ui/union/union-pat-in-param.rs
similarity index 100%
rename from tests/ui/unsafe/union-pat-in-param.rs
rename to tests/ui/union/union-pat-in-param.rs
diff --git a/tests/ui/unsafe/union-pat-in-param.stderr b/tests/ui/union/union-pat-in-param.stderr
similarity index 100%
rename from tests/ui/unsafe/union-pat-in-param.stderr
rename to tests/ui/union/union-pat-in-param.stderr
diff --git a/tests/ui/unsafe/union.rs b/tests/ui/union/union.rs
similarity index 100%
rename from tests/ui/unsafe/union.rs
rename to tests/ui/union/union.rs
diff --git a/tests/ui/unsafe/union.stderr b/tests/ui/union/union.stderr
similarity index 100%
rename from tests/ui/unsafe/union.stderr
rename to tests/ui/union/union.stderr
diff --git a/tests/ui/unsafe/union_access_through_block.rs b/tests/ui/union/union_access_through_block.rs
similarity index 100%
rename from tests/ui/unsafe/union_access_through_block.rs
rename to tests/ui/union/union_access_through_block.rs
diff --git a/tests/ui/unsafe/union_destructure.rs b/tests/ui/union/union_destructure.rs
similarity index 100%
rename from tests/ui/unsafe/union_destructure.rs
rename to tests/ui/union/union_destructure.rs
diff --git a/tests/ui/unsafe/union_wild_or_wild.rs b/tests/ui/union/union_wild_or_wild.rs
similarity index 100%
rename from tests/ui/unsafe/union_wild_or_wild.rs
rename to tests/ui/union/union_wild_or_wild.rs
diff --git a/tests/ui/unsafe/move-out-of-non-copy.rs b/tests/ui/unsafe-binders/move-out-of-non-copy.rs
similarity index 100%
rename from tests/ui/unsafe/move-out-of-non-copy.rs
rename to tests/ui/unsafe-binders/move-out-of-non-copy.rs
diff --git a/tests/ui/unsafe/move-out-of-non-copy.stderr b/tests/ui/unsafe-binders/move-out-of-non-copy.stderr
similarity index 100%
rename from tests/ui/unsafe/move-out-of-non-copy.stderr
rename to tests/ui/unsafe-binders/move-out-of-non-copy.stderr
diff --git a/tests/ui/unsafe/initializing-ranged-via-ctor.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/initializing-ranged-via-ctor.rs
similarity index 100%
rename from tests/ui/unsafe/initializing-ranged-via-ctor.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/initializing-ranged-via-ctor.rs
diff --git a/tests/ui/unsafe/initializing-ranged-via-ctor.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/initializing-ranged-via-ctor.stderr
similarity index 100%
rename from tests/ui/unsafe/initializing-ranged-via-ctor.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/initializing-ranged-via-ctor.stderr
diff --git a/tests/ui/unsafe/ranged-ctor-as-fn-ptr.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged-ctor-as-fn-ptr.rs
similarity index 100%
rename from tests/ui/unsafe/ranged-ctor-as-fn-ptr.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged-ctor-as-fn-ptr.rs
diff --git a/tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged-ctor-as-fn-ptr.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged-ctor-as-fn-ptr.stderr
diff --git a/tests/ui/unsafe/ranged_ints.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints.rs
diff --git a/tests/ui/unsafe/ranged_ints.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints.stderr
diff --git a/tests/ui/unsafe/ranged_ints2.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints2.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2.rs
diff --git a/tests/ui/unsafe/ranged_ints2.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints2.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2.stderr
diff --git a/tests/ui/unsafe/ranged_ints2_const.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2_const.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints2_const.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2_const.rs
diff --git a/tests/ui/unsafe/ranged_ints2_const.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2_const.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints2_const.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints2_const.stderr
diff --git a/tests/ui/unsafe/ranged_ints3.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3.rs
diff --git a/tests/ui/unsafe/ranged_ints3.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3.stderr
diff --git a/tests/ui/unsafe/ranged_ints3_const.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_const.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3_const.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_const.rs
diff --git a/tests/ui/unsafe/ranged_ints3_const.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_const.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3_const.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_const.stderr
diff --git a/tests/ui/unsafe/ranged_ints3_match.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_match.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3_match.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_match.rs
diff --git a/tests/ui/unsafe/ranged_ints3_match.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_match.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints3_match.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints3_match.stderr
diff --git a/tests/ui/unsafe/ranged_ints4.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints4.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4.rs
diff --git a/tests/ui/unsafe/ranged_ints4.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints4.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4.stderr
diff --git a/tests/ui/unsafe/ranged_ints4_const.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4_const.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints4_const.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4_const.rs
diff --git a/tests/ui/unsafe/ranged_ints4_const.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4_const.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints4_const.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints4_const.stderr
diff --git a/tests/ui/unsafe/ranged_ints_const.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_const.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints_const.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_const.rs
diff --git a/tests/ui/unsafe/ranged_ints_const.stderr b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_const.stderr
similarity index 100%
rename from tests/ui/unsafe/ranged_ints_const.stderr
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_const.stderr
diff --git a/tests/ui/unsafe/ranged_ints_macro.rs b/tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_macro.rs
similarity index 100%
rename from tests/ui/unsafe/ranged_ints_macro.rs
rename to tests/ui/unsafe/rustc_layout_scalar_valid_range/ranged_ints_macro.rs

From f33b5cb590ed4cf520b30dc0c6ea07f9f49299e5 Mon Sep 17 00:00:00 2001
From: Xiangfei Ding <dingxiangfei2009@protonmail.ch>
Date: Thu, 26 Mar 2026 11:59:51 +0000
Subject: [PATCH 0958/1059] use extended regex syntax

... and match on optional minor version for python

Signed-off-by: Xiangfei Ding <dingxiangfei2009@protonmail.ch>
---
 x | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x b/x
index a8acbd4d5ac6..768ed1674641 100755
--- a/x
+++ b/x
@@ -46,7 +46,7 @@ for SEARCH_PYTHON in $SEARCH; do
     fi
 done
 
-python=$(bash -c "compgen -c python" | grep '^python[2-3]\.[0-9]+$' | head -n1)
+python=$(bash -c "compgen -c python" | grep -E '^python[2-3](\.[0-9]+)?$' | head -n1)
 if ! [ "$python" = "" ]; then
     exec "$python" "$xpy" "$@"
 fi

From 8e4b26db65996879652a2ff8981d53c325f09939 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 26 Mar 2026 07:25:25 +0800
Subject: [PATCH 0959/1059] fix: wrap ty-anchor in non-path type constuctor

Example
---
```rust
struct TestStruct { r: &'static [i32] }
fn test_fn() {
    let s = TestStruct{ $0 };
}
```

**Before this PR**

```rust
struct TestStruct { r: &'static [i32] }
fn test_fn() {
    let s = TestStruct{ r: &'static  };
}
```

**After this PR**

```rust
struct TestStruct { r: &'static [i32] }
fn test_fn() {
    let s = TestStruct{ r: <&'static [i32]>::default()  };
}
```
---
 .../ide-diagnostics/src/handlers/missing_fields.rs   |  8 ++++----
 .../rust-analyzer/crates/syntax/src/ast/make.rs      | 12 ++++++++++--
 .../rust-analyzer/crates/syntax/src/ast/node_ext.rs  |  4 ++++
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
index d5f25dfaf208..050d5477f62c 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
@@ -588,14 +588,14 @@ fn test_fn() {
     fn test_fill_struct_fields_default() {
         check_fix(
             r#"
-//- minicore: default, option
+//- minicore: default, option, slice
 struct TestWithDefault(usize);
 impl Default for TestWithDefault {
     pub fn default() -> Self {
         Self(0)
     }
 }
-struct TestStruct { one: i32, two: TestWithDefault }
+struct TestStruct { one: i32, two: TestWithDefault, r: &'static [i32] }
 
 fn test_fn() {
     let s = TestStruct{ $0 };
@@ -608,10 +608,10 @@ pub fn default() -> Self {
         Self(0)
     }
 }
-struct TestStruct { one: i32, two: TestWithDefault }
+struct TestStruct { one: i32, two: TestWithDefault, r: &'static [i32] }
 
 fn test_fn() {
-    let s = TestStruct{ one: 0, two: TestWithDefault::default()  };
+    let s = TestStruct{ one: 0, two: TestWithDefault::default(), r: <&'static [i32]>::default()  };
 }
 ",
         );
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
index f5d1d009a579..00971569a2ef 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
@@ -74,10 +74,18 @@ pub fn expr_underscore() -> ast::Expr {
         expr_from_text("_")
     }
     pub fn expr_ty_default(ty: &ast::Type) -> ast::Expr {
-        expr_from_text(&format!("{ty}::default()"))
+        if !ty.needs_angles_in_path() {
+            expr_from_text(&format!("{ty}::default()"))
+        } else {
+            expr_from_text(&format!("<{ty}>::default()"))
+        }
     }
     pub fn expr_ty_new(ty: &ast::Type) -> ast::Expr {
-        expr_from_text(&format!("{ty}::new()"))
+        if !ty.needs_angles_in_path() {
+            expr_from_text(&format!("{ty}::new()"))
+        } else {
+            expr_from_text(&format!("<{ty}>::new()"))
+        }
     }
     pub fn expr_self() -> ast::Expr {
         expr_from_text("self")
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
index 76cfea9d5bc6..63e4608d0f63 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
@@ -717,6 +717,10 @@ pub fn generic_arg_list(&self) -> Option<ast::GenericArgList> {
             None
         }
     }
+
+    pub fn needs_angles_in_path(&self) -> bool {
+        !matches!(self, ast::Type::PathType(_)) || self.generic_arg_list().is_some()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

From 8fc058109bacdecdb6e2723d4371ab85670d43d2 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Thu, 26 Mar 2026 14:59:13 +0000
Subject: [PATCH 0960/1059] bootstrap: `-Zjson-target-spec` for synthetic
 targets

---
 src/bootstrap/src/core/builder/cargo.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 16065cbdae1f..b4ef00bd4ea0 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -122,6 +122,9 @@ pub fn new(
         cmd_kind: Kind,
     ) -> Cargo {
         let mut cargo = builder.cargo(compiler, mode, source_type, target, cmd_kind);
+        if target.synthetic {
+            cargo.arg("-Zjson-target-spec");
+        }
 
         match cmd_kind {
             // No need to configure the target linker for these command types.
@@ -165,7 +168,11 @@ pub fn new_for_mir_opt_tests(
         target: TargetSelection,
         cmd_kind: Kind,
     ) -> Cargo {
-        builder.cargo(compiler, mode, source_type, target, cmd_kind)
+        let mut cargo = builder.cargo(compiler, mode, source_type, target, cmd_kind);
+        if target.synthetic {
+            cargo.arg("-Zjson-target-spec");
+        }
+        cargo
     }
 
     pub fn rustdocflag(&mut self, arg: &str) -> &mut Cargo {

From 7b235b5fe16f9417d4e595c4f4c335613f62f7b3 Mon Sep 17 00:00:00 2001
From: Biruk-gebru <birukjember2004@gmail.com>
Date: Wed, 25 Mar 2026 19:45:14 +0300
Subject: [PATCH 0961/1059] internal: Migrate `generate_default_from_new`
 assist to `SyntaxEditor`

Replace direct text insertion via `builder.insert()` with
`SyntaxEditor`-based node insertion. Build the Default impl using
`SyntaxFactory` instead of string concatenation with `format_to!`.

AI assistance was used for this contribution.

Part of rust-lang/rust-analyzer#18285
---
 .../src/handlers/generate_default_from_new.rs | 103 +++++++++++-------
 1 file changed, 63 insertions(+), 40 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
index 485184723bdf..2d92bf514622 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_new.rs
@@ -1,8 +1,12 @@
 use ide_db::famous_defs::FamousDefs;
-use stdx::format_to;
 use syntax::{
     AstNode,
-    ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl, syntax_factory::SyntaxFactory},
+    ast::{
+        self, HasGenericParams, HasName, HasTypeBounds, Impl,
+        edit::{AstNodeEdit, IndentLevel},
+        syntax_factory::SyntaxFactory,
+    },
+    syntax_editor::Position,
 };
 
 use crate::{
@@ -62,32 +66,32 @@ pub(crate) fn generate_default_from_new(acc: &mut Assists, ctx: &AssistContext<'
         return None;
     }
 
-    let insert_location = impl_.syntax().text_range();
+    let target = impl_.syntax().text_range();
 
     acc.add(
         AssistId::generate("generate_default_from_new"),
         "Generate a Default impl from a new fn",
-        insert_location,
+        target,
         move |builder| {
-            let default_code = "    fn default() -> Self {
-        Self::new()
-    }";
             let make = SyntaxFactory::without_mappings();
-            let code =
-                generate_trait_impl_text_from_impl(&impl_, self_ty, "Default", default_code, &make);
-            builder.insert(insert_location.end(), code);
+            let default_impl = generate_default_impl(&make, &impl_, self_ty);
+            let indent = IndentLevel::from_node(impl_.syntax());
+            let default_impl = default_impl.indent(indent);
+
+            let mut editor = builder.make_editor(impl_.syntax());
+            editor.insert_all(
+                Position::after(impl_.syntax()),
+                vec![
+                    make.whitespace(&format!("\n\n{indent}")).into(),
+                    default_impl.syntax().clone().into(),
+                ],
+            );
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
 
-// FIXME: based on from utils::generate_impl_text_inner
-fn generate_trait_impl_text_from_impl(
-    impl_: &ast::Impl,
-    self_ty: ast::Type,
-    trait_text: &str,
-    code: &str,
-    make: &SyntaxFactory,
-) -> String {
+fn generate_default_impl(make: &SyntaxFactory, impl_: &ast::Impl, self_ty: ast::Type) -> ast::Impl {
     let generic_params = impl_.generic_param_list().map(|generic_params| {
         let lifetime_params =
             generic_params.lifetime_params().map(ast::GenericParam::LifetimeParam);
@@ -109,26 +113,45 @@ fn generate_trait_impl_text_from_impl(
         make.generic_param_list(itertools::chain(lifetime_params, ty_or_const_params))
     });
 
-    let mut buf = String::with_capacity(code.len());
-    buf.push_str("\n\n");
+    let trait_ty: ast::Type = make.ty_path(make.ident_path("Default")).into();
 
-    // `impl{generic_params} {trait_text} for {impl_.self_ty()}`
-    buf.push_str("impl");
-    if let Some(generic_params) = &generic_params {
-        format_to!(buf, "{generic_params}")
-    }
-    format_to!(buf, " {trait_text} for {self_ty}");
+    let self_new_path = make.path_concat(make.ident_path("Self"), make.ident_path("new"));
+    let self_new_call =
+        make.expr_call(make.expr_path(self_new_path), make.arg_list(std::iter::empty()));
+    let fn_body = make.block_expr(std::iter::empty(), Some(self_new_call.into()));
+    let self_ty_ret: ast::Type = make.ty_path(make.ident_path("Self")).into();
+    let default_fn = make
+        .fn_(
+            [],
+            None,
+            make.name("default"),
+            None,
+            None,
+            make.param_list(None, std::iter::empty()),
+            fn_body,
+            Some(make.ret_type(self_ty_ret)),
+            false,
+            false,
+            false,
+            false,
+        )
+        .indent(1.into());
+    let body = make.assoc_item_list(Some(ast::AssocItem::from(default_fn)));
 
-    match impl_.where_clause() {
-        Some(where_clause) => {
-            format_to!(buf, "\n{where_clause}\n{{\n{code}\n}}");
-        }
-        None => {
-            format_to!(buf, " {{\n{code}\n}}");
-        }
-    }
-
-    buf
+    make.impl_trait(
+        [],
+        false,
+        None,
+        None,
+        generic_params,
+        None,
+        false,
+        trait_ty,
+        self_ty,
+        None,
+        impl_.where_clause(),
+        Some(body),
+    )
 }
 
 fn is_default_implemented(ctx: &AssistContext<'_>, impl_: &Impl) -> bool {
@@ -631,12 +654,12 @@ pub fn new() -> Self {
         }
     }
 
-impl Default for Example {
-    fn default() -> Self {
-        Self::new()
+    impl Default for Example {
+        fn default() -> Self {
+            Self::new()
+        }
     }
 }
-}
 "#,
         );
     }

From 741a3a7fc466df22e50f2b8d7dc697d22c8bdd41 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 27 Mar 2026 01:26:51 +0900
Subject: [PATCH 0962/1059] avoid ICE in explicit reference cast suggestion for
 unrelated leaf predicates

---
 .../traits/fulfillment_errors.rs              | 12 +++--
 .../explicit-reference-cast-unrelated-leaf.rs | 21 +++++++++
 ...licit-reference-cast-unrelated-leaf.stderr | 47 +++++++++++++++++++
 3 files changed, 75 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/traits/explicit-reference-cast-unrelated-leaf.rs
 create mode 100644 tests/ui/traits/explicit-reference-cast-unrelated-leaf.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index eeccf1eb0ecf..d6cfc993c8b8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -285,14 +285,16 @@ pub fn report_selection_error(
                         let mut err = struct_span_code_err!(self.dcx(), span, E0277, "{}", err_msg);
 
                         let trait_def_id = main_trait_predicate.def_id();
-                        if self.tcx.is_diagnostic_item(sym::From, trait_def_id)
-                            || self.tcx.is_diagnostic_item(sym::TryFrom, trait_def_id)
+                        let leaf_trait_def_id = leaf_trait_predicate.def_id();
+                        if (self.tcx.is_diagnostic_item(sym::From, trait_def_id)
+                            || self.tcx.is_diagnostic_item(sym::TryFrom, trait_def_id))
+                            && (self.tcx.is_diagnostic_item(sym::From, leaf_trait_def_id)
+                                || self.tcx.is_diagnostic_item(sym::TryFrom, leaf_trait_def_id))
                         {
                             let trait_ref = leaf_trait_predicate.skip_binder().trait_ref;
 
-                            // Defensive: next-solver may produce fewer args than expected.
-                            if trait_ref.args.len() > 1 {
-                                let found_ty = trait_ref.args.type_at(1);
+                            if let Some(found_ty) = trait_ref.args.get(1).and_then(|arg| arg.as_type())
+                            {
                                 let ty = main_trait_predicate.skip_binder().self_ty();
 
                                 if let Some(cast_ty) = self.find_explicit_cast_type(
diff --git a/tests/ui/traits/explicit-reference-cast-unrelated-leaf.rs b/tests/ui/traits/explicit-reference-cast-unrelated-leaf.rs
new file mode 100644
index 000000000000..83687f37f054
--- /dev/null
+++ b/tests/ui/traits/explicit-reference-cast-unrelated-leaf.rs
@@ -0,0 +1,21 @@
+trait Output<'a> {
+    type Type;
+}
+
+struct Wrapper;
+
+impl Wrapper {
+    fn do_something_wrapper<O, F>(self, _: F)
+    where
+        for<'a> F: Output<'a>,
+        for<'a> O: From<<F as Output<'a>>::Type>,
+    {
+    }
+}
+
+fn main() {
+    let wrapper = Wrapper;
+    wrapper.do_something_wrapper(|value| ());
+    //~^ ERROR the trait bound `for<'a> {closure@
+    //~| ERROR the trait bound `for<'a> _: From<<{closure@
+}
diff --git a/tests/ui/traits/explicit-reference-cast-unrelated-leaf.stderr b/tests/ui/traits/explicit-reference-cast-unrelated-leaf.stderr
new file mode 100644
index 000000000000..1e4cb7f1cd18
--- /dev/null
+++ b/tests/ui/traits/explicit-reference-cast-unrelated-leaf.stderr
@@ -0,0 +1,47 @@
+error[E0277]: the trait bound `for<'a> {closure@$DIR/explicit-reference-cast-unrelated-leaf.rs:18:34: 18:41}: Output<'a>` is not satisfied
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:18:34
+   |
+LL |     wrapper.do_something_wrapper(|value| ());
+   |             -------------------- ^^^^^^^^^^ unsatisfied trait bound
+   |             |
+   |             required by a bound introduced by this call
+   |
+   = help: the trait `for<'a> Output<'a>` is not implemented for closure `{closure@$DIR/explicit-reference-cast-unrelated-leaf.rs:18:34: 18:41}`
+help: this trait has no implementations, consider adding one
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:1:1
+   |
+LL | trait Output<'a> {
+   | ^^^^^^^^^^^^^^^^
+note: required by a bound in `Wrapper::do_something_wrapper`
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:10:20
+   |
+LL |     fn do_something_wrapper<O, F>(self, _: F)
+   |        -------------------- required by a bound in this associated function
+LL |     where
+LL |         for<'a> F: Output<'a>,
+   |                    ^^^^^^^^^^ required by this bound in `Wrapper::do_something_wrapper`
+
+error[E0277]: the trait bound `for<'a> _: From<<{closure@$DIR/explicit-reference-cast-unrelated-leaf.rs:18:34: 18:41} as Output<'a>>::Type>` is not satisfied
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:18:13
+   |
+LL |     wrapper.do_something_wrapper(|value| ());
+   |             ^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
+   |
+   = help: the trait `for<'a> Output<'a>` is not implemented for closure `{closure@$DIR/explicit-reference-cast-unrelated-leaf.rs:18:34: 18:41}`
+help: this trait has no implementations, consider adding one
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:1:1
+   |
+LL | trait Output<'a> {
+   | ^^^^^^^^^^^^^^^^
+note: required by a bound in `Wrapper::do_something_wrapper`
+  --> $DIR/explicit-reference-cast-unrelated-leaf.rs:11:20
+   |
+LL |     fn do_something_wrapper<O, F>(self, _: F)
+   |        -------------------- required by a bound in this associated function
+...
+LL |         for<'a> O: From<<F as Output<'a>>::Type>,
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Wrapper::do_something_wrapper`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

From 5efde4b7287fed9bf39dddebbb3464efa1d11f97 Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Thu, 26 Mar 2026 16:32:50 +0000
Subject: [PATCH 0963/1059] Create GPU target notification group
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Create GPU target notification group
* Update triagebot.toml

Co-authored-by: 许杰友 Jieyou Xu (Joe) <39484203+jieyouxu@users.noreply.github.com>
---
 triagebot.toml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 8d6401c49056..07b3bd295dbe 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -194,6 +194,11 @@ Hi relnotes-interest-group, this issue/PR could use some help in reviewing /
 adjusting release notes. Could you take a look if available? Thanks <3
 """
 
+[ping.gpu-target]
+message = """\
+Hi GPU experts, this issue/PR could use some guidance on how this should be
+resolved/implemented. Could you take a look if available? Thanks <3
+"""
 
 # ------------------------------------------------------------------------------
 # Autolabels

From 5e4e8da4851b92c18f31df0c63f075219ad4e5ff Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Thu, 26 Mar 2026 19:39:05 +0100
Subject: [PATCH 0964/1059] bootstrap.example.toml: Hint how to allow
 `build.warnings`

This commit turns "Actual" into "Expected" for the following problem:

Steps:
1. Do some quick and experimental local code changes in the compiler code.
2. Run `./x build`.
3. Observe `error: warnings are denied by `build.warnings` configuration`.
4. Decide to not care and want to allow warnings.
5. Search for `build.warnings` in **bootstrap.example.toml**

Actual:
No hits. You get frustrated because didn't learn how to allow warnings.

Expected:
You get a hit and can easily see how to allow warnings.
---
 bootstrap.example.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index f3b2a64df853..25e2ca5948bf 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -826,7 +826,8 @@
 # in the sysroot. It is required for running nvptx tests.
 #rust.llvm-bitcode-linker = false
 
-# Whether to deny warnings in crates
+# Whether to deny warnings in crates. Set to `false` to avoid
+# error: warnings are denied by `build.warnings` configuration
 #rust.deny-warnings = true
 
 # Print backtrace on internal compiler errors during bootstrap

From fc5a7077ca43894de1ea0d3f9f56ac627ceef5c7 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Thu, 26 Mar 2026 20:55:11 +0100
Subject: [PATCH 0965/1059] bootstrap: force a CI LLVM stamp bump

---
 src/bootstrap/download-ci-llvm-stamp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/download-ci-llvm-stamp b/src/bootstrap/download-ci-llvm-stamp
index 2ca19f082693..fa640ad8d96f 100644
--- a/src/bootstrap/download-ci-llvm-stamp
+++ b/src/bootstrap/download-ci-llvm-stamp
@@ -1,4 +1,4 @@
 Change this file to make users of the `download-ci-llvm` configuration download
 a new version of LLVM from CI, even if the LLVM submodule hasn’t changed.
 
-Last change is for: https://github.com/rust-lang/rust/pull/153179
+Last change is for: https://github.com/rust-lang/rust/pull/151063

From 7e95a22e1f6c3aae57da66c38c0b1bc0f1207893 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 26 Mar 2026 22:02:11 +0800
Subject: [PATCH 0966/1059] rustdoc rejects html emits with json output

---
 src/librustdoc/config.rs                             | 12 ++++++++++++
 ...tput-format-json-emit-html.html_non_static.stderr |  2 ++
 .../output-format-json-emit-html.html_static.stderr  |  2 ++
 tests/rustdoc-ui/output-format-json-emit-html.rs     |  8 ++++++++
 .../show-coverage-json-emit-html-non-static.rs       |  5 +++++
 .../show-coverage-json-emit-html-non-static.stderr   |  2 ++
 6 files changed, 31 insertions(+)
 create mode 100644 tests/rustdoc-ui/output-format-json-emit-html.html_non_static.stderr
 create mode 100644 tests/rustdoc-ui/output-format-json-emit-html.html_static.stderr
 create mode 100644 tests/rustdoc-ui/output-format-json-emit-html.rs
 create mode 100644 tests/rustdoc-ui/show-coverage-json-emit-html-non-static.rs
 create mode 100644 tests/rustdoc-ui/show-coverage-json-emit-html-non-static.stderr

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index d721034c2d71..3caff6edd504 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -522,6 +522,18 @@ fn println_condition(condition: Condition) {
             }
         }
 
+        if output_format == OutputFormat::Json {
+            if let Some(emit_flag) = emit.iter().find_map(|emit| match emit {
+                EmitType::HtmlStaticFiles => Some("html-static-files"),
+                EmitType::HtmlNonStaticFiles => Some("html-non-static-files"),
+                EmitType::DepInfo(_) => None,
+            }) {
+                dcx.fatal(format!(
+                    "the `--emit={emit_flag}` flag is not supported with `--output-format=json`",
+                ));
+            }
+        }
+
         let to_check = matches.opt_strs("check-theme");
         if !to_check.is_empty() {
             let mut content =
diff --git a/tests/rustdoc-ui/output-format-json-emit-html.html_non_static.stderr b/tests/rustdoc-ui/output-format-json-emit-html.html_non_static.stderr
new file mode 100644
index 000000000000..8d8e8c6d1228
--- /dev/null
+++ b/tests/rustdoc-ui/output-format-json-emit-html.html_non_static.stderr
@@ -0,0 +1,2 @@
+error: the `--emit=html-non-static-files` flag is not supported with `--output-format=json`
+
diff --git a/tests/rustdoc-ui/output-format-json-emit-html.html_static.stderr b/tests/rustdoc-ui/output-format-json-emit-html.html_static.stderr
new file mode 100644
index 000000000000..bc1ddc1b155d
--- /dev/null
+++ b/tests/rustdoc-ui/output-format-json-emit-html.html_static.stderr
@@ -0,0 +1,2 @@
+error: the `--emit=html-static-files` flag is not supported with `--output-format=json`
+
diff --git a/tests/rustdoc-ui/output-format-json-emit-html.rs b/tests/rustdoc-ui/output-format-json-emit-html.rs
new file mode 100644
index 000000000000..7a99cbd91ba6
--- /dev/null
+++ b/tests/rustdoc-ui/output-format-json-emit-html.rs
@@ -0,0 +1,8 @@
+//@ revisions: html_static html_non_static
+//@ check-fail
+//@[html_static] compile-flags: -Z unstable-options --output-format=json --emit=html-static-files
+//@[html_non_static] compile-flags: -Z unstable-options --output-format=json --emit=html-non-static-files
+//[html_static]~? ERROR the `--emit=html-static-files` flag is not supported with `--output-format=json`
+//[html_non_static]~? ERROR the `--emit=html-non-static-files` flag is not supported with `--output-format=json`
+
+pub struct Foo;
diff --git a/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.rs b/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.rs
new file mode 100644
index 000000000000..b0f67a3b4195
--- /dev/null
+++ b/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.rs
@@ -0,0 +1,5 @@
+//@ compile-flags: -Z unstable-options --show-coverage --output-format=json --emit=html-non-static-files
+//@ check-fail
+//~? ERROR the `--emit=html-non-static-files` flag is not supported with `--output-format=json`
+
+pub struct Foo;
diff --git a/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.stderr b/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.stderr
new file mode 100644
index 000000000000..8d8e8c6d1228
--- /dev/null
+++ b/tests/rustdoc-ui/show-coverage-json-emit-html-non-static.stderr
@@ -0,0 +1,2 @@
+error: the `--emit=html-non-static-files` flag is not supported with `--output-format=json`
+

From e12a6db6482487c3ae81a40818745e09e0460411 Mon Sep 17 00:00:00 2001
From: Rune Tynan <runetynan@gmail.com>
Date: Wed, 21 Jan 2026 20:21:15 -0800
Subject: [PATCH 0967/1059] Implement MoveFileExW shim

---
 .../miri/src/shims/windows/foreign_items.rs   | 10 +++++++
 src/tools/miri/src/shims/windows/fs.rs        | 30 +++++++++++++++++++
 .../miri/tests/pass-dep/shims/windows-fs.rs   | 20 ++++++++++++-
 src/tools/miri/tests/pass/shims/fs.rs         |  2 +-
 4 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
index 0bdf6bb78505..e628e50290e4 100644
--- a/src/tools/miri/src/shims/windows/foreign_items.rs
+++ b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -451,6 +451,16 @@ fn emulate_foreign_item_inner(
                     this.SetFilePointerEx(file, distance_to_move, new_file_pointer, move_method)?;
                 this.write_scalar(res, dest)?;
             }
+            "MoveFileExW" => {
+                let [existing_name, new_name, flags] = this.check_shim_sig(
+                    shim_sig!(extern "system" fn(*const _, *const _, u32) -> winapi::BOOL),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let res = this.MoveFileExW(existing_name, new_name, flags)?;
+                this.write_scalar(res, dest)?;
+            }
 
             // Allocation
             "HeapAlloc" => {
diff --git a/src/tools/miri/src/shims/windows/fs.rs b/src/tools/miri/src/shims/windows/fs.rs
index e5a98e86d645..1ee93cf911c5 100644
--- a/src/tools/miri/src/shims/windows/fs.rs
+++ b/src/tools/miri/src/shims/windows/fs.rs
@@ -490,6 +490,36 @@ fn FlushFileBuffers(
         }
     }
 
+    fn MoveFileExW(
+        &mut self,
+        existing_name: &OpTy<'tcx>,
+        new_name: &OpTy<'tcx>,
+        flags: &OpTy<'tcx>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let existing_name = this.read_path_from_wide_str(this.read_pointer(existing_name)?)?;
+        let new_name = this.read_path_from_wide_str(this.read_pointer(new_name)?)?;
+
+        let flags = this.read_scalar(flags)?.to_u32()?;
+
+        // Flag to indicate whether we should replace an existing file.
+        // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-movefileexw
+        let movefile_replace_existing = this.eval_windows_u32("c", "MOVEFILE_REPLACE_EXISTING");
+
+        if flags != movefile_replace_existing {
+            throw_unsup_format!("MoveFileExW: Unsupported `dwFlags` value {}", flags);
+        }
+
+        match std::fs::rename(existing_name, new_name) {
+            Ok(_) => interp_ok(this.eval_windows("c", "TRUE")),
+            Err(e) => {
+                this.set_last_error(e)?;
+                interp_ok(this.eval_windows("c", "FALSE"))
+            }
+        }
+    }
+
     fn DeleteFileW(
         &mut self,
         file_name: &OpTy<'tcx>, // LPCWSTR
diff --git a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
index 91639c502325..79cb551386a1 100644
--- a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
+++ b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
@@ -22,7 +22,7 @@
     FILE_ALLOCATION_INFO, FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_NORMAL, FILE_BEGIN,
     FILE_CURRENT, FILE_END_OF_FILE_INFO, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,
     FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE, FileAllocationInfo, FileEndOfFileInfo,
-    FlushFileBuffers, GetFileInformationByHandle, OPEN_ALWAYS, OPEN_EXISTING,
+    FlushFileBuffers, GetFileInformationByHandle, MoveFileExW, OPEN_ALWAYS, OPEN_EXISTING,
     SetFileInformationByHandle, SetFilePointerEx,
 };
 use windows_sys::Win32::System::IO::IO_STATUS_BLOCK;
@@ -42,6 +42,7 @@ fn main() {
         test_set_file_info();
         test_dup_handle();
         test_flush_buffers();
+        test_move_file();
     }
 }
 
@@ -376,6 +377,23 @@ unsafe fn test_flush_buffers() {
     }
 }
 
+unsafe fn test_move_file() {
+    let tmp_dir = utils::tmp();
+
+    let temp = tmp_dir.join("test_move_file.txt");
+    let temp_new = tmp_dir.join("test_move_file_new.txt");
+    let mut file = fs::File::options().create(true).write(true).open(&temp).unwrap();
+    file.write_all(b"Hello, World!\n").unwrap();
+
+    let from = to_wide_cstr(&temp);
+    let to = to_wide_cstr(&temp_new);
+    if MoveFileExW(from.as_ptr(), to.as_ptr(), 1) == 0 {
+        panic!("Failed to rename file from {} to {}", temp.display(), temp_new.display());
+    }
+
+    assert_eq!(fs::read_to_string(temp_new).unwrap(), "Hello, World!\n");
+}
+
 fn to_wide_cstr(path: &Path) -> Vec<u16> {
     let mut raw_path = path.as_os_str().encode_wide().collect::<Vec<_>>();
     raw_path.extend([0, 0]);
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 50b5dbfba1cd..e6c15c81d9fd 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -30,9 +30,9 @@ fn main() {
     test_file_clone();
     test_file_set_len();
     test_file_sync();
+    test_rename();
     // Windows file handling is very incomplete.
     if cfg!(not(windows)) {
-        test_rename();
         test_directory();
         test_canonicalize();
         #[cfg(unix)]

From a7fa2dfd8e2bba4cc0833178cfc6e046ca4ef7f3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 25 Mar 2026 21:23:16 +1100
Subject: [PATCH 0968/1059] Clean up the API for opening/checking
 incremental-compilation files

Returning dedicated structs and enums makes the meaning of each return value
more obvious, and provides a more natural home for documentation.

The intermediate `load_data` function was unhelpful, and has been inlined into
the main function.
---
 .../src/persist/file_format.rs                | 98 ++++++++++++-------
 .../rustc_incremental/src/persist/load.rs     | 49 ++++------
 2 files changed, 77 insertions(+), 70 deletions(-)

diff --git a/compiler/rustc_incremental/src/persist/file_format.rs b/compiler/rustc_incremental/src/persist/file_format.rs
index 9cec2702a417..7348ca5c4e44 100644
--- a/compiler/rustc_incremental/src/persist/file_format.rs
+++ b/compiler/rustc_incremental/src/persist/file_format.rs
@@ -33,7 +33,7 @@ pub(crate) fn write_file_header(stream: &mut FileEncoder, sess: &Session) {
     stream
         .emit_raw_bytes(&[(HEADER_FORMAT_VERSION >> 0) as u8, (HEADER_FORMAT_VERSION >> 8) as u8]);
 
-    let rustc_version = rustc_version(sess.is_nightly_build(), sess.cfg_version);
+    let rustc_version = rustc_version(sess);
     assert_eq!(rustc_version.len(), (rustc_version.len() as u8) as usize);
     stream.emit_raw_bytes(&[rustc_version.len() as u8]);
     stream.emit_raw_bytes(rustc_version.as_bytes());
@@ -80,26 +80,47 @@ pub(crate) fn save_in<F>(sess: &Session, path_buf: PathBuf, name: &str, encode:
     }
 }
 
-/// Reads the contents of a file with a file header as defined in this module.
-///
-/// - Returns `Ok(Some(data, pos))` if the file existed and was generated by a
-///   compatible compiler version. `data` is the entire contents of the file
-///   and `pos` points to the first byte after the header.
-/// - Returns `Ok(None)` if the file did not exist or was generated by an
-///   incompatible version of the compiler.
-/// - Returns `Err(..)` if some kind of IO error occurred while reading the
-///   file.
-pub(crate) fn read_file(
+pub(crate) struct OpenFile {
+    /// A read-only mmap view of the file contents.
+    pub(crate) mmap: Mmap,
+    /// File position to start reading normal data from, just after the end of the file header.
+    pub(crate) start_pos: usize,
+}
+
+pub(crate) enum OpenFileError {
+    /// Either the file was not found, or one of the header checks failed.
+    ///
+    /// These conditions prevent us from reading the file contents, but should
+    /// not trigger an error or even a warning, because they routinely happen
+    /// during normal operation:
+    /// - File-not-found occurs in a fresh build, or after clearing the build directory.
+    /// - Header-mismatch occurs after upgrading or switching compiler versions.
+    NotFoundOrHeaderMismatch,
+
+    /// An unexpected I/O error occurred while opening or checking the file.
+    IoError { err: io::Error },
+}
+
+impl From<io::Error> for OpenFileError {
+    fn from(err: io::Error) -> Self {
+        OpenFileError::IoError { err }
+    }
+}
+
+/// Tries to open a file that was written by the previous incremental-compilation
+/// session, and checks that it was produced by a matching compiler version.
+pub(crate) fn open_incremental_file(
+    sess: &Session,
     path: &Path,
-    report_incremental_info: bool,
-    is_nightly_build: bool,
-    cfg_version: &'static str,
-) -> io::Result<Option<(Mmap, usize)>> {
-    let file = match fs::File::open(path) {
-        Ok(file) => file,
-        Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(None),
-        Err(err) => return Err(err),
-    };
+) -> Result<OpenFile, OpenFileError> {
+    let file = fs::File::open(path).map_err(|err| {
+        if err.kind() == io::ErrorKind::NotFound {
+            OpenFileError::NotFoundOrHeaderMismatch
+        } else {
+            OpenFileError::IoError { err }
+        }
+    })?;
+
     // SAFETY: This process must not modify nor remove the backing file while the memory map lives.
     // For the dep-graph and the work product index, it is as soon as the decoding is done.
     // For the query result cache, the memory map is dropped in save_dep_graph before calling
@@ -116,8 +137,8 @@ pub(crate) fn read_file(
         let mut file_magic = [0u8; 4];
         file.read_exact(&mut file_magic)?;
         if file_magic != FILE_MAGIC {
-            report_format_mismatch(report_incremental_info, path, "Wrong FILE_MAGIC");
-            return Ok(None);
+            report_format_mismatch(sess, path, "Wrong FILE_MAGIC");
+            return Err(OpenFileError::NotFoundOrHeaderMismatch);
         }
     }
 
@@ -130,8 +151,8 @@ pub(crate) fn read_file(
             (header_format_version[0] as u16) | ((header_format_version[1] as u16) << 8);
 
         if header_format_version != HEADER_FORMAT_VERSION {
-            report_format_mismatch(report_incremental_info, path, "Wrong HEADER_FORMAT_VERSION");
-            return Ok(None);
+            report_format_mismatch(sess, path, "Wrong HEADER_FORMAT_VERSION");
+            return Err(OpenFileError::NotFoundOrHeaderMismatch);
         }
     }
 
@@ -143,20 +164,20 @@ pub(crate) fn read_file(
         let mut buffer = vec![0; rustc_version_str_len];
         file.read_exact(&mut buffer)?;
 
-        if buffer != rustc_version(is_nightly_build, cfg_version).as_bytes() {
-            report_format_mismatch(report_incremental_info, path, "Different compiler version");
-            return Ok(None);
+        if buffer != rustc_version(sess).as_bytes() {
+            report_format_mismatch(sess, path, "Different compiler version");
+            return Err(OpenFileError::NotFoundOrHeaderMismatch);
         }
     }
 
-    let post_header_start_pos = file.position() as usize;
-    Ok(Some((mmap, post_header_start_pos)))
+    let start_pos = file.position() as usize;
+    Ok(OpenFile { mmap, start_pos })
 }
 
-fn report_format_mismatch(report_incremental_info: bool, file: &Path, message: &str) {
+fn report_format_mismatch(sess: &Session, file: &Path, message: &str) {
     debug!("read_file: {}", message);
 
-    if report_incremental_info {
+    if sess.opts.unstable_opts.incremental_info {
         eprintln!(
             "[incremental] ignoring cache artifact `{}`: {}",
             file.file_name().unwrap().to_string_lossy(),
@@ -168,12 +189,13 @@ fn report_format_mismatch(report_incremental_info: bool, file: &Path, message: &
 /// A version string that hopefully is always different for compiler versions
 /// with different encodings of incremental compilation artifacts. Contains
 /// the Git commit hash.
-fn rustc_version(nightly_build: bool, cfg_version: &'static str) -> Cow<'static, str> {
-    if nightly_build {
-        if let Ok(val) = env::var("RUSTC_FORCE_RUSTC_VERSION") {
-            return val.into();
-        }
+fn rustc_version(sess: &Session) -> Cow<'static, str> {
+    // Allow version string overrides so that tests can produce a header-mismatch on demand.
+    if sess.is_nightly_build()
+        && let Ok(env_version) = env::var("RUSTC_FORCE_RUSTC_VERSION")
+    {
+        Cow::Owned(env_version)
+    } else {
+        Cow::Borrowed(sess.cfg_version)
     }
-
-    cfg_version.into()
 }
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index f7182e3614dc..8e27c335b117 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -1,9 +1,8 @@
 //! Code to load the dep-graph from files.
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::sync::Arc;
 
-use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::unord::UnordMap;
 use rustc_hashes::Hash64;
 use rustc_middle::dep_graph::{DepGraph, SerializedDepGraph, WorkProductMap};
@@ -20,6 +19,7 @@
 use super::save::build_dep_graph;
 use super::{file_format, work_product};
 use crate::errors;
+use crate::persist::file_format::{OpenFile, OpenFileError};
 
 #[derive(Debug)]
 /// Represents the result of an attempt to load incremental compilation data.
@@ -69,23 +69,6 @@ pub fn open(self, sess: &Session) -> T {
     }
 }
 
-fn load_data(path: &Path, sess: &Session) -> LoadResult<(Mmap, usize)> {
-    match file_format::read_file(
-        path,
-        sess.opts.unstable_opts.incremental_info,
-        sess.is_nightly_build(),
-        sess.cfg_version,
-    ) {
-        Ok(Some(data_and_pos)) => LoadResult::Ok { data: data_and_pos },
-        Ok(None) => {
-            // The file either didn't exist or was produced by an incompatible
-            // compiler version. Neither is an error.
-            LoadResult::DataOutOfDate
-        }
-        Err(err) => LoadResult::LoadDepGraph(path.to_path_buf(), err),
-    }
-}
-
 fn delete_dirty_work_product(sess: &Session, swp: SerializedWorkProduct) {
     debug!("delete_dirty_work_product({:?})", swp);
     work_product::delete_workproduct_files(sess, &swp.work_product);
@@ -113,12 +96,12 @@ fn load_dep_graph(sess: &Session) -> LoadResult<(Arc<SerializedDepGraph>, WorkPr
     // when trying to load work products.
     if sess.incr_comp_session_dir_opt().is_some() {
         let work_products_path = work_products_path(sess);
-        let load_result = load_data(&work_products_path, sess);
 
-        if let LoadResult::Ok { data: (work_products_data, start_pos) } = load_result {
+        if let Ok(OpenFile { mmap, start_pos }) =
+            file_format::open_incremental_file(sess, &work_products_path)
+        {
             // Decode the list of work_products
-            let Ok(mut work_product_decoder) = MemDecoder::new(&work_products_data[..], start_pos)
-            else {
+            let Ok(mut work_product_decoder) = MemDecoder::new(&mmap[..], start_pos) else {
                 sess.dcx().emit_warn(errors::CorruptFile { path: &work_products_path });
                 return LoadResult::DataOutOfDate;
             };
@@ -147,11 +130,11 @@ fn load_dep_graph(sess: &Session) -> LoadResult<(Arc<SerializedDepGraph>, WorkPr
 
     let _prof_timer = prof.generic_activity("incr_comp_load_dep_graph");
 
-    match load_data(&path, sess) {
-        LoadResult::DataOutOfDate => LoadResult::DataOutOfDate,
-        LoadResult::LoadDepGraph(path, err) => LoadResult::LoadDepGraph(path, err),
-        LoadResult::Ok { data: (bytes, start_pos) } => {
-            let Ok(mut decoder) = MemDecoder::new(&bytes, start_pos) else {
+    match file_format::open_incremental_file(sess, &path) {
+        Err(OpenFileError::NotFoundOrHeaderMismatch) => LoadResult::DataOutOfDate,
+        Err(OpenFileError::IoError { err }) => LoadResult::LoadDepGraph(path.to_owned(), err),
+        Ok(OpenFile { mmap, start_pos }) => {
+            let Ok(mut decoder) = MemDecoder::new(&mmap, start_pos) else {
                 sess.dcx().emit_warn(errors::CorruptFile { path: &path });
                 return LoadResult::DataOutOfDate;
             };
@@ -191,15 +174,17 @@ pub fn load_query_result_cache(sess: &Session) -> Option<OnDiskCache> {
     let _prof_timer = sess.prof.generic_activity("incr_comp_load_query_result_cache");
 
     let path = query_cache_path(sess);
-    match load_data(&path, sess) {
-        LoadResult::Ok { data: (bytes, start_pos) } => {
-            let cache = OnDiskCache::new(sess, bytes, start_pos).unwrap_or_else(|()| {
+    match file_format::open_incremental_file(sess, &path) {
+        Ok(OpenFile { mmap, start_pos }) => {
+            let cache = OnDiskCache::new(sess, mmap, start_pos).unwrap_or_else(|()| {
                 sess.dcx().emit_warn(errors::CorruptFile { path: &path });
                 OnDiskCache::new_empty()
             });
             Some(cache)
         }
-        _ => Some(OnDiskCache::new_empty()),
+        Err(OpenFileError::NotFoundOrHeaderMismatch | OpenFileError::IoError { .. }) => {
+            Some(OnDiskCache::new_empty())
+        }
     }
 }
 

From 505dabc2a06f70708e2cd825afe9e5e215cfd699 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 26 Mar 2026 16:57:52 +1100
Subject: [PATCH 0969/1059] Tiny improvements to incremental header
 reads/writes

The standard library has helper methods for converting integers to/from
little-endian bytes, for checked conversion from `usize` to `u8`, and for
treating `&mut T` as `&mut [T; 1]`.
---
 .../src/persist/file_format.rs                | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_incremental/src/persist/file_format.rs b/compiler/rustc_incremental/src/persist/file_format.rs
index 7348ca5c4e44..c47540fe385b 100644
--- a/compiler/rustc_incremental/src/persist/file_format.rs
+++ b/compiler/rustc_incremental/src/persist/file_format.rs
@@ -12,7 +12,7 @@
 use std::borrow::Cow;
 use std::io::{self, Read};
 use std::path::{Path, PathBuf};
-use std::{env, fs};
+use std::{array, env, fs};
 
 use rustc_data_structures::memmap::Mmap;
 use rustc_serialize::Encoder;
@@ -30,12 +30,12 @@
 
 pub(crate) fn write_file_header(stream: &mut FileEncoder, sess: &Session) {
     stream.emit_raw_bytes(FILE_MAGIC);
-    stream
-        .emit_raw_bytes(&[(HEADER_FORMAT_VERSION >> 0) as u8, (HEADER_FORMAT_VERSION >> 8) as u8]);
+    stream.emit_raw_bytes(&u16::to_le_bytes(HEADER_FORMAT_VERSION));
 
     let rustc_version = rustc_version(sess);
-    assert_eq!(rustc_version.len(), (rustc_version.len() as u8) as usize);
-    stream.emit_raw_bytes(&[rustc_version.len() as u8]);
+    let rustc_version_len =
+        u8::try_from(rustc_version.len()).expect("version string should not exceed 255 bytes");
+    stream.emit_raw_bytes(&[rustc_version_len]);
     stream.emit_raw_bytes(rustc_version.as_bytes());
 }
 
@@ -147,8 +147,7 @@ pub(crate) fn open_incremental_file(
         debug_assert!(size_of_val(&HEADER_FORMAT_VERSION) == 2);
         let mut header_format_version = [0u8; 2];
         file.read_exact(&mut header_format_version)?;
-        let header_format_version =
-            (header_format_version[0] as u16) | ((header_format_version[1] as u16) << 8);
+        let header_format_version = u16::from_le_bytes(header_format_version);
 
         if header_format_version != HEADER_FORMAT_VERSION {
             report_format_mismatch(sess, path, "Wrong HEADER_FORMAT_VERSION");
@@ -158,10 +157,9 @@ pub(crate) fn open_incremental_file(
 
     // Check RUSTC_VERSION
     {
-        let mut rustc_version_str_len = [0u8; 1];
-        file.read_exact(&mut rustc_version_str_len)?;
-        let rustc_version_str_len = rustc_version_str_len[0] as usize;
-        let mut buffer = vec![0; rustc_version_str_len];
+        let mut rustc_version_str_len = 0u8;
+        file.read_exact(array::from_mut(&mut rustc_version_str_len))?;
+        let mut buffer = vec![0; usize::from(rustc_version_str_len)];
         file.read_exact(&mut buffer)?;
 
         if buffer != rustc_version(sess).as_bytes() {

From dc5cb1719eed6ac9275fe93d914d32141606b2ac Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Fri, 27 Mar 2026 08:07:58 +0800
Subject: [PATCH 0970/1059] Fix ice in rustdoc of private reexport

---
 .../passes/collect_intra_doc_links.rs         | 26 +++++++++++++------
 .../doc-link-private-reexport-issue-154383.rs | 10 +++++++
 2 files changed, 28 insertions(+), 8 deletions(-)
 create mode 100644 tests/rustdoc-ui/intra-doc/doc-link-private-reexport-issue-154383.rs

diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 3e68ed950ce1..8b66672cfa5e 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -1067,17 +1067,27 @@ impl LinkCollector<'_, '_> {
     #[instrument(level = "debug", skip_all)]
     fn resolve_links(&mut self, item: &Item) {
         let tcx = self.cx.tcx;
-        if !self.cx.document_private()
-            && let Some(def_id) = item.item_id.as_def_id()
-            && let Some(def_id) = def_id.as_local()
-            && !tcx.effective_visibilities(()).is_exported(def_id)
-            && !has_primitive_or_keyword_or_attribute_docs(&item.attrs.other_attrs)
+        let document_private = self.cx.document_private();
+        let effective_visibilities = tcx.effective_visibilities(());
+        let should_skip_link_resolution = |item_id: DefId| {
+            !document_private
+                && item_id
+                    .as_local()
+                    .is_some_and(|local_def_id| !effective_visibilities.is_exported(local_def_id))
+                && !has_primitive_or_keyword_or_attribute_docs(&item.attrs.other_attrs)
+        };
+
+        if let Some(def_id) = item.item_id.as_def_id()
+            && should_skip_link_resolution(def_id)
         {
             // Skip link resolution for non-exported items.
             return;
         }
 
-        let mut insert_links = |item_id, doc: &str| {
+        let mut try_insert_links = |item_id, doc: &str| {
+            if should_skip_link_resolution(item_id) {
+                return;
+            }
             let module_id = match tcx.def_kind(item_id) {
                 DefKind::Mod if item.inner_docs(tcx) => item_id,
                 _ => find_nearest_parent_module(tcx, item_id).unwrap(),
@@ -1108,7 +1118,7 @@ fn resolve_links(&mut self, item: &Item) {
             // NOTE: if there are links that start in one crate and end in another, this will not resolve them.
             // This is a degenerate case and it's not supported by rustdoc.
             let item_id = item_id.unwrap_or_else(|| item.item_id.expect_def_id());
-            insert_links(item_id, &doc)
+            try_insert_links(item_id, &doc)
         }
 
         // Also resolve links in the note text of `#[deprecated]`.
@@ -1137,7 +1147,7 @@ fn resolve_links(&mut self, item: &Item) {
             } else {
                 item.item_id.expect_def_id()
             };
-            insert_links(item_id, note)
+            try_insert_links(item_id, note)
         }
     }
 
diff --git a/tests/rustdoc-ui/intra-doc/doc-link-private-reexport-issue-154383.rs b/tests/rustdoc-ui/intra-doc/doc-link-private-reexport-issue-154383.rs
new file mode 100644
index 000000000000..1c736785933e
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/doc-link-private-reexport-issue-154383.rs
@@ -0,0 +1,10 @@
+//@ check-pass
+
+// Regression test for <https://github.com/rust-lang/rust/issues/154383>.
+// Rustdoc used to ICE on the doc link attached to a `pub use` inside a
+// private module.
+
+mod inner {
+    /// [std::vec::Vec]
+    pub use std::vec::Vec as MyVec;
+}

From a53356ec89a20217e0968f19693e50e25beda128 Mon Sep 17 00:00:00 2001
From: Yacin Tmimi <yacintmimi@gmail.com>
Date: Fri, 27 Mar 2026 01:11:27 -0400
Subject: [PATCH 0971/1059] fix: [rustfmt] prevent panic when rewritng
 associated item delegations

Fixes a rustfmt bug for `#![feature(fn_delegation)]`
---
 src/tools/rustfmt/src/visitor.rs             | 12 ++++++++----
 src/tools/rustfmt/tests/target/issue_6513.rs | 10 ++++++++++
 2 files changed, 18 insertions(+), 4 deletions(-)
 create mode 100644 src/tools/rustfmt/tests/target/issue_6513.rs

diff --git a/src/tools/rustfmt/src/visitor.rs b/src/tools/rustfmt/src/visitor.rs
index 6048084c8da6..560d62e9d57d 100644
--- a/src/tools/rustfmt/src/visitor.rs
+++ b/src/tools/rustfmt/src/visitor.rs
@@ -665,11 +665,11 @@ fn visit_assoc_item(&mut self, ai: &ast::AssocItem, visitor_kind: ItemVisitorKin
         }
 
         // TODO(calebcartwright): consider enabling box_patterns feature gate
-        match (&ai.kind, visitor_kind) {
-            (ast::AssocItemKind::Const(c), AssocTraitItem) => {
+        match (&ai.kind, assoc_ctxt) {
+            (ast::AssocItemKind::Const(c), visit::AssocCtxt::Trait) => {
                 self.visit_static(&StaticParts::from_trait_item(ai, c.ident))
             }
-            (ast::AssocItemKind::Const(c), AssocImplItem) => {
+            (ast::AssocItemKind::Const(c), visit::AssocCtxt::Impl { .. }) => {
                 self.visit_static(&StaticParts::from_impl_item(ai, c.ident))
             }
             (ast::AssocItemKind::Fn(ref fn_kind), _) => {
@@ -714,7 +714,11 @@ fn visit_assoc_item(&mut self, ai: &ast::AssocItem, visitor_kind: ItemVisitorKin
             (ast::AssocItemKind::MacCall(ref mac), _) => {
                 self.visit_mac(mac, MacroPosition::Item);
             }
-            _ => unreachable!(),
+            (ast::AssocItemKind::Delegation(_) | ast::AssocItemKind::DelegationMac(_), _) => {
+                // TODO(ytmimi) #![feature(fn_delegation)]
+                // add formatting for `AssocItemKind::Delegation` and `AssocItemKind::DelegationMac`
+                self.push_rewrite(ai.span, None);
+            }
         }
     }
 
diff --git a/src/tools/rustfmt/tests/target/issue_6513.rs b/src/tools/rustfmt/tests/target/issue_6513.rs
new file mode 100644
index 000000000000..827d4ccdf27f
--- /dev/null
+++ b/src/tools/rustfmt/tests/target/issue_6513.rs
@@ -0,0 +1,10 @@
+#![feature(fn_delegation)]
+
+struct Ty;
+impl Ty {
+    reuse std::convert::identity;
+}
+
+trait Trait {
+    reuse std::convert::identity;
+}

From f110b38c6f5b81494e0144ae4af5db1e3d8e8736 Mon Sep 17 00:00:00 2001
From: "Eddy (Eduard) Stefes" <eddy@linux.ibm.com>
Date: Fri, 27 Mar 2026 09:47:36 +0100
Subject: [PATCH 0972/1059] fix a tests that assunes the wrong alignment on
 s390x

on s390x vectors are aligned at 8 bytes not 16 or vector length like on
x86.
---
 .../rust-analyzer/crates/hir-ty/src/layout/tests.rs      | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 8c91be1d7811..e491c29df3b5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -379,6 +379,11 @@ impl Tr for S {
 
 #[test]
 fn simd_types() {
+    let size = 16;
+    #[cfg(not(target_arch = "s390x"))]
+    let align = 16;
+    #[cfg(target_arch = "s390x")]
+    let align = 8;
     check_size_and_align(
         r#"
             #[repr(simd)]
@@ -386,8 +391,8 @@ fn simd_types() {
             struct Goal(SimdType);
         "#,
         "",
-        16,
-        16,
+        size,
+        align,
     );
 }
 

From 1af153cdb91c3d862daa5d1382496055fef678c6 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Fri, 20 Feb 2026 12:25:04 +0900
Subject: [PATCH 0973/1059] Tweak incorrect assoc item note

---
 .../rustc_hir_typeck/src/method/suggest.rs    | 14 +++++++++++
 ...ated-type-as-value-in-impl-issue-142797.rs | 23 +++++++++++++++++++
 ...-type-as-value-in-impl-issue-142797.stderr |  9 ++++++++
 .../associated-type-call.fixed                |  2 +-
 .../associated-types/associated-type-call.rs  |  2 +-
 .../associated-type-call.stderr               |  4 ++--
 tests/ui/associated-types/invalid-ctor.fixed  |  2 +-
 tests/ui/associated-types/invalid-ctor.rs     |  2 +-
 tests/ui/associated-types/invalid-ctor.stderr |  4 ++--
 9 files changed, 54 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
 create mode 100644 tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 3198bbe0bbc6..20528f71b051 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1175,10 +1175,24 @@ fn report_no_match_method_error(
         let mut ty_file = None;
         let mode = no_match_data.mode;
         let is_method = mode == Mode::MethodCall;
+        let has_self_assoc_type = if let SelfSource::QPath(ty) = source
+            && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
+            && let Res::SelfTyAlias { alias_to: impl_def_id, .. } = path.res
+            && let DefKind::Impl { .. } = self.tcx.def_kind(impl_def_id)
+        {
+            self.tcx
+                .associated_items(impl_def_id)
+                .find_by_ident_and_kind(self.tcx, item_ident, ty::AssocTag::Type, impl_def_id)
+                .is_some()
+        } else {
+            false
+        };
         let item_kind = if is_method {
             "method"
         } else if rcvr_ty.is_enum() {
             "variant or associated item"
+        } else if has_self_assoc_type {
+            "associated function or constant"
         } else {
             match (item_ident.as_str().chars().next(), rcvr_ty.is_fresh_ty()) {
                 (Some(name), false) if name.is_lowercase() => "function or associated item",
diff --git a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
new file mode 100644
index 000000000000..77d62ebd494e
--- /dev/null
+++ b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
@@ -0,0 +1,23 @@
+// issue: <https://github.com/rust-lang/rust/issues/142797>
+
+#![allow(dead_code, unused_variables)]
+
+struct SomeStruct {
+    some_field: u64,
+}
+
+trait SomeTrait {
+    type SomeType;
+    fn foo();
+}
+
+impl SomeTrait for bool {
+    type SomeType = SomeStruct;
+
+    fn foo() {
+        let ss = Self::SomeType;
+        //~^ ERROR no associated function or constant named `SomeType` found for type `bool` in the current scope
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr
new file mode 100644
index 000000000000..aa2494c4c48c
--- /dev/null
+++ b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr
@@ -0,0 +1,9 @@
+error[E0599]: no associated function or constant named `SomeType` found for type `bool` in the current scope
+  --> $DIR/associated-type-as-value-in-impl-issue-142797.rs:18:24
+   |
+LL |         let ss = Self::SomeType;
+   |                        ^^^^^^^^ associated function or constant not found in `bool`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/associated-types/associated-type-call.fixed b/tests/ui/associated-types/associated-type-call.fixed
index d450b3b82c96..f2df7807b31e 100644
--- a/tests/ui/associated-types/associated-type-call.fixed
+++ b/tests/ui/associated-types/associated-type-call.fixed
@@ -15,7 +15,7 @@ impl Trait for () {
 
     fn f() {
         T();
-        //~^ ERROR no associated item named `Assoc` found for unit type `()` in the current scope
+        //~^ ERROR no associated function or constant named `Assoc` found for unit type `()` in the current scope
     }
 }
 
diff --git a/tests/ui/associated-types/associated-type-call.rs b/tests/ui/associated-types/associated-type-call.rs
index ffe540c329eb..88d017219b78 100644
--- a/tests/ui/associated-types/associated-type-call.rs
+++ b/tests/ui/associated-types/associated-type-call.rs
@@ -15,7 +15,7 @@ impl Trait for () {
 
     fn f() {
         <Self>::Assoc();
-        //~^ ERROR no associated item named `Assoc` found for unit type `()` in the current scope
+        //~^ ERROR no associated function or constant named `Assoc` found for unit type `()` in the current scope
     }
 }
 
diff --git a/tests/ui/associated-types/associated-type-call.stderr b/tests/ui/associated-types/associated-type-call.stderr
index eaef775e3040..94cfc2446562 100644
--- a/tests/ui/associated-types/associated-type-call.stderr
+++ b/tests/ui/associated-types/associated-type-call.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `Assoc` found for unit type `()` in the current scope
+error[E0599]: no associated function or constant named `Assoc` found for unit type `()` in the current scope
   --> $DIR/associated-type-call.rs:17:17
    |
 LL |         <Self>::Assoc();
-   |                 ^^^^^ associated item not found in `()`
+   |                 ^^^^^ associated function or constant not found in `()`
    |
 help: to construct a value of type `T`, use the explicit path
    |
diff --git a/tests/ui/associated-types/invalid-ctor.fixed b/tests/ui/associated-types/invalid-ctor.fixed
index eba3820de0c1..75980101f045 100644
--- a/tests/ui/associated-types/invalid-ctor.fixed
+++ b/tests/ui/associated-types/invalid-ctor.fixed
@@ -15,7 +15,7 @@ impl Trait for () {
 
     fn mk() -> Self::Out {
         Constructor(1)
-        //~^ ERROR no associated item named `Out` found for unit type `()`
+        //~^ ERROR no associated function or constant named `Out` found for unit type `()`
     }
 }
 
diff --git a/tests/ui/associated-types/invalid-ctor.rs b/tests/ui/associated-types/invalid-ctor.rs
index 73335c065c2a..82ec17df430f 100644
--- a/tests/ui/associated-types/invalid-ctor.rs
+++ b/tests/ui/associated-types/invalid-ctor.rs
@@ -15,7 +15,7 @@ impl Trait for () {
 
     fn mk() -> Self::Out {
         Self::Out(1)
-        //~^ ERROR no associated item named `Out` found for unit type `()`
+        //~^ ERROR no associated function or constant named `Out` found for unit type `()`
     }
 }
 
diff --git a/tests/ui/associated-types/invalid-ctor.stderr b/tests/ui/associated-types/invalid-ctor.stderr
index 0b3bf316f60f..50dc7188b681 100644
--- a/tests/ui/associated-types/invalid-ctor.stderr
+++ b/tests/ui/associated-types/invalid-ctor.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `Out` found for unit type `()` in the current scope
+error[E0599]: no associated function or constant named `Out` found for unit type `()` in the current scope
   --> $DIR/invalid-ctor.rs:17:15
    |
 LL |         Self::Out(1)
-   |               ^^^ associated item not found in `()`
+   |               ^^^ associated function or constant not found in `()`
    |
 help: to construct a value of type `Constructor`, use the explicit path
    |

From 08bb61bb88026e10468af994dc3a35270dcc072b Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 27 Mar 2026 15:17:00 +0300
Subject: [PATCH 0974/1059] Use `tcx.is_typeck_child()` more often

---
 compiler/rustc_borrowck/src/universal_regions.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs
index aeba5ee70cf1..16f00e1442ac 100644
--- a/compiler/rustc_borrowck/src/universal_regions.rs
+++ b/compiler/rustc_borrowck/src/universal_regions.rs
@@ -476,12 +476,10 @@ fn build(self) -> UniversalRegions<'tcx> {
         let mut indices = self.compute_indices(fr_static, defining_ty);
         debug!("build: indices={:?}", indices);
 
-        let typeck_root_def_id = self.infcx.tcx.typeck_root_def_id(self.mir_def.to_def_id());
-
         // If this is a 'root' body (not a closure/coroutine/inline const), then
         // there are no extern regions, so the local regions start at the same
         // position as the (empty) sub-list of extern regions
-        let first_local_index = if self.mir_def.to_def_id() == typeck_root_def_id {
+        let first_local_index = if !self.infcx.tcx.is_typeck_child(self.mir_def.to_def_id()) {
             first_extern_index
         } else {
             // If this is a closure, coroutine, or inline-const, then the late-bound regions from the enclosing
@@ -948,16 +946,14 @@ fn for_each_late_bound_region_in_recursive_scope<'tcx>(
     mut mir_def_id: LocalDefId,
     mut f: impl FnMut(ty::Region<'tcx>),
 ) {
-    let typeck_root_def_id = tcx.typeck_root_def_id(mir_def_id.to_def_id());
-
     // Walk up the tree, collecting late-bound regions until we hit the typeck root
     loop {
         for_each_late_bound_region_in_item(tcx, mir_def_id, &mut f);
 
-        if mir_def_id.to_def_id() == typeck_root_def_id {
-            break;
-        } else {
+        if tcx.is_typeck_child(mir_def_id.to_def_id()) {
             mir_def_id = tcx.local_parent(mir_def_id);
+        } else {
+            break;
         }
     }
 }

From 1b68d921a7a5a3e99a8035fec33a53789e40b8aa Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 27 Mar 2026 15:32:48 +0300
Subject: [PATCH 0975/1059] Add typeck_root_def_id_local

---
 .../src/diagnostics/conflict_errors.rs             |  6 ++----
 compiler/rustc_borrowck/src/diagnostics/mod.rs     |  9 +++------
 compiler/rustc_borrowck/src/universal_regions.rs   |  6 +++---
 compiler/rustc_hir_analysis/src/check/region.rs    |  8 ++++----
 .../rustc_hir_analysis/src/collect/generics_of.rs  | 12 ++++++------
 compiler/rustc_hir_typeck/src/closure.rs           |  2 +-
 compiler/rustc_hir_typeck/src/lib.rs               |  2 +-
 compiler/rustc_middle/src/queries.rs               |  2 +-
 compiler/rustc_middle/src/ty/context.rs            |  8 ++------
 compiler/rustc_middle/src/ty/util.rs               | 14 ++++++++++++++
 compiler/rustc_mir_build/src/thir/cx/expr.rs       | 12 ++++++------
 compiler/rustc_mir_transform/src/lib.rs            |  8 ++++----
 compiler/rustc_mir_transform/src/liveness.rs       |  2 +-
 compiler/rustc_monomorphize/src/collector.rs       |  2 +-
 .../src/error_reporting/infer/need_type_info.rs    |  6 +++---
 compiler/rustc_ty_utils/src/nested_bodies.rs       |  9 ++++-----
 src/tools/clippy/clippy_lints/src/shadow.rs        |  2 +-
 17 files changed, 57 insertions(+), 53 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 7bbce730c165..a63c54a2618b 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1569,10 +1569,8 @@ fn suggest_adding_bounds(&self, err: &mut Diag<'_>, ty: Ty<'tcx>, def_id: DefId,
         let tcx = self.infcx.tcx;
         let generics = tcx.generics_of(self.mir_def_id());
 
-        let Some(hir_generics) = tcx
-            .typeck_root_def_id(self.mir_def_id().to_def_id())
-            .as_local()
-            .and_then(|def_id| tcx.hir_get_generics(def_id))
+        let Some(hir_generics) =
+            tcx.hir_get_generics(tcx.typeck_root_def_id_local(self.mir_def_id()))
         else {
             return;
         };
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 8b4bda8f7fef..86d7119639a3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -1274,12 +1274,9 @@ fn explain_captures(
                     if let ty::Param(param_ty) = *self_ty.kind()
                         && let generics = self.infcx.tcx.generics_of(self.mir_def_id())
                         && let param = generics.type_param(param_ty, self.infcx.tcx)
-                        && let Some(hir_generics) = self
-                            .infcx
-                            .tcx
-                            .typeck_root_def_id(self.mir_def_id().to_def_id())
-                            .as_local()
-                            .and_then(|def_id| self.infcx.tcx.hir_get_generics(def_id))
+                        && let Some(hir_generics) = self.infcx.tcx.hir_get_generics(
+                            self.infcx.tcx.typeck_root_def_id_local(self.mir_def_id()),
+                        )
                         && let spans = hir_generics
                             .predicates
                             .iter()
diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs
index 16f00e1442ac..e96c6c7c56f9 100644
--- a/compiler/rustc_borrowck/src/universal_regions.rs
+++ b/compiler/rustc_borrowck/src/universal_regions.rs
@@ -581,7 +581,7 @@ fn build(self) -> UniversalRegions<'tcx> {
     /// see `DefiningTy` for details.
     fn defining_ty(&self) -> DefiningTy<'tcx> {
         let tcx = self.infcx.tcx;
-        let typeck_root_def_id = tcx.typeck_root_def_id(self.mir_def.to_def_id());
+        let typeck_root_def_id = tcx.typeck_root_def_id_local(self.mir_def);
 
         match tcx.hir_body_owner_kind(self.mir_def) {
             BodyOwnerKind::Closure | BodyOwnerKind::Fn => {
@@ -612,7 +612,7 @@ fn defining_ty(&self) -> DefiningTy<'tcx> {
 
             BodyOwnerKind::Const { .. } | BodyOwnerKind::Static(..) => {
                 let identity_args = GenericArgs::identity_for_item(tcx, typeck_root_def_id);
-                if self.mir_def.to_def_id() == typeck_root_def_id {
+                if self.mir_def == typeck_root_def_id {
                     let args = self.infcx.replace_free_regions_with_nll_infer_vars(
                         NllRegionVariableOrigin::FreeRegion,
                         identity_args,
@@ -658,7 +658,7 @@ fn compute_indices(
         defining_ty: DefiningTy<'tcx>,
     ) -> UniversalRegionIndices<'tcx> {
         let tcx = self.infcx.tcx;
-        let typeck_root_def_id = tcx.typeck_root_def_id(self.mir_def.to_def_id());
+        let typeck_root_def_id = tcx.typeck_root_def_id_local(self.mir_def);
         let identity_args = GenericArgs::identity_for_item(tcx, typeck_root_def_id);
         let renumbered_args = defining_ty.args();
 
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index 8865638e3af2..e31beca39083 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -11,7 +11,7 @@
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Arm, Block, Expr, LetStmt, Pat, PatKind, Stmt};
 use rustc_index::Idx;
@@ -849,13 +849,13 @@ fn visit_inline_const(&mut self, c: &'tcx hir::ConstBlock) {
 /// re-use in incremental scenarios. We may sometimes need to rerun the
 /// type checker even when the HIR hasn't changed, and in those cases
 /// we can avoid reconstructing the region scope tree.
-pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
-    let typeck_root_def_id = tcx.typeck_root_def_id(def_id);
+pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &ScopeTree {
+    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
     if typeck_root_def_id != def_id {
         return tcx.region_scope_tree(typeck_root_def_id);
     }
 
-    let scope_tree = if let Some(body) = tcx.hir_maybe_body_owned_by(def_id.expect_local()) {
+    let scope_tree = if let Some(body) = tcx.hir_maybe_body_owned_by(def_id) {
         let mut visitor = ScopeResolutionVisitor {
             tcx,
             scope_tree: ScopeTree::default(),
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index 866787a45718..ea98beb95580 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -76,12 +76,12 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         | Node::Ctor(..)
         | Node::Field(_) => {
             let parent_id = tcx.hir_get_parent_item(hir_id);
-            Some(parent_id.to_def_id())
+            Some(parent_id.def_id)
         }
         // FIXME(#43408) always enable this once `lazy_normalization` is
         // stable enough and does not need a feature gate anymore.
         Node::AnonConst(_) => {
-            let parent_did = tcx.parent(def_id.to_def_id());
+            let parent_did = tcx.local_parent(def_id);
             debug!(?parent_did);
 
             let mut in_param_ty = false;
@@ -175,7 +175,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         }
         Node::ConstBlock(_)
         | Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
-            Some(tcx.typeck_root_def_id(def_id.to_def_id()))
+            Some(tcx.typeck_root_def_id_local(def_id))
         }
         Node::OpaqueTy(&hir::OpaqueTy {
             origin:
@@ -188,7 +188,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             } else {
                 assert_matches!(tcx.def_kind(fn_def_id), DefKind::AssocFn | DefKind::Fn);
             }
-            Some(fn_def_id.to_def_id())
+            Some(fn_def_id)
         }
         Node::OpaqueTy(&hir::OpaqueTy {
             origin: hir::OpaqueTyOrigin::TyAlias { parent, in_assoc_ty },
@@ -202,7 +202,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
             debug!("generics_of: parent of opaque ty {:?} is {:?}", def_id, parent);
             // Opaque types are always nested within another item, and
             // inherit the generics of the item.
-            Some(parent.to_def_id())
+            Some(parent)
         }
 
         // All of these nodes have no parent from which to inherit generics.
@@ -380,7 +380,7 @@ fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         own_params.iter().map(|param| (param.def_id, param.index)).collect();
 
     ty::Generics {
-        parent: parent_def_id,
+        parent: parent_def_id.map(LocalDefId::to_def_id),
         parent_count,
         own_params,
         param_def_id_to_index,
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index 82b7c578a1f2..1a9c2a21c7ef 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -72,7 +72,7 @@ pub(crate) fn check_expr_closure(
         debug!(?bound_sig, ?liberated_sig);
 
         let parent_args =
-            GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id(expr_def_id.to_def_id()));
+            GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id_local(expr_def_id));
 
         let tupled_upvars_ty = self.next_ty_var(expr_span);
 
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 734e5136f880..6cfcdfe87480 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -106,7 +106,7 @@ fn typeck_with_inspect<'tcx>(
 ) -> &'tcx ty::TypeckResults<'tcx> {
     // Closures' typeck results come from their outermost function,
     // as they are part of the same "inference environment".
-    let typeck_root_def_id = tcx.typeck_root_def_id(def_id.to_def_id()).expect_local();
+    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
     if typeck_root_def_id != def_id {
         return tcx.typeck(typeck_root_def_id);
     }
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index ff96f5044dc1..3572e3ff35cb 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -1413,7 +1413,7 @@
 
     /// Per-body `region::ScopeTree`. The `DefId` should be the owner `DefId` for the body;
     /// in the case of closures, this will be redirected to the enclosing function.
-    query region_scope_tree(def_id: DefId) -> &'tcx crate::middle::region::ScopeTree {
+    query region_scope_tree(def_id: LocalDefId) -> &'tcx crate::middle::region::ScopeTree {
         desc { "computing drop scopes for `{}`", tcx.def_path_str(def_id) }
     }
 
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 58a2edca8ece..28688bcbfafc 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -899,12 +899,8 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn has_typeck_results(self, def_id: LocalDefId) -> bool {
         // Closures' typeck results come from their outermost function,
         // as they are part of the same "inference environment".
-        let typeck_root_def_id = self.typeck_root_def_id(def_id.to_def_id());
-        if typeck_root_def_id != def_id.to_def_id() {
-            return self.has_typeck_results(typeck_root_def_id.expect_local());
-        }
-
-        self.hir_node_by_def_id(def_id).body_id().is_some()
+        let root = self.typeck_root_def_id_local(def_id);
+        self.hir_node_by_def_id(root).body_id().is_some()
     }
 
     /// Expects a body and returns its codegen attributes.
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index e7c7d5924870..d0cbdff366df 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -650,6 +650,20 @@ pub fn typeck_root_def_id(self, def_id: DefId) -> DefId {
         def_id
     }
 
+    /// Given the `LocalDefId`, returns the `LocalDefId` of the innermost item that
+    /// has its own type-checking context or "inference environment".
+    ///
+    /// For example, a closure has its own `LocalDefId`, but it is type-checked
+    /// with the containing item. Therefore, when we fetch the `typeck` of the closure,
+    /// for example, we really wind up fetching the `typeck` of the enclosing fn item.
+    pub fn typeck_root_def_id_local(self, def_id: LocalDefId) -> LocalDefId {
+        let mut def_id = def_id;
+        while self.is_typeck_child(def_id.to_def_id()) {
+            def_id = self.local_parent(def_id);
+        }
+        def_id
+    }
+
     /// Given the `DefId` and args a closure, creates the type of
     /// `self` argument that the closure expects. For example, for a
     /// `Fn` closure, this would return a reference type `&T` where
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 4256ee45f850..7e6f30378a49 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -816,8 +816,8 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
                         }
                         hir::InlineAsmOperand::Const { ref anon_const } => {
                             let ty = self.typeck_results.node_type(anon_const.hir_id);
-                            let did = anon_const.def_id.to_def_id();
-                            let typeck_root_def_id = tcx.typeck_root_def_id(did);
+                            let did = anon_const.def_id;
+                            let typeck_root_def_id = tcx.typeck_root_def_id_local(did);
                             let parent_args = tcx.erase_and_anonymize_regions(
                                 GenericArgs::identity_for_item(tcx, typeck_root_def_id),
                             );
@@ -825,7 +825,7 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
                                 InlineConstArgs::new(tcx, InlineConstArgsParts { parent_args, ty })
                                     .args;
 
-                            let uneval = mir::UnevaluatedConst::new(did, args);
+                            let uneval = mir::UnevaluatedConst::new(did.to_def_id(), args);
                             let value = mir::Const::Unevaluated(uneval, ty);
                             InlineAsmOperand::Const { value, span: tcx.def_span(did) }
                         }
@@ -895,15 +895,15 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
 
             hir::ExprKind::ConstBlock(ref anon_const) => {
                 let ty = self.typeck_results.node_type(anon_const.hir_id);
-                let did = anon_const.def_id.to_def_id();
-                let typeck_root_def_id = tcx.typeck_root_def_id(did);
+                let did = anon_const.def_id;
+                let typeck_root_def_id = tcx.typeck_root_def_id_local(did);
                 let parent_args = tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(
                     tcx,
                     typeck_root_def_id,
                 ));
                 let args = InlineConstArgs::new(tcx, InlineConstArgsParts { parent_args, ty }).args;
 
-                ExprKind::ConstBlock { did, args }
+                ExprKind::ConstBlock { did: did.to_def_id(), args }
             }
             // Now comes the rote stuff:
             hir::ExprKind::Repeat(v, _) => {
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 094aae499c4b..9273c2103d44 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -526,7 +526,7 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
 
     // We only need to borrowck non-synthetic MIR.
     let tainted_by_errors = if !tcx.is_synthetic_mir(def) {
-        tcx.mir_borrowck(tcx.typeck_root_def_id(def.to_def_id()).expect_local()).err()
+        tcx.mir_borrowck(tcx.typeck_root_def_id_local(def)).err()
     } else {
         None
     };
@@ -554,14 +554,14 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
     //
     // We do this check here and not during `mir_promoted` because that may result
     // in borrowck cycles if WF requires looking into an opaque hidden type.
-    let root = tcx.typeck_root_def_id(def.to_def_id());
+    let root = tcx.typeck_root_def_id_local(def);
     match tcx.def_kind(root) {
         DefKind::Fn
         | DefKind::AssocFn
         | DefKind::Static { .. }
         | DefKind::Const { .. }
         | DefKind::AssocConst { .. } => {
-            if let Err(guar) = tcx.ensure_result().check_well_formed(root.expect_local()) {
+            if let Err(guar) = tcx.ensure_result().check_well_formed(root) {
                 body.tainted_by_errors = Some(guar);
             }
         }
@@ -840,7 +840,7 @@ fn promoted_mir(tcx: TyCtxt<'_>, def: LocalDefId) -> &IndexVec<Promoted, Body<'_
     }
 
     if !tcx.is_synthetic_mir(def) {
-        tcx.ensure_done().mir_borrowck(tcx.typeck_root_def_id(def.to_def_id()).expect_local());
+        tcx.ensure_done().mir_borrowck(tcx.typeck_root_def_id_local(def));
     }
     let mut promoted = tcx.mir_promoted(def).1.steal();
 
diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
index af246735b95a..90b6f07df836 100644
--- a/compiler/rustc_mir_transform/src/liveness.rs
+++ b/compiler/rustc_mir_transform/src/liveness.rs
@@ -67,7 +67,7 @@ pub(crate) fn check_liveness<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Den
     }
 
     // Don't run unused pass for #[derive]
-    let parent = tcx.parent(tcx.typeck_root_def_id(def_id.to_def_id()));
+    let parent = tcx.local_parent(tcx.typeck_root_def_id_local(def_id));
     if let DefKind::Impl { of_trait: true } = tcx.def_kind(parent)
         && find_attr!(tcx, parent, AutomaticallyDerived(..))
     {
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 8bd6730ab0eb..4698e054daf6 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -1615,7 +1615,7 @@ fn process_nested_body(&mut self, def_id: LocalDefId) {
                 if (self.strategy == MonoItemCollectionStrategy::Eager || is_pub_fn_coroutine)
                     && !self
                         .tcx
-                        .generics_of(self.tcx.typeck_root_def_id(def_id.to_def_id()))
+                        .generics_of(self.tcx.typeck_root_def_id_local(def_id))
                         .requires_monomorphization(self.tcx)
                 {
                     let instance = match *self.tcx.type_of(def_id).instantiate_identity().kind() {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 7fcaea3a629f..462f014a81f2 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -507,9 +507,9 @@ pub fn emit_inference_failure_err_with_type_hint(
         };
 
         let mut local_visitor = FindInferSourceVisitor::new(self, typeck_results, term, ty);
-        if let Some(body) = self.tcx.hir_maybe_body_owned_by(
-            self.tcx.typeck_root_def_id(body_def_id.to_def_id()).expect_local(),
-        ) {
+        if let Some(body) =
+            self.tcx.hir_maybe_body_owned_by(self.tcx.typeck_root_def_id_local(body_def_id))
+        {
             let expr = body.value;
             local_visitor.visit_expr(expr);
         }
diff --git a/compiler/rustc_ty_utils/src/nested_bodies.rs b/compiler/rustc_ty_utils/src/nested_bodies.rs
index 11dfbad7dbb7..874c8161453b 100644
--- a/compiler/rustc_ty_utils/src/nested_bodies.rs
+++ b/compiler/rustc_ty_utils/src/nested_bodies.rs
@@ -1,27 +1,26 @@
 use rustc_hir as hir;
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::Visitor;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, TyCtxt};
 
 fn nested_bodies_within<'tcx>(tcx: TyCtxt<'tcx>, item: LocalDefId) -> &'tcx ty::List<LocalDefId> {
     let body = tcx.hir_body_owned_by(item);
-    let mut collector =
-        NestedBodiesVisitor { tcx, root_def_id: item.to_def_id(), nested_bodies: vec![] };
+    let mut collector = NestedBodiesVisitor { tcx, root_def_id: item, nested_bodies: vec![] };
     collector.visit_body(body);
     tcx.mk_local_def_ids(&collector.nested_bodies)
 }
 
 struct NestedBodiesVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
-    root_def_id: DefId,
+    root_def_id: LocalDefId,
     nested_bodies: Vec<LocalDefId>,
 }
 
 impl<'tcx> Visitor<'tcx> for NestedBodiesVisitor<'tcx> {
     fn visit_nested_body(&mut self, id: hir::BodyId) {
         let body_def_id = self.tcx.hir_body_owner_def_id(id);
-        if self.tcx.typeck_root_def_id(body_def_id.to_def_id()) == self.root_def_id {
+        if self.tcx.typeck_root_def_id_local(body_def_id) == self.root_def_id {
             // We visit nested bodies before adding the current body. This
             // means that nested bodies are always stored before their parent.
             let body = self.tcx.hir_body(id);
diff --git a/src/tools/clippy/clippy_lints/src/shadow.rs b/src/tools/clippy/clippy_lints/src/shadow.rs
index 4fa22ff0cdb5..4ddf82773d87 100644
--- a/src/tools/clippy/clippy_lints/src/shadow.rs
+++ b/src/tools/clippy/clippy_lints/src/shadow.rs
@@ -179,7 +179,7 @@ fn check_body_post(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
 }
 
 fn is_shadow(cx: &LateContext<'_>, owner: LocalDefId, first: ItemLocalId, second: ItemLocalId) -> bool {
-    let scope_tree = cx.tcx.region_scope_tree(owner.to_def_id());
+    let scope_tree = cx.tcx.region_scope_tree(owner);
     if let Some(first_scope) = scope_tree.var_scope(first)
         && let Some(second_scope) = scope_tree.var_scope(second)
     {

From 2bb9d70b1e48605006cde0c85a5bd833889271d7 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 27 Mar 2026 15:33:23 +0300
Subject: [PATCH 0976/1059] Use stable_crate_id more often

---
 compiler/rustc_metadata/src/rmeta/encoder.rs | 2 +-
 compiler/rustc_symbol_mangling/src/legacy.rs | 4 +---
 compiler/rustc_symbol_mangling/src/v0.rs     | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index e554da362f83..8bf919dab8e7 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -727,7 +727,7 @@ macro_rules! stat {
                     is_stub: false,
                 },
                 extra_filename: tcx.sess.opts.cg.extra_filename.clone(),
-                stable_crate_id: tcx.def_path_hash(LOCAL_CRATE.as_def_id()).stable_crate_id(),
+                stable_crate_id: tcx.stable_crate_id(LOCAL_CRATE),
                 required_panic_strategy: tcx.required_panic_strategy(LOCAL_CRATE),
                 panic_in_drop_strategy: tcx.sess.opts.unstable_opts.panic_in_drop,
                 edition: tcx.sess.edition(),
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
index ea16231880e2..54ecf277cd3d 100644
--- a/compiler/rustc_symbol_mangling/src/legacy.rs
+++ b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -155,9 +155,7 @@ fn get_symbol_hash<'tcx>(
             args.hash_stable(hcx, &mut hasher);
 
             if let Some(instantiating_crate) = instantiating_crate {
-                tcx.def_path_hash(instantiating_crate.as_def_id())
-                    .stable_crate_id()
-                    .hash_stable(hcx, &mut hasher);
+                tcx.stable_crate_id(instantiating_crate).hash_stable(hcx, &mut hasher);
             }
 
             // We want to avoid accidental collision between different types of instances.
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 95cbb9e07ebb..eff8cbef9954 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -841,7 +841,7 @@ fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> {
     fn print_crate_name(&mut self, cnum: CrateNum) -> Result<(), PrintError> {
         self.push("C");
         if !self.is_exportable {
-            let stable_crate_id = self.tcx.def_path_hash(cnum.as_def_id()).stable_crate_id();
+            let stable_crate_id = self.tcx.stable_crate_id(cnum);
             self.push_disambiguator(stable_crate_id.as_u64());
         }
         let name = self.tcx.crate_name(cnum);

From 62ec331a840ad7b69201bfabcf439ae2c6b0b466 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Fri, 27 Mar 2026 15:33:56 +0300
Subject: [PATCH 0977/1059] Use tcx.local_parent() more often

---
 compiler/rustc_hir_analysis/src/collect/predicates_of.rs     | 2 +-
 compiler/rustc_passes/src/dead.rs                            | 4 ++--
 .../src/error_reporting/infer/need_type_info.rs              | 5 ++---
 .../src/error_reporting/traits/suggestions.rs                | 3 +--
 src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs  | 2 +-
 5 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 98999232a743..8fd3d631962c 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -107,7 +107,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             );
 
             return ty::GenericPredicates {
-                parent: Some(tcx.parent(def_id.to_def_id())),
+                parent: Some(tcx.local_parent(def_id).to_def_id()),
                 predicates: tcx.arena.alloc_from_iter(predicates),
             };
         }
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 30634c800e81..d5ef9ee9335c 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -380,8 +380,8 @@ fn mark_live_symbols(&mut self) -> <MarkSymbolVisitor<'tcx> as Visitor<'tcx>>::R
     /// for discussion).
     fn should_ignore_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) -> bool {
         if let hir::ImplItemImplKind::Trait { .. } = impl_item.impl_kind
-            && let impl_of = self.tcx.parent(impl_item.owner_id.to_def_id())
-            && self.tcx.is_automatically_derived(impl_of)
+            && let impl_of = self.tcx.local_parent(impl_item.owner_id.def_id)
+            && self.tcx.is_automatically_derived(impl_of.to_def_id())
             && let trait_ref = self.tcx.impl_trait_ref(impl_of).instantiate_identity()
             && find_attr!(self.tcx, trait_ref.def_id, RustcTrivialFieldReads)
         {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 462f014a81f2..46bc9bdee04b 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -516,9 +516,8 @@ pub fn emit_inference_failure_err_with_type_hint(
 
         let Some(InferSource { span, kind }) = local_visitor.infer_source else {
             let silence = if let DefKind::AssocFn = self.tcx.def_kind(body_def_id)
-                && let parent = self.tcx.parent(body_def_id.into())
-                && self.tcx.is_automatically_derived(parent)
-                && let Some(parent) = parent.as_local()
+                && let parent = self.tcx.local_parent(body_def_id)
+                && self.tcx.is_automatically_derived(parent.to_def_id())
                 && let hir::Node::Item(item) = self.tcx.hir_node_by_def_id(parent)
                 && let hir::ItemKind::Impl(imp) = item.kind
                 && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = imp.self_ty.kind
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 4a6d5eb48f8f..a16bbf20238c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1966,10 +1966,9 @@ pub(super) fn suggest_impl_trait(
 
         let mut span = obligation.cause.span;
         if let DefKind::Closure = self.tcx.def_kind(obligation.cause.body_id)
-            && let parent = self.tcx.parent(obligation.cause.body_id.into())
+            && let parent = self.tcx.local_parent(obligation.cause.body_id)
             && let DefKind::Fn | DefKind::AssocFn = self.tcx.def_kind(parent)
             && self.tcx.asyncness(parent).is_async()
-            && let Some(parent) = parent.as_local()
             && let Node::Item(hir::Item { kind: hir::ItemKind::Fn { sig: fn_sig, .. }, .. })
             | Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Fn(fn_sig, _), .. })
             | Node::TraitItem(hir::TraitItem {
diff --git a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
index 8b0743c8d9d5..6c45964da0da 100644
--- a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
+++ b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
@@ -332,7 +332,7 @@ fn check_body(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
                 if let ImplItemImplKind::Trait { trait_item_def_id, .. } = impl_kind
                     && let Ok(trait_item_id) = trait_item_def_id
                 {
-                    let impl_id = cx.tcx.parent(owner_id.into());
+                    let impl_id = cx.tcx.local_parent(owner_id.def_id);
                     let trait_ref = cx.tcx.impl_trait_ref(impl_id).instantiate_identity();
                     (
                         trait_item_id,

From afe3ab6ac5681668a92fb4be7a116bf1be6fb863 Mon Sep 17 00:00:00 2001
From: xtqqczze <45661989+xtqqczze@users.noreply.github.com>
Date: Thu, 26 Mar 2026 00:08:43 +0000
Subject: [PATCH 0978/1059] chore(deps): update rust crate tar to v0.4.45

---
 Cargo.lock                          | 4 ++--
 src/bootstrap/Cargo.lock            | 4 ++--
 src/bootstrap/Cargo.toml            | 2 +-
 src/tools/build-manifest/Cargo.toml | 2 +-
 src/tools/opt-dist/Cargo.toml       | 2 +-
 src/tools/rust-installer/Cargo.toml | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 85997e1886f1..3cb3293efe65 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5461,9 +5461,9 @@ dependencies = [
 
 [[package]]
 name = "tar"
-version = "0.4.44"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
 dependencies = [
  "filetime",
  "libc",
diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index d694f8e13f11..a6d8d4610521 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -757,9 +757,9 @@ dependencies = [
 
 [[package]]
 name = "tar"
-version = "0.4.44"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
 dependencies = [
  "filetime",
  "libc",
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index 7187a5a951de..9b1039bbc4f6 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -50,7 +50,7 @@ serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 sha2 = "0.10"
-tar = { version = "0.4.44", default-features = false }
+tar = { version = "0.4.45", default-features = false }
 termcolor = "1.4"
 toml = "0.5"
 walkdir = "2.4"
diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml
index c0271bbc89b5..2b0afae76da4 100644
--- a/src/tools/build-manifest/Cargo.toml
+++ b/src/tools/build-manifest/Cargo.toml
@@ -10,7 +10,7 @@ serde_json = "1.0"
 anyhow = "1.0.32"
 flate2 = "1.0.26"
 xz2 = "0.1.7"
-tar = "0.4.29"
+tar = "0.4.45"
 sha2 = "0.10.1"
 rayon = "1.5.1"
 hex = "0.4.2"
diff --git a/src/tools/opt-dist/Cargo.toml b/src/tools/opt-dist/Cargo.toml
index 29d302b52566..9b54f62da9bd 100644
--- a/src/tools/opt-dist/Cargo.toml
+++ b/src/tools/opt-dist/Cargo.toml
@@ -13,7 +13,7 @@ humansize = "2"
 sysinfo = { version = "0.38.4", default-features = false, features = ["disk"] }
 fs_extra = "1"
 camino = "1"
-tar = "0.4"
+tar = "0.4.45"
 xz = { version = "0.1", package = "xz2" }
 serde_json = "1"
 glob = "0.3"
diff --git a/src/tools/rust-installer/Cargo.toml b/src/tools/rust-installer/Cargo.toml
index cdd867c5f157..e0c93e3c4477 100644
--- a/src/tools/rust-installer/Cargo.toml
+++ b/src/tools/rust-installer/Cargo.toml
@@ -13,7 +13,7 @@ path = "src/main.rs"
 anyhow = "1.0.19"
 flate2 = "1.0.1"
 rayon = "1.0"
-tar = "0.4.38"
+tar = "0.4.45"
 walkdir = "2"
 xz2 = "0.1.4"
 

From 0c05f6c47875ec444e20411526856999e670b493 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Fri, 27 Mar 2026 10:44:41 -0400
Subject: [PATCH 0979/1059] Add ignore-cross-compile to
 incremental-finalize-fail

The test needs proc-macros to function
---
 tests/run-make/incremental-finalize-fail/rmake.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/run-make/incremental-finalize-fail/rmake.rs b/tests/run-make/incremental-finalize-fail/rmake.rs
index 36ba2a48ca46..96dae4856ca0 100644
--- a/tests/run-make/incremental-finalize-fail/rmake.rs
+++ b/tests/run-make/incremental-finalize-fail/rmake.rs
@@ -1,3 +1,6 @@
+//@ ignore-cross-compile
+//@ needs-crate-type: proc-macro
+
 //! Test that a failure to finalize the incremental compilation session directory
 //! (i.e., the rename from "-working" to the SVH-based name) results in a
 //! note, not an ICE, and that the compilation output is still produced.

From 3ee74ae580e5491aba25ab8a934fb96b876fe385 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Fri, 27 Mar 2026 19:23:37 +0300
Subject: [PATCH 0980/1059] resolve: Never lookup glob names in modules from
 other crates

---
 compiler/rustc_resolve/src/ident.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 1c53d5d03fd6..069018139145 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -638,6 +638,13 @@ fn resolve_ident_in_scope<'r>(
                     Err(ControlFlow::Break(..)) => return decl,
                 }
             }
+            Scope::ModuleGlobs(module, _)
+                if let ModuleKind::Def(_, def_id, _) = module.kind
+                    && !def_id.is_local() =>
+            {
+                // Fast path: external module decoding only creates non-glob declarations.
+                Err(Determined)
+            }
             Scope::ModuleGlobs(module, derive_fallback_lint_id) => {
                 let (adjusted_parent_scope, adjusted_finalize) = if matches!(
                     scope_set,

From 8b44562bc8e2072eb60550b24cb0ca4e6715a8f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 27 Mar 2026 16:57:47 +0100
Subject: [PATCH 0981/1059] Revert "Rollup merge of #154200 -
 resrever:enable-dwarf-call-sites, r=dingxiangfei2009"

This reverts commit 2f1603077b249819ec6ab6ba2a73b2f5b8079382, reversing
changes made to 6e3c17424d5c97770f1de534fb1bec496de4d9cf.
---
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   |  7 ++-----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  1 -
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  3 +--
 tests/codegen-llvm/debuginfo-callsite-flag.rs | 20 -------------------
 4 files changed, 3 insertions(+), 28 deletions(-)
 delete mode 100644 tests/codegen-llvm/debuginfo-callsite-flag.rs

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index a667877e8e51..c3fa86f8a2ad 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -471,7 +471,7 @@ fn dbg_scope_fn(
         // FIXME(eddyb) does this need to be separate from `loc.line` for some reason?
         let scope_line = loc.line;
 
-        let mut flags = DIFlags::FlagPrototyped | DIFlags::FlagAllCallsDescribed;
+        let mut flags = DIFlags::FlagPrototyped;
 
         if fn_abi.ret.layout.is_uninhabited() {
             flags |= DIFlags::FlagNoReturn;
@@ -494,9 +494,6 @@ fn dbg_scope_fn(
         // LLVM LTO can't unify type definitions when a child DIE is a full subprogram definition.
         // When we use this `decl` below, the subprogram definition gets created at the CU level
         // with a DW_AT_specification pointing back to the type's declaration.
-        // FlagAllCallsDescribed cannot appear on the method declaration DIE
-        // because it has no body, which LLVM's verifier rejects.
-        let decl_flags = flags & !DIFlags::FlagAllCallsDescribed;
         let decl = is_method.then(|| unsafe {
             llvm::LLVMRustDIBuilderCreateMethod(
                 DIB(self),
@@ -508,7 +505,7 @@ fn dbg_scope_fn(
                 file_metadata,
                 loc.line,
                 function_type_metadata,
-                decl_flags,
+                flags,
                 spflags & !DISPFlags::SPFlagDefinition,
                 template_parameters,
             )
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index c6c04acc4631..7355d1136792 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -781,7 +781,6 @@ pub(crate) struct DIFlags: u32 {
             const FlagNonTrivial          = (1 << 26);
             const FlagBigEndian           = (1 << 27);
             const FlagLittleEndian        = (1 << 28);
-            const FlagAllCallsDescribed   = (1 << 29);
         }
     }
 
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 392cd0601391..63ff0b2a0a0d 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -779,7 +779,6 @@ ASSERT_DIFLAG_VALUE(FlagThunk, 1 << 25);
 ASSERT_DIFLAG_VALUE(FlagNonTrivial, 1 << 26);
 ASSERT_DIFLAG_VALUE(FlagBigEndian, 1 << 27);
 ASSERT_DIFLAG_VALUE(FlagLittleEndian, 1 << 28);
-static_assert(DINode::DIFlags::FlagAllCallsDescribed == (1 << 29));
 ASSERT_DIFLAG_VALUE(FlagIndirectVirtualBase, (1 << 2) | (1 << 5));
 #undef ASSERT_DIFLAG_VALUE
 
@@ -792,7 +791,7 @@ ASSERT_DIFLAG_VALUE(FlagIndirectVirtualBase, (1 << 2) | (1 << 5));
 // to copying each bit/subvalue.
 static DINode::DIFlags fromRust(LLVMDIFlags Flags) {
   // Check that all set bits are covered by the static assertions above.
-  const unsigned UNKNOWN_BITS = (1 << 31) | (1 << 30) | (1 << 21);
+  const unsigned UNKNOWN_BITS = (1 << 31) | (1 << 30) | (1 << 29) | (1 << 21);
   if (Flags & UNKNOWN_BITS) {
     report_fatal_error("bad LLVMDIFlags");
   }
diff --git a/tests/codegen-llvm/debuginfo-callsite-flag.rs b/tests/codegen-llvm/debuginfo-callsite-flag.rs
deleted file mode 100644
index f86adfcc3626..000000000000
--- a/tests/codegen-llvm/debuginfo-callsite-flag.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Check that DIFlagAllCallsDescribed is set on subprogram definitions.
-
-//@ ignore-msvc (CodeView does not use DIFlagAllCallsDescribed)
-//@ compile-flags: -C debuginfo=2 -C opt-level=1 -C no-prepopulate-passes
-
-// CHECK: {{.*}}DISubprogram{{.*}}name: "foo"{{.*}}DIFlagAllCallsDescribed{{.*}}
-
-#[no_mangle]
-#[inline(never)]
-pub fn foo(x: i32) -> i32 {
-    bar(x + 1)
-}
-
-#[no_mangle]
-#[inline(never)]
-pub fn bar(x: i32) -> i32 {
-    x * 2
-}
-
-fn main() {}

From a1d397e113cb147fddb769b9000bc59b41f7b518 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Fri, 27 Mar 2026 17:45:04 +0100
Subject: [PATCH 0982/1059] Emit pre-expansion feature gate warning for
 `box`'ed struct field pats

---
 compiler/rustc_parse/src/parser/pat.rs        |  3 +++
 .../feature-gate-box_patterns.rs              |  7 ++++-
 .../feature-gate-box_patterns.stderr          | 12 ++++++++-
 .../soft-feature-gate-box_patterns.rs         | 17 ++++++++++++
 .../soft-feature-gate-box_patterns.stderr     | 26 +++++++++++++++++++
 5 files changed, 63 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-box_patterns.rs
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-box_patterns.stderr

diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index a21d19b6d3a2..bdcbb1eb42a8 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1749,6 +1749,9 @@ fn parse_pat_field(&mut self, lo: Span, attrs: AttrVec) -> PResult<'a, PatField>
         } else {
             // Parsing a pattern of the form `(box) (ref) (mut) fieldname`.
             let is_box = self.eat_keyword(exp!(Box));
+            if is_box {
+                self.psess.gated_spans.gate(sym::box_patterns, self.prev_token.span);
+            }
             let boxed_span = self.token.span;
             let mutability = self.parse_mutability();
             let by_ref = self.parse_byref();
diff --git a/tests/ui/feature-gates/feature-gate-box_patterns.rs b/tests/ui/feature-gates/feature-gate-box_patterns.rs
index 8bec16a974e8..9ff6604c9520 100644
--- a/tests/ui/feature-gates/feature-gate-box_patterns.rs
+++ b/tests/ui/feature-gates/feature-gate-box_patterns.rs
@@ -1,4 +1,9 @@
 fn main() {
     let box x = Box::new('c'); //~ ERROR box pattern syntax is experimental
-    println!("x: {}", x);
+    let _: char = x;
+
+    struct Packet { x: Box<i32> }
+
+    let Packet { box x } = Packet { x: Box::new(0) }; //~ ERROR box pattern syntax is experimental
+    let _: i32 = x;
 }
diff --git a/tests/ui/feature-gates/feature-gate-box_patterns.stderr b/tests/ui/feature-gates/feature-gate-box_patterns.stderr
index fb61b2b1810a..6f5ee20925ee 100644
--- a/tests/ui/feature-gates/feature-gate-box_patterns.stderr
+++ b/tests/ui/feature-gates/feature-gate-box_patterns.stderr
@@ -8,6 +8,16 @@ LL |     let box x = Box::new('c');
    = help: add `#![feature(box_patterns)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 1 previous error
+error[E0658]: box pattern syntax is experimental
+  --> $DIR/feature-gate-box_patterns.rs:7:18
+   |
+LL |     let Packet { box x } = Packet { x: Box::new(0) };
+   |                  ^^^^^
+   |
+   = note: see issue #29641 <https://github.com/rust-lang/rust/issues/29641> for more information
+   = help: add `#![feature(box_patterns)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/soft-feature-gate-box_patterns.rs b/tests/ui/feature-gates/soft-feature-gate-box_patterns.rs
new file mode 100644
index 000000000000..8ab0e80e6be3
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-box_patterns.rs
@@ -0,0 +1,17 @@
+// For historical reasons, box patterns don't have a proper pre-expansion feature gate.
+// We're now at least issuing a *warning* for those that only exist before macro expansion.
+// FIXME(#154045): Turn their post-expansion feature gate into a proper pre-expansion one.
+//                 As part of this, move these test cases into `feature-gate-box_patterns.rs`.
+//@ check-pass
+
+fn main() {
+    #[cfg(false)]
+    let box x;
+    //~^ WARN box pattern syntax is experimental
+    //~| WARN unstable syntax can change at any point in the future
+
+    #[cfg(false)]
+    let Packet { box x };
+    //~^ WARN box pattern syntax is experimental
+    //~| WARN unstable syntax can change at any point in the future
+}
diff --git a/tests/ui/feature-gates/soft-feature-gate-box_patterns.stderr b/tests/ui/feature-gates/soft-feature-gate-box_patterns.stderr
new file mode 100644
index 000000000000..a8399b5f01f8
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-box_patterns.stderr
@@ -0,0 +1,26 @@
+warning: box pattern syntax is experimental
+  --> $DIR/soft-feature-gate-box_patterns.rs:9:9
+   |
+LL |     let box x;
+   |         ^^^^^
+   |
+   = note: see issue #29641 <https://github.com/rust-lang/rust/issues/29641> for more information
+   = help: add `#![feature(box_patterns)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: box pattern syntax is experimental
+  --> $DIR/soft-feature-gate-box_patterns.rs:14:18
+   |
+LL |     let Packet { box x };
+   |                  ^^^
+   |
+   = note: see issue #29641 <https://github.com/rust-lang/rust/issues/29641> for more information
+   = help: add `#![feature(box_patterns)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: 2 warnings emitted
+

From a7ad9acc4ada5bef2489435a163eaab30c2db93c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Fri, 27 Mar 2026 17:49:44 +0100
Subject: [PATCH 0983/1059] Clearly exercise all soft feature gates

---
 tests/ui/auto-traits/pre-cfg.rs               |  8 ------
 .../soft-feature-gate-auto_traits.rs          | 12 +++++++++
 .../soft-feature-gate-auto_traits.stderr}     |  2 +-
 .../soft-feature-gate-decl_macro.rs           | 17 ++++++++++++
 .../soft-feature-gate-decl_macro.stderr       | 26 +++++++++++++++++++
 .../soft-feature-gate-trait_alias.rs          | 17 ++++++++++++
 .../soft-feature-gate-trait_alias.stderr      | 26 +++++++++++++++++++
 .../soft-feature-gate-try_blocks.rs           | 13 ++++++++++
 .../soft-feature-gate-try_blocks.stderr}      |  2 +-
 .../try-block-homogeneous-pre-expansion.rs    | 12 ---------
 10 files changed, 113 insertions(+), 22 deletions(-)
 delete mode 100644 tests/ui/auto-traits/pre-cfg.rs
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-auto_traits.rs
 rename tests/ui/{auto-traits/pre-cfg.stderr => feature-gates/soft-feature-gate-auto_traits.stderr} (92%)
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-decl_macro.rs
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-decl_macro.stderr
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-trait_alias.rs
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-trait_alias.stderr
 create mode 100644 tests/ui/feature-gates/soft-feature-gate-try_blocks.rs
 rename tests/ui/{try-block/try-block-homogeneous-pre-expansion.stderr => feature-gates/soft-feature-gate-try_blocks.stderr} (91%)
 delete mode 100644 tests/ui/try-block/try-block-homogeneous-pre-expansion.rs

diff --git a/tests/ui/auto-traits/pre-cfg.rs b/tests/ui/auto-traits/pre-cfg.rs
deleted file mode 100644
index 4820a5353580..000000000000
--- a/tests/ui/auto-traits/pre-cfg.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ check-pass
-
-#[cfg(false)]
-auto trait Foo {}
-//~^ WARN `auto` traits are unstable
-//~| WARN unstable syntax can change at any point in the future, causing a hard error!
-
-fn main() {}
diff --git a/tests/ui/feature-gates/soft-feature-gate-auto_traits.rs b/tests/ui/feature-gates/soft-feature-gate-auto_traits.rs
new file mode 100644
index 000000000000..0ccbaf1e476a
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-auto_traits.rs
@@ -0,0 +1,12 @@
+// For historical reasons, auto traits don't have a proper pre-expansion feature gate.
+// We're now at least issuing a *warning* for those that only exist before macro expansion.
+// FIXME(#154045): Turn their post-expansion feature gate into a proper pre-expansion one.
+//                 As part of this, move these test cases into `feature-gate-auto-traits.rs`.
+//@ check-pass
+
+#[cfg(false)]
+auto trait Foo {}
+//~^ WARN `auto` traits are unstable
+//~| WARN unstable syntax can change at any point in the future
+
+fn main() {}
diff --git a/tests/ui/auto-traits/pre-cfg.stderr b/tests/ui/feature-gates/soft-feature-gate-auto_traits.stderr
similarity index 92%
rename from tests/ui/auto-traits/pre-cfg.stderr
rename to tests/ui/feature-gates/soft-feature-gate-auto_traits.stderr
index 648f9464d61d..20811aadda92 100644
--- a/tests/ui/auto-traits/pre-cfg.stderr
+++ b/tests/ui/feature-gates/soft-feature-gate-auto_traits.stderr
@@ -1,5 +1,5 @@
 warning: `auto` traits are unstable
-  --> $DIR/pre-cfg.rs:4:1
+  --> $DIR/soft-feature-gate-auto_traits.rs:8:1
    |
 LL | auto trait Foo {}
    | ^^^^
diff --git a/tests/ui/feature-gates/soft-feature-gate-decl_macro.rs b/tests/ui/feature-gates/soft-feature-gate-decl_macro.rs
new file mode 100644
index 000000000000..7d2d48503797
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-decl_macro.rs
@@ -0,0 +1,17 @@
+// For historical reasons, decl macros 2.0 don't have a proper pre-expansion feature gate.
+// We're now at least issuing a *warning* for those that only exist before macro expansion.
+// FIXME(#154045): Turn their post-expansion feature gate into a proper pre-expansion one.
+//                 As part of this, move these test cases into `feature-gate-decl_macro.rs`.
+//@ check-pass
+
+#[cfg(false)]
+macro make() {}
+//~^ WARN `macro` is experimental
+//~| WARN unstable syntax can change at any point in the future
+
+#[cfg(false)]
+macro create { () => {} }
+//~^ WARN `macro` is experimental
+//~| WARN unstable syntax can change at any point in the future
+
+fn main() {}
diff --git a/tests/ui/feature-gates/soft-feature-gate-decl_macro.stderr b/tests/ui/feature-gates/soft-feature-gate-decl_macro.stderr
new file mode 100644
index 000000000000..71521626f69b
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-decl_macro.stderr
@@ -0,0 +1,26 @@
+warning: `macro` is experimental
+  --> $DIR/soft-feature-gate-decl_macro.rs:8:1
+   |
+LL | macro make() {}
+   | ^^^^^^^^^^^^^^^
+   |
+   = note: see issue #39412 <https://github.com/rust-lang/rust/issues/39412> for more information
+   = help: add `#![feature(decl_macro)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: `macro` is experimental
+  --> $DIR/soft-feature-gate-decl_macro.rs:13:1
+   |
+LL | macro create { () => {} }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #39412 <https://github.com/rust-lang/rust/issues/39412> for more information
+   = help: add `#![feature(decl_macro)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: 2 warnings emitted
+
diff --git a/tests/ui/feature-gates/soft-feature-gate-trait_alias.rs b/tests/ui/feature-gates/soft-feature-gate-trait_alias.rs
new file mode 100644
index 000000000000..553e88375a2a
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-trait_alias.rs
@@ -0,0 +1,17 @@
+// For historical reasons, trait aliases don't have a proper pre-expansion feature gate.
+// We're now at least issuing a *warning* for those that only exist before macro expansion.
+// FIXME(#154045): Turn their post-expansion feature gate into a proper pre-expansion one.
+//                 As part of this, move these test cases into `feature-gate-trait-alias.rs`.
+//@ check-pass
+
+#[cfg(false)]
+trait Trait =;
+//~^ WARN trait aliases are experimental
+//~| WARN unstable syntax can change at any point in the future
+
+#[cfg(false)]
+trait Trait<T> = Bound where T: Bound;
+//~^ WARN trait aliases are experimental
+//~| WARN unstable syntax can change at any point in the future
+
+fn main() {}
diff --git a/tests/ui/feature-gates/soft-feature-gate-trait_alias.stderr b/tests/ui/feature-gates/soft-feature-gate-trait_alias.stderr
new file mode 100644
index 000000000000..e50d4c36d122
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-trait_alias.stderr
@@ -0,0 +1,26 @@
+warning: trait aliases are experimental
+  --> $DIR/soft-feature-gate-trait_alias.rs:8:1
+   |
+LL | trait Trait =;
+   | ^^^^^^^^^^^^^^
+   |
+   = note: see issue #41517 <https://github.com/rust-lang/rust/issues/41517> for more information
+   = help: add `#![feature(trait_alias)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: trait aliases are experimental
+  --> $DIR/soft-feature-gate-trait_alias.rs:13:1
+   |
+LL | trait Trait<T> = Bound where T: Bound;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #41517 <https://github.com/rust-lang/rust/issues/41517> for more information
+   = help: add `#![feature(trait_alias)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = warning: unstable syntax can change at any point in the future, causing a hard error!
+   = note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
+
+warning: 2 warnings emitted
+
diff --git a/tests/ui/feature-gates/soft-feature-gate-try_blocks.rs b/tests/ui/feature-gates/soft-feature-gate-try_blocks.rs
new file mode 100644
index 000000000000..aa51e60d56b4
--- /dev/null
+++ b/tests/ui/feature-gates/soft-feature-gate-try_blocks.rs
@@ -0,0 +1,13 @@
+// For historical reasons, try blocks don't have a proper pre-expansion feature gate.
+// We're now at least issuing a *warning* for those that only exist before macro expansion.
+// FIXME(#154045): Turn their post-expansion feature gate into a proper pre-expansion one.
+//                 As part of this, move these test cases into `feature-gate-try_blocks.rs`.
+//@ edition: 2018
+//@ check-pass
+
+fn main() {
+    #[cfg(false)]
+    try {}
+    //~^ WARN `try` blocks are unstable
+    //~| WARN unstable syntax can change at any point
+}
diff --git a/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr b/tests/ui/feature-gates/soft-feature-gate-try_blocks.stderr
similarity index 91%
rename from tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr
rename to tests/ui/feature-gates/soft-feature-gate-try_blocks.stderr
index 67cbcb42fb47..2b20f40e09d0 100644
--- a/tests/ui/try-block/try-block-homogeneous-pre-expansion.stderr
+++ b/tests/ui/feature-gates/soft-feature-gate-try_blocks.stderr
@@ -1,5 +1,5 @@
 warning: `try` blocks are unstable
-  --> $DIR/try-block-homogeneous-pre-expansion.rs:9:5
+  --> $DIR/soft-feature-gate-try_blocks.rs:10:5
    |
 LL |     try {}
    |     ^^^^^^
diff --git a/tests/ui/try-block/try-block-homogeneous-pre-expansion.rs b/tests/ui/try-block/try-block-homogeneous-pre-expansion.rs
deleted file mode 100644
index 980f97ca0672..000000000000
--- a/tests/ui/try-block/try-block-homogeneous-pre-expansion.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ check-pass
-//@ edition: 2018
-
-// For historical reasons this is only a warning, not an error.
-// See <https://github.com/rust-lang/rust/issues/152501>
-
-fn main() {
-    #[cfg(false)]
-    try {}
-    //~^ warn `try` blocks are unstable
-    //~| warn unstable syntax can change at any point
-}

From db49482afe01c3fc207e6efa1bc6cf67911ce585 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 27 Mar 2026 22:07:43 +0100
Subject: [PATCH 0984/1059] ci: bump checkout action

---
 src/tools/miri/.github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index 4eeba3022892..9129562efe1d 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -58,7 +58,7 @@ jobs:
     env:
       HOST_TARGET: ${{ matrix.host_target }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: install multiarch
         if: ${{ matrix.multiarch != '' }}
         run: |
@@ -105,7 +105,7 @@ jobs:
     name: style checks
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: ./.github/workflows/setup
 
       - name: rustfmt
@@ -121,7 +121,7 @@ jobs:
     name: bootstrap build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       # Deliberately skipping `./.github/workflows/setup` as we do our own setup
       - name: Add cache for cargo
         id: cache
@@ -156,7 +156,7 @@ jobs:
     name: coverage report
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: ./.github/workflows/setup
       - name: coverage
         run: ./miri test --coverage
@@ -191,7 +191,7 @@ jobs:
         pull-requests: write
     if: ${{ github.event_name == 'schedule' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 256 # get a bit more of the history
       - name: install josh-sync

From 5983fd3bed08c67f8b39cc44d2bbe76579b35827 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 27 Mar 2026 22:08:45 +0100
Subject: [PATCH 0985/1059] bump sysroot builder (support for new build-dir
 layout)

---
 src/tools/miri/cargo-miri/Cargo.lock | 72 +++++++++++++---------------
 src/tools/miri/cargo-miri/Cargo.toml |  2 +-
 2 files changed, 34 insertions(+), 40 deletions(-)

diff --git a/src/tools/miri/cargo-miri/Cargo.lock b/src/tools/miri/cargo-miri/Cargo.lock
index 45be05fcc7f7..977728f63499 100644
--- a/src/tools/miri/cargo-miri/Cargo.lock
+++ b/src/tools/miri/cargo-miri/Cargo.lock
@@ -230,9 +230,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.11"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b881c015c729b43105bbd3702a9bdecee28fafaa21126d1d62e454ec011a4b7"
+checksum = "eec3905e8201688412f6f4b1f6c86d38b3ee6578f59ba85f41330a3af61e8365"
 dependencies = [
  "anyhow",
  "rustc_version",
@@ -339,11 +339,11 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.9"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+checksum = "876ac351060d4f882bb1032b6369eb0aef79ad9df1ea8bc404874d8cc3d0cd98"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -392,45 +392,42 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.23"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+checksum = "f8195ca05e4eb728f4ba94f3e3291661320af739c4e43779cbdfae82ab239fcc"
 dependencies = [
  "indexmap",
- "serde",
+ "serde_core",
  "serde_spanned",
  "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.22.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_write",
+ "toml_parser",
+ "toml_writer",
  "winnow",
 ]
 
 [[package]]
-name = "toml_write"
-version = "0.1.2"
+name = "toml_datetime"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d282ade6016312faf3e41e57ebbba0c073e4056dab1232ab1cb624199648f8ed"
 
 [[package]]
 name = "unicode-ident"
@@ -489,12 +486,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
-dependencies = [
- "memchr",
-]
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
 
 [[package]]
 name = "wit-bindgen"
diff --git a/src/tools/miri/cargo-miri/Cargo.toml b/src/tools/miri/cargo-miri/Cargo.toml
index e8da7f2ca8a7..568bb29f49f8 100644
--- a/src/tools/miri/cargo-miri/Cargo.toml
+++ b/src/tools/miri/cargo-miri/Cargo.toml
@@ -18,7 +18,7 @@ directories = "6"
 rustc_version = "0.4"
 serde_json = "1.0.40"
 cargo_metadata = "0.23"
-rustc-build-sysroot = "0.5.10"
+rustc-build-sysroot = "0.5.12"
 
 # Enable some feature flags that dev-dependencies need but dependencies
 # do not.  This makes `./miri install` after `./miri build` faster.

From d9a72196631ef948aba67da2ed109d581dd27dbf Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 27 Mar 2026 22:09:35 +0100
Subject: [PATCH 0986/1059] test with new build dir layout

---
 src/tools/miri/ci/ci.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 6c0bceac7731..9bacbbcf4597 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -28,6 +28,7 @@ begingroup "Building Miri"
 export RUSTFLAGS="-D warnings"
 export CARGO_INCREMENTAL=0
 export CARGO_EXTRA_FLAGS="--locked"
+export CARGO_UNSTABLE_BUILD_DIR_NEW_LAYOUT=true
 
 # Determine configuration for installed build (used by test-cargo-miri and `./miri bench`).
 # We use the default set of features for this.

From 4ca63285361b446fd2ab17bedf2d6a3bc81d5723 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 27 Mar 2026 18:50:08 -0400
Subject: [PATCH 0987/1059] Remove `repr(u8)`

---
 library/core/src/net/ip_addr.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 6e16184ca4f6..1d303e7d307d 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -223,7 +223,6 @@ fn hash<H: Hasher>(&self, state: &mut H) {
 /// [IETF RFC 4291 section 2.7]: https://datatracker.ietf.org/doc/html/rfc4291#section-2.7
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[unstable(feature = "ip", issue = "27709")]
-#[repr(u8)]
 pub enum Ipv6MulticastScope {
     /// Reserved by IETF.
     #[doc(hidden)]

From 1f1785712384f90b52a01e966ac70883efc8b9d3 Mon Sep 17 00:00:00 2001
From: Laine Taffin Altman <alexanderaltman@me.com>
Date: Fri, 27 Mar 2026 17:24:27 -0700
Subject: [PATCH 0988/1059] std_detect on AArch64 Darwin: Detect
 FEAT_SVE_B16B16

This is now exposed via `sysctl` as of macOS "Tahoe" 26.4 (or possibly earlier).
---
 library/std_detect/src/detect/os/darwin/aarch64.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
index a23d65a23d81..5805d5cc3646 100644
--- a/library/std_detect/src/detect/os/darwin/aarch64.rs
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -81,6 +81,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     let sme_f64f64 = _sysctlbyname(c"hw.optional.arm.FEAT_SME_F64F64");
     let sme_i16i64 = _sysctlbyname(c"hw.optional.arm.FEAT_SME_I16I64");
     let ssbs = _sysctlbyname(c"hw.optional.arm.FEAT_SSBS");
+    let sve_b16b16 = _sysctlbyname(c"hw.optional.arm.FEAT_SVE_B16B16");
     let wfxt = _sysctlbyname(c"hw.optional.arm.FEAT_WFxT");
 
     // The following features are not exposed by `is_aarch64_feature_detected`,
@@ -160,6 +161,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     enable_feature(Feature::sme_f64f64, sme_f64f64);
     enable_feature(Feature::sme_i16i64, sme_i16i64);
     enable_feature(Feature::ssbs, ssbs);
+    enable_feature(Feature::sve_b16b16, sve_b16b16);
     enable_feature(Feature::wfxt, wfxt);
 
     value

From d470684a43b467924aa6338ae2e4f84fcefb5ab4 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 28 Mar 2026 14:18:26 +1100
Subject: [PATCH 0989/1059] Revert "Unstable book options parser"

This reverts commit 6fd846676801486d304030698cc8dac261b98680, reversing
changes made to fda6d37bb88ee12fd50fa54d15859f1f91b74f55.
---
 Cargo.lock                                    |   2 -
 compiler/rustc_session/src/options.rs         | 590 +++++++++++++++++-
 .../rustc_session/src/options/unstable.rs     | 585 -----------------
 src/tools/unstable-book-gen/Cargo.toml        |   2 -
 src/tools/unstable-book-gen/src/main.rs       | 200 +-----
 src/tools/unstable-book-gen/src/tests.rs      |  73 ---
 6 files changed, 587 insertions(+), 865 deletions(-)
 delete mode 100644 compiler/rustc_session/src/options/unstable.rs
 delete mode 100644 src/tools/unstable-book-gen/src/tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index e7f713936f16..91daa229a95e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6088,8 +6088,6 @@ name = "unstable-book-gen"
 version = "0.1.0"
 dependencies = [
  "num-traits",
- "proc-macro2",
- "syn 2.0.110",
  "tidy",
 ]
 
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index a9db6979cc79..7abaae1c1760 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -605,10 +605,6 @@ pub fn is_target_modifier(flag_name: &str) -> bool {
 /// necessary code. The main gotcha of this macro is the `cgsetters` module which is a bunch of
 /// generated code to parse an option into its respective field in the struct. There are a few
 /// hand-written parsers for parsing specific types of values in this module.
-///
-/// Note: this macro's invocation is also parsed by a `syn`-based parser in
-/// `src/tools/unstable-book-gen/src/main.rs` to extract unstable option names and descriptions.
-/// If the format of this macro changes, that parser may need to be updated as well.
 macro_rules! options {
     ($struct_name:ident, $tmod_enum_name:ident, $stat:ident, $optmod:ident, $prefix:expr, $outputname:expr,
      $($( #[$attr:meta] )* $opt:ident : $t:ty = (
@@ -2219,4 +2215,588 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     // - src/doc/rustc/src/codegen-options/index.md
 }
 
-include!("options/unstable.rs");
+options! {
+    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
+
+    // If you add a new option, please update:
+    // - compiler/rustc_interface/src/tests.rs
+    // - src/doc/unstable-book/src/compiler-flags
+
+    // tidy-alphabetical-start
+    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
+        "only allow the listed language features to be enabled in code (comma separated)"),
+    always_encode_mir: bool = (false, parse_bool, [TRACKED],
+        "encode MIR of all functions into the crate metadata (default: no)"),
+    annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED],
+        "emit debug info for compiler-generated move and copy operations \
+        to make them visible in profilers. Can be a boolean or a size limit in bytes (default: disabled)"),
+    assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "assert that the incremental cache is in given state: \
+         either `loaded` or `not-loaded`."),
+    assume_incomplete_release: bool = (false, parse_bool, [TRACKED],
+        "make cfg(version) treat the current version as incomplete (default: no)"),
+    autodiff: Vec<crate::config::AutoDiff> = (Vec::new(), parse_autodiff, [TRACKED],
+        "a list of autodiff flags to enable
+        Mandatory setting:
+        `=Enable`
+        Optional extra settings:
+        `=PrintTA`
+        `=PrintAA`
+        `=PrintPerf`
+        `=PrintSteps`
+        `=PrintModBefore`
+        `=PrintModAfter`
+        `=PrintModFinal`
+        `=PrintPasses`,
+        `=NoPostopt`
+        `=LooseTypes`
+        `=Inline`
+        Multiple options can be combined with commas."),
+    #[rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field")]
+    binary_dep_depinfo: bool = (false, parse_bool, [TRACKED],
+        "include artifacts (sysroot, crate dependencies) used during compilation in dep-info \
+        (default: no)"),
+    box_noalias: bool = (true, parse_bool, [TRACKED],
+        "emit noalias metadata for box (default: yes)"),
+    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED TARGET_MODIFIER],
+        "set options for branch target identification and pointer authentication on AArch64"),
+    build_sdylib_interface: bool = (false, parse_bool, [UNTRACKED],
+        "whether the stable interface is being built"),
+    cache_proc_macros: bool = (false, parse_bool, [TRACKED],
+        "cache the results of derive proc macro invocations (potentially unsound!) (default: no"),
+    cf_protection: CFProtection = (CFProtection::None, parse_cfprotection, [TRACKED],
+        "instrument control-flow architecture protection"),
+    check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],
+        "show all expected values in check-cfg diagnostics (default: no)"),
+    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_cargo_src_file_hash, [TRACKED],
+        "hash algorithm of source files used to check freshness in cargo (`blake3` or `sha256`)"),
+    codegen_backend: Option<String> = (None, parse_opt_string, [TRACKED],
+        "the backend to use"),
+    codegen_source_order: bool = (false, parse_bool, [UNTRACKED],
+        "emit mono items in the order of spans in source files (default: no)"),
+    contract_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "emit runtime checks for contract pre- and post-conditions (default: no)"),
+    coverage_options: CoverageOptions = (CoverageOptions::default(), parse_coverage_options, [TRACKED],
+        "control details of coverage instrumentation"),
+    crate_attr: Vec<String> = (Vec::new(), parse_string_push, [TRACKED],
+        "inject the given attribute in the crate"),
+    cross_crate_inline_threshold: InliningThreshold = (InliningThreshold::Sometimes(100), parse_inlining_threshold, [TRACKED],
+        "threshold to allow cross crate inlining of functions"),
+    debug_info_for_profiling: bool = (false, parse_bool, [TRACKED],
+        "emit discriminators and other data necessary for AutoFDO"),
+    debug_info_type_line_numbers: bool = (false, parse_bool, [TRACKED],
+        "emit type and line information for additional data types (default: no)"),
+    debuginfo_compression: DebugInfoCompression = (DebugInfoCompression::None, parse_debuginfo_compression, [TRACKED],
+        "compress debug info sections (none, zlib, zstd, default: none)"),
+    deduplicate_diagnostics: bool = (true, parse_bool, [UNTRACKED],
+        "deduplicate identical diagnostics (default: yes)"),
+    default_visibility: Option<SymbolVisibility> = (None, parse_opt_symbol_visibility, [TRACKED],
+        "overrides the `default_visibility` setting of the target"),
+    dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
+        "in dep-info output, omit targets for tracking dependencies of the dep-info files \
+        themselves (default: no)"),
+    direct_access_external_data: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "Direct or use GOT indirect to reference external data symbols"),
+    dual_proc_macros: bool = (false, parse_bool, [TRACKED],
+        "load proc macros for both target and host, but only link to the target (default: no)"),
+    dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
+        "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv) \
+        (default: no)"),
+    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "dump MIR state to file.
+        `val` is used to select which passes and functions to dump. For example:
+        `all` matches all passes and functions,
+        `foo` matches all passes for functions whose name contains 'foo',
+        `foo & ConstProp` only the 'ConstProp' pass for function names containing 'foo',
+        `foo | bar` all passes for function names containing 'foo' or 'bar'."),
+    dump_mir_dataflow: bool = (false, parse_bool, [UNTRACKED],
+        "in addition to `.mir` files, create graphviz `.dot` files with dataflow results \
+        (default: no)"),
+    dump_mir_dir: String = ("mir_dump".to_string(), parse_string, [UNTRACKED],
+        "the directory the MIR is dumped into (default: `mir_dump`)"),
+    dump_mir_exclude_alloc_bytes: bool = (false, parse_bool, [UNTRACKED],
+        "exclude the raw bytes of allocations when dumping MIR (used in tests) (default: no)"),
+    dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
+        "exclude the pass number when dumping MIR (used in tests) (default: no)"),
+    dump_mir_graphviz: bool = (false, parse_bool, [UNTRACKED],
+        "in addition to `.mir` files, create graphviz `.dot` files (default: no)"),
+    dump_mono_stats: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
+        parse_switch_with_opt_path, [UNTRACKED],
+        "output statistics about monomorphization collection"),
+    dump_mono_stats_format: DumpMonoStatsFormat = (DumpMonoStatsFormat::Markdown, parse_dump_mono_stats, [UNTRACKED],
+        "the format to use for -Z dump-mono-stats (`markdown` (default) or `json`)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
+    dwarf_version: Option<u32> = (None, parse_opt_number, [TRACKED],
+        "version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),
+    dylib_lto: bool = (false, parse_bool, [UNTRACKED],
+        "enables LTO for dylib crate type"),
+    eagerly_emit_delayed_bugs: bool = (false, parse_bool, [UNTRACKED],
+        "emit delayed bugs eagerly as errors instead of stashing them and emitting \
+        them only if an error has not been emitted"),
+    ehcont_guard: bool = (false, parse_bool, [TRACKED],
+        "generate Windows EHCont Guard tables"),
+    embed_metadata: bool = (true, parse_bool, [TRACKED],
+        "embed metadata in rlibs and dylibs (default: yes)"),
+    embed_source: bool = (false, parse_bool, [TRACKED],
+        "embed source text in DWARF debug sections (default: no)"),
+    emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
+        "emit a section containing stack size metadata (default: no)"),
+    emscripten_wasm_eh: bool = (true, parse_bool, [TRACKED],
+        "Use WebAssembly error handling for wasm32-unknown-emscripten"),
+    enforce_type_length_limit: bool = (false, parse_bool, [TRACKED],
+        "enforce the type length limit when monomorphizing instances in codegen"),
+    experimental_default_bounds: bool = (false, parse_bool, [TRACKED],
+        "enable default bounds for experimental group of auto traits"),
+    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
+        "export symbols from executables, as if they were dynamic libraries"),
+    external_clangrt: bool = (false, parse_bool, [UNTRACKED],
+        "rely on user specified linker commands to find clangrt"),
+    extra_const_ub_checks: bool = (false, parse_bool, [TRACKED],
+        "turns on more checks to detect const UB, which can be slow (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field")]
+    fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
+        (default: no)"),
+    fixed_x18: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "make the x18 register reserved on AArch64 (default: no)"),
+    flatten_format_args: bool = (true, parse_bool, [TRACKED],
+        "flatten nested format_args!() and literals into a simplified format_args!() call \
+        (default: yes)"),
+    fmt_debug: FmtDebug = (FmtDebug::Full, parse_fmt_debug, [TRACKED],
+        "how detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
+        `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
+    force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
+        "force all crates to be `rustc_private` unstable (default: no)"),
+    function_return: FunctionReturn = (FunctionReturn::default(), parse_function_return, [TRACKED],
+        "replace returns with jumps to `__x86_return_thunk` (default: `keep`)"),
+    function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether each function should go in its own section"),
+    future_incompat_test: bool = (false, parse_bool, [UNTRACKED],
+        "forces all lints to be future incompatible, used for internal testing (default: no)"),
+    graphviz_dark_mode: bool = (false, parse_bool, [UNTRACKED],
+        "use dark-themed colors in graphviz output (default: no)"),
+    graphviz_font: String = ("Courier, monospace".to_string(), parse_string, [UNTRACKED],
+        "use the given `fontname` in graphviz output; can be overridden by setting \
+        environment variable `RUSTC_GRAPHVIZ_FONT` (default: `Courier, monospace`)"),
+    has_thread_local: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "explicitly enable the `cfg(target_thread_local)` directive"),
+    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
+    higher_ranked_assumptions: bool = (false, parse_bool, [TRACKED],
+        "allow deducing higher-ranked outlives assumptions from coroutines when proving auto traits"),
+    hint_mostly_unused: bool = (false, parse_bool, [TRACKED],
+        "hint that most of this crate will go unused, to minimize work for uncalled functions"),
+    human_readable_cgu_names: bool = (false, parse_bool, [TRACKED],
+        "generate human-readable, predictable names for codegen units (default: no)"),
+    identify_regions: bool = (false, parse_bool, [UNTRACKED],
+        "display unnamed regions as `'<id>`, using a non-ident unique id (default: no)"),
+    ignore_directory_in_diagnostics_source_blocks: Vec<String> = (Vec::new(), parse_string_push, [UNTRACKED],
+        "do not display the source code block in diagnostics for files in the directory"),
+    incremental_ignore_spans: bool = (false, parse_bool, [TRACKED],
+        "ignore spans during ICH computation -- used for testing (default: no)"),
+    incremental_info: bool = (false, parse_bool, [UNTRACKED],
+        "print high-level information about incremental reuse (or the lack thereof) \
+        (default: no)"),
+    incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
+        "verify extended properties for incr. comp. (default: no):
+        - hashes of green query instances
+        - hash collisions of query keys
+        - hash collisions when creating dep-nodes"),
+    indirect_branch_cs_prefix: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "add `cs` prefix to `call` and `jmp` to indirect thunks (default: no)"),
+    inline_llvm: bool = (true, parse_bool, [TRACKED],
+        "enable LLVM inlining (default: yes)"),
+    inline_mir: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable MIR inlining (default: no)"),
+    inline_mir_forwarder_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "inlining threshold when the caller is a simple forwarding function (default: 30)"),
+    inline_mir_hint_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "inlining threshold for functions with inline hint (default: 100)"),
+    inline_mir_preserve_debug: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "when MIR inlining, whether to preserve debug info for callee variables \
+        (default: preserve for debuginfo != None, otherwise remove)"),
+    inline_mir_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "a default MIR inlining threshold (default: 50)"),
+    input_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print some statistics about AST and HIR (default: no)"),
+    instrument_mcount: bool = (false, parse_bool, [TRACKED],
+        "insert function instrument code for mcount-based tracing (default: no)"),
+    instrument_xray: Option<InstrumentXRay> = (None, parse_instrument_xray, [TRACKED],
+        "insert function instrument code for XRay-based tracing (default: no)
+         Optional extra settings:
+         `=always`
+         `=never`
+         `=ignore-loops`
+         `=instruction-threshold=N`
+         `=skip-entry`
+         `=skip-exit`
+         Multiple options can be combined with commas."),
+    large_data_threshold: Option<u64> = (None, parse_opt_number, [TRACKED],
+        "set the threshold for objects to be stored in a \"large data\" section \
+         (only effective with -Ccode-model=medium, default: 65536)"),
+    layout_seed: Option<u64> = (None, parse_opt_number, [TRACKED],
+        "seed layout randomization"),
+    link_directives: bool = (true, parse_bool, [TRACKED],
+        "honor #[link] directives in the compiled crate (default: yes)"),
+    link_native_libraries: bool = (true, parse_bool, [UNTRACKED],
+        "link native libraries in the linker invocation (default: yes)"),
+    link_only: bool = (false, parse_bool, [TRACKED],
+        "link the `.rlink` file generated by `-Z no-link` (default: no)"),
+    lint_llvm_ir: bool = (false, parse_bool, [TRACKED],
+        "lint LLVM IR (default: no)"),
+    lint_mir: bool = (false, parse_bool, [UNTRACKED],
+        "lint MIR before and after each transformation"),
+    llvm_module_flag: Vec<(String, u32, String)> = (Vec::new(), parse_llvm_module_flag, [TRACKED],
+        "a list of module flags to pass to LLVM (space separated)"),
+    llvm_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
+        "a list LLVM plugins to enable (space separated)"),
+    llvm_time_trace: bool = (false, parse_bool, [UNTRACKED],
+        "generate JSON tracing data file from LLVM data (default: no)"),
+    location_detail: LocationDetail = (LocationDetail::all(), parse_location_detail, [TRACKED],
+        "what location details should be tracked when using caller_location, either \
+        `none`, or a comma separated list of location details, for which \
+        valid options are `file`, `line`, and `column` (default: `file,line,column`)"),
+    ls: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
+        "decode and print various parts of the crate metadata for a library crate \
+        (space separated)"),
+    macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
+        "show macro backtraces (default: no)"),
+    macro_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print some statistics about macro expansions (default: no)"),
+    maximal_hir_to_mir_coverage: bool = (false, parse_bool, [TRACKED],
+        "save as much information as possible about the correspondence between MIR and HIR \
+        as source scopes (default: no)"),
+    merge_functions: Option<MergeFunctions> = (None, parse_merge_functions, [TRACKED],
+        "control the operation of the MergeFunctions LLVM pass, taking \
+        the same values as the target option of the same name"),
+    meta_stats: bool = (false, parse_bool, [UNTRACKED],
+        "gather metadata statistics (default: no)"),
+    metrics_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
+        "the directory metrics emitted by rustc are dumped into (implicitly enables default set of metrics)"),
+    min_function_alignment: Option<Align> = (None, parse_align, [TRACKED],
+        "align all functions to at least this many bytes. Must be a power of 2"),
+    min_recursion_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "set a minimum recursion limit (final limit = max(this, recursion_limit_from_crate))"),
+    mir_emit_retag: bool = (false, parse_bool, [TRACKED],
+        "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
+        (default: no)"),
+    mir_enable_passes: Vec<(String, bool)> = (Vec::new(), parse_list_with_polarity, [TRACKED],
+        "use like `-Zmir-enable-passes=+DestinationPropagation,-InstSimplify`. Forces the \
+        specified passes to be enabled, overriding all other checks. In particular, this will \
+        enable unsound (known-buggy and hence usually disabled) passes without further warning! \
+        Passes that are not specified are enabled or disabled by other flags as usual."),
+    mir_include_spans: MirIncludeSpans = (MirIncludeSpans::default(), parse_mir_include_spans, [UNTRACKED],
+        "include extra comments in mir pretty printing, like line numbers and statement indices, \
+         details about types, etc. (boolean for all passes, 'nll' to enable in NLL MIR only, default: 'nll')"),
+    mir_opt_bisect_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "limit the number of MIR optimization pass executions (global across all bodies). \
+        Pass executions after this limit are skipped and reported. (default: no limit)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field")]
+    mir_opt_level: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "MIR optimization level (0-4; default: 1 in non optimized builds and 2 in optimized builds)"),
+    mir_preserve_ub: bool = (false, parse_bool, [TRACKED],
+        "keep place mention statements and reads in trivial SwitchInt terminators, which are interpreted \
+        e.g., by miri; implies -Zmir-opt-level=0 (default: no)"),
+    mir_strip_debuginfo: MirStripDebugInfo = (MirStripDebugInfo::None, parse_mir_strip_debuginfo, [TRACKED],
+        "Whether to remove some of the MIR debug info from methods.  Default: None"),
+    move_size_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "the size at which the `large_assignments` lint starts to be emitted"),
+    mutable_noalias: bool = (true, parse_bool, [TRACKED],
+        "emit noalias metadata for mutable references (default: yes)"),
+    namespaced_crates: bool = (false, parse_bool, [TRACKED],
+        "allow crates to be namespaced by other crates (default: no)"),
+    next_solver: NextSolverConfig = (NextSolverConfig::default(), parse_next_solver_config, [TRACKED],
+        "enable and configure the next generation trait solver used by rustc"),
+    nll_facts: bool = (false, parse_bool, [UNTRACKED],
+        "dump facts from NLL analysis into side files (default: no)"),
+    nll_facts_dir: String = ("nll-facts".to_string(), parse_string, [UNTRACKED],
+        "the directory the NLL facts are dumped into (default: `nll-facts`)"),
+    no_analysis: bool = (false, parse_no_value, [UNTRACKED],
+        "parse and expand the source, but run no analysis"),
+    no_codegen: bool = (false, parse_no_value, [TRACKED_NO_CRATE_HASH],
+        "run all passes except codegen; no output"),
+    no_generate_arange_section: bool = (false, parse_no_value, [TRACKED],
+        "omit DWARF address ranges that give faster lookups"),
+    no_implied_bounds_compat: bool = (false, parse_bool, [TRACKED],
+        "disable the compatibility version of the `implied_bounds_ty` query"),
+    no_leak_check: bool = (false, parse_no_value, [UNTRACKED],
+        "disable the 'leak check' for subtyping; unsound, but useful for tests"),
+    no_link: bool = (false, parse_no_value, [TRACKED],
+        "compile without linking"),
+    no_parallel_backend: bool = (false, parse_no_value, [UNTRACKED],
+        "run LLVM in non-parallel mode (while keeping codegen-units and ThinLTO)"),
+    no_profiler_runtime: bool = (false, parse_no_value, [TRACKED],
+        "prevent automatic injection of the profiler_builtins crate"),
+    no_steal_thir: bool = (false, parse_bool, [UNTRACKED],
+        "don't steal the THIR when we're done with it; useful for rustc drivers (default: no)"),
+    no_trait_vptr: bool = (false, parse_no_value, [TRACKED],
+        "disable generation of trait vptr in vtable for upcasting"),
+    no_unique_section_names: bool = (false, parse_bool, [TRACKED],
+        "do not use unique names for text and data sections when -Z function-sections is used"),
+    normalize_docs: bool = (false, parse_bool, [TRACKED],
+        "normalize associated items in rustdoc when generating documentation"),
+    offload: Vec<crate::config::Offload> = (Vec::new(), parse_offload, [TRACKED],
+        "a list of offload flags to enable
+        Mandatory setting:
+        `=Enable`
+        Currently the only option available"),
+    on_broken_pipe: OnBrokenPipe = (OnBrokenPipe::Default, parse_on_broken_pipe, [TRACKED],
+        "behavior of std::io::ErrorKind::BrokenPipe (SIGPIPE)"),
+    osx_rpath_install_name: bool = (false, parse_bool, [TRACKED],
+        "pass `-install_name @rpath/...` to the macOS linker (default: no)"),
+    packed_bundled_libs: bool = (false, parse_bool, [TRACKED],
+        "change rlib format to store native libraries as archives"),
+    panic_abort_tests: bool = (false, parse_bool, [TRACKED],
+        "support compiling tests with panic=abort (default: no)"),
+    panic_in_drop: PanicStrategy = (PanicStrategy::Unwind, parse_panic_strategy, [TRACKED],
+        "panic strategy for panics in drops"),
+    parse_crate_root_only: bool = (false, parse_bool, [UNTRACKED],
+        "parse the crate root file only; do not parse other files, compile, assemble, or link \
+        (default: no)"),
+    patchable_function_entry: PatchableFunctionEntry = (PatchableFunctionEntry::default(), parse_patchable_function_entry, [TRACKED],
+        "nop padding at function entry"),
+    plt: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether to use the PLT when calling into shared libraries;
+        only has effect for PIC code on systems with ELF binaries
+        (default: PLT is disabled if full relro is enabled on x86_64)"),
+    polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
+        "enable polonius-based borrow-checker (default: no)"),
+    pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
+        "a single extra argument to prepend the linker invocation (can be used several times)"),
+    pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
+        "extra arguments to prepend to the linker invocation (space separated)"),
+    precise_enum_drop_elaboration: bool = (true, parse_bool, [TRACKED],
+        "use a more precise version of drop elaboration for matches on enums (default: yes). \
+        This results in better codegen, but has caused miscompilations on some tier 2 platforms. \
+        See #77382 and #74551."),
+    #[rustc_lint_opt_deny_field_access("use `Session::print_codegen_stats` instead of this field")]
+    print_codegen_stats: bool = (false, parse_bool, [UNTRACKED],
+        "print codegen statistics (default: no)"),
+    print_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
+        "print the LLVM optimization passes being run (default: no)"),
+    print_mono_items: bool = (false, parse_bool, [UNTRACKED],
+        "print the result of the monomorphization collection pass (default: no)"),
+    print_type_sizes: bool = (false, parse_bool, [UNTRACKED],
+        "print layout information for each type encountered (default: no)"),
+    proc_macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
+         "show backtraces for panics during proc-macro execution (default: no)"),
+    proc_macro_execution_strategy: ProcMacroExecutionStrategy = (ProcMacroExecutionStrategy::SameThread,
+        parse_proc_macro_execution_strategy, [UNTRACKED],
+        "how to run proc-macro code (default: same-thread)"),
+    profile_closures: bool = (false, parse_no_value, [UNTRACKED],
+        "profile size of closures"),
+    profile_sample_use: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "use the given `.prof` file for sampled profile-guided optimization (also known as AutoFDO)"),
+    profiler_runtime: String = (String::from("profiler_builtins"), parse_string, [TRACKED],
+        "name of the profiler runtime crate to automatically inject (default: `profiler_builtins`)"),
+    query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
+        "enable queries of the dependency graph for regression testing (default: no)"),
+    randomize_layout: bool = (false, parse_bool, [TRACKED],
+        "randomize the layout of types (default: no)"),
+    reg_struct_return: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "On x86-32 targets, it overrides the default ABI to return small structs in registers.
+        It is UNSOUND to link together crates that use different values for this flag!"),
+    regparm: Option<u32> = (None, parse_opt_number, [TRACKED TARGET_MODIFIER],
+        "On x86-32 targets, setting this to N causes the compiler to pass N arguments \
+        in registers EAX, EDX, and ECX instead of on the stack for\
+        \"C\", \"cdecl\", and \"stdcall\" fn.\
+        It is UNSOUND to link together crates that use different values for this flag!"),
+    relax_elf_relocations: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "whether ELF relocations can be relaxed"),
+    remap_cwd_prefix: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "remap paths under the current working directory to this path prefix"),
+    remark_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
+        "directory into which to write optimization remarks (if not specified, they will be \
+written to standard error output)"),
+    retpoline: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "enables retpoline-indirect-branches and retpoline-indirect-calls target features (default: no)"),
+    retpoline_external_thunk: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
+        "enables retpoline-external-thunk, retpoline-indirect-branches and retpoline-indirect-calls \
+        target features (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::sanitizers()` instead of this field")]
+    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED TARGET_MODIFIER],
+        "use a sanitizer"),
+    sanitizer_cfi_canonical_jump_tables: Option<bool> = (Some(true), parse_opt_bool, [TRACKED],
+        "enable canonical jump tables (default: yes)"),
+    sanitizer_cfi_generalize_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable generalizing pointer types (default: no)"),
+    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED TARGET_MODIFIER],
+        "enable normalizing integer types (default: no)"),
+    sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
+        "additional ABI list files that control how shadow parameters are passed (comma separated)"),
+    sanitizer_kcfi_arity: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable KCFI arity indicator (default: no)"),
+    sanitizer_memory_track_origins: usize = (0, parse_sanitizer_memory_track_origins, [TRACKED],
+        "enable origins tracking in MemorySanitizer"),
+    sanitizer_recover: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED],
+        "enable recovery for selected sanitizers"),
+    saturating_float_casts: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "make float->int casts UB-free: numbers outside the integer type's range are clipped to \
+        the max/min integer respectively, and NaN is mapped to 0 (default: yes)"),
+    self_profile: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
+        parse_switch_with_opt_path, [UNTRACKED],
+        "run the self profiler and output the raw event data"),
+    self_profile_counter: String = ("wall-time".to_string(), parse_string, [UNTRACKED],
+        "counter used by the self profiler (default: `wall-time`), one of:
+        `wall-time` (monotonic clock, i.e. `std::time::Instant`)
+        `instructions:u` (retired instructions, userspace-only)
+        `instructions-minus-irqs:u` (subtracting hardware interrupt counts for extra accuracy)"
+    ),
+    /// keep this in sync with the event filter names in librustc_data_structures/profiling.rs
+    self_profile_events: Option<Vec<String>> = (None, parse_opt_comma_list, [UNTRACKED],
+        "specify the events recorded by the self profiler;
+        for example: `-Z self-profile-events=default,query-keys`
+        all options: none, all, default, generic-activity, query-provider, query-cache-hit
+                     query-blocked, incr-cache-load, incr-result-hashing, query-keys, function-args, args, llvm, artifact-sizes"),
+    share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "make the current crate share its generic instantiations"),
+    shell_argfiles: bool = (false, parse_bool, [UNTRACKED],
+        "allow argument files to be specified with POSIX \"shell-style\" argument quoting"),
+    simulate_remapped_rust_src_base: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "simulate the effect of remap-debuginfo = true at bootstrapping by remapping path \
+        to rust's source base directory. only meant for testing purposes"),
+    small_data_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
+        "Set the threshold for objects to be stored in a \"small data\" section"),
+    span_debug: bool = (false, parse_bool, [UNTRACKED],
+        "forward proc_macro::Span's `Debug` impl to `Span`"),
+    /// o/w tests have closure@path
+    span_free_formats: bool = (false, parse_bool, [UNTRACKED],
+        "exclude spans when debug-printing compiler state (default: no)"),
+    split_dwarf_inlining: bool = (false, parse_bool, [TRACKED],
+        "provide minimal debug info in the object/executable to facilitate online \
+         symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF"),
+    split_dwarf_kind: SplitDwarfKind = (SplitDwarfKind::Split, parse_split_dwarf_kind, [TRACKED],
+        "split dwarf variant (only if -Csplit-debuginfo is enabled and on relevant platform)
+        (default: `split`)
+
+        `split`: sections which do not require relocation are written into a DWARF object (`.dwo`)
+                 file which is ignored by the linker
+        `single`: sections which do not require relocation are written into object file but ignored
+                  by the linker"),
+    split_dwarf_out_dir : Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "location for writing split DWARF objects (`.dwo`) if enabled"),
+    split_lto_unit: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable LTO unit splitting (default: no)"),
+    src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
+        "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")]
+    stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED],
+        "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"),
+    staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED],
+        "allow staticlibs to have rust dylib dependencies"),
+    staticlib_prefer_dynamic: bool = (false, parse_bool, [TRACKED],
+        "prefer dynamic linking to static linking for staticlibs (default: no)"),
+    strict_init_checks: bool = (false, parse_bool, [TRACKED],
+        "control if mem::uninitialized and mem::zeroed panic on more UB"),
+    #[rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field")]
+    teach: bool = (false, parse_bool, [TRACKED],
+        "show extended diagnostic help (default: no)"),
+    temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],
+        "the directory the intermediate files are written to"),
+    terminal_urls: TerminalUrl = (TerminalUrl::No, parse_terminal_url, [UNTRACKED],
+        "use the OSC 8 hyperlink terminal specification to print hyperlinks in the compiler output"),
+    #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")]
+    thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "enable ThinLTO when possible"),
+    /// We default to 1 here since we want to behave like
+    /// a sequential compiler for now. This'll likely be adjusted
+    /// in the future. Note that -Zthreads=0 is the way to get
+    /// the num_cpus behavior.
+    #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")]
+    threads: usize = (1, parse_threads, [UNTRACKED],
+        "use a thread pool with N threads"),
+    time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
+        "measure time of each LLVM pass (default: no)"),
+    time_passes: bool = (false, parse_bool, [UNTRACKED],
+        "measure time of each rustc pass (default: no)"),
+    time_passes_format: TimePassesFormat = (TimePassesFormat::Text, parse_time_passes_format, [UNTRACKED],
+        "the format to use for -Z time-passes (`text` (default) or `json`)"),
+    tiny_const_eval_limit: bool = (false, parse_bool, [TRACKED],
+        "sets a tiny, non-configurable limit for const eval; useful for compiler tests"),
+    #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")]
+    tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED],
+        "choose the TLS model to use (`rustc --print tls-models` for details)"),
+    trace_macros: bool = (false, parse_bool, [UNTRACKED],
+        "for every macro invocation, print its name and arguments (default: no)"),
+    track_diagnostics: bool = (false, parse_bool, [UNTRACKED],
+        "tracks where in rustc a diagnostic was emitted"),
+    translate_remapped_path_to_local_path: bool = (true, parse_bool, [TRACKED],
+        "translate remapped paths into local paths when possible (default: yes)"),
+    trap_unreachable: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "generate trap instructions for unreachable intrinsics (default: use target setting, usually yes)"),
+    treat_err_as_bug: Option<NonZero<usize>> = (None, parse_treat_err_as_bug, [TRACKED],
+        "treat the `val`th error that occurs as bug (default if not specified: 0 - don't treat errors as bugs. \
+        default if specified without a value: 1 - treat the first error as bug)"),
+    trim_diagnostic_paths: bool = (true, parse_bool, [UNTRACKED],
+        "in diagnostics, use heuristics to shorten paths referring to items"),
+    tune_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
+        "select processor to schedule for (`rustc --print target-cpus` for details)"),
+    #[rustc_lint_opt_deny_field_access("use `TyCtxt::use_typing_mode_borrowck` instead of this field")]
+    typing_mode_borrowck: bool = (false, parse_bool, [TRACKED],
+        "enable `TypingMode::Borrowck`, changing the way opaque types are handled during MIR borrowck"),
+    #[rustc_lint_opt_deny_field_access("use `Session::ub_checks` instead of this field")]
+    ub_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "emit runtime checks for Undefined Behavior (default: -Cdebug-assertions)"),
+    ui_testing: bool = (false, parse_bool, [UNTRACKED],
+        "emit compiler diagnostics in a form suitable for UI testing (default: no)"),
+    uninit_const_chunk_threshold: usize = (16, parse_number, [TRACKED],
+        "allow generating const initializers with mixed init/uninit chunks, \
+        and set the maximum number of chunks for which this is allowed (default: 16)"),
+    unleash_the_miri_inside_of_you: bool = (false, parse_bool, [TRACKED],
+        "take the brakes off const evaluation. NOTE: this is unsound (default: no)"),
+    unpretty: Option<String> = (None, parse_unpretty, [UNTRACKED],
+        "present the input source, unstable (and less-pretty) variants;
+        `normal`, `identified`,
+        `expanded`, `expanded,identified`,
+        `expanded,hygiene` (with internal representations),
+        `ast-tree` (raw AST before expansion),
+        `ast-tree,expanded` (raw AST after expansion),
+        `hir` (the HIR), `hir,identified`,
+        `hir,typed` (HIR with types for each node),
+        `hir-tree` (dump the raw HIR),
+        `thir-tree`, `thir-flat`,
+        `mir` (the MIR), or `mir-cfg` (graphviz formatted MIR)"),
+    unsound_mir_opts: bool = (false, parse_bool, [TRACKED],
+        "enable unsound and buggy MIR optimizations (default: no)"),
+    /// This name is kind of confusing: Most unstable options enable something themselves, while
+    /// this just allows "normal" options to be feature-gated.
+    ///
+    /// The main check for `-Zunstable-options` takes place separately from the
+    /// usual parsing of `-Z` options (see [`crate::config::nightly_options`]),
+    /// so this boolean value is mostly used for enabling unstable _values_ of
+    /// stable options. That separate check doesn't handle boolean values, so
+    /// to avoid an inconsistent state we also forbid them here.
+    #[rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field")]
+    unstable_options: bool = (false, parse_no_value, [UNTRACKED],
+        "adds unstable command line options to rustc interface (default: no)"),
+    use_ctors_section: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "use legacy .ctors section for initializers rather than .init_array"),
+    use_sync_unwind: Option<bool> = (None, parse_opt_bool, [TRACKED],
+        "Generate sync unwind tables instead of async unwind tables (default: no)"),
+    validate_mir: bool = (false, parse_bool, [UNTRACKED],
+        "validate MIR after each transformation"),
+    verbose_asm: bool = (false, parse_bool, [TRACKED],
+        "add descriptive comments from LLVM to the assembly (may change behavior) (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::verbose_internals` instead of this field")]
+    verbose_internals: bool = (false, parse_bool, [TRACKED_NO_CRATE_HASH],
+        "in general, enable more debug printouts (default: no)"),
+    #[rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field")]
+    verify_llvm_ir: bool = (false, parse_bool, [TRACKED],
+        "verify LLVM IR (default: no)"),
+    virtual_function_elimination: bool = (false, parse_bool, [TRACKED],
+        "enables dead virtual function elimination optimization. \
+        Requires `-Clto[=[fat,yes]]`"),
+    wasi_exec_model: Option<WasiExecModel> = (None, parse_wasi_exec_model, [TRACKED],
+        "whether to build a wasi command or reactor"),
+    // This option only still exists to provide a more gradual transition path for people who need
+    // the spec-complaint C ABI to be used.
+    // FIXME remove this after a couple releases
+    wasm_c_abi: () = ((), parse_wasm_c_abi, [TRACKED],
+        "use spec-compliant C ABI for `wasm32-unknown-unknown` (deprecated, always enabled)"),
+    write_long_types_to_disk: bool = (true, parse_bool, [UNTRACKED],
+        "whether long type names should be written to files instead of being printed in errors"),
+    // tidy-alphabetical-end
+
+    // If you add a new option, please update:
+    // - compiler/rustc_interface/src/tests.rs
+    // - src/doc/unstable-book/src/compiler-flags
+}
diff --git a/compiler/rustc_session/src/options/unstable.rs b/compiler/rustc_session/src/options/unstable.rs
deleted file mode 100644
index dc00bd8a223a..000000000000
--- a/compiler/rustc_session/src/options/unstable.rs
+++ /dev/null
@@ -1,585 +0,0 @@
-options! {
-    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
-
-    // If you add a new option, please update:
-    // - compiler/rustc_interface/src/tests.rs
-    // - src/doc/unstable-book/src/compiler-flags
-
-    // tidy-alphabetical-start
-    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
-        "only allow the listed language features to be enabled in code (comma separated)"),
-    always_encode_mir: bool = (false, parse_bool, [TRACKED],
-        "encode MIR of all functions into the crate metadata (default: no)"),
-    annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED],
-        "emit debug info for compiler-generated move and copy operations \
-        to make them visible in profilers. Can be a boolean or a size limit in bytes (default: disabled)"),
-    assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "assert that the incremental cache is in given state: \
-         either `loaded` or `not-loaded`."),
-    assume_incomplete_release: bool = (false, parse_bool, [TRACKED],
-        "make cfg(version) treat the current version as incomplete (default: no)"),
-    autodiff: Vec<crate::config::AutoDiff> = (Vec::new(), parse_autodiff, [TRACKED],
-        "a list of autodiff flags to enable
-        Mandatory setting:
-        `=Enable`
-        Optional extra settings:
-        `=PrintTA`
-        `=PrintAA`
-        `=PrintPerf`
-        `=PrintSteps`
-        `=PrintModBefore`
-        `=PrintModAfter`
-        `=PrintModFinal`
-        `=PrintPasses`,
-        `=NoPostopt`
-        `=LooseTypes`
-        `=Inline`
-        Multiple options can be combined with commas."),
-    #[rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field")]
-    binary_dep_depinfo: bool = (false, parse_bool, [TRACKED],
-        "include artifacts (sysroot, crate dependencies) used during compilation in dep-info \
-        (default: no)"),
-    box_noalias: bool = (true, parse_bool, [TRACKED],
-        "emit noalias metadata for box (default: yes)"),
-    branch_protection: Option<BranchProtection> = (None, parse_branch_protection, [TRACKED TARGET_MODIFIER],
-        "set options for branch target identification and pointer authentication on AArch64"),
-    build_sdylib_interface: bool = (false, parse_bool, [UNTRACKED],
-        "whether the stable interface is being built"),
-    cache_proc_macros: bool = (false, parse_bool, [TRACKED],
-        "cache the results of derive proc macro invocations (potentially unsound!) (default: no"),
-    cf_protection: CFProtection = (CFProtection::None, parse_cfprotection, [TRACKED],
-        "instrument control-flow architecture protection"),
-    check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],
-        "show all expected values in check-cfg diagnostics (default: no)"),
-    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_cargo_src_file_hash, [TRACKED],
-        "hash algorithm of source files used to check freshness in cargo (`blake3` or `sha256`)"),
-    codegen_backend: Option<String> = (None, parse_opt_string, [TRACKED],
-        "the backend to use"),
-    codegen_source_order: bool = (false, parse_bool, [UNTRACKED],
-        "emit mono items in the order of spans in source files (default: no)"),
-    contract_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "emit runtime checks for contract pre- and post-conditions (default: no)"),
-    coverage_options: CoverageOptions = (CoverageOptions::default(), parse_coverage_options, [TRACKED],
-        "control details of coverage instrumentation"),
-    crate_attr: Vec<String> = (Vec::new(), parse_string_push, [TRACKED],
-        "inject the given attribute in the crate"),
-    cross_crate_inline_threshold: InliningThreshold = (InliningThreshold::Sometimes(100), parse_inlining_threshold, [TRACKED],
-        "threshold to allow cross crate inlining of functions"),
-    debug_info_for_profiling: bool = (false, parse_bool, [TRACKED],
-        "emit discriminators and other data necessary for AutoFDO"),
-    debug_info_type_line_numbers: bool = (false, parse_bool, [TRACKED],
-        "emit type and line information for additional data types (default: no)"),
-    debuginfo_compression: DebugInfoCompression = (DebugInfoCompression::None, parse_debuginfo_compression, [TRACKED],
-        "compress debug info sections (none, zlib, zstd, default: none)"),
-    deduplicate_diagnostics: bool = (true, parse_bool, [UNTRACKED],
-        "deduplicate identical diagnostics (default: yes)"),
-    default_visibility: Option<SymbolVisibility> = (None, parse_opt_symbol_visibility, [TRACKED],
-        "overrides the `default_visibility` setting of the target"),
-    dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
-        "in dep-info output, omit targets for tracking dependencies of the dep-info files \
-        themselves (default: no)"),
-    direct_access_external_data: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "Direct or use GOT indirect to reference external data symbols"),
-    dual_proc_macros: bool = (false, parse_bool, [TRACKED],
-        "load proc macros for both target and host, but only link to the target (default: no)"),
-    dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
-        "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv) \
-        (default: no)"),
-    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "dump MIR state to file.
-        `val` is used to select which passes and functions to dump. For example:
-        `all` matches all passes and functions,
-        `foo` matches all passes for functions whose name contains 'foo',
-        `foo & ConstProp` only the 'ConstProp' pass for function names containing 'foo',
-        `foo | bar` all passes for function names containing 'foo' or 'bar'."),
-    dump_mir_dataflow: bool = (false, parse_bool, [UNTRACKED],
-        "in addition to `.mir` files, create graphviz `.dot` files with dataflow results \
-        (default: no)"),
-    dump_mir_dir: String = ("mir_dump".to_string(), parse_string, [UNTRACKED],
-        "the directory the MIR is dumped into (default: `mir_dump`)"),
-    dump_mir_exclude_alloc_bytes: bool = (false, parse_bool, [UNTRACKED],
-        "exclude the raw bytes of allocations when dumping MIR (used in tests) (default: no)"),
-    dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
-        "exclude the pass number when dumping MIR (used in tests) (default: no)"),
-    dump_mir_graphviz: bool = (false, parse_bool, [UNTRACKED],
-        "in addition to `.mir` files, create graphviz `.dot` files (default: no)"),
-    dump_mono_stats: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
-        parse_switch_with_opt_path, [UNTRACKED],
-        "output statistics about monomorphization collection"),
-    dump_mono_stats_format: DumpMonoStatsFormat = (DumpMonoStatsFormat::Markdown, parse_dump_mono_stats, [UNTRACKED],
-        "the format to use for -Z dump-mono-stats (`markdown` (default) or `json`)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
-    dwarf_version: Option<u32> = (None, parse_opt_number, [TRACKED],
-        "version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),
-    dylib_lto: bool = (false, parse_bool, [UNTRACKED],
-        "enables LTO for dylib crate type"),
-    eagerly_emit_delayed_bugs: bool = (false, parse_bool, [UNTRACKED],
-        "emit delayed bugs eagerly as errors instead of stashing them and emitting \
-        them only if an error has not been emitted"),
-    ehcont_guard: bool = (false, parse_bool, [TRACKED],
-        "generate Windows EHCont Guard tables"),
-    embed_metadata: bool = (true, parse_bool, [TRACKED],
-        "embed metadata in rlibs and dylibs (default: yes)"),
-    embed_source: bool = (false, parse_bool, [TRACKED],
-        "embed source text in DWARF debug sections (default: no)"),
-    emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
-        "emit a section containing stack size metadata (default: no)"),
-    emscripten_wasm_eh: bool = (true, parse_bool, [TRACKED],
-        "Use WebAssembly error handling for wasm32-unknown-emscripten"),
-    enforce_type_length_limit: bool = (false, parse_bool, [TRACKED],
-        "enforce the type length limit when monomorphizing instances in codegen"),
-    experimental_default_bounds: bool = (false, parse_bool, [TRACKED],
-        "enable default bounds for experimental group of auto traits"),
-    export_executable_symbols: bool = (false, parse_bool, [TRACKED],
-        "export symbols from executables, as if they were dynamic libraries"),
-    external_clangrt: bool = (false, parse_bool, [UNTRACKED],
-        "rely on user specified linker commands to find clangrt"),
-    extra_const_ub_checks: bool = (false, parse_bool, [TRACKED],
-        "turns on more checks to detect const UB, which can be slow (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field")]
-    fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
-        (default: no)"),
-    fixed_x18: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "make the x18 register reserved on AArch64 (default: no)"),
-    flatten_format_args: bool = (true, parse_bool, [TRACKED],
-        "flatten nested format_args!() and literals into a simplified format_args!() call \
-        (default: yes)"),
-    fmt_debug: FmtDebug = (FmtDebug::Full, parse_fmt_debug, [TRACKED],
-        "how detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
-        `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
-    force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
-        "force all crates to be `rustc_private` unstable (default: no)"),
-    function_return: FunctionReturn = (FunctionReturn::default(), parse_function_return, [TRACKED],
-        "replace returns with jumps to `__x86_return_thunk` (default: `keep`)"),
-    function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether each function should go in its own section"),
-    future_incompat_test: bool = (false, parse_bool, [UNTRACKED],
-        "forces all lints to be future incompatible, used for internal testing (default: no)"),
-    graphviz_dark_mode: bool = (false, parse_bool, [UNTRACKED],
-        "use dark-themed colors in graphviz output (default: no)"),
-    graphviz_font: String = ("Courier, monospace".to_string(), parse_string, [UNTRACKED],
-        "use the given `fontname` in graphviz output; can be overridden by setting \
-        environment variable `RUSTC_GRAPHVIZ_FONT` (default: `Courier, monospace`)"),
-    has_thread_local: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "explicitly enable the `cfg(target_thread_local)` directive"),
-    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
-    higher_ranked_assumptions: bool = (false, parse_bool, [TRACKED],
-        "allow deducing higher-ranked outlives assumptions from coroutines when proving auto traits"),
-    hint_mostly_unused: bool = (false, parse_bool, [TRACKED],
-        "hint that most of this crate will go unused, to minimize work for uncalled functions"),
-    human_readable_cgu_names: bool = (false, parse_bool, [TRACKED],
-        "generate human-readable, predictable names for codegen units (default: no)"),
-    identify_regions: bool = (false, parse_bool, [UNTRACKED],
-        "display unnamed regions as `'<id>`, using a non-ident unique id (default: no)"),
-    ignore_directory_in_diagnostics_source_blocks: Vec<String> = (Vec::new(), parse_string_push, [UNTRACKED],
-        "do not display the source code block in diagnostics for files in the directory"),
-    incremental_ignore_spans: bool = (false, parse_bool, [TRACKED],
-        "ignore spans during ICH computation -- used for testing (default: no)"),
-    incremental_info: bool = (false, parse_bool, [UNTRACKED],
-        "print high-level information about incremental reuse (or the lack thereof) \
-        (default: no)"),
-    incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
-        "verify extended properties for incr. comp. (default: no):
-        - hashes of green query instances
-        - hash collisions of query keys
-        - hash collisions when creating dep-nodes"),
-    indirect_branch_cs_prefix: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "add `cs` prefix to `call` and `jmp` to indirect thunks (default: no)"),
-    inline_llvm: bool = (true, parse_bool, [TRACKED],
-        "enable LLVM inlining (default: yes)"),
-    inline_mir: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable MIR inlining (default: no)"),
-    inline_mir_forwarder_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "inlining threshold when the caller is a simple forwarding function (default: 30)"),
-    inline_mir_hint_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "inlining threshold for functions with inline hint (default: 100)"),
-    inline_mir_preserve_debug: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "when MIR inlining, whether to preserve debug info for callee variables \
-        (default: preserve for debuginfo != None, otherwise remove)"),
-    inline_mir_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "a default MIR inlining threshold (default: 50)"),
-    input_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print some statistics about AST and HIR (default: no)"),
-    instrument_mcount: bool = (false, parse_bool, [TRACKED],
-        "insert function instrument code for mcount-based tracing (default: no)"),
-    instrument_xray: Option<InstrumentXRay> = (None, parse_instrument_xray, [TRACKED],
-        "insert function instrument code for XRay-based tracing (default: no)
-         Optional extra settings:
-         `=always`
-         `=never`
-         `=ignore-loops`
-         `=instruction-threshold=N`
-         `=skip-entry`
-         `=skip-exit`
-         Multiple options can be combined with commas."),
-    large_data_threshold: Option<u64> = (None, parse_opt_number, [TRACKED],
-        "set the threshold for objects to be stored in a \"large data\" section \
-         (only effective with -Ccode-model=medium, default: 65536)"),
-    layout_seed: Option<u64> = (None, parse_opt_number, [TRACKED],
-        "seed layout randomization"),
-    link_directives: bool = (true, parse_bool, [TRACKED],
-        "honor #[link] directives in the compiled crate (default: yes)"),
-    link_native_libraries: bool = (true, parse_bool, [UNTRACKED],
-        "link native libraries in the linker invocation (default: yes)"),
-    link_only: bool = (false, parse_bool, [TRACKED],
-        "link the `.rlink` file generated by `-Z no-link` (default: no)"),
-    lint_llvm_ir: bool = (false, parse_bool, [TRACKED],
-        "lint LLVM IR (default: no)"),
-    lint_mir: bool = (false, parse_bool, [UNTRACKED],
-        "lint MIR before and after each transformation"),
-    llvm_module_flag: Vec<(String, u32, String)> = (Vec::new(), parse_llvm_module_flag, [TRACKED],
-        "a list of module flags to pass to LLVM (space separated)"),
-    llvm_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
-        "a list LLVM plugins to enable (space separated)"),
-    llvm_time_trace: bool = (false, parse_bool, [UNTRACKED],
-        "generate JSON tracing data file from LLVM data (default: no)"),
-    location_detail: LocationDetail = (LocationDetail::all(), parse_location_detail, [TRACKED],
-        "what location details should be tracked when using caller_location, either \
-        `none`, or a comma separated list of location details, for which \
-        valid options are `file`, `line`, and `column` (default: `file,line,column`)"),
-    ls: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
-        "decode and print various parts of the crate metadata for a library crate \
-        (space separated)"),
-    macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
-        "show macro backtraces (default: no)"),
-    macro_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print some statistics about macro expansions (default: no)"),
-    maximal_hir_to_mir_coverage: bool = (false, parse_bool, [TRACKED],
-        "save as much information as possible about the correspondence between MIR and HIR \
-        as source scopes (default: no)"),
-    merge_functions: Option<MergeFunctions> = (None, parse_merge_functions, [TRACKED],
-        "control the operation of the MergeFunctions LLVM pass, taking \
-        the same values as the target option of the same name"),
-    meta_stats: bool = (false, parse_bool, [UNTRACKED],
-        "gather metadata statistics (default: no)"),
-    metrics_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
-        "the directory metrics emitted by rustc are dumped into (implicitly enables default set of metrics)"),
-    min_function_alignment: Option<Align> = (None, parse_align, [TRACKED],
-        "align all functions to at least this many bytes. Must be a power of 2"),
-    min_recursion_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "set a minimum recursion limit (final limit = max(this, recursion_limit_from_crate))"),
-    mir_emit_retag: bool = (false, parse_bool, [TRACKED],
-        "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
-        (default: no)"),
-    mir_enable_passes: Vec<(String, bool)> = (Vec::new(), parse_list_with_polarity, [TRACKED],
-        "use like `-Zmir-enable-passes=+DestinationPropagation,-InstSimplify`. Forces the \
-        specified passes to be enabled, overriding all other checks. In particular, this will \
-        enable unsound (known-buggy and hence usually disabled) passes without further warning! \
-        Passes that are not specified are enabled or disabled by other flags as usual."),
-    mir_include_spans: MirIncludeSpans = (MirIncludeSpans::default(), parse_mir_include_spans, [UNTRACKED],
-        "include extra comments in mir pretty printing, like line numbers and statement indices, \
-         details about types, etc. (boolean for all passes, 'nll' to enable in NLL MIR only, default: 'nll')"),
-    mir_opt_bisect_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "limit the number of MIR optimization pass executions (global across all bodies). \
-        Pass executions after this limit are skipped and reported. (default: no limit)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field")]
-    mir_opt_level: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "MIR optimization level (0-4; default: 1 in non optimized builds and 2 in optimized builds)"),
-    mir_preserve_ub: bool = (false, parse_bool, [TRACKED],
-        "keep place mention statements and reads in trivial SwitchInt terminators, which are interpreted \
-        e.g., by miri; implies -Zmir-opt-level=0 (default: no)"),
-    mir_strip_debuginfo: MirStripDebugInfo = (MirStripDebugInfo::None, parse_mir_strip_debuginfo, [TRACKED],
-        "Whether to remove some of the MIR debug info from methods.  Default: None"),
-    move_size_limit: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "the size at which the `large_assignments` lint starts to be emitted"),
-    mutable_noalias: bool = (true, parse_bool, [TRACKED],
-        "emit noalias metadata for mutable references (default: yes)"),
-    namespaced_crates: bool = (false, parse_bool, [TRACKED],
-        "allow crates to be namespaced by other crates (default: no)"),
-    next_solver: NextSolverConfig = (NextSolverConfig::default(), parse_next_solver_config, [TRACKED],
-        "enable and configure the next generation trait solver used by rustc"),
-    nll_facts: bool = (false, parse_bool, [UNTRACKED],
-        "dump facts from NLL analysis into side files (default: no)"),
-    nll_facts_dir: String = ("nll-facts".to_string(), parse_string, [UNTRACKED],
-        "the directory the NLL facts are dumped into (default: `nll-facts`)"),
-    no_analysis: bool = (false, parse_no_value, [UNTRACKED],
-        "parse and expand the source, but run no analysis"),
-    no_codegen: bool = (false, parse_no_value, [TRACKED_NO_CRATE_HASH],
-        "run all passes except codegen; no output"),
-    no_generate_arange_section: bool = (false, parse_no_value, [TRACKED],
-        "omit DWARF address ranges that give faster lookups"),
-    no_implied_bounds_compat: bool = (false, parse_bool, [TRACKED],
-        "disable the compatibility version of the `implied_bounds_ty` query"),
-    no_leak_check: bool = (false, parse_no_value, [UNTRACKED],
-        "disable the 'leak check' for subtyping; unsound, but useful for tests"),
-    no_link: bool = (false, parse_no_value, [TRACKED],
-        "compile without linking"),
-    no_parallel_backend: bool = (false, parse_no_value, [UNTRACKED],
-        "run LLVM in non-parallel mode (while keeping codegen-units and ThinLTO)"),
-    no_profiler_runtime: bool = (false, parse_no_value, [TRACKED],
-        "prevent automatic injection of the profiler_builtins crate"),
-    no_steal_thir: bool = (false, parse_bool, [UNTRACKED],
-        "don't steal the THIR when we're done with it; useful for rustc drivers (default: no)"),
-    no_trait_vptr: bool = (false, parse_no_value, [TRACKED],
-        "disable generation of trait vptr in vtable for upcasting"),
-    no_unique_section_names: bool = (false, parse_bool, [TRACKED],
-        "do not use unique names for text and data sections when -Z function-sections is used"),
-    normalize_docs: bool = (false, parse_bool, [TRACKED],
-        "normalize associated items in rustdoc when generating documentation"),
-    offload: Vec<crate::config::Offload> = (Vec::new(), parse_offload, [TRACKED],
-        "a list of offload flags to enable
-        Mandatory setting:
-        `=Enable`
-        Currently the only option available"),
-    on_broken_pipe: OnBrokenPipe = (OnBrokenPipe::Default, parse_on_broken_pipe, [TRACKED],
-        "behavior of std::io::ErrorKind::BrokenPipe (SIGPIPE)"),
-    osx_rpath_install_name: bool = (false, parse_bool, [TRACKED],
-        "pass `-install_name @rpath/...` to the macOS linker (default: no)"),
-    packed_bundled_libs: bool = (false, parse_bool, [TRACKED],
-        "change rlib format to store native libraries as archives"),
-    panic_abort_tests: bool = (false, parse_bool, [TRACKED],
-        "support compiling tests with panic=abort (default: no)"),
-    panic_in_drop: PanicStrategy = (PanicStrategy::Unwind, parse_panic_strategy, [TRACKED],
-        "panic strategy for panics in drops"),
-    parse_crate_root_only: bool = (false, parse_bool, [UNTRACKED],
-        "parse the crate root file only; do not parse other files, compile, assemble, or link \
-        (default: no)"),
-    patchable_function_entry: PatchableFunctionEntry = (PatchableFunctionEntry::default(), parse_patchable_function_entry, [TRACKED],
-        "nop padding at function entry"),
-    plt: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether to use the PLT when calling into shared libraries;
-        only has effect for PIC code on systems with ELF binaries
-        (default: PLT is disabled if full relro is enabled on x86_64)"),
-    polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
-        "enable polonius-based borrow-checker (default: no)"),
-    pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
-        "a single extra argument to prepend the linker invocation (can be used several times)"),
-    pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
-        "extra arguments to prepend to the linker invocation (space separated)"),
-    precise_enum_drop_elaboration: bool = (true, parse_bool, [TRACKED],
-        "use a more precise version of drop elaboration for matches on enums (default: yes). \
-        This results in better codegen, but has caused miscompilations on some tier 2 platforms. \
-        See #77382 and #74551."),
-    #[rustc_lint_opt_deny_field_access("use `Session::print_codegen_stats` instead of this field")]
-    print_codegen_stats: bool = (false, parse_bool, [UNTRACKED],
-        "print codegen statistics (default: no)"),
-    print_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
-        "print the LLVM optimization passes being run (default: no)"),
-    print_mono_items: bool = (false, parse_bool, [UNTRACKED],
-        "print the result of the monomorphization collection pass (default: no)"),
-    print_type_sizes: bool = (false, parse_bool, [UNTRACKED],
-        "print layout information for each type encountered (default: no)"),
-    proc_macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
-         "show backtraces for panics during proc-macro execution (default: no)"),
-    proc_macro_execution_strategy: ProcMacroExecutionStrategy = (ProcMacroExecutionStrategy::SameThread,
-        parse_proc_macro_execution_strategy, [UNTRACKED],
-        "how to run proc-macro code (default: same-thread)"),
-    profile_closures: bool = (false, parse_no_value, [UNTRACKED],
-        "profile size of closures"),
-    profile_sample_use: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "use the given `.prof` file for sampled profile-guided optimization (also known as AutoFDO)"),
-    profiler_runtime: String = (String::from("profiler_builtins"), parse_string, [TRACKED],
-        "name of the profiler runtime crate to automatically inject (default: `profiler_builtins`)"),
-    query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
-        "enable queries of the dependency graph for regression testing (default: no)"),
-    randomize_layout: bool = (false, parse_bool, [TRACKED],
-        "randomize the layout of types (default: no)"),
-    reg_struct_return: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "On x86-32 targets, it overrides the default ABI to return small structs in registers.
-        It is UNSOUND to link together crates that use different values for this flag!"),
-    regparm: Option<u32> = (None, parse_opt_number, [TRACKED TARGET_MODIFIER],
-        "On x86-32 targets, setting this to N causes the compiler to pass N arguments \
-        in registers EAX, EDX, and ECX instead of on the stack for\
-        \"C\", \"cdecl\", and \"stdcall\" fn.\
-        It is UNSOUND to link together crates that use different values for this flag!"),
-    relax_elf_relocations: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "whether ELF relocations can be relaxed"),
-    remap_cwd_prefix: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "remap paths under the current working directory to this path prefix"),
-    remark_dir: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
-        "directory into which to write optimization remarks (if not specified, they will be \
-written to standard error output)"),
-    retpoline: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "enables retpoline-indirect-branches and retpoline-indirect-calls target features (default: no)"),
-    retpoline_external_thunk: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
-        "enables retpoline-external-thunk, retpoline-indirect-branches and retpoline-indirect-calls \
-        target features (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::sanitizers()` instead of this field")]
-    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED TARGET_MODIFIER],
-        "use a sanitizer"),
-    sanitizer_cfi_canonical_jump_tables: Option<bool> = (Some(true), parse_opt_bool, [TRACKED],
-        "enable canonical jump tables (default: yes)"),
-    sanitizer_cfi_generalize_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable generalizing pointer types (default: no)"),
-    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED TARGET_MODIFIER],
-        "enable normalizing integer types (default: no)"),
-    sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
-        "additional ABI list files that control how shadow parameters are passed (comma separated)"),
-    sanitizer_kcfi_arity: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable KCFI arity indicator (default: no)"),
-    sanitizer_memory_track_origins: usize = (0, parse_sanitizer_memory_track_origins, [TRACKED],
-        "enable origins tracking in MemorySanitizer"),
-    sanitizer_recover: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED],
-        "enable recovery for selected sanitizers"),
-    saturating_float_casts: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "make float->int casts UB-free: numbers outside the integer type's range are clipped to \
-        the max/min integer respectively, and NaN is mapped to 0 (default: yes)"),
-    self_profile: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
-        parse_switch_with_opt_path, [UNTRACKED],
-        "run the self profiler and output the raw event data"),
-    self_profile_counter: String = ("wall-time".to_string(), parse_string, [UNTRACKED],
-        "counter used by the self profiler (default: `wall-time`), one of:
-        `wall-time` (monotonic clock, i.e. `std::time::Instant`)
-        `instructions:u` (retired instructions, userspace-only)
-        `instructions-minus-irqs:u` (subtracting hardware interrupt counts for extra accuracy)"
-    ),
-    /// keep this in sync with the event filter names in librustc_data_structures/profiling.rs
-    self_profile_events: Option<Vec<String>> = (None, parse_opt_comma_list, [UNTRACKED],
-        "specify the events recorded by the self profiler;
-        for example: `-Z self-profile-events=default,query-keys`
-        all options: none, all, default, generic-activity, query-provider, query-cache-hit
-                     query-blocked, incr-cache-load, incr-result-hashing, query-keys, function-args, args, llvm, artifact-sizes"),
-    share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "make the current crate share its generic instantiations"),
-    shell_argfiles: bool = (false, parse_bool, [UNTRACKED],
-        "allow argument files to be specified with POSIX \"shell-style\" argument quoting"),
-    simulate_remapped_rust_src_base: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "simulate the effect of remap-debuginfo = true at bootstrapping by remapping path \
-        to rust's source base directory. only meant for testing purposes"),
-    small_data_threshold: Option<usize> = (None, parse_opt_number, [TRACKED],
-        "Set the threshold for objects to be stored in a \"small data\" section"),
-    span_debug: bool = (false, parse_bool, [UNTRACKED],
-        "forward proc_macro::Span's `Debug` impl to `Span`"),
-    /// o/w tests have closure@path
-    span_free_formats: bool = (false, parse_bool, [UNTRACKED],
-        "exclude spans when debug-printing compiler state (default: no)"),
-    split_dwarf_inlining: bool = (false, parse_bool, [TRACKED],
-        "provide minimal debug info in the object/executable to facilitate online \
-         symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF"),
-    split_dwarf_kind: SplitDwarfKind = (SplitDwarfKind::Split, parse_split_dwarf_kind, [TRACKED],
-        "split dwarf variant (only if -Csplit-debuginfo is enabled and on relevant platform)
-        (default: `split`)
-
-        `split`: sections which do not require relocation are written into a DWARF object (`.dwo`)
-                 file which is ignored by the linker
-        `single`: sections which do not require relocation are written into object file but ignored
-                  by the linker"),
-    split_dwarf_out_dir : Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
-        "location for writing split DWARF objects (`.dwo`) if enabled"),
-    split_lto_unit: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable LTO unit splitting (default: no)"),
-    src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
-        "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")]
-    stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED],
-        "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"),
-    staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED],
-        "allow staticlibs to have rust dylib dependencies"),
-    staticlib_prefer_dynamic: bool = (false, parse_bool, [TRACKED],
-        "prefer dynamic linking to static linking for staticlibs (default: no)"),
-    strict_init_checks: bool = (false, parse_bool, [TRACKED],
-        "control if mem::uninitialized and mem::zeroed panic on more UB"),
-    #[rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field")]
-    teach: bool = (false, parse_bool, [TRACKED],
-        "show extended diagnostic help (default: no)"),
-    temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "the directory the intermediate files are written to"),
-    terminal_urls: TerminalUrl = (TerminalUrl::No, parse_terminal_url, [UNTRACKED],
-        "use the OSC 8 hyperlink terminal specification to print hyperlinks in the compiler output"),
-    #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")]
-    thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "enable ThinLTO when possible"),
-    /// We default to 1 here since we want to behave like
-    /// a sequential compiler for now. This'll likely be adjusted
-    /// in the future. Note that -Zthreads=0 is the way to get
-    /// the num_cpus behavior.
-    #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")]
-    threads: usize = (1, parse_threads, [UNTRACKED],
-        "use a thread pool with N threads"),
-    time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
-        "measure time of each LLVM pass (default: no)"),
-    time_passes: bool = (false, parse_bool, [UNTRACKED],
-        "measure time of each rustc pass (default: no)"),
-    time_passes_format: TimePassesFormat = (TimePassesFormat::Text, parse_time_passes_format, [UNTRACKED],
-        "the format to use for -Z time-passes (`text` (default) or `json`)"),
-    tiny_const_eval_limit: bool = (false, parse_bool, [TRACKED],
-        "sets a tiny, non-configurable limit for const eval; useful for compiler tests"),
-    #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")]
-    tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED],
-        "choose the TLS model to use (`rustc --print tls-models` for details)"),
-    trace_macros: bool = (false, parse_bool, [UNTRACKED],
-        "for every macro invocation, print its name and arguments (default: no)"),
-    track_diagnostics: bool = (false, parse_bool, [UNTRACKED],
-        "tracks where in rustc a diagnostic was emitted"),
-    translate_remapped_path_to_local_path: bool = (true, parse_bool, [TRACKED],
-        "translate remapped paths into local paths when possible (default: yes)"),
-    trap_unreachable: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "generate trap instructions for unreachable intrinsics (default: use target setting, usually yes)"),
-    treat_err_as_bug: Option<NonZero<usize>> = (None, parse_treat_err_as_bug, [TRACKED],
-        "treat the `val`th error that occurs as bug (default if not specified: 0 - don't treat errors as bugs. \
-        default if specified without a value: 1 - treat the first error as bug)"),
-    trim_diagnostic_paths: bool = (true, parse_bool, [UNTRACKED],
-        "in diagnostics, use heuristics to shorten paths referring to items"),
-    tune_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
-        "select processor to schedule for (`rustc --print target-cpus` for details)"),
-    #[rustc_lint_opt_deny_field_access("use `TyCtxt::use_typing_mode_borrowck` instead of this field")]
-    typing_mode_borrowck: bool = (false, parse_bool, [TRACKED],
-        "enable `TypingMode::Borrowck`, changing the way opaque types are handled during MIR borrowck"),
-    #[rustc_lint_opt_deny_field_access("use `Session::ub_checks` instead of this field")]
-    ub_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "emit runtime checks for Undefined Behavior (default: -Cdebug-assertions)"),
-    ui_testing: bool = (false, parse_bool, [UNTRACKED],
-        "emit compiler diagnostics in a form suitable for UI testing (default: no)"),
-    uninit_const_chunk_threshold: usize = (16, parse_number, [TRACKED],
-        "allow generating const initializers with mixed init/uninit chunks, \
-        and set the maximum number of chunks for which this is allowed (default: 16)"),
-    unleash_the_miri_inside_of_you: bool = (false, parse_bool, [TRACKED],
-        "take the brakes off const evaluation. NOTE: this is unsound (default: no)"),
-    unpretty: Option<String> = (None, parse_unpretty, [UNTRACKED],
-        "present the input source, unstable (and less-pretty) variants;
-        `normal`, `identified`,
-        `expanded`, `expanded,identified`,
-        `expanded,hygiene` (with internal representations),
-        `ast-tree` (raw AST before expansion),
-        `ast-tree,expanded` (raw AST after expansion),
-        `hir` (the HIR), `hir,identified`,
-        `hir,typed` (HIR with types for each node),
-        `hir-tree` (dump the raw HIR),
-        `thir-tree`, `thir-flat`,
-        `mir` (the MIR), or `mir-cfg` (graphviz formatted MIR)"),
-    unsound_mir_opts: bool = (false, parse_bool, [TRACKED],
-        "enable unsound and buggy MIR optimizations (default: no)"),
-    /// This name is kind of confusing: Most unstable options enable something themselves, while
-    /// this just allows "normal" options to be feature-gated.
-    ///
-    /// The main check for `-Zunstable-options` takes place separately from the
-    /// usual parsing of `-Z` options (see [`crate::config::nightly_options`]),
-    /// so this boolean value is mostly used for enabling unstable _values_ of
-    /// stable options. That separate check doesn't handle boolean values, so
-    /// to avoid an inconsistent state we also forbid them here.
-    #[rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field")]
-    unstable_options: bool = (false, parse_no_value, [UNTRACKED],
-        "adds unstable command line options to rustc interface (default: no)"),
-    use_ctors_section: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "use legacy .ctors section for initializers rather than .init_array"),
-    use_sync_unwind: Option<bool> = (None, parse_opt_bool, [TRACKED],
-        "Generate sync unwind tables instead of async unwind tables (default: no)"),
-    validate_mir: bool = (false, parse_bool, [UNTRACKED],
-        "validate MIR after each transformation"),
-    verbose_asm: bool = (false, parse_bool, [TRACKED],
-        "add descriptive comments from LLVM to the assembly (may change behavior) (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::verbose_internals` instead of this field")]
-    verbose_internals: bool = (false, parse_bool, [TRACKED_NO_CRATE_HASH],
-        "in general, enable more debug printouts (default: no)"),
-    #[rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field")]
-    verify_llvm_ir: bool = (false, parse_bool, [TRACKED],
-        "verify LLVM IR (default: no)"),
-    virtual_function_elimination: bool = (false, parse_bool, [TRACKED],
-        "enables dead virtual function elimination optimization. \
-        Requires `-Clto[=[fat,yes]]`"),
-    wasi_exec_model: Option<WasiExecModel> = (None, parse_wasi_exec_model, [TRACKED],
-        "whether to build a wasi command or reactor"),
-    // This option only still exists to provide a more gradual transition path for people who need
-    // the spec-complaint C ABI to be used.
-    // FIXME remove this after a couple releases
-    wasm_c_abi: () = ((), parse_wasm_c_abi, [TRACKED],
-        "use spec-compliant C ABI for `wasm32-unknown-unknown` (deprecated, always enabled)"),
-    write_long_types_to_disk: bool = (true, parse_bool, [UNTRACKED],
-        "whether long type names should be written to files instead of being printed in errors"),
-    // tidy-alphabetical-end
-
-    // If you add a new option, please update:
-    // - compiler/rustc_interface/src/tests.rs
-    // - src/doc/unstable-book/src/compiler-flags
-}
diff --git a/src/tools/unstable-book-gen/Cargo.toml b/src/tools/unstable-book-gen/Cargo.toml
index 12dd2eda3d9e..73e5a91bec70 100644
--- a/src/tools/unstable-book-gen/Cargo.toml
+++ b/src/tools/unstable-book-gen/Cargo.toml
@@ -6,8 +6,6 @@ edition = "2021"
 
 [dependencies]
 tidy = { path = "../tidy" }
-proc-macro2 = { version = "1.0", features = ["span-locations"] }
-syn = { version = "2.0", features = ["full", "parsing"] }
 
 # not actually needed but required for now to unify the feature selection of
 # `num-traits` between this and `rustbook`
diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index 21d4da46bef5..16550f83003d 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -5,16 +5,11 @@
 use std::fs::{self, write};
 use std::path::Path;
 
-use proc_macro2::{Span, TokenStream, TokenTree};
-use syn::parse::{Parse, ParseStream};
-use syn::{Attribute, Ident, Item, LitStr, Token, parenthesized};
 use tidy::diagnostics::RunningCheck;
-use tidy::features::{
-    Feature, Features, Status, collect_env_vars, collect_lang_features, collect_lib_features,
-};
+use tidy::features::{Features, collect_env_vars, collect_lang_features, collect_lib_features};
 use tidy::t;
 use tidy::unstable_book::{
-    COMPILER_FLAGS_DIR, ENV_VARS_DIR, LANG_FEATURES_DIR, LIB_FEATURES_DIR, PATH_STR,
+    ENV_VARS_DIR, LANG_FEATURES_DIR, LIB_FEATURES_DIR, PATH_STR,
     collect_unstable_book_section_file_names, collect_unstable_feature_names,
 };
 
@@ -118,188 +113,6 @@ fn copy_recursive(from: &Path, to: &Path) {
     }
 }
 
-fn collect_compiler_flags(compiler_path: &Path) -> Features {
-    let options_path = compiler_path.join("rustc_session/src/options/unstable.rs");
-    let options_rs = t!(fs::read_to_string(&options_path), options_path);
-    parse_compiler_flags(&options_rs, &options_path)
-}
-
-const DESCRIPTION_FIELD: usize = 3;
-const REQUIRED_FIELDS: usize = 4;
-const OPTIONAL_FIELDS: usize = 5;
-
-struct ParsedOptionEntry {
-    name: String,
-    line: usize,
-    description: String,
-}
-
-struct UnstableOptionsInput {
-    struct_name: Ident,
-    entries: Vec<ParsedOptionEntry>,
-}
-
-impl Parse for ParsedOptionEntry {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let _attrs = input.call(Attribute::parse_outer)?;
-
-        let name: Ident = input.parse()?;
-        let line = name.span().start().line;
-        input.parse::<Token![:]>()?;
-        let _ty: syn::Type = input.parse()?;
-        input.parse::<Token![=]>()?;
-
-        let tuple_content;
-        parenthesized!(tuple_content in input);
-        let tuple_tokens: TokenStream = tuple_content.parse()?;
-        let tuple_fields = split_tuple_fields(tuple_tokens);
-
-        if !matches!(tuple_fields.len(), REQUIRED_FIELDS | OPTIONAL_FIELDS) {
-            return Err(syn::Error::new(
-                name.span(),
-                format!(
-                    "unexpected field count for option `{name}`: expected {REQUIRED_FIELDS} or {OPTIONAL_FIELDS}, found {}",
-                    tuple_fields.len()
-                ),
-            ));
-        }
-
-        if tuple_fields.len() == OPTIONAL_FIELDS
-            && !is_deprecated_marker_field(&tuple_fields[REQUIRED_FIELDS])
-        {
-            return Err(syn::Error::new(
-                name.span(),
-                format!(
-                    "unexpected trailing field in option `{name}`: expected `is_deprecated_and_do_nothing: ...`"
-                ),
-            ));
-        }
-
-        let description = parse_description_field(&tuple_fields[DESCRIPTION_FIELD], &name)?;
-        Ok(Self { name: name.to_string(), line, description })
-    }
-}
-
-impl Parse for UnstableOptionsInput {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let struct_name: Ident = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let _tmod_enum_name: Ident = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let _stat_name: Ident = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let _opt_module_name: Ident = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let _prefix: LitStr = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let _output_name: LitStr = input.parse()?;
-        input.parse::<Token![,]>()?;
-
-        let entries =
-            syn::punctuated::Punctuated::<ParsedOptionEntry, Token![,]>::parse_terminated(input)?
-                .into_iter()
-                .collect();
-
-        Ok(Self { struct_name, entries })
-    }
-}
-
-fn parse_compiler_flags(options_rs: &str, options_path: &Path) -> Features {
-    let options_input = parse_unstable_options_macro(options_rs).unwrap_or_else(|error| {
-        panic!("failed to parse unstable options from `{}`: {error}", options_path.display())
-    });
-
-    let mut features = Features::new();
-    for entry in options_input.entries {
-        if entry.name == "help" {
-            continue;
-        }
-
-        features.insert(
-            entry.name,
-            Feature {
-                level: Status::Unstable,
-                since: None,
-                has_gate_test: false,
-                tracking_issue: None,
-                file: options_path.to_path_buf(),
-                line: entry.line,
-                description: Some(entry.description),
-            },
-        );
-    }
-
-    features
-}
-
-fn parse_unstable_options_macro(source: &str) -> syn::Result<UnstableOptionsInput> {
-    let ast = syn::parse_file(source)?;
-
-    for item in ast.items {
-        let Item::Macro(item_macro) = item else {
-            continue;
-        };
-
-        if !item_macro.mac.path.is_ident("options") {
-            continue;
-        }
-
-        let parsed = syn::parse2::<UnstableOptionsInput>(item_macro.mac.tokens)?;
-        if parsed.struct_name == "UnstableOptions" {
-            return Ok(parsed);
-        }
-    }
-
-    Err(syn::Error::new(
-        Span::call_site(),
-        "could not find `options!` invocation for `UnstableOptions`",
-    ))
-}
-
-fn parse_description_field(field: &TokenStream, option_name: &Ident) -> syn::Result<String> {
-    let lit = syn::parse2::<LitStr>(field.clone()).map_err(|_| {
-        syn::Error::new_spanned(
-            field.clone(),
-            format!("expected description string literal in option `{option_name}`"),
-        )
-    })?;
-    Ok(lit.value())
-}
-
-fn split_tuple_fields(tuple_tokens: TokenStream) -> Vec<TokenStream> {
-    let mut fields = Vec::new();
-    let mut current = TokenStream::new();
-
-    for token in tuple_tokens {
-        if let TokenTree::Punct(punct) = &token {
-            if punct.as_char() == ',' {
-                fields.push(current);
-                current = TokenStream::new();
-                continue;
-            }
-        }
-        current.extend([token]);
-    }
-    fields.push(current);
-
-    while matches!(fields.last(), Some(field) if field.is_empty()) {
-        fields.pop();
-    }
-
-    fields
-}
-
-fn is_deprecated_marker_field(field: &TokenStream) -> bool {
-    let mut tokens = field.clone().into_iter();
-    let Some(TokenTree::Ident(name)) = tokens.next() else {
-        return false;
-    };
-    let Some(TokenTree::Punct(colon)) = tokens.next() else {
-        return false;
-    };
-    name == "is_deprecated_and_do_nothing" && colon.as_char() == ':'
-}
-
 fn main() {
     let library_path_str = env::args_os().nth(1).expect("library/ path required");
     let compiler_path_str = env::args_os().nth(2).expect("compiler/ path required");
@@ -316,7 +129,6 @@ fn main() {
         .filter(|&(ref name, _)| !lang_features.contains_key(name))
         .collect();
     let env_vars = collect_env_vars(compiler_path);
-    let compiler_flags = collect_compiler_flags(compiler_path);
 
     let doc_src_path = src_path.join(PATH_STR);
 
@@ -332,17 +144,9 @@ fn main() {
         &dest_path.join(LIB_FEATURES_DIR),
         &lib_features,
     );
-    generate_feature_files(
-        &doc_src_path.join(COMPILER_FLAGS_DIR),
-        &dest_path.join(COMPILER_FLAGS_DIR),
-        &compiler_flags,
-    );
     generate_env_files(&doc_src_path.join(ENV_VARS_DIR), &dest_path.join(ENV_VARS_DIR), &env_vars);
 
     copy_recursive(&doc_src_path, &dest_path);
 
     generate_summary(&dest_path, &lang_features, &lib_features);
 }
-
-#[cfg(test)]
-mod tests;
diff --git a/src/tools/unstable-book-gen/src/tests.rs b/src/tools/unstable-book-gen/src/tests.rs
deleted file mode 100644
index 000cfaebdac3..000000000000
--- a/src/tools/unstable-book-gen/src/tests.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use super::parse_compiler_flags;
-
-#[test]
-fn parses_unstable_options_entries() {
-    let options_rs = r#"options! {
-    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
-
-    #[rustc_lint_opt_deny_field_access("test attr")]
-    allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
-        "only allow the listed language features to be enabled in code (comma separated)"),
-    dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
-        "dump MIR state to file.\n\
-        `val` is used to select which passes and functions to dump."),
-    join_lines: bool = (false, parse_bool, [TRACKED],
-        "join \
-         continued lines"),
-    help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
-}"#;
-
-    let features = parse_compiler_flags(options_rs, Path::new("options/unstable.rs"));
-
-    assert!(features.contains_key("allow_features"));
-    assert!(features.contains_key("dump_mir"));
-    assert!(features.contains_key("join_lines"));
-    assert!(!features.contains_key("help"));
-
-    assert!(
-        features["dump_mir"]
-            .description
-            .as_deref()
-            .expect("dump_mir description should exist")
-            .starts_with("dump MIR state to file.\n"),
-    );
-    assert_eq!(features["join_lines"].description.as_deref(), Some("join continued lines"));
-    assert_eq!(
-        features["allow_features"].description.as_deref(),
-        Some("only allow the listed language features to be enabled in code (comma separated)"),
-    );
-    assert_eq!(features["allow_features"].file, PathBuf::from("options/unstable.rs"));
-    assert_eq!(features["allow_features"].line, 5);
-}
-
-#[test]
-fn parser_accepts_optional_trailing_metadata() {
-    let options_rs = r##"options! {
-    UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
-
-    deprecated_flag: bool = (false, parse_no_value, [UNTRACKED], "deprecated flag",
-        is_deprecated_and_do_nothing: true),
-    raw_description: bool = (false, parse_no_value, [UNTRACKED], r#"raw "quoted" text"#),
-}"##;
-
-    let features = parse_compiler_flags(options_rs, Path::new("options/unstable.rs"));
-    assert_eq!(features["deprecated_flag"].description.as_deref(), Some("deprecated flag"));
-    assert_eq!(features["raw_description"].description.as_deref(), Some("raw \"quoted\" text"),);
-}
-
-#[test]
-fn parses_real_unstable_options_file() {
-    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let options_path = manifest_dir.join("../../../compiler/rustc_session/src/options/unstable.rs");
-    let options_rs = std::fs::read_to_string(&options_path).unwrap();
-    let features = parse_compiler_flags(&options_rs, &options_path);
-
-    assert!(features.contains_key("allow_features"));
-    assert!(features.contains_key("dump_mir"));
-    assert!(features.contains_key("unstable_options"));
-    assert!(!features.contains_key("help"));
-    assert!(features["dump_mir"].line > 0);
-    assert!(features["dump_mir"].description.as_deref().unwrap().starts_with("dump MIR state"));
-}

From 41c932c327737fc70972429c1283e62a113a1c12 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sat, 28 Mar 2026 05:11:29 +0100
Subject: [PATCH 0990/1059] Revert "re-enable enzyme/autodiff builds on
 dist-aarch64-apple"

This reverts commit 988633d72cedaf3d56bb9a77589fc08bb15b62b3.
---
 src/ci/github-actions/jobs.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 5909f29d52c1..bff0046c97cb 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -509,7 +509,7 @@ auto:
   - name: dist-aarch64-apple
     env:
       SCRIPT: >-
-        ./x.py dist bootstrap enzyme
+        ./x.py dist bootstrap
         --include-default-paths
         --host=aarch64-apple-darwin
         --target=aarch64-apple-darwin

From a3261a23074654ff9bd733387ba463e4cae072c0 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sat, 28 Mar 2026 00:54:59 +0100
Subject: [PATCH 0991/1059] Revert "Link LLVM dynamically on
 aarch64-apple-darwin"

This reverts commit e7c268f8837b2e67d1f90a75357a4c58f697dc59.
---
 compiler/rustc_llvm/build.rs               | 10 ----------
 compiler/rustc_metadata/src/native_libs.rs | 10 +++-------
 src/ci/github-actions/jobs.yml             |  1 -
 3 files changed, 3 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index 66b3e266a22f..38c16fb1cd6d 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -402,16 +402,6 @@ fn main() {
             continue;
         }
 
-        // On apple-darwin, llvm-config reports the versioned shared library name such as LLVM-22-..., but
-        // the distributed toolchain ships libLLVM.dylib. Normalize the link name here.
-        let name =
-            if target.contains("apple-darwin") && llvm_kind == "dylib" && name.starts_with("LLVM-")
-            {
-                "LLVM"
-            } else {
-                name
-            };
-
         let kind = if name.starts_with("LLVM") {
             llvm_kind
         } else if is_static {
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 06755a0ccf16..a05366d7147b 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -62,15 +62,12 @@ pub fn walk_native_lib_search_dirs<R>(
         f(&sess.target_tlib_path.dir.join("self-contained"), false)?;
     }
 
-    let has_shared_llvm_apple_darwin =
-        sess.target.is_like_darwin && sess.target_tlib_path.dir.join("libLLVM.dylib").exists();
-
     // Toolchains for some targets may ship `libunwind.a`, but place it into the main sysroot
     // library directory instead of the self-contained directories.
     // Sanitizer libraries have the same issue and are also linked by name on Apple targets.
     // The targets here should be in sync with `copy_third_party_objects` in bootstrap.
-    // On Apple targets, shared LLVM is linked by name, so when `libLLVM.dylib` is
-    // present in the target libdir, add that directory to the linker search path.
+    // Finally there is shared LLVM library, which unlike compiler libraries, is linked by the name,
+    // therefore requiring the search path for the linker.
     // FIXME: implement `-Clink-self-contained=+/-unwind,+/-sanitizers`, move the shipped libunwind
     // and sanitizers to self-contained directory, and stop adding this search path.
     // FIXME: On AIX this also has the side-effect of making the list of library search paths
@@ -80,8 +77,7 @@ pub fn walk_native_lib_search_dirs<R>(
         || sess.target.os == Os::Linux
         || sess.target.os == Os::Fuchsia
         || sess.target.is_like_aix
-        || sess.target.is_like_darwin
-            && (!sess.sanitizers().is_empty() || has_shared_llvm_apple_darwin)
+        || sess.target.is_like_darwin && !sess.sanitizers().is_empty()
         || sess.target.os == Os::Windows
             && sess.target.env == Env::Gnu
             && sess.target.cfg_abi == CfgAbi::Llvm
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index bff0046c97cb..7c0f1d3f2930 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -518,7 +518,6 @@ auto:
         --enable-sanitizers
         --enable-profiler
         --set rust.jemalloc
-        --set llvm.link-shared=true
         --set rust.lto=thin
         --set rust.codegen-units=1
       # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else

From 0d3d1ac9b3417fcea4fc2cb631779b32891c14d0 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sat, 28 Mar 2026 03:28:26 +0100
Subject: [PATCH 0992/1059] bootstrap: force a CI LLVM stamp bump

---
 src/bootstrap/download-ci-llvm-stamp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/download-ci-llvm-stamp b/src/bootstrap/download-ci-llvm-stamp
index fa640ad8d96f..dd68964b7568 100644
--- a/src/bootstrap/download-ci-llvm-stamp
+++ b/src/bootstrap/download-ci-llvm-stamp
@@ -1,4 +1,4 @@
 Change this file to make users of the `download-ci-llvm` configuration download
 a new version of LLVM from CI, even if the LLVM submodule hasn’t changed.
 
-Last change is for: https://github.com/rust-lang/rust/pull/151063
+Last change is for: https://github.com/rust-lang/rust/pull/154485

From a53f0bc7ea6ae057974a3888f0744e8624515a6e Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 28 Mar 2026 12:14:27 +0800
Subject: [PATCH 0993/1059] triagebot: add reminder for bumping CI LLVM stamp

---
 triagebot.toml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 01d047cdae55..71de6d32de74 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1412,6 +1412,15 @@ cc = ["@m-ou-se"]
 [mentions."compiler/rustc_ast_lowering/src/format.rs"]
 cc = ["@m-ou-se"]
 
+[mentions."src/ci/github-actions/jobs.yml"]
+message = """
+> [!WARNING]
+>
+> If you are changing how CI LLVM is built or linked, make sure to bump
+> `src/bootstrap/download-ci-llvm-stamp`.
+"""
+cc = ["@jieyouxu"]
+
 # Content-based mentions
 
 [mentions."#[miri::intrinsic_fallback_is_spec]"]

From 1b724576cfda121debe1b7bdb442980a696d6726 Mon Sep 17 00:00:00 2001
From: Weixie Cui <cuiweixie@gmail.com>
Date: Thu, 26 Mar 2026 09:49:01 +0800
Subject: [PATCH 0994/1059] fix: Correct Display label for
 Event::FetchWorkspaces

The fmt::Display implementation for Event printed the wrong variant name
(Event::SwitchWorkspaces) for FetchWorkspaces events, which was misleading in
tracing output.

Add a regression test.
---
 src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index dad321137fa6..7c494de6f73d 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -92,7 +92,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             Event::DeferredTask(_) => write!(f, "Event::DeferredTask"),
             Event::TestResult(_) => write!(f, "Event::TestResult"),
             Event::DiscoverProject(_) => write!(f, "Event::DiscoverProject"),
-            Event::FetchWorkspaces(_) => write!(f, "Event::SwitchWorkspaces"),
+            Event::FetchWorkspaces(_) => write!(f, "Event::FetchWorkspaces"),
         }
     }
 }

From 531631c7ade22f48d5ee32bf193bb202ce2e521e Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 8 Mar 2026 13:46:10 +0900
Subject: [PATCH 0995/1059] Make messages more generic

---
 .../rustc_hir_typeck/src/method/suggest.rs    | 25 +------
 .../multiple-dep-versions.stderr              |  4 +-
 .../associated-const-no-item.rs               |  2 +-
 .../associated-const-no-item.stderr           |  4 +-
 ...rojection-self-ty-invalid-bivariant-arg.rs |  2 +-
 ...ction-self-ty-invalid-bivariant-arg.stderr |  8 +-
 ...ojection-self-ty-invalid-bivariant-arg2.rs |  2 +-
 ...tion-self-ty-invalid-bivariant-arg2.stderr |  8 +-
 .../associated-item/associated-item-enum.rs   |  6 +-
 .../associated-item-enum.stderr               | 18 ++---
 ...ated-type-as-value-in-impl-issue-142797.rs |  2 -
 ...-type-as-value-in-impl-issue-142797.stderr |  2 +-
 .../associated-type-as-value.rs               |  2 +-
 .../associated-type-as-value.stderr           |  6 +-
 tests/ui/associated-types/issue-43924.rs      |  2 +-
 tests/ui/associated-types/issue-43924.stderr  |  4 +-
 .../attributes/rustc_confusables_assoc_fn.rs  |  2 +-
 .../rustc_confusables_assoc_fn.stderr         |  6 +-
 .../non_valtreeable_const_arg-2.rs            |  2 +-
 .../non_valtreeable_const_arg-2.stderr        |  6 +-
 .../generic_const_exprs/issue-69654.rs        |  2 +-
 .../generic_const_exprs/issue-69654.stderr    |  6 +-
 .../generic_const_exprs/issue-80742.rs        |  2 +-
 .../generic_const_exprs/issue-80742.stderr    |  6 +-
 .../size_of-dyn-trait-3.rs                    |  2 +-
 .../size_of-dyn-trait-3.stderr                |  6 +-
 .../const-generics/invalid-path-in-const.rs   |  2 +-
 .../invalid-path-in-const.stderr              |  4 +-
 .../ui/consts/const-needs_drop-monomorphic.rs |  2 +-
 .../const-needs_drop-monomorphic.stderr       |  6 +-
 ..._body_owner_parent_found_in_diagnostics.rs |  2 +-
 ...y_owner_parent_found_in_diagnostics.stderr |  6 +-
 tests/ui/did_you_mean/bad-assoc-pat.rs        | 12 +--
 tests/ui/did_you_mean/bad-assoc-pat.stderr    | 24 +++---
 .../enum/enum-discriminant-missing-variant.rs |  2 +-
 .../enum-discriminant-missing-variant.stderr  |  6 +-
 tests/ui/error-codes/E0599.stderr             |  6 +-
 tests/ui/expr/issue-22933-2.rs                |  2 +-
 tests/ui/expr/issue-22933-2.stderr            |  6 +-
 ...ied-gat-bound-during-assoc-ty-selection.rs |  2 +-
 ...gat-bound-during-assoc-ty-selection.stderr |  6 +-
 tests/ui/impl-trait/issues/issue-62742.rs     |  2 +-
 tests/ui/impl-trait/issues/issue-62742.stderr | 12 +--
 tests/ui/issues/issue-28586.rs                |  2 +-
 tests/ui/issues/issue-28586.stderr            |  4 +-
 tests/ui/issues/issue-28971.rs                |  2 +-
 tests/ui/issues/issue-28971.stderr            |  6 +-
 tests/ui/issues/issue-30123.rs                |  2 +-
 tests/ui/issues/issue-30123.stderr            |  6 +-
 tests/ui/issues/issue-42880.rs                |  2 +-
 tests/ui/issues/issue-42880.stderr            |  4 +-
 tests/ui/let-else/let-else-no-double-error.rs |  2 +-
 .../let-else/let-else-no-double-error.stderr  |  4 +-
 .../ui/methods/ident-from-macro-expansion.rs  |  2 +-
 .../methods/ident-from-macro-expansion.stderr |  4 +-
 tests/ui/methods/issue-7950.rs                |  2 +-
 tests/ui/methods/issue-7950.stderr            |  6 +-
 .../missing-method-on-type-parameter.stderr   |  6 +-
 tests/ui/methods/receiver-equality.rs         |  2 +-
 tests/ui/methods/receiver-equality.stderr     |  6 +-
 tests/ui/nll/issue-57362-2.rs                 |  2 +-
 tests/ui/nll/issue-57362-2.stderr             |  4 +-
 .../nll/issue-57642-higher-ranked-subtype.rs  |  5 +-
 .../issue-57642-higher-ranked-subtype.stderr  |  8 +-
 .../ty-variance-issue-124423.rs               |  2 +-
 .../ty-variance-issue-124423.stderr           | 16 ++--
 .../ty-variance-issue-127971.rs               |  2 +-
 .../ty-variance-issue-127971.stderr           |  4 +-
 tests/ui/parser/emoji-identifiers.rs          |  2 +-
 tests/ui/parser/emoji-identifiers.stderr      |  6 +-
 .../pattern-match-invalid-variant.stderr      |  6 +-
 .../ufc-method-call.different_name.stderr     |  8 +-
 tests/ui/privacy/ufc-method-call.rs           |  2 +-
 tests/ui/resolve/empty-struct-braces-expr.rs  |  4 +-
 .../resolve/empty-struct-braces-expr.stderr   |  8 +-
 tests/ui/resolve/issue-82865.rs               |  2 +-
 tests/ui/resolve/issue-82865.stderr           |  4 +-
 tests/ui/resolve/missing-associated-items.rs  |  8 +-
 .../resolve/missing-associated-items.stderr   | 24 +++---
 .../resolve/suggestions/suggest-builder-fn.rs |  6 +-
 .../suggestions/suggest-builder-fn.stderr     | 16 ++--
 .../typo-suggestion-mistyped-in-path.rs       |  6 +-
 .../typo-suggestion-mistyped-in-path.stderr   |  6 +-
 .../no-double-error.rs                        |  2 +-
 .../no-double-error.stderr                    |  4 +-
 .../ui/rust-2018/trait-import-suggestions.rs  |  2 +-
 .../rust-2018/trait-import-suggestions.stderr |  4 +-
 .../ui/rust-2018/uniform-paths/issue-87932.rs |  2 +-
 .../uniform-paths/issue-87932.stderr          |  6 +-
 tests/ui/shadowed/shadowing-generic-item.rs   |  2 +-
 .../ui/shadowed/shadowing-generic-item.stderr |  6 +-
 ...ut-not-available.alignment_mismatch.stderr |  6 +-
 .../atomic-from-mut-not-available.rs          |  2 +-
 tests/ui/suggestions/deref-path-method.rs     |  2 +-
 tests/ui/suggestions/deref-path-method.stderr |  4 +-
 .../dont-suggest-private-trait-method.rs      |  2 +-
 .../dont-suggest-private-trait-method.stderr  |  6 +-
 .../suggestions/incorrect-variant-literal.svg | 74 +++++++++----------
 tests/ui/suggestions/issue-109291.rs          |  2 +-
 tests/ui/suggestions/issue-109291.stderr      |  4 +-
 tests/ui/suggestions/suggest-variants.stderr  | 36 ++++-----
 ...t-trait-alias-bound-on-generic-impl.stderr |  6 +-
 ...iated-item-unsatisfied-trait-bounds.stderr |  6 +-
 tests/ui/traits/issue-3973.rs                 |  2 +-
 tests/ui/traits/issue-3973.stderr             |  6 +-
 tests/ui/traits/item-privacy.rs               |  8 +-
 tests/ui/traits/item-privacy.stderr           | 24 +++---
 .../traits/unspecified-self-in-trait-ref.rs   |  8 +-
 .../unspecified-self-in-trait-ref.stderr      | 16 ++--
 tests/ui/type/issue-103271.rs                 |  8 +-
 tests/ui/type/issue-103271.stderr             |  8 +-
 tests/ui/typeck/derive-sugg-arg-arity.rs      |  2 +-
 tests/ui/typeck/derive-sugg-arg-arity.stderr  |  6 +-
 .../dont-suggest-private-dependencies.rs      |  4 +-
 .../dont-suggest-private-dependencies.stderr  |  8 +-
 ...est-trait-reexported-as-not-doc-visible.rs |  2 +-
 ...trait-reexported-as-not-doc-visible.stderr |  4 +-
 tests/ui/ufcs/bad-builder.rs                  |  2 +-
 tests/ui/ufcs/bad-builder.stderr              |  4 +-
 tests/ui/ufcs/ufcs-partially-resolved.rs      |  4 +-
 tests/ui/ufcs/ufcs-partially-resolved.stderr  |  8 +-
 121 files changed, 367 insertions(+), 387 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 20528f71b051..c5b3d7065fa9 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1175,31 +1175,12 @@ fn report_no_match_method_error(
         let mut ty_file = None;
         let mode = no_match_data.mode;
         let is_method = mode == Mode::MethodCall;
-        let has_self_assoc_type = if let SelfSource::QPath(ty) = source
-            && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
-            && let Res::SelfTyAlias { alias_to: impl_def_id, .. } = path.res
-            && let DefKind::Impl { .. } = self.tcx.def_kind(impl_def_id)
-        {
-            self.tcx
-                .associated_items(impl_def_id)
-                .find_by_ident_and_kind(self.tcx, item_ident, ty::AssocTag::Type, impl_def_id)
-                .is_some()
-        } else {
-            false
-        };
         let item_kind = if is_method {
             "method"
-        } else if rcvr_ty.is_enum() {
-            "variant or associated item"
-        } else if has_self_assoc_type {
-            "associated function or constant"
+        } else if rcvr_ty.is_enum() || rcvr_ty.is_fresh_ty() {
+            "variant, associated function, or constant"
         } else {
-            match (item_ident.as_str().chars().next(), rcvr_ty.is_fresh_ty()) {
-                (Some(name), false) if name.is_lowercase() => "function or associated item",
-                (Some(_), false) => "associated item",
-                (Some(_), true) | (None, false) => "variant or associated item",
-                (None, true) => "variant",
-            }
+            "associated function or constant"
         };
 
         if let Err(guar) = self.report_failed_method_call_on_numerical_infer_var(
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.stderr b/tests/run-make/crate-loading/multiple-dep-versions.stderr
index a683fdd389c6..42dc805b85dd 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.stderr
+++ b/tests/run-make/crate-loading/multiple-dep-versions.stderr
@@ -46,11 +46,11 @@ LL | pub trait Trait {
    | --------------- this is the trait that was imported
    = help: you can use `cargo tree` to explore your dependency tree
 
-error[E0599]: no function or associated item named `bar` found for struct `dep_2_reexport::Type` in the current scope
+error[E0599]: no associated function or constant named `bar` found for struct `dep_2_reexport::Type` in the current scope
   --> replaced
    |
 LL |     Type::bar();
-   |           ^^^ function or associated item not found in `dep_2_reexport::Type`
+   |           ^^^ associated function or constant not found in `dep_2_reexport::Type`
    |
 note: there are multiple different versions of crate `dependency` in the dependency graph
   --> replaced
diff --git a/tests/ui/associated-consts/associated-const-no-item.rs b/tests/ui/associated-consts/associated-const-no-item.rs
index 024d14e21b5f..116f1aab3f48 100644
--- a/tests/ui/associated-consts/associated-const-no-item.rs
+++ b/tests/ui/associated-consts/associated-const-no-item.rs
@@ -3,7 +3,7 @@ trait Foo {
 }
 
 const X: i32 = <i32>::ID;
-//~^ ERROR no associated item named `ID` found
+//~^ ERROR no associated function or constant named `ID` found
 
 fn main() {
     assert_eq!(1, X);
diff --git a/tests/ui/associated-consts/associated-const-no-item.stderr b/tests/ui/associated-consts/associated-const-no-item.stderr
index 7ded05b7b48e..40cd7791399b 100644
--- a/tests/ui/associated-consts/associated-const-no-item.stderr
+++ b/tests/ui/associated-consts/associated-const-no-item.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `ID` found for type `i32` in the current scope
+error[E0599]: no associated function or constant named `ID` found for type `i32` in the current scope
   --> $DIR/associated-const-no-item.rs:5:23
    |
 LL | const X: i32 = <i32>::ID;
-   |                       ^^ associated item not found in `i32`
+   |                       ^^ associated function or constant not found in `i32`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `Foo` defines an item `ID`, perhaps you need to implement it
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.rs b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.rs
index a33d4928f014..0de982142df4 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.rs
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.rs
@@ -7,5 +7,5 @@ impl Fail<i32> {
 
 fn main() {
     Fail::<()>::C
-    //~^ ERROR no associated item named `C` found for struct `Fail<()>` in the current scope
+    //~^ ERROR no associated function or constant named `C` found for struct `Fail<()>` in the current scope
 }
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
index b17682eb83e4..0ddde320f95e 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg.stderr
@@ -7,16 +7,16 @@ LL | struct Fail<T>;
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
 
-error[E0599]: no associated item named `C` found for struct `Fail<()>` in the current scope
+error[E0599]: no associated function or constant named `C` found for struct `Fail<()>` in the current scope
   --> $DIR/wrong-projection-self-ty-invalid-bivariant-arg.rs:9:17
    |
 LL | struct Fail<T>;
-   | -------------- associated item `C` not found for this struct
+   | -------------- associated function or constant `C` not found for this struct
 ...
 LL |     Fail::<()>::C
-   |                 ^ associated item not found in `Fail<()>`
+   |                 ^ associated function or constant not found in `Fail<()>`
    |
-   = note: the associated item was found for `Fail<i32>`
+   = note: the associated function or constant was found for `Fail<i32>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.rs b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.rs
index d891b7bd62b4..e4f2bbf24e6b 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.rs
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.rs
@@ -14,5 +14,5 @@ impl Fail<i32, i32> {
 fn main() {
     Fail::<i32, u32>::C
     //~^ ERROR: type mismatch
-    //~| ERROR no associated item named `C` found for struct `Fail<i32, u32>` in the current scope
+    //~| ERROR no associated function or constant named `C` found for struct `Fail<i32, u32>` in the current scope
 }
diff --git a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
index d0c7df9de43b..04568b874b5e 100644
--- a/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
+++ b/tests/ui/associated-consts/wrong-projection-self-ty-invalid-bivariant-arg2.stderr
@@ -15,16 +15,16 @@ note: required by a bound in `Fail`
 LL | struct Fail<T: Proj<Assoc = U>, U>(T);
    |                     ^^^^^^^^^ required by this bound in `Fail`
 
-error[E0599]: no associated item named `C` found for struct `Fail<i32, u32>` in the current scope
+error[E0599]: no associated function or constant named `C` found for struct `Fail<i32, u32>` in the current scope
   --> $DIR/wrong-projection-self-ty-invalid-bivariant-arg2.rs:15:23
    |
 LL | struct Fail<T: Proj<Assoc = U>, U>(T);
-   | ---------------------------------- associated item `C` not found for this struct
+   | ---------------------------------- associated function or constant `C` not found for this struct
 ...
 LL |     Fail::<i32, u32>::C
-   |                       ^ associated item not found in `Fail<i32, u32>`
+   |                       ^ associated function or constant not found in `Fail<i32, u32>`
    |
-   = note: the associated item was found for `Fail<i32, i32>`
+   = note: the associated function or constant was found for `Fail<i32, i32>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/associated-item/associated-item-enum.rs b/tests/ui/associated-item/associated-item-enum.rs
index 30ba258155bb..3a5c058f5ec2 100644
--- a/tests/ui/associated-item/associated-item-enum.rs
+++ b/tests/ui/associated-item/associated-item-enum.rs
@@ -14,7 +14,7 @@ fn misspellable_trait() {}
 }
 
 fn main() {
-    Enum::mispellable(); //~ ERROR no variant or associated item
-    Enum::mispellable_trait(); //~ ERROR no variant or associated item
-    Enum::MISPELLABLE; //~ ERROR no variant or associated item
+    Enum::mispellable(); //~ ERROR no variant, associated function, or constant
+    Enum::mispellable_trait(); //~ ERROR no variant, associated function, or constant
+    Enum::MISPELLABLE; //~ ERROR no variant, associated function, or constant
 }
diff --git a/tests/ui/associated-item/associated-item-enum.stderr b/tests/ui/associated-item/associated-item-enum.stderr
index c3ce7c34d056..6cb53e5cd0cc 100644
--- a/tests/ui/associated-item/associated-item-enum.stderr
+++ b/tests/ui/associated-item/associated-item-enum.stderr
@@ -1,39 +1,39 @@
-error[E0599]: no variant or associated item named `mispellable` found for enum `Enum` in the current scope
+error[E0599]: no variant, associated function, or constant named `mispellable` found for enum `Enum` in the current scope
   --> $DIR/associated-item-enum.rs:17:11
    |
 LL | enum Enum { Variant }
-   | --------- variant or associated item `mispellable` not found for this enum
+   | --------- variant, associated function, or constant `mispellable` not found for this enum
 ...
 LL |     Enum::mispellable();
-   |           ^^^^^^^^^^^ variant or associated item not found in `Enum`
+   |           ^^^^^^^^^^^ variant, associated function, or constant not found in `Enum`
    |
 help: there is an associated function `misspellable` with a similar name
    |
 LL |     Enum::misspellable();
    |              +
 
-error[E0599]: no variant or associated item named `mispellable_trait` found for enum `Enum` in the current scope
+error[E0599]: no variant, associated function, or constant named `mispellable_trait` found for enum `Enum` in the current scope
   --> $DIR/associated-item-enum.rs:18:11
    |
 LL | enum Enum { Variant }
-   | --------- variant or associated item `mispellable_trait` not found for this enum
+   | --------- variant, associated function, or constant `mispellable_trait` not found for this enum
 ...
 LL |     Enum::mispellable_trait();
-   |           ^^^^^^^^^^^^^^^^^ variant or associated item not found in `Enum`
+   |           ^^^^^^^^^^^^^^^^^ variant, associated function, or constant not found in `Enum`
    |
 help: there is an associated function `misspellable_trait` with a similar name
    |
 LL |     Enum::misspellable_trait();
    |              +
 
-error[E0599]: no variant or associated item named `MISPELLABLE` found for enum `Enum` in the current scope
+error[E0599]: no variant, associated function, or constant named `MISPELLABLE` found for enum `Enum` in the current scope
   --> $DIR/associated-item-enum.rs:19:11
    |
 LL | enum Enum { Variant }
-   | --------- variant or associated item `MISPELLABLE` not found for this enum
+   | --------- variant, associated function, or constant `MISPELLABLE` not found for this enum
 ...
 LL |     Enum::MISPELLABLE;
-   |           ^^^^^^^^^^^ variant or associated item not found in `Enum`
+   |           ^^^^^^^^^^^ variant, associated function, or constant not found in `Enum`
    |
 help: there is an associated constant `MISSPELLABLE` with a similar name
    |
diff --git a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
index 77d62ebd494e..f588d6d0a43f 100644
--- a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
+++ b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.rs
@@ -1,7 +1,5 @@
 // issue: <https://github.com/rust-lang/rust/issues/142797>
 
-#![allow(dead_code, unused_variables)]
-
 struct SomeStruct {
     some_field: u64,
 }
diff --git a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr
index aa2494c4c48c..83b915c2684e 100644
--- a/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr
+++ b/tests/ui/associated-types/associated-type-as-value-in-impl-issue-142797.stderr
@@ -1,5 +1,5 @@
 error[E0599]: no associated function or constant named `SomeType` found for type `bool` in the current scope
-  --> $DIR/associated-type-as-value-in-impl-issue-142797.rs:18:24
+  --> $DIR/associated-type-as-value-in-impl-issue-142797.rs:16:24
    |
 LL |         let ss = Self::SomeType;
    |                        ^^^^^^^^ associated function or constant not found in `bool`
diff --git a/tests/ui/associated-types/associated-type-as-value.rs b/tests/ui/associated-types/associated-type-as-value.rs
index ddc808236658..7fefc48eb337 100644
--- a/tests/ui/associated-types/associated-type-as-value.rs
+++ b/tests/ui/associated-types/associated-type-as-value.rs
@@ -1,7 +1,7 @@
 //! regression test for <https://github.com/rust-lang/rust/issues/38919>
 
 fn foo<T: Iterator>() {
-    T::Item; //~ ERROR no associated item named `Item` found
+    T::Item; //~ ERROR no associated function or constant named `Item` found
 }
 
 fn main() { }
diff --git a/tests/ui/associated-types/associated-type-as-value.stderr b/tests/ui/associated-types/associated-type-as-value.stderr
index c553582b3907..0015ebe767dd 100644
--- a/tests/ui/associated-types/associated-type-as-value.stderr
+++ b/tests/ui/associated-types/associated-type-as-value.stderr
@@ -1,10 +1,10 @@
-error[E0599]: no associated item named `Item` found for type parameter `T` in the current scope
+error[E0599]: no associated function or constant named `Item` found for type parameter `T` in the current scope
   --> $DIR/associated-type-as-value.rs:4:8
    |
 LL | fn foo<T: Iterator>() {
-   |        - associated item `Item` not found for this type parameter
+   |        - associated function or constant `Item` not found for this type parameter
 LL |     T::Item;
-   |        ^^^^ associated item not found in `T`
+   |        ^^^^ associated function or constant not found in `T`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/issue-43924.rs b/tests/ui/associated-types/issue-43924.rs
index 63ebbddea76f..dfc84611e8f6 100644
--- a/tests/ui/associated-types/issue-43924.rs
+++ b/tests/ui/associated-types/issue-43924.rs
@@ -13,5 +13,5 @@ impl Foo<u64> for () {}
 
 fn main() {
     assert_eq!(<() as Foo<u32>>::Out::default().to_string(), "false");
-    //~^ ERROR no function or associated item named `default` found for trait object
+    //~^ ERROR no associated function or constant named `default` found for trait object
 }
diff --git a/tests/ui/associated-types/issue-43924.stderr b/tests/ui/associated-types/issue-43924.stderr
index 196ad85f084e..5bf8ee730e61 100644
--- a/tests/ui/associated-types/issue-43924.stderr
+++ b/tests/ui/associated-types/issue-43924.stderr
@@ -10,11 +10,11 @@ note: required by a bound in `Foo::Out`
 LL |     type Out: Default + ToString + ?Sized = dyn ToString;
    |               ^^^^^^^ required by this bound in `Foo::Out`
 
-error[E0599]: no function or associated item named `default` found for trait object `(dyn ToString + 'static)` in the current scope
+error[E0599]: no associated function or constant named `default` found for trait object `(dyn ToString + 'static)` in the current scope
   --> $DIR/issue-43924.rs:15:39
    |
 LL |     assert_eq!(<() as Foo<u32>>::Out::default().to_string(), "false");
-   |                                       ^^^^^^^ function or associated item not found in `(dyn ToString + 'static)`
+   |                                       ^^^^^^^ associated function or constant not found in `(dyn ToString + 'static)`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/attributes/rustc_confusables_assoc_fn.rs b/tests/ui/attributes/rustc_confusables_assoc_fn.rs
index 5612ece0a8d9..6a93f7bb4385 100644
--- a/tests/ui/attributes/rustc_confusables_assoc_fn.rs
+++ b/tests/ui/attributes/rustc_confusables_assoc_fn.rs
@@ -12,7 +12,7 @@ fn qux(&self, x: i32) {}
 
 fn main() {
     S::bar();
-    //~^ ERROR no function or associated item named `bar`
+    //~^ ERROR no associated function or constant named `bar`
     //~| HELP you might have meant to use `foo`
 
     let s = S;
diff --git a/tests/ui/attributes/rustc_confusables_assoc_fn.stderr b/tests/ui/attributes/rustc_confusables_assoc_fn.stderr
index 657ca8098b80..da5cf27632ac 100644
--- a/tests/ui/attributes/rustc_confusables_assoc_fn.stderr
+++ b/tests/ui/attributes/rustc_confusables_assoc_fn.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no function or associated item named `bar` found for struct `S` in the current scope
+error[E0599]: no associated function or constant named `bar` found for struct `S` in the current scope
   --> $DIR/rustc_confusables_assoc_fn.rs:14:8
    |
 LL | struct S;
-   | -------- function or associated item `bar` not found for this struct
+   | -------- associated function or constant `bar` not found for this struct
 ...
 LL |     S::bar();
-   |        ^^^ function or associated item not found in `S`
+   |        ^^^ associated function or constant not found in `S`
    |
 help: you might have meant to use `foo`
    |
diff --git a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.rs b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.rs
index e364368b8a4c..3f092d08274c 100644
--- a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.rs
+++ b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.rs
@@ -15,5 +15,5 @@ fn call() {}
 
 fn main() {
     Wrapper::<function>::call;
-    //~^ ERROR: the function or associated item `call` exists for struct `Wrapper<function>`,
+    //~^ ERROR: the associated function or constant `call` exists for struct `Wrapper<function>`,
 }
diff --git a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
index b13f76eabadb..4d469deb00c0 100644
--- a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
+++ b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
@@ -15,14 +15,14 @@ error[E0741]: using function pointers as const generic parameters is forbidden
 LL | struct Wrapper<const F: fn()>;
    |                         ^^^^
 
-error[E0599]: the function or associated item `call` exists for struct `Wrapper<function>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `call` exists for struct `Wrapper<function>`, but its trait bounds were not satisfied
   --> $DIR/non_valtreeable_const_arg-2.rs:17:26
    |
 LL | struct Wrapper<const F: fn()>;
-   | ----------------------------- function or associated item `call` not found for this struct because it doesn't satisfy `Wrapper<function>: Fn<_>`
+   | ----------------------------- associated function or constant `call` not found for this struct because it doesn't satisfy `Wrapper<function>: Fn<_>`
 ...
 LL |     Wrapper::<function>::call;
-   |                          ^^^^ function or associated item cannot be called on `Wrapper<function>` due to unsatisfied trait bounds
+   |                          ^^^^ associated function or constant cannot be called on `Wrapper<function>` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `Wrapper<function>: Fn<_>`
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-69654.rs b/tests/ui/const-generics/generic_const_exprs/issue-69654.rs
index 9b36699bbf11..058f404df578 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-69654.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-69654.rs
@@ -15,5 +15,5 @@ fn foo() {}
 
 fn main() {
     Foo::foo();
-    //~^ ERROR the function or associated item
+    //~^ ERROR the associated function or constant
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-69654.stderr b/tests/ui/const-generics/generic_const_exprs/issue-69654.stderr
index 7fa0d8c7dbaa..9b5e556b94ee 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-69654.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-69654.stderr
@@ -11,14 +11,14 @@ help: you might have meant to write a const parameter here
 LL | impl<const T: /* Type */> Bar<T> for [u8; T] {}
    |      +++++  ++++++++++++
 
-error[E0599]: the function or associated item `foo` exists for struct `Foo<_>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `foo` exists for struct `Foo<_>`, but its trait bounds were not satisfied
   --> $DIR/issue-69654.rs:17:10
    |
 LL | struct Foo<const N: usize> {}
-   | -------------------------- function or associated item `foo` not found for this struct
+   | -------------------------- associated function or constant `foo` not found for this struct
 ...
 LL |     Foo::foo();
-   |          ^^^ function or associated item cannot be called on `Foo<_>` due to unsatisfied trait bounds
+   |          ^^^ associated function or constant cannot be called on `Foo<_>` due to unsatisfied trait bounds
    |
 note: trait bound `[u8; _]: Bar<[(); _]>` was not satisfied
   --> $DIR/issue-69654.rs:11:14
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
index 0d392902be87..99decb368e1d 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
@@ -27,5 +27,5 @@ pub fn new(val: T) -> Inline<T> {
 fn main() {
     let dst = Inline::<dyn Debug>::new(0);
     //~^ ERROR the size for values of type `dyn Debug` cannot be known at compilation time
-    //~| ERROR the function or associated item `new` exists for struct `Inline<dyn Debug>`
+    //~| ERROR the associated function or constant `new` exists for struct `Inline<dyn Debug>`
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
index ac1bfc8d7a1b..bad736b45685 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
@@ -15,14 +15,14 @@ help: consider relaxing the implicit `Sized` restriction
 LL | struct Inline<T: ?Sized>
    |                ++++++++
 
-error[E0599]: the function or associated item `new` exists for struct `Inline<dyn Debug>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `new` exists for struct `Inline<dyn Debug>`, but its trait bounds were not satisfied
   --> $DIR/issue-80742.rs:28:36
    |
 LL | struct Inline<T>
-   | ---------------- function or associated item `new` not found for this struct
+   | ---------------- associated function or constant `new` not found for this struct
 ...
 LL |     let dst = Inline::<dyn Debug>::new(0);
-   |                                    ^^^ function or associated item cannot be called on `Inline<dyn Debug>` due to unsatisfied trait bounds
+   |                                    ^^^ associated function or constant cannot be called on `Inline<dyn Debug>` due to unsatisfied trait bounds
    |
 note: trait bound `dyn Debug: Sized` was not satisfied
   --> $DIR/issue-80742.rs:18:6
diff --git a/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.rs b/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.rs
index afb086a41305..1e1ef0d73b45 100644
--- a/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.rs
+++ b/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.rs
@@ -17,5 +17,5 @@ struct Inline<T>
 fn main() {
     let dst = Inline::<dyn Debug>::new(0);
     //~^ ERROR the size for values of type `dyn Debug` cannot be known at compilation time
-    //~| ERROR no function or associated item named `new` found for struct `Inline<T>`
+    //~| ERROR no associated function or constant named `new` found for struct `Inline<T>`
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.stderr b/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.stderr
index bcc253ed9670..c73c2167dd75 100644
--- a/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/size_of-dyn-trait-3.stderr
@@ -15,14 +15,14 @@ help: consider relaxing the implicit `Sized` restriction
 LL | struct Inline<T: ?Sized>
    |                ++++++++
 
-error[E0599]: no function or associated item named `new` found for struct `Inline<T>` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `Inline<T>` in the current scope
   --> $DIR/size_of-dyn-trait-3.rs:18:36
    |
 LL | struct Inline<T>
-   | ---------------- function or associated item `new` not found for this struct
+   | ---------------- associated function or constant `new` not found for this struct
 ...
 LL |     let dst = Inline::<dyn Debug>::new(0);
-   |                                    ^^^ function or associated item not found in `Inline<dyn Debug>`
+   |                                    ^^^ associated function or constant not found in `Inline<dyn Debug>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/invalid-path-in-const.rs b/tests/ui/const-generics/invalid-path-in-const.rs
index 51eb86072119..a3c622aa5a96 100644
--- a/tests/ui/const-generics/invalid-path-in-const.rs
+++ b/tests/ui/const-generics/invalid-path-in-const.rs
@@ -1,4 +1,4 @@
 fn main() {
     fn f(a: [u8; u32::DOESNOTEXIST]) {}
-    //~^ ERROR no associated item named `DOESNOTEXIST` found for type `u32`
+    //~^ ERROR no associated function or constant named `DOESNOTEXIST` found for type `u32`
 }
diff --git a/tests/ui/const-generics/invalid-path-in-const.stderr b/tests/ui/const-generics/invalid-path-in-const.stderr
index 31528ab856e6..83c90a24d70b 100644
--- a/tests/ui/const-generics/invalid-path-in-const.stderr
+++ b/tests/ui/const-generics/invalid-path-in-const.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `DOESNOTEXIST` found for type `u32` in the current scope
+error[E0599]: no associated function or constant named `DOESNOTEXIST` found for type `u32` in the current scope
   --> $DIR/invalid-path-in-const.rs:2:23
    |
 LL |     fn f(a: [u8; u32::DOESNOTEXIST]) {}
-   |                       ^^^^^^^^^^^^ associated item not found in `u32`
+   |                       ^^^^^^^^^^^^ associated function or constant not found in `u32`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-needs_drop-monomorphic.rs b/tests/ui/consts/const-needs_drop-monomorphic.rs
index 7402c680985b..f68eb4bed613 100644
--- a/tests/ui/consts/const-needs_drop-monomorphic.rs
+++ b/tests/ui/consts/const-needs_drop-monomorphic.rs
@@ -9,7 +9,7 @@ fn assert() {}
 }
 fn f<T>() {
     Bool::<{ std::mem::needs_drop::<T>() }>::assert();
-    //~^ ERROR no function or associated item named `assert` found
+    //~^ ERROR no associated function or constant named `assert` found
     //~| ERROR unconstrained generic constant
 }
 fn main() {
diff --git a/tests/ui/consts/const-needs_drop-monomorphic.stderr b/tests/ui/consts/const-needs_drop-monomorphic.stderr
index 17f197cdd5d2..12ea559127ae 100644
--- a/tests/ui/consts/const-needs_drop-monomorphic.stderr
+++ b/tests/ui/consts/const-needs_drop-monomorphic.stderr
@@ -9,14 +9,14 @@ help: try adding a `where` bound
 LL | fn f<T>() where [(); { std::mem::needs_drop::<T>() } as usize]: {
    |           +++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-error[E0599]: no function or associated item named `assert` found for struct `Bool<{ std::mem::needs_drop::<T>() }>` in the current scope
+error[E0599]: no associated function or constant named `assert` found for struct `Bool<{ std::mem::needs_drop::<T>() }>` in the current scope
   --> $DIR/const-needs_drop-monomorphic.rs:11:46
    |
 LL | struct Bool<const B: bool> {}
-   | -------------------------- function or associated item `assert` not found for this struct
+   | -------------------------- associated function or constant `assert` not found for this struct
 ...
 LL |     Bool::<{ std::mem::needs_drop::<T>() }>::assert();
-   |                                              ^^^^^^ function or associated item cannot be called on `Bool<{ std::mem::needs_drop::<T>() }>` due to unsatisfied trait bounds
+   |                                              ^^^^^^ associated function or constant cannot be called on `Bool<{ std::mem::needs_drop::<T>() }>` due to unsatisfied trait bounds
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
index 0a7ec5ab5c1b..5d801f26de16 100644
--- a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
+++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
@@ -7,7 +7,7 @@
 
 impl<'a> InvariantRef<'a, ()> {
     pub const NEW: Self = InvariantRef::new(&());
-    //~^ ERROR: no function or associated item named `new` found
+    //~^ ERROR: no associated function or constant named `new` found
 }
 
 trait Trait {
diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
index ae5d0e8fa296..6cf844f29b06 100644
--- a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
+++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
@@ -43,14 +43,14 @@ help: consider introducing lifetime `'a` here
 LL | impl<'a> Trait for Z {
    |     ++++
 
-error[E0599]: no function or associated item named `new` found for struct `InvariantRef<'a, T>` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `InvariantRef<'a, T>` in the current scope
   --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:9:41
    |
 LL | pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>);
-   | -------------------------------------- function or associated item `new` not found for this struct
+   | -------------------------------------- associated function or constant `new` not found for this struct
 ...
 LL |     pub const NEW: Self = InvariantRef::new(&());
-   |                                         ^^^ function or associated item not found in `InvariantRef<'_, _>`
+   |                                         ^^^ associated function or constant not found in `InvariantRef<'_, _>`
 
 error[E0277]: the trait bound `u8: Trait` is not satisfied
   --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12
diff --git a/tests/ui/did_you_mean/bad-assoc-pat.rs b/tests/ui/did_you_mean/bad-assoc-pat.rs
index 3f912f7ffc63..911eeb0994e4 100644
--- a/tests/ui/did_you_mean/bad-assoc-pat.rs
+++ b/tests/ui/did_you_mean/bad-assoc-pat.rs
@@ -2,25 +2,25 @@ fn main() {
     match 0u8 {
         [u8]::AssocItem => {}
         //~^ ERROR missing angle brackets in associated item path
-        //~| ERROR no associated item named `AssocItem` found
+        //~| ERROR no associated function or constant named `AssocItem` found
         (u8, u8)::AssocItem => {}
         //~^ ERROR missing angle brackets in associated item path
-        //~| ERROR no associated item named `AssocItem` found
+        //~| ERROR no associated function or constant named `AssocItem` found
         _::AssocItem => {}
         //~^ ERROR missing angle brackets in associated item path
-        //~| ERROR no associated item named `AssocItem` found
+        //~| ERROR no associated function or constant named `AssocItem` found
     }
     match &0u8 {
         &(u8,)::AssocItem => {}
         //~^ ERROR missing angle brackets in associated item path
-        //~| ERROR no associated item named `AssocItem` found
+        //~| ERROR no associated function or constant named `AssocItem` found
     }
 }
 
 macro_rules! pat {
     ($ty: ty) => ($ty::AssocItem)
     //~^ ERROR missing angle brackets in associated item path
-    //~| ERROR no associated item named `AssocItem` found
+    //~| ERROR no associated function or constant named `AssocItem` found
 }
 macro_rules! ty {
     () => (u8)
@@ -31,6 +31,6 @@ fn check_macros() {
         pat!(u8) => {}
         ty!()::AssocItem => {}
         //~^ ERROR missing angle brackets in associated item path
-        //~| ERROR no associated item named `AssocItem` found
+        //~| ERROR no associated function or constant named `AssocItem` found
     }
 }
diff --git a/tests/ui/did_you_mean/bad-assoc-pat.stderr b/tests/ui/did_you_mean/bad-assoc-pat.stderr
index 8bdeb8ffdd0a..aff3d97eadae 100644
--- a/tests/ui/did_you_mean/bad-assoc-pat.stderr
+++ b/tests/ui/did_you_mean/bad-assoc-pat.stderr
@@ -68,46 +68,46 @@ help: types that don't start with an identifier need to be surrounded with angle
 LL |     ($ty: ty) => (<$ty>::AssocItem)
    |                   +   +
 
-error[E0599]: no associated item named `AssocItem` found for slice `[u8]` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for slice `[u8]` in the current scope
   --> $DIR/bad-assoc-pat.rs:3:15
    |
 LL |         [u8]::AssocItem => {}
-   |               ^^^^^^^^^ associated item not found in `[u8]`
+   |               ^^^^^^^^^ associated function or constant not found in `[u8]`
 
-error[E0599]: no associated item named `AssocItem` found for tuple `(u8, u8)` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for tuple `(u8, u8)` in the current scope
   --> $DIR/bad-assoc-pat.rs:6:19
    |
 LL |         (u8, u8)::AssocItem => {}
-   |                   ^^^^^^^^^ associated item not found in `(u8, u8)`
+   |                   ^^^^^^^^^ associated function or constant not found in `(u8, u8)`
 
-error[E0599]: no associated item named `AssocItem` found for type `_` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for type `_` in the current scope
   --> $DIR/bad-assoc-pat.rs:9:12
    |
 LL |         _::AssocItem => {}
-   |            ^^^^^^^^^ associated item not found in `_`
+   |            ^^^^^^^^^ associated function or constant not found in `_`
 
-error[E0599]: no associated item named `AssocItem` found for tuple `(u8,)` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for tuple `(u8,)` in the current scope
   --> $DIR/bad-assoc-pat.rs:14:17
    |
 LL |         &(u8,)::AssocItem => {}
-   |                 ^^^^^^^^^ associated item not found in `(u8,)`
+   |                 ^^^^^^^^^ associated function or constant not found in `(u8,)`
 
-error[E0599]: no associated item named `AssocItem` found for type `u8` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for type `u8` in the current scope
   --> $DIR/bad-assoc-pat.rs:21:24
    |
 LL |     ($ty: ty) => ($ty::AssocItem)
-   |                        ^^^^^^^^^ associated item not found in `u8`
+   |                        ^^^^^^^^^ associated function or constant not found in `u8`
 ...
 LL |         pat!(u8) => {}
    |         -------- in this macro invocation
    |
    = note: this error originates in the macro `pat` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0599]: no associated item named `AssocItem` found for type `u8` in the current scope
+error[E0599]: no associated function or constant named `AssocItem` found for type `u8` in the current scope
   --> $DIR/bad-assoc-pat.rs:32:16
    |
 LL |         ty!()::AssocItem => {}
-   |                ^^^^^^^^^ associated item not found in `u8`
+   |                ^^^^^^^^^ associated function or constant not found in `u8`
 
 error: aborting due to 12 previous errors
 
diff --git a/tests/ui/enum/enum-discriminant-missing-variant.rs b/tests/ui/enum/enum-discriminant-missing-variant.rs
index 1bdbfb1fbcd4..45c2b3744434 100644
--- a/tests/ui/enum/enum-discriminant-missing-variant.rs
+++ b/tests/ui/enum/enum-discriminant-missing-variant.rs
@@ -1,6 +1,6 @@
 //! regression test for issue <https://github.com/rust-lang/rust/issues/23217>
 pub enum SomeEnum {
-    B = SomeEnum::A, //~ ERROR no variant or associated item named `A` found
+    B = SomeEnum::A, //~ ERROR no variant, associated function, or constant named `A` found
 }
 
 fn main() {}
diff --git a/tests/ui/enum/enum-discriminant-missing-variant.stderr b/tests/ui/enum/enum-discriminant-missing-variant.stderr
index ef98a93e86f6..653a87a5ebd8 100644
--- a/tests/ui/enum/enum-discriminant-missing-variant.stderr
+++ b/tests/ui/enum/enum-discriminant-missing-variant.stderr
@@ -1,10 +1,10 @@
-error[E0599]: no variant or associated item named `A` found for enum `SomeEnum` in the current scope
+error[E0599]: no variant, associated function, or constant named `A` found for enum `SomeEnum` in the current scope
   --> $DIR/enum-discriminant-missing-variant.rs:3:19
    |
 LL | pub enum SomeEnum {
-   | ----------------- variant or associated item `A` not found for this enum
+   | ----------------- variant, associated function, or constant `A` not found for this enum
 LL |     B = SomeEnum::A,
-   |                   ^ variant or associated item not found in `SomeEnum`
+   |                   ^ variant, associated function, or constant not found in `SomeEnum`
    |
 help: there is a variant with a similar name
    |
diff --git a/tests/ui/error-codes/E0599.stderr b/tests/ui/error-codes/E0599.stderr
index 5c1c71d39f71..724bce4502b7 100644
--- a/tests/ui/error-codes/E0599.stderr
+++ b/tests/ui/error-codes/E0599.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no associated item named `NotEvenReal` found for struct `Foo` in the current scope
+error[E0599]: no associated function or constant named `NotEvenReal` found for struct `Foo` in the current scope
   --> $DIR/E0599.rs:4:20
    |
 LL | struct Foo;
-   | ---------- associated item `NotEvenReal` not found for this struct
+   | ---------- associated function or constant `NotEvenReal` not found for this struct
 ...
 LL |     || if let Foo::NotEvenReal() = Foo {};
-   |                    ^^^^^^^^^^^ associated item not found in `Foo`
+   |                    ^^^^^^^^^^^ associated function or constant not found in `Foo`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/expr/issue-22933-2.rs b/tests/ui/expr/issue-22933-2.rs
index dfd84b9a79d4..3f593cae6dfc 100644
--- a/tests/ui/expr/issue-22933-2.rs
+++ b/tests/ui/expr/issue-22933-2.rs
@@ -2,7 +2,7 @@ enum Delicious {
     Pie      = 0x1,
     Apple    = 0x2,
     ApplePie = Delicious::Apple as isize | Delicious::PIE as isize,
-    //~^ ERROR no variant or associated item named `PIE` found
+    //~^ ERROR no variant, associated function, or constant named `PIE` found
 }
 
 fn main() {}
diff --git a/tests/ui/expr/issue-22933-2.stderr b/tests/ui/expr/issue-22933-2.stderr
index 07f095f643ee..0b7416b77c04 100644
--- a/tests/ui/expr/issue-22933-2.stderr
+++ b/tests/ui/expr/issue-22933-2.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no variant or associated item named `PIE` found for enum `Delicious` in the current scope
+error[E0599]: no variant, associated function, or constant named `PIE` found for enum `Delicious` in the current scope
   --> $DIR/issue-22933-2.rs:4:55
    |
 LL | enum Delicious {
-   | -------------- variant or associated item `PIE` not found for this enum
+   | -------------- variant, associated function, or constant `PIE` not found for this enum
 ...
 LL |     ApplePie = Delicious::Apple as isize | Delicious::PIE as isize,
-   |                                                       ^^^ variant or associated item not found in `Delicious`
+   |                                                       ^^^ variant, associated function, or constant not found in `Delicious`
    |
 help: there is a variant with a similar name
    |
diff --git a/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs b/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs
index d7dff329df1e..ec6dfb87f61b 100644
--- a/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs
+++ b/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs
@@ -29,5 +29,5 @@ fn new() -> P::Pointer<Self> {
 
 fn main() {
     let mut list = RcNode::<i32>::new();
-    //~^ ERROR the variant or associated item `new` exists for enum `Node<i32, RcFamily>`, but its trait bounds were not satisfied
+    //~^ ERROR the variant, associated function, or constant `new` exists for enum `Node<i32, RcFamily>`, but its trait bounds were not satisfied
 }
diff --git a/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.stderr b/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.stderr
index b31689dbf736..674e28829073 100644
--- a/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.stderr
+++ b/tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.stderr
@@ -15,14 +15,14 @@ help: consider relaxing the implicit `Sized` restriction
 LL |     type Pointer<T>: Deref<Target = T> + ?Sized;
    |                                        ++++++++
 
-error[E0599]: the variant or associated item `new` exists for enum `Node<i32, RcFamily>`, but its trait bounds were not satisfied
+error[E0599]: the variant, associated function, or constant `new` exists for enum `Node<i32, RcFamily>`, but its trait bounds were not satisfied
   --> $DIR/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs:31:35
    |
 LL | enum Node<T, P: PointerFamily> {
-   | ------------------------------ variant or associated item `new` not found for this enum
+   | ------------------------------ variant, associated function, or constant `new` not found for this enum
 ...
 LL |     let mut list = RcNode::<i32>::new();
-   |                                   ^^^ variant or associated item cannot be called on `Node<i32, RcFamily>` due to unsatisfied trait bounds
+   |                                   ^^^ variant, associated function, or constant cannot be called on `Node<i32, RcFamily>` due to unsatisfied trait bounds
    |
 note: trait bound `(dyn Deref<Target = Node<i32, RcFamily>> + 'static): Sized` was not satisfied
   --> $DIR/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.rs:23:29
diff --git a/tests/ui/impl-trait/issues/issue-62742.rs b/tests/ui/impl-trait/issues/issue-62742.rs
index c64278c2c5be..052917085abc 100644
--- a/tests/ui/impl-trait/issues/issue-62742.rs
+++ b/tests/ui/impl-trait/issues/issue-62742.rs
@@ -2,7 +2,7 @@
 
 fn a() {
     WrongImpl::foo(0i32);
-    //~^ ERROR the function or associated item `foo` exists for struct `SafeImpl<_, RawImpl<_>>`, but its trait bounds were not satisfied
+    //~^ ERROR the associated function or constant `foo` exists for struct `SafeImpl<_, RawImpl<_>>`, but its trait bounds were not satisfied
     //~| ERROR the trait bound `RawImpl<_>: Raw<_>` is not satisfied
 }
 
diff --git a/tests/ui/impl-trait/issues/issue-62742.stderr b/tests/ui/impl-trait/issues/issue-62742.stderr
index a1fedb8fb7b8..4899a96aece6 100644
--- a/tests/ui/impl-trait/issues/issue-62742.stderr
+++ b/tests/ui/impl-trait/issues/issue-62742.stderr
@@ -16,17 +16,17 @@ note: required by a bound in `SafeImpl`
 LL | pub struct SafeImpl<T: ?Sized, A: Raw<T>>(PhantomData<(A, T)>);
    |                                   ^^^^^^ required by this bound in `SafeImpl`
 
-error[E0599]: the function or associated item `foo` exists for struct `SafeImpl<_, RawImpl<_>>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `foo` exists for struct `SafeImpl<_, RawImpl<_>>`, but its trait bounds were not satisfied
   --> $DIR/issue-62742.rs:4:16
    |
 LL |     WrongImpl::foo(0i32);
-   |                ^^^ function or associated item cannot be called on `SafeImpl<_, RawImpl<_>>` due to unsatisfied trait bounds
+   |                ^^^ associated function or constant cannot be called on `SafeImpl<_, RawImpl<_>>` due to unsatisfied trait bounds
 ...
 LL | pub struct RawImpl<T>(PhantomData<T>);
    | --------------------- doesn't satisfy `RawImpl<_>: Raw<_>`
 ...
 LL | pub struct SafeImpl<T: ?Sized, A: Raw<T>>(PhantomData<(A, T)>);
-   | ----------------------------------------- function or associated item `foo` not found for this struct
+   | ----------------------------------------- associated function or constant `foo` not found for this struct
    |
 note: trait bound `RawImpl<_>: Raw<_>` was not satisfied
   --> $DIR/issue-62742.rs:35:20
@@ -60,17 +60,17 @@ note: required by a bound in `SafeImpl`
 LL | pub struct SafeImpl<T: ?Sized, A: Raw<T>>(PhantomData<(A, T)>);
    |                                   ^^^^^^ required by this bound in `SafeImpl`
 
-error[E0599]: the function or associated item `foo` exists for struct `SafeImpl<(), RawImpl<()>>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `foo` exists for struct `SafeImpl<(), RawImpl<()>>`, but its trait bounds were not satisfied
   --> $DIR/issue-62742.rs:10:22
    |
 LL |     WrongImpl::<()>::foo(0i32);
-   |                      ^^^ function or associated item cannot be called on `SafeImpl<(), RawImpl<()>>` due to unsatisfied trait bounds
+   |                      ^^^ associated function or constant cannot be called on `SafeImpl<(), RawImpl<()>>` due to unsatisfied trait bounds
 ...
 LL | pub struct RawImpl<T>(PhantomData<T>);
    | --------------------- doesn't satisfy `RawImpl<()>: Raw<()>`
 ...
 LL | pub struct SafeImpl<T: ?Sized, A: Raw<T>>(PhantomData<(A, T)>);
-   | ----------------------------------------- function or associated item `foo` not found for this struct
+   | ----------------------------------------- associated function or constant `foo` not found for this struct
    |
 note: trait bound `RawImpl<()>: Raw<()>` was not satisfied
   --> $DIR/issue-62742.rs:35:20
diff --git a/tests/ui/issues/issue-28586.rs b/tests/ui/issues/issue-28586.rs
index c543ef9b0e3d..9520e0e51a15 100644
--- a/tests/ui/issues/issue-28586.rs
+++ b/tests/ui/issues/issue-28586.rs
@@ -2,6 +2,6 @@
 
 pub trait Foo {}
 impl Foo for [u8; usize::BYTES] {}
-//~^ ERROR no associated item named `BYTES` found
+//~^ ERROR no associated function or constant named `BYTES` found
 
 fn main() { }
diff --git a/tests/ui/issues/issue-28586.stderr b/tests/ui/issues/issue-28586.stderr
index 33f40a341c8f..dda147954fac 100644
--- a/tests/ui/issues/issue-28586.stderr
+++ b/tests/ui/issues/issue-28586.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `BYTES` found for type `usize` in the current scope
+error[E0599]: no associated function or constant named `BYTES` found for type `usize` in the current scope
   --> $DIR/issue-28586.rs:4:26
    |
 LL | impl Foo for [u8; usize::BYTES] {}
-   |                          ^^^^^ associated item not found in `usize`
+   |                          ^^^^^ associated function or constant not found in `usize`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-28971.rs b/tests/ui/issues/issue-28971.rs
index 8e7a2fe0ef20..e6a504f52e0c 100644
--- a/tests/ui/issues/issue-28971.rs
+++ b/tests/ui/issues/issue-28971.rs
@@ -5,7 +5,7 @@ fn main(){
     foo(|| {
         match Foo::Bar(1) {
             Foo::Baz(..) => (),
-            //~^ ERROR no variant or associated item named `Baz` found
+            //~^ ERROR no variant, associated function, or constant named `Baz` found
             _ => (),
         }
     });
diff --git a/tests/ui/issues/issue-28971.stderr b/tests/ui/issues/issue-28971.stderr
index fd689a2b36ee..de3fff0a49e3 100644
--- a/tests/ui/issues/issue-28971.stderr
+++ b/tests/ui/issues/issue-28971.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no variant or associated item named `Baz` found for enum `Foo` in the current scope
+error[E0599]: no variant, associated function, or constant named `Baz` found for enum `Foo` in the current scope
   --> $DIR/issue-28971.rs:7:18
    |
 LL | enum Foo {
-   | -------- variant or associated item `Baz` not found for this enum
+   | -------- variant, associated function, or constant `Baz` not found for this enum
 ...
 LL |             Foo::Baz(..) => (),
-   |                  ^^^ variant or associated item not found in `Foo`
+   |                  ^^^ variant, associated function, or constant not found in `Foo`
    |
 help: there is a variant with a similar name
    |
diff --git a/tests/ui/issues/issue-30123.rs b/tests/ui/issues/issue-30123.rs
index f6511b5f290d..88fab44741f2 100644
--- a/tests/ui/issues/issue-30123.rs
+++ b/tests/ui/issues/issue-30123.rs
@@ -5,5 +5,5 @@
 
 fn main() {
     let ug = Graph::<i32, i32>::new_undirected();
-    //~^ ERROR no function or associated item named `new_undirected` found
+    //~^ ERROR no associated function or constant named `new_undirected` found
 }
diff --git a/tests/ui/issues/issue-30123.stderr b/tests/ui/issues/issue-30123.stderr
index db2e3dd78dd9..1e2747407d1d 100644
--- a/tests/ui/issues/issue-30123.stderr
+++ b/tests/ui/issues/issue-30123.stderr
@@ -1,15 +1,15 @@
-error[E0599]: no function or associated item named `new_undirected` found for struct `issue_30123_aux::Graph<i32, i32>` in the current scope
+error[E0599]: no associated function or constant named `new_undirected` found for struct `issue_30123_aux::Graph<i32, i32>` in the current scope
   --> $DIR/issue-30123.rs:7:33
    |
 LL |     let ug = Graph::<i32, i32>::new_undirected();
-   |                                 ^^^^^^^^^^^^^^ function or associated item not found in `issue_30123_aux::Graph<i32, i32>`
+   |                                 ^^^^^^^^^^^^^^ associated function or constant not found in `issue_30123_aux::Graph<i32, i32>`
    |
 note: if you're trying to build a new `issue_30123_aux::Graph<i32, i32>`, consider using `issue_30123_aux::Graph::<N, E>::new` which returns `issue_30123_aux::Graph<_, _>`
   --> $DIR/auxiliary/issue-30123-aux.rs:14:5
    |
 LL |     pub fn new() -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^
-   = note: the function or associated item was found for `issue_30123_aux::Graph<N, E, Undirected>`
+   = note: the associated function or constant was found for `issue_30123_aux::Graph<N, E, Undirected>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-42880.rs b/tests/ui/issues/issue-42880.rs
index b61ba80e27ab..36d15fc35b48 100644
--- a/tests/ui/issues/issue-42880.rs
+++ b/tests/ui/issues/issue-42880.rs
@@ -1,7 +1,7 @@
 type Value = String;
 
 fn main() {
-    let f = |&Value::String(_)| (); //~ ERROR no associated item named
+    let f = |&Value::String(_)| (); //~ ERROR no associated function or constant named
 
     let vec: Vec<Value> = Vec::new();
     vec.last().map(f);
diff --git a/tests/ui/issues/issue-42880.stderr b/tests/ui/issues/issue-42880.stderr
index f174f42b2398..8743b1cfdef7 100644
--- a/tests/ui/issues/issue-42880.stderr
+++ b/tests/ui/issues/issue-42880.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `String` found for struct `String` in the current scope
+error[E0599]: no associated function or constant named `String` found for struct `String` in the current scope
   --> $DIR/issue-42880.rs:4:22
    |
 LL |     let f = |&Value::String(_)| ();
-   |                      ^^^^^^ associated item not found in `String`
+   |                      ^^^^^^ associated function or constant not found in `String`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/let-else/let-else-no-double-error.rs b/tests/ui/let-else/let-else-no-double-error.rs
index 91fcc5d7e91e..7b695595483f 100644
--- a/tests/ui/let-else/let-else-no-double-error.rs
+++ b/tests/ui/let-else/let-else-no-double-error.rs
@@ -8,5 +8,5 @@
 
 fn main() {
     let foo = 22;
-    let u32::XXX = foo else { return }; //~ ERROR: no associated item named `XXX` found for type `u32` in the current scope [E0599]
+    let u32::XXX = foo else { return }; //~ ERROR: no associated function or constant named `XXX` found for type `u32` in the current scope [E0599]
 }
diff --git a/tests/ui/let-else/let-else-no-double-error.stderr b/tests/ui/let-else/let-else-no-double-error.stderr
index 05668a23138e..4fd6a14ca911 100644
--- a/tests/ui/let-else/let-else-no-double-error.stderr
+++ b/tests/ui/let-else/let-else-no-double-error.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `XXX` found for type `u32` in the current scope
+error[E0599]: no associated function or constant named `XXX` found for type `u32` in the current scope
   --> $DIR/let-else-no-double-error.rs:11:14
    |
 LL |     let u32::XXX = foo else { return };
-   |              ^^^ associated item not found in `u32`
+   |              ^^^ associated function or constant not found in `u32`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/methods/ident-from-macro-expansion.rs b/tests/ui/methods/ident-from-macro-expansion.rs
index 38d2fee0e53c..2bdf5fc17b14 100644
--- a/tests/ui/methods/ident-from-macro-expansion.rs
+++ b/tests/ui/methods/ident-from-macro-expansion.rs
@@ -14,5 +14,5 @@ fn main() {
     dot!(hello);
     //~^ ERROR no method named `hello` found for unit type `()` in the current scope
     dispatch!(hello);
-    //~^ ERROR no function or associated item named `hello` found for unit type `()` in the current scope
+    //~^ ERROR no associated function or constant named `hello` found for unit type `()` in the current scope
 }
diff --git a/tests/ui/methods/ident-from-macro-expansion.stderr b/tests/ui/methods/ident-from-macro-expansion.stderr
index b596ce29f6fe..5fc8be865c4a 100644
--- a/tests/ui/methods/ident-from-macro-expansion.stderr
+++ b/tests/ui/methods/ident-from-macro-expansion.stderr
@@ -7,14 +7,14 @@ LL |         ().$id();
 LL |     dot!(hello);
    |          ^^^^^ method not found in `()`
 
-error[E0599]: no function or associated item named `hello` found for unit type `()` in the current scope
+error[E0599]: no associated function or constant named `hello` found for unit type `()` in the current scope
   --> $DIR/ident-from-macro-expansion.rs:16:15
    |
 LL |         <()>::$id();
    |               --- due to this macro variable
 ...
 LL |     dispatch!(hello);
-   |               ^^^^^ function or associated item not found in `()`
+   |               ^^^^^ associated function or constant not found in `()`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/methods/issue-7950.rs b/tests/ui/methods/issue-7950.rs
index d3dcb3380bbc..d87618a15ef3 100644
--- a/tests/ui/methods/issue-7950.rs
+++ b/tests/ui/methods/issue-7950.rs
@@ -4,5 +4,5 @@
 
 fn main() {
     Foo::bar();
-    //~^ ERROR no function or associated item named `bar` found for struct `Foo`
+    //~^ ERROR no associated function or constant named `bar` found for struct `Foo`
 }
diff --git a/tests/ui/methods/issue-7950.stderr b/tests/ui/methods/issue-7950.stderr
index 80504c070a3c..84e6dfee7757 100644
--- a/tests/ui/methods/issue-7950.stderr
+++ b/tests/ui/methods/issue-7950.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no function or associated item named `bar` found for struct `Foo` in the current scope
+error[E0599]: no associated function or constant named `bar` found for struct `Foo` in the current scope
   --> $DIR/issue-7950.rs:6:10
    |
 LL | struct Foo;
-   | ---------- function or associated item `bar` not found for this struct
+   | ---------- associated function or constant `bar` not found for this struct
 ...
 LL |     Foo::bar();
-   |          ^^^ function or associated item not found in `Foo`
+   |          ^^^ associated function or constant not found in `Foo`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/methods/missing-method-on-type-parameter.stderr b/tests/ui/methods/missing-method-on-type-parameter.stderr
index 0b58fbfa4af1..0289904effa3 100644
--- a/tests/ui/methods/missing-method-on-type-parameter.stderr
+++ b/tests/ui/methods/missing-method-on-type-parameter.stderr
@@ -1,10 +1,10 @@
-error[E0599]: no function or associated item named `try_from` found for type parameter `T` in the current scope
+error[E0599]: no associated function or constant named `try_from` found for type parameter `T` in the current scope
   --> $DIR/missing-method-on-type-parameter.rs:4:8
    |
 LL | fn x<T: Copy>() {
-   |      - function or associated item `try_from` not found for this type parameter
+   |      - associated function or constant `try_from` not found for this type parameter
 LL |     T::try_from();
-   |        ^^^^^^^^ function or associated item not found in `T`
+   |        ^^^^^^^^ associated function or constant not found in `T`
    |
    = help: items from traits can only be used if the trait is in scope
 help: there is an associated function `from` with a similar name
diff --git a/tests/ui/methods/receiver-equality.rs b/tests/ui/methods/receiver-equality.rs
index 891435a425eb..d409edc864af 100644
--- a/tests/ui/methods/receiver-equality.rs
+++ b/tests/ui/methods/receiver-equality.rs
@@ -10,7 +10,7 @@ fn method(self) {
 
 fn foo(y: B<fn(&'static ())>) {
     B::<for<'a> fn(&'a ())>::method(y);
-    //~^ ERROR no function or associated item named `method` found
+    //~^ ERROR no associated function or constant named `method` found
 }
 
 fn main() {}
diff --git a/tests/ui/methods/receiver-equality.stderr b/tests/ui/methods/receiver-equality.stderr
index bf149cc2eb4d..9dd4d71c367b 100644
--- a/tests/ui/methods/receiver-equality.stderr
+++ b/tests/ui/methods/receiver-equality.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no function or associated item named `method` found for struct `B<for<'a> fn(&'a ())>` in the current scope
+error[E0599]: no associated function or constant named `method` found for struct `B<for<'a> fn(&'a ())>` in the current scope
   --> $DIR/receiver-equality.rs:12:30
    |
 LL | struct B<T>(T);
-   | ----------- function or associated item `method` not found for this struct
+   | ----------- associated function or constant `method` not found for this struct
 ...
 LL |     B::<for<'a> fn(&'a ())>::method(y);
-   |                              ^^^^^^ function or associated item not found in `B<for<'a> fn(&'a ())>`
+   |                              ^^^^^^ associated function or constant not found in `B<for<'a> fn(&'a ())>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-57362-2.rs b/tests/ui/nll/issue-57362-2.rs
index 664cdf89a388..1f723be6794b 100644
--- a/tests/ui/nll/issue-57362-2.rs
+++ b/tests/ui/nll/issue-57362-2.rs
@@ -21,7 +21,7 @@ fn make_g() -> Self::G {
 // FIXME(@compiler-errors): This error message is less than helpful.
 fn g() {
     let x = <fn (&())>::make_g();
-    //~^ ERROR no function or associated item named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
+    //~^ ERROR no associated function or constant named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
 }
 
 fn main() {}
diff --git a/tests/ui/nll/issue-57362-2.stderr b/tests/ui/nll/issue-57362-2.stderr
index 8a1a4d6b22c1..1b962b16bdc8 100644
--- a/tests/ui/nll/issue-57362-2.stderr
+++ b/tests/ui/nll/issue-57362-2.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
+error[E0599]: no associated function or constant named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
   --> $DIR/issue-57362-2.rs:23:25
    |
 LL |     let x = <fn (&())>::make_g();
-   |                         ^^^^^^ function or associated item not found in `for<'a> fn(&'a ())`
+   |                         ^^^^^^ associated function or constant not found in `for<'a> fn(&'a ())`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `X` defines an item `make_g`, perhaps you need to implement it
diff --git a/tests/ui/nll/issue-57642-higher-ranked-subtype.rs b/tests/ui/nll/issue-57642-higher-ranked-subtype.rs
index 69187cab3422..059a2beb92f4 100644
--- a/tests/ui/nll/issue-57642-higher-ranked-subtype.rs
+++ b/tests/ui/nll/issue-57642-higher-ranked-subtype.rs
@@ -29,11 +29,12 @@ fn make_f() -> Self::F {
 
 fn higher_ranked_region_has_lost_its_binder() {
     let x = <fn (&())>::make_g();
-    //~^ ERROR no function or associated item named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
+    //~^ ERROR no associated function or constant named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
 }
 
 fn magical() {
-    let x = <fn (&())>::make_f(); //~ ERROR no function
+    let x = <fn (&())>::make_f();
+    //~^ ERROR no associated function or constant named `make_f` found for fn pointer `for<'a> fn(&'a ())` in the current scope
 }
 
 fn main() {}
diff --git a/tests/ui/nll/issue-57642-higher-ranked-subtype.stderr b/tests/ui/nll/issue-57642-higher-ranked-subtype.stderr
index 27a887e86004..0a56d1bc7203 100644
--- a/tests/ui/nll/issue-57642-higher-ranked-subtype.stderr
+++ b/tests/ui/nll/issue-57642-higher-ranked-subtype.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
+error[E0599]: no associated function or constant named `make_g` found for fn pointer `for<'a> fn(&'a ())` in the current scope
   --> $DIR/issue-57642-higher-ranked-subtype.rs:31:25
    |
 LL |     let x = <fn (&())>::make_g();
-   |                         ^^^^^^ function or associated item not found in `for<'a> fn(&'a ())`
+   |                         ^^^^^^ associated function or constant not found in `for<'a> fn(&'a ())`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `X` defines an item `make_g`, perhaps you need to implement it
@@ -11,11 +11,11 @@ note: `X` defines an item `make_g`, perhaps you need to implement it
 LL | trait X {
    | ^^^^^^^
 
-error[E0599]: no function or associated item named `make_f` found for fn pointer `for<'a> fn(&'a ())` in the current scope
+error[E0599]: no associated function or constant named `make_f` found for fn pointer `for<'a> fn(&'a ())` in the current scope
   --> $DIR/issue-57642-higher-ranked-subtype.rs:36:25
    |
 LL |     let x = <fn (&())>::make_f();
-   |                         ^^^^^^ function or associated item not found in `for<'a> fn(&'a ())`
+   |                         ^^^^^^ associated function or constant not found in `for<'a> fn(&'a ())`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `Y` defines an item `make_f`, perhaps you need to implement it
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-124423.rs b/tests/ui/parallel-rustc/ty-variance-issue-124423.rs
index 8d7f29f77641..501b0fca7bf5 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-124423.rs
+++ b/tests/ui/parallel-rustc/ty-variance-issue-124423.rs
@@ -43,7 +43,7 @@ fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
 //~| ERROR use of undeclared lifetime name `'a`
 //~| ERROR use of undeclared lifetime name `'a`
 //~| ERROR at least one trait is required for an object type
-//~| ERROR no function or associated item named `u32` found for struct `Box<_, _>` in the current scope
+//~| ERROR no associated function or constant named `u32` found for struct `Box<_, _>` in the current scope
 
 fn elided4(_: &impl Copy + 'a) ->  new  { x(x) }
 //~^ ERROR ambiguous `+` in a type
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr b/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
index 631f43eea906..2246a22eb60d 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
+++ b/tests/ui/parallel-rustc/ty-variance-issue-124423.stderr
@@ -243,18 +243,18 @@ error[E0425]: cannot find type `new` in this scope
 LL | fn elided4(_: &impl Copy + 'a) ->  new  { x(x) }
    |                                    ^^^ not found in this scope
 
-error[E0224]: at least one trait is required for an object type
-  --> $DIR/ty-variance-issue-124423.rs:55:40
-   |
-LL | impl<'a> LifetimeTrait<'a> for &'a Box<dyn 'a> {}
-   |                                        ^^^^^^
-
 error[E0224]: at least one trait is required for an object type
   --> $DIR/ty-variance-issue-124423.rs:41:40
    |
 LL | fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
    |                                        ^^^^^^
 
+error[E0224]: at least one trait is required for an object type
+  --> $DIR/ty-variance-issue-124423.rs:55:40
+   |
+LL | impl<'a> LifetimeTrait<'a> for &'a Box<dyn 'a> {}
+   |                                        ^^^^^^
+
 error[E0224]: at least one trait is required for an object type
   --> $DIR/ty-variance-issue-124423.rs:35:39
    |
@@ -267,11 +267,11 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL | fn elided(_: &impl Copy + 'a) -> _ { x }
    |                                  ^ not allowed in type signatures
 
-error[E0599]: no function or associated item named `u32` found for struct `Box<_, _>` in the current scope
+error[E0599]: no associated function or constant named `u32` found for struct `Box<_, _>` in the current scope
   --> $DIR/ty-variance-issue-124423.rs:41:55
    |
 LL | fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
-   |                                                       ^^^ function or associated item not found in `Box<_, _>`
+   |                                                       ^^^ associated function or constant not found in `Box<_, _>`
    |
 note: if you're trying to build a new `Box<_, _>` consider using one of the following associated functions:
       Box::<T>::new
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-127971.rs b/tests/ui/parallel-rustc/ty-variance-issue-127971.rs
index a17916843e70..db2dc8e4c856 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-127971.rs
+++ b/tests/ui/parallel-rustc/ty-variance-issue-127971.rs
@@ -20,6 +20,6 @@ fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
 //~| ERROR use of undeclared lifetime name `'a`
 //~| ERROR use of undeclared lifetime name `'a`
 //~| ERROR at least one trait is required for an object type
-//~| ERROR no function or associated item named `u32` found for struct `Box<_, _>` in the current scope
+//~| ERROR no associated function or constant named `u32` found for struct `Box<_, _>` in the current scope
 
 fn main() {}
diff --git a/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr b/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
index dce4acfc4ca7..47286d90d681 100644
--- a/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
+++ b/tests/ui/parallel-rustc/ty-variance-issue-127971.stderr
@@ -93,11 +93,11 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL | fn elided(_: &impl Copy + 'a) -> _ { x }
    |                                  ^ not allowed in type signatures
 
-error[E0599]: no function or associated item named `u32` found for struct `Box<_, _>` in the current scope
+error[E0599]: no associated function or constant named `u32` found for struct `Box<_, _>` in the current scope
   --> $DIR/ty-variance-issue-127971.rs:18:55
    |
 LL | fn x<'b>(_: &'a impl Copy + 'a) -> Box<dyn 'b> { Box::u32(x) }
-   |                                                       ^^^ function or associated item not found in `Box<_, _>`
+   |                                                       ^^^ associated function or constant not found in `Box<_, _>`
    |
 note: if you're trying to build a new `Box<_, _>` consider using one of the following associated functions:
       Box::<T>::new
diff --git a/tests/ui/parser/emoji-identifiers.rs b/tests/ui/parser/emoji-identifiers.rs
index b50c046bcb20..cbd2e54c5522 100644
--- a/tests/ui/parser/emoji-identifiers.rs
+++ b/tests/ui/parser/emoji-identifiers.rs
@@ -6,7 +6,7 @@ fn full_of_✨() -> 👀 { //~ ERROR identifiers cannot contain emoji
     }
 }
 fn i_like_to_😅_a_lot() -> 👀 { //~ ERROR identifiers cannot contain emoji
-    👀::full_of✨() //~ ERROR no function or associated item named `full_of✨` found for struct `👀`
+    👀::full_of✨() //~ ERROR no associated function or constant named `full_of✨` found for struct `👀`
     //~^ ERROR identifiers cannot contain emoji
 }
 fn main() {
diff --git a/tests/ui/parser/emoji-identifiers.stderr b/tests/ui/parser/emoji-identifiers.stderr
index 016ed0401caf..a6532f9c51b0 100644
--- a/tests/ui/parser/emoji-identifiers.stderr
+++ b/tests/ui/parser/emoji-identifiers.stderr
@@ -65,14 +65,14 @@ LL |     let 🦀 = 1;
 LL |     dbg!(🦀);
    |          ^^
 
-error[E0599]: no function or associated item named `full_of✨` found for struct `👀` in the current scope
+error[E0599]: no associated function or constant named `full_of✨` found for struct `👀` in the current scope
   --> $DIR/emoji-identifiers.rs:9:8
    |
 LL | struct 👀;
-   | --------- function or associated item `full_of✨` not found for this struct
+   | --------- associated function or constant `full_of✨` not found for this struct
 ...
 LL |     👀::full_of✨()
-   |         ^^^^^^^^^ function or associated item not found in `👀`
+   |         ^^^^^^^^^ associated function or constant not found in `👀`
    |
 note: if you're trying to build a new `👀`, consider using `👀::full_of_✨` which returns `👀`
   --> $DIR/emoji-identifiers.rs:4:5
diff --git a/tests/ui/pattern/pattern-match-invalid-variant.stderr b/tests/ui/pattern/pattern-match-invalid-variant.stderr
index 08a99f696f6d..94373afeb2e6 100644
--- a/tests/ui/pattern/pattern-match-invalid-variant.stderr
+++ b/tests/ui/pattern/pattern-match-invalid-variant.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no variant or associated item named `Hsl` found for enum `Color` in the current scope
+error[E0599]: no variant, associated function, or constant named `Hsl` found for enum `Color` in the current scope
   --> $DIR/pattern-match-invalid-variant.rs:14:16
    |
 LL | enum Color {
-   | ---------- variant or associated item `Hsl` not found for this enum
+   | ---------- variant, associated function, or constant `Hsl` not found for this enum
 ...
 LL |         Color::Hsl(h, s, l) => {
-   |                ^^^ variant or associated item not found in `Color`
+   |                ^^^ variant, associated function, or constant not found in `Color`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/privacy/ufc-method-call.different_name.stderr b/tests/ui/privacy/ufc-method-call.different_name.stderr
index c65fe51ca240..5d722c62255f 100644
--- a/tests/ui/privacy/ufc-method-call.different_name.stderr
+++ b/tests/ui/privacy/ufc-method-call.different_name.stderr
@@ -1,13 +1,13 @@
-error[E0599]: no function or associated item named `foo` found for struct `Foo<B>` in the current scope
+error[E0599]: no associated function or constant named `foo` found for struct `Foo<B>` in the current scope
   --> $DIR/ufc-method-call.rs:27:27
    |
 LL |     pub struct Foo<T>(T);
-   |     ----------------- function or associated item `foo` not found for this struct
+   |     ----------------- associated function or constant `foo` not found for this struct
 ...
 LL |     test::Foo::<test::B>::foo();
-   |                           ^^^ function or associated item not found in `Foo<B>`
+   |                           ^^^ associated function or constant not found in `Foo<B>`
    |
-   = note: the function or associated item was found for `Foo<A>`
+   = note: the associated function or constant was found for `Foo<A>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/privacy/ufc-method-call.rs b/tests/ui/privacy/ufc-method-call.rs
index 525d9a9eee90..87efbc79ea24 100644
--- a/tests/ui/privacy/ufc-method-call.rs
+++ b/tests/ui/privacy/ufc-method-call.rs
@@ -26,5 +26,5 @@ fn bar() {}
 fn main() {
     test::Foo::<test::B>::foo();
     //[same_name]~^ ERROR associated function `foo` is private
-    //[different_name]~^^ ERROR no function or associated item named `foo` found for struct `Foo<B>`
+    //[different_name]~^^ ERROR no associated function or constant named `foo` found for struct `Foo<B>`
 }
diff --git a/tests/ui/resolve/empty-struct-braces-expr.rs b/tests/ui/resolve/empty-struct-braces-expr.rs
index c10f76b92196..f6a174290e34 100644
--- a/tests/ui/resolve/empty-struct-braces-expr.rs
+++ b/tests/ui/resolve/empty-struct-braces-expr.rs
@@ -22,8 +22,8 @@ fn main() {
     let xe1 = XEmpty1; //~ ERROR expected value, found struct `XEmpty1`
     let xe1 = XEmpty1();
     //~^ ERROR expected function, tuple struct or tuple variant, found struct `XEmpty1`
-    let xe3 = XE::Empty3; //~ ERROR no variant or associated item named `Empty3` found for enum
-    let xe3 = XE::Empty3(); //~ ERROR no variant or associated item named `Empty3` found for enum
+    let xe3 = XE::Empty3; //~ ERROR no variant, associated function, or constant named `Empty3` found for enum
+    let xe3 = XE::Empty3(); //~ ERROR no variant, associated function, or constant named `Empty3` found for enum
 
     XE::Empty1 {}; //~ ERROR no variant named `Empty1` found for enum `empty_struct::XE`
 }
diff --git a/tests/ui/resolve/empty-struct-braces-expr.stderr b/tests/ui/resolve/empty-struct-braces-expr.stderr
index a176107a06e2..f496708512a4 100644
--- a/tests/ui/resolve/empty-struct-braces-expr.stderr
+++ b/tests/ui/resolve/empty-struct-braces-expr.stderr
@@ -117,22 +117,22 @@ LL -     let xe1 = XEmpty1();
 LL +     let xe1 = XEmpty2();
    |
 
-error[E0599]: no variant or associated item named `Empty3` found for enum `empty_struct::XE` in the current scope
+error[E0599]: no variant, associated function, or constant named `Empty3` found for enum `empty_struct::XE` in the current scope
   --> $DIR/empty-struct-braces-expr.rs:25:19
    |
 LL |     let xe3 = XE::Empty3;
-   |                   ^^^^^^ variant or associated item not found in `empty_struct::XE`
+   |                   ^^^^^^ variant, associated function, or constant not found in `empty_struct::XE`
    |
 help: there is a variant with a similar name
    |
 LL |     let xe3 = XE::XEmpty3;
    |                   +
 
-error[E0599]: no variant or associated item named `Empty3` found for enum `empty_struct::XE` in the current scope
+error[E0599]: no variant, associated function, or constant named `Empty3` found for enum `empty_struct::XE` in the current scope
   --> $DIR/empty-struct-braces-expr.rs:26:19
    |
 LL |     let xe3 = XE::Empty3();
-   |                   ^^^^^^ variant or associated item not found in `empty_struct::XE`
+   |                   ^^^^^^ variant, associated function, or constant not found in `empty_struct::XE`
    |
 help: there is a variant with a similar name
    |
diff --git a/tests/ui/resolve/issue-82865.rs b/tests/ui/resolve/issue-82865.rs
index 545ca63e0b82..230725155d8a 100644
--- a/tests/ui/resolve/issue-82865.rs
+++ b/tests/ui/resolve/issue-82865.rs
@@ -6,7 +6,7 @@
 use x::y::z; //~ ERROR: cannot find module or crate `x`
 
 macro mac () {
-    Box::z //~ ERROR: no function or associated item
+    Box::z //~ ERROR: no associated function or constant
 }
 
 fn main() {
diff --git a/tests/ui/resolve/issue-82865.stderr b/tests/ui/resolve/issue-82865.stderr
index 90059ad5a965..198f7f8e32aa 100644
--- a/tests/ui/resolve/issue-82865.stderr
+++ b/tests/ui/resolve/issue-82865.stderr
@@ -9,11 +9,11 @@ help: you might be missing a crate named `x`, add it to your project and import
 LL + extern crate x;
    |
 
-error[E0599]: no function or associated item named `z` found for struct `Box<_, _>` in the current scope
+error[E0599]: no associated function or constant named `z` found for struct `Box<_, _>` in the current scope
   --> $DIR/issue-82865.rs:9:10
    |
 LL |     Box::z
-   |          ^ function or associated item not found in `Box<_, _>`
+   |          ^ associated function or constant not found in `Box<_, _>`
 ...
 LL |     mac!();
    |     ------ in this macro invocation
diff --git a/tests/ui/resolve/missing-associated-items.rs b/tests/ui/resolve/missing-associated-items.rs
index 72d6cbb3f149..1308ce5f592c 100644
--- a/tests/ui/resolve/missing-associated-items.rs
+++ b/tests/ui/resolve/missing-associated-items.rs
@@ -14,8 +14,8 @@ fn use_token(token: &Token) {
 }
 
 fn main() {
-    use_token(&Token::Homura); //~ ERROR no variant or associated item named `Homura`
-    Struct::method(); //~ ERROR no function or associated item named `method` found
-    Struct::method; //~ ERROR no function or associated item named `method` found
-    Struct::Assoc; //~ ERROR no associated item named `Assoc` found
+    use_token(&Token::Homura); //~ ERROR no variant, associated function, or constant named `Homura`
+    Struct::method(); //~ ERROR no associated function or constant named `method` found
+    Struct::method; //~ ERROR no associated function or constant named `method` found
+    Struct::Assoc; //~ ERROR no associated function or constant named `Assoc` found
 }
diff --git a/tests/ui/resolve/missing-associated-items.stderr b/tests/ui/resolve/missing-associated-items.stderr
index d27a3a644aee..3bc63ded6bc8 100644
--- a/tests/ui/resolve/missing-associated-items.stderr
+++ b/tests/ui/resolve/missing-associated-items.stderr
@@ -1,38 +1,38 @@
-error[E0599]: no variant or associated item named `Homura` found for enum `Token` in the current scope
+error[E0599]: no variant, associated function, or constant named `Homura` found for enum `Token` in the current scope
   --> $DIR/missing-associated-items.rs:17:23
    |
 LL | enum Token {
-   | ---------- variant or associated item `Homura` not found for this enum
+   | ---------- variant, associated function, or constant `Homura` not found for this enum
 ...
 LL |     use_token(&Token::Homura);
-   |                       ^^^^^^ variant or associated item not found in `Token`
+   |                       ^^^^^^ variant, associated function, or constant not found in `Token`
 
-error[E0599]: no function or associated item named `method` found for struct `Struct` in the current scope
+error[E0599]: no associated function or constant named `method` found for struct `Struct` in the current scope
   --> $DIR/missing-associated-items.rs:18:13
    |
 LL | struct Struct {
-   | ------------- function or associated item `method` not found for this struct
+   | ------------- associated function or constant `method` not found for this struct
 ...
 LL |     Struct::method();
-   |             ^^^^^^ function or associated item not found in `Struct`
+   |             ^^^^^^ associated function or constant not found in `Struct`
 
-error[E0599]: no function or associated item named `method` found for struct `Struct` in the current scope
+error[E0599]: no associated function or constant named `method` found for struct `Struct` in the current scope
   --> $DIR/missing-associated-items.rs:19:13
    |
 LL | struct Struct {
-   | ------------- function or associated item `method` not found for this struct
+   | ------------- associated function or constant `method` not found for this struct
 ...
 LL |     Struct::method;
-   |             ^^^^^^ function or associated item not found in `Struct`
+   |             ^^^^^^ associated function or constant not found in `Struct`
 
-error[E0599]: no associated item named `Assoc` found for struct `Struct` in the current scope
+error[E0599]: no associated function or constant named `Assoc` found for struct `Struct` in the current scope
   --> $DIR/missing-associated-items.rs:20:13
    |
 LL | struct Struct {
-   | ------------- associated item `Assoc` not found for this struct
+   | ------------- associated function or constant `Assoc` not found for this struct
 ...
 LL |     Struct::Assoc;
-   |             ^^^^^ associated item not found in `Struct`
+   |             ^^^^^ associated function or constant not found in `Struct`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/resolve/suggestions/suggest-builder-fn.rs b/tests/ui/resolve/suggestions/suggest-builder-fn.rs
index 959675ef2c99..4552ed5382e9 100644
--- a/tests/ui/resolve/suggestions/suggest-builder-fn.rs
+++ b/tests/ui/resolve/suggestions/suggest-builder-fn.rs
@@ -50,15 +50,15 @@ fn build_private() -> Self {
 fn main() {
    // `new` not found on `TcpStream` and `connect` should be suggested
    let _stream = TcpStream::new();
-   //~^ ERROR no function or associated item named `new` found
+   //~^ ERROR no associated function or constant named `new` found
 
     // Although `new` is found on `<impl Foo<T>>` it should not be
     // suggested because `u8` does not meet the `T: SomeTrait` constraint
     let _foo = Foo::<u8>::new();
-   //~^ ERROR the function or associated item `new` exists for struct `Foo<u8>`, but its trait bounds were not satisfied
+   //~^ ERROR the associated function or constant `new` exists for struct `Foo<u8>`, but its trait bounds were not satisfied
 
    // Should suggest only `<impl Bar>::build()` and `SomeMod::<impl Bar>::build_public()`.
    // Other methods should not suggested because they are private or are not a builder
     let _bar = Bar::new();
-   //~^ ERROR no function or associated item named `new` found
+   //~^ ERROR no associated function or constant named `new` found
 }
diff --git a/tests/ui/resolve/suggestions/suggest-builder-fn.stderr b/tests/ui/resolve/suggestions/suggest-builder-fn.stderr
index 9c5eed35ccff..1eabb8effac9 100644
--- a/tests/ui/resolve/suggestions/suggest-builder-fn.stderr
+++ b/tests/ui/resolve/suggestions/suggest-builder-fn.stderr
@@ -1,22 +1,22 @@
-error[E0599]: no function or associated item named `new` found for struct `TcpStream` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `TcpStream` in the current scope
   --> $DIR/suggest-builder-fn.rs:52:29
    |
 LL |    let _stream = TcpStream::new();
-   |                             ^^^ function or associated item not found in `TcpStream`
+   |                             ^^^ associated function or constant not found in `TcpStream`
    |
 note: if you're trying to build a new `TcpStream` consider using one of the following associated functions:
       TcpStream::connect
       TcpStream::connect_timeout
   --> $SRC_DIR/std/src/net/tcp.rs:LL:COL
 
-error[E0599]: the function or associated item `new` exists for struct `Foo<u8>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `new` exists for struct `Foo<u8>`, but its trait bounds were not satisfied
   --> $DIR/suggest-builder-fn.rs:57:27
    |
 LL | struct Foo<T> {
-   | ------------- function or associated item `new` not found for this struct
+   | ------------- associated function or constant `new` not found for this struct
 ...
 LL |     let _foo = Foo::<u8>::new();
-   |                           ^^^ function or associated item cannot be called on `Foo<u8>` due to unsatisfied trait bounds
+   |                           ^^^ associated function or constant cannot be called on `Foo<u8>` due to unsatisfied trait bounds
    |
 note: trait bound `u8: SomeTrait` was not satisfied
   --> $DIR/suggest-builder-fn.rs:12:9
@@ -26,14 +26,14 @@ LL | impl<T: SomeTrait + Default> Foo<T> {
    |         |
    |         unsatisfied trait bound introduced here
 
-error[E0599]: no function or associated item named `new` found for struct `Bar` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `Bar` in the current scope
   --> $DIR/suggest-builder-fn.rs:62:21
    |
 LL | struct Bar;
-   | ---------- function or associated item `new` not found for this struct
+   | ---------- associated function or constant `new` not found for this struct
 ...
 LL |     let _bar = Bar::new();
-   |                     ^^^ function or associated item not found in `Bar`
+   |                     ^^^ associated function or constant not found in `Bar`
    |
 note: if you're trying to build a new `Bar` consider using one of the following associated functions:
       Bar::build
diff --git a/tests/ui/resolve/typo-suggestion-mistyped-in-path.rs b/tests/ui/resolve/typo-suggestion-mistyped-in-path.rs
index 706564dc9b21..dfbb8f1e0a51 100644
--- a/tests/ui/resolve/typo-suggestion-mistyped-in-path.rs
+++ b/tests/ui/resolve/typo-suggestion-mistyped-in-path.rs
@@ -1,5 +1,5 @@
 struct Struct;
-//~^ NOTE function or associated item `fob` not found for this struct
+//~^ NOTE associated function or constant `fob` not found for this struct
 
 impl Struct {
     fn foo() { }
@@ -21,8 +21,8 @@ trait Trait {
 
 fn main() {
     Struct::fob();
-    //~^ ERROR no function or associated item named `fob` found for struct `Struct` in the current scope
-    //~| NOTE function or associated item not found in `Struct`
+    //~^ ERROR no associated function or constant named `fob` found for struct `Struct` in the current scope
+    //~| NOTE associated function or constant not found in `Struct`
 
     Struc::foo();
     //~^ ERROR cannot find type `Struc`
diff --git a/tests/ui/resolve/typo-suggestion-mistyped-in-path.stderr b/tests/ui/resolve/typo-suggestion-mistyped-in-path.stderr
index b1afa703eb03..98412559d666 100644
--- a/tests/ui/resolve/typo-suggestion-mistyped-in-path.stderr
+++ b/tests/ui/resolve/typo-suggestion-mistyped-in-path.stderr
@@ -9,14 +9,14 @@ help: a struct with a similar name exists
 LL |     module::Struct::foo();
    |                  +
 
-error[E0599]: no function or associated item named `fob` found for struct `Struct` in the current scope
+error[E0599]: no associated function or constant named `fob` found for struct `Struct` in the current scope
   --> $DIR/typo-suggestion-mistyped-in-path.rs:23:13
    |
 LL | struct Struct;
-   | ------------- function or associated item `fob` not found for this struct
+   | ------------- associated function or constant `fob` not found for this struct
 ...
 LL |     Struct::fob();
-   |             ^^^ function or associated item not found in `Struct`
+   |             ^^^ associated function or constant not found in `Struct`
    |
 help: there is an associated function `foo` with a similar name
    |
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.rs b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.rs
index 46fdfd678cc6..c54f08e9256f 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.rs
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.rs
@@ -5,7 +5,7 @@
 fn main() {
     let foo = 22;
     match foo {
-        u32::XXX => { } //~ ERROR no associated item named
+        u32::XXX => { } //~ ERROR no associated function or constant named
         _ => { }
     }
 }
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
index 6000507c5897..51b08cde6eb0 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no associated item named `XXX` found for type `u32` in the current scope
+error[E0599]: no associated function or constant named `XXX` found for type `u32` in the current scope
   --> $DIR/no-double-error.rs:8:14
    |
 LL |         u32::XXX => { }
-   |              ^^^ associated item not found in `u32`
+   |              ^^^ associated function or constant not found in `u32`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/trait-import-suggestions.rs b/tests/ui/rust-2018/trait-import-suggestions.rs
index 5a5eeacedfcc..dce01de8c894 100644
--- a/tests/ui/rust-2018/trait-import-suggestions.rs
+++ b/tests/ui/rust-2018/trait-import-suggestions.rs
@@ -27,5 +27,5 @@ fn main() {
     let x: u32 = 22;
     x.bar(); //~ ERROR no method named `bar`
     x.baz(); //~ ERROR no method named `baz`
-    let y = u32::from_str("33"); //~ ERROR no function or associated item named `from_str`
+    let y = u32::from_str("33"); //~ ERROR no associated function or constant named `from_str`
 }
diff --git a/tests/ui/rust-2018/trait-import-suggestions.stderr b/tests/ui/rust-2018/trait-import-suggestions.stderr
index 488044ee8524..721ba0c50d78 100644
--- a/tests/ui/rust-2018/trait-import-suggestions.stderr
+++ b/tests/ui/rust-2018/trait-import-suggestions.stderr
@@ -49,11 +49,11 @@ LL -     x.baz();
 LL +     x.bar();
    |
 
-error[E0599]: no function or associated item named `from_str` found for type `u32` in the current scope
+error[E0599]: no associated function or constant named `from_str` found for type `u32` in the current scope
   --> $DIR/trait-import-suggestions.rs:30:18
    |
 LL |     let y = u32::from_str("33");
-   |                  ^^^^^^^^ function or associated item not found in `u32`
+   |                  ^^^^^^^^ associated function or constant not found in `u32`
    |
    = help: items from traits can only be used if the trait is in scope
 help: trait `FromStr` which provides `from_str` is implemented but not in scope; perhaps you want to import it
diff --git a/tests/ui/rust-2018/uniform-paths/issue-87932.rs b/tests/ui/rust-2018/uniform-paths/issue-87932.rs
index d24d4b8b4820..cde7fe7a8ea6 100644
--- a/tests/ui/rust-2018/uniform-paths/issue-87932.rs
+++ b/tests/ui/rust-2018/uniform-paths/issue-87932.rs
@@ -11,5 +11,5 @@ fn deserialize() {
 
 fn main() {
     A::deserialize();
-    //~^ ERROR no function or associated item named `deserialize` found for struct `A`
+    //~^ ERROR no associated function or constant named `deserialize` found for struct `A`
 }
diff --git a/tests/ui/rust-2018/uniform-paths/issue-87932.stderr b/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
index 3e6fc3ff2a56..c408b747b506 100644
--- a/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
+++ b/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no function or associated item named `deserialize` found for struct `A` in the current scope
+error[E0599]: no associated function or constant named `deserialize` found for struct `A` in the current scope
   --> $DIR/issue-87932.rs:13:8
    |
 LL | pub struct A {}
-   | ------------ function or associated item `deserialize` not found for this struct
+   | ------------ associated function or constant `deserialize` not found for this struct
 ...
 LL |     A::deserialize();
-   |        ^^^^^^^^^^^ function or associated item not found in `A`
+   |        ^^^^^^^^^^^ associated function or constant not found in `A`
    |
    = help: items from traits can only be used if the trait is in scope
 help: trait `Deserialize` which provides `deserialize` is implemented but not in scope; perhaps you want to import it
diff --git a/tests/ui/shadowed/shadowing-generic-item.rs b/tests/ui/shadowed/shadowing-generic-item.rs
index c3a0ced04e7f..8a81530aab42 100644
--- a/tests/ui/shadowed/shadowing-generic-item.rs
+++ b/tests/ui/shadowed/shadowing-generic-item.rs
@@ -9,7 +9,7 @@ mod Foo {
     pub fn f() {}
 }
 fn g<Foo>() {
-    Foo::f(); //~ ERROR no function or associated item named `f`
+    Foo::f(); //~ ERROR no associated function or constant named `f`
 }
 
 fn main() {}
diff --git a/tests/ui/shadowed/shadowing-generic-item.stderr b/tests/ui/shadowed/shadowing-generic-item.stderr
index 55a0bb36ea80..eb517b1a9cdb 100644
--- a/tests/ui/shadowed/shadowing-generic-item.stderr
+++ b/tests/ui/shadowed/shadowing-generic-item.stderr
@@ -8,13 +8,13 @@ LL | fn f<T>() {
 LL |     let t = T { i: 0 };
    |             ^ not a struct, variant or union type
 
-error[E0599]: no function or associated item named `f` found for type parameter `Foo` in the current scope
+error[E0599]: no associated function or constant named `f` found for type parameter `Foo` in the current scope
   --> $DIR/shadowing-generic-item.rs:12:10
    |
 LL | fn g<Foo>() {
-   |      --- function or associated item `f` not found for this type parameter
+   |      --- associated function or constant `f` not found for this type parameter
 LL |     Foo::f();
-   |          ^ function or associated item not found in `Foo`
+   |          ^ associated function or constant not found in `Foo`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.alignment_mismatch.stderr b/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.alignment_mismatch.stderr
index 4b1cd8a5a125..4df97a655d62 100644
--- a/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.alignment_mismatch.stderr
+++ b/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.alignment_mismatch.stderr
@@ -1,15 +1,15 @@
-error[E0599]: no function or associated item named `from_mut` found for struct `Atomic<u64>` in the current scope
+error[E0599]: no associated function or constant named `from_mut` found for struct `Atomic<u64>` in the current scope
   --> $DIR/atomic-from-mut-not-available.rs:24:36
    |
 LL |     core::sync::atomic::AtomicU64::from_mut(&mut 0u64);
-   |                                    ^^^^^^^^ function or associated item not found in `Atomic<u64>`
+   |                                    ^^^^^^^^ associated function or constant not found in `Atomic<u64>`
    |
 note: if you're trying to build a new `Atomic<u64>`, consider using `Atomic::<u64>::new` which returns `Atomic<u64>`
   --> $SRC_DIR/core/src/sync/atomic.rs:LL:COL
   ::: $SRC_DIR/core/src/sync/atomic.rs:LL:COL
    |
    = note: in this macro invocation
-   = note: the function or associated item was found for
+   = note: the associated function or constant was found for
            - `Atomic<*mut T>`
            - `Atomic<bool>`
            - `Atomic<i16>`
diff --git a/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.rs b/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.rs
index 519b6977dcb5..b7c7f0ed9824 100644
--- a/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.rs
+++ b/tests/ui/stdlib-unit-tests/atomic-from-mut-not-available.rs
@@ -22,6 +22,6 @@
 
 fn main() {
     core::sync::atomic::AtomicU64::from_mut(&mut 0u64);
-    //[alignment_mismatch]~^ ERROR no function or associated item named `from_mut` found for struct `Atomic<u64>`
+    //[alignment_mismatch]~^ ERROR no associated function or constant named `from_mut` found for struct `Atomic<u64>`
     //[alignment_matches]~^^ ERROR use of unstable library feature `atomic_from_mut`
 }
diff --git a/tests/ui/suggestions/deref-path-method.rs b/tests/ui/suggestions/deref-path-method.rs
index 0281cdb6b37c..d44b3bd70305 100644
--- a/tests/ui/suggestions/deref-path-method.rs
+++ b/tests/ui/suggestions/deref-path-method.rs
@@ -1,6 +1,6 @@
 fn main() {
     let vec = Vec::new();
     Vec::contains(&vec, &0);
-    //~^ ERROR no function or associated item named `contains` found for struct `Vec<_, _>` in the current scope
+    //~^ ERROR no associated function or constant named `contains` found for struct `Vec<_, _>` in the current scope
     //~| HELP the function `contains` is implemented on `[_]`
 }
diff --git a/tests/ui/suggestions/deref-path-method.stderr b/tests/ui/suggestions/deref-path-method.stderr
index 0dec424555ed..8cf8ec9146d7 100644
--- a/tests/ui/suggestions/deref-path-method.stderr
+++ b/tests/ui/suggestions/deref-path-method.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `contains` found for struct `Vec<_, _>` in the current scope
+error[E0599]: no associated function or constant named `contains` found for struct `Vec<_, _>` in the current scope
   --> $DIR/deref-path-method.rs:3:10
    |
 LL |     Vec::contains(&vec, &0);
-   |          ^^^^^^^^ function or associated item not found in `Vec<_, _>`
+   |          ^^^^^^^^ associated function or constant not found in `Vec<_, _>`
    |
 note: if you're trying to build a new `Vec<_, _>` consider using one of the following associated functions:
       Vec::<T>::new
diff --git a/tests/ui/suggestions/dont-suggest-private-trait-method.rs b/tests/ui/suggestions/dont-suggest-private-trait-method.rs
index 6e2b1abd1370..6a220b01f195 100644
--- a/tests/ui/suggestions/dont-suggest-private-trait-method.rs
+++ b/tests/ui/suggestions/dont-suggest-private-trait-method.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     T::new();
-    //~^ ERROR no function or associated item named `new` found
+    //~^ ERROR no associated function or constant named `new` found
 }
diff --git a/tests/ui/suggestions/dont-suggest-private-trait-method.stderr b/tests/ui/suggestions/dont-suggest-private-trait-method.stderr
index f251ad59a587..b53a8279dfea 100644
--- a/tests/ui/suggestions/dont-suggest-private-trait-method.stderr
+++ b/tests/ui/suggestions/dont-suggest-private-trait-method.stderr
@@ -1,11 +1,11 @@
-error[E0599]: no function or associated item named `new` found for struct `T` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `T` in the current scope
   --> $DIR/dont-suggest-private-trait-method.rs:4:8
    |
 LL | struct T;
-   | -------- function or associated item `new` not found for this struct
+   | -------- associated function or constant `new` not found for this struct
 ...
 LL |     T::new();
-   |        ^^^ function or associated item not found in `T`
+   |        ^^^ associated function or constant not found in `T`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/incorrect-variant-literal.svg b/tests/ui/suggestions/incorrect-variant-literal.svg
index d2c1f6c95ca5..54eaee2a2e90 100644
--- a/tests/ui/suggestions/incorrect-variant-literal.svg
+++ b/tests/ui/suggestions/incorrect-variant-literal.svg
@@ -1,4 +1,4 @@
-<svg width="886px" height="9524px" xmlns="http://www.w3.org/2000/svg">
+<svg width="1012px" height="9524px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
     .bg { fill: #000000 }
@@ -437,7 +437,7 @@
 </tspan>
     <tspan x="10px" y="3754px">
 </tspan>
-    <tspan x="10px" y="3772px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `unit` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="3772px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `unit` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="3790px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:34:11</tspan>
 </tspan>
@@ -445,13 +445,13 @@
 </tspan>
     <tspan x="10px" y="3826px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="3844px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `unit` not found for this enum</tspan>
+    <tspan x="10px" y="3844px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `unit` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="3862px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="3880px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::unit;</tspan>
 </tspan>
-    <tspan x="10px" y="3898px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="3898px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="3916px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -467,7 +467,7 @@
 </tspan>
     <tspan x="10px" y="4024px">
 </tspan>
-    <tspan x="10px" y="4042px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `tuple` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="4042px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `tuple` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="4060px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:35:11</tspan>
 </tspan>
@@ -475,13 +475,13 @@
 </tspan>
     <tspan x="10px" y="4096px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="4114px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `tuple` not found for this enum</tspan>
+    <tspan x="10px" y="4114px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `tuple` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="4132px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="4150px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::tuple;</tspan>
 </tspan>
-    <tspan x="10px" y="4168px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="4168px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="4186px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -497,7 +497,7 @@
 </tspan>
     <tspan x="10px" y="4294px">
 </tspan>
-    <tspan x="10px" y="4312px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `r#struct` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="4312px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `r#struct` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="4330px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:36:11</tspan>
 </tspan>
@@ -505,13 +505,13 @@
 </tspan>
     <tspan x="10px" y="4366px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="4384px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `r#struct` not found for this enum</tspan>
+    <tspan x="10px" y="4384px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `r#struct` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="4402px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="4420px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::r#struct;</tspan>
 </tspan>
-    <tspan x="10px" y="4438px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="4438px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="4456px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -527,7 +527,7 @@
 </tspan>
     <tspan x="10px" y="4564px">
 </tspan>
-    <tspan x="10px" y="4582px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `unit` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="4582px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `unit` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="4600px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:37:11</tspan>
 </tspan>
@@ -535,13 +535,13 @@
 </tspan>
     <tspan x="10px" y="4636px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="4654px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `unit` not found for this enum</tspan>
+    <tspan x="10px" y="4654px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `unit` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="4672px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="4690px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::unit();</tspan>
 </tspan>
-    <tspan x="10px" y="4708px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="4708px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="4726px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -557,7 +557,7 @@
 </tspan>
     <tspan x="10px" y="4834px">
 </tspan>
-    <tspan x="10px" y="4852px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `tuple` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="4852px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `tuple` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="4870px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:38:11</tspan>
 </tspan>
@@ -565,13 +565,13 @@
 </tspan>
     <tspan x="10px" y="4906px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="4924px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `tuple` not found for this enum</tspan>
+    <tspan x="10px" y="4924px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `tuple` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="4942px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="4960px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::tuple();</tspan>
 </tspan>
-    <tspan x="10px" y="4978px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="4978px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="4996px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -587,7 +587,7 @@
 </tspan>
     <tspan x="10px" y="5104px">
 </tspan>
-    <tspan x="10px" y="5122px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `r#struct` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="5122px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `r#struct` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="5140px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:39:11</tspan>
 </tspan>
@@ -595,13 +595,13 @@
 </tspan>
     <tspan x="10px" y="5176px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="5194px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `r#struct` not found for this enum</tspan>
+    <tspan x="10px" y="5194px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `r#struct` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="5212px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="5230px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::r#struct();</tspan>
 </tspan>
-    <tspan x="10px" y="5248px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="5248px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="5266px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -707,7 +707,7 @@
 </tspan>
     <tspan x="10px" y="6184px">
 </tspan>
-    <tspan x="10px" y="6202px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `unit` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="6202px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `unit` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="6220px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:43:11</tspan>
 </tspan>
@@ -715,13 +715,13 @@
 </tspan>
     <tspan x="10px" y="6256px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="6274px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `unit` not found for this enum</tspan>
+    <tspan x="10px" y="6274px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `unit` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="6292px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="6310px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::unit(0);</tspan>
 </tspan>
-    <tspan x="10px" y="6328px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="6328px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="6346px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -737,7 +737,7 @@
 </tspan>
     <tspan x="10px" y="6454px">
 </tspan>
-    <tspan x="10px" y="6472px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `tuple` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="6472px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `tuple` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="6490px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:44:11</tspan>
 </tspan>
@@ -745,13 +745,13 @@
 </tspan>
     <tspan x="10px" y="6526px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="6544px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `tuple` not found for this enum</tspan>
+    <tspan x="10px" y="6544px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `tuple` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="6562px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="6580px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::tuple(0);</tspan>
 </tspan>
-    <tspan x="10px" y="6598px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="6598px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="6616px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -767,7 +767,7 @@
 </tspan>
     <tspan x="10px" y="6724px">
 </tspan>
-    <tspan x="10px" y="6742px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `r#struct` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="6742px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `r#struct` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="6760px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:45:11</tspan>
 </tspan>
@@ -775,13 +775,13 @@
 </tspan>
     <tspan x="10px" y="6796px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="6814px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `r#struct` not found for this enum</tspan>
+    <tspan x="10px" y="6814px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `r#struct` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="6832px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="6850px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::r#struct(0);</tspan>
 </tspan>
-    <tspan x="10px" y="6868px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="6868px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="6886px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -887,7 +887,7 @@
 </tspan>
     <tspan x="10px" y="7804px">
 </tspan>
-    <tspan x="10px" y="7822px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `unit` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="7822px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `unit` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="7840px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:49:11</tspan>
 </tspan>
@@ -895,13 +895,13 @@
 </tspan>
     <tspan x="10px" y="7876px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="7894px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `unit` not found for this enum</tspan>
+    <tspan x="10px" y="7894px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `unit` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="7912px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="7930px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::unit(0, 0);</tspan>
 </tspan>
-    <tspan x="10px" y="7948px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="7948px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="7966px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -917,7 +917,7 @@
 </tspan>
     <tspan x="10px" y="8074px">
 </tspan>
-    <tspan x="10px" y="8092px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `tuple` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="8092px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `tuple` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="8110px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:50:11</tspan>
 </tspan>
@@ -925,13 +925,13 @@
 </tspan>
     <tspan x="10px" y="8146px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="8164px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `tuple` not found for this enum</tspan>
+    <tspan x="10px" y="8164px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `tuple` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="8182px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="8200px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::tuple(0, 0);</tspan>
 </tspan>
-    <tspan x="10px" y="8218px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="8218px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="8236px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
@@ -947,7 +947,7 @@
 </tspan>
     <tspan x="10px" y="8344px">
 </tspan>
-    <tspan x="10px" y="8362px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant or associated item named `r#struct` found for enum `Enum` in the current scope</tspan>
+    <tspan x="10px" y="8362px"><tspan class="fg-bright-red bold">error[E0599]</tspan><tspan class="bold">: no variant, associated function, or constant named `r#struct` found for enum `Enum` in the current scope</tspan>
 </tspan>
     <tspan x="10px" y="8380px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/incorrect-variant-literal.rs:51:11</tspan>
 </tspan>
@@ -955,13 +955,13 @@
 </tspan>
     <tspan x="10px" y="8416px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> enum Enum {</tspan>
 </tspan>
-    <tspan x="10px" y="8434px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant or associated item `r#struct` not found for this enum</tspan>
+    <tspan x="10px" y="8434px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">---------</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">variant, associated function, or constant `r#struct` not found for this enum</tspan>
 </tspan>
     <tspan x="10px" y="8452px"><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
     <tspan x="10px" y="8470px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>     Enum::r#struct(0, 0);</tspan>
 </tspan>
-    <tspan x="10px" y="8488px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant or associated item not found in `Enum`</tspan>
+    <tspan x="10px" y="8488px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>           </tspan><tspan class="fg-bright-red bold">^^^^^^^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">variant, associated function, or constant not found in `Enum`</tspan>
 </tspan>
     <tspan x="10px" y="8506px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
diff --git a/tests/ui/suggestions/issue-109291.rs b/tests/ui/suggestions/issue-109291.rs
index 1947b16a32e6..5b27970465a6 100644
--- a/tests/ui/suggestions/issue-109291.rs
+++ b/tests/ui/suggestions/issue-109291.rs
@@ -1,4 +1,4 @@
 fn main() {
     println!("Custom backtrace: {}", std::backtrace::Backtrace::forced_capture());
-    //~^ ERROR no function or associated item name
+    //~^ ERROR no associated function or constant name
 }
diff --git a/tests/ui/suggestions/issue-109291.stderr b/tests/ui/suggestions/issue-109291.stderr
index c2c36f105440..c58868913c42 100644
--- a/tests/ui/suggestions/issue-109291.stderr
+++ b/tests/ui/suggestions/issue-109291.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `forced_capture` found for struct `Backtrace` in the current scope
+error[E0599]: no associated function or constant named `forced_capture` found for struct `Backtrace` in the current scope
   --> $DIR/issue-109291.rs:2:65
    |
 LL |     println!("Custom backtrace: {}", std::backtrace::Backtrace::forced_capture());
-   |                                                                 ^^^^^^^^^^^^^^ function or associated item not found in `Backtrace`
+   |                                                                 ^^^^^^^^^^^^^^ associated function or constant not found in `Backtrace`
    |
 note: if you're trying to build a new `Backtrace` consider using one of the following associated functions:
       Backtrace::capture
diff --git a/tests/ui/suggestions/suggest-variants.stderr b/tests/ui/suggestions/suggest-variants.stderr
index 13518a9d5842..41c266225216 100644
--- a/tests/ui/suggestions/suggest-variants.stderr
+++ b/tests/ui/suggestions/suggest-variants.stderr
@@ -36,14 +36,14 @@ LL | enum Shape {
 LL |     println!("My shape is {:?}", Shape::Rombus{ size: 5});
    |                                         ^^^^^^ variant not found in `Shape`
 
-error[E0599]: no variant or associated item named `Squareee` found for enum `Shape` in the current scope
+error[E0599]: no variant, associated function, or constant named `Squareee` found for enum `Shape` in the current scope
   --> $DIR/suggest-variants.rs:15:12
    |
 LL | enum Shape {
-   | ---------- variant or associated item `Squareee` not found for this enum
+   | ---------- variant, associated function, or constant `Squareee` not found for this enum
 ...
 LL |     Shape::Squareee;
-   |            ^^^^^^^^ variant or associated item not found in `Shape`
+   |            ^^^^^^^^ variant, associated function, or constant not found in `Shape`
    |
 help: there is a variant with a similar name
    |
@@ -51,37 +51,37 @@ LL -     Shape::Squareee;
 LL +     Shape::Square { size: /* value */ };
    |
 
-error[E0599]: no variant or associated item named `Circl` found for enum `Shape` in the current scope
+error[E0599]: no variant, associated function, or constant named `Circl` found for enum `Shape` in the current scope
   --> $DIR/suggest-variants.rs:16:12
    |
 LL | enum Shape {
-   | ---------- variant or associated item `Circl` not found for this enum
+   | ---------- variant, associated function, or constant `Circl` not found for this enum
 ...
 LL |     Shape::Circl;
-   |            ^^^^^ variant or associated item not found in `Shape`
+   |            ^^^^^ variant, associated function, or constant not found in `Shape`
    |
 help: there is a variant with a similar name
    |
 LL |     Shape::Circle { radius: /* value */ };
    |                 +++++++++++++++++++++++++
 
-error[E0599]: no variant or associated item named `Rombus` found for enum `Shape` in the current scope
+error[E0599]: no variant, associated function, or constant named `Rombus` found for enum `Shape` in the current scope
   --> $DIR/suggest-variants.rs:17:12
    |
 LL | enum Shape {
-   | ---------- variant or associated item `Rombus` not found for this enum
+   | ---------- variant, associated function, or constant `Rombus` not found for this enum
 ...
 LL |     Shape::Rombus;
-   |            ^^^^^^ variant or associated item not found in `Shape`
+   |            ^^^^^^ variant, associated function, or constant not found in `Shape`
 
-error[E0599]: no variant or associated item named `Redd` found for enum `Color` in the current scope
+error[E0599]: no variant, associated function, or constant named `Redd` found for enum `Color` in the current scope
   --> $DIR/suggest-variants.rs:28:13
    |
 LL | enum Color {
-   | ---------- variant or associated item `Redd` not found for this enum
+   | ---------- variant, associated function, or constant `Redd` not found for this enum
 ...
 LL |   Ok(Color::Redd)
-   |             ^^^^ variant or associated item not found in `Color`
+   |             ^^^^ variant, associated function, or constant not found in `Color`
    |
 help: there is a variant with a similar name
    |
@@ -89,14 +89,14 @@ LL -   Ok(Color::Redd)
 LL +   Ok(Color::Red)
    |
 
-error[E0599]: no variant or associated item named `Greenn` found for enum `Color` in the current scope
+error[E0599]: no variant, associated function, or constant named `Greenn` found for enum `Color` in the current scope
   --> $DIR/suggest-variants.rs:32:13
    |
 LL | enum Color {
-   | ---------- variant or associated item `Greenn` not found for this enum
+   | ---------- variant, associated function, or constant `Greenn` not found for this enum
 ...
 LL |   Ok(Color::Greenn(()))
-   |             ^^^^^^ variant or associated item not found in `Color`
+   |             ^^^^^^ variant, associated function, or constant not found in `Color`
    |
 help: there is a variant with a similar name
    |
@@ -104,14 +104,14 @@ LL -   Ok(Color::Greenn(()))
 LL +   Ok(Color::Green(()))
    |
 
-error[E0599]: no variant or associated item named `Blu` found for enum `Color` in the current scope
+error[E0599]: no variant, associated function, or constant named `Blu` found for enum `Color` in the current scope
   --> $DIR/suggest-variants.rs:36:13
    |
 LL | enum Color {
-   | ---------- variant or associated item `Blu` not found for this enum
+   | ---------- variant, associated function, or constant `Blu` not found for this enum
 ...
 LL |   Ok(Color::Blu)
-   |             ^^^ variant or associated item not found in `Color`
+   |             ^^^ variant, associated function, or constant not found in `Color`
    |
 help: there is a variant with a similar name
    |
diff --git a/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr b/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
index 49a4db7491ed..1884ba620c96 100644
--- a/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
+++ b/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
@@ -1,11 +1,11 @@
-error[E0599]: the function or associated item `f` exists for struct `Foo<()>`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `f` exists for struct `Foo<()>`, but its trait bounds were not satisfied
   --> $DIR/issue-108132-unmet-trait-alias-bound-on-generic-impl.rs:14:16
    |
 LL | struct Foo<I>(I);
-   | ------------- function or associated item `f` not found for this struct
+   | ------------- associated function or constant `f` not found for this struct
 ...
 LL |     Foo::<()>::f()
-   |                ^ function or associated item cannot be called on `Foo<()>` due to unsatisfied trait bounds
+   |                ^ associated function or constant cannot be called on `Foo<()>` due to unsatisfied trait bounds
    |
 note: trait bound `(): Iterator` was not satisfied
   --> $DIR/issue-108132-unmet-trait-alias-bound-on-generic-impl.rs:5:23
diff --git a/tests/ui/traits/associated-item-unsatisfied-trait-bounds.stderr b/tests/ui/traits/associated-item-unsatisfied-trait-bounds.stderr
index 42969de715eb..f26c321a2973 100644
--- a/tests/ui/traits/associated-item-unsatisfied-trait-bounds.stderr
+++ b/tests/ui/traits/associated-item-unsatisfied-trait-bounds.stderr
@@ -1,11 +1,11 @@
-error[E0599]: the function or associated item `bat` exists for struct `Foo`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `bat` exists for struct `Foo`, but its trait bounds were not satisfied
   --> $DIR/associated-item-unsatisfied-trait-bounds.rs:8:10
    |
 LL | struct Foo;
-   | ---------- function or associated item `bat` not found for this struct because `Foo` doesn't implement `Bar` or `Baz`
+   | ---------- associated function or constant `bat` not found for this struct because `Foo` doesn't implement `Bar` or `Baz`
 ...
 LL |     Foo::bat(());
-   |          ^^^ function or associated item cannot be called on `Foo` due to unsatisfied trait bounds
+   |          ^^^ associated function or constant cannot be called on `Foo` due to unsatisfied trait bounds
    |
 note: for `bat` to be available, `Foo` must implement `Bar` and `Baz`
   --> $DIR/associated-item-unsatisfied-trait-bounds.rs:5:38
diff --git a/tests/ui/traits/issue-3973.rs b/tests/ui/traits/issue-3973.rs
index a5ed5b87051e..96e581c169f3 100644
--- a/tests/ui/traits/issue-3973.rs
+++ b/tests/ui/traits/issue-3973.rs
@@ -20,6 +20,6 @@ fn to_string(&self) -> String {
 
 fn main() {
     let p = Point::new(0.0, 0.0);
-    //~^ ERROR no function or associated item named `new` found for struct `Point`
+    //~^ ERROR no associated function or constant named `new` found for struct `Point`
     println!("{}", p.to_string());
 }
diff --git a/tests/ui/traits/issue-3973.stderr b/tests/ui/traits/issue-3973.stderr
index 87ee08049300..9da3617c05b6 100644
--- a/tests/ui/traits/issue-3973.stderr
+++ b/tests/ui/traits/issue-3973.stderr
@@ -7,14 +7,14 @@ LL | |         Point { x: x, y: y }
 LL | |     }
    | |_____^ not a member of trait `ToString_`
 
-error[E0599]: no function or associated item named `new` found for struct `Point` in the current scope
+error[E0599]: no associated function or constant named `new` found for struct `Point` in the current scope
   --> $DIR/issue-3973.rs:22:20
    |
 LL | struct Point {
-   | ------------ function or associated item `new` not found for this struct
+   | ------------ associated function or constant `new` not found for this struct
 ...
 LL |     let p = Point::new(0.0, 0.0);
-   |                    ^^^ function or associated item not found in `Point`
+   |                    ^^^ associated function or constant not found in `Point`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/traits/item-privacy.rs b/tests/ui/traits/item-privacy.rs
index 44ba87642371..519a95c5c785 100644
--- a/tests/ui/traits/item-privacy.rs
+++ b/tests/ui/traits/item-privacy.rs
@@ -77,9 +77,9 @@ fn check_method() {
     // Methods, UFCS
     // a, b, c are resolved as trait items, their traits need to be in scope
     S::a(&S);
-    //~^ ERROR no function or associated item named `a` found
+    //~^ ERROR no associated function or constant named `a` found
     S::b(&S);
-    //~^ ERROR no function or associated item named `b` found
+    //~^ ERROR no associated function or constant named `b` found
     S::c(&S); // OK
     // a, b, c are resolved as inherent items, their traits don't need to be in scope
     <dyn C>::a(&S); //~ ERROR method `a` is private
@@ -95,8 +95,8 @@ fn check_assoc_const() {
 
     // Associated constants
     // A, B, C are resolved as trait items, their traits need to be in scope
-    S::A; //~ ERROR no associated item named `A` found
-    S::B; //~ ERROR no associated item named `B` found
+    S::A; //~ ERROR no associated function or constant named `A` found
+    S::B; //~ ERROR no associated function or constant named `B` found
     S::C; // OK
     // A, B, C are resolved as inherent items, their traits don't need to be in scope
     <dyn C>::A;
diff --git a/tests/ui/traits/item-privacy.stderr b/tests/ui/traits/item-privacy.stderr
index 8c33bb6de200..7b199542c961 100644
--- a/tests/ui/traits/item-privacy.stderr
+++ b/tests/ui/traits/item-privacy.stderr
@@ -47,14 +47,14 @@ LL |         fn a(&self) { }
 LL |     c.a();
    |       ^ private method
 
-error[E0599]: no function or associated item named `a` found for struct `S` in the current scope
+error[E0599]: no associated function or constant named `a` found for struct `S` in the current scope
   --> $DIR/item-privacy.rs:79:8
    |
 LL | struct S;
-   | -------- function or associated item `a` not found for this struct
+   | -------- associated function or constant `a` not found for this struct
 ...
 LL |     S::a(&S);
-   |        ^ function or associated item not found in `S`
+   |        ^ associated function or constant not found in `S`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = help: trait `method::A` which provides `a` is implemented but not reachable
@@ -64,14 +64,14 @@ help: there is an associated constant `B` with a similar name
 LL |         const B: u8 = 0;
    |         ^^^^^^^^^^^
 
-error[E0599]: no function or associated item named `b` found for struct `S` in the current scope
+error[E0599]: no associated function or constant named `b` found for struct `S` in the current scope
   --> $DIR/item-privacy.rs:81:8
    |
 LL | struct S;
-   | -------- function or associated item `b` not found for this struct
+   | -------- associated function or constant `b` not found for this struct
 ...
 LL |     S::b(&S);
-   |        ^ function or associated item not found in `S`
+   |        ^ associated function or constant not found in `S`
    |
    = help: items from traits can only be used if the trait is in scope
 help: there is an associated constant `B` with a similar name
@@ -93,14 +93,14 @@ LL |         fn a(&self) { }
 LL |     <dyn C>::a(&S);
    |              ^ private method
 
-error[E0599]: no associated item named `A` found for struct `S` in the current scope
+error[E0599]: no associated function or constant named `A` found for struct `S` in the current scope
   --> $DIR/item-privacy.rs:98:8
    |
 LL | struct S;
-   | -------- associated item `A` not found for this struct
+   | -------- associated function or constant `A` not found for this struct
 ...
 LL |     S::A;
-   |        ^ associated item not found in `S`
+   |        ^ associated function or constant not found in `S`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = help: trait `assoc_const::A` which provides `A` is implemented but not reachable
@@ -110,14 +110,14 @@ LL -     S::A;
 LL +     S::B;
    |
 
-error[E0599]: no associated item named `B` found for struct `S` in the current scope
+error[E0599]: no associated function or constant named `B` found for struct `S` in the current scope
   --> $DIR/item-privacy.rs:99:8
    |
 LL | struct S;
-   | -------- associated item `B` not found for this struct
+   | -------- associated function or constant `B` not found for this struct
 ...
 LL |     S::B;
-   |        ^ associated item not found in `S`
+   |        ^ associated function or constant not found in `S`
    |
    = help: items from traits can only be used if the trait is in scope
 help: there is a method `b` with a similar name
diff --git a/tests/ui/traits/unspecified-self-in-trait-ref.rs b/tests/ui/traits/unspecified-self-in-trait-ref.rs
index f175a8e6dbdf..fbc95e0443c5 100644
--- a/tests/ui/traits/unspecified-self-in-trait-ref.rs
+++ b/tests/ui/traits/unspecified-self-in-trait-ref.rs
@@ -9,19 +9,19 @@ pub trait Bar<X=usize, A=Self> {
 
 fn main() {
     let a = Foo::lol();
-    //~^ ERROR no function or associated item named
+    //~^ ERROR no associated function or constant named
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let b = Foo::<_>::lol();
-    //~^ ERROR no function or associated item named
+    //~^ ERROR no associated function or constant named
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let c = Bar::lol();
-    //~^ ERROR no function or associated item named
+    //~^ ERROR no associated function or constant named
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let d = Bar::<usize, _>::lol();
-    //~^ ERROR no function or associated item named
+    //~^ ERROR no associated function or constant named
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let e = Bar::<usize>::lol();
diff --git a/tests/ui/traits/unspecified-self-in-trait-ref.stderr b/tests/ui/traits/unspecified-self-in-trait-ref.stderr
index b7d78a3284e3..e76187de81f4 100644
--- a/tests/ui/traits/unspecified-self-in-trait-ref.stderr
+++ b/tests/ui/traits/unspecified-self-in-trait-ref.stderr
@@ -12,11 +12,11 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL |     let a = <dyn Foo>::lol();
    |             ++++    +
 
-error[E0599]: no function or associated item named `lol` found for trait object `dyn Foo<_>` in the current scope
+error[E0599]: no associated function or constant named `lol` found for trait object `dyn Foo<_>` in the current scope
   --> $DIR/unspecified-self-in-trait-ref.rs:11:18
    |
 LL |     let a = Foo::lol();
-   |                  ^^^ function or associated item not found in `dyn Foo<_>`
+   |                  ^^^ associated function or constant not found in `dyn Foo<_>`
 
 warning: trait objects without an explicit `dyn` are deprecated
   --> $DIR/unspecified-self-in-trait-ref.rs:15:13
@@ -31,11 +31,11 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL |     let b = <dyn Foo::<_>>::lol();
    |             ++++         +
 
-error[E0599]: no function or associated item named `lol` found for trait object `dyn Foo<_>` in the current scope
+error[E0599]: no associated function or constant named `lol` found for trait object `dyn Foo<_>` in the current scope
   --> $DIR/unspecified-self-in-trait-ref.rs:15:23
    |
 LL |     let b = Foo::<_>::lol();
-   |                       ^^^ function or associated item not found in `dyn Foo<_>`
+   |                       ^^^ associated function or constant not found in `dyn Foo<_>`
 
 warning: trait objects without an explicit `dyn` are deprecated
   --> $DIR/unspecified-self-in-trait-ref.rs:19:13
@@ -50,11 +50,11 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL |     let c = <dyn Bar>::lol();
    |             ++++    +
 
-error[E0599]: no function or associated item named `lol` found for trait object `dyn Bar<_, _>` in the current scope
+error[E0599]: no associated function or constant named `lol` found for trait object `dyn Bar<_, _>` in the current scope
   --> $DIR/unspecified-self-in-trait-ref.rs:19:18
    |
 LL |     let c = Bar::lol();
-   |                  ^^^ function or associated item not found in `dyn Bar<_, _>`
+   |                  ^^^ associated function or constant not found in `dyn Bar<_, _>`
 
 warning: trait objects without an explicit `dyn` are deprecated
   --> $DIR/unspecified-self-in-trait-ref.rs:23:13
@@ -69,11 +69,11 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL |     let d = <dyn Bar::<usize, _>>::lol();
    |             ++++                +
 
-error[E0599]: no function or associated item named `lol` found for trait object `dyn Bar<usize, _>` in the current scope
+error[E0599]: no associated function or constant named `lol` found for trait object `dyn Bar<usize, _>` in the current scope
   --> $DIR/unspecified-self-in-trait-ref.rs:23:30
    |
 LL |     let d = Bar::<usize, _>::lol();
-   |                              ^^^ function or associated item not found in `dyn Bar<usize, _>`
+   |                              ^^^ associated function or constant not found in `dyn Bar<usize, _>`
 
 warning: trait objects without an explicit `dyn` are deprecated
   --> $DIR/unspecified-self-in-trait-ref.rs:27:13
diff --git a/tests/ui/type/issue-103271.rs b/tests/ui/type/issue-103271.rs
index 98cfaaf5cff7..e949bb10ece2 100644
--- a/tests/ui/type/issue-103271.rs
+++ b/tests/ui/type/issue-103271.rs
@@ -1,15 +1,15 @@
 fn main() {
     let iter_fun = <&[u32]>::iter;
-    //~^ ERROR no function or associated item named `iter` found for reference `&[u32]` in the current scope [E0599]
-    //~| NOTE function or associated item not found in `&[u32]`
+    //~^ ERROR no associated function or constant named `iter` found for reference `&[u32]` in the current scope [E0599]
+    //~| NOTE associated function or constant not found in `&[u32]`
     //~| HELP the function `iter` is implemented on `[u32]`
     for item in iter_fun(&[1,1]) {
         let x: &u32 = item;
         assert_eq!(x, &1);
     }
     let iter_fun2 = <(&[u32])>::iter;
-    //~^ ERROR no function or associated item named `iter` found for reference `&[u32]` in the current scope [E0599]
-    //~| NOTE function or associated item not found in `&[u32]`
+    //~^ ERROR no associated function or constant named `iter` found for reference `&[u32]` in the current scope [E0599]
+    //~| NOTE associated function or constant not found in `&[u32]`
     //~| HELP the function `iter` is implemented on `[u32]`
     for item2 in iter_fun2(&[1,1]) {
         let x: &u32 = item2;
diff --git a/tests/ui/type/issue-103271.stderr b/tests/ui/type/issue-103271.stderr
index 1b84033291a5..a83b782bec52 100644
--- a/tests/ui/type/issue-103271.stderr
+++ b/tests/ui/type/issue-103271.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `iter` found for reference `&[u32]` in the current scope
+error[E0599]: no associated function or constant named `iter` found for reference `&[u32]` in the current scope
   --> $DIR/issue-103271.rs:2:30
    |
 LL |     let iter_fun = <&[u32]>::iter;
-   |                              ^^^^ function or associated item not found in `&[u32]`
+   |                              ^^^^ associated function or constant not found in `&[u32]`
    |
 help: the function `iter` is implemented on `[u32]`
    |
@@ -10,11 +10,11 @@ LL -     let iter_fun = <&[u32]>::iter;
 LL +     let iter_fun = <[u32]>::iter;
    |
 
-error[E0599]: no function or associated item named `iter` found for reference `&[u32]` in the current scope
+error[E0599]: no associated function or constant named `iter` found for reference `&[u32]` in the current scope
   --> $DIR/issue-103271.rs:10:33
    |
 LL |     let iter_fun2 = <(&[u32])>::iter;
-   |                                 ^^^^ function or associated item not found in `&[u32]`
+   |                                 ^^^^ associated function or constant not found in `&[u32]`
    |
 help: the function `iter` is implemented on `[u32]`
    |
diff --git a/tests/ui/typeck/derive-sugg-arg-arity.rs b/tests/ui/typeck/derive-sugg-arg-arity.rs
index 094c93a8535d..1a233e68639d 100644
--- a/tests/ui/typeck/derive-sugg-arg-arity.rs
+++ b/tests/ui/typeck/derive-sugg-arg-arity.rs
@@ -3,6 +3,6 @@
 fn main() {
     match () {
         _ => match A::partial_cmp() {},
-        //~^ ERROR the function or associated item `partial_cmp` exists for struct `A`, but its trait bounds were not satisfied
+        //~^ ERROR the associated function or constant `partial_cmp` exists for struct `A`, but its trait bounds were not satisfied
     }
 }
diff --git a/tests/ui/typeck/derive-sugg-arg-arity.stderr b/tests/ui/typeck/derive-sugg-arg-arity.stderr
index 382b324c4cc5..029d8dfdfc79 100644
--- a/tests/ui/typeck/derive-sugg-arg-arity.stderr
+++ b/tests/ui/typeck/derive-sugg-arg-arity.stderr
@@ -1,11 +1,11 @@
-error[E0599]: the function or associated item `partial_cmp` exists for struct `A`, but its trait bounds were not satisfied
+error[E0599]: the associated function or constant `partial_cmp` exists for struct `A`, but its trait bounds were not satisfied
   --> $DIR/derive-sugg-arg-arity.rs:5:23
    |
 LL | pub struct A;
-   | ------------ function or associated item `partial_cmp` not found for this struct because it doesn't satisfy `A: Iterator` or `A: PartialOrd<_>`
+   | ------------ associated function or constant `partial_cmp` not found for this struct because it doesn't satisfy `A: Iterator` or `A: PartialOrd<_>`
 ...
 LL |         _ => match A::partial_cmp() {},
-   |                       ^^^^^^^^^^^ function or associated item cannot be called on `A` due to unsatisfied trait bounds
+   |                       ^^^^^^^^^^^ associated function or constant cannot be called on `A` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `A: PartialOrd<_>`
diff --git a/tests/ui/typeck/dont-suggest-private-dependencies.rs b/tests/ui/typeck/dont-suggest-private-dependencies.rs
index ee5224e2d821..23debbf4e342 100644
--- a/tests/ui/typeck/dont-suggest-private-dependencies.rs
+++ b/tests/ui/typeck/dont-suggest-private-dependencies.rs
@@ -31,7 +31,7 @@ fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
 
 fn main() {
     let _ = u8::cast_from_lossy(9);
-    //~^ ERROR no function or associated item named `cast_from_lossy` found for type `u8`
+    //~^ ERROR no associated function or constant named `cast_from_lossy` found for type `u8`
     let _ = B::foo();
-    //~^ ERROR no function or associated item named `foo` found for struct `B`
+    //~^ ERROR no associated function or constant named `foo` found for struct `B`
 }
diff --git a/tests/ui/typeck/dont-suggest-private-dependencies.stderr b/tests/ui/typeck/dont-suggest-private-dependencies.stderr
index b7b14ee6b9bb..d17964cc933a 100644
--- a/tests/ui/typeck/dont-suggest-private-dependencies.stderr
+++ b/tests/ui/typeck/dont-suggest-private-dependencies.stderr
@@ -10,17 +10,17 @@ help: there is a method `read1` with a similar name, but with different argument
 LL |     fn read1(&self) {}
    |     ^^^^^^^^^^^^^^^
 
-error[E0599]: no function or associated item named `cast_from_lossy` found for type `u8` in the current scope
+error[E0599]: no associated function or constant named `cast_from_lossy` found for type `u8` in the current scope
   --> $DIR/dont-suggest-private-dependencies.rs:33:17
    |
 LL |     let _ = u8::cast_from_lossy(9);
-   |                 ^^^^^^^^^^^^^^^ function or associated item not found in `u8`
+   |                 ^^^^^^^^^^^^^^^ associated function or constant not found in `u8`
 
-error[E0599]: no function or associated item named `foo` found for struct `B` in the current scope
+error[E0599]: no associated function or constant named `foo` found for struct `B` in the current scope
   --> $DIR/dont-suggest-private-dependencies.rs:35:16
    |
 LL |     let _ = B::foo();
-   |                ^^^ function or associated item not found in `B`
+   |                ^^^ associated function or constant not found in `B`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.rs b/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.rs
index 3cb775e85ac6..56d46fda9842 100644
--- a/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.rs
+++ b/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.rs
@@ -7,5 +7,5 @@
 
 fn main() {
     Bar::foo();
-    //~^ ERROR: no function or associated item named `foo` found for struct `Bar` in the current scope [E0599]
+    //~^ ERROR: no associated function or constant named `foo` found for struct `Bar` in the current scope [E0599]
 }
diff --git a/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.stderr b/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.stderr
index 9128ee684446..7f78d2aef617 100644
--- a/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.stderr
+++ b/tests/ui/typeck/suggest-trait-reexported-as-not-doc-visible.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `foo` found for struct `Bar` in the current scope
+error[E0599]: no associated function or constant named `foo` found for struct `Bar` in the current scope
   --> $DIR/suggest-trait-reexported-as-not-doc-visible.rs:9:10
    |
 LL |     Bar::foo();
-   |          ^^^ function or associated item not found in `Bar`
+   |          ^^^ associated function or constant not found in `Bar`
    |
    = help: items from traits can only be used if the trait is in scope
 help: trait `Foo` which provides `foo` is implemented but not in scope; perhaps you want to import it
diff --git a/tests/ui/ufcs/bad-builder.rs b/tests/ui/ufcs/bad-builder.rs
index 350c96acca08..53d174b7eaf2 100644
--- a/tests/ui/ufcs/bad-builder.rs
+++ b/tests/ui/ufcs/bad-builder.rs
@@ -1,6 +1,6 @@
 fn hello<Q>() -> Vec<Q> {
     Vec::<Q>::mew()
-    //~^ ERROR no function or associated item named `mew` found for struct `Vec<Q>` in the current scope
+    //~^ ERROR no associated function or constant named `mew` found for struct `Vec<Q>` in the current scope
 }
 
 fn main() {}
diff --git a/tests/ui/ufcs/bad-builder.stderr b/tests/ui/ufcs/bad-builder.stderr
index 2504a3d09253..5fae6268af47 100644
--- a/tests/ui/ufcs/bad-builder.stderr
+++ b/tests/ui/ufcs/bad-builder.stderr
@@ -1,8 +1,8 @@
-error[E0599]: no function or associated item named `mew` found for struct `Vec<Q>` in the current scope
+error[E0599]: no associated function or constant named `mew` found for struct `Vec<Q>` in the current scope
   --> $DIR/bad-builder.rs:2:15
    |
 LL |     Vec::<Q>::mew()
-   |               ^^^ function or associated item not found in `Vec<Q>`
+   |               ^^^ associated function or constant not found in `Vec<Q>`
    |
 note: if you're trying to build a new `Vec<Q>` consider using one of the following associated functions:
       Vec::<T>::new
diff --git a/tests/ui/ufcs/ufcs-partially-resolved.rs b/tests/ui/ufcs/ufcs-partially-resolved.rs
index 712668728c9e..ac98aef4e1de 100644
--- a/tests/ui/ufcs/ufcs-partially-resolved.rs
+++ b/tests/ui/ufcs/ufcs-partially-resolved.rs
@@ -35,7 +35,7 @@ fn main() {
     <u8 as A>::N::NN; //~ ERROR expected trait, found type alias `A`
     let _: <u8 as Tr>::Y::NN; //~ ERROR ambiguous associated type
     let _: <u8 as E>::Y::NN; //~ ERROR expected trait, found enum `E`
-    <u8 as Tr>::Y::NN; //~ ERROR no associated item named `NN` found for type `u16`
+    <u8 as Tr>::Y::NN; //~ ERROR no associated function or constant named `NN` found for type `u16`
     <u8 as E>::Y::NN; //~ ERROR expected trait, found enum `E`
 
     let _: <u8 as Tr::N>::NN; //~ ERROR cannot find trait `N` in trait `Tr`
@@ -52,5 +52,5 @@ fn main() {
     let _: <u8 as Dr>::Z; //~ ERROR expected associated type, found associated function `Dr::Z`
     <u8 as Dr>::X; //~ ERROR expected method or associated constant, found associated type `Dr::X`
     let _: <u8 as Dr>::Z::N; //~ ERROR expected associated type, found associated function `Dr::Z`
-    <u8 as Dr>::X::N; //~ ERROR no associated item named `N` found for type `u16`
+    <u8 as Dr>::X::N; //~ ERROR no associated function or constant named `N` found for type `u16`
 }
diff --git a/tests/ui/ufcs/ufcs-partially-resolved.stderr b/tests/ui/ufcs/ufcs-partially-resolved.stderr
index e1df200feccf..9efadec872b3 100644
--- a/tests/ui/ufcs/ufcs-partially-resolved.stderr
+++ b/tests/ui/ufcs/ufcs-partially-resolved.stderr
@@ -335,17 +335,17 @@ LL -     let _: <u8 as Tr>::Y::NN;
 LL +     let _: <<u8 as Tr>::Y as Example>::NN;
    |
 
-error[E0599]: no associated item named `NN` found for type `u16` in the current scope
+error[E0599]: no associated function or constant named `NN` found for type `u16` in the current scope
   --> $DIR/ufcs-partially-resolved.rs:38:20
    |
 LL |     <u8 as Tr>::Y::NN;
-   |                    ^^ associated item not found in `u16`
+   |                    ^^ associated function or constant not found in `u16`
 
-error[E0599]: no associated item named `N` found for type `u16` in the current scope
+error[E0599]: no associated function or constant named `N` found for type `u16` in the current scope
   --> $DIR/ufcs-partially-resolved.rs:55:20
    |
 LL |     <u8 as Dr>::X::N;
-   |                    ^ associated item not found in `u16`
+   |                    ^ associated function or constant not found in `u16`
 
 error: aborting due to 32 previous errors
 

From 94ed03acb552ff4bb2801d090df5f760bc9bcb74 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Tue, 24 Mar 2026 14:00:46 +0300
Subject: [PATCH 0996/1059] Make typeck a tcx method which calls typeck_root
 query

---
 compiler/rustc_hir_typeck/src/lib.rs          | 18 ++++++++++--------
 .../rustc_incremental/src/persist/clean.rs    |  2 +-
 compiler/rustc_middle/src/queries.rs          |  4 ++--
 compiler/rustc_middle/src/query/plumbing.rs   | 19 +++++++++++++++++--
 src/librustdoc/core.rs                        | 13 ++++---------
 5 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 6cfcdfe87480..fe8a9a9fb4f7 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -82,7 +82,7 @@ fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDef
     &tcx.typeck(def_id).used_trait_imports
 }
 
-fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
+fn typeck_root<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
     typeck_with_inspect(tcx, def_id, None)
 }
 
@@ -95,6 +95,13 @@ pub fn inspect_typeck<'tcx>(
     def_id: LocalDefId,
     inspect: ObligationInspector<'tcx>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
+    // Closures' typeck results come from their outermost function,
+    // as they are part of the same "inference environment".
+    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
+    if typeck_root_def_id != def_id {
+        return tcx.typeck(typeck_root_def_id);
+    }
+
     typeck_with_inspect(tcx, def_id, Some(inspect))
 }
 
@@ -104,12 +111,7 @@ fn typeck_with_inspect<'tcx>(
     def_id: LocalDefId,
     inspector: Option<ObligationInspector<'tcx>>,
 ) -> &'tcx ty::TypeckResults<'tcx> {
-    // Closures' typeck results come from their outermost function,
-    // as they are part of the same "inference environment".
-    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
-    if typeck_root_def_id != def_id {
-        return tcx.typeck(typeck_root_def_id);
-    }
+    assert!(!tcx.is_typeck_child(def_id.to_def_id()));
 
     let id = tcx.local_def_id_to_hir_id(def_id);
     let node = tcx.hir_node(id);
@@ -660,7 +662,7 @@ fn fatally_break_rust(tcx: TyCtxt<'_>, span: Span) -> ! {
 pub fn provide(providers: &mut Providers) {
     *providers = Providers {
         method_autoderef_steps: method::probe::method_autoderef_steps,
-        typeck,
+        typeck_root,
         used_trait_imports,
         check_transmutes: intrinsicck::check_transmutes,
         ..*providers
diff --git a/compiler/rustc_incremental/src/persist/clean.rs b/compiler/rustc_incremental/src/persist/clean.rs
index ab336a69737a..e999404c6cc8 100644
--- a/compiler/rustc_incremental/src/persist/clean.rs
+++ b/compiler/rustc_incremental/src/persist/clean.rs
@@ -49,7 +49,7 @@
     label_strs::type_of,
     // And a big part of compilation (that we eventually want to cache) is type inference
     // information:
-    label_strs::typeck,
+    label_strs::typeck_root,
 ];
 
 /// DepNodes for Hir, which is pretty much everything
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
index 3572e3ff35cb..7537a4fc6b0e 100644
--- a/compiler/rustc_middle/src/queries.rs
+++ b/compiler/rustc_middle/src/queries.rs
@@ -1222,9 +1222,9 @@
         separate_provide_extern
     }
 
-    query typeck(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
+    query typeck_root(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
         desc { "type-checking `{}`", tcx.def_path_str(key) }
-        cache_on_disk_if { !tcx.is_typeck_child(key.to_def_id()) }
+        cache_on_disk_if { true }
     }
 
     query used_trait_imports(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index ef6259b1a0c1..e5c7d994b6c8 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -7,14 +7,15 @@
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::sync::{AtomicU64, Lock, WorkerLocal};
 use rustc_errors::Diag;
+use rustc_hir::def_id::LocalDefId;
 use rustc_span::Span;
 
 use crate::dep_graph::{DepKind, DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
-use crate::query::{QueryCache, QueryJob, QueryStackFrame};
-use crate::ty::TyCtxt;
+use crate::query::{IntoQueryKey, QueryCache, QueryJob, QueryStackFrame};
+use crate::ty::{self, TyCtxt};
 
 /// For a particular query, keeps track of "active" keys, i.e. keys whose
 /// evaluation has started but has not yet finished successfully.
@@ -200,7 +201,21 @@ pub struct TyCtxtEnsureDone<'tcx> {
     pub tcx: TyCtxt<'tcx>,
 }
 
+impl<'tcx> TyCtxtEnsureOk<'tcx> {
+    pub fn typeck(self, def_id: impl IntoQueryKey<LocalDefId>) {
+        self.typeck_root(
+            self.tcx.typeck_root_def_id(def_id.into_query_key().to_def_id()).expect_local(),
+        )
+    }
+}
+
 impl<'tcx> TyCtxt<'tcx> {
+    pub fn typeck(self, def_id: impl IntoQueryKey<LocalDefId>) -> &'tcx ty::TypeckResults<'tcx> {
+        self.typeck_root(
+            self.typeck_root_def_id(def_id.into_query_key().to_def_id()).expect_local(),
+        )
+    }
+
     /// Returns a transparent wrapper for `TyCtxt` which uses
     /// `span` as the location of queries performed through it.
     #[inline(always)]
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index a875d6d00221..42d7237f68e5 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -309,19 +309,14 @@ pub(crate) fn create_config(
                 &EMPTY_SET
             };
             // In case typeck does end up being called, don't ICE in case there were name resolution errors
-            providers.queries.typeck = move |tcx, def_id| {
-                // Closures' tables come from their outermost function,
-                // as they are part of the same "inference environment".
-                // This avoids emitting errors for the parent twice (see similar code in `typeck_with_fallback`)
-                let typeck_root_def_id = tcx.typeck_root_def_id(def_id.to_def_id()).expect_local();
-                if typeck_root_def_id != def_id {
-                    return tcx.typeck(typeck_root_def_id);
-                }
+            providers.queries.typeck_root = move |tcx, def_id| {
+                // Panic before code below breaks in case of someone calls typeck_root directly
+                assert!(!tcx.is_typeck_child(def_id.to_def_id()));
 
                 let body = tcx.hir_body_owned_by(def_id);
                 debug!("visiting body for {def_id:?}");
                 EmitIgnoredResolutionErrors::new(tcx).visit_body(body);
-                (rustc_interface::DEFAULT_QUERY_PROVIDERS.queries.typeck)(tcx, def_id)
+                (rustc_interface::DEFAULT_QUERY_PROVIDERS.queries.typeck_root)(tcx, def_id)
             };
         }),
         extra_symbols: Vec::new(),

From 26c75dfccf8e102c00067897dcac4864b22656e6 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Wed, 25 Mar 2026 11:56:49 +0300
Subject: [PATCH 0997/1059] Rename typeck into typeck_root in tests/ui

---
 .../dep-graph/dep-graph-assoc-type-codegen.rs |  2 +-
 .../dep-graph-assoc-type-codegen.stderr       |  4 ++--
 tests/ui/dep-graph/dep-graph-caller-callee.rs |  4 ++--
 .../dep-graph/dep-graph-caller-callee.stderr  | 10 ++++-----
 .../dep-graph/dep-graph-struct-signature.rs   | 10 ++++-----
 .../dep-graph-struct-signature.stderr         | 22 +++++++++----------
 ...graph-trait-impl-two-traits-same-method.rs |  4 ++--
 ...h-trait-impl-two-traits-same-method.stderr | 10 ++++-----
 .../dep-graph-trait-impl-two-traits.rs        |  4 ++--
 .../dep-graph-trait-impl-two-traits.stderr    | 12 +++++-----
 tests/ui/dep-graph/dep-graph-trait-impl.rs    | 10 ++++-----
 .../ui/dep-graph/dep-graph-trait-impl.stderr  | 22 +++++++++----------
 tests/ui/dep-graph/dep-graph-type-alias.rs    |  4 ++--
 .../ui/dep-graph/dep-graph-type-alias.stderr  |  8 +++----
 tests/ui/track-diagnostics/track.stderr       |  2 +-
 15 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
index e04975f9c99b..8b87499966de 100644
--- a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
+++ b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.rs
@@ -26,7 +26,7 @@ mod x {
 mod y {
     use crate::Foo;
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn use_char_assoc() {
         // Careful here: in the representation, <char as Foo>::T gets
         // normalized away, so at a certain point we had no edge to
diff --git a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
index b0372051f026..1a56d3181884 100644
--- a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
+++ b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
@@ -1,8 +1,8 @@
 error: OK
   --> $DIR/dep-graph-assoc-type-codegen.rs:29:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/dep-graph/dep-graph-caller-callee.rs b/tests/ui/dep-graph/dep-graph-caller-callee.rs
index df959a93c9c2..43d10cd57cdb 100644
--- a/tests/ui/dep-graph/dep-graph-caller-callee.rs
+++ b/tests/ui/dep-graph/dep-graph-caller-callee.rs
@@ -18,7 +18,7 @@ mod y {
     use crate::x;
 
     // These dependencies SHOULD exist:
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn y() {
         x::x();
     }
@@ -29,7 +29,7 @@ mod z {
 
     // These are expected to yield errors, because changes to `x`
     // affect the BODY of `y`, but not its signature.
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path
     pub fn z() {
         y::y();
     }
diff --git a/tests/ui/dep-graph/dep-graph-caller-callee.stderr b/tests/ui/dep-graph/dep-graph-caller-callee.stderr
index 33fe91b3500a..379e23fc9a27 100644
--- a/tests/ui/dep-graph/dep-graph-caller-callee.stderr
+++ b/tests/ui/dep-graph/dep-graph-caller-callee.stderr
@@ -1,14 +1,14 @@
 error: OK
   --> $DIR/dep-graph-caller-callee.rs:21:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
-error: no path from `x` to `typeck`
+error: no path from `x` to `typeck_root`
   --> $DIR/dep-graph-caller-callee.rs:32:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/dep-graph/dep-graph-struct-signature.rs b/tests/ui/dep-graph/dep-graph-struct-signature.rs
index 080a1b5c583d..abef7d2e9884 100644
--- a/tests/ui/dep-graph/dep-graph-struct-signature.rs
+++ b/tests/ui/dep-graph/dep-graph-struct-signature.rs
@@ -34,11 +34,11 @@ trait Bar {
     }
 
     #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     fn some_fn(x: WillChange) { }
 
     #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     fn new_foo(x: u32, y: u32) -> WillChange {
         WillChange { x: x, y: y }
     }
@@ -46,14 +46,14 @@ fn new_foo(x: u32, y: u32) -> WillChange {
     #[rustc_then_this_would_need(type_of)] //~ ERROR OK
     impl WillChange {
         #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-        #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+        #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
         fn new(x: u32, y: u32) -> WillChange { loop { } }
     }
 
     #[rustc_then_this_would_need(type_of)] //~ ERROR OK
     impl WillChange {
         #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-        #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+        #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
         fn method(&self, x: u32) { }
     }
 
@@ -82,6 +82,6 @@ trait A {
     fn b(x: WontChange) { }
 
     #[rustc_then_this_would_need(fn_sig)] //~ ERROR no path from `WillChange`
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path from `WillChange`
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path from `WillChange`
     fn c(x: u32) { }
 }
diff --git a/tests/ui/dep-graph/dep-graph-struct-signature.stderr b/tests/ui/dep-graph/dep-graph-struct-signature.stderr
index 98efedc7244c..24d35b87820d 100644
--- a/tests/ui/dep-graph/dep-graph-struct-signature.stderr
+++ b/tests/ui/dep-graph/dep-graph-struct-signature.stderr
@@ -25,8 +25,8 @@ LL |     #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:37:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:40:34
@@ -37,8 +37,8 @@ LL |     #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:41:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:46:34
@@ -88,11 +88,11 @@ error: no path from `WillChange` to `fn_sig`
 LL |     #[rustc_then_this_would_need(fn_sig)]
    |                                  ^^^^^^
 
-error: no path from `WillChange` to `typeck`
+error: no path from `WillChange` to `typeck_root`
   --> $DIR/dep-graph-struct-signature.rs:85:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:32:38
@@ -115,8 +115,8 @@ LL |         #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:49:38
    |
-LL |         #[rustc_then_this_would_need(typeck)]
-   |                                      ^^^^^^
+LL |         #[rustc_then_this_would_need(typeck_root)]
+   |                                      ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:55:38
@@ -127,8 +127,8 @@ LL |         #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-struct-signature.rs:56:38
    |
-LL |         #[rustc_then_this_would_need(typeck)]
-   |                                      ^^^^^^
+LL |         #[rustc_then_this_would_need(typeck_root)]
+   |                                      ^^^^^^^^^^^
 
 error: aborting due to 22 previous errors
 
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
index 397a8c6a39d4..ccdd2ff570f6 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
+++ b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.rs
@@ -30,7 +30,7 @@ impl Bar for char { }
 mod y {
     use crate::{Foo, Bar};
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
@@ -39,7 +39,7 @@ pub fn with_char() {
 mod z {
     use crate::y;
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path
     pub fn z() {
         y::with_char();
     }
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.stderr b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.stderr
index 293f918a3187..9802d5acce18 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.stderr
+++ b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits-same-method.stderr
@@ -1,14 +1,14 @@
 error: OK
   --> $DIR/dep-graph-trait-impl-two-traits-same-method.rs:33:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
-error: no path from `x::<impl Foo for u32>` to `typeck`
+error: no path from `x::<impl Foo for u32>` to `typeck_root`
   --> $DIR/dep-graph-trait-impl-two-traits-same-method.rs:42:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.rs b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.rs
index 859505a4a7a1..c86923c0468b 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.rs
+++ b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.rs
@@ -29,7 +29,7 @@ impl Bar for char { }
 mod y {
     use crate::{Foo, Bar};
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path
     pub fn call_bar() {
         char::bar('a');
     }
@@ -38,7 +38,7 @@ pub fn call_bar() {
 mod z {
     use crate::y;
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path
     pub fn z() {
         y::call_bar();
     }
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.stderr b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.stderr
index 46cb0e9ea86f..7d7ff0543cb3 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.stderr
+++ b/tests/ui/dep-graph/dep-graph-trait-impl-two-traits.stderr
@@ -1,14 +1,14 @@
-error: no path from `x::<impl Foo for char>` to `typeck`
+error: no path from `x::<impl Foo for char>` to `typeck_root`
   --> $DIR/dep-graph-trait-impl-two-traits.rs:32:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
-error: no path from `x::<impl Foo for char>` to `typeck`
+error: no path from `x::<impl Foo for char>` to `typeck_root`
   --> $DIR/dep-graph-trait-impl-two-traits.rs:41:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl.rs b/tests/ui/dep-graph/dep-graph-trait-impl.rs
index 80925ddfe0c0..952ccf61c7d5 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl.rs
+++ b/tests/ui/dep-graph/dep-graph-trait-impl.rs
@@ -25,22 +25,22 @@ impl Foo for u32 { }
 mod y {
     use crate::Foo;
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn take_foo_with_char() {
         take_foo::<char>('a');
     }
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn with_u32() {
         u32::method(22);
     }
 
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     pub fn take_foo_with_u32() {
         take_foo::<u32>(22);
     }
@@ -53,7 +53,7 @@ mod z {
 
     // These are expected to yield errors, because changes to `x`
     // affect the BODY of `y`, but not its signature.
-    #[rustc_then_this_would_need(typeck)] //~ ERROR no path
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR no path
     pub fn z() {
         y::with_char();
         y::with_u32();
diff --git a/tests/ui/dep-graph/dep-graph-trait-impl.stderr b/tests/ui/dep-graph/dep-graph-trait-impl.stderr
index a5fce64c3a1c..8a205feb774b 100644
--- a/tests/ui/dep-graph/dep-graph-trait-impl.stderr
+++ b/tests/ui/dep-graph/dep-graph-trait-impl.stderr
@@ -1,32 +1,32 @@
 error: OK
   --> $DIR/dep-graph-trait-impl.rs:28:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-trait-impl.rs:33:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-trait-impl.rs:38:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-trait-impl.rs:43:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
-error: no path from `x::<impl Foo for char>` to `typeck`
+error: no path from `x::<impl Foo for char>` to `typeck_root`
   --> $DIR/dep-graph-trait-impl.rs:56:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/dep-graph/dep-graph-type-alias.rs b/tests/ui/dep-graph/dep-graph-type-alias.rs
index 1796ebda1fc7..8d0407a74ca8 100644
--- a/tests/ui/dep-graph/dep-graph-type-alias.rs
+++ b/tests/ui/dep-graph/dep-graph-type-alias.rs
@@ -42,7 +42,7 @@ trait Trait {
 #[rustc_then_this_would_need(type_of)] //~ ERROR no path
 impl SomeType {
     #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-    #[rustc_then_this_would_need(typeck)] //~ ERROR OK
+    #[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
     fn method(&self, _: TypeAlias) {}
 }
 
@@ -50,7 +50,7 @@ fn method(&self, _: TypeAlias) {}
 type TypeAlias2 = TypeAlias;
 
 #[rustc_then_this_would_need(fn_sig)] //~ ERROR OK
-#[rustc_then_this_would_need(typeck)] //~ ERROR OK
+#[rustc_then_this_would_need(typeck_root)] //~ ERROR OK
 fn function(_: TypeAlias) {
 
 }
diff --git a/tests/ui/dep-graph/dep-graph-type-alias.stderr b/tests/ui/dep-graph/dep-graph-type-alias.stderr
index 9f24c1113b98..63312a5f249d 100644
--- a/tests/ui/dep-graph/dep-graph-type-alias.stderr
+++ b/tests/ui/dep-graph/dep-graph-type-alias.stderr
@@ -49,8 +49,8 @@ LL | #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-type-alias.rs:53:30
    |
-LL | #[rustc_then_this_would_need(typeck)]
-   |                              ^^^^^^
+LL | #[rustc_then_this_would_need(typeck_root)]
+   |                              ^^^^^^^^^^^
 
 error: OK
   --> $DIR/dep-graph-type-alias.rs:36:34
@@ -67,8 +67,8 @@ LL |     #[rustc_then_this_would_need(fn_sig)]
 error: OK
   --> $DIR/dep-graph-type-alias.rs:45:34
    |
-LL |     #[rustc_then_this_would_need(typeck)]
-   |                                  ^^^^^^
+LL |     #[rustc_then_this_would_need(typeck_root)]
+   |                                  ^^^^^^^^^^^
 
 error: aborting due to 12 previous errors
 
diff --git a/tests/ui/track-diagnostics/track.stderr b/tests/ui/track-diagnostics/track.stderr
index ba314c14b37e..9ac567436939 100644
--- a/tests/ui/track-diagnostics/track.stderr
+++ b/tests/ui/track-diagnostics/track.stderr
@@ -40,7 +40,7 @@ note: rustc $VERSION running on $TARGET
 note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics
 
 query stack during panic:
-#0 [typeck] type-checking `main`
+#0 [typeck_root] type-checking `main`
 #1 [analysis] running analysis passes on crate `track`
 end of query stack
 error: aborting due to 3 previous errors

From 5cf7376aac506122c466ecdb569b431636e0b5e9 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Wed, 25 Mar 2026 13:37:51 +0300
Subject: [PATCH 0998/1059] Rename typeck into typeck_root in tests/incremental

---
 .../callee_caller_cross_crate/b.rs            |  2 +-
 .../change_add_field/struct_point.rs          | 12 +--
 tests/incremental/change_crate_order/main.rs  |  2 +-
 .../change_private_fn/struct_point.rs         |  4 +-
 .../struct_point.rs                           |  2 +-
 tests/incremental/clean.rs                    |  6 +-
 tests/incremental/hashes/call_expressions.rs  | 24 +++---
 .../incremental/hashes/closure_expressions.rs | 16 ++--
 tests/incremental/hashes/enum_constructors.rs | 36 ++++-----
 tests/incremental/hashes/for_loops.rs         |  8 +-
 .../incremental/hashes/function_interfaces.rs | 38 +++++-----
 tests/incremental/hashes/if_expressions.rs    | 20 ++---
 .../hashes/indexing_expressions.rs            | 16 ++--
 tests/incremental/hashes/inherent_impls.rs    | 76 +++++++++----------
 tests/incremental/hashes/let_expressions.rs   | 36 ++++-----
 tests/incremental/hashes/loop_expressions.rs  | 12 +--
 tests/incremental/hashes/match_expressions.rs | 36 ++++-----
 .../incremental/hashes/struct_constructors.rs | 28 +++----
 tests/incremental/hashes/trait_defs.rs        |  4 +-
 tests/incremental/hashes/trait_impls.rs       | 36 ++++-----
 .../hashes/unary_and_binary_exprs.rs          |  4 +-
 tests/incremental/hashes/while_let_loops.rs   |  4 +-
 tests/incremental/hashes/while_loops.rs       |  4 +-
 .../hygiene/auxiliary/cached_hygiene.rs       |  2 +-
 .../ich_method_call_trait_scope.rs            |  2 +-
 tests/incremental/ich_resolve_results.rs      |  4 +-
 tests/incremental/issue-42602.rs              |  2 +-
 tests/incremental/rlib_cross_crate/b.rs       |  2 +-
 tests/incremental/string_constant.rs          |  2 +-
 tests/incremental/struct_add_field.rs         |  4 +-
 tests/incremental/struct_change_field_name.rs |  4 +-
 tests/incremental/struct_change_field_type.rs |  4 +-
 .../struct_change_field_type_cross_crate/b.rs |  4 +-
 tests/incremental/struct_remove_field.rs      |  4 +-
 tests/incremental/type_alias_cross_crate/b.rs |  2 +-
 35 files changed, 231 insertions(+), 231 deletions(-)

diff --git a/tests/incremental/callee_caller_cross_crate/b.rs b/tests/incremental/callee_caller_cross_crate/b.rs
index 78f3d8b3958f..ebdecf5b0a16 100644
--- a/tests/incremental/callee_caller_cross_crate/b.rs
+++ b/tests/incremental/callee_caller_cross_crate/b.rs
@@ -7,7 +7,7 @@
 
 extern crate a;
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn call_function0() {
     a::function0(77);
 }
diff --git a/tests/incremental/change_add_field/struct_point.rs b/tests/incremental/change_add_field/struct_point.rs
index 024812bd4beb..142a8e7533e4 100644
--- a/tests/incremental/change_add_field/struct_point.rs
+++ b/tests/incremental/change_add_field/struct_point.rs
@@ -70,7 +70,7 @@ pub fn x(&self) -> f32 {
 pub mod fn_with_type_in_sig {
     use point::Point;
 
-    #[rustc_clean(except="typeck,fn_sig,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,fn_sig,optimized_mir", cfg="cfail2")]
     pub fn boop(p: Option<&Point>) -> f32 {
         p.map(|p| p.total()).unwrap_or(0.0)
     }
@@ -86,7 +86,7 @@ pub fn boop(p: Option<&Point>) -> f32 {
 pub mod call_fn_with_type_in_sig {
     use fn_with_type_in_sig;
 
-    #[rustc_clean(except="typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,optimized_mir", cfg="cfail2")]
     pub fn bip() -> f32 {
         fn_with_type_in_sig::boop(None)
     }
@@ -102,7 +102,7 @@ pub fn bip() -> f32 {
 pub mod fn_with_type_in_body {
     use point::Point;
 
-    #[rustc_clean(except="typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,optimized_mir", cfg="cfail2")]
     pub fn boop() -> f32 {
         Point::origin().total()
     }
@@ -125,7 +125,7 @@ pub fn bip() -> f32 {
 pub mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(except="typeck,fn_sig,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,fn_sig,optimized_mir", cfg="cfail2")]
     pub fn make_origin(p: Point) -> Point {
         Point { ..p }
     }
@@ -135,7 +135,7 @@ pub fn make_origin(p: Point) -> Point {
 pub mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(except="typeck,fn_sig,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,fn_sig,optimized_mir", cfg="cfail2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -145,7 +145,7 @@ pub fn get_x(p: Point) -> f32 {
 pub mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(except="typeck,fn_sig,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,fn_sig,optimized_mir", cfg="cfail2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }
diff --git a/tests/incremental/change_crate_order/main.rs b/tests/incremental/change_crate_order/main.rs
index 38a2541a76b5..b5e05c244e07 100644
--- a/tests/incremental/change_crate_order/main.rs
+++ b/tests/incremental/change_crate_order/main.rs
@@ -19,7 +19,7 @@
 use a::A;
 use b::B;
 
-//? #[rustc_clean(label="typeck", cfg="rpass2")]
+//? #[rustc_clean(label="typeck_root", cfg="rpass2")]
 pub fn main() {
     A + B;
 }
diff --git a/tests/incremental/change_private_fn/struct_point.rs b/tests/incremental/change_private_fn/struct_point.rs
index 2c2560309d27..eac1def3348d 100644
--- a/tests/incremental/change_private_fn/struct_point.rs
+++ b/tests/incremental/change_private_fn/struct_point.rs
@@ -54,8 +54,8 @@ pub mod fn_calls_methods_in_same_impl {
     // The cached result should actually be loaded from disk
     // (not just marked green) - for example, `DeadVisitor`
     // always runs during compilation as a "pass", and loads
-    // the typeck results for bodies.
-    #[rustc_clean(cfg="cfail2", loaded_from_disk="typeck")]
+    // the typeck_root results for bodies.
+    #[rustc_clean(cfg="cfail2", loaded_from_disk="typeck_root")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
diff --git a/tests/incremental/change_pub_inherent_method_sig/struct_point.rs b/tests/incremental/change_pub_inherent_method_sig/struct_point.rs
index 5c24199df6aa..e9778ed9dd5d 100644
--- a/tests/incremental/change_pub_inherent_method_sig/struct_point.rs
+++ b/tests/incremental/change_pub_inherent_method_sig/struct_point.rs
@@ -52,7 +52,7 @@ pub fn x(&self) -> f32 {
 pub mod fn_calls_changed_method {
     use point::Point;
 
-    #[rustc_clean(except="typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root,optimized_mir", cfg="cfail2")]
     pub fn check() {
         let p = Point { x: 2.0, y: 2.0 };
         p.distance_from_point(None);
diff --git a/tests/incremental/clean.rs b/tests/incremental/clean.rs
index 1188b46fa0ad..25aa25addfcd 100644
--- a/tests/incremental/clean.rs
+++ b/tests/incremental/clean.rs
@@ -36,14 +36,14 @@ pub fn y() {
         //[cfail2]~| ERROR `predicates_of(y)` should be dirty but is not
         //[cfail2]~| ERROR `type_of(y)` should be dirty but is not
         //[cfail2]~| ERROR `fn_sig(y)` should be dirty but is not
-        //[cfail2]~| ERROR `typeck(y)` should be clean but is not
+        //[cfail2]~| ERROR `typeck_root(y)` should be clean but is not
         x::x();
     }
 }
 
 mod z {
-    #[rustc_clean(except="typeck", cfg="cfail2")]
+    #[rustc_clean(except="typeck_root", cfg="cfail2")]
     pub fn z() {
-        //[cfail2]~^ ERROR `typeck(z)` should be dirty but is not
+        //[cfail2]~^ ERROR `typeck_root(z)` should be dirty but is not
     }
 }
diff --git a/tests/incremental/hashes/call_expressions.rs b/tests/incremental/hashes/call_expressions.rs
index d58bf0416c6f..f106519f0373 100644
--- a/tests/incremental/hashes/call_expressions.rs
+++ b/tests/incremental/hashes/call_expressions.rs
@@ -29,9 +29,9 @@ pub fn change_callee_function() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_callee_function() {
     callee2(1, 2)
@@ -63,9 +63,9 @@ mod change_callee_indirectly_function {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::callee2 as callee;
 
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     pub fn change_callee_indirectly_function() {
         callee(1, 2)
@@ -87,9 +87,9 @@ pub fn change_callee_method() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_callee_method() {
     let s = Struct;
@@ -125,9 +125,9 @@ pub fn change_ufcs_callee_method() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_ufcs_callee_method() {
     let s = Struct;
@@ -163,9 +163,9 @@ pub fn change_to_ufcs() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 // One might think this would be expanded in the opt_hir_owner_nodes/Mir, but it actually
 // results in slightly different hir_owner/Mir.
@@ -187,9 +187,9 @@ pub mod change_ufcs_callee_indirectly {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::Struct2 as Struct;
 
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn change_ufcs_callee_indirectly() {
         let s = Struct;
diff --git a/tests/incremental/hashes/closure_expressions.rs b/tests/incremental/hashes/closure_expressions.rs
index 3cda661834f5..0d9f62c90df0 100644
--- a/tests/incremental/hashes/closure_expressions.rs
+++ b/tests/incremental/hashes/closure_expressions.rs
@@ -43,9 +43,9 @@ pub fn add_parameter() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_parameter() {
     let x = 0u32;
@@ -61,9 +61,9 @@ pub fn change_parameter_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_parameter_pattern() {
     let _ = |(x,): (u32,)| x;
@@ -96,9 +96,9 @@ pub fn add_type_ascription_to_parameter() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg = "cfail3")]
-#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg = "cfail6")]
 pub fn add_type_ascription_to_parameter() {
     let closure = |x: u32| x + 1u32;
@@ -115,9 +115,9 @@ pub fn change_parameter_type() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_parameter_type() {
     let closure = |x: u16| (x as u64) + 1;
diff --git a/tests/incremental/hashes/enum_constructors.rs b/tests/incremental/hashes/enum_constructors.rs
index 5962727b3af0..4c6971eabd1e 100644
--- a/tests/incremental/hashes/enum_constructors.rs
+++ b/tests/incremental/hashes/enum_constructors.rs
@@ -63,9 +63,9 @@ pub fn change_field_order_struct_like() -> Enum {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 // FIXME(michaelwoerister):Interesting. I would have thought that that changes the MIR. And it
 // would if it were not all constants
@@ -104,9 +104,9 @@ pub fn change_constructor_path_struct_like() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_path_struct_like() {
     let _ = Enum2::Struct {
@@ -149,9 +149,9 @@ pub mod change_constructor_path_indirectly_struct_like {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::Enum2 as TheEnum;
 
-    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn function() -> TheEnum {
         TheEnum::Struct {
@@ -211,12 +211,12 @@ pub fn change_constructor_path_tuple_like() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg="cfail2",
-    except="opt_hir_owner_nodes,typeck"
+    except="opt_hir_owner_nodes,typeck_root"
 )]
 #[rustc_clean(cfg="cfail3")]
 #[rustc_clean(
     cfg="cfail5",
-    except="opt_hir_owner_nodes,typeck"
+    except="opt_hir_owner_nodes,typeck_root"
 )]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_path_tuple_like() {
@@ -234,12 +234,12 @@ pub fn change_constructor_variant_tuple_like() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg="cfail2",
-    except="opt_hir_owner_nodes,typeck"
+    except="opt_hir_owner_nodes,typeck_root"
 )]
 #[rustc_clean(cfg="cfail3")]
 #[rustc_clean(
     cfg="cfail5",
-    except="opt_hir_owner_nodes,typeck"
+    except="opt_hir_owner_nodes,typeck_root"
 )]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_variant_tuple_like() {
@@ -254,9 +254,9 @@ pub mod change_constructor_path_indirectly_tuple_like {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::Enum2 as TheEnum;
 
-    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn function() -> TheEnum {
         TheEnum::Tuple(0, 1, 2)
@@ -273,9 +273,9 @@ pub mod change_constructor_variant_indirectly_tuple_like {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::Enum2::Tuple2 as Variant;
 
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn function() -> Enum2 {
         Variant(0, 1, 2)
@@ -302,9 +302,9 @@ pub fn change_constructor_path_c_like() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_path_c_like() {
     let _x = Clike2::B;
@@ -335,9 +335,9 @@ pub mod change_constructor_path_indirectly_c_like {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::Clike2 as TheEnum;
 
-    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn function() -> TheEnum {
         TheEnum::B
diff --git a/tests/incremental/hashes/for_loops.rs b/tests/incremental/hashes/for_loops.rs
index 24717e0faaf5..d63f264da6e4 100644
--- a/tests/incremental/hashes/for_loops.rs
+++ b/tests/incremental/hashes/for_loops.rs
@@ -79,9 +79,9 @@ pub fn change_iteration_variable_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_iteration_variable_pattern() {
     let mut _x = 0;
@@ -129,9 +129,9 @@ pub fn add_break() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_break() {
     let mut _x = 0;
diff --git a/tests/incremental/hashes/function_interfaces.rs b/tests/incremental/hashes/function_interfaces.rs
index 5b03f9ed6c67..8c0685042dbc 100644
--- a/tests/incremental/hashes/function_interfaces.rs
+++ b/tests/incremental/hashes/function_interfaces.rs
@@ -26,12 +26,12 @@ pub fn add_parameter() {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg = "cfail2",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail3")]
 #[rustc_clean(
     cfg = "cfail5",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail6")]
 pub fn add_parameter(p: i32) {}
@@ -56,12 +56,12 @@ pub fn type_of_parameter(p: i32) {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg = "cfail2",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail3")]
 #[rustc_clean(
     cfg = "cfail5",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail6")]
 pub fn type_of_parameter(p: i64) {}
@@ -74,12 +74,12 @@ pub fn type_of_parameter_ref(p: &i32) {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg = "cfail2",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail3")]
 #[rustc_clean(
     cfg = "cfail5",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail6")]
 pub fn type_of_parameter_ref(p: &mut i32) {}
@@ -92,12 +92,12 @@ pub fn order_of_parameters(p1: i32, p2: i64) {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg = "cfail2",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail3")]
 #[rustc_clean(
     cfg = "cfail5",
-    except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail6")]
 pub fn order_of_parameters(p2: i64, p1: i32) {}
@@ -110,12 +110,12 @@ pub        fn make_unsafe() {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(
     cfg = "cfail2",
-    except = "opt_hir_owner_nodes, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail3")]
 #[rustc_clean(
     cfg = "cfail5",
-    except = "opt_hir_owner_nodes, typeck, fn_sig"
+    except = "opt_hir_owner_nodes, typeck_root, fn_sig"
 )]
 #[rustc_clean(cfg = "cfail6")]
 pub unsafe fn make_unsafe() {}
@@ -126,9 +126,9 @@ pub unsafe fn make_unsafe() {}
 pub            fn make_extern() {}
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck, fn_sig")]
+#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck_root, fn_sig")]
 #[rustc_clean(cfg = "cfail3")]
-#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck, fn_sig")]
+#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck_root, fn_sig")]
 #[rustc_clean(cfg = "cfail6")]
 pub extern "C" fn make_extern() {}
 
@@ -303,9 +303,9 @@ pub fn return_impl_trait() -> i32        {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck, fn_sig")]
+#[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes, typeck_root, fn_sig")]
 #[rustc_clean(cfg = "cfail3")]
-#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck, fn_sig, optimized_mir")]
+#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck_root, fn_sig, optimized_mir")]
 #[rustc_clean(cfg = "cfail6")]
 pub fn return_impl_trait() -> impl Clone {
     0
@@ -321,7 +321,7 @@ pub fn change_return_impl_trait() -> impl Clone {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes")]
 #[rustc_clean(cfg = "cfail3")]
-#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg = "cfail6")]
 pub fn change_return_impl_trait() -> impl  Copy {
     0u32
@@ -340,12 +340,12 @@ pub mod change_return_type_indirectly {
 
     #[rustc_clean(
         cfg = "cfail2",
-        except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+        except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
     )]
     #[rustc_clean(cfg = "cfail3")]
     #[rustc_clean(
         cfg = "cfail5",
-        except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+        except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
     )]
     #[rustc_clean(cfg = "cfail6")]
     pub fn indirect_return_type() -> ReturnType {
@@ -363,12 +363,12 @@ pub mod change_parameter_type_indirectly {
 
     #[rustc_clean(
         cfg = "cfail2",
-        except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+        except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
     )]
     #[rustc_clean(cfg = "cfail3")]
     #[rustc_clean(
         cfg = "cfail5",
-        except = "opt_hir_owner_nodes, optimized_mir, typeck, fn_sig"
+        except = "opt_hir_owner_nodes, optimized_mir, typeck_root, fn_sig"
     )]
     #[rustc_clean(cfg = "cfail6")]
     pub fn indirect_parameter_type(p: ParameterType) {}
diff --git a/tests/incremental/hashes/if_expressions.rs b/tests/incremental/hashes/if_expressions.rs
index 6a241692977f..47a50838633d 100644
--- a/tests/incremental/hashes/if_expressions.rs
+++ b/tests/incremental/hashes/if_expressions.rs
@@ -28,9 +28,9 @@ pub fn change_condition(x: bool) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_condition(x: bool) -> u32 {
     if !x {
@@ -104,9 +104,9 @@ pub fn add_else_branch(x: bool) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_else_branch(x: bool) -> u32 {
     let mut ret = 1;
@@ -132,9 +132,9 @@ pub fn change_condition_if_let(x: Option<u32>) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_condition_if_let(x: Option<u32>) -> u32 {
     if let Some(_ ) = x {
@@ -157,9 +157,9 @@ pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
     if let Some(x) = x {
@@ -210,9 +210,9 @@ pub fn add_else_branch_if_let(x: Option<u32>) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_else_branch_if_let(x: Option<u32>) -> u32 {
     let mut ret = 1;
diff --git a/tests/incremental/hashes/indexing_expressions.rs b/tests/incremental/hashes/indexing_expressions.rs
index bfc64c904039..cf056287994d 100644
--- a/tests/incremental/hashes/indexing_expressions.rs
+++ b/tests/incremental/hashes/indexing_expressions.rs
@@ -75,9 +75,9 @@ fn add_lower_bound(slice: &[u32]) -> &[u32] {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 fn add_lower_bound(slice: &[u32]) -> &[u32] {
     &slice[3..4]
@@ -92,9 +92,9 @@ fn add_upper_bound(slice: &[u32]) -> &[u32] {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 fn add_upper_bound(slice: &[u32]) -> &[u32] {
     &slice[3..7]
@@ -109,9 +109,9 @@ fn change_mutability(slice: &mut [u32]) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 fn change_mutability(slice: &mut [u32]) -> u32 {
     (&    slice[3..5])[0]
@@ -126,9 +126,9 @@ fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] {
     &slice[3..=7]
diff --git a/tests/incremental/hashes/inherent_impls.rs b/tests/incremental/hashes/inherent_impls.rs
index 75c0939fbfcd..c0d1c9a7b652 100644
--- a/tests/incremental/hashes/inherent_impls.rs
+++ b/tests/incremental/hashes/inherent_impls.rs
@@ -58,9 +58,9 @@ pub fn method_body() {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck")]
+    #[rustc_clean(cfg="cfail2",except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck")]
+    #[rustc_clean(cfg="cfail5",except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn method_body() {
         println!("Hello, world!");
@@ -89,9 +89,9 @@ pub fn method_body_inlined() {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     #[inline]
     pub fn method_body_inlined() {
@@ -147,12 +147,12 @@ pub fn method_selfness() { }
 impl Foo {
     #[rustc_clean(
         cfg="cfail2",
-        except="opt_hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir",
+        except="opt_hir_owner_nodes,fn_sig,generics_of,typeck_root,associated_item,optimized_mir",
     )]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(
         cfg="cfail5",
-        except="opt_hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir",
+        except="opt_hir_owner_nodes,fn_sig,generics_of,typeck_root,associated_item,optimized_mir",
     )]
     #[rustc_clean(cfg="cfail6")]
     pub fn method_selfness(&self) { }
@@ -174,9 +174,9 @@ pub fn method_selfmutness(&    self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
     #[rustc_clean(cfg="cfail6")]
     pub fn method_selfmutness(&mut self) { }
 }
@@ -224,9 +224,9 @@ pub fn add_method_parameter(&self        ) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
     #[rustc_clean(cfg="cfail6")]
     pub fn add_method_parameter(&self, _: i32) { }
 }
@@ -274,9 +274,9 @@ pub fn change_method_return_type(&self) -> u16 { 0 }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn change_method_return_type(&self) -> u32 { 0 }
 }
@@ -351,9 +351,9 @@ pub        fn make_method_unsafe(&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub unsafe fn make_method_unsafe(&self) { }
 }
@@ -376,9 +376,9 @@ pub            fn make_method_extern(&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub extern "C" fn make_method_extern(&self) { }
 }
@@ -401,9 +401,9 @@ pub extern "C"      fn change_method_calling_convention(&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck")]
+    #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub extern "system" fn change_method_calling_convention(&self) { }
 }
@@ -435,15 +435,15 @@ pub fn add_lifetime_parameter_to_method    (&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    // Warning: Note that `typeck` are coming up clean here.
+    // Warning: Note that `typeck_root` are coming up clean here.
     // The addition or removal of lifetime parameters that don't
     // appear in the arguments or fn body in any way does not, in
-    // fact, affect the `typeck` in any semantic way (at least
+    // fact, affect the `typeck_root` in any semantic way (at least
     // as of this writing). **However,** altering the order of
-    // lowering **can** cause it appear to affect the `typeck`:
+    // lowering **can** cause it appear to affect the `typeck_root`:
     // if we lower generics before the body, then the `HirId` for
     // things in the body will be affected. So if you start to see
-    // `typeck` appear dirty, that might be the cause. -nmatsakis
+    // `typeck_root` appear dirty, that might be the cause. -nmatsakis
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig")]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,fn_sig,generics_of")]
@@ -484,14 +484,14 @@ pub fn add_type_parameter_to_method   (&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    // Warning: Note that `typeck` are coming up clean here.
+    // Warning: Note that `typeck_root` are coming up clean here.
     // The addition or removal of type parameters that don't appear in
     // the arguments or fn body in any way does not, in fact, affect
-    // the `typeck` in any semantic way (at least as of this
+    // the `typeck_root` in any semantic way (at least as of this
     // writing). **However,** altering the order of lowering **can**
-    // cause it appear to affect the `typeck`: if we lower
+    // cause it appear to affect the `typeck_root`: if we lower
     // generics before the body, then the `HirId` for things in the
-    // body will be affected. So if you start to see `typeck`
+    // body will be affected. So if you start to see `typeck_root`
     // appear dirty, that might be the cause. -nmatsakis
     #[rustc_clean(
         cfg="cfail2",
@@ -576,14 +576,14 @@ pub fn add_lifetime_bound_to_type_param_of_method<'a, T    >(&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    // Warning: Note that `typeck` are coming up clean here.
+    // Warning: Note that `typeck_root` are coming up clean here.
     // The addition or removal of bounds that don't appear in the
     // arguments or fn body in any way does not, in fact, affect the
-    // `typeck` in any semantic way (at least as of this
+    // `typeck_root` in any semantic way (at least as of this
     // writing). **However,** altering the order of lowering **can**
-    // cause it appear to affect the `typeck`: if we lower
+    // cause it appear to affect the `typeck_root`: if we lower
     // generics before the body, then the `HirId` for things in the
-    // body will be affected. So if you start to see `typeck`
+    // body will be affected. So if you start to see `typeck_root`
     // appear dirty, that might be the cause. -nmatsakis
     #[rustc_clean(
         cfg="cfail2",
@@ -625,14 +625,14 @@ pub fn add_trait_bound_to_type_param_of_method<T       >(&self) { }
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
-    // Warning: Note that `typeck` are coming up clean here.
+    // Warning: Note that `typeck_root` are coming up clean here.
     // The addition or removal of bounds that don't appear in the
     // arguments or fn body in any way does not, in fact, affect the
-    // `typeck` in any semantic way (at least as of this
+    // `typeck_root` in any semantic way (at least as of this
     // writing). **However,** altering the order of lowering **can**
-    // cause it appear to affect the `typeck`: if we lower
+    // cause it appear to affect the `typeck_root`: if we lower
     // generics before the body, then the `HirId` for things in the
-    // body will be affected. So if you start to see `typeck`
+    // body will be affected. So if you start to see `typeck_root`
     // appear dirty, that might be the cause. -nmatsakis
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,predicates_of")]
     #[rustc_clean(cfg="cfail3")]
@@ -686,12 +686,12 @@ pub fn add_type_parameter_to_impl(&self) { }
 impl<T> Bar<T> {
     #[rustc_clean(
         cfg="cfail2",
-        except="generics_of,fn_sig,typeck,type_of,optimized_mir"
+        except="generics_of,fn_sig,typeck_root,type_of,optimized_mir"
     )]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(
         cfg="cfail5",
-        except="generics_of,fn_sig,typeck,type_of,optimized_mir"
+        except="generics_of,fn_sig,typeck_root,type_of,optimized_mir"
     )]
     #[rustc_clean(cfg="cfail6")]
     pub fn add_type_parameter_to_impl(&self) { }
@@ -711,9 +711,9 @@ pub fn change_impl_self_type(&self) { }
 #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes")]
 #[rustc_clean(cfg="cfail6")]
 impl Bar<u64> {
-    #[rustc_clean(cfg="cfail2", except="fn_sig,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="fn_sig,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn change_impl_self_type(&self) { }
 }
diff --git a/tests/incremental/hashes/let_expressions.rs b/tests/incremental/hashes/let_expressions.rs
index b2e89380acb3..155132b63856 100644
--- a/tests/incremental/hashes/let_expressions.rs
+++ b/tests/incremental/hashes/let_expressions.rs
@@ -41,9 +41,9 @@ pub fn add_type() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_type() {
     let _x: u32 = 2u32;
@@ -58,9 +58,9 @@ pub fn change_type() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_type() {
     let _x: u8  = 2;
@@ -75,9 +75,9 @@ pub fn change_mutability_of_reference_type() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_mutability_of_reference_type() {
     let _x: &mut u64;
@@ -92,9 +92,9 @@ pub fn change_mutability_of_slot() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_mutability_of_slot() {
     let     _x: u64 = 0;
@@ -109,9 +109,9 @@ pub fn change_simple_binding_to_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_simple_binding_to_pattern() {
     let (_a, _b) = (0u8, 'x');
@@ -143,9 +143,9 @@ pub fn add_ref_in_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_ref_in_pattern() {
     let (ref _a, _b) = (1u8, 'y');
@@ -160,9 +160,9 @@ pub fn add_amp_in_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_amp_in_pattern() {
     let (&_a, _b) = (&1u8, 'y');
@@ -177,9 +177,9 @@ pub fn change_mutability_of_binding_in_pattern() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_mutability_of_binding_in_pattern() {
     let (mut _a, _b) = (99u8, 'q');
@@ -194,9 +194,9 @@ pub fn add_initializer() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root,optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_initializer() {
     let _x: i16 = 3i16;
diff --git a/tests/incremental/hashes/loop_expressions.rs b/tests/incremental/hashes/loop_expressions.rs
index a8b89217b949..da03fb17680a 100644
--- a/tests/incremental/hashes/loop_expressions.rs
+++ b/tests/incremental/hashes/loop_expressions.rs
@@ -54,9 +54,9 @@ pub fn add_break() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_break() {
     let mut _x = 0;
@@ -131,9 +131,9 @@ pub fn change_break_label() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_break_label() {
     let mut _x = 0;
@@ -212,9 +212,9 @@ pub fn change_continue_to_break() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck, optimized_mir")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck_root, optimized_mir")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck, optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck_root, optimized_mir")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_continue_to_break() {
     let mut _x = 0;
diff --git a/tests/incremental/hashes/match_expressions.rs b/tests/incremental/hashes/match_expressions.rs
index 0c7f847932b8..b6d753ac8a08 100644
--- a/tests/incremental/hashes/match_expressions.rs
+++ b/tests/incremental/hashes/match_expressions.rs
@@ -29,9 +29,9 @@ pub fn add_arm(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_arm(x: u32) -> u32 {
     match x {
@@ -80,9 +80,9 @@ pub fn add_guard_clause(x: u32, y: bool) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_guard_clause(x: u32, y: bool) -> u32 {
     match x {
@@ -105,9 +105,9 @@ pub fn change_guard_clause(x: u32, y: bool) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_guard_clause(x: u32, y: bool) -> u32 {
     match x {
@@ -130,9 +130,9 @@ pub fn add_at_binding(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_at_binding(x: u32) -> u32 {
     match x {
@@ -179,9 +179,9 @@ pub fn change_simple_name_to_pattern(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_simple_name_to_pattern(x: u32) -> u32 {
     match (x, x & 1) {
@@ -228,9 +228,9 @@ pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 {
 
 // Ignore optimized_mir in cfail2, the only change to optimized MIR is a span.
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 {
     match (x, x & 1) {
@@ -251,9 +251,9 @@ pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 {
     match (x, x & 1) {
@@ -274,9 +274,9 @@ pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 {
     match (&x, x & 1) {
@@ -323,9 +323,9 @@ pub fn add_alternative_to_arm(x: u32) -> u32 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_alternative_to_arm(x: u32) -> u32 {
     match x {
diff --git a/tests/incremental/hashes/struct_constructors.rs b/tests/incremental/hashes/struct_constructors.rs
index b2f8d116b1e9..0efbd50627d7 100644
--- a/tests/incremental/hashes/struct_constructors.rs
+++ b/tests/incremental/hashes/struct_constructors.rs
@@ -60,9 +60,9 @@ pub fn change_field_order_regular_struct() -> RegularStruct {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_field_order_regular_struct() -> RegularStruct {
     RegularStruct {
@@ -91,9 +91,9 @@ pub fn add_field_regular_struct() -> RegularStruct {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_field_regular_struct() -> RegularStruct {
     let struct1 = RegularStruct {
@@ -128,9 +128,9 @@ pub fn change_field_label_regular_struct() -> RegularStruct {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_field_label_regular_struct() -> RegularStruct {
     let struct1 = RegularStruct {
@@ -165,9 +165,9 @@ pub fn change_constructor_path_regular_struct() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_path_regular_struct() {
     let _ = RegularStruct2 {
@@ -186,9 +186,9 @@ pub mod change_constructor_path_indirectly_regular_struct {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::RegularStruct2 as Struct;
 
-    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
     pub fn function() -> Struct {
         Struct {
@@ -229,9 +229,9 @@ pub fn change_constructor_path_tuple_struct() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_constructor_path_tuple_struct() {
     let _ = TupleStruct2(0, 1, 2);
@@ -246,9 +246,9 @@ pub mod change_constructor_path_indirectly_tuple_struct {
     #[cfg(not(any(cfail1,cfail4)))]
     use super::TupleStruct2 as Struct;
 
-    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail5", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail6")]
-    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck")]
+    #[rustc_clean(cfg="cfail2", except="fn_sig,opt_hir_owner_nodes,optimized_mir,typeck_root")]
     #[rustc_clean(cfg="cfail3")]
     pub fn function() -> Struct {
         Struct(0, 1, 2)
diff --git a/tests/incremental/hashes/trait_defs.rs b/tests/incremental/hashes/trait_defs.rs
index 13334a08cae8..28f0c8633b4d 100644
--- a/tests/incremental/hashes/trait_defs.rs
+++ b/tests/incremental/hashes/trait_defs.rs
@@ -356,9 +356,9 @@ fn method(    self) {}
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 trait TraitChangeModeSelfOwnToMut: Sized {
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn method(mut self) {}
 }
diff --git a/tests/incremental/hashes/trait_impls.rs b/tests/incremental/hashes/trait_impls.rs
index d4ac69a8b55d..26a87ef5d723 100644
--- a/tests/incremental/hashes/trait_impls.rs
+++ b/tests/incremental/hashes/trait_impls.rs
@@ -79,9 +79,9 @@ fn method_name() {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodBodyTrait for Foo {
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn method_name() {
         ()
@@ -114,9 +114,9 @@ fn method_name() {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodBodyTraitInlined for Foo {
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     #[inline]
     fn method_name() {
@@ -148,12 +148,12 @@ pub trait ChangeMethodSelfnessTrait {
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodSelfnessTrait for Foo {
     #[rustc_clean(
-        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck_root,optimized_mir",
         cfg="cfail2",
     )]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(
-        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck_root,optimized_mir",
         cfg="cfail5",
     )]
     #[rustc_clean(cfg="cfail6")]
@@ -186,12 +186,12 @@ pub trait RemoveMethodSelfnessTrait {
 #[rustc_clean(cfg="cfail6")]
 impl RemoveMethodSelfnessTrait for Foo {
     #[rustc_clean(
-        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck_root,optimized_mir",
         cfg="cfail2",
     )]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(
-        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,associated_item,generics_of,fn_sig,typeck_root,optimized_mir",
         cfg="cfail5",
     )]
     #[rustc_clean(cfg="cfail6")]
@@ -225,9 +225,9 @@ pub trait ChangeMethodSelfmutnessTrait {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodSelfmutnessTrait for Foo {
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn method_name(&mut self) {}
 }
@@ -407,9 +407,9 @@ pub trait AddArgumentTrait {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl AddArgumentTrait for Foo {
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn method_name(&self, _x: u32) { }
 }
@@ -441,9 +441,9 @@ pub trait ChangeArgumentTypeTrait {
 #[rustc_clean(cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeArgumentTypeTrait for Foo {
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn method_name(&self, _x: char) { }
 }
@@ -469,12 +469,12 @@ fn id(t: u32) -> u32 { t }
 #[rustc_clean(cfg="cfail6")]
 impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> {
     #[rustc_clean(
-        except="opt_hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,generics_of,fn_sig,type_of,typeck_root,optimized_mir",
         cfg="cfail2",
     )]
     #[rustc_clean(cfg="cfail3")]
     #[rustc_clean(
-        except="opt_hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
+        except="opt_hir_owner_nodes,generics_of,fn_sig,type_of,typeck_root,optimized_mir",
         cfg="cfail5",
     )]
     #[rustc_clean(cfg="cfail6")]
@@ -499,9 +499,9 @@ fn id(self) -> Self { self }
 #[rustc_clean(except="opt_hir_owner_nodes,impl_trait_header", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeSelfTypeOfImpl for u64 {
-    #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")]
+    #[rustc_clean(except="fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
     #[rustc_clean(cfg="cfail3")]
-    #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail5")]
+    #[rustc_clean(except="fn_sig,typeck_root,optimized_mir", cfg="cfail5")]
     #[rustc_clean(cfg="cfail6")]
     fn id(self) -> Self { self }
 }
diff --git a/tests/incremental/hashes/unary_and_binary_exprs.rs b/tests/incremental/hashes/unary_and_binary_exprs.rs
index fec167c2604c..9154aa30e4a6 100644
--- a/tests/incremental/hashes/unary_and_binary_exprs.rs
+++ b/tests/incremental/hashes/unary_and_binary_exprs.rs
@@ -418,9 +418,9 @@ pub fn type_cast(a: u8) -> u64 {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes,optimized_mir,typeck", cfg="cfail2")]
+#[rustc_clean(except="opt_hir_owner_nodes,optimized_mir,typeck_root", cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(except="opt_hir_owner_nodes,optimized_mir,typeck", cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes,optimized_mir,typeck_root", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 pub fn type_cast(a: u8) -> u64 {
     let b = a as u32;
diff --git a/tests/incremental/hashes/while_let_loops.rs b/tests/incremental/hashes/while_let_loops.rs
index 1071ee86b1fb..62ff32fcc97c 100644
--- a/tests/incremental/hashes/while_let_loops.rs
+++ b/tests/incremental/hashes/while_let_loops.rs
@@ -79,9 +79,9 @@ pub fn add_break() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_break() {
     let mut _x = 0;
diff --git a/tests/incremental/hashes/while_loops.rs b/tests/incremental/hashes/while_loops.rs
index 57287cbcdcee..79e514546544 100644
--- a/tests/incremental/hashes/while_loops.rs
+++ b/tests/incremental/hashes/while_loops.rs
@@ -79,9 +79,9 @@ pub fn add_break() {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes, optimized_mir, typeck_root")]
 #[rustc_clean(cfg="cfail6")]
 pub fn add_break() {
     let mut _x = 0;
diff --git a/tests/incremental/hygiene/auxiliary/cached_hygiene.rs b/tests/incremental/hygiene/auxiliary/cached_hygiene.rs
index 67b54e641430..d52a6397590f 100644
--- a/tests/incremental/hygiene/auxiliary/cached_hygiene.rs
+++ b/tests/incremental/hygiene/auxiliary/cached_hygiene.rs
@@ -13,7 +13,7 @@ macro_rules! first_macro {
     }
 }
 
-#[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="rpass2")]
+#[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="rpass2")]
 #[inline(always)]
 pub fn changed_fn() {
     // This will cause additional hygiene to be generate,
diff --git a/tests/incremental/ich_method_call_trait_scope.rs b/tests/incremental/ich_method_call_trait_scope.rs
index 28234ca60d8e..58a56e6646f0 100644
--- a/tests/incremental/ich_method_call_trait_scope.rs
+++ b/tests/incremental/ich_method_call_trait_scope.rs
@@ -27,7 +27,7 @@ mod mod3 {
     #[cfg(rpass2)]
     use Trait2;
 
-    #[rustc_clean(except="typeck", cfg="rpass2")]
+    #[rustc_clean(except="typeck_root", cfg="rpass2")]
     fn bar() {
         ().method();
     }
diff --git a/tests/incremental/ich_resolve_results.rs b/tests/incremental/ich_resolve_results.rs
index 41c98bd38912..60d3fd929479 100644
--- a/tests/incremental/ich_resolve_results.rs
+++ b/tests/incremental/ich_resolve_results.rs
@@ -31,13 +31,13 @@ mod mod3 {
     use mod2::Foo;
 
     #[rustc_clean(cfg="rpass2")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="rpass3")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="rpass3")]
     fn in_expr() {
         Foo(0);
     }
 
     #[rustc_clean(cfg="rpass2")]
-    #[rustc_clean(except="opt_hir_owner_nodes,typeck", cfg="rpass3")]
+    #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="rpass3")]
     fn in_type() {
         test::<Foo>();
     }
diff --git a/tests/incremental/issue-42602.rs b/tests/incremental/issue-42602.rs
index e75dd9696b79..de1fd701f8cd 100644
--- a/tests/incremental/issue-42602.rs
+++ b/tests/incremental/issue-42602.rs
@@ -1,7 +1,7 @@
 // Regression test for #42602. It used to be that we had
 // a dep-graph like
 //
-//     typeck(foo) -> FnOnce -> typeck(bar)
+//     typeck_root(foo) -> FnOnce -> typeck_root(bar)
 //
 // This was fixed by improving the resolution of the `FnOnce` trait
 // selection node.
diff --git a/tests/incremental/rlib_cross_crate/b.rs b/tests/incremental/rlib_cross_crate/b.rs
index 3373f8098c4f..c60e1c52f7ed 100644
--- a/tests/incremental/rlib_cross_crate/b.rs
+++ b/tests/incremental/rlib_cross_crate/b.rs
@@ -13,7 +13,7 @@
 
 extern crate a;
 
-#[rustc_clean(except="typeck,optimized_mir", cfg="rpass2")]
+#[rustc_clean(except="typeck_root,optimized_mir", cfg="rpass2")]
 #[rustc_clean(cfg="rpass3")]
 pub fn use_X() -> u32 {
     let x: a::X = 22;
diff --git a/tests/incremental/string_constant.rs b/tests/incremental/string_constant.rs
index 4200df87ec65..fad76d4a9096 100644
--- a/tests/incremental/string_constant.rs
+++ b/tests/incremental/string_constant.rs
@@ -7,7 +7,7 @@
 #![crate_type = "rlib"]
 
 // Here the only thing which changes is the string constant in `x`.
-// Therefore, the compiler deduces (correctly) that typeck is not
+// Therefore, the compiler deduces (correctly) that typeck_root is not
 // needed even for callers of `x`.
 
 pub mod x {
diff --git a/tests/incremental/struct_add_field.rs b/tests/incremental/struct_add_field.rs
index 2c26b388122a..e39935c0231a 100644
--- a/tests/incremental/struct_add_field.rs
+++ b/tests/incremental/struct_add_field.rs
@@ -22,12 +22,12 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_clean(except="fn_sig,typeck", cfg="rpass2")]
+#[rustc_clean(except="fn_sig,typeck_root", cfg="rpass2")]
 pub fn use_X(x: X) -> u32 {
     x.x as u32
 }
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
diff --git a/tests/incremental/struct_change_field_name.rs b/tests/incremental/struct_change_field_name.rs
index 1519f8d477e5..76f42b68c5c8 100644
--- a/tests/incremental/struct_change_field_name.rs
+++ b/tests/incremental/struct_change_field_name.rs
@@ -26,7 +26,7 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_clean(except="typeck", cfg="cfail2")]
+#[rustc_clean(except="typeck_root", cfg="cfail2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     //[cfail2]~^ ERROR struct `X` has no field named `x`
@@ -34,7 +34,7 @@ pub fn use_X() -> u32 {
     //[cfail2]~^ ERROR no field `x` on type `X`
 }
 
-#[rustc_clean(except="typeck", cfg="cfail2")]
+#[rustc_clean(except="typeck_root", cfg="cfail2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
     //[cfail2]~^ ERROR no field `x` on type `X`
diff --git a/tests/incremental/struct_change_field_type.rs b/tests/incremental/struct_change_field_type.rs
index 0291b34e3622..9414790303b3 100644
--- a/tests/incremental/struct_change_field_type.rs
+++ b/tests/incremental/struct_change_field_type.rs
@@ -25,13 +25,13 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_EmbedX(x: EmbedX) -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
diff --git a/tests/incremental/struct_change_field_type_cross_crate/b.rs b/tests/incremental/struct_change_field_type_cross_crate/b.rs
index 5307d0af9d0a..ccd604717389 100644
--- a/tests/incremental/struct_change_field_type_cross_crate/b.rs
+++ b/tests/incremental/struct_change_field_type_cross_crate/b.rs
@@ -9,13 +9,13 @@
 
 use a::*;
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
diff --git a/tests/incremental/struct_remove_field.rs b/tests/incremental/struct_remove_field.rs
index 23ba27344f9c..eeb0dff8f422 100644
--- a/tests/incremental/struct_remove_field.rs
+++ b/tests/incremental/struct_remove_field.rs
@@ -26,12 +26,12 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_clean(except="typeck,fn_sig", cfg="rpass2")]
+#[rustc_clean(except="typeck_root,fn_sig", cfg="rpass2")]
 pub fn use_X(x: X) -> u32 {
     x.x as u32
 }
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
diff --git a/tests/incremental/type_alias_cross_crate/b.rs b/tests/incremental/type_alias_cross_crate/b.rs
index 7fa7073e3da9..095312c6cfe8 100644
--- a/tests/incremental/type_alias_cross_crate/b.rs
+++ b/tests/incremental/type_alias_cross_crate/b.rs
@@ -7,7 +7,7 @@
 
 extern crate a;
 
-#[rustc_clean(except="typeck", cfg="rpass2")]
+#[rustc_clean(except="typeck_root", cfg="rpass2")]
 #[rustc_clean(cfg="rpass3")]
 pub fn use_X() -> u32 {
     let x: a::X = 22;

From 1792232d01c1f4f336640c913e21bab4d0e7db78 Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Wed, 25 Mar 2026 13:59:59 +0300
Subject: [PATCH 0999/1059] fix tests/incremental/hashes

---
 tests/incremental/hashes/inherent_impls.rs | 24 +++++++++++-----------
 tests/incremental/hashes/trait_defs.rs     |  2 +-
 tests/incremental/hashes/trait_impls.rs    | 10 ++++-----
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/incremental/hashes/inherent_impls.rs b/tests/incremental/hashes/inherent_impls.rs
index c0d1c9a7b652..ad871e5965ea 100644
--- a/tests/incremental/hashes/inherent_impls.rs
+++ b/tests/incremental/hashes/inherent_impls.rs
@@ -55,7 +55,7 @@ pub fn method_body() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2",except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck_root")]
@@ -86,7 +86,7 @@ pub fn method_body_inlined() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck_root")]
@@ -171,7 +171,7 @@ pub fn method_selfmutness(&    self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
@@ -221,7 +221,7 @@ pub fn add_method_parameter(&self        ) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir")]
@@ -271,7 +271,7 @@ pub fn change_method_return_type(&self) -> u16 { 0 }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,optimized_mir,typeck_root")]
@@ -348,7 +348,7 @@ pub        fn make_method_unsafe(&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
@@ -373,7 +373,7 @@ pub            fn make_method_extern(&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
@@ -398,7 +398,7 @@ pub extern "C"      fn change_method_calling_convention(&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,fn_sig,typeck_root")]
@@ -432,7 +432,7 @@ pub fn add_lifetime_parameter_to_method    (&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     // Warning: Note that `typeck_root` are coming up clean here.
@@ -481,7 +481,7 @@ pub fn add_type_parameter_to_method   (&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     // Warning: Note that `typeck_root` are coming up clean here.
@@ -573,7 +573,7 @@ pub fn add_lifetime_bound_to_type_param_of_method<'a, T    >(&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     // Warning: Note that `typeck_root` are coming up clean here.
@@ -622,7 +622,7 @@ pub fn add_trait_bound_to_type_param_of_method<T       >(&self) { }
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl Foo {
     // Warning: Note that `typeck_root` are coming up clean here.
diff --git a/tests/incremental/hashes/trait_defs.rs b/tests/incremental/hashes/trait_defs.rs
index 28f0c8633b4d..0842fbadd1c4 100644
--- a/tests/incremental/hashes/trait_defs.rs
+++ b/tests/incremental/hashes/trait_defs.rs
@@ -353,7 +353,7 @@ fn method(    self) {}
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 trait TraitChangeModeSelfOwnToMut: Sized {
     #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail2")]
diff --git a/tests/incremental/hashes/trait_impls.rs b/tests/incremental/hashes/trait_impls.rs
index 26a87ef5d723..3e13212e5fd1 100644
--- a/tests/incremental/hashes/trait_impls.rs
+++ b/tests/incremental/hashes/trait_impls.rs
@@ -76,7 +76,7 @@ fn method_name() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodBodyTrait for Foo {
     #[rustc_clean(except="opt_hir_owner_nodes,typeck_root", cfg="cfail2")]
@@ -111,7 +111,7 @@ fn method_name() {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodBodyTraitInlined for Foo {
     #[rustc_clean(except="opt_hir_owner_nodes,typeck_root,optimized_mir", cfg="cfail2")]
@@ -222,7 +222,7 @@ pub trait ChangeMethodSelfmutnessTrait {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeMethodSelfmutnessTrait for Foo {
     #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
@@ -404,7 +404,7 @@ pub trait AddArgumentTrait {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl AddArgumentTrait for Foo {
     #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]
@@ -438,7 +438,7 @@ pub trait ChangeArgumentTypeTrait {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5")]
+#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
 impl ChangeArgumentTypeTrait for Foo {
     #[rustc_clean(except="opt_hir_owner_nodes,fn_sig,typeck_root,optimized_mir", cfg="cfail2")]

From 12119eccc5c1243843a9efc83d658dcf3ab73a35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Sat, 28 Mar 2026 12:40:12 +0200
Subject: [PATCH 1000/1059] Bump GitHub actions

---
 .../.github/workflows/autopublish.yaml        |  2 +-
 .../rust-analyzer/.github/workflows/ci.yaml   | 31 ++++++++----------
 .../.github/workflows/coverage.yaml           |  6 ++--
 .../rust-analyzer/.github/workflows/fuzz.yml  |  6 ++--
 .../.github/workflows/metrics.yaml            | 22 ++++++-------
 .../.github/workflows/publish-libs.yaml       |  2 +-
 .../.github/workflows/release.yaml            | 32 +++++++++----------
 .../.github/workflows/rustdoc.yaml            | 30 ++++++++---------
 8 files changed, 63 insertions(+), 68 deletions(-)

diff --git a/src/tools/rust-analyzer/.github/workflows/autopublish.yaml b/src/tools/rust-analyzer/.github/workflows/autopublish.yaml
index 6e2be7fd3da5..abb9b521f1a5 100644
--- a/src/tools/rust-analyzer/.github/workflows/autopublish.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/autopublish.yaml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
diff --git a/src/tools/rust-analyzer/.github/workflows/ci.yaml b/src/tools/rust-analyzer/.github/workflows/ci.yaml
index 04de6d11e3eb..c27d84fb0bc0 100644
--- a/src/tools/rust-analyzer/.github/workflows/ci.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/ci.yaml
@@ -30,8 +30,8 @@ jobs:
     outputs:
       typescript: ${{ steps.filter.outputs.typescript }}
     steps:
-      - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@1441771bbfdd59dcd748680ee64ebd8faab1a242
+      - uses: actions/checkout@v6
+      - uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
         id: filter
         with:
           filters: |
@@ -45,7 +45,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
 
@@ -88,7 +88,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
 
@@ -136,7 +136,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         run: |
@@ -164,7 +164,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         run: |
@@ -180,7 +180,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       # Note that clippy output is currently dependent on whether rust-src is installed,
       # https://github.com/rust-lang/rust-clippy/issues/14625
@@ -202,7 +202,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         run: |
@@ -226,12 +226,7 @@ jobs:
 
     strategy:
       matrix:
-        target:
-          [
-            powerpc-unknown-linux-gnu,
-            x86_64-unknown-linux-musl,
-            wasm32-unknown-unknown,
-          ]
+        target: [powerpc-unknown-linux-gnu, x86_64-unknown-linux-musl, wasm32-unknown-unknown]
         include:
           # The rust-analyzer binary is not expected to compile on WASM, but the IDE
           # crate should
@@ -240,7 +235,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         run: |
@@ -268,10 +263,10 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install Nodejs
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: 22
 
@@ -327,7 +322,7 @@ jobs:
         run: curl -LsSf https://github.com/crate-ci/typos/releases/download/$TYPOS_VERSION/typos-$TYPOS_VERSION-x86_64-unknown-linux-musl.tar.gz | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin
 
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
 
diff --git a/src/tools/rust-analyzer/.github/workflows/coverage.yaml b/src/tools/rust-analyzer/.github/workflows/coverage.yaml
index bd4edba747ca..9460c6a3c77a 100644
--- a/src/tools/rust-analyzer/.github/workflows/coverage.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/coverage.yaml
@@ -13,7 +13,7 @@ jobs:
   coverage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         run: |
@@ -34,9 +34,9 @@ jobs:
 
       - name: Generate code coverage
         run: cargo llvm-cov --workspace --lcov --output-path lcov.info
-      
+
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
         with:
           files: lcov.info
           fail_ci_if_error: false
diff --git a/src/tools/rust-analyzer/.github/workflows/fuzz.yml b/src/tools/rust-analyzer/.github/workflows/fuzz.yml
index 7acfcbe351fe..af0e03598ecf 100644
--- a/src/tools/rust-analyzer/.github/workflows/fuzz.yml
+++ b/src/tools/rust-analyzer/.github/workflows/fuzz.yml
@@ -2,10 +2,10 @@ name: Fuzz
 on:
   schedule:
     # Once a week
-    - cron: '0 0 * * 0'
+    - cron: "0 0 * * 0"
   push:
     paths:
-    - '.github/workflows/fuzz.yml'
+      - ".github/workflows/fuzz.yml"
   # Allow manual trigger
   workflow_dispatch:
 
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           fetch-depth: 1
diff --git a/src/tools/rust-analyzer/.github/workflows/metrics.yaml b/src/tools/rust-analyzer/.github/workflows/metrics.yaml
index 860837dd7fd4..a482235105c0 100644
--- a/src/tools/rust-analyzer/.github/workflows/metrics.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/metrics.yaml
@@ -23,7 +23,7 @@ jobs:
           rustup component add --toolchain beta rust-src
 
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Cache cargo
         uses: actions/cache@v4
@@ -45,7 +45,7 @@ jobs:
           key: ${{ runner.os }}-target-${{ github.sha }}
 
       - name: Upload build metrics
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: build-${{ github.sha }}
           path: target/build.json
@@ -66,7 +66,7 @@ jobs:
           rustup component add --toolchain beta rust-src
 
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Restore target cache
         uses: actions/cache@v4
@@ -78,7 +78,7 @@ jobs:
         run: cargo xtask metrics "${{ matrix.names }}"
 
       - name: Upload metrics
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.names }}-${{ github.sha }}
           path: target/${{ matrix.names }}.json
@@ -89,35 +89,35 @@ jobs:
     needs: [build_metrics, other_metrics]
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Download build metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: build-${{ github.sha }}
 
       - name: Download self metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: self-${{ github.sha }}
 
       - name: Download ripgrep-13.0.0 metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: ripgrep-13.0.0-${{ github.sha }}
 
       - name: Download webrender-2022 metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: webrender-2022-${{ github.sha }}
 
       - name: Download diesel-1.4.8 metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: diesel-1.4.8-${{ github.sha }}
 
       - name: Download hyper-0.14.18 metrics
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: hyper-0.14.18-${{ github.sha }}
 
diff --git a/src/tools/rust-analyzer/.github/workflows/publish-libs.yaml b/src/tools/rust-analyzer/.github/workflows/publish-libs.yaml
index f2c8b6365b66..762b7bda871c 100644
--- a/src/tools/rust-analyzer/.github/workflows/publish-libs.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/publish-libs.yaml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
diff --git a/src/tools/rust-analyzer/.github/workflows/release.yaml b/src/tools/rust-analyzer/.github/workflows/release.yaml
index 28914118de94..b35614f91b2d 100644
--- a/src/tools/rust-analyzer/.github/workflows/release.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/release.yaml
@@ -70,12 +70,12 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: ${{ env.FETCH_DEPTH }}
 
       - name: Install Node.js toolchain
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: 22
 
@@ -143,7 +143,7 @@ jobs:
         run: target/${{ matrix.target }}/release/rust-analyzer analysis-stats --with-deps --no-sysroot --no-test $(rustc --print sysroot)/lib/rustlib/src/rust/library/std -q
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: dist-${{ matrix.target }}
           path: ./dist
@@ -166,7 +166,7 @@ jobs:
         run: apk add --no-cache git clang lld musl-dev nodejs npm
 
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: ${{ env.FETCH_DEPTH }}
 
@@ -189,7 +189,7 @@ jobs:
       - run: rm -rf editors/code/server
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: dist-x86_64-unknown-linux-musl
           path: ./dist
@@ -201,7 +201,7 @@ jobs:
     needs: ["dist", "dist-x86_64-unknown-linux-musl"]
     steps:
       - name: Install Nodejs
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: 22
 
@@ -212,46 +212,46 @@ jobs:
       - run: 'echo "TAG: $TAG"'
 
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: ${{ env.FETCH_DEPTH }}
 
       - run: echo "HEAD_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
       - run: 'echo "HEAD_SHA: $HEAD_SHA"'
 
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-aarch64-apple-darwin
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-x86_64-apple-darwin
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-x86_64-unknown-linux-gnu
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-x86_64-unknown-linux-musl
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-aarch64-unknown-linux-gnu
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-arm-unknown-linux-gnueabihf
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-x86_64-pc-windows-msvc
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-i686-pc-windows-msvc
           path: dist
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist-aarch64-pc-windows-msvc
           path: dist
diff --git a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
index 0cc7ce77ddb6..244eaac2b819 100644
--- a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
@@ -1,8 +1,8 @@
 name: rustdoc
 on:
   push:
-   branches:
-   - master
+    branches:
+      - master
 
 env:
   CARGO_INCREMENTAL: 0
@@ -17,19 +17,19 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v6
 
-    - name: Install Rust toolchain
-      run: rustup update --no-self-update stable
+      - name: Install Rust toolchain
+        run: rustup update --no-self-update stable
 
-    - name: Build Documentation
-      run: cargo doc --all --no-deps --document-private-items
+      - name: Build Documentation
+        run: cargo doc --all --no-deps --document-private-items
 
-    - name: Deploy Docs
-      uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
-      with:
-        github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_branch: gh-pages
-        publish_dir: ./target/doc
-        force_orphan: true
+      - name: Deploy Docs
+        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_branch: gh-pages
+          publish_dir: ./target/doc
+          force_orphan: true

From 767d71fcb2cd0e2329b1192c500648b709045c48 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 11:34:01 +0100
Subject: [PATCH 1001/1059] EnumSizeOpt test: show actual bytes of new
 allocation

---
 tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff | 6 ++++--
 tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff | 6 ++++--
 tests/mir-opt/enum_opt.rs                          | 3 ++-
 tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff | 6 ++++--
 tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff | 6 ++++--
 5 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
index cf850351c1d6..adc723a72682 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
@@ -64,7 +64,9 @@
           StorageDead(_1);
           return;
       }
-  }
++ }
 + 
-+ ALLOC0 (size: 8, align: 4) { .. }
++ ALLOC0 (size: 8, align: 4) {
++     02 00 00 00 05 20 00 00                         │ ..... ..
+  }
   
diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
index dc5ea1add000..c92bf7bb0a09 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
@@ -64,7 +64,9 @@
           StorageDead(_1);
           return;
       }
-  }
++ }
 + 
-+ ALLOC0 (size: 16, align: 8) { .. }
++ ALLOC0 (size: 16, align: 8) {
++     02 00 00 00 00 00 00 00 05 20 00 00 00 00 00 00 │ ......... ......
+  }
   
diff --git a/tests/mir-opt/enum_opt.rs b/tests/mir-opt/enum_opt.rs
index 81390567c2bb..45a3edca90ed 100644
--- a/tests/mir-opt/enum_opt.rs
+++ b/tests/mir-opt/enum_opt.rs
@@ -1,7 +1,8 @@
 // skip-filecheck
 //@ test-mir-pass: EnumSizeOpt
 // EMIT_MIR_FOR_EACH_BIT_WIDTH
-//@ compile-flags: -Zunsound-mir-opts -Zdump-mir-exclude-alloc-bytes
+//@ compile-flags: -Zunsound-mir-opts
+//@ ignore-endian-big
 
 // Tests that an enum with a variant with no data gets correctly transformed.
 pub enum NoData {
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
index 3cd2e74a0db6..f6dbf8bb2586 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
@@ -64,7 +64,9 @@
           StorageDead(_1);
           return;
       }
-  }
++ }
 + 
-+ ALLOC0 (size: 8, align: 4) { .. }
++ ALLOC0 (size: 8, align: 4) {
++     05 20 00 00 01 00 00 00                         │ . ......
+  }
   
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
index 10b0ec5a63fa..7900c3ce3775 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
@@ -64,7 +64,9 @@
           StorageDead(_1);
           return;
       }
-  }
++ }
 + 
-+ ALLOC0 (size: 16, align: 8) { .. }
++ ALLOC0 (size: 16, align: 8) {
++     05 20 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ . ..............
+  }
   

From 20f97a5f70973b97375fea26fa88909dace095da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Sat, 28 Mar 2026 12:43:29 +0200
Subject: [PATCH 1002/1059] Allow Node 20 for peaceiris/actions-gh-pages

---
 src/tools/rust-analyzer/.github/workflows/rustdoc.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
index 244eaac2b819..03fd08317501 100644
--- a/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/rustdoc.yaml
@@ -10,6 +10,7 @@ env:
   RUSTFLAGS: "-D warnings -W unreachable-pub"
   RUSTDOCFLAGS: "-D warnings"
   RUSTUP_MAX_RETRIES: 10
+  ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
 
 jobs:
   rustdoc:

From 1dfbb8998c1f9319adf36d91b9dafc662a522d01 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 11:43:58 +0100
Subject: [PATCH 1003/1059] use Allocation::write_scalar instead of manual
 endianess logic

---
 .../rustc_mir_transform/src/large_enums.rs    | 50 ++++++-------------
 1 file changed, 15 insertions(+), 35 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
index b9a620645267..2f812358fcfe 100644
--- a/compiler/rustc_mir_transform/src/large_enums.rs
+++ b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -1,4 +1,5 @@
 use rustc_abi::{HasDataLayout, Size, TagEncoding, Variants};
+use rustc_const_eval::interpret::{Scalar, alloc_range};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::mir::interpret::AllocId;
 use rustc_middle::mir::*;
@@ -23,7 +24,8 @@
 ///
 /// In summary, what this does is at runtime determine which enum variant is active,
 /// and instead of copying all the bytes of the largest possible variant,
-/// copy only the bytes for the currently active variant.
+/// copy only the bytes for the currently active variant. The number of bytes to copy is determined
+/// by a lookup table: a discriminant-indexed array indicating the size of each variant.
 pub(super) struct EnumSizeOpt {
     pub(crate) discrepancy: u64,
 }
@@ -202,45 +204,23 @@ fn candidate<'tcx>(
             return Some((*adt_def, num_discrs, *alloc_id));
         }
 
+        // Construct an in-memory array mapping discriminant idx to variant size.
         let data_layout = tcx.data_layout();
-        let ptr_sized_int = data_layout.ptr_sized_integer();
-        let target_bytes = ptr_sized_int.size().bytes() as usize;
-        let mut data = vec![0; target_bytes * num_discrs];
-
-        // We use a macro because `$bytes` can be u32 or u64.
-        macro_rules! encode_store {
-            ($curr_idx: expr, $endian: expr, $bytes: expr) => {
-                let bytes = match $endian {
-                    rustc_abi::Endian::Little => $bytes.to_le_bytes(),
-                    rustc_abi::Endian::Big => $bytes.to_be_bytes(),
-                };
-                for (i, b) in bytes.into_iter().enumerate() {
-                    data[$curr_idx + i] = b;
-                }
-            };
-        }
-
-        for (var_idx, layout) in variants.iter_enumerated() {
-            let curr_idx =
-                target_bytes * adt_def.discriminant_for_variant(tcx, var_idx).val as usize;
-            let sz = layout.size;
-            match ptr_sized_int {
-                rustc_abi::Integer::I32 => {
-                    encode_store!(curr_idx, data_layout.endian, sz.bytes() as u32);
-                }
-                rustc_abi::Integer::I64 => {
-                    encode_store!(curr_idx, data_layout.endian, sz.bytes());
-                }
-                _ => unreachable!(),
-            };
-        }
-        let alloc = interpret::Allocation::from_bytes(
-            data,
+        let ptr_size = data_layout.pointer_size();
+        let mut alloc = interpret::Allocation::from_bytes(
+            vec![0; ptr_size.bytes_usize() * num_discrs],
             tcx.data_layout.ptr_sized_integer().align(&tcx.data_layout).abi,
-            Mutability::Not,
+            Mutability::Mut,
             (),
         );
+        for (var_idx, layout) in variants.iter_enumerated() {
+            let curr_idx = ptr_size * adt_def.discriminant_for_variant(tcx, var_idx).val as u64;
+            let val = Scalar::from_target_usize(layout.size.bytes(), &tcx);
+            alloc.write_scalar(&tcx, alloc_range(curr_idx, val.size()), val).unwrap();
+        }
+        alloc.mutability = Mutability::Not;
         let alloc = tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(alloc));
+
         Some((*adt_def, num_discrs, *alloc_cache.entry(ty).or_insert(alloc)))
     }
 }

From 29be0590f4e2996934a0e804e439b1e9e16fb99b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 27 Mar 2026 14:10:33 +1100
Subject: [PATCH 1004/1059] Use the normal arg-parsing machinery for
 `-Zassert-incr-state`

---
 compiler/rustc_incremental/src/persist/load.rs |  4 ++--
 compiler/rustc_interface/src/tests.rs          | 14 +++++++-------
 compiler/rustc_session/src/config.rs           | 18 ------------------
 compiler/rustc_session/src/options.rs          | 16 ++++++++++++++--
 4 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index 8e27c335b117..6f84073ff645 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -38,8 +38,8 @@ pub enum LoadResult<T> {
 impl<T: Default> LoadResult<T> {
     /// Accesses the data returned in [`LoadResult::Ok`].
     pub fn open(self, sess: &Session) -> T {
-        // Check for errors when using `-Zassert-incremental-state`
-        match (sess.opts.assert_incr_state, &self) {
+        // Check for errors when using `-Zassert-incr-state`.
+        match (sess.opts.unstable_opts.assert_incr_state, &self) {
             (Some(IncrementalStateAssertion::NotLoaded), LoadResult::Ok { .. }) => {
                 sess.dcx().emit_fatal(errors::AssertNotLoaded);
             }
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index f9d583bdf18c..417cde119c21 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -12,12 +12,12 @@
 use rustc_session::config::{
     AnnotateMoves, AutoDiff, BranchProtection, CFGuard, Cfg, CoverageLevel, CoverageOptions,
     DebugInfo, DumpMonoStatsFormat, ErrorOutputType, ExternEntry, ExternLocation, Externs,
-    FmtDebug, FunctionReturn, InliningThreshold, Input, InstrumentCoverage, InstrumentXRay,
-    LinkSelfContained, LinkerPluginLto, LocationDetail, LtoCli, MirIncludeSpans, NextSolverConfig,
-    Offload, Options, OutFileName, OutputType, OutputTypes, PAuthKey, PacRet, Passes,
-    PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath,
-    SymbolManglingVersion, WasiExecModel, build_configuration, build_session_options,
-    rustc_optgroups,
+    FmtDebug, FunctionReturn, IncrementalStateAssertion, InliningThreshold, Input,
+    InstrumentCoverage, InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail, LtoCli,
+    MirIncludeSpans, NextSolverConfig, Offload, Options, OutFileName, OutputType, OutputTypes,
+    PAuthKey, PacRet, Passes, PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip,
+    SwitchWithOptPath, SymbolManglingVersion, WasiExecModel, build_configuration,
+    build_session_options, rustc_optgroups,
 };
 use rustc_session::lint::Level;
 use rustc_session::search_paths::SearchPath;
@@ -686,7 +686,7 @@ macro_rules! untracked {
 
     // Make sure that changing an [UNTRACKED] option leaves the hash unchanged.
     // tidy-alphabetical-start
-    untracked!(assert_incr_state, Some(String::from("loaded")));
+    untracked!(assert_incr_state, Some(IncrementalStateAssertion::Loaded));
     untracked!(codegen_source_order, true);
     untracked!(deduplicate_diagnostics, false);
     untracked!(dump_dep_graph, true);
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 0677ca0fddba..42d5a50df699 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1405,7 +1405,6 @@ fn default() -> Options {
         };
 
         Options {
-            assert_incr_state: None,
             crate_types: Vec::new(),
             optimize: OptLevel::No,
             debuginfo: DebugInfo::None,
@@ -2287,20 +2286,6 @@ fn select_debuginfo(matches: &getopts::Matches, cg: &CodegenOptions) -> DebugInf
     if max_g > max_c { DebugInfo::Full } else { cg.debuginfo }
 }
 
-fn parse_assert_incr_state(
-    early_dcx: &EarlyDiagCtxt,
-    opt_assertion: &Option<String>,
-) -> Option<IncrementalStateAssertion> {
-    match opt_assertion {
-        Some(s) if s.as_str() == "loaded" => Some(IncrementalStateAssertion::Loaded),
-        Some(s) if s.as_str() == "not-loaded" => Some(IncrementalStateAssertion::NotLoaded),
-        Some(s) => {
-            early_dcx.early_fatal(format!("unexpected incremental state assertion value: {s}"))
-        }
-        None => None,
-    }
-}
-
 pub fn parse_externs(
     early_dcx: &EarlyDiagCtxt,
     matches: &getopts::Matches,
@@ -2506,8 +2491,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
 
     let incremental = cg.incremental.as_ref().map(PathBuf::from);
 
-    let assert_incr_state = parse_assert_incr_state(early_dcx, &unstable_opts.assert_incr_state);
-
     if cg.profile_generate.enabled() && cg.profile_use.is_some() {
         early_dcx.early_fatal("options `-C profile-generate` and `-C profile-use` are exclusive");
     }
@@ -2759,7 +2742,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     let verbose = matches.opt_present("verbose") || unstable_opts.verbose_internals;
 
     Options {
-        assert_incr_state,
         crate_types,
         optimize: opt_level,
         debuginfo,
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 7abaae1c1760..8771dbd05c49 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -419,7 +419,6 @@ pub struct Options {
         /// If `Some`, enable incremental compilation, using the given
         /// directory to store intermediate results.
         incremental: Option<PathBuf> [UNTRACKED],
-        assert_incr_state: Option<IncrementalStateAssertion> [UNTRACKED],
         /// Set based on the result of the `Config::track_state` callback
         /// for custom drivers to invalidate the incremental cache.
         #[rustc_lint_opt_deny_field_access("should only be used via `Config::track_state`")]
@@ -889,6 +888,7 @@ mod desc {
     pub(crate) const parse_mir_include_spans: &str =
         "either a boolean (`yes`, `no`, `on`, `off`, etc), or `nll` (default: `nll`)";
     pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";
+    pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`";
 }
 
 pub mod parse {
@@ -2061,6 +2061,18 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
 
         true
     }
+
+    pub(crate) fn parse_assert_incr_state(
+        slot: &mut Option<IncrementalStateAssertion>,
+        v: Option<&str>,
+    ) -> bool {
+        *slot = match v {
+            Some("loaded") => Some(IncrementalStateAssertion::Loaded),
+            Some("not-loaded") => Some(IncrementalStateAssertion::NotLoaded),
+            _ => return false,
+        };
+        true
+    }
 }
 
 options! {
@@ -2230,7 +2242,7 @@ pub(crate) fn parse_align(slot: &mut Option<Align>, v: Option<&str>) -> bool {
     annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED],
         "emit debug info for compiler-generated move and copy operations \
         to make them visible in profilers. Can be a boolean or a size limit in bytes (default: disabled)"),
-    assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED],
+    assert_incr_state: Option<IncrementalStateAssertion> = (None, parse_assert_incr_state, [UNTRACKED],
         "assert that the incremental cache is in given state: \
          either `loaded` or `not-loaded`."),
     assume_incomplete_release: bool = (false, parse_bool, [TRACKED],

From 10d29ee606c80356ea2885b63c6996e26fe48d2c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 27 Mar 2026 14:23:06 +1100
Subject: [PATCH 1005/1059] Extract `-Zassert-incr-state` into a separate
 helper function

This code is only needed by an obscure `-Z` flag, so pulling it out of the main
path makes the normal logic easier to follow.
---
 .../rustc_incremental/src/persist/load.rs     | 41 +++++++++++++------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index 6f84073ff645..c0466a4b5211 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -38,19 +38,8 @@ pub enum LoadResult<T> {
 impl<T: Default> LoadResult<T> {
     /// Accesses the data returned in [`LoadResult::Ok`].
     pub fn open(self, sess: &Session) -> T {
-        // Check for errors when using `-Zassert-incr-state`.
-        match (sess.opts.unstable_opts.assert_incr_state, &self) {
-            (Some(IncrementalStateAssertion::NotLoaded), LoadResult::Ok { .. }) => {
-                sess.dcx().emit_fatal(errors::AssertNotLoaded);
-            }
-            (
-                Some(IncrementalStateAssertion::Loaded),
-                LoadResult::LoadDepGraph(..) | LoadResult::DataOutOfDate,
-            ) => {
-                sess.dcx().emit_fatal(errors::AssertLoaded);
-            }
-            _ => {}
-        };
+        // Emit a fatal error if `-Zassert-incr-state` is present and unsatisfied.
+        maybe_assert_incr_state(sess, &self);
 
         match self {
             LoadResult::LoadDepGraph(path, err) => {
@@ -188,6 +177,32 @@ pub fn load_query_result_cache(sess: &Session) -> Option<OnDiskCache> {
     }
 }
 
+/// Emits a fatal error if the assertion in `-Zassert-incr-state` doesn't match
+/// the outcome of trying to load previous-session state.
+fn maybe_assert_incr_state(sess: &Session, load_result: &LoadResult<impl Sized>) {
+    // Return immediately if there's nothing to assert.
+    let Some(assertion) = sess.opts.unstable_opts.assert_incr_state else { return };
+
+    // Match exhaustively to make sure we don't miss any cases.
+    let loaded = match load_result {
+        LoadResult::Ok { .. } => true,
+        LoadResult::DataOutOfDate | LoadResult::LoadDepGraph(..) => false,
+    };
+
+    match assertion {
+        IncrementalStateAssertion::Loaded => {
+            if !loaded {
+                sess.dcx().emit_fatal(errors::AssertLoaded);
+            }
+        }
+        IncrementalStateAssertion::NotLoaded => {
+            if loaded {
+                sess.dcx().emit_fatal(errors::AssertNotLoaded)
+            }
+        }
+    }
+}
+
 /// Setups the dependency graph by loading an existing graph from disk and set up streaming of a
 /// new graph to an incremental session directory.
 pub fn setup_dep_graph(

From ad298d5a81d71b7b463a4900077750fc88e72d42 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 12:07:49 +0100
Subject: [PATCH 1006/1059] interpret: ensure that untupled arguments are
 actually tuples

---
 compiler/rustc_const_eval/src/interpret/call.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 802aa9ef4645..0ac9f3025d48 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -60,7 +60,7 @@ pub fn copy_fn_args(args: &[FnArg<'tcx, M::Provenance>]) -> Vec<OpTy<'tcx, M::Pr
     }
 
     /// Helper function for argument untupling.
-    pub(super) fn fn_arg_field(
+    fn fn_arg_project_field(
         &self,
         arg: &FnArg<'tcx, M::Provenance>,
         field: FieldIdx,
@@ -655,12 +655,17 @@ pub(super) fn init_fn_call(
                     if caller_abi == ExternAbi::RustCall && !args.is_empty() {
                         // Untuple
                         let (untuple_arg, args) = args.split_last().unwrap();
+                        let ty::Tuple(untuple_fields) = untuple_arg.layout().ty.kind() else {
+                            span_bug!(self.cur_span(), "untuple argument must be a tuple")
+                        };
                         trace!("init_fn_call: Will pass last argument by untupling");
                         Cow::from(
                             args.iter()
+                                // The regular arguments.
                                 .map(|a| interp_ok(a.clone()))
-                                .chain((0..untuple_arg.layout().fields.count()).map(|i| {
-                                    self.fn_arg_field(untuple_arg, FieldIdx::from_usize(i))
+                                // The fields of the untupled argument.
+                                .chain((0..untuple_fields.len()).map(|i| {
+                                    self.fn_arg_project_field(untuple_arg, FieldIdx::from_usize(i))
                                 }))
                                 .collect::<InterpResult<'_, Vec<_>>>()?,
                         )

From a779e16812735e7ff352e9be6c01b410fe480681 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 28 Mar 2026 11:34:47 +0000
Subject: [PATCH 1007/1059] Bump brace-expansion from 1.1.12 to 1.1.13 in
 /editors/code

Bumps [brace-expansion](https://github.com/juliangruber/brace-expansion) from 1.1.12 to 1.1.13.
- [Release notes](https://github.com/juliangruber/brace-expansion/releases)
- [Commits](https://github.com/juliangruber/brace-expansion/compare/v1.1.12...v1.1.13)

---
updated-dependencies:
- dependency-name: brace-expansion
  dependency-version: 1.1.13
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .../editors/code/package-lock.json            | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 047dbba11fcf..c4e362b38b12 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -738,9 +738,9 @@
             }
         },
         "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-            "version": "1.1.12",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -799,9 +799,9 @@
             }
         },
         "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-            "version": "1.1.12",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -1817,9 +1817,9 @@
             ]
         },
         "node_modules/@vscode/vsce/node_modules/brace-expansion": {
-            "version": "1.1.12",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -2060,9 +2060,9 @@
             "license": "BSD-2-Clause"
         },
         "node_modules/brace-expansion": {
-            "version": "2.0.2",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-            "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+            "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
             "license": "MIT",
             "dependencies": {
                 "balanced-match": "^1.0.0"
@@ -3416,9 +3416,9 @@
             }
         },
         "node_modules/eslint/node_modules/brace-expansion": {
-            "version": "1.1.12",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-            "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -3895,9 +3895,9 @@
             }
         },
         "node_modules/glob/node_modules/brace-expansion": {
-            "version": "5.0.4",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz",
-            "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==",
+            "version": "5.0.5",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+            "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
             "dev": true,
             "license": "MIT",
             "dependencies": {

From d10baae9ce4947706623256d4a31d588e9cfaafe Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <contact@alona.page>
Date: Wed, 25 Mar 2026 23:37:39 +0000
Subject: [PATCH 1008/1059] Normalize rustc path prefix when testing `-Z
 track-diagnostics`

Fixes https://www.github.com/rust-lang/rust/issues/154392
---
 tests/rustdoc-ui/track-diagnostics.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/rustdoc-ui/track-diagnostics.rs b/tests/rustdoc-ui/track-diagnostics.rs
index 6a5d1b53b3c7..f7f0c9849ef0 100644
--- a/tests/rustdoc-ui/track-diagnostics.rs
+++ b/tests/rustdoc-ui/track-diagnostics.rs
@@ -3,6 +3,7 @@
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
 //@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: "/rustc(?:-dev)?/[a-z0-9.]+/" -> ""
 
 struct A;
 struct B;

From 5bdde380cc7b65da3c30232117a14581abf82bbc Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sat, 28 Mar 2026 12:38:35 +0000
Subject: [PATCH 1009/1059] move many tests from `structs-enums` to `structs`
 or `enum`

---
 .../auxiliary/namespaced_enum_emulate_flat.rs                     | 0
 tests/ui/{structs-enums => enum}/auxiliary/namespaced_enums.rs    | 0
 tests/ui/{structs-enums => enum}/enum-clike-ffi-as-int.rs         | 0
 tests/ui/{structs-enums => enum}/enum-discrim-manual-sizing.rs    | 0
 tests/ui/{structs-enums => enum}/enum-discrim-range-overflow.rs   | 0
 tests/ui/{structs-enums => enum}/enum-discrim-width-stuff.rs      | 0
 tests/ui/{structs-enums => enum}/enum-disr-val-pretty.rs          | 0
 .../{structs-enums => enum}/enum-nullable-simplifycfg-misopt.rs   | 0
 tests/ui/{structs-enums => enum}/enum-univariant-repr.rs          | 0
 tests/ui/{structs-enums => enum}/enum-variants.rs                 | 0
 .../ui/{structs-enums => enum}/namespaced-enum-emulate-flat-xc.rs | 0
 tests/ui/{structs-enums => enum}/namespaced-enum-emulate-flat.rs  | 0
 .../{structs-enums => enum}/namespaced-enum-glob-import-xcrate.rs | 0
 tests/ui/{structs-enums => enum}/namespaced-enum-glob-import.rs   | 0
 tests/ui/{structs-enums => enum}/namespaced-enums-xcrate.rs       | 0
 tests/ui/{structs-enums => enum}/namespaced-enums.rs              | 0
 tests/ui/{structs-enums => enum}/struct-like-variant-construct.rs | 0
 tests/ui/{structs-enums => enum}/struct-like-variant-match.rs     | 0
 .../recover}/recover-enum-with-bad-where.rs                       | 0
 .../recover}/recover-enum-with-bad-where.stderr                   | 0
 .../ui/{structs-enums => structs}/auxiliary/newtype_struct_xc.rs  | 0
 .../{structs-enums => structs}/cross-crate-newtype-struct-pat.rs  | 0
 tests/ui/{structs-enums => structs}/field-destruction-order.rs    | 0
 .../module-qualified-struct-destructure.rs                        | 0
 tests/ui/{structs-enums => structs}/newtype-struct-drop-run.rs    | 0
 tests/ui/{structs-enums => structs}/newtype-struct-with-dtor.rs   | 0
 tests/ui/{structs-enums => structs}/newtype-struct-xc-2.rs        | 0
 tests/ui/{structs-enums => structs}/newtype-struct-xc.rs          | 0
 tests/ui/{structs-enums => structs}/rec-align-u32.rs              | 0
 tests/ui/{structs-enums => structs}/rec-align-u64.rs              | 0
 .../{structs-enums => structs}/struct-lit-functional-no-fields.rs | 0
 tests/ui/{structs-enums => structs}/struct-literal-dtor.rs        | 0
 tests/ui/{structs-enums => structs}/struct-new-as-field-name.rs   | 0
 tests/ui/{structs-enums => structs}/struct-order-of-eval-1.rs     | 0
 tests/ui/{structs-enums => structs}/struct-order-of-eval-2.rs     | 0
 tests/ui/{structs-enums => structs}/struct-order-of-eval-3.rs     | 0
 tests/ui/{structs-enums => structs}/struct-order-of-eval-4.rs     | 0
 tests/ui/{structs-enums => structs}/struct-partial-move-1.rs      | 0
 tests/ui/{structs-enums => structs}/struct-partial-move-2.rs      | 0
 .../struct-path-associated-type-2.rs}                             | 0
 .../struct-path-self.rs => structs/struct-path-self-2.rs}         | 0
 tests/ui/{structs-enums => structs}/struct-pattern-matching.rs    | 0
 .../{structs-enums => structs}/struct-variant-field-visibility.rs | 0
 tests/ui/{structs-enums => structs}/uninstantiable-struct.rs      | 0
 tests/ui/{structs-enums => structs}/unit-like-struct-drop-run.rs  | 0
 tests/ui/{structs-enums => structs}/unit-like-struct.rs           | 0
 tests/ui/{structs-enums => structs}/variant-structs-trivial.rs    | 0
 47 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{structs-enums => enum}/auxiliary/namespaced_enum_emulate_flat.rs (100%)
 rename tests/ui/{structs-enums => enum}/auxiliary/namespaced_enums.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-clike-ffi-as-int.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-discrim-manual-sizing.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-discrim-range-overflow.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-discrim-width-stuff.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-disr-val-pretty.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-nullable-simplifycfg-misopt.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-univariant-repr.rs (100%)
 rename tests/ui/{structs-enums => enum}/enum-variants.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enum-emulate-flat-xc.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enum-emulate-flat.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enum-glob-import-xcrate.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enum-glob-import.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enums-xcrate.rs (100%)
 rename tests/ui/{structs-enums => enum}/namespaced-enums.rs (100%)
 rename tests/ui/{structs-enums => enum}/struct-like-variant-construct.rs (100%)
 rename tests/ui/{structs-enums => enum}/struct-like-variant-match.rs (100%)
 rename tests/ui/{structs-enums => parser/recover}/recover-enum-with-bad-where.rs (100%)
 rename tests/ui/{structs-enums => parser/recover}/recover-enum-with-bad-where.stderr (100%)
 rename tests/ui/{structs-enums => structs}/auxiliary/newtype_struct_xc.rs (100%)
 rename tests/ui/{structs-enums => structs}/cross-crate-newtype-struct-pat.rs (100%)
 rename tests/ui/{structs-enums => structs}/field-destruction-order.rs (100%)
 rename tests/ui/{structs-enums => structs}/module-qualified-struct-destructure.rs (100%)
 rename tests/ui/{structs-enums => structs}/newtype-struct-drop-run.rs (100%)
 rename tests/ui/{structs-enums => structs}/newtype-struct-with-dtor.rs (100%)
 rename tests/ui/{structs-enums => structs}/newtype-struct-xc-2.rs (100%)
 rename tests/ui/{structs-enums => structs}/newtype-struct-xc.rs (100%)
 rename tests/ui/{structs-enums => structs}/rec-align-u32.rs (100%)
 rename tests/ui/{structs-enums => structs}/rec-align-u64.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-lit-functional-no-fields.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-literal-dtor.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-new-as-field-name.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-order-of-eval-1.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-order-of-eval-2.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-order-of-eval-3.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-order-of-eval-4.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-partial-move-1.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-partial-move-2.rs (100%)
 rename tests/ui/{structs-enums/struct-path-associated-type.rs => structs/struct-path-associated-type-2.rs} (100%)
 rename tests/ui/{structs-enums/struct-path-self.rs => structs/struct-path-self-2.rs} (100%)
 rename tests/ui/{structs-enums => structs}/struct-pattern-matching.rs (100%)
 rename tests/ui/{structs-enums => structs}/struct-variant-field-visibility.rs (100%)
 rename tests/ui/{structs-enums => structs}/uninstantiable-struct.rs (100%)
 rename tests/ui/{structs-enums => structs}/unit-like-struct-drop-run.rs (100%)
 rename tests/ui/{structs-enums => structs}/unit-like-struct.rs (100%)
 rename tests/ui/{structs-enums => structs}/variant-structs-trivial.rs (100%)

diff --git a/tests/ui/structs-enums/auxiliary/namespaced_enum_emulate_flat.rs b/tests/ui/enum/auxiliary/namespaced_enum_emulate_flat.rs
similarity index 100%
rename from tests/ui/structs-enums/auxiliary/namespaced_enum_emulate_flat.rs
rename to tests/ui/enum/auxiliary/namespaced_enum_emulate_flat.rs
diff --git a/tests/ui/structs-enums/auxiliary/namespaced_enums.rs b/tests/ui/enum/auxiliary/namespaced_enums.rs
similarity index 100%
rename from tests/ui/structs-enums/auxiliary/namespaced_enums.rs
rename to tests/ui/enum/auxiliary/namespaced_enums.rs
diff --git a/tests/ui/structs-enums/enum-clike-ffi-as-int.rs b/tests/ui/enum/enum-clike-ffi-as-int.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-clike-ffi-as-int.rs
rename to tests/ui/enum/enum-clike-ffi-as-int.rs
diff --git a/tests/ui/structs-enums/enum-discrim-manual-sizing.rs b/tests/ui/enum/enum-discrim-manual-sizing.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-discrim-manual-sizing.rs
rename to tests/ui/enum/enum-discrim-manual-sizing.rs
diff --git a/tests/ui/structs-enums/enum-discrim-range-overflow.rs b/tests/ui/enum/enum-discrim-range-overflow.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-discrim-range-overflow.rs
rename to tests/ui/enum/enum-discrim-range-overflow.rs
diff --git a/tests/ui/structs-enums/enum-discrim-width-stuff.rs b/tests/ui/enum/enum-discrim-width-stuff.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-discrim-width-stuff.rs
rename to tests/ui/enum/enum-discrim-width-stuff.rs
diff --git a/tests/ui/structs-enums/enum-disr-val-pretty.rs b/tests/ui/enum/enum-disr-val-pretty.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-disr-val-pretty.rs
rename to tests/ui/enum/enum-disr-val-pretty.rs
diff --git a/tests/ui/structs-enums/enum-nullable-simplifycfg-misopt.rs b/tests/ui/enum/enum-nullable-simplifycfg-misopt.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-nullable-simplifycfg-misopt.rs
rename to tests/ui/enum/enum-nullable-simplifycfg-misopt.rs
diff --git a/tests/ui/structs-enums/enum-univariant-repr.rs b/tests/ui/enum/enum-univariant-repr.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-univariant-repr.rs
rename to tests/ui/enum/enum-univariant-repr.rs
diff --git a/tests/ui/structs-enums/enum-variants.rs b/tests/ui/enum/enum-variants.rs
similarity index 100%
rename from tests/ui/structs-enums/enum-variants.rs
rename to tests/ui/enum/enum-variants.rs
diff --git a/tests/ui/structs-enums/namespaced-enum-emulate-flat-xc.rs b/tests/ui/enum/namespaced-enum-emulate-flat-xc.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enum-emulate-flat-xc.rs
rename to tests/ui/enum/namespaced-enum-emulate-flat-xc.rs
diff --git a/tests/ui/structs-enums/namespaced-enum-emulate-flat.rs b/tests/ui/enum/namespaced-enum-emulate-flat.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enum-emulate-flat.rs
rename to tests/ui/enum/namespaced-enum-emulate-flat.rs
diff --git a/tests/ui/structs-enums/namespaced-enum-glob-import-xcrate.rs b/tests/ui/enum/namespaced-enum-glob-import-xcrate.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enum-glob-import-xcrate.rs
rename to tests/ui/enum/namespaced-enum-glob-import-xcrate.rs
diff --git a/tests/ui/structs-enums/namespaced-enum-glob-import.rs b/tests/ui/enum/namespaced-enum-glob-import.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enum-glob-import.rs
rename to tests/ui/enum/namespaced-enum-glob-import.rs
diff --git a/tests/ui/structs-enums/namespaced-enums-xcrate.rs b/tests/ui/enum/namespaced-enums-xcrate.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enums-xcrate.rs
rename to tests/ui/enum/namespaced-enums-xcrate.rs
diff --git a/tests/ui/structs-enums/namespaced-enums.rs b/tests/ui/enum/namespaced-enums.rs
similarity index 100%
rename from tests/ui/structs-enums/namespaced-enums.rs
rename to tests/ui/enum/namespaced-enums.rs
diff --git a/tests/ui/structs-enums/struct-like-variant-construct.rs b/tests/ui/enum/struct-like-variant-construct.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-like-variant-construct.rs
rename to tests/ui/enum/struct-like-variant-construct.rs
diff --git a/tests/ui/structs-enums/struct-like-variant-match.rs b/tests/ui/enum/struct-like-variant-match.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-like-variant-match.rs
rename to tests/ui/enum/struct-like-variant-match.rs
diff --git a/tests/ui/structs-enums/recover-enum-with-bad-where.rs b/tests/ui/parser/recover/recover-enum-with-bad-where.rs
similarity index 100%
rename from tests/ui/structs-enums/recover-enum-with-bad-where.rs
rename to tests/ui/parser/recover/recover-enum-with-bad-where.rs
diff --git a/tests/ui/structs-enums/recover-enum-with-bad-where.stderr b/tests/ui/parser/recover/recover-enum-with-bad-where.stderr
similarity index 100%
rename from tests/ui/structs-enums/recover-enum-with-bad-where.stderr
rename to tests/ui/parser/recover/recover-enum-with-bad-where.stderr
diff --git a/tests/ui/structs-enums/auxiliary/newtype_struct_xc.rs b/tests/ui/structs/auxiliary/newtype_struct_xc.rs
similarity index 100%
rename from tests/ui/structs-enums/auxiliary/newtype_struct_xc.rs
rename to tests/ui/structs/auxiliary/newtype_struct_xc.rs
diff --git a/tests/ui/structs-enums/cross-crate-newtype-struct-pat.rs b/tests/ui/structs/cross-crate-newtype-struct-pat.rs
similarity index 100%
rename from tests/ui/structs-enums/cross-crate-newtype-struct-pat.rs
rename to tests/ui/structs/cross-crate-newtype-struct-pat.rs
diff --git a/tests/ui/structs-enums/field-destruction-order.rs b/tests/ui/structs/field-destruction-order.rs
similarity index 100%
rename from tests/ui/structs-enums/field-destruction-order.rs
rename to tests/ui/structs/field-destruction-order.rs
diff --git a/tests/ui/structs-enums/module-qualified-struct-destructure.rs b/tests/ui/structs/module-qualified-struct-destructure.rs
similarity index 100%
rename from tests/ui/structs-enums/module-qualified-struct-destructure.rs
rename to tests/ui/structs/module-qualified-struct-destructure.rs
diff --git a/tests/ui/structs-enums/newtype-struct-drop-run.rs b/tests/ui/structs/newtype-struct-drop-run.rs
similarity index 100%
rename from tests/ui/structs-enums/newtype-struct-drop-run.rs
rename to tests/ui/structs/newtype-struct-drop-run.rs
diff --git a/tests/ui/structs-enums/newtype-struct-with-dtor.rs b/tests/ui/structs/newtype-struct-with-dtor.rs
similarity index 100%
rename from tests/ui/structs-enums/newtype-struct-with-dtor.rs
rename to tests/ui/structs/newtype-struct-with-dtor.rs
diff --git a/tests/ui/structs-enums/newtype-struct-xc-2.rs b/tests/ui/structs/newtype-struct-xc-2.rs
similarity index 100%
rename from tests/ui/structs-enums/newtype-struct-xc-2.rs
rename to tests/ui/structs/newtype-struct-xc-2.rs
diff --git a/tests/ui/structs-enums/newtype-struct-xc.rs b/tests/ui/structs/newtype-struct-xc.rs
similarity index 100%
rename from tests/ui/structs-enums/newtype-struct-xc.rs
rename to tests/ui/structs/newtype-struct-xc.rs
diff --git a/tests/ui/structs-enums/rec-align-u32.rs b/tests/ui/structs/rec-align-u32.rs
similarity index 100%
rename from tests/ui/structs-enums/rec-align-u32.rs
rename to tests/ui/structs/rec-align-u32.rs
diff --git a/tests/ui/structs-enums/rec-align-u64.rs b/tests/ui/structs/rec-align-u64.rs
similarity index 100%
rename from tests/ui/structs-enums/rec-align-u64.rs
rename to tests/ui/structs/rec-align-u64.rs
diff --git a/tests/ui/structs-enums/struct-lit-functional-no-fields.rs b/tests/ui/structs/struct-lit-functional-no-fields.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-lit-functional-no-fields.rs
rename to tests/ui/structs/struct-lit-functional-no-fields.rs
diff --git a/tests/ui/structs-enums/struct-literal-dtor.rs b/tests/ui/structs/struct-literal-dtor.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-literal-dtor.rs
rename to tests/ui/structs/struct-literal-dtor.rs
diff --git a/tests/ui/structs-enums/struct-new-as-field-name.rs b/tests/ui/structs/struct-new-as-field-name.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-new-as-field-name.rs
rename to tests/ui/structs/struct-new-as-field-name.rs
diff --git a/tests/ui/structs-enums/struct-order-of-eval-1.rs b/tests/ui/structs/struct-order-of-eval-1.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-order-of-eval-1.rs
rename to tests/ui/structs/struct-order-of-eval-1.rs
diff --git a/tests/ui/structs-enums/struct-order-of-eval-2.rs b/tests/ui/structs/struct-order-of-eval-2.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-order-of-eval-2.rs
rename to tests/ui/structs/struct-order-of-eval-2.rs
diff --git a/tests/ui/structs-enums/struct-order-of-eval-3.rs b/tests/ui/structs/struct-order-of-eval-3.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-order-of-eval-3.rs
rename to tests/ui/structs/struct-order-of-eval-3.rs
diff --git a/tests/ui/structs-enums/struct-order-of-eval-4.rs b/tests/ui/structs/struct-order-of-eval-4.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-order-of-eval-4.rs
rename to tests/ui/structs/struct-order-of-eval-4.rs
diff --git a/tests/ui/structs-enums/struct-partial-move-1.rs b/tests/ui/structs/struct-partial-move-1.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-partial-move-1.rs
rename to tests/ui/structs/struct-partial-move-1.rs
diff --git a/tests/ui/structs-enums/struct-partial-move-2.rs b/tests/ui/structs/struct-partial-move-2.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-partial-move-2.rs
rename to tests/ui/structs/struct-partial-move-2.rs
diff --git a/tests/ui/structs-enums/struct-path-associated-type.rs b/tests/ui/structs/struct-path-associated-type-2.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-path-associated-type.rs
rename to tests/ui/structs/struct-path-associated-type-2.rs
diff --git a/tests/ui/structs-enums/struct-path-self.rs b/tests/ui/structs/struct-path-self-2.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-path-self.rs
rename to tests/ui/structs/struct-path-self-2.rs
diff --git a/tests/ui/structs-enums/struct-pattern-matching.rs b/tests/ui/structs/struct-pattern-matching.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-pattern-matching.rs
rename to tests/ui/structs/struct-pattern-matching.rs
diff --git a/tests/ui/structs-enums/struct-variant-field-visibility.rs b/tests/ui/structs/struct-variant-field-visibility.rs
similarity index 100%
rename from tests/ui/structs-enums/struct-variant-field-visibility.rs
rename to tests/ui/structs/struct-variant-field-visibility.rs
diff --git a/tests/ui/structs-enums/uninstantiable-struct.rs b/tests/ui/structs/uninstantiable-struct.rs
similarity index 100%
rename from tests/ui/structs-enums/uninstantiable-struct.rs
rename to tests/ui/structs/uninstantiable-struct.rs
diff --git a/tests/ui/structs-enums/unit-like-struct-drop-run.rs b/tests/ui/structs/unit-like-struct-drop-run.rs
similarity index 100%
rename from tests/ui/structs-enums/unit-like-struct-drop-run.rs
rename to tests/ui/structs/unit-like-struct-drop-run.rs
diff --git a/tests/ui/structs-enums/unit-like-struct.rs b/tests/ui/structs/unit-like-struct.rs
similarity index 100%
rename from tests/ui/structs-enums/unit-like-struct.rs
rename to tests/ui/structs/unit-like-struct.rs
diff --git a/tests/ui/structs-enums/variant-structs-trivial.rs b/tests/ui/structs/variant-structs-trivial.rs
similarity index 100%
rename from tests/ui/structs-enums/variant-structs-trivial.rs
rename to tests/ui/structs/variant-structs-trivial.rs

From fcf665077c457661f2a31e69b4a93a6fe4ed4c63 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sun, 22 Mar 2026 09:19:52 +0100
Subject: [PATCH 1010/1059] Hookup Signature Inference in more places

---
 .../rust-analyzer/crates/hir-def/src/db.rs    | 152 +------
 .../crates/hir-def/src/expr_store.rs          |  94 +++-
 .../crates/hir-def/src/expr_store/body.rs     |  16 +-
 .../crates/hir-def/src/expr_store/lower.rs    |   7 +-
 .../crates/hir-def/src/expr_store/pretty.rs   |   8 +-
 .../crates/hir-def/src/expr_store/scope.rs    |  65 +--
 .../hir-def/src/expr_store/tests/body.rs      | 153 +++----
 .../src/expr_store/tests/signatures.rs        |   5 +-
 .../crates/hir-def/src/hir/generics.rs        | 137 +++---
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  54 +--
 .../hir-def/src/macro_expansion_tests/mod.rs  |   3 +-
 .../crates/hir-def/src/resolver.rs            |  65 ++-
 .../crates/hir-def/src/signatures.rs          | 219 +++++++---
 .../crates/hir-def/src/test_db.rs             |   5 +-
 .../crates/hir-ty/src/consteval.rs            |  22 +-
 .../crates/hir-ty/src/consteval/tests.rs      |   8 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  12 +-
 .../hir-ty/src/diagnostics/decl_check.rs      |  33 +-
 .../crates/hir-ty/src/diagnostics/expr.rs     |  22 +-
 .../hir-ty/src/diagnostics/match_check.rs     |   5 +-
 .../hir-ty/src/diagnostics/unsafe_check.rs    |  12 +-
 .../crates/hir-ty/src/display.rs              |  67 +--
 .../rust-analyzer/crates/hir-ty/src/drop.rs   |  15 +-
 .../crates/hir-ty/src/dyn_compatibility.rs    |  10 +-
 .../hir-ty/src/dyn_compatibility/tests.rs     |   5 +-
 .../crates/hir-ty/src/generics.rs             |  24 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 163 +++----
 .../crates/hir-ty/src/infer/cast.rs           |   9 +-
 .../hir-ty/src/infer/closure/analysis.rs      |  61 ++-
 .../crates/hir-ty/src/infer/expr.rs           |   3 +-
 .../crates/hir-ty/src/infer/path.rs           |   5 +-
 .../crates/hir-ty/src/infer/unify.rs          |   4 +-
 .../crates/hir-ty/src/lang_items.rs           |   8 +-
 .../rust-analyzer/crates/hir-ty/src/layout.rs |   5 +-
 .../crates/hir-ty/src/layout/adt.rs           |   4 +-
 .../crates/hir-ty/src/layout/tests.rs         |  41 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |   6 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  77 ++--
 .../crates/hir-ty/src/lower/path.rs           |   9 +-
 .../crates/hir-ty/src/method_resolution.rs    |  11 +-
 .../hir-ty/src/method_resolution/probe.rs     |  10 +-
 .../crates/hir-ty/src/mir/borrowck.rs         |  13 +-
 .../crates/hir-ty/src/mir/eval.rs             |  43 +-
 .../crates/hir-ty/src/mir/eval/shim.rs        |   7 +-
 .../crates/hir-ty/src/mir/eval/tests.rs       |   6 +-
 .../crates/hir-ty/src/mir/lower.rs            |  30 +-
 .../crates/hir-ty/src/mir/pretty.rs           |  18 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |  54 +--
 .../hir-ty/src/next_solver/fulfill/errors.rs  |   3 +-
 .../crates/hir-ty/src/next_solver/interner.rs |  61 ++-
 .../crates/hir-ty/src/next_solver/ir_print.rs |  15 +-
 .../crates/hir-ty/src/next_solver/solver.rs   |  96 +++--
 .../crates/hir-ty/src/opaques.rs              |  14 +-
 .../crates/hir-ty/src/specialization.rs       |  13 +-
 .../rust-analyzer/crates/hir-ty/src/tests.rs  |  87 ++--
 .../hir-ty/src/tests/closure_captures.rs      |  16 +-
 .../crates/hir-ty/src/tests/incremental.rs    | 140 +++---
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  34 +-
 .../rust-analyzer/crates/hir-ty/src/upvars.rs |   8 +-
 .../rust-analyzer/crates/hir-ty/src/utils.rs  |   3 +-
 .../crates/hir-ty/src/variance.rs             |   9 +-
 .../rust-analyzer/crates/hir/src/display.rs   |  49 ++-
 .../rust-analyzer/crates/hir/src/from_id.rs   |  17 +-
 .../crates/hir/src/has_source.rs              |   9 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 401 ++++++++++--------
 .../rust-analyzer/crates/hir/src/semantics.rs |  66 +--
 .../hir/src/semantics/child_by_source.rs      |  13 +-
 .../crates/hir/src/semantics/source_to_def.rs |  83 ++--
 .../crates/hir/src/source_analyzer.rs         |  98 +++--
 .../rust-analyzer/crates/hir/src/symbols.rs   |  10 +-
 .../crates/hir/src/term_search/tactics.rs     |   2 +-
 .../src/handlers/add_missing_match_arms.rs    |  12 +-
 .../rust-analyzer/crates/ide-db/src/defs.rs   |  21 +-
 .../rust-analyzer/crates/ide-db/src/search.rs |  48 ++-
 .../ide/src/inlay_hints/implicit_drop.rs      |   4 +-
 .../rust-analyzer/crates/ide/src/rename.rs    |   4 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  47 +-
 77 files changed, 1707 insertions(+), 1481 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index ba0efe0ff13a..9c7f4943db97 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -9,24 +9,16 @@
 
 use crate::{
     AnonConstId, AnonConstLoc, AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc,
-    DefWithBodyId, EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExpressionStoreOwner,
-    ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId,
-    MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
-    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
-    UnionLoc, UseId, UseLoc, VariantId,
+    EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
+    ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id,
+    Macro2Loc, MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags,
+    ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
+    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
     attrs::AttrFlags,
-    expr_store::{
-        Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, scope::ExprScopes,
-    },
     hir::generics::GenericParams,
     import_map::ImportMap,
     item_tree::{ItemTree, file_item_tree_query},
     nameres::crate_def_map,
-    signatures::{
-        ConstSignature, EnumSignature, FunctionSignature, ImplSignature, StaticSignature,
-        StructSignature, TraitSignature, TypeAliasSignature, UnionSignature,
-    },
     visibility::{self, Visibility},
 };
 
@@ -106,144 +98,10 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(macro_def)]
     fn macro_def(&self, m: MacroId) -> MacroDefId;
 
-    // region:data
-
-    #[salsa::tracked]
-    fn trait_signature(&self, trait_: TraitId) -> Arc<TraitSignature> {
-        self.trait_signature_with_source_map(trait_).0
-    }
-
-    #[salsa::tracked]
-    fn impl_signature(&self, impl_: ImplId) -> Arc<ImplSignature> {
-        self.impl_signature_with_source_map(impl_).0
-    }
-
-    #[salsa::tracked]
-    fn struct_signature(&self, struct_: StructId) -> Arc<StructSignature> {
-        self.struct_signature_with_source_map(struct_).0
-    }
-
-    #[salsa::tracked]
-    fn union_signature(&self, union_: UnionId) -> Arc<UnionSignature> {
-        self.union_signature_with_source_map(union_).0
-    }
-
-    #[salsa::tracked]
-    fn enum_signature(&self, e: EnumId) -> Arc<EnumSignature> {
-        self.enum_signature_with_source_map(e).0
-    }
-
-    #[salsa::tracked]
-    fn const_signature(&self, e: ConstId) -> Arc<ConstSignature> {
-        self.const_signature_with_source_map(e).0
-    }
-
-    #[salsa::tracked]
-    fn static_signature(&self, e: StaticId) -> Arc<StaticSignature> {
-        self.static_signature_with_source_map(e).0
-    }
-
-    #[salsa::tracked]
-    fn function_signature(&self, e: FunctionId) -> Arc<FunctionSignature> {
-        self.function_signature_with_source_map(e).0
-    }
-
-    #[salsa::tracked]
-    fn type_alias_signature(&self, e: TypeAliasId) -> Arc<TypeAliasSignature> {
-        self.type_alias_signature_with_source_map(e).0
-    }
-
-    #[salsa::invoke(TraitSignature::query)]
-    fn trait_signature_with_source_map(
-        &self,
-        trait_: TraitId,
-    ) -> (Arc<TraitSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(ImplSignature::query)]
-    fn impl_signature_with_source_map(
-        &self,
-        impl_: ImplId,
-    ) -> (Arc<ImplSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(StructSignature::query)]
-    fn struct_signature_with_source_map(
-        &self,
-        struct_: StructId,
-    ) -> (Arc<StructSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(UnionSignature::query)]
-    fn union_signature_with_source_map(
-        &self,
-        union_: UnionId,
-    ) -> (Arc<UnionSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(EnumSignature::query)]
-    fn enum_signature_with_source_map(
-        &self,
-        e: EnumId,
-    ) -> (Arc<EnumSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(ConstSignature::query)]
-    fn const_signature_with_source_map(
-        &self,
-        e: ConstId,
-    ) -> (Arc<ConstSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(StaticSignature::query)]
-    fn static_signature_with_source_map(
-        &self,
-        e: StaticId,
-    ) -> (Arc<StaticSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(FunctionSignature::query)]
-    fn function_signature_with_source_map(
-        &self,
-        e: FunctionId,
-    ) -> (Arc<FunctionSignature>, Arc<ExpressionStoreSourceMap>);
-
-    #[salsa::invoke(TypeAliasSignature::query)]
-    fn type_alias_signature_with_source_map(
-        &self,
-        e: TypeAliasId,
-    ) -> (Arc<TypeAliasSignature>, Arc<ExpressionStoreSourceMap>);
-
-    // endregion:data
-
-    #[salsa::invoke(Body::body_with_source_map_query)]
-    #[salsa::lru(512)]
-    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
-
-    #[salsa::invoke(Body::body_query)]
-    fn body(&self, def: DefWithBodyId) -> Arc<Body>;
-
-    #[salsa::invoke(ExprScopes::body_expr_scopes_query)]
-    fn body_expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
-
-    #[salsa::invoke(ExprScopes::sig_expr_scopes_query)]
-    fn sig_expr_scopes(&self, def: GenericDefId) -> Arc<ExprScopes>;
-
-    #[salsa::transparent]
-    #[salsa::invoke(ExprScopes::expr_scopes_query)]
-    fn expr_scopes(&self, def: ExpressionStoreOwner) -> Arc<ExprScopes>;
-
     #[salsa::transparent]
     #[salsa::invoke(GenericParams::new)]
     fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
 
-    #[salsa::transparent]
-    #[salsa::invoke(GenericParams::generic_params_and_store)]
-    fn generic_params_and_store(
-        &self,
-        def: GenericDefId,
-    ) -> (Arc<GenericParams>, Arc<ExpressionStore>);
-
-    #[salsa::transparent]
-    #[salsa::invoke(GenericParams::generic_params_and_store_and_source_map)]
-    fn generic_params_and_store_and_source_map(
-        &self,
-        def: GenericDefId,
-    ) -> (Arc<GenericParams>, Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>);
-
     #[salsa::invoke(ImportMap::import_map_query)]
     fn import_map(&self, krate: Crate) -> Arc<ImportMap>;
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
index b5436f3ba338..1ae89e170d9c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
@@ -9,10 +9,7 @@
 #[cfg(test)]
 mod tests;
 
-use std::{
-    ops::{Deref, Index},
-    sync::LazyLock,
-};
+use std::ops::{Deref, Index};
 
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
@@ -23,11 +20,10 @@
 use span::{Edition, SyntaxContext};
 use syntax::{AstPtr, SyntaxNodePtr, ast};
 use thin_vec::ThinVec;
-use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
-    BlockId, SyntheticSyntax,
+    AdtId, BlockId, ExpressionStoreOwnerId, GenericDefId, SyntheticSyntax,
     db::DefDatabase,
     expr_store::path::Path,
     hir::{
@@ -431,13 +427,85 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
 }
 
 impl ExpressionStore {
-    pub fn empty_singleton() -> (Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>) {
-        static EMPTY: LazyLock<(Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>)> =
-            LazyLock::new(|| {
-                let (store, source_map) = ExpressionStoreBuilder::default().finish();
-                (Arc::new(store), Arc::new(source_map))
-            });
-        EMPTY.clone()
+    pub fn of(db: &dyn DefDatabase, def: ExpressionStoreOwnerId) -> &ExpressionStore {
+        match def {
+            ExpressionStoreOwnerId::Signature(def) => {
+                use crate::signatures::{
+                    ConstSignature, EnumSignature, FunctionSignature, ImplSignature,
+                    StaticSignature, StructSignature, TraitSignature, TypeAliasSignature,
+                    UnionSignature,
+                };
+                match def {
+                    GenericDefId::AdtId(AdtId::EnumId(id)) => &EnumSignature::of(db, id).store,
+                    GenericDefId::AdtId(AdtId::StructId(id)) => &StructSignature::of(db, id).store,
+                    GenericDefId::AdtId(AdtId::UnionId(id)) => &UnionSignature::of(db, id).store,
+                    GenericDefId::ConstId(id) => &ConstSignature::of(db, id).store,
+                    GenericDefId::FunctionId(id) => &FunctionSignature::of(db, id).store,
+                    GenericDefId::ImplId(id) => &ImplSignature::of(db, id).store,
+                    GenericDefId::StaticId(id) => &StaticSignature::of(db, id).store,
+                    GenericDefId::TraitId(id) => &TraitSignature::of(db, id).store,
+                    GenericDefId::TypeAliasId(id) => &TypeAliasSignature::of(db, id).store,
+                }
+            }
+            ExpressionStoreOwnerId::Body(body) => &Body::of(db, body).store,
+        }
+    }
+
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        def: ExpressionStoreOwnerId,
+    ) -> (&ExpressionStore, &ExpressionStoreSourceMap) {
+        match def {
+            ExpressionStoreOwnerId::Signature(def) => {
+                use crate::signatures::{
+                    ConstSignature, EnumSignature, FunctionSignature, ImplSignature,
+                    StaticSignature, StructSignature, TraitSignature, TypeAliasSignature,
+                    UnionSignature,
+                };
+                match def {
+                    GenericDefId::AdtId(AdtId::EnumId(id)) => {
+                        let sig = EnumSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::AdtId(AdtId::StructId(id)) => {
+                        let sig = StructSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::AdtId(AdtId::UnionId(id)) => {
+                        let sig = UnionSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::ConstId(id) => {
+                        let sig = ConstSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::FunctionId(id) => {
+                        let sig = FunctionSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::ImplId(id) => {
+                        let sig = ImplSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::StaticId(id) => {
+                        let sig = StaticSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::TraitId(id) => {
+                        let sig = TraitSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                    GenericDefId::TypeAliasId(id) => {
+                        let sig = TypeAliasSignature::with_source_map(db, id);
+                        (&sig.0.store, &sig.1)
+                    }
+                }
+            }
+            ExpressionStoreOwnerId::Body(body) => {
+                let (store, sm) = Body::with_source_map(db, body);
+                (&store.store, &sm.store)
+            }
+        }
     }
 
     /// Returns all const expression root `ExprId`s found in this store.
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
index ad8fa73ad839..60aaba5b84db 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
@@ -68,11 +68,10 @@ fn deref(&self) -> &Self::Target {
     }
 }
 
+#[salsa::tracked]
 impl Body {
-    pub(crate) fn body_with_source_map_query(
-        db: &dyn DefDatabase,
-        def: DefWithBodyId,
-    ) -> (Arc<Body>, Arc<BodySourceMap>) {
+    #[salsa::tracked(lru = 512, returns(ref))]
+    pub fn with_source_map(db: &dyn DefDatabase, def: DefWithBodyId) -> (Arc<Body>, BodySourceMap) {
         let _p = tracing::info_span!("body_with_source_map_query").entered();
         let mut params = None;
 
@@ -106,13 +105,16 @@ pub(crate) fn body_with_source_map_query(
         let module = def.module(db);
         let (body, source_map) = lower_body(db, def, file_id, module, params, body, is_async_fn);
 
-        (Arc::new(body), Arc::new(source_map))
+        (Arc::new(body), source_map)
     }
 
-    pub(crate) fn body_query(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<Body> {
-        db.body_with_source_map(def).0
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<Body> {
+        Self::with_source_map(db, def).0.clone()
     }
+}
 
+impl Body {
     pub fn pretty_print(
         &self,
         db: &dyn DefDatabase,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index 67ce5eafc6d8..3ed1b587411c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -53,6 +53,7 @@
     item_tree::FieldsShape,
     lang_item::{LangItemTarget, LangItems},
     nameres::{DefMap, LocalDefMap, MacroSubNs, block_def_map},
+    signatures::StructSignature,
     type_ref::{
         ArrayType, ConstRef, FnType, LifetimeRef, LifetimeRefId, Mutability, PathId, Rawness,
         RefType, TraitBoundModifier, TraitRef, TypeBound, TypeRef, TypeRefId, UseArgRef,
@@ -200,13 +201,13 @@ pub(crate) fn lower_generic_params(
     file_id: HirFileId,
     param_list: Option<ast::GenericParamList>,
     where_clause: Option<ast::WhereClause>,
-) -> (Arc<ExpressionStore>, Arc<GenericParams>, ExpressionStoreSourceMap) {
+) -> (ExpressionStore, Arc<GenericParams>, ExpressionStoreSourceMap) {
     let mut expr_collector = ExprCollector::signature(db, module, file_id);
     let mut collector = generics::GenericParamsCollector::new(def);
     collector.lower(&mut expr_collector, param_list, where_clause);
     let params = collector.finish();
     let (store, source_map) = expr_collector.store.finish();
-    (Arc::new(store), params, source_map)
+    (store, params, source_map)
 }
 
 pub(crate) fn lower_impl(
@@ -2363,7 +2364,7 @@ fn collect_pat(&mut self, pat: ast::Pat, binding_list: &mut BindingList) -> PatI
                         }
                         Some(ModuleDefId::AdtId(AdtId::StructId(s)))
                         // FIXME: This can cause a cycle if the user is writing invalid code
-                            if self.db.struct_signature(s).shape != FieldsShape::Record =>
+                            if StructSignature::of(self.db, s).shape != FieldsShape::Record =>
                         {
                             (None, Pat::Path(name.into()))
                         }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
index 35f3cd114e36..405ebe9b7bc9 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
@@ -168,8 +168,8 @@ pub fn print_signature(db: &dyn DefDatabase, owner: GenericDefId, edition: Editi
     match owner {
         GenericDefId::AdtId(id) => match id {
             AdtId::StructId(id) => {
-                let signature = db.struct_signature(id);
-                print_struct(db, id, &signature, edition)
+                let signature = StructSignature::of(db, id);
+                print_struct(db, id, signature, edition)
             }
             AdtId::UnionId(id) => {
                 format!("unimplemented {id:?}")
@@ -180,8 +180,8 @@ pub fn print_signature(db: &dyn DefDatabase, owner: GenericDefId, edition: Editi
         },
         GenericDefId::ConstId(id) => format!("unimplemented {id:?}"),
         GenericDefId::FunctionId(id) => {
-            let signature = db.function_signature(id);
-            print_function(db, id, &signature, edition)
+            let signature = FunctionSignature::of(db, id);
+            print_function(db, id, signature, edition)
         }
         GenericDefId::ImplId(id) => format!("unimplemented {id:?}"),
         GenericDefId::StaticId(id) => format!("unimplemented {id:?}"),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
index 43ce053836c4..2250cf5f1638 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
@@ -1,13 +1,15 @@
 //! Name resolution for expressions.
 use hir_expand::{MacroDefId, name::Name};
 use la_arena::{Arena, ArenaMap, Idx, IdxRange, RawIdx};
-use triomphe::Arc;
 
 use crate::{
-    BlockId, DefWithBodyId, ExpressionStoreOwner, GenericDefId,
+    BlockId, DefWithBodyId, ExpressionStoreOwnerId, GenericDefId,
     db::DefDatabase,
     expr_store::{Body, ExpressionStore, HygieneId},
-    hir::{Binding, BindingId, Expr, ExprId, Item, LabelId, Pat, PatId, Statement},
+    hir::{
+        Binding, BindingId, Expr, ExprId, Item, LabelId, Pat, PatId, Statement,
+        generics::GenericParams,
+    },
 };
 
 pub type ScopeId = Idx<ScopeData>;
@@ -50,36 +52,33 @@ pub struct ScopeData {
     entries: IdxRange<ScopeEntry>,
 }
 
+#[salsa::tracked]
 impl ExprScopes {
-    pub(crate) fn expr_scopes_query(
-        db: &dyn DefDatabase,
-        def: ExpressionStoreOwner,
-    ) -> Arc<ExprScopes> {
-        match def {
-            ExpressionStoreOwner::Body(def) => db.body_expr_scopes(def),
-            ExpressionStoreOwner::Signature(def) => db.sig_expr_scopes(def),
-        }
-    }
-
-    pub(crate) fn body_expr_scopes_query(
-        db: &dyn DefDatabase,
-        def: DefWithBodyId,
-    ) -> Arc<ExprScopes> {
-        let body = db.body(def);
-        let mut scopes = ExprScopes::new_body(&body);
+    #[salsa::tracked(returns(ref))]
+    pub fn body_expr_scopes(db: &dyn DefDatabase, def: DefWithBodyId) -> ExprScopes {
+        let body = Body::of(db, def);
+        let mut scopes = ExprScopes::new_body(body);
         scopes.shrink_to_fit();
-        Arc::new(scopes)
+        scopes
     }
 
-    pub(crate) fn sig_expr_scopes_query(
-        db: &dyn DefDatabase,
-        def: GenericDefId,
-    ) -> Arc<ExprScopes> {
-        let (_, store) = db.generic_params_and_store(def);
+    #[salsa::tracked(returns(ref))]
+    pub fn sig_expr_scopes(db: &dyn DefDatabase, def: GenericDefId) -> ExprScopes {
+        let (_, store) = GenericParams::of(db, def);
         let roots = store.signature_const_expr_roots();
-        let mut scopes = ExprScopes::new_store(&store, roots);
+        let mut scopes = ExprScopes::new_store(store, roots);
         scopes.shrink_to_fit();
-        Arc::new(scopes)
+        scopes
+    }
+}
+
+impl ExprScopes {
+    #[inline]
+    pub fn of(db: &dyn DefDatabase, def: impl Into<ExpressionStoreOwnerId>) -> &ExprScopes {
+        match def.into() {
+            ExpressionStoreOwnerId::Body(def) => Self::body_expr_scopes(db, def),
+            ExpressionStoreOwnerId::Signature(def) => Self::sig_expr_scopes(db, def),
+        }
     }
 
     pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
@@ -367,7 +366,9 @@ mod tests {
     use test_utils::{assert_eq_text, extract_offset};
 
     use crate::{
-        DefWithBodyId, FunctionId, ModuleDefId, db::DefDatabase, nameres::crate_def_map,
+        DefWithBodyId, FunctionId, ModuleDefId,
+        expr_store::{Body, scope::ExprScopes},
+        nameres::crate_def_map,
         test_db::TestDB,
     };
 
@@ -404,8 +405,8 @@ fn do_check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected: &[&str])
         let marker: ast::PathExpr = find_node_at_offset(&file_syntax, offset).unwrap();
         let function = find_function(&db, file_id);
 
-        let scopes = db.expr_scopes(DefWithBodyId::from(function).into());
-        let (_body, source_map) = db.body_with_source_map(function.into());
+        let scopes = ExprScopes::of(&db, DefWithBodyId::from(function));
+        let (_body, source_map) = Body::with_source_map(&db, function.into());
 
         let expr_id = source_map
             .node_expr(InFile { file_id: editioned_file_id.into(), value: &marker.into() })
@@ -563,8 +564,8 @@ fn do_check_local_name(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected
 
         let function = find_function(&db, file_id);
 
-        let scopes = db.expr_scopes(DefWithBodyId::from(function).into());
-        let (_, source_map) = db.body_with_source_map(function.into());
+        let scopes = ExprScopes::body_expr_scopes(&db, DefWithBodyId::from(function));
+        let (_, source_map) = Body::with_source_map(&db, function.into());
 
         let expr_scope = {
             let expr_ast = name_ref.syntax().ancestors().find_map(ast::Expr::cast).unwrap();
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body.rs
index 8f857aeeff95..985cd9666267 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body.rs
@@ -4,11 +4,10 @@
 use expect_test::{Expect, expect};
 use la_arena::RawIdx;
 use test_fixture::WithFixture;
-use triomphe::Arc;
 
 use super::super::*;
 
-fn lower(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (TestDB, Arc<Body>, DefWithBodyId) {
+fn lower(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (TestDB, DefWithBodyId) {
     let db = TestDB::with_files(ra_fixture);
 
     let krate = db.fetch_test_crate();
@@ -24,8 +23,27 @@ fn lower(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> (TestDB, Arc<Body>,
     }
     let fn_def = fn_def.unwrap().into();
 
-    let body = db.body(fn_def);
-    (db, body, fn_def)
+    Body::of(&db, fn_def);
+    (db, fn_def)
+}
+
+fn pretty_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
+    let db = TestDB::with_files(ra_fixture);
+
+    let krate = db.fetch_test_crate();
+    let def_map = crate_def_map(&db, krate);
+    let mut fn_def = None;
+    'outer: for (_, module) in def_map.modules() {
+        for decl in module.scope.declarations() {
+            if let ModuleDefId::FunctionId(it) = decl {
+                fn_def = Some(it);
+                break 'outer;
+            }
+        }
+    }
+    let fn_def = fn_def.unwrap().into();
+
+    expect.assert_eq(&Body::of(&db, fn_def).pretty_print(&db, fn_def, Edition::CURRENT));
 }
 
 fn def_map_at(#[rust_analyzer::rust_fixture] ra_fixture: &str) -> String {
@@ -144,7 +162,7 @@ fn outer() {
 
 #[test]
 fn desugar_for_loop() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 //- minicore: iterator
 fn main() {
@@ -154,9 +172,7 @@ fn main() {
     }
 }
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main() {
             match builtin#lang(into_iter)(
                 0..10,
@@ -173,13 +189,13 @@ fn main() {
                     }
                 },
             }
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    );
 }
 
 #[test]
 fn desugar_builtin_format_args_before_1_89_0() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 //- minicore: fmt_before_1_89_0
 fn main() {
@@ -188,9 +204,7 @@ fn main() {
     builtin#format_args("\u{1b}hello {count:02} {} friends, we {are:?} {0}{last}", "fancy", orphan = (), last = "!");
 }
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main() {
             let are = "are";
             let count = 10;
@@ -256,13 +270,13 @@ fn main() {
                     }
                 },
             );
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn desugar_builtin_format_args_before_1_93_0() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 //- minicore: fmt_before_1_93_0
 fn main() {
@@ -271,9 +285,7 @@ fn main() {
     builtin#format_args("\u{1b}hello {count:02} {} friends, we {are:?} {0}{last}", "fancy", orphan = (), last = "!");
 }
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main() {
             let are = "are";
             let count = 10;
@@ -339,13 +351,13 @@ fn main() {
                     )
                 }
             };
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn desugar_builtin_format_args() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 //- minicore: fmt
 fn main() {
@@ -356,9 +368,7 @@ fn main() {
     builtin#format_args("hello world", orphan = ());
 }
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main() {
             let are = "are";
             let count = 10;
@@ -392,13 +402,13 @@ fn main() {
                     "hello world",
                 )
             };
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn test_macro_hygiene() {
-    let (db, body, def) = lower(
+    pretty_print(
         r##"
 //- minicore: fmt, from
 //- /main.rs
@@ -428,10 +438,7 @@ pub(crate) fn new(message: impl Into<core::fmt::Arguments>) -> SsrError {
     }
 }
 "##,
-    );
-
-    assert_eq!(db.body_with_source_map(def).1.diagnostics(), &[]);
-    expect![[r#"
+        expect![[r#"
         fn main() {
             _ = ra_test_fixture::error::SsrError::new(
                 {
@@ -449,13 +456,13 @@ fn main() {
                     }
                 },
             );
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn regression_10300() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 //- minicore: concat, panic, fmt_before_1_89_0
 mod private {
@@ -472,16 +479,7 @@ fn f(a: i32, b: u32) -> String {
     m!();
 }
 "#,
-    );
-
-    let (_, source_map) = db.body_with_source_map(def);
-    assert_eq!(source_map.diagnostics(), &[]);
-
-    for (_, def_map) in body.blocks(&db) {
-        assert_eq!(def_map.diagnostics(), &[]);
-    }
-
-    expect![[r#"
+        expect![[r#"
         fn f(a, b) {
             {
                 core::panicking::panic_fmt(
@@ -497,8 +495,8 @@ fn f(a, b) {
                     ),
                 );
             };
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
@@ -507,7 +505,7 @@ fn destructuring_assignment_tuple_macro() {
     // but in destructuring assignment it is valid, because `m!()()` is a valid expression, and destructuring
     // assignments start their lives as expressions. So we have to do the same.
 
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 struct Bar();
 
@@ -519,25 +517,16 @@ fn foo() {
     m!()() = Bar();
 }
 "#,
-    );
-
-    let (_, source_map) = db.body_with_source_map(def);
-    assert_eq!(source_map.diagnostics(), &[]);
-
-    for (_, def_map) in body.blocks(&db) {
-        assert_eq!(def_map.diagnostics(), &[]);
-    }
-
-    expect![[r#"
+        expect![[r#"
         fn foo() {
             Bar() = Bar();
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn shadowing_record_variant() {
-    let (_, body, _) = lower(
+    let (db, def) = lower(
         r#"
 enum A {
     B { field: i32 },
@@ -550,6 +539,7 @@ fn f() {
 }
     "#,
     );
+    let body = Body::of(&db, def);
     assert_eq!(body.assert_expr_only().bindings.len(), 1, "should have a binding for `B`");
     assert_eq!(
         body[BindingId::from_raw(RawIdx::from_u32(0))].name.as_str(),
@@ -560,39 +550,35 @@ fn f() {
 
 #[test]
 fn regression_pretty_print_bind_pat() {
-    let (db, body, owner) = lower(
+    pretty_print(
         r#"
 fn foo() {
     let v @ u = 123;
 }
 "#,
-    );
-    let printed = body.pretty_print(&db, owner, Edition::CURRENT);
-
-    expect![[r#"
+        expect![[r#"
         fn foo() {
             let v @ u = 123;
-        }"#]]
-    .assert_eq(&printed);
+        }"#]],
+    );
 }
 
 #[test]
 fn skip_skips_body() {
-    let (db, body, owner) = lower(
+    pretty_print(
         r#"
 #[rust_analyzer::skip]
 async fn foo(a: (), b: i32) -> u32 {
     0 + 1 + b()
 }
 "#,
+        expect!["fn foo(�, �) �"],
     );
-    let printed = body.pretty_print(&db, owner, Edition::CURRENT);
-    expect!["fn foo(�, �) �"].assert_eq(&printed);
 }
 
 #[test]
 fn range_bounds_are_hir_exprs() {
-    let (_, body, _) = lower(
+    let (db, body) = lower(
         r#"
 pub const L: i32 = 6;
 mod x {
@@ -607,6 +593,7 @@ const fn f(x: i32) -> i32 {
 }"#,
     );
 
+    let body = Body::of(&db, body);
     let mtch_arms = body
         .assert_expr_only()
         .exprs
@@ -635,7 +622,7 @@ const fn f(x: i32) -> i32 {
 
 #[test]
 fn print_hir_precedences() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 fn main() {
     _ = &(1 - (2 - 3) + 4 * 5 * (6 + 7));
@@ -646,9 +633,7 @@ fn main() {
     let _ = &mut (*r as i32)
 }
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main() {
             _ = &((1 - (2 - 3)) + (4 * 5) * (6 + 7));
             _ = 1 + 2 < 3 && true && 4 < 5 && (a || b || c) || d && e;
@@ -656,24 +641,22 @@ fn main() {
             break a && b || (return) || (return 2);
             let r = &2;
             let _ = &mut (*r as i32);
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
 
 #[test]
 fn async_fn_weird_param_patterns() {
-    let (db, body, def) = lower(
+    pretty_print(
         r#"
 async fn main(&self, param1: i32, ref mut param2: i32, _: i32, param4 @ _: i32, 123: i32) {}
 "#,
-    );
-
-    expect![[r#"
+        expect![[r#"
         fn main(self, param1, mut param2, mut <ra@gennew>0, param4 @ _, mut <ra@gennew>1) async {
             let ref mut param2 = param2;
             let _ = <ra@gennew>0;
             let 123 = <ra@gennew>1;
             {}
-        }"#]]
-    .assert_eq(&body.pretty_print(&db, def, Edition::CURRENT))
+        }"#]],
+    )
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
index f1db00cf6a67..5e0184dfad82 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
@@ -2,6 +2,7 @@
     GenericDefId, ModuleDefId,
     expr_store::pretty::{print_function, print_struct},
     nameres::crate_def_map,
+    signatures::{FunctionSignature, StructSignature},
     test_db::TestDB,
 };
 use expect_test::{Expect, expect};
@@ -41,7 +42,7 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
                     out += &print_struct(
                         &db,
                         struct_id,
-                        &db.struct_signature(struct_id),
+                        StructSignature::of(&db, struct_id),
                         Edition::CURRENT,
                     );
                 }
@@ -53,7 +54,7 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
                 out += &print_function(
                     &db,
                     function_id,
-                    &db.function_signature(function_id),
+                    FunctionSignature::of(&db, function_id),
                     Edition::CURRENT,
                 )
             }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
index 022f8adfdb06..41767131fc3b 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
@@ -11,6 +11,10 @@
     AdtId, ConstParamId, GenericDefId, LifetimeParamId, TypeOrConstParamId, TypeParamId,
     db::DefDatabase,
     expr_store::{ExpressionStore, ExpressionStoreSourceMap},
+    signatures::{
+        ConstSignature, EnumSignature, FunctionSignature, ImplSignature, StaticSignature,
+        StructSignature, TraitSignature, TypeAliasSignature, UnionSignature,
+    },
     type_ref::{ConstRef, LifetimeRefId, TypeBound, TypeRefId},
 };
 
@@ -188,111 +192,90 @@ impl GenericParams {
         LocalTypeOrConstParamId::from_raw(RawIdx::from_u32(0));
 
     pub fn new(db: &dyn DefDatabase, def: GenericDefId) -> Arc<GenericParams> {
+        Self::of(db, def).0
+    }
+
+    pub fn of(db: &dyn DefDatabase, def: GenericDefId) -> (Arc<GenericParams>, &ExpressionStore) {
         match def {
-            GenericDefId::AdtId(AdtId::EnumId(it)) => db.enum_signature(it).generic_params.clone(),
-            GenericDefId::AdtId(AdtId::StructId(it)) => {
-                db.struct_signature(it).generic_params.clone()
+            GenericDefId::AdtId(AdtId::EnumId(id)) => {
+                let sig = EnumSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
             }
-            GenericDefId::AdtId(AdtId::UnionId(it)) => {
-                db.union_signature(it).generic_params.clone()
+            GenericDefId::AdtId(AdtId::StructId(id)) => {
+                let sig = StructSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
             }
-            GenericDefId::ConstId(_) => EMPTY.clone(),
-            GenericDefId::FunctionId(function_id) => {
-                db.function_signature(function_id).generic_params.clone()
+            GenericDefId::AdtId(AdtId::UnionId(id)) => {
+                let sig = UnionSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
             }
-            GenericDefId::ImplId(impl_id) => db.impl_signature(impl_id).generic_params.clone(),
-            GenericDefId::StaticId(_) => EMPTY.clone(),
-            GenericDefId::TraitId(trait_id) => db.trait_signature(trait_id).generic_params.clone(),
-            GenericDefId::TypeAliasId(type_alias_id) => {
-                db.type_alias_signature(type_alias_id).generic_params.clone()
+            GenericDefId::FunctionId(id) => {
+                let sig = FunctionSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
+            }
+            GenericDefId::ImplId(id) => {
+                let sig = ImplSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
+            }
+            GenericDefId::TraitId(id) => {
+                let sig = TraitSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
+            }
+            GenericDefId::TypeAliasId(id) => {
+                let sig = TypeAliasSignature::of(db, id);
+                (sig.generic_params.clone(), &sig.store)
+            }
+            GenericDefId::ConstId(id) => {
+                let sig = ConstSignature::of(db, id);
+                (EMPTY.clone(), &sig.store)
+            }
+            GenericDefId::StaticId(id) => {
+                let sig = StaticSignature::of(db, id);
+                (EMPTY.clone(), &sig.store)
             }
         }
     }
 
-    pub fn generic_params_and_store(
+    pub fn with_source_map(
         db: &dyn DefDatabase,
         def: GenericDefId,
-    ) -> (Arc<GenericParams>, Arc<ExpressionStore>) {
+    ) -> (Arc<GenericParams>, &ExpressionStore, &ExpressionStoreSourceMap) {
         match def {
             GenericDefId::AdtId(AdtId::EnumId(id)) => {
-                let sig = db.enum_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = EnumSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::AdtId(AdtId::StructId(id)) => {
-                let sig = db.struct_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = StructSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::AdtId(AdtId::UnionId(id)) => {
-                let sig = db.union_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = UnionSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::ConstId(id) => {
-                let sig = db.const_signature(id);
-                (EMPTY.clone(), sig.store.clone())
+                let (sig, sm) = ConstSignature::with_source_map(db, id);
+                (EMPTY.clone(), &sig.store, sm)
             }
             GenericDefId::FunctionId(id) => {
-                let sig = db.function_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = FunctionSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::ImplId(id) => {
-                let sig = db.impl_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = ImplSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::StaticId(id) => {
-                let sig = db.static_signature(id);
-                (EMPTY.clone(), sig.store.clone())
+                let (sig, sm) = StaticSignature::with_source_map(db, id);
+                (EMPTY.clone(), &sig.store, sm)
             }
             GenericDefId::TraitId(id) => {
-                let sig = db.trait_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
+                let (sig, sm) = TraitSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
             GenericDefId::TypeAliasId(id) => {
-                let sig = db.type_alias_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
-            }
-        }
-    }
-
-    pub fn generic_params_and_store_and_source_map(
-        db: &dyn DefDatabase,
-        def: GenericDefId,
-    ) -> (Arc<GenericParams>, Arc<ExpressionStore>, Arc<ExpressionStoreSourceMap>) {
-        match def {
-            GenericDefId::AdtId(AdtId::EnumId(id)) => {
-                let (sig, sm) = db.enum_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::AdtId(AdtId::StructId(id)) => {
-                let (sig, sm) = db.struct_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::AdtId(AdtId::UnionId(id)) => {
-                let (sig, sm) = db.union_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::ConstId(id) => {
-                let (sig, sm) = db.const_signature_with_source_map(id);
-                (EMPTY.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::FunctionId(id) => {
-                let (sig, sm) = db.function_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::ImplId(id) => {
-                let (sig, sm) = db.impl_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::StaticId(id) => {
-                let (sig, sm) = db.static_signature_with_source_map(id);
-                (EMPTY.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::TraitId(id) => {
-                let (sig, sm) = db.trait_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
-            GenericDefId::TypeAliasId(id) => {
-                let (sig, sm) = db.type_alias_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
+                let (sig, sm) = TypeAliasSignature::with_source_map(db, id);
+                (sig.generic_params.clone(), &sig.store, sm)
             }
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index ffad5fee47ff..4387ef055fdd 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -49,7 +49,6 @@
 use intern::{Interned, Symbol};
 pub use rustc_abi as layout;
 use thin_vec::ThinVec;
-use triomphe::Arc;
 
 pub use crate::signatures::LocalFieldId;
 
@@ -96,7 +95,9 @@
         block_def_map, crate_def_map, crate_local_def_map,
         diagnostics::DefDiagnostics,
     },
-    signatures::{EnumVariants, InactiveEnumVariantCode, VariantFields},
+    signatures::{
+        ConstSignature, EnumVariants, InactiveEnumVariantCode, StaticSignature, VariantFields,
+    },
 };
 
 type FxIndexMap<K, V> = indexmap::IndexMap<K, V, rustc_hash::FxBuildHasher>;
@@ -264,8 +265,9 @@ pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
     pub fn fields_with_source_map(
         self,
         db: &dyn DefDatabase,
-    ) -> (Arc<VariantFields>, Arc<ExpressionStoreSourceMap>) {
-        VariantFields::query(db, self.into())
+    ) -> (&VariantFields, &ExpressionStoreSourceMap) {
+        let r = VariantFields::with_source_map(db, self.into());
+        (&r.0, &r.1)
     }
 }
 
@@ -280,8 +282,9 @@ pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
     pub fn fields_with_source_map(
         self,
         db: &dyn DefDatabase,
-    ) -> (Arc<VariantFields>, Arc<ExpressionStoreSourceMap>) {
-        VariantFields::query(db, self.into())
+    ) -> (&VariantFields, &ExpressionStoreSourceMap) {
+        let r = VariantFields::with_source_map(db, self.into());
+        (&r.0, &r.1)
     }
 }
 
@@ -315,7 +318,7 @@ pub fn enum_variants_with_diagnostics(
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
 pub struct AnonConstLoc {
     /// The owner store containing this expression.
-    pub owner: ExpressionStoreOwner,
+    pub owner: ExpressionStoreOwnerId,
     /// The ExprId within the owner's ExpressionStore that is the root
     /// of this anonymous const expression.
     pub expr: ExprId,
@@ -399,8 +402,9 @@ pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
     pub fn fields_with_source_map(
         self,
         db: &dyn DefDatabase,
-    ) -> (Arc<VariantFields>, Arc<ExpressionStoreSourceMap>) {
-        VariantFields::query(db, self.into())
+    ) -> (&VariantFields, &ExpressionStoreSourceMap) {
+        let r = VariantFields::with_source_map(db, self.into());
+        (&r.0, &r.1)
     }
 }
 
@@ -739,10 +743,10 @@ pub fn generic_def(self, db: &dyn DefDatabase) -> Option<GenericDefId> {
     pub fn name(self, db: &dyn DefDatabase) -> String {
         match self {
             GeneralConstId::StaticId(it) => {
-                db.static_signature(it).name.display(db, Edition::CURRENT).to_string()
+                StaticSignature::of(db, it).name.display(db, Edition::CURRENT).to_string()
             }
             GeneralConstId::ConstId(const_id) => {
-                db.const_signature(const_id).name.as_ref().map_or_else(
+                ConstSignature::of(db, const_id).name.as_ref().map_or_else(
                     || "_".to_owned(),
                     |name| name.display(db, Edition::CURRENT).to_string(),
                 )
@@ -837,20 +841,21 @@ pub enum GenericDefId {
 /// This is used for queries that operate on expression stores generically,
 /// such as `expr_scopes`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum ExpressionStoreOwner {
+pub enum ExpressionStoreOwnerId {
     Signature(GenericDefId),
     Body(DefWithBodyId),
 }
 
-impl ExpressionStoreOwner {
+impl ExpressionStoreOwnerId {
+    // FIXME: Check callers of this, this method likely can be removed
     pub fn as_def_with_body(self) -> Option<DefWithBodyId> {
         if let Self::Body(v) = self { Some(v) } else { None }
     }
 
     pub fn generic_def(self, db: &dyn DefDatabase) -> GenericDefId {
         match self {
-            ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id,
-            ExpressionStoreOwner::Body(def_with_body_id) => match def_with_body_id {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => generic_def_id,
+            ExpressionStoreOwnerId::Body(def_with_body_id) => match def_with_body_id {
                 DefWithBodyId::FunctionId(id) => GenericDefId::FunctionId(id),
                 DefWithBodyId::StaticId(id) => GenericDefId::StaticId(id),
                 DefWithBodyId::ConstId(id) => GenericDefId::ConstId(id),
@@ -860,15 +865,15 @@ pub fn generic_def(self, db: &dyn DefDatabase) -> GenericDefId {
     }
 }
 
-impl From<GenericDefId> for ExpressionStoreOwner {
+impl From<GenericDefId> for ExpressionStoreOwnerId {
     fn from(id: GenericDefId) -> Self {
-        ExpressionStoreOwner::Signature(id)
+        ExpressionStoreOwnerId::Signature(id)
     }
 }
 
-impl From<DefWithBodyId> for ExpressionStoreOwner {
+impl From<DefWithBodyId> for ExpressionStoreOwnerId {
     fn from(id: DefWithBodyId) -> Self {
-        ExpressionStoreOwner::Body(id)
+        ExpressionStoreOwnerId::Body(id)
     }
 }
 
@@ -1028,8 +1033,9 @@ pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
     pub fn fields_with_source_map(
         self,
         db: &dyn DefDatabase,
-    ) -> (Arc<VariantFields>, Arc<ExpressionStoreSourceMap>) {
-        VariantFields::query(db, self)
+    ) -> (&VariantFields, &ExpressionStoreSourceMap) {
+        let r = VariantFields::with_source_map(db, self);
+        (&r.0, &r.1)
     }
 
     pub fn file_id(self, db: &dyn DefDatabase) -> HirFileId {
@@ -1230,11 +1236,11 @@ fn module(&self, db: &dyn DefDatabase) -> ModuleId {
     }
 }
 
-impl HasModule for ExpressionStoreOwner {
+impl HasModule for ExpressionStoreOwnerId {
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {
         match self {
-            ExpressionStoreOwner::Signature(def) => def.module(db),
-            ExpressionStoreOwner::Body(def) => def.module(db),
+            ExpressionStoreOwnerId::Signature(def) => def.module(db),
+            ExpressionStoreOwnerId::Body(def) => def.module(db),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
index 8ee93dcaa32d..8317c56caf76 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs
@@ -45,6 +45,7 @@
 use crate::{
     AdtId, Lookup, ModuleDefId,
     db::DefDatabase,
+    expr_store::Body,
     nameres::{DefMap, ModuleSource, crate_def_map},
     src::HasSource,
     test_db::TestDB,
@@ -276,7 +277,7 @@ fn resolve_macro_call_id(
                 _ => continue,
             };
 
-            let (body, sm) = db.body_with_source_map(body);
+            let (body, sm) = Body::with_source_map(db, body);
             if let Some(it) = body
                 .blocks(db)
                 .find_map(|block| resolve_macro_call_id(db, block.1, ast_id, ast_ptr))
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 38b461770cbf..9ffa80346c2f 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -17,7 +17,7 @@
 
 use crate::{
     AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    ExpressionStoreOwner, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
+    ExpressionStoreOwnerId, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
     GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, Lookup, Macro2Id, MacroId,
     MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId, TraitId, TypeAliasId,
     TypeOrConstParamId, TypeParamId, UseId, VariantId,
@@ -36,6 +36,7 @@
     lang_item::LangItemTarget,
     nameres::{DefMap, LocalDefMap, MacroSubNs, ResolvePathResultPrefixInfo, block_def_map},
     per_ns::PerNs,
+    signatures::ImplSignature,
     src::HasSource,
     type_ref::LifetimeRef,
     visibility::{RawVisibility, Visibility},
@@ -65,13 +66,13 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 }
 
 #[derive(Clone)]
-struct ExprScope {
-    owner: ExpressionStoreOwner,
-    expr_scopes: Arc<ExprScopes>,
+struct ExprScope<'db> {
+    owner: ExpressionStoreOwnerId,
+    expr_scopes: &'db ExprScopes,
     scope_id: ScopeId,
 }
 
-impl fmt::Debug for ExprScope {
+impl fmt::Debug for ExprScope<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ExprScope")
             .field("owner", &self.owner)
@@ -88,7 +89,7 @@ enum Scope<'db> {
     /// generic for ADTs and impls.
     GenericParams { def: GenericDefId, params: Arc<GenericParams> },
     /// Local bindings
-    ExprScope(ExprScope),
+    ExprScope(ExprScope<'db>),
     /// Macro definition inside bodies that affects all paths after it in the same block.
     MacroDefScope(MacroDefId),
 }
@@ -653,7 +654,7 @@ pub fn traits_in_scope(&self, db: &dyn DefDatabase) -> FxHashSet<TraitId> {
             match scope {
                 Scope::BlockScope(m) => traits.extend(m.def_map[m.module_id].scope.traits()),
                 &Scope::GenericParams { def: GenericDefId::ImplId(impl_), .. } => {
-                    let impl_data = db.impl_signature(impl_);
+                    let impl_data = ImplSignature::of(db, impl_);
                     if let Some(target_trait) = impl_data.target_trait
                         && let Some(TypeNs::TraitId(trait_)) = self
                             .resolve_path_in_type_ns_fully(db, &impl_data.store[target_trait.path])
@@ -736,12 +737,9 @@ pub fn all_generic_params(&self) -> impl Iterator<Item = (&GenericParams, &Gener
         })
     }
 
-    pub fn body_owner(&self) -> Option<DefWithBodyId> {
+    pub fn expression_store_owner(&self) -> Option<ExpressionStoreOwnerId> {
         self.scopes().find_map(|scope| match scope {
-            Scope::ExprScope(it) => match it.owner {
-                ExpressionStoreOwner::Body(def) => Some(def),
-                ExpressionStoreOwner::Signature(_) => None,
-            },
+            Scope::ExprScope(it) => Some(it.owner),
             _ => None,
         })
     }
@@ -857,7 +855,7 @@ pub fn rename_will_conflict_with_renamed(
     pub fn update_to_inner_scope(
         &mut self,
         db: &'db dyn DefDatabase,
-        owner: impl Into<ExpressionStoreOwner>,
+        owner: impl Into<ExpressionStoreOwnerId>,
         expr_id: ExprId,
     ) -> UpdateGuard {
         self.update_to_inner_scope_(db, owner.into(), expr_id)
@@ -866,25 +864,21 @@ pub fn update_to_inner_scope(
     fn update_to_inner_scope_(
         &mut self,
         db: &'db dyn DefDatabase,
-        owner: ExpressionStoreOwner,
+        owner: ExpressionStoreOwnerId,
         expr_id: ExprId,
     ) -> UpdateGuard {
         #[inline(always)]
         fn append_expr_scope<'db>(
             db: &'db dyn DefDatabase,
             resolver: &mut Resolver<'db>,
-            owner: ExpressionStoreOwner,
-            expr_scopes: &Arc<ExprScopes>,
+            owner: ExpressionStoreOwnerId,
+            expr_scopes: &'db ExprScopes,
             scope_id: ScopeId,
         ) {
             if let Some(macro_id) = expr_scopes.macro_def(scope_id) {
                 resolver.scopes.push(Scope::MacroDefScope(**macro_id));
             }
-            resolver.scopes.push(Scope::ExprScope(ExprScope {
-                owner,
-                expr_scopes: expr_scopes.clone(),
-                scope_id,
-            }));
+            resolver.scopes.push(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }));
             if let Some(block) = expr_scopes.block(scope_id) {
                 let def_map = block_def_map(db, block);
                 let local_def_map = block.lookup(db).module.only_local_def_map(db);
@@ -902,21 +896,20 @@ fn append_expr_scope<'db>(
         let start = self.scopes.len();
         let innermost_scope = self.scopes().find(|scope| !matches!(scope, Scope::MacroDefScope(_)));
         match innermost_scope {
-            Some(&Scope::ExprScope(ExprScope { scope_id, ref expr_scopes, owner })) => {
-                let expr_scopes = expr_scopes.clone();
+            Some(&Scope::ExprScope(ExprScope { scope_id, expr_scopes, owner })) => {
                 let scope_chain = expr_scopes
                     .scope_chain(expr_scopes.scope_for(expr_id))
                     .take_while(|&it| it != scope_id);
                 for scope_id in scope_chain {
-                    append_expr_scope(db, self, owner, &expr_scopes, scope_id);
+                    append_expr_scope(db, self, owner, expr_scopes, scope_id);
                 }
             }
             _ => {
-                let expr_scopes = db.expr_scopes(owner);
+                let expr_scopes = ExprScopes::of(db, owner);
                 let scope_chain = expr_scopes.scope_chain(expr_scopes.scope_for(expr_id));
 
                 for scope_id in scope_chain {
-                    append_expr_scope(db, self, owner, &expr_scopes, scope_id);
+                    append_expr_scope(db, self, owner, expr_scopes, scope_id);
                 }
             }
         }
@@ -1072,21 +1065,21 @@ fn process_names(&self, acc: &mut ScopeNames, db: &'db dyn DefDatabase) {
 
 pub fn resolver_for_scope(
     db: &dyn DefDatabase,
-    owner: impl Into<ExpressionStoreOwner> + HasResolver,
+    owner: impl Into<ExpressionStoreOwnerId> + HasResolver,
     scope_id: Option<ScopeId>,
 ) -> Resolver<'_> {
     let store_owner = owner.into();
     let r = store_owner.resolver(db);
-    let scopes = db.expr_scopes(store_owner);
+    let scopes = ExprScopes::of(db, store_owner);
     resolver_for_scope_(db, scopes, scope_id, r, store_owner)
 }
 
 fn resolver_for_scope_<'db>(
     db: &'db dyn DefDatabase,
-    scopes: Arc<ExprScopes>,
+    scopes: &'db ExprScopes,
     scope_id: Option<ScopeId>,
     mut r: Resolver<'db>,
-    owner: ExpressionStoreOwner,
+    owner: ExpressionStoreOwnerId,
 ) -> Resolver<'db> {
     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
     r.scopes.reserve(scope_chain.len());
@@ -1106,7 +1099,7 @@ fn resolver_for_scope_<'db>(
             r = r.push_scope(Scope::MacroDefScope(**macro_id));
         }
 
-        r = r.push_expr_scope(owner, Arc::clone(&scopes), scope);
+        r = r.push_expr_scope(owner, scopes, scope);
     }
     r
 }
@@ -1137,8 +1130,8 @@ fn push_block_scope(
 
     fn push_expr_scope(
         self,
-        owner: ExpressionStoreOwner,
-        expr_scopes: Arc<ExprScopes>,
+        owner: ExpressionStoreOwnerId,
+        expr_scopes: &'db ExprScopes,
         scope_id: ScopeId,
     ) -> Resolver<'db> {
         self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
@@ -1422,11 +1415,11 @@ fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
     }
 }
 
-impl HasResolver for ExpressionStoreOwner {
+impl HasResolver for ExpressionStoreOwnerId {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         match self {
-            ExpressionStoreOwner::Signature(def) => def.resolver(db),
-            ExpressionStoreOwner::Body(def) => def.resolver(db),
+            ExpressionStoreOwnerId::Signature(def) => def.resolver(db),
+            ExpressionStoreOwnerId::Body(def) => def.resolver(db),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index ce76158151c3..7862049f993e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -24,7 +24,7 @@
     attrs::AttrFlags,
     db::DefDatabase,
     expr_store::{
-        ExpressionStore, ExpressionStoreSourceMap,
+        Body, ExpressionStore, ExpressionStoreBuilder, ExpressionStoreSourceMap,
         lower::{
             ExprCollector, lower_function, lower_generic_params, lower_trait, lower_type_alias,
         },
@@ -44,7 +44,7 @@ fn as_name_opt(name: Option<ast::Name>) -> Name {
 pub struct StructSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub flags: StructFlags,
     pub shape: FieldsShape,
 }
@@ -71,8 +71,18 @@ pub struct StructFlags: u8 {
     }
 }
 
+#[salsa::tracked]
 impl StructSignature {
-    pub fn query(db: &dyn DefDatabase, id: StructId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: StructId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: StructId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
         let InFile { file_id, value: source } = loc.source(db);
         let attrs = AttrFlags::query(db, id.into());
@@ -115,10 +125,12 @@ pub fn query(db: &dyn DefDatabase, id: StructId) -> (Arc<Self>, Arc<ExpressionSt
                 shape,
                 name: as_name_opt(source.name()),
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
+}
 
+impl StructSignature {
     #[inline]
     pub fn repr(&self, db: &dyn DefDatabase, id: StructId) -> Option<ReprOptions> {
         if self.flags.contains(StructFlags::HAS_REPR) {
@@ -142,12 +154,22 @@ fn adt_shape(adt_kind: ast::StructKind) -> FieldsShape {
 pub struct UnionSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub flags: StructFlags,
 }
 
+#[salsa::tracked]
 impl UnionSignature {
-    pub fn query(db: &dyn DefDatabase, id: UnionId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: UnionId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: UnionId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
         let attrs = AttrFlags::query(db, id.into());
         let mut flags = StructFlags::empty();
@@ -177,7 +199,7 @@ pub fn query(db: &dyn DefDatabase, id: UnionId) -> (Arc<Self>, Arc<ExpressionSto
                 flags,
                 name: as_name_opt(source.name()),
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
 }
@@ -196,12 +218,22 @@ pub struct EnumFlags: u8 {
 pub struct EnumSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub flags: EnumFlags,
 }
 
+#[salsa::tracked]
 impl EnumSignature {
-    pub fn query(db: &dyn DefDatabase, id: EnumId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: EnumId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: EnumId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
         let attrs = AttrFlags::query(db, id.into());
         let mut flags = EnumFlags::empty();
@@ -229,10 +261,12 @@ pub fn query(db: &dyn DefDatabase, id: EnumId) -> (Arc<Self>, Arc<ExpressionStor
                 flags,
                 name: as_name_opt(source.name()),
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
+}
 
+impl EnumSignature {
     pub fn variant_body_type(db: &dyn DefDatabase, id: EnumId) -> IntegerType {
         match AttrFlags::repr(db, id.into()) {
             Some(ReprOptions { int: Some(builtin), .. }) => builtin,
@@ -257,13 +291,23 @@ pub struct ConstFlags: u8 {
 pub struct ConstSignature {
     pub name: Option<Name>,
     // generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub type_ref: TypeRefId,
     pub flags: ConstFlags,
 }
 
+#[salsa::tracked]
 impl ConstSignature {
-    pub fn query(db: &dyn DefDatabase, id: ConstId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: ConstId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: ConstId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
 
         let module = loc.container.module(db);
@@ -282,15 +326,17 @@ pub fn query(db: &dyn DefDatabase, id: ConstId) -> (Arc<Self>, Arc<ExpressionSto
 
         (
             Arc::new(ConstSignature {
-                store: Arc::new(store),
+                store,
                 type_ref,
                 flags,
                 name: source.value.name().map(|it| it.as_name()),
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
+}
 
+impl ConstSignature {
     pub fn has_body(&self) -> bool {
         self.flags.contains(ConstFlags::HAS_BODY)
     }
@@ -313,12 +359,23 @@ pub struct StaticSignature {
     pub name: Name,
 
     // generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub type_ref: TypeRefId,
     pub flags: StaticFlags,
 }
+
+#[salsa::tracked]
 impl StaticSignature {
-    pub fn query(db: &dyn DefDatabase, id: StaticId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: StaticId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: StaticId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
 
         let module = loc.container.module(db);
@@ -351,12 +408,12 @@ pub fn query(db: &dyn DefDatabase, id: StaticId) -> (Arc<Self>, Arc<ExpressionSt
 
         (
             Arc::new(StaticSignature {
-                store: Arc::new(store),
+                store,
                 type_ref,
                 flags,
                 name: as_name_opt(source.value.name()),
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
 }
@@ -373,14 +430,24 @@ pub struct ImplFlags: u8 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct ImplSignature {
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub self_ty: TypeRefId,
     pub target_trait: Option<TraitRef>,
     pub flags: ImplFlags,
 }
 
+#[salsa::tracked]
 impl ImplSignature {
-    pub fn query(db: &dyn DefDatabase, id: ImplId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: ImplId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: ImplId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
 
         let mut flags = ImplFlags::empty();
@@ -399,17 +466,13 @@ pub fn query(db: &dyn DefDatabase, id: ImplId) -> (Arc<Self>, Arc<ExpressionStor
             crate::expr_store::lower::lower_impl(db, loc.container, src, id);
 
         (
-            Arc::new(ImplSignature {
-                store: Arc::new(store),
-                generic_params,
-                self_ty,
-                target_trait,
-                flags,
-            }),
-            Arc::new(source_map),
+            Arc::new(ImplSignature { store, generic_params, self_ty, target_trait, flags }),
+            source_map,
         )
     }
+}
 
+impl ImplSignature {
     #[inline]
     pub fn is_negative(&self) -> bool {
         self.flags.contains(ImplFlags::NEGATIVE)
@@ -440,12 +503,22 @@ pub struct TraitFlags: u16 {
 pub struct TraitSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub flags: TraitFlags,
 }
 
+#[salsa::tracked]
 impl TraitSignature {
-    pub fn query(db: &dyn DefDatabase, id: TraitId) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: TraitId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
+        db: &dyn DefDatabase,
+        id: TraitId,
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
 
         let mut flags = TraitFlags::empty();
@@ -483,10 +556,7 @@ pub fn query(db: &dyn DefDatabase, id: TraitId) -> (Arc<Self>, Arc<ExpressionSto
         let name = as_name_opt(source.value.name());
         let (store, source_map, generic_params) = lower_trait(db, loc.container, source, id);
 
-        (
-            Arc::new(TraitSignature { store: Arc::new(store), generic_params, flags, name }),
-            Arc::new(source_map),
-        )
+        (Arc::new(TraitSignature { store, generic_params, flags, name }), source_map)
     }
 }
 
@@ -517,18 +587,25 @@ pub struct FnFlags: u16 {
 pub struct FunctionSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub params: Box<[TypeRefId]>,
     pub ret_type: Option<TypeRefId>,
     pub abi: Option<Symbol>,
     pub flags: FnFlags,
 }
 
+#[salsa::tracked]
 impl FunctionSignature {
-    pub fn query(
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: FunctionId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
         db: &dyn DefDatabase,
         id: FunctionId,
-    ) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
         let module = loc.container.module(db);
 
@@ -589,17 +666,19 @@ pub fn query(
         (
             Arc::new(FunctionSignature {
                 generic_params,
-                store: Arc::new(store),
+                store,
                 params,
                 ret_type,
                 abi,
                 flags,
                 name,
             }),
-            Arc::new(source_map),
+            source_map,
         )
     }
+}
 
+impl FunctionSignature {
     pub fn has_body(&self) -> bool {
         self.flags.contains(FnFlags::HAS_BODY)
     }
@@ -656,7 +735,7 @@ pub fn legacy_const_generics_indices<'db>(
     }
 
     pub fn is_intrinsic(db: &dyn DefDatabase, id: FunctionId) -> bool {
-        let data = db.function_signature(id);
+        let data = FunctionSignature::of(db, id);
         data.flags.contains(FnFlags::RUSTC_INTRINSIC)
             // Keep this around for a bit until extern "rustc-intrinsic" abis are no longer used
             || match &data.abi {
@@ -684,17 +763,24 @@ pub struct TypeAliasFlags: u8 {
 pub struct TypeAliasSignature {
     pub name: Name,
     pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub bounds: Box<[TypeBound]>,
     pub ty: Option<TypeRefId>,
     pub flags: TypeAliasFlags,
 }
 
+#[salsa::tracked]
 impl TypeAliasSignature {
-    pub fn query(
+    #[salsa::tracked(returns(deref))]
+    pub fn of(db: &dyn DefDatabase, id: TypeAliasId) -> Arc<Self> {
+        Self::with_source_map(db, id).0.clone()
+    }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn with_source_map(
         db: &dyn DefDatabase,
         id: TypeAliasId,
-    ) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let loc = id.lookup(db);
 
         let mut flags = TypeAliasFlags::empty();
@@ -714,28 +800,21 @@ pub fn query(
             lower_type_alias(db, loc.container.module(db), source, id);
 
         (
-            Arc::new(TypeAliasSignature {
-                store: Arc::new(store),
-                generic_params,
-                flags,
-                bounds,
-                name,
-                ty,
-            }),
-            Arc::new(source_map),
+            Arc::new(TypeAliasSignature { store, generic_params, flags, bounds, name, ty }),
+            source_map,
         )
     }
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct FunctionBody {
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub parameters: Box<[PatId]>,
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct SimpleBody {
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
 }
 pub type StaticBody = SimpleBody;
 pub type ConstBody = SimpleBody;
@@ -743,7 +822,7 @@ pub struct SimpleBody {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct VariantFieldsBody {
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub fields: Box<[Option<ExprId>]>,
 }
 
@@ -762,17 +841,17 @@ pub struct FieldData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct VariantFields {
     fields: Arena<FieldData>,
-    pub store: Arc<ExpressionStore>,
+    pub store: ExpressionStore,
     pub shape: FieldsShape,
 }
 
 #[salsa::tracked]
 impl VariantFields {
-    #[salsa::tracked(returns(clone))]
-    pub(crate) fn query(
+    #[salsa::tracked(returns(ref))]
+    pub(crate) fn with_source_map(
         db: &dyn DefDatabase,
         id: VariantId,
-    ) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
+    ) -> (Arc<Self>, ExpressionStoreSourceMap) {
         let (shape, result) = match id {
             VariantId::EnumVariantId(id) => {
                 let loc = id.lookup(db);
@@ -809,20 +888,26 @@ pub(crate) fn query(
             }
         };
         match result {
-            Some((fields, store, source_map)) => (
-                Arc::new(VariantFields { fields, store: Arc::new(store), shape }),
-                Arc::new(source_map),
-            ),
+            Some((fields, store, source_map)) => {
+                (Arc::new(VariantFields { fields, store, shape }), source_map)
+            }
             None => {
-                let (store, source_map) = ExpressionStore::empty_singleton();
-                (Arc::new(VariantFields { fields: Arena::default(), store, shape }), source_map)
+                let source_map = ExpressionStoreSourceMap::default();
+                (
+                    Arc::new(VariantFields {
+                        fields: Arena::default(),
+                        store: ExpressionStoreBuilder::default().finish().0,
+                        shape,
+                    }),
+                    source_map,
+                )
             }
         }
     }
 
     #[salsa::tracked(returns(deref))]
     pub(crate) fn firewall(db: &dyn DefDatabase, id: VariantId) -> Arc<Self> {
-        Self::query(db, id).0
+        Self::with_source_map(db, id).0.clone()
     }
 }
 
@@ -1014,7 +1099,7 @@ pub fn is_payload_free(&self, db: &dyn DefDatabase) -> bool {
             }
             // The outer if condition is whether this variant has const ctor or not
             if !matches!(variant.shape, FieldsShape::Unit) {
-                let body = db.body(v.into());
+                let body = Body::of(db, v.into());
                 // A variant with explicit discriminant
                 if !matches!(body[body.body_expr], crate::hir::Expr::Missing) {
                     return false;
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
index d2921db6f4fa..0d260279f98c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
@@ -15,6 +15,7 @@
 use crate::{
     Lookup, ModuleDefId, ModuleId,
     db::DefDatabase,
+    expr_store::{Body, scope::ExprScopes},
     nameres::{DefMap, ModuleSource, block_def_map, crate_def_map},
     src::HasSource,
 };
@@ -284,8 +285,8 @@ fn block_at_position(&self, def_map: &DefMap, position: FilePosition) -> Option<
         // Find the innermost block expression that has a `DefMap`.
         let (def_with_body, file_id) = fn_def?;
         let def_with_body = def_with_body.into();
-        let source_map = self.body_with_source_map(def_with_body).1;
-        let scopes = self.expr_scopes(def_with_body.into());
+        let source_map = &Body::with_source_map(self, def_with_body).1;
+        let scopes = ExprScopes::body_expr_scopes(self, def_with_body);
 
         let root_syntax_node = self.parse(file_id).syntax_node();
         let scope_iter =
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index c294238030bd..673d00d956ad 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -5,10 +5,11 @@
 
 use base_db::Crate;
 use hir_def::{
-    ConstId, EnumVariantId, GeneralConstId, HasModule, StaticId,
+    ConstId, EnumVariantId, ExpressionStoreOwnerId, GeneralConstId, GenericDefId, HasModule,
+    StaticId,
     attrs::AttrFlags,
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
-    expr_store::ExpressionStore,
+    expr_store::{Body, ExpressionStore},
     hir::{Expr, ExprId, Literal},
 };
 use hir_expand::Lookup;
@@ -273,7 +274,7 @@ pub(crate) fn const_eval_discriminant_variant(
 ) -> Result<i128, ConstEvalError> {
     let interner = DbInterner::new_no_crate(db);
     let def = variant_id.into();
-    let body = db.body(def);
+    let body = Body::of(db, def);
     let loc = variant_id.lookup(db);
     if matches!(body[body.body_expr], Expr::Missing) {
         let prev_idx = loc.index.checked_sub(1);
@@ -294,7 +295,7 @@ pub(crate) fn const_eval_discriminant_variant(
     let mir_body = db.monomorphized_mir_body(
         def,
         GenericArgs::empty(interner).store(),
-        ParamEnvAndCrate { param_env: db.trait_environment_for_body(def), krate: def.krate(db) }
+        ParamEnvAndCrate { param_env: db.trait_environment(def.into()), krate: def.krate(db) }
             .store(),
     )?;
     let c = interpret_mir(db, mir_body, false, None)?.0?;
@@ -337,7 +338,7 @@ fn has_closure(store: &ExpressionStore, expr: ExprId) -> bool {
     }
     if let Some(body_owner) = ctx.owner.as_def_with_body()
         && let Ok(mir_body) =
-            lower_body_to_mir(ctx.db, body_owner, &ctx.db.body(body_owner), &infer, expr)
+            lower_body_to_mir(ctx.db, body_owner, Body::of(ctx.db, body_owner), &infer, expr)
         && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None)
     {
         return result;
@@ -374,8 +375,12 @@ pub(crate) fn const_eval_query<'db>(
         let body = db.monomorphized_mir_body(
             def.into(),
             subst,
-            ParamEnvAndCrate { param_env: db.trait_environment(def.into()), krate: def.krate(db) }
-                .store(),
+            ParamEnvAndCrate {
+                param_env: db
+                    .trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(def))),
+                krate: def.krate(db),
+            }
+            .store(),
         )?;
         let c = interpret_mir(db, body, false, trait_env.as_ref().map(|env| env.as_ref()))?.0?;
         Ok(c.store())
@@ -411,7 +416,8 @@ pub(crate) fn const_eval_static_query<'db>(
             def.into(),
             GenericArgs::empty(interner).store(),
             ParamEnvAndCrate {
-                param_env: db.trait_environment_for_body(def.into()),
+                param_env: db
+                    .trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(def))),
                 krate: def.krate(db),
             }
             .store(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 5f6bcb4a602c..31cf86476f9a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -1,5 +1,5 @@
 use base_db::RootQueryDb;
-use hir_def::db::DefDatabase;
+use hir_def::signatures::ConstSignature;
 use hir_expand::EditionedFileId;
 use rustc_apfloat::{
     Float,
@@ -131,7 +131,11 @@ fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const<'_>, ConstEv
         .declarations()
         .find_map(|x| match x {
             hir_def::ModuleDefId::ConstId(x) => {
-                if db.const_signature(x).name.as_ref()?.display(db, file_id.edition(db)).to_string()
+                if ConstSignature::of(db, x)
+                    .name
+                    .as_ref()?
+                    .display(db, file_id.edition(db))
+                    .to_string()
                     == "GOAL"
                 {
                     Some(x)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index ca5b1b771631..a0fb75397a23 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -5,7 +5,7 @@
 use either::Either;
 use hir_def::{
     AdtId, BuiltinDeriveImplId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId,
-    ExpressionStoreOwner, FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId,
+    ExpressionStoreOwnerId, FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId,
     StaticId, TraitId, TypeAliasId, VariantId, builtin_derive::BuiltinDeriveImplMethod,
     db::DefDatabase, hir::ExprId, layout::TargetDataLayout,
 };
@@ -178,13 +178,9 @@ fn callable_item_signature<'db>(
         def: CallableDefId,
     ) -> EarlyBinder<'db, PolyFnSig<'db>>;
 
-    #[salsa::invoke(crate::lower::trait_environment_for_body_query)]
-    #[salsa::transparent]
-    fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId) -> ParamEnv<'db>;
-
     #[salsa::invoke(crate::lower::trait_environment)]
     #[salsa::transparent]
-    fn trait_environment<'db>(&'db self, def: GenericDefId) -> ParamEnv<'db>;
+    fn trait_environment<'db>(&'db self, def: ExpressionStoreOwnerId) -> ParamEnv<'db>;
 
     #[salsa::invoke(crate::lower::generic_defaults_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower::generic_defaults_with_diagnostics_cycle_result)]
@@ -240,7 +236,7 @@ pub struct InternedOpaqueTyId {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct InternedClosure(pub ExpressionStoreOwner, pub ExprId);
+pub struct InternedClosure(pub ExpressionStoreOwnerId, pub ExprId);
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
@@ -249,7 +245,7 @@ pub struct InternedClosureId {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct InternedCoroutine(pub ExpressionStoreOwner, pub ExprId);
+pub struct InternedCoroutine(pub ExpressionStoreOwnerId, pub ExprId);
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
index 0931b859656f..89d8c0e91d18 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -17,8 +17,17 @@
 
 use hir_def::{
     AdtId, ConstId, EnumId, EnumVariantId, FunctionId, HasModule, ItemContainerId, Lookup,
-    ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId, attrs::AttrFlags,
-    db::DefDatabase, hir::Pat, item_tree::FieldsShape, signatures::StaticFlags, src::HasSource,
+    ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    attrs::AttrFlags,
+    db::DefDatabase,
+    expr_store::Body,
+    hir::Pat,
+    item_tree::FieldsShape,
+    signatures::{
+        ConstSignature, EnumSignature, FunctionSignature, StaticFlags, StaticSignature,
+        StructSignature, TraitSignature, TypeAliasSignature, UnionSignature,
+    },
+    src::HasSource,
 };
 use hir_expand::{
     HirFileId,
@@ -178,7 +187,7 @@ fn validate_module(&mut self, module_id: ModuleId) {
 
     fn validate_trait(&mut self, trait_id: TraitId) {
         // Check the trait name.
-        let data = self.db.trait_signature(trait_id);
+        let data = TraitSignature::of(self.db, trait_id);
         self.create_incorrect_case_diagnostic_for_item_name(
             trait_id,
             &data.name,
@@ -197,7 +206,7 @@ fn validate_func(&mut self, func: FunctionId) {
         // Check the function name.
         // Skipped if function is an associated item of a trait implementation.
         if !self.is_trait_impl_container(container) {
-            let data = self.db.function_signature(func);
+            let data = FunctionSignature::of(self.db, func);
 
             // Don't run the lint on extern "[not Rust]" fn items with the
             // #[no_mangle] attribute.
@@ -223,7 +232,7 @@ fn validate_func(&mut self, func: FunctionId) {
     /// Check incorrect names for patterns inside the function body.
     /// This includes function parameters except for trait implementation associated functions.
     fn validate_func_body(&mut self, func: FunctionId) {
-        let body = self.db.body(func.into());
+        let body = Body::of(self.db, func.into());
         let edition = self.edition(func);
         let mut pats_replacements = body
             .pats()
@@ -250,7 +259,7 @@ fn validate_func_body(&mut self, func: FunctionId) {
             return;
         }
 
-        let source_map = self.db.body_with_source_map(func.into()).1;
+        let source_map = &Body::with_source_map(self.db, func.into()).1;
         for (id, replacement) in pats_replacements {
             let Ok(source_ptr) = source_map.pat_syntax(id) else {
                 continue;
@@ -292,7 +301,7 @@ fn edition(&self, id: impl HasModule) -> span::Edition {
 
     fn validate_struct(&mut self, struct_id: StructId) {
         // Check the structure name.
-        let data = self.db.struct_signature(struct_id);
+        let data = StructSignature::of(self.db, struct_id);
 
         // rustc implementation excuses repr(C) since C structs predominantly don't
         // use camel case.
@@ -385,7 +394,7 @@ fn validate_struct_fields(&mut self, struct_id: StructId) {
 
     fn validate_union(&mut self, union_id: UnionId) {
         // Check the union name.
-        let data = self.db.union_signature(union_id);
+        let data = UnionSignature::of(self.db, union_id);
 
         // rustc implementation excuses repr(C) since C unions predominantly don't
         // use camel case.
@@ -473,7 +482,7 @@ fn validate_union_fields(&mut self, union_id: UnionId) {
 
     fn validate_enum(&mut self, enum_id: EnumId) {
         // Check the enum name.
-        let data = self.db.enum_signature(enum_id);
+        let data = EnumSignature::of(self.db, enum_id);
 
         // rustc implementation excuses repr(C) since C structs predominantly don't
         // use camel case.
@@ -644,7 +653,7 @@ fn validate_const(&mut self, const_id: ConstId) {
             return;
         }
 
-        let data = self.db.const_signature(const_id);
+        let data = ConstSignature::of(self.db, const_id);
         let Some(name) = &data.name else {
             return;
         };
@@ -657,7 +666,7 @@ fn validate_const(&mut self, const_id: ConstId) {
     }
 
     fn validate_static(&mut self, static_id: StaticId) {
-        let data = self.db.static_signature(static_id);
+        let data = StaticSignature::of(self.db, static_id);
         if data.flags.contains(StaticFlags::EXTERN) {
             cov_mark::hit!(extern_static_incorrect_case_ignored);
             return;
@@ -683,7 +692,7 @@ fn validate_type_alias(&mut self, type_alias_id: TypeAliasId) {
         }
 
         // Check the type alias name.
-        let data = self.db.type_alias_signature(type_alias_id);
+        let data = TypeAliasSignature::of(self.db, type_alias_id);
         self.create_incorrect_case_diagnostic_for_item_name(
             type_alias_id,
             &data.name,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
index 4e1bb6f4c533..e227be6995d0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
@@ -21,7 +21,7 @@
     ast::{self, UnaryOp},
 };
 use tracing::debug;
-use triomphe::Arc;
+
 use typed_arena::Arena;
 
 use crate::{
@@ -76,9 +76,9 @@ pub fn collect(
         validate_lints: bool,
     ) -> Vec<BodyValidationDiagnostic> {
         let _p = tracing::info_span!("BodyValidationDiagnostic::collect").entered();
-        let infer = InferenceResult::for_body(db, owner);
-        let body = db.body(owner);
-        let env = db.trait_environment_for_body(owner);
+        let infer = InferenceResult::of(db, owner);
+        let body = Body::of(db, owner);
+        let env = db.trait_environment(owner.into());
         let interner = DbInterner::new_with(db, owner.krate(db));
         let infcx =
             interner.infer_ctxt().build(TypingMode::typeck_for_body(interner, owner.into()));
@@ -98,7 +98,7 @@ pub fn collect(
 
 struct ExprValidator<'db> {
     owner: DefWithBodyId,
-    body: Arc<Body>,
+    body: &'db Body,
     infer: &'db InferenceResult,
     env: ParamEnv<'db>,
     diagnostics: Vec<BodyValidationDiagnostic>,
@@ -116,10 +116,10 @@ fn validate_body(&mut self) {
         let db = self.db();
         let mut filter_map_next_checker = None;
         // we'll pass &mut self while iterating over body.exprs, so they need to be disjoint
-        let body = Arc::clone(&self.body);
+        let body = self.body;
 
         if matches!(self.owner, DefWithBodyId::FunctionId(_)) {
-            self.check_for_trailing_return(body.body_expr, &body);
+            self.check_for_trailing_return(body.body_expr, body);
         }
 
         for (id, expr) in body.exprs() {
@@ -141,7 +141,7 @@ fn validate_body(&mut self) {
                     self.validate_call(id, expr, &mut filter_map_next_checker);
                 }
                 Expr::Closure { body: body_expr, .. } => {
-                    self.check_for_trailing_return(*body_expr, &body);
+                    self.check_for_trailing_return(*body_expr, body);
                 }
                 Expr::If { .. } => {
                     self.check_for_unnecessary_else(id, expr);
@@ -240,7 +240,7 @@ fn validate_match(&mut self, match_expr: ExprId, scrutinee_expr: ExprId, arms: &
                     .as_reference()
                     .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
                     .unwrap_or(false))
-                && types_of_subpatterns_do_match(arm.pat, &self.body, self.infer)
+                && types_of_subpatterns_do_match(arm.pat, self.body, self.infer)
             {
                 // If we had a NotUsefulMatchArm diagnostic, we could
                 // check the usefulness of each pattern as we added it
@@ -388,7 +388,7 @@ fn lower_pattern<'a>(
         pat: PatId,
         have_errors: &mut bool,
     ) -> DeconstructedPat<'a, 'db> {
-        let mut patcx = match_check::PatCtxt::new(self.db(), self.infer, &self.body);
+        let mut patcx = match_check::PatCtxt::new(self.db(), self.infer, self.body);
         let pattern = patcx.lower_pattern(pat);
         let pattern = cx.lower_pat(&pattern);
         if !patcx.errors.is_empty() {
@@ -451,7 +451,7 @@ fn check_for_unnecessary_else(&mut self, id: ExprId, expr: &Expr) {
                     && last_then_expr_ty.is_never()
                 {
                     // Only look at sources if the then branch diverges and we have an else branch.
-                    let source_map = self.db().body_with_source_map(self.owner).1;
+                    let source_map = &Body::with_source_map(self.db(), self.owner).1;
                     let Ok(source_ptr) = source_map.expr_syntax(id) else {
                         return;
                     };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs
index 8e6101e6a0e3..f559c26bf57e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs
@@ -14,6 +14,7 @@
     expr_store::{Body, path::Path},
     hir::PatId,
     item_tree::FieldsShape,
+    signatures::{StructSignature, UnionSignature},
 };
 use hir_expand::name::Name;
 use rustc_type_ir::inherent::IntoKind;
@@ -340,12 +341,12 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError>
                         VariantId::StructId(s) => write!(
                             f,
                             "{}",
-                            f.db.struct_signature(s).name.display(f.db, f.edition())
+                            StructSignature::of(f.db, s).name.display(f.db, f.edition())
                         )?,
                         VariantId::UnionId(u) => write!(
                             f,
                             "{}",
-                            f.db.union_signature(u).name.display(f.db, f.edition())
+                            UnionSignature::of(f.db, u).name.display(f.db, f.edition())
                         )?,
                     };
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 21f263723bb1..ba9b7416b76c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -9,7 +9,7 @@
     expr_store::{Body, path::Path},
     hir::{AsmOperand, Expr, ExprId, ExprOrPatId, InlineAsmKind, Pat, PatId, Statement, UnaryOp},
     resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},
-    signatures::StaticFlags,
+    signatures::{FunctionSignature, StaticFlags, StaticSignature},
     type_ref::Rawness,
 };
 use rustc_type_ir::inherent::IntoKind;
@@ -34,15 +34,15 @@ pub fn missing_unsafe(db: &dyn HirDatabase, def: DefWithBodyId) -> MissingUnsafe
     let _p = tracing::info_span!("missing_unsafe").entered();
 
     let is_unsafe = match def {
-        DefWithBodyId::FunctionId(it) => db.function_signature(it).is_unsafe(),
+        DefWithBodyId::FunctionId(it) => FunctionSignature::of(db, it).is_unsafe(),
         DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) | DefWithBodyId::VariantId(_) => {
             false
         }
     };
 
     let mut res = MissingUnsafeResult { fn_is_unsafe: is_unsafe, ..MissingUnsafeResult::default() };
-    let body = db.body(def);
-    let infer = InferenceResult::for_body(db, def);
+    let body = Body::of(db, def);
+    let infer = InferenceResult::of(db, def);
     let mut callback = |diag| match diag {
         UnsafeDiagnostic::UnsafeOperation { node, inside_unsafe_block, reason } => {
             if inside_unsafe_block == InsideUnsafeBlock::No {
@@ -55,7 +55,7 @@ pub fn missing_unsafe(db: &dyn HirDatabase, def: DefWithBodyId) -> MissingUnsafe
             }
         }
     };
-    let mut visitor = UnsafeVisitor::new(db, infer, &body, def, &mut callback);
+    let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut callback);
     visitor.walk_expr(body.body_expr);
 
     if !is_unsafe {
@@ -431,7 +431,7 @@ fn mark_unsafe_path(&mut self, node: ExprOrPatId, path: &Path) {
         let hygiene = self.body.expr_or_pat_path_hygiene(node);
         let value_or_partial = self.resolver.resolve_path_in_value_ns(self.db, path, hygiene);
         if let Some(ResolveValueResult::ValueNs(ValueNs::StaticId(id))) = value_or_partial {
-            let static_data = self.db.static_signature(id);
+            let static_data = StaticSignature::of(self.db, id);
             if static_data.flags.contains(StaticFlags::MUTABLE) {
                 self.on_unsafe_op(node, UnsafetyReason::MutableStatic);
             } else if static_data.flags.contains(StaticFlags::EXTERN)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index f4d0ed148492..54cd750de6c8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -10,15 +10,18 @@
 use base_db::{Crate, FxIndexMap};
 use either::Either;
 use hir_def::{
-    FindPathConfig, GenericDefId, GenericParamId, HasModule, LocalFieldId, Lookup, ModuleDefId,
-    ModuleId, TraitId,
+    ExpressionStoreOwnerId, FindPathConfig, GenericDefId, GenericParamId, HasModule, LocalFieldId,
+    Lookup, ModuleDefId, ModuleId, TraitId,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
     hir::generics::{TypeOrConstParamData, TypeParamProvenance, WherePredicate},
     item_scope::ItemInNs,
     item_tree::FieldsShape,
     lang_item::LangItems,
-    signatures::VariantFields,
+    signatures::{
+        EnumSignature, FunctionSignature, StructSignature, TraitSignature, TypeAliasSignature,
+        UnionSignature, VariantFields,
+    },
     type_ref::{
         ConstRef, LifetimeRef, LifetimeRefId, TraitBoundModifier, TypeBound, TypeRef, TypeRefId,
         UseArgRef,
@@ -671,7 +674,9 @@ fn write_projection<'db>(
     write!(
         f,
         ">::{}",
-        f.db.type_alias_signature(alias.def_id.expect_type_alias()).name.display(f.db, f.edition())
+        TypeAliasSignature::of(f.db, alias.def_id.expect_type_alias())
+            .name
+            .display(f.db, f.edition())
     )?;
     let proj_params = &alias.args.as_slice()[trait_ref.args.len()..];
     hir_fmt_generics(f, proj_params, None, None)
@@ -853,7 +858,7 @@ fn render_const_scalar_inner<'db>(
             }
             TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id().0 {
                 hir_def::AdtId::StructId(s) => {
-                    let data = f.db.struct_signature(s);
+                    let data = StructSignature::of(f.db, s);
                     write!(f, "&{}", data.name.display(f.db, f.edition()))?;
                     Ok(())
                 }
@@ -911,14 +916,16 @@ fn render_const_scalar_inner<'db>(
             };
             match def {
                 hir_def::AdtId::StructId(s) => {
-                    let data = f.db.struct_signature(s);
+                    let data = StructSignature::of(f.db, s);
                     write!(f, "{}", data.name.display(f.db, f.edition()))?;
                     let field_types = f.db.field_types(s.into());
                     render_variant_after_name(
                         s.fields(f.db),
                         f,
                         field_types,
-                        f.db.trait_environment(def.into()),
+                        f.db.trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(
+                            def,
+                        ))),
                         &layout,
                         args,
                         b,
@@ -926,7 +933,7 @@ fn render_const_scalar_inner<'db>(
                     )
                 }
                 hir_def::AdtId::UnionId(u) => {
-                    write!(f, "{}", f.db.union_signature(u).name.display(f.db, f.edition()))
+                    write!(f, "{}", UnionSignature::of(f.db, u).name.display(f.db, f.edition()))
                 }
                 hir_def::AdtId::EnumId(e) => {
                     let Ok(target_data_layout) = f.db.target_data_layout(f.krate()) else {
@@ -950,7 +957,9 @@ fn render_const_scalar_inner<'db>(
                         var_id.fields(f.db),
                         f,
                         field_types,
-                        f.db.trait_environment(def.into()),
+                        f.db.trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(
+                            def,
+                        ))),
                         var_layout,
                         args,
                         b,
@@ -1152,11 +1161,13 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 write!(f, "fn ")?;
                 f.start_location_link(def.into());
                 match def {
-                    CallableDefId::FunctionId(ff) => {
-                        write!(f, "{}", db.function_signature(ff).name.display(f.db, f.edition()))?
-                    }
+                    CallableDefId::FunctionId(ff) => write!(
+                        f,
+                        "{}",
+                        FunctionSignature::of(db, ff).name.display(f.db, f.edition())
+                    )?,
                     CallableDefId::StructId(s) => {
-                        write!(f, "{}", db.struct_signature(s).name.display(f.db, f.edition()))?
+                        write!(f, "{}", StructSignature::of(db, s).name.display(f.db, f.edition()))?
                     }
                     CallableDefId::EnumVariantId(e) => {
                         let loc = e.lookup(db);
@@ -1235,9 +1246,11 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 match f.display_kind {
                     DisplayKind::Diagnostics | DisplayKind::Test => {
                         let name = match def_id {
-                            hir_def::AdtId::StructId(it) => db.struct_signature(it).name.clone(),
-                            hir_def::AdtId::UnionId(it) => db.union_signature(it).name.clone(),
-                            hir_def::AdtId::EnumId(it) => db.enum_signature(it).name.clone(),
+                            hir_def::AdtId::StructId(it) => {
+                                StructSignature::of(db, it).name.clone()
+                            }
+                            hir_def::AdtId::UnionId(it) => UnionSignature::of(db, it).name.clone(),
+                            hir_def::AdtId::EnumId(it) => EnumSignature::of(db, it).name.clone(),
                         };
                         write!(f, "{}", name.display(f.db, f.edition()))?;
                     }
@@ -1272,7 +1285,7 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 write_projection(f, &alias_ty, trait_bounds_need_parens)?
             }
             TyKind::Foreign(alias) => {
-                let type_alias = db.type_alias_signature(alias.0);
+                let type_alias = TypeAliasSignature::of(db, alias.0);
                 f.start_location_link(alias.0.into());
                 write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
                 f.end_location_link();
@@ -1337,11 +1350,7 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 let sig = interner.signature_unclosure(substs.as_closure().sig(), Safety::Safe);
                 let sig = sig.skip_binder();
                 let InternedClosure(owner, _) = db.lookup_intern_closure(id);
-                let Some(def) = owner.as_def_with_body() else {
-                    write!(f, "{{closure}}")?;
-                    return Ok(());
-                };
-                let infer = InferenceResult::for_body(db, def);
+                let infer = InferenceResult::of(db, owner);
                 let (_, kind) = infer.closure_info(id);
                 match f.closure_style {
                     ClosureStyle::ImplFn => write!(f, "impl {kind:?}(")?,
@@ -1530,13 +1539,7 @@ fn hir_fmt(&self, f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>)
                 let InternedCoroutine(owner, expr_id) = coroutine_id.0.loc(db);
                 let CoroutineArgsParts { resume_ty, yield_ty, return_ty, .. } =
                     subst.split_coroutine_args();
-                let Some(body_owner) = owner.as_def_with_body() else {
-                    write!(f, "impl Future<Output = ")?;
-                    return_ty.hir_fmt(f)?;
-                    write!(f, ">")?;
-                    return Ok(());
-                };
-                let body = db.body(body_owner);
+                let body = ExpressionStore::of(db, owner);
                 let expr = &body[expr_id];
                 match expr {
                     hir_def::hir::Expr::Closure {
@@ -1877,7 +1880,7 @@ fn write_bounds_like_dyn_trait<'db>(
                 // existential) here, which is the only thing that's
                 // possible in actual Rust, and hence don't print it
                 f.start_location_link(trait_.into());
-                write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
+                write!(f, "{}", TraitSignature::of(f.db, trait_).name.display(f.db, f.edition()))?;
                 f.end_location_link();
                 if is_fn_trait {
                     if let [_self, params @ ..] = trait_ref.trait_ref.args.as_slice()
@@ -1940,7 +1943,7 @@ fn write_bounds_like_dyn_trait<'db>(
                     angle_open = true;
                 }
                 let assoc_ty_id = projection.def_id().expect_type_alias();
-                let type_alias = f.db.type_alias_signature(assoc_ty_id);
+                let type_alias = TypeAliasSignature::of(f.db, assoc_ty_id);
                 f.start_location_link(assoc_ty_id.into());
                 write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
                 f.end_location_link();
@@ -2031,7 +2034,7 @@ impl<'db> HirDisplay<'db> for TraitRef<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         let trait_ = self.def_id.0;
         f.start_location_link(trait_.into());
-        write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
+        write!(f, "{}", TraitSignature::of(f.db, trait_).name.display(f.db, f.edition()))?;
         f.end_location_link();
         let substs = self.args.as_slice();
         hir_fmt_generic_args(f, &substs[1..], None, Some(self.self_ty()))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index 1303e08801bd..ddc4e4ce85ef 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -1,6 +1,9 @@
 //! Utilities for computing drop info about types.
 
-use hir_def::{AdtId, signatures::StructFlags};
+use hir_def::{
+    AdtId,
+    signatures::{StructFlags, StructSignature},
+};
 use rustc_hash::FxHashSet;
 use rustc_type_ir::inherent::{AdtDef, IntoKind};
 use stdx::never;
@@ -73,8 +76,7 @@ fn has_drop_glue_impl<'db>(
             }
             match adt_id {
                 AdtId::StructId(id) => {
-                    if db
-                        .struct_signature(id)
+                    if StructSignature::of(db, id)
                         .flags
                         .intersects(StructFlags::IS_MANUALLY_DROP | StructFlags::IS_PHANTOM_DATA)
                     {
@@ -132,12 +134,9 @@ fn has_drop_glue_impl<'db>(
         TyKind::Slice(ty) => has_drop_glue_impl(infcx, ty, env, visited),
         TyKind::Closure(closure_id, subst) => {
             let owner = db.lookup_intern_closure(closure_id.0).0;
-            let Some(body_owner) = owner.as_def_with_body() else {
-                return DropGlue::None;
-            };
-            let infer = InferenceResult::for_body(db, body_owner);
+            let infer = InferenceResult::of(db, owner);
             let (captures, _) = infer.closure_info(closure_id.0);
-            let env = db.trait_environment_for_body(body_owner);
+            let env = db.trait_environment(owner);
             captures
                 .iter()
                 .map(|capture| has_drop_glue_impl(infcx, capture.ty(db, subst), env, visited))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 59cfd3fdc98c..d8093b3eb1c8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -4,8 +4,10 @@
 
 use hir_def::{
     AssocItemId, ConstId, FunctionId, GenericDefId, HasModule, TraitId, TypeAliasId,
-    TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
-    nameres::crate_def_map, signatures::TraitFlags,
+    TypeOrConstParamId, TypeParamId,
+    hir::generics::LocalTypeOrConstParamId,
+    nameres::crate_def_map,
+    signatures::{FunctionSignature, TraitFlags, TraitSignature},
 };
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -318,7 +320,7 @@ fn virtual_call_violations_for_method<F>(
 where
     F: FnMut(MethodViolationCode) -> ControlFlow<()>,
 {
-    let func_data = db.function_signature(func);
+    let func_data = FunctionSignature::of(db, func);
     if !func_data.has_self_param() {
         cb(MethodViolationCode::StaticMethod)?;
     }
@@ -371,7 +373,7 @@ fn virtual_call_violations_for_method<F>(
             trait_ref: pred_trait_ref,
             polarity: PredicatePolarity::Positive,
         }) = pred
-            && let trait_data = db.trait_signature(pred_trait_ref.def_id.0)
+            && let trait_data = TraitSignature::of(db, pred_trait_ref.def_id.0)
             && trait_data.flags.contains(TraitFlags::AUTO)
             && let rustc_type_ir::TyKind::Param(ParamTy { index: 0, .. }) =
                 pred_trait_ref.self_ty().kind()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
index 5c9b06e39a70..a70f98a0fe7b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
@@ -1,6 +1,6 @@
 use std::ops::ControlFlow;
 
-use hir_def::db::DefDatabase;
+use hir_def::signatures::TraitSignature;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ToSmolStr;
 use test_fixture::WithFixture;
@@ -40,8 +40,7 @@ fn check_dyn_compatibility<'a>(
             .declarations()
             .filter_map(|def| {
                 if let hir_def::ModuleDefId::TraitId(trait_id) = def {
-                    let name = db
-                        .trait_signature(trait_id)
+                    let name = TraitSignature::of(&db, trait_id)
                         .name
                         .display_no_db(file_id.edition(&db))
                         .to_smolstr();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index b3c888da8e95..57fe4d749b2d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -22,22 +22,22 @@
 use itertools::chain;
 use triomphe::Arc;
 
-pub fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {
+pub fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics<'_> {
     let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def)));
-    let (params, store) = db.generic_params_and_store(def);
+    let (params, store) = GenericParams::of(db, def);
     let has_trait_self_param = params.trait_self_param().is_some();
     Generics { def, params, parent_generics, has_trait_self_param, store }
 }
 #[derive(Clone, Debug)]
-pub struct Generics {
+pub struct Generics<'db> {
     def: GenericDefId,
     params: Arc<GenericParams>,
-    store: Arc<ExpressionStore>,
-    parent_generics: Option<Box<Generics>>,
+    store: &'db ExpressionStore,
+    parent_generics: Option<Box<Generics<'db>>>,
     has_trait_self_param: bool,
 }
 
-impl<T> ops::Index<T> for Generics
+impl<T> ops::Index<T> for Generics<'_>
 where
     GenericParams: ops::Index<T>,
 {
@@ -47,13 +47,13 @@ fn index(&self, index: T) -> &Self::Output {
     }
 }
 
-impl Generics {
+impl<'db> Generics<'db> {
     pub(crate) fn def(&self) -> GenericDefId {
         self.def
     }
 
     pub(crate) fn store(&self) -> &ExpressionStore {
-        &self.store
+        self.store
     }
 
     pub(crate) fn where_predicates(&self) -> impl Iterator<Item = &WherePredicate> {
@@ -97,7 +97,7 @@ pub(crate) fn iter_parents_with_store(
     ) -> impl Iterator<Item = ((GenericParamId, GenericParamDataRef<'_>), &ExpressionStore)> + '_
     {
         self.iter_parent()
-            .zip(self.parent_generics().into_iter().flat_map(|it| std::iter::repeat(&*it.store)))
+            .zip(self.parent_generics().into_iter().flat_map(|it| std::iter::repeat(it.store)))
     }
 
     /// Iterate over the params without parent params.
@@ -219,7 +219,7 @@ fn find_lifetime(&self, lifetime: LifetimeParamId) -> Option<usize> {
         }
     }
 
-    pub(crate) fn parent_generics(&self) -> Option<&Generics> {
+    pub(crate) fn parent_generics(&self) -> Option<&Generics<'db>> {
         self.parent_generics.as_deref()
     }
 }
@@ -243,7 +243,7 @@ pub(crate) fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Opt
 }
 
 fn from_toc_id<'a>(
-    it: &'a Generics,
+    it: &'a Generics<'a>,
 ) -> impl Fn(
     (LocalTypeOrConstParamId, &'a TypeOrConstParamData),
 ) -> (GenericParamId, GenericParamDataRef<'a>) {
@@ -263,7 +263,7 @@ fn from_toc_id<'a>(
 }
 
 fn from_lt_id<'a>(
-    it: &'a Generics,
+    it: &'a Generics<'a>,
 ) -> impl Fn((LocalLifetimeParamId, &'a LifetimeParamData)) -> (GenericParamId, GenericParamDataRef<'a>)
 {
     move |(local_id, p): (_, _)| {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 9d78f5de9e05..52edbc899ffa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -33,15 +33,15 @@
 use base_db::Crate;
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner, FieldId,
+    AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwnerId, FieldId,
     FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup, TraitId,
     TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
-    expr_store::{ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
+    expr_store::{Body, ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
     layout::Integer,
     resolver::{HasResolver, ResolveValueResult, Resolver, TypeNs, ValueNs},
-    signatures::{ConstSignature, EnumSignature, StaticSignature},
+    signatures::{ConstSignature, EnumSignature, FunctionSignature, StaticSignature},
     type_ref::{ConstRef, LifetimeRefId, TypeRef, TypeRefId},
 };
 use hir_expand::{mod_path::ModPath, name::Name};
@@ -105,8 +105,9 @@ pub fn infer_query_with_inspect<'db>(
 ) -> InferenceResult {
     let _p = tracing::info_span!("infer_query").entered();
     let resolver = def.resolver(db);
-    let body = db.body(def);
-    let mut ctx = InferenceContext::new(db, ExpressionStoreOwner::Body(def), &body.store, resolver);
+    let body = Body::of(db, def);
+    let mut ctx =
+        InferenceContext::new(db, ExpressionStoreOwnerId::Body(def), &body.store, resolver);
 
     if let Some(inspect) = inspect {
         ctx.table.infer_ctxt.attach_obligation_inspector(inspect);
@@ -114,8 +115,8 @@ pub fn infer_query_with_inspect<'db>(
 
     match def {
         DefWithBodyId::FunctionId(f) => ctx.collect_fn(f, body.self_param, &body.params),
-        DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
-        DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
+        DefWithBodyId::ConstId(c) => ctx.collect_const(c, ConstSignature::of(db, c)),
+        DefWithBodyId::StaticId(s) => ctx.collect_static(StaticSignature::of(db, s)),
         DefWithBodyId::VariantId(v) => {
             ctx.return_ty = match EnumSignature::variant_body_type(db, v.lookup(db).parent) {
                 hir_def::layout::IntegerType::Pointer(signed) => match signed {
@@ -146,10 +147,66 @@ pub fn infer_query_with_inspect<'db>(
 
     ctx.infer_mut_body(body.body_expr);
 
-    finalize_infer(ctx)
+    infer_finalize(ctx)
 }
 
-fn finalize_infer(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
+fn infer_cycle_result(db: &dyn HirDatabase, _: salsa::Id, _: DefWithBodyId) -> InferenceResult {
+    InferenceResult {
+        has_errors: true,
+        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
+    }
+}
+
+/// Infer types for all const expressions in an item's signature.
+///
+/// This handles const expressions that appear in type positions within a generic
+/// item's signature, such as array lengths (`[T; N]`) and const generic arguments
+/// (`Foo<{ expr }>`). Each root expression is inferred independently within
+/// a shared `InferenceContext`, accumulating results into a single `InferenceResult`.
+fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
+    let _p = tracing::info_span!("infer_signature_query").entered();
+    let store = ExpressionStore::of(db, def.into());
+    let mut roots = store.signature_const_expr_roots_with_origins().peekable();
+    let Some(_) = roots.peek() else {
+        return InferenceResult::new(crate::next_solver::default_types(db).types.error);
+    };
+
+    let resolver = def.resolver(db);
+    let owner = ExpressionStoreOwnerId::Signature(def);
+
+    let mut ctx = InferenceContext::new(db, owner, store, resolver);
+
+    for (root_expr, origin) in roots {
+        let expected = match origin {
+            // Array lengths are always `usize`.
+            ConstExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
+            // Const parameter default: look up the param's declared type.
+            ConstExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(
+                ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),
+            )),
+            // Path const generic args: determining the expected type requires
+            // path resolution.
+            // FIXME
+            ConstExprOrigin::GenericArgsPath => Expectation::None,
+        };
+        ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
+    }
+
+    infer_finalize(ctx)
+}
+
+fn infer_signature_cycle_result(
+    db: &dyn HirDatabase,
+    _: salsa::Id,
+    _: GenericDefId,
+) -> InferenceResult {
+    InferenceResult {
+        has_errors: true,
+        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
+    }
+}
+
+fn infer_finalize(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
     ctx.handle_opaque_type_uses();
 
     ctx.type_inference_fallback();
@@ -174,63 +231,6 @@ fn finalize_infer(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
 
     ctx.resolve_all()
 }
-
-fn infer_cycle_result(db: &dyn HirDatabase, _: salsa::Id, _: DefWithBodyId) -> InferenceResult {
-    InferenceResult {
-        has_errors: true,
-        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
-    }
-}
-
-/// Infer types for all const expressions in an item's signature.
-///
-/// This handles const expressions that appear in type positions within a generic
-/// item's signature, such as array lengths (`[T; N]`) and const generic arguments
-/// (`Foo<{ expr }>`). Each root expression is inferred independently within
-/// a shared `InferenceContext`, accumulating results into a single `InferenceResult`.
-fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
-    let _p = tracing::info_span!("infer_signature_query").entered();
-    let (_, store) = db.generic_params_and_store(def);
-    let mut roots = store.signature_const_expr_roots_with_origins().peekable();
-    let Some(_) = roots.peek() else {
-        return InferenceResult::new(crate::next_solver::default_types(db).types.error);
-    };
-
-    let resolver = def.resolver(db);
-    let owner = ExpressionStoreOwner::Signature(def);
-
-    let mut ctx = InferenceContext::new(db, owner, &store, resolver);
-
-    for (root_expr, origin) in roots {
-        let expected = match origin {
-            // Array lengths are always `usize`.
-            ConstExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
-            // Const parameter default: look up the param's declared type.
-            ConstExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(
-                ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),
-            )),
-            // Path const generic args: determining the expected type requires
-            // path resolution.
-            // FIXME
-            ConstExprOrigin::GenericArgsPath => Expectation::None,
-        };
-        ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
-    }
-
-    finalize_infer(ctx)
-}
-
-fn infer_signature_cycle_result(
-    db: &dyn HirDatabase,
-    _: salsa::Id,
-    _: GenericDefId,
-) -> InferenceResult {
-    InferenceResult {
-        has_errors: true,
-        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
-    }
-}
-
 /// Binding modes inferred for patterns.
 /// <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
@@ -604,7 +604,7 @@ pub struct InferenceResult {
 #[salsa::tracked]
 impl InferenceResult {
     #[salsa::tracked(returns(ref), cycle_result = infer_cycle_result)]
-    pub fn for_body(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
+    fn for_body(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
         infer_query(db, def)
     }
 
@@ -614,12 +614,21 @@ pub fn for_body(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
     /// const generic arguments, and other const expressions appearing in type
     /// positions within the item's signature.
     #[salsa::tracked(returns(ref), cycle_result = infer_signature_cycle_result)]
-    pub fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
+    fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
         infer_signature_query(db, def)
     }
 }
 
 impl InferenceResult {
+    pub fn of(db: &dyn HirDatabase, def: impl Into<ExpressionStoreOwnerId>) -> &InferenceResult {
+        match def.into() {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                Self::for_signature(db, generic_def_id)
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => Self::for_body(db, def_with_body_id),
+        }
+    }
+
     fn new(error_ty: Ty<'_>) -> Self {
         Self {
             method_resolutions: Default::default(),
@@ -816,7 +825,7 @@ pub fn binding_ty<'db>(&self, id: BindingId) -> Ty<'db> {
 #[derive(Clone, Debug)]
 pub(crate) struct InferenceContext<'body, 'db> {
     pub(crate) db: &'db dyn HirDatabase,
-    pub(crate) owner: ExpressionStoreOwner,
+    pub(crate) owner: ExpressionStoreOwnerId,
     pub(crate) store: &'body ExpressionStore,
     /// Generally you should not resolve things via this resolver. Instead create a TyLoweringContext
     /// and resolve the path via its methods. This will ensure proper error reporting.
@@ -917,14 +926,16 @@ fn find_continuable<'a, 'db>(
 impl<'body, 'db> InferenceContext<'body, 'db> {
     fn new(
         db: &'db dyn HirDatabase,
-        owner: ExpressionStoreOwner,
+        owner: ExpressionStoreOwnerId,
         store: &'body ExpressionStore,
         resolver: Resolver<'db>,
     ) -> Self {
         let trait_env = match owner {
-            ExpressionStoreOwner::Signature(generic_def_id) => db.trait_environment(generic_def_id),
-            ExpressionStoreOwner::Body(def_with_body_id) => {
-                db.trait_environment_for_body(def_with_body_id)
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                db.trait_environment(ExpressionStoreOwnerId::from(generic_def_id))
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => {
+                db.trait_environment(ExpressionStoreOwnerId::Body(def_with_body_id))
             }
         };
         let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
@@ -970,7 +981,7 @@ fn krate(&self) -> Crate {
     fn target_features(&self) -> (&TargetFeatures<'db>, TargetFeatureIsSafeInTarget) {
         let (target_features, target_feature_is_safe) = self.target_features.get_or_init(|| {
             let target_features = match self.owner {
-                ExpressionStoreOwner::Body(DefWithBodyId::FunctionId(id)) => {
+                ExpressionStoreOwnerId::Body(DefWithBodyId::FunctionId(id)) => {
                     TargetFeatures::from_fn(self.db, id)
                 }
                 _ => TargetFeatures::default(),
@@ -1167,11 +1178,11 @@ fn collect_static(&mut self, data: &StaticSignature) {
     }
 
     fn collect_fn(&mut self, func: FunctionId, self_param: Option<BindingId>, params: &[PatId]) {
-        let data = self.db.function_signature(func);
+        let data = FunctionSignature::of(self.db, func);
         let mut param_tys = self.with_ty_lowering(
             &data.store,
             InferenceTyDiagnosticSource::Signature,
-            LifetimeElisionKind::for_fn_params(&data),
+            LifetimeElisionKind::for_fn_params(data),
             |ctx| data.params.iter().map(|&type_ref| ctx.lower_ty(type_ref)).collect::<Vec<_>>(),
         );
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index fc38361d7e41..e5ee73447471 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -1,6 +1,10 @@
 //! Type cast logic. Basically coercion + additional casts.
 
-use hir_def::{AdtId, hir::ExprId, signatures::TraitFlags};
+use hir_def::{
+    AdtId,
+    hir::ExprId,
+    signatures::{TraitFlags, TraitSignature},
+};
 use rustc_ast_ir::Mutability;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -383,8 +387,7 @@ fn check_ptr_ptr_cast(
                             .chain(
                                 elaborate::supertrait_def_ids(ctx.interner(), src_principal)
                                     .filter(|trait_| {
-                                        ctx.db
-                                            .trait_signature(trait_.0)
+                                        TraitSignature::of(ctx.db, trait_.0)
                                             .flags
                                             .contains(TraitFlags::AUTO)
                                     }),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
index 2b9d3a7f5dbb..913d54e9697d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -4,8 +4,8 @@
 
 use base_db::Crate;
 use hir_def::{
-    DefWithBodyId, FieldId, HasModule, VariantId,
-    expr_store::path::Path,
+    ExpressionStoreOwnerId, FieldId, HasModule, VariantId,
+    expr_store::{Body, ExpressionStore, path::Path},
     hir::{
         Array, AsmOperand, BinaryOp, BindingId, CaptureBy, Expr, ExprId, ExprOrPatId, Pat, PatId,
         RecordSpread, Statement, UnaryOp,
@@ -179,9 +179,22 @@ pub fn kind(&self) -> CaptureKind {
     }
 
     /// Converts the place to a name that can be inserted into source code.
-    pub fn place_to_name(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
-        let mut result = body[self.place.local].name.as_str().to_owned();
+    pub fn place_to_name(&self, owner: ExpressionStoreOwnerId, db: &dyn HirDatabase) -> String {
+        let krate = owner.krate(db);
+        let edition = krate.data(db).edition;
+        let mut result = match owner {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                ExpressionStore::of(db, generic_def_id.into())[self.place.local]
+                    .name
+                    .display(db, edition)
+                    .to_string()
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => Body::of(db, def_with_body_id)
+                [self.place.local]
+                .name
+                .display(db, edition)
+                .to_string(),
+        };
         for proj in &self.place.projections {
             match proj {
                 HirPlaceProjection::Deref => {}
@@ -213,11 +226,26 @@ pub fn place_to_name(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> Strin
         result
     }
 
-    pub fn display_place_source_code(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
+    pub fn display_place_source_code(
+        &self,
+        owner: ExpressionStoreOwnerId,
+        db: &dyn HirDatabase,
+    ) -> String {
         let krate = owner.krate(db);
         let edition = krate.data(db).edition;
-        let mut result = body[self.place.local].name.display(db, edition).to_string();
+        let mut result = match owner {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                ExpressionStore::of(db, generic_def_id.into())[self.place.local]
+                    .name
+                    .display(db, edition)
+                    .to_string()
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => Body::of(db, def_with_body_id)
+                [self.place.local]
+                .name
+                .display(db, edition)
+                .to_string(),
+        };
         for proj in &self.place.projections {
             match proj {
                 // In source code autoderef kicks in.
@@ -258,11 +286,22 @@ pub fn display_place_source_code(&self, owner: DefWithBodyId, db: &dyn HirDataba
         result
     }
 
-    pub fn display_place(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
+    pub fn display_place(&self, owner: ExpressionStoreOwnerId, db: &dyn HirDatabase) -> String {
         let krate = owner.krate(db);
         let edition = krate.data(db).edition;
-        let mut result = body[self.place.local].name.display(db, edition).to_string();
+        let mut result = match owner {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                ExpressionStore::of(db, generic_def_id.into())[self.place.local]
+                    .name
+                    .display(db, edition)
+                    .to_string()
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => Body::of(db, def_with_body_id)
+                [self.place.local]
+                .name
+                .display(db, edition)
+                .to_string(),
+        };
         let mut field_need_paren = false;
         for proj in &self.place.projections {
             match proj {
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 2e80bad61414..c4c217b010ee 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
@@ -11,6 +11,7 @@
         InlineAsmKind, LabelId, Literal, Pat, PatId, RecordSpread, Statement, UnaryOp,
     },
     resolver::ValueNs,
+    signatures::FunctionSignature,
 };
 use hir_def::{FunctionId, hir::ClosureKind};
 use hir_expand::name::Name;
@@ -2194,7 +2195,7 @@ fn check_legacy_const_generics(&mut self, callee: Ty<'db>, args: &[ExprId]) -> B
             _ => return Default::default(),
         };
 
-        let data = self.db.function_signature(func);
+        let data = FunctionSignature::of(self.db, func);
         let Some(legacy_const_generics_indices) = data.legacy_const_generics_indices(self.db, func)
         else {
             return Default::default();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 17d4901123bb..71d68ccd47a6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -4,6 +4,7 @@
     AdtId, AssocItemId, GenericDefId, ItemContainerId, Lookup,
     expr_store::path::{Path, PathSegment},
     resolver::{ResolveValueResult, TypeNs, ValueNs},
+    signatures::{ConstSignature, FunctionSignature},
 };
 use hir_expand::name::Name;
 use rustc_type_ir::inherent::{SliceLike, Ty as _};
@@ -263,7 +264,7 @@ fn resolve_trait_assoc_item(
             trait_.trait_items(self.db).items.iter().map(|(_name, id)| *id).find_map(|item| {
                 match item {
                     AssocItemId::FunctionId(func) => {
-                        if segment.name == &self.db.function_signature(func).name {
+                        if segment.name == &FunctionSignature::of(self.db, func).name {
                             Some(CandidateId::FunctionId(func))
                         } else {
                             None
@@ -271,7 +272,7 @@ fn resolve_trait_assoc_item(
                     }
 
                     AssocItemId::ConstId(konst) => {
-                        if self.db.const_signature(konst).name.as_ref() == Some(segment.name) {
+                        if ConstSignature::of(self.db, konst).name.as_ref() == Some(segment.name) {
                             Some(CandidateId::ConstId(konst))
                         } else {
                             None
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 77f76c97b8e6..d093412b4210 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -3,7 +3,7 @@
 use std::fmt;
 
 use base_db::Crate;
-use hir_def::{AdtId, ExpressionStoreOwner, GenericParamId};
+use hir_def::{AdtId, ExpressionStoreOwnerId, GenericParamId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::FxHashSet;
@@ -147,7 +147,7 @@ pub(crate) fn new(
         db: &'db dyn HirDatabase,
         trait_env: ParamEnv<'db>,
         krate: Crate,
-        owner: Option<ExpressionStoreOwner>,
+        owner: Option<ExpressionStoreOwnerId>,
     ) -> Self {
         let interner = DbInterner::new_with(db, krate);
         let typing_mode = match owner {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lang_items.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lang_items.rs
index 18feb0f46a32..ae53276f56a5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lang_items.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lang_items.rs
@@ -1,13 +1,17 @@
 //! Functions to detect special lang items
 
-use hir_def::{AdtId, TraitId, lang_item::LangItems, signatures::StructFlags};
+use hir_def::{
+    AdtId, TraitId,
+    lang_item::LangItems,
+    signatures::{StructFlags, StructSignature},
+};
 use intern::{Symbol, sym};
 
 use crate::db::HirDatabase;
 
 pub fn is_box(db: &dyn HirDatabase, adt: AdtId) -> bool {
     let AdtId::StructId(id) = adt else { return false };
-    db.struct_signature(id).flags.contains(StructFlags::IS_BOX)
+    StructSignature::of(db, id).flags.contains(StructFlags::IS_BOX)
 }
 
 pub fn lang_items_for_bin_op(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index a325b2e17438..54332122d0e4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -333,10 +333,7 @@ pub fn layout_of_ty_query(
         }
         TyKind::Closure(id, args) => {
             let def = db.lookup_intern_closure(id.0);
-            let Some(body_owner) = def.0.as_def_with_body() else {
-                return Err(LayoutError::HasErrorType);
-            };
-            let infer = InferenceResult::for_body(db, body_owner);
+            let infer = InferenceResult::of(db, def.0);
             let (captures, _) = infer.closure_info(id.0);
             let fields = captures
                 .iter()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index d2495917187e..6090ddfd45cc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -5,7 +5,7 @@
 use hir_def::{
     AdtId, VariantId,
     attrs::AttrFlags,
-    signatures::{StructFlags, VariantFields},
+    signatures::{StructFlags, StructSignature, VariantFields},
 };
 use rustc_abi::{Integer, ReprOptions, TargetDataLayout};
 use rustc_index::IndexVec;
@@ -41,7 +41,7 @@ pub fn layout_of_adt_query(
     };
     let (variants, repr, is_special_no_niche) = match def {
         AdtId::StructId(s) => {
-            let sig = db.struct_signature(s);
+            let sig = StructSignature::of(db, s);
             let mut r = SmallVec::<[_; 1]>::new();
             r.push(handle_variant(s.into(), s.fields(db))?);
             (
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index e491c29df3b5..484ecebba534 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -1,6 +1,12 @@
 use base_db::target::TargetData;
 use either::Either;
-use hir_def::{HasModule, db::DefDatabase};
+use hir_def::{
+    DefWithBodyId, ExpressionStoreOwnerId, GenericDefId, HasModule,
+    expr_store::Body,
+    signatures::{
+        EnumSignature, FunctionSignature, StructSignature, TypeAliasSignature, UnionSignature,
+    },
+};
 use project_model::{Sysroot, toolchain_info::QueryConfig};
 use rustc_hash::FxHashMap;
 use rustc_type_ir::inherent::GenericArgs as _;
@@ -49,18 +55,15 @@ fn eval_goal(
             let adt_or_type_alias_id = scope.declarations().find_map(|x| match x {
                 hir_def::ModuleDefId::AdtId(x) => {
                     let name = match x {
-                        hir_def::AdtId::StructId(x) => db
-                            .struct_signature(x)
+                        hir_def::AdtId::StructId(x) => StructSignature::of(&db, x)
                             .name
                             .display_no_db(file_id.edition(&db))
                             .to_smolstr(),
-                        hir_def::AdtId::UnionId(x) => db
-                            .union_signature(x)
+                        hir_def::AdtId::UnionId(x) => UnionSignature::of(&db, x)
                             .name
                             .display_no_db(file_id.edition(&db))
                             .to_smolstr(),
-                        hir_def::AdtId::EnumId(x) => db
-                            .enum_signature(x)
+                        hir_def::AdtId::EnumId(x) => EnumSignature::of(&db, x)
                             .name
                             .display_no_db(file_id.edition(&db))
                             .to_smolstr(),
@@ -68,8 +71,7 @@ fn eval_goal(
                     (name == "Goal").then_some(Either::Left(x))
                 }
                 hir_def::ModuleDefId::TypeAliasId(x) => {
-                    let name = db
-                        .type_alias_signature(x)
+                    let name = TypeAliasSignature::of(&db, x)
                         .name
                         .display_no_db(file_id.edition(&db))
                         .to_smolstr();
@@ -90,10 +92,13 @@ fn eval_goal(
             ),
             Either::Right(ty_id) => db.ty(ty_id.into()).instantiate_identity(),
         };
-        let param_env = db.trait_environment(match adt_or_type_alias_id {
-            Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
-            Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
-        });
+        let param_env = db.trait_environment(
+            match adt_or_type_alias_id {
+                Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
+                Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
+            }
+            .into(),
+        );
         let krate = match adt_or_type_alias_id {
             Either::Left(it) => it.krate(&db),
             Either::Right(it) => it.krate(&db),
@@ -123,8 +128,7 @@ fn eval_expr(
             .declarations()
             .find_map(|x| match x {
                 hir_def::ModuleDefId::FunctionId(x) => {
-                    let name = db
-                        .function_signature(x)
+                    let name = FunctionSignature::of(&db, x)
                         .name
                         .display_no_db(file_id.edition(&db))
                         .to_smolstr();
@@ -133,15 +137,16 @@ fn eval_expr(
                 _ => None,
             })
             .unwrap();
-        let hir_body = db.body(function_id.into());
+        let hir_body = Body::of(&db, function_id.into());
         let b = hir_body
             .bindings()
             .find(|x| x.1.name.display_no_db(file_id.edition(&db)).to_smolstr() == "goal")
             .unwrap()
             .0;
-        let infer = InferenceResult::for_body(&db, function_id.into());
+        let infer = InferenceResult::of(&db, DefWithBodyId::from(function_id));
         let goal_ty = infer.type_of_binding[b].clone();
-        let param_env = db.trait_environment(function_id.into());
+        let param_env =
+            db.trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(function_id)));
         let krate = function_id.krate(&db);
         db.layout_of_ty(goal_ty, ParamEnvAndCrate { param_env, krate }.store())
     })
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
index 8d87276a0b15..e6b8329ca861 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -61,8 +61,8 @@
 use std::{hash::Hash, ops::ControlFlow};
 
 use hir_def::{
-    CallableDefId, GenericDefId, TypeAliasId, TypeOrConstParamId, TypeParamId,
-    hir::generics::GenericParams, resolver::TypeNs, type_ref::Rawness,
+    CallableDefId, ExpressionStoreOwnerId, GenericDefId, TypeAliasId, TypeOrConstParamId,
+    TypeParamId, hir::generics::GenericParams, resolver::TypeNs, type_ref::Rawness,
 };
 use hir_expand::name::Name;
 use indexmap::{IndexMap, map::Entry};
@@ -507,7 +507,7 @@ pub fn associated_type_shorthand_candidates(
     let mut dedup_map = FxHashSet::default();
     let param_ty = Ty::new_param(interner, param, param_idx(db, param.into()).unwrap() as u32);
     // We use the ParamEnv and not the predicates because the ParamEnv elaborates bounds.
-    let param_env = db.trait_environment(def);
+    let param_env = db.trait_environment(ExpressionStoreOwnerId::from(def));
     for clause in param_env.clauses {
         let ClauseKind::Trait(trait_clause) = clause.kind().skip_binder() else { continue };
         if trait_clause.self_ty() != param_ty {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index c0bd8975711f..3ed563315e5e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -13,10 +13,10 @@
 use arrayvec::ArrayVec;
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    FunctionId, GeneralConstId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId,
-    LifetimeParamId, LocalFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId,
-    TypeOrConstParamId, TypeParamId, UnionId, VariantId,
+    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, EnumId, EnumVariantId,
+    ExpressionStoreOwnerId, FunctionId, GeneralConstId, GenericDefId, GenericParamId, HasModule,
+    ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup, StaticId, StructId, TraitId,
+    TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId, VariantId,
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, HygieneId, path::Path},
     hir::generics::{
@@ -26,7 +26,10 @@
     item_tree::FieldsShape,
     lang_item::LangItems,
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs, ValueNs},
-    signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
+    signatures::{
+        ConstSignature, FunctionSignature, ImplSignature, StaticSignature, StructSignature,
+        TraitFlags, TraitSignature, TypeAliasFlags, TypeAliasSignature,
+    },
     type_ref::{
         ConstRef, FnType, LifetimeRefId, PathId, TraitBoundModifier, TraitRef as HirTraitRef,
         TypeBound, TypeRef, TypeRefId,
@@ -178,7 +181,7 @@ pub struct TyLoweringContext<'db, 'a> {
     resolver: &'a Resolver<'db>,
     store: &'a ExpressionStore,
     def: GenericDefId,
-    generics: OnceCell<Generics>,
+    generics: OnceCell<Generics<'db>>,
     in_binders: DebruijnIndex,
     impl_trait_mode: ImplTraitLoweringState,
     /// Tracks types with explicit `?Sized` bounds.
@@ -404,7 +407,7 @@ pub(crate) fn lower_path_as_const(&mut self, path: &Path, const_type: Ty<'db>) -
         self.path_to_const(path).unwrap_or_else(|| unknown_const(const_type))
     }
 
-    fn generics(&self) -> &Generics {
+    fn generics(&self) -> &Generics<'db> {
         self.generics.get_or_init(|| generics(self.db, self.def))
     }
 
@@ -782,7 +785,8 @@ fn lower_dyn_trait(&mut self, bounds: &[TypeBound]) -> Ty<'db> {
                     match b.kind().skip_binder() {
                         rustc_type_ir::ClauseKind::Trait(t) => {
                             let id = t.def_id();
-                            let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
+                            let is_auto =
+                                TraitSignature::of(db, id.0).flags.contains(TraitFlags::AUTO);
                             if is_auto {
                                 auto_traits.push(t.def_id().0);
                             } else {
@@ -1166,7 +1170,7 @@ pub(crate) fn impl_trait_with_diagnostics_query<'db>(
         db: &'db dyn HirDatabase,
         impl_id: ImplId,
     ) -> Option<(StoredEarlyBinder<(TraitId, StoredGenericArgs)>, Diagnostics)> {
-        let impl_data = db.impl_signature(impl_id);
+        let impl_data = ImplSignature::of(db, impl_id);
         let resolver = impl_id.resolver(db);
         let mut ctx = TyLoweringContext::new(
             db,
@@ -1251,7 +1255,7 @@ pub(crate) fn return_type_impl_traits(
         def: hir_def::FunctionId,
     ) -> Option<Box<StoredEarlyBinder<ImplTraits>>> {
         // FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe
-        let data = db.function_signature(def);
+        let data = FunctionSignature::of(db, def);
         let resolver = def.resolver(db);
         let mut ctx_ret = TyLoweringContext::new(
             db,
@@ -1279,7 +1283,7 @@ pub(crate) fn type_alias_impl_traits(
         db: &dyn HirDatabase,
         def: hir_def::TypeAliasId,
     ) -> Option<Box<StoredEarlyBinder<ImplTraits>>> {
-        let data = db.type_alias_signature(def);
+        let data = TypeAliasSignature::of(db, def);
         let resolver = def.resolver(db);
         let mut ctx = TyLoweringContext::new(
             db,
@@ -1369,7 +1373,7 @@ fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> StoredEarlyBinder<Store
 /// Build the declared type of a const.
 fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> StoredEarlyBinder<StoredTy> {
     let resolver = def.resolver(db);
-    let data = db.const_signature(def);
+    let data = ConstSignature::of(db, def);
     let parent = def.loc(db).container;
     let mut ctx = TyLoweringContext::new(
         db,
@@ -1385,7 +1389,7 @@ fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> StoredEarlyBinder<Store
 /// Build the declared type of a static.
 fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> StoredEarlyBinder<StoredTy> {
     let resolver = def.resolver(db);
-    let data = db.static_signature(def);
+    let data = StaticSignature::of(db, def);
     let mut ctx = TyLoweringContext::new(
         db,
         &resolver,
@@ -1402,7 +1406,7 @@ fn type_for_struct_constructor(
     db: &dyn HirDatabase,
     def: StructId,
 ) -> Option<StoredEarlyBinder<StoredTy>> {
-    let struct_data = db.struct_signature(def);
+    let struct_data = StructSignature::of(db, def);
     match struct_data.shape {
         FieldsShape::Record => None,
         FieldsShape::Unit => Some(type_for_adt(db, def.into())),
@@ -1477,7 +1481,7 @@ pub(crate) fn type_for_type_alias_with_diagnostics_query<'db>(
         db: &'db dyn HirDatabase,
         t: TypeAliasId,
     ) -> (StoredEarlyBinder<StoredTy>, Diagnostics) {
-        let type_alias_data = db.type_alias_signature(t);
+        let type_alias_data = TypeAliasSignature::of(db, t);
         let mut diags = None;
         let resolver = t.resolver(db);
         let interner = DbInterner::new_no_crate(db);
@@ -1540,7 +1544,7 @@ pub(crate) fn impl_self_ty_with_diagnostics_query<'db>(
     ) -> (StoredEarlyBinder<StoredTy>, Diagnostics) {
         let resolver = impl_id.resolver(db);
 
-        let impl_data = db.impl_signature(impl_id);
+        let impl_data = ImplSignature::of(db, impl_id);
         let mut ctx = TyLoweringContext::new(
             db,
             &resolver,
@@ -1586,14 +1590,14 @@ pub(crate) fn const_param_ty_with_diagnostics_query<'db>(
         _: (),
         def: ConstParamId,
     ) -> (StoredTy, Diagnostics) {
-        let (parent_data, store) = db.generic_params_and_store(def.parent());
+        let (parent_data, store) = GenericParams::of(db, def.parent());
         let data = &parent_data[def.local_id()];
         let resolver = def.parent().resolver(db);
         let interner = DbInterner::new_no_crate(db);
         let mut ctx = TyLoweringContext::new(
             db,
             &resolver,
-            &store,
+            store,
             def.parent(),
             LifetimeElisionKind::AnonymousReportError,
         );
@@ -1684,7 +1688,7 @@ fn supertraits_info(db: &dyn HirDatabase, trait_: TraitId) -> SupertraitsInfo {
             ));
 
             let resolver = trait_.resolver(db);
-            let signature = db.trait_signature(trait_);
+            let signature = TraitSignature::of(db, trait_);
             for pred in signature.generic_params.where_predicates() {
                 let (WherePredicate::TypeBound { target, bound }
                 | WherePredicate::ForLifetime { lifetimes: _, target, bound }) = pred
@@ -1955,7 +1959,7 @@ pub fn type_alias_bounds_with_diagnostics_query<'db>(
         db: &'db dyn HirDatabase,
         type_alias: TypeAliasId,
     ) -> (TypeAliasBounds<StoredEarlyBinder<StoredClauses>>, Diagnostics) {
-        let type_alias_data = db.type_alias_signature(type_alias);
+        let type_alias_data = TypeAliasSignature::of(db, type_alias);
         let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
         let mut ctx = TyLoweringContext::new(
             db,
@@ -2134,16 +2138,6 @@ pub fn explicit_implied_predicates(&self) -> EarlyBinder<'_, &[Clause<'_>]> {
     }
 }
 
-pub(crate) fn trait_environment_for_body_query(
-    db: &dyn HirDatabase,
-    def: DefWithBodyId,
-) -> ParamEnv<'_> {
-    let Some(def) = def.as_generic_def_id(db) else {
-        return ParamEnv::empty();
-    };
-    db.trait_environment(def)
-}
-
 pub(crate) fn param_env_from_predicates<'db>(
     interner: DbInterner<'db>,
     predicates: &'db GenericPredicates,
@@ -2158,7 +2152,18 @@ pub(crate) fn param_env_from_predicates<'db>(
     ParamEnv { clauses }
 }
 
-pub(crate) fn trait_environment<'db>(db: &'db dyn HirDatabase, def: GenericDefId) -> ParamEnv<'db> {
+pub(crate) fn trait_environment<'db>(
+    db: &'db dyn HirDatabase,
+    def: ExpressionStoreOwnerId,
+) -> ParamEnv<'db> {
+    let def = match def {
+        ExpressionStoreOwnerId::Signature(def) => def,
+        ExpressionStoreOwnerId::Body(def) => match def.as_generic_def_id(db) {
+            Some(def) => def,
+            None => return ParamEnv::empty(),
+        },
+    };
+
     return ParamEnv { clauses: trait_environment_query(db, def).as_ref() };
 
     #[salsa::tracked(returns(ref))]
@@ -2358,7 +2363,7 @@ fn implicit_trait_predicate<'db>(
 fn push_const_arg_has_type_predicates<'db>(
     db: &'db dyn HirDatabase,
     predicates: &mut Vec<Clause<'db>>,
-    generics: &Generics,
+    generics: &Generics<'db>,
 ) {
     let interner = DbInterner::new_no_crate(db);
     let const_params_offset = generics.len_parent() + generics.len_lifetimes_self();
@@ -2504,7 +2509,7 @@ pub(crate) fn callable_item_signature_query<'db>(
 }
 
 fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> StoredEarlyBinder<StoredPolyFnSig> {
-    let data = db.function_signature(def);
+    let data = FunctionSignature::of(db, def);
     let resolver = def.resolver(db);
     let interner = DbInterner::new_no_crate(db);
     let mut ctx_params = TyLoweringContext::new(
@@ -2512,7 +2517,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> StoredEarlyBinder<Sto
         &resolver,
         &data.store,
         def.into(),
-        LifetimeElisionKind::for_fn_params(&data),
+        LifetimeElisionKind::for_fn_params(data),
     );
     let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));
 
@@ -2590,7 +2595,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
     db: &'db dyn HirDatabase,
     type_alias: TypeAliasId,
 ) -> EarlyBinder<'db, BoundExistentialPredicates<'db>> {
-    let type_alias_data = db.type_alias_signature(type_alias);
+    let type_alias_data = TypeAliasSignature::of(db, type_alias);
     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
     let interner = DbInterner::new_no_crate(db);
     let mut ctx = TyLoweringContext::new(
@@ -2612,7 +2617,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
                 .map_bound(|c| match c {
                     rustc_type_ir::ClauseKind::Trait(t) => {
                         let id = t.def_id();
-                        let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
+                        let is_auto = TraitSignature::of(db, id.0).flags.contains(TraitFlags::AUTO);
                         if is_auto {
                             Some(ExistentialPredicate::AutoTrait(t.def_id()))
                         } else {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index 81a944128d23..889f0792d347 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -14,7 +14,7 @@
         GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,
     },
     resolver::{ResolveValueResult, TypeNs, ValueNs},
-    signatures::TraitFlags,
+    signatures::{TraitFlags, TraitSignature},
     type_ref::{TypeRef, TypeRefId},
 };
 use rustc_type_ir::{
@@ -625,10 +625,7 @@ pub(crate) fn substs_from_path_segment(
                 GenericDefId::TraitId(trait_) => {
                     // RTN is prohibited anyways if we got here.
                     let is_rtn = args.parenthesized == GenericArgsParentheses::ReturnTypeNotation;
-                    let is_fn_trait = self
-                        .ctx
-                        .db
-                        .trait_signature(trait_)
+                    let is_fn_trait = TraitSignature::of(self.ctx.db, trait_)
                         .flags
                         .contains(TraitFlags::RUSTC_PAREN_SUGAR);
                     is_rtn || !is_fn_trait
@@ -1024,7 +1021,7 @@ fn inferred_kind(
 fn check_generic_args_len<'db>(
     args_and_bindings: Option<&HirGenericArgs>,
     def: GenericDefId,
-    def_generics: &Generics,
+    def_generics: &Generics<'db>,
     infer_args: bool,
     lifetime_elision: &LifetimeElisionKind<'db>,
     lowering_assoc_type_generics: bool,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index ad4d79e68a9f..e058a254205e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -17,11 +17,12 @@
     ImplId, ItemContainerId, ModuleId, TraitId,
     attrs::AttrFlags,
     builtin_derive::BuiltinDeriveImplMethod,
-    expr_store::path::GenericArgs as HirGenericArgs,
+    expr_store::{Body, path::GenericArgs as HirGenericArgs},
     hir::ExprId,
     lang_item::LangItems,
     nameres::{DefMap, block_def_map, crate_def_map},
     resolver::Resolver,
+    signatures::{ConstSignature, FunctionSignature},
 };
 use intern::{Symbol, sym};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -366,7 +367,7 @@ pub fn lookup_impl_const<'db>(
     };
     let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), subs);
 
-    let const_signature = db.const_signature(const_id);
+    let const_signature = ConstSignature::of(db, const_id);
     let name = match const_signature.name.as_ref() {
         Some(name) => name,
         None => return (const_id, subs),
@@ -439,7 +440,7 @@ pub(crate) fn lookup_impl_method_query<'db>(
         GenericArgs::new_from_slice(&fn_subst[..trait_params]),
     );
 
-    let name = &db.function_signature(func).name;
+    let name = &FunctionSignature::of(db, func).name;
     let Some((impl_fn, impl_subst)) =
         lookup_impl_assoc_item_for_trait_ref(&infcx, trait_ref, env.param_env, name).and_then(
             |(assoc, impl_args)| {
@@ -623,7 +624,7 @@ fn collect(
                 // To better support custom derives, collect impls in all unnamed const items.
                 // const _: () = { ... };
                 for konst in module_data.scope.unnamed_consts() {
-                    let body = db.body(konst.into());
+                    let body = Body::of(db, konst.into());
                     for (_, block_def_map) in body.blocks(db) {
                         collect(db, block_def_map, map);
                     }
@@ -766,7 +767,7 @@ fn collect(
                 // To better support custom derives, collect impls in all unnamed const items.
                 // const _: () = { ... };
                 for konst in module_data.scope.unnamed_consts() {
-                    let body = db.body(konst.into());
+                    let body = Body::of(db, konst.into());
                     for (_, block_def_map) in body.blocks(db) {
                         collect(db, block_def_map, lang_items, map);
                     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
index fc2bd87ee429..e2a53cc830e3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
@@ -5,7 +5,7 @@
 
 use hir_def::{
     AssocItemId, FunctionId, GenericParamId, ImplId, ItemContainerId, TraitId,
-    signatures::TraitFlags,
+    signatures::{FunctionSignature, TraitFlags, TraitSignature},
 };
 use hir_expand::name::Name;
 use rustc_ast_ir::Mutability;
@@ -1605,7 +1605,8 @@ fn consider_probe(
                     // Some trait methods are excluded for arrays before 2021.
                     // (`array.into_iter()` wants a slice iterator for compatibility.)
                     if self_ty.is_array() && !self.ctx.edition.at_least_2021() {
-                        let trait_signature = self.db().trait_signature(poly_trait_ref.def_id().0);
+                        let trait_signature =
+                            TraitSignature::of(self.db(), poly_trait_ref.def_id().0);
                         if trait_signature
                             .flags
                             .contains(TraitFlags::SKIP_ARRAY_DURING_METHOD_DISPATCH)
@@ -1619,7 +1620,8 @@ fn consider_probe(
                     if self_ty.boxed_ty().is_some_and(Ty::is_slice)
                         && !self.ctx.edition.at_least_2024()
                     {
-                        let trait_signature = self.db().trait_signature(poly_trait_ref.def_id().0);
+                        let trait_signature =
+                            TraitSignature::of(self.db(), poly_trait_ref.def_id().0);
                         if trait_signature
                             .flags
                             .contains(TraitFlags::SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH)
@@ -1963,7 +1965,7 @@ fn has_applicable_self(&self, item: CandidateId) -> bool {
         // associated value (i.e., methods, constants).
         match item {
             CandidateId::FunctionId(id) if self.mode == Mode::MethodCall => {
-                self.db().function_signature(id).has_self_param()
+                FunctionSignature::of(self.db(), id).has_self_param()
             }
             _ => true,
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
index 2dcc2d1062fd..3ff2db15aaf5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
@@ -5,10 +5,10 @@
 
 use std::iter;
 
-use hir_def::{DefWithBodyId, HasModule};
+use hir_def::{DefWithBodyId, ExpressionStoreOwnerId, HasModule};
 use la_arena::ArenaMap;
 use rustc_hash::FxHashMap;
-use rustc_type_ir::inherent::{GenericArgs as _, Ty as _};
+use rustc_type_ir::inherent::GenericArgs as _;
 use stdx::never;
 use triomphe::Arc;
 
@@ -18,7 +18,7 @@
     display::DisplayTarget,
     mir::OperandKind,
     next_solver::{
-        DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, StoredTy, Ty, TypingMode,
+        DbInterner, GenericArgs, ParamEnv, StoredTy, Ty, TypingMode,
         infer::{DbInternerInferExt, InferCtxt},
     },
 };
@@ -99,7 +99,7 @@ pub fn borrowck_query(
     let _p = tracing::info_span!("borrowck_query").entered();
     let module = def.module(db);
     let interner = DbInterner::new_with(db, module.krate(db));
-    let env = db.trait_environment_for_body(def);
+    let env = db.trait_environment(ExpressionStoreOwnerId::from(def));
     let mut res = vec![];
     // This calculates opaques defining scope which is a bit costly therefore is put outside `all_mir_bodies()`.
     let typing_mode = TypingMode::borrowck(interner, def.into());
@@ -123,10 +123,7 @@ fn make_fetch_closure_field<'db>(
     |c: InternedClosureId, subst: GenericArgs<'db>, f: usize| {
         let InternedClosure(owner, _) = db.lookup_intern_closure(c);
         let interner = DbInterner::new_no_crate(db);
-        let Some(def) = owner.as_def_with_body() else {
-            return Ty::new_error(interner, ErrorGuaranteed);
-        };
-        let infer = InferenceResult::for_body(db, def);
+        let infer = InferenceResult::of(db, owner);
         let (captures, _) = infer.closure_info(c);
         let parent_subst = subst.as_closure().parent_args();
         captures.get(f).expect("broken closure field").ty.get().instantiate(interner, parent_subst)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index a85b3ef50aa5..c013e78d81b8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -5,14 +5,17 @@
 use base_db::{Crate, target::TargetLoadError};
 use either::Either;
 use hir_def::{
-    AdtId, DefWithBodyId, EnumVariantId, FunctionId, GeneralConstId, HasModule, ItemContainerId,
-    Lookup, StaticId, VariantId,
-    expr_store::HygieneId,
+    AdtId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId, FunctionId, GeneralConstId,
+    HasModule, ItemContainerId, Lookup, StaticId, VariantId,
+    expr_store::{Body, HygieneId},
     item_tree::FieldsShape,
     lang_item::LangItems,
     layout::{TagEncoding, Variants},
     resolver::{HasResolver, TypeNs, ValueNs},
-    signatures::{StaticFlags, StructFlags},
+    signatures::{
+        EnumSignature, FunctionSignature, StaticFlags, StaticSignature, StructFlags,
+        StructSignature, TraitSignature,
+    },
 };
 use hir_expand::{InFile, mod_path::path, name::Name};
 use intern::sym;
@@ -386,7 +389,7 @@ pub fn pretty_print(
             for (func, span, def) in stack.iter().take(30).rev() {
                 match func {
                     Either::Left(func) => {
-                        let function_name = db.function_signature(*func);
+                        let function_name = FunctionSignature::of(db, *func);
                         writeln!(
                             f,
                             "In function {} ({:?})",
@@ -398,7 +401,7 @@ pub fn pretty_print(
                         writeln!(f, "In {closure:?}")?;
                     }
                 }
-                let source_map = db.body_with_source_map(*def).1;
+                let source_map = &Body::with_source_map(db, *def).1;
                 let span: InFile<SyntaxNodePtr> = match span {
                     MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {
                         Ok(s) => s.map(|it| it.into()),
@@ -441,7 +444,7 @@ pub fn pretty_print(
                 )?;
             }
             MirEvalError::MirLowerError(func, err) => {
-                let function_name = db.function_signature(*func);
+                let function_name = FunctionSignature::of(db, *func);
                 let self_ = match func.lookup(db).container {
                     ItemContainerId::ImplId(impl_id) => Some({
                         db.impl_self_ty(impl_id)
@@ -450,7 +453,10 @@ pub fn pretty_print(
                             .to_string()
                     }),
                     ItemContainerId::TraitId(it) => Some(
-                        db.trait_signature(it).name.display(db, display_target.edition).to_string(),
+                        TraitSignature::of(db, it)
+                            .name
+                            .display(db, display_target.edition)
+                            .to_string(),
                     ),
                     _ => None,
                 };
@@ -660,7 +666,7 @@ pub fn new(
             db,
             random_state: oorandom::Rand64::new(0),
             param_env: trait_env.unwrap_or_else(|| ParamEnvAndCrate {
-                param_env: db.trait_environment_for_body(owner),
+                param_env: db.trait_environment(ExpressionStoreOwnerId::from(owner)),
                 krate: crate_id,
             }),
             crate_id,
@@ -731,10 +737,7 @@ fn projected_ty(&self, ty: Ty<'db>, proj: PlaceElem) -> Ty<'db> {
             ty,
             |c, subst, f| {
                 let InternedClosure(owner, _) = self.db.lookup_intern_closure(c);
-                let Some(def) = owner.as_def_with_body() else {
-                    return Ty::new_error(self.interner(), ErrorGuaranteed);
-                };
-                let infer = InferenceResult::for_body(self.db, def);
+                let infer = InferenceResult::of(self.db, owner);
                 let (captures, _) = infer.closure_info(c);
                 let parent_subst = subst.as_closure().parent_args();
                 captures
@@ -896,8 +899,8 @@ fn operand_ty(&self, o: &Operand, locals: &Locals) -> Result<'db, Ty<'db>> {
             OperandKind::Copy(p) | OperandKind::Move(p) => self.place_ty(p, locals)?,
             OperandKind::Constant { konst: _, ty } => ty.as_ref(),
             &OperandKind::Static(s) => {
-                let ty = InferenceResult::for_body(self.db, s.into())
-                    .expr_ty(self.db.body(s.into()).body_expr);
+                let ty = InferenceResult::of(self.db, DefWithBodyId::from(s))
+                    .expr_ty(Body::of(self.db, s.into()).body_expr);
                 Ty::new_ref(
                     self.interner(),
                     Region::new_static(self.interner()),
@@ -2824,15 +2827,15 @@ fn eval_static(&mut self, st: StaticId, locals: &Locals) -> Result<'db, Address>
         if let Some(o) = self.static_locations.get(&st) {
             return Ok(*o);
         };
-        let static_data = self.db.static_signature(st);
+        let static_data = StaticSignature::of(self.db, st);
         let result = if !static_data.flags.contains(StaticFlags::EXTERN) {
             let konst = self.db.const_eval_static(st).map_err(|e| {
                 MirEvalError::ConstEvalError(static_data.name.as_str().to_owned(), Box::new(e))
             })?;
             self.allocate_const_in_heap(locals, konst)?
         } else {
-            let ty = InferenceResult::for_body(self.db, st.into())
-                .expr_ty(self.db.body(st.into()).body_expr);
+            let ty = InferenceResult::of(self.db, DefWithBodyId::from(st))
+                .expr_ty(Body::of(self.db, st.into()).body_expr);
             let Some((size, align)) = self.size_align_of(ty, locals)? else {
                 not_supported!("unsized extern static");
             };
@@ -2855,7 +2858,7 @@ fn const_eval_discriminant(&self, variant: EnumVariantId) -> Result<'db, i128> {
                 let edition = self.crate_id.data(self.db).edition;
                 let name = format!(
                     "{}::{}",
-                    self.db.enum_signature(loc.parent).name.display(db, edition),
+                    EnumSignature::of(self.db, loc.parent).name.display(db, edition),
                     loc.parent
                         .enum_variants(self.db)
                         .variant_name_by_id(variant)
@@ -2915,7 +2918,7 @@ fn run_drop_glue_deep(
                 let id = adt_def.def_id().0;
                 match id {
                     AdtId::StructId(s) => {
-                        let data = self.db.struct_signature(s);
+                        let data = StructSignature::of(self.db, s);
                         if data.flags.contains(StructFlags::IS_MANUALLY_DROP) {
                             return Ok(());
                         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index 86d951060140..ff6c99ca53b3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -45,7 +45,7 @@ pub(super) fn detect_and_exec_special_function(
             return Ok(false);
         }
 
-        let function_data = self.db.function_signature(def);
+        let function_data = FunctionSignature::of(self.db, def);
         let attrs = AttrFlags::query(self.db, def.into());
         let is_intrinsic = FunctionSignature::is_intrinsic(self.db, def);
 
@@ -153,10 +153,7 @@ fn exec_clone(
                 };
                 let addr = Address::from_bytes(arg.get(self)?)?;
                 let InternedClosure(owner, _) = self.db.lookup_intern_closure(id.0);
-                let Some(closure_owner) = owner.as_def_with_body() else {
-                    not_supported!("closure in non-body context");
-                };
-                let infer = InferenceResult::for_body(self.db, closure_owner);
+                let infer = InferenceResult::of(self.db, owner);
                 let (captures, _) = infer.closure_info(id.0);
                 let layout = self.layout(self_ty)?;
                 let db = self.db;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
index 61dd7757c90b..6bf966c3ef1d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
@@ -1,4 +1,4 @@
-use hir_def::{HasModule, db::DefDatabase};
+use hir_def::{GenericDefId, HasModule, signatures::FunctionSignature};
 use hir_expand::EditionedFileId;
 use span::Edition;
 use syntax::{TextRange, TextSize};
@@ -25,7 +25,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String),
             .declarations()
             .find_map(|x| match x {
                 hir_def::ModuleDefId::FunctionId(x) => {
-                    if db.function_signature(x).name.display(db, Edition::CURRENT).to_string()
+                    if FunctionSignature::of(db, x).name.display(db, Edition::CURRENT).to_string()
                         == "main"
                     {
                         Some(x)
@@ -41,7 +41,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String),
                 func_id.into(),
                 GenericArgs::empty(interner).store(),
                 crate::ParamEnvAndCrate {
-                    param_env: db.trait_environment(func_id.into()),
+                    param_env: db.trait_environment(GenericDefId::from(func_id).into()),
                     krate: func_id.krate(db),
                 }
                 .store(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 269d8729baf3..8d85e2412f3b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -4,8 +4,8 @@
 
 use base_db::Crate;
 use hir_def::{
-    AdtId, DefWithBodyId, EnumVariantId, GeneralConstId, GenericParamId, HasModule,
-    ItemContainerId, LocalFieldId, Lookup, TraitId, TupleId,
+    AdtId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId, GeneralConstId, GenericParamId,
+    HasModule, ItemContainerId, LocalFieldId, Lookup, TraitId, TupleId,
     expr_store::{Body, ExpressionStore, HygieneId, path::Path},
     hir::{
         ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm,
@@ -14,6 +14,7 @@
     item_tree::FieldsShape,
     lang_item::LangItems,
     resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},
+    signatures::{ConstSignature, EnumSignature, FunctionSignature, StaticSignature},
 };
 use hir_expand::name::Name;
 use la_arena::ArenaMap;
@@ -185,7 +186,7 @@ pub fn pretty_print(
                 }
             }
             MirLowerError::MissingFunctionDefinition(owner, it) => {
-                let body = db.body(*owner);
+                let body = Body::of(db, *owner);
                 writeln!(
                     f,
                     "Missing function definition for {}",
@@ -307,7 +308,7 @@ fn new(
             closures: vec![],
         };
         let resolver = owner.resolver(db);
-        let env = db.trait_environment_for_body(owner);
+        let env = db.trait_environment(ExpressionStoreOwnerId::from(owner));
         let interner = DbInterner::new_with(db, resolver.krate());
         // FIXME(next-solver): Is `non_body_analysis()` correct here? Don't we want to reveal opaque types defined by this body?
         let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
@@ -472,7 +473,7 @@ fn lower_expr_to_place_without_adjust(
                 if let DefWithBodyId::FunctionId(f) = self.owner {
                     let assoc = f.lookup(self.db);
                     if let ItemContainerId::TraitId(t) = assoc.container {
-                        let name = &self.db.function_signature(f).name;
+                        let name = &FunctionSignature::of(self.db, f).name;
                         return Err(MirLowerError::TraitFunctionDefinition(t, name.clone()));
                     }
                 }
@@ -1993,7 +1994,7 @@ fn const_eval_discriminant(&self, variant: EnumVariantId) -> Result<'db, i128> {
                 let loc = variant.lookup(db);
                 let name = format!(
                     "{}::{}",
-                    self.db.enum_signature(loc.parent).name.display(db, edition),
+                    EnumSignature::of(db, loc.parent).name.display(db, edition),
                     loc.parent
                         .enum_variants(self.db)
                         .variant_name_by_id(variant)
@@ -2112,8 +2113,8 @@ pub fn mir_body_for_closure_query<'db>(
     let InternedClosure(owner, expr) = db.lookup_intern_closure(closure);
     let body_owner =
         owner.as_def_with_body().expect("MIR lowering should only happen for body-owned closures");
-    let body = db.body(body_owner);
-    let infer = InferenceResult::for_body(db, body_owner);
+    let body = Body::of(db, body_owner);
+    let infer = InferenceResult::of(db, body_owner);
     let Expr::Closure { args, body: root, .. } = &body[expr] else {
         implementation_error!("closure expression is not closure");
     };
@@ -2228,13 +2229,12 @@ pub fn mir_body_query<'db>(
     let edition = krate.data(db).edition;
     let detail = match def {
         DefWithBodyId::FunctionId(it) => {
-            db.function_signature(it).name.display(db, edition).to_string()
+            FunctionSignature::of(db, it).name.display(db, edition).to_string()
         }
         DefWithBodyId::StaticId(it) => {
-            db.static_signature(it).name.display(db, edition).to_string()
+            StaticSignature::of(db, it).name.display(db, edition).to_string()
         }
-        DefWithBodyId::ConstId(it) => db
-            .const_signature(it)
+        DefWithBodyId::ConstId(it) => ConstSignature::of(db, it)
             .name
             .clone()
             .unwrap_or_else(Name::missing)
@@ -2249,9 +2249,9 @@ pub fn mir_body_query<'db>(
         }
     };
     let _p = tracing::info_span!("mir_body_query", ?detail).entered();
-    let body = db.body(def);
-    let infer = InferenceResult::for_body(db, def);
-    let mut result = lower_body_to_mir(db, def, &body, infer, body.body_expr)?;
+    let body = Body::of(db, def);
+    let infer = InferenceResult::of(db, def);
+    let mut result = lower_body_to_mir(db, def, body, infer, body.body_expr)?;
     result.shrink_to_fit();
     Ok(Arc::new(result))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/pretty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/pretty.rs
index 96b90a3f4074..4b654a0fbe08 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/pretty.rs
@@ -6,7 +6,11 @@
 };
 
 use either::Either;
-use hir_def::{expr_store::Body, hir::BindingId};
+use hir_def::{
+    expr_store::Body,
+    hir::BindingId,
+    signatures::{ConstSignature, EnumSignature, FunctionSignature, StaticSignature},
+};
 use hir_expand::{Lookup, name::Name};
 use la_arena::ArenaMap;
 
@@ -38,19 +42,19 @@ macro_rules! wln {
 
 impl MirBody {
     pub fn pretty_print(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {
-        let hir_body = db.body(self.owner);
-        let mut ctx = MirPrettyCtx::new(self, &hir_body, db, display_target);
+        let hir_body = Body::of(db, self.owner);
+        let mut ctx = MirPrettyCtx::new(self, hir_body, db, display_target);
         ctx.for_body(|this| match ctx.body.owner {
             hir_def::DefWithBodyId::FunctionId(id) => {
-                let data = db.function_signature(id);
+                let data = FunctionSignature::of(db, id);
                 w!(this, "fn {}() ", data.name.display(db, this.display_target.edition));
             }
             hir_def::DefWithBodyId::StaticId(id) => {
-                let data = db.static_signature(id);
+                let data = StaticSignature::of(db, id);
                 w!(this, "static {}: _ = ", data.name.display(db, this.display_target.edition));
             }
             hir_def::DefWithBodyId::ConstId(id) => {
-                let data = db.const_signature(id);
+                let data = ConstSignature::of(db, id);
                 w!(
                     this,
                     "const {}: _ = ",
@@ -66,7 +70,7 @@ pub fn pretty_print(&self, db: &dyn HirDatabase, display_target: DisplayTarget)
                 w!(
                     this,
                     "enum {}::{} = ",
-                    db.enum_signature(loc.parent).name.display(db, edition),
+                    EnumSignature::of(db, loc.parent).name.display(db, edition),
                     loc.parent
                         .enum_variants(db)
                         .variant_name_by_id(id)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index f725af320db7..5d122ce446ad 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -2,8 +2,12 @@
 
 use hir_def::{
     AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,
-    EnumId, EnumVariantId, ExpressionStoreOwner, FunctionId, GeneralConstId, GenericDefId, ImplId,
-    StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    EnumId, EnumVariantId, ExpressionStoreOwnerId, FunctionId, GeneralConstId, GenericDefId,
+    ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    signatures::{
+        ConstSignature, EnumSignature, FunctionSignature, StaticSignature, StructSignature,
+        TraitSignature, TypeAliasSignature, UnionSignature,
+    },
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -42,32 +46,33 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let db = interner.db;
         match *self {
             SolverDefId::AdtId(AdtId::StructId(id)) => {
-                f.debug_tuple("AdtId").field(&db.struct_signature(id).name.as_str()).finish()
+                f.debug_tuple("AdtId").field(&StructSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::AdtId(AdtId::EnumId(id)) => {
-                f.debug_tuple("AdtId").field(&db.enum_signature(id).name.as_str()).finish()
+                f.debug_tuple("AdtId").field(&EnumSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::AdtId(AdtId::UnionId(id)) => {
-                f.debug_tuple("AdtId").field(&db.union_signature(id).name.as_str()).finish()
+                f.debug_tuple("AdtId").field(&UnionSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::ConstId(id) => f
                 .debug_tuple("ConstId")
-                .field(&db.const_signature(id).name.as_ref().map_or("_", |name| name.as_str()))
+                .field(&ConstSignature::of(db, id).name.as_ref().map_or("_", |name| name.as_str()))
+                .finish(),
+            SolverDefId::FunctionId(id) => f
+                .debug_tuple("FunctionId")
+                .field(&FunctionSignature::of(db, id).name.as_str())
                 .finish(),
-            SolverDefId::FunctionId(id) => {
-                f.debug_tuple("FunctionId").field(&db.function_signature(id).name.as_str()).finish()
-            }
             SolverDefId::ImplId(id) => f.debug_tuple("ImplId").field(&id).finish(),
             SolverDefId::BuiltinDeriveImplId(id) => f.debug_tuple("ImplId").field(&id).finish(),
             SolverDefId::StaticId(id) => {
-                f.debug_tuple("StaticId").field(&db.static_signature(id).name.as_str()).finish()
+                f.debug_tuple("StaticId").field(&StaticSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::TraitId(id) => {
-                f.debug_tuple("TraitId").field(&db.trait_signature(id).name.as_str()).finish()
+                f.debug_tuple("TraitId").field(&TraitSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::TypeAliasId(id) => f
                 .debug_tuple("TypeAliasId")
-                .field(&db.type_alias_signature(id).name.as_str())
+                .field(&TypeAliasSignature::of(db, id).name.as_str())
                 .finish(),
             SolverDefId::InternedClosureId(id) => {
                 f.debug_tuple("InternedClosureId").field(&id).finish()
@@ -83,21 +88,21 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 f.debug_tuple("EnumVariantId")
                     .field(&format_args!(
                         "\"{}::{}\"",
-                        db.enum_signature(parent_enum).name.as_str(),
+                        EnumSignature::of(db, parent_enum).name.as_str(),
                         parent_enum.enum_variants(db).variant_name_by_id(id).unwrap().as_str()
                     ))
                     .finish()
             }
             SolverDefId::AnonConstId(id) => f.debug_tuple("AnonConstId").field(&id).finish(),
             SolverDefId::Ctor(Ctor::Struct(id)) => {
-                f.debug_tuple("Ctor").field(&db.struct_signature(id).name.as_str()).finish()
+                f.debug_tuple("Ctor").field(&StructSignature::of(db, id).name.as_str()).finish()
             }
             SolverDefId::Ctor(Ctor::Enum(id)) => {
                 let parent_enum = id.loc(db).parent;
                 f.debug_tuple("Ctor")
                     .field(&format_args!(
                         "\"{}::{}\"",
-                        db.enum_signature(parent_enum).name.as_str(),
+                        EnumSignature::of(db, parent_enum).name.as_str(),
                         parent_enum.enum_variants(db).variant_name_by_id(id).unwrap().as_str()
                     ))
                     .finish()
@@ -138,15 +143,6 @@ fn from(value: GenericDefId) -> Self {
     }
 }
 
-impl From<ExpressionStoreOwner> for SolverDefId {
-    fn from(value: ExpressionStoreOwner) -> Self {
-        match value {
-            ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id.into(),
-            ExpressionStoreOwner::Body(def_with_body_id) => def_with_body_id.into(),
-        }
-    }
-}
-
 impl From<GeneralConstId> for SolverDefId {
     #[inline]
     fn from(value: GeneralConstId) -> Self {
@@ -170,6 +166,16 @@ fn from(value: DefWithBodyId) -> Self {
     }
 }
 
+impl From<ExpressionStoreOwnerId> for SolverDefId {
+    #[inline]
+    fn from(value: ExpressionStoreOwnerId) -> Self {
+        match value {
+            ExpressionStoreOwnerId::Body(body_id) => body_id.into(),
+            ExpressionStoreOwnerId::Signature(sig_id) => sig_id.into(),
+        }
+    }
+}
+
 impl TryFrom<SolverDefId> for AttrDefId {
     type Error = ();
     #[inline]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
index 8f798b4ade24..0e8218b33aaa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
@@ -617,6 +617,7 @@ pub fn to_debuggable_error(&self, infcx: &InferCtxt<'db>) -> FulfillmentError<'d
 }
 
 mod wf {
+    use hir_def::signatures::ImplSignature;
     use hir_def::{GeneralConstId, ItemContainerId};
     use rustc_type_ir::inherent::{
         AdtDef, BoundExistentialPredicates, GenericArgs as _, IntoKind, SliceLike, Term as _,
@@ -1054,7 +1055,7 @@ fn visit_const(&mut self, c: Const<'db>) -> Self::Result {
                         if let GeneralConstId::ConstId(uv_def) = uv.def.0
                             && let ItemContainerId::ImplId(impl_) =
                                 uv_def.loc(self.interner().db).container
-                            && self.interner().db.impl_signature(impl_).target_trait.is_none()
+                            && ImplSignature::of(self.interner().db, impl_).target_trait.is_none()
                         {
                             return; // Subtree is handled by above function
                         } else {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index dba4e74730f1..5b81c7675dbb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -10,11 +10,15 @@
 
 use base_db::Crate;
 use hir_def::{
-    AdtId, CallableDefId, DefWithBodyId, EnumVariantId, ExpressionStoreOwner, HasModule,
+    AdtId, CallableDefId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId, HasModule,
     ItemContainerId, StructId, UnionId, VariantId,
     attrs::AttrFlags,
+    expr_store::{Body, ExpressionStore},
     lang_item::LangItems,
-    signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags},
+    signatures::{
+        EnumSignature, FieldData, FnFlags, FunctionSignature, ImplFlags, ImplSignature,
+        StructFlags, StructSignature, TraitFlags, TraitSignature, UnionSignature,
+    },
 };
 use la_arena::Idx;
 use rustc_abi::{ReprFlags, ReprOptions};
@@ -548,7 +552,7 @@ pub fn new<'db>(def_id: AdtId, interner: DbInterner<'db>) -> Self {
         let db = interner.db();
         let (flags, variants, repr) = match def_id {
             AdtId::StructId(struct_id) => {
-                let data = db.struct_signature(struct_id);
+                let data = StructSignature::of(db, struct_id);
 
                 let flags = AdtFlags {
                     is_enum: false,
@@ -775,15 +779,15 @@ impl fmt::Debug for AdtDef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         crate::with_attached_db(|db| match self.inner().id {
             AdtId::StructId(struct_id) => {
-                let data = db.struct_signature(struct_id);
+                let data = StructSignature::of(db, struct_id);
                 f.write_str(data.name.as_str())
             }
             AdtId::UnionId(union_id) => {
-                let data = db.union_signature(union_id);
+                let data = UnionSignature::of(db, union_id);
                 f.write_str(data.name.as_str())
             }
             AdtId::EnumId(enum_id) => {
-                let data = db.enum_signature(enum_id);
+                let data = EnumSignature::of(db, enum_id);
                 f.write_str(data.name.as_str())
             }
         })
@@ -1231,7 +1235,7 @@ fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> AliasTyKind {
             SolverDefId::InternedOpaqueTyId(_) => AliasTyKind::Opaque,
             SolverDefId::TypeAliasId(type_alias) => match type_alias.loc(self.db).container {
                 ItemContainerId::ImplId(impl_)
-                    if self.db.impl_signature(impl_).target_trait.is_none() =>
+                    if ImplSignature::of(self.db, impl_).target_trait.is_none() =>
                 {
                     AliasTyKind::Inherent
                 }
@@ -1250,7 +1254,7 @@ fn alias_term_kind(
             SolverDefId::InternedOpaqueTyId(_) => AliasTermKind::OpaqueTy,
             SolverDefId::TypeAliasId(type_alias) => match type_alias.loc(self.db).container {
                 ItemContainerId::ImplId(impl_)
-                    if self.db.impl_signature(impl_).target_trait.is_none() =>
+                    if ImplSignature::of(self.db, impl_).target_trait.is_none() =>
                 {
                     AliasTermKind::InherentTy
                 }
@@ -1353,11 +1357,8 @@ fn coroutine_movability(self, def_id: Self::CoroutineId) -> rustc_ast_ir::Movabi
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let Some(body_owner) = owner.as_def_with_body() else {
-            return rustc_ast_ir::Movability::Static;
-        };
-        let body = self.db.body(body_owner);
-        let expr = &body[expr_id];
+        let store = ExpressionStore::of(self.db, owner);
+        let expr = &store[expr_id];
         match *expr {
             hir_def::hir::Expr::Closure { closure_kind, .. } => match closure_kind {
                 hir_def::hir::ClosureKind::Coroutine(movability) => match movability {
@@ -1929,7 +1930,7 @@ fn has_item_definition(self, _def_id: Self::DefId) -> bool {
 
     fn impl_is_default(self, impl_def_id: Self::ImplId) -> bool {
         match impl_def_id {
-            AnyImplId::ImplId(impl_id) => self.db.impl_signature(impl_id).is_default(),
+            AnyImplId::ImplId(impl_id) => ImplSignature::of(self.db, impl_id).is_default(),
             AnyImplId::BuiltinDeriveImplId(_) => false,
         }
     }
@@ -1956,7 +1957,7 @@ fn impl_polarity(self, impl_id: Self::ImplId) -> rustc_type_ir::ImplPolarity {
         let AnyImplId::ImplId(impl_id) = impl_id else {
             return ImplPolarity::Positive;
         };
-        let impl_data = self.db().impl_signature(impl_id);
+        let impl_data = ImplSignature::of(self.db(), impl_id);
         if impl_data.flags.contains(ImplFlags::NEGATIVE) {
             ImplPolarity::Negative
         } else {
@@ -1965,12 +1966,12 @@ fn impl_polarity(self, impl_id: Self::ImplId) -> rustc_type_ir::ImplPolarity {
     }
 
     fn trait_is_auto(self, trait_: Self::TraitId) -> bool {
-        let trait_data = self.db().trait_signature(trait_.0);
+        let trait_data = TraitSignature::of(self.db(), trait_.0);
         trait_data.flags.contains(TraitFlags::AUTO)
     }
 
     fn trait_is_alias(self, trait_: Self::TraitId) -> bool {
-        let trait_data = self.db().trait_signature(trait_.0);
+        let trait_data = TraitSignature::of(self.db(), trait_.0);
         trait_data.flags.contains(TraitFlags::ALIAS)
     }
 
@@ -1979,7 +1980,7 @@ fn trait_is_dyn_compatible(self, trait_: Self::TraitId) -> bool {
     }
 
     fn trait_is_fundamental(self, trait_: Self::TraitId) -> bool {
-        let trait_data = self.db().trait_signature(trait_.0);
+        let trait_data = TraitSignature::of(self.db(), trait_.0);
         trait_data.flags.contains(TraitFlags::FUNDAMENTAL)
     }
 
@@ -2002,12 +2003,9 @@ fn is_general_coroutine(self, def_id: Self::CoroutineId) -> bool {
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let Some(body_owner) = owner.as_def_with_body() else {
-            return false;
-        };
-        let body = self.db.body(body_owner);
+        let store = ExpressionStore::of(self.db, owner);
         matches!(
-            body[expr_id],
+            store[expr_id],
             hir_def::hir::Expr::Closure {
                 closure_kind: hir_def::hir::ClosureKind::Coroutine(_),
                 ..
@@ -2019,12 +2017,9 @@ fn coroutine_is_async(self, def_id: Self::CoroutineId) -> bool {
         // FIXME: Make this a query? I don't believe this can be accessed from bodies other than
         // the current infer query, except with revealed opaques - is it rare enough to not matter?
         let InternedCoroutine(owner, expr_id) = def_id.0.loc(self.db);
-        let Some(body_owner) = owner.as_def_with_body() else {
-            return false;
-        };
-        let body = self.db.body(body_owner);
+        let store = ExpressionStore::of(self.db, owner);
         matches!(
-            body[expr_id],
+            store[expr_id],
             hir_def::hir::Expr::Closure { closure_kind: hir_def::hir::ClosureKind::Async, .. }
                 | hir_def::hir::Expr::Async { .. }
         )
@@ -2145,7 +2140,7 @@ fn opaque_types_and_coroutines_defined_by(self, def_id: Self::LocalDefId) -> Sel
         crate::opaques::opaque_types_defined_by(self.db, def_id, &mut result);
 
         // Collect coroutines.
-        let body = self.db.body(def_id);
+        let body = Body::of(self.db, def_id);
         body.exprs().for_each(|(expr_id, expr)| {
             if matches!(
                 expr,
@@ -2158,7 +2153,7 @@ fn opaque_types_and_coroutines_defined_by(self, def_id: Self::LocalDefId) -> Sel
             ) {
                 let coroutine = InternedCoroutineId::new(
                     self.db,
-                    InternedCoroutine(ExpressionStoreOwner::Body(def_id), expr_id),
+                    InternedCoroutine(ExpressionStoreOwnerId::Body(def_id), expr_id),
                 );
                 result.push(coroutine.into());
             }
@@ -2188,7 +2183,7 @@ fn fn_is_const(self, id: Self::FunctionId) -> bool {
             CallableDefId::FunctionId(id) => id,
             _ => return false,
         };
-        self.db().function_signature(id).flags.contains(FnFlags::CONST)
+        FunctionSignature::of(self.db(), id).flags.contains(FnFlags::CONST)
     }
 
     fn impl_is_const(self, _def_id: Self::ImplId) -> bool {
@@ -2236,11 +2231,11 @@ fn is_default_trait(self, def_id: Self::TraitId) -> bool {
     }
 
     fn trait_is_coinductive(self, trait_: Self::TraitId) -> bool {
-        self.db().trait_signature(trait_.0).flags.contains(TraitFlags::COINDUCTIVE)
+        TraitSignature::of(self.db(), trait_.0).flags.contains(TraitFlags::COINDUCTIVE)
     }
 
     fn trait_is_unsafe(self, trait_: Self::TraitId) -> bool {
-        self.db().trait_signature(trait_.0).flags.contains(TraitFlags::UNSAFE)
+        TraitSignature::of(self.db(), trait_.0).flags.contains(TraitFlags::UNSAFE)
     }
 
     fn impl_self_is_guaranteed_unsized(self, _def_id: Self::ImplId) -> bool {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
index 65931549db02..e0732b347374 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
@@ -1,5 +1,6 @@
 //! Things related to IR printing in the next-trait-solver.
 
+use hir_def::signatures::{TraitSignature, TypeAliasSignature};
 use rustc_type_ir::{self as ty, ir_print::IrPrint};
 
 use super::SolverDefId;
@@ -14,7 +15,7 @@ fn print_debug(t: &ty::AliasTy<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std:
         crate::with_attached_db(|db| match t.def_id {
             SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
                 "AliasTy({:?}[{:?}])",
-                db.type_alias_signature(id).name.as_str(),
+                TypeAliasSignature::of(db, id).name.as_str(),
                 t.args
             )),
             SolverDefId::InternedOpaqueTyId(id) => {
@@ -34,7 +35,7 @@ fn print_debug(t: &ty::AliasTerm<Self>, fmt: &mut std::fmt::Formatter<'_>) -> st
         crate::with_attached_db(|db| match t.def_id {
             SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
                 "AliasTerm({:?}[{:?}])",
-                db.type_alias_signature(id).name.as_str(),
+                TypeAliasSignature::of(db, id).name.as_str(),
                 t.args
             )),
             SolverDefId::InternedOpaqueTyId(id) => {
@@ -58,13 +59,13 @@ fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std
                 fmt.write_str(&format!(
                     "{:?}: {}",
                     self_ty,
-                    db.trait_signature(trait_).name.as_str()
+                    TraitSignature::of(db, trait_).name.as_str()
                 ))
             } else {
                 fmt.write_str(&format!(
                     "{:?}: {}<{:?}>",
                     self_ty,
-                    db.trait_signature(trait_).name.as_str(),
+                    TraitSignature::of(db, trait_).name.as_str(),
                     trait_args
                 ))
             }
@@ -121,7 +122,7 @@ fn print_debug(
             let trait_ = t.def_id.0;
             fmt.write_str(&format!(
                 "ExistentialTraitRef({:?}[{:?}])",
-                db.trait_signature(trait_).name.as_str(),
+                TraitSignature::of(db, trait_).name.as_str(),
                 t.args
             ))
         })
@@ -146,7 +147,7 @@ fn print_debug(
             };
             fmt.write_str(&format!(
                 "ExistentialProjection(({:?}[{:?}]) -> {:?})",
-                db.type_alias_signature(id).name.as_str(),
+                TypeAliasSignature::of(db, id).name.as_str(),
                 t.args,
                 t.term
             ))
@@ -172,7 +173,7 @@ fn print_debug(
             };
             fmt.write_str(&format!(
                 "ProjectionPredicate(({:?}[{:?}]) -> {:?})",
-                db.type_alias_signature(id).name.as_str(),
+                TypeAliasSignature::of(db, id).name.as_str(),
                 t.projection_term.args,
                 t.term
             ))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 54baa8ac41ac..848bb110af2d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -1,6 +1,9 @@
 //! Defining `SolverContext` for next-trait-solver.
 
-use hir_def::{AssocItemId, GeneralConstId};
+use hir_def::{
+    AssocItemId, GeneralConstId,
+    signatures::{ConstSignature, TypeAliasSignature},
+};
 use rustc_next_trait_solver::delegate::SolverDelegate;
 use rustc_type_ir::{
     AliasTyKind, GenericArgKind, InferCtxtLike, Interner, PredicatePolarity, TypeFlags,
@@ -181,52 +184,53 @@ fn fetch_eligible_assoc_item(
             return Ok(None);
         };
         let impl_items = impl_id.impl_items(self.0.interner.db());
-        let id =
-            match trait_assoc_def_id {
-                SolverDefId::TypeAliasId(trait_assoc_id) => {
-                    let trait_assoc_data = self.0.interner.db.type_alias_signature(trait_assoc_id);
-                    impl_items
-                        .items
-                        .iter()
-                        .find_map(|(impl_assoc_name, impl_assoc_id)| {
-                            if let AssocItemId::TypeAliasId(impl_assoc_id) = *impl_assoc_id
-                                && *impl_assoc_name == trait_assoc_data.name
-                            {
-                                Some(impl_assoc_id)
-                            } else {
-                                None
-                            }
-                        })
-                        .or_else(|| {
-                            if trait_assoc_data.ty.is_some() { Some(trait_assoc_id) } else { None }
-                        })
-                        .map(SolverDefId::TypeAliasId)
-                }
-                SolverDefId::ConstId(trait_assoc_id) => {
-                    let trait_assoc_data = self.0.interner.db.const_signature(trait_assoc_id);
-                    let trait_assoc_name = trait_assoc_data
-                        .name
-                        .as_ref()
-                        .expect("unnamed consts should not get passed to the solver");
-                    impl_items
-                        .items
-                        .iter()
-                        .find_map(|(impl_assoc_name, impl_assoc_id)| {
-                            if let AssocItemId::ConstId(impl_assoc_id) = *impl_assoc_id
-                                && impl_assoc_name == trait_assoc_name
-                            {
-                                Some(impl_assoc_id)
-                            } else {
-                                None
-                            }
-                        })
-                        .or_else(|| {
+        let id = match trait_assoc_def_id {
+            SolverDefId::TypeAliasId(trait_assoc_id) => {
+                let trait_assoc_data = TypeAliasSignature::of(self.0.interner.db, trait_assoc_id);
+                impl_items
+                    .items
+                    .iter()
+                    .find_map(|(impl_assoc_name, impl_assoc_id)| {
+                        if let AssocItemId::TypeAliasId(impl_assoc_id) = *impl_assoc_id
+                            && *impl_assoc_name == trait_assoc_data.name
+                        {
+                            Some(impl_assoc_id)
+                        } else {
+                            None
+                        }
+                    })
+                    .or_else(|| {
+                        if trait_assoc_data.ty.is_some() { Some(trait_assoc_id) } else { None }
+                    })
+                    .map(SolverDefId::TypeAliasId)
+            }
+            SolverDefId::ConstId(trait_assoc_id) => {
+                let trait_assoc_data = ConstSignature::of(self.0.interner.db, trait_assoc_id);
+                let trait_assoc_name = trait_assoc_data
+                    .name
+                    .as_ref()
+                    .expect("unnamed consts should not get passed to the solver");
+                impl_items
+                    .items
+                    .iter()
+                    .find_map(|(impl_assoc_name, impl_assoc_id)| {
+                        if let AssocItemId::ConstId(impl_assoc_id) = *impl_assoc_id
+                            && impl_assoc_name == trait_assoc_name
+                        {
+                            Some(impl_assoc_id)
+                        } else {
+                            None
+                        }
+                    })
+                    .or_else(
+                        || {
                             if trait_assoc_data.has_body() { Some(trait_assoc_id) } else { None }
-                        })
-                        .map(SolverDefId::ConstId)
-                }
-                _ => panic!("Unexpected SolverDefId"),
-            };
+                        },
+                    )
+                    .map(SolverDefId::ConstId)
+            }
+            _ => panic!("Unexpected SolverDefId"),
+        };
         Ok(id)
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/opaques.rs b/src/tools/rust-analyzer/crates/hir-ty/src/opaques.rs
index 27ae5e39d55b..ce93a334221c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/opaques.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/opaques.rs
@@ -1,7 +1,8 @@
 //! Handling of opaque types, detection of defining scope and hidden type.
 
 use hir_def::{
-    AssocItemId, AssocItemLoc, DefWithBodyId, FunctionId, HasModule, ItemContainerId, TypeAliasId,
+    AssocItemId, AssocItemLoc, DefWithBodyId, ExpressionStoreOwnerId, FunctionId, GenericDefId,
+    HasModule, ItemContainerId, TypeAliasId, signatures::ImplSignature,
 };
 use hir_expand::name::Name;
 use la_arena::ArenaMap;
@@ -55,7 +56,7 @@ pub(crate) fn opaque_types_defined_by(
     };
     let extend_with_atpit_from_container = |container| match container {
         ItemContainerId::ImplId(impl_id) => {
-            if db.impl_signature(impl_id).target_trait.is_some() {
+            if ImplSignature::of(db, impl_id).target_trait.is_some() {
                 extend_with_atpit_from_assoc_items(&impl_id.impl_items(db).items);
             }
         }
@@ -94,7 +95,7 @@ pub(crate) fn rpit_hidden_types<'db>(
     db: &'db dyn HirDatabase,
     function: FunctionId,
 ) -> ArenaMap<ImplTraitIdx, StoredEarlyBinder<StoredTy>> {
-    let infer = InferenceResult::for_body(db, function.into());
+    let infer = InferenceResult::of(db, DefWithBodyId::from(function));
     let mut result = ArenaMap::new();
     for (opaque, hidden_type) in infer.return_position_impl_trait_types(db) {
         result.insert(opaque, StoredEarlyBinder::bind(hidden_type.store()));
@@ -122,13 +123,14 @@ pub(crate) fn tait_hidden_types<'db>(
     let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
     let mut ocx = ObligationCtxt::new(&infcx);
     let cause = ObligationCause::dummy();
-    let param_env = db.trait_environment(type_alias.into());
+    let param_env =
+        db.trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(type_alias)));
 
     let defining_bodies = tait_defining_bodies(db, &loc);
 
     let mut result = ArenaMap::with_capacity(taits_count);
     for defining_body in defining_bodies {
-        let infer = InferenceResult::for_body(db, defining_body);
+        let infer = InferenceResult::of(db, defining_body);
         for (&opaque, hidden_type) in &infer.type_of_opaque {
             let ImplTraitId::TypeAliasImplTrait(opaque_owner, opaque_idx) = opaque.loc(db) else {
                 continue;
@@ -195,7 +197,7 @@ fn tait_defining_bodies(
     };
     match loc.container {
         ItemContainerId::ImplId(impl_id) => {
-            if db.impl_signature(impl_id).target_trait.is_some() {
+            if ImplSignature::of(db, impl_id).target_trait.is_some() {
                 return from_assoc_items(&impl_id.impl_items(db).items);
             }
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/specialization.rs b/src/tools/rust-analyzer/crates/hir-ty/src/specialization.rs
index d97a35549ca4..90cbcfea6abe 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/specialization.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/specialization.rs
@@ -1,6 +1,9 @@
 //! Impl specialization related things
 
-use hir_def::{HasModule, ImplId, nameres::crate_def_map};
+use hir_def::{
+    ExpressionStoreOwnerId, GenericDefId, HasModule, ImplId, nameres::crate_def_map,
+    signatures::ImplSignature,
+};
 use intern::sym;
 use tracing::debug;
 
@@ -45,11 +48,13 @@ fn specializes_query(
     specializing_impl_def_id: ImplId,
     parent_impl_def_id: ImplId,
 ) -> bool {
-    let trait_env = db.trait_environment(specializing_impl_def_id.into());
+    let trait_env = db.trait_environment(ExpressionStoreOwnerId::from(GenericDefId::from(
+        specializing_impl_def_id,
+    )));
     let interner = DbInterner::new_with(db, specializing_impl_def_id.krate(db));
 
-    let specializing_impl_signature = db.impl_signature(specializing_impl_def_id);
-    let parent_impl_signature = db.impl_signature(parent_impl_def_id);
+    let specializing_impl_signature = ImplSignature::of(db, specializing_impl_def_id);
+    let parent_impl_signature = ImplSignature::of(db, parent_impl_def_id);
 
     // We determine whether there's a subset relationship by:
     //
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index 042f0568f3d8..430a570444d8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -18,7 +18,6 @@
 use hir_def::{
     AssocItemId, DefWithBodyId, GenericDefId, HasModule, Lookup, ModuleDefId, ModuleId,
     SyntheticSyntax,
-    db::DefDatabase,
     expr_store::{Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap},
     hir::{ExprId, Pat, PatId},
     item_scope::ItemScope,
@@ -146,15 +145,15 @@ fn check_impl(
         let mut unexpected_type_mismatches = String::new();
         for (def, krate) in defs {
             let display_target = DisplayTarget::from_crate(&db, krate);
-            let (body, body_source_map) = db.body_with_source_map(def);
-            let inference_result = InferenceResult::for_body(&db, def);
+            let (body, body_source_map) = Body::with_source_map(&db, def);
+            let inference_result = InferenceResult::of(&db, def);
 
             for (pat, ty) in inference_result.type_of_pat.iter() {
                 let mut ty = ty.as_ref();
                 if let Pat::Bind { id, .. } = body[pat] {
                     ty = inference_result.type_of_binding[id].as_ref();
                 }
-                let node = match pat_node(&body_source_map, pat, &db) {
+                let node = match pat_node(body_source_map, pat, &db) {
                     Some(value) => value,
                     None => continue,
                 };
@@ -171,7 +170,7 @@ fn check_impl(
 
             for (expr, ty) in inference_result.type_of_expr.iter() {
                 let ty = ty.as_ref();
-                let node = match expr_node(&body_source_map, expr, &db) {
+                let node = match expr_node(body_source_map, expr, &db) {
                     Some(value) => value,
                     None => continue,
                 };
@@ -202,9 +201,9 @@ fn check_impl(
             for (expr_or_pat, mismatch) in inference_result.type_mismatches() {
                 let Some(node) = (match expr_or_pat {
                     hir_def::hir::ExprOrPatId::ExprId(expr) => {
-                        expr_node(&body_source_map, expr, &db)
+                        expr_node(body_source_map, expr, &db)
                     }
-                    hir_def::hir::ExprOrPatId::PatId(pat) => pat_node(&body_source_map, pat, &db),
+                    hir_def::hir::ExprOrPatId::PatId(pat) => pat_node(body_source_map, pat, &db),
                 }) else {
                     continue;
                 };
@@ -223,7 +222,7 @@ fn check_impl(
             }
 
             for (type_ref, ty) in inference_result.placeholder_types() {
-                let node = match type_node(&body_source_map, type_ref, &db) {
+                let node = match type_node(body_source_map, type_ref, &db) {
                     Some(value) => value,
                     None => continue,
                 };
@@ -487,22 +486,22 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             }
         });
         for (def, krate) in defs {
-            let (body, source_map) = db.body_with_source_map(def);
-            let infer = InferenceResult::for_body(&db, def);
+            let (body, source_map) = Body::with_source_map(&db, def);
+            let infer = InferenceResult::of(&db, def);
             let self_param = body.self_param.map(|id| (id, source_map.self_param_syntax()));
-            infer_def(infer, &body, &source_map, self_param, krate);
+            infer_def(infer, body, source_map, self_param, krate);
         }
 
         // Also infer signature const expressions (array lengths, const generic args, etc.)
         generic_defs.dedup();
         for (def, krate) in generic_defs {
-            let (_, store, source_map) = db.generic_params_and_store_and_source_map(def);
+            let (store, source_map) = ExpressionStore::with_source_map(&db, def.into());
             // Skip if there are no const expressions in the signature
             if store.const_expr_origins().is_empty() {
                 continue;
             }
-            let infer = InferenceResult::for_signature(&db, def);
-            infer_def(infer, &store, &source_map, None, krate);
+            let infer = InferenceResult::of(&db, def);
+            infer_def(infer, store, source_map, None, krate);
         }
 
         buf.truncate(buf.trim_end().len());
@@ -522,14 +521,14 @@ pub(crate) fn visit_module(
         for &(_, item) in impl_data.items.iter() {
             match item {
                 AssocItemId::FunctionId(it) => {
-                    let body = db.body(it.into());
+                    let body = Body::of(db, it.into());
                     cb(it.into());
-                    visit_body(db, &body, cb);
+                    visit_body(db, body, cb);
                 }
                 AssocItemId::ConstId(it) => {
-                    let body = db.body(it.into());
+                    let body = Body::of(db, it.into());
                     cb(it.into());
-                    visit_body(db, &body, cb);
+                    visit_body(db, body, cb);
                 }
                 AssocItemId::TypeAliasId(it) => {
                     cb(it.into());
@@ -548,22 +547,22 @@ fn visit_scope(
             cb(decl);
             match decl {
                 ModuleDefId::FunctionId(it) => {
-                    let body = db.body(it.into());
-                    visit_body(db, &body, cb);
+                    let body = Body::of(db, it.into());
+                    visit_body(db, body, cb);
                 }
                 ModuleDefId::ConstId(it) => {
-                    let body = db.body(it.into());
-                    visit_body(db, &body, cb);
+                    let body = Body::of(db, it.into());
+                    visit_body(db, body, cb);
                 }
                 ModuleDefId::StaticId(it) => {
-                    let body = db.body(it.into());
-                    visit_body(db, &body, cb);
+                    let body = Body::of(db, it.into());
+                    visit_body(db, body, cb);
                 }
                 ModuleDefId::AdtId(hir_def::AdtId::EnumId(it)) => {
                     it.enum_variants(db).variants.iter().for_each(|&(it, _, _)| {
-                        let body = db.body(it.into());
+                        let body = Body::of(db, it.into());
                         cb(it.into());
-                        visit_body(db, &body, cb);
+                        visit_body(db, body, cb);
                     });
                 }
                 ModuleDefId::TraitId(it) => {
@@ -653,16 +652,14 @@ fn main() {
         let module = db.module_for_file(pos.file_id.file_id(&db));
         let crate_def_map = module.def_map(&db);
         visit_module(&db, crate_def_map, module, &mut |def| {
-            InferenceResult::for_body(
-                &db,
-                match def {
-                    ModuleDefId::FunctionId(it) => it.into(),
-                    ModuleDefId::EnumVariantId(it) => it.into(),
-                    ModuleDefId::ConstId(it) => it.into(),
-                    ModuleDefId::StaticId(it) => it.into(),
-                    _ => return,
-                },
-            );
+            let body_def: DefWithBodyId = match def {
+                ModuleDefId::FunctionId(it) => it.into(),
+                ModuleDefId::EnumVariantId(it) => it.into(),
+                ModuleDefId::ConstId(it) => it.into(),
+                ModuleDefId::StaticId(it) => it.into(),
+                _ => return,
+            };
+            InferenceResult::of(&db, body_def);
         });
     });
 
@@ -697,16 +694,14 @@ fn main() {
         let module = db.module_for_file(pos.file_id.file_id(&db));
         let crate_def_map = module.def_map(&db);
         visit_module(&db, crate_def_map, module, &mut |def| {
-            InferenceResult::for_body(
-                &db,
-                match def {
-                    ModuleDefId::FunctionId(it) => it.into(),
-                    ModuleDefId::EnumVariantId(it) => it.into(),
-                    ModuleDefId::ConstId(it) => it.into(),
-                    ModuleDefId::StaticId(it) => it.into(),
-                    _ => return,
-                },
-            );
+            let body_def: DefWithBodyId = match def {
+                ModuleDefId::FunctionId(it) => it.into(),
+                ModuleDefId::EnumVariantId(it) => it.into(),
+                ModuleDefId::ConstId(it) => it.into(),
+                ModuleDefId::StaticId(it) => it.into(),
+                _ => return,
+            };
+            InferenceResult::of(&db, body_def);
         });
     })
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
index 6e55641e56f2..9e687568216d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
@@ -1,5 +1,8 @@
 use expect_test::{Expect, expect};
-use hir_def::db::DefDatabase;
+use hir_def::{
+    DefWithBodyId,
+    expr_store::{Body, ExpressionStore},
+};
 use hir_expand::{HirFileId, files::InFileWrapper};
 use itertools::Itertools;
 use span::TextRange;
@@ -28,20 +31,20 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
 
         let mut captures_info = Vec::new();
         for def in defs {
-            let def = match def {
+            let def: DefWithBodyId = match def {
                 hir_def::ModuleDefId::FunctionId(it) => it.into(),
                 hir_def::ModuleDefId::EnumVariantId(it) => it.into(),
                 hir_def::ModuleDefId::ConstId(it) => it.into(),
                 hir_def::ModuleDefId::StaticId(it) => it.into(),
                 _ => continue,
             };
-            let infer = InferenceResult::for_body(&db, def);
+            let infer = InferenceResult::of(&db, def);
             let db = &db;
             captures_info.extend(infer.closure_info.iter().flat_map(
                 |(closure_id, (captures, _))| {
                     let closure = db.lookup_intern_closure(*closure_id);
-                    let body_owner = closure.0.as_def_with_body().unwrap();
-                    let source_map = db.body_with_source_map(body_owner).1;
+                    let body_owner = closure.0;
+                    let source_map = ExpressionStore::with_source_map(db, body_owner).1;
                     let closure_text_range = source_map
                         .expr_syntax(closure.1)
                         .expect("failed to map closure to SyntaxNode")
@@ -57,7 +60,8 @@ fn text_range<N: AstNode>(
                         }
 
                         // FIXME: Deduplicate this with hir::Local::sources().
-                        let (body, source_map) = db.body_with_source_map(body_owner);
+                        let (body, source_map) =
+                            Body::with_source_map(db, body_owner.as_def_with_body().unwrap());
                         let local_text_range =
                             match body.self_param.zip(source_map.self_param_syntax()) {
                                 Some((param, source)) if param == capture.local() => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index 0fbf8acf530f..3e8089c9c13e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -24,7 +24,7 @@ fn foo() -> i32 {
             let crate_def_map = module.def_map(&db);
             visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
-                    InferenceResult::for_body(&db, it.into());
+                    InferenceResult::of(&db, DefWithBodyId::from(it));
                 }
             });
         },
@@ -38,17 +38,17 @@ fn foo() -> i32 {
                 "parse_shim",
                 "real_span_map_shim",
                 "InferenceResult::for_body_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "trait_environment_query",
                 "lang_items",
                 "crate_lang_items",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
+                "ExprScopes::body_expr_scopes_",
             ]
         "#]],
     );
@@ -69,7 +69,7 @@ fn foo() -> i32 {
             let crate_def_map = module.def_map(&db);
             visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
-                    InferenceResult::for_body(&db, it.into());
+                    InferenceResult::of(&db, DefWithBodyId::from(it));
                 }
             });
         },
@@ -81,10 +81,10 @@ fn foo() -> i32 {
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "AttrFlags::query_",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
+                "FunctionSignature::with_source_map_",
+                "FunctionSignature::of_",
+                "Body::with_source_map_",
+                "Body::of_",
             ]
         "#]],
     );
@@ -112,7 +112,7 @@ fn baz() -> i32 {
             let crate_def_map = module.def_map(&db);
             visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
-                    InferenceResult::for_body(&db, it.into());
+                    InferenceResult::of(&db, DefWithBodyId::from(it));
                 }
             });
         },
@@ -126,37 +126,37 @@ fn baz() -> i32 {
                 "parse_shim",
                 "real_span_map_shim",
                 "InferenceResult::for_body_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "trait_environment_query",
                 "lang_items",
                 "crate_lang_items",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
+                "ExprScopes::body_expr_scopes_",
                 "InferenceResult::for_body_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
+                "ExprScopes::body_expr_scopes_",
                 "InferenceResult::for_body_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
+                "ExprScopes::body_expr_scopes_",
             ]
         "#]],
     );
@@ -182,7 +182,7 @@ fn baz() -> i32 {
             let crate_def_map = module.def_map(&db);
             visit_module(&db, crate_def_map, module, &mut |def| {
                 if let ModuleDefId::FunctionId(it) = def {
-                    InferenceResult::for_body(&db, it.into());
+                    InferenceResult::of(&db, DefWithBodyId::from(it));
                 }
             });
         },
@@ -194,22 +194,22 @@ fn baz() -> i32 {
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "AttrFlags::query_",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
+                "FunctionSignature::with_source_map_",
+                "FunctionSignature::of_",
+                "Body::with_source_map_",
+                "Body::of_",
                 "AttrFlags::query_",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
+                "FunctionSignature::with_source_map_",
+                "FunctionSignature::of_",
+                "Body::with_source_map_",
+                "Body::of_",
                 "InferenceResult::for_body_",
-                "body_expr_scopes_shim",
+                "ExprScopes::body_expr_scopes_",
                 "AttrFlags::query_",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
+                "FunctionSignature::with_source_map_",
+                "FunctionSignature::of_",
+                "Body::with_source_map_",
+                "Body::of_",
             ]
         "#]],
     );
@@ -562,7 +562,7 @@ fn main() {
             });
 
             for def in defs {
-                let _inference_result = InferenceResult::for_body(&db, def);
+                let _inference_result = InferenceResult::of(&db, def);
             }
         },
         &[("trait_solve_shim", 0)],
@@ -575,19 +575,19 @@ fn main() {
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitItems::query_with_diagnostics_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "AttrFlags::query_",
                 "ImplItems::of_",
                 "InferenceResult::for_body_",
-                "trait_signature_shim",
-                "trait_signature_with_source_map_shim",
+                "TraitSignature::of_",
+                "TraitSignature::with_source_map_",
                 "AttrFlags::query_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
-                "body_with_source_map_shim",
+                "Body::of_",
+                "Body::with_source_map_",
                 "trait_environment_query",
                 "lang_items",
                 "crate_lang_items",
@@ -595,14 +595,14 @@ fn main() {
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
                 "InferenceResult::for_body_",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::of_",
+                "FunctionSignature::with_source_map_",
                 "trait_environment_query",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
-                "struct_signature_shim",
-                "struct_signature_with_source_map_shim",
+                "ExprScopes::body_expr_scopes_",
+                "StructSignature::of_",
+                "StructSignature::with_source_map_",
                 "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "value_ty_query",
@@ -611,8 +611,8 @@ fn main() {
                 "TraitImpls::for_crate_and_deps_",
                 "TraitImpls::for_crate_",
                 "impl_trait_with_diagnostics_query",
-                "impl_signature_shim",
-                "impl_signature_with_source_map_shim",
+                "ImplSignature::of_",
+                "ImplSignature::with_source_map_",
                 "impl_self_ty_with_diagnostics_query",
                 "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
@@ -658,7 +658,7 @@ fn main() {
             });
 
             for def in defs {
-                let _inference_result = InferenceResult::for_body(&db, def);
+                let _inference_result = InferenceResult::of(&db, def);
             }
         },
         &[("trait_solve_shim", 0)],
@@ -670,35 +670,35 @@ fn main() {
                 "real_span_map_shim",
                 "crate_local_def_map",
                 "TraitItems::query_with_diagnostics_",
-                "body_with_source_map_shim",
+                "Body::with_source_map_",
                 "AttrFlags::query_",
-                "body_shim",
+                "Body::of_",
                 "ImplItems::of_",
                 "InferenceResult::for_body_",
                 "AttrFlags::query_",
-                "trait_signature_with_source_map_shim",
+                "TraitSignature::with_source_map_",
                 "AttrFlags::query_",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
+                "FunctionSignature::with_source_map_",
+                "FunctionSignature::of_",
+                "Body::with_source_map_",
+                "Body::of_",
                 "crate_lang_items",
                 "GenericPredicates::query_with_diagnostics_",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
                 "InferenceResult::for_body_",
-                "function_signature_with_source_map_shim",
+                "FunctionSignature::with_source_map_",
                 "GenericPredicates::query_with_diagnostics_",
                 "ImplTraits::return_type_impl_traits_",
-                "body_expr_scopes_shim",
-                "struct_signature_with_source_map_shim",
+                "ExprScopes::body_expr_scopes_",
+                "StructSignature::with_source_map_",
                 "AttrFlags::query_",
                 "GenericPredicates::query_with_diagnostics_",
                 "InherentImpls::for_crate_",
                 "callable_item_signature_query",
                 "TraitImpls::for_crate_",
-                "impl_signature_with_source_map_shim",
-                "impl_signature_shim",
+                "ImplSignature::with_source_map_",
+                "ImplSignature::of_",
                 "impl_trait_with_diagnostics_query",
                 "impl_self_ty_with_diagnostics_query",
                 "AttrFlags::query_",
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index fb598fe5acb0..878696c72129 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -7,7 +7,11 @@
     AdtId, AssocItemId, HasModule, ImplId, Lookup, TraitId,
     lang_item::LangItems,
     nameres::DefMap,
-    signatures::{ConstFlags, EnumFlags, FnFlags, StructFlags, TraitFlags, TypeAliasFlags},
+    signatures::{
+        ConstFlags, ConstSignature, EnumFlags, EnumSignature, FnFlags, FunctionSignature,
+        StructFlags, StructSignature, TraitFlags, TraitSignature, TypeAliasFlags,
+        TypeAliasSignature, UnionSignature,
+    },
 };
 use hir_expand::name::Name;
 use intern::sym;
@@ -279,21 +283,18 @@ pub fn is_inherent_impl_coherent(db: &dyn HirDatabase, def_map: &DefMap, impl_id
             | TyKind::Float(_) => true,
 
             TyKind::Adt(adt_def, _) => match adt_def.def_id().0 {
-                hir_def::AdtId::StructId(id) => db
-                    .struct_signature(id)
+                hir_def::AdtId::StructId(id) => StructSignature::of(db, id)
                     .flags
                     .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
-                hir_def::AdtId::UnionId(id) => db
-                    .union_signature(id)
+                hir_def::AdtId::UnionId(id) => UnionSignature::of(db, id)
                     .flags
                     .contains(StructFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
-                hir_def::AdtId::EnumId(it) => db
-                    .enum_signature(it)
+                hir_def::AdtId::EnumId(it) => EnumSignature::of(db, it)
                     .flags
                     .contains(EnumFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS),
             },
             TyKind::Dynamic(it, _) => it.principal_def_id().is_some_and(|trait_id| {
-                db.trait_signature(trait_id.0)
+                TraitSignature::of(db, trait_id.0)
                     .flags
                     .contains(TraitFlags::RUSTC_HAS_INCOHERENT_INHERENT_IMPLS)
             }),
@@ -304,14 +305,13 @@ pub fn is_inherent_impl_coherent(db: &dyn HirDatabase, def_map: &DefMap, impl_id
         rustc_has_incoherent_inherent_impls
             && !items.items.is_empty()
             && items.items.iter().all(|&(_, assoc)| match assoc {
-                AssocItemId::FunctionId(it) => {
-                    db.function_signature(it).flags.contains(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPL)
-                }
-                AssocItemId::ConstId(it) => {
-                    db.const_signature(it).flags.contains(ConstFlags::RUSTC_ALLOW_INCOHERENT_IMPL)
-                }
-                AssocItemId::TypeAliasId(it) => db
-                    .type_alias_signature(it)
+                AssocItemId::FunctionId(it) => FunctionSignature::of(db, it)
+                    .flags
+                    .contains(FnFlags::RUSTC_ALLOW_INCOHERENT_IMPL),
+                AssocItemId::ConstId(it) => ConstSignature::of(db, it)
+                    .flags
+                    .contains(ConstFlags::RUSTC_ALLOW_INCOHERENT_IMPL),
+                AssocItemId::TypeAliasId(it) => TypeAliasSignature::of(db, it)
                     .flags
                     .contains(TypeAliasFlags::RUSTC_ALLOW_INCOHERENT_IMPL),
             })
@@ -350,7 +350,7 @@ pub fn check_orphan_rules<'db>(db: &'db dyn HirDatabase, impl_: ImplId) -> bool
                     let AdtId::StructId(s) = adt_def.def_id().0 else {
                         break ty;
                     };
-                    let struct_signature = db.struct_signature(s);
+                    let struct_signature = StructSignature::of(db, s);
                     if struct_signature.flags.contains(StructFlags::FUNDAMENTAL) {
                         let next = subs.types().next();
                         match next {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs b/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
index ee864ab068d2..d19fbbc18793 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
@@ -44,10 +44,10 @@ pub fn upvars_mentioned(
     db: &dyn HirDatabase,
     owner: DefWithBodyId,
 ) -> Option<Box<FxHashMap<ExprId, Upvars>>> {
-    let body = db.body(owner);
+    let body = Body::of(db, owner);
     let mut resolver = owner.resolver(db);
     let mut result = FxHashMap::default();
-    handle_expr_outside_closure(db, &mut resolver, owner, &body, body.body_expr, &mut result);
+    handle_expr_outside_closure(db, &mut resolver, owner, body, body.body_expr, &mut result);
     return if result.is_empty() {
         None
     } else {
@@ -198,7 +198,7 @@ fn resolve_maybe_upvar<'db>(
 #[cfg(test)]
 mod tests {
     use expect_test::{Expect, expect};
-    use hir_def::{ModuleDefId, db::DefDatabase, nameres::crate_def_map};
+    use hir_def::{ModuleDefId, expr_store::Body, nameres::crate_def_map};
     use itertools::Itertools;
     use span::Edition;
     use test_fixture::WithFixture;
@@ -219,7 +219,7 @@ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expectation: Expect) {
                 })
                 .exactly_one()
                 .unwrap_or_else(|_| panic!("expected one function"));
-            let (body, source_map) = db.body_with_source_map(func.into());
+            let (body, source_map) = Body::with_source_map(&db, func.into());
             let Some(upvars) = upvars_mentioned(&db, func.into()) else {
                 expectation.assert_eq("");
                 return;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index be64f55ea550..509109543cd6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -4,6 +4,7 @@
 use base_db::target::{self, TargetData};
 use hir_def::{
     EnumId, EnumVariantId, FunctionId, Lookup, TraitId, attrs::AttrFlags, lang_item::LangItems,
+    signatures::FunctionSignature,
 };
 use intern::sym;
 use rustc_abi::TargetDataLayout;
@@ -79,7 +80,7 @@ pub fn is_fn_unsafe_to_call(
     call_edition: Edition,
     target_feature_is_safe: TargetFeatureIsSafeInTarget,
 ) -> Unsafety {
-    let data = db.function_signature(func);
+    let data = FunctionSignature::of(db, func);
     if data.is_unsafe() {
         return Unsafety::Unsafe;
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index 6f415a5289c9..1945b04bb3cc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -13,7 +13,10 @@
 //! by the next salsa version. If not, we will likely have to adapt and go with the rustc approach
 //! while installing firewall per item queries to prevent invalidation issues.
 
-use hir_def::{AdtId, GenericDefId, GenericParamId, VariantId, signatures::StructFlags};
+use hir_def::{
+    AdtId, GenericDefId, GenericParamId, VariantId,
+    signatures::{StructFlags, StructSignature},
+};
 use rustc_ast_ir::Mutability;
 use rustc_type_ir::{
     Variance,
@@ -45,7 +48,7 @@ fn variances_of_query(db: &dyn HirDatabase, def: GenericDefId) -> StoredVariance
         GenericDefId::FunctionId(_) => (),
         GenericDefId::AdtId(adt) => {
             if let AdtId::StructId(id) = adt {
-                let flags = &db.struct_signature(id).flags;
+                let flags = &StructSignature::of(db, id).flags;
                 let types = || crate::next_solver::default_types(db);
                 if flags.contains(StructFlags::IS_UNSAFE_CELL) {
                     return types().one_invariant.store();
@@ -113,7 +116,7 @@ pub(crate) fn variances_of_cycle_initial(
 
 struct Context<'db> {
     db: &'db dyn HirDatabase,
-    generics: Generics,
+    generics: Generics<'db>,
     variances: Box<[Variance]>,
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index 91fdcb8e6369..826b8d5f808c 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -4,10 +4,13 @@
 use hir_def::{
     AdtId, BuiltinDeriveImplId, FunctionId, GenericDefId, ImplId, ItemContainerId,
     builtin_derive::BuiltinDeriveImplMethod,
-    expr_store::ExpressionStore,
+    expr_store::{Body, ExpressionStore},
     hir::generics::{GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate},
     item_tree::FieldsShape,
-    signatures::{StaticFlags, TraitFlags},
+    signatures::{
+        ConstSignature, FunctionSignature, ImplSignature, StaticFlags, StaticSignature, TraitFlags,
+        TraitSignature, TypeAliasSignature,
+    },
     type_ref::{TypeBound, TypeRef, TypeRefId},
 };
 use hir_expand::name::Name;
@@ -38,7 +41,7 @@ fn write_builtin_derive_impl_method<'db>(
 ) -> Result {
     let db = f.db;
     let loc = impl_.loc(db);
-    let (adt_params, _adt_params_store) = db.generic_params_and_store(loc.adt.into());
+    let (adt_params, _adt_params_store) = GenericParams::of(db, loc.adt.into());
 
     if f.show_container_bounds() && !adt_params.is_empty() {
         f.write_str("impl")?;
@@ -94,22 +97,22 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         // Write container (trait or impl)
         let container_params = match container {
             ItemContainerId::TraitId(trait_) => {
-                let (params, params_store) = f.db.generic_params_and_store(trait_.into());
+                let (params, params_store) = GenericParams::of(f.db, trait_.into());
                 if f.show_container_bounds() && !params.is_empty() {
                     write_trait_header(trait_.into(), f)?;
                     f.write_char('\n')?;
-                    has_disaplayable_predicates(f.db, &params, &params_store)
+                    has_disaplayable_predicates(f.db, &params, params_store)
                         .then_some((params, params_store))
                 } else {
                     None
                 }
             }
             ItemContainerId::ImplId(impl_) => {
-                let (params, params_store) = f.db.generic_params_and_store(impl_.into());
+                let (params, params_store) = GenericParams::of(f.db, impl_.into());
                 if f.show_container_bounds() && !params.is_empty() {
                     write_impl_header(impl_, f)?;
                     f.write_char('\n')?;
-                    has_disaplayable_predicates(f.db, &params, &params_store)
+                    has_disaplayable_predicates(f.db, &params, params_store)
                         .then_some((params, params_store))
                 } else {
                     None
@@ -131,7 +134,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 _ => unreachable!(),
             };
             write!(f, "\n    // Bounds from {container_name}:",)?;
-            write_where_predicates(&container_params, &container_params_store, f)?;
+            write_where_predicates(&container_params, container_params_store, f)?;
         }
         Ok(())
     }
@@ -140,7 +143,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
 fn write_function<'db>(f: &mut HirFormatter<'_, 'db>, func_id: FunctionId) -> Result<bool> {
     let db = f.db;
     let func = Function::from(func_id);
-    let data = db.function_signature(func_id);
+    let data = FunctionSignature::of(db, func_id);
 
     let mut module = func.module(db);
     // Block-local impls are "hoisted" to the nearest (non-block) module.
@@ -189,7 +192,7 @@ fn write_function<'db>(f: &mut HirFormatter<'_, 'db>, func_id: FunctionId) -> Re
 
     let comma = if too_long_param { ",\n    " } else { ", " };
     // FIXME: Use resolved `param.ty` once we no longer discard lifetimes
-    let body = db.body(func_id.into());
+    let body = Body::of(db, func_id.into());
     for (type_ref, param) in data.params.iter().zip(func.assoc_fn_params(db)).skip(skip_self) {
         if !first {
             f.write_str(comma)?;
@@ -268,7 +271,7 @@ fn write_impl_header<'db>(impl_: ImplId, f: &mut HirFormatter<'_, 'db>) -> Resul
     let def_id = GenericDefId::ImplId(impl_);
     write_generic_params(def_id, f)?;
 
-    let impl_data = db.impl_signature(impl_);
+    let impl_data = ImplSignature::of(db, impl_);
     if let Some(target_trait) = &impl_data.target_trait {
         f.write_char(' ')?;
         hir_display_with_store(&impl_data.store[target_trait.path], &impl_data.store).hir_fmt(f)?;
@@ -297,7 +300,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 }
             },
         };
-        let data = f.db.function_signature(func);
+        let data = FunctionSignature::of(f.db, func);
         let param = *data.params.first().unwrap();
         match &data.store[param] {
             TypeRef::Path(p) if p.is_self_type() => f.write_str("self"),
@@ -657,7 +660,7 @@ fn write_generic_params_or_args<'db>(
     f: &mut HirFormatter<'_, 'db>,
     include_defaults: bool,
 ) -> Result {
-    let (params, store) = f.db.generic_params_and_store(def);
+    let (params, store) = GenericParams::of(f.db, def);
     if params.iter_lt().next().is_none()
         && params.iter_type_or_consts().all(|it| it.1.const_param().is_none())
         && params
@@ -693,17 +696,17 @@ fn write_generic_params_or_args<'db>(
                     write!(f, "{}", name.display(f.db, f.edition()))?;
                     if include_defaults && let Some(default) = &ty.default {
                         f.write_str(" = ")?;
-                        default.hir_fmt(f, &store)?;
+                        default.hir_fmt(f, store)?;
                     }
                 }
                 TypeOrConstParamData::ConstParamData(c) => {
                     delim(f)?;
                     write!(f, "const {}: ", name.display(f.db, f.edition()))?;
-                    c.ty.hir_fmt(f, &store)?;
+                    c.ty.hir_fmt(f, store)?;
 
                     if include_defaults && let Some(default) = &c.default {
                         f.write_str(" = ")?;
-                        default.hir_fmt(f, &store)?;
+                        default.hir_fmt(f, store)?;
                     }
                 }
             }
@@ -715,13 +718,13 @@ fn write_generic_params_or_args<'db>(
 }
 
 fn write_where_clause<'db>(def: GenericDefId, f: &mut HirFormatter<'_, 'db>) -> Result<bool> {
-    let (params, store) = f.db.generic_params_and_store(def);
-    if !has_disaplayable_predicates(f.db, &params, &store) {
+    let (params, store) = GenericParams::of(f.db, def);
+    if !has_disaplayable_predicates(f.db, &params, store) {
         return Ok(false);
     }
 
     f.write_str("\nwhere")?;
-    write_where_predicates(&params, &store, f)?;
+    write_where_predicates(&params, store, f)?;
 
     Ok(true)
 }
@@ -816,7 +819,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
             module = module.nearest_non_block_module(db);
         }
         write_visibility(module.id, self.visibility(db), f)?;
-        let data = db.const_signature(self.id);
+        let data = ConstSignature::of(db, self.id);
         f.write_str("const ")?;
         match &data.name {
             Some(name) => write!(f, "{}: ", name.display(f.db, f.edition()))?,
@@ -830,7 +833,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
 impl<'db> HirDisplay<'db> for Static {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
-        let data = f.db.static_signature(self.id);
+        let data = StaticSignature::of(f.db, self.id);
         f.write_str("static ")?;
         if data.flags.contains(StaticFlags::MUTABLE) {
             f.write_str("mut ")?;
@@ -889,7 +892,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
 
 fn write_trait_header<'db>(trait_: Trait, f: &mut HirFormatter<'_, 'db>) -> Result {
     write_visibility(trait_.module(f.db).id, trait_.visibility(f.db), f)?;
-    let data = f.db.trait_signature(trait_.id);
+    let data = TraitSignature::of(f.db, trait_.id);
     if data.flags.contains(TraitFlags::UNSAFE) {
         f.write_str("unsafe ")?;
     }
@@ -904,7 +907,7 @@ fn write_trait_header<'db>(trait_: Trait, f: &mut HirFormatter<'_, 'db>) -> Resu
 impl<'db> HirDisplay<'db> for TypeAlias {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
-        let data = f.db.type_alias_signature(self.id);
+        let data = TypeAliasSignature::of(f.db, self.id);
         write!(f, "type {}", data.name.display(f.db, f.edition()))?;
         let def_id = GenericDefId::TypeAliasId(self.id);
         write_generic_params(def_id, f)?;
diff --git a/src/tools/rust-analyzer/crates/hir/src/from_id.rs b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
index fc20f4b46bb9..1aeed874af45 100644
--- a/src/tools/rust-analyzer/crates/hir/src/from_id.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
@@ -4,8 +4,8 @@
 //! are splitting the hir.
 
 use hir_def::{
-    AdtId, AssocItemId, BuiltinDeriveImplId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId,
-    GenericParamId, ModuleDefId, VariantId,
+    AdtId, AssocItemId, BuiltinDeriveImplId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId,
+    FieldId, GenericDefId, GenericParamId, ModuleDefId, VariantId,
     hir::{BindingId, LabelId},
 };
 use hir_ty::next_solver::AnyImplId;
@@ -255,14 +255,19 @@ fn try_from(item: AssocItem) -> Result<Self, Self::Error> {
     }
 }
 
-impl From<(DefWithBodyId, BindingId)> for Local {
-    fn from((parent, binding_id): (DefWithBodyId, BindingId)) -> Self {
+impl From<(ExpressionStoreOwnerId, BindingId)> for Local {
+    fn from((parent, binding_id): (ExpressionStoreOwnerId, BindingId)) -> Self {
         Local { parent, binding_id }
     }
 }
+impl From<(DefWithBodyId, BindingId)> for Local {
+    fn from((parent, binding_id): (DefWithBodyId, BindingId)) -> Self {
+        Local { parent: parent.into(), binding_id }
+    }
+}
 
-impl From<(DefWithBodyId, LabelId)> for Label {
-    fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self {
+impl From<(ExpressionStoreOwnerId, LabelId)> for Label {
+    fn from((parent, label_id): (ExpressionStoreOwnerId, LabelId)) -> Self {
         Label { parent, label_id }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index 6a1aeb64f35b..752c4f3173e6 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -3,6 +3,7 @@
 use either::Either;
 use hir_def::{
     CallableDefId, Lookup, MacroId, VariantId,
+    expr_store::ExpressionStore,
     nameres::{ModuleOrigin, ModuleSource},
     src::{HasChildSource, HasSource as _},
 };
@@ -293,8 +294,7 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
             }
             Callee::Closure(closure, _) => {
                 let InternedClosure(owner, expr_id) = db.lookup_intern_closure(closure);
-                let body_owner = owner.as_def_with_body()?;
-                let (_, source_map) = db.body_with_source_map(body_owner);
+                let (_, source_map) = ExpressionStore::with_source_map(db, owner);
                 let ast @ InFile { file_id, value } = source_map.expr_syntax(expr_id).ok()?;
                 let root = db.parse_or_expand(file_id);
                 match value.to_node(&root) {
@@ -328,8 +328,7 @@ impl HasSource for Label {
     type Ast = ast::Label;
 
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
-        let (_body, source_map) = db.body_with_source_map(self.parent);
-        let src = source_map.label_syntax(self.label_id);
+        let src = ExpressionStore::with_source_map(db, self.parent).1.label_syntax(self.label_id);
         let root = src.file_syntax(db);
         src.map(|ast| ast.to_node(&root).left()).transpose()
     }
@@ -346,7 +345,7 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
 impl HasSource for InlineAsmOperand {
     type Ast = ast::AsmOperandNamed;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
-        let source_map = db.body_with_source_map(self.owner).1;
+        let (_, source_map) = ExpressionStore::with_source_map(db, self.owner);
         if let Ok(src) = source_map.expr_syntax(self.expr) {
             let root = src.file_syntax(db);
             return src
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 34372a4a95a2..4d4482b1afa3 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -49,13 +49,13 @@
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, AssocItemLoc, BuiltinDeriveImplId, CallableDefId, ConstId, ConstParamId,
-    DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId,
-    HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup, MacroExpander,
-    MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId, TypeOrConstParamId,
-    TypeParamId, UnionId,
+    DefWithBodyId, EnumId, EnumVariantId, ExpressionStoreOwnerId, ExternBlockId, ExternCrateId,
+    FunctionId, GenericDefId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId,
+    Lookup, MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId,
+    TypeOrConstParamId, TypeParamId, UnionId,
     attrs::AttrFlags,
     builtin_derive::BuiltinDeriveImplMethod,
-    expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
+    expr_store::{ExpressionStore, ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
     hir::{
         BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,
         generics::{LifetimeParamData, TypeOrConstParamData, TypeParamProvenance},
@@ -69,7 +69,11 @@
     },
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
-    signatures::{EnumSignature, ImplFlags, StaticFlags, StructFlags, TraitFlags, VariantFields},
+    signatures::{
+        ConstSignature, EnumSignature, FunctionSignature, ImplFlags, ImplSignature, StaticFlags,
+        StaticSignature, StructFlags, StructSignature, TraitFlags, TraitSignature,
+        TypeAliasSignature, UnionSignature, VariantFields,
+    },
     src::HasSource as _,
     visibility::visibility_from_ast,
 };
@@ -141,6 +145,7 @@
         Complete,
         FindPathConfig,
         attrs::{Docs, IsInnerDoc},
+        expr_store::Body,
         find_path::PrefixKind,
         import_map,
         lang_item::{LangItemEnum as LangItem, crate_lang_items},
@@ -729,8 +734,8 @@ pub fn diagnostics<'db>(
                 ModuleDef::Adt(adt) => {
                     match adt {
                         Adt::Struct(s) => {
-                            let source_map = db.struct_signature_with_source_map(s.id).1;
-                            expr_store_diagnostics(db, acc, &source_map);
+                            let source_map = &StructSignature::with_source_map(db, s.id).1;
+                            expr_store_diagnostics(db, acc, source_map);
                             let source_map = &s.id.fields_with_source_map(db).1;
                             expr_store_diagnostics(db, acc, source_map);
                             push_ty_diagnostics(
@@ -741,8 +746,8 @@ pub fn diagnostics<'db>(
                             );
                         }
                         Adt::Union(u) => {
-                            let source_map = db.union_signature_with_source_map(u.id).1;
-                            expr_store_diagnostics(db, acc, &source_map);
+                            let source_map = &UnionSignature::with_source_map(db, u.id).1;
+                            expr_store_diagnostics(db, acc, source_map);
                             let source_map = &u.id.fields_with_source_map(db).1;
                             expr_store_diagnostics(db, acc, source_map);
                             push_ty_diagnostics(
@@ -753,8 +758,8 @@ pub fn diagnostics<'db>(
                             );
                         }
                         Adt::Enum(e) => {
-                            let source_map = db.enum_signature_with_source_map(e.id).1;
-                            expr_store_diagnostics(db, acc, &source_map);
+                            let source_map = &EnumSignature::with_source_map(db, e.id).1;
+                            expr_store_diagnostics(db, acc, source_map);
                             let (variants, diagnostics) = e.id.enum_variants_with_diagnostics(db);
                             let file = e.id.lookup(db).id.file_id;
                             let ast_id_map = db.ast_id_map(file);
@@ -789,13 +794,13 @@ pub fn diagnostics<'db>(
                 }
                 ModuleDef::Macro(m) => emit_macro_def_diagnostics(db, acc, m),
                 ModuleDef::TypeAlias(type_alias) => {
-                    let source_map = db.type_alias_signature_with_source_map(type_alias.id).1;
-                    expr_store_diagnostics(db, acc, &source_map);
+                    let source_map = &TypeAliasSignature::with_source_map(db, type_alias.id).1;
+                    expr_store_diagnostics(db, acc, source_map);
                     push_ty_diagnostics(
                         db,
                         acc,
                         db.type_for_type_alias_with_diagnostics(type_alias.id).1,
-                        &source_map,
+                        source_map,
                     );
                     acc.extend(def.diagnostics(db, style_lints));
                 }
@@ -815,8 +820,8 @@ pub fn diagnostics<'db>(
                 continue;
             };
             let loc = impl_id.lookup(db);
-            let (impl_signature, source_map) = db.impl_signature_with_source_map(impl_id);
-            expr_store_diagnostics(db, acc, &source_map);
+            let (impl_signature, source_map) = ImplSignature::with_source_map(db, impl_id);
+            expr_store_diagnostics(db, acc, source_map);
 
             let file_id = loc.id.file_id;
             if file_id.macro_file().is_some_and(|it| it.kind(db) == MacroKind::DeriveBuiltIn) {
@@ -888,9 +893,9 @@ pub fn diagnostics<'db>(
             if let (false, Some(trait_)) = (impl_is_negative, trait_) {
                 let items = &trait_.id.trait_items(db).items;
                 let required_items = items.iter().filter(|&(_, assoc)| match *assoc {
-                    AssocItemId::FunctionId(it) => !db.function_signature(it).has_body(),
-                    AssocItemId::ConstId(id) => !db.const_signature(id).has_body(),
-                    AssocItemId::TypeAliasId(it) => db.type_alias_signature(it).ty.is_none(),
+                    AssocItemId::FunctionId(it) => !FunctionSignature::of(db, it).has_body(),
+                    AssocItemId::ConstId(id) => !ConstSignature::of(db, id).has_body(),
+                    AssocItemId::TypeAliasId(it) => TypeAliasSignature::of(db, it).ty.is_none(),
                 });
                 impl_assoc_items_scratch.extend(impl_id.impl_items(db).items.iter().cloned());
 
@@ -928,7 +933,7 @@ pub fn diagnostics<'db>(
                     let self_ty = structurally_normalize_ty(
                         &infcx,
                         self_ty,
-                        db.trait_environment(impl_id.into()),
+                        db.trait_environment(GenericDefId::from(impl_id).into()),
                     );
                     let self_ty_is_guaranteed_unsized = matches!(
                         self_ty.kind(),
@@ -983,7 +988,7 @@ pub fn diagnostics<'db>(
                                         continue;
                                     }
 
-                                    if db.function_signature(*fn_).is_default() {
+                                    if FunctionSignature::of(db, *fn_).is_default() {
                                         return false;
                                     }
                                 }
@@ -1007,12 +1012,12 @@ pub fn diagnostics<'db>(
                 impl_assoc_items_scratch.clear();
             }
 
-            push_ty_diagnostics(db, acc, db.impl_self_ty_with_diagnostics(impl_id).1, &source_map);
+            push_ty_diagnostics(db, acc, db.impl_self_ty_with_diagnostics(impl_id).1, source_map);
             push_ty_diagnostics(
                 db,
                 acc,
                 db.impl_trait_with_diagnostics(impl_id).and_then(|it| it.1),
-                &source_map,
+                source_map,
             );
 
             for &(_, item) in impl_id.impl_items(db).items.iter() {
@@ -1331,7 +1336,7 @@ pub fn name(&self) -> Name {
 
     pub fn ty<'db>(&self, db: &'db dyn HirDatabase) -> Type<'db> {
         let interner = DbInterner::new_no_crate(db);
-        let ty = InferenceResult::for_body(db, self.owner)
+        let ty = InferenceResult::of(db, self.owner)
             .tuple_field_access_type(self.tuple)
             .as_slice()
             .get(self.index as usize)
@@ -1455,7 +1460,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.struct_signature(self.id).name.clone()
+        StructSignature::of(db, self.id).name.clone()
     }
 
     pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@@ -1548,7 +1553,7 @@ pub struct Union {
 
 impl Union {
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.union_signature(self.id).name.clone()
+        UnionSignature::of(db, self.id).name.clone()
     }
 
     pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -1607,7 +1612,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.enum_signature(self.id).name.clone()
+        EnumSignature::of(db, self.id).name.clone()
     }
 
     pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {
@@ -1962,6 +1967,44 @@ pub fn name(&self, db: &dyn HirDatabase) -> Name {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ExpressionStoreOwner {
+    Body(DefWithBody),
+    Signature(GenericDef),
+}
+
+impl From<GenericDef> for ExpressionStoreOwner {
+    fn from(v: GenericDef) -> Self {
+        Self::Signature(v)
+    }
+}
+
+impl From<DefWithBody> for ExpressionStoreOwner {
+    fn from(v: DefWithBody) -> Self {
+        Self::Body(v)
+    }
+}
+
+impl From<ExpressionStoreOwnerId> for ExpressionStoreOwner {
+    fn from(v: ExpressionStoreOwnerId) -> Self {
+        match v {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                Self::Signature(generic_def_id.into())
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => Self::Body(def_with_body_id.into()),
+        }
+    }
+}
+
+impl ExpressionStoreOwner {
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            Self::Body(body) => body.module(db),
+            Self::Signature(generic_def) => generic_def.module(db),
+        }
+    }
+}
+
 /// The defs which have a body.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum DefWithBody {
@@ -2018,7 +2061,7 @@ pub fn debug_hir(self, db: &dyn HirDatabase) -> String {
         let Some(id) = self.id() else {
             return String::new();
         };
-        let body = db.body(id);
+        let body = Body::of(db, id);
         body.pretty_print(db, id, Edition::CURRENT)
     }
 
@@ -2045,17 +2088,17 @@ pub fn diagnostics<'db>(
         };
         let krate = self.module(db).id.krate(db);
 
-        let (body, source_map) = db.body_with_source_map(id);
+        let (body, source_map) = Body::with_source_map(db, id);
         let sig_source_map = match self {
             DefWithBody::Function(id) => match id.id {
-                AnyFunctionId::FunctionId(id) => db.function_signature_with_source_map(id).1,
+                AnyFunctionId::FunctionId(id) => &FunctionSignature::with_source_map(db, id).1,
                 AnyFunctionId::BuiltinDeriveImplMethod { .. } => return,
             },
-            DefWithBody::Static(id) => db.static_signature_with_source_map(id.into()).1,
-            DefWithBody::Const(id) => db.const_signature_with_source_map(id.into()).1,
+            DefWithBody::Static(id) => &StaticSignature::with_source_map(db, id.into()).1,
+            DefWithBody::Const(id) => &ConstSignature::with_source_map(db, id.into()).1,
             DefWithBody::Variant(variant) => {
                 let enum_id = variant.parent_enum(db).id;
-                db.enum_signature_with_source_map(enum_id).1
+                &EnumSignature::with_source_map(db, enum_id).1
             }
         };
 
@@ -2063,17 +2106,11 @@ pub fn diagnostics<'db>(
             Module { id: def_map.root_module_id() }.diagnostics(db, acc, style_lints);
         }
 
-        expr_store_diagnostics(db, acc, &source_map);
+        expr_store_diagnostics(db, acc, source_map);
 
-        let infer = InferenceResult::for_body(db, id);
+        let infer = InferenceResult::of(db, id);
         for d in infer.diagnostics() {
-            acc.extend(AnyDiagnostic::inference_diagnostic(
-                db,
-                id,
-                d,
-                &source_map,
-                &sig_source_map,
-            ));
+            acc.extend(AnyDiagnostic::inference_diagnostic(db, id, d, source_map, sig_source_map));
         }
 
         for (pat_or_expr, mismatch) in infer.type_mismatches() {
@@ -2195,7 +2232,7 @@ pub fn diagnostics<'db>(
                     {
                         need_mut = &mir::MutabilityReason::Not;
                     }
-                    let local = Local { parent: id, binding_id };
+                    let local = Local { parent: id.into(), binding_id };
                     let is_mut = body[binding_id].mode == BindingAnnotation::Mutable;
 
                     match (need_mut, is_mut) {
@@ -2252,7 +2289,7 @@ pub fn diagnostics<'db>(
         }
 
         for diagnostic in BodyValidationDiagnostic::collect(db, id, style_lints) {
-            acc.extend(AnyDiagnostic::body_validation_diagnostic(db, diagnostic, &source_map));
+            acc.extend(AnyDiagnostic::body_validation_diagnostic(db, diagnostic, source_map));
         }
 
         for diag in hir_ty::diagnostics::incorrect_case(db, id.into()) {
@@ -2266,7 +2303,7 @@ pub fn expression_types<'db>(
         db: &'db dyn HirDatabase,
     ) -> impl Iterator<Item = Type<'db>> {
         self.id().into_iter().flat_map(move |def_id| {
-            let infer = InferenceResult::for_body(db, def_id);
+            let infer = InferenceResult::of(db, def_id);
             let resolver = def_id.resolver(db);
 
             infer.expression_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))
@@ -2276,7 +2313,7 @@ pub fn expression_types<'db>(
     /// Returns an iterator over the inferred types of all patterns in this body.
     pub fn pattern_types<'db>(self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Type<'db>> {
         self.id().into_iter().flat_map(move |def_id| {
-            let infer = InferenceResult::for_body(db, def_id);
+            let infer = InferenceResult::of(db, def_id);
             let resolver = def_id.resolver(db);
 
             infer.pattern_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))
@@ -2286,7 +2323,7 @@ pub fn pattern_types<'db>(self, db: &'db dyn HirDatabase) -> impl Iterator<Item
     /// Returns an iterator over the inferred types of all bindings in this body.
     pub fn binding_types<'db>(self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Type<'db>> {
         self.id().into_iter().flat_map(move |def_id| {
-            let infer = InferenceResult::for_body(db, def_id);
+            let infer = InferenceResult::of(db, def_id);
             let resolver = def_id.resolver(db);
 
             infer.binding_types().map(move |(_, ty)| Type::new_with_resolver(db, &resolver, ty))
@@ -2354,7 +2391,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).name.clone(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).name.clone(),
             AnyFunctionId::BuiltinDeriveImplMethod { method, .. } => {
                 Name::new_symbol_root(method.name())
             }
@@ -2556,7 +2593,7 @@ pub fn async_ret_type<'db>(self, db: &'db dyn HirDatabase) -> Option<Type<'db>>
 
     pub fn has_self_param(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).has_self_param(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).has_self_param(),
             AnyFunctionId::BuiltinDeriveImplMethod { method, .. } => match method {
                 BuiltinDeriveImplMethod::clone
                 | BuiltinDeriveImplMethod::fmt
@@ -2591,7 +2628,7 @@ pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {
 
     pub fn num_params(self, db: &dyn HirDatabase) -> usize {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).params.len(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).params.len(),
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => {
                 self.fn_sig(db).1.skip_binder().inputs().len()
             }
@@ -2635,21 +2672,21 @@ pub fn params_without_self_with_args<'db>(
 
     pub fn is_const(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).is_const(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).is_const(),
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,
         }
     }
 
     pub fn is_async(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).is_async(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).is_async(),
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,
         }
     }
 
     pub fn is_varargs(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).is_varargs(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).is_varargs(),
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,
         }
     }
@@ -2702,7 +2739,7 @@ pub fn is_main(self, db: &dyn HirDatabase) -> bool {
             AnyFunctionId::FunctionId(id) => {
                 self.exported_main(db)
                     || self.module(db).is_crate_root(db)
-                        && db.function_signature(id).name == sym::main
+                        && FunctionSignature::of(db, id).name == sym::main
             }
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,
         }
@@ -2779,7 +2816,7 @@ pub fn is_unsafe_to_call(
     /// This is false in the case of required (not provided) trait methods.
     pub fn has_body(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyFunctionId::FunctionId(id) => db.function_signature(id).has_body(),
+            AnyFunctionId::FunctionId(id) => FunctionSignature::of(db, id).has_body(),
             AnyFunctionId::BuiltinDeriveImplMethod { .. } => true,
         }
     }
@@ -2807,7 +2844,7 @@ pub fn eval(
             id.into(),
             GenericArgs::empty(interner).store(),
             ParamEnvAndCrate {
-                param_env: db.trait_environment(id.into()),
+                param_env: db.trait_environment(GenericDefId::from(id).into()),
                 krate: id.module(db).krate(db),
             }
             .store(),
@@ -2893,23 +2930,24 @@ pub fn as_local(&self, db: &dyn HirDatabase) -> Option<Local> {
         match self.func {
             Callee::Def(CallableDefId::FunctionId(it)) => {
                 let parent = DefWithBodyId::FunctionId(it);
-                let body = db.body(parent);
+                let body = Body::of(db, parent);
                 if let Some(self_param) = body.self_param.filter(|_| self.idx == 0) {
-                    Some(Local { parent, binding_id: self_param })
+                    Some(Local { parent: parent.into(), binding_id: self_param })
                 } else if let Pat::Bind { id, .. } =
                     &body[body.params[self.idx - body.self_param.is_some() as usize]]
                 {
-                    Some(Local { parent, binding_id: *id })
+                    Some(Local { parent: parent.into(), binding_id: *id })
                 } else {
                     None
                 }
             }
             Callee::Closure(closure, _) => {
                 let c = db.lookup_intern_closure(closure);
-                let body_owner = c.0.as_def_with_body()?;
-                let body = db.body(body_owner);
-                if let Expr::Closure { args, .. } = &body[c.1]
-                    && let Pat::Bind { id, .. } = &body[args[self.idx]]
+                let body_owner = c.0;
+                let store = ExpressionStore::of(db, c.0);
+
+                if let Expr::Closure { args, .. } = &store[c.1]
+                    && let Pat::Bind { id, .. } = &store[args[self.idx]]
                 {
                     return Some(Local { parent: body_owner, binding_id: *id });
                 }
@@ -2933,7 +2971,7 @@ impl SelfParam {
     pub fn access(self, db: &dyn HirDatabase) -> Access {
         match self.func.id {
             AnyFunctionId::FunctionId(id) => {
-                let func_data = db.function_signature(id);
+                let func_data = FunctionSignature::of(db, id);
                 func_data
                     .params
                     .first()
@@ -3062,7 +3100,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
-        db.const_signature(self.id).name.clone()
+        ConstSignature::of(db, self.id).name.clone()
     }
 
     pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {
@@ -3135,11 +3173,11 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.static_signature(self.id).name.clone()
+        StaticSignature::of(db, self.id).name.clone()
     }
 
     pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
-        db.static_signature(self.id).flags.contains(StaticFlags::MUTABLE)
+        StaticSignature::of(db, self.id).flags.contains(StaticFlags::MUTABLE)
     }
 
     pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {
@@ -3195,7 +3233,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.trait_signature(self.id).name.clone()
+        TraitSignature::of(db, self.id).name.clone()
     }
 
     pub fn direct_supertraits(self, db: &dyn HirDatabase) -> Vec<Trait> {
@@ -3225,11 +3263,11 @@ pub fn items_with_supertraits(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
     }
 
     pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
-        db.trait_signature(self.id).flags.contains(TraitFlags::AUTO)
+        TraitSignature::of(db, self.id).flags.contains(TraitFlags::AUTO)
     }
 
     pub fn is_unsafe(&self, db: &dyn HirDatabase) -> bool {
-        db.trait_signature(self.id).flags.contains(TraitFlags::UNSAFE)
+        TraitSignature::of(db, self.id).flags.contains(TraitFlags::UNSAFE)
     }
 
     pub fn type_or_const_param_count(
@@ -3305,7 +3343,7 @@ pub fn ty_params(self, db: &dyn HirDatabase) -> Type<'_> {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.type_alias_signature(self.id).name.clone()
+        TypeAliasSignature::of(db, self.id).name.clone()
     }
 }
 
@@ -3752,6 +3790,17 @@ fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
     }
 }
 
+impl AsAssocItem for GenericDef {
+    fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
+        match self {
+            GenericDef::Function(it) => it.as_assoc_item(db),
+            GenericDef::Const(it) => it.as_assoc_item(db),
+            GenericDef::TypeAlias(it) => it.as_assoc_item(db),
+            _ => None,
+        }
+    }
+}
+
 fn as_assoc_item<'db, ID, DEF, LOC>(
     db: &(dyn HirDatabase + 'db),
     ctor: impl FnOnce(DEF) -> AssocItem,
@@ -3934,7 +3983,7 @@ pub fn diagnostics<'db>(
                     db,
                     acc,
                     db.type_for_type_alias_with_diagnostics(type_alias.id).1,
-                    &db.type_alias_signature_with_source_map(type_alias.id).1,
+                    &TypeAliasSignature::with_source_map(db, type_alias.id).1,
                 );
                 for diag in hir_ty::diagnostics::incorrect_case(db, type_alias.id.into()) {
                     acc.push(diag.into());
@@ -4085,24 +4134,24 @@ pub fn diagnostics<'db>(self, db: &'db dyn HirDatabase, acc: &mut Vec<AnyDiagnos
         }
 
         let source_map = match def {
-            GenericDefId::AdtId(AdtId::EnumId(it)) => db.enum_signature_with_source_map(it).1,
-            GenericDefId::AdtId(AdtId::StructId(it)) => db.struct_signature_with_source_map(it).1,
-            GenericDefId::AdtId(AdtId::UnionId(it)) => db.union_signature_with_source_map(it).1,
+            GenericDefId::AdtId(AdtId::EnumId(it)) => &EnumSignature::with_source_map(db, it).1,
+            GenericDefId::AdtId(AdtId::StructId(it)) => &StructSignature::with_source_map(db, it).1,
+            GenericDefId::AdtId(AdtId::UnionId(it)) => &UnionSignature::with_source_map(db, it).1,
             GenericDefId::ConstId(_) => return,
-            GenericDefId::FunctionId(it) => db.function_signature_with_source_map(it).1,
-            GenericDefId::ImplId(it) => db.impl_signature_with_source_map(it).1,
+            GenericDefId::FunctionId(it) => &FunctionSignature::with_source_map(db, it).1,
+            GenericDefId::ImplId(it) => &ImplSignature::with_source_map(db, it).1,
             GenericDefId::StaticId(_) => return,
-            GenericDefId::TraitId(it) => db.trait_signature_with_source_map(it).1,
-            GenericDefId::TypeAliasId(it) => db.type_alias_signature_with_source_map(it).1,
+            GenericDefId::TraitId(it) => &TraitSignature::with_source_map(db, it).1,
+            GenericDefId::TypeAliasId(it) => &TypeAliasSignature::with_source_map(db, it).1,
         };
 
-        expr_store_diagnostics(db, acc, &source_map);
-        push_ty_diagnostics(db, acc, db.generic_defaults_with_diagnostics(def).1, &source_map);
+        expr_store_diagnostics(db, acc, source_map);
+        push_ty_diagnostics(db, acc, db.generic_defaults_with_diagnostics(def).1, source_map);
         push_ty_diagnostics(
             db,
             acc,
             GenericPredicates::query_with_diagnostics(db, def).1.clone(),
-            &source_map,
+            source_map,
         );
         for (param_id, param) in generics.iter_type_or_consts() {
             if let TypeOrConstParamData::ConstParamData(_) = param {
@@ -4113,7 +4162,7 @@ pub fn diagnostics<'db>(self, db: &'db dyn HirDatabase, acc: &mut Vec<AnyDiagnos
                         TypeOrConstParamId { parent: def, local_id: param_id },
                     ))
                     .1,
-                    &source_map,
+                    source_map,
                 );
             }
         }
@@ -4210,7 +4259,7 @@ pub fn types(&self, db: &'db dyn HirDatabase) -> Vec<(Symbol, Type<'db>)> {
 /// A single local definition.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Local {
-    pub(crate) parent: DefWithBodyId,
+    pub(crate) parent: ExpressionStoreOwnerId,
     pub(crate) binding_id: BindingId,
 }
 
@@ -4272,7 +4321,7 @@ pub fn is_param(self, db: &dyn HirDatabase) -> bool {
 
     pub fn as_self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
         match self.parent {
-            DefWithBodyId::FunctionId(func) if self.is_self(db) => {
+            ExpressionStoreOwnerId::Body(DefWithBodyId::FunctionId(func)) if self.is_self(db) => {
                 Some(SelfParam { func: func.into() })
             }
             _ => None,
@@ -4280,8 +4329,7 @@ pub fn as_self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let body = db.body(self.parent);
-        body[self.binding_id].name.clone()
+        ExpressionStore::of(db, self.parent)[self.binding_id].name.clone()
     }
 
     pub fn is_self(self, db: &dyn HirDatabase) -> bool {
@@ -4289,16 +4337,17 @@ pub fn is_self(self, db: &dyn HirDatabase) -> bool {
     }
 
     pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
-        let body = db.body(self.parent);
-        body[self.binding_id].mode == BindingAnnotation::Mutable
+        ExpressionStore::of(db, self.parent)[self.binding_id].mode == BindingAnnotation::Mutable
     }
 
     pub fn is_ref(self, db: &dyn HirDatabase) -> bool {
-        let body = db.body(self.parent);
-        matches!(body[self.binding_id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
+        matches!(
+            ExpressionStore::of(db, self.parent)[self.binding_id].mode,
+            BindingAnnotation::Ref | BindingAnnotation::RefMut
+        )
     }
 
-    pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
+    pub fn parent(self, _db: &dyn HirDatabase) -> ExpressionStoreOwner {
         self.parent.into()
     }
 
@@ -4312,67 +4361,89 @@ pub fn as_id(self) -> u32 {
 
     pub fn ty(self, db: &dyn HirDatabase) -> Type<'_> {
         let def = self.parent;
-        let infer = InferenceResult::for_body(db, def);
+        let infer = InferenceResult::of(db, def);
         let ty = infer.binding_ty(self.binding_id);
         Type::new(db, def, ty)
     }
 
     /// All definitions for this local. Example: `let (a$0, _) | (_, a$0) = it;`
     pub fn sources(self, db: &dyn HirDatabase) -> Vec<LocalSource> {
-        let (body, source_map) = db.body_with_source_map(self.parent);
-        match body.self_param.zip(source_map.self_param_syntax()) {
-            Some((param, source)) if param == self.binding_id => {
-                let root = source.file_syntax(db);
-                vec![LocalSource {
-                    local: self,
-                    source: source.map(|ast| Either::Right(ast.to_node(&root))),
-                }]
+        let b;
+        let s;
+        let (_, source_map) = match self.parent {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                s = ExpressionStore::with_source_map(db, generic_def_id.into());
+                (s.0, s.1)
             }
-            _ => source_map
-                .patterns_for_binding(self.binding_id)
-                .iter()
-                .map(|&definition| {
-                    let src = source_map.pat_syntax(definition).unwrap(); // Hmm...
-                    let root = src.file_syntax(db);
-                    LocalSource {
+            ExpressionStoreOwnerId::Body(def_with_body_id) => {
+                b = Body::with_source_map(db, def_with_body_id);
+                if let Some((param, source)) = b.0.self_param.zip(b.1.self_param_syntax())
+                    && param == self.binding_id
+                {
+                    let root = source.file_syntax(db);
+                    return vec![LocalSource {
                         local: self,
-                        source: src.map(|ast| match ast.to_node(&root) {
-                            Either::Right(ast::Pat::IdentPat(it)) => Either::Left(it),
-                            _ => unreachable!("local with non ident-pattern"),
-                        }),
-                    }
-                })
-                .collect(),
-        }
+                        source: source.map(|ast| Either::Right(ast.to_node(&root))),
+                    }];
+                }
+                (&b.0.store, &b.1.store)
+            }
+        };
+        source_map
+            .patterns_for_binding(self.binding_id)
+            .iter()
+            .map(|&definition| {
+                let src = source_map.pat_syntax(definition).unwrap(); // Hmm...
+                let root = src.file_syntax(db);
+                LocalSource {
+                    local: self,
+                    source: src.map(|ast| match ast.to_node(&root) {
+                        Either::Right(ast::Pat::IdentPat(it)) => Either::Left(it),
+                        _ => unreachable!("local with non ident-pattern"),
+                    }),
+                }
+            })
+            .collect()
     }
 
     /// The leftmost definition for this local. Example: `let (a$0, _) | (_, a) = it;`
     pub fn primary_source(self, db: &dyn HirDatabase) -> LocalSource {
-        let (body, source_map) = db.body_with_source_map(self.parent);
-        match body.self_param.zip(source_map.self_param_syntax()) {
-            Some((param, source)) if param == self.binding_id => {
-                let root = source.file_syntax(db);
+        let b;
+        let s;
+        let (_, source_map) = match self.parent {
+            ExpressionStoreOwnerId::Signature(generic_def_id) => {
+                s = ExpressionStore::with_source_map(db, generic_def_id.into());
+                (s.0, s.1)
+            }
+            ExpressionStoreOwnerId::Body(def_with_body_id) => {
+                b = Body::with_source_map(db, def_with_body_id);
+                if let Some((param, source)) = b.0.self_param.zip(b.1.self_param_syntax())
+                    && param == self.binding_id
+                {
+                    let root = source.file_syntax(db);
+                    return LocalSource {
+                        local: self,
+                        source: source.map(|ast| Either::Right(ast.to_node(&root))),
+                    };
+                }
+                (&b.0.store, &b.1.store)
+            }
+        };
+        source_map
+            .patterns_for_binding(self.binding_id)
+            .first()
+            .map(|&definition| {
+                let src = source_map.pat_syntax(definition).unwrap(); // Hmm...
+                let root = src.file_syntax(db);
                 LocalSource {
                     local: self,
-                    source: source.map(|ast| Either::Right(ast.to_node(&root))),
+                    source: src.map(|ast| match ast.to_node(&root) {
+                        Either::Right(ast::Pat::IdentPat(it)) => Either::Left(it),
+                        _ => unreachable!("local with non ident-pattern"),
+                    }),
                 }
-            }
-            _ => source_map
-                .patterns_for_binding(self.binding_id)
-                .first()
-                .map(|&definition| {
-                    let src = source_map.pat_syntax(definition).unwrap(); // Hmm...
-                    let root = src.file_syntax(db);
-                    LocalSource {
-                        local: self,
-                        source: src.map(|ast| match ast.to_node(&root) {
-                            Either::Right(ast::Pat::IdentPat(it)) => Either::Left(it),
-                            _ => unreachable!("local with non ident-pattern"),
-                        }),
-                    }
-                })
-                .unwrap(),
-        }
+            })
+            .unwrap()
     }
 }
 
@@ -4457,7 +4528,7 @@ pub fn krate(&self) -> Crate {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Label {
-    pub(crate) parent: DefWithBodyId,
+    pub(crate) parent: ExpressionStoreOwnerId,
     pub(crate) label_id: LabelId,
 }
 
@@ -4466,13 +4537,12 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
         self.parent(db).module(db)
     }
 
-    pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
+    pub fn parent(self, _db: &dyn HirDatabase) -> ExpressionStoreOwner {
         self.parent.into()
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let body = db.body(self.parent);
-        body[self.label_id].name.clone()
+        ExpressionStore::of(db, self.parent)[self.label_id].name.clone()
     }
 }
 
@@ -4781,7 +4851,7 @@ fn extend_with_def_map(db: &dyn HirDatabase, def_map: &DefMap, result: &mut Vec<
                 result.extend(module.scope.builtin_derive_impls().map(Impl::from));
 
                 for unnamed_const in module.scope.unnamed_consts() {
-                    for (_, block_def_map) in db.body(unnamed_const.into()).blocks(db) {
+                    for (_, block_def_map) in Body::of(db, unnamed_const.into()).blocks(db) {
                         extend_with_def_map(db, block_def_map, result);
                     }
                 }
@@ -4938,14 +5008,14 @@ pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
 
     pub fn is_negative(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyImplId::ImplId(id) => db.impl_signature(id).flags.contains(ImplFlags::NEGATIVE),
+            AnyImplId::ImplId(id) => ImplSignature::of(db, id).flags.contains(ImplFlags::NEGATIVE),
             AnyImplId::BuiltinDeriveImplId(_) => false,
         }
     }
 
     pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
         match self.id {
-            AnyImplId::ImplId(id) => db.impl_signature(id).flags.contains(ImplFlags::UNSAFE),
+            AnyImplId::ImplId(id) => ImplSignature::of(db, id).flags.contains(ImplFlags::UNSAFE),
             AnyImplId::BuiltinDeriveImplId(_) => false,
         }
     }
@@ -5052,16 +5122,13 @@ pub fn captured_items(&self, db: &'db dyn HirDatabase) -> Vec<ClosureCapture<'db
             return Vec::new();
         };
         let owner = db.lookup_intern_closure(id).0;
-        let Some(body_owner) = owner.as_def_with_body() else {
-            return Vec::new();
-        };
-        let infer = InferenceResult::for_body(db, body_owner);
+        let infer = InferenceResult::of(db, owner);
         let info = infer.closure_info(id);
         info.0
             .iter()
             .cloned()
             .map(|capture| ClosureCapture {
-                owner: body_owner,
+                owner,
                 closure: id,
                 capture,
                 _marker: PhantomCovariantLifetime::new(),
@@ -5078,7 +5145,7 @@ pub fn capture_types(&self, db: &'db dyn HirDatabase) -> Vec<Type<'db>> {
         let Some(body_owner) = owner.as_def_with_body() else {
             return Vec::new();
         };
-        let infer = InferenceResult::for_body(db, body_owner);
+        let infer = InferenceResult::of(db, body_owner);
         let (captures, _) = infer.closure_info(id);
         let env = body_param_env_from_has_crate(db, body_owner);
         captures.iter().map(|capture| Type { env, ty: capture.ty(db, self.subst) }).collect()
@@ -5091,7 +5158,7 @@ pub fn fn_trait(&self, db: &dyn HirDatabase) -> FnTrait {
                 let Some(body_owner) = owner.as_def_with_body() else {
                     return FnTrait::FnOnce;
                 };
-                let infer = InferenceResult::for_body(db, body_owner);
+                let infer = InferenceResult::of(db, body_owner);
                 let info = infer.closure_info(id);
                 info.1.into()
             }
@@ -5174,7 +5241,7 @@ pub fn get_id(self, db: &dyn HirDatabase, krate: Crate) -> Option<Trait> {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ClosureCapture<'db> {
-    owner: DefWithBodyId,
+    owner: ExpressionStoreOwnerId,
     closure: InternedClosureId,
     capture: hir_ty::CapturedItem,
     _marker: PhantomCovariantLifetime<'db>,
@@ -5233,17 +5300,16 @@ pub enum CaptureKind {
 
 #[derive(Debug, Clone)]
 pub struct CaptureUsages {
-    parent: DefWithBodyId,
+    parent: ExpressionStoreOwnerId,
     spans: SmallVec<[mir::MirSpan; 3]>,
 }
 
 impl CaptureUsages {
     pub fn sources(&self, db: &dyn HirDatabase) -> Vec<CaptureUsageSource> {
-        let (body, source_map) = db.body_with_source_map(self.parent);
-
+        let (body, source_map) = ExpressionStore::with_source_map(db, self.parent);
         let mut result = Vec::with_capacity(self.spans.len());
         for &span in self.spans.iter() {
-            let is_ref = span.is_ref_span(&body);
+            let is_ref = span.is_ref_span(body);
             match span {
                 mir::MirSpan::ExprId(expr) => {
                     if let Ok(expr) = source_map.expr_syntax(expr) {
@@ -5411,7 +5477,7 @@ pub fn contains_reference(&self, db: &'db dyn HirDatabase) -> bool {
         fn is_phantom_data(db: &dyn HirDatabase, adt_id: AdtId) -> bool {
             match adt_id {
                 AdtId::StructId(s) => {
-                    let flags = db.struct_signature(s).flags;
+                    let flags = StructSignature::of(db, s).flags;
                     flags.contains(StructFlags::IS_PHANTOM_DATA)
                 }
                 AdtId::UnionId(_) | AdtId::EnumId(_) => false,
@@ -6005,8 +6071,8 @@ fn with_method_resolution<R>(
         // for a nicer IDE experience. However, method resolution is always done on real code (either
         // existing code or code to be inserted), and there using PostAnalysis is dangerous - we may
         // suggest invalid methods. So we're using the TypingMode of the body we're in.
-        let typing_mode = if let Some(body_owner) = resolver.body_owner() {
-            TypingMode::analysis_in_body(interner, body_owner.into())
+        let typing_mode = if let Some(store_owner) = resolver.expression_store_owner() {
+            TypingMode::analysis_in_body(interner, store_owner.into())
         } else {
             TypingMode::non_body_analysis()
         };
@@ -6411,18 +6477,19 @@ pub fn is_bool(&self) -> bool {
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub struct InlineAsmOperand {
-    owner: DefWithBodyId,
+    owner: ExpressionStoreOwnerId,
     expr: ExprId,
     index: usize,
 }
 
 impl InlineAsmOperand {
-    pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
+    pub fn parent(self, _db: &dyn HirDatabase) -> ExpressionStoreOwner {
         self.owner.into()
     }
 
     pub fn name(&self, db: &dyn HirDatabase) -> Option<Name> {
-        match &db.body(self.owner)[self.expr] {
+        let body = ExpressionStore::of(db, self.owner);
+        match &body[self.expr] {
             hir_def::hir::Expr::InlineAsm(e) => e.operands.get(self.index)?.0.clone(),
             _ => None,
         }
@@ -7183,7 +7250,7 @@ fn param_env_from_resolver<'db>(
     ParamEnvAndCrate {
         param_env: resolver
             .generic_def()
-            .map_or_else(ParamEnv::empty, |generic_def| db.trait_environment(generic_def)),
+            .map_or_else(ParamEnv::empty, |generic_def| db.trait_environment(generic_def.into())),
         krate: resolver.krate(),
     }
 }
@@ -7192,14 +7259,14 @@ fn param_env_from_has_crate<'db>(
     db: &'db dyn HirDatabase,
     id: impl hir_def::HasModule + Into<GenericDefId> + Copy,
 ) -> ParamEnvAndCrate<'db> {
-    ParamEnvAndCrate { param_env: db.trait_environment(id.into()), krate: id.krate(db) }
+    ParamEnvAndCrate { param_env: db.trait_environment(id.into().into()), krate: id.krate(db) }
 }
 
 fn body_param_env_from_has_crate<'db>(
     db: &'db dyn HirDatabase,
     id: impl hir_def::HasModule + Into<DefWithBodyId> + Copy,
 ) -> ParamEnvAndCrate<'db> {
-    ParamEnvAndCrate { param_env: db.trait_environment_for_body(id.into()), krate: id.krate(db) }
+    ParamEnvAndCrate { param_env: db.trait_environment(id.into().into()), krate: id.krate(db) }
 }
 
 fn empty_param_env<'db>(krate: base_db::Crate) -> ParamEnvAndCrate<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index a231f4aff515..f1aabb59337a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -13,7 +13,8 @@
 use base_db::FxIndexSet;
 use either::Either;
 use hir_def::{
-    BuiltinDeriveImplId, DefWithBodyId, HasModule, MacroId, StructId, TraitId, VariantId,
+    BuiltinDeriveImplId, DefWithBodyId, ExpressionStoreOwnerId, HasModule, MacroId, StructId,
+    TraitId, VariantId,
     attrs::parse_extra_crate_attrs,
     expr_store::{Body, ExprOrPatSource, HygieneId, path::Path},
     hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat},
@@ -54,10 +55,10 @@
 
 use crate::{
     Adjust, Adjustment, Adt, AnyFunctionId, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const,
-    ConstParam, Crate, DefWithBody, DeriveHelper, Enum, Field, Function, GenericSubstitution,
-    HasSource, Impl, InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam, Local, Macro,
-    Module, ModuleDef, Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule, Trait,
-    TupleField, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+    ConstParam, Crate, DefWithBody, DeriveHelper, Enum, ExpressionStoreOwner, Field, Function,
+    GenericSubstitution, HasSource, Impl, InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam,
+    Local, Macro, Module, ModuleDef, Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule,
+    Trait, TupleField, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
     db::HirDatabase,
     semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
     source_analyzer::{SourceAnalyzer, resolve_hir_path},
@@ -785,16 +786,20 @@ pub fn speculative_expand_derive_as_pseudo_attr_macro(
     /// Checks if renaming `renamed` to `new_name` may introduce conflicts with other locals,
     /// and returns the conflicting locals.
     pub fn rename_conflicts(&self, to_be_renamed: &Local, new_name: &Name) -> Vec<Local> {
-        let body = self.db.body(to_be_renamed.parent);
+        // FIXME: signatures
+        let Some(def) = to_be_renamed.parent.as_def_with_body() else {
+            return Vec::new();
+        };
+        let body = Body::of(self.db, def);
         let resolver = to_be_renamed.parent.resolver(self.db);
         let starting_expr = body.binding_owner(to_be_renamed.binding_id).unwrap_or(body.body_expr);
         let mut visitor = RenameConflictsVisitor {
-            body: &body,
+            body,
             conflicts: FxHashSet::default(),
             db: self.db,
             new_name: new_name.symbol().clone(),
             old_name: to_be_renamed.name(self.db).symbol().clone(),
-            owner: to_be_renamed.parent,
+            owner: def,
             to_be_renamed: to_be_renamed.binding_id,
             resolver,
         };
@@ -1917,10 +1922,10 @@ pub fn get_unsafe_ops(&self, def: DefWithBody) -> FxHashSet<ExprOrPatSource> {
         let Ok(def) = DefWithBodyId::try_from(def) else {
             return FxHashSet::default();
         };
-        let (body, source_map) = self.db.body_with_source_map(def);
-        let infer = InferenceResult::for_body(self.db, def);
+        let (body, source_map) = Body::with_source_map(self.db, def);
+        let infer = InferenceResult::of(self.db, def);
         let mut res = FxHashSet::default();
-        unsafe_operations_for_body(self.db, infer, def, &body, &mut |node| {
+        unsafe_operations_for_body(self.db, infer, def, body, &mut |node| {
             if let Ok(node) = source_map.expr_or_pat_syntax(node) {
                 res.insert(node);
             }
@@ -1935,13 +1940,13 @@ pub fn get_unsafe_ops_for_unsafe_block(&self, block: ast::BlockExpr) -> Vec<Expr
         let Ok(def) = def.try_into() else {
             return Vec::new();
         };
-        let (body, source_map) = self.db.body_with_source_map(def);
-        let infer = InferenceResult::for_body(self.db, def);
+        let (body, source_map) = Body::with_source_map(self.db, def);
+        let infer = InferenceResult::of(self.db, def);
         let Some(ExprOrPatId::ExprId(block)) = source_map.node_expr(block.as_ref()) else {
             return Vec::new();
         };
         let mut res = Vec::default();
-        unsafe_operations(self.db, infer, def, &body, block, &mut |node, _| {
+        unsafe_operations(self.db, infer, def, body, block, &mut |node, _| {
             if let Ok(node) = source_map.expr_or_pat_syntax(node) {
                 res.push(node);
             }
@@ -2275,7 +2280,7 @@ pub fn is_inside_unsafe(&self, expr: &ast::Expr) -> bool {
         let Some(def) = def else { return false };
         let enclosing_node = enclosing_item.as_ref().either(|i| i.syntax(), |v| v.syntax());
 
-        let (body, source_map) = self.db.body_with_source_map(def);
+        let (body, source_map) = Body::with_source_map(self.db, def);
 
         let file_id = self.find_file(expr.syntax()).file_id;
 
@@ -2326,7 +2331,7 @@ pub fn locals_used(
         let sa = self.analyze(element.either(|e| e.syntax(), |s| s.syntax()))?;
         let store = sa.store()?;
         let mut resolver = sa.resolver.clone();
-        let def = resolver.body_owner()?;
+        let def = resolver.expression_store_owner()?;
 
         let is_not_generated = |path: &Path| {
             !path.mod_path().and_then(|path| path.as_ident()).is_some_and(Name::is_generated)
@@ -2576,13 +2581,18 @@ pub fn krate(&self) -> Crate {
         Crate { id: self.resolver.krate() }
     }
 
+    // FIXME: This is a weird function, we shouldn't have this?
     pub fn containing_function(&self) -> Option<Function> {
-        self.resolver.body_owner().and_then(|owner| match owner {
-            DefWithBodyId::FunctionId(id) => Some(id.into()),
+        self.resolver.expression_store_owner().and_then(|owner| match owner {
+            ExpressionStoreOwnerId::Body(DefWithBodyId::FunctionId(id)) => Some(id.into()),
             _ => None,
         })
     }
 
+    pub fn expression_store_owner(&self) -> Option<ExpressionStoreOwner> {
+        self.resolver.expression_store_owner().map(Into::into)
+    }
+
     pub(crate) fn resolver(&self) -> &Resolver<'db> {
         &self.resolver
     }
@@ -2604,14 +2614,18 @@ pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
                     resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                     resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
                     resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(id.into()),
-                    resolver::ScopeDef::Local(binding_id) => match self.resolver.body_owner() {
-                        Some(parent) => ScopeDef::Local(Local { parent, binding_id }),
-                        None => continue,
-                    },
-                    resolver::ScopeDef::Label(label_id) => match self.resolver.body_owner() {
-                        Some(parent) => ScopeDef::Label(Label { parent, label_id }),
-                        None => continue,
-                    },
+                    resolver::ScopeDef::Local(binding_id) => {
+                        match self.resolver.expression_store_owner() {
+                            Some(parent) => ScopeDef::Local(Local { parent, binding_id }),
+                            None => continue,
+                        }
+                    }
+                    resolver::ScopeDef::Label(label_id) => {
+                        match self.resolver.expression_store_owner() {
+                            Some(parent) => ScopeDef::Label(Label { parent, label_id }),
+                            None => continue,
+                        }
+                    }
                 };
                 f(name.clone(), def)
             }
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
index 143cc14c3377..f6d1bec5754c 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
@@ -18,8 +18,10 @@
         DynMap,
         keys::{self, Key},
     },
+    expr_store::Body,
     hir::generics::GenericParams,
     item_scope::ItemScope,
+    signatures::{EnumSignature, ImplSignature, TraitSignature},
     src::{HasChildSource, HasSource},
 };
 
@@ -49,7 +51,7 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
         data.items.iter().for_each(|&(_, item)| {
             add_assoc_item(db, res, file_id, item);
         });
-        let (_, source_map) = db.trait_signature_with_source_map(*self);
+        let (_, source_map) = TraitSignature::with_source_map(db, *self);
         source_map.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(
             |(ast, &exp_id)| {
                 res[keys::MACRO_CALL].insert(ast.value, exp_id);
@@ -74,7 +76,7 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
         data.items.iter().for_each(|&(_, item)| {
             add_assoc_item(db, res, file_id, item);
         });
-        let (_, source_map) = db.impl_signature_with_source_map(*self);
+        let (_, source_map) = ImplSignature::with_source_map(db, *self);
         source_map.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(
             |(ast, &exp_id)| {
                 res[keys::MACRO_CALL].insert(ast.value, exp_id);
@@ -204,7 +206,7 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
         self.enum_variants(db).variants.iter().for_each(|&(variant, _, _)| {
             res[keys::ENUM_VARIANT].insert(ast_id_map.get(variant.lookup(db).id.value), variant);
         });
-        let (_, source_map) = db.enum_signature_with_source_map(*self);
+        let (_, source_map) = EnumSignature::with_source_map(db, *self);
         source_map
             .expansions()
             .filter(|(ast, _)| ast.file_id == file_id)
@@ -214,7 +216,7 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
 
 impl ChildBySource for DefWithBodyId {
     fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
-        let (body, sm) = db.body_with_source_map(*self);
+        let (body, sm) = Body::with_source_map(db, *self);
         if let &DefWithBodyId::VariantId(v) = self {
             VariantId::EnumVariantId(v).child_by_source_to(db, res, file_id)
         }
@@ -239,8 +241,7 @@ fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: Hi
             return;
         }
 
-        let (generic_params, _, source_map) =
-            GenericParams::generic_params_and_store_and_source_map(db, *self);
+        let (generic_params, _, source_map) = GenericParams::with_source_map(db, *self);
         let mut toc_idx_iter = generic_params.iter_type_or_consts().map(|(idx, _)| idx);
         let lts_idx_iter = generic_params.iter_lt().map(|(idx, _)| idx);
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
index d222c3dc7ed1..8c398728b08a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
@@ -88,13 +88,14 @@
 use either::Either;
 use hir_def::{
     AdtId, BlockId, BuiltinDeriveImplId, ConstId, ConstParamId, DefWithBodyId, EnumId,
-    EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId, GenericDefId, GenericParamId,
-    ImplId, LifetimeParamId, Lookup, MacroId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
-    TypeParamId, UnionId, UseId, VariantId,
+    EnumVariantId, ExpressionStoreOwnerId, ExternBlockId, ExternCrateId, FieldId, FunctionId,
+    GenericDefId, GenericParamId, ImplId, LifetimeParamId, Lookup, MacroId, ModuleId, StaticId,
+    StructId, TraitId, TypeAliasId, TypeParamId, UnionId, UseId, VariantId,
     dyn_map::{
         DynMap,
         keys::{self, Key},
     },
+    expr_store::{Body, ExpressionStore},
     hir::{BindingId, Expr, LabelId},
     nameres::{block_def_map, crate_def_map},
 };
@@ -334,8 +335,8 @@ pub(super) fn asm_operand_to_def(
                 _ => None,
             })
             .position(|it| it == *src.value)?;
-        let container = self.find_pat_or_label_container(src.syntax_ref())?;
-        let source_map = self.db.body_with_source_map(container).1;
+        let container = self.find_container(src.syntax_ref())?.as_expression_store_owner()?;
+        let (_, source_map) = ExpressionStore::with_source_map(self.db, container);
         let expr = source_map.node_expr(src.with_value(&ast::Expr::AsmExpr(asm)))?.as_expr()?;
         Some(InlineAsmOperand { owner: container, expr, index })
     }
@@ -343,13 +344,13 @@ pub(super) fn asm_operand_to_def(
     pub(super) fn bind_pat_to_def(
         &mut self,
         src: InFile<&ast::IdentPat>,
-    ) -> Option<(DefWithBodyId, BindingId)> {
-        let container = self.find_pat_or_label_container(src.syntax_ref())?;
-        let (body, source_map) = self.db.body_with_source_map(container);
+    ) -> Option<(ExpressionStoreOwnerId, BindingId)> {
+        let container = self.find_container(src.syntax_ref())?.as_expression_store_owner()?;
+        let (store, source_map) = ExpressionStore::with_source_map(self.db, container);
         let src = src.cloned().map(ast::Pat::from);
         let pat_id = source_map.node_pat(src.as_ref())?;
         // the pattern could resolve to a constant, verify that this is not the case
-        if let crate::Pat::Bind { id, .. } = body[pat_id.as_pat()?] {
+        if let crate::Pat::Bind { id, .. } = store[pat_id.as_pat()?] {
             Some((container, id))
         } else {
             None
@@ -359,17 +360,19 @@ pub(super) fn self_param_to_def(
         &mut self,
         src: InFile<&ast::SelfParam>,
     ) -> Option<(DefWithBodyId, BindingId)> {
-        let container = self.find_pat_or_label_container(src.syntax_ref())?;
-        let body = self.db.body(container);
+        let container = self
+            .find_container(src.syntax_ref())?
+            .as_expression_store_owner()?
+            .as_def_with_body()?;
+        let body = Body::of(self.db, container);
         Some((container, body.self_param?))
     }
     pub(super) fn label_to_def(
         &mut self,
         src: InFile<&ast::Label>,
-    ) -> Option<(DefWithBodyId, LabelId)> {
-        let container = self.find_pat_or_label_container(src.syntax_ref())?;
-        let source_map = self.db.body_with_source_map(container).1;
-
+    ) -> Option<(ExpressionStoreOwnerId, LabelId)> {
+        let container = self.find_container(src.syntax_ref())?.as_expression_store_owner()?;
+        let (_, source_map) = ExpressionStore::with_source_map(self.db, container);
         let label_id = source_map.node_label(src)?;
         Some((container, label_id))
     }
@@ -377,13 +380,14 @@ pub(super) fn label_to_def(
     pub(super) fn label_ref_to_def(
         &mut self,
         src: InFile<&ast::Lifetime>,
-    ) -> Option<(DefWithBodyId, LabelId)> {
+    ) -> Option<(ExpressionStoreOwnerId, LabelId)> {
         let break_or_continue = ast::Expr::cast(src.value.syntax().parent()?)?;
-        let container = self.find_pat_or_label_container(src.syntax_ref())?;
-        let (body, source_map) = self.db.body_with_source_map(container);
+        let container = self.find_container(src.syntax_ref())?.as_expression_store_owner()?;
+        let (store, source_map) = ExpressionStore::with_source_map(self.db, container);
         let break_or_continue =
             source_map.node_expr(src.with_value(&break_or_continue))?.as_expr()?;
-        let (Expr::Break { label, .. } | Expr::Continue { label }) = body[break_or_continue] else {
+        let (Expr::Break { label, .. } | Expr::Continue { label }) = store[break_or_continue]
+        else {
             return None;
         };
         Some((container, label?))
@@ -557,29 +561,6 @@ fn find_generic_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<G
         })
     }
 
-    // FIXME: Remove this when we do inference in signatures
-    fn find_pat_or_label_container(&mut self, src: InFile<&SyntaxNode>) -> Option<DefWithBodyId> {
-        self.parent_ancestors_with_macros(src, |this, InFile { file_id, value }, _| {
-            let item = match ast::Item::cast(value.clone()) {
-                Some(it) => it,
-                None => {
-                    let variant = ast::Variant::cast(value)?;
-                    return this
-                        .enum_variant_to_def(InFile::new(file_id, &variant))
-                        .map(Into::into);
-                }
-            };
-            match &item {
-                ast::Item::Fn(it) => this.fn_to_def(InFile::new(file_id, it)).map(Into::into),
-                ast::Item::Const(it) => this.const_to_def(InFile::new(file_id, it)).map(Into::into),
-                ast::Item::Static(it) => {
-                    this.static_to_def(InFile::new(file_id, it)).map(Into::into)
-                }
-                _ => None,
-            }
-        })
-    }
-
     /// Skips the attributed item that caused the macro invocation we are climbing up
     fn parent_ancestors_with_macros<T>(
         &mut self,
@@ -756,4 +737,22 @@ fn child_by_source(self, db: &dyn HirDatabase, file_id: HirFileId) -> DynMap {
             ChildContainer::GenericDefId(it) => it.child_by_source(db, file_id),
         }
     }
+
+    fn as_expression_store_owner(self) -> Option<ExpressionStoreOwnerId> {
+        match self {
+            ChildContainer::DefWithBodyId(it) => Some(it.into()),
+            ChildContainer::ModuleId(_) => None,
+            ChildContainer::TraitId(it) => {
+                Some(ExpressionStoreOwnerId::Signature(GenericDefId::TraitId(it)))
+            }
+            ChildContainer::EnumId(it) => {
+                Some(ExpressionStoreOwnerId::Signature(GenericDefId::AdtId(it.into())))
+            }
+            ChildContainer::ImplId(it) => {
+                Some(ExpressionStoreOwnerId::Signature(GenericDefId::ImplId(it)))
+            }
+            ChildContainer::VariantId(_) => None,
+            ChildContainer::GenericDefId(it) => Some(it.into()),
+        }
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index 1d3cfc748e95..bd77347e93eb 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -9,8 +9,8 @@
 
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstId, DefWithBodyId, FieldId, FunctionId, GenericDefId,
-    LocalFieldId, ModuleDefId, StructId, TraitId, VariantId,
+    AdtId, AssocItemId, CallableDefId, ConstId, DefWithBodyId, ExpressionStoreOwnerId, FieldId,
+    FunctionId, GenericDefId, LocalFieldId, ModuleDefId, StructId, TraitId, VariantId,
     expr_store::{
         Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, HygieneId,
         lower::ExprCollector,
@@ -78,20 +78,20 @@ pub(crate) struct SourceAnalyzer<'db> {
 pub(crate) enum BodyOrSig<'db> {
     Body {
         def: DefWithBodyId,
-        body: Arc<Body>,
-        source_map: Arc<BodySourceMap>,
+        body: &'db Body,
+        source_map: &'db BodySourceMap,
         infer: Option<&'db InferenceResult>,
     },
     // To be folded into body once it is considered one
     VariantFields {
         def: VariantId,
-        store: Arc<ExpressionStore>,
-        source_map: Arc<ExpressionStoreSourceMap>,
+        store: &'db ExpressionStore,
+        source_map: &'db ExpressionStoreSourceMap,
     },
     Sig {
         def: GenericDefId,
-        store: Arc<ExpressionStore>,
-        source_map: Arc<ExpressionStoreSourceMap>,
+        store: &'db ExpressionStore,
+        source_map: &'db ExpressionStoreSourceMap,
         infer: Option<&'db InferenceResult>,
         #[expect(dead_code)]
         generics: Arc<GenericParams>,
@@ -105,7 +105,7 @@ pub(crate) fn new_for_body(
         node: InFile<&SyntaxNode>,
         offset: Option<TextSize>,
     ) -> SourceAnalyzer<'db> {
-        Self::new_for_body_(db, def, node, offset, Some(InferenceResult::for_body(db, def)))
+        Self::new_for_body_(db, def, node, offset, Some(InferenceResult::of(db, def)))
     }
 
     pub(crate) fn new_for_body_no_infer(
@@ -124,10 +124,10 @@ pub(crate) fn new_for_body_(
         offset: Option<TextSize>,
         infer: Option<&'db InferenceResult>,
     ) -> SourceAnalyzer<'db> {
-        let (body, source_map) = db.body_with_source_map(def);
-        let scopes = db.expr_scopes(def.into());
+        let (body, source_map) = Body::with_source_map(db, def);
+        let scopes = ExprScopes::of(db, def);
         let scope = match offset {
-            None => scope_for(db, &scopes, &source_map, node),
+            None => scope_for(db, scopes, source_map, node),
             Some(offset) => {
                 debug_assert!(
                     node.text_range().contains_inclusive(offset),
@@ -135,7 +135,7 @@ pub(crate) fn new_for_body_(
                     offset,
                     node.text_range()
                 );
-                scope_for_offset(db, &scopes, &source_map, node.file_id, offset)
+                scope_for_offset(db, scopes, source_map, node.file_id, offset)
             }
         };
         let resolver = resolver_for_scope(db, def, scope);
@@ -171,10 +171,10 @@ pub(crate) fn new_generic_def_(
         offset: Option<TextSize>,
         infer: bool,
     ) -> SourceAnalyzer<'db> {
-        let (generics, store, source_map) = db.generic_params_and_store_and_source_map(def);
-        let scopes = db.expr_scopes(def.into());
+        let (generics, store, source_map) = GenericParams::with_source_map(db, def);
+        let scopes = ExprScopes::of(db, def);
         let scope = match offset {
-            None => scope_for(db, &scopes, &source_map, node),
+            None => scope_for(db, scopes, source_map, node),
             Some(offset) => {
                 debug_assert!(
                     node.text_range().contains_inclusive(offset),
@@ -182,15 +182,11 @@ pub(crate) fn new_generic_def_(
                     offset,
                     node.text_range()
                 );
-                scope_for_offset(db, &scopes, &source_map, node.file_id, offset)
+                scope_for_offset(db, scopes, source_map, node.file_id, offset)
             }
         };
         let resolver = resolver_for_scope(db, def, scope);
-        let infer = if infer && !Arc::ptr_eq(&store, &ExpressionStore::empty_singleton().0) {
-            Some(InferenceResult::for_signature(db, def))
-        } else {
-            None
-        };
+        let infer = if infer { Some(InferenceResult::of(db, def)) } else { None };
         SourceAnalyzer {
             resolver,
             body_or_sig: Some(BodyOrSig::Sig { def, store, source_map, generics, infer }),
@@ -208,11 +204,7 @@ pub(crate) fn new_variant_body(
         let resolver = def.resolver(db);
         SourceAnalyzer {
             resolver,
-            body_or_sig: Some(BodyOrSig::VariantFields {
-                def,
-                store: fields.store.clone(),
-                source_map: source_map.clone(),
-            }),
+            body_or_sig: Some(BodyOrSig::VariantFields { def, store: &fields.store, source_map }),
             file_id,
         }
     }
@@ -241,6 +233,18 @@ fn infer(&self) -> Option<&InferenceResult> {
         })
     }
 
+    pub(crate) fn def(
+        &self,
+    ) -> Option<(ExpressionStoreOwnerId, &ExpressionStore, &ExpressionStoreSourceMap)> {
+        self.body_or_sig.as_ref().and_then(|it| match it {
+            BodyOrSig::VariantFields { .. } => None,
+            &BodyOrSig::Sig { def, store, source_map, .. } => Some((def.into(), store, source_map)),
+            BodyOrSig::Body { def, body, source_map, .. } => {
+                Some(((*def).into(), &body.store, source_map))
+            }
+        })
+    }
+
     pub(crate) fn store(&self) -> Option<&ExpressionStore> {
         self.body_or_sig.as_ref().map(|it| match it {
             BodyOrSig::Sig { store, .. } => &**store,
@@ -264,9 +268,9 @@ fn param_and<'a>(&self, param_env: ParamEnv<'a>) -> ParamEnvAndCrate<'a> {
     fn trait_environment(&self, db: &'db dyn HirDatabase) -> ParamEnvAndCrate<'db> {
         self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {
             match *body_or_sig {
-                BodyOrSig::Body { def, .. } => db.trait_environment_for_body(def),
+                BodyOrSig::Body { def, .. } => db.trait_environment(def.into()),
                 BodyOrSig::VariantFields { .. } => ParamEnv::empty(),
-                BodyOrSig::Sig { def, .. } => db.trait_environment(def),
+                BodyOrSig::Sig { def, .. } => db.trait_environment(def.into()),
             }
         }))
     }
@@ -806,7 +810,7 @@ pub(crate) fn resolve_record_field(
                 name_hygiene(db, InFile::new(self.file_id, ast_name.syntax())),
             ) {
                 Some(ValueNs::LocalBinding(binding_id)) => {
-                    Some(Local { binding_id, parent: self.resolver.body_owner()? })
+                    Some(Local { binding_id, parent: self.resolver.expression_store_owner()? })
                 }
                 _ => None,
             }
@@ -866,8 +870,8 @@ pub(crate) fn resolve_bind_pat_to_const(
             },
         };
 
-        let body_owner = self.resolver.body_owner();
-        let res = resolve_hir_value_path(db, &self.resolver, body_owner, path, HygieneId::ROOT)?;
+        let store_owner = self.resolver.expression_store_owner();
+        let res = resolve_hir_value_path(db, &self.resolver, store_owner, path, HygieneId::ROOT)?;
         match res {
             PathResolution::Def(def) => Some(def),
             _ => None,
@@ -1435,7 +1439,7 @@ pub(crate) fn resolve_offset_in_format_args(
                 resolve_hir_value_path(
                     db,
                     &self.resolver,
-                    self.resolver.body_owner(),
+                    self.resolver.expression_store_owner(),
                     &Path::from_known_path_with_no_generic(ModPath::from_segments(
                         PathKind::Plain,
                         Some(name.clone()),
@@ -1451,9 +1455,9 @@ pub(crate) fn resolve_offset_in_asm_template(
         asm: InFile<&ast::AsmExpr>,
         line: usize,
         offset: TextSize,
-    ) -> Option<(DefWithBodyId, (ExprId, TextRange, usize))> {
-        let (def, _, body_source_map, _) = self.body_()?;
-        let (expr, args) = body_source_map.asm_template_args(asm)?;
+    ) -> Option<(ExpressionStoreOwnerId, (ExprId, TextRange, usize))> {
+        let (def, _, sm) = self.def()?;
+        let (expr, args) = sm.asm_template_args(asm)?;
         Some(def).zip(
             args.get(line)?
                 .iter()
@@ -1474,7 +1478,7 @@ pub(crate) fn as_format_args_parts<'a>(
                 resolve_hir_value_path(
                     db,
                     &self.resolver,
-                    self.resolver.body_owner(),
+                    self.resolver.expression_store_owner(),
                     &Path::from_known_path_with_no_generic(ModPath::from_segments(
                         PathKind::Plain,
                         Some(name.clone()),
@@ -1488,9 +1492,9 @@ pub(crate) fn as_format_args_parts<'a>(
     pub(crate) fn as_asm_parts(
         &self,
         asm: InFile<&ast::AsmExpr>,
-    ) -> Option<(DefWithBodyId, (ExprId, &[Vec<(TextRange, usize)>]))> {
-        let (def, _, body_source_map, _) = self.body_()?;
-        Some(def).zip(body_source_map.asm_template_args(asm))
+    ) -> Option<(ExpressionStoreOwnerId, (ExprId, &[Vec<(TextRange, usize)>]))> {
+        let (def, _, sm) = self.def()?;
+        Some(def).zip(sm.asm_template_args(asm))
     }
 
     fn resolve_impl_method_or_trait_def(
@@ -1508,11 +1512,11 @@ fn resolve_impl_method_or_trait_def_with_subst(
         func: FunctionId,
         substs: GenericArgs<'db>,
     ) -> (Function, GenericArgs<'db>) {
-        let owner = match self.resolver.body_owner() {
+        let owner = match self.resolver.expression_store_owner() {
             Some(it) => it,
             None => return (func.into(), substs),
         };
-        let env = self.param_and(db.trait_environment_for_body(owner));
+        let env = self.param_and(db.trait_environment(owner));
         let (func, args) = db.lookup_impl_method(env, func, substs);
         match func {
             Either::Left(func) => (func.into(), args),
@@ -1528,11 +1532,11 @@ fn resolve_impl_const_or_trait_def_with_subst(
         const_id: ConstId,
         subs: GenericArgs<'db>,
     ) -> (ConstId, GenericArgs<'db>) {
-        let owner = match self.resolver.body_owner() {
+        let owner = match self.resolver.expression_store_owner() {
             Some(it) => it,
             None => return (const_id, subs),
         };
-        let env = self.param_and(db.trait_environment_for_body(owner));
+        let env = self.param_and(db.trait_environment(owner));
         let interner = DbInterner::new_with(db, env.krate);
         let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
         method_resolution::lookup_impl_const(&infcx, env.param_env, const_id, subs)
@@ -1743,7 +1747,7 @@ fn resolve_hir_path_(
         }
     };
 
-    let body_owner = resolver.body_owner();
+    let body_owner = resolver.expression_store_owner();
     let values = || resolve_hir_value_path(db, resolver, body_owner, path, hygiene);
 
     let items = || {
@@ -1789,14 +1793,14 @@ fn resolve_hir_path_(
 fn resolve_hir_value_path(
     db: &dyn HirDatabase,
     resolver: &Resolver<'_>,
-    body_owner: Option<DefWithBodyId>,
+    store_owner: Option<ExpressionStoreOwnerId>,
     path: &Path,
     hygiene: HygieneId,
 ) -> Option<PathResolution> {
     resolver.resolve_path_in_value_ns_fully(db, path, hygiene).and_then(|val| {
         let res = match val {
             ValueNs::LocalBinding(binding_id) => {
-                let var = Local { parent: body_owner?, binding_id };
+                let var = Local { parent: store_owner?, binding_id };
                 PathResolution::Local(var)
             }
             ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
diff --git a/src/tools/rust-analyzer/crates/hir/src/symbols.rs b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
index c088f3aa0cc0..ff56544d82e0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/symbols.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
@@ -8,9 +8,11 @@
     AdtId, AssocItemId, AstIdLoc, Complete, DefWithBodyId, ExternCrateId, HasModule, ImplId,
     Lookup, MacroId, ModuleDefId, ModuleId, TraitId,
     db::DefDatabase,
+    expr_store::Body,
     item_scope::{ImportId, ImportOrExternCrate, ImportOrGlob},
     nameres::crate_def_map,
     per_ns::Item,
+    signatures::{EnumSignature, ImplSignature, TraitSignature},
     src::{HasChildSource, HasSource},
     visibility::{Visibility, VisibilityExplicitness},
 };
@@ -185,7 +187,7 @@ fn collect_from_module(&mut self, module_id: ModuleId) {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(id)) => {
                     this.push_decl(id, name, false, None);
-                    let enum_name = Symbol::intern(this.db.enum_signature(id).name.as_str());
+                    let enum_name = Symbol::intern(EnumSignature::of(this.db, id).name.as_str());
                     this.with_container_name(Some(enum_name), |this| {
                         let variants = id.enum_variants(this.db);
                         for (variant_id, variant_name, _) in &variants.variants {
@@ -386,7 +388,7 @@ fn collect_from_body(&mut self, body_id: impl Into<DefWithBodyId>, name: Option<
             return;
         }
         let body_id = body_id.into();
-        let body = self.db.body(body_id);
+        let body = Body::of(self.db, body_id);
 
         // Descend into the blocks and enqueue collection of all modules within.
         for (_, def_map) in body.blocks(self.db) {
@@ -397,7 +399,7 @@ fn collect_from_body(&mut self, body_id: impl Into<DefWithBodyId>, name: Option<
     }
 
     fn collect_from_impl(&mut self, impl_id: ImplId) {
-        let impl_data = self.db.impl_signature(impl_id);
+        let impl_data = ImplSignature::of(self.db, impl_id);
         let impl_name = Some(
             hir_display_with_store(impl_data.self_ty, &impl_data.store)
                 .display(
@@ -419,7 +421,7 @@ fn collect_from_impl(&mut self, impl_id: ImplId) {
     }
 
     fn collect_from_trait(&mut self, trait_id: TraitId, trait_do_not_complete: Complete) {
-        let trait_data = self.db.trait_signature(trait_id);
+        let trait_data = TraitSignature::of(self.db, trait_id);
         self.with_container_name(Some(Symbol::intern(trait_data.name.as_str())), |s| {
             for &(ref name, assoc_item_id) in &trait_id.trait_items(self.db).items {
                 s.push_assoc_item(assoc_item_id, name, Some(trait_do_not_complete));
diff --git a/src/tools/rust-analyzer/crates/hir/src/term_search/tactics.rs b/src/tools/rust-analyzer/crates/hir/src/term_search/tactics.rs
index 8622aa1378b3..c7ef4e5d5deb 100644
--- a/src/tools/rust-analyzer/crates/hir/src/term_search/tactics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/term_search/tactics.rs
@@ -53,7 +53,7 @@ pub(super) fn trivial<'a, 'lt, 'db, DB: HirDatabase>(
             ScopeDef::GenericParam(GenericParam::ConstParam(it)) => Some(Expr::ConstParam(*it)),
             ScopeDef::Local(it) => {
                 if ctx.config.enable_borrowcheck {
-                    let borrowck = db.borrowck(it.parent).ok()?;
+                    let borrowck = db.borrowck(it.parent.as_def_with_body()?).ok()?;
 
                     let invalid = borrowck.iter().any(|b| {
                         b.partially_moved.iter().any(|moved| {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 1749db1e61b4..3c3f71aea6cf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -80,9 +80,15 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
     let module = scope.module();
     let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(scope.krate()));
     let self_ty = if ctx.config.prefer_self_ty {
-        scope
-            .containing_function()
-            .and_then(|function| function.as_assoc_item(ctx.db())?.implementing_ty(ctx.db()))
+        scope.expression_store_owner().and_then(|def| {
+            match def {
+                hir::ExpressionStoreOwner::Body(def_with_body) => {
+                    def_with_body.as_assoc_item(ctx.db())
+                }
+                hir::ExpressionStoreOwner::Signature(def) => def.as_assoc_item(ctx.db()),
+            }?
+            .implementing_ty(ctx.db())
+        })
     } else {
         None
     };
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
index 788f9b73fa19..6ee4c97c873f 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
@@ -14,11 +14,12 @@
 use either::Either;
 use hir::{
     Adt, AsAssocItem, AsExternAssocItem, AssocItem, AttributeTemplate, BuiltinAttr, BuiltinType,
-    Const, Crate, DefWithBody, DeriveHelper, DisplayTarget, DocLinkDef, ExternAssocItem,
-    ExternCrateDecl, Field, Function, GenericDef, GenericParam, GenericSubstitution, HasContainer,
-    HasVisibility, HirDisplay, Impl, InlineAsmOperand, ItemContainer, Label, Local, Macro, Module,
-    ModuleDef, Name, PathResolution, Semantics, Static, StaticLifetime, Struct, ToolModule, Trait,
-    TupleField, TypeAlias, Variant, VariantDef, Visibility,
+    Const, Crate, DefWithBody, DeriveHelper, DisplayTarget, DocLinkDef, ExpressionStoreOwner,
+    ExternAssocItem, ExternCrateDecl, Field, Function, GenericDef, GenericParam,
+    GenericSubstitution, HasContainer, HasVisibility, HirDisplay, Impl, InlineAsmOperand,
+    ItemContainer, Label, Local, Macro, Module, ModuleDef, Name, PathResolution, Semantics, Static,
+    StaticLifetime, Struct, ToolModule, Trait, TupleField, TypeAlias, Variant, VariantDef,
+    Visibility,
 };
 use span::Edition;
 use stdx::{format_to, impl_from};
@@ -1020,6 +1021,16 @@ fn from(def: GenericDef) -> Self {
     }
 }
 
+impl TryFrom<ExpressionStoreOwner> for Definition {
+    type Error = ();
+    fn try_from(def: ExpressionStoreOwner) -> Result<Self, Self::Error> {
+        match def {
+            ExpressionStoreOwner::Body(def_with_body) => def_with_body.try_into(),
+            ExpressionStoreOwner::Signature(generic_def) => Ok(generic_def.into()),
+        }
+    }
+}
+
 impl TryFrom<Definition> for GenericDef {
     type Error = ();
     fn try_from(def: Definition) -> Result<Self, Self::Error> {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/search.rs b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
index 3822eaae2cc7..2cf4627ac892 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/search.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
@@ -10,9 +10,9 @@
 use base_db::{RootQueryDb, SourceDatabase};
 use either::Either;
 use hir::{
-    Adt, AsAssocItem, DefWithBody, EditionedFileId, FileRange, FileRangeWrapper, HasAttrs,
-    HasContainer, HasSource, InFile, InFileWrapper, InRealFile, InlineAsmOperand, ItemContainer,
-    ModuleSource, PathResolution, Semantics, Visibility,
+    Adt, AsAssocItem, DefWithBody, EditionedFileId, ExpressionStoreOwner, FileRange,
+    FileRangeWrapper, HasAttrs, HasContainer, HasSource, InFile, InFileWrapper, InRealFile,
+    InlineAsmOperand, ItemContainer, ModuleSource, PathResolution, Semantics, Visibility,
 };
 use memchr::memmem::Finder;
 use parser::SyntaxKind;
@@ -310,10 +310,23 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
 
         if let Definition::Local(var) = self {
             let def = match var.parent(db) {
-                DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                ExpressionStoreOwner::Body(def) => match def {
+                    DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                },
+                ExpressionStoreOwner::Signature(def) => match def {
+                    hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Adt(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Trait(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::TypeAlias(it) => {
+                        it.source(db).map(|src| src.syntax().cloned())
+                    }
+                    hir::GenericDef::Impl(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Static(it) => it.source(db).map(|src| src.syntax().cloned()),
+                },
             };
             return match def {
                 Some(def) => SearchScope::file_range(
@@ -325,10 +338,23 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
 
         if let Definition::InlineAsmOperand(op) = self {
             let def = match op.parent(db) {
-                DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
-                DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                ExpressionStoreOwner::Body(def) => match def {
+                    DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                },
+                ExpressionStoreOwner::Signature(def) => match def {
+                    hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Adt(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Trait(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::TypeAlias(it) => {
+                        it.source(db).map(|src| src.syntax().cloned())
+                    }
+                    hir::GenericDef::Impl(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
+                    hir::GenericDef::Static(it) => it.source(db).map(|src| src.syntax().cloned()),
+                },
             };
             return match def {
                 Some(def) => SearchScope::file_range(
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implicit_drop.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implicit_drop.rs
index e5e4c899ec03..3af529e8c56d 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implicit_drop.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implicit_drop.rs
@@ -7,7 +7,7 @@
 //! ```
 use hir::{
     DefWithBody,
-    db::{DefDatabase as _, HirDatabase as _},
+    db::HirDatabase as _,
     mir::{MirSpan, TerminatorKind},
 };
 use ide_db::{FileRange, famous_defs::FamousDefs};
@@ -35,7 +35,7 @@ pub(super) fn hints(
     let def: DefWithBody = def.into();
 
     let def = def.try_into().ok()?;
-    let (hir, source_map) = sema.db.body_with_source_map(def);
+    let (hir, source_map) = hir::Body::with_source_map(sema.db, def);
 
     let mir = sema.db.mir_body(def).ok()?;
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/rename.rs b/src/tools/rust-analyzer/crates/ide/src/rename.rs
index ae19e7750968..900a885a64de 100644
--- a/src/tools/rust-analyzer/crates/ide/src/rename.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/rename.rs
@@ -480,7 +480,7 @@ fn rename_to_self(
     }
 
     let fn_def = match local.parent(sema.db) {
-        hir::DefWithBody::Function(func) => func,
+        hir::ExpressionStoreOwner::Body(hir::DefWithBody::Function(func)) => func,
         _ => bail!("Cannot rename local to self outside of function"),
     };
 
@@ -743,7 +743,7 @@ fn rename_self_to_param(
     }
 
     let fn_def = match local.parent(sema.db) {
-        hir::DefWithBody::Function(func) => func,
+        hir::ExpressionStoreOwner::Body(hir::DefWithBody::Function(func)) => func,
         _ => bail!("Cannot rename local to self outside of function"),
     };
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 3ee379765461..43e73175c820 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -16,8 +16,8 @@
     next_solver::{DbInterner, GenericArgs},
 };
 use hir_def::{
-    SyntheticSyntax,
-    expr_store::BodySourceMap,
+    DefWithBodyId, ExpressionStoreOwnerId, GenericDefId, SyntheticSyntax,
+    expr_store::{Body, BodySourceMap, ExpressionStore},
     hir::{ExprId, PatId},
 };
 use hir_ty::InferenceResult;
@@ -406,7 +406,7 @@ fn run_data_layout(&self, db: &RootDatabase, adts: &[hir::Adt], verbosity: Verbo
                 hir_def::AdtId::from(a),
                 GenericArgs::empty(interner).store(),
                 hir_ty::ParamEnvAndCrate {
-                    param_env: db.trait_environment(a.into()),
+                    param_env: db.trait_environment(GenericDefId::from(a).into()),
                     krate: a.krate(db).into(),
                 }
                 .store(),
@@ -778,21 +778,24 @@ fn run_inference(
 
         if self.parallel {
             let mut inference_sw = self.stop_watch();
-            let bodies = bodies.iter().filter_map(|&body| body.try_into().ok()).collect::<Vec<_>>();
+            let bodies = bodies
+                .iter()
+                .filter_map(|&body| body.try_into().ok())
+                .collect::<Vec<DefWithBodyId>>();
             bodies
                 .par_iter()
                 .map_with(db.clone(), |snap, &body| {
-                    InferenceResult::for_body(snap, body);
+                    InferenceResult::of(snap, body);
                 })
                 .count();
             let signatures = signatures
                 .iter()
                 .filter_map(|&signatures| signatures.try_into().ok())
-                .collect::<Vec<_>>();
+                .collect::<Vec<GenericDefId>>();
             signatures
                 .par_iter()
                 .map_with(db.clone(), |snap, &signatures| {
-                    InferenceResult::for_signature(snap, signatures);
+                    InferenceResult::of(snap, signatures);
                 })
                 .count();
             eprintln!("{:<20} {}", "Parallel Inference:", inference_sw.elapsed());
@@ -849,9 +852,9 @@ fn run_inference(
                 bar.println(msg());
             }
             bar.set_message(msg);
-            let body = db.body(body_def_id);
+            let body = Body::of(db, body_def_id);
             let inference_result =
-                catch_unwind(AssertUnwindSafe(|| InferenceResult::for_body(db, body_def_id)));
+                catch_unwind(AssertUnwindSafe(|| InferenceResult::of(db, body_def_id)));
             let inference_result = match inference_result {
                 Ok(inference_result) => inference_result,
                 Err(p) => {
@@ -879,7 +882,7 @@ fn run_inference(
                 }
             };
             // This query is LRU'd, so actually calling it will skew the timing results.
-            let sm = || db.body_with_source_map(body_def_id).1;
+            let sm = || &Body::with_source_map(db, body_def_id).1;
 
             // region:expressions
             let (previous_exprs, previous_unknown, previous_partially_unknown) =
@@ -890,7 +893,7 @@ fn run_inference(
                 let unknown_or_partial = if ty.is_ty_error() {
                     num_exprs_unknown += 1;
                     if verbosity.is_spammy() {
-                        if let Some((path, start, end)) = expr_syntax_range(db, vfs, &sm(), expr_id)
+                        if let Some((path, start, end)) = expr_syntax_range(db, vfs, sm(), expr_id)
                         {
                             bar.println(format!(
                                 "{} {}:{}-{}:{}: Unknown type",
@@ -917,7 +920,7 @@ fn run_inference(
                 };
                 if self.only.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single expression
-                    if let Some((_, start, end)) = expr_syntax_range(db, vfs, &sm(), expr_id) {
+                    if let Some((_, start, end)) = expr_syntax_range(db, vfs, sm(), expr_id) {
                         bar.println(format!(
                             "{}:{}-{}:{}: {}",
                             start.line + 1,
@@ -936,14 +939,14 @@ fn run_inference(
                 if unknown_or_partial && self.output == Some(OutputFormat::Csv) {
                     println!(
                         r#"{},type,"{}""#,
-                        location_csv_expr(db, vfs, &sm(), expr_id),
+                        location_csv_expr(db, vfs, sm(), expr_id),
                         ty.display(db, display_target)
                     );
                 }
                 if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                     num_expr_type_mismatches += 1;
                     if verbosity.is_verbose() {
-                        if let Some((path, start, end)) = expr_syntax_range(db, vfs, &sm(), expr_id)
+                        if let Some((path, start, end)) = expr_syntax_range(db, vfs, sm(), expr_id)
                         {
                             bar.println(format!(
                                 "{} {}:{}-{}:{}: Expected {}, got {}",
@@ -967,7 +970,7 @@ fn run_inference(
                     if self.output == Some(OutputFormat::Csv) {
                         println!(
                             r#"{},mismatch,"{}","{}""#,
-                            location_csv_expr(db, vfs, &sm(), expr_id),
+                            location_csv_expr(db, vfs, sm(), expr_id),
                             mismatch.expected.as_ref().display(db, display_target),
                             mismatch.actual.as_ref().display(db, display_target)
                         );
@@ -994,7 +997,7 @@ fn run_inference(
                 let unknown_or_partial = if ty.is_ty_error() {
                     num_pats_unknown += 1;
                     if verbosity.is_spammy() {
-                        if let Some((path, start, end)) = pat_syntax_range(db, vfs, &sm(), pat_id) {
+                        if let Some((path, start, end)) = pat_syntax_range(db, vfs, sm(), pat_id) {
                             bar.println(format!(
                                 "{} {}:{}-{}:{}: Unknown type",
                                 path,
@@ -1020,7 +1023,7 @@ fn run_inference(
                 };
                 if self.only.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single pattern
-                    if let Some((_, start, end)) = pat_syntax_range(db, vfs, &sm(), pat_id) {
+                    if let Some((_, start, end)) = pat_syntax_range(db, vfs, sm(), pat_id) {
                         bar.println(format!(
                             "{}:{}-{}:{}: {}",
                             start.line + 1,
@@ -1039,14 +1042,14 @@ fn run_inference(
                 if unknown_or_partial && self.output == Some(OutputFormat::Csv) {
                     println!(
                         r#"{},type,"{}""#,
-                        location_csv_pat(db, vfs, &sm(), pat_id),
+                        location_csv_pat(db, vfs, sm(), pat_id),
                         ty.display(db, display_target)
                     );
                 }
                 if let Some(mismatch) = inference_result.type_mismatch_for_pat(pat_id) {
                     num_pat_type_mismatches += 1;
                     if verbosity.is_verbose() {
-                        if let Some((path, start, end)) = pat_syntax_range(db, vfs, &sm(), pat_id) {
+                        if let Some((path, start, end)) = pat_syntax_range(db, vfs, sm(), pat_id) {
                             bar.println(format!(
                                 "{} {}:{}-{}:{}: Expected {}, got {}",
                                 path,
@@ -1069,7 +1072,7 @@ fn run_inference(
                     if self.output == Some(OutputFormat::Csv) {
                         println!(
                             r#"{},mismatch,"{}","{}""#,
-                            location_csv_pat(db, vfs, &sm(), pat_id),
+                            location_csv_pat(db, vfs, sm(), pat_id),
                             mismatch.expected.as_ref().display(db, display_target),
                             mismatch.actual.as_ref().display(db, display_target)
                         );
@@ -1174,7 +1177,7 @@ fn run_body_lowering(
                 bar.println(msg());
             }
             bar.set_message(msg);
-            db.generic_params_and_store(signature_id);
+            ExpressionStore::of(db, ExpressionStoreOwnerId::Signature(signature_id));
             bar.inc(1);
         }
 
@@ -1213,7 +1216,7 @@ fn run_body_lowering(
                 bar.println(msg());
             }
             bar.set_message(msg);
-            db.body(body_def_id);
+            Body::of(db, body_def_id);
             bar.inc(1);
         }
 

From a9966ba4cd694f2e79a284a2c1e54a95de7843f5 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 28 Mar 2026 14:05:14 +0100
Subject: [PATCH 1011/1059] Remove `Arc` from `GenericParams`

---
 .../rust-analyzer/crates/hir-def/src/attrs.rs |  2 +-
 .../rust-analyzer/crates/hir-def/src/db.rs    | 13 +--
 .../crates/hir-def/src/expr_store/lower.rs    | 18 ++--
 .../hir-def/src/expr_store/lower/generics.rs  | 23 +----
 .../crates/hir-def/src/expr_store/pretty.rs   |  4 +-
 .../crates/hir-def/src/expr_store/scope.rs    |  2 +-
 .../crates/hir-def/src/hir/generics.rs        | 84 +++++++++----------
 .../crates/hir-def/src/resolver.rs            | 13 ++-
 .../crates/hir-def/src/signatures.rs          | 18 ++--
 .../rust-analyzer/crates/hir-def/src/src.rs   |  6 +-
 .../crates/hir-ty/src/builtin_derive.rs       |  6 +-
 .../crates/hir-ty/src/display.rs              |  6 +-
 .../crates/hir-ty/src/dyn_compatibility.rs    |  6 +-
 .../crates/hir-ty/src/generics.rs             |  5 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  2 +-
 .../crates/hir-ty/src/method_resolution.rs    |  6 +-
 .../hir-ty/src/method_resolution/probe.rs     |  3 +-
 .../crates/hir-ty/src/mir/lower.rs            |  8 +-
 .../crates/hir-ty/src/next_solver/generics.rs |  2 +-
 .../crates/hir-ty/src/next_solver/ty.rs       |  4 +-
 .../crates/hir-ty/src/representability.rs     |  4 +-
 .../rust-analyzer/crates/hir/src/attrs.rs     |  3 +-
 .../rust-analyzer/crates/hir/src/display.rs   | 16 ++--
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 32 +++----
 .../crates/hir/src/source_analyzer.rs         |  5 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  4 +-
 26 files changed, 134 insertions(+), 161 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs b/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
index 0b8f65687218..e3e1aac7090a 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/attrs.rs
@@ -894,7 +894,7 @@ pub fn query_generic_params(
         def: GenericDefId,
     ) -> &(ArenaMap<LocalLifetimeParamId, AttrFlags>, ArenaMap<LocalTypeOrConstParamId, AttrFlags>)
     {
-        let generic_params = GenericParams::new(db, def);
+        let generic_params = GenericParams::of(db, def);
         let params_count_excluding_self =
             generic_params.len() - usize::from(generic_params.trait_self_param().is_some());
         if params_count_excluding_self == 0 {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index 9c7f4943db97..0451523390e3 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -10,12 +10,11 @@
 use crate::{
     AnonConstId, AnonConstLoc, AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc,
     EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
-    ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id,
-    Macro2Loc, MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags,
-    ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
-    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
+    ExternCrateLoc, FunctionId, FunctionLoc, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc,
+    MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId,
+    ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
+    TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
     attrs::AttrFlags,
-    hir::generics::GenericParams,
     import_map::ImportMap,
     item_tree::{ItemTree, file_item_tree_query},
     nameres::crate_def_map,
@@ -98,10 +97,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(macro_def)]
     fn macro_def(&self, m: MacroId) -> MacroDefId;
 
-    #[salsa::transparent]
-    #[salsa::invoke(GenericParams::new)]
-    fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
-
     #[salsa::invoke(ImportMap::import_map_query)]
     fn import_map(&self, krate: Crate) -> Arc<ImportMap>;
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index 3ed1b587411c..de1f7463afbe 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -28,7 +28,6 @@
     },
 };
 use thin_vec::ThinVec;
-use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
@@ -201,7 +200,7 @@ pub(crate) fn lower_generic_params(
     file_id: HirFileId,
     param_list: Option<ast::GenericParamList>,
     where_clause: Option<ast::WhereClause>,
-) -> (ExpressionStore, Arc<GenericParams>, ExpressionStoreSourceMap) {
+) -> (ExpressionStore, GenericParams, ExpressionStoreSourceMap) {
     let mut expr_collector = ExprCollector::signature(db, module, file_id);
     let mut collector = generics::GenericParamsCollector::new(def);
     collector.lower(&mut expr_collector, param_list, where_clause);
@@ -215,7 +214,7 @@ pub(crate) fn lower_impl(
     module: ModuleId,
     impl_syntax: InFile<ast::Impl>,
     impl_id: ImplId,
-) -> (ExpressionStore, ExpressionStoreSourceMap, TypeRefId, Option<TraitRef>, Arc<GenericParams>) {
+) -> (ExpressionStore, ExpressionStoreSourceMap, TypeRefId, Option<TraitRef>, GenericParams) {
     let mut expr_collector = ExprCollector::signature(db, module, impl_syntax.file_id);
     let self_ty =
         expr_collector.lower_type_ref_opt_disallow_impl_trait(impl_syntax.value.self_ty());
@@ -243,7 +242,7 @@ pub(crate) fn lower_trait(
     module: ModuleId,
     trait_syntax: InFile<ast::Trait>,
     trait_id: TraitId,
-) -> (ExpressionStore, ExpressionStoreSourceMap, Arc<GenericParams>) {
+) -> (ExpressionStore, ExpressionStoreSourceMap, GenericParams) {
     let mut expr_collector = ExprCollector::signature(db, module, trait_syntax.file_id);
     let mut collector = generics::GenericParamsCollector::with_self_param(
         &mut expr_collector,
@@ -265,13 +264,8 @@ pub(crate) fn lower_type_alias(
     module: ModuleId,
     alias: InFile<ast::TypeAlias>,
     type_alias_id: TypeAliasId,
-) -> (
-    ExpressionStore,
-    ExpressionStoreSourceMap,
-    Arc<GenericParams>,
-    Box<[TypeBound]>,
-    Option<TypeRefId>,
-) {
+) -> (ExpressionStore, ExpressionStoreSourceMap, GenericParams, Box<[TypeBound]>, Option<TypeRefId>)
+{
     let mut expr_collector = ExprCollector::signature(db, module, alias.file_id);
     let bounds = alias
         .value
@@ -308,7 +302,7 @@ pub(crate) fn lower_function(
 ) -> (
     ExpressionStore,
     ExpressionStoreSourceMap,
-    Arc<GenericParams>,
+    GenericParams,
     Box<[TypeRefId]>,
     Option<TypeRefId>,
     bool,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
index 03de7937bad3..7c7b6971647e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
@@ -3,15 +3,12 @@
 //! generic parameters. See also the `Generics` type and the `generics_of` query
 //! in rustc.
 
-use std::sync::LazyLock;
-
 use either::Either;
 use hir_expand::name::{AsName, Name};
 use intern::sym;
 use la_arena::Arena;
 use syntax::ast::{self, HasName, HasTypeBounds};
 use thin_vec::ThinVec;
-use triomphe::Arc;
 
 use crate::{
     GenericDefId, TypeOrConstParamId, TypeParamId,
@@ -84,28 +81,16 @@ pub(crate) fn collect_impl_trait<R>(
         )
     }
 
-    pub(crate) fn finish(self) -> Arc<GenericParams> {
-        let Self { mut lifetimes, mut type_or_consts, mut where_predicates, parent: _ } = self;
-
-        if lifetimes.is_empty() && type_or_consts.is_empty() && where_predicates.is_empty() {
-            static EMPTY: LazyLock<Arc<GenericParams>> = LazyLock::new(|| {
-                Arc::new(GenericParams {
-                    lifetimes: Arena::new(),
-                    type_or_consts: Arena::new(),
-                    where_predicates: Box::default(),
-                })
-            });
-            return Arc::clone(&EMPTY);
-        }
+    pub(crate) fn finish(self) -> GenericParams {
+        let Self { mut lifetimes, mut type_or_consts, where_predicates, parent: _ } = self;
 
         lifetimes.shrink_to_fit();
         type_or_consts.shrink_to_fit();
-        where_predicates.shrink_to_fit();
-        Arc::new(GenericParams {
+        GenericParams {
             type_or_consts,
             lifetimes,
             where_predicates: where_predicates.into_boxed_slice(),
-        })
+        }
     }
 
     fn lower_param_list(&mut self, ec: &mut ExprCollector<'_>, params: ast::GenericParamList) {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
index 405ebe9b7bc9..39e0153ded37 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
@@ -1212,7 +1212,7 @@ pub(crate) fn print_generic_arg(&mut self, arg: &GenericArg) {
     }
 
     pub(crate) fn print_type_param(&mut self, param: TypeParamId) {
-        let generic_params = self.db.generic_params(param.parent());
+        let generic_params = GenericParams::of(self.db, param.parent());
 
         match generic_params[param.local_id()].name() {
             Some(name) => w!(self, "{}", name.display(self.db, self.edition)),
@@ -1221,7 +1221,7 @@ pub(crate) fn print_type_param(&mut self, param: TypeParamId) {
     }
 
     pub(crate) fn print_lifetime_param(&mut self, param: LifetimeParamId) {
-        let generic_params = self.db.generic_params(param.parent);
+        let generic_params = GenericParams::of(self.db, param.parent);
         w!(self, "{}", generic_params[param.local_id].name.display(self.db, self.edition))
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
index 2250cf5f1638..22a3a7b07900 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
@@ -64,7 +64,7 @@ pub fn body_expr_scopes(db: &dyn DefDatabase, def: DefWithBodyId) -> ExprScopes
 
     #[salsa::tracked(returns(ref))]
     pub fn sig_expr_scopes(db: &dyn DefDatabase, def: GenericDefId) -> ExprScopes {
-        let (_, store) = GenericParams::of(db, def);
+        let (_, store) = GenericParams::with_store(db, def);
         let roots = store.signature_const_expr_roots();
         let mut scopes = ExprScopes::new_store(store, roots);
         scopes.shrink_to_fit();
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
index 41767131fc3b..43dd7d1c54cd 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
@@ -5,7 +5,6 @@
 use la_arena::{Arena, Idx, RawIdx};
 use stdx::impl_from;
 use thin_vec::ThinVec;
-use triomphe::Arc;
 
 use crate::{
     AdtId, ConstParamId, GenericDefId, LifetimeParamId, TypeOrConstParamId, TypeParamId,
@@ -146,7 +145,7 @@ pub enum GenericParamDataRef<'a> {
 }
 
 /// Data about the generic parameters of a function, struct, impl, etc.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+#[derive(PartialEq, Eq, Debug, Hash, Default)]
 pub struct GenericParams {
     pub(crate) type_or_consts: Arena<TypeOrConstParamData>,
     pub(crate) lifetimes: Arena<LifetimeParamData>,
@@ -178,12 +177,10 @@ pub enum WherePredicate {
     ForLifetime { lifetimes: ThinVec<Name>, target: TypeRefId, bound: TypeBound },
 }
 
-static EMPTY: LazyLock<Arc<GenericParams>> = LazyLock::new(|| {
-    Arc::new(GenericParams {
-        type_or_consts: Arena::default(),
-        lifetimes: Arena::default(),
-        where_predicates: Box::default(),
-    })
+static EMPTY: LazyLock<GenericParams> = LazyLock::new(|| GenericParams {
+    type_or_consts: Arena::default(),
+    lifetimes: Arena::default(),
+    where_predicates: Box::default(),
 });
 
 impl GenericParams {
@@ -191,47 +188,50 @@ impl GenericParams {
     pub const SELF_PARAM_ID_IN_SELF: la_arena::Idx<TypeOrConstParamData> =
         LocalTypeOrConstParamId::from_raw(RawIdx::from_u32(0));
 
-    pub fn new(db: &dyn DefDatabase, def: GenericDefId) -> Arc<GenericParams> {
-        Self::of(db, def).0
+    pub fn of(db: &dyn DefDatabase, def: GenericDefId) -> &GenericParams {
+        Self::with_store(db, def).0
     }
 
-    pub fn of(db: &dyn DefDatabase, def: GenericDefId) -> (Arc<GenericParams>, &ExpressionStore) {
+    pub fn with_store(
+        db: &dyn DefDatabase,
+        def: GenericDefId,
+    ) -> (&GenericParams, &ExpressionStore) {
         match def {
             GenericDefId::AdtId(AdtId::EnumId(id)) => {
                 let sig = EnumSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
+                (&sig.generic_params, &sig.store)
             }
             GenericDefId::AdtId(AdtId::StructId(id)) => {
                 let sig = StructSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
+                (&sig.generic_params, &sig.store)
             }
             GenericDefId::AdtId(AdtId::UnionId(id)) => {
                 let sig = UnionSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
-            }
-            GenericDefId::FunctionId(id) => {
-                let sig = FunctionSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
-            }
-            GenericDefId::ImplId(id) => {
-                let sig = ImplSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
-            }
-            GenericDefId::TraitId(id) => {
-                let sig = TraitSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
-            }
-            GenericDefId::TypeAliasId(id) => {
-                let sig = TypeAliasSignature::of(db, id);
-                (sig.generic_params.clone(), &sig.store)
+                (&sig.generic_params, &sig.store)
             }
             GenericDefId::ConstId(id) => {
                 let sig = ConstSignature::of(db, id);
-                (EMPTY.clone(), &sig.store)
+                (&EMPTY, &sig.store)
+            }
+            GenericDefId::FunctionId(id) => {
+                let sig = FunctionSignature::of(db, id);
+                (&sig.generic_params, &sig.store)
+            }
+            GenericDefId::ImplId(id) => {
+                let sig = ImplSignature::of(db, id);
+                (&sig.generic_params, &sig.store)
             }
             GenericDefId::StaticId(id) => {
                 let sig = StaticSignature::of(db, id);
-                (EMPTY.clone(), &sig.store)
+                (&EMPTY, &sig.store)
+            }
+            GenericDefId::TraitId(id) => {
+                let sig = TraitSignature::of(db, id);
+                (&sig.generic_params, &sig.store)
+            }
+            GenericDefId::TypeAliasId(id) => {
+                let sig = TypeAliasSignature::of(db, id);
+                (&sig.generic_params, &sig.store)
             }
         }
     }
@@ -239,43 +239,43 @@ pub fn of(db: &dyn DefDatabase, def: GenericDefId) -> (Arc<GenericParams>, &Expr
     pub fn with_source_map(
         db: &dyn DefDatabase,
         def: GenericDefId,
-    ) -> (Arc<GenericParams>, &ExpressionStore, &ExpressionStoreSourceMap) {
+    ) -> (&GenericParams, &ExpressionStore, &ExpressionStoreSourceMap) {
         match def {
             GenericDefId::AdtId(AdtId::EnumId(id)) => {
                 let (sig, sm) = EnumSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::AdtId(AdtId::StructId(id)) => {
                 let (sig, sm) = StructSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::AdtId(AdtId::UnionId(id)) => {
                 let (sig, sm) = UnionSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::ConstId(id) => {
                 let (sig, sm) = ConstSignature::with_source_map(db, id);
-                (EMPTY.clone(), &sig.store, sm)
+                (&EMPTY, &sig.store, sm)
             }
             GenericDefId::FunctionId(id) => {
                 let (sig, sm) = FunctionSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::ImplId(id) => {
                 let (sig, sm) = ImplSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::StaticId(id) => {
                 let (sig, sm) = StaticSignature::with_source_map(db, id);
-                (EMPTY.clone(), &sig.store, sm)
+                (&EMPTY, &sig.store, sm)
             }
             GenericDefId::TraitId(id) => {
                 let (sig, sm) = TraitSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
             GenericDefId::TypeAliasId(id) => {
                 let (sig, sm) = TypeAliasSignature::with_source_map(db, id);
-                (sig.generic_params.clone(), &sig.store, sm)
+                (&sig.generic_params, &sig.store, sm)
             }
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 9ffa80346c2f..1a0e6a46f174 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -13,7 +13,6 @@
 use smallvec::{SmallVec, smallvec};
 use span::SyntaxContext;
 use syntax::ast::HasName;
-use triomphe::Arc;
 
 use crate::{
     AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
@@ -87,7 +86,7 @@ enum Scope<'db> {
     BlockScope(ModuleItemMap<'db>),
     /// Brings the generic parameters of an item into scope as well as the `Self` type alias /
     /// generic for ADTs and impls.
-    GenericParams { def: GenericDefId, params: Arc<GenericParams> },
+    GenericParams { def: GenericDefId, params: &'db GenericParams },
     /// Local bindings
     ExprScope(ExprScope<'db>),
     /// Macro definition inside bodies that affects all paths after it in the same block.
@@ -725,14 +724,14 @@ pub fn generic_def(&self) -> Option<GenericDefId> {
 
     pub fn generic_params(&self) -> Option<&GenericParams> {
         self.scopes().find_map(|scope| match scope {
-            Scope::GenericParams { params, .. } => Some(&**params),
+            &Scope::GenericParams { params, .. } => Some(params),
             _ => None,
         })
     }
 
-    pub fn all_generic_params(&self) -> impl Iterator<Item = (&GenericParams, &GenericDefId)> {
+    pub fn all_generic_params(&self) -> impl Iterator<Item = (&GenericParams, GenericDefId)> {
         self.scopes().filter_map(|scope| match scope {
-            Scope::GenericParams { params, def } => Some((&**params, def)),
+            &Scope::GenericParams { params, def } => Some((params, def)),
             _ => None,
         })
     }
@@ -1031,7 +1030,7 @@ fn process_names(&self, acc: &mut ScopeNames, db: &'db dyn DefDatabase) {
                 for (local_id, param) in params.iter_type_or_consts() {
                     if let Some(name) = &param.name() {
                         let id = TypeOrConstParamId { parent, local_id };
-                        let data = &db.generic_params(parent)[local_id];
+                        let data = &GenericParams::of(db, parent)[local_id];
                         acc.add(
                             name,
                             ScopeDef::GenericParam(match data {
@@ -1115,7 +1114,7 @@ fn push_generic_params_scope(
         db: &'db dyn DefDatabase,
         def: GenericDefId,
     ) -> Resolver<'db> {
-        let params = db.generic_params(def);
+        let params = GenericParams::of(db, def);
         self.push_scope(Scope::GenericParams { def, params })
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 7862049f993e..c16ca6d0b432 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -43,7 +43,7 @@ fn as_name_opt(name: Option<ast::Name>) -> Name {
 #[derive(Debug, PartialEq, Eq)]
 pub struct StructSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub flags: StructFlags,
     pub shape: FieldsShape,
@@ -153,7 +153,7 @@ fn adt_shape(adt_kind: ast::StructKind) -> FieldsShape {
 #[derive(Debug, PartialEq, Eq)]
 pub struct UnionSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub flags: StructFlags,
 }
@@ -217,7 +217,7 @@ pub struct EnumFlags: u8 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct EnumSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub flags: EnumFlags,
 }
@@ -290,7 +290,7 @@ pub struct ConstFlags: u8 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct ConstSignature {
     pub name: Option<Name>,
-    // generic_params: Arc<GenericParams>,
+    // generic_params: GenericParams,
     pub store: ExpressionStore,
     pub type_ref: TypeRefId,
     pub flags: ConstFlags,
@@ -358,7 +358,7 @@ pub struct StaticFlags: u8 {
 pub struct StaticSignature {
     pub name: Name,
 
-    // generic_params: Arc<GenericParams>,
+    // generic_params: GenericParams,
     pub store: ExpressionStore,
     pub type_ref: TypeRefId,
     pub flags: StaticFlags,
@@ -429,7 +429,7 @@ pub struct ImplFlags: u8 {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct ImplSignature {
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub self_ty: TypeRefId,
     pub target_trait: Option<TraitRef>,
@@ -502,7 +502,7 @@ pub struct TraitFlags: u16 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct TraitSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub flags: TraitFlags,
 }
@@ -586,7 +586,7 @@ pub struct FnFlags: u16 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct FunctionSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub params: Box<[TypeRefId]>,
     pub ret_type: Option<TypeRefId>,
@@ -762,7 +762,7 @@ pub struct TypeAliasFlags: u8 {
 #[derive(Debug, PartialEq, Eq)]
 pub struct TypeAliasSignature {
     pub name: Name,
-    pub generic_params: Arc<GenericParams>,
+    pub generic_params: GenericParams,
     pub store: ExpressionStore,
     pub bounds: Box<[TypeBound]>,
     pub ty: Option<TypeRefId>,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/src.rs b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
index 6fe016f1e680..e33fd95908b9 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/src.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
@@ -7,7 +7,7 @@
 
 use crate::{
     AstIdLoc, GenericDefId, LocalFieldId, LocalLifetimeParamId, LocalTypeOrConstParamId, Lookup,
-    UseId, VariantId, attrs::AttrFlags, db::DefDatabase,
+    UseId, VariantId, attrs::AttrFlags, db::DefDatabase, hir::generics::GenericParams,
 };
 
 pub trait HasSource {
@@ -76,7 +76,7 @@ fn child_source(
         &self,
         db: &dyn DefDatabase,
     ) -> InFile<ArenaMap<LocalTypeOrConstParamId, Self::Value>> {
-        let generic_params = db.generic_params(*self);
+        let generic_params = GenericParams::of(db, *self);
         let mut idx_iter = generic_params.iter_type_or_consts().map(|(idx, _)| idx);
 
         let (file_id, generic_params_list) = self.file_id_and_params_of(db);
@@ -110,7 +110,7 @@ fn child_source(
         &self,
         db: &dyn DefDatabase,
     ) -> InFile<ArenaMap<LocalLifetimeParamId, Self::Value>> {
-        let generic_params = db.generic_params(*self);
+        let generic_params = GenericParams::of(db, *self);
         let idx_iter = generic_params.iter_lt().map(|(idx, _)| idx);
 
         let (file_id, generic_params_list) = self.file_id_and_params_of(db);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
index 5a93c2b53606..6cdc07e430b6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
@@ -80,7 +80,7 @@ pub(crate) fn generics_of<'db>(interner: DbInterner<'db>, id: BuiltinDeriveImplI
 
 pub fn generic_params_count(db: &dyn HirDatabase, id: BuiltinDeriveImplId) -> usize {
     let loc = id.loc(db);
-    let adt_params = GenericParams::new(db, loc.adt.into());
+    let adt_params = GenericParams::of(db, loc.adt.into());
     let extra_params_count = match loc.trait_ {
         BuiltinDeriveImplTrait::Copy
         | BuiltinDeriveImplTrait::Clone
@@ -128,7 +128,7 @@ pub fn impl_trait<'db>(
             ))
         }
         BuiltinDeriveImplTrait::CoerceUnsized | BuiltinDeriveImplTrait::DispatchFromDyn => {
-            let generic_params = GenericParams::new(db, loc.adt.into());
+            let generic_params = GenericParams::of(db, loc.adt.into());
             let interner = DbInterner::new_no_crate(db);
             let args = GenericArgs::identity_for_item(interner, loc.adt.into());
             let self_ty = Ty::new_adt(interner, loc.adt, args);
@@ -152,7 +152,7 @@ pub fn impl_trait<'db>(
 #[salsa::tracked(returns(ref))]
 pub fn predicates<'db>(db: &'db dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPredicates {
     let loc = impl_.loc(db);
-    let generic_params = GenericParams::new(db, loc.adt.into());
+    let generic_params = GenericParams::of(db, loc.adt.into());
     let interner = DbInterner::new_with(db, loc.module(db).krate(db));
     let adt_predicates = GenericPredicates::query(db, loc.adt.into());
     let trait_id = loc
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index 54cd750de6c8..d68058864564 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -14,7 +14,7 @@
     Lookup, ModuleDefId, ModuleId, TraitId,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
-    hir::generics::{TypeOrConstParamData, TypeParamProvenance, WherePredicate},
+    hir::generics::{GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate},
     item_scope::ItemInNs,
     item_tree::FieldsShape,
     lang_item::LangItems,
@@ -2141,7 +2141,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>, store: &ExpressionStore) -> Res
             LifetimeRef::Placeholder => write!(f, "'_"),
             LifetimeRef::Error => write!(f, "'{{error}}"),
             &LifetimeRef::Param(lifetime_param_id) => {
-                let generic_params = f.db.generic_params(lifetime_param_id.parent);
+                let generic_params = GenericParams::of(f.db, lifetime_param_id.parent);
                 write!(
                     f,
                     "{}",
@@ -2157,7 +2157,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>, store: &ExpressionStore) -> Res
         match &store[*self] {
             TypeRef::Never => write!(f, "!")?,
             TypeRef::TypeParam(param) => {
-                let generic_params = f.db.generic_params(param.parent());
+                let generic_params = GenericParams::of(f.db, param.parent());
                 match generic_params[param.local_id()].name() {
                     Some(name) => write!(f, "{}", name.display(f.db, f.edition()))?,
                     None => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index d8093b3eb1c8..4c300affd8a2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -5,7 +5,7 @@
 use hir_def::{
     AssocItemId, ConstId, FunctionId, GenericDefId, HasModule, TraitId, TypeAliasId,
     TypeOrConstParamId, TypeParamId,
-    hir::generics::LocalTypeOrConstParamId,
+    hir::generics::{GenericParams, LocalTypeOrConstParamId},
     nameres::crate_def_map,
     signatures::{FunctionSignature, TraitFlags, TraitSignature},
 };
@@ -300,7 +300,7 @@ fn dyn_compatibility_violation_for_assoc_item<F>(
             if def_map.is_unstable_feature_enabled(&intern::sym::generic_associated_type_extended) {
                 ControlFlow::Continue(())
             } else {
-                let generic_params = db.generic_params(item.into());
+                let generic_params = GenericParams::of(db, item.into());
                 if !generic_params.is_empty() {
                     cb(DynCompatibilityViolation::GAT(it))
                 } else {
@@ -351,7 +351,7 @@ fn virtual_call_violations_for_method<F>(
         cb(mvc)?;
     }
 
-    let generic_params = db.generic_params(func.into());
+    let generic_params = GenericParams::of(db, func.into());
     if generic_params.len_type_or_consts() > 0 {
         cb(MethodViolationCode::Generic)?;
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index 57fe4d749b2d..822942eec37d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -20,18 +20,17 @@
     },
 };
 use itertools::chain;
-use triomphe::Arc;
 
 pub fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics<'_> {
     let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def)));
-    let (params, store) = GenericParams::of(db, def);
+    let (params, store) = GenericParams::with_store(db, def);
     let has_trait_self_param = params.trait_self_param().is_some();
     Generics { def, params, parent_generics, has_trait_self_param, store }
 }
 #[derive(Clone, Debug)]
 pub struct Generics<'db> {
     def: GenericDefId,
-    params: Arc<GenericParams>,
+    params: &'db GenericParams,
     store: &'db ExpressionStore,
     parent_generics: Option<Box<Generics<'db>>>,
     has_trait_self_param: bool,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 3ed563315e5e..5eee025f2c00 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1590,7 +1590,7 @@ pub(crate) fn const_param_ty_with_diagnostics_query<'db>(
         _: (),
         def: ConstParamId,
     ) -> (StoredTy, Diagnostics) {
-        let (parent_data, store) = GenericParams::of(db, def.parent());
+        let (parent_data, store) = GenericParams::with_store(db, def.parent());
         let data = &parent_data[def.local_id()];
         let resolver = def.parent().resolver(db);
         let interner = DbInterner::new_no_crate(db);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index e058a254205e..05b9ea5d748f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -18,7 +18,7 @@
     attrs::AttrFlags,
     builtin_derive::BuiltinDeriveImplMethod,
     expr_store::{Body, path::GenericArgs as HirGenericArgs},
-    hir::ExprId,
+    hir::{ExprId, generics::GenericParams},
     lang_item::LangItems,
     nameres::{DefMap, block_def_map, crate_def_map},
     resolver::Resolver,
@@ -397,7 +397,7 @@ pub fn is_dyn_method<'db>(
     let ItemContainerId::TraitId(trait_id) = func.loc(db).container else {
         return None;
     };
-    let trait_params = db.generic_params(trait_id.into()).len();
+    let trait_params = GenericParams::of(db, trait_id.into()).len();
     let fn_params = fn_subst.len() - trait_params;
     let trait_ref = TraitRef::new_from_args(
         interner,
@@ -433,7 +433,7 @@ pub(crate) fn lookup_impl_method_query<'db>(
     let ItemContainerId::TraitId(trait_id) = func.loc(db).container else {
         return (Either::Left(func), fn_subst);
     };
-    let trait_params = db.generic_params(trait_id.into()).len();
+    let trait_params = GenericParams::of(db, trait_id.into()).len();
     let trait_ref = TraitRef::new_from_args(
         interner,
         trait_id.into(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
index e2a53cc830e3..8c76bfbc076b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution/probe.rs
@@ -5,6 +5,7 @@
 
 use hir_def::{
     AssocItemId, FunctionId, GenericParamId, ImplId, ItemContainerId, TraitId,
+    hir::generics::GenericParams,
     signatures::{FunctionSignature, TraitFlags, TraitSignature},
 };
 use hir_expand::name::Name;
@@ -2010,7 +2011,7 @@ fn xform_method_sig(&self, method: FunctionId, args: &[GenericArg<'db>]) -> FnSi
         // we are given do not include type/lifetime parameters for the
         // method yet. So create fresh variables here for those too,
         // if there are any.
-        let generics = self.db().generic_params(method.into());
+        let generics = GenericParams::of(self.db(), method.into());
 
         let xform_fn_sig = if generics.is_empty() {
             fn_sig.instantiate(self.interner(), args)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 8d85e2412f3b..675fc371c619 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -9,7 +9,7 @@
     expr_store::{Body, ExpressionStore, HygieneId, path::Path},
     hir::{
         ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm,
-        Pat, PatId, RecordFieldPat, RecordLitField, RecordSpread,
+        Pat, PatId, RecordFieldPat, RecordLitField, RecordSpread, generics::GenericParams,
     },
     item_tree::FieldsShape,
     lang_item::LangItems,
@@ -203,13 +203,13 @@ pub fn pretty_print(
             MirLowerError::GenericArgNotProvided(id, subst) => {
                 let param_name = match *id {
                     GenericParamId::TypeParamId(id) => {
-                        db.generic_params(id.parent())[id.local_id()].name().cloned()
+                        GenericParams::of(db, id.parent())[id.local_id()].name().cloned()
                     }
                     GenericParamId::ConstParamId(id) => {
-                        db.generic_params(id.parent())[id.local_id()].name().cloned()
+                        GenericParams::of(db, id.parent())[id.local_id()].name().cloned()
                     }
                     GenericParamId::LifetimeParamId(id) => {
-                        Some(db.generic_params(id.parent)[id.local_id].name.clone())
+                        Some(GenericParams::of(db, id.parent)[id.local_id].name.clone())
                     }
                 };
                 writeln!(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
index a8288b4e8259..f31de21796fe 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
@@ -55,7 +55,7 @@ pub(crate) fn generics(interner: DbInterner<'_>, def: SolverDefId) -> Generics {
     let (parent, own_params) = match (def.try_into(), def) {
         (Ok(def), _) => (
             parent_generic_def(db, def),
-            own_params_for_generic_params(def, &db.generic_params(def)),
+            own_params_for_generic_params(def, GenericParams::of(db, def)),
         ),
         (_, SolverDefId::InternedOpaqueTyId(id)) => {
             match db.lookup_intern_impl_trait_id(id) {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 09b1585866b0..192cdb70aee5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -4,7 +4,7 @@
 
 use hir_def::{
     AdtId, HasModule, TypeParamId,
-    hir::generics::{TypeOrConstParamData, TypeParamProvenance},
+    hir::generics::{GenericParams, TypeOrConstParamData, TypeParamProvenance},
 };
 use hir_def::{TraitId, type_ref::Rawness};
 use intern::{Interned, InternedRef, impl_internable};
@@ -690,7 +690,7 @@ pub fn impl_trait_bounds(self, db: &'db dyn HirDatabase) -> Option<Vec<Clause<'d
             ),
             TyKind::Param(param) => {
                 // FIXME: We shouldn't use `param.id` here.
-                let generic_params = db.generic_params(param.id.parent());
+                let generic_params = GenericParams::of(db, param.id.parent());
                 let param_data = &generic_params[param.id.local_id()];
                 match param_data {
                     TypeOrConstParamData::TypeParamData(p) => match p.provenance {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/representability.rs b/src/tools/rust-analyzer/crates/hir-ty/src/representability.rs
index 7e40f2d7ac75..bae204c4ef7c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/representability.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/representability.rs
@@ -1,6 +1,6 @@
 //! Detecting whether a type is infinitely-sized.
 
-use hir_def::{AdtId, VariantId};
+use hir_def::{AdtId, VariantId, hir::generics::GenericParams};
 use rustc_type_ir::inherent::{AdtDef, IntoKind};
 
 use crate::{
@@ -88,7 +88,7 @@ fn representability_adt_ty<'db>(
 }
 
 fn params_in_repr(db: &dyn HirDatabase, def_id: AdtId) -> Box<[bool]> {
-    let generics = db.generic_params(def_id.into());
+    let generics = GenericParams::of(db, def_id.into());
     let mut params_in_repr = (0..generics.len_lifetimes() + generics.len_type_or_consts())
         .map(|_| false)
         .collect::<Box<[bool]>>();
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index cfb95e07c362..4efb7fcb6f2b 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -7,6 +7,7 @@
     TraitId, TypeOrConstParamId,
     attrs::{AttrFlags, Docs, IsInnerDoc},
     expr_store::path::Path,
+    hir::generics::GenericParams,
     item_scope::ItemInNs,
     per_ns::Namespace,
     resolver::{HasResolver, Resolver, TypeNs},
@@ -377,7 +378,7 @@ fn resolve_assoc_or_field(
     let ty = match base_def {
         TypeNs::SelfType(id) => Impl::from(id).self_ty(db),
         TypeNs::GenericParam(param) => {
-            let generic_params = db.generic_params(param.parent());
+            let generic_params = GenericParams::of(db, param.parent());
             if generic_params[param.local_id()].is_trait_self() {
                 // `Self::assoc` in traits should refer to the trait itself.
                 let parent_trait = |container| match container {
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index 826b8d5f808c..aa34177b89a1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -41,7 +41,7 @@ fn write_builtin_derive_impl_method<'db>(
 ) -> Result {
     let db = f.db;
     let loc = impl_.loc(db);
-    let (adt_params, _adt_params_store) = GenericParams::of(db, loc.adt.into());
+    let adt_params = GenericParams::of(db, loc.adt.into());
 
     if f.show_container_bounds() && !adt_params.is_empty() {
         f.write_str("impl")?;
@@ -97,7 +97,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         // Write container (trait or impl)
         let container_params = match container {
             ItemContainerId::TraitId(trait_) => {
-                let (params, params_store) = GenericParams::of(f.db, trait_.into());
+                let (params, params_store) = GenericParams::with_store(f.db, trait_.into());
                 if f.show_container_bounds() && !params.is_empty() {
                     write_trait_header(trait_.into(), f)?;
                     f.write_char('\n')?;
@@ -108,7 +108,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 }
             }
             ItemContainerId::ImplId(impl_) => {
-                let (params, params_store) = GenericParams::of(f.db, impl_.into());
+                let (params, params_store) = GenericParams::with_store(f.db, impl_.into());
                 if f.show_container_bounds() && !params.is_empty() {
                     write_impl_header(impl_, f)?;
                     f.write_char('\n')?;
@@ -572,7 +572,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
 
 impl<'db> HirDisplay<'db> for TypeParam {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
-        let params = f.db.generic_params(self.id.parent());
+        let params = GenericParams::of(f.db, self.id.parent());
         let param_data = &params[self.id.local_id()];
         let krate = self.id.parent().krate(f.db).id;
         let ty = self.ty(f.db).ty;
@@ -660,7 +660,7 @@ fn write_generic_params_or_args<'db>(
     f: &mut HirFormatter<'_, 'db>,
     include_defaults: bool,
 ) -> Result {
-    let (params, store) = GenericParams::of(f.db, def);
+    let (params, store) = GenericParams::with_store(f.db, def);
     if params.iter_lt().next().is_none()
         && params.iter_type_or_consts().all(|it| it.1.const_param().is_none())
         && params
@@ -718,7 +718,7 @@ fn write_generic_params_or_args<'db>(
 }
 
 fn write_where_clause<'db>(def: GenericDefId, f: &mut HirFormatter<'_, 'db>) -> Result<bool> {
-    let (params, store) = GenericParams::of(f.db, def);
+    let (params, store) = GenericParams::with_store(f.db, def);
     if !has_disaplayable_predicates(f.db, &params, store) {
         return Ok(false);
     }
@@ -739,7 +739,7 @@ fn has_disaplayable_predicates(
             pred,
             WherePredicate::TypeBound { target, .. }
             if  matches!(store[*target],
-                TypeRef::TypeParam(id) if db.generic_params(id.parent())[id.local_id()].name().is_none()
+                TypeRef::TypeParam(id) if GenericParams::of(db,id.parent())[id.local_id()].name().is_none()
             )
         )
     })
@@ -755,7 +755,7 @@ fn write_where_predicates<'db>(
     // unnamed type targets are displayed inline with the argument itself, e.g. `f: impl Y`.
     let is_unnamed_type_target = |target: TypeRefId| {
         matches!(store[target],
-            TypeRef::TypeParam(id) if f.db.generic_params(id.parent())[id.local_id()].name().is_none()
+            TypeRef::TypeParam(id) if GenericParams::of(f.db,id.parent())[id.local_id()].name().is_none()
         )
     };
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 4d4482b1afa3..67527150bd45 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -58,7 +58,7 @@
     expr_store::{ExpressionStore, ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
     hir::{
         BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,
-        generics::{LifetimeParamData, TypeOrConstParamData, TypeParamProvenance},
+        generics::{GenericParams, LifetimeParamData, TypeOrConstParamData, TypeParamProvenance},
     },
     item_tree::ImportAlias,
     lang_item::LangItemTarget,
@@ -3275,7 +3275,7 @@ pub fn type_or_const_param_count(
         db: &dyn HirDatabase,
         count_required_only: bool,
     ) -> usize {
-        db.generic_params(self.id.into())
+        GenericParams::of(db,self.id.into())
             .iter_type_or_consts()
             .filter(|(_, ty)| !matches!(ty, TypeOrConstParamData::TypeParamData(ty) if ty.provenance != TypeParamProvenance::TypeParamList))
             .filter(|(_, ty)| !count_required_only || !ty.has_default())
@@ -4065,7 +4065,7 @@ pub fn params(self, db: &dyn HirDatabase) -> Vec<GenericParam> {
             // Let's pretend builtin derive impls don't have generic parameters.
             return Vec::new();
         };
-        let generics = db.generic_params(id);
+        let generics = GenericParams::of(db, id);
         let ty_params = generics.iter_type_or_consts().map(|(local_id, _)| {
             let toc = TypeOrConstParam { id: TypeOrConstParamId { parent: id, local_id } };
             match toc.split(db) {
@@ -4085,7 +4085,7 @@ pub fn lifetime_params(self, db: &dyn HirDatabase) -> Vec<LifetimeParam> {
             // Let's pretend builtin derive impls don't have generic parameters.
             return Vec::new();
         };
-        let generics = db.generic_params(id);
+        let generics = GenericParams::of(db, id);
         generics
             .iter_lt()
             .map(|(local_id, _)| LifetimeParam { id: LifetimeParamId { parent: id, local_id } })
@@ -4097,7 +4097,7 @@ pub fn type_or_const_params(self, db: &dyn HirDatabase) -> Vec<TypeOrConstParam>
             // Let's pretend builtin derive impls don't have generic parameters.
             return Vec::new();
         };
-        let generics = db.generic_params(id);
+        let generics = GenericParams::of(db, id);
         generics
             .iter_type_or_consts()
             .map(|(local_id, _)| TypeOrConstParam {
@@ -4127,7 +4127,7 @@ fn id(self) -> Option<GenericDefId> {
     pub fn diagnostics<'db>(self, db: &'db dyn HirDatabase, acc: &mut Vec<AnyDiagnostic<'db>>) {
         let Some(def) = self.id() else { return };
 
-        let generics = db.generic_params(def);
+        let generics = GenericParams::of(db, def);
 
         if generics.is_empty() && generics.has_no_predicates() {
             return;
@@ -4223,7 +4223,7 @@ pub fn types(&self, db: &'db dyn HirDatabase) -> Vec<(Symbol, Type<'db>)> {
                 _ => None,
             })
             .map(|container| {
-                db.generic_params(container)
+                GenericParams::of(db, container)
                     .iter_type_or_consts()
                     .filter_map(|param| match param.1 {
                         TypeOrConstParamData::TypeParamData(param) => Some(param.name.clone()),
@@ -4231,7 +4231,7 @@ pub fn types(&self, db: &'db dyn HirDatabase) -> Vec<(Symbol, Type<'db>)> {
                     })
                     .collect::<Vec<_>>()
             });
-        let generics = db.generic_params(self.def);
+        let generics = GenericParams::of(db, self.def);
         let type_params = generics.iter_type_or_consts().filter_map(|param| match param.1 {
             TypeOrConstParamData::TypeParamData(param) => Some(param.name.clone()),
             TypeOrConstParamData::ConstParamData(_) => None,
@@ -4653,7 +4653,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
     /// Is this type parameter implicitly introduced (eg. `Self` in a trait or an `impl Trait`
     /// argument)?
     pub fn is_implicit(self, db: &dyn HirDatabase) -> bool {
-        let params = db.generic_params(self.id.parent());
+        let params = GenericParams::of(db, self.id.parent());
         let data = &params[self.id.local_id()];
         match data.type_param().unwrap().provenance {
             TypeParamProvenance::TypeParamList => false,
@@ -4708,7 +4708,7 @@ pub struct LifetimeParam {
 
 impl LifetimeParam {
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let params = db.generic_params(self.id.parent);
+        let params = GenericParams::of(db, self.id.parent);
         params[self.id.local_id].name.clone()
     }
 
@@ -4732,7 +4732,7 @@ pub fn merge(self) -> TypeOrConstParam {
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let params = db.generic_params(self.id.parent());
+        let params = GenericParams::of(db, self.id.parent());
         match params[self.id.local_id()].name() {
             Some(it) => it.clone(),
             None => {
@@ -4779,7 +4779,7 @@ pub struct TypeOrConstParam {
 
 impl TypeOrConstParam {
     pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let params = db.generic_params(self.id.parent);
+        let params = GenericParams::of(db, self.id.parent);
         match params[self.id.local_id].name() {
             Some(n) => n.clone(),
             _ => Name::missing(),
@@ -4795,7 +4795,7 @@ pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {
     }
 
     pub fn split(self, db: &dyn HirDatabase) -> Either<ConstParam, TypeParam> {
-        let params = db.generic_params(self.id.parent);
+        let params = GenericParams::of(db, self.id.parent);
         match &params[self.id.local_id] {
             TypeOrConstParamData::TypeParamData(_) => {
                 Either::Right(TypeParam { id: TypeParamId::from_unchecked(self.id) })
@@ -4814,7 +4814,7 @@ pub fn ty(self, db: &dyn HirDatabase) -> Type<'_> {
     }
 
     pub fn as_type_param(self, db: &dyn HirDatabase) -> Option<TypeParam> {
-        let params = db.generic_params(self.id.parent);
+        let params = GenericParams::of(db, self.id.parent);
         match &params[self.id.local_id] {
             TypeOrConstParamData::TypeParamData(_) => {
                 Some(TypeParam { id: TypeParamId::from_unchecked(self.id) })
@@ -4824,7 +4824,7 @@ pub fn as_type_param(self, db: &dyn HirDatabase) -> Option<TypeParam> {
     }
 
     pub fn as_const_param(self, db: &dyn HirDatabase) -> Option<ConstParam> {
-        let params = db.generic_params(self.id.parent);
+        let params = GenericParams::of(db, self.id.parent);
         match &params[self.id.local_id] {
             TypeOrConstParamData::TypeParamData(_) => None,
             TypeOrConstParamData::ConstParamData(_) => {
@@ -7229,7 +7229,7 @@ fn generic_args_from_tys<'db>(
 }
 
 fn has_non_default_type_params(db: &dyn HirDatabase, generic_def: GenericDefId) -> bool {
-    let params = db.generic_params(generic_def);
+    let params = GenericParams::of(db, generic_def);
     let defaults = db.generic_defaults(generic_def);
     params
         .iter_type_or_consts()
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index bd77347e93eb..1b41c78892d6 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -55,7 +55,6 @@
     SyntaxKind, SyntaxNode, TextRange, TextSize,
     ast::{self, AstNode, RangeItem, RangeOp},
 };
-use triomphe::Arc;
 
 use crate::{
     Adt, AnyFunctionId, AssocItem, BindingMode, BuiltinAttr, BuiltinType, Callable, Const,
@@ -94,7 +93,7 @@ pub(crate) enum BodyOrSig<'db> {
         source_map: &'db ExpressionStoreSourceMap,
         infer: Option<&'db InferenceResult>,
         #[expect(dead_code)]
-        generics: Arc<GenericParams>,
+        generics: &'db GenericParams,
     },
 }
 
@@ -882,7 +881,7 @@ pub(crate) fn resolve_use_type_arg(&self, name: &ast::NameRef) -> Option<crate::
         let name = name.as_name();
         self.resolver
             .all_generic_params()
-            .find_map(|(params, parent)| params.find_type_by_name(&name, *parent))
+            .find_map(|(params, parent)| params.find_type_by_name(&name, parent))
             .map(crate::TypeParam::from)
     }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 43e73175c820..7541a41b20eb 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -18,7 +18,7 @@
 use hir_def::{
     DefWithBodyId, ExpressionStoreOwnerId, GenericDefId, SyntheticSyntax,
     expr_store::{Body, BodySourceMap, ExpressionStore},
-    hir::{ExprId, PatId},
+    hir::{ExprId, PatId, generics::GenericParams},
 };
 use hir_ty::InferenceResult;
 use ide::{
@@ -394,7 +394,7 @@ fn run_data_layout(&self, db: &RootDatabase, adts: &[hir::Adt], verbosity: Verbo
         let mut fail = 0;
         for &a in adts {
             let interner = DbInterner::new_no_crate(db);
-            let generic_params = db.generic_params(a.into());
+            let generic_params = GenericParams::of(db, a.into());
             if generic_params.iter_type_or_consts().next().is_some()
                 || generic_params.iter_lt().next().is_some()
             {

From da00358f75e149c91203273804032b41389019f3 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 28 Mar 2026 14:20:33 +0100
Subject: [PATCH 1012/1059] Remove `Arc` from `AstIdMap`

---
 .../rust-analyzer/crates/hir-def/src/db.rs    |  4 --
 .../crates/hir-def/src/expr_store/expander.rs | 33 +++++----
 .../crates/hir-def/src/expr_store/lower.rs    |  2 +-
 .../crates/hir-def/src/find_path.rs           |  3 +-
 .../crates/hir-def/src/import_map.rs          | 25 ++++---
 .../crates/hir-def/src/item_tree.rs           | 33 ++-------
 .../crates/hir-def/src/item_tree/lower.rs     | 15 ++--
 .../crates/hir-def/src/nameres/assoc.rs       | 17 +++--
 .../hir-def/src/nameres/tests/incremental.rs  | 68 +++++++++----------
 .../crates/hir-def/src/resolver.rs            |  2 +-
 .../rust-analyzer/crates/hir-expand/src/db.rs |  9 +--
 .../crates/hir-ty/src/builtin_derive.rs       |  8 +--
 .../crates/hir-ty/src/tests/incremental.rs    | 30 ++++----
 .../rust-analyzer/crates/hir/src/display.rs   | 10 +--
 .../crates/ide-db/src/prime_caches.rs         |  4 +-
 15 files changed, 121 insertions(+), 142 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index 0451523390e3..2f2889ec6611 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -15,7 +15,6 @@
     ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
     TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
     attrs::AttrFlags,
-    import_map::ImportMap,
     item_tree::{ItemTree, file_item_tree_query},
     nameres::crate_def_map,
     visibility::{self, Visibility},
@@ -97,9 +96,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(macro_def)]
     fn macro_def(&self, m: MacroId) -> MacroDefId;
 
-    #[salsa::invoke(ImportMap::import_map_query)]
-    fn import_map(&self, krate: Crate) -> Arc<ImportMap>;
-
     // region:visibilities
 
     #[salsa::invoke(visibility::field_visibilities_query)]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
index d34ec9bbc182..2fffa02c1314 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs
@@ -14,7 +14,6 @@
 use span::{AstIdMap, SyntaxContext};
 use syntax::ast::HasAttrs;
 use syntax::{AstNode, Parse, ast};
-use triomphe::Arc;
 use tt::TextRange;
 
 use crate::{
@@ -23,21 +22,21 @@
 };
 
 #[derive(Debug)]
-pub(super) struct Expander {
+pub(super) struct Expander<'db> {
     span_map: SpanMap,
     current_file_id: HirFileId,
-    ast_id_map: Arc<AstIdMap>,
+    ast_id_map: &'db AstIdMap,
     /// `recursion_depth == usize::MAX` indicates that the recursion limit has been reached.
     recursion_depth: u32,
     recursion_limit: usize,
 }
 
-impl Expander {
+impl<'db> Expander<'db> {
     pub(super) fn new(
-        db: &dyn DefDatabase,
+        db: &'db dyn DefDatabase,
         current_file_id: HirFileId,
-        def_map: &DefMap,
-    ) -> Expander {
+        def_map: &'db DefMap,
+    ) -> Expander<'db> {
         let recursion_limit = def_map.recursion_limit() as usize;
         let recursion_limit = if cfg!(test) {
             // Without this, `body::tests::your_stack_belongs_to_me` stack-overflows in debug
@@ -77,12 +76,12 @@ pub(super) fn is_cfg_enabled(
 
     pub(super) fn enter_expand<T: ast::AstNode>(
         &mut self,
-        db: &dyn DefDatabase,
+        db: &'db dyn DefDatabase,
         macro_call: ast::MacroCall,
         krate: Crate,
         resolver: impl Fn(&ModPath) -> Option<MacroId>,
         eager_callback: EagerCallBackFn<'_>,
-    ) -> Result<ExpandResult<Option<(Mark, Option<Parse<T>>)>>, UnresolvedMacro> {
+    ) -> Result<ExpandResult<Option<(Mark<'db>, Option<Parse<T>>)>>, UnresolvedMacro> {
         // FIXME: within_limit should support this, instead of us having to extract the error
         let mut unresolved_macro_err = None;
 
@@ -130,13 +129,13 @@ pub(super) fn enter_expand<T: ast::AstNode>(
 
     pub(super) fn enter_expand_id<T: ast::AstNode>(
         &mut self,
-        db: &dyn DefDatabase,
+        db: &'db dyn DefDatabase,
         call_id: MacroCallId,
-    ) -> ExpandResult<Option<(Mark, Option<Parse<T>>)>> {
+    ) -> ExpandResult<Option<(Mark<'db>, Option<Parse<T>>)>> {
         self.within_limit(db, |_this| ExpandResult::ok(Some(call_id)))
     }
 
-    pub(super) fn exit(&mut self, Mark { file_id, span_map, ast_id_map, mut bomb }: Mark) {
+    pub(super) fn exit(&mut self, Mark { file_id, span_map, ast_id_map, mut bomb }: Mark<'db>) {
         self.span_map = span_map;
         self.current_file_id = file_id;
         self.ast_id_map = ast_id_map;
@@ -162,9 +161,9 @@ pub(super) fn current_file_id(&self) -> HirFileId {
 
     fn within_limit<F, T: ast::AstNode>(
         &mut self,
-        db: &dyn DefDatabase,
+        db: &'db dyn DefDatabase,
         op: F,
-    ) -> ExpandResult<Option<(Mark, Option<Parse<T>>)>>
+    ) -> ExpandResult<Option<(Mark<'db>, Option<Parse<T>>)>>
     where
         F: FnOnce(&mut Self) -> ExpandResult<Option<MacroCallId>>,
     {
@@ -219,7 +218,7 @@ fn within_limit<F, T: ast::AstNode>(
 
     #[inline]
     pub(super) fn ast_id_map(&self) -> &AstIdMap {
-        &self.ast_id_map
+        self.ast_id_map
     }
 
     #[inline]
@@ -229,9 +228,9 @@ pub(super) fn span_map(&self) -> SpanMapRef<'_> {
 }
 
 #[derive(Debug)]
-pub(super) struct Mark {
+pub(super) struct Mark<'db> {
     file_id: HirFileId,
     span_map: SpanMap,
-    ast_id_map: Arc<AstIdMap>,
+    ast_id_map: &'db AstIdMap,
     bomb: DropBomb,
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index de1f7463afbe..afa1c7fcfd5b 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -414,7 +414,7 @@ pub(crate) fn lower_function(
 pub struct ExprCollector<'db> {
     db: &'db dyn DefDatabase,
     cfg_options: &'db CfgOptions,
-    expander: Expander,
+    expander: Expander<'db>,
     def_map: &'db DefMap,
     local_def_map: &'db LocalDefMap,
     module: ModuleId,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs b/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
index 5d1cac8e93c4..830820369336 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
@@ -14,6 +14,7 @@
 use crate::{
     FindPathConfig, ModuleDefId, ModuleId,
     db::DefDatabase,
+    import_map::ImportMap,
     item_scope::ItemInNs,
     nameres::DefMap,
     visibility::{Visibility, VisibilityExplicitness},
@@ -426,7 +427,7 @@ fn find_in_dep(
     best_choice: &mut Option<Choice>,
     dep: Crate,
 ) {
-    let import_map = ctx.db.import_map(dep);
+    let import_map = ImportMap::of(ctx.db, dep);
     let Some(import_info_for) = import_map.import_info_for(item) else {
         return;
     };
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/import_map.rs b/src/tools/rust-analyzer/crates/hir-def/src/import_map.rs
index 6c5d226cac1b..0014e1af5c0d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/import_map.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/import_map.rs
@@ -10,7 +10,6 @@
 use smallvec::SmallVec;
 use span::Edition;
 use stdx::format_to;
-use triomphe::Arc;
 
 use crate::{
     AssocItemId, AttrDefId, Complete, FxIndexMap, ModuleDefId, ModuleId, TraitId,
@@ -63,6 +62,14 @@ enum IsTraitAssocItem {
 
 type ImportMapIndex = FxIndexMap<ItemInNs, (SmallVec<[ImportInfo; 1]>, IsTraitAssocItem)>;
 
+#[salsa::tracked]
+impl ImportMap {
+    #[salsa::tracked(returns(ref))]
+    pub fn of(db: &dyn DefDatabase, krate: Crate) -> Self {
+        Self::import_map_query_impl(db, krate)
+    }
+}
+
 impl ImportMap {
     pub fn dump(&self, db: &dyn DefDatabase) -> String {
         let mut out = String::new();
@@ -76,7 +83,7 @@ pub fn dump(&self, db: &dyn DefDatabase) -> String {
         out
     }
 
-    pub(crate) fn import_map_query(db: &dyn DefDatabase, krate: Crate) -> Arc<Self> {
+    fn import_map_query_impl(db: &dyn DefDatabase, krate: Crate) -> Self {
         let _p = tracing::info_span!("import_map_query").entered();
 
         let map = Self::collect_import_map(db, krate);
@@ -120,7 +127,7 @@ pub(crate) fn import_map_query(db: &dyn DefDatabase, krate: Crate) -> Arc<Self>
         }
 
         let importables = importables.into_iter().map(|(item, _, idx)| (item, idx)).collect();
-        Arc::new(ImportMap { item_to_info_map: map, fst: builder.into_map(), importables })
+        ImportMap { item_to_info_map: map, fst: builder.into_map(), importables }
     }
 
     pub fn import_info_for(&self, item: ItemInNs) -> Option<&[ImportInfo]> {
@@ -424,7 +431,7 @@ pub fn search_dependencies(
     let _p = tracing::info_span!("search_dependencies", ?query).entered();
 
     let import_maps: Vec<_> =
-        krate.data(db).dependencies.iter().map(|dep| db.import_map(dep.crate_id)).collect();
+        krate.data(db).dependencies.iter().map(|dep| ImportMap::of(db, dep.crate_id)).collect();
 
     let mut op = fst::map::OpBuilder::new();
 
@@ -458,7 +465,7 @@ pub fn search_dependencies(
 
 fn search_maps(
     _db: &dyn DefDatabase,
-    import_maps: &[Arc<ImportMap>],
+    import_maps: &[&ImportMap],
     mut stream: fst::map::Union<'_>,
     query: &Query,
 ) -> FxHashSet<(ItemInNs, Complete)> {
@@ -467,7 +474,7 @@ fn search_maps(
         for &IndexedValue { index: import_map_idx, value } in indexed_values {
             let end = (value & 0xFFFF_FFFF) as usize;
             let start = (value >> 32) as usize;
-            let ImportMap { item_to_info_map, importables, .. } = &*import_maps[import_map_idx];
+            let ImportMap { item_to_info_map, importables, .. } = import_maps[import_map_idx];
             let importables = &importables[start..end];
 
             let iter = importables
@@ -546,9 +553,9 @@ fn check_search(
             .into_iter()
             .filter_map(|(dependency, _)| {
                 let dependency_krate = dependency.krate(&db)?;
-                let dependency_imports = db.import_map(dependency_krate);
+                let dependency_imports = ImportMap::of(&db, dependency_krate);
 
-                let (path, mark) = match assoc_item_path(&db, &dependency_imports, dependency) {
+                let (path, mark) = match assoc_item_path(&db, dependency_imports, dependency) {
                     Some(assoc_item_path) => (assoc_item_path, "a"),
                     None => (
                         render_path(&db, &dependency_imports.import_info_for(dependency)?[0]),
@@ -618,7 +625,7 @@ fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
                 let cdata = &krate.extra_data(&db);
                 let name = cdata.display_name.as_ref()?;
 
-                let map = db.import_map(krate);
+                let map = ImportMap::of(&db, krate);
 
                 Some(format!("{name}:\n{}\n", map.fmt_for_test(&db)))
             })
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
index 9825dbfe1cd2..e7ab2b390f26 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
@@ -192,45 +192,22 @@ pub(crate) fn file_item_tree_query(
     }
 }
 
-#[salsa_macros::tracked(returns(deref))]
+#[salsa_macros::tracked(returns(ref))]
 pub(crate) fn block_item_tree_query(
     db: &dyn DefDatabase,
     block: BlockId,
     krate: Crate,
-) -> Arc<ItemTree> {
+) -> ItemTree {
     let _p = tracing::info_span!("block_item_tree_query", ?block).entered();
-    static EMPTY: OnceLock<Arc<ItemTree>> = OnceLock::new();
-
     let loc = block.lookup(db);
     let block = loc.ast_id.to_node(db);
 
     let ctx = lower::Ctx::new(db, loc.ast_id.file_id, krate);
     let mut item_tree = ctx.lower_block(&block);
-    let ItemTree { top_level, top_attrs, attrs, vis, big_data, small_data } = &item_tree;
-    if small_data.is_empty()
-        && big_data.is_empty()
-        && top_level.is_empty()
-        && attrs.is_empty()
-        && top_attrs.is_empty()
-        && vis.arena.is_empty()
-    {
-        EMPTY
-            .get_or_init(|| {
-                Arc::new(ItemTree {
-                    top_level: Box::new([]),
-                    attrs: FxHashMap::default(),
-                    small_data: FxHashMap::default(),
-                    big_data: FxHashMap::default(),
-                    top_attrs: AttrsOrCfg::empty(),
-                    vis: ItemVisibilities { arena: ThinVec::new() },
-                })
-            })
-            .clone()
-    } else {
-        item_tree.shrink_to_fit();
-        Arc::new(item_tree)
-    }
+    item_tree.shrink_to_fit();
+    item_tree
 }
+
 /// The item tree of a source file.
 #[derive(Debug, Default, Eq, PartialEq)]
 pub struct ItemTree {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
index 31c6ef867d2c..31e409d86e49 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
@@ -16,7 +16,6 @@
     AstNode,
     ast::{self, HasModuleItem, HasName},
 };
-use triomphe::Arc;
 
 use crate::{
     db::DefDatabase,
@@ -29,20 +28,20 @@
     },
 };
 
-pub(super) struct Ctx<'a> {
-    pub(super) db: &'a dyn DefDatabase,
+pub(super) struct Ctx<'db> {
+    pub(super) db: &'db dyn DefDatabase,
     tree: ItemTree,
-    source_ast_id_map: Arc<AstIdMap>,
+    source_ast_id_map: &'db AstIdMap,
     span_map: OnceCell<SpanMap>,
     file: HirFileId,
-    cfg_options: OnceCell<&'a CfgOptions>,
+    cfg_options: OnceCell<&'db CfgOptions>,
     krate: Crate,
     top_level: Vec<ModItemId>,
     visibilities: FxIndexSet<RawVisibility>,
 }
 
-impl<'a> Ctx<'a> {
-    pub(super) fn new(db: &'a dyn DefDatabase, file: HirFileId, krate: Crate) -> Self {
+impl<'db> Ctx<'db> {
+    pub(super) fn new(db: &'db dyn DefDatabase, file: HirFileId, krate: Crate) -> Self {
         Self {
             db,
             tree: ItemTree::default(),
@@ -57,7 +56,7 @@ pub(super) fn new(db: &'a dyn DefDatabase, file: HirFileId, krate: Crate) -> Sel
     }
 
     #[inline]
-    pub(super) fn cfg_options(&self) -> &'a CfgOptions {
+    pub(super) fn cfg_options(&self) -> &'db CfgOptions {
         self.cfg_options.get_or_init(|| self.krate.cfg_options(self.db))
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
index 9d2b2109fbcb..f5a852b39c8d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
@@ -17,7 +17,6 @@
     ast::{self, HasModuleItem, HasName},
 };
 use thin_vec::ThinVec;
-use triomphe::Arc;
 
 use crate::{
     AssocItemId, AstIdWithPath, ConstLoc, FunctionId, FunctionLoc, ImplId, ItemContainerId,
@@ -133,14 +132,14 @@ pub fn macro_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId
     }
 }
 
-struct AssocItemCollector<'a> {
-    db: &'a dyn DefDatabase,
+struct AssocItemCollector<'db> {
+    db: &'db dyn DefDatabase,
     module_id: ModuleId,
-    def_map: &'a DefMap,
-    local_def_map: &'a LocalDefMap,
-    ast_id_map: Arc<AstIdMap>,
+    def_map: &'db DefMap,
+    local_def_map: &'db LocalDefMap,
+    ast_id_map: &'db AstIdMap,
     span_map: SpanMap,
-    cfg_options: &'a CfgOptions,
+    cfg_options: &'db CfgOptions,
     file_id: HirFileId,
     diagnostics: Vec<DefDiagnostic>,
     container: ItemContainerId,
@@ -150,9 +149,9 @@ struct AssocItemCollector<'a> {
     macro_calls: ThinVec<(AstId<ast::Item>, MacroCallId)>,
 }
 
-impl<'a> AssocItemCollector<'a> {
+impl<'db> AssocItemCollector<'db> {
     fn new(
-        db: &'a dyn DefDatabase,
+        db: &'db dyn DefDatabase,
         module_id: ModuleId,
         container: ItemContainerId,
         file_id: HirFileId,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
index 7fedfa03bbd9..5b75c078ecfa 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
@@ -166,15 +166,15 @@ fn no() {}
             [
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "EnumVariants::of_",
@@ -183,7 +183,7 @@ fn no() {}
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "EnumVariants::of_",
@@ -224,21 +224,21 @@ pub struct S {}
             [
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "decl_macro_expander_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
             ]
@@ -246,12 +246,12 @@ pub struct S {}
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "macro_arg_shim",
                 "parse_macro_expansion_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
             ]
         "#]],
@@ -282,26 +282,26 @@ fn f() { foo }
             [
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "crate_local_def_map",
                 "proc_macros_for_crate_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "expand_proc_macro_shim",
                 "macro_arg_shim",
@@ -311,13 +311,13 @@ fn f() { foo }
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "macro_arg_shim",
                 "expand_proc_macro_shim",
                 "parse_macro_expansion_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
             ]
         "#]],
@@ -406,38 +406,38 @@ pub struct S {}
             [
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "crate_local_def_map",
                 "proc_macros_for_crate_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "decl_macro_expander_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
                 "decl_macro_expander_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "expand_proc_macro_shim",
                 "macro_arg_shim",
@@ -447,7 +447,7 @@ pub struct S {}
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "macro_arg_shim",
@@ -523,29 +523,29 @@ fn quux() { 1$0 }
             [
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "decl_macro_expander_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "macro_def_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
             ]
@@ -572,7 +572,7 @@ fn quux() { 92 }
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "macro_arg_shim",
@@ -610,7 +610,7 @@ impl Tr for () {}
         expect![[r#"
             [
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
             ]
@@ -630,7 +630,7 @@ impl Tr for () {}
         expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
             ]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index 1a0e6a46f174..dee7800e8428 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -1020,7 +1020,7 @@ fn process_names(&self, acc: &mut ScopeNames, db: &'db dyn DefDatabase) {
                     })
                 });
             }
-            &Scope::GenericParams { ref params, def: parent } => {
+            &Scope::GenericParams { params, def: parent } => {
                 if let GenericDefId::ImplId(impl_) = parent {
                     acc.add(&Name::new_symbol_root(sym::Self_), ScopeDef::ImplSelfType(impl_));
                 } else if let GenericDefId::AdtId(adt) = parent {
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
index 363465fdda35..020731cf9aca 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/db.rs
@@ -58,8 +58,8 @@ pub trait ExpandDatabase: RootQueryDb {
     fn proc_macros_for_crate(&self, krate: Crate) -> Option<Arc<CrateProcMacros>>;
 
     #[salsa::invoke(ast_id_map)]
-    #[salsa::lru(1024)]
-    fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
+    #[salsa::transparent]
+    fn ast_id_map(&self, file_id: HirFileId) -> &AstIdMap;
 
     #[salsa::transparent]
     fn resolve_span(&self, span: Span) -> FileRange;
@@ -334,8 +334,9 @@ pub fn expand_speculative(
     Some((node.syntax_node(), token))
 }
 
-fn ast_id_map(db: &dyn ExpandDatabase, file_id: HirFileId) -> triomphe::Arc<AstIdMap> {
-    triomphe::Arc::new(AstIdMap::from_source(&db.parse_or_expand(file_id)))
+#[salsa::tracked(lru = 1024, returns(ref))]
+fn ast_id_map(db: &dyn ExpandDatabase, file_id: HirFileId) -> AstIdMap {
+    AstIdMap::from_source(&db.parse_or_expand(file_id))
 }
 
 /// Main public API -- parses a hir file, not caring whether it's a real
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
index 6cdc07e430b6..92629b7a0532 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/builtin_derive.rs
@@ -133,7 +133,7 @@ pub fn impl_trait<'db>(
             let args = GenericArgs::identity_for_item(interner, loc.adt.into());
             let self_ty = Ty::new_adt(interner, loc.adt, args);
             let Some((pointee_param_idx, _, new_param_ty)) =
-                coerce_pointee_params(interner, loc, &generic_params, trait_id)
+                coerce_pointee_params(interner, loc, generic_params, trait_id)
             else {
                 // Malformed derive.
                 return EarlyBinder::bind(TraitRef::new(
@@ -168,7 +168,7 @@ pub fn predicates<'db>(db: &'db dyn HirDatabase, impl_: BuiltinDeriveImplId) ->
         | BuiltinDeriveImplTrait::PartialOrd
         | BuiltinDeriveImplTrait::Eq
         | BuiltinDeriveImplTrait::PartialEq => {
-            simple_trait_predicates(interner, loc, &generic_params, adt_predicates, trait_id)
+            simple_trait_predicates(interner, loc, generic_params, adt_predicates, trait_id)
         }
         BuiltinDeriveImplTrait::Default => {
             if matches!(loc.adt, AdtId::EnumId(_)) {
@@ -178,12 +178,12 @@ pub fn predicates<'db>(db: &'db dyn HirDatabase, impl_: BuiltinDeriveImplId) ->
                         .store(),
                 ))
             } else {
-                simple_trait_predicates(interner, loc, &generic_params, adt_predicates, trait_id)
+                simple_trait_predicates(interner, loc, generic_params, adt_predicates, trait_id)
             }
         }
         BuiltinDeriveImplTrait::CoerceUnsized | BuiltinDeriveImplTrait::DispatchFromDyn => {
             let Some((pointee_param_idx, pointee_param_id, new_param_ty)) =
-                coerce_pointee_params(interner, loc, &generic_params, trait_id)
+                coerce_pointee_params(interner, loc, generic_params, trait_id)
             else {
                 // Malformed derive.
                 return GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index 3e8089c9c13e..e806999cb44e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -34,7 +34,7 @@ fn foo() -> i32 {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "InferenceResult::for_body_",
@@ -77,7 +77,7 @@ fn foo() -> i32 {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "AttrFlags::query_",
@@ -122,7 +122,7 @@ fn baz() -> i32 {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "InferenceResult::for_body_",
@@ -190,7 +190,7 @@ fn baz() -> i32 {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "AttrFlags::query_",
@@ -242,7 +242,7 @@ fn bar() -> f32 {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitImpls::for_crate_",
@@ -279,7 +279,7 @@ pub struct NewStruct {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "crate_local_def_map",
@@ -317,7 +317,7 @@ fn bar() -> f32 {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitImpls::for_crate_",
@@ -355,7 +355,7 @@ pub enum SomeEnum {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "crate_local_def_map",
@@ -393,7 +393,7 @@ fn bar() -> f32 {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitImpls::for_crate_",
@@ -428,7 +428,7 @@ fn bar() -> f32 {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "crate_local_def_map",
@@ -470,7 +470,7 @@ pub struct SomeStruct {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitImpls::for_crate_",
@@ -513,7 +513,7 @@ pub fn new(value: i32) -> Self {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "crate_local_def_map",
@@ -571,7 +571,7 @@ fn main() {
                 "source_root_crates_shim",
                 "crate_local_def_map",
                 "file_item_tree_query",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "parse_shim",
                 "real_span_map_shim",
                 "TraitItems::query_with_diagnostics_",
@@ -665,7 +665,7 @@ fn main() {
         expect_test::expect![[r#"
             [
                 "parse_shim",
-                "ast_id_map_shim",
+                "ast_id_map",
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "crate_local_def_map",
@@ -716,6 +716,7 @@ fn execute_assert_events(
 ) {
     crate::attach_db(db, || {
         let (executed, events) = db.log_executed(f);
+        expect.assert_debug_eq(&executed);
         for (event, count) in required {
             let n = executed.iter().filter(|it| it.contains(event)).count();
             assert_eq!(
@@ -731,6 +732,5 @@ fn execute_assert_events(
                     .collect::<Vec<_>>(),
             );
         }
-        expect.assert_debug_eq(&executed);
     });
 }
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index aa34177b89a1..ef885f0be8a2 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -101,7 +101,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 if f.show_container_bounds() && !params.is_empty() {
                     write_trait_header(trait_.into(), f)?;
                     f.write_char('\n')?;
-                    has_disaplayable_predicates(f.db, &params, params_store)
+                    has_disaplayable_predicates(f.db, params, params_store)
                         .then_some((params, params_store))
                 } else {
                     None
@@ -112,7 +112,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 if f.show_container_bounds() && !params.is_empty() {
                     write_impl_header(impl_, f)?;
                     f.write_char('\n')?;
-                    has_disaplayable_predicates(f.db, &params, params_store)
+                    has_disaplayable_predicates(f.db, params, params_store)
                         .then_some((params, params_store))
                 } else {
                     None
@@ -134,7 +134,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
                 _ => unreachable!(),
             };
             write!(f, "\n    // Bounds from {container_name}:",)?;
-            write_where_predicates(&container_params, container_params_store, f)?;
+            write_where_predicates(container_params, container_params_store, f)?;
         }
         Ok(())
     }
@@ -719,12 +719,12 @@ fn write_generic_params_or_args<'db>(
 
 fn write_where_clause<'db>(def: GenericDefId, f: &mut HirFormatter<'_, 'db>) -> Result<bool> {
     let (params, store) = GenericParams::with_store(f.db, def);
-    if !has_disaplayable_predicates(f.db, &params, store) {
+    if !has_disaplayable_predicates(f.db, params, store) {
         return Ok(false);
     }
 
     f.write_str("\nwhere")?;
-    write_where_predicates(&params, store, f)?;
+    write_where_predicates(params, store, f)?;
 
     Ok(true)
 }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/prime_caches.rs b/src/tools/rust-analyzer/crates/ide-db/src/prime_caches.rs
index 015b06e8e0b2..d264428212cb 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/prime_caches.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/prime_caches.rs
@@ -4,7 +4,7 @@
 //! various caches, it's not really advanced at the moment.
 use std::panic::AssertUnwindSafe;
 
-use hir::{Symbol, db::DefDatabase};
+use hir::{Symbol, import_map::ImportMap};
 use rustc_hash::FxHashMap;
 use salsa::{Cancelled, Database};
 
@@ -123,7 +123,7 @@ enum ParallelPrimeCacheWorkerProgress {
                 Ok::<_, crossbeam_channel::SendError<_>>(())
             };
             let handle_import_map = |crate_id| {
-                let cancelled = Cancelled::catch(|| _ = db.import_map(crate_id));
+                let cancelled = Cancelled::catch(|| _ = ImportMap::of(&db, crate_id));
 
                 match cancelled {
                     Ok(()) => {

From b451c258ba8a2c374fdce8a857bd869adc8d2804 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 28 Mar 2026 15:11:29 +0100
Subject: [PATCH 1013/1059] Remove another `Arc`

---
 .../rust-analyzer/crates/hir-def/src/db.rs    | 12 ++----
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  8 ++--
 .../crates/hir-def/src/signatures.rs          |  2 +-
 .../crates/hir-def/src/visibility.rs          | 39 ++++++++++---------
 .../diagnostics/match_check/pat_analysis.rs   |  4 +-
 .../crates/hir-ty/src/infer/expr.rs           |  7 ++--
 .../crates/hir-ty/src/infer/pat.rs            |  5 ++-
 .../crates/hir-ty/src/inhabitedness.rs        | 10 ++++-
 8 files changed, 48 insertions(+), 39 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index 2f2889ec6611..5d5d43539822 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -4,16 +4,15 @@
     EditionedFileId, HirFileId, InFile, Lookup, MacroCallId, MacroDefId, MacroDefKind,
     db::ExpandDatabase,
 };
-use la_arena::ArenaMap;
 use triomphe::Arc;
 
 use crate::{
     AnonConstId, AnonConstLoc, AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc,
     EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,
-    ExternCrateLoc, FunctionId, FunctionLoc, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc,
-    MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId,
-    ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
-    TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
+    ExternCrateLoc, FunctionId, FunctionLoc, ImplId, ImplLoc, Macro2Id, Macro2Loc, MacroExpander,
+    MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
+    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
+    UnionLoc, UseId, UseLoc,
     attrs::AttrFlags,
     item_tree::{ItemTree, file_item_tree_query},
     nameres::crate_def_map,
@@ -98,9 +97,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
 
     // region:visibilities
 
-    #[salsa::invoke(visibility::field_visibilities_query)]
-    fn field_visibilities(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Visibility>>;
-
     #[salsa::invoke(visibility::assoc_visibility_query)]
     fn assoc_visibility(&self, def: AssocItemId) -> Visibility;
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index 4387ef055fdd..800c08aa2c96 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -259,7 +259,7 @@ fn module(&self, db: &dyn DefDatabase) -> ModuleId {
 
 impl StructId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
-        VariantFields::firewall(db, self.into())
+        VariantFields::of(db, self.into())
     }
 
     pub fn fields_with_source_map(
@@ -276,7 +276,7 @@ pub fn fields_with_source_map(
 
 impl UnionId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
-        VariantFields::firewall(db, self.into())
+        VariantFields::of(db, self.into())
     }
 
     pub fn fields_with_source_map(
@@ -396,7 +396,7 @@ pub struct EnumVariantLoc {
 
 impl EnumVariantId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
-        VariantFields::firewall(db, self.into())
+        VariantFields::of(db, self.into())
     }
 
     pub fn fields_with_source_map(
@@ -1027,7 +1027,7 @@ pub enum VariantId {
 
 impl VariantId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
-        VariantFields::firewall(db, self)
+        VariantFields::of(db, self)
     }
 
     pub fn fields_with_source_map(
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index c16ca6d0b432..9d988c821ab7 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -906,7 +906,7 @@ pub(crate) fn with_source_map(
     }
 
     #[salsa::tracked(returns(deref))]
-    pub(crate) fn firewall(db: &dyn DefDatabase, id: VariantId) -> Arc<Self> {
+    pub(crate) fn of(db: &dyn DefDatabase, id: VariantId) -> Arc<Self> {
         Self::with_source_map(db, id).0.clone()
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/visibility.rs b/src/tools/rust-analyzer/crates/hir-def/src/visibility.rs
index cb5eed1b8b6c..81a61ec20f17 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/visibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/visibility.rs
@@ -6,11 +6,11 @@
 use hir_expand::{InFile, Lookup};
 use la_arena::ArenaMap;
 use syntax::ast::{self, HasVisibility};
-use triomphe::Arc;
 
 use crate::{
     AssocItemId, HasModule, ItemContainerId, LocalFieldId, ModuleId, TraitId, VariantId,
-    db::DefDatabase, nameres::DefMap, resolver::HasResolver, src::HasSource,
+    db::DefDatabase, nameres::DefMap, resolver::HasResolver, signatures::VariantFields,
+    src::HasSource,
 };
 
 pub use crate::item_tree::{RawVisibility, VisibilityExplicitness};
@@ -277,23 +277,26 @@ pub(crate) fn min(
     }
 }
 
-/// Resolve visibility of all specific fields of a struct or union variant.
-pub(crate) fn field_visibilities_query(
-    db: &dyn DefDatabase,
-    variant_id: VariantId,
-) -> Arc<ArenaMap<LocalFieldId, Visibility>> {
-    let variant_fields = variant_id.fields(db);
-    let fields = variant_fields.fields();
-    if fields.is_empty() {
-        return Arc::default();
+#[salsa::tracked]
+impl VariantFields {
+    /// Resolve visibility of all specific fields of a struct or union variant.
+    #[salsa::tracked(returns(ref))]
+    pub fn field_visibilities(
+        db: &dyn DefDatabase,
+        variant_id: VariantId,
+    ) -> ArenaMap<LocalFieldId, Visibility> {
+        let variant_fields = variant_id.fields(db);
+        let fields = variant_fields.fields();
+        if fields.is_empty() {
+            return ArenaMap::default();
+        }
+        let resolver = variant_id.module(db).resolver(db);
+        let mut res = ArenaMap::with_capacity(fields.len());
+        for (field_id, field_data) in fields.iter() {
+            res.insert(field_id, Visibility::resolve(db, &resolver, &field_data.visibility));
+        }
+        res
     }
-    let resolver = variant_id.module(db).resolver(db);
-    let mut res = ArenaMap::default();
-    for (field_id, field_data) in fields.iter() {
-        res.insert(field_id, Visibility::resolve(db, &resolver, &field_data.visibility));
-    }
-    res.shrink_to_fit();
-    Arc::new(res)
 }
 
 pub fn visibility_from_ast(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index eda7e7e249b3..bc3d9bbec6fa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -4,6 +4,7 @@
 
 use hir_def::{
     EnumId, EnumVariantId, HasModule, LocalFieldId, ModuleId, VariantId, attrs::AttrFlags,
+    signatures::VariantFields,
 };
 use intern::sym;
 use rustc_pattern_analysis::{
@@ -363,7 +364,8 @@ fn ctor_sub_tys(
                     let adt = adt_def.def_id().0;
                     let variant = Self::variant_id_for_adt(self.db, ctor, adt).unwrap();
 
-                    let visibilities = LazyCell::new(|| self.db.field_visibilities(variant));
+                    let visibilities =
+                        LazyCell::new(|| VariantFields::field_visibilities(self.db, variant));
 
                     self.list_variant_fields(*ty, variant)
                         .map(move |(fid, ty)| {
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 c4c217b010ee..dc57b1d1c215 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
@@ -11,7 +11,7 @@
         InlineAsmKind, LabelId, Literal, Pat, PatId, RecordSpread, Statement, UnaryOp,
     },
     resolver::ValueNs,
-    signatures::FunctionSignature,
+    signatures::{FunctionSignature, VariantFields},
 };
 use hir_def::{FunctionId, hir::ClosureKind};
 use hir_expand::name::Name;
@@ -609,7 +609,7 @@ fn infer_expr_inner(
                     Some(def) => {
                         let field_types = self.db.field_types(def);
                         let variant_data = def.fields(self.db);
-                        let visibilities = self.db.field_visibilities(def);
+                        let visibilities = VariantFields::field_visibilities(self.db, def);
                         for field in fields.iter() {
                             let field_def = {
                                 match variant_data.field(&field.name) {
@@ -1625,7 +1625,8 @@ fn lookup_field(
                 },
                 _ => return None,
             };
-            let is_visible = self.db.field_visibilities(field_id.parent)[field_id.local_id]
+            let is_visible = VariantFields::field_visibilities(self.db, field_id.parent)
+                [field_id.local_id]
                 .is_visible_from(self.db, self.resolver.module());
             if !is_visible {
                 if private_field.is_none() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 0b6c9977f079..8033680dcc5c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -6,6 +6,7 @@
     HasModule as _,
     expr_store::{ExpressionStore, path::Path},
     hir::{Binding, BindingAnnotation, BindingId, Expr, ExprId, Literal, Pat, PatId},
+    signatures::VariantFields,
 };
 use hir_expand::name::Name;
 use rustc_ast_ir::Mutability;
@@ -60,7 +61,7 @@ pub(super) fn infer_tuple_struct_pat_like(
             Some(def) => {
                 let field_types = self.db.field_types(def);
                 let variant_data = def.fields(self.db);
-                let visibilities = self.db.field_visibilities(def);
+                let visibilities = VariantFields::field_visibilities(self.db, def);
 
                 let (pre, post) = match ellipsis {
                     Some(idx) => subs.split_at(idx as usize),
@@ -129,7 +130,7 @@ pub(super) fn infer_record_pat_like(
             Some(def) => {
                 let field_types = self.db.field_types(def);
                 let variant_data = def.fields(self.db);
-                let visibilities = self.db.field_visibilities(def);
+                let visibilities = VariantFields::field_visibilities(self.db, def);
 
                 let substs = ty.as_adt().map(TupleExt::tail);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs b/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
index 402e9ce96971..74d66123ea53 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
@@ -1,7 +1,9 @@
 //! Type inhabitedness logic.
 use std::ops::ControlFlow::{self, Break, Continue};
 
-use hir_def::{AdtId, EnumVariantId, ModuleId, VariantId, visibility::Visibility};
+use hir_def::{
+    AdtId, EnumVariantId, ModuleId, VariantId, signatures::VariantFields, visibility::Visibility,
+};
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
     TypeSuperVisitable, TypeVisitable, TypeVisitor,
@@ -151,7 +153,11 @@ fn visit_variant(
 
         let is_enum = matches!(variant, VariantId::EnumVariantId(..));
         let field_tys = self.db().field_types(variant);
-        let field_vis = if is_enum { None } else { Some(self.db().field_visibilities(variant)) };
+        let field_vis = if is_enum {
+            None
+        } else {
+            Some(VariantFields::field_visibilities(self.db(), variant))
+        };
 
         for (fid, _) in fields.iter() {
             self.visit_field(field_vis.as_ref().map(|it| it[fid]), &field_tys[fid].get(), subst)?;

From d30c76d2c00a83843da04d0b81cb3f1139f3eb08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Sat, 28 Mar 2026 16:56:45 +0200
Subject: [PATCH 1014/1059] Replace truncate(0) with clear()

---
 .../rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
index 913d54e9697d..d720295d934b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -897,7 +897,7 @@ fn restrict_precision_for_unsafe(&mut self) {
             if ty.is_raw_ptr() || ty.is_union() {
                 capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
                 self.truncate_capture_spans(capture, 0);
-                capture.place.projections.truncate(0);
+                capture.place.projections.clear();
                 continue;
             }
             for (i, p) in capture.place.projections.iter().enumerate() {

From 024acdd4b6e04efde74559f9a9416558d89aa165 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Sat, 28 Mar 2026 10:51:02 -0400
Subject: [PATCH 1015/1059] Fix ambiguous parsing in bootstrap.py

---
 src/bootstrap/bootstrap.py                | 7 ++++++-
 src/bootstrap/src/utils/change_tracker.rs | 5 +++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 105e41ca45f6..b893bb3f5821 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -1259,7 +1259,12 @@ class RustBuild(object):
 
 def parse_args(args):
     """Parse the command line arguments that the python script needs."""
-    parser = argparse.ArgumentParser(add_help=False)
+
+    # Pass allow_abbrev=False to remove support for inexact matches (e.g.,
+    # `--json` turning on `--json-output`). The argument list here is partial,
+    # most flags are matched in the Rust bootstrap code. This prevents the the
+    # default ambiguity checks in argparse from functioning correctly.
+    parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
     parser.add_argument("-h", "--help", action="store_true")
     parser.add_argument("--config")
     parser.add_argument("--build-dir")
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index f8af8f3bec03..3ae2373e1da2 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -616,4 +616,9 @@ pub fn human_readable_changes(changes: &[ChangeInfo]) -> String {
         severity: ChangeSeverity::Warning,
         summary: "`x.py test --no-doc` is renamed to `--all-targets`. Additionally `--tests` is added which only executes unit and integration tests.",
     },
+    ChangeInfo {
+        change_id: 154508,
+        severity: ChangeSeverity::Info,
+        summary: "`x.py` stopped accepting partial argument names. Use full names to avoid errors.",
+    },
 ];

From 412b4fff350a2458850800bf5e73190709f88f9f Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 28 Mar 2026 18:09:55 +0100
Subject: [PATCH 1016/1059] Fully implement `VariantFields` expression support

---
 .../crates/hir-def/src/expr_store.rs          |  46 +++---
 .../crates/hir-def/src/expr_store/body.rs     |   6 +-
 .../crates/hir-def/src/expr_store/lower.rs    |  29 ++--
 .../hir-def/src/expr_store/lower/generics.rs  |   4 +-
 .../crates/hir-def/src/expr_store/pretty.rs   |   2 +-
 .../crates/hir-def/src/expr_store/scope.rs    |  19 ++-
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  35 +++--
 .../crates/hir-def/src/resolver.rs            |   1 +
 .../crates/hir-def/src/signatures.rs          |   6 +-
 .../crates/hir-ty/src/consteval.rs            |   2 +-
 .../crates/hir-ty/src/diagnostics/expr.rs     |   2 +-
 .../hir-ty/src/diagnostics/unsafe_check.rs    |  30 ++--
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  68 ++++++++-
 .../hir-ty/src/infer/closure/analysis.rs      |  13 ++
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |   8 +-
 .../crates/hir-ty/src/mir/eval.rs             |   4 +-
 .../crates/hir-ty/src/mir/lower.rs            |   4 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |  14 +-
 .../rust-analyzer/crates/hir-ty/src/upvars.rs |   2 +-
 .../rust-analyzer/crates/hir/src/attrs.rs     |  14 +-
 .../rust-analyzer/crates/hir/src/display.rs   |  10 +-
 .../rust-analyzer/crates/hir/src/from_id.rs   |  91 ++++++++----
 .../crates/hir/src/has_source.rs              |  16 +--
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 133 +++++++++---------
 .../rust-analyzer/crates/hir/src/semantics.rs |  67 ++++-----
 .../crates/hir/src/semantics/source_to_def.rs |   2 +-
 .../crates/hir/src/source_analyzer.rs         | 113 ++++++++++-----
 .../crates/hir/src/term_search/expr.rs        |   8 +-
 .../src/handlers/add_missing_match_arms.rs    |   3 +-
 .../ide-assists/src/handlers/auto_import.rs   |   2 +-
 .../src/handlers/convert_bool_then.rs         |  10 +-
 .../convert_named_struct_to_tuple_struct.rs   |   4 +-
 .../convert_tuple_struct_to_named_struct.rs   |   4 +-
 .../src/handlers/expand_glob_import.rs        |   4 +-
 .../src/handlers/expand_rest_pattern.rs       |   2 +-
 .../src/handlers/extract_module.rs            |   2 +-
 .../extract_struct_from_enum_variant.rs       |   8 +-
 .../src/handlers/extract_variable.rs          |   2 +-
 .../src/handlers/fix_visibility.rs            |   2 +-
 .../replace_qualified_name_with_use.rs        |   2 +-
 .../crates/ide-completion/src/completions.rs  |  14 +-
 .../ide-completion/src/completions/pattern.rs |   4 +-
 .../ide-completion/src/completions/type.rs    |   4 +-
 .../crates/ide-completion/src/context.rs      |   4 +-
 .../ide-completion/src/context/analysis.rs    |   8 +-
 .../crates/ide-completion/src/render.rs       |   8 +-
 .../ide-completion/src/render/literal.rs      |   4 +-
 .../ide-completion/src/render/pattern.rs      |   2 +-
 .../crates/ide-db/src/active_parameter.rs     |   4 +-
 .../rust-analyzer/crates/ide-db/src/defs.rs   |  39 ++---
 .../crates/ide-db/src/documentation.rs        |  18 ++-
 .../rust-analyzer/crates/ide-db/src/lib.rs    |   2 +-
 .../crates/ide-db/src/path_transform.rs       |   2 +-
 .../rust-analyzer/crates/ide-db/src/rename.rs |   2 +-
 .../rust-analyzer/crates/ide-db/src/search.rs |  10 +-
 .../test_symbol_index_collection.txt          |   8 +-
 .../src/handlers/no_such_field.rs             |   8 +-
 .../rust-analyzer/crates/ide/src/doc_links.rs |  10 +-
 .../crates/ide/src/doc_links/tests.rs         |   2 +-
 .../crates/ide/src/hover/render.rs            |  16 +--
 .../crates/ide/src/inlay_hints/param_name.rs  |   2 +-
 .../rust-analyzer/crates/ide/src/moniker.rs   |   2 +-
 .../crates/ide/src/navigation_target.rs       |   8 +-
 .../crates/ide/src/references.rs              |   4 +-
 .../rust-analyzer/crates/ide/src/runnables.rs |   2 +-
 .../crates/ide/src/signature_help.rs          |   4 +-
 .../crates/ide/src/syntax_highlighting.rs     |  37 ++---
 .../ide/src/syntax_highlighting/highlight.rs  |   2 +-
 .../ide/src/syntax_highlighting/inject.rs     |   2 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  86 +++++++++--
 70 files changed, 693 insertions(+), 419 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
index 1ae89e170d9c..ca523622ec84 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs
@@ -31,6 +31,7 @@
         PatId, RecordFieldPat, RecordSpread, Statement,
     },
     nameres::{DefMap, block_def_map},
+    signatures::VariantFields,
     type_ref::{LifetimeRef, LifetimeRefId, PathId, TypeRef, TypeRefId},
 };
 
@@ -95,7 +96,7 @@ pub(crate) fn is_root(self) -> bool {
 /// Used by signature/body inference to determine the expected type for each
 /// const expression root.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ConstExprOrigin {
+pub enum RootExprOrigin {
     /// Array length expression: `[T; <expr>]` — expected type is `usize`.
     ArrayLength,
     /// Const parameter default value: `const N: usize = <expr>`.
@@ -103,6 +104,8 @@ pub enum ConstExprOrigin {
     /// Const generic argument in a path: `SomeType::<{ <expr> }>` or `some_fn::<{ <expr> }>()`.
     /// Determining the expected type requires path resolution, so it is deferred.
     GenericArgsPath,
+    /// The root expression of a body.
+    BodyRoot,
 }
 
 // We split the store into types-only and expressions, because most stores (e.g. generics)
@@ -125,11 +128,8 @@ struct ExpressionOnlyStore {
     /// to variables and have hygiene (some refer to items, we don't know at this stage).
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
 
-    /// Maps const expression roots to their origin.
-    ///
-    /// Populated during lowering. Used by signature inference to determine expected types,
-    /// and by `signature_const_expr_roots()` to enumerate roots for scope computation.
-    const_expr_origins: ThinVec<(ExprId, ConstExprOrigin)>,
+    /// Maps expression roots to their origin.
+    expr_roots: SmallVec<[(ExprId, RootExprOrigin); 1]>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -243,7 +243,7 @@ pub struct ExpressionStoreBuilder {
     pub types: Arena<TypeRef>,
     block_scopes: Vec<BlockId>,
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
-    pub const_expr_origins: Option<ThinVec<(ExprId, ConstExprOrigin)>>,
+    pub inference_roots: Option<SmallVec<[(ExprId, RootExprOrigin); 1]>>,
 
     // AST expressions can create patterns in destructuring assignments. Therefore, `ExprSource` can also map
     // to `PatId`, and `PatId` can also map to `ExprSource` (the other way around is unaffected).
@@ -315,7 +315,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
             mut bindings,
             mut binding_owners,
             mut ident_hygiene,
-            mut const_expr_origins,
+            inference_roots: mut expr_roots,
             mut types,
             mut lifetimes,
 
@@ -375,7 +375,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
 
         let store = {
             let expr_only = if has_exprs {
-                if let Some(const_expr_origins) = &mut const_expr_origins {
+                if let Some(const_expr_origins) = &mut expr_roots {
                     const_expr_origins.shrink_to_fit();
                 }
                 Some(Box::new(ExpressionOnlyStore {
@@ -386,7 +386,7 @@ pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
                     binding_owners,
                     block_scopes: block_scopes.into_boxed_slice(),
                     ident_hygiene,
-                    const_expr_origins: const_expr_origins.unwrap_or_default(),
+                    expr_roots: expr_roots.unwrap_or_default(),
                 }))
             } else {
                 None
@@ -448,6 +448,9 @@ pub fn of(db: &dyn DefDatabase, def: ExpressionStoreOwnerId) -> &ExpressionStore
                 }
             }
             ExpressionStoreOwnerId::Body(body) => &Body::of(db, body).store,
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                &VariantFields::of(db, variant_id).store
+            }
         }
     }
 
@@ -505,30 +508,27 @@ pub fn with_source_map(
                 let (store, sm) = Body::with_source_map(db, body);
                 (&store.store, &sm.store)
             }
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                let (store, sm) = VariantFields::with_source_map(db, variant_id);
+                (&store.store, sm)
+            }
         }
     }
 
-    /// Returns all const expression root `ExprId`s found in this store.
-    ///
-    /// Used to compute expression scopes for signature stores.
-    pub fn signature_const_expr_roots(&self) -> impl Iterator<Item = ExprId> {
+    /// Returns all expression root `ExprId`s found in this store.
+    pub fn expr_roots(&self) -> impl Iterator<Item = ExprId> {
         self.const_expr_origins().iter().map(|&(id, _)| id)
     }
 
     /// Like [`Self::signature_const_expr_roots`], but also returns the origin
-    /// of each const expression.
-    ///
-    /// This is used by signature inference to determine the expected type for
-    /// each root expression.
-    pub fn signature_const_expr_roots_with_origins(
-        &self,
-    ) -> impl Iterator<Item = (ExprId, ConstExprOrigin)> {
+    /// of each expression.
+    pub fn expr_roots_with_origins(&self) -> impl Iterator<Item = (ExprId, RootExprOrigin)> {
         self.const_expr_origins().iter().map(|&(id, origin)| (id, origin))
     }
 
     /// Returns the map of const expression roots to their origins.
-    pub fn const_expr_origins(&self) -> &[(ExprId, ConstExprOrigin)] {
-        self.expr_only.as_ref().map_or(&[], |it| &it.const_expr_origins)
+    pub fn const_expr_origins(&self) -> &[(ExprId, RootExprOrigin)] {
+        self.expr_only.as_ref().map_or(&[], |it| &it.expr_roots)
     }
 
     /// Returns an iterator over all block expressions in this store that define inner items.
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
index 60aaba5b84db..0c8320369f66 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs
@@ -29,8 +29,6 @@ pub struct Body {
     /// empty.
     pub params: Box<[PatId]>,
     pub self_param: Option<BindingId>,
-    /// The `ExprId` of the actual body expression.
-    pub body_expr: ExprId,
 }
 
 impl ops::Deref for Body {
@@ -115,6 +113,10 @@ pub fn of(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<Body> {
 }
 
 impl Body {
+    pub fn root_expr(&self) -> ExprId {
+        self.store.expr_roots().next().unwrap()
+    }
+
     pub fn pretty_print(
         &self,
         db: &dyn DefDatabase,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index afa1c7fcfd5b..74006c603703 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -18,6 +18,7 @@
 };
 use intern::{Symbol, sym};
 use rustc_hash::FxHashMap;
+use smallvec::smallvec;
 use stdx::never;
 use syntax::{
     AstNode, AstPtr, SyntaxNodePtr,
@@ -36,9 +37,9 @@
     attrs::AttrFlags,
     db::DefDatabase,
     expr_store::{
-        Body, BodySourceMap, ConstExprOrigin, ExprPtr, ExpressionStore, ExpressionStoreBuilder,
+        Body, BodySourceMap, ExprPtr, ExpressionStore, ExpressionStoreBuilder,
         ExpressionStoreDiagnostics, ExpressionStoreSourceMap, HygieneId, LabelPtr, LifetimePtr,
-        PatPtr, TypePtr,
+        PatPtr, RootExprOrigin, TypePtr,
         expander::Expander,
         lower::generics::ImplTraitLowerFn,
         path::{AssociatedTypeBinding, GenericArg, GenericArgs, GenericArgsParentheses, Path},
@@ -117,9 +118,10 @@ pub(super) fn lower_body(
             params = (0..count).map(|_| collector.missing_pat()).collect();
         };
         let body_expr = collector.missing_expr();
+        collector.store.inference_roots = Some(smallvec![(body_expr, RootExprOrigin::BodyRoot)]);
         let (store, source_map) = collector.store.finish();
         return (
-            Body { store, params: params.into_boxed_slice(), self_param, body_expr },
+            Body { store, params: params.into_boxed_slice(), self_param },
             BodySourceMap { self_param: source_map_self_param, store: source_map },
         );
     }
@@ -173,10 +175,11 @@ pub(super) fn lower_body(
             }
         },
     );
+    collector.store.inference_roots = Some(smallvec![(body_expr, RootExprOrigin::BodyRoot)]);
 
     let (store, source_map) = collector.store.finish();
     (
-        Body { store, params: params.into_boxed_slice(), self_param, body_expr },
+        Body { store, params: params.into_boxed_slice(), self_param },
         BodySourceMap { self_param: source_map_self_param, store: source_map },
     )
 }
@@ -535,7 +538,7 @@ pub fn signature(
         current_file_id: HirFileId,
     ) -> ExprCollector<'_> {
         let mut this = Self::body(db, module, current_file_id);
-        this.store.const_expr_origins = Some(Default::default());
+        this.store.inference_roots = Some(Default::default());
         this
     }
 
@@ -635,8 +638,8 @@ pub(in crate::expr_store) fn lower_type_ref(
             }
             ast::Type::ArrayType(inner) => {
                 let len = self.lower_const_arg_opt(inner.const_arg());
-                if let Some(const_expr_origins) = &mut self.store.const_expr_origins {
-                    const_expr_origins.push((len.expr, ConstExprOrigin::ArrayLength));
+                if let Some(const_expr_origins) = &mut self.store.inference_roots {
+                    const_expr_origins.push((len.expr, RootExprOrigin::ArrayLength));
                 }
                 TypeRef::Array(ArrayType {
                     ty: self.lower_type_ref_opt(inner.ty(), impl_trait_lower_fn),
@@ -922,8 +925,8 @@ pub(super) fn lower_generic_args(
                 }
                 ast::GenericArg::ConstArg(arg) => {
                     let arg = self.lower_const_arg(arg);
-                    if let Some(const_expr_origins) = &mut self.store.const_expr_origins {
-                        const_expr_origins.push((arg.expr, ConstExprOrigin::GenericArgsPath));
+                    if let Some(const_expr_origins) = &mut self.store.inference_roots {
+                        const_expr_origins.push((arg.expr, RootExprOrigin::GenericArgsPath));
                     }
                     args.push(GenericArg::Const(arg))
                 }
@@ -1065,16 +1068,16 @@ fn lower_type_bound(
     }
 
     fn lower_const_arg_opt(&mut self, arg: Option<ast::ConstArg>) -> ConstRef {
-        let const_expr_origins = self.store.const_expr_origins.take();
+        let const_expr_origins = self.store.inference_roots.take();
         let r = ConstRef { expr: self.collect_expr_opt(arg.and_then(|it| it.expr())) };
-        self.store.const_expr_origins = const_expr_origins;
+        self.store.inference_roots = const_expr_origins;
         r
     }
 
     pub fn lower_const_arg(&mut self, arg: ast::ConstArg) -> ConstRef {
-        let const_expr_origins = self.store.const_expr_origins.take();
+        let const_expr_origins = self.store.inference_roots.take();
         let r = ConstRef { expr: self.collect_expr_opt(arg.expr()) };
-        self.store.const_expr_origins = const_expr_origins;
+        self.store.inference_roots = const_expr_origins;
         r
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
index 7c7b6971647e..5ffc4f5851d3 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/generics.rs
@@ -130,11 +130,11 @@ fn lower_param_list(&mut self, ec: &mut ExprCollector<'_>, params: ast::GenericP
                     let param = ConstParamData { name, ty, default };
                     let idx = self.type_or_consts.alloc(param.into());
                     if let Some(default) = default
-                        && let Some(const_expr_origins) = &mut ec.store.const_expr_origins
+                        && let Some(const_expr_origins) = &mut ec.store.inference_roots
                     {
                         const_expr_origins.push((
                             default.expr,
-                            crate::expr_store::ConstExprOrigin::ConstParam(idx),
+                            crate::expr_store::RootExprOrigin::ConstParam(idx),
                         ));
                     }
                 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
index 39e0153ded37..9c9c4db3b208 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
@@ -105,7 +105,7 @@ pub fn print_body_hir(
         p.buf.push(')');
         p.buf.push(' ');
     }
-    p.print_expr(body.body_expr);
+    p.print_expr(body.root_expr());
     if matches!(owner, DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_)) {
         p.buf.push(';');
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
index 22a3a7b07900..40ae0b7de462 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs
@@ -3,13 +3,14 @@
 use la_arena::{Arena, ArenaMap, Idx, IdxRange, RawIdx};
 
 use crate::{
-    BlockId, DefWithBodyId, ExpressionStoreOwnerId, GenericDefId,
+    BlockId, DefWithBodyId, ExpressionStoreOwnerId, GenericDefId, VariantId,
     db::DefDatabase,
     expr_store::{Body, ExpressionStore, HygieneId},
     hir::{
         Binding, BindingId, Expr, ExprId, Item, LabelId, Pat, PatId, Statement,
         generics::GenericParams,
     },
+    signatures::VariantFields,
 };
 
 pub type ScopeId = Idx<ScopeData>;
@@ -65,11 +66,20 @@ pub fn body_expr_scopes(db: &dyn DefDatabase, def: DefWithBodyId) -> ExprScopes
     #[salsa::tracked(returns(ref))]
     pub fn sig_expr_scopes(db: &dyn DefDatabase, def: GenericDefId) -> ExprScopes {
         let (_, store) = GenericParams::with_store(db, def);
-        let roots = store.signature_const_expr_roots();
+        let roots = store.expr_roots();
         let mut scopes = ExprScopes::new_store(store, roots);
         scopes.shrink_to_fit();
         scopes
     }
+
+    #[salsa::tracked(returns(ref))]
+    pub fn variant_scopes(db: &dyn DefDatabase, def: VariantId) -> ExprScopes {
+        let fields = VariantFields::of(db, def);
+        let roots = fields.store.expr_roots();
+        let mut scopes = ExprScopes::new_store(&fields.store, roots);
+        scopes.shrink_to_fit();
+        scopes
+    }
 }
 
 impl ExprScopes {
@@ -78,6 +88,9 @@ pub fn of(db: &dyn DefDatabase, def: impl Into<ExpressionStoreOwnerId>) -> &Expr
         match def.into() {
             ExpressionStoreOwnerId::Body(def) => Self::body_expr_scopes(db, def),
             ExpressionStoreOwnerId::Signature(def) => Self::sig_expr_scopes(db, def),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                Self::variant_scopes(db, variant_id)
+            }
         }
     }
 
@@ -138,7 +151,7 @@ fn new_body(body: &Body) -> ExprScopes {
             scopes.add_bindings(body, root, self_param, body.binding_hygiene(self_param));
         }
         scopes.add_params_bindings(body, root, &body.params);
-        compute_expr_scopes(body.body_expr, body, &mut scopes, &mut root);
+        compute_expr_scopes(body.root_expr(), body, &mut scopes, &mut root);
         scopes
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index 800c08aa2c96..9a7fbc812f87 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -756,19 +756,17 @@ pub fn name(self, db: &dyn DefDatabase) -> String {
     }
 }
 
-/// The defs which have a body (have root expressions for type inference).
+/// The defs which have a body.
 #[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa_macros::Supertype)]
 pub enum DefWithBodyId {
+    /// A function body.
     FunctionId(FunctionId),
+    /// A static item initializer.
     StaticId(StaticId),
+    /// A const item initializer
     ConstId(ConstId),
+    /// An enum variant discrimiant
     VariantId(EnumVariantId),
-    // /// All fields of a variant are inference roots
-    // VariantId(VariantId),
-    // /// The signature can contain inference roots in a bunch of places
-    // /// like const parameters or const arguments in paths
-    // This should likely be kept on its own with a separate query
-    // GenericDefId(GenericDefId),
 }
 impl_from!(FunctionId, ConstId, StaticId for DefWithBodyId);
 
@@ -840,10 +838,15 @@ pub enum GenericDefId {
 /// Owner of an expression store - either a body or a signature.
 /// This is used for queries that operate on expression stores generically,
 /// such as `expr_scopes`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+// NOTE: This type cannot be `salsa::Supertype` as its variants are overlapping.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord /* !salsa::Supertype */)]
 pub enum ExpressionStoreOwnerId {
     Signature(GenericDefId),
+    /// A body, something with a root expression.
+    ///
+    /// An enum variant's body is considered its discriminant initializer.
     Body(DefWithBodyId),
+    VariantFields(VariantId),
 }
 
 impl ExpressionStoreOwnerId {
@@ -861,6 +864,11 @@ pub fn generic_def(self, db: &dyn DefDatabase) -> GenericDefId {
                 DefWithBodyId::ConstId(id) => GenericDefId::ConstId(id),
                 DefWithBodyId::VariantId(it) => it.lookup(db).parent.into(),
             },
+            ExpressionStoreOwnerId::VariantFields(variant_id) => match variant_id {
+                VariantId::EnumVariantId(it) => it.lookup(db).parent.into(),
+                VariantId::StructId(it) => it.into(),
+                VariantId::UnionId(it) => it.into(),
+            },
         }
     }
 }
@@ -877,6 +885,12 @@ fn from(id: DefWithBodyId) -> Self {
     }
 }
 
+impl From<VariantId> for ExpressionStoreOwnerId {
+    fn from(id: VariantId) -> Self {
+        ExpressionStoreOwnerId::VariantFields(id)
+    }
+}
+
 impl GenericDefId {
     pub fn file_id_and_params_of(
         self,
@@ -1017,7 +1031,9 @@ fn from(vid: VariantId) -> Self {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa_macros::Supertype, salsa::Update)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, salsa_macros::Supertype, salsa::Update,
+)]
 pub enum VariantId {
     EnumVariantId(EnumVariantId),
     StructId(StructId),
@@ -1241,6 +1257,7 @@ fn module(&self, db: &dyn DefDatabase) -> ModuleId {
         match self {
             ExpressionStoreOwnerId::Signature(def) => def.module(db),
             ExpressionStoreOwnerId::Body(def) => def.module(db),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => variant_id.module(db),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index dee7800e8428..bb292ac1a6bc 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -1419,6 +1419,7 @@ fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         match self {
             ExpressionStoreOwnerId::Signature(def) => def.resolver(db),
             ExpressionStoreOwnerId::Body(def) => def.resolver(db),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => variant_id.resolver(db),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 9d988c821ab7..6d704274f45d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -848,7 +848,7 @@ pub struct VariantFields {
 #[salsa::tracked]
 impl VariantFields {
     #[salsa::tracked(returns(ref))]
-    pub(crate) fn with_source_map(
+    pub fn with_source_map(
         db: &dyn DefDatabase,
         id: VariantId,
     ) -> (Arc<Self>, ExpressionStoreSourceMap) {
@@ -906,7 +906,7 @@ pub(crate) fn with_source_map(
     }
 
     #[salsa::tracked(returns(deref))]
-    pub(crate) fn of(db: &dyn DefDatabase, id: VariantId) -> Arc<Self> {
+    pub fn of(db: &dyn DefDatabase, id: VariantId) -> Arc<Self> {
         Self::with_source_map(db, id).0.clone()
     }
 }
@@ -1101,7 +1101,7 @@ pub fn is_payload_free(&self, db: &dyn DefDatabase) -> bool {
             if !matches!(variant.shape, FieldsShape::Unit) {
                 let body = Body::of(db, v.into());
                 // A variant with explicit discriminant
-                if !matches!(body[body.body_expr], crate::hir::Expr::Missing) {
+                if !matches!(body[body.root_expr()], crate::hir::Expr::Missing) {
                     return false;
                 }
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 673d00d956ad..928396c63aaf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -276,7 +276,7 @@ pub(crate) fn const_eval_discriminant_variant(
     let def = variant_id.into();
     let body = Body::of(db, def);
     let loc = variant_id.lookup(db);
-    if matches!(body[body.body_expr], Expr::Missing) {
+    if matches!(body[body.root_expr()], Expr::Missing) {
         let prev_idx = loc.index.checked_sub(1);
         let value = match prev_idx {
             Some(prev_idx) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
index e227be6995d0..33d9dd538dd3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
@@ -119,7 +119,7 @@ fn validate_body(&mut self) {
         let body = self.body;
 
         if matches!(self.owner, DefWithBodyId::FunctionId(_)) {
-            self.check_for_trailing_return(body.body_expr, body);
+            self.check_for_trailing_return(body.root_expr(), body);
         }
 
         for (id, expr) in body.exprs() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index ba9b7416b76c..09c648139c45 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -5,8 +5,9 @@
 
 use either::Either;
 use hir_def::{
-    AdtId, CallableDefId, DefWithBodyId, FieldId, FunctionId, VariantId,
-    expr_store::{Body, path::Path},
+    AdtId, CallableDefId, DefWithBodyId, ExpressionStoreOwnerId, FieldId, FunctionId, GenericDefId,
+    VariantId,
+    expr_store::{Body, ExpressionStore, path::Path},
     hir::{AsmOperand, Expr, ExprId, ExprOrPatId, InlineAsmKind, Pat, PatId, Statement, UnaryOp},
     resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},
     signatures::{FunctionSignature, StaticFlags, StaticSignature},
@@ -55,8 +56,8 @@ pub fn missing_unsafe(db: &dyn HirDatabase, def: DefWithBodyId) -> MissingUnsafe
             }
         }
     };
-    let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut callback);
-    visitor.walk_expr(body.body_expr);
+    let mut visitor = UnsafeVisitor::new(db, infer, body, def.into(), &mut callback);
+    visitor.walk_expr(body.root_expr());
 
     if !is_unsafe {
         // Unsafety in function parameter patterns (that can only be union destructuring)
@@ -109,8 +110,8 @@ pub fn unsafe_operations_for_body(
             callback(node);
         }
     };
-    let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut visitor_callback);
-    visitor.walk_expr(body.body_expr);
+    let mut visitor = UnsafeVisitor::new(db, infer, body, def.into(), &mut visitor_callback);
+    visitor.walk_expr(body.root_expr());
     for &param in &body.params {
         visitor.walk_pat(param);
     }
@@ -119,8 +120,8 @@ pub fn unsafe_operations_for_body(
 pub fn unsafe_operations(
     db: &dyn HirDatabase,
     infer: &InferenceResult,
-    def: DefWithBodyId,
-    body: &Body,
+    def: ExpressionStoreOwnerId,
+    body: &ExpressionStore,
     current: ExprId,
     callback: &mut dyn FnMut(ExprOrPatId, InsideUnsafeBlock),
 ) {
@@ -137,9 +138,9 @@ pub fn unsafe_operations(
 struct UnsafeVisitor<'db> {
     db: &'db dyn HirDatabase,
     infer: &'db InferenceResult,
-    body: &'db Body,
+    body: &'db ExpressionStore,
     resolver: Resolver<'db>,
-    def: DefWithBodyId,
+    def: ExpressionStoreOwnerId,
     inside_unsafe_block: InsideUnsafeBlock,
     inside_assignment: bool,
     inside_union_destructure: bool,
@@ -156,13 +157,16 @@ impl<'db> UnsafeVisitor<'db> {
     fn new(
         db: &'db dyn HirDatabase,
         infer: &'db InferenceResult,
-        body: &'db Body,
-        def: DefWithBodyId,
+        body: &'db ExpressionStore,
+        def: ExpressionStoreOwnerId,
         unsafe_expr_cb: &'db mut dyn FnMut(UnsafeDiagnostic),
     ) -> Self {
         let resolver = def.resolver(db);
         let def_target_features = match def {
-            DefWithBodyId::FunctionId(func) => TargetFeatures::from_fn(db, func),
+            ExpressionStoreOwnerId::Body(DefWithBodyId::FunctionId(func))
+            | ExpressionStoreOwnerId::Signature(GenericDefId::FunctionId(func)) => {
+                TargetFeatures::from_fn(db, func)
+            }
             _ => TargetFeatures::default(),
         };
         let krate = resolver.krate();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 52edbc899ffa..d14e9d652654 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -36,7 +36,7 @@
     AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwnerId, FieldId,
     FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup, TraitId,
     TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,
-    expr_store::{Body, ConstExprOrigin, ExpressionStore, HygieneId, path::Path},
+    expr_store::{Body, ExpressionStore, HygieneId, RootExprOrigin, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
     lang_item::LangItems,
     layout::Integer,
@@ -143,9 +143,9 @@ pub fn infer_query_with_inspect<'db>(
         }
     }
 
-    ctx.infer_body(body.body_expr);
+    ctx.infer_body(body.root_expr());
 
-    ctx.infer_mut_body(body.body_expr);
+    ctx.infer_mut_body(body.root_expr());
 
     infer_finalize(ctx)
 }
@@ -166,7 +166,7 @@ fn infer_cycle_result(db: &dyn HirDatabase, _: salsa::Id, _: DefWithBodyId) -> I
 fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
     let _p = tracing::info_span!("infer_signature_query").entered();
     let store = ExpressionStore::of(db, def.into());
-    let mut roots = store.signature_const_expr_roots_with_origins().peekable();
+    let mut roots = store.expr_roots_with_origins().peekable();
     let Some(_) = roots.peek() else {
         return InferenceResult::new(crate::next_solver::default_types(db).types.error);
     };
@@ -179,15 +179,47 @@ fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceRe
     for (root_expr, origin) in roots {
         let expected = match origin {
             // Array lengths are always `usize`.
-            ConstExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
+            RootExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
             // Const parameter default: look up the param's declared type.
-            ConstExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(
+            RootExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(
                 ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),
             )),
             // Path const generic args: determining the expected type requires
             // path resolution.
             // FIXME
-            ConstExprOrigin::GenericArgsPath => Expectation::None,
+            RootExprOrigin::GenericArgsPath => Expectation::None,
+            RootExprOrigin::BodyRoot => Expectation::None,
+        };
+        ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
+    }
+
+    infer_finalize(ctx)
+}
+
+fn infer_variant_fields_query(db: &dyn HirDatabase, def: VariantId) -> InferenceResult {
+    let _p = tracing::info_span!("infer_variant_fields_query").entered();
+    let store = ExpressionStore::of(db, def.into());
+    let mut roots = store.expr_roots_with_origins().peekable();
+    let Some(_) = roots.peek() else {
+        return InferenceResult::new(crate::next_solver::default_types(db).types.error);
+    };
+
+    let resolver = def.resolver(db);
+    let owner = ExpressionStoreOwnerId::VariantFields(def);
+
+    let mut ctx = InferenceContext::new(db, owner, store, resolver);
+
+    for (root_expr, origin) in roots {
+        let expected = match origin {
+            // Array lengths are always `usize`.
+            RootExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),
+            // unreachable
+            RootExprOrigin::ConstParam(_) => Expectation::None,
+            // Path const generic args: determining the expected type requires
+            // path resolution.
+            // FIXME
+            RootExprOrigin::GenericArgsPath => Expectation::None,
+            RootExprOrigin::BodyRoot => Expectation::None,
         };
         ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);
     }
@@ -206,6 +238,17 @@ fn infer_signature_cycle_result(
     }
 }
 
+fn infer_variant_fields_cycle_result(
+    db: &dyn HirDatabase,
+    _: salsa::Id,
+    _: VariantId,
+) -> InferenceResult {
+    InferenceResult {
+        has_errors: true,
+        ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))
+    }
+}
+
 fn infer_finalize(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {
     ctx.handle_opaque_type_uses();
 
@@ -617,6 +660,11 @@ fn for_body(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
     fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {
         infer_signature_query(db, def)
     }
+
+    #[salsa::tracked(returns(ref), cycle_result = infer_variant_fields_cycle_result)]
+    fn for_variant_fields(db: &dyn HirDatabase, def: VariantId) -> InferenceResult {
+        infer_variant_fields_query(db, def)
+    }
 }
 
 impl InferenceResult {
@@ -626,6 +674,9 @@ pub fn of(db: &dyn HirDatabase, def: impl Into<ExpressionStoreOwnerId>) -> &Infe
                 Self::for_signature(db, generic_def_id)
             }
             ExpressionStoreOwnerId::Body(def_with_body_id) => Self::for_body(db, def_with_body_id),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                Self::for_variant_fields(db, variant_id)
+            }
         }
     }
 
@@ -937,6 +988,9 @@ fn new(
             ExpressionStoreOwnerId::Body(def_with_body_id) => {
                 db.trait_environment(ExpressionStoreOwnerId::Body(def_with_body_id))
             }
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                db.trait_environment(ExpressionStoreOwnerId::VariantFields(variant_id))
+            }
         };
         let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
         let types = crate::next_solver::default_types(db);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
index 913d54e9697d..5abb96978dad 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -12,6 +12,7 @@
     },
     item_tree::FieldsShape,
     resolver::ValueNs,
+    signatures::VariantFields,
 };
 use rustc_ast_ir::Mutability;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -194,6 +195,10 @@ pub fn place_to_name(&self, owner: ExpressionStoreOwnerId, db: &dyn HirDatabase)
                 .name
                 .display(db, edition)
                 .to_string(),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                let fields = VariantFields::of(db, variant_id);
+                fields.store[self.place.local].name.display(db, edition).to_string()
+            }
         };
         for proj in &self.place.projections {
             match proj {
@@ -245,6 +250,10 @@ pub fn display_place_source_code(
                 .name
                 .display(db, edition)
                 .to_string(),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                let fields = VariantFields::of(db, variant_id);
+                fields.store[self.place.local].name.display(db, edition).to_string()
+            }
         };
         for proj in &self.place.projections {
             match proj {
@@ -301,6 +310,10 @@ pub fn display_place(&self, owner: ExpressionStoreOwnerId, db: &dyn HirDatabase)
                 .name
                 .display(db, edition)
                 .to_string(),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                let fields = VariantFields::of(db, variant_id);
+                fields.store[self.place.local].name.display(db, edition).to_string()
+            }
         };
         let mut field_need_paren = false;
         for proj in &self.place.projections {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 5eee025f2c00..7259099107ca 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -2156,13 +2156,7 @@ pub(crate) fn trait_environment<'db>(
     db: &'db dyn HirDatabase,
     def: ExpressionStoreOwnerId,
 ) -> ParamEnv<'db> {
-    let def = match def {
-        ExpressionStoreOwnerId::Signature(def) => def,
-        ExpressionStoreOwnerId::Body(def) => match def.as_generic_def_id(db) {
-            Some(def) => def,
-            None => return ParamEnv::empty(),
-        },
-    };
+    let def = def.generic_def(db);
 
     return ParamEnv { clauses: trait_environment_query(db, def).as_ref() };
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index c013e78d81b8..505db1776f28 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -900,7 +900,7 @@ fn operand_ty(&self, o: &Operand, locals: &Locals) -> Result<'db, Ty<'db>> {
             OperandKind::Constant { konst: _, ty } => ty.as_ref(),
             &OperandKind::Static(s) => {
                 let ty = InferenceResult::of(self.db, DefWithBodyId::from(s))
-                    .expr_ty(Body::of(self.db, s.into()).body_expr);
+                    .expr_ty(Body::of(self.db, s.into()).root_expr());
                 Ty::new_ref(
                     self.interner(),
                     Region::new_static(self.interner()),
@@ -2835,7 +2835,7 @@ fn eval_static(&mut self, st: StaticId, locals: &Locals) -> Result<'db, Address>
             self.allocate_const_in_heap(locals, konst)?
         } else {
             let ty = InferenceResult::of(self.db, DefWithBodyId::from(st))
-                .expr_ty(Body::of(self.db, st.into()).body_expr);
+                .expr_ty(Body::of(self.db, st.into()).root_expr());
             let Some((size, align)) = self.size_align_of(ty, locals)? else {
                 not_supported!("unsized extern static");
             };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 675fc371c619..44785d948a49 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -2251,7 +2251,7 @@ pub fn mir_body_query<'db>(
     let _p = tracing::info_span!("mir_body_query", ?detail).entered();
     let body = Body::of(db, def);
     let infer = InferenceResult::of(db, def);
-    let mut result = lower_body_to_mir(db, def, body, infer, body.body_expr)?;
+    let mut result = lower_body_to_mir(db, def, body, infer, body.root_expr())?;
     result.shrink_to_fit();
     Ok(Arc::new(result))
 }
@@ -2275,7 +2275,7 @@ pub fn lower_body_to_mir<'db>(
     // but this is currently also used for `X` in `[(); X]` which live in the same expression store
     root_expr: ExprId,
 ) -> Result<'db, MirBody> {
-    let is_root = root_expr == body.body_expr;
+    let is_root = root_expr == body.root_expr();
     // Extract params and self_param only when lowering the body's root expression for a function.
     if is_root && let DefWithBodyId::FunctionId(fid) = owner {
         let callable_sig =
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index 5d122ce446ad..00161d6d0825 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -3,7 +3,7 @@
 use hir_def::{
     AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,
     EnumId, EnumVariantId, ExpressionStoreOwnerId, FunctionId, GeneralConstId, GenericDefId,
-    ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
     signatures::{
         ConstSignature, EnumSignature, FunctionSignature, StaticSignature, StructSignature,
         TraitSignature, TypeAliasSignature, UnionSignature,
@@ -166,12 +166,24 @@ fn from(value: DefWithBodyId) -> Self {
     }
 }
 
+impl From<VariantId> for SolverDefId {
+    #[inline]
+    fn from(value: VariantId) -> Self {
+        match value {
+            VariantId::EnumVariantId(id) => id.into(),
+            VariantId::StructId(id) => id.into(),
+            VariantId::UnionId(id) => id.into(),
+        }
+    }
+}
+
 impl From<ExpressionStoreOwnerId> for SolverDefId {
     #[inline]
     fn from(value: ExpressionStoreOwnerId) -> Self {
         match value {
             ExpressionStoreOwnerId::Body(body_id) => body_id.into(),
             ExpressionStoreOwnerId::Signature(sig_id) => sig_id.into(),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => variant_id.into(),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs b/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
index d19fbbc18793..489895fe3cb7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/upvars.rs
@@ -47,7 +47,7 @@ pub fn upvars_mentioned(
     let body = Body::of(db, owner);
     let mut resolver = owner.resolver(db);
     let mut result = FxHashMap::default();
-    handle_expr_outside_closure(db, &mut resolver, owner, body, body.body_expr, &mut result);
+    handle_expr_outside_closure(db, &mut resolver, owner, body, body.root_expr(), &mut result);
     return if result.is_empty() {
         None
     } else {
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index 4efb7fcb6f2b..27e798514610 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -27,9 +27,9 @@
 use stdx::never;
 
 use crate::{
-    Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, ExternCrateDecl,
-    Field, Function, GenericParam, HasCrate, Impl, LangItem, LifetimeParam, Macro, Module,
-    ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+    Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, EnumVariant,
+    ExternCrateDecl, Field, Function, GenericParam, HasCrate, Impl, LangItem, LifetimeParam, Macro,
+    Module, ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -200,7 +200,7 @@ fn attr_id(self, _db: &dyn HirDatabase) -> AttrsOwner {
 }
 
 impl_has_attrs![
-    (Variant, EnumVariantId),
+    (EnumVariant, EnumVariantId),
     (Static, StaticId),
     (Const, ConstId),
     (Trait, TraitId),
@@ -407,7 +407,7 @@ fn resolve_assoc_or_field(
         TypeNs::AdtId(id) | TypeNs::AdtSelfType(id) => Adt::from(id).ty(db),
         TypeNs::EnumVariantId(id) => {
             // Enum variants don't have path candidates.
-            let variant = Variant::from(id);
+            let variant = EnumVariant::from(id);
             return resolve_field(db, variant.into(), name, ns);
         }
         TypeNs::TypeAliasId(id) => {
@@ -444,7 +444,7 @@ fn resolve_assoc_or_field(
                 .id
                 .enum_variants(db)
                 .variant(&name)
-                .map(|variant| DocLinkDef::ModuleDef(ModuleDef::Variant(variant.into())));
+                .map(|variant| DocLinkDef::ModuleDef(ModuleDef::EnumVariant(variant.into())));
         }
     };
     resolve_field(db, variant_def, name, ns)
@@ -506,7 +506,7 @@ fn resolve_impl_trait_item<'db>(
 
 fn resolve_field(
     db: &dyn HirDatabase,
-    def: VariantDef,
+    def: Variant,
     name: Name,
     ns: Option<Namespace>,
 ) -> Option<DocLinkDef> {
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index ef885f0be8a2..4bfdd239f937 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -29,9 +29,9 @@
 
 use crate::{
     Adt, AnyFunctionId, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
-    ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam,
-    Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitRef, TupleField, Type,
-    TypeAlias, TypeNs, TypeOrConstParam, TypeParam, Union, Variant,
+    EnumVariant, ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl,
+    LifetimeParam, Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitRef,
+    TupleField, Type, TypeAlias, TypeNs, TypeOrConstParam, TypeParam, Union,
 };
 
 fn write_builtin_derive_impl_method<'db>(
@@ -443,7 +443,7 @@ fn write_fields<'db>(
 }
 
 fn write_variants<'db>(
-    variants: &[Variant],
+    variants: &[EnumVariant],
     has_where_clause: bool,
     limit: usize,
     f: &mut HirFormatter<'_, 'db>,
@@ -497,7 +497,7 @@ fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
     }
 }
 
-impl<'db> HirDisplay<'db> for Variant {
+impl<'db> HirDisplay<'db> for EnumVariant {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
         let data = self.id.fields(f.db);
diff --git a/src/tools/rust-analyzer/crates/hir/src/from_id.rs b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
index 1aeed874af45..0a48be5473d2 100644
--- a/src/tools/rust-analyzer/crates/hir/src/from_id.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
@@ -5,14 +5,14 @@
 
 use hir_def::{
     AdtId, AssocItemId, BuiltinDeriveImplId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId,
-    FieldId, GenericDefId, GenericParamId, ModuleDefId, VariantId,
+    FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, ModuleDefId, VariantId,
     hir::{BindingId, LabelId},
 };
 use hir_ty::next_solver::AnyImplId;
 
 use crate::{
-    Adt, AnyFunctionId, AssocItem, BuiltinType, DefWithBody, Field, GenericDef, GenericParam,
-    ItemInNs, Label, Local, ModuleDef, Variant, VariantDef,
+    Adt, AnyFunctionId, AssocItem, BuiltinType, DefWithBody, EnumVariant, ExpressionStoreOwner,
+    Field, Function, GenericDef, GenericParam, Impl, ItemInNs, Label, Local, ModuleDef, Variant,
 };
 
 macro_rules! from_id {
@@ -71,6 +71,15 @@ fn from(id: Adt) -> Self {
     }
 }
 
+impl From<VariantId> for Variant {
+    fn from(v: VariantId) -> Self {
+        match v {
+            VariantId::EnumVariantId(it) => Variant::EnumVariant(it.into()),
+            VariantId::StructId(it) => Variant::Struct(it.into()),
+            VariantId::UnionId(it) => Variant::Union(it.into()),
+        }
+    }
+}
 impl From<GenericParamId> for GenericParam {
     fn from(id: GenericParamId) -> Self {
         match id {
@@ -91,14 +100,14 @@ fn from(id: GenericParam) -> Self {
     }
 }
 
-impl From<EnumVariantId> for Variant {
+impl From<EnumVariantId> for EnumVariant {
     fn from(id: EnumVariantId) -> Self {
-        Variant { id }
+        EnumVariant { id }
     }
 }
 
-impl From<Variant> for EnumVariantId {
-    fn from(def: Variant) -> Self {
+impl From<EnumVariant> for EnumVariantId {
+    fn from(def: EnumVariant) -> Self {
         def.id
     }
 }
@@ -109,7 +118,7 @@ fn from(id: ModuleDefId) -> Self {
             ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
             ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
             ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
-            ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
+            ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
             ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
             ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
             ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
@@ -130,7 +139,7 @@ fn try_from(id: ModuleDef) -> Result<Self, Self::Error> {
                 AnyFunctionId::BuiltinDeriveImplMethod { .. } => return Err(()),
             },
             ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
-            ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
+            ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
             ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
             ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
             ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
@@ -151,7 +160,7 @@ fn try_from(def: DefWithBody) -> Result<Self, ()> {
             },
             DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
             DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
-            DefWithBody::Variant(it) => DefWithBodyId::VariantId(it.into()),
+            DefWithBody::EnumVariant(it) => DefWithBodyId::VariantId(it.into()),
         })
     }
 }
@@ -162,7 +171,7 @@ fn from(def: DefWithBodyId) -> Self {
             DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
             DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
             DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
-            DefWithBodyId::VariantId(it) => DefWithBody::Variant(it.into()),
+            DefWithBodyId::VariantId(it) => DefWithBody::EnumVariant(it.into()),
         }
     }
 }
@@ -209,22 +218,12 @@ fn from(id: Adt) -> Self {
     }
 }
 
-impl From<VariantId> for VariantDef {
-    fn from(def: VariantId) -> Self {
+impl From<Variant> for VariantId {
+    fn from(def: Variant) -> Self {
         match def {
-            VariantId::StructId(it) => VariantDef::Struct(it.into()),
-            VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
-            VariantId::UnionId(it) => VariantDef::Union(it.into()),
-        }
-    }
-}
-
-impl From<VariantDef> for VariantId {
-    fn from(def: VariantDef) -> Self {
-        match def {
-            VariantDef::Struct(it) => VariantId::StructId(it.id),
-            VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
-            VariantDef::Union(it) => VariantId::UnionId(it.id),
+            Variant::Struct(it) => VariantId::StructId(it.id),
+            Variant::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+            Variant::Union(it) => VariantId::UnionId(it.id),
         }
     }
 }
@@ -322,3 +321,43 @@ fn from(value: hir_def::FunctionId) -> Self {
         crate::Function { id: AnyFunctionId::FunctionId(value) }
     }
 }
+
+impl TryFrom<ExpressionStoreOwner> for ExpressionStoreOwnerId {
+    type Error = ();
+
+    fn try_from(v: ExpressionStoreOwner) -> Result<Self, Self::Error> {
+        match v {
+            ExpressionStoreOwner::Signature(generic_def_id) => {
+                Ok(Self::Signature(generic_def_id.try_into()?))
+            }
+            ExpressionStoreOwner::Body(def_with_body_id) => {
+                Ok(Self::Body(def_with_body_id.try_into()?))
+            }
+            ExpressionStoreOwner::VariantFields(variant_id) => {
+                Ok(Self::VariantFields(variant_id.into()))
+            }
+        }
+    }
+}
+
+impl TryFrom<Function> for FunctionId {
+    type Error = ();
+
+    fn try_from(v: Function) -> Result<Self, Self::Error> {
+        match v.id {
+            AnyFunctionId::FunctionId(id) => Ok(id),
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<Impl> for ImplId {
+    type Error = ();
+
+    fn try_from(v: Impl) -> Result<Self, Self::Error> {
+        match v.id {
+            AnyImplId::ImplId(id) => Ok(id),
+            _ => Err(()),
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index 752c4f3173e6..f9badc0b7901 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -13,9 +13,9 @@
 use tt::TextRange;
 
 use crate::{
-    Adt, AnyFunctionId, Callee, Const, Enum, ExternCrateDecl, Field, FieldSource, Function, Impl,
-    InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param, SelfParam, Static,
-    Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef, db::HirDatabase,
+    Adt, AnyFunctionId, Callee, Const, Enum, EnumVariant, ExternCrateDecl, Field, FieldSource,
+    Function, Impl, InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param,
+    SelfParam, Static, Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant, db::HirDatabase,
 };
 
 pub trait HasSource: Sized {
@@ -124,13 +124,13 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         }
     }
 }
-impl HasSource for VariantDef {
+impl HasSource for Variant {
     type Ast = ast::VariantDef;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         match self {
-            VariantDef::Struct(s) => Some(s.source(db)?.map(ast::VariantDef::Struct)),
-            VariantDef::Union(u) => Some(u.source(db)?.map(ast::VariantDef::Union)),
-            VariantDef::Variant(v) => Some(v.source(db)?.map(ast::VariantDef::Variant)),
+            Variant::Struct(s) => Some(s.source(db)?.map(ast::VariantDef::Struct)),
+            Variant::Union(u) => Some(u.source(db)?.map(ast::VariantDef::Union)),
+            Variant::EnumVariant(v) => Some(v.source(db)?.map(ast::VariantDef::Variant)),
         }
     }
 }
@@ -152,7 +152,7 @@ fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         Some(self.id.lookup(db).source(db))
     }
 }
-impl HasSource for Variant {
+impl HasSource for EnumVariant {
     type Ast = ast::Variant;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Variant>> {
         Some(self.id.lookup(db).source(db))
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 67527150bd45..bc5e16483054 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -356,8 +356,7 @@ pub enum ModuleDef {
     Function(Function),
     Adt(Adt),
     // Can't be directly declared, but can be imported.
-    // FIXME: Rename to `EnumVariant`
-    Variant(Variant),
+    EnumVariant(EnumVariant),
     Const(Const),
     Static(Static),
     Trait(Trait),
@@ -369,7 +368,7 @@ pub enum ModuleDef {
     Module,
     Function,
     Adt(Struct, Enum, Union),
-    Variant,
+    EnumVariant,
     Const,
     Static,
     Trait,
@@ -379,12 +378,12 @@ pub enum ModuleDef {
     for ModuleDef
 );
 
-impl From<VariantDef> for ModuleDef {
-    fn from(var: VariantDef) -> Self {
+impl From<Variant> for ModuleDef {
+    fn from(var: Variant) -> Self {
         match var {
-            VariantDef::Struct(t) => Adt::from(t).into(),
-            VariantDef::Union(t) => Adt::from(t).into(),
-            VariantDef::Variant(t) => t.into(),
+            Variant::Struct(t) => Adt::from(t).into(),
+            Variant::Union(t) => Adt::from(t).into(),
+            Variant::EnumVariant(t) => t.into(),
         }
     }
 }
@@ -395,7 +394,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
             ModuleDef::Module(it) => it.parent(db),
             ModuleDef::Function(it) => Some(it.module(db)),
             ModuleDef::Adt(it) => Some(it.module(db)),
-            ModuleDef::Variant(it) => Some(it.module(db)),
+            ModuleDef::EnumVariant(it) => Some(it.module(db)),
             ModuleDef::Const(it) => Some(it.module(db)),
             ModuleDef::Static(it) => Some(it.module(db)),
             ModuleDef::Trait(it) => Some(it.module(db)),
@@ -428,7 +427,7 @@ pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
             ModuleDef::Adt(it) => it.name(db),
             ModuleDef::Trait(it) => it.name(db),
             ModuleDef::Function(it) => it.name(db),
-            ModuleDef::Variant(it) => it.name(db),
+            ModuleDef::EnumVariant(it) => it.name(db),
             ModuleDef::TypeAlias(it) => it.name(db),
             ModuleDef::Static(it) => it.name(db),
             ModuleDef::Macro(it) => it.name(db),
@@ -457,7 +456,7 @@ pub fn diagnostics<'db>(
             ModuleDef::Module(it) => it.id.into(),
             ModuleDef::Const(it) => it.id.into(),
             ModuleDef::Static(it) => it.id.into(),
-            ModuleDef::Variant(it) => it.id.into(),
+            ModuleDef::EnumVariant(it) => it.id.into(),
             ModuleDef::BuiltinType(_) | ModuleDef::Macro(_) => return Vec::new(),
         };
 
@@ -486,7 +485,7 @@ pub fn as_def_with_body(self) -> Option<DefWithBody> {
             ModuleDef::Function(it) => Some(it.into()),
             ModuleDef::Const(it) => Some(it.into()),
             ModuleDef::Static(it) => Some(it.into()),
-            ModuleDef::Variant(it) => Some(it.into()),
+            ModuleDef::EnumVariant(it) => Some(it.into()),
 
             ModuleDef::Module(_)
             | ModuleDef::Adt(_)
@@ -505,7 +504,7 @@ pub fn as_self_generic_def(self) -> Option<GenericDef> {
             ModuleDef::Trait(it) => Some(it.into()),
             ModuleDef::TypeAlias(it) => Some(it.into()),
             ModuleDef::Module(_)
-            | ModuleDef::Variant(_)
+            | ModuleDef::EnumVariant(_)
             | ModuleDef::Static(_)
             | ModuleDef::Const(_)
             | ModuleDef::BuiltinType(_)
@@ -521,7 +520,7 @@ pub fn as_generic_def(self) -> Option<GenericDef> {
             ModuleDef::TypeAlias(it) => Some(it.into()),
             ModuleDef::Static(it) => Some(it.into()),
             ModuleDef::Const(it) => Some(it.into()),
-            ModuleDef::Variant(_)
+            ModuleDef::EnumVariant(_)
             | ModuleDef::Module(_)
             | ModuleDef::BuiltinType(_)
             | ModuleDef::Macro(_) => None,
@@ -533,7 +532,7 @@ pub fn attrs(&self, db: &dyn HirDatabase) -> Option<AttrsWithOwner> {
             ModuleDef::Module(it) => it.attrs(db),
             ModuleDef::Function(it) => HasAttrs::attrs(*it, db),
             ModuleDef::Adt(it) => it.attrs(db),
-            ModuleDef::Variant(it) => it.attrs(db),
+            ModuleDef::EnumVariant(it) => it.attrs(db),
             ModuleDef::Const(it) => it.attrs(db),
             ModuleDef::Static(it) => it.attrs(db),
             ModuleDef::Trait(it) => it.attrs(db),
@@ -563,7 +562,7 @@ fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
             ModuleDef::Static(it) => it.visibility(db),
             ModuleDef::Trait(it) => it.visibility(db),
             ModuleDef::TypeAlias(it) => it.visibility(db),
-            ModuleDef::Variant(it) => it.visibility(db),
+            ModuleDef::EnumVariant(it) => it.visibility(db),
             ModuleDef::Macro(it) => it.visibility(db),
             ModuleDef::BuiltinType(_) => Visibility::Public,
         }
@@ -1300,7 +1299,7 @@ fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Field {
-    pub(crate) parent: VariantDef,
+    pub(crate) parent: Variant,
     pub(crate) id: LocalFieldId,
 }
 
@@ -1324,7 +1323,7 @@ pub fn ty(&self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub struct TupleField {
-    pub owner: DefWithBodyId,
+    pub owner: ExpressionStoreOwnerId,
     pub tuple: TupleId,
     pub index: u32,
 }
@@ -1406,9 +1405,9 @@ pub fn ty_with_args<'db>(
     ) -> Type<'db> {
         let var_id = self.parent.into();
         let def_id: AdtId = match self.parent {
-            VariantDef::Struct(it) => it.id.into(),
-            VariantDef::Union(it) => it.id.into(),
-            VariantDef::Variant(it) => it.parent_enum(db).id.into(),
+            Variant::Struct(it) => it.id.into(),
+            Variant::Union(it) => it.id.into(),
+            Variant::EnumVariant(it) => it.parent_enum(db).id.into(),
         };
         let interner = DbInterner::new_no_crate(db);
         let args = generic_args_from_tys(interner, def_id.into(), generics.map(|ty| ty.ty));
@@ -1434,7 +1433,7 @@ pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
         .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).into()).unwrap()))
     }
 
-    pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
+    pub fn parent_def(&self, _db: &dyn HirDatabase) -> Variant {
         self.parent
     }
 }
@@ -1615,8 +1614,8 @@ pub fn name(self, db: &dyn HirDatabase) -> Name {
         EnumSignature::of(db, self.id).name.clone()
     }
 
-    pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {
-        self.id.enum_variants(db).variants.iter().map(|&(id, _, _)| Variant { id }).collect()
+    pub fn variants(self, db: &dyn HirDatabase) -> Vec<EnumVariant> {
+        self.id.enum_variants(db).variants.iter().map(|&(id, _, _)| EnumVariant { id }).collect()
     }
 
     pub fn num_variants(self, db: &dyn HirDatabase) -> usize {
@@ -1708,19 +1707,18 @@ pub fn ty(self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
     }
 }
 
-impl From<&Variant> for DefWithBodyId {
-    fn from(&v: &Variant) -> Self {
+impl From<&EnumVariant> for DefWithBodyId {
+    fn from(&v: &EnumVariant) -> Self {
         DefWithBodyId::VariantId(v.into())
     }
 }
 
-// FIXME: Rename to `EnumVariant`
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Variant {
+pub struct EnumVariant {
     pub(crate) id: EnumVariantId,
 }
 
-impl Variant {
+impl EnumVariant {
     pub fn module(self, db: &dyn HirDatabase) -> Module {
         Module { id: self.id.module(db) }
     }
@@ -1794,7 +1792,7 @@ pub fn instantiate_infer<'db>(self, infer_ctxt: &InferCtxt<'db>) -> Instantiated
 // FIXME: Rename to `EnumVariant`
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct InstantiatedVariant<'db> {
-    pub(crate) inner: Variant,
+    pub(crate) inner: EnumVariant,
     pub(crate) args: GenericArgs<'db>,
 }
 
@@ -1825,7 +1823,7 @@ pub enum StructKind {
 }
 
 /// Variants inherit visibility from the parent enum.
-impl HasVisibility for Variant {
+impl HasVisibility for EnumVariant {
     fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
         self.parent_enum(db).visibility(db)
     }
@@ -1934,35 +1932,35 @@ fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum VariantDef {
+pub enum Variant {
     Struct(Struct),
     Union(Union),
-    Variant(Variant),
+    EnumVariant(EnumVariant),
 }
-impl_from!(Struct, Union, Variant for VariantDef);
+impl_from!(Struct, Union, EnumVariant for Variant);
 
-impl VariantDef {
+impl Variant {
     pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
         match self {
-            VariantDef::Struct(it) => it.fields(db),
-            VariantDef::Union(it) => it.fields(db),
-            VariantDef::Variant(it) => it.fields(db),
+            Variant::Struct(it) => it.fields(db),
+            Variant::Union(it) => it.fields(db),
+            Variant::EnumVariant(it) => it.fields(db),
         }
     }
 
     pub fn module(self, db: &dyn HirDatabase) -> Module {
         match self {
-            VariantDef::Struct(it) => it.module(db),
-            VariantDef::Union(it) => it.module(db),
-            VariantDef::Variant(it) => it.module(db),
+            Variant::Struct(it) => it.module(db),
+            Variant::Union(it) => it.module(db),
+            Variant::EnumVariant(it) => it.module(db),
         }
     }
 
     pub fn name(&self, db: &dyn HirDatabase) -> Name {
         match self {
-            VariantDef::Struct(s) => (*s).name(db),
-            VariantDef::Union(u) => (*u).name(db),
-            VariantDef::Variant(e) => (*e).name(db),
+            Variant::Struct(s) => (*s).name(db),
+            Variant::Union(u) => (*u).name(db),
+            Variant::EnumVariant(e) => (*e).name(db),
         }
     }
 }
@@ -1971,6 +1969,7 @@ pub fn name(&self, db: &dyn HirDatabase) -> Name {
 pub enum ExpressionStoreOwner {
     Body(DefWithBody),
     Signature(GenericDef),
+    VariantFields(Variant),
 }
 
 impl From<GenericDef> for ExpressionStoreOwner {
@@ -1992,6 +1991,9 @@ fn from(v: ExpressionStoreOwnerId) -> Self {
                 Self::Signature(generic_def_id.into())
             }
             ExpressionStoreOwnerId::Body(def_with_body_id) => Self::Body(def_with_body_id.into()),
+            ExpressionStoreOwnerId::VariantFields(variant_id) => {
+                Self::VariantFields(variant_id.into())
+            }
         }
     }
 }
@@ -2001,6 +2003,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
         match self {
             Self::Body(body) => body.module(db),
             Self::Signature(generic_def) => generic_def.module(db),
+            Self::VariantFields(variant) => variant.module(db),
         }
     }
 }
@@ -2011,9 +2014,9 @@ pub enum DefWithBody {
     Function(Function),
     Static(Static),
     Const(Const),
-    Variant(Variant),
+    EnumVariant(EnumVariant),
 }
-impl_from!(Function, Const, Static, Variant for DefWithBody);
+impl_from!(Function, Const, Static, EnumVariant for DefWithBody);
 
 impl DefWithBody {
     pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -2021,7 +2024,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module {
             DefWithBody::Const(c) => c.module(db),
             DefWithBody::Function(f) => f.module(db),
             DefWithBody::Static(s) => s.module(db),
-            DefWithBody::Variant(v) => v.module(db),
+            DefWithBody::EnumVariant(v) => v.module(db),
         }
     }
 
@@ -2030,7 +2033,7 @@ pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
             DefWithBody::Function(f) => Some(f.name(db)),
             DefWithBody::Static(s) => Some(s.name(db)),
             DefWithBody::Const(c) => c.name(db),
-            DefWithBody::Variant(v) => Some(v.name(db)),
+            DefWithBody::EnumVariant(v) => Some(v.name(db)),
         }
     }
 
@@ -2040,7 +2043,7 @@ pub fn body_type(self, db: &dyn HirDatabase) -> Type<'_> {
             DefWithBody::Function(it) => it.ret_type(db),
             DefWithBody::Static(it) => it.ty(db),
             DefWithBody::Const(it) => it.ty(db),
-            DefWithBody::Variant(it) => it.parent_enum(db).variant_body_ty(db),
+            DefWithBody::EnumVariant(it) => it.parent_enum(db).variant_body_ty(db),
         }
     }
 
@@ -2052,7 +2055,7 @@ fn id(&self) -> Option<DefWithBodyId> {
             },
             DefWithBody::Static(it) => it.id.into(),
             DefWithBody::Const(it) => it.id.into(),
-            DefWithBody::Variant(it) => it.into(),
+            DefWithBody::EnumVariant(it) => it.into(),
         })
     }
 
@@ -2096,7 +2099,7 @@ pub fn diagnostics<'db>(
             },
             DefWithBody::Static(id) => &StaticSignature::with_source_map(db, id.into()).1,
             DefWithBody::Const(id) => &ConstSignature::with_source_map(db, id.into()).1,
-            DefWithBody::Variant(variant) => {
+            DefWithBody::EnumVariant(variant) => {
                 let enum_id = variant.parent_enum(db).id;
                 &EnumSignature::with_source_map(db, enum_id).1
             }
@@ -3785,7 +3788,7 @@ fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
         match self {
             DefWithBody::Function(it) => it.as_assoc_item(db),
             DefWithBody::Const(it) => it.as_assoc_item(db),
-            DefWithBody::Static(_) | DefWithBody::Variant(_) => None,
+            DefWithBody::Static(_) | DefWithBody::EnumVariant(_) => None,
         }
     }
 }
@@ -4369,11 +4372,9 @@ pub fn ty(self, db: &dyn HirDatabase) -> Type<'_> {
     /// All definitions for this local. Example: `let (a$0, _) | (_, a$0) = it;`
     pub fn sources(self, db: &dyn HirDatabase) -> Vec<LocalSource> {
         let b;
-        let s;
         let (_, source_map) = match self.parent {
             ExpressionStoreOwnerId::Signature(generic_def_id) => {
-                s = ExpressionStore::with_source_map(db, generic_def_id.into());
-                (s.0, s.1)
+                ExpressionStore::with_source_map(db, generic_def_id.into())
             }
             ExpressionStoreOwnerId::Body(def_with_body_id) => {
                 b = Body::with_source_map(db, def_with_body_id);
@@ -4388,6 +4389,9 @@ pub fn sources(self, db: &dyn HirDatabase) -> Vec<LocalSource> {
                 }
                 (&b.0.store, &b.1.store)
             }
+            ExpressionStoreOwnerId::VariantFields(def) => {
+                ExpressionStore::with_source_map(db, def.into())
+            }
         };
         source_map
             .patterns_for_binding(self.binding_id)
@@ -4409,11 +4413,9 @@ pub fn sources(self, db: &dyn HirDatabase) -> Vec<LocalSource> {
     /// The leftmost definition for this local. Example: `let (a$0, _) | (_, a) = it;`
     pub fn primary_source(self, db: &dyn HirDatabase) -> LocalSource {
         let b;
-        let s;
         let (_, source_map) = match self.parent {
             ExpressionStoreOwnerId::Signature(generic_def_id) => {
-                s = ExpressionStore::with_source_map(db, generic_def_id.into());
-                (s.0, s.1)
+                ExpressionStore::with_source_map(db, generic_def_id.into())
             }
             ExpressionStoreOwnerId::Body(def_with_body_id) => {
                 b = Body::with_source_map(db, def_with_body_id);
@@ -4428,6 +4430,9 @@ pub fn primary_source(self, db: &dyn HirDatabase) -> LocalSource {
                 }
                 (&b.0.store, &b.1.store)
             }
+            ExpressionStoreOwnerId::VariantFields(def) => {
+                ExpressionStore::with_source_map(db, def.into())
+            }
         };
         source_map
             .patterns_for_binding(self.binding_id)
@@ -6519,7 +6524,7 @@ enum Callee<'db> {
 pub enum CallableKind<'db> {
     Function(Function),
     TupleStruct(Struct),
-    TupleEnumVariant(Variant),
+    TupleEnumVariant(EnumVariant),
     Closure(Closure<'db>),
     FnPtr,
     FnImpl(FnTrait),
@@ -6869,7 +6874,7 @@ fn krate(&self, db: &dyn HirDatabase) -> Crate {
     }
 }
 
-impl HasCrate for Variant {
+impl HasCrate for EnumVariant {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
         self.module(db).krate(db)
     }
@@ -7038,9 +7043,9 @@ fn name(&self, db: &dyn HirDatabase) -> Option<Name> {
     Struct,
     Union,
     Enum,
-    Variant,
+    EnumVariant,
     Adt,
-    VariantDef,
+    Variant,
     DefWithBody,
     Function,
     ExternCrateDecl,
@@ -7264,9 +7269,9 @@ fn param_env_from_has_crate<'db>(
 
 fn body_param_env_from_has_crate<'db>(
     db: &'db dyn HirDatabase,
-    id: impl hir_def::HasModule + Into<DefWithBodyId> + Copy,
+    id: impl hir_def::HasModule + Into<ExpressionStoreOwnerId> + Copy,
 ) -> ParamEnvAndCrate<'db> {
-    ParamEnvAndCrate { param_env: db.trait_environment(id.into().into()), krate: id.krate(db) }
+    ParamEnvAndCrate { param_env: db.trait_environment(id.into()), krate: id.krate(db) }
 }
 
 fn empty_param_env<'db>(krate: base_db::Crate) -> ParamEnvAndCrate<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index f1aabb59337a..4e9e3c44be11 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -16,7 +16,7 @@
     BuiltinDeriveImplId, DefWithBodyId, ExpressionStoreOwnerId, HasModule, MacroId, StructId,
     TraitId, VariantId,
     attrs::parse_extra_crate_attrs,
-    expr_store::{Body, ExprOrPatSource, HygieneId, path::Path},
+    expr_store::{Body, ExprOrPatSource, ExpressionStore, HygieneId, path::Path},
     hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat},
     nameres::{ModuleOrigin, crate_def_map},
     resolver::{self, HasResolver, Resolver, TypeNs, ValueNs},
@@ -32,7 +32,7 @@
 };
 use hir_ty::{
     InferenceResult,
-    diagnostics::{unsafe_operations, unsafe_operations_for_body},
+    diagnostics::unsafe_operations,
     infer_query_with_inspect,
     next_solver::{
         AnyImplId, DbInterner, Span,
@@ -55,10 +55,10 @@
 
 use crate::{
     Adjust, Adjustment, Adt, AnyFunctionId, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const,
-    ConstParam, Crate, DefWithBody, DeriveHelper, Enum, ExpressionStoreOwner, Field, Function,
+    ConstParam, Crate, DeriveHelper, Enum, EnumVariant, ExpressionStoreOwner, Field, Function,
     GenericSubstitution, HasSource, Impl, InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam,
     Local, Macro, Module, ModuleDef, Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule,
-    Trait, TupleField, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+    Trait, TupleField, Type, TypeAlias, TypeParam, Union, Variant,
     db::HirDatabase,
     semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
     source_analyzer::{SourceAnalyzer, resolve_hir_path},
@@ -91,7 +91,7 @@ pub(crate) fn in_type_ns(&self) -> Option<TypeNs> {
             }
             PathResolution::Def(
                 ModuleDef::Const(_)
-                | ModuleDef::Variant(_)
+                | ModuleDef::EnumVariant(_)
                 | ModuleDef::Macro(_)
                 | ModuleDef::Function(_)
                 | ModuleDef::Module(_)
@@ -368,8 +368,8 @@ pub fn resolve_try_expr(&self, try_expr: &ast::TryExpr) -> Option<Function> {
         self.imp.resolve_try_expr(try_expr)
     }
 
-    pub fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantDef> {
-        self.imp.resolve_variant(record_lit).map(VariantDef::from)
+    pub fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<Variant> {
+        self.imp.resolve_variant(record_lit).map(Variant::from)
     }
 
     pub fn file_to_module_def(&self, file: impl Into<FileId>) -> Option<Module> {
@@ -410,7 +410,7 @@ pub fn to_enum_def(&self, e: &ast::Enum) -> Option<Enum> {
         self.imp.to_def(e)
     }
 
-    pub fn to_enum_variant_def(&self, v: &ast::Variant) -> Option<Variant> {
+    pub fn to_enum_variant_def(&self, v: &ast::Variant) -> Option<EnumVariant> {
         self.imp.to_def(v)
     }
 
@@ -792,7 +792,8 @@ pub fn rename_conflicts(&self, to_be_renamed: &Local, new_name: &Name) -> Vec<Lo
         };
         let body = Body::of(self.db, def);
         let resolver = to_be_renamed.parent.resolver(self.db);
-        let starting_expr = body.binding_owner(to_be_renamed.binding_id).unwrap_or(body.body_expr);
+        let starting_expr =
+            body.binding_owner(to_be_renamed.binding_id).unwrap_or(body.root_expr());
         let mut visitor = RenameConflictsVisitor {
             body,
             conflicts: FxHashSet::default(),
@@ -1918,36 +1919,32 @@ pub fn resolve_macro_call_arm(&self, macro_call: &ast::MacroCall) -> Option<u32>
         self.db.parse_macro_expansion(file_id).value.1.matched_arm
     }
 
-    pub fn get_unsafe_ops(&self, def: DefWithBody) -> FxHashSet<ExprOrPatSource> {
-        let Ok(def) = DefWithBodyId::try_from(def) else {
-            return FxHashSet::default();
-        };
-        let (body, source_map) = Body::with_source_map(self.db, def);
+    pub fn get_unsafe_ops(&self, def: ExpressionStoreOwner) -> FxHashSet<ExprOrPatSource> {
+        let Ok(def) = ExpressionStoreOwnerId::try_from(def) else { return Default::default() };
+        let (body, source_map) = ExpressionStore::with_source_map(self.db, def);
         let infer = InferenceResult::of(self.db, def);
         let mut res = FxHashSet::default();
-        unsafe_operations_for_body(self.db, infer, def, body, &mut |node| {
-            if let Ok(node) = source_map.expr_or_pat_syntax(node) {
-                res.insert(node);
-            }
-        });
+        for root in body.expr_roots() {
+            unsafe_operations(self.db, infer, def, body, root, &mut |node, _| {
+                if let Ok(node) = source_map.expr_or_pat_syntax(node) {
+                    res.insert(node);
+                }
+            });
+        }
         res
     }
 
     pub fn get_unsafe_ops_for_unsafe_block(&self, block: ast::BlockExpr) -> Vec<ExprOrPatSource> {
         always!(block.unsafe_token().is_some());
+        let Some(sa) = self.analyze(block.syntax()) else { return vec![] };
+        let Some((def, store, sm, Some(infer))) = sa.def() else { return vec![] };
         let block = self.wrap_node_infile(ast::Expr::from(block));
-        let Some(def) = self.body_for(block.syntax()) else { return Vec::new() };
-        let Ok(def) = def.try_into() else {
-            return Vec::new();
-        };
-        let (body, source_map) = Body::with_source_map(self.db, def);
-        let infer = InferenceResult::of(self.db, def);
-        let Some(ExprOrPatId::ExprId(block)) = source_map.node_expr(block.as_ref()) else {
+        let Some(ExprOrPatId::ExprId(block)) = sm.node_expr(block.as_ref()) else {
             return Vec::new();
         };
         let mut res = Vec::default();
-        unsafe_operations(self.db, infer, def, body, block, &mut |node, _| {
-            if let Ok(node) = source_map.expr_or_pat_syntax(node) {
+        unsafe_operations(self.db, infer, def, store, block, &mut |node, _| {
+            if let Ok(node) = sm.expr_or_pat_syntax(node) {
                 res.push(node);
             }
         });
@@ -1999,7 +1996,7 @@ pub fn resolve_use_type_arg(&self, name: &ast::NameRef) -> Option<TypeParam> {
     pub fn resolve_offset_of_field(
         &self,
         name_ref: &ast::NameRef,
-    ) -> Option<(Either<Variant, Field>, GenericSubstitution<'db>)> {
+    ) -> Option<(Either<EnumVariant, Field>, GenericSubstitution<'db>)> {
         self.analyze_no_infer(name_ref.syntax())?.resolve_offset_of_field(self.db, name_ref)
     }
 
@@ -2119,13 +2116,9 @@ pub fn source_with_range<Def: HasSource>(
         Some(res)
     }
 
-    pub fn body_for(&self, node: InFile<&SyntaxNode>) -> Option<DefWithBody> {
+    pub fn store_owner_for(&self, node: InFile<&SyntaxNode>) -> Option<ExpressionStoreOwner> {
         let container = self.with_ctx(|ctx| ctx.find_container(node))?;
-
-        match container {
-            ChildContainer::DefWithBodyId(def) => Some(def.into()),
-            _ => None,
-        }
+        container.as_expression_store_owner().map(|id| id.into())
     }
 
     /// Returns none if the file of the node is not part of a crate.
@@ -2169,7 +2162,7 @@ fn analyze_impl(
                 });
             }
             ChildContainer::VariantId(def) => {
-                return Some(SourceAnalyzer::new_variant_body(self.db, def, node, offset));
+                return Some(SourceAnalyzer::new_variant_body(self.db, def, node, offset, infer));
             }
             ChildContainer::TraitId(it) => {
                 return Some(if infer {
@@ -2522,7 +2515,7 @@ fn to_def(sema: &SemanticsImpl<'_>, src: InFile<&Self>) -> Option<Self::Def> {
     (crate::Function, ast::Fn, fn_to_def),
     (crate::Field, ast::RecordField, record_field_to_def),
     (crate::Field, ast::TupleField, tuple_field_to_def),
-    (crate::Variant, ast::Variant, enum_variant_to_def),
+    (crate::EnumVariant, ast::Variant, enum_variant_to_def),
     (crate::TypeParam, ast::TypeParam, type_param_to_def),
     (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
     (crate::ConstParam, ast::ConstParam, const_param_to_def),
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
index 8c398728b08a..a9a779a287d6 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
@@ -738,7 +738,7 @@ fn child_by_source(self, db: &dyn HirDatabase, file_id: HirFileId) -> DynMap {
         }
     }
 
-    fn as_expression_store_owner(self) -> Option<ExpressionStoreOwnerId> {
+    pub(crate) fn as_expression_store_owner(self) -> Option<ExpressionStoreOwnerId> {
         match self {
             ChildContainer::DefWithBodyId(it) => Some(it.into()),
             ChildContainer::ModuleId(_) => None,
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index 1b41c78892d6..1a34fa913425 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -20,7 +20,7 @@
     hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat, PatId, generics::GenericParams},
     lang_item::LangItems,
     nameres::MacroSubNs,
-    resolver::{HasResolver, Resolver, TypeNs, ValueNs, resolver_for_scope},
+    resolver::{Resolver, TypeNs, ValueNs, resolver_for_scope},
     type_ref::{Mutability, TypeRef, TypeRefId},
 };
 use hir_expand::{
@@ -58,8 +58,8 @@
 
 use crate::{
     Adt, AnyFunctionId, AssocItem, BindingMode, BuiltinAttr, BuiltinType, Callable, Const,
-    DeriveHelper, Field, Function, GenericSubstitution, Local, Macro, ModuleDef, Static, Struct,
-    ToolModule, Trait, TupleField, Type, TypeAlias, Variant,
+    DeriveHelper, EnumVariant, Field, Function, GenericSubstitution, Local, Macro, ModuleDef,
+    Static, Struct, ToolModule, Trait, TupleField, Type, TypeAlias,
     db::HirDatabase,
     semantics::{PathResolution, PathResolutionPerNs},
 };
@@ -81,11 +81,11 @@ pub(crate) enum BodyOrSig<'db> {
         source_map: &'db BodySourceMap,
         infer: Option<&'db InferenceResult>,
     },
-    // To be folded into body once it is considered one
     VariantFields {
         def: VariantId,
         store: &'db ExpressionStore,
         source_map: &'db ExpressionStoreSourceMap,
+        infer: Option<&'db InferenceResult>,
     },
     Sig {
         def: GenericDefId,
@@ -196,14 +196,34 @@ pub(crate) fn new_generic_def_(
     pub(crate) fn new_variant_body(
         db: &'db dyn HirDatabase,
         def: VariantId,
-        InFile { file_id, .. }: InFile<&SyntaxNode>,
-        _offset: Option<TextSize>,
+        node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
+        offset: Option<TextSize>,
+        infer: bool,
     ) -> SourceAnalyzer<'db> {
         let (fields, source_map) = def.fields_with_source_map(db);
-        let resolver = def.resolver(db);
+        let scopes = ExprScopes::of(db, def);
+        let scope = match offset {
+            None => scope_for(db, scopes, source_map, node),
+            Some(offset) => {
+                debug_assert!(
+                    node.text_range().contains_inclusive(offset),
+                    "{:?} not in {:?}",
+                    offset,
+                    node.text_range()
+                );
+                scope_for_offset(db, scopes, source_map, node.file_id, offset)
+            }
+        };
+        let resolver = resolver_for_scope(db, def, scope);
+        let infer = if infer { Some(InferenceResult::of(db, def)) } else { None };
         SourceAnalyzer {
             resolver,
-            body_or_sig: Some(BodyOrSig::VariantFields { def, store: &fields.store, source_map }),
+            body_or_sig: Some(BodyOrSig::VariantFields {
+                def,
+                store: &fields.store,
+                source_map,
+                infer,
+            }),
             file_id,
         }
     }
@@ -215,31 +235,39 @@ pub(crate) fn new_for_resolver(
         SourceAnalyzer { resolver, body_or_sig: None, file_id: node.file_id }
     }
 
-    // FIXME: Remove this
-    fn body_(&self) -> Option<(DefWithBodyId, &Body, &BodySourceMap, Option<&InferenceResult>)> {
-        self.body_or_sig.as_ref().and_then(|it| match it {
-            BodyOrSig::Body { def, body, source_map, infer } => {
-                Some((*def, &**body, &**source_map, infer.as_deref()))
-            }
-            _ => None,
+    fn owner(&self) -> Option<ExpressionStoreOwnerId> {
+        self.body_or_sig.as_ref().map(|it| match *it {
+            BodyOrSig::VariantFields { def, .. } => def.into(),
+            BodyOrSig::Sig { def, .. } => def.into(),
+            BodyOrSig::Body { def, .. } => def.into(),
         })
     }
 
     fn infer(&self) -> Option<&InferenceResult> {
         self.body_or_sig.as_ref().and_then(|it| match it {
-            BodyOrSig::VariantFields { .. } => None,
-            BodyOrSig::Sig { infer, .. } | BodyOrSig::Body { infer, .. } => infer.as_deref(),
+            BodyOrSig::VariantFields { infer, .. }
+            | BodyOrSig::Sig { infer, .. }
+            | BodyOrSig::Body { infer, .. } => infer.as_deref(),
         })
     }
 
     pub(crate) fn def(
         &self,
-    ) -> Option<(ExpressionStoreOwnerId, &ExpressionStore, &ExpressionStoreSourceMap)> {
-        self.body_or_sig.as_ref().and_then(|it| match it {
-            BodyOrSig::VariantFields { .. } => None,
-            &BodyOrSig::Sig { def, store, source_map, .. } => Some((def.into(), store, source_map)),
-            BodyOrSig::Body { def, body, source_map, .. } => {
-                Some(((*def).into(), &body.store, source_map))
+    ) -> Option<(
+        ExpressionStoreOwnerId,
+        &ExpressionStore,
+        &ExpressionStoreSourceMap,
+        Option<&InferenceResult>,
+    )> {
+        self.body_or_sig.as_ref().map(|it| match *it {
+            BodyOrSig::VariantFields { def, store, source_map, infer, .. } => {
+                (def.into(), store, source_map, infer)
+            }
+            BodyOrSig::Sig { def, store, source_map, infer, .. } => {
+                (def.into(), store, source_map, infer)
+            }
+            BodyOrSig::Body { def, body, source_map, infer, .. } => {
+                (def.into(), &body.store, &source_map.store, infer)
             }
         })
     }
@@ -268,7 +296,7 @@ fn trait_environment(&self, db: &'db dyn HirDatabase) -> ParamEnvAndCrate<'db> {
         self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {
             match *body_or_sig {
                 BodyOrSig::Body { def, .. } => db.trait_environment(def.into()),
-                BodyOrSig::VariantFields { .. } => ParamEnv::empty(),
+                BodyOrSig::VariantFields { def, .. } => db.trait_environment(def.into()),
                 BodyOrSig::Sig { def, .. } => db.trait_environment(def.into()),
             }
         }))
@@ -510,7 +538,7 @@ pub(crate) fn resolve_field(
         &self,
         field: &ast::FieldExpr,
     ) -> Option<Either<Field, TupleField>> {
-        let (def, ..) = self.body_()?;
+        let def = self.owner()?;
         let expr_id = self.expr_id(field.clone().into())?.as_expr()?;
         self.infer()?.field_resolution(expr_id).map(|it| {
             it.map_either(Into::into, |f| TupleField { owner: def, tuple: f.tuple, index: f.index })
@@ -537,7 +565,7 @@ pub(crate) fn resolve_field_fallback(
         field: &ast::FieldExpr,
     ) -> Option<(Either<Either<Field, TupleField>, Function>, Option<GenericSubstitution<'db>>)>
     {
-        let (def, ..) = self.body_()?;
+        let def = self.owner()?;
         let expr_id = self.expr_id(field.clone().into())?.as_expr()?;
         let inference_result = self.infer()?;
         match inference_result.field_resolution(expr_id) {
@@ -889,7 +917,7 @@ pub(crate) fn resolve_offset_of_field(
         &self,
         db: &'db dyn HirDatabase,
         name_ref: &ast::NameRef,
-    ) -> Option<(Either<crate::Variant, crate::Field>, GenericSubstitution<'db>)> {
+    ) -> Option<(Either<crate::EnumVariant, crate::Field>, GenericSubstitution<'db>)> {
         let offset_of_expr = ast::OffsetOfExpr::cast(name_ref.syntax().parent()?)?;
         let container = offset_of_expr.ty()?;
         let container = self.type_of_type(db, &container)?;
@@ -940,7 +968,7 @@ pub(crate) fn resolve_offset_of_field(
                                 let variants = id.enum_variants(db);
                                 let variant = variants.variant(&field_name.as_name())?;
                                 container = Either::Left((variant, subst));
-                                (Either::Left(Variant { id: variant }), id.into(), subst)
+                                (Either::Left(EnumVariant { id: variant }), id.into(), subst)
                             }
                         },
                         _ => return None,
@@ -1020,7 +1048,10 @@ pub(crate) fn resolve_path(
                 if let Some(VariantId::EnumVariantId(variant)) =
                     infer.variant_resolution_for_expr_or_pat(expr_id)
                 {
-                    return Some((PathResolution::Def(ModuleDef::Variant(variant.into())), None));
+                    return Some((
+                        PathResolution::Def(ModuleDef::EnumVariant(variant.into())),
+                        None,
+                    ));
                 }
                 prefer_value_ns = true;
             } else if let Some(path_pat) = parent().and_then(ast::PathPat::cast) {
@@ -1052,14 +1083,20 @@ pub(crate) fn resolve_path(
                 if let Some(VariantId::EnumVariantId(variant)) =
                     infer.variant_resolution_for_expr_or_pat(expr_or_pat_id)
                 {
-                    return Some((PathResolution::Def(ModuleDef::Variant(variant.into())), None));
+                    return Some((
+                        PathResolution::Def(ModuleDef::EnumVariant(variant.into())),
+                        None,
+                    ));
                 }
             } else if let Some(rec_lit) = parent().and_then(ast::RecordExpr::cast) {
                 let expr_id = self.expr_id(rec_lit.into())?;
                 if let Some(VariantId::EnumVariantId(variant)) =
                     infer.variant_resolution_for_expr_or_pat(expr_id)
                 {
-                    return Some((PathResolution::Def(ModuleDef::Variant(variant.into())), None));
+                    return Some((
+                        PathResolution::Def(ModuleDef::EnumVariant(variant.into())),
+                        None,
+                    ));
                 }
             } else {
                 let record_pat = parent().and_then(ast::RecordPat::cast).map(ast::Pat::from);
@@ -1070,7 +1107,7 @@ pub(crate) fn resolve_path(
                     let variant_res_for_pat = infer.variant_resolution_for_pat(pat_id.as_pat()?);
                     if let Some(VariantId::EnumVariantId(variant)) = variant_res_for_pat {
                         return Some((
-                            PathResolution::Def(ModuleDef::Variant(variant.into())),
+                            PathResolution::Def(ModuleDef::EnumVariant(variant.into())),
                             None,
                         ));
                     }
@@ -1404,7 +1441,7 @@ pub(crate) fn is_unsafe_macro_call_expr(
         db: &'db dyn HirDatabase,
         macro_expr: InFile<&ast::MacroExpr>,
     ) -> bool {
-        if let Some((def, body, sm, Some(infer))) = self.body_()
+        if let Some((def, body, sm, Some(infer))) = self.def()
             && let Some(expanded_expr) = sm.macro_expansion_expr(macro_expr)
         {
             let mut is_unsafe = false;
@@ -1455,7 +1492,7 @@ pub(crate) fn resolve_offset_in_asm_template(
         line: usize,
         offset: TextSize,
     ) -> Option<(ExpressionStoreOwnerId, (ExprId, TextRange, usize))> {
-        let (def, _, sm) = self.def()?;
+        let (def, _, sm, _) = self.def()?;
         let (expr, args) = sm.asm_template_args(asm)?;
         Some(def).zip(
             args.get(line)?
@@ -1492,7 +1529,7 @@ pub(crate) fn as_asm_parts(
         &self,
         asm: InFile<&ast::AsmExpr>,
     ) -> Option<(ExpressionStoreOwnerId, (ExprId, &[Vec<(TextRange, usize)>]))> {
-        let (def, _, sm) = self.def()?;
+        let (def, _, sm, _) = self.def()?;
         Some(def).zip(sm.asm_template_args(asm))
     }
 
@@ -1722,7 +1759,7 @@ fn resolve_hir_path_(
             TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
                 PathResolution::Def(Adt::from(it).into())
             }
-            TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
+            TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
             TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
             TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
             TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
@@ -1806,7 +1843,7 @@ fn resolve_hir_value_path(
             ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
             ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
             ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
-            ValueNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
+            ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
             ValueNs::ImplSelf(impl_id) => PathResolution::SelfType(impl_id.into()),
             ValueNs::GenericParam(id) => PathResolution::ConstParam(id.into()),
         };
@@ -1871,7 +1908,7 @@ fn resolve_hir_path_qualifier(
             TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
                 PathResolution::Def(Adt::from(it).into())
             }
-            TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
+            TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
             TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
             TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
             TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
diff --git a/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs b/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
index e56f9e91e3f3..e3d0121e4912 100644
--- a/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
@@ -10,8 +10,8 @@
 use span::Edition;
 
 use crate::{
-    Adt, AsAssocItem, AssocItemContainer, Const, ConstParam, Field, Function, Local, ModuleDef,
-    SemanticsScope, Static, Struct, StructKind, Trait, Type, Variant,
+    Adt, AsAssocItem, AssocItemContainer, Const, ConstParam, EnumVariant, Field, Function, Local,
+    ModuleDef, SemanticsScope, Static, Struct, StructKind, Trait, Type,
 };
 
 /// Helper function to get path to `ModuleDef`
@@ -80,7 +80,7 @@ pub enum Expr<'db> {
         params: Vec<Expr<'db>>,
     },
     /// Enum variant construction
-    Variant { variant: Variant, generics: Vec<Type<'db>>, params: Vec<Expr<'db>> },
+    Variant { variant: EnumVariant, generics: Vec<Type<'db>>, params: Vec<Expr<'db>> },
     /// Struct construction
     Struct { strukt: Struct, generics: Vec<Type<'db>>, params: Vec<Expr<'db>> },
     /// Tuple construction
@@ -222,7 +222,7 @@ pub fn gen_source_code(
                     StructKind::Unit => String::new(),
                 };
 
-                let prefix = mod_item_path_str(sema_scope, &ModuleDef::Variant(*variant))?;
+                let prefix = mod_item_path_str(sema_scope, &ModuleDef::EnumVariant(*variant))?;
                 Ok(format!("{prefix}{inner}"))
             }
             Expr::Struct { strukt, params, .. } => {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 3c3f71aea6cf..b063e5ffce87 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -86,6 +86,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                     def_with_body.as_assoc_item(ctx.db())
                 }
                 hir::ExpressionStoreOwner::Signature(def) => def.as_assoc_item(ctx.db()),
+                hir::ExpressionStoreOwner::VariantFields(_) => None,
             }?
             .implementing_ty(ctx.db())
         })
@@ -477,7 +478,7 @@ enum ExtendedEnum {
 enum ExtendedVariant {
     True,
     False,
-    Variant { variant: hir::Variant, use_self: bool },
+    Variant { variant: hir::EnumVariant, use_self: bool },
 }
 
 impl ExtendedVariant {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/auto_import.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/auto_import.rs
index da5c12395771..de5dfdf4d954 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/auto_import.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/auto_import.rs
@@ -268,7 +268,7 @@ pub(crate) fn relevance_score(
                         hir::Adt::Union(it) => it.ty(ctx.db()),
                         hir::Adt::Enum(it) => it.ty(ctx.db()),
                     }),
-                    hir::ModuleDef::Variant(variant) => Some(variant.constructor_ty(ctx.db())),
+                    hir::ModuleDef::EnumVariant(variant) => Some(variant.constructor_ty(ctx.db())),
                     hir::ModuleDef::Const(it) => Some(it.ty(ctx.db())),
                     hir::ModuleDef::Static(it) => Some(it.ty(ctx.db())),
                     hir::ModuleDef::TypeAlias(it) => Some(it.ty(ctx.db())),
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
index 236436989e15..b3bfe5b8c41a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_then.rs
@@ -237,7 +237,7 @@ pub(crate) fn convert_bool_then_to_if(acc: &mut Assists, ctx: &AssistContext<'_>
 fn option_variants(
     sema: &Semantics<'_, RootDatabase>,
     expr: &SyntaxNode,
-) -> Option<(hir::Variant, hir::Variant)> {
+) -> Option<(hir::EnumVariant, hir::EnumVariant)> {
     let fam = FamousDefs(sema, sema.scope(expr)?.krate());
     let option_variants = fam.core_option_Option()?.variants(sema.db);
     match &*option_variants {
@@ -254,7 +254,7 @@ fn option_variants(
 /// If any of these conditions are met it is impossible to rewrite this as a `bool::then` call.
 fn is_invalid_body(
     sema: &Semantics<'_, RootDatabase>,
-    some_variant: hir::Variant,
+    some_variant: hir::EnumVariant,
     expr: &ast::Expr,
 ) -> bool {
     let mut invalid = false;
@@ -277,7 +277,7 @@ fn is_invalid_body(
                 && let Some(ast::Expr::PathExpr(p)) = call.expr()
             {
                 let res = p.path().and_then(|p| sema.resolve_path(&p));
-                if let Some(hir::PathResolution::Def(hir::ModuleDef::Variant(v))) = res {
+                if let Some(hir::PathResolution::Def(hir::ModuleDef::EnumVariant(v))) = res {
                     return invalid |= v != some_variant;
                 }
             }
@@ -290,11 +290,11 @@ fn is_invalid_body(
 fn block_is_none_variant(
     sema: &Semantics<'_, RootDatabase>,
     block: &ast::BlockExpr,
-    none_variant: hir::Variant,
+    none_variant: hir::EnumVariant,
 ) -> bool {
     block_as_lone_tail(block).and_then(|e| match e {
         ast::Expr::PathExpr(pat) => match sema.resolve_path(&pat.path()?)? {
-            hir::PathResolution::Def(hir::ModuleDef::Variant(v)) => Some(v),
+            hir::PathResolution::Def(hir::ModuleDef::EnumVariant(v)) => Some(v),
             _ => None,
         },
         _ => None,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
index 4dd2036c024c..aaf727058cf1 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs
@@ -158,11 +158,11 @@ fn edit_struct_def(
 fn edit_struct_references(
     ctx: &AssistContext<'_>,
     builder: &mut SourceChangeBuilder,
-    strukt: Either<hir::Struct, hir::Variant>,
+    strukt: Either<hir::Struct, hir::EnumVariant>,
 ) {
     let strukt_def = match strukt {
         Either::Left(s) => Definition::Adt(hir::Adt::Struct(s)),
-        Either::Right(v) => Definition::Variant(v),
+        Either::Right(v) => Definition::EnumVariant(v),
     };
     let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
index 270467b14f0c..ae41e6c015ce 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -142,12 +142,12 @@ fn edit_struct_def(
 fn edit_struct_references(
     ctx: &AssistContext<'_>,
     edit: &mut SourceChangeBuilder,
-    strukt: Either<hir::Struct, hir::Variant>,
+    strukt: Either<hir::Struct, hir::EnumVariant>,
     names: &[ast::Name],
 ) {
     let strukt_def = match strukt {
         Either::Left(s) => Definition::Adt(hir::Adt::Struct(s)),
-        Either::Right(v) => Definition::Variant(v),
+        Either::Right(v) => Definition::EnumVariant(v),
     };
     let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
index 7eca4d3f2a09..6c5c21bfc90f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
@@ -317,7 +317,7 @@ fn find_refs_in_mod(
                 .into_iter()
                 .map(|v| Ref {
                     visible_name: v.name(ctx.db()),
-                    def: Definition::Variant(v),
+                    def: Definition::EnumVariant(v),
                     is_pub: true,
                 })
                 .collect(),
@@ -379,7 +379,7 @@ fn find_imported_defs(ctx: &AssistContext<'_>, use_item: Use) -> Vec<Definition>
                 | Definition::Module(_)
                 | Definition::Function(_)
                 | Definition::Adt(_)
-                | Definition::Variant(_)
+                | Definition::EnumVariant(_)
                 | Definition::Const(_)
                 | Definition::Static(_)
                 | Definition::Trait(_)
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
index 867ac4851864..a7e78dfc9c94 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
@@ -102,7 +102,7 @@ fn expand_tuple_struct_rest_pattern(
     let fields = match ctx.sema.type_of_pat(&pat.clone().into())?.original.as_adt()? {
         hir::Adt::Struct(s) if s.kind(ctx.sema.db) == StructKind::Tuple => s.fields(ctx.sema.db),
         hir::Adt::Enum(_) => match ctx.sema.resolve_path(&path)? {
-            PathResolution::Def(hir::ModuleDef::Variant(v))
+            PathResolution::Def(hir::ModuleDef::EnumVariant(v))
                 if v.kind(ctx.sema.db) == StructKind::Tuple =>
             {
                 v.fields(ctx.sema.db)
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
index a17ae4885e62..dcbeaefa21f4 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
@@ -728,7 +728,7 @@ macro_rules! check_item {
         }
         Definition::Function(x) => check_item!(x),
         Definition::Adt(x) => check_item!(x),
-        Definition::Variant(x) => check_item!(x),
+        Definition::EnumVariant(x) => check_item!(x),
         Definition::Const(x) => check_item!(x),
         Definition::Static(x) => check_item!(x),
         Definition::Trait(x) => check_item!(x),
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index cbf4e0ec28af..4c46a51bef58 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -1,7 +1,7 @@
 use std::iter;
 
 use either::Either;
-use hir::{HasCrate, Module, ModuleDef, Name, Variant};
+use hir::{EnumVariant, HasCrate, Module, ModuleDef, Name};
 use ide_db::{
     FxHashSet, RootDatabase,
     defs::Definition,
@@ -61,7 +61,7 @@ pub(crate) fn extract_struct_from_enum_variant(
             let edition = enum_hir.krate(ctx.db()).edition(ctx.db());
             let variant_hir_name = variant_hir.name(ctx.db());
             let enum_module_def = ModuleDef::from(enum_hir);
-            let usages = Definition::Variant(variant_hir).usages(&ctx.sema).all();
+            let usages = Definition::EnumVariant(variant_hir).usages(&ctx.sema).all();
 
             let mut visited_modules_set = FxHashSet::default();
             let current_module = enum_hir.module(ctx.db());
@@ -161,7 +161,7 @@ fn extract_field_list_if_applicable(
     }
 }
 
-fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Variant) -> bool {
+fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool {
     variant
         .parent_enum(db)
         .module(db)
@@ -173,7 +173,7 @@ fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Va
                 def,
                 ModuleDef::Module(_)
                     | ModuleDef::Adt(_)
-                    | ModuleDef::Variant(_)
+                    | ModuleDef::EnumVariant(_)
                     | ModuleDef::Trait(_)
                     | ModuleDef::TypeAlias(_)
                     | ModuleDef::BuiltinType(_)
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
index 7071106970a1..e5ce02cf5357 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
@@ -465,7 +465,7 @@ fn like_const_value(ctx: &AssistContext<'_>, path_resolution: hir::PathResolutio
     match path_resolution {
         hir::PathResolution::Def(def) => match def {
             hir::ModuleDef::Adt(adt) => adt_like_const_value(Some(adt)),
-            hir::ModuleDef::Variant(variant) => variant.kind(db) == hir::StructKind::Unit,
+            hir::ModuleDef::EnumVariant(variant) => variant.kind(db) == hir::StructKind::Unit,
             hir::ModuleDef::TypeAlias(ty) => adt_like_const_value(ty.ty(db).as_adt()),
             hir::ModuleDef::Const(_) | hir::ModuleDef::Static(_) => true,
             hir::ModuleDef::Trait(_)
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
index 5134b98f1b2f..440f2d5f17ca 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
@@ -173,7 +173,7 @@ fn offset_target_and_file_id<S, Ast>(
         // FIXME
         hir::ModuleDef::Macro(_) => return None,
         // Enum variants can't be private, we can't modify builtin types
-        hir::ModuleDef::Variant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
     };
 
     Some((offset, target, target_file, target_name))
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
index 009fc077ce6c..cdf20586ef15 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
@@ -102,7 +102,7 @@ fn target_path(ctx: &AssistContext<'_>, mut original_path: ast::Path) -> Option<
     }
 
     match ctx.sema.resolve_path(&original_path)? {
-        PathResolution::Def(ModuleDef::Variant(_)) if on_first => original_path.qualifier(),
+        PathResolution::Def(ModuleDef::EnumVariant(_)) if on_first => original_path.qualifier(),
         PathResolution::Def(def) if def.as_assoc_item(ctx.db()).is_some() => {
             on_first.then_some(original_path.qualifier()?)
         }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
index 355687b2032b..1fb1fd4e579d 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
@@ -26,7 +26,7 @@
 
 use std::iter;
 
-use hir::{HasAttrs, Name, ScopeDef, Variant, sym};
+use hir::{EnumVariant, HasAttrs, Name, ScopeDef, sym};
 use ide_db::{RootDatabase, SymbolKind, imports::import_assets::LocatedImport};
 use syntax::{SmolStr, ToSmolStr, ast};
 
@@ -426,7 +426,7 @@ pub(crate) fn add_qualified_enum_variant(
         &mut self,
         ctx: &CompletionContext<'_>,
         path_ctx: &PathCompletionCtx<'_>,
-        variant: hir::Variant,
+        variant: hir::EnumVariant,
         path: hir::ModPath,
     ) {
         if !ctx.check_stability_and_hidden(variant) {
@@ -443,7 +443,7 @@ pub(crate) fn add_enum_variant(
         &mut self,
         ctx: &CompletionContext<'_>,
         path_ctx: &PathCompletionCtx<'_>,
-        variant: hir::Variant,
+        variant: hir::EnumVariant,
         local_name: Option<hir::Name>,
     ) {
         if !ctx.check_stability_and_hidden(variant) {
@@ -569,7 +569,7 @@ pub(crate) fn add_variant_pat(
         ctx: &CompletionContext<'_>,
         pattern_ctx: &PatternContext,
         path_ctx: Option<&PathCompletionCtx<'_>>,
-        variant: hir::Variant,
+        variant: hir::EnumVariant,
         local_name: Option<hir::Name>,
     ) {
         if !ctx.check_stability_and_hidden(variant) {
@@ -589,7 +589,7 @@ pub(crate) fn add_qualified_variant_pat(
         &mut self,
         ctx: &CompletionContext<'_>,
         pattern_ctx: &PatternContext,
-        variant: hir::Variant,
+        variant: hir::EnumVariant,
         path: hir::ModPath,
     ) {
         if !ctx.check_stability_and_hidden(variant) {
@@ -644,9 +644,9 @@ fn enum_variants_with_paths(
     ctx: &CompletionContext<'_>,
     enum_: hir::Enum,
     impl_: Option<&ast::Impl>,
-    cb: impl Fn(&mut Completions, &CompletionContext<'_>, hir::Variant, hir::ModPath),
+    cb: impl Fn(&mut Completions, &CompletionContext<'_>, hir::EnumVariant, hir::ModPath),
 ) {
-    let mut process_variant = |variant: Variant| {
+    let mut process_variant = |variant: EnumVariant| {
         let self_path = hir::ModPath::from_segments(
             hir::PathKind::Plain,
             iter::once(Name::new_symbol_root(sym::Self_)).chain(iter::once(variant.name(ctx.db))),
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/pattern.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/pattern.rs
index 6e9328165d95..e7597bf95c80 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/pattern.rs
@@ -91,7 +91,7 @@ pub(crate) fn complete_pattern(
                     acc.add_struct_pat(ctx, pattern_ctx, strukt, Some(name.clone()));
                     true
                 }
-                hir::ModuleDef::Variant(variant)
+                hir::ModuleDef::EnumVariant(variant)
                     if refutable || single_variant_enum(variant.parent_enum(ctx.db)) =>
                 {
                     acc.add_variant_pat(ctx, pattern_ctx, None, variant, Some(name.clone()));
@@ -190,7 +190,7 @@ pub(crate) fn complete_pattern_path(
                 let add_completion = match res {
                     ScopeDef::ModuleDef(hir::ModuleDef::Macro(mac)) => mac.is_fn_like(ctx.db),
                     ScopeDef::ModuleDef(hir::ModuleDef::Adt(_)) => true,
-                    ScopeDef::ModuleDef(hir::ModuleDef::Variant(_)) => true,
+                    ScopeDef::ModuleDef(hir::ModuleDef::EnumVariant(_)) => true,
                     ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) => true,
                     ScopeDef::ImplSelfType(_) => true,
                     _ => false,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
index abcf9fca6f29..8ff9c3258e8e 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
@@ -23,7 +23,9 @@ pub(crate) fn complete_type_path(
             ScopeDef::GenericParam(LifetimeParam(_)) => location.complete_lifetimes(),
             ScopeDef::Label(_) => false,
             // no values in type places
-            ScopeDef::ModuleDef(Function(_) | Variant(_) | Static(_)) | ScopeDef::Local(_) => false,
+            ScopeDef::ModuleDef(Function(_) | EnumVariant(_) | Static(_)) | ScopeDef::Local(_) => {
+                false
+            }
             // unless its a constant in a generic arg list position
             ScopeDef::ModuleDef(Const(_)) | ScopeDef::GenericParam(ConstParam(_)) => {
                 location.complete_consts()
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index 97afd07b0086..4fd0348156a5 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -288,7 +288,7 @@ pub(crate) struct PatternContext {
     pub(crate) record_pat: Option<ast::RecordPat>,
     pub(crate) impl_or_trait: Option<Either<ast::Impl, ast::Trait>>,
     /// List of missing variants in a match expr
-    pub(crate) missing_variants: Vec<hir::Variant>,
+    pub(crate) missing_variants: Vec<hir::EnumVariant>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -527,7 +527,7 @@ pub(crate) fn def_is_visible(&self, item: &ScopeDef) -> Visible {
                 hir::ModuleDef::Module(it) => self.is_visible(it),
                 hir::ModuleDef::Function(it) => self.is_visible(it),
                 hir::ModuleDef::Adt(it) => self.is_visible(it),
-                hir::ModuleDef::Variant(it) => self.is_visible(it),
+                hir::ModuleDef::EnumVariant(it) => self.is_visible(it),
                 hir::ModuleDef::Const(it) => self.is_visible(it),
                 hir::ModuleDef::Static(it) => self.is_visible(it),
                 hir::ModuleDef::Trait(it) => self.is_visible(it),
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index bf899539a20b..a3494b964f89 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1,7 +1,7 @@
 //! Module responsible for analyzing the code surrounding the cursor for completion.
 use std::iter;
 
-use hir::{ExpandResult, InFile, Semantics, Type, TypeInfo, Variant};
+use hir::{EnumVariant, ExpandResult, InFile, Semantics, Type, TypeInfo};
 use ide_db::{
     RootDatabase, active_parameter::ActiveParameter, syntax_helpers::node_ext::find_loops,
 };
@@ -781,7 +781,7 @@ fn expected_type_and_name<'db>(
                 ast::TupleStructPat(it) => {
                     let fields = it.path().and_then(|path| match sema.resolve_path(&path)? {
                         hir::PathResolution::Def(hir::ModuleDef::Adt(adt)) => Some(adt.as_struct()?.fields(sema.db)),
-                        hir::PathResolution::Def(hir::ModuleDef::Variant(variant)) => Some(variant.fields(sema.db)),
+                        hir::PathResolution::Def(hir::ModuleDef::EnumVariant(variant)) => Some(variant.fields(sema.db)),
                         _ => None,
                     });
                     let nr = it.fields().take_while(|it| it.syntax().text_range().end() <= token.text_range().start()).count();
@@ -1149,7 +1149,7 @@ fn classify_name_ref<'db>(
                                     hir::ModuleDef::Adt(adt) => {
                                         sema.source(adt)?.value.generic_param_list()
                                     }
-                                    hir::ModuleDef::Variant(variant) => {
+                                    hir::ModuleDef::EnumVariant(variant) => {
                                         sema.source(variant.parent_enum(sema.db))?.value.generic_param_list()
                                     }
                                     hir::ModuleDef::Trait(trait_) => {
@@ -1825,7 +1825,7 @@ fn pattern_context_for(
                                         });
 
                                         (!variant_already_present).then_some(*variant)
-                                    }).collect::<Vec<Variant>>())
+                                    }).collect::<Vec<EnumVariant>>())
                         });
 
                         if let Some(missing_variants_) = missing_variants_opt {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
index 765304d8187d..d77e79329541 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
@@ -408,7 +408,7 @@ fn render_resolution_path(
             let ctx = ctx.import_to_add(import_to_add);
             return render_fn(ctx, path_ctx, Some(local_name), func);
         }
-        ScopeDef::ModuleDef(Variant(var)) => {
+        ScopeDef::ModuleDef(EnumVariant(var)) => {
             let ctx = ctx.clone().import_to_add(import_to_add.clone());
             if let Some(item) =
                 render_variant_lit(ctx, path_ctx, Some(local_name.clone()), var, None)
@@ -476,7 +476,7 @@ fn render_resolution_path(
         }
         // Filtered out above
         ScopeDef::ModuleDef(
-            ModuleDef::Function(_) | ModuleDef::Variant(_) | ModuleDef::Macro(_),
+            ModuleDef::Function(_) | ModuleDef::EnumVariant(_) | ModuleDef::Macro(_),
         ) => (),
         ScopeDef::ModuleDef(ModuleDef::Const(konst)) => set_item_relevance(konst.ty(db)),
         ScopeDef::ModuleDef(ModuleDef::Static(stat)) => set_item_relevance(stat.ty(db)),
@@ -528,7 +528,7 @@ fn res_to_kind(resolution: ScopeDef) -> CompletionItemKind {
     match resolution {
         ScopeDef::Unknown => CompletionItemKind::UnresolvedReference,
         ScopeDef::ModuleDef(Function(_)) => CompletionItemKind::SymbolKind(SymbolKind::Function),
-        ScopeDef::ModuleDef(Variant(_)) => CompletionItemKind::SymbolKind(SymbolKind::Variant),
+        ScopeDef::ModuleDef(EnumVariant(_)) => CompletionItemKind::SymbolKind(SymbolKind::Variant),
         ScopeDef::ModuleDef(Macro(_)) => CompletionItemKind::SymbolKind(SymbolKind::Macro),
         ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::SymbolKind(SymbolKind::Module),
         ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
@@ -559,7 +559,7 @@ fn scope_def_docs(db: &RootDatabase, resolution: ScopeDef) -> Option<Documentati
     match resolution {
         ScopeDef::ModuleDef(Module(it)) => it.docs(db),
         ScopeDef::ModuleDef(Adt(it)) => it.docs(db),
-        ScopeDef::ModuleDef(Variant(it)) => it.docs(db),
+        ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(db),
         ScopeDef::ModuleDef(Const(it)) => it.docs(db),
         ScopeDef::ModuleDef(Static(it)) => it.docs(db),
         ScopeDef::ModuleDef(Trait(it)) => it.docs(db),
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render/literal.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render/literal.rs
index 8b14f05b72b2..6e49af980aea 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render/literal.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render/literal.rs
@@ -23,7 +23,7 @@ pub(crate) fn render_variant_lit(
     ctx: RenderContext<'_>,
     path_ctx: &PathCompletionCtx<'_>,
     local_name: Option<hir::Name>,
-    variant: hir::Variant,
+    variant: hir::EnumVariant,
     path: Option<hir::ModPath>,
 ) -> Option<Builder> {
     let _p = tracing::info_span!("render_variant_lit").entered();
@@ -150,7 +150,7 @@ fn render(
 #[derive(Clone, Copy)]
 enum Variant {
     Struct(hir::Struct),
-    EnumVariant(hir::Variant),
+    EnumVariant(hir::EnumVariant),
 }
 
 impl Variant {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
index 60474a31b4d3..fb35d7b9b671 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
@@ -47,7 +47,7 @@ pub(crate) fn render_variant_pat(
     ctx: RenderContext<'_>,
     pattern_ctx: &PatternContext,
     path_ctx: Option<&PathCompletionCtx<'_>>,
-    variant: hir::Variant,
+    variant: hir::EnumVariant,
     local_name: Option<Name>,
     path: Option<&hir::ModPath>,
 ) -> Option<CompletionItem> {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs b/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
index f5a5b76c336a..8bd4c6c46b85 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
@@ -113,7 +113,7 @@ pub fn generic_def_for_node(
     sema: &Semantics<'_, RootDatabase>,
     generic_arg_list: &ast::GenericArgList,
     token: &SyntaxToken,
-) -> Option<(hir::GenericDef, usize, bool, Option<hir::Variant>)> {
+) -> Option<(hir::GenericDef, usize, bool, Option<hir::EnumVariant>)> {
     let parent = generic_arg_list.syntax().parent()?;
     let mut variant = None;
     let def = match_ast! {
@@ -125,7 +125,7 @@ pub fn generic_def_for_node(
                     hir::PathResolution::Def(hir::ModuleDef::Function(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::Trait(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::TypeAlias(it)) => it.into(),
-                    hir::PathResolution::Def(hir::ModuleDef::Variant(it)) => {
+                    hir::PathResolution::Def(hir::ModuleDef::EnumVariant(it)) => {
                         variant = Some(it);
                         it.parent_enum(sema.db).into()
                     },
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
index 6ee4c97c873f..82cff372963a 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
@@ -14,11 +14,11 @@
 use either::Either;
 use hir::{
     Adt, AsAssocItem, AsExternAssocItem, AssocItem, AttributeTemplate, BuiltinAttr, BuiltinType,
-    Const, Crate, DefWithBody, DeriveHelper, DisplayTarget, DocLinkDef, ExpressionStoreOwner,
-    ExternAssocItem, ExternCrateDecl, Field, Function, GenericDef, GenericParam,
-    GenericSubstitution, HasContainer, HasVisibility, HirDisplay, Impl, InlineAsmOperand,
-    ItemContainer, Label, Local, Macro, Module, ModuleDef, Name, PathResolution, Semantics, Static,
-    StaticLifetime, Struct, ToolModule, Trait, TupleField, TypeAlias, Variant, VariantDef,
+    Const, Crate, DefWithBody, DeriveHelper, DisplayTarget, DocLinkDef, EnumVariant,
+    ExpressionStoreOwner, ExternAssocItem, ExternCrateDecl, Field, Function, GenericDef,
+    GenericParam, GenericSubstitution, HasContainer, HasVisibility, HirDisplay, Impl,
+    InlineAsmOperand, ItemContainer, Label, Local, Macro, Module, ModuleDef, Name, PathResolution,
+    Semantics, Static, StaticLifetime, Struct, ToolModule, Trait, TupleField, TypeAlias, Variant,
     Visibility,
 };
 use span::Edition;
@@ -39,7 +39,7 @@ pub enum Definition {
     Crate(Crate),
     Function(Function),
     Adt(Adt),
-    Variant(Variant),
+    EnumVariant(EnumVariant),
     Const(Const),
     Static(Static),
     Trait(Trait),
@@ -86,7 +86,7 @@ pub fn module(&self, db: &RootDatabase) -> Option<Module> {
             Definition::Static(it) => it.module(db),
             Definition::Trait(it) => it.module(db),
             Definition::TypeAlias(it) => it.module(db),
-            Definition::Variant(it) => it.module(db),
+            Definition::EnumVariant(it) => it.module(db),
             Definition::SelfType(it) => it.module(db),
             Definition::Local(it) => it.module(db),
             Definition::GenericParam(it) => it.module(db),
@@ -124,7 +124,7 @@ fn container_to_definition(container: ItemContainer) -> Option<Definition> {
             Definition::Static(it) => container_to_definition(it.container(db)),
             Definition::Trait(it) => container_to_definition(it.container(db)),
             Definition::TypeAlias(it) => container_to_definition(it.container(db)),
-            Definition::Variant(it) => Some(Adt::Enum(it.parent_enum(db)).into()),
+            Definition::EnumVariant(it) => Some(Adt::Enum(it.parent_enum(db)).into()),
             Definition::SelfType(it) => Some(it.module(db).into()),
             Definition::Local(it) => it.parent(db).try_into().ok(),
             Definition::GenericParam(it) => Some(it.parent().into()),
@@ -152,7 +152,7 @@ pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
             Definition::Static(it) => it.visibility(db),
             Definition::Trait(it) => it.visibility(db),
             Definition::TypeAlias(it) => it.visibility(db),
-            Definition::Variant(it) => it.visibility(db),
+            Definition::EnumVariant(it) => it.visibility(db),
             Definition::ExternCrateDecl(it) => it.visibility(db),
             Definition::Macro(it) => it.visibility(db),
             Definition::BuiltinType(_) | Definition::TupleField(_) => Visibility::Public,
@@ -180,7 +180,7 @@ pub fn name(&self, db: &RootDatabase) -> Option<Name> {
             }
             Definition::Function(it) => it.name(db),
             Definition::Adt(it) => it.name(db),
-            Definition::Variant(it) => it.name(db),
+            Definition::EnumVariant(it) => it.name(db),
             Definition::Const(it) => it.name(db)?,
             Definition::Static(it) => it.name(db),
             Definition::Trait(it) => it.name(db),
@@ -228,7 +228,7 @@ pub fn docs_with_rangemap<'db>(
             Definition::Crate(it) => it.docs_with_rangemap(db),
             Definition::Function(it) => it.docs_with_rangemap(db),
             Definition::Adt(it) => it.docs_with_rangemap(db),
-            Definition::Variant(it) => it.docs_with_rangemap(db),
+            Definition::EnumVariant(it) => it.docs_with_rangemap(db),
             Definition::Const(it) => it.docs_with_rangemap(db),
             Definition::Static(it) => it.docs_with_rangemap(db),
             Definition::Trait(it) => it.docs_with_rangemap(db),
@@ -316,7 +316,7 @@ pub fn label(&self, db: &RootDatabase, display_target: DisplayTarget) -> String
             Definition::Crate(it) => it.display(db, display_target).to_string(),
             Definition::Function(it) => it.display(db, display_target).to_string(),
             Definition::Adt(it) => it.display(db, display_target).to_string(),
-            Definition::Variant(it) => it.display(db, display_target).to_string(),
+            Definition::EnumVariant(it) => it.display(db, display_target).to_string(),
             Definition::Const(it) => it.display(db, display_target).to_string(),
             Definition::Static(it) => it.display(db, display_target).to_string(),
             Definition::Trait(it) => it.display(db, display_target).to_string(),
@@ -557,7 +557,7 @@ pub fn classify(
                 ast::Rename(it) => classify_rename(sema, it)?,
                 ast::SelfParam(it) => Definition::Local(sema.to_def(&it)?),
                 ast::RecordField(it) => Definition::Field(sema.to_def(&it)?),
-                ast::Variant(it) => Definition::Variant(sema.to_def(&it)?),
+                ast::Variant(it) => Definition::EnumVariant(sema.to_def(&it)?),
                 ast::TypeParam(it) => Definition::GenericParam(sema.to_def(&it)?.into()),
                 ast::ConstParam(it) => Definition::GenericParam(sema.to_def(&it)?.into()),
                 ast::AsmOperandNamed(it) => Definition::InlineAsmOperand(sema.to_def(&it)?),
@@ -849,7 +849,7 @@ pub fn classify(
                 ast::OffsetOfExpr(_) => {
                     let (def, subst) = sema.resolve_offset_of_field(name_ref)?;
                     let def = match def {
-                        Either::Left(variant) => Definition::Variant(variant),
+                        Either::Left(variant) => Definition::EnumVariant(variant),
                         Either::Right(field) => Definition::Field(field),
                     };
                     Some(NameRefClass::Definition(def, Some(subst)))
@@ -892,7 +892,7 @@ pub fn classify_lifetime(
 }
 
 impl_from!(
-    Field, Module, Function, Adt, Variant, Const, Static, Trait, TypeAlias, BuiltinType, Local,
+    Field, Module, Function, Adt, EnumVariant, Const, Static, Trait, TypeAlias, BuiltinType, Local,
     GenericParam, Label, Macro, ExternCrateDecl
     for Definition
 );
@@ -968,7 +968,7 @@ fn from(def: ModuleDef) -> Self {
             ModuleDef::Module(it) => Definition::Module(it),
             ModuleDef::Function(it) => Definition::Function(it),
             ModuleDef::Adt(it) => Definition::Adt(it),
-            ModuleDef::Variant(it) => Definition::Variant(it),
+            ModuleDef::EnumVariant(it) => Definition::EnumVariant(it),
             ModuleDef::Const(it) => Definition::Const(it),
             ModuleDef::Static(it) => Definition::Static(it),
             ModuleDef::Trait(it) => Definition::Trait(it),
@@ -989,8 +989,8 @@ fn from(def: DocLinkDef) -> Self {
     }
 }
 
-impl From<VariantDef> for Definition {
-    fn from(def: VariantDef) -> Self {
+impl From<Variant> for Definition {
+    fn from(def: Variant) -> Self {
         ModuleDef::from(def).into()
     }
 }
@@ -1002,7 +1002,7 @@ fn try_from(def: DefWithBody) -> Result<Self, Self::Error> {
             DefWithBody::Function(it) => Ok(it.into()),
             DefWithBody::Static(it) => Ok(it.into()),
             DefWithBody::Const(it) => Ok(it.into()),
-            DefWithBody::Variant(it) => Ok(it.into()),
+            DefWithBody::EnumVariant(it) => Ok(it.into()),
         }
     }
 }
@@ -1027,6 +1027,7 @@ fn try_from(def: ExpressionStoreOwner) -> Result<Self, Self::Error> {
         match def {
             ExpressionStoreOwner::Body(def_with_body) => def_with_body.try_into(),
             ExpressionStoreOwner::Signature(generic_def) => Ok(generic_def.into()),
+            ExpressionStoreOwner::VariantFields(it) => Ok(it.into()),
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs b/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
index 4c4691cca2ca..407049f4b362 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
@@ -58,8 +58,22 @@ impl HasDocs for hir::$def {}
 }
 
 impl_has_docs![
-    Variant, Field, Static, Const, Trait, TypeAlias, Macro, Function, Adt, Module, Impl, Crate,
-    AssocItem, Struct, Union, Enum,
+    EnumVariant,
+    Field,
+    Static,
+    Const,
+    Trait,
+    TypeAlias,
+    Macro,
+    Function,
+    Adt,
+    Module,
+    Impl,
+    Crate,
+    AssocItem,
+    Struct,
+    Union,
+    Enum,
 ];
 
 impl HasDocs for hir::ExternCrateDecl {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
index 023b32b36195..cde0705d8ac2 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
@@ -312,7 +312,7 @@ impl SymbolKind {
     pub fn from_module_def(db: &dyn HirDatabase, it: hir::ModuleDef) -> Self {
         match it {
             hir::ModuleDef::Const(..) => SymbolKind::Const,
-            hir::ModuleDef::Variant(..) => SymbolKind::Variant,
+            hir::ModuleDef::EnumVariant(..) => SymbolKind::Variant,
             hir::ModuleDef::Function(..) => SymbolKind::Function,
             hir::ModuleDef::Macro(mac) if mac.is_proc_macro() => SymbolKind::ProcMacro,
             hir::ModuleDef::Macro(..) => SymbolKind::Macro,
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
index 01a326a0dc63..508f841340b1 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
@@ -580,7 +580,7 @@ fn transform_ident_pat(
                     }
                 }
 
-                if let hir::ModuleDef::Variant(v) = def
+                if let hir::ModuleDef::EnumVariant(v) = def
                     && v.kind(self.source_scope.db) != hir::StructKind::Unit
                 {
                     return None;
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/rename.rs b/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
index b03a5b6efb6a..b18ed69d80fe 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
@@ -170,7 +170,7 @@ pub fn range_for_rename(self, sema: &Semantics<'_, RootDatabase>) -> Option<File
                 hir::Adt::Union(it) => name_range(it, sema).and_then(syn_ctx_is_root),
                 hir::Adt::Enum(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             },
-            Definition::Variant(it) => name_range(it, sema).and_then(syn_ctx_is_root),
+            Definition::EnumVariant(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Const(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Static(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Trait(it) => name_range(it, sema).and_then(syn_ctx_is_root),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/search.rs b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
index 2cf4627ac892..25acb47f7b4c 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/search.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
@@ -314,7 +314,7 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
                     DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
                     DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
                     DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
-                    DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::EnumVariant(v) => v.source(db).map(|src| src.syntax().cloned()),
                 },
                 ExpressionStoreOwner::Signature(def) => match def {
                     hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
@@ -327,6 +327,9 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
                     hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
                     hir::GenericDef::Static(it) => it.source(db).map(|src| src.syntax().cloned()),
                 },
+                ExpressionStoreOwner::VariantFields(it) => {
+                    it.source(db).map(|src| src.syntax().cloned())
+                }
             };
             return match def {
                 Some(def) => SearchScope::file_range(
@@ -342,7 +345,7 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
                     DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
                     DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
                     DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
-                    DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
+                    DefWithBody::EnumVariant(v) => v.source(db).map(|src| src.syntax().cloned()),
                 },
                 ExpressionStoreOwner::Signature(def) => match def {
                     hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
@@ -355,6 +358,9 @@ fn search_scope(&self, db: &RootDatabase) -> SearchScope {
                     hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
                     hir::GenericDef::Static(it) => it.source(db).map(|src| src.syntax().cloned()),
                 },
+                ExpressionStoreOwner::VariantFields(it) => {
+                    it.source(db).map(|src| src.syntax().cloned())
+                }
             };
             return match def {
                 Some(def) => SearchScope::file_range(
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
index 46d938b5a503..02a023038a61 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
+++ b/src/tools/rust-analyzer/crates/ide-db/src/test_data/test_symbol_index_collection.txt
@@ -8,8 +8,8 @@
         [
             FileSymbol {
                 name: "A",
-                def: Variant(
-                    Variant {
+                def: EnumVariant(
+                    EnumVariant {
                         id: EnumVariantId(
                             7c00,
                         ),
@@ -80,8 +80,8 @@
             },
             FileSymbol {
                 name: "B",
-                def: Variant(
-                    Variant {
+                def: EnumVariant(
+                    EnumVariant {
                         id: EnumVariantId(
                             7c01,
                         ),
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
index 619bb2307cd4..944622bb1d58 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/no_such_field.rs
@@ -64,20 +64,20 @@ fn missing_record_expr_field_fixes(
     let module;
     let def_file_id;
     let record_fields = match def_id {
-        hir::VariantDef::Struct(s) => {
+        hir::Variant::Struct(s) => {
             module = s.module(sema.db);
             let source = s.source(sema.db)?;
             def_file_id = source.file_id;
             let fields = source.value.field_list()?;
             record_field_list(fields)?
         }
-        hir::VariantDef::Union(u) => {
+        hir::Variant::Union(u) => {
             module = u.module(sema.db);
             let source = u.source(sema.db)?;
             def_file_id = source.file_id;
             source.value.record_field_list()?
         }
-        hir::VariantDef::Variant(e) => {
+        hir::Variant::EnumVariant(e) => {
             module = e.module(sema.db);
             let source = e.source(sema.db)?;
             def_file_id = source.file_id;
@@ -116,7 +116,7 @@ fn missing_record_expr_field_fixes(
 
     let mut new_field = new_field.to_string();
     // FIXME: check submodule instead of FileId
-    if usage_file_id != def_file_id && !matches!(def_id, hir::VariantDef::Variant(_)) {
+    if usage_file_id != def_file_id && !matches!(def_id, hir::Variant::EnumVariant(_)) {
         new_field = format!("pub(crate) {new_field}");
     }
     new_field = format!("\n{indent}{new_field}{postfix}");
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
index d854c1c45044..33bed9501a39 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
@@ -219,7 +219,7 @@ pub(crate) fn resolve_doc_path_for_def(
         Definition::Crate(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Function(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Adt(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
-        Definition::Variant(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
+        Definition::EnumVariant(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Const(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Static(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Trait(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
@@ -678,7 +678,7 @@ fn filename_and_frag_for_def(
         Definition::Function(f) => {
             format!("fn.{}.html", f.name(db).as_str())
         }
-        Definition::Variant(ev) => {
+        Definition::EnumVariant(ev) => {
             let def = Definition::Adt(ev.parent_enum(db).into());
             let (_, file, _) = filename_and_frag_for_def(db, def)?;
             return Some((def, file, Some(format!("variant.{}", ev.name(db).as_str()))));
@@ -703,9 +703,9 @@ fn filename_and_frag_for_def(
         },
         Definition::Field(field) => {
             let def = match field.parent_def(db) {
-                hir::VariantDef::Struct(it) => Definition::Adt(it.into()),
-                hir::VariantDef::Union(it) => Definition::Adt(it.into()),
-                hir::VariantDef::Variant(it) => Definition::Variant(it),
+                hir::Variant::Struct(it) => Definition::Adt(it.into()),
+                hir::Variant::Union(it) => Definition::Adt(it.into()),
+                hir::Variant::EnumVariant(it) => Definition::EnumVariant(it),
             };
             let (_, file, _) = filename_and_frag_for_def(db, def)?;
             return Some((def, file, Some(format!("structfield.{}", field.name(db).as_str()))));
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
index a61a6c677f65..509c55a31e58 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
@@ -113,7 +113,7 @@ fn node_to_def<'db>(
             ast::Struct(it)      => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Adt(hir::Adt::Struct(def)))),
             ast::Union(it)       => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Adt(hir::Adt::Union(def)))),
             ast::Enum(it)        => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Adt(hir::Adt::Enum(def)))),
-            ast::Variant(it)     => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Variant(def))),
+            ast::Variant(it)     => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::EnumVariant(def))),
             ast::Trait(it)       => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Trait(def))),
             ast::Static(it)      => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Static(def))),
             ast::Const(it)       => sema.to_def(&it).map(|def| (def.docs_with_rangemap(sema.db), Definition::Const(def))),
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index cf5f137cdd03..af78e9a40c9f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -5,7 +5,7 @@
 use hir::{
     Adt, AsAssocItem, AsExternAssocItem, CaptureKind, DisplayTarget, DropGlue,
     DynCompatibilityViolation, HasCrate, HasSource, HirDisplay, Layout, LayoutError,
-    MethodViolationCode, Name, Semantics, Symbol, Trait, Type, TypeInfo, VariantDef,
+    MethodViolationCode, Name, Semantics, Symbol, Trait, Type, TypeInfo, Variant,
     db::ExpandDatabase,
 };
 use ide_db::{
@@ -366,14 +366,14 @@ fn definition_owner_name(db: &RootDatabase, def: Definition, edition: Edition) -
             let parent_name = parent.name(db);
             let parent_name = parent_name.display(db, edition).to_string();
             return match parent {
-                VariantDef::Variant(variant) => {
+                Variant::EnumVariant(variant) => {
                     let enum_name = variant.parent_enum(db).name(db);
                     Some(format!("{}::{parent_name}", enum_name.display(db, edition)))
                 }
                 _ => Some(parent_name),
             };
         }
-        Definition::Variant(e) => Some(e.parent_enum(db).name(db)),
+        Definition::EnumVariant(e) => Some(e.parent_enum(db).name(db)),
         Definition::GenericParam(generic_param) => match generic_param.parent() {
             hir::GenericDef::Adt(it) => Some(it.name(db)),
             hir::GenericDef::Trait(it) => Some(it.name(db)),
@@ -470,7 +470,7 @@ pub(super) fn definition(
         Definition::Adt(adt @ (Adt::Struct(_) | Adt::Union(_))) => {
             adt.display_limited(db, config.max_fields_count, display_target).to_string()
         }
-        Definition::Variant(variant) => {
+        Definition::EnumVariant(variant) => {
             variant.display_limited(db, config.max_fields_count, display_target).to_string()
         }
         Definition::Adt(adt @ Adt::Enum(_)) => {
@@ -499,7 +499,7 @@ pub(super) fn definition(
     };
     let docs = def.docs_with_rangemap(db, famous_defs, display_target);
     let value = || match def {
-        Definition::Variant(it) => {
+        Definition::EnumVariant(it) => {
             if !it.parent_enum(db).is_data_carrying(db) {
                 match it.eval(db) {
                     Ok(it) => {
@@ -596,7 +596,7 @@ pub(super) fn definition(
             |_| {
                 let var_def = it.parent_def(db);
                 match var_def {
-                    hir::VariantDef::Struct(s) => {
+                    hir::Variant::Struct(s) => {
                         Adt::from(s).layout(db).ok().and_then(|layout| layout.field_offset(it))
                     }
                     _ => None,
@@ -627,7 +627,7 @@ pub(super) fn definition(
             |_| None,
             |_| None,
         ),
-        Definition::Variant(it) => render_memory_layout(
+        Definition::EnumVariant(it) => render_memory_layout(
             config.memory_layout,
             || it.layout(db),
             |_| None,
@@ -710,7 +710,7 @@ pub(super) fn definition(
                     has_dtor: Some(enum_drop_glue > fields_drop_glue),
                 }
             }
-            Definition::Variant(variant) => {
+            Definition::EnumVariant(variant) => {
                 let fields_drop_glue = variant
                     .fields(db)
                     .iter()
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
index f1e62a5ab8ac..08588bbed090 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
@@ -374,7 +374,7 @@ fn is_adt_constructor_similar_to_param_name(
         hir::PathResolution::Def(hir::ModuleDef::Adt(_)) => {
             Some(to_lower_snake_case(&path.segment()?.name_ref()?.text()) == param_name)
         }
-        hir::PathResolution::Def(hir::ModuleDef::Function(_) | hir::ModuleDef::Variant(_)) => {
+        hir::PathResolution::Def(hir::ModuleDef::Function(_) | hir::ModuleDef::EnumVariant(_)) => {
             if to_lower_snake_case(&path.segment()?.name_ref()?.text()) == param_name {
                 return Some(true);
             }
diff --git a/src/tools/rust-analyzer/crates/ide/src/moniker.rs b/src/tools/rust-analyzer/crates/ide/src/moniker.rs
index 1c1389ca7a15..335e1b5b13ca 100644
--- a/src/tools/rust-analyzer/crates/ide/src/moniker.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/moniker.rs
@@ -205,7 +205,7 @@ pub(crate) fn def_to_kind(db: &RootDatabase, def: Definition) -> SymbolInformati
         Definition::Adt(Adt::Struct(..)) => Struct,
         Definition::Adt(Adt::Union(..)) => Union,
         Definition::Adt(Adt::Enum(..)) => Enum,
-        Definition::Variant(..) => EnumMember,
+        Definition::EnumVariant(..) => EnumMember,
         Definition::Const(..) => Constant,
         Definition::Static(..) => StaticVariable,
         Definition::Trait(..) => Trait,
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index 185df92e2d39..92020321f453 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -276,7 +276,7 @@ fn try_to_nav(
                             Some(it.display(db, display_target).to_string())
                         }
                         hir::ModuleDef::Adt(it) => Some(it.display(db, display_target).to_string()),
-                        hir::ModuleDef::Variant(it) => {
+                        hir::ModuleDef::EnumVariant(it) => {
                             Some(it.display(db, display_target).to_string())
                         }
                         hir::ModuleDef::Const(it) => {
@@ -319,7 +319,7 @@ fn try_to_nav(
             Definition::GenericParam(it) => it.try_to_nav(sema),
             Definition::Function(it) => it.try_to_nav(sema),
             Definition::Adt(it) => it.try_to_nav(sema),
-            Definition::Variant(it) => it.try_to_nav(sema),
+            Definition::EnumVariant(it) => it.try_to_nav(sema),
             Definition::Const(it) => it.try_to_nav(sema),
             Definition::Static(it) => it.try_to_nav(sema),
             Definition::Trait(it) => it.try_to_nav(sema),
@@ -347,7 +347,7 @@ fn try_to_nav(
             hir::ModuleDef::Module(it) => Some(it.to_nav(sema.db)),
             hir::ModuleDef::Function(it) => it.try_to_nav(sema),
             hir::ModuleDef::Adt(it) => it.try_to_nav(sema),
-            hir::ModuleDef::Variant(it) => it.try_to_nav(sema),
+            hir::ModuleDef::EnumVariant(it) => it.try_to_nav(sema),
             hir::ModuleDef::Const(it) => it.try_to_nav(sema),
             hir::ModuleDef::Static(it) => it.try_to_nav(sema),
             hir::ModuleDef::Trait(it) => it.try_to_nav(sema),
@@ -406,7 +406,7 @@ fn container_name(self, db: &RootDatabase) -> Option<Symbol> {
         container_name(db, self)
     }
 }
-impl ToNavFromAst for hir::Variant {
+impl ToNavFromAst for hir::EnumVariant {
     const KIND: SymbolKind = SymbolKind::Variant;
 }
 impl ToNavFromAst for hir::Union {
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index 6464c477160b..9392651c1794 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -299,7 +299,7 @@ fn retain_adt_literal_usages(
             });
             usages.references.retain(|_, it| !it.is_empty());
         }
-        Definition::Adt(_) | Definition::Variant(_) => {
+        Definition::Adt(_) | Definition::EnumVariant(_) => {
             refs.for_each(|it| {
                 it.retain(|reference| reference.name.as_name_ref().is_some_and(is_lit_name_ref))
             });
@@ -377,7 +377,7 @@ fn is_enum_lit_name_ref(
     let path_is_variant_of_enum = |path: ast::Path| {
         matches!(
             sema.resolve_path(&path),
-            Some(PathResolution::Def(hir::ModuleDef::Variant(variant)))
+            Some(PathResolution::Def(hir::ModuleDef::EnumVariant(variant)))
                 if variant.parent_enum(sema.db) == enum_
         )
     };
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 42efa7142b50..a0a6a245592c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -494,7 +494,7 @@ fn module_def_doctest(sema: &Semantics<'_, RootDatabase>, def: Definition) -> Op
         Definition::Module(it) => it.attrs(db),
         Definition::Function(it) => it.attrs(db),
         Definition::Adt(it) => it.attrs(db),
-        Definition::Variant(it) => it.attrs(db),
+        Definition::EnumVariant(it) => it.attrs(db),
         Definition::Const(it) => it.attrs(db),
         Definition::Static(it) => it.attrs(db),
         Definition::Trait(it) => it.attrs(db),
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index f86974b4ec76..9eb01b12f2bd 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -497,7 +497,7 @@ fn signature_help_for_tuple_struct_pat(
     };
     let db = sema.db;
 
-    let fields: Vec<_> = if let PathResolution::Def(ModuleDef::Variant(variant)) = path_res {
+    let fields: Vec<_> = if let PathResolution::Def(ModuleDef::EnumVariant(variant)) = path_res {
         let en = variant.parent_enum(db);
 
         res.doc = en.docs(db).map(Documentation::into_owned);
@@ -623,7 +623,7 @@ fn signature_help_for_record_<'db>(
 
     let db = sema.db;
     let path_res = sema.resolve_path(path)?;
-    if let PathResolution::Def(ModuleDef::Variant(variant)) = path_res {
+    if let PathResolution::Def(ModuleDef::EnumVariant(variant)) = path_res {
         fields = variant.fields(db);
         let en = variant.parent_enum(db);
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index ce1df6a1e7dc..217b13b4ef95 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -14,7 +14,9 @@
 use std::ops::ControlFlow;
 
 use either::Either;
-use hir::{DefWithBody, EditionedFileId, InFile, InRealFile, MacroKind, Semantics};
+use hir::{
+    DefWithBody, EditionedFileId, ExpressionStoreOwner, InFile, InRealFile, MacroKind, Semantics,
+};
 use ide_db::{FxHashMap, FxHashSet, MiniCore, Ranker, RootDatabase, SymbolKind};
 use syntax::{
     AstNode, AstToken, NodeOrToken,
@@ -256,8 +258,8 @@ fn item(&self) -> &ast::Item {
     let mut inside_attribute = false;
 
     // FIXME: accommodate range highlighting
-    let mut body_stack: Vec<Option<DefWithBody>> = vec![];
-    let mut per_body_cache: FxHashMap<DefWithBody, FxHashSet<_>> = FxHashMap::default();
+    let mut body_stack: Vec<Option<ExpressionStoreOwner>> = vec![];
+    let mut per_body_cache: FxHashMap<ExpressionStoreOwner, FxHashSet<_>> = FxHashMap::default();
 
     // Walk all nodes, keeping track of whether we are inside a macro or not.
     // If in macro, expand it first and highlight the expanded code.
@@ -288,19 +290,18 @@ fn item(&self) -> &ast::Item {
                 inside_attribute = false
             }
             Enter(NodeOrToken::Node(node)) => {
+                // FIXME: ExpressionStore signatures and variant fields
+                // Maybe we can re-use child container stuff here
                 if let Some(item) = <Either<ast::Item, ast::Variant>>::cast(node.clone()) {
                     match item {
                         Either::Left(item) => {
                             match &item {
-                                ast::Item::Fn(it) => {
-                                    body_stack.push(sema.to_def(it).map(Into::into))
-                                }
-                                ast::Item::Const(it) => {
-                                    body_stack.push(sema.to_def(it).map(Into::into))
-                                }
-                                ast::Item::Static(it) => {
-                                    body_stack.push(sema.to_def(it).map(Into::into))
-                                }
+                                ast::Item::Fn(it) => body_stack
+                                    .push(sema.to_def(it).map(DefWithBody::from).map(Into::into)),
+                                ast::Item::Const(it) => body_stack
+                                    .push(sema.to_def(it).map(DefWithBody::from).map(Into::into)),
+                                ast::Item::Static(it) => body_stack
+                                    .push(sema.to_def(it).map(DefWithBody::from).map(Into::into)),
                                 _ => (),
                             }
 
@@ -329,7 +330,9 @@ fn item(&self) -> &ast::Item {
                                 }
                             }
                         }
-                        Either::Right(it) => body_stack.push(sema.to_def(&it).map(Into::into)),
+                        Either::Right(it) => {
+                            body_stack.push(sema.to_def(&it).map(DefWithBody::from).map(Into::into))
+                        }
                     }
                 }
             }
@@ -392,11 +395,11 @@ fn item(&self) -> &ast::Item {
                 let descended = descend_token(sema, InRealFile::new(file_id, token));
                 let body = match &descended.value {
                     NodeOrToken::Node(n) => {
-                        sema.body_for(InFile::new(descended.file_id, n.syntax()))
-                    }
-                    NodeOrToken::Token(t) => {
-                        t.parent().and_then(|it| sema.body_for(InFile::new(descended.file_id, &it)))
+                        sema.store_owner_for(InFile::new(descended.file_id, n.syntax()))
                     }
+                    NodeOrToken::Token(t) => t
+                        .parent()
+                        .and_then(|it| sema.store_owner_for(InFile::new(descended.file_id, &it))),
                 };
                 (descended, body)
             }
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
index a94bbc9f041d..0e101ab235f5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
@@ -538,7 +538,7 @@ pub(super) fn highlight_def(
 
             (Highlight::new(h), Some(adt.attrs(sema.db)))
         }
-        Definition::Variant(variant) => {
+        Definition::EnumVariant(variant) => {
             (Highlight::new(HlTag::Symbol(SymbolKind::Variant)), Some(variant.attrs(sema.db)))
         }
         Definition::Const(konst) => {
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index 291333f09cf8..74a8d93dfe82 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -209,7 +209,7 @@ fn module_def_to_hl_tag(db: &dyn HirDatabase, def: Definition) -> HlTag {
         Definition::Adt(hir::Adt::Struct(_)) => SymbolKind::Struct,
         Definition::Adt(hir::Adt::Enum(_)) => SymbolKind::Enum,
         Definition::Adt(hir::Adt::Union(_)) => SymbolKind::Union,
-        Definition::Variant(_) => SymbolKind::Variant,
+        Definition::EnumVariant(_) => SymbolKind::Variant,
         Definition::Const(_) => SymbolKind::Const,
         Definition::Static(_) => SymbolKind::Static,
         Definition::Trait(_) => SymbolKind::Trait,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 7541a41b20eb..74828cba02ed 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -11,7 +11,7 @@
 use cfg::{CfgAtom, CfgDiff};
 use hir::{
     Adt, AssocItem, Crate, DefWithBody, FindPathConfig, GenericDef, HasCrate, HasSource,
-    HirDisplay, ModuleDef, Name, crate_lang_items,
+    HirDisplay, ModuleDef, Name, Variant, VariantId, crate_lang_items,
     db::{DefDatabase, ExpandDatabase, HirDatabase},
     next_solver::{DbInterner, GenericArgs},
 };
@@ -230,6 +230,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
         let mut num_decls = 0;
         let mut bodies = Vec::new();
         let mut signatures = Vec::new();
+        let mut variants = Vec::new();
         let mut adts = Vec::new();
         let mut file_ids = Vec::new();
 
@@ -247,10 +248,15 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                     match decl {
                         ModuleDef::Function(f) => bodies.push(DefWithBody::from(f)),
                         ModuleDef::Adt(a) => {
-                            if let Adt::Enum(e) = a {
-                                for v in e.variants(db) {
-                                    bodies.push(DefWithBody::from(v));
+                            match a {
+                                Adt::Enum(e) => {
+                                    for v in e.variants(db) {
+                                        bodies.push(DefWithBody::from(v));
+                                        variants.push(Variant::EnumVariant(v));
+                                    }
                                 }
+                                Adt::Struct(it) => variants.push(Variant::Struct(it)),
+                                Adt::Union(it) => variants.push(Variant::Union(it)),
                             }
                             adts.push(a)
                         }
@@ -293,7 +299,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             }
         }
         eprintln!(
-            ", mods: {}, decls: {num_decls}, bodies: {}, adts: {}, consts: {}, signatures: {}",
+            ", mods: {}, decls: {num_decls}, bodies: {}, adts: {}, consts: {}, signatures: {}, variants: {}",
             visited_modules.len(),
             bodies.len(),
             adts.len(),
@@ -302,6 +308,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
                 .filter(|it| matches!(it, DefWithBody::Const(_) | DefWithBody::Static(_)))
                 .count(),
             signatures.len(),
+            variants.len()
         );
 
         eprintln!("  Workspace:");
@@ -337,15 +344,15 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             }
 
             if !self.skip_lowering {
-                self.run_body_lowering(db, &vfs, &bodies, &signatures, verbosity);
+                self.run_body_lowering(db, &vfs, &bodies, &signatures, &variants, verbosity);
             }
 
             if !self.skip_inference {
-                self.run_inference(db, &vfs, &bodies, &signatures, verbosity);
+                self.run_inference(db, &vfs, &bodies, &signatures, &variants, verbosity);
             }
 
             if !self.skip_mir_stats {
-                self.run_mir_lowering(db, &bodies, &signatures, verbosity);
+                self.run_mir_lowering(db, &bodies, &signatures, &variants, verbosity);
             }
 
             if !self.skip_data_layout {
@@ -353,7 +360,7 @@ pub fn run(self, verbosity: Verbosity) -> anyhow::Result<()> {
             }
 
             if !self.skip_const_eval {
-                self.run_const_eval(db, &bodies, &signatures, verbosity);
+                self.run_const_eval(db, &bodies, &signatures, &variants, verbosity);
             }
         });
 
@@ -431,6 +438,7 @@ fn run_const_eval(
         db: &RootDatabase,
         bodies: &[DefWithBody],
         _signatures: &[GenericDef],
+        _variants: &[Variant],
         verbosity: Verbosity,
     ) {
         let len = bodies
@@ -710,6 +718,7 @@ fn run_mir_lowering(
         db: &RootDatabase,
         bodies: &[DefWithBody],
         _signatures: &[GenericDef],
+        _variants: &[Variant],
         verbosity: Verbosity,
     ) {
         let mut bar = match verbosity {
@@ -725,7 +734,7 @@ fn run_mir_lowering(
                 format!("mir lowering: {}", full_name(db, || body.name(db), body.module(db)))
             });
             bar.inc(1);
-            if matches!(body, DefWithBody::Variant(_)) {
+            if matches!(body, DefWithBody::EnumVariant(_)) {
                 continue;
             }
             let module = body.module(db);
@@ -768,6 +777,7 @@ fn run_inference(
         vfs: &Vfs,
         bodies: &[DefWithBody],
         signatures: &[GenericDef],
+        variants: &[Variant],
         verbosity: Verbosity,
     ) {
         let mut bar = match verbosity {
@@ -798,6 +808,13 @@ fn run_inference(
                     InferenceResult::of(snap, signatures);
                 })
                 .count();
+            let variants = variants.iter().copied().map(Into::into).collect::<Vec<VariantId>>();
+            variants
+                .par_iter()
+                .map_with(db.clone(), |snap, &variants| {
+                    InferenceResult::of(snap, variants);
+                })
+                .count();
             eprintln!("{:<20} {}", "Parallel Inference:", inference_sw.elapsed());
         }
 
@@ -829,7 +846,9 @@ fn run_inference(
                         DefWithBody::Function(it) => it.source(db).map(|it| it.syntax().cloned()),
                         DefWithBody::Static(it) => it.source(db).map(|it| it.syntax().cloned()),
                         DefWithBody::Const(it) => it.source(db).map(|it| it.syntax().cloned()),
-                        DefWithBody::Variant(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        DefWithBody::EnumVariant(it) => {
+                            it.source(db).map(|it| it.syntax().cloned())
+                        }
                     };
                     if let Some(src) = source {
                         let original_file = src.file_id.original_file(db);
@@ -1127,12 +1146,13 @@ fn run_body_lowering(
         vfs: &Vfs,
         bodies: &[DefWithBody],
         signatures: &[GenericDef],
+        variants: &[Variant],
         verbosity: Verbosity,
     ) {
         let mut bar = match verbosity {
             Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
             _ if self.output.is_some() => ProgressReport::hidden(),
-            _ => ProgressReport::new(bodies.len() + signatures.len()),
+            _ => ProgressReport::new(bodies.len() + signatures.len() + variants.len()),
         };
 
         let mut sw = self.stop_watch();
@@ -1181,6 +1201,44 @@ fn run_body_lowering(
             bar.inc(1);
         }
 
+        for &variant in variants {
+            let variant_id = variant.into();
+            let module = variant.module(db);
+            if !self.should_process(db, || Some(variant.name(db)), module) {
+                continue;
+            }
+            let msg = move || {
+                if verbosity.is_verbose() {
+                    let source = match variant {
+                        Variant::EnumVariant(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        Variant::Struct(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        Variant::Union(it) => it.source(db).map(|it| it.syntax().cloned()),
+                    };
+                    if let Some(src) = source {
+                        let original_file = src.file_id.original_file(db);
+                        let path = vfs.file_path(original_file.file_id(db));
+                        let syntax_range = src.text_range();
+                        format!(
+                            "processing: {} ({} {:?})",
+                            full_name(db, || Some(variant.name(db)), module),
+                            path,
+                            syntax_range
+                        )
+                    } else {
+                        format!("processing: {}", full_name(db, || Some(variant.name(db)), module))
+                    }
+                } else {
+                    format!("processing: {}", full_name(db, || Some(variant.name(db)), module))
+                }
+            };
+            if verbosity.is_spammy() {
+                bar.println(msg());
+            }
+            bar.set_message(msg);
+            ExpressionStore::of(db, ExpressionStoreOwnerId::VariantFields(variant_id));
+            bar.inc(1);
+        }
+
         for &body_id in bodies {
             let Ok(body_def_id) = body_id.try_into() else { continue };
             let module = body_id.module(db);
@@ -1193,7 +1251,9 @@ fn run_body_lowering(
                         DefWithBody::Function(it) => it.source(db).map(|it| it.syntax().cloned()),
                         DefWithBody::Static(it) => it.source(db).map(|it| it.syntax().cloned()),
                         DefWithBody::Const(it) => it.source(db).map(|it| it.syntax().cloned()),
-                        DefWithBody::Variant(it) => it.source(db).map(|it| it.syntax().cloned()),
+                        DefWithBody::EnumVariant(it) => {
+                            it.source(db).map(|it| it.syntax().cloned())
+                        }
                     };
                     if let Some(src) = source {
                         let original_file = src.file_id.original_file(db);

From 219420573bd46c196978176249539c5dd35764e8 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 28 Mar 2026 19:25:06 +0300
Subject: [PATCH 1017/1059] `const_cmp` for `core::mem::Alignment`

---
 library/core/src/mem/alignment.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/library/core/src/mem/alignment.rs b/library/core/src/mem/alignment.rs
index 69a5f66ff5d2..54d4cd75886e 100644
--- a/library/core/src/mem/alignment.rs
+++ b/library/core/src/mem/alignment.rs
@@ -11,7 +11,8 @@
 /// Note that particularly large alignments, while representable in this type,
 /// are likely not to be supported by actual allocators and linkers.
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone)]
+#[derive_const(PartialEq, Eq)]
 #[repr(transparent)]
 pub struct Alignment {
     // This field is never used directly (nor is the enum),
@@ -303,7 +304,8 @@ fn from(align: Alignment) -> usize {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl cmp::Ord for Alignment {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const cmp::Ord for Alignment {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.as_nonzero_usize().cmp(&other.as_nonzero_usize())
@@ -311,7 +313,8 @@ fn cmp(&self, other: &Self) -> cmp::Ordering {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl cmp::PartialOrd for Alignment {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const cmp::PartialOrd for Alignment {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         Some(self.cmp(other))
@@ -336,7 +339,8 @@ fn default() -> Alignment {
 }
 
 #[cfg(target_pointer_width = "16")]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone)]
+#[derive_const(PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,
@@ -358,7 +362,8 @@ enum AlignmentEnum {
 }
 
 #[cfg(target_pointer_width = "32")]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone)]
+#[derive_const(PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,
@@ -396,7 +401,8 @@ enum AlignmentEnum {
 }
 
 #[cfg(target_pointer_width = "64")]
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone)]
+#[derive_const(PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,

From c45bfa8d73fe7706c162f934345c8dacb349ba9a Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 28 Mar 2026 20:21:33 +0300
Subject: [PATCH 1018/1059] `const_clone` for `core::mem::Alignment`

---
 library/core/src/mem/alignment.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/core/src/mem/alignment.rs b/library/core/src/mem/alignment.rs
index 54d4cd75886e..a8c4c8ea78ff 100644
--- a/library/core/src/mem/alignment.rs
+++ b/library/core/src/mem/alignment.rs
@@ -11,8 +11,8 @@
 /// Note that particularly large alignments, while representable in this type,
 /// are likely not to be supported by actual allocators and linkers.
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[derive(Copy, Clone)]
-#[derive_const(PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct Alignment {
     // This field is never used directly (nor is the enum),
@@ -339,8 +339,8 @@ fn default() -> Alignment {
 }
 
 #[cfg(target_pointer_width = "16")]
-#[derive(Copy, Clone)]
-#[derive_const(PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,
@@ -362,8 +362,8 @@ enum AlignmentEnum {
 }
 
 #[cfg(target_pointer_width = "32")]
-#[derive(Copy, Clone)]
-#[derive_const(PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,
@@ -401,8 +401,8 @@ enum AlignmentEnum {
 }
 
 #[cfg(target_pointer_width = "64")]
-#[derive(Copy, Clone)]
-#[derive_const(PartialEq, Eq)]
+#[derive(Copy)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[repr(usize)]
 enum AlignmentEnum {
     _Align1Shl0 = 1 << 0,

From 085dff4944882b255671a4a5ca76e05a71e6b625 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Mon, 2 Mar 2026 21:01:30 -0700
Subject: [PATCH 1019/1059] stabilize new RangeFrom type and iterator

stabilizes `core::range::RangeFrom`
stabilizes `core::range::RangeFromIter`

add examples for `remainder` method on range iterators
`RangeFromIter::remainder` was not stabilized (see issue 154458)
---
 library/core/src/ffi/c_str.rs                 |  2 +-
 library/core/src/range.rs                     | 41 ++++++++-----------
 library/core/src/range/iter.rs                | 41 +++++++++++++++++--
 library/core/src/slice/index.rs               |  4 +-
 library/core/src/str/traits.rs                |  2 +-
 .../fromrangeiter-overflow-checks.rs          |  1 +
 .../rangefrom-overflow-2crates-ocno.rs        |  1 -
 .../rangefrom-overflow-2crates-ocyes.rs       |  1 -
 tests/ui/iterators/fromrangeiter.rs           |  2 -
 .../iterators/rangefrom-overflow-2crates.rs   |  2 -
 tests/ui/range/new_range_stability.rs         | 24 +++++++++--
 tests/ui/range/new_range_stability.stderr     | 38 +++++++----------
 12 files changed, 95 insertions(+), 64 deletions(-)

diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index 5fc97d9a69ef..62b3d75d7a77 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -716,7 +716,7 @@ fn index(&self, index: ops::RangeFrom<usize>) -> &CStr {
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 impl ops::Index<range::RangeFrom<usize>> for CStr {
     type Output = CStr;
 
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index 3c2c40d49200..2007533e68e5 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -24,12 +24,15 @@
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub mod legacy;
 
+#[doc(inline)]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+pub use iter::RangeFromIter;
 #[doc(inline)]
 #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 pub use iter::RangeInclusiveIter;
 #[doc(inline)]
 #[unstable(feature = "new_range_api", issue = "125687")]
-pub use iter::{RangeFromIter, RangeIter};
+pub use iter::RangeIter;
 
 // FIXME(#125687): re-exports temporarily removed
 // Because re-exports of stable items (Bound, RangeBounds, RangeFull, RangeTo)
@@ -416,14 +419,13 @@ fn from(value: legacy::RangeInclusive<T>) -> Self {
 ///
 /// The `RangeFrom` `start..` contains all values with `x >= start`.
 ///
-/// *Note*: Overflow in the [`Iterator`] implementation (when the contained
+/// *Note*: Overflow in the [`IntoIterator`] implementation (when the contained
 /// data type reaches its numerical limit) is allowed to panic, wrap, or
 /// saturate. This behavior is defined by the implementation of the [`Step`]
 /// trait. For primitive integers, this follows the normal rules, and respects
-/// the overflow checks profile (panic in debug, wrap in release). Note also
-/// that overflow happens earlier than you might assume: the overflow happens
-/// in the call to `next` that yields the maximum value, as the range must be
-/// set to a state to yield the next value.
+/// the overflow checks profile (panic in debug, wrap in release). Unlike
+/// its legacy counterpart, the iterator will only panic after yielding the
+/// maximum value when overflow checks are enabled.
 ///
 /// [`Step`]: crate::iter::Step
 ///
@@ -432,7 +434,6 @@ fn from(value: legacy::RangeInclusive<T>) -> Self {
 /// The `start..` syntax is a `RangeFrom`:
 ///
 /// ```
-/// #![feature(new_range_api)]
 /// use core::range::RangeFrom;
 ///
 /// assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });
@@ -441,14 +442,14 @@ fn from(value: legacy::RangeInclusive<T>) -> Self {
 #[lang = "RangeFromCopy"]
 #[derive(Copy, Hash)]
 #[derive_const(Clone, PartialEq, Eq)]
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
     pub start: Idx,
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 impl<Idx: fmt::Debug> fmt::Debug for RangeFrom<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.start.fmt(fmt)?;
@@ -465,7 +466,6 @@ impl<Idx: Step> RangeFrom<Idx> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_range_api)]
     /// use core::range::RangeFrom;
     ///
     /// let mut i = RangeFrom::from(3..).iter().map(|n| n*n);
@@ -473,7 +473,7 @@ impl<Idx: Step> RangeFrom<Idx> {
     /// assert_eq!(i.next(), Some(16));
     /// assert_eq!(i.next(), Some(25));
     /// ```
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub fn iter(&self) -> RangeFromIter<Idx> {
         self.clone().into_iter()
@@ -486,7 +486,6 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_range_api)]
     /// use core::range::RangeFrom;
     ///
     /// assert!(!RangeFrom::from(3..).contains(&2));
@@ -498,7 +497,7 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
     /// assert!(!RangeFrom::from(f32::NAN..).contains(&0.5));
     /// ```
     #[inline]
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
     #[rustc_const_unstable(feature = "const_range", issue = "none")]
     pub const fn contains<U>(&self, item: &U) -> bool
     where
@@ -509,7 +508,7 @@ pub const fn contains<U>(&self, item: &U) -> bool
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeFrom<T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -526,7 +525,7 @@ fn end_bound(&self) -> Bound<&T> {
 /// If you need to use this implementation where `T` is unsized,
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..` with `(Bound::Included(start), Bound::Unbounded)`.
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeFrom<&T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -537,8 +536,7 @@ fn end_bound(&self) -> Bound<&T> {
     }
 }
 
-// #[unstable(feature = "range_into_bounds", issue = "136903")]
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[unstable(feature = "range_into_bounds", issue = "136903")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const IntoBounds<T> for RangeFrom<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
@@ -547,7 +545,6 @@ fn into_bounds(self) -> (Bound<T>, Bound<T>) {
 }
 
 #[unstable(feature = "one_sided_range", issue = "69780")]
-// #[unstable(feature = "new_range_api", issue = "125687")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const OneSidedRange<T> for RangeFrom<T>
 where
@@ -558,7 +555,7 @@ fn bound(self) -> (OneSidedRangeBound, T) {
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 impl<T> const From<RangeFrom<T>> for legacy::RangeFrom<T> {
     #[inline]
@@ -566,7 +563,7 @@ fn from(value: RangeFrom<T>) -> Self {
         Self { start: value.start }
     }
 }
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
     #[inline]
@@ -697,7 +694,6 @@ fn end_bound(&self) -> Bound<&T> {
     }
 }
 
-// #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
 #[unstable(feature = "range_into_bounds", issue = "136903")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const IntoBounds<T> for RangeToInclusive<T> {
@@ -706,7 +702,6 @@ fn into_bounds(self) -> (Bound<T>, Bound<T>) {
     }
 }
 
-// #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
 #[unstable(feature = "one_sided_range", issue = "69780")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const OneSidedRange<T> for RangeToInclusive<T>
diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs
index 23ace6e1ba25..0cddfff4022d 100644
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -13,6 +13,18 @@
 impl<A> RangeIter<A> {
     #[unstable(feature = "new_range_api", issue = "125687")]
     /// Returns the remainder of the range being iterated over.
+    ///
+    /// # Examples
+    /// ```
+    /// #![feature(new_range_api)]
+    /// let range = core::range::Range::from(3..11);
+    /// let mut iter = range.into_iter();
+    /// assert_eq!(iter.clone().remainder(), range);
+    /// iter.next();
+    /// assert_eq!(iter.clone().remainder(), core::range::Range::from(4..11));
+    /// iter.by_ref().for_each(drop);
+    /// assert!(iter.remainder().is_empty());
+    /// ```
     pub fn remainder(self) -> Range<A> {
         Range { start: self.0.start, end: self.0.end }
     }
@@ -161,6 +173,17 @@ impl<A: Step> RangeInclusiveIter<A> {
     /// Returns the remainder of the range being iterated over.
     ///
     /// If the iterator is exhausted or empty, returns `None`.
+    ///
+    /// # Examples
+    /// ```
+    /// let range = core::range::RangeInclusive::from(3..=11);
+    /// let mut iter = range.into_iter();
+    /// assert_eq!(iter.clone().remainder().unwrap(), range);
+    /// iter.next();
+    /// assert_eq!(iter.clone().remainder().unwrap(), core::range::RangeInclusive::from(4..=11));
+    /// iter.by_ref().for_each(drop);
+    /// assert!(iter.remainder().is_none());
+    /// ```
     #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
     pub fn remainder(self) -> Option<RangeInclusive<A>> {
         if self.0.is_empty() {
@@ -294,7 +317,7 @@ impl ExactSizeIterator for RangeInclusiveIter<$t> { }
 }
 
 /// By-value [`RangeFrom`] iterator.
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[derive(Debug, Clone)]
 pub struct RangeFromIter<A> {
     start: A,
@@ -305,6 +328,16 @@ pub struct RangeFromIter<A> {
 
 impl<A: Step> RangeFromIter<A> {
     /// Returns the remainder of the range being iterated over.
+    ///
+    /// # Examples
+    /// ```
+    /// #![feature(new_range_api)]
+    /// let range = core::range::RangeFrom::from(3..);
+    /// let mut iter = range.into_iter();
+    /// assert_eq!(iter.clone().remainder(), range);
+    /// iter.next();
+    /// assert_eq!(iter.remainder(), core::range::RangeFrom::from(4..));
+    /// ```
     #[inline]
     #[rustc_inherit_overflow_checks]
     #[unstable(feature = "new_range_api", issue = "125687")]
@@ -321,7 +354,7 @@ pub fn remainder(self) -> RangeFrom<A> {
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Step> Iterator for RangeFromIter<A> {
     type Item = A;
 
@@ -392,10 +425,10 @@ fn nth(&mut self, n: usize) -> Option<A> {
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A: TrustedStep> TrustedLen for RangeFromIter<A> {}
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Step> FusedIterator for RangeFromIter<A> {}
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Step> IntoIterator for RangeFrom<A> {
     type Item = A;
     type IntoIter = RangeFromIter<A>;
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index 1709bc7c0984..b30f82a5783a 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -131,7 +131,7 @@ impl Sealed for range::Range<usize> {}
     impl Sealed for range::RangeInclusive<usize> {}
     #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
     impl Sealed for range::RangeToInclusive<usize> {}
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
     impl Sealed for range::RangeFrom<usize> {}
 
     impl Sealed for ops::IndexRange {}
@@ -588,7 +588,7 @@ fn index_mut(self, slice: &mut [T]) -> &mut [T] {
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl<T> const SliceIndex<[T]> for range::RangeFrom<usize> {
     type Output = [T];
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 88a8a9764cbc..336f074883d2 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -555,7 +555,7 @@ fn index_mut(self, slice: &mut str) -> &mut Self::Output {
     }
 }
 
-#[unstable(feature = "new_range_api", issue = "125687")]
+#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl const SliceIndex<str> for range::RangeFrom<usize> {
     type Output = str;
diff --git a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
index 455c81c63340..6bc4d3de3478 100644
--- a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
+++ b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
@@ -11,6 +11,7 @@
 
 #![crate_type = "lib"]
 #![feature(new_range_api)]
+
 use std::range::RangeFrom;
 
 // CHECK-LABEL: @rangefrom_increments(
diff --git a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
index ebba4ae92c47..e2aa817699a0 100644
--- a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
+++ b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocno.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -C overflow-checks=no
 
 #![crate_type = "lib"]
-#![feature(new_range_api)]
 
 use std::range::RangeFromIter;
 
diff --git a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
index 8eb5392c7bac..b37f6985a0ea 100644
--- a/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
+++ b/tests/ui/iterators/auxiliary/rangefrom-overflow-2crates-ocyes.rs
@@ -1,7 +1,6 @@
 //@ compile-flags: -C overflow-checks=yes
 
 #![crate_type = "lib"]
-#![feature(new_range_api)]
 
 use std::range::RangeFromIter;
 
diff --git a/tests/ui/iterators/fromrangeiter.rs b/tests/ui/iterators/fromrangeiter.rs
index 54d8f522a2c8..c672f1348437 100644
--- a/tests/ui/iterators/fromrangeiter.rs
+++ b/tests/ui/iterators/fromrangeiter.rs
@@ -1,8 +1,6 @@
 //@ run-pass
 //@ compile-flags: -C overflow-checks=yes
 
-#![feature(new_range_api)]
-
 use std::{iter, range};
 
 fn main() {
diff --git a/tests/ui/iterators/rangefrom-overflow-2crates.rs b/tests/ui/iterators/rangefrom-overflow-2crates.rs
index c35c96f99322..56b642b2c548 100644
--- a/tests/ui/iterators/rangefrom-overflow-2crates.rs
+++ b/tests/ui/iterators/rangefrom-overflow-2crates.rs
@@ -7,8 +7,6 @@
 // Test that two crates with different overflow-checks have the same results,
 // even when the iterator is passed between them.
 
-#![feature(new_range_api)]
-
 extern crate rangefrom_overflow_2crates_ocno;
 extern crate rangefrom_overflow_2crates_ocyes;
 
diff --git a/tests/ui/range/new_range_stability.rs b/tests/ui/range/new_range_stability.rs
index 2d129fb6815f..0b2965ecba23 100644
--- a/tests/ui/range/new_range_stability.rs
+++ b/tests/ui/range/new_range_stability.rs
@@ -1,6 +1,12 @@
 // Stable
 
-use std::range::{RangeInclusive, RangeInclusiveIter, RangeToInclusive};
+use std::range::{
+    RangeInclusive,
+    RangeInclusiveIter,
+    RangeToInclusive,
+    RangeFrom,
+    RangeFromIter,
+};
 
 fn range_inclusive(mut r: RangeInclusive<usize>) {
     &[1, 2, 3][r]; // Indexing
@@ -23,15 +29,27 @@ fn range_to_inclusive(mut r: RangeToInclusive<usize>) {
     r.contains(&5);
 }
 
+fn range_from(mut r: RangeFrom<usize>) {
+    &[1, 2, 3][r]; // Indexing
+
+    r.start;
+    r.contains(&5);
+    r.iter();
+
+    let mut i = r.into_iter();
+    i.next();
+
+    // Left unstable
+    i.remainder(); //~ ERROR unstable
+}
+
 // Unstable module
 
 use std::range::legacy; //~ ERROR unstable
 
 // Unstable types
 
-use std::range::RangeFrom; //~ ERROR unstable
 use std::range::Range; //~ ERROR unstable
-use std::range::RangeFromIter; //~ ERROR unstable
 use std::range::RangeIter; //~ ERROR unstable
 
 fn main() {}
diff --git a/tests/ui/range/new_range_stability.stderr b/tests/ui/range/new_range_stability.stderr
index b5a7e06e5f2e..747c39d001eb 100644
--- a/tests/ui/range/new_range_stability.stderr
+++ b/tests/ui/range/new_range_stability.stderr
@@ -1,5 +1,5 @@
 error[E0658]: use of unstable library feature `new_range_api`
-  --> $DIR/new_range_stability.rs:28:5
+  --> $DIR/new_range_stability.rs:48:5
    |
 LL | use std::range::legacy;
    |     ^^^^^^^^^^^^^^^^^^
@@ -9,17 +9,7 @@ LL | use std::range::legacy;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `new_range_api`
-  --> $DIR/new_range_stability.rs:32:5
-   |
-LL | use std::range::RangeFrom;
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #125687 <https://github.com/rust-lang/rust/issues/125687> for more information
-   = help: add `#![feature(new_range_api)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: use of unstable library feature `new_range_api`
-  --> $DIR/new_range_stability.rs:33:5
+  --> $DIR/new_range_stability.rs:52:5
    |
 LL | use std::range::Range;
    |     ^^^^^^^^^^^^^^^^^
@@ -29,17 +19,7 @@ LL | use std::range::Range;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `new_range_api`
-  --> $DIR/new_range_stability.rs:34:5
-   |
-LL | use std::range::RangeFromIter;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #125687 <https://github.com/rust-lang/rust/issues/125687> for more information
-   = help: add `#![feature(new_range_api)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: use of unstable library feature `new_range_api`
-  --> $DIR/new_range_stability.rs:35:5
+  --> $DIR/new_range_stability.rs:53:5
    |
 LL | use std::range::RangeIter;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -48,6 +28,16 @@ LL | use std::range::RangeIter;
    = help: add `#![feature(new_range_api)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 5 previous errors
+error[E0658]: use of unstable library feature `new_range_api`
+  --> $DIR/new_range_stability.rs:43:7
+   |
+LL |     i.remainder();
+   |       ^^^^^^^^^
+   |
+   = note: see issue #125687 <https://github.com/rust-lang/rust/issues/125687> for more information
+   = help: add `#![feature(new_range_api)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0658`.

From 8c2516c0799e44ae177c125c24681fb0c974485d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sat, 28 Mar 2026 19:45:29 +0100
Subject: [PATCH 1020/1059] Only allocate item blocks if they actually contain
 items or statement macros

---
 .../rust-analyzer/crates/span/src/ast_id.rs   | 70 ++++++++++++++-----
 1 file changed, 52 insertions(+), 18 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/span/src/ast_id.rs b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
index f52604e13917..bae461e5a8de 100644
--- a/src/tools/rust-analyzer/crates/span/src/ast_id.rs
+++ b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
@@ -206,6 +206,11 @@ fn kind(self) -> u32 {
         self.0 >> (HASH_BITS + INDEX_BITS)
     }
 
+    #[inline]
+    pub fn is_root(self) -> bool {
+        self.kind() == ErasedFileAstIdKind::Root as u32
+    }
+
     fn ast_id_for(
         node: &SyntaxNode,
         index_map: &mut ErasedAstIdNextIndexMap,
@@ -220,14 +225,16 @@ fn ast_id_for(
             .or_else(|| asm_expr_ast_id(node, index_map))
     }
 
-    fn should_alloc(node: &SyntaxNode) -> bool {
+    fn should_alloc(node: &SyntaxNode) -> Option<ErasedFileAstIdKind> {
         let kind = node.kind();
         should_alloc_has_name(kind)
-            || should_alloc_assoc_item(kind)
-            || ast::ExternBlock::can_cast(kind)
-            || ast::Use::can_cast(kind)
-            || ast::Impl::can_cast(kind)
-            || ast::AsmExpr::can_cast(kind)
+            .or_else(|| should_alloc_assoc_item(kind))
+            .or_else(|| {
+                ast::ExternBlock::can_cast(kind).then_some(ErasedFileAstIdKind::ExternBlock)
+            })
+            .or_else(|| ast::Use::can_cast(kind).then_some(ErasedFileAstIdKind::Use))
+            .or_else(|| ast::Impl::can_cast(kind).then_some(ErasedFileAstIdKind::Impl))
+            .or_else(|| ast::AsmExpr::can_cast(kind).then_some(ErasedFileAstIdKind::AsmExpr))
     }
 
     #[inline]
@@ -478,8 +485,8 @@ fn has_name_ast_id(node: &SyntaxNode, index_map: &mut ErasedAstIdNextIndexMap) -
             }
         }
 
-        fn should_alloc_has_name(kind: SyntaxKind) -> bool {
-            false $( || ast::$ident::can_cast(kind) )*
+        fn should_alloc_has_name(kind: SyntaxKind) -> Option<ErasedFileAstIdKind> {
+            $( if ast::$ident::can_cast(kind) { Some(ErasedFileAstIdKind::$ident) } else )* { None }
         }
     };
 }
@@ -528,8 +535,8 @@ fn assoc_item_ast_id(
             }
         }
 
-        fn should_alloc_assoc_item(kind: SyntaxKind) -> bool {
-            false $( || ast::$ident::can_cast(kind) )*
+        fn should_alloc_assoc_item(kind: SyntaxKind) -> Option<ErasedFileAstIdKind> {
+            $( if ast::$ident::can_cast(kind) { Some(ErasedFileAstIdKind::$ident) } else )* { None }
         }
     };
 }
@@ -612,22 +619,49 @@ pub fn from_source(node: &SyntaxNode) -> AstIdMap {
                         syntax::WalkEvent::Enter(node) => {
                             if ast::BlockExpr::can_cast(node.kind()) {
                                 blocks.push((node, ContainsItems::No));
-                            } else if ErasedFileAstId::should_alloc(&node) {
+                            } else if let Some(kind) = ErasedFileAstId::should_alloc(&node) {
                                 // Allocate blocks on-demand, only if they have items.
                                 // We don't associate items with blocks, only with items, since block IDs can be quite unstable.
                                 // FIXME: Is this the correct thing to do? Macro calls might actually be more incremental if
                                 // associated with blocks (not sure). Either way it's not a big deal.
+                                let is_item = matches!(
+                                    kind,
+                                    ErasedFileAstIdKind::Enum
+                                        | ErasedFileAstIdKind::Struct
+                                        | ErasedFileAstIdKind::Union
+                                        | ErasedFileAstIdKind::ExternCrate
+                                        | ErasedFileAstIdKind::MacroDef
+                                        | ErasedFileAstIdKind::MacroRules
+                                        | ErasedFileAstIdKind::Module
+                                        | ErasedFileAstIdKind::Static
+                                        | ErasedFileAstIdKind::Trait
+                                        | ErasedFileAstIdKind::Const
+                                        | ErasedFileAstIdKind::Fn
+                                        | ErasedFileAstIdKind::TypeAlias
+                                        | ErasedFileAstIdKind::ExternBlock
+                                        | ErasedFileAstIdKind::Use
+                                        | ErasedFileAstIdKind::Impl
+                                );
                                 if let Some((
                                     last_block_node,
                                     already_allocated @ ContainsItems::No,
                                 )) = blocks.last_mut()
+                                    && (is_item
+                                        || (kind == ErasedFileAstIdKind::MacroCall && {
+                                            let mut anc = node.ancestors();
+                                            _ = anc.next();
+                                            anc.next().is_some_and(|it| {
+                                                it.kind() == SyntaxKind::MACRO_EXPR
+                                            }) && anc.next().is_some_and(|it| {
+                                                it.kind() == SyntaxKind::EXPR_STMT
+                                                    || it.kind() == SyntaxKind::STMT_LIST
+                                            })
+                                        }))
                                 {
-                                    let block_ast_id = block_expr_ast_id(
-                                        last_block_node,
-                                        &mut index_map,
-                                        parent_of(parent_idx, &res),
-                                    )
-                                    .expect("not a BlockExpr");
+                                    let parent = parent_of(parent_idx, &res);
+                                    let block_ast_id =
+                                        block_expr_ast_id(last_block_node, &mut index_map, parent)
+                                            .expect("not a BlockExpr");
                                     res.arena
                                         .alloc((SyntaxNodePtr::new(last_block_node), block_ast_id));
                                     *already_allocated = ContainsItems::Yes;
@@ -644,7 +678,7 @@ pub fn from_source(node: &SyntaxNode) -> AstIdMap {
                             }
                         }
                         syntax::WalkEvent::Leave(node) => {
-                            if ast::BlockExpr::can_cast(node.kind()) {
+                            if cfg!(debug_assertions) && ast::BlockExpr::can_cast(node.kind()) {
                                 assert_eq!(
                                     blocks.pop().map(|it| it.0),
                                     Some(node),

From 14e4991c03dc1e5d3f4785a4f2ba5e0e59ce5954 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Sun, 29 Mar 2026 00:25:43 +0530
Subject: [PATCH 1021/1059] Notify stdarch maintainers for std_detect

---
 triagebot.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 01d047cdae55..9ab39bba578a 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1073,6 +1073,10 @@ instead.
 """
 cc = ["@Amanieu", "@folkertdev", "@sayantn"]
 
+[mentions."library/std_detect"]
+message = "Some changes occurred in `std_detect`"
+cc = ["@Amanieu", "@folkertdev", "@sayantn"]
+
 [mentions."library/core/src/intrinsics/simd.rs"]
 message = """
 Some changes occurred to the platform-builtins intrinsics. Make sure the

From fbfecb8d782ccce085c5d9b0deac55a985b58450 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Sun, 29 Mar 2026 00:31:12 +0530
Subject: [PATCH 1022/1059] Map std_detect to t-libs

---
 triagebot.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/triagebot.toml b/triagebot.toml
index 9ab39bba578a..1d48365d288e 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1596,6 +1596,7 @@ dep-bumps = [
 "/library/std" =                                         ["libs", "@ChrisDenton"]
 "/library/std/src/sys/pal/windows" =                     ["@ChrisDenton"]
 "/library/stdarch" =                                     ["libs"]
+"/library/std_detect" =                                  ["libs"]
 "/library/test" =                                        ["libs"]
 "/src/bootstrap" =                                       ["bootstrap"]
 "/src/ci" =                                              ["infra-ci"]

From 1a320616e9d090e7ef7ac90e5ceabd7e2248d97f Mon Sep 17 00:00:00 2001
From: Nikita Popov <github@npopov.com>
Date: Sat, 28 Mar 2026 17:43:29 +0100
Subject: [PATCH 1023/1059] [perf] Revert FastISel patch

This change caused a significant compile-time regression for
debug builds.
---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 05918363362b..1cb4e3833c19 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 05918363362b439b9b0bced3daa14badd75da790
+Subproject commit 1cb4e3833c1919c2e6fb579a23ac0e2b22587b7e

From 27242aa3196c1aa7b58fa744231f76362b0ecf2c Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@gmail.com>
Date: Sat, 28 Mar 2026 21:00:03 +0000
Subject: [PATCH 1024/1059] Panic in Hermit clock_gettime

---
 library/std/src/sys/time/hermit.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/time/hermit.rs b/library/std/src/sys/time/hermit.rs
index 8e8a656ab61e..4e8e5dfe21c8 100644
--- a/library/std/src/sys/time/hermit.rs
+++ b/library/std/src/sys/time/hermit.rs
@@ -6,7 +6,7 @@
 
 fn clock_gettime(clock: hermit_abi::clockid_t) -> Timespec {
     let mut t = hermit_abi::timespec { tv_sec: 0, tv_nsec: 0 };
-    let _ = unsafe { hermit_abi::clock_gettime(clock, &raw mut t) };
+    unsafe { hermit_abi::clock_gettime(clock, &raw mut t) }.unwrap();
     Timespec::new(t.tv_sec, t.tv_nsec.into()).unwrap()
 }
 

From 6183ecdda52ba9b9b93f656f9a37492168c82726 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 22:39:52 +0100
Subject: [PATCH 1025/1059] native-lib: fix passing repr(C) enums

---
 src/tools/miri/src/shims/native_lib/mod.rs            |  5 +++--
 .../miri/tests/native-lib/pass/scalar_arguments.rs    | 11 +++++++++++
 src/tools/miri/tests/native-lib/scalar_arguments.c    |  9 +++++++++
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 6a281ddbb7b2..b302a07cf0c5 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -396,8 +396,9 @@ fn ty_to_ffitype(&self, layout: TyAndLayout<'tcx>) -> Result<FfiType, Ty<'tcx>>
         // matches what codegen does. This does mean that we support some types whose ABI is not
         // stable, but that's fine -- we are anyway quite conservative in native-lib mode.
         if let BackendRepr::Scalar(s) = layout.backend_repr {
-            // Simple sanity-check: this cannot be `repr(C)`.
-            assert!(!layout.ty.ty_adt_def().is_some_and(|adt| adt.repr().c()));
+            // Simple sanity-check: this cannot be a `repr(C)` struct or union. (It could be a
+            // repr(C) enum. Those indeed behave like integers in the ABI.)
+            assert!(!layout.ty.ty_adt_def().is_some_and(|adt| !adt.is_enum() && adt.repr().c()));
             return Ok(match s.primitive() {
                 Primitive::Int(Integer::I8, /* signed */ true) => FfiType::i8(),
                 Primitive::Int(Integer::I16, /* signed */ true) => FfiType::i16(),
diff --git a/src/tools/miri/tests/native-lib/pass/scalar_arguments.rs b/src/tools/miri/tests/native-lib/pass/scalar_arguments.rs
index 231df67bb5b8..07584ba236b9 100644
--- a/src/tools/miri/tests/native-lib/pass/scalar_arguments.rs
+++ b/src/tools/miri/tests/native-lib/pass/scalar_arguments.rs
@@ -1,3 +1,10 @@
+#[allow(unused)]
+#[repr(C)]
+enum CEnum {
+    A,
+    B,
+}
+
 extern "C" {
     fn add_one_int(x: i32) -> i32;
     fn add_int16(x: i16) -> i16;
@@ -19,6 +26,7 @@ fn test_stack_spill(
     fn get_unsigned_int() -> u32;
     fn add_float(x: f32) -> f32;
     fn printer();
+    fn scalar_enum(e: CEnum) -> u8;
 }
 
 fn main() {
@@ -43,5 +51,8 @@ fn main() {
 
         // test void function that prints from C
         printer();
+
+        // test passing enums with scalar layout
+        assert_eq!(scalar_enum(CEnum::B), 1);
     }
 }
diff --git a/src/tools/miri/tests/native-lib/scalar_arguments.c b/src/tools/miri/tests/native-lib/scalar_arguments.c
index 720f1982178c..19ca940204a0 100644
--- a/src/tools/miri/tests/native-lib/scalar_arguments.c
+++ b/src/tools/miri/tests/native-lib/scalar_arguments.c
@@ -4,6 +4,11 @@
 // See comments in build_native_lib()
 #define EXPORT __attribute__((visibility("default")))
 
+enum cenum {
+  cenum_a,
+  cenum_b,
+};
+
 EXPORT int32_t add_one_int(int32_t x) {
   return 2 + x;
 }
@@ -38,6 +43,10 @@ EXPORT uint8_t u8_id(uint8_t x) {
   return x;
 }
 
+EXPORT uint8_t scalar_enum(enum cenum e) {
+  return (uint8_t)e;
+}
+
 // To test that functions not marked with EXPORT cannot be called by Miri.
 int32_t not_exported(void) {
   return 0;

From 1c3e8d133d07d7492afa355c544b8bb15251141b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 22:55:21 +0100
Subject: [PATCH 1026/1059] fix UB in test_swap_ptr_triple_dangling

---
 src/tools/miri/tests/native-lib/pass/ptr_write_access.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs
index 57def78b0ab1..03f14dcc3cc9 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs
+++ b/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs
@@ -176,7 +176,7 @@ struct Triple {
     }
 
     extern "C" {
-        fn swap_ptr_triple_dangling(t_ptr: *const Triple);
+        fn swap_ptr_triple_dangling(t_ptr: *mut Triple);
     }
 
     let x = 101;
@@ -184,9 +184,9 @@ struct Triple {
     let ptr = Box::as_ptr(&b);
     drop(b);
     let z = 121;
-    let triple = Triple { ptr0: &raw const x, ptr1: ptr, ptr2: &raw const z };
+    let mut triple = Triple { ptr0: &raw const x, ptr1: ptr, ptr2: &raw const z };
 
-    unsafe { swap_ptr_triple_dangling(&triple) }
+    unsafe { swap_ptr_triple_dangling(&mut triple) }
     assert_eq!(unsafe { *triple.ptr2 }, x);
 }
 

From 7500768c6877b2f75d4b6263df70f9a45b9ee1eb Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Sat, 28 Mar 2026 21:58:50 +0000
Subject: [PATCH 1027/1059] Use flag subtraction pattern for _umtx_time flags
 check.

Instead of listing supported flags twice (once for the unsupported
check and once for extraction), subtract known flags and check for
!= 0 at the end, matching the convention used elsewhere in Miri.
---
 src/tools/miri/src/shims/unix/freebsd/sync.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/freebsd/sync.rs b/src/tools/miri/src/shims/unix/freebsd/sync.rs
index 8c585c7ec264..7c46dd549bc0 100644
--- a/src/tools/miri/src/shims/unix/freebsd/sync.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/sync.rs
@@ -215,14 +215,18 @@ fn read_umtx_time(&mut self, ut: &MPlaceTy<'tcx>) -> InterpResult<'tcx, Option<U
         let Some(duration) = this.read_timespec(&timespec_place)? else { return interp_ok(None) };
 
         let flags_place = this.project_field(ut, FieldIdx::from_u32(1))?;
-        let flags = this.read_scalar(&flags_place)?.to_u32()?;
+        let mut flags = this.read_scalar(&flags_place)?.to_u32()?;
 
-        if flags & !abs_time != 0 {
+        let abs_time_flag = if flags & abs_time != 0 {
+            flags &= !abs_time;
+            true
+        } else {
+            false
+        };
+        if flags != 0 {
             throw_unsup_format!("unsupported `_umtx_time` flags: {:#x}", flags);
         }
 
-        let abs_time_flag = flags & abs_time != 0;
-
         let clock_id_place = this.project_field(ut, FieldIdx::from_u32(2))?;
         let clock_id = this.read_scalar(&clock_id_place)?;
         let Some(timeout_clock) = this.parse_clockid(clock_id) else {

From 18a3bda0912e94af231fea44b9bd0f629f12608d Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 29 Mar 2026 01:07:39 +0300
Subject: [PATCH 1028/1059] Add doc links to `ExtractIf` of `BTree{Set,Map}`
 and `LinkedList`

---
 library/alloc/src/collections/btree/map.rs   | 4 +++-
 library/alloc/src/collections/btree/set.rs   | 4 +++-
 library/alloc/src/collections/linked_list.rs | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index e7a10d2220b0..e3a6e90566f5 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -2102,7 +2102,9 @@ fn default() -> Self {
     }
 }
 
-/// An iterator produced by calling `extract_if` on BTreeMap.
+/// This `struct` is created by the [`extract_if`] method on [`BTreeMap`].
+///
+/// [`extract_if`]: BTreeMap::extract_if
 #[stable(feature = "btree_extract_if", since = "1.91.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` or `extract_if().for_each(drop)` to remove and discard elements"]
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index af6f5c7d7017..db8007834432 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -1547,7 +1547,9 @@ fn into_iter(self) -> Iter<'a, T> {
     }
 }
 
-/// An iterator produced by calling `extract_if` on BTreeSet.
+/// This `struct` is created by the [`extract_if`] method on [`BTreeSet`].
+///
+/// [`extract_if`]: BTreeSet::extract_if
 #[stable(feature = "btree_extract_if", since = "1.91.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` or `extract_if().for_each(drop)` to remove and discard elements"]
diff --git a/library/alloc/src/collections/linked_list.rs b/library/alloc/src/collections/linked_list.rs
index 674828b8e7de..1816349e45f4 100644
--- a/library/alloc/src/collections/linked_list.rs
+++ b/library/alloc/src/collections/linked_list.rs
@@ -1942,7 +1942,9 @@ pub fn back_mut(&mut self) -> Option<&mut T> {
     }
 }
 
-/// An iterator produced by calling `extract_if` on LinkedList.
+/// This `struct` is created by the [`extract_if`] method on [`LinkedList`].
+///
+/// [`extract_if`]: LinkedList::extract_if
 #[stable(feature = "extract_if", since = "1.87.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `extract_if().for_each(drop)` to remove and discard elements"]

From afe522a7545a14c741a0aea05663a4cb130e44fd Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 29 Mar 2026 08:47:40 +0800
Subject: [PATCH 1029/1059] fix: don't panic unmerge arm on trailing pipe

Example
---
```rust
fn main() {
    let y = match 0 {
        0 |$0 => { 1i32 }
        1 => { 2i32 }
    };
}
```

**Before this PR**

Panic on apply

**After this PR**

Assist not applicable
---
 .../src/handlers/unmerge_match_arm.rs         | 26 ++++++++++++++++---
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_match_arm.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_match_arm.rs
index 7b0f2dc65a78..c4c03d3e35f5 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_match_arm.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_match_arm.rs
@@ -38,11 +38,18 @@ pub(crate) fn unmerge_match_arm(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
     }
     let match_arm = ast::MatchArm::cast(or_pat.syntax().parent()?)?;
     let match_arm_body = match_arm.expr()?;
+    let pats_after = pipe_token
+        .siblings_with_tokens(Direction::Next)
+        .filter_map(|it| ast::Pat::cast(it.into_node()?))
+        .collect::<Vec<_>>();
 
     // We don't need to check for leading pipe because it is directly under `MatchArm`
     // without `OrPat`.
 
     let new_parent = match_arm.syntax().parent()?;
+    if pats_after.is_empty() {
+        return None;
+    }
 
     acc.add(
         AssistId::refactor_rewrite("unmerge_match_arm"),
@@ -51,10 +58,6 @@ pub(crate) fn unmerge_match_arm(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
         |edit| {
             let make = SyntaxFactory::with_mappings();
             let mut editor = edit.make_editor(&new_parent);
-            let pats_after = pipe_token
-                .siblings_with_tokens(Direction::Next)
-                .filter_map(|it| ast::Pat::cast(it.into_node()?))
-                .collect::<Vec<_>>();
             // It is guaranteed that `pats_after` has at least one element
             let new_pat = if pats_after.len() == 1 {
                 pats_after[0].clone()
@@ -190,6 +193,21 @@ fn main() {
         );
     }
 
+    #[test]
+    fn unmerge_match_arm_trailing_pipe() {
+        check_assist_not_applicable(
+            unmerge_match_arm,
+            r#"
+fn main() {
+    let y = match 0 {
+        0 |$0 => { 1i32 }
+        1 => { 2i32 }
+    };
+}
+"#,
+        );
+    }
+
     #[test]
     fn unmerge_match_arm_multiple_pipes() {
         check_assist(

From 64ee85d511782d70d39626c5b9514108a0998295 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sun, 29 Mar 2026 01:02:48 -0400
Subject: [PATCH 1030/1059] update zulip link in `std` documentation

#docs doesn't seem to exist anymore, so point people to `t-libs`.
Also include direct link to topic since Zulip is world-viewable now.
---
 library/std/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index c8c8a6c89714..e831d7b46653 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -94,8 +94,8 @@
 //! pull-requests for your suggested changes.
 //!
 //! Contributions are appreciated! If you see a part of the docs that can be
-//! improved, submit a PR, or chat with us first on [Zulip][rust-zulip]
-//! #docs.
+//! improved, submit a PR, or chat with us first on [Zulip][t-libs-zulip]
+//! #t-libs.
 //!
 //! # A Tour of The Rust Standard Library
 //!
@@ -209,7 +209,7 @@
 //! [multithreading]: thread
 //! [other]: #what-is-in-the-standard-library-documentation
 //! [primitive types]: ../book/ch03-02-data-types.html
-//! [rust-zulip]: https://rust-lang.zulipchat.com/
+//! [t-libs-zulip]: https://rust-lang.zulipchat.com/#narrow/channel/219381-t-libs/
 //! [array]: prim@array
 //! [slice]: prim@slice
 

From 424dfe5544b77e239b995d2594d4bb445654e27e Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 29 Mar 2026 05:28:27 +0000
Subject: [PATCH 1031/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 148adf223edb0444eb1f99753919dd2080c2a534.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 68f38716dbb0..c98397c1c67f 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-1174f784096deb8e4ba93f7e4b5ccb7bb4ba2c55
+148adf223edb0444eb1f99753919dd2080c2a534

From 5bc280c0a97b235412ad43d5866284faca324c21 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 29 Mar 2026 05:37:03 +0000
Subject: [PATCH 1032/1059] fmt

---
 .../tests/pass/intrinsics/portable-simd.rs    | 20 +++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index 1e86c458ac21..f81f62e17602 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -134,13 +134,19 @@ macro_rules! assert_eq {
         assert_eq!(simd_reduce_min(b), -4.0f16);
 
         assert_eq!(
-            simd_maximum_number_nsz(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            simd_maximum_number_nsz(
+                f16x2::from_array([0.0, f16::NAN]),
+                f16x2::from_array([f16::NAN, 0.0])
+            ),
             f16x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_max(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
         assert_eq!(simd_reduce_max(f16x2::from_array([f16::NAN, 0.0])), 0.0f16);
         assert_eq!(
-            simd_minimum_number_nsz(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            simd_minimum_number_nsz(
+                f16x2::from_array([0.0, f16::NAN]),
+                f16x2::from_array([f16::NAN, 0.0])
+            ),
             f16x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_min(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
@@ -348,13 +354,19 @@ macro_rules! assert_eq {
         assert_eq!(simd_reduce_min(b), -4.0f128);
 
         assert_eq!(
-            simd_maximum_number_nsz(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            simd_maximum_number_nsz(
+                f128x2::from_array([0.0, f128::NAN]),
+                f128x2::from_array([f128::NAN, 0.0])
+            ),
             f128x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_max(f128x2::from_array([0.0, f128::NAN])), 0.0f128);
         assert_eq!(simd_reduce_max(f128x2::from_array([f128::NAN, 0.0])), 0.0f128);
         assert_eq!(
-            simd_minimum_number_nsz(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            simd_minimum_number_nsz(
+                f128x2::from_array([0.0, f128::NAN]),
+                f128x2::from_array([f128::NAN, 0.0])
+            ),
             f128x2::from_array([0.0, 0.0])
         );
         assert_eq!(simd_reduce_min(f128x2::from_array([0.0, f128::NAN])), 0.0f128);

From cbc94349d0ba20d6781cd3892794db55e630922a Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 27 Mar 2026 09:31:38 +0000
Subject: [PATCH 1033/1059] core: Destabilize beta-stable
 `RangeInclusiveIter::remainder`

As discussed, make this portion of the range API unstable again. This
will now be tracked under `new_range_remainder`.

Discussion: https://rust-lang.zulipchat.com/#narrow/channel/327149-t-libs-api.2Fapi-changes/topic/.60RangeFrom.3A.3Aremainder.60.20possible.20panic/with/582108913
---
 library/core/src/range/iter.rs            |  5 ++++-
 tests/ui/range/new_range_stability.rs     |  2 +-
 tests/ui/range/new_range_stability.stderr | 12 +++++++++++-
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs
index 0cddfff4022d..e2795ebaadad 100644
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -175,7 +175,10 @@ impl<A: Step> RangeInclusiveIter<A> {
     /// If the iterator is exhausted or empty, returns `None`.
     ///
     /// # Examples
+    ///
     /// ```
+    /// #![feature(new_range_remainder)]
+    ///
     /// let range = core::range::RangeInclusive::from(3..=11);
     /// let mut iter = range.into_iter();
     /// assert_eq!(iter.clone().remainder().unwrap(), range);
@@ -184,7 +187,7 @@ impl<A: Step> RangeInclusiveIter<A> {
     /// iter.by_ref().for_each(drop);
     /// assert!(iter.remainder().is_none());
     /// ```
-    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
     pub fn remainder(self) -> Option<RangeInclusive<A>> {
         if self.0.is_empty() {
             return None;
diff --git a/tests/ui/range/new_range_stability.rs b/tests/ui/range/new_range_stability.rs
index 0b2965ecba23..71a0f02e5896 100644
--- a/tests/ui/range/new_range_stability.rs
+++ b/tests/ui/range/new_range_stability.rs
@@ -19,7 +19,7 @@ fn range_inclusive(mut r: RangeInclusive<usize>) {
 
     let mut i = r.into_iter();
     i.next();
-    i.remainder();
+    i.remainder(); //~ ERROR unstable
 }
 
 fn range_to_inclusive(mut r: RangeToInclusive<usize>) {
diff --git a/tests/ui/range/new_range_stability.stderr b/tests/ui/range/new_range_stability.stderr
index 747c39d001eb..8a6dd5cac11e 100644
--- a/tests/ui/range/new_range_stability.stderr
+++ b/tests/ui/range/new_range_stability.stderr
@@ -28,6 +28,16 @@ LL | use std::range::RangeIter;
    = help: add `#![feature(new_range_api)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
+error[E0658]: use of unstable library feature `new_range_remainder`
+  --> $DIR/new_range_stability.rs:22:7
+   |
+LL |     i.remainder();
+   |       ^^^^^^^^^
+   |
+   = note: see issue #154458 <https://github.com/rust-lang/rust/issues/154458> for more information
+   = help: add `#![feature(new_range_remainder)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
 error[E0658]: use of unstable library feature `new_range_api`
   --> $DIR/new_range_stability.rs:43:7
    |
@@ -38,6 +48,6 @@ LL |     i.remainder();
    = help: add `#![feature(new_range_api)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0658`.

From 0bb3fe315e2130ce5229462d44ccc0ff09c41a4c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg@trevorgross.com>
Date: Fri, 27 Mar 2026 09:35:24 +0000
Subject: [PATCH 1034/1059] core: Move `{RangeIter, RangeFromIter}::remainder`
 to `new_range_remainder`

Split the remainder functions from the rest of `std::range`.
---
 library/core/src/range/iter.rs                        | 11 ++++++++---
 tests/codegen-llvm/fromrangeiter-overflow-checks.rs   |  1 +
 tests/ui/iterators/rangefrom-overflow-debug.rs        |  2 +-
 tests/ui/iterators/rangefrom-overflow-ndebug.rs       |  2 +-
 .../iterators/rangefrom-overflow-overflow-checks.rs   |  2 +-
 tests/ui/range/new_range_stability.stderr             |  6 +++---
 6 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs
index e2795ebaadad..c29b498bd25f 100644
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -11,12 +11,15 @@
 pub struct RangeIter<A>(legacy::Range<A>);
 
 impl<A> RangeIter<A> {
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
     /// Returns the remainder of the range being iterated over.
     ///
     /// # Examples
+    ///
     /// ```
     /// #![feature(new_range_api)]
+    /// #![feature(new_range_remainder)]
+    ///
     /// let range = core::range::Range::from(3..11);
     /// let mut iter = range.into_iter();
     /// assert_eq!(iter.clone().remainder(), range);
@@ -333,8 +336,10 @@ impl<A: Step> RangeFromIter<A> {
     /// Returns the remainder of the range being iterated over.
     ///
     /// # Examples
+    ///
     /// ```
-    /// #![feature(new_range_api)]
+    /// #![feature(new_range_remainder)]
+    ///
     /// let range = core::range::RangeFrom::from(3..);
     /// let mut iter = range.into_iter();
     /// assert_eq!(iter.clone().remainder(), range);
@@ -343,7 +348,7 @@ impl<A: Step> RangeFromIter<A> {
     /// ```
     #[inline]
     #[rustc_inherit_overflow_checks]
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
     pub fn remainder(self) -> RangeFrom<A> {
         // Need to handle this case even if overflow-checks are disabled,
         // because a `RangeFromIter` could be exhausted in a crate with
diff --git a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
index 0d640178f459..8662a6456c8b 100644
--- a/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
+++ b/tests/codegen-llvm/fromrangeiter-overflow-checks.rs
@@ -11,6 +11,7 @@
 
 #![crate_type = "lib"]
 #![feature(new_range_api)]
+#![feature(new_range_remainder)]
 
 use std::range::RangeFrom;
 
diff --git a/tests/ui/iterators/rangefrom-overflow-debug.rs b/tests/ui/iterators/rangefrom-overflow-debug.rs
index 9a1bc6910a04..7eafbadc62fb 100644
--- a/tests/ui/iterators/rangefrom-overflow-debug.rs
+++ b/tests/ui/iterators/rangefrom-overflow-debug.rs
@@ -2,7 +2,7 @@
 //@ needs-unwind
 //@ compile-flags: -O -C debug_assertions=yes
 
-#![feature(new_range_api)]
+#![feature(new_range_remainder)]
 
 use std::panic;
 
diff --git a/tests/ui/iterators/rangefrom-overflow-ndebug.rs b/tests/ui/iterators/rangefrom-overflow-ndebug.rs
index 4ce9b0636383..f1a6301c50d9 100644
--- a/tests/ui/iterators/rangefrom-overflow-ndebug.rs
+++ b/tests/ui/iterators/rangefrom-overflow-ndebug.rs
@@ -1,7 +1,7 @@
 //@ run-pass
 //@ compile-flags: -O -C debug_assertions=no
 
-#![feature(new_range_api)]
+#![feature(new_range_remainder)]
 
 fn main() {
     let mut it = core::range::RangeFrom::from(u8::MAX..).into_iter();
diff --git a/tests/ui/iterators/rangefrom-overflow-overflow-checks.rs b/tests/ui/iterators/rangefrom-overflow-overflow-checks.rs
index 7e3b0fc30840..af432afacabb 100644
--- a/tests/ui/iterators/rangefrom-overflow-overflow-checks.rs
+++ b/tests/ui/iterators/rangefrom-overflow-overflow-checks.rs
@@ -2,7 +2,7 @@
 //@ needs-unwind
 //@ compile-flags: -O -C overflow-checks=yes
 
-#![feature(new_range_api)]
+#![feature(new_range_remainder)]
 
 use std::panic;
 
diff --git a/tests/ui/range/new_range_stability.stderr b/tests/ui/range/new_range_stability.stderr
index 8a6dd5cac11e..64ef6a416687 100644
--- a/tests/ui/range/new_range_stability.stderr
+++ b/tests/ui/range/new_range_stability.stderr
@@ -38,14 +38,14 @@ LL |     i.remainder();
    = help: add `#![feature(new_range_remainder)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: use of unstable library feature `new_range_api`
+error[E0658]: use of unstable library feature `new_range_remainder`
   --> $DIR/new_range_stability.rs:43:7
    |
 LL |     i.remainder();
    |       ^^^^^^^^^
    |
-   = note: see issue #125687 <https://github.com/rust-lang/rust/issues/125687> for more information
-   = help: add `#![feature(new_range_api)]` to the crate attributes to enable
+   = note: see issue #154458 <https://github.com/rust-lang/rust/issues/154458> for more information
+   = help: add `#![feature(new_range_remainder)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 5 previous errors

From 69b6d26d05006dca7556abc555fb0e029ecf1f4e Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sun, 29 Mar 2026 16:23:14 +0800
Subject: [PATCH 1035/1059] fix invalid type suggestion for item nested in
 function

---
 .../rustc_hir_analysis/src/collect/type_of.rs   |  4 ++--
 compiler/rustc_middle/src/ty/print/mod.rs       | 17 +++++++++++++++--
 compiler/rustc_middle/src/ty/print/pretty.rs    | 13 +++++++++++++
 ...ocal-item-type-suggestion-issue-146786.fixed | 11 +++++++++++
 ...n-local-item-type-suggestion-issue-146786.rs | 11 +++++++++++
 ...cal-item-type-suggestion-issue-146786.stderr |  8 ++++++++
 6 files changed, 60 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.fixed
 create mode 100644 tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.rs
 create mode 100644 tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.stderr

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index f2ae5c1f928d..e65efd6880b8 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -4,7 +4,7 @@
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::{self as hir, AmbigArg, HirId};
-use rustc_middle::ty::print::with_forced_trimmed_paths;
+use rustc_middle::ty::print::{with_forced_trimmed_paths, with_types_for_suggestion};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, DefiningScopeKind, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
@@ -451,7 +451,7 @@ fn infer_placeholder_type<'tcx>(
                     err.span_suggestion(
                         ty_span,
                         format!("provide a type for the {kind}"),
-                        format!("{colon} {ty}"),
+                        with_types_for_suggestion!(format!("{colon} {ty}")),
                         Applicability::MachineApplicable,
                     );
                 } else {
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index 0fd68e74e044..20e40dd6b2fe 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -133,8 +133,15 @@ fn print_coroutine_with_kind(
         self.print_path_with_generic_args(|p| p.print_def_path(def_id, parent_args), &[kind.into()])
     }
 
-    // Defaults (should not be overridden):
+    fn reset_path(&mut self) -> Result<(), PrintError> {
+        Ok(())
+    }
 
+    fn should_omit_parent_def_path(&self, _parent_def_id: DefId) -> bool {
+        false
+    }
+
+    // Defaults (should not be overridden):
     #[instrument(skip(self), level = "debug")]
     fn default_print_def_path(
         &mut self,
@@ -210,9 +217,15 @@ fn default_print_def_path(
                         && self.tcx().generics_of(parent_def_id).parent_count == 0;
                 }
 
+                let omit_parent = matches!(key.disambiguated_data.data, DefPathData::TypeNs(..))
+                    && self.should_omit_parent_def_path(parent_def_id);
+
                 self.print_path_with_simple(
                     |p: &mut Self| {
-                        if trait_qualify_parent {
+                        if omit_parent {
+                            p.reset_path()?;
+                            Ok(())
+                        } else if trait_qualify_parent {
                             let trait_ref = ty::TraitRef::new(
                                 p.tcx(),
                                 parent_def_id,
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 2c14c37609d4..b196327763f0 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2224,6 +2224,19 @@ fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
         self.tcx
     }
 
+    fn reset_path(&mut self) -> Result<(), PrintError> {
+        self.empty_path = true;
+        Ok(())
+    }
+
+    fn should_omit_parent_def_path(&self, parent_def_id: DefId) -> bool {
+        RTN_MODE.with(|mode| mode.get()) == RtnMode::ForSuggestion
+            && matches!(
+                self.tcx().def_key(parent_def_id).disambiguated_data.data,
+                DefPathData::ValueNs(..) | DefPathData::Closure | DefPathData::AnonConst
+            )
+    }
+
     fn print_def_path(
         &mut self,
         def_id: DefId,
diff --git a/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.fixed b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.fixed
new file mode 100644
index 000000000000..50beced2940b
--- /dev/null
+++ b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.fixed
@@ -0,0 +1,11 @@
+//@ run-rustfix
+#![allow(dead_code)]
+
+fn main() {
+    struct Error;
+
+    const ERROR: Error = Error;
+    //~^ ERROR missing type for `const` item
+    //~| HELP provide a type for the constant
+    //~| SUGGESTION : Error
+}
diff --git a/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.rs b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.rs
new file mode 100644
index 000000000000..f3c4aed435da
--- /dev/null
+++ b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.rs
@@ -0,0 +1,11 @@
+//@ run-rustfix
+#![allow(dead_code)]
+
+fn main() {
+    struct Error;
+
+    const ERROR = Error;
+    //~^ ERROR missing type for `const` item
+    //~| HELP provide a type for the constant
+    //~| SUGGESTION : Error
+}
diff --git a/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.stderr b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.stderr
new file mode 100644
index 000000000000..4111f9d35306
--- /dev/null
+++ b/tests/ui/suggestions/function-local-item-type-suggestion-issue-146786.stderr
@@ -0,0 +1,8 @@
+error: missing type for `const` item
+  --> $DIR/function-local-item-type-suggestion-issue-146786.rs:7:16
+   |
+LL |     const ERROR = Error;
+   |                ^ help: provide a type for the constant: `: Error`
+
+error: aborting due to 1 previous error
+

From de6826beff7cbfc52be0f1efecea6449e2df295d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Sun, 29 Mar 2026 11:12:27 +0200
Subject: [PATCH 1036/1059] fix: Fix block lowering in ast id map

---
 src/tools/rust-analyzer/crates/span/src/ast_id.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/span/src/ast_id.rs b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
index bae461e5a8de..f6500a9b4dbe 100644
--- a/src/tools/rust-analyzer/crates/span/src/ast_id.rs
+++ b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
@@ -678,9 +678,10 @@ pub fn from_source(node: &SyntaxNode) -> AstIdMap {
                             }
                         }
                         syntax::WalkEvent::Leave(node) => {
-                            if cfg!(debug_assertions) && ast::BlockExpr::can_cast(node.kind()) {
-                                assert_eq!(
-                                    blocks.pop().map(|it| it.0),
+                            if ast::BlockExpr::can_cast(node.kind()) {
+                                let block = blocks.pop();
+                                debug_assert_eq!(
+                                    block.map(|it| it.0),
                                     Some(node),
                                     "left a BlockExpr we never entered"
                                 );

From 5bbdfb078d206282b75386530fe650749a76785d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 29 Mar 2026 12:56:05 +0200
Subject: [PATCH 1037/1059] use 'flag subtraction' pattern for 'open'

---
 src/tools/miri/src/shims/unix/fs.rs | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 9873af85b989..5adc5932883e 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -364,6 +364,9 @@ fn open(
             this.machine.emit_diagnostic(NonHaltingDiagnostic::FileInProcOpened);
         }
 
+        // We will "subtract" supported flags from this and at the end check that no bits are left.
+        let mut flag = flag;
+
         let mut options = OpenOptions::new();
 
         let o_rdonly = this.eval_libc_i32("O_RDONLY");
@@ -379,6 +382,7 @@ fn open(
 
         // Now we check the access mode
         let access_mode = flag & 0b11;
+        flag &= !access_mode;
 
         if access_mode == o_rdonly {
             writable = false;
@@ -390,23 +394,20 @@ fn open(
         } else {
             throw_unsup_format!("unsupported access mode {:#x}", access_mode);
         }
-        // We need to check that there aren't unsupported options in `flag`. For this we try to
-        // reproduce the content of `flag` in the `mirror` variable using only the supported
-        // options.
-        let mut mirror = access_mode;
 
         let o_append = this.eval_libc_i32("O_APPEND");
         if flag & o_append == o_append {
+            flag &= !o_append;
             options.append(true);
-            mirror |= o_append;
         }
         let o_trunc = this.eval_libc_i32("O_TRUNC");
         if flag & o_trunc == o_trunc {
+            flag &= !o_trunc;
             options.truncate(true);
-            mirror |= o_trunc;
         }
         let o_creat = this.eval_libc_i32("O_CREAT");
         if flag & o_creat == o_creat {
+            flag &= !o_creat;
             // Get the mode.  On macOS, the argument type `mode_t` is actually `u16`, but
             // C integer promotion rules mean that on the ABI level, it gets passed as `u32`
             // (see https://github.com/rust-lang/rust/issues/71915).
@@ -430,11 +431,9 @@ fn open(
                 }
             }
 
-            mirror |= o_creat;
-
             let o_excl = this.eval_libc_i32("O_EXCL");
             if flag & o_excl == o_excl {
-                mirror |= o_excl;
+                flag &= !o_excl;
                 options.create_new(true);
             } else {
                 options.create(true);
@@ -442,9 +441,9 @@ fn open(
         }
         let o_cloexec = this.eval_libc_i32("O_CLOEXEC");
         if flag & o_cloexec == o_cloexec {
+            flag &= !o_cloexec;
             // We do not need to do anything for this flag because `std` already sets it.
             // (Technically we do not support *not* setting this flag, but we ignore that.)
-            mirror |= o_cloexec;
         }
         if this.tcx.sess.target.os == Os::Linux {
             let o_tmpfile = this.eval_libc_i32("O_TMPFILE");
@@ -456,6 +455,7 @@ fn open(
 
         let o_nofollow = this.eval_libc_i32("O_NOFOLLOW");
         if flag & o_nofollow == o_nofollow {
+            flag &= !o_nofollow;
             #[cfg(unix)]
             {
                 use std::os::unix::fs::OpenOptionsExt;
@@ -472,13 +472,11 @@ fn open(
                     return this.set_last_error_and_return_i32(LibcError("ELOOP"));
                 }
             }
-            mirror |= o_nofollow;
         }
 
-        // If `flag` is not equal to `mirror`, there is an unsupported option enabled in `flag`,
-        // then we throw an error.
-        if flag != mirror {
-            throw_unsup_format!("unsupported flags {:#x}", flag & !mirror);
+        // If `flag` has any bits left set, those are not supported.
+        if flag != 0 {
+            throw_unsup_format!("unsupported flags {:#x}", flag);
         }
 
         // Reject if isolation is enabled.

From 684bff70b5ed1e4921773251b072812fb9a002cb Mon Sep 17 00:00:00 2001
From: aditya <189266166+Bougerous@users.noreply.github.com>
Date: Fri, 13 Mar 2026 08:59:56 +0530
Subject: [PATCH 1038/1059] Add aarch64 CRC32 intrinsic shims

Implement shims for the 8 aarch64 CRC32 LLVM intrinsics:
- crc32b/h/w/x (standard CRC-32, polynomial 0x104C11DB7)
- crc32cb/ch/cw/cx (CRC-32C/Castagnoli, polynomial 0x11EDC6F41)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/tools/miri/src/shims/aarch64.rs           | 43 +++++++++++++
 src/tools/miri/src/shims/mod.rs               |  1 +
 src/tools/miri/src/shims/simd/math.rs         | 41 +++++++++++++
 src/tools/miri/src/shims/simd/mod.rs          |  1 +
 src/tools/miri/src/shims/x86/sse42.rs         | 46 ++++----------
 .../shims/aarch64/intrinsics-aarch64-crc32.rs | 61 +++++++++++++++++++
 6 files changed, 158 insertions(+), 35 deletions(-)
 create mode 100644 src/tools/miri/src/shims/simd/math.rs
 create mode 100644 src/tools/miri/src/shims/simd/mod.rs
 create mode 100644 src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-crc32.rs

diff --git a/src/tools/miri/src/shims/aarch64.rs b/src/tools/miri/src/shims/aarch64.rs
index d06b02a41334..7138ec3d122b 100644
--- a/src/tools/miri/src/shims/aarch64.rs
+++ b/src/tools/miri/src/shims/aarch64.rs
@@ -85,6 +85,49 @@ fn emulate_aarch64_intrinsic(
                     this.write_scalar(val, &this.project_index(&dest, i)?)?;
                 }
             }
+            // Used to implement the __crc32{b,h,w,x} and __crc32c{b,h,w,x} functions.
+            // Polynomial 0x04C11DB7 (standard CRC-32):
+            // https://developer.arm.com/documentation/ddi0602/latest/Base-Instructions/CRC32B--CRC32H--CRC32W--CRC32X--CRC32-checksum-
+            // Polynomial 0x1EDC6F41 (CRC-32C / Castagnoli):
+            // https://developer.arm.com/documentation/ddi0602/latest/Base-Instructions/CRC32CB--CRC32CH--CRC32CW--CRC32CX--CRC32C-checksum-
+            "crc32b" | "crc32h" | "crc32w" | "crc32x" | "crc32cb" | "crc32ch" | "crc32cw"
+            | "crc32cx" => {
+                this.expect_target_feature_for_intrinsic(link_name, "crc")?;
+                // The polynomial constants below include the leading 1 bit
+                // (e.g. 0x104C11DB7 instead of 0x04C11DB7) which the ARM docs
+                // omit but the polynomial division algorithm requires.
+                let (bit_size, polynomial): (u32, u128) = match unprefixed_name {
+                    "crc32b" => (8, 0x104C11DB7),
+                    "crc32h" => (16, 0x104C11DB7),
+                    "crc32w" => (32, 0x104C11DB7),
+                    "crc32x" => (64, 0x104C11DB7),
+                    "crc32cb" => (8, 0x11EDC6F41),
+                    "crc32ch" => (16, 0x11EDC6F41),
+                    "crc32cw" => (32, 0x11EDC6F41),
+                    "crc32cx" => (64, 0x11EDC6F41),
+                    _ => unreachable!(),
+                };
+
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let left = this.read_scalar(left)?;
+                let right = this.read_scalar(right)?;
+
+                // The CRC accumulator is always u32. The data argument is u32 for
+                // b/h/w variants and u64 for the x variant, per the LLVM intrinsic
+                // definitions (all b/h/w take i32, only x takes i64).
+                // https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/IR/IntrinsicsAArch64.td
+                // For b/h, the Rust std::arch wrappers accept u8/u16 and zero-extend
+                // to i32 before calling the LLVM intrinsic, so the upper bits of the
+                // i32 are always zero. compute_crc32 only uses the low `bit_size` bits.
+                let crc = left.to_u32()?;
+                let data =
+                    if bit_size == 64 { right.to_u64()? } else { u64::from(right.to_u32()?) };
+
+                let result =
+                    crate::shims::simd::math::compute_crc32(crc, data, bit_size, polynomial);
+                this.write_scalar(Scalar::from_u32(result), dest)?;
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 281dfc758f4e..09a00363cfda 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -7,6 +7,7 @@
 mod math;
 #[cfg(all(feature = "native-lib", unix))]
 pub mod native_lib;
+mod simd;
 mod unix;
 mod windows;
 mod x86;
diff --git a/src/tools/miri/src/shims/simd/math.rs b/src/tools/miri/src/shims/simd/math.rs
new file mode 100644
index 000000000000..5ba32eedc3be
--- /dev/null
+++ b/src/tools/miri/src/shims/simd/math.rs
@@ -0,0 +1,41 @@
+/// Compute a CRC32 checksum using the given polynomial.
+///
+/// `bit_size` is the number of relevant data bits (8, 16, 32, or 64).
+/// Only the low `bit_size` bits of `data` are used; higher bits are ignored.
+/// `polynomial` includes the leading 1 bit (e.g. `0x11EDC6F41` for CRC32C).
+#[expect(clippy::arithmetic_side_effects)]
+pub(crate) fn compute_crc32(crc: u32, data: u64, bit_size: u32, polynomial: u128) -> u32 {
+    // Bit-reverse inputs to match hardware CRC conventions.
+    let crc = u128::from(crc.reverse_bits());
+    // Reverse all 64 bits of `data`, then shift right by `64 - bit_size`. This
+    // discards the (now-reversed) higher bits, leaving only the reversed low
+    // `bit_size` bits in the lowest positions (with zeros above).
+    let v = u128::from(data.reverse_bits() >> (64 - bit_size));
+
+    // Perform polynomial division modulo 2.
+    // The algorithm for the division is an adapted version of the
+    // schoolbook division algorithm used for normal integer or polynomial
+    // division. In this context, the quotient is not calculated, since
+    // only the remainder is needed.
+    //
+    // The algorithm works as follows:
+    // 1. Pull down digits until division can be performed. In the context of division
+    //    modulo 2 it means locating the most significant digit of the dividend and shifting
+    //    the divisor such that the position of the divisors most significand digit and the
+    //    dividends most significand digit match.
+    // 2. Perform a division and determine the remainder. Since it is arithmetic modulo 2,
+    //    this operation is a simple bitwise exclusive or.
+    // 3. Repeat steps 1. and 2. until the full remainder is calculated. This is the case
+    //    once the degree of the remainder polynomial is smaller than the degree of the
+    //    divisor polynomial. In other words, the number of leading zeros of the remainder
+    //    is larger than the number of leading zeros of the divisor. It is important to
+    //    note that standard arithmetic comparison is not applicable here:
+    //    0b10011 / 0b11111 = 0b01100 is a valid division, even though the dividend is
+    //    smaller than the divisor.
+    let mut dividend = (crc << bit_size) ^ (v << 32);
+    while dividend.leading_zeros() <= polynomial.leading_zeros() {
+        dividend ^= (polynomial << polynomial.leading_zeros()) >> dividend.leading_zeros();
+    }
+
+    u32::try_from(dividend).unwrap().reverse_bits()
+}
diff --git a/src/tools/miri/src/shims/simd/mod.rs b/src/tools/miri/src/shims/simd/mod.rs
new file mode 100644
index 000000000000..0c937aa8d935
--- /dev/null
+++ b/src/tools/miri/src/shims/simd/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod math;
diff --git a/src/tools/miri/src/shims/x86/sse42.rs b/src/tools/miri/src/shims/x86/sse42.rs
index 7c0f9c570e2e..c7a43427ca88 100644
--- a/src/tools/miri/src/shims/x86/sse42.rs
+++ b/src/tools/miri/src/shims/x86/sse42.rs
@@ -5,6 +5,7 @@
 use rustc_target::callconv::FnAbi;
 use rustc_target::spec::Arch;
 
+use crate::shims::simd::math::compute_crc32;
 use crate::*;
 
 /// A bitmask constant for scrutinizing the immediate byte provided
@@ -445,46 +446,21 @@ fn emulate_x86_sse42_intrinsic(
                     // The 64-bit version will only consider the lower 32 bits,
                     // while the upper 32 bits get discarded.
                     #[expect(clippy::as_conversions)]
-                    u128::from((left.to_u64()? as u32).reverse_bits())
+                    {
+                        left.to_u64()? as u32
+                    }
                 } else {
-                    u128::from(left.to_u32()?.reverse_bits())
+                    left.to_u32()?
                 };
-                let v = match bit_size {
-                    8 => u128::from(right.to_u8()?.reverse_bits()),
-                    16 => u128::from(right.to_u16()?.reverse_bits()),
-                    32 => u128::from(right.to_u32()?.reverse_bits()),
-                    64 => u128::from(right.to_u64()?.reverse_bits()),
+                let data = match bit_size {
+                    8 => u64::from(right.to_u8()?),
+                    16 => u64::from(right.to_u16()?),
+                    32 => u64::from(right.to_u32()?),
+                    64 => right.to_u64()?,
                     _ => unreachable!(),
                 };
 
-                // Perform polynomial division modulo 2.
-                // The algorithm for the division is an adapted version of the
-                // schoolbook division algorithm used for normal integer or polynomial
-                // division. In this context, the quotient is not calculated, since
-                // only the remainder is needed.
-                //
-                // The algorithm works as follows:
-                // 1. Pull down digits until division can be performed. In the context of division
-                //    modulo 2 it means locating the most significant digit of the dividend and shifting
-                //    the divisor such that the position of the divisors most significand digit and the
-                //    dividends most significand digit match.
-                // 2. Perform a division and determine the remainder. Since it is arithmetic modulo 2,
-                //    this operation is a simple bitwise exclusive or.
-                // 3. Repeat steps 1. and 2. until the full remainder is calculated. This is the case
-                //    once the degree of the remainder polynomial is smaller than the degree of the
-                //    divisor polynomial. In other words, the number of leading zeros of the remainder
-                //    is larger than the number of leading zeros of the divisor. It is important to
-                //    note that standard arithmetic comparison is not applicable here:
-                //    0b10011 / 0b11111 = 0b01100 is a valid division, even though the dividend is
-                //    smaller than the divisor.
-                let mut dividend = (crc << bit_size) ^ (v << 32);
-                const POLYNOMIAL: u128 = 0x11EDC6F41;
-                while dividend.leading_zeros() <= POLYNOMIAL.leading_zeros() {
-                    dividend ^=
-                        (POLYNOMIAL << POLYNOMIAL.leading_zeros()) >> dividend.leading_zeros();
-                }
-
-                let result = u32::try_from(dividend).unwrap().reverse_bits();
+                let result = compute_crc32(crc, data, bit_size, 0x11EDC6F41);
                 let result = if bit_size == 64 {
                     Scalar::from_u64(u64::from(result))
                 } else {
diff --git a/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-crc32.rs b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-crc32.rs
new file mode 100644
index 000000000000..849f99ee36cc
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-crc32.rs
@@ -0,0 +1,61 @@
+// We're testing aarch64 CRC32 target specific features
+//@only-target: aarch64
+//@compile-flags: -C target-feature=+crc
+
+use std::arch::aarch64::*;
+use std::arch::is_aarch64_feature_detected;
+
+fn main() {
+    assert!(is_aarch64_feature_detected!("crc"));
+
+    unsafe {
+        test_crc32_standard();
+        test_crc32c_castagnoli();
+    }
+}
+
+#[target_feature(enable = "crc")]
+unsafe fn test_crc32_standard() {
+    // __crc32b: 8-bit input
+    assert_eq!(__crc32b(0x00000000, 0x01), 0x77073096);
+    assert_eq!(__crc32b(0xffffffff, 0x61), 0x174841bc);
+    assert_eq!(__crc32b(0x2aa1e72b, 0x2a), 0x772d9171);
+
+    // __crc32h: 16-bit input
+    assert_eq!(__crc32h(0x00000000, 0x0001), 0x191b3141);
+    assert_eq!(__crc32h(0xffffffff, 0x1234), 0xf6b56fbf);
+    assert_eq!(__crc32h(0x8ecec3b5, 0x022b), 0x03a1db7c);
+
+    // __crc32w: 32-bit input
+    assert_eq!(__crc32w(0x00000000, 0x00000001), 0xb8bc6765);
+    assert_eq!(__crc32w(0xffffffff, 0x12345678), 0x5092782d);
+    assert_eq!(__crc32w(0xae2912c8, 0x00845fed), 0xc5690dd4);
+
+    // __crc32d: 64-bit input
+    assert_eq!(__crc32d(0x00000000, 0x0000000000000001), 0xccaa009e);
+    assert_eq!(__crc32d(0xffffffff, 0x123456789abcdef0), 0xe6ddf8b5);
+    assert_eq!(__crc32d(0x0badeafe, 0xc0febeefdadafefe), 0x61a45fba);
+}
+
+#[target_feature(enable = "crc")]
+unsafe fn test_crc32c_castagnoli() {
+    // __crc32cb: 8-bit input
+    assert_eq!(__crc32cb(0x00000000, 0x01), 0xf26b8303);
+    assert_eq!(__crc32cb(0xffffffff, 0x61), 0x3e2fbccf);
+    assert_eq!(__crc32cb(0x2aa1e72b, 0x2a), 0xf24122e4);
+
+    // __crc32ch: 16-bit input
+    assert_eq!(__crc32ch(0x00000000, 0x0001), 0x13a29877);
+    assert_eq!(__crc32ch(0xffffffff, 0x1234), 0xf13f4cea);
+    assert_eq!(__crc32ch(0x8ecec3b5, 0x022b), 0x013bb2fb);
+
+    // __crc32cw: 32-bit input
+    assert_eq!(__crc32cw(0x00000000, 0x00000001), 0xdd45aab8);
+    assert_eq!(__crc32cw(0xffffffff, 0x12345678), 0x4dece20c);
+    assert_eq!(__crc32cw(0xae2912c8, 0x00845fed), 0xffae2ed1);
+
+    // __crc32cd: 64-bit input
+    assert_eq!(__crc32cd(0x00000000, 0x0000000000000001), 0x493c7d27);
+    assert_eq!(__crc32cd(0xffffffff, 0x123456789abcdef0), 0xd95b664b);
+    assert_eq!(__crc32cd(0x0badeafe, 0xc0febeefdadafefe), 0x5b44f54f);
+}

From 59f15fbbb8caa60cf8ba32d065fc294be33fbc73 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Mar 2026 21:02:23 +0100
Subject: [PATCH 1039/1059] minor tweaks

---
 src/tools/miri/src/shims/aarch64.rs   |  9 +++--
 src/tools/miri/src/shims/math.rs      | 48 +++++++++++++++++++++++++++
 src/tools/miri/src/shims/mod.rs       |  1 -
 src/tools/miri/src/shims/simd/math.rs | 41 -----------------------
 src/tools/miri/src/shims/simd/mod.rs  |  1 -
 src/tools/miri/src/shims/x86/sse42.rs |  6 ++--
 6 files changed, 54 insertions(+), 52 deletions(-)
 delete mode 100644 src/tools/miri/src/shims/simd/math.rs
 delete mode 100644 src/tools/miri/src/shims/simd/mod.rs

diff --git a/src/tools/miri/src/shims/aarch64.rs b/src/tools/miri/src/shims/aarch64.rs
index 7138ec3d122b..b96d1b1a38dd 100644
--- a/src/tools/miri/src/shims/aarch64.rs
+++ b/src/tools/miri/src/shims/aarch64.rs
@@ -4,6 +4,7 @@
 use rustc_span::Symbol;
 use rustc_target::callconv::FnAbi;
 
+use crate::shims::math::compute_crc32;
 use crate::*;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -117,15 +118,13 @@ fn emulate_aarch64_intrinsic(
                 // b/h/w variants and u64 for the x variant, per the LLVM intrinsic
                 // definitions (all b/h/w take i32, only x takes i64).
                 // https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/IR/IntrinsicsAArch64.td
-                // For b/h, the Rust std::arch wrappers accept u8/u16 and zero-extend
-                // to i32 before calling the LLVM intrinsic, so the upper bits of the
-                // i32 are always zero. compute_crc32 only uses the low `bit_size` bits.
+                // If the higher bits are non-zero, `compute_crc32` will panic. We should probably
+                // raise a proper error instead, but outside stdarch nobody can trigger this anyway.
                 let crc = left.to_u32()?;
                 let data =
                     if bit_size == 64 { right.to_u64()? } else { u64::from(right.to_u32()?) };
 
-                let result =
-                    crate::shims::simd::math::compute_crc32(crc, data, bit_size, polynomial);
+                let result = compute_crc32(crc, data, bit_size, polynomial);
                 this.write_scalar(Scalar::from_u32(result), dest)?;
             }
             _ => return interp_ok(EmulateItemResult::NotSupported),
diff --git a/src/tools/miri/src/shims/math.rs b/src/tools/miri/src/shims/math.rs
index ef185aa2a3e9..1da7fbbdac0c 100644
--- a/src/tools/miri/src/shims/math.rs
+++ b/src/tools/miri/src/shims/math.rs
@@ -245,3 +245,51 @@ fn emulate_foreign_item_inner(
         interp_ok(EmulateItemResult::NeedsReturn)
     }
 }
+
+/// Compute a CRC32 checksum using the given polynomial.
+///
+/// `bit_size` is the number of relevant data bits (8, 16, 32, or 64).
+/// Only the low `bit_size` bits of `data` are used; higher bits must be zero.
+/// `polynomial` includes the leading 1 bit (e.g. `0x11EDC6F41` for CRC32C).
+///
+/// Following hardware CRC conventions, `crc` and `data` bits are assumed to be reversed,
+/// and output bits will be equally reversed.
+pub(crate) fn compute_crc32(crc: u32, data: u64, bit_size: u32, polynomial: u128) -> u32 {
+    assert!(
+        bit_size == 64 || data < 1u64.strict_shl(bit_size),
+        "crc32: `data` is larger than {bit_size} bits"
+    );
+    // Bit-reverse inputs to match hardware CRC conventions.
+    let crc = u128::from(crc.reverse_bits());
+    // Reverse all 64 bits of `data`, then shift right by `64 - bit_size`. This
+    // discards the (now-reversed) higher bits, leaving only the reversed low
+    // `bit_size` bits in the lowest positions (with zeros above).
+    let v = u128::from(data.reverse_bits() >> (64u32.strict_sub(bit_size)));
+
+    // Perform polynomial division modulo 2.
+    // The algorithm for the division is an adapted version of the
+    // schoolbook division algorithm used for normal integer or polynomial
+    // division. In this context, the quotient is not calculated, since
+    // only the remainder is needed.
+    //
+    // The algorithm works as follows:
+    // 1. Pull down digits until division can be performed. In the context of division
+    //    modulo 2 it means locating the most significant digit of the dividend and shifting
+    //    the divisor such that the position of the divisors most significand digit and the
+    //    dividends most significand digit match.
+    // 2. Perform a division and determine the remainder. Since it is arithmetic modulo 2,
+    //    this operation is a simple bitwise exclusive or.
+    // 3. Repeat steps 1. and 2. until the full remainder is calculated. This is the case
+    //    once the degree of the remainder polynomial is smaller than the degree of the
+    //    divisor polynomial. In other words, the number of leading zeros of the remainder
+    //    is larger than the number of leading zeros of the divisor. It is important to
+    //    note that standard arithmetic comparison is not applicable here:
+    //    0b10011 / 0b11111 = 0b01100 is a valid division, even though the dividend is
+    //    smaller than the divisor.
+    let mut dividend = (crc << bit_size) ^ (v << 32);
+    while dividend.leading_zeros() <= polynomial.leading_zeros() {
+        dividend ^= (polynomial << polynomial.leading_zeros()) >> dividend.leading_zeros();
+    }
+
+    u32::try_from(dividend).unwrap().reverse_bits()
+}
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 09a00363cfda..281dfc758f4e 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -7,7 +7,6 @@
 mod math;
 #[cfg(all(feature = "native-lib", unix))]
 pub mod native_lib;
-mod simd;
 mod unix;
 mod windows;
 mod x86;
diff --git a/src/tools/miri/src/shims/simd/math.rs b/src/tools/miri/src/shims/simd/math.rs
deleted file mode 100644
index 5ba32eedc3be..000000000000
--- a/src/tools/miri/src/shims/simd/math.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-/// Compute a CRC32 checksum using the given polynomial.
-///
-/// `bit_size` is the number of relevant data bits (8, 16, 32, or 64).
-/// Only the low `bit_size` bits of `data` are used; higher bits are ignored.
-/// `polynomial` includes the leading 1 bit (e.g. `0x11EDC6F41` for CRC32C).
-#[expect(clippy::arithmetic_side_effects)]
-pub(crate) fn compute_crc32(crc: u32, data: u64, bit_size: u32, polynomial: u128) -> u32 {
-    // Bit-reverse inputs to match hardware CRC conventions.
-    let crc = u128::from(crc.reverse_bits());
-    // Reverse all 64 bits of `data`, then shift right by `64 - bit_size`. This
-    // discards the (now-reversed) higher bits, leaving only the reversed low
-    // `bit_size` bits in the lowest positions (with zeros above).
-    let v = u128::from(data.reverse_bits() >> (64 - bit_size));
-
-    // Perform polynomial division modulo 2.
-    // The algorithm for the division is an adapted version of the
-    // schoolbook division algorithm used for normal integer or polynomial
-    // division. In this context, the quotient is not calculated, since
-    // only the remainder is needed.
-    //
-    // The algorithm works as follows:
-    // 1. Pull down digits until division can be performed. In the context of division
-    //    modulo 2 it means locating the most significant digit of the dividend and shifting
-    //    the divisor such that the position of the divisors most significand digit and the
-    //    dividends most significand digit match.
-    // 2. Perform a division and determine the remainder. Since it is arithmetic modulo 2,
-    //    this operation is a simple bitwise exclusive or.
-    // 3. Repeat steps 1. and 2. until the full remainder is calculated. This is the case
-    //    once the degree of the remainder polynomial is smaller than the degree of the
-    //    divisor polynomial. In other words, the number of leading zeros of the remainder
-    //    is larger than the number of leading zeros of the divisor. It is important to
-    //    note that standard arithmetic comparison is not applicable here:
-    //    0b10011 / 0b11111 = 0b01100 is a valid division, even though the dividend is
-    //    smaller than the divisor.
-    let mut dividend = (crc << bit_size) ^ (v << 32);
-    while dividend.leading_zeros() <= polynomial.leading_zeros() {
-        dividend ^= (polynomial << polynomial.leading_zeros()) >> dividend.leading_zeros();
-    }
-
-    u32::try_from(dividend).unwrap().reverse_bits()
-}
diff --git a/src/tools/miri/src/shims/simd/mod.rs b/src/tools/miri/src/shims/simd/mod.rs
deleted file mode 100644
index 0c937aa8d935..000000000000
--- a/src/tools/miri/src/shims/simd/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod math;
diff --git a/src/tools/miri/src/shims/x86/sse42.rs b/src/tools/miri/src/shims/x86/sse42.rs
index c7a43427ca88..6b0e6726e8f7 100644
--- a/src/tools/miri/src/shims/x86/sse42.rs
+++ b/src/tools/miri/src/shims/x86/sse42.rs
@@ -5,7 +5,7 @@
 use rustc_target::callconv::FnAbi;
 use rustc_target::spec::Arch;
 
-use crate::shims::simd::math::compute_crc32;
+use crate::shims::math::compute_crc32;
 use crate::*;
 
 /// A bitmask constant for scrutinizing the immediate byte provided
@@ -446,9 +446,7 @@ fn emulate_x86_sse42_intrinsic(
                     // The 64-bit version will only consider the lower 32 bits,
                     // while the upper 32 bits get discarded.
                     #[expect(clippy::as_conversions)]
-                    {
-                        left.to_u64()? as u32
-                    }
+                    (left.to_u64()? as u32)
                 } else {
                     left.to_u32()?
                 };

From 51816efcc02d36d6f4c1a9149f655869ee6bc58d Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Wed, 18 Mar 2026 20:06:02 -0700
Subject: [PATCH 1040/1059] don't drop arguments' temporaries in `dbg!`

---
 library/std/src/macros.rs                     | 82 ++++++++++---------
 library/std/src/macros/tests.rs               | 13 +++
 .../clippy/clippy_lints/src/dbg_macro.rs      | 47 ++---------
 .../dangling_primitive.stderr                 |  2 +-
 .../return_pointer_on_unwind.stderr           |  2 +-
 tests/ui/borrowck/dbg-issue-120327.stderr     | 40 ++++-----
 tests/ui/liveness/liveness-upvars.rs          |  2 +-
 tests/ui/liveness/liveness-upvars.stderr      | 10 ++-
 .../dbg-macro-move-semantics.stderr           | 16 ++--
 9 files changed, 103 insertions(+), 111 deletions(-)
 create mode 100644 library/std/src/macros/tests.rs

diff --git a/library/std/src/macros.rs b/library/std/src/macros.rs
index 0bb14552432d..5f9b383c2da3 100644
--- a/library/std/src/macros.rs
+++ b/library/std/src/macros.rs
@@ -5,6 +5,9 @@
 //! library.
 // ignore-tidy-dbg
 
+#[cfg(test)]
+mod tests;
+
 #[doc = include_str!("../../core/src/macros/panic.md")]
 #[macro_export]
 #[rustc_builtin_macro(std_panic)]
@@ -359,19 +362,16 @@ macro_rules! dbg {
     };
 }
 
-/// Internal macro that processes a list of expressions and produces a chain of
-/// nested `match`es, one for each expression, before finally calling `eprint!`
-/// with the collected information and returning all the evaluated expressions
-/// in a tuple.
+/// Internal macro that processes a list of expressions, binds their results
+/// with `match`, calls `eprint!` with the collected information, and returns
+/// all the evaluated expressions in a tuple.
 ///
 /// E.g. `dbg_internal!(() () (1, 2))` expands into
 /// ```rust, ignore
-/// match 1 {
-///     tmp_1 => match 2 {
-///         tmp_2 => {
-///             eprint!("...", &tmp_1, &tmp_2, /* some other arguments */);
-///             (tmp_1, tmp_2)
-///         }
+/// match (1, 2) {
+///     (tmp_1, tmp_2) => {
+///         eprint!("...", &tmp_1, &tmp_2, /* some other arguments */);
+///         (tmp_1, tmp_2)
 ///     }
 /// }
 /// ```
@@ -380,37 +380,41 @@ macro_rules! dbg {
 #[doc(hidden)]
 #[rustc_macro_transparency = "semiopaque"]
 pub macro dbg_internal {
-    (($($piece:literal),+) ($($processed:expr => $bound:expr),+) ()) => {{
-        $crate::eprint!(
-            $crate::concat!($($piece),+),
-            $(
-                $crate::stringify!($processed),
-                // The `&T: Debug` check happens here (not in the format literal desugaring)
-                // to avoid format literal related messages and suggestions.
-                &&$bound as &dyn $crate::fmt::Debug
-            ),+,
-            // The location returned here is that of the macro invocation, so
-            // it will be the same for all expressions. Thus, label these
-            // arguments so that they can be reused in every piece of the
-            // formatting template.
-            file=$crate::file!(),
-            line=$crate::line!(),
-            column=$crate::column!()
-        );
-        // Comma separate the variables only when necessary so that this will
-        // not yield a tuple for a single expression, but rather just parenthesize
-        // the expression.
-        ($($bound),+)
-    }},
-    (($($piece:literal),*) ($($processed:expr => $bound:expr),*) ($val:expr $(,$rest:expr)*)) => {
+    (($($piece:literal),+) ($($processed:expr => $bound:ident),+) ()) => {
         // Use of `match` here is intentional because it affects the lifetimes
         // of temporaries - https://stackoverflow.com/a/48732525/1063961
-        match $val {
-            tmp => $crate::macros::dbg_internal!(
-                ($($piece,)* "[{file}:{line}:{column}] {} = {:#?}\n")
-                ($($processed => $bound,)* $val => tmp)
-                ($($rest),*)
-            ),
+        // Always put the arguments in a tuple to avoid an unused parens lint on the pattern.
+        match ($($processed,)+) {
+            ($($bound,)+) => {
+                $crate::eprint!(
+                    $crate::concat!($($piece),+),
+                    $(
+                        $crate::stringify!($processed),
+                        // The `&T: Debug` check happens here (not in the format literal desugaring)
+                        // to avoid format literal related messages and suggestions.
+                        &&$bound as &dyn $crate::fmt::Debug
+                    ),+,
+                    // The location returned here is that of the macro invocation, so
+                    // it will be the same for all expressions. Thus, label these
+                    // arguments so that they can be reused in every piece of the
+                    // formatting template.
+                    file=$crate::file!(),
+                    line=$crate::line!(),
+                    column=$crate::column!()
+                );
+                // Comma separate the variables only when necessary so that this will
+                // not yield a tuple for a single expression, but rather just parenthesize
+                // the expression.
+                ($($bound),+)
+
+            }
         }
     },
+    (($($piece:literal),*) ($($processed:expr => $bound:ident),*) ($val:expr $(,$rest:expr)*)) => {
+        $crate::macros::dbg_internal!(
+            ($($piece,)* "[{file}:{line}:{column}] {} = {:#?}\n")
+            ($($processed => $bound,)* $val => tmp)
+            ($($rest),*)
+        )
+    },
 }
diff --git a/library/std/src/macros/tests.rs b/library/std/src/macros/tests.rs
new file mode 100644
index 000000000000..db2be925ff30
--- /dev/null
+++ b/library/std/src/macros/tests.rs
@@ -0,0 +1,13 @@
+// ignore-tidy-dbg
+
+/// Test for <https://github.com/rust-lang/rust/issues/153850>:
+/// `dbg!` shouldn't drop arguments' temporaries.
+#[test]
+fn no_dropping_temps() {
+    fn temp() {}
+
+    *dbg!(&temp());
+    *dbg!(&temp(), 1).0;
+    *dbg!(0, &temp()).1;
+    *dbg!(0, &temp(), 2).1;
+}
diff --git a/src/tools/clippy/clippy_lints/src/dbg_macro.rs b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
index eb14ef18c03d..63968a8b5e04 100644
--- a/src/tools/clippy/clippy_lints/src/dbg_macro.rs
+++ b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
@@ -5,7 +5,7 @@
 use clippy_utils::{is_in_test, sym};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
+use rustc_hir::{Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, SyntaxContext};
@@ -92,16 +92,15 @@ fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
                                 (macro_call.span, String::from("()"))
                             }
                         },
-                        ExprKind::Match(first, arms, _) => {
-                            let vals = collect_vals(first, arms);
-                            let suggestion = match *vals.as_slice() {
+                        ExprKind::Match(args, _, _) => {
+                            let suggestion = match args.kind {
                                 // dbg!(1) => 1
-                                [val] => {
+                                ExprKind::Tup([val]) => {
                                     snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
                                         .to_string()
                                 },
                                 // dbg!(2, 3) => (2, 3)
-                                [first, .., last] => {
+                                ExprKind::Tup([first, .., last]) => {
                                     let snippet = snippet_with_applicability(
                                         cx,
                                         first.span.source_callsite().to(last.span.source_callsite()),
@@ -165,39 +164,3 @@ fn is_async_move_desugar<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx
 fn first_dbg_macro_in_expansion(cx: &LateContext<'_>, span: Span) -> Option<MacroCall> {
     macro_backtrace(span).find(|mc| cx.tcx.is_diagnostic_item(sym::dbg_macro, mc.def_id))
 }
-
-/// Extracts all value expressions from the `match`-tree generated by `dbg!`.
-///
-/// E.g. from
-/// ```rust, ignore
-/// match 1 {
-///     tmp_1 => match 2 {
-///         tmp_2 => {
-///             /* printing */
-///             (tmp_1, tmp_2)
-///         }
-///     }
-/// }
-/// ```
-/// this extracts `1` and `2`.
-fn collect_vals<'hir>(first: &'hir Expr<'hir>, mut arms: &'hir [Arm<'hir>]) -> Vec<&'hir Expr<'hir>> {
-    let mut vals = vec![first];
-    loop {
-        let [arm] = arms else {
-            unreachable!("dbg! macro expansion only has single-arm matches")
-        };
-
-        match is_async_move_desugar(arm.body)
-            .unwrap_or(arm.body)
-            .peel_drop_temps()
-            .kind
-        {
-            ExprKind::Block(..) => return vals,
-            ExprKind::Match(val, a, _) => {
-                vals.push(val);
-                arms = a;
-            },
-            _ => unreachable!("dbg! macro expansion only results in block or match expressions"),
-        }
-    }
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
index afc2cb214842..4f06a1afa50f 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
@@ -2,7 +2,7 @@ error: Undefined Behavior: memory access failed: ALLOC has been freed, so this p
   --> tests/fail/dangling_pointers/dangling_primitive.rs:LL:CC
    |
 LL |         dbg!(*ptr);
-   |         ^^^^^^^^^^ Undefined Behavior occurred here
+   |              ^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
index 364a4b4a7441..88d5694c4736 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
@@ -7,7 +7,7 @@ error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is unin
   --> tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC
    |
 LL |     dbg!(x.0);
-   |     ^^^^^^^^^ Undefined Behavior occurred here
+   |          ^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/tests/ui/borrowck/dbg-issue-120327.stderr b/tests/ui/borrowck/dbg-issue-120327.stderr
index efacc0c3f134..685a530a1fe5 100644
--- a/tests/ui/borrowck/dbg-issue-120327.stderr
+++ b/tests/ui/borrowck/dbg-issue-120327.stderr
@@ -4,14 +4,14 @@ error[E0382]: use of moved value: `a`
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(a);
-   |     ------- value moved here
+   |          - value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider borrowing instead of transferring ownership
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |     dbg!(&a);
-   |          +
+LL |     dbg!(a.clone());
+   |           ++++++++
 
 error[E0382]: use of moved value: `a`
   --> $DIR/dbg-issue-120327.rs:10:12
@@ -19,14 +19,14 @@ error[E0382]: use of moved value: `a`
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(1, 2, a, 1, 2);
-   |     ------------------- value moved here
+   |                - value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider borrowing instead of transferring ownership
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |     dbg!(1, 2, &a, 1, 2);
-   |                +
+LL |     dbg!(1, 2, a.clone(), 1, 2);
+   |                 ++++++++
 
 error[E0382]: use of moved value: `b`
   --> $DIR/dbg-issue-120327.rs:16:12
@@ -34,14 +34,14 @@ error[E0382]: use of moved value: `b`
 LL |     let b: String = "".to_string();
    |         - move occurs because `b` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(a, b);
-   |     ---------- value moved here
+   |             - value moved here
 LL |     return b;
    |            ^ value used here after move
    |
-help: consider borrowing instead of transferring ownership
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |     dbg!(a, &b);
-   |             +
+LL |     dbg!(a, b.clone());
+   |              ++++++++
 
 error[E0382]: use of moved value: `a`
   --> $DIR/dbg-issue-120327.rs:22:12
@@ -50,14 +50,14 @@ LL | fn x(a: String) -> String {
    |      - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     let b: String = "".to_string();
 LL |     dbg!(a, b);
-   |     ---------- value moved here
+   |          - value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider borrowing instead of transferring ownership
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |     dbg!(&a, b);
-   |          +
+LL |     dbg!(a.clone(), b);
+   |           ++++++++
 
 error[E0382]: use of moved value: `b`
   --> $DIR/dbg-issue-120327.rs:46:12
@@ -103,14 +103,14 @@ error[E0382]: borrow of moved value: `a`
 LL |     let a: String = "".to_string();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     let _res = get_expr(dbg!(a));
-   |                         ------- value moved here
+   |                              - value moved here
 LL |     let _l = a.len();
    |              ^ value borrowed here after move
    |
-help: consider borrowing instead of transferring ownership
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let _res = get_expr(dbg!(&a));
-   |                              +
+LL |     let _res = get_expr(dbg!(a.clone()));
+   |                               ++++++++
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/liveness/liveness-upvars.rs b/tests/ui/liveness/liveness-upvars.rs
index be58b48a4057..0e198f1dea10 100644
--- a/tests/ui/liveness/liveness-upvars.rs
+++ b/tests/ui/liveness/liveness-upvars.rs
@@ -98,7 +98,7 @@ pub fn g<T: Default>(mut v: T) {
 }
 
 pub fn h<T: Copy + Default + std::fmt::Debug>() {
-    let mut z = T::default();
+    let mut z = T::default(); //~ WARN unused variable: `z`
     let _ = move |b| {
         loop {
             if b {
diff --git a/tests/ui/liveness/liveness-upvars.stderr b/tests/ui/liveness/liveness-upvars.stderr
index cfed2830164a..0bb5786ab3e2 100644
--- a/tests/ui/liveness/liveness-upvars.stderr
+++ b/tests/ui/liveness/liveness-upvars.stderr
@@ -156,6 +156,14 @@ LL |                 z = T::default();
    |
    = help: maybe it is overwritten before being read?
 
+warning: unused variable: `z`
+  --> $DIR/liveness-upvars.rs:101:9
+   |
+LL |     let mut z = T::default();
+   |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_z`
+   |
+   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+
 warning: value captured by `state` is never read
   --> $DIR/liveness-upvars.rs:131:9
    |
@@ -196,5 +204,5 @@ LL |         s = yield ();
    |
    = help: maybe it is overwritten before being read?
 
-warning: 24 warnings emitted
+warning: 25 warnings emitted
 
diff --git a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
index f8ef315b9cc7..76b2d1be2779 100644
--- a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
+++ b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
@@ -1,17 +1,21 @@
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-macro-move-semantics.rs:9:13
+  --> $DIR/dbg-macro-move-semantics.rs:9:18
    |
 LL |     let a = NoCopy(0);
    |         - move occurs because `a` has type `NoCopy`, which does not implement the `Copy` trait
 LL |     let _ = dbg!(a);
-   |             ------- value moved here
+   |                  - value moved here
 LL |     let _ = dbg!(a);
-   |             ^^^^^^^ value used here after move
+   |                  ^ value used here after move
    |
-help: consider borrowing instead of transferring ownership
+note: if `NoCopy` implemented `Clone`, you could clone the value
+  --> $DIR/dbg-macro-move-semantics.rs:4:1
    |
-LL |     let _ = dbg!(&a);
-   |                  +
+LL | struct NoCopy(usize);
+   | ^^^^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     let _ = dbg!(a);
+   |                  - you could clone this value
 
 error: aborting due to 1 previous error
 

From 5e698662cdddb6a53c724b301989553e54b27936 Mon Sep 17 00:00:00 2001
From: Jean IBARZ <ibarz.jean@gmail.com>
Date: Sun, 29 Mar 2026 14:15:38 +0200
Subject: [PATCH 1041/1059] Add regression test for TransmuteFrom ICE with
 min_generic_const_args

Exercises TransmuteFrom with min_generic_const_args, which previously
caused an ICE in well-formedness checking.
---
 .../transmute-from-const-args-ice-150457.rs   | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 tests/ui/transmutability/transmute-from-const-args-ice-150457.rs

diff --git a/tests/ui/transmutability/transmute-from-const-args-ice-150457.rs b/tests/ui/transmutability/transmute-from-const-args-ice-150457.rs
new file mode 100644
index 000000000000..8c1b709127b0
--- /dev/null
+++ b/tests/ui/transmutability/transmute-from-const-args-ice-150457.rs
@@ -0,0 +1,31 @@
+//! Ensure `TransmuteFrom` with `min_generic_const_args` doesn't ICE
+//! during well-formedness checking.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/150457>.
+
+//@ check-pass
+
+#![feature(transmutability)]
+#![feature(min_generic_const_args)]
+
+use std::mem::{Assume, TransmuteFrom};
+
+struct W<'a>(&'a ());
+
+fn test<'a>()
+where
+    W<'a>: TransmuteFrom<
+        (),
+        {
+            Assume {
+                alignment: const { true },
+                lifetimes: const { true },
+                safety: const { true },
+                validity: true,
+            }
+        },
+    >,
+{
+}
+
+fn main() {}

From 9fd2c9ef01d859ac3eaa04d68804140a988d75ae Mon Sep 17 00:00:00 2001
From: Jean IBARZ <ibarz.jean@gmail.com>
Date: Sun, 29 Mar 2026 14:15:57 +0200
Subject: [PATCH 1042/1059] Add regression test for recursive lazy type alias
 normalization ICE

Exercises a self-referencing type alias with lazy_type_alias and
min_generic_const_args, which previously caused an ICE during
normalization.
---
 .../recursive-lazy-type-alias-ice-152633.rs        | 14 ++++++++++++++
 .../recursive-lazy-type-alias-ice-152633.stderr    | 11 +++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.rs
 create mode 100644 tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.stderr

diff --git a/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.rs b/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.rs
new file mode 100644
index 000000000000..4b3633653133
--- /dev/null
+++ b/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.rs
@@ -0,0 +1,14 @@
+//! Ensure a self-referencing lazy type alias with `min_generic_const_args`
+//! doesn't ICE during normalization.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/152633>.
+
+#![feature(lazy_type_alias)]
+#![feature(min_generic_const_args)]
+
+trait Trait {
+    type const ASSOC: ();
+}
+type Arr2 = [usize; <Arr2 as Trait>::ASSOC]; //~ ERROR E0275
+
+fn main() {}
diff --git a/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.stderr b/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.stderr
new file mode 100644
index 000000000000..a8e68a05253b
--- /dev/null
+++ b/tests/ui/type-alias/recursive-lazy-type-alias-ice-152633.stderr
@@ -0,0 +1,11 @@
+error[E0275]: overflow normalizing the type alias `Arr2`
+  --> $DIR/recursive-lazy-type-alias-ice-152633.rs:12:1
+   |
+LL | type Arr2 = [usize; <Arr2 as Trait>::ASSOC];
+   | ^^^^^^^^^
+   |
+   = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.

From c67380d6fe272b985bc8fdb4a54abfca5d51bf97 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Thu, 19 Mar 2026 21:35:58 +0000
Subject: [PATCH 1043/1059] rustdoc: add test showing cfg pretty-printing of
 all targets

---
 tests/rustdoc-html/doc-cfg/all-targets.rs | 144 ++++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 tests/rustdoc-html/doc-cfg/all-targets.rs

diff --git a/tests/rustdoc-html/doc-cfg/all-targets.rs b/tests/rustdoc-html/doc-cfg/all-targets.rs
new file mode 100644
index 000000000000..ab6e6c216eef
--- /dev/null
+++ b/tests/rustdoc-html/doc-cfg/all-targets.rs
@@ -0,0 +1,144 @@
+#![feature(doc_cfg)]
+
+//@ has all_targets/fn.foo.html \
+//  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
+//  'Available on GNU or target_env=macabi or target_env=mlibc or MSVC or musl or \
+//  Newlib or target_env=nto70 or target_env=nto71 or target_env=nto71_iosock or \
+//  target_env=nto80 or target_env=ohos or target_env=relibc or SGX or \
+//  target_env=sim or target_env=p1 or target_env=p2 or target_env=p3 or uClibc or \
+//  target_env=v5 or target_env=fake_env only.'
+#[doc(cfg(any(
+    target_env = "gnu",
+    target_env = "macabi",
+    target_env = "mlibc",
+    target_env = "msvc",
+    target_env = "musl",
+    target_env = "newlib",
+    target_env = "nto70",
+    target_env = "nto71",
+    target_env = "nto71_iosock",
+    target_env = "nto80",
+    target_env = "ohos",
+    target_env = "relibc",
+    target_env = "sgx",
+    target_env = "sim",
+    target_env = "p1",
+    target_env = "p2",
+    target_env = "p3",
+    target_env = "uclibc",
+    target_env = "v5",
+    target_env = "fake_env",
+)))]
+pub fn foo() {}
+
+//@ has all_targets/fn.bar.html \
+//  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
+//  'Available on AArch64 or target_arch=amdgpu or ARM or target_arch=arm64ec or \
+//  target_arch=avr or target_arch=bpf or CSKY or target_arch=hexagon or LoongArch \
+//  LA32 or LoongArch LA64 or M68k or MIPS or MIPS Release 6 or MIPS-64 or MIPS-64 \
+//  Release 6 or MSP430 or target_arch=nvptx64 or PowerPC or PowerPC-64 or RISC-V \
+//  RV32 or RISC-V RV64 or s390x or target_arch=sparc or SPARC64 or \
+//  target_arch=spirv or WebAssembly or WebAssembly or x86 or x86-64 or \
+//  target_arch=xtensa or target_arch=fake_arch only.'
+#[doc(cfg(any(
+    target_arch = "aarch64",
+    target_arch = "amdgpu",
+    target_arch = "arm",
+    target_arch = "arm64ec",
+    target_arch = "avr",
+    target_arch = "bpf",
+    target_arch = "csky",
+    target_arch = "hexagon",
+    target_arch = "loongarch32",
+    target_arch = "loongarch64",
+    target_arch = "m68k",
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "mips64",
+    target_arch = "mips64r6",
+    target_arch = "msp430",
+    target_arch = "nvptx64",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "riscv32",
+    target_arch = "riscv64",
+    target_arch = "s390x",
+    target_arch = "sparc",
+    target_arch = "sparc64",
+    target_arch = "spirv",
+    target_arch = "wasm32",
+    target_arch = "wasm64",
+    target_arch = "x86",
+    target_arch = "x86_64",
+    target_arch = "xtensa",
+    target_arch = "fake_arch",
+)))]
+pub fn bar() {}
+
+//@ has all_targets/fn.baz.html \
+//  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
+//  'Available on target_os=aix and target_os=amdhsa and Android and target_os=cuda \
+//  and Cygwin and DragonFly BSD and Emscripten and target_os=espidf and FreeBSD \
+//  and Fuchsia and Haiku and target_os=helenos and Hermit and target_os=horizon \
+//  and target_os=hurd and illumos and iOS and L4Re and Linux and \
+//  target_os=lynxos178 and macOS and target_os=managarm and target_os=motor and \
+//  NetBSD and target_os=none and target_os=nto and target_os=nuttx and OpenBSD and \
+//  target_os=psp and target_os=psx and target_os=qurt and Redox and \
+//  target_os=rtems and Solaris and target_os=solid_asp3 and target_os=teeos and \
+//  target_os=trusty and tvOS and target_os=uefi and target_os=vexos and visionOS \
+//  and target_os=vita and target_os=vxworks and WASI and watchOS and Windows and \
+//  target_os=xous and target_os=zkvm and target_os=unknown and target_os=fake_os \
+//  only.'
+#[doc(cfg(all(
+    target_os = "aix",
+    target_os = "amdhsa",
+    target_os = "android",
+    target_os = "cuda",
+    target_os = "cygwin",
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "espidf",
+    target_os = "freebsd",
+    target_os = "fuchsia",
+    target_os = "haiku",
+    target_os = "helenos",
+    target_os = "hermit",
+    target_os = "horizon",
+    target_os = "hurd",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "l4re",
+    target_os = "linux",
+    target_os = "lynxos178",
+    target_os = "macos",
+    target_os = "managarm",
+    target_os = "motor",
+    target_os = "netbsd",
+    target_os = "none",
+    target_os = "nto",
+    target_os = "nuttx",
+    target_os = "openbsd",
+    target_os = "psp",
+    target_os = "psx",
+    target_os = "qurt",
+    target_os = "redox",
+    target_os = "rtems",
+    target_os = "solaris",
+    target_os = "solid_asp3",
+    target_os = "teeos",
+    target_os = "trusty",
+    target_os = "tvos",
+    target_os = "uefi",
+    target_os = "vexos",
+    target_os = "visionos",
+    target_os = "vita",
+    target_os = "vxworks",
+    target_os = "wasi",
+    target_os = "watchos",
+    target_os = "windows",
+    target_os = "xous",
+    target_os = "zkvm",
+    target_os = "unknown",
+    target_os = "fake_os",
+)))]
+pub fn baz() {}

From 9f0944832b62279adba24c702e5d6f7a94880485 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Thu, 19 Mar 2026 21:35:58 +0000
Subject: [PATCH 1044/1059] rustdoc: add missing target_{os,arch,env} values
 for cfg pretty printer

---
 src/librustdoc/clean/cfg.rs               | 195 +++++++++++++++-------
 tests/rustdoc-gui/item-info-overflow.goml |   4 +-
 tests/rustdoc-html/doc-cfg/all-targets.rs |  43 +++--
 3 files changed, 159 insertions(+), 83 deletions(-)

diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index 3ec2bc3af8d4..ee03431d036b 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -3,6 +3,7 @@
 // FIXME: Once the portability lint RFC is implemented (see tracking issue #41619),
 // switch to use those structures instead.
 
+use std::str::FromStr;
 use std::sync::Arc;
 use std::{fmt, mem, ops};
 
@@ -15,6 +16,7 @@
 use rustc_middle::ty::TyCtxt;
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{DUMMY_SP, Span};
+use rustc_target::spec;
 
 use crate::display::{Joined as _, MaybeDisplay, Wrapped};
 use crate::html::escape::Escape;
@@ -421,54 +423,10 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
                     (sym::unix, None) => "Unix",
                     (sym::windows, None) => "Windows",
                     (sym::debug_assertions, None) => "debug-assertions enabled",
-                    (sym::target_os, Some(os)) => match os.as_str() {
-                        "android" => "Android",
-                        "cygwin" => "Cygwin",
-                        "dragonfly" => "DragonFly BSD",
-                        "emscripten" => "Emscripten",
-                        "freebsd" => "FreeBSD",
-                        "fuchsia" => "Fuchsia",
-                        "haiku" => "Haiku",
-                        "hermit" => "Hermit",
-                        "illumos" => "illumos",
-                        "ios" => "iOS",
-                        "l4re" => "L4Re",
-                        "linux" => "Linux",
-                        "macos" => "macOS",
-                        "netbsd" => "NetBSD",
-                        "openbsd" => "OpenBSD",
-                        "redox" => "Redox",
-                        "solaris" => "Solaris",
-                        "tvos" => "tvOS",
-                        "wasi" => "WASI",
-                        "watchos" => "watchOS",
-                        "windows" => "Windows",
-                        "visionos" => "visionOS",
-                        _ => "",
-                    },
-                    (sym::target_arch, Some(arch)) => match arch.as_str() {
-                        "aarch64" => "AArch64",
-                        "arm" => "ARM",
-                        "loongarch32" => "LoongArch LA32",
-                        "loongarch64" => "LoongArch LA64",
-                        "m68k" => "M68k",
-                        "csky" => "CSKY",
-                        "mips" => "MIPS",
-                        "mips32r6" => "MIPS Release 6",
-                        "mips64" => "MIPS-64",
-                        "mips64r6" => "MIPS-64 Release 6",
-                        "msp430" => "MSP430",
-                        "powerpc" => "PowerPC",
-                        "powerpc64" => "PowerPC-64",
-                        "riscv32" => "RISC-V RV32",
-                        "riscv64" => "RISC-V RV64",
-                        "s390x" => "s390x",
-                        "sparc64" => "SPARC64",
-                        "wasm32" | "wasm64" => "WebAssembly",
-                        "x86" => "x86",
-                        "x86_64" => "x86-64",
-                        _ => "",
-                    },
+                    (sym::target_os, Some(os)) => human_readable_target_os(*os).unwrap_or_default(),
+                    (sym::target_arch, Some(arch)) => {
+                        human_readable_target_arch(*arch).unwrap_or_default()
+                    }
                     (sym::target_vendor, Some(vendor)) => match vendor.as_str() {
                         "apple" => "Apple",
                         "pc" => "PC",
@@ -476,15 +434,9 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
                         "fortanix" => "Fortanix",
                         _ => "",
                     },
-                    (sym::target_env, Some(env)) => match env.as_str() {
-                        "gnu" => "GNU",
-                        "msvc" => "MSVC",
-                        "musl" => "musl",
-                        "newlib" => "Newlib",
-                        "uclibc" => "uClibc",
-                        "sgx" => "SGX",
-                        _ => "",
-                    },
+                    (sym::target_env, Some(env)) => {
+                        human_readable_target_env(*env).unwrap_or_default()
+                    }
                     (sym::target_endian, Some(endian)) => {
                         return write!(fmt, "{endian}-endian");
                     }
@@ -527,6 +479,135 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
+fn human_readable_target_os(os: Symbol) -> Option<&'static str> {
+    let os = spec::Os::from_str(os.as_str()).ok()?;
+
+    use spec::Os::*;
+    Some(match os {
+        // tidy-alphabetical-start
+        Aix => "AIX",
+        AmdHsa => "AMD HSA",
+        Android => "Android",
+        Cuda => "CUDA",
+        Cygwin => "Cygwin",
+        Dragonfly => "DragonFly BSD",
+        Emscripten => "Emscripten",
+        EspIdf => "ESP-IDF",
+        FreeBsd => "FreeBSD",
+        Fuchsia => "Fuchsia",
+        Haiku => "Haiku",
+        HelenOs => "HelenOS",
+        Hermit => "Hermit",
+        Horizon => "Horizon",
+        Hurd => "GNU/Hurd",
+        IOs => "iOS",
+        Illumos => "illumos",
+        L4Re => "L4Re",
+        Linux => "Linux",
+        LynxOs178 => "LynxOS-178",
+        MacOs => "macOS",
+        Managarm => "Managarm",
+        Motor => "Motor OS",
+        NetBsd => "NetBSD",
+        None => "bare-metal", // FIXME(scrabsha): is this appropriate?
+        Nto => "QNX Neutrino",
+        NuttX => "NuttX",
+        OpenBsd => "OpenBSD",
+        Psp => "Play Station Portable",
+        Psx => "Play Station 1",
+        Qurt => "QuRT",
+        Redox => "Redox OS",
+        Rtems => "RTEMS OS",
+        Solaris => "Solaris",
+        SolidAsp3 => "SOLID ASP3",
+        TeeOs => "TEEOS",
+        Trusty => "Trusty",
+        TvOs => "tvOS",
+        Uefi => "UEFI",
+        VexOs => "VEXos",
+        VisionOs => "visionOS",
+        Vita => "Play Station Vita",
+        VxWorks => "VxWorks",
+        Wasi => "WASI",
+        WatchOs => "watchOS",
+        Windows => "Windows",
+        Xous => "Xous",
+        Zkvm => "zero knowledge Virtual Machine",
+        // tidy-alphabetical-end
+        Unknown | Other(_) => return Option::None,
+    })
+}
+
+fn human_readable_target_arch(os: Symbol) -> Option<&'static str> {
+    let arch = spec::Arch::from_str(os.as_str()).ok()?;
+
+    use spec::Arch::*;
+    Some(match arch {
+        // tidy-alphabetical-start
+        AArch64 => "AArch64",
+        AmdGpu => "AMG GPU",
+        Arm => "ARM",
+        Arm64EC => "ARM64EC",
+        Avr => "AVR",
+        Bpf => "BPF",
+        CSky => "C-SKY",
+        Hexagon => "Hexagon",
+        LoongArch32 => "LoongArch64",
+        LoongArch64 => "LoongArch32",
+        M68k => "Motorola 680x0",
+        Mips => "MIPS",
+        Mips32r6 => "MIPS release 6",
+        Mips64 => "MIPS-64",
+        Mips64r6 => "MIPS-64 release 6",
+        Msp430 => "MSP430",
+        Nvptx64 => "NVidia GPU",
+        PowerPC => "PowerPC",
+        PowerPC64 => "PowerPC64",
+        RiscV32 => "RISC-V RV32",
+        RiscV64 => "RISC-V RV64",
+        S390x => "s390x",
+        Sparc => "SPARC",
+        Sparc64 => "SPARC-64",
+        SpirV => "SPIR-V",
+        Wasm32 | Wasm64 => "WebAssembly",
+        X86 => "x86",
+        X86_64 => "x86-64",
+        Xtensa => "Xtensa",
+        // tidy-alphabetical-end
+        Other(_) => return None,
+    })
+}
+
+fn human_readable_target_env(env: Symbol) -> Option<&'static str> {
+    let env = spec::Env::from_str(env.as_str()).ok()?;
+
+    use spec::Env::*;
+    Some(match env {
+        // tidy-alphabetical-start
+        Gnu => "GNU",
+        MacAbi => "Catalyst",
+        Mlibc => "mac ABI",
+        Msvc => "MSVC",
+        Musl => "musl",
+        Newlib => "Newlib",
+        Nto70 => "Neutrino 7.0",
+        Nto71 => "Neutrino 7.1",
+        Nto71IoSock => "Neutrino 7.1 with io-sock",
+        Nto80 => "Neutrino 8.0",
+        Ohos => "OpenHarmony",
+        P1 => "WASIp1",
+        P2 => "WASIp2",
+        P3 => "WASIp3",
+        Relibc => "relibc",
+        Sgx => "SGX",
+        Sim => "Simulator",
+        Uclibc => "uClibc",
+        V5 => "V5",
+        // tidy-alphabetical-end
+        Unspecified | Other(_) => return None,
+    })
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 struct NameValueCfg {
     name: Symbol,
diff --git a/tests/rustdoc-gui/item-info-overflow.goml b/tests/rustdoc-gui/item-info-overflow.goml
index 2c4e06e297c7..b53ffb00f1c3 100644
--- a/tests/rustdoc-gui/item-info-overflow.goml
+++ b/tests/rustdoc-gui/item-info-overflow.goml
@@ -8,7 +8,7 @@ assert-property: (".item-info", {"scrollWidth": "940"})
 // Just to be sure we're comparing the correct "item-info":
 assert-text: (
     ".item-info",
-    "Available on Android or Linux or Emscripten or DragonFly BSD",
+    "Available on Android or Linux or Emscripten or DragonFly BSD or FreeBSD or NetBSD or OpenBSD",
     STARTS_WITH,
 )
 
@@ -26,6 +26,6 @@ assert-property: (
 // Just to be sure we're comparing the correct "item-info":
 assert-text: (
     "#impl-SimpleTrait-for-LongItemInfo2 .item-info",
-    "Available on Android or Linux or Emscripten or DragonFly BSD",
+    "Available on Android or Linux or Emscripten or DragonFly BSD or FreeBSD or NetBSD or OpenBSD",
     STARTS_WITH,
 )
diff --git a/tests/rustdoc-html/doc-cfg/all-targets.rs b/tests/rustdoc-html/doc-cfg/all-targets.rs
index ab6e6c216eef..4db41e1f8344 100644
--- a/tests/rustdoc-html/doc-cfg/all-targets.rs
+++ b/tests/rustdoc-html/doc-cfg/all-targets.rs
@@ -2,11 +2,10 @@
 
 //@ has all_targets/fn.foo.html \
 //  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
-//  'Available on GNU or target_env=macabi or target_env=mlibc or MSVC or musl or \
-//  Newlib or target_env=nto70 or target_env=nto71 or target_env=nto71_iosock or \
-//  target_env=nto80 or target_env=ohos or target_env=relibc or SGX or \
-//  target_env=sim or target_env=p1 or target_env=p2 or target_env=p3 or uClibc or \
-//  target_env=v5 or target_env=fake_env only.'
+//  'Available on GNU or Catalyst or mac ABI or MSVC or musl or Newlib or \
+//  Neutrino 7.0 or Neutrino 7.1 or Neutrino 7.1 with io-sock or Neutrino 8.0 or \
+//  OpenHarmony or relibc or SGX or Simulator or WASIp1 or WASIp2 or WASIp3 or \
+//  uClibc or V5 or target_env=fake_env only.'
 #[doc(cfg(any(
     target_env = "gnu",
     target_env = "macabi",
@@ -33,13 +32,12 @@ pub fn foo() {}
 
 //@ has all_targets/fn.bar.html \
 //  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
-//  'Available on AArch64 or target_arch=amdgpu or ARM or target_arch=arm64ec or \
-//  target_arch=avr or target_arch=bpf or CSKY or target_arch=hexagon or LoongArch \
-//  LA32 or LoongArch LA64 or M68k or MIPS or MIPS Release 6 or MIPS-64 or MIPS-64 \
-//  Release 6 or MSP430 or target_arch=nvptx64 or PowerPC or PowerPC-64 or RISC-V \
-//  RV32 or RISC-V RV64 or s390x or target_arch=sparc or SPARC64 or \
-//  target_arch=spirv or WebAssembly or WebAssembly or x86 or x86-64 or \
-//  target_arch=xtensa or target_arch=fake_arch only.'
+//  'Available on AArch64 or AMG GPU or ARM or ARM64EC or AVR or BPF or C-SKY or \
+//  Hexagon or LoongArch64 or LoongArch32 or Motorola 680x0 or MIPS or MIPS release \
+//  6 or MIPS-64 or MIPS-64 release 6 or MSP430 or NVidia GPU or PowerPC or \
+//  PowerPC64 or RISC-V RV32 or RISC-V RV64 or s390x or SPARC or SPARC-64 or SPIR-V \
+//  or WebAssembly or WebAssembly or x86 or x86-64 or Xtensa or \
+//  target_arch=fake_arch only.'
 #[doc(cfg(any(
     target_arch = "aarch64",
     target_arch = "amdgpu",
@@ -77,18 +75,15 @@ pub fn bar() {}
 
 //@ has all_targets/fn.baz.html \
 //  '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' \
-//  'Available on target_os=aix and target_os=amdhsa and Android and target_os=cuda \
-//  and Cygwin and DragonFly BSD and Emscripten and target_os=espidf and FreeBSD \
-//  and Fuchsia and Haiku and target_os=helenos and Hermit and target_os=horizon \
-//  and target_os=hurd and illumos and iOS and L4Re and Linux and \
-//  target_os=lynxos178 and macOS and target_os=managarm and target_os=motor and \
-//  NetBSD and target_os=none and target_os=nto and target_os=nuttx and OpenBSD and \
-//  target_os=psp and target_os=psx and target_os=qurt and Redox and \
-//  target_os=rtems and Solaris and target_os=solid_asp3 and target_os=teeos and \
-//  target_os=trusty and tvOS and target_os=uefi and target_os=vexos and visionOS \
-//  and target_os=vita and target_os=vxworks and WASI and watchOS and Windows and \
-//  target_os=xous and target_os=zkvm and target_os=unknown and target_os=fake_os \
-//  only.'
+//  'Available on AIX and AMD HSA and Android and CUDA and Cygwin and DragonFly \
+//  BSD and Emscripten and ESP-IDF and FreeBSD and Fuchsia and Haiku and HelenOS \
+//  and Hermit and Horizon and GNU/Hurd and illumos and iOS and L4Re and Linux \
+//  and LynxOS-178 and macOS and Managarm and Motor OS and NetBSD and bare-metal \
+//  and QNX Neutrino and NuttX and OpenBSD and Play Station Portable and Play \
+//  Station 1 and QuRT and Redox OS and RTEMS OS and Solaris and SOLID ASP3 and \
+//  TEEOS and Trusty and tvOS and UEFI and VEXos and visionOS and Play Station \
+//  Vita and VxWorks and WASI and watchOS and Windows and Xous and zero knowledge \
+//  Virtual Machine and target_os=unknown and target_os=fake_os only.'
 #[doc(cfg(all(
     target_os = "aix",
     target_os = "amdhsa",

From 7d1b41cbb386fef7763885f738f7f89b48de10e2 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Sun, 29 Mar 2026 08:08:51 -0700
Subject: [PATCH 1045/1059] update diagnostic for variables moved by `dbg!`

---
 .../src/diagnostics/conflict_errors.rs        | 40 +++++----
 compiler/rustc_span/src/symbol.rs             |  1 +
 src/tools/clippy/clippy_utils/src/sym.rs      |  1 -
 tests/ui/borrowck/dbg-issue-120327.rs         | 53 ++++-------
 tests/ui/borrowck/dbg-issue-120327.stderr     | 87 ++++++++++++-------
 .../dbg-macro-move-semantics.stderr           |  4 +
 6 files changed, 99 insertions(+), 87 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 641121597848..56facbb70e64 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -545,8 +545,6 @@ fn visit_pat(&mut self, p: &'hir hir::Pat<'hir>) {
     }
 
     // for dbg!(x) which may take ownership, suggest dbg!(&x) instead
-    // but here we actually do not check whether the macro name is `dbg!`
-    // so that we may extend the scope a bit larger to cover more cases
     fn suggest_ref_for_dbg_args(
         &self,
         body: &hir::Expr<'_>,
@@ -560,29 +558,41 @@ fn suggest_ref_for_dbg_args(
         });
         let Some(var_info) = var_info else { return };
         let arg_name = var_info.name;
-        struct MatchArgFinder {
-            expr_span: Span,
-            match_arg_span: Option<Span>,
+        struct MatchArgFinder<'tcx> {
+            tcx: TyCtxt<'tcx>,
+            move_span: Span,
             arg_name: Symbol,
+            match_arg_span: Option<Span> = None,
         }
-        impl Visitor<'_> for MatchArgFinder {
+        impl Visitor<'_> for MatchArgFinder<'_> {
             fn visit_expr(&mut self, e: &hir::Expr<'_>) {
                 // dbg! is expanded into a match pattern, we need to find the right argument span
-                if let hir::ExprKind::Match(expr, ..) = &e.kind
-                    && let hir::ExprKind::Path(hir::QPath::Resolved(
-                        _,
-                        path @ Path { segments: [seg], .. },
-                    )) = &expr.kind
-                    && seg.ident.name == self.arg_name
-                    && self.expr_span.source_callsite().contains(expr.span)
+                if let hir::ExprKind::Match(scrutinee, ..) = &e.kind
+                    && let hir::ExprKind::Tup(args) = scrutinee.kind
+                    && e.span.macro_backtrace().any(|expn| {
+                        expn.macro_def_id.is_some_and(|macro_def_id| {
+                            self.tcx.is_diagnostic_item(sym::dbg_macro, macro_def_id)
+                        })
+                    })
                 {
-                    self.match_arg_span = Some(path.span);
+                    for arg in args {
+                        if let hir::ExprKind::Path(hir::QPath::Resolved(
+                            _,
+                            path @ Path { segments: [seg], .. },
+                        )) = &arg.kind
+                            && seg.ident.name == self.arg_name
+                            && self.move_span.source_equal(arg.span)
+                        {
+                            self.match_arg_span = Some(path.span);
+                            return;
+                        }
+                    }
                 }
                 hir::intravisit::walk_expr(self, e);
             }
         }
 
-        let mut finder = MatchArgFinder { expr_span: move_span, match_arg_span: None, arg_name };
+        let mut finder = MatchArgFinder { tcx: self.infcx.tcx, move_span, arg_name, .. };
         finder.visit_expr(body);
         if let Some(macro_arg_span) = finder.match_arg_span {
             err.span_suggestion_verbose(
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 286fea7d9050..e6658fc0eec1 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -746,6 +746,7 @@
         custom_mir,
         custom_test_frameworks,
         d32,
+        dbg_macro,
         dead_code,
         dealloc,
         debug,
diff --git a/src/tools/clippy/clippy_utils/src/sym.rs b/src/tools/clippy/clippy_utils/src/sym.rs
index d6ba678434bc..909dc3956d5f 100644
--- a/src/tools/clippy/clippy_utils/src/sym.rs
+++ b/src/tools/clippy/clippy_utils/src/sym.rs
@@ -199,7 +199,6 @@ macro_rules! generate {
     cx,
     cycle,
     cyclomatic_complexity,
-    dbg_macro,
     de,
     debug_struct,
     deprecated_in_future,
diff --git a/tests/ui/borrowck/dbg-issue-120327.rs b/tests/ui/borrowck/dbg-issue-120327.rs
index 2de43f634877..45605acc3433 100644
--- a/tests/ui/borrowck/dbg-issue-120327.rs
+++ b/tests/ui/borrowck/dbg-issue-120327.rs
@@ -1,67 +1,44 @@
+//! Diagnostic test for <https://github.com/rust-lang/rust/issues/120327>: suggest borrowing
+//! variables passed to `dbg!` that are later used.
+//@ dont-require-annotations: HELP
+
 fn s() -> String {
     let a = String::new();
-    dbg!(a);
+    dbg!(a); //~ HELP consider borrowing instead of transferring ownership
     return a; //~ ERROR use of moved value:
 }
 
 fn m() -> String {
     let a = String::new();
-    dbg!(1, 2, a, 1, 2);
+    dbg!(1, 2, a, 1, 2); //~ HELP consider borrowing instead of transferring ownership
     return a; //~ ERROR use of moved value:
 }
 
 fn t(a: String) -> String {
     let b: String = "".to_string();
-    dbg!(a, b);
+    dbg!(a, b); //~ HELP consider borrowing instead of transferring ownership
     return b; //~ ERROR use of moved value:
 }
 
 fn x(a: String) -> String {
     let b: String = "".to_string();
-    dbg!(a, b);
+    dbg!(a, b); //~ HELP consider borrowing instead of transferring ownership
     return a; //~ ERROR use of moved value:
 }
 
-macro_rules! my_dbg {
-    () => {
-        eprintln!("[{}:{}:{}]", file!(), line!(), column!())
-    };
-    ($val:expr $(,)?) => {
-        match $val {
-            tmp => {
-                eprintln!("[{}:{}:{}] {} = {:#?}",
-                    file!(), line!(), column!(), stringify!($val), &tmp);
-                tmp
-            }
-        }
-    };
-    ($($val:expr),+ $(,)?) => {
-        ($(my_dbg!($val)),+,)
-    };
-}
-
-fn test_my_dbg() -> String {
-    let b: String = "".to_string();
-    my_dbg!(b, 1);
-    return b; //~ ERROR use of moved value:
-}
-
-fn test_not_macro() -> String {
-    let a = String::new();
-    let _b = match a {
-        tmp => {
-            eprintln!("dbg: {}", tmp);
-            tmp
-        }
-    };
-    return a; //~ ERROR use of moved value:
+fn two_of_them(a: String) -> String {
+    dbg!(a, a); //~ ERROR use of moved value
+    //~| HELP consider borrowing instead of transferring ownership
+    //~| HELP consider borrowing instead of transferring ownership
+    return a; //~ ERROR use of moved value
 }
 
 fn get_expr(_s: String) {}
 
+// The suggestion is purely syntactic; applying it here will result in a type error.
 fn test() {
     let a: String = "".to_string();
-    let _res = get_expr(dbg!(a));
+    let _res = get_expr(dbg!(a)); //~ HELP consider borrowing instead of transferring ownership
     let _l = a.len(); //~ ERROR borrow of moved value
 }
 
diff --git a/tests/ui/borrowck/dbg-issue-120327.stderr b/tests/ui/borrowck/dbg-issue-120327.stderr
index 685a530a1fe5..e7a7151e541d 100644
--- a/tests/ui/borrowck/dbg-issue-120327.stderr
+++ b/tests/ui/borrowck/dbg-issue-120327.stderr
@@ -1,5 +1,5 @@
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-issue-120327.rs:4:12
+  --> $DIR/dbg-issue-120327.rs:8:12
    |
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
@@ -12,9 +12,13 @@ help: consider cloning the value if the performance cost is acceptable
    |
 LL |     dbg!(a.clone());
    |           ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     dbg!(&a);
+   |          +
 
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-issue-120327.rs:10:12
+  --> $DIR/dbg-issue-120327.rs:14:12
    |
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
@@ -27,9 +31,13 @@ help: consider cloning the value if the performance cost is acceptable
    |
 LL |     dbg!(1, 2, a.clone(), 1, 2);
    |                 ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     dbg!(1, 2, &a, 1, 2);
+   |                +
 
 error[E0382]: use of moved value: `b`
-  --> $DIR/dbg-issue-120327.rs:16:12
+  --> $DIR/dbg-issue-120327.rs:20:12
    |
 LL |     let b: String = "".to_string();
    |         - move occurs because `b` has type `String`, which does not implement the `Copy` trait
@@ -42,9 +50,13 @@ help: consider cloning the value if the performance cost is acceptable
    |
 LL |     dbg!(a, b.clone());
    |              ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     dbg!(a, &b);
+   |             +
 
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-issue-120327.rs:22:12
+  --> $DIR/dbg-issue-120327.rs:26:12
    |
 LL | fn x(a: String) -> String {
    |      - move occurs because `a` has type `String`, which does not implement the `Copy` trait
@@ -58,47 +70,52 @@ help: consider cloning the value if the performance cost is acceptable
    |
 LL |     dbg!(a.clone(), b);
    |           ++++++++
-
-error[E0382]: use of moved value: `b`
-  --> $DIR/dbg-issue-120327.rs:46:12
-   |
-LL |             tmp => {
-   |             --- value moved here
-...
-LL |     let b: String = "".to_string();
-   |         - move occurs because `b` has type `String`, which does not implement the `Copy` trait
-LL |     my_dbg!(b, 1);
-LL |     return b;
-   |            ^ value used here after move
-   |
 help: consider borrowing instead of transferring ownership
    |
-LL |     my_dbg!(&b, 1);
-   |             +
-help: borrow this binding in the pattern to avoid moving the value
-   |
-LL |             ref tmp => {
-   |             +++
+LL |     dbg!(&a, b);
+   |          +
 
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-issue-120327.rs:57:12
+  --> $DIR/dbg-issue-120327.rs:30:13
    |
-LL |     let a = String::new();
-   |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
-LL |     let _b = match a {
-LL |         tmp => {
-   |         --- value moved here
+LL | fn two_of_them(a: String) -> String {
+   |                - move occurs because `a` has type `String`, which does not implement the `Copy` trait
+LL |     dbg!(a, a);
+   |          -  ^ value used here after move
+   |          |
+   |          value moved here
+   |
+help: consider cloning the value if the performance cost is acceptable
+   |
+LL |     dbg!(a.clone(), a);
+   |           ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     dbg!(&a, a);
+   |          +
+
+error[E0382]: use of moved value: `a`
+  --> $DIR/dbg-issue-120327.rs:33:12
+   |
+LL | fn two_of_them(a: String) -> String {
+   |                - move occurs because `a` has type `String`, which does not implement the `Copy` trait
+LL |     dbg!(a, a);
+   |             - value moved here
 ...
 LL |     return a;
    |            ^ value used here after move
    |
-help: borrow this binding in the pattern to avoid moving the value
+help: consider cloning the value if the performance cost is acceptable
    |
-LL |         ref tmp => {
-   |         +++
+LL |     dbg!(a, a.clone());
+   |              ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     dbg!(a, &a);
+   |             +
 
 error[E0382]: borrow of moved value: `a`
-  --> $DIR/dbg-issue-120327.rs:65:14
+  --> $DIR/dbg-issue-120327.rs:42:14
    |
 LL |     let a: String = "".to_string();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
@@ -111,6 +128,10 @@ help: consider cloning the value if the performance cost is acceptable
    |
 LL |     let _res = get_expr(dbg!(a.clone()));
    |                               ++++++++
+help: consider borrowing instead of transferring ownership
+   |
+LL |     let _res = get_expr(dbg!(&a));
+   |                              +
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
index 76b2d1be2779..7ce5ebf81e31 100644
--- a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
+++ b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
@@ -16,6 +16,10 @@ LL | struct NoCopy(usize);
 ...
 LL |     let _ = dbg!(a);
    |                  - you could clone this value
+help: consider borrowing instead of transferring ownership
+   |
+LL |     let _ = dbg!(&a);
+   |                  +
 
 error: aborting due to 1 previous error
 

From dae0c011084c7877b47dda1e7514fa7685c94e9a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 29 Mar 2026 18:25:55 +0000
Subject: [PATCH 1046/1059] Tweak wording of E0275 WF errors

Modify the main error message to read better:

```
error[E0275]: overflow evaluating whether `&'a mut Bar` is well-formed
```
---
 .../src/error_reporting/traits/overflow.rs             |  9 +++++++++
 tests/ui/associated-types/issue-64855-2.rs             |  2 +-
 tests/ui/associated-types/issue-64855-2.stderr         |  2 +-
 tests/ui/associated-types/issue-64855.rs               |  2 +-
 tests/ui/associated-types/issue-64855.stderr           |  2 +-
 .../const-generics/generic_const_exprs/adt_wf_hang.rs  |  2 +-
 .../generic_const_exprs/adt_wf_hang.stderr             |  2 +-
 .../ui/const-generics/mgca/const-ctor-overflow-eval.rs | 10 +++++-----
 .../mgca/const-ctor-overflow-eval.stderr               | 10 +++++-----
 tests/ui/higher-ranked/trait-bounds/issue-95230.rs     |  2 +-
 tests/ui/higher-ranked/trait-bounds/issue-95230.stderr |  2 +-
 tests/ui/traits/next-solver/alias-bound-unsound.rs     |  4 ++--
 tests/ui/traits/next-solver/alias-bound-unsound.stderr |  4 ++--
 .../item-bound-via-impl-where-clause.next.stderr       |  2 +-
 .../coinduction/item-bound-via-impl-where-clause.rs    |  2 +-
 .../next-solver/normalize/normalize-param-env-2.stderr |  2 +-
 16 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
index a0876d8fe759..a543f549bdae 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
@@ -99,6 +99,15 @@ fn with_short_path<'tcx, T>(tcx: TyCtxt<'tcx>, value: T) -> String
                             "overflow assigning `{a}` to `{b}`",
                         )
                     }
+                    ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(term)) => {
+                        let term = with_short_path(self.tcx, term);
+                        struct_span_code_err!(
+                            self.dcx(),
+                            span,
+                            E0275,
+                            "overflow evaluating whether `{term}` is well-formed",
+                        )
+                    }
                     _ => {
                         let pred_str = with_short_path(self.tcx, predicate);
                         struct_span_code_err!(
diff --git a/tests/ui/associated-types/issue-64855-2.rs b/tests/ui/associated-types/issue-64855-2.rs
index 20b8ff17e9e5..5509ebb2e4e9 100644
--- a/tests/ui/associated-types/issue-64855-2.rs
+++ b/tests/ui/associated-types/issue-64855-2.rs
@@ -3,6 +3,6 @@
 // also inadvertently a test for the (non-)co-inductiveness of WF predicates.
 
 pub struct Bar<'a>(&'a Self) where Self: ;
-//~^ ERROR overflow evaluating the requirement `Bar<'a> well-formed`
+//~^ ERROR overflow evaluating whether `Bar<'a>` is well-formed
 
 fn main() {}
diff --git a/tests/ui/associated-types/issue-64855-2.stderr b/tests/ui/associated-types/issue-64855-2.stderr
index 22292a8721a1..75da64505916 100644
--- a/tests/ui/associated-types/issue-64855-2.stderr
+++ b/tests/ui/associated-types/issue-64855-2.stderr
@@ -1,4 +1,4 @@
-error[E0275]: overflow evaluating the requirement `Bar<'a> well-formed`
+error[E0275]: overflow evaluating whether `Bar<'a>` is well-formed
   --> $DIR/issue-64855-2.rs:5:36
    |
 LL | pub struct Bar<'a>(&'a Self) where Self: ;
diff --git a/tests/ui/associated-types/issue-64855.rs b/tests/ui/associated-types/issue-64855.rs
index 5d325b981a2c..003f11f4a509 100644
--- a/tests/ui/associated-types/issue-64855.rs
+++ b/tests/ui/associated-types/issue-64855.rs
@@ -8,6 +8,6 @@ pub trait Foo {
 
 pub struct Bar<T>(<Self as Foo>::Type) where Self: ;
 //~^ ERROR the trait bound `Bar<T>: Foo` is not satisfied
-//~| ERROR overflow evaluating the requirement `Bar<T> well-formed`
+//~| ERROR overflow evaluating whether `Bar<T>` is well-formed
 
 fn main() {}
diff --git a/tests/ui/associated-types/issue-64855.stderr b/tests/ui/associated-types/issue-64855.stderr
index 4358ab473651..9472dbf6adb6 100644
--- a/tests/ui/associated-types/issue-64855.stderr
+++ b/tests/ui/associated-types/issue-64855.stderr
@@ -15,7 +15,7 @@ help: this trait has no implementations, consider adding one
 LL | pub trait Foo {
    | ^^^^^^^^^^^^^
 
-error[E0275]: overflow evaluating the requirement `Bar<T> well-formed`
+error[E0275]: overflow evaluating whether `Bar<T>` is well-formed
   --> $DIR/issue-64855.rs:9:46
    |
 LL | pub struct Bar<T>(<Self as Foo>::Type) where Self: ;
diff --git a/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.rs b/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.rs
index 5d538d2679dd..1516b0571490 100644
--- a/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.rs
+++ b/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.rs
@@ -9,6 +9,6 @@
 struct S<const N: U>()
 where
     S<{ U }>:;
-//~^ ERROR: overflow evaluating the requirement `S<{ U }> well-formed`
+//~^ ERROR: overflow evaluating whether `S<{ U }>` is well-formed
 
 fn main() {}
diff --git a/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.stderr b/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.stderr
index b244acb37dde..1eb2890d4cbc 100644
--- a/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/adt_wf_hang.stderr
@@ -1,4 +1,4 @@
-error[E0275]: overflow evaluating the requirement `S<{ U }> well-formed`
+error[E0275]: overflow evaluating whether `S<{ U }>` is well-formed
   --> $DIR/adt_wf_hang.rs:11:5
    |
 LL |     S<{ U }>:;
diff --git a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs
index 6a4ee3ed1772..ec74a6e53012 100644
--- a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs
+++ b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.rs
@@ -6,14 +6,14 @@
 struct U;
 
 #[derive(ConstParamTy, PartialEq, Eq)]
-//~^ ERROR overflow evaluating the requirement `S<U> well-formed`
-//~| ERROR overflow evaluating the requirement `S<U> well-formed`
+//~^ ERROR overflow evaluating whether `S<U>` is well-formed
+//~| ERROR overflow evaluating whether `S<U>` is well-formed
 
 struct S<const N: U>()
 where
     S<{ U }>:;
-//~^ ERROR overflow evaluating the requirement `S<U> well-formed`
-//~| ERROR overflow evaluating the requirement `S<U> well-formed`
-//~| ERROR overflow evaluating the requirement `S<U> well-formed`
+//~^ ERROR overflow evaluating whether `S<U>` is well-formed
+//~| ERROR overflow evaluating whether `S<U>` is well-formed
+//~| ERROR overflow evaluating whether `S<U>` is well-formed
 
 fn main() {}
diff --git a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr
index 4c5ad645bc45..bb393cad567e 100644
--- a/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr
+++ b/tests/ui/const-generics/mgca/const-ctor-overflow-eval.stderr
@@ -1,4 +1,4 @@
-error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+error[E0275]: overflow evaluating whether `S<U>` is well-formed
   --> $DIR/const-ctor-overflow-eval.rs:14:5
    |
 LL |     S<{ U }>:;
@@ -13,7 +13,7 @@ LL | where
 LL |     S<{ U }>:;
    |     ^^^^^^^^ required by this bound in `S`
 
-error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+error[E0275]: overflow evaluating whether `S<U>` is well-formed
   --> $DIR/const-ctor-overflow-eval.rs:14:5
    |
 LL |     S<{ U }>:;
@@ -29,7 +29,7 @@ LL |     S<{ U }>:;
    |     ^^^^^^^^ required by this bound in `S`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+error[E0275]: overflow evaluating whether `S<U>` is well-formed
   --> $DIR/const-ctor-overflow-eval.rs:14:5
    |
 LL |     S<{ U }>:;
@@ -45,7 +45,7 @@ LL |     S<{ U }>:;
    |     ^^^^^^^^ required by this bound in `S`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+error[E0275]: overflow evaluating whether `S<U>` is well-formed
   --> $DIR/const-ctor-overflow-eval.rs:8:24
    |
 LL | #[derive(ConstParamTy, PartialEq, Eq)]
@@ -60,7 +60,7 @@ LL | where
 LL |     S<{ U }>:;
    |     ^^^^^^^^ required by this bound in `S`
 
-error[E0275]: overflow evaluating the requirement `S<U> well-formed`
+error[E0275]: overflow evaluating whether `S<U>` is well-formed
   --> $DIR/const-ctor-overflow-eval.rs:8:35
    |
 LL | #[derive(ConstParamTy, PartialEq, Eq)]
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-95230.rs b/tests/ui/higher-ranked/trait-bounds/issue-95230.rs
index 821a04ff0655..b0f623ce3321 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-95230.rs
+++ b/tests/ui/higher-ranked/trait-bounds/issue-95230.rs
@@ -5,6 +5,6 @@
 pub struct Bar
 where
     for<'a> &'a mut Self:;
-//~^ ERROR overflow evaluating the requirement `for<'a> &'a mut Bar well-formed`
+//~^ ERROR: overflow evaluating whether `&'a mut Bar` is well-formed
 
 fn main() {}
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-95230.stderr b/tests/ui/higher-ranked/trait-bounds/issue-95230.stderr
index 7070af75d290..9e85c689f69d 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-95230.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/issue-95230.stderr
@@ -1,4 +1,4 @@
-error[E0275]: overflow evaluating the requirement `for<'a> &'a mut Bar well-formed`
+error[E0275]: overflow evaluating whether `&'a mut Bar` is well-formed
   --> $DIR/issue-95230.rs:7:13
    |
 LL |     for<'a> &'a mut Self:;
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.rs b/tests/ui/traits/next-solver/alias-bound-unsound.rs
index 7b91078c639e..b2015b336b24 100644
--- a/tests/ui/traits/next-solver/alias-bound-unsound.rs
+++ b/tests/ui/traits/next-solver/alias-bound-unsound.rs
@@ -26,8 +26,8 @@ impl Foo for () {
 fn main() {
     let x = String::from("hello, world");
     let _ = identity(<() as Foo>::copy_me(&x));
-    //~^ ERROR overflow evaluating the requirement `<() as Foo>::Item well-formed`
-    //~| ERROR overflow evaluating the requirement `&<() as Foo>::Item well-formed`
+    //~^ ERROR overflow evaluating whether `<() as Foo>::Item` is well-formed
+    //~| ERROR overflow evaluating whether `&<() as Foo>::Item` is well-formed
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == String`
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.stderr b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
index 3509aea717ef..ebfaf469ddf8 100644
--- a/tests/ui/traits/next-solver/alias-bound-unsound.stderr
+++ b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
@@ -32,13 +32,13 @@ LL |     let _ = identity(<() as Foo>::copy_me(&x));
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error[E0275]: overflow evaluating the requirement `&<() as Foo>::Item well-formed`
+error[E0275]: overflow evaluating whether `&<() as Foo>::Item` is well-formed
   --> $DIR/alias-bound-unsound.rs:28:43
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
    |                                           ^^
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item well-formed`
+error[E0275]: overflow evaluating whether `<() as Foo>::Item` is well-formed
   --> $DIR/alias-bound-unsound.rs:28:22
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
index 451c1442ed29..ed6e595d0afb 100644
--- a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
+++ b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
@@ -30,7 +30,7 @@ LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
    |
    = note: the return type of a function must have a statically known size
 
-error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof well-formed`
+error[E0275]: overflow evaluating whether `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof` is well-formed
   --> $DIR/item-bound-via-impl-where-clause.rs:31:21
    |
 LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
index 39381d17f7af..6ac0c1481c79 100644
--- a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
+++ b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
@@ -33,7 +33,7 @@ fn main() {
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == String`
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof: Sized`
-    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof well-formed`
+    //[next]~| ERROR overflow evaluating whether `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof` is well-formed
     //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
     println!("{}", s); // ABC
 }
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr
index 82a5f33628e6..cb1bbd4c6171 100644
--- a/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr
+++ b/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr
@@ -27,7 +27,7 @@ error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc: A<T>`
 LL |         Self::Assoc: A<T>,
    |                      ^^^^
 
-error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc well-formed`
+error[E0275]: overflow evaluating whether `<() as A<T>>::Assoc` is well-formed
   --> $DIR/normalize-param-env-2.rs:24:22
    |
 LL |         Self::Assoc: A<T>,

From 0740609ea38a7274911952fa90c28b89c71f6611 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 29 Mar 2026 21:07:47 +0000
Subject: [PATCH 1047/1059] Point at binop lhs and rhs when expression is
 multiline

```
error[E0277]: cannot add `()` to `u32`
  --> $DIR/multiline-span-simple.rs:13:18
   |
LL |       foo(1 as u32 +
   |           -------- ^ no implementation for `u32 + ()`
LL |
LL | /         bar(x,
LL | |
LL | |             y),
   | |______________-
```
---
 .../src/error_reporting/traits/suggestions.rs         | 11 ++++++++++-
 tests/ui/span/multiline-span-simple.stderr            |  9 +++++++--
 tests/ui/typeck/unit-type-add-error-11771.stderr      |  8 ++++++--
 3 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 4a6d5eb48f8f..93afa1bf5f26 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -2916,12 +2916,21 @@ pub(super) fn note_obligation_cause_code<G: EmissionGuarantee, T>(
             | ObligationCauseCode::CheckAssociatedTypeBounds { .. }
             | ObligationCauseCode::LetElse
             | ObligationCauseCode::UnOp { .. }
-            | ObligationCauseCode::BinOp { .. }
             | ObligationCauseCode::AscribeUserTypeProvePredicate(..)
             | ObligationCauseCode::AlwaysApplicableImpl
             | ObligationCauseCode::ConstParam(_)
             | ObligationCauseCode::ReferenceOutlivesReferent(..)
             | ObligationCauseCode::ObjectTypeBound(..) => {}
+            ObligationCauseCode::BinOp { lhs_hir_id, rhs_hir_id, .. } => {
+                if let hir::Node::Expr(lhs) = tcx.hir_node(lhs_hir_id)
+                    && let hir::Node::Expr(rhs) = tcx.hir_node(rhs_hir_id)
+                    && tcx.sess.source_map().lookup_char_pos(lhs.span.lo()).line
+                        != tcx.sess.source_map().lookup_char_pos(rhs.span.hi()).line
+                {
+                    err.span_label(lhs.span, "");
+                    err.span_label(rhs.span, "");
+                }
+            }
             ObligationCauseCode::RustCall => {
                 if let Some(pred) = predicate.as_trait_clause()
                     && tcx.is_lang_item(pred.def_id(), LangItem::Sized)
diff --git a/tests/ui/span/multiline-span-simple.stderr b/tests/ui/span/multiline-span-simple.stderr
index e013b3c06bc1..ea7aff370fe1 100644
--- a/tests/ui/span/multiline-span-simple.stderr
+++ b/tests/ui/span/multiline-span-simple.stderr
@@ -1,8 +1,13 @@
 error[E0277]: cannot add `()` to `u32`
   --> $DIR/multiline-span-simple.rs:13:18
    |
-LL |     foo(1 as u32 +
-   |                  ^ no implementation for `u32 + ()`
+LL |       foo(1 as u32 +
+   |           -------- ^ no implementation for `u32 + ()`
+LL |
+LL | /         bar(x,
+LL | |
+LL | |             y),
+   | |______________-
    |
    = help: the trait `Add<()>` is not implemented for `u32`
 help: the following other types implement trait `Add<Rhs>`
diff --git a/tests/ui/typeck/unit-type-add-error-11771.stderr b/tests/ui/typeck/unit-type-add-error-11771.stderr
index 155cc0935245..4b8f59e543fa 100644
--- a/tests/ui/typeck/unit-type-add-error-11771.stderr
+++ b/tests/ui/typeck/unit-type-add-error-11771.stderr
@@ -2,7 +2,9 @@ error[E0277]: cannot add `()` to `{integer}`
   --> $DIR/unit-type-add-error-11771.rs:5:7
    |
 LL |     1 +
-   |       ^ no implementation for `{integer} + ()`
+   |     - ^ no implementation for `{integer} + ()`
+LL |     x
+   |     -
    |
    = help: the trait `Add<()>` is not implemented for `{integer}`
    = help: the following other types implement trait `Add<Rhs>`:
@@ -20,7 +22,9 @@ error[E0277]: cannot add `()` to `{integer}`
   --> $DIR/unit-type-add-error-11771.rs:10:7
    |
 LL |     1 +
-   |       ^ no implementation for `{integer} + ()`
+   |     - ^ no implementation for `{integer} + ()`
+LL |     x
+   |     -
    |
    = help: the trait `Add<()>` is not implemented for `{integer}`
    = help: the following other types implement trait `Add<Rhs>`:

From 6e984cd4bf5535d707b9eeacd023637f6031f1cb Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Sun, 29 Mar 2026 21:37:07 +0800
Subject: [PATCH 1048/1059] loongarch: use "_mcount" as the default mcount
 symbol

Set the `mcount` field to "_mcount" for all LoongArch targets to match
Clang/GCC behavior [1]. This fixes linking failures when using
`-Z instrument-mcount`, where the runtime expects "_mcount" instead of
"mcount".

[1] https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/Targets/LoongArch.h#L60
---
 .../rustc_target/src/spec/targets/loongarch32_unknown_none.rs    | 1 +
 .../src/spec/targets/loongarch32_unknown_none_softfloat.rs       | 1 +
 .../src/spec/targets/loongarch64_unknown_linux_gnu.rs            | 1 +
 .../src/spec/targets/loongarch64_unknown_linux_musl.rs           | 1 +
 .../src/spec/targets/loongarch64_unknown_linux_ohos.rs           | 1 +
 .../rustc_target/src/spec/targets/loongarch64_unknown_none.rs    | 1 +
 .../src/spec/targets/loongarch64_unknown_none_softfloat.rs       | 1 +
 7 files changed, 7 insertions(+)

diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
index 2a53d4256b76..7e074b73919f 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs
@@ -22,6 +22,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             llvm_abiname: LlvmAbi::Ilp32d,
             max_atomic_width: Some(32),
+            mcount: "_mcount".into(),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
index e9a9260db8ea..4e6807012e89 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs
@@ -23,6 +23,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             llvm_abiname: LlvmAbi::Ilp32s,
             max_atomic_width: Some(32),
+            mcount: "_mcount".into(),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             ..Default::default()
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
index 180d064570ab..8dad88bfc46f 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs
@@ -20,6 +20,7 @@ pub(crate) fn target() -> Target {
             features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
+            mcount: "_mcount".into(),
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI
                 | SanitizerSet::LEAK
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
index 246e28a243af..91a028988548 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs
@@ -20,6 +20,7 @@ pub(crate) fn target() -> Target {
             features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
+            mcount: "_mcount".into(),
             crt_static_default: false,
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
index 461a7bd26268..679235673488 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs
@@ -20,6 +20,7 @@ pub(crate) fn target() -> Target {
             features: "+f,+d,+lsx,+relax".into(),
             llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
+            mcount: "_mcount".into(),
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI
                 | SanitizerSet::LEAK
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
index 2a9f0dcfd2ef..2d3b217e7789 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
@@ -22,6 +22,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             llvm_abiname: LlvmAbi::Lp64d,
             max_atomic_width: Some(64),
+            mcount: "_mcount".into(),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             code_model: Some(CodeModel::Medium),
diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
index efed9778caab..f5e2fb4eb832 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs
@@ -23,6 +23,7 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             llvm_abiname: LlvmAbi::Lp64s,
             max_atomic_width: Some(64),
+            mcount: "_mcount".into(),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             code_model: Some(CodeModel::Medium),

From 77199806b7ca6ccbe57e5692e861d6bab131b10e Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 30 Mar 2026 05:38:07 +0000
Subject: [PATCH 1049/1059] Prepare for merging from rust-lang/rust

This updates the rust-version file to 116458d0a5ae01cd517cabd2d1aee7f5457018ab.
---
 src/tools/miri/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index c98397c1c67f..85571d95f742 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-148adf223edb0444eb1f99753919dd2080c2a534
+116458d0a5ae01cd517cabd2d1aee7f5457018ab

From 29710ca2705f5b87d217f6a36b4a9afbd0bc87f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 27 Jan 2026 16:09:52 +0100
Subject: [PATCH 1050/1059] remove debug requirement from hooks

---
 compiler/rustc_middle/src/hooks/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 0ddcdac817b8..1a7a8f5cae60 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -35,8 +35,10 @@ pub struct Providers {
 
         impl Default for Providers {
             fn default() -> Self {
+                #[allow(unused)]
                 Providers {
-                    $($name: |_, $($arg,)*| default_hook(stringify!($name), &($($arg,)*))),*
+                    $($name:
+                        |_, $($arg,)*| default_hook(stringify!($name))),*
                 }
             }
         }
@@ -118,8 +120,6 @@ fn clone(&self) -> Self { *self }
 }
 
 #[cold]
-fn default_hook(name: &str, args: &dyn std::fmt::Debug) -> ! {
-    bug!(
-        "`tcx.{name}{args:?}` cannot be called as `{name}` was never assigned to a provider function"
-    )
+fn default_hook(name: &str) -> ! {
+    bug!("`tcx.{name}` cannot be called as `{name}` was never assigned to a provider function")
 }

From bf42a53bf7de0171ad8191abf7fc7f86ab8d4d6b Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 30 Mar 2026 09:15:22 +0000
Subject: [PATCH 1051/1059] delete several `ui/consts` tests

---
 tests/ui/consts/const-bound.rs             | 19 -------------------
 tests/ui/consts/const-enum-tuple.rs        | 11 -----------
 tests/ui/consts/const-enum-tuple2.rs       | 11 -----------
 tests/ui/consts/const-enum-tuplestruct2.rs | 12 ------------
 tests/ui/consts/const.rs                   |  6 ------
 5 files changed, 59 deletions(-)
 delete mode 100644 tests/ui/consts/const-bound.rs
 delete mode 100644 tests/ui/consts/const-enum-tuple.rs
 delete mode 100644 tests/ui/consts/const-enum-tuple2.rs
 delete mode 100644 tests/ui/consts/const-enum-tuplestruct2.rs
 delete mode 100644 tests/ui/consts/const.rs

diff --git a/tests/ui/consts/const-bound.rs b/tests/ui/consts/const-bound.rs
deleted file mode 100644
index 00a833ba3f79..000000000000
--- a/tests/ui/consts/const-bound.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-// Make sure const bounds work on things, and test that a few types
-// are const.
-
-
-fn foo<T: Sync>(x: T) -> T { x }
-
-struct F { field: isize }
-
-pub fn main() {
-    /*foo(1);
-    foo("hi".to_string());
-    foo(vec![1, 2, 3]);
-    foo(F{field: 42});
-    foo((1, 2));
-    foo(@1);*/
-    foo(Box::new(1));
-}
diff --git a/tests/ui/consts/const-enum-tuple.rs b/tests/ui/consts/const-enum-tuple.rs
deleted file mode 100644
index fe6b54aa7935..000000000000
--- a/tests/ui/consts/const-enum-tuple.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-enum E { V16(u16), V32(u32) }
-static C: (E, u16, u16) = (E::V16(0xDEAD), 0x600D, 0xBAD);
-
-pub fn main() {
-    let (_, n, _) = C;
-    assert!(n != 0xBAD);
-    assert_eq!(n, 0x600D);
-}
diff --git a/tests/ui/consts/const-enum-tuple2.rs b/tests/ui/consts/const-enum-tuple2.rs
deleted file mode 100644
index 713209943d3e..000000000000
--- a/tests/ui/consts/const-enum-tuple2.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-enum E { V0, V16(u16) }
-static C: (E, u16, u16) = (E::V0, 0x600D, 0xBAD);
-
-pub fn main() {
-    let (_, n, _) = C;
-    assert!(n != 0xBAD);
-    assert_eq!(n, 0x600D);
-}
diff --git a/tests/ui/consts/const-enum-tuplestruct2.rs b/tests/ui/consts/const-enum-tuplestruct2.rs
deleted file mode 100644
index dc4453236952..000000000000
--- a/tests/ui/consts/const-enum-tuplestruct2.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-enum E { V0, V16(u16) }
-struct S(E, u16, u16);
-static C: S = S(E::V0, 0x600D, 0xBAD);
-
-pub fn main() {
-    let S(_, n, _) = C;
-    assert!(n != 0xBAD);
-    assert_eq!(n, 0x600D);
-}
diff --git a/tests/ui/consts/const.rs b/tests/ui/consts/const.rs
deleted file mode 100644
index 1f1c6e30b4a0..000000000000
--- a/tests/ui/consts/const.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ run-pass
-#![allow(non_upper_case_globals)]
-
-static i: isize = 10;
-
-pub fn main() { println!("{}", i); }

From e61842d378622d3bbb9271b6edc9b01872c43665 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Mon, 30 Mar 2026 10:54:46 +0000
Subject: [PATCH 1052/1059] Update `mir-opt` 64-bit panic-abort tests for
 `Alignment` rename

These seem to have been missed when the PR originally merged.
---
 ...without_updating_operand.test.GVN.64bit.panic-abort.diff | 2 +-
 ...8_print_invalid_constant.main.GVN.64bit.panic-abort.diff | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
index 88fb27386218..0219db325c8f 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
@@ -51,7 +51,7 @@
           StorageLive(_12);
           StorageLive(_13);
 -         _13 = boxed::box_new_uninit(const <() as std::mem::SizedTypeProperties>::LAYOUT) -> [return: bb2, unwind unreachable];
-+         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::mem::Alignment {{ _inner_repr_trick: std::ptr::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
++         _13 = boxed::box_new_uninit(const Layout {{ size: 0_usize, align: std::mem::Alignment {{ _inner_repr_trick: mem::alignment::AlignmentEnum::_Align1Shl0 }} }}) -> [return: bb2, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index 139cf2116fc4..11d64d05c7d1 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
@@ -63,7 +63,7 @@
   
       bb3: {
 -         _1 = move ((_2 as Some).0: std::alloc::Layout);
-+         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
++         _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }};
           StorageDead(_8);
           StorageDead(_2);
           StorageLive(_3);
@@ -73,8 +73,8 @@
           StorageLive(_7);
 -         _7 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable];
-+         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }};
-+         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
++         _7 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }};
++         _6 = std::alloc::Global::alloc_impl_runtime(const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::mem::Alignment {{ _inner_repr_trick: Scalar(0x0000000000000000): mem::alignment::AlignmentEnum }} }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {

From 02611d8d3fc12f5be01773ba793b0bcb275b1f08 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 21 Mar 2026 15:38:11 +0100
Subject: [PATCH 1053/1059] aarch64: add shims for pairwise widening/wrapping
 addition

---
 src/tools/miri/src/shims/aarch64.rs           | 87 ++++++++++++++++++
 .../shims/aarch64/intrinsics-aarch64-neon.rs  | 92 +++++++++++++++++++
 2 files changed, 179 insertions(+)

diff --git a/src/tools/miri/src/shims/aarch64.rs b/src/tools/miri/src/shims/aarch64.rs
index b96d1b1a38dd..6a914d5cfa68 100644
--- a/src/tools/miri/src/shims/aarch64.rs
+++ b/src/tools/miri/src/shims/aarch64.rs
@@ -59,6 +59,93 @@ fn emulate_aarch64_intrinsic(
                     this.write_immediate(*res_lane, &dest)?;
                 }
             }
+
+            // Wrapping pairwise addition.
+            //
+            // Concatenates the two input vectors and adds adjacent elements. For input vectors `v`
+            // and `w` this computes `[v0 + v1, v2 + v3, ..., w0 + w1, w2 + w3, ...]`, using
+            // wrapping addition for `+`.
+            //
+            // Used by `vpadd_{s8, u8, s16, u16, s32, u32}`.
+            name if name.starts_with("neon.addp.") => {
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(left_len, dest_len);
+
+                assert_eq!(left.layout, right.layout);
+                assert_eq!(left.layout, dest.layout);
+
+                assert!(dest_len.is_multiple_of(2));
+                let half_len = dest_len.strict_div(2);
+
+                for lane_idx in 0..dest_len {
+                    // The left and right vectors are concatenated.
+                    let (src, src_pair_idx) = if lane_idx < half_len {
+                        (&left, lane_idx)
+                    } else {
+                        (&right, lane_idx.strict_sub(half_len))
+                    };
+                    // Convert "pair index" into "index of first element of the pair".
+                    let i = src_pair_idx.strict_mul(2);
+
+                    let lhs = this.read_immediate(&this.project_index(src, i)?)?;
+                    let rhs = this.read_immediate(&this.project_index(src, i.strict_add(1))?)?;
+
+                    // Wrapping addition on the element type.
+                    let sum = this.binary_op(BinOp::Add, &lhs, &rhs)?;
+
+                    let dst_lane = this.project_index(&dest, lane_idx)?;
+                    this.write_immediate(*sum, &dst_lane)?;
+                }
+            }
+
+            // Widening pairwise addition.
+            //
+            // Takes a single input vector, and an output vector with half as many lanes and double
+            // the element width. Takes adjacent pairs of elements, widens both, and then adds them
+            // together.
+            //
+            // Used by `vpaddl_{u8, u16, u32}` and `vpaddlq_{u8, u16, u32}`.
+            name if name.starts_with("neon.uaddlp.") => {
+                let [src] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (src, src_len) = this.project_to_simd(src)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                // Operates pairwise, so src has twice as many lanes.
+                assert_eq!(src_len, dest_len.strict_mul(2));
+
+                let src_elem_size = src.layout.field(this, 0).size;
+                let dest_elem_size = dest.layout.field(this, 0).size;
+
+                // Widens, so dest elements must be exactly twice as wide.
+                assert_eq!(dest_elem_size.bytes(), src_elem_size.bytes().strict_mul(2));
+
+                for dest_idx in 0..dest_len {
+                    let src_idx = dest_idx.strict_mul(2);
+
+                    let a_scalar = this.read_scalar(&this.project_index(&src, src_idx)?)?;
+                    let b_scalar =
+                        this.read_scalar(&this.project_index(&src, src_idx.strict_add(1))?)?;
+
+                    let a_val = a_scalar.to_uint(src_elem_size)?;
+                    let b_val = b_scalar.to_uint(src_elem_size)?;
+
+                    // Use addition on u128 to simulate widening addition for the destination type.
+                    // This cannot wrap since the element type is at most u64.
+                    let sum = a_val.strict_add(b_val);
+
+                    let dst_lane = this.project_index(&dest, dest_idx)?;
+                    this.write_scalar(Scalar::from_uint(sum, dest_elem_size), &dst_lane)?;
+                }
+            }
+
             // Vector table lookup: each index selects a byte from the 16-byte table, out-of-range -> 0.
             // Used to implement vtbl1_u8 function.
             // LLVM does not have a portable shuffle that takes non-const indices
diff --git a/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs
index 6d3f153e194f..884f8eff41bd 100644
--- a/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs
+++ b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs
@@ -12,6 +12,8 @@ fn main() {
     unsafe {
         test_vpmaxq_u8();
         test_tbl1_v16i8_basic();
+        test_vpadd();
+        test_vpaddl();
     }
 }
 
@@ -65,3 +67,93 @@ fn test_tbl1_v16i8_basic() {
         assert_eq!(&got2_arr[3..16], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12][..]);
     }
 }
+#[target_feature(enable = "neon")]
+unsafe fn test_vpadd() {
+    let a = vld1_s8([1, 2, 3, 4, 5, 6, 7, 8].as_ptr());
+    let b = vld1_s8([9, 10, -1, 2, i8::MIN, i8::MIN, i8::MAX, i8::MAX].as_ptr());
+    let e =
+        [3i8, 7, 11, 15, 19, -1 + 2, i8::MIN.wrapping_add(i8::MIN), i8::MAX.wrapping_add(i8::MAX)];
+    let mut r = [0i8; 8];
+    vst1_s8(r.as_mut_ptr(), vpadd_s8(a, b));
+    assert_eq!(r, e);
+
+    let a = vld1_s16([1, 2, 3, 4].as_ptr());
+    let b = vld1_s16([-1, 2, i16::MAX, i16::MAX].as_ptr());
+    let e = [3i16, 7, -1 + 2, i16::MAX.wrapping_add(i16::MAX)];
+    let mut r = [0i16; 4];
+    vst1_s16(r.as_mut_ptr(), vpadd_s16(a, b));
+    assert_eq!(r, e);
+
+    let a = vld1_s32([1, 2].as_ptr());
+    let b = vld1_s32([i32::MAX, i32::MAX].as_ptr());
+    let e = [3i32, i32::MAX.wrapping_add(i32::MAX)];
+    let mut r = [0i32; 2];
+    vst1_s32(r.as_mut_ptr(), vpadd_s32(a, b));
+    assert_eq!(r, e);
+
+    let a = vld1_u8([1, 2, 3, 4, 5, 6, 7, 8].as_ptr());
+    let b = vld1_u8([9, 10, 11, 12, 13, 14, u8::MAX, u8::MAX].as_ptr());
+    let e = [3u8, 7, 11, 15, 19, 23, 27, 254];
+    let mut r = [0u8; 8];
+    vst1_u8(r.as_mut_ptr(), vpadd_u8(a, b));
+    assert_eq!(r, e);
+
+    let a = vld1_u16([1, 2, 3, 4].as_ptr());
+    let b = vld1_u16([5, 6, u16::MAX, u16::MAX].as_ptr());
+    let e = [3u16, 7, 11, 65534];
+    let mut r = [0u16; 4];
+    vst1_u16(r.as_mut_ptr(), vpadd_u16(a, b));
+    assert_eq!(r, e);
+
+    let a = vld1_u32([1, 2].as_ptr());
+    let b = vld1_u32([u32::MAX, u32::MAX].as_ptr());
+    let e = [3u32, u32::MAX.wrapping_add(u32::MAX)];
+    let mut r = [0u32; 2];
+    vst1_u32(r.as_mut_ptr(), vpadd_u32(a, b));
+    assert_eq!(r, e);
+}
+
+#[target_feature(enable = "neon")]
+unsafe fn test_vpaddl() {
+    let a = vld1_u8([1, 2, 3, 4, 5, 6, u8::MAX, u8::MAX].as_ptr());
+    let e = [3u16, 7, 11, 510];
+    let mut r = [0u16; 4];
+    vst1_u16(r.as_mut_ptr(), vpaddl_u8(a));
+    assert_eq!(r, e);
+
+    let a = vld1q_u8([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, u8::MAX, u8::MAX].as_ptr());
+    let e = [3u16, 7, 11, 15, 19, 23, 27, 510];
+    let mut r = [0u16; 8];
+    vst1q_u16(r.as_mut_ptr(), vpaddlq_u8(a));
+    assert_eq!(r, e);
+
+    let a = vld1_u16([1, 2, u16::MAX, u16::MAX].as_ptr());
+    let e = [3u32, 131070];
+    let mut r = [0u32; 2];
+    vst1_u32(r.as_mut_ptr(), vpaddl_u16(a));
+    assert_eq!(r, e);
+
+    let a = vld1q_u16([1, 2, 3, 4, 5, 6, u16::MAX, u16::MAX].as_ptr());
+    let e = [3u32, 7, 11, 131070];
+    let mut r = [0u32; 4];
+    vst1q_u32(r.as_mut_ptr(), vpaddlq_u16(a));
+    assert_eq!(r, e);
+
+    let a = vld1_u32([1, 2].as_ptr());
+    let e = [3u64];
+    let mut r = [0u64; 1];
+    vst1_u64(r.as_mut_ptr(), vpaddl_u32(a));
+    assert_eq!(r, e);
+
+    let a = vld1_u32([u32::MAX, u32::MAX].as_ptr());
+    let e = [8589934590];
+    let mut r = [0u64; 1];
+    vst1_u64(r.as_mut_ptr(), vpaddl_u32(a));
+    assert_eq!(r, e);
+
+    let a = vld1q_u32([1, 2, u32::MAX, u32::MAX].as_ptr());
+    let e = [3u64, 8589934590];
+    let mut r = [0u64; 2];
+    vst1q_u64(r.as_mut_ptr(), vpaddlq_u32(a));
+    assert_eq!(r, e);
+}

From 79d00dbf251cc14886b9b71b902659d5cf65f80d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 30 Mar 2026 14:48:37 +0200
Subject: [PATCH 1054/1059] update lockfile

---
 Cargo.lock | 53 +++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 41 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d4c1a02c018a..8b3792cef61b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3421,14 +3421,14 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.11"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b881c015c729b43105bbd3702a9bdecee28fafaa21126d1d62e454ec011a4b7"
+checksum = "eec3905e8201688412f6f4b1f6c86d38b3ee6578f59ba85f41330a3af61e8365"
 dependencies = [
  "anyhow",
  "rustc_version",
  "tempfile",
- "toml 0.8.23",
+ "toml 1.1.0+spec-1.1.0",
  "walkdir",
 ]
 
@@ -5195,9 +5195,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "1.0.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
+checksum = "876ac351060d4f882bb1032b6369eb0aef79ad9df1ea8bc404874d8cc3d0cd98"
 dependencies = [
  "serde_core",
 ]
@@ -5693,7 +5693,6 @@ version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
- "indexmap",
  "serde",
  "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
@@ -5708,13 +5707,28 @@ checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
 dependencies = [
  "indexmap",
  "serde_core",
- "serde_spanned 1.0.3",
+ "serde_spanned 1.1.0",
  "toml_datetime 0.7.3",
  "toml_parser",
  "toml_writer",
  "winnow 0.7.13",
 ]
 
+[[package]]
+name = "toml"
+version = "1.1.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8195ca05e4eb728f4ba94f3e3291661320af739c4e43779cbdfae82ab239fcc"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned 1.1.0",
+ "toml_datetime 1.1.0+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 1.0.0",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.11"
@@ -5733,6 +5747,15 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "toml_datetime"
+version = "1.1.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "toml_edit"
 version = "0.19.15"
@@ -5762,11 +5785,11 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.0.4"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011"
 dependencies = [
- "winnow 0.7.13",
+ "winnow 1.0.0",
 ]
 
 [[package]]
@@ -5777,9 +5800,9 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "toml_writer"
-version = "1.0.4"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+checksum = "d282ade6016312faf3e41e57ebbba0c073e4056dab1232ab1cb624199648f8ed"
 
 [[package]]
 name = "tracing"
@@ -6765,6 +6788,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "winnow"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
+
 [[package]]
 name = "winsplit"
 version = "0.1.0"

From 75eeece98c6fc71bd076f3dad2d6808b15ea95f3 Mon Sep 17 00:00:00 2001
From: khyperia <953151+khyperia@users.noreply.github.com>
Date: Mon, 30 Mar 2026 15:47:49 +0200
Subject: [PATCH 1055/1059] Properly generalize unevaluated consts

---
 .../src/infer/relate/generalize.rs            | 352 ++++++++++--------
 compiler/rustc_infer/src/infer/unify_key.rs   |   7 +
 compiler/rustc_middle/src/ty/consts.rs        |   7 +
 .../occurs-check/associated-type.next.stderr  |   4 +-
 .../occurs-check/associated-type.old.stderr   |   4 +-
 .../mgca/free-const-recursive.rs              |  13 +
 .../mgca/free-const-recursive.stderr          |  15 +
 .../mgca/projection-const-recursive.rs        |  19 +
 .../mgca/projection-const-recursive.stderr    |  15 +
 .../ogca/coherence-ambiguous.rs               |   7 +-
 .../ogca/coherence-ambiguous.stderr           |  20 +
 .../structually-relate-aliases.stderr         |   2 +-
 .../issue-118950-root-region.stderr           |   2 +-
 13 files changed, 312 insertions(+), 155 deletions(-)
 create mode 100644 tests/ui/const-generics/mgca/free-const-recursive.rs
 create mode 100644 tests/ui/const-generics/mgca/free-const-recursive.stderr
 create mode 100644 tests/ui/const-generics/mgca/projection-const-recursive.rs
 create mode 100644 tests/ui/const-generics/mgca/projection-const-recursive.stderr
 create mode 100644 tests/ui/const-generics/ogca/coherence-ambiguous.stderr

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 69c090b662e5..3ab39e83f312 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -61,103 +61,13 @@ pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
     ) -> RelateResult<'tcx, ()> {
         debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
 
-        // Generalize `source_ty` depending on the current variance. As an example, assume
-        // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
-        // variable.
-        //
-        // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
-        // region/type inference variables.
-        //
-        // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
-        // `?1 <: ?3`.
-        let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
-            relation.span(),
-            relation.structurally_relate_aliases(),
-            target_vid,
+        self.instantiate_var(
+            relation,
+            target_is_expected,
+            target_vid.into(),
             instantiation_variance,
-            source_ty,
-        )?;
-
-        // Constrain `b_vid` to the generalized type `generalized_ty`.
-        if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
-            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
-        } else {
-            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
-        }
-
-        // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
-        //
-        // FIXME(#16847): This code is non-ideal because all these subtype
-        // relations wind up attributed to the same spans. We need
-        // to associate causes/spans with each of the relations in
-        // the stack to get this right.
-        if generalized_ty.is_ty_var() {
-            // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
-            // We can't instantiate `?0` here as that would result in a
-            // cyclic type. We instead delay the unification in case
-            // the alias can be normalized to something which does not
-            // mention `?0`.
-            if self.next_trait_solver() {
-                let (lhs, rhs, direction) = match instantiation_variance {
-                    ty::Invariant => {
-                        (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Equate)
-                    }
-                    ty::Covariant => {
-                        (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Subtype)
-                    }
-                    ty::Contravariant => {
-                        (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
-                    }
-                    ty::Bivariant => unreachable!("bivariant generalization"),
-                };
-
-                relation.register_predicates([ty::PredicateKind::AliasRelate(lhs, rhs, direction)]);
-            } else {
-                match source_ty.kind() {
-                    &ty::Alias(ty::Projection, data) => {
-                        // FIXME: This does not handle subtyping correctly, we could
-                        // instead create a new inference variable `?normalized_source`, emitting
-                        // `Projection(normalized_source, ?ty_normalized)` and
-                        // `?normalized_source <: generalized_ty`.
-                        relation.register_predicates([ty::ProjectionPredicate {
-                            projection_term: data.into(),
-                            term: generalized_ty.into(),
-                        }]);
-                    }
-                    // The old solver only accepts projection predicates for associated types.
-                    ty::Alias(ty::Inherent | ty::Free | ty::Opaque, _) => {
-                        return Err(TypeError::CyclicTy(source_ty));
-                    }
-                    _ => bug!("generalized `{source_ty:?} to infer, not an alias"),
-                }
-            }
-        } else {
-            // NOTE: The `instantiation_variance` is not the same variance as
-            // used by the relation. When instantiating `b`, `target_is_expected`
-            // is flipped and the `instantiation_variance` is also flipped. To
-            // constrain the `generalized_ty` while using the original relation,
-            // we therefore only have to flip the arguments.
-            //
-            // ```ignore (not code)
-            // ?a rel B
-            // instantiate_ty_var(?a, B) # expected and variance not flipped
-            // B' rel B
-            // ```
-            // or
-            // ```ignore (not code)
-            // A rel ?b
-            // instantiate_ty_var(?b, A) # expected and variance flipped
-            // A rel A'
-            // ```
-            if target_is_expected {
-                relation.relate(generalized_ty, source_ty)?;
-            } else {
-                debug!("flip relation");
-                relation.relate(source_ty, generalized_ty)?;
-            }
-        }
-
-        Ok(())
+            source_ty.into(),
+        )
     }
 
     /// Instantiates the const variable `target_vid` with the given constant.
@@ -204,54 +114,191 @@ pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'tcx>
     ) -> RelateResult<'tcx, ()> {
         // FIXME(generic_const_exprs): Occurs check failures for unevaluated
         // constants and generic expressions are not yet handled correctly.
-        let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
+        debug_assert!(
+            self.inner.borrow_mut().const_unification_table().probe_value(target_vid).is_unknown()
+        );
+
+        self.instantiate_var(
+            relation,
+            target_is_expected,
+            target_vid.into(),
+            ty::Invariant,
+            source_ct.into(),
+        )
+    }
+
+    #[instrument(level = "debug", skip(self, relation))]
+    fn instantiate_var<R: PredicateEmittingRelation<Self>>(
+        &self,
+        relation: &mut R,
+        target_is_expected: bool,
+        target_vid: TermVid,
+        instantiation_variance: ty::Variance,
+        source_term: Term<'tcx>,
+    ) -> RelateResult<'tcx, ()> {
+        // Generalize `source_term` depending on the current variance. As an example, assume
+        // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+        // variable.
+        //
+        // Then the `generalized_term` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+        // region/type inference variables.
+        //
+        // We then relate `generalized_term <: source_term`, adding constraints like `'x: '?2` and
+        // `?1 <: ?3`.
+        let Generalization { value_may_be_infer: generalized_term } = self.generalize(
             relation.span(),
             relation.structurally_relate_aliases(),
             target_vid,
-            ty::Invariant,
-            source_ct,
+            instantiation_variance,
+            source_term,
         )?;
 
-        debug_assert!(!generalized_ct.is_ct_infer());
+        // Constrain `b_vid` to the generalized type `generalized_term`.
+        self.union_var_term(target_vid, generalized_term);
 
-        self.inner
-            .borrow_mut()
-            .const_unification_table()
-            .union_value(target_vid, ConstVariableValue::Known { value: generalized_ct });
+        // Finally, relate `generalized_term` to `source_term`, as described in previous comment.
+        //
+        // FIXME(#16847): This code is non-ideal because all these subtype
+        // relations wind up attributed to the same spans. We need
+        // to associate causes/spans with each of the relations in
+        // the stack to get this right.
+        if generalized_term.is_infer() {
+            // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
+            // We can't instantiate `?0` here as that would result in a
+            // cyclic type. We instead delay the unification in case
+            // the alias can be normalized to something which does not
+            // mention `?0`.
+            if self.next_trait_solver() {
+                let (lhs, rhs, direction) = match instantiation_variance {
+                    ty::Invariant => {
+                        (generalized_term, source_term, AliasRelationDirection::Equate)
+                    }
+                    ty::Covariant => {
+                        (generalized_term, source_term, AliasRelationDirection::Subtype)
+                    }
+                    ty::Contravariant => {
+                        (source_term, generalized_term, AliasRelationDirection::Subtype)
+                    }
+                    ty::Bivariant => unreachable!("bivariant generalization"),
+                };
 
-        // Make sure that the order is correct when relating the
-        // generalized const and the source.
-        if target_is_expected {
-            relation.relate_with_variance(
-                ty::Invariant,
-                ty::VarianceDiagInfo::default(),
-                generalized_ct,
-                source_ct,
-            )?;
+                relation.register_predicates([ty::PredicateKind::AliasRelate(lhs, rhs, direction)]);
+            } else {
+                let Some(source_alias) = source_term.to_alias_term() else {
+                    bug!("generalized `{source_term:?} to infer, not an alias");
+                };
+                match source_alias.kind(self.tcx) {
+                    ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
+                        // FIXME: This does not handle subtyping correctly, we could
+                        // instead create a new inference variable `?normalized_source`, emitting
+                        // `Projection(normalized_source, ?ty_normalized)` and
+                        // `?normalized_source <: generalized_term`.
+                        relation.register_predicates([ty::ProjectionPredicate {
+                            projection_term: source_alias,
+                            term: generalized_term,
+                        }]);
+                    }
+                    // The old solver only accepts projection predicates for associated types.
+                    ty::AliasTermKind::InherentTy
+                    | ty::AliasTermKind::FreeTy
+                    | ty::AliasTermKind::OpaqueTy => {
+                        return Err(TypeError::CyclicTy(source_term.expect_type()));
+                    }
+                    ty::AliasTermKind::InherentConst
+                    | ty::AliasTermKind::FreeConst
+                    | ty::AliasTermKind::UnevaluatedConst => {
+                        return Err(TypeError::CyclicConst(source_term.expect_const()));
+                    }
+                }
+            }
         } else {
-            relation.relate_with_variance(
-                ty::Invariant,
-                ty::VarianceDiagInfo::default(),
-                source_ct,
-                generalized_ct,
-            )?;
+            // NOTE: The `instantiation_variance` is not the same variance as
+            // used by the relation. When instantiating `b`, `target_is_expected`
+            // is flipped and the `instantiation_variance` is also flipped. To
+            // constrain the `generalized_term` while using the original relation,
+            // we therefore only have to flip the arguments.
+            //
+            // ```ignore (not code)
+            // ?a rel B
+            // instantiate_ty_var(?a, B) # expected and variance not flipped
+            // B' rel B
+            // ```
+            // or
+            // ```ignore (not code)
+            // A rel ?b
+            // instantiate_ty_var(?b, A) # expected and variance flipped
+            // A rel A'
+            // ```
+            match generalized_term.kind() {
+                ty::TermKind::Ty(_) => {
+                    if target_is_expected {
+                        relation.relate(generalized_term, source_term)?;
+                    } else {
+                        debug!("flip relation");
+                        relation.relate(source_term, generalized_term)?;
+                    }
+                }
+                ty::TermKind::Const(_) => {
+                    // Override consts to always be invariant
+                    if target_is_expected {
+                        relation.relate_with_variance(
+                            ty::Invariant,
+                            ty::VarianceDiagInfo::default(),
+                            generalized_term,
+                            source_term,
+                        )?;
+                    } else {
+                        relation.relate_with_variance(
+                            ty::Invariant,
+                            ty::VarianceDiagInfo::default(),
+                            source_term,
+                            generalized_term,
+                        )?;
+                    }
+                }
+            }
         }
 
         Ok(())
     }
 
+    /// This is a thin wrapper around inserting into the var tables. You probably want
+    /// [`Self::instantiate_var`] instead, which calls this method.
+    fn union_var_term(&self, l: TermVid, r: ty::Term<'tcx>) {
+        match (l, r.kind()) {
+            (TermVid::Ty(l), ty::TermKind::Ty(r)) => {
+                if let Some(r) = r.ty_vid() {
+                    self.inner.borrow_mut().type_variables().equate(l, r)
+                } else {
+                    self.inner.borrow_mut().type_variables().instantiate(l, r)
+                }
+            }
+            (TermVid::Const(l), ty::TermKind::Const(r)) => {
+                if let Some(r) = r.ct_vid() {
+                    self.inner.borrow_mut().const_unification_table().union(l, r)
+                } else {
+                    self.inner
+                        .borrow_mut()
+                        .const_unification_table()
+                        .union_value(l, ConstVariableValue::Known { value: r })
+                }
+            }
+            _ => bug!("mismatched term kinds in generalize: {l:?}, {r:?}"),
+        }
+    }
+
     /// Attempts to generalize `source_term` for the type variable `target_vid`.
     /// This checks for cycles -- that is, whether `source_term` references `target_vid`.
-    fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
+    fn generalize(
         &self,
         span: Span,
         structurally_relate_aliases: StructurallyRelateAliases,
-        target_vid: impl Into<TermVid>,
+        target_vid: TermVid,
         ambient_variance: ty::Variance,
-        source_term: T,
-    ) -> RelateResult<'tcx, Generalization<T>> {
+        source_term: Term<'tcx>,
+    ) -> RelateResult<'tcx, Generalization<Term<'tcx>>> {
         assert!(!source_term.has_escaping_bound_vars());
-        let (for_universe, root_vid) = match target_vid.into() {
+        let (for_universe, root_vid) = match target_vid {
             TermVid::Ty(ty_vid) => {
                 (self.probe_ty_var(ty_vid).unwrap_err(), TermVid::Ty(self.root_var(ty_vid)))
             }
@@ -267,7 +314,7 @@ fn generalize<T: Into<Term<'tcx>> + Relate<TyCtxt<'tcx>>>(
             structurally_relate_aliases,
             root_vid,
             for_universe,
-            root_term: source_term.into(),
+            root_term: source_term,
             ambient_variance,
             in_alias: false,
             cache: Default::default(),
@@ -377,8 +424,12 @@ fn cyclic_term_error(&self) -> TypeError<'tcx> {
 
     /// Create a new type variable in the universe of the target when
     /// generalizing an alias.
-    fn next_ty_var_for_alias(&self) -> Ty<'tcx> {
-        self.infcx.next_ty_var_in_universe(self.span, self.for_universe)
+    fn next_var_for_alias_of_kind(&self, alias: ty::AliasTerm<'tcx>) -> ty::Term<'tcx> {
+        if alias.kind(self.cx()).is_type() {
+            self.infcx.next_ty_var_in_universe(self.span, self.for_universe).into()
+        } else {
+            self.infcx.next_const_var_in_universe(self.span, self.for_universe).into()
+        }
     }
 
     /// An occurs check failure inside of an alias does not mean
@@ -399,10 +450,10 @@ fn next_ty_var_for_alias(&self) -> Ty<'tcx> {
     ///   continue generalizing the alias. This ends up pulling down the universe of the
     ///   inference variable and is incomplete in case the alias would normalize to a type
     ///   which does not mention that inference variable.
-    fn generalize_alias_ty(
+    fn generalize_alias_term(
         &mut self,
-        alias: ty::AliasTy<'tcx>,
-    ) -> Result<Ty<'tcx>, TypeError<'tcx>> {
+        alias: ty::AliasTerm<'tcx>,
+    ) -> Result<Term<'tcx>, TypeError<'tcx>> {
         // We do not eagerly replace aliases with inference variables if they have
         // escaping bound vars, see the method comment for details. However, when we
         // are inside of an alias with escaping bound vars replacing nested aliases
@@ -410,12 +461,12 @@ fn generalize_alias_ty(
         //
         // cc trait-system-refactor-initiative#110
         if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
-            return Ok(self.next_ty_var_for_alias());
+            return Ok(self.next_var_for_alias_of_kind(alias));
         }
 
         let is_nested_alias = mem::replace(&mut self.in_alias, true);
         let result = match self.relate(alias, alias) {
-            Ok(alias) => Ok(alias.to_ty(self.cx())),
+            Ok(alias) => Ok(alias.to_term(self.cx())),
             Err(e) => {
                 if is_nested_alias {
                     return Err(e);
@@ -430,7 +481,7 @@ fn generalize_alias_ty(
                     }
 
                     debug!("generalization failure in alias");
-                    Ok(self.next_ty_var_for_alias())
+                    Ok(self.next_var_for_alias_of_kind(alias))
                 }
             }
         };
@@ -585,7 +636,9 @@ fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
             }
 
             ty::Alias(_, data) => match self.structurally_relate_aliases {
-                StructurallyRelateAliases::No => self.generalize_alias_ty(data),
+                StructurallyRelateAliases::No => {
+                    self.generalize_alias_term(data.into()).map(|v| v.expect_type())
+                }
                 StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
             },
 
@@ -695,17 +748,26 @@ fn consts(
             // FIXME: Unevaluated constants are also not rigid, so the current
             // approach of always relating them structurally is incomplete.
             //
-            // FIXME: remove this branch once `structurally_relate_consts` is fully
-            // structural.
-            ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, args }) => {
-                let args = self.relate_with_variance(
-                    ty::Invariant,
-                    ty::VarianceDiagInfo::default(),
-                    args,
-                    args,
-                )?;
-                Ok(ty::Const::new_unevaluated(self.cx(), ty::UnevaluatedConst { def, args }))
-            }
+            // FIXME: replace the StructurallyRelateAliases::Yes branch with
+            // `structurally_relate_consts` once it is fully structural.
+            ty::ConstKind::Unevaluated(uv) => match self.structurally_relate_aliases {
+                // Hack: Fall back to old behavior if GCE is enabled (it used to just be the Yes
+                // path), as doing this new No path breaks some GCE things. I expect GCE to be
+                // ripped out soon so this shouldn't matter soon.
+                StructurallyRelateAliases::No if !self.cx().features().generic_const_exprs() => {
+                    self.generalize_alias_term(uv.into()).map(|v| v.expect_const())
+                }
+                _ => {
+                    let ty::UnevaluatedConst { def, args } = uv;
+                    let args = self.relate_with_variance(
+                        ty::Invariant,
+                        ty::VarianceDiagInfo::default(),
+                        args,
+                        args,
+                    )?;
+                    Ok(ty::Const::new_unevaluated(self.cx(), ty::UnevaluatedConst { def, args }))
+                }
+            },
             ty::ConstKind::Placeholder(placeholder) => {
                 if self.for_universe.can_name(placeholder.universe) {
                     Ok(c)
diff --git a/compiler/rustc_infer/src/infer/unify_key.rs b/compiler/rustc_infer/src/infer/unify_key.rs
index 5e5d0e063a0d..4016054d8974 100644
--- a/compiler/rustc_infer/src/infer/unify_key.rs
+++ b/compiler/rustc_infer/src/infer/unify_key.rs
@@ -110,6 +110,13 @@ pub(crate) fn known(&self) -> Option<ty::Const<'tcx>> {
             ConstVariableValue::Known { value } => Some(value),
         }
     }
+
+    pub(crate) fn is_unknown(&self) -> bool {
+        match *self {
+            ConstVariableValue::Unknown { .. } => true,
+            ConstVariableValue::Known { .. } => false,
+        }
+    }
 }
 
 #[derive(PartialEq, Copy, Clone, Debug)]
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index aade274bfc98..d342e4ba5efa 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -323,6 +323,13 @@ pub fn is_ct_infer(self) -> bool {
         matches!(self.kind(), ty::ConstKind::Infer(_))
     }
 
+    pub fn ct_vid(self) -> Option<ty::ConstVid> {
+        match self.kind() {
+            ConstKind::Infer(ty::InferConst::Var(vid)) => Some(vid),
+            _ => None,
+        }
+    }
+
     /// Iterator that walks `self` and any types reachable from
     /// `self`, in depth-first order. Note that just walks the types
     /// that appear in `self`, it does not descend into the fields of
diff --git a/tests/ui/coherence/occurs-check/associated-type.next.stderr b/tests/ui/coherence/occurs-check/associated-type.next.stderr
index 52794b19945b..381f5c60f983 100644
--- a/tests/ui/coherence/occurs-check/associated-type.next.stderr
+++ b/tests/ui/coherence/occurs-check/associated-type.next.stderr
@@ -1,5 +1,5 @@
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
 error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), ())>` for type `for<'a> fn(&'a (), ())`
   --> $DIR/associated-type.rs:32:1
    |
diff --git a/tests/ui/coherence/occurs-check/associated-type.old.stderr b/tests/ui/coherence/occurs-check/associated-type.old.stderr
index 9fa443eefb3d..40811a67dd18 100644
--- a/tests/ui/coherence/occurs-check/associated-type.old.stderr
+++ b/tests/ui/coherence/occurs-check/associated-type.old.stderr
@@ -1,5 +1,5 @@
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1))], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
 error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), ())>` for type `for<'a> fn(&'a (), ())`
   --> $DIR/associated-type.rs:32:1
    |
diff --git a/tests/ui/const-generics/mgca/free-const-recursive.rs b/tests/ui/const-generics/mgca/free-const-recursive.rs
new file mode 100644
index 000000000000..8d75c1a941a7
--- /dev/null
+++ b/tests/ui/const-generics/mgca/free-const-recursive.rs
@@ -0,0 +1,13 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/153831>
+//@ check-fail
+//@compile-flags: -Znext-solver=globally --emit=obj
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+type const A: () = A;
+//~^ ERROR type mismatch resolving `A normalizes-to _`
+//~| ERROR the constant `A` is not of type `()`
+
+fn main() {
+    A;
+}
diff --git a/tests/ui/const-generics/mgca/free-const-recursive.stderr b/tests/ui/const-generics/mgca/free-const-recursive.stderr
new file mode 100644
index 000000000000..d0f10275b40d
--- /dev/null
+++ b/tests/ui/const-generics/mgca/free-const-recursive.stderr
@@ -0,0 +1,15 @@
+error[E0271]: type mismatch resolving `A normalizes-to _`
+  --> $DIR/free-const-recursive.rs:7:1
+   |
+LL | type const A: () = A;
+   | ^^^^^^^^^^^^^^^^ types differ
+
+error: the constant `A` is not of type `()`
+  --> $DIR/free-const-recursive.rs:7:1
+   |
+LL | type const A: () = A;
+   | ^^^^^^^^^^^^^^^^ expected `()`, found a different `()`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/const-generics/mgca/projection-const-recursive.rs b/tests/ui/const-generics/mgca/projection-const-recursive.rs
new file mode 100644
index 000000000000..c9b5039b5fd0
--- /dev/null
+++ b/tests/ui/const-generics/mgca/projection-const-recursive.rs
@@ -0,0 +1,19 @@
+//! See also <https://github.com/rust-lang/rust/issues/153831>
+//@ check-fail
+//@compile-flags: -Znext-solver=globally --emit=obj
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    type const A: ();
+}
+
+impl Trait for () {
+    type const A: () = <() as Trait>::A;
+    //~^ ERROR type mismatch resolving `<() as Trait>::A normalizes-to _`
+    //~| ERROR the constant `<() as Trait>::A` is not of type `()`
+}
+
+fn main() {
+    <() as Trait>::A;
+}
diff --git a/tests/ui/const-generics/mgca/projection-const-recursive.stderr b/tests/ui/const-generics/mgca/projection-const-recursive.stderr
new file mode 100644
index 000000000000..d9c60102c318
--- /dev/null
+++ b/tests/ui/const-generics/mgca/projection-const-recursive.stderr
@@ -0,0 +1,15 @@
+error[E0271]: type mismatch resolving `<() as Trait>::A normalizes-to _`
+  --> $DIR/projection-const-recursive.rs:12:5
+   |
+LL |     type const A: () = <() as Trait>::A;
+   |     ^^^^^^^^^^^^^^^^ types differ
+
+error: the constant `<() as Trait>::A` is not of type `()`
+  --> $DIR/projection-const-recursive.rs:12:5
+   |
+LL |     type const A: () = <() as Trait>::A;
+   |     ^^^^^^^^^^^^^^^^ expected `()`, found a different `()`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/const-generics/ogca/coherence-ambiguous.rs b/tests/ui/const-generics/ogca/coherence-ambiguous.rs
index 21efe4cfe981..bb20c0457c03 100644
--- a/tests/ui/const-generics/ogca/coherence-ambiguous.rs
+++ b/tests/ui/const-generics/ogca/coherence-ambiguous.rs
@@ -1,5 +1,4 @@
-// FIXME(ogca): this should ERROR not pass!!
-//@ check-pass
+//@ check-fail
 
 #![feature(generic_const_items, min_generic_const_args, opaque_generic_const_args)]
 #![expect(incomplete_features)]
@@ -12,8 +11,8 @@ trait Trait {}
 
 impl Trait for [(); FOO::<1>] {}
 impl Trait for [(); BAR::<1>] {}
-// FIXME(ogca): this should ERROR!
+//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
 impl Trait for [(); BAR::<2>] {}
-// FIXME(ogca): this should ERROR!
+//~^ ERROR conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
 
 fn main() {}
diff --git a/tests/ui/const-generics/ogca/coherence-ambiguous.stderr b/tests/ui/const-generics/ogca/coherence-ambiguous.stderr
new file mode 100644
index 000000000000..919a0c8d70e9
--- /dev/null
+++ b/tests/ui/const-generics/ogca/coherence-ambiguous.stderr
@@ -0,0 +1,20 @@
+error[E0119]: conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+  --> $DIR/coherence-ambiguous.rs:13:1
+   |
+LL | impl Trait for [(); FOO::<1>] {}
+   | ----------------------------- first implementation here
+LL | impl Trait for [(); BAR::<1>] {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); FOO::<1>]`
+
+error[E0119]: conflicting implementations of trait `Trait` for type `[(); FOO::<1>]`
+  --> $DIR/coherence-ambiguous.rs:15:1
+   |
+LL | impl Trait for [(); FOO::<1>] {}
+   | ----------------------------- first implementation here
+...
+LL | impl Trait for [(); BAR::<2>] {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); FOO::<1>]`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/higher-ranked/structually-relate-aliases.stderr b/tests/ui/higher-ranked/structually-relate-aliases.stderr
index b27a2dcceb13..f8fcb73db447 100644
--- a/tests/ui/higher-ranked/structually-relate-aliases.stderr
+++ b/tests/ui/higher-ranked/structually-relate-aliases.stderr
@@ -1,4 +1,4 @@
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [?1t, '^0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a))], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: [?1t, '^0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a))], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit), .. }
 error[E0277]: the trait bound `for<'a> T: ToUnit<'a>` is not satisfied
   --> $DIR/structually-relate-aliases.rs:13:36
    |
diff --git a/tests/ui/traits/next-solver/issue-118950-root-region.stderr b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
index 5516f1e36089..a4c8d259406b 100644
--- a/tests/ui/traits/next-solver/issue-118950-root-region.stderr
+++ b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
@@ -16,7 +16,7 @@ help: this trait has no implementations, consider adding one
 LL | trait ToUnit<'a> {
    | ^^^^^^^^^^^^^^^^
 
- WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a)), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
+ WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTerm { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a)), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
 error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0277, E0425.

From d29c4895994dae92c6e8e47aec08fd4c81fb5d54 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Mon, 9 Mar 2026 01:41:56 +0900
Subject: [PATCH 1056/1059] add self-referential param-env normalization
 regression

avoid ICE on invalid param-env normalization

remove 120033 crash test

fix comments

use rustc_no_implicit_bounds

set #![allow(incomplete_features)]
---
 .../rustc_trait_selection/src/traits/mod.rs   | 19 +++-----
 tests/crashes/120033.rs                       | 16 -------
 ...zed-param-env-unconstrained-type-120033.rs | 22 ++++++++++
 ...param-env-unconstrained-type-120033.stderr | 43 +++++++++++++++++++
 ...elf-referential-param-env-normalization.rs | 18 ++++++++
 ...referential-param-env-normalization.stderr | 42 ++++++++++++++++++
 6 files changed, 132 insertions(+), 28 deletions(-)
 delete mode 100644 tests/crashes/120033.rs
 create mode 100644 tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.rs
 create mode 100644 tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.stderr
 create mode 100644 tests/ui/traits/self-referential-param-env-normalization.rs
 create mode 100644 tests/ui/traits/self-referential-param-env-normalization.stderr

diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index 1fde7e5d43b7..bdad1b259b73 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -300,19 +300,14 @@ fn do_normalize_predicates<'tcx>(
         Ok(predicates) => Ok(predicates),
         Err(fixup_err) => {
             // If we encounter a fixup error, it means that some type
-            // variable wound up unconstrained. I actually don't know
-            // if this can happen, and I certainly don't expect it to
-            // happen often, but if it did happen it probably
-            // represents a legitimate failure due to some kind of
-            // unconstrained variable.
-            //
-            // @lcnr: Let's still ICE here for now. I want a test case
-            // for that.
-            span_bug!(
+            // variable wound up unconstrained. That can happen for
+            // ill-formed impls, so we delay a bug here instead of
+            // immediately ICEing and let type checking report the
+            // actual user-facing errors.
+            Err(tcx.dcx().span_delayed_bug(
                 span,
-                "inference variables in normalized parameter environment: {}",
-                fixup_err
-            );
+                format!("inference variables in normalized parameter environment: {fixup_err}"),
+            ))
         }
     }
 }
diff --git a/tests/crashes/120033.rs b/tests/crashes/120033.rs
deleted file mode 100644
index 7584f98ec906..000000000000
--- a/tests/crashes/120033.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ known-bug: #120033
-#![feature(non_lifetime_binders)]
-#![allow(sized_hierarchy_migration)]
-#![feature(sized_hierarchy)] // added to keep parameters unconstrained
-
-pub trait Foo<T: std::marker::PointeeSized> {
-    type Bar<K: std::marker::PointeeSized>;
-}
-
-pub struct Bar<T: ?AutoTrait> {}
-
-pub fn f<T1, T2>()
-where
-    T1: for<T> Foo<usize, Bar = Bar<T>>,
-    T2: for<L, T> Foo<usize, Bar<T> = T1::Bar<T>>,
-{}
diff --git a/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.rs b/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.rs
new file mode 100644
index 000000000000..52f83966c6bd
--- /dev/null
+++ b/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: --crate-type=lib
+
+// Regression test for <https://github.com/rust-lang/rust/issues/120033>
+
+#![feature(rustc_attrs)]
+#![feature(non_lifetime_binders)]
+#![allow(incomplete_features)]
+#![rustc_no_implicit_bounds]
+
+pub trait Foo<T> {
+    type Bar<K>;
+}
+
+pub struct Bar<T: ?AutoTrait> {} //~ ERROR cannot find trait `AutoTrait`
+
+pub fn f<T1, T2>()
+where
+    T1: for<T> Foo<usize, Bar = Bar<T>>, //~ ERROR missing generics for associated type `Foo::Bar`
+    //~| ERROR missing generics for associated type `Foo::Bar`
+    T2: for<L, T> Foo<usize, Bar<T> = T1::Bar<T>>,
+{
+}
diff --git a/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.stderr b/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.stderr
new file mode 100644
index 000000000000..c95e6c68fc6a
--- /dev/null
+++ b/tests/ui/traits/non_lifetime_binders/normalized-param-env-unconstrained-type-120033.stderr
@@ -0,0 +1,43 @@
+error[E0405]: cannot find trait `AutoTrait` in this scope
+  --> $DIR/normalized-param-env-unconstrained-type-120033.rs:14:20
+   |
+LL | pub struct Bar<T: ?AutoTrait> {}
+   |                    ^^^^^^^^^ not found in this scope
+
+error[E0107]: missing generics for associated type `Foo::Bar`
+  --> $DIR/normalized-param-env-unconstrained-type-120033.rs:18:27
+   |
+LL |     T1: for<T> Foo<usize, Bar = Bar<T>>,
+   |                           ^^^ expected 1 generic argument
+   |
+note: associated type defined here, with 1 generic parameter: `K`
+  --> $DIR/normalized-param-env-unconstrained-type-120033.rs:11:10
+   |
+LL |     type Bar<K>;
+   |          ^^^ -
+help: add missing generic argument
+   |
+LL |     T1: for<T> Foo<usize, Bar<K> = Bar<T>>,
+   |                              +++
+
+error[E0107]: missing generics for associated type `Foo::Bar`
+  --> $DIR/normalized-param-env-unconstrained-type-120033.rs:18:27
+   |
+LL |     T1: for<T> Foo<usize, Bar = Bar<T>>,
+   |                           ^^^ expected 1 generic argument
+   |
+note: associated type defined here, with 1 generic parameter: `K`
+  --> $DIR/normalized-param-env-unconstrained-type-120033.rs:11:10
+   |
+LL |     type Bar<K>;
+   |          ^^^ -
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: add missing generic argument
+   |
+LL |     T1: for<T> Foo<usize, Bar<K> = Bar<T>>,
+   |                              +++
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0107, E0405.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/traits/self-referential-param-env-normalization.rs b/tests/ui/traits/self-referential-param-env-normalization.rs
new file mode 100644
index 000000000000..a40c8cc26bd9
--- /dev/null
+++ b/tests/ui/traits/self-referential-param-env-normalization.rs
@@ -0,0 +1,18 @@
+//~ ERROR overflow evaluating the requirement `Self: StreamingIterator<'_>` [E0275]
+// Regression test for <https://github.com/rust-lang/rust/issues/153354>.
+
+trait StreamingIterator<'a> {
+    type Item: 'a;
+}
+
+impl<'b, I, T> StreamingIterator<'b> for I
+//~^ ERROR the type parameter `T` is not constrained by the impl trait, self type, or predicates [E0207]
+where
+    I: IntoIterator,
+    T: FnMut(Self::Item, I::Item),
+{
+    type Item = T;
+    //~^ ERROR overflow evaluating the requirement `I: IntoIterator` [E0275]
+}
+
+fn main() {}
diff --git a/tests/ui/traits/self-referential-param-env-normalization.stderr b/tests/ui/traits/self-referential-param-env-normalization.stderr
new file mode 100644
index 000000000000..5e9c2c92eaac
--- /dev/null
+++ b/tests/ui/traits/self-referential-param-env-normalization.stderr
@@ -0,0 +1,42 @@
+error[E0275]: overflow evaluating the requirement `Self: StreamingIterator<'_>`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`self_referential_param_env_normalization`)
+note: required for `Self` to implement `StreamingIterator<'_>`
+  --> $DIR/self-referential-param-env-normalization.rs:8:16
+   |
+LL | impl<'b, I, T> StreamingIterator<'b> for I
+   |                ^^^^^^^^^^^^^^^^^^^^^     ^
+...
+LL |     T: FnMut(Self::Item, I::Item),
+   |        -------------------------- unsatisfied trait bound introduced here
+   = note: 127 redundant requirements hidden
+   = note: required for `Self` to implement `StreamingIterator<'a>`
+
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/self-referential-param-env-normalization.rs:8:13
+   |
+LL | impl<'b, I, T> StreamingIterator<'b> for I
+   |             ^ unconstrained type parameter
+
+error[E0275]: overflow evaluating the requirement `I: IntoIterator`
+  --> $DIR/self-referential-param-env-normalization.rs:14:17
+   |
+LL |     type Item = T;
+   |                 ^
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`self_referential_param_env_normalization`)
+note: required for `I` to implement `StreamingIterator<'_>`
+  --> $DIR/self-referential-param-env-normalization.rs:8:16
+   |
+LL | impl<'b, I, T> StreamingIterator<'b> for I
+   |                ^^^^^^^^^^^^^^^^^^^^^     ^
+...
+LL |     T: FnMut(Self::Item, I::Item),
+   |        -------------------------- unsatisfied trait bound introduced here
+   = note: 127 redundant requirements hidden
+   = note: required for `I` to implement `StreamingIterator<'b>`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0207, E0275.
+For more information about an error, try `rustc --explain E0207`.

From 6518de37d450f35e18fc49502ea6183fda065714 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Mon, 30 Mar 2026 21:55:05 +0800
Subject: [PATCH 1057/1059] Skip suggestions pointing to extern macro def for
 assert_eq

---
 .../src/error_reporting/traits/suggestions.rs | 34 +++++++++---
 .../assert-ne-no-invalid-help-issue-146204.rs | 23 ++++++++
 ...ert-ne-no-invalid-help-issue-146204.stderr | 55 +++++++++++++++++++
 3 files changed, 104 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/macros/assert-ne-no-invalid-help-issue-146204.rs
 create mode 100644 tests/ui/macros/assert-ne-no-invalid-help-issue-146204.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index a16bbf20238c..151008790daf 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -545,8 +545,12 @@ pub(super) fn suggest_dereferences(
                         .all(|obligation| self.predicate_may_hold(obligation))
             }) && steps > 0
             {
+                if span.in_external_macro(self.tcx.sess.source_map()) {
+                    return false;
+                }
                 let derefs = "*".repeat(steps);
                 let msg = "consider dereferencing here";
+
                 let call_node = self.tcx.hir_node(*call_hir_id);
                 let is_receiver = matches!(
                     call_node,
@@ -593,7 +597,6 @@ pub(super) fn suggest_dereferences(
                 })
         {
             // Suggest dereferencing the LHS, RHS, or both terms of a binop if possible
-
             let trait_pred = predicate.unwrap_or(trait_pred);
             let lhs_ty = self.tcx.instantiate_bound_regions_with_erased(trait_pred.self_ty());
             let lhs_autoderef = (self.autoderef_steps)(lhs_ty);
@@ -644,6 +647,9 @@ pub(super) fn suggest_dereferences(
                 })
             {
                 let make_sugg = |mut expr: &Expr<'_>, mut steps| {
+                    if expr.span.in_external_macro(self.tcx.sess.source_map()) {
+                        return None;
+                    }
                     let mut prefix_span = expr.span.shrink_to_lo();
                     let mut msg = "consider dereferencing here";
                     if let hir::ExprKind::AddrOf(_, _, inner) = expr.kind {
@@ -661,10 +667,10 @@ pub(super) fn suggest_dereferences(
                     }
                     // Empty suggestions with empty spans ICE with debug assertions
                     if steps == 0 {
-                        return (
+                        return Some((
                             msg.trim_end_matches(" and dereferencing instead"),
                             vec![(prefix_span, String::new())],
-                        );
+                        ));
                     }
                     let derefs = "*".repeat(steps);
                     let needs_parens = steps > 0 && expr_needs_parens(expr);
@@ -686,7 +692,7 @@ pub(super) fn suggest_dereferences(
                     if !prefix_span.is_empty() {
                         suggestion.push((prefix_span, String::new()));
                     }
-                    (msg, suggestion)
+                    Some((msg, suggestion))
                 };
 
                 if let Some(lsteps) = lsteps
@@ -694,8 +700,13 @@ pub(super) fn suggest_dereferences(
                     && lsteps > 0
                     && rsteps > 0
                 {
-                    let mut suggestion = make_sugg(lhs, lsteps).1;
-                    suggestion.append(&mut make_sugg(rhs, rsteps).1);
+                    let Some((_, mut suggestion)) = make_sugg(lhs, lsteps) else {
+                        return false;
+                    };
+                    let Some((_, mut rhs_suggestion)) = make_sugg(rhs, rsteps) else {
+                        return false;
+                    };
+                    suggestion.append(&mut rhs_suggestion);
                     err.multipart_suggestion(
                         "consider dereferencing both sides of the expression",
                         suggestion,
@@ -705,13 +716,17 @@ pub(super) fn suggest_dereferences(
                 } else if let Some(lsteps) = lsteps
                     && lsteps > 0
                 {
-                    let (msg, suggestion) = make_sugg(lhs, lsteps);
+                    let Some((msg, suggestion)) = make_sugg(lhs, lsteps) else {
+                        return false;
+                    };
                     err.multipart_suggestion(msg, suggestion, Applicability::MachineApplicable);
                     return true;
                 } else if let Some(rsteps) = rsteps
                     && rsteps > 0
                 {
-                    let (msg, suggestion) = make_sugg(rhs, rsteps);
+                    let Some((msg, suggestion)) = make_sugg(rhs, rsteps) else {
+                        return false;
+                    };
                     err.multipart_suggestion(msg, suggestion, Applicability::MachineApplicable);
                     return true;
                 }
@@ -4815,6 +4830,9 @@ pub(super) fn suggest_convert_to_slice(
         candidate_impls: &[ImplCandidate<'tcx>],
         span: Span,
     ) {
+        if span.in_external_macro(self.tcx.sess.source_map()) {
+            return;
+        }
         // We can only suggest the slice coercion for function and binary operation arguments,
         // since the suggestion would make no sense in turbofish or call
         let (ObligationCauseCode::BinOp { .. } | ObligationCauseCode::FunctionArg { .. }) =
diff --git a/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.rs b/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.rs
new file mode 100644
index 000000000000..5a6ef0421e2f
--- /dev/null
+++ b/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.rs
@@ -0,0 +1,23 @@
+macro_rules! local_assert_ne {
+    ($left:expr, $right:expr $(,)?) => {
+        match (&$left, &$right) {
+            (left_val, right_val) => {
+                if *left_val == *right_val {
+                    //~^ ERROR can't compare `[u8; 4]` with `&[u8; 4]`
+                    panic!();
+                }
+            }
+        }
+    };
+}
+
+fn main() {
+    let buf = [0_u8; 4];
+    assert_ne!(buf, b"----");
+    //~^ ERROR can't compare `[u8; 4]` with `&[u8; 4]`
+
+    assert_eq!(buf, b"----");
+    //~^ ERROR can't compare `[u8; 4]` with `&[u8; 4]`
+
+    local_assert_ne!(buf, b"----");
+}
diff --git a/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.stderr b/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.stderr
new file mode 100644
index 000000000000..359deee7bee4
--- /dev/null
+++ b/tests/ui/macros/assert-ne-no-invalid-help-issue-146204.stderr
@@ -0,0 +1,55 @@
+error[E0277]: can't compare `[u8; 4]` with `&[u8; 4]`
+  --> $DIR/assert-ne-no-invalid-help-issue-146204.rs:16:5
+   |
+LL |     assert_ne!(buf, b"----");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `[u8; 4] == &[u8; 4]`
+   |
+   = help: the trait `PartialEq<&[u8; 4]>` is not implemented for `[u8; 4]`
+   = help: the following other types implement trait `PartialEq<Rhs>`:
+             `&[T]` implements `PartialEq<Vec<U, A>>`
+             `&[T]` implements `PartialEq<[U; N]>`
+             `&[u8; N]` implements `PartialEq<ByteStr>`
+             `&[u8; N]` implements `PartialEq<ByteString>`
+             `&[u8]` implements `PartialEq<ByteStr>`
+             `&[u8]` implements `PartialEq<ByteString>`
+             `&mut [T]` implements `PartialEq<Vec<U, A>>`
+             `&mut [T]` implements `PartialEq<[U; N]>`
+           and 11 others
+
+error[E0277]: can't compare `[u8; 4]` with `&[u8; 4]`
+  --> $DIR/assert-ne-no-invalid-help-issue-146204.rs:19:5
+   |
+LL |     assert_eq!(buf, b"----");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `[u8; 4] == &[u8; 4]`
+   |
+   = help: the trait `PartialEq<&[u8; 4]>` is not implemented for `[u8; 4]`
+   = help: the following other types implement trait `PartialEq<Rhs>`:
+             `&[T]` implements `PartialEq<Vec<U, A>>`
+             `&[T]` implements `PartialEq<[U; N]>`
+             `&[u8; N]` implements `PartialEq<ByteStr>`
+             `&[u8; N]` implements `PartialEq<ByteString>`
+             `&[u8]` implements `PartialEq<ByteStr>`
+             `&[u8]` implements `PartialEq<ByteString>`
+             `&mut [T]` implements `PartialEq<Vec<U, A>>`
+             `&mut [T]` implements `PartialEq<[U; N]>`
+           and 11 others
+
+error[E0277]: can't compare `[u8; 4]` with `&[u8; 4]`
+  --> $DIR/assert-ne-no-invalid-help-issue-146204.rs:5:30
+   |
+LL |                 if *left_val == *right_val {
+   |                              ^^ no implementation for `[u8; 4] == &[u8; 4]`
+...
+LL |     local_assert_ne!(buf, b"----");
+   |     ------------------------------ in this macro invocation
+   |
+   = help: the trait `PartialEq<&[u8; 4]>` is not implemented for `[u8; 4]`
+   = note: this error originates in the macro `local_assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider dereferencing here
+   |
+LL |                 if *left_val == **right_val {
+   |                                 +
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

From c575b7fe62589f347e6456f2afccba61f315e13b Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 27 Mar 2026 16:48:18 -0400
Subject: [PATCH 1058/1059] Update cargo submodule

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index e84cb639edfe..888f675344eb 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit e84cb639edfea2c42efd563b72a9be0cc5de6523
+Subproject commit 888f675344eb1cf2308fd53183e667bdd2c58e51

From 59fe28d0ff4e6fa757d2ad31149252ddaff0d1df Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 18 Jun 2025 06:25:32 +0000
Subject: [PATCH 1059/1059] compiler-builtins: Clean up features

Remove the `compiler-builtins` feature from default because it prevents
testing via the default `cargo test` command. It made more sense as a
default when `compiler-builtins` was a dependency that some crates added
via crates.io, but is no longer needed.

The `rustc-dep-of-std` feature is also removed since it doesn't do
anything beyond what the `compiler-builtins` feature already does.
---
 library/alloc/Cargo.toml                               |  2 +-
 library/compiler-builtins/builtins-shim/Cargo.toml     |  8 +++-----
 library/compiler-builtins/compiler-builtins/Cargo.toml | 10 ++++------
 3 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 541257b6cda6..b32e5e991cc7 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -16,7 +16,7 @@ bench = false
 
 [dependencies]
 core = { path = "../core", public = true }
-compiler_builtins = { path = "../compiler-builtins/compiler-builtins", features = ["rustc-dep-of-std"] }
+compiler_builtins = { path = "../compiler-builtins/compiler-builtins", features = ["compiler-builtins"] }
 
 [features]
 compiler-builtins-mem = ['compiler_builtins/mem']
diff --git a/library/compiler-builtins/builtins-shim/Cargo.toml b/library/compiler-builtins/builtins-shim/Cargo.toml
index 37d3407e9f66..32b0308a7b3c 100644
--- a/library/compiler-builtins/builtins-shim/Cargo.toml
+++ b/library/compiler-builtins/builtins-shim/Cargo.toml
@@ -39,7 +39,7 @@ test = false
 cc = { version = "1.2", optional = true }
 
 [features]
-default = ["compiler-builtins"]
+default = []
 
 # Enable compilation of C code in compiler-rt, filling in some more optimized
 # implementations and also filling in unimplemented intrinsics
@@ -50,7 +50,8 @@ c = ["dep:cc"]
 # the generic versions on all platforms.
 no-asm = []
 
-# Flag this library as the unstable compiler-builtins lib
+# Flag this library as the unstable compiler-builtins lib. This must be enabled
+# when using as `std`'s dependency.'
 compiler-builtins = []
 
 # Generate memory-related intrinsics like memcpy
@@ -60,9 +61,6 @@ mem = []
 # compiler-rt implementations. Also used for testing
 mangled-names = []
 
-# Only used in the compiler's build system
-rustc-dep-of-std = ["compiler-builtins"]
-
 # This makes certain traits and function specializations public that
 # are not normally public but are required by the `builtins-test`
 unstable-public-internals = []
diff --git a/library/compiler-builtins/compiler-builtins/Cargo.toml b/library/compiler-builtins/compiler-builtins/Cargo.toml
index a8b8920421b3..d9acb8341d48 100644
--- a/library/compiler-builtins/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/compiler-builtins/Cargo.toml
@@ -34,7 +34,7 @@ core = { path = "../../core", optional = true }
 cc = { version = "1.2", optional = true }
 
 [features]
-default = ["compiler-builtins"]
+default = []
 
 # Enable compilation of C code in compiler-rt, filling in some more optimized
 # implementations and also filling in unimplemented intrinsics
@@ -45,8 +45,9 @@ c = ["dep:cc"]
 # the generic versions on all platforms.
 no-asm = []
 
-# Flag this library as the unstable compiler-builtins lib
-compiler-builtins = []
+# Flag this library as the unstable compiler-builtins lib. This must be enabled
+# when using as `std`'s dependency.'
+compiler-builtins = ["dep:core"]
 
 # Generate memory-related intrinsics like memcpy
 mem = []
@@ -55,9 +56,6 @@ mem = []
 # compiler-rt implementations. Also used for testing
 mangled-names = []
 
-# Only used in the compiler's build system
-rustc-dep-of-std = ["compiler-builtins", "dep:core"]
-
 # This makes certain traits and function specializations public that
 # are not normally public but are required by the `builtins-test`
 unstable-public-internals = []